Load service isolate from the kernel binary.

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/dfe.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/service_isolate_bindata.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/growable_array.h"
 #include "platform/hashmap.h"
 #include "platform/text_buffer.h"
 #if !defined(DART_PRECOMPILER)
 #include "zlib/zlib.h"
 #endif
 
 #include "vm/kernel.h"
 
 extern "C" {
 extern const uint8_t kDartVmSnapshotData[];
 extern const uint8_t kDartVmSnapshotInstructions[];
 extern const uint8_t kDartCoreIsolateSnapshotData[];
 extern const uint8_t kDartCoreIsolateSnapshotInstructions[];
 }
 
 namespace dart {
+
+DECLARE_FLAG(bool, use_dart_frontend);

[siva, 2017/06/08 01:05:18]

This is not needed you can use dfe.UseDartFrontEnd() for this

+
 namespace bin {
 
 // Snapshot pieces if we link in a snapshot, otherwise initialized to NULL.
 #if defined(DART_NO_SNAPSHOT)
 const uint8_t* vm_snapshot_data = NULL;
 const uint8_t* vm_snapshot_instructions = NULL;
 const uint8_t* core_isolate_snapshot_data = NULL;
 const uint8_t* core_isolate_snapshot_instructions = NULL;
 #else
 const uint8_t* vm_snapshot_data = kDartVmSnapshotData;
@@ skipping 931 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 (FLAG_use_dart_frontend) {
+    ASSERT(service_isolate_kernel_bindata_size_ != 0);
+    void* kernel = Dart_ReadKernelBinary(service_isolate_kernel_bindata_,
+                                         service_isolate_kernel_bindata_size_);
+    if (kernel == NULL) {
+      *error = strdup("Could not load service isolate from kernel");
+    } else {
+      isolate = Dart_CreateIsolateFromKernel(script_uri, NULL, kernel, flags,
+                                             isolate_data, error);
+      skip_library_load = true;
+    }
+  } else {
+    isolate = Dart_CreateIsolate(script_uri, main, isolate_snapshot_data,
+                                 isolate_snapshot_instructions, flags,
+                                 isolate_data, error);
+  }
   if (isolate == NULL) {
     delete isolate_data;
     return NULL;
   }
 
   Dart_EnterScope();
 
   Dart_Handle result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
   CHECK_RESULT(result);
 
   // 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 837 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }