Using type feedback, eliminate store barriers for indexed stores.

runtime/vm/stub_code_ia32.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/globals.h"
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/assembler.h"
 #include "vm/assembler_macros.h"
 #include "vm/compiler.h"
@@ skipping 1537 matching lines @@
 //  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.
-// TODO(srdjan): Change IC data to keep class ids as integers not as Smi-s.
 void StubCode::GenerateNArgsCheckInlineCacheStub(Assembler* assembler,
                                                  intptr_t num_args) {
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
 
   __ 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
@@ skipping 43 matching lines @@
   if (num_args == 1) {
     __ call(&get_class_id_as_smi);
     // EAX: receiver's class id Smi.
     __ Bind(&loop);
     __ movl(EDI, Address(EBX, 0));  // Get class id (Smi) to check.
     __ cmpl(EAX, EDI);  // Class id match?
     __ j(EQUAL, &found, Assembler::kNearJump);
     __ addl(EBX, Immediate(kWordSize * 2));  // Next element (class + target).
     __ cmpl(EDI, Immediate(Smi::RawValue(kIllegalCid)));  // Done?
     __ j(NOT_EQUAL, &loop, Assembler::kNearJump);
-  } else if (num_args == 2) {
-    // EDI: class to check.
+  } else {
     Label no_match;
     __ Bind(&loop);
-    // Get class id from IC data to check.
-    // Get receiver using argument descriptor in EDX.
-    __ movl(EAX, FieldAddress(EDX, Array::data_offset()));
-    __ movl(EAX, Address(ESP, EAX, TIMES_2, 0));  // EAX (arg. count) is Smi.
-    __ call(&get_class_id_as_smi);
-    __ movl(EDI, Address(EBX, 0));
-    __ cmpl(EAX, EDI);  // Class id match?
-    __ j(NOT_EQUAL, &no_match, Assembler::kNearJump);
-    // Check second class/argument.
-    // Get class id from IC data to check.
-    // Get next argument.
-    __ movl(EAX, FieldAddress(EDX, Array::data_offset()));
-    __ movl(EAX, Address(ESP, EAX, TIMES_2, -kWordSize));
-    // EAX (argument count) is Smi.
-    __ call(&get_class_id_as_smi);
-    __ movl(EDI, Address(EBX, kWordSize));
-    __ cmpl(EAX, EDI);  // Class id match?
-    __ j(EQUAL, &found, Assembler::kNearJump);
+    for (int i = 0; i < num_args; i++) {
+      __ movl(EAX, FieldAddress(EDX, Array::data_offset()));
+      __ movl(EAX, Address(ESP, EAX, TIMES_2, - i * kWordSize));
+      __ call(&get_class_id_as_smi);
+      __ movl(EDI, Address(EBX, i * kWordSize));
+      __ cmpl(EAX, EDI);  // Class id match?
+      if (i < (num_args - 1)) {
+        __ j(NOT_EQUAL, &no_match);
+      } else {
+        // Last check, all checks before matched.
+        __ j(EQUAL, &found, Assembler::kNearJump);
+      }
+    }
     __ Bind(&no_match);
     // Each test entry has (1 + num_args) array elements.
     __ addl(EBX, Immediate(kWordSize * (1 + num_args)));  // Next element.
     __ cmpl(EDI, Immediate(Smi::RawValue(kIllegalCid)));  // Done?
     __ j(NOT_EQUAL, &loop, Assembler::kNearJump);
   }
 
   __ Bind(&ic_miss);
   // Compute address of arguments (first read number of arguments from argument
   // descriptor array and then compute address on the stack).
   __ movl(EAX, FieldAddress(EDX, Array::data_offset()));
   __ leal(EAX, Address(ESP, EAX, TIMES_2, 0));  // EAX is Smi.
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   AssemblerMacros::EnterStubFrame(assembler);
   __ pushl(EDX);  // Preserve arguments array.
   __ pushl(ECX);  // Preserve IC data array
   __ pushl(raw_null);  // Setup space on stack for result (target code object).
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
     __ movl(EDX, Address(EAX, -kWordSize * i));
     __ pushl(EDX);
   }
   if (num_args == 1) {
     __ CallRuntime(kInlineCacheMissHandlerOneArgRuntimeEntry);
   } else if (num_args == 2) {
     __ CallRuntime(kInlineCacheMissHandlerTwoArgsRuntimeEntry);
+  } else if (num_args == 3) {
+    __ CallRuntime(kInlineCacheMissHandlerThreeArgsRuntimeEntry);
   } else {
     UNIMPLEMENTED();
   }
   // Remove call arguments pushed earlier.
   for (intptr_t i = 0; i < num_args; i++) {
     __ popl(EAX);
   }
   __ popl(EAX);  // Pop returned code object into EAX (null if not found).
   __ popl(ECX);  // Restore IC data array.
   __ popl(EDX);  // Restore arguments array.
   __ LeaveFrame();
   Label call_target_function;
   __ cmpl(EAX, raw_null);
   __ j(NOT_EQUAL, &call_target_function, Assembler::kNearJump);
   // NoSuchMethod or closure.
   __ jmp(&StubCode::InstanceFunctionLookupLabel());
 
   __ Bind(&found);
   // EBX: Pointer to an IC data check group (classes + target)
   __ movl(EAX, Address(EBX, kWordSize * num_args));  // Target function.
 
   __ Bind(&call_target_function);
   // EAX: Target function.
   __ movl(EAX, FieldAddress(EAX, Function::code_offset()));
   __ movl(EAX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(EAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(EAX);
 
+  // Instance in EAX, return its class-id in EAX as Smi.
   __ Bind(&get_class_id_as_smi);
   Label not_smi;
   // Test if Smi -> load Smi class for comparison.
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &not_smi, Assembler::kNearJump);
   __ movl(EAX, Immediate(Smi::RawValue(kSmiCid)));
   __ ret();
 
   __ Bind(&not_smi);
   __ LoadClassId(EAX, EAX);
@@ skipping 15 matching lines @@
 //   - 1 target function.
 void StubCode::GenerateOneArgCheckInlineCacheStub(Assembler* assembler) {
   return GenerateNArgsCheckInlineCacheStub(assembler, 1);
 }
 
 
 void StubCode::GenerateTwoArgsCheckInlineCacheStub(Assembler* assembler) {
   return GenerateNArgsCheckInlineCacheStub(assembler, 2);
 }
 
+
+void StubCode::GenerateThreeArgsCheckInlineCacheStub(Assembler* assembler) {
+  return GenerateNArgsCheckInlineCacheStub(assembler, 3);
+}
+
+
 //  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 44 matching lines @@
   __ LeaveFrame();
 
   // Find out which dispatch stub to call.
   Label ic_cache_one_arg;
   __ movl(EBX, FieldAddress(ECX, ICData::num_args_tested_offset()));
   __ cmpl(EBX, Immediate(1));
   __ j(EQUAL, &ic_cache_one_arg, Assembler::kNearJump);
   __ jmp(&StubCode::TwoArgsCheckInlineCacheLabel());
   __ Bind(&ic_cache_one_arg);
   __ jmp(&StubCode::OneArgCheckInlineCacheLabel());
+
+  Label test_two, test_three, test_four;

[Vyacheslav Egorov (Google), 2012/09/12 15:38:09]

I think you need to remove the code above (this code replaces it).

[srdjan, 2012/09/12 15:45:25]

Done.

+  __ movl(EBX, FieldAddress(ECX, ICData::num_args_tested_offset()));
+  __ cmpl(EBX, Immediate(1));
+  __ j(NOT_EQUAL, &test_two, Assembler::kNearJump);
+  __ jmp(&StubCode::OneArgCheckInlineCacheLabel());
+  __ Bind(&test_two);
+  __ cmpl(EBX, Immediate(2));
+  __ j(NOT_EQUAL, &test_three, Assembler::kNearJump);
+  __ jmp(&StubCode::TwoArgsCheckInlineCacheLabel());
+  __ Bind(&test_three);
+  __ cmpl(EBX, Immediate(3));
+  __ j(NOT_EQUAL, &test_four, Assembler::kNearJump);
+  __ jmp(&StubCode::ThreeArgsCheckInlineCacheLabel());
+  __ Bind(&test_four);
+  __ Stop("Unsupported number of arguments tested.");
 }
 
 
 // Used to check class and type arguments. Arguments passed on stack:
 // TOS + 0: return address.
 // TOS + 1: instantiator type arguments (can be NULL).
 // TOS + 2: instance.
 // TOS + 3: SubtypeTestCache.
 // Result in ECX: null -> not found, otherwise result (true or false).
 static void GenerateSubtypeNTestCacheStub(Assembler* assembler, int n) {
@@ skipping 141 matching lines @@
   __ movl(EAX, Address(ESP, 4 * kWordSize));  // Load error object.
   __ movl(EBP, Address(ESP, 3 * kWordSize));  // Load target frame_pointer.
   __ movl(EBX, Address(ESP, 1 * kWordSize));  // Load target PC into EBX.
   __ movl(ESP, Address(ESP, 2 * kWordSize));  // Load target stack_pointer.
   __ jmp(EBX);  // Jump to the exception handler code.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32