Reland "Load service isolate from a .dill file."

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 808 matching lines @@
     if (value != NULL) {
       result = Dart_NewStringFromUTF8(reinterpret_cast<const uint8_t*>(value),
                                       strlen(value));
     }
     free(name_chars);
   }
   return result;
 }
 
 
+#define SAVE_ERROR_AND_EXIT(result)                                            \
+  *error = strdup(Dart_GetError(result));                                      \
+  if (Dart_IsCompilationError(result)) {                                       \
+    *exit_code = kCompilationErrorExitCode;                                    \
+  } else if (Dart_IsApiError(result)) {                                        \
+    *exit_code = kApiErrorExitCode;                                            \
+  } else {                                                                     \
+    *exit_code = kErrorExitCode;                                               \
+  }                                                                            \
+  Dart_ExitScope();                                                            \
+  Dart_ShutdownIsolate();                                                      \
+  return NULL;
+
+
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
-    *error = strdup(Dart_GetError(result));                                    \
-    if (Dart_IsCompilationError(result)) {                                     \
-      *exit_code = kCompilationErrorExitCode;                                  \
-    } else if (Dart_IsApiError(result)) {                                      \
-      *exit_code = kApiErrorExitCode;                                          \
-    } else {                                                                   \
-      *exit_code = kErrorExitCode;                                             \
-    }                                                                          \
-    Dart_ExitScope();                                                          \
-    Dart_ShutdownIsolate();                                                    \
-    return NULL;                                                               \
+    SAVE_ERROR_AND_EXIT(result);                                               \
   }
 
 
+#define CHECK_RESULT_CLEANUP(result, cleanup)                                  \
+  if (Dart_IsError(result)) {                                                  \
+    delete (cleanup);                                                          \
+    SAVE_ERROR_AND_EXIT(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);
   }
   if (exit_code == 0) {
     Snapshot::GenerateAppJIT(snapshot_filename);
@@ skipping 166 matching lines @@
                                                  const char* main,
                                                  const char* package_root,
                                                  const char* packages_config,
                                                  Dart_IsolateFlags* flags,
                                                  char** error,
                                                  int* exit_code) {
   ASSERT(script_uri != NULL);
 
 #if defined(DART_PRECOMPILED_RUNTIME)
   // AOT: All isolates start from the app snapshot.
-  bool isolate_run_app_snapshot = true;
+  bool skip_library_load = true;
   const uint8_t* isolate_snapshot_data = app_isolate_snapshot_data;
   const uint8_t* isolate_snapshot_instructions =
       app_isolate_snapshot_instructions;
 #else
   // JIT: Service isolate uses the core libraries snapshot.
-  bool isolate_run_app_snapshot = false;
+  bool skip_library_load = false;
   const uint8_t* isolate_snapshot_data = core_isolate_snapshot_data;
   const uint8_t* isolate_snapshot_instructions =
       core_isolate_snapshot_instructions;
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
+  Dart_Isolate isolate = NULL;
   IsolateData* isolate_data =
       new IsolateData(script_uri, package_root, packages_config, NULL);
-  Dart_Isolate isolate = Dart_CreateIsolate(
-      script_uri, main, isolate_snapshot_data, isolate_snapshot_instructions,
-      flags, isolate_data, error);
+#if defined(DART_PRECOMPILED_RUNTIME)
+  isolate = Dart_CreateIsolate(script_uri, main, isolate_snapshot_data,
+                               isolate_snapshot_instructions, flags,
+                               isolate_data, error);
+#else
+  if (dfe.UsePlatformBinary()) {
+    isolate = Dart_CreateIsolateFromKernel(
+        script_uri, NULL, dfe.kernel_platform(), flags, isolate_data, error);
+  } else {
+    isolate = Dart_CreateIsolate(script_uri, main, isolate_snapshot_data,
+                                 isolate_snapshot_instructions, flags,
+                                 isolate_data, error);
+  }
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)
   if (isolate == NULL) {
     delete isolate_data;
     return NULL;
   }
 
   Dart_EnterScope();
 
   Dart_Handle result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
   CHECK_RESULT(result);
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
+  if (dfe.UsePlatformBinary()) {
+    Dart_Handle library = Dart_LoadKernel(dfe.kernel_vmservice_io());
+    CHECK_RESULT_CLEANUP(library, isolate_data);
+    skip_library_load = true;
+  }
+#endif  // !defined(DART_PRECOMPILED_RUNTIME)
+
   // Load embedder specific bits and return.
-  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,
                         trace_loading)) {
     *error = strdup(VmService::GetErrorMessage());
     return NULL;
   }
   if (compile_all) {
     result = Dart_CompileAll();
     CHECK_RESULT(result);
   }
@@ skipping 755 matching lines @@
   if (gen_snapshot_kind == kAppAOT) {
     vm_options.AddArgument("--precompilation");
   }
 #if defined(DART_PRECOMPILED_RUNTIME)
   vm_options.AddArgument("--precompilation");
 #endif
   if (gen_snapshot_kind == kAppJIT) {
     Process::SetExitHook(SnapshotOnExitHook);
   }
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
+  // If a kernel platform binary file is specified, read it. This
+  // step will become redundant once we have the snapshot version
+  // of the kernel core/platform libraries.
+  if (dfe.UsePlatformBinary()) {
+    if (dfe.ReadPlatform() == NULL) {
+      Log::PrintErr("The platform binary is not a valid Dart Kernel file.");
+      Platform::Exit(kErrorExitCode);
+    }
+    if (dfe.ReadVMServiceIO() == NULL) {
+      Log::PrintErr("Could not read dart:vmservice_io binary file.");
+      Platform::Exit(kErrorExitCode);
+    }
+  }
+#endif
+
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Start event handler.
   TimerUtils::InitOnce();
   EventHandler::Start();
 
   // Initialize the Dart VM.
   Dart_InitializeParams init_params;
   memset(&init_params, 0, sizeof(init_params));
   init_params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
@@ skipping 14 matching lines @@
     EventHandler::Stop();
     Log::PrintErr("VM initialization failed: %s\n", error);
     free(error);
     Platform::Exit(kErrorExitCode);
   }
 
   Dart_SetServiceStreamCallbacks(&ServiceStreamListenCallback,
                                  &ServiceStreamCancelCallback);
   Dart_SetFileModifiedCallback(&FileModifiedCallback);
 
-#if !defined(DART_PRECOMPILED_RUNTIME)
-  // If a kernel platform binary file is specified, read it. This
-  // step will become redundant once we have the snapshot version
-  // of the kernel core/platform libraries.
-  if (dfe.UsePlatformBinary()) {
-    if (dfe.ReadPlatform() == NULL) {
-      Log::PrintErr("The platform binary is not a valid Dart Kernel file.");
-      Platform::Exit(kErrorExitCode);
-    }
-  }
-#endif
-
   // Run the main isolate until we aren't told to restart.
   while (RunMainIsolate(script_name, &dart_options)) {
     Log::PrintErr("Restarting VM\n");
   }
 
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   error = Dart_Cleanup();
   if (error != NULL) {
@@ skipping 26 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }