Preparation for moving reusable handles to thread and more cleanups: isolate -> thread based handle…

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 2192 matching lines @@
   for (intptr_t i = 0; i < arr.Length(); i++) {
     entry ^= arr.At(i);
     if (function.raw() != entry.raw()) {
       AddFunction(entry);
     }
   }
 }
 
 
 intptr_t Class::FindFunctionIndex(const Function& needle) const {
-  Isolate* isolate = Isolate::Current();
-  if (EnsureIsFinalized(isolate) != Error::null()) {
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  if (EnsureIsFinalized(thread) != Error::null()) {
     return -1;
   }
   REUSABLE_ARRAY_HANDLESCOPE(isolate);
   REUSABLE_FUNCTION_HANDLESCOPE(isolate);
   Array& funcs = isolate->ArrayHandle();
   Function& function = isolate->FunctionHandle();
   funcs ^= functions();
   ASSERT(!funcs.IsNull());
   const intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
@@ skipping 31 matching lines @@
     return Function::null();
   }
   const Function& closure_func =
       Function::Handle(func.ImplicitClosureFunction());
   ASSERT(!closure_func.IsNull());
   return closure_func.raw();
 }
 
 
 intptr_t Class::FindImplicitClosureFunctionIndex(const Function& needle) const {
-  Isolate* isolate = Isolate::Current();
-  if (EnsureIsFinalized(isolate) != Error::null()) {
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  if (EnsureIsFinalized(thread) != Error::null()) {
     return -1;
   }
   REUSABLE_ARRAY_HANDLESCOPE(isolate);
   REUSABLE_FUNCTION_HANDLESCOPE(isolate);
   Array& funcs = isolate->ArrayHandle();
   Function& function = isolate->FunctionHandle();
   funcs ^= functions();
   ASSERT(!funcs.IsNull());
   Function& implicit_closure = Function::Handle(isolate);
   const intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     implicit_closure ^= function.implicit_closure_function();
     if (implicit_closure.IsNull()) {
       // Skip non-implicit closure functions.
       continue;
     }
     if (needle.raw() == implicit_closure.raw()) {
       return i;
     }
   }
   // No function found.
   return -1;
 }
 
 
 
 intptr_t Class::FindInvocationDispatcherFunctionIndex(
     const Function& needle) const {
-  Isolate* isolate = Isolate::Current();
-  if (EnsureIsFinalized(isolate) != Error::null()) {
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  if (EnsureIsFinalized(thread) != Error::null()) {
     return -1;
   }
   REUSABLE_ARRAY_HANDLESCOPE(isolate);
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Array& funcs = isolate->ArrayHandle();
   Object& object = isolate->ObjectHandle();
   funcs ^= invocation_dispatcher_cache();
   ASSERT(!funcs.IsNull());
   const intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
@@ skipping 116 matching lines @@
 void Class::set_library(const Library& value) const {
   StorePointer(&raw_ptr()->library_, value.raw());
 }
 
 
 void Class::set_type_parameters(const TypeArguments& value) const {
   StorePointer(&raw_ptr()->type_parameters_, value.raw());
 }
 
 
-intptr_t Class::NumTypeParameters(Isolate* isolate) const {
+intptr_t Class::NumTypeParameters(Thread* thread) const {
   if (IsMixinApplication() && !is_mixin_type_applied()) {
     ClassFinalizer::ApplyMixinType(*this);
   }
   if (type_parameters() == TypeArguments::null()) {
     return 0;
   }
+  Isolate* isolate = thread->isolate();
   REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(isolate);
   TypeArguments& type_params = isolate->TypeArgumentsHandle();
   type_params = type_parameters();
   return type_params.Length();
 }
 
 
 intptr_t Class::NumOwnTypeArguments() const {
   // Return cached value if already calculated.
   if (num_own_type_arguments() != kUnknownNumTypeArguments) {
@@ skipping 571 matching lines @@
   const Function& eval_func =
       Function::Handle(EvaluateHelper(*this, expr, param_names, true));
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(eval_func, param_values));
   return result.raw();
 }
 
 
 // Ensure that top level parsing of the class has been done.
 // TODO(24109): Migrate interface to Thread*.
-RawError* Class::EnsureIsFinalized(Isolate* isolate) const {
+RawError* Class::EnsureIsFinalized(Thread* thread) const {
   // Finalized classes have already been parsed.
   if (is_finalized()) {
     return Error::null();
   }
-  ASSERT(isolate != NULL);
-  const Error& error = Error::Handle(isolate, Compiler::CompileClass(*this));
+  ASSERT(thread != NULL);
+  const Error& error = Error::Handle(
+      thread->zone(), Compiler::CompileClass(*this));
   if (!error.IsNull()) {
-    ASSERT(isolate == Thread::Current()->isolate());
-    if (Thread::Current()->long_jump_base() != NULL) {
+    ASSERT(thread == Thread::Current());
+    if (thread->long_jump_base() != NULL) {
       Report::LongJump(error);
       UNREACHABLE();
     }
   }
   return error.raw();
 }
 
 
 void Class::SetFields(const Array& value) const {
   ASSERT(!value.IsNull());
@@ skipping 27 matching lines @@
   const Array& new_arr = Array::Handle(
       Array::Grow(arr, num_old_fields + num_new_fields, Heap::kOld));
   for (intptr_t i = 0; i < num_new_fields; i++) {
     new_arr.SetAt(i + num_old_fields, *new_fields.At(i));
   }
   SetFields(new_arr);
 }
 
 
 intptr_t Class::FindFieldIndex(const Field& needle) const {
-  Isolate* isolate = Isolate::Current();
-  if (EnsureIsFinalized(isolate) != Error::null()) {
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  if (EnsureIsFinalized(thread) != Error::null()) {
     return -1;
   }
   REUSABLE_ARRAY_HANDLESCOPE(isolate);
   REUSABLE_FIELD_HANDLESCOPE(isolate);
   REUSABLE_STRING_HANDLESCOPE(isolate);
   Array& fields_array = isolate->ArrayHandle();
   Field& field = isolate->FieldHandle();
   String& field_name = isolate->StringHandle();
   fields_array ^= fields();
   ASSERT(!fields_array.IsNull());
@@ skipping 592 matching lines @@
     Array& types = Array::Handle();
     types ^= canonical_types();
     ASSERT(!types.IsNull() && (types.Length() > 1));
     ASSERT((types.At(0) == Object::null()) || (types.At(0) == type.raw()));
     types.SetAt(0, type);
   }
 }
 
 
 intptr_t Class::FindCanonicalTypeIndex(const Type& needle) const {
-  Isolate* isolate = Isolate::Current();
-  if (EnsureIsFinalized(isolate) != Error::null()) {
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  if (EnsureIsFinalized(thread) != Error::null()) {
     return -1;
   }
   if (needle.raw() == CanonicalType()) {
     // For a generic type or signature type, there exists another index with the
     // same type. It will never be returned by this function.
     return 0;
   }
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& types = isolate->ObjectHandle();
   types = canonical_types();
@@ skipping 375 matching lines @@
       return func.raw();
     }
   } else if (kind == kAny) {
     return func.raw();
   }
   return Function::null();
 }
 
 
 RawFunction* Class::LookupFunction(const String& name, MemberKind kind) const {
-  Isolate* isolate = Isolate::Current();
-  if (EnsureIsFinalized(isolate) != Error::null()) {
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  if (EnsureIsFinalized(thread) != Error::null()) {
     return Function::null();
   }
   REUSABLE_ARRAY_HANDLESCOPE(isolate);
   REUSABLE_FUNCTION_HANDLESCOPE(isolate);
   Array& funcs = isolate->ArrayHandle();
   funcs ^= functions();
   ASSERT(!funcs.IsNull());
   const intptr_t len = funcs.Length();
   Function& function = isolate->FunctionHandle();
   if (len >= kFunctionLookupHashTreshold) {
@@ skipping 25 matching lines @@
       }
     }
   }
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupFunctionAllowPrivate(const String& name,
                                                MemberKind kind) const {
-  Isolate* isolate = Isolate::Current();
-  if (EnsureIsFinalized(isolate) != Error::null()) {
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  if (EnsureIsFinalized(thread) != Error::null()) {
     return Function::null();
   }
   REUSABLE_ARRAY_HANDLESCOPE(isolate);
   REUSABLE_FUNCTION_HANDLESCOPE(isolate);
   REUSABLE_STRING_HANDLESCOPE(isolate);
   Array& funcs = isolate->ArrayHandle();
   funcs ^= functions();
   ASSERT(!funcs.IsNull());
   const intptr_t len = funcs.Length();
   Function& function = isolate->FunctionHandle();
@@ skipping 16 matching lines @@
 
 
 RawFunction* Class::LookupSetterFunction(const String& name) const {
   return LookupAccessorFunction(kSetterPrefix, kSetterPrefixLength, name);
 }
 
 
 RawFunction* Class::LookupAccessorFunction(const char* prefix,
                                            intptr_t prefix_length,
                                            const String& name) const {
-  Isolate* isolate = Isolate::Current();
-  if (EnsureIsFinalized(isolate) != Error::null()) {
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  if (EnsureIsFinalized(thread) != Error::null()) {
     return Function::null();
   }
   REUSABLE_ARRAY_HANDLESCOPE(isolate);
   REUSABLE_FUNCTION_HANDLESCOPE(isolate);
   REUSABLE_STRING_HANDLESCOPE(isolate);
   Array& funcs = isolate->ArrayHandle();
   funcs ^= functions();
   intptr_t len = funcs.Length();
   Function& function = isolate->FunctionHandle();
   String& function_name = isolate->StringHandle();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
     function_name ^= function.name();
     if (MatchesAccessorName(function_name, prefix, prefix_length, name)) {
       return function.raw();
     }
   }
 
   // No function found.
   return Function::null();
 }
 
 
 RawFunction* Class::LookupFunctionAtToken(intptr_t token_pos) const {
   // TODO(hausner): we can shortcut the negative case if we knew the
   // beginning and end token position of the class.
-  Isolate* isolate = Isolate::Current();
-  if (EnsureIsFinalized(isolate) != Error::null()) {
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  if (EnsureIsFinalized(thread) != Error::null()) {
     return Function::null();
   }
   Function& func = Function::Handle(isolate);
   func = LookupClosureFunction(token_pos);
   if (!func.IsNull()) {
     return func.raw();
   }
   Array& funcs = Array::Handle(isolate, functions());
   intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
@@ skipping 17 matching lines @@
   return LookupField(name, kStatic);
 }
 
 
 RawField* Class::LookupField(const String& name) const {
   return LookupField(name, kAny);
 }
 
 
 RawField* Class::LookupField(const String& name, MemberKind kind) const {
-  Isolate* isolate = Isolate::Current();
-  if (EnsureIsFinalized(isolate) != Error::null()) {
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  if (EnsureIsFinalized(thread) != Error::null()) {
     return Field::null();
   }
   REUSABLE_ARRAY_HANDLESCOPE(isolate);
   REUSABLE_FIELD_HANDLESCOPE(isolate);
   REUSABLE_STRING_HANDLESCOPE(isolate);
   Array& flds = isolate->ArrayHandle();
   flds ^= fields();
   ASSERT(!flds.IsNull());
   intptr_t len = flds.Length();
   Field& field = isolate->FieldHandle();
@@ skipping 52 matching lines @@
   }
   AddCommonObjectProperties(&jsobj, "Class", ref);
   jsobj.AddFixedServiceId("classes/%" Pd "", id());
   const String& user_name = String::Handle(PrettyName());
   const String& vm_name = String::Handle(Name());
   AddNameProperties(&jsobj, user_name, vm_name);
   if (ref) {
     return;
   }
 
-  const Error& err = Error::Handle(EnsureIsFinalized(Isolate::Current()));
+  const Error& err = Error::Handle(EnsureIsFinalized(Thread::Current()));
   if (!err.IsNull()) {
     jsobj.AddProperty("error", err);
   }
   jsobj.AddProperty("abstract", is_abstract());
   jsobj.AddProperty("const", is_const());
   jsobj.AddProperty("_finalized", is_finalized());
   jsobj.AddProperty("_implemented", is_implemented());
   jsobj.AddProperty("_patch", is_patch());
   jsobj.AddProperty("_traceAllocations", TraceAllocation(isolate));
   const Class& superClass = Class::Handle(SuperClass());
@@ skipping 2784 matching lines @@
   // id ring. Current known examples are signature functions of closures
   // and stubs like 'megamorphic_miss'.
   jsobj.AddServiceId(f);
 }
 
 
 void Function::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Class& cls = Class::Handle(Owner());
   ASSERT(!cls.IsNull());
   Error& err = Error::Handle();
-  err ^= cls.EnsureIsFinalized(Isolate::Current());
+  err ^= cls.EnsureIsFinalized(Thread::Current());
   ASSERT(err.IsNull());
   JSONObject jsobj(stream);
   AddCommonObjectProperties(&jsobj, "Function", ref);
   AddFunctionServiceId(jsobj, *this, cls);
   const String& user_name = String::Handle(PrettyName());
   const String& vm_name = String::Handle(name());
   AddNameProperties(&jsobj, user_name, vm_name);
   const Function& parent = Function::Handle(parent_function());
   if (!parent.IsNull()) {
     jsobj.AddProperty("owner", parent);
@@ skipping 3702 matching lines @@
   Error& error = Error::Handle();
   const GrowableObjectArray& libs = GrowableObjectArray::Handle(
       Isolate::Current()->object_store()->libraries());
   Library& lib = Library::Handle();
   Class& cls = Class::Handle();
   for (int i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
     while (it.HasNext()) {
       cls = it.GetNextClass();
-      error = cls.EnsureIsFinalized(Isolate::Current());
+      error = cls.EnsureIsFinalized(Thread::Current());
       if (!error.IsNull()) {
         return error.raw();
       }
       error = Compiler::CompileAllFunctions(cls);
       if (!error.IsNull()) {
         return error.raw();
       }
     }
   }
   return error.raw();
@@ skipping 3793 matching lines @@
       }
       return true;
     }
     cls = cls.SuperClass();
   } while (!cls.IsNull());
   return false;
 }
 
 
 RawInstance* Instance::New(const Class& cls, Heap::Space space) {
-  Isolate* isolate = Isolate::Current();
-  if (cls.EnsureIsFinalized(isolate) != Error::null()) {
+  Thread* thread = Thread::Current();
+  if (cls.EnsureIsFinalized(thread) != Error::null()) {
     return Instance::null();
   }
   intptr_t instance_size = cls.instance_size();
   ASSERT(instance_size > 0);
   RawObject* raw = Object::Allocate(cls.id(), instance_size, space);
   return reinterpret_cast<RawInstance*>(raw);
 }
 
 
 bool Instance::IsValidFieldOffset(intptr_t offset) const {
@@ skipping 959 matching lines @@
   }
   if (type_class() != other_type.type_class()) {
     return false;
   }
   if (!IsFinalized() || !other_type.IsFinalized()) {
     return false;
   }
   if (arguments() == other_type.arguments()) {
     return true;
   }
-  Isolate* isolate = Isolate::Current();
-  const Class& cls = Class::Handle(isolate, type_class());
-  const intptr_t num_type_params = cls.NumTypeParameters(isolate);
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  const Class& cls = Class::Handle(zone, type_class());
+  const intptr_t num_type_params = cls.NumTypeParameters(thread);
   if (num_type_params == 0) {
     // Shortcut unnecessary handle allocation below.
     return true;
   }
   const intptr_t num_type_args = cls.NumTypeArguments();
   const intptr_t from_index = num_type_args - num_type_params;
-  const TypeArguments& type_args = TypeArguments::Handle(isolate, arguments());
+  const TypeArguments& type_args = TypeArguments::Handle(zone, arguments());
   const TypeArguments& other_type_args = TypeArguments::Handle(
-      isolate, other_type.arguments());
+      zone, other_type.arguments());
   if (type_args.IsNull()) {
     // Ignore from_index.
     return other_type_args.IsRaw(0, num_type_args);
   }
   if (other_type_args.IsNull()) {
     // Ignore from_index.
     return type_args.IsRaw(0, num_type_args);
   }
   if (!type_args.IsSubvectorEquivalent(other_type_args,
                                        from_index,
                                        num_type_params)) {
     return false;
   }
 #ifdef DEBUG
   if (from_index > 0) {
     // Verify that the type arguments of the super class match, since they
     // depend solely on the type parameters that were just verified to match.
     ASSERT(type_args.Length() >= (from_index + num_type_params));
     ASSERT(other_type_args.Length() >= (from_index + num_type_params));
-    AbstractType& type_arg = AbstractType::Handle(isolate);
-    AbstractType& other_type_arg = AbstractType::Handle(isolate);
+    AbstractType& type_arg = AbstractType::Handle(zone);
+    AbstractType& other_type_arg = AbstractType::Handle(zone);
     for (intptr_t i = 0; i < from_index; i++) {
       type_arg = type_args.TypeAt(i);
       other_type_arg = other_type_args.TypeAt(i);
       ASSERT(type_arg.IsEquivalent(other_type_arg, trail));
     }
   }
 #endif
   return true;
 }
 
@@ skipping 5798 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart