sys_amd64.s

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2022 The Ebitengine Authors

//go:build darwin || freebsd || linux || netbsd

#include "textflag.h"
#include "abi_amd64.h"
#include "go_asm.h"
#include "funcdata.h"

#define STACK_SIZE 224
#define PTR_ADDRESS (STACK_SIZE - 8)

// syscallX calls a function in libc on behalf of the syscall package.
// syscallX takes a pointer to a struct like:
// struct {
//	fn    uintptr
//	a1    uintptr
//	a2    uintptr
//	a3    uintptr
//	a4    uintptr
//	a5    uintptr
//	a6    uintptr
//	a7    uintptr
//	a8    uintptr
//	a9    uintptr
//	a10    uintptr
//	a11    uintptr
//	a12    uintptr
//	a13    uintptr
//	a14    uintptr
//	a15    uintptr
//	r1    uintptr
//	r2    uintptr
//	err   uintptr
// }
// syscallX must be called on the g0 stack with the
// C calling convention (use libcCall).
GLOBL ·syscallXABI0(SB), NOPTR|RODATA, $8
DATA ·syscallXABI0(SB)/8, $syscallX(SB)
TEXT syscallX(SB), NOSPLIT, $STACK_SIZE
	MOVQ  DI, PTR_ADDRESS(SP) // save the pointer
	MOVQ  DI, R11

	MOVQ syscallArgs_f1(R11), X0 // f1
	MOVQ syscallArgs_f2(R11), X1 // f2
	MOVQ syscallArgs_f3(R11), X2 // f3
	MOVQ syscallArgs_f4(R11), X3 // f4
	MOVQ syscallArgs_f5(R11), X4 // f5
	MOVQ syscallArgs_f6(R11), X5 // f6
	MOVQ syscallArgs_f7(R11), X6 // f7
	MOVQ syscallArgs_f8(R11), X7 // f8

	MOVQ syscallArgs_a1(R11), DI // a1
	MOVQ syscallArgs_a2(R11), SI // a2
	MOVQ syscallArgs_a3(R11), DX // a3
	MOVQ syscallArgs_a4(R11), CX // a4
	MOVQ syscallArgs_a5(R11), R8 // a5
	MOVQ syscallArgs_a6(R11), R9 // a6

	// push the remaining parameters onto the stack
	MOVQ syscallArgs_a7(R11), R12
	MOVQ R12, 0(SP)                  // push a7
	MOVQ syscallArgs_a8(R11), R12
	MOVQ R12, 8(SP)                  // push a8
	MOVQ syscallArgs_a9(R11), R12
	MOVQ R12, 16(SP)                 // push a9
	MOVQ syscallArgs_a10(R11), R12
	MOVQ R12, 24(SP)                 // push a10
	MOVQ syscallArgs_a11(R11), R12
	MOVQ R12, 32(SP)                 // push a11
	MOVQ syscallArgs_a12(R11), R12
	MOVQ R12, 40(SP)                 // push a12
	MOVQ syscallArgs_a13(R11), R12
	MOVQ R12, 48(SP)                 // push a13
	MOVQ syscallArgs_a14(R11), R12
	MOVQ R12, 56(SP)                 // push a14
	MOVQ syscallArgs_a15(R11), R12
	MOVQ R12, 64(SP)                 // push a15
	MOVQ syscallArgs_a16(R11), R12
	MOVQ R12, 72(SP)                 // push a16
	MOVQ syscallArgs_a17(R11), R12
	MOVQ R12, 80(SP)                 // push a17
	MOVQ syscallArgs_a18(R11), R12
	MOVQ R12, 88(SP)                 // push a18
	MOVQ syscallArgs_a19(R11), R12
	MOVQ R12, 96(SP)                 // push a19
	MOVQ syscallArgs_a20(R11), R12
	MOVQ R12, 104(SP)                // push a20
	MOVQ syscallArgs_a21(R11), R12
	MOVQ R12, 112(SP)                // push a21
	MOVQ syscallArgs_a22(R11), R12
	MOVQ R12, 120(SP)                // push a22
	MOVQ syscallArgs_a23(R11), R12
	MOVQ R12, 128(SP)                // push a23
	MOVQ syscallArgs_a24(R11), R12
	MOVQ R12, 136(SP)                // push a24
	MOVQ syscallArgs_a25(R11), R12
	MOVQ R12, 144(SP)                // push a25
	MOVQ syscallArgs_a26(R11), R12
	MOVQ R12, 152(SP)                // push a26
	MOVQ syscallArgs_a27(R11), R12
	MOVQ R12, 160(SP)                // push a27
	MOVQ syscallArgs_a28(R11), R12
	MOVQ R12, 168(SP)                // push a28
	MOVQ syscallArgs_a29(R11), R12
	MOVQ R12, 176(SP)                // push a29
	MOVQ syscallArgs_a30(R11), R12
	MOVQ R12, 184(SP)                // push a30
	MOVQ syscallArgs_a31(R11), R12
	MOVQ R12, 192(SP)                // push a31
	MOVQ syscallArgs_a32(R11), R12
	MOVQ R12, 200(SP)                // push a32
	XORL AX, AX                      // vararg: say "no float args"

	MOVQ syscallArgs_fn(R11), R10 // fn
	CALL R10

	MOVQ PTR_ADDRESS(SP), DI      // get the pointer back
	MOVQ AX, syscallArgs_a1(DI) // r1
	MOVQ DX, syscallArgs_a2(DI) // r2
	MOVQ X0, syscallArgs_f1(DI) // f1
	MOVQ X1, syscallArgs_f2(DI) // f2

#ifdef GOOS_darwin
	CALL purego_error(SB)
	MOVQ PTR_ADDRESS(SP), DI      // reload (DI clobbered by call)
	MOVQ (AX), AX
	MOVQ AX, syscallArgs_a3(DI) // save errno
#endif

	XORL AX, AX          // no error (it's ignored anyway)
	RET

TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0
	MOVQ 0(SP), AX  // save the return address to calculate the cb index
	MOVQ 8(SP), R10 // get the return SP so that we can align register args with stack args
	ADDQ $8, SP     // remove return address from stack, we are not returning to callbackasm, but to its caller.

	// make space for first six int and 8 float arguments below the frame
	ADJSP $14*8, SP
	MOVSD X0, (1*8)(SP)
	MOVSD X1, (2*8)(SP)
	MOVSD X2, (3*8)(SP)
	MOVSD X3, (4*8)(SP)
	MOVSD X4, (5*8)(SP)
	MOVSD X5, (6*8)(SP)
	MOVSD X6, (7*8)(SP)
	MOVSD X7, (8*8)(SP)
	MOVQ  DI, (9*8)(SP)
	MOVQ  SI, (10*8)(SP)
	MOVQ  DX, (11*8)(SP)
	MOVQ  CX, (12*8)(SP)
	MOVQ  R8, (13*8)(SP)
	MOVQ  R9, (14*8)(SP)
	LEAQ  8(SP), R8      // R8 = address of args vector

	PUSHQ R10 // push the stack pointer below registers

	// Switch from the host ABI to the Go ABI.
	PUSH_REGS_HOST_TO_ABI0()

	// determine index into runtime·cbs table
	MOVQ $callbackasm(SB), DX
	SUBQ DX, AX
	MOVQ $0, DX
	MOVQ $5, CX               // divide by 5 because each call instruction in ·callbacks is 5 bytes long
	DIVL CX
	SUBQ $1, AX               // subtract 1 because return PC is to the next slot

	// Create a struct callbackArgs on our stack to be passed as
	// the "frame" to cgocallback and on to callbackWrap.
	// $24 to make enough room for the arguments to runtime.cgocallback
	SUBQ $(24+callbackArgs__size), SP
	MOVQ AX, (24+callbackArgs_index)(SP)  // callback index
	MOVQ R8, (24+callbackArgs_args)(SP)   // address of args vector
	MOVQ DI, (24+callbackArgs_result)(SP) // result
	LEAQ 24(SP), AX                       // take the address of callbackArgs

	// Call cgocallback, which will call callbackWrap(frame).
	MOVQ ·callbackWrap_call(SB), DI // Get the ABIInternal function pointer
	MOVQ (DI), DI                   // without <ABIInternal> by using a closure.
	MOVQ AX, SI                     // frame (address of callbackArgs)
	MOVQ $0, CX                     // context

	CALL crosscall2(SB) // runtime.cgocallback(fn, frame, ctxt uintptr)

	// Get callback result.
	MOVQ (24+callbackArgs_result)(SP), AX
	MOVQ (24+callbackArgs_result+8)(SP), DX
	// Restore XMM0/XMM1 from result[2]/result[3] for struct eightbytes
	// classified as SSE by the SysV ABI.
	MOVQ (24+callbackArgs_result+16)(SP), X0
	MOVQ (24+callbackArgs_result+24)(SP), X1
	ADDQ $(24+callbackArgs__size), SP      // remove callbackArgs struct

	POP_REGS_HOST_TO_ABI0()

	POPQ  R10        // get the SP back
	ADJSP $-14*8, SP // remove arguments

	MOVQ R10, 0(SP)

	RET