In optimized code use IC calls for instance calls that have no IC data instead of deoptimizing. The…

runtime/vm/intermediate_language_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"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 24 matching lines @@
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(EAX));
   locs->set_temp(0, Location::RegisterLocation(EDX));
   return locs;
 }
 
 
+// Attempt optimized compilation at return instruction instead of at the entry.
+// The entry needs to be patchable, no inlined objects are allowed in the area
+// that will be overwritten by the patch instruction: a jump).
 void ReturnInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  const Function& function =
+      Function::ZoneHandle(compiler->parsed_function().function().raw());
   Register result = locs()->in(0).reg();
   Register func_reg = locs()->temp(0).reg();
   ASSERT(result == EAX);
-  if (!compiler->is_optimizing()) {
-    // Count only in unoptimized code.
-    // TODO(srdjan): Replace the counting code with a type feedback
-    // collection and counting stub.
-    const Function& function =
-          Function::ZoneHandle(compiler->parsed_function().function().raw());
+  if (compiler->is_optimizing()) {
+    if (compiler->may_reoptimize()) {
+      // Increment of counter occurs only in optimized IC calls, as they
+      // can cause reoptimization.
+      Label done;
+      __ LoadObject(func_reg, function);
+      __ cmpl(FieldAddress(func_reg, Function::usage_counter_offset()),
+          Immediate(FLAG_optimization_counter_threshold));
+      __ j(LESS, &done, Assembler::kNearJump);
+      // Equal (or greater), optimize. Note that counter can reach equality
+      // only at return instruction.
+      // The stub call preserves result register (EAX).
+      ASSERT(func_reg == EDX);
+      compiler->GenerateCall(0,  // no token position.
+                             &StubCode::OptimizeFunctionLabel(),
+                             PcDescriptors::kOther,
+                             locs());
+      __ Bind(&done);
+    }
+  } else {
     __ LoadObject(func_reg, function);
     __ incl(FieldAddress(func_reg, Function::usage_counter_offset()));
     if (FlowGraphCompiler::CanOptimize() &&
         compiler->parsed_function().function().is_optimizable()) {
       // Do not optimize if usage count must be reported.
       __ cmpl(FieldAddress(func_reg, Function::usage_counter_offset()),
           Immediate(FLAG_optimization_counter_threshold));
       Label not_yet_hot;
       __ j(LESS, &not_yet_hot, Assembler::kNearJump);
       // Equal (or greater), optimize.
@@ skipping 278 matching lines @@
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label check_identity;
   __ cmpl(Address(ESP, 0 * kWordSize), raw_null);
   __ j(EQUAL, &check_identity, Assembler::kNearJump);
   __ cmpl(Address(ESP, 1 * kWordSize), raw_null);
   __ j(EQUAL, &check_identity, Assembler::kNearJump);
 
   ICData& equality_ic_data = ICData::ZoneHandle();
   if (compiler->is_optimizing() && FLAG_propagate_ic_data) {
     ASSERT(!original_ic_data.IsNull());
-    equality_ic_data = original_ic_data.AsUnaryClassChecks();
+    if (original_ic_data.NumberOfChecks() == 0) {
+      // IC call for reoptimization populates original ICData.
+      equality_ic_data = original_ic_data.raw();
+    } else {
+      // Megamorphic call.
+      equality_ic_data = original_ic_data.AsUnaryClassChecks();
+    }
   } else {
     equality_ic_data = ICData::New(compiler->parsed_function().function(),
                                    operator_name,
                                    deopt_id,
                                    kNumArgumentsChecked);
   }
   compiler->GenerateInstanceCall(deopt_id,
                                  token_pos,
                                  kNumberOfArguments,
                                  kNoArgumentNames,
@@ skipping 599 matching lines @@
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(PcDescriptors::kDeoptBefore,
                                    deopt_id(),
                                    token_pos());
   }
   const intptr_t kNumArguments = 2;
   const intptr_t kNumArgsChecked = 2;  // Type-feedback.
   ICData& relational_ic_data = ICData::ZoneHandle(ic_data()->raw());
   if (compiler->is_optimizing() && FLAG_propagate_ic_data) {
     ASSERT(!ic_data()->IsNull());
-    relational_ic_data = ic_data()->AsUnaryClassChecks();
+    if (ic_data()->NumberOfChecks() == 0) {
+      // IC call for reoptimization populates original ICData.
+      relational_ic_data = ic_data()->raw();
+    } else {
+      // Megamorphic call.
+      relational_ic_data = ic_data()->AsUnaryClassChecks();
+    }
   } else {
     relational_ic_data = ICData::New(compiler->parsed_function().function(),
                                      function_name,
                                      deopt_id(),
                                      kNumArgsChecked);
   }
   compiler->GenerateInstanceCall(deopt_id(),
                                  token_pos(),
                                  kNumArguments,
                                  Array::ZoneHandle(),  // No optional arguments.
@@ skipping 1707 matching lines @@
   __ pcmpeqq(XMM0, XMM0);  // Generate all 1's.
   __ pxor(value, XMM0);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64