gen_snapshot:

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 337 matching lines @@
   }
   if (name != NULL) {
     print_dependencies = true;
     return true;
   }
   return false;
 }
 
 static bool ProcessEmbedderEntryPointsManifestOption(const char* option) {
   const char* name = ProcessOption(option, "--embedder_entry_points_manifest=");
+  if (name == NULL) {
+    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) {
+    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=");
@@ skipping 306 matching lines @@
   if (Dart_IsError(resolved_uri)) {
     return resolved_uri;
   }
   // Now load the contents of the specified uri.
   const char* resolved_uri_string = DartUtils::GetStringValue(resolved_uri);
   Dart_Handle source = LoadUrlContents(resolved_uri_string);
 
   if (Dart_IsError(source)) {
     return source;
   }
-  if (snapshot_kind == kCore) {
+  if (snapshot_kind == kCore || snapshot_kind == kCoreJIT) {
     return Dart_LoadLibrary(resolved_uri, Dart_Null(), source, 0, 0);
   } else {
     return Dart_LoadScript(resolved_uri, Dart_Null(), source, 0, 0);
   }
 }
 
 
 static Builtin::BuiltinLibraryId BuiltinId(const char* url) {
   if (DartUtils::IsDartBuiltinLibURL(url)) {
     return Builtin::kBuiltinLibrary;
@@ skipping 824 matching lines @@
                         false /* trace_loading */)) {
     *error = strdup(VmService::GetErrorMessage());
     return NULL;
   }
   Dart_ExitScope();
   Dart_ExitIsolate();
   return isolate;
 }
 
 
-static MappedMemory* MapFile(const char* filename, File::MapType type) {
+static MappedMemory* MapFile(const char* filename,
+                             File::MapType type,
+                             const uint8_t** buffer) {
   File* file = File::Open(filename, File::kRead);
   if (file == NULL) {
     Log::PrintErr("Failed to open: %s\n", filename);
     exit(kErrorExitCode);
   }
-  MappedMemory* mapping = file->Map(type, 0, file->Length());
+  intptr_t length = file->Length();
+  if (length == 0) {
+    // Can't map an empty file.
+    *buffer = NULL;
+    return NULL;
+  }
+  MappedMemory* mapping = file->Map(type, 0, length);
   if (mapping == NULL) {
-    Log::PrintErr("Failed to read: %s\n", vm_snapshot_data_filename);
+    Log::PrintErr("Failed to read: %s\n", filename);
     exit(kErrorExitCode);
   }
   file->Release();
+  *buffer = reinterpret_cast<const uint8_t*>(mapping->address());
   return mapping;
 }
 
 
 int main(int argc, char** argv) {
   const int EXTRA_VM_ARGUMENTS = 2;
   CommandLineOptions vm_options(argc + EXTRA_VM_ARGUMENTS);
 
   // Initialize the URL mapping array.
   CommandLineOptions cmdline_url_mapping(argc);
@@ skipping 51 matching lines @@
   init_params.file_write = DartUtils::WriteFile;
   init_params.file_close = DartUtils::CloseFile;
   init_params.entropy_source = DartUtils::EntropySource;
 
   MappedMemory* mapped_vm_snapshot_data = NULL;
   MappedMemory* mapped_vm_snapshot_instructions = NULL;
   MappedMemory* mapped_isolate_snapshot_data = NULL;
   MappedMemory* mapped_isolate_snapshot_instructions = NULL;
   if (snapshot_kind == kScript) {
     mapped_vm_snapshot_data =
-        MapFile(vm_snapshot_data_filename, File::kReadOnly);
-    init_params.vm_snapshot_data =
-        reinterpret_cast<const uint8_t*>(mapped_vm_snapshot_data->address());
+        MapFile(vm_snapshot_data_filename, File::kReadOnly,
+                &init_params.vm_snapshot_data);
 
     if (vm_snapshot_instructions_filename != NULL) {
       mapped_vm_snapshot_instructions =
-          MapFile(vm_snapshot_instructions_filename, File::kReadExecute);
-      init_params.vm_snapshot_instructions = reinterpret_cast<const uint8_t*>(
-          mapped_vm_snapshot_instructions->address());
+          MapFile(vm_snapshot_instructions_filename, File::kReadExecute,
+                  &init_params.vm_snapshot_instructions);
     }
 
     mapped_isolate_snapshot_data =
-        MapFile(isolate_snapshot_data_filename, File::kReadOnly);
-    isolate_snapshot_data = reinterpret_cast<const uint8_t*>(
-        mapped_isolate_snapshot_data->address());
+        MapFile(isolate_snapshot_data_filename, File::kReadOnly,
+                &isolate_snapshot_data);
 
     if (isolate_snapshot_instructions_filename != NULL) {
       mapped_isolate_snapshot_instructions =
-          MapFile(isolate_snapshot_instructions_filename, File::kReadExecute);
-      isolate_snapshot_instructions = reinterpret_cast<const uint8_t*>(
-          mapped_isolate_snapshot_instructions->address());
+          MapFile(isolate_snapshot_instructions_filename, File::kReadExecute,
+                  &isolate_snapshot_instructions);
     }
   }
 
   char* error = Dart_Initialize(&init_params);
   if (error != NULL) {
     Log::PrintErr("VM initialization failed: %s\n", error);
     free(error);
     return kErrorExitCode;
   }
 
@@ skipping 165 matching lines @@
     Dart_ExitScope();
     Dart_ShutdownIsolate();
   }
   error = Dart_Cleanup();
   if (error != NULL) {
     Log::PrintErr("VM cleanup failed: %s\n", error);
     free(error);
   }
   EventHandler::Stop();
   delete mapped_vm_snapshot_data;
+  delete mapped_vm_snapshot_instructions;
   delete mapped_isolate_snapshot_data;
+  delete mapped_isolate_snapshot_instructions;
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }