Move the canonical empty context to the VM isolate.

runtime/vm/object.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 "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 95 matching lines @@
 #error RAW_NULL should not be defined.
 #endif
 #define RAW_NULL kHeapObjectTag
 Object* Object::null_object_ = NULL;
 Array* Object::null_array_ = NULL;
 String* Object::null_string_ = NULL;
 Instance* Object::null_instance_ = NULL;
 TypeArguments* Object::null_type_arguments_ = NULL;
 Array* Object::empty_array_ = NULL;
 Array* Object::zero_array_ = NULL;
+Context* Object::empty_context_ = NULL;
 ContextScope* Object::empty_context_scope_ = NULL;
 ObjectPool* Object::empty_object_pool_ = NULL;
 PcDescriptors* Object::empty_descriptors_ = NULL;
 LocalVarDescriptors* Object::empty_var_descriptors_ = NULL;
 ExceptionHandlers* Object::empty_exception_handlers_ = NULL;
 Array* Object::extractor_parameter_types_ = NULL;
 Array* Object::extractor_parameter_names_ = NULL;
 Instance* Object::sentinel_ = NULL;
 Instance* Object::transition_sentinel_ = NULL;
 Instance* Object::unknown_constant_ = NULL;
@@ skipping 383 matching lines @@
   Heap* heap = isolate->heap();
 
   // Allocate the read only object handles here.
   null_object_ = Object::ReadOnlyHandle();
   null_array_ = Array::ReadOnlyHandle();
   null_string_ = String::ReadOnlyHandle();
   null_instance_ = Instance::ReadOnlyHandle();
   null_type_arguments_ = TypeArguments::ReadOnlyHandle();
   empty_array_ = Array::ReadOnlyHandle();
   zero_array_ = Array::ReadOnlyHandle();
+  empty_context_ = Context::ReadOnlyHandle();
   empty_context_scope_ = ContextScope::ReadOnlyHandle();
   empty_object_pool_ = ObjectPool::ReadOnlyHandle();
   empty_descriptors_ = PcDescriptors::ReadOnlyHandle();
   empty_var_descriptors_ = LocalVarDescriptors::ReadOnlyHandle();
   empty_exception_handlers_ = ExceptionHandlers::ReadOnlyHandle();
   extractor_parameter_types_ = Array::ReadOnlyHandle();
   extractor_parameter_names_ = Array::ReadOnlyHandle();
   sentinel_ = Instance::ReadOnlyHandle();
   transition_sentinel_ = Instance::ReadOnlyHandle();
   unknown_constant_ = Instance::ReadOnlyHandle();
@@ skipping 241 matching lines @@
     uword address = heap->Allocate(Array::InstanceSize(1), Heap::kOld);
     InitializeObject(address, kImmutableArrayCid, Array::InstanceSize(1), true);
     Array::initializeHandle(
         zero_array_, reinterpret_cast<RawArray*>(address + kHeapObjectTag));
     zero_array_->StoreSmi(&zero_array_->raw_ptr()->length_, Smi::New(1));
     smi = Smi::New(0);
     zero_array_->SetAt(0, smi);
     zero_array_->SetCanonical();
   }
 
+  // Allocate and initialize the empty context object.
+  {
+    uword address = heap->Allocate(Context::InstanceSize(0), Heap::kOld);
+    InitializeObject(address, kContextCid, Context::InstanceSize(0), true);
+    Context::initializeHandle(empty_context_, reinterpret_cast<RawContext*>(
+                                                  address + kHeapObjectTag));
+    empty_context_->StoreNonPointer(&empty_context_->raw_ptr()->num_variables_,
+                                    0);
+    empty_context_->SetCanonical();
+  }
+
   // Allocate and initialize the canonical empty context scope object.
   {
     uword address = heap->Allocate(ContextScope::InstanceSize(0), Heap::kOld);
     InitializeObject(address, kContextScopeCid, ContextScope::InstanceSize(0),
                      true);
     ContextScope::initializeHandle(
         empty_context_scope_,
         reinterpret_cast<RawContextScope*>(address + kHeapObjectTag));
     empty_context_scope_->StoreNonPointer(
         &empty_context_scope_->raw_ptr()->num_variables_, 0);
@@ skipping 125 matching lines @@
   ASSERT(!null_string_->IsSmi());
   ASSERT(null_string_->IsString());
   ASSERT(!null_instance_->IsSmi());
   ASSERT(null_instance_->IsInstance());
   ASSERT(!null_type_arguments_->IsSmi());
   ASSERT(null_type_arguments_->IsTypeArguments());
   ASSERT(!empty_array_->IsSmi());
   ASSERT(empty_array_->IsArray());
   ASSERT(!zero_array_->IsSmi());
   ASSERT(zero_array_->IsArray());
+  ASSERT(!empty_context_->IsSmi());
+  ASSERT(empty_context_->IsContext());
   ASSERT(!empty_context_scope_->IsSmi());
   ASSERT(empty_context_scope_->IsContextScope());
   ASSERT(!empty_descriptors_->IsSmi());
   ASSERT(empty_descriptors_->IsPcDescriptors());
   ASSERT(!empty_var_descriptors_->IsSmi());
   ASSERT(empty_var_descriptors_->IsLocalVarDescriptors());
   ASSERT(!empty_exception_handlers_->IsSmi());
   ASSERT(empty_exception_handlers_->IsExceptionHandlers());
   ASSERT(!sentinel_->IsSmi());
   ASSERT(sentinel_->IsInstance());
@@ skipping 326 matching lines @@
     Library::InitCoreLibrary(isolate);
 
     // Basic infrastructure has been setup, initialize the class dictionary.
     const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
 
     const GrowableObjectArray& pending_classes =
         GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
     object_store->set_pending_classes(pending_classes);
 
-    Context& context = Context::Handle(zone, Context::New(0, Heap::kOld));
-    object_store->set_empty_context(context);
-
     // Now that the symbol table is initialized and that the core dictionary as
     // well as the core implementation dictionary have been setup, preallocate
     // remaining classes and register them by name in the dictionaries.
     String& name = String::Handle(zone);
     cls = object_store->array_class();  // Was allocated above.
     RegisterPrivateClass(cls, Symbols::_List(), core_lib);
     pending_classes.Add(cls);
     // We cannot use NewNonParameterizedType(cls), because Array is
     // parameterized.  Warning: class _List has not been patched yet. Its
     // declared number of type parameters is still 0. It will become 1 after
@@ skipping 496 matching lines @@
     cls = Class::New<SendPort>();
     cls = Class::New<StackTrace>();
     cls = Class::New<RegExp>();
     cls = Class::New<Number>();
 
     cls = Class::New<WeakProperty>();
     object_store->set_weak_property_class(cls);
 
     cls = Class::New<MirrorReference>();
     cls = Class::New<UserTag>();
-
-    const Context& context = Context::Handle(zone, Context::New(0, Heap::kOld));
-    object_store->set_empty_context(context);
   }
   return Error::null();
 }
 
 
 #if defined(DEBUG)
 bool Object::InVMHeap() const {
   if (FLAG_verify_handles && raw()->IsVMHeapObject()) {
     Heap* vm_isolate_heap = Dart::vm_isolate()->heap();
     ASSERT(vm_isolate_heap->Contains(RawObject::ToAddr(raw())));
@@ skipping 5120 matching lines @@
       pieces->Add(Symbols::RBracket());
     } else {
       pieces->Add(Symbols::RBrace());
     }
   }
 }
 
 
 RawInstance* Function::ImplicitStaticClosure() const {
   if (implicit_static_closure() == Instance::null()) {
-    Thread* thread = Thread::Current();
-    Isolate* isolate = thread->isolate();
-    Zone* zone = thread->zone();
-    ObjectStore* object_store = isolate->object_store();
-    const Context& context =
-        Context::Handle(zone, object_store->empty_context());
+    Zone* zone = Thread::Current()->zone();
+    const Context& context = Object::empty_context();
     const TypeArguments& instantiator = TypeArguments::Handle(zone);
     Instance& closure = Instance::Handle(
         zone, Closure::New(instantiator, *this, context, Heap::kOld));
     set_implicit_static_closure(closure);
   }
   return implicit_static_closure();
 }
 
 
 RawInstance* Function::ImplicitInstanceClosure(const Instance& receiver) const {
@@ skipping 16158 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart