For megamorphic calls (IC calls in optimized code), use a stub without attempting to count usage of…

runtime/vm/stub_code_ia32.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/globals.h"
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/assembler.h"
 #include "vm/assembler_macros.h"
 #include "vm/compiler.h"
@@ skipping 1525 matching lines @@
   __ popl(EAX);
   __ popl(EAX);
   __ popl(EAX);  // Get result into EAX.
 
   // Remove the stub frame as we are about to return.
   __ LeaveFrame();
   __ ret();
 }
 
 
+// Loads function into 'temp_reg', preserves 'ic_reg'.
+void StubCode::GenerateUsageCounterIncrement(Assembler* assembler,
+                                             Register ic_reg,
+                                             Register temp_reg) {
+  __ movl(temp_reg, FieldAddress(ic_reg, ICData::function_offset()));
+  Label is_hot;
+  if (FlowGraphCompiler::CanOptimize()) {
+    ASSERT(FLAG_optimization_counter_threshold > 1);
+    // The usage_counter is always less than FLAG_optimization_counter_threshold
+    // except when the function gets optimized.
+    __ cmpl(FieldAddress(temp_reg, Function::usage_counter_offset()),
+        Immediate(FLAG_optimization_counter_threshold - 1));
+    // Do not increment to equality with threshold, since a counter greater
+    // than threshold denotes a function that was already optimized.
+    // The equality should be reached only at exit of the method
+    // (return instruction).
+    __ j(EQUAL, &is_hot, Assembler::kNearJump);
+    // As long as VM has no OSR do not optimize in the middle of the function
+    // but only at exit so that we have collected all type feedback before
+    // optimizing.
+  }
+  __ incl(FieldAddress(temp_reg, Function::usage_counter_offset()));
+  __ Bind(&is_hot);
+}
+
 
 // Generate inline cache check for 'num_args'.
 //  ECX: Inline cache data object.
 //  EDX: Arguments descriptor array.
 //  TOS(0): return address
 // Control flow:
 // - If receiver is null -> jump to IC miss.
 // - If receiver is Smi -> load Smi class.
 // - If receiver is not-Smi -> load receiver's class.
 // - Check if 'num_args' (including receiver) match any IC data group.
 // - Match found -> jump to target.
 // - Match not found -> jump to IC miss.
 void StubCode::GenerateNArgsCheckInlineCacheStub(Assembler* assembler,
                                                  intptr_t num_args) {
   ASSERT(num_args > 0);
 #if defined(DEBUG)
   { Label ok;
     // Check that the IC data array has NumberOfArgumentsChecked() == num_args.
     // 'num_args_tested' is stored as an untagged int.
     __ movl(EBX, FieldAddress(ECX, ICData::num_args_tested_offset()));
     __ cmpl(EBX, Immediate(num_args));
     __ j(EQUAL, &ok, Assembler::kNearJump);
     __ Stop("Incorrect stub for IC data");
     __ Bind(&ok);
   }
 #endif  // DEBUG
 
-  __ movl(EBX, FieldAddress(ECX, ICData::function_offset()));
-  Label is_hot;
-  if (FlowGraphCompiler::CanOptimize()) {
-    ASSERT(FLAG_optimization_counter_threshold > 1);
-    // The usage_counter is always less than FLAG_optimization_counter_threshold
-    // except when the function gets optimized.
-    __ cmpl(FieldAddress(EBX, Function::usage_counter_offset()),
-        Immediate(FLAG_optimization_counter_threshold - 1));
-    // Do not increment to equality with threshold, since a counter greater
-    // than threshold denotes a function that was already optimized.
-    // The equality should be reached only at exit of the method
-    // (return instruction).
-    __ j(EQUAL, &is_hot, Assembler::kNearJump);
-    // As long as VM has no OSR do not optimize in the middle of the function
-    // but only at exit so that we have collected all type feedback before
-    // optimizing.
-  }
-  __ incl(FieldAddress(EBX, Function::usage_counter_offset()));
-  __ Bind(&is_hot);
-
   // Loop that checks if there is an IC data match.
   Label loop, update, test, found, get_class_id_as_smi;
   // ECX: IC data object (preserved).
   __ movl(EBX, FieldAddress(ECX, ICData::ic_data_offset()));
   // EBX: ic_data_array with check entries: classes and target functions.
   __ leal(EBX, FieldAddress(EBX, Array::data_offset()));
   // EBX: points directly to the first ic data array element.
 
   // Get the receiver's class ID (first read number of arguments from
   // argument descriptor array and then access the receiver from the stack).
@@ skipping 102 matching lines @@
 
   __ Bind(&not_smi);
   __ LoadClassId(EAX, EAX);
   __ SmiTag(EAX);
   __ ret();
 }
 
 
 // Use inline cache data array to invoke the target or continue in inline
 // cache miss handler. Stub for 1-argument check (receiver class).
-//  ECX: Inline cache data array
-//  EDX: Arguments array
-//  TOS(0): return address
-// Inline cache data array structure:
+//  ECX: Inline cache data object.
+//  EDX: Arguments array.
+//  TOS(0): Return address.
+// Inline cache data object structure:
 // 0: function-name
 // 1: N, number of arguments checked.
 // 2 .. (length - 1): group of checks, each check containing:
 //   - N classes.
 //   - 1 target function.
 void StubCode::GenerateOneArgCheckInlineCacheStub(Assembler* assembler) {
+  GenerateUsageCounterIncrement(assembler, ECX, EBX);
   return GenerateNArgsCheckInlineCacheStub(assembler, 1);
 }
 
 
 void StubCode::GenerateTwoArgsCheckInlineCacheStub(Assembler* assembler) {
+  GenerateUsageCounterIncrement(assembler, ECX, EBX);
   return GenerateNArgsCheckInlineCacheStub(assembler, 2);
 }
 
 
 void StubCode::GenerateThreeArgsCheckInlineCacheStub(Assembler* assembler) {
+  GenerateUsageCounterIncrement(assembler, ECX, EBX);
   return GenerateNArgsCheckInlineCacheStub(assembler, 3);
 }
 
 
+// Megamorphic call is currently implemented as IC call but through a stub
+// that does not check/count function invocations.
+void StubCode::GenerateMegamorphicCallStub(Assembler* assembler) {
+  return GenerateNArgsCheckInlineCacheStub(assembler, 1);
+}
+
+
 //  ECX: Function object.
 //  EDX: Arguments array.
 //  TOS(0): return address (Dart code).
 void StubCode::GenerateBreakpointStaticStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   AssemblerMacros::EnterStubFrame(assembler);
   __ pushl(EDX);
   __ pushl(ECX);
   __ CallRuntime(kBreakpointStaticHandlerRuntimeEntry);
@@ skipping 304 matching lines @@
   __ Drop(4);
   __ LeaveFrame();
 
   __ jmp(&compute_result, Assembler::kNearJump);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32