ffi 1.9.21-x64-mingw32 → 1.9.22-x64-mingw32

data/ext/ffi_c/libffi/src/metag/ffitarget.h

@@ -1,53 +0,0 @@
-/* -----------------------------------------------------------------*-C-*-
-   ffitarget.h - Copyright (c) 2013 Imagination Technologies Ltd.
-   Target configuration macros for Meta
-
-   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.
-
-   ----------------------------------------------------------------------- */
-
-#ifndef LIBFFI_TARGET_H
-#define LIBFFI_TARGET_H
-
-#ifndef LIBFFI_H
-#error "Please do not include ffitarget.h directly into your source.  Use ffi.h instead."
-#endif
-
-#ifndef LIBFFI_ASM
-typedef unsigned long          ffi_arg;
-typedef signed long            ffi_sarg;
-
-typedef enum ffi_abi {
-  FFI_FIRST_ABI = 0,
-  FFI_SYSV,
-  FFI_DEFAULT_ABI = FFI_SYSV,
-  FFI_LAST_ABI = FFI_DEFAULT_ABI + 1,
-} ffi_abi;
-#endif
-
-/* ---- Definitions for closures ----------------------------------------- */
-
-#define FFI_CLOSURES 1
-#define FFI_TRAMPOLINE_SIZE 48
-#define FFI_NATIVE_RAW_API 0
-
-#endif
-

data/ext/ffi_c/libffi/src/metag/sysv.S

@@ -1,311 +0,0 @@
-/* -----------------------------------------------------------------------
-   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]

data/ext/ffi_c/libffi/src/microblaze/ffi.c

@@ -1,321 +0,0 @@
-/* -----------------------------------------------------------------------
-   ffi.c - Copyright (c) 2012, 2013 Xilinx, Inc
-
-   MicroBlaze 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.
-   ----------------------------------------------------------------------- */
-
-#include <ffi.h>
-#include <ffi_common.h>
-
-extern void ffi_call_SYSV(void (*)(void*, extended_cif*), extended_cif*,
-		unsigned int, unsigned int, unsigned int*, void (*fn)(void),
-		unsigned int, unsigned int);
-
-extern void ffi_closure_SYSV(void);
-
-#define WORD_SIZE			sizeof(unsigned int)
-#define ARGS_REGISTER_SIZE	(WORD_SIZE * 6)
-#define WORD_FFI_ALIGN(x)		FFI_ALIGN(x, WORD_SIZE)
-
-/* ffi_prep_args is called by the assembly routine once stack space
-   has been allocated for the function's arguments */
-void ffi_prep_args(void* stack, extended_cif* ecif)
-{
-	unsigned int i;
-	ffi_type** p_arg;
-	void** p_argv;
-	void* stack_args_p = stack;
-
-	if (ecif == NULL || ecif->cif == NULL) {
-		return; /* no description to prepare */
-	}
-
-	p_argv = ecif->avalue;
-
-	if ((ecif->cif->rtype != NULL) &&
-			(ecif->cif->rtype->type == FFI_TYPE_STRUCT))
-	{
-		/* if return type is a struct which is referenced on the stack/reg5,
-		 * by a pointer. Stored the return value pointer in r5.
-		 */
-		char* addr = stack_args_p;
-		memcpy(addr, &(ecif->rvalue), WORD_SIZE);
-		stack_args_p += WORD_SIZE;
-	}
-
-	if (ecif->avalue == NULL) {
-		return; /* no arguments to prepare */
-	}
-
-	for (i = 0, p_arg = ecif->cif->arg_types; i < ecif->cif->nargs;
-			i++, p_arg++)
-	{
-		size_t size = (*p_arg)->size;
-		int type = (*p_arg)->type;
-		void* value = p_argv[i];
-		char* addr = stack_args_p;
-		int aligned_size = WORD_FFI_ALIGN(size);
-
-		/* force word alignment on the stack */
-		stack_args_p += aligned_size;
-		
-		switch (type)
-		{
-			case FFI_TYPE_UINT8:
-				*(unsigned int *)addr = (unsigned int)*(UINT8*)(value);
-				break;
-			case FFI_TYPE_SINT8:
-				*(signed int *)addr = (signed int)*(SINT8*)(value);
-				break;
-			case FFI_TYPE_UINT16:
-				*(unsigned int *)addr = (unsigned int)*(UINT16*)(value);
-				break;
-			case FFI_TYPE_SINT16:
-				*(signed int *)addr = (signed int)*(SINT16*)(value);
-				break;
-			case FFI_TYPE_STRUCT:
-#if __BIG_ENDIAN__
-				/*
-				 * MicroBlaze toolchain appears to emit:
-				 * bsrli r5, r5, 8 (caller)
-				 * ...
-				 * <branch to callee>
-				 * ...
-				 * bslli r5, r5, 8 (callee)
-				 * 
-				 * For structs like "struct a { uint8_t a[3]; };", when passed
-				 * by value.
-				 *
-				 * Structs like "struct b { uint16_t a; };" are also expected
-				 * to be packed strangely in registers.
-				 *
-				 * This appears to be because the microblaze toolchain expects
-				 * "struct b == uint16_t", which is only any issue for big
-				 * endian.
-				 *
-				 * The following is a work around for big-endian only, for the
-				 * above mentioned case, it will re-align the contents of a
-				 * <= 3-byte struct value.
-				 */
-				if (size < WORD_SIZE)
-				{
-				  memcpy (addr + (WORD_SIZE - size), value, size);
-				  break;
-				}
-#endif
-			case FFI_TYPE_SINT32:
-			case FFI_TYPE_UINT32:
-			case FFI_TYPE_FLOAT:
-			case FFI_TYPE_SINT64:
-			case FFI_TYPE_UINT64:
-			case FFI_TYPE_DOUBLE:
-			default:
-				memcpy(addr, value, aligned_size);
-		}
-	}
-}
-
-ffi_status ffi_prep_cif_machdep(ffi_cif* cif)
-{
-	/* check ABI */
-	switch (cif->abi)
-	{
-		case FFI_SYSV:
-			break;
-		default:
-			return FFI_BAD_ABI;
-	}
-	return FFI_OK;
-}
-
-void ffi_call(ffi_cif* cif, void (*fn)(void), void* rvalue, void** avalue)
-{
-	extended_cif ecif;
-	ecif.cif = cif;
-	ecif.avalue = avalue;
-
-	/* If the return value is a struct and we don't have a return */
-	/* value address then we need to make one */
-	if ((rvalue == NULL) && (cif->rtype->type == FFI_TYPE_STRUCT)) {
-		ecif.rvalue = alloca(cif->rtype->size);
-	} else {
-		ecif.rvalue = rvalue;
-	}
-
-	switch (cif->abi)
-	{
-	case FFI_SYSV:
-		ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes, cif->flags,
-				ecif.rvalue, fn, cif->rtype->type, cif->rtype->size);
-		break;
-	default:
-		FFI_ASSERT(0);
-		break;
-	}
-}
-
-void ffi_closure_call_SYSV(void* register_args, void* stack_args,
-			ffi_closure* closure, void* rvalue,
-			unsigned int* rtype, unsigned int* rsize)
-{
-	/* prepare arguments for closure call */
-	ffi_cif* cif = closure->cif;
-	ffi_type** arg_types = cif->arg_types;
-
-	/* re-allocate data for the args. This needs to be done in order to keep
-	 * multi-word objects (e.g. structs) in contiguous memory. Callers are not
-	 * required to store the value of args in the lower 6 words in the stack
-	 * (although they are allocated in the stack).
-	 */
-	char* stackclone = alloca(cif->bytes);
-	void** avalue = alloca(cif->nargs * sizeof(void*));
-	void* struct_rvalue = NULL;
-	char* ptr = stackclone;
-	int i;
-
-	/* copy registers into stack clone */
-	int registers_used = cif->bytes;
-	if (registers_used > ARGS_REGISTER_SIZE) {
-		registers_used = ARGS_REGISTER_SIZE;
-	}
-	memcpy(stackclone, register_args, registers_used);
-
-	/* copy stack allocated args into stack clone */
-	if (cif->bytes > ARGS_REGISTER_SIZE) {
-		int stack_used = cif->bytes - ARGS_REGISTER_SIZE;
-		memcpy(stackclone + ARGS_REGISTER_SIZE, stack_args, stack_used);
-	}
-
-	/* preserve struct type return pointer passing */
-	if ((cif->rtype != NULL) && (cif->rtype->type == FFI_TYPE_STRUCT)) {
-		struct_rvalue = *((void**)ptr);
-		ptr += WORD_SIZE;
-	}
-
-	/* populate arg pointer list */
-	for (i = 0; i < cif->nargs; i++)
-	{
-		switch (arg_types[i]->type)
-		{
-			case FFI_TYPE_SINT8:
-			case FFI_TYPE_UINT8:
-#ifdef __BIG_ENDIAN__
-				avalue[i] = ptr + 3;
-#else
-				avalue[i] = ptr;
-#endif
-				break;
-			case FFI_TYPE_SINT16:
-			case FFI_TYPE_UINT16:
-#ifdef __BIG_ENDIAN__
-				avalue[i] = ptr + 2;
-#else
-				avalue[i] = ptr;
-#endif
-				break;
-			case FFI_TYPE_STRUCT:
-#if __BIG_ENDIAN__
-				/*
-				 * Work around strange ABI behaviour.
-				 * (see info in ffi_prep_args)
-				 */
-				if (arg_types[i]->size < WORD_SIZE)
-				{
-				  memcpy (ptr, ptr + (WORD_SIZE - arg_types[i]->size), arg_types[i]->size);
-				}
-#endif
-				avalue[i] = (void*)ptr;
-				break;
-			case FFI_TYPE_UINT64:
-			case FFI_TYPE_SINT64:
-			case FFI_TYPE_DOUBLE:
-				avalue[i] = ptr;
-				break;
-			case FFI_TYPE_SINT32:
-			case FFI_TYPE_UINT32:
-			case FFI_TYPE_FLOAT:
-			default:
-				/* default 4-byte argument */
-				avalue[i] = ptr;
-				break;
-		}
-		ptr += WORD_FFI_ALIGN(arg_types[i]->size);
-	}
-
-	/* set the return type info passed back to the wrapper */
-	*rsize = cif->rtype->size;
-	*rtype = cif->rtype->type;
-	if (struct_rvalue != NULL) {
-		closure->fun(cif, struct_rvalue, avalue, closure->user_data);
-		/* copy struct return pointer value into function return value */
-		*((void**)rvalue) = struct_rvalue;
-	} else {
-		closure->fun(cif, rvalue, avalue, closure->user_data);
-	}
-}
-
-ffi_status ffi_prep_closure_loc(
-		ffi_closure* closure, ffi_cif* cif,
-		void (*fun)(ffi_cif*, void*, void**, void*),
-		void* user_data, void* codeloc)
-{
-	unsigned long* tramp = (unsigned long*)&(closure->tramp[0]);
-	unsigned long cls = (unsigned long)codeloc;
-	unsigned long fn = 0;
-	unsigned long fn_closure_call_sysv = (unsigned long)ffi_closure_call_SYSV;
-
-	closure->cif = cif;
-	closure->fun = fun;
-	closure->user_data = user_data;
-
-	switch (cif->abi)
-	{
-	case FFI_SYSV:
-		fn = (unsigned long)ffi_closure_SYSV;
-
-		/* load r11 (temp) with fn */
-		/* imm fn(upper) */
-		tramp[0] = 0xb0000000 | ((fn >> 16) & 0xffff);
-		/* addik r11, r0, fn(lower) */
-		tramp[1] = 0x31600000 | (fn & 0xffff);
-
-		/* load r12 (temp) with cls */
-		/* imm cls(upper) */
-		tramp[2] = 0xb0000000 | ((cls >> 16) & 0xffff);
-		/* addik r12, r0, cls(lower) */
-		tramp[3] = 0x31800000 | (cls & 0xffff);
-
-		/* load r3 (temp) with ffi_closure_call_SYSV */
-		/* imm fn_closure_call_sysv(upper) */
-		tramp[4] = 0xb0000000 | ((fn_closure_call_sysv >> 16) & 0xffff);
-		/* addik r3, r0, fn_closure_call_sysv(lower) */
-		tramp[5] = 0x30600000 | (fn_closure_call_sysv & 0xffff);
-		/* branch/jump to address stored in r11 (fn) */
-		tramp[6] = 0x98085800; /* bra r11 */
-
-		break;
-	default:
-		return FFI_BAD_ABI;
-	}
-	return FFI_OK;
-}