ffi 1.9.21-x86-mingw32 → 1.9.22-x86-mingw32

data/ext/ffi_c/libffi/src/sparc/v9.S

@@ -1,440 +0,0 @@
-/* -----------------------------------------------------------------------
-   v9.S - Copyright (c) 2000, 2003, 2004, 2008 Red Hat, Inc.
-   
-   SPARC 64-bit 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>
-#include "internal.h"
-
-#ifdef SPARC64
-
-#define C2(X, Y)  X ## Y
-#define C1(X, Y)  C2(X, Y)
-
-#ifdef __USER_LABEL_PREFIX__
-# define C(Y)	C1(__USER_LABEL_PREFIX__, Y)
-#else
-# define C(Y)	Y
-#endif
-#define L(Y)	C1(.L, Y)
-
-#if defined(__sun__) && defined(__svr4__)
-# define E(INDEX)	.align 16
-#else
-# define E(INDEX)	.align 16; .org 2b + INDEX * 16
-#endif
-
-#define STACK_BIAS 2047
-
-	.text
-        .align 8
-	.globl	C(ffi_call_v9)
-	.type	C(ffi_call_v9),#function
-	FFI_HIDDEN(C(ffi_call_v9))
-
-C(ffi_call_v9):
-.LUW0:
-	save	%sp, %o4, %sp
-.LUW1:
-	mov	%i0, %o0			! copy cif
-	add	%sp, STACK_BIAS+128+48, %o1	! load args area
-	mov	%i2, %o2			! copy rvalue
-	call	C(ffi_prep_args_v9)
-	 mov	%i3, %o3			! copy avalue
-
-	andcc	%o0, SPARC_FLAG_FP_ARGS, %g0	! need fp regs?
-	add	%sp, 48, %sp			! deallocate prep frame
-	be,pt	%xcc, 1f
-	 mov	%o0, %l0			! save flags
-
-	ldd	[%sp+STACK_BIAS+128], %f0	! load all fp arg regs
-	ldd	[%sp+STACK_BIAS+128+8], %f2
-	ldd	[%sp+STACK_BIAS+128+16], %f4
-	ldd	[%sp+STACK_BIAS+128+24], %f6
-	ldd	[%sp+STACK_BIAS+128+32], %f8
-	ldd	[%sp+STACK_BIAS+128+40], %f10
-	ldd	[%sp+STACK_BIAS+128+48], %f12
-	ldd	[%sp+STACK_BIAS+128+56], %f14
-	ldd	[%sp+STACK_BIAS+128+64], %f16
-	ldd	[%sp+STACK_BIAS+128+72], %f18
-	ldd	[%sp+STACK_BIAS+128+80], %f20
-	ldd	[%sp+STACK_BIAS+128+88], %f22
-	ldd	[%sp+STACK_BIAS+128+96], %f24
-	ldd	[%sp+STACK_BIAS+128+104], %f26
-	ldd	[%sp+STACK_BIAS+128+112], %f28
-	ldd	[%sp+STACK_BIAS+128+120], %f30
-
-1:	ldx	[%sp+STACK_BIAS+128], %o0	! load all int arg regs
-	ldx	[%sp+STACK_BIAS+128+8], %o1
-	ldx	[%sp+STACK_BIAS+128+16], %o2
-	ldx	[%sp+STACK_BIAS+128+24], %o3
-	ldx	[%sp+STACK_BIAS+128+32], %o4
-	ldx	[%sp+STACK_BIAS+128+40], %o5
-	call	%i1
-	 mov	%i5, %g5			! load static chain
-
-0:	call	1f		! load pc in %o7
-	 and	%l0, SPARC_FLAG_RET_MASK, %l1
-1:	sll	%l1, 4, %l1
-	add	%o7, %l1, %o7	! o7 = 0b + ret_type*16
-	jmp	%o7+(2f-0b)
-	 nop
-
-	.align	16
-2:
-E(SPARC_RET_VOID)
-	return	%i7+8
-	 nop
-E(SPARC_RET_STRUCT)
-	add	%sp, STACK_BIAS-64+128+48, %l2
-	sub	%sp, 64, %sp
-	b	8f
-	 stx	%o0, [%l2]
-E(SPARC_RET_UINT8)
-	and	%o0, 0xff, %i0
-	return	%i7+8
-	  stx	%o0, [%o2]
-E(SPARC_RET_SINT8)
-	sll	%o0, 24, %o0
-	sra	%o0, 24, %i0
-	return	%i7+8
-	 stx	%o0, [%o2]
-E(SPARC_RET_UINT16)
-	sll	%o0, 16, %o0
-	srl	%o0, 16, %i0
-	return	%i7+8
-	 stx	%o0, [%o2]
-E(SPARC_RET_SINT16)
-	sll	%o0, 16, %o0
-	sra	%o0, 16, %i0
-	return	%i7+8
-	 stx	%o0, [%o2]
-E(SPARC_RET_UINT32)
-	srl	%o0, 0, %i0
-	return	%i7+8
-	 stx	%o0, [%o2]
-E(SP_V9_RET_SINT32)
-	sra	%o0, 0, %i0
-	return	%i7+8
-	 stx	%o0, [%o2]
-E(SPARC_RET_INT64)
-	stx	%o0, [%i2]
-	return	%i7+8
-	 nop
-E(SPARC_RET_INT128)
-	stx	%o0, [%i2]
-	stx	%o1, [%i2+8]
-	return	%i7+8
-	 nop
-E(SPARC_RET_F_8)
-	st	%f7, [%i2+7*4]
-	nop
-	st	%f6, [%i2+6*4]
-	nop
-E(SPARC_RET_F_6)
-	st	%f5, [%i2+5*4]
-	nop
-	st	%f4, [%i2+4*4]
-	nop
-E(SPARC_RET_F_4)
-	std	%f2, [%i2+2*4]
-	return	%i7+8
-	 std	%f0, [%o2]
-E(SPARC_RET_F_2)
-	return	%i7+8
-	 std	%f0, [%o2]
-E(SP_V9_RET_F_3)
-	st	%f2, [%i2+2*4]
-	nop
-	st	%f1, [%i2+1*4]
-	nop
-E(SPARC_RET_F_1)
-	return	%i7+8
-	 st	%f0, [%o2]
-
-	! Finish the SPARC_RET_STRUCT sequence.
-	.align	8
-8:	stx	%o1, [%l2+8]
-	stx	%o2, [%l2+16]
-	stx	%o3, [%l2+24]
-	std	%f0, [%l2+32]
-	std	%f2, [%l2+40]
-	std	%f4, [%l2+48]
-	std	%f6, [%l2+56]
-
-	! Copy the structure into place.
-	srl	%l0, SPARC_SIZEMASK_SHIFT, %o0	! load size_mask
-	mov	%i2, %o1			! load dst
-	mov	%l2, %o2			! load src_gp
-	call	C(ffi_struct_float_copy)
-	 add	%l2, 32, %o3			! load src_fp
-
-	return	%i7+8
-	 nop
-
-.LUW2:
-	.size	C(ffi_call_v9), . - C(ffi_call_v9)
-
-
-#undef STACKFRAME
-#define	STACKFRAME	 336	/* 16*8 register window +
-				   6*8 args backing store +
-				   20*8 locals */
-#define	FP		%fp+STACK_BIAS
-
-/* ffi_closure_v9(...)
-
-   Receives the closure argument in %g1.   */
-
-	.align 8
-	.globl	C(ffi_go_closure_v9)
-	.type	C(ffi_go_closure_v9),#function
-	FFI_HIDDEN(C(ffi_go_closure_v9))
-
-C(ffi_go_closure_v9):
-.LUW3:
-	save	%sp, -STACKFRAME, %sp
-.LUW4:
-	ldx	[%g5+8], %o0
-	ldx	[%g5+16], %o1
-	b	0f
-	 mov	%g5, %o2
-
-.LUW5:
-	.size	C(ffi_go_closure_v9), . - C(ffi_go_closure_v9)
-
-	.align 8
-	.globl	C(ffi_closure_v9)
-	.type	C(ffi_closure_v9),#function
-	FFI_HIDDEN(C(ffi_closure_v9))
-
-C(ffi_closure_v9):
-.LUW6:
-	save	%sp, -STACKFRAME, %sp
-.LUW7:
-	ldx	[%g1+FFI_TRAMPOLINE_SIZE], %o0
-	ldx	[%g1+FFI_TRAMPOLINE_SIZE+8], %o1
-	ldx	[%g1+FFI_TRAMPOLINE_SIZE+16], %o2
-0:
-	! Store all of the potential argument registers in va_list format.
-	stx	%i0, [FP+128+0]
-	stx	%i1, [FP+128+8]
-	stx	%i2, [FP+128+16]
-	stx	%i3, [FP+128+24]
-	stx	%i4, [FP+128+32]
-	stx	%i5, [FP+128+40]
-
-	! Store possible floating point argument registers too.
-	std	%f0,  [FP-128]
-	std	%f2,  [FP-120]
-	std	%f4,  [FP-112]
-	std	%f6,  [FP-104]
-	std	%f8,  [FP-96]
-	std	%f10, [FP-88]
-	std     %f12, [FP-80]
-	std     %f14, [FP-72]
-	std     %f16, [FP-64]
-	std     %f18, [FP-56]
-	std     %f20, [FP-48]
-	std     %f22, [FP-40]
-	std     %f24, [FP-32]
-	std     %f26, [FP-24]
-	std     %f28, [FP-16]
-	std     %f30, [FP-8]
-
-	! Call ffi_closure_sparc_inner to do the bulk of the work.
-	add	%fp, STACK_BIAS-160, %o3
-	add	%fp, STACK_BIAS+128, %o4
-	call	C(ffi_closure_sparc_inner_v9)
-	 add	%fp, STACK_BIAS-128, %o5
-
-0:	call	1f		! load pc in %o7
-	 and	%o0, SPARC_FLAG_RET_MASK, %o0
-1:	sll	%o0, 4, %o0	! o2 = i2 * 16
-	add	%o7, %o0, %o7	! o7 = 0b + i2*16
-	jmp	%o7+(2f-0b)
-	 nop
-
-	! Note that we cannot load the data in the delay slot of
-	! the return insn because the data is in the stack frame
-	! that is deallocated by the return.
-	.align	16
-2:
-E(SPARC_RET_VOID)
-	return	%i7+8
-	 nop
-E(SPARC_RET_STRUCT)
-	ldx	[FP-160], %i0
-	ldd	[FP-160], %f0
-	b	8f
-	 ldx	[FP-152], %i1
-E(SPARC_RET_UINT8)
-	ldub	[FP-160+7], %i0
-	return	%i7+8
-	 nop
-E(SPARC_RET_SINT8)
-	ldsb	[FP-160+7], %i0
-	return	%i7+8
-	 nop
-E(SPARC_RET_UINT16)
-	lduh	[FP-160+6], %i0
-	return	%i7+8
-	 nop
-E(SPARC_RET_SINT16)
-	ldsh	[FP-160+6], %i0
-	return	%i7+8
-	 nop
-E(SPARC_RET_UINT32)
-	lduw	[FP-160+4], %i0
-	return	%i7+8
-	 nop
-E(SP_V9_RET_SINT32)
-	ldsw	[FP-160+4], %i0
-	return	%i7+8
-	 nop
-E(SPARC_RET_INT64)
-	ldx	[FP-160], %i0
-	return	%i7+8
-	 nop
-E(SPARC_RET_INT128)
-	ldx	[FP-160], %i0
-	ldx	[FP-160+8], %i1
-	return	%i7+8
-	 nop
-E(SPARC_RET_F_8)
-	ld	[FP-160+7*4], %f7
-	nop
-	ld	[FP-160+6*4], %f6
-	nop
-E(SPARC_RET_F_6)
-	ld	[FP-160+5*4], %f5
-	nop
-	ld	[FP-160+4*4], %f4
-	nop
-E(SPARC_RET_F_4)
-	ldd	[FP-160], %f0
-	ldd	[FP-160+8], %f2
-	return	%i7+8
-	 nop
-E(SPARC_RET_F_2)
-	ldd	[FP-160], %f0
-	return	%i7+8
-	 nop
-E(SP_V9_RET_F_3)
-	ld	[FP-160+2*4], %f2
-	nop
-	ld	[FP-160+1*4], %f1
-	nop
-E(SPARC_RET_F_1)
-	ld	[FP-160], %f0
-	return	%i7+8
-	 nop
-
-	! Finish the SPARC_RET_STRUCT sequence.
-	.align	8
-8:	ldd	[FP-152], %f2
-	ldx	[FP-144], %i2
-	ldd	[FP-144], %f4
-	ldx	[FP-136], %i3
-	ldd	[FP-136], %f6
-	return	%i7+8
-	 nop
-
-.LUW8:
-	.size	C(ffi_closure_v9), . - C(ffi_closure_v9)
-
-#ifdef HAVE_RO_EH_FRAME
-        .section        ".eh_frame",#alloc
-#else
-        .section        ".eh_frame",#alloc,#write
-#endif
-
-#ifdef HAVE_AS_SPARC_UA_PCREL
-# define FDE_RANGE(B, E)  .long %r_disp32(B), E - B
-#else
-# define FDE_RANGE(B, E)  .align 8; .xword B, E - B
-#endif
-
-	.align 8
-.LCIE:
-	.long	.LECIE - .LSCIE		! CIE Length
-.LSCIE:
-	.long	0			! CIE Identifier Tag
-	.byte	1			! CIE Version
-	.ascii	"zR\0"			! CIE Augmentation
-	.byte	4			! CIE Code Alignment Factor
-	.byte	0x78			! CIE Data Alignment Factor
-	.byte	15			! CIE RA Column
-	.byte	1			! Augmentation size
-#ifdef HAVE_AS_SPARC_UA_PCREL
-	.byte	0x1b			! FDE Encoding (pcrel sdata4)
-#else
-	.byte	0x50			! FDE Encoding (aligned absolute)
-#endif
-	.byte	0xc, 14, 0xff, 0xf	! DW_CFA_def_cfa, %o6, offset 0x7ff
-	.align	8
-.LECIE:
-
-	.long	.LEFDE1 - .LSFDE1	! FDE Length
-.LSFDE1:
-	.long	.LSFDE1 - .LCIE		! FDE CIE offset
-	FDE_RANGE(.LUW0, .LUW2)
-	.byte	0			! Augmentation size
-	.byte	0x40+1			! DW_CFA_advance_loc 4
-	.byte	0xd, 30			! DW_CFA_def_cfa_register, %i6
-	.byte	0x2d			! DW_CFA_GNU_window_save
-	.byte	0x9, 15, 31		! DW_CFA_register, %o7, %i7
-	.align	8
-.LEFDE1:
-
-	.long	.LEFDE2 - .LSFDE2	! FDE Length
-.LSFDE2:
-	.long	.LSFDE2 - .LCIE		! FDE CIE offset
-	FDE_RANGE(.LUW3, .LUW5)
-	.byte	0			! Augmentation size
-	.byte	0x40+1			! DW_CFA_advance_loc 4
-	.byte	0xd, 30			! DW_CFA_def_cfa_register, %i6
-	.byte	0x2d			! DW_CFA_GNU_window_save
-	.byte	0x9, 15, 31		! DW_CFA_register, %o7, %i7
-	.align	8
-.LEFDE2:
-
-	.long	.LEFDE3 - .LSFDE3	! FDE Length
-.LSFDE3:
-	.long	.LSFDE3 - .LCIE		! FDE CIE offset
-	FDE_RANGE(.LUW6, .LUW8)
-	.byte	0			! Augmentation size
-	.byte	0x40+1			! DW_CFA_advance_loc 4
-	.byte	0xd, 30			! DW_CFA_def_cfa_register, %i6
-	.byte	0x2d			! DW_CFA_GNU_window_save
-	.byte	0x9, 15, 31		! DW_CFA_register, %o7, %i7
-	.align	8
-.LEFDE3:
-
-#endif /* SPARC64 */
-#ifdef __linux__
-	.section	.note.GNU-stack,"",@progbits
-#endif

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

@@ -1,355 +0,0 @@
-/* -----------------------------------------------------------------------
-   ffi.c - Copyright (c) 2012 Tilera Corp.
-
-   TILE 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>
-#include <stdlib.h>
-#include <stdint.h>
-#include <unistd.h>
-#include <arch/abi.h>
-#include <arch/icache.h>
-#include <arch/opcode.h>
-
-
-/* The first 10 registers are used to pass arguments and return values. */
-#define NUM_ARG_REGS 10
-
-/* Performs a raw function call with the given NUM_ARG_REGS register arguments
-   and the specified additional stack arguments (if any). */
-extern void ffi_call_tile(ffi_sarg reg_args[NUM_ARG_REGS],
-                          const ffi_sarg *stack_args,
-                          size_t stack_args_bytes,
-                          void (*fnaddr)(void))
-  FFI_HIDDEN;
-
-/* This handles the raw call from the closure stub, cleaning up the
-   parameters and delegating to ffi_closure_tile_inner. */
-extern void ffi_closure_tile(void) FFI_HIDDEN;
-
-
-ffi_status
-ffi_prep_cif_machdep(ffi_cif *cif)
-{
-  /* We always allocate room for all registers. Even if we don't
-     use them as parameters, they get returned in the same array
-     as struct return values so we need to make room. */
-  if (cif->bytes < NUM_ARG_REGS * FFI_SIZEOF_ARG)
-    cif->bytes = NUM_ARG_REGS * FFI_SIZEOF_ARG;
-
-  if (cif->rtype->size > NUM_ARG_REGS * FFI_SIZEOF_ARG)
-    cif->flags = FFI_TYPE_STRUCT;
-  else
-    cif->flags = FFI_TYPE_INT;
-
-  /* Nothing to do. */
-  return FFI_OK;
-}
-
-
-static long
-assign_to_ffi_arg(ffi_sarg *out, void *in, const ffi_type *type,
-                  int write_to_reg)
-{
-  switch (type->type)
-    {
-    case FFI_TYPE_SINT8:
-      *out = *(SINT8 *)in;
-      return 1;
-
-    case FFI_TYPE_UINT8:
-      *out = *(UINT8 *)in;
-      return 1;
-
-    case FFI_TYPE_SINT16:
-      *out = *(SINT16 *)in;
-      return 1;
-
-    case FFI_TYPE_UINT16:
-      *out = *(UINT16 *)in;
-      return 1;
-
-    case FFI_TYPE_SINT32:
-    case FFI_TYPE_UINT32:
-#ifndef __LP64__
-    case FFI_TYPE_POINTER:
-#endif
-      /* Note that even unsigned 32-bit quantities are sign extended
-         on tilegx when stored in a register.  */
-      *out = *(SINT32 *)in;
-      return 1;
-
-    case FFI_TYPE_FLOAT:
-#ifdef __tilegx__
-      if (write_to_reg)
-        {
-          /* Properly sign extend the value.  */
-          union { float f; SINT32 s32; } val;
-          val.f = *(float *)in;
-          *out = val.s32;
-        }
-      else
-#endif
-        {
-          *(float *)out = *(float *)in;
-        }
-      return 1;
-
-    case FFI_TYPE_SINT64:
-    case FFI_TYPE_UINT64:
-    case FFI_TYPE_DOUBLE:
-#ifdef __LP64__
-    case FFI_TYPE_POINTER:
-#endif
-      *(UINT64 *)out = *(UINT64 *)in;
-      return sizeof(UINT64) / FFI_SIZEOF_ARG;
-
-    case FFI_TYPE_STRUCT:
-      memcpy(out, in, type->size);
-      return (type->size + FFI_SIZEOF_ARG - 1) / FFI_SIZEOF_ARG;
-
-    case FFI_TYPE_VOID:
-      /* Must be a return type. Nothing to do. */
-      return 0;
-
-    default:
-      FFI_ASSERT(0);
-      return -1;
-    }
-}
-
-
-void
-ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
-{
-  ffi_sarg * const arg_mem = alloca(cif->bytes);
-  ffi_sarg * const reg_args = arg_mem;
-  ffi_sarg * const stack_args = &reg_args[NUM_ARG_REGS];
-  ffi_sarg *argp = arg_mem;
-  ffi_type ** const arg_types = cif->arg_types;
-  const long num_args = cif->nargs;
-  long i;
-
-  if (cif->flags == FFI_TYPE_STRUCT)
-    {
-      /* Pass a hidden pointer to the return value. We make sure there
-         is scratch space for the callee to store the return value even if
-         our caller doesn't care about it. */
-      *argp++ = (intptr_t)(rvalue ? rvalue : alloca(cif->rtype->size));
-
-      /* No more work needed to return anything. */
-      rvalue = NULL;
-    }
-
-  for (i = 0; i < num_args; i++)
-    {
-      ffi_type *type = arg_types[i];
-      void * const arg_in = avalue[i];
-      ptrdiff_t arg_word = argp - arg_mem;
-
-#ifndef __tilegx__
-      /* Doubleword-aligned values are always in an even-number register
-         pair, or doubleword-aligned stack slot if out of registers. */
-      long align = arg_word & (type->alignment > FFI_SIZEOF_ARG);
-      argp += align;
-      arg_word += align;
-#endif
-
-      if (type->type == FFI_TYPE_STRUCT)
-        {
-          const size_t arg_size_in_words =
-            (type->size + FFI_SIZEOF_ARG - 1) / FFI_SIZEOF_ARG;
-
-          if (arg_word < NUM_ARG_REGS &&
-              arg_word + arg_size_in_words > NUM_ARG_REGS)
-            {
-              /* Args are not allowed to span registers and the stack. */
-              argp = stack_args;
-            }
-
-          memcpy(argp, arg_in, type->size);
-          argp += arg_size_in_words;
-        }
-      else
-        {
-          argp += assign_to_ffi_arg(argp, arg_in, arg_types[i], 1);
-        }
-    }
-
-  /* Actually do the call. */
-  ffi_call_tile(reg_args, stack_args,
-                cif->bytes - (NUM_ARG_REGS * FFI_SIZEOF_ARG), fn);
-
-  if (rvalue != NULL)
-    assign_to_ffi_arg(rvalue, reg_args, cif->rtype, 0);
-}
-
-
-/* Template code for closure. */
-extern const UINT64 ffi_template_tramp_tile[] FFI_HIDDEN;
-
-
-ffi_status
-ffi_prep_closure_loc (ffi_closure *closure,
-                      ffi_cif *cif,
-                      void (*fun)(ffi_cif*, void*, void**, void*),
-                      void *user_data,
-                      void *codeloc)
-{
-#ifdef __tilegx__
-  /* TILE-Gx */
-  SINT64 c;
-  SINT64 h;
-  int s;
-  UINT64 *out;
-
-  if (cif->abi != FFI_UNIX)
-    return FFI_BAD_ABI;
-
-  out = (UINT64 *)closure->tramp;
-
-  c = (intptr_t)closure;
-  h = (intptr_t)ffi_closure_tile;
-  s = 0;
-
-  /* Find the smallest shift count that doesn't lose information
-     (i.e. no need to explicitly insert high bits of the address that
-     are just the sign extension of the low bits). */
-  while ((c >> s) != (SINT16)(c >> s) || (h >> s) != (SINT16)(h >> s))
-    s += 16;
-
-#define OPS(a, b, shift) \
-  (create_Imm16_X0((a) >> (shift)) | create_Imm16_X1((b) >> (shift)))
-
-  /* Emit the moveli. */
-  *out++ = ffi_template_tramp_tile[0] | OPS(c, h, s);
-  for (s -= 16; s >= 0; s -= 16)
-    *out++ = ffi_template_tramp_tile[1] | OPS(c, h, s);
-
-#undef OPS
-
-  *out++ = ffi_template_tramp_tile[2];
-
-#else
-  /* TILEPro */
-  UINT64 *out;
-  intptr_t delta;
-
-  if (cif->abi != FFI_UNIX)
-    return FFI_BAD_ABI;
-
-  out = (UINT64 *)closure->tramp;
-  delta = (intptr_t)ffi_closure_tile - (intptr_t)codeloc;
-
-  *out++ = ffi_template_tramp_tile[0] | create_JOffLong_X1(delta >> 3);
-#endif
-
-  closure->cif = cif;
-  closure->fun = fun;
-  closure->user_data = user_data;
-
-  invalidate_icache(closure->tramp, (char *)out - closure->tramp,
-                    getpagesize());
-
-  return FFI_OK;
-}
-
-
-/* This is called by the assembly wrapper for closures. This does
-   all of the work. On entry reg_args[0] holds the values the registers
-   had when the closure was invoked. On return reg_args[1] holds the register
-   values to be returned to the caller (many of which may be garbage). */
-void FFI_HIDDEN
-ffi_closure_tile_inner(ffi_closure *closure,
-                       ffi_sarg reg_args[2][NUM_ARG_REGS],
-                       ffi_sarg *stack_args)
-{
-  ffi_cif * const cif = closure->cif;
-  void ** const avalue = alloca(cif->nargs * sizeof(void *));
-  void *rvalue;
-  ffi_type ** const arg_types = cif->arg_types;
-  ffi_sarg * const reg_args_in = reg_args[0];
-  ffi_sarg * const reg_args_out = reg_args[1];
-  ffi_sarg * argp;
-  long i, arg_word, nargs = cif->nargs;
-  /* Use a union to guarantee proper alignment for double. */
-  union { ffi_sarg arg[NUM_ARG_REGS]; double d; UINT64 u64; } closure_ret;
-
-  /* Start out reading register arguments. */
-  argp = reg_args_in;
-
-  /* Copy the caller's structure return address to that the closure
-     returns the data directly to the caller.  */
-  if (cif->flags == FFI_TYPE_STRUCT)
-    {
-      /* Return by reference via hidden pointer. */
-      rvalue = (void *)(intptr_t)*argp++;
-      arg_word = 1;
-    }
-  else
-    {
-      /* Return the value in registers. */
-      rvalue = &closure_ret;
-      arg_word = 0;
-    }
-
-  /* Grab the addresses of the arguments. */
-  for (i = 0; i < nargs; i++)
-    {
-      ffi_type * const type = arg_types[i];
-      const size_t arg_size_in_words =
-        (type->size + FFI_SIZEOF_ARG - 1) / FFI_SIZEOF_ARG;
-
-#ifndef __tilegx__
-      /* Doubleword-aligned values are always in an even-number register
-         pair, or doubleword-aligned stack slot if out of registers. */
-      long align = arg_word & (type->alignment > FFI_SIZEOF_ARG);
-      argp += align;
-      arg_word += align;
-#endif
-
-      if (arg_word == NUM_ARG_REGS ||
-          (arg_word < NUM_ARG_REGS &&
-           arg_word + arg_size_in_words > NUM_ARG_REGS))
-        {
-          /* Switch to reading arguments from the stack. */
-          argp = stack_args;
-          arg_word = NUM_ARG_REGS;
-        }
-
-      avalue[i] = argp;
-      argp += arg_size_in_words;
-      arg_word += arg_size_in_words;
-    }
-
-  /* Invoke the closure.  */
-  closure->fun(cif, rvalue, avalue, closure->user_data);
-
-  if (cif->flags != FFI_TYPE_STRUCT)
-    {
-      /* Canonicalize for register representation. */
-      assign_to_ffi_arg(reg_args_out, &closure_ret, cif->rtype, 1);
-    }
-}