Factor out snapshot helpers from main.cc.

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"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/directory.h"
 #include "bin/embedded_dart_io.h"
+#include "bin/error_exit.h"
 #include "bin/eventhandler.h"
 #include "bin/extensions.h"
 #include "bin/file.h"
 #include "bin/isolate_data.h"
 #include "bin/loader.h"
 #include "bin/log.h"
 #include "bin/platform.h"
 #include "bin/process.h"
+#include "bin/snapshot_utils.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 #include "bin/vmservice_impl.h"
 #include "platform/globals.h"
 #include "platform/hashmap.h"
 #include "platform/text_buffer.h"
 #if !defined(DART_PRECOMPILER)
 #include "zlib/zlib.h"
 #endif
 
@@ skipping 54 matching lines @@
 // dart functions and not run anything.
 static bool compile_all = false;
 static bool parse_all = 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;
 
 
-extern const char* kVmSnapshotDataSymbolName;
-extern const char* kVmSnapshotInstructionsSymbolName;
-extern const char* kIsolateSnapshotDataSymbolName;
-extern const char* kIsolateSnapshotInstructionsSymbolName;
-
-
 // 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 char* app_script_uri = NULL;
 static const uint8_t* app_isolate_snapshot_data = NULL;
 static const uint8_t* app_isolate_snapshot_instructions = NULL;
 
 
 static Dart_Isolate main_isolate = NULL;
 
 
 static const char* DEFAULT_VM_SERVICE_SERVER_IP = "localhost";
 static const int DEFAULT_VM_SERVICE_SERVER_PORT = 8181;
 // VM Service options.
 static const char* vm_service_server_ip = DEFAULT_VM_SERVICE_SERVER_IP;
 // The 0 port is a magic value which results in the first available port
 // being allocated.
 static int vm_service_server_port = -1;
 // True when we are running in development mode and cross origin security
 // checks are disabled.
 static bool vm_service_dev_mode = false;
 
-// Exit code indicating an internal Dart Frontend error.
-static const int kDartFrontendErrorExitCode = 252;
-// Exit code indicating an API error.
-static const int kApiErrorExitCode = 253;
-// Exit code indicating a compilation error.
-static const int kCompilationErrorExitCode = 254;
-// Exit code indicating an unhandled error that is not a compilation error.
-static const int kErrorExitCode = 255;
-// Exit code indicating a vm restart request.  Never returned to the user.
-static const int kRestartRequestExitCode = 1000;
-
-static void ErrorExit(int exit_code, const char* format, ...) {
-  va_list arguments;
-  va_start(arguments, format);
-  Log::VPrintErr(format, arguments);
-  va_end(arguments);
-
-  Dart_ExitScope();
-  Dart_ShutdownIsolate();
-
-  // Terminate process exit-code handler.
-  Process::TerminateExitCodeHandler();
-
-  char* error = Dart_Cleanup();
-  if (error != NULL) {
-    Log::PrintErr("VM cleanup failed: %s\n", error);
-    free(error);
-  }
-
-  EventHandler::Stop();
-  Platform::Exit(exit_code);
-}
-
 
 // The environment provided through the command line using -D options.
 static dart::HashMap* environment = 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));
@@ skipping 630 matching lines @@
       *exit_code = kRestartRequestExitCode;                                    \
     } else {                                                                   \
       *exit_code = kErrorExitCode;                                             \
     }                                                                          \
     Dart_ExitScope();                                                          \
     Dart_ShutdownIsolate();                                                    \
     return NULL;                                                               \
   }
 
 
-static void SnapshotOnExitHook(int64_t exit_code);
-
-
-static const int64_t kAppSnapshotHeaderSize = 5 * kInt64Size;
-static const int64_t kAppSnapshotMagicNumber = 0xf6f6dcdc;
-static const int64_t kAppSnapshotPageSize = 4 * KB;
-
-
-static bool ReadAppSnapshotBlobs(const char* script_name,
-                                 const uint8_t** vm_data_buffer,
-                                 const uint8_t** vm_instructions_buffer,
-                                 const uint8_t** isolate_data_buffer,
-                                 const uint8_t** isolate_instructions_buffer) {
-  File* file = File::Open(script_name, File::kRead);
-  if (file == NULL) {
-    return false;
-  }
-  if (file->Length() < kAppSnapshotHeaderSize) {
-    file->Release();
-    return false;
-  }
-  int64_t header[5];
-  ASSERT(sizeof(header) == kAppSnapshotHeaderSize);
-  if (!file->ReadFully(&header, kAppSnapshotHeaderSize)) {
-    file->Release();
-    return false;
-  }
-  if (header[0] != kAppSnapshotMagicNumber) {
-    file->Release();
-    return false;
-  }
-
-  int64_t vm_data_size = header[1];
-  int64_t vm_data_position =
-      Utils::RoundUp(file->Position(), kAppSnapshotPageSize);
-  int64_t vm_instructions_size = header[2];
-  int64_t vm_instructions_position = vm_data_position + vm_data_size;
-  if (vm_instructions_size != 0) {
-    vm_instructions_position =
-        Utils::RoundUp(vm_instructions_position, kAppSnapshotPageSize);
-  }
-  int64_t isolate_data_size = header[3];
-  int64_t isolate_data_position = Utils::RoundUp(
-      vm_instructions_position + vm_instructions_size, kAppSnapshotPageSize);
-  int64_t isolate_instructions_size = header[4];
-  int64_t isolate_instructions_position =
-      isolate_data_position + isolate_data_size;
-  if (isolate_instructions_size != 0) {
-    isolate_instructions_position =
-        Utils::RoundUp(isolate_instructions_position, kAppSnapshotPageSize);
-  }
-
-  if (vm_data_size != 0) {
-    *vm_data_buffer = reinterpret_cast<const uint8_t*>(
-        file->Map(File::kReadOnly, vm_data_position, vm_data_size));
-    if (vm_data_buffer == NULL) {
-      Log::PrintErr("Failed to memory map snapshot\n");
-      Platform::Exit(kErrorExitCode);
-    }
-  }
-
-  if (vm_instructions_size != 0) {
-    *vm_instructions_buffer = reinterpret_cast<const uint8_t*>(file->Map(
-        File::kReadExecute, vm_instructions_position, vm_instructions_size));
-    if (*vm_instructions_buffer == NULL) {
-      Log::PrintErr("Failed to memory map snapshot\n");
-      Platform::Exit(kErrorExitCode);
-    }
-  }
-
-  *isolate_data_buffer = reinterpret_cast<const uint8_t*>(
-      file->Map(File::kReadOnly, isolate_data_position, isolate_data_size));
-  if (isolate_data_buffer == NULL) {
-    Log::PrintErr("Failed to memory map snapshot\n");
+static void SnapshotOnExitHook(int64_t exit_code) {
+  if (Dart_CurrentIsolate() != main_isolate) {
+    Log::PrintErr(
+        "A snapshot was requested, but a secondary isolate "
+        "performed a hard exit (%" Pd64 ").\n",
+        exit_code);
     Platform::Exit(kErrorExitCode);
   }
-
-  if (isolate_instructions_size == 0) {
-    *isolate_instructions_buffer = NULL;
-  } else {
-    *isolate_instructions_buffer = reinterpret_cast<const uint8_t*>(
-        file->Map(File::kReadExecute, isolate_instructions_position,
-                  isolate_instructions_size));
-    if (*isolate_instructions_buffer == NULL) {
-      Log::PrintErr("Failed to memory map snapshot\n");
-      Platform::Exit(kErrorExitCode);
-    }
+  if (exit_code == 0) {
+    Snapshot::GenerateAppJIT(snapshot_filename);
   }
-
-  file->Release();
-  return true;
 }
 
 
-#if defined(DART_PRECOMPILED_RUNTIME)
-static bool ReadAppSnapshotDynamicLibrary(
-    const char* script_name,
-    const uint8_t** vm_data_buffer,
-    const uint8_t** vm_instructions_buffer,
-    const uint8_t** isolate_data_buffer,
-    const uint8_t** isolate_instructions_buffer) {
-  void* library = Extensions::LoadExtensionLibrary(script_name);
-  if (library == NULL) {
-    return false;
-  }
-
-  *vm_data_buffer = reinterpret_cast<const uint8_t*>(
-      Extensions::ResolveSymbol(library, kVmSnapshotDataSymbolName));
-  if (*vm_data_buffer == NULL) {
-    Log::PrintErr("Failed to resolve symbol '%s'\n", kVmSnapshotDataSymbolName);
-    Platform::Exit(kErrorExitCode);
-  }
-
-  *vm_instructions_buffer = reinterpret_cast<const uint8_t*>(
-      Extensions::ResolveSymbol(library, kVmSnapshotInstructionsSymbolName));
-  if (*vm_instructions_buffer == NULL) {
-    Log::PrintErr("Failed to resolve symbol '%s'\n",
-                  kVmSnapshotInstructionsSymbolName);
-    Platform::Exit(kErrorExitCode);
-  }
-
-  *isolate_data_buffer = reinterpret_cast<const uint8_t*>(
-      Extensions::ResolveSymbol(library, kIsolateSnapshotDataSymbolName));
-  if (*isolate_data_buffer == NULL) {
-    Log::PrintErr("Failed to resolve symbol '%s'\n",
-                  kIsolateSnapshotDataSymbolName);
-    Platform::Exit(kErrorExitCode);
-  }
-
-  *isolate_instructions_buffer =
-      reinterpret_cast<const uint8_t*>(Extensions::ResolveSymbol(
-          library, kIsolateSnapshotInstructionsSymbolName));
-  if (*isolate_instructions_buffer == NULL) {
-    Log::PrintErr("Failed to resolve symbol '%s'\n",
-                  kIsolateSnapshotInstructionsSymbolName);
-    Platform::Exit(kErrorExitCode);
-  }
-
-  return true;
-}
-#endif  // defined(DART_PRECOMPILED_RUNTIME)
-
-
-static bool ReadAppSnapshot(const char* script_name,
-                            const uint8_t** vm_data_buffer,
-                            const uint8_t** vm_instructions_buffer,
-                            const uint8_t** isolate_data_buffer,
-                            const uint8_t** isolate_instructions_buffer) {
-  if (File::GetType(script_name, true) != File::kIsFile) {
-    // If 'script_name' refers to a pipe, don't read to check for an app
-    // snapshot since we cannot rewind if it isn't (and couldn't mmap it in
-    // anyway if it was).
-    return false;
-  }
-  if (ReadAppSnapshotBlobs(script_name, vm_data_buffer, vm_instructions_buffer,
-                           isolate_data_buffer, isolate_instructions_buffer)) {
-    return true;
-  }
-#if defined(DART_PRECOMPILED_RUNTIME)
-  // For testing AOT with the standalone embedder, we also support loading
-  // from a dynamic library to simulate what happens on iOS.
-  return ReadAppSnapshotDynamicLibrary(
-      script_name, vm_data_buffer, vm_instructions_buffer, isolate_data_buffer,
-      isolate_instructions_buffer);
-#else
-  return false;
-#endif  //  defined(DART_PRECOMPILED_RUNTIME)
-}
-
-
 // Returns newly created Isolate on success, NULL on failure.
 static Dart_Isolate CreateIsolateAndSetupHelper(bool is_main_isolate,
                                                 const char* script_uri,
                                                 const char* main,
                                                 const char* package_root,
                                                 const char* packages_config,
                                                 Dart_IsolateFlags* flags,
                                                 char** error,
                                                 int* exit_code) {
   ASSERT(script_uri != NULL);
@@ skipping 29 matching lines @@
       (is_main_isolate || ((app_script_uri != NULL) &&
                            (strcmp(script_uri, app_script_uri) == 0)))) {
     isolate_run_app_snapshot = true;
     isolate_snapshot_data = app_isolate_snapshot_data;
     isolate_snapshot_instructions = app_isolate_snapshot_instructions;
   } else if (!is_main_isolate) {
     const uint8_t* file_vm_snapshot_data = NULL;
     const uint8_t* file_vm_snapshot_instructions = NULL;
     const uint8_t* file_isolate_snapshot_data = NULL;
     const uint8_t* file_isolate_snapshot_instructions = NULL;
-    if (ReadAppSnapshot(
+    if (Snapshot::ReadAppSnapshot(
             script_uri, &file_vm_snapshot_data, &file_vm_snapshot_instructions,
             &file_isolate_snapshot_data, &file_isolate_snapshot_instructions)) {
       // TODO(rmacnak): We are leaking the snapshot when the isolate shuts down.
       isolate_run_app_snapshot = true;
       isolate_snapshot_data = file_isolate_snapshot_data;
       isolate_snapshot_instructions = file_isolate_snapshot_instructions;
     }
   }
 #endif
 
@@ skipping 414 matching lines @@
   int64_t data[File::kStatSize];
   File::Stat(url + 7, data);
   if (data[File::kType] == File::kDoesNotExist) {
     return true;
   }
   bool modified = data[File::kModifiedTime] > since;
   return modified;
 }
 
 
-static void WriteSnapshotFile(const char* filename,
-                              bool write_magic_number,
-                              const uint8_t* buffer,
-                              const intptr_t size) {
-  char* concat = NULL;
-  File* file = File::Open(filename, File::kWriteTruncate);
-  if (file == NULL) {
-    ErrorExit(kErrorExitCode, "Unable to open file %s for writing snapshot\n",
-              filename);
-  }
-
-  if (write_magic_number) {
-    // Write the magic number to indicate file is a script snapshot.
-    DartUtils::WriteMagicNumber(file);
-  }
-
-  if (!file->WriteFully(buffer, size)) {
-    ErrorExit(kErrorExitCode, "Unable to write file %s for writing snapshot\n",
-              filename);
-  }
-  file->Release();
-  if (concat != NULL) {
-    delete concat;
-  }
-}
-
-
-static bool WriteInt64(File* file, int64_t size) {
-  return file->WriteFully(&size, sizeof(size));
-}
-
-
-static void WriteAppSnapshot(const char* filename,
-                             uint8_t* vm_data_buffer,
-                             intptr_t vm_data_size,
-                             uint8_t* vm_instructions_buffer,
-                             intptr_t vm_instructions_size,
-                             uint8_t* isolate_data_buffer,
-                             intptr_t isolate_data_size,
-                             uint8_t* isolate_instructions_buffer,
-                             intptr_t isolate_instructions_size) {
-  File* file = File::Open(filename, File::kWriteTruncate);
-  if (file == NULL) {
-    ErrorExit(kErrorExitCode, "Unable to write snapshot file '%s'\n", filename);
-  }
-
-  file->WriteFully(&kAppSnapshotMagicNumber, sizeof(kAppSnapshotMagicNumber));
-  WriteInt64(file, vm_data_size);
-  WriteInt64(file, vm_instructions_size);
-  WriteInt64(file, isolate_data_size);
-  WriteInt64(file, isolate_instructions_size);
-  ASSERT(file->Position() == kAppSnapshotHeaderSize);
-
-  file->SetPosition(Utils::RoundUp(file->Position(), kAppSnapshotPageSize));
-  if (!file->WriteFully(vm_data_buffer, vm_data_size)) {
-    ErrorExit(kErrorExitCode, "Unable to write snapshot file '%s'\n", filename);
-  }
-
-  if (vm_instructions_size != 0) {
-    file->SetPosition(Utils::RoundUp(file->Position(), kAppSnapshotPageSize));
-    if (!file->WriteFully(vm_instructions_buffer, vm_instructions_size)) {
-      ErrorExit(kErrorExitCode, "Unable to write snapshot file '%s'\n",
-                filename);
-    }
-  }
-
-  file->SetPosition(Utils::RoundUp(file->Position(), kAppSnapshotPageSize));
-  if (!file->WriteFully(isolate_data_buffer, isolate_data_size)) {
-    ErrorExit(kErrorExitCode, "Unable to write snapshot file '%s'\n", filename);
-  }
-
-  if (isolate_instructions_size != 0) {
-    file->SetPosition(Utils::RoundUp(file->Position(), kAppSnapshotPageSize));
-    if (!file->WriteFully(isolate_instructions_buffer,
-                          isolate_instructions_size)) {
-      ErrorExit(kErrorExitCode, "Unable to write snapshot file '%s'\n",
-                filename);
-    }
-  }
-
-  file->Flush();
-  file->Release();
-}
-
-
-static void GenerateScriptSnapshot() {
-  // First create a snapshot.
-  uint8_t* buffer = NULL;
-  intptr_t size = 0;
-  Dart_Handle result = Dart_CreateScriptSnapshot(&buffer, &size);
-  if (Dart_IsError(result)) {
-    ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
-  }
-
-  WriteSnapshotFile(snapshot_filename, true, buffer, size);
-}
-
-
-static void GenerateAppAOTSnapshotAsBlobs() {
-  uint8_t* vm_data_buffer = NULL;
-  intptr_t vm_data_size = 0;
-  uint8_t* vm_instructions_buffer = NULL;
-  intptr_t vm_instructions_size = 0;
-  uint8_t* isolate_data_buffer = NULL;
-  intptr_t isolate_data_size = 0;
-  uint8_t* isolate_instructions_buffer = NULL;
-  intptr_t isolate_instructions_size = 0;
-  Dart_Handle result = Dart_CreateAppAOTSnapshotAsBlobs(
-      &vm_data_buffer, &vm_data_size, &vm_instructions_buffer,
-      &vm_instructions_size, &isolate_data_buffer, &isolate_data_size,
-      &isolate_instructions_buffer, &isolate_instructions_size);
-  if (Dart_IsError(result)) {
-    ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
-  }
-  WriteAppSnapshot(snapshot_filename, vm_data_buffer, vm_data_size,
-                   vm_instructions_buffer, vm_instructions_size,
-                   isolate_data_buffer, isolate_data_size,
-                   isolate_instructions_buffer, isolate_instructions_size);
-}
-
-static void GenerateAppAOTSnapshotAsAssembly() {
-  uint8_t* assembly_buffer = NULL;
-  intptr_t assembly_size = 0;
-  Dart_Handle result =
-      Dart_CreateAppAOTSnapshotAsAssembly(&assembly_buffer, &assembly_size);
-  if (Dart_IsError(result)) {
-    ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
-  }
-  WriteSnapshotFile(snapshot_filename, false, assembly_buffer, assembly_size);
-}
-
-
 static void GenerateAppAOTSnapshot() {
   if (use_blobs) {
-    GenerateAppAOTSnapshotAsBlobs();
+    Snapshot::GenerateAppAOTAsBlobs(snapshot_filename);
   } else {
-    GenerateAppAOTSnapshotAsAssembly();
+    Snapshot::GenerateAppAOTAsAssembly(snapshot_filename);
   }
 }
 
 
-static void GenerateAppJITSnapshot() {
-#if defined(TARGET_ARCH_X64)
-  uint8_t* isolate_data_buffer = NULL;
-  intptr_t isolate_data_size = 0;
-  uint8_t* isolate_instructions_buffer = NULL;
-  intptr_t isolate_instructions_size = 0;
-  Dart_Handle result = Dart_CreateAppJITSnapshotAsBlobs(
-      &isolate_data_buffer, &isolate_data_size, &isolate_instructions_buffer,
-      &isolate_instructions_size);
-  if (Dart_IsError(result)) {
-    ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
-  }
-  WriteAppSnapshot(snapshot_filename, NULL, 0, NULL, 0, isolate_data_buffer,
-                   isolate_data_size, isolate_instructions_buffer,
-                   isolate_instructions_size);
-#else
-  uint8_t* isolate_buffer = NULL;
-  intptr_t isolate_size = 0;
-
-  Dart_Handle result =
-      Dart_CreateSnapshot(NULL, NULL, &isolate_buffer, &isolate_size);
-  if (Dart_IsError(result)) {
-    ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
-  }
-
-  WriteAppSnapshot(snapshot_filename, NULL, 0, NULL, 0, isolate_buffer,
-                   isolate_size, NULL, 0);
-#endif  // defined(TARGET_ARCH_X64)
-}
-
-
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
     if (Dart_IsVMRestartRequest(result)) {                                     \
       Dart_ExitScope();                                                        \
       Dart_ShutdownIsolate();                                                  \
       return true;                                                             \
     }                                                                          \
     const int exit_code = Dart_IsCompilationError(result)                      \
                               ? kCompilationErrorExitCode                      \
                               : kErrorExitCode;                                \
     ErrorExit(exit_code, "%s\n", Dart_GetError(result));                       \
   }
 
 
-static void SnapshotOnExitHook(int64_t exit_code) {
-  if (Dart_CurrentIsolate() != main_isolate) {
-    Log::PrintErr(
-        "A snapshot was requested, but a secondary isolate "
-        "performed a hard exit (%" Pd64 ").\n",
-        exit_code);
-    Platform::Exit(kErrorExitCode);
+static void WriteFile(const char* filename,
+                      const uint8_t* buffer,
+                      const intptr_t size) {
+  File* file = File::Open(filename, File::kWriteTruncate);
+  if (file == NULL) {
+    ErrorExit(kErrorExitCode, "Unable to open file %s\n", filename);
   }
-  if (exit_code == 0) {
-    GenerateAppJITSnapshot();
+  if (!file->WriteFully(buffer, size)) {
+    ErrorExit(kErrorExitCode, "Unable to write file %s\n", filename);
   }
+  file->Release();
 }
 
 
 bool RunMainIsolate(const char* script_name, CommandLineOptions* dart_options) {
   // Call CreateIsolateAndSetup which creates an isolate and loads up
   // the specified application script.
   char* error = NULL;
   bool is_main_isolate = true;
   int exit_code = 0;
   char* isolate_name = BuildIsolateName(script_name, "main");
@@ skipping 22 matching lines @@
   delete[] isolate_name;
 
   Dart_EnterIsolate(isolate);
   ASSERT(isolate == Dart_CurrentIsolate());
   ASSERT(isolate != NULL);
   Dart_Handle result;
 
   Dart_EnterScope();
 
   if (gen_snapshot_kind == kScript) {
-    GenerateScriptSnapshot();
+    Snapshot::GenerateScript(snapshot_filename);
   } else {
     // Lookup the library of the root script.
     Dart_Handle root_lib = Dart_RootLibrary();
     // Import the root library into the builtin library so that we can easily
     // lookup the main entry point exported from the root library.
     IsolateData* isolate_data =
         reinterpret_cast<IsolateData*>(Dart_IsolateData(isolate));
     result = Dart_LibraryImportLibrary(isolate_data->builtin_lib(), root_lib,
                                        Dart_Null());
     if ((gen_snapshot_kind == kAppAOT) || (gen_snapshot_kind == kAppJIT)) {
@@ skipping 110 matching lines @@
                            Dart_NewStringFromCString("_startMainIsolate"),
                            kNumIsolateArgs, isolate_args);
       CHECK_RESULT(result);
 
       // Keep handling messages until the last active receive port is closed.
       result = Dart_RunLoop();
       // Generate an app snapshot after execution if specified.
       if (gen_snapshot_kind == kAppJIT) {
         if (!Dart_IsCompilationError(result) &&
             !Dart_IsVMRestartRequest(result)) {
-          GenerateAppJITSnapshot();
+          Snapshot::GenerateAppJIT(snapshot_filename);
         }
       }
       CHECK_RESULT(result);
 
       if (save_feedback_filename != NULL) {
         uint8_t* buffer = NULL;
         intptr_t size = 0;
         result = Dart_SaveJITFeedback(&buffer, &size);
         if (Dart_IsError(result)) {
           ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
         }
-        WriteSnapshotFile(save_feedback_filename, false, buffer, size);
+        WriteFile(save_feedback_filename, buffer, size);
       }
     }
   }
 
   Dart_ExitScope();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 
   // No restart.
   return false;
@@ skipping 130 matching lines @@
   Thread::InitOnce();
 
   Loader::InitOnce();
 
   if (!DartUtils::SetOriginalWorkingDirectory()) {
     OSError err;
     Log::PrintErr("Error determining current directory: %s\n", err.message());
     Platform::Exit(kErrorExitCode);
   }
 
-  if (ReadAppSnapshot(script_name, &vm_snapshot_data, &vm_snapshot_instructions,
-                      &app_isolate_snapshot_data,
-                      &app_isolate_snapshot_instructions)) {
+  if (Snapshot::ReadAppSnapshot(
+          script_name, &vm_snapshot_data, &vm_snapshot_instructions,
+          &app_isolate_snapshot_data, &app_isolate_snapshot_instructions)) {
     vm_run_app_snapshot = true;
   }
 
 #if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
   // Constant true if PRODUCT or DART_PRECOMPILED_RUNTIME.
   if ((gen_snapshot_kind != kNone) || vm_run_app_snapshot) {
     vm_options.AddArgument("--load_deferred_eagerly");
   }
 #endif
 
@@ skipping 85 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }