Simplify handling of IC and megamorphic cache misses.

runtime/vm/stub_code_x64.cc

 // Copyright (c) 2013, 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/globals.h"
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 363 matching lines @@
   __ movq(RAX, Address(R12, 0));
   __ movq(Address(RBX, 0), RAX);
   __ addq(RBX, Immediate(kWordSize));
   __ subq(R12, Immediate(kWordSize));
   __ Bind(&loop_condition);
   __ decq(R10);
   __ j(POSITIVE, &loop, Assembler::kNearJump);
 }
 
 
-// Input parameters:
-//   RBX: ic-data.
-//   R10: arguments descriptor array.
-// Note: The receiver object is the first argument to the function being
-//       called, the stub accesses the receiver from this location directly
-//       when trying to resolve the call.
-void StubCode::GenerateInstanceFunctionLookupStub(Assembler* assembler) {
-  __ EnterStubFrame();
-  __ PushObject(Object::null_object(), PP);  // Space for the return value.
-
-  // Push the receiver as an argument.  Load the smi-tagged argument
-  // count into R13 to index the receiver in the stack.  There are
-  // four words (null, stub's pc marker, saved pp, saved fp) above the return
-  // address.
-  __ movq(R13, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
-  __ pushq(Address(RSP, R13, TIMES_4, (4 * kWordSize)));
-
-  __ pushq(RBX);  // Pass IC data object.
-  __ pushq(R10);  // Pass arguments descriptor array.
-
-  // Pass the call's arguments array.
-  __ movq(R10, R13);  // Smi-tagged arguments array length.
-  PushArgumentsArray(assembler);
-
-  __ CallRuntime(kInstanceFunctionLookupRuntimeEntry, 4);
-
-  // Remove arguments.
-  __ Drop(4);
-  __ popq(RAX);  // Get result into RAX.
-  __ LeaveStubFrame();
-  __ ret();
-}
-
-
 DECLARE_LEAF_RUNTIME_ENTRY(intptr_t, DeoptimizeCopyFrame,
                            intptr_t deopt_reason,
                            uword saved_registers_address);
 
 DECLARE_LEAF_RUNTIME_ENTRY(void, DeoptimizeFillFrame, uword last_fp);
 
 
 // Used by eager and lazy deoptimization. Preserve result in RAX if necessary.
 // This stub translates optimized frame into unoptimized frame. The optimized
 // frame can contain values in registers and on stack, the unoptimized
@@ skipping 143 matching lines @@
   // Space for the result of the runtime call.
   __ PushObject(Object::null_object(), PP);
   __ pushq(RAX);  // Receiver.
   __ pushq(RBX);  // IC data.
   __ pushq(R10);  // Arguments descriptor.
   __ CallRuntime(kMegamorphicCacheMissHandlerRuntimeEntry, 3);
   // Discard arguments.
   __ popq(RAX);
   __ popq(RAX);
   __ popq(RAX);
-  __ popq(RAX);  // Return value from the runtime call (instructions).
+  __ popq(RAX);  // Return value from the runtime call (function).
   __ popq(R10);  // Restore arguments descriptor.
   __ popq(RBX);  // Restore IC data.
   __ LeaveStubFrame();
 
-  Label lookup;
-  __ CompareObject(RAX, Object::null_object(), PP);
-  __ j(EQUAL, &lookup, Assembler::kNearJump);
-  __ addq(RAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
-  __ jmp(RAX);
-
-  __ Bind(&lookup);
-  __ jmp(&StubCode::InstanceFunctionLookupLabel());
+  __ movq(RCX, FieldAddress(RAX, Function::code_offset()));
+  __ movq(RCX, FieldAddress(RCX, Code::instructions_offset()));
+  __ addq(RCX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
+  __ jmp(RCX);
 }
 
 
 // Called for inline allocation of arrays.
 // Input parameters:
 //   R10 : Array length as Smi.
 //   RBX : array element type (either NULL or an instantiated type).
 // NOTE: R10 cannot be clobbered here as the caller relies on it being saved.
 // The newly allocated object is returned in RAX.
 void StubCode::GenerateAllocateArrayStub(Assembler* assembler) {
@@ skipping 155 matching lines @@
   // Actual class is not a closure class.
   __ j(EQUAL, &not_closure, Assembler::kNearJump);
 
   // RAX is just the signature function. Load the actual closure function.
   __ movq(RAX, FieldAddress(R13, Closure::function_offset()));
 
   // Load closure context in CTX; note that CTX has already been preserved.
   __ movq(CTX, FieldAddress(R13, Closure::context_offset()));
 
   // Load closure function code in RAX.
-  __ movq(RBX, FieldAddress(RAX, Function::code_offset()));
+  __ movq(RCX, FieldAddress(RAX, Function::code_offset()));
 
   // RAX: Function.
   // R10: Arguments descriptor array.
-  __ movq(RCX, FieldAddress(RBX, Code::instructions_offset()));
+  __ movq(RCX, FieldAddress(RCX, Code::instructions_offset()));
   __ addq(RCX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(RCX);
 
   __ Bind(&not_closure);
   // Call runtime to attempt to resolve and invoke a call method on a
   // non-closure object, passing the non-closure object and its arguments array,
   // returning here.
   // If no call method exists, throw a NoSuchMethodError.
   // R13: non-closure object.
   // R10: arguments descriptor array.
@@ skipping 655 matching lines @@
   for (intptr_t i = 0; i < num_args; i++) {
     __ movq(RCX, Address(RAX, -kWordSize * i));
     __ pushq(RCX);
   }
   __ pushq(RBX);  // Pass IC data object.
   __ CallRuntime(handle_ic_miss, num_args + 1);
   // Remove the call arguments pushed earlier, including the IC data object.
   for (intptr_t i = 0; i < num_args + 1; i++) {
     __ popq(RAX);
   }
-  __ popq(RAX);  // Pop returned code object into RAX (null if not found).
+  __ popq(RAX);  // Pop returned function object into RAX.
   __ popq(RBX);  // Restore IC data array.
   __ popq(R10);  // Restore arguments descriptor array.
   __ LeaveStubFrame();
   Label call_target_function;
-  __ cmpq(RAX, R12);
-  __ j(NOT_EQUAL, &call_target_function, Assembler::kNearJump);
-  // NoSuchMethod or closure.
-  // Mark IC call that it may be a closure call that does not collect
-  // type feedback.
-  __ movb(FieldAddress(RBX, ICData::is_closure_call_offset()), Immediate(1));
-  __ jmp(&StubCode::InstanceFunctionLookupLabel());
+  __ jmp(&call_target_function);
 
   __ Bind(&found);
   // R12: Pointer to an IC data check group.
   const intptr_t target_offset = ICData::TargetIndexFor(num_args) * kWordSize;
   const intptr_t count_offset = ICData::CountIndexFor(num_args) * kWordSize;
   __ movq(RAX, Address(R12, target_offset));
   __ addq(Address(R12, count_offset), Immediate(Smi::RawValue(1)));
   __ j(NO_OVERFLOW, &call_target_function, Assembler::kNearJump);
   __ movq(Address(R12, count_offset),
           Immediate(Smi::RawValue(Smi::kMaxValue)));
@@ skipping 489 matching lines @@
 
   __ movq(left, Address(RSP, 2 * kWordSize));
   __ movq(right, Address(RSP, 1 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64