/
githubmirror
/
node
Обзор
Документация
Войти
/
githubmirror
/
node
Код
Запросы
0
Пакеты
0
Релизы
0
Аналитика
Безопасность
main
deps/libffi/src/powerpc/darwin_closure.S
552 строки
16 KB
Node.js GitHub Bot
deps: update libffi to 3.8.0
11 авг 2026, 03:35
Не верифицирован
11 авг 2026, 03:35
01f2018
Код
Авторство
О чём код?
/* ----------------------------------------------------------------------- darwin_closure.S - Copyright (c) 2002, 2003, 2004, 2010, Free Software Foundation, Inc. based on ppc_closure.S 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 #define L(x) x #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) ; ... 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" .machine machine_choice .text .globl _ffi_closure_ASM .align LOG2_GPR_BYTES _ffi_closure_ASM: LFB1: Lstartcode: mflr r0 /* extract return address */ sg r0,SAVED_LR_OFFSET(r1) /* save the return address */ LCFI0: 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) */ /* 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 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 /* Now load up the pointer to the result storage. */ addi r4,r1,(SAVE_SIZE-RESULT_BYTES) /* Now load up the pointer to the saved gpr registers. */ addi r5,r1,PARENT_PARM_BASE /* Now load up the pointer to the saved fpr registers. */ addi r6,r1,FP_SAVE_BASE /* Make the call. */ bl BLCLS_HELP /* r3 now holds a small PPC_LD_* jump-table index (see the PPC_LD_* defines in ffi_darwin.c), not an ffi_type* as this file previously assumed: ffi_closure_helper_common cannot return both an ffi_type* and the dispatch index through r3, so it returns the index. The helper has already intercepted by-reference struct returns (writing the result to the caller`s buffer and returning PPC_LD_NONE); for a by-value struct return it returns PPC_LD_STRUCT and stashes cif->rtype in the first parameter-save slot, which the PPC_LD_STRUCT fragment below recovers. */ addi r5,r1,(SAVE_SIZE-RESULT_BYTES) /* Our return value 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 first. */ .align 4 nop nop nop Lget_ret_type0_addr: blrl /* The fragments below are indexed by the PPC_LD_* return code that ffi_closure_helper_common handed back in r3, so their order must match the PPC_LD_* values in ffi_darwin.c. Each is exactly 16 bytes (four instructions), except the final PPC_LD_STRUCT fragment. */ /* case PPC_LD_NONE (void, or a struct returned by reference) */ Lret_type0: b Lfinish nop nop nop /* case PPC_LD_R3 (one GPR: int, pointer, and on ppc64 also 64-bit ints) */ Lret_type1: lg r3,0(r5) b Lfinish nop nop /* case PPC_LD_R3R4 (two GPRs: the 32-bit ABI`s 64-bit integer) */ Lret_type2: #if defined(__ppc64__) lg r3,0(r5) lg r4,8(r5) #else lwz r3,0(r5) lwz r4,4(r5) #endif b Lfinish nop /* case PPC_LD_F32 */ Lret_type3: lfs f1,0(r5) b Lfinish nop nop /* case PPC_LD_F64 */ Lret_type4: lfd f1,0(r5) b Lfinish nop nop /* case PPC_LD_F128 (128-bit long double: two doubles) */ Lret_type5: lfd f1,0(r5) lfd f2,8(r5) b Lfinish nop /* case PPC_LD_U8 */ Lret_type6: #if defined(__ppc64__) lbz r3,7(r5) #else lbz r3,3(r5) #endif b Lfinish nop nop /* case PPC_LD_S8 */ Lret_type7: #if defined(__ppc64__) lbz r3,7(r5) #else lbz r3,3(r5) #endif extsb r3,r3 b Lfinish nop /* case PPC_LD_U16 */ Lret_type8: #if defined(__ppc64__) lhz r3,6(r5) #else lhz r3,2(r5) #endif b Lfinish nop nop /* case PPC_LD_S16 */ Lret_type9: #if defined(__ppc64__) lha r3,6(r5) #else lha r3,2(r5) #endif b Lfinish nop nop #if defined(__ppc64__) /* case PPC_LD_U32 (ppc64 only; the 32-bit ABI aliases U32 to PPC_LD_R3) */ Lret_type10: lwz r3,4(r5) b Lfinish nop nop /* case PPC_LD_S32 (ppc64 only; the 32-bit ABI aliases S32 to PPC_LD_R3) */ Lret_type11: lwa r3,4(r5) b Lfinish nop nop #endif /* case PPC_LD_STRUCT (a by-value struct return). This is the final, variable-length fragment, so it need not be padded to 16 bytes. The helper stashed cif->rtype in the first parameter-save slot (see ffi_darwin.c), because the small dispatch index in r3 left no room for it. */ Lret_type_struct: lg r6,PARENT_PARM_BASE(r1) ; cif->rtype sg r6,LINKAGE_SIZE(r1) ; where the struct code below expects it lg r0,0(r6) ; size => r0 #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 lg r3,0(r5) ; a <=4-byte struct, returned in r3 b Lfinish #endif #if defined(__ppc64__) Lsmallstruct: beq Lfour ; continuation of Lret_type_struct. 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,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) */ /* 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) .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_closure_ASM.eh _ffi_closure_ASM.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$2,LFE1-Lstartcode .g_long L$set$2 ; 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 EH_FRAME_OFFSETA,EH_FRAME_OFFSETB ; uleb128 176,1/190,3 .byte 0x4 ; DW_CFA_advance_loc4 .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: .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,"L1$spb" "L1$spb": mflr r11 addis r11,r11,ha16(L_ffi_closure_helper_DARWIN$lazy_ptr-"L1$spb") mtlr r0 lwzu r12,lo16(L_ffi_closure_helper_DARWIN$lazy_ptr-"L1$spb")(r11) mtctr r12 bctr .lazy_symbol_pointer L_ffi_closure_helper_DARWIN$lazy_ptr: .indirect_symbol _ffi_closure_helper_DARWIN .g_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,"L2$spb" "L2$spb": mflr r11 addis r11,r11,ha16(L_darwin64_struct_ret_by_value_p$lazy_ptr-"L2$spb") mtlr r0 lwzu r12,lo16(L_darwin64_struct_ret_by_value_p$lazy_ptr-"L2$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 .g_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,"L3$spb" "L3$spb": mflr r11 addis r11,r11,ha16(L_darwin64_pass_struct_floats$lazy_ptr-"L3$spb") mtlr r0 lwzu r12,lo16(L_darwin64_pass_struct_floats$lazy_ptr-"L3$spb")(r11) mtctr r12 bctr .lazy_symbol_pointer L_darwin64_pass_struct_floats$lazy_ptr: .indirect_symbol _darwin64_pass_struct_floats .g_long dyld_stub_binding_helper # endif #endif