--- a/js/src/jit/x64/Assembler-x64.h
+++ b/js/src/jit/x64/Assembler-x64.h
@@ -301,16 +301,17 @@ class Assembler : public AssemblerX86Sha
   //    +1 byte for mod r/m
   //    +4 bytes for rip-relative offset (2)
   //    +2 bytes for ud2 instruction
   //    +8 bytes for 64-bit address
   //
   static const uint32_t SizeOfExtendedJump = 1 + 1 + 4 + 2 + 8;
   static const uint32_t SizeOfJumpTableEntry = 16;
 
+  Vector<RelativePatch, 8, SystemAllocPolicy> jumps_;
   uint32_t extendedJumpTable_;
 
   static JitCode* CodeFromJump(JitCode* code, uint8_t* jump);
 
  private:
   void addPendingJump(JmpSrc src, ImmPtr target, RelocationKind reloc);
 
  public:
@@ -328,16 +329,25 @@ class Assembler : public AssemblerX86Sha
   // The buffer is about to be linked, make sure any constant pools or excess
   // bookkeeping has been flushed to the instruction stream.
   void finish();
 
   // Copy the assembly code to the given buffer, and perform any pending
   // relocations relying on the target address.
   void executableCopy(uint8_t* buffer);
 
+  void assertNoGCThings() const {
+#ifdef DEBUG
+    MOZ_ASSERT(dataRelocations_.length() == 0);
+    for (auto& j : jumps_) {
+      MOZ_ASSERT(j.kind == RelocationKind::HARDCODED);
+    }
+#endif
+  }
+
   // Actual assembly emitting functions.
 
   void push(const ImmGCPtr ptr) {
     movq(ptr, ScratchReg);
     push(ScratchReg);
   }
   void push(const ImmWord ptr) {
     // We often end up with ImmWords that actually fit into int32.

--- a/js/src/jit/x86-shared/Assembler-x86-shared.h
+++ b/js/src/jit/x86-shared/Assembler-x86-shared.h
@@ -272,17 +272,16 @@ class AssemblerX86Shared : public Assemb
     int32_t offset;
     void* target;
     RelocationKind kind;
 
     RelativePatch(int32_t offset, void* target, RelocationKind kind)
         : offset(offset), target(target), kind(kind) {}
   };
 
-  Vector<RelativePatch, 8, SystemAllocPolicy> jumps_;
   CompactBufferWriter jumpRelocations_;
   CompactBufferWriter dataRelocations_;
 
   void writeDataRelocation(ImmGCPtr ptr) {
     // Raw GC pointer relocations and Value relocations both end up in
     // Assembler::TraceDataRelocations.
     if (ptr.value) {
       if (gc::IsInsideNursery(ptr.value)) {
@@ -414,25 +413,16 @@ class AssemblerX86Shared : public Assemb
   // Use NaNCondFromDoubleCondition to determine what else is needed.
   static inline Condition ConditionFromDoubleCondition(DoubleCondition cond) {
     return static_cast<Condition>(cond & ~DoubleConditionBits);
   }
 
   static void TraceDataRelocations(JSTracer* trc, JitCode* code,
                                    CompactBufferReader& reader);
 
-  void assertNoGCThings() const {
-#ifdef DEBUG
-    MOZ_ASSERT(dataRelocations_.length() == 0);
-    for (auto& j : jumps_) {
-      MOZ_ASSERT(j.kind == RelocationKind::HARDCODED);
-    }
-#endif
-  }
-
   void setUnlimitedBuffer() {
     // No-op on this platform
   }
   bool oom() const {
     return AssemblerShared::oom() || masm.oom() || jumpRelocations_.oom() ||
            dataRelocations_.oom();
   }
   bool reserve(size_t size) { return masm.reserve(size); }

--- a/js/src/jit/x86/Assembler-x86.h
+++ b/js/src/jit/x86/Assembler-x86.h
@@ -224,16 +224,18 @@ static inline Operand HighWord(const Ope
   }
 }
 
 // Return operand from a JS -> JS call.
 static constexpr ValueOperand JSReturnOperand{JSReturnReg_Type,
                                               JSReturnReg_Data};
 
 class Assembler : public AssemblerX86Shared {
+  Vector<RelativePatch, 8, SystemAllocPolicy> jumps_;
+
   void addPendingJump(JmpSrc src, ImmPtr target, RelocationKind kind) {
     enoughMemory_ &=
         jumps_.append(RelativePatch(src.offset(), target.value, kind));
     if (kind == RelocationKind::JITCODE) {
       jumpRelocations_.writeUnsigned(src.offset());
     }
   }
 
@@ -251,16 +253,25 @@ class Assembler : public AssemblerX86Sha
 
   static void TraceJumpRelocations(JSTracer* trc, JitCode* code,
                                    CompactBufferReader& reader);
 
   // Copy the assembly code to the given buffer, and perform any pending
   // relocations relying on the target address.
   void executableCopy(uint8_t* buffer);
 
+  void assertNoGCThings() const {
+#ifdef DEBUG
+    MOZ_ASSERT(dataRelocations_.length() == 0);
+    for (auto& j : jumps_) {
+      MOZ_ASSERT(j.kind == RelocationKind::HARDCODED);
+    }
+#endif
+  }
+
   // Actual assembly emitting functions.
 
   void push(ImmGCPtr ptr) {
     masm.push_i32(int32_t(ptr.value));
     writeDataRelocation(ptr);
   }
   void push(const ImmWord imm) { push(Imm32(imm.value)); }
   void push(const ImmPtr imm) { push(ImmWord(uintptr_t(imm.value))); }