Option to output precompiled instructions as a blob for use with mmap instead of assembly for use i…

runtime/bin/main.cc

 // Copyright (c) 2012, 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.
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 65 matching lines @@
 // Global flag that is used to indicate that we want to compile all the
 // dart functions before running main and not compile anything thereafter.
 static bool gen_precompiled_snapshot = false;
 
 
 // Global flag that is used to indicate that we want to run from a precompiled
 // snapshot.
 static bool run_precompiled_snapshot = false;
 
 
+// Global flag that is used to indicate that we want to use blobs/mmap instead
+// of assembly/shared libraries for precompilation.
+static bool use_blobs = false;
+
+
 // Value of the --gen/run_precompiled_snapshot flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* precompiled_snapshot_directory = NULL;
 
 
 // Global flag that is used to indicate that we want to compile everything in
 // the same way as precompilation before main, then continue running in the
 // same process.
 // Always set this with dart_noopt.
 #if defined(DART_PRECOMPILER) && !defined(DART_NO_SNAPSHOT)
 static const bool is_noopt = true;
 #else
 static const bool is_noopt = false;
 #endif
 
 
 extern const char* kPrecompiledLibraryName;
 extern const char* kPrecompiledInstructionsSymbolName;
 extern const char* kPrecompiledDataSymbolName;
 static const char* kPrecompiledVmIsolateName = "precompiled.vmisolate";
 static const char* kPrecompiledIsolateName = "precompiled.isolate";
-static const char* kPrecompiledInstructionsName = "precompiled.S";
+static const char* kPrecompiledAssemblyName = "precompiled.S";
+static const char* kPrecompiledInstructionsBlobName =
+    "precompiled.instructions";
+static const char* kPrecompiledRodataBlobName = "precompiled.rodata";
 static const char* kVMIsolateSuffix = "vmisolate";
 static const char* kIsolateSuffix = "isolate";
 
 // Global flag that is used to indicate that we want to trace resolution of
 // URIs and the loading of libraries, parts and scripts.
 static bool trace_loading = false;
 
 
 static const char* DEFAULT_VM_SERVICE_SERVER_IP = "127.0.0.1";
 static const int DEFAULT_VM_SERVICE_SERVER_PORT = 8181;
@@ skipping 200 matching lines @@
                                     CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   compile_all = true;
   return true;
 }
 
 
+static bool ProcessUseBlobsOption(const char* arg,
+                                  CommandLineOptions* vm_options) {
+  ASSERT(arg != NULL);
+  if (*arg != '\0') {
+    return false;
+  }
+  use_blobs = true;
+  return true;
+}
+
+
 static bool ProcessGenPrecompiledSnapshotOption(
     const char* arg,
     CommandLineOptions* vm_options) {
 #if !defined(DART_PRECOMPILER)
   Log::PrintErr("Precompiled snapshots must be generated with "
                 "dart_bootstrap.\n");
   return false;
 #else  // defined(DART_PRECOMPILER)
   ASSERT(arg != NULL);
   if ((arg[0] == '=') || (arg[0] == ':')) {
@@ skipping 167 matching lines @@
   { "-h", ProcessHelpOption },
   { "--help", ProcessHelpOption },
   { "--packages=", ProcessPackagesOption },
   { "--package-root=", ProcessPackageRootOption },
   { "-v", ProcessVerboseOption },
   { "--verbose", ProcessVerboseOption },
   { "--version", ProcessVersionOption },
 
   // VM specific options to the standalone dart program.
   { "--compile_all", ProcessCompileAllOption },
+  { "--use_blobs", ProcessUseBlobsOption },
   { "--enable-vm-service", ProcessEnableVmServiceOption },
   { "--gen-precompiled-snapshot", ProcessGenPrecompiledSnapshotOption },
   { "--observe", ProcessObserveOption },
   { "--run-precompiled-snapshot", ProcessRunPrecompiledSnapshotOption },
   { "--shutdown", ProcessShutdownOption },
   { "--snapshot=", ProcessScriptSnapshotOption },
   { "--full-snapshot-after-run=", ProcessFullSnapshotAfterRunOption },
   { "--run-full-snapshot=", ProcessRunFullSnapshotOption },
   { "--trace-loading", ProcessTraceLoadingOption },
   { NULL, NULL }
@@ skipping 610 matching lines @@
     fflush(stderr);
     Platform::Exit(kErrorExitCode);
   }
   DartUtils::CloseFile(file);
   if (concat != NULL) {
     delete concat;
   }
 }
 
 
+static void ReadExecutableSnapshotFile(const char* snapshot_directory,
+                                       const char* filename,
+                                       const uint8_t** buffer) {
+  char* concat = NULL;
+  const char* qualified_filename;
+  if ((snapshot_directory != NULL) && (strlen(snapshot_directory) > 0)) {
+    intptr_t len = snprintf(NULL, 0, "%s/%s", snapshot_directory, filename);
+    concat = new char[len + 1];
+    snprintf(concat, len + 1, "%s/%s", snapshot_directory, filename);
+    qualified_filename = concat;
+  } else {
+    qualified_filename = filename;
+  }
+
+  intptr_t len = -1;
+  *buffer = reinterpret_cast<uint8_t*>(
+      DartUtils::MapExecutable(qualified_filename, &len));
+  if ((*buffer == NULL) || (len == -1)) {
+    fprintf(stderr,
+            "Error: Unable to read snapshot file %s\n", qualified_filename);
+    fflush(stderr);
+    Platform::Exit(kErrorExitCode);
+  }
+  if (concat != NULL) {
+    delete concat;
+  }
+}
+
+
 static void* LoadLibrarySymbol(const char* snapshot_directory,
                                const char* libname,
                                const char* symname) {
   char* concat = NULL;
   const char* qualified_libname;
   if ((snapshot_directory != NULL) && (strlen(snapshot_directory) > 0)) {
     intptr_t len = snprintf(NULL, 0, "%s/%s", snapshot_directory, libname);
     concat = new char[len + 1];
     snprintf(concat, len + 1, "%s/%s", snapshot_directory, libname);
     qualified_libname = concat;
@@ skipping 202 matching lines @@
       const bool reset_fields = gen_precompiled_snapshot;
       result = Dart_Precompile(standalone_entry_points, reset_fields);
       CHECK_RESULT(result);
     }
 
     if (gen_precompiled_snapshot) {
       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_buffer = NULL;
-      intptr_t instructions_size = 0;
-      result = Dart_CreatePrecompiledSnapshot(&vm_isolate_buffer,
-                                              &vm_isolate_size,
-                                              &isolate_buffer,
-                                              &isolate_size,
-                                              &instructions_buffer,
-                                              &instructions_size);
-      CHECK_RESULT(result);
+      uint8_t* assembly_buffer = NULL;
+      intptr_t assembly_size = 0;
+      uint8_t* instructions_blob_buffer = NULL;
+      intptr_t instructions_blob_size = NULL;
+      uint8_t* rodata_blob_buffer = NULL;
+      intptr_t rodata_blob_size = NULL;
+      if (use_blobs) {
+        result = Dart_CreatePrecompiledSnapshotBlob(
+            &vm_isolate_buffer,
+            &vm_isolate_size,
+            &isolate_buffer,
+            &isolate_size,
+            &instructions_blob_buffer,
+            &instructions_blob_size,
+            &rodata_blob_buffer,
+            &rodata_blob_size);
+        CHECK_RESULT(result);
+      } else {
+        result = Dart_CreatePrecompiledSnapshotAssembly(
+            &vm_isolate_buffer,
+            &vm_isolate_size,
+            &isolate_buffer,
+            &isolate_size,
+            &assembly_buffer,
+            &assembly_size);
+        CHECK_RESULT(result);
+      }
       WriteSnapshotFile(precompiled_snapshot_directory,
                         kPrecompiledVmIsolateName,
                         false,
                         vm_isolate_buffer,
                         vm_isolate_size);
       WriteSnapshotFile(precompiled_snapshot_directory,
                         kPrecompiledIsolateName,
                         false,
                         isolate_buffer,
                         isolate_size);
-      WriteSnapshotFile(precompiled_snapshot_directory,
-                        kPrecompiledInstructionsName,
-                        false,
-                        instructions_buffer,
-                        instructions_size);
+      if (use_blobs) {
+        WriteSnapshotFile(precompiled_snapshot_directory,
+                          kPrecompiledInstructionsBlobName,
+                          false,
+                          instructions_blob_buffer,
+                          instructions_blob_size);
+        WriteSnapshotFile(precompiled_snapshot_directory,
+                          kPrecompiledRodataBlobName,
+                          false,
+                          rodata_blob_buffer,
+                          rodata_blob_size);
+      } else {
+        WriteSnapshotFile(precompiled_snapshot_directory,
+                          kPrecompiledAssemblyName,
+                          false,
+                          assembly_buffer,
+                          assembly_size);
+      }
     } else {
       if (Dart_IsNull(root_lib)) {
         ErrorExit(kErrorExitCode,
                   "Unable to find root library for '%s'\n",
                   script_name);
       }
 
       // The helper function _getMainClosure creates a closure for the main
       // entry point which is either explicitly or implictly exported from the
       // root library.
@@ skipping 196 matching lines @@
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Start event handler.
   TimerUtils::InitOnce();
   EventHandler::Start();
 
   const uint8_t* instructions_snapshot = NULL;
   const uint8_t* data_snapshot = NULL;
   if (run_precompiled_snapshot) {
-    instructions_snapshot = reinterpret_cast<const uint8_t*>(
-        LoadLibrarySymbol(precompiled_snapshot_directory,
-                          kPrecompiledLibraryName,
-                          kPrecompiledInstructionsSymbolName));
-    data_snapshot = reinterpret_cast<const uint8_t*>(
-        LoadLibrarySymbol(precompiled_snapshot_directory,
-                          kPrecompiledLibraryName,
-                          kPrecompiledDataSymbolName));
     ReadSnapshotFile(precompiled_snapshot_directory,
                      kPrecompiledVmIsolateName,
                      &vm_isolate_snapshot_buffer);
     ReadSnapshotFile(precompiled_snapshot_directory,
                      kPrecompiledIsolateName,
                      &isolate_snapshot_buffer);
-
+    if (use_blobs) {
+      ReadExecutableSnapshotFile(precompiled_snapshot_directory,
+                                 kPrecompiledInstructionsBlobName,
+                                 &instructions_snapshot);
+      ReadSnapshotFile(precompiled_snapshot_directory,
+                       kPrecompiledRodataBlobName,
+                       &data_snapshot);
+    } else {
+      instructions_snapshot = reinterpret_cast<const uint8_t*>(
+          LoadLibrarySymbol(precompiled_snapshot_directory,
+                            kPrecompiledLibraryName,
+                            kPrecompiledInstructionsSymbolName));
+      data_snapshot = reinterpret_cast<const uint8_t*>(
+          LoadLibrarySymbol(precompiled_snapshot_directory,
+                            kPrecompiledLibraryName,
+                            kPrecompiledDataSymbolName));
+    }
   } else if (run_full_snapshot) {
     char* vm_snapshot_fname;
     char* isolate_snapshot_fname;
 
     // Compute file names.
     ComputeSnapshotFilenames(snapshot_filename,
                              &vm_snapshot_fname,
                              &isolate_snapshot_fname);
 
     ReadSnapshotFile(NULL, vm_snapshot_fname, &vm_isolate_snapshot_buffer);
@@ skipping 66 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }