re PR libffi/29152 (64-bit darwin ppc port needed for libffi)
libffi: PR libffi/29152 PR libffi/42378 * 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: Likewise. From-SVN: r168016
This commit is contained in:
Iain Sandoe
parent
c1ea31e3a5
commit
3a9f56e8c8
|
|
@ -1,3 +1,15 @@
|
|||
2010-12-18 Iain Sandoe <iains@gcc.gnu.org>
|
||||
|
||||
PR libffi/29152
|
||||
PR libffi/42378
|
||||
* 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: Likewise.
|
||||
|
||||
2010-12-06 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE>
|
||||
|
||||
* configure.ac (libffi_cv_as_ascii_pseudo_op): Use double
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
||||
; ... 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)
|
||||
|
||||
#define LIBFFI_ASM
|
||||
#include <fficonfig.h>
|
||||
#include <ffi.h>
|
||||
|
||||
#define JUMPTARGET(name) name
|
||||
#define L(x) x
|
||||
.text
|
||||
.align 2
|
||||
.globl _ffi_prep_args
|
||||
|
||||
.text
|
||||
.text
|
||||
.align 2
|
||||
.globl _ffi_call_DARWIN
|
||||
.text
|
||||
.globl _ffi_prep_args
|
||||
|
||||
.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)
|
||||
|
||||
#if !defined(POWERPC_DARWIN)
|
||||
/* The TOC slot is reserved in the Darwin ABI and r2 is volatile. */
|
||||
sg r2,(5 * GPR_BYTES)(r1)
|
||||
#endif
|
||||
|
||||
stw r9,8(r8)
|
||||
stw r2,20(r1)
|
||||
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
|
||||
.align 2
|
||||
.globl _ffi_call_AIX
|
||||
.text
|
||||
.text
|
||||
.globl _ffi_call_AIX
|
||||
.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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
#endif
|
||||
/* case FFI_TYPE_POINTER */
|
||||
Lret_type14:
|
||||
lg r3,0(r5)
|
||||
b Lfinish
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
|
||||
/* case FFI_TYPE_POINTER */
|
||||
Lret_type14:
|
||||
lwz 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
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in New Issue