Improve ABI compliance

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.

Therefore, this commit makes the dynamically linked shecc more strictly
compliant with ABI, and ensure that dynamically linked programs compiled
by shecc also follow ABI.

Author: DrXiao

mk/arm.mk

@@ -11,5 +11,6 @@ ARCH_DEFS = \
     \#define PLT_FIXUP_SIZE 20\n$\
     \#define PLT_ENT_SIZE 12\n$\
     \#define R_ARCH_JUMP_SLOT 0x16\n$\
+    \#define MAX_ARGS_IN_REG 4\n$\
     "
 RUNNER_LD_PREFIX=-L /usr/arm-linux-gnueabihf/

mk/riscv.mk

@@ -12,6 +12,7 @@ ARCH_DEFS = \
     \#define PLT_FIXUP_SIZE 20\n$\
     \#define PLT_ENT_SIZE 12\n$\
     \#define R_ARCH_JUMP_SLOT 0x5\n$\
+    \#define MAX_ARGS_IN_REG 8\n$\
     "
 
 # TODO: Set this variable for RISC-V architecture

src/arm-codegen.c

@@ -13,6 +13,7 @@
 
 void update_elf_offset(ph2_ir_t *ph2_ir)
 {
+    func_t *func;
     switch (ph2_ir->op) {
     case OP_load_constant:
         /* ARMv7 uses 12 bits to encode immediate value, but the higher 4 bits
@@ -70,7 +71,6 @@ void update_elf_offset(ph2_ir_t *ph2_ir)
     case OP_read:
     case OP_write:
     case OP_jump:
-    case OP_call:
     case OP_load_func:
     case OP_indirect:
     case OP_add:
@@ -85,6 +85,17 @@ void update_elf_offset(ph2_ir_t *ph2_ir)
     case OP_bit_not:
         elf_offset += 4;
         return;
+    case OP_call:
+        func = find_func(ph2_ir->func_name);
+        if (func->bbs)
+            elf_offset += 4;
+        else if (dynlink)
+            elf_offset += 12;
+        else {
+            printf("The '%s' function is not implemented\n", ph2_ir->func_name);
+            abort();
+        }
+        return;
     case OP_div:
     case OP_mod:
         if (hard_mul_div) {
@@ -211,6 +222,7 @@ void emit_ph2_ir(ph2_ir_t *ph2_ir)
     const int rn = ph2_ir->src0;
     int rm = ph2_ir->src1; /* Not const because OP_trunc modifies it */
     int ofs;
+    bool is_external_call = false;
 
     /* Prepare this variable to reuse code for:
      * 1. division and modulo operations
@@ -307,14 +319,23 @@ void emit_ph2_ir(ph2_ir_t *ph2_ir)
         func = find_func(ph2_ir->func_name);
         if (func->bbs)
             ofs = func->bbs->elf_offset - elf_code->size;
-        else if (dynlink)
+        else if (dynlink) {
             ofs = (dynamic_sections.elf_plt_start + func->plt_offset) -
-                  (elf_code_start + elf_code->size);
-        else {
+                  (elf_code_start + elf_code->size + 4);
+            is_external_call = true;
+        } else {
             printf("The '%s' function is not implemented\n", ph2_ir->func_name);
             abort();
         }
+
+        /* If the callee is external, save __r12 at [sp + 16] and
+         * restore it after the function returns.
+         */
+        if (is_external_call)
+            emit(__sw(__AL, __r12, __sp, 16));
         emit(__bl(__AL, ofs));
+        if (is_external_call)
+            emit(__lw(__AL, __r12, __sp, 16));
         return;
     case OP_load_data_address:
         emit(__movw(__AL, rd, ph2_ir->src0 + elf_data_start));

src/globals.c

@@ -935,7 +935,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

@@ -388,6 +388,39 @@ void extend_liveness(basic_block_t *bb, insn_t *insn, var_t *var, int offset)
         var->consumed = insn->idx + offset;
 }
 
+/* Return whether extra arguments are pushed onto stack. */
+bool abi_lower_call_args(basic_block_t *bb, insn_t *insn)
+{
+    int num_of_args = 0;
+    int stack_args = 0;
+    while (insn && insn->opcode == OP_push) {
+        num_of_args += 1;
+        insn = insn->next;
+    }
+
+    if (insn && insn->opcode == OP_call) {
+        func_t *func = find_func(insn->str);
+        if (func->bbs)
+            return false;
+    }
+
+    if (num_of_args <= MAX_ARGS_IN_REG)
+        return false;
+
+    insn = insn->prev;
+    stack_args = num_of_args - MAX_ARGS_IN_REG;
+    while (stack_args) {
+        load_var(bb, insn->rs1, MAX_ARGS_IN_REG - 1);
+        ph2_ir_t *ir = bb_add_ph2_ir(bb, OP_store);
+        ir->src0 = MAX_ARGS_IN_REG - 1;
+        ir->src1 = (stack_args - 1) * 4;
+        stack_args -= 1;
+        insn = insn->prev;
+    }
+    REGS[MAX_ARGS_IN_REG - 1].var = NULL;
+    return true;
+}
+
 void reg_alloc(void)
 {
     /* TODO: Add proper .bss and .data section support for uninitialized /
@@ -556,7 +589,8 @@ void reg_alloc(void)
         }
 
         for (basic_block_t *bb = func->bbs; bb; bb = bb->rpo_next) {
-            bool is_pushing_args = false;
+            bool is_pushing_args = false, handle_abi = false,
+                 args_on_stack = false;
             int args = 0;
 
             bb->visited++;
@@ -757,6 +791,13 @@ void reg_alloc(void)
                         spill_alive(bb, insn);
                         is_pushing_args = true;
                     }
+                    if (dynlink && !handle_abi) {
+                        args_on_stack = abi_lower_call_args(bb, insn);
+                        handle_abi = true;
+                    }
+
+                    if (dynlink && args_on_stack && args >= MAX_ARGS_IN_REG)
+                        break;
 
                     src0 = prepare_operand(bb, insn->rs1, -1);
                     ir = bb_add_ph2_ir(bb, OP_assign);
@@ -778,6 +819,7 @@ void reg_alloc(void)
 
                     is_pushing_args = false;
                     args = 0;
+                    handle_abi = false;
 
                     for (int i = 0; i < REG_CNT; i++)
                         REGS[i].var = NULL;
@@ -795,6 +837,7 @@ void reg_alloc(void)
 
                     is_pushing_args = false;
                     args = 0;
+                    handle_abi = false;
                     break;
                 case OP_func_ret:
                     dest = prepare_dest(bb, insn->rd, -1, -1);