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

runtime/vm/dart.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 "vm/dart.h"
 
 #include "vm/become.h"
 #include "vm/clustered_snapshot.h"
 #include "vm/code_observers.h"
 #include "vm/cpu.h"
@@ skipping 473 matching lines @@
 
 
 Isolate* Dart::CreateIsolate(const char* name_prefix,
                              const Dart_IsolateFlags& api_flags) {
   // Create a new isolate.
   Isolate* isolate = Isolate::Init(name_prefix, api_flags);
   return isolate;
 }
 
 
-RawError* Dart::InitializeIsolate(const uint8_t* snapshot_buffer, void* data) {
+RawError* Dart::InitializeIsolate(const uint8_t* snapshot_buffer,
+                                  intptr_t snapshot_length,
+                                  bool from_kernel,
+                                  void* data) {
   // Initialize the new isolate.
   Thread* T = Thread::Current();
   Isolate* I = T->isolate();
   NOT_IN_PRODUCT(TimelineDurationScope tds(T, Timeline::GetIsolateStream(),
                                            "InitializeIsolate");
                  tds.SetNumArguments(1);
                  tds.CopyArgument(0, "isolateName", I->name());)
   ASSERT(I != NULL);
   StackZone zone(T);
   HandleScope handle_scope(T);
   {
     NOT_IN_PRODUCT(TimelineDurationScope tds(T, Timeline::GetIsolateStream(),
                                              "ObjectStore::Init"));
     ObjectStore::Init(I);
   }
 
-  const Error& error = Error::Handle(Object::Init(I));
+  Error& error = Error::Handle(T->zone());
+  if (from_kernel) {
+    ASSERT(snapshot_buffer != NULL);
+    ASSERT(snapshot_length > 0);
+    error = Object::Init(I, snapshot_buffer, snapshot_length);
+  } else {
+    error = Object::Init(I, NULL, -1);
+  }
   if (!error.IsNull()) {
     return error.raw();
   }
-  if (snapshot_buffer != NULL) {
+  if ((snapshot_buffer != NULL) && !from_kernel) {
     // Read the snapshot and setup the initial state.
     NOT_IN_PRODUCT(TimelineDurationScope tds(T, Timeline::GetIsolateStream(),
                                              "IsolateSnapshotReader"));
     // TODO(turnidge): Remove once length is not part of the snapshot.
     const Snapshot* snapshot = Snapshot::SetupFromBuffer(snapshot_buffer);
     if (snapshot == NULL) {
       const String& message = String::Handle(String::New("Invalid snapshot"));
       return ApiError::New(message);
     }
     if (snapshot->kind() != snapshot_kind_) {
@@ skipping 20 matching lines @@
       tds.FormatArgument(0, "snapshotSize", "%" Pd, snapshot->length());
       tds.FormatArgument(1, "heapSize", "%" Pd64,
                          I->heap()->UsedInWords(Heap::kOld) * kWordSize);
     }
 #endif  // !defined(PRODUCT)
     if (FLAG_trace_isolates) {
       I->heap()->PrintSizes();
       MegamorphicCacheTable::PrintSizes(I);
     }
   } else {
-    if (snapshot_kind_ != Snapshot::kNone) {
+    if ((snapshot_kind_ != Snapshot::kNone) && !from_kernel) {
       const String& message =
           String::Handle(String::New("Missing isolate snapshot"));
       return ApiError::New(message);
     }
   }
 
   Object::VerifyBuiltinVtables();
   DEBUG_ONLY(I->heap()->Verify(kForbidMarked));
 
   {
     NOT_IN_PRODUCT(TimelineDurationScope tds(T, Timeline::GetIsolateStream(),
                                              "StubCode::Init"));
     StubCode::Init(I);
   }
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
   // When running precompiled, the megamorphic miss function/code comes from the
   // snapshot.
   if (!Snapshot::IncludesCode(Dart::snapshot_kind())) {
     MegamorphicCacheTable::InitMissHandler(I);
   }
 #endif
 
   const Code& miss_code =
       Code::Handle(I->object_store()->megamorphic_miss_code());
   I->set_ic_miss_code(miss_code);
 
-  if (snapshot_buffer == NULL) {
+  if ((snapshot_buffer == NULL) || from_kernel) {
     const Error& error = Error::Handle(I->object_store()->PreallocateObjects());
     if (!error.IsNull()) {
       return error.raw();
     }
   }
 
   I->heap()->InitGrowthControl();
   I->set_init_callback_data(data);
   Api::SetupAcquiredError(I);
   if (FLAG_print_class_table) {
@@ skipping 130 matching lines @@
   return predefined_handles_->handles_.IsValidScopedHandle(address);
 }
 
 
 bool Dart::IsReadOnlyApiHandle(Dart_Handle handle) {
   ASSERT(predefined_handles_ != NULL);
   return predefined_handles_->api_handles_.IsValidHandle(handle);
 }
 
 }  // namespace dart