本节将继续学习逻辑指令(and、or、xor)和移位指令(sll、srl、sra)
从CPU芯片电路角度来看，其实CPU更擅长指令逻辑操作，如与、或、异或
RISC-V指令集中包含了三种逻辑指令，这些指令又分为立即数版本和寄存器版本，分别是这六条指令。
andi、and 指令，它们的形式如下所示：
上述代码中 rd、rs1、rs2 可以是任何通用寄存器，imm 是立即数。
andi、and 这两个指令完成的操作，我们用伪代码描述如下：
按位与的操作，就是把 rs1 与 imm 或者 rs1 与 rs2 其中的每个数据位两两相与。两个位都是 1，结果为 1，否则结果为 0。
下面我们在工程目录下建立一个 and.S 文件，写代码验证一下这两个指令，如下所示：
andi 指令是拿 a0 寄存器和立即数 0xff 进行与操作。由于立即数是 0xff，所以总是返回 a0 的低 8 位数据；and 指令则是拿 a0 和 a1 寄存器进行与操作，再把结果写入到 a0 寄存器。
用 VSCode 打开工程按下“F5”调试一下，如下所示：
上图中是执行完 andi a0，a0，0xff 指令之后，执行 jr ra 指令之前的状态。可以看到，a0 寄存器中的值确实已经变成 2 了，这说明运算的结果是符合预期的。
andi_ins 函数返回后，输出的结果如下图所示：
因为 2 的二进制数据是（0b00000000000000000000000000000010）与上 0xff 的二进制数据是（0b000000000000000000000000）结果确实是 2，所以返回 2，结果是正确的。
接下来，我们对 and_ins 函数进行调试。
上图展示的是执行完 and a0，a0，a1 指令之后，执行 jr ra 指令之前的状态。我们看到 a0 寄存器中的值已经变成了 1，这说明运算的结果是正确的。
and_ins 函数返回后，输出的结果如下图所示：
上图中因为 1 的二进制数据是（0b00000000000000000000000000000001）与上 1 的二进制数据是（0b00000000000000000000000000000001）确实是 1，所以返回 1，结果完全正确。
或指令 ori、or，它们的形式如下：
同样地，上述代码中 rd、rs1、rs2 可以是任何通用寄存器，imm 表示立即数。
我们还是从伪代码的描述入手，看看 ori、or 完成的操作。
按位或的操作就是把 rs1 与 imm 或者 rs1 与 rs2 其中的每个数据位两两相或，两个位有一位为 1，结果为 1，否则结果为 0。
在 and.S 文件中写写代码，做个验证，如下所示：
上述代码中 ori_ins 与 or_ins 函数，分别执行了 ori 和 or 指令。
ori 指令是拿 a0 寄存器和立即数 0 进行或操作，由于立即数是 0，所以总是返回 a0 原本的数据；or 指令是拿 a0 和 a1 寄存器进行或操作，再把结果写入到 a0 寄存器。
VSCode 里，按下“F5”调试一下，如下所示：
上图中是执行完 ori a0，a0，0 指令之后，执行 jr ra 指令之前的状态。如果 a0 寄存器中的值确实已经变成 0xf0f0 了，就说明运算的结果正确。
ori_ins 函数返回后，输出的结果如下图所示：
因为 0xf0f0 的二进制数据是（0b000000000000000010000）或上 0 的二进制数据是（0b00000000000000000000000000000000）按位或操作是“有 1 为 1”，所以返回 0xf0f0，结果是正确的。
再用同样的方法调试一下 or_ins 函数，如下图所示：
上图展示的是执行完 or a0，a0，a1 指令之后，执行 jr ra 指令之前的状态。如果我们看到 a0 寄存器中的值确实已经变成 0x1111 了，就说明运算的结果正确，符合预期。
or_ins 函数返回后，输出的结果如下：
上图中 or_ins 函数第一个参数为 0x1000 的二进制数据是（0b000000000000000000000）第二个参数为 0x1111 的二进制数据是（0b000000000000000000001）两个参数相或，而按位或操作是“有 1 为 1”，所以返回 0x1111，结果是正确的。
逻辑指令中的最后两条指令 xori、xor，即异或指令的立即数版本和寄存器版本，它们的形式如下所示：
xori、xor 完成的操作用伪代码描述如下：
按位异或的操作是把 rs1 与 imm 或者 rs1 与 rs2 其中的每个数据位两两相异或，两个位如果不相同，结果为 1。如果两个位相同，结果为 0。
在 and.S 文件中写代码验证一下，如下所示。
xori 指令是拿 a0 寄存器和立即数 0 进行异或操作，由于立即数是 0，而且各个数据位相同为 0，不同为 1，所以同样会返回 a0 原本的数据 ；而 xor 指令是拿 a0 和 a1 寄存器进行或操作，再把结果写入到 a0 寄存器。
按下“F5”调试一下，如下所示
上图中是执行完 xori a0，a0，0 指令之后，执行 jr ra 指令之前的状态，我们已经看到 a0 寄存器中的值已经变成 0xff 了，这说明运算的结果正确。
xori_ins 函数返回后，输出的结果如下图所示：
结合上面这张截图不难发现，我们传递给 xori_ins 函数的参数是 0xff，因为 0xff 的二进制数据是（0b000000000000000000000000）异或上 0 的二进制数据是（0b00000000000000000000000000000000）按位异或操作是“相同为 0，不同为 1”，所以返回 0xff，结果是正确的。
再来调试一下 xor_ins 函数。xor a0，a0，a1 指令执行完成之后，执行 jr ra 指令之前的状态如图所示：
看到 a0 寄存器中的值已经变成 0 了，这说明运算的结果正确，符合预期。
xor_ins 函数返回后，输出的结果如下图所示：
由于我们给 xor_ins 函数传递了两个相同的参数都是 0xffff。因为 0xffff 的二进制数据是（0b000000000000000011111）两者异或，按位异或操作是“相同为 0，不同为 1”，所以返回 0，结果是正确的。
下面来看下andi、and、ori、or、xori、xor 这六条指令的二进制数据。
打开工程目录下的 and.bin 文件，如下所示：
上述图中的 12 个 32 位数据是 12 条指令，其中六个 0x00008067 数据是六个函数的返回指令。
具体的指令形式，还有对应的汇编语句，见下表格：
同样地，我带你拆分一下 andi、and、ori、or、xori、xor 指令的各位段的数据，看看它们是如何编码的。
从上图中可以发现，立即数版本和寄存器版本的 and、or、xor 指令通过操作码区分，而它们之间的寄存器和立即数版本是靠功能位段来区分，立即数位段和源寄存器与目标寄存器位段和之前的指令是相同的。
移位指令和逻辑操作指令一样，都是 CPU 电路很容易就能实现的。
RISC-V 指令集中的移位指令包括逻辑左移、逻辑右移和算术右移，它们分别有立即数和寄存器版本，所以一共有六条。
上述代码中 rd、rs1、rs2 可以是任何通用寄存器。imm 是立即数，其实在官方文档中，这里是 shamt，表示 rs1 左移 shamt 位。这里我为了和之前的形式保持一致，才继续沿用了 imm。
slli、sll 它们俩完成的操作，用伪代码描述如下：
逻辑左移的操作是把 rs1 中的数据向左移动 imm 位，或者把 rs1 中的数据向左移动 rs2 位，右边多出的空位填 0 并写入 rd 中。
在工程目录下，建立一个 sll.S 文件，写代码验证一下，如下所示
立即数逻辑左移 slli 指令是把 a0 中的数据左移 4 位。而逻辑左移 sll 指令是把 a0 中的数据左移，左移多少位要取决于 a1 中的数据，完成移动后再把结果写入到 a0 寄存器。
用 VSCode 打开工程，按下“F5”调试，如下所示：
上图中是进入 slli_ins 函数，执行完 slli a0，a0，4 指令之后，执行 jr ra 指令之前的状态，我们给 slli_ins 函数传进来的参数是 0xffff。现在对照图示就能看到，a0 寄存器中的值确实已经变成 0xffff0 了，这说明运算结果是正确的。
slli_ins 函数返回后，输出的结果如下：
因为 0xffff 二进制数据是（0b000000000000000011111），逻辑左移 4 位后的结果是 0xffff0，它的二进制数据是（0b000000000000），结果正确无误。
下面我们接着对 sll_ins 函数进行调试，如下所示：
上图中是进入 sll_ins 函数，执行完 sll a0，a0，a1 指令之后，执行 jr ra 指令之前的状态，我们给 sll_ins 函数传进来的参数是 0xeeeeeeee 和 31（a1 寄存器）。如果看到 a0 寄存器中的值确实已经变成 0 了，这说明运算结果是正确的。
sll_ins 函数返回后，输出的结果如下图所示：
第一个参数 0xeeeeeeee 的二进制数据是（0b00），逻辑左移 31 位后的结果是 0，因为它把所有的二进制数据位都移出去了，然后空位补 0，所以结果正确无误。
有逻辑左移就有逻辑右移。逻辑右移指令 srli、srl，分别对应着立即数和寄存器版本，它们的形式如下：
上述代码中 rd、rs1、rs2 可以是任何通用寄存器。imm 是立即数。为了和之前的形式保持一致，我们还是沿用 imm，而非官方文档中的 shamt。
srli、srl 完成的操作，可以用后面的伪代码来描述：
逻辑右移的操作是把 rs1 中的数据向右移动 imm 位。或者把 rs1 中的数据向右移动 rs2 位，左边多出的空位填 0 并写入 rd 中。
在 sll.S 文件中写段代码来验证一下，如下所示：
代码中立即数逻辑右移 srli 指令是把 a0 中的数据右移 8 位。逻辑右移 srl 指令，则是把 a0 中的数据右移，右移多少位要看 a1 中数据表示的位数是多少，再把结果写入到 a0 寄存器。
打开工程按下“F5”就可以调试了，效果如图：
上图中是进入 srli_ins 函数，执行完 srli a0，a0，8 指令之后，执行 jr ra 指令之前的状态，我们给 srli_ins 函数传进来的参数是 0xffff。现在，对照截图可以看到 a0 寄存器中的值确实已经变成 0xff 了，这说明运算结果正确。
srli_ins 函数返回后，输出的结果如下图所示：
因为调用函数 srli_ins 的参数 0xffff 的二进制数据是（0b000000000000000011111），逻辑右移 8 位后的结果是 0xff，它的二进制数据是（0b000000000000000000000000），结果正确，符合我们的预期
拿下了 srli_ins 函数，接下来就是 srl_ins 函数的调试，如下所示：
上图中是调用进入 srl_ins 函数，执行完 srl a0，a0，a1 指令之后，执行 jr ra 指令之前的状态，给 srl_ins 函数传进来的参数是 0xaaaaaaaa。可以看到，a0 寄存器中的值确实已经变成 0xaaaa 了，所以运算结果也是正确的。
srl_ins 函数返回后，输出的结果如下图所示：
给 srl_ins 函数传进来的第一个参数是 0xaaaaaaaa 的二进制数据是（0b00），逻辑右移 16 位后的结果是 0xaaaa，其二进制数据为（0b000000000000000001010 ），因为它把低 16 位二进制数据位移出去了，然后高 16 位的空位补 0，所以结果正确无误。
最后还有两个算术右移指令，它们和逻辑右移的最大区别是，数据在逻辑右移之后左边多出空位用 0 填充，而数据在算术右移之后左边多出的空位是用数据的符号位填充。如果数据的符号位为 1 就填充 1，如果为 0 就填充 0。
上述代码中的两个函数 srai_ins 与 sra_ins，可以实现算术右移。先看立即数算术右移 srai 指令，它把 a0 中的数据右移了 8 位。而算术右移 srl 指令是把 a0 中的数据右移，右移多少位由 a1 中的数据表示的位数来决定，之后再把结果写入到 a0 寄存器。
按下“F5”，调试的结果如下：
上图中是进入立即数算术右移函数 srai_ins，执行完 srai a0，a0，8 指令之后，执行 jr ra 指令之前的状态。对照图里红框的内容可以看到，给 srai_ins 函数传进来的参数是 0x1111。如果 a0 寄存器中的值确实已经变成 0x11 了，就代表运算结果正确。
srai_ins 函数返回后，输出的结果如下：
因为我们给立即数算术右移函数 srai_ins 的参数 0x1111，其二进制数据是（0b000000000000000000001），符号位为 0，所以算术右移 8 位后的结果是 0x11，它的二进制数据是（0b00000000000000000000000000010001），结果非常正确。
接着调试一下 sra_ins 函数，如下所示：
上图中是进入算术右移函数 sra_ins，执行完 sra a0，a0，a1 指令之后，执行 jr ra 指令之前的状态。对照图里左侧红框的部分，我们就能知道 sra_ins 函数传进来的参数是 0xaaaaaaaa，你可能判断 a0 寄存器里输出的结果应该是 0x0000aaaa，但调试显示的实际结果却是 0xffffaaaa。
先看看 sra_ins 函数返回后输出的结果是什么，然后再分析原因。
因为我们给算术右移函数 sra_ins 的参数是 0xaaaaaaaa 和 16，这表明对 0xaaaaaaaa 算术右移 16，0xaaaaaaaa 的二进制数据是（0b00），注意其符号位为 1，所以算术右移 16 位后的结果是 0xffffaaaa，它的二进制数据是（0b），结果是符合预期的。输出的结果也证实了这一点。
还是要看一下 slli、sll、srli、srl、srai、sra 这六条指令的二进制数据，我们打开工程目录下的 sll.bin 文件。
可以看出，图中的 12 个 32 位数据是 12 条指令，其中六个 0x00008067 数据是六个函数的返回指令。具体的指令形式，还有对应的汇编语句，你可以参考后面的表格。
我们拆分一下 slli、sll、srli、srl、srai、sra 指令的各位段的数据，看看它们是在内存中如何编码的，你可以结合示意图来理解。
从上图中我们可以发现，sll、srl、sra 指令的立即数版本和寄存器版本要通过操作码区分，而它们之间是靠功能位段来区分的，源寄存器与目标寄存器所在的位段和之前的指令是相同的。需要注意的是，这些立即数版本的立即数位段在官方文档中叫 shamt 位段，并且只占 5 位，而其它指令的立即数占 12 位，这里为了一致性还是沿用立即数。
版权声明：
本文来源网络，所有图片文章版权属于原作者，如有侵权，联系删除。
本文网址：https://www.mushiming.com/mjsbk/3532.html