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(Precompiler* precompiler,
-                           FlowGraph* flow_graph,
+AotOptimizer::AotOptimizer(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)) {
-    return TryStringLengthOneEquality(call, op_kind);
+    if (TryStringLengthOneEquality(call, op_kind)) {
+      return true;
+    } else {
+      return false;
+    }
   } 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