【ARMv8 编程】A64 内存访问指令——内存加载指令
2024-05-04 15:58:02
与所有先前的 ARM 处理器一样，ARMv8 架构是一种加载/存储架构。这意味着没有数据处理指令直接对内存中的数据进行操作。数据必须首先被加载到寄存器中，修改，然后存储到内存中。该程序必须指定地址、要传输的数据大小以及源或目标寄存器。有额外的加载和存储指令提供更多选项，例如非临时加载/存储、加载/存储独占和获取/释放。
Load 指令的一般形式如下：
LDR Rt, <addr>
对于加载到整数寄存器中的指令，可以选择要加载的大小。例如，要加载小于指定寄存器值的大小，请将以下后缀之一附加到 LDR 指令：
- LDRB（8 位，零扩展）
- LDRSB（8 位，符号扩展）
- LDRH（16 位，零扩展）
- LDRSH（16 位，符号扩展）
- LDRSW（32 位，符号扩展）
下面是 LDRSB 和 LDRB 加载示例图：
还有 unscaled-offset 的偏移形式，例如 LDUR<type>。 程序员通常不需要显式使用 LDUR 形式，因为大多数汇编器可以根据使用的偏移量选择合适的版本。
我们不需要指定 X 寄存器的零扩展加载，因为写入 W 寄存器实际上是零扩展到整个寄存器宽度。
下面是在 Android 平台 Log 打印使用的代码，下面 Demo 代码中会使用到。
#define LOG_TAG "NativeCore"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
1 LDR（立即数）
LDR 指令加载寄存器（立即偏移量）。它有 3 种类型编码：后索引（Post-index）、前索引（Pre-index）和无符号偏移（Unsigned offset）。
Post-index
32-bit (size = 10)
LDR <Wt>, [<Xn|SP>], #<simm>
64-bit (size = 11)
LDR <Xt>, [<Xn|SP>], #<simm>
Pre-index
32-bit (size = 10)
LDR <Wt>, [<Xn|SP>, #<simm>]!
64-bit (size = 11)
LDR <Xt>, [<Xn|SP>, #<simm>]!
Unsigned offset
32-bit (size = 10)
LDR <Wt>, [<Xn|SP>{, #<pimm>}]
64-bit (size = 11)
LDR <Xt>, [<Xn|SP>{, #<pimm>}]
<Wt> 是要传输的通用寄存器的 32 位名称，编码在“Rt”字段中。
<Xt> 是要传输的通用寄存器的 64 位名称，在“Rt”字段中编码。
<Xn|SP> 是通用基址寄存器或堆栈指针的 64 位名称，在“Rn”字段中编码。
<simm> 是带符号的立即字节偏移量，在 -256 到 255 的范围内，在“imm9”字段中编码。
<pimm> 是可选的正立即字节偏移量。对于 32 位变体：是 0 到 16380 范围内 4 的倍数，默认为 0 并在“imm12”字段中编码为 <pimm>/4。对于 64 位变体：是 0 到 32760 范围内 8 的倍数，默认为 0 并在“imm12”字段中编码为 <pimm>/8。
LDR 指令 Post-index
下面是使用 LDR 指令 Post-index 的例子。
- 新建 src_arr、dst_arr 数组，并初始化为 0。
- 给 src_arr 赋初值，将 long long int* 指针转为 char*，为了后续内联汇编加载（笔者环境实测：如果不这样赋值 STR 指令无法正常写入内存）。
- 经过内联汇编代码运行，
MOV X3, %x[len]先将数组长度 len 移动到 X3 寄存器，接着 1 是标签，LDR X2, [%x[src]], #8将 src_arr 数组的前 8 个字节加载到 X2 寄存器，接着 Post-index（也就是地址加 8 写回，下次读取起点已经加 8）。STR X2, [%x[dst]], #8会将刚刚 X2 寄存器的值写入 dst_arr 内存中，同样 Post-index（也就是地址加 8 写回，下次写入起点已经加 8）。SUBS X3, X3, #1将 X3 每次都减去 1，SUBS 会设置条件标志，后面B.GT 1b判断当 SUBS 设置条件标志 Z = 1 时，就不满足跳转到标签 1 处执行的条件，也就退出了内联汇编代码，否则跳转到标签 1 处继续执行。 - 继续打印一次 dst_arr 数组，查看内部值，此时和 src_arr 内的值保持一致，说明 LDR 和 STR 都生效了。
long long int len = 10;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0101010101010101 * i;LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""1:\n""LDR X2, [%x[src]], #8\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
下面是运行结果，首先打印出 src_arr 和 dst_arr 的值，此处知道 dst_arr 已经清零。后面一次 dst_arr 打印，则是经过了内联汇编代码。
2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[0]=0x02023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[1]=0x1010101010101012023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[2]=0x2020202020202022023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[3]=0x3030303030303032023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[4]=0x4040404040404042023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[5]=0x5050505050505052023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[6]=0x6060606060606062023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[7]=0x7070707070707072023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[8]=0x8080808080808082023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[9]=0x9090909090909092023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: =============================2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[0]=0x02023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[1]=0x02023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[2]=0x02023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[3]=0x02023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[4]=0x02023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[5]=0x02023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[6]=0x02023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[7]=0x02023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[8]=0x02023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[9]=0x02023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: -----------------------------2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[0]=0x02023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[1]=0x1010101010101012023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[2]=0x2020202020202022023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[3]=0x3030303030303032023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[4]=0x4040404040404042023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[5]=0x5050505050505052023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[6]=0x6060606060606062023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[7]=0x7070707070707072023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[8]=0x8080808080808082023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[9]=0x909090909090909
LDR 指令 Pre-index
下面是使用 LDR 指令 Pre-index 的例子，也就是 index 提前加 8 的意思。将程序稍做修改，因为 index 提前加 8，为了防止发生内存读取越界，因此引入 SUB X3, X3, #1 先减 1，其次 LDR 指令也换为了 Pre-index 的格式 LDR X2, [%x[src], #8]!，地址先加 8 再去读取内存中的值到寄存器 X2。
long long int len = 10;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0101010101010101 * i;LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""SUB X3, X3, #1\n""1:\n""LDR X2, [%x[src], #8]!\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
运行结果如下：
2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[0]=0x02023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[1]=0x1010101010101012023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[2]=0x2020202020202022023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[3]=0x3030303030303032023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[4]=0x4040404040404042023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[5]=0x5050505050505052023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[6]=0x6060606060606062023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[7]=0x7070707070707072023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[8]=0x8080808080808082023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[9]=0x9090909090909092023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: =============================2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[0]=0x02023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[1]=0x02023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[2]=0x02023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[3]=0x02023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[4]=0x02023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[5]=0x02023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[6]=0x02023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[7]=0x02023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[8]=0x02023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[9]=0x02023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: -----------------------------2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[0]=0x1010101010101012023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[1]=0x2020202020202022023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[2]=0x3030303030303032023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[3]=0x4040404040404042023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[4]=0x5050505050505052023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[5]=0x6060606060606062023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[6]=0x7070707070707072023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[7]=0x8080808080808082023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[8]=0x9090909090909092023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[9]=0x0
LDR 指令 Unsigned offset
下面是使用 LDR 指令 Unsigned offset 的例子，也就是每次从这个 offset（无符号数）读取。
long long int len = 10;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0101010101010101 * i;LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""1:\n""LDR X2, [%x[src], #8]\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
运行结果如下：
2023-04-14 08:05:08.059 7157-7305/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[0]=0x02023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[1]=0x1010101010101012023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[2]=0x2020202020202022023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[3]=0x3030303030303032023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[4]=0x4040404040404042023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[5]=0x5050505050505052023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[6]=0x6060606060606062023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[7]=0x7070707070707072023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[8]=0x8080808080808082023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[9]=0x9090909090909092023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: =============================2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[0]=0x02023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[1]=0x02023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[2]=0x02023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[3]=0x02023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[4]=0x02023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[5]=0x02023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[6]=0x02023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[7]=0x02023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[8]=0x02023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[9]=0x02023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: -----------------------------2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[0]=0x1010101010101012023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[1]=0x1010101010101012023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[2]=0x1010101010101012023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[3]=0x1010101010101012023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[4]=0x1010101010101012023-04-14 08:05:08.061 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[5]=0x1010101010101012023-04-14 08:05:08.061 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[6]=0x1010101010101012023-04-14 08:05:08.061 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[7]=0x1010101010101012023-04-14 08:05:08.061 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[8]=0x1010101010101012023-04-14 08:05:08.061 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[9]=0x101010101010101
2 LDR(literal)
LDR（文字）指令根据 PC 值和立即偏移量计算地址，从内存加载一个字，并将其写入寄存器。
32-bit (opc = 00)
LDR <Wt>, <label>
64-bit (opc = 01)
LDR <Xt>, <label>
<Wt> 是要加载的通用寄存器的 32 位名称，编码在“Rt”字段中。
<Xt> 是要加载的通用寄存器的 64 位名称，编码在“Rt”字段中。
<label> 是要从中加载数据的程序标签。它与该指令地址的偏移量在 +/-1MB 范围内，编码为“imm19”乘以 4。
下面是使用 LDR(literal) 指令的例子。
long long int x = 0;asm volatile("LDR X2, abc\n""MOV %x[x], X2\n""abc:\n""MOV X2, #0\n""MOV X2, #1\n""MOV X2, #2\n":[x] "+r"(x):: "cc", "memory");
执行 LDR X2, abc 将 abc 标签根据 PC 值和立即偏移量计算地址，将这个地址的内容加载到寄存器。此时 x 的值打印出来它固定为 0xd2800022d2800002，它是什么呢？实际就是 MOV X2, #0 和 MOV X2, #1 这两条指令。每条指令都编码为 32 位。
温习一下 MOV (wide immediate)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-StgTzt7P-1682724688018)(https://note.youdao.com/yws/res/112016/WEBRESOURCE199789001157b11eae15547fb4c87e34)]
0xd2800022d2800002 的二进制为 0b1 10 100101 00 0000000000000001 00010 1 10 100101 00 0000000000000000 00010（实际上这些位都是连续的，为了方便解读指令编码做了一些空白），0b1 10 100101 00 0000000000000001 00010 正好是 MOV X2, #1 的指令编码，而 0b1 10 100101 00 0000000000000000 00010则是 MOV X2, #0 的指令编码。
再来用 IDA 工具反编译一下这段代码：
我们可以清晰看到 MOV X2, #2 这条指令，却看不到它上面的另外两条 MOV (wide immediate) 指令，因为它们编码在 0xd2800022d2800002 内了。 并且 LDR X2, abc 替换成了 LDR X2, =0xD2800022D2800002，这和我们的运行结果完全一致。
3 LDR（寄存器）
LDR（寄存器）指令根据基址寄存器值和偏移寄存器值计算地址，从内存中加载一个字，并将其写入寄存器。偏移寄存器值可以选择性地移位和扩展。
32-bit (size = 10)
LDR <Wt>, [<Xn|SP>, (<Wm>|<Xm>){, <extend> {<amount>}}]
64-bit (size = 11)
LDR <Xt>, [<Xn|SP>, (<Wm>|<Xm>){, <extend> {<amount>}}]
<Wt> 是要传输的通用寄存器的 32 位名称，在“Rt”字段中编码。
<Xt> 是要传输的通用寄存器的 64 位名称，在“Rt”字段中编码。
<Xn|SP> 是通用基址寄存器或堆栈指针的 64 位名称，在“Rn”字段中编码。
<Wm> 当 option<0> 设置为 0 时，是通用索引寄存器的 32 位名称，编码在“Rm”字段中。
<Xm> 当 option<0> 设置为 1 时，是通用索引寄存器的 64 位名称，编码在“Rm”字段中。
<extend> 是索引扩展/移位说明符，默认为 LSL，当省略 <amount> 时，LSL 选项必须省略。在“option”字段中编码。它可以具有以下值：
| <extend> | option 编码 |
|---|---|
| UXTW | 010 |
| LSL | 011 |
| SXTW | 110 |
| SXTX | 111 |
<amount> 是索引移位量。仅当 <extend> 不是 LSL 时才可选。在允许可选的地方，它默认为 #0。
对于 32 位变体：它在“S”字段中编码可以具有以下值：
| <amount> | S 编码 |
|---|---|
| #0 | 0 |
| #2 | 1 |
对于 64 位变体：它在“S”字段中编码可以具有以下值：
| <amount> | S 编码 |
|---|---|
| #0 | 0 |
| #3 | 1 |
下面是使用 LDR（寄存器）指令的例子。
long long int len = 3;long long int x = 0;auto *y_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){y_arr[i] = 0x0102030410203040 * (i + 1);LOGD("y_arr[%d]=0x%llx", i, y_arr[i]);}char* y = (char*)y_arr;asm volatile("MOV X3, #1\n""LDR %x[x], [%x[y] ,X3, LSL#3]\n":[x] "+r"(x),[y] "+r"(y):: "cc", "memory");LOGD("-----------------------------");LOGD("x=0x%llx", x);delete[] y_arr;
运行结果如下：
2023-04-15 21:14:22.007 20790-20790/com.example.myapplication D/native-armv8a: +++++++++++++++++++++++++++++2023-04-15 21:14:22.007 20790-20790/com.example.myapplication D/native-armv8a: y_arr[0]=0x1020304102030402023-04-15 21:14:22.007 20790-20790/com.example.myapplication D/native-armv8a: y_arr[1]=0x2040608204060802023-04-15 21:14:22.007 20790-20790/com.example.myapplication D/native-armv8a: y_arr[2]=0x306090c306090c02023-04-15 21:14:22.007 20790-20790/com.example.myapplication D/native-armv8a: -----------------------------2023-04-15 21:14:22.007 20790-20790/com.example.myapplication D/native-armv8a: x=0x204060820406080
执行 LDR %x[x], [%x[y] ,X3, LSL#3]，首先经过 MOV X3, #1 指令后 X3 的值为 1，在 X3 索引寄存器上逻辑左移 3 位，也就是 1 * 8 = 8，最终在 y_arr（%x[y] 内装载的实际上就是 y_arr 数组的基址） 上准备加载的索引就是 8，也就将 8 ~ 15 这些索引指向的字节加载到 %x[x] 寄存器，所以最终 x 的值为 0x204060820406080（和 y_arr 中第二个值是相同的）。
4 LDRB（立即数）
加载寄存器字节（立即数）指令从内存中加载一个字节，对其进行零扩展，并将结果写入寄存器。用于加载的地址是根据基址寄存器和立即偏移量计算得出的。
Post-index
LDRB <Wt>, [<Xn|SP>], #<simm>
Pre-index
LDRB <Wt>, [<Xn|SP>, #<simm>]!
Unsigned offset
LDRB <Wt>, [<Xn|SP>{, #<pimm>}]
<Wt> 是要传输的通用寄存器的 32 位名称，在“Rt”字段中编码。
<Xn|SP> 是通用基址寄存器或堆栈指针的 64 位名称，在“Rn”字段中编码。
<simm> 是带符号的立即字节偏移量，在 -256 到 255 的范围内，在“imm9”字段中编码。
<pimm> 是可选的正立即字节偏移量，范围为 0 到 4095，默认为 0 并在“imm12”字段中编码。
LDRB（立即数）Post-index
下面是使用 LDRB（立即数）Post-index 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0102030410203040 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""1:\n""LDRB W2, [%x[src]], #8\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
从结果不难知道 LDRB W2, [%x[src]], #8 确实只加载了一个字节到 W2 寄存器，并把寄存器高位全部清零，这里还能确定的一点是数据是按照小端在内存中分布的。运行结果如下：
2023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: +++++++++++++++++++++++++++++2023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: src_arr[0]=0x1020304102030402023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: src_arr[1]=0x2040608204060802023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: src_arr[2]=0x306090c306090c02023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: =============================2023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: dst_arr[0]=0x02023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: dst_arr[1]=0x02023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: dst_arr[2]=0x02023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: -----------------------------2023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: dst_arr[0]=0x402023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: dst_arr[1]=0x802023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: dst_arr[2]=0xc0
LDRB（立即数）Pre-index
下面是使用 LDRB（立即数）Pre-index 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0102030410203040 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""SUB X3, X3, #1\n""1:\n""LDRB W2, [%x[src], #8]!\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
运行结果如下：
2023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: +++++++++++++++++++++++++++++2023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: src_arr[0]=0x1020304102030402023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: src_arr[1]=0x2040608204060802023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: src_arr[2]=0x306090c306090c02023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: =============================2023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: dst_arr[0]=0x02023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: dst_arr[1]=0x02023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: dst_arr[2]=0x02023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: -----------------------------2023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: dst_arr[0]=0x802023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: dst_arr[1]=0xc02023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: dst_arr[2]=0x0
LDRB（立即数）Unsigned offset
下面是使用 LDRB（立即数）Unsigned offset 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0102030410203040 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""1:\n""LDRB W2, [%x[src], #6]\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
运行结果如下：
2023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: +++++++++++++++++++++++++++++2023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: src_arr[0]=0x1020304102030402023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: src_arr[1]=0x2040608204060802023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: src_arr[2]=0x306090c306090c02023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: =============================2023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: dst_arr[0]=0x02023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: dst_arr[1]=0x02023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: dst_arr[2]=0x02023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: -----------------------------2023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: dst_arr[0]=0x22023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: dst_arr[1]=0x22023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: dst_arr[2]=0x2
5 LDRB（寄存器）
加载寄存器字节（寄存器）指令根据基址寄存器值和偏移寄存器值计算地址，从内存中加载一个字节，对其进行零扩展，并将其写入寄存器。
Extended register (option != 011)
LDRB <Wt>, [<Xn|SP>, (<Wm>|<Xm>), <extend> {<amount>}]
Shifted register (option = 011)
LDRB <Wt>, [<Xn|SP>, <Xm>{, LSL <amount>}]
<Wt> 是要传输的通用寄存器的 32 位名称，在“Rt”字段中编码。
<Xn|SP> 是通用基址寄存器或堆栈指针的 64 位名称，在“Rn”字段中编码。
<Wm> 当 option<0> 设置为 0 时，是通用索引寄存器的 32 位名称，编码在“Rm”字段中。
<Xm> 当 option<0> 设置为 1 时，是通用索引寄存器的 64 位名称，编码在“Rm”字段中。
<extend> 是索引扩展说明符，在“option”字段中编码。它可以具有以下值：
| <extend> | option 编码 |
|---|---|
| UXTW | 010 |
| SXTW | 110 |
| SXTX | 111 |
<amount> 是索引移位量，必须是#0，如果省略则在“S”中编码为0，如果存在则编码为1。
下面是使用 LDRB（寄存器）指令的例子。
long long int len = 3;long int x = 0;auto *y_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){y_arr[i] = 0x0102030410203050 * (i + 1);LOGD("y_arr[%d]=0x%llx", i, y_arr[i]);}char* y = (char*)y_arr;asm volatile("MOV X3, #16\n""LDRB %w[x], [%x[y] ,X3, LSL#0]\n":[x] "+r"(x),[y] "+r"(y):: "cc", "memory");LOGD("-----------------------------");LOGD("x=0x%lx", x);delete[] y_arr;
运行结果如下：
2023-04-16 16:07:58.615 20132-20132/com.example.myapplication D/native-armv8a: +++++++++++++++++++++++++++++2023-04-16 16:07:58.615 20132-20132/com.example.myapplication D/native-armv8a: y_arr[0]=0x1020304102030502023-04-16 16:07:58.615 20132-20132/com.example.myapplication D/native-armv8a: y_arr[1]=0x2040608204060a02023-04-16 16:07:58.615 20132-20132/com.example.myapplication D/native-armv8a: y_arr[2]=0x306090c306090f02023-04-16 16:07:58.615 20132-20132/com.example.myapplication D/native-armv8a: -----------------------------2023-04-16 16:07:58.615 20132-20132/com.example.myapplication D/native-armv8a: x=0xf0
MOV X3, #16 将索引立即数 16 移动到 X3 寄存器，LDRB %w[x], [%x[y] ,X3, LSL#0] 则首先对索引逻辑左移 0 位，也就是没变化还是 16，接着就从 16 这个位置加载 y_arr 中的字节，也就是 0xF0，写入 %w[x]，并把寄存器高位清零，所以最终 x 的值就为 0xF0。
6 LDRSB（立即数）
加载寄存器有符号字节（立即数）指令从内存中加载一个字节，将其符号扩展为 32 位或 64 位，并将结果写入寄存器。用于加载的地址是根据基址寄存器和立即偏移量计算得出的。
Post-index
32-bit (opc = 11)
LDRSB <Wt>, [<Xn|SP>], #<simm>
64-bit (opc = 10)
LDRSB <Xt>, [<Xn|SP>], #<simm>
Pre-index
32-bit (opc = 11)
LDRSB <Wt>, [<Xn|SP>, #<simm>]!
64-bit (opc = 10)
LDRSB <Xt>, [<Xn|SP>, #<simm>]!
Unsigned offset
32-bit (opc = 11)
LDRSB <Wt>, [<Xn|SP>{, #<pimm>}]
64-bit (opc = 10)
LDRSB <Xt>, [<Xn|SP>{, #<pimm>}]
<Wt> 是要传输的通用寄存器的 32 位名称，在“Rt”字段中编码。
<Xt> 是要传输的通用寄存器的 64 位名称，在“Rt”字段中编码。
<Xn|SP> 是通用基址寄存器或堆栈指针的 64 位名称，在“Rn”字段中编码。
<simm> 是带符号的立即字节偏移量，在 -256 到 255 的范围内，在“imm9”字段中编码。
<pimm> 是可选的正立即字节偏移量，范围为 0 到 4095，默认为 0 并在“imm12”字段中编码。
LDRSB（立即数）Post-index
下面是使用 LDRSB（立即数）Post-index 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0102030410203050 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""1:\n""LDRSB X2, [%x[src]], #8\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
我们看到 dst_arr 的最后两个值变为了负数，这就是 LDRSB 补符号位的作用。运行结果如下：
2023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: +++++++++++++++++++++++++++++2023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: src_arr[0]=0x1020304102030502023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: src_arr[1]=0x2040608204060a02023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: src_arr[2]=0x306090c306090f02023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: =============================2023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: dst_arr[0]=0x02023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: dst_arr[1]=0x02023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: dst_arr[2]=0x02023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: -----------------------------2023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: dst_arr[0]=0x502023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: dst_arr[1]=0xffffffffffffffa02023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: dst_arr[2]=0xfffffffffffffff0
LDRSB（立即数）Pre-index
下面是使用 LDRSB（立即数）Pre-index 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0102030410203050 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""SUB X3, X3, #1\n""1:\n""LDRSB X2, [%x[src], #8]!\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
和 LDRSB（立即数）Post-index 指令的区别就是 index 前置自增了。运行结果如下：
2023-04-16 20:44:15.080 10777-10777/com.example.myapplication D/native-armv8a: +++++++++++++++++++++++++++++
2023-04-16 20:44:15.080 10777-10777/com.example.myapplication D/native-armv8a: src_arr[0]=0x102030410203050
2023-04-16 20:44:15.080 10777-10777/com.example.myapplication D/native-armv8a: src_arr[1]=0x2040608204060a0
2023-04-16 20:44:15.080 10777-10777/com.example.myapplication D/native-armv8a: src_arr[2]=0x306090c306090f0
2023-04-16 20:44:15.080 10777-10777/com.example.myapplication D/native-armv8a: =============================
2023-04-16 20:44:15.080 10777-10777/com.example.myapplication D/native-armv8a: dst_arr[0]=0x0
2023-04-16 20:44:15.080 10777-10777/com.example.myapplication D/native-armv8a: dst_arr[1]=0x0
2023-04-16 20:44:15.080 10777-10777/com.example.myapplication D/native-armv8a: dst_arr[2]=0x0
2023-04-16 20:44:15.080 10777-10777/com.example.myapplication D/native-armv8a: -----------------------------
2023-04-16 20:44:15.080 10777-10777/com.example.myapplication D/native-armv8a: dst_arr[0]=0xffffffffffffffa0
2023-04-16 20:44:15.080 10777-10777/com.example.myapplication D/native-armv8a: dst_arr[1]=0xfffffffffffffff0
2023-04-16 20:44:15.080 10777-10777/com.example.myapplication D/native-armv8a: dst_arr[2]=0x0LDRSB（立即数）Unsigned offset
下面是使用 LDRSB（立即数）Unsigned offset 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0102030410203050 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""1:\n""LDRSB X2, [%x[src], #6]\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
除了加载固定位置的字节外，由于字节的符号位为 0，所以没有出现负数的行为！运行结果如下：
2023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: +++++++++++++++++++++++++++++2023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: src_arr[0]=0x1020304102030502023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: src_arr[1]=0x2040608204060a02023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: src_arr[2]=0x306090c306090f02023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: =============================2023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: dst_arr[0]=0x02023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: dst_arr[1]=0x02023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: dst_arr[2]=0x02023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: -----------------------------2023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: dst_arr[0]=0x22023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: dst_arr[1]=0x22023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: dst_arr[2]=0x2
7 LDRSB（寄存器）
加载寄存器有符号字（寄存器）指令根据基址寄存器值和偏移寄存器值计算地址，从内存中加载一个字节，对其进行符号扩展，并将其写入寄存器。
32-bit extended register offset (opc = 11 && option != 011)
LDRSB <Wt>, [<Xn|SP>, (<Wm>|<Xm>), <extend> {<amount>}]
32-bit shifted register offset (opc = 11 && option = 011)
LDRSB <Wt>, [<Xn|SP>, <Xm>{, LSL <amount>}]
64-bit extended register offset (opc = 10 && option != 011)
LDRSB <Xt>, [<Xn|SP>, (<Wm>|<Xm>), <extend> {<amount>}]
64-bit shifted register offset (opc = 10 && option = 011)
LDRSB <Xt>, [<Xn|SP>, <Xm>{, LSL <amount>}]
<Wt> 是要传输的通用寄存器的 32 位名称，在“Rt”字段中编码。
<Xt> 是要传输的通用寄存器的 64 位名称，在“Rt”字段中编码。
<Xn|SP> 是通用基址寄存器或堆栈指针的 64 位名称，在“Rn”字段中编码。
<Wm> 当 option<0> 设置为 0 时，是通用索引寄存器的 32 位名称，编码在“Rm”字段中。
<Xm> 当 option<0> 设置为 1 时，是通用索引寄存器的 64 位名称，编码在“Rm”字段中。
<extend> 是索引扩展说明符，编码在“option”中：
| option | <extend> |
|---|---|
| 010 | UXTW |
| 110 | SXTW |
| 111 | SXTX |
<amount> 是索引移位量，必须是#0，如果省略则在“S”中编码为0，如果存在则编码为1。
下面是使用 LDRSB（寄存器）指令的例子。
long long int len = 3;long int x = 0;auto *y_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){y_arr[i] = 0x0102030410203050 * (i + 1);LOGD("y_arr[%d]=0x%llx", i, y_arr[i]);}char* y = (char*)y_arr;asm volatile("MOV X3, #16\n""LDRSB %w[x], [%x[y] ,X3, LSL#0]\n":[x] "+r"(x),[y] "+r"(y):: "cc", "memory");LOGD("-----------------------------");LOGD("x=0x%lx", x);delete[] y_arr;
我们看到和 LDRB（寄存器）指令的区别是对符号位的处理。运行结果如下：
2023-04-17 08:13:44.105 12670-12733/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++
2023-04-17 08:13:44.105 12670-12733/com.demo.myapplication D/NativeCore: y_arr[0]=0x102030410203050
2023-04-17 08:13:44.105 12670-12733/com.demo.myapplication D/NativeCore: y_arr[1]=0x2040608204060a0
2023-04-17 08:13:44.105 12670-12733/com.demo.myapplication D/NativeCore: y_arr[2]=0x306090c306090f0
2023-04-17 08:13:44.105 12670-12733/com.demo.myapplication D/NativeCore: -----------------------------
2023-04-17 08:13:44.105 12670-12733/com.demo.myapplication D/NativeCore: x=0xfffffff0
8 LDRH（立即数）
加载寄存器半字（立即数）指令从内存中加载一个半字，对其进行零扩展，并将结果写入寄存器。用于加载的地址是根据基址寄存器和立即偏移量计算得出的。
Post-index
LDRH <Wt>, [<Xn|SP>], #<simm>
Pre-index
LDRH <Wt>, [<Xn|SP>, #<simm>]!
Unsigned offset
LDRH <Wt>, [<Xn|SP>{, #<pimm>}]
<Wt> 是要传输的通用寄存器的 32 位名称，在“Rt”字段中编码。
<Xn|SP> 是通用基址寄存器或堆栈指针的 64 位名称，在“Rn”字段中编码。
<simm> 是带符号的立即字节偏移量，在 -256 到 255 的范围内，在“imm9”字段中编码。
<pimm> 是可选的正立即字节偏移量，是 0 到 8190 范围内 2 的倍数，默认为 0 并在“imm12”字段中编码为 <pimm>/2。
LDRH（立即数）Post-index
下面是使用 LDRH（立即数）Post-index 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0102030410203040 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""1:\n""LDRH W2, [%x[src]], #8\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
从结果不难知道 LDRH W2, [%x[src]], #8 确实只加载了两个字节（即半字）到 W2 寄存器，并把寄存器高位全部清零。运行结果如下：
2023-04-18 07:47:47.383 15674-15741/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++
2023-04-18 07:47:47.383 15674-15741/com.demo.myapplication D/NativeCore: src_arr[0]=0x102030410203040
2023-04-18 07:47:47.383 15674-15741/com.demo.myapplication D/NativeCore: src_arr[1]=0x204060820406080
2023-04-18 07:47:47.383 15674-15741/com.demo.myapplication D/NativeCore: src_arr[2]=0x306090c306090c0
2023-04-18 07:47:47.383 15674-15741/com.demo.myapplication D/NativeCore: =============================
2023-04-18 07:47:47.383 15674-15741/com.demo.myapplication D/NativeCore: dst_arr[0]=0x0
2023-04-18 07:47:47.383 15674-15741/com.demo.myapplication D/NativeCore: dst_arr[1]=0x0
2023-04-18 07:47:47.383 15674-15741/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
2023-04-18 07:47:47.383 15674-15741/com.demo.myapplication D/NativeCore: -----------------------------
2023-04-18 07:47:47.383 15674-15741/com.demo.myapplication D/NativeCore: dst_arr[0]=0x3040
2023-04-18 07:47:47.383 15674-15741/com.demo.myapplication D/NativeCore: dst_arr[1]=0x6080
2023-04-18 07:47:47.383 15674-15741/com.demo.myapplication D/NativeCore: dst_arr[2]=0x90c0
LDRH（立即数）Pre-index
下面是使用 LDRH（立即数）Pre-index 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0102030410203040 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""SUB X3, X3, #1\n""1:\n""LDRH W2, [%x[src], #8]!\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
运行结果如下：
2023-04-18 07:51:27.771 17090-17178/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++
2023-04-18 07:51:27.771 17090-17178/com.demo.myapplication D/NativeCore: src_arr[0]=0x102030410203040
2023-04-18 07:51:27.772 17090-17178/com.demo.myapplication D/NativeCore: src_arr[1]=0x204060820406080
2023-04-18 07:51:27.772 17090-17178/com.demo.myapplication D/NativeCore: src_arr[2]=0x306090c306090c0
2023-04-18 07:51:27.772 17090-17178/com.demo.myapplication D/NativeCore: =============================
2023-04-18 07:51:27.772 17090-17178/com.demo.myapplication D/NativeCore: dst_arr[0]=0x0
2023-04-18 07:51:27.772 17090-17178/com.demo.myapplication D/NativeCore: dst_arr[1]=0x0
2023-04-18 07:51:27.772 17090-17178/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
2023-04-18 07:51:27.772 17090-17178/com.demo.myapplication D/NativeCore: -----------------------------
2023-04-18 07:51:27.772 17090-17178/com.demo.myapplication D/NativeCore: dst_arr[0]=0x6080
2023-04-18 07:51:27.772 17090-17178/com.demo.myapplication D/NativeCore: dst_arr[1]=0x90c0
2023-04-18 07:51:27.772 17090-17178/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
LDRH（立即数）Unsigned offset
下面是使用 LDRH（立即数）Unsigned offset 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0102030410203040 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""1:\n""LDRH W2, [%x[src], #6]\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
运行结果如下：
2023-04-18 07:53:55.745 18154-18224/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++
2023-04-18 07:53:55.745 18154-18224/com.demo.myapplication D/NativeCore: src_arr[0]=0x102030410203040
2023-04-18 07:53:55.745 18154-18224/com.demo.myapplication D/NativeCore: src_arr[1]=0x204060820406080
2023-04-18 07:53:55.745 18154-18224/com.demo.myapplication D/NativeCore: src_arr[2]=0x306090c306090c0
2023-04-18 07:53:55.745 18154-18224/com.demo.myapplication D/NativeCore: =============================
2023-04-18 07:53:55.745 18154-18224/com.demo.myapplication D/NativeCore: dst_arr[0]=0x0
2023-04-18 07:53:55.745 18154-18224/com.demo.myapplication D/NativeCore: dst_arr[1]=0x0
2023-04-18 07:53:55.745 18154-18224/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
2023-04-18 07:53:55.745 18154-18224/com.demo.myapplication D/NativeCore: -----------------------------
2023-04-18 07:53:55.745 18154-18224/com.demo.myapplication D/NativeCore: dst_arr[0]=0x102
2023-04-18 07:53:55.745 18154-18224/com.demo.myapplication D/NativeCore: dst_arr[1]=0x102
2023-04-18 07:53:55.745 18154-18224/com.demo.myapplication D/NativeCore: dst_arr[2]=0x102
9 LDRH（寄存器）
加载寄存器半字（寄存器）指令根据基址寄存器值和偏移寄存器值计算地址，从内存中加载一个半字，对其进行零扩展，并将其写入寄存器。
LDRH <Wt>, [<Xn|SP>, (<Wm>|<Xm>){, <extend> {<amount>}}]
<Wt> 是要传输的通用寄存器的 32 位名称，在“Rt”字段中编码。
<Xn|SP> 是通用基址寄存器或堆栈指针的 64 位名称，在“Rn”字段中编码。
<Wm> 当 option<0> 设置为 0 时，是通用索引寄存器的 32 位名称，编码在“Rm”字段中。
<Xm> 当 option<0> 设置为 1 时，是通用索引寄存器的 64 位名称，编码在“Rm”字段中。
<extend> 是索引扩展/移位说明符，默认为 LSL，当省略 <amount> 时，LSL 选项必须省略。 在“option”中编码：
| option | <extend> |
|---|---|
| 010 | UXTW |
| 011 | LSL |
| 110 | SXTW |
| 111 | SXTX |
<amount> 索引移位量，仅当<extend>不是 LSL 时可选。在允许可选的地方，它默认为#0。 它以“S”编码：
| S | <amount> |
|---|---|
| 0 | #0 |
| 1 | #1 |
下面是使用 LDRH（寄存器）指令的例子。
long long int len = 3;long int x = 0;auto *y_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){y_arr[i] = 0x0102030410205030 * (i + 1);LOGD("y_arr[%d]=0x%llx", i, y_arr[i]);}char* y = (char*)y_arr;asm volatile("MOV X3, #16\n""LDRH %w[x], [%x[y] ,X3, LSL#0]\n":[x] "+r"(x),[y] "+r"(y):: "cc", "memory");LOGD("-----------------------------");LOGD("x=0x%lx", x);delete[] y_arr;
注意看 LDRH（寄存器）指令的对符号位的处理方式，并没有扩展符号位。运行结果如下：
2023-04-18 08:03:02.690 19907-20036/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++
2023-04-18 08:03:02.690 19907-20036/com.demo.myapplication D/NativeCore: y_arr[0]=0x102030410205030
2023-04-18 08:03:02.690 19907-20036/com.demo.myapplication D/NativeCore: y_arr[1]=0x20406082040a060
2023-04-18 08:03:02.690 19907-20036/com.demo.myapplication D/NativeCore: y_arr[2]=0x306090c3060f090
2023-04-18 08:03:02.691 19907-20036/com.demo.myapplication D/NativeCore: -----------------------------
2023-04-18 08:03:02.691 19907-20036/com.demo.myapplication D/NativeCore: x=0xf090
10 LDRSH（立即数）
加载寄存器带符号半字（立即数）指令从内存中加载半字，将其符号扩展为 32 位或 64 位，并将结果写入寄存器。用于加载的地址是根据基址寄存器和立即偏移量计算得出的。
Post-index
32-bit (opc == 11)
LDRSH <Wt>, [<Xn|SP>], #<simm>
64-bit (opc == 10)
LDRSH <Xt>, [<Xn|SP>], #<simm>
Pre-index
32-bit (opc == 11)
LDRSH <Wt>, [<Xn|SP>, #<simm>]!
64-bit (opc == 10)
LDRSH <Xt>, [<Xn|SP>, #<simm>]!
Unsigned offset
32-bit (opc == 11)
LDRSH <Wt>, [<Xn|SP>{, #<pimm>}]
64-bit (opc == 10)
LDRSH <Xt>, [<Xn|SP>{, #<pimm>}]
<Wt> 是要传输的通用寄存器的 32 位名称，在“Rt”字段中编码。
<Xt> 是要传输的通用寄存器的 64 位名称，在“Rt”字段中编码。
<Xn|SP> 是通用基址寄存器或堆栈指针的 64 位名称，在“Rn”字段中编码。
<simm> 是带符号的立即字节偏移量，在 -256 到 255 的范围内，在“imm9”字段中编码。
<pimm> 是可选的正立即字节偏移量，是 0 到 8190 范围内 2 的倍数，默认为 0 并在“imm12”字段中编码为 <pimm>/2。
LDRSH（立即数）Post-index
下面是使用 LDRSH（立即数）Post-index 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0102030410203050 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""1:\n""LDRSH X2, [%x[src]], #8\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
我们看到 dst_arr 的最后一个值变为了负数，这就是 LDRSH 补符号位的作用。运行结果如下：
2023-04-18 08:20:35.778 24768-24851/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++
2023-04-18 08:20:35.778 24768-24851/com.demo.myapplication D/NativeCore: src_arr[0]=0x102030410203050
2023-04-18 08:20:35.778 24768-24851/com.demo.myapplication D/NativeCore: src_arr[1]=0x2040608204060a0
2023-04-18 08:20:35.778 24768-24851/com.demo.myapplication D/NativeCore: src_arr[2]=0x306090c306090f0
2023-04-18 08:20:35.778 24768-24851/com.demo.myapplication D/NativeCore: =============================
2023-04-18 08:20:35.778 24768-24851/com.demo.myapplication D/NativeCore: dst_arr[0]=0x0
2023-04-18 08:20:35.778 24768-24851/com.demo.myapplication D/NativeCore: dst_arr[1]=0x0
2023-04-18 08:20:35.778 24768-24851/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
2023-04-18 08:20:35.778 24768-24851/com.demo.myapplication D/NativeCore: -----------------------------
2023-04-18 08:20:35.778 24768-24851/com.demo.myapplication D/NativeCore: dst_arr[0]=0x3050
2023-04-18 08:20:35.778 24768-24851/com.demo.myapplication D/NativeCore: dst_arr[1]=0x60a0
2023-04-18 08:20:35.778 24768-24851/com.demo.myapplication D/NativeCore: dst_arr[2]=0xffffffffffff90f0
LDRSH（立即数）Pre-index
下面是使用 LDRSH（立即数）Pre-index 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0102030410203050 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""SUB X3, X3, #1\n""1:\n""LDRSH X2, [%x[src], #8]!\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
和 LDRSH（立即数）Post-index 指令的区别就是 index 前置自增了。运行结果如下：
2023-04-18 08:22:29.119 25484-25614/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++
2023-04-18 08:22:29.119 25484-25614/com.demo.myapplication D/NativeCore: src_arr[0]=0x102030410203050
2023-04-18 08:22:29.119 25484-25614/com.demo.myapplication D/NativeCore: src_arr[1]=0x2040608204060a0
2023-04-18 08:22:29.119 25484-25614/com.demo.myapplication D/NativeCore: src_arr[2]=0x306090c306090f0
2023-04-18 08:22:29.119 25484-25614/com.demo.myapplication D/NativeCore: =============================
2023-04-18 08:22:29.119 25484-25614/com.demo.myapplication D/NativeCore: dst_arr[0]=0x0
2023-04-18 08:22:29.119 25484-25614/com.demo.myapplication D/NativeCore: dst_arr[1]=0x0
2023-04-18 08:22:29.119 25484-25614/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
2023-04-18 08:22:29.119 25484-25614/com.demo.myapplication D/NativeCore: -----------------------------
2023-04-18 08:22:29.119 25484-25614/com.demo.myapplication D/NativeCore: dst_arr[0]=0x60a0
2023-04-18 08:22:29.119 25484-25614/com.demo.myapplication D/NativeCore: dst_arr[1]=0xffffffffffff90f0
2023-04-18 08:22:29.119 25484-25614/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
LDRSH（立即数）Unsigned offset
下面是使用 LDRSH（立即数）Unsigned offset 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x8102030410203050 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""1:\n""LDRSH X2, [%x[src], #6]\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
除了加载固定位置的半字外，由于半字的符号位为 1，所以进行了补 1 操作（符号位扩展），运行结果如下：
2023-04-18 08:25:22.617 27152-27230/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++
2023-04-18 08:25:22.617 27152-27230/com.demo.myapplication D/NativeCore: src_arr[0]=0x8102030410203050
2023-04-18 08:25:22.617 27152-27230/com.demo.myapplication D/NativeCore: src_arr[1]=0x2040608204060a0
2023-04-18 08:25:22.617 27152-27230/com.demo.myapplication D/NativeCore: src_arr[2]=0x8306090c306090f0
2023-04-18 08:25:22.617 27152-27230/com.demo.myapplication D/NativeCore: =============================
2023-04-18 08:25:22.617 27152-27230/com.demo.myapplication D/NativeCore: dst_arr[0]=0x0
2023-04-18 08:25:22.617 27152-27230/com.demo.myapplication D/NativeCore: dst_arr[1]=0x0
2023-04-18 08:25:22.617 27152-27230/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
2023-04-18 08:25:22.617 27152-27230/com.demo.myapplication D/NativeCore: -----------------------------
2023-04-18 08:25:22.617 27152-27230/com.demo.myapplication D/NativeCore: dst_arr[0]=0xffffffffffff8102
2023-04-18 08:25:22.617 27152-27230/com.demo.myapplication D/NativeCore: dst_arr[1]=0xffffffffffff8102
2023-04-18 08:25:22.617 27152-27230/com.demo.myapplication D/NativeCore: dst_arr[2]=0xffffffffffff8102
11 LDRSH（寄存器）
加载寄存器带符号半字（寄存器）指令根据基址寄存器值和偏移寄存器值计算地址，从内存加载半字，对其进行符号扩展，并将其写入寄存器。
32-bit (opc == 11)
LDRSH <Wt>, [<Xn|SP>, (<Wm>|<Xm>){, <extend> {<amount>}}]
64-bit (opc == 10)
LDRSH <Xt>, [<Xn|SP>, (<Wm>|<Xm>){, <extend> {<amount>}}]
<Wt> 是要传输的通用寄存器的 32 位名称，在“Rt”字段中编码。
<Xt> 是要传输的通用寄存器的 64 位名称，在“Rt”字段中编码。
<Xn|SP> 是通用基址寄存器或堆栈指针的 64 位名称，在“Rn”字段中编码。
<Wm> 当 option<0> 设置为 0 时，是通用索引寄存器的 32 位名称，编码在“Rm”字段中。
<Xm> 当 option<0> 设置为 1 时，是通用索引寄存器的 64 位名称，编码在“Rm”字段中。
<extend> 是索引扩展/移位说明符，默认为 LSL，当省略 <amount> 时，LSL 选项必须省略。 在“option”中编码：
| option | <extend> |
|---|---|
| 010 | UXTW |
| 011 | LSL |
| 110 | SXTW |
| 111 | SXTX |
<amount> 索引移位量，仅当<extend>不是 LSL 时可选。在允许可选的地方，它默认为#0。 它以“S”编码：
| S | <amount> |
|---|---|
| 0 | #0 |
| 1 | #1 |
下面是使用 LDRSH（寄存器）指令的例子。
long long int len = 3;long int x = 0;auto *y_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){y_arr[i] = 0x0102030410205030 * (i + 1);LOGD("y_arr[%d]=0x%llx", i, y_arr[i]);}char* y = (char*)y_arr;asm volatile("MOV X3, #16\n""LDRSH %w[x], [%x[y] ,X3, LSL#0]\n":[x] "+r"(x),[y] "+r"(y):: "cc", "memory");LOGD("-----------------------------");LOGD("x=0x%lx", x);delete[] y_arr;
注意看 LDRH（寄存器）指令的对符号位的处理方式，此处扩展了符号位。运行结果如下：
2023-04-18 08:07:02.317 21812-21904/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++
2023-04-18 08:07:02.317 21812-21904/com.demo.myapplication D/NativeCore: y_arr[0]=0x102030410205030
2023-04-18 08:07:02.317 21812-21904/com.demo.myapplication D/NativeCore: y_arr[1]=0x20406082040a060
2023-04-18 08:07:02.317 21812-21904/com.demo.myapplication D/NativeCore: y_arr[2]=0x306090c3060f090
2023-04-18 08:07:02.317 21812-21904/com.demo.myapplication D/NativeCore: -----------------------------
2023-04-18 08:07:02.317 21812-21904/com.demo.myapplication D/NativeCore: x=0xfffff090
12 LDRSW（立即数）
加载寄存器有符号字（立即数）指令从内存中加载一个字，将其符号扩展为 64 位，并将结果写入寄存器。用于加载的地址是根据基址寄存器和立即偏移量计算得出的。
Post-index
LDRSW <Xt>, [<Xn|SP>], #<simm>
Pre-index
LDRSW <Xt>, [<Xn|SP>, #<simm>]!
Unsigned offset
LDRSW <Xt>, [<Xn|SP>{, #<pimm>}]
<Xt> 是要传输的通用寄存器的 64 位名称，在“Rt”字段中编码。
<Xn|SP> 是通用基址寄存器或堆栈指针的 64 位名称，在“Rn”字段中编码。
<simm> 是带符号的立即字节偏移量，在 -256 到 255 的范围内，在“imm9”字段中编码。
<pimm> 是可选的正立即字节偏移量，是 0 到 16380 范围内的 4 的倍数，默认为 0 并在“imm12”字段中编码为 <pimm>/4。
LDRSW（立即数）Post-index
下面是使用 LDRSW（立即数）Post-index 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0102030410203050 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""1:\n""LDRSW X2, [%x[src]], #8\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
运行结果如下：
2023-04-19 07:54:08.461 3256-3487/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++
2023-04-19 07:54:08.461 3256-3487/com.demo.myapplication D/NativeCore: src_arr[0]=0x102030410203050
2023-04-19 07:54:08.461 3256-3487/com.demo.myapplication D/NativeCore: src_arr[1]=0x2040608204060a0
2023-04-19 07:54:08.461 3256-3487/com.demo.myapplication D/NativeCore: src_arr[2]=0x306090c306090f0
2023-04-19 07:54:08.461 3256-3487/com.demo.myapplication D/NativeCore: =============================
2023-04-19 07:54:08.461 3256-3487/com.demo.myapplication D/NativeCore: dst_arr[0]=0x0
2023-04-19 07:54:08.461 3256-3487/com.demo.myapplication D/NativeCore: dst_arr[1]=0x0
2023-04-19 07:54:08.461 3256-3487/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
2023-04-19 07:54:08.461 3256-3487/com.demo.myapplication D/NativeCore: -----------------------------
2023-04-19 07:54:08.461 3256-3487/com.demo.myapplication D/NativeCore: dst_arr[0]=0x10203050
2023-04-19 07:54:08.461 3256-3487/com.demo.myapplication D/NativeCore: dst_arr[1]=0x204060a0
2023-04-19 07:54:08.461 3256-3487/com.demo.myapplication D/NativeCore: dst_arr[2]=0x306090f0
LDRSW（立即数）Pre-index
下面是使用 LDRSW（立即数）Pre-index 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x0102030450203050 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""SUB X3, X3, #1\n""1:\n""LDRSW X2, [%x[src], #8]!\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
运行结果如下：
2023-04-19 07:55:54.196 5861-5962/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++
2023-04-19 07:55:54.196 5861-5962/com.demo.myapplication D/NativeCore: src_arr[0]=0x102030450203050
2023-04-19 07:55:54.196 5861-5962/com.demo.myapplication D/NativeCore: src_arr[1]=0x2040608a04060a0
2023-04-19 07:55:54.196 5861-5962/com.demo.myapplication D/NativeCore: src_arr[2]=0x306090cf06090f0
2023-04-19 07:55:54.196 5861-5962/com.demo.myapplication D/NativeCore: =============================
2023-04-19 07:55:54.196 5861-5962/com.demo.myapplication D/NativeCore: dst_arr[0]=0x0
2023-04-19 07:55:54.196 5861-5962/com.demo.myapplication D/NativeCore: dst_arr[1]=0x0
2023-04-19 07:55:54.196 5861-5962/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
2023-04-19 07:55:54.196 5861-5962/com.demo.myapplication D/NativeCore: -----------------------------
2023-04-19 07:55:54.196 5861-5962/com.demo.myapplication D/NativeCore: dst_arr[0]=0xffffffffa04060a0
2023-04-19 07:55:54.196 5861-5962/com.demo.myapplication D/NativeCore: dst_arr[1]=0xfffffffff06090f0
2023-04-19 07:55:54.196 5861-5962/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
LDRSW（立即数）Unsigned offset
下面是使用 LDRSW（立即数）Unsigned offset 指令的例子。
long long int len = 3;auto *src_arr = new long long int[len]{0};auto *dst_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){src_arr[i] = 0x8102030410203050 * (i + 1);LOGD("src_arr[%d]=0x%llx", i, src_arr[i]);}LOGD("=============================");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}char *src = (char *) src_arr;char *dst = (char *) dst_arr;asm volatile("MOV X3, %x[len]\n""1:\n""LDRSW X2, [%x[src], #6]\n""STR X2, [%x[dst]], #8\n""SUBS X3, X3, #1\n""B.GT 1b\n":[len] "+r"(len),[src] "+r"(src),[dst] "+r"(dst):: "cc", "memory");LOGD("-----------------------------");for(int i = 0; i < len; i++){LOGD("dst_arr[%d]=0x%llx", i, dst_arr[i]);}delete[] src_arr;delete[] dst_arr;
运行结果如下：
2023-04-19 07:58:02.543 7440-7531/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++
2023-04-19 07:58:02.543 7440-7531/com.demo.myapplication D/NativeCore: src_arr[0]=0x8102030410203050
2023-04-19 07:58:02.543 7440-7531/com.demo.myapplication D/NativeCore: src_arr[1]=0x2040608204060a0
2023-04-19 07:58:02.543 7440-7531/com.demo.myapplication D/NativeCore: src_arr[2]=0x8306090c306090f0
2023-04-19 07:58:02.543 7440-7531/com.demo.myapplication D/NativeCore: =============================
2023-04-19 07:58:02.543 7440-7531/com.demo.myapplication D/NativeCore: dst_arr[0]=0x0
2023-04-19 07:58:02.543 7440-7531/com.demo.myapplication D/NativeCore: dst_arr[1]=0x0
2023-04-19 07:58:02.543 7440-7531/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
2023-04-19 07:58:02.543 7440-7531/com.demo.myapplication D/NativeCore: -----------------------------
2023-04-19 07:58:02.543 7440-7531/com.demo.myapplication D/NativeCore: dst_arr[0]=0x60a08102
2023-04-19 07:58:02.543 7440-7531/com.demo.myapplication D/NativeCore: dst_arr[1]=0x60a08102
2023-04-19 07:58:02.543 7440-7531/com.demo.myapplication D/NativeCore: dst_arr[2]=0x60a08102
13 LDRSW(literal)
加载寄存器有符号字（文字）指令根据 PC 值和立即偏移量计算地址，从内存加载一个字，并将其写入寄存器。
LDRSW <Xt>, <label>
<Xt> 是要加载的通用寄存器的 64 位名称，在“Rt”字段中编码。
<label> 是要从中加载数据的程序标签。它与该指令地址的偏移量在 +/-1MB 范围内，编码为“imm19”乘以 4。
下面是使用 LDRSW(literal) 指令的例子。
long long int x = 0;asm volatile("LDRSW X2, abc\n""MOV %x[x], X2\n""abc:\n""MOV X2, #0\n""MOV X2, #1\n""MOV X2, #2\n":[x] "+r"(x):: "cc", "memory");
执行 LDRSW X2, abc 将 abc 标签根据 PC 值和立即偏移量计算地址，将这个地址的内容加载到寄存器。此时 x 的值打印出来它固定为 0xffffffffd2800002，高半部分的字全部被填充为了 1（这是因为 0xd2800002 符号位扩展了），0xd2800002 实际就是 MOV X2, #0 这条指令，所以这个地址的内容仅包含一条指令，而 LDR(literal) 包含了两条指令。使用 IDA 反汇编工具可看到 MOV X2, #1 和 MOV X2, #2 的确没有编码到这个地址指向的内容中。
14 LDRSW（寄存器）
加载寄存器有符号字（寄存器）指令根据基址寄存器值和偏移寄存器值计算地址，从内存中加载一个字，对其进行符号扩展以形成 64 位值，并将其写入寄存器。偏移寄存器值可以左移 0 或 2 位。
LDRSW <Xt>, [<Xn|SP>, (<Wm>|<Xm>){, <extend> {<amount>}}]
<Xt> 是要传输的通用寄存器的 64 位名称，在“Rt”字段中编码。
<Xn|SP> 是通用基址寄存器或堆栈指针的 64 位名称，在“Rn”字段中编码。
<Wm> 当 option<0> 设置为 0 时，是通用索引寄存器的 32 位名称，编码在“Rm”字段中。
<Xm> 当 option<0> 设置为 1 时，是通用索引寄存器的 64 位名称，编码在“Rm”字段中。
<extend> 是索引扩展/移位说明符，默认为 LSL，当省略 <amount> 时，LSL 选项必须省略。在“option”中编码：
| option | <extend> |
|---|---|
| 010 | UXTW |
| 011 | LSL |
| 110 | SXTW |
| 111 | SXTX |
<amount> 索引移位量，仅当 <extend> 不是 LSL 时可选。在允许可选的地方，它默认为#0。 它以“S”编码：
| S | <amount> |
|---|---|
| 0 | #0 |
| 1 | #2 |
下面是使用 LDRSW（寄存器）指令的例子。
long long int len = 3;long long int x = 0;auto *y_arr = new long long int[len]{0};LOGD("+++++++++++++++++++++++++++++");for(int i = 0; i < len; i++){y_arr[i] = 0x0102030450205030 * (i + 1);LOGD("y_arr[%d]=0x%llx", i, y_arr[i]);}char* y = (char*)y_arr;asm volatile("MOV X3, #4\n""LDRSW %x[x], [%x[y] ,X3, LSL#2]\n":[x] "+r"(x),[y] "+r"(y):: "cc", "memory");LOGD("-----------------------------");LOGD("x=0x%llx", x);delete[] y_arr;
LDRSW %x[x], [%x[y] ,X3, LSL#2] 首先将索引寄存器的值逻辑左移 2 位，也就是将 X3 寄存器的值乘以 4，即索引最终的值为 4 * 4 = 16，接着使用索引的值去加载数组中的一个字，也就是 0xF060F090，扩展符号位后就变为了 0xFFFFFFFFF060F090，这也是最终 x 的值。运行结果如下：
2023-04-19 08:34:42.228 27863-27920/com.demo.myapplication D/NativeCore: +++++++++++++++++++++++++++++
2023-04-19 08:34:42.228 27863-27920/com.demo.myapplication D/NativeCore: y_arr[0]=0x102030450205030
2023-04-19 08:34:42.228 27863-27920/com.demo.myapplication D/NativeCore: y_arr[1]=0x2040608a040a060
2023-04-19 08:34:42.228 27863-27920/com.demo.myapplication D/NativeCore: y_arr[2]=0x306090cf060f090
2023-04-19 08:34:42.228 27863-27920/com.demo.myapplication D/NativeCore: -----------------------------
2023-04-19 08:34:42.228 27863-27920/com.demo.myapplication D/NativeCore: x=0xfffffffff060f090
参考资料
1.《ARMv8-A-Programmer-Guide》
2.《Arm® A64 Instruction Set Architecture Armv8, for Armv8-A architecture profile》
【ARMv8 编程】A64 内存访问指令——内存加载指令相关推荐
- 【Android 逆向】x86 汇编 ( call 子函数调用指令 | jmp 跳转指令 | lea 加载指令 | mov 数据传送指令 )
文章目录 一.call 子函数调用指令 二.jmp 跳转指令 三.lea 加载指令 四.mov 数据传送指令 总结 一.call 子函数调用指令 call 指令是 子函数调用指令 , 调用的指令的下一 ...
- ios 图片加载内存尺寸_iOS内存分析上-图片加载内存分析
简介 对于大多数App来说,内存占用主要就是图片.本文将从实用的角度分析,iOS图片的内存占用.测量.优化等. iOS内存-有什么影响 在移动操作系统设备中,是不能像PC一样进行内存swap的,而随着 ...
- ldr加载指令，ldr伪指令
转载于http://www.cnblogs.com/hnrainll/archive/2011/06/14/2080241.html 一.ldr作为加载指令 (1)格式为:LDR{条件} 目的寄存器 ...
- jq异步实现ajax,用jQuery的AJax实现异步访问、异步加载
本篇文章实现了用jQuery的AJax实现异步访问和异步加载,具有一定的参考价值,感兴趣的小伙伴们可以参考一下. [异步访问] 用一个例子用以说明:点击按钮,将input内用户输入的数据发送给服务端, ...
- ARM中LDR伪指令与LDR加载指令
ARM指令集中,LDR通常都是作加载指令的,但是它也可以作伪指令. LDR伪指令的形式是"LDR Rn,=expr".下面举一个例子来说明它的用法. COUNT EQU ...
- JS判断访问设备(userAgent)加载不同页面 JS判断客户端操作系统类型(platform)
//平台.设备和操作系统var system ={win : false,mac : false,xll : false};//检测平台var p = navigator.platform;syste ...
- 新手必看：访问url到加载全过程详解（看完不会我吃shi）
新手必看:访问url到加载全过程详解(看完不会我吃shi) 1.放在前面:新手必须知道的那些概念 1.1 什么是IP.域名.主机名.url.服务器 1.2 http & https 1.3 O ...
- 记录--Vue自定义指令实现加载中效果v-load（不使用Vue.extend）
这里给大家分享我在网上总结出来的一些知识,希望对大家有所帮助 网站效果演示:ashuai.work:8888/#/myLoad GitHub仓库地址代码:github.com/shuirongshu- ...
- vue自定义指令---处理加载图片失败时出现的碎图,onerror事件
目录 一.自定义指令 1.局部注册和使用 2.全局注册和使用 二.自定义指令处理图片加载失败(碎图) 一.自定义指令 vue中除v-model.v-show等内置指令之外,还允许注册自定义指令,获取D ...
最新文章
- 为什么“ cd”在shell脚本中不起作用？
- RSA加密解密及数字签名Java实现--转
- 5.2 计算机网络之传输层UDP协议
- 多线程编程1 - NSThread
- C++学习之路 | PTA乙级—— 1015 德才论 (25分)（精简）
- 鼠标移入时闪闪发光的效果
- 零门槛！ZBLibrary仿微信朋友圈自定义View，就是这么简单！
- Django安装与开发虚拟环境搭建01
- 第九次作业(杨辉三角)
- 蚂蚁金服总监杨冰：金融科技公司为什么要拥抱开源？ | 穿山甲专访
- X 1 BT5kali
- 百度下拉框|百度下拉联想词|百度搜索框优化|百度下拉
- Android更换皮肤解决方案，2021年哔哩哔哩Android高级面试题及答案
- inl和dnl matlab_AD的一些指标——INL与DNL
- 视频转换格式 qlv 转 mp4 详解
- 案例 | 巴别鸟为弘睿构建企业知识库
- 在线任务管理服务大汇总
- 书评《半小时漫画中国史》
- 【Python】利用python进行数据分析——以新型冠状病毒疫情为例
- SaaSBase：什么是INFOR ERP？