clang-format runtime/vm

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
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/constants_x64.h"
 #include "vm/hash_map.h"
 #include "vm/object.h"
 
 namespace dart {
 
 // Forward declarations.
 class RuntimeEntry;
 class StubEntry;
 
 class Immediate : public ValueObject {
  public:
-  explicit Immediate(int64_t value) : value_(value) { }
+  explicit Immediate(int64_t value) : value_(value) {}
 
-  Immediate(const Immediate& other) : ValueObject(), value_(other.value_) { }
+  Immediate(const Immediate& other) : ValueObject(), value_(other.value_) {}
 
   int64_t value() const { return value_; }
 
   bool is_int8() const { return Utils::IsInt(8, value_); }
   bool is_uint8() const { return Utils::IsUint(8, value_); }
   bool is_uint16() const { return Utils::IsUint(16, value_); }
   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 rex() const { return rex_; }
 
-  uint8_t mod() const {
-    return (encoding_at(0) >> 6) & 3;
-  }
+  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));
   }
 
   ScaleFactor scale() const {
     return static_cast<ScaleFactor>((encoding_at(1) >> 6) & 3);
   }
 
@@ skipping 32 matching lines @@
   bool Equals(const Operand& other) const {
     if (length_ != other.length_) return false;
     if (rex_ != other.rex_) return false;
     for (uint8_t i = 0; i < length_; i++) {
       if (encoding_[i] != other.encoding_[i]) return false;
     }
     return true;
   }
 
  protected:
-  Operand() : length_(0), rex_(REX_NONE) { }  // Needed by subclass Address.
+  Operand() : length_(0), rex_(REX_NONE) {}  // Needed by subclass Address.
 
   void SetModRM(int mod, Register rm) {
     ASSERT((mod & ~3) == 0);
     if ((rm > 7) && !((rm == R12) && (mod != 3))) {
       rex_ |= REX_B;
     }
     encoding_[0] = (mod << 6) | (rm & 7);
     length_ = 1;
   }
 
@@ skipping 30 matching lines @@
   // Get the operand encoding byte at the given index.
   uint8_t encoding_at(intptr_t index) const {
     ASSERT(index >= 0 && index < length_);
     return encoding_[index];
   }
 
   // Returns whether or not this operand is really the given register in
   // 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.
+           && ((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)) {
@@ skipping 41 matching lines @@
     } else {
       SetModRM(2, RSP);
       SetSIB(scale, index, base);
       SetDisp32(disp);
     }
   }
 
   // This addressing mode does not exist.
   Address(Register base, Register index, ScaleFactor scale, Register r);
 
-  Address(const Address& other) : Operand(other) { }
+  Address(const Address& other) : Operand(other) {}
 
   Address& operator=(const Address& other) {
     Operand::operator=(other);
     return *this;
   }
 
   static Address AddressRIPRelative(int32_t disp) {
     return Address(RIPRelativeDisp(disp));
   }
   static Address AddressBaseImm32(Register base, int32_t disp) {
     return Address(base, disp, true);
   }
 
   // This addressing mode does not exist.
   static Address AddressBaseImm32(Register base, Register r);
 
  private:
   Address(Register base, int32_t disp, bool fixed) {
     ASSERT(fixed);
     SetModRM(2, base);
     if ((base & 7) == RSP) {
       SetSIB(TIMES_1, RSP, base);
     }
     SetDisp32(disp);
   }
 
   struct RIPRelativeDisp {
-    explicit RIPRelativeDisp(int32_t disp) : disp_(disp) { }
+    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) { }
+      : 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) { }
+      : 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(const FieldAddress& other) : Address(other) {}
 
   FieldAddress& operator=(const FieldAddress& other) {
     Address::operator=(other);
     return *this;
   }
 };
 
 
 class Label : public ValueObject {
  public:
@@ skipping 61 matching lines @@
 
   friend class Assembler;
   DISALLOW_COPY_AND_ASSIGN(Label);
 };
 
 
 class Assembler : public ValueObject {
  public:
   explicit Assembler(bool use_far_branches = false);
 
-  ~Assembler() { }
+  ~Assembler() {}
 
   static const bool kNearJump = true;
   static const bool kFarJump = false;
 
   /*
    * Emit Machine Instructions.
    */
   void call(Register reg);
   void call(const Address& address);
   void call(Label* label);
@@ skipping 129 matching lines @@
   void cvtsi2sdl(XmmRegister a, Register b);
   void cvttsd2siq(Register dst, XmmRegister src);
 
   void cvtss2sd(XmmRegister dst, XmmRegister src);
   void cvtsd2ss(XmmRegister dst, XmmRegister src);
 
   void pxor(XmmRegister dst, XmmRegister src);
 
   enum RoundingMode {
     kRoundToNearest = 0x0,
-    kRoundDown      = 0x1,
-    kRoundUp        = 0x2,
-    kRoundToZero    = 0x3
+    kRoundDown = 0x1,
+    kRoundUp = 0x2,
+    kRoundToZero = 0x3
   };
   void roundsd(XmmRegister dst, XmmRegister src, RoundingMode mode);
 
   void xchgl(Register dst, Register src);
   void xchgq(Register dst, Register src);
 
   void cmpb(const Address& address, const Immediate& imm);
 
   void cmpw(Register reg, const Address& address);
   void cmpw(const Address& address, const Immediate& imm);
@@ skipping 156 matching lines @@
   void ffree(intptr_t value);
 
   void fsin();
   void fcos();
 
   // 'size' indicates size in bytes and must be in the range 1..8.
   void nop(int size = 1);
   void int3();
   void hlt();
 
-  static uword GetBreakInstructionFiller() {
-    return 0xCCCCCCCCCCCCCCCC;
-  }
+  static uword GetBreakInstructionFiller() { return 0xCCCCCCCCCCCCCCCC; }
 
   void j(Condition condition, Label* label, bool near = kFarJump);
 
   void jmp(Register reg);
   void jmp(const Address& address);
   void jmp(Label* label, bool near = kFarJump);
   void jmp(const ExternalLabel* label);
   void jmp(const StubEntry& stub_entry);
 
   void lock();
@@ skipping 44 matching lines @@
   // Macros for adding/subtracting an immediate value that may be loaded from
   // the constant pool.
   // TODO(koda): Assert that these are not used for heap objects.
   void AddImmediate(Register reg, const Immediate& imm);
   void AddImmediate(const Address& address, const Immediate& imm);
   void SubImmediate(Register reg, const Immediate& imm);
   void SubImmediate(const Address& address, const Immediate& imm);
 
   void Drop(intptr_t stack_elements, Register tmp = TMP);
 
-  bool constant_pool_allowed() const {
-    return constant_pool_allowed_;
-  }
-  void set_constant_pool_allowed(bool b) {
-    constant_pool_allowed_ = b;
-  }
+  bool constant_pool_allowed() const { return constant_pool_allowed_; }
+  void set_constant_pool_allowed(bool b) { constant_pool_allowed_ = b; }
 
   void LoadImmediate(Register reg, const Immediate& imm);
   void LoadIsolate(Register dst);
   void LoadObject(Register dst, const Object& obj);
   void LoadUniqueObject(Register dst, const Object& obj);
   void LoadNativeEntry(Register dst,
                        const ExternalLabel* label,
                        Patchability patchable);
   void LoadFunctionFromCalleePool(Register dst,
                                   const Function& function,
                                   Register new_pp);
   void JmpPatchable(const StubEntry& stub_entry, Register pp);
   void Jmp(const StubEntry& stub_entry, Register pp = PP);
   void J(Condition condition, const StubEntry& stub_entry, Register pp);
   void CallPatchable(const StubEntry& stub_entry);
   void Call(const StubEntry& stub_entry);
   void CallToRuntime();
   // Emit a call that shares its object pool entries with other calls
   // that have the same equivalence marker.
   void CallWithEquivalence(const StubEntry& stub_entry,
                            const Object& equivalence);
   // Unaware of write barrier (use StoreInto* methods for storing to objects).
   // TODO(koda): Add StackAddress/HeapAddress types to prevent misuse.
   void StoreObject(const Address& dst, const Object& obj);
   void PushObject(const Object& object);
   void CompareObject(Register reg, const Object& object);
 
   // Destroys value.
-  void StoreIntoObject(Register object,  // Object we are storing into.
+  void StoreIntoObject(Register object,      // Object we are storing into.
                        const Address& dest,  // Where we are storing into.
-                       Register value,  // Value we are storing.
+                       Register value,       // Value we are storing.
                        bool can_value_be_smi = true);
 
   void StoreIntoObjectNoBarrier(Register object,
                                 const Address& dest,
                                 Register value);
   void StoreIntoObjectNoBarrier(Register object,
                                 const Address& dest,
                                 const Object& value);
 
   // Stores a Smi value into a heap object field that always contains a Smi.
@@ skipping 47 matching lines @@
   void LoadClassIdMayBeSmi(Register result, Register object);
   void LoadTaggedClassIdMayBeSmi(Register result, Register object);
 
   // CheckClassIs fused with optimistic SmiUntag.
   // Value in the register object is untagged optimistically.
   void SmiUntagOrCheckClass(Register object, intptr_t class_id, Label* smi);
 
   /*
    * Misc. functionality.
    */
-  void SmiTag(Register reg) {
-    addq(reg, reg);
-  }
+  void SmiTag(Register reg) { addq(reg, reg); }
 
-  void SmiUntag(Register reg) {
-    sarq(reg, Immediate(kSmiTagSize));
-  }
+  void SmiUntag(Register reg) { sarq(reg, Immediate(kSmiTagSize)); }
 
   void BranchIfNotSmi(Register reg, Label* label) {
     testq(reg, Immediate(kSmiTagMask));
     j(NOT_ZERO, label);
   }
 
   void Align(int alignment, intptr_t offset);
   void Bind(Label* label);
   void Jump(Label* label) { jmp(label); }
 
   void Comment(const char* format, ...) PRINTF_ATTRIBUTE(2, 3);
   static bool EmittingComments();
 
   const Code::Comments& GetCodeComments() const;
 
   // Address of code at offset.
-  uword CodeAddress(intptr_t offset) {
-    return buffer_.Address(offset);
-  }
+  uword CodeAddress(intptr_t offset) { return buffer_.Address(offset); }
 
   intptr_t CodeSize() const { return buffer_.Size(); }
   intptr_t prologue_offset() const { return prologue_offset_; }
   bool has_single_entry_point() const { return has_single_entry_point_; }
 
   // Count the fixups that produce a pointer offset, without processing
   // the fixups.
-  intptr_t CountPointerOffsets() const {
-    return buffer_.CountPointerOffsets();
-  }
+  intptr_t CountPointerOffsets() const { return buffer_.CountPointerOffsets(); }
 
   const ZoneGrowableArray<intptr_t>& GetPointerOffsets() const {
     return buffer_.pointer_offsets();
   }
 
   ObjectPoolWrapper& object_pool_wrapper() { return object_pool_wrapper_; }
 
   RawObjectPool* MakeObjectPool() {
     return object_pool_wrapper_.MakeObjectPool();
   }
@@ skipping 43 matching lines @@
   // This code sets this up with the sequence:
   //   pushq rbp
   //   movq rbp, rsp
   //   pushq immediate(0)
   //   .....
   void EnterStubFrame();
   void LeaveStubFrame();
 
   void MonomorphicCheckedEntry();
 
-  void UpdateAllocationStats(intptr_t cid,
-                             Heap::Space space);
+  void UpdateAllocationStats(intptr_t cid, Heap::Space space);
 
   void UpdateAllocationStatsWithSize(intptr_t cid,
                                      Register size_reg,
                                      Heap::Space space);
   void UpdateAllocationStatsWithSize(intptr_t cid,
                                      intptr_t instance_size,
                                      Heap::Space space);
 
   // If allocation tracing for |cid| is enabled, will jump to |trace| label,
   // which will allocate in the runtime where tracing occurs.
-  void MaybeTraceAllocation(intptr_t cid,
-                            Label* trace,
-                            bool near_jump);
+  void MaybeTraceAllocation(intptr_t cid, Label* trace, bool near_jump);
 
   // Inlined allocation of an instance of class 'cls', code has no runtime
   // calls. Jump to 'failure' if the instance cannot be allocated here.
   // Allocated instance is returned in 'instance_reg'.
   // Only the tags field of the object is initialized.
   void TryAllocate(const Class& cls,
                    Label* failure,
                    bool near_jump,
                    Register instance_reg,
                    Register temp);
@@ skipping 42 matching lines @@
   AssemblerBuffer buffer_;
 
   ObjectPoolWrapper object_pool_wrapper_;
 
   intptr_t prologue_offset_;
   bool has_single_entry_point_;
 
   class CodeComment : public ZoneAllocated {
    public:
     CodeComment(intptr_t pc_offset, const String& comment)
-        : pc_offset_(pc_offset), comment_(comment) { }
+        : pc_offset_(pc_offset), comment_(comment) {}
 
     intptr_t pc_offset() const { return pc_offset_; }
     const String& comment() const { return comment_; }
 
    private:
     intptr_t pc_offset_;
     const String& comment_;
 
     DISALLOW_COPY_AND_ASSIGN(CodeComment);
   };
@@ skipping 96 matching lines @@
 
 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) {
+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) {
+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_