Generalize bounds checks.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
@@ skipping 753 matching lines @@
 }
 
 
 void BranchInstr::InheritDeoptTarget(Isolate* isolate, Instruction* other) {
   ASSERT(env() == NULL);
   Instruction::InheritDeoptTarget(isolate, other);
   comparison()->SetDeoptId(GetDeoptId());
 }
 
 
+bool Instruction::IsDominatedBy(Instruction* dom) {
+  BlockEntryInstr* block = GetBlock();
+  BlockEntryInstr* dom_block = dom->GetBlock();
+
+  if (dom->IsPhi()) {
+    dom = dom_block;
+  }
+
+  if (block == dom_block) {
+    if ((block == dom) || (this == block->last_instruction())) {
+      return true;
+    }
+
+    if (IsPhi()) {
+      return false;
+    }
+
+    for (Instruction* curr = dom->next(); curr != NULL; curr = curr->next()) {
+      if (curr == this) return true;
+    }
+
+    return false;
+  }
+
+  return dom_block->Dominates(block);
+}
+
+
 void Definition::ReplaceWith(Definition* other,
                              ForwardInstructionIterator* iterator) {
   // Record other's input uses.
   for (intptr_t i = other->InputCount() - 1; i >= 0; --i) {
     Value* input = other->InputAt(i);
     input->definition()->AddInputUse(input);
   }
   // Take other's environment from this definition.
   ASSERT(other->env() == NULL);
   other->SetEnvironment(env());
@@ skipping 172 matching lines @@
   // block while computing the dominator tree.
   ASSERT(other != NULL);
   BlockEntryInstr* current = other;
   while (current != NULL && current != this) {
     current = current->dominator();
   }
   return current == this;
 }
 
 
+BlockEntryInstr* BlockEntryInstr::ImmediateDominator() const {
+  Instruction* last = dominator()->last_instruction();
+  if ((last->SuccessorCount() == 1) && (last->SuccessorAt(0) == this)) {
+    return dominator();
+  }
+  return NULL;
+}
+
+
 // Helper to mutate the graph during inlining. This block should be
 // replaced with new_block as a predecessor of all of this block's
 // successors.  For each successor, the predecessors will be reordered
 // to preserve block-order sorting of the predecessors as well as the
 // phis if the successor is a join.
 void BlockEntryInstr::ReplaceAsPredecessorWith(BlockEntryInstr* new_block) {
   // Set the last instruction of the new block to that of the old block.
   Instruction* last = last_instruction();
   new_block->set_last_instruction(last);
   // For each successor, update the predecessors.
@@ skipping 2359 matching lines @@
     case Token::kTRUNCDIV: return 0;
     case Token::kMOD: return 1;
     default: UNIMPLEMENTED(); return -1;
   }
 }
 
 
 #undef __
 
 }  // namespace dart