| push | 将一个或多个寄存器的值压入栈中，更新栈指针寄存器。 | push {r1, r2, r3} |
| add | 执行加法并将结果存储到目标操作数中。 | add r1, r2, #5 |
| push.w | 将指定的寄存器的值压入栈中，并将栈指针向下调整4个字节。 | push.w {r4, r5, lr} |
| sub | 执行减法并将结果存储到目标操作数中。 | sub r1, r2, #5 |
| mov | 将源操作数的值移动到目标操作数中。 | mov r1, r2 |
| ldr | 将内存中指定地址的数据加载到目标操作数中。 | ldr r1, [r2] |
| str | 将源操作数的值存储到内存中指定地址。 | str r1, [r2] |
| movs | 将源操作数的值移动到目标操作数中，并设置条件标志位。 | movs r1, #1 |
| adr | 将指定地址的偏移量加载到目标操作数中。 | adr r1, label |
| ldr.w | 将内存中指定地址的数据加载到目标操作数中，并零扩展为32位。 | ldr.w r1, [r2] |
| adds.w | 将两个操作数相加，并将结果存储到第一个操作数中。 | adds.w r1, r2, #3 |
| bx | 将控制流程更改为另一个代码地址处。 | bx lr |
| cmp | 比较两个操作数的值，并根据比较结果设置条件码寄存器。 | cmp r2, #0 |
| bgt | 当最近一次比较的结果大于时，将控制流程更改为另一个代码地址处。 | bgt loop |
| cmp.w | 与cmp类似，但".w"表示使用16位的操作数大小。 | cmp.w r2, #255 |
| it | 条件代码融合，允许在同一条指令中执行多个条件操作。 | it gt |
| mov.w | 将一个操作数的值复制到另一个操作数中。".w"表示使用16位的操作数大小。 | mov.w r0, #10 |
| lsl.w | 将一个操作数向左移动指定数量的位数。".w"表示使用16位的操作数大小。 | lsl.w r1, r2, #3 |
| b | 将控制流程更改为另一个代码地址处。 | b done |
| bne | 当最近一次比较的结果不相等时，将控制流程更改为另一个代码地址处。 | bne error |
| beq.w | 在条件码寄存器表明最近一次比较的结果相等时，将控制流程更改为另一个代码地址处。".w"表示使用16位的操作数大小。 | beq.w done |
| bl | 将当前程序计数器（PC）中的地址压入链接寄存器（LR），然后将控制流程更改为另一个代码地址处。 | bl printf |
| beq | 与beq.w类似，但没有指定操作数的大小。 | beq error |
| cbz | 测试一个寄存器的值是否为零，如果为零，则将控制流程更改为另一个代码地址处。 | cbz r1, done |
| movt | 将一个16位的立即数移动到寄存器的高16位。 | movt r1, #0x1234 |
| blx | 与bl类似，但可用于跳转到Thumb或ARM代码中的函数。 | blx func |
| cbnz | 与cbz类似，但在测试时会反转结果。 | cbnz r3, loop |
| subs | 将两个操作数相减，并将结果存储到第一个操作数中。它还设置条件码寄存器以表明结果是否小于、等于或大于零。 | subs r1, r2, #1 |
| ittt | 条件并行执行（if-then）。它允许在同一条指令中根据条件执行多个操作。 | ittt eq |
| pop | 从栈中弹出一个或多个寄存器的值。 | pop {r0, r1, r2} |
| ldrb | 从内存中读取一个字节的数据，并将其存储到寄存器中。 | ldrb r1, [r2, #3] |
| strd | 将两个寄存器的值存储到内存中。它可以一次性存储64位的数据。 | strd r1, r2, [r0] |
| strb | 将一个字节的数据存储到内存中。 | strb r1, [r2, #3] |
| pop.w | 从栈中弹出一个或多个寄存器的值。".w"表示使用16位的操作数大小。 | pop.w {r0, r1, r2} |
| str.w | 将一个操作数的值存储到内存中。".w"表示使用16位的操作数大小。 | str.w r3, [r4, #8] |
| bne.w | 当最近一次比较的结果不相等时，跳转到标签所在的地址执行。".w"表示使用16位的操作数大小。 | bne.w loop |
| eor | 对两个操作数进行异或运算，并将结果存储到第一个操作数中。 | eor r1, r2, #0xff |
| mla | 将三个操作数进行乘加运算，并将结果存储到第一个操作数中。 | mla r1, r2, r3, r4 |
| lsls | 将一个操作数向左移动指定数量的位数。它还设置条件码寄存器以表明结果是否小于、等于或大于零。 | lsls r1, r2, #3 |
| adds | 将两个操作数相加，并将结果存储到第一个操作数中。它还设置条件码寄存器以表明结果是否小于、等于或大于零。 | adds r1, r2, #3 |
| movs.w | 将一个操作数的值移动到另一个操作数中，并设置条件码寄存器以指示结果是否小于、等于或大于零。".w"表示使用16位的操作数大小。 | movs.w r1, #10 |
| itttt | 与ittt类似，但可以在同一条指令中执行四个条件分支。 | itttt gt |
| bhi | 在无符号数比较中，如果最近一次比较的结果大于时，跳转到标签所在的地址执行。 | bhi loop |
| add.w | 与add类似，但".w"表示使用16位的操作数大小。 | add.w r1, r2, #3 |
| subs.w | 与subs类似，但".w"表示使用16位的操作数大小。 | subs.w r1, r2, #1 |
| b.w | 与b类似，但指令要求使用16位的操作数大小。 | b.w loop |
| blt | 在有符号数比较中，如果最近一次比较的结果小于时，跳转到标签所在的地址执行。 | blt error |
| stm.w | 与stm类似，但".w"表示使用16位的操作数大小。 | stm.w r0!, {r1, r2, r3} |
| itt | 与ittt类似，但只能在同一条指令中执行两个条件分支。 | itt lt |
| addw | 与add类似，但它允许同时对两个操作数进行加法运算，结果存储到第一个操作数中。 | addw r1, r2, r3 |
| eors.w | 与eor类似，但".w"表示使用16位的操作数大小。 | eors.w r1, r2, #0xff |
| lsls.w | 与lsls类似，但".w"表示使用16位的操作数大小。 | lsls.w r1, r2, #3 |
| eors | 与eors.w类似，但没有指定操作数的大小。 | eors r1, r2, #0xff |
| ldrd | 与ldr类似，但可以一次性读取64位的数据。 | ldrd r1, r2, [r3] |
| ble | 在有符号数比较中，如果最近一次比较的结果小于或等于时，跳转到标签所在的地址执行。 | ble loop |
| movw | 与mov类似，但可以将一个16位的立即数移动到寄存器中。 | movw r1, #0x1234 |
| mul | 将两个操作数进行乘法运算，并将结果存储到第一个操作数中。 | mul r1, r2, r3 |
| asrs | 与asr类似，但它会设置条件码寄存器以指示结果是否小于、等于或大于零。 | asrs r1, r2, #3 |
| ands | 与and类似，但对两个操作数进行按位与运算，并将结果存储到第一个操作数中。 | ands r1, r2, #0xff |
| and.w | 与and类似，但".w"表示使用16位的操作数大小。 | and.w r1, r2, #0xff |
| blt.w | 如果上一次比较结果小于零，则无条件跳转到目标地址。 | blt.w 0x8000 |
| rsb | 将第二个操作数从第一个操作数中减去，并将结果存储在目标寄存器中。 | rsb r0, r1, #2 |
| orr.w | 对两个操作数执行按位逻辑或运算，并将结果存储在目标寄存器中。 | orr.w r0, r1, #0xFF |
| bls | 如果上一次比较结果小于或等于零，则无条件跳转到目标地址。 | bls 0x9000 |
| smmul | 执行有符号的16位乘法，将结果存储在目标寄存器中。 | smmul r0, r1, r2 |
| mls | 执行有符号的32位乘法并减去第三个操作数，将结果存储在目标寄存器中。 | mls r0, r1, r2, r3 |
| asr.w | 对第一个操作数进行算术右移，位移数由第二个操作数指定，并将结果存储在目标寄存器中。 | asr.w r0, r1, #4 |
| bge | 如果上一次比较结果大于或等于零，则无条件跳转到目标地址。 | bge 0xA000 |
| bhs | 如果上一次比较结果大于或等于零，则无条件跳转到目标地址。 | bhs 0xB000 |
| orr | 对两个操作数执行按位逻辑或运算，并将结果存储在目标寄存器中。 | orr r0, r1, #0xFF |
| eor.w | 执行操作数之间的按位异或运算，并将结果存储在目标寄存器中。".w"表示使用16位操作数大小。 | eor.w r0, r1, #0x12 |
| orrs | 执行两个操作数之间的按位逻辑或运算，并根据结果设置条件码。 | orrs r0, r1, #0x3F |
| and | 执行两个操作数之间的按位与运算，并将结果存储在目标寄存器中。 | and r0, r1, #0xFF |
| bic | 对第一个操作数执行与第二个操作数的按位补码运算，并将结果存储在目标寄存器中。 | bic r0, r1, #0x8 |
| sub.w | 将第二个操作数从第一个操作数中减去，并将结果存储在目标寄存器中。".w"表示使用16位操作数大小。 | sub.w r0, r1, #0x2 |
| blo | 如果上一次比较结果小于零（表示目标地址在当前指令之前），则跳转到目标地址执行。 | blo label |
| ldrb.w | 从内存中读取单个字节（8位）的数据，并将其存储在目标寄存器中。".w"表示使用16位操作数大小。 | ldrb.w r0, [r1, #4] |
| strb.w | 将一个寄存器中的单个字节（8位）的数据写入内存。".w"表示使用16位操作数大小。 | strb.w r0, [r1, #4] |
| uxtab | 用于将两个无符号数相加，并将结果存储回一个寄存器中。 | uxtab r0, r1, r2 |
| uxtb | 将一个操作数的低8位扩展为32位，并将结果存储在目标寄存器中。 | uxtb r0, r1 |
| orn | 执行按位或运算并取反操作，将第二个操作数和第一个操作数中的位进行逐位运算，如果结果为0，则将目标寄存器设置为1，否则为0。 | orn r0, r1, #0x3F |
| umull | 执行无符号的32位乘法，并将结果存储在两个目标寄存器中。 | umull r0, r1, r2, r3 |
| lsrs | 将第一个操作数向右移动指定数量的位数，用零填充左侧空缺的位，并将结果存储在另一个操作数中。 | lsrs r0, r1, #4 |
| ldm.w | 从内存中读取一组寄存器的值，并将它们存储在连续的目标寄存器中。".w"表示使用16位操作数大小。 | ldm.w r0, {r1-r4} |
| ite | 条件代码块，根据条件码设置选择执行一组指令或另一组指令。 | ite eq |
| stm | 将一组寄存器的值存储到内存中，并使用递增或递减的方式更新基地址寄存器。 | stm r0!, {r1-r3} |
| rsbs.w | 将第二个操作数从第一个操作数中减去，并将结果的负数存储在目标寄存器中。".w"表示使用16位操作数大小。 | rsbs.w r0, r1, #5 |
| sbcs.w | 执行第一个操作数和第二个操作数之间的按位逻辑加运算，并考虑上一次比较的结果。".w"表示使用16位操作数大小。 | sbcs.w r0, r1, #0x3F |
| ldrh | 从内存中读取一个半字（16位）的数据，并将其存储在目标寄存器中。 | ldrh r0, [r1, #4] |
| ldrsh.w | 从内存中读取有符号半字（16位）的数据并将其扩展为32位，并将结果存储在目标寄存器中。".w"表示使用16位操作数大小。 | ldrsh.w r0, [r1, #2] |
| uxth.w | 将一个操作数的低16位扩展为32位，并将结果存储在目标寄存器中。".w"表示使用16位操作数大小。 | uxth.w r0, r1 |
| uxth | 将一个操作数的低16位扩展为32位，并将结果存储在目标寄存器中。 | uxth r0, r1 |
| vpush | 将一组向量寄存器的值从高地址向低地址压入堆栈。 | vpush {d8-d15} |
| vldr | 从内存中读取向量寄存器的值，并将其加载到指定向量寄存器中。 | vldr d0, [r1] |
| mvn | 对一个操作数执行按位取反操作，并将结果存储在目标寄存器中。 | mvn r0, r1 |
| vmov | 将一个向量寄存器中的值复制到另一个向量寄存器中。 | vmov d0, d1 |
| muls | 执行有符号16位乘法，并将结果存储在目标寄存器中。 | muls r0, r1, r2 |
| vstr | 将向量寄存器的值存储到内存中。 | vstr d0, [r1] |
| vpop | 从堆栈中弹出一组向量寄存器的值，并将它们加载到相应的向量寄存器中。 | vpop {d8-d15} |
| tbb | 使用一个操作数中的索引值获取查找表中的一个字节，并跳转到该字节所对应的地址。 | tbb [r0, r1] |
| strh | 将一个半字（16位）的数据写入内存中。 | strh r0, [r1, #4] |
| vmrs | 将状态寄存器中的值加载到通用寄存器中。 | vmrs r0, fpscr |
| tst.w | 执行两个操作数之间的按位与运算，并根据结果设置条件码。".w"表示使用16位操作数大小。 | tst.w r0, #0x3F |
| bmi | 如果前一次比较结果为负数，则跳转到目标地址执行。 | bmi label |
| lsr.w | 将第一个操作数向右移动指定数量的位数，并将结果存储在另一个操作数中。".w"表示使用16位操作数大小。 | lsr.w r0, r1, #2 |
| sbfx | 选取一个操作数中的一段位，并将其存储在目标寄存器中。 | sbfx r0, r1, #4, #6 |
| ubfx | 选取一个操作数中的一段位，并将其无符号地扩展为32位，并将结果存储在目标寄存器中。 | ubfx r0, r1, #4, #6 |
| subw | 将第二个操作数从第一个操作数中减去，并将结果存储在目标寄存器中。".w"表示使用16位操作数大小。 | subw r0, r1, #2 |
| rsb.w | 将第一个操作数从第二个操作数中减去，并将结果的负数存储在目标寄存器中。".w"表示使用16位操作数大小。 | rsb.w r0, r1, #5 |
| sbc | 执行第一个操作数减去第二个操作数再减去上一次比较结果中的进位值（carry），并将结果存储在目标寄存器中。 | sbc r0, r1, r2 |
| dmb | 确保在所有内存访问之前和之后对其进行屏障同步处理。 | dmb |
| ldrex | 加载一个单一数据元素，并设置一个锁定位以防止其他核心修改该数据元素。 | ldrex r0, [r1] |
| strex | 将一个单一数据元素写入内存地址，并清除标志位以表明数据元素不再被锁定。 | strex r0, r1, [r2] |
| blo.w | 如果前一个比较结果为负数或零，则跳转到目标地址执行。".w"表示使用16位操作数大小。 | blo.w label |
| bhi.w | 如果前一个比较结果为无符号高于，则跳转到目标地址执行。".w"表示使用16位操作数大小。 | bhi.w label |
| tbh | 使用一个操作数中的索引值获取查找表中的一个半字，并跳转到该半字所对应的地址。 | tbh [r0, r1, lsl #1] |
| bls.w | 如果前一个比较结果为负数、零或者无符号低于，则跳转到目标地址执行。".w"表示使用16位操作数大小。 | bls.w label |
| bics | 将第二个操作数按位取反，并与第一个操作数进行按位与运算，将结果存储在目标寄存器中。 | bics r0, r1, #0x3F |
| sxth | 将一个操作数的低16位扩展为有符号的32位，并将结果存储在目标寄存器中。 | sxth r0, r1 |
| bge.w | 如果前一个比较结果大于等于零，则跳转到目标地址执行。".w"表示使用16位操作数大小。 | bge.w label |
| bgt.w | 如果前一个比较结果大于零，则跳转到目标地址执行。".w"表示使用16位操作数大小。 | bgt.w label |
| ror.w | 将第一个操作数向右旋转指定数量的位数，并将结果存储在另一个操作数中。".w"表示使用16位操作数大小。 | ror.w r0, r1, #4 |
| adc.w | 执行第一个操作数加上第二个操作数再加上上一次比较结果中的进位值（carry），并将结果存储在目标寄存器中。".w"表示使用16位操作数大小。 | adc.w r0, r1, r2 |
| bhs.w | 如果前一个比较结果无符号大于等于，则跳转到目标地址执行。".w"表示使用16位操作数大小。 | bhs.w label |
| pkhbt | 从两个操作数中选择一个指定数量的字节，并将它们交替存储在目标寄存器中。 | pkhbt r0, r1, r2 |
| adcs | 执行第一个操作数加上第二个操作数再加上上一次比较结果中的进位值（carry），并将结果和进位值都存储在目标寄存器中。 | adcs r0, r1, r2 |
| sbcs | 执行第一个操作数减去第二个操作数再减去上一次比较结果中的进位值（carry），并将结果和借位值都存储在目标寄存器中。 | sbcs r0, r1, r2 |
| adc | 执行第一个操作数加上第二个操作数再加上上一次比较结果中的进位值（carry），并将结果存储在目标寄存器中。 | adc r0, r1, r2 |
| ble.w | 如果前一个比较结果小于等于零，则跳转到目标地址执行。".w"表示使用16位操作数大小。 | ble.w label |
| bfi | 将一个操作数的一段位插入到另一个操作数的指定位置，并将结果存储在目标寄存器中。 | bfi r0, r1, #4, #6 |
| cmn.w | 执行第一个操作数加上第二个操作数，但不改变任何操作数的值，根据结果设置条件码。".w"表示使用16位操作数大小。 | cmn.w r0, r1 |
| lsr | 将第一个操作数向右移动指定数量的位数，并将结果存储在另一个操作数中。 | lsr r0, r1, #2 |
| lsl | 将第一个操作数向左移动指定数量的位数，并将结果存储在另一个操作数中。 | lsl r0, r1, #4 |
| movge | 如果前一个比较结果大于等于零，则将第二个操作数的值复制到目标寄存器中。 | movge r0, r1 |
| ldrh.w | 从内存中加载一个半字（16位），并将其存储在目标寄存器中。".w"表示使用16位操作数大小。 | ldrh.w r0, [r1, #4] |
| bic.w | 对第一个操作数进行按位取反，并与第二个操作数进行按位与运算，将结果存储在目标寄存器中。".w"表示使用16位操作数大小。 | bic.w r0, r1, #0x3F |
