--- a/js/src/wasm/WasmBaselineCompile.cpp
+++ b/js/src/wasm/WasmBaselineCompile.cpp
@@ -983,64 +983,64 @@ class BaseStackFrame
     uint32_t initialSize() const {
         MOZ_ASSERT(localSize_ != UINT32_MAX);
 
         return localSize_;
     }
 
     void zeroLocals(BaseRegAlloc& ra);
 
-    void loadLocalI32(RegI32 r, Local& local) {
-        masm.load32(Address(sp_, localOffset(local)), r);
+    void loadLocalI32(Local& src, RegI32 dest) {
+        masm.load32(Address(sp_, localOffset(src)), dest);
     }
 
 #ifndef JS_64BIT
-    void loadLocalI64Low(RegI32 r, Local& local) {
-        masm.load32(Address(sp_, localOffset(local) + INT64LOW_OFFSET), r);
-    }
-
-    void loadLocalI64High(RegI32 r, Local& local) {
-        masm.load32(Address(sp_, localOffset(local) + INT64HIGH_OFFSET), r);
-    }
-#endif
-
-    void loadLocalI64(RegI64 r, Local& local) {
-        masm.load64(Address(sp_, localOffset(local)), r);
-    }
-
-    void loadLocalPtr(Register r, Local& local) {
-        masm.loadPtr(Address(sp_, localOffset(local)), r);
-    }
-
-    void loadLocalF64(RegF64 r, Local& local) {
-        masm.loadDouble(Address(sp_, localOffset(local)), r);
-    }
-
-    void loadLocalF32(RegF32 r, Local& local) {
-        masm.loadFloat32(Address(sp_, localOffset(local)), r);
-    }
-
-    void storeLocalI32(RegI32 r, Local& local) {
-        masm.store32(r, Address(sp_, localOffset(local)));
-    }
-
-    void storeLocalI64(RegI64 r, Local& local) {
-        masm.store64(r, Address(sp_, localOffset(local)));
-    }
-
-    void storeLocalPtr(Register r, Local& local) {
-        masm.storePtr(r, Address(sp_, localOffset(local)));
-    }
-
-    void storeLocalF64(RegF64 r, Local& local) {
-        masm.storeDouble(r, Address(sp_, localOffset(local)));
-    }
-
-    void storeLocalF32(RegF32 r, Local& local) {
-        masm.storeFloat32(r, Address(sp_, localOffset(local)));
+    void loadLocalI64Low(Local& src, RegI32 dest) {
+        masm.load32(Address(sp_, localOffset(src) + INT64LOW_OFFSET), dest);
+    }
+
+    void loadLocalI64High(Local& src, RegI32 dest) {
+        masm.load32(Address(sp_, localOffset(src) + INT64HIGH_OFFSET), dest);
+    }
+#endif
+
+    void loadLocalI64(Local& src, RegI64 dest) {
+        masm.load64(Address(sp_, localOffset(src)), dest);
+    }
+
+    void loadLocalPtr(Local& src, Register dest) {
+        masm.loadPtr(Address(sp_, localOffset(src)), dest);
+    }
+
+    void loadLocalF64(Local& src, RegF64 dest) {
+        masm.loadDouble(Address(sp_, localOffset(src)), dest);
+    }
+
+    void loadLocalF32(Local& src, RegF32 dest) {
+        masm.loadFloat32(Address(sp_, localOffset(src)), dest);
+    }
+
+    void storeLocalI32(RegI32 src, Local& dest) {
+        masm.store32(src, Address(sp_, localOffset(dest)));
+    }
+
+    void storeLocalI64(RegI64 src, Local& dest) {
+        masm.store64(src, Address(sp_, localOffset(dest)));
+    }
+
+    void storeLocalPtr(Register src, Local& dest) {
+        masm.storePtr(src, Address(sp_, localOffset(dest)));
+    }
+
+    void storeLocalF64(RegF64 src, Local& dest) {
+        masm.storeDouble(src, Address(sp_, localOffset(dest)));
+    }
+
+    void storeLocalF32(RegF32 src, Local& dest) {
+        masm.storeFloat32(src, Address(sp_, localOffset(dest)));
     }
 
     //////////////////////////////////////////////////////////////////////
     //
     // The stack area - the dynamic part of the frame.
 
   private:
 
@@ -1173,47 +1173,47 @@ class BaseStackFrame
         if (stackHere > destStackHeight) {
             if (deadCode)
                 masm.setFramePushed(destStackHeight);
             else
                 masm.freeStack(stackHere - destStackHeight);
         }
     }
 
-    void loadStackI32(RegI32 r, int32_t offset) {
-        masm.load32(Address(sp_, stackOffset(offset)), r);
-    }
-
-    void loadStackI64(RegI64 r, int32_t offset) {
-        masm.load64(Address(sp_, stackOffset(offset)), r);
+    void loadStackI32(int32_t offset, RegI32 dest) {
+        masm.load32(Address(sp_, stackOffset(offset)), dest);
+    }
+
+    void loadStackI64(int32_t offset, RegI64 dest) {
+        masm.load64(Address(sp_, stackOffset(offset)), dest);
     }
 
 #ifndef JS_64BIT
-    void loadStackI64Low(RegI32 r, int32_t offset) {
-        masm.load32(Address(sp_, stackOffset(offset - INT64LOW_OFFSET)), r);
-    }
-
-    void loadStackI64High(RegI32 r, int32_t offset) {
-        masm.load32(Address(sp_, stackOffset(offset - INT64HIGH_OFFSET)), r);
+    void loadStackI64Low(int32_t offset, RegI32 dest) {
+        masm.load32(Address(sp_, stackOffset(offset - INT64LOW_OFFSET)), dest);
+    }
+
+    void loadStackI64High(int32_t offset, RegI32 dest) {
+        masm.load32(Address(sp_, stackOffset(offset - INT64HIGH_OFFSET)), dest);
     }
 #endif
 
     // Disambiguation: this loads a "Ptr" value from the stack, it does not load
     // the "StackPtr".
 
-    void loadStackPtr(Register r, int32_t offset) {
-        masm.loadPtr(Address(sp_, stackOffset(offset)), r);
-    }
-
-    void loadStackF64(RegF64 r, int32_t offset) {
-        masm.loadDouble(Address(sp_, stackOffset(offset)), r);
-    }
-
-    void loadStackF32(RegF32 r, int32_t offset) {
-        masm.loadFloat32(Address(sp_, stackOffset(offset)), r);
+    void loadStackPtr(int32_t offset, Register dest) {
+        masm.loadPtr(Address(sp_, stackOffset(offset)), dest);
+    }
+
+    void loadStackF64(int32_t offset, RegF64 dest) {
+        masm.loadDouble(Address(sp_, stackOffset(offset)), dest);
+    }
+
+    void loadStackF32(int32_t offset, RegF32 dest) {
+        masm.loadFloat32(Address(sp_, stackOffset(offset)), dest);
     }
 
     //////////////////////////////////////////////////////////////////////
     //
     // The argument area - for outgoing calls.
     //
     // We abstract these operations as an optimization: we can merge the freeing
     // of the argument area and dropping values off the stack after a call.  But
@@ -1867,73 +1867,73 @@ class BaseCompiler final : public BaseCo
         return stk_.back();
     }
 
     void loadConstI32(Stk& src, RegI32 dest) {
         moveImm32(src.i32val(), dest);
     }
 
     void loadMemI32(Stk& src, RegI32 dest) {
-        fr.loadStackI32(dest, src.offs());
+        fr.loadStackI32(src.offs(), dest);
     }
 
     void loadLocalI32(Stk& src, RegI32 dest) {
-        fr.loadLocalI32(dest, localFromSlot(src.slot(), MIRType::Int32));
+        fr.loadLocalI32(localFromSlot(src.slot(), MIRType::Int32), dest);
     }
 
     void loadRegisterI32(Stk& src, RegI32 dest) {
         moveI32(src.i32reg(), dest);
     }
 
     void loadConstI64(Stk &src, RegI64 dest) {
         moveImm64(src.i64val(), dest);
     }
 
     void loadMemI64(Stk& src, RegI64 dest) {
-        fr.loadStackI64(dest, src.offs());
+        fr.loadStackI64(src.offs(), dest);
     }
 
     void loadLocalI64(Stk& src, RegI64 dest) {
-        fr.loadLocalI64(dest, localFromSlot(src.slot(), MIRType::Int64));
+        fr.loadLocalI64(localFromSlot(src.slot(), MIRType::Int64), dest);
     }
 
     void loadRegisterI64(Stk& src, RegI64 dest) {
         moveI64(src.i64reg(), dest);
     }
 
     void loadConstF64(Stk &src, RegF64 dest) {
         double d;
         src.f64val(&d);
         masm.loadConstantDouble(d, dest);
     }
 
     void loadMemF64(Stk& src, RegF64 dest) {
-        fr.loadStackF64(dest, src.offs());
+        fr.loadStackF64(src.offs(), dest);
     }
 
     void loadLocalF64(Stk& src, RegF64 dest) {
-        fr.loadLocalF64(dest, localFromSlot(src.slot(), MIRType::Double));
+        fr.loadLocalF64(localFromSlot(src.slot(), MIRType::Double), dest);
     }
 
     void loadRegisterF64(Stk& src, RegF64 dest) {
         moveF64(src.f64reg(), dest);
     }
 
     void loadConstF32(Stk &src, RegF32 dest) {
         float f;
         src.f32val(&f);
         masm.loadConstantFloat32(f, dest);
     }
 
     void loadMemF32(Stk& src, RegF32 dest) {
-        fr.loadStackF32(dest, src.offs());
+        fr.loadStackF32(src.offs(), dest);
     }
 
     void loadLocalF32(Stk& src, RegF32 dest) {
-        fr.loadLocalF32(dest, localFromSlot(src.slot(), MIRType::Float32));
+        fr.loadLocalF32(localFromSlot(src.slot(), MIRType::Float32), dest);
     }
 
     void loadRegisterF32(Stk& src, RegF32 dest) {
         moveF32(src.f32reg(), dest);
     }
 
     void loadI32(Stk& src, RegI32 dest) {
         switch (src.kind()) {
@@ -1977,40 +1977,40 @@ class BaseCompiler final : public BaseCo
 
 #if !defined(JS_PUNBOX64)
     void loadI64Low(Stk& src, RegI32 dest) {
         switch (src.kind()) {
           case Stk::ConstI64:
             moveImm32(int32_t(src.i64val()), dest);
             break;
           case Stk::MemI64:
-            fr.loadStackI64Low(dest, src.offs());
+            fr.loadStackI64Low(src.offs(), dest);
             break;
           case Stk::LocalI64:
-            fr.loadLocalI64Low(dest, localFromSlot(src.slot(), MIRType::Int64));
+            fr.loadLocalI64Low(localFromSlot(src.slot(), MIRType::Int64), dest);
             break;
           case Stk::RegisterI64:
             moveI32(RegI32(src.i64reg().low), dest);
             break;
           case Stk::None:
           default:
             MOZ_CRASH("Compiler bug: Expected I64 on stack");
         }
     }
 
     void loadI64High(Stk& src, RegI32 dest) {
         switch (src.kind()) {
           case Stk::ConstI64:
             moveImm32(int32_t(src.i64val() >> 32), dest);
             break;
           case Stk::MemI64:
-            fr.loadStackI64High(dest, src.offs());
+            fr.loadStackI64High(src.offs(), dest);
             break;
           case Stk::LocalI64:
-            fr.loadLocalI64High(dest, localFromSlot(src.slot(), MIRType::Int64));
+            fr.loadLocalI64High(localFromSlot(src.slot(), MIRType::Int64), dest);
             break;
           case Stk::RegisterI64:
             moveI32(RegI32(src.i64reg().high), dest);
             break;
           case Stk::None:
           default:
             MOZ_CRASH("Compiler bug: Expected I64 on stack");
         }
@@ -2108,19 +2108,19 @@ class BaseCompiler final : public BaseCo
                 break;
               }
               case Stk::LocalI64: {
                 ScratchI32 scratch(*this);
 #ifdef JS_PUNBOX64
                 loadI64(v, fromI32(scratch));
                 uint32_t offs = fr.pushPtr(scratch);
 #else
-                fr.loadLocalI64High(scratch, localFromSlot(v.slot(), MIRType::Int64));
+                fr.loadLocalI64High(localFromSlot(v.slot(), MIRType::Int64), scratch);
                 fr.pushPtr(scratch);
-                fr.loadLocalI64Low(scratch, localFromSlot(v.slot(), MIRType::Int64));
+                fr.loadLocalI64Low(localFromSlot(v.slot(), MIRType::Int64), scratch);
                 uint32_t offs = fr.pushPtr(scratch);
 #endif
                 v.setOffs(Stk::MemI64, offs);
                 break;
               }
               case Stk::RegisterI64: {
 #ifdef JS_PUNBOX64
                 uint32_t offs = fr.pushPtr(v.i64reg().reg);