Implement loop invariant code motion for check instructions.

runtime/vm/intermediate_language.cc

 // Copyright (c) 2012, 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/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 183 matching lines @@
 void Definition::InsertAfter(Instruction* prev) {
   ASSERT(previous_ == NULL);
   ASSERT(next_ == NULL);
   previous_ = prev;
   next_ = prev->next_;
   next_->previous_ = this;
   previous_->next_ = this;
 }
 
 
+BlockEntryInstr* Definition::GetBlock() const {
+  // TODO(fschneider): Implement a faster way to get the block of an
+  // instruction.
+  ASSERT(previous() != NULL);
+  Instruction* result = previous();
+  while (!result->IsBlockEntry()) result = result->previous();
+  return result->AsBlockEntry();
+}
+
+
 void ForwardInstructionIterator::RemoveCurrentFromGraph() {
   current_ = current_->RemoveFromGraph(true);  // Set current_ to previous.
 }
 
 
 void ForwardInstructionIterator::ReplaceCurrentWith(Definition* other) {
   Definition* defn = current_->AsDefinition();
   ASSERT(defn != NULL);
   defn->ReplaceUsesWith(other);
   ASSERT(other->env() == NULL);
@@ skipping 366 matching lines @@
                                parent, assigned_vars,
                                variable_count, fixed_parameter_count);
   }
 
   // 6. Assign postorder number and add the block entry to the list.
   set_postorder_number(postorder->length());
   postorder->Add(this);
 }
 
 
+bool BlockEntryInstr::Dominates(BlockEntryInstr* other) const {
+  ASSERT(other != NULL);

[Kevin Millikin (Google), 2012/09/06 12:42:42]

Add a TODO to make this faster :)

[Florian Schneider, 2012/09/06 13:05:53]

Done.

+  BlockEntryInstr* current = other;
+  while (current != NULL && current != this) {
+    current = current->dominator();
+  }
+  return current == this;
+}
+
+
 void ControlInstruction::DiscoverBlocks(
     BlockEntryInstr* current_block,
     GrowableArray<BlockEntryInstr*>* preorder,
     GrowableArray<BlockEntryInstr*>* postorder,
     GrowableArray<intptr_t>* parent,
     GrowableArray<BitVector*>* assigned_vars,
     intptr_t variable_count,
     intptr_t fixed_parameter_count) {
   current_block->set_last_instruction(this);
   // Visit the false successor before the true successor so they appear in
@@ skipping 667 matching lines @@
   __ int3();
 }
 
 
 LocationSummary* GotoInstr::MakeLocationSummary() const {
   return new LocationSummary(0, 0, LocationSummary::kNoCall);
 }
 
 
 void GotoInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  // Add deoptimization descriptor for deoptimizing instructions
+  // that may be inserted before this instruction.
+  compiler->AddCurrentDescriptor(PcDescriptors::kDeoptBefore,
+                                 GetDeoptId(),
+                                 0);  // No token position.
+
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 
   // We can fall through if the successor is the next block in the list.
   // Otherwise, we need a jump.
   if (!compiler->IsNextBlock(successor())) {
     __ jmp(compiler->GetBlockLabel(successor()));
   }
 }
@@ skipping 310 matching lines @@
     value->set_use_index(i);
     value->AddToEnvUseList();
   }
   instr->set_env(copy);
 }
 
 
 #undef __
 
 }  // namespace dart