VM Propagate receiver type from calls to unique selectors in AOT compilation.

runtime/vm/aot_optimizer.cc

 // Copyright (c) 2013, 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/aot_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 36 matching lines @@
 static bool CanUnboxDouble() {
   return FlowGraphCompiler::SupportsUnboxedDoubles();
 }
 
 
 static bool CanConvertUnboxedMintToDouble() {
   return FlowGraphCompiler::CanConvertUnboxedMintToDouble();
 }
 
 
+// Returns named function that is a unique dynamic target, i.e.,
+// - the target is identified by its name alone, since it occurs only once.
+// - target's class has no subclasses, and neither is subclassed, i.e.,
+//   the receiver type can be only the function's class.
+// Returns Function::null() if there is no unique dynamic target for
+// given 'fname'. 'fname' must be a symbol.
+static void GetUniqueDynamicTarget(Isolate* isolate,
+                                   const String& fname,
+                                   Object* function) {
+  UniqueFunctionsSet functions_set(
+      isolate->object_store()->unique_dynamic_targets());
+  ASSERT(fname.IsSymbol());
+  *function = functions_set.GetOrNull(fname);
+  ASSERT(functions_set.Release().raw() ==
+      isolate->object_store()->unique_dynamic_targets());
+}
+
+
+AotOptimizer::AotOptimizer(FlowGraph* flow_graph,
+                           bool use_speculative_inlining,
+                           GrowableArray<intptr_t>* inlining_black_list)
+    : FlowGraphVisitor(flow_graph->reverse_postorder()),
+      flow_graph_(flow_graph),
+      use_speculative_inlining_(use_speculative_inlining),
+      inlining_black_list_(inlining_black_list),
+      has_unique_no_such_method_(false) {
+  ASSERT(!use_speculative_inlining || (inlining_black_list != NULL));
+  Function& target_function = Function::Handle();
+  if (isolate()->object_store()->unique_dynamic_targets() != Array::null()) {
+    GetUniqueDynamicTarget(
+        isolate(), Symbols::NoSuchMethod(), &target_function);
+    has_unique_no_such_method_ = !target_function.IsNull();
+  }
+}
+
+
 // Optimize instance calls using ICData.
 void AotOptimizer::ApplyICData() {
   VisitBlocks();
 }
 
 
 void AotOptimizer::PopulateWithICData() {
   ASSERT(current_iterator_ == NULL);
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
        !block_it.Done();
@@ skipping 49 matching lines @@
   }
 }
 
 
 // TODO(srdjan): Test/support other number types as well.
 static bool IsNumberCid(intptr_t cid) {
   return (cid == kSmiCid) || (cid == kDoubleCid);
 }
 
 
-// Returns named function that is a unique dynamic target, i.e.,
-// - the target is identified by its name alone, since it occurs only once.
-// - target's class has no subclasses, and neither is subclassed, i.e.,
-//   the receiver type can be only the function's class.
-// Returns Function::null() if there is no unique dynamic target for
-// given 'fname'. 'fname' must be a symbol.
-static void GetUniqueDynamicTarget(Isolate* isolate,
-                                   const String& fname,
-                                   Object* function) {
-  UniqueFunctionsSet functions_set(
-      isolate->object_store()->unique_dynamic_targets());
-  ASSERT(fname.IsSymbol());
-  *function = functions_set.GetOrNull(fname);
-  ASSERT(functions_set.Release().raw() ==
-      isolate->object_store()->unique_dynamic_targets());
-}
-
-
 bool AotOptimizer::TryCreateICData(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   if (call->ic_data()->NumberOfUsedChecks() > 0) {
     // This occurs when an instance call has too many checks, will be converted
     // to megamorphic call.
     return false;
   }
   GrowableArray<intptr_t> class_ids(call->ic_data()->NumArgsTested());
   ASSERT(call->ic_data()->NumArgsTested() <= call->ArgumentCount());
   for (intptr_t i = 0; i < call->ic_data()->NumArgsTested(); i++) {
@@ skipping 66 matching lines @@
 
   if (isolate()->object_store()->unique_dynamic_targets() != Array::null()) {
     // Check if the target is unique.
     Function& target_function = Function::Handle(Z);
     GetUniqueDynamicTarget(isolate(), call->function_name(), &target_function);
     // Calls with named arguments must be resolved/checked at runtime.
     if (!target_function.IsNull() &&
         !target_function.HasOptionalNamedParameters() &&
         target_function.AreValidArgumentCounts(call->ArgumentCount(), 0,
                                                /* error_message = */ NULL)) {
-      const intptr_t cid = Class::Handle(Z, target_function.Owner()).id();
-      const ICData& ic_data = ICData::ZoneHandle(Z,
-          ICData::NewFrom(*call->ic_data(), 1));
-      ic_data.AddReceiverCheck(cid, target_function);
-      call->set_ic_data(&ic_data);
-      return true;
+      const Class& cls = Class::Handle(Z, target_function.Owner());
+      if (!CHA::IsImplemented(cls) && !CHA::HasSubclasses(cls)) {
+        const ICData& ic_data = ICData::ZoneHandle(Z,
+            ICData::NewFrom(*call->ic_data(), 1));
+        ic_data.AddReceiverCheck(cls.id(), target_function);
+        call->set_ic_data(&ic_data);
+        if (has_unique_no_such_method_) {
+          call->set_has_unique_selector(true);
+        }
+        return true;
+      }
     }
   }
 
   return false;
 }
 
 
 const ICData& AotOptimizer::TrySpecializeICData(const ICData& ic_data,
                                                 intptr_t cid) {
   ASSERT(ic_data.NumArgsTested() == 1);
@@ skipping 1742 matching lines @@
     PolymorphicInstanceCallInstr* call =
         new(Z) PolymorphicInstanceCallInstr(instr, unary_checks,
                                             /* with_checks = */ true,
                                             /* complete = */ false);
     instr->ReplaceWith(call, current_iterator());
     return;
   }
 }
 
 
+void AotOptimizer::VisitPolymorphicInstanceCall(
+    PolymorphicInstanceCallInstr* call) {
+  if (call->with_checks()) {
+    const intptr_t receiver_cid =
+        call->PushArgumentAt(0)->value()->Type()->ToCid();
+    if (receiver_cid != kDynamicCid) {
+      const Class& receiver_class = Class::Handle(Z,
+          isolate()->class_table()->At(receiver_cid));
+
+      const Array& args_desc_array = Array::Handle(Z,
+          ArgumentsDescriptor::New(call->ArgumentCount(),
+                                   call->instance_call()->argument_names()));
+      ArgumentsDescriptor args_desc(args_desc_array);
+      const Function& function = Function::Handle(Z,
+          Resolver::ResolveDynamicForReceiverClass(
+              receiver_class,
+              call->instance_call()->function_name(),
+              args_desc));
+      if (!function.IsNull()) {
+        call->set_with_checks(false);
+      }
+    }
+  }
+}
+
+
 void AotOptimizer::VisitStaticCall(StaticCallInstr* call) {
   if (!IsAllowedForInlining(call->deopt_id())) {
     // Inlining disabled after a speculative inlining attempt.
     return;
   }
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(call->function());
   switch (recognized_kind) {
     case MethodRecognizer::kObjectConstructor:
     case MethodRecognizer::kObjectArrayAllocate:
@@ skipping 170 matching lines @@
                                   check->env(), FlowGraph::kEffect);
         current_iterator()->RemoveCurrentFromGraph();
       }
     }
   }
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart