Revert "Revert "Recognize and optimize a.runtimeType == b.runtimeType pattern.""

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 54 matching lines @@
                                    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,
+AotOptimizer::AotOptimizer(Precompiler* precompiler,
+                           FlowGraph* flow_graph,
                            bool use_speculative_inlining,
                            GrowableArray<intptr_t>* inlining_black_list)
     : FlowGraphVisitor(flow_graph->reverse_postorder()),
+      precompiler_(precompiler),
       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();
@@ skipping 28 matching lines @@
               call->checked_argument_count(), false));
           call->set_ic_data(&ic_data);
         }
       }
     }
     current_iterator_ = NULL;
   }
 }
 
 
+bool AotOptimizer::RecognizeRuntimeTypeGetter(InstanceCallInstr* call) {
+  if ((precompiler_ == NULL) || !precompiler_->get_runtime_type_is_unique()) {
+    return false;
+  }
+
+  if (call->function_name().raw() != Symbols::GetRuntimeType().raw()) {
+    return false;
+  }
+
+  // There is only a single function Object.get:runtimeType that can be invoked
+  // by this call. Convert dynamic invocation to a static one.
+  const Class& cls = Class::Handle(Z, I->object_store()->object_class());
+  const Array& args_desc_array = Array::Handle(Z,
+      ArgumentsDescriptor::New(call->ArgumentCount(),
+                               call->argument_names()));
+  ArgumentsDescriptor args_desc(args_desc_array);
+  const Function& function = Function::Handle(Z,
+      Resolver::ResolveDynamicForReceiverClass(
+          cls,
+          call->function_name(),
+          args_desc));
+  ASSERT(!function.IsNull());
+
+  ZoneGrowableArray<PushArgumentInstr*>* args =
+      new (Z) ZoneGrowableArray<PushArgumentInstr*>(
+          call->ArgumentCount());
+  for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
+    args->Add(call->PushArgumentAt(i));
+  }
+  StaticCallInstr* static_call = new (Z) StaticCallInstr(
+      call->token_pos(),
+      Function::ZoneHandle(Z, function.raw()),
+      call->argument_names(),
+      args,
+      call->deopt_id());
+  static_call->set_result_cid(kTypeCid);
+  call->ReplaceWith(static_call, current_iterator());
+  return true;
+}
+
+
 // Optimize instance calls using cid.  This is called after optimizer
 // converted instance calls to instructions. Any remaining
 // instance calls are either megamorphic calls, cannot be optimized or
 // have no runtime type feedback collected.
 // Attempts to convert an instance call (IC call) using propagated class-ids,
 // e.g., receiver class id, guarded-cid, or by guessing cid-s.
 void AotOptimizer::ApplyClassIds() {
   ASSERT(current_iterator_ == NULL);
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
        !block_it.Done();
@@ skipping 485 matching lines @@
       to_remove_right->RemoveFromGraph();
     }
     return true;
   }
   return false;
 }
 
 
 static bool SmiFitsInDouble() { return kSmiBits < 53; }
 
+
+static bool IsGetRuntimeType(Definition* defn) {
+  StaticCallInstr* call = defn->AsStaticCall();
+  return (call != NULL) &&
+      (call->function().recognized_kind() ==
+          MethodRecognizer::kObjectRuntimeType);
+}
+
+
+// Recognize a.runtimeType == b.runtimeType and fold it into
+// Object._haveSameRuntimeType(a, b).
+// Note: this optimization is not speculative.
+bool AotOptimizer::TryReplaceWithHaveSameRuntimeType(InstanceCallInstr* call) {
+  const ICData& ic_data = *call->ic_data();
+  ASSERT(ic_data.NumArgsTested() == 2);
+
+  ASSERT(call->ArgumentCount() == 2);
+  Definition* left = call->ArgumentAt(0);
+  Definition* right = call->ArgumentAt(1);
+
+  if (IsGetRuntimeType(left) && left->input_use_list()->IsSingleUse() &&
+      IsGetRuntimeType(right) && right->input_use_list()->IsSingleUse()) {
+    const Class& cls = Class::Handle(Z, I->object_store()->object_class());
+    const Function& have_same_runtime_type = Function::ZoneHandle(Z,
+        cls.LookupStaticFunctionAllowPrivate(Symbols::HaveSameRuntimeType()));
+    ASSERT(!have_same_runtime_type.IsNull());
+
+    ZoneGrowableArray<PushArgumentInstr*>* args =
+        new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
+    PushArgumentInstr* arg = new (Z) PushArgumentInstr(
+        new (Z) Value(left->ArgumentAt(0)));
+    InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+    args->Add(arg);
+    arg = new (Z) PushArgumentInstr(
+         new (Z) Value(right->ArgumentAt(0)));
+    InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+    args->Add(arg);
+    StaticCallInstr* static_call = new (Z) StaticCallInstr(
+        call->token_pos(),
+        have_same_runtime_type,
+        Object::null_array(),  // argument_names
+        args,
+        call->deopt_id());
+    static_call->set_result_cid(kBoolCid);
+    ReplaceCall(call, static_call);
+    return true;
+  }
+
+  return false;
+}
+
+
 bool AotOptimizer::TryReplaceWithEqualityOp(InstanceCallInstr* call,
                                             Token::Kind op_kind) {
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   intptr_t cid = kIllegalCid;
   if (HasOnlyTwoOf(ic_data, kOneByteStringCid)) {
-    if (TryStringLengthOneEquality(call, op_kind)) {
-      return true;
-    } else {
-      return false;
-    }
+    return TryStringLengthOneEquality(call, op_kind);
   } else if (HasOnlyTwoOf(ic_data, kSmiCid)) {
     InsertBefore(call,
                  new(Z) CheckSmiInstr(new(Z) Value(left),
                                       call->deopt_id(),
                                       call->token_pos()),
                  call->env(),
                  FlowGraph::kEffect);
     InsertBefore(call,
                  new(Z) CheckSmiInstr(new(Z) Value(right),
                                       call->deopt_id(),
@@ skipping 45 matching lines @@
       const ICData& unary_checks_1 =
           ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecksForArgNr(1));
       AddCheckClass(right,
                     unary_checks_1,
                     call->deopt_id(),
                     call->env(),
                     call);
       cid = kSmiCid;
     } else {
       // Shortcut for equality with null.
+      // TODO(vegorov): this optimization is not speculative and should
+      // be hoisted out of this function.
       ConstantInstr* right_const = right->AsConstant();
       ConstantInstr* left_const = left->AsConstant();
       if ((right_const != NULL && right_const->value().IsNull()) ||
           (left_const != NULL && left_const->value().IsNull())) {
         StrictCompareInstr* comp =
             new(Z) StrictCompareInstr(call->token_pos(),
                                       Token::kEQ_STRICT,
                                       new(Z) Value(left),
                                       new(Z) Value(right),
                                       false);  // No number check.
@@ skipping 1027 matching lines @@
   }
   if (Token::IsTypeCastOperator(op_kind)) {
     ReplaceWithTypeCast(instr);
     return;
   }
 
   if (TryInlineFieldAccess(instr)) {
     return;
   }
 
+  if (RecognizeRuntimeTypeGetter(instr)) {
+    return;
+  }
+
+  if ((op_kind == Token::kEQ) && TryReplaceWithHaveSameRuntimeType(instr)) {
+    return;
+  }
+
   const ICData& unary_checks =
       ICData::ZoneHandle(Z, instr->ic_data()->AsUnaryClassChecks());
   if (IsAllowedForInlining(instr->deopt_id()) &&
       (unary_checks.NumberOfChecks() > 0)) {
     if ((op_kind == Token::kINDEX) && TryReplaceWithIndexedOp(instr)) {
       return;
     }
     if ((op_kind == Token::kASSIGN_INDEX) && TryReplaceWithIndexedOp(instr)) {
       return;
     }
@@ skipping 457 matching lines @@
                                   check->env(), FlowGraph::kEffect);
         current_iterator()->RemoveCurrentFromGraph();
       }
     }
   }
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart