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 499897 7127bf67c3b90bb70473774659a4cbad492dafe7
parent 499896 dc75dad8f69b572650ddb2c4a0ea06661135837f
child 499898 b032c73f6f69d6e01fd86125ec1ce183061bdb78
push id1864
push userffxbld-merge
push dateMon, 03 Dec 2018 15:51:40 +0000
treeherdermozilla-release@f040763d99ad [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersnbp
bugs1498618
milestone64.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
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