Bug 1498618 - Never apply clang-format on code in {{{ check_macroassembler_style r=nbp
authorSylvestre Ledru <sledru@mozilla.com>
Mon, 15 Oct 2018 10:02:00 +0000
changeset 489785 7127bf67c3b90bb70473774659a4cbad492dafe7
parent 489784 dc75dad8f69b572650ddb2c4a0ea06661135837f
child 489786 b032c73f6f69d6e01fd86125ec1ce183061bdb78
push id247
push userfmarier@mozilla.com
push dateSat, 27 Oct 2018 01:06:44 +0000
reviewersnbp
bugs1498618
milestone64.0a1
Bug 1498618 - Never apply clang-format on code in {{{ check_macroassembler_style r=nbp Differential Revision: https://phabricator.services.mozilla.com/D8571
js/src/jit/MacroAssembler-inl.h
js/src/jit/MacroAssembler.cpp
js/src/jit/MacroAssembler.h
js/src/jit/arm/MacroAssembler-arm-inl.h
js/src/jit/arm/MacroAssembler-arm.cpp
js/src/jit/arm64/MacroAssembler-arm64-inl.h
js/src/jit/arm64/MacroAssembler-arm64.cpp
js/src/jit/mips-shared/MacroAssembler-mips-shared-inl.h
js/src/jit/mips-shared/MacroAssembler-mips-shared.cpp
js/src/jit/mips32/MacroAssembler-mips32-inl.h
js/src/jit/mips32/MacroAssembler-mips32.cpp
js/src/jit/mips64/MacroAssembler-mips64-inl.h
js/src/jit/mips64/MacroAssembler-mips64.cpp
js/src/jit/x64/MacroAssembler-x64-inl.h
js/src/jit/x64/MacroAssembler-x64.cpp
js/src/jit/x86-shared/MacroAssembler-x86-shared-inl.h
js/src/jit/x86-shared/MacroAssembler-x86-shared.cpp
js/src/jit/x86/MacroAssembler-x86-inl.h
js/src/jit/x86/MacroAssembler-x86.cpp
--- a/js/src/jit/MacroAssembler-inl.h
+++ b/js/src/jit/MacroAssembler-inl.h
@@ -28,16 +28,17 @@
 # error "Unknown architecture!"
 #endif
 
 #include "wasm/WasmBuiltins.h"
 
 namespace js {
 namespace jit {
 
+// clang-format off
 //{{{ check_macroassembler_style
 // ===============================================================
 // Stack manipulation functions.
 
 CodeOffset
 MacroAssembler::PushWithPatch(ImmWord word)
 {
     framePushed_ += sizeof(word.value);
@@ -794,16 +795,17 @@ MacroAssembler::storeFloat32(FloatRegist
     canonicalizeFloatIfDeterministic(src);
     storeUncanonicalizedFloat32(src, dest);
 }
 
 template void MacroAssembler::storeFloat32(FloatRegister src, const Address& dest);
 template void MacroAssembler::storeFloat32(FloatRegister src, const BaseIndex& dest);
 
 //}}} check_macroassembler_style
+// clang-format on
 // ===============================================================
 
 #ifndef JS_CODEGEN_ARM64
 
 template <typename T>
 void
 MacroAssembler::branchTestStackPtr(Condition cond, T t, Label* label)
 {
--- a/js/src/jit/MacroAssembler.cpp
+++ b/js/src/jit/MacroAssembler.cpp
@@ -2968,16 +2968,17 @@ MacroAssembler::icBuildOOLFakeExitFrame(
 #ifndef JS_CODEGEN_ARM64
 void
 MacroAssembler::subFromStackPtr(Register reg)
 {
     subPtr(reg, getStackPointer());
 }
 #endif // JS_CODEGEN_ARM64
 
+// clang-format off
 //{{{ check_macroassembler_style
 // ===============================================================
 // Stack manipulation functions.
 
 void
 MacroAssembler::PushRegsInMask(LiveGeneralRegisterSet set)
 {
     PushRegsInMask(LiveRegisterSet(set.set(), FloatRegisterSet()));
@@ -3811,16 +3812,17 @@ MacroAssembler::boundsCheck32PowerOfTwo(
     // Note: it's fine to clobber the input register, as this is a no-op: it
     // only affects speculative execution.
     if (JitOptions.spectreIndexMasking) {
         and32(Imm32(length - 1), index);
     }
 }
 
 //}}} check_macroassembler_style
+// clang-format on
 
 void
 MacroAssembler::memoryBarrierBefore(const Synchronization& sync) {
     memoryBarrier(sync.barrierBefore);
 }
 
 void
 MacroAssembler::memoryBarrierAfter(const Synchronization& sync) {
--- a/js/src/jit/MacroAssembler.h
+++ b/js/src/jit/MacroAssembler.h
@@ -345,16 +345,17 @@ class MacroAssembler : public MacroAssem
     size_t instructionsSize() const {
         return size();
     }
 
 #ifdef JS_HAS_HIDDEN_SP
     void Push(RegisterOrSP reg);
 #endif
 
+    // clang-format off
     //{{{ check_macroassembler_decl_style
   public:
     // ===============================================================
     // MacroAssembler high-level usage.
 
     // Flushes the assembly buffer, on platforms that need it.
     void flush() PER_SHARED_ARCH;
 
@@ -2051,16 +2052,17 @@ class MacroAssembler : public MacroAssem
 
     // The length must be a power of two. Performs a bounds check and Spectre index
     // masking.
     void boundsCheck32PowerOfTwo(Register index, uint32_t length, Label* failure);
 
     void speculationBarrier() PER_SHARED_ARCH;
 
     //}}} check_macroassembler_decl_style
+    // clang-format on
   public:
 
     // Emits a test of a value against all types in a TypeSet. A scratch
     // register is required.
     template <typename Source>
     void guardTypeSet(const Source& address, const TypeSet* types, BarrierKind kind,
                       Register unboxScratch, Register objScratch, Register spectreRegToZero,
                       Label* miss);
@@ -2814,16 +2816,17 @@ class IonHeapMacroAssembler : public Mac
   public:
     IonHeapMacroAssembler()
       : MacroAssembler()
     {
         MOZ_ASSERT(CurrentThreadIsIonCompiling());
     }
 };
 
+// clang-format off
 //{{{ check_macroassembler_style
 inline uint32_t
 MacroAssembler::framePushed() const
 {
     return framePushed_;
 }
 
 inline void
@@ -2842,16 +2845,17 @@ MacroAssembler::adjustFrame(int32_t valu
 inline void
 MacroAssembler::implicitPop(uint32_t bytes)
 {
     MOZ_ASSERT(bytes % sizeof(intptr_t) == 0);
     MOZ_ASSERT(bytes <= INT32_MAX);
     adjustFrame(-int32_t(bytes));
 }
 //}}} check_macroassembler_style
+// clang-format on
 
 static inline Assembler::DoubleCondition
 JSOpToDoubleCondition(JSOp op)
 {
     switch (op) {
       case JSOP_EQ:
       case JSOP_STRICTEQ:
         return Assembler::DoubleEqual;
--- a/js/src/jit/arm/MacroAssembler-arm-inl.h
+++ b/js/src/jit/arm/MacroAssembler-arm-inl.h
@@ -7,16 +7,17 @@
 #ifndef jit_arm_MacroAssembler_arm_inl_h
 #define jit_arm_MacroAssembler_arm_inl_h
 
 #include "jit/arm/MacroAssembler-arm.h"
 
 namespace js {
 namespace jit {
 
+// clang-format off
 //{{{ check_macroassembler_style
 
 void
 MacroAssembler::move64(Register64 src, Register64 dest)
 {
     move32(src.low, dest.low);
     move32(src.high, dest.high);
 }
@@ -2329,16 +2330,17 @@ MacroAssembler::clampIntToUint8(Register
     // <0, then we want to clamp to 0, otherwise, we wish to clamp to 255
     ScratchRegisterScope scratch(*this);
     as_mov(scratch, asr(reg, 8), SetCC);
     ma_mov(Imm32(0xff), reg, NotEqual);
     ma_mov(Imm32(0), reg, Signed);
 }
 
 //}}} check_macroassembler_style
+// clang-format on
 // ===============================================================
 
 void
 MacroAssemblerARMCompat::incrementInt32Value(const Address& addr)
 {
     asMasm().add32(Imm32(1), ToPayload(addr));
 }
 
--- a/js/src/jit/arm/MacroAssembler-arm.cpp
+++ b/js/src/jit/arm/MacroAssembler-arm.cpp
@@ -4357,16 +4357,17 @@ void
 MacroAssembler::subFromStackPtr(Imm32 imm32)
 {
     ScratchRegisterScope scratch(*this);
     if (imm32.value) {
         ma_sub(imm32, sp, scratch);
     }
 }
 
+// clang-format off
 //{{{ check_macroassembler_style
 // ===============================================================
 // MacroAssembler high-level usage.
 
 void
 MacroAssembler::flush()
 {
     Assembler::flush();
@@ -6170,16 +6171,17 @@ void
 MacroAssembler::speculationBarrier()
 {
     // Spectre mitigation recommended by ARM for cases where csel/cmov cannot be
     // used.
     as_csdb();
 }
 
 //}}} check_macroassembler_style
+// clang-format on
 
 void
 MacroAssemblerARM::wasmTruncateToInt32(FloatRegister input, Register output, MIRType fromType,
                                        bool isUnsigned, bool isSaturating, Label* oolEntry)
 {
     ScratchDoubleScope scratchScope(asMasm());
     ScratchRegisterScope scratchReg(asMasm());
     FloatRegister scratch = scratchScope.uintOverlay();
--- a/js/src/jit/arm64/MacroAssembler-arm64-inl.h
+++ b/js/src/jit/arm64/MacroAssembler-arm64-inl.h
@@ -7,16 +7,17 @@
 #ifndef jit_arm64_MacroAssembler_arm64_inl_h
 #define jit_arm64_MacroAssembler_arm64_inl_h
 
 #include "jit/arm64/MacroAssembler-arm64.h"
 
 namespace js {
 namespace jit {
 
+// clang-format off
 //{{{ check_macroassembler_style
 
 void
 MacroAssembler::move64(Register64 src, Register64 dest)
 {
     Mov(ARMRegister(dest.reg, 64), ARMRegister(src.reg, 64));
 }
 
@@ -1976,16 +1977,17 @@ MacroAssembler::clampIntToUint8(Register
 
     Cmp(reg32, Operand(reg32, vixl::UXTB));
     Csel(reg32, reg32, vixl::wzr, Assembler::GreaterThanOrEqual);
     Mov(scratch32, Operand(0xff));
     Csel(reg32, reg32, scratch32, Assembler::LessThanOrEqual);
 }
 
 //}}} check_macroassembler_style
+// clang-format on
 // ===============================================================
 
 void
 MacroAssemblerCompat::addToStackPtr(Register src)
 {
     Add(GetStackPointer64(), GetStackPointer64(), ARMRegister(src, 64));
 }
 
--- a/js/src/jit/arm64/MacroAssembler-arm64.cpp
+++ b/js/src/jit/arm64/MacroAssembler-arm64.cpp
@@ -408,16 +408,17 @@ MacroAssembler::Push(RegisterOrSP reg)
     if (IsHiddenSP(reg)) {
         push(sp);
     } else {
         push(AsRegister(reg));
     }
     adjustFrame(sizeof(intptr_t));
 }
 
+// clang-format off
 //{{{ check_macroassembler_style
 // ===============================================================
 // MacroAssembler high-level usage.
 
 void
 MacroAssembler::flush()
 {
     Assembler::flush();
@@ -2019,11 +2020,12 @@ MacroAssembler::flexibleDivMod32(Registe
 void
 MacroAssembler::speculationBarrier()
 {
     // Conditional speculation barrier.
     csdb();
 }
 
 //}}} check_macroassembler_style
+// clang-format off
 
 } // namespace jit
 } // namespace js
--- a/js/src/jit/mips-shared/MacroAssembler-mips-shared-inl.h
+++ b/js/src/jit/mips-shared/MacroAssembler-mips-shared-inl.h
@@ -7,16 +7,17 @@
 #ifndef jit_mips_shared_MacroAssembler_mips_shared_inl_h
 #define jit_mips_shared_MacroAssembler_mips_shared_inl_h
 
 #include "jit/mips-shared/MacroAssembler-mips-shared.h"
 
 namespace js {
 namespace jit {
 
+// clang-format off
 //{{{ check_macroassembler_style
 
 void
 MacroAssembler::moveFloat32ToGPR(FloatRegister src, Register dest)
 {
     moveFromFloat32(src, dest);
 }
 
@@ -1105,14 +1106,15 @@ MacroAssembler::clampIntToUint8(Register
 
     // If reg is >= 255, then we want to clamp to 255.
     ma_li(SecondScratchReg, Imm32(255));
     as_slti(ScratchRegister, reg, 255);
     as_movz(reg, SecondScratchReg, ScratchRegister);
 }
 
 //}}} check_macroassembler_style
+// clang-format on
 // ===============================================================
 
 } // namespace jit
 } // namespace js
 
 #endif /* jit_mips_shared_MacroAssembler_mips_shared_inl_h */
--- a/js/src/jit/mips-shared/MacroAssembler-mips-shared.cpp
+++ b/js/src/jit/mips-shared/MacroAssembler-mips-shared.cpp
@@ -1434,16 +1434,17 @@ MacroAssemblerMIPSShared::asMasm()
 }
 
 const MacroAssembler&
 MacroAssemblerMIPSShared::asMasm() const
 {
     return *static_cast<const MacroAssembler*>(this);
 }
 
+// clang-format off
 //{{{ check_macroassembler_style
 // ===============================================================
 // MacroAssembler high-level usage.
 
 void
 MacroAssembler::flush()
 {
 }
@@ -2922,8 +2923,10 @@ MacroAssembler::flexibleDivMod32(Registe
 // ========================================================================
 // Spectre Mitigations.
 
 void
 MacroAssembler::speculationBarrier()
 {
     MOZ_CRASH();
 }
+//}}} check_macroassembler_style
+// clang-format on
--- a/js/src/jit/mips32/MacroAssembler-mips32-inl.h
+++ b/js/src/jit/mips32/MacroAssembler-mips32-inl.h
@@ -9,16 +9,17 @@
 
 #include "jit/mips32/MacroAssembler-mips32.h"
 
 #include "jit/mips-shared/MacroAssembler-mips-shared-inl.h"
 
 namespace js {
 namespace jit {
 
+// clang-format off
 //{{{ check_macroassembler_style
 
 void
 MacroAssembler::move64(Register64 src, Register64 dest)
 {
     move32(src.low, dest.low);
     move32(src.high, dest.high);
 }
@@ -1006,16 +1007,17 @@ MacroAssembler::branchTruncateFloat32May
     as_truncws(ScratchFloat32Reg, src);
     as_cfc1(ScratchRegister, Assembler::FCSR);
     moveFromFloat32(ScratchFloat32Reg, dest);
     ma_ext(ScratchRegister, ScratchRegister, Assembler::CauseV, 1);
     ma_b(ScratchRegister, Imm32(0), fail, Assembler::NotEqual);
 }
 
 //}}} check_macroassembler_style
+// clang-format on
 // ===============================================================
 
 void
 MacroAssemblerMIPSCompat::incrementInt32Value(const Address& addr)
 {
     asMasm().add32(Imm32(1), ToPayload(addr));
 }
 
--- a/js/src/jit/mips32/MacroAssembler-mips32.cpp
+++ b/js/src/jit/mips32/MacroAssembler-mips32.cpp
@@ -2104,16 +2104,17 @@ MacroAssemblerMIPSCompat::profilerExitFr
 void
 MacroAssembler::subFromStackPtr(Imm32 imm32)
 {
     if (imm32.value) {
         asMasm().subPtr(imm32, StackPointer);
     }
 }
 
+// clang-format on
 //{{{ check_macroassembler_style
 // ===============================================================
 // Stack manipulation functions.
 
 void
 MacroAssembler::PushRegsInMask(LiveRegisterSet set)
 {
     int32_t diffF = set.fpus().getPushSizeInBytes();
@@ -2962,8 +2963,9 @@ MacroAssembler::convertUInt64ToDouble(Re
     convertUInt32ToDouble(src.high, dest);
     loadConstantDouble(TO_DOUBLE_HIGH_SCALE, ScratchDoubleReg);
     mulDouble(ScratchDoubleReg, dest);
     convertUInt32ToDouble(src.low, ScratchDoubleReg);
     addDouble(ScratchDoubleReg, dest);
 }
 
 //}}} check_macroassembler_style
+// clang-format on
--- a/js/src/jit/mips64/MacroAssembler-mips64-inl.h
+++ b/js/src/jit/mips64/MacroAssembler-mips64-inl.h
@@ -9,16 +9,17 @@
 
 #include "jit/mips64/MacroAssembler-mips64.h"
 
 #include "jit/mips-shared/MacroAssembler-mips-shared-inl.h"
 
 namespace js {
 namespace jit {
 
+// clang-format off
 //{{{ check_macroassembler_style
 
 void
 MacroAssembler::move64(Register64 src, Register64 dest)
 {
     movePtr(src.reg, dest.reg);
 }
 
@@ -753,16 +754,17 @@ MacroAssembler::branchTruncateFloat32May
     moveFromDouble(ScratchDoubleReg, dest);
     ma_ext(ScratchRegister, ScratchRegister, Assembler::CauseV, 1);
     ma_b(ScratchRegister, Imm32(0), fail, Assembler::NotEqual);
 
     as_sll(dest, dest, 0);
 }
 
 //}}} check_macroassembler_style
+// clang-format on
 // ===============================================================
 
 // The specializations for cmpPtrSet are outside the braces because check_macroassembler_style can't yet
 // deal with specializations.
 
 template<>
 inline void
 MacroAssembler::cmpPtrSet(Assembler::Condition cond, Address lhs, ImmPtr rhs,
--- a/js/src/jit/mips64/MacroAssembler-mips64.cpp
+++ b/js/src/jit/mips64/MacroAssembler-mips64.cpp
@@ -1943,16 +1943,17 @@ MacroAssemblerMIPS64Compat::profilerExit
 void
 MacroAssembler::subFromStackPtr(Imm32 imm32)
 {
     if (imm32.value) {
         asMasm().subPtr(imm32, StackPointer);
     }
 }
 
+// clang-format off
 //{{{ check_macroassembler_style
 // ===============================================================
 // Stack manipulation functions.
 
 void
 MacroAssembler::PushRegsInMask(LiveRegisterSet set)
 {
     int32_t diff = set.gprs().size() * sizeof(intptr_t) +
@@ -2754,8 +2755,9 @@ MacroAssembler::convertUInt64ToFloat32(R
     bind(&positive);
     as_dmtc1(src, dest);
     as_cvtsl(dest, dest);
 
     bind(&done);
 }
 
 //}}} check_macroassembler_style
+// clang-format on
--- a/js/src/jit/x64/MacroAssembler-x64-inl.h
+++ b/js/src/jit/x64/MacroAssembler-x64-inl.h
@@ -9,16 +9,17 @@
 
 #include "jit/x64/MacroAssembler-x64.h"
 
 #include "jit/x86-shared/MacroAssembler-x86-shared-inl.h"
 
 namespace js {
 namespace jit {
 
+// clang-format off
 //{{{ check_macroassembler_style
 // ===============================================================
 
 void
 MacroAssembler::move64(Imm64 imm, Register64 dest)
 {
     movq(ImmWord(imm.value), dest.reg);
 }
@@ -959,16 +960,17 @@ MacroAssembler::truncateDoubleToUInt64(A
     loadPtr(dest, temp);
     or64(Imm64(0x8000000000000000), Register64(temp));
     storePtr(temp, dest);
 
     bind(&done);
 }
 
 //}}} check_macroassembler_style
+// clang-format on
 // ===============================================================
 
 void
 MacroAssemblerX64::incrementInt32Value(const Address& addr)
 {
     asMasm().addPtr(Imm32(1), addr);
 }
 
--- a/js/src/jit/x64/MacroAssembler-x64.cpp
+++ b/js/src/jit/x64/MacroAssembler-x64.cpp
@@ -298,16 +298,17 @@ MacroAssembler::subFromStackPtr(Imm32 im
             amountLeft -= fullPages * 4096;
             if (amountLeft) {
                 subq(Imm32(amountLeft), StackPointer);
             }
         }
     }
 }
 
+// clang-format off
 //{{{ check_macroassembler_style
 // ===============================================================
 // ABI function calls.
 
 void
 MacroAssembler::setupUnalignedABICall(Register scratch)
 {
     MOZ_ASSERT(!IsCompilingWasm(), "wasm should only use aligned ABI calls");
@@ -1033,8 +1034,9 @@ MacroAssembler::wasmAtomicEffectOp64(con
       case AtomicFetchAndOp: lock_andq(value.reg, Operand(mem)); break;
       case AtomicFetchOrOp:  lock_orq(value.reg, Operand(mem)); break;
       case AtomicFetchXorOp: lock_xorq(value.reg, Operand(mem)); break;
       default:               MOZ_CRASH();
     }
 }
 
 //}}} check_macroassembler_style
+// clang-format on
--- a/js/src/jit/x86-shared/MacroAssembler-x86-shared-inl.h
+++ b/js/src/jit/x86-shared/MacroAssembler-x86-shared-inl.h
@@ -7,16 +7,17 @@
 #ifndef jit_x86_shared_MacroAssembler_x86_shared_inl_h
 #define jit_x86_shared_MacroAssembler_x86_shared_inl_h
 
 #include "jit/x86-shared/MacroAssembler-x86-shared.h"
 
 namespace js {
 namespace jit {
 
+// clang-format off
 //{{{ check_macroassembler_style
 // ===============================================================
 // Move instructions
 
 void
 MacroAssembler::moveFloat32ToGPR(FloatRegister src, Register dest)
 {
     vmovd(src, dest);
@@ -1326,14 +1327,15 @@ MacroAssembler::clampIntToUint8(Register
         sarl(Imm32(31), reg);
         notl(reg);
         andl(Imm32(255), reg);
     }
     bind(&inRange);
 }
 
 //}}} check_macroassembler_style
+// clang-format on
 // ===============================================================
 
 } // namespace jit
 } // namespace js
 
 #endif /* jit_x86_shared_MacroAssembler_x86_shared_inl_h */
--- a/js/src/jit/x86-shared/MacroAssembler-x86-shared.cpp
+++ b/js/src/jit/x86-shared/MacroAssembler-x86-shared.cpp
@@ -265,16 +265,17 @@ MacroAssemblerX86Shared::minMaxFloat32(F
         vmaxss(second, first, first);
     } else {
         vminss(second, first, first);
     }
 
     bind(&done);
 }
 
+// clang-format off
 //{{{ check_macroassembler_style
 // ===============================================================
 // MacroAssembler high-level usage.
 
 void
 MacroAssembler::flush()
 {
 }
@@ -1668,8 +1669,9 @@ MacroAssembler::speculationBarrier()
 {
     // Spectre mitigation recommended by Intel and AMD suggest to use lfence as
     // a way to force all speculative execution of instructions to end.
     MOZ_ASSERT(HasSSE2());
     masm.lfence();
 }
 
 //}}} check_macroassembler_style
+// clang-format on
--- a/js/src/jit/x86/MacroAssembler-x86-inl.h
+++ b/js/src/jit/x86/MacroAssembler-x86-inl.h
@@ -9,16 +9,17 @@
 
 #include "jit/x86/MacroAssembler-x86.h"
 
 #include "jit/x86-shared/MacroAssembler-x86-shared-inl.h"
 
 namespace js {
 namespace jit {
 
+// clang-format off
 //{{{ check_macroassembler_style
 
 void
 MacroAssembler::move64(Imm64 imm, Register64 dest)
 {
     movl(Imm32(imm.value & 0xFFFFFFFFL), dest.low);
     movl(Imm32((imm.value >> 32) & 0xFFFFFFFFL), dest.high);
 }
@@ -1177,16 +1178,17 @@ MacroAssembler::truncateDoubleToUInt64(A
     load32(HighWord(dest), temp);
     orl(Imm32(0x80000000), temp);
     store32(temp, HighWord(dest));
 
     bind(&done);
 }
 
 //}}} check_macroassembler_style
+// clang-format on
 // ===============================================================
 
 // Note: this function clobbers the source register.
 void
 MacroAssemblerX86::convertUInt32ToDouble(Register src, FloatRegister dest)
 {
     // src is [0, 2^32-1]
     subl(Imm32(0x80000000), src);
--- a/js/src/jit/x86/MacroAssembler-x86.cpp
+++ b/js/src/jit/x86/MacroAssembler-x86.cpp
@@ -297,16 +297,17 @@ MacroAssembler::subFromStackPtr(Imm32 im
             }
 
             // Restore scratch register.
             movl(Operand(StackPointer, uint32_t(imm32.value) - 4), eax);
         }
     }
 }
 
+// clang-format off
 //{{{ check_macroassembler_style
 // ===============================================================
 // ABI function calls.
 
 void
 MacroAssembler::setupUnalignedABICall(Register scratch)
 {
     MOZ_ASSERT(!IsCompilingWasm(), "wasm should only use aligned ABI calls");
@@ -1269,9 +1270,10 @@ MacroAssembler::convertInt64ToFloat32(Re
     fild(Operand(esp, 0));
 
     fstp32(Operand(esp, 0));
     vmovss(Address(esp, 0), output);
     freeStack(2 * sizeof(intptr_t));
 }
 
 //}}} check_macroassembler_style
+// clang-format on