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

runtime/vm/assembler.h

 // 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.
 
 #ifndef RUNTIME_VM_ASSEMBLER_H_
 #define RUNTIME_VM_ASSEMBLER_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
 #include "vm/hash_map.h"
 #include "vm/object.h"
 
 namespace dart {
 
 #if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_ARM64)
 DECLARE_FLAG(bool, use_far_branches);
 #endif
 
 // Forward declarations.
 class Assembler;
 class AssemblerFixup;
 class AssemblerBuffer;
 class MemoryRegion;
 
-
 // External labels keep a function pointer to allow them
 // to be called from code generated by the assembler.
 class ExternalLabel : public ValueObject {
  public:
   explicit ExternalLabel(uword address) : address_(address) {}
 
   bool is_resolved() const { return address_ != 0; }
   uword address() const {
     ASSERT(is_resolved());
     return address_;
   }
 
  private:
   const uword address_;
 };
 
-
 // Assembler fixups are positions in generated code that hold relocation
 // information that needs to be processed before finalizing the code
 // into executable memory.
 class AssemblerFixup : public ZoneAllocated {
  public:
   virtual void Process(const MemoryRegion& region, intptr_t position) = 0;
 
   virtual bool IsPointerOffset() const = 0;
 
   // It would be ideal if the destructor method could be made private,
   // but the g++ compiler complains when this is subclassed.
   virtual ~AssemblerFixup() { UNREACHABLE(); }
 
  private:
   AssemblerFixup* previous_;
   intptr_t position_;
 
   AssemblerFixup* previous() const { return previous_; }
   void set_previous(AssemblerFixup* previous) { previous_ = previous; }
 
   intptr_t position() const { return position_; }
   void set_position(intptr_t position) { position_ = position; }
 
   friend class AssemblerBuffer;
 };
 
-
 // Assembler buffers are used to emit binary code. They grow on demand.
 class AssemblerBuffer : public ValueObject {
  public:
   AssemblerBuffer();
   ~AssemblerBuffer();
 
   // Basic support for emitting, loading, and storing.
   template <typename T>
   void Emit(T value) {
     ASSERT(HasEnsuredCapacity());
@@ skipping 124 matching lines @@
   // description of kMinimumGap for the reasoning behind the value.
   static uword ComputeLimit(uword data, intptr_t capacity) {
     return data + capacity - kMinimumGap;
   }
 
   void ExtendCapacity();
 
   friend class AssemblerFixup;
 };
 
-
 struct ObjectPoolWrapperEntry {
   ObjectPoolWrapperEntry() : raw_value_(), type_(), equivalence_() {}
   explicit ObjectPoolWrapperEntry(const Object* obj)
       : obj_(obj), type_(ObjectPool::kTaggedObject), equivalence_(obj) {}
   explicit ObjectPoolWrapperEntry(const Object* obj, const Object* eqv)
       : obj_(obj), type_(ObjectPool::kTaggedObject), equivalence_(eqv) {}
   ObjectPoolWrapperEntry(uword value, ObjectPool::EntryType info)
       : raw_value_(value), type_(info), equivalence_() {}
 
   union {
     const Object* obj_;
     uword raw_value_;
   };
   ObjectPool::EntryType type_;
   const Object* equivalence_;
 };
 
-
 // Pair type parameter for DirectChainedHashMap used for the constant pool.
 class ObjIndexPair {
  public:
   // Typedefs needed for the DirectChainedHashMap template.
   typedef ObjectPoolWrapperEntry Key;
   typedef intptr_t Value;
   typedef ObjIndexPair Pair;
 
   static const intptr_t kNoIndex = -1;
 
@@ skipping 37 matching lines @@
              (kv.key_.equivalence_->raw() == key.equivalence_->raw());
     }
     return kv.key_.raw_value_ == key.raw_value_;
   }
 
  private:
   Key key_;
   Value value_;
 };
 
-
 enum Patchability {
   kPatchable,
   kNotPatchable,
 };
 
-
 class ObjectPoolWrapper : public ValueObject {
  public:
   intptr_t AddObject(const Object& obj, Patchability patchable = kNotPatchable);
   intptr_t AddImmediate(uword imm);
 
   intptr_t FindObject(const Object& obj,
                       Patchability patchable = kNotPatchable);
   intptr_t FindObject(const Object& obj, const Object& equivalence);
   intptr_t FindImmediate(uword imm);
   intptr_t FindNativeEntry(const ExternalLabel* label, Patchability patchable);
 
   RawObjectPool* MakeObjectPool();
 
  private:
   intptr_t AddObject(ObjectPoolWrapperEntry entry, Patchability patchable);
   intptr_t FindObject(ObjectPoolWrapperEntry entry, Patchability patchable);
 
   // Objects and jump targets.
   GrowableArray<ObjectPoolWrapperEntry> object_pool_;
 
   // Hashmap for fast lookup in object pool.
   DirectChainedHashMap<ObjIndexPair> object_pool_index_table_;
 };
 
-
 enum RestorePP { kRestoreCallerPP, kKeepCalleePP };
 
 }  // namespace dart
 
-
 #if defined(TARGET_ARCH_IA32)
 #include "vm/assembler_ia32.h"
 #elif defined(TARGET_ARCH_X64)
 #include "vm/assembler_x64.h"
 #elif defined(TARGET_ARCH_ARM)
 #include "vm/assembler_arm.h"
 #elif defined(TARGET_ARCH_ARM64)
 #include "vm/assembler_arm64.h"
 #elif defined(TARGET_ARCH_DBC)
 #include "vm/assembler_dbc.h"
 #else
 #error Unknown architecture.
 #endif
 
 #endif  // RUNTIME_VM_ASSEMBLER_H_