mksnapshot.cc File Reference

#include <errno.h>
#include <stdio.h>
#include <signal.h>
#include "src/v8.h"
#include "include/libplatform/libplatform.h"
#include "src/assembler.h"
#include "src/base/platform/platform.h"
#include "src/bootstrapper.h"
#include "src/flags.h"
#include "src/list.h"
#include "src/natives.h"
#include "src/serialize.h"

Include dependency graph for mksnapshot.cc:

Go to the source code of this file.

Classes
class	Compressor
class	SnapshotWriter

Functions
void	DumpException (Handle< Message > message)
int	main (int argc, char **argv)

Function Documentation

DumpException()

void DumpException

(

Handle< Message >

message

)

Definition at line 294 of file mksnapshot.cc.

                                            {
  String::Utf8Value message_string(message->Get());
  String::Utf8Value message_line(message->GetSourceLine());
  fprintf(stderr, "%s at line %d\n", *message_string, message->GetLineNumber());
  fprintf(stderr, "%s\n", *message_line);
  for (int i = 0; i <= message->GetEndColumn(); ++i) {
    fprintf(stderr, "%c", i < message->GetStartColumn() ? ' ' : '^');
  }
  fprintf(stderr, "\n");
}

Referenced by main().

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 306 of file mksnapshot.cc.

                                {
  // By default, log code create information in the snapshot.
  i::FLAG_log_code = true;
 
  // Print the usage if an error occurs when parsing the command line
  // flags or if the help flag is set.
  int result = i::FlagList::SetFlagsFromCommandLine(&argc, argv, true);
  if (result > 0 || argc != 2 || i::FLAG_help) {
    ::printf("Usage: %s [flag] ... outfile\n", argv[0]);
    i::FlagList::PrintHelp();
    return !i::FLAG_help;
  }
 
  i::CpuFeatures::Probe(true);
  V8::InitializeICU();
  v8::Platform* platform = v8::platform::CreateDefaultPlatform();
  v8::V8::InitializePlatform(platform);
  v8::V8::Initialize();
 
#ifdef COMPRESS_STARTUP_DATA_BZ2
  BZip2Decompressor natives_decompressor;
  int bz2_result = natives_decompressor.Decompress();
  if (bz2_result != BZ_OK) {
    fprintf(stderr, "bzip error code: %d\n", bz2_result);
    exit(1);
  }
#endif
  i::FLAG_logfile_per_isolate = false;
 
  Isolate::CreateParams params;
  params.enable_serializer = true;
  Isolate* isolate = v8::Isolate::New(params);
  { Isolate::Scope isolate_scope(isolate);
    i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
 
    Persistent<Context> context;
    {
      HandleScope handle_scope(isolate);
      context.Reset(isolate, Context::New(isolate));
    }
 
    if (context.IsEmpty()) {
      fprintf(stderr,
              "\nException thrown while compiling natives - see above.\n\n");
      exit(1);
    }
    if (i::FLAG_extra_code != NULL) {
      // Capture 100 frames if anything happens.
      V8::SetCaptureStackTraceForUncaughtExceptions(true, 100);
      HandleScope scope(isolate);
      v8::Context::Scope cscope(v8::Local<v8::Context>::New(isolate, context));
      const char* name = i::FLAG_extra_code;
      FILE* file = base::OS::FOpen(name, "rb");
      if (file == NULL) {
        fprintf(stderr, "Failed to open '%s': errno %d\n", name, errno);
        exit(1);
      }
 
      fseek(file, 0, SEEK_END);
      int size = ftell(file);
      rewind(file);
 
      char* chars = new char[size + 1];
      chars[size] = '\0';
      for (int i = 0; i < size;) {
        int read = static_cast<int>(fread(&chars[i], 1, size - i, file));
        if (read < 0) {
          fprintf(stderr, "Failed to read '%s': errno %d\n", name, errno);
          exit(1);
        }
        i += read;
      }
      fclose(file);
      Local<String> source = String::NewFromUtf8(isolate, chars);
      TryCatch try_catch;
      Local<Script> script = Script::Compile(source);
      if (try_catch.HasCaught()) {
        fprintf(stderr, "Failure compiling '%s'\n", name);
        DumpException(try_catch.Message());
        exit(1);
      }
      script->Run();
      if (try_catch.HasCaught()) {
        fprintf(stderr, "Failure running '%s'\n", name);
        DumpException(try_catch.Message());
        exit(1);
      }
    }
    // Make sure all builtin scripts are cached.
    { HandleScope scope(isolate);
      for (int i = 0; i < i::Natives::GetBuiltinsCount(); i++) {
        internal_isolate->bootstrapper()->NativesSourceLookup(i);
      }
    }
    // If we don't do this then we end up with a stray root pointing at the
    // context even after we have disposed of the context.
    internal_isolate->heap()->CollectAllGarbage(
        i::Heap::kNoGCFlags, "mksnapshot");
    i::Object* raw_context = *v8::Utils::OpenPersistent(context);
    context.Reset();
 
    // This results in a somewhat smaller snapshot, probably because it gets
    // rid of some things that are cached between garbage collections.
    i::List<i::byte> snapshot_data;
    i::ListSnapshotSink snapshot_sink(&snapshot_data);
    i::StartupSerializer ser(internal_isolate, &snapshot_sink);
    ser.SerializeStrongReferences();
 
    i::List<i::byte> context_data;
    i::ListSnapshotSink contex_sink(&context_data);
    i::PartialSerializer context_ser(internal_isolate, &ser, &contex_sink);
    context_ser.Serialize(&raw_context);
    ser.SerializeWeakReferences();
 
    {
      SnapshotWriter writer(argv[1]);
      if (i::FLAG_raw_file && i::FLAG_raw_context_file)
        writer.SetRawFiles(i::FLAG_raw_file, i::FLAG_raw_context_file);
      if (i::FLAG_startup_blob)
        writer.SetStartupBlobFile(i::FLAG_startup_blob);
  #ifdef COMPRESS_STARTUP_DATA_BZ2
      BZip2Compressor bzip2;
      writer.SetCompressor(&bzip2);
  #endif
      writer.WriteSnapshot(snapshot_data, ser, context_data, context_ser);
    }
  }
 
  isolate->Dispose();
  V8::Dispose();
  V8::ShutdownPlatform();
  delete platform;
  return 0;
}

References v8::internal::Isolate::bootstrapper(), v8::internal::Heap::CollectAllGarbage(), v8::Script::Compile(), v8::platform::CreateDefaultPlatform(), v8::Isolate::Dispose(), v8::V8::Dispose(), DumpException(), v8::Isolate::CreateParams::enable_serializer, file(), v8::base::OS::FOpen(), v8::internal::NativesCollection< type >::GetBuiltinsCount(), v8::TryCatch::HasCaught(), v8::internal::Isolate::heap(), v8::V8::Initialize(), v8::V8::InitializeICU(), v8::V8::InitializePlatform(), v8::PersistentBase< T >::IsEmpty(), v8::internal::Heap::kNoGCFlags, v8::TryCatch::Message(), name, v8::Isolate::New(), v8::Context::New(), v8::String::NewFromUtf8(), NULL, v8::Utils::OpenPersistent(), v8::internal::FlagList::PrintHelp(), v8::internal::CpuFeatures::Probe(), v8::PersistentBase< T >::Reset(), v8::internal::PartialSerializer::Serialize(), v8::internal::StartupSerializer::SerializeStrongReferences(), v8::internal::StartupSerializer::SerializeWeakReferences(), v8::V8::SetCaptureStackTraceForUncaughtExceptions(), SnapshotWriter::SetCompressor(), v8::internal::FlagList::SetFlagsFromCommandLine(), SnapshotWriter::SetRawFiles(), SnapshotWriter::SetStartupBlobFile(), v8::V8::ShutdownPlatform(), size, and SnapshotWriter::WriteSnapshot().

Here is the call graph for this function: