Refactor snapshots pieces to include a section for loading instructions into the heap of a regular …

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 42 matching lines @@
       exit_code = kErrorExitCode;                                              \
     }                                                                          \
     Dart_ExitScope();                                                          \
     Dart_ShutdownIsolate();                                                    \
     exit(exit_code);                                                           \
   }
 
 
 // Global state that indicates whether a snapshot is to be created and
 // if so which file to write the snapshot into.
-static const char* vm_isolate_snapshot_filename = NULL;
-static const char* isolate_snapshot_filename = NULL;
+static const char* vm_snapshot_data_filename = NULL;
+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* instructions_blob_filename = NULL;
-static const char* rodata_blob_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.)
@@ skipping 104 matching lines @@
 
 static const char* ProcessOption(const char* option, const char* name) {
   const intptr_t length = strlen(name);
   if (strncmp(option, name, length) == 0) {
     return (option + length);
   }
   return NULL;
 }
 
 
-static bool ProcessVmIsolateSnapshotOption(const char* option) {
-  const char* name = ProcessOption(option, "--vm_isolate_snapshot=");
+static bool ProcessVmSnapshotDataOption(const char* option) {
+  const char* name = ProcessOption(option, "--vm_snapshot_data=");
   if (name != NULL) {
-    vm_isolate_snapshot_filename = name;
+    vm_snapshot_data_filename = name;
     return true;
   }
   return false;
 }
 
 
-static bool ProcessIsolateSnapshotOption(const char* option) {
-  const char* name = ProcessOption(option, "--isolate_snapshot=");
+static bool ProcessVmSnapshotInstructionsOption(const char* option) {
+  const char* name = ProcessOption(option, "--vm_snapshot_instructions=");
   if (name != NULL) {
-    isolate_snapshot_filename = name;
+    vm_snapshot_instructions_filename = name;
+    return true;
+  }
+  return false;
+}
+
+
+static bool ProcessIsolateSnapshotDataOption(const char* option) {
+  const char* name = ProcessOption(option, "--isolate_snapshot_data=");
+  if (name != NULL) {
+    isolate_snapshot_data_filename = name;
+    return true;
+  }
+  return false;
+}
+
+
+static bool ProcessIsolateSnapshotInstructionsOption(const char* option) {
+  const char* name = ProcessOption(option, "--isolate_snapshot_instructions=");
+  if (name != NULL) {
+    isolate_snapshot_instructions_filename = name;
     return true;
   }
   return false;
 }
 
 
 static bool ProcessAssemblyOption(const char* option) {
   const char* name = ProcessOption(option, "--assembly=");
   if (name != NULL) {
     assembly_filename = name;
     return true;
   }
   return false;
-}
-
-
-static bool ProcessInstructionsBlobOption(const char* option) {
-  const char* name = ProcessOption(option, "--instructions_blob=");
-  if (name != NULL) {
-    instructions_blob_filename = name;
-    return true;
-  }
-  return false;
-}
-
-
-static bool ProcessRodataBlobOption(const char* option) {
-  const char* name = ProcessOption(option, "--rodata_blob=");
-  if (name != NULL) {
-    rodata_blob_filename = name;
-    return true;
-  }
-  return false;
 }
 
 
 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;
@@ skipping 30 matching lines @@
   }
   if (mapping != NULL) {
     DartUtils::url_mapping->AddArgument(mapping);
     return true;
   }
   return false;
 }
 
 
 static bool IsSnapshottingForPrecompilation() {
-  return (assembly_filename != NULL) || (instructions_blob_filename != NULL);
+  return (assembly_filename != NULL) ||
+         (vm_snapshot_instructions_filename != NULL);
 }
 
 
 // Parse out the command line arguments. Returns -1 if the arguments
 // are incorrect, 0 otherwise.
 static int ParseArguments(int argc,
                           char** argv,
                           CommandLineOptions* vm_options,
                           char** script_name) {
   const char* kPrefix = "-";
   const intptr_t kPrefixLen = strlen(kPrefix);
 
   // Skip the binary name.
   int i = 1;
 
   // Parse out the vm options.
   while ((i < argc) && IsValidFlag(argv[i], kPrefix, kPrefixLen)) {
-    if (ProcessVmIsolateSnapshotOption(argv[i]) ||
-        ProcessIsolateSnapshotOption(argv[i]) ||
+    if (ProcessVmSnapshotDataOption(argv[i]) ||
+        ProcessVmSnapshotInstructionsOption(argv[i]) ||
+        ProcessIsolateSnapshotDataOption(argv[i]) ||
+        ProcessIsolateSnapshotInstructionsOption(argv[i]) ||
         ProcessAssemblyOption(argv[i]) ||
-        ProcessInstructionsBlobOption(argv[i]) ||
-        ProcessRodataBlobOption(argv[i]) ||
         ProcessEmbedderEntryPointsManifestOption(argv[i]) ||
         ProcessURLmappingOption(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];
     i += 1;
   } else {
     *script_name = NULL;
   }
 
   // Verify consistency of arguments.
   if ((commandline_package_root != NULL) &&
       (commandline_packages_file != NULL)) {
     Log::PrintErr(
         "Specifying both a packages directory and a packages "
         "file is invalid.\n");
     return -1;
   }
 
-  if (vm_isolate_snapshot_filename == NULL) {
-    Log::PrintErr("No vm isolate snapshot output file specified.\n\n");
+  if (vm_snapshot_data_filename == NULL) {
+    Log::PrintErr("No vm snapshot output file specified.\n\n");
     return -1;
   }
 
-  if (isolate_snapshot_filename == NULL) {
+  if (isolate_snapshot_data_filename == NULL) {
     Log::PrintErr("No isolate snapshot output file specified.\n\n");
     return -1;
   }
 
   bool precompiled_as_assembly = assembly_filename != NULL;
-  bool precompiled_as_blobs =
-      (instructions_blob_filename != NULL) || (rodata_blob_filename != NULL);
+  bool precompiled_as_blobs = (vm_snapshot_instructions_filename != NULL) ||
+                              (isolate_snapshot_instructions_filename != NULL);
   if (precompiled_as_assembly && precompiled_as_blobs) {
     Log::PrintErr(
         "Cannot request a precompiled snapshot simultaneously as "
         "assembly (--assembly=<output.file>) and as blobs "
         "(--instructions-blob=<output.file> and "
         "--rodata-blob=<output.file>)\n\n");
     return -1;
   }
-  if ((instructions_blob_filename != NULL) != (rodata_blob_filename != NULL)) {
+  if ((vm_snapshot_instructions_filename != NULL) !=
+      (isolate_snapshot_instructions_filename != NULL)) {
     Log::PrintErr(
         "Requesting a precompiled snapshot as blobs requires both "
-        "(--instructions-blob=<output.file> and "
-        "--rodata-blob=<output.file>)\n\n");
+        "(--vm_snapshot_instructions=<output.file> and "
+        "--isolate_snapshot_instructions=<output.file>)\n\n");
     return -1;
   }
   if (IsSnapshottingForPrecompilation() && (entry_points_files->count() == 0)) {
     Log::PrintErr(
         "Specifying an instructions snapshot filename indicates precompilation"
         ". But no embedder entry points manifest was specified.\n\n");
     return -1;
   }
 
   return 0;
@@ skipping 258 matching lines @@
 "  Not specifying these may cause the tree shaker to remove them from the    \n"
 "  program. The format of this manifest is as follows. Each line in the      \n"
 "  manifest is a comma separated list of three elements. The first entry is  \n"
 "  the library URI, the second entry is the class name and the final entry   \n"
 "  the function name. The file must be terminated with a newline charater.   \n"
 "                                                                            \n"
 "    Example:                                                                \n"
 "      dart:something,SomeClass,doSomething                                  \n"
 "                                                                            \n"
 "  Supported options:                                                        \n"
-"    --vm_isolate_snapshot=<file>      A full snapshot is a compact          \n"
-"    --isolate_snapshot=<file>         representation of the dart vm isolate \n"
+"    --vm_snapshot_data=<file>         A full snapshot is a compact          \n"
+"    --isolate_snapshot_data=<file>    representation of the dart vm isolate \n"
 "                                      heap and dart isolate heap states.    \n"
 "                                      Both these options are required       \n"
 "                                                                            \n"
 "    --package_root=<path>             Where to find packages, that is,      \n"
 "                                      package:...  imports.                 \n"
 "                                                                            \n"
 "    --packages=<packages_file>        Where to find a package spec file     \n"
 "                                                                            \n"
 "    --url_mapping=<mapping>           Uses the URL mapping(s) specified on  \n"
 "                                      the command line to load the          \n"
 "                                      libraries.                            \n"
 "                                                                            \n"
 "    --assembly=<file>                 (Precompilation only) Contains the    \n"
 "                                      assembly that must be linked into     \n"
 "                                      the target binary                     \n"
 "                                                                            \n"
-"    --instructions_blob=<file>        (Precompilation only) Contains the    \n"
-"    --rodata_blob=<file>              instructions and read-only data that  \n"
-"                                      must be mapped into the target binary \n"
+"    --vm_snapshot_instructions=<file> (Precompilation only) Contains the    \n"
+"    --isolate_snapshot_instructions=<file> instructions and read-only data  \n"
+"                                      that must be mapped into the target   \n"
+"                                      binary                                \n"
 "                                                                            \n"
 "    --embedder_entry_points_manifest=<file> (Precompilation or app          \n"
 "                                      snapshots) Contains embedder's entry  \n"
 "                                      points into Dart code from the C API. \n"
 "\n");
 }
 // clang-format on
 
 
 static void VerifyLoaded(Dart_Handle library) {
@@ skipping 346 matching lines @@
         "Could not find native embedder entry points during precompilation\n");
     exit(kErrorExitCode);
   }
   return entries;
 }
 
 
 static void CreateAndWriteSnapshot() {
   ASSERT(!IsSnapshottingForPrecompilation());
   Dart_Handle result;
-  uint8_t* vm_isolate_buffer = NULL;
-  intptr_t vm_isolate_size = 0;
-  uint8_t* isolate_buffer = NULL;
-  intptr_t isolate_size = 0;
+  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_isolate_buffer, &vm_isolate_size,
-                               &isolate_buffer, &isolate_size);
+  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_isolate_snapshot_filename, vm_isolate_buffer,
-                    vm_isolate_size);
-  WriteSnapshotFile(isolate_snapshot_filename, isolate_buffer, isolate_size);
+  WriteSnapshotFile(vm_snapshot_data_filename, vm_snapshot_data_buffer,
+                    vm_snapshot_data_size);
+  WriteSnapshotFile(isolate_snapshot_data_filename,
+                    isolate_snapshot_data_buffer, isolate_snapshot_data_size);
   Dart_ExitScope();
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 }
 
 
 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) {
     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);
   } else {
-    uint8_t* vm_isolate_buffer = NULL;
-    intptr_t vm_isolate_size = 0;
-    uint8_t* isolate_buffer = NULL;
-    intptr_t isolate_size = 0;
-    uint8_t* instructions_blob_buffer = NULL;
-    intptr_t instructions_blob_size = 0;
-    uint8_t* rodata_blob_buffer = NULL;
-    intptr_t rodata_blob_size = 0;
+    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_isolate_buffer, &vm_isolate_size, &isolate_buffer, &isolate_size,
-        &instructions_blob_buffer, &instructions_blob_size, &rodata_blob_buffer,
-        &rodata_blob_size);
+        &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_isolate_snapshot_filename, vm_isolate_buffer,
-                      vm_isolate_size);
-    WriteSnapshotFile(isolate_snapshot_filename, isolate_buffer, isolate_size);
-    WriteSnapshotFile(instructions_blob_filename, instructions_blob_buffer,
-                      instructions_blob_size);
-    WriteSnapshotFile(rodata_blob_filename, rodata_blob_buffer,
-                      rodata_blob_size);
+    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);
   }
 
   Dart_ExitScope();
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 }
 
 
 static void SetupForUriResolution() {
@@ skipping 31 matching lines @@
 static Dart_Isolate CreateServiceIsolate(const char* script_uri,
                                          const char* main,
                                          const char* package_root,
                                          const char* package_config,
                                          Dart_IsolateFlags* flags,
                                          void* data,
                                          char** error) {
   IsolateData* isolate_data =
       new IsolateData(script_uri, package_root, package_config);
   Dart_Isolate isolate = NULL;
-  isolate =
-      Dart_CreateIsolate(script_uri, main, NULL, NULL, isolate_data, error);
+  isolate = Dart_CreateIsolate(script_uri, main, NULL, NULL, NULL, isolate_data,
+                               error);
 
   if (isolate == NULL) {
     Log::PrintErr("Error: Could not create service isolate");
     return NULL;
   }
 
   Dart_EnterScope();
   if (!Dart_IsServiceIsolate(isolate)) {
     Log::PrintErr("Error: We only expect to create the service isolate");
     return NULL;
@@ skipping 82 matching lines @@
   char* error = Dart_Initialize(&init_params);
   if (error != NULL) {
     Log::PrintErr("VM initialization failed: %s\n", error);
     free(error);
     return kErrorExitCode;
   }
 
   IsolateData* isolate_data = new IsolateData(NULL, commandline_package_root,
                                               commandline_packages_file);
   Dart_Isolate isolate =
-      Dart_CreateIsolate(NULL, NULL, NULL, NULL, isolate_data, &error);
+      Dart_CreateIsolate(NULL, NULL, NULL, NULL, NULL, isolate_data, &error);
   if (isolate == NULL) {
     Log::PrintErr("Error: %s", error);
     free(error);
     exit(kErrorExitCode);
   }
 
   Dart_Handle result;
   Dart_Handle library;
   Dart_EnterScope();
 
   result = Dart_SetEnvironmentCallback(EnvironmentCallback);
   CHECK_RESULT(result);
 
-  ASSERT(vm_isolate_snapshot_filename != NULL);
-  ASSERT(isolate_snapshot_filename != NULL);
+  ASSERT(vm_snapshot_data_filename != NULL);
+  ASSERT(isolate_snapshot_data_filename != NULL);
   // Load up the script before a snapshot is created.
   if (app_script_name != NULL) {
     // This is the case of a custom embedder (e.g: dartium) trying to
     // create a full snapshot. The current isolate is set up so that we can
     // invoke the dart uri resolution code like _resolveURI. App script is
     // loaded into a separate isolate.
     SetupForUriResolution();
 
     // Prepare builtin and its dependent libraries for use to resolve URIs.
     // Set up various closures, e.g: printing, timers etc.
@@ skipping 26 matching lines @@
     void* kernel_program = NULL;
     if (is_kernel_file) {
       kernel_program = Dart_ReadKernelBinary(kernel, kernel_length);
       free(const_cast<uint8_t*>(kernel));
     }
 
     Dart_Isolate isolate =
         is_kernel_file
             ? Dart_CreateIsolateFromKernel(NULL, NULL, kernel_program, NULL,
                                            isolate_data, &error)
-            : Dart_CreateIsolate(NULL, NULL, NULL, NULL, isolate_data, &error);
+            : Dart_CreateIsolate(NULL, NULL, NULL, NULL, NULL, isolate_data,
+                                 &error);
     if (isolate == NULL) {
       Log::PrintErr("%s", error);
       free(error);
       exit(kErrorExitCode);
     }
     Dart_EnterScope();
     result = Dart_SetEnvironmentCallback(EnvironmentCallback);
     CHECK_RESULT(result);
 
     // Set up the library tag handler in such a manner that it will use the
@@ skipping 52 matching lines @@
   EventHandler::Stop();
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }