Cleanup: Make CheckClassId instruction more general so it

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 1526 matching lines @@
     }
   }
 
   return false;
 }
 
 
 bool PolymorphicInliner::TryInliningPoly(const TargetInfo& target_info) {
   if ((!FLAG_precompiled_mode ||
        owner_->inliner_->use_speculative_inlining()) &&
-      target_info.cid_start == target_info.cid_end &&
+      target_info.IsSingleCid() &&
       TryInlineRecognizedMethod(target_info.cid_start, *target_info.target)) {
     owner_->inlined_ = true;
     return true;
   }
 
   GrowableArray<Value*> arguments(call_->ArgumentCount());
   for (int i = 0; i < call_->ArgumentCount(); ++i) {
     arguments.Add(call_->PushArgumentAt(i)->value());
   }
   InlinedCallData call_data(call_, &arguments, caller_function_,
@@ skipping 10 matching lines @@
   exit_collector_->Union(call_data.exit_collector);
 
   // Replace parameter stubs and constants.  Replace the receiver argument
   // with a redefinition to prevent code from the inlined body from being
   // hoisted above the inlined entry.
   ASSERT(arguments.length() > 0);
   Value* actual = arguments[0];
   RedefinitionInstr* redefinition = new (Z) RedefinitionInstr(actual->Copy(Z));
   redefinition->set_ssa_temp_index(
       owner_->caller_graph()->alloc_ssa_temp_index());
-  if (target_info.cid_start == target_info.cid_end) {
+  if (target_info.IsSingleCid()) {
     redefinition->UpdateType(CompileType::FromCid(target_info.cid_start));
   }
   redefinition->InsertAfter(callee_graph->graph_entry()->normal_entry());
   Definition* stub = (*call_data.parameter_stubs)[0];
   stub->ReplaceUsesWith(redefinition);
 
   for (intptr_t i = 1; i < arguments.length(); ++i) {
     actual = arguments[i];
     if (actual != NULL) {
       stub = (*call_data.parameter_stubs)[i];
@@ skipping 98 matching lines @@
   BlockEntryInstr* current_block = entry;
   Instruction* cursor = entry;
 
   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);
-  bool follow_with_deopt = false;
   for (intptr_t i = 0; i < inlined_variants_.length(); ++i) {
     const CidRange& variant = inlined_variants_[i];
-    bool test_is_range = (variant.cid_start != variant.cid_end);
+    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.  TODO(erikcorry): Enhance CheckClassIdInstr so it can take an
-    // arbitrary CidRangeTarget.  Currently we don't go into this branch if the
-    // last test is a range test - instead we set the follow_with_deopt flag.
-    if (is_last_test && (!test_is_range || call_->complete()) &&
-        non_inlined_variants_->is_empty()) {
+    // 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()) {
-        ASSERT(!test_is_range);  // See condition above.
         RedefinitionInstr* cid_redefinition =
             new RedefinitionInstr(new (Z) Value(load_cid));
         cid_redefinition->set_ssa_temp_index(
             owner_->caller_graph()->alloc_ssa_temp_index());
         cursor = AppendInstruction(cursor, cid_redefinition);
-        CheckClassIdInstr* check_class_id =
-            new (Z) CheckClassIdInstr(new (Z) Value(cid_redefinition),
-                                      variant.cid_start, call_->deopt_id());
+        CheckClassIdInstr* check_class_id = new (Z) CheckClassIdInstr(
+            new (Z) Value(cid_redefinition), variant, call_->deopt_id());
         check_class_id->InheritDeoptTarget(zone(), call_);
         cursor = AppendInstruction(cursor, check_class_id);
       }
 
       // The next instruction is the first instruction of the inlined body.
       // Handle the two possible cases (unshared and shared subsequent
       // predecessors) separately.
       BlockEntryInstr* callee_entry = inlined_entries_[i];
       if (callee_entry->IsGraphEntry()) {
         // Unshared.  Graft the normal entry on after the check class
@@ skipping 21 matching lines @@
         goto_join->InheritDeoptTarget(zone(), join);
         cursor->LinkTo(goto_join);
         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 {
-      if (is_last_test && test_is_range) follow_with_deopt = true;
       // 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;
       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
@@ skipping 126 matching lines @@
     fallback_call->set_total_call_count(call_->CallCount());
     ReturnInstr* fallback_return = new ReturnInstr(
         call_->instance_call()->token_pos(), new Value(fallback_call));
     fallback_return->InheritDeoptTargetAfter(owner_->caller_graph(), call_,
                                              fallback_call);
     AppendInstruction(AppendInstruction(cursor, fallback_call),
                       fallback_return);
     exit_collector_->AddExit(fallback_return);
     cursor = NULL;
   } else {
-    if (follow_with_deopt) {
-      DeoptimizeInstr* deopt = new DeoptimizeInstr(
-          ICData::kDeoptPolymorphicInstanceCallTestFail, call_->deopt_id());
-      deopt->InheritDeoptTarget(zone(), call_);
-      cursor = AppendInstruction(cursor, deopt);
-      cursor = NULL;
-    }
-
     // Remove 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->RemoveFromGraph();
     }
   }
   return entry;
 }
 
@@ skipping 1855 matching lines @@
     }
 
     default:
       return false;
   }
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)