[Python-checkins] cpython (3.1): Revert typo fixes in _cytpes/libffi*
ezio.melotti
python-checkins at python.org
Tue Mar 15 18:21:43 CET 2011
http://hg.python.org/cpython/rev/1ba77f3ccc2e
changeset: 68505:1ba77f3ccc2e
branch: 3.1
parent: 68491:141bbcb19c06
user: Ezio Melotti <ezio.melotti at gmail.com>
date: Tue Mar 15 19:10:51 2011 +0200
summary:
Revert typo fixes in _cytpes/libffi*
files:
Modules/_ctypes/libffi/src/powerpc/ffi_darwin.c
Modules/_ctypes/libffi_osx/powerpc/ppc-ffi_darwin.c
diff --git a/Modules/_ctypes/libffi/src/powerpc/ffi_darwin.c b/Modules/_ctypes/libffi/src/powerpc/ffi_darwin.c
--- a/Modules/_ctypes/libffi/src/powerpc/ffi_darwin.c
+++ b/Modules/_ctypes/libffi/src/powerpc/ffi_darwin.c
@@ -59,24 +59,24 @@
The stack layout we want looks like this:
- | Return address from ffi_call_DARWIN | higher addresses
+ | Return address from ffi_call_DARWIN | higher addresses
|--------------------------------------------|
- | Previous backchain pointer 4 | stack pointer here
- |--------------------------------------------|<+ <<< on entry to
- | Saved r28-r31 4*4 | | ffi_call_DARWIN
+ | Previous backchain pointer 4 | stack pointer here
+ |--------------------------------------------|<+ <<< on entry to
+ | Saved r28-r31 4*4 | | ffi_call_DARWIN
|--------------------------------------------| |
| Parameters (at least 8*4=32) | |
|--------------------------------------------| |
| Space for GPR2 4 | |
- |--------------------------------------------| | stack |
- | Reserved 2*4 | | grows |
- |--------------------------------------------| | down V
- | Space for callee's LR 4 | |
- |--------------------------------------------| | lower addresses
+ |--------------------------------------------| | stack |
+ | Reserved 2*4 | | grows |
+ |--------------------------------------------| | down V
+ | Space for callee's LR 4 | |
+ |--------------------------------------------| | lower addresses
| Saved CR 4 | |
|--------------------------------------------| | stack pointer here
- | Current backchain pointer 4 |-/ during
- |--------------------------------------------| <<< ffi_call_DARWIN
+ | Current backchain pointer 4 |-/ during
+ |--------------------------------------------| <<< ffi_call_DARWIN
*/
@@ -123,106 +123,106 @@
i--, ptr++, p_argv++)
{
switch ((*ptr)->type)
- {
- /* If a floating-point parameter appears before all of the general-
- purpose registers are filled, the corresponding GPRs that match
- the size of the floating-point parameter are skipped. */
- case FFI_TYPE_FLOAT:
- double_tmp = *(float *)*p_argv;
- if (fparg_count >= NUM_FPR_ARG_REGISTERS)
- *(double *)next_arg = double_tmp;
- else
- *fpr_base++ = double_tmp;
- next_arg++;
- fparg_count++;
- FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
- break;
+ {
+ /* If a floating-point parameter appears before all of the general-
+ purpose registers are filled, the corresponding GPRs that match
+ the size of the floating-point parameter are skipped. */
+ case FFI_TYPE_FLOAT:
+ double_tmp = *(float *)*p_argv;
+ if (fparg_count >= NUM_FPR_ARG_REGISTERS)
+ *(double *)next_arg = double_tmp;
+ else
+ *fpr_base++ = double_tmp;
+ next_arg++;
+ fparg_count++;
+ FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
+ break;
- case FFI_TYPE_DOUBLE:
- double_tmp = *(double *)*p_argv;
- if (fparg_count >= NUM_FPR_ARG_REGISTERS)
- *(double *)next_arg = double_tmp;
- else
- *fpr_base++ = double_tmp;
- next_arg += 2;
- fparg_count++;
- FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
- break;
+ case FFI_TYPE_DOUBLE:
+ double_tmp = *(double *)*p_argv;
+ if (fparg_count >= NUM_FPR_ARG_REGISTERS)
+ *(double *)next_arg = double_tmp;
+ else
+ *fpr_base++ = double_tmp;
+ next_arg += 2;
+ fparg_count++;
+ FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
+ break;
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
- case FFI_TYPE_LONGDOUBLE:
- double_tmp = ((double *)*p_argv)[0];
- if (fparg_count >= NUM_FPR_ARG_REGISTERS)
- *(double *)next_arg = double_tmp;
- else
- *fpr_base++ = double_tmp;
- next_arg += 2;
- fparg_count++;
- double_tmp = ((double *)*p_argv)[1];
- if (fparg_count >= NUM_FPR_ARG_REGISTERS)
- *(double *)next_arg = double_tmp;
- else
- *fpr_base++ = double_tmp;
- next_arg += 2;
- fparg_count++;
- FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
- break;
+ case FFI_TYPE_LONGDOUBLE:
+ double_tmp = ((double *)*p_argv)[0];
+ if (fparg_count >= NUM_FPR_ARG_REGISTERS)
+ *(double *)next_arg = double_tmp;
+ else
+ *fpr_base++ = double_tmp;
+ next_arg += 2;
+ fparg_count++;
+ double_tmp = ((double *)*p_argv)[1];
+ if (fparg_count >= NUM_FPR_ARG_REGISTERS)
+ *(double *)next_arg = double_tmp;
+ else
+ *fpr_base++ = double_tmp;
+ next_arg += 2;
+ fparg_count++;
+ FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
+ break;
#endif
- case FFI_TYPE_UINT64:
- case FFI_TYPE_SINT64:
- *(long long *)next_arg = *(long long *)*p_argv;
- next_arg+=2;
- break;
- case FFI_TYPE_UINT8:
- gprvalue = *(unsigned char *)*p_argv;
- goto putgpr;
- case FFI_TYPE_SINT8:
- gprvalue = *(signed char *)*p_argv;
- goto putgpr;
- case FFI_TYPE_UINT16:
- gprvalue = *(unsigned short *)*p_argv;
- goto putgpr;
- case FFI_TYPE_SINT16:
- gprvalue = *(signed short *)*p_argv;
- goto putgpr;
+ case FFI_TYPE_UINT64:
+ case FFI_TYPE_SINT64:
+ *(long long *)next_arg = *(long long *)*p_argv;
+ next_arg+=2;
+ break;
+ case FFI_TYPE_UINT8:
+ gprvalue = *(unsigned char *)*p_argv;
+ goto putgpr;
+ case FFI_TYPE_SINT8:
+ gprvalue = *(signed char *)*p_argv;
+ goto putgpr;
+ case FFI_TYPE_UINT16:
+ gprvalue = *(unsigned short *)*p_argv;
+ goto putgpr;
+ case FFI_TYPE_SINT16:
+ gprvalue = *(signed short *)*p_argv;
+ goto putgpr;
- case FFI_TYPE_STRUCT:
- dest_cpy = (char *) next_arg;
+ case FFI_TYPE_STRUCT:
+ dest_cpy = (char *) next_arg;
- /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
- SI 4 bytes) are aligned as if they were those modes.
- Structures with 3 byte in size are padded upwards. */
- size_al = (*ptr)->size;
- /* If the first member of the struct is a double, then align
- the struct to double-word.
- Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
- if ((*ptr)->elements[0]->type == 3)
- size_al = ALIGN((*ptr)->size, 8);
- if (size_al < 3 && ecif->cif->abi == FFI_DARWIN)
- dest_cpy += 4 - size_al;
+ /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
+ SI 4 bytes) are aligned as if they were those modes.
+ Structures with 3 byte in size are padded upwards. */
+ size_al = (*ptr)->size;
+ /* If the first member of the struct is a double, then align
+ the struct to double-word.
+ Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
+ if ((*ptr)->elements[0]->type == 3)
+ size_al = ALIGN((*ptr)->size, 8);
+ if (size_al < 3 && ecif->cif->abi == FFI_DARWIN)
+ dest_cpy += 4 - size_al;
- memcpy((char *)dest_cpy, (char *)*p_argv, size_al);
- next_arg += (size_al + 3) / 4;
- break;
+ memcpy((char *)dest_cpy, (char *)*p_argv, size_al);
+ next_arg += (size_al + 3) / 4;
+ break;
- case FFI_TYPE_INT:
- case FFI_TYPE_UINT32:
- case FFI_TYPE_SINT32:
- case FFI_TYPE_POINTER:
- gprvalue = *(unsigned *)*p_argv;
- putgpr:
- *next_arg++ = gprvalue;
- break;
- default:
- break;
- }
+ case FFI_TYPE_INT:
+ case FFI_TYPE_UINT32:
+ case FFI_TYPE_SINT32:
+ case FFI_TYPE_POINTER:
+ gprvalue = *(unsigned *)*p_argv;
+ putgpr:
+ *next_arg++ = gprvalue;
+ break;
+ default:
+ break;
+ }
}
/* Check that we didn't overrun the stack... */
//FFI_ASSERT(gpr_base <= stacktop - ASM_NEEDS_REGISTERS);
//FFI_ASSERT((unsigned *)fpr_base
- // <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
+ // <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
//FFI_ASSERT(flags & FLAG_4_GPR_ARGUMENTS || intarg_count <= 4);
}
@@ -246,15 +246,15 @@
p = s->elements[i];
darwin_adjust_aggregate_sizes (p);
if (i == 0
- && (p->type == FFI_TYPE_UINT64
- || p->type == FFI_TYPE_SINT64
- || p->type == FFI_TYPE_DOUBLE
- || p->alignment == 8))
- align = 8;
+ && (p->type == FFI_TYPE_UINT64
+ || p->type == FFI_TYPE_SINT64
+ || p->type == FFI_TYPE_DOUBLE
+ || p->alignment == 8))
+ align = 8;
else if (p->alignment == 16 || p->alignment < 4)
- align = p->alignment;
+ align = p->alignment;
else
- align = 4;
+ align = 4;
s->size = ALIGN(s->size, align) + p->size;
}
@@ -287,7 +287,7 @@
{
darwin_adjust_aggregate_sizes (cif->rtype);
for (i = 0; i < cif->nargs; i++)
- darwin_adjust_aggregate_sizes (cif->arg_types[i]);
+ darwin_adjust_aggregate_sizes (cif->arg_types[i]);
}
/* Space for the frame pointer, callee's LR, CR, etc, and for
@@ -348,58 +348,58 @@
for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
{
switch ((*ptr)->type)
- {
- case FFI_TYPE_FLOAT:
- case FFI_TYPE_DOUBLE:
- fparg_count++;
- /* If this FP arg is going on the stack, it must be
- 8-byte-aligned. */
- if (fparg_count > NUM_FPR_ARG_REGISTERS
- && intarg_count%2 != 0)
- intarg_count++;
- break;
+ {
+ case FFI_TYPE_FLOAT:
+ case FFI_TYPE_DOUBLE:
+ fparg_count++;
+ /* If this FP arg is going on the stack, it must be
+ 8-byte-aligned. */
+ if (fparg_count > NUM_FPR_ARG_REGISTERS
+ && intarg_count%2 != 0)
+ intarg_count++;
+ break;
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
- case FFI_TYPE_LONGDOUBLE:
- fparg_count += 2;
- /* If this FP arg is going on the stack, it must be
- 8-byte-aligned. */
- if (fparg_count > NUM_FPR_ARG_REGISTERS
- && intarg_count%2 != 0)
- intarg_count++;
- intarg_count +=2;
- break;
+ case FFI_TYPE_LONGDOUBLE:
+ fparg_count += 2;
+ /* If this FP arg is going on the stack, it must be
+ 8-byte-aligned. */
+ if (fparg_count > NUM_FPR_ARG_REGISTERS
+ && intarg_count%2 != 0)
+ intarg_count++;
+ intarg_count +=2;
+ break;
#endif
- case FFI_TYPE_UINT64:
- case FFI_TYPE_SINT64:
- /* 'long long' arguments are passed as two words, but
- either both words must fit in registers or both go
- on the stack. If they go on the stack, they must
- be 8-byte-aligned. */
- if (intarg_count == NUM_GPR_ARG_REGISTERS-1
- || (intarg_count >= NUM_GPR_ARG_REGISTERS && intarg_count%2 != 0))
- intarg_count++;
- intarg_count += 2;
- break;
+ case FFI_TYPE_UINT64:
+ case FFI_TYPE_SINT64:
+ /* 'long long' arguments are passed as two words, but
+ either both words must fit in registers or both go
+ on the stack. If they go on the stack, they must
+ be 8-byte-aligned. */
+ if (intarg_count == NUM_GPR_ARG_REGISTERS-1
+ || (intarg_count >= NUM_GPR_ARG_REGISTERS && intarg_count%2 != 0))
+ intarg_count++;
+ intarg_count += 2;
+ break;
- case FFI_TYPE_STRUCT:
- size_al = (*ptr)->size;
- /* If the first member of the struct is a double, then align
- the struct to double-word.
- Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
- if ((*ptr)->elements[0]->type == 3)
- size_al = ALIGN((*ptr)->size, 8);
- intarg_count += (size_al + 3) / 4;
- break;
+ case FFI_TYPE_STRUCT:
+ size_al = (*ptr)->size;
+ /* If the first member of the struct is a double, then align
+ the struct to double-word.
+ Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
+ if ((*ptr)->elements[0]->type == 3)
+ size_al = ALIGN((*ptr)->size, 8);
+ intarg_count += (size_al + 3) / 4;
+ break;
- default:
- /* Everything else is passed as a 4-byte word in a GPR, either
- the object itself or a pointer to it. */
- intarg_count++;
- break;
- }
+ default:
+ /* Everything else is passed as a 4-byte word in a GPR, either
+ the object itself or a pointer to it. */
+ intarg_count++;
+ break;
+ }
}
if (fparg_count != 0)
@@ -425,9 +425,9 @@
}
extern void ffi_call_AIX(extended_cif *, unsigned, unsigned, unsigned *,
- void (*fn)(void), void (*fn2)(void));
+ void (*fn)(void), void (*fn2)(void));
extern void ffi_call_DARWIN(extended_cif *, unsigned, unsigned, unsigned *,
- void (*fn)(void), void (*fn2)(void));
+ void (*fn)(void), void (*fn2)(void));
void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
{
@@ -451,11 +451,11 @@
{
case FFI_AIX:
ffi_call_AIX(&ecif, -cif->bytes, cif->flags, ecif.rvalue, fn,
- ffi_prep_args);
+ ffi_prep_args);
break;
case FFI_DARWIN:
ffi_call_DARWIN(&ecif, -cif->bytes, cif->flags, ecif.rvalue, fn,
- ffi_prep_args);
+ ffi_prep_args);
break;
default:
FFI_ASSERT(0);
@@ -478,61 +478,61 @@
and aix_clsoure.S
SP previous -> +---------------------------------------+ <--- child frame
- | back chain to caller 4 |
- +---------------------------------------+ 4
- | saved CR 4 |
- +---------------------------------------+ 8
- | saved LR 4 |
- +---------------------------------------+ 12
- | reserved for compilers 4 |
- +---------------------------------------+ 16
- | reserved for binders 4 |
- +---------------------------------------+ 20
- | saved TOC pointer 4 |
- +---------------------------------------+ 24
- | always reserved 8*4=32 (previous GPRs)|
- | according to the linkage convention |
- | from AIX |
- +---------------------------------------+ 56
- | our FPR area 13*8=104 |
- | f1 |
- | . |
- | f13 |
- +---------------------------------------+ 160
- | result area 8 |
- +---------------------------------------+ 168
- | alignment to the next multiple of 16 |
+ | back chain to caller 4 |
+ +---------------------------------------+ 4
+ | saved CR 4 |
+ +---------------------------------------+ 8
+ | saved LR 4 |
+ +---------------------------------------+ 12
+ | reserved for compilers 4 |
+ +---------------------------------------+ 16
+ | reserved for binders 4 |
+ +---------------------------------------+ 20
+ | saved TOC pointer 4 |
+ +---------------------------------------+ 24
+ | always reserved 8*4=32 (previous GPRs)|
+ | according to the linkage convention |
+ | from AIX |
+ +---------------------------------------+ 56
+ | our FPR area 13*8=104 |
+ | f1 |
+ | . |
+ | f13 |
+ +---------------------------------------+ 160
+ | result area 8 |
+ +---------------------------------------+ 168
+ | alignement to the next multiple of 16 |
SP current --> +---------------------------------------+ 176 <- parent frame
- | back chain to caller 4 |
- +---------------------------------------+ 180
- | saved CR 4 |
- +---------------------------------------+ 184
- | saved LR 4 |
- +---------------------------------------+ 188
- | reserved for compilers 4 |
- +---------------------------------------+ 192
- | reserved for binders 4 |
- +---------------------------------------+ 196
- | saved TOC pointer 4 |
- +---------------------------------------+ 200
- | always reserved 8*4=32 we store our |
- | GPRs here |
- | r3 |
- | . |
- | r10 |
- +---------------------------------------+ 232
- | overflow part |
- +---------------------------------------+ xxx
- | ???? |
- +---------------------------------------+ xxx
+ | back chain to caller 4 |
+ +---------------------------------------+ 180
+ | saved CR 4 |
+ +---------------------------------------+ 184
+ | saved LR 4 |
+ +---------------------------------------+ 188
+ | reserved for compilers 4 |
+ +---------------------------------------+ 192
+ | reserved for binders 4 |
+ +---------------------------------------+ 196
+ | saved TOC pointer 4 |
+ +---------------------------------------+ 200
+ | always reserved 8*4=32 we store our |
+ | GPRs here |
+ | r3 |
+ | . |
+ | r10 |
+ +---------------------------------------+ 232
+ | overflow part |
+ +---------------------------------------+ xxx
+ | ???? |
+ +---------------------------------------+ xxx
*/
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_cif* cif,
+ void (*fun)(ffi_cif*, void*, void**, void*),
+ void *user_data,
+ void *codeloc)
{
unsigned int *tramp;
struct ffi_aix_trampoline_struct *tramp_aix;
@@ -592,12 +592,12 @@
{
#ifndef _AIX
__asm__ volatile (
- "dcbf 0,%0\n"
- "\tsync\n"
- "\ticbi 0,%0\n"
- "\tsync\n"
- "\tisync"
- : : "r"(addr) : "memory");
+ "dcbf 0,%0\n"
+ "\tsync\n"
+ "\ticbi 0,%0\n"
+ "\tsync\n"
+ "\tisync"
+ : : "r"(addr) : "memory");
#endif
}
@@ -618,7 +618,7 @@
} ffi_dblfl;
int ffi_closure_helper_DARWIN (ffi_closure*, void*,
- unsigned long*, ffi_dblfl*);
+ unsigned long*, ffi_dblfl*);
/* Basically the trampoline invokes ffi_closure_ASM, and on
entry, r11 holds the address of the closure.
@@ -628,7 +628,7 @@
following helper function to do most of the work. */
int ffi_closure_helper_DARWIN (ffi_closure* closure, void * rvalue,
- unsigned long * pgr, ffi_dblfl * pfr)
+ unsigned long * pgr, ffi_dblfl * pfr)
{
/* rvalue is the pointer to space for return value in closure assembly
pgr is the pointer to where r3-r10 are stored in ffi_closure_ASM
@@ -675,121 +675,121 @@
while (i < avn)
{
switch (arg_types[i]->type)
- {
- case FFI_TYPE_SINT8:
- case FFI_TYPE_UINT8:
- avalue[i] = (char *) pgr + 3;
- ng++;
- pgr++;
- break;
+ {
+ case FFI_TYPE_SINT8:
+ case FFI_TYPE_UINT8:
+ avalue[i] = (char *) pgr + 3;
+ ng++;
+ pgr++;
+ break;
- case FFI_TYPE_SINT16:
- case FFI_TYPE_UINT16:
- avalue[i] = (char *) pgr + 2;
- ng++;
- pgr++;
- break;
+ case FFI_TYPE_SINT16:
+ case FFI_TYPE_UINT16:
+ avalue[i] = (char *) pgr + 2;
+ ng++;
+ pgr++;
+ break;
- case FFI_TYPE_SINT32:
- case FFI_TYPE_UINT32:
- case FFI_TYPE_POINTER:
- avalue[i] = pgr;
- ng++;
- pgr++;
- break;
+ case FFI_TYPE_SINT32:
+ case FFI_TYPE_UINT32:
+ case FFI_TYPE_POINTER:
+ avalue[i] = pgr;
+ ng++;
+ pgr++;
+ break;
- case FFI_TYPE_STRUCT:
- /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
- SI 4 bytes) are aligned as if they were those modes. */
- size_al = arg_types[i]->size;
- /* If the first member of the struct is a double, then align
- the struct to double-word.
- Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
- if (arg_types[i]->elements[0]->type == 3)
- size_al = ALIGN(arg_types[i]->size, 8);
- if (size_al < 3 && cif->abi == FFI_DARWIN)
- avalue[i] = (void*) pgr + 4 - size_al;
- else
- avalue[i] = (void*) pgr;
- ng += (size_al + 3) / 4;
- pgr += (size_al + 3) / 4;
- break;
+ case FFI_TYPE_STRUCT:
+ /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
+ SI 4 bytes) are aligned as if they were those modes. */
+ size_al = arg_types[i]->size;
+ /* If the first member of the struct is a double, then align
+ the struct to double-word.
+ Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
+ if (arg_types[i]->elements[0]->type == 3)
+ size_al = ALIGN(arg_types[i]->size, 8);
+ if (size_al < 3 && cif->abi == FFI_DARWIN)
+ avalue[i] = (void*) pgr + 4 - size_al;
+ else
+ avalue[i] = (void*) pgr;
+ ng += (size_al + 3) / 4;
+ pgr += (size_al + 3) / 4;
+ break;
- case FFI_TYPE_SINT64:
- case FFI_TYPE_UINT64:
- /* Long long ints are passed in two gpr's. */
- avalue[i] = pgr;
- ng += 2;
- pgr += 2;
- break;
+ case FFI_TYPE_SINT64:
+ case FFI_TYPE_UINT64:
+ /* Long long ints are passed in two gpr's. */
+ avalue[i] = pgr;
+ ng += 2;
+ pgr += 2;
+ break;
- case FFI_TYPE_FLOAT:
- /* A float value consumes a GPR.
- There are 13 64bit floating point registers. */
- if (nf < NUM_FPR_ARG_REGISTERS)
- {
- temp = pfr->d;
- pfr->f = (float)temp;
- avalue[i] = pfr;
- pfr++;
- }
- else
- {
- avalue[i] = pgr;
- }
- nf++;
- ng++;
- pgr++;
- break;
+ case FFI_TYPE_FLOAT:
+ /* A float value consumes a GPR.
+ There are 13 64bit floating point registers. */
+ if (nf < NUM_FPR_ARG_REGISTERS)
+ {
+ temp = pfr->d;
+ pfr->f = (float)temp;
+ avalue[i] = pfr;
+ pfr++;
+ }
+ else
+ {
+ avalue[i] = pgr;
+ }
+ nf++;
+ ng++;
+ pgr++;
+ break;
- case FFI_TYPE_DOUBLE:
- /* A double value consumes two GPRs.
- There are 13 64bit floating point registers. */
- if (nf < NUM_FPR_ARG_REGISTERS)
- {
- avalue[i] = pfr;
- pfr++;
- }
- else
- {
- avalue[i] = pgr;
- }
- nf++;
- ng += 2;
- pgr += 2;
- break;
+ case FFI_TYPE_DOUBLE:
+ /* A double value consumes two GPRs.
+ There are 13 64bit floating point registers. */
+ if (nf < NUM_FPR_ARG_REGISTERS)
+ {
+ avalue[i] = pfr;
+ pfr++;
+ }
+ else
+ {
+ avalue[i] = pgr;
+ }
+ nf++;
+ ng += 2;
+ pgr += 2;
+ break;
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
- case FFI_TYPE_LONGDOUBLE:
- /* A long double value consumes four GPRs and two FPRs.
- There are 13 64bit floating point registers. */
- if (nf < NUM_FPR_ARG_REGISTERS - 1)
- {
- avalue[i] = pfr;
- pfr += 2;
- }
- /* Here we have the situation where one part of the long double
- is stored in fpr13 and the other part is already on the stack.
- We use a union to pass the long double to avalue[i]. */
- else if (nf == NUM_FPR_ARG_REGISTERS - 1)
- {
- memcpy (&temp_ld.lb[0], pfr, sizeof(ldbits));
- memcpy (&temp_ld.lb[1], pgr + 2, sizeof(ldbits));
- avalue[i] = &temp_ld.ld;
- }
- else
- {
- avalue[i] = pgr;
- }
- nf += 2;
- ng += 4;
- pgr += 4;
- break;
+ case FFI_TYPE_LONGDOUBLE:
+ /* A long double value consumes four GPRs and two FPRs.
+ There are 13 64bit floating point registers. */
+ if (nf < NUM_FPR_ARG_REGISTERS - 1)
+ {
+ avalue[i] = pfr;
+ pfr += 2;
+ }
+ /* Here we have the situation where one part of the long double
+ is stored in fpr13 and the other part is already on the stack.
+ We use a union to pass the long double to avalue[i]. */
+ else if (nf == NUM_FPR_ARG_REGISTERS - 1)
+ {
+ memcpy (&temp_ld.lb[0], pfr, sizeof(ldbits));
+ memcpy (&temp_ld.lb[1], pgr + 2, sizeof(ldbits));
+ avalue[i] = &temp_ld.ld;
+ }
+ else
+ {
+ avalue[i] = pgr;
+ }
+ nf += 2;
+ ng += 4;
+ pgr += 4;
+ break;
#endif
- default:
- FFI_ASSERT(0);
- }
+ default:
+ FFI_ASSERT(0);
+ }
i++;
}
diff --git a/Modules/_ctypes/libffi_osx/powerpc/ppc-ffi_darwin.c b/Modules/_ctypes/libffi_osx/powerpc/ppc-ffi_darwin.c
--- a/Modules/_ctypes/libffi_osx/powerpc/ppc-ffi_darwin.c
+++ b/Modules/_ctypes/libffi_osx/powerpc/ppc-ffi_darwin.c
@@ -39,7 +39,7 @@
#if 0
#if defined(POWERPC_DARWIN)
-#include <libkern/OSCacheControl.h> // for sys_icache_invalidate()
+#include <libkern/OSCacheControl.h> // for sys_icache_invalidate()
#endif
#else
@@ -55,8 +55,8 @@
// The layout of a function descriptor. A C function pointer really
// points to one of these.
typedef struct aix_fd_struct {
- void* code_pointer;
- void* toc;
+ void* code_pointer;
+ void* toc;
} aix_fd;
/* ffi_prep_args is called by the assembly routine once stack space
@@ -64,241 +64,241 @@
The stack layout we want looks like this:
- | Return address from ffi_call_DARWIN | higher addresses
+ | Return address from ffi_call_DARWIN | higher addresses
|--------------------------------------------|
- | Previous backchain pointer 4/8 | stack pointer here
+ | Previous backchain pointer 4/8 | stack pointer here
|--------------------------------------------|-\ <<< on entry to
- | Saved r28-r31 (4/8)*4 | | ffi_call_DARWIN
+ | Saved r28-r31 (4/8)*4 | | ffi_call_DARWIN
|--------------------------------------------| |
| Parameters (at least 8*(4/8)=32/64) | | (176) +112 - +288
|--------------------------------------------| |
| Space for GPR2 4/8 | |
- |--------------------------------------------| | stack |
- | Reserved (4/8)*2 | | grows |
- |--------------------------------------------| | down V
+ |--------------------------------------------| | stack |
+ | Reserved (4/8)*2 | | grows |
+ |--------------------------------------------| | down V
| Space for callee's LR 4/8 | |
- |--------------------------------------------| | lower addresses
+ |--------------------------------------------| | lower addresses
| Saved CR 4/8 | |
|--------------------------------------------| | stack pointer here
| Current backchain pointer 4/8 | | during
|--------------------------------------------|-/ <<< ffi_call_DARWIN
- Note: ppc64 CR is saved in the low word of a long on the stack.
+ Note: ppc64 CR is saved in the low word of a long on the stack.
*/
/*@-exportheader@*/
void
ffi_prep_args(
- extended_cif* inEcif,
- unsigned *const stack)
+ extended_cif* inEcif,
+ unsigned *const stack)
/*@=exportheader@*/
{
- /* Copy the ecif to a local var so we can trample the arg.
- BC note: test this with GP later for possible problems... */
- volatile extended_cif* ecif = inEcif;
+ /* Copy the ecif to a local var so we can trample the arg.
+ BC note: test this with GP later for possible problems... */
+ volatile extended_cif* ecif = inEcif;
- const unsigned bytes = ecif->cif->bytes;
- const unsigned flags = ecif->cif->flags;
+ const unsigned bytes = ecif->cif->bytes;
+ const unsigned flags = ecif->cif->flags;
- /* Cast the stack arg from int* to long*. sizeof(long) == 4 in 32-bit mode
- and 8 in 64-bit mode. */
- unsigned long *const longStack = (unsigned long *const)stack;
+ /* Cast the stack arg from int* to long*. sizeof(long) == 4 in 32-bit mode
+ and 8 in 64-bit mode. */
+ unsigned long *const longStack = (unsigned long *const)stack;
- /* 'stacktop' points at the previous backchain pointer. */
+ /* 'stacktop' points at the previous backchain pointer. */
#if defined(__ppc64__)
- // In ppc-darwin.s, an extra 96 bytes is reserved for the linkage area,
- // saved registers, and an extra FPR.
- unsigned long *const stacktop =
- (unsigned long *)(unsigned long)((char*)longStack + bytes + 96);
+ // In ppc-darwin.s, an extra 96 bytes is reserved for the linkage area,
+ // saved registers, and an extra FPR.
+ unsigned long *const stacktop =
+ (unsigned long *)(unsigned long)((char*)longStack + bytes + 96);
#elif defined(__ppc__)
- unsigned long *const stacktop = longStack + (bytes / sizeof(long));
+ unsigned long *const stacktop = longStack + (bytes / sizeof(long));
#else
#error undefined architecture
#endif
- /* 'fpr_base' points at the space for fpr1, and grows upwards as
- we use FPR registers. */
- double* fpr_base = (double*)(stacktop - ASM_NEEDS_REGISTERS) -
- NUM_FPR_ARG_REGISTERS;
+ /* 'fpr_base' points at the space for fpr1, and grows upwards as
+ we use FPR registers. */
+ double* fpr_base = (double*)(stacktop - ASM_NEEDS_REGISTERS) -
+ NUM_FPR_ARG_REGISTERS;
#if defined(__ppc64__)
- // 64-bit saves an extra register, and uses an extra FPR. Knock fpr_base
- // down a couple pegs.
- fpr_base -= 2;
+ // 64-bit saves an extra register, and uses an extra FPR. Knock fpr_base
+ // down a couple pegs.
+ fpr_base -= 2;
#endif
- unsigned int fparg_count = 0;
+ unsigned int fparg_count = 0;
- /* 'next_arg' grows up as we put parameters in it. */
- unsigned long* next_arg = longStack + 6; /* 6 reserved positions. */
+ /* 'next_arg' grows up as we put parameters in it. */
+ unsigned long* next_arg = longStack + 6; /* 6 reserved positions. */
- int i;
- double double_tmp;
- void** p_argv = ecif->avalue;
- unsigned long gprvalue;
- ffi_type** ptr = ecif->cif->arg_types;
+ int i;
+ double double_tmp;
+ void** p_argv = ecif->avalue;
+ unsigned long gprvalue;
+ ffi_type** ptr = ecif->cif->arg_types;
- /* Check that everything starts aligned properly. */
- FFI_ASSERT(stack == SF_ROUND(stack));
- FFI_ASSERT(stacktop == SF_ROUND(stacktop));
- FFI_ASSERT(bytes == SF_ROUND(bytes));
+ /* Check that everything starts aligned properly. */
+ FFI_ASSERT(stack == SF_ROUND(stack));
+ FFI_ASSERT(stacktop == SF_ROUND(stacktop));
+ FFI_ASSERT(bytes == SF_ROUND(bytes));
- /* Deal with return values that are actually pass-by-reference.
- Rule:
- Return values are referenced by r3, so r4 is the first parameter. */
+ /* Deal with return values that are actually pass-by-reference.
+ Rule:
+ Return values are referenced by r3, so r4 is the first parameter. */
- if (flags & FLAG_RETVAL_REFERENCE)
- *next_arg++ = (unsigned long)(char*)ecif->rvalue;
+ if (flags & FLAG_RETVAL_REFERENCE)
+ *next_arg++ = (unsigned long)(char*)ecif->rvalue;
- /* Now for the arguments. */
- for (i = ecif->cif->nargs; i > 0; i--, ptr++, p_argv++)
+ /* Now for the arguments. */
+ for (i = ecif->cif->nargs; i > 0; i--, ptr++, p_argv++)
{
- switch ((*ptr)->type)
- {
- /* If a floating-point parameter appears before all of the general-
- purpose registers are filled, the corresponding GPRs that match
- the size of the floating-point parameter are shadowed for the
- benefit of vararg and pre-ANSI functions. */
- case FFI_TYPE_FLOAT:
- double_tmp = *(float*)*p_argv;
+ switch ((*ptr)->type)
+ {
+ /* If a floating-point parameter appears before all of the general-
+ purpose registers are filled, the corresponding GPRs that match
+ the size of the floating-point parameter are shadowed for the
+ benefit of vararg and pre-ANSI functions. */
+ case FFI_TYPE_FLOAT:
+ double_tmp = *(float*)*p_argv;
- if (fparg_count < NUM_FPR_ARG_REGISTERS)
- *fpr_base++ = double_tmp;
+ if (fparg_count < NUM_FPR_ARG_REGISTERS)
+ *fpr_base++ = double_tmp;
- *(double*)next_arg = double_tmp;
+ *(double*)next_arg = double_tmp;
- next_arg++;
- fparg_count++;
- FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
+ next_arg++;
+ fparg_count++;
+ FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
- break;
+ break;
- case FFI_TYPE_DOUBLE:
- double_tmp = *(double*)*p_argv;
+ case FFI_TYPE_DOUBLE:
+ double_tmp = *(double*)*p_argv;
- if (fparg_count < NUM_FPR_ARG_REGISTERS)
- *fpr_base++ = double_tmp;
+ if (fparg_count < NUM_FPR_ARG_REGISTERS)
+ *fpr_base++ = double_tmp;
- *(double*)next_arg = double_tmp;
+ *(double*)next_arg = double_tmp;
- next_arg += MODE_CHOICE(2,1);
- fparg_count++;
- FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
+ next_arg += MODE_CHOICE(2,1);
+ fparg_count++;
+ FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
- break;
+ break;
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
- case FFI_TYPE_LONGDOUBLE:
+ case FFI_TYPE_LONGDOUBLE:
#if defined(__ppc64__)
- if (fparg_count < NUM_FPR_ARG_REGISTERS)
- *(long double*)fpr_base = *(long double*)*p_argv;
+ if (fparg_count < NUM_FPR_ARG_REGISTERS)
+ *(long double*)fpr_base = *(long double*)*p_argv;
#elif defined(__ppc__)
- if (fparg_count < NUM_FPR_ARG_REGISTERS - 1)
- *(long double*)fpr_base = *(long double*)*p_argv;
- else if (fparg_count == NUM_FPR_ARG_REGISTERS - 1)
- *(double*)fpr_base = *(double*)*p_argv;
+ if (fparg_count < NUM_FPR_ARG_REGISTERS - 1)
+ *(long double*)fpr_base = *(long double*)*p_argv;
+ else if (fparg_count == NUM_FPR_ARG_REGISTERS - 1)
+ *(double*)fpr_base = *(double*)*p_argv;
#else
#error undefined architecture
#endif
- *(long double*)next_arg = *(long double*)*p_argv;
- fparg_count += 2;
- fpr_base += 2;
- next_arg += MODE_CHOICE(4,2);
- FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
+ *(long double*)next_arg = *(long double*)*p_argv;
+ fparg_count += 2;
+ fpr_base += 2;
+ next_arg += MODE_CHOICE(4,2);
+ FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
- break;
-#endif // FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
+ break;
+#endif // FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
- case FFI_TYPE_UINT64:
- case FFI_TYPE_SINT64:
+ case FFI_TYPE_UINT64:
+ case FFI_TYPE_SINT64:
#if defined(__ppc64__)
- gprvalue = *(long long*)*p_argv;
- goto putgpr;
+ gprvalue = *(long long*)*p_argv;
+ goto putgpr;
#elif defined(__ppc__)
- *(long long*)next_arg = *(long long*)*p_argv;
- next_arg += 2;
- break;
+ *(long long*)next_arg = *(long long*)*p_argv;
+ next_arg += 2;
+ break;
#else
#error undefined architecture
#endif
- case FFI_TYPE_POINTER:
- gprvalue = *(unsigned long*)*p_argv;
- goto putgpr;
+ case FFI_TYPE_POINTER:
+ gprvalue = *(unsigned long*)*p_argv;
+ goto putgpr;
- case FFI_TYPE_UINT8:
- gprvalue = *(unsigned char*)*p_argv;
- goto putgpr;
+ case FFI_TYPE_UINT8:
+ gprvalue = *(unsigned char*)*p_argv;
+ goto putgpr;
- case FFI_TYPE_SINT8:
- gprvalue = *(signed char*)*p_argv;
- goto putgpr;
+ case FFI_TYPE_SINT8:
+ gprvalue = *(signed char*)*p_argv;
+ goto putgpr;
- case FFI_TYPE_UINT16:
- gprvalue = *(unsigned short*)*p_argv;
- goto putgpr;
+ case FFI_TYPE_UINT16:
+ gprvalue = *(unsigned short*)*p_argv;
+ goto putgpr;
- case FFI_TYPE_SINT16:
- gprvalue = *(signed short*)*p_argv;
- goto putgpr;
+ case FFI_TYPE_SINT16:
+ gprvalue = *(signed short*)*p_argv;
+ goto putgpr;
- case FFI_TYPE_STRUCT:
- {
+ case FFI_TYPE_STRUCT:
+ {
#if defined(__ppc64__)
- unsigned int gprSize = 0;
- unsigned int fprSize = 0;
+ unsigned int gprSize = 0;
+ unsigned int fprSize = 0;
- ffi64_struct_to_reg_form(*ptr, (char*)*p_argv, NULL, &fparg_count,
- (char*)next_arg, &gprSize, (char*)fpr_base, &fprSize);
- next_arg += gprSize / sizeof(long);
- fpr_base += fprSize / sizeof(double);
+ ffi64_struct_to_reg_form(*ptr, (char*)*p_argv, NULL, &fparg_count,
+ (char*)next_arg, &gprSize, (char*)fpr_base, &fprSize);
+ next_arg += gprSize / sizeof(long);
+ fpr_base += fprSize / sizeof(double);
#elif defined(__ppc__)
- char* dest_cpy = (char*)next_arg;
+ char* dest_cpy = (char*)next_arg;
- /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
- SI 4 bytes) are aligned as if they were those modes.
- Structures with 3 byte in size are padded upwards. */
- unsigned size_al = (*ptr)->size;
+ /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
+ SI 4 bytes) are aligned as if they were those modes.
+ Structures with 3 byte in size are padded upwards. */
+ unsigned size_al = (*ptr)->size;
- /* If the first member of the struct is a double, then align
- the struct to double-word. */
- if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
- size_al = ALIGN((*ptr)->size, 8);
+ /* If the first member of the struct is a double, then align
+ the struct to double-word. */
+ if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
+ size_al = ALIGN((*ptr)->size, 8);
- if (ecif->cif->abi == FFI_DARWIN)
- {
- if (size_al < 3)
- dest_cpy += 4 - size_al;
- }
+ if (ecif->cif->abi == FFI_DARWIN)
+ {
+ if (size_al < 3)
+ dest_cpy += 4 - size_al;
+ }
- memcpy((char*)dest_cpy, (char*)*p_argv, size_al);
- next_arg += (size_al + 3) / 4;
+ memcpy((char*)dest_cpy, (char*)*p_argv, size_al);
+ next_arg += (size_al + 3) / 4;
#else
#error undefined architecture
#endif
- break;
- }
+ break;
+ }
- case FFI_TYPE_INT:
- case FFI_TYPE_UINT32:
- case FFI_TYPE_SINT32:
- gprvalue = *(unsigned*)*p_argv;
+ case FFI_TYPE_INT:
+ case FFI_TYPE_UINT32:
+ case FFI_TYPE_SINT32:
+ gprvalue = *(unsigned*)*p_argv;
putgpr:
- *next_arg++ = gprvalue;
- break;
+ *next_arg++ = gprvalue;
+ break;
- default:
- break;
- }
- }
+ default:
+ break;
+ }
+ }
/* Check that we didn't overrun the stack... */
//FFI_ASSERT(gpr_base <= stacktop - ASM_NEEDS_REGISTERS);
//FFI_ASSERT((unsigned *)fpr_base
- // <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
+ // <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
//FFI_ASSERT(flags & FLAG_4_GPR_ARGUMENTS || intarg_count <= 4);
}
@@ -306,320 +306,320 @@
bool
ffi64_struct_contains_fp(
- const ffi_type* inType)
+ const ffi_type* inType)
{
- bool containsFP = false;
- unsigned int i;
+ bool containsFP = false;
+ unsigned int i;
- for (i = 0; inType->elements[i] != NULL && !containsFP; i++)
- {
- if (inType->elements[i]->type == FFI_TYPE_FLOAT ||
- inType->elements[i]->type == FFI_TYPE_DOUBLE ||
- inType->elements[i]->type == FFI_TYPE_LONGDOUBLE)
- containsFP = true;
- else if (inType->elements[i]->type == FFI_TYPE_STRUCT)
- containsFP = ffi64_struct_contains_fp(inType->elements[i]);
- }
+ for (i = 0; inType->elements[i] != NULL && !containsFP; i++)
+ {
+ if (inType->elements[i]->type == FFI_TYPE_FLOAT ||
+ inType->elements[i]->type == FFI_TYPE_DOUBLE ||
+ inType->elements[i]->type == FFI_TYPE_LONGDOUBLE)
+ containsFP = true;
+ else if (inType->elements[i]->type == FFI_TYPE_STRUCT)
+ containsFP = ffi64_struct_contains_fp(inType->elements[i]);
+ }
- return containsFP;
+ return containsFP;
}
-#endif // defined(__ppc64__)
+#endif // defined(__ppc64__)
/* Perform machine dependent cif processing. */
ffi_status
ffi_prep_cif_machdep(
- ffi_cif* cif)
+ ffi_cif* cif)
{
- /* All this is for the DARWIN ABI. */
- int i;
- ffi_type** ptr;
- int intarg_count = 0;
- int fparg_count = 0;
- unsigned int flags = 0;
- unsigned int size_al = 0;
+ /* All this is for the DARWIN ABI. */
+ int i;
+ ffi_type** ptr;
+ int intarg_count = 0;
+ int fparg_count = 0;
+ unsigned int flags = 0;
+ unsigned int size_al = 0;
- /* All the machine-independent calculation of cif->bytes will be wrong.
- Redo the calculation for DARWIN. */
+ /* All the machine-independent calculation of cif->bytes will be wrong.
+ Redo the calculation for DARWIN. */
- /* Space for the frame pointer, callee's LR, CR, etc, and for
- the asm's temp regs. */
- unsigned int bytes = (6 + ASM_NEEDS_REGISTERS) * sizeof(long);
+ /* Space for the frame pointer, callee's LR, CR, etc, and for
+ the asm's temp regs. */
+ unsigned int bytes = (6 + ASM_NEEDS_REGISTERS) * sizeof(long);
- /* Return value handling. The rules are as follows:
- - 32-bit (or less) integer values are returned in gpr3;
- - Structures of size <= 4 bytes also returned in gpr3;
- - 64-bit integer values and structures between 5 and 8 bytes are
- returned in gpr3 and gpr4;
- - Single/double FP values are returned in fpr1;
- - Long double FP (if not equivalent to double) values are returned in
- fpr1 and fpr2;
- - Larger structures values are allocated space and a pointer is passed
- as the first argument. */
- switch (cif->rtype->type)
- {
+ /* Return value handling. The rules are as follows:
+ - 32-bit (or less) integer values are returned in gpr3;
+ - Structures of size <= 4 bytes also returned in gpr3;
+ - 64-bit integer values and structures between 5 and 8 bytes are
+ returned in gpr3 and gpr4;
+ - Single/double FP values are returned in fpr1;
+ - Long double FP (if not equivalent to double) values are returned in
+ fpr1 and fpr2;
+ - Larger structures values are allocated space and a pointer is passed
+ as the first argument. */
+ switch (cif->rtype->type)
+ {
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
- case FFI_TYPE_LONGDOUBLE:
- flags |= FLAG_RETURNS_128BITS;
- flags |= FLAG_RETURNS_FP;
- break;
-#endif // FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
+ case FFI_TYPE_LONGDOUBLE:
+ flags |= FLAG_RETURNS_128BITS;
+ flags |= FLAG_RETURNS_FP;
+ break;
+#endif // FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
- case FFI_TYPE_DOUBLE:
- flags |= FLAG_RETURNS_64BITS;
- /* Fall through. */
- case FFI_TYPE_FLOAT:
- flags |= FLAG_RETURNS_FP;
- break;
+ case FFI_TYPE_DOUBLE:
+ flags |= FLAG_RETURNS_64BITS;
+ /* Fall through. */
+ case FFI_TYPE_FLOAT:
+ flags |= FLAG_RETURNS_FP;
+ break;
#if defined(__ppc64__)
- case FFI_TYPE_POINTER:
+ case FFI_TYPE_POINTER:
#endif
- case FFI_TYPE_UINT64:
- case FFI_TYPE_SINT64:
- flags |= FLAG_RETURNS_64BITS;
- break;
+ case FFI_TYPE_UINT64:
+ case FFI_TYPE_SINT64:
+ flags |= FLAG_RETURNS_64BITS;
+ break;
- case FFI_TYPE_STRUCT:
- {
+ case FFI_TYPE_STRUCT:
+ {
#if defined(__ppc64__)
- if (ffi64_stret_needs_ptr(cif->rtype, NULL, NULL))
- {
- flags |= FLAG_RETVAL_REFERENCE;
- flags |= FLAG_RETURNS_NOTHING;
- intarg_count++;
- }
- else
- {
- flags |= FLAG_RETURNS_STRUCT;
+ if (ffi64_stret_needs_ptr(cif->rtype, NULL, NULL))
+ {
+ flags |= FLAG_RETVAL_REFERENCE;
+ flags |= FLAG_RETURNS_NOTHING;
+ intarg_count++;
+ }
+ else
+ {
+ flags |= FLAG_RETURNS_STRUCT;
- if (ffi64_struct_contains_fp(cif->rtype))
- flags |= FLAG_STRUCT_CONTAINS_FP;
- }
+ if (ffi64_struct_contains_fp(cif->rtype))
+ flags |= FLAG_STRUCT_CONTAINS_FP;
+ }
#elif defined(__ppc__)
- flags |= FLAG_RETVAL_REFERENCE;
- flags |= FLAG_RETURNS_NOTHING;
- intarg_count++;
+ flags |= FLAG_RETVAL_REFERENCE;
+ flags |= FLAG_RETURNS_NOTHING;
+ intarg_count++;
#else
#error undefined architecture
#endif
- break;
- }
+ break;
+ }
- case FFI_TYPE_VOID:
- flags |= FLAG_RETURNS_NOTHING;
- break;
+ case FFI_TYPE_VOID:
+ flags |= FLAG_RETURNS_NOTHING;
+ break;
- default:
- /* Returns 32-bit integer, or similar. Nothing to do here. */
- break;
- }
+ default:
+ /* Returns 32-bit integer, or similar. Nothing to do here. */
+ break;
+ }
- /* The first NUM_GPR_ARG_REGISTERS words of integer arguments, and the
- first NUM_FPR_ARG_REGISTERS fp arguments, go in registers; the rest
- goes on the stack. Structures are passed as a pointer to a copy of
- the structure. Stuff on the stack needs to keep proper alignment. */
- for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
- {
- switch ((*ptr)->type)
- {
- case FFI_TYPE_FLOAT:
- case FFI_TYPE_DOUBLE:
- fparg_count++;
- /* If this FP arg is going on the stack, it must be
- 8-byte-aligned. */
- if (fparg_count > NUM_FPR_ARG_REGISTERS
- && intarg_count % 2 != 0)
- intarg_count++;
- break;
+ /* The first NUM_GPR_ARG_REGISTERS words of integer arguments, and the
+ first NUM_FPR_ARG_REGISTERS fp arguments, go in registers; the rest
+ goes on the stack. Structures are passed as a pointer to a copy of
+ the structure. Stuff on the stack needs to keep proper alignment. */
+ for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
+ {
+ switch ((*ptr)->type)
+ {
+ case FFI_TYPE_FLOAT:
+ case FFI_TYPE_DOUBLE:
+ fparg_count++;
+ /* If this FP arg is going on the stack, it must be
+ 8-byte-aligned. */
+ if (fparg_count > NUM_FPR_ARG_REGISTERS
+ && intarg_count % 2 != 0)
+ intarg_count++;
+ break;
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
- case FFI_TYPE_LONGDOUBLE:
- fparg_count += 2;
- /* If this FP arg is going on the stack, it must be
- 8-byte-aligned. */
+ case FFI_TYPE_LONGDOUBLE:
+ fparg_count += 2;
+ /* If this FP arg is going on the stack, it must be
+ 8-byte-aligned. */
- if (
+ if (
#if defined(__ppc64__)
- fparg_count > NUM_FPR_ARG_REGISTERS + 1
+ fparg_count > NUM_FPR_ARG_REGISTERS + 1
#elif defined(__ppc__)
- fparg_count > NUM_FPR_ARG_REGISTERS
+ fparg_count > NUM_FPR_ARG_REGISTERS
#else
#error undefined architecture
#endif
- && intarg_count % 2 != 0)
- intarg_count++;
+ && intarg_count % 2 != 0)
+ intarg_count++;
- intarg_count += 2;
- break;
-#endif // FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
+ intarg_count += 2;
+ break;
+#endif // FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
- case FFI_TYPE_UINT64:
- case FFI_TYPE_SINT64:
- /* 'long long' arguments are passed as two words, but
- either both words must fit in registers or both go
- on the stack. If they go on the stack, they must
- be 8-byte-aligned. */
- if (intarg_count == NUM_GPR_ARG_REGISTERS - 1
- || (intarg_count >= NUM_GPR_ARG_REGISTERS
- && intarg_count % 2 != 0))
- intarg_count++;
+ case FFI_TYPE_UINT64:
+ case FFI_TYPE_SINT64:
+ /* 'long long' arguments are passed as two words, but
+ either both words must fit in registers or both go
+ on the stack. If they go on the stack, they must
+ be 8-byte-aligned. */
+ if (intarg_count == NUM_GPR_ARG_REGISTERS - 1
+ || (intarg_count >= NUM_GPR_ARG_REGISTERS
+ && intarg_count % 2 != 0))
+ intarg_count++;
- intarg_count += MODE_CHOICE(2,1);
+ intarg_count += MODE_CHOICE(2,1);
- break;
+ break;
- case FFI_TYPE_STRUCT:
- size_al = (*ptr)->size;
- /* If the first member of the struct is a double, then align
- the struct to double-word. */
- if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
- size_al = ALIGN((*ptr)->size, 8);
+ case FFI_TYPE_STRUCT:
+ size_al = (*ptr)->size;
+ /* If the first member of the struct is a double, then align
+ the struct to double-word. */
+ if ((*ptr)->elements[0]->type == FFI_TYPE_DOUBLE)
+ size_al = ALIGN((*ptr)->size, 8);
#if defined(__ppc64__)
- // Look for FP struct members.
- unsigned int j;
+ // Look for FP struct members.
+ unsigned int j;
- for (j = 0; (*ptr)->elements[j] != NULL; j++)
- {
- if ((*ptr)->elements[j]->type == FFI_TYPE_FLOAT ||
- (*ptr)->elements[j]->type == FFI_TYPE_DOUBLE)
- {
- fparg_count++;
+ for (j = 0; (*ptr)->elements[j] != NULL; j++)
+ {
+ if ((*ptr)->elements[j]->type == FFI_TYPE_FLOAT ||
+ (*ptr)->elements[j]->type == FFI_TYPE_DOUBLE)
+ {
+ fparg_count++;
- if (fparg_count > NUM_FPR_ARG_REGISTERS)
- intarg_count++;
- }
- else if ((*ptr)->elements[j]->type == FFI_TYPE_LONGDOUBLE)
- {
- fparg_count += 2;
+ if (fparg_count > NUM_FPR_ARG_REGISTERS)
+ intarg_count++;
+ }
+ else if ((*ptr)->elements[j]->type == FFI_TYPE_LONGDOUBLE)
+ {
+ fparg_count += 2;
- if (fparg_count > NUM_FPR_ARG_REGISTERS + 1)
- intarg_count += 2;
- }
- else
- intarg_count++;
- }
+ if (fparg_count > NUM_FPR_ARG_REGISTERS + 1)
+ intarg_count += 2;
+ }
+ else
+ intarg_count++;
+ }
#elif defined(__ppc__)
- intarg_count += (size_al + 3) / 4;
+ intarg_count += (size_al + 3) / 4;
#else
#error undefined architecture
#endif
- break;
+ break;
- default:
- /* Everything else is passed as a 4/8-byte word in a GPR, either
- the object itself or a pointer to it. */
- intarg_count++;
- break;
- }
- }
+ default:
+ /* Everything else is passed as a 4/8-byte word in a GPR, either
+ the object itself or a pointer to it. */
+ intarg_count++;
+ break;
+ }
+ }
- /* Space for the FPR registers, if needed. */
- if (fparg_count != 0)
- {
- flags |= FLAG_FP_ARGUMENTS;
+ /* Space for the FPR registers, if needed. */
+ if (fparg_count != 0)
+ {
+ flags |= FLAG_FP_ARGUMENTS;
#if defined(__ppc64__)
- bytes += (NUM_FPR_ARG_REGISTERS + 1) * sizeof(double);
+ bytes += (NUM_FPR_ARG_REGISTERS + 1) * sizeof(double);
#elif defined(__ppc__)
- bytes += NUM_FPR_ARG_REGISTERS * sizeof(double);
+ bytes += NUM_FPR_ARG_REGISTERS * sizeof(double);
#else
#error undefined architecture
#endif
- }
+ }
- /* Stack space. */
+ /* Stack space. */
#if defined(__ppc64__)
- if ((intarg_count + fparg_count) > NUM_GPR_ARG_REGISTERS)
- bytes += (intarg_count + fparg_count) * sizeof(long);
+ if ((intarg_count + fparg_count) > NUM_GPR_ARG_REGISTERS)
+ bytes += (intarg_count + fparg_count) * sizeof(long);
#elif defined(__ppc__)
- if ((intarg_count + 2 * fparg_count) > NUM_GPR_ARG_REGISTERS)
- bytes += (intarg_count + 2 * fparg_count) * sizeof(long);
+ if ((intarg_count + 2 * fparg_count) > NUM_GPR_ARG_REGISTERS)
+ bytes += (intarg_count + 2 * fparg_count) * sizeof(long);
#else
#error undefined architecture
#endif
- else
- bytes += NUM_GPR_ARG_REGISTERS * sizeof(long);
+ else
+ bytes += NUM_GPR_ARG_REGISTERS * sizeof(long);
- /* The stack space allocated needs to be a multiple of 16/32 bytes. */
- bytes = SF_ROUND(bytes);
+ /* The stack space allocated needs to be a multiple of 16/32 bytes. */
+ bytes = SF_ROUND(bytes);
- cif->flags = flags;
- cif->bytes = bytes;
+ cif->flags = flags;
+ cif->bytes = bytes;
- return FFI_OK;
+ return FFI_OK;
}
/*@-declundef@*/
/*@-exportheader@*/
extern void
ffi_call_AIX(
-/*@out@*/ extended_cif*,
- unsigned,
- unsigned,
-/*@out@*/ unsigned*,
- void (*fn)(void),
- void (*fn2)(extended_cif*, unsigned *const));
+/*@out@*/ extended_cif*,
+ unsigned,
+ unsigned,
+/*@out@*/ unsigned*,
+ void (*fn)(void),
+ void (*fn2)(extended_cif*, unsigned *const));
extern void
ffi_call_DARWIN(
-/*@out@*/ extended_cif*,
- unsigned long,
- unsigned,
-/*@out@*/ unsigned*,
- void (*fn)(void),
- void (*fn2)(extended_cif*, unsigned *const));
+/*@out@*/ extended_cif*,
+ unsigned long,
+ unsigned,
+/*@out@*/ unsigned*,
+ void (*fn)(void),
+ void (*fn2)(extended_cif*, unsigned *const));
/*@=declundef@*/
/*@=exportheader@*/
void
ffi_call(
-/*@dependent@*/ ffi_cif* cif,
- void (*fn)(void),
-/*@out@*/ void* rvalue,
-/*@dependent@*/ void** avalue)
+/*@dependent@*/ ffi_cif* cif,
+ void (*fn)(void),
+/*@out@*/ void* rvalue,
+/*@dependent@*/ void** avalue)
{
- extended_cif ecif;
+ extended_cif ecif;
- ecif.cif = cif;
- ecif.avalue = avalue;
+ 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 ((rvalue == NULL) &&
- (cif->rtype->type == FFI_TYPE_STRUCT))
- {
- /*@-sysunrecog@*/
- ecif.rvalue = alloca(cif->rtype->size);
- /*@=sysunrecog@*/
- }
- else
- ecif.rvalue = rvalue;
+ /* 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->rtype->type == FFI_TYPE_STRUCT))
+ {
+ /*@-sysunrecog@*/
+ ecif.rvalue = alloca(cif->rtype->size);
+ /*@=sysunrecog@*/
+ }
+ else
+ ecif.rvalue = rvalue;
- switch (cif->abi)
- {
- case FFI_AIX:
- /*@-usedef@*/
- ffi_call_AIX(&ecif, -cif->bytes,
- cif->flags, ecif.rvalue, fn, ffi_prep_args);
- /*@=usedef@*/
- break;
+ switch (cif->abi)
+ {
+ case FFI_AIX:
+ /*@-usedef@*/
+ ffi_call_AIX(&ecif, -cif->bytes,
+ cif->flags, ecif.rvalue, fn, ffi_prep_args);
+ /*@=usedef@*/
+ break;
- case FFI_DARWIN:
- /*@-usedef@*/
- ffi_call_DARWIN(&ecif, -(long)cif->bytes,
- cif->flags, ecif.rvalue, fn, ffi_prep_args);
- /*@=usedef@*/
- break;
+ case FFI_DARWIN:
+ /*@-usedef@*/
+ ffi_call_DARWIN(&ecif, -(long)cif->bytes,
+ cif->flags, ecif.rvalue, fn, ffi_prep_args);
+ /*@=usedef@*/
+ break;
- default:
- FFI_ASSERT(0);
- break;
+ default:
+ FFI_ASSERT(0);
+ break;
}
}
@@ -627,53 +627,53 @@
and aix_clsoure.S
SP previous -> +---------------------------------------+ <--- child frame
- | back chain to caller 4 |
- +---------------------------------------+ 4
- | saved CR 4 |
- +---------------------------------------+ 8
- | saved LR 4 |
- +---------------------------------------+ 12
- | reserved for compilers 4 |
- +---------------------------------------+ 16
- | reserved for binders 4 |
- +---------------------------------------+ 20
- | saved TOC pointer 4 |
- +---------------------------------------+ 24
- | always reserved 8*4=32 (previous GPRs)|
- | according to the linkage convention |
- | from AIX |
- +---------------------------------------+ 56
- | our FPR area 13*8=104 |
- | f1 |
- | . |
- | f13 |
- +---------------------------------------+ 160
- | result area 8 |
- +---------------------------------------+ 168
- | alignment to the next multiple of 16 |
+ | back chain to caller 4 |
+ +---------------------------------------+ 4
+ | saved CR 4 |
+ +---------------------------------------+ 8
+ | saved LR 4 |
+ +---------------------------------------+ 12
+ | reserved for compilers 4 |
+ +---------------------------------------+ 16
+ | reserved for binders 4 |
+ +---------------------------------------+ 20
+ | saved TOC pointer 4 |
+ +---------------------------------------+ 24
+ | always reserved 8*4=32 (previous GPRs)|
+ | according to the linkage convention |
+ | from AIX |
+ +---------------------------------------+ 56
+ | our FPR area 13*8=104 |
+ | f1 |
+ | . |
+ | f13 |
+ +---------------------------------------+ 160
+ | result area 8 |
+ +---------------------------------------+ 168
+ | alignement to the next multiple of 16 |
SP current --> +---------------------------------------+ 176 <- parent frame
- | back chain to caller 4 |
- +---------------------------------------+ 180
- | saved CR 4 |
- +---------------------------------------+ 184
- | saved LR 4 |
- +---------------------------------------+ 188
- | reserved for compilers 4 |
- +---------------------------------------+ 192
- | reserved for binders 4 |
- +---------------------------------------+ 196
- | saved TOC pointer 4 |
- +---------------------------------------+ 200
- | always reserved 8*4=32 we store our |
- | GPRs here |
- | r3 |
- | . |
- | r10 |
- +---------------------------------------+ 232
- | overflow part |
- +---------------------------------------+ xxx
- | ???? |
- +---------------------------------------+ xxx
+ | back chain to caller 4 |
+ +---------------------------------------+ 180
+ | saved CR 4 |
+ +---------------------------------------+ 184
+ | saved LR 4 |
+ +---------------------------------------+ 188
+ | reserved for compilers 4 |
+ +---------------------------------------+ 192
+ | reserved for binders 4 |
+ +---------------------------------------+ 196
+ | saved TOC pointer 4 |
+ +---------------------------------------+ 200
+ | always reserved 8*4=32 we store our |
+ | GPRs here |
+ | r3 |
+ | . |
+ | r10 |
+ +---------------------------------------+ 232
+ | overflow part |
+ +---------------------------------------+ xxx
+ | ???? |
+ +---------------------------------------+ xxx
*/
#if !defined(POWERPC_DARWIN)
@@ -682,1095 +682,1095 @@
static void
flush_icache(
- char* addr)
+ char* addr)
{
#ifndef _AIX
- __asm__ volatile (
- "dcbf 0,%0\n"
- "sync\n"
- "icbi 0,%0\n"
- "sync\n"
- "isync"
- : : "r" (addr) : "memory");
+ __asm__ volatile (
+ "dcbf 0,%0\n"
+ "sync\n"
+ "icbi 0,%0\n"
+ "sync\n"
+ "isync"
+ : : "r" (addr) : "memory");
#endif
}
static void
flush_range(
- char* addr,
- int size)
+ char* addr,
+ int size)
{
- int i;
+ int i;
- for (i = 0; i < size; i += MIN_LINE_SIZE)
- flush_icache(addr + i);
+ for (i = 0; i < size; i += MIN_LINE_SIZE)
+ flush_icache(addr + i);
- flush_icache(addr + size - 1);
+ flush_icache(addr + size - 1);
}
-#endif // !defined(POWERPC_DARWIN)
+#endif // !defined(POWERPC_DARWIN)
ffi_status
ffi_prep_closure(
- ffi_closure* closure,
- ffi_cif* cif,
- void (*fun)(ffi_cif*, void*, void**, void*),
- void* user_data)
+ ffi_closure* closure,
+ ffi_cif* cif,
+ void (*fun)(ffi_cif*, void*, void**, void*),
+ void* user_data)
{
- switch (cif->abi)
- {
- case FFI_DARWIN:
- {
- FFI_ASSERT (cif->abi == FFI_DARWIN);
+ switch (cif->abi)
+ {
+ case FFI_DARWIN:
+ {
+ FFI_ASSERT (cif->abi == FFI_DARWIN);
- unsigned int* tramp = (unsigned int*)&closure->tramp[0];
+ unsigned int* tramp = (unsigned int*)&closure->tramp[0];
#if defined(__ppc64__)
- tramp[0] = 0x7c0802a6; // mflr r0
- tramp[1] = 0x429f0005; // bcl 20,31,+0x8
- tramp[2] = 0x7d6802a6; // mflr r11
- tramp[3] = 0x7c0803a6; // mtlr r0
- tramp[4] = 0xe98b0018; // ld r12,24(r11)
- tramp[5] = 0x7d8903a6; // mtctr r12
- tramp[6] = 0xe96b0020; // ld r11,32(r11)
- tramp[7] = 0x4e800420; // bctr
- *(unsigned long*)&tramp[8] = (unsigned long)ffi_closure_ASM;
- *(unsigned long*)&tramp[10] = (unsigned long)closure;
+ tramp[0] = 0x7c0802a6; // mflr r0
+ tramp[1] = 0x429f0005; // bcl 20,31,+0x8
+ tramp[2] = 0x7d6802a6; // mflr r11
+ tramp[3] = 0x7c0803a6; // mtlr r0
+ tramp[4] = 0xe98b0018; // ld r12,24(r11)
+ tramp[5] = 0x7d8903a6; // mtctr r12
+ tramp[6] = 0xe96b0020; // ld r11,32(r11)
+ tramp[7] = 0x4e800420; // bctr
+ *(unsigned long*)&tramp[8] = (unsigned long)ffi_closure_ASM;
+ *(unsigned long*)&tramp[10] = (unsigned long)closure;
#elif defined(__ppc__)
- tramp[0] = 0x7c0802a6; // mflr r0
- tramp[1] = 0x429f0005; // bcl 20,31,+0x8
- tramp[2] = 0x7d6802a6; // mflr r11
- tramp[3] = 0x7c0803a6; // mtlr r0
- tramp[4] = 0x818b0018; // lwz r12,24(r11)
- tramp[5] = 0x7d8903a6; // mtctr r12
- tramp[6] = 0x816b001c; // lwz r11,28(r11)
- tramp[7] = 0x4e800420; // bctr
- tramp[8] = (unsigned long)ffi_closure_ASM;
- tramp[9] = (unsigned long)closure;
+ tramp[0] = 0x7c0802a6; // mflr r0
+ tramp[1] = 0x429f0005; // bcl 20,31,+0x8
+ tramp[2] = 0x7d6802a6; // mflr r11
+ tramp[3] = 0x7c0803a6; // mtlr r0
+ tramp[4] = 0x818b0018; // lwz r12,24(r11)
+ tramp[5] = 0x7d8903a6; // mtctr r12
+ tramp[6] = 0x816b001c; // lwz r11,28(r11)
+ tramp[7] = 0x4e800420; // bctr
+ tramp[8] = (unsigned long)ffi_closure_ASM;
+ tramp[9] = (unsigned long)closure;
#else
#error undefined architecture
#endif
- closure->cif = cif;
- closure->fun = fun;
- closure->user_data = user_data;
+ closure->cif = cif;
+ closure->fun = fun;
+ closure->user_data = user_data;
- // Flush the icache. Only necessary on Darwin.
+ // Flush the icache. Only necessary on Darwin.
#if defined(POWERPC_DARWIN)
- sys_icache_invalidate(closure->tramp, FFI_TRAMPOLINE_SIZE);
+ sys_icache_invalidate(closure->tramp, FFI_TRAMPOLINE_SIZE);
#else
- flush_range(closure->tramp, FFI_TRAMPOLINE_SIZE);
+ flush_range(closure->tramp, FFI_TRAMPOLINE_SIZE);
#endif
- break;
- }
+ break;
+ }
- case FFI_AIX:
- {
- FFI_ASSERT (cif->abi == FFI_AIX);
+ case FFI_AIX:
+ {
+ FFI_ASSERT (cif->abi == FFI_AIX);
- ffi_aix_trampoline_struct* tramp_aix =
- (ffi_aix_trampoline_struct*)(closure->tramp);
- aix_fd* fd = (aix_fd*)(void*)ffi_closure_ASM;
+ ffi_aix_trampoline_struct* tramp_aix =
+ (ffi_aix_trampoline_struct*)(closure->tramp);
+ aix_fd* fd = (aix_fd*)(void*)ffi_closure_ASM;
- tramp_aix->code_pointer = fd->code_pointer;
- tramp_aix->toc = fd->toc;
- tramp_aix->static_chain = closure;
- closure->cif = cif;
- closure->fun = fun;
- closure->user_data = user_data;
- break;
- }
+ tramp_aix->code_pointer = fd->code_pointer;
+ tramp_aix->toc = fd->toc;
+ tramp_aix->static_chain = closure;
+ closure->cif = cif;
+ closure->fun = fun;
+ closure->user_data = user_data;
+ break;
+ }
- default:
- return FFI_BAD_ABI;
- }
+ default:
+ return FFI_BAD_ABI;
+ }
- return FFI_OK;
+ return FFI_OK;
}
#if defined(__ppc__)
- typedef double ldbits[2];
+ typedef double ldbits[2];
- typedef union
- {
- ldbits lb;
- long double ld;
- } ldu;
+ typedef union
+ {
+ ldbits lb;
+ long double ld;
+ } ldu;
#endif
typedef union
{
- float f;
- double d;
+ float f;
+ double d;
} ffi_dblfl;
-/* The trampoline invokes ffi_closure_ASM, and on entry, r11 holds the
- address of the closure. After storing the registers that could possibly
- contain parameters to be passed into the stack frame and setting up space
- for a return value, ffi_closure_ASM invokes the following helper function
- to do most of the work. */
+/* The trampoline invokes ffi_closure_ASM, and on entry, r11 holds the
+ address of the closure. After storing the registers that could possibly
+ contain parameters to be passed into the stack frame and setting up space
+ for a return value, ffi_closure_ASM invokes the following helper function
+ to do most of the work. */
int
ffi_closure_helper_DARWIN(
- ffi_closure* closure,
- void* rvalue,
- unsigned long* pgr,
- ffi_dblfl* pfr)
+ ffi_closure* closure,
+ void* rvalue,
+ unsigned long* pgr,
+ ffi_dblfl* pfr)
{
- /* rvalue is the pointer to space for return value in closure assembly
- pgr is the pointer to where r3-r10 are stored in ffi_closure_ASM
- pfr is the pointer to where f1-f13 are stored in ffi_closure_ASM. */
+ /* rvalue is the pointer to space for return value in closure assembly
+ pgr is the pointer to where r3-r10 are stored in ffi_closure_ASM
+ pfr is the pointer to where f1-f13 are stored in ffi_closure_ASM. */
#if defined(__ppc__)
- ldu temp_ld;
+ ldu temp_ld;
#endif
- double temp;
- unsigned int i;
- unsigned int nf = 0; /* number of FPRs already used. */
- unsigned int ng = 0; /* number of GPRs already used. */
- ffi_cif* cif = closure->cif;
- long avn = cif->nargs;
- void** avalue = alloca(cif->nargs * sizeof(void*));
- ffi_type** arg_types = cif->arg_types;
+ double temp;
+ unsigned int i;
+ unsigned int nf = 0; /* number of FPRs already used. */
+ unsigned int ng = 0; /* number of GPRs already used. */
+ ffi_cif* cif = closure->cif;
+ long avn = cif->nargs;
+ void** avalue = alloca(cif->nargs * sizeof(void*));
+ ffi_type** arg_types = cif->arg_types;
- /* Copy the caller's structure return value address so that the closure
- returns the data directly to the caller. */
+ /* Copy the caller's structure return value address so that the closure
+ returns the data directly to the caller. */
#if defined(__ppc64__)
- if (cif->rtype->type == FFI_TYPE_STRUCT &&
- ffi64_stret_needs_ptr(cif->rtype, NULL, NULL))
+ if (cif->rtype->type == FFI_TYPE_STRUCT &&
+ ffi64_stret_needs_ptr(cif->rtype, NULL, NULL))
#elif defined(__ppc__)
- if (cif->rtype->type == FFI_TYPE_STRUCT)
+ if (cif->rtype->type == FFI_TYPE_STRUCT)
#else
#error undefined architecture
#endif
- {
- rvalue = (void*)*pgr;
- pgr++;
- ng++;
- }
+ {
+ rvalue = (void*)*pgr;
+ pgr++;
+ ng++;
+ }
- /* Grab the addresses of the arguments from the stack frame. */
- for (i = 0; i < avn; i++)
- {
- switch (arg_types[i]->type)
- {
- case FFI_TYPE_SINT8:
- case FFI_TYPE_UINT8:
- avalue[i] = (char*)pgr + MODE_CHOICE(3,7);
- ng++;
- pgr++;
- break;
+ /* Grab the addresses of the arguments from the stack frame. */
+ for (i = 0; i < avn; i++)
+ {
+ switch (arg_types[i]->type)
+ {
+ case FFI_TYPE_SINT8:
+ case FFI_TYPE_UINT8:
+ avalue[i] = (char*)pgr + MODE_CHOICE(3,7);
+ ng++;
+ pgr++;
+ break;
- case FFI_TYPE_SINT16:
- case FFI_TYPE_UINT16:
- avalue[i] = (char*)pgr + MODE_CHOICE(2,6);
- ng++;
- pgr++;
- break;
+ case FFI_TYPE_SINT16:
+ case FFI_TYPE_UINT16:
+ avalue[i] = (char*)pgr + MODE_CHOICE(2,6);
+ ng++;
+ pgr++;
+ break;
#if defined(__ppc__)
- case FFI_TYPE_POINTER:
+ case FFI_TYPE_POINTER:
#endif
- case FFI_TYPE_SINT32:
- case FFI_TYPE_UINT32:
- avalue[i] = (char*)pgr + MODE_CHOICE(0,4);
- ng++;
- pgr++;
+ case FFI_TYPE_SINT32:
+ case FFI_TYPE_UINT32:
+ avalue[i] = (char*)pgr + MODE_CHOICE(0,4);
+ ng++;
+ pgr++;
- break;
+ break;
- case FFI_TYPE_STRUCT:
- if (cif->abi == FFI_DARWIN)
- {
+ case FFI_TYPE_STRUCT:
+ if (cif->abi == FFI_DARWIN)
+ {
#if defined(__ppc64__)
- unsigned int gprSize = 0;
- unsigned int fprSize = 0;
- unsigned int savedFPRSize = fprSize;
+ unsigned int gprSize = 0;
+ unsigned int fprSize = 0;
+ unsigned int savedFPRSize = fprSize;
- avalue[i] = alloca(arg_types[i]->size);
- ffi64_struct_to_ram_form(arg_types[i], (const char*)pgr,
- &gprSize, (const char*)pfr, &fprSize, &nf, avalue[i], NULL);
+ avalue[i] = alloca(arg_types[i]->size);
+ ffi64_struct_to_ram_form(arg_types[i], (const char*)pgr,
+ &gprSize, (const char*)pfr, &fprSize, &nf, avalue[i], NULL);
- ng += gprSize / sizeof(long);
- pgr += gprSize / sizeof(long);
- pfr += (fprSize - savedFPRSize) / sizeof(double);
+ ng += gprSize / sizeof(long);
+ pgr += gprSize / sizeof(long);
+ pfr += (fprSize - savedFPRSize) / sizeof(double);
#elif defined(__ppc__)
- /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
- SI 4 bytes) are aligned as if they were those modes. */
- unsigned int size_al = size_al = arg_types[i]->size;
+ /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
+ SI 4 bytes) are aligned as if they were those modes. */
+ unsigned int size_al = size_al = arg_types[i]->size;
- /* If the first member of the struct is a double, then align
- the struct to double-word. */
- if (arg_types[i]->elements[0]->type == FFI_TYPE_DOUBLE)
- size_al = ALIGN(arg_types[i]->size, 8);
+ /* If the first member of the struct is a double, then align
+ the struct to double-word. */
+ if (arg_types[i]->elements[0]->type == FFI_TYPE_DOUBLE)
+ size_al = ALIGN(arg_types[i]->size, 8);
- if (size_al < 3)
- avalue[i] = (void*)pgr + MODE_CHOICE(4,8) - size_al;
- else
- avalue[i] = (void*)pgr;
+ if (size_al < 3)
+ avalue[i] = (void*)pgr + MODE_CHOICE(4,8) - size_al;
+ else
+ avalue[i] = (void*)pgr;
- ng += (size_al + 3) / sizeof(long);
- pgr += (size_al + 3) / sizeof(long);
+ ng += (size_al + 3) / sizeof(long);
+ pgr += (size_al + 3) / sizeof(long);
#else
#error undefined architecture
#endif
- }
+ }
- break;
+ break;
#if defined(__ppc64__)
- case FFI_TYPE_POINTER:
+ case FFI_TYPE_POINTER:
#endif
- case FFI_TYPE_SINT64:
- case FFI_TYPE_UINT64:
- /* Long long ints are passed in 1 or 2 GPRs. */
- avalue[i] = pgr;
- ng += MODE_CHOICE(2,1);
- pgr += MODE_CHOICE(2,1);
+ case FFI_TYPE_SINT64:
+ case FFI_TYPE_UINT64:
+ /* Long long ints are passed in 1 or 2 GPRs. */
+ avalue[i] = pgr;
+ ng += MODE_CHOICE(2,1);
+ pgr += MODE_CHOICE(2,1);
- break;
+ break;
- case FFI_TYPE_FLOAT:
- /* A float value consumes a GPR.
- There are 13 64-bit floating point registers. */
- if (nf < NUM_FPR_ARG_REGISTERS)
- {
- temp = pfr->d;
- pfr->f = (float)temp;
- avalue[i] = pfr;
- pfr++;
- }
- else
- avalue[i] = pgr;
+ case FFI_TYPE_FLOAT:
+ /* A float value consumes a GPR.
+ There are 13 64-bit floating point registers. */
+ if (nf < NUM_FPR_ARG_REGISTERS)
+ {
+ temp = pfr->d;
+ pfr->f = (float)temp;
+ avalue[i] = pfr;
+ pfr++;
+ }
+ else
+ avalue[i] = pgr;
- nf++;
- ng++;
- pgr++;
- break;
+ nf++;
+ ng++;
+ pgr++;
+ break;
- case FFI_TYPE_DOUBLE:
- /* A double value consumes one or two GPRs.
- There are 13 64bit floating point registers. */
- if (nf < NUM_FPR_ARG_REGISTERS)
- {
- avalue[i] = pfr;
- pfr++;
- }
- else
- avalue[i] = pgr;
+ case FFI_TYPE_DOUBLE:
+ /* A double value consumes one or two GPRs.
+ There are 13 64bit floating point registers. */
+ if (nf < NUM_FPR_ARG_REGISTERS)
+ {
+ avalue[i] = pfr;
+ pfr++;
+ }
+ else
+ avalue[i] = pgr;
- nf++;
- ng += MODE_CHOICE(2,1);
- pgr += MODE_CHOICE(2,1);
+ nf++;
+ ng += MODE_CHOICE(2,1);
+ pgr += MODE_CHOICE(2,1);
- break;
+ break;
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
- case FFI_TYPE_LONGDOUBLE:
+ case FFI_TYPE_LONGDOUBLE:
#if defined(__ppc64__)
- if (nf < NUM_FPR_ARG_REGISTERS)
- {
- avalue[i] = pfr;
- pfr += 2;
- }
+ if (nf < NUM_FPR_ARG_REGISTERS)
+ {
+ avalue[i] = pfr;
+ pfr += 2;
+ }
#elif defined(__ppc__)
- /* A long double value consumes 2/4 GPRs and 2 FPRs.
- There are 13 64bit floating point registers. */
- if (nf < NUM_FPR_ARG_REGISTERS - 1)
- {
- avalue[i] = pfr;
- pfr += 2;
- }
- /* Here we have the situation where one part of the long double
- is stored in fpr13 and the other part is already on the stack.
- We use a union to pass the long double to avalue[i]. */
- else if (nf == NUM_FPR_ARG_REGISTERS - 1)
- {
- memcpy (&temp_ld.lb[0], pfr, sizeof(temp_ld.lb[0]));
- memcpy (&temp_ld.lb[1], pgr + 2, sizeof(temp_ld.lb[1]));
- avalue[i] = &temp_ld.ld;
- }
+ /* A long double value consumes 2/4 GPRs and 2 FPRs.
+ There are 13 64bit floating point registers. */
+ if (nf < NUM_FPR_ARG_REGISTERS - 1)
+ {
+ avalue[i] = pfr;
+ pfr += 2;
+ }
+ /* Here we have the situation where one part of the long double
+ is stored in fpr13 and the other part is already on the stack.
+ We use a union to pass the long double to avalue[i]. */
+ else if (nf == NUM_FPR_ARG_REGISTERS - 1)
+ {
+ memcpy (&temp_ld.lb[0], pfr, sizeof(temp_ld.lb[0]));
+ memcpy (&temp_ld.lb[1], pgr + 2, sizeof(temp_ld.lb[1]));
+ avalue[i] = &temp_ld.ld;
+ }
#else
#error undefined architecture
#endif
- else
- avalue[i] = pgr;
+ else
+ avalue[i] = pgr;
- nf += 2;
- ng += MODE_CHOICE(4,2);
- pgr += MODE_CHOICE(4,2);
+ nf += 2;
+ ng += MODE_CHOICE(4,2);
+ pgr += MODE_CHOICE(4,2);
- break;
+ break;
-#endif /* FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE */
+#endif /* FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE */
- default:
- FFI_ASSERT(0);
- break;
- }
- }
+ default:
+ FFI_ASSERT(0);
+ break;
+ }
+ }
- (closure->fun)(cif, rvalue, avalue, closure->user_data);
+ (closure->fun)(cif, rvalue, avalue, closure->user_data);
- /* Tell ffi_closure_ASM to perform return type promotions. */
- return cif->rtype->type;
+ /* Tell ffi_closure_ASM to perform return type promotions. */
+ return cif->rtype->type;
}
#if defined(__ppc64__)
-/* ffi64_struct_to_ram_form
+/* ffi64_struct_to_ram_form
- Rebuild a struct's natural layout from buffers of concatenated registers.
- Return the number of registers used.
- inGPRs[0-7] == r3, inFPRs[0-7] == f1 ...
+ Rebuild a struct's natural layout from buffers of concatenated registers.
+ Return the number of registers used.
+ inGPRs[0-7] == r3, inFPRs[0-7] == f1 ...
*/
void
ffi64_struct_to_ram_form(
- const ffi_type* inType,
- const char* inGPRs,
- unsigned int* ioGPRMarker,
- const char* inFPRs,
- unsigned int* ioFPRMarker,
- unsigned int* ioFPRsUsed,
- char* outStruct, // caller-allocated
- unsigned int* ioStructMarker)
+ const ffi_type* inType,
+ const char* inGPRs,
+ unsigned int* ioGPRMarker,
+ const char* inFPRs,
+ unsigned int* ioFPRMarker,
+ unsigned int* ioFPRsUsed,
+ char* outStruct, // caller-allocated
+ unsigned int* ioStructMarker)
{
- unsigned int srcGMarker = 0;
- unsigned int srcFMarker = 0;
- unsigned int savedFMarker = 0;
- unsigned int fprsUsed = 0;
- unsigned int savedFPRsUsed = 0;
- unsigned int destMarker = 0;
+ unsigned int srcGMarker = 0;
+ unsigned int srcFMarker = 0;
+ unsigned int savedFMarker = 0;
+ unsigned int fprsUsed = 0;
+ unsigned int savedFPRsUsed = 0;
+ unsigned int destMarker = 0;
- static unsigned int recurseCount = 0;
+ static unsigned int recurseCount = 0;
- if (ioGPRMarker)
- srcGMarker = *ioGPRMarker;
+ if (ioGPRMarker)
+ srcGMarker = *ioGPRMarker;
- if (ioFPRMarker)
- {
- srcFMarker = *ioFPRMarker;
- savedFMarker = srcFMarker;
- }
+ if (ioFPRMarker)
+ {
+ srcFMarker = *ioFPRMarker;
+ savedFMarker = srcFMarker;
+ }
- if (ioFPRsUsed)
- {
- fprsUsed = *ioFPRsUsed;
- savedFPRsUsed = fprsUsed;
- }
+ if (ioFPRsUsed)
+ {
+ fprsUsed = *ioFPRsUsed;
+ savedFPRsUsed = fprsUsed;
+ }
- if (ioStructMarker)
- destMarker = *ioStructMarker;
+ if (ioStructMarker)
+ destMarker = *ioStructMarker;
- size_t i;
+ size_t i;
- switch (inType->size)
- {
- case 1: case 2: case 4:
- srcGMarker += 8 - inType->size;
- break;
+ switch (inType->size)
+ {
+ case 1: case 2: case 4:
+ srcGMarker += 8 - inType->size;
+ break;
- default:
- break;
- }
+ default:
+ break;
+ }
- for (i = 0; inType->elements[i] != NULL; i++)
- {
- switch (inType->elements[i]->type)
- {
- case FFI_TYPE_FLOAT:
- srcFMarker = ALIGN(srcFMarker, 4);
- srcGMarker = ALIGN(srcGMarker, 4);
- destMarker = ALIGN(destMarker, 4);
+ for (i = 0; inType->elements[i] != NULL; i++)
+ {
+ switch (inType->elements[i]->type)
+ {
+ case FFI_TYPE_FLOAT:
+ srcFMarker = ALIGN(srcFMarker, 4);
+ srcGMarker = ALIGN(srcGMarker, 4);
+ destMarker = ALIGN(destMarker, 4);
- if (fprsUsed < NUM_FPR_ARG_REGISTERS)
- {
- *(float*)&outStruct[destMarker] =
- (float)*(double*)&inFPRs[srcFMarker];
- srcFMarker += 8;
- fprsUsed++;
- }
- else
- *(float*)&outStruct[destMarker] =
- (float)*(double*)&inGPRs[srcGMarker];
+ if (fprsUsed < NUM_FPR_ARG_REGISTERS)
+ {
+ *(float*)&outStruct[destMarker] =
+ (float)*(double*)&inFPRs[srcFMarker];
+ srcFMarker += 8;
+ fprsUsed++;
+ }
+ else
+ *(float*)&outStruct[destMarker] =
+ (float)*(double*)&inGPRs[srcGMarker];
- srcGMarker += 4;
- destMarker += 4;
+ srcGMarker += 4;
+ destMarker += 4;
- // Skip to next GPR if next element won't fit and we're
- // not already at a register boundary.
- if (inType->elements[i + 1] != NULL && (destMarker % 8))
- {
- if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
- (!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
- (ALIGN(srcGMarker, 8) - srcGMarker) < 2) &&
- (!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
- (ALIGN(srcGMarker, 8) - srcGMarker) < 4))
- srcGMarker = ALIGN(srcGMarker, 8);
- }
+ // Skip to next GPR if next element won't fit and we're
+ // not already at a register boundary.
+ if (inType->elements[i + 1] != NULL && (destMarker % 8))
+ {
+ if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
+ (!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
+ (ALIGN(srcGMarker, 8) - srcGMarker) < 2) &&
+ (!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
+ (ALIGN(srcGMarker, 8) - srcGMarker) < 4))
+ srcGMarker = ALIGN(srcGMarker, 8);
+ }
- break;
+ break;
- case FFI_TYPE_DOUBLE:
- srcFMarker = ALIGN(srcFMarker, 8);
- destMarker = ALIGN(destMarker, 8);
+ case FFI_TYPE_DOUBLE:
+ srcFMarker = ALIGN(srcFMarker, 8);
+ destMarker = ALIGN(destMarker, 8);
- if (fprsUsed < NUM_FPR_ARG_REGISTERS)
- {
- *(double*)&outStruct[destMarker] =
- *(double*)&inFPRs[srcFMarker];
- srcFMarker += 8;
- fprsUsed++;
- }
- else
- *(double*)&outStruct[destMarker] =
- *(double*)&inGPRs[srcGMarker];
+ if (fprsUsed < NUM_FPR_ARG_REGISTERS)
+ {
+ *(double*)&outStruct[destMarker] =
+ *(double*)&inFPRs[srcFMarker];
+ srcFMarker += 8;
+ fprsUsed++;
+ }
+ else
+ *(double*)&outStruct[destMarker] =
+ *(double*)&inGPRs[srcGMarker];
- destMarker += 8;
+ destMarker += 8;
- // Skip next GPR
- srcGMarker += 8;
- srcGMarker = ALIGN(srcGMarker, 8);
+ // Skip next GPR
+ srcGMarker += 8;
+ srcGMarker = ALIGN(srcGMarker, 8);
- break;
+ break;
- case FFI_TYPE_LONGDOUBLE:
- destMarker = ALIGN(destMarker, 16);
+ case FFI_TYPE_LONGDOUBLE:
+ destMarker = ALIGN(destMarker, 16);
- if (fprsUsed < NUM_FPR_ARG_REGISTERS)
- {
- srcFMarker = ALIGN(srcFMarker, 8);
- srcGMarker = ALIGN(srcGMarker, 8);
- *(long double*)&outStruct[destMarker] =
- *(long double*)&inFPRs[srcFMarker];
- srcFMarker += 16;
- fprsUsed += 2;
- }
- else
- {
- srcFMarker = ALIGN(srcFMarker, 16);
- srcGMarker = ALIGN(srcGMarker, 16);
- *(long double*)&outStruct[destMarker] =
- *(long double*)&inGPRs[srcGMarker];
- }
+ if (fprsUsed < NUM_FPR_ARG_REGISTERS)
+ {
+ srcFMarker = ALIGN(srcFMarker, 8);
+ srcGMarker = ALIGN(srcGMarker, 8);
+ *(long double*)&outStruct[destMarker] =
+ *(long double*)&inFPRs[srcFMarker];
+ srcFMarker += 16;
+ fprsUsed += 2;
+ }
+ else
+ {
+ srcFMarker = ALIGN(srcFMarker, 16);
+ srcGMarker = ALIGN(srcGMarker, 16);
+ *(long double*)&outStruct[destMarker] =
+ *(long double*)&inGPRs[srcGMarker];
+ }
- destMarker += 16;
+ destMarker += 16;
- // Skip next 2 GPRs
- srcGMarker += 16;
- srcGMarker = ALIGN(srcGMarker, 8);
+ // Skip next 2 GPRs
+ srcGMarker += 16;
+ srcGMarker = ALIGN(srcGMarker, 8);
- break;
+ break;
- case FFI_TYPE_UINT8:
- case FFI_TYPE_SINT8:
- {
- if (inType->alignment == 1) // chars only
- {
- if (inType->size == 1)
- outStruct[destMarker++] = inGPRs[srcGMarker++];
- else if (inType->size == 2)
- {
- outStruct[destMarker++] = inGPRs[srcGMarker++];
- outStruct[destMarker++] = inGPRs[srcGMarker++];
- i++;
- }
- else
- {
- memcpy(&outStruct[destMarker],
- &inGPRs[srcGMarker], inType->size);
- srcGMarker += inType->size;
- destMarker += inType->size;
- i += inType->size - 1;
- }
- }
- else // chars and other stuff
- {
- outStruct[destMarker++] = inGPRs[srcGMarker++];
+ case FFI_TYPE_UINT8:
+ case FFI_TYPE_SINT8:
+ {
+ if (inType->alignment == 1) // chars only
+ {
+ if (inType->size == 1)
+ outStruct[destMarker++] = inGPRs[srcGMarker++];
+ else if (inType->size == 2)
+ {
+ outStruct[destMarker++] = inGPRs[srcGMarker++];
+ outStruct[destMarker++] = inGPRs[srcGMarker++];
+ i++;
+ }
+ else
+ {
+ memcpy(&outStruct[destMarker],
+ &inGPRs[srcGMarker], inType->size);
+ srcGMarker += inType->size;
+ destMarker += inType->size;
+ i += inType->size - 1;
+ }
+ }
+ else // chars and other stuff
+ {
+ outStruct[destMarker++] = inGPRs[srcGMarker++];
- // Skip to next GPR if next element won't fit and we're
- // not already at a register boundary.
- if (inType->elements[i + 1] != NULL && (srcGMarker % 8))
- {
- if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
- (!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
- (ALIGN(srcGMarker, 8) - srcGMarker) < 2) &&
- (!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
- (ALIGN(srcGMarker, 8) - srcGMarker) < 4))
- srcGMarker = ALIGN(srcGMarker, inType->alignment); // was 8
- }
- }
+ // Skip to next GPR if next element won't fit and we're
+ // not already at a register boundary.
+ if (inType->elements[i + 1] != NULL && (srcGMarker % 8))
+ {
+ if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
+ (!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
+ (ALIGN(srcGMarker, 8) - srcGMarker) < 2) &&
+ (!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
+ (ALIGN(srcGMarker, 8) - srcGMarker) < 4))
+ srcGMarker = ALIGN(srcGMarker, inType->alignment); // was 8
+ }
+ }
- break;
- }
+ break;
+ }
- case FFI_TYPE_UINT16:
- case FFI_TYPE_SINT16:
- srcGMarker = ALIGN(srcGMarker, 2);
- destMarker = ALIGN(destMarker, 2);
+ case FFI_TYPE_UINT16:
+ case FFI_TYPE_SINT16:
+ srcGMarker = ALIGN(srcGMarker, 2);
+ destMarker = ALIGN(destMarker, 2);
- *(short*)&outStruct[destMarker] =
- *(short*)&inGPRs[srcGMarker];
- srcGMarker += 2;
- destMarker += 2;
+ *(short*)&outStruct[destMarker] =
+ *(short*)&inGPRs[srcGMarker];
+ srcGMarker += 2;
+ destMarker += 2;
- break;
+ break;
- case FFI_TYPE_INT:
- case FFI_TYPE_UINT32:
- case FFI_TYPE_SINT32:
- srcGMarker = ALIGN(srcGMarker, 4);
- destMarker = ALIGN(destMarker, 4);
+ case FFI_TYPE_INT:
+ case FFI_TYPE_UINT32:
+ case FFI_TYPE_SINT32:
+ srcGMarker = ALIGN(srcGMarker, 4);
+ destMarker = ALIGN(destMarker, 4);
- *(int*)&outStruct[destMarker] =
- *(int*)&inGPRs[srcGMarker];
- srcGMarker += 4;
- destMarker += 4;
+ *(int*)&outStruct[destMarker] =
+ *(int*)&inGPRs[srcGMarker];
+ srcGMarker += 4;
+ destMarker += 4;
- break;
+ break;
- case FFI_TYPE_POINTER:
- case FFI_TYPE_UINT64:
- case FFI_TYPE_SINT64:
- srcGMarker = ALIGN(srcGMarker, 8);
- destMarker = ALIGN(destMarker, 8);
+ case FFI_TYPE_POINTER:
+ case FFI_TYPE_UINT64:
+ case FFI_TYPE_SINT64:
+ srcGMarker = ALIGN(srcGMarker, 8);
+ destMarker = ALIGN(destMarker, 8);
- *(long long*)&outStruct[destMarker] =
- *(long long*)&inGPRs[srcGMarker];
- srcGMarker += 8;
- destMarker += 8;
+ *(long long*)&outStruct[destMarker] =
+ *(long long*)&inGPRs[srcGMarker];
+ srcGMarker += 8;
+ destMarker += 8;
- break;
+ break;
- case FFI_TYPE_STRUCT:
- recurseCount++;
- ffi64_struct_to_ram_form(inType->elements[i], inGPRs,
- &srcGMarker, inFPRs, &srcFMarker, &fprsUsed,
- outStruct, &destMarker);
- recurseCount--;
- break;
+ case FFI_TYPE_STRUCT:
+ recurseCount++;
+ ffi64_struct_to_ram_form(inType->elements[i], inGPRs,
+ &srcGMarker, inFPRs, &srcFMarker, &fprsUsed,
+ outStruct, &destMarker);
+ recurseCount--;
+ break;
- default:
- FFI_ASSERT(0); // unknown element type
- break;
- }
- }
+ default:
+ FFI_ASSERT(0); // unknown element type
+ break;
+ }
+ }
- srcGMarker = ALIGN(srcGMarker, inType->alignment);
+ srcGMarker = ALIGN(srcGMarker, inType->alignment);
- // Take care of the special case for 16-byte structs, but not for
- // nested structs.
- if (recurseCount == 0 && srcGMarker == 16)
- {
- *(long double*)&outStruct[0] = *(long double*)&inGPRs[0];
- srcFMarker = savedFMarker;
- fprsUsed = savedFPRsUsed;
- }
+ // Take care of the special case for 16-byte structs, but not for
+ // nested structs.
+ if (recurseCount == 0 && srcGMarker == 16)
+ {
+ *(long double*)&outStruct[0] = *(long double*)&inGPRs[0];
+ srcFMarker = savedFMarker;
+ fprsUsed = savedFPRsUsed;
+ }
- if (ioGPRMarker)
- *ioGPRMarker = ALIGN(srcGMarker, 8);
+ if (ioGPRMarker)
+ *ioGPRMarker = ALIGN(srcGMarker, 8);
- if (ioFPRMarker)
- *ioFPRMarker = srcFMarker;
+ if (ioFPRMarker)
+ *ioFPRMarker = srcFMarker;
- if (ioFPRsUsed)
- *ioFPRsUsed = fprsUsed;
+ if (ioFPRsUsed)
+ *ioFPRsUsed = fprsUsed;
- if (ioStructMarker)
- *ioStructMarker = ALIGN(destMarker, 8);
+ if (ioStructMarker)
+ *ioStructMarker = ALIGN(destMarker, 8);
}
-/* ffi64_struct_to_reg_form
+/* ffi64_struct_to_reg_form
- Copy a struct's elements into buffers that can be sliced into registers.
- Return the sizes of the output buffers in bytes. Pass NULL buffer pointers
- to calculate size only.
- outGPRs[0-7] == r3, outFPRs[0-7] == f1 ...
+ Copy a struct's elements into buffers that can be sliced into registers.
+ Return the sizes of the output buffers in bytes. Pass NULL buffer pointers
+ to calculate size only.
+ outGPRs[0-7] == r3, outFPRs[0-7] == f1 ...
*/
void
ffi64_struct_to_reg_form(
- const ffi_type* inType,
- const char* inStruct,
- unsigned int* ioStructMarker,
- unsigned int* ioFPRsUsed,
- char* outGPRs, // caller-allocated
- unsigned int* ioGPRSize,
- char* outFPRs, // caller-allocated
- unsigned int* ioFPRSize)
+ const ffi_type* inType,
+ const char* inStruct,
+ unsigned int* ioStructMarker,
+ unsigned int* ioFPRsUsed,
+ char* outGPRs, // caller-allocated
+ unsigned int* ioGPRSize,
+ char* outFPRs, // caller-allocated
+ unsigned int* ioFPRSize)
{
- size_t i;
- unsigned int srcMarker = 0;
- unsigned int destGMarker = 0;
- unsigned int destFMarker = 0;
- unsigned int savedFMarker = 0;
- unsigned int fprsUsed = 0;
- unsigned int savedFPRsUsed = 0;
+ size_t i;
+ unsigned int srcMarker = 0;
+ unsigned int destGMarker = 0;
+ unsigned int destFMarker = 0;
+ unsigned int savedFMarker = 0;
+ unsigned int fprsUsed = 0;
+ unsigned int savedFPRsUsed = 0;
- static unsigned int recurseCount = 0;
+ static unsigned int recurseCount = 0;
- if (ioStructMarker)
- srcMarker = *ioStructMarker;
+ if (ioStructMarker)
+ srcMarker = *ioStructMarker;
- if (ioFPRsUsed)
- {
- fprsUsed = *ioFPRsUsed;
- savedFPRsUsed = fprsUsed;
- }
+ if (ioFPRsUsed)
+ {
+ fprsUsed = *ioFPRsUsed;
+ savedFPRsUsed = fprsUsed;
+ }
- if (ioGPRSize)
- destGMarker = *ioGPRSize;
+ if (ioGPRSize)
+ destGMarker = *ioGPRSize;
- if (ioFPRSize)
- {
- destFMarker = *ioFPRSize;
- savedFMarker = destFMarker;
- }
+ if (ioFPRSize)
+ {
+ destFMarker = *ioFPRSize;
+ savedFMarker = destFMarker;
+ }
- switch (inType->size)
- {
- case 1: case 2: case 4:
- destGMarker += 8 - inType->size;
- break;
+ switch (inType->size)
+ {
+ case 1: case 2: case 4:
+ destGMarker += 8 - inType->size;
+ break;
- default:
- break;
- }
+ default:
+ break;
+ }
- for (i = 0; inType->elements[i] != NULL; i++)
- {
- switch (inType->elements[i]->type)
- {
- // Shadow floating-point types in GPRs for vararg and pre-ANSI
- // functions.
- case FFI_TYPE_FLOAT:
- // Nudge markers to next 4/8-byte boundary
- srcMarker = ALIGN(srcMarker, 4);
- destGMarker = ALIGN(destGMarker, 4);
- destFMarker = ALIGN(destFMarker, 8);
+ for (i = 0; inType->elements[i] != NULL; i++)
+ {
+ switch (inType->elements[i]->type)
+ {
+ // Shadow floating-point types in GPRs for vararg and pre-ANSI
+ // functions.
+ case FFI_TYPE_FLOAT:
+ // Nudge markers to next 4/8-byte boundary
+ srcMarker = ALIGN(srcMarker, 4);
+ destGMarker = ALIGN(destGMarker, 4);
+ destFMarker = ALIGN(destFMarker, 8);
- if (fprsUsed < NUM_FPR_ARG_REGISTERS)
- {
- if (outFPRs != NULL && inStruct != NULL)
- *(double*)&outFPRs[destFMarker] =
- (double)*(float*)&inStruct[srcMarker];
+ if (fprsUsed < NUM_FPR_ARG_REGISTERS)
+ {
+ if (outFPRs != NULL && inStruct != NULL)
+ *(double*)&outFPRs[destFMarker] =
+ (double)*(float*)&inStruct[srcMarker];
- destFMarker += 8;
- fprsUsed++;
- }
+ destFMarker += 8;
+ fprsUsed++;
+ }
- if (outGPRs != NULL && inStruct != NULL)
- *(double*)&outGPRs[destGMarker] =
- (double)*(float*)&inStruct[srcMarker];
+ if (outGPRs != NULL && inStruct != NULL)
+ *(double*)&outGPRs[destGMarker] =
+ (double)*(float*)&inStruct[srcMarker];
- srcMarker += 4;
- destGMarker += 4;
+ srcMarker += 4;
+ destGMarker += 4;
- // Skip to next GPR if next element won't fit and we're
- // not already at a register boundary.
- if (inType->elements[i + 1] != NULL && (srcMarker % 8))
- {
- if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
- (!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
- (ALIGN(destGMarker, 8) - destGMarker) < 2) &&
- (!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
- (ALIGN(destGMarker, 8) - destGMarker) < 4))
- destGMarker = ALIGN(destGMarker, 8);
- }
+ // Skip to next GPR if next element won't fit and we're
+ // not already at a register boundary.
+ if (inType->elements[i + 1] != NULL && (srcMarker % 8))
+ {
+ if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
+ (!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
+ (ALIGN(destGMarker, 8) - destGMarker) < 2) &&
+ (!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
+ (ALIGN(destGMarker, 8) - destGMarker) < 4))
+ destGMarker = ALIGN(destGMarker, 8);
+ }
- break;
+ break;
- case FFI_TYPE_DOUBLE:
- srcMarker = ALIGN(srcMarker, 8);
- destFMarker = ALIGN(destFMarker, 8);
+ case FFI_TYPE_DOUBLE:
+ srcMarker = ALIGN(srcMarker, 8);
+ destFMarker = ALIGN(destFMarker, 8);
- if (fprsUsed < NUM_FPR_ARG_REGISTERS)
- {
- if (outFPRs != NULL && inStruct != NULL)
- *(double*)&outFPRs[destFMarker] =
- *(double*)&inStruct[srcMarker];
+ if (fprsUsed < NUM_FPR_ARG_REGISTERS)
+ {
+ if (outFPRs != NULL && inStruct != NULL)
+ *(double*)&outFPRs[destFMarker] =
+ *(double*)&inStruct[srcMarker];
- destFMarker += 8;
- fprsUsed++;
- }
+ destFMarker += 8;
+ fprsUsed++;
+ }
- if (outGPRs != NULL && inStruct != NULL)
- *(double*)&outGPRs[destGMarker] =
- *(double*)&inStruct[srcMarker];
+ if (outGPRs != NULL && inStruct != NULL)
+ *(double*)&outGPRs[destGMarker] =
+ *(double*)&inStruct[srcMarker];
- srcMarker += 8;
+ srcMarker += 8;
- // Skip next GPR
- destGMarker += 8;
- destGMarker = ALIGN(destGMarker, 8);
+ // Skip next GPR
+ destGMarker += 8;
+ destGMarker = ALIGN(destGMarker, 8);
- break;
+ break;
- case FFI_TYPE_LONGDOUBLE:
- srcMarker = ALIGN(srcMarker, 16);
+ case FFI_TYPE_LONGDOUBLE:
+ srcMarker = ALIGN(srcMarker, 16);
- if (fprsUsed < NUM_FPR_ARG_REGISTERS)
- {
- destFMarker = ALIGN(destFMarker, 8);
- destGMarker = ALIGN(destGMarker, 8);
+ if (fprsUsed < NUM_FPR_ARG_REGISTERS)
+ {
+ destFMarker = ALIGN(destFMarker, 8);
+ destGMarker = ALIGN(destGMarker, 8);
- if (outFPRs != NULL && inStruct != NULL)
- *(long double*)&outFPRs[destFMarker] =
- *(long double*)&inStruct[srcMarker];
+ if (outFPRs != NULL && inStruct != NULL)
+ *(long double*)&outFPRs[destFMarker] =
+ *(long double*)&inStruct[srcMarker];
- if (outGPRs != NULL && inStruct != NULL)
- *(long double*)&outGPRs[destGMarker] =
- *(long double*)&inStruct[srcMarker];
+ if (outGPRs != NULL && inStruct != NULL)
+ *(long double*)&outGPRs[destGMarker] =
+ *(long double*)&inStruct[srcMarker];
- destFMarker += 16;
- fprsUsed += 2;
- }
- else
- {
- destGMarker = ALIGN(destGMarker, 16);
+ destFMarker += 16;
+ fprsUsed += 2;
+ }
+ else
+ {
+ destGMarker = ALIGN(destGMarker, 16);
- if (outGPRs != NULL && inStruct != NULL)
- *(long double*)&outGPRs[destGMarker] =
- *(long double*)&inStruct[srcMarker];
- }
+ if (outGPRs != NULL && inStruct != NULL)
+ *(long double*)&outGPRs[destGMarker] =
+ *(long double*)&inStruct[srcMarker];
+ }
- srcMarker += 16;
- destGMarker += 16; // Skip next 2 GPRs
- destGMarker = ALIGN(destGMarker, 8); // was 16
+ srcMarker += 16;
+ destGMarker += 16; // Skip next 2 GPRs
+ destGMarker = ALIGN(destGMarker, 8); // was 16
- break;
+ break;
- case FFI_TYPE_UINT8:
- case FFI_TYPE_SINT8:
- if (inType->alignment == 1) // bytes only
- {
- if (inType->size == 1)
- {
- if (outGPRs != NULL && inStruct != NULL)
- outGPRs[destGMarker] = inStruct[srcMarker];
+ case FFI_TYPE_UINT8:
+ case FFI_TYPE_SINT8:
+ if (inType->alignment == 1) // bytes only
+ {
+ if (inType->size == 1)
+ {
+ if (outGPRs != NULL && inStruct != NULL)
+ outGPRs[destGMarker] = inStruct[srcMarker];
- srcMarker++;
- destGMarker++;
- }
- else if (inType->size == 2)
- {
- if (outGPRs != NULL && inStruct != NULL)
- {
- outGPRs[destGMarker] = inStruct[srcMarker];
- outGPRs[destGMarker + 1] = inStruct[srcMarker + 1];
- }
+ srcMarker++;
+ destGMarker++;
+ }
+ else if (inType->size == 2)
+ {
+ if (outGPRs != NULL && inStruct != NULL)
+ {
+ outGPRs[destGMarker] = inStruct[srcMarker];
+ outGPRs[destGMarker + 1] = inStruct[srcMarker + 1];
+ }
- srcMarker += 2;
- destGMarker += 2;
+ srcMarker += 2;
+ destGMarker += 2;
- i++;
- }
- else
- {
- if (outGPRs != NULL && inStruct != NULL)
- {
- // Avoid memcpy for small chunks.
- if (inType->size <= sizeof(long))
- *(long*)&outGPRs[destGMarker] =
- *(long*)&inStruct[srcMarker];
- else
- memcpy(&outGPRs[destGMarker],
- &inStruct[srcMarker], inType->size);
- }
-
- srcMarker += inType->size;
- destGMarker += inType->size;
- i += inType->size - 1;
- }
- }
- else // bytes and other stuff
- {
- if (outGPRs != NULL && inStruct != NULL)
- outGPRs[destGMarker] = inStruct[srcMarker];
+ i++;
+ }
+ else
+ {
+ if (outGPRs != NULL && inStruct != NULL)
+ {
+ // Avoid memcpy for small chunks.
+ if (inType->size <= sizeof(long))
+ *(long*)&outGPRs[destGMarker] =
+ *(long*)&inStruct[srcMarker];
+ else
+ memcpy(&outGPRs[destGMarker],
+ &inStruct[srcMarker], inType->size);
+ }
+
+ srcMarker += inType->size;
+ destGMarker += inType->size;
+ i += inType->size - 1;
+ }
+ }
+ else // bytes and other stuff
+ {
+ if (outGPRs != NULL && inStruct != NULL)
+ outGPRs[destGMarker] = inStruct[srcMarker];
- srcMarker++;
- destGMarker++;
+ srcMarker++;
+ destGMarker++;
- // Skip to next GPR if next element won't fit and we're
- // not already at a register boundary.
- if (inType->elements[i + 1] != NULL && (destGMarker % 8))
- {
- if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
- (!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
- (ALIGN(destGMarker, 8) - destGMarker) < 2) &&
- (!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
- (ALIGN(destGMarker, 8) - destGMarker) < 4))
- destGMarker = ALIGN(destGMarker, inType->alignment); // was 8
- }
- }
+ // Skip to next GPR if next element won't fit and we're
+ // not already at a register boundary.
+ if (inType->elements[i + 1] != NULL && (destGMarker % 8))
+ {
+ if (!FFI_TYPE_1_BYTE(inType->elements[i + 1]->type) &&
+ (!FFI_TYPE_2_BYTE(inType->elements[i + 1]->type) ||
+ (ALIGN(destGMarker, 8) - destGMarker) < 2) &&
+ (!FFI_TYPE_4_BYTE(inType->elements[i + 1]->type) ||
+ (ALIGN(destGMarker, 8) - destGMarker) < 4))
+ destGMarker = ALIGN(destGMarker, inType->alignment); // was 8
+ }
+ }
- break;
+ break;
- case FFI_TYPE_UINT16:
- case FFI_TYPE_SINT16:
- srcMarker = ALIGN(srcMarker, 2);
- destGMarker = ALIGN(destGMarker, 2);
+ case FFI_TYPE_UINT16:
+ case FFI_TYPE_SINT16:
+ srcMarker = ALIGN(srcMarker, 2);
+ destGMarker = ALIGN(destGMarker, 2);
- if (outGPRs != NULL && inStruct != NULL)
- *(short*)&outGPRs[destGMarker] =
- *(short*)&inStruct[srcMarker];
+ if (outGPRs != NULL && inStruct != NULL)
+ *(short*)&outGPRs[destGMarker] =
+ *(short*)&inStruct[srcMarker];
- srcMarker += 2;
- destGMarker += 2;
+ srcMarker += 2;
+ destGMarker += 2;
- if (inType->elements[i + 1] == NULL)
- destGMarker = ALIGN(destGMarker, inType->alignment);
+ if (inType->elements[i + 1] == NULL)
+ destGMarker = ALIGN(destGMarker, inType->alignment);
- break;
+ break;
- case FFI_TYPE_INT:
- case FFI_TYPE_UINT32:
- case FFI_TYPE_SINT32:
- srcMarker = ALIGN(srcMarker, 4);
- destGMarker = ALIGN(destGMarker, 4);
+ case FFI_TYPE_INT:
+ case FFI_TYPE_UINT32:
+ case FFI_TYPE_SINT32:
+ srcMarker = ALIGN(srcMarker, 4);
+ destGMarker = ALIGN(destGMarker, 4);
- if (outGPRs != NULL && inStruct != NULL)
- *(int*)&outGPRs[destGMarker] =
- *(int*)&inStruct[srcMarker];
+ if (outGPRs != NULL && inStruct != NULL)
+ *(int*)&outGPRs[destGMarker] =
+ *(int*)&inStruct[srcMarker];
- srcMarker += 4;
- destGMarker += 4;
+ srcMarker += 4;
+ destGMarker += 4;
- break;
+ break;
- case FFI_TYPE_POINTER:
- case FFI_TYPE_UINT64:
- case FFI_TYPE_SINT64:
- srcMarker = ALIGN(srcMarker, 8);
- destGMarker = ALIGN(destGMarker, 8);
+ case FFI_TYPE_POINTER:
+ case FFI_TYPE_UINT64:
+ case FFI_TYPE_SINT64:
+ srcMarker = ALIGN(srcMarker, 8);
+ destGMarker = ALIGN(destGMarker, 8);
- if (outGPRs != NULL && inStruct != NULL)
- *(long long*)&outGPRs[destGMarker] =
- *(long long*)&inStruct[srcMarker];
+ if (outGPRs != NULL && inStruct != NULL)
+ *(long long*)&outGPRs[destGMarker] =
+ *(long long*)&inStruct[srcMarker];
- srcMarker += 8;
- destGMarker += 8;
+ srcMarker += 8;
+ destGMarker += 8;
- if (inType->elements[i + 1] == NULL)
- destGMarker = ALIGN(destGMarker, inType->alignment);
+ if (inType->elements[i + 1] == NULL)
+ destGMarker = ALIGN(destGMarker, inType->alignment);
- break;
+ break;
- case FFI_TYPE_STRUCT:
- recurseCount++;
- ffi64_struct_to_reg_form(inType->elements[i],
- inStruct, &srcMarker, &fprsUsed, outGPRs,
- &destGMarker, outFPRs, &destFMarker);
- recurseCount--;
- break;
+ case FFI_TYPE_STRUCT:
+ recurseCount++;
+ ffi64_struct_to_reg_form(inType->elements[i],
+ inStruct, &srcMarker, &fprsUsed, outGPRs,
+ &destGMarker, outFPRs, &destFMarker);
+ recurseCount--;
+ break;
- default:
- FFI_ASSERT(0);
- break;
- }
- }
+ default:
+ FFI_ASSERT(0);
+ break;
+ }
+ }
- destGMarker = ALIGN(destGMarker, inType->alignment);
+ destGMarker = ALIGN(destGMarker, inType->alignment);
- // Take care of the special case for 16-byte structs, but not for
- // nested structs.
- if (recurseCount == 0 && destGMarker == 16)
- {
- if (outGPRs != NULL && inStruct != NULL)
- *(long double*)&outGPRs[0] = *(long double*)&inStruct[0];
+ // Take care of the special case for 16-byte structs, but not for
+ // nested structs.
+ if (recurseCount == 0 && destGMarker == 16)
+ {
+ if (outGPRs != NULL && inStruct != NULL)
+ *(long double*)&outGPRs[0] = *(long double*)&inStruct[0];
- destFMarker = savedFMarker;
- fprsUsed = savedFPRsUsed;
- }
+ destFMarker = savedFMarker;
+ fprsUsed = savedFPRsUsed;
+ }
- if (ioStructMarker)
- *ioStructMarker = ALIGN(srcMarker, 8);
+ if (ioStructMarker)
+ *ioStructMarker = ALIGN(srcMarker, 8);
- if (ioFPRsUsed)
- *ioFPRsUsed = fprsUsed;
+ if (ioFPRsUsed)
+ *ioFPRsUsed = fprsUsed;
- if (ioGPRSize)
- *ioGPRSize = ALIGN(destGMarker, 8);
+ if (ioGPRSize)
+ *ioGPRSize = ALIGN(destGMarker, 8);
- if (ioFPRSize)
- *ioFPRSize = ALIGN(destFMarker, 8);
+ if (ioFPRSize)
+ *ioFPRSize = ALIGN(destFMarker, 8);
}
-/* ffi64_stret_needs_ptr
+/* ffi64_stret_needs_ptr
- Determine whether a returned struct needs a pointer in r3 or can fit
- in registers.
+ Determine whether a returned struct needs a pointer in r3 or can fit
+ in registers.
*/
bool
ffi64_stret_needs_ptr(
- const ffi_type* inType,
- unsigned short* ioGPRCount,
- unsigned short* ioFPRCount)
+ const ffi_type* inType,
+ unsigned short* ioGPRCount,
+ unsigned short* ioFPRCount)
{
- // Obvious case first- struct is larger than combined FPR size.
- if (inType->size > 14 * 8)
- return true;
+ // Obvious case first- struct is larger than combined FPR size.
+ if (inType->size > 14 * 8)
+ return true;
- // Now the struct can physically fit in registers, determine if it
- // also fits logically.
- bool needsPtr = false;
- unsigned short gprsUsed = 0;
- unsigned short fprsUsed = 0;
- size_t i;
+ // Now the struct can physically fit in registers, determine if it
+ // also fits logically.
+ bool needsPtr = false;
+ unsigned short gprsUsed = 0;
+ unsigned short fprsUsed = 0;
+ size_t i;
- if (ioGPRCount)
- gprsUsed = *ioGPRCount;
+ if (ioGPRCount)
+ gprsUsed = *ioGPRCount;
- if (ioFPRCount)
- fprsUsed = *ioFPRCount;
+ if (ioFPRCount)
+ fprsUsed = *ioFPRCount;
- for (i = 0; inType->elements[i] != NULL && !needsPtr; i++)
- {
- switch (inType->elements[i]->type)
- {
- case FFI_TYPE_FLOAT:
- case FFI_TYPE_DOUBLE:
- gprsUsed++;
- fprsUsed++;
+ for (i = 0; inType->elements[i] != NULL && !needsPtr; i++)
+ {
+ switch (inType->elements[i]->type)
+ {
+ case FFI_TYPE_FLOAT:
+ case FFI_TYPE_DOUBLE:
+ gprsUsed++;
+ fprsUsed++;
- if (fprsUsed > 13)
- needsPtr = true;
+ if (fprsUsed > 13)
+ needsPtr = true;
- break;
+ break;
- case FFI_TYPE_LONGDOUBLE:
- gprsUsed += 2;
- fprsUsed += 2;
+ case FFI_TYPE_LONGDOUBLE:
+ gprsUsed += 2;
+ fprsUsed += 2;
- if (fprsUsed > 14)
- needsPtr = true;
+ if (fprsUsed > 14)
+ needsPtr = true;
- break;
+ break;
- case FFI_TYPE_UINT8:
- case FFI_TYPE_SINT8:
- {
- gprsUsed++;
+ case FFI_TYPE_UINT8:
+ case FFI_TYPE_SINT8:
+ {
+ gprsUsed++;
- if (gprsUsed > 8)
- {
- needsPtr = true;
- break;
- }
+ if (gprsUsed > 8)
+ {
+ needsPtr = true;
+ break;
+ }
- if (inType->elements[i + 1] == NULL) // last byte in the struct
- break;
+ if (inType->elements[i + 1] == NULL) // last byte in the struct
+ break;
- // Count possible contiguous bytes ahead, up to 8.
- unsigned short j;
+ // Count possible contiguous bytes ahead, up to 8.
+ unsigned short j;
- for (j = 1; j < 8; j++)
- {
- if (inType->elements[i + j] == NULL ||
- !FFI_TYPE_1_BYTE(inType->elements[i + j]->type))
- break;
- }
+ for (j = 1; j < 8; j++)
+ {
+ if (inType->elements[i + j] == NULL ||
+ !FFI_TYPE_1_BYTE(inType->elements[i + j]->type))
+ break;
+ }
- i += j - 1; // allow for i++ before the test condition
+ i += j - 1; // allow for i++ before the test condition
- break;
- }
+ break;
+ }
- case FFI_TYPE_UINT16:
- case FFI_TYPE_SINT16:
- case FFI_TYPE_INT:
- case FFI_TYPE_UINT32:
- case FFI_TYPE_SINT32:
- case FFI_TYPE_POINTER:
- case FFI_TYPE_UINT64:
- case FFI_TYPE_SINT64:
- gprsUsed++;
+ case FFI_TYPE_UINT16:
+ case FFI_TYPE_SINT16:
+ case FFI_TYPE_INT:
+ case FFI_TYPE_UINT32:
+ case FFI_TYPE_SINT32:
+ case FFI_TYPE_POINTER:
+ case FFI_TYPE_UINT64:
+ case FFI_TYPE_SINT64:
+ gprsUsed++;
- if (gprsUsed > 8)
- needsPtr = true;
+ if (gprsUsed > 8)
+ needsPtr = true;
- break;
+ break;
- case FFI_TYPE_STRUCT:
- needsPtr = ffi64_stret_needs_ptr(
- inType->elements[i], &gprsUsed, &fprsUsed);
+ case FFI_TYPE_STRUCT:
+ needsPtr = ffi64_stret_needs_ptr(
+ inType->elements[i], &gprsUsed, &fprsUsed);
- break;
+ break;
- default:
- FFI_ASSERT(0);
- break;
- }
- }
+ default:
+ FFI_ASSERT(0);
+ break;
+ }
+ }
- if (ioGPRCount)
- *ioGPRCount = gprsUsed;
+ if (ioGPRCount)
+ *ioGPRCount = gprsUsed;
- if (ioFPRCount)
- *ioFPRCount = fprsUsed;
+ if (ioFPRCount)
+ *ioFPRCount = fprsUsed;
- return needsPtr;
+ return needsPtr;
}
-/* ffi64_data_size
+/* ffi64_data_size
- Calculate the size in bytes of an ffi type.
+ Calculate the size in bytes of an ffi type.
*/
unsigned int
ffi64_data_size(
- const ffi_type* inType)
+ const ffi_type* inType)
{
- unsigned int size = 0;
+ unsigned int size = 0;
- switch (inType->type)
- {
- case FFI_TYPE_UINT8:
- case FFI_TYPE_SINT8:
- size = 1;
- break;
+ switch (inType->type)
+ {
+ case FFI_TYPE_UINT8:
+ case FFI_TYPE_SINT8:
+ size = 1;
+ break;
- case FFI_TYPE_UINT16:
- case FFI_TYPE_SINT16:
- size = 2;
- break;
+ case FFI_TYPE_UINT16:
+ case FFI_TYPE_SINT16:
+ size = 2;
+ break;
- case FFI_TYPE_INT:
- case FFI_TYPE_UINT32:
- case FFI_TYPE_SINT32:
- case FFI_TYPE_FLOAT:
- size = 4;
- break;
+ case FFI_TYPE_INT:
+ case FFI_TYPE_UINT32:
+ case FFI_TYPE_SINT32:
+ case FFI_TYPE_FLOAT:
+ size = 4;
+ break;
- case FFI_TYPE_POINTER:
- case FFI_TYPE_UINT64:
- case FFI_TYPE_SINT64:
- case FFI_TYPE_DOUBLE:
- size = 8;
- break;
+ case FFI_TYPE_POINTER:
+ case FFI_TYPE_UINT64:
+ case FFI_TYPE_SINT64:
+ case FFI_TYPE_DOUBLE:
+ size = 8;
+ break;
- case FFI_TYPE_LONGDOUBLE:
- size = 16;
- break;
+ case FFI_TYPE_LONGDOUBLE:
+ size = 16;
+ break;
- case FFI_TYPE_STRUCT:
- ffi64_struct_to_reg_form(
- inType, NULL, NULL, NULL, NULL, &size, NULL, NULL);
- break;
+ case FFI_TYPE_STRUCT:
+ ffi64_struct_to_reg_form(
+ inType, NULL, NULL, NULL, NULL, &size, NULL, NULL);
+ break;
- case FFI_TYPE_VOID:
- break;
+ case FFI_TYPE_VOID:
+ break;
- default:
- FFI_ASSERT(0);
- break;
- }
+ default:
+ FFI_ASSERT(0);
+ break;
+ }
- return size;
+ return size;
}
-#endif /* defined(__ppc64__) */
-#endif /* __ppc__ || __ppc64__ */
+#endif /* defined(__ppc64__) */
+#endif /* __ppc__ || __ppc64__ */
--
Repository URL: http://hg.python.org/cpython
More information about the Python-checkins
mailing list