This is the mail archive of the
libffi-discuss@sourceware.org
mailing list for the libffi project.
[PATCH 01/10] arm: Reindent arm/ffi.c
- From: Richard Henderson <rth at twiddle dot net>
- To: libffi-discuss at sourceware dot org
- Date: Wed, 29 Oct 2014 13:05:38 -0700
- Subject: [PATCH 01/10] arm: Reindent arm/ffi.c
- Authentication-results: sourceware.org; auth=none
- References: <1414613147-10917-1-git-send-email-rth at twiddle dot net>
---
src/arm/ffi.c | 743 +++++++++++++++++++++++++++++++---------------------------
1 file changed, 392 insertions(+), 351 deletions(-)
diff --git a/src/arm/ffi.c b/src/arm/ffi.c
index 6691ab5..c5fd831 100644
--- a/src/arm/ffi.c
+++ b/src/arm/ffi.c
@@ -37,122 +37,126 @@
static int vfp_type_p (ffi_type *);
static void layout_vfp_args (ffi_cif *);
-int ffi_prep_args_SYSV(char *stack, extended_cif *ecif, float *vfp_space);
-int ffi_prep_args_VFP(char *stack, extended_cif *ecif, float *vfp_space);
+int ffi_prep_args_SYSV (char *stack, extended_cif *ecif, float *vfp_space);
+int ffi_prep_args_VFP (char *stack, extended_cif *ecif, float *vfp_space);
-static char* ffi_align(ffi_type **p_arg, char *argp)
+static char *
+ffi_align (ffi_type **p_arg, char *argp)
{
/* Align if necessary */
register size_t alignment = (*p_arg)->alignment;
if (alignment < 4)
- {
- alignment = 4;
- }
+ {
+ alignment = 4;
+ }
#ifdef _WIN32_WCE
if (alignment > 4)
- {
- alignment = 4;
- }
+ {
+ alignment = 4;
+ }
#endif
if ((alignment - 1) & (unsigned) argp)
- {
- argp = (char *) ALIGN(argp, alignment);
- }
-
+ {
+ argp = (char *) ALIGN (argp, alignment);
+ }
if ((*p_arg)->type == FFI_TYPE_STRUCT)
- {
- argp = (char *) ALIGN(argp, 4);
- }
+ {
+ argp = (char *) ALIGN (argp, 4);
+ }
return argp;
}
-static size_t ffi_put_arg(ffi_type **arg_type, void **arg, char *stack)
+static size_t
+ffi_put_arg (ffi_type **arg_type, void **arg, char *stack)
{
- register char* argp = stack;
- register ffi_type **p_arg = arg_type;
- register void **p_argv = arg;
- register size_t z = (*p_arg)->size;
- if (z < sizeof(int))
+ register char *argp = stack;
+ register ffi_type **p_arg = arg_type;
+ register void **p_argv = arg;
+ register size_t z = (*p_arg)->size;
+
+ if (z < sizeof (int))
{
- z = sizeof(int);
- switch ((*p_arg)->type)
- {
- case FFI_TYPE_SINT8:
- *(signed int *) argp = (signed int)*(SINT8 *)(* p_argv);
- break;
-
- case FFI_TYPE_UINT8:
- *(unsigned int *) argp = (unsigned int)*(UINT8 *)(* p_argv);
- break;
-
- case FFI_TYPE_SINT16:
- *(signed int *) argp = (signed int)*(SINT16 *)(* p_argv);
- break;
-
- case FFI_TYPE_UINT16:
- *(unsigned int *) argp = (unsigned int)*(UINT16 *)(* p_argv);
- break;
-
- case FFI_TYPE_STRUCT:
- memcpy(argp, *p_argv, (*p_arg)->size);
- break;
-
- default:
- FFI_ASSERT(0);
- }
+ z = sizeof (int);
+ switch ((*p_arg)->type)
+ {
+ case FFI_TYPE_SINT8:
+ *(signed int *) argp = (signed int) *(SINT8 *) (*p_argv);
+ break;
+
+ case FFI_TYPE_UINT8:
+ *(unsigned int *) argp = (unsigned int) *(UINT8 *) (*p_argv);
+ break;
+
+ case FFI_TYPE_SINT16:
+ *(signed int *) argp = (signed int) *(SINT16 *) (*p_argv);
+ break;
+
+ case FFI_TYPE_UINT16:
+ *(unsigned int *) argp = (unsigned int) *(UINT16 *) (*p_argv);
+ break;
+
+ case FFI_TYPE_STRUCT:
+ memcpy (argp, *p_argv, (*p_arg)->size);
+ break;
+
+ default:
+ FFI_ASSERT (0);
+ }
}
- else if (z == sizeof(int))
+ else if (z == sizeof (int))
{
- if ((*p_arg)->type == FFI_TYPE_FLOAT)
- *(float *) argp = *(float *)(* p_argv);
- else
- *(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
+ if ((*p_arg)->type == FFI_TYPE_FLOAT)
+ *(float *) argp = *(float *) (*p_argv);
+ else
+ *(unsigned int *) argp = (unsigned int) *(UINT32 *) (*p_argv);
+ }
+ else if (z == sizeof (double) && (*p_arg)->type == FFI_TYPE_DOUBLE)
+ {
+ *(double *) argp = *(double *) (*p_argv);
}
- else if (z == sizeof(double) && (*p_arg)->type == FFI_TYPE_DOUBLE)
- {
- *(double *) argp = *(double *)(* p_argv);
- }
else
{
- memcpy(argp, *p_argv, z);
+ memcpy (argp, *p_argv, z);
}
return z;
}
+
/* ffi_prep_args is called by the assembly routine once stack space
has been allocated for the function's arguments
-
+
The vfp_space parameter is the load area for VFP regs, the return
value is cif->vfp_used (word bitset of VFP regs used for passing
arguments). These are only used for the VFP hard-float ABI.
*/
-int ffi_prep_args_SYSV(char *stack, extended_cif *ecif, float *vfp_space)
+int
+ffi_prep_args_SYSV (char *stack, extended_cif *ecif, float *vfp_space)
{
register unsigned int i;
register void **p_argv;
register char *argp;
register ffi_type **p_arg;
argp = stack;
-
- if ( ecif->cif->flags == FFI_TYPE_STRUCT ) {
- *(void **) argp = ecif->rvalue;
- argp += 4;
- }
+ if (ecif->cif->flags == FFI_TYPE_STRUCT)
+ {
+ *(void **) argp = ecif->rvalue;
+ argp += 4;
+ }
p_argv = ecif->avalue;
for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
- (i != 0);
- i--, p_arg++, p_argv++)
+ (i != 0); i--, p_arg++, p_argv++)
{
- argp = ffi_align(p_arg, argp);
- argp += ffi_put_arg(p_arg, p_argv, argp);
+ argp = ffi_align (p_arg, argp);
+ argp += ffi_put_arg (p_arg, p_argv, argp);
}
return 0;
}
-int ffi_prep_args_VFP(char *stack, extended_cif *ecif, float *vfp_space)
+int
+ffi_prep_args_VFP (char *stack, extended_cif * ecif, float *vfp_space)
{
register unsigned int i, vi = 0;
register void **p_argv;
@@ -162,79 +166,79 @@ int ffi_prep_args_VFP(char *stack, extended_cif *ecif, float *vfp_space)
char done_with_regs = 0;
char is_vfp_type;
- // make sure we are using FFI_VFP
- FFI_ASSERT(ecif->cif->abi == FFI_VFP);
+ /* Make sure we are using FFI_VFP. */
+ FFI_ASSERT (ecif->cif->abi == FFI_VFP);
- /* the first 4 words on the stack are used for values passed in core
- * registers. */
+ /* The first 4 words on the stack are used for values
+ passed in core registers. */
regp = stack;
eo_regp = argp = regp + 16;
-
- /* if the function returns an FFI_TYPE_STRUCT in memory, that address is
- * passed in r0 to the function */
- if ( ecif->cif->flags == FFI_TYPE_STRUCT ) {
- *(void **) regp = ecif->rvalue;
- regp += 4;
- }
+ /* If the function returns an FFI_TYPE_STRUCT in memory,
+ that address is passed in r0 to the function. */
+ if (ecif->cif->flags == FFI_TYPE_STRUCT)
+ {
+ *(void **) regp = ecif->rvalue;
+ regp += 4;
+ }
p_argv = ecif->avalue;
for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
- (i != 0);
- i--, p_arg++, p_argv++)
+ (i != 0); i--, p_arg++, p_argv++)
{
is_vfp_type = vfp_type_p (*p_arg);
/* Allocated in VFP registers. */
- if(vi < ecif->cif->vfp_nargs && is_vfp_type)
- {
- char *vfp_slot = (char *)(vfp_space + ecif->cif->vfp_args[vi++]);
- ffi_put_arg(p_arg, p_argv, vfp_slot);
- continue;
- }
+ if (vi < ecif->cif->vfp_nargs && is_vfp_type)
+ {
+ char *vfp_slot = (char *) (vfp_space + ecif->cif->vfp_args[vi++]);
+ ffi_put_arg (p_arg, p_argv, vfp_slot);
+ continue;
+ }
/* Try allocating in core registers. */
else if (!done_with_regs && !is_vfp_type)
- {
- char *tregp = ffi_align(p_arg, regp);
- size_t size = (*p_arg)->size;
- size = (size < 4)? 4 : size; // pad
- /* Check if there is space left in the aligned register area to place
- * the argument */
- if(tregp + size <= eo_regp)
- {
- regp = tregp + ffi_put_arg(p_arg, p_argv, tregp);
- done_with_regs = (regp == argp);
- // ensure we did not write into the stack area
- FFI_ASSERT(regp <= argp);
- continue;
- }
- /* In case there are no arguments in the stack area yet,
- the argument is passed in the remaining core registers and on the
- stack. */
- else if (!stack_used)
- {
- stack_used = 1;
- done_with_regs = 1;
- argp = tregp + ffi_put_arg(p_arg, p_argv, tregp);
- FFI_ASSERT(eo_regp < argp);
- continue;
- }
- }
+ {
+ char *tregp = ffi_align (p_arg, regp);
+ size_t size = (*p_arg)->size;
+ size = (size < 4) ? 4 : size; // pad
+ /* Check if there is space left in the aligned register
+ area to place the argument. */
+ if (tregp + size <= eo_regp)
+ {
+ regp = tregp + ffi_put_arg (p_arg, p_argv, tregp);
+ done_with_regs = (regp == argp);
+ // ensure we did not write into the stack area
+ FFI_ASSERT (regp <= argp);
+ continue;
+ }
+ /* In case there are no arguments in the stack area yet,
+ the argument is passed in the remaining core registers
+ and on the stack. */
+ else if (!stack_used)
+ {
+ stack_used = 1;
+ done_with_regs = 1;
+ argp = tregp + ffi_put_arg (p_arg, p_argv, tregp);
+ FFI_ASSERT (eo_regp < argp);
+ continue;
+ }
+ }
/* Base case, arguments are passed on the stack */
stack_used = 1;
- argp = ffi_align(p_arg, argp);
- argp += ffi_put_arg(p_arg, p_argv, argp);
+ argp = ffi_align (p_arg, argp);
+ argp += ffi_put_arg (p_arg, p_argv, argp);
}
/* Indicate the VFP registers used. */
return ecif->cif->vfp_used;
}
/* Perform machine dependent cif processing */
-ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
+ffi_status
+ffi_prep_cif_machdep (ffi_cif * cif)
{
int type_code;
- /* Round the stack up to a multiple of 8 bytes. This isn't needed
+ /* Round the stack up to a multiple of 8 bytes. This isn't needed
everywhere, but it is on some platforms, and it doesn't harm anything
when it isn't needed. */
cif->bytes = (cif->bytes + 7) & ~7;
@@ -254,21 +258,24 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
break;
case FFI_TYPE_STRUCT:
- if (cif->abi == FFI_VFP
- && (type_code = vfp_type_p (cif->rtype)) != 0)
+ if (cif->abi == FFI_VFP && (type_code = vfp_type_p (cif->rtype)) != 0)
{
/* A Composite Type passed in VFP registers, either
FFI_TYPE_STRUCT_VFP_FLOAT or FFI_TYPE_STRUCT_VFP_DOUBLE. */
cif->flags = (unsigned) type_code;
}
else if (cif->rtype->size <= 4)
- /* A Composite Type not larger than 4 bytes is returned in r0. */
- cif->flags = (unsigned)FFI_TYPE_INT;
+ {
+ /* A Composite Type not larger than 4 bytes is returned in r0. */
+ cif->flags = (unsigned) FFI_TYPE_INT;
+ }
else
- /* A Composite Type larger than 4 bytes, or whose size cannot
- be determined statically ... is stored in memory at an
- address passed [in r0]. */
- cif->flags = (unsigned)FFI_TYPE_STRUCT;
+ {
+ /* A Composite Type larger than 4 bytes, or whose size cannot
+ be determined statically ... is stored in memory at an
+ address passed [in r0]. */
+ cif->flags = (unsigned) FFI_TYPE_STRUCT;
+ }
break;
default:
@@ -276,9 +283,10 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
break;
}
- /* Map out the register placements of VFP register args.
- The VFP hard-float calling conventions are slightly more sophisticated than
- the base calling conventions, so we do it here instead of in ffi_prep_args(). */
+ /* Map out the register placements of VFP register args. The VFP
+ hard-float calling conventions are slightly more sophisticated
+ than the base calling conventions, so we do it here instead of
+ in ffi_prep_args(). */
if (cif->abi == FFI_VFP)
layout_vfp_args (cif);
@@ -286,54 +294,56 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
}
/* Perform machine dependent cif processing for variadic calls */
-ffi_status ffi_prep_cif_machdep_var(ffi_cif *cif,
- unsigned int nfixedargs,
- unsigned int ntotalargs)
+ffi_status
+ffi_prep_cif_machdep_var (ffi_cif * cif,
+ unsigned int nfixedargs, unsigned int ntotalargs)
{
/* VFP variadic calls actually use the SYSV ABI */
if (cif->abi == FFI_VFP)
- cif->abi = FFI_SYSV;
+ cif->abi = FFI_SYSV;
- return ffi_prep_cif_machdep(cif);
+ return ffi_prep_cif_machdep (cif);
}
-/* Prototypes for assembly functions, in sysv.S */
-extern void ffi_call_SYSV (void (*fn)(void), extended_cif *, unsigned, unsigned, unsigned *);
-extern void ffi_call_VFP (void (*fn)(void), extended_cif *, unsigned, unsigned, unsigned *);
+/* Prototypes for assembly functions, in sysv.S. */
+extern void ffi_call_SYSV (void (*fn) (void), extended_cif *, unsigned,
+ unsigned, unsigned *);
+extern void ffi_call_VFP (void (*fn) (void), extended_cif *, unsigned,
+ unsigned, unsigned *);
-void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
+void
+ffi_call (ffi_cif * cif, void (*fn) (void), void *rvalue, void **avalue)
{
extended_cif ecif;
- int small_struct = (cif->flags == FFI_TYPE_INT
+ int small_struct = (cif->flags == FFI_TYPE_INT
&& cif->rtype->type == FFI_TYPE_STRUCT);
int vfp_struct = (cif->flags == FFI_TYPE_STRUCT_VFP_FLOAT
|| cif->flags == FFI_TYPE_STRUCT_VFP_DOUBLE);
unsigned int temp;
-
+
ecif.cif = cif;
ecif.avalue = avalue;
- /* If the return value is a struct and we don't have a return */
- /* value address then we need to make one */
+ /* If the return value is a struct and we don't have a return
+ value address then we need to make one. */
- if ((rvalue == NULL) &&
- (cif->flags == FFI_TYPE_STRUCT))
+ if ((rvalue == NULL) && (cif->flags == FFI_TYPE_STRUCT))
{
- ecif.rvalue = alloca(cif->rtype->size);
+ ecif.rvalue = alloca (cif->rtype->size);
}
else if (small_struct)
ecif.rvalue = &temp;
else if (vfp_struct)
{
/* Largest case is double x 4. */
- ecif.rvalue = alloca(32);
+ ecif.rvalue = alloca (32);
}
else
ecif.rvalue = rvalue;
- switch (cif->abi)
+ switch (cif->abi)
{
case FFI_SYSV:
ffi_call_SYSV (fn, &ecif, cif->bytes, cif->flags, ecif.rvalue);
@@ -346,30 +356,30 @@ void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
#endif
default:
- FFI_ASSERT(0);
+ FFI_ASSERT (0);
break;
}
if (small_struct)
{
- FFI_ASSERT(rvalue != NULL);
+ FFI_ASSERT (rvalue != NULL);
memcpy (rvalue, &temp, cif->rtype->size);
}
-
else if (vfp_struct)
{
- FFI_ASSERT(rvalue != NULL);
+ FFI_ASSERT (rvalue != NULL);
memcpy (rvalue, ecif.rvalue, cif->rtype->size);
}
-
}
/** private members **/
static void ffi_prep_incoming_args_SYSV (char *stack, void **ret,
- void** args, ffi_cif* cif, float *vfp_stack);
+ void **args, ffi_cif *cif,
+ float *vfp_stack);
static void ffi_prep_incoming_args_VFP (char *stack, void **ret,
- void** args, ffi_cif* cif, float *vfp_stack);
+ void **args, ffi_cif *cif,
+ float *vfp_stack);
void ffi_closure_SYSV (ffi_closure *);
@@ -378,25 +388,25 @@ void ffi_closure_VFP (ffi_closure *);
/* This function is jumped to by the trampoline */
unsigned int FFI_HIDDEN
-ffi_closure_inner (ffi_closure *closure,
+ffi_closure_inner (ffi_closure *closure,
void **respp, void *args, void *vfp_args)
{
// our various things...
- ffi_cif *cif;
- void **arg_area;
+ ffi_cif *cif;
+ void **arg_area;
- cif = closure->cif;
- arg_area = (void**) alloca (cif->nargs * sizeof (void*));
+ cif = closure->cif;
+ arg_area = (void **) alloca (cif->nargs * sizeof (void *));
/* this call will initialize ARG_AREA, such that each
- * element in that array points to the corresponding
+ * element in that array points to the corresponding
* value on the stack; and if the function returns
* a structure, it will re-set RESP to point to the
* structure return address. */
if (cif->abi == FFI_VFP)
- ffi_prep_incoming_args_VFP(args, respp, arg_area, cif, vfp_args);
+ ffi_prep_incoming_args_VFP (args, respp, arg_area, cif, vfp_args);
else
- ffi_prep_incoming_args_SYSV(args, respp, arg_area, cif, vfp_args);
+ ffi_prep_incoming_args_SYSV (args, respp, arg_area, cif, vfp_args);
(closure->fun) (cif, *respp, arg_area, closure->user_data);
@@ -404,11 +414,11 @@ ffi_closure_inner (ffi_closure *closure,
}
/*@-exportheader@*/
-static void
-ffi_prep_incoming_args_SYSV(char *stack, void **rvalue,
- void **avalue, ffi_cif *cif,
- /* Used only under VFP hard-float ABI. */
- float *vfp_stack)
+static void
+ffi_prep_incoming_args_SYSV (char *stack, void **rvalue,
+ void **avalue, ffi_cif *cif,
+ /* Used only under VFP hard-float ABI. */
+ float *vfp_stack)
/*@=exportheader@*/
{
register unsigned int i;
@@ -418,10 +428,11 @@ ffi_prep_incoming_args_SYSV(char *stack, void **rvalue,
argp = stack;
- if ( cif->flags == FFI_TYPE_STRUCT ) {
- *rvalue = *(void **) argp;
- argp += 4;
- }
+ if (cif->flags == FFI_TYPE_STRUCT)
+ {
+ *rvalue = *(void **) argp;
+ argp += 4;
+ }
p_argv = avalue;
@@ -429,25 +440,25 @@ ffi_prep_incoming_args_SYSV(char *stack, void **rvalue,
{
size_t z;
- argp = ffi_align(p_arg, argp);
+ argp = ffi_align (p_arg, argp);
z = (*p_arg)->size;
/* because we're little endian, this is what it turns into. */
- *p_argv = (void*) argp;
+ *p_argv = (void *) argp;
p_argv++;
argp += z;
}
-
+
return;
}
/*@-exportheader@*/
-static void
-ffi_prep_incoming_args_VFP(char *stack, void **rvalue,
- void **avalue, ffi_cif *cif,
+static void
+ffi_prep_incoming_args_VFP (char *stack, void **rvalue,
+ void **avalue, ffi_cif * cif,
/* Used only under VFP hard-float ABI. */
float *vfp_stack)
/*@=exportheader@*/
@@ -460,76 +471,77 @@ ffi_prep_incoming_args_VFP(char *stack, void **rvalue,
char stack_used = 0;
char is_vfp_type;
- FFI_ASSERT(cif->abi == FFI_VFP);
+ FFI_ASSERT (cif->abi == FFI_VFP);
regp = stack;
eo_regp = argp = regp + 16;
- if ( cif->flags == FFI_TYPE_STRUCT ) {
- *rvalue = *(void **) regp;
- regp += 4;
- }
+ if (cif->flags == FFI_TYPE_STRUCT)
+ {
+ *rvalue = *(void **) regp;
+ regp += 4;
+ }
p_argv = avalue;
for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++)
{
- size_t z;
- is_vfp_type = vfp_type_p (*p_arg);
+ size_t z;
+ is_vfp_type = vfp_type_p (*p_arg);
- if(vi < cif->vfp_nargs && is_vfp_type)
- {
- *p_argv++ = (void*)(vfp_stack + cif->vfp_args[vi++]);
- continue;
- }
- else if (!done_with_regs && !is_vfp_type)
- {
- char* tregp = ffi_align(p_arg, regp);
-
- z = (*p_arg)->size;
- z = (z < 4)? 4 : z; // pad
-
- /* if the arguments either fits into the registers or uses registers
- * and stack, while we haven't read other things from the stack */
- if(tregp + z <= eo_regp || !stack_used)
- {
- /* because we're little endian, this is what it turns into. */
- *p_argv = (void*) tregp;
-
- p_argv++;
- regp = tregp + z;
- // if we read past the last core register, make sure we have not read
- // from the stack before and continue reading after regp
- if(regp > eo_regp)
- {
- if(stack_used)
- {
- abort(); // we should never read past the end of the register
- // are if the stack is already in use
- }
- argp = regp;
- }
- if(regp >= eo_regp)
- {
- done_with_regs = 1;
- stack_used = 1;
- }
- continue;
- }
- }
- stack_used = 1;
+ if (vi < cif->vfp_nargs && is_vfp_type)
+ {
+ *p_argv++ = (void *) (vfp_stack + cif->vfp_args[vi++]);
+ continue;
+ }
+ else if (!done_with_regs && !is_vfp_type)
+ {
+ char *tregp = ffi_align (p_arg, regp);
+
+ z = (*p_arg)->size;
+ z = (z < 4) ? 4 : z; // pad
+
+ /* if the arguments either fits into the registers or uses registers
+ * and stack, while we haven't read other things from the stack */
+ if (tregp + z <= eo_regp || !stack_used)
+ {
+ /* because we're little endian, this is what it turns into. */
+ *p_argv = (void *) tregp;
+
+ p_argv++;
+ regp = tregp + z;
+ // if we read past the last core register, make sure we have not read
+ // from the stack before and continue reading after regp
+ if (regp > eo_regp)
+ {
+ if (stack_used)
+ {
+ abort (); // we should never read past the end of the register
+ // are if the stack is already in use
+ }
+ argp = regp;
+ }
+ if (regp >= eo_regp)
+ {
+ done_with_regs = 1;
+ stack_used = 1;
+ }
+ continue;
+ }
+ }
+ stack_used = 1;
- argp = ffi_align(p_arg, argp);
+ argp = ffi_align (p_arg, argp);
- z = (*p_arg)->size;
+ z = (*p_arg)->size;
- /* because we're little endian, this is what it turns into. */
+ /* because we're little endian, this is what it turns into. */
- *p_argv = (void*) argp;
+ *p_argv = (void *) argp;
- p_argv++;
- argp += z;
+ p_argv++;
+ argp += z;
}
-
+
return;
}
@@ -549,7 +561,8 @@ 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 {
+struct ffi_trampoline_table
+{
/* contiguous writable and executable pages */
vm_address_t config_page;
vm_address_t trampoline_page;
@@ -563,8 +576,9 @@ struct ffi_trampoline_table {
ffi_trampoline_table *next;
};
-struct ffi_trampoline_table_entry {
- void *(*trampoline)();
+struct ffi_trampoline_table_entry
+{
+ void *(*trampoline) ();
ffi_trampoline_table_entry *next;
};
@@ -591,62 +605,79 @@ 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;
- }
+ 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;
- }
+ /* 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;
+ /* 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);
+ 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__);
- }
+ /* 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;
- }
+ 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;
+ /* 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));
+ /* 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));
+ 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];
- }
+ if (i < table->free_count - 1)
+ entry->next = &table->free_list_pool[i + 1];
+ }
- table->free_list = table->free_list_pool;
- }
+ table->free_list = table->free_list_pool;
+ }
return table;
}
@@ -655,28 +686,30 @@ void *
ffi_closure_alloc (size_t size, void **code)
{
/* Create the closure */
- ffi_closure *closure = malloc(size);
+ ffi_closure *closure = malloc (size);
if (closure == NULL)
return NULL;
- pthread_mutex_lock(&ffi_trampoline_lock);
+ 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;
- }
+ 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;
+ /* 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;
- }
+ ffi_trampoline_tables = table;
+ }
/* Claim the free entry */
ffi_trampoline_table_entry *entry = ffi_trampoline_tables->free_list;
@@ -684,7 +717,7 @@ ffi_closure_alloc (size_t size, void **code)
ffi_trampoline_tables->free_count--;
entry->next = NULL;
- pthread_mutex_unlock(&ffi_trampoline_lock);
+ pthread_mutex_unlock (&ffi_trampoline_lock);
/* Initialize the return values */
*code = entry->trampoline;
@@ -699,7 +732,7 @@ ffi_closure_free (void *ptr)
{
ffi_closure *closure = ptr;
- pthread_mutex_lock(&ffi_trampoline_lock);
+ pthread_mutex_lock (&ffi_trampoline_lock);
/* Fetch the table and entry references */
ffi_trampoline_table *table = closure->trampoline_table;
@@ -712,36 +745,43 @@ ffi_closure_free (void *ptr)
/* 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;
- }
+ 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);
@@ -770,13 +810,12 @@ ffi_closure_free (void *ptr)
/* the cif must already be prep'ed */
ffi_status
-ffi_prep_closure_loc (ffi_closure* closure,
- ffi_cif* cif,
- void (*fun)(ffi_cif*,void*,void**,void*),
- void *user_data,
- void *codeloc)
+ffi_prep_closure_loc (ffi_closure * closure,
+ ffi_cif * cif,
+ void (*fun) (ffi_cif *, void *, void **, void *),
+ void *user_data, void *codeloc)
{
- void (*closure_func)(ffi_closure*) = NULL;
+ void (*closure_func) (ffi_closure *) = NULL;
if (cif->abi == FFI_SYSV)
closure_func = &ffi_closure_SYSV;
@@ -788,25 +827,24 @@ ffi_prep_closure_loc (ffi_closure* closure,
return FFI_BAD_ABI;
#if FFI_EXEC_TRAMPOLINE_TABLE
- void **config = FFI_TRAMPOLINE_CODELOC_CONFIG(codeloc);
+ void **config = FFI_TRAMPOLINE_CODELOC_CONFIG (codeloc);
config[0] = closure;
config[1] = closure_func;
#else
- FFI_INIT_TRAMPOLINE (&closure->tramp[0], \
- closure_func, \
- codeloc);
+ FFI_INIT_TRAMPOLINE (&closure->tramp[0], closure_func, codeloc);
#endif
- closure->cif = cif;
+ closure->cif = cif;
closure->user_data = user_data;
- closure->fun = fun;
+ closure->fun = fun;
return FFI_OK;
}
/* Below are routines for VFP hard-float support. */
-static int rec_vfp_type_p (ffi_type *t, int *elt, int *elnum)
+static int
+rec_vfp_type_p (ffi_type * t, int *elt, int *elnum)
{
switch (t->type)
{
@@ -833,7 +871,7 @@ static int rec_vfp_type_p (ffi_type *t, int *elt, int *elnum)
while (*el)
{
int el_elt = 0, el_elnum = 0;
- if (! rec_vfp_type_p (*el, &el_elt, &el_elnum)
+ if (!rec_vfp_type_p (*el, &el_elt, &el_elnum)
|| (base_elt && base_elt != el_elt)
|| total_elnum + el_elnum > 4)
return 0;
@@ -845,12 +883,13 @@ static int rec_vfp_type_p (ffi_type *t, int *elt, int *elnum)
*elt = base_elt;
return 1;
}
- default: ;
+ default:;
}
return 0;
}
-static int vfp_type_p (ffi_type *t)
+static int
+vfp_type_p (ffi_type * t)
{
int elt, elnum;
if (rec_vfp_type_p (t, &elt, &elnum))
@@ -869,7 +908,8 @@ static int vfp_type_p (ffi_type *t)
return 0;
}
-static int place_vfp_arg (ffi_cif *cif, ffi_type *t)
+static int
+place_vfp_arg (ffi_cif * cif, ffi_type * t)
{
short reg = cif->vfp_reg_free;
int nregs = t->size / sizeof (float);
@@ -903,7 +943,7 @@ static int place_vfp_arg (ffi_cif *cif, ffi_type *t)
cif->vfp_reg_free = reg;
}
return 0;
- next_reg: ;
+ next_reg:;
}
// done, mark all regs as used
cif->vfp_reg_free = 16;
@@ -911,21 +951,22 @@ static int place_vfp_arg (ffi_cif *cif, ffi_type *t)
return 1;
}
-static void layout_vfp_args (ffi_cif *cif)
+static void
+layout_vfp_args (ffi_cif * cif)
{
int i;
/* Init VFP fields */
cif->vfp_used = 0;
cif->vfp_nargs = 0;
cif->vfp_reg_free = 0;
- memset (cif->vfp_args, -1, 16); /* Init to -1. */
+ memset (cif->vfp_args, -1, 16); /* Init to -1. */
for (i = 0; i < cif->nargs; i++)
{
ffi_type *t = cif->arg_types[i];
if (vfp_type_p (t) && place_vfp_arg (cif, t) == 1)
- {
- break;
- }
+ {
+ break;
+ }
}
}
--
1.9.3