Bytecode Descriptions

Bytecode Listing

This document is automatically generated from Opcodes.h by make_opcode_doc.py.

Statements

Jumps

JSOP_AND [-1, +1] (JUMP, DETECTING, LEFTASSOC)
Value 69 (0x45)
Operands int32_t offset
Length 5
Stack Uses cond
Stack Defs cond

Converts the top of stack value into a boolean, if the result is false, jumps to a 32-bit offset from the current bytecode.

JSOP_GOTO [-0, +0] (JUMP)
Value 6 (0x06)
Operands int32_t offset
Length 5
Stack Uses  
Stack Defs  

Jumps to a 32-bit offset from the current bytecode.

JSOP_IFEQ [-1, +0] (JUMP, DETECTING)
Value 7 (0x07)
Operands int32_t offset
Length 5
Stack Uses cond
Stack Defs  

Pops the top of stack value, converts it into a boolean, if the result is false, jumps to a 32-bit offset from the current bytecode.

The idea is that a sequence like JSOP_ZERO; JSOP_ZERO; JSOP_EQ; JSOP_IFEQ; JSOP_RETURN; reads like a nice linear sequence that will execute the return.

JSOP_IFNE [-1, +0] (JUMP)
Value 8 (0x08)
Operands int32_t offset
Length 5
Stack Uses cond
Stack Defs  

Pops the top of stack value, converts it into a boolean, if the result is true, jumps to a 32-bit offset from the current bytecode.

JSOP_LABEL [-0, +0] (JUMP)
Value 106 (0x6a)
Operands int32_t offset
Length 5
Stack Uses  
Stack Defs  

This opcode precedes every labeled statement. It's a no-op.

offset is the offset to the next instruction after this statement, the one break LABEL; would jump to. IonMonkey uses this.

JSOP_LOOPENTRY [-0, +0] (UINT8)
Value 227 (0xe3)
Operands uint8_t BITFIELD
Length 2
Stack Uses  
Stack Defs  

This opcode is the target of the entry jump for some loop. The uint8 argument is a bitfield. The lower 7 bits of the argument indicate the loop depth. This value starts at 1 and is just a hint: deeply nested loops all have the same value. The upper bit is set if Ion should be able to OSR at this point, which is true unless there is non-loop state on the stack.

JSOP_LOOPHEAD [-0, +0]
Value 109 (0x6d)
Operands  
Length 1
Stack Uses  
Stack Defs  

Another no-op.

This opcode is the target of the backwards jump for some loop.

JSOP_OR [-1, +1] (JUMP, DETECTING, LEFTASSOC)
Value 68 (0x44)
Operands int32_t offset
Length 5
Stack Uses cond
Stack Defs cond

Converts the top of stack value into a boolean, if the result is true, jumps to a 32-bit offset from the current bytecode.

Switch Statement

JSOP_CASE [-2, +1] (JUMP)
Value 121 (0x79)
Operands int32_t offset
Length 5
Stack Uses lval, rval
Stack Defs lval(if lval !== rval)

Pops the top two values on the stack as rval and lval, compare them with ===, if the result is true, jumps to a 32-bit offset from the current bytecode, re-pushes lval onto the stack if false.

JSOP_CONDSWITCH [-0, +0]
Value 120 (0x78)
Operands  
Length 1
Stack Uses  
Stack Defs  

This no-op appears after the bytecode for EXPR in switch (EXPR) {...} if the switch cannot be optimized using JSOP_TABLESWITCH. For a non-optimized switch statement like this:

   switch (EXPR) {
     case V0:
       C0;
     ...
     default:
       D;
   }

the bytecode looks like this:

   (EXPR)
   condswitch
   (V0)
   case ->C0
   ...
   default ->D
   (C0)
   ...
   (D)

Note that code for all case-labels is emitted first, then code for the body of each case clause.

JSOP_DEFAULT [-1, +0] (JUMP)
Value 122 (0x7a)
Operands int32_t offset
Length 5
Stack Uses lval
Stack Defs  

This appears after all cases in a JSOP_CONDSWITCH, whether there is a default: label in the switch statement or not. Pop the switch operand from the stack and jump to a 32-bit offset from the current bytecode. offset from the current bytecode.

JSOP_TABLESWITCH [-1, +0] (TABLESWITCH, DETECTING)
Value 70 (0x46)
Operands int32_t len, int32_t low, int32_t high,int32_t offset[0], ..., int32_t offset[high-low]
Length len
Stack Uses i
Stack Defs  

Pops the top of stack value as i, if low <= i <= high, jumps to a 32-bit offset: offset[i - low] from the current bytecode, jumps to a 32-bit offset: len from the current bytecode if not.

This opcode has variable length.

For-In Statement

JSOP_ENDITER [-1, +0]
Value 78 (0x4e)
Operands  
Length 1
Stack Uses iter
Stack Defs  

Exits a for-in loop by popping the iterator object from the stack and closing it.

JSOP_ISNOITER [-1, +2]
Value 77 (0x4d)
Operands  
Length 1
Stack Uses val
Stack Defs val, res

Pushes a boolean indicating whether the value on top of the stack is MagicValue(JS_NO_ITER_VALUE).

JSOP_ITER [-1, +1] (UINT8)
Value 75 (0x4b)
Operands uint8_t flags
Length 2
Stack Uses val
Stack Defs iter

Sets up a for-in or for-each-in loop using the JSITER_* flag bits in this op's uint8_t immediate operand. It pops the top of stack value as val and pushes iter which is an iterator for val.

JSOP_MOREITER [-1, +2]
Value 76 (0x4c)
Operands  
Length 1
Stack Uses iter
Stack Defs iter, val

Pushes the next iterated value onto the stack. If no value is available, MagicValue(JS_NO_ITER_VALUE) is pushed.

With Statement

JSOP_ENTERWITH [-1, +0] (SCOPE)
Value 3 (0x03)
Operands uint32_t staticWithIndex
Length 5
Stack Uses val
Stack Defs  

Pops the top of stack value, converts it to an object, and adds a WithEnvironmentObject wrapping that object to the scope chain.

There is a matching JSOP_LEAVEWITH instruction later. All name lookups between the two that may need to consult the With object are deoptimized.

JSOP_LEAVEWITH [-0, +0]
Value 4 (0x04)
Operands  
Length 1
Stack Uses  
Stack Defs  

Pops the scope chain object pushed by JSOP_ENTERWITH.

Exception Handling

JSOP_EXCEPTION [-0, +1]
Value 118 (0x76)
Operands  
Length 1
Stack Uses  
Stack Defs exception

Pushes the current pending exception onto the stack and clears the pending exception. This is only emitted at the beginning of code for a catch-block, so it is known that an exception is pending. It is used to implement catch-blocks and yield*.

JSOP_FINALLY [-0, +2]
Value 135 (0x87)
Operands  
Length 1
Stack Uses  
Stack Defs false, (next bytecode's PC)

This opcode has a def count of 2, but these values are already on the stack (they're pushed by JSOP_GOSUB).

JSOP_GOSUB [-0, +0] (JUMP)
Value 116 (0x74)
Operands int32_t offset
Length 5
Stack Uses  
Stack Defs false, (next bytecode's PC)

Pushes false and next bytecode's PC onto the stack, and jumps to a 32-bit offset from the current bytecode.

This opcode is used for entering finally block.

JSOP_RETSUB [-2, +0]
Value 117 (0x75)
Operands  
Length 1
Stack Uses lval, rval
Stack Defs  

Pops the top two values on the stack as rval and lval, converts lval into a boolean, raises error if the result is true, jumps to a 32-bit absolute PC: rval if false.

This opcode is used for returning from finally block.

JSOP_THROW [-1, +0]
Value 112 (0x70)
Operands  
Length 1
Stack Uses v
Stack Defs  

Pops the top of stack value as v, sets pending exception as v, then raises error.

JSOP_THROWING [-1, +0]
Value 151 (0x97)
Operands  
Length 1
Stack Uses v
Stack Defs  

Pops the top of stack value as v, sets pending exception as v, to trigger rethrow.

This opcode is used in conditional catch clauses.

JSOP_THROWMSG [-0, +0] (UINT16)
Value 74 (0x4a)
Operands uint16_t msgNumber
Length 3
Stack Uses  
Stack Defs  

Sometimes we know when emitting that an operation will always throw.

Throws the indicated JSMSG.

JSOP_TRY [-0, +0]
Value 134 (0x86)
Operands  
Length 1
Stack Uses  
Stack Defs  

This no-op appears at the top of the bytecode for a TryStatement.

Location information for catch/finally blocks is stored in a side table, script->trynotes().

Function

JSOP_CALL [-(argc+2), +1] (UINT16, INVOKE, TYPESET)
Value 58 (0x3a)
Operands uint16_t argc
Length 3
Stack Uses callee, this, args[0], ..., args[argc-1]
Stack Defs rval

Invokes callee with this and args, pushes return value onto the stack.

JSOP_CALLITER [-2, +1] (UINT16, INVOKE, TYPESET)
Value 145 (0x91)
Operands uint16_t argc (must be 0)
Length 3
Stack Uses callee, this
Stack Defs rval

Like JSOP_CALL, but used as part of for-of and destructuring bytecode to provide better error messages.

JSOP_EVAL [-(argc+2), +1] (UINT16, INVOKE, TYPESET, CHECKSLOPPY)
Value 123 (0x7b)
Operands uint16_t argc
Length 3
Stack Uses callee, this, args[0], ..., args[argc-1]
Stack Defs rval

Invokes eval with args and pushes return value onto the stack.

If eval in global scope is not original one, invokes the function with this and args, and pushes return value onto the stack.

JSOP_FUNAPPLY [-(argc+2), +1] (UINT16, INVOKE, TYPESET)
Value 79 (0x4f)
Operands uint16_t argc
Length 3
Stack Uses callee, this, args[0], ..., args[argc-1]
Stack Defs rval

Invokes callee with this and args, pushes return value onto the stack.

This is for f.apply.

JSOP_FUNCALL [-(argc+2), +1] (UINT16, INVOKE, TYPESET)
Value 108 (0x6c)
Operands uint16_t argc
Length 3
Stack Uses callee, this, args[0], ..., args[argc-1]
Stack Defs rval

Invokes callee with this and args, pushes return value onto the stack.

If callee is determined to be the canonical Function.prototype.call function, then this operation is optimized to directly call callee with args[0] as this, and the remaining arguments as formal args to callee.

Like JSOP_FUNAPPLY but for f.call instead of f.apply.

JSOP_FUNWITHPROTO [-1, +1] (OBJECT)
Value 52 (0x34)
Operands uint32_t funcIndex
Length 5
Stack Uses proto
Stack Defs obj

Pushes a clone of a function with a given [[Prototype]] onto the stack.

JSOP_GETRVAL [-0, +1]
Value 2 (0x02)
Operands  
Length 1
Stack Uses  
Stack Defs rval

Pushes stack frame's rval onto the stack.

JSOP_LAMBDA [-0, +1] (OBJECT)
Value 130 (0x82)
Operands uint32_t funcIndex
Length 5
Stack Uses  
Stack Defs obj

Pushes a closure for a named or anonymous function expression onto the stack.

JSOP_LAMBDA_ARROW [-1, +1] (OBJECT)
Value 131 (0x83)
Operands uint32_t funcIndex
Length 5
Stack Uses new.target
Stack Defs obj

Pops the top of stack value as new.target, pushes an arrow function with lexical new.target onto the stack.

JSOP_NEW [-(argc+3), +1] (UINT16, INVOKE, TYPESET)
Value 82 (0x52)
Operands uint16_t argc
Length 3
Stack Uses callee, this, args[0], ..., args[argc-1], newTarget
Stack Defs rval

Invokes callee as a constructor with this and args, pushes return value onto the stack.

JSOP_OPTIMIZE_SPREADCALL [-1, +2]
Value 178 (0xb2)
Operands  
Length 1
Stack Uses arr
Stack Defs arr optimized

Pops the top stack value, pushes the value and a boolean value that indicates whether the spread operation for the value can be optimized in spread call.

JSOP_RETRVAL [-0, +0]
Value 153 (0x99)
Operands  
Length 1
Stack Uses  
Stack Defs  

Stops interpretation and returns value set by JSOP_SETRVAL. When not set, returns undefined.

Also emitted at end of script so interpreter don't need to check if opcode is still in script range.

JSOP_RETURN [-1, +0]
Value 5 (0x05)
Operands  
Length 1
Stack Uses rval
Stack Defs  

Pops the top of stack value as rval, stops interpretation of current script and returns rval.

JSOP_RUNONCE [-0, +0]
Value 71 (0x47)
Operands  
Length 1
Stack Uses  
Stack Defs  

Prologue emitted in scripts expected to run once, which deoptimizes code if it executes multiple times.

JSOP_SETFUNNAME [-2, +1] (UINT8)
Value 182 (0xb6)
Operands uint8_t prefixKind
Length 2
Stack Uses fun, name
Stack Defs fun

Pops the top two values on the stack as name and fun, defines the name of fun to name with prefix if any, and pushes fun back onto the stack.

JSOP_SETRVAL [-1, +0]
Value 152 (0x98)
Operands  
Length 1
Stack Uses rval
Stack Defs  

Pops the top of stack value as rval, sets the return value in stack frame as rval.

JSOP_SPREADCALL [-3, +1] (INVOKE, TYPESET)
Value 41 (0x29)
Operands  
Length 1
Stack Uses callee, this, args
Stack Defs rval

spreadcall variant of JSOP_CALL.

Invokes callee with this and args, pushes the return value onto the stack.

args is an Array object which contains actual arguments.

JSOP_SPREADEVAL [-3, +1] (INVOKE, TYPESET, CHECKSLOPPY)
Value 43 (0x2b)
Operands  
Length 1
Stack Uses callee, this, args
Stack Defs rval

spreadcall variant of JSOP_EVAL

Invokes eval with args and pushes the return value onto the stack.

If eval in global scope is not original one, invokes the function with this and args, and pushes return value onto the stack.

JSOP_SPREADNEW [-4, +1] (INVOKE, TYPESET)
Value 42 (0x2a)
Operands  
Length 1
Stack Uses callee, this, args, newTarget
Stack Defs rval

spreadcall variant of JSOP_NEW

Invokes callee as a constructor with this and args, pushes the return value onto the stack.

JSOP_SPREADSUPERCALL [-4, +1] (INVOKE, TYPESET)
Value 166 (0xa6)
Operands  
Length 1
Stack Uses callee, this, args, newTarget
Stack Defs rval

spreadcall variant of JSOP_SUPERCALL.

Behaves exactly like JSOP_SPREADNEW.

JSOP_STRICTEVAL [-(argc+2), +1] (UINT16, INVOKE, TYPESET, CHECKSTRICT)
Value 124 (0x7c)
Operands uint16_t argc
Length 3
Stack Uses callee, this, args[0], ..., args[argc-1]
Stack Defs rval

Invokes eval with args and pushes return value onto the stack.

If eval in global scope is not original one, invokes the function with this and args, and pushes return value onto the stack.

JSOP_STRICTSPREADEVAL [-3, +1] (INVOKE, TYPESET, CHECKSTRICT)
Value 50 (0x32)
Operands  
Length 1
Stack Uses callee, this, args
Stack Defs rval

spreadcall variant of JSOP_EVAL

Invokes eval with args and pushes the return value onto the stack.

If eval in global scope is not original one, invokes the function with this and args, and pushes return value onto the stack.

JSOP_SUPERCALL [-(argc+3), +1] (UINT16, INVOKE, TYPESET)
Value 165 (0xa5)
Operands uint16_t argc
Length 3
Stack Uses callee, this, args[0], ..., args[argc-1], newTarget
Stack Defs rval

Behaves exactly like JSOP_NEW, but allows JITs to distinguish the two cases.

JSOP_TOASYNC [-1, +1]
Value 149 (0x95)
Operands  
Length 1
Stack Uses unwrapped
Stack Defs wrapped

Pops the top of stack value as unwrapped, converts it to async function wrapped, and pushes wrapped back on the stack.

Generator

JSOP_CHECKISOBJ [-1, +1] (UINT8)
Value 14 (0x0e)
Operands uint8_t kind
Length 2
Stack Uses result
Stack Defs result

Checks that the top value on the stack is an object, and throws a TypeError if not. The operand kind is used only to generate an appropriate error message.

JSOP_FINALYIELDRVAL [-1, +0]
Value 204 (0xcc)
Operands  
Length 1
Stack Uses gen
Stack Defs  

Pops the generator and suspends and closes it. Yields the value in the frame's return value slot.

JSOP_GENERATOR [-0, +1]
Value 212 (0xd4)
Operands  
Length 1
Stack Uses  
Stack Defs generator

Initializes generator frame, creates a generator and pushes it on the stack.

JSOP_INITIALYIELD [-1, +1] (UINT24)
Value 202 (0xca)
Operands uint24_t yieldIndex
Length 4
Stack Uses generator
Stack Defs  

Pops the generator from the top of the stack, suspends it and stops interpretation.

JSOP_RESUME [-2, +1] (UINT8, INVOKE)
Value 205 (0xcd)
Operands resume kind (GeneratorObject::ResumeKind)
Length 3
Stack Uses gen, val
Stack Defs rval

Pops the generator and argument from the stack, pushes a new generator frame and resumes execution of it. Pushes the return value after the generator yields.

JSOP_YIELD [-2, +1] (UINT24)
Value 203 (0xcb)
Operands uint24_t yieldIndex
Length 4
Stack Uses rval1, gen
Stack Defs rval2

Pops the generator and the return value rval1, stops interpretation and returns rval1. Pushes sent value from send() onto the stack.

Debugger

JSOP_DEBUGGER [-0, +0]
Value 115 (0x73)
Operands  
Length 1
Stack Uses  
Stack Defs  

Invokes debugger.

JSOP_DEBUGLEAVELEXICALENV [-0, +0]
Value 201 (0xc9)
Operands  
Length 1
Stack Uses  
Stack Defs  

The opcode to assist the debugger.

Variables and Scopes

Variables

JSOP_BINDNAME [-0, +1] (ATOM, NAME, SET)
Value 110 (0x6e)
Operands uint32_t nameIndex
Length 5
Stack Uses  
Stack Defs scope

Looks up name on the scope chain and pushes the scope which contains the name onto the stack. If not found, pushes global scope onto the stack.

JSOP_DEFCONST [-0, +0] (ATOM)
Value 128 (0x80)
Operands uint32_t nameIndex
Length 5
Stack Uses  
Stack Defs  
Defines the new constant binding on global lexical scope.

Throws if a binding with the same name already exists on the scope, or if a var binding with the same name exists on the global.

JSOP_DEFFUN [-1, +0]
Value 127 (0x7f)
Operands  
Length 1
Stack Uses fun
Stack Defs  

Defines the given function on the current scope.

This is used for global scripts and also in some cases for function scripts where use of dynamic scoping inhibits optimization.

JSOP_DEFLET [-0, +0] (ATOM)
Value 162 (0xa2)
Operands uint32_t nameIndex
Length 5
Stack Uses  
Stack Defs  
Defines the new mutable binding on global lexical scope.

Throws if a binding with the same name already exists on the scope, or if a var binding with the same name exists on the global.

JSOP_DEFVAR [-0, +0] (ATOM)
Value 129 (0x81)
Operands uint32_t nameIndex
Length 5
Stack Uses  
Stack Defs  

Defines the new binding on the frame's current variables-object (the scope object on the scope chain designated to receive new variables).

Throws if the current variables-object is the global object and a binding with the same name exists on the global lexical scope.

This is used for global scripts and also in some cases for function scripts where use of dynamic scoping inhibits optimization.

JSOP_DELNAME [-0, +1] (ATOM, NAME, CHECKSLOPPY)
Value 36 (0x24)
Operands uint32_t nameIndex
Length 5
Stack Uses  
Stack Defs succeeded

Looks up name on the scope chain and deletes it, pushes true onto the stack if succeeded (if the property was present and deleted or if the property wasn't present in the first place), false if not.

Strict mode code should never contain this opcode.

JSOP_GETIMPORT [-0, +1] (ATOM, NAME, TYPESET)
Value 176 (0xb0)
Operands uint32_t nameIndex
Length 5
Stack Uses  
Stack Defs val

Gets the value of a module import by name and pushes it onto the stack.

JSOP_GETNAME [-0, +1] (ATOM, NAME, TYPESET)
Value 59 (0x3b)
Operands uint32_t nameIndex
Length 5
Stack Uses  
Stack Defs val

Looks up name on the scope chain and pushes its value onto the stack.

JSOP_SETNAME [-2, +1] (ATOM, NAME, SET, DETECTING, CHECKSLOPPY)
Value 111 (0x6f)
Operands uint32_t nameIndex
Length 5
Stack Uses scope, val
Stack Defs val

Pops a scope and value from the stack, assigns value to the given name, and pushes the value back on the stack

JSOP_STRICTSETNAME [-2, +1] (ATOM, NAME, SET, DETECTING, CHECKSTRICT)
Value 49 (0x31)
Operands uint32_t nameIndex
Length 5
Stack Uses scope, val
Stack Defs val

Pops a scope and value from the stack, assigns value to the given name, and pushes the value back on the stack. If the set failed, then throw a TypeError, per usual strict mode semantics.

Free Variables

JSOP_BINDGNAME [-0, +1] (ATOM, NAME, SET, GNAME)
Value 214 (0xd6)
Operands uint32_t nameIndex
Length 5
Stack Uses  
Stack Defs global

Pushes the global scope onto the stack if the script doesn't have a non-syntactic global scope. Otherwise will act like JSOP_BINDNAME.

nameIndex is only used when acting like JSOP_BINDNAME.

JSOP_BINDVAR [-0, +1]
Value 213 (0xd5)
Operands  
Length 1
Stack Uses  
Stack Defs scope

Pushes the nearest var environment.

JSOP_GETGNAME [-0, +1] (ATOM, NAME, TYPESET, GNAME)
Value 154 (0x9a)
Operands uint32_t nameIndex
Length 5
Stack Uses  
Stack Defs val

Looks up name on global scope and pushes its value onto the stack, unless the script has a non-syntactic global scope, in which case it acts just like JSOP_NAME.

Free variable references that must either be found on the global or a ReferenceError.

JSOP_INITGLEXICAL [-1, +1] (ATOM, NAME, SET, GNAME)
Value 161 (0xa1)
Operands uint32_t nameIndex
Length 5
Stack Uses val
Stack Defs val

Initializes an uninitialized global lexical binding with the top of stack value.

JSOP_SETGNAME [-2, +1] (ATOM, NAME, SET, DETECTING, GNAME, CHECKSLOPPY)
Value 155 (0x9b)
Operands uint32_t nameIndex
Length 5
Stack Uses scope, val
Stack Defs val

Pops the top two values on the stack as val and scope, sets property of scope as val and pushes val back on the stack.

scope should be the global scope unless the script has a non-syntactic global scope, in which case acts like JSOP_SETNAME.

JSOP_STRICTSETGNAME [-2, +1] (ATOM, NAME, SET, DETECTING, GNAME, CHECKSTRICT)
Value 156 (0x9c)
Operands uint32_t nameIndex
Length 5
Stack Uses scope, val
Stack Defs val

Pops the top two values on the stack as val and scope, sets property of scope as val and pushes val back on the stack. Throws a TypeError if the set fails, per strict mode semantics.

scope should be the global scope unless the script has a non-syntactic global scope, in which case acts like JSOP_STRICTSETNAME.

Local Variables

JSOP_CHECKLEXICAL [-0, +0] (LOCAL, NAME)
Value 138 (0x8a)
Operands uint32_t localno
Length 4
Stack Uses  
Stack Defs  

Checks if the value of the local variable is the JS_UNINITIALIZED_LEXICAL magic, throwing an error if so.

JSOP_GETLOCAL [-0, +1] (LOCAL, NAME)
Value 86 (0x56)
Operands uint32_t localno
Length 4
Stack Uses  
Stack Defs val

Pushes the value of local variable onto the stack.

JSOP_INITLEXICAL [-1, +1] (LOCAL, NAME, SET, DETECTING)
Value 139 (0x8b)
Operands uint32_t localno
Length 4
Stack Uses v
Stack Defs v

Initializes an uninitialized local lexical binding with the top of stack value.

JSOP_SETLOCAL [-1, +1] (LOCAL, NAME, SET, DETECTING)
Value 87 (0x57)
Operands uint32_t localno
Length 4
Stack Uses v
Stack Defs v

Stores the top stack value to the given local.

JSOP_THROWSETCALLEE [-1, +1] (SET)
Value 179 (0xb3)
Operands  
Length 1
Stack Uses  
Stack Defs  

Throws a runtime TypeError for invalid assignment to the callee in a named lambda, which is always a const binding. This is a different bytecode than JSOP_SETCONST because the named lambda callee, if not closed over, does not have a frame slot to look up the name with for the error message.

JSOP_THROWSETCONST [-1, +1] (LOCAL, NAME, SET, DETECTING)
Value 169 (0xa9)
Operands uint32_t localno
Length 4
Stack Uses  
Stack Defs  

Throws a runtime TypeError for invalid assignment to const. The localno is used for better error messages.

Aliased Variables

JSOP_CHECKALIASEDLEXICAL [-0, +0] (ENVCOORD, NAME)
Value 140 (0x8c)
Operands uint8_t hops, uint24_t slot
Length 5
Stack Uses  
Stack Defs  

Checks if the value of the aliased variable is the JS_UNINITIALIZED_LEXICAL magic, throwing an error if so.

JSOP_GETALIASEDVAR [-0, +1] (ENVCOORD, NAME, TYPESET)
Value 136 (0x88)
Operands uint8_t hops, uint24_t slot
Length 5
Stack Uses  
Stack Defs aliasedVar

Pushes aliased variable onto the stack.

An "aliased variable" is a var, let, or formal arg that is aliased. Sources of aliasing include: nested functions accessing the vars of an enclosing function, function statements that are conditionally executed, eval, with, and arguments. All of these cases require creating a CallObject to own the aliased variable.

An ALIASEDVAR opcode contains the following immediates:

uint8 hops:  the number of scope objects to skip to find the ScopeObject
             containing the variable being accessed
uint24 slot: the slot containing the variable in the ScopeObject (this
             'slot' does not include RESERVED_SLOTS).
JSOP_INITALIASEDLEXICAL [-1, +1] (ENVCOORD, NAME, SET, DETECTING)
Value 141 (0x8d)
Operands uint8_t hops, uint24_t slot
Length 5
Stack Uses v
Stack Defs v

Initializes an uninitialized aliased lexical binding with the top of stack value.

JSOP_SETALIASEDVAR [-1, +1] (ENVCOORD, NAME, SET, DETECTING)
Value 137 (0x89)
Operands uint8_t hops, uint24_t slot
Length 5
Stack Uses v
Stack Defs v

Sets aliased variable as the top of stack value.

JSOP_THROWSETALIASEDCONST [-1, +1] (ENVCOORD, NAME, SET, DETECTING)
Value 170 (0xaa)
Operands uint8_t hops, uint24_t slot
Length 5
Stack Uses  
Stack Defs  

Throws a runtime TypeError for invalid assignment to const. The scope coordinate is used for better error messages.

Intrinsics

JSOP_GETINTRINSIC [-0, +1] (ATOM, NAME, TYPESET)
Value 143 (0x8f)
Operands uint32_t nameIndex
Length 5
Stack Uses  
Stack Defs intrinsic[name]
Pushes the value of the intrinsic onto the stack.

Intrinsic names are emitted instead of JSOP_*NAME ops when the CompileOptions flag selfHostingMode is set.

They are used in self-hosted code to access other self-hosted values and intrinsic functions the runtime doesn't give client JS code access to.

JSOP_SETINTRINSIC [-1, +1] (ATOM, NAME, SET, DETECTING)
Value 144 (0x90)
Operands uint32_t nameIndex
Length 5
Stack Uses val
Stack Defs val

Stores the top stack value in the specified intrinsic.

Block-local Scope

JSOP_FRESHENLEXICALENV [-0, +0]
Value 197 (0xc5)
Operands  
Length 1
Stack Uses  
Stack Defs  

Replaces the current block on the env chain with a fresh block that copies all the bindings in the bock. This operation implements the behavior of inducing a fresh lexical environment for every iteration of a for(let ...; ...; ...) loop, if any declarations induced by such a loop are captured within the loop.

JSOP_POPLEXICALENV [-0, +0]
Value 200 (0xc8)
Operands  
Length 1
Stack Uses  
Stack Defs  

Pops lexical environment from the env chain.

JSOP_PUSHLEXICALENV [-0, +0] (SCOPE)
Value 199 (0xc7)
Operands uint32_t scopeIndex
Length 5
Stack Uses  
Stack Defs  

Pushes lexical environment onto the env chain.

JSOP_RECREATELEXICALENV [-0, +0]
Value 198 (0xc6)
Operands  
Length 1
Stack Uses  
Stack Defs  

Recreates the current block on the env chain with a fresh block with uninitialized bindings. This operation implements the behavior of inducing a fresh lexical environment for every iteration of a for-in/of loop whose loop-head has a (captured) lexical declaration.

This

JSOP_CHECKRETURN [-1, +0]
Value 190 (0xbe)
Operands  
Length 1
Stack Uses this
Stack Defs  

Check if a derived class constructor has a valid return value and this value before it returns. If the return value is not an object, stores the this value to the return value slot.

JSOP_CHECKTHIS [-1, +1]
Value 189 (0xbd)
Operands  
Length 1
Stack Uses this
Stack Defs this

Throw if the value on top of the stack is the TDZ MagicValue. Used in derived class constructors.

JSOP_CHECKTHISREINIT [-1, +1]
Value 191 (0xbf)
Operands  
Length 1
Stack Uses this
Stack Defs this

Throw an exception if the value on top of the stack is not the TDZ MagicValue. Used in derived class constructors.

JSOP_FUNCTIONTHIS [-0, +1]
Value 185 (0xb9)
Operands  
Length 1
Stack Uses  
Stack Defs this

Determines the this value for current function frame and pushes it onto the stack. Emitted in the prologue of functions with a this-binding.

JSOP_GIMPLICITTHIS [-0, +1] (ATOM)
Value 157 (0x9d)
Operands uint32_t nameIndex
Length 5
Stack Uses  
Stack Defs this

Pushes the implicit this value for calls to the associated name onto the stack; only used when we know this implicit this will be our first non-syntactic scope.

JSOP_GLOBALTHIS [-0, +1]
Value 186 (0xba)
Operands  
Length 1
Stack Uses  
Stack Defs this

Pushes this value for current stack frame onto the stack. Emitted when this refers to the global this.

JSOP_IMPLICITTHIS [-0, +1] (ATOM)
Value 226 (0xe2)
Operands uint32_t nameIndex
Length 5
Stack Uses  
Stack Defs this

Pushes the implicit this value for calls to the associated name onto the stack.

Super

JSOP_SUPERBASE [-0, +1]
Value 103 (0x67)
Operands  
Length 1
Stack Uses  
Stack Defs homeObjectProto

Pushes the prototype of the home object for current callee onto the stack.

JSOP_SUPERFUN [-0, +1]
Value 164 (0xa4)
Operands  
Length 1
Stack Uses  
Stack Defs superFun

Find the function to invoke with |super()| on the scope chain.

Arguments

JSOP_ARGUMENTS [-0, +1]
Value 9 (0x09)
Operands  
Length 1
Stack Uses  
Stack Defs arguments

Pushes the arguments object for the current function activation.

If JSScript is not marked needsArgsObj, then a JS_OPTIMIZED_ARGUMENTS magic value is pushed. Otherwise, a proper arguments object is constructed and pushed.

This opcode requires that the function does not have rest parameter.

JSOP_CALLEE [-0, +1]
Value 132 (0x84)
Operands  
Length 1
Stack Uses  
Stack Defs callee

Pushes current callee onto the stack.

Used for named function expression self-naming, if lightweight.

JSOP_GETARG [-0, +1] (QARG , NAME)
Value 84 (0x54)
Operands uint16_t argno
Length 3
Stack Uses  
Stack Defs arguments[argno]

Fast get op for function arguments and local variables.

Pushes arguments[argno] onto the stack.

JSOP_NEWTARGET [-0, +1]
Value 148 (0x94)
Operands  
Length 1
Stack Uses  
Stack Defs new.target

Push "new.target"

JSOP_REST [-0, +1] (TYPESET)
Value 224 (0xe0)
Operands  
Length 1
Stack Uses  
Stack Defs rest

Creates rest parameter array for current function call, and pushes it onto the stack.

JSOP_SETARG [-1, +1] (QARG , NAME, SET)
Value 85 (0x55)
Operands uint16_t argno
Length 3
Stack Uses v
Stack Defs v

Fast set op for function arguments and local variables.

Sets arguments[argno] as the top of stack value.

Var Scope

JSOP_POPVARENV [-0, +0]
Value 181 (0xb5)
Operands  
Length 1
Stack Uses  
Stack Defs  

Pops a var environment from the env chain.

JSOP_PUSHVARENV [-0, +0] (SCOPE)
Value 180 (0xb4)
Operands uint32_t scopeIndex
Length 5
Stack Uses  
Stack Defs  

Pushes a var environment onto the env chain.

Operators

Comparison Operators

JSOP_EQ [-2, +1] (LEFTASSOC, ARITH, DETECTING)
JSOP_GE [-2, +1] (LEFTASSOC, ARITH)
JSOP_GT [-2, +1] (LEFTASSOC, ARITH)
JSOP_LE [-2, +1] (LEFTASSOC, ARITH)
JSOP_LT [-2, +1] (LEFTASSOC, ARITH)
JSOP_NE [-2, +1] (LEFTASSOC, ARITH, DETECTING)
Value JSOP_EQ: 18 (0x12)
JSOP_GE: 23 (0x17)
JSOP_GT: 22 (0x16)
JSOP_LE: 21 (0x15)
JSOP_LT: 20 (0x14)
JSOP_NE: 19 (0x13)
Operands  
Length 1
Stack Uses lval, rval
Stack Defs (lval OP rval)

Pops the top two values from the stack and pushes the result of comparing them.

JSOP_STRICTEQ [-2, +1] (DETECTING, LEFTASSOC, ARITH)
JSOP_STRICTNE [-2, +1] (DETECTING, LEFTASSOC, ARITH)
Value JSOP_STRICTEQ: 72 (0x48)
JSOP_STRICTNE: 73 (0x49)
Operands  
Length 1
Stack Uses lval, rval
Stack Defs (lval OP rval)

Pops the top two values from the stack, then pushes the result of applying the operator to the two values.

Arithmetic Operators

JSOP_ADD [-2, +1] (LEFTASSOC, ARITH)
Value 27 (0x1b)
Operands  
Length 1
Stack Uses lval, rval
Stack Defs (lval + rval)

Pops the top two values lval and rval from the stack, then pushes the result of lval + rval.

JSOP_DIV [-2, +1] (LEFTASSOC, ARITH)
JSOP_MOD [-2, +1] (LEFTASSOC, ARITH)
JSOP_MUL [-2, +1] (LEFTASSOC, ARITH)
JSOP_SUB [-2, +1] (LEFTASSOC, ARITH)
Value JSOP_DIV: 30 (0x1e)
JSOP_MOD: 31 (0x1f)
JSOP_MUL: 29 (0x1d)
JSOP_SUB: 28 (0x1c)
Operands  
Length 1
Stack Uses lval, rval
Stack Defs (lval OP rval)

Pops the top two values lval and rval from the stack, then pushes the result of applying the arithmetic operation to them.

JSOP_NEG [-1, +1] (ARITH)
Value 34 (0x22)
Operands  
Length 1
Stack Uses val
Stack Defs (-val)

Pops the value val from the stack, then pushes -val.

JSOP_POS [-1, +1] (ARITH)
Value 35 (0x23)
Operands  
Length 1
Stack Uses val
Stack Defs (+val)

Pops the value val from the stack, then pushes +val. (+val is the value converted to a number.)

JSOP_POW [-2, +1] (ARITH)
Value 150 (0x96)
Operands  
Length 1
Stack Uses lval, rval
Stack Defs (lval ** rval)

Pops the top two values lval and rval from the stack, then pushes the result of Math.pow(lval, rval).

Bitwise Logical Operators

JSOP_BITAND [-2, +1] (LEFTASSOC, ARITH)
JSOP_BITOR [-2, +1] (LEFTASSOC, ARITH)
JSOP_BITXOR [-2, +1] (LEFTASSOC, ARITH)
Value JSOP_BITAND: 17 (0x11)
JSOP_BITOR: 15 (0x0f)
JSOP_BITXOR: 16 (0x10)
Operands  
Length 1
Stack Uses lval, rval
Stack Defs (lval OP rval)

Pops the top two values lval and rval from the stack, then pushes the result of the operation applied to the two operands, converting both to 32-bit signed integers if necessary.

JSOP_BITNOT [-1, +1] (ARITH)
Value 33 (0x21)
Operands  
Length 1
Stack Uses val
Stack Defs (~val)

Pops the value val from the stack, then pushes ~val.

Bitwise Shift Operators

JSOP_LSH [-2, +1] (LEFTASSOC, ARITH)
JSOP_RSH [-2, +1] (LEFTASSOC, ARITH)
Value JSOP_LSH: 24 (0x18)
JSOP_RSH: 25 (0x19)
Operands  
Length 1
Stack Uses lval, rval
Stack Defs (lval OP rval)

Pops the top two values lval and rval from the stack, then pushes the result of the operation applied to the operands.

JSOP_URSH [-2, +1] (LEFTASSOC, ARITH)
Value 26 (0x1a)
Operands  
Length 1
Stack Uses lval, rval
Stack Defs (lval >>> rval)

Pops the top two values lval and rval from the stack, then pushes lval >>> rval.

Logical Operators

JSOP_NOT [-1, +1] (ARITH, DETECTING)
Value 32 (0x20)
Operands  
Length 1
Stack Uses val
Stack Defs (!val)

Pops the value val from the stack, then pushes !val.

Special Operators

JSOP_DELELEM [-2, +1] (BYTE , ELEM, CHECKSLOPPY)
Value 38 (0x26)
Operands  
Length 1
Stack Uses obj, propval
Stack Defs succeeded

Pops the top two values on the stack as propval and obj, deletes propval property from obj, pushes true onto the stack if succeeded, false if not.

JSOP_DELPROP [-1, +1] (ATOM, PROP, CHECKSLOPPY)
Value 37 (0x25)
Operands uint32_t nameIndex
Length 5
Stack Uses obj
Stack Defs succeeded

Pops the top of stack value, deletes property from it, pushes true onto the stack if succeeded, false if not.

JSOP_IN [-2, +1] (LEFTASSOC)
Value 113 (0x71)
Operands  
Length 1
Stack Uses id, obj
Stack Defs (id in obj)

Pops the top two values id and obj from the stack, then pushes id in obj. This will throw a TypeError if obj is not an object.

Note that obj is the top value.

JSOP_INSTANCEOF [-2, +1] (LEFTASSOC)
Value 114 (0x72)
Operands  
Length 1
Stack Uses obj, ctor
Stack Defs (obj instanceof ctor)

Pops the top two values obj and ctor from the stack, then pushes obj instanceof ctor. This will throw a TypeError if obj is not an object.

JSOP_STRICTDELPROP [-1, +1] (ATOM, PROP, CHECKSTRICT)
Value 46 (0x2e)
Operands uint32_t nameIndex
Length 5
Stack Uses obj
Stack Defs succeeded

Pops the top of stack value and attempts to delete the given property from it. Pushes true onto success, else throws a TypeError per strict mode property-deletion requirements.

JSOP_TYPEOF [-1, +1] (DETECTING)
Value 39 (0x27)
Operands  
Length 1
Stack Uses val
Stack Defs (typeof val)

Pops the value val from the stack, then pushes typeof val.

JSOP_TYPEOFEXPR [-1, +1] (DETECTING)
Value 196 (0xc4)
Operands  
Length 1
Stack Uses val
Stack Defs (typeof val)

Pops the top stack value as val and pushes typeof val. Note that this opcode isn't used when, in the original source code, val is a name -- see JSOP_TYPEOF for that. (This is because typeof undefinedName === "undefined".)

JSOP_VOID [-1, +1]
Value 40 (0x28)
Operands  
Length 1
Stack Uses val
Stack Defs undefined

Pops the top value on the stack and pushes undefined.

Stack Operations

JSOP_DUP [-1, +2]
Value 12 (0x0c)
Operands  
Length 1
Stack Uses v
Stack Defs v, v

Pushes a copy of the top value on the stack.

JSOP_DUP2 [-2, +4]
Value 13 (0x0d)
Operands  
Length 1
Stack Uses v1, v2
Stack Defs v1, v2, v1, v2

Duplicates the top two values on the stack.

JSOP_DUPAT [-0, +1] (UINT24)
Value 44 (0x2c)
Operands uint24_t n
Length 4
Stack Uses v[n], v[n-1], ..., v[1], v[0]
Stack Defs v[n], v[n-1], ..., v[1], v[0], v[n]

Duplicates the Nth value from the top onto the stack.

JSOP_PICK [-0, +0] (UINT8)
Value 133 (0x85)
Operands uint8_t n
Length 2
Stack Uses v[n], v[n-1], ..., v[1], v[0]
Stack Defs v[n-1], ..., v[1], v[0], v[n]

Picks the nth element from the stack and moves it to the top of the stack.

JSOP_POP [-1, +0]
Value 81 (0x51)
Operands  
Length 1
Stack Uses v
Stack Defs  

Pops the top value off the stack.

JSOP_POPN [-n, +0] (UINT16)
Value 11 (0x0b)
Operands uint16_t n
Length 3
Stack Uses v[n-1], ..., v[1], v[0]
Stack Defs  

Pops the top n values from the stack.

JSOP_SWAP [-2, +2]
Value 10 (0x0a)
Operands  
Length 1
Stack Uses v1, v2
Stack Defs v2, v1

Swaps the top two values on the stack. This is useful for things like post-increment/decrement.

Debugger

JSOP_DEBUGAFTERYIELD [-0, +0]
Value 208 (0xd0)
Operands  
Length 1
Stack Uses  
Stack Defs  

Bytecode emitted after yield expressions to help the Debugger fix up the frame in the JITs. No-op in the interpreter.

Literals

Constants

JSOP_DOUBLE [-0, +1] (DOUBLE)
Value 60 (0x3c)
Operands uint32_t constIndex
Length 5
Stack Uses  
Stack Defs val

Pushes numeric constant onto the stack.

JSOP_FALSE [-0, +1]
JSOP_TRUE [-0, +1]
Value JSOP_FALSE: 66 (0x42)
JSOP_TRUE: 67 (0x43)
Operands  
Length 1
Stack Uses  
Stack Defs true/false

Pushes boolean value onto the stack.

JSOP_INT32 [-0, +1] (INT32)
Value 216 (0xd8)
Operands int32_t val
Length 5
Stack Uses  
Stack Defs val

Pushes 32-bit int immediate integer operand onto the stack.

JSOP_INT8 [-0, +1] (INT8)
Value 215 (0xd7)
Operands int8_t val
Length 2
Stack Uses  
Stack Defs val

Pushes 8-bit int immediate integer operand onto the stack.

JSOP_IS_CONSTRUCTING [-0, +1]
Value 65 (0x41)
Operands  
Length 1
Stack Uses  
Stack Defs JS_IS_CONSTRUCTING

Pushes JS_IS_CONSTRUCTING

JSOP_NULL [-0, +1]
Value 64 (0x40)
Operands  
Length 1
Stack Uses  
Stack Defs null

Pushes null onto the stack.

JSOP_ONE [-0, +1]
Value 63 (0x3f)
Operands  
Length 1
Stack Uses  
Stack Defs 1

Pushes 1 onto the stack.

JSOP_STRING [-0, +1] (ATOM)
Value 61 (0x3d)
Operands uint32_t atomIndex
Length 5
Stack Uses  
Stack Defs string

Pushes string constant onto the stack.

JSOP_SYMBOL [-0, +1] (UINT8)
Value 45 (0x2d)
Operands uint8_t n, the JS::SymbolCode of the symbol to use
Length 2
Stack Uses  
Stack Defs symbol

Push a well-known symbol onto the operand stack.

JSOP_UINT16 [-0, +1] (UINT16)
Value 88 (0x58)
Operands uint16_t val
Length 3
Stack Uses  
Stack Defs val

Pushes unsigned 16-bit int immediate integer operand onto the stack.

JSOP_UINT24 [-0, +1] (UINT24)
Value 188 (0xbc)
Operands uint24_t val
Length 4
Stack Uses  
Stack Defs val

Pushes unsigned 24-bit int immediate integer operand onto the stack.

JSOP_UNDEFINED [-0, +1]
Value 1 (0x01)
Operands  
Length 1
Stack Uses  
Stack Defs undefined

Pushes undefined onto the stack.

JSOP_UNINITIALIZED [-0, +1]
Value 142 (0x8e)
Operands  
Length 1
Stack Uses  
Stack Defs uninitialized

Pushes a JS_UNINITIALIZED_LEXICAL value onto the stack, representing an uninitialized lexical binding.

This opcode is used with the JSOP_INITLET opcode.

JSOP_ZERO [-0, +1]
Value 62 (0x3e)
Operands  
Length 1
Stack Uses  
Stack Defs 0

Pushes 0 onto the stack.

Object

JSOP_CALLELEM [-2, +1] (BYTE , ELEM, TYPESET, LEFTASSOC)
Value 193 (0xc1)
Operands  
Length 1
Stack Uses obj, propval
Stack Defs obj[propval]

Pops the top two values on the stack as propval and obj, pushes propval property of obj onto the stack.

Like JSOP_GETELEM but for call context.

JSOP_CALLPROP [-1, +1] (ATOM, PROP, TYPESET)
Value 184 (0xb8)
Operands uint32_t nameIndex
Length 5
Stack Uses obj
Stack Defs obj[name]

Pops the top of stack value, pushes property of it onto the stack.

Like JSOP_GETPROP but for call context.

JSOP_CALLSITEOBJ [-0, +1] (OBJECT)
Value 101 (0x65)
Operands uint32_t objectIndex
Length 5
Stack Uses  
Stack Defs obj

Pushes the call site object specified by objectIndex onto the stack. Defines the raw property specified by objectIndex + 1 on the call site object and freezes both the call site object as well as its raw property.

JSOP_CHECKOBJCOERCIBLE [-1, +1]
Value 163 (0xa3)
Operands  
Length 1
Stack Uses val
Stack Defs val

Throw if the value on the stack is not coerscible to an object (is |null| or |undefined|).

JSOP_CLASSHERITAGE [-1, +2]
Value 51 (0x33)
Operands  
Length 1
Stack Uses heritage
Stack Defs funcProto, objProto

Writes the [[Prototype]] objects for both a class and its .prototype to the stack, given the result of a heritage expression.

JSOP_GETELEM [-2, +1] (BYTE , ELEM, TYPESET, LEFTASSOC)
Value 55 (0x37)
Operands  
Length 1
Stack Uses obj, propval
Stack Defs obj[propval]

Pops the top two values on the stack as propval and obj, pushes propval property of obj onto the stack.

JSOP_GETELEM_SUPER [-3, +1] (BYTE , ELEM, LEFTASSOC)
Value 125 (0x7d)
Operands  
Length 1
Stack Uses receiver, obj, propval
Stack Defs obj[propval]

LIKE JSOP_GETELEM but takes receiver on stack, and the propval is evaluated before the obj.

JSOP_GETPROP [-1, +1] (ATOM, PROP, TYPESET)
Value 53 (0x35)
Operands uint32_t nameIndex
Length 5
Stack Uses obj
Stack Defs obj[name]

Pops the top of stack value, pushes property of it onto the stack.

JSOP_GETPROP_SUPER [-2, +1] (ATOM, PROP)
Value 104 (0x68)
Operands uint32_t nameIndex
Length 5
Stack Uses receiver obj
Stack Defs obj[name]

Pops the top two values, and pushes the property of one, using the other as the receiver.

JSOP_GETXPROP [-1, +1] (ATOM, PROP, TYPESET)
Value 195 (0xc3)
Operands uint32_t nameIndex
Length 5
Stack Uses obj
Stack Defs obj[name]

Pops the top of stack value, gets an extant property value of it, throwing ReferenceError if the identified property does not exist.

JSOP_INITELEM [-3, +1] (ELEM, SET, DETECTING)
Value 94 (0x5e)
Operands  
Length 1
Stack Uses obj, id, val
Stack Defs obj

Initialize a numeric property in an object literal, like {1: x}.

Pops the top three values on the stack as val, id and obj, defines id property of obj as val, pushes obj onto the stack.

JSOP_INITELEM_GETTER [-3, +1] (ELEM, SET, DETECTING)
Value 99 (0x63)
Operands  
Length 1
Stack Uses obj, id, val
Stack Defs obj

Initialize a numeric getter in an object literal like {get 2() {}}.

Pops the top three values on the stack as val, id and obj, defines id getter of obj as val, pushes obj onto the stack.

JSOP_INITELEM_SETTER [-3, +1] (ELEM, SET, DETECTING)
Value 100 (0x64)
Operands  
Length 1
Stack Uses obj, id, val
Stack Defs obj

Initialize a numeric setter in an object literal like {set 2(v) {}}.

Pops the top three values on the stack as val, id and obj, defines id setter of obj as val, pushes obj onto the stack.

JSOP_INITHIDDENELEM [-3, +1] (ELEM, SET, DETECTING)
Value 175 (0xaf)
Operands  
Length 1
Stack Uses obj, id, val
Stack Defs obj

Initialize a non-enumerable numeric property in an object literal, like {1: x}.

Pops the top three values on the stack as val, id and obj, defines id property of obj as val, pushes obj onto the stack.

JSOP_INITHIDDENELEM_GETTER [-3, +1] (ELEM, SET, DETECTING)
Value 173 (0xad)
Operands  
Length 1
Stack Uses obj, id, val
Stack Defs obj

Initialize a non-enumerable numeric getter in an object literal like {get 2() {}}.

Pops the top three values on the stack as val, id and obj, defines id getter of obj as val, pushes obj onto the stack.

JSOP_INITHIDDENELEM_SETTER [-3, +1] (ELEM, SET, DETECTING)
Value 174 (0xae)
Operands  
Length 1
Stack Uses obj, id, val
Stack Defs obj

Initialize a non-enumerable numeric setter in an object literal like {set 2(v) {}}.

Pops the top three values on the stack as val, id and obj, defines id setter of obj as val, pushes obj onto the stack.

JSOP_INITHIDDENPROP [-2, +1] (ATOM, PROP, SET, DETECTING)
Value 147 (0x93)
Operands uint32_t nameIndex
Length 5
Stack Uses obj, val
Stack Defs obj

Initialize a non-enumerable data-property on an object.

Pops the top two values on the stack as val and obj, defines nameIndex property of obj as val, pushes obj onto the stack.

JSOP_INITHIDDENPROP_GETTER [-2, +1] (ATOM, PROP, SET, DETECTING)
Value 171 (0xab)
Operands uint32_t nameIndex
Length 5
Stack Uses obj, val
Stack Defs obj

Initialize a non-enumerable getter in an object literal.

Pops the top two values on the stack as val and obj, defines getter of obj as val, pushes obj onto the stack.

JSOP_INITHIDDENPROP_SETTER [-2, +1] (ATOM, PROP, SET, DETECTING)
Value 172 (0xac)
Operands uint32_t nameIndex
Length 5
Stack Uses obj, val
Stack Defs obj

Initialize a non-enumerable setter in an object literal.

Pops the top two values on the stack as val and obj, defines setter of obj as val, pushes obj onto the stack.

JSOP_INITHOMEOBJECT [-2, +2] (UINT8)
Value 92 (0x5c)
Operands uint8_t n
Length 2
Stack Uses homeObject, [...n], fun
Stack Defs homeObject, [...n], fun

Initialize the home object for functions with super bindings.

This opcode takes the function and the object to be the home object, does the set, and leaves both on the stack.

JSOP_INITLOCKEDPROP [-2, +1] (ATOM, PROP, SET, DETECTING)
Value 146 (0x92)
Operands uint32_t nameIndex
Length 5
Stack Uses obj, val
Stack Defs obj

Initialize a non-configurable, non-writable, non-enumerable data-property on an object.

Pops the top two values on the stack as val and obj, defines nameIndex property of obj as val, pushes obj onto the stack.

JSOP_INITPROP [-2, +1] (ATOM, PROP, SET, DETECTING)
Value 93 (0x5d)
Operands uint32_t nameIndex
Length 5
Stack Uses obj, val
Stack Defs obj

Initialize a named property in an object literal, like {a: x}.

Pops the top two values on the stack as val and obj, defines nameIndex property of obj as val, pushes obj onto the stack.

JSOP_INITPROP_GETTER [-2, +1] (ATOM, PROP, SET, DETECTING)
Value 97 (0x61)
Operands uint32_t nameIndex
Length 5
Stack Uses obj, val
Stack Defs obj

Initialize a getter in an object literal.

Pops the top two values on the stack as val and obj, defines getter of obj as val, pushes obj onto the stack.

JSOP_INITPROP_SETTER [-2, +1] (ATOM, PROP, SET, DETECTING)
Value 98 (0x62)
Operands uint32_t nameIndex
Length 5
Stack Uses obj, val
Stack Defs obj

Initialize a setter in an object literal.

Pops the top two values on the stack as val and obj, defines setter of obj as val, pushes obj onto the stack.

JSOP_MUTATEPROTO [-2, +1]
Value 194 (0xc2)
Operands  
Length 1
Stack Uses obj, newProto
Stack Defs succeeded

__proto__: v inside an object initializer.

Pops the top two values on the stack as newProto and obj, sets prototype of obj as newProto, pushes true onto the stack if succeeded, false if not.

JSOP_NEWINIT [-0, +1] (UINT8)
Value 89 (0x59)
Operands uint8_t kind (, uint24_t extra)
Length 5
Stack Uses  
Stack Defs obj

Pushes newly created object onto the stack.

This opcode takes the kind of initializer (JSProto_Array or JSProto_Object).

This opcode has three extra bytes so it can be exchanged with JSOP_NEWOBJECT during emit.

JSOP_NEWOBJECT [-0, +1] (OBJECT)
Value 91 (0x5b)
Operands uint32_t baseobjIndex
Length 5
Stack Uses  
Stack Defs obj

Pushes newly created object onto the stack.

This opcode takes an object with the final shape, which can be set at the start and slots then filled in directly.

JSOP_OBJECT [-0, +1] (OBJECT)
Value 80 (0x50)
Operands uint32_t objectIndex
Length 5
Stack Uses  
Stack Defs obj

Pushes deep-cloned object literal or singleton onto the stack.

JSOP_OBJWITHPROTO [-1, +1]
Value 83 (0x53)
Operands  
Length 1
Stack Uses proto
Stack Defs obj

Pushes newly created object onto the stack with provided [[Prototype]].

JSOP_SETELEM [-3, +1] (BYTE , ELEM, SET, DETECTING, CHECKSLOPPY)
Value 56 (0x38)
Operands  
Length 1
Stack Uses obj, propval, val
Stack Defs val

Pops the top three values on the stack as val, propval and obj, sets propval property of obj as val, pushes obj onto the stack.

JSOP_SETELEM_SUPER [-4, +1] (BYTE , ELEM, SET, DETECTING, CHECKSLOPPY)
Value 158 (0x9e)
Operands  
Length 1
Stack Uses propval, receiver, obj, val
Stack Defs val

LIKE JSOP_SETELEM, but takes receiver on the stack, and the propval is evaluated before the base.

JSOP_SETPROP [-2, +1] (ATOM, PROP, SET, DETECTING, CHECKSLOPPY)
Value 54 (0x36)
Operands uint32_t nameIndex
Length 5
Stack Uses obj, val
Stack Defs val

Pops the top two values on the stack as val and obj and performs obj.prop = val, pushing val back onto the stack.

JSOP_SETPROP_SUPER [-3, +1] (ATOM, PROP, SET, DETECTING, CHECKSLOPPY)
Value 107 (0x6b)
Operands uint32_t nameIndex
Length 5
Stack Uses receiver, obj, val
Stack Defs val

Pops the top three values on the stack as val, obj and receiver, and performs obj.prop = val, pushing val back onto the stack.

JSOP_STRICTDELELEM [-2, +1] (ELEM, CHECKSTRICT)
Value 47 (0x2f)
Operands  
Length 1
Stack Uses obj, propval
Stack Defs succeeded

Pops the top two values on the stack as propval and obj, and attempts to delete propval property from obj. Pushes true onto the stack on success, else throws a TypeError per strict mode property deletion requirements.

JSOP_STRICTSETELEM [-3, +1] (BYTE , ELEM, SET, DETECTING, CHECKSTRICT)
Value 57 (0x39)
Operands  
Length 1
Stack Uses obj, propval, val
Stack Defs val

Pops the top three values on the stack as val, propval and obj, sets propval property of obj as val, pushes obj onto the stack. Throws a TypeError if the set fails, per strict mode semantics.

JSOP_STRICTSETELEM_SUPER [-4, +1] (BYTE , ELEM, SET, DETECTING, CHECKSTRICT)
Value 159 (0x9f)
Operands  
Length 1
Stack Uses propval, receiver, obj, val
Stack Defs val

LIKE JSOP_STRICTSETELEM, but takes receiver on the stack, and the propval is evaluated before the base.

JSOP_STRICTSETPROP [-2, +1] (ATOM, PROP, SET, DETECTING, CHECKSTRICT)
Value 48 (0x30)
Operands uint32_t nameIndex
Length 5
Stack Uses obj, val
Stack Defs val

Pops the top two values on the stack as val and obj, and performs obj.prop = val, pushing val back onto the stack. Throws a TypeError if the set-operation failed (per strict mode semantics).

JSOP_STRICTSETPROP_SUPER [-3, +1] (ATOM, PROP, SET, DETECTING, CHECKSTRICT)
Value 105 (0x69)
Operands uint32_t nameIndex
Length 5
Stack Uses receiver, obj, val
Stack Defs val

Pops the top three values on the stack as val and obj, and receiver, and performs obj.prop = val, pushing val back onto the stack. Throws a TypeError if the set-operation failed (per strict mode semantics).

JSOP_TOID [-1, +1]
Value 225 (0xe1)
Operands  
Length 1
Stack Uses propertyNameValue
Stack Defs propertyKey

Replace the top-of-stack value propertyNameValue with ToPropertyKey(propertyNameValue).

Array

JSOP_ARRAYPUSH [-2, +0]
Value 206 (0xce)
Operands  
Length 1
Stack Uses v, obj
Stack Defs  

Pops the top two values on the stack as obj and v, pushes v to obj.

This opcode is used for Array Comprehension.

JSOP_HOLE [-0, +1]
Value 218 (0xda)
Operands  
Length 1
Stack Uses  
Stack Defs hole

Pushes a JS_ELEMENTS_HOLE value onto the stack, representing an omitted property in an array literal (e.g. property 0 in the array [, 1]).

This opcode is used with the JSOP_NEWARRAY opcode.

JSOP_INITELEM_ARRAY [-2, +1] (UINT32, ELEM, SET, DETECTING)
Value 96 (0x60)
Operands uint32_t index
Length 5
Stack Uses obj, val
Stack Defs obj

Initialize an array element.

Pops the top two values on the stack as val and obj, sets index property of obj as val, pushes obj onto the stack.

JSOP_INITELEM_INC [-3, +2] (ELEM, SET)
Value 95 (0x5f)
Operands  
Length 1
Stack Uses obj, index, val
Stack Defs obj, (index + 1)

Pops the top three values on the stack as val, index and obj, sets index property of obj as val, pushes obj and index + 1 onto the stack.

This opcode is used in Array literals with spread and spreadcall arguments.

JSOP_LENGTH [-1, +1] (ATOM, PROP, TYPESET)
Value 217 (0xd9)
Operands uint32_t nameIndex
Length 5
Stack Uses obj
Stack Defs obj['length']

Pops the top of stack value, pushes the length property of it onto the stack.

JSOP_NEWARRAY [-0, +1] (UINT32)
Value 90 (0x5a)
Operands uint32_t length
Length 5
Stack Uses  
Stack Defs obj

Pushes newly created array onto the stack.

This opcode takes the final length, which is preallocated.

JSOP_NEWARRAY_COPYONWRITE [-0, +1] (OBJECT)
Value 102 (0x66)
Operands uint32_t objectIndex
Length 5
Stack Uses  
Stack Defs obj

Pushes a newly created array onto the stack, whose elements are the same as that of a template object's copy on write elements.

JSOP_SPREADCALLARRAY [-0, +1] (UINT32)
Value 126 (0x7e)
Operands uint32_t length
Length 5
Stack Uses  
Stack Defs obj

Pushes newly created array for a spread call onto the stack. This has the same semantics as JSOP_NEWARRAY, but is distinguished to avoid using unboxed arrays in spread calls, which would make compiling spread calls in baseline more complex.

RegExp

JSOP_REGEXP [-0, +1] (REGEXP)
Value 160 (0xa0)
Operands uint32_t regexpIndex
Length 5
Stack Uses  
Stack Defs regexp

Pushes a regular expression literal onto the stack. It requires special "clone on exec" handling.

Class

JSOP_CLASSCONSTRUCTOR [-0, +1] (ATOM)
Value 167 (0xa7)
Operands atom className
Length 5
Stack Uses  
Stack Defs constructor

Push a default constructor for a base class literal.

JSOP_DERIVEDCONSTRUCTOR [-1, +1] (ATOM)
Value 168 (0xa8)
Operands atom className
Length 5
Stack Uses  
Stack Defs constructor

Push a default constructor for a derived class literal.

Other

JSOP_DEBUGCHECKSELFHOSTED [-1, +1]
Value 177 (0xb1)
Operands  
Length 1
Stack Uses checkVal
Stack Defs checkVal

Examines the top stack value, asserting that it's either a self-hosted function or a self-hosted intrinsic. This opcode does nothing in a non-debug build.

JSOP_FORCEINTERPRETER [-0, +0]
Value 207 (0xcf)
Operands  
Length 1
Stack Uses  
Stack Defs  

No-op bytecode only emitted in some self-hosted functions. Not handled by the JITs so the script always runs in the interpreter.

JSOP_JUMPTARGET [-0, +0]
Value 230 (0xe6)
Operands  
Length 1
Stack Uses  
Stack Defs  

This opcode is a no-op and it indicates the location of a jump instruction target. Some other opcodes act as jump targets, such as LOOPENTRY, as well as all which are matched by BytecodeIsJumpTarget function.

JSOP_LINENO [-0, +0] (UINT32)
Value 119 (0x77)
Operands uint32_t lineno
Length 5
Stack Uses  
Stack Defs  

Embedded lineno to speedup pc->line mapping.

JSOP_NOP [-0, +0]
Value 0 (0x00)
Operands  
Length 1
Stack Uses  
Stack Defs  

No operation is performed.

JSOP_NOP_DESTRUCTURING [-0, +0]
Value 229 (0xe5)
Operands  
Length 1
Stack Uses  
Stack Defs  

No-op used by the decompiler to produce nicer error messages about destructuring code.

JSOP_TOSTRING [-1, +1]
Value 228 (0xe4)
Operands  
Length 1
Stack Uses val
Stack Defs ToString(val)

Converts the value on the top of the stack to a String

Document Tags and Contributors

Tags: 
 Contributors to this page: arai, teoli, h4writer, fscholz, evilpie, guptha, Waldo, cdleary
 Last updated by: arai,