andrius
/
tinycc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

be stricter with aliasing 

Refactoring (no logical changes):
- use memcpy in tccgen.c:ieee_finite(double d)
- use union to store attribute flags in Sym
Makefile: "CFLAGS+=-fno-strict-aliasing" basically not necessary
anymore but I left it for now because gcc sometimes behaves
unexpectedly without.

Also:
- configure: back to mode 100755
- tcc.h: remove unused variables tdata/tbss_section
- x86_64-gen.c: adjust gfunc_sret for prototype
This commit is contained in:
grischka 2014-01-07 14:57:07 +01:00
parent 2bd0daabbe
commit 3fe2a95d7f
6 changed files with 92 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
configure vendored Normal file → Executable file
View File

4
i386-gen.c
View File

@ -457,7 +457,7 @@ ST_FUNC void gfunc_call(int nb_args)
}
save_regs(0); /* save used temporary registers */
func_sym = vtop->type.ref;
func_call = FUNC_CALL(func_sym->r);
func_call = func_sym->a.func_call;
/* fast call case */
if ((func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) ||
func_call == FUNC_FASTCALLW) {
@ -505,7 +505,7 @@ ST_FUNC void gfunc_prolog(CType *func_type)
CType *type;
sym = func_type->ref;
func_call = FUNC_CALL(sym->r);
func_call = sym->a.func_call;
addr = 8;
loc = 0;
func_vc = 0;

8
libtcc.c
View File

@ -493,11 +493,11 @@ ST_FUNC void put_extern_sym2(Sym *sym, Section *section,
if (sym->type.t & VT_EXPORT)
other |= 1;
if (sym_type == STT_FUNC && sym->type.ref) {
int attr = sym->type.ref->r;
if (FUNC_EXPORT(attr))
Sym *ref = sym->type.ref;
if (ref->a.func_export)
other |= 1;
if (FUNC_CALL(attr) == FUNC_STDCALL && can_add_underscore) {
sprintf(buf1, "_%s@%d", name, FUNC_ARGS(attr) * PTR_SIZE);
if (ref->a.func_call == FUNC_STDCALL && can_add_underscore) {
sprintf(buf1, "_%s@%d", name, ref->a.func_args * PTR_SIZE);
name = buf1;
other |= 2;
can_add_underscore = 0;

57
tcc.h
View File

@ -326,11 +326,35 @@ typedef struct SValue {
struct Sym *sym; /* symbol, if (VT_SYM | VT_CONST) */
} SValue;
struct Attribute {
unsigned
func_call : 3, /* calling convention (0..5), see below */
aligned : 5, /* alignement (0..16) */
packed : 1,
func_export : 1,
func_import : 1,
func_args : 5,
func_proto : 1,
mode : 4,
weak : 1,
fill : 10; // 10 bits left to fit well in union below
};
/* GNUC attribute definition */
typedef struct AttributeDef {
struct Attribute a;
struct Section *section;
int alias_target; /* token */
} AttributeDef;
/* symbol management */
typedef struct Sym {
int v; /* symbol token */
char *asm_label; /* associated asm label */
long r; /* associated register */
union {
long r; /* associated register */
struct Attribute a;
};
union {
long c; /* associated number */
int *d; /* define token stream */
@ -381,34 +405,6 @@ typedef struct DLLReference {
char name[1];
} DLLReference;
/* GNUC attribute definition */
typedef struct AttributeDef {
unsigned
func_call : 3, /* calling convention (0..5), see below */
aligned : 5, /* alignement (0..16) */
packed : 1,
func_export : 1,
func_import : 1,
func_args : 5,
func_proto : 1,
mode : 4,
weak : 1,
fill : 10;
struct Section *section;
int alias_target; /* token */
} AttributeDef;
/* gr: wrappers for casting sym->r for other purposes */
#define FUNC_CALL(r) (((AttributeDef*)&(r))->func_call)
#define FUNC_EXPORT(r) (((AttributeDef*)&(r))->func_export)
#define FUNC_IMPORT(r) (((AttributeDef*)&(r))->func_import)
#define FUNC_ARGS(r) (((AttributeDef*)&(r))->func_args)
#define FUNC_PROTO(r) (((AttributeDef*)&(r))->func_proto)
#define FUNC_ALIGN(r) (((AttributeDef*)&(r))->aligned)
#define FUNC_PACKED(r) (((AttributeDef*)&(r))->packed)
#define ATTR_MODE(r) (((AttributeDef*)&(r))->mode)
#define INT_ATTR(ad) (*(int*)(ad))
/* -------------------------------------------------- */
#define SYM_STRUCT 0x40000000 /* struct/union/enum symbol space */
@ -1142,7 +1138,6 @@ ST_FUNC void expect(const char *msg);
/* ------------ tccgen.c ------------ */
ST_DATA Section *text_section, *data_section, *bss_section; /* predefined sections */
ST_DATA Section *tdata_section, *tbss_section; /* thread-local storage sections */
ST_DATA Section *cur_text_section; /* current section where function code is generated */
#ifdef CONFIG_TCC_ASM
ST_DATA Section *last_text_section; /* to handle .previous asm directive */
@ -1268,7 +1263,7 @@ ST_FUNC void build_got_entries(TCCState *s1);
ST_FUNC void tcc_add_runtime(TCCState *s1);
ST_FUNC addr_t get_elf_sym_addr(TCCState *s, const char *name, int err);
#ifdef TCC_IS_NATIVE
#if defined TCC_IS_NATIVE || defined TCC_TARGET_PE
ST_FUNC void *tcc_get_symbol_err(TCCState *s, const char *name);
#endif

97
tccgen.c
View File

@ -103,7 +103,8 @@ ST_INLN int is_float(int t)
/* XXX: endianness dependent */
ST_FUNC int ieee_finite(double d)
{
int *p = (int *)&d;
int p[4];
memcpy(p, &d, sizeof(double));
return ((unsigned)((p[1] | 0x800fffff) + 1)) >> 31;
}
@ -2172,7 +2173,7 @@ static int is_compatible_func(CType *type1, CType *type2)
if (!is_compatible_types(&s1->type, &s2->type))
return 0;
/* check func_call */
if (FUNC_CALL(s1->r) != FUNC_CALL(s2->r))
if (s1->a.func_call != s2->a.func_call)
return 0;
/* XXX: not complete */
if (s1->c == FUNC_OLD || s2->c == FUNC_OLD)
@ -2659,15 +2660,15 @@ static void parse_attribute(AttributeDef *ad)
} else {
n = MAX_ALIGN;
}
ad->aligned = n;
ad->a.aligned = n;
break;
case TOK_PACKED1:
case TOK_PACKED2:
ad->packed = 1;
ad->a.packed = 1;
break;
case TOK_WEAK1:
case TOK_WEAK2:
ad->weak = 1;
ad->a.weak = 1;
break;
case TOK_UNUSED1:
case TOK_UNUSED2:
@ -2682,12 +2683,12 @@ static void parse_attribute(AttributeDef *ad)
case TOK_CDECL1:
case TOK_CDECL2:
case TOK_CDECL3:
ad->func_call = FUNC_CDECL;
ad->a.func_call = FUNC_CDECL;
break;
case TOK_STDCALL1:
case TOK_STDCALL2:
case TOK_STDCALL3:
ad->func_call = FUNC_STDCALL;
ad->a.func_call = FUNC_STDCALL;
break;
#ifdef TCC_TARGET_I386
case TOK_REGPARM1:
@ -2699,26 +2700,26 @@ static void parse_attribute(AttributeDef *ad)
else if (n < 0)
n = 0;
if (n > 0)
ad->func_call = FUNC_FASTCALL1 + n - 1;
ad->a.func_call = FUNC_FASTCALL1 + n - 1;
skip(')');
break;
case TOK_FASTCALL1:
case TOK_FASTCALL2:
case TOK_FASTCALL3:
ad->func_call = FUNC_FASTCALLW;
ad->a.func_call = FUNC_FASTCALLW;
break;
#endif
case TOK_MODE:
skip('(');
switch(tok) {
case TOK_MODE_DI:
ad->mode = VT_LLONG + 1;
ad->a.mode = VT_LLONG + 1;
break;
case TOK_MODE_HI:
ad->mode = VT_SHORT + 1;
ad->a.mode = VT_SHORT + 1;
break;
case TOK_MODE_SI:
ad->mode = VT_INT + 1;
ad->a.mode = VT_INT + 1;
break;
default:
tcc_warning("__mode__(%s) not supported\n", get_tok_str(tok, NULL));
@ -2728,10 +2729,10 @@ static void parse_attribute(AttributeDef *ad)
skip(')');
break;
case TOK_DLLEXPORT:
ad->func_export = 1;
ad->a.func_export = 1;
break;
case TOK_DLLIMPORT:
ad->func_import = 1;
ad->a.func_import = 1;
break;
default:
if (tcc_state->warn_unsupported)
@ -2873,10 +2874,10 @@ static void struct_decl(CType *type, int u, int tdef)
get_tok_str(v, NULL));
}
size = type_size(&type1, &align);
if (ad.aligned) {
if (align < ad.aligned)
align = ad.aligned;
} else if (ad.packed) {
if (ad.a.aligned) {
if (align < ad.a.aligned)
align = ad.a.aligned;
} else if (ad.a.packed) {
align = 1;
} else if (*tcc_state->pack_stack_ptr) {
if (align > *tcc_state->pack_stack_ptr)
@ -3118,8 +3119,8 @@ static int parse_btype(CType *type, AttributeDef *ad)
case TOK_ATTRIBUTE1:
case TOK_ATTRIBUTE2:
parse_attribute(ad);
if (ad->mode) {
u = ad->mode -1;
if (ad->a.mode) {
u = ad->a.mode -1;
t = (t & ~VT_BTYPE) | u;
}
break;
@ -3143,11 +3144,11 @@ static int parse_btype(CType *type, AttributeDef *ad)
type->ref = s->type.ref;
if (s->r) {
/* get attributes from typedef */
if (0 == ad->aligned)
ad->aligned = FUNC_ALIGN(s->r);
if (0 == ad->func_call)
ad->func_call = FUNC_CALL(s->r);
ad->packed |= FUNC_PACKED(s->r);
if (0 == ad->a.aligned)
ad->a.aligned = s->a.aligned;
if (0 == ad->a.func_call)
ad->a.func_call = s->a.func_call;
ad->a.packed |= s->a.packed;
}
next();
typespec_found = 1;
@ -3287,8 +3288,9 @@ static void post_type(CType *type, AttributeDef *ad)
type->t |= VT_PTR;
}
/* we push a anonymous symbol which will contain the function prototype */
ad->func_args = arg_size;
s = sym_push(SYM_FIELD, type, INT_ATTR(ad), l);
ad->a.func_args = arg_size;
s = sym_push(SYM_FIELD, type, 0, l);
s->a = ad->a;
s->next = first;
type->t = VT_FUNC;
type->ref = s;
@ -5484,10 +5486,10 @@ static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
if (flexible_array)
size += flexible_array->type.ref->c * pointed_size(&flexible_array->type);
/* take into account specified alignment if bigger */
if (ad->aligned) {
if (ad->aligned > align)
align = ad->aligned;
} else if (ad->packed) {
if (ad->a.aligned) {
if (ad->a.aligned > align)
align = ad->a.aligned;
} else if (ad->a.packed) {
align = 1;
}
if ((r & VT_VALMASK) == VT_LOCAL) {
@ -5869,12 +5871,12 @@ static int decl0(int l, int is_for_loop_init)
parse_attribute(&ad);
}
if (ad.weak)
if (ad.a.weak)
type.t |= VT_WEAK;
#ifdef TCC_TARGET_PE
if (ad.func_import)
if (ad.a.func_import)
type.t |= VT_IMPORT;
if (ad.func_export)
if (ad.a.func_export)
type.t |= VT_EXPORT;
#endif
if (tok == '{') {
@ -5895,22 +5897,22 @@ static int decl0(int l, int is_for_loop_init)
sym = sym_find(v);
if (sym) {
Sym *ref;
if ((sym->type.t & VT_BTYPE) != VT_FUNC)
goto func_error1;
r = sym->type.ref->r;
if (!FUNC_PROTO(r))
ref = sym->type.ref;
if (0 == ref->a.func_proto)
tcc_error("redefinition of '%s'", get_tok_str(v, NULL));
/* use func_call from prototype if not defined */
if (FUNC_CALL(r) != FUNC_CDECL
&& FUNC_CALL(type.ref->r) == FUNC_CDECL)
FUNC_CALL(type.ref->r) = FUNC_CALL(r);
if (ref->a.func_call != FUNC_CDECL
&& type.ref->a.func_call == FUNC_CDECL)
type.ref->a.func_call = ref->a.func_call;
/* use export from prototype */
if (FUNC_EXPORT(r))
FUNC_EXPORT(type.ref->r) = 1;
if (ref->a.func_export)
type.ref->a.func_export = 1;
/* use static from prototype */
if (sym->type.t & VT_STATIC)
@ -5921,7 +5923,7 @@ static int decl0(int l, int is_for_loop_init)
tcc_error("incompatible types for redefinition of '%s'",
get_tok_str(v, NULL));
}
FUNC_PROTO(type.ref->r) = 0;
type.ref->a.func_proto = 0;
/* if symbol is already defined, then put complete type */
sym->type = type;
} else {
@ -5980,15 +5982,16 @@ static int decl0(int l, int is_for_loop_init)
if (btype.t & VT_TYPEDEF) {
/* save typedefed type */
/* XXX: test storage specifiers ? */
sym = sym_push(v, &type, INT_ATTR(&ad), 0);
sym = sym_push(v, &type, 0, 0);
sym->a = ad.a;
sym->type.t |= VT_TYPEDEF;
} else {
r = 0;
if ((type.t & VT_BTYPE) == VT_FUNC) {
/* external function definition */
/* specific case for func_call attribute */
ad.func_proto = 1;
type.ref->r = INT_ATTR(&ad);
ad.a.func_proto = 1;
type.ref->a = ad.a;
} else if (!(type.t & VT_ARRAY)) {
/* not lvalue if array */
r |= lvalue_type(type.t);
@ -6039,7 +6042,7 @@ static int decl0(int l, int is_for_loop_init)
}
next();
}
ad.aligned = 0;
ad.a.aligned = 0;
}
}
return 0;

15
x86_64-gen.c
View File

@ -933,7 +933,8 @@ typedef enum X86_64_Mode {
x86_64_mode_x87
} X86_64_Mode;
static X86_64_Mode classify_x86_64_merge(X86_64_Mode a, X86_64_Mode b) {
static X86_64_Mode classify_x86_64_merge(X86_64_Mode a, X86_64_Mode b)
{
if (a == b)
return a;
else if (a == x86_64_mode_none)
@ -950,7 +951,8 @@ static X86_64_Mode classify_x86_64_merge(X86_64_Mode a, X86_64_Mode b) {
return x86_64_mode_sse;
}
static X86_64_Mode classify_x86_64_inner(CType *ty) {
static X86_64_Mode classify_x86_64_inner(CType *ty)
{
X86_64_Mode mode;
Sym *f;
@ -988,7 +990,8 @@ static X86_64_Mode classify_x86_64_inner(CType *ty) {
assert(0);
}
static X86_64_Mode classify_x86_64_arg(CType *ty, CType *ret, int *psize, int *palign, int *reg_count) {
static X86_64_Mode classify_x86_64_arg(CType *ty, CType *ret, int *psize, int *palign, int *reg_count)
{
X86_64_Mode mode;
int size, align, ret_t = 0;
@ -1045,7 +1048,8 @@ static X86_64_Mode classify_x86_64_arg(CType *ty, CType *ret, int *psize, int *p
return mode;
}
ST_FUNC int classify_x86_64_va_arg(CType *ty) {
ST_FUNC int classify_x86_64_va_arg(CType *ty)
{
/* This definition must be synced with stdarg.h */
enum __va_arg_type {
__va_gen_reg, __va_float_reg, __va_stack
@ -1061,7 +1065,8 @@ ST_FUNC int classify_x86_64_va_arg(CType *ty) {
/* Return the number of registers needed to return the struct, or 0 if
returning via struct pointer. */
int gfunc_sret(CType *vt, CType *ret, int *ret_align) {
ST_FUNC int gfunc_sret(CType *vt, int variadic, CType *ret, int *ret_align)
{
int size, align, reg_count;
*ret_align = 1; // Never have to re-align return values for x86-64
return (classify_x86_64_arg(vt, ret, &size, &align, &reg_count) != x86_64_mode_memory);