Create and cache method extraction stub in the ICData.

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 585 matching lines @@
                                type_arguments_field_offset,
                                Type::ZoneHandle());  // No type.
         InsertBefore(call, load_type_args, NULL, Definition::kValue);
         instantiator = array->Copy();
         type_args = new Value(load_type_args);
         break;
       }
       case kUint8ArrayCid:
       case kFloat32ArrayCid:
       case kFloat64ArrayCid: {
-        ConstantInstr* null_constant = new ConstantInstr(Object::ZoneHandle());
-        InsertBefore(call, null_constant, NULL, Definition::kValue);
-        instantiator = new Value(null_constant);
-        type_args = new Value(null_constant);
+        instantiator = new Value(flow_graph_->constant_null());
+        type_args = new Value(flow_graph_->constant_null());
         ASSERT((class_id != kUint8ArrayCid) || value_type.IsIntType());
         ASSERT((class_id != kFloat32ArrayCid && class_id != kFloat64ArrayCid) ||
                value_type.IsDoubleType());
         ASSERT(value_type.IsInstantiated());
         break;
       }
       default:
         // TODO(fschneider): Add support for other array types.
         UNREACHABLE();
     }
@@ skipping 337 matching lines @@
   if (function.IsDynamicFunction() &&
       callee_receiver->IsParameter() &&
       (callee_receiver->AsParameter()->index() == 0)) {
     return CHA::HasOverride(Class::Handle(function.Owner()),
                             call->function_name());
   }
   return true;
 }
 
 
+bool FlowGraphOptimizer::MethodExtractorNeedsClassCheck(
+    InstanceCallInstr* call) const {
+  if (!FLAG_use_cha) return true;
+  Definition* callee_receiver = call->ArgumentAt(0)->value()->definition();
+  ASSERT(callee_receiver != NULL);
+  const Function& function = flow_graph_->parsed_function().function();
+  if (function.IsDynamicFunction() &&
+      callee_receiver->IsParameter() &&
+      (callee_receiver->AsParameter()->index() == 0)) {
+    const String& field_name =
+      String::Handle(Field::NameFromGetter(call->function_name()));
+    return CHA::HasOverride(Class::Handle(function.Owner()), field_name);
+  }
+  return true;
+}
+
+
 void FlowGraphOptimizer::InlineImplicitInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   ASSERT(class_ids.length() == 1);
   // Inline implicit instance getter.
   const String& field_name =
       String::Handle(Field::NameFromGetter(call->function_name()));
@@ skipping 127 matching lines @@
     return false;
   }
   Function& target = Function::Handle(ic_data.GetTargetAt(0));
   if (target.kind() == RawFunction::kImplicitGetter) {
     if (!ic_data.HasOneTarget()) {
       // TODO(srdjan): Implement for mutiple targets.
       return false;
     }
     InlineImplicitInstanceGetter(call);
     return true;
+  } else if (target.kind() == RawFunction::kMethodExtractor) {
+    return false;
   }
 
   // Not an implicit getter.
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
   // VM objects length getter.
   switch (recognized_kind) {
     case MethodRecognizer::kObjectArrayLength:
     case MethodRecognizer::kImmutableArrayLength:
@@ skipping 232 matching lines @@
 
   const Token::Kind op_kind = instr->token_kind();
   // Type test is special as it always gets converted into inlined code.
   if (Token::IsTypeTestOperator(op_kind)) {
     ReplaceWithInstanceOf(instr);
     return;
   }
 
   const ICData& unary_checks =
       ICData::ZoneHandle(instr->ic_data()->AsUnaryClassChecks());
+
   if ((unary_checks.NumberOfChecks() > FLAG_max_polymorphic_checks) &&
       InstanceCallNeedsClassCheck(instr)) {
     // Too many checks, it will be megamorphic which needs unary checks.
     instr->set_ic_data(&unary_checks);
     return;
   }
 
   if ((op_kind == Token::kASSIGN_INDEX) &&
       TryReplaceWithStoreIndexed(instr)) {
     return;
@@ skipping 12 matching lines @@
   if ((op_kind == Token::kGET) && TryInlineInstanceGetter(instr)) {
     return;
   }
   if ((op_kind == Token::kSET) &&
       TryInlineInstanceSetter(instr, unary_checks)) {
     return;
   }
   if (TryInlineInstanceMethod(instr)) {
     return;
   }
-  if (!InstanceCallNeedsClassCheck(instr)) {
-    const bool call_with_checks = false;
-    PolymorphicInstanceCallInstr* call =
-        new PolymorphicInstanceCallInstr(instr, unary_checks,
-                                         call_with_checks);
-    instr->ReplaceWith(call, current_iterator());
-    return;
+
+  const bool has_one_target = unary_checks.HasOneTarget();
+
+  if (has_one_target) {
+    const bool is_method_extraction =
+        Function::Handle(unary_checks.GetTargetAt(0)).IsMethodExtractor();
+
+    if ((is_method_extraction && !MethodExtractorNeedsClassCheck(instr)) ||
+        (!is_method_extraction && !InstanceCallNeedsClassCheck(instr))) {
+      const bool call_with_checks = false;
+      PolymorphicInstanceCallInstr* call =
+          new PolymorphicInstanceCallInstr(instr, unary_checks,
+                                           call_with_checks);
+      instr->ReplaceWith(call, current_iterator());
+      return;
+    }
   }
+
   if (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks) {
     bool call_with_checks;
-    if (unary_checks.HasOneTarget()) {
+    if (has_one_target) {
       // Type propagation has not run yet, we cannot eliminate the check.
       AddCheckClass(instr, instr->ArgumentAt(0)->value()->Copy());
       // Call can still deoptimize, do not detach environment from instr.
       call_with_checks = false;
     } else {
       call_with_checks = true;
     }
     PolymorphicInstanceCallInstr* call =
         new PolymorphicInstanceCallInstr(instr, unary_checks,
                                          call_with_checks);
@@ skipping 3031 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart