gameboard 3.1.0 → 3.2.0

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.14/ext/ffi_c/libffi/src/m68k/ffitarget.h

@@ -1,49 +0,0 @@
-/* -----------------------------------------------------------------*-C-*-
-   ffitarget.h - Copyright (c) 1996-2003  Red Hat, Inc.
-   Target configuration macros for Motorola 68K.
-
-   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_ASM
-typedef unsigned long          ffi_arg;
-typedef signed long            ffi_sarg;
-
-typedef enum ffi_abi {
-  FFI_FIRST_ABI = 0,
-  FFI_SYSV,
-  FFI_LAST_ABI,
-  FFI_DEFAULT_ABI = FFI_SYSV
-} ffi_abi;
-#endif
-
-/* ---- Definitions for closures ----------------------------------------- */
-
-#define FFI_CLOSURES 1
-#define FFI_TRAMPOLINE_SIZE 16
-#define FFI_NATIVE_RAW_API 0
-
-#endif
-

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.14/ext/ffi_c/libffi/src/m68k/sysv.S

@@ -1,270 +0,0 @@
-/* -----------------------------------------------------------------------
-	
-   sysv.S - Copyright (c) 1998 Andreas Schwab
-	    Copyright (c) 2008 Red Hat, Inc. 
-   
-   m68k 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_AS_CFI_PSEUDO_OP
-#define CFI_STARTPROC()		.cfi_startproc
-#define CFI_OFFSET(reg,off)	.cfi_offset	reg,off
-#define CFI_DEF_CFA(reg,off)	.cfi_def_cfa	reg,off
-#define CFI_ENDPROC()		.cfi_endproc
-#else
-#define CFI_STARTPROC()
-#define CFI_OFFSET(reg,off)
-#define CFI_DEF_CFA(reg,off)
-#define CFI_ENDPROC()
-#endif
-
-	.text
-
-	.globl	ffi_call_SYSV
-	.type	ffi_call_SYSV,@function
-	.align	4
-
-ffi_call_SYSV:
-	CFI_STARTPROC()
-	link	%fp,#0
-	CFI_OFFSET(14,-8)
-	CFI_DEF_CFA(14,8)
-	move.l	%d2,-(%sp)
-	CFI_OFFSET(2,-12)
-
-	| Make room for all of the new args.
-	sub.l	12(%fp),%sp
-
-	| Call ffi_prep_args
-	move.l	8(%fp),-(%sp)
-	pea	4(%sp)
-#if !defined __PIC__
-	jsr	ffi_prep_args
-#else
-	bsr.l	ffi_prep_args@PLTPC
-#endif
-	addq.l	#8,%sp	
-
-	| Pass pointer to struct value, if any
-	move.l	%a0,%a1
-
-	| Call the function
-	move.l	24(%fp),%a0
-	jsr	(%a0)
-
-	| Remove the space we pushed for the args
-	add.l	12(%fp),%sp
-
-	| Load the pointer to storage for the return value
-	move.l	20(%fp),%a1
-
-	| Load the return type code 
-	move.l	16(%fp),%d2
-
-	| If the return value pointer is NULL, assume no return value.
-	| NOTE: On the mc68000, tst on an address register is not supported.
-#if defined(__mc68000__) && !defined(__mcoldfire__)
-	cmp.w	#0, %a1
-#else
-	tst.l	%a1
-#endif
-	jbeq	noretval
-
-	btst	#0,%d2
-	jbeq	retlongint
-	move.l	%d0,(%a1)
-	jbra	epilogue
-
-retlongint:
-	btst	#1,%d2
-	jbeq	retfloat
-	move.l	%d0,(%a1)
-	move.l	%d1,4(%a1)
-	jbra	epilogue
-
-retfloat:
-	btst	#2,%d2
-	jbeq	retdouble
-#if defined(__MC68881__)
-	fmove.s	%fp0,(%a1)
-#else
-	move.l	%d0,(%a1)
-#endif
-	jbra	epilogue
-
-retdouble:
-	btst	#3,%d2
-	jbeq	retlongdouble
-#if defined(__MC68881__)
-	fmove.d	%fp0,(%a1)
-#else
-	move.l	%d0,(%a1)+
-	move.l	%d1,(%a1)
-#endif
-	jbra	epilogue
-
-retlongdouble:
-	btst	#4,%d2
-	jbeq	retpointer
-#if defined(__MC68881__)
-	fmove.x	%fp0,(%a1)
-#else
-	move.l	%d0,(%a1)+
-	move.l	%d1,(%a1)+
-	move.l	%d2,(%a1)
-#endif
-	jbra	epilogue
-
-retpointer:
-	btst	#5,%d2
-	jbeq	retstruct1
-	move.l	%a0,(%a1)
-	jbra	epilogue
-
-retstruct1:
-	btst	#6,%d2
-	jbeq	retstruct2
-	move.b	%d0,(%a1)
-	jbra	epilogue
-
-retstruct2:
-	btst	#7,%d2
-	jbeq	noretval
-	move.w	%d0,(%a1)
-
-noretval:
-epilogue:
-	move.l	(%sp)+,%d2
-	unlk	%fp
-	rts
-	CFI_ENDPROC()
-	.size	ffi_call_SYSV,.-ffi_call_SYSV
-
-	.globl	ffi_closure_SYSV
-	.type	ffi_closure_SYSV, @function
-	.align	4
-
-ffi_closure_SYSV:
-	CFI_STARTPROC()
-	link	%fp,#-12
-	CFI_OFFSET(14,-8)
-	CFI_DEF_CFA(14,8)
-	move.l	%sp,-12(%fp)
-	pea	8(%fp)
-	pea	-12(%fp)
-	move.l	%a0,-(%sp)
-#if !defined __PIC__
-	jsr	ffi_closure_SYSV_inner
-#else
-	bsr.l	ffi_closure_SYSV_inner@PLTPC
-#endif
-
-	lsr.l	#1,%d0
-	jne	1f
-	jcc	.Lcls_epilogue
-	move.l	-12(%fp),%d0
-.Lcls_epilogue:
-	unlk	%fp
-	rts
-1:
-	lea	-12(%fp),%a0
-	lsr.l	#2,%d0
-	jne	1f
-	jcs	.Lcls_ret_float
-	move.l	(%a0)+,%d0
-	move.l	(%a0),%d1
-	jra	.Lcls_epilogue
-.Lcls_ret_float:
-#if defined(__MC68881__)
-	fmove.s	(%a0),%fp0
-#else
-	move.l	(%a0),%d0
-#endif
-	jra	.Lcls_epilogue
-1:
-	lsr.l	#2,%d0
-	jne	1f
-	jcs	.Lcls_ret_ldouble
-#if defined(__MC68881__)
-	fmove.d	(%a0),%fp0
-#else
-	move.l	(%a0)+,%d0
-	move.l	(%a0),%d1
-#endif
-	jra	.Lcls_epilogue
-.Lcls_ret_ldouble:
-#if defined(__MC68881__)
-	fmove.x	(%a0),%fp0
-#else
-	move.l	(%a0)+,%d0
-	move.l	(%a0)+,%d1
-	move.l	(%a0),%d2
-#endif
-	jra	.Lcls_epilogue
-1:
-	lsr.l	#2,%d0
-	jne	.Lcls_ret_struct2
-	jcs	.Lcls_ret_struct1
-	move.l	(%a0),%a0
-	move.l	%a0,%d0
-	jra	.Lcls_epilogue
-.Lcls_ret_struct1:
-	move.b	(%a0),%d0
-	jra	.Lcls_epilogue
-.Lcls_ret_struct2:
-	move.w	(%a0),%d0
-	jra	.Lcls_epilogue
-	CFI_ENDPROC()
-
-	.size	ffi_closure_SYSV,.-ffi_closure_SYSV
-
-	.globl	ffi_closure_struct_SYSV
-	.type	ffi_closure_struct_SYSV, @function
-	.align	4
-
-ffi_closure_struct_SYSV:
-	CFI_STARTPROC()
-	link	%fp,#0
-	CFI_OFFSET(14,-8)
-	CFI_DEF_CFA(14,8)
-	move.l	%sp,-12(%fp)
-	pea	8(%fp)
-	move.l	%a1,-(%sp)
-	move.l	%a0,-(%sp)
-#if !defined __PIC__
-	jsr	ffi_closure_SYSV_inner
-#else
-	bsr.l	ffi_closure_SYSV_inner@PLTPC
-#endif
-	unlk	%fp
-	rts
-	CFI_ENDPROC()
-	.size	ffi_closure_struct_SYSV,.-ffi_closure_struct_SYSV
-
-#if defined __ELF__ && defined __linux__
-	.section	.note.GNU-stack,"",@progbits
-#endif

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.14/ext/ffi_c/libffi/src/mips/ffi.c

@@ -1,1038 +0,0 @@
-/* -----------------------------------------------------------------------
-   ffi.c - Copyright (c) 2011  Anthony Green
-           Copyright (c) 2008  David Daney
-           Copyright (c) 1996, 2007, 2008, 2011  Red Hat, Inc.
-   
-   MIPS 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>
-
-#ifdef __GNUC__
-#  if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3))
-#    define USE__BUILTIN___CLEAR_CACHE 1
-#  endif
-#endif
-
-#ifndef USE__BUILTIN___CLEAR_CACHE
-#  if defined(__OpenBSD__)
-#    include <mips64/sysarch.h>
-#  else
-#    include <sys/cachectl.h>
-#  endif
-#endif
-
-#ifdef FFI_DEBUG
-# define FFI_MIPS_STOP_HERE() ffi_stop_here()
-#else
-# define FFI_MIPS_STOP_HERE() do {} while(0)
-#endif
-
-#ifdef FFI_MIPS_N32
-#define FIX_ARGP \
-FFI_ASSERT(argp <= &stack[bytes]); \
-if (argp == &stack[bytes]) \
-{ \
-  argp = stack; \
-  FFI_MIPS_STOP_HERE(); \
-}
-#else
-#define FIX_ARGP 
-#endif
-
-
-/* ffi_prep_args is called by the assembly routine once stack space
-   has been allocated for the function's arguments */
-
-static void ffi_prep_args(char *stack, 
-			  extended_cif *ecif,
-			  int bytes,
-			  int flags)
-{
-  int i;
-  void **p_argv;
-  char *argp;
-  ffi_type **p_arg;
-  int ecif_test;
-
-#ifdef FFI_MIPS_N32
-  /* If more than 8 double words are used, the remainder go
-     on the stack. We reorder stuff on the stack here to 
-     support this easily. */
-  if (bytes > 8 * sizeof(ffi_arg))
-    argp = &stack[bytes - (8 * sizeof(ffi_arg))];
-  else
-    argp = stack;
-#else
-  argp = stack;
-#endif
-
-  memset(stack, 0, bytes);
-
-#ifdef FFI_MIPS_N32
-  ecif_test = ecif->cif->rstruct_flag != 0;
-#else
-  ecif_test = ecif->cif->rtype->type == FFI_TYPE_STRUCT;
-#endif  
-    if (ecif_test)
-    {
-      *(ffi_arg *) argp = (ffi_arg) ecif->rvalue;
-      argp += sizeof(ffi_arg);
-      FIX_ARGP;
-    }
-
-  p_argv = ecif->avalue;
-
-  for (i = 0, p_arg = ecif->cif->arg_types; i < ecif->cif->nargs; i++, p_arg++)
-    {
-      size_t z;
-      unsigned int a;
-
-      /* Align if necessary.  */
-      a = (*p_arg)->alignment;
-      if (a < sizeof(ffi_arg))
-        a = sizeof(ffi_arg);
-      
-      if ((a - 1) & (unsigned long) argp)
-	{
-	  argp = (char *) ALIGN(argp, a);
-	  FIX_ARGP;
-	}
-
-      z = (*p_arg)->size;
-      if (z <= sizeof(ffi_arg))
-	{
-          int type = (*p_arg)->type;
-	  z = sizeof(ffi_arg);
-
-          /* The size of a pointer depends on the ABI */
-          if (type == FFI_TYPE_POINTER)
-            type = (ecif->cif->abi == FFI_N64
-		    || ecif->cif->abi == FFI_N64_SOFT_FLOAT)
-	      ? FFI_TYPE_SINT64 : FFI_TYPE_SINT32;
-
-	if (i < 8 && (ecif->cif->abi == FFI_N32_SOFT_FLOAT
-		      || ecif->cif->abi == FFI_N64_SOFT_FLOAT))
-	  {
-	    switch (type)
-	      {
-	      case FFI_TYPE_FLOAT:
-		type = FFI_TYPE_UINT32;
-		break;
-	      case FFI_TYPE_DOUBLE:
-		type = FFI_TYPE_UINT64;
-		break;
-	      default:
-		break;
-	      }
-	  }
-	  switch (type)
-	    {
-	      case FFI_TYPE_SINT8:
-		*(ffi_arg *)argp = *(SINT8 *)(* p_argv);
-		break;
-
-	      case FFI_TYPE_UINT8:
-		*(ffi_arg *)argp = *(UINT8 *)(* p_argv);
-		break;
-		  
-	      case FFI_TYPE_SINT16:
-		*(ffi_arg *)argp = *(SINT16 *)(* p_argv);
-		break;
-		  
-	      case FFI_TYPE_UINT16:
-		*(ffi_arg *)argp = *(UINT16 *)(* p_argv);
-		break;
-		  
-	      case FFI_TYPE_SINT32:
-		*(ffi_arg *)argp = *(SINT32 *)(* p_argv);
-		break;
-		  
-	      case FFI_TYPE_UINT32:
-		*(ffi_arg *)argp = *(UINT32 *)(* p_argv);
-		break;
-
-	      /* This can only happen with 64bit slots.  */
-	      case FFI_TYPE_FLOAT:
-		*(float *) argp = *(float *)(* p_argv);
-		break;
-
-	      /* Handle structures.  */
-	      default:
-		memcpy(argp, *p_argv, (*p_arg)->size);
-		break;
-	    }
-	}
-      else
-	{
-#ifdef FFI_MIPS_O32
-	  memcpy(argp, *p_argv, z);
-#else
-	  {
-	    unsigned long end = (unsigned long) argp + z;
-	    unsigned long cap = (unsigned long) stack + bytes;
-
-	    /* Check if the data will fit within the register space.
-	       Handle it if it doesn't.  */
-
-	    if (end <= cap)
-	      memcpy(argp, *p_argv, z);
-	    else
-	      {
-		unsigned long portion = cap - (unsigned long)argp;
-
-		memcpy(argp, *p_argv, portion);
-		argp = stack;
-                z -= portion;
-		memcpy(argp, (void*)((unsigned long)(*p_argv) + portion),
-                       z);
-	      }
-	  }
-#endif
-      }
-      p_argv++;
-      argp += z;
-      FIX_ARGP;
-    }
-}
-
-#ifdef FFI_MIPS_N32
-
-/* The n32 spec says that if "a chunk consists solely of a double 
-   float field (but not a double, which is part of a union), it
-   is passed in a floating point register. Any other chunk is
-   passed in an integer register". This code traverses structure
-   definitions and generates the appropriate flags. */
-
-static unsigned
-calc_n32_struct_flags(int soft_float, ffi_type *arg,
-		      unsigned *loc, unsigned *arg_reg)
-{
-  unsigned flags = 0;
-  unsigned index = 0;
-
-  ffi_type *e;
-
-  if (soft_float)
-    return 0;
-
-  while ((e = arg->elements[index]))
-    {
-      /* Align this object.  */
-      *loc = ALIGN(*loc, e->alignment);
-      if (e->type == FFI_TYPE_DOUBLE)
-	{
-          /* Already aligned to FFI_SIZEOF_ARG.  */
-          *arg_reg = *loc / FFI_SIZEOF_ARG;
-          if (*arg_reg > 7)
-            break;
-	  flags += (FFI_TYPE_DOUBLE << (*arg_reg * FFI_FLAG_BITS));
-          *loc += e->size;
-	}
-      else
-        *loc += e->size;
-      index++;
-    }
-  /* Next Argument register at alignment of FFI_SIZEOF_ARG.  */
-  *arg_reg = ALIGN(*loc, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
-
-  return flags;
-}
-
-static unsigned
-calc_n32_return_struct_flags(int soft_float, ffi_type *arg)
-{
-  unsigned flags = 0;
-  unsigned small = FFI_TYPE_SMALLSTRUCT;
-  ffi_type *e;
-
-  /* Returning structures under n32 is a tricky thing.
-     A struct with only one or two floating point fields 
-     is returned in $f0 (and $f2 if necessary). Any other
-     struct results at most 128 bits are returned in $2
-     (the first 64 bits) and $3 (remainder, if necessary).
-     Larger structs are handled normally. */
-  
-  if (arg->size > 16)
-    return 0;
-
-  if (arg->size > 8)
-    small = FFI_TYPE_SMALLSTRUCT2;
-
-  e = arg->elements[0];
-
-  if (e->type == FFI_TYPE_DOUBLE)
-    flags = FFI_TYPE_DOUBLE;
-  else if (e->type == FFI_TYPE_FLOAT)
-    flags = FFI_TYPE_FLOAT;
-
-  if (flags && (e = arg->elements[1]))
-    {
-      if (e->type == FFI_TYPE_DOUBLE)
-	flags += FFI_TYPE_DOUBLE << FFI_FLAG_BITS;
-      else if (e->type == FFI_TYPE_FLOAT)
-	flags += FFI_TYPE_FLOAT << FFI_FLAG_BITS;
-      else 
-	return small;
-
-      if (flags && (arg->elements[2]))
-	{
-	  /* There are three arguments and the first two are 
-	     floats! This must be passed the old way. */
-	  return small;
-	}
-      if (soft_float)
-	flags += FFI_TYPE_STRUCT_SOFT;
-    }
-  else
-    if (!flags)
-      return small;
-
-  return flags;
-}
-
-#endif
-
-/* Perform machine dependent cif processing */
-ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
-{
-  cif->flags = 0;
-
-#ifdef FFI_MIPS_O32
-  /* Set the flags necessary for O32 processing.  FFI_O32_SOFT_FLOAT
-   * does not have special handling for floating point args.
-   */
-
-  if (cif->rtype->type != FFI_TYPE_STRUCT && cif->abi == FFI_O32)
-    {
-      if (cif->nargs > 0)
-	{
-	  switch ((cif->arg_types)[0]->type)
-	    {
-	    case FFI_TYPE_FLOAT:
-	    case FFI_TYPE_DOUBLE:
-	      cif->flags += (cif->arg_types)[0]->type;
-	      break;
-	      
-	    default:
-	      break;
-	    }
-
-	  if (cif->nargs > 1)
-	    {
-	      /* Only handle the second argument if the first
-		 is a float or double. */
-	      if (cif->flags)
-		{
-		  switch ((cif->arg_types)[1]->type)
-		    {
-		    case FFI_TYPE_FLOAT:
-		    case FFI_TYPE_DOUBLE:
-		      cif->flags += (cif->arg_types)[1]->type << FFI_FLAG_BITS;
-		      break;
-		      
-		    default:
-		      break;
-		    }
-		}
-	    }
-	}
-    }
-      
-  /* Set the return type flag */
-
-  if (cif->abi == FFI_O32_SOFT_FLOAT)
-    {
-      switch (cif->rtype->type)
-        {
-        case FFI_TYPE_VOID:
-        case FFI_TYPE_STRUCT:
-          cif->flags += cif->rtype->type << (FFI_FLAG_BITS * 2);
-          break;
-
-        case FFI_TYPE_SINT64:
-        case FFI_TYPE_UINT64:
-        case FFI_TYPE_DOUBLE:
-          cif->flags += FFI_TYPE_UINT64 << (FFI_FLAG_BITS * 2);
-          break;
-      
-        case FFI_TYPE_FLOAT:
-        default:
-          cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 2);
-          break;
-        }
-    }
-  else
-    {
-      /* FFI_O32 */      
-      switch (cif->rtype->type)
-        {
-        case FFI_TYPE_VOID:
-        case FFI_TYPE_STRUCT:
-        case FFI_TYPE_FLOAT:
-        case FFI_TYPE_DOUBLE:
-          cif->flags += cif->rtype->type << (FFI_FLAG_BITS * 2);
-          break;
-
-        case FFI_TYPE_SINT64:
-        case FFI_TYPE_UINT64:
-          cif->flags += FFI_TYPE_UINT64 << (FFI_FLAG_BITS * 2);
-          break;
-      
-        default:
-          cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 2);
-          break;
-        }
-    }
-#endif
-
-#ifdef FFI_MIPS_N32
-  /* Set the flags necessary for N32 processing */
-  {
-    int type;
-    unsigned arg_reg = 0;
-    unsigned loc = 0;
-    unsigned count = (cif->nargs < 8) ? cif->nargs : 8;
-    unsigned index = 0;
-
-    unsigned struct_flags = 0;
-    int soft_float = (cif->abi == FFI_N32_SOFT_FLOAT
-		      || cif->abi == FFI_N64_SOFT_FLOAT);
-
-    if (cif->rtype->type == FFI_TYPE_STRUCT)
-      {
-	struct_flags = calc_n32_return_struct_flags(soft_float, cif->rtype);
-
-	if (struct_flags == 0)
-	  {
-	    /* This means that the structure is being passed as
-	       a hidden argument */
-
-	    arg_reg = 1;
-	    count = (cif->nargs < 7) ? cif->nargs : 7;
-
-	    cif->rstruct_flag = !0;
-	  }
-	else
-	    cif->rstruct_flag = 0;
-      }
-    else
-      cif->rstruct_flag = 0;
-
-    while (count-- > 0 && arg_reg < 8)
-      {
-	type = (cif->arg_types)[index]->type;
-	if (soft_float)
-	  {
-	    switch (type)
-	      {
-	      case FFI_TYPE_FLOAT:
-		type = FFI_TYPE_UINT32;
-		break;
-	      case FFI_TYPE_DOUBLE:
-		type = FFI_TYPE_UINT64;
-		break;
-	      default:
-		break;
-	      }
-	  }
-	switch (type)
-	  {
-	  case FFI_TYPE_FLOAT:
-	  case FFI_TYPE_DOUBLE:
-	    cif->flags +=
-              ((cif->arg_types)[index]->type << (arg_reg * FFI_FLAG_BITS));
-	    arg_reg++;
-	    break;
-          case FFI_TYPE_LONGDOUBLE:
-            /* Align it.  */
-            arg_reg = ALIGN(arg_reg, 2);
-            /* Treat it as two adjacent doubles.  */
-	    if (soft_float) 
-	      {
-		arg_reg += 2;
-	      }
-	    else
-	      {
-		cif->flags +=
-		  (FFI_TYPE_DOUBLE << (arg_reg * FFI_FLAG_BITS));
-		arg_reg++;
-		cif->flags +=
-		  (FFI_TYPE_DOUBLE << (arg_reg * FFI_FLAG_BITS));
-		arg_reg++;
-	      }
-            break;
-
-	  case FFI_TYPE_STRUCT:
-            loc = arg_reg * FFI_SIZEOF_ARG;
-	    cif->flags += calc_n32_struct_flags(soft_float,
-						(cif->arg_types)[index],
-						&loc, &arg_reg);
-	    break;
-
-	  default:
-	    arg_reg++;
-            break;
-	  }
-
-	index++;
-      }
-
-  /* Set the return type flag */
-    switch (cif->rtype->type)
-      {
-      case FFI_TYPE_STRUCT:
-	{
-	  if (struct_flags == 0)
-	    {
-	      /* The structure is returned through a hidden
-		 first argument. Do nothing, 'cause FFI_TYPE_VOID 
-		 is 0 */
-	    }
-	  else
-	    {
-	      /* The structure is returned via some tricky
-		 mechanism */
-	      cif->flags += FFI_TYPE_STRUCT << (FFI_FLAG_BITS * 8);
-	      cif->flags += struct_flags << (4 + (FFI_FLAG_BITS * 8));
-	    }
-	  break;
-	}
-      
-      case FFI_TYPE_VOID:
-	/* Do nothing, 'cause FFI_TYPE_VOID is 0 */
-	break;
-
-      case FFI_TYPE_POINTER:
-	if (cif->abi == FFI_N32_SOFT_FLOAT || cif->abi == FFI_N32)
-	  cif->flags += FFI_TYPE_SINT32 << (FFI_FLAG_BITS * 8);
-	else
-	  cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
-	break;
-
-      case FFI_TYPE_FLOAT:
-	if (soft_float)
-	  {
-	    cif->flags += FFI_TYPE_SINT32 << (FFI_FLAG_BITS * 8);
-	    break;
-	  }
-	/* else fall through */
-      case FFI_TYPE_DOUBLE:
-	if (soft_float)
-	  cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
-	else
-	  cif->flags += cif->rtype->type << (FFI_FLAG_BITS * 8);
-	break;
-
-      case FFI_TYPE_LONGDOUBLE:
-	/* Long double is returned as if it were a struct containing
-	   two doubles.  */
-	if (soft_float)
-	  {
-	    cif->flags += FFI_TYPE_STRUCT << (FFI_FLAG_BITS * 8);
-	    cif->flags += FFI_TYPE_SMALLSTRUCT2 << (4 + (FFI_FLAG_BITS * 8));
- 	  }
-	else
-	  {
-	    cif->flags += FFI_TYPE_STRUCT << (FFI_FLAG_BITS * 8);
-	    cif->flags += (FFI_TYPE_DOUBLE
-			   + (FFI_TYPE_DOUBLE << FFI_FLAG_BITS))
-					      << (4 + (FFI_FLAG_BITS * 8));
-	  }
-	break;
-      default:
-	cif->flags += FFI_TYPE_INT << (FFI_FLAG_BITS * 8);
-	break;
-      }
-  }
-#endif
-  
-  return FFI_OK;
-}
-
-/* Low level routine for calling O32 functions */
-extern int ffi_call_O32(void (*)(char *, extended_cif *, int, int), 
-			extended_cif *, unsigned, 
-			unsigned, unsigned *, void (*)(void));
-
-/* Low level routine for calling N32 functions */
-extern int ffi_call_N32(void (*)(char *, extended_cif *, int, int), 
-			extended_cif *, unsigned, 
-			unsigned, void *, void (*)(void));
-
-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) 
-    {
-#ifdef FFI_MIPS_O32
-    case FFI_O32:
-    case FFI_O32_SOFT_FLOAT:
-      ffi_call_O32(ffi_prep_args, &ecif, cif->bytes, 
-		   cif->flags, ecif.rvalue, fn);
-      break;
-#endif
-
-#ifdef FFI_MIPS_N32
-    case FFI_N32:
-    case FFI_N32_SOFT_FLOAT:
-    case FFI_N64:
-    case FFI_N64_SOFT_FLOAT:
-      {
-        int copy_rvalue = 0;
-	int copy_offset = 0;
-        char *rvalue_copy = ecif.rvalue;
-        if (cif->rtype->type == FFI_TYPE_STRUCT && cif->rtype->size < 16)
-          {
-            /* For structures smaller than 16 bytes we clobber memory
-               in 8 byte increments.  Make a copy so we don't clobber
-               the callers memory outside of the struct bounds.  */
-            rvalue_copy = alloca(16);
-            copy_rvalue = 1;
-          }
-	else if (cif->rtype->type == FFI_TYPE_FLOAT
-		 && (cif->abi == FFI_N64_SOFT_FLOAT
-		     || cif->abi == FFI_N32_SOFT_FLOAT))
-	  {
-	    rvalue_copy = alloca (8);
-	    copy_rvalue = 1;
-#if defined(__MIPSEB__) || defined(_MIPSEB)
-	    copy_offset = 4;
-#endif
-	  }
-        ffi_call_N32(ffi_prep_args, &ecif, cif->bytes,
-                     cif->flags, rvalue_copy, fn);
-        if (copy_rvalue)
-          memcpy(ecif.rvalue, rvalue_copy + copy_offset, cif->rtype->size);
-      }
-      break;
-#endif
-
-    default:
-      FFI_ASSERT(0);
-      break;
-    }
-}
-
-#if FFI_CLOSURES
-#if defined(FFI_MIPS_O32)
-extern void ffi_closure_O32(void);
-#else
-extern void ffi_closure_N32(void);
-#endif /* FFI_MIPS_O32 */
-
-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 int *tramp = (unsigned int *) &closure->tramp[0];
-  void * fn;
-  char *clear_location = (char *) codeloc;
-
-#if defined(FFI_MIPS_O32)
-  if (cif->abi != FFI_O32 && cif->abi != FFI_O32_SOFT_FLOAT)
-    return FFI_BAD_ABI;
-  fn = ffi_closure_O32;
-#else /* FFI_MIPS_N32 */
-  if (cif->abi != FFI_N32 && cif->abi != FFI_N64)
-    return FFI_BAD_ABI;
-  fn = ffi_closure_N32;
-#endif /* FFI_MIPS_O32 */
-
-#if defined(FFI_MIPS_O32) || (_MIPS_SIM ==_ABIN32)
-  /* lui  $25,high(fn) */
-  tramp[0] = 0x3c190000 | ((unsigned)fn >> 16);
-  /* ori  $25,low(fn)  */
-  tramp[1] = 0x37390000 | ((unsigned)fn & 0xffff);
-  /* lui  $12,high(codeloc) */
-  tramp[2] = 0x3c0c0000 | ((unsigned)codeloc >> 16);
-  /* jr   $25          */
-  tramp[3] = 0x03200008;
-  /* ori  $12,low(codeloc)  */
-  tramp[4] = 0x358c0000 | ((unsigned)codeloc & 0xffff);
-#else
-  /* N64 has a somewhat larger trampoline.  */
-  /* lui  $25,high(fn) */
-  tramp[0] = 0x3c190000 | ((unsigned long)fn >> 48);
-  /* lui  $12,high(codeloc) */
-  tramp[1] = 0x3c0c0000 | ((unsigned long)codeloc >> 48);
-  /* ori  $25,mid-high(fn)  */
-  tramp[2] = 0x37390000 | (((unsigned long)fn >> 32 ) & 0xffff);
-  /* ori  $12,mid-high(codeloc)  */
-  tramp[3] = 0x358c0000 | (((unsigned long)codeloc >> 32) & 0xffff);
-  /* dsll $25,$25,16 */
-  tramp[4] = 0x0019cc38;
-  /* dsll $12,$12,16 */
-  tramp[5] = 0x000c6438;
-  /* ori  $25,mid-low(fn)  */
-  tramp[6] = 0x37390000 | (((unsigned long)fn >> 16 ) & 0xffff);
-  /* ori  $12,mid-low(codeloc)  */
-  tramp[7] = 0x358c0000 | (((unsigned long)codeloc >> 16) & 0xffff);
-  /* dsll $25,$25,16 */
-  tramp[8] = 0x0019cc38;
-  /* dsll $12,$12,16 */
-  tramp[9] = 0x000c6438;
-  /* ori  $25,low(fn)  */
-  tramp[10] = 0x37390000 | ((unsigned long)fn  & 0xffff);
-  /* jr   $25          */
-  tramp[11] = 0x03200008;
-  /* ori  $12,low(codeloc)  */
-  tramp[12] = 0x358c0000 | ((unsigned long)codeloc & 0xffff);
-
-#endif
-
-  closure->cif = cif;
-  closure->fun = fun;
-  closure->user_data = user_data;
-
-#ifdef USE__BUILTIN___CLEAR_CACHE
-  __builtin___clear_cache(clear_location, clear_location + FFI_TRAMPOLINE_SIZE);
-#else
-  cacheflush (clear_location, FFI_TRAMPOLINE_SIZE, ICACHE);
-#endif
-  return FFI_OK;
-}
-
-/*
- * Decodes the arguments to a function, which will be stored on the
- * stack. AR is the pointer to the beginning of the integer arguments
- * (and, depending upon the arguments, some floating-point arguments
- * as well). FPR is a pointer to the area where floating point
- * registers have been saved, if any.
- *
- * RVALUE is the location where the function return value will be
- * stored. CLOSURE is the prepared closure to invoke.
- *
- * This function should only be called from assembly, which is in
- * turn called from a trampoline.
- *
- * Returns the function return type.
- *
- * Based on the similar routine for sparc.
- */
-int
-ffi_closure_mips_inner_O32 (ffi_closure *closure,
-			    void *rvalue, ffi_arg *ar,
-			    double *fpr)
-{
-  ffi_cif *cif;
-  void **avaluep;
-  ffi_arg *avalue;
-  ffi_type **arg_types;
-  int i, avn, argn, seen_int;
-
-  cif = closure->cif;
-  avalue = alloca (cif->nargs * sizeof (ffi_arg));
-  avaluep = alloca (cif->nargs * sizeof (ffi_arg));
-
-  seen_int = (cif->abi == FFI_O32_SOFT_FLOAT);
-  argn = 0;
-
-  if ((cif->flags >> (FFI_FLAG_BITS * 2)) == FFI_TYPE_STRUCT)
-    {
-      rvalue = (void *)(UINT32)ar[0];
-      argn = 1;
-    }
-
-  i = 0;
-  avn = cif->nargs;
-  arg_types = cif->arg_types;
-
-  while (i < avn)
-    {
-      if (i < 2 && !seen_int &&
-	  (arg_types[i]->type == FFI_TYPE_FLOAT ||
-	   arg_types[i]->type == FFI_TYPE_DOUBLE ||
-	   arg_types[i]->type == FFI_TYPE_LONGDOUBLE))
-	{
-#if defined(__MIPSEB__) || defined(_MIPSEB)
-	  if (arg_types[i]->type == FFI_TYPE_FLOAT)
-	    avaluep[i] = ((char *) &fpr[i]) + sizeof (float);
-	  else
-#endif
-	    avaluep[i] = (char *) &fpr[i];
-	}
-      else
-	{
-	  if (arg_types[i]->alignment == 8 && (argn & 0x1))
-	    argn++;
-	  switch (arg_types[i]->type)
-	    {
-	      case FFI_TYPE_SINT8:
-		avaluep[i] = &avalue[i];
-		*(SINT8 *) &avalue[i] = (SINT8) ar[argn];
-		break;
-
-	      case FFI_TYPE_UINT8:
-		avaluep[i] = &avalue[i];
-		*(UINT8 *) &avalue[i] = (UINT8) ar[argn];
-		break;
-		  
-	      case FFI_TYPE_SINT16:
-		avaluep[i] = &avalue[i];
-		*(SINT16 *) &avalue[i] = (SINT16) ar[argn];
-		break;
-		  
-	      case FFI_TYPE_UINT16:
-		avaluep[i] = &avalue[i];
-		*(UINT16 *) &avalue[i] = (UINT16) ar[argn];
-		break;
-
-	      default:
-		avaluep[i] = (char *) &ar[argn];
-		break;
-	    }
-	  seen_int = 1;
-	}
-      argn += ALIGN(arg_types[i]->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
-      i++;
-    }
-
-  /* Invoke the closure. */
-  (closure->fun) (cif, rvalue, avaluep, closure->user_data);
-
-  if (cif->abi == FFI_O32_SOFT_FLOAT)
-    {
-      switch (cif->rtype->type)
-        {
-        case FFI_TYPE_FLOAT:
-          return FFI_TYPE_INT;
-        case FFI_TYPE_DOUBLE:
-          return FFI_TYPE_UINT64;
-        default:
-          return cif->rtype->type;
-        }
-    }
-  else
-    {
-      return cif->rtype->type;
-    }
-}
-
-#if defined(FFI_MIPS_N32)
-
-static void
-copy_struct_N32(char *target, unsigned offset, ffi_abi abi, ffi_type *type,
-                int argn, unsigned arg_offset, ffi_arg *ar,
-                ffi_arg *fpr, int soft_float)
-{
-  ffi_type **elt_typep = type->elements;
-  while(*elt_typep)
-    {
-      ffi_type *elt_type = *elt_typep;
-      unsigned o;
-      char *tp;
-      char *argp;
-      char *fpp;
-
-      o = ALIGN(offset, elt_type->alignment);
-      arg_offset += o - offset;
-      offset = o;
-      argn += arg_offset / sizeof(ffi_arg);
-      arg_offset = arg_offset % sizeof(ffi_arg);
-
-      argp = (char *)(ar + argn);
-      fpp = (char *)(argn >= 8 ? ar + argn : fpr + argn);
-
-      tp = target + offset;
-
-      if (elt_type->type == FFI_TYPE_DOUBLE && !soft_float)
-        *(double *)tp = *(double *)fpp;
-      else
-        memcpy(tp, argp + arg_offset, elt_type->size);
-
-      offset += elt_type->size;
-      arg_offset += elt_type->size;
-      elt_typep++;
-      argn += arg_offset / sizeof(ffi_arg);
-      arg_offset = arg_offset % sizeof(ffi_arg);
-    }
-}
-
-/*
- * Decodes the arguments to a function, which will be stored on the
- * stack. AR is the pointer to the beginning of the integer
- * arguments. FPR is a pointer to the area where floating point
- * registers have been saved.
- *
- * RVALUE is the location where the function return value will be
- * stored. CLOSURE is the prepared closure to invoke.
- *
- * This function should only be called from assembly, which is in
- * turn called from a trampoline.
- *
- * Returns the function return flags.
- *
- */
-int
-ffi_closure_mips_inner_N32 (ffi_closure *closure,
-			    void *rvalue, ffi_arg *ar,
-			    ffi_arg *fpr)
-{
-  ffi_cif *cif;
-  void **avaluep;
-  ffi_arg *avalue;
-  ffi_type **arg_types;
-  int i, avn, argn;
-  int soft_float;
-  ffi_arg *argp;
-
-  cif = closure->cif;
-  soft_float = cif->abi == FFI_N64_SOFT_FLOAT
-    || cif->abi == FFI_N32_SOFT_FLOAT;
-  avalue = alloca (cif->nargs * sizeof (ffi_arg));
-  avaluep = alloca (cif->nargs * sizeof (ffi_arg));
-
-  argn = 0;
-
-  if (cif->rstruct_flag)
-    {
-#if _MIPS_SIM==_ABIN32
-      rvalue = (void *)(UINT32)ar[0];
-#else /* N64 */
-      rvalue = (void *)ar[0];
-#endif
-      argn = 1;
-    }
-
-  i = 0;
-  avn = cif->nargs;
-  arg_types = cif->arg_types;
-
-  while (i < avn)
-    {
-      if (arg_types[i]->type == FFI_TYPE_FLOAT
-	  || arg_types[i]->type == FFI_TYPE_DOUBLE
-	  || arg_types[i]->type == FFI_TYPE_LONGDOUBLE)
-        {
-          argp = (argn >= 8 || soft_float) ? ar + argn : fpr + argn;
-          if ((arg_types[i]->type == FFI_TYPE_LONGDOUBLE) && ((unsigned)argp & (arg_types[i]->alignment-1)))
-            {
-              argp=(ffi_arg*)ALIGN(argp,arg_types[i]->alignment);
-              argn++;
-            }
-#if defined(__MIPSEB__) || defined(_MIPSEB)
-          if (arg_types[i]->type == FFI_TYPE_FLOAT && argn < 8)
-            avaluep[i] = ((char *) argp) + sizeof (float);
-          else
-#endif
-            avaluep[i] = (char *) argp;
-        }
-      else
-        {
-          unsigned type = arg_types[i]->type;
-
-          if (arg_types[i]->alignment > sizeof(ffi_arg))
-            argn = ALIGN(argn, arg_types[i]->alignment / sizeof(ffi_arg));
-
-          argp = ar + argn;
-
-          /* The size of a pointer depends on the ABI */
-          if (type == FFI_TYPE_POINTER)
-            type = (cif->abi == FFI_N64 || cif->abi == FFI_N64_SOFT_FLOAT)
-	      ? FFI_TYPE_SINT64 : FFI_TYPE_SINT32;
-
-	  if (soft_float && type ==  FFI_TYPE_FLOAT)
-	    type = FFI_TYPE_UINT32;
-
-          switch (type)
-            {
-            case FFI_TYPE_SINT8:
-              avaluep[i] = &avalue[i];
-              *(SINT8 *) &avalue[i] = (SINT8) *argp;
-              break;
-
-            case FFI_TYPE_UINT8:
-              avaluep[i] = &avalue[i];
-              *(UINT8 *) &avalue[i] = (UINT8) *argp;
-              break;
-
-            case FFI_TYPE_SINT16:
-              avaluep[i] = &avalue[i];
-              *(SINT16 *) &avalue[i] = (SINT16) *argp;
-              break;
-
-            case FFI_TYPE_UINT16:
-              avaluep[i] = &avalue[i];
-              *(UINT16 *) &avalue[i] = (UINT16) *argp;
-              break;
-
-            case FFI_TYPE_SINT32:
-              avaluep[i] = &avalue[i];
-              *(SINT32 *) &avalue[i] = (SINT32) *argp;
-              break;
-
-            case FFI_TYPE_UINT32:
-              avaluep[i] = &avalue[i];
-              *(UINT32 *) &avalue[i] = (UINT32) *argp;
-              break;
-
-            case FFI_TYPE_STRUCT:
-              if (argn < 8)
-                {
-                  /* Allocate space for the struct as at least part of
-                     it was passed in registers.  */
-                  avaluep[i] = alloca(arg_types[i]->size);
-                  copy_struct_N32(avaluep[i], 0, cif->abi, arg_types[i],
-                                  argn, 0, ar, fpr, soft_float);
-
-                  break;
-                }
-              /* Else fall through.  */
-            default:
-              avaluep[i] = (char *) argp;
-              break;
-            }
-        }
-      argn += ALIGN(arg_types[i]->size, sizeof(ffi_arg)) / sizeof(ffi_arg);
-      i++;
-    }
-
-  /* Invoke the closure. */
-  (closure->fun) (cif, rvalue, avaluep, closure->user_data);
-
-  return cif->flags >> (FFI_FLAG_BITS * 8);
-}
-
-#endif /* FFI_MIPS_N32 */
-
-#endif /* FFI_CLOSURES */