From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 18594 invoked by alias); 29 Oct 2014 20:06:05 -0000 Mailing-List: contact libffi-discuss-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libffi-discuss-owner@sourceware.org Received: (qmail 18558 invoked by uid 89); 29 Oct 2014 20:06:04 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.3 required=5.0 tests=AWL,BAYES_00,FREEMAIL_ENVFROM_END_DIGIT,FREEMAIL_FROM,RCVD_IN_DNSWL_LOW,SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-qa0-f50.google.com Received: from mail-qa0-f50.google.com (HELO mail-qa0-f50.google.com) (209.85.216.50) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-SHA encrypted) ESMTPS; Wed, 29 Oct 2014 20:05:59 +0000 Received: by mail-qa0-f50.google.com with SMTP id bm13so960685qab.37 for ; Wed, 29 Oct 2014 13:05:56 -0700 (PDT) X-Received: by 10.140.89.232 with SMTP id v95mr18063074qgd.85.1414613154986; Wed, 29 Oct 2014 13:05:54 -0700 (PDT) Received: from pike.twiddle.home.com (50-194-63-110-static.hfc.comcastbusiness.net. [50.194.63.110]) by mx.google.com with ESMTPSA id a12sm5020495qai.1.2014.10.29.13.05.53 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 29 Oct 2014 13:05:54 -0700 (PDT) From: Richard Henderson To: libffi-discuss@sourceware.org Subject: [PATCH 01/10] arm: Reindent arm/ffi.c Date: Wed, 29 Oct 2014 20:06:00 -0000 Message-Id: <1414613147-10917-2-git-send-email-rth@twiddle.net> In-Reply-To: <1414613147-10917-1-git-send-email-rth@twiddle.net> References: <1414613147-10917-1-git-send-email-rth@twiddle.net> X-SW-Source: 2014/txt/msg00165.txt.bz2 --- 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