VM: Support bootstrapping core libraries from Kernel binaries instead of source.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "lib/stacktrace.h"
@@ skipping 1223 matching lines @@
   }
 
   char* chars = NULL;
   intptr_t len = OS::SNPrint(NULL, 0, "%s$%s", script_uri, main) + 1;
   chars = reinterpret_cast<char*>(malloc(len));
   OS::SNPrint(chars, len, "%s$%s", script_uri, main);
   return chars;
 }
 
 
-DART_EXPORT Dart_Isolate Dart_CreateIsolate(const char* script_uri,
-                                            const char* main,
-                                            const uint8_t* snapshot,
-                                            Dart_IsolateFlags* flags,
-                                            void* callback_data,
-                                            char** error) {
+static Dart_Isolate CreateIsolate(const char* script_uri,
+                                  const char* main,
+                                  const uint8_t* snapshot_buffer,
+                                  intptr_t snapshot_length,
+                                  bool from_kernel,
+                                  Dart_IsolateFlags* flags,
+                                  void* callback_data,
+                                  char** error) {
+  ASSERT(!from_kernel || (snapshot_buffer != NULL));
   CHECK_NO_ISOLATE(Isolate::Current());
   char* isolate_name = BuildIsolateName(script_uri, main);
 
   // Setup default flags in case none were passed.
   Dart_IsolateFlags api_flags;
   if (flags == NULL) {
     Isolate::FlagsInitialize(&api_flags);
     flags = &api_flags;
   }
   Isolate* I = Dart::CreateIsolate(isolate_name, *flags);
   free(isolate_name);
   if (I == NULL) {
     *error = strdup("Isolate creation failed");
     return reinterpret_cast<Dart_Isolate>(NULL);
   }
   {
     Thread* T = Thread::Current();
     StackZone zone(T);
     HANDLESCOPE(T);
     // We enter an API scope here as InitializeIsolate could compile some
     // bootstrap library files which call out to a tag handler that may create
     // Api Handles when an error is encountered.
     Dart_EnterScope();
-    const Error& error_obj =
-        Error::Handle(Z, Dart::InitializeIsolate(snapshot, callback_data));
+    const Error& error_obj = Error::Handle(
+        Z, Dart::InitializeIsolate(snapshot_buffer, snapshot_length,
+                                   from_kernel, callback_data));
     if (error_obj.IsNull()) {
 #if defined(DART_NO_SNAPSHOT) && !defined(PRODUCT)
-      if (FLAG_check_function_fingerprints) {
+      if (FLAG_check_function_fingerprints && !from_kernel) {
         Library::CheckFunctionFingerprints();
       }
 #endif  // defined(DART_NO_SNAPSHOT) && !defined(PRODUCT).
       // We exit the API scope entered above.
       Dart_ExitScope();
       // A Thread structure has been associated to the thread, we do the
       // safepoint transition explicity here instead of using the
       // TransitionXXX scope objects as the reverse transition happens
       // outside this scope in Dart_ShutdownIsolate/Dart_ExitIsolate.
       T->set_execution_state(Thread::kThreadInNative);
       T->EnterSafepoint();
       return Api::CastIsolate(I);
     }
     *error = strdup(error_obj.ToErrorCString());
     // We exit the API scope entered above.
     Dart_ExitScope();
   }
   Dart::ShutdownIsolate();
   return reinterpret_cast<Dart_Isolate>(NULL);
 }
 
 
+DART_EXPORT Dart_Isolate Dart_CreateIsolate(const char* script_uri,
+                                            const char* main,
+                                            const uint8_t* snapshot_buffer,
+                                            Dart_IsolateFlags* flags,
+                                            void* callback_data,
+                                            char** error) {
+  return CreateIsolate(script_uri, main, snapshot_buffer, -1, false, flags,
+                       callback_data, error);
+}
+
+
+DART_EXPORT Dart_Isolate Dart_CreateIsolateFromKernel(
+    const char* script_uri,
+    const char* main,
+    const uint8_t* kernel_file,
+    intptr_t kernel_length,
+    Dart_IsolateFlags* flags,
+    void* callback_data,
+    char** error) {
+  return CreateIsolate(script_uri, main, kernel_file, kernel_length, true,
+                       flags, callback_data, error);
+}
+
+
 DART_EXPORT void Dart_ShutdownIsolate() {
   Thread* T = Thread::Current();
   Isolate* I = T->isolate();
   CHECK_ISOLATE(I);
   I->WaitForOutstandingSpawns();
   {
     StackZone zone(T);
     HandleScope handle_scope(T);
     Dart::RunShutdownCallback();
     // The Thread structure is disassociated from the isolate, we do the
@@ skipping 4015 matching lines @@
   return Api::NewHandle(T, library.raw());
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadKernel(const uint8_t* buffer,
                                         intptr_t buffer_len) {
   API_TIMELINE_DURATION;
   DARTSCOPE(Thread::Current());
   StackZone zone(T);
 
-#if defined(DART_PRECOMPILED_RUNTIME) && !defined(DART_PRECOMPILER)
+#if defined(DART_PRECOMPILED_RUNTIME)
   return Api::NewError("%s: Can't load Kernel files from precompiled runtime.",
                        CURRENT_FUNC);
 #else
   Isolate* I = T->isolate();
 
   Library& library = Library::Handle(Z, I->object_store()->root_library());
   if (!library.IsNull()) {
     const String& library_url = String::Handle(Z, library.url());
     return Api::NewError("%s: A script has already been loaded from '%s'.",
                          CURRENT_FUNC, library_url.ToCString());
@@ skipping 1227 matching lines @@
 
 DART_EXPORT bool Dart_IsPrecompiledRuntime() {
 #if defined(DART_PRECOMPILED_RUNTIME)
   return true;
 #else
   return false;
 #endif
 }
 
 }  // namespace dart