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 554 matching lines @@
             new LoadFieldInstr(array->Copy(),
                                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 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(value_type.IsDoubleType());
         ASSERT(value_type.IsInstantiated());
         break;
       }
       default:
         // TODO(fschneider): Add support for other array types.
         UNREACHABLE();
     }
     AssertAssignableInstr* assert_value =
         new AssertAssignableInstr(call->token_pos(),
@@ skipping 331 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()));

[srdjan, 2013/01/16 22:08:56]

indent 4 spaces

+    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 93 matching lines @@
 
   StrictCompareInstr* compare =
       new StrictCompareInstr(Token::kEQ_STRICT,
                              new Value(load),
                              new Value(zero));
   call->ReplaceWith(compare, current_iterator());
   RemovePushArguments(call);
 }
 
 
+void FlowGraphOptimizer::InlineMethodExtractor(InstanceCallInstr* call) {
+  Value* receiver = call->ArgumentAt(0)->value();
+  if (MethodExtractorNeedsClassCheck(call)) {
+    AddCheckClass(call, receiver->Copy());
+  }
+
+  // Load and push type arguments.
+  Definition* type_arguments = NULL;
+
+  const Class& receiver_class = Class::Handle(
+      Isolate::Current()->class_table()->At(ReceiverClassId(call)));
+  const intptr_t type_arguments_field_offset =
+      receiver_class.type_arguments_field_offset();
+  if (type_arguments_field_offset != Class::kNoTypeArguments) {
+    type_arguments = new LoadFieldInstr(receiver->Copy(),
+                                        type_arguments_field_offset,
+                                        Type::ZoneHandle());  // No type.
+    InsertBefore(call, type_arguments, NULL, Definition::kValue);
+  } else {
+    type_arguments = flow_graph_->constant_null();
+  }
+
+  PushArgumentInstr* push_type_arguments =
+      new PushArgumentInstr(new Value(type_arguments));
+  InsertBefore(call, push_type_arguments, NULL, Definition::kEffect);
+
+  ZoneGrowableArray<PushArgumentInstr*>* args =
+      new ZoneGrowableArray<PushArgumentInstr*>(2);
+
+  args->Add(call->ArgumentAt(0));
+  args->Add(push_type_arguments);
+
+  const Function& extractor = Function::Handle(call->ic_data()->GetTargetAt(0));
+  const Function& function =
+      Function::ZoneHandle(extractor.extracted_method_closure());
+  ASSERT(function.IsImplicitInstanceClosureFunction());
+  call->set_env(NULL);
+  CreateClosureInstr* create_closure =
+      new CreateClosureInstr(function, args, call->token_pos());
+  call->ReplaceWith(create_closure, current_iterator());
+}
+
+
 // Only unique implicit instance getters can be currently handled.
 bool FlowGraphOptimizer::TryInlineInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     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) {
+    if (!ic_data.HasOneTarget()) {
+      return false;
+    }
+    InlineMethodExtractor(call);
+    return true;
   }
 
   // Not an implicit getter.
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
   // VM objects length getter.
   if ((recognized_kind == MethodRecognizer::kObjectArrayLength) ||
       (recognized_kind == MethodRecognizer::kImmutableArrayLength) ||
       (recognized_kind == MethodRecognizer::kGrowableArrayLength)) {
@@ skipping 148 matching lines @@
 // Tries to optimize instance call by replacing it with a faster instruction
 // (e.g, binary op, field load, ..).
 void FlowGraphOptimizer::VisitInstanceCall(InstanceCallInstr* instr) {
   if (!instr->HasICData() || (instr->ic_data()->NumberOfChecks() == 0)) {
     // An instance call without ICData will trigger deoptimization.
     return;
   }
 
   const ICData& unary_checks =
       ICData::ZoneHandle(instr->ic_data()->AsUnaryClassChecks());
+  const bool has_one_target = unary_checks.HasOneTarget();
   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;
   }
 
   const Token::Kind op_kind = instr->token_kind();
   if ((op_kind == Token::kASSIGN_INDEX) &&
       TryReplaceWithStoreIndexed(instr)) {
@@ skipping 13 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)) {
+  if (has_one_target && !InstanceCallNeedsClassCheck(instr)) {
+    ASSERT(!Function::Handle(unary_checks.GetTargetAt(0)).IsMethodExtractor());
     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 2988 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart