ffi 1.9.18-x86-mingw32 → 1.9.21-x86-mingw32

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

@@ -0,0 +1,53 @@
+/* -----------------------------------------------------------------------
+   ffitarget.h - Copyright (c) 2012, 2013 Xilinx, Inc
+
+   Target configuration macros for MicroBlaze.
+
+   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_LAST_ABI,
+	FFI_DEFAULT_ABI = FFI_SYSV
+} ffi_abi;
+#endif
+
+/* Definitions for closures */
+
+#define FFI_CLOSURES 1
+#define FFI_NATIVE_RAW_API 0
+
+#define FFI_TRAMPOLINE_SIZE (4*8)
+
+#endif

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

@@ -0,0 +1,302 @@
+/* -----------------------------------------------------------------------
+   sysv.S - 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.
+   ----------------------------------------------------------------------- */
+
+#define LIBFFI_ASM
+#include <fficonfig.h>
+#include <ffi.h>
+
+	/*
+	 * arg[0] (r5)  = ffi_prep_args,
+	 * arg[1] (r6)  = &ecif,
+	 * arg[2] (r7)  = cif->bytes,
+	 * arg[3] (r8)  = cif->flags,
+	 * arg[4] (r9)  = ecif.rvalue,
+	 * arg[5] (r10) = fn
+	 * arg[6] (sp[0]) = cif->rtype->type
+	 * arg[7] (sp[4]) = cif->rtype->size
+	 */
+	.text
+	.globl ffi_call_SYSV
+	.type ffi_call_SYSV, @function
+ffi_call_SYSV:
+	/* push callee saves */
+	addik r1, r1, -20
+	swi r19, r1, 0 /* Frame Pointer */
+	swi r20, r1, 4 /* PIC register */
+	swi r21, r1, 8 /* PIC register */
+	swi r22, r1, 12 /* save for locals */
+	swi r23, r1, 16 /* save for locals */
+	
+	/* save the r5-r10 registers in the stack */
+	addik r1, r1, -24 /* increment sp to store 6x 32-bit words */
+	swi r5, r1, 0
+	swi r6, r1, 4
+	swi r7, r1, 8
+	swi r8, r1, 12
+	swi r9, r1, 16
+	swi r10, r1, 20
+
+	/* save function pointer */
+	addik r3, r5, 0 /* copy ffi_prep_args into r3 */
+	addik r22, r1, 0 /* save sp for unallocated args into r22 (callee-saved) */
+	addik r23, r10, 0 /* save function address into r23 (callee-saved) */
+
+	/* prepare stack with allocation for n (bytes = r7) args */
+	rsub r1, r7, r1 /* subtract bytes from sp */
+
+	/* prep args for ffi_prep_args call */
+	addik r5, r1, 0 /* store stack pointer into arg[0] */
+	/* r6 still holds ecif for arg[1] */
+
+	/* Call ffi_prep_args(stack, &ecif). */
+	addik r1, r1, -4
+	swi r15, r1, 0 /* store the link register in the frame */
+	brald r15, r3
+	nop /* branch has delay slot */
+	lwi r15, r1, 0
+	addik r1, r1, 4 /* restore the link register from the frame */
+	/* returns calling stack pointer location */
+
+	/* prepare args for fn call, prep_args populates them onto the stack */
+	lwi r5, r1, 0 /* arg[0] */
+	lwi r6, r1, 4 /* arg[1] */
+	lwi r7, r1, 8 /* arg[2] */
+	lwi r8, r1, 12 /* arg[3] */
+	lwi r9, r1, 16 /* arg[4] */
+	lwi r10, r1, 20 /* arg[5] */
+
+	/* call (fn) (...). */
+	addik r1, r1, -4
+	swi r15, r1, 0 /* store the link register in the frame */
+	brald r15, r23
+	nop /* branch has delay slot */
+	lwi r15, r1, 0
+	addik r1, r1, 4 /* restore the link register from the frame */
+
+	/* Remove the space we pushed for the args. */
+	addik r1, r22, 0 /* restore old SP */
+
+	/* restore this functions parameters */
+	lwi r5, r1, 0 /* arg[0] */
+	lwi r6, r1, 4 /* arg[1] */
+	lwi r7, r1, 8 /* arg[2] */
+	lwi r8, r1, 12 /* arg[3] */
+	lwi r9, r1, 16 /* arg[4] */
+	lwi r10, r1, 20 /* arg[5] */
+	addik r1, r1, 24 /* decrement sp to de-allocate 6x 32-bit words */
+
+	/* If the return value pointer is NULL, assume no return value. */
+	beqi r9, ffi_call_SYSV_end
+
+	lwi r22, r1, 48 /* get return type (20 for locals + 28 for arg[6]) */
+	lwi r23, r1, 52 /* get return size (20 for locals + 32 for arg[7])  */
+	
+	/* Check if return type is actually a struct, do nothing */
+	rsubi r11, r22, FFI_TYPE_STRUCT
+	beqi r11, ffi_call_SYSV_end
+
+	/* Return 8bit */
+	rsubi r11, r23, 1
+	beqi r11, ffi_call_SYSV_store8
+
+	/* Return 16bit */
+	rsubi r11, r23, 2
+	beqi r11, ffi_call_SYSV_store16
+
+	/* Return 32bit */
+	rsubi r11, r23, 4
+	beqi r11, ffi_call_SYSV_store32
+
+	/* Return 64bit */
+	rsubi r11, r23, 8
+	beqi r11, ffi_call_SYSV_store64
+
+	/* Didn't match anything */
+	bri ffi_call_SYSV_end
+
+ffi_call_SYSV_store64:
+	swi r3, r9, 0 /* store word r3 into return value */
+	swi r4, r9, 4 /* store word r4 into return value */
+	bri ffi_call_SYSV_end
+
+ffi_call_SYSV_store32:
+	swi r3, r9, 0 /* store word r3 into return value */
+	bri ffi_call_SYSV_end
+
+ffi_call_SYSV_store16:
+#ifdef __BIG_ENDIAN__
+	shi r3, r9, 2 /* store half-word r3 into return value */
+#else
+	shi r3, r9, 0 /* store half-word r3 into return value */
+#endif
+	bri ffi_call_SYSV_end
+
+ffi_call_SYSV_store8:
+#ifdef __BIG_ENDIAN__
+	sbi r3, r9, 3 /* store byte r3 into return value */
+#else
+	sbi r3, r9, 0 /* store byte r3 into return value */
+#endif
+	bri ffi_call_SYSV_end
+
+ffi_call_SYSV_end:
+	/* callee restores */
+	lwi r19, r1, 0 /* frame pointer */
+	lwi r20, r1, 4 /* PIC register */
+	lwi r21, r1, 8 /* PIC register */
+	lwi r22, r1, 12
+	lwi r23, r1, 16
+	addik r1, r1, 20
+
+	/* return from sub-routine (with delay slot) */
+	rtsd r15, 8
+	nop
+
+	.size ffi_call_SYSV, . - ffi_call_SYSV
+
+/* ------------------------------------------------------------------------- */
+
+	/*
+	 * args passed into this function, are passed down to the callee.
+	 * this function is the target of the closure trampoline, as such r12 is 
+	 * a pointer to the closure object.
+	 */
+	.text
+	.globl ffi_closure_SYSV
+	.type ffi_closure_SYSV, @function
+ffi_closure_SYSV:
+	/* push callee saves */
+	addik r11, r1, 28 /* save stack args start location (excluding regs/link) */
+	addik r1, r1, -12
+	swi r19, r1, 0 /* Frame Pointer */
+	swi r20, r1, 4 /* PIC register */
+	swi r21, r1, 8 /* PIC register */
+
+	/* store register args on stack */
+	addik r1, r1, -24
+	swi r5, r1, 0
+	swi r6, r1, 4
+	swi r7, r1, 8
+	swi r8, r1, 12
+	swi r9, r1, 16
+	swi r10, r1, 20
+
+	/* setup args */
+	addik r5, r1, 0 /* register_args */
+	addik r6, r11, 0 /* stack_args */
+	addik r7, r12, 0 /* closure object */
+	addik r1, r1, -8 /* allocate return value */
+	addik r8, r1, 0 /* void* rvalue */
+	addik r1, r1, -8 /* allocate for return type/size values */
+	addik r9, r1, 0 /* void* rtype */
+	addik r10, r1, 4 /* void* rsize */
+
+	/* call the wrap_call function */
+	addik r1, r1, -28 /* allocate args + link reg */
+	swi r15, r1, 0 /* store the link register in the frame */
+	brald r15, r3
+	nop /* branch has delay slot */
+	lwi r15, r1, 0
+	addik r1, r1, 28 /* restore the link register from the frame */
+
+ffi_closure_SYSV_prepare_return:
+	lwi r9, r1, 0 /* rtype */
+	lwi r10, r1, 4 /* rsize */
+	addik r1, r1, 8 /* de-allocate return info values */
+
+	/* Check if return type is actually a struct, store 4 bytes */
+	rsubi r11, r9, FFI_TYPE_STRUCT
+	beqi r11, ffi_closure_SYSV_store32
+
+	/* Return 8bit */
+	rsubi r11, r10, 1
+	beqi r11, ffi_closure_SYSV_store8
+
+	/* Return 16bit */
+	rsubi r11, r10, 2
+	beqi r11, ffi_closure_SYSV_store16
+
+	/* Return 32bit */
+	rsubi r11, r10, 4
+	beqi r11, ffi_closure_SYSV_store32
+
+	/* Return 64bit */
+	rsubi r11, r10, 8
+	beqi r11, ffi_closure_SYSV_store64
+
+	/* Didn't match anything */
+	bri ffi_closure_SYSV_end
+
+ffi_closure_SYSV_store64:
+	lwi r3, r1, 0 /* store word r3 into return value */
+	lwi r4, r1, 4 /* store word r4 into return value */
+	/* 64 bits == 2 words, no sign extend occurs */
+	bri ffi_closure_SYSV_end
+
+ffi_closure_SYSV_store32:
+	lwi r3, r1, 0 /* store word r3 into return value */
+	/* 32 bits == 1 word, no sign extend occurs */
+	bri ffi_closure_SYSV_end
+
+ffi_closure_SYSV_store16:
+#ifdef __BIG_ENDIAN__
+	lhui r3, r1, 2 /* store half-word r3 into return value */
+#else
+	lhui r3, r1, 0 /* store half-word r3 into return value */
+#endif
+	rsubi r11, r9, FFI_TYPE_SINT16
+	bnei r11, ffi_closure_SYSV_end
+	sext16 r3, r3 /* fix sign extend of sint8 */
+	bri ffi_closure_SYSV_end
+
+ffi_closure_SYSV_store8:
+#ifdef __BIG_ENDIAN__
+	lbui r3, r1, 3 /* store byte r3 into return value */
+#else
+	lbui r3, r1, 0 /* store byte r3 into return value */
+#endif
+	rsubi r11, r9, FFI_TYPE_SINT8
+	bnei r11, ffi_closure_SYSV_end
+	sext8 r3, r3 /* fix sign extend of sint8 */
+	bri ffi_closure_SYSV_end
+
+ffi_closure_SYSV_end:
+	addik r1, r1, 8 /* de-allocate return value */
+
+	/* de-allocate stored args */
+	addik r1, r1, 24
+
+	/* callee restores */
+	lwi r19, r1, 0 /* frame pointer */
+	lwi r20, r1, 4 /* PIC register */
+	lwi r21, r1, 8 /* PIC register */
+	addik r1, r1, 12
+
+	/* return from sub-routine (with delay slot) */
+	rtsd r15, 8
+	nop
+
+	.size ffi_closure_SYSV, . - ffi_closure_SYSV

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

@@ -76,7 +76,6 @@ static void ffi_prep_args(char *stack,
   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
@@ -93,11 +92,10 @@ static void ffi_prep_args(char *stack,
   memset(stack, 0, bytes);
 
 #ifdef FFI_MIPS_N32
-  ecif_test = ecif->cif->rstruct_flag != 0;
+  if ( ecif->cif->rstruct_flag != 0 )
 #else
-  ecif_test = ecif->cif->rtype->type == FFI_TYPE_STRUCT;
+  if ( ecif->cif->rtype->type == FFI_TYPE_STRUCT )
 #endif  
-    if (ecif_test)
     {
       *(ffi_arg *) argp = (ffi_arg) ecif->rvalue;
       argp += sizeof(ffi_arg);
@@ -118,7 +116,7 @@ static void ffi_prep_args(char *stack,
       
       if ((a - 1) & (unsigned long) argp)
 	{
-	  argp = (char *) ALIGN(argp, a);
+	  argp = (char *) FFI_ALIGN(argp, a);
 	  FIX_ARGP;
 	}
 
@@ -172,7 +170,14 @@ static void ffi_prep_args(char *stack,
 		break;
 		  
 	      case FFI_TYPE_UINT32:
+#ifdef FFI_MIPS_N32
+		/* The N32 ABI requires that 32-bit integers
+		   be sign-extended to 64-bits, regardless of
+		   whether they are signed or unsigned. */
+		*(ffi_arg *)argp = *(SINT32 *)(* p_argv);
+#else
 		*(ffi_arg *)argp = *(UINT32 *)(* p_argv);
+#endif
 		break;
 
 	      /* This can only happen with 64bit slots.  */
@@ -242,7 +247,7 @@ calc_n32_struct_flags(int soft_float, ffi_type *arg,
   while ((e = arg->elements[index]))
     {
       /* Align this object.  */
-      *loc = ALIGN(*loc, e->alignment);
+      *loc = FFI_ALIGN(*loc, e->alignment);
       if (e->type == FFI_TYPE_DOUBLE)
 	{
           /* Already aligned to FFI_SIZEOF_ARG.  */
@@ -257,7 +262,7 @@ calc_n32_struct_flags(int soft_float, ffi_type *arg,
       index++;
     }
   /* Next Argument register at alignment of FFI_SIZEOF_ARG.  */
-  *arg_reg = ALIGN(*loc, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
+  *arg_reg = FFI_ALIGN(*loc, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
 
   return flags;
 }
@@ -469,7 +474,7 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
 	    break;
           case FFI_TYPE_LONGDOUBLE:
             /* Align it.  */
-            arg_reg = ALIGN(arg_reg, 2);
+            arg_reg = FFI_ALIGN(arg_reg, 2);
             /* Treat it as two adjacent doubles.  */
 	    if (soft_float) 
 	      {
@@ -576,14 +581,15 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
 /* 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));
+			unsigned, unsigned *, void (*)(void), void *closure);
 
 /* 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));
+			unsigned, void *, void (*)(void), void *closure);
 
-void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
+void ffi_call_int(ffi_cif *cif, void (*fn)(void), void *rvalue, 
+	      void **avalue, void *closure)
 {
   extended_cif ecif;
 
@@ -605,7 +611,7 @@ void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
     case FFI_O32:
     case FFI_O32_SOFT_FLOAT:
       ffi_call_O32(ffi_prep_args, &ecif, cif->bytes, 
-		   cif->flags, ecif.rvalue, fn);
+		   cif->flags, ecif.rvalue, fn, closure);
       break;
 #endif
 
@@ -637,7 +643,7 @@ void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
 #endif
 	  }
         ffi_call_N32(ffi_prep_args, &ecif, cif->bytes,
-                     cif->flags, rvalue_copy, fn);
+                     cif->flags, rvalue_copy, fn, closure);
         if (copy_rvalue)
           memcpy(ecif.rvalue, rvalue_copy + copy_offset, cif->rtype->size);
       }
@@ -650,11 +656,27 @@ void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
     }
 }
 
+void
+ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
+{
+  ffi_call_int (cif, fn, rvalue, avalue, NULL);
+}
+
+void
+ffi_call_go (ffi_cif *cif, void (*fn)(void), void *rvalue,
+	     void **avalue, void *closure)
+{
+  ffi_call_int (cif, fn, rvalue, avalue, closure);
+}
+
+
 #if FFI_CLOSURES
 #if defined(FFI_MIPS_O32)
 extern void ffi_closure_O32(void);
+extern void ffi_go_closure_O32(void);
 #else
 extern void ffi_closure_N32(void);
+extern void ffi_go_closure_N32(void);
 #endif /* FFI_MIPS_O32 */
 
 ffi_status
@@ -672,9 +694,16 @@ ffi_prep_closure_loc (ffi_closure *closure,
   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)
+#else
+#if _MIPS_SIM ==_ABIN32
+  if (cif->abi != FFI_N32
+      && cif->abi != FFI_N32_SOFT_FLOAT)
+    return FFI_BAD_ABI;
+#else
+  if (cif->abi != FFI_N64
+      && cif->abi != FFI_N64_SOFT_FLOAT)
     return FFI_BAD_ABI;
+#endif
   fn = ffi_closure_N32;
 #endif /* FFI_MIPS_O32 */
 
@@ -750,17 +779,17 @@ ffi_prep_closure_loc (ffi_closure *closure,
  * Based on the similar routine for sparc.
  */
 int
-ffi_closure_mips_inner_O32 (ffi_closure *closure,
+ffi_closure_mips_inner_O32 (ffi_cif *cif,
+                            void (*fun)(ffi_cif*, void*, void**, void*),
+			    void *user_data,
 			    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));
 
@@ -823,12 +852,12 @@ ffi_closure_mips_inner_O32 (ffi_closure *closure,
 	    }
 	  seen_int = 1;
 	}
-      argn += ALIGN(arg_types[i]->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
+      argn += FFI_ALIGN(arg_types[i]->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
       i++;
     }
 
   /* Invoke the closure. */
-  (closure->fun) (cif, rvalue, avaluep, closure->user_data);
+  fun(cif, rvalue, avaluep, user_data);
 
   if (cif->abi == FFI_O32_SOFT_FLOAT)
     {
@@ -864,7 +893,7 @@ copy_struct_N32(char *target, unsigned offset, ffi_abi abi, ffi_type *type,
       char *argp;
       char *fpp;
 
-      o = ALIGN(offset, elt_type->alignment);
+      o = FFI_ALIGN(offset, elt_type->alignment);
       arg_offset += o - offset;
       offset = o;
       argn += arg_offset / sizeof(ffi_arg);
@@ -904,11 +933,12 @@ copy_struct_N32(char *target, unsigned offset, ffi_abi abi, ffi_type *type,
  *
  */
 int
-ffi_closure_mips_inner_N32 (ffi_closure *closure,
+ffi_closure_mips_inner_N32 (ffi_cif *cif, 
+			    void (*fun)(ffi_cif*, void*, void**, void*),
+                            void *user_data,
 			    void *rvalue, ffi_arg *ar,
 			    ffi_arg *fpr)
 {
-  ffi_cif *cif;
   void **avaluep;
   ffi_arg *avalue;
   ffi_type **arg_types;
@@ -916,7 +946,6 @@ ffi_closure_mips_inner_N32 (ffi_closure *closure,
   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));
@@ -947,7 +976,7 @@ ffi_closure_mips_inner_N32 (ffi_closure *closure,
           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);
+              argp=(ffi_arg*)FFI_ALIGN(argp,arg_types[i]->alignment);
               argn++;
             }
 #if defined(__MIPSEB__) || defined(_MIPSEB)
@@ -962,7 +991,7 @@ ffi_closure_mips_inner_N32 (ffi_closure *closure,
           unsigned type = arg_types[i]->type;
 
           if (arg_types[i]->alignment > sizeof(ffi_arg))
-            argn = ALIGN(argn, arg_types[i]->alignment / sizeof(ffi_arg));
+            argn = FFI_ALIGN(argn, arg_types[i]->alignment / sizeof(ffi_arg));
 
           argp = ar + argn;
 
@@ -1023,16 +1052,54 @@ ffi_closure_mips_inner_N32 (ffi_closure *closure,
               break;
             }
         }
-      argn += ALIGN(arg_types[i]->size, sizeof(ffi_arg)) / sizeof(ffi_arg);
+      argn += FFI_ALIGN(arg_types[i]->size, sizeof(ffi_arg)) / sizeof(ffi_arg);
       i++;
     }
 
   /* Invoke the closure. */
-  (closure->fun) (cif, rvalue, avaluep, closure->user_data);
+  fun (cif, rvalue, avaluep, user_data);
 
   return cif->flags >> (FFI_FLAG_BITS * 8);
 }
 
 #endif /* FFI_MIPS_N32 */
 
+#if defined(FFI_MIPS_O32)
+extern void ffi_closure_O32(void);
+extern void ffi_go_closure_O32(void);
+#else
+extern void ffi_closure_N32(void);
+extern void ffi_go_closure_N32(void);
+#endif /* FFI_MIPS_O32 */
+
+ffi_status
+ffi_prep_go_closure (ffi_go_closure* closure, ffi_cif* cif,
+		     void (*fun)(ffi_cif*,void*,void**,void*))
+{
+  void * fn;
+
+#if defined(FFI_MIPS_O32)
+  if (cif->abi != FFI_O32 && cif->abi != FFI_O32_SOFT_FLOAT)
+    return FFI_BAD_ABI;
+  fn = ffi_go_closure_O32;
+#else
+#if _MIPS_SIM ==_ABIN32
+  if (cif->abi != FFI_N32
+      && cif->abi != FFI_N32_SOFT_FLOAT)
+    return FFI_BAD_ABI;
+#else
+  if (cif->abi != FFI_N64
+      && cif->abi != FFI_N64_SOFT_FLOAT)
+    return FFI_BAD_ABI;
+#endif
+  fn = ffi_go_closure_N32;
+#endif /* FFI_MIPS_O32 */
+
+  closure->tramp = (void *)fn;
+  closure->cif = cif;
+  closure->fun = fun;
+
+  return FFI_OK;
+}
+
 #endif /* FFI_CLOSURES */