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

runtime/vm/locations.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_LOCATIONS_H_
 #define RUNTIME_VM_LOCATIONS_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/bitfield.h"
 #include "vm/log.h"
 
 namespace dart {
 
-
 class BufferFormatter;
 class ConstantInstr;
 class Definition;
 class PairLocation;
 class Value;
 
-
 enum Representation {
   kNoRepresentation,
   kTagged,
   kUntagged,
   kUnboxedDouble,
   kUnboxedInt32,
   kUnboxedUint32,
   kUnboxedMint,
   kUnboxedFloat32x4,
   kUnboxedInt32x4,
   kUnboxedFloat64x2,
   kPairOfTagged,
   kNumRepresentations
 };
 
-
 // Location objects are used to connect register allocator and code generator.
 // Instruction templates used by code generator have a corresponding
 // LocationSummary object which specifies expected location for every input
 // and output.
 // Each location is encoded as a single word: for non-constant locations
 // low 4 bits denote location kind, rest is kind specific location payload
 // e.g. for REGISTER kind payload is register code (value of the Register
 // enumeration), constant locations contain a tagged (low 2 bits are set to 01)
 // Object handle.
 //
@@ skipping 333 matching lines @@
 
   static const intptr_t kStackIndexBias = static_cast<intptr_t>(1)
                                           << (kBitsForStackIndex - 1);
 
   // Location either contains kind and payload fields or a tagged handle for
   // a constant locations. Values of enumeration Kind are selected in such a
   // way that none of them can be interpreted as a kConstant tag.
   uword value_;
 };
 
-
 class PairLocation : public ZoneAllocated {
  public:
   PairLocation() {
     for (intptr_t i = 0; i < kPairLength; i++) {
       ASSERT(locations_[i].IsInvalid());
     }
   }
 
   intptr_t length() const { return kPairLength; }
 
@@ skipping 13 matching lines @@
     ASSERT(i >= 0);
     ASSERT(i < kPairLength);
     return &locations_[i];
   }
 
  private:
   static const intptr_t kPairLength = 2;
   Location locations_[kPairLength];
 };
 
-
 template <typename T>
 class SmallSet {
  public:
   SmallSet() : data_(0) {}
 
   explicit SmallSet(intptr_t data) : data_(data) {}
 
   bool Contains(T value) const { return (data_ & ToMask(value)) != 0; }
 
   void Add(T value) { data_ |= ToMask(value); }
 
   void Remove(T value) { data_ &= ~ToMask(value); }
 
   bool IsEmpty() const { return data_ == 0; }
 
   intptr_t data() const { return data_; }
 
  private:
   static intptr_t ToMask(T value) {
     ASSERT(static_cast<intptr_t>(value) < (kWordSize * kBitsPerByte));
     return 1 << static_cast<intptr_t>(value);
   }
 
   intptr_t data_;
 };
 
-
 class RegisterSet : public ValueObject {
  public:
   RegisterSet()
       : cpu_registers_(), untagged_cpu_registers_(), fpu_registers_() {
     ASSERT(kNumberOfCpuRegisters <= (kWordSize * kBitsPerByte));
     ASSERT(kNumberOfFpuRegisters <= (kWordSize * kBitsPerByte));
   }
 
-
   void Add(Location loc, Representation rep = kTagged) {
     if (loc.IsRegister()) {
       cpu_registers_.Add(loc.reg());
       if (rep != kTagged) {
         // CPU register contains an untagged value.
         MarkUntagged(loc);
       }
     } else if (loc.IsFpuRegister()) {
       fpu_registers_.Add(loc.fpu_reg());
     }
@@ skipping 68 matching lines @@
   intptr_t fpu_registers() const { return fpu_registers_.data(); }
 
  private:
   SmallSet<Register> cpu_registers_;
   SmallSet<Register> untagged_cpu_registers_;
   SmallSet<FpuRegister> fpu_registers_;
 
   DISALLOW_COPY_AND_ASSIGN(RegisterSet);
 };
 
-
 // Specification of locations for inputs and output.
 class LocationSummary : public ZoneAllocated {
  public:
   enum ContainsCall {
     kNoCall,  // Used registers must be reserved as tmp.
     kCall,    // Registers have been saved and can be used without reservation.
     kCallOnSlowPath  // Used registers must be reserved as tmp.
   };
 
   LocationSummary(Zone* zone,
@@ skipping 106 matching lines @@
   BitmapBuilder* stack_bitmap_;
 
   const ContainsCall contains_call_;
   RegisterSet live_registers_;
 
 #if defined(DEBUG)
   intptr_t writable_inputs_;
 #endif
 };
 
-
 }  // namespace dart
 
 #endif  // RUNTIME_VM_LOCATIONS_H_