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

runtime/vm/assembler_arm.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_ASSEMBLER_ARM_H_
 #define RUNTIME_VM_ASSEMBLER_ARM_H_
 
 #ifndef RUNTIME_VM_ASSEMBLER_H_
 #error Do not include assembler_arm.h directly; use assembler.h instead.
 #endif
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/constants_arm.h"
 #include "vm/cpu.h"
 #include "vm/hash_map.h"
 #include "vm/object.h"
 #include "vm/simulator.h"
 
 namespace dart {
 
 // Forward declarations.
 class RuntimeEntry;
 class StubEntry;
 
-
 // Instruction encoding bits.
 enum {
   H = 1 << 5,   // halfword (or byte)
   L = 1 << 20,  // load (or store)
   S = 1 << 20,  // set condition code (or leave unchanged)
   W = 1 << 21,  // writeback base register (or leave unchanged)
   A = 1 << 21,  // accumulate in multiply instruction (or not)
   B = 1 << 22,  // unsigned byte (or word)
   D = 1 << 22,  // high/lo bit of start of s/d register range
   N = 1 << 22,  // long (or short)
@@ skipping 21 matching lines @@
   B20 = 1 << 20,
   B21 = 1 << 21,
   B22 = 1 << 22,
   B23 = 1 << 23,
   B24 = 1 << 24,
   B25 = 1 << 25,
   B26 = 1 << 26,
   B27 = 1 << 27,
 };
 
-
 class Label : public ValueObject {
  public:
   Label() : position_(0) {}
 
   ~Label() {
     // Assert if label is being destroyed with unresolved branches pending.
     ASSERT(!IsLinked());
   }
 
   // Returns the position for bound and linked labels. Cannot be used
@@ skipping 21 matching lines @@
   void LinkTo(intptr_t position) {
     ASSERT(!IsBound());
     position_ = position + kWordSize;
     ASSERT(IsLinked());
   }
 
   friend class Assembler;
   DISALLOW_COPY_AND_ASSIGN(Label);
 };
 
-
 // Encodes Addressing Mode 1 - Data-processing operands.
 class Operand : public ValueObject {
  public:
   // Data-processing operands - Uninitialized.
   Operand() : type_(-1), encoding_(-1) {}
 
   // Data-processing operands - Copy constructor.
   Operand(const Operand& other)
       : ValueObject(), type_(other.type_), encoding_(other.encoding_) {}
 
@@ skipping 73 matching lines @@
     return encoding_;
   }
 
   uint32_t type_;  // Encodes the type field (bits 27-25) in the instruction.
   uint32_t encoding_;
 
   friend class Assembler;
   friend class Address;
 };
 
-
 enum OperandSize {
   kByte,
   kUnsignedByte,
   kHalfword,
   kUnsignedHalfword,
   kWord,
   kUnsignedWord,
   kWordPair,
   kSWord,
   kDWord,
   kRegList,
 };
 
-
 // Load/store multiple addressing mode.
 enum BlockAddressMode {
   // bit encoding P U W
   DA = (0 | 0 | 0) << 21,    // decrement after
   IA = (0 | 4 | 0) << 21,    // increment after
   DB = (8 | 0 | 0) << 21,    // decrement before
   IB = (8 | 4 | 0) << 21,    // increment before
   DA_W = (0 | 0 | 1) << 21,  // decrement after with writeback to base
   IA_W = (0 | 4 | 1) << 21,  // increment after with writeback to base
   DB_W = (8 | 0 | 1) << 21,  // decrement before with writeback to base
   IB_W = (8 | 4 | 1) << 21   // increment before with writeback to base
 };
 
-
 class Address : public ValueObject {
  public:
   enum OffsetKind {
     Immediate,
     IndexRegister,
     ScaledIndexRegister,
   };
 
   // Memory operand addressing mode
   enum Mode {
@@ skipping 93 matching lines @@
 
   OffsetKind kind() const { return kind_; }
 
   uint32_t encoding_;
 
   OffsetKind kind_;
 
   friend class Assembler;
 };
 
-
 class FieldAddress : public Address {
  public:
   FieldAddress(Register base, int32_t disp)
       : Address(base, disp - kHeapObjectTag) {}
 
   // This addressing mode does not exist.
   FieldAddress(Register base, Register r);
 
   FieldAddress(const FieldAddress& other) : Address(other) {}
 
   FieldAddress& operator=(const FieldAddress& other) {
     Address::operator=(other);
     return *this;
   }
 };
 
-
 class Assembler : public ValueObject {
  public:
   explicit Assembler(bool use_far_branches = false)
       : buffer_(),
         prologue_offset_(-1),
         has_single_entry_point_(true),
         use_far_branches_(use_far_branches),
         comments_(),
         constant_pool_allowed_(false) {}
 
@@ skipping 372 matching lines @@
                             int32_t value,
                             Condition cond = AL);
   void AndImmediate(Register rd, Register rs, int32_t imm, Condition cond = AL);
 
   // Test rn and immediate. May clobber IP.
   void TestImmediate(Register rn, int32_t imm, Condition cond = AL);
 
   // Compare rn with signed immediate value. May clobber IP.
   void CompareImmediate(Register rn, int32_t value, Condition cond = AL);
 
-
   // Signed integer division of left by right. Checks to see if integer
   // division is supported. If not, uses the FPU for division with
   // temporary registers tmpl and tmpr. tmpl and tmpr must be different
   // registers.
   void IntegerDivide(Register result,
                      Register left,
                      Register right,
                      DRegister tmpl,
                      DRegister tmpr);
 
@@ skipping 489 matching lines @@
                                   Register value,
                                   Label* no_update);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_ASSEMBLER_ARM_H_