ag/cpython-source-deps
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

alpha: Reorganize cif flags

Browse Source 
Unties the backend from changes to FFI_TYPE_* constants, and allows
compilation to succeed after the addition of FFI_TYPE_COMPLEX.

Delete the hand-written unwind info.
This commit is contained in:
Richard Henderson
2014-10-17 12:33:53 -07:00
parent c6352b664c
commit 32a26b75ba
3 changed files with 161 additions and 264 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
src/alpha/ffi.c
View File

@@ -28,6 +28,7 @@
#include <ffi.h> #include <ffi.h>
#include <ffi_common.h> #include <ffi_common.h>
#include <stdlib.h> #include <stdlib.h>
#include "internal.h"
/* Force FFI_TYPE_LONGDOUBLE to be different than FFI_TYPE_DOUBLE; /* Force FFI_TYPE_LONGDOUBLE to be different than FFI_TYPE_DOUBLE;
all further uses in this file will refer to the 128-bit type. */ all further uses in this file will refer to the 128-bit type. */
@@ -48,6 +49,8 @@ extern void ffi_closure_osf(void) FFI_HIDDEN;
ffi_status ffi_status
ffi_prep_cif_machdep(ffi_cif *cif) ffi_prep_cif_machdep(ffi_cif *cif)
{ {
int flags;
/* Adjust cif->bytes to represent a minimum 6 words for the temporary /* Adjust cif->bytes to represent a minimum 6 words for the temporary
register argument loading area. */ register argument loading area. */
if (cif->bytes < 6*FFI_SIZEOF_ARG) if (cif->bytes < 6*FFI_SIZEOF_ARG)
@@ -56,21 +59,46 @@ ffi_prep_cif_machdep(ffi_cif *cif)
/* Set the return type flag */ /* Set the return type flag */
switch (cif->rtype->type) switch (cif->rtype->type)
{ {
case FFI_TYPE_STRUCT: case FFI_TYPE_VOID:
flags = ALPHA_FLAGS(ALPHA_ST_VOID, ALPHA_LD_VOID);
break;
case FFI_TYPE_INT:
case FFI_TYPE_UINT32:
case FFI_TYPE_SINT32:
flags = ALPHA_FLAGS(ALPHA_ST_INT, ALPHA_LD_INT32);
break;
case FFI_TYPE_FLOAT: case FFI_TYPE_FLOAT:
flags = ALPHA_FLAGS(ALPHA_ST_FLOAT, ALPHA_LD_FLOAT);
break;
case FFI_TYPE_DOUBLE: case FFI_TYPE_DOUBLE:
cif->flags = cif->rtype->type; flags = ALPHA_FLAGS(ALPHA_ST_DOUBLE, ALPHA_LD_DOUBLE);
break;
case FFI_TYPE_UINT8:
flags = ALPHA_FLAGS(ALPHA_ST_INT, ALPHA_LD_UINT8);
break;
case FFI_TYPE_SINT8:
flags = ALPHA_FLAGS(ALPHA_ST_INT, ALPHA_LD_SINT8);
break;
case FFI_TYPE_UINT16:
flags = ALPHA_FLAGS(ALPHA_ST_INT, ALPHA_LD_UINT16);
break;
case FFI_TYPE_SINT16:
flags = ALPHA_FLAGS(ALPHA_ST_INT, ALPHA_LD_SINT16);
break;
case FFI_TYPE_UINT64:
case FFI_TYPE_SINT64:
case FFI_TYPE_POINTER:
flags = ALPHA_FLAGS(ALPHA_ST_INT, ALPHA_LD_INT64);
break; break;
case FFI_TYPE_LONGDOUBLE: case FFI_TYPE_LONGDOUBLE:
/* 128-bit long double is returned in memory, like a struct. */ case FFI_TYPE_STRUCT:
cif->flags = FFI_TYPE_STRUCT; /* Passed in memory, with a hidden pointer. */
flags = ALPHA_RET_IN_MEM;
break; break;
default: default:
cif->flags = FFI_TYPE_INT; abort();
break;
} }
cif->flags = flags;
return FFI_OK; return FFI_OK;
} }
@@ -80,20 +108,20 @@ void
ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue) ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
{ {
unsigned long *stack, *argp; unsigned long *stack, *argp;
long i, avn; long i, avn, flags = cif->flags;
ffi_type **arg_types; ffi_type **arg_types;
/* If the return value is a struct and we don't have a return /* If the return value is a struct and we don't have a return
value address then we need to make one. */ value address then we need to make one. */
if (rvalue == NULL && cif->flags == FFI_TYPE_STRUCT) if (rvalue == NULL && flags == ALPHA_RET_IN_MEM)
rvalue = alloca(cif->rtype->size); rvalue = alloca(cif->rtype->size);
/* Allocate the space for the arguments, plus 4 words of temp /* Allocate the space for the arguments, plus 4 words of temp
space for ffi_call_osf. */ space for ffi_call_osf. */
argp = stack = alloca(cif->bytes + 4*FFI_SIZEOF_ARG); argp = stack = alloca(cif->bytes + 4*FFI_SIZEOF_ARG);
if (cif->flags == FFI_TYPE_STRUCT) if (flags == ALPHA_RET_IN_MEM)
*(void **) argp++ = rvalue; *argp++ = (unsigned long)rvalue;
i = 0; i = 0;
avn = cif->nargs; avn = cif->nargs;
@@ -166,7 +194,8 @@ ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
i++, arg_types++, avalue++; i++, arg_types++, avalue++;
} }
ffi_call_osf(stack, cif->bytes, cif->flags, rvalue, fn); flags = (flags >> ALPHA_ST_SHIFT) & 0xff;
ffi_call_osf(stack, cif->bytes, flags, rvalue, fn);
} }
@@ -211,16 +240,16 @@ ffi_closure_osf_inner(ffi_closure *closure, void *rvalue, unsigned long *argp)
ffi_cif *cif; ffi_cif *cif;
void **avalue; void **avalue;
ffi_type **arg_types; ffi_type **arg_types;
long i, avn, argn; long i, avn, argn, flags;
cif = closure->cif; cif = closure->cif;
avalue = alloca(cif->nargs * sizeof(void *)); avalue = alloca(cif->nargs * sizeof(void *));
flags = cif->flags;
argn = 0; argn = 0;
/* Copy the caller's structure return address to that the closure /* Copy the caller's structure return address to that the closure
returns the data directly to the caller. */ returns the data directly to the caller. */
if (cif->flags == FFI_TYPE_STRUCT) if (flags == ALPHA_RET_IN_MEM)
{ {
rvalue = (void *) argp[0]; rvalue = (void *) argp[0];
argn = 1; argn = 1;
@@ -284,5 +313,5 @@ ffi_closure_osf_inner(ffi_closure *closure, void *rvalue, unsigned long *argp)
closure->fun (cif, rvalue, avalue, closure->user_data); closure->fun (cif, rvalue, avalue, closure->user_data);
/* Tell ffi_closure_osf how to perform return type promotions. */ /* Tell ffi_closure_osf how to perform return type promotions. */
return cif->rtype->type; return (flags >> ALPHA_LD_SHIFT) & 0xff;
} }

19
src/alpha/internal.h Normal file
View File

@@ -0,0 +1,19 @@
#define ALPHA_ST_VOID 0
#define ALPHA_ST_INT 1
#define ALPHA_ST_FLOAT 2
#define ALPHA_ST_DOUBLE 3
#define ALPHA_LD_VOID 0
#define ALPHA_LD_INT64 1
#define ALPHA_LD_INT32 2
#define ALPHA_LD_UINT16 3
#define ALPHA_LD_SINT16 4
#define ALPHA_LD_UINT8 5
#define ALPHA_LD_SINT8 6
#define ALPHA_LD_FLOAT 7
#define ALPHA_LD_DOUBLE 8
#define ALPHA_ST_SHIFT 0
#define ALPHA_LD_SHIFT 8
#define ALPHA_RET_IN_MEM 0x10000
#define ALPHA_FLAGS(S, L) (((L) << ALPHA_LD_SHIFT) | (S))

337
src/alpha/osf.S
View File

@@ -1,5 +1,5 @@
/* ----------------------------------------------------------------------- /* -----------------------------------------------------------------------
osf.S - Copyright (c) 1998, 2001, 2007, 2008, 2011 Red Hat osf.S - Copyright (c) 1998, 2001, 2007, 2008, 2011, 2014 Red Hat
Alpha/OSF Foreign Function Interface Alpha/OSF Foreign Function Interface
@@ -27,10 +27,18 @@
#define LIBFFI_ASM #define LIBFFI_ASM
#include <fficonfig.h> #include <fficonfig.h>
#include <ffi.h> #include <ffi.h>
#include <ffi_cfi.h>
#include "internal.h"
.arch ev6 .arch ev6
.text .text
/* Aid in building a direct addressed jump table, 4 insns per entry. */
.macro E index
.align 4
.org 99b + \index * 16
.endm
/* ffi_call_osf (void *args, unsigned long bytes, unsigned flags, /* ffi_call_osf (void *args, unsigned long bytes, unsigned flags,
void *raddr, void (*fnaddr)(void)); void *raddr, void (*fnaddr)(void));
@@ -38,7 +46,7 @@
for this function. This has been allocated by ffi_call. We also for this function. This has been allocated by ffi_call. We also
deallocate some of the stack that has been alloca'd. */ deallocate some of the stack that has been alloca'd. */
.align 3 .align 4
.globl ffi_call_osf .globl ffi_call_osf
.ent ffi_call_osf .ent ffi_call_osf
FFI_HIDDEN(ffi_call_osf) FFI_HIDDEN(ffi_call_osf)
@@ -46,15 +54,17 @@
ffi_call_osf: ffi_call_osf:
.frame $15, 32, $26, 0 .frame $15, 32, $26, 0
.mask 0x4008000, -32 .mask 0x4008000, -32
$LFB1: cfi_startproc
addq $16,$17,$1 addq $16,$17,$1
mov $16, $30 mov $16, $30
stq $26, 0($1) stq $26, 0($1)
stq $15, 8($1) stq $15, 8($1)
stq $18, 16($1) stq $18, 16($1)
mov $1, $15 mov $1, $15
$LCFI1:
.prologue 0 .prologue 0
cfi_def_cfa($15, 32)
cfi_rel_offset($26, 0)
cfi_rel_offset($15, 8)
stq $19, 24($1) stq $19, 24($1)
mov $20, $27 mov $20, $27
@@ -77,71 +87,61 @@ $LCFI1:
lda $30, 48($30) lda $30, 48($30)
jsr $26, ($27), 0 jsr $26, ($27), 0
ldgp $29, 0($26) 0:
ldah $29, 0($26) !gpdisp!1
# If the return value pointer is NULL, assume no return value. ldq $2, 24($15)
ldq $19, 24($15) lda $29, 0($29) !gpdisp!1
ldq $18, 16($15) ldq $3, 16($15)
lda $1, 99f-0b($26)
ldq $26, 0($15) ldq $26, 0($15)
$LCFI2:
beq $19, $noretval
# Store the return value out in the proper type.
cmpeq $18, FFI_TYPE_INT, $1
bne $1, $retint
cmpeq $18, FFI_TYPE_FLOAT, $2
bne $2, $retfloat
cmpeq $18, FFI_TYPE_DOUBLE, $3
bne $3, $retdouble
.align 3
$noretval:
ldq $15, 8($15) ldq $15, 8($15)
ret cfi_restore($26)
cfi_restore($15)
cfi_def_cfa($sp, 0)
cmoveq $2, ALPHA_ST_VOID, $3 # mash null return to void
addq $3, $3, $3
s8addq $3, $1, $1 # 99f + stcode * 16
jmp $31, ($1), $st_int
.align 4 .align 4
$retint: 99:
stq $0, 0($19) E ALPHA_ST_VOID
nop ret
ldq $15, 8($15) E ALPHA_ST_INT
$st_int:
stq $0, 0($2)
ret
E ALPHA_ST_FLOAT
sts $f0, 0($2)
ret
E ALPHA_ST_DOUBLE
stt $f0, 0($2)
ret ret
.align 4 cfi_endproc
$retfloat:
sts $f0, 0($19)
nop
ldq $15, 8($15)
ret
.align 4
$retdouble:
stt $f0, 0($19)
nop
ldq $15, 8($15)
ret
$LFE1:
.end ffi_call_osf .end ffi_call_osf
/* ffi_closure_osf(...) /* ffi_closure_osf(...)
Receives the closure argument in $1. */ Receives the closure argument in $1. */
.align 3 #define CLOSURE_FS (16*8)
.align 4
.globl ffi_closure_osf .globl ffi_closure_osf
.ent ffi_closure_osf .ent ffi_closure_osf
FFI_HIDDEN(ffi_closure_osf) FFI_HIDDEN(ffi_closure_osf)
ffi_closure_osf: ffi_closure_osf:
.frame $30, 16*8, $26, 0 .frame $30, CLOSURE_FS, $26, 0
.mask 0x4000000, -16*8 .mask 0x4000000, -CLOSURE_FS
$LFB2: cfi_startproc
ldgp $29, 0($27) ldgp $29, 0($27)
subq $30, 16*8, $30 subq $30, CLOSURE_FS, $30
$LCFI5: cfi_adjust_cfa_offset(CLOSURE_FS)
stq $26, 0($30) stq $26, 0($30)
$LCFI6:
.prologue 1 .prologue 1
cfi_rel_offset($26, 0)
# Store all of the potential argument registers in va_list format. # Store all of the potential argument registers in va_list format.
stt $f16, 4*8($30) stt $f16, 4*8($30)
@@ -162,225 +162,74 @@ $LCFI6:
lda $17, 2*8($30) lda $17, 2*8($30)
lda $18, 10*8($30) lda $18, 10*8($30)
jsr $26, ffi_closure_osf_inner jsr $26, ffi_closure_osf_inner
ldgp $29, 0($26) 0:
ldah $29, 0($26) !gpdisp!2
lda $2, 99f-0b($26)
s4addq $0, 0, $1 # ldcode * 4
ldq $0, 16($30) # preload return value
s4addq $1, $2, $1 # 99f + ldcode * 16
lda $29, 0($29) !gpdisp!2
ldq $26, 0($30) ldq $26, 0($30)
cfi_restore($26)
# Load up the return value in the proper type.
lda $1, $load_table
s4addq $0, $1, $1
ldl $1, 0($1)
addq $1, $29, $1
jmp $31, ($1), $load_32 jmp $31, ($1), $load_32
.align 4 .macro epilogue
$load_none: addq $30, CLOSURE_FS, $30
addq $30, 16*8, $30 cfi_adjust_cfa_offset(-CLOSURE_FS)
ret ret
.align 4
cfi_adjust_cfa_offset(CLOSURE_FS)
.endm
.align 4 .align 4
$load_float: 99:
lds $f0, 16($30) E ALPHA_LD_VOID
nop epilogue
addq $30, 16*8, $30
ret
.align 4 E ALPHA_LD_INT64
$load_double: epilogue
ldt $f0, 16($30)
nop
addq $30, 16*8, $30
ret
.align 4 E ALPHA_LD_INT32
$load_u8: $load_32:
#ifdef __alpha_bwx__ sextl $0, $0
ldbu $0, 16($30) epilogue
nop
#else
ldq $0, 16($30)
and $0, 255, $0
#endif
addq $30, 16*8, $30
ret
.align 4 E ALPHA_LD_UINT16
$load_s8:
#ifdef __alpha_bwx__
ldbu $0, 16($30)
sextb $0, $0
#else
ldq $0, 16($30)
sll $0, 56, $0
sra $0, 56, $0
#endif
addq $30, 16*8, $30
ret
.align 4
$load_u16:
#ifdef __alpha_bwx__
ldwu $0, 16($30)
nop
#else
ldq $0, 16($30)
zapnot $0, 3, $0 zapnot $0, 3, $0
#endif epilogue
addq $30, 16*8, $30
ret
.align 4 E ALPHA_LD_SINT16
$load_s16:
#ifdef __alpha_bwx__ #ifdef __alpha_bwx__
ldwu $0, 16($30)
sextw $0, $0 sextw $0, $0
#else #else
ldq $0, 16($30)
sll $0, 48, $0 sll $0, 48, $0
sra $0, 48, $0 sra $0, 48, $0
#endif #endif
addq $30, 16*8, $30 epilogue
ret
.align 4 E ALPHA_LD_UINT8
$load_32: and $0, 0xff, $0
ldl $0, 16($30) epilogue
nop
addq $30, 16*8, $30
ret
.align 4 E ALPHA_LD_SINT8
$load_64: #ifdef __alpha_bwx__
ldq $0, 16($30) sextb $0, $0
nop
addq $30, 16*8, $30
ret
$LFE2:
.end ffi_closure_osf
#ifdef __ELF__
.section .rodata
#else #else
.rdata sll $0, 56, $0
sra $0, 56, $0
#endif #endif
$load_table: epilogue
.gprel32 $load_none # FFI_TYPE_VOID
.gprel32 $load_32 # FFI_TYPE_INT
.gprel32 $load_float # FFI_TYPE_FLOAT
.gprel32 $load_double # FFI_TYPE_DOUBLE
.gprel32 $load_none # FFI_TYPE_LONGDOUBLE
.gprel32 $load_u8 # FFI_TYPE_UINT8
.gprel32 $load_s8 # FFI_TYPE_SINT8
.gprel32 $load_u16 # FFI_TYPE_UINT16
.gprel32 $load_s16 # FFI_TYPE_SINT16
.gprel32 $load_32 # FFI_TYPE_UINT32
.gprel32 $load_32 # FFI_TYPE_SINT32
.gprel32 $load_64 # FFI_TYPE_UINT64
.gprel32 $load_64 # FFI_TYPE_SINT64
.gprel32 $load_none # FFI_TYPE_STRUCT
.gprel32 $load_64 # FFI_TYPE_POINTER
/* Assert that the table above is in sync with ffi.h. */ E ALPHA_LD_FLOAT
lds $f0, 16($sp)
epilogue
#if FFI_TYPE_FLOAT != 2 \ E ALPHA_LD_DOUBLE
|| FFI_TYPE_DOUBLE != 3 \ ldt $f0, 16($sp)
|| FFI_TYPE_UINT8 != 5 \ epilogue
|| FFI_TYPE_SINT8 != 6 \
|| FFI_TYPE_UINT16 != 7 \
|| FFI_TYPE_SINT16 != 8 \
|| FFI_TYPE_UINT32 != 9 \
|| FFI_TYPE_SINT32 != 10 \
|| FFI_TYPE_UINT64 != 11 \
|| FFI_TYPE_SINT64 != 12 \
|| FFI_TYPE_STRUCT != 13 \
|| FFI_TYPE_POINTER != 14 \
|| FFI_TYPE_LAST != 14
#error "osf.S out of sync with ffi.h"
#endif
#ifdef __ELF__ cfi_endproc
# define UA_SI .4byte .end ffi_closure_osf
# define FDE_ENCODING 0x1b /* pcrel sdata4 */
# define FDE_ENCODE(X) .4byte X-.
# define FDE_ARANGE(X) .4byte X
#elif defined __osf__
# define UA_SI .align 0; .long
# define FDE_ENCODING 0x50 /* aligned absolute */
# define FDE_ENCODE(X) .align 3; .quad X
# define FDE_ARANGE(X) .align 0; .quad X
#endif
#ifdef __ELF__
.section .eh_frame,EH_FRAME_FLAGS,@progbits
#elif defined __osf__
.data
.align 3
.globl _GLOBAL__F_ffi_call_osf
_GLOBAL__F_ffi_call_osf:
#endif
__FRAME_BEGIN__:
UA_SI $LECIE1-$LSCIE1 # Length of Common Information Entry
$LSCIE1:
UA_SI 0x0 # CIE Identifier Tag
.byte 0x1 # CIE Version
.ascii "zR\0" # CIE Augmentation
.byte 0x1 # uleb128 0x1; CIE Code Alignment Factor
.byte 0x78 # sleb128 -8; CIE Data Alignment Factor
.byte 26 # CIE RA Column
.byte 0x1 # uleb128 0x1; Augmentation size
.byte FDE_ENCODING # FDE Encoding
.byte 0xc # DW_CFA_def_cfa
.byte 30 # uleb128 column 30
.byte 0 # uleb128 offset 0
.align 3
$LECIE1:
$LSFDE1:
UA_SI $LEFDE1-$LASFDE1 # FDE Length
$LASFDE1:
UA_SI $LASFDE1-__FRAME_BEGIN__ # FDE CIE offset
FDE_ENCODE($LFB1) # FDE initial location
FDE_ARANGE($LFE1-$LFB1) # FDE address range
.byte 0x0 # uleb128 0x0; Augmentation size
.byte 0x4 # DW_CFA_advance_loc4
UA_SI $LCFI1-$LFB1
.byte 0x9a # DW_CFA_offset, column 26
.byte 4 # uleb128 4*-8
.byte 0x8f # DW_CFA_offset, column 15
.byte 0x3 # uleb128 3*-8
.byte 0xc # DW_CFA_def_cfa
.byte 15 # uleb128 column 15
.byte 32 # uleb128 offset 32
.byte 0x4 # DW_CFA_advance_loc4
UA_SI $LCFI2-$LCFI1
.byte 0xda # DW_CFA_restore, column 26
.align 3
$LEFDE1:
$LSFDE3:
UA_SI $LEFDE3-$LASFDE3 # FDE Length
$LASFDE3:
UA_SI $LASFDE3-__FRAME_BEGIN__ # FDE CIE offset
FDE_ENCODE($LFB2) # FDE initial location
FDE_ARANGE($LFE2-$LFB2) # FDE address range
.byte 0x0 # uleb128 0x0; Augmentation size
.byte 0x4 # DW_CFA_advance_loc4
UA_SI $LCFI5-$LFB2
.byte 0xe # DW_CFA_def_cfa_offset
.byte 0x80,0x1 # uleb128 128
.byte 0x4 # DW_CFA_advance_loc4
UA_SI $LCFI6-$LCFI5
.byte 0x9a # DW_CFA_offset, column 26
.byte 16 # uleb128 offset 16*-8
.align 3
$LEFDE3:
#if defined __osf__
.align 0
.long 0 # End of Table
#endif
#if defined __ELF__ && defined __linux__ #if defined __ELF__ && defined __linux__
.section .note.GNU-stack,"",@progbits .section .note.GNU-stack,"",@progbits