Add Dart_Save/LoadCompilationTrace.

runtime/bin/gen_snapshot.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Generate a snapshot file after loading all the scripts specified on the
 // command line.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 67 matching lines @@
 static const char* vm_snapshot_instructions_filename = NULL;
 static const char* isolate_snapshot_data_filename = NULL;
 static const char* isolate_snapshot_instructions_filename = NULL;
 static const char* assembly_filename = NULL;
 static const char* script_snapshot_filename = NULL;
 static bool dependencies_only = false;
 static bool print_dependencies = false;
 static const char* dependencies_filename = NULL;
 
 
+// Value of the --load-compilation-trace flag.
+// (This pointer points into an argv buffer and does not need to be
+// free'd.)
+static const char* load_compilation_trace_filename = NULL;
+
 // Value of the --package-root flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* commandline_package_root = NULL;
 
 // Value of the --packages flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* commandline_packages_file = NULL;
 
@@ skipping 253 matching lines @@
 static bool ProcessEmbedderEntryPointsManifestOption(const char* option) {
   const char* name = ProcessOption(option, "--embedder_entry_points_manifest=");
   if (name != NULL) {
     entry_points_files->AddArgument(name);
     return true;
   }
   return false;
 }
 
 
+static bool ProcessLoadCompilationTraceOption(const char* option) {
+  const char* name = ProcessOption(option, "--load_compilation_trace=");
+  if (name != NULL) {
+    load_compilation_trace_filename = name;
+    return true;
+  }
+  return false;
+}
+
+
 static bool ProcessPackageRootOption(const char* option) {
   const char* name = ProcessOption(option, "--package_root=");
   if (name == NULL) {
     name = ProcessOption(option, "--package-root=");
   }
   if (name != NULL) {
     commandline_package_root = name;
     return true;
   }
   return false;
@@ skipping 46 matching lines @@
         ProcessVmSnapshotDataOption(argv[i]) ||
         ProcessVmSnapshotInstructionsOption(argv[i]) ||
         ProcessIsolateSnapshotDataOption(argv[i]) ||
         ProcessIsolateSnapshotInstructionsOption(argv[i]) ||
         ProcessAssemblyOption(argv[i]) ||
         ProcessScriptSnapshotOption(argv[i]) ||
         ProcessDependenciesOption(argv[i]) ||
         ProcessDependenciesOnlyOption(argv[i]) ||
         ProcessPrintDependenciesOption(argv[i]) ||
         ProcessEmbedderEntryPointsManifestOption(argv[i]) ||
-        ProcessURLmappingOption(argv[i]) || ProcessPackageRootOption(argv[i]) ||
-        ProcessPackagesOption(argv[i]) || ProcessEnvironmentOption(argv[i])) {
+        ProcessURLmappingOption(argv[i]) ||
+        ProcessLoadCompilationTraceOption(argv[i]) ||
+        ProcessPackageRootOption(argv[i]) || ProcessPackagesOption(argv[i]) ||
+        ProcessEnvironmentOption(argv[i])) {
       i += 1;
       continue;
     }
     vm_options->AddArgument(argv[i]);
     i += 1;
   }
 
   // Get the script name.
   if (i < argc) {
     *script_name = argv[i];
@@ skipping 77 matching lines @@
     Log::PrintErr(
         "Building an AOT snapshot requires at least one embedder "
         "entry points manifest.\n\n");
     return -1;
   }
 
   return 0;
 }
 
 
-static void WriteSnapshotFile(const char* filename,
-                              const uint8_t* buffer,
-                              const intptr_t size,
-                              bool write_magic_number = false) {
+static void WriteFile(const char* filename,
+                      const uint8_t* buffer,
+                      const intptr_t size) {
   File* file = File::Open(filename, File::kWriteTruncate);
   if (file == NULL) {
     Log::PrintErr("Error: Unable to write snapshot file: %s\n\n", filename);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     exit(kErrorExitCode);
   }
-  if (write_magic_number) {
-    // Write the magic number to indicate file is a script snapshot.
-    DartUtils::WriteMagicNumber(file);
-  }
   if (!file->WriteFully(buffer, size)) {
     Log::PrintErr("Error: Unable to write snapshot file: %s\n\n", filename);
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     exit(kErrorExitCode);
   }
   file->Release();
 }
 
 
+static void ReadFile(const char* filename, uint8_t** buffer, intptr_t* size) {
+  File* file = File::Open(filename, File::kRead);
+  if (file == NULL) {
+    Log::PrintErr("Unable to open file %s\n", filename);
+    Dart_ExitScope();
+    Dart_ShutdownIsolate();
+    exit(kErrorExitCode);
+  }
+  *size = file->Length();
+  *buffer = reinterpret_cast<uint8_t*>(malloc(*size));
+  if (!file->ReadFully(*buffer, *size)) {
+    Log::PrintErr("Unable to read file %s\n", filename);
+    Dart_ExitScope();
+    Dart_ShutdownIsolate();
+    exit(kErrorExitCode);
+  }
+  file->Release();
+}
+
+
 class UriResolverIsolateScope {
  public:
   UriResolverIsolateScope() {
     ASSERT(isolate != NULL);
     snapshotted_isolate_ = Dart_CurrentIsolate();
     Dart_ExitIsolate();
     Dart_EnterIsolate(isolate);
     Dart_EnterScope();
   }
 
@@ skipping 705 matching lines @@
   Dart_QualifiedFunctionName* entries = ParseEntryPointsManifestFiles();
   if ((entries == NULL) && IsSnapshottingForPrecompilation()) {
     Log::PrintErr(
         "Could not find native embedder entry points during precompilation\n");
     exit(kErrorExitCode);
   }
   return entries;
 }
 
 
+static void LoadCompilationTrace() {
+  if ((load_compilation_trace_filename != NULL) &&
+      (snapshot_kind == kCoreJIT)) {
+    uint8_t* buffer = NULL;
+    intptr_t size = 0;
+    ReadFile(load_compilation_trace_filename, &buffer, &size);
+    Dart_Handle result = Dart_LoadCompilationTrace(buffer, size);
+    CHECK_RESULT(result);
+  }
+}
+
+
 static void CreateAndWriteCoreSnapshot() {
   ASSERT(snapshot_kind == kCore);
   ASSERT(vm_snapshot_data_filename != NULL);
   ASSERT(isolate_snapshot_data_filename != NULL);
 
   Dart_Handle result;
   uint8_t* vm_snapshot_data_buffer = NULL;
   intptr_t vm_snapshot_data_size = 0;
   uint8_t* isolate_snapshot_data_buffer = NULL;
   intptr_t isolate_snapshot_data_size = 0;
 
   // First create a snapshot.
   result = Dart_CreateSnapshot(&vm_snapshot_data_buffer, &vm_snapshot_data_size,
                                &isolate_snapshot_data_buffer,
                                &isolate_snapshot_data_size);
   CHECK_RESULT(result);
 
   // Now write the vm isolate and isolate snapshots out to the
   // specified file and exit.
-  WriteSnapshotFile(vm_snapshot_data_filename, vm_snapshot_data_buffer,
-                    vm_snapshot_data_size);
+  WriteFile(vm_snapshot_data_filename, vm_snapshot_data_buffer,
+            vm_snapshot_data_size);
   if (vm_snapshot_instructions_filename != NULL) {
-    WriteSnapshotFile(vm_snapshot_instructions_filename, NULL, 0);
+    WriteFile(vm_snapshot_instructions_filename, NULL, 0);
   }
-  WriteSnapshotFile(isolate_snapshot_data_filename,
-                    isolate_snapshot_data_buffer, isolate_snapshot_data_size);
+  WriteFile(isolate_snapshot_data_filename, isolate_snapshot_data_buffer,
+            isolate_snapshot_data_size);
   if (isolate_snapshot_instructions_filename != NULL) {
-    WriteSnapshotFile(isolate_snapshot_instructions_filename, NULL, 0);
+    WriteFile(isolate_snapshot_instructions_filename, NULL, 0);
   }
 }
 
 
 static void CreateAndWriteCoreJITSnapshot() {
   ASSERT(snapshot_kind == kCoreJIT);
   ASSERT(vm_snapshot_data_filename != NULL);
   ASSERT(vm_snapshot_instructions_filename != NULL);
   ASSERT(isolate_snapshot_data_filename != NULL);
   ASSERT(isolate_snapshot_instructions_filename != NULL);
@@ skipping 12 matching lines @@
   result = Dart_CreateCoreJITSnapshotAsBlobs(
       &vm_snapshot_data_buffer, &vm_snapshot_data_size,
       &vm_snapshot_instructions_buffer, &vm_snapshot_instructions_size,
       &isolate_snapshot_data_buffer, &isolate_snapshot_data_size,
       &isolate_snapshot_instructions_buffer,
       &isolate_snapshot_instructions_size);
   CHECK_RESULT(result);
 
   // Now write the vm isolate and isolate snapshots out to the
   // specified file and exit.
-  WriteSnapshotFile(vm_snapshot_data_filename, vm_snapshot_data_buffer,
-                    vm_snapshot_data_size);
-  WriteSnapshotFile(vm_snapshot_instructions_filename,
-                    vm_snapshot_instructions_buffer,
-                    vm_snapshot_instructions_size);
-  WriteSnapshotFile(isolate_snapshot_data_filename,
-                    isolate_snapshot_data_buffer, isolate_snapshot_data_size);
-  WriteSnapshotFile(isolate_snapshot_instructions_filename,
-                    isolate_snapshot_instructions_buffer,
-                    isolate_snapshot_instructions_size);
+  WriteFile(vm_snapshot_data_filename, vm_snapshot_data_buffer,
+            vm_snapshot_data_size);
+  WriteFile(vm_snapshot_instructions_filename, vm_snapshot_instructions_buffer,
+            vm_snapshot_instructions_size);
+  WriteFile(isolate_snapshot_data_filename, isolate_snapshot_data_buffer,
+            isolate_snapshot_data_size);
+  WriteFile(isolate_snapshot_instructions_filename,
+            isolate_snapshot_instructions_buffer,
+            isolate_snapshot_instructions_size);
 }
 
 
 static void CreateAndWriteScriptSnapshot() {
   ASSERT(snapshot_kind == kScript);
   ASSERT(script_snapshot_filename != NULL);
 
   // First create a snapshot.
   uint8_t* buffer = NULL;
   intptr_t size = 0;
   Dart_Handle result = Dart_CreateScriptSnapshot(&buffer, &size);
   CHECK_RESULT(result);
 
   // Now write it out to the specified file.
-  WriteSnapshotFile(script_snapshot_filename, buffer, size, false);
+  WriteFile(script_snapshot_filename, buffer, size);
 }
 
 
 static void CreateAndWritePrecompiledSnapshot(
     Dart_QualifiedFunctionName* standalone_entry_points) {
   ASSERT(IsSnapshottingForPrecompilation());
   Dart_Handle result;
 
   // Precompile with specified embedder entry points
   result = Dart_Precompile(standalone_entry_points, NULL, 0);
   CHECK_RESULT(result);
 
   // Create a precompiled snapshot.
   bool as_assembly = assembly_filename != NULL;
   if (as_assembly) {
     ASSERT(snapshot_kind == kAppAOTAssembly);
 
     uint8_t* assembly_buffer = NULL;
     intptr_t assembly_size = 0;
     result =
         Dart_CreateAppAOTSnapshotAsAssembly(&assembly_buffer, &assembly_size);
     CHECK_RESULT(result);
 
-    WriteSnapshotFile(assembly_filename, assembly_buffer, assembly_size);
+    WriteFile(assembly_filename, assembly_buffer, assembly_size);
   } else {
     ASSERT(snapshot_kind == kAppAOTBlobs);
 
     uint8_t* vm_snapshot_data_buffer = NULL;
     intptr_t vm_snapshot_data_size = 0;
     uint8_t* vm_snapshot_instructions_buffer = NULL;
     intptr_t vm_snapshot_instructions_size = 0;
     uint8_t* isolate_snapshot_data_buffer = NULL;
     intptr_t isolate_snapshot_data_size = 0;
     uint8_t* isolate_snapshot_instructions_buffer = NULL;
     intptr_t isolate_snapshot_instructions_size = 0;
     result = Dart_CreateAppAOTSnapshotAsBlobs(
         &vm_snapshot_data_buffer, &vm_snapshot_data_size,
         &vm_snapshot_instructions_buffer, &vm_snapshot_instructions_size,
         &isolate_snapshot_data_buffer, &isolate_snapshot_data_size,
         &isolate_snapshot_instructions_buffer,
         &isolate_snapshot_instructions_size);
     CHECK_RESULT(result);
 
-    WriteSnapshotFile(vm_snapshot_data_filename, vm_snapshot_data_buffer,
-                      vm_snapshot_data_size);
-    WriteSnapshotFile(vm_snapshot_instructions_filename,
-                      vm_snapshot_instructions_buffer,
-                      vm_snapshot_instructions_size);
-    WriteSnapshotFile(isolate_snapshot_data_filename,
-                      isolate_snapshot_data_buffer, isolate_snapshot_data_size);
-    WriteSnapshotFile(isolate_snapshot_instructions_filename,
-                      isolate_snapshot_instructions_buffer,
-                      isolate_snapshot_instructions_size);
+    WriteFile(vm_snapshot_data_filename, vm_snapshot_data_buffer,
+              vm_snapshot_data_size);
+    WriteFile(vm_snapshot_instructions_filename,
+              vm_snapshot_instructions_buffer, vm_snapshot_instructions_size);
+    WriteFile(isolate_snapshot_data_filename, isolate_snapshot_data_buffer,
+              isolate_snapshot_data_size);
+    WriteFile(isolate_snapshot_instructions_filename,
+              isolate_snapshot_instructions_buffer,
+              isolate_snapshot_instructions_size);
   }
 }
 
 
 static void SetupForUriResolution() {
   // Set up the library tag handler for this isolate.
   Dart_Handle result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
   if (Dart_IsError(result)) {
     Log::PrintErr("%s\n", Dart_GetError(result));
     Dart_ExitScope();
@@ skipping 296 matching lines @@
       library = LoadSnapshotCreationScript(app_script_name);
       CHECK_RESULT(library);
 
       ImportNativeEntryPointLibrariesIntoRoot(entry_points);
     }
 
     // Ensure that we mark all libraries as loaded.
     result = Dart_FinalizeLoading(false);
     CHECK_RESULT(result);
 
+    LoadCompilationTrace();
+
     if (!dependencies_only) {
       switch (snapshot_kind) {
         case kCore:
           CreateAndWriteCoreSnapshot();
           break;
         case kCoreJIT:
           CreateAndWriteCoreJITSnapshot();
           break;
         case kScript:
           CreateAndWriteScriptSnapshot();
@@ skipping 11 matching lines @@
 
     Dart_ExitScope();
     Dart_ShutdownIsolate();
 
     CleanupEntryPointsCollection(entry_points);
 
     Dart_EnterIsolate(UriResolverIsolateScope::isolate);
     Dart_ShutdownIsolate();
   } else {
     SetupForGenericSnapshotCreation();
+    LoadCompilationTrace();
     switch (snapshot_kind) {
       case kCore:
         CreateAndWriteCoreSnapshot();
         break;
       case kCoreJIT:
         CreateAndWriteCoreJITSnapshot();
         break;
       default:
         UNREACHABLE();
         break;
@@ skipping 12 matching lines @@
   delete mapped_isolate_snapshot_data;
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }