| /* ----------------------------------------------------------------------- |
| sysv.S - Copyright (c) 1998, 2008, 2011 Red Hat, Inc. |
| Copyright (c) 2011 Plausible Labs Cooperative, Inc. |
| |
| ARM Foreign Function Interface |
| |
| 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 AUTHORS OR COPYRIGHT |
| HOLDERS 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 |
| #include <fficonfig.h> |
| #include <ffi.h> |
| #include <ffi_cfi.h> |
| #include "internal.h" |
| |
| /* GCC 4.8 provides __ARM_ARCH; construct it otherwise. */ |
| #ifndef __ARM_ARCH |
| # if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) \ |
| || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) \ |
| || defined(__ARM_ARCH_7EM__) |
| # define __ARM_ARCH 7 |
| # elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) \ |
| || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) \ |
| || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) \ |
| || defined(__ARM_ARCH_6M__) |
| # define __ARM_ARCH 6 |
| # elif defined(__ARM_ARCH_5__) || defined(__ARM_ARCH_5T__) \ |
| || defined(__ARM_ARCH_5E__) || defined(__ARM_ARCH_5TE__) \ |
| || defined(__ARM_ARCH_5TEJ__) |
| # define __ARM_ARCH 5 |
| # else |
| # define __ARM_ARCH 4 |
| # endif |
| #endif |
| |
| /* Conditionally compile unwinder directives. */ |
| .macro UNWIND text:vararg |
| #ifdef __ARM_EABI__ |
| \text |
| #endif |
| .endm |
| #if defined(HAVE_AS_CFI_PSEUDO_OP) && defined(__ARM_EABI__) |
| .cfi_sections .debug_frame |
| #endif |
| |
| #define CONCAT(a, b) CONCAT2(a, b) |
| #define CONCAT2(a, b) a ## b |
| |
| #ifdef __USER_LABEL_PREFIX__ |
| # define CNAME(X) CONCAT (__USER_LABEL_PREFIX__, X) |
| #else |
| # define CNAME(X) X |
| #endif |
| #ifdef __ELF__ |
| # define SIZE(X) .size CNAME(X), . - CNAME(X) |
| # define TYPE(X, Y) .type CNAME(X), Y |
| #else |
| # define SIZE(X) |
| # define TYPE(X, Y) |
| #endif |
| |
| #define ARM_FUNC_START(name, gl) \ |
| .align 3; \ |
| .ifne gl; .globl CNAME(name); FFI_HIDDEN(CNAME(name)); .endif; \ |
| TYPE(name, %function); \ |
| CNAME(name): |
| |
| #define ARM_FUNC_END(name) \ |
| SIZE(name) |
| |
| /* Aid in defining a jump table with 8 bytes between entries. */ |
| .macro E index |
| .if . - 0b - 8*\index |
| .error "type table out of sync" |
| .endif |
| .endm |
| |
| .text |
| .syntax unified |
| .arm |
| |
| /* We require interworking on LDM, which implies ARMv5T, |
| which implies the existance of BLX. */ |
| .arch armv5t |
| |
| /* Note that we use STC and LDC to encode VFP instructions, |
| so that we do not need ".fpu vfp", nor get that added to |
| the object file attributes. These will not be executed |
| unless the FFI_VFP abi is used. */ |
| |
| @ r0: stack |
| @ r1: frame |
| @ r2: fn |
| @ r3: vfp_used |
| |
| ARM_FUNC_START(ffi_call_VFP, 1) |
| UNWIND .fnstart |
| cfi_startproc |
| |
| cmp r3, #3 @ load only d0 if possible |
| ldcle p11, cr0, [r0] @ vldrle d0, [sp] |
| ldcgt p11, cr0, [r0], {16} @ vldmgt sp, {d0-d7} |
| add r0, r0, #64 @ discard the vfp register args |
| /* FALLTHRU */ |
| ARM_FUNC_END(ffi_call_VFP) |
| |
| ARM_FUNC_START(ffi_call_SYSV, 1) |
| stm r1, {fp, lr} |
| mov fp, r1 |
| |
| @ This is a bit of a lie wrt the origin of the unwind info, but |
| @ now we've got the usual frame pointer and two saved registers. |
| UNWIND .save {fp,lr} |
| UNWIND .setfp fp, sp |
| cfi_def_cfa(fp, 8) |
| cfi_rel_offset(fp, 0) |
| cfi_rel_offset(lr, 4) |
| |
| mov sp, r0 @ install the stack pointer |
| mov lr, r2 @ move the fn pointer out of the way |
| ldr ip, [fp, #16] @ install the static chain |
| ldmia sp!, {r0-r3} @ move first 4 parameters in registers. |
| blx lr @ call fn |
| |
| @ Load r2 with the pointer to storage for the return value |
| @ Load r3 with the return type code |
| ldr r2, [fp, #8] |
| ldr r3, [fp, #12] |
| |
| @ Deallocate the stack with the arguments. |
| mov sp, fp |
| cfi_def_cfa_register(sp) |
| |
| @ Store values stored in registers. |
| .align 3 |
| add pc, pc, r3, lsl #3 |
| nop |
| 0: |
| E ARM_TYPE_VFP_S |
| stc p10, cr0, [r2] @ vstr s0, [r2] |
| pop {fp,pc} |
| E ARM_TYPE_VFP_D |
| stc p11, cr0, [r2] @ vstr d0, [r2] |
| pop {fp,pc} |
| E ARM_TYPE_VFP_N |
| stc p11, cr0, [r2], {8} @ vstm r2, {d0-d3} |
| pop {fp,pc} |
| E ARM_TYPE_INT64 |
| str r1, [r2, #4] |
| nop |
| E ARM_TYPE_INT |
| str r0, [r2] |
| pop {fp,pc} |
| E ARM_TYPE_VOID |
| pop {fp,pc} |
| nop |
| E ARM_TYPE_STRUCT |
| pop {fp,pc} |
| |
| cfi_endproc |
| UNWIND .fnend |
| ARM_FUNC_END(ffi_call_SYSV) |
| |
| |
| /* |
| int ffi_closure_inner_* (cif, fun, user_data, frame) |
| */ |
| |
| ARM_FUNC_START(ffi_go_closure_SYSV, 1) |
| cfi_startproc |
| stmdb sp!, {r0-r3} @ save argument regs |
| cfi_adjust_cfa_offset(16) |
| ldr r0, [ip, #4] @ load cif |
| ldr r1, [ip, #8] @ load fun |
| mov r2, ip @ load user_data |
| b 0f |
| cfi_endproc |
| ARM_FUNC_END(ffi_go_closure_SYSV) |
| |
| ARM_FUNC_START(ffi_closure_SYSV, 1) |
| UNWIND .fnstart |
| cfi_startproc |
| stmdb sp!, {r0-r3} @ save argument regs |
| cfi_adjust_cfa_offset(16) |
| ldr r0, [ip, #FFI_TRAMPOLINE_SIZE] @ load cif |
| ldr r1, [ip, #FFI_TRAMPOLINE_SIZE+4] @ load fun |
| ldr r2, [ip, #FFI_TRAMPOLINE_SIZE+8] @ load user_data |
| 0: |
| add ip, sp, #16 @ compute entry sp |
| sub sp, sp, #64+32 @ allocate frame |
| cfi_adjust_cfa_offset(64+32) |
| stmdb sp!, {ip,lr} |
| |
| /* Remember that EABI unwind info only applies at call sites. |
| We need do nothing except note the save of the stack pointer |
| and the link registers. */ |
| UNWIND .save {sp,lr} |
| cfi_adjust_cfa_offset(8) |
| cfi_rel_offset(lr, 4) |
| |
| add r3, sp, #8 @ load frame |
| bl CNAME(ffi_closure_inner_SYSV) |
| |
| @ Load values returned in registers. |
| add r2, sp, #8+64 @ load result |
| adr r3, CNAME(ffi_closure_ret) |
| add pc, r3, r0, lsl #3 |
| cfi_endproc |
| UNWIND .fnend |
| ARM_FUNC_END(ffi_closure_SYSV) |
| |
| ARM_FUNC_START(ffi_go_closure_VFP, 1) |
| cfi_startproc |
| stmdb sp!, {r0-r3} @ save argument regs |
| cfi_adjust_cfa_offset(16) |
| ldr r0, [ip, #4] @ load cif |
| ldr r1, [ip, #8] @ load fun |
| mov r2, ip @ load user_data |
| b 0f |
| cfi_endproc |
| ARM_FUNC_END(ffi_go_closure_VFP) |
| |
| ARM_FUNC_START(ffi_closure_VFP, 1) |
| UNWIND .fnstart |
| cfi_startproc |
| stmdb sp!, {r0-r3} @ save argument regs |
| cfi_adjust_cfa_offset(16) |
| ldr r0, [ip, #FFI_TRAMPOLINE_SIZE] @ load cif |
| ldr r1, [ip, #FFI_TRAMPOLINE_SIZE+4] @ load fun |
| ldr r2, [ip, #FFI_TRAMPOLINE_SIZE+8] @ load user_data |
| 0: |
| add ip, sp, #16 |
| sub sp, sp, #64+32 @ allocate frame |
| cfi_adjust_cfa_offset(64+32) |
| stc p11, cr0, [sp], {16} @ vstm sp, {d0-d7} |
| stmdb sp!, {ip,lr} |
| |
| /* See above. */ |
| UNWIND .save {sp,lr} |
| cfi_adjust_cfa_offset(8) |
| cfi_rel_offset(lr, 4) |
| |
| add r3, sp, #8 @ load frame |
| bl CNAME(ffi_closure_inner_VFP) |
| |
| @ Load values returned in registers. |
| add r2, sp, #8+64 @ load result |
| adr r3, CNAME(ffi_closure_ret) |
| add pc, r3, r0, lsl #3 |
| cfi_endproc |
| UNWIND .fnend |
| ARM_FUNC_END(ffi_closure_VFP) |
| |
| /* Load values returned in registers for both closure entry points. |
| Note that we use LDM with SP in the register set. This is deprecated |
| by ARM, but not yet unpredictable. */ |
| |
| ARM_FUNC_START(ffi_closure_ret, 0) |
| cfi_startproc |
| cfi_rel_offset(sp, 0) |
| cfi_rel_offset(lr, 4) |
| 0: |
| E ARM_TYPE_VFP_S |
| ldc p10, cr0, [r2] @ vldr s0, [r2] |
| ldm sp, {sp,pc} |
| E ARM_TYPE_VFP_D |
| ldc p11, cr0, [r2] @ vldr d0, [r2] |
| ldm sp, {sp,pc} |
| E ARM_TYPE_VFP_N |
| ldc p11, cr0, [r2], {8} @ vldm r2, {d0-d3} |
| ldm sp, {sp,pc} |
| E ARM_TYPE_INT64 |
| ldr r1, [r2, #4] |
| nop |
| E ARM_TYPE_INT |
| ldr r0, [r2] |
| ldm sp, {sp,pc} |
| E ARM_TYPE_VOID |
| ldm sp, {sp,pc} |
| nop |
| E ARM_TYPE_STRUCT |
| ldm sp, {sp,pc} |
| cfi_endproc |
| ARM_FUNC_END(ffi_closure_ret) |
| |
| #if FFI_EXEC_TRAMPOLINE_TABLE |
| |
| /* ??? The iOS support should be updated. The first insn used to |
| be STMFD, but that's been moved into ffi_closure_SYSV. If the |
| writable page is put after this one we can make use of the |
| pc+8 feature of the architecture. We can also reduce the size |
| of the thunk to 8 and pack more of these into the page. |
| |
| In the meantime, simply replace the STMFD with a NOP so as to |
| keep all the magic numbers the same within ffi.c. */ |
| |
| .align 12 |
| ARM_FUNC_START(ffi_closure_trampoline_table_page) |
| .rept 4096 / 12 |
| nop |
| ldr ip, [pc, #-4092] |
| ldr pc, [pc, #-4092] |
| .endr |
| |
| #else |
| |
| ARM_FUNC_START(ffi_arm_trampoline, 1) |
| 0: adr ip, 0b |
| ldr pc, 1f |
| 1: .long 0 |
| ARM_FUNC_END(ffi_arm_trampoline) |
| |
| #endif /* FFI_EXEC_TRAMPOLINE_TABLE */ |
| |
| #if defined __ELF__ && defined __linux__ |
| .section .note.GNU-stack,"",%progbits |
| #endif |
