大家好，我是微微笑的蜗牛，🐌。

在经历了前面三篇文章的冲刷之后，是不是越发对虚拟机感到熟悉了😆？如果还没看过的童鞋，可以回过头去看看。

• 听说你想写个虚拟机（一）？
• 听说你想写个虚拟机（二）？
• 听说你想写个虚拟机（三）？

这篇文章，主要介绍数据存取指令的实现，附加实践部分。难度不大，请放心阅读~

存值

ST

ST SR, LABEL

Store 的缩写，操作码为 0011。

SR 表示待存值的寄存器，LABEL 表示标签，我们在上篇文章中提到过。LC-3 中，它既可以表示函数，也可以表示数据。同样，标签在指令中最终会转换为一个数值，即：相对于 PC 的偏移量。

指令含义：将寄存器 SR 中的值，存储到指定的内存地址中。

指令布局如下：

image

还记得上篇文章中定义的内存区域吗？数据最终会写到那里去。但写入数据肯定是需要知道地址，那如何得到地址呢？

上图中的 pc_offset 是相对于 PC 的偏移量，PC 指向下一条指令的地址。弄清关系后，写入地址的计算就比较简单了，如下所示：

// 取出偏移量，符号扩展
uint16_t pc_offset = sign_extend(instr & 0x1ff, 9);

// 计算真实地址
uint16_t address = PC + pc_offset;

这样，我们只需将寄存器中的值取出，写入上面的地址就好。

// 取出寄存器的值
uint16_t value = reg[r0];

// 写入
mem_write(address, value);

mem_write 的实现很简单，给数组赋值即可。

// 将 data 写入内存地址为 address 处
void mem_write(uint16_t address, uint16_t data)
{
  if (address < 0 || address >= UINT16_MAX)
  {
    printf("memory write error!\n");
    exit(3);
  }

  mem[address] = data;
}

STI

STI SR, LABEL

Store Indirect 的缩写，意思是间接存储。操作码为 1011。

指令参数布局与含义都与 ST 一样。只不过是将寄存器中的值，间接存储到指定的内存地址中，地址是相对于 PC 的偏移量。

指令布局如下：

image

这里，重点关注一下间接地址，它是啥意思？其实也就是待存储数据地址的地址。

怎么理解呢？看下面这张图可能就明白了。

image

对照上图理解：

• 图中的地址 3 并不是数据最终的存储地址，称之为间接地址。
• 地址 3 里面的内容 6 才是最终地址，也就是说数据会存储到地址 6。
• mem[mem[3]] = mem[6] = data，是这样一个计算关系。

理解了间接地址后，实现也就很简单了。对照着代码注释，相信你能顺利理清。

// 间接存储，pc+pc_offset 是待存储数据地址的地址。
void store_indirect(uint16_t instr)
{
    // 取出偏移量
  uint16_t pc_offset = sign_extend(instr & 0x1ff, 9);

    // 取出寄存器
  uint16_t r0 = (instr >> 9) & 0x7;

    // 计算出间接地址
  uint16_t indirect_address = PC + pc_offset;

    // 计算出实际地址
  uint16_t address = mem_read(indirect_address);

    // 取出寄存器的值
  uint16_t value = reg[r0];

    // 写入地址
  mem_write(address, value);
}

STR

STR SR, BaseR, offset

Store Register 的缩写，操作码为 0111。

指令含义：将寄存器 SR 中的值，存储到指定的内存地址中，只是 offset 是相对于寄存器 BaseR 的偏移量。

指令布局如下：

image

它与 ST 指令的区别是，偏移量不是相对于 PC，而是寄存器 BaseR。相比起来，实现会稍稍复杂一些，多一个取 BaseR 的步骤。

• 取出 BaseR。
• 取出 offset。
• 计算真实地址： BaseR + offset。

代码如下所示：

//  取出 6 位偏移 offset
uint16_t pc_offset = sign_extend(instr & 0x1ff, 6);

// r1
uint16_t r1 = (instr >> 6) & 0x7;

// 真实地址
uint16_t address = reg[r1] + offset;

其余操作跟 ST 一模一样，就不再赘述了。

取值

取值指令分为取数据和取地址，下面我们来详细讲述。

LD

LD DR, LABEl

Load 的缩写，操作码为 0010。

指令含义：将指定内存地址中的内容，放到寄存器 DR 中，并更新标志寄存器。地址以相对于 PC 的偏移量来计算。

指令布局如下：

image

LD 可以跟 ST 对应起来，它们是一对操作。参数布局完全一样，一个取值，一个存值。

数据地址的计算方式与 ST 的实现一样，使用 PC 作为基准，详见代码。

// 以 pc 寄存器作为偏移基准
// 将距离下一条指令 pc_offset 处的数据取出来，放入 r 中。
void load(uint16_t instr)
{
    // 取出 offset
  uint16_t pc_offset = sign_extend(instr & 0x1ff, 9);

    // 取出待存放数据的寄存器
  uint16_t r0 = (instr >> 9) & 0x7;

    // PC + pc_offset 为地址，读取数据到寄存器
  reg[r0] = mem_read(PC + pc_offset);

    // 更新标志寄存器
  update_flags(r0);
}

从内存地址读取数据的函数 mem_read，同样很简单，取出数组的值即可。

uint16_t mem_read(int address)
{
  if (address < 0 || address >= UINT16_MAX)
  {
    printf("memory read error!\n");
    exit(4);
  }

  return mem[address];
}

LDI

LDI DR,LABEL

Load Indirect 是缩写，操作码为 1010。

指令含义：将指定的「间接内存地址」中的内容，放到寄存器 DR 中，更新标志寄存器。地址是相对于 PC 的偏移量。

指令布局如下：

image

类似的，它跟 STI 也是一对操作，参数布局一样。间接地址的含义上边已经说过，放在这里的操作就是如下三步：

• 计算间接地址: indirect_address = PC + pc_offset
• 获取直接地址: address = mem_read(indirect_address)
• 获取数据：data = mem_read(address)

完整实现代码如下：

// load indirect，从内存中获取数据，放入寄存器。间接模式
// 以 pc 寄存器作为偏移基准
// [[pc+pc_offset]]，pc+pc_offset 中的内容是数据的地址。
void load_indirect(uint16_t instr)
{
    // 偏移地址
  uint16_t pc_offset = instr & 0x1ff;

  // 符号扩展
  pc_offset = sign_extend(pc_offset, 9);

    // 待存放数据的寄存器
  uint16_t r = (instr >> 9) & 0x7;

  // 取出存储数据的地址
  uint16_t address = mem_read(PC + pc_offset);

  // 取出数据
  uint16_t data = mem_read(address);

  // 更新寄存器
  reg[r] = data;

  // 更新标志寄存器
  update_flags(r);
}

LDR

LDR DR, BaseR, offset

Load Register 的缩写，操作码为 0110。

指令含义：将指定内存地址中的内容，放到寄存器 DR 中，更新标志寄存器。其中 offset 是相对于寄存器 BaseR 的偏移量。

指令布局如下：

image

它和 STR 也是一对操作，地址计算以 BaseR 为基准。到现在，看懂这段代码应该比较简单了吧🤩。

// ldr r0, r1, offset
// 以 r1 作为偏移基准
// 将距离 r1，offset 处的数据取出来，放入 r0。
void load_register(uint16_t instr)
{
    // 取出 DR
  uint16_t r0 = (instr >> 9) & 0x7;

    // 取出 BaseR
  uint16_t r1 = (instr >> 6) & 0x7;

    // 取出偏移
  uint16_t offset = sign_extend(instr & 0x3f, 6);

    // 计算地址
  uint16_t address = reg[r1] + offset;

    // 取出数据
  uint16_t value = mem_read(address);

    // 放到寄存器
  reg[r0] = value;

  // 更新标志寄存器
  update_flags(r0);
}

LEA

LEA DR, LABEL

Load Effective Address 的缩写，操作码 1110。

指令含义：将指定地址放入寄存器中，更新标志寄存器。地址计算是相对于 PC 的偏移量。这个指令与其他取值指令的区别在于取的是地址，而不是地址中的内容。

指令布局如下：

image

实现非常简单，将计算出的地址放入寄存器 DR 中就好。

// 将地址放入寄存器 r
// 以 pc 寄存器作为偏移基准
void load_effective_address(uint16_t instr)
{
  uint16_t pc_offset = instr & 0x1ff;

  // 符号扩展
  pc_offset = sign_extend(pc_offset, 9);

    // 地址
  uint16_t address = PC + pc_offset;

    // 寄存器 DR
  uint16_t r = (instr >> 9) & 0x7;

  // 将地址放入寄存器
  reg[r] = address;

  // 更新标志寄存器
  update_flags(r);
}

实践

有了趁手的兵器，总得上阵杀敌不是。哈哈，不知你有没有在上篇文章中感受到手写指令的”快感“。现在，让我们来继续强化这种感觉。

可执行文件分为代码段和数据段，当它被装载到内存区后，代码和数据也就放在了对应的内存地址中。

这里，我们简化一下，假设内存地址 [0, 9] 范围内放的是代码，另一个区间 [10, 15] 放的是数据，且已经初始化了部分数据。如下图所示：

image

我们将要实现的功能是：

• 使用「取值」指令，从数据区中取出数据，放到寄存器。
• 修改寄存器的值，使用「存值」指令，将数据写回到内存。
• 使用 LEA 指令，取地址。

总共设计了 10 条指令。现在，我们挨个来写下。假设指令从 0 号地址开始存储。

1. 使用 LD 指令，将 10 号地址的数据放入 R0。

• 此条指令放在 0 号地址，此时 PC = 1，因为 PC 指向下一条指令。
• LD 的地址是相对于 PC 的偏移量。如要取出 10 号地址，那么偏移量为 10 - PC = 9。
• 最终，R0 = 1。

经过如上分析，可写出如下伪汇编代码：

LD R0, 9

接着，我们来详细分析下这条指令的数据构成，其余指令就不细讲了。

• LD 的操作码：0010。
• RO 下标是 0，二进制表示： 000。
• 数值 9 是偏移量，用 9 位二进制表示：000001001。

将操作码和操作数拼起来，得到指令的二进制为：0010000000001001，十六进制表示为 0x2009。

2. 使用 ADD 指令，修改 R0 的值，加 1。

此条指令在 1 号地址。最终，R0 = 2。

// R0=R0+1
ADD R0, R0, 1

可以自己动手推导一下指令各个部分的二进制表示。最终指令的十六进制表示为：0x1021。

3. 使用 ST 指令，将 R0 的值写回地址 10。

• 此条指令在 2 号地址，此时 PC = 3。
• 地址 10 相对于 PC 的偏移量为 10 - PC = 7。
• 写入之后，地址 10 处的内容为 2。

伪汇编代码如下：

ST, R0, 7

指令十六进制表示：0x3007。

4. 使用 LDI 指令，取出间接地址 12 的内容，放入寄存器 R1。

• 此条指令在 3 号地址，此时 PC = 4。
• 偏移量为 12 - PC = 8。

伪汇编代码如下：

LDI R1, 8

其实上图中的数据是特意构造的。间接地址 12 中存储的是 15，表示地址。也就是说数据的真实地址是 15，而地址 15 处的内容是 3。最终结果：R1 = 3。

指令十六进制表示：0xa208。

5. 修改 R1 的值，加 2。

此条指令在 4 号地址，最终 R1 = 5。

// R1=R1+2
ADD R1, R1, 2

指令十六进制表示：0x1262。

6. 使用 STI 指令，将 R1 的值放入间接地址 12 中。

• 此条指令在 5 号地址，此时 PC = 6。
• 偏移量 = 12 - PC = 6。

同样的，间接地址 12 中的内容 15 是写入地址。因此，写入之后，地址 15 处的内容为 5。

伪汇编代码如下：

STI R1, 6

指令十六进制表示：0xb206。

7. 使用 LEA 指令，取地址。

• 此条指令在 6 号地址，PC = 7。
• 相对于 PC 的偏移量为 4，那么取出的地址为 PC + 4 = 11。
• 最后得到 R2 = 11。

伪汇编代码如下：

LEA R2, 4

指令十六进制表示：0xe404。

8. 占位和退出指令

// RTI
0x8000,
0x8000,

// trap-halt
0xf000,

使用了两条占位指令凑数，加上最后一条程序退出指令，正好 10 条。

此时，指令和数据在内存中的布局情况如下：

image

执行完上述指令后，寄存器的结果和内存数据的值应该如下：

R0=2, R1=5, R2=11
mem[10]=2, mem[15]=5

另外，STR/LDR 指令没有使用，有兴趣自己可以尝试着写一下。

完整 Demo 在此：https://github.com/silan-liu/virtual-machine/blob/master/mac/vm_lc_3_2.c。

总结

不知道大家有没有注意到，我们介绍的存取指令其实是一一对应的，比如 ST/LD、STI/LDI。理解了存指令的思想后，取指令照葫芦画瓢，轻轻松松就能弄明白。

唯一有点绕的地方就是间接地址，它表示地址的地址。因此，需要两步操作才能得到实际地址。

好了，这篇就结束了。下一篇，我们将介绍 TRAP 指令，并实现几个系统调用。

参考资料

• https://justinmeiners.github.io/lc3-vm/#1:8
• https://justinmeiners.github.io/lc3-vm/supplies/lc3-isa.pdf
• https://github.com/silan-liu/virtual-machine