Working implementation of #29153 range check in as-casts.

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 1547 matching lines @@
 
 
 // TODO(srdjan): Apply optimizations as in ReplaceWithInstanceOf (TestCids).
 void AotOptimizer::ReplaceWithTypeCast(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeCastOperator(call->token_kind()));
   Definition* left = call->ArgumentAt(0);
   Definition* type_args = call->ArgumentAt(1);
   const AbstractType& type =
       AbstractType::Cast(call->ArgumentAt(2)->AsConstant()->value());
   ASSERT(!type.IsMalformedOrMalbounded());
+
+  if (TypeCheckAsClassEquality(type)) {
+    LoadClassIdInstr* left_cid = new (Z) LoadClassIdInstr(new (Z) Value(left));
+    InsertBefore(call, left_cid, NULL, FlowGraph::kValue);
+    const intptr_t type_cid = Class::ZoneHandle(Z, type.type_class()).id();
+    ConstantInstr* cid =
+        flow_graph()->GetConstant(Smi::ZoneHandle(Z, Smi::New(type_cid)));
+    ConstantInstr* pos = flow_graph()->GetConstant(
+        Smi::ZoneHandle(Z, Smi::New(call->token_pos().Pos())));
+
+    ZoneGrowableArray<PushArgumentInstr*>* args =
+        new (Z) ZoneGrowableArray<PushArgumentInstr*>(5);
+    PushArgumentInstr* arg = new (Z) PushArgumentInstr(new (Z) Value(pos));
+    InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+    args->Add(arg);
+    arg = new (Z) PushArgumentInstr(new (Z) Value(left));
+    InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+    args->Add(arg);
+    arg = new (Z)
+        PushArgumentInstr(new (Z) Value(flow_graph()->GetConstant(type)));
+    InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+    args->Add(arg);
+    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(cid));
+    InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+    args->Add(arg);
+
+    const Library& dart_internal = Library::Handle(Z, Library::CoreLibrary());
+    const String& target_name = Symbols::_classIdEqualsAssert();
+    const Function& target = Function::ZoneHandle(
+        Z, dart_internal.LookupFunctionAllowPrivate(target_name));
+    ASSERT(!target.IsNull());
+    ASSERT(target.IsRecognized());
+    ASSERT(target.always_inline());
+
+    StaticCallInstr* new_call =
+        new (Z) StaticCallInstr(call->token_pos(), target,
+                                Object::null_array(),  // argument_names
+                                args, call->deopt_id());
+    Environment* copy =
+        call->env()->DeepCopy(Z, call->env()->Length() - call->ArgumentCount());
+    for (intptr_t i = 0; i < args->length(); ++i) {
+      copy->PushValue(new (Z) Value((*args)[i]->value()->definition()));
+    }
+    call->RemoveEnvironment();
+    ReplaceCall(call, new_call);
+    copy->DeepCopyTo(Z, new_call);

[siva, 2017/04/13 17:01:04]

Maybe not for this CL but in a follow up CL, this pattern of looking up and
constructing the Static call seems to be repeated multiple times, it might make
sense to abstract this out into a helper method.

+    return;
+  }
+
+  if (precompiler_ != NULL) {
+    TypeRangeCache* cache = precompiler_->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::ZoneHandle(Z, Smi::New(lower_limit)));
+      ConstantInstr* upper_cid =
+          flow_graph()->GetConstant(Smi::ZoneHandle(Z, Smi::New(upper_limit)));
+      ConstantInstr* pos = flow_graph()->GetConstant(
+          Smi::ZoneHandle(Z, Smi::New(call->token_pos().Pos())));
+
+      ZoneGrowableArray<PushArgumentInstr*>* args =
+          new (Z) ZoneGrowableArray<PushArgumentInstr*>(6);
+      PushArgumentInstr* arg = new (Z) PushArgumentInstr(new (Z) Value(pos));
+      InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+      args->Add(arg);
+      arg = new (Z) PushArgumentInstr(new (Z) Value(left));
+      InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+      args->Add(arg);
+      arg = new (Z)
+          PushArgumentInstr(new (Z) Value(flow_graph()->GetConstant(type)));
+      InsertBefore(call, arg, NULL, FlowGraph::kEffect);
+      args->Add(arg);
+      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::CoreLibrary());
+      const String& target_name = Symbols::_classRangeAssert();
+      const Function& target = Function::ZoneHandle(
+          Z, dart_internal.LookupFunctionAllowPrivate(target_name));
+      ASSERT(!target.IsNull());
+      ASSERT(target.IsRecognized());
+      ASSERT(target.always_inline());
+
+      StaticCallInstr* new_call =
+          new (Z) StaticCallInstr(call->token_pos(), target,
+                                  Object::null_array(),  // argument_names
+                                  args, call->deopt_id());
+      Environment* copy = call->env()->DeepCopy(
+          Z, call->env()->Length() - call->ArgumentCount());
+      for (intptr_t i = 0; i < args->length(); ++i) {
+        copy->PushValue(new (Z) Value((*args)[i]->value()->definition()));
+      }
+      call->RemoveEnvironment();
+      ReplaceCall(call, new_call);
+      copy->DeepCopyTo(Z, new_call);
+      return;
+    }
+  }
+
   const ICData& unary_checks =
       ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecks());
   const intptr_t number_of_checks = unary_checks.NumberOfChecks();
   if (number_of_checks > 0 && number_of_checks <= FLAG_max_polymorphic_checks) {
     ZoneGrowableArray<intptr_t>* results =
         new (Z) ZoneGrowableArray<intptr_t>(number_of_checks * 2);
     const Bool& as_bool =
         Bool::ZoneHandle(Z, InstanceOfAsBool(unary_checks, type, results));
     if (as_bool.raw() == Bool::True().raw()) {
       // Guard against repeated speculative inlining.
@@ skipping 554 matching lines @@
                                   FlowGraph::kEffect);
         current_iterator()->RemoveCurrentFromGraph();
       }
     }
   }
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart