cucu: a compiler u can understand (part 3)

现在让我们谈谈编译器的后端架构。C语言应该是一个可以移植的语言，但是在移植的过程中，我们并没有必要为新的CPU架构去重新编写整个C的编译器。编译器后端用来产生低级别字节码，而编译器前端会调用编译器后端的函数。一个好的后端设计会使得编译器具有良好的移植性。

我希望CUCU成为一个可以移植的编译器（也就是所谓的交叉编译）。因此我打算将后端代码写到一个独立的模块里。

但在我们具体考虑一个后端代码之前，我们还有很多工作要做。

简化的CPU架构 

我们间滑过的CPU架构含有两个寄存器（我们记作A和B）和一个栈。寄存器A是一个累加器。像很多RISC的CPU一样，我们将使用定长指令集，为了更加有趣一些，我们并不把指令变成16进制代码，而采用较为自然的方式呈现。

我使用一种简单的方式设计指令。每一个指令8字节长（的确，这有点长，但是没有关系，毕竟这是一个假象的架构）。开头的7个字节是ASCII的符号，最后一个是0x10('\n')。

这就让我们可以设计出更易于阅读的指令，比如A:=A+B, A:=1ef8,或 push A。这些指令基本上都是自解释的了（“将B寄存器的内容加给A寄存器”，“将0x1ef8放入A寄存器”和“将寄存器A的值压入堆栈”）。

• A:=NNNN - 将0xNNNN放入寄存器A。
• A:=m[A] - 将地址为寄存器A中的值处的内容（作为字节）存入寄存器A中
• A:=M[A] -将地址为寄存器A中的值处的内容（作为int型变量）存入寄存器A中
• m[B]:=A - 将寄存器A中的值存入寄存器B所指向的地址处（作为字节）。
• M[B]:=A - 将寄存器A中的值存入寄存器B所指向的地址处（作为int型变量）。
• push A - 将寄存器A中的值压入队长。
• pop B - 将栈顶元素出栈并放入寄存器B。
• A:=B+A - 将A和B的值相加并将结果放入A。
• A:=B-A - B减A并将结果存入A。
• A:=B&A - 按位与。
• A:=B|A - 按位或。
• A:=B!=A -若B!=A，则A为1，否则A为0.
• A:=B==A - 若B==A，则A为1，否则A为0
• A:=B<<A - 将B中的值左移A位并将结果存入A。
• A:=B>>A - 将B中的值右移A位并将结果存入A。
• A:=B<A - 若B<A ，则A为1，否则A为0.
• popNNNN - 将栈中的NNNN个元素出栈。
• sp@NNNN - 将栈中地址是NNNN的元素的值放入寄存器A。
• jmpNNNN - 程序跳转到NNNN地址处继续执行。
• jpzNNNN - 若A的值是0，则跳转到NNNN处执行。
• call A - 调用地址存在A中的函数。
• ret - 从函数中返回

CUCU后端架构设计

当我们包含“gen.c” 这个文件时，实际上就是包含了一个后端架构的具体实现。让我们从两个最基本的函数开始：: gen_start() 和 gen_finish(). 这两个函数用来生成程序头（比如PE头和ELF头）和一些预处理过的字节码。

编译器使用一个函数 emit(), 来将字节码发射到code[]数组中。这个数组的每一个元素都代表着一个可以使用的编译好的程序。

因此，编译器只调用后端架构提供的借口，而后端架构调用emit()来生成特定的字节码，这就是编译器编译出机器语言的过程。

因此，现在我们需要定义出最常用的一些指令，然后让后端架构去实现。让我们从一个最简单的程序开始。

int main() {
    return 0;
}

让我们分析下函数调用的过程。这个过程也就是函数参数如何传递给函数体以及返回值如何处理的过程。我们在前面也已经说过了，参数是放在栈顶进行传递的（第一个参数第一个压栈）。让我们再做个约定，寄存器A带有函数的返回值。

事实上，我们使用寄存器A来存储所有的值，寄存器B只用来存储临时变量。

对于上述程序，我们期待的字节码应该有如下的形式:

A:=0000
ret

因此我们需要一个函数来将立即数存入寄存器A，还需要一个函数用来处理返回。我们把这两个函数定义为gen_const(int)和gen_ret()。

    当编译器发现一个主表达式是立即数的时候，gen_const就会被调用，当发现一个return语句时，gent_ret就会被调用。虽然，有些函数的类型是void，因此其没有显式的Return。但为了安全和简单，在每一个函数的结尾，我们都会去调用一次gen_ret()，即使其前面有一个显式的return。

我们的编译器并不追求优化、效率和安全，因此这种双return的方式对于我们是可行的。

数学运算

现在让我们来编译数学表达式。这些数学表达式都很相似，因此我们使用一个例子来说明编译器是如何处理的。还记得词法分析器如何工作吗？它分析（更严谨的说法是编译）表达式左值，表达式右值然后才是运算符。

这就是一个典型的数学表达式编译的过程（还记得把大象装进冰箱的笑话吗）：

..计算左值
push A
..计算右值
pop B
A:=A+B

当我们计算完左值的时候我们需要暂存结果。使用堆栈是一个很好的选择。因此一个表达式1+2+3我们将会编译成如下的形式：

A:=0001  -+     -+
push A    |      |
A:=0002   | 1+2  |
pop B     |      |
A:=A+B   -+      | +3
push A           |
A:=0003          |
pop B            |
A:=A+B       ----+

一些其它的东西

处理符号也同样很简单。

为了调用一个函数，我们首先要把其地址放入寄存器A，然后使用gen_call()产生代码call A。

要访问局部变量则使用gen_stack_addr然后返回这个变量在堆栈中的地址。

访问全局变量则使用gen_sym_addr()。除此之外，每次建立一个新的符号编译器就需要产生一些代码（比如汇编代码），gen_sym用于处理这些情况。

gen_pop 从堆栈顶弹出N个元素，同时增加栈顶指针。

gen_unref用于产生一些指针相关操作。根据类型的不同（byte或者int），会产生A:=m[A] or A:=M[A] 代码。

gen_array将一个数组地址压入栈顶。

最后，当遇到if/while语句的时候，gen_patch用于追加产生地址跳转的代码。为什么说是追加呢？因为当我们遇到需要跳转的语句时需要跳转的地址是未知的，这个地址依赖于编译后的语句块的大小。因此需要在语句块编译结束后进行追加地址跳转的代码。

差不多要成功了，让我们试试以下的程序:

int main() {
    int k;
    k = 3;
    if (k == 0) {
        return 1;
    }
    return 0;
}

jmp0008 # 由gen_start()产生，跳转到main，地址为0x08
push A  # 为局部变量K申请空间
sp@0000 # 取得刚才申请的空间的地址
push A  # 将这个地址入栈
A:=0003 # 将3存入A里
pop B   # 取得之前存入的K的地址
M[B]:=A # 将A中的值作为int放入K中
sp@0000 # 取得K的地址
A:=M[A] # 取得其中的值作为int存入A
push A  # 存这个值
A:=0000 # 将A的值置0
pop B   # 取得之前存入的K的值
A:=B==A # 比较A和B的值 (也就是"k" 和 0)
jmz0090 # 如果是假(A!=B, k!=0) - 跳转到 to 0x90
A:=0001 # 把1放入A中作为返回值
pop0001 # 释放堆栈中存储k的值的空间
ret     # return
jmp0090 # else分支内容在此，下一条语句地址是0x90
A:=0000 # 把0放入A中作为返回值

pop0001 # 释放堆栈中存储k的值的空间

ret     # return
ret     # 之前为了安全考虑的第二次return

虽然我们的代码又乱又臃肿，但它的确能工作。更重要的是，你现在能弄明白编译器的工作原理并且可以自己动手做一个自己的编译器。

但是，我必须警告你。。。

警告

请千万不要按以上的步骤那么做！如果你要写一个自己的编译器，建议使用以下成熟的工具：

• flex/lex/jlex/...
• yacc/bison/cup...
• ANTLR
• Ragel
• and many others

除此之外，你想要一些专业的文献，比如龙书（《编译原理》，译者注）。并且coursera.org上的课程或许对你会有帮助。

如果你需要使你的系统可以适应现有的语言，你可以去了解LLVM的后端和GCC的后端。

如果你需要一些更多地关于玩具编译器的信息，可以去了解一下SmallC。

如果你想写一个简单的语言编译器，可以去了解一下PL/0或者Basic或者C。

但是请千万不要去从头写一个编译器并把它用在实际的工作中。

后记

整个项目的代码可以在这里找到。授权给MIT，任何人都可以免费使用或者修改。

不管如何，编译器是个很有趣的东西。我希望你能喜欢它。