clang-format runtime/vm

runtime/vm/assembler_ia32.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_IA32_H_
 #define RUNTIME_VM_ASSEMBLER_IA32_H_
 
 #ifndef RUNTIME_VM_ASSEMBLER_H_
 #error Do not include assembler_ia32.h directly; use assembler.h instead.
 #endif
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/constants_ia32.h"
 
 namespace dart {
 
 // Forward declarations.
 class RuntimeEntry;
 class StubEntry;
 
 class Immediate : public ValueObject {
  public:
-  explicit Immediate(int32_t value) : value_(value) { }
+  explicit Immediate(int32_t value) : value_(value) {}
 
-  Immediate(const Immediate& other) : ValueObject(), value_(other.value_) { }
+  Immediate(const Immediate& other) : ValueObject(), value_(other.value_) {}
 
   int32_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_); }
 
  private:
   const int32_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 mod() const {
-    return (encoding_at(0) >> 6) & 3;
-  }
+  uint8_t mod() const { return (encoding_at(0) >> 6) & 3; }
 
-  Register rm() const {
-    return static_cast<Register>(encoding_at(0) & 7);
-  }
+  Register rm() const { return static_cast<Register>(encoding_at(0) & 7); }
 
   ScaleFactor scale() const {
     return static_cast<ScaleFactor>((encoding_at(1) >> 6) & 3);
   }
 
   Register index() const {
     return static_cast<Register>((encoding_at(1) >> 3) & 7);
   }
 
-  Register base() const {
-    return static_cast<Register>(encoding_at(1) & 7);
-  }
+  Register base() const { return static_cast<Register>(encoding_at(1) & 7); }
 
   int8_t disp8() const {
     ASSERT(length_ >= 2);
     return static_cast<int8_t>(encoding_[length_ - 1]);
   }
 
   int32_t disp32() const {
     ASSERT(length_ >= 5);
     return bit_copy<int32_t>(encoding_[length_ - 4]);
   }
@@ skipping 10 matching lines @@
 
   bool Equals(const Operand& other) const {
     if (length_ != other.length_) return false;
     for (uint8_t i = 0; i < length_; i++) {
       if (encoding_[i] != other.encoding_[i]) return false;
     }
     return true;
   }
 
  protected:
-  Operand() : length_(0) { }  // Needed by subclass Address.
+  Operand() : length_(0) {}  // Needed by subclass Address.
 
   void SetModRM(int mod, Register rm) {
     ASSERT((mod & ~3) == 0);
     encoding_[0] = (mod << 6) | rm;
     length_ = 1;
   }
 
   void SetSIB(ScaleFactor scale, Register index, Register base) {
     ASSERT(length_ == 1);
     ASSERT((scale & ~3) == 0);
@@ skipping 23 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 ((encoding_[0] & 0xF8) == 0xC0)  // Addressing mode is register only.
-        && ((encoding_[0] & 0x07) == reg);  // Register codes match.
+           && ((encoding_[0] & 0x07) == reg);  // Register codes match.
   }
 
   friend class Assembler;
 };
 
 
 class Address : public Operand {
  public:
   Address(Register base, int32_t disp) {
     if (disp == 0 && base != EBP) {
@@ skipping 32 matching lines @@
     } else {
       SetModRM(2, ESP);
       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 Absolute(const uword addr) {
     Address result;
     result.SetModRM(0, EBP);
     result.SetDisp32(addr);
     return result;
   }
 
  private:
-  Address() { }  // Needed by Address::Absolute.
+  Address() {}  // Needed by Address::Absolute.
 };
 
 
 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 68 matching lines @@
  public:
   explicit Assembler(bool use_far_branches = false)
       : buffer_(),
         prologue_offset_(-1),
         jit_cookie_(0),
         comments_(),
         code_(Code::ZoneHandle()) {
     // This mode is only needed and implemented for MIPS and ARM.
     ASSERT(!use_far_branches);
   }
-  ~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 167 matching lines @@
   void orpd(XmmRegister dst, XmmRegister src);
 
   void pextrd(Register dst, XmmRegister src, const Immediate& imm);
   void pmovsxdq(XmmRegister dst, XmmRegister src);
   void pcmpeqq(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 flds(const Address& src);
   void fstps(const Address& dst);
 
   void fldl(const Address& src);
   void fstpl(const Address& dst);
 
   void fnstcw(const Address& dst);
@@ skipping 111 matching lines @@
   void leave();
 
   void ret();
   void ret(const Immediate& imm);
 
   // '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 0xCCCCCCCC;
-  }
+  static uword GetBreakInstructionFiller() { return 0xCCCCCCCC; }
 
   void j(Condition condition, Label* label, bool near = kFarJump);
   void j(Condition condition, const ExternalLabel* label);
 
   void jmp(Register reg);
   void jmp(Label* label, bool near = kFarJump);
   void jmp(const ExternalLabel* label);
 
   void lock();
   void cmpxchgl(const Address& address, Register reg);
@@ skipping 20 matching lines @@
   void LoadObject(Register dst, const Object& object);
 
   // If 'object' is a large Smi, xor it with a per-assembler cookie value to
   // prevent user-controlled immediates from appearing in the code stream.
   void LoadObjectSafely(Register dst, const Object& object);
 
   void PushObject(const Object& object);
   void CompareObject(Register reg, const Object& object);
   void LoadDoubleConstant(XmmRegister dst, double 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 61 matching lines @@
                                            Register array,
                                            Register index);
 
   static Address VMTagAddress() {
     return Address(THR, Thread::vm_tag_offset());
   }
 
   /*
    * Misc. functionality
    */
-  void SmiTag(Register reg) {
-    addl(reg, reg);
-  }
+  void SmiTag(Register reg) { addl(reg, reg); }
 
-  void SmiUntag(Register reg) {
-    sarl(reg, Immediate(kSmiTagSize));
-  }
+  void SmiUntag(Register reg) { sarl(reg, Immediate(kSmiTagSize)); }
 
   void BranchIfNotSmi(Register reg, Label* label) {
     testl(reg, Immediate(kSmiTagMask));
     j(NOT_ZERO, label);
   }
 
   void Align(intptr_t alignment, intptr_t offset);
   void Bind(Label* label);
   void Jump(Label* label) { jmp(label); }
 
   // 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 true; }
 
   // 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 122 matching lines @@
     if (Utils::IsPowerOfTwo(value) || Utils::IsPowerOfTwo(value + 1)) {
       return true;
     }
 
     return false;
   }
   static bool IsSafe(const Object& object) {
     return !object.IsSmi() || IsSafeSmi(object);
   }
 
-  void set_code_object(const Code& code) {
-    code_ ^= code.raw();
-  }
+  void set_code_object(const Code& code) { code_ ^= code.raw(); }
 
   void PushCodeObject();
 
  private:
   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 64 matching lines @@
 }
 
 
 inline void Assembler::EmitOperandSizeOverride() {
   EmitUint8(0x66);
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_ASSEMBLER_IA32_H_