[Linux] Implement thunk generation

Author: uytvbn

src/xenia/cpu/backend/x64/x64_backend.cc

@@ -403,9 +403,9 @@ X64ThunkEmitter::X64ThunkEmitter(X64Backend* backend, XbyakAllocator* allocator)
 X64ThunkEmitter::~X64ThunkEmitter() {}
 
 HostToGuestThunk X64ThunkEmitter::EmitHostToGuestThunk() {
-  // rcx = target
-  // rdx = arg0 (context)
-  // r8 = arg1 (guest return address)
+  // rcx (win), rdi (linux) = target
+  // rdx (win), rsi (linux) = arg0 (context)
+  // r8 (win), rdx (linux) = arg1 (guest return address)
 
   struct _code_offsets {
     size_t prolog;
@@ -420,9 +420,15 @@ HostToGuestThunk X64ThunkEmitter::EmitHostToGuestThunk() {
   code_offsets.prolog = getSize();
 
   // rsp + 0 = return address
+#if XE_PLATFORM_LINUX
+  mov(qword[rsp + 8 * 3], rdx);
+  mov(qword[rsp + 8 * 2], rsi);
+  mov(qword[rsp + 8 * 1], rdi);
+#else
   mov(qword[rsp + 8 * 3], r8);
   mov(qword[rsp + 8 * 2], rdx);
   mov(qword[rsp + 8 * 1], rcx);
+#endif
   sub(rsp, stack_size);
 
   code_offsets.prolog_stack_alloc = getSize();
@@ -431,19 +437,31 @@ HostToGuestThunk X64ThunkEmitter::EmitHostToGuestThunk() {
   // Save nonvolatile registers.
   EmitSaveNonvolatileRegs();
 
+#ifdef XE_PLATFORM_LINUX
+  mov(rax, rdi);
+  // context already in rsi
+  mov(rcx, rdx);  // return address
+#else
   mov(rax, rcx);
   mov(rsi, rdx);  // context
   mov(rcx, r8);   // return address
+#endif
   call(rax);
 
   EmitLoadNonvolatileRegs();
 
   code_offsets.epilog = getSize();
 
   add(rsp, stack_size);
+#if XE_PLATFORM_LINUX
+  mov(rdi, qword[rsp + 8 * 1]);
+  mov(rsi, qword[rsp + 8 * 2]);
+  mov(rdx, qword[rsp + 8 * 3]);
+#else
   mov(rcx, qword[rsp + 8 * 1]);
   mov(rdx, qword[rsp + 8 * 2]);
   mov(r8, qword[rsp + 8 * 3]);
+#endif
   ret();
 
   code_offsets.tail = getSize();
@@ -464,10 +482,12 @@ HostToGuestThunk X64ThunkEmitter::EmitHostToGuestThunk() {
 }
 
 GuestToHostThunk X64ThunkEmitter::EmitGuestToHostThunk() {
-  // rcx = target function
-  // rdx = arg0
-  // r8  = arg1
-  // r9  = arg2
+  // rcx (windows), rdi (linux) = target function
+  // rdx (windows), rsi (linux) = arg0
+  // r8  (windows), rdx (linux) = arg1
+  // r9  (windows), rcx (linux) = arg2
+  // --- (windows), r8  (linux) = arg3
+  // --- (windows), r9  (linux) = arg4
 
   struct _code_offsets {
     size_t prolog;
@@ -490,8 +510,13 @@ GuestToHostThunk X64ThunkEmitter::EmitGuestToHostThunk() {
   // Save off volatile registers.
   EmitSaveVolatileRegs();
 
-  mov(rax, rcx);              // function
+  mov(rax, rcx);  // function
+#if XE_PLATFORM_LINUX
+  mov(rdi, GetContextReg());  // context
+  mov(rsi, rbx);
+#else
   mov(rcx, GetContextReg());  // context
+#endif
   call(rax);
 
   EmitLoadVolatileRegs();
@@ -546,8 +571,13 @@ ResolveFunctionThunk X64ThunkEmitter::EmitResolveFunctionThunk() {
   // Save volatile registers
   EmitSaveVolatileRegs();
 
-  mov(rcx, rsi);  // context
+#if XE_PLATFORM_LINUX
+  mov(rdi, rsi);  // context
+  mov(rsi, rbx);
+#else
+  mov(rcx, rsi);              // context
   mov(rdx, rbx);
+#endif
   mov(rax, uint64_t(&ResolveFunction));
   call(rax);
 

src/xenia/cpu/backend/x64/x64_emitter.cc

@@ -499,9 +499,9 @@ void X64Emitter::CallExtern(const hir::Instr* instr, const Function* function) {
     if (builtin_function->handler()) {
       undefined = false;
       // rcx = target function
-      // rdx = arg0
-      // r8  = arg1
-      // r9  = arg2
+      // rdx (windows), r8 (linux) = arg0
+      // r8  (windows), rdx (linux) = arg1
+      // r9  (windows), rcx (linux) = arg2
       auto thunk = backend()->guest_to_host_thunk();
       mov(rax, reinterpret_cast<uint64_t>(thunk));
       mov(rcx, reinterpret_cast<uint64_t>(builtin_function->handler()));
@@ -515,9 +515,9 @@ void X64Emitter::CallExtern(const hir::Instr* instr, const Function* function) {
     if (extern_function->extern_handler()) {
       undefined = false;
       // rcx = target function
-      // rdx = arg0
-      // r8  = arg1
-      // r9  = arg2
+      // rdx (windows), r8 (linux) = arg0
+      // r8  (windows), rdx (linux) = arg1
+      // r9  (windows), rcx (linux) = arg2
       auto thunk = backend()->guest_to_host_thunk();
       mov(rax, reinterpret_cast<uint64_t>(thunk));
       mov(rcx, reinterpret_cast<uint64_t>(extern_function->extern_handler()));
@@ -550,9 +550,9 @@ void X64Emitter::CallNative(uint64_t (*fn)(void* raw_context, uint64_t arg0),
 
 void X64Emitter::CallNativeSafe(void* fn) {
   // rcx = target function
-  // rdx = arg0
-  // r8  = arg1
-  // r9  = arg2
+  // rdx (windows), r8 (linux) = arg0
+  // r8  (windows), rdx (linux) = arg1
+  // r9  (windows), rcx (linux) = arg2
   auto thunk = backend()->guest_to_host_thunk();
   mov(rax, reinterpret_cast<uint64_t>(thunk));
   mov(rcx, reinterpret_cast<uint64_t>(fn));
@@ -566,6 +566,17 @@ void X64Emitter::SetReturnAddress(uint64_t value) {
 }
 
 Xbyak::Reg64 X64Emitter::GetNativeParam(uint32_t param) {
+#if XE_PLATFORM_LINUX
+  if (param == 0)
+    return rbx;
+  else if (param == 1)
+    return rdx;
+  else if (param == 2)
+    return rcx;
+
+  assert_always();
+  return rcx;
+#else
   if (param == 0)
     return rdx;
   else if (param == 1)
@@ -575,6 +586,7 @@ Xbyak::Reg64 X64Emitter::GetNativeParam(uint32_t param) {
 
   assert_always();
   return r9;
+#endif
 }
 
 // Important: If you change these, you must update the thunks in x64_backend.cc!