RISC-V on Lorn

[从零开始的编译原理][实验] Exp Chapter 2：从 Koopa IR 到 RISC-V

Tue, 06 Oct 2026 20:24:45 +0800

接下来，在本节中，我们将在上一节工作的基础上，让编译器进一步支持生成 RISC-V 汇编代码。

目前我们需要编译的 SysY 程序仍然非常简单：

1
2
3
4
5


int main()
{
 // 摊牌了，我是注释
 return 0;
}

上一节中，我们已经可以将它编译为如下的 Koopa IR：

1
2
3
4


fun @main(): i32 {
%entry:
 ret 0
}

而本节的目标，是继续完成从 Koopa IR 到 RISC-V 汇编的转换。例如生成：

1
2
3
4
5


 .text
 .globl main
main:
 li a0, 0
 ret

当然，根据具体的代码生成策略，也可能生成：

1
2
3
4
5
6


 .text
 .globl main
main:
 li t0, 0
 mv a0, t0
 ret

两种写法在这里的效果是一样的：最终都将整数 0 放入返回值寄存器 a0 中，然后从 main 函数返回。

具体生成哪一种形式，取决于我们的代码生成器如何处理中间结果和寄存器。对于当前这个非常简单的程序来说，显然没有必要额外使用临时寄存器，因此我们直接生成第一种形式即可。

目标代码生成

目前，我们的编译器已经完成了这样一条编译链：

1
2
3
4
5
6
7


SysY 源代码
 ↓
Lexer / Parser
 ↓
AST
 ↓
Koopa IR

接下来需要继续完成：

1
2
3
4
5


Koopa IR
 ↓
CodeGen
 ↓
RISC-V Assembly

上一章中，我们已经自己设计并实现了 Koopa IR 的数据结构。因此，这里的目标代码生成与之前实现 Printer 输出 Koopa IR 文本其实非常类似：

遍历 IR 数据结构，根据不同的 IR 节点输出对应的 RISC-V 指令。

例如：

1

ret 0

对应：

1
2


li a0, 0
ret

因此，从整体结构来看，CodeGen 同样可以采用 Visitor 风格的实现：依次访问 Program、Function、BasicBlock 和 Instruction，最终将每条 IR 指令翻译成对应的汇编指令。

不过，在开始实现之前，我们首先需要理解生成出来的这几行 RISC-V 汇编究竟在做什么。

对于：

1
2
3
4
5


 .text
 .globl main
main:
 li a0, 0
 ret

整体上主要完成了三件事情：

定义函数 main 的入口；
将函数返回值 0 放入规定的返回值寄存器；
执行函数返回。

因此，我们首先需要回答三个问题。

如何定义一个函数？

在高级语言中，我们习惯把函数理解成：

1
2
3
4


int main()
{
 return 0;
}

但从处理器的视角来看，函数本质上只是一段连续或逻辑关联的指令序列。

调用函数时，处理器跳转到这段指令序列的入口开始执行；函数执行结束时，再通过返回指令跳回调用者。

因此，在汇编层面，并不存在类似 C/C++ 中：

1

int main()

这样的“函数定义语法”。

我们真正需要做的，只是给这段指令的入口位置定义一个符号：

1

main:

这里的 main 是一个 label（标签）。汇编器会把它关联到当前位置对应的地址。之后，无论是链接器还是其他代码，都可以通过符号 main 找到这段代码的入口。

同时：

1

.globl main

用于声明 main 是一个全局符号，使这个符号可以被链接器看到。

而：

1

.text

则表示接下来的内容属于 .text 段，也就是程序的代码段。

因此：

1
2
3


 .text
 .globl main
main:

可以简单理解成：

接下来是一段代码，并且我们定义了一个可以被外部找到的函数入口 main。

至于函数如何返回，并不是函数标签本身负责的，而是函数内部生成的指令负责的。

如何在 RISC-V 中设置返回值？

函数调用不仅涉及“跳转到哪里”，还涉及调用者和被调用者之间如何传递参数、返回值，以及哪些寄存器需要保存等问题。

这些规则由 RISC-V Calling Convention（调用约定）规定。

对于整数返回值，RISC-V 使用：

作为返回值寄存器。

在 RV32 中，一个通用寄存器的宽度为 32 bit，因此 a0 和 a1 可以用于传递最多两个 XLEN 宽度的整数返回值。

不过对于我们现在的程序：

1
2
3
4


int main()
{
 return 0;
}

只有一个 int 类型返回值，因此只需要：

1

a0

也就是说：

1

return 0;

最终需要确保：

1

a0 = 0

随后再执行函数返回即可。

如何将整数加载到寄存器中？

接下来的问题就是：如何让：

1

a0 = 0

RISC-V 汇编器提供了一个非常方便的伪指令：

1

li rd, imm

其中：

rd 表示目标寄存器；
imm 表示立即数。

例如：

1

li a0, 0

表示：

将立即数 0 加载到寄存器 a0 中。

需要注意的是，li 是一个伪指令（pseudo-instruction），它并不一定直接对应某一条真实的 RISC-V 机器指令。

汇编器会根据立即数的大小，将它展开为一条或多条真正的 RISC-V 指令。例如对于较小的立即数：

1

li a0, 0

可以被展开成类似：

1

addi a0, zero, 0

至于具体如何展开，则交给汇编器处理即可。对于编译器前端和目前的简单代码生成器而言，我们直接生成 li 会方便很多。

函数最后的：

1

ret

同样也是一个伪指令。

它表示：

从当前函数返回到调用者。

其底层实际上可以展开为类似：

1

jalr zero, 0(ra)

其中 ra 保存了函数调用完成后应该返回的位置。

因此，我们生成：

1
2
3
4
5


 .text
 .globl main
main:
 li a0, 0
 ret

其含义可以完整地理解为：

1
2
3
4
5
6


 .text # 接下来的内容放入代码段
 .globl main # 将 main 声明为全局符号

main: # main 函数的入口
 li a0, 0 # 将返回值 0 放入 a0
 ret # 返回调用者

这就完成了：

1
2
3
4


int main()
{
 return 0;
}

最基本的目标代码生成。

接下来，我们就可以仿照上一节 Printer 的实现方式，设计一个 CodeGen 类：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


class CodeGen
{
public:
 std::string Generate(const Program& program) const;

private:
 void Visit(const Function& func, std::ostream& out) const;
 void Visit(
 const BasicBlock& block,
 const std::string& func_name,
 std::ostream& out
 ) const;

 void Visit(const Instruction& inst, std::ostream& out) const;
 void Visit(const Return& ret, std::ostream& out) const;

 void LoadOperand(
 const IRValue& value,
 const char* reg,
 std::ostream& out
 ) const;
};

它的整体结构和 Printer 非常相似。

我们仍然按照：

1
2
3
4
5
6
7


Program
 ↓
Function
 ↓
BasicBlock
 ↓
Instruction

这样的层次遍历 IR。

区别在于，之前的 Printer 只是把 IR 数据结构重新打印为 Koopa IR 文本，例如：

1

ret 0

而现在的 CodeGen 需要真正考虑目标机器的语义。

例如面对：

1

ret 0

我们不能简单地输出：

1

ret 0

而需要知道 RISC-V 的调用约定规定返回值应当放在 a0 中，因此要生成：

1
2


li a0, 0
ret

也就是说：

Printer 主要关心 IR 的语法，而 CodeGen 开始需要关心目标架构的 ABI、寄存器和指令。

因此，我们额外定义：

1

LoadOperand(...)

负责将一个 IR 操作数加载到指定寄存器。

目前我们的 IR 非常简单，操作数只有整数立即数，因此 LoadOperand 暂时只需要处理：

1

IRInteger

未来随着 IR 中出现临时变量、二元表达式、局部变量等内容，这个函数才会逐渐涉及寄存器和栈上的数据。

具体实现如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


std::string CodeGen::Generate(const Program& program) const
{
 std::ostringstream out;

 out << " .text\n";

 for (const auto& func : program.funcs)
 {
 Visit(*func, out);
 }

 return out.str();
}

Generate 是整个目标代码生成过程的入口。

首先：

1

out << " .text\n";

声明接下来生成的是代码段。

然后依次遍历程序中的所有函数：

1
2
3
4


for (const auto& func : program.funcs)
{
 Visit(*func, out);
}

虽然目前我们的程序中只有一个：

1

main

但是从数据结构和代码生成器的设计上，我们仍然按照“一个程序可以包含多个函数”的方式实现。

接下来处理函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


void CodeGen::Visit(const Function& func, std::ostream& out) const
{
 out << " .globl " << func.name << "\n";
 out << func.name << ":\n";

 for (const auto& block : func.bbs)
 {
 Visit(*block, func.name, out);
 }

 out << "\n";
}

对于每个函数，首先生成：

1
2


.globl main
main:

分别对应：

1
2


out << " .globl " << func.name << "\n";
out << func.name << ":\n";

随后遍历函数中的所有基本块：

1
2
3
4


for (const auto& block : func.bbs)
{
 Visit(*block, func.name, out);
}

目前我们的 main 只有一个基本块：

1

%entry

并且不存在跳转，因此还不需要真的为 %entry 生成汇编标签。

后面当程序出现：

1
2


if
while

等控制流结构时，一个函数中会出现多个基本块。此时我们就需要为不同的基本块生成标签，例如：

1
2
3
4


main_entry:
main_then:
main_else:
main_end:

这里将 func.name 一并传给 Visit(BasicBlock)，也正是为了给后续生成基本块标签预留上下文。

目前基本块本身只需要继续遍历其中的指令：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


void CodeGen::Visit(
 const BasicBlock& bb,
 const std::string& func_name,
 std::ostream& out
) const
{
 for (const auto& inst : bb.insts)
 {
 Visit(*inst, out);
 }
}

接下来根据指令类型进行分派：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


void CodeGen::Visit(const Instruction& inst, std::ostream& out) const
{
 switch (inst.kind)
 {
 case ValueKind::Return:
 {
 Visit(static_cast<const Return&>(inst), out);
 return;
 }

 default:
 {
 throw std::runtime_error(
 "unsupported instruction kind: " +
 std::to_string(static_cast<int>(inst.kind))
 );
 }
 }
}

目前我们的 IR 中唯一可能出现的指令就是：

1

Return

因此只需要处理：

1

ValueKind::Return

即可。

对于：

1

ret 0

对应的 IR 大致可以理解为：

1
2
3


Return
└── operand
 └── Integer(0)

因此在处理 Return 时：

1
2
3
4
5


void CodeGen::Visit(const Return& ret, std::ostream& out) const
{
 LoadOperand(*ret.operand, "a0", out);
 out << " ret\n";
}

我们首先调用：

1

LoadOperand(*ret.operand, "a0", out);

含义就是：

将 return 的操作数加载到返回值寄存器 a0。

随后：

1

out << " ret\n";

生成函数返回指令。

最后实现 LoadOperand：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


void CodeGen::LoadOperand(
 const IRValue& value,
 const char* reg,
 std::ostream& out
) const
{
 switch (value.kind)
 {
 case ValueKind::Integer:
 {
 const auto& integer =
 static_cast<const IRInteger&>(value);

 out << " li " << reg << ", "
 << integer.value << "\n";

 return;
 }

 default:
 {
 throw std::runtime_error(
 "unsupported value kind: " +
 std::to_string(static_cast<int>(value.kind))
 );
 }
 }
}

目前 LoadOperand 只需要处理整数立即数。

例如：

1

IRInteger(0)

并要求加载到：

1

a0

最终就会生成：

1

li a0, 0

于是整个调用过程就是：

1
2
3
4
5
6
7
8
9


Generate(Program)
 ↓
Visit(Function main)
 ↓
Visit(BasicBlock entry)
 ↓
Visit(Return)
 ↓
LoadOperand(Integer(0), a0)

最终输出：

1
2
3
4
5


 .text
 .globl main
main:
 li a0, 0
 ret

至此，我们的编译器已经第一次完成了一条完整的编译链：

1
2
3
4
5
6
7


SysY
 ↓
AST
 ↓
Koopa IR
 ↓
RISC-V Assembly

虽然目前支持的程序只有最简单的：

1
2
3
4


int main()
{
 return 0;
}

但这里建立起来的 CodeGen 框架之后基本可以继续沿用。

随着后面的 SysY 语法逐渐复杂，我们主要需要不断扩展：

1

Visit(...)

来支持新的 IR 指令，并逐步完善：

1

LoadOperand(...)

对临时变量、寄存器和栈上数据的处理。

[从零开始的编译原理][实验] Exp Chapter 0：实验环境搭建

Mon, 28 Sep 2026 16:36:25 +0800

Docker配置

根据课程指导书的要求，我们通过Docker拉取对应的镜像:

1

docker pull maxxing/compiler-dev

下面简单介绍一下Docker的使用方法。

首先我们需要简单区分一下镜像(image)和容器(container),前者可以看作是一个硬盘，里面装好了操作系统，但它是静态的，不能直接拿来运行。而后者则是一台计算机，里面装了硬盘，就能运行对应的操作系统。

在实际情况中，我们可以在容器中对文件系统进行修改，例如创建和删除文件，但是镜像不会受到影响。

通常而言，我们只希望在镜像的环境做一些一次性的工作，比如用里面的测试脚本来测试自己的编译器，然后查看测试结果。在此之后这个临时容器就没有任何作用了。

例如我们希望在上面image的环境中执行如下命令:ls -l /，那么我可以输入指令:

1

docker run maxxing/compiler-dev ls -l /

然后此时终端就会显示命令ls -l /的结果，此时会生成一个临时容器，我们可以用指令:docker ps -a查看:

1
2
3


user@macbook compiler % docker ps -a 
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
441f432b9731 maxxing/compiler-dev "ls -l" 3 seconds ago Exited (0) 3 seconds ago hopeful_shannon

那么我们可以通过指令:docker rm 441f432b9731来删除这个容器。

当然我们还可以将上述执行命令-删除临时容器的操作合并为一个指令:

1

docker run --rm maxxing/compiler-dev ls -l /

这样创造临时容器，运行完指令后，就会直接把临时容器给删掉了。

有时候，可能我们期望在容器中执行的命令很复杂，不能一行输入完整，那么此时我们可以使用

1

docker run -it --rm maxxing/compiler-dev bash

这样我们就创建了临时容器后，执行了bash指令，就可以在容器内的shell中工作输入任何指令了。其中-it参数是为了开启容器的stdin。

如果需要退出，直接输入exit即可

在大部分情况下，我们还希望Docker容器能够访问宿主机中的文件，如我们实现的编译器位于宿主机的/path/to/compiler目录下，我们希望 Docker 容器也能访问到这个目录里的内容, 这样你就可以使用容器中的测试脚本测试你的编译器了. 可以执行:

1

docker run -it --rm -v /path/to/compiler:/root/compiler maxxing/compiler-dev bash

这条命令多了一个-v参数，它的作用是把宿主机的某个目录挂载到容器的某个目录（例如上面指令是/root/compiler）。这样，在进入容器之后，就可以通过访问挂载的目录访问宿主机的目录了。

Koopa IR介绍

Koopa IR是一种简化后的中间表示，在设计上类似LLVM IR。同时我们在后续lab中会用到对应的框架:

https://github.com/pku-minic/koopa

Koopa IR 是一种强类型的 IR, IR 中的所有值 (Value) 和函数 (Function) 都具备类型 (Type).

Koopa IR 中, 基本块 (basic block) 必须是显式定义的. 即, 在描述函数内的指令时, 你必须把指令按照基本块分组, 每个基本块结尾的指令只能是分支/跳转/函数返回指令之一. 在 IR 的数据结构表示上, 指令也会被按照基本块分类. 这很大程度上方便了 IR 的优化, 因为许多优化算法都是在基本块的基础上对程序进行分析/变换的.

假设我们有一个用Koopa IR编写的程序（见指导书中的"hello world!"），我们将其保存在了文件hello.koopa中，那么我们可以在实验环境中运行这个koopa IR程序:

1
2
3


koopac hello.koopa | llc --filetype=obj -o hello.o
clang hello.o -L$CDE_LIBRARY_PATH/native -lsysy -o hello
./hello

RISC-V介绍

我们的编译器最终会生成RISC-V汇编。

RISC-V的指令系统由

基础指令系统 (base instruction set) 和指令系统扩展 (extension) 构成. 每个 RISC-V 处理器必须实现基础指令系统, 同时可以支持若干扩展. 常用的基础指令系统有两种:

RV32I: 32 位整数指令系统.
RV64I: 64 位整数指令系统. 兼容 RV32I.

常用的标准指令系统扩展包括:

M 扩展: 包括乘法和除法相关的指令.
A 扩展: 包括原子内存操作相关的指令.
F 扩展: 包括单精度浮点操作相关的指令.
D 扩展: 包括双精度浮点操作相关的指令.
C 扩展: 包括常用指令的 16 位宽度的压缩版本.

我们通常使用 RV32/64I + 扩展名称的方式来描述某个处理器/平台支持的 RISC-V 指令系统类型, 例如 RV32IMA 代表这个处理器是一个 32 位的, 支持 M 和 A 扩展的 RISC-V 处理器.

在我们的Lab中，我们编译器将生成RV32IM范围内的RISC-V汇编。

假设我们有一段RISC-V的汇编程序:hello.S，我们可以在实验环境中将这个RISC-V程序汇编并链接为可执行文件并运行起来:

1
2
3


clang hello.S -c -o hello.o -target riscv32-unknown-linux-elf -march=rv32im -mabi=ilp32
ld.lld hello.o -L$CDE_LIBRARY_PATH/riscv32 -lsysy -o hello
qemu-riscv32-static hello

编程语言选择

为了方便起见，我最终还是选择使用C++进行开发。

我们使用CMake模版:https://github.com/pku-minic/sysy-cmake-template

配置好环境后，我们可以进入docker环境中，执行命令:

1
2


cmake -DCMAKE_BUILD_TYPE=Debug -B build
cmake --build build

构建编译器，后续如果我们更改了代码，则仅仅需要通过:

1

cmake --build build

即可。