/* -----------------------------------------------------------------------
   sysv.S - Copyright (c) 2013 Imagination Technologies Ltd.

   Meta Foreign Function Interface

   Permission is hereby granted, free of charge, to any person obtaining
   a copy of this software and associated documentation files (the
   ``Software''), to deal in the Software without restriction, including
   without limitation the rights to use, copy, modify, merge, publish,
   distribute, sublicense, and/or sell copies of the Software, and to
   permit persons to whom the Software is furnished to do so, subject to
   the following conditions:

   The above copyright notice and this permission notice shall be included
   in all copies or substantial portions of the Software.


   THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
   NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
   DEALINGS IN THE SOFTWARE.
   ----------------------------------------------------------------------- */

#define LIBFFI_ASM
#include <fficonfig.h>
#include <ffi.h>
#ifdef HAVE_MACHINE_ASM_H
#include <machine/asm.h>
#else
#ifdef __USER_LABEL_PREFIX__
#define CONCAT1(a, b) CONCAT2(a, b)
#define CONCAT2(a, b) a ## b

/* Use the right prefix for global labels. */
#define CNAME(x) CONCAT1 (__USER_LABEL_PREFIX__, x)
#else
#define CNAME(x) x
#endif
#define ENTRY(x) .globl CNAME(x); .type CNAME(x), %function; CNAME(x):
#endif

#ifdef __ELF__
#define LSYM(x) .x
#else
#define LSYM(x) x
#endif

.macro call_reg x=
	.text
	.balign 4
	mov D1RtP, \x
	swap D1RtP, PC
.endm

! Save register arguments
.macro SAVE_ARGS
	.text
	.balign 4
	setl	[A0StP++], D0Ar6, D1Ar5
	setl	[A0StP++], D0Ar4, D1Ar3
	setl	[A0StP++], D0Ar2, D1Ar1
.endm

! Save retrun, frame pointer and other regs
.macro SAVE_REGS regs=
	.text
	.balign 4
	setl	[A0StP++], D0FrT, D1RtP
	! Needs to be a pair of regs
	.ifnc "\regs",""
	setl	[A0StP++], \regs
	.endif
.endm

! Declare a global function
.macro METAG_FUNC_START name
	.text
	.balign 4
	ENTRY(\name)
.endm

! Return registers from the stack. Reverse SAVE_REGS operation
.macro RET_REGS regs=, cond=
	.ifnc "\regs", ""
	getl	\regs, [--A0StP]
	.endif
	getl	D0FrT, D1RtP, [--A0StP]
.endm

! Return arguments
.macro RET_ARGS
	getl	D0Ar2, D1Ar1, [--A0StP]
	getl	D0Ar4, D1Ar3, [--A0StP]
	getl	D0Ar6, D1Ar5, [--A0StP]
.endm


	! D1Ar1:	fn
	! D0Ar2:	&ecif
	! D1Ar3:	cif->bytes
	! D0Ar4:	fig->flags
	! D1Ar5:	ecif.rvalue

	! This assumes we are using GNU as
METAG_FUNC_START ffi_call_SYSV
	! Save argument registers

	SAVE_ARGS

	! new frame
	mov	D0FrT, A0FrP
	add     A0FrP, A0StP, #0

	! Preserve the old frame pointer
	SAVE_REGS "D1.5, D0.5"

	! Make room for new args. cifs->bytes is the total space for input
	! and return arguments

	add	A0StP, A0StP, D1Ar3

	! Preserve cifs->bytes & fn
	mov	D0.5, D1Ar3
	mov	D1.5, D1Ar1

	! Place all of the ffi_prep_args in position
	mov	D1Ar1, A0StP

	! Call ffi_prep_args(stack, &ecif)
#ifdef __PIC__
	callr  D1RtP, CNAME(ffi_prep_args@PLT)
#else
	callr  D1RtP, CNAME(ffi_prep_args)
#endif

	! Restore fn pointer

	! The foreign stack should look like this
	! XXXXX XXXXXX <--- stack pointer
	! FnArgN rvalue
	! FnArgN+2 FnArgN+1
	! FnArgN+4 FnArgN+3
	! ....
	!

	! A0StP now points to the first (or return) argument + 4

	! Preserve cif->bytes
	getl	D0Ar2, D1Ar1, [--A0StP]
	getl	D0Ar4, D1Ar3, [--A0StP]
	getl	D0Ar6, D1Ar5, [--A0StP]

	! Place A0StP to the first argument again
	add	A0StP, A0StP, #24 ! That's because we loaded 6 regs x 4 byte each

	! A0FrP points to the initial stack without the reserved space for the
	! cifs->bytes, whilst A0StP points to the stack after the space allocation

	! fn was the first argument of ffi_call_SYSV.
	! The stack at this point looks like this:
	!
	! A0StP(on entry to _SYSV) ->	Arg6	Arg5     | low
	!				Arg4	Arg3     |
	! 				Arg2	Arg1     |
	! A0FrP ---->			D0FrtP	D1RtP    |
	!				D1.5	D0.5	 |
	! A0StP(bf prep_args) ->	FnArgn	FnArgn-1 |
	!				FnArgn-2FnArgn-3 |
	!				................ | <= cifs->bytes
	!				FnArg4  FnArg3	 |
	! A0StP (prv_A0StP+cifs->bytes) FnArg2  FnArg1   | high
	!
	! fn was in Arg1 so it's located in in A0FrP+#-0xC
	!

	! D0Re0 contains the size of arguments stored in registers
	sub	A0StP, A0StP, D0Re0

	! Arg1 is the function pointer for the foreign call. This has been
	! preserved in D1.5

	! Time to call (fn). Arguments should be like this:
	! Arg1-Arg6 are loaded to regs
	! The rest of the arguments are stored in stack pointed by A0StP

	call_reg D1.5

	! Reset stack.

	mov	A0StP, A0FrP

	! Load Arg1 with the pointer to storage for the return type
	! This was stored in Arg5

	getd	D1Ar1, [A0FrP+#-20]

	! Load D0Ar2 with the return type code. This was stored in Arg4 (flags)

	getd	D0Ar2, [A0FrP+#-16]

	! We are ready to start processing the return value
	! D0Re0 (and D1Re0) hold the return value

	! If the return value is NULL, assume no return value
	cmp	D1Ar1, #0
	beq	LSYM(Lepilogue)

	! return INT
	cmp		D0Ar2, #FFI_TYPE_INT
	! Sadly, there is no setd{cc} instruction so we need to workaround that
	bne	.INT64
	setd	[D1Ar1], D0Re0
	b	LSYM(Lepilogue)

	! return INT64
.INT64:
	cmp	D0Ar2, #FFI_TYPE_SINT64
	setleq	[D1Ar1], D0Re0, D1Re0

	! return DOUBLE
	cmp	D0Ar2, #FFI_TYPE_DOUBLE
	setl	[D1AR1++], D0Re0, D1Re0

LSYM(Lepilogue):
	! At this point, the stack pointer points right after the argument
	! saved area. We need to restore 4 regs, therefore we need to move
	! 16 bytes ahead.
	add     A0StP, A0StP, #16
	RET_REGS "D1.5, D0.5"
	RET_ARGS
	getd	D0Re0, [A0StP]
	mov     A0FrP, D0FrT
	swap	D1RtP, PC

.ffi_call_SYSV_end:
       .size   CNAME(ffi_call_SYSV),.ffi_call_SYSV_end-CNAME(ffi_call_SYSV)


/*
	(called by ffi_metag_trampoline)
	void ffi_closure_SYSV (ffi_closure*)

	(called by ffi_closure_SYSV)
	unsigned int FFI_HIDDEN
	ffi_closure_SYSV_inner (closure,respp, args)
		ffi_closure *closure;
		void **respp;
		void *args;
*/

METAG_FUNC_START ffi_closure_SYSV
	! We assume that D1Ar1 holds the address of the
	! ffi_closure struct. We will use that to fetch the
	! arguments. The stack pointer points to an empty space
	! and it is ready to store more data.

	! D1Ar1 is ready
	! Allocate stack space for return value
	add A0StP, A0StP, #8
	! Store it to D0Ar2
	sub D0Ar2, A0StP, #8

	sub D1Ar3, A0FrP, #4

	! D1Ar3 contains the address of the original D1Ar1 argument
	! We need to subtract #4 later on

	! Preverve D0Ar2
	mov D0.5, D0Ar2

#ifdef __PIC__
	callr D1RtP, CNAME(ffi_closure_SYSV_inner@PLT)
#else
	callr D1RtP, CNAME(ffi_closure_SYSV_inner)
#endif

	! Check the return value and store it to D0.5
	cmp D0Re0, #FFI_TYPE_INT
	beq .Lretint
	cmp D0Re0, #FFI_TYPE_DOUBLE
	beq .Lretdouble
.Lclosure_epilogue:
	sub A0StP, A0StP, #8
	RET_REGS "D1.5, D0.5"
	RET_ARGS
	swap	D1RtP, PC

.Lretint:
	setd [D0.5], D0Re0
	b .Lclosure_epilogue
.Lretdouble:
	setl [D0.5++], D0Re0, D1Re0
	b .Lclosure_epilogue
.ffi_closure_SYSV_end:
.size CNAME(ffi_closure_SYSV),.ffi_closure_SYSV_end-CNAME(ffi_closure_SYSV)


ENTRY(ffi_metag_trampoline)
	SAVE_ARGS
	! New frame
	mov A0FrP, A0StP
	SAVE_REGS "D1.5, D0.5"
	mov D0.5, PC
	! Load D1Ar1 the value of ffi_metag_trampoline
	getd D1Ar1, [D0.5 + #8]
	! Jump to ffi_closure_SYSV
	getd PC, [D0.5 + #12]