xref: /docs/en/application-dev/arkts-utils/arkts-bytecode-fundamentals.md

# Ark Bytecode Fundamentals

## Overall Design
### Overview
Ark bytecode is a binary file generated by the ArkCompiler from ArkTS/TS/JS code and provided for Ark Runtime to interpret and execute. Bytecode mainly contains Ark bytecode instructions.<br>
This topic introduces the design of these instructions, covering key concepts, specific formats, and meanings to help you understand and work with Ark bytecode instructions effectively.<br>
An Ark bytecode instruction consists of an operation code (instruction name) and a list of parameters. An operation code can be prefix-free or prefixed. Registers, immediate values, string id, method id, and literal id can be used as parameters. In addition, the accumulator can be used as a default parameter in some instructions.<br>
In addition to registers and accumulator, Ark bytecode supports four value storage mechanisms: global variables, [module](https://262.ecma-international.org/12.0/#sec-ecmascript-language-scripts-and-modules) namespaces and variables, lexical environments and variables, and patch variables. Instructions can reference values from these storage locations as parameters.

### Terms and Constraints
#### Terms
The following table lists the terms used in this topic.

|     Term     |      Description       |
|   ----------  |    ----------   |
|  acc         |	Accumulator, a special register in the Ark bytecode, used to store the default input or output values for most instructions.  |
|  bit	|  A binary digit, represented as a bit in this topic.  |
|  hole	|  An uninitialized object or variable.  |
|  id	|  Index, a general term for string id, method id, or literal id.  |
|  string id	|  A 16-bit number indexing a string.  |
|  method id	|  A 16-bit number indexing a method.  |
|  literal id  |     A 16-bit number indexing a literal array.  |
|  lexical environment	|  A semantic environment storing closure variables.  |
|  lexical variable	|  A closure variable stored in the lexical environment.  |

#### Constraints
* All code examples provided in this topic adhere to the [ArkTS language specifications](../quick-start/introduction-to-arkts.md).
* This topic is applicable only to Ark bytecode of version 12.0.6.0. The version number is an internal field of the ArkCompiler and does not require your attention.

### Bytecode Composition
#### Operation Codes and Prefixes
Operation codes in Ark bytecode are typically 8-bit values, allowing for up to 256 unique opcodes. However, as the ArkCompiler's functionality has expanded, the number of operation codes has exceeded 256. To accommodate this, the Ark bytecode introduces prefixes, expanding the maximum operation code width from 8 bits to 16 bits. 8-bit operation codes (prefix-free) are used for common instructions, whereas 16-bit operation codes (prefixed) are used for less frequent ones.<br>
Prefixed operation codes are stored in little-endian format, composed of an 8-bit operation code and an 8-bit prefix. During encoding, the operation code is shifted left by 8 bits and then ORed with the prefix.
|     Prefix     |      Mnemonic       |      Description       |
|     ----------  |    ----------   |    ----------   |
|  0xfe	  |  throw	|  Conditional/Unconditional **throw** instruction.|
|  0xfd	  |  wide	|  Instructions with wider encoding widths for immediate values, IDs, or register indexes. |
|  0xfc	  |  deprecated	 |  Instructions no longer generated by the ArkCompiler. They are used only for runtime compatibility.<br>These instructions are not described in the following sections.|
|  0xfb	  |  callruntime | 	Instructions for calling runtime methods. |

The mnemonic form of a prefixed operation code is **prefix mnemonic.operation code mnemonic**. For example, **wide.stlexvar** combines the prefix **wide** (**0xfd**) with the operation code **stlexvar** (**0x0d**), resulting in the prefixed operation code **0x0dfd**.

#### Registers and Accumulator
The Ark Virtual Machine (VM) uses a register-based model with virtual registers. When a register holds a primitive value, it is 64 bits wide; when it holds an object reference, its width adjusts accordingly.<br>
A special invisible register called the accumulator (acc) is used in the Ark bytecode. The acc serves as the default target for many instructions and as a default parameter for others, helping to produce more compact bytecode without consuming additional encoding width.<br>

Example:
```ts
function foo(): number {
    return 1;
}
```
Related instructions in the bytecode:
```assembly
.function any .foo(any a0, any a1, any a2) {
    ldai 0x1
    return
}
```
*ldai 0x1*: loads integer literal 1 to the acc.<br>
*return*: returns the value in the acc.

#### immediate values
Some instructions use constants to represent integer values, double-precision floating-point values, or jump offsets. These constants, known as immediate values, can be 8-bit, 16-bit, 32-bit, or 64-bit.

#### Method, String, and Literal Indexes
The Ark bytecode stores offsets for all methods, strings, and literal arrays used in the source file. Literal arrays contain various literals, such as integer numbers, string offsets, and method offsets. In Ark bytecode instructions, these indexes are 16-bit values, referred to as method indexes (method id), string indexes (string id), and literal indexes (literal id). These indexes are encoded in instructions to reference methods, strings, and literal arrays.

### Value Storage Mechanisms
#### Global Variables
In [Script](https://262.ecma-international.org/12.0/#sec-ecmascript-language-scripts-and-modules) build mode, global variables are stored in a globally unique mapping, with the variable name as the key and its value as the value. Global variables can be accessed using global-related instructions.<br>

Example:
```ts
function foo(): void {
    a += 2;
    b = 5;
}
```
Related instructions in the bytecode:
```assembly
.function any .foo(any a0, any a1, any a2) {
    tryldglobalbyname 0x0, a
    sta v4
    ldai 0x2
    add2 0x1, v4
    trystglobalbyname 0x2, a
    ldai 0x5
    trystglobalbyname 0x3, b
    ...
}
```
*tryldglobalbyname 0x0, a*: loads a global variable named **a** to the acc. If this variable does not exist, an exception is thrown.<br>
*trystglobalbyname 0x2, a*: stores the value of the acc to a global variable named **a**. If this variable does not exist, an exception is thrown.<br>
*trystglobalbyname 0x3, b*: stores the value of the acc to a global variable named **b**. If this variable does not exist, an exception is thrown.<br>

> **NOTE**
>
> **0x0**, **0x2**, and **0x3** in the preceding instructions are reserved for internal use in the Ark Runtime.

#### Module Namespaces and Variables
All [module namespaces](https://262.ecma-international.org/12.0/#module-namespace-exotic-object) used in the source file are compiled into arrays, referenced by instructions using indexes. For example, *getmodulenamespace 0x1* references the module namespace at index *0x1*.<br>
All module variables used in the source file are compiled into arrays, referenced by instructions using indexes. For example, *stmodulevar 0x1* references a module variable at index *0x1*.<br>
In a function, if the declaration of a module variable is in the same source file as the function, the variable is called a local module variable. Otherwise, it is called an external module variable. For example, *ldlocalmodulevar* and *ldexternalmodulevar* are used to load local module variables and external module variables, respectively.<br>
Scenarios for generating module instructions include [import](https://262.ecma-international.org/12.0/#sec-imports) and [export](https://262.ecma-international.org/12.0/#sec-exports). The main scenarios are as follows:
* **import * as**: module namespace
* **import { }**: module variable
* **export**: local export

> **NOTE**
>
> Module-related logic is an internal implementation detail of the compiler. As the ArkCompiler evolves, new scenarios involving module instructions may emerge, and existing ones may change due to evolving requirements or code refactoring.<br>

Example:
```ts
import { a, b } from "./module_foo"
import * as c from "./module_bar"

export let d: number = 3;

a + b + d;
```
Related instructions in the bytecode:
```assembly
.function any .func_main_0(any a0, any a1, any a2) {
    getmodulenamespace 0x1
    ldai 0x3
    stmodulevar 0x0
    ldexternalmodulevar 0x0
    sta v0
    throw.undefinedifholewithname a
    ldexternalmodulevar 0x1
    sta v1
    throw.undefinedifholewithname b
    lda v1
    add2 0x0, v0
    sta v0
    ldlocalmodulevar 0x0
    sta v1
    throw.undefinedifholewithname d
    lda v1
    add2 0x1, v0
    ...
}
```
*getmodulenamespace 0x1*: obtains the module namespace (c) of slot 1 and stores it in the acc.<br>
*stmodulevar 0x0*: stores the values in the acc into slot 0 of the current module.<br>
*ldexternalmodulevar 0x0*: loads the value (a) of slot 0 of the external module and stores it in the acc.<br>
*ldlocalmodulevar 0x0*: loads the value (d) of slot 0 of the current local module and stores it in the acc.

#### Lexical Environments and Lexical Variables
In Ark bytecode, a lexical environment may be considered as an array with multiple slots, and each slot corresponds to one lexical variable. A method may contain multiple lexical environments. Instructions reference lexical variables using the relative nesting level and slot index of the lexical environment. For example, *ldlexvar 0x1, 0x2* loads the value from slot 0x2 of the lexical environment one level outside the current lexical environment into the acc.
```
|xxx|xxx|xxx|xxx|   <-- Lexical environment one level outside the current lexical environment.
         ^
         |------------ ldlexvar 0x1, 0x2

|xxx|xxx|xxx|xxx|   <-- Current lexical environment.
```
**NOTE**<br>
The logic related to **lexical** is used in the compiler. With subsequent evolution of the ArkCompiler, new scenarios involving lexical instructions may emerge. On the other hand, existing **lexical** instruction-related scenarios may no longer generates **lexical** instructions as requirements evolve and code is reconstructed.
Example:
```ts
function foo(): void {
    let a: number = 1;
    function bar(): number {
        return a;
    }
}
```
Related instructions in the bytecode:
```assembly
.function any .foo(any a0, any a1, any a2) {
    newlexenv 0x1
    ...
    definefunc 0x0, .bar, 0x0
    sta v3
    ldai 0x1
    ...
    stlexvar 0x0, 0x0
    ...
}

.function any .bar(any a0, any a1, any a2) {
    ...
    ldlexvar 0x0, 0x0
    ...
}
```
*newlexenv 0x1*: creates a lexical environment with one slot, stores it in the acc, and enters this environment.<br>
*stlexvar 0x0, 0x0*: stores the value in the acc into slot 0 of the lexical environment 0 level outside the current lexical environment.<br>
*ldlexvar 0x0, 0x0*: stores the value from slot 0 of the lexical environment 0 level outside the current lexical environment into the acc.

#### Shared Lexical Environments
Shared lexical environments are a special type of lexical environment Unlike regular lexical environments, each lexical variable in a shared lexical environment is a [Sendable object](arkts-sendable.md). The ArkCompiler uses shared lexical environments to enable sharing of lexical variables across multiple threads.

Example:
```ets
@Sendable
class A { }

@Sendable
class B {
    u: A = new A()
}
```
Related instructions in the bytecode:
```assembly
.function any .#~B=#B(any a0, any a1, any a2) {
label_1:
label_0:
	callruntime.ldsendablevar 0x0, 0x0
	sta v0
	throw.undefinedifholewithname A
	...
label_2:
}

.function any .func_main_0(any a0, any a1, any a2) {
label_1:
label_0:
	callruntime.newsendableenv 0x1
	...
	callruntime.definesendableclass 0x0, .#~A=#A, _3, 0x0, v0
	callruntime.stsendablevar 0x0, 0x0
	...
label_2:
}
```
an instruction callruntime.newsendableenv 0x1: creates a shared lexical environment with one slot and enters this lexical environment.<br>
*callruntime.stsendablevar 0x0, 0x0*: stores the value in the acc into slot 0 of the lexical environment outside level 0.<br>
*callruntime.ldsendablevar 0x0, 0x0*: stores the value from slot 0 of the lexical environment 0 level outside the current lexical environment into the acc.

#### Patch Variables
The ArkCompiler supports patch mode compilation. When a source file is modified, patch mode compilation generates a patch bytecode that, together with the original bytecode, completes the functional update. During patch mode compilation, patch variables generated by the ArkCompiler are stored in a special patch lexical environment. Instructions in the Ark bytecode use slot numbers from the patch lexical environment to reference patch variables. For example, the instruction *ldpatchvar 0x1* is used to load the patch variable from slot 1.<br>

Example:
```ts
function bar(): void {} // Add a statement and compile the patch.

function foo(): void {
    bar(); // Add a statement and compile the patch.
}
```
Related instructions in the bytecode:
```assembly
.function any foo(...) {
    ...
    wide.ldpatchvar 0x0
    sta v4
    lda v4
    callarg0 0x0
    ...
}

.function any patch_main_0(...) {
    newlexenv 0x1
    definefunc 0x1, bar:(any,any,any), 0x0
    wide.stpatchvar 0x0
    ...
}
```
*wide.stpatchvar 0x0*: stores the **bar** function into slot 0 of the patch lexical environment.<br>
*wide.ldpatchvar 0x0*: stores the value from slot 0 in the patch lexical environment into the acc.

### Function Call Specifications
For a method with N formal parameters, the last N+3 registers are used to pass parameters. The first three registers are fixed to represent the function object (FunctionObject), [new.target](https://262.ecma-international.org/12.0/#sec-function-environment-records) (NewTarget), and **this** from the lexical environment where the function resides. The subsequent N registers correspond to the N formal parameters.<br>

Example:
```ts
function foo(a: number, b: number): void {}
```
Related instructions in the bytecode:
```assembly
.function any .foo(any a0, any a1, any a2, any a3, any a4) {
    // a0: FunctionObject
    // a1: NewTarget
    // a2: this
    // a3: a
    // a4: b
}
```

## Bytecode Format Description
|     Mnemonic     |      Semantic Description      |
|   ----------   |    ----------   |
|  ID16	 |  8-bit operation code and 16-bit id  |
|  IMM16	 |  8-bit operation code and 16-bit immediate value  |
|  IMM16_ID16	 |  8-bit operation code, 16-bit immediate value, and 16-bit id  |
|  IMM16_ID16_ID16_IMM16_V8	 |  8-bit operation code, 16-bit immediate value, two 16-bit id, 16-bit immediate value, and 8-bit register  |
|  IMM16_ID16_IMM8	 |  8-bit operation code, 16-bit immediate value, 16-bit id, and 8-bit immediate value  |
|  IMM16_ID16_V8	 |  8-bit operation code, 16-bit immediate value, 16-bit id, and 8-bit register  |
|  IMM16_IMM16	 |  8-bit operation code and two 16-bit immediate values  |
|  IMM16_IMM8_V8	 |  8-bit operation code, 16-bit immediate value, 8-bit immediate value, and 8-bit register  |
|  IMM16_V8	 |  8-bit operation code, 16-bit immediate value, and 8-bit register  |
|  IMM16_V8_IMM16	 |  8-bit operation code, 16-bit immediate value, 8-bit register, and 16-bit immediate value  |
|  IMM16_V8_V8	 |  8-bit operation code, 16-bit immediate value, and two 8-bit registers  |
|  IMM32	 |  8-bit operation code and 32-bit immediate value  |
|  IMM4_IMM4	 |  8-bit operation code and two 4-bit immediate values  |
|  IMM64	 |  8-bit operation code and 64-bit immediate value  |
|  IMM8	 |  8-bit operation code and 8-bit immediate value  |
|  IMM8_ID16	 |  8-bit operation code, 8-bit immediate value, and 16-bit id  |
|  IMM8_ID16_ID16_IMM16_V8	 |  8-bit operation code, 8-bit immediate value, two 16-bit id, 16-bit immediate value, and 8-bit register  |
|  IMM8_ID16_IMM8	 |  8-bit operation code, 8-bit immediate value, 16-bit id, 8-bit immediate value  |
|  IMM8_ID16_V8	 |  8-bit operation code, 8-bit immediate value, 16-bit id, and 8-bit register  |
|  IMM8_IMM16	 |  8-bit operation code, 8-bit immediate value, and 16-bit immediate value  |
|  IMM8_IMM8	 |  8-bit operation code and two 8-bit immediate values  |
|  IMM8_IMM8_V8	 |  8-bit operation code, two 8-bit immediate values, and 8-bit register  |
|  IMM8_V8	 |  8-bit operation code, 8-bit immediate value, and 8-bit register  |
|  IMM8_V8_IMM16	 |  8-bit operation code, 8-bit immediate value, 8-bit register, and 16-bit immediate value  |
|  IMM8_V8_V8	 |  8-bit operation code, 8-bit immediate value, and two 8-bit registers  |
|  IMM8_V8_V8_V8	 |  8-bit operation code, 8-bit immediate value, and three 8-bit registers  |
|  IMM8_V8_V8_V8_V8	 |  8-bit operation code, 8-bit immediate value, and four 8-bit registers  |
|  NONE	 |  8-bit operation code  |
|  PREF_IMM16	 |  16-bit prefixed operation code, 16-bit immediate value  |
|  PREF_IMM16_ID16	 |  16-bit prefixed operation code, 16-bit immediate value, and 16-bit id  |
|  PREF_IMM16_V8	 |  16-bit prefixed operation code, 16-bit immediate value, and 8-bit register  |
|  PREF_IMM16_V8_V8	 |  16-bit prefixed operation code, 16-bit immediate value, and two 8-bit registers  |
|  PREF_IMM8	 |  16-bit prefixed operation code and 8-bit immediate value  |
|  PREF_NONE	 |  16-bit prefixed operation code  |
|  PREF_V8	 |  16-bit prefixed operation code and 8-bit register  |
|  PREF_V8_ID16	 |  16-bit prefixed operation code, 8-bit register, and 16-bit id  |
|  PREF_V8_IMM32	 |  16-bit prefixed operation code, 8-bit register, and 32-bit immediate value  |
|  V16_V16	 |  8-bit operation code and two 16-bit registers  |
|  V4_V4	 |  8-bit operation code and two 4-bit registers  |
|  V8	 |  8-bit operation code and 8-bit register  |
|  V8_IMM16	 |  8-bit operation code, 8-bit register, and 16-bit immediate value  |
|  V8_IMM8	 |  8-bit operation code, 8-bit register, and 8-bit immediate value  |
|  V8_V8	 |  8-bit operation code and two 8-bit registers  |
|  V8_V8_V8	 |  8-bit operation code and three 8-bit registers  |
|  V8_V8_V8_V8	 |  8-bit operation code and four 8-bit registers  |

## Bytecode Summary
The table below summarizes all Ark bytecode instructions in the current version. The register index, immediate value, and id are described using a character to represent each four-bit width.<br>
For example, consider the instruction *defineclasswithbuffer RR, @AAAA, @BBBB, +CCCC, vDD*:<br>
* *defineclasswithbuffer*: mnemonic for the operation code.
* *RR*: 8-bit reserved number used internally during the Ark runtime. The number mentioned here is just an example showing a complete instruction format.
* *@AAAA, @BBBB*: 16-bit id
* *+CCCC*: 16-bit immediate value
* *vDD*: 8-bit register index

|    Operation Code  |   Format   |  Mnemonic/Syntax  |     Parameters      |      Description    |
|   -------   |  -------  |  ----------  |   ----------   |   --------   |
|  0x00	|  NONE	|  ldundefined	|   |  	Loads **undefined** to the acc.  |
|  0x01	|  NONE	|  ldnull	|   |  	Loads **null** to the acc.  |
|  0x02	|  NONE	|  ldtrue	|   |  	Loads **true** to the acc.  |
|  0x03	|  NONE	|  ldfalse	|   |  	Loads **false** to the acc.  |
|  0x04	|  NONE	|  createemptyobject	|   |  	Creates an empty object and stores it in the acc.  |
|  0x05	|  IMM8|  	createemptyarray RR	|  R: 8-bit reserved number used in Ark runtime|  Creates an empty array and stores it in the acc.  |
|  0x06	|  IMM8_ID16	|  createarraywithbuffer RR, @AAAA	|  R: 8-bit reserved number used in Ark runtime<br>A: 16-bit literal id|  Uses the literal array corresponding to index A to create an array object and stores it in the acc.  |
|  0x07	|  IMM8_ID16	|  createobjectwithbuffer RR, @AAAA	|  R: 8-bit reserved number used in Ark runtime<br>A: 16-bit literal id|  Uses the literal array corresponding to index A to create an object and stores it in the acc.  |
|  0x08	|  IMM8_IMM8_V8	|  newobjrange RR, +AA, vBB	|  R: 8-bit reserved number used in Ark runtime<br>A: number of parameters<br>B: class object<br>B + 1, ..., B + A - 1: parameter passed to the constructor|  	Uses **B + 1, ..., B + A - 1** as a parameter to create an instance of class B and stores it in the acc.  |
|  0x09	|  IMM8	|  newlexenv +AA	|  A: number of slots in the lexical environment|  Creates a lexical environment with slot A, stores it in the acc, and enters the lexical environment.  |
|  0x0a	|  IMM8_V8	|  add2 RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A + acc` and stores the result in the acc.  |
|  0x0b	|  IMM8_V8	|  sub2 RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A - acc` and stores the result in the acc.  |
|  0x0c	|  IMM8_V8	|  mul2 RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A * acc` and stores the result in the acc.  |
|  0x0d	|  IMM8_V8	|  div2 RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A / acc` and stores the result in the acc.  |
|  0x0e	|  IMM8_V8	|  mod2 RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A % acc` and stores the result in the acc.  |
|  0x0f	|  IMM8_V8	|  eq RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A == acc` and stores the result in the acc.  |
|  0x10	|  IMM8_V8	|  noteq RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A != acc` and stores the result in the acc.  |
|  0x11	|  IMM8_V8	|  less RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A < acc` and stores the result in the acc.  |
|  0x12	|  IMM8_V8	|  lesseq RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A <= acc` and stores the result in the acc.  |
|  0x13	|  IMM8_V8	|  greater RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A > acc` and stores the result in the acc.  |
|  0x14	|  IMM8_V8	|  greatereq RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A >= acc` and stores the result in the acc.  |
|  0x15	|  IMM8_V8	|  shl2 RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A << acc` and stores the result in the acc.  |
|  0x16	|  IMM8_V8	|  shr2 RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A >>> acc` and stores the result in the acc.  |
|  0x17	|  IMM8_V8	|  ashr2 RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A >> acc` and stores the result in the acc.  |
|  0x18	|  IMM8_V8	|  and2 RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A & acc` and stores the result in the acc.  |
|  0x19	|  IMM8_V8	|  or2 RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A \| acc` and stores the result in the acc.  |
|  0x1a	|  IMM8_V8	|  xor2 RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A ^ acc` and stores the result in the acc.
|  0x1b	|  IMM8_V8	|  exp RR, vAA	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime<br>A: operand|  Calculates `A ** acc` and stores the result in the acc.  |
|  0x1c	|  IMM8	|  typeof RR	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime|  Calculates `typeof acc` and stores the result in the acc.  |
|  0x1d	|  IMM8	|  tonumber RR	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime|  Uses the acc as a parameter, executes [ToNumber](https://262.ecma-international.org/12.0/#sec-tonumber), and stores the result in the acc.  |
|  0x1e	|  IMM8	|  tonumeric RR	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime|  Uses the acc as a parameter, executes [ToNumeric](https://262.ecma-international.org/12.0/#sec-tonumeric), and stores the result in the acc.  |
|  0x1f	|  IMM8	|  neg RR	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime|  Calculates `-acc` and stores the result in the acc.  |
|  0x20	|  IMM8	|  not RR	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime|  Calculates `~acc` and stores the result in the acc.  |
|  0x21	|  IMM8	|  inc RR	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime|  Calculates `acc + 1` and stores the result in the acc.  |
|  0x22	|  IMM8	|  dec RR	|  Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime|  Calculates `acc - 1` and stores the result in the acc.  |
|  0x23	|  NONE	|  istrue	|  Default input parameter: acc: object|  Calculates `acc == true` and stores the result in the acc.  |
|  0x24	|  NONE	|  isfalse	|  Default input parameter: acc: object|  Calculates `acc == false` and stores the result in the acc.  |
|  0x25	|  IMM8_V8	|  isin RR, vAA	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime<br>A: Object|  Calculates `A in acc` and stores the result in the acc.  |
|  0x26	|  IMM8_V8	|  instanceof RR, vAA	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime<br>A: Object|  Calculates `A instanceof acc` and stores the result in the acc.  |
|  0x27	|  IMM8_V8	|  strictnoteq RR, vAA	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime<br>A: Object|  Calculates `acc !== A` and stores the result in the acc.  |
|  0x28	|  IMM8_V8	|  stricteq RR, vAA	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime<br>A: Object|  Calculates `acc === A` and stores the result in the acc.  |
|  0x29	|  IMM8	|  callarg0 RR	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime|  Directly calls the function object stored in the acc without passing parameters and stores the result in the acc.  |
|  0x2a	|  IMM8_V8	|  callarg1 RR, vAA	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A: Parameter|  Uses **A** as a parameter to call the function object stored in the acc and stores the result in the acc.  |
|  0x2b	|  IMM8_V8_V8	|  callargs2 RR, vAA, vBB	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A and B: parameters|  Uses **A** and **B** as parameters to call the function object stored in the acc and stores the result in the acc.  |
|  0x2c	|  IMM8_V8_V8_V8	|  callargs3 RR, vAA, vBB, vCC	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A, B, C: parameter|  Uses **A**, **B**, and **C** as parameters to call the function object stored in the acc and stores the result in the acc.  |
|  0x2d	|  IMM8_V8	|  callthis0 RR, vAA	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A: Object|  Sets **this** to **A**, calls the function object stored in the acc without passing parameters, and stores the result in the acc.  |
|  0x2e	|  IMM8_V8_V8	|  callthis1 RR, vAA, vBB	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A: Object<br>B: parameter|  Sets **this** to **A**, calls the function object stored in the acc by setting **B** as a parameter, and stores the result in the acc.  |
|  0x2f	|  IMM8_V8_V8_V8	|  callthis2 RR, vAA, vBB, vCC	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A: Object<br>B, C: parameter |  Sets **this** to **A**, calls the function object stored in the acc by setting **B** and **C** as parameters, and stores the result in the acc.  |
|  0x30	|  IMM8_V8_V8_V8_V8	|  callthis3 RR, vAA, vBB, vCC, vDD	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A: Object<br>B, C, D: parameter |  Sets **this** to **A**, calls the function object stored in the acc by setting **B**, **C**, and **D** as parameters, and stores the result in the acc.  |
|  0x31	|  IMM8_IMM8_V8	|  callthisrange RR, +AA, vBB	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A: number of parameters<br>B: object<br>B + 1, ..., B + A: parameter|  Sets **this** to **B**, calls the function object stored in the acc by setting **B + 1, ..., B + A** as a parameter, and stores the result in the acc.  |
|  0x32	|  IMM8_IMM8_V8	|  supercallthisrange RR, +AA, vBB	|  R: 8-bit reserved number used in Ark runtime<br>A: number of parameters<br>B, ..., B + A - 1: parameter|  Uses **B, ..., B + A - 1** as a parameter to call the **super** function and stores the result in the acc.<br>When the value of **A** is **0**, the value of **B** is **undefined**.<br>This instruction appears only in non-arrow functions.  |
|  0x33	|  IMM8_ID16_IMM8	|  definefunc RR, @AAAA, +BB	|  R: 8-bit reserved number used in Ark runtime<br>A: method id<br>B: number of formal parameters of method A| Creates the function object of method A and stores it in the acc.  |
|  0x34	|  IMM8_ID16_IMM8	|  definemethod RR, @AAAA, +BB	|  Default input parameter: acc: class object or its prototype. When the static method is used, the parameter is a class object in the acc.<br>R: 8-bit reserved number used in Ark runtime<br>A: method id<br>B: number of formal parameters of method A	|  Creates the function object of method A, sets the object in the acc to the [HomeObject](https://262.ecma-international.org/12.0/#sec-ecmascript-function-objects) property of the function object, and stores this function object in the acc.  |
|  0x35	|  IMM8_ID16_ID16_IMM16_V8	|  defineclasswithbuffer RR, @AAAA, @BBBB, +CCCC, vDD	|  R: 8-bit reserved number used in Ark runtime<br>A: method id of the constructor of a class<br>B: literal id<br>C: number of formal parameters of method A<br>D: parent class|  Uses the literal array corresponding to index B and parent class D to create a class object of A and stores it in the acc.  |
|  0x36	|  V8	|  getnextpropname vAA	| A: iterator|  Executes the [next](https://262.ecma-international.org/12.0/#sec-%25foriniteratorprototype%25.next) method of [for-in iterator](https://262.ecma-international.org/12.0/#sec-createiterresultobject) A and stores the result in the acc.  |
|  0x37	|  IMM8_V8	|  ldobjbyvalue RR, vAA	|  Default input parameter: acc: property key<br>R: 8-bit reserved number used in Ark runtime<br>A: Object|  Loads the property whose key is **acc** of object A and stores the result in the acc.
|  0x38	|  IMM8_V8_V8	|  stobjbyvalue RR, vAA, vBB	|  Default input parameter: acc: value<br>R: 8-bit reserved number used in Ark runtime<br>A: Object<br>B: property key|  Stores the value in the acc to the property whose key is B of object A.  |
|  0x39	|  IMM8_V8	|  ldsuperbyvalue RR, vAA	|  Default input parameter: acc: property key<br>R: 8-bit reserved number used in Ark runtime<br>A: Object|  In the current function, obtains the property whose key of **super** is **acc** and stores the property in the acc. If the property is of an accessor, the object in A is used as the **this** parameter when the **getter** function of the property is called.  |
|  0x3a	|  IMM8_IMM16	|  ldobjbyindex RR, +AAAA	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime<br>A: property key|  Loads the property whose key is A of the object stored in the acc and stores the property in the **acc**.  |
|  0x3b	|  IMM8_V8_IMM16	|  stobjbyindex RR, vAA, +BBBB	|  Default input parameter: acc: value<br>R: 8-bit reserved number used in Ark runtime<br>A: Object<br>B: property key|  Stores the value in the **acc** to the property whose key is B of object A.  |
|  0x3c	|  IMM4_IMM4	|  ldlexvar +A, +B	|  A: lexical environment level<br>B: slot number|  Stores the value of slot B in the lexical environment beyond A levels in the acc.  |
|  0x3d	|  IMM4_IMM4	|  stlexvar +A, +B	|  Default input parameter: acc: value<br>A: lexical environment level<br>B: slot number|  Stores the value in the acc to slot B in the lexical environment beyond A levels.  |
|  0x3e	|  ID16	|  lda.str @AAAA	|  A: string id|  Stores the string corresponding to index A to **acc**.  |
|  0x3f	|  IMM8_ID16	|  tryldglobalbyname RR, @AAAA	|  R: 8-bit reserved number used in Ark runtime<br>A: string id|  Stores the global variable whose name is the string corresponding to index A in the acc. If the global variable named A does not exist, an exception is thrown.  |
|  0x40	|  IMM8_ID16	|  trystglobalbyname RR, @AAAA	|  Default input parameter: acc: value<br>R: 8-bit reserved number used in Ark runtime<br>A: string id|  Stores the value in the acc to the global variable whose name is the string corresponding to index A. If the global variable named A does not exist, an exception is thrown.  |
|  0x41	|  IMM16_ID16	|  ldglobalvar RRRR, @AAAA	|  R: 16-bit reserved number used in Ark runtime<br>A: string id|  Stores the value of the global variable whose name is the string corresponding to index A in the acc. The variable must exist.  |
|  0x42	|  IMM8_ID16	|  ldobjbyname RR, @AAAA	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime<br>A: string id|  Loads the property whose key of the object stored in the acc is the string corresponding to index A and stores the property in the acc.  |
|  0x43	|  IMM8_ID16_V8	|  stobjbyname RR, @AAAA, vBB	|  Default input parameter: acc: value<br>R: 8-bit reserved number used in Ark runtime<br>A: string id<br>B: object|  Stores the value in the acc to the property whose key of object B is the string corresponding to index A.  |
|  0x44	|  V4_V4	|  mov vA, vB	|  A, B: register index|  Copies the contents in register B to register A.  |
|  0x45	|  V8_V8	|  mov vAA, vBB	|  A, B: register index|  Copies the contents in register B to register A.  |
|  0x46	|  IMM8_ID16	|  ldsuperbyname RR, @AAAA	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime<br>A: string id|  In the current function, obtains the property whose key of **super** is the string corresponding to index A and stores the property in the acc. If the property is of an accessor, the object in the acc is used as the **this** parameter when the **getter** function of the property is called.  |
|  0x47	|  IMM16_ID16	|  stconsttoglobalrecord RRRR, @AAAA	|  Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: string id|  Stores the value in the acc to the constant of the string corresponding to index A defined by **const** in the global variable.  |
|  0x48	|  IMM16_ID16	|  sttoglobalrecord RRRR, @AAAA	|  Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: string id|  Stores the value in the acc to the variable of the string corresponding to index A defined by **let** in the global variable.  |
|  0x49	|  IMM8_ID16	|  ldthisbyname RR, @AAAA	|  R: 8-bit reserved number used in Ark runtime<br>A: string id|  Loads the property whose key of **this** is the string corresponding to index A and stores the result in the acc.  |
|  0x4a	|  IMM8_ID16	|  stthisbyname RR, @AAAA	|  Default input parameter: acc: value<br>R: 8-bit reserved number used in Ark runtime<br>A: string id|  Stores the value in the acc to the property whose key of **this** is the string corresponding to index A.  |
|  0x4b	|  IMM8	|  ldthisbyvalue RR	|  Default input parameter: acc: property key<br>R: 8-bit reserved number used in Ark runtime|  Loads the property whose key of **this** is **acc** and stores the result in the acc.  |
|  0x4c	|  IMM8_V8	|  stthisbyvalue RR, vAA	|  Default input parameter: acc: value<br>R: 8-bit reserved number used in Ark runtime<br>A: property key|  Stores the value in the acc to the property whose key of **this** is A.  |
|  0x4d	|  IMM8	|  jmp +AA	|  A: signed branch offset|  Jumps to branch A unconditionally.  |
|  0x4e	|  IMM16	|  jmp +AAAA	|  A: signed branch offset|  Jumps to branch A unconditionally.  |
|  0x4f	|  IMM8	|  jeqz +AA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc == 0` and jumps to branch A if it is true.  |
|  0x50	|  IMM16	|  jeqz +AAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc == 0` and jumps to branch A if it is true.  |
|  0x51	|  IMM8	|  jnez +AA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc != 0` and jumps to branch A if it is true.  |
|  0x52	|  IMM8	|  jstricteqz +AA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc === 0` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x53	|  IMM8	|  jnstricteqz +AA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc !== 0` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x54	|  IMM8	|  jeqnull +AA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc == null` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x55	|  IMM8	|  jnenull +AA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc != null` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x56	|  IMM8	|  jstricteqnull +AA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc === null` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x57	|  IMM8	|  jnstricteqnull +AA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc !== null` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x58	|  IMM8	|  jequndefined +AA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc == undefined` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x59	|  IMM8	|  jneundefined +AA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc != undefined` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x5a	|  IMM8	|  jstrictequndefined +AA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc === undefined` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x5b	|  IMM8	|  jnstrictequndefined +AA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc !== undefined` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x5c	|  V8_IMM8	|  jeq vAA, +BB	|  Default input parameter: acc: value<br>A: value<br>B: signed branch offset|  Calculates `acc == A` and jumps to branch B if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x5d	|  V8_IMM8	|  jne vAA, +BB	|  Default input parameter: acc: value<br>A: value<br>B: signed branch offset|  Calculates `acc != A` and jumps to branch B if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x5e	|  V8_IMM8	|  jstricteq vAA, +BB	|  Default input parameter: acc: object<br>A: Object<br>B: signed branch offset|  Calculates `acc === A` and jumps to branch B if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x5f	|  V8_IMM8	|  jnstricteq vAA, +BB	|  Default input parameter: acc: object<br>A: Object<br>B: signed branch offset|  Calculates `acc !== A` and jumps to branch B if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x60	|  V8	|  lda vAA	|  A: register index|  Stores the contents of register A in the acc.  |
|  0x61	|  V8	|  sta vAA	|  Default input parameter: acc<br>A: register index|  Stores the contents of acc in register A.  |
|  0x62	|  IMM32	|  ldai +AAAAAAAA	|  A: constant literal|  Stores the integer literal A in the acc.  |
|  0x63	|  IMM64	|  fldai +AAAAAAAAAAAAAAAA	|  A: constant literal|  Stores the double-precision floating-point literal A in the acc.  |
|  0x64	|  NONE	|  return	|  Default input parameter: acc: value|  Returns the value in the acc.  |
|  0x65	|  NONE	|  returnundefined	 | 	|  Returns **undefined**.  |
|  0x66	|  NONE	|  getpropiterator	|  Default input parameter: acc: object|  Stores the [for-in iterator](https://262.ecma-international.org/12.0/#sec-createiterresultobject) of the object in the acc.  |
|  0x67	|  IMM8	|  getiterator RR	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime|  Executes the [GetIterator](https://262.ecma-international.org/12.0/#sec-getiterator) (acc, sync) method and stores the result in the acc.  |
|  0x68	|  IMM8_V8	|  closeiterator RR, vAA	|  R: 8-bit reserved number used in Ark runtime<br>A: Object|  Uses A of the *[iteratorRecord](https://262.ecma-international.org/12.0/#sec-iterator-records)* type as a parameter to execute [IteratorClose](https://262.ecma-international.org/12.0/#sec-iteratorclose) and stores the result in the acc.  |
|  0x69	|  NONE	|  poplexenv	|   	|  Jumps out of the current lexical environment and enters the outer lexical environment.  |
|  0x6a	|  NONE	|  ldnan	|   	|  Stores the **nan** value in the acc.  |
|  0x6b	|  NONE	|  ldinfinity	|   	|  Stores the **infinity** value in the acc.  |
|  0x6c	|  NONE	|  getunmappedargs	 |  	|  Stores the **arguments** of the current function in the acc.  |
|  0x6d	|  NONE	|  ldglobal	 |  	|  Stores the **global** object in the acc.|
|  0x6e	|  NONE	|  ldnewtarget	 |  	|  Stores the **NewTarget** implicit parameter of the current function in the acc.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x6f	|  NONE	|  ldthis	|   	|  Stores the **this** value in the acc.  |
|  0x70	|  NONE	|  ldhole	 |  	|  Stores the **hole** value in the acc.  |
|  0x71	|  IMM8_ID16_IMM8	|  createregexpwithliteral RR, @AAAA, +BB	|  R: 8-bit reserved number used in Ark runtime<br>A: string id<br>B: regular expression modifier|  Uses the string corresponding to index A and the modifier corresponding to index B to create a regular expression and stores it in the acc.<br>The correspondence between B and a specified modifier is: 0 (default value with no modifier), 1 (g), 2 (i), 4 (m), 8 (s), 16 (u), 32 (y); B may also refer to a combination of modifiers that comply with syntax specifications, for example, **3** and its modifier is **gi**. |
|  0x72	|  IMM16_ID16_IMM8	|  createregexpwithliteral RRRR, @AAAA, +BB	|  R: 16-bit reserved number used in Ark runtime<br>A: string id<br>B: regular expression modifier|  Uses the string corresponding to index A and the modifier corresponding to index B to create a regular expression and stores it in the acc.<br>The correspondence between B and a specified modifier is: 0 (default value with no modifier), 1 (g), 2 (i), 4 (m), 8 (s), 16 (u), 32 (y); B may also refer to a combination of modifiers that comply with syntax specifications, for example, **3** and its modifier is **gi**. |
|  0x73	|  IMM8_IMM8_V8	|  callrange RR, +AA, vBB	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A: number of parameters<br>B, ..., B + A - 1: parameter|  Uses **B, ..., B + A - 1** as a parameter to call the function object stored in the acc and stores the result in the acc.  |
|  0x74	|  IMM16_ID16_IMM8	|  definefunc RRRR, @AAAA, +BB	|  R: 16-bit reserved number used in Ark runtime<br>A: method id<br>B: number of formal parameters of method A|  Creates the function object of method A and stores it in the acc.  |
|  0x75	|  IMM16_ID16_ID16_IMM16_V8	|  defineclasswithbuffer RRRR, @AAAA, @BBBB, +CCCC, vDD	|  R: 16-bit reserved number used in Ark runtime<br>A: **method id** of the constructor of a class<br>B: literal id<br>C: number of formal parameters of method A<br>D: parent class|  Uses the literal array corresponding to index B and parent class D to create a class object of A and stores it in the acc.  |
|  0x76	|  IMM8	|  gettemplateobject RR	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime|  Executes [GetTemplateObject](https://262.ecma-international.org/12.0/#sec-gettemplateobject) (acc) and stores the result in the acc.  |
|  0x77	| IMM8_V8	| setobjectwithproto RR, vAA	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime<br>A: value|  Sets the **\_\_proto\_\_** property of the object stored in the acc to A.  |
|  0x78	|  IMM8_V8_V8	|  stownbyvalue RR, vAA, vBB	|  Default input parameter: acc: value<br>R: 8-bit reserved number used in Ark runtime<br>A: Object<br>B: property key|  Stores the value in the acc to the property whose key is B of object A.  |
|  0x79	|  IMM8_V8_IMM16	|  stownbyindex RR, vAA, +BBBB	|  Default input parameter: acc: value<br>R: 8-bit reserved number used in Ark runtime<br>A: Object<br>B: property key|  Stores the value in the acc to the property whose key is B of object A.  |
|  0x7a	|  IMM8_ID16_V8	|  stownbyname RR, @AAAA, vBB	|  Default input parameter: acc: value<br>R: 8-bit reserved number used in Ark runtime<br>A: string id<br>B: object|  Stores the value in the acc to the property whose key of object B is the string corresponding to index A.  |
|  0x7b	|  IMM8	|  getmodulenamespace +AA	|  A: module index|  Executes the [GetModuleNamespace](https://262.ecma-international.org/12.0/#sec-getmodulenamespace) instruction for module A and stores the result in the acc.  |
|  0x7c	|  IMM8	|  stmodulevar +AA	|  Default input parameter: acc: value<br>A: slot number|  Stores the value in the acc to the module variable of slot A.  |
|  0x7d	|  IMM8	|  ldlocalmodulevar +AA	|  A: slot number|  Stores the local module variables of slot A in the acc.  |
|  0x7e	|  IMM8	|  ldexternalmodulevar +AA	|  A: slot number|  Stores the external module variable of slot A in the acc.  |
|  0x7f	|  IMM16_ID16	|  stglobalvar RRRR, @AAAA	|  Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: string id|  Stores the value in the acc to the global variable whose name is the string corresponding to index A. This variable must exist.  |
|  0x80	|  IMM16	|  createemptyarray RRRR	|  R: 16-bit reserved number used in Ark runtime|  Creates an empty array and stores it in the acc.  |
|  0x81	|  IMM16_ID16	|  createarraywithbuffer RRRR, @AAAA	|  R: 16-bit reserved number used in Ark runtime<br>A: literal id|  Uses the literal array corresponding to index A to create an array object and stores it in the acc.  |
|  0x82	|  IMM16_ID16	|  createobjectwithbuffer RRRR, @AAAA	|  R: 16-bit reserved number used in Ark runtime<br>A: literal id|  Uses the literal array corresponding to index A to create an object and stores it in the acc.  |
|  0x83	|  IMM16_IMM8_V8	|  newobjrange RRRR, +AA, vBB	|  R: 16-bit reserved number used in Ark runtime<br>A: number of parameters<br>B: class object<br>B + 1, ..., B + A - 1: parameter passed to the constructor|  Uses **B + 1, ..., B + A - 1** as a parameter to create an instance of class B and stores it in the acc.  |
|  0x84	|  IMM16	|  typeof RRRR	|  Default input parameter: acc: object<br>R: 16-bit reserved number used in Ark runtime|  Calculates `typeof acc` and stores the result in the acc.  |
|  0x85	|  IMM16_V8	|  ldobjbyvalue RRRR, vAA	|  Default input parameter: acc: property key<br>R: 16-bit reserved number used in Ark runtime<br>A: Object|  Loads the property whose key is **acc** of object A and stores the result in the acc.  |
|  0x86	|  IMM16_V8_V8	|  stobjbyvalue RRRR, vAA, vBB	|  Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: Object<br>B: property key|  Stores the value in the acc to the property whose key is B of object A.  |
|  0x87	|  IMM16_V8	|  ldsuperbyvalue RRRR, vAA	|  Default input parameter: acc: property key<br>R: 16-bit reserved number used in Ark runtime<br>A: Object|  In the current function, obtains the property whose key of **super** is **acc** and stores the property in the acc. If the property is of an accessor, the object in A is used as the **this** parameter when the **getter** function of the property is called.  |
|  0x88	|  IMM16_IMM16	|  ldobjbyindex RRRR, +AAAA	|  Default input parameter: acc: object<br>R: 16-bit reserved number used in Ark runtime<br>A: property key|  Loads the property whose key is A of the object stored in the acc and stores the property in the acc.  |
|  0x89	|  IMM16_V8_IMM16	|  stobjbyindex RRRR, vAA, +BBBB	|  Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: Object<br>B: property key|  Stores the value in the acc to the property whose key is B of object A.  |
|  0x8a	|  IMM8_IMM8	|  ldlexvar +AA, +BB	|  A: lexical environment level<br>B: slot number|  Stores the value of slot B in the lexical environment beyond A levels in the acc.  |
|  0x8b	|  IMM8_IMM8	|  stlexvar +AA, +BB	|  Default input parameter: acc: value<br>A: lexical environment level<br>B: slot number|  Stores the value in the acc to slot B in the lexical environment beyond A levels.  |
|  0x8c	|  IMM16_ID16	|  tryldglobalbyname RRRR, @AAAA	|  R: 16-bit reserved number used in Ark runtime<br>A: string id|  Stores the global variable whose name is the string corresponding to index A in the acc. If the global variable named A does not exist, an exception is thrown.  |
|  0x8d	|  IMM16_ID16	|  trystglobalbyname RRRR, @AAAA	|  Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: string id|  Stores the value in the acc to the global variable whose name is the string corresponding to index A. If the global variable named A does not exist, an exception is thrown.  |
|  0x8e	|  IMM8_ID16_V8	|  stownbynamewithnameset RR, @AAAA, vBB	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A: string id<br>B: object|  Stores the function object in the acc to the property whose key of object B is the string corresponding to index A and sets the function name to the string corresponding to index A.  |
|  0x8f	|  V16_V16	|  mov vAAAA, vBBBB	|  A, B: register index|  Copies the contents in register B to register A.  |
|  0x90	|  IMM16_ID16	|  ldobjbyname RRRR, @AAAA	|  Default input parameter: acc: object<br>R: 16-bit reserved number used in Ark runtime<br>A: string id|  Loads the property whose key of the object stored in the acc is the string corresponding to index A and stores the property in the acc.  |
|  0x91	|  IMM16_ID16_V8	|  stobjbyname RRRR, @AAAA, vBB	|  Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: string id<br>B: object|  Stores the value in the acc to the property whose key of object B is the string corresponding to index A.  |
|  0x92	|  IMM16_ID16	|  ldsuperbyname RRRR, @AAAA	|  Default input parameter: acc: object<br>R: 16-bit reserved number used in Ark runtime<br>A: string id|  In the current function, obtains the property whose key of **super** is the string corresponding to index A and stores the property in the acc. If the property is of an accessor, the object in the acc is used as the **this** parameter when the **getter** function of the property is called.  |
|  0x93	|  IMM16_ID16	|  ldthisbyname RRRR, @AAAA	|  R: 16-bit reserved number used in Ark runtime<br>A: string id|  Loads the property whose key of **this** is the string corresponding to index A and stores the result in the acc.  |
|  0x94	|  IMM16_ID16	|  stthisbyname RRRR, @AAAA	|  Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: string id|  Stores the value in the acc to the property whose key of **this** is the string corresponding to index A.  |
|  0x95	|  IMM16	|  ldthisbyvalue RRRR	|  Default input parameter: acc: property key<br>R: 16-bit reserved number used in Ark runtime|  Loads the property whose key of **this** is **acc** and stores the result in the acc.  |
|  0x96	|  IMM16_V8	|  stthisbyvalue RRRR, vAA	|  Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: property key|  Stores the value in the acc to the property whose key of **this** is A.  |
|  0x97	|  V8	|  asyncgeneratorreject vAA	 |  Default input parameter: acc: exception<br>A: generator|  Uses the exception stored in [generator](https://262.ecma-international.org/12.0/#sec-generator-objects) A and the acc, executes [AsyncGeneratorReject](https://262.ecma-international.org/12.0/#sec-asyncgeneratorreject), and stores the result in the acc.  |
|  0x98	|  IMM32	|  jmp +AAAAAAAA	|  A: signed branch offset|  Jumps to branch A unconditionally.  |
|  0x99	|  IMM8_V8_V8	|  stownbyvaluewithnameset RR, vAA, vBB	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A: Object<br>B: property key|  Stores the value in the acc to the property whose key of object A is B and set the function name to B.  |
|  0x9a	|  IMM32	|  jeqz +AAAAAAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc == 0` and jumps to branch A if it is true.  |
|  0x9b	|  IMM16	|  jnez +AAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc != 0` and jumps to branch A if it is true.  |
|  0x9c	|  IMM32	|  jnez +AAAAAAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc != 0` and jumps to branch A if it is true.  |
|  0x9d	|  IMM16	|  jstricteqz +AAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc === 0` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x9e	|  IMM16	|  jnstricteqz +AAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc !== 0` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0x9f	|  IMM16	|  jeqnull +AAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc == null` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0xa0	|  IMM16	|  jnenull +AAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc != null` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0xa1	|  IMM16	|  jstricteqnull +AAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc === null` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0xa2	|  IMM16	|  jnstricteqnull +AAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc !== null` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0xa3	|  IMM16	|  jequndefined +AAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc == undefined` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0xa4	|  IMM16	|  jneundefined +AAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc != undefined` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0xa5	|  IMM16	|  jstrictequndefined +AAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc === undefined` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0xa6	|  IMM16	|  jnstrictequndefined +AAAA	|  Default input parameter: acc: value<br>A: signed branch offset|  Calculates `acc !== undefined` and jumps to branch A if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0xa7	|  V8_IMM16	|  jeq vAA, +BBBB	|  Default input parameter: acc: value<br>A: value<br>B: signed branch offset|  Calculates `acc == A` and jumps to branch B if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0xa8	|  V8_IMM16	|  jne vAA, +BBBB	|  Default input parameter: acc: value<br>A: value<br>B: signed branch offset|  Calculates `acc != A` and jumps to branch B if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0xa9	|  V8_IMM16	|  jstricteq vAA, +BBBB	|  Default input parameter: acc: value<br>A: value<br>B: signed branch offset|  Calculates `acc === A` and jumps to branch B if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0xaa	|  V8_IMM16	|  jnstricteq vAA, +BBBB	|  Default input parameter: acc: value<br>A: value<br>B: signed branch offset|  Calculates `acc !== A` and jumps to branch B if it is true.<br>The instruction feature is disabled and is unavailable currently.  |
|  0xab	|  IMM16	|  getiterator RRRR	|  Default input parameter: acc: object<br>R: 16-bit reserved number used in Ark runtime|  Executes the [GetIterator](https://262.ecma-international.org/12.0/#sec-getiterator) (acc, sync) method and stores the result in the acc.  |
|  0xac	|  IMM16_V8	|  closeiterator RRRR, vAA	|  R: 16-bit reserved number used in Ark runtime<br>A: Object|  Uses A of the *[iteratorRecord](https://262.ecma-international.org/12.0/#sec-iterator-records)* type as a parameter to execute [IteratorClose](https://262.ecma-international.org/12.0/#sec-iteratorclose) and stores the result in the acc.  |
|  0xad	|  NONE	|  ldsymbol	 |  	|  Load the **Symbol** object in **acc**.  |
|  0xae	|  NONE	|  asyncfunctionenter	|   	|  Creates an asynchronous function object and store the object in the acc.  |
|  0xaf	|  NONE	|  ldfunction	|   	|  Loads the current function object in the acc.  |
|  0xb0	|  NONE	|  debugger	|   	|  Pauses execution during debugging.  |
|  0xb1	|  V8	|  creategeneratorobj vAA	|  A: function object|  Uses function object A to create a generator and stores it in the acc.  |
|  0xb2	|  V8_V8	|  createiterresultobj vAA, vBB	|  A: Object<br>B: Boolean value|  Sets *value* A and *done* B as parameters to execute [CreateIterResultObject](https://262.ecma-international.org/12.0/#sec-createiterresultobject) instruction and stores the result in the acc.  |
|  0xb3	|  IMM8_V8_V8	|  createobjectwithexcludedkeys +AA, vBB, vCC	|  A: number of range registers<br>B: object<br>C, ..., C + A: property key value.|  Based on object B, creates an object excluding the key **C, ..., C + A** and stores it in the acc.<br>This instruction supports object creation by using destructor and extension syntax.  |
|  0xb4	|  IMM8_V8	|  newobjapply RR, vAA	|  Default input parameter: acc: parameter list<br>R: 8-bit reserved number used in Ark runtime<br>A: class object|  Uses the parameter list stored in the acc to create an instance of class A and stores it in the acc.  |
|  0xb5	|  IMM16_V8	|  newobjapply RRRR, vAA	|  Default input parameter: acc: parameter list<br>R: 16-bit reserved number used in Ark runtime<br>A: class object|  Uses the parameter list stored in the acc to create an instance of class A and stores it in the acc.  |
|  0xb6	|  IMM8_ID16	|  newlexenvwithname +AA, @BBBB	|  A: number of slots in the lexical environment<br>B: literal id|  Uses the lexical variable name stored in the literal array corresponding to index B to create a lexical environment with A slots, stores this lexical environment in the acc, and enters the lexical environment.  |
|  0xb7	|  V8	|  createasyncgeneratorobj vAA	|  A: function object|  Creates an asynchronous generator based on function object A and stores it in the acc.  |
|  0xb8	|  V8_V8_V8	|  asyncgeneratorresolve vAA, vBB, vCC	|  A: generator<br>B: object<br>C: boolean value|  Uses *generator* A, *value* B, and *done* C as parameters to execute [AsyncGeneratorResolve](https://262.ecma-international.org/12.0/#sec-asyncgeneratorresolve) and stores the result in the acc.  |
|  0xb9	|  IMM8_V8	|  supercallspread RR, vAA	|  Default input parameter: acc: class object<br>R: 8-bit reserved number used in Ark runtime<br>A: parameter list|  Uses parameter list A as a parameter, calls the parent class constructor of the class stored in the acc, and stores the result in the acc.  |
|  0xba	|  IMM8_V8_V8	|  apply RR, vAA, vBB	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A: Object<br>B: parameter list|  Sets **this** to A, use parameter list B as a parameter, calls the function object stored in the acc, and stores the return value in the acc.  |
|  0xbb	|  IMM8_IMM8_V8	|  supercallarrowrange RR, +AA, vBB	|  Default input parameter: acc: class object<br>R: 8-bit reserved number used in Ark runtime<br>A: number of parameters<br>B, ..., B + A - 1: parameter|  Uses **B, ..., B + A - 1** as a parameter to call the constructor function of the parent class of the class stored in the acc and stores the result in the acc.<br>If the value of A is **0**, B is **undefined**.<br>This instruction appears only in arrow functions.  |
|  0xbc	|  V8_V8_V8_V8	|  definegettersetterbyvalue vAA, vBB, vCC, vDD	|  Default input parameter: acc: boolean value, indicating whether to set a name for the accessor.<br>A: Object<br>B: property key<br>C: **getter** function object<br>D: **setter** function object|  Uses **getter** method C and **setter** method D as parameters to define the accessor of the property whose key of object A is B and stores the result object in the acc.<br>If C is **undefined** and D is **undefined**, **getter** and **setter** are not set respectively.  |
|  0xbd	|  NONE	|  dynamicimport	|  Default input parameter: acc: value|  Uses the value in the acc as a parameter, executes [ImportCalls](https://262.ecma-international.org/12.0/#sec-import-calls), and stores the result in the acc.  |
|  0xbe	|  IMM16_ID16_IMM8	|  definemethod RRRR, @AAAA, +BB	|  Default input parameter: acc: class object or its prototype. When the static method is used, the parameter is a class object in the acc.<br>R: 16-bit reserved number used in Ark runtime<br>A: method id<br>B: number of formal parameters of method A|  Creates the function object of method A, sets the object in the acc to the [HomeObject](https://262.ecma-international.org/12.0/#sec-ecmascript-function-objects) property of the function object, and stores this function object in the acc.  |
|  0xbf	|  NONE	|  resumegenerator	|  Default input parameter: acc: generator|  Executes [GeneratorResume](https://262.ecma-international.org/12.0/#sec-generatorresume) based on the generator stored in the acc and stores the result in the acc.  |
|  0xc0	|  NONE	|  getresumemode	|  Default input parameter: acc: generator|  After the generator finishes executing, obtains the restored value and stores it in the acc.  |
|  0xc1	|  IMM16	|  gettemplateobject RRRR	|  Default input parameter: acc: object<br>R: 16-bit reserved number used in Ark runtime|  Executes [GetTemplateObject](https://262.ecma-international.org/12.0/#sec-gettemplateobject) (acc) and stores the result in the acc.  |
|  0xc2	|  V8	|  delobjprop vAA	|  Default input parameter: acc: property key<br>A: Object|  Deletes the property whose key is **acc** of object A.  |
|  0xc3	|  V8	|  suspendgenerator vAA	|  Default input parameter: acc: value<br>A: generator|  Uses the value stored in the acc to suspend *generator* A and stores the result in the acc.  |
|  0xc4	|  V8	|  asyncfunctionawaituncaught vAA	|  Default input parameter: acc: value<br>A: function object|  Uses the function object A and the value in the acc to execute [AwaitExpression](https://262.ecma-international.org/12.0/#prod-AwaitExpression) and stores the result in the acc.  |
|  0xc5	|  V8	|  copydataproperties vAA	|  Default input parameter: acc: object<br>A: target object|  Copies all properties of the object stored in the acc to A and stores A in the acc.  |
|  0xc6	|  V8_V8	|  starrayspread vAA, vBB	|  Default input parameter: acc: value<br>A: array<br>B: array index|  Stores the value in the acc to the position starting with index B of array A in the format of [SpreadElement](https://262.ecma-international.org/12.0/#prod-SpreadElement), and stores the length of the result array in the acc.  |
|  0xc7	|  IMM16_V8	|  setobjectwithproto RRRR, vAA	|  Default input parameter: acc: object<br>R: 16-bit reserved number used in Ark runtime<br>A: value|  Sets the **\_\_proto\_\_** property of the object stored in the acc to A.  |
|  0xc8	|  IMM16_V8_V8	|  stownbyvalue RRRR, vAA, vBB	|  Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: Object<br>B: property key|  Stores the value in the acc to the property whose key is B of object A.  |
|  0xc9	|  IMM8_V8_V8	|  stsuperbyvalue RR, vAA, vBB	|  Default input parameter: acc: value<br>R: 8-bit reserved number used in Ark runtime<br>A: Object<br>B: property key|  In the current function, stores the value in the acc to the property whose key of **super** is B. If the property is of an accessor, the object in A is used as the **this** parameter when the **setter** function of the property is called.  |
|  0xca	|  IMM16_V8_V8	|  stsuperbyvalue RRRR, vAA, vBB | Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: Object<br>B: property key|  In the current function, stores the value in the acc to the property whose key of **super** is B. If the property is of an accessor, the object in A is used as the **this** parameter when the **setter** function of the property is called.  |
|  0xcb	|  IMM16_V8_IMM16	|  stownbyindex RRRR, vAA, +BBBB	|  Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: Object<br>B: property key|  Stores the value in the acc to the property whose key is B of object A.  |
|  0xcc	|  IMM16_ID16_V8	|  stownbyname RRRR, @AAAA, vBB	|  Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: string id<br>B: object|  Stores the value in the acc to the property whose key of object B is the string corresponding to index A.  |
|  0xcd	|  V8	|  asyncfunctionresolve vAA	|  Default input parameter: acc: value<br>A: asynchronous function object|  Uses the value in the acc to parse the **Promise** object of object A and stores the result in the acc.  |
|  0xce	|  V8	|  asyncfunctionreject vAA	|  Default input parameter: acc: value<br>A: asynchronous function object|  Uses the value in the acc to reject the **Promise** object of object A and stores the result in the acc.  |
|  0xcf	|  IMM8	|  copyrestargs +AA	|  A: position of the [rest parameter](https://262.ecma-international.org/12.0/#prod-FunctionRestParameter) in the formal parameter list|  Copies the rest parameters and stores the parameter array copy in the acc.  |
|  0xd0	|  IMM8_ID16_V8	|  stsuperbyname RR, @AAAA, vBB	|  Default input parameter: acc: value<br>R: 8-bit reserved number used in Ark runtime<br>A: string id<br>B: object|  In the current function, stores the value in the acc to the property whose key of **super** is the string corresponding to index A.<br>If the property is of an accessor, the object in B is used as the **this** parameter when the **setter** function of the property is called.  |
|  0xd1	|  IMM16_ID16_V8	|  stsuperbyname RRRR, @AAAA, vBB	|  Default input parameter: acc: value<br>R: 16-bit reserved number used in Ark runtime<br>A: string id<br>B: object|  In the current function, stores the value in the acc to the property whose key of **super** is the string corresponding to index A.<br>If the property is of an accessor, the object in B is used as the **this** parameter when the **setter** function of the property is called.  |
|  0xd2	|  IMM16_V8_V8	|  stownbyvaluewithnameset RRRR, vAA, vBB	|  Default input parameter: acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A: Object<br>B: property key|  Stores the value in the acc to the property whose key of object A is B and set the function name to B.  |
|  0xd3	|  ID16	|  ldbigint @AAAA	|  A: string id|  Creates a value of the **BigInt** type based on the string corresponding to index A and stores the value in the acc.  |
|  0xd4	|  IMM16_ID16_V8	|  stownbynamewithnameset RRRR, @AAAA, vBB	|  Default input parameter: acc: function object<br>R: 16-bit reserved number used in Ark runtime<br>A: string id<br>B: object|  Stores the function object in the acc to the property whose key of object B is the string corresponding to index A and sets the function name to the string corresponding to index A.  |
|  0xd5	|  NONE	|  nop	 |  	|  No operation.  |
|  0xd6	|  IMM8	|  setgeneratorstate +AA	|  Default input parameter: acc: generator object<br>A: generator state|  Sets the generator state stored in the acc to A. For details, see [GeneratorState](https://262.ecma-international.org/12.0/#sec-properties-of-generator-instances) and [AsyncGeneratorState](https://262.ecma-international.org/12.0/#sec-properties-of-asyncgenerator-intances).<br>A may have the following values: undefined(0x0), suspendedStart(0x1), suspendedYield(0x2), executing(0x3), completed (0x4), and awaitingReturn (0x5).  |
|  0xd7	|  IMM8	|  getasynciterator RR	|  Default input parameter: acc: object<br>R: 8-bit reserved number used in Ark runtime|  Executes the [GetIterator](https://262.ecma-international.org/12.0/#sec-getiterator) (acc, async) and stores the result in the acc.  |
|  0xd8	|  IMM8_IMM16_IMM16	|  ldprivateproperty RR, +AAAA, +BBBB	|  Default input parameter: acc: object<br>A: lexical environment level<br>B: slot number|  Loads and sets the value of slot B in the lexical environment beyond A levels as the property key, and stores the value corresponding to the key of the object in the acc.  |
|  0xd9	|  IMM8_IMM16_IMM16_V8	|  stprivateproperty RR, +AAAA, +BBBB, vCC	|  A: lexical environment level<br>B: slot number<br>C: object|  Loads the value of slot B in the lexical environment beyond A levels as the property key and stores the value in the acc to the key of the object C stored in the acc.  |
|  0xda	|  IMM8_IMM16_IMM16	|  testin RR, +AAAA, +BBBB	|  Default input parameter: acc: object<br>A: lexical environment level<br>B: slot number|  Loads the value of slot B in the lexical environment beyond A levels, calculates whether the value is **in acc**, and stores the result in the acc.  |
|  0xdb	|  IMM8_ID16_V8	|  definefieldbyname RR, @AAAA, vBB	|  Default input parameter: acc: value<br>A: string id<br>B: object|  Defines a property whose key is A for object B and store the value in the acc to the property.  |
|  0xdc	|  IMM8_ID16_V8	|  definepropertybyname RR, @AAAA, vBB	|  Default input parameter: acc: value<br>A: string id<br>B: object|  Defines a property whose key is A for object B and store the value in the acc to the property.  |
|  0xfb	|  PREF_NONE	|  callruntime.notifyconcurrentresult	|  Default input parameter: acc: return value of the concurrent function|  Notifies the runtime of the return value of the concurrent function.<br>This instruction appears only in concurrent functions.  |
|  0xfc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0xfd	|  PREF_IMM16_V8_V8	|  wide.createobjectwithexcludedkeys +AAAA, vBB, vCC	|  A: number of range registers<br>B: object<br>C, ..., C + A: property key value.|  Based on object B, creates an object excluding the key **C, ..., C + A** and stores it in the acc.<br>This instruction supports object creation by using destructor and extension syntax.  |
|  0xfe	|  PREF_NONE	|  throw	|  Default input parameter: acc: exception|  Throws the exception stored in acc.  |
|  0x01fb	|  PREF_IMM8_V8_V8	|  callruntime.definefieldbyvalue RR, vAA, vBB	|  Default input parameter: acc: value<br>A: property key<br>B: object|  Defines a property whose key is A for object B and store the value in the acc to the property.  |
|  0x01fc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x01fd	|  PREF_IMM16_V8	|  wide.newobjrange +AAAA, vBB	|  A: number of parameters<br>B: class object<br>B + 1, ..., B + A - 1: parameter passed to the constructor|  Uses **B + 1, ..., B + A - 1** as a parameter to create an instance of class B and stores it in the acc.  |
|  0x01fe	|  PREF_NONE	|  throw.notexists	|   	|  Exception thrown: undefined method.  |
|  0x02fb	|  PREF_IMM8_IMM32_V8	|  callruntime.definefieldbyindex RR, +AAAAAAAA, vBB	|  Default input parameter: acc: value<br>A: property key<br>B: object|  Defines a property whose key is A for object B and store the value in the acc to the property.  |
|  0x02fc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x02fd	|  PREF_IMM16	|  wide.newlexenv +AAAA	|  A: number of slots in the lexical environment|  Creates a lexical environment with slot A, stores it in the acc, and enters the lexical environment.  |
|  0x02fe	|  PREF_NONE	|  throw.patternnoncoercible |   	|  Throws an exception indicating that this object cannot be forcibly executed.  |
|  0x03fb	|  PREF_NONE	|  callruntime.topropertykey 	|  Default input parameter: acc: value|  Converts the value in the acc to the property value. If the conversion fails, an error is thrown.  |
|  0x03fc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x03fd	|  PREF_IMM16_ID16	|  wide.newlexenvwithname +AAAA, @BBBB	|  A: number of slots in the lexical environment<br>B: literal id|  Uses the lexical variable name stored in the literal array corresponding to index B to create a lexical environment with A slots, stores this lexical environment in the acc, and enters the lexical environment.  |
|  0x03fe	|  PREF_NONE	|  throw.deletesuperproperty	|   |  	Throws an exception indicating an attempt to delete the property of the parent class.  |
|  0x04fb	|  PREF_IMM_16_ID16	|  callruntime.createprivateproperty +AAAA, @BBBB	|  A: number of symbols to be created<br>B: literal id|  Creates A symbols. Obtain the stored private method from the literal array corresponding to index B. If a private instance method exists, an additional symbol ("method") will be created. Based on the creation sequence, place the created symbols at the end of the lexical environment where the current class is located.<br>This instruction appears only when a class is defined.  |
|  0x04fc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x04fd	|  PREF_IMM16_V8	|  wide.callrange +AAAA, vBB	|  Default input parameter: acc: function object<br>A: number of parameters<br>B, ..., B + A - 1: parameter|  Uses **B, ..., B + A - 1** as a parameter to call the function object stored in the acc and stores the result in the acc.  |
|  0x04fe	|  PREF_V8	|  throw.constassignment vAA	|  A: constant variable name|  Throws an exception indicating a value is assigned to a constant variable.  |
|  0x05fb	|  PREF_IMM8_IMM_16_IMM_16_V8	|  callruntime.defineprivateproperty RR, +AAAA, +BBBB, vCC	|  Default input parameter: acc: value<br>A: lexical environment level<br>B: slot number<br>C: object|  Loads the value of slot B in the lexical environment beyond A levels, changes the value to **acc**, and adds it to object C as a private property.  |
|  0x05fc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x05fd	|  PREF_IMM16_V8	|  wide.callthisrange +AAAA, vBB	|  Default input parameter: acc: function object<br>A: number of parameters<br>B: object<br>B + 1, ..., B + A: parameter|  Sets **this** to **B**, calls the function object stored in the acc by setting **B + 1, ..., B + A** as a parameter, and stores the result in the acc.  |
|  0x05fe	|  PREF_V8	|  throw.ifnotobject vAA	|  A: Object|  Throws an exception if A is not an object.  |
|  0x06fb	|  PREF_IMM8_V8	|  callruntime.callinit +RR, vAA	|  acc: function object<br>R: 8-bit reserved number used in Ark runtime<br>A: Object|  Sets **this** to **A**, calls the function object stored in the acc without passing parameters, and stores the result in the acc.  |
|  0x06fc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x06fd	|  PREF_IMM16_V8	|  wide.supercallthisrange +AAAA, vBB	|  A: number of parameters<br>B, ..., B + A - 1: parameter|  Uses **B, ..., B + A - 1** as a parameter to call the **super** function and stores the result in the acc.<br>When the value of **A** is **0**, the value of **B** is **undefined**.<br>This instruction appears only in non-arrow functions.  |
|  0x06fe	|  PREF_V8_V8	|  throw.undefinedifhole vAA, vBB	|  A: Object<br>B: object name|  Throws an exception indicating that the value of B is **undefined**, if the value of A is **hole**.  |
|  0x07fb	|  PREF_IMM16_ID16_ID16_IMM16_V8	|  callruntime.definesendableclass RRRR, @AAAA, @BBBB, +CCCC, vDD	|  R: 16-bit reserved number used in Ark runtime<br>A: method id of the constructor of [sendable class](arkts-sendable.md#sendable-class)<br>B: literal id<br>C: number of formal parameters of method A<br>D: parent class|  Uses the literal array corresponding to index B and parent class D to create a class object of A and stores it in the acc.  |
|  0x07fc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x07fd	|  PREF_IMM16_V8	|  wide.supercallarrowrange +AAAA, vBB	|  Default input parameter: acc: class object<br>A: number of parameters<br>B, ..., B + A - 1: parameter|  Uses **B, ..., B + A - 1** as a parameter to call the constructor function of the parent class of the class stored in the acc and stores the result in the acc.<br>If the value of A is **0**, B is **undefined**.<br>This instruction appears only in arrow functions.  |
|  0x07fe	|  PREF_IMM8	|  throw.ifsupernotcorrectcall +AA	|  Default input parameter: acc: object<br>A: error type|  Throws an exception if **super** is not called properly.  |
|  0x08fb	|  PREF_IMM16	|  callruntime.ldsendableclass +AAAA	|  A: lexical environment level|  Stores the [Sendable class](arkts-sendable.md#sendable-class) of the lexical environment beyond A levels in the acc.  |
|  0x08fc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x08fd	|  PREF_IMM32	|  wide.ldobjbyindex +AAAAAAAA	|  Default input parameter: acc: object<br>A: property key|  Loads the property whose key is A of the object stored in the acc and stores the property in the acc.  |
|  0x08fe	|  PREF_IMM16	|  throw.ifsupernotcorrectcall +AAAA	|  Default input parameter: acc: object<br>A: error type|  Throws an exception if **super** is not called properly.  |
|  0x09fb	|  PREF_IMM8	|  callruntime.ldsendableexternalmodulevar +AA	|  A: slot number|  Stores the external module variable of slot A in the acc. This instruction is used only in Sendable classes and [Sendable functions](arkts-sendable.md#sendable-function).  |
|  0x09fc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x09fd	|  PREF_V8_IMM32	|  wide.stobjbyindex vAA, +BBBBBBBB	|  Default input parameter: acc: value<br>A: Object<br>B: property key|  Stores the value in the acc to the property whose key is B of object A.  |
|  0x09fe	|  PREF_ID16	|  throw.undefinedifholewithname @AAAA	|  Default input parameter: acc: object<br>A: string id|  Throws an exception indicating that the value of A is **undefined**, if the value in the acc is **hole**.  |
|  0x0afb	|  PREF_IMM16	|  callruntime.wideldsendableexternalmodulevar +AAAA	|  A: slot number|  Stores the external module variable of slot A in the acc. This instruction is used only in Sendable classes and Sendable functions.  |
|  0x0afc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x0afd	|  PREF_V8_IMM32	|  wide.stownbyindex vAA, +BBBBBBBB	|  Default input parameter: acc: value<br>A: Object<br>B: property key|  Stores the value in the acc to the property whose key is B of object A.  |
|  0x0bfb	|  PREF_IMM8	|  callruntime.newsendableenv +AA	|  A: number of slots in a shared lexical environment|  Creates a shared lexical environment with slot A and enters the lexical environment.  |
|  0x0bfc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x0bfd	|  PREF_IMM16	|  wide.copyrestargs +AAAA	|  A: start position of the rest parameters in the formal parameter list|  Copies the rest parameters and stores the parameter array copy in the acc.  |
|  0x0cfb	|  PREF_IMM16	|  callruntime.widenewsendableenv +AAAA	|  A: number of slots in a shared lexical environment| Creates a shared lexical environment with slot A and enters the lexical environment.  |
|  0x0cfc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x0cfd	|  PREF_IMM16_IMM16	|  wide.ldlexvar +AAAA, +BBBB	|  A: lexical environment level<br>B: slot number|  Stores the value of slot B in the lexical environment beyond A levels in the acc.  |
|  0x0dfb	|  PREF_IMM4_IMM4	|  callruntime.stsendablevar +A +B	| 	Default input parameter: acc: value<br>A: shared lexical environment level<br>B: slot number|  Stores the value in the acc to slot B in the shared lexical environment beyond A levels.  |
|  0x0dfc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x0dfd	|  PREF_IMM16_IMM16	|  wide.stlexvar +AAAA, +BBBB	|  Default input parameter: acc: value<br>A: lexical environment level<br>B: slot number|  Stores the value in the acc to slot B in the lexical environment beyond A levels.  |
|  0x0efb	|  PREF_IMM8_IMM8	|  callruntime.stsendablevar +AA +BB	| Default input parameter: acc: value<br>A: shared lexical environment level<br>B: slot number  | Stores the value in the acc to slot B in the shared lexical environment beyond A levels.  |
|  0x0efc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x0efd	|  PREF_IMM16	|  wide.getmodulenamespace +AAAA	|  A: module index|  Executes the [GetModuleNamespace](https://262.ecma-international.org/12.0/#sec-getmodulenamespace) instruction for module A and stores the result in the acc.  |
|  0x0ffb	|  PREF_IMM16_IMM16	|  callruntime.widestsendablevar +AAAA +BBBB	|  Default input parameter: acc: value<br>A: shared lexical environment level<br>B: slot number|  Stores the value in the acc to slot B in the shared lexical environment beyond A levels.  |
|  0x0ffc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x0ffd	|  PREF_IMM16	|  wide.stmodulevar +AAAA	|  Default input parameter: acc: value<br>A: slot number|  Stores the value in the acc to the module variable of slot A.  |
|  0x10fb	|  PREF_IMM4_IMM4	|  callruntime.ldsendablevar +A +B	|  A: shared lexical environment level<br>B: slot number | Stores the value of slot B in the shared lexical environment beyond A levels in the acc.  |
|  0x10fc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x10fd	|  PREF_IMM16	|  wide.ldlocalmodulevar +AAAA	|  A: slot number|  Stores the local module variables of slot A in the acc.|
|  0x11fb	|  PREF_IMM8_IMM8	|  callruntime.ldsendablevar +AA + BB	|  A: shared lexical environment level<br>B: slot number | Stores the value of slot B in the shared lexical environment beyond A levels in the acc.  |
|  0x11fc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x11fd	|  PREF_IMM16	|  wide.ldexternalmodulevar +AAAA	|  A: slot number|  Stores the external module variable of slot A in the acc.|
|  0x12fb	|  PREF_IMM16_IMM16	|  callruntime.wideldsendablevar +AAAA +BBBB	|  A: shared lexical environment level<br>B: slot number|  Stores the value of slot B in the shared lexical environment beyond A levels in the acc.  |
|  0x12fc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x12fd	|  PREF_IMM16	|  wide.ldpatchvar +AAAA	|  A: slot number of the patch variable|  Loads the patch variable of slot A to the acc.<br>This instruction is used only build scenarios under the patch mode.|
|  0x13fb	|  PREF_IMM8	|  callruntime.istrue +RR	|  	Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime|  Calculates `acc == true` and stores the result in the acc.  |
|  0x13fc	|  (deprecated)	 |  |  | Deprecated operation code.|
|  0x13fd	|  PREF_IMM16	|  wide.stpatchvar +AAAA	|  Default input parameter: acc: value<br>A: slot number of the patch variable|  Stores the value in the acc to the patch variable of slot A.<br>This instruction is used only build scenarios under the patch mode.|
|  0x14fb	|  PREF_IMM8	|  callruntime.isfalse +RR	|  	Default input parameter: acc: operand<br>R: 8-bit reserved number used in Ark runtime|  Calculates `acc == false` and stores the result in the acc.  |
|  0x15fb	|  PREF_IMM8	|  callruntime.ldlazymodulevar +AA	|  A: slot number|   Stores the external module variable of slot A in the acc. This instruction applies only to module variables imported using [lazy import](arkts-lazy-import.md).  |
|  0x16fb	|  PREF_IMM16	|  callruntime.wideldlazymodulevar +AAAA	|  A: slot number|   Stores the external module variable of slot A in the acc. This instruction applies only to module variables imported using lazy import.  |
|  0x17fb	|  PREF_IMM8	|  callruntime.ldlazysendablemodulevar +AA	|  A: slot number|   Stores the external module variable of slot A in the acc. This instruction applies only to module variables imported through lazy import and appears only in Sendable classes and Sendable functions.  |
|  0x18fb	|  PREF_IMM16	|  callruntime.wideldlazysendablemodulevar +AAAA	|  A: slot number|  Stores the external module variable of slot A in the acc. This instruction applies only to module variables imported through lazy import and appears only in Sendable classes and Sendable functions.  |
|  0x14fc<br>0x15fc<br>...<br>0x2efc | (deprecated)	 |  |  | Deprecated operation code.|