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

Fix ChangeLog merge

Browse Source
This commit is contained in:
Anthony Green
2014-02-27 15:42:41 -05:00
parent 51377bda9a b4df9cf9cc
commit 447483d51c
19 changed files with 826 additions and 827 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/aarch64/ffi.c
+75 -18
View File
@@ -27,7 +27,11 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include <stdlib.h>
/* Stack alignment requirement in bytes */
#if defined (__APPLE__)
#define AARCH64_STACK_ALIGN 1
#else
#define AARCH64_STACK_ALIGN 16
#endif
#define N_X_ARG_REG 8
#define N_V_ARG_REG 8
@@ -49,6 +53,23 @@ struct call_context
} v [AARCH64_N_VREG];
};
#if defined (__clang__) && defined (__APPLE__)
extern void
sys_icache_invalidate (void *start, size_t len);
#endif
static inline void
ffi_clear_cache (void *start, void *end)
{
#if defined (__clang__) && defined (__APPLE__)
sys_icache_invalidate (start, (char *)end - (char *)start);
#elif defined (__GNUC__)
__builtin___clear_cache (start, end);
#else
#error "Missing builtin to flush instruction cache"
#endif
}
static void *
get_x_addr (struct call_context *context, unsigned n)
{
@@ -94,8 +115,10 @@ get_basic_type_addr (unsigned short type, struct call_context *context,
return get_s_addr (context, n);
case FFI_TYPE_DOUBLE:
return get_d_addr (context, n);
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
return get_v_addr (context, n);
#endif
case FFI_TYPE_UINT8:
case FFI_TYPE_SINT8:
case FFI_TYPE_UINT16:
@@ -107,6 +130,8 @@ get_basic_type_addr (unsigned short type, struct call_context *context,
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64:
return get_x_addr (context, n);
case FFI_TYPE_VOID:
return NULL;
default:
FFI_ASSERT (0);
return NULL;
@@ -123,15 +148,26 @@ get_basic_type_alignment (unsigned short type)
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
return sizeof (UINT64);
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
return sizeof (long double);
#endif
case FFI_TYPE_UINT8:
case FFI_TYPE_SINT8:
#if defined (__APPLE__)
return sizeof (UINT8);
#endif
case FFI_TYPE_UINT16:
case FFI_TYPE_SINT16:
#if defined (__APPLE__)
return sizeof (UINT16);
#endif
case FFI_TYPE_UINT32:
case FFI_TYPE_INT:
case FFI_TYPE_SINT32:
#if defined (__APPLE__)
return sizeof (UINT32);
#endif
case FFI_TYPE_POINTER:
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64:
@@ -154,8 +190,10 @@ get_basic_type_size (unsigned short type)
return sizeof (UINT32);
case FFI_TYPE_DOUBLE:
return sizeof (UINT64);
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
return sizeof (long double);
#endif
case FFI_TYPE_UINT8:
return sizeof (UINT8);
case FFI_TYPE_SINT8:
@@ -186,7 +224,7 @@ ffi_call_SYSV (unsigned (*)(struct call_context *context, unsigned char *,
extended_cif *),
struct call_context *context,
extended_cif *,
unsigned,
size_t,
void (*fn)(void));
extern void
@@ -305,7 +343,9 @@ is_register_candidate (ffi_type *ty)
case FFI_TYPE_VOID:
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
#endif
case FFI_TYPE_UINT8:
case FFI_TYPE_UINT16:
case FFI_TYPE_UINT32:
@@ -367,12 +407,12 @@ struct arg_state
{
unsigned ngrn; /* Next general-purpose register number. */
unsigned nsrn; /* Next vector register number. */
unsigned nsaa; /* Next stack offset. */
size_t nsaa; /* Next stack offset. */
};
/* Initialize a procedure call argument marshalling state. */
static void
arg_init (struct arg_state *state, unsigned call_frame_size)
arg_init (struct arg_state *state, size_t call_frame_size)
{
state->ngrn = 0;
state->nsrn = 0;
@@ -400,35 +440,35 @@ available_v (struct arg_state *state)
static void *
allocate_to_x (struct call_context *context, struct arg_state *state)
{
FFI_ASSERT (state->ngrn < N_X_ARG_REG)
FFI_ASSERT (state->ngrn < N_X_ARG_REG);
return get_x_addr (context, (state->ngrn)++);
}
static void *
allocate_to_s (struct call_context *context, struct arg_state *state)
{
FFI_ASSERT (state->nsrn < N_V_ARG_REG)
FFI_ASSERT (state->nsrn < N_V_ARG_REG);
return get_s_addr (context, (state->nsrn)++);
}
static void *
allocate_to_d (struct call_context *context, struct arg_state *state)
{
FFI_ASSERT (state->nsrn < N_V_ARG_REG)
FFI_ASSERT (state->nsrn < N_V_ARG_REG);
return get_d_addr (context, (state->nsrn)++);
}
static void *
allocate_to_v (struct call_context *context, struct arg_state *state)
{
FFI_ASSERT (state->nsrn < N_V_ARG_REG)
FFI_ASSERT (state->nsrn < N_V_ARG_REG);
return get_v_addr (context, (state->nsrn)++);
}
/* Allocate an aligned slot on the stack and return a pointer to it. */
static void *
allocate_to_stack (struct arg_state *state, void *stack, unsigned alignment,
unsigned size)
allocate_to_stack (struct arg_state *state, void *stack, size_t alignment,
size_t size)
{
void *allocation;
@@ -436,7 +476,9 @@ allocate_to_stack (struct arg_state *state, void *stack, unsigned alignment,
alignment of the argument's type. */
state->nsaa = ALIGN (state->nsaa, alignment);
state->nsaa = ALIGN (state->nsaa, alignment);
#if !defined (__APPLE__)
state->nsaa = ALIGN (state->nsaa, 8);
#endif
allocation = stack + state->nsaa;
@@ -457,9 +499,11 @@ copy_basic_type (void *dest, void *source, unsigned short type)
case FFI_TYPE_DOUBLE:
*(double *) dest = *(double *) source;
break;
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
*(long double *) dest = *(long double *) source;
break;
#endif
case FFI_TYPE_UINT8:
*(ffi_arg *) dest = *(UINT8 *) source;
break;
@@ -486,6 +530,8 @@ copy_basic_type (void *dest, void *source, unsigned short type)
case FFI_TYPE_SINT64:
*(ffi_sarg *) dest = *(SINT64 *) source;
break;
case FFI_TYPE_VOID:
break;
default:
FFI_ASSERT (0);
@@ -514,7 +560,6 @@ copy_hfa_to_reg_or_stack (void *memory,
{
int i;
unsigned short type = get_homogeneous_type (ty);
unsigned elems = element_count (ty);
for (i = 0; i < elems; i++)
{
void *reg = allocate_to_v (context, state);
@@ -548,11 +593,13 @@ allocate_to_register_or_stack (struct call_context *context,
return allocate_to_d (context, state);
state->nsrn = N_V_ARG_REG;
break;
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
if (state->nsrn < N_V_ARG_REG)
return allocate_to_v (context, state);
state->nsrn = N_V_ARG_REG;
break;
#endif
case FFI_TYPE_UINT8:
case FFI_TYPE_SINT8:
case FFI_TYPE_UINT16:
@@ -615,7 +662,9 @@ aarch64_prep_args (struct call_context *context, unsigned char *stack,
appropriate register, or if none are available, to the stack. */
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
#endif
case FFI_TYPE_UINT8:
case FFI_TYPE_SINT8:
case FFI_TYPE_UINT16:
@@ -728,7 +777,7 @@ ffi_call (ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
case FFI_SYSV:
{
struct call_context context;
unsigned stack_bytes;
size_t stack_bytes;
/* Figure out the total amount of stack space we need, the
above call frame space needs to be 16 bytes aligned to
@@ -745,7 +794,9 @@ ffi_call (ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
case FFI_TYPE_VOID:
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
#endif
case FFI_TYPE_UINT8:
case FFI_TYPE_SINT8:
case FFI_TYPE_UINT16:
@@ -778,7 +829,7 @@ ffi_call (ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
}
else if ((cif->rtype->size + 7) / 8 < N_X_ARG_REG)
{
unsigned size = ALIGN (cif->rtype->size, sizeof (UINT64));
size_t size = ALIGN (cif->rtype->size, sizeof (UINT64));
memcpy (rvalue, get_x_addr (&context, 0), size);
}
else
@@ -824,7 +875,7 @@ static unsigned char trampoline [] =
memcpy (__tramp + 12, &__fun, sizeof (__fun)); \
memcpy (__tramp + 20, &__ctx, sizeof (__ctx)); \
memcpy (__tramp + 28, &__flags, sizeof (__flags)); \
__clear_cache(__tramp, __tramp + FFI_TRAMPOLINE_SIZE); \
ffi_clear_cache(__tramp, __tramp + FFI_TRAMPOLINE_SIZE); \
})
ffi_status
@@ -863,7 +914,7 @@ ffi_prep_closure_loc (ffi_closure* closure,
descriptors, invokes the wrapped function, then marshalls the return
value back into the call context. */
void
void FFI_HIDDEN
ffi_closure_SYSV_inner (ffi_closure *closure, struct call_context *context,
void *stack)
{
@@ -897,10 +948,12 @@ ffi_closure_SYSV_inner (ffi_closure *closure, struct call_context *context,
case FFI_TYPE_SINT64:
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
avalue[i] = allocate_to_register_or_stack (context, stack,
&state, ty->type);
break;
#endif
case FFI_TYPE_STRUCT:
if (is_hfa (ty))
@@ -958,11 +1011,13 @@ ffi_closure_SYSV_inner (ffi_closure *closure, struct call_context *context,
break;
}
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
memcpy (&avalue[i],
allocate_to_v (context, &state),
sizeof (*avalue));
break;
#endif
default:
FFI_ASSERT (0);
@@ -1033,7 +1088,9 @@ ffi_closure_SYSV_inner (ffi_closure *closure, struct call_context *context,
case FFI_TYPE_SINT64:
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
#if FFI_TYPE_DOUBLE != FFI_TYPE_LONGDOUBLE
case FFI_TYPE_LONGDOUBLE:
#endif
{
void *addr = get_basic_type_addr (cif->rtype->type, context, 0);
copy_basic_type (addr, rvalue, cif->rtype->type);
@@ -1042,19 +1099,19 @@ ffi_closure_SYSV_inner (ffi_closure *closure, struct call_context *context,
case FFI_TYPE_STRUCT:
if (is_hfa (cif->rtype))
{
int i;
int j;
unsigned short type = get_homogeneous_type (cif->rtype);
unsigned elems = element_count (cif->rtype);
for (i = 0; i < elems; i++)
for (j = 0; j < elems; j++)
{
void *reg = get_basic_type_addr (type, context, i);
void *reg = get_basic_type_addr (type, context, j);
copy_basic_type (reg, rvalue, type);
rvalue += get_basic_type_size (type);
}
}
else if ((cif->rtype->size + 7) / 8 < N_X_ARG_REG)
{
unsigned size = ALIGN (cif->rtype->size, sizeof (UINT64)) ;
size_t size = ALIGN (cif->rtype->size, sizeof (UINT64)) ;
memcpy (get_x_addr (context, 0), rvalue, size);
}
else
src/aarch64/sysv.S
+31 -11
View File
@@ -23,14 +23,30 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#include <fficonfig.h>
#include <ffi.h>
#ifdef HAVE_MACHINE_ASM_H
#include <machine/asm.h>
#else
#ifdef __USER_LABEL_PREFIX__
#define CONCAT1(a, b) CONCAT2(a, b)
#define CONCAT2(a, b) a ## b
/* Use the right prefix for global labels. */
#define CNAME(x) CONCAT1 (__USER_LABEL_PREFIX__, x)
#else
#define CNAME(x) x
#endif
#endif
#define cfi_adjust_cfa_offset(off) .cfi_adjust_cfa_offset off
#define cfi_rel_offset(reg, off) .cfi_rel_offset reg, off
#define cfi_restore(reg) .cfi_restore reg
#define cfi_def_cfa_register(reg) .cfi_def_cfa_register reg
.text
.globl ffi_call_SYSV
.type ffi_call_SYSV, #function
.globl CNAME(ffi_call_SYSV)
#ifdef __ELF__
.type CNAME(ffi_call_SYSV), #function
#endif
/* ffi_call_SYSV()
@@ -53,7 +69,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
extended_cif *),
struct call_context *context,
extended_cif *,
unsigned required_stack_size,
size_t required_stack_size,
void (*fn)(void));
Therefore on entry we have:
@@ -82,7 +98,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#define ffi_call_SYSV_FS (8 * 4)
.cfi_startproc
ffi_call_SYSV:
CNAME(ffi_call_SYSV):
stp x29, x30, [sp, #-16]!
cfi_adjust_cfa_offset (16)
cfi_rel_offset (x29, 0)
@@ -92,11 +108,11 @@ ffi_call_SYSV:
cfi_def_cfa_register (x29)
sub sp, sp, #ffi_call_SYSV_FS
stp x21, x22, [sp, 0]
stp x21, x22, [sp, #0]
cfi_rel_offset (x21, 0 - ffi_call_SYSV_FS)
cfi_rel_offset (x22, 8 - ffi_call_SYSV_FS)
stp x23, x24, [sp, 16]
stp x23, x24, [sp, #16]
cfi_rel_offset (x23, 16 - ffi_call_SYSV_FS)
cfi_rel_offset (x24, 24 - ffi_call_SYSV_FS)
@@ -180,7 +196,9 @@ ffi_call_SYSV:
ret
.cfi_endproc
.size ffi_call_SYSV, .-ffi_call_SYSV
#ifdef __ELF__
.size CNAME(ffi_call_SYSV), .-CNAME(ffi_call_SYSV)
#endif
#define ffi_closure_SYSV_FS (8 * 2 + AARCH64_CALL_CONTEXT_SIZE)
@@ -222,9 +240,9 @@ ffi_call_SYSV:
Voila! */
.text
.globl ffi_closure_SYSV
.globl CNAME(ffi_closure_SYSV)
.cfi_startproc
ffi_closure_SYSV:
CNAME(ffi_closure_SYSV):
stp x29, x30, [sp, #-16]!
cfi_adjust_cfa_offset (16)
cfi_rel_offset (x29, 0)
@@ -270,7 +288,7 @@ ffi_closure_SYSV:
trampoline was called. */
add x2, x29, #16
bl ffi_closure_SYSV_inner
bl CNAME(ffi_closure_SYSV_inner)
/* Figure out if we should touch the vector registers. */
ldr x0, [x22, #8]
@@ -304,4 +322,6 @@ ffi_closure_SYSV:
ret
.cfi_endproc
.size ffi_closure_SYSV, .-ffi_closure_SYSV
#ifdef __ELF__
.size CNAME(ffi_closure_SYSV), .-CNAME(ffi_closure_SYSV)
#endif
src/arm/ffi.c
+15 -4
View File
@@ -37,6 +37,9 @@
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);
static char* ffi_align(ffi_type **p_arg, char *argp)
{
/* Align if necessary */
@@ -347,9 +350,17 @@ void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
break;
}
if (small_struct)
memcpy (rvalue, &temp, cif->rtype->size);
{
FFI_ASSERT(rvalue != NULL);
memcpy (rvalue, &temp, cif->rtype->size);
}
else if (vfp_struct)
memcpy (rvalue, ecif.rvalue, cif->rtype->size);
{
FFI_ASSERT(rvalue != NULL);
memcpy (rvalue, ecif.rvalue, cif->rtype->size);
}
}
/** private members **/
@@ -366,7 +377,7 @@ void ffi_closure_VFP (ffi_closure *);
/* This function is jumped to by the trampoline */
unsigned int
unsigned int FFI_HIDDEN
ffi_closure_inner (ffi_closure *closure,
void **respp, void *args, void *vfp_args)
{
@@ -860,7 +871,7 @@ static int vfp_type_p (ffi_type *t)
static int place_vfp_arg (ffi_cif *cif, ffi_type *t)
{
int reg = cif->vfp_reg_free;
short reg = cif->vfp_reg_free;
int nregs = t->size / sizeof (float);
int align = ((t->type == FFI_TYPE_STRUCT_VFP_FLOAT
|| t->type == FFI_TYPE_FLOAT) ? 1 : 2);
src/arm/sysv.S
+23 -38
View File
@@ -109,42 +109,27 @@
#define UNWIND @
#endif
.syntax unified
#if defined(__thumb__) && !defined(__THUMB_INTERWORK__)
.macro ARM_FUNC_START name
.text
.align 0
.thumb
.thumb_func
#ifdef __APPLE__
ENTRY($0)
#define ARM_FUNC_START(name) \
.text; \
.align 2; \
.thumb; \
.thumb_func; \
ENTRY(name); \
bx pc; \
nop; \
.arm; \
UNWIND .fnstart; \
_L__##name:
#else
ENTRY(\name)
#endif
bx pc
nop
.arm
#define ARM_FUNC_START(name) \
.text; \
.align 2; \
.arm; \
ENTRY(name); \
UNWIND .fnstart
/* A hook to tell gdb that we've switched to ARM mode. Also used to call
directly from other local arm routines. */
#ifdef __APPLE__
_L__$0:
#else
_L__\name:
#endif
.endm
#else
.macro ARM_FUNC_START name
.text
.align 0
.arm
#ifdef __APPLE__
ENTRY($0)
#else
ENTRY(\name)
#endif
UNWIND .fnstart
.endm
#endif
.macro RETLDM regs=, cond=, dirn=ia
@@ -171,7 +156,7 @@ _L__\name:
@ sp+0: ecif.rvalue
@ This assumes we are using gas.
ARM_FUNC_START ffi_call_SYSV
ARM_FUNC_START(ffi_call_SYSV)
@ Save registers
stmfd sp!, {r0-r3, fp, lr}
UNWIND .save {r0-r3, fp, lr}
@@ -228,7 +213,7 @@ ARM_FUNC_START ffi_call_SYSV
#if defined(__SOFTFP__) || defined(__ARM_EABI__)
cmpne r3, #FFI_TYPE_DOUBLE
#endif
stmeqia r2, {r0, r1}
stmiaeq r2, {r0, r1}
#if !defined(__SOFTFP__) && !defined(__ARM_EABI__)
beq LSYM(Lepilogue)
@@ -266,7 +251,7 @@ LSYM(Lepilogue):
void *args;
*/
ARM_FUNC_START ffi_closure_SYSV
ARM_FUNC_START(ffi_closure_SYSV)
UNWIND .pad #16
add ip, sp, #16
stmfd sp!, {ip, lr}
@@ -345,7 +330,7 @@ ARM_FUNC_START ffi_closure_SYSV
@ r3: fig->flags
@ sp+0: ecif.rvalue
ARM_FUNC_START ffi_call_VFP
ARM_FUNC_START(ffi_call_VFP)
@ Save registers
stmfd sp!, {r0-r3, fp, lr}
UNWIND .save {r0-r3, fp, lr}
@@ -433,7 +418,7 @@ LSYM(Lepilogue_vfp):
.size CNAME(ffi_call_VFP),.ffi_call_VFP_end-CNAME(ffi_call_VFP)
ARM_FUNC_START ffi_closure_VFP
ARM_FUNC_START(ffi_closure_VFP)
fstmfdd sp!, {d0-d7}
@ r0-r3, then d0-d7
UNWIND .pad #80
src/closures.c
+1 -1
View File
@@ -264,7 +264,7 @@ static int
open_temp_exec_file_dir (const char *dir)
{
static const char suffix[] = "/ffiXXXXXX";
int lendir = strlen (dir);
size_t lendir = strlen (dir);
char *tempname = __builtin_alloca (lendir + sizeof (suffix));
if (!tempname)
src/dlmalloc.c
+3 -3
View File
@@ -1661,7 +1661,7 @@ struct malloc_chunk {
typedef struct malloc_chunk mchunk;
typedef struct malloc_chunk* mchunkptr;
typedef struct malloc_chunk* sbinptr; /* The type of bins of chunks */
typedef unsigned int bindex_t; /* Described below */
typedef size_t bindex_t; /* Described below */
typedef unsigned int binmap_t; /* Described below */
typedef unsigned int flag_t; /* The type of various bit flag sets */
@@ -3388,7 +3388,7 @@ static void add_segment(mstate m, char* tbase, size_t tsize, flag_t mmapped) {
*ss = m->seg; /* Push current record */
m->seg.base = tbase;
m->seg.size = tsize;
set_segment_flags(&m->seg, mmapped);
(void)set_segment_flags(&m->seg, mmapped);
m->seg.next = ss;
/* Insert trailing fenceposts */
@@ -3548,7 +3548,7 @@ static void* sys_alloc(mstate m, size_t nb) {
if (!is_initialized(m)) { /* first-time initialization */
m->seg.base = m->least_addr = tbase;
m->seg.size = tsize;
set_segment_flags(&m->seg, mmap_flag);
(void)set_segment_flags(&m->seg, mmap_flag);
m->magic = mparams.magic;
init_bins(m);
if (is_global(m))
src/prep_cif.c
+1 -1
View File
@@ -187,7 +187,7 @@ ffi_status FFI_HIDDEN ffi_prep_cif_core(ffi_cif *cif, ffi_abi abi,
{
/* Add any padding if necessary */
if (((*ptr)->alignment - 1) & bytes)
bytes = ALIGN(bytes, (*ptr)->alignment);
bytes = (unsigned)ALIGN(bytes, (*ptr)->alignment);
#ifdef TILE
if (bytes < 10 * FFI_SIZEOF_ARG &&
src/x86/ffi.c
+2
View File
@@ -39,9 +39,11 @@
#include <stdlib.h>
/* ffi_prep_args is called by the assembly routine once stack space
has been allocated for the function's arguments */
void ffi_prep_args(char *stack, extended_cif *ecif);
void ffi_prep_args(char *stack, extended_cif *ecif)
{
register unsigned int i;
src/x86/ffi64.c
+15 -15
View File
@@ -152,7 +152,7 @@ merge_classes (enum x86_64_reg_class class1, enum x86_64_reg_class class2)
See the x86-64 PS ABI for details.
*/
static int
static size_t
classify_argument (ffi_type *type, enum x86_64_reg_class classes[],
size_t byte_offset)
{
@@ -168,7 +168,7 @@ classify_argument (ffi_type *type, enum x86_64_reg_class classes[],
case FFI_TYPE_SINT64:
case FFI_TYPE_POINTER:
{
int size = byte_offset + type->size;
size_t size = byte_offset + type->size;
if (size <= 4)
{
@@ -209,8 +209,8 @@ classify_argument (ffi_type *type, enum x86_64_reg_class classes[],
return 2;
case FFI_TYPE_STRUCT:
{
const int UNITS_PER_WORD = 8;
int words = (type->size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
const size_t UNITS_PER_WORD = 8;
size_t words = (type->size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
ffi_type **ptr;
int i;
enum x86_64_reg_class subclasses[MAX_CLASSES];
@@ -233,7 +233,7 @@ classify_argument (ffi_type *type, enum x86_64_reg_class classes[],
/* Merge the fields of structure. */
for (ptr = type->elements; *ptr != NULL; ptr++)
{
int num;
size_t num;
byte_offset = ALIGN (byte_offset, (*ptr)->alignment);
@@ -242,7 +242,7 @@ classify_argument (ffi_type *type, enum x86_64_reg_class classes[],
return 0;
for (i = 0; i < num; i++)
{
int pos = byte_offset / 8;
size_t pos = byte_offset / 8;
classes[i + pos] =
merge_classes (subclasses[i], classes[i + pos]);
}
@@ -306,11 +306,12 @@ classify_argument (ffi_type *type, enum x86_64_reg_class classes[],
class. Return zero iff parameter should be passed in memory, otherwise
the number of registers. */
static int
static size_t
examine_argument (ffi_type *type, enum x86_64_reg_class classes[MAX_CLASSES],
_Bool in_return, int *pngpr, int *pnsse)
{
int i, n, ngpr, nsse;
size_t n;
int i, ngpr, nsse;
n = classify_argument (type, classes, 0);
if (n == 0)
@@ -351,9 +352,9 @@ examine_argument (ffi_type *type, enum x86_64_reg_class classes[MAX_CLASSES],
ffi_status
ffi_prep_cif_machdep (ffi_cif *cif)
{
int gprcount, ssecount, i, avn, n, ngpr, nsse, flags;
int gprcount, ssecount, i, avn, ngpr, nsse, flags;
enum x86_64_reg_class classes[MAX_CLASSES];
size_t bytes;
size_t bytes, n;
gprcount = ssecount = 0;
@@ -411,7 +412,7 @@ ffi_prep_cif_machdep (ffi_cif *cif)
if (ssecount)
flags |= 1 << 11;
cif->flags = flags;
cif->bytes = ALIGN (bytes, 8);
cif->bytes = (unsigned)ALIGN (bytes, 8);
return FFI_OK;
}
@@ -454,8 +455,7 @@ ffi_call (ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
for (i = 0; i < avn; ++i)
{
size_t size = arg_types[i]->size;
int n;
size_t n, size = arg_types[i]->size;
n = examine_argument (arg_types[i], classes, 0, &ngpr, &nsse);
if (n == 0
@@ -584,7 +584,7 @@ ffi_closure_unix64_inner(ffi_closure *closure, void *rvalue,
if (ret != FFI_TYPE_VOID)
{
enum x86_64_reg_class classes[MAX_CLASSES];
int n = examine_argument (cif->rtype, classes, 1, &ngpr, &nsse);
size_t n = examine_argument (cif->rtype, classes, 1, &ngpr, &nsse);
if (n == 0)
{
/* The return value goes in memory. Arrange for the closure
@@ -611,7 +611,7 @@ ffi_closure_unix64_inner(ffi_closure *closure, void *rvalue,
for (i = 0; i < avn; ++i)
{
enum x86_64_reg_class classes[MAX_CLASSES];
int n;
size_t n;
n = examine_argument (arg_types[i], classes, 0, &ngpr, &nsse);
if (n == 0