Shulou(Shulou.com)06/02 Report--

This article will explain in detail how to deal with function calls in c language. The editor thinks it is very practical, so I share it for you as a reference. I hope you can get something after reading this article.

1. Test code to compile: int plus (int x, int y) {return x + y;} int main (void) {return plus (3,4);} 2.Syntax analysis of return statements in main 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.1The current token is return

Then a node of type ND_RETURN is created.

2.2 because return is followed by plus (3,4)

So call the expr function to parse the expression.

2.3 skip the ";" symbol. Set the left expression of node of type ND_RETURN to node of type ND_CAST. 3. Expr process 3.1 parse "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;}

When the token type is TK_IDENT, find the node that represents the plus function in the symbol table, this node

It is created when parsing the plus function, so it will not be analyzed in detail.

Create a new node of type ND_VAR, and the varfield of this node is node that represents the plus function.

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

After parsing the function name plus, continue to parse the function parameter call. If the plus is followed by "(", it is judged to be the function call.

The funcall function is called, and the parameter node of this function is the node of type ND_VAR created above.

After creating a node of type ND_FUNCALL, call new_cast to create a node of type ND_CAST

The left expression is node of type ND_FUNCALL The node type of return is ND_RETURN, and its left expression is

Node for ND_CAST.

3.2 funcall function 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

Call the assign function in the funcall function to parse "(3Jing 4)", and 3 is parsed into a node of type ND_NUM

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;}

Call the new_cast function to create a node node of type ND_CAST, whose left expression is node for 3.

Skip ",", and continue to call assign to parse 4 node that is also parsed to ND_NUM, continue to call new_cast, and create a type of

The node node of ND_CAST, whose left expression is node for 4.

Jump out of the loop and skip the ")".

Create a node of type ND_FUNCALL in the new_unary function, and the left expression of this node is the node of the plus function

The args parameter is the two node of type ND_CAST generated by parsing "(3pr 4)".

4. Generate assembly language static void gen_stmt (Node * node) {switch (node- > kind) {case ND_RETURN: if (node- > lhs) {gen_expr (node- > lhs);} println ("jmp .L.Secretn.s", current_fn- > name);.}

If the node node is determined to be ND_RETURN, gen_expr is called to process the node of type 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;...}.

Then gen_expr is called with an argument of type ND_FUNCALL node.

4.2 call the push_args function to generate assembly statements in turn

"mov rax, 4"

"push rax"

Mov rax, 3

"push rax"

Press 4 and 3 into the stack.

4.3Recursive call to gen_expr

The parameter is node of type ND_VAR.

4.4 call the gen_addr function to generate the assembly code "lea rax, plus"

Load the plus function address into the rax register.

4.5 pop statement generates assembly code "pop rdi"

"pop rsi", pop 3 into the rdi register and 4 into the rsi register

The plus function reads parameters from these two registers.

4.6 generate assembly code

"mov R10, rax"

"call R10"

"add rsp, 0"

The address of the plus function is loaded from rax into the R10 register, and the call statement completes the call to the plus function. Because there is no stack space allocated, the parameters are passed.

So there is no need to change the value of the rsp register here

4.7 "jmp .L.principn.main"

Jump to the end of the main function to implement the return function.

This is the end of the article on "how the c language handles function calls". I hope the above content can be helpful to you, so that you can learn more knowledge. if you think the article is good, please share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.