Fix Arm calling convention by storing arguments to stack

In the previous implementation, shecc lacked the consideration of
calling convention, so the function arguments were loaded into registers
directly when encountering a function call, regardless of the target
architecture. For the Arm architecture, if the number of arguments is
greater than 4, the additional arguments were still loaded into
registers instead of being passed to stack, causing dynamically linked
programs to execute incorrectly.

To ensure that dynamically linked programs execute correctly, these
changes introduce the following strategy:
- Each function allocates an additional 20 bytes of space using stack.
  - 16 bytes are used for the extra arguments.
  - 4 bytes are used to save and restore the global pointer stored in
    register r12 (ip).
    - Because the external call may change register r12, the compiled
      program could lose the address of the global stack. Therefore,
      4 bytes are allocated to preserve its value.
- If any internal function calls an external function with more than
  4 arguments, the extra arguments are stored directly on stack.
- If the callee is an internal function, all arguments are still loaded
  into registers.

Author: DrXiao

src/globals.c

@@ -948,7 +948,31 @@ func_t *add_func(char *func_name, bool synthesize)
     hashmap_put(FUNC_MAP, func_name, func);
     /* Use interned string for function name */
     strcpy(func->return_def.var_name, intern_string(func_name));
-    func->stack_size = 4;
+    /* Prepare space for function arguments and global pointer.
+     *
+     * For Arm architecture, the first four arguments are passed to r0 ~ r3,
+     * and any additional arguments are passed to the stack.
+     *
+     * +-------------+ <-- sp + 20
+     * | (val of ip) |
+     * +-------------+ <-- sp + 16
+     * |    arg 8    |
+     * +-------------+ <-- sp + 12
+     * |    arg 7    |
+     * +-------------+ <-- sp + 8
+     * |    arg 6    |
+     * +-------------+ <-- sp + 4
+     * |    arg 5    |
+     * +-------------+ <-- sp
+     *
+     * However, register r12 (ip) holds the global pointer that points to
+     * global stack, but this register may be changed after an external call.
+     *
+     * Therefore, the current strategy is preparing additional space for ip,
+     * saves its original value to the stack before an external call, and
+     * restores it from the stack after the external function returns.
+     * */
+    func->stack_size = 20;
 
     if (synthesize)
         return func;

src/reg-alloc.c

@@ -770,12 +770,40 @@ void reg_alloc(void)
                     if (!callee_func->num_params)
                         spill_alive(bb, insn);
 
-                    if (dynlink)
+                    if (dynlink) {
                         callee_func->is_used = true;
+                        if (!callee_func->bbs) {
+                            int ofs = 0;
+                            if (args > 4) {
+                                /* Store args to stack for Arm output */
+                                for (int i = 4; i < args; i++) {
+                                    ir = bb_add_ph2_ir(bb, OP_store);
+                                    ir->src0 = i;
+                                    ir->src1 = ofs;
+                                    ofs += 4;
+                                }
+                            }
+                            /* FIXME:
+                             * use a better way to preserve global pointer */
+                            ir = bb_add_ph2_ir(bb, OP_store);
+                            ir->src0 = 12;
+                            ir->src1 = 16;
+                        }
+                    }
 
                     ir = bb_add_ph2_ir(bb, OP_call);
                     strcpy(ir->func_name, insn->str);
 
+                    if (dynlink) {
+                        if (!callee_func->bbs) {
+                            /* FIXME:
+                             * use a better way to restore global pointer */
+                            ir = bb_add_ph2_ir(bb, OP_load);
+                            ir->dest = 12;
+                            ir->src0 = 16;
+                        }
+                    }
+
                     is_pushing_args = false;
                     args = 0;