[vm,aot,kernel] Fix AOT snapshot creation with kernel front-end

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 <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 1029 matching lines @@
     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());
+    // Read vmservice_io kernel file independently of main thread
+    // as Dart_LoadKernel takes ownership.
+    void* kernel_vmservice_io = dfe.ReadVMServiceIO();
+    if (kernel_vmservice_io == NULL) {
+      Log::PrintErr("Could not read dart:vmservice_io binary file.");
+      Platform::Exit(kErrorExitCode);
+    }
+    // Dart_LoadKernel takes ownership.
+    Dart_Handle library = Dart_LoadKernel(kernel_vmservice_io);
     CHECK_RESULT_CLEANUP(library, isolate_data);
-    dfe.clear_kernel_vmservice_io();  // Dart_LoadKernel takes ownership.
     skip_library_load = true;
   }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
   // Load embedder specific bits and return.
   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;
@@ skipping 388 matching lines @@
   } 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)) {
-// Load the embedder's portion of the VM service's Dart code so it will
-// be included in the app snapshot.
-#if defined(DART_PRECOMPILED_RUNTIME)
-      if (!VmService::LoadForGenPrecompiled(NULL)) {
-#else
-      if (!VmService::LoadForGenPrecompiled(dfe.kernel_vmservice_io())) {
+      // Load the embedder's portion of the VM service's Dart code so it will
+      // be included in the app snapshot.
+      void* kernel_vmservice_io = NULL;
+#if !defined(DART_PRECOMPILED_RUNTIME)
+      if (dfe.UsePlatformBinary()) {
+        // Do not cache vmservice_io kernel file as
+        // VmService::LoadForGenPrecompiled takes ownership.
+        kernel_vmservice_io = dfe.ReadVMServiceIO();
+        if (kernel_vmservice_io == NULL) {
+          Log::PrintErr("Could not read dart:vmservice_io binary file.");
+          Platform::Exit(kErrorExitCode);
+        }
+      }
 #endif  // defined(DART_PRECOMPILED_RUNTIME)
+      if (!VmService::LoadForGenPrecompiled(kernel_vmservice_io)) {
         Log::PrintErr("VM service loading failed: %s\n",
                       VmService::GetErrorMessage());
-        exit(kErrorExitCode);
+        Platform::Exit(kErrorExitCode);
       }
     }
 
     if (compile_all) {
       result = Dart_CompileAll();
       CHECK_RESULT(result);
     }
 
     if (parse_all) {
       result = Dart_ParseAll();
@@ skipping 281 matching lines @@
 #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) {
+    void* kernel_platform = dfe.ReadPlatform();
+    if (kernel_platform == 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);
-    }
+    dfe.set_kernel_platform(kernel_platform);
   }
 #endif
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Start event handler.
   TimerUtils::InitOnce();
   EventHandler::Start();
 
   // Initialize the Dart VM.
@@ skipping 69 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }