Support spawnUri in app 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 22 matching lines @@
 
 namespace dart {
 namespace bin {
 
 // vm_isolate_snapshot_buffer points to a snapshot for the vm isolate if we
 // link in a snapshot otherwise it is initialized to NULL.
 extern const uint8_t* vm_isolate_snapshot_buffer;
 
 // isolate_snapshot_buffer points to a snapshot for an isolate if we link in a
 // snapshot otherwise it is initialized to NULL.
-extern const uint8_t* isolate_snapshot_buffer;
+extern const uint8_t* const core_isolate_snapshot_buffer;
+
 
 /**
  * Global state used to control and store generation of application snapshots
  * An application snapshot can be generated and run using the following
  * command
  *   dart --snapshot-kind=app-jit --snapshot=<app_snapshot_filename>
  *       <script_uri> [<script_options>]
  * To Run the application snapshot generated above, use :
  *   dart <app_snapshot_filename> [<script_options>]
  */
-static bool run_app_snapshot = false;
+static bool vm_run_app_snapshot = false;
 static const char* snapshot_filename = NULL;
 enum SnapshotKind {
   kNone,
   kScript,
   kAppAOT,
   kAppJIT,
 };
 static SnapshotKind gen_snapshot_kind = kNone;
 
 static bool use_dart_frontend = false;
@@ skipping 36 matching lines @@
 extern const char* kPrecompiledIsolateSymbolName;
 extern const char* kPrecompiledInstructionsSymbolName;
 extern const char* kPrecompiledDataSymbolName;
 
 
 // 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_buffer = 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;
@@ skipping 595 matching lines @@
   }
   if ((commandline_packages_file != NULL) &&
       (strlen(commandline_packages_file) == 0)) {
     Log::PrintErr("Empty package file name specified.\n");
     return -1;
   }
   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) {
+  if ((gen_snapshot_kind != kNone) && vm_run_app_snapshot) {
     Log::PrintErr(
         "Specifying an option to generate a snapshot and"
         " run using a snapshot is invalid.\n");
     return -1;
   }
 
   return 0;
 }
 
 
@@ skipping 63 matching lines @@
     Dart_ExitScope();                                                          \
     Dart_ShutdownIsolate();                                                    \
     return NULL;                                                               \
   }
 
 
 static void SnapshotOnExitHook(int64_t exit_code);
 
 
 // Returns true on success, false on failure.
-static Dart_Isolate CreateIsolateAndSetupHelper(const char* script_uri,
+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);
   if (strcmp(script_uri, DART_KERNEL_ISOLATE_NAME) == 0) {
     if (!use_dart_frontend) {
       *error = strdup("Kernel isolate not supported.");
       return NULL;
     } else {
       if (packages_config == NULL) {
         packages_config = commandline_packages_file;
       }
     }
   }
 
+#if defined(DART_PRECOMPILED_RUNTIME)
+  // AOT: All isolates start from the app snapshot.
+  bool isolate_run_app_snapshot = true;
+  const uint8_t* isolate_snapshot_buffer = app_isolate_snapshot_buffer;
+#else
+  // JIT: Main isolate starts from the app snapshot, if any. Other use the
+  // core libraries snapshot.
+  bool isolate_run_app_snapshot = false;
+  const uint8_t* isolate_snapshot_buffer = core_isolate_snapshot_buffer;
+  if ((app_isolate_snapshot_buffer != NULL) &&
+      (is_main_isolate || ((app_script_uri != NULL) &&
+                           (strcmp(script_uri, app_script_uri) == 0)))) {
+    isolate_run_app_snapshot = true;
+    isolate_snapshot_buffer = app_isolate_snapshot_buffer;
+  }
+#endif
+
   // If the script is a Kernel binary, then we will try to bootstrap from the
   // script.
   const uint8_t* kernel_file = NULL;
   intptr_t kernel_length = -1;
   const bool is_kernel =
-      !run_app_snapshot &&
+      !isolate_run_app_snapshot &&
       TryReadKernel(script_uri, &kernel_file, &kernel_length);
 
   void* kernel_program = NULL;
   if (is_kernel) {
     kernel_program = Dart_ReadKernelBinary(kernel_file, kernel_length);
     free(const_cast<uint8_t*>(kernel_file));
   }
 
   IsolateData* isolate_data =
       new IsolateData(script_uri, package_root, packages_config);
@@ skipping 15 matching lines @@
 
   if (is_kernel) {
     Dart_Handle result = Dart_LoadKernel(kernel_program);
     CHECK_RESULT(result);
   }
   if (is_kernel || (isolate_snapshot_buffer != NULL)) {
     // Setup the native resolver as the snapshot does not carry it.
     Builtin::SetNativeResolver(Builtin::kBuiltinLibrary);
     Builtin::SetNativeResolver(Builtin::kIOLibrary);
   }
-  if (run_app_snapshot) {
+  if (isolate_run_app_snapshot) {
     Dart_Handle result = Loader::ReloadNativeExtensions();
     CHECK_RESULT(result);
   }
 
   if (Dart_IsServiceIsolate(isolate)) {
     // If this is the service isolate, load embedder specific bits and return.
-    bool skip_library_load = run_app_snapshot;
+    bool skip_library_load = isolate_run_app_snapshot;
     if (!VmService::Setup(vm_service_server_ip, vm_service_server_port,
                           skip_library_load, vm_service_dev_mode)) {
       *error = strdup(VmService::GetErrorMessage());
       return NULL;
     }
     if (compile_all) {
       result = Dart_CompileAll();
       CHECK_RESULT(result);
     }
     result = Dart_SetEnvironmentCallback(EnvironmentCallback);
@@ skipping 28 matching lines @@
   if (!Dart_IsKernelIsolate(isolate) && use_dart_frontend) {
     // This must be the main script to be loaded. Wait for Kernel isolate
     // to finish initialization.
     Dart_Port port = Dart_ServiceWaitForKernelPort();
     if (port == ILLEGAL_PORT) {
       *error = strdup("Error while initializing Kernel isolate");
       return NULL;
     }
   }
 
-  if (run_app_snapshot) {
+  if (isolate_run_app_snapshot) {
     result = DartUtils::SetupIOLibrary(script_uri);
     CHECK_RESULT(result);
     Loader::InitForSnapshot(script_uri);
+#if !defined(DART_PRECOMPILED_RUNTIME)
+    if (is_main_isolate) {
+      // Find the canonical uri of the app snapshot. We'll use this to decide if
+      // other isolates should use the app snapshot or the core snapshot.
+      const char* resolved_script_uri = NULL;
+      result = Dart_StringToCString(
+          DartUtils::ResolveScript(Dart_NewStringFromCString(script_uri)),
+          &resolved_script_uri);
+      CHECK_RESULT(result);
+      ASSERT(app_script_uri == NULL);
+      app_script_uri = strdup(resolved_script_uri);
+    }
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)
   } else {
     // Load the specified application script into the newly created isolate.
     Dart_Handle uri =
         DartUtils::ResolveScript(Dart_NewStringFromCString(script_uri));
     CHECK_RESULT(uri);
     if (!is_kernel) {
       result = Loader::LibraryTagHandler(Dart_kScriptTag, Dart_Null(), uri);
       CHECK_RESULT(result);
     }
 
@@ skipping 32 matching lines @@
   // The VM should never call the isolate helper with a NULL flags.
   ASSERT(flags != NULL);
   ASSERT(flags->version == DART_FLAGS_CURRENT_VERSION);
   if ((package_root != NULL) && (package_config != NULL)) {
     *error = strdup(
         "Invalid arguments - Cannot simultaneously specify "
         "package root and package map.");
     return NULL;
   }
 
+  bool is_main_isolate = false;
   int exit_code = 0;
-  return CreateIsolateAndSetupHelper(script_uri, main, package_root,
-                                     package_config, flags, error, &exit_code);
+  return CreateIsolateAndSetupHelper(is_main_isolate, script_uri, main,
+                                     package_root, package_config, flags, error,
+                                     &exit_code);
 }
 
 
 static void PrintVersion() {
   Log::PrintErr("Dart VM version: %s\n", Dart_VersionString());
 }
 
 
 // clang-format off
 static void PrintUsage() {
@@ skipping 570 matching lines @@
   if (exit_code == 0) {
     GenerateAppJITSnapshot();
   }
 }
 
 
 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");
   Dart_Isolate isolate = CreateIsolateAndSetupHelper(
-      script_name, "main", commandline_package_root, commandline_packages_file,
-      NULL, &error, &exit_code);
+      is_main_isolate, script_name, "main", commandline_package_root,
+      commandline_packages_file, NULL, &error, &exit_code);
   if (isolate == NULL) {
     delete[] isolate_name;
     if (exit_code == kRestartRequestExitCode) {
       free(error);
       return true;
     }
     Log::PrintErr("%s\n", error);
     free(error);
     error = NULL;
     Process::TerminateExitCodeHandler();
@@ skipping 305 matching lines @@
   Loader::InitOnce();
 
   if (!DartUtils::SetOriginalWorkingDirectory()) {
     OSError err;
     Log::PrintErr("Error determining current directory: %s\n", err.message());
     Platform::Exit(kErrorExitCode);
   }
 
   const uint8_t* instructions_snapshot = NULL;
   const uint8_t* data_snapshot = NULL;
-
   if (ReadAppSnapshot(script_name, &vm_isolate_snapshot_buffer,
-                      &isolate_snapshot_buffer, &instructions_snapshot,
+                      &app_isolate_snapshot_buffer, &instructions_snapshot,
                       &data_snapshot)) {
-    run_app_snapshot = true;
+    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) || run_app_snapshot) {
+  if ((gen_snapshot_kind != kNone) || vm_run_app_snapshot) {
     vm_options.AddArgument("--load_deferred_eagerly");
   }
 #endif
 
   if (gen_snapshot_kind == kAppJIT) {
     vm_options.AddArgument("--fields_may_be_reset");
 #if !defined(PRODUCT)
     vm_options.AddArgument("--collect_code=false");
 #endif
   }
@@ skipping 51 matching lines @@
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   error = Dart_Cleanup();
   if (error != NULL) {
     Log::PrintErr("VM cleanup failed: %s\n", error);
     free(error);
   }
   EventHandler::Stop();
 
+  free(app_script_uri);
+
   // Free copied argument strings if converted.
   if (argv_converted) {
     for (int i = 0; i < argc; i++) {
       free(argv[i]);
     }
   }
 
   // Free environment if any.
   if (environment != NULL) {
     for (HashMap::Entry* p = environment->Start(); p != NULL;
          p = environment->Next(p)) {
       free(p->key);
       free(p->value);
     }
     delete environment;
   }
 
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }