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

runtime/vm/assembler_x64.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_X64_H_
 #define RUNTIME_VM_ASSEMBLER_X64_H_
 
 #ifndef RUNTIME_VM_ASSEMBLER_H_
 #error Do not include assembler_x64.h directly; use assembler.h instead.
 #endif
@@ skipping 24 matching lines @@
   bool is_int32() const { return Utils::IsInt(32, value_); }
 
  private:
   const int64_t value_;
 
   // TODO(5411081): Add DISALLOW_COPY_AND_ASSIGN(Immediate) once the mac
   // build issue is resolved.
   // And remove the unnecessary copy constructor.
 };
 
-
 class Operand : public ValueObject {
  public:
   uint8_t rex() const { return rex_; }
 
   uint8_t mod() const { return (encoding_at(0) >> 6) & 3; }
 
   Register rm() const {
     int rm_rex = (rex_ & REX_B) << 3;
     return static_cast<Register>(rm_rex + (encoding_at(0) & 7));
   }
@@ skipping 95 matching lines @@
   // disguise. Used from the assembler to generate better encodings.
   bool IsRegister(Register reg) const {
     return ((reg > 7 ? 1 : 0) == (rex_ & REX_B))  // REX.B match.
            && ((encoding_at(0) & 0xF8) == 0xC0)  // Addressing mode is register.
            && ((encoding_at(0) & 0x07) == reg);  // Register codes match.
   }
 
   friend class Assembler;
 };
 
-
 class Address : public Operand {
  public:
   Address(Register base, int32_t disp) {
     if ((disp == 0) && ((base & 7) != RBP)) {
       SetModRM(0, base);
       if ((base & 7) == RSP) {
         SetSIB(TIMES_1, RSP, base);
       }
     } else if (Utils::IsInt(8, disp)) {
       SetModRM(1, base);
@@ skipping 73 matching lines @@
     explicit RIPRelativeDisp(int32_t disp) : disp_(disp) {}
     const int32_t disp_;
   };
 
   explicit Address(const RIPRelativeDisp& disp) {
     SetModRM(0, static_cast<Register>(0x5));
     SetDisp32(disp.disp_);
   }
 };
 
-
 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(Register base, Register index, ScaleFactor scale, int32_t disp)
       : Address(base, index, scale, disp - kHeapObjectTag) {}
 
   // This addressing mode does not exist.
   FieldAddress(Register base, Register index, ScaleFactor scale, Register r);
 
   FieldAddress(const FieldAddress& other) : Address(other) {}
 
   FieldAddress& operator=(const FieldAddress& other) {
     Address::operator=(other);
     return *this;
   }
 };
 
-
 class Label : public ValueObject {
  public:
   Label() : position_(0), unresolved_(0) {
 #ifdef DEBUG
     for (int i = 0; i < kMaxUnresolvedBranches; i++) {
       unresolved_near_positions_[i] = -1;
     }
 #endif  // DEBUG
   }
 
@@ skipping 48 matching lines @@
   static const int kMaxUnresolvedBranches = 20;
 
   intptr_t position_;
   intptr_t unresolved_;
   intptr_t unresolved_near_positions_[kMaxUnresolvedBranches];
 
   friend class Assembler;
   DISALLOW_COPY_AND_ASSIGN(Label);
 };
 
-
 class Assembler : public ValueObject {
  public:
   explicit Assembler(bool use_far_branches = false);
 
   ~Assembler() {}
 
   static const bool kNearJump = true;
   static const bool kFarJump = false;
 
   /*
@@ skipping 713 matching lines @@
   void MoveImmediate(const Address& dst, const Immediate& imm);
 
   void ComputeCounterAddressesForCid(intptr_t cid,
                                      Heap::Space space,
                                      Address* count_address,
                                      Address* size_address);
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
-
 inline void Assembler::EmitUint8(uint8_t value) {
   buffer_.Emit<uint8_t>(value);
 }
 
-
 inline void Assembler::EmitInt32(int32_t value) {
   buffer_.Emit<int32_t>(value);
 }
 
-
 inline void Assembler::EmitInt64(int64_t value) {
   buffer_.Emit<int64_t>(value);
 }
 
-
 inline void Assembler::EmitRegisterREX(Register reg, uint8_t rex) {
   ASSERT(reg != kNoRegister);
   rex |= (reg > 7 ? REX_B : REX_NONE);
   if (rex != REX_NONE) EmitUint8(REX_PREFIX | rex);
 }
 
-
 inline void Assembler::EmitOperandREX(int rm,
                                       const Operand& operand,
                                       uint8_t rex) {
   rex |= (rm > 7 ? REX_R : REX_NONE) | operand.rex();
   if (rex != REX_NONE) EmitUint8(REX_PREFIX | rex);
 }
 
-
 inline void Assembler::EmitREX_RB(XmmRegister reg,
                                   XmmRegister base,
                                   uint8_t rex) {
   if (reg > 7) rex |= REX_R;
   if (base > 7) rex |= REX_B;
   if (rex != REX_NONE) EmitUint8(REX_PREFIX | rex);
 }
 
-
 inline void Assembler::EmitREX_RB(XmmRegister reg,
                                   const Operand& operand,
                                   uint8_t rex) {
   if (reg > 7) rex |= REX_R;
   rex |= operand.rex();
   if (rex != REX_NONE) EmitUint8(REX_PREFIX | rex);
 }
 
-
 inline void Assembler::EmitREX_RB(XmmRegister reg, Register base, uint8_t rex) {
   if (reg > 7) rex |= REX_R;
   if (base > 7) rex |= REX_B;
   if (rex != REX_NONE) EmitUint8(REX_PREFIX | rex);
 }
 
-
 inline void Assembler::EmitREX_RB(Register reg, XmmRegister base, uint8_t rex) {
   if (reg > 7) rex |= REX_R;
   if (base > 7) rex |= REX_B;
   if (rex != REX_NONE) EmitUint8(REX_PREFIX | rex);
 }
 
-
 inline void Assembler::EmitFixup(AssemblerFixup* fixup) {
   buffer_.EmitFixup(fixup);
 }
 
-
 inline void Assembler::EmitOperandSizeOverride() {
   EmitUint8(0x66);
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_ASSEMBLER_X64_H_