package main

import "strings"

var regNamesWasm = []string{
	"R0",
	"R1",
	"R2",
	"R3",
	"R4",
	"R5",
	"R6",
	"R7",
	"R8",
	"R9",
	"R10",
	"R11",
	"R12",
	"R13",
	"R14",
	"R15",

	"F0",
	"F1",
	"F2",
	"F3",
	"F4",
	"F5",
	"F6",
	"F7",
	"F8",
	"F9",
	"F10",
	"F11",
	"F12",
	"F13",
	"F14",
	"F15",

	"F16",
	"F17",
	"F18",
	"F19",

#define BYTES R7
// const 16 used as index
#define IDX16 R8
// temp used for copies, etc.
#define TMP R9
// number of 64 byte chunks
#define QWORDS R10
// index values
#define IDX32 R14
#define IDX48 R15
#define OCTWORDS R16

TEXT runtime·memmove<ABIInternal>(SB), NOSPLIT|NOFRAME, $0-24
	// R3 = TGT = to
	// R4 = SRC = from
	// R5 = LEN = n

	// Determine if there are doublewords to

// This is called from .init_array and follows the platform, not Go, ABI.
TEXT runtime·addmoduledata(SB),NOSPLIT,$0-0
	PUSHQ	R15 // The access to global variables below implicitly uses R15, which is callee-save
	MOVQ	runtime·lastmoduledatap(SB), AX
	MOVQ	DI, moduledata_next(AX)
	MOVQ	DI, runtime·lastmoduledatap(SB)
	POPQ	R15
	RET

// Initialize special registers then jump to sigpanic.

	MOVV	R6, (2*8)(R25)
	MOVV	R7, (3*8)(R25)
	MOVV	R8, (4*8)(R25)
	MOVV	R9, (5*8)(R25)
	MOVV	R10, (6*8)(R25)
	MOVV	R11, (7*8)(R25)
	MOVV	R12, (8*8)(R25)
	MOVV	R13, (9*8)(R25)
	MOVV	R14, (10*8)(R25)
	MOVV	R15, (11*8)(R25)
	MOVV	R16, (12*8)(R25)
	MOVV	R17, (13*8)(R25)
	MOVV	R18, (14*8)(R25)
	MOVV	R19, (15*8)(R25)
	MOVD	F0, (16*8)(R25)
	MOVD	F1, (17*8)(R25)
	MOVD	F2, (18*8)(R25)
	MOVD	F3, (19*8)(R25)

	MOVD	0(R3), R4		// arg 2 - attr
	MOVD	8(R3), R5		// arg 3 - start
	MOVD	16(R3), R6		// arg 4 - arg

	MOVD	R1, R15
	SUB	$64, R1
	RLDCR	$0, R1, $~15, R1
	MOVD	R1, R3			// arg 1 - &threadid (discard)
	CALL	libc_pthread_create(SB)
	MOVD	R15, R1

	RET

TEXT runtime·thrkill_trampoline(SB),NOSPLIT,$32
	MOVD	8(R3), R4		// arg 2 - signal (int64)
	MOVD	$0, R5			// arg 3 - tcb

	REGENTRYTMP1 = REG_R13     // scratch register available at function entry in ABIInternal
	REGG         = REG_R14     // g register in ABIInternal
	REGEXT       = REG_R15     // compiler allocates external registers R15 down
	FREGMIN      = REG_X0 + 5  // first register variable
	FREGEXT      = REG_X0 + 15 // first external register
	T_TYPE       = 1 << 0
	T_INDEX      = 1 << 1
	T_OFFSET     = 1 << 2
	T_FCONST     = 1 << 3

// Offsets into Thread Environment Block (pointer in R18)
#define TEB_error 0x68
#define TEB_TlsSlots 0x1480
#define TEB_ArbitraryPtr 0x28

// Note: R0-R7 are args, R8 is indirect return value address,
// R9-R15 are caller-save, R19-R29 are callee-save.
//
// load_g and save_g (in tls_arm64.s) clobber R27 (REGTMP) and R0.

TEXT runtime·asmstdcall_trampoline<ABIInternal>(SB),NOSPLIT,$0
	B	runtime·asmstdcall(SB)

	STP	(R0, R1), (0*8)(R20)
	STP	(R2, R3), (2*8)(R20)
	STP	(R4, R5), (4*8)(R20)
	STP	(R6, R7), (6*8)(R20)
	STP	(R8, R9), (8*8)(R20)
	STP	(R10, R11), (10*8)(R20)
	STP	(R12, R13), (12*8)(R20)
	STP	(R14, R15), (14*8)(R20)
	FSTPD	(F0, F1), (16*8)(R20)
	FSTPD	(F2, F3), (18*8)(R20)
	FSTPD	(F4, F5), (20*8)(R20)
	FSTPD	(F6, F7), (22*8)(R20)
	FSTPD	(F8, F9), (24*8)(R20)
	FSTPD	(F10, F11), (26*8)(R20)

	// An attempt to synchronize on the address would cause crash.
	MOVD	R8, R15	// save the original function
	MOVD	R6, R17 // save the original arg list addr
	MOVD	$__tsan_go_ignore_sync_begin(SB), R8 // func addr to call
	MOVD    runtime·tls_g(SB), R10
	MOVD    0(R10), g
	MOVD    g_racectx(g), R3        // goroutine context
	BL	racecall<>(SB)
	MOVD	R15, R8	// restore the original function
	MOVD	R17, R6 // restore arg list addr

	Code   int32
	Pid    int32
	Uid    uint32
	Status int32
	Addr   uintptr
	Value  [8]byte
	_      [40]byte
}

type Sigset_t struct {
	Val [4]uint32
}

type Reg struct {
	R15    int64
	R14    int64
	R13    int64
	R12    int64
	R11    int64
	R10    int64
	R9     int64
	R8     int64
	Rdi    int64
	Rsi    int64
	Rbp    int64
	Rbx    int64
	Rdx    int64