Changes to pass the current isolate to all runtime and native calls.

runtime/vm/code_generator.cc

 // Copyright (c) 2011, 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/code_generator.h"
 
 #include "vm/code_index_table.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
@@ skipping 210 matching lines @@
   arguments.SetReturn(type_arguments);
 }
 
 
 // Allocate a new closure.
 // Arg0: local function.
 // Arg1: type arguments of the closure.
 // Return value: newly allocated closure.
 DEFINE_RUNTIME_ENTRY(AllocateClosure, 2) {
   ASSERT(arguments.Count() == kAllocateClosureRuntimeEntry.argument_count());
+  Isolate* isolate = arguments.isolate();
   const Function& function = Function::CheckedHandle(arguments.At(0));
   ASSERT(function.IsClosureFunction() && !function.IsImplicitClosureFunction());
   const TypeArguments& type_arguments =
       TypeArguments::CheckedHandle(arguments.At(1));
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   // The current context was saved in the Isolate structure when entering the
   // runtime.
-  const Context& context = Context::Handle(Isolate::Current()->top_context());
+  const Context& context = Context::Handle(isolate->top_context());
   ASSERT(!context.IsNull());
   const Closure& closure = Closure::Handle(Closure::New(function, context));
   closure.SetTypeArguments(type_arguments);
   arguments.SetReturn(closure);
 }
 
 
 // Allocate a new implicit static closure.
 // Arg0: local function.
 // Return value: newly allocated closure.
 DEFINE_RUNTIME_ENTRY(AllocateImplicitStaticClosure, 1) {
   ASSERT(arguments.Count() ==
          kAllocateImplicitStaticClosureRuntimeEntry.argument_count());
-  ObjectStore* object_store = Isolate::Current()->object_store();
+  Isolate* isolate = arguments.isolate();
+  ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
   const Function& function = Function::CheckedHandle(arguments.At(0));
   ASSERT(function.IsImplicitStaticClosureFunction());
   const Context& context = Context::Handle(object_store->empty_context());
   arguments.SetReturn(Closure::Handle(Closure::New(function, context)));
 }
 
 
 // Allocate a new implicit instance closure.
 // Arg0: local function.
@@ skipping 113 matching lines @@
         caller_frame->pc(),
         target_function.ToFullyQualifiedCString(),
         new_target);
   }
 }
 
 
 // Resolves and compiles the target function of an instance call, updates
 // function cache of the receiver's class and returns the compiled code or null.
 // Only the number of named arguments is checked, but not the actual names.
-static RawCode* ResolveCompileInstanceCallTarget(const Instance& receiver) {
+static RawCode* ResolveCompileInstanceCallTarget(Isolate* isolate,
+                                                 const Instance& receiver) {
   DartFrameIterator iterator;
   DartFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   int num_arguments = -1;
   int num_named_arguments = -1;
   uword target = 0;
   String& function_name = String::Handle();
   CodePatcher::GetInstanceCallAt(caller_frame->pc(),
                                  &function_name,
                                  &num_arguments,
                                  &num_named_arguments,
                                  &target);
   ASSERT(function_name.IsSymbol());
   Class& receiver_class = Class::Handle();
   if (receiver.IsNull()) {
     // TODO(srdjan): Clarify behavior of null objects.
-    receiver_class = Isolate::Current()->object_store()->object_class();
+    receiver_class = isolate->object_store()->object_class();
   } else {
     receiver_class = receiver.clazz();
   }
   FunctionsCache functions_cache(receiver_class);
   Code& code = Code::Handle();
       code = functions_cache.LookupCode(function_name,
                                         num_arguments,
                                         num_named_arguments);
   if (!code.IsNull()) {
     // Function's code found in the cache.
@@ skipping 34 matching lines @@
 
 // Resolves an instance function and compiles it if necessary.
 //   Arg0: receiver object.
 //   Returns: RawCode object or NULL (method not found or not compileable).
 // This is called by the megamorphic stub when instance call does not need to be
 // patched.
 // Used by megamorphic lookup/no-such-method-handling.
 DEFINE_RUNTIME_ENTRY(ResolveCompileInstanceFunction, 1) {
   ASSERT(arguments.Count() ==
          kResolveCompileInstanceFunctionRuntimeEntry.argument_count());
+  Isolate* isolate = arguments.isolate();
   const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
-  const Code& code = Code::Handle(ResolveCompileInstanceCallTarget(receiver));
+  const Code& code = Code::Handle(
+      ResolveCompileInstanceCallTarget(isolate, receiver));
   arguments.SetReturn(Code::Handle(code.raw()));
 }
 
 
 // Handles inline cache misses by updating the IC data array of the call
 // site.
 //   Arg0: Receiver object.
 //   Returns: target function with compiled code or 0.
 // Modifies the instance call to hold the updated IC data array.
 DEFINE_RUNTIME_ENTRY(InlineCacheMissHandler, 1) {
   ASSERT(arguments.Count() ==
       kInlineCacheMissHandlerRuntimeEntry.argument_count());
+  Isolate* isolate = arguments.isolate();
   const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
   const Code& target_code =
-      Code::Handle(ResolveCompileInstanceCallTarget(receiver));
+      Code::Handle(ResolveCompileInstanceCallTarget(isolate, receiver));
   if (target_code.IsNull()) {
     // Let the megamorphic stub handle special cases: NoSuchMethod,
     // closure calls.
     if (FLAG_trace_ic) {
       OS::Print("InlineCacheMissHandler NULL code for receiver: %s\n",
           receiver.ToCString());
     }
     arguments.SetReturn(target_code);
     return;
   }
@@ skipping 24 matching lines @@
   arguments.SetReturn(target_function);
   if (FLAG_trace_ic) {
     OS::Print("InlineCacheMissHandler call at 0x%x' adding <%s> -> <%s>\n",
         caller_frame->pc(),
         Class::Handle(receiver.clazz()).ToCString(),
         target_function.ToCString());
   }
 }
 
 
-static RawFunction* LookupDynamicFunction(const Class& in_cls,
+static RawFunction* LookupDynamicFunction(Isolate* isolate,
+                                          const Class& in_cls,
                                           const String& name) {
   Class& cls = Class::Handle();
   // For lookups treat null as an instance of class Object.
   if (in_cls.IsNullClass()) {
-    cls = Isolate::Current()->object_store()->object_class();
+    cls = isolate->object_store()->object_class();
   } else {
     cls = in_cls.raw();
   }
 
   Function& function = Function::Handle();
   while (!cls.IsNull()) {
     // Check if function exists.
     function = cls.LookupDynamicFunction(name);
     if (!function.IsNull()) {
       break;
     }
     cls = cls.SuperClass();
   }
   return function.raw();
 }
 
 
 // Resolve an implicit closure by checking if an instance function
 // of the same name exists and creating a closure object of the function.
 // Arg0: receiver object.
 // Arg1: ic-data array.
 // Returns: Closure object or NULL (instance function not found).
 // This is called by the megamorphic stub when it is unable to resolve an
 // instance method. This is done just before the call to noSuchMethod.
 DEFINE_RUNTIME_ENTRY(ResolveImplicitClosureFunction, 2) {
   ASSERT(arguments.Count() ==
          kResolveImplicitClosureFunctionRuntimeEntry.argument_count());
+  Isolate* isolate = arguments.isolate();
   const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
   const Array& ic_data_array = Array::CheckedHandle(arguments.At(1));
   ICData ic_data(ic_data_array);
   const String& original_function_name = String::Handle(ic_data.FunctionName());
   const String& getter_prefix = String::Handle(String::New("get:"));
   Closure& closure = Closure::Handle();
   if (!original_function_name.StartsWith(getter_prefix)) {
     // This is not a getter so can't be the case where we are trying to
     // create an implicit closure of an instance function.
     arguments.SetReturn(closure);
     return;
   }
   Class& receiver_class = Class::Handle();
   receiver_class ^= receiver.clazz();
   ASSERT(!receiver_class.IsNull());
   String& func_name = String::Handle();
   func_name = String::SubString(original_function_name, getter_prefix.Length());
   func_name = String::NewSymbol(func_name);
-  const Function& function =
-      Function::Handle(LookupDynamicFunction(receiver_class, func_name));
+  const Function& function = Function::Handle(
+      LookupDynamicFunction(isolate, receiver_class, func_name));
   if (function.IsNull()) {
     // There is no function of the same name so can't be the case where
     // we are trying to create an implicit closure of an instance function.
     arguments.SetReturn(closure);
     return;
   }
   Function& implicit_closure_function =
       Function::Handle(function.ImplicitClosureFunction());
   // Create a closure object for the implicit closure function.
   const Context& context = Context::Handle(Context::New(1));
@@ skipping 199 matching lines @@
   ASSERT(arguments.Count() ==
          kClosureArgumentMismatchRuntimeEntry.argument_count());
   GrowableArray<const Object*> args;
   Exceptions::ThrowByType(Exceptions::kClosureArgumentMismatch, args);
 }
 
 
 DEFINE_RUNTIME_ENTRY(StackOverflow, 0) {
   ASSERT(arguments.Count() ==
          kStackOverflowRuntimeEntry.argument_count());
-  uword old_stack_limit = Isolate::Current()->stack_limit();
-  Isolate::Current()->AdjustStackLimitForException();
+  Isolate* isolate = arguments.isolate();

[Ivan Posva, 2011/11/11 22:07:07]

This is such a repeating pattern that we might consider passing it as a
parameter into these functions.

[siva, 2011/11/12 03:01:05]

Done.

+  uword old_stack_limit = isolate->stack_limit();
+  isolate->AdjustStackLimitForException();
   // Recursive stack overflow check.
-  ASSERT(old_stack_limit != Isolate::Current()->stack_limit());
+  ASSERT(old_stack_limit != isolate->stack_limit());
   GrowableArray<const Object*> args;
   Exceptions::ThrowByType(Exceptions::kStackOverflow, args);
-  Isolate::Current()->ResetStackLimitAfterException();
+  isolate->ResetStackLimitAfterException();
 }
 
 
 // Only unoptimized code has invocation counter threshold checking.
 // Once the invocation counter threshold is reached any entry into the
 // unoptimized code is redirected to this function.
 DEFINE_RUNTIME_ENTRY(OptimizeInvokedFunction, 1) {
   ASSERT(arguments.Count() ==
          kOptimizeInvokedFunctionRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.At(0));
@@ skipping 51 matching lines @@
 
 
 // The top Dart frame belongs to the optimized method that needs to be
 // deoptimized. The pc of the Dart frame points to the deoptimization point.
 // Find the node id of the deoptimization point and find the continuation
 // pc in the unoptimized code.
 // Since both unoptimized and optimized code have the same layout, we need only
 // to patch the pc of the Dart frame and to disable/enable appropriate code.
 DEFINE_RUNTIME_ENTRY(Deoptimize, 0) {
   ASSERT(arguments.Count() == kDeoptimizeRuntimeEntry.argument_count());
+  Isolate* isolate = arguments.isolate();
   DartFrameIterator iterator;
   DartFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
-  CodeIndexTable* ci_table = Isolate::Current()->code_index_table();
+  CodeIndexTable* ci_table = isolate->code_index_table();
   const Code& optimized_code =
       Code::Handle(ci_table->LookupCode(caller_frame->pc()));
   const Function& function = Function::Handle(optimized_code.function());
   ASSERT(!function.IsNull());
   const Code& unoptimized_code = Code::Handle(function.unoptimized_code());
   ASSERT(!optimized_code.IsNull() && optimized_code.is_optimized());
   ASSERT(!unoptimized_code.IsNull() && !unoptimized_code.is_optimized());
   const PcDescriptors& descriptors =
       PcDescriptors::Handle(optimized_code.pc_descriptors());
   ASSERT(!descriptors.IsNull());
@@ skipping 110 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart