Bug 1480390: Rename TRY_DESTRUCTURING_ITERCLOSE to TRY_DESTRUCTURING to standardize naming conventions r=tcampbell
authorIain Ireland <iireland@mozilla.com>
Fri, 21 Dec 2018 22:36:19 +0000
changeset 511777 d30b4fd63e1723d205e31251af32ba8930aa9abd
parent 511776 c903ba5922f2d7e4d87b929f37f0f34dabdc3e6a
child 511787 42d4ad944a37049139e65a175a9b9c0961a3e3b9
child 511789 4fb2228049560f0c9923fa338bd31e4f1706ac37
push id1953
push userffxbld-merge
push dateMon, 11 Mar 2019 12:10:20 +0000
treeherdermozilla-release@9c35dcbaa899 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerstcampbell
bugs1480390
milestone66.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1480390: Rename TRY_DESTRUCTURING_ITERCLOSE to TRY_DESTRUCTURING to standardize naming conventions r=tcampbell Differential Revision: https://phabricator.services.mozilla.com/D14793
js/src/frontend/BytecodeEmitter.cpp
js/src/frontend/BytecodeEmitter.h
js/src/jit/BaselineBailouts.cpp
js/src/jit/BaselineCompiler.cpp
js/src/jit/BaselineCompiler.h
js/src/jit/IonBuilder.cpp
js/src/jit/JitFrames.cpp
js/src/shell/js.cpp
js/src/vm/Interpreter.cpp
js/src/vm/JSScript.cpp
js/src/vm/JSScript.h
js/src/vm/Opcodes.h
--- a/js/src/frontend/BytecodeEmitter.cpp
+++ b/js/src/frontend/BytecodeEmitter.cpp
@@ -2950,36 +2950,36 @@ bool BytecodeEmitter::emitIteratorCloseI
     return false;
   }
 
   return emit1(JSOP_POP);
   //                [stack] ...
 }
 
 template <typename InnerEmitter>
-bool BytecodeEmitter::wrapWithDestructuringIteratorCloseTryNote(
-    int32_t iterDepth, InnerEmitter emitter) {
+bool BytecodeEmitter::wrapWithDestructuringTryNote(int32_t iterDepth,
+                                                   InnerEmitter emitter) {
   MOZ_ASSERT(this->stackDepth >= iterDepth);
 
   // Pad a nop at the beginning of the bytecode covered by the trynote so
   // that when unwinding environments, we may unwind to the scope
   // corresponding to the pc *before* the start, in case the first bytecode
   // emitted by |emitter| is the start of an inner scope. See comment above
   // UnwindEnvironmentToTryPc.
-  if (!emit1(JSOP_TRY_DESTRUCTURING_ITERCLOSE)) {
+  if (!emit1(JSOP_TRY_DESTRUCTURING)) {
     return false;
   }
 
   ptrdiff_t start = offset();
   if (!emitter(this)) {
     return false;
   }
   ptrdiff_t end = offset();
   if (start != end) {
-    return addTryNote(JSTRY_DESTRUCTURING_ITERCLOSE, iterDepth, start, end);
+    return addTryNote(JSTRY_DESTRUCTURING, iterDepth, start, end);
   }
   return true;
 }
 
 bool BytecodeEmitter::emitDefault(ParseNode* defaultExpr, ParseNode* pattern) {
   IfEmitter ifUndefined(this);
   if (!ifUndefined.emitIf(Nothing())) {
     return false;
@@ -3196,17 +3196,17 @@ bool BytecodeEmitter::emitDestructuringO
   }
 
   // Push an initial FALSE value for DONE.
   if (!emit1(JSOP_FALSE)) {
     //              [stack] ... OBJ NEXT ITER FALSE
     return false;
   }
 
-  // JSTRY_DESTRUCTURING_ITERCLOSE expects the iterator and the done value
+  // JSTRY_DESTRUCTURING expects the iterator and the done value
   // to be the second to top and the top of the stack, respectively.
   // IteratorClose is called upon exception only if done is false.
   int32_t tryNoteDepth = stackDepth;
 
   for (ParseNode* member : pattern->contents()) {
     bool isFirst = member == pattern->head();
     DebugOnly<bool> hasNext = !!member->pn_next;
 
@@ -3219,18 +3219,17 @@ bool BytecodeEmitter::emitDestructuringO
     }
 
     bool isElision = lhsPattern->isKind(ParseNodeKind::Elision);
     if (!isElision) {
       auto emitLHSRef = [lhsPattern, &emitted](BytecodeEmitter* bce) {
         return bce->emitDestructuringLHSRef(lhsPattern, &emitted);
         //          [stack] ... OBJ NEXT ITER DONE LREF*
       };
-      if (!wrapWithDestructuringIteratorCloseTryNote(tryNoteDepth,
-                                                     emitLHSRef)) {
+      if (!wrapWithDestructuringTryNote(tryNoteDepth, emitLHSRef)) {
         return false;
       }
     }
 
     // Pick the DONE value to the top of the stack.
     if (emitted) {
       if (!emit2(JSOP_PICK, emitted)) {
         //          [stack] ... OBJ NEXT ITER LREF* DONE
@@ -3315,18 +3314,17 @@ bool BytecodeEmitter::emitDestructuringO
         //          [stack] ... OBJ NEXT ITER TRUE LREF* ARRAY
         return false;
       }
 
       auto emitAssignment = [member, flav](BytecodeEmitter* bce) {
         return bce->emitSetOrInitializeDestructuring(member, flav);
         //          [stack] ... OBJ NEXT ITER TRUE
       };
-      if (!wrapWithDestructuringIteratorCloseTryNote(tryNoteDepth,
-                                                     emitAssignment)) {
+      if (!wrapWithDestructuringTryNote(tryNoteDepth, emitAssignment)) {
         return false;
       }
 
       MOZ_ASSERT(!hasNext);
       break;
     }
 
     ParseNode* pndefault = nullptr;
@@ -3442,30 +3440,28 @@ bool BytecodeEmitter::emitDestructuringO
     }
 
     if (pndefault) {
       auto emitDefault = [pndefault, lhsPattern](BytecodeEmitter* bce) {
         return bce->emitDefault(pndefault, lhsPattern);
         //          [stack] ... OBJ NEXT ITER DONE LREF* VALUE
       };
 
-      if (!wrapWithDestructuringIteratorCloseTryNote(tryNoteDepth,
-                                                     emitDefault)) {
+      if (!wrapWithDestructuringTryNote(tryNoteDepth, emitDefault)) {
         return false;
       }
     }
 
     if (!isElision) {
       auto emitAssignment = [lhsPattern, flav](BytecodeEmitter* bce) {
         return bce->emitSetOrInitializeDestructuring(lhsPattern, flav);
         //          [stack] ... OBJ NEXT ITER DONE
       };
 
-      if (!wrapWithDestructuringIteratorCloseTryNote(tryNoteDepth,
-                                                     emitAssignment)) {
+      if (!wrapWithDestructuringTryNote(tryNoteDepth, emitAssignment)) {
         return false;
       }
     } else {
       if (!emit1(JSOP_POP)) {
         //          [stack] ... OBJ NEXT ITER DONE
         return false;
       }
     }
--- a/js/src/frontend/BytecodeEmitter.h
+++ b/js/src/frontend/BytecodeEmitter.h
@@ -769,18 +769,18 @@ struct MOZ_STACK_CLASS BytecodeEmitter {
       IteratorKind iterKind = IteratorKind::Sync,
       CompletionKind completionKind = CompletionKind::Normal,
       bool allowSelfHosted = false) {
     return emitIteratorCloseInScope(*innermostEmitterScope(), iterKind,
                                     completionKind, allowSelfHosted);
   }
 
   template <typename InnerEmitter>
-  MOZ_MUST_USE bool wrapWithDestructuringIteratorCloseTryNote(
-      int32_t iterDepth, InnerEmitter emitter);
+  MOZ_MUST_USE bool wrapWithDestructuringTryNote(int32_t iterDepth,
+                                                 InnerEmitter emitter);
 
   // Check if the value on top of the stack is "undefined". If so, replace
   // that value on the stack with the value defined by |defaultExpr|.
   // |pattern| is a lhs node of the default expression.  If it's an
   // identifier and |defaultExpr| is an anonymous function, |SetFunctionName|
   // is called at compile time.
   MOZ_MUST_USE bool emitDefault(ParseNode* defaultExpr, ParseNode* pattern);
 
--- a/js/src/jit/BaselineBailouts.cpp
+++ b/js/src/jit/BaselineBailouts.cpp
@@ -503,17 +503,17 @@ static bool HasLiveStackValueAtDepth(JSS
         // The iterator is below the result.value, the next method below
         // the iterator.
         if (stackDepth == tn.stackDepth - 1 ||
             stackDepth == tn.stackDepth - 2) {
           return true;
         }
         break;
 
-      case JSTRY_DESTRUCTURING_ITERCLOSE:
+      case JSTRY_DESTRUCTURING:
         // Destructuring code that need to call IteratorClose have both
         // the iterator and the "done" value on the stack.
         if (stackDepth == tn.stackDepth || stackDepth == tn.stackDepth - 1) {
           return true;
         }
         break;
 
       default:
--- a/js/src/jit/BaselineCompiler.cpp
+++ b/js/src/jit/BaselineCompiler.cpp
@@ -1265,17 +1265,17 @@ bool BaselineCodeGen<Handler>::emit_JSOP
 }
 
 template <typename Handler>
 bool BaselineCodeGen<Handler>::emit_JSOP_NOP_DESTRUCTURING() {
   return true;
 }
 
 template <typename Handler>
-bool BaselineCodeGen<Handler>::emit_JSOP_TRY_DESTRUCTURING_ITERCLOSE() {
+bool BaselineCodeGen<Handler>::emit_JSOP_TRY_DESTRUCTURING() {
   return true;
 }
 
 template <typename Handler>
 bool BaselineCodeGen<Handler>::emit_JSOP_LABEL() {
   return true;
 }
 
--- a/js/src/jit/BaselineCompiler.h
+++ b/js/src/jit/BaselineCompiler.h
@@ -11,248 +11,248 @@
 #include "jit/BaselineIC.h"
 #include "jit/BytecodeAnalysis.h"
 #include "jit/FixedList.h"
 #include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
-#define OPCODE_LIST(_)                \
-  _(JSOP_NOP)                         \
-  _(JSOP_NOP_DESTRUCTURING)           \
-  _(JSOP_LABEL)                       \
-  _(JSOP_ITERNEXT)                    \
-  _(JSOP_POP)                         \
-  _(JSOP_POPN)                        \
-  _(JSOP_DUPAT)                       \
-  _(JSOP_ENTERWITH)                   \
-  _(JSOP_LEAVEWITH)                   \
-  _(JSOP_DUP)                         \
-  _(JSOP_DUP2)                        \
-  _(JSOP_SWAP)                        \
-  _(JSOP_PICK)                        \
-  _(JSOP_UNPICK)                      \
-  _(JSOP_GOTO)                        \
-  _(JSOP_IFEQ)                        \
-  _(JSOP_IFNE)                        \
-  _(JSOP_AND)                         \
-  _(JSOP_OR)                          \
-  _(JSOP_NOT)                         \
-  _(JSOP_POS)                         \
-  _(JSOP_LOOPHEAD)                    \
-  _(JSOP_LOOPENTRY)                   \
-  _(JSOP_VOID)                        \
-  _(JSOP_UNDEFINED)                   \
-  _(JSOP_HOLE)                        \
-  _(JSOP_NULL)                        \
-  _(JSOP_TRUE)                        \
-  _(JSOP_FALSE)                       \
-  _(JSOP_ZERO)                        \
-  _(JSOP_ONE)                         \
-  _(JSOP_INT8)                        \
-  _(JSOP_INT32)                       \
-  _(JSOP_UINT16)                      \
-  _(JSOP_UINT24)                      \
-  _(JSOP_RESUMEINDEX)                 \
-  _(JSOP_DOUBLE)                      \
-  IF_BIGINT(_(JSOP_BIGINT), )         \
-  _(JSOP_STRING)                      \
-  _(JSOP_SYMBOL)                      \
-  _(JSOP_OBJECT)                      \
-  _(JSOP_CALLSITEOBJ)                 \
-  _(JSOP_REGEXP)                      \
-  _(JSOP_LAMBDA)                      \
-  _(JSOP_LAMBDA_ARROW)                \
-  _(JSOP_SETFUNNAME)                  \
-  _(JSOP_BITOR)                       \
-  _(JSOP_BITXOR)                      \
-  _(JSOP_BITAND)                      \
-  _(JSOP_LSH)                         \
-  _(JSOP_RSH)                         \
-  _(JSOP_URSH)                        \
-  _(JSOP_ADD)                         \
-  _(JSOP_SUB)                         \
-  _(JSOP_MUL)                         \
-  _(JSOP_DIV)                         \
-  _(JSOP_MOD)                         \
-  _(JSOP_POW)                         \
-  _(JSOP_LT)                          \
-  _(JSOP_LE)                          \
-  _(JSOP_GT)                          \
-  _(JSOP_GE)                          \
-  _(JSOP_EQ)                          \
-  _(JSOP_NE)                          \
-  _(JSOP_STRICTEQ)                    \
-  _(JSOP_STRICTNE)                    \
-  _(JSOP_CONDSWITCH)                  \
-  _(JSOP_CASE)                        \
-  _(JSOP_DEFAULT)                     \
-  _(JSOP_LINENO)                      \
-  _(JSOP_BITNOT)                      \
-  _(JSOP_NEG)                         \
-  _(JSOP_NEWARRAY)                    \
-  _(JSOP_NEWARRAY_COPYONWRITE)        \
-  _(JSOP_INITELEM_ARRAY)              \
-  _(JSOP_NEWOBJECT)                   \
-  _(JSOP_NEWINIT)                     \
-  _(JSOP_INITELEM)                    \
-  _(JSOP_INITELEM_GETTER)             \
-  _(JSOP_INITELEM_SETTER)             \
-  _(JSOP_INITELEM_INC)                \
-  _(JSOP_MUTATEPROTO)                 \
-  _(JSOP_INITPROP)                    \
-  _(JSOP_INITLOCKEDPROP)              \
-  _(JSOP_INITHIDDENPROP)              \
-  _(JSOP_INITPROP_GETTER)             \
-  _(JSOP_INITPROP_SETTER)             \
-  _(JSOP_GETELEM)                     \
-  _(JSOP_SETELEM)                     \
-  _(JSOP_STRICTSETELEM)               \
-  _(JSOP_CALLELEM)                    \
-  _(JSOP_DELELEM)                     \
-  _(JSOP_STRICTDELELEM)               \
-  _(JSOP_GETELEM_SUPER)               \
-  _(JSOP_SETELEM_SUPER)               \
-  _(JSOP_STRICTSETELEM_SUPER)         \
-  _(JSOP_IN)                          \
-  _(JSOP_HASOWN)                      \
-  _(JSOP_GETGNAME)                    \
-  _(JSOP_BINDGNAME)                   \
-  _(JSOP_SETGNAME)                    \
-  _(JSOP_STRICTSETGNAME)              \
-  _(JSOP_SETNAME)                     \
-  _(JSOP_STRICTSETNAME)               \
-  _(JSOP_GETPROP)                     \
-  _(JSOP_SETPROP)                     \
-  _(JSOP_STRICTSETPROP)               \
-  _(JSOP_CALLPROP)                    \
-  _(JSOP_DELPROP)                     \
-  _(JSOP_STRICTDELPROP)               \
-  _(JSOP_GETPROP_SUPER)               \
-  _(JSOP_SETPROP_SUPER)               \
-  _(JSOP_STRICTSETPROP_SUPER)         \
-  _(JSOP_LENGTH)                      \
-  _(JSOP_GETBOUNDNAME)                \
-  _(JSOP_GETALIASEDVAR)               \
-  _(JSOP_SETALIASEDVAR)               \
-  _(JSOP_GETNAME)                     \
-  _(JSOP_BINDNAME)                    \
-  _(JSOP_DELNAME)                     \
-  _(JSOP_GETIMPORT)                   \
-  _(JSOP_GETINTRINSIC)                \
-  _(JSOP_BINDVAR)                     \
-  _(JSOP_DEFVAR)                      \
-  _(JSOP_DEFCONST)                    \
-  _(JSOP_DEFLET)                      \
-  _(JSOP_DEFFUN)                      \
-  _(JSOP_GETLOCAL)                    \
-  _(JSOP_SETLOCAL)                    \
-  _(JSOP_GETARG)                      \
-  _(JSOP_SETARG)                      \
-  _(JSOP_CHECKLEXICAL)                \
-  _(JSOP_INITLEXICAL)                 \
-  _(JSOP_INITGLEXICAL)                \
-  _(JSOP_CHECKALIASEDLEXICAL)         \
-  _(JSOP_INITALIASEDLEXICAL)          \
-  _(JSOP_UNINITIALIZED)               \
-  _(JSOP_CALL)                        \
-  _(JSOP_CALL_IGNORES_RV)             \
-  _(JSOP_CALLITER)                    \
-  _(JSOP_FUNCALL)                     \
-  _(JSOP_FUNAPPLY)                    \
-  _(JSOP_NEW)                         \
-  _(JSOP_EVAL)                        \
-  _(JSOP_STRICTEVAL)                  \
-  _(JSOP_SPREADCALL)                  \
-  _(JSOP_SPREADNEW)                   \
-  _(JSOP_SPREADEVAL)                  \
-  _(JSOP_STRICTSPREADEVAL)            \
-  _(JSOP_OPTIMIZE_SPREADCALL)         \
-  _(JSOP_IMPLICITTHIS)                \
-  _(JSOP_GIMPLICITTHIS)               \
-  _(JSOP_INSTANCEOF)                  \
-  _(JSOP_TYPEOF)                      \
-  _(JSOP_TYPEOFEXPR)                  \
-  _(JSOP_THROWMSG)                    \
-  _(JSOP_THROW)                       \
-  _(JSOP_TRY)                         \
-  _(JSOP_FINALLY)                     \
-  _(JSOP_GOSUB)                       \
-  _(JSOP_RETSUB)                      \
-  _(JSOP_PUSHLEXICALENV)              \
-  _(JSOP_POPLEXICALENV)               \
-  _(JSOP_FRESHENLEXICALENV)           \
-  _(JSOP_RECREATELEXICALENV)          \
-  _(JSOP_DEBUGLEAVELEXICALENV)        \
-  _(JSOP_PUSHVARENV)                  \
-  _(JSOP_POPVARENV)                   \
-  _(JSOP_EXCEPTION)                   \
-  _(JSOP_DEBUGGER)                    \
-  _(JSOP_ARGUMENTS)                   \
-  _(JSOP_RUNONCE)                     \
-  _(JSOP_REST)                        \
-  _(JSOP_TOASYNC)                     \
-  _(JSOP_TOASYNCGEN)                  \
-  _(JSOP_TOASYNCITER)                 \
-  _(JSOP_TOID)                        \
-  _(JSOP_TOSTRING)                    \
-  _(JSOP_TABLESWITCH)                 \
-  _(JSOP_ITER)                        \
-  _(JSOP_MOREITER)                    \
-  _(JSOP_ISNOITER)                    \
-  _(JSOP_ENDITER)                     \
-  _(JSOP_ISGENCLOSING)                \
-  _(JSOP_GENERATOR)                   \
-  _(JSOP_INITIALYIELD)                \
-  _(JSOP_YIELD)                       \
-  _(JSOP_AWAIT)                       \
-  _(JSOP_TRYSKIPAWAIT)                \
-  _(JSOP_DEBUGAFTERYIELD)             \
-  _(JSOP_FINALYIELDRVAL)              \
-  _(JSOP_RESUME)                      \
-  _(JSOP_CALLEE)                      \
-  _(JSOP_ENVCALLEE)                   \
-  _(JSOP_SUPERBASE)                   \
-  _(JSOP_SUPERFUN)                    \
-  _(JSOP_GETRVAL)                     \
-  _(JSOP_SETRVAL)                     \
-  _(JSOP_RETRVAL)                     \
-  _(JSOP_RETURN)                      \
-  _(JSOP_FUNCTIONTHIS)                \
-  _(JSOP_GLOBALTHIS)                  \
-  _(JSOP_CHECKISOBJ)                  \
-  _(JSOP_CHECKISCALLABLE)             \
-  _(JSOP_CHECKTHIS)                   \
-  _(JSOP_CHECKTHISREINIT)             \
-  _(JSOP_CHECKRETURN)                 \
-  _(JSOP_NEWTARGET)                   \
-  _(JSOP_SUPERCALL)                   \
-  _(JSOP_SPREADSUPERCALL)             \
-  _(JSOP_THROWSETCONST)               \
-  _(JSOP_THROWSETALIASEDCONST)        \
-  _(JSOP_THROWSETCALLEE)              \
-  _(JSOP_INITHIDDENPROP_GETTER)       \
-  _(JSOP_INITHIDDENPROP_SETTER)       \
-  _(JSOP_INITHIDDENELEM)              \
-  _(JSOP_INITHIDDENELEM_GETTER)       \
-  _(JSOP_INITHIDDENELEM_SETTER)       \
-  _(JSOP_CHECKOBJCOERCIBLE)           \
-  _(JSOP_DEBUGCHECKSELFHOSTED)        \
-  _(JSOP_JUMPTARGET)                  \
-  _(JSOP_IS_CONSTRUCTING)             \
-  _(JSOP_TRY_DESTRUCTURING_ITERCLOSE) \
-  _(JSOP_CHECKCLASSHERITAGE)          \
-  _(JSOP_INITHOMEOBJECT)              \
-  _(JSOP_BUILTINPROTO)                \
-  _(JSOP_OBJWITHPROTO)                \
-  _(JSOP_FUNWITHPROTO)                \
-  _(JSOP_CLASSCONSTRUCTOR)            \
-  _(JSOP_DERIVEDCONSTRUCTOR)          \
-  _(JSOP_IMPORTMETA)                  \
+#define OPCODE_LIST(_)          \
+  _(JSOP_NOP)                   \
+  _(JSOP_NOP_DESTRUCTURING)     \
+  _(JSOP_LABEL)                 \
+  _(JSOP_ITERNEXT)              \
+  _(JSOP_POP)                   \
+  _(JSOP_POPN)                  \
+  _(JSOP_DUPAT)                 \
+  _(JSOP_ENTERWITH)             \
+  _(JSOP_LEAVEWITH)             \
+  _(JSOP_DUP)                   \
+  _(JSOP_DUP2)                  \
+  _(JSOP_SWAP)                  \
+  _(JSOP_PICK)                  \
+  _(JSOP_UNPICK)                \
+  _(JSOP_GOTO)                  \
+  _(JSOP_IFEQ)                  \
+  _(JSOP_IFNE)                  \
+  _(JSOP_AND)                   \
+  _(JSOP_OR)                    \
+  _(JSOP_NOT)                   \
+  _(JSOP_POS)                   \
+  _(JSOP_LOOPHEAD)              \
+  _(JSOP_LOOPENTRY)             \
+  _(JSOP_VOID)                  \
+  _(JSOP_UNDEFINED)             \
+  _(JSOP_HOLE)                  \
+  _(JSOP_NULL)                  \
+  _(JSOP_TRUE)                  \
+  _(JSOP_FALSE)                 \
+  _(JSOP_ZERO)                  \
+  _(JSOP_ONE)                   \
+  _(JSOP_INT8)                  \
+  _(JSOP_INT32)                 \
+  _(JSOP_UINT16)                \
+  _(JSOP_UINT24)                \
+  _(JSOP_RESUMEINDEX)           \
+  _(JSOP_DOUBLE)                \
+  IF_BIGINT(_(JSOP_BIGINT), )   \
+  _(JSOP_STRING)                \
+  _(JSOP_SYMBOL)                \
+  _(JSOP_OBJECT)                \
+  _(JSOP_CALLSITEOBJ)           \
+  _(JSOP_REGEXP)                \
+  _(JSOP_LAMBDA)                \
+  _(JSOP_LAMBDA_ARROW)          \
+  _(JSOP_SETFUNNAME)            \
+  _(JSOP_BITOR)                 \
+  _(JSOP_BITXOR)                \
+  _(JSOP_BITAND)                \
+  _(JSOP_LSH)                   \
+  _(JSOP_RSH)                   \
+  _(JSOP_URSH)                  \
+  _(JSOP_ADD)                   \
+  _(JSOP_SUB)                   \
+  _(JSOP_MUL)                   \
+  _(JSOP_DIV)                   \
+  _(JSOP_MOD)                   \
+  _(JSOP_POW)                   \
+  _(JSOP_LT)                    \
+  _(JSOP_LE)                    \
+  _(JSOP_GT)                    \
+  _(JSOP_GE)                    \
+  _(JSOP_EQ)                    \
+  _(JSOP_NE)                    \
+  _(JSOP_STRICTEQ)              \
+  _(JSOP_STRICTNE)              \
+  _(JSOP_CONDSWITCH)            \
+  _(JSOP_CASE)                  \
+  _(JSOP_DEFAULT)               \
+  _(JSOP_LINENO)                \
+  _(JSOP_BITNOT)                \
+  _(JSOP_NEG)                   \
+  _(JSOP_NEWARRAY)              \
+  _(JSOP_NEWARRAY_COPYONWRITE)  \
+  _(JSOP_INITELEM_ARRAY)        \
+  _(JSOP_NEWOBJECT)             \
+  _(JSOP_NEWINIT)               \
+  _(JSOP_INITELEM)              \
+  _(JSOP_INITELEM_GETTER)       \
+  _(JSOP_INITELEM_SETTER)       \
+  _(JSOP_INITELEM_INC)          \
+  _(JSOP_MUTATEPROTO)           \
+  _(JSOP_INITPROP)              \
+  _(JSOP_INITLOCKEDPROP)        \
+  _(JSOP_INITHIDDENPROP)        \
+  _(JSOP_INITPROP_GETTER)       \
+  _(JSOP_INITPROP_SETTER)       \
+  _(JSOP_GETELEM)               \
+  _(JSOP_SETELEM)               \
+  _(JSOP_STRICTSETELEM)         \
+  _(JSOP_CALLELEM)              \
+  _(JSOP_DELELEM)               \
+  _(JSOP_STRICTDELELEM)         \
+  _(JSOP_GETELEM_SUPER)         \
+  _(JSOP_SETELEM_SUPER)         \
+  _(JSOP_STRICTSETELEM_SUPER)   \
+  _(JSOP_IN)                    \
+  _(JSOP_HASOWN)                \
+  _(JSOP_GETGNAME)              \
+  _(JSOP_BINDGNAME)             \
+  _(JSOP_SETGNAME)              \
+  _(JSOP_STRICTSETGNAME)        \
+  _(JSOP_SETNAME)               \
+  _(JSOP_STRICTSETNAME)         \
+  _(JSOP_GETPROP)               \
+  _(JSOP_SETPROP)               \
+  _(JSOP_STRICTSETPROP)         \
+  _(JSOP_CALLPROP)              \
+  _(JSOP_DELPROP)               \
+  _(JSOP_STRICTDELPROP)         \
+  _(JSOP_GETPROP_SUPER)         \
+  _(JSOP_SETPROP_SUPER)         \
+  _(JSOP_STRICTSETPROP_SUPER)   \
+  _(JSOP_LENGTH)                \
+  _(JSOP_GETBOUNDNAME)          \
+  _(JSOP_GETALIASEDVAR)         \
+  _(JSOP_SETALIASEDVAR)         \
+  _(JSOP_GETNAME)               \
+  _(JSOP_BINDNAME)              \
+  _(JSOP_DELNAME)               \
+  _(JSOP_GETIMPORT)             \
+  _(JSOP_GETINTRINSIC)          \
+  _(JSOP_BINDVAR)               \
+  _(JSOP_DEFVAR)                \
+  _(JSOP_DEFCONST)              \
+  _(JSOP_DEFLET)                \
+  _(JSOP_DEFFUN)                \
+  _(JSOP_GETLOCAL)              \
+  _(JSOP_SETLOCAL)              \
+  _(JSOP_GETARG)                \
+  _(JSOP_SETARG)                \
+  _(JSOP_CHECKLEXICAL)          \
+  _(JSOP_INITLEXICAL)           \
+  _(JSOP_INITGLEXICAL)          \
+  _(JSOP_CHECKALIASEDLEXICAL)   \
+  _(JSOP_INITALIASEDLEXICAL)    \
+  _(JSOP_UNINITIALIZED)         \
+  _(JSOP_CALL)                  \
+  _(JSOP_CALL_IGNORES_RV)       \
+  _(JSOP_CALLITER)              \
+  _(JSOP_FUNCALL)               \
+  _(JSOP_FUNAPPLY)              \
+  _(JSOP_NEW)                   \
+  _(JSOP_EVAL)                  \
+  _(JSOP_STRICTEVAL)            \
+  _(JSOP_SPREADCALL)            \
+  _(JSOP_SPREADNEW)             \
+  _(JSOP_SPREADEVAL)            \
+  _(JSOP_STRICTSPREADEVAL)      \
+  _(JSOP_OPTIMIZE_SPREADCALL)   \
+  _(JSOP_IMPLICITTHIS)          \
+  _(JSOP_GIMPLICITTHIS)         \
+  _(JSOP_INSTANCEOF)            \
+  _(JSOP_TYPEOF)                \
+  _(JSOP_TYPEOFEXPR)            \
+  _(JSOP_THROWMSG)              \
+  _(JSOP_THROW)                 \
+  _(JSOP_TRY)                   \
+  _(JSOP_FINALLY)               \
+  _(JSOP_GOSUB)                 \
+  _(JSOP_RETSUB)                \
+  _(JSOP_PUSHLEXICALENV)        \
+  _(JSOP_POPLEXICALENV)         \
+  _(JSOP_FRESHENLEXICALENV)     \
+  _(JSOP_RECREATELEXICALENV)    \
+  _(JSOP_DEBUGLEAVELEXICALENV)  \
+  _(JSOP_PUSHVARENV)            \
+  _(JSOP_POPVARENV)             \
+  _(JSOP_EXCEPTION)             \
+  _(JSOP_DEBUGGER)              \
+  _(JSOP_ARGUMENTS)             \
+  _(JSOP_RUNONCE)               \
+  _(JSOP_REST)                  \
+  _(JSOP_TOASYNC)               \
+  _(JSOP_TOASYNCGEN)            \
+  _(JSOP_TOASYNCITER)           \
+  _(JSOP_TOID)                  \
+  _(JSOP_TOSTRING)              \
+  _(JSOP_TABLESWITCH)           \
+  _(JSOP_ITER)                  \
+  _(JSOP_MOREITER)              \
+  _(JSOP_ISNOITER)              \
+  _(JSOP_ENDITER)               \
+  _(JSOP_ISGENCLOSING)          \
+  _(JSOP_GENERATOR)             \
+  _(JSOP_INITIALYIELD)          \
+  _(JSOP_YIELD)                 \
+  _(JSOP_AWAIT)                 \
+  _(JSOP_TRYSKIPAWAIT)          \
+  _(JSOP_DEBUGAFTERYIELD)       \
+  _(JSOP_FINALYIELDRVAL)        \
+  _(JSOP_RESUME)                \
+  _(JSOP_CALLEE)                \
+  _(JSOP_ENVCALLEE)             \
+  _(JSOP_SUPERBASE)             \
+  _(JSOP_SUPERFUN)              \
+  _(JSOP_GETRVAL)               \
+  _(JSOP_SETRVAL)               \
+  _(JSOP_RETRVAL)               \
+  _(JSOP_RETURN)                \
+  _(JSOP_FUNCTIONTHIS)          \
+  _(JSOP_GLOBALTHIS)            \
+  _(JSOP_CHECKISOBJ)            \
+  _(JSOP_CHECKISCALLABLE)       \
+  _(JSOP_CHECKTHIS)             \
+  _(JSOP_CHECKTHISREINIT)       \
+  _(JSOP_CHECKRETURN)           \
+  _(JSOP_NEWTARGET)             \
+  _(JSOP_SUPERCALL)             \
+  _(JSOP_SPREADSUPERCALL)       \
+  _(JSOP_THROWSETCONST)         \
+  _(JSOP_THROWSETALIASEDCONST)  \
+  _(JSOP_THROWSETCALLEE)        \
+  _(JSOP_INITHIDDENPROP_GETTER) \
+  _(JSOP_INITHIDDENPROP_SETTER) \
+  _(JSOP_INITHIDDENELEM)        \
+  _(JSOP_INITHIDDENELEM_GETTER) \
+  _(JSOP_INITHIDDENELEM_SETTER) \
+  _(JSOP_CHECKOBJCOERCIBLE)     \
+  _(JSOP_DEBUGCHECKSELFHOSTED)  \
+  _(JSOP_JUMPTARGET)            \
+  _(JSOP_IS_CONSTRUCTING)       \
+  _(JSOP_TRY_DESTRUCTURING)     \
+  _(JSOP_CHECKCLASSHERITAGE)    \
+  _(JSOP_INITHOMEOBJECT)        \
+  _(JSOP_BUILTINPROTO)          \
+  _(JSOP_OBJWITHPROTO)          \
+  _(JSOP_FUNWITHPROTO)          \
+  _(JSOP_CLASSCONSTRUCTOR)      \
+  _(JSOP_DERIVEDCONSTRUCTOR)    \
+  _(JSOP_IMPORTMETA)            \
   _(JSOP_DYNAMIC_IMPORT)
 
 // Base class for BaselineCompiler and BaselineInterpreterGenerator. The Handler
 // template is a class storing fields/methods that are interpreter or compiler
 // specific. This can be combined with template specialization of methods in
 // this class to specialize behavior.
 template <typename Handler>
 class BaselineCodeGen {
--- a/js/src/jit/IonBuilder.cpp
+++ b/js/src/jit/IonBuilder.cpp
@@ -1869,17 +1869,17 @@ AbortReasonOr<Ok> IonBuilder::visitContr
   MOZ_CRASH("Unknown Control Instruction");
 }
 
 AbortReasonOr<Ok> IonBuilder::inspectOpcode(JSOp op) {
   // Add not yet implemented opcodes at the bottom of the switch!
   switch (op) {
     case JSOP_NOP:
     case JSOP_NOP_DESTRUCTURING:
-    case JSOP_TRY_DESTRUCTURING_ITERCLOSE:
+    case JSOP_TRY_DESTRUCTURING:
     case JSOP_LINENO:
     case JSOP_JUMPTARGET:
     case JSOP_LABEL:
       return Ok();
 
     case JSOP_UNDEFINED:
       // If this ever changes, change what JSOP_GIMPLICITTHIS does too.
       pushConstant(UndefinedValue());
--- a/js/src/jit/JitFrames.cpp
+++ b/js/src/jit/JitFrames.cpp
@@ -84,20 +84,19 @@ static inline bool ReadFrameBooleanSlot(
 static uint32_t NumArgAndLocalSlots(const InlineFrameIterator& frame) {
   JSScript* script = frame.script();
   return CountArgSlots(script, frame.maybeCalleeTemplate()) + script->nfixed();
 }
 
 static void CloseLiveIteratorIon(JSContext* cx,
                                  const InlineFrameIterator& frame,
                                  const JSTryNote* tn) {
-  MOZ_ASSERT(tn->kind == JSTRY_FOR_IN ||
-             tn->kind == JSTRY_DESTRUCTURING_ITERCLOSE);
+  MOZ_ASSERT(tn->kind == JSTRY_FOR_IN || tn->kind == JSTRY_DESTRUCTURING);
 
-  bool isDestructuring = tn->kind == JSTRY_DESTRUCTURING_ITERCLOSE;
+  bool isDestructuring = tn->kind == JSTRY_DESTRUCTURING;
   MOZ_ASSERT_IF(!isDestructuring, tn->stackDepth > 0);
   MOZ_ASSERT_IF(isDestructuring, tn->stackDepth > 1);
 
   SnapshotIterator si = frame.snapshotIterator();
 
   // Skip stack slots until we reach the iterator object on the stack. For
   // the destructuring case, we also need to get the "done" value.
   uint32_t stackSlot = tn->stackDepth;
@@ -203,17 +202,17 @@ static void HandleExceptionIon(JSContext
 
   bool inForOfIterClose = false;
 
   for (TryNoteIterIon tni(cx, frame); !tni.done(); ++tni) {
     const JSTryNote* tn = *tni;
 
     switch (tn->kind) {
       case JSTRY_FOR_IN:
-      case JSTRY_DESTRUCTURING_ITERCLOSE:
+      case JSTRY_DESTRUCTURING:
         // See corresponding comment in ProcessTryNotes.
         if (inForOfIterClose) {
           break;
         }
 
         MOZ_ASSERT_IF(tn->kind == JSTRY_FOR_IN,
                       JSOp(*(script->offsetToPC(tn->start + tn->length))) ==
                           JSOP_ENDITER);
@@ -457,17 +456,17 @@ static bool ProcessTryNotesBaseline(JSCo
         BaselineFrameAndStackPointersFromTryNote(tn, frame, &framePointer,
                                                  &stackPointer);
         Value iterValue(*reinterpret_cast<Value*>(stackPointer));
         JSObject* iterObject = &iterValue.toObject();
         CloseIterator(iterObject);
         break;
       }
 
-      case JSTRY_DESTRUCTURING_ITERCLOSE: {
+      case JSTRY_DESTRUCTURING: {
         // See corresponding comment in ProcessTryNotes.
         if (inForOfIterClose) {
           break;
         }
 
         uint8_t* framePointer;
         uint8_t* stackPointer;
         BaselineFrameAndStackPointersFromTryNote(tn, frame, &framePointer,
--- a/js/src/shell/js.cpp
+++ b/js/src/shell/js.cpp
@@ -3041,18 +3041,18 @@ static const char* TryNoteName(JSTryNote
     case JSTRY_FOR_IN:
       return "for-in";
     case JSTRY_FOR_OF:
       return "for-of";
     case JSTRY_LOOP:
       return "loop";
     case JSTRY_FOR_OF_ITERCLOSE:
       return "for-of-iterclose";
-    case JSTRY_DESTRUCTURING_ITERCLOSE:
-      return "dstr-iterclose";
+    case JSTRY_DESTRUCTURING:
+      return "destructuring";
   }
 
   MOZ_CRASH("Bad JSTryNoteKind");
 }
 
 static MOZ_MUST_USE bool TryNotes(JSContext* cx, HandleScript script,
                                   Sprinter* sp) {
   if (!script->hasTrynotes()) {
--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -1260,19 +1260,19 @@ void js::UnwindAllEnvironmentsInFrame(JS
 // will have no pc location distinguishing the try block scope from the inner
 // let block scope.
 jsbytecode* js::UnwindEnvironmentToTryPc(JSScript* script,
                                          const JSTryNote* tn) {
   jsbytecode* pc = script->offsetToPC(tn->start);
   if (tn->kind == JSTRY_CATCH || tn->kind == JSTRY_FINALLY) {
     pc -= JSOP_TRY_LENGTH;
     MOZ_ASSERT(*pc == JSOP_TRY);
-  } else if (tn->kind == JSTRY_DESTRUCTURING_ITERCLOSE) {
-    pc -= JSOP_TRY_DESTRUCTURING_ITERCLOSE_LENGTH;
-    MOZ_ASSERT(*pc == JSOP_TRY_DESTRUCTURING_ITERCLOSE);
+  } else if (tn->kind == JSTRY_DESTRUCTURING) {
+    pc -= JSOP_TRY_DESTRUCTURING_LENGTH;
+    MOZ_ASSERT(*pc == JSOP_TRY_DESTRUCTURING);
   }
   return pc;
 }
 
 static bool ForcedReturn(JSContext* cx, InterpreterRegs& regs) {
   bool ok = Debugger::onLeaveFrame(cx, regs.fp(), regs.pc, true);
   // Point the frame to the end of the script, regardless of error. The
   // caller must jump to the correct continuation depending on 'ok'.
@@ -1411,17 +1411,17 @@ static HandleErrorContinuation ProcessTr
             regs.fp()->script()->offsetToPC(tn->start + tn->length);
         MOZ_ASSERT(JSOp(*pc) == JSOP_ENDITER);
         Value* sp = regs.spForStackDepth(tn->stackDepth);
         JSObject* obj = &sp[-1].toObject();
         CloseIterator(obj);
         break;
       }
 
-      case JSTRY_DESTRUCTURING_ITERCLOSE: {
+      case JSTRY_DESTRUCTURING: {
         // See note above.
         if (inForOfIterClose) {
           break;
         }
 
         // Whether the destructuring iterator is done is at the top of the
         // stack. The iterator object is second from the top.
         MOZ_ASSERT(tn->stackDepth > 1);
@@ -2210,17 +2210,17 @@ static MOZ_NEVER_INLINE JS_HAZ_JSNATIVE_
       /* Commence executing the actual opcode. */
       SANITY_CHECKS();
       DISPATCH_TO(op);
     }
 
     /* Various 1-byte no-ops. */
     CASE(JSOP_NOP)
     CASE(JSOP_NOP_DESTRUCTURING)
-    CASE(JSOP_TRY_DESTRUCTURING_ITERCLOSE)
+    CASE(JSOP_TRY_DESTRUCTURING)
     CASE(JSOP_UNUSED151)
     CASE(JSOP_CONDSWITCH) {
       MOZ_ASSERT(CodeSpec[*REGS.pc].length == 1);
       ADVANCE_AND_DISPATCH(1);
     }
 
     CASE(JSOP_TRY)
     CASE(JSOP_JUMPTARGET)
--- a/js/src/vm/JSScript.cpp
+++ b/js/src/vm/JSScript.cpp
@@ -4839,17 +4839,17 @@ bool JSScript::hasLoops() {
     switch (tn.kind) {
       case JSTRY_FOR_IN:
       case JSTRY_FOR_OF:
       case JSTRY_LOOP:
         return true;
       case JSTRY_CATCH:
       case JSTRY_FINALLY:
       case JSTRY_FOR_OF_ITERCLOSE:
-      case JSTRY_DESTRUCTURING_ITERCLOSE:
+      case JSTRY_DESTRUCTURING:
         break;
       default:
         MOZ_ASSERT(false, "Add new try note type to JSScript::hasLoops");
         break;
     }
   }
   return false;
 }
--- a/js/src/vm/JSScript.h
+++ b/js/src/vm/JSScript.h
@@ -100,17 +100,17 @@ bool CopyScript(JSContext* cx, HandleScr
  */
 enum JSTryNoteKind {
   JSTRY_CATCH,
   JSTRY_FINALLY,
   JSTRY_FOR_IN,
   JSTRY_FOR_OF,
   JSTRY_LOOP,
   JSTRY_FOR_OF_ITERCLOSE,
-  JSTRY_DESTRUCTURING_ITERCLOSE
+  JSTRY_DESTRUCTURING
 };
 
 /*
  * Exception handling record.
  */
 struct JSTryNote {
   uint8_t kind;        /* one of JSTryNoteKind */
   uint32_t stackDepth; /* stack depth upon exception handler entry */
--- a/js/src/vm/Opcodes.h
+++ b/js/src/vm/Opcodes.h
@@ -2372,17 +2372,17 @@
      * No-op used by the exception unwinder to determine the correct
      * environment to unwind to when performing IteratorClose due to
      * destructuring.
      *
      *   Category: Other
      *   Operands:
      *   Stack: =>
      */ \
-    MACRO(JSOP_TRY_DESTRUCTURING_ITERCLOSE, 220, "try-destructuring-iterclose", NULL, 1, 0, 0, JOF_BYTE) \
+    MACRO(JSOP_TRY_DESTRUCTURING, 220, "try-destructuring", NULL, 1, 0, 0, JOF_BYTE) \
     /*
      * Pushes the current global's builtin prototype for a given proto key.
      *
      *   Category: Literals
      *   Type: Constants
      *   Operands: uint8_t kind
      *   Stack: => %BuiltinPrototype%
      */ \