【ARMv8 编程】A64 数据处理指令——逻辑&移位指令

最新推荐文章于 2024-11-28 19:11:37 发布
最新推荐文章于 2024-11-28 19:11:37 发布
阅读量3.1k 收藏 2
点赞数 1
CC 4.0 BY-SA版权
分类专栏： ARMv8 文章标签： armv8 A64 逻辑 移位 汇编
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tyyj90/article/details/129911571
本文详细介绍了ARMv8-A架构中的逻辑指令，包括AND、BIC、ORR、ORN、EOR和EON，以及移位指令ASR、LSL、LSR和ROR的操作和用法，通过实例展示了这些指令如何对寄存器中的位进行操作和移位计算。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

逻辑指令包括与、或等指令，移位指令则分为逻辑移位和算术移位指令，下面则详细展开学习。

指令类型指令
逻辑AND、BIC、ORR、ORN、EOR、EON
移位ASR、LSL、LSR、ROR

逻辑运算本质上与对寄存器的各个位进行运算的相应布尔运算符相同。

• 逻辑左移(LSL)。 LSL 指令执行乘以 2 的幂。

• 逻辑右移(LSR)。 LSR 指令执行除以 2 的幂。

• 算术右移(ASR)。 ASR 指令执行除以 2 的幂，保留符号位。

• 循环右移(ROR)。 ROR 指令执行按位循环，将循环后的位从 LSB 移动到 MSB。

一、逻辑指令

1.1 AND

AND（立即数）

按位与（立即数）指令执行寄存器值和立即数的按位与，并将结果写入目标寄存器。

在这里插入图片描述

32-bit (sf == 0 && N == 0)

AND <Wd|WSP>, <Wn>, #<imm>

64-bit (sf == 1)

AND <Xd|SP>, <Xn>, #<imm>

<Wd|WSP> 是目标通用寄存器或堆栈指针的 32 位名称，编码在“Rd”字段中。

<Wn> 是通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Xd|SP> 是目标通用寄存器或堆栈指针的 64 位名称，在“Rd”字段中编码。

<Xn> 是通用源寄存器的 64 位名称，在“Rn”字段中编码。

<imm> 对于 32 位变体：是位掩码立即数，编码为“imms:immr”；对于 64 位变体：是位掩码立即数，编码为“N:imms:immr”。

下面是使用 AND（立即数）指令的例子。

    long long int y = -1;
    long long int z = 100;

    asm volatile(
        "AND %x[z], %x[y], #4\n"
    :[y] "+r"(y),
    [z] "+r"(z)
    :
    : "cc", "memory");

AND %x[z], %x[y], #4 将 z & y 并只取后 4 位（掩码），也就是 0xFFFF FFFF FFFF FFFF & 0x64 = 0x64(0b0110 0100)，取后四位即 0b0100，也就是 4，所以 z 的值最终为 4。这里需要说明的一点是 -1 需要补码表示，存储在计算机内就是 64 位全为 1。

AND（移位寄存器）

按位与（移位寄存器）指令执行寄存器值和可选移位寄存器值的按位与，并将结果写入目标寄存器。

在这里插入图片描述

32-bit (sf == 0)

AND <Wd>, <Wn>, <Wm>{, <shift> #<amount>}

64-bit (sf == 1)

AND <Xd>, <Xn>, <Xm>{, <shift> #<amount>}

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Wn> 是第一个通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Wm> 是第二个通用源寄存器的 32 位名称，在“Rm”字段中编码。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xn> 是第一个通用源寄存器的 64 位名称，在“Rn”字段中编码。

<Xm> 是第二个通用源寄存器的 64 位名称，在“Rm”字段中编码。

<shift> 是应用于最终源的可选移位，默认为 LSL 并在“shift”字段中编码。 它可以具有以下值：

<shift>shift 字段取值
LSLshift = 00
LSRshift = 01
ASRshift = 10
RORshift = 11

<amount> 对于 32 位变体：是移位量，范围为 0 到 31，默认为 0 并在“imm6”字段中编码；对于 64 位变体：是移位量，在 0 到 63 范围内，默认为 0 并在“imm6”字段中编码。

下面是使用 AND（移位寄存器）指令的例子。

    long long int x = -1;
    long long int y = 4;
    long long int z = 0;

    asm volatile(
    "AND %x[z], %x[x], %x[y], LSL#4\n"
    :[x] "+r"(x),
     [y] "+r"(y),
     [z] "+r"(z)
    :
    : "cc", "memory");

AND %x[z], %x[x], %x[y], LSL#4 将 x & (y << 4) ，也就是 0xFFFF FFFF FFFF FFFF & (4 * (2^4)) = 64，所以 z 的值最终为 64。

1.2 BIC

按位清零（移位寄存器）：Rd = Rn AND NOT shift(Rm, amount)。

在这里插入图片描述

32-bit (sf = 0)

BIC <Wd>, <Wn>, <Wm>{, <shift> #<amount>}

64-bit (sf = 1)

BIC <Xd>, <Xn>, <Xm>{, <shift> #<amount>}

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Wn> 是第一个通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Wm> 是第二个通用源寄存器的 32 位名称，在“Rm”字段中编码。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xn> 是第一个通用源寄存器的 64 位名称，在“Rn”字段中编码。

<Xm> 是第二个通用源寄存器的 64 位名称，在“Rm”字段中编码。

<shift> 是要应用于最终源的可选移位，默认为 LSL 并在移位字段中编码：

<shift>shift 字段取值
LSLshift = 00
LSRshift = 01
ASRshift = 10
RORshift = 11

<amount> 对于 32 位变体：是移位量，范围为 0 到 31，默认为 0 并在“imm6”字段中编码；对于 64 位变体：是移位量，在 0 到 63 范围内，默认为 0 并在“imm6”字段中编码。

下面是使用 BIC 指令的例子。

    long long int x = 0b01101100;//108
    long long int y = 0b00110000;//48
    long long int z = 0;

    asm volatile(
        "BIC %x[z], %x[x], %x[y], LSL#1\n"
    :[x] "+r"(x),
    [y] "+r"(y),
    [z] "+r"(z)
    :
    : "cc", "memory");

BIC %x[z], %x[x], %x[y], LSL#1 执行 x & (~(y << 1)) = 0b01101100 & (~0b01100000) = 0b01101100 & 0b1…110011111 = 0b1100，也就是 12，所以 z 的最终结果为 12(0b1100)。0b1…110011111（共 64 位 1…1 之间省略了其他 1）。

BICS 唯一不同的一点是会设置条件标志。

1.3 ORR

ORR（立即数）

按位或（立即数）：Rd = Rn OR imm。

在这里插入图片描述

32-bit (sf = 0, N = 0)

ORR <Wd|WSP>, <Wn>, #<imm>

64-bit (sf = 1)

ORR <Xd|SP>, <Xn>, #<imm>

<Wd|WSP> 是目标通用寄存器或堆栈指针的 32 位名称，在“Rd”字段中编码。

<Wn> 是通用源寄存器的 32 位名称，在“Rn 字段中编码。

<Xd|SP> 是目标通用寄存器或堆栈指针的 64 位名称，在“Rd”字段中编码。

<Xn> 是通用源寄存器的 64 位名称，在“Rn”字段中编码。

<imm> 是位掩码立即数，编码为 N:imms:immr。

下面是使用 ORR（立即数）指令的例子。

    long long int x = 0b01101100;//108
    long long int z = 0;

    asm volatile(
        "ORR %x[z], %x[x], #0b1111\n"
    :[x] "+r"(x),
    [z] "+r"(z)
    :
    : "cc", "memory");

ORR %x[z], %x[x], L#0b1111 执行 x | 0b1111 = 0b01101100 | 0b1111 = 0b01101111，也就是 111，所以 z 的最终结果为 111。

ORR（移位寄存器）

按位或（移位寄存器）：Rd = Rn OR shift(Rm, amount)。

在这里插入图片描述

32-bit (sf = 0)

ORR <Wd>, <Wn>, <Wm>{, <shift> #<amount>}

64-bit (sf = 1)

ORR <Xd>, <Xn>, <Xm>{, <shift> #<amount>}

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Wn> 是第一个通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Wm> 是第二个通用源寄存器的 32 位名称，在“Rm”字段中编码。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xn> 是第一个通用源寄存器的 64 位名称，在“Rn”字段中编码。

<Xm> 是第二个通用源寄存器的 64 位名称，在“Rm”字段中编码。

<shift> 是要应用于最终源的可选移位，默认为 LSL 并在移位字段中编码：

<shift>shift 字段取值
LSLshift = 00
LSRshift = 01
ASRshift = 10
RORshift = 11

<amount> 对于 32 位变体：是移位量，范围为 0 到 31，默认为 0 并在“imm6”字段中编码；对于 64 位变体：是移位量，在 0 到 63 范围内，默认为 0 并在“imm6”字段中编码。

下面是使用 ORR（移位寄存器）指令的例子。

    long long int x = 0b01101100;//108
    long long int y = 0b00110000;//48
    long long int z = 0;

    asm volatile(
        "ORR %x[z], %x[x], %x[y], LSL#2\n"
    :[x] "+r"(x),
    [y] "+r"(y),
    [z] "+r"(z)
    :
    : "cc", "memory");

ORR %x[z], %x[x], %x[y], LSL#2 执行 x | (y << 2) = 0b01101100 | 0b11000000 = 0b11101100，也就是 236，所以 z 的最终结果为 236。

1.4 ORN

按位或非（移位寄存器）：Rd = Rn OR NOT shift(Rm, amount)。

在这里插入图片描述

32-bit (sf = 0)

ORN <Wd>, <Wn>, <Wm>{, <shift> #<amount>}

64-bit (sf = 1)

ORN <Xd>, <Xn>, <Xm>{, <shift> #<amount>}

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Wn> 是第一个通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Wm> 是第二个通用源寄存器的 32 位名称，在“Rm”字段中编码。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xn> 是第一个通用源寄存器的 64 位名称，在“Rn”字段中编码。

<Xm> 是第二个通用源寄存器的 64 位名称，在“Rm”字段中编码。

<shift> 是要应用于最终源的可选移位，默认为 LSL 并在移位字段中编码：

<shift>shift 字段取值
LSLshift = 00
LSRshift = 01
ASRshift = 10
RORshift = 11

<amount> 对于 32 位变体：是移位量，范围为 0 到 31，默认为 0 并在“imm6”字段中编码；对于 64 位变体：是移位量，在 0 到 63 范围内，默认为 0 并在“imm6”字段中编码。

下面是使用 ORN 指令的例子。

    long long int x = 0b01101100;//108
    long long int y = 0b00110000;//48
    long long int z = 0;

    asm volatile(
        "ORN %x[z], %x[x], %x[y], LSL#2\n"
    :[x] "+r"(x),
    [y] "+r"(y),
    [z] "+r"(z)
    :
    : "cc", "memory");

ORN %x[z], %x[x], %x[y], LSL#2 执行 x | (~(y << 2)) = 0b01101100 | (~(0b11000000)) = 0b01101100 | 0xFFFF FFFF FFFF FF3F = 0xFFFF FFFF FFFF FF7F，也就是 -129，所以 z 的最终结果为 -129。这里需要注意的一点是取反操作是将寄存器内的 64 位都做取反操作的！

1.5 EOR

EOR（立即数）

按位异或（立即数）：Rd = Rn EOR imm。

在这里插入图片描述

32-bit (sf = 0)

EOR <Wd|WSP>, <Wn>, #<imm>

64-bit (sf = 1)

EOR <Xd|SP>, <Xn>, #<imm>

<Wd|WSP> 是目标通用寄存器或堆栈指针的 32 位名称，在“Rd”字段中编码。

<Wn> 是通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Xd|SP> 是目标通用寄存器或堆栈指针的 64 位名称，在“Rd”字段中编码。

<Xn> 是通用源寄存器的 64 位名称，在“Rn”字段中编码。

<imm> 是位掩码立即数，编码为 N:imms:immr。

下面是使用 EOR（立即数）指令的例子。

    long long int x = 0b01101100;//108
    long long int z = 0;

    asm volatile(
        "EOR %x[z], %x[x], #0b01100000\n"
    :[x] "+r"(x),
    [z] "+r"(z)
    :
    : "cc", "memory");

EOR %x[z], %x[x], #0b01100000 执行 x 异或 0b01100000 = 0b01101100 异或 0b01100000 = 0b1100，也就是 12，所以 z 的最终结果为 12。

EOR（移位寄存器）

按位异或（移位寄存器）：Rd = Rn EOR shift(Rm, amount)。

在这里插入图片描述

32-bit (sf = 0)

EOR <Wd>, <Wn>, <Wm>{, <shift> #<amount>}

64-bit (sf = 1)

EOR <Xd>, <Xn>, <Xm>{, <shift> #<amount>}

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Wn> 是第一个通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Wm> 是第二个通用源寄存器的 32 位名称，在“Rm”字段中编码。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xn> 是第一个通用源寄存器的 64 位名称，在“Rn”字段中编码。

<Xm> 是第二个通用源寄存器的 64 位名称，在“Rm”字段中编码。

<shift> 是要应用于最终源的可选移位，默认为 LSL 并在移位字段中编码：

<shift>shift 字段取值
LSLshift = 00
LSRshift = 01
ASRshift = 10
RORshift = 11

<amount> 对于 32 位变体：是移位量，范围为 0 到 31，默认为 0 并在“imm6”字段中编码；对于 64 位变体：是移位量，在 0 到 63 范围内，默认为 0 并在“imm6”字段中编码。

下面是使用 EOR（移位寄存器）指令的例子。

    long long int x = 0b01101100;//108
    long long int y = 0b00110000;//48
    long long int z = 0;

    asm volatile(
        "EOR %x[z], %x[x], %x[y], LSL#2\n"
    :[x] "+r"(x),
    [y] "+r"(y),
    [z] "+r"(z)
    :
    : "cc", "memory");

EOR %x[z], %x[x], %x[y], LSL#2 执行 x 异或 (y << 2) = 0b01101100 异或 0b11000000 = 0b10101100，也就是 172，所以 z 的最终结果为 172。

1.6 EON

按位异或非（移位寄存器）：Rd = Rn EOR NOT shift(Rm, amount)。

在这里插入图片描述

32-bit (sf = 0)

EON <Wd>, <Wn>, <Wm>{, <shift> #<amount>}

64-bit (sf = 1)

EON <Xd>, <Xn>, <Xm>{, <shift> #<amount>}

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Wn> 是第一个通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Wm> 是第二个通用源寄存器的 32 位名称，在“Rm”字段中编码。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xn> 是第一个通用源寄存器的 64 位名称，在“Rn”字段中编码。

<Xm> 是第二个通用源寄存器的 64 位名称，在“Rm”字段中编码。

<shift> 是要应用于最终源的可选移位，默认为 LSL 并在移位字段中编码：

<shift>shift 字段取值
LSLshift = 00
LSRshift = 01
ASRshift = 10
RORshift = 11

<amount> 对于 32 位变体：是移位量，范围为 0 到 31，默认为 0 并在“imm6”字段中编码；对于 64 位变体：是移位量，在 0 到 63 范围内，默认为 0 并在“imm6”字段中编码。

下面是使用 EON 指令的例子。

    long long int x = 0b01101100;//108
    long long int y = 0b00110000;//48
    long long int z = 0;

    asm volatile(
        "EON %x[z], %x[x], %x[y], LSL#2\n"
    :[x] "+r"(x),
    [y] "+r"(y),
    [z] "+r"(z)
    :
    : "cc", "memory");

EON %x[z], %x[x], %x[y], LSL#2 执行 x 异或 ~(y << 2) = 0b01101100 异或 ~0b11000000 = 0b01101100 异或 0xFFFF FFFF FFFF FF3F = 0xFFFF FFFF FFFF FF53，也就是 -173，所以 z 的最终结果为 -173。

二、移位指令

指定用于移位的寄存器可以是 32 位或 64 位。要移位的量可以指定为立即数，即最大寄存器大小减一，或者指定值仅取自底部五位（模 32）或六位（模 64）位的寄存器。

下面的图详细解释了移位指令是如何操作的。

在这里插入图片描述

2.1 ASR

ASR（寄存器）

算术右移（寄存器）：Rd = ASR(Rn, Rm)。

在这里插入图片描述

32-bit (sf = 0)

ASR <Wd>, <Wn>, <Wm>

等价指令

ASRV <Wd>, <Wn>, <Wm>

64-bit (sf = 1)

ASR <Xd>, <Xn>, <Xm>

等价指令

ASRV <Xd>, <Xn>, <Xm>

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Wn> 是第一个通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Wm> 是第二个通用源寄存器的 32 位名称，在其底部 5 位中保存从 0 到 31 的移位量，编码在“Rm”字段中。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xn> 是第一个通用源寄存器的 64 位名称，在“Rn”字段中编码。

<Xm> 是第二个通用源寄存器的 64 位名称，在其底部 6 位中保存从 0 到 63 的移位量，编码在“Rm”字段中。

下面是使用 ASR（寄存器）指令的例子。

    long long int x = -64769;//0xFFFFFFFFFFFF02FF
    long long int y = 8;
    long long int z = 0;

    asm volatile(
        "ASR %x[z], %x[x], %x[y]\n"
    :[x] "+r"(x),
    [y] "+r"(y),
    [z] "+r"(z)
    :
    : "cc", "memory");

ASR %x[z], %x[x], %x[y] 执行 x 算术右移 y 位，也就是 0xFFFFFFFFFFFF02FF 算术右移 8 位，即最终结果为 0xFFFFFFFFFFFFFF02，所以 z 的最终结果为 -254。算术右移符号位得到了保留！

ASR（立即数）

算术右移（立即数）：Rd = ASR(Rn, shift)。

在这里插入图片描述

32-bit (sf = 0, N = 0)

ASR <Wd>, <Wn>, #<shift>

等价指令

SBFM <Wd>, <Wn>, #<shift>, #31

64-bit (sf = 1, N = 1)

ASR <Xd>, <Xn>, #<shift>

等价指令

SBFM <Xd>, <Xn>, #<shift>, #63

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Wn> 是通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xn> 是通用源寄存器的 64 位名称，在“Rn”字段中编码。

<shift> 对于 32 位变体：是移位量，范围为 0 到 31；对于 64 位变体：是移位量，范围为 0 到 63。

下面是使用 ASR（立即数）指令的例子。

    long long int x = -64769;//0xFFFFFFFFFFFF02FF
    long long int z = 0;

    asm volatile(
        "ASR %x[z], %x[x], #8\n"
    :[x] "+r"(x),
    [z] "+r"(z)
    :
    : "cc", "memory");

ASR %x[z], %x[x], #8 执行 x 算术右移 8 位，也就是 0xFFFFFFFFFFFF02FF 算术右移 8 位，即最终结果为 0xFFFFFFFFFFFFFF02，所以 z 的最终结果为 -254。

2.2 LSL

LSL（寄存器）

逻辑左移（寄存器）：Rd = LSL(Rn, Rm)。

在这里插入图片描述

32-bit (sf = 0)

LSL <Wd>, <Wn>, <Wm>

等价指令

LSLV <Wd>, <Wn>, <Wm>

64-bit (sf = 1)

LSL <Xd>, <Xn>, <Xm>

等价指令

LSLV <Xd>, <Xn>, <Xm>

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Wn> 是第一个通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Wm> 是第二个通用源寄存器的 32 位名称，在其底部 5 位中保存从 0 到 31 的移位量，编码在“Rm”字段中。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xn> 是第一个通用源寄存器的 64 位名称，在“Rn”字段中编码。

<Xm> 是第二个通用源寄存器的 64 位名称，在其底部 6 位中保存从 0 到 63 的移位量，编码在“Rm”字段中。

下面是使用 LSL（寄存器）指令的例子。

    long long int x = -64769;//0xFFFFFFFFFFFF02FF
    long long int y = 8;
    long long int z = 0;

    asm volatile(
        "LSL %x[z], %x[x], %x[y]\n"
    :[x] "+r"(x),
    [y] "+r"(y),
    [z] "+r"(z)
    :
    : "cc", "memory");

LSL %x[z], %x[x], %x[y] 执行 x 逻辑左移 y 位，也就是 0xFFFFFFFFFFFF02FF 逻辑左移 8 位，即最终结果为 0xFFFFFFFFFF02FF00，所以 z 的最终结果为 -16580864。

LSL（立即数）

逻辑左移（立即数）：Rd = LSL(Rn, shift)。

在这里插入图片描述

32-bit (sf = 0, N = 0)

LSL <Wd>, <Wn>, #<shift>

等价指令

UBFM <Wd>, <Wn>, #(-<shift> MOD 32), #(31-<shift>)

64-bit (sf = 1, N = 1)

LSL <Xd>, <Xn>, #<shift>

等价指令

UBFM <Xd>, <Xn>, #(-<shift> MOD 64), #(63-<shift>)

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Wn> 是通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xn> 是通用源寄存器的 64 位名称，在“Rn”字段中编码。

<shift> 对于 32 位变体：是移位量，范围为 0 到 31；对于 64 位变体：是移位量，范围为 0 到 63。

下面是使用 LSL（立即数）指令的例子。

    long long int x = -64769;//0xFFFFFFFFFFFF02FF
    long long int z = 0;

    asm volatile(
        "LSL %x[z], %x[x], #8\n"
    :[x] "+r"(x),
    [z] "+r"(z)
    :
    : "cc", "memory");

LSL %x[z], %x[x], #8 执行 x 逻辑左移 8 位，也就是 0xFFFFFFFFFFFF02FF 逻辑左移 8 位，即最终结果为 0xFFFFFFFFFF02FF00，所以 z 的最终结果为 -16580864。

2.3 LSR

LSR（寄存器）

逻辑右移（寄存器）：Rd = LSR(Rn, Rm)。

在这里插入图片描述

32-bit (sf = 0)

LSR <Wd>, <Wn>, <Wm>

等价指令

LSRV <Wd>, <Wn>, <Wm>

64-bit (sf = 1)

LSR <Xd>, <Xn>, <Xm>

等价指令

LSRV <Xd>, <Xn>, <Xm>

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Wn> 是第一个通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Wm> 是第二个通用源寄存器的 32 位名称，在其底部 5 位中保存从 0 到 31 的移位量，编码在“Rm”字段中。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xn> 是第一个通用源寄存器的 64 位名称，在“Rn”字段中编码。

<Xm> 是第二个通用源寄存器的 64 位名称，在其底部 6 位中保存从 0 到 63 的移位量，编码在“Rm”字段中。

下面是使用 LSR（寄存器）指令的例子。

    long long int x = -64769;//0xFFFFFFFFFFFF02FF
    long long int y = 8;
    long long int z = 0;

    asm volatile(
        "LSR %x[z], %x[x], %x[y]\n"
    :[x] "+r"(x),
    [y] "+r"(y),
    [z] "+r"(z)
    :
    : "cc", "memory");

LSR %x[z], %x[x], %x[y] 执行 x 逻辑右移 y 位，也就是 0xFFFFFFFFFFFF02FF 逻辑右移 8 位，即最终结果为 0x00FFFFFFFFFFFF02，所以 z 的最终结果为 72057594037927682。

LSR（立即数）

逻辑右移（立即数）：Rd = LSR(Rn, shift)。

在这里插入图片描述

32-bit (sf = 0, N = 0)

LSR <Wd>, <Wn>, #<shift>

等价指令

UBFM <Wd>, <Wn>, #<shift>, #31

64-bit (sf = 1, N = 1)

LSR <Xd>, <Xn>, #<shift>

等价指令

UBFM <Xd>, <Xn>, #<shift>, #63

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Wn> 是通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xn> 是通用源寄存器的 64 位名称，在“Rn”字段中编码。

<shift> 对于 32 位变体：是移位量，范围为 0 到 31；对于 64 位变体：是移位量，范围为 0 到 63。

下面是使用 LSR（立即数）指令的例子。

    long long int x = -64769;//0xFFFFFFFFFFFF02FF
    long long int z = 0;

    asm volatile(
        "LSR %x[z], %x[x], #8\n"
    :[x] "+r"(x),
    [z] "+r"(z)
    :
    : "cc", "memory");

LSR %x[z], %x[x], #8 执行 x 逻辑右移 8 位，也就是 0xFFFFFFFFFFFF02FF 逻辑右移 8 位，即最终结果为 0x00FFFFFFFFFFFF02，所以 z 的最终结果为 72057594037927682。

2.4 ROR

ROR（寄存器）

循环右移（寄存器）：Rd = ROR(Rn, Rm)。

在这里插入图片描述

32-bit (sf = 0)

ROR <Wd>, <Wn>, <Wm>

等价指令

RORV <Wd>, <Wn>, <Wm>

64-bit (sf = 1)

ROR <Xd>, <Xn>, <Xm>

等价指令

RORV <Xd>, <Xn>, <Xm>

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Wn> 是第一个通用源寄存器的 32 位名称，在“Rn”字段中编码。

<Wm> 是第二个通用源寄存器的 32 位名称，在其底部 5 位中保存从 0 到 31 的移位量，编码在“Rm”字段中。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xn> 是第一个通用源寄存器的 64 位名称，在“Rn”字段中编码。

<Xm> 是第二个通用源寄存器的 64 位名称，在其底部 6 位中保存从 0 到 63 的移位量，编码在“Rm”字段中。

下面是使用 ROR（寄存器）指令的例子。

    long long int x = 255;//0xFF
    long long int y = 8;
    long long int z = 0;

    asm volatile(
        "ROR %x[z], %x[x], %x[y]\n"
    :[x] "+r"(x),
    [y] "+r"(y),
    [z] "+r"(z)
    :
    : "cc", "memory");

ROR %x[z], %x[x], %x[y] 执行 x 循环右移 y 位，也就是 0xFF 循环右移 8 位，即最终结果为 0xFF00000000000000，所以 z 的最终结果为 -72057594037927936。

ROR（立即数）

逻辑右移（立即数）：Rd = ROR(Rs, shift)。

在这里插入图片描述

32-bit (sf = 0, N = 0, imms = 0xxxxx)

ROR <Wd>, <Ws>, #<shift>

等价指令

EXTR <Wd>, <Ws>, <Ws>, #<shift>

64-bit (sf = 1, N = 1)

ROR <Xd>, <Xs>, #<shift>

等价指令

EXTR <Xd>, <Xs>, <Xs>, #<shift>

<Wd> 是通用目标寄存器的 32 位名称，在“Rd”字段中编码。

<Ws> 是通用源寄存器的 32 位名称，编码在“Rn”和“Rm”字段中。

<Xd> 是通用目标寄存器的 64 位名称，在“Rd”字段中编码。

<Xs> 是通用源寄存器的 64 位名称，在“Rn”和“Rm”字段中编码。

<shift> 对于 32 位变体：是循环移位的量，在 0 到 31 的范围内，编码在“imms”字段中；对于 64 位变体：是在 0 到 63 范围内循环移位的量，编码在“imms”字段中。

下面是使用 ROR（立即数）指令的例子。

    long long int x = 255;//0xFF
    long long int z = 0;

    asm volatile(
        "ROR %x[z], %x[x], #8\n"
    :[x] "+r"(x),
    [z] "+r"(z)
    :
    : "cc", "memory");

ROR %x[z], %x[x], #8 执行 x 循环右移 8 位，也就是 0xFF 循环右移 8 位，即最终结果为 0xFF00000000000000，所以 z 的最终结果为 -72057594037927936。

参考资料

1.《ARMv8-A-Programmer-Guide》
2.《Arm® A64 Instruction Set Architecture Armv8, for Armv8-A architecture profile》

iOS逆向：【ARM 移位操作】（LSL、ASL、LSR、ASR、ROR、RRX）
专注于计算机研发知识和资讯分享
10-19 4万+
前言移位操作在ARM指令集中不作为单独的命令使用，它在指令格式中是一个字段。(1)、LSL —- 逻辑左移（Logical Shift Left）与 ASL —- 算术左移 (Arithmetic Shift Left)逻辑左移与算术左移的操作是一样的，都是将操作数向左移位，低位补零，移除的高位进行丢弃。MOV R0, #5 MOV R1, R0, LSL #2上述命令，就是将5存储到R0寄存器......
【ARMv7-A】——汇编指令集
tyustli
11-30 2058
ARM 指令集 ARM 指令集分为 6 类： 跳转指令 数据处理指令 程序状态寄存器(PSR)转移指令 Load/Store 指令 协处理器指令 异常中断产生指令 指令的一般格式 ARM 指令的一般编码格式 &lt;opcode&gt; {&lt;cond&gt;}{S} &lt;Rd&gt;,&lt;Rn&gt;,&lt;shifter_operand&gt; opcode：是指令助记符，如 ADD 表示算数加法操作指令 cond：表示指令执行的条件 S：决定指令的操作是否影响 CPSR 的值 Rd
[ARM 汇编]进阶篇—数据处理指令—2.1.3 移位指令
Andy0214的专栏
06-14 1万+
逻辑左移指令用于将一个寄存器中的值进行逻辑左移，并将结果存储在目标寄存器中。逻辑右移指令用于将一个寄存器中的值进行逻辑右移，并将结果存储在目标寄存器中。算术右移指令用于将一个寄存器中的值进行算术右移，并将结果存储在目标寄存器中。循环右移指令用于将一个寄存器中的值进行循环右移，并将结果存储在目标寄存器中。这个指令将 R1 中的值逻辑右移 2 位，并将结果存储在 R0 中。这个指令将 R1 中的值算术右移 2 位，并将结果存储在 R0 中。这个指令将 R1 中的值循环右移 2 位，并将结果存储在 R0 中。
移位操作指令
weixin_51332399的博客
03-10 269
移位操作指令
汇编语言移位操作
qq_46626684的博客
01-06 1907
汇编语言移位操作
ARM体系结构2：汇编指令集
weixin_57535837的博客
08-22 1835
本文章介绍了ARM体系结构相关的汇编指令集，有需要的可以参考下。
《ARM Cortex-R 学习指南》-【第五章】-统一汇编语言指令
baron-周贺贺-代码改变世界ctw
09-03 1736
本章是对统一汇编语言的一般性介绍。它并不提供每个指令的详细解释。我们将依次简要介绍这些类别。在此之前，让我们先探讨不同指令类别共有的功能。
ARMzhiling.rar_arm指令
09-23
1. 数据处理指令：这是ARM指令集中的核心部分，用于执行算术和逻辑运算。例如，`ADD`指令用于加法，`SUB`用于减法，`AND`和`ORR`分别进行按位与和按位或操作。此外，还有移位操作指令，如`LSL`(逻辑左移)、`LSR`...
嵌入式软件开发培训笔记——ARM体系结构、A8处理器内核及汇编指令集
CSDN85391440的专栏
05-31 2043
一、ARM     ARM是处理器，但不是实实在的硬件。它是一种叫作“核”的东西。     1、主要设计ARM架构的RISC处理器     2、ARM公司不生产芯片，只是授权内核给生产和销售半导体的合作伙伴，另外也提供基于ARM架构的开发设计技术。      二、SOC概念     System on Chip，简称Soc,也即片上系统。从狭义角度讲，它是信息系统核心的芯片集成，是将系
【ARM架构中文手册】第五章 ARM/Thumb Unified Assembly Language Instructions
baron-周贺贺-代码改变世界ctw
10-06 199
无符号数字会被零扩展（即寄存器的最高16或24位被设置为零），但对于有符号数字，则需要将符号位（字节的第[7]位或半字的第[15]位）复制到寄存器的高16位（或24位）。SIMD指令的一般形式是每个寄存器中的子字节数量会并行操作（例如，可以执行四个字节大小的ADD操作），GE标志根据指令的结果被设置或清除。对于明确的比较指令，S后缀既不是必需的，也不允许。另一种分支指令类型可以通过加载（LDR）指令将PC作为目标，或通过加载多重（LDM）指令，或堆栈弹出（POP）指令将PC放在要加载的寄存器列表中实现。
汇编语言学习笔记（一）ARM指令集
weixin_53295593的博客
05-26 3329
汇编语言学习笔记（一）ARM指令集 文章目录汇编语言学习笔记（一）ARM指令集前言一、数据处理指令类型二、跳转指令类型：三、控制指令类型：四、存储器访问指令类型：总结 前言 杂事太多，浪费我10多天的时间。ARM指令集，我感觉还是“复杂”了；功能虽全，但记忆量也多。其实，编写OS所用到的只是100多条ARM指令集中的约30多条吧。以下是对ARM指令集的第一次简单整理，有错难免、仅供参考。 有多种指令集架构（Instruction Set Architecture），如RISC类（RISC-V、Open
【ARMv8 编程】A64 系统控制和其他指令
洪伟的专栏
05-17 1609
A64 指令集包含与以下相关的指令：异常处理、系统寄存器访问、调试、提示指令，在许多系统中都有电源管理应用程序。
用ARM进行汇编语言编程（3）逻辑移位和轮换，条件与分支
Ba1_Ma0的博客
09-02 1811
这是我学习的笔记，有什么错误和不懂的地方欢迎来私信我，或者加我qq。
ARM64体系结构编程3-算数和移位指令
做一位会读书的Linux工程师
12-12 2656
b 指令的操作由后缀 cs 决定，cs 表示判断是否发生无符号溢出，3 + not(2) + 1 , not(2) = 0xfffffffffffffffd , 3 + 0xfffffffffffffffd + 1 = 1， ，这个过程发生了溢出，C 标志位置为 1， 所以 b.cs 的判断条件成立，跳转到标签 1 处，继续执行。BFI 指令把 X1 寄存器中的 Bit[3,0] 设置为 X0 寄存器中的 Bit[7,4], X0 寄存器中的 Bit[7,4] ,X0 寄存器的值是 0x50。
常用ARM汇编指令
qq_52978107的博客
01-30 1123
汇编常用指令
汇编指令-NOT、SHL、LSR
嵌入式Stark
02-20 4830
NOT在汇编语言中，NOT是一个按位逻辑非操作指令。它对一个操作数中的每一位执行逻辑取反操作，即将0变成1，将1变成0。例如，在某些CPU架构（如x86）的汇编语言中，对于一个字节或字（以及其他大小的寄存器或内存位置），NOT对于给定的操作数执行NOT操作后，结果确实会是0100111，因为每一位都被翻转了。请注意，不同的CPU架构可能有不同的指令来实现按位取反操作，并且指令的语法也有所不同。但在大多数情况下，汇编程序员通过查阅相应架构的指令集手册来正确编写和使用这些指令。
ARM64汇编06 - 基本整型运算指令
a5right的博客
03-12 1524
将 Xn 与 imm 相加，结果赋值给 Xd，imm 是无符号数，范围为 0 - 4095。shift 是对 imm 进行移位，shift 为 0 的时候，表示左移 0 位，即不变。shift 为 1 的时候，表示左移12 位：由于 imm 有效位只有 12 位，所以无法表示 0x1234 之类的数，但是可以表示 0x123。且有左移操作，所以也可以表示 0x123000 之类的数。
常用汇编指令和解释
最新发布
2301_78622258的博客
11-28 945
常见的汇编指令格式如下：注：在汇编当中不区分大小写，例如：ADD=add，都是表示按位加法。
arm 32 常见汇编指令解释
热门推荐
slbwgslz的专栏
04-18 1万+
例如：asrs r1, r2, #3 表示将寄存器r2的值向右移动3个位，并用符号位填充左侧空缺的位，并将结果存储到寄存器r1中，并设置条件码寄存器以表明结果是否小于、等于或大于零。例如：adds r1, r2, #3 表示将寄存器r2中的值加上3，并将结果存储到寄存器r1中，并设置条件码寄存器以表明结果是否小于、等于或大于零。例如：subs.w r1, r2, #1 表示将寄存器r2中的值减去1，然后将结果存储到寄存器r1中，并设置条件码寄存器以表明结果是否小于、等于或大于零。例如：stm.w r0!
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

TYYJ-洪伟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值