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

 

 

 

  

 

posted @ 2021-11-25 11:07  Just_4_fun  阅读(173)  评论(0编辑  时时彩怎么破解连挂  举报