feat: aarch64 linux support

am/include/arch/native.h

@@ -15,11 +15,19 @@ struct Context {
   uint8_t redzone[128];
 };
 
+#ifdef __x86_64__
 #define GPR1 uc.uc_mcontext.gregs[REG_RDI]
 #define GPR2 uc.uc_mcontext.gregs[REG_RSI]
 #define GPR3 uc.uc_mcontext.gregs[REG_RDX]
 #define GPR4 uc.uc_mcontext.gregs[REG_RCX]
 #define GPRx uc.uc_mcontext.gregs[REG_RAX]
+#elif __aarch64__
+#define GPR1 uc.uc_mcontext.regs[0]
+#define GPR2 uc.uc_mcontext.regs[1]
+#define GPR3 uc.uc_mcontext.regs[2]
+#define GPR4 uc.uc_mcontext.regs[3]
+#define GPRx uc.uc_mcontext.regs[0]
+#endif
 
 #undef __USE_GNU
 

am/src/native/cte.c

@@ -20,9 +20,8 @@ static void irq_handle(Context *c) {
   c->ksp = thiscpu->ksp;
 
   if (thiscpu->ev.event == EVENT_ERROR) {
-    uintptr_t rip = c->uc.uc_mcontext.gregs[REG_RIP];
-    printf("Unhandle signal '%s' at rip = %p, badaddr = %p, cause = 0x%x\n",
-        thiscpu->ev.msg, rip, thiscpu->ev.ref, thiscpu->ev.cause);
+    printf("Unhandle signal '%s' at pc = %p, badaddr = %p, cause = 0x%x\n",
+      thiscpu->ev.msg, REG_PC(&c->uc), thiscpu->ev.ref, thiscpu->ev.cause);
     assert(0);
   }
   c = user_handler(thiscpu->ev, c);
@@ -37,7 +36,7 @@ static void irq_handle(Context *c) {
 }
 
 static void setup_stack(uintptr_t event, ucontext_t *uc) {
-  void *rip = (void *)uc->uc_mcontext.gregs[REG_RIP];
+  void *rip = (void *)REG_PC(uc);
   extern uint8_t _start, _etext;
   int trap_from_user = __am_in_userspace(rip);
   int signal_safe = IN_RANGE(rip, RANGE(&_start, &_etext)) || trap_from_user ||
@@ -60,13 +59,15 @@ static void setup_stack(uintptr_t event, ucontext_t *uc) {
 
   // skip the instructions causing SIGSEGV for syscall
   if (event == EVENT_SYSCALL) { rip += SYSCALL_INSTR_LEN; }
-  uc->uc_mcontext.gregs[REG_RIP] = (uintptr_t)rip;
+  REG_PC(uc) = (uintptr_t)rip;
 
   // switch to kernel stack if we were previously in user space
-  uintptr_t rsp = trap_from_user ? thiscpu->ksp : uc->uc_mcontext.gregs[REG_RSP];
+  uintptr_t rsp = trap_from_user ? thiscpu->ksp : REG_SP(uc);
   rsp -= sizeof(Context);
+#ifdef __x86_64__
   // keep (rsp + 8) % 16 == 0 to support SSE
   if ((rsp + 8) % 16 != 0) rsp -= 8;
+#endif
   Context *c = (void *)rsp;
 
   // save the context on the stack
@@ -76,17 +77,17 @@ static void setup_stack(uintptr_t event, ucontext_t *uc) {
   __am_get_intr_sigmask(&uc->uc_sigmask);
 
   // call irq_handle after returning from the signal handler
-  uc->uc_mcontext.gregs[REG_RDI] = (uintptr_t)c;
-  uc->uc_mcontext.gregs[REG_RIP] = (uintptr_t)irq_handle;
-  uc->uc_mcontext.gregs[REG_RSP] = (uintptr_t)c;
+  REG_GPR1(uc) = (uintptr_t)c;
+  REG_PC(uc)   = (uintptr_t)irq_handle;
+  REG_SP(uc)   = (uintptr_t)c;
 }
 
 static void iret(ucontext_t *uc) {
-  Context *c = (void *)uc->uc_mcontext.gregs[REG_RDI];
+  Context *c = (void *)REG_GPR1(uc);
   // restore the context
   *uc = c->uc;
   thiscpu->ksp = c->ksp;
-  if (__am_in_userspace((void *)uc->uc_mcontext.gregs[REG_RIP])) __am_pmem_protect();
+  if (__am_in_userspace((void *)REG_PC(uc))) __am_pmem_protect();
 }
 
 static void sig_handler(int sig, siginfo_t *info, void *ucontext) {
@@ -167,8 +168,8 @@ Context* kcontext(Area kstack, void (*entry)(void *), void *arg) {
   Context *c = (Context*)kstack.end - 1;
 
   __am_get_example_uc(c);
-  c->uc.uc_mcontext.gregs[REG_RIP] = (uintptr_t)__am_kcontext_start;
-  c->uc.uc_mcontext.gregs[REG_RSP] = (uintptr_t)kstack.end;
+  REG_PC(&c->uc) = (uintptr_t)__am_kcontext_start;
+  REG_SP(&c->uc) = (uintptr_t)kstack.end;
 
   int ret = sigemptyset(&(c->uc.uc_sigmask)); // enable interrupt
   assert(ret == 0);

am/src/native/ioe/input.c

@@ -1,5 +1,5 @@
 #include <am.h>
-#include <SDL2/SDL.h>
+#include <SDL.h>
 
 #define KEYDOWN_MASK 0x8000
 

am/src/native/platform.c

@@ -150,7 +150,9 @@ static void init_platform() {
 
   // save the context template
   save_example_context();
+#ifdef __x86_64__
   uc_example.uc_mcontext.fpregs = NULL; // clear the FPU context
+#endif
   __am_get_intr_sigmask(&uc_example.uc_sigmask);
 
   // disable interrupts by default

am/src/native/platform.h

@@ -7,6 +7,18 @@
 #include <klib.h>
 #include <klib-macros.h>
 
+#ifdef __x86_64__
+#define REG_PC(uc)   (uc)->uc_mcontext.gregs[REG_RIP]
+#define REG_SP(uc)   (uc)->uc_mcontext.gregs[REG_RSP]
+#define REG_GPR1(uc) (uc)->uc_mcontext.gregs[REG_RDI]
+#elif __aarch64__
+#define REG_PC(uc)   (uc)->uc_mcontext.pc
+#define REG_SP(uc)   (uc)->uc_mcontext.sp
+#define REG_GPR1(uc) (uc)->uc_mcontext.regs[0]
+#else
+#error Unsupported architecture
+#endif
+
 void __am_get_example_uc(Context *r);
 void __am_get_intr_sigmask(sigset_t *s);
 int __am_is_sigmask_sti(sigset_t *s);

am/src/native/trap.S

@@ -1,5 +1,6 @@
 .global __am_kcontext_start
 __am_kcontext_start:
+#ifdef __x86_64__
   // rdi = arg, rsi = entry
 
   // (rsp + 8) should be multiple of 16 when
@@ -8,3 +9,14 @@ __am_kcontext_start:
   andq $0xfffffffffffffff0, %rsp
   call *%rsi
   call __am_panic_on_return
+#elif __aarch64__
+  // x0 = arg, x1 = entry
+  // (sp + 16) should be multiple of 16 when
+  // control is transfered to the function entry point.
+  // See aarch64 ABI manual for more details
+  // https://github.com/ARM-software/abi-aa
+  mov x2, sp
+  and sp, x2, #0xfffffffffffffff0
+  br x1
+  bl __am_panic_on_return
+#endif

am/src/native/vme.c

@@ -124,8 +124,8 @@ Context* ucontext(AddrSpace *as, Area kstack, void *entry) {
   Context *c = (Context*)kstack.end - 1;
 
   __am_get_example_uc(c);
-  c->uc.uc_mcontext.gregs[REG_RIP] = (uintptr_t)entry;
-  c->uc.uc_mcontext.gregs[REG_RSP] = (uintptr_t)USER_SPACE.end;
+  REG_PC(&c->uc) = (uintptr_t)entry;
+  REG_SP(&c->uc) = (uintptr_t)USER_SPACE.end;
 
   int ret = sigemptyset(&(c->uc.uc_sigmask)); // enable interrupt
   assert(ret == 0);

scripts/native.mk

@@ -12,10 +12,10 @@ AM_SRCS := native/trm.c \
            native/ioe/audio.c \
            native/ioe/disk.c \
 
-CFLAGS  += -fpie
+CFLAGS  += -fpie $(shell sdl2-config --cflags)
 ASFLAGS += -fpie -pie
 comma = ,
-LDFLAGS_CXX = $(addprefix -Wl$(comma), $(LDFLAGS)) -pie -lSDL2 -ldl
+LDFLAGS_CXX = $(addprefix -Wl$(comma), $(LDFLAGS)) -pie -ldl $(shell sdl2-config --libs)
 
 run: image
 	$(IMAGE).elf