Skip to content

C
cpython
Commit 8beaa6c2 authored by Ezio Melotti's avatar Ezio Melotti
Browse files
Options

Revert typo fixes in _cytpes/libffi*

parent 81ce6859
Hide whitespace changes
Inline Side-by-side
Showing with 1721 additions and 1721 deletions
Modules/_ctypes/libffi/src/powerpc/ffi_darwin.c
View file @ 8beaa6c2
...@@ -59,24 +59,24 @@ enum { ASM_NEEDS_REGISTERS = 4 }; ...@@ -59,24 +59,24 @@ enum { ASM_NEEDS_REGISTERS = 4 };
The stack layout we want looks like this: 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 | Previous backchain pointer 4 | stack pointer here
|--------------------------------------------|<+ <<< on entry to |--------------------------------------------|<+ <<< on entry to
| Saved r28-r31 4*4 | | ffi_call_DARWIN | Saved r28-r31 4*4 | | ffi_call_DARWIN
|--------------------------------------------| | |--------------------------------------------| |
| Parameters (at least 8*4=32) | | | Parameters (at least 8*4=32) | |
|--------------------------------------------| | |--------------------------------------------| |
| Space for GPR2 4 | | | Space for GPR2 4 | |
|--------------------------------------------| | stack | |--------------------------------------------| | stack |
| Reserved 2*4 | | grows | | Reserved 2*4 | | grows |
|--------------------------------------------| | down V |--------------------------------------------| | down V
| Space for callee's LR 4 | | | Space for callee's LR 4 | |
|--------------------------------------------| | lower addresses |--------------------------------------------| | lower addresses
| Saved CR 4 | | | Saved CR 4 | |
|--------------------------------------------| | stack pointer here |--------------------------------------------| | stack pointer here
| Current backchain pointer 4 |-/ during | Current backchain pointer 4 |-/ during
|--------------------------------------------| <<< ffi_call_DARWIN |--------------------------------------------| <<< ffi_call_DARWIN
*/ */
...@@ -123,106 +123,106 @@ void ffi_prep_args(extended_cif *ecif, unsigned *const stack) ...@@ -123,106 +123,106 @@ void ffi_prep_args(extended_cif *ecif, unsigned *const stack)
i--, ptr++, p_argv++) i--, ptr++, p_argv++)
{ {
switch ((*ptr)->type) switch ((*ptr)->type)
{ {
/* If a floating-point parameter appears before all of the general- /* If a floating-point parameter appears before all of the general-
purpose registers are filled, the corresponding GPRs that match purpose registers are filled, the corresponding GPRs that match
the size of the floating-point parameter are skipped. */ the size of the floating-point parameter are skipped. */
case FFI_TYPE_FLOAT: case FFI_TYPE_FLOAT:
double_tmp = *(float *)*p_argv; double_tmp = *(float *)*p_argv;
if (fparg_count >= NUM_FPR_ARG_REGISTERS) if (fparg_count >= NUM_FPR_ARG_REGISTERS)
*(double *)next_arg = double_tmp; *(double *)next_arg = double_tmp;
else else
*fpr_base++ = double_tmp; *fpr_base++ = double_tmp;
next_arg++; next_arg++;
fparg_count++; fparg_count++;
FFI_ASSERT(flags & FLAG_FP_ARGUMENTS); FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
break; break;
case FFI_TYPE_DOUBLE: case FFI_TYPE_DOUBLE:
double_tmp = *(double *)*p_argv; double_tmp = *(double *)*p_argv;
if (fparg_count >= NUM_FPR_ARG_REGISTERS) if (fparg_count >= NUM_FPR_ARG_REGISTERS)
*(double *)next_arg = double_tmp; *(double *)next_arg = double_tmp;
else else
*fpr_base++ = double_tmp; *fpr_base++ = double_tmp;
next_arg += 2; next_arg += 2;
fparg_count++; fparg_count++;
FFI_ASSERT(flags & FLAG_FP_ARGUMENTS); FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
break; break;
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
case FFI_TYPE_LONGDOUBLE: case FFI_TYPE_LONGDOUBLE:
double_tmp = ((double *)*p_argv)[0]; double_tmp = ((double *)*p_argv)[0];
if (fparg_count >= NUM_FPR_ARG_REGISTERS) if (fparg_count >= NUM_FPR_ARG_REGISTERS)
*(double *)next_arg = double_tmp; *(double *)next_arg = double_tmp;
else else
*fpr_base++ = double_tmp; *fpr_base++ = double_tmp;
next_arg += 2; next_arg += 2;
fparg_count++; fparg_count++;
double_tmp = ((double *)*p_argv)[1]; double_tmp = ((double *)*p_argv)[1];
if (fparg_count >= NUM_FPR_ARG_REGISTERS) if (fparg_count >= NUM_FPR_ARG_REGISTERS)
*(double *)next_arg = double_tmp; *(double *)next_arg = double_tmp;
else else
*fpr_base++ = double_tmp; *fpr_base++ = double_tmp;
next_arg += 2; next_arg += 2;
fparg_count++; fparg_count++;
FFI_ASSERT(flags & FLAG_FP_ARGUMENTS); FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
break; break;
#endif #endif
case FFI_TYPE_UINT64: case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64: case FFI_TYPE_SINT64:
*(long long *)next_arg = *(long long *)*p_argv; *(long long *)next_arg = *(long long *)*p_argv;
next_arg+=2; next_arg+=2;
break; break;
case FFI_TYPE_UINT8: case FFI_TYPE_UINT8:
gprvalue = *(unsigned char *)*p_argv; gprvalue = *(unsigned char *)*p_argv;
goto putgpr; goto putgpr;
case FFI_TYPE_SINT8: case FFI_TYPE_SINT8:
gprvalue = *(signed char *)*p_argv; gprvalue = *(signed char *)*p_argv;
goto putgpr; goto putgpr;
case FFI_TYPE_UINT16: case FFI_TYPE_UINT16:
gprvalue = *(unsigned short *)*p_argv; gprvalue = *(unsigned short *)*p_argv;
goto putgpr; goto putgpr;
case FFI_TYPE_SINT16: case FFI_TYPE_SINT16:
gprvalue = *(signed short *)*p_argv; gprvalue = *(signed short *)*p_argv;
goto putgpr; goto putgpr;
case FFI_TYPE_STRUCT: case FFI_TYPE_STRUCT:
dest_cpy = (char *) next_arg; dest_cpy = (char *) next_arg;
/* Structures that match the basic modes (QI 1 byte, HI 2 bytes, /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
SI 4 bytes) are aligned as if they were those modes. SI 4 bytes) are aligned as if they were those modes.
Structures with 3 byte in size are padded upwards. */ Structures with 3 byte in size are padded upwards. */
size_al = (*ptr)->size; size_al = (*ptr)->size;
/* If the first member of the struct is a double, then align /* If the first member of the struct is a double, then align
the struct to double-word. the struct to double-word.
Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */ Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
if ((*ptr)->elements[0]->type == 3) if ((*ptr)->elements[0]->type == 3)
size_al = ALIGN((*ptr)->size, 8); size_al = ALIGN((*ptr)->size, 8);
if (size_al < 3 && ecif->cif->abi == FFI_DARWIN) if (size_al < 3 && ecif->cif->abi == FFI_DARWIN)
dest_cpy += 4 - size_al; dest_cpy += 4 - size_al;
memcpy((char *)dest_cpy, (char *)*p_argv, size_al); memcpy((char *)dest_cpy, (char *)*p_argv, size_al);
next_arg += (size_al + 3) / 4; next_arg += (size_al + 3) / 4;
break; break;
case FFI_TYPE_INT: case FFI_TYPE_INT:
case FFI_TYPE_UINT32: case FFI_TYPE_UINT32:
case FFI_TYPE_SINT32: case FFI_TYPE_SINT32:
case FFI_TYPE_POINTER: case FFI_TYPE_POINTER:
gprvalue = *(unsigned *)*p_argv; gprvalue = *(unsigned *)*p_argv;
putgpr: putgpr:
*next_arg++ = gprvalue; *next_arg++ = gprvalue;
break; break;
default: default:
break; break;
} }
} }
/* Check that we didn't overrun the stack... */ /* Check that we didn't overrun the stack... */
//FFI_ASSERT(gpr_base <= stacktop - ASM_NEEDS_REGISTERS); //FFI_ASSERT(gpr_base <= stacktop - ASM_NEEDS_REGISTERS);
//FFI_ASSERT((unsigned *)fpr_base //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); //FFI_ASSERT(flags & FLAG_4_GPR_ARGUMENTS || intarg_count <= 4);
} }
...@@ -246,15 +246,15 @@ darwin_adjust_aggregate_sizes (ffi_type *s) ...@@ -246,15 +246,15 @@ darwin_adjust_aggregate_sizes (ffi_type *s)
p = s->elements[i]; p = s->elements[i];
darwin_adjust_aggregate_sizes (p); darwin_adjust_aggregate_sizes (p);
if (i == 0 if (i == 0
&& (p->type == FFI_TYPE_UINT64 && (p->type == FFI_TYPE_UINT64
|| p->type == FFI_TYPE_SINT64 || p->type == FFI_TYPE_SINT64
|| p->type == FFI_TYPE_DOUBLE || p->type == FFI_TYPE_DOUBLE
|| p->alignment == 8)) || p->alignment == 8))
align = 8; align = 8;
else if (p->alignment == 16 || p->alignment < 4) else if (p->alignment == 16 || p->alignment < 4)
align = p->alignment; align = p->alignment;
else else
align = 4; align = 4;
s->size = ALIGN(s->size, align) + p->size; s->size = ALIGN(s->size, align) + p->size;
} }
...@@ -287,7 +287,7 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif) ...@@ -287,7 +287,7 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
{ {
darwin_adjust_aggregate_sizes (cif->rtype); darwin_adjust_aggregate_sizes (cif->rtype);
for (i = 0; i < cif->nargs; i++) 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 /* Space for the frame pointer, callee's LR, CR, etc, and for
...@@ -348,58 +348,58 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif) ...@@ -348,58 +348,58 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++) for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
{ {
switch ((*ptr)->type) switch ((*ptr)->type)
{ {
case FFI_TYPE_FLOAT: case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE: case FFI_TYPE_DOUBLE:
fparg_count++; fparg_count++;
/* If this FP arg is going on the stack, it must be /* If this FP arg is going on the stack, it must be
8-byte-aligned. */ 8-byte-aligned. */
if (fparg_count > NUM_FPR_ARG_REGISTERS if (fparg_count > NUM_FPR_ARG_REGISTERS
&& intarg_count%2 != 0) && intarg_count%2 != 0)
intarg_count++; intarg_count++;
break; break;
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
case FFI_TYPE_LONGDOUBLE: case FFI_TYPE_LONGDOUBLE:
fparg_count += 2; fparg_count += 2;
/* If this FP arg is going on the stack, it must be /* If this FP arg is going on the stack, it must be
8-byte-aligned. */ 8-byte-aligned. */
if (fparg_count > NUM_FPR_ARG_REGISTERS if (fparg_count > NUM_FPR_ARG_REGISTERS
&& intarg_count%2 != 0) && intarg_count%2 != 0)
intarg_count++; intarg_count++;
intarg_count +=2; intarg_count +=2;
break; break;
#endif #endif
case FFI_TYPE_UINT64: case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64: case FFI_TYPE_SINT64:
/* 'long long' arguments are passed as two words, but /* 'long long' arguments are passed as two words, but
either both words must fit in registers or both go either both words must fit in registers or both go
on the stack. If they go on the stack, they must on the stack. If they go on the stack, they must
be 8-byte-aligned. */ be 8-byte-aligned. */
if (intarg_count == NUM_GPR_ARG_REGISTERS-1 if (intarg_count == NUM_GPR_ARG_REGISTERS-1
|| (intarg_count >= NUM_GPR_ARG_REGISTERS && intarg_count%2 != 0)) || (intarg_count >= NUM_GPR_ARG_REGISTERS && intarg_count%2 != 0))
intarg_count++; intarg_count++;
intarg_count += 2; intarg_count += 2;
break; break;
case FFI_TYPE_STRUCT: case FFI_TYPE_STRUCT:
size_al = (*ptr)->size; size_al = (*ptr)->size;
/* If the first member of the struct is a double, then align /* If the first member of the struct is a double, then align
the struct to double-word. the struct to double-word.
Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */ Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
if ((*ptr)->elements[0]->type == 3) if ((*ptr)->elements[0]->type == 3)
size_al = ALIGN((*ptr)->size, 8); size_al = ALIGN((*ptr)->size, 8);
intarg_count += (size_al + 3) / 4; intarg_count += (size_al + 3) / 4;
break; break;
default: default:
/* Everything else is passed as a 4-byte word in a GPR, either /* Everything else is passed as a 4-byte word in a GPR, either
the object itself or a pointer to it. */ the object itself or a pointer to it. */
intarg_count++; intarg_count++;
break; break;
} }
} }
if (fparg_count != 0) if (fparg_count != 0)
...@@ -425,9 +425,9 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif) ...@@ -425,9 +425,9 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
} }
extern void ffi_call_AIX(extended_cif *, unsigned, unsigned, unsigned *, 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 *, 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) void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
{ {
...@@ -451,11 +451,11 @@ void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue) ...@@ -451,11 +451,11 @@ void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
{ {
case FFI_AIX: case FFI_AIX:
ffi_call_AIX(&ecif, -cif->bytes, cif->flags, ecif.rvalue, fn, ffi_call_AIX(&ecif, -cif->bytes, cif->flags, ecif.rvalue, fn,
ffi_prep_args); ffi_prep_args);
break; break;
case FFI_DARWIN: case FFI_DARWIN:
ffi_call_DARWIN(&ecif, -cif->bytes, cif->flags, ecif.rvalue, fn, ffi_call_DARWIN(&ecif, -cif->bytes, cif->flags, ecif.rvalue, fn,
ffi_prep_args); ffi_prep_args);
break; break;
default: default:
FFI_ASSERT(0); FFI_ASSERT(0);
...@@ -478,61 +478,61 @@ typedef struct aix_fd_struct { ...@@ -478,61 +478,61 @@ typedef struct aix_fd_struct {
and aix_clsoure.S and aix_clsoure.S
SP previous -> +---------------------------------------+ <--- child frame SP previous -> +---------------------------------------+ <--- child frame
| back chain to caller 4 | | back chain to caller 4 |
+---------------------------------------+ 4 +---------------------------------------+ 4
| saved CR 4 | | saved CR 4 |
+---------------------------------------+ 8 +---------------------------------------+ 8
| saved LR 4 | | saved LR 4 |
+---------------------------------------+ 12 +---------------------------------------+ 12
| reserved for compilers 4 | | reserved for compilers 4 |
+---------------------------------------+ 16 +---------------------------------------+ 16
| reserved for binders 4 | | reserved for binders 4 |
+---------------------------------------+ 20 +---------------------------------------+ 20
| saved TOC pointer 4 | | saved TOC pointer 4 |
+---------------------------------------+ 24 +---------------------------------------+ 24
| always reserved 8*4=32 (previous GPRs)| | always reserved 8*4=32 (previous GPRs)|
| according to the linkage convention | | according to the linkage convention |
| from AIX | | from AIX |
+---------------------------------------+ 56 +---------------------------------------+ 56
| our FPR area 13*8=104 | | our FPR area 13*8=104 |
| f1 | | f1 |
| . | | . |
| f13 | | f13 |
+---------------------------------------+ 160 +---------------------------------------+ 160
| result area 8 | | result area 8 |
+---------------------------------------+ 168 +---------------------------------------+ 168
| alignment to the next multiple of 16 | | alignement to the next multiple of 16 |
SP current --> +---------------------------------------+ 176 <- parent frame SP current --> +---------------------------------------+ 176 <- parent frame
| back chain to caller 4 | | back chain to caller 4 |
+---------------------------------------+ 180 +---------------------------------------+ 180
| saved CR 4 | | saved CR 4 |
+---------------------------------------+ 184 +---------------------------------------+ 184
| saved LR 4 | | saved LR 4 |
+---------------------------------------+ 188 +---------------------------------------+ 188
| reserved for compilers 4 | | reserved for compilers 4 |
+---------------------------------------+ 192 +---------------------------------------+ 192
| reserved for binders 4 | | reserved for binders 4 |
+---------------------------------------+ 196 +---------------------------------------+ 196
| saved TOC pointer 4 | | saved TOC pointer 4 |
+---------------------------------------+ 200 +---------------------------------------+ 200
| always reserved 8*4=32 we store our | | always reserved 8*4=32 we store our |
| GPRs here | | GPRs here |
| r3 | | r3 |
| . | | . |
| r10 | | r10 |
+---------------------------------------+ 232 +---------------------------------------+ 232
| overflow part | | overflow part |
+---------------------------------------+ xxx +---------------------------------------+ xxx
| ???? | | ???? |
+---------------------------------------+ xxx +---------------------------------------+ xxx
*/ */
ffi_status ffi_status
ffi_prep_closure_loc (ffi_closure* closure, ffi_prep_closure_loc (ffi_closure* closure,
ffi_cif* cif, ffi_cif* cif,
void (*fun)(ffi_cif*, void*, void**, void*), void (*fun)(ffi_cif*, void*, void**, void*),
void *user_data, void *user_data,
void *codeloc) void *codeloc)
{ {
unsigned int *tramp; unsigned int *tramp;
struct ffi_aix_trampoline_struct *tramp_aix; struct ffi_aix_trampoline_struct *tramp_aix;
...@@ -592,12 +592,12 @@ flush_icache(char *addr) ...@@ -592,12 +592,12 @@ flush_icache(char *addr)
{ {
#ifndef _AIX #ifndef _AIX
__asm__ volatile ( __asm__ volatile (
"dcbf 0,%0\n" "dcbf 0,%0\n"
"\tsync\n" "\tsync\n"
"\ticbi 0,%0\n" "\ticbi 0,%0\n"
"\tsync\n" "\tsync\n"
"\tisync" "\tisync"
: : "r"(addr) : "memory"); : : "r"(addr) : "memory");
#endif #endif
} }
...@@ -618,7 +618,7 @@ typedef union ...@@ -618,7 +618,7 @@ typedef union
} ffi_dblfl; } ffi_dblfl;
int ffi_closure_helper_DARWIN (ffi_closure*, void*, 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 /* Basically the trampoline invokes ffi_closure_ASM, and on
entry, r11 holds the address of the closure. entry, r11 holds the address of the closure.
...@@ -628,7 +628,7 @@ int ffi_closure_helper_DARWIN (ffi_closure*, void*, ...@@ -628,7 +628,7 @@ int ffi_closure_helper_DARWIN (ffi_closure*, void*,
following helper function to do most of the work. */ following helper function to do most of the work. */
int ffi_closure_helper_DARWIN (ffi_closure* closure, void * rvalue, 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 /* 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 pgr is the pointer to where r3-r10 are stored in ffi_closure_ASM
...@@ -675,121 +675,121 @@ int ffi_closure_helper_DARWIN (ffi_closure* closure, void * rvalue, ...@@ -675,121 +675,121 @@ int ffi_closure_helper_DARWIN (ffi_closure* closure, void * rvalue,
while (i < avn) while (i < avn)
{ {
switch (arg_types[i]->type) switch (arg_types[i]->type)
{ {
case FFI_TYPE_SINT8: case FFI_TYPE_SINT8:
case FFI_TYPE_UINT8: case FFI_TYPE_UINT8:
avalue[i] = (char *) pgr + 3; avalue[i] = (char *) pgr + 3;
ng++; ng++;
pgr++; pgr++;
break; break;
case FFI_TYPE_SINT16: case FFI_TYPE_SINT16:
case FFI_TYPE_UINT16: case FFI_TYPE_UINT16:
avalue[i] = (char *) pgr + 2; avalue[i] = (char *) pgr + 2;
ng++; ng++;
pgr++; pgr++;
break; break;
case FFI_TYPE_SINT32: case FFI_TYPE_SINT32:
case FFI_TYPE_UINT32: case FFI_TYPE_UINT32:
case FFI_TYPE_POINTER: case FFI_TYPE_POINTER:
avalue[i] = pgr; avalue[i] = pgr;
ng++; ng++;
pgr++; pgr++;
break; break;
case FFI_TYPE_STRUCT: case FFI_TYPE_STRUCT:
/* Structures that match the basic modes (QI 1 byte, HI 2 bytes, /* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
SI 4 bytes) are aligned as if they were those modes. */ SI 4 bytes) are aligned as if they were those modes. */
size_al = arg_types[i]->size; size_al = arg_types[i]->size;
/* If the first member of the struct is a double, then align /* If the first member of the struct is a double, then align
the struct to double-word. the struct to double-word.
Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */ Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
if (arg_types[i]->elements[0]->type == 3) if (arg_types[i]->elements[0]->type == 3)
size_al = ALIGN(arg_types[i]->size, 8); size_al = ALIGN(arg_types[i]->size, 8);
if (size_al < 3 && cif->abi == FFI_DARWIN) if (size_al < 3 && cif->abi == FFI_DARWIN)
avalue[i] = (void*) pgr + 4 - size_al; avalue[i] = (void*) pgr + 4 - size_al;
else else
avalue[i] = (void*) pgr; avalue[i] = (void*) pgr;
ng += (size_al + 3) / 4; ng += (size_al + 3) / 4;
pgr += (size_al + 3) / 4; pgr += (size_al + 3) / 4;
break; break;
case FFI_TYPE_SINT64: case FFI_TYPE_SINT64:
case FFI_TYPE_UINT64: case FFI_TYPE_UINT64:
/* Long long ints are passed in two gpr's. */ /* Long long ints are passed in two gpr's. */
avalue[i] = pgr; avalue[i] = pgr;
ng += 2; ng += 2;
pgr += 2; pgr += 2;
break; break;
case FFI_TYPE_FLOAT: case FFI_TYPE_FLOAT:
/* A float value consumes a GPR. /* A float value consumes a GPR.
There are 13 64bit floating point registers. */ There are 13 64bit floating point registers. */
if (nf < NUM_FPR_ARG_REGISTERS) if (nf < NUM_FPR_ARG_REGISTERS)
{ {
temp = pfr->d; temp = pfr->d;
pfr->f = (float)temp; pfr->f = (float)temp;
avalue[i] = pfr; avalue[i] = pfr;
pfr++; pfr++;
} }
else else
{ {
avalue[i] = pgr; avalue[i] = pgr;
} }
nf++; nf++;
ng++; ng++;
pgr++; pgr++;
break; break;
case FFI_TYPE_DOUBLE: case FFI_TYPE_DOUBLE:
/* A double value consumes two GPRs. /* A double value consumes two GPRs.
There are 13 64bit floating point registers. */ There are 13 64bit floating point registers. */
if (nf < NUM_FPR_ARG_REGISTERS) if (nf < NUM_FPR_ARG_REGISTERS)
{ {
avalue[i] = pfr; avalue[i] = pfr;
pfr++; pfr++;
} }
else else
{ {
avalue[i] = pgr; avalue[i] = pgr;
} }
nf++; nf++;
ng += 2; ng += 2;
pgr += 2; pgr += 2;
break; break;
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE #if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
case FFI_TYPE_LONGDOUBLE: case FFI_TYPE_LONGDOUBLE:
/* A long double value consumes four GPRs and two FPRs. /* A long double value consumes four GPRs and two FPRs.
There are 13 64bit floating point registers. */ There are 13 64bit floating point registers. */
if (nf < NUM_FPR_ARG_REGISTERS - 1) if (nf < NUM_FPR_ARG_REGISTERS - 1)
{ {
avalue[i] = pfr; avalue[i] = pfr;
pfr += 2; pfr += 2;
} }
/* Here we have the situation where one part of the long double /* 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. 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]. */ We use a union to pass the long double to avalue[i]. */
else if (nf == NUM_FPR_ARG_REGISTERS - 1) else if (nf == NUM_FPR_ARG_REGISTERS - 1)
{ {
memcpy (&temp_ld.lb[0], pfr, sizeof(ldbits)); memcpy (&temp_ld.lb[0], pfr, sizeof(ldbits));
memcpy (&temp_ld.lb[1], pgr + 2, sizeof(ldbits)); memcpy (&temp_ld.lb[1], pgr + 2, sizeof(ldbits));
avalue[i] = &temp_ld.ld; avalue[i] = &temp_ld.ld;
} }
else else
{ {
avalue[i] = pgr; avalue[i] = pgr;
} }
nf += 2; nf += 2;
ng += 4; ng += 4;
pgr += 4; pgr += 4;
break; break;
#endif #endif
default: default:
FFI_ASSERT(0); FFI_ASSERT(0);
} }
i++; i++;
} }
......
Modules/_ctypes/libffi_osx/powerpc/ppc-ffi_darwin.c
View file @ 8beaa6c2
This source diff could not be displayed because it is too large. You can view the blob instead.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7