--- a/js/src/asmjs/WasmIonCompile.cpp
+++ b/js/src/asmjs/WasmIonCompile.cpp
@@ -1135,27 +1135,27 @@ class FunctionCompiler
         return curBlock_ == nullptr;
     }
 
     void returnExpr(MDefinition* expr)
     {
         if (inDeadCode())
             return;
 
-        MAsmJSReturn* ins = MAsmJSReturn::New(alloc(), expr, tlsPointer_);
+        MWasmReturn* ins = MWasmReturn::New(alloc(), expr, tlsPointer_);
         curBlock_->end(ins);
         curBlock_ = nullptr;
     }
 
     void returnVoid()
     {
         if (inDeadCode())
             return;
 
-        MAsmJSVoidReturn* ins = MAsmJSVoidReturn::New(alloc(), tlsPointer_);
+        MWasmReturnVoid* ins = MWasmReturnVoid::New(alloc(), tlsPointer_);
         curBlock_->end(ins);
         curBlock_ = nullptr;
     }
 
     void unreachableTrap()
     {
         if (inDeadCode())
             return;

--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -11421,33 +11421,33 @@ CodeGenerator::visitAsmJSParameter(LAsmJ
 }
 
 void
 CodeGenerator::visitAsmJSParameterI64(LAsmJSParameterI64* lir)
 {
 }
 
 void
-CodeGenerator::visitAsmJSReturn(LAsmJSReturn* lir)
+CodeGenerator::visitWasmReturn(LWasmReturn* lir)
 {
     // Don't emit a jump to the return label if this is the last block.
     if (current->mir() != *gen->graph().poBegin())
         masm.jump(&returnLabel_);
 }
 
 void
-CodeGenerator::visitAsmJSReturnI64(LAsmJSReturnI64* lir)
+CodeGenerator::visitWasmReturnI64(LWasmReturnI64* lir)
 {
     // Don't emit a jump to the return label if this is the last block.
     if (current->mir() != *gen->graph().poBegin())
         masm.jump(&returnLabel_);
 }
 
 void
-CodeGenerator::visitAsmJSVoidReturn(LAsmJSVoidReturn* lir)
+CodeGenerator::visitWasmReturnVoid(LWasmReturnVoid* lir)
 {
     // Don't emit a jump to the return label if this is the last block.
     if (current->mir() != *gen->graph().poBegin())
         masm.jump(&returnLabel_);
 }
 
 void
 CodeGenerator::emitAssertRangeI(const Range* r, Register input)

--- a/js/src/jit/CodeGenerator.h
+++ b/js/src/jit/CodeGenerator.h
@@ -366,19 +366,19 @@ class CodeGenerator final : public CodeG
     void visitOutOfLineIsCallable(OutOfLineIsCallable* ool);
     void visitIsConstructor(LIsConstructor* lir);
     void visitOutOfLineIsConstructor(OutOfLineIsConstructor* ool);
     void visitIsObject(LIsObject* lir);
     void visitIsObjectAndBranch(LIsObjectAndBranch* lir);
     void visitHasClass(LHasClass* lir);
     void visitAsmJSParameter(LAsmJSParameter* lir);
     void visitAsmJSParameterI64(LAsmJSParameterI64* lir);
-    void visitAsmJSReturn(LAsmJSReturn* ret);
-    void visitAsmJSReturnI64(LAsmJSReturnI64* ret);
-    void visitAsmJSVoidReturn(LAsmJSVoidReturn* ret);
+    void visitWasmReturn(LWasmReturn* ret);
+    void visitWasmReturnI64(LWasmReturnI64* ret);
+    void visitWasmReturnVoid(LWasmReturnVoid* ret);
     void visitLexicalCheck(LLexicalCheck* ins);
     void visitThrowRuntimeLexicalError(LThrowRuntimeLexicalError* ins);
     void visitGlobalNameConflictsCheck(LGlobalNameConflictsCheck* ins);
     void visitDebugger(LDebugger* ins);
     void visitNewTarget(LNewTarget* ins);
     void visitArrowNewTarget(LArrowNewTarget* ins);
     void visitCheckReturn(LCheckReturn* ins);
     void visitCheckIsObj(LCheckIsObj* ins);

--- a/js/src/jit/Lowering.cpp
+++ b/js/src/jit/Lowering.cpp
@@ -4219,32 +4219,32 @@ LIRGenerator::visitAsmJSParameter(MAsmJS
         );
     } else {
         MOZ_ASSERT(IsNumberType(ins->type()) || IsSimdType(ins->type()));
         defineFixed(new(alloc()) LAsmJSParameter, ins, LArgument(abi.offsetFromArgBase()));
     }
 }
 
 void
-LIRGenerator::visitAsmJSReturn(MAsmJSReturn* ins)
+LIRGenerator::visitWasmReturn(MWasmReturn* ins)
 {
     MDefinition* rval = ins->getOperand(0);
 
     if (rval->type() == MIRType::Int64) {
-        LAsmJSReturnI64* lir = new(alloc()) LAsmJSReturnI64(useInt64Fixed(rval, ReturnReg64));
+        LWasmReturnI64* lir = new(alloc()) LWasmReturnI64(useInt64Fixed(rval, ReturnReg64));
 
         // Preserve the TLS pointer we were passed in `WasmTlsReg`.
         MDefinition* tlsPtr = ins->getOperand(1);
         lir->setOperand(INT64_PIECES, useFixed(tlsPtr, WasmTlsReg));
 
         add(lir);
         return;
     }
 
-    LAsmJSReturn* lir = new(alloc()) LAsmJSReturn;
+    LWasmReturn* lir = new(alloc()) LWasmReturn;
     if (rval->type() == MIRType::Float32)
         lir->setOperand(0, useFixed(rval, ReturnFloat32Reg));
     else if (rval->type() == MIRType::Double)
         lir->setOperand(0, useFixed(rval, ReturnDoubleReg));
     else if (IsSimdType(rval->type()))
         lir->setOperand(0, useFixed(rval, ReturnSimd128Reg));
     else if (rval->type() == MIRType::Int32)
         lir->setOperand(0, useFixed(rval, ReturnReg));
@@ -4254,19 +4254,19 @@ LIRGenerator::visitAsmJSReturn(MAsmJSRet
     // Preserve the TLS pointer we were passed in `WasmTlsReg`.
     MDefinition* tlsPtr = ins->getOperand(1);
     lir->setOperand(1, useFixed(tlsPtr, WasmTlsReg));
 
     add(lir);
 }
 
 void
-LIRGenerator::visitAsmJSVoidReturn(MAsmJSVoidReturn* ins)
-{
-    auto* lir = new(alloc()) LAsmJSVoidReturn;
+LIRGenerator::visitWasmReturnVoid(MWasmReturnVoid* ins)
+{
+    auto* lir = new(alloc()) LWasmReturnVoid;
 
     // Preserve the TLS pointer we were passed in `WasmTlsReg`.
     MDefinition* tlsPtr = ins->getOperand(0);
     lir->setOperand(0, useFixed(tlsPtr, WasmTlsReg));
 
     add(lir);
 }
 

--- a/js/src/jit/Lowering.h
+++ b/js/src/jit/Lowering.h
@@ -287,18 +287,18 @@ class LIRGenerator : public LIRGenerator
     void visitIsConstructor(MIsConstructor* ins);
     void visitIsObject(MIsObject* ins);
     void visitHasClass(MHasClass* ins);
     void visitWasmAddOffset(MWasmAddOffset* ins);
     void visitWasmBoundsCheck(MWasmBoundsCheck* ins);
     void visitWasmLoadGlobalVar(MWasmLoadGlobalVar* ins);
     void visitWasmStoreGlobalVar(MWasmStoreGlobalVar* ins);
     void visitAsmJSParameter(MAsmJSParameter* ins);
-    void visitAsmJSReturn(MAsmJSReturn* ins);
-    void visitAsmJSVoidReturn(MAsmJSVoidReturn* ins);
+    void visitWasmReturn(MWasmReturn* ins);
+    void visitWasmReturnVoid(MWasmReturnVoid* ins);
     void visitAsmJSPassStackArg(MAsmJSPassStackArg* ins);
     void visitWasmCall(MWasmCall* ins);
     void visitSetDOMProperty(MSetDOMProperty* ins);
     void visitGetDOMProperty(MGetDOMProperty* ins);
     void visitGetDOMMember(MGetDOMMember* ins);
     void visitRecompileCheck(MRecompileCheck* ins);
     void visitSimdBox(MSimdBox* ins);
     void visitSimdUnbox(MSimdUnbox* ins);

--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -13900,40 +13900,40 @@ class MAsmJSParameter : public MNullaryI
 
   public:
     INSTRUCTION_HEADER(AsmJSParameter)
     TRIVIAL_NEW_WRAPPERS
 
     ABIArg abi() const { return abi_; }
 };
 
-class MAsmJSReturn
+class MWasmReturn
   : public MAryControlInstruction<2, 0>,
     public NoTypePolicy::Data
 {
-    explicit MAsmJSReturn(MDefinition* ins, MDefinition* tlsPtr) {
+    explicit MWasmReturn(MDefinition* ins, MDefinition* tlsPtr) {
         initOperand(0, ins);
         initOperand(1, tlsPtr);
     }
 
   public:
-    INSTRUCTION_HEADER(AsmJSReturn)
-    TRIVIAL_NEW_WRAPPERS
-};
-
-class MAsmJSVoidReturn
+    INSTRUCTION_HEADER(WasmReturn)
+    TRIVIAL_NEW_WRAPPERS
+};
+
+class MWasmReturnVoid
   : public MAryControlInstruction<1, 0>,
     public NoTypePolicy::Data
 {
-    explicit MAsmJSVoidReturn(MDefinition* tlsPtr) {
+    explicit MWasmReturnVoid(MDefinition* tlsPtr) {
         initOperand(0, tlsPtr);
     }
 
   public:
-    INSTRUCTION_HEADER(AsmJSVoidReturn)
+    INSTRUCTION_HEADER(WasmReturnVoid)
     TRIVIAL_NEW_WRAPPERS
 };
 
 class MAsmJSPassStackArg
   : public MUnaryInstruction,
     public NoTypePolicy::Data
 {
     MAsmJSPassStackArg(uint32_t spOffset, MDefinition* ins)

--- a/js/src/jit/MOpcodes.h
+++ b/js/src/jit/MOpcodes.h
@@ -280,19 +280,19 @@ namespace jit {
     _(WasmTruncateToInt32)                                                  \
     _(AsmJSNeg)                                                             \
     _(WasmUnsignedToDouble)                                                 \
     _(WasmUnsignedToFloat32)                                                \
     _(AsmJSLoadHeap)                                                        \
     _(AsmJSStoreHeap)                                                       \
     _(WasmLoadGlobalVar)                                                    \
     _(WasmStoreGlobalVar)                                                   \
-    _(AsmJSReturn)                                                          \
+    _(WasmReturn)                                                           \
+    _(WasmReturnVoid)                                                       \
     _(AsmJSParameter)                                                       \
-    _(AsmJSVoidReturn)                                                      \
     _(AsmJSPassStackArg)                                                    \
     _(WasmCall)                                                             \
     _(WasmSelect)                                                           \
     _(WasmReinterpret)                                                      \
     _(Rotate)                                                               \
     _(NewDerivedTypedObject)                                                \
     _(RecompileCheck)                                                       \
     _(AsmJSCompareExchangeHeap)                                             \

--- a/js/src/jit/shared/LIR-shared.h
+++ b/js/src/jit/shared/LIR-shared.h
@@ -8369,36 +8369,36 @@ class LAsmJSParameter : public LInstruct
 };
 
 class LAsmJSParameterI64 : public LInstructionHelper<INT64_PIECES, 0, 0>
 {
   public:
     LIR_HEADER(AsmJSParameterI64);
 };
 
-class LAsmJSReturn : public LInstructionHelper<0, 2, 0>
-{
-  public:
-    LIR_HEADER(AsmJSReturn);
-};
-
-class LAsmJSReturnI64 : public LInstructionHelper<0, INT64_PIECES + 1, 0>
-{
-  public:
-    LIR_HEADER(AsmJSReturnI64)
-
-    explicit LAsmJSReturnI64(const LInt64Allocation& input) {
+class LWasmReturn : public LInstructionHelper<0, 2, 0>
+{
+  public:
+    LIR_HEADER(WasmReturn);
+};
+
+class LWasmReturnI64 : public LInstructionHelper<0, INT64_PIECES + 1, 0>
+{
+  public:
+    LIR_HEADER(WasmReturnI64)
+
+    explicit LWasmReturnI64(const LInt64Allocation& input) {
         setInt64Operand(0, input);
     }
 };
 
-class LAsmJSVoidReturn : public LInstructionHelper<0, 1, 0>
-{
-  public:
-    LIR_HEADER(AsmJSVoidReturn);
+class LWasmReturnVoid : public LInstructionHelper<0, 1, 0>
+{
+  public:
+    LIR_HEADER(WasmReturnVoid);
 };
 
 class LAsmJSPassStackArg : public LInstructionHelper<0, 1, 0>
 {
   public:
     LIR_HEADER(AsmJSPassStackArg);
     explicit LAsmJSPassStackArg(const LAllocation& arg) {
         setOperand(0, arg);

--- a/js/src/jit/shared/LOpcodes-shared.h
+++ b/js/src/jit/shared/LOpcodes-shared.h
@@ -400,19 +400,19 @@
     _(WasmLoadGlobalVar)            \
     _(WasmLoadGlobalVarI64)         \
     _(WasmStoreGlobalVar)           \
     _(WasmStoreGlobalVarI64)        \
     _(AsmJSLoadHeap)                \
     _(AsmJSStoreHeap)               \
     _(AsmJSParameter)               \
     _(AsmJSParameterI64)            \
-    _(AsmJSReturn)                  \
-    _(AsmJSReturnI64)               \
-    _(AsmJSVoidReturn)              \
+    _(WasmReturn)                   \
+    _(WasmReturnI64)                \
+    _(WasmReturnVoid)               \
     _(AsmJSPassStackArg)            \
     _(AsmJSPassStackArgI64)         \
     _(WasmCall)                     \
     _(WasmCallI64)                  \
     _(AsmJSCompareExchangeHeap)     \
     _(AsmJSAtomicExchangeHeap)      \
     _(AsmJSAtomicBinopHeap)         \
     _(AsmJSAtomicBinopHeapForEffect)\