1. 要編譯的測試代碼：
|
1
2
3
4
5
6
7
|
int plus(int x, int y) { return x + y;}int main(void) { return plus(3, 4);} |
2. main中return語句語法分析
|
1
2
3
4
5
6
7
8
9
10
11
|
if (equal(tok, "return")) { Node *node = new_node(ND_RETURN, tok); if (consume(rest, tok->next, ";")) return node; Node *exp = expr(&tok, tok->next); *rest = skip(tok, ";"); node->lhs = exp; return node; } |
2.1 當前token為return
則創建類型為ND_RETURN的node。
2.2 由于return后面跟著plus(3, 4)
所以調用expr函數解析這個表達式。
2.3 跳過"；"符號。
2.4 將類型為ND_RETURN的node的左表達式設置為類型為ND_CAST的node。
3. expr的處理
3.1 解析"plus"
|
1
2
3
4
5
6
7
8
9
10
|
if (tok->kind == TK_IDENT) { VarScope *sc = find_var(tok); return new_var_node(sc->var, tok); }static Node *new_var_node(Obj *var, Token *tok) { Node *node = new_node(ND_VAR, tok); node->var = var; return node;} |
當token類型為TK_IDENT時，從符號表中找到代表plus函數的node，這個node
是在解析plus函數時創建的，就不詳細分析了。
創建新的類型為ND_VAR的node，這個node的var域為代表plus函數的node。
|
1
2
3
4
5
6
7
8
|
if (equal(tok, "(")) { node = funcall(&tok, tok->next, node);}if (ty->kind != TY_STRUCT && ty->kind != TY_UNION) exp = new_cast(exp, current_fn->ty->return_ty);node->lhs = exp;return node; |
解析完函數名plus后，繼續解析函數參數調用，如果plus后面跟著是"("，則判斷為函數調用，
于是調用funcall函數，這個函數的參數node即為上面創建的類型為ND_VAR的node。
創建完類型為ND_FUNCALL的node，又調用new_cast創建類型為ND_CAST的節點，這個節點
的左表達式為類型為ND_FUNCALL的node。return的node類型為ND_RETURN，它的左表達式為
ND_CAST的node。
3.2 funcall函數
|
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
|
Node head = {}; Node *cur = &head;while (!equal(tok, ")")) { if (cur != &head) tok = skip(tok, ","); Node *arg = assign(&tok, tok);if (param_ty) { if (param_ty->kind != TY_STRUCT && param_ty->kind != TY_UNION) arg = new_cast(arg, param_ty); param_ty = param_ty->next; } else if (arg->ty->kind == TY_FLOAT) { // If parameter type is omitted (e.g. in "..."), float // arguments are promoted to double. arg = new_cast(arg, ty_double); } cur = cur->next = arg;}*rest = skip(tok, ")");Node *node = new_unary(ND_FUNCALL, fn, tok);node->func_ty = ty;node->ty = ty->return_ty; node->args = head.next;return node; |
在funcall函數中調用assign函數解析"(3,4)"，3被解析為類型為ND_NUM的node，
|
1
2
3
4
5
6
7
8
9
10
|
Node *new_cast(Node *expr, Type *ty) { add_type(expr); Node *node = calloc(1, sizeof(Node)); node->kind = ND_CAST; node->tok = expr->tok; node->lhs = expr; node->ty = copy_type(ty); return node;} |
調用new_cast函數，創建類型為ND_CAST的node節點，這個節點的左表達式為代表3的node。
跳過","，繼續調用assign解析4,4也被解析為ND_NUM的node，繼續調用new_cast，創建類型為
ND_CAST的node節點，這個節點的左表達式為代表4的node。
跳出循環，跳過")"。
new_unary函數中創建類型為ND_FUNCALL的node，這個node的左表達式為plus函數的node，
args參數為解析"(3,4)"生成的兩個類型為ND_CAST的node。
4. 生成匯編語言
|
1
2
3
4
5
6
7
8
|
static void gen_stmt(Node *node) {switch (node->kind) {case ND_RETURN: if (node->lhs) { gen_expr(node->lhs); } println(" jmp .L.return.%s", current_fn->name);...} |
判斷node節點為ND_RETURN，則調用gen_expr處理類型為ND_CAST的節點。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
static void gen_expr(Node *node) { switch (node->kind) { case ND_FUNCALL: { int stack_args = push_args(node); gen_expr(node->lhs); for (Node *arg = node->args; arg; arg = arg->next) { pop(argreg64[gp++]); println(" mov %%rax, %%r10"); println(" call *%%r10"); println(" add $%d, %%rsp", stack_args * 8); } case ND_VAR: gen_addr(node);return; case ND_CAST: gen_expr(node->lhs); cast(node->lhs->ty, node->ty); return;... }... |
4.1 判斷為ND_CAST類型的node
則調用gen_expr,參數為類型為ND_FUNCALL的node。
4.2 調用push_args函數依次生成匯編語句
"mov rax, 4"
"push rax"
"mov rax, 3"
"push rax"
將4和3壓入棧。
4.3 遞歸調用gen_expr
參數為類型為ND_VAR的node。
4.4 調用gen_addr函數生成匯編代碼"lea rax, plus"
將plus函數地址載入rax寄存器。
4.5 pop語句生成匯編代碼"pop rdi"
"pop rsi"，將3彈入rdi寄存器，將4彈入rsi寄存器，
plus函數中從這兩個寄存器中讀取參數。
4.6 生成匯編代碼
"mov r10, rax"
"call r10"
"add rsp, 0"
將plus函數地址從rax載入r10寄存器，call語句完成調用plus函數，由于沒有分配棧空間傳遞參數
，所以這里不需要修改rsp寄存器的值。
4.7 "jmp .L.return.main"
跳轉到main函數的結尾處，實現return功能。
到此這篇關于c語言是如何處理函數調用的？的文章就介紹到這了,更多相關c語言處理函數調用內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！
原文鏈接：https://www.cnblogs.com/iszhang/p/15601809.html
