From 7762686e6997fc00a19e3fac8fa3564bf18dc7e8 Mon Sep 17 00:00:00 2001
From: Jason Orendorff <jorendorff@mozilla.com>
Date: Tue, 14 Jan 2020 17:49:22 +0000
Subject: [PATCH] Bug 1608509 - Part 5: Rename baseline emit methods. r=jandem.

Differential Revision: https://phabricator.services.mozilla.com/D59806

--HG--
extra : moz-landing-system : lando
---
 js/src/frontend/BytecodeEmitter.cpp |   4 +-
 js/src/jit/BaselineCodeGen.cpp      | 616 ++++++++++++++--------------
 js/src/jit/BaselineCodeGen.h        |   2 +-
 js/src/jit/IonBuilder.cpp           |   6 +-
 4 files changed, 314 insertions(+), 314 deletions(-)

diff --git a/js/src/frontend/BytecodeEmitter.cpp b/js/src/frontend/BytecodeEmitter.cpp
index 2c2ab982902b..f1ec528610fc 100644
--- a/js/src/frontend/BytecodeEmitter.cpp
+++ b/js/src/frontend/BytecodeEmitter.cpp
@@ -8523,8 +8523,8 @@ bool BytecodeEmitter::emitArray(ParseNode* arrayHead, uint32_t count,
   // Array literal's length is limited to NELEMENTS_LIMIT in parser.
   static_assert(NativeObject::MAX_DENSE_ELEMENTS_COUNT <= INT32_MAX,
                 "array literals' maximum length must not exceed limits "
-                "required by BaselineCompiler::emit_JSOP_NEWARRAY, "
-                "BaselineCompiler::emit_JSOP_INITELEM_ARRAY, "
+                "required by BaselineCompiler::emit_NewArray, "
+                "BaselineCompiler::emit_InitElemArray, "
                 "and DoSetElemFallback's handling of JSOP_INITELEM_ARRAY");
   MOZ_ASSERT(count >= nspread);
   MOZ_ASSERT(count <= NativeObject::MAX_DENSE_ELEMENTS_COUNT,
diff --git a/js/src/jit/BaselineCodeGen.cpp b/js/src/jit/BaselineCodeGen.cpp
index 67bcd52170be..0366be5b2b22 100644
--- a/js/src/jit/BaselineCodeGen.cpp
+++ b/js/src/jit/BaselineCodeGen.cpp
@@ -1709,46 +1709,46 @@ void BaselineCodeGen<Handler>::emitProfilerExitFrame() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_NOP() {
+bool BaselineCodeGen<Handler>::emit_Nop() {
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_ITERNEXT() {
+bool BaselineCodeGen<Handler>::emit_IterNext() {
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_NOP_DESTRUCTURING() {
+bool BaselineCodeGen<Handler>::emit_NopDestructuring() {
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_TRY_DESTRUCTURING() {
+bool BaselineCodeGen<Handler>::emit_TryDestructuring() {
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_POP() {
+bool BaselineCodeGen<Handler>::emit_Pop() {
   frame.pop();
   return true;
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_POPN() {
+bool BaselineCompilerCodeGen::emit_PopN() {
   frame.popn(GET_UINT16(handler.pc()));
   return true;
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_POPN() {
+bool BaselineInterpreterCodeGen::emit_PopN() {
   LoadUint16Operand(masm, R0.scratchReg());
   frame.popn(R0.scratchReg());
   return true;
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_DUPAT() {
+bool BaselineCompilerCodeGen::emit_DupAt() {
   frame.syncStack(0);
 
   // DupAt takes a value on the stack and re-pushes it on top.  It's like
@@ -1762,7 +1762,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_DUPAT() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_DUPAT() {
+bool BaselineInterpreterCodeGen::emit_DupAt() {
   LoadUint24Operand(masm, 0, R0.scratchReg());
   masm.loadValue(frame.addressOfStackValue(R0.scratchReg()), R0);
   frame.push(R0);
@@ -1770,7 +1770,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_DUPAT() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DUP() {
+bool BaselineCodeGen<Handler>::emit_Dup() {
   // Keep top stack value in R0, sync the rest so that we can use R1. We use
   // separate registers because every register can be used by at most one
   // StackValue.
@@ -1784,7 +1784,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_DUP() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DUP2() {
+bool BaselineCodeGen<Handler>::emit_Dup2() {
   frame.syncStack(0);
 
   masm.loadValue(frame.addressOfStackValue(-2), R0);
@@ -1796,7 +1796,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_DUP2() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SWAP() {
+bool BaselineCodeGen<Handler>::emit_Swap() {
   // Keep top stack values in R0 and R1.
   frame.popRegsAndSync(2);
 
@@ -1806,7 +1806,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_SWAP() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_PICK() {
+bool BaselineCompilerCodeGen::emit_Pick() {
   frame.syncStack(0);
 
   // Pick takes a value on the stack and moves it to the top.
@@ -1834,7 +1834,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_PICK() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_PICK() {
+bool BaselineInterpreterCodeGen::emit_Pick() {
   // First, move the value to move up into R0.
   Register scratch = R2.scratchReg();
   LoadUint8Operand(masm, scratch);
@@ -1858,7 +1858,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_PICK() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_UNPICK() {
+bool BaselineCompilerCodeGen::emit_Unpick() {
   frame.syncStack(0);
 
   // Pick takes the top of the stack value and moves it under the nth value.
@@ -1888,7 +1888,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_UNPICK() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_UNPICK() {
+bool BaselineInterpreterCodeGen::emit_Unpick() {
   Register scratch = R2.scratchReg();
   LoadUint8Operand(masm, scratch);
 
@@ -2078,7 +2078,7 @@ MOZ_MUST_USE bool BaselineInterpreterCodeGen::emitTestScriptFlag(
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GOTO() {
+bool BaselineCodeGen<Handler>::emit_Goto() {
   frame.syncStack(0);
   emitJump();
   return true;
@@ -2115,12 +2115,12 @@ bool BaselineCodeGen<Handler>::emitTest(bool branchIfTrue) {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_IFEQ() {
+bool BaselineCodeGen<Handler>::emit_IfEq() {
   return emitTest(false);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_IFNE() {
+bool BaselineCodeGen<Handler>::emit_IfNe() {
   return emitTest(true);
 }
 
@@ -2141,17 +2141,17 @@ bool BaselineCodeGen<Handler>::emitAndOr(bool branchIfTrue) {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_AND() {
+bool BaselineCodeGen<Handler>::emit_And() {
   return emitAndOr(false);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_OR() {
+bool BaselineCodeGen<Handler>::emit_Or() {
   return emitAndOr(true);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_COALESCE() {
+bool BaselineCodeGen<Handler>::emit_Coalesce() {
   // Coalesce leaves the original value on the stack.
   frame.syncStack(0);
 
@@ -2169,7 +2169,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_COALESCE() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_NOT() {
+bool BaselineCodeGen<Handler>::emit_Not() {
   bool knownBoolean = frame.stackValueHasKnownType(-1, JSVAL_TYPE_BOOLEAN);
 
   // Keep top stack value in R0.
@@ -2186,7 +2186,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_NOT() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_POS() {
+bool BaselineCodeGen<Handler>::emit_Pos() {
   // Keep top stack value in R0.
   frame.popRegsAndSync(1);
 
@@ -2208,7 +2208,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_POS() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_TONUMERIC() {
+bool BaselineCodeGen<Handler>::emit_ToNumeric() {
   // Keep top stack value in R0.
   frame.popRegsAndSync(1);
 
@@ -2230,8 +2230,8 @@ bool BaselineCodeGen<Handler>::emit_JSOP_TONUMERIC() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_LOOPHEAD() {
-  if (!emit_JSOP_JUMPTARGET()) {
+bool BaselineCodeGen<Handler>::emit_LoopHead() {
+  if (!emit_JumpTarget()) {
     return false;
   }
   if (!emitInterruptCheck()) {
@@ -2260,33 +2260,33 @@ bool BaselineCodeGen<Handler>::emitIncExecutionProgressCounter(
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_VOID() {
+bool BaselineCodeGen<Handler>::emit_Void() {
   frame.pop();
   frame.push(UndefinedValue());
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_UNDEFINED() {
+bool BaselineCodeGen<Handler>::emit_Undefined() {
   // If this ever changes, change what JSOp::GImplicitThis does too.
   frame.push(UndefinedValue());
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_HOLE() {
+bool BaselineCodeGen<Handler>::emit_Hole() {
   frame.push(MagicValue(JS_ELEMENTS_HOLE));
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_NULL() {
+bool BaselineCodeGen<Handler>::emit_Null() {
   frame.push(NullValue());
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CHECKISOBJ() {
+bool BaselineCodeGen<Handler>::emit_CheckIsObj() {
   frame.syncStack(0);
   masm.loadValue(frame.addressOfStackValue(-1), R0);
 
@@ -2307,7 +2307,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_CHECKISOBJ() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CHECKISCALLABLE() {
+bool BaselineCodeGen<Handler>::emit_CheckIsCallable() {
   frame.syncStack(0);
   masm.loadValue(frame.addressOfStackValue(-1), R0);
 
@@ -2325,7 +2325,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_CHECKISCALLABLE() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CHECKTHIS() {
+bool BaselineCodeGen<Handler>::emit_CheckThis() {
   frame.syncStack(0);
   masm.loadValue(frame.addressOfStackValue(-1), R0);
 
@@ -2333,7 +2333,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_CHECKTHIS() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CHECKTHISREINIT() {
+bool BaselineCodeGen<Handler>::emit_CheckThisReinit() {
   frame.syncStack(0);
   masm.loadValue(frame.addressOfStackValue(-1), R0);
 
@@ -2368,7 +2368,7 @@ bool BaselineCodeGen<Handler>::emitCheckThis(ValueOperand val, bool reinit) {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CHECKRETURN() {
+bool BaselineCodeGen<Handler>::emit_CheckReturn() {
   MOZ_ASSERT_IF(handler.maybeScript(),
                 handler.maybeScript()->isDerivedClassConstructor());
 
@@ -2404,7 +2404,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_CHECKRETURN() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_FUNCTIONTHIS() {
+bool BaselineCodeGen<Handler>::emit_FunctionThis() {
   MOZ_ASSERT_IF(handler.maybeFunction(), !handler.maybeFunction()->isArrow());
 
   frame.pushThis();
@@ -2436,7 +2436,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_FUNCTIONTHIS() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GLOBALTHIS() {
+bool BaselineCodeGen<Handler>::emit_GlobalThis() {
   frame.syncStack(0);
 
   auto getNonSyntacticThis = [this]() {
@@ -2464,37 +2464,37 @@ bool BaselineCodeGen<Handler>::emit_JSOP_GLOBALTHIS() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_TRUE() {
+bool BaselineCodeGen<Handler>::emit_True() {
   frame.push(BooleanValue(true));
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_FALSE() {
+bool BaselineCodeGen<Handler>::emit_False() {
   frame.push(BooleanValue(false));
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_ZERO() {
+bool BaselineCodeGen<Handler>::emit_Zero() {
   frame.push(Int32Value(0));
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_ONE() {
+bool BaselineCodeGen<Handler>::emit_One() {
   frame.push(Int32Value(1));
   return true;
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_INT8() {
+bool BaselineCompilerCodeGen::emit_Int8() {
   frame.push(Int32Value(GET_INT8(handler.pc())));
   return true;
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_INT8() {
+bool BaselineInterpreterCodeGen::emit_Int8() {
   LoadInt8Operand(masm, R0.scratchReg());
   masm.tagValue(JSVAL_TYPE_INT32, R0.scratchReg(), R0);
   frame.push(R0);
@@ -2502,13 +2502,13 @@ bool BaselineInterpreterCodeGen::emit_JSOP_INT8() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_INT32() {
+bool BaselineCompilerCodeGen::emit_Int32() {
   frame.push(Int32Value(GET_INT32(handler.pc())));
   return true;
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_INT32() {
+bool BaselineInterpreterCodeGen::emit_Int32() {
   LoadInt32Operand(masm, R0.scratchReg());
   masm.tagValue(JSVAL_TYPE_INT32, R0.scratchReg(), R0);
   frame.push(R0);
@@ -2516,13 +2516,13 @@ bool BaselineInterpreterCodeGen::emit_JSOP_INT32() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_UINT16() {
+bool BaselineCompilerCodeGen::emit_Uint16() {
   frame.push(Int32Value(GET_UINT16(handler.pc())));
   return true;
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_UINT16() {
+bool BaselineInterpreterCodeGen::emit_Uint16() {
   LoadUint16Operand(masm, R0.scratchReg());
   masm.tagValue(JSVAL_TYPE_INT32, R0.scratchReg(), R0);
   frame.push(R0);
@@ -2530,13 +2530,13 @@ bool BaselineInterpreterCodeGen::emit_JSOP_UINT16() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_UINT24() {
+bool BaselineCompilerCodeGen::emit_Uint24() {
   frame.push(Int32Value(GET_UINT24(handler.pc())));
   return true;
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_UINT24() {
+bool BaselineInterpreterCodeGen::emit_Uint24() {
   LoadUint24Operand(masm, 0, R0.scratchReg());
   masm.tagValue(JSVAL_TYPE_INT32, R0.scratchReg(), R0);
   frame.push(R0);
@@ -2544,32 +2544,32 @@ bool BaselineInterpreterCodeGen::emit_JSOP_UINT24() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_RESUMEINDEX() {
-  return emit_JSOP_UINT24();
+bool BaselineCodeGen<Handler>::emit_ResumeIndex() {
+  return emit_Uint24();
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_DOUBLE() {
+bool BaselineCompilerCodeGen::emit_Double() {
   frame.push(GET_INLINE_VALUE(handler.pc()));
   return true;
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_DOUBLE() {
+bool BaselineInterpreterCodeGen::emit_Double() {
   LoadInlineValueOperand(masm, R0);
   frame.push(R0);
   return true;
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_BIGINT() {
+bool BaselineCompilerCodeGen::emit_BigInt() {
   BigInt* bi = handler.script()->getBigInt(handler.pc());
   frame.push(BigIntValue(bi));
   return true;
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_BIGINT() {
+bool BaselineInterpreterCodeGen::emit_BigInt() {
   Register scratch1 = R0.scratchReg();
   Register scratch2 = R1.scratchReg();
   loadScriptGCThing(ScriptGCThingType::BigInt, scratch1, scratch2);
@@ -2579,13 +2579,13 @@ bool BaselineInterpreterCodeGen::emit_JSOP_BIGINT() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_STRING() {
+bool BaselineCompilerCodeGen::emit_String() {
   frame.push(StringValue(handler.script()->getAtom(handler.pc())));
   return true;
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_STRING() {
+bool BaselineInterpreterCodeGen::emit_String() {
   Register scratch1 = R0.scratchReg();
   Register scratch2 = R1.scratchReg();
   LoadInt32Operand(masm, scratch1);
@@ -2598,7 +2598,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_STRING() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_SYMBOL() {
+bool BaselineCompilerCodeGen::emit_Symbol() {
   unsigned which = GET_UINT8(handler.pc());
   JS::Symbol* sym = cx->runtime()->wellKnownSymbols->get(which);
   frame.push(SymbolValue(sym));
@@ -2606,7 +2606,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_SYMBOL() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_SYMBOL() {
+bool BaselineInterpreterCodeGen::emit_Symbol() {
   Register scratch1 = R0.scratchReg();
   Register scratch2 = R1.scratchReg();
   LoadUint8Operand(masm, scratch1);
@@ -2630,7 +2630,7 @@ JSObject* BaselineCompilerHandler::maybeNoCloneSingletonObject() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_OBJECT() {
+bool BaselineCodeGen<Handler>::emit_Object() {
   // If we know we don't have to clone the object literal, just push it
   // directly. Note that the interpreter always does the VM call; that's fine
   // because this op is only used in run-once code.
@@ -2656,7 +2656,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_OBJECT() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_CALLSITEOBJ() {
+bool BaselineCompilerCodeGen::emit_CallSiteObj() {
   RootedScript script(cx, handler.script());
   JSObject* cso = ProcessCallSiteObjOperation(cx, script, handler.pc());
   if (!cso) {
@@ -2668,7 +2668,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_CALLSITEOBJ() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_CALLSITEOBJ() {
+bool BaselineInterpreterCodeGen::emit_CallSiteObj() {
   prepareVMCall();
 
   pushBytecodePCArg();
@@ -2686,7 +2686,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_CALLSITEOBJ() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_REGEXP() {
+bool BaselineCodeGen<Handler>::emit_RegExp() {
   prepareVMCall();
   pushScriptGCThingArg(ScriptGCThingType::RegExp, R0.scratchReg(),
                        R1.scratchReg());
@@ -2703,7 +2703,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_REGEXP() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_LAMBDA() {
+bool BaselineCodeGen<Handler>::emit_Lambda() {
   prepareVMCall();
   masm.loadPtr(frame.addressOfEnvironmentChain(), R0.scratchReg());
 
@@ -2723,7 +2723,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_LAMBDA() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_LAMBDA_ARROW() {
+bool BaselineCodeGen<Handler>::emit_LambdaArrow() {
   // Keep pushed newTarget in R0.
   frame.popRegsAndSync(1);
 
@@ -2748,7 +2748,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_LAMBDA_ARROW() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SETFUNNAME() {
+bool BaselineCodeGen<Handler>::emit_SetFunName() {
   frame.popRegsAndSync(2);
 
   frame.push(R0);
@@ -2768,62 +2768,62 @@ bool BaselineCodeGen<Handler>::emit_JSOP_SETFUNNAME() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_BITOR() {
+bool BaselineCodeGen<Handler>::emit_BitOr() {
   return emitBinaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_BITXOR() {
+bool BaselineCodeGen<Handler>::emit_BitXor() {
   return emitBinaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_BITAND() {
+bool BaselineCodeGen<Handler>::emit_BitAnd() {
   return emitBinaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_LSH() {
+bool BaselineCodeGen<Handler>::emit_Lsh() {
   return emitBinaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_RSH() {
+bool BaselineCodeGen<Handler>::emit_Rsh() {
   return emitBinaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_URSH() {
+bool BaselineCodeGen<Handler>::emit_Ursh() {
   return emitBinaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_ADD() {
+bool BaselineCodeGen<Handler>::emit_Add() {
   return emitBinaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SUB() {
+bool BaselineCodeGen<Handler>::emit_Sub() {
   return emitBinaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_MUL() {
+bool BaselineCodeGen<Handler>::emit_Mul() {
   return emitBinaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DIV() {
+bool BaselineCodeGen<Handler>::emit_Div() {
   return emitBinaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_MOD() {
+bool BaselineCodeGen<Handler>::emit_Mod() {
   return emitBinaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_POW() {
+bool BaselineCodeGen<Handler>::emit_Pow() {
   return emitBinaryArith();
 }
 
@@ -2858,52 +2858,52 @@ bool BaselineCodeGen<Handler>::emitUnaryArith() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_BITNOT() {
+bool BaselineCodeGen<Handler>::emit_BitNot() {
   return emitUnaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_NEG() {
+bool BaselineCodeGen<Handler>::emit_Neg() {
   return emitUnaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INC() {
+bool BaselineCodeGen<Handler>::emit_Inc() {
   return emitUnaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DEC() {
+bool BaselineCodeGen<Handler>::emit_Dec() {
   return emitUnaryArith();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_LT() {
+bool BaselineCodeGen<Handler>::emit_Lt() {
   return emitCompare();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_LE() {
+bool BaselineCodeGen<Handler>::emit_Le() {
   return emitCompare();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GT() {
+bool BaselineCodeGen<Handler>::emit_Gt() {
   return emitCompare();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GE() {
+bool BaselineCodeGen<Handler>::emit_Ge() {
   return emitCompare();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_EQ() {
+bool BaselineCodeGen<Handler>::emit_Eq() {
   return emitCompare();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_NE() {
+bool BaselineCodeGen<Handler>::emit_Ne() {
   return emitCompare();
 }
 
@@ -2925,17 +2925,17 @@ bool BaselineCodeGen<Handler>::emitCompare() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_STRICTEQ() {
+bool BaselineCodeGen<Handler>::emit_StrictEq() {
   return emitCompare();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_STRICTNE() {
+bool BaselineCodeGen<Handler>::emit_StrictNe() {
   return emitCompare();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CASE() {
+bool BaselineCodeGen<Handler>::emit_Case() {
   frame.popRegsAndSync(1);
 
   Label done;
@@ -2950,18 +2950,18 @@ bool BaselineCodeGen<Handler>::emit_JSOP_CASE() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DEFAULT() {
+bool BaselineCodeGen<Handler>::emit_Default() {
   frame.pop();
-  return emit_JSOP_GOTO();
+  return emit_Goto();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_LINENO() {
+bool BaselineCodeGen<Handler>::emit_Lineno() {
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_NEWARRAY() {
+bool BaselineCodeGen<Handler>::emit_NewArray() {
   frame.syncStack(0);
 
   // Pass length in R0.
@@ -2976,7 +2976,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_NEWARRAY() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_NEWARRAY_COPYONWRITE() {
+bool BaselineCompilerCodeGen::emit_NewArrayCopyOnWrite() {
   // This is like the interpreter implementation, but we can call
   // getOrFixupCopyOnWriteObject at compile-time.
 
@@ -3003,7 +3003,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_NEWARRAY_COPYONWRITE() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_NEWARRAY_COPYONWRITE() {
+bool BaselineInterpreterCodeGen::emit_NewArrayCopyOnWrite() {
   prepareVMCall();
 
   pushBytecodePCArg();
@@ -3021,7 +3021,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_NEWARRAY_COPYONWRITE() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITELEM_ARRAY() {
+bool BaselineCodeGen<Handler>::emit_InitElemArray() {
   // Keep the object and rhs on the stack.
   frame.syncStack(0);
 
@@ -3040,17 +3040,17 @@ bool BaselineCodeGen<Handler>::emit_JSOP_INITELEM_ARRAY() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_NEWOBJECT() {
+bool BaselineCodeGen<Handler>::emit_NewObject() {
   return emitNewObject();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_NEWOBJECT_WITHGROUP() {
+bool BaselineCodeGen<Handler>::emit_NewObjectWithGroup() {
   return emitNewObject();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_NEWINIT() {
+bool BaselineCodeGen<Handler>::emit_NewInit() {
   return emitNewObject();
 }
 
@@ -3067,7 +3067,7 @@ bool BaselineCodeGen<Handler>::emitNewObject() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITELEM() {
+bool BaselineCodeGen<Handler>::emit_InitElem() {
   // Store RHS in the scratch slot.
   frame.storeStackValue(-1, frame.addressOfScratchValue(), R2);
   frame.pop();
@@ -3093,12 +3093,12 @@ bool BaselineCodeGen<Handler>::emit_JSOP_INITELEM() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITHIDDENELEM() {
-  return emit_JSOP_INITELEM();
+bool BaselineCodeGen<Handler>::emit_InitHiddenElem() {
+  return emit_InitElem();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_MUTATEPROTO() {
+bool BaselineCodeGen<Handler>::emit_MutateProto() {
   // Keep values on the stack for the decompiler.
   frame.syncStack(0);
 
@@ -3120,7 +3120,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_MUTATEPROTO() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITPROP() {
+bool BaselineCodeGen<Handler>::emit_InitProp() {
   // Load lhs in R0, rhs in R1.
   frame.syncStack(0);
   masm.loadValue(frame.addressOfStackValue(-2), R0);
@@ -3137,17 +3137,17 @@ bool BaselineCodeGen<Handler>::emit_JSOP_INITPROP() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITLOCKEDPROP() {
-  return emit_JSOP_INITPROP();
+bool BaselineCodeGen<Handler>::emit_InitLockedProp() {
+  return emit_InitProp();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITHIDDENPROP() {
-  return emit_JSOP_INITPROP();
+bool BaselineCodeGen<Handler>::emit_InitHiddenProp() {
+  return emit_InitProp();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GETELEM() {
+bool BaselineCodeGen<Handler>::emit_GetElem() {
   // Keep top two stack values in R0 and R1.
   frame.popRegsAndSync(2);
 
@@ -3162,7 +3162,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_GETELEM() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GETELEM_SUPER() {
+bool BaselineCodeGen<Handler>::emit_GetElemSuper() {
   // Store obj in the scratch slot.
   frame.storeStackValue(-1, frame.addressOfScratchValue(), R2);
   frame.pop();
@@ -3183,12 +3183,12 @@ bool BaselineCodeGen<Handler>::emit_JSOP_GETELEM_SUPER() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CALLELEM() {
-  return emit_JSOP_GETELEM();
+bool BaselineCodeGen<Handler>::emit_CallElem() {
+  return emit_GetElem();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SETELEM() {
+bool BaselineCodeGen<Handler>::emit_SetElem() {
   // Store RHS in the scratch slot.
   frame.storeStackValue(-1, frame.addressOfScratchValue(), R2);
   frame.pop();
@@ -3208,8 +3208,8 @@ bool BaselineCodeGen<Handler>::emit_JSOP_SETELEM() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_STRICTSETELEM() {
-  return emit_JSOP_SETELEM();
+bool BaselineCodeGen<Handler>::emit_StrictSetElem() {
+  return emit_SetElem();
 }
 
 template <typename Handler>
@@ -3243,12 +3243,12 @@ bool BaselineCodeGen<Handler>::emitSetElemSuper(bool strict) {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SETELEM_SUPER() {
+bool BaselineCodeGen<Handler>::emit_SetElemSuper() {
   return emitSetElemSuper(/* strict = */ false);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_STRICTSETELEM_SUPER() {
+bool BaselineCodeGen<Handler>::emit_StrictSetElemSuper() {
   return emitSetElemSuper(/* strict = */ true);
 }
 
@@ -3282,17 +3282,17 @@ bool BaselineCodeGen<Handler>::emitDelElem(bool strict) {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DELELEM() {
+bool BaselineCodeGen<Handler>::emit_DelElem() {
   return emitDelElem(/* strict = */ false);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_STRICTDELELEM() {
+bool BaselineCodeGen<Handler>::emit_StrictDelElem() {
   return emitDelElem(/* strict = */ true);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_IN() {
+bool BaselineCodeGen<Handler>::emit_In() {
   frame.popRegsAndSync(2);
 
   if (!emitNextIC()) {
@@ -3304,7 +3304,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_IN() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_HASOWN() {
+bool BaselineCodeGen<Handler>::emit_HasOwn() {
   frame.popRegsAndSync(2);
 
   if (!emitNextIC()) {
@@ -3343,8 +3343,8 @@ bool BaselineInterpreterCodeGen::tryOptimizeGetGlobalName() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GETGNAME() {
-  auto getName = [this]() { return emit_JSOP_GETNAME(); };
+bool BaselineCodeGen<Handler>::emit_GetGName() {
+  auto getName = [this]() { return emit_GetName(); };
 
   auto getGlobalName = [this]() {
     if (tryOptimizeGetGlobalName()) {
@@ -3411,7 +3411,7 @@ bool BaselineInterpreterCodeGen::tryOptimizeBindGlobalName() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_BINDGNAME() {
+bool BaselineCodeGen<Handler>::emit_BindGName() {
   if (tryOptimizeBindGlobalName()) {
     return true;
   }
@@ -3419,7 +3419,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_BINDGNAME() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_BINDVAR() {
+bool BaselineCodeGen<Handler>::emit_BindVar() {
   frame.syncStack(0);
   masm.loadPtr(frame.addressOfEnvironmentChain(), R0.scratchReg());
 
@@ -3437,7 +3437,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_BINDVAR() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SETPROP() {
+bool BaselineCodeGen<Handler>::emit_SetProp() {
   // Keep lhs in R0, rhs in R1.
   frame.popRegsAndSync(2);
 
@@ -3454,28 +3454,28 @@ bool BaselineCodeGen<Handler>::emit_JSOP_SETPROP() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_STRICTSETPROP() {
-  return emit_JSOP_SETPROP();
+bool BaselineCodeGen<Handler>::emit_StrictSetProp() {
+  return emit_SetProp();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SETNAME() {
-  return emit_JSOP_SETPROP();
+bool BaselineCodeGen<Handler>::emit_SetName() {
+  return emit_SetProp();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_STRICTSETNAME() {
-  return emit_JSOP_SETPROP();
+bool BaselineCodeGen<Handler>::emit_StrictSetName() {
+  return emit_SetProp();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SETGNAME() {
-  return emit_JSOP_SETPROP();
+bool BaselineCodeGen<Handler>::emit_SetGName() {
+  return emit_SetProp();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_STRICTSETGNAME() {
-  return emit_JSOP_SETPROP();
+bool BaselineCodeGen<Handler>::emit_StrictSetGName() {
+  return emit_SetProp();
 }
 
 template <typename Handler>
@@ -3508,17 +3508,17 @@ bool BaselineCodeGen<Handler>::emitSetPropSuper(bool strict) {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SETPROP_SUPER() {
+bool BaselineCodeGen<Handler>::emit_SetPropSuper() {
   return emitSetPropSuper(/* strict = */ false);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_STRICTSETPROP_SUPER() {
+bool BaselineCodeGen<Handler>::emit_StrictSetPropSuper() {
   return emitSetPropSuper(/* strict = */ true);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GETPROP() {
+bool BaselineCodeGen<Handler>::emit_GetProp() {
   // Keep object in R0.
   frame.popRegsAndSync(1);
 
@@ -3533,22 +3533,22 @@ bool BaselineCodeGen<Handler>::emit_JSOP_GETPROP() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CALLPROP() {
-  return emit_JSOP_GETPROP();
+bool BaselineCodeGen<Handler>::emit_CallProp() {
+  return emit_GetProp();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_LENGTH() {
-  return emit_JSOP_GETPROP();
+bool BaselineCodeGen<Handler>::emit_Length() {
+  return emit_GetProp();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GETBOUNDNAME() {
-  return emit_JSOP_GETPROP();
+bool BaselineCodeGen<Handler>::emit_GetBoundName() {
+  return emit_GetProp();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GETPROP_SUPER() {
+bool BaselineCodeGen<Handler>::emit_GetPropSuper() {
   // Receiver -> R1, Object -> R0
   frame.popRegsAndSync(1);
   masm.loadValue(frame.addressOfStackValue(-1), R1);
@@ -3591,12 +3591,12 @@ bool BaselineCodeGen<Handler>::emitDelProp(bool strict) {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DELPROP() {
+bool BaselineCodeGen<Handler>::emit_DelProp() {
   return emitDelProp(/* strict = */ false);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_STRICTDELPROP() {
+bool BaselineCodeGen<Handler>::emit_StrictDelProp() {
   return emitDelProp(/* strict = */ true);
 }
 
@@ -3706,7 +3706,7 @@ void BaselineInterpreterCodeGen::emitGetAliasedVar(ValueOperand dest) {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GETALIASEDVAR() {
+bool BaselineCodeGen<Handler>::emit_GetAliasedVar() {
   emitGetAliasedVar(R0);
 
   if (handler.maybeIonCompileable()) {
@@ -3721,7 +3721,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_GETALIASEDVAR() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_SETALIASEDVAR() {
+bool BaselineCompilerCodeGen::emit_SetAliasedVar() {
   // Keep rvalue in R0.
   frame.popRegsAndSync(1);
   Register objReg = R2.scratchReg();
@@ -3748,7 +3748,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_SETALIASEDVAR() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_SETALIASEDVAR() {
+bool BaselineInterpreterCodeGen::emit_SetAliasedVar() {
   AllocatableGeneralRegisterSet regs(GeneralRegisterSet::All());
   regs.take(BaselineFrameReg);
   regs.take(R2);
@@ -3817,7 +3817,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_SETALIASEDVAR() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GETNAME() {
+bool BaselineCodeGen<Handler>::emit_GetName() {
   frame.syncStack(0);
 
   masm.loadPtr(frame.addressOfEnvironmentChain(), R0.scratchReg());
@@ -3871,12 +3871,12 @@ bool BaselineCodeGen<Handler>::emitBindName(JSOp op) {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_BINDNAME() {
+bool BaselineCodeGen<Handler>::emit_BindName() {
   return emitBindName(JSOP_BINDNAME);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DELNAME() {
+bool BaselineCodeGen<Handler>::emit_DelName() {
   frame.syncStack(0);
   masm.loadPtr(frame.addressOfEnvironmentChain(), R0.scratchReg());
 
@@ -3896,7 +3896,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_DELNAME() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_GETIMPORT() {
+bool BaselineCompilerCodeGen::emit_GetImport() {
   JSScript* script = handler.script();
   ModuleEnvironmentObject* env = GetModuleEnvironmentForScript(script);
   MOZ_ASSERT(env);
@@ -3943,7 +3943,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_GETIMPORT() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_GETIMPORT() {
+bool BaselineInterpreterCodeGen::emit_GetImport() {
   frame.syncStack(0);
 
   masm.loadPtr(frame.addressOfEnvironmentChain(), R0.scratchReg());
@@ -3970,7 +3970,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_GETIMPORT() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GETINTRINSIC() {
+bool BaselineCodeGen<Handler>::emit_GetIntrinsic() {
   frame.syncStack(0);
 
   if (!emitNextIC()) {
@@ -3982,7 +3982,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_GETINTRINSIC() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SETINTRINSIC() {
+bool BaselineCodeGen<Handler>::emit_SetIntrinsic() {
   frame.syncStack(0);
   masm.loadValue(frame.addressOfStackValue(-1), R0);
 
@@ -3997,7 +3997,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_SETINTRINSIC() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DEFVAR() {
+bool BaselineCodeGen<Handler>::emit_DefVar() {
   frame.syncStack(0);
 
   masm.loadPtr(frame.addressOfEnvironmentChain(), R0.scratchReg());
@@ -4031,17 +4031,17 @@ bool BaselineCodeGen<Handler>::emitDefLexical(JSOp op) {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DEFCONST() {
+bool BaselineCodeGen<Handler>::emit_DefConst() {
   return emitDefLexical(JSOP_DEFCONST);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DEFLET() {
+bool BaselineCodeGen<Handler>::emit_DefLet() {
   return emitDefLexical(JSOP_DEFLET);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DEFFUN() {
+bool BaselineCodeGen<Handler>::emit_DefFun() {
   frame.popRegsAndSync(1);
   masm.unboxObject(R0, R0.scratchReg());
   masm.loadPtr(frame.addressOfEnvironmentChain(), R1.scratchReg());
@@ -4082,22 +4082,22 @@ bool BaselineCodeGen<Handler>::emitInitPropGetterSetter() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITPROP_GETTER() {
+bool BaselineCodeGen<Handler>::emit_InitPropGetter() {
   return emitInitPropGetterSetter();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITHIDDENPROP_GETTER() {
+bool BaselineCodeGen<Handler>::emit_InitHiddenPropGetter() {
   return emitInitPropGetterSetter();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITPROP_SETTER() {
+bool BaselineCodeGen<Handler>::emit_InitPropSetter() {
   return emitInitPropGetterSetter();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITHIDDENPROP_SETTER() {
+bool BaselineCodeGen<Handler>::emit_InitHiddenPropSetter() {
   return emitInitPropGetterSetter();
 }
 
@@ -4128,27 +4128,27 @@ bool BaselineCodeGen<Handler>::emitInitElemGetterSetter() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITELEM_GETTER() {
+bool BaselineCodeGen<Handler>::emit_InitElemGetter() {
   return emitInitElemGetterSetter();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITHIDDENELEM_GETTER() {
+bool BaselineCodeGen<Handler>::emit_InitHiddenElemGetter() {
   return emitInitElemGetterSetter();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITELEM_SETTER() {
+bool BaselineCodeGen<Handler>::emit_InitElemSetter() {
   return emitInitElemGetterSetter();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITHIDDENELEM_SETTER() {
+bool BaselineCodeGen<Handler>::emit_InitHiddenElemSetter() {
   return emitInitElemGetterSetter();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITELEM_INC() {
+bool BaselineCodeGen<Handler>::emit_InitElemInc() {
   // Keep the object and rhs on the stack.
   frame.syncStack(0);
 
@@ -4177,7 +4177,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_INITELEM_INC() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_GETLOCAL() {
+bool BaselineCompilerCodeGen::emit_GetLocal() {
   frame.pushLocal(GET_LOCALNO(handler.pc()));
   return true;
 }
@@ -4192,7 +4192,7 @@ static BaseValueIndex ComputeAddressOfLocal(MacroAssembler& masm,
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_GETLOCAL() {
+bool BaselineInterpreterCodeGen::emit_GetLocal() {
   Register scratch = R0.scratchReg();
   LoadUint24Operand(masm, 0, scratch);
   BaseValueIndex addr = ComputeAddressOfLocal(masm, scratch);
@@ -4202,7 +4202,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_GETLOCAL() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_SETLOCAL() {
+bool BaselineCompilerCodeGen::emit_SetLocal() {
   // Ensure no other StackValue refers to the old value, for instance i + (i =
   // 3). This also allows us to use R0 as scratch below.
   frame.syncStack(1);
@@ -4213,7 +4213,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_SETLOCAL() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_SETLOCAL() {
+bool BaselineInterpreterCodeGen::emit_SetLocal() {
   Register scratch = R0.scratchReg();
   LoadUint24Operand(masm, 0, scratch);
   BaseValueIndex addr = ComputeAddressOfLocal(masm, scratch);
@@ -4234,7 +4234,7 @@ bool BaselineCompilerCodeGen::emitFormalArgAccess(JSOp op) {
     if (op == JSOP_GETARG) {
       frame.pushArg(arg);
     } else {
-      // See the comment in emit_JSOP_SETLOCAL.
+      // See the comment in emit_SetLocal.
       frame.syncStack(1);
       frame.storeStackValue(-1, frame.addressOfArg(arg), R0);
     }
@@ -4364,12 +4364,12 @@ bool BaselineInterpreterCodeGen::emitFormalArgAccess(JSOp op) {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GETARG() {
+bool BaselineCodeGen<Handler>::emit_GetArg() {
   return emitFormalArgAccess(JSOP_GETARG);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SETARG() {
+bool BaselineCodeGen<Handler>::emit_SetArg() {
   return emitFormalArgAccess(JSOP_SETARG);
 }
 
@@ -4415,7 +4415,7 @@ void BaselineCodeGen<Handler>::emitPushNonArrowFunctionNewTarget() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_NEWTARGET() {
+bool BaselineCompilerCodeGen::emit_NewTarget() {
   if (handler.script()->isForEval()) {
     frame.pushEvalNewTarget();
     return true;
@@ -4440,7 +4440,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_NEWTARGET() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_NEWTARGET() {
+bool BaselineInterpreterCodeGen::emit_NewTarget() {
   Register scratch1 = R0.scratchReg();
   Register scratch2 = R1.scratchReg();
 
@@ -4487,17 +4487,17 @@ bool BaselineCodeGen<Handler>::emitThrowConstAssignment() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_THROWSETCONST() {
+bool BaselineCodeGen<Handler>::emit_ThrowSetConst() {
   return emitThrowConstAssignment();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_THROWSETALIASEDCONST() {
+bool BaselineCodeGen<Handler>::emit_ThrowSetAliasedConst() {
   return emitThrowConstAssignment();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_THROWSETCALLEE() {
+bool BaselineCodeGen<Handler>::emit_ThrowSetCallee() {
   return emitThrowConstAssignment();
 }
 
@@ -4521,14 +4521,14 @@ bool BaselineCodeGen<Handler>::emitUninitializedLexicalCheck(
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_CHECKLEXICAL() {
+bool BaselineCompilerCodeGen::emit_CheckLexical() {
   frame.syncStack(0);
   masm.loadValue(frame.addressOfLocal(GET_LOCALNO(handler.pc())), R0);
   return emitUninitializedLexicalCheck(R0);
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_CHECKLEXICAL() {
+bool BaselineInterpreterCodeGen::emit_CheckLexical() {
   Register scratch = R0.scratchReg();
   LoadUint24Operand(masm, 0, scratch);
   BaseValueIndex addr = ComputeAddressOfLocal(masm, scratch);
@@ -4537,32 +4537,32 @@ bool BaselineInterpreterCodeGen::emit_JSOP_CHECKLEXICAL() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITLEXICAL() {
-  return emit_JSOP_SETLOCAL();
+bool BaselineCodeGen<Handler>::emit_InitLexical() {
+  return emit_SetLocal();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITGLEXICAL() {
+bool BaselineCodeGen<Handler>::emit_InitGLexical() {
   frame.popRegsAndSync(1);
   pushGlobalLexicalEnvironmentValue(R1);
   frame.push(R0);
-  return emit_JSOP_SETPROP();
+  return emit_SetProp();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CHECKALIASEDLEXICAL() {
+bool BaselineCodeGen<Handler>::emit_CheckAliasedLexical() {
   frame.syncStack(0);
   emitGetAliasedVar(R0);
   return emitUninitializedLexicalCheck(R0);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITALIASEDLEXICAL() {
-  return emit_JSOP_SETALIASEDVAR();
+bool BaselineCodeGen<Handler>::emit_InitAliasedLexical() {
+  return emit_SetAliasedVar();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_UNINITIALIZED() {
+bool BaselineCodeGen<Handler>::emit_Uninitialized() {
   frame.push(MagicValue(JS_UNINITIALIZED_LEXICAL));
   return true;
 }
@@ -4630,77 +4630,77 @@ bool BaselineCodeGen<Handler>::emitSpreadCall(JSOp op) {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CALL() {
+bool BaselineCodeGen<Handler>::emit_Call() {
   return emitCall(JSOP_CALL);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CALL_IGNORES_RV() {
+bool BaselineCodeGen<Handler>::emit_CallIgnoresRv() {
   return emitCall(JSOP_CALL_IGNORES_RV);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CALLITER() {
+bool BaselineCodeGen<Handler>::emit_CallIter() {
   return emitCall(JSOP_CALLITER);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_NEW() {
+bool BaselineCodeGen<Handler>::emit_New() {
   return emitCall(JSOP_NEW);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SUPERCALL() {
+bool BaselineCodeGen<Handler>::emit_SuperCall() {
   return emitCall(JSOP_SUPERCALL);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_FUNCALL() {
+bool BaselineCodeGen<Handler>::emit_FunCall() {
   return emitCall(JSOP_FUNCALL);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_FUNAPPLY() {
+bool BaselineCodeGen<Handler>::emit_FunApply() {
   return emitCall(JSOP_FUNAPPLY);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_EVAL() {
+bool BaselineCodeGen<Handler>::emit_Eval() {
   return emitCall(JSOP_EVAL);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_STRICTEVAL() {
+bool BaselineCodeGen<Handler>::emit_StrictEval() {
   return emitCall(JSOP_STRICTEVAL);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SPREADCALL() {
+bool BaselineCodeGen<Handler>::emit_SpreadCall() {
   return emitSpreadCall(JSOP_SPREADCALL);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SPREADNEW() {
+bool BaselineCodeGen<Handler>::emit_SpreadNew() {
   return emitSpreadCall(JSOP_SPREADNEW);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SPREADSUPERCALL() {
+bool BaselineCodeGen<Handler>::emit_SpreadSuperCall() {
   return emitSpreadCall(JSOP_SPREADSUPERCALL);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SPREADEVAL() {
+bool BaselineCodeGen<Handler>::emit_SpreadEval() {
   return emitSpreadCall(JSOP_SPREADEVAL);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_STRICTSPREADEVAL() {
+bool BaselineCodeGen<Handler>::emit_StrictSpreadEval() {
   return emitSpreadCall(JSOP_STRICTSPREADEVAL);
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_OPTIMIZE_SPREADCALL() {
+bool BaselineCodeGen<Handler>::emit_OptimizeSpreadCall() {
   frame.syncStack(0);
   masm.loadValue(frame.addressOfStackValue(-1), R0);
 
@@ -4718,7 +4718,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_OPTIMIZE_SPREADCALL() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_IMPLICITTHIS() {
+bool BaselineCodeGen<Handler>::emit_ImplicitThis() {
   frame.syncStack(0);
   masm.loadPtr(frame.addressOfEnvironmentChain(), R0.scratchReg());
 
@@ -4738,18 +4738,18 @@ bool BaselineCodeGen<Handler>::emit_JSOP_IMPLICITTHIS() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GIMPLICITTHIS() {
+bool BaselineCodeGen<Handler>::emit_GImplicitThis() {
   auto pushUndefined = [this]() {
     frame.push(UndefinedValue());
     return true;
   };
-  auto emitImplicitThis = [this]() { return emit_JSOP_IMPLICITTHIS(); };
+  auto emitImplicitThis = [this]() { return emit_ImplicitThis(); };
   return emitTestScriptFlag(JSScript::ImmutableFlags::HasNonSyntacticScope,
                             emitImplicitThis, pushUndefined, R2.scratchReg());
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INSTANCEOF() {
+bool BaselineCodeGen<Handler>::emit_Instanceof() {
   frame.popRegsAndSync(2);
 
   if (!emitNextIC()) {
@@ -4761,7 +4761,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_INSTANCEOF() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_TYPEOF() {
+bool BaselineCodeGen<Handler>::emit_Typeof() {
   frame.popRegsAndSync(1);
 
   if (!emitNextIC()) {
@@ -4773,12 +4773,12 @@ bool BaselineCodeGen<Handler>::emit_JSOP_TYPEOF() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_TYPEOFEXPR() {
-  return emit_JSOP_TYPEOF();
+bool BaselineCodeGen<Handler>::emit_TypeofExpr() {
+  return emit_Typeof();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_THROWMSG() {
+bool BaselineCodeGen<Handler>::emit_ThrowMsg() {
   prepareVMCall();
   pushUint16BytecodeOperandArg(R2.scratchReg());
 
@@ -4787,7 +4787,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_THROWMSG() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_THROW() {
+bool BaselineCodeGen<Handler>::emit_Throw() {
   // Keep value to throw in R0.
   frame.popRegsAndSync(1);
 
@@ -4799,12 +4799,12 @@ bool BaselineCodeGen<Handler>::emit_JSOP_THROW() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_TRY() {
+bool BaselineCodeGen<Handler>::emit_Try() {
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_FINALLY() {
+bool BaselineCodeGen<Handler>::emit_Finally() {
   // JSOp::Finally has a def count of 2, but these values are already on the
   // stack (they're pushed by JSOp::Gosub). Update the compiler's stack state.
   frame.incStackDepth(2);
@@ -4815,7 +4815,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_FINALLY() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GOSUB() {
+bool BaselineCodeGen<Handler>::emit_Gosub() {
   // Jump to the finally block.
   frame.syncStack(0);
   emitJump();
@@ -4880,7 +4880,7 @@ void BaselineInterpreterCodeGen::jumpToResumeEntry(Register resumeIndex,
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_RETSUB() {
+bool BaselineCodeGen<Handler>::emit_Retsub() {
   frame.popRegsAndSync(2);
 
   Label isReturn;
@@ -4962,7 +4962,7 @@ MOZ_MUST_USE bool BaselineInterpreterCodeGen::emitDebugInstrumentation(
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_PUSHLEXICALENV() {
+bool BaselineCodeGen<Handler>::emit_PushLexicalEnv() {
   // Call a stub to push the block on the block chain.
   prepareVMCall();
   masm.loadBaselineFramePtr(BaselineFrameReg, R0.scratchReg());
@@ -4976,7 +4976,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_PUSHLEXICALENV() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_POPLEXICALENV() {
+bool BaselineCodeGen<Handler>::emit_PopLexicalEnv() {
   frame.syncStack(0);
 
   masm.loadBaselineFramePtr(BaselineFrameReg, R0.scratchReg());
@@ -5000,7 +5000,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_POPLEXICALENV() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_FRESHENLEXICALENV() {
+bool BaselineCodeGen<Handler>::emit_FreshenLexicalEnv() {
   frame.syncStack(0);
 
   masm.loadBaselineFramePtr(BaselineFrameReg, R0.scratchReg());
@@ -5024,7 +5024,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_FRESHENLEXICALENV() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_RECREATELEXICALENV() {
+bool BaselineCodeGen<Handler>::emit_RecreateLexicalEnv() {
   frame.syncStack(0);
 
   masm.loadBaselineFramePtr(BaselineFrameReg, R0.scratchReg());
@@ -5048,7 +5048,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_RECREATELEXICALENV() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DEBUGLEAVELEXICALENV() {
+bool BaselineCodeGen<Handler>::emit_DebugLeaveLexicalEnv() {
   auto ifDebuggee = [this]() {
     prepareVMCall();
     masm.loadBaselineFramePtr(BaselineFrameReg, R0.scratchReg());
@@ -5062,7 +5062,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_DEBUGLEAVELEXICALENV() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_PUSHVARENV() {
+bool BaselineCodeGen<Handler>::emit_PushVarEnv() {
   prepareVMCall();
   masm.loadBaselineFramePtr(BaselineFrameReg, R0.scratchReg());
   pushScriptGCThingArg(ScriptGCThingType::Scope, R1.scratchReg(),
@@ -5074,7 +5074,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_PUSHVARENV() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_POPVARENV() {
+bool BaselineCodeGen<Handler>::emit_PopVarEnv() {
   prepareVMCall();
   masm.loadBaselineFramePtr(BaselineFrameReg, R0.scratchReg());
   pushArg(R0.scratchReg());
@@ -5084,7 +5084,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_POPVARENV() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_ENTERWITH() {
+bool BaselineCodeGen<Handler>::emit_EnterWith() {
   // Pop "with" object to R0.
   frame.popRegsAndSync(1);
 
@@ -5103,7 +5103,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_ENTERWITH() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_LEAVEWITH() {
+bool BaselineCodeGen<Handler>::emit_LeaveWith() {
   // Call a stub to pop the with object from the environment chain.
   prepareVMCall();
 
@@ -5115,7 +5115,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_LEAVEWITH() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_EXCEPTION() {
+bool BaselineCodeGen<Handler>::emit_Exception() {
   prepareVMCall();
 
   using Fn = bool (*)(JSContext*, MutableHandleValue);
@@ -5128,7 +5128,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_EXCEPTION() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DEBUGGER() {
+bool BaselineCodeGen<Handler>::emit_Debugger() {
   prepareVMCall();
 
   frame.assertSyncedStack();
@@ -5190,7 +5190,7 @@ bool BaselineCodeGen<Handler>::emitReturn() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_RETURN() {
+bool BaselineCodeGen<Handler>::emit_Return() {
   frame.assertStackDepth(1);
 
   frame.popValue(JSReturnOperand);
@@ -5212,7 +5212,7 @@ void BaselineCodeGen<Handler>::emitLoadReturnValue(ValueOperand val) {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_RETRVAL() {
+bool BaselineCodeGen<Handler>::emit_RetRval() {
   frame.assertStackDepth(0);
 
   masm.moveValue(UndefinedValue(), JSReturnOperand);
@@ -5231,7 +5231,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_RETRVAL() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_TOID() {
+bool BaselineCodeGen<Handler>::emit_ToId() {
   // Load index in R0, but keep values on the stack for the decompiler.
   frame.syncStack(0);
   masm.loadValue(frame.addressOfStackValue(-1), R0);
@@ -5258,7 +5258,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_TOID() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_TOASYNCITER() {
+bool BaselineCodeGen<Handler>::emit_ToAsyncIter() {
   frame.syncStack(0);
   masm.unboxObject(frame.addressOfStackValue(-2), R0.scratchReg());
   masm.loadValue(frame.addressOfStackValue(-1), R1);
@@ -5279,7 +5279,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_TOASYNCITER() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_TRYSKIPAWAIT() {
+bool BaselineCodeGen<Handler>::emit_TrySkipAwait() {
   frame.syncStack(0);
   masm.loadValue(frame.addressOfStackValue(-1), R0);
 
@@ -5310,7 +5310,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_TRYSKIPAWAIT() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_ASYNCAWAIT() {
+bool BaselineCodeGen<Handler>::emit_AsyncAwait() {
   frame.syncStack(0);
   masm.loadValue(frame.addressOfStackValue(-2), R1);
   masm.unboxObject(frame.addressOfStackValue(-1), R0.scratchReg());
@@ -5332,7 +5332,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_ASYNCAWAIT() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_ASYNCRESOLVE() {
+bool BaselineCodeGen<Handler>::emit_AsyncResolve() {
   frame.syncStack(0);
   masm.loadValue(frame.addressOfStackValue(-2), R1);
   masm.unboxObject(frame.addressOfStackValue(-1), R0.scratchReg());
@@ -5355,7 +5355,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_ASYNCRESOLVE() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CHECKOBJCOERCIBLE() {
+bool BaselineCodeGen<Handler>::emit_CheckObjCoercible() {
   frame.syncStack(0);
   masm.loadValue(frame.addressOfStackValue(-1), R0);
 
@@ -5379,7 +5379,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_CHECKOBJCOERCIBLE() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_TOSTRING() {
+bool BaselineCodeGen<Handler>::emit_ToString() {
   // Keep top stack value in R0.
   frame.popRegsAndSync(1);
 
@@ -5495,7 +5495,7 @@ void BaselineInterpreterCodeGen::emitTableSwitchJump(Register key,
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_TABLESWITCH() {
+bool BaselineCodeGen<Handler>::emit_TableSwitch() {
   frame.popRegsAndSync(1);
 
   Register key = R0.scratchReg();
@@ -5516,7 +5516,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_TABLESWITCH() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_ITER() {
+bool BaselineCodeGen<Handler>::emit_Iter() {
   frame.popRegsAndSync(1);
 
   if (!emitNextIC()) {
@@ -5528,7 +5528,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_ITER() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_MOREITER() {
+bool BaselineCodeGen<Handler>::emit_MoreIter() {
   frame.syncStack(0);
 
   masm.unboxObject(frame.addressOfStackValue(-1), R1.scratchReg());
@@ -5557,12 +5557,12 @@ bool BaselineCodeGen<Handler>::emitIsMagicValue() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_ISNOITER() {
+bool BaselineCodeGen<Handler>::emit_IsNoIter() {
   return emitIsMagicValue();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_ENDITER() {
+bool BaselineCodeGen<Handler>::emit_EndIter() {
   // Pop iterator value.
   frame.pop();
 
@@ -5587,12 +5587,12 @@ bool BaselineCodeGen<Handler>::emit_JSOP_ENDITER() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_ISGENCLOSING() {
+bool BaselineCodeGen<Handler>::emit_IsGenClosing() {
   return emitIsMagicValue();
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GETRVAL() {
+bool BaselineCodeGen<Handler>::emit_GetRval() {
   frame.syncStack(0);
 
   emitLoadReturnValue(R0);
@@ -5602,7 +5602,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_GETRVAL() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SETRVAL() {
+bool BaselineCodeGen<Handler>::emit_SetRval() {
   // Store to the frame's return value slot.
   frame.storeStackValue(-1, frame.addressOfReturnValue(), R2);
   masm.or32(Imm32(BaselineFrame::HAS_RVAL), frame.addressOfFlags());
@@ -5611,7 +5611,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_SETRVAL() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CALLEE() {
+bool BaselineCodeGen<Handler>::emit_Callee() {
   MOZ_ASSERT_IF(handler.maybeScript(), handler.maybeScript()->function());
   frame.syncStack(0);
   masm.loadFunctionFromCalleeToken(frame.addressOfCalleeToken(),
@@ -5622,7 +5622,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_CALLEE() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_ENVCALLEE() {
+bool BaselineCompilerCodeGen::emit_EnvCallee() {
   frame.syncStack(0);
   uint8_t numHops = GET_UINT8(handler.pc());
   Register scratch = R0.scratchReg();
@@ -5640,7 +5640,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_ENVCALLEE() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_ENVCALLEE() {
+bool BaselineInterpreterCodeGen::emit_EnvCallee() {
   Register scratch = R0.scratchReg();
   Register env = R1.scratchReg();
 
@@ -5656,7 +5656,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_ENVCALLEE() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SUPERBASE() {
+bool BaselineCodeGen<Handler>::emit_SuperBase() {
   frame.popRegsAndSync(1);
 
   Register scratch = R0.scratchReg();
@@ -5701,7 +5701,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_SUPERBASE() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_SUPERFUN() {
+bool BaselineCodeGen<Handler>::emit_SuperFun() {
   frame.popRegsAndSync(1);
 
   Register callee = R0.scratchReg();
@@ -5751,7 +5751,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_SUPERFUN() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_ARGUMENTS() {
+bool BaselineCodeGen<Handler>::emit_Arguments() {
   frame.syncStack(0);
 
   MOZ_ASSERT_IF(handler.maybeScript(),
@@ -5788,7 +5788,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_ARGUMENTS() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_REST() {
+bool BaselineCodeGen<Handler>::emit_Rest() {
   frame.syncStack(0);
 
   if (!emitNextIC()) {
@@ -5801,7 +5801,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_REST() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_GENERATOR() {
+bool BaselineCodeGen<Handler>::emit_Generator() {
   frame.assertStackDepth(0);
 
   masm.loadBaselineFramePtr(BaselineFrameReg, R0.scratchReg());
@@ -5820,7 +5820,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_GENERATOR() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITIALYIELD() {
+bool BaselineCodeGen<Handler>::emit_InitialYield() {
   frame.syncStack(0);
   frame.assertStackDepth(1);
 
@@ -5860,7 +5860,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_INITIALYIELD() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_YIELD() {
+bool BaselineCodeGen<Handler>::emit_Yield() {
   // Store generator in R0.
   frame.popRegsAndSync(1);
 
@@ -5922,8 +5922,8 @@ bool BaselineCodeGen<Handler>::emit_JSOP_YIELD() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_AWAIT() {
-  return emit_JSOP_YIELD();
+bool BaselineCodeGen<Handler>::emit_Await() {
+  return emit_Yield();
 }
 
 template <>
@@ -5963,8 +5963,8 @@ bool BaselineInterpreterCodeGen::emitAfterYieldDebugInstrumentation(
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_AFTERYIELD() {
-  if (!emit_JSOP_JUMPTARGET()) {
+bool BaselineCodeGen<Handler>::emit_AfterYield() {
+  if (!emit_JumpTarget()) {
     return false;
   }
 
@@ -5987,7 +5987,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_AFTERYIELD() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_FINALYIELDRVAL() {
+bool BaselineCodeGen<Handler>::emit_FinalYieldRval() {
   // Store generator in R0.
   frame.popRegsAndSync(1);
   masm.unboxObject(R0, R0.scratchReg());
@@ -6054,7 +6054,7 @@ bool BaselineCodeGen<Handler>::emitEnterGeneratorCode(Register script,
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_RESUME() {
+bool BaselineCodeGen<Handler>::emit_Resume() {
   frame.syncStack(0);
   masm.assertStackAlignment(sizeof(Value), 0);
 
@@ -6283,7 +6283,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_RESUME() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CHECK_RESUMEKIND() {
+bool BaselineCodeGen<Handler>::emit_CheckResumeKind() {
   // Load resumeKind in R1, generator in R0.
   frame.popRegsAndSync(2);
 
@@ -6324,14 +6324,14 @@ bool BaselineCodeGen<Handler>::emit_JSOP_CHECK_RESUMEKIND() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_RESUMEKIND() {
+bool BaselineCompilerCodeGen::emit_ResumeKind() {
   GeneratorResumeKind resumeKind = ResumeKindFromPC(handler.pc());
   frame.push(Int32Value(int32_t(resumeKind)));
   return true;
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_RESUMEKIND() {
+bool BaselineInterpreterCodeGen::emit_ResumeKind() {
   LoadUint8Operand(masm, R0.scratchReg());
   masm.tagValue(JSVAL_TYPE_INT32, R0.scratchReg(), R0);
   frame.push(R0);
@@ -6339,7 +6339,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_RESUMEKIND() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DEBUGCHECKSELFHOSTED() {
+bool BaselineCodeGen<Handler>::emit_DebugCheckSelfHosted() {
 #ifdef DEBUG
   frame.syncStack(0);
 
@@ -6357,19 +6357,19 @@ bool BaselineCodeGen<Handler>::emit_JSOP_DEBUGCHECKSELFHOSTED() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_IS_CONSTRUCTING() {
+bool BaselineCodeGen<Handler>::emit_IsConstructing() {
   frame.push(MagicValue(JS_IS_CONSTRUCTING));
   return true;
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_JUMPTARGET() {
+bool BaselineCompilerCodeGen::emit_JumpTarget() {
   MaybeIncrementCodeCoverageCounter(masm, handler.script(), handler.pc());
   return true;
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_JUMPTARGET() {
+bool BaselineInterpreterCodeGen::emit_JumpTarget() {
   Register scratch1 = R0.scratchReg();
   Register scratch2 = R1.scratchReg();
 
@@ -6401,7 +6401,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_JUMPTARGET() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CHECKCLASSHERITAGE() {
+bool BaselineCodeGen<Handler>::emit_CheckClassHeritage() {
   frame.syncStack(0);
 
   // Leave the heritage value on the stack.
@@ -6415,7 +6415,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_CHECKCLASSHERITAGE() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_INITHOMEOBJECT() {
+bool BaselineCodeGen<Handler>::emit_InitHomeObject() {
   // Load HomeObject in R0.
   frame.popRegsAndSync(1);
 
@@ -6439,7 +6439,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_INITHOMEOBJECT() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_BUILTINPROTO() {
+bool BaselineCompilerCodeGen::emit_BuiltinProto() {
   // The builtin prototype is a constant for a given global.
   JSObject* builtin = BuiltinProtoOperation(cx, handler.pc());
   if (!builtin) {
@@ -6450,7 +6450,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_BUILTINPROTO() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_BUILTINPROTO() {
+bool BaselineInterpreterCodeGen::emit_BuiltinProto() {
   prepareVMCall();
 
   pushBytecodePCArg();
@@ -6466,7 +6466,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_BUILTINPROTO() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_OBJWITHPROTO() {
+bool BaselineCodeGen<Handler>::emit_ObjWithProto() {
   frame.syncStack(0);
 
   // Leave the proto value on the stack for the decompiler
@@ -6487,7 +6487,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_OBJWITHPROTO() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_FUNWITHPROTO() {
+bool BaselineCodeGen<Handler>::emit_FunWithProto() {
   frame.popRegsAndSync(1);
 
   masm.unboxObject(R0, R0.scratchReg());
@@ -6511,7 +6511,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_FUNWITHPROTO() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_CLASSCONSTRUCTOR() {
+bool BaselineCodeGen<Handler>::emit_ClassConstructor() {
   frame.syncStack(0);
 
   // Pass nullptr as prototype to MakeDefaultConstructor
@@ -6532,7 +6532,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_CLASSCONSTRUCTOR() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DERIVEDCONSTRUCTOR() {
+bool BaselineCodeGen<Handler>::emit_DerivedConstructor() {
   frame.popRegsAndSync(1);
 
   masm.unboxObject(R0, R0.scratchReg());
@@ -6554,7 +6554,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_DERIVEDCONSTRUCTOR() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_IMPORTMETA() {
+bool BaselineCompilerCodeGen::emit_ImportMeta() {
   // Note: this is like the interpreter implementation, but optimized a bit by
   // calling GetModuleObjectForScript at compile-time.
 
@@ -6577,7 +6577,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_IMPORTMETA() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_IMPORTMETA() {
+bool BaselineInterpreterCodeGen::emit_ImportMeta() {
   prepareVMCall();
 
   pushScriptArg();
@@ -6593,7 +6593,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_IMPORTMETA() {
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_DYNAMIC_IMPORT() {
+bool BaselineCodeGen<Handler>::emit_DynamicImport() {
   // Put specifier value in R0.
   frame.popRegsAndSync(1);
 
@@ -6612,7 +6612,7 @@ bool BaselineCodeGen<Handler>::emit_JSOP_DYNAMIC_IMPORT() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_INSTRUMENTATION_ACTIVE() {
+bool BaselineCompilerCodeGen::emit_InstrumentationActive() {
   frame.syncStack(0);
 
   // RealmInstrumentation cannot be removed from a global without destroying the
@@ -6628,7 +6628,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_INSTRUMENTATION_ACTIVE() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_INSTRUMENTATION_ACTIVE() {
+bool BaselineInterpreterCodeGen::emit_InstrumentationActive() {
   prepareVMCall();
 
   using Fn = bool (*)(JSContext*, MutableHandleValue);
@@ -6641,7 +6641,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_INSTRUMENTATION_ACTIVE() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_INSTRUMENTATION_CALLBACK() {
+bool BaselineCompilerCodeGen::emit_InstrumentationCallback() {
   JSObject* obj = RealmInstrumentation::getCallback(cx->global());
   MOZ_ASSERT(obj);
   frame.push(ObjectValue(*obj));
@@ -6649,7 +6649,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_INSTRUMENTATION_CALLBACK() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_INSTRUMENTATION_CALLBACK() {
+bool BaselineInterpreterCodeGen::emit_InstrumentationCallback() {
   prepareVMCall();
 
   using Fn = JSObject* (*)(JSContext*);
@@ -6663,7 +6663,7 @@ bool BaselineInterpreterCodeGen::emit_JSOP_INSTRUMENTATION_CALLBACK() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_INSTRUMENTATION_SCRIPT_ID() {
+bool BaselineCompilerCodeGen::emit_InstrumentationScriptId() {
   int32_t scriptId;
   RootedScript script(cx, handler.script());
   if (!RealmInstrumentation::getScriptId(cx, cx->global(), script, &scriptId)) {
@@ -6674,7 +6674,7 @@ bool BaselineCompilerCodeGen::emit_JSOP_INSTRUMENTATION_SCRIPT_ID() {
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_INSTRUMENTATION_SCRIPT_ID() {
+bool BaselineInterpreterCodeGen::emit_InstrumentationScriptId() {
   prepareVMCall();
   pushScriptArg();
 
@@ -6688,13 +6688,13 @@ bool BaselineInterpreterCodeGen::emit_JSOP_INSTRUMENTATION_SCRIPT_ID() {
 }
 
 template <>
-bool BaselineCompilerCodeGen::emit_JSOP_FORCEINTERPRETER() {
+bool BaselineCompilerCodeGen::emit_ForceInterpreter() {
   // Caller is responsible for checking script->hasForceInterpreterOp().
   MOZ_CRASH("JSOP_FORCEINTERPRETER in baseline");
 }
 
 template <>
-bool BaselineInterpreterCodeGen::emit_JSOP_FORCEINTERPRETER() {
+bool BaselineInterpreterCodeGen::emit_ForceInterpreter() {
   masm.assumeUnreachable("JSOP_FORCEINTERPRETER");
   return true;
 }
@@ -6861,9 +6861,9 @@ MethodStatus BaselineCompiler::emitBody() {
       return Method_Error;
     }
 
-#define EMIT_OP(OP, ...)                                       \
-  case OP:                                                     \
-    if (MOZ_UNLIKELY(!this->emit_##OP())) return Method_Error; \
+#define EMIT_OP(op, op_camel, ...)                                   \
+  case JSOp::op_camel:                                               \
+    if (MOZ_UNLIKELY(!this->emit_##op_camel())) return Method_Error; \
     break;
 
     switch (op) {
@@ -6979,17 +6979,17 @@ bool BaselineInterpreterGenerator::emitInterpreterLoop() {
 
   // Emit code for each bytecode op.
   Label opLabels[JSOP_LIMIT];
-#define EMIT_OP(OP, ...)                \
-  {                                     \
-    masm.bind(&opLabels[uint8_t(OP)]);  \
-    handler.setCurrentOp(OP);           \
-    if (!this->emit_##OP()) {           \
-      return false;                     \
-    }                                   \
-    if (!opEpilogue(OP, OP##_LENGTH)) { \
-      return false;                     \
-    }                                   \
-    handler.resetCurrentOp();           \
+#define EMIT_OP(op, op_camel, ...)                  \
+  {                                                 \
+    masm.bind(&opLabels[uint8_t(JSOp::op_camel)]);  \
+    handler.setCurrentOp(JSOp::op_camel);           \
+    if (!this->emit_##op_camel()) {                 \
+      return false;                                 \
+    }                                               \
+    if (!opEpilogue(JSOp::op_camel, op##_LENGTH)) { \
+      return false;                                 \
+    }                                               \
+    handler.resetCurrentOp();                       \
   }
   FOR_EACH_OPCODE(EMIT_OP)
 #undef EMIT_OP
diff --git a/js/src/jit/BaselineCodeGen.h b/js/src/jit/BaselineCodeGen.h
index d39d6a54a0db..a6143a5d8128 100644
--- a/js/src/jit/BaselineCodeGen.h
+++ b/js/src/jit/BaselineCodeGen.h
@@ -187,7 +187,7 @@ class BaselineCodeGen {
   MOZ_MUST_USE bool emitTraceLoggerResume(Register script,
                                           AllocatableGeneralRegisterSet& regs);
 
-#define EMIT_OP(op, ...) bool emit_##op();
+#define EMIT_OP(op, op_camel, ...) bool emit_##op_camel();
   FOR_EACH_OPCODE(EMIT_OP)
 #undef EMIT_OP
 
diff --git a/js/src/jit/IonBuilder.cpp b/js/src/jit/IonBuilder.cpp
index c32741b08b96..0ea9fda032e5 100644
--- a/js/src/jit/IonBuilder.cpp
+++ b/js/src/jit/IonBuilder.cpp
@@ -10580,9 +10580,9 @@ AbortReasonOr<Ok> IonBuilder::jsop_rest() {
     }
   }
 
-  // The array's length is incorrectly 0 now, from the template object
-  // created by BaselineCompiler::emit_JSOP_REST() before the actual argument
-  // count was known. Set the correct length now that we know that count.
+  // The array's length is incorrectly 0 now, from the template object created
+  // by BaselineCompiler::emit_Rest() before the actual argument count was
+  // known. Set the correct length now that we know that count.
   MSetArrayLength* length = MSetArrayLength::New(alloc(), elements, index);
   current->add(length);