| /* ----------------------------------------------------------------------- |
| darwin.S - Copyright (c) 2000 John Hornkvist |
| Copyright (c) 2004, 2010 Free Software Foundation, Inc. |
| |
| PowerPC Assembly glue. |
| |
| Permission is hereby granted, free of charge, to any person obtaining |
| a copy of this software and associated documentation files (the |
| ``Software''), to deal in the Software without restriction, including |
| without limitation the rights to use, copy, modify, merge, publish, |
| distribute, sublicense, and/or sell copies of the Software, and to |
| permit persons to whom the Software is furnished to do so, subject to |
| the following conditions: |
| |
| The above copyright notice and this permission notice shall be included |
| in all copies or substantial portions of the Software. |
| |
| THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| OTHER DEALINGS IN THE SOFTWARE. |
| ----------------------------------------------------------------------- */ |
| |
| #define LIBFFI_ASM |
| #if defined(__ppc64__) |
| #define MODE_CHOICE(x, y) y |
| #else |
| #define MODE_CHOICE(x, y) x |
| #endif |
| |
| #define machine_choice MODE_CHOICE(ppc7400,ppc64) |
| |
| ; 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) |
| |
| #include <fficonfig.h> |
| #include <ffi.h> |
| |
| #define JUMPTARGET(name) name |
| #define L(x) x |
| |
| .text |
| .align 2 |
| .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: |
| Lstartcode: |
| mr r12,r8 /* We only need r12 until the call, |
| 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. */ |
| sgux r1,r1,r4 |
| |
| /* Save registers we use. */ |
| mflr r9 |
| sg r9,SAVED_LR_OFFSET(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 |
| |
| LCFI1: |
| |
| /* Save arguments over call. */ |
| mr r31,r5 /* flags, */ |
| mr r30,r6 /* rvalue, */ |
| mr r29,r7 /* function address, */ |
| mr r28,r8 /* our AP. */ |
| LCFI2: |
| /* 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 |
| |
| #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 |
| /* Get the address to call into CTR. */ |
| mtctr r29 |
| /* Load all those argument registers. |
| We have set up a nice stack frame, just load it into registers. */ |
| 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 |
| 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. */ |
| bf 6,L2 /* No floats to load. */ |
| 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, -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, -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,-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. */ |
| |
| /* 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. */ |
| |
| /* 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 |
| |
| /* 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) ; FLAG_RETURNS_128BITS |
| stfd f1,0(r30) |
| stfd f2,FPR_SIZE(r30) |
| b L(done_return_value) |
| |
| L(fd_return_value): |
| /* Do we have double to store? */ |
| bf 28,L(float_return_value) |
| stfd f1,0(r30) |
| b L(done_return_value) |
| |
| L(float_return_value): |
| /* We only have a float to store. */ |
| 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 |
| .globl _ffi_call_AIX |
| .align 2 |
| _ffi_call_AIX: |
| blr |
| /* END(_ffi_call_AIX) */ |
| |
| /* EH stuff. */ |
| |
| #define EH_DATA_ALIGN_FACT MODE_CHOICE(0x7c,0x78) |
| |
| .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 |
| LSCIE1: |
| .long 0x0 ; CIE Identifier Tag |
| .byte 0x1 ; CIE Version |
| .ascii "zR\0" ; CIE Augmentation |
| .byte 0x1 ; uleb128 0x1; CIE Code 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 0x10 ; FDE Encoding (pcrel) |
| .byte 0xc ; DW_CFA_def_cfa |
| .byte 0x1 ; uleb128 0x1 |
| .byte 0x0 ; uleb128 0x0 |
| .align LOG2_GPR_BYTES |
| LECIE1: |
| |
| .globl _ffi_call_DARWIN.eh |
| _ffi_call_DARWIN.eh: |
| LSFDE1: |
| .set L$set$1,LEFDE1-LASFDE1 |
| .long L$set$1 ; FDE Length |
| LASFDE1: |
| .long LASFDE1-EH_frame1 ; FDE CIE offset |
| .g_long Lstartcode-. ; FDE initial location |
| .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-Lstartcode |
| .long L$set$4 |
| .byte 0xd ; DW_CFA_def_cfa_register |
| .byte 0x08 ; uleb128 0x08 |
| .byte 0x4 ; DW_CFA_advance_loc4 |
| .set L$set$5,LCFI1-LCFI0 |
| .long L$set$5 |
| .byte 0x11 ; DW_CFA_offset_extended_sf |
| .byte 0x41 ; uleb128 0x41 |
| .byte 0x7e ; sleb128 -2 |
| .byte 0x9f ; DW_CFA_offset, column 0x1f |
| .byte 0x1 ; uleb128 0x1 |
| .byte 0x9e ; DW_CFA_offset, column 0x1e |
| .byte 0x2 ; uleb128 0x2 |
| .byte 0x9d ; DW_CFA_offset, column 0x1d |
| .byte 0x3 ; uleb128 0x3 |
| .byte 0x9c ; DW_CFA_offset, column 0x1c |
| .byte 0x4 ; uleb128 0x4 |
| .byte 0x4 ; DW_CFA_advance_loc4 |
| .set L$set$6,LCFI2-LCFI1 |
| .long L$set$6 |
| .byte 0xd ; DW_CFA_def_cfa_register |
| .byte 0x1c ; uleb128 0x1c |
| .align LOG2_GPR_BYTES |
| LEFDE1: |
| .align 1 |
| |
