clang-format runtime/vm

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) ||                                              \
+#if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_ARM64) ||                  \
     defined(TARGET_ARCH_MIPS)
 DECLARE_FLAG(bool, use_far_branches);
 #endif
 
 // Forward declarations.
 class Assembler;
 class AssemblerFixup;
 class AssemblerBuffer;
 class MemoryRegion;
 
@@ skipping 42 matching lines @@
 };
 
 
 // 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) {
+  template <typename T>
+  void Emit(T value) {
     ASSERT(HasEnsuredCapacity());
     *reinterpret_cast<T*>(cursor_) = value;
     cursor_ += sizeof(T);
   }
 
-  template<typename T> void Remit() {
+  template <typename T>
+  void Remit() {
     ASSERT(Size() >= static_cast<intptr_t>(sizeof(T)));
     cursor_ -= sizeof(T);
   }
 
   // Return address to code at |position| bytes.
-  uword Address(intptr_t position) {
-    return contents_ + position;
-  }
+  uword Address(intptr_t position) { return contents_ + position; }
 
-  template<typename T> T Load(intptr_t position) {
+  template <typename T>
+  T Load(intptr_t position) {
     ASSERT(position >= 0 &&
            position <= (Size() - static_cast<intptr_t>(sizeof(T))));
     return *reinterpret_cast<T*>(contents_ + position);
   }
 
-  template<typename T> void Store(intptr_t position, T value) {
+  template <typename T>
+  void Store(intptr_t position, T value) {
     ASSERT(position >= 0 &&
            position <= (Size() - static_cast<intptr_t>(sizeof(T))));
     *reinterpret_cast<T*>(contents_ + position) = value;
   }
 
   const ZoneGrowableArray<intptr_t>& pointer_offsets() const {
 #if defined(DEBUG)
     ASSERT(fixups_processed_);
 #endif
     return *pointer_offsets_;
@@ skipping 14 matching lines @@
   intptr_t CountPointerOffsets() const;
 
   // Get the size of the emitted code.
   intptr_t Size() const { return cursor_ - contents_; }
   uword contents() const { return contents_; }
 
   // Copy the assembled instructions into the specified memory block
   // and apply all fixups.
   void FinalizeInstructions(const MemoryRegion& region);
 
-  // To emit an instruction to the assembler buffer, the EnsureCapacity helper
-  // must be used to guarantee that the underlying data area is big enough to
-  // hold the emitted instruction. Usage:
-  //
-  //     AssemblerBuffer buffer;
-  //     AssemblerBuffer::EnsureCapacity ensured(&buffer);
-  //     ... emit bytes for single instruction ...
+// To emit an instruction to the assembler buffer, the EnsureCapacity helper
+// must be used to guarantee that the underlying data area is big enough to
+// hold the emitted instruction. Usage:
+//
+//     AssemblerBuffer buffer;
+//     AssemblerBuffer::EnsureCapacity ensured(&buffer);
+//     ... emit bytes for single instruction ...
 
 #if defined(DEBUG)
   class EnsureCapacity : public ValueObject {
    public:
     explicit EnsureCapacity(AssemblerBuffer* buffer);
     ~EnsureCapacity();
 
    private:
     AssemblerBuffer* buffer_;
     intptr_t gap_;
@@ skipping 53 matching lines @@
     return data + capacity - kMinimumGap;
   }
 
   void ExtendCapacity();
 
   friend class AssemblerFixup;
 };
 
 
 struct ObjectPoolWrapperEntry {
-  ObjectPoolWrapperEntry()
-    : raw_value_(), type_(), equivalence_() { }
+  ObjectPoolWrapperEntry() : raw_value_(), type_(), equivalence_() {}
   explicit ObjectPoolWrapperEntry(const Object* obj)
-    : obj_(obj), type_(ObjectPool::kTaggedObject), equivalence_(obj) { }
+      : obj_(obj), type_(ObjectPool::kTaggedObject), equivalence_(obj) {}
   explicit ObjectPoolWrapperEntry(const Object* obj, const Object* eqv)
-    : obj_(obj), type_(ObjectPool::kTaggedObject), equivalence_(eqv) { }
+      : obj_(obj), type_(ObjectPool::kTaggedObject), equivalence_(eqv) {}
   ObjectPoolWrapperEntry(uword value, ObjectPool::EntryType info)
-    : raw_value_(value), type_(info), equivalence_() { }
+      : 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;
 
-  ObjIndexPair() : key_(static_cast<uword>(NULL), ObjectPool::kTaggedObject),
-                   value_(kNoIndex) { }
+  ObjIndexPair()
+      : key_(static_cast<uword>(NULL), ObjectPool::kTaggedObject),
+        value_(kNoIndex) {}
 
   ObjIndexPair(Key key, Value value) : value_(value) {
     key_.type_ = key.type_;
     if (key.type_ == ObjectPool::kTaggedObject) {
       key_.obj_ = key.obj_;
       key_.equivalence_ = key.equivalence_;
     } else {
       key_.raw_value_ = key.raw_value_;
     }
   }
@@ skipping 33 matching lines @@
 
 
 enum Patchability {
   kPatchable,
   kNotPatchable,
 };
 
 
 class ObjectPoolWrapper : public ValueObject {
  public:
-  intptr_t AddObject(const Object& obj,
-                     Patchability patchable = kNotPatchable);
+  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 FindObject(const Object& obj, const Object& equivalence);
   intptr_t FindImmediate(uword imm);
-  intptr_t FindNativeEntry(const ExternalLabel* label,
-                           Patchability patchable);
+  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
-};
+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_MIPS)
 #include "vm/assembler_mips.h"
 #elif defined(TARGET_ARCH_DBC)
 #include "vm/assembler_dbc.h"
 #else
 #error Unknown architecture.
 #endif
 
 #endif  // RUNTIME_VM_ASSEMBLER_H_