VM: Re-format to use at most one newline between functions

runtime/vm/flow_graph_allocator.h

 // 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.
 
 #ifndef RUNTIME_VM_FLOW_GRAPH_ALLOCATOR_H_
 #define RUNTIME_VM_FLOW_GRAPH_ALLOCATOR_H_
 
 #include "vm/flow_graph.h"
 #include "vm/growable_array.h"
 #include "vm/intermediate_language.h"
 
 namespace dart {
 
 class AllocationFinger;
 class BlockInfo;
 class FlowGraph;
 class LiveRange;
 class UseInterval;
 class UsePosition;
 
-
 class ReachingDefs : public ValueObject {
  public:
   explicit ReachingDefs(const FlowGraph& flow_graph)
       : flow_graph_(flow_graph), phis_(10) {}
 
   BitVector* Get(PhiInstr* phi);
 
  private:
   void AddPhi(PhiInstr* phi);
   void Compute();
 
   const FlowGraph& flow_graph_;
   GrowableArray<PhiInstr*> phis_;
 };
 
-
 class SSALivenessAnalysis : public LivenessAnalysis {
  public:
   explicit SSALivenessAnalysis(const FlowGraph& flow_graph)
       : LivenessAnalysis(flow_graph.max_virtual_register_number(),
                          flow_graph.postorder()),
         graph_entry_(flow_graph.graph_entry()) {}
 
  private:
   // Compute initial values for live-out, kill and live-in sets.
   virtual void ComputeInitialSets();
 
   GraphEntryInstr* graph_entry_;
 };
 
-
 class FlowGraphAllocator : public ValueObject {
  public:
   // Number of stack slots needed for a fpu register spill slot.
   static const intptr_t kDoubleSpillFactor = kDoubleSize / kWordSize;
 
   explicit FlowGraphAllocator(const FlowGraph& flow_graph,
                               bool intrinsic_mode = false);
 
   void AllocateRegisters();
 
@@ skipping 83 matching lines @@
 
   // Find all safepoints that are covered by this live range.
   void AssignSafepoints(Definition* defn, LiveRange* range);
 
   void PrepareForAllocation(Location::Kind register_kind,
                             intptr_t number_of_registers,
                             const GrowableArray<LiveRange*>& unallocated,
                             LiveRange** blocking_ranges,
                             bool* blocked_registers);
 
-
   // Process live ranges sorted by their start and assign registers
   // to them
   void AllocateUnallocatedRanges();
   void AdvanceActiveIntervals(const intptr_t start);
 
   // Connect split siblings over non-linear control flow edges.
   void ResolveControlFlow();
   void ConnectSplitSiblings(LiveRange* range,
                             BlockEntryInstr* source_block,
                             BlockEntryInstr* target_block);
@@ skipping 137 matching lines @@
 
   // Per register lists of allocated live ranges.  Contain only those
   // ranges that can be affected by future allocation decisions.
   // Those live ranges that end before the start of the current live range are
   // removed from the list and will not be affected.
   // The length of both arrays is 'number_of_registers_'
   GrowableArray<ZoneGrowableArray<LiveRange*>*> registers_;
 
   GrowableArray<bool> blocked_registers_;
 
-
   // Worklist for register allocator. Always maintained sorted according
   // to ShouldBeAllocatedBefore predicate.
   GrowableArray<LiveRange*> unallocated_;
 
   // List of used spill slots. Contains positions after which spill slots
   // become free and can be reused for allocation.
   GrowableArray<intptr_t> spill_slots_;
 
   // For every used spill slot contains a flag determines whether it is
   // QuadSpillSlot to ensure that indexes of quad and double spill slots
   // are disjoint.
   GrowableArray<bool> quad_spill_slots_;
 
   // Track whether a spill slot is expected to hold a tagged or untagged value.
   // This is used to keep tagged and untagged spill slots disjoint. See bug
   // #18955 for details.
   GrowableArray<bool> untagged_spill_slots_;
 
   intptr_t cpu_spill_slot_count_;
 
   const bool intrinsic_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(FlowGraphAllocator);
 };
 
-
 // Additional information about a block that is not contained in a
 // block entry.
 class BlockInfo : public ZoneAllocated {
  public:
   explicit BlockInfo(BlockEntryInstr* entry)
       : entry_(entry),
         loop_(NULL),
         is_loop_header_(false),
         backedge_interference_(NULL) {}
 
@@ skipping 42 matching lines @@
   bool is_loop_header_;
 
   BlockEntryInstr* last_block_;
   intptr_t loop_id_;
 
   BitVector* backedge_interference_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockInfo);
 };
 
-
 // UsePosition represents a single use of an SSA value by some instruction.
 // It points to a location slot which either tells register allocator
 // where instruction expects the value (if slot contains a fixed location) or
 // asks register allocator to allocate storage (register or spill slot) for
 // this use with certain properties (if slot contains an unallocated location).
 class UsePosition : public ZoneAllocated {
  public:
   UsePosition(intptr_t pos, UsePosition* next, Location* location_slot)
       : pos_(pos), location_slot_(location_slot), hint_(NULL), next_(next) {
     ASSERT(location_slot != NULL);
   }
 
   Location* location_slot() const { return location_slot_; }
   void set_location_slot(Location* location_slot) {
     location_slot_ = location_slot;
   }
 
   Location hint() const {
     ASSERT(HasHint());
     return *hint_;
   }
 
   void set_hint(Location* hint) { hint_ = hint; }
 
   bool HasHint() const { return (hint_ != NULL) && !hint_->IsUnallocated(); }
 
-
   void set_next(UsePosition* next) { next_ = next; }
   UsePosition* next() const { return next_; }
 
   intptr_t pos() const { return pos_; }
 
  private:
   const intptr_t pos_;
   Location* location_slot_;
   Location* hint_;
   UsePosition* next_;
 
   DISALLOW_COPY_AND_ASSIGN(UsePosition);
 };
 
-
 // UseInterval represents a holeless half open interval of liveness for a given
 // SSA value: [start, end) in terms of lifetime positions that
 // NumberInstructions assigns to instructions.  Register allocator has to keep
 // a value live in the register or in a spill slot from start position and until
 // the end position.  The interval can cover zero or more uses.
 // Note: currently all uses of the same SSA value are linked together into a
 // single list (and not split between UseIntervals).
 class UseInterval : public ZoneAllocated {
  public:
   UseInterval(intptr_t start, intptr_t end, UseInterval* next)
@@ skipping 16 matching lines @@
  private:
   friend class LiveRange;
 
   intptr_t start_;
   intptr_t end_;
   UseInterval* next_;
 
   DISALLOW_COPY_AND_ASSIGN(UseInterval);
 };
 
-
 // AllocationFinger is used to keep track of currently active position
 // for the register allocator and cache lookup results.
 class AllocationFinger : public ValueObject {
  public:
   AllocationFinger()
       : first_pending_use_interval_(NULL),
         first_register_use_(NULL),
         first_register_beneficial_use_(NULL),
         first_hinted_use_(NULL) {}
 
@@ skipping 12 matching lines @@
 
  private:
   UseInterval* first_pending_use_interval_;
   UsePosition* first_register_use_;
   UsePosition* first_register_beneficial_use_;
   UsePosition* first_hinted_use_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocationFinger);
 };
 
-
 class SafepointPosition : public ZoneAllocated {
  public:
   SafepointPosition(intptr_t pos, LocationSummary* locs)
       : pos_(pos), locs_(locs), next_(NULL) {}
 
   void set_next(SafepointPosition* next) { next_ = next; }
   SafepointPosition* next() const { return next_; }
 
   intptr_t pos() const { return pos_; }
 
   LocationSummary* locs() const { return locs_; }
 
  private:
   const intptr_t pos_;
   LocationSummary* const locs_;
 
   SafepointPosition* next_;
 };
 
-
 // LiveRange represents a sequence of UseIntervals for a given SSA value.
 class LiveRange : public ZoneAllocated {
  public:
   explicit LiveRange(intptr_t vreg, Representation rep)
       : vreg_(vreg),
         representation_(rep),
         assigned_location_(),
         spill_slot_(),
         uses_(NULL),
         first_use_interval_(NULL),
@@ skipping 105 matching lines @@
   LiveRange* next_sibling_;
 
   intptr_t has_only_any_uses_in_loops_;
   bool is_loop_phi_;
 
   AllocationFinger finger_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRange);
 };
 
-
 }  // namespace dart
 
 #endif  // RUNTIME_VM_FLOW_GRAPH_ALLOCATOR_H_