Pass IC data and arguments descriptor to IC miss runtime functions.

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 773 matching lines @@
         target_function.ToFullyQualifiedCString(),
         target_code.EntryPoint());
   }
   arguments.SetReturn(target_code);
 }
 
 
 // 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.
-RawCode* ResolveCompileInstanceCallTarget(Isolate* isolate,
-                                          const Instance& receiver) {
-  int num_arguments = -1;
-  int num_named_arguments = -1;
-  uword target = 0;
-  String& function_name = String::Handle();
-  DartFrameIterator iterator;
-  StackFrame* caller_frame = iterator.NextFrame();
-  ASSERT(caller_frame != NULL);
-  CodePatcher::GetInstanceCallAt(caller_frame->pc(),
-                                 &function_name,
-                                 &num_arguments,
-                                 &num_named_arguments,
-                                 &target);
+RawCode* ResolveCompileInstanceCallTarget(
+    const Instance& receiver,
+    const ICData& ic_data,
+    const ArgumentsDescriptor& arguments_descriptor) {
+  intptr_t num_arguments = arguments_descriptor.Count();
+  int num_named_arguments = arguments_descriptor.NamedCount();
+  String& function_name = String::Handle(ic_data.target_name());
   ASSERT(function_name.IsSymbol());
 
   Function& function = Function::Handle();
   function = Resolver::ResolveDynamic(receiver,
                                       function_name,
                                       num_arguments,
                                       num_named_arguments);
   if (function.IsNull()) {
     return Code::null();
   } else {
@@ skipping 12 matching lines @@
 // rethrow it.
 static void CheckResultError(const Object& result) {
   if (result.IsError()) {
     Exceptions::PropagateError(Error::Cast(result));
   }
 }
 
 
 // Resolves an instance function and compiles it if necessary.
 //   Arg0: receiver object.
+//   Arg1: IC data object.
+//   Arg2: Arguments descriptor array.
 //   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) {
+DEFINE_RUNTIME_ENTRY(ResolveCompileInstanceFunction, 3) {
   ASSERT(arguments.ArgCount() ==
          kResolveCompileInstanceFunctionRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
-  const Code& code = Code::Handle(
-      ResolveCompileInstanceCallTarget(isolate, receiver));
+  const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
+  ArgumentsDescriptor arg_descriptor(arguments.ArgAt(2));
+  const Code& code =
+      Code::Handle(ResolveCompileInstanceCallTarget(receiver,
+                                                    ic_data,
+                                                    arg_descriptor));
   arguments.SetReturn(code);
 }
 
 
 // Gets called from debug stub when code reaches a breakpoint.
 DEFINE_RUNTIME_ENTRY(BreakpointStaticHandler, 0) {
   ASSERT(arguments.ArgCount() ==
       kBreakpointStaticHandlerRuntimeEntry.argument_count());
   ASSERT(isolate->debugger() != NULL);
   isolate->debugger()->SignalBpReached();
@@ skipping 30 matching lines @@
 // Gets called from debug stub when code reaches a breakpoint.
 DEFINE_RUNTIME_ENTRY(BreakpointDynamicHandler, 0) {
   ASSERT(arguments.ArgCount() ==
      kBreakpointDynamicHandlerRuntimeEntry.argument_count());
   ASSERT(isolate->debugger() != NULL);
   isolate->debugger()->SignalBpReached();
 }
 
 
 static RawFunction* InlineCacheMissHandler(
-    Isolate* isolate, const GrowableArray<const Instance*>& args) {
+    const GrowableArray<const Instance*>& args,
+    const ICData& ic_data,
+    const ArgumentsDescriptor& arg_descriptor) {
   const Instance& receiver = *args[0];
   const Code& target_code =
-      Code::Handle(ResolveCompileInstanceCallTarget(isolate, receiver));
+      Code::Handle(ResolveCompileInstanceCallTarget(receiver,
+                                                    ic_data,
+                                                    arg_descriptor));
   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());
     }
     return Function::null();
   }
   const Function& target_function =
       Function::Handle(target_code.function());
   ASSERT(!target_function.IsNull());
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
-  ICData& ic_data = ICData::Handle(
-      CodePatcher::GetInstanceCallIcDataAt(caller_frame->pc()));
   if (args.length() == 1) {
     ic_data.AddReceiverCheck(Class::Handle(args[0]->clazz()).id(),
                              target_function);
   } else {
     GrowableArray<intptr_t> class_ids(args.length());
     ASSERT(ic_data.num_args_tested() == args.length());
     for (intptr_t i = 0; i < args.length(); i++) {
       class_ids.Add(Class::Handle(args[i]->clazz()).id());
     }
     ic_data.AddCheck(class_ids, target_function);
@@ skipping 15 matching lines @@
         Class::Handle(receiver.clazz()).id(),
         target_function.ToCString());
   }
   return target_function.raw();
 }
 
 
 // Handles inline cache misses by updating the IC data array of the call
 // site.
 //   Arg0: Receiver object.
+//   Arg1: IC data object.
+//   Arg2: Arguments descriptor array.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
-DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerOneArg, 1) {
+DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerOneArg, 3) {
   ASSERT(arguments.ArgCount() ==
       kInlineCacheMissHandlerOneArgRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
+  const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
+  ArgumentsDescriptor arg_descriptor(arguments.ArgAt(2));
   GrowableArray<const Instance*> args(1);
   args.Add(&receiver);
   const Function& result =
-      Function::Handle(InlineCacheMissHandler(isolate, args));
+      Function::Handle(InlineCacheMissHandler(args, ic_data, arg_descriptor));
   arguments.SetReturn(result);
 }
 
 
 // Handles inline cache misses by updating the IC data array of the call
 // site.
 //   Arg0: Receiver object.
 //   Arg1: Argument after receiver.
+//   Arg2: IC data object.
+//   Arg3: Arguments descriptor array.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
-DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerTwoArgs, 2) {
+DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerTwoArgs, 4) {
   ASSERT(arguments.ArgCount() ==
       kInlineCacheMissHandlerTwoArgsRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& other = Instance::CheckedHandle(arguments.ArgAt(1));
+  const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(2));
+  ArgumentsDescriptor arg_descriptor(arguments.ArgAt(3));
   GrowableArray<const Instance*> args(2);
   args.Add(&receiver);
   args.Add(&other);
   const Function& result =
-      Function::Handle(InlineCacheMissHandler(isolate, args));
+      Function::Handle(InlineCacheMissHandler(args, ic_data, arg_descriptor));
   arguments.SetReturn(result);
 }
 
 
 // Handles inline cache misses by updating the IC data array of the call
 // site.
 //   Arg0: Receiver object.
 //   Arg1: Argument after receiver.
 //   Arg2: Second argument after receiver.
+//   Arg3: IC data object.
+//   Arg4: Arguments descriptor array.
 //   Returns: target function with compiled code or null.
 // Modifies the instance call to hold the updated IC data array.
-DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerThreeArgs, 3) {
+DEFINE_RUNTIME_ENTRY(InlineCacheMissHandlerThreeArgs, 5) {
   ASSERT(arguments.ArgCount() ==
       kInlineCacheMissHandlerThreeArgsRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& arg1 = Instance::CheckedHandle(arguments.ArgAt(1));
   const Instance& arg2 = Instance::CheckedHandle(arguments.ArgAt(2));
+  const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(3));
+  ArgumentsDescriptor arg_descriptor(arguments.ArgAt(4));
   GrowableArray<const Instance*> args(3);
   args.Add(&receiver);
   args.Add(&arg1);
   args.Add(&arg2);
   const Function& result =
-      Function::Handle(InlineCacheMissHandler(isolate, args));
+      Function::Handle(InlineCacheMissHandler(args, ic_data, arg_descriptor));
   arguments.SetReturn(result);
 }
 
 
 // Updates IC data for two arguments. Used by the equality operation when
 // the control flow bypasses regular inline cache (null arguments).
 //   Arg0: Receiver object.
 //   Arg1: Argument after receiver.
 //   Arg2: Target's name.
 //   Arg3: ICData.
@@ skipping 859 matching lines @@
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
   HANDLESCOPE(isolate);
   const Bigint& big_left = Bigint::Handle(left);
   const Bigint& big_right = Bigint::Handle(right);
   return BigintOperations::Compare(big_left, big_right);
 }
 END_LEAF_RUNTIME_ENTRY
 
 }  // namespace dart