Some 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 842 matching lines @@
 Instruction* FlowGraphAllocator::InstructionAt(intptr_t pos) const {
   return instructions_[pos / 2];
 }
 
 
 bool FlowGraphAllocator::IsBlockEntry(intptr_t pos) const {
   return InstructionAt(pos)->IsBlockEntry();
 }
 
 
-static UsePosition* FirstUseAfter(UsePosition* use, intptr_t after) {
-  while ((use != NULL) && (use->pos() < after)) {
-    use = use->next();
-  }
-  return use;
+void AllocationFinger::Initialize(LiveRange* range) {
+  first_pending_use_interval_ = range->first_use_interval();
+  first_register_use_ = range->first_use();
+  first_register_beneficial_use_ = range->first_use();
+  first_hinted_use_ = range->first_use();
 }
 
 
+bool AllocationFinger::Advance(const intptr_t start) {
+  UseInterval* a = first_pending_use_interval_;
+  while (a != NULL && a->end() <= start) a = a->next();
+  first_pending_use_interval_ = a;
+  if (first_pending_use_interval_ == NULL) {
+    return true;
+  }
+  return false;
+}
+
+
 Location AllocationFinger::FirstHint() {
   UsePosition* use = first_hinted_use_;
 
   while (use != NULL) {
     if (use->HasHint()) return use->hint();
     use = use->next();
   }
 
   return Location::NoLocation();
 }
 
 
+static UsePosition* FirstUseAfter(UsePosition* use, intptr_t after) {
+  while ((use != NULL) && (use->pos() < after)) {
+    use = use->next();
+  }
+  return use;
+}
+
+
 UsePosition* AllocationFinger::FirstRegisterUse(intptr_t after) {
   for (UsePosition* use = FirstUseAfter(first_register_use_, after);
        use != NULL;
        use = use->next()) {
     Location* loc = use->location_slot();
     if ((loc != NULL) &&
         loc->IsUnallocated() &&
         (loc->policy() == Location::kRequiresRegister)) {
       first_register_use_ = use;
       return use;
@@ skipping 268 matching lines @@
 
   cpu_regs_[candidate].Add(unallocated);
   unallocated->set_assigned_location(Location::RegisterLocation(candidate));
 
   return true;
 }
 
 
 void FlowGraphAllocator::AllocateAnyRegister(LiveRange* unallocated) {
   UsePosition* register_use =
-    unallocated->finger()->FirstRegisterUse(unallocated->Start());
+      unallocated->finger()->FirstRegisterUse(unallocated->Start());
   if (register_use == NULL) {
     Spill(unallocated);
     return;
   }
 
   Register candidate = kNoRegister;
   intptr_t free_until = 0;
   intptr_t blocked_at = kMaxPosition;
 
   for (int reg = 0; reg < kNumberOfCpuRegisters; ++reg) {
@@ skipping 29 matching lines @@
                                          intptr_t* cur_free_until,
                                          intptr_t* cur_blocked_at) {
   intptr_t free_until = kMaxPosition;
   intptr_t blocked_at = kMaxPosition;
   const intptr_t start = unallocated->Start();
 
   for (intptr_t i = 0; i < cpu_regs_[reg].length(); i++) {
     LiveRange* allocated = cpu_regs_[reg][i];
 
     UseInterval* first_pending_use_interval =
-      allocated->finger()->first_pending_use_interval();
+        allocated->finger()->first_pending_use_interval();
     if (first_pending_use_interval->Contains(start)) {
       // This is an active interval.
       if (allocated->vreg() <= 0) {
         // This register blocked by an interval that
         // can't be spilled.
         return false;
       }
 
       const UsePosition* use =
         allocated->finger()->FirstRegisterBeneficialUse(unallocated->Start());
 
       if ((use != NULL) && ((use->pos() - start) <= 1)) {
         // This register is blocked by interval that is used
         // as register in the current instruction and can't
         // be spilled.
         return false;
       }
 
       const intptr_t use_pos = (use != NULL) ? use->pos()
                                              : allocated->End();
 
       if (use_pos < free_until) free_until = use_pos;
     } else {
       // This is inactive interval.
       const intptr_t intersection = FirstIntersection(
-        first_pending_use_interval, unallocated->first_use_interval());
+          first_pending_use_interval, unallocated->first_use_interval());
       if (intersection != kMaxPosition) {
         if (intersection < free_until) free_until = intersection;
         if (allocated->vreg() == kNoVirtualRegister) blocked_at = intersection;
       }
     }
 
     if (free_until <= *cur_free_until) {
       return false;
     }
   }
@@ skipping 19 matching lines @@
 void FlowGraphAllocator::AssignNonFreeRegister(LiveRange* unallocated,
                                                Register reg) {
   TRACE_ALLOC(("assigning blocked register %s to live range %d\n",
                Location::RegisterLocation(reg).Name(),
                unallocated->vreg()));
 
   intptr_t first_evicted = -1;
   for (intptr_t i = cpu_regs_[reg].length() - 1; i >= 0; i--) {
     LiveRange* allocated = cpu_regs_[reg][i];
     if (allocated->vreg() < 0) continue;  // Can't be evicted.
-    if (EvictIntersection(allocated,
-                          unallocated)) {
+    if (EvictIntersection(allocated, unallocated)) {
       cpu_regs_[reg][i] = NULL;
       first_evicted = i;
     }
   }
 
   // Remove evicted ranges from the array.
   if (first_evicted != -1) RemoveEvicted(reg, first_evicted);
 
   cpu_regs_[reg].Add(unallocated);
   unallocated->set_assigned_location(Location::RegisterLocation(reg));
@@ skipping 56 matching lines @@
                range->vreg(),
                range->assigned_location().Name()));
   ASSERT(!range->assigned_location().IsInvalid());
   const Location loc = range->assigned_location();
   for (UsePosition* use = range->first_use(); use != NULL; use = use->next()) {
     ConvertUseTo(use, loc);
   }
 }
 
 
-bool AllocationFinger::Advance(const intptr_t start) {
-  UseInterval* a = first_pending_use_interval_;
-  while (a != NULL && a->end() <= start) a = a->next();
-  first_pending_use_interval_ = a;
-  if (first_pending_use_interval_ == NULL) {
-    return true;
-  }
-  return false;
-}
-
-
 void FlowGraphAllocator::AdvanceActiveIntervals(const intptr_t start) {
   for (intptr_t reg = 0; reg < kNumberOfCpuRegisters; reg++) {
     if (cpu_regs_[reg].is_empty()) continue;
 
     intptr_t first_evicted = -1;
     for (intptr_t i = cpu_regs_[reg].length() - 1; i >= 0; i--) {
       LiveRange* range = cpu_regs_[reg][i];
       if (range->finger()->Advance(start)) {
         ConvertAllUses(range);
         cpu_regs_[reg][i] = NULL;
         first_evicted = i;
       }
     }
 
     if (first_evicted != -1) {
       RemoveEvicted(static_cast<Register>(reg), first_evicted);
     }
   }
 }
 
 
-void AllocationFinger::Initialize(LiveRange* range) {
-  first_pending_use_interval_ = range->first_use_interval();
-  first_register_use_ = range->first_use();
-  first_register_beneficial_use_ = range->first_use();
-  first_hinted_use_ = range->first_use();
-}
-
-
 static inline bool ShouldBeAllocatedBefore(LiveRange* a, LiveRange* b) {
   return a->Start() <= b->Start();
 }
 
 
 void FlowGraphAllocator::AddToUnallocated(LiveRange* range) {
   range->finger()->Initialize(range);
 
   if (unallocated_.is_empty()) {
     unallocated_.Add(range);
@@ skipping 180 matching lines @@
 
   if (FLAG_trace_ssa_allocator) {
     OS::Print("-- ir after allocation -------------------------\n");
     FlowGraphPrinter printer(Function::Handle(), block_order_, true);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart