Simplify command line options for creating snapshots.

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 34 matching lines @@
  * Global state used to control and store generation of application snapshots
  * (script/full).
  * A full application snapshot can be generated and run using the following
  * commands
  * - Generating a full application snapshot :
  * dart_bootstrap --full-snapshot-after-run=<filename> --package-root=<dirs>
  *   <script_uri> [<script_options>]
  * - Running the full application snapshot generated above :
  * dart --run-full-snapshot=<filename> <script_uri> [<script_options>]
  */
-static bool generate_script_snapshot = false;
-static bool generate_full_snapshot_after_run = false;
-static bool run_full_snapshot = false;
+static bool run_app_snapshot = false;
 static const char* snapshot_filename = NULL;
+enum SnapshotKind {
+  kNone,
+  kScript,
+  kAppAOT,
+  kAppJITAfterRun,
+  kAppAfterRun,
+};
+static SnapshotKind gen_snapshot_kind = kNone;
 
 // 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.)
 static const char* commandline_packages_file = NULL;
 
 
 // Global flag that is used to indicate that we want to compile all the
 // dart functions and not run anything.
 static bool compile_all = false;
 
 
-// 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;
-static bool gen_precompiled_jit_snapshot = false;
-
-
-// Global flag that is used to indicate that we want to run from a precompiled
-// snapshot.
-static bool run_precompiled_snapshot = false;
-static bool run_precompiled_jit_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* 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";
+
+static const char* kVMIsolateSuffix = "snapshot.vmisolate";
+static const char* kIsolateSuffix = "snapshot.isolate";
+static const char* kAssemblySuffix = "snapshot.S";
+static const char* kInstructionsSuffix = "snapshot.instructions";
+static const char* kRODataSuffix = "snapshot.rodata";
+
 
 // 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;
 // VM Service options.
 static const char* vm_service_server_ip = DEFAULT_VM_SERVICE_SERVER_IP;
@@ skipping 209 matching lines @@
                                   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] == ':')) {
-    precompiled_snapshot_directory = &arg[1];
-  } else {
-    precompiled_snapshot_directory = arg;
-  }
-  gen_precompiled_snapshot = true;
-  vm_options->AddArgument("--precompilation");
-  return true;
-#endif  // defined(DART_PRECOMPILER)
-}
-
-
-static bool ProcessGenPrecompiledJITSnapshotOption(
-    const char* arg,
-    CommandLineOptions* vm_options) {
-  ASSERT(arg != NULL);
-  if ((arg[0] == '=') || (arg[0] == ':')) {
-    precompiled_snapshot_directory = &arg[1];
-  } else {
-    precompiled_snapshot_directory = arg;
-  }
-  gen_precompiled_jit_snapshot = true;
-  return true;
-}
-
-
-static bool ProcessRunPrecompiledSnapshotOption(
-    const char* arg,
-    CommandLineOptions* vm_options) {
-  ASSERT(arg != NULL);
-  precompiled_snapshot_directory = arg;
-  if ((precompiled_snapshot_directory[0] == '=') ||
-      (precompiled_snapshot_directory[0] == ':')) {
-    precompiled_snapshot_directory = &precompiled_snapshot_directory[1];
-  }
-  run_precompiled_snapshot = true;
-  vm_options->AddArgument("--precompilation");
-  return true;
-}
-
-
-static bool ProcessRunPrecompiledJITSnapshotOption(
-    const char* arg,
-    CommandLineOptions* vm_options) {
-  ASSERT(arg != NULL);
-  precompiled_snapshot_directory = arg;
-  if ((precompiled_snapshot_directory[0] == '=') ||
-      (precompiled_snapshot_directory[0] == ':')) {
-    precompiled_snapshot_directory = &precompiled_snapshot_directory[1];
-  }
-  run_precompiled_jit_snapshot = true;
-  return true;
-}
-
-
-static bool ProcessSnapshotOptionHelper(const char* filename,
-                                        bool* snapshot_option) {
-  ASSERT((filename != NULL) && (strlen(filename) != 0));
+static bool ProcessSnapshotFilenameOption(const char* filename,
+                                          CommandLineOptions* vm_options) {
   snapshot_filename = filename;
-  *snapshot_option = true;
-  if (generate_script_snapshot && generate_full_snapshot_after_run) {
-    Log::PrintErr("--snapshot and --snapshot-after-run options"
-                  " cannot be specified at the same time\n");
-    *snapshot_option = false;
-    return false;
+  if (gen_snapshot_kind == kNone) {
+    gen_snapshot_kind = kScript;  // Default behavior.
   }
   return true;
 }
 
 
-static bool ProcessScriptSnapshotOption(const char* filename,
-                                        CommandLineOptions* vm_options) {
-  if ((filename == NULL) || (strlen(filename) == 0)) {
-    return false;
+static bool ProcessSnapshotKindOption(const char* kind,
+                                      CommandLineOptions* vm_options) {
+  if (strcmp(kind, "script") == 0) {
+    gen_snapshot_kind = kScript;
+    return true;
+  } else if (strcmp(kind, "app-aot") == 0) {
+    gen_snapshot_kind = kAppAOT;
+    return true;
+  } else if (strcmp(kind, "app-jit-after-run") == 0) {
+    gen_snapshot_kind = kAppJITAfterRun;
+    return true;
+  } else if (strcmp(kind, "app-after-run") == 0) {
+    gen_snapshot_kind = kAppAfterRun;
+    return true;
   }
-  // Ensure that we are already running using a full snapshot.
-  if (isolate_snapshot_buffer == NULL) {
-    Log::PrintErr("Script snapshots cannot be generated in this version of"
-                  " Dart\n");
-    return false;
-  }
-  return ProcessSnapshotOptionHelper(filename, &generate_script_snapshot);
+  Log::PrintErr("Unrecognized snapshot kind: '%s'\nValid kinds are: "
+                "script, app-aot, app-jit-after-run, app-after-run\n", kind);
+  return false;
 }
 
 
-static bool ProcessFullSnapshotAfterRunOption(
+static bool ProcessRunAppSnapshotOption(
     const char* filename, CommandLineOptions* vm_options) {
-  if ((filename == NULL) || (strlen(filename) == 0)) {
-    return false;
-  }
-  // Ensure that we are running 'dart_bootstrap'.
-  if (isolate_snapshot_buffer != NULL) {
-    Log::PrintErr("Full Application snapshots must be generated with"
-                  " dart_bootstrap\n");
-    return false;
-  }
-  return ProcessSnapshotOptionHelper(filename,
-                                     &generate_full_snapshot_after_run);
+  ASSERT(filename != NULL);
+  snapshot_filename = filename;
+  run_app_snapshot = true;
+  return true;
 }
 
 
-static bool ProcessRunFullSnapshotOption(
-    const char* filename, CommandLineOptions* vm_options) {
-#if !defined(PRODUCT)
-  Log::PrintErr("Full Application snapshots can only be be run with"
-                " product mode\n");
-  return false;
-#else
-  return ProcessSnapshotOptionHelper(filename, &run_full_snapshot);
-#endif  // defined(PRODUCT)
-}
-
-
 static bool ProcessEnableVmServiceOption(const char* option_value,
                                          CommandLineOptions* vm_options) {
   ASSERT(option_value != NULL);
 
   if (!ExtractPortAndIP(option_value,
                         &vm_service_server_port,
                         &vm_service_server_ip,
                         DEFAULT_VM_SERVICE_SERVER_PORT,
                         DEFAULT_VM_SERVICE_SERVER_IP)) {
     Log::PrintErr("unrecognized --enable-vm-service option syntax. "
@@ skipping 73 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 },
-  { "--gen-precompiled-jit-snapshot", ProcessGenPrecompiledJITSnapshotOption },
   { "--observe", ProcessObserveOption },
-  { "--run-precompiled-snapshot", ProcessRunPrecompiledSnapshotOption },
-  { "--run-precompiled-jit-snapshot", ProcessRunPrecompiledJITSnapshotOption },
   { "--shutdown", ProcessShutdownOption },
-  { "--snapshot=", ProcessScriptSnapshotOption },
-  { "--full-snapshot-after-run=", ProcessFullSnapshotAfterRunOption },
-  { "--run-full-snapshot=", ProcessRunFullSnapshotOption },
+  { "--snapshot=", ProcessSnapshotFilenameOption },
+  { "--snapshot-kind=", ProcessSnapshotKindOption },
+  { "--run-app-snapshot=", ProcessRunAppSnapshotOption },
+  { "--use-blobs", ProcessUseBlobsOption },
   { "--trace-loading", ProcessTraceLoadingOption },
   { NULL, NULL }
 };
 
 
 static bool ProcessMainOptions(const char* option,
                                CommandLineOptions* vm_options) {
   int i = 0;
   const char* name = main_options[0].option_name;
   int option_length = strlen(option);
@@ skipping 96 matching lines @@
     i++;
   }
 
   // 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 (is_noopt) {
-    if (gen_precompiled_snapshot) {
-      Log::PrintErr("Running dart_noopt with --gen_precompiled_snapshot"
-                    " is invalid.\n");
-      return -1;
-    }
-    if (run_precompiled_snapshot) {
-      Log::PrintErr("Running dart_noopt with --run_precompiled_snapshot"
-                    " is invalid.\n");
-      return -1;
-    }
-  }
-  if (run_full_snapshot && run_precompiled_snapshot) {
-    Log::PrintErr("Specifying --run_full_snapshot and"
-                  " --run_precompiled_snapshot is invalid.\n");
+  if (is_noopt && gen_snapshot_kind != kNone) {
+    Log::PrintErr("Generating a snapshot with dart_noopt is invalid.\n");
     return -1;
   }
-  if ((generate_full_snapshot_after_run || gen_precompiled_snapshot) &&
-      (run_full_snapshot || run_precompiled_snapshot)) {
+  if ((gen_snapshot_kind != kNone) && (snapshot_filename == NULL)) {
+    Log::PrintErr("Generating a snapshot requires a filename (--snapshot).\n");
+    return -1;
+  }
+  if ((gen_snapshot_kind != kNone) && run_app_snapshot) {
     Log::PrintErr("Specifying an option to generate a snapshot and"
                   " run using a snapshot is invalid.\n");
     return -1;
   }
 
   return 0;
 }
 
 
 static Dart_Handle CreateRuntimeOptions(CommandLineOptions* options) {
@@ skipping 70 matching lines @@
 // Returns true on success, false on failure.
 static Dart_Isolate CreateIsolateAndSetupHelper(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);
 
+  const bool needs_load_port = !run_app_snapshot;
 #if defined(PRODUCT)
-  const bool run_service_isolate = !run_full_snapshot &&
-                                   !run_precompiled_snapshot;
+  const bool run_service_isolate = needs_load_port;
 #else
-  const bool run_service_isolate = !run_full_snapshot;
+  // Always create the service isolate in DEBUG and RELEASE modes for profiling,
+  // even if we don't need it for loading.
+  const bool run_service_isolate = true;
 #endif  // PRODUCT
   if (!run_service_isolate &&
       (strcmp(script_uri, DART_VM_SERVICE_ISOLATE_NAME) == 0)) {
-    // We do not create a service isolate when running a full application
-    // snapshot or a precompiled snapshot in product mode.
     return NULL;
   }
 
   IsolateData* isolate_data = new IsolateData(script_uri,
                                               package_root,
                                               packages_config);
   Dart_Isolate isolate = Dart_CreateIsolate(script_uri,
                                             main,
                                             isolate_snapshot_buffer,
                                             flags,
@@ skipping 11 matching lines @@
     Builtin::SetNativeResolver(Builtin::kBuiltinLibrary);
     Builtin::SetNativeResolver(Builtin::kIOLibrary);
   }
 
   // Set up the library tag handler for this isolate.
   Dart_Handle result = Dart_SetLibraryTagHandler(DartUtils::LibraryTagHandler);
   CHECK_RESULT(result);
 
   if (Dart_IsServiceIsolate(isolate)) {
     // If this is the service isolate, load embedder specific bits and return.
-    bool skip_library_load = run_precompiled_snapshot ||
-                             run_precompiled_jit_snapshot;
+    bool skip_library_load = run_app_snapshot;
     if (!VmService::Setup(vm_service_server_ip,
                           vm_service_server_port,
                           skip_library_load)) {
       *error = strdup(VmService::GetErrorMessage());
       return NULL;
     }
     if (compile_all) {
       result = Dart_CompileAll();
       CHECK_RESULT(result);
     }
     Dart_ExitScope();
     Dart_ExitIsolate();
     return isolate;
   }
 
   // Prepare builtin and other core libraries for use to resolve URIs.
   // Set up various closures, e.g: printing, timers etc.
   // Set up 'package root' for URI resolution.
   result = DartUtils::PrepareForScriptLoading(false, trace_loading);
   CHECK_RESULT(result);
 
-  if (!run_precompiled_snapshot &&
-      !run_precompiled_jit_snapshot &&
-      !run_full_snapshot) {
+  if (needs_load_port) {
     // Set up the load port provided by the service isolate so that we can
     // load scripts.
-    // With a full snapshot or a precompiled snapshot in product mode, there is
-    // no service isolate. A precompiled snapshot in release or debug mode does
-    // have the service isolate, but it doesn't use it for loading.
     result = DartUtils::SetupServiceLoadPort();
     CHECK_RESULT(result);
   }
 
   // Setup package root if specified.
   result = DartUtils::SetupPackageRoot(package_root, packages_config);
   CHECK_RESULT(result);
 
   result = Dart_SetEnvironmentCallback(EnvironmentCallback);
   CHECK_RESULT(result);
 
-  if (run_precompiled_snapshot) {
-    // No setup.
-  } else if (run_full_snapshot || run_precompiled_jit_snapshot) {
+  if (run_app_snapshot) {
     result = DartUtils::SetupIOLibrary(script_uri);
     CHECK_RESULT(result);
   } else {
     // Load the specified application script into the newly created isolate.
     result = DartUtils::LoadScript(script_uri);
     CHECK_RESULT(result);
 
     // Run event-loop and wait for script loading to complete.
     result = Dart_RunLoop();
     CHECK_RESULT(result);
@@ skipping 340 matching lines @@
   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;
   } else {
     qualified_libname = libname;
   }
   void* library = Extensions::LoadExtensionLibrary(qualified_libname);
-  if (library == NULL) {
-    Log::PrintErr("Error: Failed to load library '%s'\n", qualified_libname);
-    Platform::Exit(kErrorExitCode);
-  }
-  void* symbol = Extensions::ResolveSymbol(library, symname);
-  if (symbol == NULL) {
-    Log::PrintErr("Error: Failed to load symbol '%s'\n", symname);
-    Platform::Exit(kErrorExitCode);
-  }
   if (concat != NULL) {
     delete concat;
   }
-  return symbol;
+  if (library == NULL) {
+    return NULL;
+  }
+  return Extensions::ResolveSymbol(library, symname);
 }
 
 
 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(NULL, snapshot_filename, true, buffer, size);
 }
 
 
-static void ComputeSnapshotFilenames(const char* filename,
-                                     char** vm_snapshot_fname,
-                                     char** isolate_snapshot_fname) {
-  intptr_t len = snprintf(NULL, 0, "%s.%s", filename, kVMIsolateSuffix);
-  *vm_snapshot_fname = new char[len + 1];
-  snprintf(*vm_snapshot_fname, len + 1, "%s.%s", filename, kVMIsolateSuffix);
-
-  len = snprintf(NULL, 0, "%s.%s", filename, kIsolateSuffix);
-  *isolate_snapshot_fname = new char[len + 1];
-  snprintf(*isolate_snapshot_fname, len + 1, "%s.%s", filename, kIsolateSuffix);
-}
-
-
 static void GeneratePrecompiledSnapshot() {
   uint8_t* vm_isolate_buffer = NULL;
   intptr_t vm_isolate_size = 0;
   uint8_t* isolate_buffer = NULL;
   intptr_t isolate_size = 0;
   uint8_t* assembly_buffer = NULL;
   intptr_t assembly_size = 0;
   uint8_t* instructions_blob_buffer = NULL;
   intptr_t instructions_blob_size = 0;
   uint8_t* rodata_blob_buffer = NULL;
@@ skipping 14 matching lines @@
         &vm_isolate_buffer,
         &vm_isolate_size,
         &isolate_buffer,
         &isolate_size,
         &assembly_buffer,
         &assembly_size);
   }
   if (Dart_IsError(result)) {
     ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
   }
-  WriteSnapshotFile(precompiled_snapshot_directory,
-                    kPrecompiledVmIsolateName,
+  WriteSnapshotFile(snapshot_filename, kVMIsolateSuffix,
                     false,
                     vm_isolate_buffer,
                     vm_isolate_size);
-  WriteSnapshotFile(precompiled_snapshot_directory,
-                    kPrecompiledIsolateName,
+  WriteSnapshotFile(snapshot_filename, kIsolateSuffix,
                     false,
                     isolate_buffer,
                     isolate_size);
   if (use_blobs) {
-    WriteSnapshotFile(precompiled_snapshot_directory,
-                      kPrecompiledInstructionsBlobName,
+    WriteSnapshotFile(snapshot_filename, kInstructionsSuffix,
                       false,
                       instructions_blob_buffer,
                       instructions_blob_size);
-    WriteSnapshotFile(precompiled_snapshot_directory,
-                      kPrecompiledRodataBlobName,
+    WriteSnapshotFile(snapshot_filename, kRODataSuffix,
                       false,
                       rodata_blob_buffer,
                       rodata_blob_size);
   } else {
-    WriteSnapshotFile(precompiled_snapshot_directory,
-                      kPrecompiledAssemblyName,
+    WriteSnapshotFile(snapshot_filename, kAssemblySuffix,
                       false,
                       assembly_buffer,
                       assembly_size);
   }
 }
 
 
 static void GeneratePrecompiledJITSnapshot() {
+  if (!use_blobs) {
+    ErrorExit(kErrorExitCode,
+              "Generating app JIT snapshots as assembly unimplemented\n");
+  }
   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;
   Dart_Handle result = Dart_CreatePrecompiledJITSnapshotBlob(
       &vm_isolate_buffer,
       &vm_isolate_size,
       &isolate_buffer,
       &isolate_size,
       &instructions_blob_buffer,
       &instructions_blob_size,
       &rodata_blob_buffer,
       &rodata_blob_size);
   if (Dart_IsError(result)) {
     ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
   }
-  WriteSnapshotFile(precompiled_snapshot_directory,
-                    kPrecompiledVmIsolateName,
+  WriteSnapshotFile(snapshot_filename, kVMIsolateSuffix,
                     false,
                     vm_isolate_buffer,
                     vm_isolate_size);
-  WriteSnapshotFile(precompiled_snapshot_directory,
-                    kPrecompiledIsolateName,
+  WriteSnapshotFile(snapshot_filename, kIsolateSuffix,
                     false,
                     isolate_buffer,
                     isolate_size);
-  WriteSnapshotFile(precompiled_snapshot_directory,
-                    kPrecompiledInstructionsBlobName,
+  WriteSnapshotFile(snapshot_filename, kInstructionsSuffix,
                     false,
                     instructions_blob_buffer,
                     instructions_blob_size);
-  WriteSnapshotFile(precompiled_snapshot_directory,
-                    kPrecompiledRodataBlobName,
+  WriteSnapshotFile(snapshot_filename, kRODataSuffix,
                     false,
                     rodata_blob_buffer,
                     rodata_blob_size);
 }
 
 
 static void GenerateFullSnapshot() {
   // Create a full snapshot of the script.
   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;
-  char* vm_snapshot_fname = NULL;
-  char* isolate_snapshot_fname = NULL;
 
   result = Dart_CreateSnapshot(&vm_isolate_buffer,
                                &vm_isolate_size,
                                &isolate_buffer,
                                &isolate_size);
   if (Dart_IsError(result)) {
     ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
   }
 
-  // Compute snapshot file names and write out the snapshot files.
-  ComputeSnapshotFilenames(snapshot_filename,
-                           &vm_snapshot_fname,
-                           &isolate_snapshot_fname);
-  WriteSnapshotFile(NULL,
-                    vm_snapshot_fname,
+  WriteSnapshotFile(snapshot_filename,
+                    kVMIsolateSuffix,
                     false,
                     vm_isolate_buffer,
                     vm_isolate_size);
-  WriteSnapshotFile(NULL,
-                    isolate_snapshot_fname,
+  WriteSnapshotFile(snapshot_filename,
+                    kIsolateSuffix,
                     false,
                     isolate_buffer,
                     isolate_size);
 }
 
 
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
     if (Dart_IsVMRestartRequest(result)) {                                     \
       Dart_ExitScope();                                                        \
@@ skipping 42 matching lines @@
   }
   delete [] isolate_name;
 
   Dart_EnterIsolate(isolate);
   ASSERT(isolate == Dart_CurrentIsolate());
   ASSERT(isolate != NULL);
   Dart_Handle result;
 
   Dart_EnterScope();
 
-  if (generate_script_snapshot) {
+  if (gen_snapshot_kind == kScript) {
     GenerateScriptSnapshot();
   } 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 !defined(PRODUCT)
-    if (is_noopt || gen_precompiled_snapshot || gen_precompiled_jit_snapshot) {
+    if (is_noopt ||
+        (gen_snapshot_kind == kAppAfterRun) ||
+        (gen_snapshot_kind == kAppAOT) ||
+        (gen_snapshot_kind == kAppJITAfterRun)) {
       // Load the embedder's portion of the VM service's Dart code so it will
-      // be included in the precompiled snapshot.
+      // be included in the app snapshot.
       if (!VmService::LoadForGenPrecompiled()) {
         fprintf(stderr,
                 "VM service loading failed: %s\n",
                 VmService::GetErrorMessage());
         fflush(stderr);
         exit(kErrorExitCode);
       }
     }
 #endif  // PRODUCT
 
     if (compile_all) {
       result = Dart_CompileAll();
       CHECK_RESULT(result);
     }
 
-    if (is_noopt || gen_precompiled_snapshot) {
+    if (is_noopt || (gen_snapshot_kind == kAppAOT)) {
       Dart_QualifiedFunctionName standalone_entry_points[] = {
         { "dart:_builtin", "::", "_getMainClosure" },
         { "dart:_builtin", "::", "_getPrintClosure" },
         { "dart:_builtin", "::", "_getUriBaseClosure" },
         { "dart:_builtin", "::", "_resolveUri" },
         { "dart:_builtin", "::", "_setWorkingDirectory" },
         { "dart:_builtin", "::", "_setPackageRoot" },
         { "dart:_builtin", "::", "_loadPackagesMap" },
         { "dart:_builtin", "::", "_loadDataAsync" },
         { "dart:io", "::", "_makeUint8ListView" },
@@ skipping 14 matching lines @@
         { "dart:io", "_ProcessStartStatus", "set:_errorCode" },
         { "dart:io", "_ProcessStartStatus", "set:_errorMessage" },
         { "dart:io", "_SecureFilterImpl", "get:ENCRYPTED_SIZE" },
         { "dart:io", "_SecureFilterImpl", "get:SIZE" },
 #if !defined(PRODUCT)
         { "dart:vmservice_io", "::", "main" },
 #endif  // !PRODUCT
         { NULL, NULL, NULL }  // Must be terminated with NULL entries.
       };
 
-      const bool reset_fields = gen_precompiled_snapshot;
+      const bool reset_fields = gen_snapshot_kind == kAppAOT;
       result = Dart_Precompile(standalone_entry_points, reset_fields);
       CHECK_RESULT(result);
     }
 
-    if (gen_precompiled_snapshot) {
+    if (gen_snapshot_kind == kAppAOT) {
       GeneratePrecompiledSnapshot();
     } 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
@@ skipping 11 matching lines @@
 
       Dart_Handle isolate_lib =
           Dart_LookupLibrary(Dart_NewStringFromCString("dart:isolate"));
       result = Dart_Invoke(isolate_lib,
                            Dart_NewStringFromCString("_startMainIsolate"),
                            kNumIsolateArgs, isolate_args);
       CHECK_RESULT(result);
 
       // Keep handling messages until the last active receive port is closed.
       result = Dart_RunLoop();
-      // Generate a full snapshot after execution if specified.
-      if (generate_full_snapshot_after_run || gen_precompiled_jit_snapshot) {
+      // Generate an app snapshot after execution if specified.
+      if ((gen_snapshot_kind == kAppAfterRun) ||
+          (gen_snapshot_kind == kAppJITAfterRun)) {
         if (!Dart_IsCompilationError(result) &&
             !Dart_IsVMRestartRequest(result)) {
-          if (generate_full_snapshot_after_run) {
+          if (gen_snapshot_kind == kAppAfterRun) {
             GenerateFullSnapshot();
           } else {
             Dart_Handle prepare_result = Dart_PrecompileJIT();
             CHECK_RESULT(prepare_result);
             GeneratePrecompiledJITSnapshot();
           }
         }
       }
       CHECK_RESULT(result);
     }
@@ skipping 143 matching lines @@
 
   Thread::InitOnce();
 
   if (!DartUtils::SetOriginalWorkingDirectory()) {
     OSError err;
     fprintf(stderr, "Error determining current directory: %s\n", err.message());
     fflush(stderr);
     Platform::Exit(kErrorExitCode);
   }
 
-#if !defined(PRODUCT)
-  // Constant true in PRODUCT mode.
-  if (generate_script_snapshot ||
-      generate_full_snapshot_after_run ||
-      run_full_snapshot ||
-      gen_precompiled_jit_snapshot ||
-      run_precompiled_jit_snapshot) {
+#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
+  // Constant true if PRODUCT or DART_PRECOMPILED_RUNTIME.
+  if ((gen_snapshot_kind != kNone) || run_app_snapshot) {
     vm_options.AddArgument("--load_deferred_eagerly");
   }
 #endif
 
-#if defined(DART_PRECOMPILER) && !defined(DART_NO_SNAPSHOT)
-  // Always set --precompilation with dart_noopt.
-  ASSERT(!gen_precompiled_snapshot && !run_precompiled_snapshot);
+  if ((gen_snapshot_kind == kAppAOT) || is_noopt) {
+    vm_options.AddArgument("--precompilation");
+  }
+#if defined(DART_PRECOMPILED_RUNTIME)
   vm_options.AddArgument("--precompilation");
 #endif
 
   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 || run_precompiled_jit_snapshot) {
-    ReadSnapshotFile(precompiled_snapshot_directory,
-                     kPrecompiledVmIsolateName,
+  if (run_app_snapshot) {
+    ReadSnapshotFile(snapshot_filename, kVMIsolateSuffix,
                      &vm_isolate_snapshot_buffer);
-    ReadSnapshotFile(precompiled_snapshot_directory,
-                     kPrecompiledIsolateName,
+    ReadSnapshotFile(snapshot_filename, kIsolateSuffix,
                      &isolate_snapshot_buffer);
     if (use_blobs) {
-      ReadExecutableSnapshotFile(precompiled_snapshot_directory,
-                                 kPrecompiledInstructionsBlobName,
+      ReadExecutableSnapshotFile(snapshot_filename,
+                                 kInstructionsSuffix,
                                  &instructions_snapshot);
-      ReadSnapshotFile(precompiled_snapshot_directory,
-                       kPrecompiledRodataBlobName,
+      ReadSnapshotFile(snapshot_filename, kRODataSuffix,
                        &data_snapshot);
     } else {
       instructions_snapshot = reinterpret_cast<const uint8_t*>(
-          LoadLibrarySymbol(precompiled_snapshot_directory,
+          LoadLibrarySymbol(snapshot_filename,
                             kPrecompiledLibraryName,
                             kPrecompiledInstructionsSymbolName));
       data_snapshot = reinterpret_cast<const uint8_t*>(
-          LoadLibrarySymbol(precompiled_snapshot_directory,
+          LoadLibrarySymbol(snapshot_filename,
                             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);
-    ReadSnapshotFile(NULL, isolate_snapshot_fname, &isolate_snapshot_buffer);
-    delete vm_snapshot_fname;
-    delete isolate_snapshot_fname;
   }
 
   // Initialize the Dart VM.
   char* error = Dart_Initialize(
       vm_isolate_snapshot_buffer, instructions_snapshot, data_snapshot,
       CreateIsolateAndSetup, NULL, NULL, ShutdownIsolate,
       NULL,
       DartUtils::OpenFile,
       DartUtils::ReadFile,
       DartUtils::WriteFile,
@@ skipping 53 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }