--- a/js/src/jit/BaselineCacheIRCompiler.cpp
+++ b/js/src/jit/BaselineCacheIRCompiler.cpp
@@ -2218,18 +2218,17 @@ js::jit::AttachBaselineCacheIRStub(JSCon
         return nullptr;
     }
 
     // Time to allocate and attach a new stub.
 
     size_t bytesNeeded = stubInfo->stubDataOffset() + stubInfo->stubDataSize();
 
     ICStubSpace* stubSpace = ICStubCompiler::StubSpaceForStub(stubInfo->makesGCCalls(),
-                                                              outerScript,
-                                                              ICStubEngine::Baseline);
+                                                              outerScript);
     void* newStubMem = stubSpace->alloc(bytesNeeded);
     if (!newStubMem)
         return nullptr;
 
     switch (stubKind) {
       case BaselineCacheIRStubKind::Regular: {
         auto newStub = new(newStubMem) ICCacheIR_Regular(code, stubInfo);
         writer.copyStubData(newStub->stubDataStart());

--- a/js/src/jit/BaselineDebugModeOSR.cpp
+++ b/js/src/jit/BaselineDebugModeOSR.cpp
@@ -777,18 +777,18 @@ CloneOldBaselineStub(JSContext* cx, Debu
     for (size_t i = 0; i < entryIndex; i++) {
         if (oldStub == entries[i].oldStub && entries[i].frameKind != ICEntry::Kind_Invalid) {
             MOZ_ASSERT(entries[i].newStub);
             entry.newStub = entries[i].newStub;
             return true;
         }
     }
 
-    ICStubSpace* stubSpace = ICStubCompiler::StubSpaceForStub(oldStub->makesGCCalls(), entry.script,
-                                                              ICStubCompiler::Engine::Baseline);
+    ICStubSpace* stubSpace = ICStubCompiler::StubSpaceForStub(oldStub->makesGCCalls(),
+                                                              entry.script);
 
     // Clone the existing stub into the recompiled IC.
     //
     // Note that since JitCode is a GC thing, cloning an ICStub with the same
     // JitCode ensures it won't be collected.
     switch (oldStub->kind()) {
 #define CASE_KIND(kindName)                                                  \
       case ICStub::kindName:                                                 \

--- a/js/src/jit/BaselineIC.cpp
+++ b/js/src/jit/BaselineIC.cpp
@@ -173,18 +173,16 @@ typedef bool (*DoWarmUpCounterFallbackOS
                                              ICWarmUpCounter_Fallback*, IonOsrTempData** infoPtr);
 static const VMFunction DoWarmUpCounterFallbackOSRInfo =
     FunctionInfo<DoWarmUpCounterFallbackOSRFn>(DoWarmUpCounterFallbackOSR,
                                                "DoWarmUpCounterFallbackOSR");
 
 bool
 ICWarmUpCounter_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     // Push a stub frame so that we can perform a non-tail call.
     enterStubFrame(masm, R1.scratchReg());
 
     Label noCompiledCode;
     // Call DoWarmUpCounterFallbackOSR to compile/check-for Ion-compiled function
     {
         // Push IonOsrTempData pointer storage
         masm.subFromStackPtr(Imm32(sizeof(void*)));
@@ -341,29 +339,25 @@ DoTypeUpdateFallback(JSContext* cx, Base
 typedef bool (*DoTypeUpdateFallbackFn)(JSContext*, BaselineFrame*, ICUpdatedStub*, HandleValue,
                                        HandleValue);
 const VMFunction DoTypeUpdateFallbackInfo =
     FunctionInfo<DoTypeUpdateFallbackFn>(DoTypeUpdateFallback, "DoTypeUpdateFallback", NonTailCall);
 
 bool
 ICTypeUpdate_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     // Just store false into R1.scratchReg() and return.
     masm.move32(Imm32(0), R1.scratchReg());
     EmitReturnFromIC(masm);
     return true;
 }
 
 bool
 ICTypeUpdate_PrimitiveSet::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     Label success;
     if ((flags_ & TypeToFlag(JSVAL_TYPE_INT32)) && !(flags_ & TypeToFlag(JSVAL_TYPE_DOUBLE)))
         masm.branchTestInt32(Assembler::Equal, R0, &success);
 
     if (flags_ & TypeToFlag(JSVAL_TYPE_DOUBLE))
         masm.branchTestNumber(Assembler::Equal, R0, &success);
 
     if (flags_ & TypeToFlag(JSVAL_TYPE_UNDEFINED))
@@ -392,18 +386,16 @@ ICTypeUpdate_PrimitiveSet::Compiler::gen
     EmitReturnFromIC(masm);
 
     return true;
 }
 
 bool
 ICTypeUpdate_SingleObject::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     Label failure;
     masm.branchTestObject(Assembler::NotEqual, R0, &failure);
 
     // Guard on the object's identity.
     Register obj = masm.extractObject(R0, R1.scratchReg());
     Address expectedObject(ICStubReg, ICTypeUpdate_SingleObject::offsetOfObject());
     masm.branchPtr(Assembler::NotEqual, expectedObject, obj, &failure);
 
@@ -414,18 +406,16 @@ ICTypeUpdate_SingleObject::Compiler::gen
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
     return true;
 }
 
 bool
 ICTypeUpdate_ObjectGroup::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     Label failure;
     masm.branchTestObject(Assembler::NotEqual, R0, &failure);
 
     // Guard on the object's ObjectGroup.
     Address expectedGroup(ICStubReg, ICTypeUpdate_ObjectGroup::offsetOfGroup());
     Register scratch1 = R1.scratchReg();
     masm.unboxObject(R0, scratch1);
     masm.branchTestObjGroup(Assembler::NotEqual, scratch1, expectedGroup, scratch1,
@@ -491,17 +481,16 @@ DoToBoolFallback(JSContext* cx, Baseline
 
 typedef bool (*pf)(JSContext*, BaselineFrame*, ICToBool_Fallback*, HandleValue,
                    MutableHandleValue);
 static const VMFunction fun = FunctionInfo<pf>(DoToBoolFallback, "DoToBoolFallback", TailCall);
 
 bool
 ICToBool_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
     MOZ_ASSERT(R0 == JSReturnOperand);
 
     // Restore the tail call register.
     EmitRestoreTailCallReg(masm);
 
     // Push arguments.
     masm.pushValue(R0);
     masm.push(ICStubReg);
@@ -526,17 +515,16 @@ DoToNumberFallback(JSContext* cx, ICToNu
 typedef bool (*DoToNumberFallbackFn)(JSContext*, ICToNumber_Fallback*, HandleValue, MutableHandleValue);
 static const VMFunction DoToNumberFallbackInfo =
     FunctionInfo<DoToNumberFallbackFn>(DoToNumberFallback, "DoToNumberFallback", TailCall,
                                        PopValues(1));
 
 bool
 ICToNumber_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
     MOZ_ASSERT(R0 == JSReturnOperand);
 
     // Restore the tail call register.
     EmitRestoreTailCallReg(masm);
 
     // Ensure stack is fully synced for the expression decompiler.
     masm.pushValue(R0);
 
@@ -740,17 +728,16 @@ typedef bool (*DoGetElemSuperFallbackFn)
                                          MutableHandleValue);
 static const VMFunction DoGetElemSuperFallbackInfo =
     FunctionInfo<DoGetElemSuperFallbackFn>(DoGetElemSuperFallback, "DoGetElemSuperFallback",
                                            TailCall, PopValues(3));
 
 bool
 ICGetElem_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
     MOZ_ASSERT(R0 == JSReturnOperand);
 
     // Restore the tail call register.
     EmitRestoreTailCallReg(masm);
 
     // Super property getters use a |this| that differs from base object
     if (hasReceiver_) {
         // State: receiver in R0, index in R1, obj on the stack
@@ -928,17 +915,16 @@ typedef bool (*DoSetElemFallbackFn)(JSCo
                                     HandleValue, HandleValue, HandleValue);
 static const VMFunction DoSetElemFallbackInfo =
     FunctionInfo<DoSetElemFallbackFn>(DoSetElemFallback, "DoSetElemFallback", TailCall,
                                       PopValues(2));
 
 bool
 ICSetElem_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
     MOZ_ASSERT(R0 == JSReturnOperand);
 
     EmitRestoreTailCallReg(masm);
 
     // State: R0: object, R1: index, stack: rhs.
     // For the decompiler, the stack has to be: object, index, rhs,
     // so we push the index, then overwrite the rhs Value with R0
     // and push the rhs value.
@@ -1119,18 +1105,16 @@ DoInFallback(JSContext* cx, BaselineFram
 typedef bool (*DoInFallbackFn)(JSContext*, BaselineFrame*, ICIn_Fallback*, HandleValue,
                                HandleValue, MutableHandleValue);
 static const VMFunction DoInFallbackInfo =
     FunctionInfo<DoInFallbackFn>(DoInFallback, "DoInFallback", TailCall, PopValues(2));
 
 bool
 ICIn_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     EmitRestoreTailCallReg(masm);
 
     // Sync for the decompiler.
     masm.pushValue(R0);
     masm.pushValue(R1);
 
     // Push arguments.
     masm.pushValue(R1);
@@ -1186,18 +1170,16 @@ DoHasOwnFallback(JSContext* cx, Baseline
 typedef bool (*DoHasOwnFallbackFn)(JSContext*, BaselineFrame*, ICHasOwn_Fallback*, HandleValue,
                                HandleValue, MutableHandleValue);
 static const VMFunction DoHasOwnFallbackInfo =
     FunctionInfo<DoHasOwnFallbackFn>(DoHasOwnFallback, "DoHasOwnFallback", TailCall, PopValues(2));
 
 bool
 ICHasOwn_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     EmitRestoreTailCallReg(masm);
 
     // Sync for the decompiler.
     masm.pushValue(R0);
     masm.pushValue(R1);
 
     // Push arguments.
     masm.pushValue(R1);
@@ -1275,17 +1257,16 @@ DoGetNameFallback(JSContext* cx, Baselin
 typedef bool (*DoGetNameFallbackFn)(JSContext*, BaselineFrame*, ICGetName_Fallback*,
                                     HandleObject, MutableHandleValue);
 static const VMFunction DoGetNameFallbackInfo =
     FunctionInfo<DoGetNameFallbackFn>(DoGetNameFallback, "DoGetNameFallback", TailCall);
 
 bool
 ICGetName_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
     MOZ_ASSERT(R0 == JSReturnOperand);
 
     EmitRestoreTailCallReg(masm);
 
     masm.push(R0.scratchReg());
     masm.push(ICStubReg);
     pushStubPayload(masm, R0.scratchReg());
 
@@ -1337,17 +1318,16 @@ DoBindNameFallback(JSContext* cx, Baseli
 typedef bool (*DoBindNameFallbackFn)(JSContext*, BaselineFrame*, ICBindName_Fallback*,
                                      HandleObject, MutableHandleValue);
 static const VMFunction DoBindNameFallbackInfo =
     FunctionInfo<DoBindNameFallbackFn>(DoBindNameFallback, "DoBindNameFallback", TailCall);
 
 bool
 ICBindName_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
     MOZ_ASSERT(R0 == JSReturnOperand);
 
     EmitRestoreTailCallReg(masm);
 
     masm.push(R0.scratchReg());
     masm.push(ICStubReg);
     pushStubPayload(masm, R0.scratchReg());
 
@@ -1410,18 +1390,16 @@ typedef bool (*DoGetIntrinsicFallbackFn)
                                          MutableHandleValue);
 static const VMFunction DoGetIntrinsicFallbackInfo =
     FunctionInfo<DoGetIntrinsicFallbackFn>(DoGetIntrinsicFallback, "DoGetIntrinsicFallback",
                                            TailCall);
 
 bool
 ICGetIntrinsic_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     EmitRestoreTailCallReg(masm);
 
     masm.push(ICStubReg);
     pushStubPayload(masm, R0.scratchReg());
 
     return tailCallVM(DoGetIntrinsicFallbackInfo, masm);
 }
 
@@ -1664,22 +1642,20 @@ ICGetProp_Fallback::Compiler::generateSt
     EmitEnterTypeMonitorIC(masm, ICTypeMonitor_Fallback::offsetOfFirstMonitorStub());
 
     return true;
 }
 
 void
 ICGetProp_Fallback::Compiler::postGenerateStubCode(MacroAssembler& masm, Handle<JitCode*> code)
 {
-    if (engine_ == Engine::Baseline) {
-        BailoutReturnStub kind = hasReceiver_ ? BailoutReturnStub::GetPropSuper
-                                              : BailoutReturnStub::GetProp;
-        void* address = code->raw() + bailoutReturnOffset_.offset();
-        cx->realm()->jitRealm()->initBailoutReturnAddr(address, getKey(), kind);
-    }
+    BailoutReturnStub kind = hasReceiver_ ? BailoutReturnStub::GetPropSuper
+                                            : BailoutReturnStub::GetProp;
+    void* address = code->raw() + bailoutReturnOffset_.offset();
+    cx->realm()->jitRealm()->initBailoutReturnAddr(address, getKey(), kind);
 }
 
 //
 // SetProp_Fallback
 //
 
 static bool
 DoSetPropFallback(JSContext* cx, BaselineFrame* frame, ICSetProp_Fallback* stub_, Value* stack,
@@ -1842,17 +1818,16 @@ typedef bool (*DoSetPropFallbackFn)(JSCo
                                     HandleValue, HandleValue);
 static const VMFunction DoSetPropFallbackInfo =
     FunctionInfo<DoSetPropFallbackFn>(DoSetPropFallback, "DoSetPropFallback", TailCall,
                                       PopValues(1));
 
 bool
 ICSetProp_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
     MOZ_ASSERT(R0 == JSReturnOperand);
 
     EmitRestoreTailCallReg(masm);
 
     // Ensure stack is fully synced for the expression decompiler.
     // Overwrite the RHS value on top of the stack with the object, then push
     // the RHS in R1 on top of that.
     masm.storeValue(R0, Address(masm.getStackPointer(), 0));
@@ -2937,18 +2912,16 @@ static const VMFunction DoCallFallbackIn
 typedef bool (*DoSpreadCallFallbackFn)(JSContext*, BaselineFrame*, ICCall_Fallback*,
                                        Value*, MutableHandleValue);
 static const VMFunction DoSpreadCallFallbackInfo =
     FunctionInfo<DoSpreadCallFallbackFn>(DoSpreadCallFallback, "DoSpreadCallFallback");
 
 bool
 ICCall_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     MOZ_ASSERT(R0 == JSReturnOperand);
 
     // Values are on the stack left-to-right. Calling convention wants them
     // right-to-left so duplicate them on the stack in reverse order.
     // |this| and callee are pushed last.
 
     AllocatableGeneralRegisterSet regs(availableGeneralRegs(0));
 
@@ -3065,18 +3038,16 @@ ICCall_Fallback::Compiler::postGenerateS
 typedef bool (*CreateThisFn)(JSContext* cx, HandleObject callee, HandleObject newTarget,
                              MutableHandleValue rval);
 static const VMFunction CreateThisInfoBaseline =
     FunctionInfo<CreateThisFn>(CreateThis, "CreateThis");
 
 bool
 ICCallScriptedCompiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     Label failure;
     AllocatableGeneralRegisterSet regs(availableGeneralRegs(0));
     bool canUseTailCallReg = regs.has(ICTailCallReg);
 
     Register argcReg = R0.scratchReg();
     regs.take(argcReg);
     regs.takeUnchecked(ICTailCallReg);
 
@@ -3333,18 +3304,16 @@ ICCallScriptedCompiler::generateStubCode
 
 typedef bool (*CopyStringSplitArrayFn)(JSContext*, HandleArrayObject, MutableHandleValue);
 static const VMFunction CopyStringSplitArrayInfo =
     FunctionInfo<CopyStringSplitArrayFn>(CopyStringSplitArray, "CopyStringSplitArray");
 
 bool
 ICCall_ConstStringSplit::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     // Stack Layout: [ ..., CalleeVal, ThisVal, strVal, sepVal, +ICStackValueOffset+ ]
     static const size_t SEP_DEPTH = 0;
     static const size_t STR_DEPTH = sizeof(Value);
     static const size_t CALLEE_DEPTH = 3 * sizeof(Value);
 
     AllocatableGeneralRegisterSet regs(availableGeneralRegs(0));
     Label failureRestoreArgc;
 #ifdef DEBUG
@@ -3433,18 +3402,16 @@ ICCall_ConstStringSplit::Compiler::gener
     masm.move32(Imm32(2), R0.scratchReg());
     EmitStubGuardFailure(masm);
     return true;
 }
 
 bool
 ICCall_IsSuspendedGenerator::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     // The IsSuspendedGenerator intrinsic is only called in self-hosted code,
     // so it's safe to assume we have a single argument and the callee is our
     // intrinsic.
 
     AllocatableGeneralRegisterSet regs(availableGeneralRegs(0));
 
     // Load the argument.
     Address argAddr(masm.getStackPointer(), ICStackValueOffset);
@@ -3478,18 +3445,16 @@ ICCall_IsSuspendedGenerator::Compiler::g
     masm.moveValue(BooleanValue(false), R0);
     EmitReturnFromIC(masm);
     return true;
 }
 
 bool
 ICCall_Native::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     Label failure;
     AllocatableGeneralRegisterSet regs(availableGeneralRegs(0));
 
     Register argcReg = R0.scratchReg();
     regs.take(argcReg);
     regs.takeUnchecked(ICTailCallReg);
 
     if (isSpread_)
@@ -3591,18 +3556,16 @@ ICCall_Native::Compiler::generateStubCod
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
     return true;
 }
 
 bool
 ICCall_ClassHook::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     Label failure;
     AllocatableGeneralRegisterSet regs(availableGeneralRegs(0));
 
     Register argcReg = R0.scratchReg();
     regs.take(argcReg);
     regs.takeUnchecked(ICTailCallReg);
 
     // Load the callee in R1.
@@ -3682,18 +3645,16 @@ ICCall_ClassHook::Compiler::generateStub
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
     return true;
 }
 
 bool
 ICCall_ScriptedApplyArray::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     Label failure;
     AllocatableGeneralRegisterSet regs(availableGeneralRegs(0));
 
     Register argcReg = R0.scratchReg();
     regs.take(argcReg);
     regs.takeUnchecked(ICTailCallReg);
 
     //
@@ -3780,18 +3741,16 @@ ICCall_ScriptedApplyArray::Compiler::gen
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
     return true;
 }
 
 bool
 ICCall_ScriptedApplyArguments::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     Label failure;
     AllocatableGeneralRegisterSet regs(availableGeneralRegs(0));
 
     Register argcReg = R0.scratchReg();
     regs.take(argcReg);
     regs.takeUnchecked(ICTailCallReg);
 
     //
@@ -3872,18 +3831,16 @@ ICCall_ScriptedApplyArguments::Compiler:
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
     return true;
 }
 
 bool
 ICCall_ScriptedFunCall::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     Label failure;
     AllocatableGeneralRegisterSet regs(availableGeneralRegs(0));
     bool canUseTailCallReg = regs.has(ICTailCallReg);
 
     Register argcReg = R0.scratchReg();
     regs.take(argcReg);
     regs.takeUnchecked(ICTailCallReg);
 
@@ -4006,18 +3963,16 @@ DoubleValueToInt32ForSwitch(Value* v)
 
     v->setInt32(truncated);
     return true;
 }
 
 bool
 ICTableSwitch::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     Label isInt32, notInt32, outOfRange;
     Register scratch = R1.scratchReg();
 
     masm.branchTestInt32(Assembler::NotEqual, R0, &notInt32);
 
     Register key = masm.extractInt32(R0, ExtractTemp0);
 
     masm.bind(&isInt32);
@@ -4154,18 +4109,16 @@ typedef bool (*DoGetIteratorFallbackFn)(
                                         HandleValue, MutableHandleValue);
 static const VMFunction DoGetIteratorFallbackInfo =
     FunctionInfo<DoGetIteratorFallbackFn>(DoGetIteratorFallback, "DoGetIteratorFallback",
                                           TailCall, PopValues(1));
 
 bool
 ICGetIterator_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     EmitRestoreTailCallReg(masm);
 
     // Sync stack for the decompiler.
     masm.pushValue(R0);
 
     masm.pushValue(R0);
     masm.push(ICStubReg);
     pushStubPayload(masm, R0.scratchReg());
@@ -4213,18 +4166,16 @@ typedef bool (*DoIteratorMoreFallbackFn)
                                          HandleObject, MutableHandleValue);
 static const VMFunction DoIteratorMoreFallbackInfo =
     FunctionInfo<DoIteratorMoreFallbackFn>(DoIteratorMoreFallback, "DoIteratorMoreFallback",
                                            TailCall);
 
 bool
 ICIteratorMore_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     EmitRestoreTailCallReg(masm);
 
     masm.unboxObject(R0, R0.scratchReg());
     masm.push(R0.scratchReg());
     masm.push(ICStubReg);
     pushStubPayload(masm, R0.scratchReg());
 
     return tailCallVM(DoIteratorMoreFallbackInfo, masm);
@@ -4232,18 +4183,16 @@ ICIteratorMore_Fallback::Compiler::gener
 
 //
 // IteratorMore_Native
 //
 
 bool
 ICIteratorMore_Native::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     Label failure;
 
     Register obj = masm.extractObject(R0, ExtractTemp0);
 
     AllocatableGeneralRegisterSet regs(availableGeneralRegs(1));
     Register nativeIterator = regs.takeAny();
     Register scratch = regs.takeAny();
 
@@ -4293,18 +4242,16 @@ DoIteratorCloseFallback(JSContext* cx, I
 typedef void (*DoIteratorCloseFallbackFn)(JSContext*, ICIteratorClose_Fallback*, HandleValue);
 static const VMFunction DoIteratorCloseFallbackInfo =
     FunctionInfo<DoIteratorCloseFallbackFn>(DoIteratorCloseFallback, "DoIteratorCloseFallback",
                                             TailCall);
 
 bool
 ICIteratorClose_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     EmitRestoreTailCallReg(masm);
 
     masm.pushValue(R0);
     masm.push(ICStubReg);
 
     return tailCallVM(DoIteratorCloseFallbackInfo, masm);
 }
 
@@ -4390,18 +4337,16 @@ typedef bool (*DoInstanceOfFallbackFn)(J
                                        HandleValue, HandleValue, MutableHandleValue);
 static const VMFunction DoInstanceOfFallbackInfo =
     FunctionInfo<DoInstanceOfFallbackFn>(DoInstanceOfFallback, "DoInstanceOfFallback", TailCall,
                                          PopValues(2));
 
 bool
 ICInstanceOf_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     EmitRestoreTailCallReg(masm);
 
     // Sync stack for the decompiler.
     masm.pushValue(R0);
     masm.pushValue(R1);
 
     masm.pushValue(R1);
     masm.pushValue(R0);
@@ -4450,18 +4395,16 @@ DoTypeOfFallback(JSContext* cx, Baseline
 typedef bool (*DoTypeOfFallbackFn)(JSContext*, BaselineFrame* frame, ICTypeOf_Fallback*,
                                    HandleValue, MutableHandleValue);
 static const VMFunction DoTypeOfFallbackInfo =
     FunctionInfo<DoTypeOfFallbackFn>(DoTypeOfFallback, "DoTypeOfFallback", TailCall);
 
 bool
 ICTypeOf_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     EmitRestoreTailCallReg(masm);
 
     masm.pushValue(R0);
     masm.push(ICStubReg);
     pushStubPayload(masm, R0.scratchReg());
 
     return tailCallVM(DoTypeOfFallbackInfo, masm);
 }
@@ -4503,18 +4446,16 @@ static const VMFunction DoRetSubFallback
 
 typedef bool (*ThrowFn)(JSContext*, HandleValue);
 static const VMFunction ThrowInfoBaseline =
     FunctionInfo<ThrowFn>(js::Throw, "ThrowInfoBaseline", TailCall);
 
 bool
 ICRetSub_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     // If R0 is BooleanValue(true), rethrow R1.
     Label rethrow;
     masm.branchTestBooleanTruthy(true, R0, &rethrow);
     {
         // Call a stub to get the native code address for the pc offset in R1.
         AllocatableGeneralRegisterSet regs(availableGeneralRegs(0));
         regs.take(R1);
         regs.takeUnchecked(ICTailCallReg);
@@ -4539,18 +4480,16 @@ ICRetSub_Fallback::Compiler::generateStu
     EmitRestoreTailCallReg(masm);
     masm.pushValue(R1);
     return tailCallVM(ThrowInfoBaseline, masm);
 }
 
 bool
 ICRetSub_Resume::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     // If R0 is BooleanValue(true), rethrow R1.
     Label fail, rethrow;
     masm.branchTestBooleanTruthy(true, R0, &rethrow);
 
     // R1 is the pc offset. Ensure it matches this stub's offset.
     Register offset = masm.extractInt32(R1, ExtractTemp0);
     masm.branch32(Assembler::NotEqual,
                   Address(ICStubReg, ICRetSub_Resume::offsetOfPCOffset()),
@@ -4722,18 +4661,16 @@ DoRestFallback(JSContext* cx, BaselineFr
 typedef bool (*DoRestFallbackFn)(JSContext*, BaselineFrame*, ICRest_Fallback*,
                                  MutableHandleValue);
 static const VMFunction DoRestFallbackInfo =
     FunctionInfo<DoRestFallbackFn>(DoRestFallback, "DoRestFallback", TailCall);
 
 bool
 ICRest_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
-
     EmitRestoreTailCallReg(masm);
 
     masm.push(ICStubReg);
     pushStubPayload(masm, R0.scratchReg());
 
     return tailCallVM(DoRestFallbackInfo, masm);
 }
 

--- a/js/src/jit/BaselineIC.h
+++ b/js/src/jit/BaselineIC.h
@@ -39,17 +39,17 @@ class ICWarmUpCounter_Fallback : public 
   public:
     // Compiler for this stub kind.
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::WarmUpCounter_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::WarmUpCounter_Fallback)
         { }
 
         ICWarmUpCounter_Fallback* getStub(ICStubSpace* space) override {
             return newStub<ICWarmUpCounter_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -71,17 +71,17 @@ class ICTypeUpdate_Fallback : public ICS
   public:
     // Compiler for this stub kind.
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::TypeUpdate_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::TypeUpdate_Fallback)
         { }
 
         ICTypeUpdate_Fallback* getStub(ICStubSpace* space) override {
             return newStub<ICTypeUpdate_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -139,17 +139,17 @@ class ICTypeUpdate_SingleObject : public
 
     class Compiler : public ICStubCompiler {
       protected:
         HandleObject obj_;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         Compiler(JSContext* cx, HandleObject obj)
-          : ICStubCompiler(cx, TypeUpdate_SingleObject, Engine::Baseline),
+          : ICStubCompiler(cx, TypeUpdate_SingleObject),
             obj_(obj)
         { }
 
         ICTypeUpdate_SingleObject* getStub(ICStubSpace* space) override {
             return newStub<ICTypeUpdate_SingleObject>(space, getStubCode(), obj_);
         }
     };
 };
@@ -174,17 +174,17 @@ class ICTypeUpdate_ObjectGroup : public 
 
     class Compiler : public ICStubCompiler {
       protected:
         HandleObjectGroup group_;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         Compiler(JSContext* cx, HandleObjectGroup group)
-          : ICStubCompiler(cx, TypeUpdate_ObjectGroup, Engine::Baseline),
+          : ICStubCompiler(cx, TypeUpdate_ObjectGroup),
             group_(group)
         { }
 
         ICTypeUpdate_ObjectGroup* getStub(ICStubSpace* space) override {
             return newStub<ICTypeUpdate_ObjectGroup>(space, getStubCode(), group_);
         }
     };
 };
@@ -199,17 +199,17 @@ class ICTypeUpdate_AnyValue : public ICS
 
   public:
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, TypeUpdate_AnyValue, Engine::Baseline)
+          : ICStubCompiler(cx, TypeUpdate_AnyValue)
         {}
 
         ICTypeUpdate_AnyValue* getStub(ICStubSpace* space) override {
             return newStub<ICTypeUpdate_AnyValue>(space, getStubCode());
         }
     };
 };
 
@@ -228,17 +228,17 @@ class ICToBool_Fallback : public ICFallb
 
     // Compiler for this stub kind.
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::ToBool_Fallback, Engine::Baseline) {}
+          : ICStubCompiler(cx, ICStub::ToBool_Fallback) {}
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICToBool_Fallback>(space, getStubCode());
         }
     };
 };
 
 // ToNumber
@@ -254,17 +254,17 @@ class ICToNumber_Fallback : public ICFal
   public:
     // Compiler for this stub kind.
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::ToNumber_Fallback, Engine::Baseline) {}
+          : ICStubCompiler(cx, ICStub::ToNumber_Fallback) {}
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICToNumber_Fallback>(space, getStubCode());
         }
     };
 };
 
 // GetElem
@@ -298,24 +298,23 @@ class ICGetElem_Fallback : public ICMoni
 
     // Compiler for this stub kind.
     class Compiler : public ICStubCompiler {
       protected:
         bool hasReceiver_;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
         virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1) |
+            return static_cast<int32_t>(kind) << 1 |
                   (static_cast<int32_t>(hasReceiver_) << 17);
         }
 
       public:
         explicit Compiler(JSContext* cx, bool hasReceiver = false)
-          : ICStubCompiler(cx, ICStub::GetElem_Fallback, Engine::Baseline),
+          : ICStubCompiler(cx, ICStub::GetElem_Fallback),
             hasReceiver_(hasReceiver)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICGetElem_Fallback>(space, getStubCode());
         }
     };
 };
@@ -344,17 +343,17 @@ class ICSetElem_Fallback : public ICFall
 
     // Compiler for this stub kind.
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::SetElem_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::SetElem_Fallback)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICSetElem_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -370,17 +369,17 @@ class ICIn_Fallback : public ICFallbackS
 
   public:
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::In_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::In_Fallback)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICIn_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -396,17 +395,17 @@ class ICHasOwn_Fallback : public ICFallb
 
   public:
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::HasOwn_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::HasOwn_Fallback)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICHasOwn_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -432,17 +431,17 @@ class ICGetName_Fallback : public ICMoni
     }
 
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::GetName_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::GetName_Fallback)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICGetName_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -458,17 +457,17 @@ class ICBindName_Fallback : public ICFal
 
   public:
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::BindName_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::BindName_Fallback)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICBindName_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -484,17 +483,17 @@ class ICGetIntrinsic_Fallback : public I
 
   public:
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::GetIntrinsic_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::GetIntrinsic_Fallback)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICGetIntrinsic_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -531,24 +530,23 @@ class ICGetProp_Fallback : public ICMoni
     class Compiler : public ICStubCompiler {
       protected:
         CodeOffset bailoutReturnOffset_;
         bool hasReceiver_;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
         void postGenerateStubCode(MacroAssembler& masm, Handle<JitCode*> code) override;
 
         virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1) |
+            return static_cast<int32_t>(kind) << 1 |
                   (static_cast<int32_t>(hasReceiver_) << 17);
         }
 
       public:
         explicit Compiler(JSContext* cx, bool hasReceiver = false)
-          : ICStubCompiler(cx, ICStub::GetProp_Fallback, Engine::Baseline),
+          : ICStubCompiler(cx, ICStub::GetProp_Fallback),
             hasReceiver_(hasReceiver)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICGetProp_Fallback>(space, getStubCode());
         }
     };
 };
@@ -580,17 +578,17 @@ class ICSetProp_Fallback : public ICFall
     class Compiler : public ICStubCompiler {
       protected:
         CodeOffset bailoutReturnOffset_;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
         void postGenerateStubCode(MacroAssembler& masm, Handle<JitCode*> code) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::SetProp_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::SetProp_Fallback)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICSetProp_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -603,17 +601,17 @@ class ICSetProp_Fallback : public ICFall
 //      JSOP_SPREADCALL
 //      JSOP_SPREADNEW
 //      JSOP_SPREADEVAL
 
 class ICCallStubCompiler : public ICStubCompiler
 {
   protected:
     ICCallStubCompiler(JSContext* cx, ICStub::Kind kind)
-      : ICStubCompiler(cx, kind, Engine::Baseline)
+      : ICStubCompiler(cx, kind)
     { }
 
     enum FunApplyThing {
         FunApply_MagicArgs,
         FunApply_Array
     };
 
     void pushCallArguments(MacroAssembler& masm, AllocatableGeneralRegisterSet regs,
@@ -664,18 +662,17 @@ class ICCall_Fallback : public ICMonitor
       protected:
         bool isConstructing_;
         bool isSpread_;
         CodeOffset bailoutReturnOffset_;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
         void postGenerateStubCode(MacroAssembler& masm, Handle<JitCode*> code) override;
 
         virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1) |
+            return static_cast<int32_t>(kind) << 1 |
                   (static_cast<int32_t>(isSpread_) << 17) |
                   (static_cast<int32_t>(isConstructing_) << 18);
         }
 
       public:
         Compiler(JSContext* cx, bool isConstructing, bool isSpread)
           : ICCallStubCompiler(cx, ICStub::Call_Fallback),
             isConstructing_(isConstructing),
@@ -754,18 +751,17 @@ class ICCallScriptedCompiler : public IC
     bool isSpread_;
     bool maybeCrossRealm_;
     RootedFunction callee_;
     RootedObject templateObject_;
     uint32_t pcOffset_;
     MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
     virtual int32_t getKey() const override {
-        return static_cast<int32_t>(engine_) |
-              (static_cast<int32_t>(kind) << 1) |
+        return static_cast<int32_t>(kind) << 1 |
               (static_cast<int32_t>(isConstructing_) << 17) |
               (static_cast<int32_t>(isSpread_) << 18) |
               (static_cast<int32_t>(maybeCrossRealm_) << 19);
     }
 
   public:
     ICCallScriptedCompiler(JSContext* cx, ICStub* firstMonitorStub,
                            JSFunction* callee, JSObject* templateObject,
@@ -852,18 +848,17 @@ class ICCall_Native : public ICMonitored
         bool isSpread_;
         bool isCrossRealm_;
         RootedFunction callee_;
         RootedObject templateObject_;
         uint32_t pcOffset_;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
         virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1) |
+            return static_cast<int32_t>(kind) << 1 |
                   (static_cast<int32_t>(isSpread_) << 17) |
                   (static_cast<int32_t>(isConstructing_) << 18) |
                   (static_cast<int32_t>(ignoresReturnValue_) << 19) |
                   (static_cast<int32_t>(isCrossRealm_) << 20);
         }
 
       public:
         Compiler(JSContext* cx, ICStub* firstMonitorStub,
@@ -933,18 +928,17 @@ class ICCall_ClassHook : public ICMonito
         bool isConstructing_;
         const Class* clasp_;
         Native native_;
         RootedObject templateObject_;
         uint32_t pcOffset_;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
         virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1) |
+            return static_cast<int32_t>(kind) << 1 |
                   (static_cast<int32_t>(isConstructing_) << 17);
         }
 
       public:
         Compiler(JSContext* cx, ICStub* firstMonitorStub,
                  const Class* clasp, Native native,
                  HandleObject templateObject, uint32_t pcOffset,
                  bool isConstructing)
@@ -993,21 +987,16 @@ class ICCall_ScriptedApplyArray : public
 
     // Compiler for this stub kind.
     class Compiler : public ICCallStubCompiler {
       protected:
         ICStub* firstMonitorStub_;
         uint32_t pcOffset_;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
-        virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1);
-        }
-
       public:
         Compiler(JSContext* cx, ICStub* firstMonitorStub, uint32_t pcOffset)
           : ICCallStubCompiler(cx, ICStub::Call_ScriptedApplyArray),
             firstMonitorStub_(firstMonitorStub),
             pcOffset_(pcOffset)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
@@ -1041,21 +1030,16 @@ class ICCall_ScriptedApplyArguments : pu
 
     // Compiler for this stub kind.
     class Compiler : public ICCallStubCompiler {
       protected:
         ICStub* firstMonitorStub_;
         uint32_t pcOffset_;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
-        virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1);
-        }
-
       public:
         Compiler(JSContext* cx, ICStub* firstMonitorStub, uint32_t pcOffset)
           : ICCallStubCompiler(cx, ICStub::Call_ScriptedApplyArguments),
             firstMonitorStub_(firstMonitorStub),
             pcOffset_(pcOffset)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
@@ -1088,21 +1072,16 @@ class ICCall_ScriptedFunCall : public IC
 
     // Compiler for this stub kind.
     class Compiler : public ICCallStubCompiler {
       protected:
         ICStub* firstMonitorStub_;
         uint32_t pcOffset_;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
-        virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1);
-        }
-
       public:
         Compiler(JSContext* cx, ICStub* firstMonitorStub, uint32_t pcOffset)
           : ICCallStubCompiler(cx, ICStub::Call_ScriptedFunCall),
             firstMonitorStub_(firstMonitorStub),
             pcOffset_(pcOffset)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
@@ -1159,21 +1138,16 @@ class ICCall_ConstStringSplit : public I
         ICStub* firstMonitorStub_;
         uint32_t pcOffset_;
         RootedString expectedStr_;
         RootedString expectedSep_;
         RootedArrayObject templateObject_;
 
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
-        virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1);
-        }
-
       public:
         Compiler(JSContext* cx, ICStub* firstMonitorStub, uint32_t pcOffset, HandleString str,
                  HandleString sep, HandleArrayObject templateObject)
           : ICCallStubCompiler(cx, ICStub::Call_ConstStringSplit),
             firstMonitorStub_(firstMonitorStub),
             pcOffset_(pcOffset),
             expectedStr_(cx, str),
             expectedSep_(cx, sep),
@@ -1199,17 +1173,17 @@ class ICCall_IsSuspendedGenerator : publ
 
   public:
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::Call_IsSuspendedGenerator, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::Call_IsSuspendedGenerator)
         {}
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICCall_IsSuspendedGenerator>(space, getStubCode());
         }
    };
 };
 
 // Stub for performing a TableSwitch, updating the IC's return address to jump
@@ -1235,17 +1209,17 @@ class ICTableSwitch : public ICStub
 
     class Compiler : public ICStubCompiler {
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
         jsbytecode* pc_;
 
       public:
         Compiler(JSContext* cx, jsbytecode* pc)
-          : ICStubCompiler(cx, ICStub::TableSwitch, Engine::Baseline), pc_(pc)
+          : ICStubCompiler(cx, ICStub::TableSwitch), pc_(pc)
         {}
 
         ICStub* getStub(ICStubSpace* space) override;
     };
 };
 
 // IC for constructing an iterator from an input value.
 class ICGetIterator_Fallback : public ICFallbackStub
@@ -1258,17 +1232,17 @@ class ICGetIterator_Fallback : public IC
 
   public:
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::GetIterator_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::GetIterator_Fallback)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICGetIterator_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -1291,17 +1265,17 @@ class ICIteratorMore_Fallback : public I
     }
 
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::IteratorMore_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::IteratorMore_Fallback)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICIteratorMore_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -1316,17 +1290,17 @@ class ICIteratorMore_Native : public ICS
 
   public:
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::IteratorMore_Native, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::IteratorMore_Native)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICIteratorMore_Native>(space, getStubCode());
         }
     };
 };
 
@@ -1341,17 +1315,17 @@ class ICIteratorClose_Fallback : public 
 
   public:
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::IteratorClose_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::IteratorClose_Fallback)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICIteratorClose_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -1377,17 +1351,17 @@ class ICInstanceOf_Fallback : public ICF
     }
 
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::InstanceOf_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::InstanceOf_Fallback)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICInstanceOf_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -1406,17 +1380,17 @@ class ICTypeOf_Fallback : public ICFallb
     static const uint32_t MAX_OPTIMIZED_STUBS = 6;
 
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::TypeOf_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::TypeOf_Fallback)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICTypeOf_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -1439,17 +1413,17 @@ class ICRest_Fallback : public ICFallbac
 
     class Compiler : public ICStubCompiler {
       protected:
         RootedArrayObject templateObject;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         Compiler(JSContext* cx, ArrayObject* templateObject)
-          : ICStubCompiler(cx, ICStub::Rest_Fallback, Engine::Baseline),
+          : ICStubCompiler(cx, ICStub::Rest_Fallback),
             templateObject(cx, templateObject)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICRest_Fallback>(space, getStubCode(), templateObject);
         }
     };
 };
@@ -1467,17 +1441,17 @@ class ICRetSub_Fallback : public ICFallb
     static const uint32_t MAX_OPTIMIZED_STUBS = 8;
 
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::RetSub_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::RetSub_Fallback)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICRetSub_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -1508,17 +1482,17 @@ class ICRetSub_Resume : public ICStub
     class Compiler : public ICStubCompiler {
         uint32_t pcOffset_;
         uint8_t* addr_;
 
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         Compiler(JSContext* cx, uint32_t pcOffset, uint8_t* addr)
-          : ICStubCompiler(cx, ICStub::RetSub_Resume, Engine::Baseline),
+          : ICStubCompiler(cx, ICStub::RetSub_Resume),
             pcOffset_(pcOffset),
             addr_(addr)
         { }
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICRetSub_Resume>(space, getStubCode(), pcOffset_, addr_);
         }
     };
@@ -1548,17 +1522,17 @@ class ICUnaryArith_Fallback : public ICF
 
     // Compiler for this stub kind.
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::UnaryArith_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::UnaryArith_Fallback)
         {}
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICUnaryArith_Fallback>(space, getStubCode());
         }
     };
 };
 
@@ -1592,17 +1566,17 @@ class ICCompare_Fallback : public ICFall
 
     // Compiler for this stub kind.
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::Compare_Fallback, Engine::Baseline) {}
+          : ICStubCompiler(cx, ICStub::Compare_Fallback) {}
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICCompare_Fallback>(space, getStubCode());
         }
     };
 };
 
 
@@ -1642,17 +1616,17 @@ class ICBinaryArith_Fallback : public IC
 
     // Compiler for this stub kind.
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::BinaryArith_Fallback, Engine::Baseline) {}
+          : ICStubCompiler(cx, ICStub::BinaryArith_Fallback) {}
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICBinaryArith_Fallback>(space, getStubCode());
         }
     };
 };
 
 // JSOP_NEWARRAY
@@ -1674,17 +1648,17 @@ class ICNewArray_Fallback : public ICFal
 
   public:
     class Compiler : public ICStubCompiler {
         RootedObjectGroup templateGroup;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         Compiler(JSContext* cx, ObjectGroup* templateGroup)
-          : ICStubCompiler(cx, ICStub::NewArray_Fallback, Engine::Baseline),
+          : ICStubCompiler(cx, ICStub::NewArray_Fallback),
             templateGroup(cx, templateGroup)
         {}
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICNewArray_Fallback>(space, getStubCode(), templateGroup);
         }
     };
 
@@ -1721,17 +1695,17 @@ class ICNewObject_Fallback : public ICFa
     {}
 
   public:
     class Compiler : public ICStubCompiler {
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, ICStub::NewObject_Fallback, Engine::Baseline)
+          : ICStubCompiler(cx, ICStub::NewObject_Fallback)
         {}
 
         ICStub* getStub(ICStubSpace* space) override {
             return newStub<ICNewObject_Fallback>(space, getStubCode());
         }
     };
 
     GCPtrObject& templateObject() {

--- a/js/src/jit/SharedIC.cpp
+++ b/js/src/jit/SharedIC.cpp
@@ -528,42 +528,35 @@ ICStubCompiler::getStubCode()
 }
 
 bool
 ICStubCompiler::tailCallVM(const VMFunction& fun, MacroAssembler& masm)
 {
     TrampolinePtr code = cx->runtime()->jitRuntime()->getVMWrapper(fun);
     MOZ_ASSERT(fun.expectTailCall == TailCall);
     uint32_t argSize = fun.explicitStackSlots() * sizeof(void*);
-    if (engine_ == Engine::Baseline) {
-        EmitBaselineTailCallVM(code, masm, argSize);
-    } else {
-        uint32_t stackSize = argSize + fun.extraValuesToPop * sizeof(Value);
-        EmitIonTailCallVM(code, masm, stackSize);
-    }
+    EmitBaselineTailCallVM(code, masm, argSize);
     return true;
 }
 
 bool
 ICStubCompiler::callVM(const VMFunction& fun, MacroAssembler& masm)
 {
     MOZ_ASSERT(inStubFrame_);
 
     TrampolinePtr code = cx->runtime()->jitRuntime()->getVMWrapper(fun);
     MOZ_ASSERT(fun.expectTailCall == NonTailCall);
-    MOZ_ASSERT(engine_ == Engine::Baseline);
 
     EmitBaselineCallVM(code, masm);
     return true;
 }
 
 void
 ICStubCompiler::enterStubFrame(MacroAssembler& masm, Register scratch)
 {
-    MOZ_ASSERT(engine_ == Engine::Baseline);
     EmitBaselineEnterStubFrame(masm, scratch);
 #ifdef DEBUG
     framePushedAtEnterStubFrame_ = masm.framePushed();
 #endif
 
     MOZ_ASSERT(!inStubFrame_);
     inStubFrame_ = true;
 
@@ -587,18 +580,17 @@ ICStubCompiler::assumeStubFrame()
 #endif
 }
 
 void
 ICStubCompiler::leaveStubFrame(MacroAssembler& masm, bool calledIntoIon)
 {
     MOZ_ASSERT(entersStubFrame_ && inStubFrame_);
     inStubFrame_ = false;
-
-    MOZ_ASSERT(engine_ == Engine::Baseline);
+    
 #ifdef DEBUG
     masm.setFramePushed(framePushedAtEnterStubFrame_);
     if (calledIntoIon)
         masm.adjustFrame(sizeof(intptr_t)); // Calls into ion have this extra.
 #endif
     EmitBaselineLeaveStubFrame(masm, calledIntoIon);
 }
 

--- a/js/src/jit/SharedIC.h
+++ b/js/src/jit/SharedIC.h
@@ -996,43 +996,38 @@ class ICCacheIR_Updated : public ICUpdat
 };
 
 // Base class for stubcode compilers.
 class ICStubCompiler
 {
     // Prevent GC in the middle of stub compilation.
     js::gc::AutoSuppressGC suppressGC;
 
-  public:
-    using Engine = ICStubEngine;
-
   protected:
     JSContext* cx;
     ICStub::Kind kind;
-    Engine engine_;
     bool inStubFrame_;
 
 #ifdef DEBUG
     bool entersStubFrame_;
     uint32_t framePushedAtEnterStubFrame_;
 #endif
 
     // By default the stubcode key is just the kind.
     virtual int32_t getKey() const {
-        return static_cast<int32_t>(engine_) |
-              (static_cast<int32_t>(kind) << 1);
+        return (static_cast<int32_t>(kind) << 1);
     }
 
     virtual MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) = 0;
     virtual void postGenerateStubCode(MacroAssembler& masm, Handle<JitCode*> genCode) {}
 
     JitCode* getStubCode();
 
-    ICStubCompiler(JSContext* cx, ICStub::Kind kind, Engine engine)
-      : suppressGC(cx), cx(cx), kind(kind), engine_(engine), inStubFrame_(false)
+    ICStubCompiler(JSContext* cx, ICStub::Kind kind)
+      : suppressGC(cx), cx(cx), kind(kind), inStubFrame_(false)
 #ifdef DEBUG
       , entersStubFrame_(false), framePushedAtEnterStubFrame_(0)
 #endif
     {}
 
     // Push a payload specialized per compiler needed to execute stubs.
     void PushStubPayload(MacroAssembler& masm, Register scratch);
     void pushStubPayload(MacroAssembler& masm, Register scratch);
@@ -1096,25 +1091,24 @@ class ICStubCompiler
     template <typename T, typename... Args>
     T* newStub(Args&&... args) {
         return ICStub::New<T>(cx, std::forward<Args>(args)...);
     }
 
   public:
     virtual ICStub* getStub(ICStubSpace* space) = 0;
 
-    static ICStubSpace* StubSpaceForStub(bool makesGCCalls, JSScript* outerScript, Engine engine) {
+    static ICStubSpace* StubSpaceForStub(bool makesGCCalls, JSScript* outerScript) {
         if (makesGCCalls) {
-            MOZ_ASSERT(engine == ICStubCompiler::Engine::Baseline);
             return outerScript->baselineScript()->fallbackStubSpace();
         }
         return outerScript->zone()->jitZone()->optimizedStubSpace();
     }
     ICStubSpace* getStubSpace(JSScript* outerScript) {
-        return StubSpaceForStub(ICStub::NonCacheIRStubMakesGCCalls(kind), outerScript, engine_);
+        return StubSpaceForStub(ICStub::NonCacheIRStubMakesGCCalls(kind), outerScript);
     }
 };
 
 // Monitored fallback stubs - as the name implies.
 class ICMonitoredFallbackStub : public ICFallbackStub
 {
   protected:
     // Pointer to the fallback monitor stub. Created lazily by
@@ -1198,25 +1192,24 @@ class TypeCheckPrimitiveSetStub : public
     }
 
     class Compiler : public ICStubCompiler {
       protected:
         TypeCheckPrimitiveSetStub* existingStub_;
         uint16_t flags_;
 
         virtual int32_t getKey() const override {
-            return static_cast<int32_t>(engine_) |
-                  (static_cast<int32_t>(kind) << 1) |
+            return static_cast<int32_t>(kind) << 1 |
                   (static_cast<int32_t>(flags_) << 17);
         }
 
       public:
         Compiler(JSContext* cx, Kind kind, TypeCheckPrimitiveSetStub* existingStub,
                  JSValueType type)
-          : ICStubCompiler(cx, kind, Engine::Baseline),
+          : ICStubCompiler(cx, kind),
             existingStub_(existingStub),
             flags_((existingStub ? existingStub->typeFlags() : 0) | TypeToFlag(type))
         {
             MOZ_ASSERT_IF(existingStub_, flags_ != existingStub_->typeFlags());
         }
 
         TypeCheckPrimitiveSetStub* updateStub() {
             MOZ_ASSERT(existingStub_);
@@ -1384,23 +1377,23 @@ class ICTypeMonitor_Fallback : public IC
         ICMonitoredFallbackStub* mainFallbackStub_;
         uint32_t argumentIndex_;
 
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         Compiler(JSContext* cx, ICMonitoredFallbackStub* mainFallbackStub)
-          : ICStubCompiler(cx, ICStub::TypeMonitor_Fallback, Engine::Baseline),
+          : ICStubCompiler(cx, ICStub::TypeMonitor_Fallback),
             mainFallbackStub_(mainFallbackStub),
             argumentIndex_(BYTECODE_INDEX)
         { }
 
         Compiler(JSContext* cx, uint32_t argumentIndex)
-          : ICStubCompiler(cx, ICStub::TypeMonitor_Fallback, Engine::Baseline),
+          : ICStubCompiler(cx, ICStub::TypeMonitor_Fallback),
             mainFallbackStub_(nullptr),
             argumentIndex_(argumentIndex)
         { }
 
         ICTypeMonitor_Fallback* getStub(ICStubSpace* space) override {
             return newStub<ICTypeMonitor_Fallback>(space, getStubCode(), mainFallbackStub_,
                                                        argumentIndex_);
         }
@@ -1461,17 +1454,17 @@ class ICTypeMonitor_SingleObject : publi
 
     class Compiler : public ICStubCompiler {
       protected:
         HandleObject obj_;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         Compiler(JSContext* cx, HandleObject obj)
-          : ICStubCompiler(cx, TypeMonitor_SingleObject, Engine::Baseline),
+          : ICStubCompiler(cx, TypeMonitor_SingleObject),
             obj_(obj)
         { }
 
         ICTypeMonitor_SingleObject* getStub(ICStubSpace* space) override {
             return newStub<ICTypeMonitor_SingleObject>(space, getStubCode(), obj_);
         }
     };
 };
@@ -1495,17 +1488,17 @@ class ICTypeMonitor_ObjectGroup : public
 
     class Compiler : public ICStubCompiler {
       protected:
         HandleObjectGroup group_;
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         Compiler(JSContext* cx, HandleObjectGroup group)
-          : ICStubCompiler(cx, TypeMonitor_ObjectGroup, Engine::Baseline),
+          : ICStubCompiler(cx, TypeMonitor_ObjectGroup),
             group_(group)
         { }
 
         ICTypeMonitor_ObjectGroup* getStub(ICStubSpace* space) override {
             return newStub<ICTypeMonitor_ObjectGroup>(space, getStubCode(), group_);
         }
     };
 };
@@ -1520,17 +1513,17 @@ class ICTypeMonitor_AnyValue : public IC
 
   public:
     class Compiler : public ICStubCompiler {
       protected:
         MOZ_MUST_USE bool generateStubCode(MacroAssembler& masm) override;
 
       public:
         explicit Compiler(JSContext* cx)
-          : ICStubCompiler(cx, TypeMonitor_AnyValue, Engine::Baseline)
+          : ICStubCompiler(cx, TypeMonitor_AnyValue)
         { }
 
         ICTypeMonitor_AnyValue* getStub(ICStubSpace* space) override {
             return newStub<ICTypeMonitor_AnyValue>(space, getStubCode());
         }
     };
 };
 

--- a/js/src/jit/arm/SharedICHelpers-arm-inl.h
+++ b/js/src/jit/arm/SharedICHelpers-arm-inl.h
@@ -40,38 +40,16 @@ EmitBaselineTailCallVM(TrampolinePtr tar
     MOZ_ASSERT(ICTailCallReg == lr);
     masm.makeFrameDescriptor(r0, JitFrame_BaselineJS, ExitFrameLayout::Size());
     masm.push(r0);
     masm.push(lr);
     masm.jump(target);
 }
 
 inline void
-EmitIonTailCallVM(TrampolinePtr target, MacroAssembler& masm, uint32_t stackSize)
-{
-    // We assume during this that R0 and R1 have been pushed, and that R2 is
-    // unused.
-    MOZ_ASSERT(R2 == ValueOperand(r1, r0));
-
-    masm.loadPtr(Address(sp, stackSize), r0);
-    masm.rshiftPtr(Imm32(FRAMESIZE_SHIFT), r0);
-    masm.add32(Imm32(stackSize + JitStubFrameLayout::Size() - sizeof(intptr_t)), r0);
-
-    // Push frame descriptor and perform the tail call.
-    // ICTailCallReg (lr) already contains the return address (as we keep
-    // it there through the stub calls), but the VMWrapper code being called
-    // expects the return address to also be pushed on the stack.
-    MOZ_ASSERT(ICTailCallReg == lr);
-    masm.makeFrameDescriptor(r0, JitFrame_IonJS, ExitFrameLayout::Size());
-    masm.push(r0);
-    masm.push(lr);
-    masm.jump(target);
-}
-
-inline void
 EmitBaselineCreateStubFrameDescriptor(MacroAssembler& masm, Register reg, uint32_t headerSize)
 {
     // Compute stub frame size. We have to add two pointers: the stub reg and
     // previous frame pointer pushed by EmitEnterStubFrame.
     masm.mov(BaselineFrameReg, reg);
     masm.as_add(reg, reg, Imm8(sizeof(void*) * 2));
     masm.ma_sub(BaselineStackReg, reg);
 

--- a/js/src/jit/arm64/SharedICHelpers-arm64-inl.h
+++ b/js/src/jit/arm64/SharedICHelpers-arm64-inl.h
@@ -43,22 +43,16 @@ EmitBaselineTailCallVM(TrampolinePtr tar
     // with direct calls. Refer to the top of generateVMWrapper().
     // ICTailCallReg (lr) already contains the return address (as we keep
     // it there through the stub calls).
 
     masm.jump(target);
 }
 
 inline void
-EmitIonTailCallVM(TrampolinePtr target, MacroAssembler& masm, uint32_t stackSize)
-{
-    MOZ_CRASH("Not implemented yet.");
-}
-
-inline void
 EmitBaselineCreateStubFrameDescriptor(MacroAssembler& masm, Register reg, uint32_t headerSize)
 {
     ARMRegister reg64(reg, 64);
 
     // Compute stub frame size.
     masm.Sub(reg64, masm.GetStackPointer64(), Operand(sizeof(void*) * 2));
     masm.Sub(reg64, BaselineFrameReg64, reg64);
 

--- a/js/src/jit/mips-shared/SharedICHelpers-mips-shared-inl.h
+++ b/js/src/jit/mips-shared/SharedICHelpers-mips-shared-inl.h
@@ -38,33 +38,16 @@ EmitBaselineTailCallVM(TrampolinePtr tar
     masm.subPtr(Imm32(sizeof(CommonFrameLayout)), StackPointer);
     masm.storePtr(scratch, Address(StackPointer, CommonFrameLayout::offsetOfDescriptor()));
     masm.storePtr(ra, Address(StackPointer, CommonFrameLayout::offsetOfReturnAddress()));
 
     masm.jump(target);
 }
 
 inline void
-EmitIonTailCallVM(TrampolinePtr target, MacroAssembler& masm, uint32_t stackSize)
-{
-    Register scratch = R2.scratchReg();
-
-    masm.loadPtr(Address(sp, stackSize), scratch);
-    masm.rshiftPtr(Imm32(FRAMESIZE_SHIFT), scratch);
-    masm.addPtr(Imm32(stackSize + JitStubFrameLayout::Size() - sizeof(intptr_t)), scratch);
-
-    // Push frame descriptor and perform the tail call.
-    MOZ_ASSERT(ICTailCallReg == ra);
-    masm.makeFrameDescriptor(scratch, JitFrame_IonJS, ExitFrameLayout::Size());
-    masm.push(scratch);
-    masm.push(ICTailCallReg);
-    masm.jump(target);
-}
-
-inline void
 EmitBaselineCreateStubFrameDescriptor(MacroAssembler& masm, Register reg, uint32_t headerSize)
 {
     // Compute stub frame size. We have to add two pointers: the stub reg and
     // previous frame pointer pushed by EmitEnterStubFrame.
     masm.movePtr(BaselineFrameReg, reg);
     masm.addPtr(Imm32(sizeof(intptr_t) * 2), reg);
     masm.subPtr(BaselineStackReg, reg);
 

--- a/js/src/jit/none/SharedICHelpers-none-inl.h
+++ b/js/src/jit/none/SharedICHelpers-none-inl.h
@@ -8,17 +8,16 @@
 #define jit_none_SharedICHelpers_none_inl_h
 
 #include "jit/SharedICHelpers.h"
 
 namespace js {
 namespace jit {
 
 inline void EmitBaselineTailCallVM(TrampolinePtr, MacroAssembler&, uint32_t) { MOZ_CRASH(); }
-inline void EmitIonTailCallVM(TrampolinePtr, MacroAssembler&, uint32_t) { MOZ_CRASH(); }
 inline void EmitBaselineCreateStubFrameDescriptor(MacroAssembler&, Register, uint32_t) { MOZ_CRASH(); }
 inline void EmitBaselineCallVM(TrampolinePtr, MacroAssembler&) { MOZ_CRASH(); }
 
 static const uint32_t STUB_FRAME_SIZE = 0;
 static const uint32_t STUB_FRAME_SAVED_STUB_OFFSET = 0;
 
 inline void EmitBaselineEnterStubFrame(MacroAssembler&, Register) { MOZ_CRASH(); }
 

--- a/js/src/jit/x64/SharedICHelpers-x64-inl.h
+++ b/js/src/jit/x64/SharedICHelpers-x64-inl.h
@@ -32,37 +32,16 @@ EmitBaselineTailCallVM(TrampolinePtr tar
     // Push frame descriptor and perform the tail call.
     masm.makeFrameDescriptor(scratch, JitFrame_BaselineJS, ExitFrameLayout::Size());
     masm.push(scratch);
     masm.push(ICTailCallReg);
     masm.jump(target);
 }
 
 inline void
-EmitIonTailCallVM(TrampolinePtr target, MacroAssembler& masm, uint32_t stackSize)
-{
-    // For tail calls, find the already pushed JitFrame_IonJS signifying the
-    // end of the Ion frame. Retrieve the length of the frame and repush
-    // JitFrame_IonJS with the extra stacksize, rendering the original
-    // JitFrame_IonJS obsolete.
-
-    ScratchRegisterScope scratch(masm);
-
-    masm.loadPtr(Address(esp, stackSize), scratch);
-    masm.shrq(Imm32(FRAMESIZE_SHIFT), scratch);
-    masm.addq(Imm32(stackSize + JitStubFrameLayout::Size() - sizeof(intptr_t)), scratch);
-
-    // Push frame descriptor and perform the tail call.
-    masm.makeFrameDescriptor(scratch, JitFrame_IonJS, ExitFrameLayout::Size());
-    masm.push(scratch);
-    masm.push(ICTailCallReg);
-    masm.jump(target);
-}
-
-inline void
 EmitBaselineCreateStubFrameDescriptor(MacroAssembler& masm, Register reg, uint32_t headerSize)
 {
     // Compute stub frame size. We have to add two pointers: the stub reg and previous
     // frame pointer pushed by EmitEnterStubFrame.
     masm.movq(BaselineFrameReg, reg);
     masm.addq(Imm32(sizeof(void*) * 2), reg);
     masm.subq(BaselineStackReg, reg);
 

--- a/js/src/jit/x86/SharedICHelpers-x86-inl.h
+++ b/js/src/jit/x86/SharedICHelpers-x86-inl.h
@@ -32,35 +32,16 @@ EmitBaselineTailCallVM(TrampolinePtr tar
     // Push frame descriptor and perform the tail call.
     masm.makeFrameDescriptor(eax, JitFrame_BaselineJS, ExitFrameLayout::Size());
     masm.push(eax);
     masm.push(ICTailCallReg);
     masm.jump(target);
 }
 
 inline void
-EmitIonTailCallVM(TrampolinePtr target, MacroAssembler& masm, uint32_t stackSize)
-{
-    // For tail calls, find the already pushed JitFrame_IonJS signifying the
-    // end of the Ion frame. Retrieve the length of the frame and repush
-    // JitFrame_IonJS with the extra stacksize, rendering the original
-    // JitFrame_IonJS obsolete.
-
-    masm.loadPtr(Address(esp, stackSize), eax);
-    masm.shrl(Imm32(FRAMESIZE_SHIFT), eax);
-    masm.addl(Imm32(stackSize + JitStubFrameLayout::Size() - sizeof(intptr_t)), eax);
-
-    // Push frame descriptor and perform the tail call.
-    masm.makeFrameDescriptor(eax, JitFrame_IonJS, ExitFrameLayout::Size());
-    masm.push(eax);
-    masm.push(ICTailCallReg);
-    masm.jump(target);
-}
-
-inline void
 EmitBaselineCreateStubFrameDescriptor(MacroAssembler& masm, Register reg, uint32_t headerSize)
 {
     // Compute stub frame size. We have to add two pointers: the stub reg and previous
     // frame pointer pushed by EmitEnterStubFrame.
     masm.movl(BaselineFrameReg, reg);
     masm.addl(Imm32(sizeof(void*) * 2), reg);
     masm.subl(BaselineStackReg, reg);