1. Toy模板网首页
  2. > Toy博客

【ARMv8 编程】A64 内存访问指令——内存加载指令

10月前 作者：TYYJ-洪伟 分类：Toy博客 阅读(39) 违法举报

这篇具有很好参考价值的文章主要介绍了【ARMv8 编程】A64 内存访问指令——内存加载指令。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

与所有先前的 ARM 处理器一样，ARMv8 架构是一种加载/存储架构。这意味着没有数据处理指令直接对内存中的数据进行操作。数据必须首先被加载到寄存器中，修改，然后存储到内存中。该程序必须指定地址、要传输的数据大小以及源或目标寄存器。有额外的加载和存储指令提供更多选项，例如非临时加载/存储、加载/存储独占和获取/释放。

Load 指令的一般形式如下：

LDR Rt, <addr>

对于加载到整数寄存器中的指令，可以选择要加载的大小。例如，要加载小于指定寄存器值的大小，请将以下后缀之一附加到 LDR 指令：

  • LDRB（8 位，零扩展）
  • LDRSB（8 位，符号扩展）
  • LDRH（16 位，零扩展）
  • LDRSH（16 位，符号扩展）
  • LDRSW（32 位，符号扩展）

下面是 LDRSB 和 LDRB 加载示例图：

【ARMv8 编程】A64 内存访问指令——内存加载指令

还有 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

【ARMv8 编程】A64 内存访问指令——内存加载指令

32-bit (size = 10)

LDR <Wt>, [<Xn|SP>], #<simm>

64-bit (size = 11)

LDR <Xt>, [<Xn|SP>], #<simm>

Pre-index

【ARMv8 编程】A64 内存访问指令——内存加载指令

32-bit (size = 10)

LDR <Wt>, [<Xn|SP>, #<simm>]!

64-bit (size = 11)

LDR <Xt>, [<Xn|SP>, #<simm>]!

Unsigned offset

【ARMv8 编程】A64 内存访问指令——内存加载指令

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 的例子。

  1. 新建 src_arr、dst_arr 数组，并初始化为 0。
  2. 给 src_arr 赋初值，将 long long int* 指针转为 char*，为了后续内联汇编加载（笔者环境实测：如果不这样赋值 STR 指令无法正常写入内存）。
  3. 经过内联汇编代码运行，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 处继续执行。
  4. 继续打印一次 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]=0x0
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[1]=0x101010101010101
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[2]=0x202020202020202
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[3]=0x303030303030303
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[4]=0x404040404040404
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[5]=0x505050505050505
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[6]=0x606060606060606
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[7]=0x707070707070707
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[8]=0x808080808080808
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: src_arr[9]=0x909090909090909
    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: dst_arr[0]=0x0
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[1]=0x0
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[3]=0x0
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[4]=0x0
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[5]=0x0
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[6]=0x0
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[7]=0x0
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[8]=0x0
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[9]=0x0
    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: dst_arr[0]=0x0
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[1]=0x101010101010101
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[2]=0x202020202020202
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[3]=0x303030303030303
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[4]=0x404040404040404
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[5]=0x505050505050505
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[6]=0x606060606060606
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[7]=0x707070707070707
    2023-04-13 18:46:34.838 11692-11801/com.demo.myapplication D/NativeCore: dst_arr[8]=0x808080808080808
    2023-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]=0x0
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[1]=0x101010101010101
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[2]=0x202020202020202
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[3]=0x303030303030303
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[4]=0x404040404040404
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[5]=0x505050505050505
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[6]=0x606060606060606
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[7]=0x707070707070707
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[8]=0x808080808080808
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: src_arr[9]=0x909090909090909
    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: dst_arr[0]=0x0
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[1]=0x0
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[3]=0x0
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[4]=0x0
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[5]=0x0
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[6]=0x0
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[7]=0x0
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[8]=0x0
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[9]=0x0
    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: dst_arr[0]=0x101010101010101
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[1]=0x202020202020202
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[2]=0x303030303030303
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[3]=0x404040404040404
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[4]=0x505050505050505
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[5]=0x606060606060606
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[6]=0x707070707070707
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[7]=0x808080808080808
    2023-04-13 19:22:58.314 19791-19862/com.demo.myapplication D/NativeCore: dst_arr[8]=0x909090909090909
    2023-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]=0x0
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[1]=0x101010101010101
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[2]=0x202020202020202
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[3]=0x303030303030303
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[4]=0x404040404040404
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[5]=0x505050505050505
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[6]=0x606060606060606
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[7]=0x707070707070707
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[8]=0x808080808080808
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: src_arr[9]=0x909090909090909
    2023-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]=0x0
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[1]=0x0
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[2]=0x0
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[3]=0x0
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[4]=0x0
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[5]=0x0
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[6]=0x0
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[7]=0x0
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[8]=0x0
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[9]=0x0
    2023-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]=0x101010101010101
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[1]=0x101010101010101
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[2]=0x101010101010101
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[3]=0x101010101010101
    2023-04-14 08:05:08.060 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[4]=0x101010101010101
    2023-04-14 08:05:08.061 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[5]=0x101010101010101
    2023-04-14 08:05:08.061 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[6]=0x101010101010101
    2023-04-14 08:05:08.061 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[7]=0x101010101010101
    2023-04-14 08:05:08.061 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[8]=0x101010101010101
    2023-04-14 08:05:08.061 7157-7305/com.demo.myapplication D/NativeCore: dst_arr[9]=0x101010101010101

2 LDR(literal)

LDR（文字）指令根据 PC 值和立即偏移量计算地址，从内存加载一个字，并将其写入寄存器。

【ARMv8 编程】A64 内存访问指令——内存加载指令

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 工具反编译一下这段代码：

【ARMv8 编程】A64 内存访问指令——内存加载指令

我们可以清晰看到 MOV X2, #2 这条指令，却看不到它上面的另外两条 MOV (wide immediate) 指令，因为它们编码在 0xd2800022d2800002 内了。 并且 LDR X2, abc 替换成了 LDR X2, =0xD2800022D2800002，这和我们的运行结果完全一致。

3 LDR（寄存器）

LDR（寄存器）指令根据基址寄存器值和偏移寄存器值计算地址，从内存中加载一个字，并将其写入寄存器。偏移寄存器值可以选择性地移位和扩展。

【ARMv8 编程】A64 内存访问指令——内存加载指令

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]=0x102030410203040
    2023-04-15 21:14:22.007 20790-20790/com.example.myapplication D/native-armv8a: y_arr[1]=0x204060820406080
    2023-04-15 21:14:22.007 20790-20790/com.example.myapplication D/native-armv8a: y_arr[2]=0x306090c306090c0
    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: 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

【ARMv8 编程】A64 内存访问指令——内存加载指令

LDRB <Wt>, [<Xn|SP>], #<simm>

Pre-index

【ARMv8 编程】A64 内存访问指令——内存加载指令

LDRB <Wt>, [<Xn|SP>, #<simm>]!

Unsigned offset

【ARMv8 编程】A64 内存访问指令——内存加载指令

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]=0x102030410203040
    2023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: src_arr[1]=0x204060820406080
    2023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: src_arr[2]=0x306090c306090c0
    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: dst_arr[0]=0x0
    2023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: dst_arr[1]=0x0
    2023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: dst_arr[2]=0x0
    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: dst_arr[0]=0x40
    2023-04-16 15:26:19.658 14573-14573/com.example.myapplication D/native-armv8a: dst_arr[1]=0x80
    2023-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]=0x102030410203040
    2023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: src_arr[1]=0x204060820406080
    2023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: src_arr[2]=0x306090c306090c0
    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: dst_arr[0]=0x0
    2023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: dst_arr[1]=0x0
    2023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: dst_arr[2]=0x0
    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: dst_arr[0]=0x80
    2023-04-16 15:37:29.915 19872-19872/com.example.myapplication D/native-armv8a: dst_arr[1]=0xc0
    2023-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]=0x102030410203040
    2023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: src_arr[1]=0x204060820406080
    2023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: src_arr[2]=0x306090c306090c0
    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: dst_arr[0]=0x0
    2023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: dst_arr[1]=0x0
    2023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: dst_arr[2]=0x0
    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: dst_arr[0]=0x2
    2023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: dst_arr[1]=0x2
    2023-04-16 15:43:05.327 24289-24289/com.example.myapplication D/native-armv8a: dst_arr[2]=0x2

5 LDRB（寄存器）

加载寄存器字节（寄存器）指令根据基址寄存器值和偏移寄存器值计算地址，从内存中加载一个字节，对其进行零扩展，并将其写入寄存器。

【ARMv8 编程】A64 内存访问指令——内存加载指令

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]=0x102030410203050
    2023-04-16 16:07:58.615 20132-20132/com.example.myapplication D/native-armv8a: y_arr[1]=0x2040608204060a0
    2023-04-16 16:07:58.615 20132-20132/com.example.myapplication D/native-armv8a: y_arr[2]=0x306090c306090f0
    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: 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

【ARMv8 编程】A64 内存访问指令——内存加载指令

32-bit (opc = 11)

LDRSB <Wt>, [<Xn|SP>], #<simm>

64-bit (opc = 10)

LDRSB <Xt>, [<Xn|SP>], #<simm>

Pre-index

【ARMv8 编程】A64 内存访问指令——内存加载指令

32-bit (opc = 11)

LDRSB <Wt>, [<Xn|SP>, #<simm>]!

64-bit (opc = 10)

LDRSB <Xt>, [<Xn|SP>, #<simm>]!

Unsigned offset

【ARMv8 编程】A64 内存访问指令——内存加载指令

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]=0x102030410203050
    2023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: src_arr[1]=0x2040608204060a0
    2023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: src_arr[2]=0x306090c306090f0
    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: dst_arr[0]=0x0
    2023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: dst_arr[1]=0x0
    2023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: dst_arr[2]=0x0
    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: dst_arr[0]=0x50
    2023-04-16 20:39:09.486 7564-7564/com.example.myapplication D/native-armv8a: dst_arr[1]=0xffffffffffffffa0
    2023-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]=0x0

LDRSB（立即数）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]=0x102030410203050
    2023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: src_arr[1]=0x2040608204060a0
    2023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: src_arr[2]=0x306090c306090f0
    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: dst_arr[0]=0x0
    2023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: dst_arr[1]=0x0
    2023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: dst_arr[2]=0x0
    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: dst_arr[0]=0x2
    2023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: dst_arr[1]=0x2
    2023-04-16 20:48:49.703 13214-13214/com.example.myapplication D/native-armv8a: dst_arr[2]=0x2

7 LDRSB（寄存器）

加载寄存器有符号字（寄存器）指令根据基址寄存器值和偏移寄存器值计算地址，从内存中加载一个字节，对其进行符号扩展，并将其写入寄存器。

【ARMv8 编程】A64 内存访问指令——内存加载指令

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

【ARMv8 编程】A64 内存访问指令——内存加载指令

LDRH <Wt>, [<Xn|SP>], #<simm>

Pre-index

【ARMv8 编程】A64 内存访问指令——内存加载指令

LDRH <Wt>, [<Xn|SP>, #<simm>]!

Unsigned offset

【ARMv8 编程】A64 内存访问指令——内存加载指令

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（寄存器）

加载寄存器半字（寄存器）指令根据基址寄存器值和偏移寄存器值计算地址，从内存中加载一个半字，对其进行零扩展，并将其写入寄存器。

【ARMv8 编程】A64 内存访问指令——内存加载指令

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

【ARMv8 编程】A64 内存访问指令——内存加载指令

32-bit (opc == 11)

LDRSH <Wt>, [<Xn|SP>], #<simm>

64-bit (opc == 10)

LDRSH <Xt>, [<Xn|SP>], #<simm>

Pre-index

【ARMv8 编程】A64 内存访问指令——内存加载指令

32-bit (opc == 11)

LDRSH <Wt>, [<Xn|SP>, #<simm>]!

64-bit (opc == 10)

LDRSH <Xt>, [<Xn|SP>, #<simm>]!

Unsigned offset

【ARMv8 编程】A64 内存访问指令——内存加载指令

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（寄存器）

加载寄存器带符号半字（寄存器）指令根据基址寄存器值和偏移寄存器值计算地址，从内存加载半字，对其进行符号扩展，并将其写入寄存器。

【ARMv8 编程】A64 内存访问指令——内存加载指令

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

【ARMv8 编程】A64 内存访问指令——内存加载指令

LDRSW <Xt>, [<Xn|SP>], #<simm>

Pre-index

【ARMv8 编程】A64 内存访问指令——内存加载指令

LDRSW <Xt>, [<Xn|SP>, #<simm>]!

Unsigned offset

【ARMv8 编程】A64 内存访问指令——内存加载指令

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 值和立即偏移量计算地址，从内存加载一个字，并将其写入寄存器。

【ARMv8 编程】A64 内存访问指令——内存加载指令

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 位。

【ARMv8 编程】A64 内存访问指令——内存加载指令

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》文章来源地址https://www.toymoban.com/news/detail-432385.html

到了这里，关于【ARMv8 编程】A64 内存访问指令——内存加载指令的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【ARMv8 SIMD和浮点指令编程】浮点加减乘除指令——四则运算

    【ARMv8 SIMD和浮点指令编程】浮点加减乘除指令——四则运算

    浮点指令有专门的加减乘除四则运算指令，比如 FADD、FSUB、FMUL、FDIV 等。 1 FADD (scalar) 浮点加法（标量）。该指令将两个源 SIMDFP 寄存器的浮点值相加，并将结果写入目标 SIMDFP 寄存器。 该指令可以产生浮点异常。根据 FPCR 中的设置，异常会导致在 FPSR 中设置标志，或者生成同

    2024年02月05日
    浏览(52)

  • 【ARMv8 SIMD和浮点指令编程】浮点数据转换指令——数据类型互转必备

    浮点数据转换指令包括不同的浮点精度数之间的转换，还包括整型和浮点数之间的转化。 在了解数据转换指令前，必须学习 IEEE 754 定义的五种舍入规则。前两条规则舍入到最接近的值，其他的称为定向舍入： 舍入到最接近的值 Round to nearest, ties to even – rounds to the nearest va

    2024年02月02日
    浏览(55)
  • 【ARMv8 SIMD和浮点指令编程】NEON 通用数据处理指令——复制、反转、提取、转置...

    【ARMv8 SIMD和浮点指令编程】NEON 通用数据处理指令——复制、反转、提取、转置...

    NEON 通用数据处理指令包括以下指令（不限于）： • DUP 将标量复制到向量的所有向量线。 • EXT 提取。 • REV16、REV32、REV64 反转向量中的元素。 • TBL、TBX 向量表查找。 • TRN 向量转置。 • UZP、ZIP 向量交叉存取和反向交叉存取。 1 DUP (element) 将向量元素复制为向量或标量。

    2024年02月07日
    浏览(42)
  • ARMv8 汇编指令

    ARMv8 汇编指令

    MOV Xd|SP, Xn|SP MOV Xd|SP, #imm16 常用于寄存器之间的搬移和立即数搬移，   仅仅支持imm16， 0-4096大小范围的立即数操作 MRS: 状态寄存器 -- 通用寄存器的传送指令。 MSR: 通用寄存器 -- 状态寄存器的传送指令。 注意：在ARMv7里通过CP15协处理器方位系统寄存器 还可以访问PSTATE寄存器一

    2024年04月27日
    浏览(42)
  • ARMv8-A 与异常相关的指令

    ARMv8-A 与异常相关的指令

    最近一直在学习 ARMv8-A 的东西，记录一下与异常相关的指令。下面的内容基于AArch64讨论，暂不考虑 AArch32。 与异常生成相关的指令如下所示。下面主要学习 SVC 和 HVC 。 1. SVC SVC (Supervisor Call) 产生一个路由到 EL1 的异常，可以调用系统服务这些。此时， ESR_ELx.EC = 0x15 。 2. HVC

    2024年02月21日
    浏览(48)
  • 树莓派4b(armv8) 64位系统编译安装onnx

    树莓派4b(armv8) 64位系统编译安装onnx

    网上大部分树莓派安装onnx的都是基于树莓派3b的，或者说基于armv7架构的。 本文记录一下如何在最新的树莓派4b系统（armv8、python3.9）上编译安装onnx的过程。 获取当前系统的内核版本号及系统名称 获取当前系统的内核版本及系统名称 可以看到我的cpu版本是armv8 如果是armv7架构

    2024年02月05日
    浏览(193)
  • 交叉编译----宿主机x86 ubuntu 64位-目标机ARMv8 aarch64

    交叉编译----宿主机x86 ubuntu 64位-目标机ARMv8 aarch64

    1.交叉编译是什么，为什么要交叉编译 编译：在一个平台上生成在该平台上的可执行代码 交叉编译：在一个平台上生成在另一个平台上的可执行代码 交叉编译的例子：如51单片机的可执行代码（hex文件）是在集成环境keil上面编译完成的，我们只需要将编译好的可执行代码下

    2024年02月15日
    浏览(46)
  • Yocto系列讲解[技巧篇]92 - armv8 aarch64兼容armv7 32位程序运行环境

    Yocto系列讲解[技巧篇]92 - armv8 aarch64兼容armv7 32位程序运行环境

    By: fulinux E-mail: fulinux@sina.com Blog: https://blog.csdn.net/fulinus 喜欢的盆友欢迎点赞和订阅！ 你的喜欢就是我写作的动力！

    2024年01月24日
    浏览(61)

  • 【ARM Cortex-M 系列 3 番外篇 -- ARMv6, ARMv7, ARMv8, ARMv9 架构差异及精简指令集 与 复杂指令集 介绍】

    上篇文章：ARM Cortex-M 系列 2.1 – RT-Thread Cortex-M7 异常处理及 hardfault 处理分析 ARM架构是一种处理器架构，全称为高级精简指令集计算机（Advanced RISC Machine）。它是英国ARM公司设计的一种精简指令集（ RISC ）处理器架构，和复杂指令集（ CISC ）处理器架构相对。 CISC 与 RISC 差异

    2024年02月08日
    浏览(47)
  • ARMv8的异常等级（Exception Level）以及执行状态（AArch64/AArch32）

    ARMv8的异常等级（Exception Level）以及执行状态（AArch64/AArch32）

    目录 1，异常等级（Exception Level） 2，Execution states，执行状态 AArch64的异常等级 AArch32的异常等级： 3，异常等级切换  4，执行状态切换（AArch64 = AArch32） 5，状态切换后的寄存器状态 Registers at AArch32 PSTATE at AArch32 6，指令集的切换：Switching between the instruction sets 在ARMv8中，存在

    2024年02月13日
    浏览(55)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包