First step towards splitting a full snapshot into a vm isolate snapshot and a

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 <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/file.h"
 #include "bin/log.h"
 #include "bin/thread.h"
 
 #include "platform/globals.h"
 
 
 namespace dart {
 namespace bin {
 
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
-    free(snapshot_buffer);                                                     \
     Log::PrintErr("Error: %s", Dart_GetError(result));                         \
     Dart_ExitScope();                                                          \
     Dart_ShutdownIsolate();                                                    \
     exit(255);                                                                 \
   }                                                                            \
 
 
 // Global state that indicates whether a snapshot is to be created and
 // if so which file to write the snapshot into.
-static const char* snapshot_filename = NULL;
+static const char* vm_isolate_snapshot_filename = NULL;
+static const char* isolate_snapshot_filename = NULL;
 static const char* package_root = NULL;
-static uint8_t* snapshot_buffer = NULL;
 
 
 // Global state which contains a pointer to the script name for which
 // a snapshot needs to be created (NULL would result in the creation
 // of a generic snapshot that contains only the corelibs).
 static char* app_script_name = NULL;
 
 
 // Global state that captures the URL mappings specified on the command line.
 static CommandLineOptions* url_mapping = NULL;
 
 static bool IsValidFlag(const char* name,
                         const char* prefix,
                         intptr_t prefix_length) {
   intptr_t name_length = strlen(name);
   return ((name_length > prefix_length) &&
           (strncmp(name, prefix, prefix_length) == 0));
 }
 
 
 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 ProcessSnapshotOption(const char* option) {
-  const char* name = ProcessOption(option, "--snapshot=");
+static bool ProcessVmIsolateSnapshotOption(const char* option) {
+  const char* name = ProcessOption(option, "--vm_isolate_snapshot=");
   if (name != NULL) {
-    snapshot_filename = name;
+    vm_isolate_snapshot_filename = name;
     return true;
   }
   return false;
 }
 
 
+static bool ProcessIsolateSnapshotOption(const char* option) {
+  const char* name = ProcessOption(option, "--isolate_snapshot=");
+  if (name != NULL) {
+    isolate_snapshot_filename = name;
+    return true;
+  }
+  return false;
+}
+
+
 static bool ProcessPackageRootOption(const char* option) {
   const char* name = ProcessOption(option, "--package_root=");
   if (name != NULL) {
     package_root = name;
     return true;
   }
   return false;
 }
 
 
@@ skipping 17 matching lines @@
                           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 (ProcessSnapshotOption(argv[i]) ||
+    if (ProcessVmIsolateSnapshotOption(argv[i]) ||
+        ProcessIsolateSnapshotOption(argv[i]) ||
         ProcessURLmappingOption(argv[i]) ||
         ProcessPackageRootOption(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;
   }
 
-  if (snapshot_filename == NULL) {
-    Log::PrintErr("No snapshot output file specified.\n\n");
+  if (vm_isolate_snapshot_filename == NULL) {
+    Log::PrintErr("No vm isolate snapshot output file specified.\n\n");
+    return -1;
+  }
+
+  if (isolate_snapshot_filename == NULL) {
+    Log::PrintErr("No isolate snapshot output file specified.\n\n");
     return -1;
   }
 
   return 0;
 }
 
 
-static void WriteSnapshotFile(const uint8_t* buffer, const intptr_t size) {
-  File* file = File::Open(snapshot_filename, File::kWriteTruncate);
+static void WriteSnapshotFile(const char* filename,
+                              const uint8_t* buffer,
+                              const intptr_t size) {
+  File* file = File::Open(filename, File::kWriteTruncate);
   ASSERT(file != NULL);
   if (!file->WriteFully(buffer, size)) {
-    Log::PrintErr("Error: Failed to write full snapshot.\n\n");
+    Log::PrintErr("Error: Failed to write snapshot file.\n\n");
   }
   delete file;
 }
 
 
 class UriResolverIsolateScope {
  public:
   UriResolverIsolateScope() {
     ASSERT(isolate != NULL);
     snapshotted_isolate_ = Dart_CurrentIsolate();
@@ skipping 272 matching lines @@
     Dart_ExitScope();
     Dart_ShutdownIsolate();
     exit(255);
   }
   ASSERT(Dart_IsLibrary(library));
 }
 
 
 static void CreateAndWriteSnapshot() {
   Dart_Handle result;
-  uint8_t* buffer = NULL;
-  intptr_t size = 0;
+  uint8_t* vm_isolate_buffer = NULL;
+  intptr_t vm_isolate_size = 0;
+  uint8_t* isolate_buffer = NULL;
+  intptr_t isolate_size = 0;
 
   // First create a snapshot.
-  result = Dart_CreateSnapshot(&buffer, &size);
+  result = Dart_CreateSnapshot(&vm_isolate_buffer,
+                               &vm_isolate_size,
+                               &isolate_buffer,
+                               &isolate_size);
   CHECK_RESULT(result);
 
-  // Now write the snapshot out to specified file and exit.
-  WriteSnapshotFile(buffer, size);
+  // 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);
   Dart_ExitScope();
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 }
 
 
 static void SetupForUriResolution() {
   // Set up the library tag handler for this isolate.
   Dart_Handle result = Dart_SetLibraryTagHandler(DartUtils::LibraryTagHandler);
@@ skipping 43 matching lines @@
   }
 
   Thread::InitOnce();
   DartUtils::SetOriginalWorkingDirectory();
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Initialize the Dart VM.
   // Note: We don't expect isolates to be created from dart code during
   // snapshot generation.
-  if (!Dart_Initialize(NULL, NULL, NULL, NULL,
+  if (!Dart_Initialize(NULL,
+                       NULL, NULL, NULL, NULL,
                        DartUtils::OpenFile,
                        DartUtils::ReadFile,
                        DartUtils::WriteFile,
                        DartUtils::CloseFile,
                        DartUtils::EntropySource)) {
     Log::PrintErr("VM initialization failed\n");
     return 255;
   }
 
   char* error;
   Dart_Isolate isolate = Dart_CreateIsolate(NULL, NULL, NULL, NULL, &error);
   if (isolate == NULL) {
     Log::PrintErr("Error: %s", error);
     free(error);
     exit(255);
   }
 
   Dart_Handle result;
   Dart_Handle library;
   Dart_EnterScope();
 
-  ASSERT(snapshot_filename != NULL);
+  ASSERT(vm_isolate_snapshot_filename != NULL);
+  ASSERT(isolate_snapshot_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();
 
     // Get handle to builtin library.
@@ skipping 43 matching lines @@
   }
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }