Remove isolate pointer from context objects.

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/cpu.h"
@@ skipping 1118 matching lines @@
   pending_classes.Add(cls);
 
   // Pre-register the isolate library so the native class implementations
   // can be hooked up before compiling it.
   Library& isolate_lib =
       Library::Handle(isolate, Library::LookupLibrary(Symbols::DartIsolate()));
   if (isolate_lib.IsNull()) {
     isolate_lib = Library::NewLibraryHelper(Symbols::DartIsolate(), true);
     isolate_lib.SetLoadRequested();
     isolate_lib.Register();
-    isolate->object_store()->set_bootstrap_library(ObjectStore::kIsolate,
-                                                   isolate_lib);
+    object_store->set_bootstrap_library(ObjectStore::kIsolate, isolate_lib);
   }
   ASSERT(!isolate_lib.IsNull());
   ASSERT(isolate_lib.raw() == Library::IsolateLibrary());
 
   cls = Class::New<Capability>();
   RegisterPrivateClass(cls, Symbols::_CapabilityImpl(), isolate_lib);
   pending_classes.Add(cls);
 
   cls = Class::New<ReceivePort>();
   RegisterPrivateClass(cls, Symbols::_RawReceivePortImpl(), isolate_lib);
@@ skipping 101 matching lines @@
   object_store->set_weak_property_class(cls);
   RegisterPrivateClass(cls, Symbols::_WeakProperty(), core_lib);
 
   // Pre-register the mirrors library so we can place the vm class
   // MirrorReference there rather than the core library.
   lib = Library::LookupLibrary(Symbols::DartMirrors());
   if (lib.IsNull()) {
     lib = Library::NewLibraryHelper(Symbols::DartMirrors(), true);
     lib.SetLoadRequested();
     lib.Register();
-    isolate->object_store()->set_bootstrap_library(ObjectStore::kMirrors,
-                                                   lib);
+    object_store->set_bootstrap_library(ObjectStore::kMirrors, lib);
   }
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::MirrorsLibrary());
 
   cls = Class::New<MirrorReference>();
   RegisterPrivateClass(cls, Symbols::_MirrorReference(), lib);
 
   // Pre-register the collection library so we can place the vm class
   // LinkedHashMap there rather than the core library.
   lib = Library::LookupLibrary(Symbols::DartCollection());
   if (lib.IsNull()) {
     lib = Library::NewLibraryHelper(Symbols::DartCollection(), true);
     lib.SetLoadRequested();
     lib.Register();
-    isolate->object_store()->set_bootstrap_library(ObjectStore::kCollection,
-                                                   lib);
+    object_store->set_bootstrap_library(ObjectStore::kCollection, lib);
   }
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::CollectionLibrary());
 
   cls = Class::New<LinkedHashMap>();
   object_store->set_linked_hash_map_class(cls);
   cls.set_type_arguments_field_offset(LinkedHashMap::type_arguments_offset());
   cls.set_num_type_arguments(2);
   cls.set_num_own_type_arguments(2);
   RegisterPrivateClass(cls, Symbols::_LinkedHashMap(), lib);
   pending_classes.Add(cls);
 
   // Pre-register the profiler library so we can place the vm class
   // UserTag there rather than the core library.
   lib = Library::LookupLibrary(Symbols::DartProfiler());
   if (lib.IsNull()) {
     lib = Library::NewLibraryHelper(Symbols::DartProfiler(), true);
     lib.SetLoadRequested();
     lib.Register();
-    isolate->object_store()->set_bootstrap_library(ObjectStore::kProfiler,
-                                                   lib);
+    object_store->set_bootstrap_library(ObjectStore::kProfiler, lib);
   }
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::ProfilerLibrary());
 
   lib = Library::LookupLibrary(Symbols::DartProfiler());
   ASSERT(!lib.IsNull());
   cls = Class::New<UserTag>();
   RegisterPrivateClass(cls, Symbols::_UserTag(), lib);
   pending_classes.Add(cls);
 
   // Setup some default native field classes which can be extended for
   // specifying native fields in dart classes.
   Library::InitNativeWrappersLibrary(isolate);
-  ASSERT(isolate->object_store()->native_wrappers_library() != Library::null());
+  ASSERT(object_store->native_wrappers_library() != Library::null());
 
   // Pre-register the typed_data library so the native class implementations
   // can be hooked up before compiling it.
   lib = Library::LookupLibrary(Symbols::DartTypedData());
   if (lib.IsNull()) {
     lib = Library::NewLibraryHelper(Symbols::DartTypedData(), true);
     lib.SetLoadRequested();
     lib.Register();
-    isolate->object_store()->set_bootstrap_library(ObjectStore::kTypedData,
-                                                   lib);
+    object_store->set_bootstrap_library(ObjectStore::kTypedData, lib);
   }
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::TypedDataLibrary());
 #define REGISTER_TYPED_DATA_CLASS(clazz)                                       \
   cls = Class::NewTypedDataClass(kTypedData##clazz##Cid);                      \
   RegisterPrivateClass(cls, Symbols::_##clazz(), lib);                         \
 
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_CLASS);
 #undef REGISTER_TYPED_DATA_CLASS
 #define REGISTER_TYPED_DATA_VIEW_CLASS(clazz)                                  \
@@ skipping 124 matching lines @@
   // is a built-in identifier (this is wrong).
   // The corresponding types are stored in the object store.
   cls = object_store->null_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_null_type(type);
 
   // Consider removing when/if Null becomes an ordinary class.
   type = object_store->object_type();
   cls.set_super_type(type);
 
+  return Error::null();
+}
+
+
+RawError* Object::FinishInit(Isolate* isolate) {
   // Finish the initialization by compiling the bootstrap scripts containing the
   // base interfaces and the implementation of the internal classes.
   const Error& error = Error::Handle(Bootstrap::LoadandCompileScripts());
   if (!error.IsNull()) {
     return error.raw();
   }
 
   ClassFinalizer::VerifyBootstrapClasses();
   MarkInvisibleFunctions();
 
   // Set up the intrinsic state of all functions (core, math and typed data).
   Intrinsifier::InitializeState();
 
   // Set up recognized state of all functions (core, math and typed data).
   MethodRecognizer::InitializeState();
 
   // Adds static const fields (class ids) to the class 'ClassID');
+  Library& lib = Library::Handle(isolate);
   lib = Library::LookupLibrary(Symbols::DartInternal());
   ASSERT(!lib.IsNull());
+  Class& cls = Class::Handle(isolate);
   cls = lib.LookupClassAllowPrivate(Symbols::ClassID());
   ASSERT(!cls.IsNull());
   Field& field = Field::Handle(isolate);
   Smi& value = Smi::Handle(isolate);
   String& field_name = String::Handle(isolate);
 
 #define CLASS_LIST_WITH_NULL(V)                                                \
   V(Null)                                                                      \
   CLASS_LIST_NO_OBJECT(V)
 
 #define ADD_SET_FIELD(clazz)                                                   \
   field_name = Symbols::New("cid"#clazz);                                      \
   field = Field::New(field_name, true, false, true, false, cls, 0);            \
   value = Smi::New(k##clazz##Cid);                                             \
   field.set_value(value);                                                      \
   field.set_type(Type::Handle(Type::IntType()));                               \
   cls.AddField(field);                                                         \
 
   CLASS_LIST_WITH_NULL(ADD_SET_FIELD)
 #undef ADD_SET_FIELD
 
-  object_store->InitAsyncObjects();
+  isolate->object_store()->InitAsyncObjects();
 
   return Error::null();
 }
 
 
 void Object::InitFromSnapshot(Isolate* isolate) {
   TIMERSCOPE(isolate, time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle();
@@ skipping 3581 matching lines @@
 void Function::AttachCode(const Code& value) const {
   SetInstructions(value);
   ASSERT(Function::Handle(value.function()).IsNull() ||
     (value.function() == this->raw()));
   value.set_owner(*this);
 }
 
 
 bool Function::HasCode() const {
   ASSERT(raw_ptr()->instructions_ != Instructions::null());
+  StubCode* stub_code = Isolate::Current()->stub_code();
   return raw_ptr()->instructions_ !=
-      StubCode::LazyCompile_entry()->code()->ptr()->instructions_;
+      stub_code->LazyCompile_entry()->code()->ptr()->instructions_;
 }
 
 
 void Function::ClearCode() const {
   StorePointer(&raw_ptr()->unoptimized_code_, Code::null());
+  StubCode* stub_code = Isolate::Current()->stub_code();
   StorePointer(&raw_ptr()->instructions_,
-      Code::Handle(StubCode::LazyCompile_entry()->code()).instructions());
+      Code::Handle(stub_code->LazyCompile_entry()->code()).instructions());
 }
 
 
 void Function::SwitchToUnoptimizedCode() const {
   ASSERT(HasOptimizedCode());
   const Code& current_code = Code::Handle(CurrentCode());
 
   if (FLAG_trace_disabling_optimized_code) {
     OS::Print("Disabling optimized code: '%s' entry: %#" Px "\n",
       ToFullyQualifiedCString(),
@@ skipping 993 matching lines @@
   result.set_num_fixed_parameters(0);
   result.set_num_optional_parameters(0);
   result.set_usage_counter(0);
   result.set_deoptimization_counter(0);
   result.set_optimized_instruction_count(0);
   result.set_optimized_call_site_count(0);
   result.set_is_optimizable(is_native ? false : true);
   result.set_is_inlinable(true);
   result.set_allows_hoisting_check_class(true);
   result.set_allows_bounds_check_generalization(true);
-  result.SetInstructions(Code::Handle(StubCode::LazyCompile_entry()->code()));
+  StubCode* stub_code = Isolate::Current()->stub_code();
+  result.SetInstructions(Code::Handle(stub_code->LazyCompile_entry()->code()));
   if (kind == RawFunction::kClosureFunction) {
     const ClosureData& data = ClosureData::Handle(ClosureData::New());
     result.set_data(data);
   }
 
   return result.raw();
 }
 
 
 RawFunction* Function::Clone(const Class& new_owner) const {
@@ skipping 6294 matching lines @@
   }
   Context& result = Context::Handle();
   {
     RawObject* raw = Object::Allocate(Context::kClassId,
                                       Context::InstanceSize(num_variables),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.set_num_variables(num_variables);
   }
-  result.set_isolate(Isolate::Current());
   return result.raw();
 }
 
 
 const char* Context::ToCString() const {
   if (IsNull()) {
     return "Context (Null)";
   }
   Zone* zone = Isolate::Current()->current_zone();
   const Context& parent_ctx = Context::Handle(parent());
@@ skipping 7231 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, format, fun_sig, from, fun_desc) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, fun_sig, from, fun_desc);
   return chars;
 }
 
 
 RawInstance* Closure::New(const Function& function,
                           const Context& context,
                           Heap::Space space) {
-  Isolate* isolate = Isolate::Current();
-  ASSERT(context.isolate() == isolate);
-
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(cls.instance_size() == Closure::InstanceSize());
   Instance& result = Instance::Handle();
   {
     RawObject* raw = Object::Allocate(cls.id(), Closure::InstanceSize(), space);
     NoGCScope no_gc;
     result ^= raw;
   }
   Closure::set_function(result, function);
   Closure::set_context(result, context);
@@ skipping 604 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart