AOT: Use a cid range check when possible to implement type tests.

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 19 matching lines @@
 namespace dart {
 
 DEFINE_FLAG(int, max_exhaustive_polymorphic_checks, 5,
             "If a call receiver is known to be of at most this many classes, "
             "generate exhaustive class tests instead of a megamorphic call");
 
 // Quick access to the current isolate and zone.
 #define I (isolate())
 #define Z (zone())
 
+#ifdef DART_PRECOMPILER
+
 static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
 
 static bool CanUnboxDouble() {
   return FlowGraphCompiler::SupportsUnboxedDoubles();
 }
 
 
@@ skipping 1464 matching lines @@
     }
   } else {
     type_args = call->ArgumentAt(1);
     type = AbstractType::Cast(call->ArgumentAt(2)->AsConstant()->value()).raw();
     negate = Bool::Cast(call->ArgumentAt(3)->OriginalDefinition()
         ->AsConstant()->value()).value();
   }
 
   if (TypeCheckAsClassEquality(type)) {
     LoadClassIdInstr* left_cid = new(Z) LoadClassIdInstr(new(Z) Value(left));
-    InsertBefore(call,
-                 left_cid,
-                 NULL,
-                 FlowGraph::kValue);
+    InsertBefore(call, left_cid, NULL, FlowGraph::kValue);
     const intptr_t type_cid = Class::Handle(Z, type.type_class()).id();
     ConstantInstr* cid =
         flow_graph()->GetConstant(Smi::Handle(Z, Smi::New(type_cid)));
 
     StrictCompareInstr* check_cid =
         new(Z) StrictCompareInstr(
             call->token_pos(),
             negate ? Token::kNE_STRICT : Token::kEQ_STRICT,
             new(Z) Value(left_cid),
             new(Z) Value(cid),
             false);  // No number check.
     ReplaceCall(call, check_cid);
     return;
   }
 
+  TypeRangeCache* cache = thread()->type_range_cache();
+  intptr_t lower_limit, upper_limit;
+  if (cache != NULL &&
+      cache->InstanceOfHasClassRange(type, &lower_limit, &upper_limit)) {
+    // left.instanceof(type) =>
+    //     _classRangeCheck(left.cid, lower_limit, upper_limit)
+
+    LoadClassIdInstr* left_cid = new(Z) LoadClassIdInstr(new(Z) Value(left));
+    InsertBefore(call, left_cid, NULL, FlowGraph::kValue);
+    ConstantInstr* lower_cid =
+        flow_graph()->GetConstant(Smi::Handle(Z, Smi::New(lower_limit)));
+    ConstantInstr* upper_cid =
+        flow_graph()->GetConstant(Smi::Handle(Z, Smi::New(upper_limit)));
+
+    ZoneGrowableArray<PushArgumentInstr*>* args =
+        new(Z) ZoneGrowableArray<PushArgumentInstr*>(3);
+    PushArgumentInstr* arg = new (Z) PushArgumentInstr(new (Z) Value(left_cid));
+    InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+    args->Add(arg);
+    arg = new (Z) PushArgumentInstr(new (Z) Value(lower_cid));
+    InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+    args->Add(arg);
+    arg = new (Z) PushArgumentInstr(new (Z) Value(upper_cid));
+    InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+    args->Add(arg);
+
+    const Library& dart_internal =
+        Library::Handle(Z, Library::InternalLibrary());
+    const String& target_name = negate ? Symbols::_classRangeCheckNegative()
+                                       : Symbols::_classRangeCheck();
+    const Function& target = Function::ZoneHandle(Z,
+        dart_internal.LookupFunctionAllowPrivate(target_name));
+    ASSERT(!target.IsNull());
+    ASSERT(target.IsRecognized() && target.always_inline());
+
+    StaticCallInstr* new_call = new (Z) StaticCallInstr(
+        call->token_pos(),
+        target,
+        Object::null_array(),  // argument_names
+        args,
+        call->deopt_id());
+    ReplaceCall(call, new_call);
+    return;
+  }
+
   const ICData& unary_checks =
       ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecks());
   if ((unary_checks.NumberOfChecks() > 0) &&
       (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks)) {
     ZoneGrowableArray<intptr_t>* results =
         new(Z) ZoneGrowableArray<intptr_t>(unary_checks.NumberOfChecks() * 2);
     InstanceOfAsBool(unary_checks, type, results);
     if (results->length() == unary_checks.NumberOfChecks() * 2) {
       const bool can_deopt = TryExpandTestCidsResult(results, type);
       if (can_deopt && !IsAllowedForInlining(call->deopt_id())) {
@@ skipping 578 matching lines @@
             new(Z) Value(check->index()->definition()),
             check->deopt_id());
         flow_graph_->InsertBefore(check, new_check,
                                   check->env(), FlowGraph::kEffect);
         current_iterator()->RemoveCurrentFromGraph();
       }
     }
   }
 }
 
+#endif  // DART_PRECOMPILER
 
 }  // namespace dart