本章是“手把手教你構建 C 語言編譯器”系列的第三篇，本章我們要構建一臺虛擬的電腦，設計我們自己的指令集，執行我們的指令集，說得通俗一點就是自己實現一套匯編語言。它們將作為我們的編譯器最終輸出的目的碼。

手把手教你構建 C 語言編譯器系列共有10個部分：

#計算機的內部工作原理

計算機中有三個基本部件需要我們關注：CPU、暫存器及記憶體。程式碼（彙編指令）以二進位制的形式儲存在記憶體中；CPU 從中一條條地載入指令執行；程式執行的狀態儲存在暫存器中。

#記憶體

記憶體用於儲存資料，這裡的資料可以是程式碼，也可以是其它的資料。現代作業系統在操作記憶體時，並不是直接處理”實體記憶體“，而是操作”虛擬記憶體“。虛擬記憶體可以理解為一種對映，它的作用是遮蔽了物理的細節。例如 32 位的機器中，我們可以使用的記憶體地址為 2^32 = 4G

當然，我們這裡並不需要了解太多，但需要了解的是：程序的記憶體會被分成幾個段：

1. 程式碼段（text）用於存放程式碼（指令）。
2. 資料段（data）用於存放初始化了的資料，如int i = 10;，就需要存放到資料段中。
3. 未初始化資料段（bss）用於存放未初始化的資料，如 int i[1000];，因為不關心其中的真正數值，所以單獨存放可以節省空間，減少程式的體積。
4. 棧（stack）用於處理函式呼叫相關的資料，如呼叫幀（calling frame）或是函式的區域性變數等。
5. 堆（heap）用於為程式動態分配記憶體。

它們在記憶體中的位置類似於下圖：

+------------------+
|    stack   |     |      high address
|    ...     v     |
|                  |
|                  |
|                  |
|                  |
|    ...     ^     |
|    heap    |     |
+------------------+
| bss  segment     |
+------------------+
| data segment     |
+------------------+
 

| text segment     |      low address
+------------------+

我們的虛擬機器並不打算模擬完整的計算機，因此簡單起見，我們只關心三個內容：程式碼段、資料段以及棧。其中的資料段我們只用來存放字串，因為我們的編譯器並不支援初始化變數，因此我們也不需要未初始化資料段。

當用戶的程式需要分配記憶體時，理論上我們的虛擬機器需要維護一個堆用於記憶體分配，但實際實現上較為複雜且與編譯無關，故我們引入一個指令MSET，使我們能直接使用編譯器（直譯器）中的記憶體。

綜上，我們需要首先在全域性新增如下程式碼：

int *text,            // text segment
    *old_text,        // for dump text segment
    *stack;           // stack
char *data;           // data segment

注意這裡的型別，雖然是int型，但理解起來應該作為無符號的整型，因為我們會在程式碼段（text）中存放如指標/記憶體地址的資料，它們就是無符號的。其中資料段（data）由於只存放字串，所以是 char * 型的。

接著，在main函式中加入初始化程式碼，真正為其分配記憶體：

int main() {
    close(fd);
    ...

    // allocate memory for virtual machine
    if (!(text = old_text = malloc(poolsize))) {
        printf("could not malloc(%d) for text area\n", poolsize);
        return -1;
    }
    if (!(data = malloc(poolsize))) {
        printf("could not malloc(%d) for data area\n", poolsize);
        return -1;
    }
    if (!(stack = malloc(poolsize))) {
        printf("could not malloc(%d) for stack area\n", poolsize);
        return -1;
    }

    memset(text, 0, poolsize);
    memset(data, 0, poolsize);
    memset(stack, 0, poolsize);

    ...
    program();
}

#暫存器

計算機中的暫存器用於存放計算機的執行狀態，真正的計算機中有許多不同種類的暫存器，但我們的虛擬機器中只使用 4 個暫存器，分別如下：

1. PC 程式計數器，它存放的是一個記憶體地址，該地址中存放著 下一條 要執行的計算機指令。
2. SP 指標暫存器，永遠指向當前的棧頂。注意的是由於棧是位於高地址並向低地址增長的，所以入棧時 SP 的值減小。
3. BP 基址指標。也是用於指向棧的某些位置，在呼叫函式時會使用到它。
4. AX 通用暫存器，我們的虛擬機器中，它用於存放一條指令執行後的結果。

要理解這些暫存器的作用，需要去理解程式執行中會有哪些狀態。而這些暫存器只是用於儲存這些狀態的。

在全域性中加入如下定義：

int *pc, *bp, *sp, ax, cycle; // virtual machine registers

在 main 函式中加入初始化程式碼，注意的是PC在初始應指向目的碼中的main函式，但我們還沒有寫任何編譯相關的程式碼，因此先不處理。程式碼如下：

memset(stack, 0, poolsize);
...

bp = sp = (int *)((int)stack + poolsize);
ax = 0;

...
program();

與 CPU 相關的是指令集，我們將專門作為一個小節。

#指令集

指令集是 CPU 能識別的命令的集合，也可以說是 CPU 能理解的語言。這裡我們要為我們的虛擬機器構建自己的指令集。它們基於 x86 的指令集，但更為簡單。

首先在全域性變數中加入一個列舉型別，這是我們要支援的全部指令：

// instructions
enum { LEA ,IMM ,JMP ,CALL,JZ  ,JNZ ,ENT ,ADJ ,LEV ,LI  ,LC  ,SI  ,SC  ,PUSH,
       OR  ,XOR ,AND ,EQ  ,NE  ,LT  ,GT  ,LE  ,GE  ,SHL ,SHR ,ADD ,SUB ,MUL ,DIV ,MOD ,
       OPEN,READ,CLOS,PRTF,MALC,MSET,MCMP,EXIT };

這些指令的順序安排是有意的，稍後你會看到，帶有引數的指令在前，沒有引數的指令在後。這種順序的唯一作用就是在列印除錯資訊時更加方便。但我們講解的順序並不依據它。

#MOV

MOV 是所有指令中最基礎的一個，它用於將資料放進暫存器或記憶體地址，有點類似於 C 語言中的賦值語句。x86 的 MOV 指令有兩個引數，分別是源地址和目標地址：MOV dest, source （Intel 風格），表示將 source 的內容放在 dest 中，它們可以是一個數、暫存器或是一個記憶體地址。

一方面，我們的虛擬機器只有一個暫存器，另一方面，識別這些引數的型別（是資料還是地址）是比較困難的，因此我們將 MOV 指令拆分成 5 個指令，這些指令只接受一個引數，如下：

1. IMM <num> 將 <num> 放入暫存器 ax 中。
2. LC 將對應地址中的字元載入 ax 中，要求 ax 中存放地址。
3. LI 將對應地址中的整數載入 ax 中，要求 ax 中存放地址。
4. SC 將 ax 中的資料作為字元存放入地址中，要求棧頂存放地址。
5. SI 將 ax 中的資料作為整數存放入地址中，要求棧頂存放地址。

你可能會覺得將一個指令變成了許多指令，整個系統就變得複雜了，但實際情況並非如此。首先是 x86 的 MOV 指令其實有許多變種，根據型別的不同有 MOVB, MOVW 等指令，我們這裡的 LC/SC 和 LI/SI 就是對應字元型和整型的存取操作。

但最為重要的是，通過將 MOV 指令拆分成這些指令，只有 IMM 需要有引數，且不需要判斷型別，所以大大簡化了實現的難度。

在 eval() 函式中加入下列程式碼：

void eval() {
    int op, *tmp;
    while (1) {
        if (op == IMM)       {ax = *pc++;}                                     // load immediate value to ax
        else if (op == LC)   {ax = *(char *)ax;}                               // load character to ax, address in ax
        else if (op == LI)   {ax = *(int *)ax;}                                // load integer to ax, address in ax
        else if (op == SC)   {ax = *(char *)*sp++ = ax;}                       // save character to address, value in ax, address on stack
        else if (op == SI)   {*(int *)*sp++ = ax;}                             // save integer to address, value in ax, address on stack
    }

    ...
    return 0;
}

其中的 *sp++ 的作用是退棧，相當於 POP 操作。

這裡要解釋的一點是，為什麼 SI/SC 指令中，地址存放在棧中，而 LI/LC 中，地址存放在 ax 中？原因是預設計算的結果是存放在 ax 中的，而地址通常是需要通過計算獲得，所以執行 LI/LC 時直接從 ax 取值會更高效。另一點是我們的 PUSH 指令只能將 ax 的值放到棧上，而不能以值作為引數，詳細見下文。

#PUSH

在 x86 中，PUSH 的作用是將值或暫存器，而在我們的虛擬機器中，它的作用是將 ax 的值放入棧中。這樣做的主要原因是為了簡化虛擬機器的實現，並且我們也只有一個暫存器 ax 。程式碼如下：

else if (op == PUSH) {*--sp = ax;}                                     // push the value of ax onto the stack

#JMP

JMP <addr> 是跳轉指令，無條件地將當前的 PC 暫存器設定為指定的 <addr>，實現如下：

else if (op == JMP)  {pc = (int *)*pc;}                                // jump to the address

需要注意的是，pc 暫存器指向的是 下一條 指令。所以此時它存放的是 JMP 指令的引數，即 <addr> 的值。

#JZ/JNZ

為了實現 if 語句，我們需要條件判斷相關的指令。這裡我們只實現兩個最簡單的條件判斷，即結果（ax）為零或不為零情況下的跳轉。

實現如下：

else if (op == JZ)   {pc = ax ? pc + 1 : (int *)*pc;}                   // jump if ax is zero
else if (op == JNZ)  {pc = ax ? (int *)*pc : pc + 1;}                   // jump if ax is zero

#子函式呼叫

這是彙編中最難理解的部分，所以合在一起說，要引入的命令有 CALL, ENT, ADJ 及 LEV。

首先我們介紹 CALL <addr> 與 RET 指令，CALL 的作用是跳轉到地址為 <addr> 的子函式，RET 則用於從子函式中返回。

為什麼不能直接使用 JMP 指令呢？原因是當我們從子函式中返回時，程式需要回到跳轉之前的地方繼續執行，這就需要事先將這個位置資訊儲存起來。反過來，子函式要返回時，就需要獲取並恢復這個資訊。因此實際中我們將 PC 儲存在棧中。如下：

else if (op == CALL) {*--sp = (int)(pc+1); pc = (int *)*pc;}           // call subroutine
//else if (op == RET)  {pc = (int *)*sp++;}                              // return from subroutine;

這裡我們把 RET 相關的內容註釋了，是因為之後我們將用 LEV 指令來代替它。

在實際呼叫函式時，不僅要考慮函式的地址，還要考慮如何傳遞引數和如何返回結果。這裡我們約定，如果子函式有返回結果，那麼就在返回時儲存在 ax 中，它可以是一個值，也可以是一個地址。那麼引數的傳遞呢？

各種程式語言關於如何呼叫子函式有不同的約定，例如 C 語言的呼叫標準是：

1. 由呼叫者將引數入棧。
2. 呼叫結束時，由呼叫者將引數出棧。
3. 引數逆序入棧。

事先宣告一下，我們的編譯器引數是順序入棧的，下面的例子（C 語言呼叫標準）取自 維基百科：

int callee(int, int, int);

int caller(void)
{
	int i, ret;

	ret = callee(1, 2, 3);
	ret += 5;
	return ret;
}

會生成如下的 x86 彙編程式碼：

caller:
	; make new call frame
	push    ebp
	mov     ebp, esp
        sub     1, esp       ; save stack for variable: i
	; push call arguments
	push    3
	push    2
	push    1
	; call subroutine 'callee'
	call    callee
	; remove arguments from frame
	add     esp, 12
	; use subroutine result
	add     eax, 5
	; restore old call frame
        mov     esp, ebp
	pop     ebp
	; return
	ret

上面這段程式碼在我們自己的虛擬機器裡會有幾個問題：

1. push ebp，但我們的 PUSH 指令並無法指定暫存器。
2. mov ebp, esp，我們的 MOV 指令同樣功能不足。
3. add esp, 12，也是一樣的問題（儘管我們還沒定義）。

也就是說由於我們的指令過於簡單（如只能操作ax暫存器），所以用上面提到的指令，我們連函式呼叫都無法實現。而我們又不希望擴充現有指令的功能，因為這樣實現起來就會變得複雜，因此我們採用的方法是增加指令集。畢竟我們不是真正的計算機，增加指令會消耗許多資源（錢）。

#ENT

ENT <size> 指的是 enter，用於實現 ‘make new call frame’ 的功能，即儲存當前的棧指標，同時在棧上保留一定的空間，用以存放區域性變數。對應的彙編程式碼為：

; make new call frame
push    ebp
mov     ebp, esp
       sub     1, esp       ; save stack for variable: i

實現如下：

else if (op == ENT)  {*--sp = (int)bp; bp = sp; sp = sp - *pc++;}      // make new stack frame

#ADJ

ADJ <size> 用於實現 ‘remove arguments from frame’。在將呼叫子函式時壓入棧中的資料清除，本質上是因為我們的 ADD 指令功能有限。對應的彙編程式碼為：

; remove arguments from frame
add     esp, 12

實現如下：

else if (op == ADJ)  {sp = sp + *pc++;}                                // add esp, <size>

#LEV

本質上這個指令並不是必需的，只是我們的指令集中並沒有 POP 指令。並且三條指令寫來比較麻煩且浪費空間，所以用一個指令代替。對應的彙編指令為：

; restore old call frame
       mov     esp, ebp
pop     ebp
; return
ret

具體的實現如下：

else if (op == LEV)  {sp = bp; bp = (int *)*sp++; pc = (int *)*sp++;}  // restore call frame and PC

注意的是，LEV 已經把 RET 的功能包含了，所以我們不再需要 RET 指令。

#LEA

上面的一些指令解決了呼叫幀的問題，但還有一個問題是如何在子函式中獲得傳入的引數。這裡我們首先要了解的是當引數呼叫時，棧中的呼叫幀是什麼樣的。我們依舊用上面的例子（只是現在用“順序”呼叫引數）：

sub_function(arg1, arg2, arg3);

|    ....       | high address
+---------------+
| arg: 1        |    new_bp + 4
+---------------+
| arg: 2        |    new_bp + 3
+---------------+
| arg: 3        |    new_bp + 2
+---------------+
|return address |    new_bp + 1
+---------------+
| old BP        | <- new BP
+---------------+
| local var 1   |    new_bp - 1
+---------------+
| local var 2   |    new_bp - 2
+---------------+
|    ....       |  low address

所以為了獲取第一個引數，我們需要得到 new_bp + 4，但就如上面的說，我們的 ADD 指令無法操作除 ax 外的暫存器，所以我們提供了一個新的指令：LEA <offset>

實現如下：

else if (op == LEA)  {ax = (int)(bp + *pc++);}                         // load address for arguments.

以上就是我們為了實現函式呼叫需要的指令了。

#運算子指令

我們為 C 語言中支援的運算子都提供對應彙編指令。每個運算子都是二元的，即有兩個引數，第一個引數放在棧頂，第二個引數放在 ax 中。這個順序要特別注意。因為像 -，/ 之類的運算子是與引數順序有關的。計算後會將棧頂的引數退棧，結果存放在暫存器 ax 中。因此計算結束後，兩個引數都無法取得了（彙編的意義上，存在記憶體地址上就另當別論）。

實現如下：

else if (op == OR)  ax = *sp++ | ax;
else if (op == XOR) ax = *sp++ ^ ax;
else if (op == AND) ax = *sp++ & ax;
else if (op == EQ)  ax = *sp++ == ax;
else if (op == NE)  ax = *sp++ != ax;
else if (op == LT)  ax = *sp++ < ax;
else if (op == LE)  ax = *sp++ <= ax;
else if (op == GT)  ax = *sp++ >  ax;
else if (op == GE)  ax = *sp++ >= ax;
else if (op == SHL) ax = *sp++ << ax;
else if (op == SHR) ax = *sp++ >> ax;
else if (op == ADD) ax = *sp++ + ax;
else if (op == SUB) ax = *sp++ - ax;
else if (op == MUL) ax = *sp++ * ax;
else if (op == DIV) ax = *sp++ / ax;
else if (op == MOD) ax = *sp++ % ax;

#內建函式

寫的程式要”有用“，除了核心的邏輯外還需要輸入輸出，例如 C 語言中我們經常使用的 printf 函式就是用於輸出。但是 printf 函式的實現本身就十分複雜，如果我們的編譯器要達到自舉，就勢必要實現 printf 之類的函式，但它又與編譯器沒有太大的聯絡，因此我們繼續實現新的指令，從虛擬機器的角度予以支援。

編譯器中我們需要用到的函式有：exit, open, close, read, printf, malloc, memset 及 memcmp。程式碼如下：

else if (op == EXIT) { printf("exit(%d)", *sp); return *sp;}
else if (op == OPEN) { ax = open((char *)sp[1], sp[0]); }
else if (op == CLOS) { ax = close(*sp);}
else if (op == READ) { ax = read(sp[2], (char *)sp[1], *sp); }
else if (op == PRTF) { tmp = sp + pc[1]; ax = printf((char *)tmp[-1], tmp[-2], tmp[-3], tmp[-4], tmp[-5], tmp[-6]); }
else if (op == MALC) { ax = (int)malloc(*sp);}
else if (op == MSET) { ax = (int)memset((char *)sp[2], sp[1], *sp);}
else if (op == MCMP) { ax = memcmp((char *)sp[2], (char *)sp[1], *sp);}

這裡的原理是，我們的電腦上已經有了這些函式的實現，因此編譯編譯器時，這些函式的二進位制程式碼就被編譯進了我們的編譯器，因此在我們的編譯器/虛擬機器上執行我們提供的這些指令時，這些函式就是可用的。換句話說就是不需要我們自己去實現了。

最後再加上一個錯誤判斷：

else {
    printf("unknown instruction:%d\n", op);
    return -1;
}

#測試

下面我們用我們的彙編寫一小段程式，來計算 10+20，在 main 函式中加入下列程式碼：

int main(int argc, char *argv[])
{
    ax = 0;
    ...

    i = 0;
    text[i++] = IMM;
    text[i++] = 10;
    text[i++] = PUSH;
    text[i++] = IMM;
    text[i++] = 20;
    text[i++] = ADD;
    text[i++] = PUSH;
    text[i++] = EXIT;
    pc = text;

    ...
    program();
}

編譯程式 gcc xc-tutor.c，執行程式：./a.out hello.c。輸出

exit(30)

注意我們的之前的程式需要指令一個原始檔，只是現在還用不著，但從結果可以看出，我們的虛擬機器還是工作良好的。

#小結

本章中我們回顧了計算機的內部執行原理，並仿照 x86 彙編指令設計並實現了我們自己的指令集。希望通過本章的學習，你能對計算機程式的原理有一定的瞭解，同時能對組合語言有一定的概念，因為組合語言就是 C 編譯器的輸出。

本章的程式碼可以在 Github 上下載，也可以直接 clone

git clone -b step-1 https://github.com/lotabout/write-a-C-interpreter

實際計算機中，新增一個新的指令需要設計許多新的電路，會增加許多的成本，但我們的虛擬機器中，新的指令幾乎不消耗資源，因此我們可以利用這一點，用更多的指令來完成更多的功能，從而簡化具體的實現。