Cleanups.

runtime/vm/flow_graph_allocator.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/flow_graph_allocator.h"
 
 #include "vm/bit_vector.h"
 #include "vm/intermediate_language.h"
 #include "vm/il_printer.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 103 matching lines @@
       Definition* current_def = current->AsDefinition();
       if ((current_def != NULL) && (current_def->ssa_temp_index() >= 0)) {
         kill->Add(current_def->ssa_temp_index());
       }
     }
   }
 
   // Update initial live_in sets to match live_out sets. Has to be
   // done in a separate path because of backwards branches.
   for (intptr_t i = 0; i < block_count; i++) {
-    UpdateLiveIn(postorder_[i]);
+    UpdateLiveIn(*postorder_[i]);
   }
 }
 
 
-bool FlowGraphAllocator::UpdateLiveOut(BlockEntryInstr* instr) {
-  BitVector* live_out = live_out_[instr->postorder_number()];
+bool FlowGraphAllocator::UpdateLiveOut(const BlockEntryInstr& instr) {
+  BitVector* live_out = live_out_[instr.postorder_number()];
   bool changed = false;
-  Instruction* last = instr->last_instruction();
+  Instruction* last = instr.last_instruction();
   ASSERT(last != NULL);
   for (intptr_t i = 0; i < last->SuccessorCount(); i++) {
     BlockEntryInstr* succ = last->SuccessorAt(i);
     ASSERT(succ != NULL);
     if (live_out->AddAll(live_in_[succ->postorder_number()])) {
       changed = true;
     }
   }
   return changed;
 }
 
 
-bool FlowGraphAllocator::UpdateLiveIn(BlockEntryInstr* instr) {
-  BitVector* live_out = live_out_[instr->postorder_number()];
-  BitVector* kill = kill_[instr->postorder_number()];
-  BitVector* live_in = live_in_[instr->postorder_number()];
+bool FlowGraphAllocator::UpdateLiveIn(const BlockEntryInstr& instr) {
+  BitVector* live_out = live_out_[instr.postorder_number()];
+  BitVector* kill = kill_[instr.postorder_number()];
+  BitVector* live_in = live_in_[instr.postorder_number()];
   return live_in->KillAndAdd(kill, live_out);
 }
 
 
 void FlowGraphAllocator::ComputeLiveInAndLiveOutSets() {
   const intptr_t block_count = postorder_.length();
   bool changed;
   do {
     changed = false;
 
     for (intptr_t i = 0; i < block_count; i++) {
-      BlockEntryInstr* block = postorder_[i];
+      const BlockEntryInstr& block = *postorder_[i];
 
       // Live-in set depends only on kill set which does not
       // change in this loop and live-out set.  If live-out
       // set does not change there is no need to recompute
       // live-in set.
       if (UpdateLiveOut(block) && UpdateLiveIn(block)) {
         changed = true;
       }
     }
   } while (changed);
@@ skipping 233 matching lines @@
       // instruction numbers to parallel moves.
       ParallelMoveInstr* parallel_move = current->AsParallelMove();
       if (parallel_move != NULL) {
         JoinEntryInstr* join = goto_instr->successor();
         ASSERT(join != NULL);
 
         // Search for the index of the current block in the predecessors of
         // the join.
         // TODO(kmillikin): record the predecessor index in the goto when
         // building the predecessor list to avoid this search.
-        intptr_t pred_idx = 0;
-        for (; pred_idx < join->PredecessorCount(); pred_idx++) {
-          if (join->PredecessorAt(pred_idx) == block) break;
-        }
-        ASSERT(pred_idx < join->PredecessorCount());
+        intptr_t pred_idx = join->IndexOfPredecessor(block);
+        ASSERT(pred_idx >= 0);
 
         // Record the corresponding phi input use for each phi.
         ZoneGrowableArray<PhiInstr*>* phis = join->phis();
         intptr_t move_idx = 0;
         for (intptr_t phi_idx = 0; phi_idx < phis->length(); phi_idx++) {
           PhiInstr* phi = (*phis)[phi_idx];
           if (phi == NULL) continue;
 
           Value* val = phi->InputAt(pred_idx);
           MoveOperands* move = parallel_move->MoveOperandsAt(move_idx);
@@ skipping 428 matching lines @@
       FinalizeInterval(a,
                        Location::RegisterLocation(static_cast<Register>(reg)));
       a = a->next_allocated();
     }
 
     cpu_regs_[reg] = a;
   }
 }
 
 
-static inline bool ShouldBeAllocatedBefore(UseInterval* a, UseInterval* b) {
-  return a->start() <= b->start();
+static inline bool ShouldBeAllocatedBefore(const UseInterval& a,
+                                           const UseInterval& b) {
+  return a.start() <= b.start();
 }
 
 
 void FlowGraphAllocator::AddToUnallocated(UseInterval* chain) {
   if (unallocated_.is_empty()) {
     unallocated_.Add(chain);
     return;
   }
 
   for (intptr_t i = unallocated_.length() - 1; i >= 0; i--) {
-    if (ShouldBeAllocatedBefore(chain, unallocated_[i])) {
+    if (ShouldBeAllocatedBefore(*chain, *unallocated_[i])) {
       unallocated_.InsertAt(i + 1, chain);
       return;
     }
   }
   unallocated_.InsertAt(0, chain);
 }
 
 
 bool FlowGraphAllocator::UnallocatedIsSorted() {
   for (intptr_t i = unallocated_.length() - 1; i >= 1; i--) {
     UseInterval* a = unallocated_[i];
     UseInterval* b = unallocated_[i - 1];
-    if (!ShouldBeAllocatedBefore(a, b)) return false;
+    if (!ShouldBeAllocatedBefore(*a, *b)) return false;
   }
   return true;
 }
 
 
 void FlowGraphAllocator::AllocateCPURegisters() {
   ASSERT(UnallocatedIsSorted());
 
   while (!unallocated_.is_empty()) {
     UseInterval* range = unallocated_.Last();
@@ skipping 47 matching lines @@
 
   if (FLAG_trace_ssa_allocator) {
     OS::Print("-- ir after allocation -------------------------\n");
     FlowGraphPrinter printer(Function::Handle(), block_order_, true);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart