Support Arm dynamic linking

Author: DrXiao

Makefile

@@ -43,6 +43,19 @@ HOST_ARCH = $(shell arch 2>/dev/null)
 SRCDIR := $(shell find src -type d)
 LIBDIR := $(shell find lib -type d)
 
+BUILTIN_LIBC ?= c.c
+STAGE0_FLAGS ?= --dump-ir
+STAGE1_FLAGS ?=
+ifeq ($(DYNLINK),1)
+    ifeq ($(ARCH),riscv)
+        # TODO: implement dynamic linking for RISC-V.
+        $(error "Dynamic linking mode is not implemented for RISC-V")
+    endif
+    BUILTIN_LIBC := c.h
+    STAGE0_FLAGS += --dynlink
+    STAGE1_FLAGS += --dynlink
+endif
+
 SRCS := $(wildcard $(patsubst %,%/main.c, $(SRCDIR)))
 OBJS := $(SRCS:%.c=$(OUT)/%.o)
 deps := $(OBJS:%.o=%.o.d)
@@ -72,7 +85,7 @@ config:
 
 $(OUT)/tests/%.elf: tests/%.c $(OUT)/$(STAGE0)
 	$(VECHO) "  SHECC\t$@\n"
-	$(Q)$(OUT)/$(STAGE0) --dump-ir -o $@ $< > $(basename $@).log ; \
+	$(Q)$(OUT)/$(STAGE0) $(STAGE0_FLAGS) -o $@ $< > $(basename $@).log ; \
 	chmod +x $@ ; $(PRINTF) "Running $@ ...\n"
 	$(Q)$(TARGET_EXEC) $@ && $(call pass)
 
@@ -122,9 +135,9 @@ $(OUT)/norm-lf: tools/norm-lf.c
 	$(VECHO) "  CC+LD\t$@\n"
 	$(Q)$(CC) $(CFLAGS) -o $@ $^
 
-$(OUT)/libc.inc: $(OUT)/inliner $(OUT)/norm-lf $(LIBDIR)/c.c
+$(OUT)/libc.inc: $(OUT)/inliner $(OUT)/norm-lf $(LIBDIR)/$(BUILTIN_LIBC)
 	$(VECHO) "  GEN\t$@\n"
-	$(Q)$(OUT)/norm-lf $(LIBDIR)/c.c $(OUT)/c.normalized.c
+	$(Q)$(OUT)/norm-lf $(LIBDIR)/$(BUILTIN_LIBC) $(OUT)/c.normalized.c
 	$(Q)$(OUT)/inliner $(OUT)/c.normalized.c $@
 	$(Q)$(RM) $(OUT)/c.normalized.c
 
@@ -143,12 +156,12 @@ $(OUT)/$(STAGE0)-sanitizer: $(OUT)/libc.inc $(OBJS)
 $(OUT)/$(STAGE1): $(OUT)/$(STAGE0)
 	$(Q)$(STAGE1_CHECK_CMD)
 	$(VECHO) "  SHECC\t$@\n"
-	$(Q)$(OUT)/$(STAGE0) --dump-ir -o $@ $(SRCDIR)/main.c > $(OUT)/shecc-stage1.log
+	$(Q)$(OUT)/$(STAGE0) $(STAGE0_FLAGS) -o $@ $(SRCDIR)/main.c > $(OUT)/shecc-stage1.log
 	$(Q)chmod a+x $@
 
 $(OUT)/$(STAGE2): $(OUT)/$(STAGE1)
 	$(VECHO) "  SHECC\t$@\n"
-	$(Q)$(TARGET_EXEC) $(OUT)/$(STAGE1) -o $@ $(SRCDIR)/main.c
+	$(Q)$(TARGET_EXEC) $(OUT)/$(STAGE1) $(STAGE1_FLAGS) -o $@ $(SRCDIR)/main.c
 
 bootstrap: $(OUT)/$(STAGE2)
 	$(Q)chmod 775 $(OUT)/$(STAGE2)

lib/c.h

@@ -0,0 +1,50 @@
+/*
+ * shecc - Self-Hosting and Educational C Compiler.
+ *
+ * shecc is freely redistributable under the BSD 2 clause license. See the
+ * file "LICENSE" for information on usage and redistribution of this file.
+ */
+
+#pragma once
+/* Declarations of C standard library functions */
+
+#define NULL 0
+
+#define bool _Bool
+#define true 1
+#define false 0
+
+/* va_list support for variadic functions */
+typedef int *va_list;
+
+/* File I/O */
+typedef int FILE;
+FILE *fopen(char *filename, char *mode);
+int fclose(FILE *stream);
+int fgetc(FILE *stream);
+char *fgets(char *str, int n, FILE *stream);
+int fputc(int c, FILE *stream);
+
+/* string-related functions */
+int strlen(char *str);
+int strcmp(char *s1, char *s2);
+int strncmp(char *s1, char *s2, int len);
+char *strcpy(char *dest, char *src);
+char *strncpy(char *dest, char *src, int len);
+char *memcpy(char *dest, char *src, int count);
+int memcmp(void *s1, void *s2, int n);
+void *memset(void *s, int c, int n);
+
+/* formatted output string */
+int printf(char *str, ...);
+int sprintf(char *buffer, char *str, ...);
+int snprintf(char *buffer, int n, char *str, ...);
+
+/* Terminating program */
+void exit(int exit_code);
+void abort(void);
+
+/* Dynamic memory allocation/deallocation functions */
+void *malloc(int size);
+void *calloc(int n, int size);
+void free(void *ptr);

mk/arm.mk

@@ -6,4 +6,10 @@ ARCH_DEFS = \
     \#define ARCH_PREDEFINED \"__arm__\" /* defined by GNU C and RealView */\n$\
     \#define ELF_MACHINE 0x28 /* up to ARMv7/Aarch32 */\n$\
     \#define ELF_FLAGS 0x5000200\n$\
+    \#define DYN_LINKER \"/lib/ld-linux.so.3\"\n$\
+    \#define LIBC_SO \"libc.so.6\"\n$\
+    \#define PLT_FIXUP_SIZE 20\n$\
+    \#define PLT_ENT_SIZE 12\n$\
+    \#define R_ARCH_JUMP_SLOT 0x16\n$\
     "
+RUNNER_LD_PREFIX=-L /usr/arm-linux-gnueabi/

mk/common.mk

@@ -36,6 +36,9 @@ ifneq ($(HOST_ARCH),$(ARCH_NAME))
 
     # Generate the path to the architecture-specific qemu
     TARGET_EXEC = $(shell which $(ARCH_RUNNER))
+    ifeq ($(DYNLINK),1)
+        TARGET_EXEC += $(RUNNER_LD_PREFIX)
+    endif
 endif
 export TARGET_EXEC
 

mk/riscv.mk

@@ -7,4 +7,12 @@ ARCH_DEFS = \
     \#define ARCH_PREDEFINED \"__riscv\" /* Older versions of the GCC toolchain defined __riscv__ */\n$\
     \#define ELF_MACHINE 0xf3\n$\
     \#define ELF_FLAGS 0\n$\
+    \#define DYN_LINKER \"/lib/ld-linux.so.3\"\n$\
+    \#define LIBC_SO \"libc.so.6\"\n$\
+    \#define PLT_FIXUP_SIZE 20\n$\
+    \#define PLT_ENT_SIZE 12\n$\
+    \#define R_ARCH_JUMP_SLOT 0x5\n$\
     "
+
+# TODO: Set this variable for RISC-V architecture
+RUNNER_LD_PREFIX=

src/arm-codegen.c

@@ -136,10 +136,18 @@ void update_elf_offset(ph2_ir_t *ph2_ir)
 
 void cfg_flatten(void)
 {
-    func_t *func = find_func("__syscall");
-    func->bbs->elf_offset = 48; /* offset of start + branch + exit in codegen */
+    func_t *func;
+
+    if (dynlink)
+        elf_offset =
+            84; /* offset of __libc_start_main + main_wrapper in codegen */
+    else {
+        func = find_func("__syscall");
+        func->bbs->elf_offset = 48; /* offset of start + exit in codegen */
+        elf_offset =
+            84; /* offset of start + branch + exit + syscall in codegen */
+    }
 
-    elf_offset = 84; /* offset of start + branch + exit + syscall in codegen */
     GLOBAL_FUNC->bbs->elf_offset = elf_offset;
 
     for (ph2_ir_t *ph2_ir = GLOBAL_FUNC->bbs->ph2_ir_list.head; ph2_ir;
@@ -148,7 +156,10 @@ void cfg_flatten(void)
     }
 
     /* prepare 'argc' and 'argv', then proceed to 'main' function */
-    elf_offset += 32; /* 6 insns for main call + 2 for exit */
+    if (dynlink)
+        elf_offset += 12;
+    else
+        elf_offset += 32; /* 6 insns for main call + 2 for exit */
 
     for (func = FUNC_LIST.head; func; func = func->next) {
         /* Skip function declarations without bodies */
@@ -287,7 +298,16 @@ void emit_ph2_ir(ph2_ir_t *ph2_ir)
         return;
     case OP_call:
         func = find_func(ph2_ir->func_name);
-        emit(__bl(__AL, func->bbs->elf_offset - elf_code->size));
+        if (func->bbs)
+            ofs = func->bbs->elf_offset - elf_code->size;
+        else if (dynlink)
+            ofs = (elf_plt_start + func->plt_offset) -
+                  (elf_code_start + elf_code->size);
+        else {
+            printf("The '%s' function is not implemented\n", ph2_ir->func_name);
+            abort();
+        }
+        emit(__bl(__AL, ofs));
         return;
     case OP_load_data_address:
         emit(__movw(__AL, rd, ph2_ir->src0 + elf_data_start));
@@ -299,7 +319,14 @@ void emit_ph2_ir(ph2_ir_t *ph2_ir)
         return;
     case OP_address_of_func:
         func = find_func(ph2_ir->func_name);
-        ofs = elf_code_start + func->bbs->elf_offset;
+        if (func->bbs)
+            ofs = elf_code_start + func->bbs->elf_offset;
+        else if (dynlink)
+            ofs = elf_plt_start + func->plt_offset;
+        else {
+            printf("The '%s' function is not implemented\n", ph2_ir->func_name);
+            abort();
+        }
         emit(__movw(__AL, __r8, ofs));
         emit(__movt(__AL, __r8, ofs));
         emit(__sw(__AL, __r8, rn, 0));
@@ -456,39 +483,74 @@ void emit_ph2_ir(ph2_ir_t *ph2_ir)
     }
 }
 
+void plt_generate(void);
 void code_generate(void)
 {
-    elf_data_start = elf_code_start + elf_offset;
-    elf_rodata_start = elf_data_start + elf_data->size;
-    elf_bss_start = elf_rodata_start + elf_rodata->size;
+    if (dynlink) {
+        plt_generate();
+        /* Call __libc_start_main() */
+        emit(__mov_i(__AL, __r11, 0));
+        emit(__mov_i(__AL, __lr, 0));
+        emit(__pop_word(__AL, __r1));
+        emit(__mov_r(__AL, __r2, __sp));
+        emit(__push_reg(__AL, __r2));
+        emit(__push_reg(__AL, __r0));
+        emit(__mov_i(__AL, __r12, 0));
+        emit(__push_reg(__AL, __r12));
 
-    /* start */
+        int main_wrapper_offset = elf_code->size + 28;
+        emit(__movw(__AL, __r0, elf_code_start + main_wrapper_offset));
+        emit(__movt(__AL, __r0, elf_code_start + main_wrapper_offset));
+        emit(__mov_i(__AL, __r3, 0));
+        emit(__bl(__AL, (elf_plt_start + PLT_FIXUP_SIZE) -
+                            (elf_code_start + elf_code->size)));
+        /* Call '_exit' (syscall) to terminate the program if __libc_start_main
+         * returns. */
+        emit(__mov_i(__AL, __r0, 127));
+        emit(__mov_i(__AL, __r7, 1));
+        emit(__svc());
+
+        /* If the compiled program is dynamic linking, the starting
+         * point of 'main_wrapper' is located here.
+         *
+         * Preserve 'argc' and 'argv' for the 'main' function.
+         * */
+        emit(__mov_r(__AL, __r9, __r0));
+        emit(__mov_r(__AL, __r10, __r1));
+    }
+    /* For both static and dynamic linking, we need to set up the stack
+     * and call the main function.
+     * */
     emit(__movw(__AL, __r8, GLOBAL_FUNC->stack_size));
     emit(__movt(__AL, __r8, GLOBAL_FUNC->stack_size));
     emit(__sub_r(__AL, __sp, __sp, __r8));
     emit(__mov_r(__AL, __r12, __sp));
-    emit(__bl(__AL, GLOBAL_FUNC->bbs->elf_offset - elf_code->size));
-    /* After global init, jump to main preparation */
-    emit(__b(__AL, 56)); /* PC+8: skip exit (24) + syscall (36) + ret (4) - 8 */
 
-    /* exit */
-    emit(__movw(__AL, __r8, GLOBAL_FUNC->stack_size));
-    emit(__movt(__AL, __r8, GLOBAL_FUNC->stack_size));
-    emit(__add_r(__AL, __sp, __sp, __r8));
-    emit(__mov_r(__AL, __r0, __r0));
-    emit(__mov_i(__AL, __r7, 1));
-    emit(__svc());
-
-    /* syscall */
-    emit(__mov_r(__AL, __r7, __r0));
-    emit(__mov_r(__AL, __r0, __r1));
-    emit(__mov_r(__AL, __r1, __r2));
-    emit(__mov_r(__AL, __r2, __r3));
-    emit(__mov_r(__AL, __r3, __r4));
-    emit(__mov_r(__AL, __r4, __r5));
-    emit(__mov_r(__AL, __r5, __r6));
-    emit(__svc());
-    emit(__bx(__AL, __lr));
+    if (!dynlink) {
+        emit(__bl(__AL, GLOBAL_FUNC->bbs->elf_offset - elf_code->size));
+        /* After global init, jump to main preparation */
+        emit(__b(__AL,
+                 56)); /* PC+8: skip exit (24) + syscall (36) + ret (4) - 8 */
+
+        /* exit - only for static linking */
+        emit(__movw(__AL, __r8, GLOBAL_FUNC->stack_size));
+        emit(__movt(__AL, __r8, GLOBAL_FUNC->stack_size));
+        emit(__add_r(__AL, __sp, __sp, __r8));
+        emit(__mov_r(__AL, __r0, __r0));
+        emit(__mov_i(__AL, __r7, 1));
+        emit(__svc());
+
+        /* syscall */
+        emit(__mov_r(__AL, __r7, __r0));
+        emit(__mov_r(__AL, __r0, __r1));
+        emit(__mov_r(__AL, __r1, __r2));
+        emit(__mov_r(__AL, __r2, __r3));
+        emit(__mov_r(__AL, __r3, __r4));
+        emit(__mov_r(__AL, __r4, __r5));
+        emit(__mov_r(__AL, __r5, __r6));
+        emit(__svc());
+        emit(__bx(__AL, __lr));
+    }
 
     ph2_ir_t *ph2_ir;
     for (ph2_ir = GLOBAL_FUNC->bbs->ph2_ir_list.head; ph2_ir;
@@ -497,20 +559,51 @@ void code_generate(void)
 
     /* prepare 'argc' and 'argv', then proceed to 'main' function */
     if (MAIN_BB) {
-        emit(__movw(__AL, __r8, GLOBAL_FUNC->stack_size));
-        emit(__movt(__AL, __r8, GLOBAL_FUNC->stack_size));
-        emit(__add_r(__AL, __r8, __r12, __r8));
-        emit(__lw(__AL, __r0, __r8, 0));
-        emit(__add_i(__AL, __r1, __r8, 4));
-        emit(__bl(__AL, MAIN_BB->elf_offset - elf_code->size));
+        if (dynlink) {
+            emit(__mov_r(__AL, __r0, __r9));
+            emit(__mov_r(__AL, __r1, __r10));
+            /* Jump directly to the main function.
+             *
+             * When the main function returns, the program
+             * will return to __libc_start_main. */
+            emit(__b(__AL, MAIN_BB->elf_offset - elf_code->size));
+        } else {
+            emit(__movw(__AL, __r8, GLOBAL_FUNC->stack_size));
+            emit(__movt(__AL, __r8, GLOBAL_FUNC->stack_size));
+            emit(__add_r(__AL, __r8, __r12, __r8));
+            emit(__lw(__AL, __r0, __r8, 0));
+            emit(__add_i(__AL, __r1, __r8, 4));
 
-        /* exit with main's return value - r0 already has the return value */
-        emit(__mov_i(__AL, __r7, 1));
-        emit(__svc());
+            /* Call main function, and call '_exit' syscall to
+             * terminate the program. */
+            emit(__bl(__AL, MAIN_BB->elf_offset - elf_code->size));
+
+            /* exit with main's return value - r0 already has the
+             * return value */
+            emit(__mov_i(__AL, __r7, 1));
+            emit(__svc());
+        }
     }
 
     for (int i = 0; i < ph2_ir_idx; i++) {
         ph2_ir = PH2_IR_FLATTEN[i];
         emit_ph2_ir(ph2_ir);
     }
 }
+
+void plt_generate(void)
+{
+    int addr_of_got = elf_got_start + PTR_SIZE * 2;
+    int end = plt_size - PLT_FIXUP_SIZE;
+    elf_write_int(elf_plt, __push_reg(__AL, __lr));
+    elf_write_int(elf_plt, __movw(__AL, __r10, addr_of_got));
+    elf_write_int(elf_plt, __movt(__AL, __r10, addr_of_got));
+    elf_write_int(elf_plt, __mov_r(__AL, __lr, __r10));
+    elf_write_int(elf_plt, __lw(__AL, __pc, __lr, 0));
+    for (int i = 0; i * PLT_ENT_SIZE < end; i++) {
+        addr_of_got = elf_got_start + PTR_SIZE * (i + 3);
+        elf_write_int(elf_plt, __movw(__AL, __r12, addr_of_got));
+        elf_write_int(elf_plt, __movt(__AL, __r12, addr_of_got));
+        elf_write_int(elf_plt, __lw(__AL, __pc, __r12, 0));
+    }
+}

src/arm.c

@@ -312,6 +312,16 @@ int __ldm(arm_cond_t cond, int w, arm_reg rn, int reg_list)
     return arm_encode(cond, arm_ldm + (0x2 << 6) + (w << 1), rn, 0, reg_list);
 }
 
+int __push_reg(arm_cond_t cond, arm_reg rt)
+{
+    return arm_encode(cond, (0x5 << 4) | 0x2, 0xd, rt, 0x4);
+}
+
+int __pop_word(arm_cond_t cond, arm_reg rt)
+{
+    return arm_encode(cond, (0x4 << 4) | 0x9, 0xd, rt, 0x4);
+}
+
 int __b(arm_cond_t cond, int ofs)
 {
     int o = (ofs - 8) >> 2;