samsonium/libffi
1
0
Fork 0
mirror of https://github.com/partic2/libffi synced 2026-11-11 02:27:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #222 from freakboy3742/t181

Browse Source 
Fixed #181 -- Corrected problems with ARMv7 build under iOS.
This commit is contained in:
Anthony Green
2016-01-02 20:03:41 -05:00
parent 8005600a92 6a3a6acd9f
commit 6ba2a49e22
7 changed files with 412 additions and 561 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/aarch64/ffi.c
+12 -235
View File
@@ -22,6 +22,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
#include <fficonfig.h>
#include <ffi.h> #include <ffi.h>
#include <ffi_common.h> #include <ffi_common.h>
#include "internal.h" #include "internal.h"
@@ -70,6 +71,14 @@ ffi_clear_cache (void *start, void *end)
#endif #endif
} }
#if FFI_EXEC_TRAMPOLINE_TABLE
#ifdef __MACH__
#include <mach/vm_param.h>
#endif
#endif
/* A subroutine of is_vfp_type. Given a structure type, return the type code /* A subroutine of is_vfp_type. Given a structure type, return the type code
of the first non-structure element. Recurse for structure elements. of the first non-structure element. Recurse for structure elements.
Return -1 if the structure is in fact empty, i.e. no nested elements. */ Return -1 if the structure is in fact empty, i.e. no nested elements. */
@@ -725,240 +734,6 @@ ffi_call_go (ffi_cif *cif, void (*fn) (void), void *rvalue,
extern void ffi_closure_SYSV (void) FFI_HIDDEN; extern void ffi_closure_SYSV (void) FFI_HIDDEN;
extern void ffi_closure_SYSV_V (void) FFI_HIDDEN; extern void ffi_closure_SYSV_V (void) FFI_HIDDEN;
#if FFI_EXEC_TRAMPOLINE_TABLE
#include <mach/mach.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
extern void *ffi_closure_trampoline_table_page;
typedef struct ffi_trampoline_table ffi_trampoline_table;
typedef struct ffi_trampoline_table_entry ffi_trampoline_table_entry;
struct ffi_trampoline_table
{
/* contiguous writable and executable pages */
vm_address_t config_page;
vm_address_t trampoline_page;
/* free list tracking */
uint16_t free_count;
ffi_trampoline_table_entry *free_list;
ffi_trampoline_table_entry *free_list_pool;
ffi_trampoline_table *prev;
ffi_trampoline_table *next;
};
struct ffi_trampoline_table_entry
{
void *(*trampoline) ();
ffi_trampoline_table_entry *next;
};
/* The trampoline configuration is placed a page prior to the trampoline's entry point */
#define FFI_TRAMPOLINE_CODELOC_CONFIG(codeloc) ((void **) (((uint8_t *) codeloc) - PAGE_SIZE));
/* Total number of trampolines that fit in one trampoline table */
#define FFI_TRAMPOLINE_COUNT (PAGE_SIZE / FFI_TRAMPOLINE_SIZE)
static pthread_mutex_t ffi_trampoline_lock = PTHREAD_MUTEX_INITIALIZER;
static ffi_trampoline_table *ffi_trampoline_tables = NULL;
static ffi_trampoline_table *
ffi_trampoline_table_alloc ()
{
ffi_trampoline_table *table = NULL;
/* Loop until we can allocate two contiguous pages */
while (table == NULL)
{
vm_address_t config_page = 0x0;
kern_return_t kt;
/* Try to allocate two pages */
kt =
vm_allocate (mach_task_self (), &config_page, PAGE_SIZE * 2,
VM_FLAGS_ANYWHERE);
if (kt != KERN_SUCCESS)
{
fprintf (stderr, "vm_allocate() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
break;
}
/* Now drop the second half of the allocation to make room for the trampoline table */
vm_address_t trampoline_page = config_page + PAGE_SIZE;
kt = vm_deallocate (mach_task_self (), trampoline_page, PAGE_SIZE);
if (kt != KERN_SUCCESS)
{
fprintf (stderr, "vm_deallocate() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
break;
}
/* Remap the trampoline table to directly follow the config page */
vm_prot_t cur_prot;
vm_prot_t max_prot;
kt =
vm_remap (mach_task_self (), &trampoline_page, PAGE_SIZE, 0x0, FALSE,
mach_task_self (),
(vm_address_t) & ffi_closure_trampoline_table_page, FALSE,
&cur_prot, &max_prot, VM_INHERIT_SHARE);
/* If we lost access to the destination trampoline page, drop our config allocation mapping and retry */
if (kt != KERN_SUCCESS)
{
/* Log unexpected failures */
if (kt != KERN_NO_SPACE)
{
fprintf (stderr, "vm_remap() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
}
vm_deallocate (mach_task_self (), config_page, PAGE_SIZE);
continue;
}
/* We have valid trampoline and config pages */
table = calloc (1, sizeof (ffi_trampoline_table));
table->free_count = FFI_TRAMPOLINE_COUNT;
table->config_page = config_page;
table->trampoline_page = trampoline_page;
/* Create and initialize the free list */
table->free_list_pool =
calloc (FFI_TRAMPOLINE_COUNT, sizeof (ffi_trampoline_table_entry));
uint16_t i;
for (i = 0; i < table->free_count; i++)
{
ffi_trampoline_table_entry *entry = &table->free_list_pool[i];
entry->trampoline =
(void *) (table->trampoline_page + (i * FFI_TRAMPOLINE_SIZE));
if (i < table->free_count - 1)
entry->next = &table->free_list_pool[i + 1];
}
table->free_list = table->free_list_pool;
}
return table;
}
void *
ffi_closure_alloc (size_t size, void **code)
{
/* Create the closure */
ffi_closure *closure = malloc (size);
if (closure == NULL)
return NULL;
pthread_mutex_lock (&ffi_trampoline_lock);
/* Check for an active trampoline table with available entries. */
ffi_trampoline_table *table = ffi_trampoline_tables;
if (table == NULL || table->free_list == NULL)
{
table = ffi_trampoline_table_alloc ();
if (table == NULL)
{
free (closure);
return NULL;
}
/* Insert the new table at the top of the list */
table->next = ffi_trampoline_tables;
if (table->next != NULL)
table->next->prev = table;
ffi_trampoline_tables = table;
}
/* Claim the free entry */
ffi_trampoline_table_entry *entry = ffi_trampoline_tables->free_list;
ffi_trampoline_tables->free_list = entry->next;
ffi_trampoline_tables->free_count--;
entry->next = NULL;
pthread_mutex_unlock (&ffi_trampoline_lock);
/* Initialize the return values */
*code = entry->trampoline;
closure->trampoline_table = table;
closure->trampoline_table_entry = entry;
return closure;
}
void
ffi_closure_free (void *ptr)
{
ffi_closure *closure = ptr;
pthread_mutex_lock (&ffi_trampoline_lock);
/* Fetch the table and entry references */
ffi_trampoline_table *table = closure->trampoline_table;
ffi_trampoline_table_entry *entry = closure->trampoline_table_entry;
/* Return the entry to the free list */
entry->next = table->free_list;
table->free_list = entry;
table->free_count++;
/* If all trampolines within this table are free, and at least one other table exists, deallocate
* the table */
if (table->free_count == FFI_TRAMPOLINE_COUNT
&& ffi_trampoline_tables != table)
{
/* Remove from the list */
if (table->prev != NULL)
table->prev->next = table->next;
if (table->next != NULL)
table->next->prev = table->prev;
/* Deallocate pages */
kern_return_t kt;
kt = vm_deallocate (mach_task_self (), table->config_page, PAGE_SIZE);
if (kt != KERN_SUCCESS)
fprintf (stderr, "vm_deallocate() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
kt =
vm_deallocate (mach_task_self (), table->trampoline_page, PAGE_SIZE);
if (kt != KERN_SUCCESS)
fprintf (stderr, "vm_deallocate() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
/* Deallocate free list */
free (table->free_list_pool);
free (table);
}
else if (ffi_trampoline_tables != table)
{
/* Otherwise, bump this table to the top of the list */
table->prev = NULL;
table->next = ffi_trampoline_tables;
if (ffi_trampoline_tables != NULL)
ffi_trampoline_tables->prev = table;
ffi_trampoline_tables = table;
}
pthread_mutex_unlock (&ffi_trampoline_lock);
/* Free the closure */
free (closure);
}
#endif
ffi_status ffi_status
ffi_prep_closure_loc (ffi_closure *closure, ffi_prep_closure_loc (ffi_closure *closure,
ffi_cif* cif, ffi_cif* cif,
@@ -977,9 +752,11 @@ ffi_prep_closure_loc (ffi_closure *closure,
start = ffi_closure_SYSV; start = ffi_closure_SYSV;
#if FFI_EXEC_TRAMPOLINE_TABLE #if FFI_EXEC_TRAMPOLINE_TABLE
void **config = FFI_TRAMPOLINE_CODELOC_CONFIG (codeloc); #ifdef __MACH__
void **config = (void **)((uint8_t *)codeloc - PAGE_MAX_SIZE);
config[0] = closure; config[0] = closure;
config[1] = start; config[1] = start;
#endif
#else #else
static const unsigned char trampoline[16] = { static const unsigned char trampoline[16] = {
0x90, 0x00, 0x00, 0x58, /* ldr x16, tramp+16 */ 0x90, 0x00, 0x00, 0x58, /* ldr x16, tramp+16 */
src/aarch64/ffitarget.h
+10 -3
View File
@@ -48,14 +48,21 @@ typedef enum ffi_abi
/* ---- Definitions for closures ----------------------------------------- */ /* ---- Definitions for closures ----------------------------------------- */
#define FFI_CLOSURES 1 #define FFI_CLOSURES 1
#if defined (__APPLE__) #define FFI_NATIVE_RAW_API 0
#define FFI_TRAMPOLINE_SIZE 20
#if defined (FFI_EXEC_TRAMPOLINE_TABLE) && FFI_EXEC_TRAMPOLINE_TABLE
#ifdef __MACH__
#define FFI_TRAMPOLINE_SIZE 16
#define FFI_TRAMPOLINE_CLOSURE_OFFSET 16 #define FFI_TRAMPOLINE_CLOSURE_OFFSET 16
#else
#error "No trampoline table implementation"
#endif
#else #else
#define FFI_TRAMPOLINE_SIZE 24 #define FFI_TRAMPOLINE_SIZE 24
#define FFI_TRAMPOLINE_CLOSURE_OFFSET FFI_TRAMPOLINE_SIZE #define FFI_TRAMPOLINE_CLOSURE_OFFSET FFI_TRAMPOLINE_SIZE
#endif #endif
#define FFI_NATIVE_RAW_API 0
/* ---- Internal ---- */ /* ---- Internal ---- */
src/aarch64/sysv.S
+12 -8
View File
@@ -356,16 +356,18 @@ CNAME(ffi_closure_SYSV):
#endif #endif
#if FFI_EXEC_TRAMPOLINE_TABLE #if FFI_EXEC_TRAMPOLINE_TABLE
.align 12
#ifdef __MACH__
#include <mach/vm_param.h>
.align PAGE_MAX_SHIFT
CNAME(ffi_closure_trampoline_table_page): CNAME(ffi_closure_trampoline_table_page):
.rept 16384 / FFI_TRAMPOLINE_SIZE .rept PAGE_MAX_SIZE / FFI_TRAMPOLINE_SIZE
adr x17, -16384 adr x16, -PAGE_MAX_SIZE
adr x16, -16380 ldp x17, x16, [x16]
ldr x16, [x16] br x16
ldr x17, [x17] nop /* each entry in the trampoline config page is 2*sizeof(void*) so the trampoline itself cannot be smaller that 16 bytes */
br x16
.endr .endr
.globl CNAME(ffi_closure_trampoline_table_page) .globl CNAME(ffi_closure_trampoline_table_page)
#ifdef __ELF__ #ifdef __ELF__
.type CNAME(ffi_closure_trampoline_table_page), #function .type CNAME(ffi_closure_trampoline_table_page), #function
@@ -374,6 +376,8 @@ CNAME(ffi_closure_trampoline_table_page):
#endif #endif
#endif #endif
#endif /* FFI_EXEC_TRAMPOLINE_TABLE */
#ifdef FFI_GO_CLOSURES #ifdef FFI_GO_CLOSURES
.align 4 .align 4
CNAME(ffi_go_closure_SYSV_V): CNAME(ffi_go_closure_SYSV_V):
src/arm/ffi.c
+12 -247
View File
@@ -28,11 +28,22 @@
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
----------------------------------------------------------------------- */ ----------------------------------------------------------------------- */
#include <fficonfig.h>
#include <ffi.h> #include <ffi.h>
#include <ffi_common.h> #include <ffi_common.h>
#include <stdlib.h> #include <stdlib.h>
#include "internal.h" #include "internal.h"
#if FFI_EXEC_TRAMPOLINE_TABLE
#ifdef __MACH__
#include <mach/vm_param.h>
#endif
#else
extern unsigned int ffi_arm_trampoline[2] FFI_HIDDEN;
#endif
/* Forward declares. */ /* Forward declares. */
static int vfp_type_p (const ffi_type *); static int vfp_type_p (const ffi_type *);
static void layout_vfp_args (ffi_cif *); static void layout_vfp_args (ffi_cif *);
@@ -530,252 +541,6 @@ void ffi_closure_VFP (void) FFI_HIDDEN;
void ffi_go_closure_SYSV (void) FFI_HIDDEN; void ffi_go_closure_SYSV (void) FFI_HIDDEN;
void ffi_go_closure_VFP (void) FFI_HIDDEN; void ffi_go_closure_VFP (void) FFI_HIDDEN;
#if FFI_EXEC_TRAMPOLINE_TABLE
#include <mach/mach.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
extern void *ffi_closure_trampoline_table_page;
typedef struct ffi_trampoline_table ffi_trampoline_table;
typedef struct ffi_trampoline_table_entry ffi_trampoline_table_entry;
struct ffi_trampoline_table
{
/* contiguous writable and executable pages */
vm_address_t config_page;
vm_address_t trampoline_page;
/* free list tracking */
uint16_t free_count;
ffi_trampoline_table_entry *free_list;
ffi_trampoline_table_entry *free_list_pool;
ffi_trampoline_table *prev;
ffi_trampoline_table *next;
};
struct ffi_trampoline_table_entry
{
void *(*trampoline) ();
ffi_trampoline_table_entry *next;
};
/* Override the standard architecture trampoline size */
// XXX TODO - Fix
#undef FFI_TRAMPOLINE_SIZE
#define FFI_TRAMPOLINE_SIZE 12
/* The trampoline configuration is placed at 4080 bytes prior to the trampoline's entry point */
#define FFI_TRAMPOLINE_CODELOC_CONFIG(codeloc) ((void **) (((uint8_t *) codeloc) - 4080));
/* The first 16 bytes of the config page are unused, as they are unaddressable from the trampoline page. */
#define FFI_TRAMPOLINE_CONFIG_PAGE_OFFSET 16
/* Total number of trampolines that fit in one trampoline table */
#define FFI_TRAMPOLINE_COUNT ((PAGE_SIZE - FFI_TRAMPOLINE_CONFIG_PAGE_OFFSET) / FFI_TRAMPOLINE_SIZE)
static pthread_mutex_t ffi_trampoline_lock = PTHREAD_MUTEX_INITIALIZER;
static ffi_trampoline_table *ffi_trampoline_tables = NULL;
static ffi_trampoline_table *
ffi_trampoline_table_alloc ()
{
ffi_trampoline_table *table = NULL;
/* Loop until we can allocate two contiguous pages */
while (table == NULL)
{
vm_address_t config_page = 0x0;
kern_return_t kt;
/* Try to allocate two pages */
kt =
vm_allocate (mach_task_self (), &config_page, PAGE_SIZE * 2,
VM_FLAGS_ANYWHERE);
if (kt != KERN_SUCCESS)
{
fprintf (stderr, "vm_allocate() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
break;
}
/* Now drop the second half of the allocation to make room for the trampoline table */
vm_address_t trampoline_page = config_page + PAGE_SIZE;
kt = vm_deallocate (mach_task_self (), trampoline_page, PAGE_SIZE);
if (kt != KERN_SUCCESS)
{
fprintf (stderr, "vm_deallocate() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
break;
}
/* Remap the trampoline table to directly follow the config page */
vm_prot_t cur_prot;
vm_prot_t max_prot;
kt =
vm_remap (mach_task_self (), &trampoline_page, PAGE_SIZE, 0x0, FALSE,
mach_task_self (),
(vm_address_t) & ffi_closure_trampoline_table_page, FALSE,
&cur_prot, &max_prot, VM_INHERIT_SHARE);
/* If we lost access to the destination trampoline page, drop our config allocation mapping and retry */
if (kt != KERN_SUCCESS)
{
/* Log unexpected failures */
if (kt != KERN_NO_SPACE)
{
fprintf (stderr, "vm_remap() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
}
vm_deallocate (mach_task_self (), config_page, PAGE_SIZE);
continue;
}
/* We have valid trampoline and config pages */
table = calloc (1, sizeof (ffi_trampoline_table));
table->free_count = FFI_TRAMPOLINE_COUNT;
table->config_page = config_page;
table->trampoline_page = trampoline_page;
/* Create and initialize the free list */
table->free_list_pool =
calloc (FFI_TRAMPOLINE_COUNT, sizeof (ffi_trampoline_table_entry));
uint16_t i;
for (i = 0; i < table->free_count; i++)
{
ffi_trampoline_table_entry *entry = &table->free_list_pool[i];
entry->trampoline =
(void *) (table->trampoline_page + (i * FFI_TRAMPOLINE_SIZE));
if (i < table->free_count - 1)
entry->next = &table->free_list_pool[i + 1];
}
table->free_list = table->free_list_pool;
}
return table;
}
void *
ffi_closure_alloc (size_t size, void **code)
{
/* Create the closure */
ffi_closure *closure = malloc (size);
if (closure == NULL)
return NULL;
pthread_mutex_lock (&ffi_trampoline_lock);
/* Check for an active trampoline table with available entries. */
ffi_trampoline_table *table = ffi_trampoline_tables;
if (table == NULL || table->free_list == NULL)
{
table = ffi_trampoline_table_alloc ();
if (table == NULL)
{
free (closure);
return NULL;
}
/* Insert the new table at the top of the list */
table->next = ffi_trampoline_tables;
if (table->next != NULL)
table->next->prev = table;
ffi_trampoline_tables = table;
}
/* Claim the free entry */
ffi_trampoline_table_entry *entry = ffi_trampoline_tables->free_list;
ffi_trampoline_tables->free_list = entry->next;
ffi_trampoline_tables->free_count--;
entry->next = NULL;
pthread_mutex_unlock (&ffi_trampoline_lock);
/* Initialize the return values */
*code = entry->trampoline;
closure->trampoline_table = table;
closure->trampoline_table_entry = entry;
return closure;
}
void
ffi_closure_free (void *ptr)
{
ffi_closure *closure = ptr;
pthread_mutex_lock (&ffi_trampoline_lock);
/* Fetch the table and entry references */
ffi_trampoline_table *table = closure->trampoline_table;
ffi_trampoline_table_entry *entry = closure->trampoline_table_entry;
/* Return the entry to the free list */
entry->next = table->free_list;
table->free_list = entry;
table->free_count++;
/* If all trampolines within this table are free, and at least one other table exists, deallocate
* the table */
if (table->free_count == FFI_TRAMPOLINE_COUNT
&& ffi_trampoline_tables != table)
{
/* Remove from the list */
if (table->prev != NULL)
table->prev->next = table->next;
if (table->next != NULL)
table->next->prev = table->prev;
/* Deallocate pages */
kern_return_t kt;
kt = vm_deallocate (mach_task_self (), table->config_page, PAGE_SIZE);
if (kt != KERN_SUCCESS)
fprintf (stderr, "vm_deallocate() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
kt =
vm_deallocate (mach_task_self (), table->trampoline_page, PAGE_SIZE);
if (kt != KERN_SUCCESS)
fprintf (stderr, "vm_deallocate() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
/* Deallocate free list */
free (table->free_list_pool);
free (table);
}
else if (ffi_trampoline_tables != table)
{
/* Otherwise, bump this table to the top of the list */
table->prev = NULL;
table->next = ffi_trampoline_tables;
if (ffi_trampoline_tables != NULL)
ffi_trampoline_tables->prev = table;
ffi_trampoline_tables = table;
}
pthread_mutex_unlock (&ffi_trampoline_lock);
/* Free the closure */
free (closure);
}
#else
extern unsigned int ffi_arm_trampoline[2] FFI_HIDDEN;
#endif
/* the cif must already be prep'ed */ /* the cif must already be prep'ed */
ffi_status ffi_status
@@ -796,7 +561,7 @@ ffi_prep_closure_loc (ffi_closure * closure,
return FFI_BAD_ABI; return FFI_BAD_ABI;
#if FFI_EXEC_TRAMPOLINE_TABLE #if FFI_EXEC_TRAMPOLINE_TABLE
void **config = FFI_TRAMPOLINE_CODELOC_CONFIG (codeloc); void **config = (void **)((uint8_t *)codeloc - PAGE_MAX_SIZE);
config[0] = closure; config[0] = closure;
config[1] = closure_func; config[1] = closure_func;
#else #else
src/arm/ffitarget.h
+14 -1
View File
@@ -63,7 +63,20 @@ typedef enum ffi_abi {
#define FFI_CLOSURES 1 #define FFI_CLOSURES 1
#define FFI_GO_CLOSURES 1 #define FFI_GO_CLOSURES 1
#define FFI_TRAMPOLINE_SIZE 12
#define FFI_NATIVE_RAW_API 0 #define FFI_NATIVE_RAW_API 0
#if defined (FFI_EXEC_TRAMPOLINE_TABLE) && FFI_EXEC_TRAMPOLINE_TABLE
#ifdef __MACH__
#define FFI_TRAMPOLINE_SIZE 12
#define FFI_TRAMPOLINE_CLOSURE_OFFSET 8
#else
#error "No trampoline table implementation"
#endif
#else
#define FFI_TRAMPOLINE_SIZE 12
#define FFI_TRAMPOLINE_CLOSURE_OFFSET FFI_TRAMPOLINE_SIZE
#endif
#endif #endif
src/arm/sysv.S
+113 -65
View File
@@ -25,7 +25,7 @@
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
----------------------------------------------------------------------- */ ----------------------------------------------------------------------- */
#define LIBFFI_ASM #define LIBFFI_ASM
#include <fficonfig.h> #include <fficonfig.h>
#include <ffi.h> #include <ffi.h>
#include <ffi_cfi.h> #include <ffi_cfi.h>
@@ -52,11 +52,12 @@
#endif #endif
/* Conditionally compile unwinder directives. */ /* Conditionally compile unwinder directives. */
.macro UNWIND text:vararg
#ifdef __ARM_EABI__ #ifdef __ARM_EABI__
\text # define UNWIND(...) __VA_ARGS__
#endif #else
.endm # define UNWIND(...)
#endif
#if defined(HAVE_AS_CFI_PSEUDO_OP) && defined(__ARM_EABI__) #if defined(HAVE_AS_CFI_PSEUDO_OP) && defined(__ARM_EABI__)
.cfi_sections .debug_frame .cfi_sections .debug_frame
#endif #endif
@@ -77,29 +78,39 @@
# define TYPE(X, Y) # define TYPE(X, Y)
#endif #endif
#define ARM_FUNC_START(name, gl) \ #define ARM_FUNC_START_LOCAL(name) \
.align 3; \ .align 3; \
.ifne gl; .globl CNAME(name); FFI_HIDDEN(CNAME(name)); .endif; \ TYPE(CNAME(name), %function); \
TYPE(name, %function); \
CNAME(name): CNAME(name):
#define ARM_FUNC_START(name) \
.globl CNAME(name); \
FFI_HIDDEN(CNAME(name)); \
ARM_FUNC_START_LOCAL(name)
#define ARM_FUNC_END(name) \ #define ARM_FUNC_END(name) \
SIZE(name) SIZE(name)
/* Aid in defining a jump table with 8 bytes between entries. */ /* Aid in defining a jump table with 8 bytes between entries. */
.macro E index /* ??? The clang assembler doesn't handle .if with symbolic expressions. */
.if . - 0b - 8*\index #ifdef __clang__
.error "type table out of sync" # define E(index)
#else
# define E(index) \
.if . - 0b - 8*index; \
.error "type table out of sync"; \
.endif .endif
.endm #endif
.text .text
.syntax unified .syntax unified
.arm .arm
#ifndef __clang__
/* We require interworking on LDM, which implies ARMv5T, /* We require interworking on LDM, which implies ARMv5T,
which implies the existance of BLX. */ which implies the existance of BLX. */
.arch armv5t .arch armv5t
#endif
/* Note that we use STC and LDC to encode VFP instructions, /* Note that we use STC and LDC to encode VFP instructions,
so that we do not need ".fpu vfp", nor get that added to so that we do not need ".fpu vfp", nor get that added to
@@ -111,25 +122,30 @@
@ r2: fn @ r2: fn
@ r3: vfp_used @ r3: vfp_used
ARM_FUNC_START(ffi_call_VFP, 1) ARM_FUNC_START(ffi_call_VFP)
UNWIND .fnstart UNWIND(.fnstart)
cfi_startproc cfi_startproc
cmp r3, #3 @ load only d0 if possible cmp r3, #3 @ load only d0 if possible
#ifdef __clang__
vldrle d0, [sp]
vldmgt sp, {d0-d7}
#else
ldcle p11, cr0, [r0] @ vldrle d0, [sp] ldcle p11, cr0, [r0] @ vldrle d0, [sp]
ldcgt p11, cr0, [r0], {16} @ vldmgt sp, {d0-d7} ldcgt p11, cr0, [r0], {16} @ vldmgt sp, {d0-d7}
#endif
add r0, r0, #64 @ discard the vfp register args add r0, r0, #64 @ discard the vfp register args
/* FALLTHRU */ /* FALLTHRU */
ARM_FUNC_END(ffi_call_VFP) ARM_FUNC_END(ffi_call_VFP)
ARM_FUNC_START(ffi_call_SYSV, 1) ARM_FUNC_START(ffi_call_SYSV)
stm r1, {fp, lr} stm r1, {fp, lr}
mov fp, r1 mov fp, r1
@ This is a bit of a lie wrt the origin of the unwind info, but @ 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. @ now we've got the usual frame pointer and two saved registers.
UNWIND .save {fp,lr} UNWIND(.save {fp,lr})
UNWIND .setfp fp, sp UNWIND(.setfp fp, sp)
cfi_def_cfa(fp, 8) cfi_def_cfa(fp, 8)
cfi_rel_offset(fp, 0) cfi_rel_offset(fp, 0)
cfi_rel_offset(lr, 4) cfi_rel_offset(lr, 4)
@@ -154,29 +170,41 @@ ARM_FUNC_START(ffi_call_SYSV, 1)
add pc, pc, r3, lsl #3 add pc, pc, r3, lsl #3
nop nop
0: 0:
E ARM_TYPE_VFP_S E(ARM_TYPE_VFP_S)
#ifdef __clang__
vstr s0, [r2]
#else
stc p10, cr0, [r2] @ vstr s0, [r2] stc p10, cr0, [r2] @ vstr s0, [r2]
#endif
pop {fp,pc} pop {fp,pc}
E ARM_TYPE_VFP_D E(ARM_TYPE_VFP_D)
#ifdef __clang__
vstr d0, [r2]
#else
stc p11, cr0, [r2] @ vstr d0, [r2] stc p11, cr0, [r2] @ vstr d0, [r2]
#endif
pop {fp,pc} pop {fp,pc}
E ARM_TYPE_VFP_N E(ARM_TYPE_VFP_N)
#ifdef __clang__
vstm r2, {d0-d3}
#else
stc p11, cr0, [r2], {8} @ vstm r2, {d0-d3} stc p11, cr0, [r2], {8} @ vstm r2, {d0-d3}
#endif
pop {fp,pc} pop {fp,pc}
E ARM_TYPE_INT64 E(ARM_TYPE_INT64)
str r1, [r2, #4] str r1, [r2, #4]
nop nop
E ARM_TYPE_INT E(ARM_TYPE_INT)
str r0, [r2] str r0, [r2]
pop {fp,pc} pop {fp,pc}
E ARM_TYPE_VOID E(ARM_TYPE_VOID)
pop {fp,pc} pop {fp,pc}
nop nop
E ARM_TYPE_STRUCT E(ARM_TYPE_STRUCT)
pop {fp,pc} pop {fp,pc}
cfi_endproc cfi_endproc
UNWIND .fnend UNWIND(.fnend)
ARM_FUNC_END(ffi_call_SYSV) ARM_FUNC_END(ffi_call_SYSV)
@@ -184,7 +212,7 @@ ARM_FUNC_END(ffi_call_SYSV)
int ffi_closure_inner_* (cif, fun, user_data, frame) int ffi_closure_inner_* (cif, fun, user_data, frame)
*/ */
ARM_FUNC_START(ffi_go_closure_SYSV, 1) ARM_FUNC_START(ffi_go_closure_SYSV)
cfi_startproc cfi_startproc
stmdb sp!, {r0-r3} @ save argument regs stmdb sp!, {r0-r3} @ save argument regs
cfi_adjust_cfa_offset(16) cfi_adjust_cfa_offset(16)
@@ -195,14 +223,18 @@ ARM_FUNC_START(ffi_go_closure_SYSV, 1)
cfi_endproc cfi_endproc
ARM_FUNC_END(ffi_go_closure_SYSV) ARM_FUNC_END(ffi_go_closure_SYSV)
ARM_FUNC_START(ffi_closure_SYSV, 1) ARM_FUNC_START(ffi_closure_SYSV)
UNWIND .fnstart UNWIND(.fnstart)
cfi_startproc cfi_startproc
stmdb sp!, {r0-r3} @ save argument regs stmdb sp!, {r0-r3} @ save argument regs
cfi_adjust_cfa_offset(16) cfi_adjust_cfa_offset(16)
ldr r0, [ip, #FFI_TRAMPOLINE_SIZE] @ load cif
ldr r1, [ip, #FFI_TRAMPOLINE_SIZE+4] @ load fun #if FFI_EXEC_TRAMPOLINE_TABLE
ldr r2, [ip, #FFI_TRAMPOLINE_SIZE+8] @ load user_data ldr ip, [ip] @ ip points to the config page, dereference to get the ffi_closure*
#endif
ldr r0, [ip, #FFI_TRAMPOLINE_CLOSURE_OFFSET] @ load cif
ldr r1, [ip, #FFI_TRAMPOLINE_CLOSURE_OFFSET+4] @ load fun
ldr r2, [ip, #FFI_TRAMPOLINE_CLOSURE_OFFSET+8] @ load user_data
0: 0:
add ip, sp, #16 @ compute entry sp add ip, sp, #16 @ compute entry sp
sub sp, sp, #64+32 @ allocate frame sub sp, sp, #64+32 @ allocate frame
@@ -212,7 +244,7 @@ ARM_FUNC_START(ffi_closure_SYSV, 1)
/* Remember that EABI unwind info only applies at call sites. /* Remember that EABI unwind info only applies at call sites.
We need do nothing except note the save of the stack pointer We need do nothing except note the save of the stack pointer
and the link registers. */ and the link registers. */
UNWIND .save {sp,lr} UNWIND(.save {sp,lr})
cfi_adjust_cfa_offset(8) cfi_adjust_cfa_offset(8)
cfi_rel_offset(lr, 4) cfi_rel_offset(lr, 4)
@@ -224,10 +256,10 @@ ARM_FUNC_START(ffi_closure_SYSV, 1)
adr r3, CNAME(ffi_closure_ret) adr r3, CNAME(ffi_closure_ret)
add pc, r3, r0, lsl #3 add pc, r3, r0, lsl #3
cfi_endproc cfi_endproc
UNWIND .fnend UNWIND(.fnend)
ARM_FUNC_END(ffi_closure_SYSV) ARM_FUNC_END(ffi_closure_SYSV)
ARM_FUNC_START(ffi_go_closure_VFP, 1) ARM_FUNC_START(ffi_go_closure_VFP)
cfi_startproc cfi_startproc
stmdb sp!, {r0-r3} @ save argument regs stmdb sp!, {r0-r3} @ save argument regs
cfi_adjust_cfa_offset(16) cfi_adjust_cfa_offset(16)
@@ -238,23 +270,31 @@ ARM_FUNC_START(ffi_go_closure_VFP, 1)
cfi_endproc cfi_endproc
ARM_FUNC_END(ffi_go_closure_VFP) ARM_FUNC_END(ffi_go_closure_VFP)
ARM_FUNC_START(ffi_closure_VFP, 1) ARM_FUNC_START(ffi_closure_VFP)
UNWIND .fnstart UNWIND(.fnstart)
cfi_startproc cfi_startproc
stmdb sp!, {r0-r3} @ save argument regs stmdb sp!, {r0-r3} @ save argument regs
cfi_adjust_cfa_offset(16) cfi_adjust_cfa_offset(16)
ldr r0, [ip, #FFI_TRAMPOLINE_SIZE] @ load cif
ldr r1, [ip, #FFI_TRAMPOLINE_SIZE+4] @ load fun #if FFI_EXEC_TRAMPOLINE_TABLE
ldr r2, [ip, #FFI_TRAMPOLINE_SIZE+8] @ load user_data ldr ip, [ip] @ ip points to the config page, dereference to get the ffi_closure*
#endif
ldr r0, [ip, #FFI_TRAMPOLINE_CLOSURE_OFFSET] @ load cif
ldr r1, [ip, #FFI_TRAMPOLINE_CLOSURE_OFFSET+4] @ load fun
ldr r2, [ip, #FFI_TRAMPOLINE_CLOSURE_OFFSET+8] @ load user_data
0: 0:
add ip, sp, #16 add ip, sp, #16
sub sp, sp, #64+32 @ allocate frame sub sp, sp, #64+32 @ allocate frame
cfi_adjust_cfa_offset(64+32) cfi_adjust_cfa_offset(64+32)
#ifdef __clang__
vstm sp, {d0-d7}
#else
stc p11, cr0, [sp], {16} @ vstm sp, {d0-d7} stc p11, cr0, [sp], {16} @ vstm sp, {d0-d7}
#endif
stmdb sp!, {ip,lr} stmdb sp!, {ip,lr}
/* See above. */ /* See above. */
UNWIND .save {sp,lr} UNWIND(.save {sp,lr})
cfi_adjust_cfa_offset(8) cfi_adjust_cfa_offset(8)
cfi_rel_offset(lr, 4) cfi_rel_offset(lr, 4)
@@ -266,63 +306,71 @@ ARM_FUNC_START(ffi_closure_VFP, 1)
adr r3, CNAME(ffi_closure_ret) adr r3, CNAME(ffi_closure_ret)
add pc, r3, r0, lsl #3 add pc, r3, r0, lsl #3
cfi_endproc cfi_endproc
UNWIND .fnend UNWIND(.fnend)
ARM_FUNC_END(ffi_closure_VFP) ARM_FUNC_END(ffi_closure_VFP)
/* Load values returned in registers for both closure entry points. /* Load values returned in registers for both closure entry points.
Note that we use LDM with SP in the register set. This is deprecated Note that we use LDM with SP in the register set. This is deprecated
by ARM, but not yet unpredictable. */ by ARM, but not yet unpredictable. */
ARM_FUNC_START(ffi_closure_ret, 0) ARM_FUNC_START_LOCAL(ffi_closure_ret)
cfi_startproc cfi_startproc
cfi_rel_offset(sp, 0) cfi_rel_offset(sp, 0)
cfi_rel_offset(lr, 4) cfi_rel_offset(lr, 4)
0: 0:
E ARM_TYPE_VFP_S E(ARM_TYPE_VFP_S)
#ifdef __clang__
vldr s0, [r2]
#else
ldc p10, cr0, [r2] @ vldr s0, [r2] ldc p10, cr0, [r2] @ vldr s0, [r2]
#endif
ldm sp, {sp,pc} ldm sp, {sp,pc}
E ARM_TYPE_VFP_D E(ARM_TYPE_VFP_D)
#ifdef __clang__
vldr d0, [r2]
#else
ldc p11, cr0, [r2] @ vldr d0, [r2] ldc p11, cr0, [r2] @ vldr d0, [r2]
#endif
ldm sp, {sp,pc} ldm sp, {sp,pc}
E ARM_TYPE_VFP_N E(ARM_TYPE_VFP_N)
#ifdef __clang__
vldm r2, {d0-d3}
#else
ldc p11, cr0, [r2], {8} @ vldm r2, {d0-d3} ldc p11, cr0, [r2], {8} @ vldm r2, {d0-d3}
#endif
ldm sp, {sp,pc} ldm sp, {sp,pc}
E ARM_TYPE_INT64 E(ARM_TYPE_INT64)
ldr r1, [r2, #4] ldr r1, [r2, #4]
nop nop
E ARM_TYPE_INT E(ARM_TYPE_INT)
ldr r0, [r2] ldr r0, [r2]
ldm sp, {sp,pc} ldm sp, {sp,pc}
E ARM_TYPE_VOID E(ARM_TYPE_VOID)
ldm sp, {sp,pc} ldm sp, {sp,pc}
nop nop
E ARM_TYPE_STRUCT E(ARM_TYPE_STRUCT)
ldm sp, {sp,pc} ldm sp, {sp,pc}
cfi_endproc cfi_endproc
ARM_FUNC_END(ffi_closure_ret) ARM_FUNC_END(ffi_closure_ret)
#if FFI_EXEC_TRAMPOLINE_TABLE #if FFI_EXEC_TRAMPOLINE_TABLE
/* ??? The iOS support should be updated. The first insn used to #ifdef __MACH__
be STMFD, but that's been moved into ffi_closure_SYSV. If the #include <mach/vm_param.h>
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 .align PAGE_MAX_SHIFT
keep all the magic numbers the same within ffi.c. */
.align 12
ARM_FUNC_START(ffi_closure_trampoline_table_page) ARM_FUNC_START(ffi_closure_trampoline_table_page)
.rept 4096 / 12 .rept PAGE_MAX_SIZE / FFI_TRAMPOLINE_SIZE
nop adr ip, #-PAGE_MAX_SIZE @ the config page is PAGE_MAX_SIZE behind the trampoline page
ldr ip, [pc, #-4092] sub ip, #8 @ account for pc bias
ldr pc, [pc, #-4092] ldr pc, [ip, #4] @ jump to ffi_closure_SYSV or ffi_closure_VFP
.endr .endr
ARM_FUNC_END(ffi_closure_trampoline_table_page)
#endif
#else #else
ARM_FUNC_START(ffi_arm_trampoline, 1) ARM_FUNC_START(ffi_arm_trampoline)
0: adr ip, 0b 0: adr ip, 0b
ldr pc, 1f ldr pc, 1f
1: .long 0 1: .long 0
src/closures.c
+239 -2
View File
@@ -30,6 +30,7 @@
#define _GNU_SOURCE 1 #define _GNU_SOURCE 1
#endif #endif
#include <fficonfig.h>
#include <ffi.h> #include <ffi.h>
#include <ffi_common.h> #include <ffi_common.h>
@@ -64,11 +65,247 @@
#if FFI_CLOSURES #if FFI_CLOSURES
# if FFI_EXEC_TRAMPOLINE_TABLE #if FFI_EXEC_TRAMPOLINE_TABLE
#ifdef __MACH__
#include <mach/mach.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
extern void *ffi_closure_trampoline_table_page;
typedef struct ffi_trampoline_table ffi_trampoline_table;
typedef struct ffi_trampoline_table_entry ffi_trampoline_table_entry;
struct ffi_trampoline_table
{
/* contiguous writable and executable pages */
vm_address_t config_page;
vm_address_t trampoline_page;
/* free list tracking */
uint16_t free_count;
ffi_trampoline_table_entry *free_list;
ffi_trampoline_table_entry *free_list_pool;
ffi_trampoline_table *prev;
ffi_trampoline_table *next;
};
struct ffi_trampoline_table_entry
{
void *(*trampoline) ();
ffi_trampoline_table_entry *next;
};
/* Total number of trampolines that fit in one trampoline table */
#define FFI_TRAMPOLINE_COUNT (PAGE_MAX_SIZE / FFI_TRAMPOLINE_SIZE)
static pthread_mutex_t ffi_trampoline_lock = PTHREAD_MUTEX_INITIALIZER;
static ffi_trampoline_table *ffi_trampoline_tables = NULL;
static ffi_trampoline_table *
ffi_trampoline_table_alloc ()
{
ffi_trampoline_table *table = NULL;
/* Loop until we can allocate two contiguous pages */
while (table == NULL)
{
vm_address_t config_page = 0x0;
kern_return_t kt;
/* Try to allocate two pages */
kt =
vm_allocate (mach_task_self (), &config_page, PAGE_MAX_SIZE * 2,
VM_FLAGS_ANYWHERE);
if (kt != KERN_SUCCESS)
{
fprintf (stderr, "vm_allocate() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
break;
}
/* Now drop the second half of the allocation to make room for the trampoline table */
vm_address_t trampoline_page = config_page + PAGE_MAX_SIZE;
kt = vm_deallocate (mach_task_self (), trampoline_page, PAGE_MAX_SIZE);
if (kt != KERN_SUCCESS)
{
fprintf (stderr, "vm_deallocate() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
break;
}
/* Remap the trampoline table to directly follow the config page */
vm_prot_t cur_prot;
vm_prot_t max_prot;
vm_address_t trampoline_page_template = (vm_address_t)&ffi_closure_trampoline_table_page;
#ifdef __arm__
/* ffi_closure_trampoline_table_page can be thumb-biased on some ARM archs */
trampoline_page_template &= ~1UL;
#endif
kt =
vm_remap (mach_task_self (), &trampoline_page, PAGE_MAX_SIZE, 0x0, FALSE,
mach_task_self (), trampoline_page_template, FALSE,
&cur_prot, &max_prot, VM_INHERIT_SHARE);
/* If we lost access to the destination trampoline page, drop our config allocation mapping and retry */
if (kt != KERN_SUCCESS)
{
/* Log unexpected failures */
if (kt != KERN_NO_SPACE)
{
fprintf (stderr, "vm_remap() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
}
vm_deallocate (mach_task_self (), config_page, PAGE_SIZE);
continue;
}
/* We have valid trampoline and config pages */
table = calloc (1, sizeof (ffi_trampoline_table));
table->free_count = FFI_TRAMPOLINE_COUNT;
table->config_page = config_page;
table->trampoline_page = trampoline_page;
/* Create and initialize the free list */
table->free_list_pool =
calloc (FFI_TRAMPOLINE_COUNT, sizeof (ffi_trampoline_table_entry));
uint16_t i;
for (i = 0; i < table->free_count; i++)
{
ffi_trampoline_table_entry *entry = &table->free_list_pool[i];
entry->trampoline =
(void *) (table->trampoline_page + (i * FFI_TRAMPOLINE_SIZE));
if (i < table->free_count - 1)
entry->next = &table->free_list_pool[i + 1];
}
table->free_list = table->free_list_pool;
}
return table;
}
void *
ffi_closure_alloc (size_t size, void **code)
{
/* Create the closure */
ffi_closure *closure = malloc (size);
if (closure == NULL)
return NULL;
pthread_mutex_lock (&ffi_trampoline_lock);
/* Check for an active trampoline table with available entries. */
ffi_trampoline_table *table = ffi_trampoline_tables;
if (table == NULL || table->free_list == NULL)
{
table = ffi_trampoline_table_alloc ();
if (table == NULL)
{
free (closure);
return NULL;
}
/* Insert the new table at the top of the list */
table->next = ffi_trampoline_tables;
if (table->next != NULL)
table->next->prev = table;
ffi_trampoline_tables = table;
}
/* Claim the free entry */
ffi_trampoline_table_entry *entry = ffi_trampoline_tables->free_list;
ffi_trampoline_tables->free_list = entry->next;
ffi_trampoline_tables->free_count--;
entry->next = NULL;
pthread_mutex_unlock (&ffi_trampoline_lock);
/* Initialize the return values */
*code = entry->trampoline;
closure->trampoline_table = table;
closure->trampoline_table_entry = entry;
return closure;
}
void
ffi_closure_free (void *ptr)
{
ffi_closure *closure = ptr;
pthread_mutex_lock (&ffi_trampoline_lock);
/* Fetch the table and entry references */
ffi_trampoline_table *table = closure->trampoline_table;
ffi_trampoline_table_entry *entry = closure->trampoline_table_entry;
/* Return the entry to the free list */
entry->next = table->free_list;
table->free_list = entry;
table->free_count++;
/* If all trampolines within this table are free, and at least one other table exists, deallocate
* the table */
if (table->free_count == FFI_TRAMPOLINE_COUNT
&& ffi_trampoline_tables != table)
{
/* Remove from the list */
if (table->prev != NULL)
table->prev->next = table->next;
if (table->next != NULL)
table->next->prev = table->prev;
/* Deallocate pages */
kern_return_t kt;
kt = vm_deallocate (mach_task_self (), table->config_page, PAGE_SIZE);
if (kt != KERN_SUCCESS)
fprintf (stderr, "vm_deallocate() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
kt =
vm_deallocate (mach_task_self (), table->trampoline_page, PAGE_SIZE);
if (kt != KERN_SUCCESS)
fprintf (stderr, "vm_deallocate() failure: %d at %s:%d\n", kt,
__FILE__, __LINE__);
/* Deallocate free list */
free (table->free_list_pool);
free (table);
}
else if (ffi_trampoline_tables != table)
{
/* Otherwise, bump this table to the top of the list */
table->prev = NULL;
table->next = ffi_trampoline_tables;
if (ffi_trampoline_tables != NULL)
ffi_trampoline_tables->prev = table;
ffi_trampoline_tables = table;
}
pthread_mutex_unlock (&ffi_trampoline_lock);
/* Free the closure */
free (closure);
}
#endif
// Per-target implementation; It's unclear what can reasonable be shared between two OS/architecture implementations. // Per-target implementation; It's unclear what can reasonable be shared between two OS/architecture implementations.
# elif FFI_MMAP_EXEC_WRIT /* !FFI_EXEC_TRAMPOLINE_TABLE */ #elif FFI_MMAP_EXEC_WRIT /* !FFI_EXEC_TRAMPOLINE_TABLE */
#define USE_LOCKS 1 #define USE_LOCKS 1
#define USE_DL_PREFIX 1 #define USE_DL_PREFIX 1