ffi 1.9.24 → 1.16.3

data/ext/ffi_c/libffi/src/mips/n32.S

@@ -114,6 +114,16 @@ loadregs:
 
 	REG_L	t6, 3*FFI_SIZEOF_ARG($fp)  # load the flags word into t6.
 
+	# when retval is _Complex long double, $f12/$a0, $f13/$a1 will be skipped
+	# no idea why, but gcc does it.
+	SRL	t4, t6, 8*FFI_FLAG_BITS
+	move	t8, t6
+	bne	t4, FFI_TYPE_COMPLEX_LDLD, loadregs1
+
+	SLL	t8, t6, 2*FFI_FLAG_BITS
+
+
+loadregs1:
 #ifdef __mips_soft_float
 	REG_L	a0, 0*FFI_SIZEOF_ARG(t9)
 	REG_L	a1, 1*FFI_SIZEOF_ARG(t9)
@@ -124,7 +134,7 @@ loadregs:
 	REG_L	a6, 6*FFI_SIZEOF_ARG(t9)
 	REG_L	a7, 7*FFI_SIZEOF_ARG(t9)
 #else
-	and	t4, t6, ((1<<FFI_FLAG_BITS)-1)
+	and	t4, t8, ((1<<FFI_FLAG_BITS)-1)
 	REG_L	a0, 0*FFI_SIZEOF_ARG(t9)
 	beqz	t4, arg1_next
 	bne	t4, FFI_TYPE_FLOAT, arg1_doublep
@@ -134,7 +144,7 @@ arg1_doublep:
 	l.d	$f12, 0*FFI_SIZEOF_ARG(t9)
 arg1_next:	
 	
-	SRL	t4, t6, 1*FFI_FLAG_BITS
+	SRL	t4, t8, 1*FFI_FLAG_BITS
 	and	t4, ((1<<FFI_FLAG_BITS)-1)
 	REG_L	a1, 1*FFI_SIZEOF_ARG(t9)
 	beqz	t4, arg2_next
@@ -145,7 +155,7 @@ arg2_doublep:
 	l.d	$f13, 1*FFI_SIZEOF_ARG(t9)	
 arg2_next:	
 	
-	SRL	t4, t6, 2*FFI_FLAG_BITS
+	SRL	t4, t8, 2*FFI_FLAG_BITS
 	and	t4, ((1<<FFI_FLAG_BITS)-1)
 	REG_L	a2, 2*FFI_SIZEOF_ARG(t9)
 	beqz	t4, arg3_next
@@ -156,7 +166,7 @@ arg3_doublep:
 	l.d	$f14, 2*FFI_SIZEOF_ARG(t9)	
 arg3_next:	
 	
-	SRL	t4, t6, 3*FFI_FLAG_BITS
+	SRL	t4, t8, 3*FFI_FLAG_BITS
 	and	t4, ((1<<FFI_FLAG_BITS)-1)
 	REG_L	a3, 3*FFI_SIZEOF_ARG(t9)
 	beqz	t4, arg4_next
@@ -167,7 +177,7 @@ arg4_doublep:
 	l.d	$f15, 3*FFI_SIZEOF_ARG(t9)	
 arg4_next:	
 	
-	SRL	t4, t6, 4*FFI_FLAG_BITS
+	SRL	t4, t8, 4*FFI_FLAG_BITS
 	and	t4, ((1<<FFI_FLAG_BITS)-1)
 	REG_L	a4, 4*FFI_SIZEOF_ARG(t9)
 	beqz	t4, arg5_next
@@ -178,7 +188,7 @@ arg5_doublep:
 	l.d	$f16, 4*FFI_SIZEOF_ARG(t9)	
 arg5_next:	
 	
-	SRL	t4, t6, 5*FFI_FLAG_BITS
+	SRL	t4, t8, 5*FFI_FLAG_BITS
 	and	t4, ((1<<FFI_FLAG_BITS)-1)
 	REG_L	a5, 5*FFI_SIZEOF_ARG(t9)
 	beqz	t4, arg6_next
@@ -189,7 +199,7 @@ arg6_doublep:
 	l.d	$f17, 5*FFI_SIZEOF_ARG(t9)	
 arg6_next:	
 	
-	SRL	t4, t6, 6*FFI_FLAG_BITS
+	SRL	t4, t8, 6*FFI_FLAG_BITS
 	and	t4, ((1<<FFI_FLAG_BITS)-1)
 	REG_L	a6, 6*FFI_SIZEOF_ARG(t9)
 	beqz	t4, arg7_next
@@ -200,7 +210,7 @@ arg7_doublep:
 	l.d	$f18, 6*FFI_SIZEOF_ARG(t9)	
 arg7_next:	
 	
-	SRL	t4, t6, 7*FFI_FLAG_BITS
+	SRL	t4, t8, 7*FFI_FLAG_BITS
 	and	t4, ((1<<FFI_FLAG_BITS)-1)
 	REG_L	a7, 7*FFI_SIZEOF_ARG(t9)
 	beqz	t4, arg8_next
@@ -212,7 +222,7 @@ arg8_doublep:
 arg8_next:	
 #endif
 
-callit:		
+callit:
 	# Load the function pointer
 	REG_L	t9, 5*FFI_SIZEOF_ARG($fp)
 
@@ -226,14 +236,21 @@ callit:
 	# Shift the return type flag over
 	SRL	t6, 8*FFI_FLAG_BITS
 
-	beq	t6, FFI_TYPE_SINT32, retint	
-	bne     t6, FFI_TYPE_INT, retfloat
+	beq	t6, FFI_TYPE_SINT32, retint
+	bne     t6, FFI_TYPE_INT, retuint32
 retint:
 	jal	t9
 	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
 	REG_S	v0, 0(t4)
 	b	epilogue
 
+retuint32:
+	bne     t6, FFI_TYPE_UINT32, retfloat
+	jal	t9
+	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
+	sw	v0, 0(t4)
+	b	epilogue
+
 retfloat:
 #ifndef __mips_soft_float
 	bne     t6, FFI_TYPE_FLOAT, retdouble
@@ -249,7 +266,7 @@ retdouble:
 	s.d	$f0, 0(t4)
 	b	epilogue
 
-retstruct_d:	
+retstruct_d:
 	bne	t6, FFI_TYPE_STRUCT_D, retstruct_f
 	jal	t9
 	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
@@ -263,16 +280,37 @@ retstruct_f:
 	s.s	$f0, 0(t4)
 	b	epilogue
 	
-retstruct_d_d:	
-	bne	t6, FFI_TYPE_STRUCT_DD, retstruct_f_f
+retstruct_d_d:
+	bne	t6, FFI_TYPE_STRUCT_DD, retcomplex_d_d
 	jal	t9
 	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
 	s.d	$f0, 0(t4)
 	s.d	$f2, 8(t4)
 	b	epilogue
+
+retcomplex_d_d:
+	bne	t6, FFI_TYPE_COMPLEX_DD, retcomplex_ld_ld
+	jal	t9
+	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
+	s.d	$f0, 0(t4)
+	s.d	$f2, 8(t4)
+	b	epilogue
+
+retcomplex_ld_ld:
+	bne	t6, FFI_TYPE_COMPLEX_LDLD, retstruct_f_f
+	jal	t9
+	b	epilogue
 	
-retstruct_f_f:	
-	bne	t6, FFI_TYPE_STRUCT_FF, retstruct_d_f
+retstruct_f_f:
+	bne	t6, FFI_TYPE_STRUCT_FF, retcomplex_f_f
+	jal	t9
+	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
+	s.s	$f0, 0(t4)
+	s.s	$f2, 4(t4)
+	b	epilogue
+
+retcomplex_f_f:
+	bne	t6, FFI_TYPE_COMPLEX_FF, retstruct_d_f
 	jal	t9
 	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
 	s.s	$f0, 0(t4)
@@ -315,7 +353,7 @@ retstruct_d_d_soft:
 	jal	t9
 	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
 	sd	v0, 0(t4)
-	sd	v1, 8(t4)
+	sd	a0, 8(t4) # not typo, it is a0, I have no idea, gcc does do it
 	b	epilogue
 	
 retstruct_f_f_soft:	
@@ -339,7 +377,7 @@ retstruct_f_d_soft:
 	jal	t9
 	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
 	sw	v0, 0(t4)
-	sd	v1, 8(t4)
+	sd	a0, 8(t4) # not typo, it is a0, I have no idea, gcc does do it
 	b	epilogue
 	
 retstruct_small:	
@@ -350,14 +388,37 @@ retstruct_small:
 	b	epilogue
 	
 retstruct_small2:	
-	bne	t6, FFI_TYPE_STRUCT_SMALL2, retstruct
+	bne	t6, FFI_TYPE_STRUCT_SMALL2, retlongdouble_soft
 	jal	t9
 	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
 	REG_S	v0, 0(t4)
 	REG_S	v1, 8(t4)
 	b	epilogue
 	
-retstruct:	
+retlongdouble_soft:
+	bne	t6, FFI_TYPE_LONGDOUBLE, retcomplex_small
+	jal	t9
+	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
+	REG_S	v0, 0(t4)
+	REG_S	a0, 8(t4) # not typo, it is a0, I have no idea, gcc does do it
+	b	epilogue
+
+retcomplex_small:
+	bne	t6, FFI_TYPE_COMPLEX_SMALL, retcomplex_small2
+	jal	t9
+	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
+	REG_S	v0, 0(t4)
+	b	epilogue
+
+retcomplex_small2:
+	bne	t6, FFI_TYPE_COMPLEX_SMALL2, retstruct
+	jal	t9
+	REG_L	t4, 4*FFI_SIZEOF_ARG($fp)
+	REG_S	v0, 0(t4)
+	REG_S	v1, 8(t4)
+	b	epilogue
+
+retstruct:
 noretval:	
 	jal	t9
 	
@@ -403,7 +464,7 @@ epilogue:
 	 */
 
 #define SIZEOF_FRAME2	(20 * FFI_SIZEOF_ARG)
-	
+
 #define A7_OFF2		(19 * FFI_SIZEOF_ARG)
 #define A6_OFF2		(18 * FFI_SIZEOF_ARG)
 #define A5_OFF2		(17 * FFI_SIZEOF_ARG)
@@ -451,8 +512,13 @@ ffi_go_closure_N32:
 
 	# Call ffi_closure_mips_inner_N32 to do the real work.
 	LA	t9, ffi_closure_mips_inner_N32
+#if _MIPS_SIM==_ABIN32
+	lw	a0, 4($15)   # cif
+	lw	a1, 8($15) # fun
+#else
 	REG_L	a0, 8($15)   # cif
 	REG_L	a1, 16($15) # fun
+#endif
 	move	a2, t7                     # userdata=closure
 	ADDU	a3, $sp, V0_OFF2           # rvalue
 	ADDU	a4, $sp, A0_OFF2           # ar
@@ -485,10 +551,17 @@ ffi_closure_N32:
 
 	# Call ffi_closure_mips_inner_N32 to do the real work.
 	LA	t9, ffi_closure_mips_inner_N32
+#if _MIPS_SIM==_ABIN32
+	lw	a0, 20($12)   # cif
+	lw	a1, 24($12)   # fun
+	lw	a2, 28($12) # user_data
+#else
 	REG_L	a0, 56($12)   # cif
 	REG_L	a1, 64($12)   # fun
 	REG_L	a2, 72($12) # user_data
+#endif
 	ADDU	a3, $sp, V0_OFF2
+	# FIXME: a4 does work, while if ret is _Complex long double, it will overwrite Fn_OFF2
 	ADDU	a4, $sp, A0_OFF2
 	ADDU	a5, $sp, F12_OFF2
 
@@ -513,10 +586,15 @@ $do_closure:
 	jalr	t9
 
 	# Return flags are in v0
-	bne     v0, FFI_TYPE_SINT32, cls_retint
+	bne     v0, FFI_TYPE_SINT32, cls_retuint32
 	lw	v0, V0_OFF2($sp)
 	b	cls_epilogue
 
+cls_retuint32:
+	bne     v0, FFI_TYPE_UINT32, cls_retint
+	lwu	v0, V0_OFF2($sp)
+	b	cls_epilogue
+
 cls_retint:
 	bne     v0, FFI_TYPE_INT, cls_retfloat
 	REG_L	v0, V0_OFF2($sp)
@@ -544,17 +622,29 @@ cls_retstruct_f:
 	b	cls_epilogue
 	
 cls_retstruct_d_d:	
-	bne	v0, FFI_TYPE_STRUCT_DD, cls_retstruct_f_f
+	bne	v0, FFI_TYPE_STRUCT_DD, cls_retcomplex_d_d
+	l.d	$f0, V0_OFF2($sp)
+	l.d	$f2, V1_OFF2($sp)
+	b	cls_epilogue
+
+cls_retcomplex_d_d:
+	bne	v0, FFI_TYPE_COMPLEX_DD, cls_retcomplex_f_f
 	l.d	$f0, V0_OFF2($sp)
 	l.d	$f2, V1_OFF2($sp)
 	b	cls_epilogue
 	
-cls_retstruct_f_f:	
-	bne	v0, FFI_TYPE_STRUCT_FF, cls_retstruct_d_f
+cls_retstruct_f_f:
+	bne	v0, FFI_TYPE_STRUCT_FF, cls_retcomplex_f_f
 	l.s	$f0, V0_OFF2($sp)
 	l.s	$f2, V1_OFF2($sp)
 	b	cls_epilogue
 	
+cls_retcomplex_f_f:
+	bne	v0, FFI_TYPE_COMPLEX_FF, cls_retstruct_d_f
+	l.s	$f0, V0_OFF2($sp)
+	l.s	$f2, (V0_OFF2+4)($sp)
+	b	cls_epilogue
+
 cls_retstruct_d_f:	
 	bne	v0, FFI_TYPE_STRUCT_DF, cls_retstruct_f_d
 	l.d	$f0, V0_OFF2($sp)
@@ -562,12 +652,31 @@ cls_retstruct_d_f:
 	b	cls_epilogue
 	
 cls_retstruct_f_d:	
-	bne	v0, FFI_TYPE_STRUCT_FD, cls_retstruct_small2
+	bne	v0, FFI_TYPE_STRUCT_FD, cls_retcomplex_ld_ld
 	l.s	$f0, V0_OFF2($sp)
 	l.d	$f2, V1_OFF2($sp)
 	b	cls_epilogue
+#else
+cls_longdouble_soft:
+	bne	v0, FFI_TYPE_LONGDOUBLE, cls_retcomplex_ld_ld
+	REG_L	v0, V0_OFF2($sp)
+	REG_L	a0, V1_OFF2($sp) # not typo, it is a0, I have no idea, gcc does do it
+	b	cls_epilogue
 #endif
-	
+
+cls_retcomplex_ld_ld:
+	bne	v0, FFI_TYPE_COMPLEX_LDLD, cls_retstruct_small2
+	REG_L	t8, A0_OFF2($sp)
+	REG_L	t9, 16($sp)
+	REG_S	t9, 0(t8)
+	REG_L	t9, 24($sp)
+	REG_S	t9, 8(t8)
+	REG_L	t9, 32($sp)
+	REG_S	t9, 16(t8)
+	REG_L	t9, 40($sp)
+	REG_S	t9, 24(t8)
+	b	cls_epilogue
+
 cls_retstruct_small2:	
 	REG_L	v0, V0_OFF2($sp)
 	REG_L	v1, V1_OFF2($sp)
@@ -582,7 +691,7 @@ cls_epilogue:
 	.end	ffi_closure_N32
 
 #ifdef __GNUC__
-        .section        .eh_frame,"aw",@progbits
+        .section        .eh_frame,EH_FRAME_FLAGS,@progbits
 .Lframe1:
         .4byte  .LECIE1-.LSCIE1		# length
 .LSCIE1:

data/ext/ffi_c/libffi/src/mips/o32.S

@@ -133,6 +133,7 @@ pass_f_d:
  #	bne	t0, FFI_ARGS_F_D, call_it
 	l.s	$f12, 0*FFI_SIZEOF_ARG($sp)	# load $fp regs from args
 	l.d	$f14, 2*FFI_SIZEOF_ARG($sp)	# passing double and float
+
 #endif
 
 call_it:	
@@ -146,7 +147,8 @@ call_it:
 	REG_L	t1, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
 	beqz	t1, noretval
 
-	bne     t2, FFI_TYPE_INT, retlonglong
+	and     t1, t2, ((1<<4)-1)
+	bne     t1, FFI_TYPE_INT, retlonglong
 	jalr	t9
 	REG_L	t0, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
 	REG_S	v0, 0(t0)
@@ -154,7 +156,7 @@ call_it:
 
 retlonglong:
 	# Really any 64-bit int, signed or not.
-	bne	t2, FFI_TYPE_UINT64, retfloat
+	bne	t1, FFI_TYPE_UINT64, retfloat
 	jalr	t9
 	REG_L	t0, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
 	REG_S	v1, 4(t0)
@@ -162,7 +164,7 @@ retlonglong:
 	b	epilogue
 
 retfloat:
-	bne     t2, FFI_TYPE_FLOAT, retdouble
+	bne     t1, FFI_TYPE_FLOAT, retdouble
 	jalr	t9
 	REG_L	t0, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
 #ifndef __mips_soft_float
@@ -173,7 +175,7 @@ retfloat:
 	b	epilogue
 
 retdouble:	
-	bne	t2, FFI_TYPE_DOUBLE, noretval
+	bne	t1, FFI_TYPE_DOUBLE, retcomplex
 	jalr	t9
 	REG_L	t0, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
 #ifndef __mips_soft_float
@@ -184,6 +186,48 @@ retdouble:
 #endif
 	b	epilogue
 	
+retcomplex:
+	# mask out the complex elements type.
+	# the struct of flags (bits):
+	# 0-1: arg0
+	# 2-3: arg1
+	# 4-7: return type
+	# 8-11: rtype elements type: for complex
+	# Note here: t2 is flags>>4
+	bne	t1, FFI_TYPE_COMPLEX, noretval
+	jalr	t9
+	REG_L	t0, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
+	REG_L	t1, A3_OFF($fp)		# load the flags word
+	SRL	t1, t1, 8
+	li	t3, 3
+	beq	t1, t3, 3f # double
+	li	t3, 2
+	beq	t1, t3, 2f # float
+	# FIXME: long double
+	slti	t3, t1, 5
+	beqz	t3, 5f     # (u)int8/16/32/64
+2:
+#ifndef __mips_soft_float
+	s.s	$f0, 0(t0)
+	s.s	$f2, 4(t0)
+#else
+	# FIXME: do nothing can pass all of the testsuite
+#endif
+	b	epilogue
+3:
+#ifndef __mips_soft_float
+	s.d	$f0, 0(t0)
+	s.d	$f2, 8(t0)
+#else
+	# FIXME: do nothing can pass all of the testsuite
+#endif
+	b	epilogue
+
+5:
+	REG_S	v1, 4(t0)
+	REG_S	v0, 0(t0)
+	b	epilogue
+
 noretval:	
 	jalr	t9
 	
@@ -282,9 +326,11 @@ $LCFI12:
 	li	$13, 1		# FFI_O32
 	bne	$16, $13, 1f	# Skip fp save if FFI_O32_SOFT_FLOAT
 	
+#ifndef __mips_soft_float
 	# Store all possible float/double registers.
 	s.d	$f12, FA_0_0_OFF2($fp)
 	s.d	$f14, FA_1_0_OFF2($fp)
+#endif
 1:
 	# prepare arguments for ffi_closure_mips_inner_O32
 	REG_L	a0, 4($15)	 # cif 
@@ -376,6 +422,19 @@ $do_closure:
 	li	$9, FFI_TYPE_DOUBLE
 	l.d	$f0, V0_OFF2($fp)
 	beq	$8, $9, closure_done
+
+	li      $9, FFI_TYPE_COMPLEX
+	bne     $8, $9, 1f
+
+	li      $9, 8
+	l.s	$f0, V0_OFF2($fp)
+	l.s	$f2, V1_OFF2($fp)
+	beq     $3, $9, closure_done
+
+	li      $9, 16
+	l.d	$f0, V0_OFF2($fp)
+	l.d	$f2, (V0_OFF2+8)($fp)
+	beq     $3, $9, closure_done
 #endif
 1:	
 	REG_L	$3, V1_OFF2($fp)

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

@@ -1,7 +1,7 @@
 /* -----------------------------------------------------------------------
-   ffi.c - Copyright (C) 2012, 2013, 2018  Anthony Green
-   
-   Moxie Foreign Function Interface 
+   ffi.c - Copyright (C) 2012, 2013, 2018, 2021, 2022  Anthony Green
+
+   Moxie Foreign Function Interface
 
    Permission is hereby granted, free of charge, to any person obtaining
    a copy of this software and associated documentation files (the
@@ -54,14 +54,14 @@ void *ffi_prep_args(char *stack, extended_cif *ecif)
        i--, p_arg++)
     {
       size_t z;
-      
+
       z = (*p_arg)->size;
 
       if ((*p_arg)->type == FFI_TYPE_STRUCT)
 	{
 	  z = sizeof(void*);
 	  *(void **) argp = *p_argv;
-	} 
+	}
       else if (z < sizeof(int))
 	{
 	  z = sizeof(int);
@@ -70,19 +70,19 @@ void *ffi_prep_args(char *stack, extended_cif *ecif)
 	    case FFI_TYPE_SINT8:
 	      *(signed int *) argp = (signed int)*(SINT8 *)(* p_argv);
 	      break;
-	      
+
 	    case FFI_TYPE_UINT8:
 	      *(unsigned int *) argp = (unsigned int)*(UINT8 *)(* p_argv);
 	      break;
-	      
+
 	    case FFI_TYPE_SINT16:
 	      *(signed int *) argp = (signed int)*(SINT16 *)(* p_argv);
 	      break;
-		  
+
 	    case FFI_TYPE_UINT16:
 	      *(unsigned int *) argp = (unsigned int)*(UINT16 *)(* p_argv);
 	      break;
-		  
+
 	    default:
 	      FFI_ASSERT(0);
 	    }
@@ -100,7 +100,7 @@ void *ffi_prep_args(char *stack, extended_cif *ecif)
       count += z;
     }
 
-  return (stack + ((count > 24) ? 24 : ALIGN_DOWN(count, 8)));
+  return (stack + ((count > 24) ? 24 : FFI_ALIGN_DOWN(count, 8)));
 }
 
 /* Perform machine dependent cif processing */
@@ -116,26 +116,28 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
   return FFI_OK;
 }
 
-extern void ffi_call_EABI(void *(*)(char *, extended_cif *), 
-			  extended_cif *, 
-			  unsigned, unsigned, 
-			  unsigned *, 
+extern void ffi_call_EABI(void *(*)(char *, extended_cif *),
+			  extended_cif *,
+			  unsigned, unsigned,
+			  unsigned *,
 			  void (*fn)(void));
 
-void ffi_call(ffi_cif *cif, 
-	      void (*fn)(void), 
-	      void *rvalue, 
+void ffi_call(ffi_cif *cif,
+	      void (*fn)(void),
+	      void *rvalue,
 	      void **avalue)
 {
   extended_cif ecif;
+  ffi_type **arg_types = cif->arg_types;
+  int i, nargs = cif->nargs;
 
   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) && 
+  if ((rvalue == NULL) &&
       (cif->rtype->type == FFI_TYPE_STRUCT))
     {
       ecif.rvalue = alloca(cif->rtype->size);
@@ -143,10 +145,24 @@ void ffi_call(ffi_cif *cif,
   else
     ecif.rvalue = rvalue;
 
-  switch (cif->abi) 
+  /* If we have any large structure arguments, make a copy so we are passing
+     by value.  */
+  for (i = 0; i < nargs; i++)
+    {
+      ffi_type *at = arg_types[i];
+      int size = at->size;
+      if (at->type == FFI_TYPE_STRUCT) /*  && size > 4) All struct args?? */
+        {
+          char *argcopy = alloca (size);
+          memcpy (argcopy, avalue[i], size);
+          avalue[i] = argcopy;
+        }
+    }
+
+  switch (cif->abi)
     {
     case FFI_EABI:
-      ffi_call_EABI(ffi_prep_args, &ecif, cif->bytes, 
+      ffi_call_EABI(ffi_prep_args, &ecif, cif->bytes,
 		    cif->flags, ecif.rvalue, fn);
       break;
     default:
@@ -172,7 +188,7 @@ void ffi_closure_eabi (unsigned arg1, unsigned arg2, unsigned arg3,
   void *struct_rvalue = (void *) arg1;
 
   /* 6 words reserved for register args + 3 words from jsr */
-  char *stack_args = frame_pointer + 9*4; 
+  char *stack_args = frame_pointer + 9*4;
 
   /* Lay the register arguments down in a continuous chunk of memory.  */
   unsigned register_args[6] =
@@ -211,7 +227,16 @@ void ffi_closure_eabi (unsigned arg1, unsigned arg2, unsigned arg3,
 	  avalue[i] = ptr;
 	  break;
 	case FFI_TYPE_STRUCT:
-	  avalue[i] = *(void**)ptr;
+          {
+            if (arg_types[i]->size > 4)
+              {
+                void *copy = alloca(arg_types[i]->size);
+                memcpy(copy, *(void**)ptr, arg_types[i]->size);
+                avalue[i] = copy;
+              }
+            else
+              avalue[i] = *(void**)ptr;
+          }
 	  break;
 	default:
 	  /* This is an 8-byte value.  */