/* Copyright (c) 2009, 2010, 2011, 2012 ARM Ltd.
|
|
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>
|
|
#ifdef HAVE_MACHINE_ASM_H
|
#include <machine/asm.h>
|
#else
|
#ifdef __USER_LABEL_PREFIX__
|
#define CONCAT1(a, b) CONCAT2(a, b)
|
#define CONCAT2(a, b) a ## b
|
|
/* Use the right prefix for global labels. */
|
#define CNAME(x) CONCAT1 (__USER_LABEL_PREFIX__, x)
|
#else
|
#define CNAME(x) x
|
#endif
|
#endif
|
|
#define cfi_adjust_cfa_offset(off) .cfi_adjust_cfa_offset off
|
#define cfi_rel_offset(reg, off) .cfi_rel_offset reg, off
|
#define cfi_restore(reg) .cfi_restore reg
|
#define cfi_def_cfa_register(reg) .cfi_def_cfa_register reg
|
|
.text
|
.globl CNAME(ffi_call_SYSV)
|
#ifdef __ELF__
|
.type CNAME(ffi_call_SYSV), #function
|
#endif
|
#ifdef __APPLE__
|
.align 2
|
#endif
|
|
/* ffi_call_SYSV()
|
|
Create a stack frame, setup an argument context, call the callee
|
and extract the result.
|
|
The maximum required argument stack size is provided,
|
ffi_call_SYSV() allocates that stack space then calls the
|
prepare_fn to populate register context and stack. The
|
argument passing registers are loaded from the register
|
context and the callee called, on return the register passing
|
register are saved back to the context. Our caller will
|
extract the return value from the final state of the saved
|
register context.
|
|
Prototype:
|
|
extern unsigned
|
ffi_call_SYSV (void (*)(struct call_context *context, unsigned char *,
|
extended_cif *),
|
struct call_context *context,
|
extended_cif *,
|
size_t required_stack_size,
|
void (*fn)(void));
|
|
Therefore on entry we have:
|
|
x0 prepare_fn
|
x1 &context
|
x2 &ecif
|
x3 bytes
|
x4 fn
|
|
This function uses the following stack frame layout:
|
|
==
|
saved x30(lr)
|
x29(fp)-> saved x29(fp)
|
saved x24
|
saved x23
|
saved x22
|
sp' -> saved x21
|
...
|
sp -> (constructed callee stack arguments)
|
==
|
|
Voila! */
|
|
#define ffi_call_SYSV_FS (8 * 4)
|
|
.cfi_startproc
|
CNAME(ffi_call_SYSV):
|
stp x29, x30, [sp, #-16]!
|
cfi_adjust_cfa_offset (16)
|
cfi_rel_offset (x29, 0)
|
cfi_rel_offset (x30, 8)
|
|
mov x29, sp
|
cfi_def_cfa_register (x29)
|
sub sp, sp, #ffi_call_SYSV_FS
|
|
stp x21, x22, [sp, #0]
|
cfi_rel_offset (x21, 0 - ffi_call_SYSV_FS)
|
cfi_rel_offset (x22, 8 - ffi_call_SYSV_FS)
|
|
stp x23, x24, [sp, #16]
|
cfi_rel_offset (x23, 16 - ffi_call_SYSV_FS)
|
cfi_rel_offset (x24, 24 - ffi_call_SYSV_FS)
|
|
mov x21, x1
|
mov x22, x2
|
mov x24, x4
|
|
/* Allocate the stack space for the actual arguments, many
|
arguments will be passed in registers, but we assume
|
worst case and allocate sufficient stack for ALL of
|
the arguments. */
|
sub sp, sp, x3
|
|
/* unsigned (*prepare_fn) (struct call_context *context,
|
unsigned char *stack, extended_cif *ecif);
|
*/
|
mov x23, x0
|
mov x0, x1
|
mov x1, sp
|
/* x2 already in place */
|
blr x23
|
|
/* Preserve the flags returned. */
|
mov x23, x0
|
|
/* Figure out if we should touch the vector registers. */
|
tbz x23, #AARCH64_FFI_WITH_V_BIT, 1f
|
|
/* Load the vector argument passing registers. */
|
ldp q0, q1, [x21, #8*32 + 0]
|
ldp q2, q3, [x21, #8*32 + 32]
|
ldp q4, q5, [x21, #8*32 + 64]
|
ldp q6, q7, [x21, #8*32 + 96]
|
1:
|
/* Load the core argument passing registers. */
|
ldp x0, x1, [x21, #0]
|
ldp x2, x3, [x21, #16]
|
ldp x4, x5, [x21, #32]
|
ldp x6, x7, [x21, #48]
|
|
/* Don't forget x8 which may be holding the address of a return buffer.
|
*/
|
ldr x8, [x21, #8*8]
|
|
blr x24
|
|
/* Save the core argument passing registers. */
|
stp x0, x1, [x21, #0]
|
stp x2, x3, [x21, #16]
|
stp x4, x5, [x21, #32]
|
stp x6, x7, [x21, #48]
|
|
/* Note nothing useful ever comes back in x8! */
|
|
/* Figure out if we should touch the vector registers. */
|
tbz x23, #AARCH64_FFI_WITH_V_BIT, 1f
|
|
/* Save the vector argument passing registers. */
|
stp q0, q1, [x21, #8*32 + 0]
|
stp q2, q3, [x21, #8*32 + 32]
|
stp q4, q5, [x21, #8*32 + 64]
|
stp q6, q7, [x21, #8*32 + 96]
|
1:
|
/* All done, unwind our stack frame. */
|
ldp x21, x22, [x29, # - ffi_call_SYSV_FS]
|
cfi_restore (x21)
|
cfi_restore (x22)
|
|
ldp x23, x24, [x29, # - ffi_call_SYSV_FS + 16]
|
cfi_restore (x23)
|
cfi_restore (x24)
|
|
mov sp, x29
|
cfi_def_cfa_register (sp)
|
|
ldp x29, x30, [sp], #16
|
cfi_adjust_cfa_offset (-16)
|
cfi_restore (x29)
|
cfi_restore (x30)
|
|
ret
|
|
.cfi_endproc
|
#ifdef __ELF__
|
.size CNAME(ffi_call_SYSV), .-CNAME(ffi_call_SYSV)
|
#endif
|
|
#define ffi_closure_SYSV_FS (8 * 2 + AARCH64_CALL_CONTEXT_SIZE)
|
|
/* ffi_closure_SYSV
|
|
Closure invocation glue. This is the low level code invoked directly by
|
the closure trampoline to setup and call a closure.
|
|
On entry x17 points to a struct trampoline_data, x16 has been clobbered
|
all other registers are preserved.
|
|
We allocate a call context and save the argument passing registers,
|
then invoked the generic C ffi_closure_SYSV_inner() function to do all
|
the real work, on return we load the result passing registers back from
|
the call context.
|
|
On entry
|
|
extern void
|
ffi_closure_SYSV (struct trampoline_data *);
|
|
struct trampoline_data
|
{
|
UINT64 *ffi_closure;
|
UINT64 flags;
|
};
|
|
This function uses the following stack frame layout:
|
|
==
|
saved x30(lr)
|
x29(fp)-> saved x29(fp)
|
saved x22
|
saved x21
|
...
|
sp -> call_context
|
==
|
|
Voila! */
|
|
.text
|
.globl CNAME(ffi_closure_SYSV)
|
#ifdef __APPLE__
|
.align 2
|
#endif
|
.cfi_startproc
|
CNAME(ffi_closure_SYSV):
|
stp x29, x30, [sp, #-16]!
|
cfi_adjust_cfa_offset (16)
|
cfi_rel_offset (x29, 0)
|
cfi_rel_offset (x30, 8)
|
|
mov x29, sp
|
cfi_def_cfa_register (x29)
|
|
sub sp, sp, #ffi_closure_SYSV_FS
|
|
stp x21, x22, [x29, #-16]
|
cfi_rel_offset (x21, -16)
|
cfi_rel_offset (x22, -8)
|
|
/* Load x21 with &call_context. */
|
mov x21, sp
|
/* Preserve our struct trampoline_data * */
|
mov x22, x17
|
|
/* Save the rest of the argument passing registers. */
|
stp x0, x1, [x21, #0]
|
stp x2, x3, [x21, #16]
|
stp x4, x5, [x21, #32]
|
stp x6, x7, [x21, #48]
|
/* Don't forget we may have been given a result scratch pad address.
|
*/
|
str x8, [x21, #64]
|
|
/* Figure out if we should touch the vector registers. */
|
ldr x0, [x22, #8]
|
tbz x0, #AARCH64_FFI_WITH_V_BIT, 1f
|
|
/* Save the argument passing vector registers. */
|
stp q0, q1, [x21, #8*32 + 0]
|
stp q2, q3, [x21, #8*32 + 32]
|
stp q4, q5, [x21, #8*32 + 64]
|
stp q6, q7, [x21, #8*32 + 96]
|
1:
|
/* Load &ffi_closure.. */
|
ldr x0, [x22, #0]
|
mov x1, x21
|
/* Compute the location of the stack at the point that the
|
trampoline was called. */
|
add x2, x29, #16
|
|
bl CNAME(ffi_closure_SYSV_inner)
|
|
/* Figure out if we should touch the vector registers. */
|
ldr x0, [x22, #8]
|
tbz x0, #AARCH64_FFI_WITH_V_BIT, 1f
|
|
/* Load the result passing vector registers. */
|
ldp q0, q1, [x21, #8*32 + 0]
|
ldp q2, q3, [x21, #8*32 + 32]
|
ldp q4, q5, [x21, #8*32 + 64]
|
ldp q6, q7, [x21, #8*32 + 96]
|
1:
|
/* Load the result passing core registers. */
|
ldp x0, x1, [x21, #0]
|
ldp x2, x3, [x21, #16]
|
ldp x4, x5, [x21, #32]
|
ldp x6, x7, [x21, #48]
|
/* Note nothing useful is returned in x8. */
|
|
/* We are done, unwind our frame. */
|
ldp x21, x22, [x29, #-16]
|
cfi_restore (x21)
|
cfi_restore (x22)
|
|
mov sp, x29
|
cfi_def_cfa_register (sp)
|
|
ldp x29, x30, [sp], #16
|
cfi_adjust_cfa_offset (-16)
|
cfi_restore (x29)
|
cfi_restore (x30)
|
|
ret
|
.cfi_endproc
|
#ifdef __ELF__
|
.size CNAME(ffi_closure_SYSV), .-CNAME(ffi_closure_SYSV)
|
#endif
|
