Patchwork [libffi,Darwin,PPC64] PR29152 (Darwin64 implementation), PR42387 (ppc va faults).

login
register
mail settings
Submitter IainS
Date Dec. 9, 2010, 8:26 p.m.
Message ID <246BFCEA-99CF-4968-B7EB-71A24BCEC799@sandoe-acoustics.co.uk>
Download mbox | patch
Permalink /patch/74987/
State New
Headers show

Comments

IainS - Dec. 9, 2010, 8:26 p.m.
Hi,

Here is an update to the Darwin port of libffi that covers Darwin64.

Along the way, I also fixed the long double va args problems for  
Darwin32.

There is one failing test remaining on Darwin32  This is not a new  
fail, but I have not been able to fix it in this iteration (see ***).
(needs separate consideration as to whether it's a real fail or the  
test-case is making an invalid assumption).

With this patch + already approved patches, Darwin64 passes all the  
libffi suite and thus libJava is also functional.

OK to apply?
Iain

===
P.S.  1/
Just to make it clear, this patch has no relationship whatsoever with  
the pyobjc one.
===
P.S. 2/
***
nested-struct5.c (still) fails for the 32 bit implementation.  This is  
because the testcase casts void * pointers to structure pointers --  
the compiler thence assumes that those structure pointers are  
appropriately aligned - and uses vector instructions.   However, there  
is no guarantee that the stacked version of the structs will be  
appropriately aligned.  So, either the testcase is wrong code - or the  
process for passing structures in the closure needs to be refined  
(significant re-write, since the structs are currently passed in-place).
Anyway, IMO we should either XFAIL this - or declare that the structs  
should be mem-moved from the (void *) source.

===

libffi:

	*src/powerpc/darwin_closure.S: Provide Darwin64 implementation,  
update comments.
	* src/powerpc/ffitarget.h (POWERPC_DARWIN64): New,
	(FFI_TRAMPOLINE_SIZE): Update for Darwin64.
	* src/powerpc/darwin.S: Provide Darwin64 implementation, update  
comments.
	* src/powerpc/ffi_darwin.c: Provide Darwin64 implementation, update  
comments.
Mike Stump - Dec. 9, 2010, 9:09 p.m.
On Dec 9, 2010, at 12:26 PM, IainS wrote:
> Here is an update to the Darwin port of libffi that covers Darwin64.

I'll plead ignorance on who exactly should review this patch, that said, I think it is a nice step forward and I'll go out on a limb and say...

> OK to apply?

Ok...  That said, please watch out for additional reviews from the ffi side.
IainS - Dec. 18, 2010, 8:59 a.m.
On 9 Dec 2010, at 21:09, Mike Stump wrote:

> On Dec 9, 2010, at 12:26 PM, IainS wrote:
>> Here is an update to the Darwin port of libffi that covers Darwin64.
>
> I'll plead ignorance on who exactly should review this patch, that  
> said, I think it is a nice step forward and I'll go out on a limb  
> and say...
>
>> OK to apply?
>
> Ok...  That said, please watch out for additional reviews from the  
> ffi side.

given:
(a) no additional review in > 1 week
(b) no libffi maintainer listed in MAINTAINERS
(c) Darwin-specific changes...

committed as r168016.

I am still hopeful of review/comments on nestedstruct5.c from  
Anthony ...  when time permits.

thanks,
Iain

Patch

Index: libffi/src/powerpc/darwin_closure.S
===================================================================
--- libffi/src/powerpc/darwin_closure.S	(revision 167645)
+++ libffi/src/powerpc/darwin_closure.S	(working copy)
@@ -1,6 +1,7 @@ 
 /* -----------------------------------------------------------------------
-   darwin_closure.S - Copyright (c) 2002, 2003, 2004, Free Software Foundation,
-   Inc. based on ppc_closure.S
+   darwin_closure.S - Copyright (c) 2002, 2003, 2004, 2010, 
+   Free Software Foundation, Inc. 
+   based on ppc_closure.S
 
    PowerPC Assembly glue.
 
@@ -33,91 +34,177 @@ 
 #define MODE_CHOICE(x, y) x
 #endif
 
-#define lgu     MODE_CHOICE(lwzu, ldu)
+#define machine_choice	MODE_CHOICE(ppc7400,ppc64)
 
-#define g_long  MODE_CHOICE(long, quad)         /* usage is ".g_long" */
+; Define some pseudo-opcodes for size-independent load & store of GPRs ...
+#define lgu		MODE_CHOICE(lwzu, ldu)
+#define lg		MODE_CHOICE(lwz,ld)
+#define sg		MODE_CHOICE(stw,std)
+#define sgu		MODE_CHOICE(stwu,stdu)
 
-#define LOG2_GPR_BYTES  MODE_CHOICE(2,3)        /* log2(GPR_BYTES) */
+; ... and the size of GPRs and their storage indicator.
+#define GPR_BYTES	MODE_CHOICE(4,8)
+#define LOG2_GPR_BYTES	MODE_CHOICE(2,3)	/* log2(GPR_BYTES) */
+#define g_long		MODE_CHOICE(long, quad)	/* usage is ".g_long" */
 
+; From the ABI doc: "Mac OS X ABI Function Call Guide" Version 2009-02-04.
+#define LINKAGE_SIZE	MODE_CHOICE(24,48)
+#define PARAM_AREA	MODE_CHOICE(32,64)
+
+#define SAVED_CR_OFFSET	MODE_CHOICE(4,8)	/* save position for CR */
+#define SAVED_LR_OFFSET	MODE_CHOICE(8,16)	/* save position for lr */
+
+/* WARNING: if ffi_type is changed... here be monsters.  
+   Offsets of items within the result type.  */
+#define FFI_TYPE_TYPE	MODE_CHOICE(6,10)
+#define FFI_TYPE_ELEM	MODE_CHOICE(8,16)
+
+#define SAVED_FPR_COUNT 13
+#define FPR_SIZE	8
+/* biggest m64 struct ret is 8GPRS + 13FPRS = 168 bytes - rounded to 16bytes = 176. */
+#define RESULT_BYTES	MODE_CHOICE(16,176)
+
+; The whole stack frame **MUST** be 16byte-aligned.
+#define SAVE_SIZE (((LINKAGE_SIZE+PARAM_AREA+SAVED_FPR_COUNT*FPR_SIZE+RESULT_BYTES)+15) & -16LL)
+#define PAD_SIZE (SAVE_SIZE-(LINKAGE_SIZE+PARAM_AREA+SAVED_FPR_COUNT*FPR_SIZE+RESULT_BYTES))
+
+#define PARENT_PARM_BASE (SAVE_SIZE+LINKAGE_SIZE)
+#define FP_SAVE_BASE (LINKAGE_SIZE+PARAM_AREA)
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
+; We no longer need the pic symbol stub for Darwin >= 9.
+#define BLCLS_HELP _ffi_closure_helper_DARWIN
+#define STRUCT_RETVALUE_P _darwin64_struct_ret_by_value_p
+#define PASS_STR_FLOATS _darwin64_pass_struct_floats
+#undef WANT_STUB
+#else
+#define BLCLS_HELP L_ffi_closure_helper_DARWIN$stub
+#define STRUCT_RETVALUE_P L_darwin64_struct_ret_by_value_p$stub
+#define PASS_STR_FLOATS L_darwin64_pass_struct_floats$stub
+#define WANT_STUB
+#endif
+
+/* m32/m64
+
+   The stack layout looks like this:
+
+   |   Additional params...			| |     Higher address
+   ~						~ ~
+   |   Parameters      (at least 8*4/8=32/64)	| | NUM_GPR_ARG_REGISTERS
+   |--------------------------------------------| |
+   |   TOC=R2 (AIX) Reserved (Darwin)   4/8	| |
+   |--------------------------------------------| |
+   |   Reserved                       2*4/8	| |
+   |--------------------------------------------| |
+   |   Space for callee`s LR		4/8	| |
+   |--------------------------------------------| |
+   |   Saved CR [low word for m64]      4/8	| |
+   |--------------------------------------------| |
+   |   Current backchain pointer	4/8	|-/ Parent`s frame.
+   |--------------------------------------------| <+ <<< on entry to
+   |   Result Bytes		       16/176	| |
+   |--------------------------------------------| |
+   ~   padding to 16-byte alignment		~ ~
+   |--------------------------------------------| |
+   |   NUM_FPR_ARG_REGISTERS slots		| |
+   |   here fp13 .. fp1		       13*8	| |
+   |--------------------------------------------| |
+   |   R3..R10			  8*4/8=32/64	| | NUM_GPR_ARG_REGISTERS
+   |--------------------------------------------| |
+   |   TOC=R2 (AIX) Reserved (Darwin)   4/8	| |
+   |--------------------------------------------| |	stack	|
+   |   Reserved [compiler,binder]     2*4/8	| |	grows	|
+   |--------------------------------------------| |	down	V
+   |   Space for callees LR		4/8	| |
+   |--------------------------------------------| |	lower addresses
+   |   Saved CR [low word for m64]      4/8	| |
+   |--------------------------------------------| |     stack pointer here
+   |   Current backchain pointer	4/8	|-/	during
+   |--------------------------------------------|   <<<	call.
+
+*/
+
 	.file	"darwin_closure.S"
-.text
-	.align LOG2_GPR_BYTES
-.globl _ffi_closure_ASM
 
-.text
+	.machine machine_choice
+
+	.text
+	.globl _ffi_closure_ASM
 	.align LOG2_GPR_BYTES
 _ffi_closure_ASM:
 LFB1:
-	mflr	r0		/* extract return address  */
-	stw	r0,8(r1)	/* save the return address  */
+Lstartcode:
+	mflr	r0			/* extract return address  */
+	sg	r0,SAVED_LR_OFFSET(r1)	/* save the return address  */
 LCFI0:
-	/* 24 Bytes (Linkage Area)
-	   32 Bytes (outgoing parameter area, always reserved)
-	   104 Bytes (13*8 from FPR)
-	   16 Bytes (result)
-	   176 Bytes  */
-
-	stwu	r1,-176(r1)	/* skip over caller save area
-				keep stack aligned to 16.  */
+	sgu	r1,-SAVE_SIZE(r1)	/* skip over caller save area
+					keep stack aligned to 16.  */
 LCFI1:
 	/* We want to build up an area for the parameters passed
 	   in registers. (both floating point and integer)  */
 
-	/* We store gpr 3 to gpr 10 (aligned to 4)
-	   in the parents outgoing area.  */
-	stw   r3,200(r1)
-	stw   r4,204(r1)
-	stw   r5,208(r1)
-	stw   r6,212(r1)
-	stw   r7,216(r1)
-	stw   r8,220(r1)
-	stw   r9,224(r1)
-	stw   r10,228(r1)
+	/* Put gpr 3 to gpr 10 in the parents outgoing area...
+	   ... the remainder of any params that overflowed the regs will
+	   follow here.  */
+	sg	r3, (PARENT_PARM_BASE                )(r1)
+	sg	r4, (PARENT_PARM_BASE + GPR_BYTES    )(r1)
+	sg	r5, (PARENT_PARM_BASE + GPR_BYTES * 2)(r1)
+	sg	r6, (PARENT_PARM_BASE + GPR_BYTES * 3)(r1)
+	sg	r7, (PARENT_PARM_BASE + GPR_BYTES * 4)(r1)
+	sg	r8, (PARENT_PARM_BASE + GPR_BYTES * 5)(r1)
+	sg	r9, (PARENT_PARM_BASE + GPR_BYTES * 6)(r1)
+	sg	r10,(PARENT_PARM_BASE + GPR_BYTES * 7)(r1)
 
-	/* We save fpr 1 to fpr 13. (aligned to 8)  */
-	stfd  f1,56(r1)
-	stfd  f2,64(r1)
-	stfd  f3,72(r1)
-	stfd  f4,80(r1)
-	stfd  f5,88(r1)
-	stfd  f6,96(r1)
-	stfd  f7,104(r1)
-	stfd  f8,112(r1)
-	stfd  f9,120(r1)
-	stfd  f10,128(r1)
-	stfd  f11,136(r1)
-	stfd  f12,144(r1)
-	stfd  f13,152(r1)
+	/* We save fpr 1 to fpr 14 in our own save frame.  */
+	stfd	f1, (FP_SAVE_BASE                 )(r1)
+	stfd	f2, (FP_SAVE_BASE +  FPR_SIZE     )(r1)
+	stfd	f3, (FP_SAVE_BASE +  FPR_SIZE * 2 )(r1)
+	stfd	f4, (FP_SAVE_BASE +  FPR_SIZE * 3 )(r1)
+	stfd	f5, (FP_SAVE_BASE +  FPR_SIZE * 4 )(r1)
+	stfd	f6, (FP_SAVE_BASE +  FPR_SIZE * 5 )(r1)
+	stfd	f7, (FP_SAVE_BASE +  FPR_SIZE * 6 )(r1)
+	stfd	f8, (FP_SAVE_BASE +  FPR_SIZE * 7 )(r1)
+	stfd	f9, (FP_SAVE_BASE +  FPR_SIZE * 8 )(r1)
+	stfd	f10,(FP_SAVE_BASE +  FPR_SIZE * 9 )(r1)
+	stfd	f11,(FP_SAVE_BASE +  FPR_SIZE * 10)(r1)
+	stfd	f12,(FP_SAVE_BASE +  FPR_SIZE * 11)(r1)
+	stfd	f13,(FP_SAVE_BASE +  FPR_SIZE * 12)(r1)
 
 	/* Set up registers for the routine that actually does the work
 	   get the context pointer from the trampoline.  */
-	mr r3,r11
+	mr	r3,r11
 
 	/* Now load up the pointer to the result storage.  */
-	addi r4,r1,160
+	addi	r4,r1,(SAVE_SIZE-RESULT_BYTES)
 
 	/* Now load up the pointer to the saved gpr registers.  */
-	addi r5,r1,200
+	addi	r5,r1,PARENT_PARM_BASE
 
 	/* Now load up the pointer to the saved fpr registers.  */
-	addi r6,r1,56
+	addi	r6,r1,FP_SAVE_BASE
 
 	/* Make the call.  */
-	bl	Lffi_closure_helper_DARWIN$stub
+	bl	BLCLS_HELP
 
-	/* Now r3 contains the return type
-	   so use it to look up in a table
+	/* r3 contains the rtype pointer... save it since we will need
+	   it later.  */
+	sg	r3,LINKAGE_SIZE(r1)	; ffi_type * result_type
+	lg	r0,0(r3)		; size => r0
+	lhz	r3,FFI_TYPE_TYPE(r3)	; type => r3
+
+	/* The helper will have intercepted struture returns and inserted
+	   the caller`s destination address for structs returned by ref.  */
+
+	/* r3 contains the return type  so use it to look up in a table
 	   so we know how to deal with each type.  */
 
-	/* Look up the proper starting point in table
-	   by using return type as offset.  */
-	addi  r5,r1,160		  /* Get pointer to results area.  */
-	bl    Lget_ret_type0_addr /* Get pointer to Lret_type0 into LR.  */
-	mflr  r4		  /* Move to r4.  */
-	slwi  r3,r3,4		  /* Now multiply return type by 16.  */
-	add   r3,r3,r4		  /* Add contents of table to table address.  */
-	mtctr r3
-	bctr			  /* Jump to it.  */
+	addi	r5,r1,(SAVE_SIZE-RESULT_BYTES) /* Otherwise, our return is here.  */
+	bl	Lget_ret_type0_addr	/* Get pointer to Lret_type0 into LR.  */
+	mflr	r4			/* Move to r4.  */
+	slwi	r3,r3,4			/* Now multiply return type by 16.  */
+	add	r3,r3,r4		/* Add contents of table to table address.  */
+	mtctr	r3
+	bctr			 	 /* Jump to it.  */
 LFE1:
 /* Each of the ret_typeX code fragments has to be exactly 16 bytes long
    (4 instructions). For cache effectiveness we align to a 16 byte boundary
@@ -140,7 +227,7 @@  Lret_type0:
 
 /* case FFI_TYPE_INT  */
 Lret_type1:
-	lwz	r3,0(r5)
+	lg	r3,0(r5)
 	b	Lfinish
 	nop
 	nop
@@ -168,85 +255,224 @@  Lret_type4:
 
 /* case FFI_TYPE_UINT8  */
 Lret_type5:
+#if defined(__ppc64__)
+	lbz	r3,7(r5)
+#else
 	lbz	r3,3(r5)
+#endif
 	b	Lfinish
 	nop
 	nop
 
 /* case FFI_TYPE_SINT8  */
 Lret_type6:
+#if defined(__ppc64__)
+	lbz	r3,7(r5)
+#else
 	lbz	r3,3(r5)
+#endif
 	extsb	r3,r3
 	b	Lfinish
 	nop
 
 /* case FFI_TYPE_UINT16  */
 Lret_type7:
+#if defined(__ppc64__)
+	lhz	r3,6(r5)
+#else
 	lhz	r3,2(r5)
+#endif
 	b	Lfinish
 	nop
 	nop
 
 /* case FFI_TYPE_SINT16  */
 Lret_type8:
+#if defined(__ppc64__)
+	lha	r3,6(r5)
+#else
 	lha	r3,2(r5)
+#endif
 	b	Lfinish
 	nop
 	nop
 
 /* case FFI_TYPE_UINT32  */
 Lret_type9:
+#if defined(__ppc64__)
+	lwz	r3,4(r5)
+#else
 	lwz	r3,0(r5)
+#endif
 	b	Lfinish
 	nop
 	nop
 
 /* case FFI_TYPE_SINT32  */
 Lret_type10:
+#if defined(__ppc64__)
+	lwz	r3,4(r5)
+#else
 	lwz	r3,0(r5)
+#endif
 	b	Lfinish
 	nop
 	nop
 
 /* case FFI_TYPE_UINT64  */
 Lret_type11:
+#if defined(__ppc64__)
+	lg	r3,0(r5)
+	b	Lfinish
+	nop
+#else
 	lwz	r3,0(r5)
 	lwz	r4,4(r5)
 	b	Lfinish
+#endif
 	nop
 
 /* case FFI_TYPE_SINT64  */
 Lret_type12:
+#if defined(__ppc64__)
+	lg	r3,0(r5)
+	b	Lfinish
+	nop
+#else
 	lwz	r3,0(r5)
 	lwz	r4,4(r5)
 	b	Lfinish
+#endif
 	nop
 
 /* case FFI_TYPE_STRUCT  */
 Lret_type13:
+#if defined(__ppc64__)
+	lg	r3,0(r5)		; we need at least this...
+	cmpi	0,r0,4
+	bgt	Lstructend		; not a special small case
+	b	Lsmallstruct		; see if we need more.
+#else
+	cmpi	0,r0,4
+	bgt	Lfinish		; not by value
+	lg	r3,0(r5)
 	b	Lfinish
-	nop
-	nop
-	nop
-
+#endif
 /* case FFI_TYPE_POINTER  */
 Lret_type14:
-	lwz	r3,0(r5)
+	lg	r3,0(r5)
 	b	Lfinish
 	nop
 	nop
 
+#if defined(__ppc64__)
+Lsmallstruct:
+	beq	Lfour			; continuation of Lret13.
+	cmpi	0,r0,3
+	beq	Lfinish			; don`t adjust this - can`t be any floats here...
+	srdi	r3,r3,48
+	cmpi	0,r0,2
+	beq	Lfinish			; .. or here ..
+	srdi	r3,r3,8
+	b 	Lfinish			; .. or here.
+
+Lfour:
+	lg	r6,LINKAGE_SIZE(r1)	; get the result type
+	lg	r6,FFI_TYPE_ELEM(r6)	; elements array pointer
+	lg	r6,0(r6)		; first element
+	lhz	r0,FFI_TYPE_TYPE(r6)	; OK go the type
+	cmpi	0,r0,2			; FFI_TYPE_FLOAT
+	bne	Lfourint
+	lfs	f1,0(r5)		; just one float in the struct.
+	b 	Lfinish
+
+Lfourint:
+	srdi	r3,r3,32		; four bytes.
+	b 	Lfinish
+
+Lstructend:
+	lg	r3,LINKAGE_SIZE(r1)	; get the result type
+	bl	STRUCT_RETVALUE_P
+	cmpi	0,r3,0
+	beq	Lfinish			; nope.
+	/* Recover a pointer to the results.  */
+	addi	r11,r1,(SAVE_SIZE-RESULT_BYTES)
+	lg	r3,0(r11)		; we need at least this...
+	lg	r4,8(r11)
+	cmpi	0,r0,16
+	beq	Lfinish		; special case 16 bytes we don't consider floats.
+
+	/* OK, frustratingly, the process of saving the struct to mem might have
+	   messed with the FPRs, so we have to re-load them :(.
+	   We`ll use our FPRs space again - calling: 
+	   void darwin64_pass_struct_floats (ffi_type *s, char *src, 
+					     unsigned *nfpr, double **fprs) 
+	   We`ll temporarily pinch the first two slots of the param area for local
+	   vars used by the routine.  */
+	xor	r6,r6,r6
+	addi	r5,r1,PARENT_PARM_BASE		; some space
+	sg	r6,0(r5)			; *nfpr zeroed.
+	addi	r6,r5,8				; **fprs
+	addi	r3,r1,FP_SAVE_BASE		; pointer to FPRs space
+	sg	r3,0(r6)
+	mr	r4,r11				; the struct is here...
+	lg	r3,LINKAGE_SIZE(r1)		; ffi_type * result_type.
+	bl	PASS_STR_FLOATS			; get struct floats into FPR save space.
+	/* See if we used any floats  */
+	lwz	r0,(SAVE_SIZE-RESULT_BYTES)(r1)	
+	cmpi	0,r0,0
+	beq	Lstructints			; nope.
+	/* OK load `em up... */
+	lfd	f1, (FP_SAVE_BASE                 )(r1)
+	lfd	f2, (FP_SAVE_BASE +  FPR_SIZE     )(r1)
+	lfd	f3, (FP_SAVE_BASE +  FPR_SIZE * 2 )(r1)
+	lfd	f4, (FP_SAVE_BASE +  FPR_SIZE * 3 )(r1)
+	lfd	f5, (FP_SAVE_BASE +  FPR_SIZE * 4 )(r1)
+	lfd	f6, (FP_SAVE_BASE +  FPR_SIZE * 5 )(r1)
+	lfd	f7, (FP_SAVE_BASE +  FPR_SIZE * 6 )(r1)
+	lfd	f8, (FP_SAVE_BASE +  FPR_SIZE * 7 )(r1)
+	lfd	f9, (FP_SAVE_BASE +  FPR_SIZE * 8 )(r1)
+	lfd	f10,(FP_SAVE_BASE +  FPR_SIZE * 9 )(r1)
+	lfd	f11,(FP_SAVE_BASE +  FPR_SIZE * 10)(r1)
+	lfd	f12,(FP_SAVE_BASE +  FPR_SIZE * 11)(r1)
+	lfd	f13,(FP_SAVE_BASE +  FPR_SIZE * 12)(r1)
+
+	/* point back at our saved struct.  */
+Lstructints:
+	addi	r11,r1,(SAVE_SIZE-RESULT_BYTES)
+	lg	r3,0(r11)			; we end up picking the
+	lg	r4,8(r11)			; first two again.
+	lg	r5,16(r11)
+	lg	r6,24(r11)
+	lg	r7,32(r11)
+	lg	r8,40(r11)
+	lg	r9,48(r11)
+	lg	r10,56(r11)
+#endif
+
 /* case done  */
 Lfinish:
-	addi	r1,r1,176	/* Restore stack pointer.  */
-	lwz	r0,8(r1)	/* Get return address.  */
-	mtlr	r0		/* Reset link register.  */
+	addi	r1,r1,SAVE_SIZE		/* Restore stack pointer.  */
+	lg	r0,SAVED_LR_OFFSET(r1)	/* Get return address.  */
+	mtlr	r0			/* Reset link register.  */
 	blr
-
+Lendcode:
+	.align 1
+	
 /* END(ffi_closure_ASM)  */
 
-.data
-.section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
+/* EH frame stuff.  */
+#define EH_DATA_ALIGN_FACT MODE_CHOICE(0x7c,0x78)
+/* 176, 400 */
+#define EH_FRAME_OFFSETA MODE_CHOICE(176,0x90)
+#define EH_FRAME_OFFSETB MODE_CHOICE(1,3)
+
+	.static_data
+	.align LOG2_GPR_BYTES
+LLFB1$non_lazy_ptr:
+	.g_long Lstartcode
+
+	.section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
 EH_frame1:
 	.set	L$set$0,LECIE1-LSCIE1
 	.long	L$set$0	; Length of Common Information Entry
@@ -255,7 +481,7 @@  LSCIE1:
 	.byte	0x1	; CIE Version
 	.ascii	"zR\0"	; CIE Augmentation
 	.byte	0x1	; uleb128 0x1; CIE Code Alignment Factor
-	.byte	0x7c	; sleb128 -4; CIE Data Alignment Factor
+	.byte	EH_DATA_ALIGN_FACT ; sleb128 -4; CIE Data Alignment Factor
 	.byte	0x41	; CIE RA Column
 	.byte	0x1	; uleb128 0x1; Augmentation size
 	.byte	0x90	; FDE Encoding (indirect pcrel)
@@ -264,7 +490,7 @@  LSCIE1:
 	.byte	0x0	; uleb128 0x0
 	.align	LOG2_GPR_BYTES
 LECIE1:
-.globl _ffi_closure_ASM.eh
+	.globl _ffi_closure_ASM.eh
 _ffi_closure_ASM.eh:
 LSFDE1:
 	.set	L$set$1,LEFDE1-LASFDE1
@@ -273,45 +499,77 @@  LSFDE1:
 LASFDE1:
 	.long	LASFDE1-EH_frame1	; FDE CIE offset
 	.g_long	LLFB1$non_lazy_ptr-.	; FDE initial location
-	.set	L$set$3,LFE1-LFB1
+	.set	L$set$3,LFE1-Lstartcode
 	.g_long	L$set$3	; FDE address range
 	.byte   0x0     ; uleb128 0x0; Augmentation size
 	.byte	0x4	; DW_CFA_advance_loc4
 	.set	L$set$3,LCFI1-LCFI0
 	.long	L$set$3
 	.byte	0xe	; DW_CFA_def_cfa_offset
-	.byte	176,1	; uleb128 176
+	.byte	EH_FRAME_OFFSETA,EH_FRAME_OFFSETB	; uleb128 176,1/190,3
 	.byte	0x4	; DW_CFA_advance_loc4
-	.set	L$set$4,LCFI0-LFB1
+	.set	L$set$4,LCFI0-Lstartcode
 	.long	L$set$4
 	.byte   0x11    ; DW_CFA_offset_extended_sf
 	.byte	0x41	; uleb128 0x41
 	.byte   0x7e    ; sleb128 -2
 	.align	LOG2_GPR_BYTES
 LEFDE1:
-.data
-	.align	LOG2_GPR_BYTES
-LDFCM0:
-.section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
-	.align	LOG2_GPR_BYTES
-Lffi_closure_helper_DARWIN$stub:
-#if 1
+	.align 	1
+
+#ifdef WANT_STUB
+	.section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
+	.align 5
+L_ffi_closure_helper_DARWIN$stub:
 	.indirect_symbol _ffi_closure_helper_DARWIN
-	mflr	r0
-	bcl	20,31,LO$ffi_closure_helper_DARWIN
-LO$ffi_closure_helper_DARWIN:
-	mflr	r11
-	addis	r11,r11,ha16(L_ffi_closure_helper_DARWIN$lazy_ptr - LO$ffi_closure_helper_DARWIN)
-	mtlr	r0
-	lgu	r12,lo16(L_ffi_closure_helper_DARWIN$lazy_ptr - LO$ffi_closure_helper_DARWIN)(r11)
-	mtctr	r12
+	mflr r0
+	bcl 20,31,"L00000000001$spb"
+"L00000000001$spb":
+	mflr r11
+	addis r11,r11,ha16(L_ffi_closure_helper_DARWIN$lazy_ptr-"L00000000001$spb")
+	mtlr r0
+	lwzu r12,lo16(L_ffi_closure_helper_DARWIN$lazy_ptr-"L00000000001$spb")(r11)
+	mtctr r12
 	bctr
-.lazy_symbol_pointer
+	.lazy_symbol_pointer
 L_ffi_closure_helper_DARWIN$lazy_ptr:
 	.indirect_symbol _ffi_closure_helper_DARWIN
-	.g_long dyld_stub_binding_helper
+	.long	dyld_stub_binding_helper
+
+#if defined(__ppc64__)
+	.section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
+	.align 5
+L_darwin64_struct_ret_by_value_p$stub:
+	.indirect_symbol _darwin64_struct_ret_by_value_p
+	mflr r0
+	bcl 20,31,"L00000000002$spb"
+"L00000000002$spb":
+	mflr r11
+	addis r11,r11,ha16(L_darwin64_struct_ret_by_value_p$lazy_ptr-"L00000000002$spb")
+	mtlr r0
+	lwzu r12,lo16(L_darwin64_struct_ret_by_value_p$lazy_ptr-"L00000000002$spb")(r11)
+	mtctr r12
+	bctr
+	.lazy_symbol_pointer
+L_darwin64_struct_ret_by_value_p$lazy_ptr:
+	.indirect_symbol _darwin64_struct_ret_by_value_p
+	.long	dyld_stub_binding_helper
+	.section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32
+	.align 5
+L_darwin64_pass_struct_floats$stub:
+	.indirect_symbol _darwin64_pass_struct_floats
+	mflr r0
+	bcl 20,31,"L00000000003$spb"
+"L00000000003$spb":
+	mflr r11
+	addis r11,r11,ha16(L_darwin64_pass_struct_floats$lazy_ptr-"L00000000003$spb")
+	mtlr r0
+	lwzu r12,lo16(L_darwin64_pass_struct_floats$lazy_ptr-"L00000000003$spb")(r11)
+	mtctr r12
+	bctr
+	.lazy_symbol_pointer
+L_darwin64_pass_struct_floats$lazy_ptr:
+	.indirect_symbol _darwin64_pass_struct_floats
+	.long	dyld_stub_binding_helper
+#  endif
 #endif
-.data
-	.align LOG2_GPR_BYTES
-LLFB1$non_lazy_ptr:
-	.g_long LFB1
Index: libffi/src/powerpc/ffitarget.h
===================================================================
--- libffi/src/powerpc/ffitarget.h	(revision 167645)
+++ libffi/src/powerpc/ffitarget.h	(working copy)
@@ -1,6 +1,6 @@ 
 /* -----------------------------------------------------------------*-C-*-
    ffitarget.h - Copyright (c) 1996-2003  Red Hat, Inc.
-   Copyright (C) 2007, 2008 Free Software Foundation, Inc
+   Copyright (C) 2007, 2008, 2010 Free Software Foundation, Inc
    Target configuration macros for PowerPC.
 
    Permission is hereby granted, free of charge, to any person obtaining
@@ -34,10 +34,13 @@ 
 #ifndef POWERPC64
 #define POWERPC64
 #endif
-#elif defined (POWERPC_DARWIN) && defined (__ppc64__)	/* Darwin */
+#elif defined (POWERPC_DARWIN) && defined (__ppc64__)	/* Darwin64 */
 #ifndef POWERPC64
 #define POWERPC64
 #endif
+#ifndef POWERPC_DARWIN64
+#define POWERPC_DARWIN64
+#endif
 #elif defined (POWERPC_AIX) && defined (__64BIT__)	/* AIX64 */
 #ifndef POWERPC64
 #define POWERPC64
@@ -114,9 +117,13 @@  typedef enum ffi_abi {
 #define FFI_SYSV_TYPE_SMALL_STRUCT (FFI_TYPE_LAST + 2)
 
 #if defined(POWERPC64) || defined(POWERPC_AIX)
-#define FFI_TRAMPOLINE_SIZE 24
+#  if defined(POWERPC_DARWIN64)
+#    define FFI_TRAMPOLINE_SIZE 48
+#  else
+#    define FFI_TRAMPOLINE_SIZE 24
+#  endif
 #else /* POWERPC || POWERPC_AIX */
-#define FFI_TRAMPOLINE_SIZE 40
+#  define FFI_TRAMPOLINE_SIZE 40
 #endif
 
 #ifndef LIBFFI_ASM
Index: libffi/src/powerpc/darwin.S
===================================================================
--- libffi/src/powerpc/darwin.S	(revision 167645)
+++ libffi/src/powerpc/darwin.S	(working copy)
@@ -1,6 +1,6 @@ 
 /* -----------------------------------------------------------------------
    darwin.S - Copyright (c) 2000 John Hornkvist
-	      Copyright (c) 2004 Free Software Foundation, Inc.
+	      Copyright (c) 2004, 2010 Free Software Foundation, Inc.
 
    PowerPC Assembly glue.
 
@@ -24,51 +24,92 @@ 
    OTHER DEALINGS IN THE SOFTWARE.
    ----------------------------------------------------------------------- */
 
+#define LIBFFI_ASM
 #if defined(__ppc64__)
 #define MODE_CHOICE(x, y) y
 #else
 #define MODE_CHOICE(x, y) x
 #endif
 
-#define g_long  MODE_CHOICE(long, quad)         /* usage is ".g_long" */
+#define machine_choice	MODE_CHOICE(ppc7400,ppc64)
 
-#define LOG2_GPR_BYTES  MODE_CHOICE(2,3)        /* log2(GPR_BYTES) */
+; Define some pseudo-opcodes for size-independent load & store of GPRs ...
+#define lgu		MODE_CHOICE(lwzu, ldu)
+#define lg		MODE_CHOICE(lwz,ld)
+#define sg		MODE_CHOICE(stw,std)
+#define sgu		MODE_CHOICE(stwu,stdu)
+#define sgux		MODE_CHOICE(stwux,stdux)
 
-#define LIBFFI_ASM
+; ... and the size of GPRs and their storage indicator.
+#define GPR_BYTES	MODE_CHOICE(4,8)
+#define LOG2_GPR_BYTES	MODE_CHOICE(2,3)	/* log2(GPR_BYTES) */
+#define g_long		MODE_CHOICE(long, quad)	/* usage is ".g_long" */
+
+; From the ABI doc: "Mac OS X ABI Function Call Guide" Version 2009-02-04.
+#define LINKAGE_SIZE	MODE_CHOICE(24,48)
+#define PARAM_AREA	MODE_CHOICE(32,64)
+#define SAVED_LR_OFFSET	MODE_CHOICE(8,16)	/* save position for lr */
+
+/* If there is any FP stuff we make space for all of the regs.  */
+#define SAVED_FPR_COUNT 13
+#define FPR_SIZE	8
+#define RESULT_BYTES	16
+
+/* This should be kept in step with the same value in ffi_darwin.c.  */
+#define ASM_NEEDS_REGISTERS 4
+#define SAVE_REGS_SIZE (ASM_NEEDS_REGISTERS * GPR_BYTES)
+
 #include <fficonfig.h>
 #include <ffi.h>
+
 #define JUMPTARGET(name) name
 #define L(x) x
-.text
+
+	.text
 	.align 2
-.globl _ffi_prep_args
+	.globl _ffi_prep_args
 
-.text
 	.align 2
-.globl _ffi_call_DARWIN
-.text
-	.align 2
+	.globl _ffi_call_DARWIN
+
+	/* We arrive here with:
+	   r3 = ptr to extended cif.
+	   r4 = -bytes.
+	   r5 = cif flags.
+	   r6 = ptr to return value.
+	   r7 = fn pointer (user func).
+	   r8 = fn pointer (ffi_prep_args).
+	   r9 = ffi_type* for the ret val.  */
+
 _ffi_call_DARWIN:
-LFB0:
+Lstartcode:
 	mr   	r12,r8	/* We only need r12 until the call,
-			   so it doesn't have to be saved.  */
+			   so it does not have to be saved.  */
 LFB1:
 	/* Save the old stack pointer as AP.  */
 	mr	r8,r1
 LCFI0:
+	
+	/* Save the retval type in parents frame.  */
+	sg	r9,(LINKAGE_SIZE+6*GPR_BYTES)(r8)
+
 	/* Allocate the stack space we need.  */
-	stwux	r1,r1,r4
+	sgux	r1,r1,r4
 
 	/* Save registers we use.  */
 	mflr	r9
+	sg	r9,SAVED_LR_OFFSET(r8)
 
-	stw	r28,-16(r8)	
-	stw	r29,-12(r8)
-	stw	r30,-8(r8)
-	stw	r31,-4(r8)
+	sg	r28,-(4 * GPR_BYTES)(r8)	
+	sg	r29,-(3 * GPR_BYTES)(r8)
+	sg	r30,-(2 * GPR_BYTES)(r8)
+	sg	r31,-(    GPR_BYTES)(r8)
 
-	stw	r9,8(r8)
-	stw	r2,20(r1)
+#if !defined(POWERPC_DARWIN)
+	/* The TOC slot is reserved in the Darwin ABI and r2 is volatile.  */
+	sg	r2,(5 * GPR_BYTES)(r1)
+#endif
+
 LCFI1:
 
 	/* Save arguments over call.  */
@@ -77,14 +118,17 @@  LCFI1:
 	mr	r29,r7	/* function address,  */
 	mr	r28,r8	/* our AP.  */
 LCFI2:
-	/* Call ffi_prep_args.  */
+	/* Call ffi_prep_args. r3 = extended cif, r4 = stack ptr copy.  */
 	mr	r4,r1
 	li	r9,0
 
 	mtctr	r12 /* r12 holds address of _ffi_prep_args.  */
 	bctrl
-	lwz     r2,20(r1)
 
+#if !defined(POWERPC_DARWIN)
+	/* The TOC slot is reserved in the Darwin ABI and r2 is volatile.  */
+	lg     r2,(5 * GPR_BYTES)(r1)
+#endif
 	/* Now do the call.
 	   Set up cr1 with bits 4-7 of the flags.  */
 	mtcrf	0x40,r31
@@ -92,71 +136,130 @@  LCFI2:
 	mtctr	r29
 	/* Load all those argument registers.
 	   We have set up a nice stack frame, just load it into registers.  */
-	lwz     r3,20+(1*4)(r1)
-	lwz     r4,20+(2*4)(r1)
-	lwz     r5,20+(3*4)(r1)
-	lwz     r6,20+(4*4)(r1)
+	lg     r3, (LINKAGE_SIZE                )(r1)
+	lg     r4, (LINKAGE_SIZE +     GPR_BYTES)(r1)
+	lg     r5, (LINKAGE_SIZE + 2 * GPR_BYTES)(r1)
+	lg     r6, (LINKAGE_SIZE + 3 * GPR_BYTES)(r1)
 	nop
-	lwz     r7,20+(5*4)(r1)
-	lwz     r8,20+(6*4)(r1)
-	lwz     r9,20+(7*4)(r1)
-	lwz     r10,20+(8*4)(r1)
+	lg     r7, (LINKAGE_SIZE + 4 * GPR_BYTES)(r1)
+	lg     r8, (LINKAGE_SIZE + 5 * GPR_BYTES)(r1)
+	lg     r9, (LINKAGE_SIZE + 6 * GPR_BYTES)(r1)
+	lg     r10,(LINKAGE_SIZE + 7 * GPR_BYTES)(r1)
 
 L1:
-	/* Load all the FP registers.  */
+	/* ... Load all the FP registers.  */
 	bf	6,L2	/* No floats to load.  */
-	lfd	f1,-16-(13*8)(r28)
-	lfd	f2,-16-(12*8)(r28)
-	lfd	f3,-16-(11*8)(r28)
-	lfd	f4,-16-(10*8)(r28)
+	lfd	f1, -SAVE_REGS_SIZE-(13*FPR_SIZE)(r28)
+	lfd	f2, -SAVE_REGS_SIZE-(12*FPR_SIZE)(r28)
+	lfd	f3, -SAVE_REGS_SIZE-(11*FPR_SIZE)(r28)
+	lfd	f4, -SAVE_REGS_SIZE-(10*FPR_SIZE)(r28)
 	nop
-	lfd	f5,-16-(9*8)(r28)
-	lfd	f6,-16-(8*8)(r28)
-	lfd	f7,-16-(7*8)(r28)
-	lfd	f8,-16-(6*8)(r28)
+	lfd	f5, -SAVE_REGS_SIZE-( 9*FPR_SIZE)(r28)
+	lfd	f6, -SAVE_REGS_SIZE-( 8*FPR_SIZE)(r28)
+	lfd	f7, -SAVE_REGS_SIZE-( 7*FPR_SIZE)(r28)
+	lfd	f8, -SAVE_REGS_SIZE-( 6*FPR_SIZE)(r28)
 	nop
-	lfd     f9,-16-(5*8)(r28)
-	lfd     f10,-16-(4*8)(r28)
-	lfd     f11,-16-(3*8)(r28)
-	lfd     f12,-16-(2*8)(r28)
+	lfd     f9, -SAVE_REGS_SIZE-( 5*FPR_SIZE)(r28)
+	lfd     f10,-SAVE_REGS_SIZE-( 4*FPR_SIZE)(r28)
+	lfd     f11,-SAVE_REGS_SIZE-( 3*FPR_SIZE)(r28)
+	lfd     f12,-SAVE_REGS_SIZE-( 2*FPR_SIZE)(r28)
 	nop
-	lfd     f13,-16-(1*8)(r28)
+	lfd     f13,-SAVE_REGS_SIZE-( 1*FPR_SIZE)(r28)
 
 L2:
 	mr	r12,r29	/* Put the target address in r12 as specified.  */
 	mtctr  	r12
 	nop
 	nop
+
 	/* Make the call.  */
 	bctrl
 
 	/* Now, deal with the return value.  */
-	mtcrf	0x01,r31
 
-	bt	30,L(done_return_value)
-	bt	29,L(fp_return_value)
-	stw	r3,0(r30)
-	bf	28,L(done_return_value)
-	stw	r4,4(r30)
+	/* m64 structure returns can occupy the same set of registers as
+	   would be used to pass such a structure as arg0 - so take care 
+	   not to step on any possibly hot regs.  */
 
-	/* Fall through.  */
+	/* Get the flags.. */
+	mtcrf	0x03,r31 ; we need c6 & cr7 now.
+	; FLAG_RETURNS_NOTHING also covers struct ret-by-ref.
+	bt	30,L(done_return_value)	  ; FLAG_RETURNS_NOTHING
+	bf	27,L(scalar_return_value) ; not FLAG_RETURNS_STRUCT
+	
+	/* OK, so we have a struct.  */
+#if defined(__ppc64__)
+	bt	31,L(maybe_return_128) ; FLAG_RETURNS_128BITS, special case 
 
-L(done_return_value):
-	/* Restore the registers we used and return.  */
-	lwz	r9,8(r28)
-	lwz	r31,-4(r28)
-	mtlr	r9
-	lwz	r30,-8(r28)
-	lwz	r29,-12(r28)
-	lwz	r28,-16(r28)
-	lwz	r1,0(r1)
-	blr
+	/* OK, we have to map the return back to a mem struct.
+	   We are about to trample the parents param area, so recover the
+	   return type.  r29 is free, since the call is done.  */
+	lg	r29,(LINKAGE_SIZE + 6 * GPR_BYTES)(r28)
 
+	sg	r3, (LINKAGE_SIZE                )(r28)
+	sg	r4, (LINKAGE_SIZE +     GPR_BYTES)(r28)
+	sg	r5, (LINKAGE_SIZE + 2 * GPR_BYTES)(r28)
+	sg	r6, (LINKAGE_SIZE + 3 * GPR_BYTES)(r28)
+	nop
+	sg	r7, (LINKAGE_SIZE + 4 * GPR_BYTES)(r28)
+	sg	r8, (LINKAGE_SIZE + 5 * GPR_BYTES)(r28)
+	sg	r9, (LINKAGE_SIZE + 6 * GPR_BYTES)(r28)
+	sg	r10,(LINKAGE_SIZE + 7 * GPR_BYTES)(r28)
+	/* OK, so do the block move - we trust that memcpy will not trample
+	   the fprs...  */
+	mr 	r3,r30 ; dest
+	addi	r4,r28,LINKAGE_SIZE ; source
+	/* The size is a size_t, should be long.  */
+	lg	r5,0(r29)
+	/* Figure out small structs */
+	cmpi	0,r5,4
+	bgt	L3	; 1, 2 and 4 bytes have special rules.
+	cmpi	0,r5,3
+	beq	L3	; not 3
+	addi	r4,r4,8
+	subf	r4,r5,r4
+L3:
+	bl	_memcpy
+	
+	/* ... do we need the FP registers? - recover the flags.. */
+	mtcrf	0x03,r31 ; we need c6 & cr7 now.
+	bf	29,L(done_return_value)	/* No floats in the struct.  */
+	stfd	f1, -SAVE_REGS_SIZE-(13*FPR_SIZE)(r28)
+	stfd	f2, -SAVE_REGS_SIZE-(12*FPR_SIZE)(r28)
+	stfd	f3, -SAVE_REGS_SIZE-(11*FPR_SIZE)(r28)
+	stfd	f4, -SAVE_REGS_SIZE-(10*FPR_SIZE)(r28)
+	nop
+	stfd	f5, -SAVE_REGS_SIZE-( 9*FPR_SIZE)(r28)
+	stfd	f6, -SAVE_REGS_SIZE-( 8*FPR_SIZE)(r28)
+	stfd	f7, -SAVE_REGS_SIZE-( 7*FPR_SIZE)(r28)
+	stfd	f8, -SAVE_REGS_SIZE-( 6*FPR_SIZE)(r28)
+	nop
+	stfd	f9, -SAVE_REGS_SIZE-( 5*FPR_SIZE)(r28)
+	stfd	f10,-SAVE_REGS_SIZE-( 4*FPR_SIZE)(r28)
+	stfd	f11,-SAVE_REGS_SIZE-( 3*FPR_SIZE)(r28)
+	stfd	f12,-SAVE_REGS_SIZE-( 2*FPR_SIZE)(r28)
+	nop
+	stfd	f13,-SAVE_REGS_SIZE-( 1*FPR_SIZE)(r28)
+
+	mr	r3,r29	; ffi_type *
+	mr	r4,r30	; dest
+	addi	r5,r28,-SAVE_REGS_SIZE-(13*FPR_SIZE) ; fprs
+	xor	r6,r6,r6
+	sg	r6,(LINKAGE_SIZE + 7 * GPR_BYTES)(r28)
+	addi	r6,r28,(LINKAGE_SIZE + 7 * GPR_BYTES) ; point to a zeroed counter.
+	bl 	_darwin64_struct_floats_to_mem
+
+	b L(done_return_value)
+#else
+	stw	r3,0(r30) ; m32 the only struct return in reg is 4 bytes.
+#endif
+	b L(done_return_value)
+
 L(fp_return_value):
 	/* Do we have long double to store?  */
-	bf	31,L(fd_return_value)
+	bf	31,L(fd_return_value) ; FLAG_RETURNS_128BITS
 	stfd	f1,0(r30)
-	stfd	f2,8(r30)
+	stfd	f2,FPR_SIZE(r30)
 	b	L(done_return_value)
 
 L(fd_return_value):
@@ -170,21 +273,57 @@  L(float_return_value):
 	stfs	f1,0(r30)
 	b	L(done_return_value)
 
+L(scalar_return_value):
+	bt	29,L(fp_return_value)	; FLAG_RETURNS_FP
+	; ffi_arg is defined as unsigned long. 
+	sg	r3,0(r30)		; Save the reg.
+	bf	28,L(done_return_value) ; not FLAG_RETURNS_64BITS 
+
+#if defined(__ppc64__)
+L(maybe_return_128):
+	std	r3,0(r30)
+	bf	31,L(done_return_value) ; not FLAG_RETURNS_128BITS 
+	std	r4,8(r30)
+#else
+	stw	r4,4(r30)
+#endif
+
+	/* Fall through.  */
+	/* We want this at the end to simplify eh epilog computation.  */
+
+L(done_return_value):
+	/* Restore the registers we used and return.  */
+	lg	r29,SAVED_LR_OFFSET(r28)
+	; epilog
+	lg	r31,-(1 * GPR_BYTES)(r28)
+	mtlr	r29
+	lg	r30,-(2 * GPR_BYTES)(r28)
+	lg	r29,-(3 * GPR_BYTES)(r28)
+	lg	r28,-(4 * GPR_BYTES)(r28)
+	lg	r1,0(r1)
+	blr
 LFE1:
+	.align	1
 /* END(_ffi_call_DARWIN)  */
 
 /* Provide a null definition of _ffi_call_AIX.  */
-.text
+	.text
+	.globl _ffi_call_AIX
 	.align 2
-.globl _ffi_call_AIX
-.text
-	.align 2
 _ffi_call_AIX:
 	blr
 /* END(_ffi_call_AIX)  */
 
-.data
-.section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms
+/* EH stuff.  */
+
+#define EH_DATA_ALIGN_FACT MODE_CHOICE(0x7c,0x78)
+
+	.static_data
+	.align LOG2_GPR_BYTES
+LLFB0$non_lazy_ptr:
+	.g_long Lstartcode
+
+	.section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
 EH_frame1:
 	.set	L$set$0,LECIE1-LSCIE1
 	.long	L$set$0	; Length of Common Information Entry
@@ -193,7 +332,7 @@  LSCIE1:
 	.byte	0x1	; CIE Version
 	.ascii	"zR\0"	; CIE Augmentation
 	.byte	0x1	; uleb128 0x1; CIE Code Alignment Factor
-	.byte	0x7c	; sleb128 -4; CIE Data Alignment Factor
+	.byte	EH_DATA_ALIGN_FACT ; sleb128 -4; CIE Data Alignment Factor
 	.byte	0x41	; CIE RA Column
 	.byte	0x1	; uleb128 0x1; Augmentation size
 	.byte	0x90	; FDE Encoding (indirect pcrel)
@@ -202,7 +341,8 @@  LSCIE1:
 	.byte	0x0	; uleb128 0x0
 	.align	LOG2_GPR_BYTES
 LECIE1:
-.globl _ffi_call_DARWIN.eh
+
+	.globl _ffi_call_DARWIN.eh
 _ffi_call_DARWIN.eh:
 LSFDE1:
 	.set	L$set$1,LEFDE1-LASFDE1
@@ -210,11 +350,11 @@  LSFDE1:
 LASFDE1:
 	.long	LASFDE1-EH_frame1 ; FDE CIE offset
 	.g_long	LLFB0$non_lazy_ptr-.	; FDE initial location
-	.set	L$set$3,LFE1-LFB0
+	.set	L$set$3,LFE1-Lstartcode
 	.g_long	L$set$3	; FDE address range
 	.byte   0x0     ; uleb128 0x0; Augmentation size
 	.byte	0x4	; DW_CFA_advance_loc4
-	.set	L$set$4,LCFI0-LFB1
+	.set	L$set$4,LCFI0-Lstartcode
 	.long	L$set$4
 	.byte	0xd	; DW_CFA_def_cfa_register
 	.byte	0x08	; uleb128 0x08
@@ -239,7 +379,5 @@  LASFDE1:
 	.byte	0x1c	; uleb128 0x1c
 	.align LOG2_GPR_BYTES
 LEFDE1:
-.data
-	.align LOG2_GPR_BYTES
-LLFB0$non_lazy_ptr:
-	.g_long LFB0
+	.align 1
+
Index: libffi/src/powerpc/ffi_darwin.c
===================================================================
--- libffi/src/powerpc/ffi_darwin.c	(revision 167645)
+++ libffi/src/powerpc/ffi_darwin.c	(working copy)
@@ -3,7 +3,7 @@ 
 
    Copyright (C) 1998 Geoffrey Keating
    Copyright (C) 2001 John Hornkvist
-   Copyright (C) 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
 
    FFI support for Darwin and AIX.
    
@@ -35,12 +35,18 @@ 
 extern void ffi_closure_ASM (void);
 
 enum {
-  /* The assembly depends on these exact flags.  */
-  FLAG_RETURNS_NOTHING  = 1 << (31-30), /* These go in cr7  */
-  FLAG_RETURNS_FP       = 1 << (31-29),
-  FLAG_RETURNS_64BITS   = 1 << (31-28),
-  FLAG_RETURNS_128BITS  = 1 << (31-31),
+  /* The assembly depends on these exact flags.  
+     For Darwin64 (when FLAG_RETURNS_STRUCT is set):
+       FLAG_RETURNS_FP indicates that the structure embeds FP data.
+       FLAG_RETURNS_128BITS signals a special struct size that is not
+       expanded for float content.  */
+  FLAG_RETURNS_128BITS	= 1 << (31-31), /* These go in cr7  */
+  FLAG_RETURNS_NOTHING	= 1 << (31-30),
+  FLAG_RETURNS_FP	= 1 << (31-29),
+  FLAG_RETURNS_64BITS	= 1 << (31-28),
 
+  FLAG_RETURNS_STRUCT	= 1 << (31-27), /* This goes in cr6  */
+
   FLAG_ARG_NEEDS_COPY   = 1 << (31- 7),
   FLAG_FP_ARGUMENTS     = 1 << (31- 6), /* cr1.eq; specified by ABI  */
   FLAG_4_GPR_ARGUMENTS  = 1 << (31- 5),
@@ -50,43 +56,61 @@  enum {
 /* About the DARWIN ABI.  */
 enum {
   NUM_GPR_ARG_REGISTERS = 8,
-  NUM_FPR_ARG_REGISTERS = 13
+  NUM_FPR_ARG_REGISTERS = 13,
+  LINKAGE_AREA_GPRS = 6
 };
-enum { ASM_NEEDS_REGISTERS = 4 };
 
+enum { ASM_NEEDS_REGISTERS = 4 }; /* r28-r31 */
+
 /* ffi_prep_args is called by the assembly routine once stack space
    has been allocated for the function's arguments.
+   
+   m32/m64
 
    The stack layout we want looks like this:
 
    |   Return address from ffi_call_DARWIN      |	higher addresses
    |--------------------------------------------|
-   |   Previous backchain pointer	4	|	stack pointer here
+   |   Previous backchain pointer	4/8	|	stack pointer here
    |--------------------------------------------|<+ <<<	on entry to
-   |   Saved r28-r31			4*4	| |	ffi_call_DARWIN
+   |   ASM_NEEDS_REGISTERS=r28-r31   4*(4/8)	| |	ffi_call_DARWIN
    |--------------------------------------------| |
-   |   Parameters             (at least 8*4=32) | |
+   |   When we have any FP activity... the	| |
+   |   FPRs occupy NUM_FPR_ARG_REGISTERS slots	| |
+   |   here fp13 .. fp1 from high to low addr.	| |
+   ~						~ ~
+   |   Parameters      (at least 8*4/8=32/64)	| | NUM_GPR_ARG_REGISTERS
    |--------------------------------------------| |
-   |   Space for GPR2                   4       | |
+   |   TOC=R2 (AIX) Reserved (Darwin)   4/8	| |
    |--------------------------------------------| |	stack	|
-   |   Reserved                       2*4       | |	grows	|
+   |   Reserved                       2*4/8	| |	grows	|
    |--------------------------------------------| |	down	V
-   |   Space for callee's LR		4	| |
+   |   Space for callee's LR		4/8	| |
    |--------------------------------------------| |	lower addresses
-   |   Saved CR                         4       | |
+   |   Saved CR [low word for m64]      4/8	| |
    |--------------------------------------------| |     stack pointer here
-   |   Current backchain pointer	4	|-/	during
+   |   Current backchain pointer	4/8	|-/	during
    |--------------------------------------------|   <<<	ffi_call_DARWIN
 
    */
 
+#if defined(POWERPC_DARWIN64)
+static void
+darwin64_pass_struct_by_value 
+  (ffi_type *, char *, unsigned, unsigned *, double **, unsigned long **);
+#endif
+
+/* This depends on GPR_SIZE = sizeof (unsigned long) */
+
 void
 ffi_prep_args (extended_cif *ecif, unsigned long *const stack)
 {
   const unsigned bytes = ecif->cif->bytes;
   const unsigned flags = ecif->cif->flags;
   const unsigned nargs = ecif->cif->nargs;
+#if !defined(POWERPC_DARWIN64) 
   const ffi_abi abi = ecif->cif->abi;
+#endif
 
   /* 'stacktop' points at the previous backchain pointer.  */
   unsigned long *const stacktop = stack + (bytes / sizeof(unsigned long));
@@ -94,18 +118,19 @@  ffi_prep_args (extended_cif *ecif, unsigned long *
   /* 'fpr_base' points at the space for fpr1, and grows upwards as
      we use FPR registers.  */
   double *fpr_base = (double *) (stacktop - ASM_NEEDS_REGISTERS) - NUM_FPR_ARG_REGISTERS;
-  int fparg_count = 0;
+  int gp_count = 0, fparg_count = 0;
 
-
   /* 'next_arg' grows up as we put parameters in it.  */
-  unsigned long *next_arg = stack + 6; /* 6 reserved positions.  */
+  unsigned long *next_arg = stack + LINKAGE_AREA_GPRS; /* 6 reserved positions.  */
 
   int i;
   double double_tmp;
   void **p_argv = ecif->avalue;
   unsigned long gprvalue;
   ffi_type** ptr = ecif->cif->arg_types;
+#if !defined(POWERPC_DARWIN64) 
   char *dest_cpy;
+#endif
   unsigned size_al = 0;
 
   /* Check that everything starts aligned properly.  */
@@ -130,25 +155,30 @@  ffi_prep_args (extended_cif *ecif, unsigned long *
 	   the size of the floating-point parameter are skipped.  */
 	case FFI_TYPE_FLOAT:
 	  double_tmp = *(float *) *p_argv;
-	  if (fparg_count >= NUM_FPR_ARG_REGISTERS)
-	    *(double *)next_arg = double_tmp;
-	  else
+	  if (fparg_count < NUM_FPR_ARG_REGISTERS)
 	    *fpr_base++ = double_tmp;
+#if defined(POWERPC_DARWIN)
+	  *(float *)next_arg = *(float *) *p_argv;
+#else
+	  *(double *)next_arg = double_tmp;
+#endif
 	  next_arg++;
+	  gp_count++;
 	  fparg_count++;
 	  FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
 	  break;
 
 	case FFI_TYPE_DOUBLE:
 	  double_tmp = *(double *) *p_argv;
-	  if (fparg_count >= NUM_FPR_ARG_REGISTERS)
-	    *(double *)next_arg = double_tmp;
-	  else
+	  if (fparg_count < NUM_FPR_ARG_REGISTERS)
 	    *fpr_base++ = double_tmp;
+	  *(double *)next_arg = double_tmp;
 #ifdef POWERPC64
 	  next_arg++;
+	  gp_count++;
 #else
 	  next_arg += 2;
+	  gp_count += 2;
 #endif
 	  fparg_count++;
 	  FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
@@ -157,30 +187,41 @@  ffi_prep_args (extended_cif *ecif, unsigned long *
 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
 
 	case FFI_TYPE_LONGDOUBLE:
-#ifdef POWERPC64
+#  if defined(POWERPC64) && !defined(POWERPC_DARWIN64)
+	  /* ??? This will exceed the regs count when the value starts at fp13
+	     and it will not put the extra bit on the stack.  */
 	  if (fparg_count < NUM_FPR_ARG_REGISTERS)
 	    *(long double *) fpr_base++ = *(long double *) *p_argv;
 	  else
 	    *(long double *) next_arg = *(long double *) *p_argv;
 	  next_arg += 2;
 	  fparg_count += 2;
-#else
+#  else
 	  double_tmp = ((double *) *p_argv)[0];
 	  if (fparg_count < NUM_FPR_ARG_REGISTERS)
 	    *fpr_base++ = double_tmp;
-	  else
-	    *(double *) next_arg = double_tmp;
+	  *(double *) next_arg = double_tmp;
+#    if defined(POWERPC_DARWIN64)
+	  next_arg++;
+	  gp_count++;
+#    else
 	  next_arg += 2;
+	  gp_count += 2;
+#    endif
 	  fparg_count++;
-
 	  double_tmp = ((double *) *p_argv)[1];
 	  if (fparg_count < NUM_FPR_ARG_REGISTERS)
 	    *fpr_base++ = double_tmp;
-	  else
-	    *(double *) next_arg = double_tmp;
+	  *(double *) next_arg = double_tmp;
+#    if defined(POWERPC_DARWIN64)
+	  next_arg++;
+	  gp_count++;
+#    else
 	  next_arg += 2;
+	  gp_count += 2;
+#    endif
 	  fparg_count++;
-#endif
+#  endif
 	  FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
 	  break;
 #endif
@@ -192,6 +233,7 @@  ffi_prep_args (extended_cif *ecif, unsigned long *
 #else
 	  *(long long *) next_arg = *(long long *) *p_argv;
 	  next_arg += 2;
+	  gp_count += 2;
 #endif
 	  break;
 	case FFI_TYPE_POINTER:
@@ -211,32 +253,35 @@  ffi_prep_args (extended_cif *ecif, unsigned long *
 	  goto putgpr;
 
 	case FFI_TYPE_STRUCT:
-#ifdef POWERPC64
+	  size_al = (*ptr)->size;
+#if defined(POWERPC_DARWIN64)
+	  next_arg = (unsigned long *)ALIGN((char *)next_arg, (*ptr)->alignment);
+	  darwin64_pass_struct_by_value (*ptr, (char *) *p_argv, 
+					 (unsigned) size_al,
+					 (unsigned int *) &fparg_count,
+					 &fpr_base, &next_arg);
+#else
 	  dest_cpy = (char *) next_arg;
-	  size_al = (*ptr)->size;
-	  if ((*ptr)->elements[0]->type == 3)
+
+	  /* If the first member of the struct is a double, then include enough
+	     padding in the struct size to align it to double-word.  */
+	  if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
 	    size_al = ALIGN((*ptr)->size, 8);
-	  if (size_al < 3 && abi == FFI_DARWIN)
-	    dest_cpy += 4 - size_al;
 
+#  if defined(POWERPC64) 
+	  FFI_ASSERT (abi != FFI_DARWIN);
 	  memcpy ((char *) dest_cpy, (char *) *p_argv, size_al);
 	  next_arg += (size_al + 7) / 8;
-#else
-	  dest_cpy = (char *) next_arg;
-
+#  else
 	  /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
 	     SI 4 bytes) are aligned as if they were those modes.
 	     Structures with 3 byte in size are padded upwards.  */
-	  size_al = (*ptr)->size;
-	  /* If the first member of the struct is a double, then align
-	     the struct to double-word.  */
-	  if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
-	    size_al = ALIGN((*ptr)->size, 8);
 	  if (size_al < 3 && abi == FFI_DARWIN)
 	    dest_cpy += 4 - size_al;
 
 	  memcpy((char *) dest_cpy, (char *) *p_argv, size_al);
 	  next_arg += (size_al + 3) / 4;
+#  endif
 #endif
 	  break;
 
@@ -249,6 +294,7 @@  ffi_prep_args (extended_cif *ecif, unsigned long *
 	  gprvalue = *(unsigned int *) *p_argv;
 	putgpr:
 	  *next_arg++ = gprvalue;
+	  gp_count++;
 	  break;
 	default:
 	  break;
@@ -262,8 +308,269 @@  ffi_prep_args (extended_cif *ecif, unsigned long *
   //FFI_ASSERT(flags & FLAG_4_GPR_ARGUMENTS || intarg_count <= 4);
 }
 
+#if defined(POWERPC_DARWIN64)
+
+/* See if we can put some of the struct into fprs.
+   This should not be called for structures of size 16 bytes, since these are not
+   broken out this way.  */
+static void
+darwin64_scan_struct_for_floats (ffi_type *s, unsigned *nfpr)
+{
+  int i;
+
+  FFI_ASSERT (s->type == FFI_TYPE_STRUCT)
+
+  for (i = 0; s->elements[i] != NULL; i++)
+    {
+      ffi_type *p = s->elements[i];
+      switch (p->type)
+	{
+	  case FFI_TYPE_STRUCT:
+	    darwin64_scan_struct_for_floats (p, nfpr);
+	    break;
+	  case FFI_TYPE_LONGDOUBLE:
+	    (*nfpr) += 2;
+	    break;
+	  case FFI_TYPE_DOUBLE:
+	  case FFI_TYPE_FLOAT:
+	    (*nfpr) += 1;
+	    break;
+	  default:
+	    break;    
+	}
+    }
+}
+
+static int
+darwin64_struct_size_exceeds_gprs_p (ffi_type *s, char *src, unsigned *nfpr)
+{
+  unsigned struct_offset=0, i;
+
+  for (i = 0; s->elements[i] != NULL; i++)
+    {
+      char *item_base;
+      ffi_type *p = s->elements[i];
+      /* Find the start of this item (0 for the first one).  */
+      if (i > 0)
+        struct_offset = ALIGN(struct_offset, p->alignment);
+
+      item_base = src + struct_offset;
+
+      switch (p->type)
+	{
+	  case FFI_TYPE_STRUCT:
+	    if (darwin64_struct_size_exceeds_gprs_p (p, item_base, nfpr))
+	      return 1;
+	    break;
+	  case FFI_TYPE_LONGDOUBLE:
+	    if (*nfpr >= NUM_FPR_ARG_REGISTERS)
+	      return 1;
+	    (*nfpr) += 1;
+	    item_base += 8;
+	  /* FALL THROUGH */
+	  case FFI_TYPE_DOUBLE:
+	    if (*nfpr >= NUM_FPR_ARG_REGISTERS)
+	      return 1;
+	    (*nfpr) += 1;
+	    break;
+	  case FFI_TYPE_FLOAT:
+	    if (*nfpr >= NUM_FPR_ARG_REGISTERS)
+	      return 1;
+	    (*nfpr) += 1;
+	    break;
+	  default:
+	    /* If we try and place any item, that is non-float, once we've
+	       exceeded the 8 GPR mark, then we can't fit the struct.  */
+	    if ((unsigned long)item_base >= 8*8) 
+	      return 1;
+	    break;    
+	}
+      /* now count the size of what we just used.  */
+      struct_offset += p->size;
+    }
+  return 0;
+}
+
+/* Can this struct be returned by value?  */
+int 
+darwin64_struct_ret_by_value_p (ffi_type *s)
+{
+  unsigned nfp = 0;
+
+  FFI_ASSERT (s && s->type == FFI_TYPE_STRUCT);
+  
+  /* The largest structure we can return is 8long + 13 doubles.  */
+  if (s->size > 168)
+    return 0;
+  
+  /* We can't pass more than 13 floats.  */
+  darwin64_scan_struct_for_floats (s, &nfp);
+  if (nfp > 13)
+    return 0;
+  
+  /* If there are not too many floats, and the struct is
+     small enough to accommodate in the GPRs, then it must be OK.  */
+  if (s->size <= 64)
+    return 1;
+  
+  /* Well, we have to look harder.  */
+  nfp = 0;
+  if (darwin64_struct_size_exceeds_gprs_p (s, NULL, &nfp))
+    return 0;
+  
+  return 1;
+}
+
+void
+darwin64_pass_struct_floats (ffi_type *s, char *src, 
+			     unsigned *nfpr, double **fprs)
+{
+  int i;
+  double *fpr_base = *fprs;
+  unsigned struct_offset = 0;
+
+  /* We don't assume anything about the alignment of the source.  */
+  for (i = 0; s->elements[i] != NULL; i++)
+    {
+      char *item_base;
+      ffi_type *p = s->elements[i];
+      /* Find the start of this item (0 for the first one).  */
+      if (i > 0)
+        struct_offset = ALIGN(struct_offset, p->alignment);
+      item_base = src + struct_offset;
+
+      switch (p->type)
+	{
+	  case FFI_TYPE_STRUCT:
+	    darwin64_pass_struct_floats (p, item_base, nfpr,
+					   &fpr_base);
+	    break;
+	  case FFI_TYPE_LONGDOUBLE:
+	    if (*nfpr < NUM_FPR_ARG_REGISTERS)
+	      *fpr_base++ = *(double *)item_base;
+	    (*nfpr) += 1;
+	    item_base += 8;
+	  /* FALL THROUGH */
+	  case FFI_TYPE_DOUBLE:
+	    if (*nfpr < NUM_FPR_ARG_REGISTERS)
+	      *fpr_base++ = *(double *)item_base;
+	    (*nfpr) += 1;
+	    break;
+	  case FFI_TYPE_FLOAT:
+	    if (*nfpr < NUM_FPR_ARG_REGISTERS)
+	      *fpr_base++ = (double) *(float *)item_base;
+	    (*nfpr) += 1;
+	    break;
+	  default:
+	    break;    
+	}
+      /* now count the size of what we just used.  */
+      struct_offset += p->size;
+    }
+  /* Update the scores.  */
+  *fprs = fpr_base;
+}
+
+/* Darwin64 special rules.
+   Break out a struct into params and float registers.  */
+static void
+darwin64_pass_struct_by_value (ffi_type *s, char *src, unsigned size,
+			       unsigned *nfpr, double **fprs, unsigned long **arg)
+{
+  unsigned long *next_arg = *arg;
+  char *dest_cpy = (char *)next_arg;
+
+  FFI_ASSERT (s->type == FFI_TYPE_STRUCT)
+
+  if (!size)
+    return;
+
+  /* First... special cases.  */
+  if (size < 3
+      || (size == 4 
+	  && s->elements[0] 
+	  && s->elements[0]->type != FFI_TYPE_FLOAT))
+    {
+      /* Must be at least one GPR, padding is unspecified in value, 
+	 let's make it zero.  */
+      *next_arg = 0UL; 
+      dest_cpy += 8 - size;
+      memcpy ((char *) dest_cpy, src, size);
+      next_arg++;
+    }
+  else if (size == 16)
+    {
+      memcpy ((char *) dest_cpy, src, size);
+      next_arg += 2;
+    }
+  else
+    {
+      /* now the general case, we consider embedded floats.  */
+      memcpy ((char *) dest_cpy, src, size);
+      darwin64_pass_struct_floats (s, src, nfpr, fprs);
+      next_arg += (size+7)/8;
+    }
+    
+  *arg = next_arg;
+}
+
+double *
+darwin64_struct_floats_to_mem (ffi_type *s, char *dest, double *fprs, unsigned *nf)
+{
+  int i;
+  unsigned struct_offset = 0;
+
+  /* We don't assume anything about the alignment of the source.  */
+  for (i = 0; s->elements[i] != NULL; i++)
+    {
+      char *item_base;
+      ffi_type *p = s->elements[i];
+      /* Find the start of this item (0 for the first one).  */
+      if (i > 0)
+        struct_offset = ALIGN(struct_offset, p->alignment);
+      item_base = dest + struct_offset;
+
+      switch (p->type)
+	{
+	  case FFI_TYPE_STRUCT:
+	    fprs = darwin64_struct_floats_to_mem (p, item_base, fprs, nf);
+	    break;
+	  case FFI_TYPE_LONGDOUBLE:
+	    if (*nf < NUM_FPR_ARG_REGISTERS)
+	      {
+		*(double *)item_base = *fprs++ ;
+		(*nf) += 1;
+	      }
+	    item_base += 8;
+	  /* FALL THROUGH */
+	  case FFI_TYPE_DOUBLE:
+	    if (*nf < NUM_FPR_ARG_REGISTERS)
+	      {
+		*(double *)item_base = *fprs++ ;
+		(*nf) += 1;
+	      }
+	    break;
+	  case FFI_TYPE_FLOAT:
+	    if (*nf < NUM_FPR_ARG_REGISTERS)
+	      {
+		*(float *)item_base = (float) *fprs++ ;
+		(*nf) += 1;
+	      }
+	    break;
+	  default:
+	    break;    
+	}
+      /* now count the size of what we just used.  */
+      struct_offset += p->size;
+    }
+  return fprs;
+}
+
+#endif
+
 /* Adjust the size of S to be correct for Darwin.
-   On Darwin, the first field of a structure has natural alignment.  */
+   On Darwin m32, the first field of a structure has natural alignment.  
+   On Darwin m64, all fields have natural alignment.  */
 
 static void
 darwin_adjust_aggregate_sizes (ffi_type *s)
@@ -280,22 +587,29 @@  darwin_adjust_aggregate_sizes (ffi_type *s)
       int align;
       
       p = s->elements[i];
-      darwin_adjust_aggregate_sizes (p);
-      if (i == 0
-	  && (p->type == FFI_TYPE_UINT64
-	      || p->type == FFI_TYPE_SINT64
-	      || p->type == FFI_TYPE_DOUBLE
-	      || p->alignment == 8))
-	align = 8;
+      if (p->type == FFI_TYPE_STRUCT)
+	darwin_adjust_aggregate_sizes (p);
+#if defined(POWERPC_DARWIN64)
+      /* Natural alignment for all items.  */
+      align = p->alignment;
+#else
+      /* Natrual alignment for the first item... */
+      if (i == 0)
+	align = p->alignment;
       else if (p->alignment == 16 || p->alignment < 4)
+	/* .. subsequent items with vector or align < 4 have natural align.  */
 	align = p->alignment;
       else
+	/* .. or align is 4.  */
 	align = 4;
+#endif
+      /* Pad, if necessary, before adding the current item.  */
       s->size = ALIGN(s->size, align) + p->size;
     }
   
   s->size = ALIGN(s->size, s->alignment);
   
+  /* This should not be necessary on m64, but harmless.  */
   if (s->elements[0]->type == FFI_TYPE_UINT64
       || s->elements[0]->type == FFI_TYPE_SINT64
       || s->elements[0]->type == FFI_TYPE_DOUBLE
@@ -347,7 +661,7 @@  ffi_prep_cif_machdep (ffi_cif *cif)
   unsigned i;
   ffi_type **ptr;
   unsigned bytes;
-  int fparg_count = 0, intarg_count = 0;
+  unsigned fparg_count = 0, intarg_count = 0;
   unsigned flags = 0;
   unsigned size_al = 0;
 
@@ -372,16 +686,25 @@  ffi_prep_cif_machdep (ffi_cif *cif)
   /* Space for the frame pointer, callee's LR, CR, etc, and for
      the asm's temp regs.  */
 
-  bytes = (6 + ASM_NEEDS_REGISTERS) * sizeof(long);
+  bytes = (LINKAGE_AREA_GPRS + ASM_NEEDS_REGISTERS) * sizeof(unsigned long);
 
-  /* Return value handling.  The rules are as follows:
+  /* Return value handling.  
+    The rules m32 are as follows:
      - 32-bit (or less) integer values are returned in gpr3;
-     - Structures of size <= 4 bytes also returned in gpr3;
-     - 64-bit integer values and structures between 5 and 8 bytes are returned
-       in gpr3 and gpr4;
+     - structures of size <= 4 bytes also returned in gpr3;
+     - 64-bit integer values [??? and structures between 5 and 8 bytes] are
+       returned in gpr3 and gpr4;
      - Single/double FP values are returned in fpr1;
      - Long double FP (if not equivalent to double) values are returned in
        fpr1 and fpr2;
+     m64:
+     - 64-bit or smaller integral values are returned in GPR3
+     - Single/double FP values are returned in fpr1;
+     - Long double FP values are returned in fpr1 and fpr2;
+     m64 Structures:
+     - If the structure could be accommodated in registers were it to be the
+       first argument to a routine, then it is returned in those registers.
+     m32/m64 structures otherwise:
      - Larger structures values are allocated space and a pointer is passed
        as the first argument.  */
   switch (cif->rtype->type)
@@ -410,9 +733,42 @@  ffi_prep_cif_machdep (ffi_cif *cif)
       break;
 
     case FFI_TYPE_STRUCT:
+#if defined(POWERPC_DARWIN64)
+      {
+	/* Can we fit the struct into regs?  */
+	if (darwin64_struct_ret_by_value_p (cif->rtype))
+	  {
+	    unsigned nfpr = 0;
+	    flags |= FLAG_RETURNS_STRUCT;
+	    if (cif->rtype->size != 16)
+	      darwin64_scan_struct_for_floats (cif->rtype, &nfpr) ;
+	    else
+	      flags |= FLAG_RETURNS_128BITS;
+	    /* Will be 0 for 16byte struct.  */
+	    if (nfpr)
+	      flags |= FLAG_RETURNS_FP;
+	  }
+	else /* By ref. */
+	  {
+	    flags |= FLAG_RETVAL_REFERENCE;
+	    flags |= FLAG_RETURNS_NOTHING;
+	    intarg_count++;
+	  }
+      }
+#elif defined(DARWIN_PPC)
+      if (cif->rtype->size <= 4)
+	flags |= FLAG_RETURNS_STRUCT;
+      else /* else by reference.  */
+	{
+	  flags |= FLAG_RETVAL_REFERENCE;
+	  flags |= FLAG_RETURNS_NOTHING;
+	  intarg_count++;
+	}
+#else /* assume we pass by ref.  */
       flags |= FLAG_RETVAL_REFERENCE;
       flags |= FLAG_RETURNS_NOTHING;
       intarg_count++;
+#endif
       break;
     case FFI_TYPE_VOID:
       flags |= FLAG_RETURNS_NOTHING;
@@ -425,57 +781,83 @@  ffi_prep_cif_machdep (ffi_cif *cif)
 
   /* The first NUM_GPR_ARG_REGISTERS words of integer arguments, and the
      first NUM_FPR_ARG_REGISTERS fp arguments, go in registers; the rest
-     goes on the stack.  Structures are passed as a pointer to a copy of
-     the structure. Stuff on the stack needs to keep proper alignment.  */
+     goes on the stack.  
+     ??? Structures are passed as a pointer to a copy of the structure. 
+     Stuff on the stack needs to keep proper alignment.  
+     For m64 the count is effectively of half-GPRs.  */
   for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
     {
+      unsigned align_words;
       switch ((*ptr)->type)
 	{
 	case FFI_TYPE_FLOAT:
 	case FFI_TYPE_DOUBLE:
 	  fparg_count++;
+#if !defined(POWERPC_DARWIN64)
 	  /* If this FP arg is going on the stack, it must be
 	     8-byte-aligned.  */
 	  if (fparg_count > NUM_FPR_ARG_REGISTERS
-	      && intarg_count%2 != 0)
+	      && (intarg_count & 0x01) != 0)
 	    intarg_count++;
+#endif
 	  break;
 
 #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
-
 	case FFI_TYPE_LONGDOUBLE:
 	  fparg_count += 2;
 	  /* If this FP arg is going on the stack, it must be
-	     8-byte-aligned.  */
-	  if (fparg_count > NUM_FPR_ARG_REGISTERS
-	      && intarg_count%2 != 0)
-	    intarg_count++;
-	  intarg_count +=2;
+	     16-byte-aligned.  */
+	  if (fparg_count >= NUM_FPR_ARG_REGISTERS)
+#if defined (POWERPC64)
+	    intarg_count = ALIGN(intarg_count, 2);
+#else
+	    intarg_count = ALIGN(intarg_count, 4);
+#endif
 	  break;
 #endif
 
 	case FFI_TYPE_UINT64:
 	case FFI_TYPE_SINT64:
+#if defined(POWERPC64)
+	  intarg_count++;
+#else
 	  /* 'long long' arguments are passed as two words, but
 	     either both words must fit in registers or both go
 	     on the stack.  If they go on the stack, they must
 	     be 8-byte-aligned.  */
 	  if (intarg_count == NUM_GPR_ARG_REGISTERS-1
-	      || (intarg_count >= NUM_GPR_ARG_REGISTERS && intarg_count%2 != 0))
+	      || (intarg_count >= NUM_GPR_ARG_REGISTERS 
+	          && (intarg_count & 0x01) != 0))
 	    intarg_count++;
 	  intarg_count += 2;
+#endif
 	  break;
 
 	case FFI_TYPE_STRUCT:
 	  size_al = (*ptr)->size;
+#if defined(POWERPC_DARWIN64)
+	  align_words = (*ptr)->alignment >> 3;
+	  if (align_words)
+	    intarg_count = ALIGN(intarg_count, align_words);
+	  /* Base size of the struct.  */
+	  intarg_count += (size_al + 7) / 8;
+	  /* If 16 bytes then don't worry about floats.  */
+	  if (size_al != 16)
+	    /* Scan through for floats to be placed in regs.  */
+	    darwin64_scan_struct_for_floats (*ptr, &fparg_count) ;
+#else
+	  align_words = (*ptr)->alignment >> 2;
+	  if (align_words)
+	    intarg_count = ALIGN(intarg_count, align_words);
 	  /* If the first member of the struct is a double, then align
-	     the struct to double-word.  */
+	     the struct to double-word. 
 	  if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
-	    size_al = ALIGN((*ptr)->size, 8);
-#ifdef POWERPC64
+	    size_al = ALIGN((*ptr)->size, 8); */
+#  ifdef POWERPC64
 	  intarg_count += (size_al + 7) / 8;
-#else
+#  else
 	  intarg_count += (size_al + 3) / 4;
+#  endif
 #endif
 	  break;
 
@@ -490,9 +872,18 @@  ffi_prep_cif_machdep (ffi_cif *cif)
   if (fparg_count != 0)
     flags |= FLAG_FP_ARGUMENTS;
 
+#if defined(POWERPC_DARWIN64)
+  /* Space to image the FPR registers, if needed - which includes when they might be
+     used in a struct return.  */
+  if (fparg_count != 0 
+      || ((flags & FLAG_RETURNS_STRUCT)
+	   && (flags & FLAG_RETURNS_FP)))
+    bytes += NUM_FPR_ARG_REGISTERS * sizeof(double);
+#else
   /* Space for the FPR registers, if needed.  */
   if (fparg_count != 0)
     bytes += NUM_FPR_ARG_REGISTERS * sizeof(double);
+#endif
 
   /* Stack space.  */
 #ifdef POWERPC64
@@ -506,7 +897,7 @@  ffi_prep_cif_machdep (ffi_cif *cif)
     bytes += NUM_GPR_ARG_REGISTERS * sizeof(long);
 
   /* The stack space allocated needs to be a multiple of 16 bytes.  */
-  bytes = (bytes + 15) & ~0xF;
+  bytes = ALIGN(bytes, 16) ;
 
   cif->flags = flags;
   cif->bytes = bytes;
@@ -516,8 +907,9 @@  ffi_prep_cif_machdep (ffi_cif *cif)
 
 extern void ffi_call_AIX(extended_cif *, long, unsigned, unsigned *,
 			 void (*fn)(void), void (*fn2)(void));
+
 extern void ffi_call_DARWIN(extended_cif *, long, unsigned, unsigned *,
-			    void (*fn)(void), void (*fn2)(void));
+			    void (*fn)(void), void (*fn2)(void), ffi_type*);
 
 void
 ffi_call (ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
@@ -546,7 +938,7 @@  ffi_call (ffi_cif *cif, void (*fn)(void), void *rv
       break;
     case FFI_DARWIN:
       ffi_call_DARWIN(&ecif, -(long)cif->bytes, cif->flags, ecif.rvalue, fn,
-		      FFI_FN(ffi_prep_args));
+		      FFI_FN(ffi_prep_args), cif->rtype);
       break;
     default:
       FFI_ASSERT(0);
@@ -566,58 +958,48 @@  typedef struct aix_fd_struct {
 } aix_fd;
 
 /* here I'd like to add the stack frame layout we use in darwin_closure.S
-   and aix_clsoure.S
+   and aix_closure.S
 
-   SP previous -> +---------------------------------------+ <--- child frame
-		  | back chain to caller 4                |
-		  +---------------------------------------+ 4
-		  | saved CR 4                            |
-		  +---------------------------------------+ 8
-		  | saved LR 4                            |
-		  +---------------------------------------+ 12
-		  | reserved for compilers 4              |
-		  +---------------------------------------+ 16
-		  | reserved for binders 4                |
-		  +---------------------------------------+ 20
-		  | saved TOC pointer 4                   |
-		  +---------------------------------------+ 24
-		  | always reserved 8*4=32 (previous GPRs)|
-		  | according to the linkage convention   |
-		  | from AIX                              |
-		  +---------------------------------------+ 56
-		  | our FPR area 13*8=104                 |
-		  | f1                                    |
-		  | .                                     |
-		  | f13                                   |
-		  +---------------------------------------+ 160
-		  | result area 8                         |
-		  +---------------------------------------+ 168
-		  | alignement to the next multiple of 16 |
-SP current -->    +---------------------------------------+ 176 <- parent frame
-		  | back chain to caller 4                |
-		  +---------------------------------------+ 180
-		  | saved CR 4                            |
-		  +---------------------------------------+ 184
-		  | saved LR 4                            |
-		  +---------------------------------------+ 188
-		  | reserved for compilers 4              |
-		  +---------------------------------------+ 192
-		  | reserved for binders 4                |
-		  +---------------------------------------+ 196
-		  | saved TOC pointer 4                   |
-		  +---------------------------------------+ 200
-		  | always reserved 8*4=32  we store our  |
-		  | GPRs here                             |
-		  | r3                                    |
-		  | .                                     |
-		  | r10                                   |
-		  +---------------------------------------+ 232
-		  | overflow part                         |
-		  +---------------------------------------+ xxx
-		  | ????                                  |
-		  +---------------------------------------+ xxx
+   m32/m64
 
+   The stack layout looks like this:
+
+   |   Additional params...			| |     Higher address
+   ~						~ ~
+   |   Parameters      (at least 8*4/8=32/64)	| | NUM_GPR_ARG_REGISTERS
+   |--------------------------------------------| |
+   |   TOC=R2 (AIX) Reserved (Darwin)   4/8	| |
+   |--------------------------------------------| |
+   |   Reserved                       2*4/8	| |
+   |--------------------------------------------| |
+   |   Space for callee's LR		4/8	| |
+   |--------------------------------------------| |
+   |   Saved CR [low word for m64]      4/8	| |
+   |--------------------------------------------| |
+   |   Current backchain pointer	4/8	|-/ Parent's frame.
+   |--------------------------------------------| <+ <<< on entry to ffi_closure_ASM
+   |   Result Bytes			16	| |
+   |--------------------------------------------| |
+   ~   padding to 16-byte alignment		~ ~
+   |--------------------------------------------| |
+   |   NUM_FPR_ARG_REGISTERS slots		| |
+   |   here fp13 .. fp1		       13*8	| |
+   |--------------------------------------------| |
+   |   R3..R10			  8*4/8=32/64	| | NUM_GPR_ARG_REGISTERS
+   |--------------------------------------------| |
+   |   TOC=R2 (AIX) Reserved (Darwin)   4/8	| |
+   |--------------------------------------------| |	stack	|
+   |   Reserved [compiler,binder]     2*4/8	| |	grows	|
+   |--------------------------------------------| |	down	V
+   |   Space for callee's LR		4/8	| |
+   |--------------------------------------------| |	lower addresses
+   |   Saved CR [low word for m64]      4/8	| |
+   |--------------------------------------------| |     stack pointer here
+   |   Current backchain pointer	4/8	|-/	during
+   |--------------------------------------------|   <<<	ffi_closure_ASM.
+
 */
+
 ffi_status
 ffi_prep_closure_loc (ffi_closure* closure,
 		      ffi_cif* cif,
@@ -631,30 +1013,44 @@  ffi_prep_closure_loc (ffi_closure* closure,
 
   switch (cif->abi)
     {
-    case FFI_DARWIN:
+      case FFI_DARWIN:
 
-      FFI_ASSERT (cif->abi == FFI_DARWIN);
+	FFI_ASSERT (cif->abi == FFI_DARWIN);
 
-      tramp = (unsigned int *) &closure->tramp[0];
-      tramp[0] = 0x7c0802a6;  /*   mflr    r0  */
-      tramp[1] = 0x429f000d;  /*   bcl-    20,4*cr7+so,0x10  */
-      tramp[4] = 0x7d6802a6;  /*   mflr    r11  */
-      tramp[5] = 0x818b0000;  /*   lwz     r12,0(r11) function address  */
-      tramp[6] = 0x7c0803a6;  /*   mtlr    r0   */
-      tramp[7] = 0x7d8903a6;  /*   mtctr   r12  */
-      tramp[8] = 0x816b0004;  /*   lwz     r11,4(r11) static chain  */
-      tramp[9] = 0x4e800420;  /*   bctr  */
-      tramp[2] = (unsigned long) ffi_closure_ASM; /* function  */
-      tramp[3] = (unsigned long) codeloc; /* context  */
+	tramp = (unsigned int *) &closure->tramp[0];
+#if defined(POWERPC_DARWIN64)
+	tramp[0] = 0x7c0802a6;  /*   mflr    r0  */
+	tramp[1] = 0x429f0015;  /*   bcl-    20,4*cr7+so,  +0x18 (L1)  */
+	/* We put the addresses here.  */
+	tramp[6] = 0x7d6802a6;  /*L1:   mflr    r11  */
+	tramp[7] = 0xe98b0000;  /*   ld     r12,0(r11) function address  */
+	tramp[8] = 0x7c0803a6;  /*   mtlr    r0   */
+	tramp[9] = 0x7d8903a6;  /*   mtctr   r12  */
+	tramp[10] = 0xe96b0008;  /*   lwz     r11,8(r11) static chain  */
+	tramp[11] = 0x4e800420;  /*   bctr  */
 
-      closure->cif = cif;
-      closure->fun = fun;
-      closure->user_data = user_data;
+	*((unsigned long *)&tramp[2]) = (unsigned long) ffi_closure_ASM; /* function  */
+	*((unsigned long *)&tramp[4]) = (unsigned long) codeloc; /* context  */
+#else
+	tramp[0] = 0x7c0802a6;  /*   mflr    r0  */
+	tramp[1] = 0x429f000d;  /*   bcl-    20,4*cr7+so,0x10  */
+	tramp[4] = 0x7d6802a6;  /*   mflr    r11  */
+	tramp[5] = 0x818b0000;  /*   lwz     r12,0(r11) function address  */
+	tramp[6] = 0x7c0803a6;  /*   mtlr    r0   */
+	tramp[7] = 0x7d8903a6;  /*   mtctr   r12  */
+	tramp[8] = 0x816b0004;  /*   lwz     r11,4(r11) static chain  */
+	tramp[9] = 0x4e800420;  /*   bctr  */
+	tramp[2] = (unsigned long) ffi_closure_ASM; /* function  */
+	tramp[3] = (unsigned long) codeloc; /* context  */
+#endif
+	closure->cif = cif;
+	closure->fun = fun;
+	closure->user_data = user_data;
 
-      /* Flush the icache. Only necessary on Darwin.  */
-      flush_range(codeloc, FFI_TRAMPOLINE_SIZE);
+	/* Flush the icache. Only necessary on Darwin.  */
+	flush_range(codeloc, FFI_TRAMPOLINE_SIZE);
 
-      break;
+	break;
 
     case FFI_AIX:
 
@@ -708,7 +1104,7 @@  typedef union
   double d;
 } ffi_dblfl;
 
-int
+ffi_type *
 ffi_closure_helper_DARWIN (ffi_closure *, void *,
 			   unsigned long *, ffi_dblfl *);
 
@@ -719,7 +1115,7 @@  ffi_closure_helper_DARWIN (ffi_closure *, void *,
    up space for a return value, ffi_closure_ASM invokes the
    following helper function to do most of the work.  */
 
-int
+ffi_type *
 ffi_closure_helper_DARWIN (ffi_closure *closure, void *rvalue,
 			   unsigned long *pgr, ffi_dblfl *pfr)
 {
@@ -741,16 +1137,32 @@  ffi_closure_helper_DARWIN (ffi_closure *closure, v
   ffi_cif *        cif;
   ffi_dblfl *      end_pfr = pfr + NUM_FPR_ARG_REGISTERS;
   unsigned         size_al;
+#if defined(POWERPC_DARWIN64)
+  unsigned 	   fpsused = 0;
+#endif
 
   cif = closure->cif;
   avalue = alloca (cif->nargs * sizeof(void *));
 
-  /* Copy the caller's structure return value address so that the closure
-     returns the data directly to the caller.  */
   if (cif->rtype->type == FFI_TYPE_STRUCT)
     {
+#if defined(POWERPC_DARWIN64)
+      if (!darwin64_struct_ret_by_value_p (cif->rtype))
+	{
+    	  /* Won't fit into the regs - return by ref.  */
+	  rvalue = (void *) *pgr;
+	  pgr++;
+	}
+#elif defined(DARWIN_PPC)
+      if (cif->rtype->size > 4)
+	{
+	  rvalue = (void *) *pgr;
+	  pgr++;
+	}
+#else /* assume we return by ref.  */
       rvalue = (void *) *pgr;
       pgr++;
+#endif
     }
 
   i = 0;
@@ -764,7 +1176,7 @@  ffi_closure_helper_DARWIN (ffi_closure *closure, v
 	{
 	case FFI_TYPE_SINT8:
 	case FFI_TYPE_UINT8:
-#ifdef POWERPC64
+#if  defined(POWERPC64)
 	  avalue[i] = (char *) pgr + 7;
 #else
 	  avalue[i] = (char *) pgr + 3;
@@ -774,7 +1186,7 @@  ffi_closure_helper_DARWIN (ffi_closure *closure, v
 
 	case FFI_TYPE_SINT16:
 	case FFI_TYPE_UINT16:
-#ifdef POWERPC64
+#if  defined(POWERPC64)
 	  avalue[i] = (char *) pgr + 6;
 #else
 	  avalue[i] = (char *) pgr + 2;
@@ -784,7 +1196,7 @@  ffi_closure_helper_DARWIN (ffi_closure *closure, v
 
 	case FFI_TYPE_SINT32:
 	case FFI_TYPE_UINT32:
-#ifdef POWERPC64
+#if  defined(POWERPC64)
 	  avalue[i] = (char *) pgr + 4;
 #else
 	case FFI_TYPE_POINTER:
@@ -794,34 +1206,53 @@  ffi_closure_helper_DARWIN (ffi_closure *closure, v
 	  break;
 
 	case FFI_TYPE_STRUCT:
-#ifdef POWERPC64
 	  size_al = arg_types[i]->size;
-	  if (arg_types[i]->elements[0]->type == FFI_TYPE_DOUBLE)
-	    size_al = ALIGN (arg_types[i]->size, 8);
-	  if (size_al < 3 && cif->abi == FFI_DARWIN)
-	    avalue[i] = (char *) pgr + 8 - size_al;
-	  else
-	    avalue[i] = pgr;
+#if defined(POWERPC_DARWIN64)
+	  pgr = (unsigned long *)ALIGN((char *)pgr, arg_types[i]->alignment);
+	  if (size_al < 3 || size_al == 4)
+	    {
+	      avalue[i] = ((char *)pgr)+8-size_al;
+	      if (arg_types[i]->elements[0]->type == FFI_TYPE_FLOAT
+		  && fpsused < NUM_FPR_ARG_REGISTERS)
+		{
+		  *(float *)pgr = (float) *(double *)pfr;
+		  pfr++;
+		  fpsused++;
+		}
+	    }
+	  else 
+	    {
+	      if (size_al != 16)
+		pfr = (ffi_dblfl *) 
+		    darwin64_struct_floats_to_mem (arg_types[i], (char *)pgr,
+						   (double *)pfr, &fpsused);
+	      avalue[i] = pgr;
+	    }
 	  pgr += (size_al + 7) / 8;
 #else
-	  /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
-	     SI 4 bytes) are aligned as if they were those modes.  */
-	  size_al = arg_types[i]->size;
 	  /* If the first member of the struct is a double, then align
 	     the struct to double-word.  */
 	  if (arg_types[i]->elements[0]->type == FFI_TYPE_DOUBLE)
 	    size_al = ALIGN(arg_types[i]->size, 8);
+#  if defined(POWERPC64)
+	  FFI_ASSERT (cif->abi != FFI_DARWIN)
+	  avalue[i] = pgr;
+	  pgr += (size_al + 7) / 8;
+#  else
+	  /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
+	     SI 4 bytes) are aligned as if they were those modes.  */
 	  if (size_al < 3 && cif->abi == FFI_DARWIN)
 	    avalue[i] = (char*) pgr + 4 - size_al;
 	  else
 	    avalue[i] = pgr;
 	  pgr += (size_al + 3) / 4;
+#  endif
 #endif
 	  break;
 
 	case FFI_TYPE_SINT64:
 	case FFI_TYPE_UINT64:
-#ifdef POWERPC64
+#if  defined(POWERPC64)
 	case FFI_TYPE_POINTER:
 	  avalue[i] = pgr;
 	  pgr++;
@@ -924,5 +1355,5 @@  ffi_closure_helper_DARWIN (ffi_closure *closure, v
   (closure->fun) (cif, rvalue, avalue, closure->user_data);
 
   /* Tell ffi_closure_ASM to perform return type promotions.  */
-  return cif->rtype->type;
+  return cif->rtype;
 }