c語言是如何處理函式呼叫的？

Just_4_fun發表於2021-11-25
C語言函式

1.  要編譯的測試程式碼：

int plus(int x, int y) {
  return x + y;
}

int main(void) {
  return plus(3, 4);
}

 

2. main中return語句語法分析

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"

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。

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函式建立型別為ND_FUNCALL的node，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函式

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，

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. 生成組合語言

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的節點。

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功能。

 

 

 

　　

 

相關文章