VM-codegen: Add IL instruction to check if a Smi is in a constant range

runtime/vm/flow_graph_inliner.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.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include "vm/flow_graph_inliner.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/precompiler.h"
 #include "vm/block_scheduler.h"
 #include "vm/branch_optimizer.h"
@@ skipping 1654 matching lines @@
 
   Definition* receiver = call_->ArgumentAt(0);
   // There are at least two variants including non-inlined ones, so we have
   // at least one branch on the class id.
   LoadClassIdInstr* load_cid =
       new (Z) LoadClassIdInstr(new (Z) Value(receiver));
   load_cid->set_ssa_temp_index(owner_->caller_graph()->alloc_ssa_temp_index());
   cursor = AppendInstruction(cursor, load_cid);
   for (intptr_t i = 0; i < inlined_variants_.length(); ++i) {
     const CidRange& variant = inlined_variants_[i];
-    bool test_is_range = !variant.IsSingleCid();
     bool is_last_test = (i == inlined_variants_.length() - 1);
     // 1. Guard the body with a class id check.  We don't need any check if
     // it's the last test and global analysis has told us that the call is
     // complete.
     if (is_last_test && non_inlined_variants_->is_empty()) {
       // If it is the last variant use a check class id instruction which can
       // deoptimize, followed unconditionally by the body. Omit the check if
       // we know that we have covered all possible classes.
       if (!call_->complete()) {
         RedefinitionInstr* cid_redefinition =
@@ skipping 39 matching lines @@
         current_block->set_last_instruction(goto_join);
       } else {
         // There is no possibility of a TargetEntry (the first entry to a
         // shared inlined body) because this is the last inlined entry.
         UNREACHABLE();
       }
       cursor = NULL;
     } else {
       // For all variants except the last, use a branch on the loaded class
       // id.
-      const Smi& cid = Smi::ZoneHandle(Smi::New(variant.cid_start));
-      ConstantInstr* cid_constant = owner_->caller_graph()->GetConstant(cid);
-      BranchInstr* branch;
-      BranchInstr* upper_limit_branch = NULL;
+      ComparisonInstr* compare;
       BlockEntryInstr* cid_test_entry_block = current_block;
-      if (test_is_range) {
-        // Double branch for testing a range of Cids.  TODO(erikcorry): Make a
-        // special instruction that uses subtraction and unsigned comparison to
-        // do this with a single branch.
-        const Smi& cid_end = Smi::ZoneHandle(Smi::New(variant.cid_end));
-        ConstantInstr* cid_constant_end =
-            owner_->caller_graph()->GetConstant(cid_end);
-        RelationalOpInstr* compare_top = new RelationalOpInstr(
-            call_->instance_call()->token_pos(), Token::kLTE,
-            new Value(load_cid), new Value(cid_constant_end), kSmiCid,
-            call_->deopt_id());
-        BranchInstr* branch_top = upper_limit_branch =
-            new BranchInstr(compare_top, Thread::kNoDeoptId);
-        branch_top->InheritDeoptTarget(zone(), call_);
-        cursor = AppendInstruction(cursor, branch_top);
-        current_block->set_last_instruction(branch_top);
-
-        TargetEntryInstr* below_target = new TargetEntryInstr(
-            AllocateBlockId(), try_idx, Thread::kNoDeoptId);
-        below_target->InheritDeoptTarget(zone(), call_);
-        current_block->AddDominatedBlock(below_target);
-        cursor = current_block = below_target;
-        *branch_top->true_successor_address() = below_target;
-
-        RelationalOpInstr* compare_bottom = new RelationalOpInstr(
-            call_->instance_call()->token_pos(), Token::kGTE,
-            new Value(load_cid), new Value(cid_constant), kSmiCid,
-            call_->deopt_id());
-        branch = new BranchInstr(compare_bottom, Thread::kNoDeoptId);
-      } else {
-        StrictCompareInstr* compare = new StrictCompareInstr(
+      if (variant.IsSingleCid()) {
+        const Smi& cid = Smi::ZoneHandle(Smi::New(variant.cid_start));
+        ConstantInstr* cid_constant = owner_->caller_graph()->GetConstant(cid);
+        compare = new StrictCompareInstr(
             call_->instance_call()->token_pos(), Token::kEQ_STRICT,
             new Value(load_cid), new Value(cid_constant),
             /* number_check = */ false, Thread::kNoDeoptId);
-        branch = new BranchInstr(compare, Thread::kNoDeoptId);
+      } else {
+        compare = new SmiRangeComparisonInstr(
+            call_->instance_call()->token_pos(), new Value(load_cid),
+            variant.cid_start, variant.cid_end);
       }
+      BranchInstr* branch = new BranchInstr(compare, Thread::kNoDeoptId);
 
       branch->InheritDeoptTarget(zone(), call_);
       cursor = AppendInstruction(cursor, branch);
       current_block->set_last_instruction(branch);
       cursor = NULL;
 
       // 2. Handle a match by linking to the inlined body.  There are three
       // cases (unshared, shared first predecessor, and shared subsequent
       // predecessors).
       BlockEntryInstr* callee_entry = inlined_entries_[i];
@@ skipping 30 matching lines @@
       // 3. Prepare to handle a match failure on the next iteration or the
       // fall-through code below for non-inlined variants.
 
       TargetEntryInstr* false_target =
           new TargetEntryInstr(AllocateBlockId(), try_idx, Thread::kNoDeoptId);
       false_target->InheritDeoptTarget(zone(), call_);
       *branch->false_successor_address() = false_target;
       cid_test_entry_block->AddDominatedBlock(false_target);
 
       cursor = current_block = false_target;
-
-      if (test_is_range) {
-        // If we tested against a range of Cids there are two different tests
-        // that can go to the no-cid-match target.
-        JoinEntryInstr* join =
-            new JoinEntryInstr(AllocateBlockId(), try_idx, Thread::kNoDeoptId);
-        TargetEntryInstr* false_target2 = new TargetEntryInstr(
-            AllocateBlockId(), try_idx, Thread::kNoDeoptId);
-        *upper_limit_branch->false_successor_address() = false_target2;
-        cid_test_entry_block->AddDominatedBlock(false_target2);
-        cid_test_entry_block->AddDominatedBlock(join);
-        GotoInstr* goto_1 = new GotoInstr(join, Thread::kNoDeoptId);
-        GotoInstr* goto_2 = new GotoInstr(join, Thread::kNoDeoptId);
-        false_target->LinkTo(goto_1);
-        false_target2->LinkTo(goto_2);
-        false_target->set_last_instruction(goto_1);
-        false_target2->set_last_instruction(goto_2);
-
-        join->InheritDeoptTarget(zone(), call_);
-        false_target2->InheritDeoptTarget(zone(), call_);
-        goto_1->InheritDeoptTarget(zone(), call_);
-        goto_2->InheritDeoptTarget(zone(), call_);
-
-        cursor = current_block = join;
-      }
     }
   }
 
   // Handle any non-inlined variants.
   if (!non_inlined_variants_->is_empty()) {
     // Move push arguments of the call.
     for (intptr_t i = 0; i < call_->ArgumentCount(); ++i) {
       PushArgumentInstr* push = call_->PushArgumentAt(i);
       push->ReplaceUsesWith(push->value()->definition());
       push->previous()->LinkTo(push->next());
@@ skipping 1906 matching lines @@
     }
 
     default:
       return false;
   }
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)