0,0 → 1,6500 |
/* |
* TCC - Tiny C Compiler |
* |
* Copyright (c) 2001-2004 Fabrice Bellard |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
*/ |
|
#include "tcc.h" |
|
/********************************************************/ |
/* global variables */ |
|
/* loc : local variable index |
ind : output code index |
rsym: return symbol |
anon_sym: anonymous symbol index |
*/ |
ST_DATA int rsym, anon_sym, ind, loc; |
|
ST_DATA Section *text_section, *data_section, *bss_section; /* predefined 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 */ |
#endif |
#ifdef CONFIG_TCC_BCHECK |
/* bound check related sections */ |
ST_DATA Section *bounds_section; /* contains global data bound description */ |
ST_DATA Section *lbounds_section; /* contains local data bound description */ |
#endif |
/* symbol sections */ |
ST_DATA Section *symtab_section, *strtab_section; |
/* debug sections */ |
ST_DATA Section *stab_section, *stabstr_section; |
ST_DATA Sym *sym_free_first; |
ST_DATA void **sym_pools; |
ST_DATA int nb_sym_pools; |
|
ST_DATA Sym *global_stack; |
ST_DATA Sym *local_stack; |
ST_DATA Sym *scope_stack_bottom; |
ST_DATA Sym *define_stack; |
ST_DATA Sym *global_label_stack; |
ST_DATA Sym *local_label_stack; |
|
ST_DATA int vlas_in_scope; /* number of VLAs that are currently in scope */ |
ST_DATA int vla_sp_root_loc; /* vla_sp_loc for SP before any VLAs were pushed */ |
ST_DATA int vla_sp_loc; /* Pointer to variable holding location to store stack pointer on the stack when modifying stack pointer */ |
|
ST_DATA SValue __vstack[1+VSTACK_SIZE], *vtop, *pvtop; |
|
ST_DATA int const_wanted; /* true if constant wanted */ |
ST_DATA int nocode_wanted; /* true if no code generation wanted for an expression */ |
ST_DATA int global_expr; /* true if compound literals must be allocated globally (used during initializers parsing */ |
ST_DATA CType func_vt; /* current function return type (used by return instruction) */ |
ST_DATA int func_var; /* true if current function is variadic (used by return instruction) */ |
ST_DATA int func_vc; |
ST_DATA int last_line_num, last_ind, func_ind; /* debug last line number and pc */ |
ST_DATA const char *funcname; |
|
ST_DATA CType char_pointer_type, func_old_type, int_type, size_type; |
|
/* ------------------------------------------------------------------------- */ |
static void gen_cast(CType *type); |
static inline CType *pointed_type(CType *type); |
static int is_compatible_types(CType *type1, CType *type2); |
static int parse_btype(CType *type, AttributeDef *ad); |
static void type_decl(CType *type, AttributeDef *ad, int *v, int td); |
static void parse_expr_type(CType *type); |
static void decl_initializer(CType *type, Section *sec, unsigned long c, int first, int size_only); |
static void block(int *bsym, int *csym, int *case_sym, int *def_sym, int case_reg, int is_expr); |
static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, int has_init, int v, int scope); |
static int decl0(int l, int is_for_loop_init); |
static void expr_eq(void); |
static void expr_lor_const(void); |
static void unary_type(CType *type); |
static void vla_runtime_type_size(CType *type, int *a); |
static void vla_sp_restore(void); |
static void vla_sp_restore_root(void); |
static int is_compatible_parameter_types(CType *type1, CType *type2); |
static void expr_type(CType *type); |
ST_FUNC void vpush64(int ty, unsigned long long v); |
ST_FUNC void vpush(CType *type); |
ST_FUNC int gvtst(int inv, int t); |
ST_FUNC int is_btype_size(int bt); |
|
ST_INLN int is_float(int t) |
{ |
int bt; |
bt = t & VT_BTYPE; |
return bt == VT_LDOUBLE || bt == VT_DOUBLE || bt == VT_FLOAT || bt == VT_QFLOAT; |
} |
|
/* we use our own 'finite' function to avoid potential problems with |
non standard math libs */ |
/* XXX: endianness dependent */ |
ST_FUNC int ieee_finite(double d) |
{ |
int p[4]; |
memcpy(p, &d, sizeof(double)); |
return ((unsigned)((p[1] | 0x800fffff) + 1)) >> 31; |
} |
|
ST_FUNC void test_lvalue(void) |
{ |
if (!(vtop->r & VT_LVAL)) |
expect("lvalue"); |
} |
|
ST_FUNC void check_vstack(void) |
{ |
if (pvtop != vtop) |
tcc_error("internal compiler error: vstack leak (%d)", vtop - pvtop); |
} |
|
/* ------------------------------------------------------------------------- */ |
/* symbol allocator */ |
static Sym *__sym_malloc(void) |
{ |
Sym *sym_pool, *sym, *last_sym; |
int i; |
|
sym_pool = tcc_malloc(SYM_POOL_NB * sizeof(Sym)); |
dynarray_add(&sym_pools, &nb_sym_pools, sym_pool); |
|
last_sym = sym_free_first; |
sym = sym_pool; |
for(i = 0; i < SYM_POOL_NB; i++) { |
sym->next = last_sym; |
last_sym = sym; |
sym++; |
} |
sym_free_first = last_sym; |
return last_sym; |
} |
|
static inline Sym *sym_malloc(void) |
{ |
Sym *sym; |
sym = sym_free_first; |
if (!sym) |
sym = __sym_malloc(); |
sym_free_first = sym->next; |
return sym; |
} |
|
ST_INLN void sym_free(Sym *sym) |
{ |
sym->next = sym_free_first; |
sym_free_first = sym; |
} |
|
/* push, without hashing */ |
ST_FUNC Sym *sym_push2(Sym **ps, int v, int t, long c) |
{ |
Sym *s; |
if (ps == &local_stack) { |
for (s = *ps; s && s != scope_stack_bottom; s = s->prev) |
if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM && s->v == v) |
tcc_error("incompatible types for redefinition of '%s'", |
get_tok_str(v, NULL)); |
} |
s = sym_malloc(); |
s->asm_label = 0; |
s->v = v; |
s->type.t = t; |
s->type.ref = NULL; |
#ifdef _WIN64 |
s->d = NULL; |
#endif |
s->c = c; |
s->next = NULL; |
/* add in stack */ |
s->prev = *ps; |
*ps = s; |
return s; |
} |
|
/* find a symbol and return its associated structure. 's' is the top |
of the symbol stack */ |
ST_FUNC Sym *sym_find2(Sym *s, int v) |
{ |
while (s) { |
if (s->v == v) |
return s; |
else if (s->v == -1) |
return NULL; |
s = s->prev; |
} |
return NULL; |
} |
|
/* structure lookup */ |
ST_INLN Sym *struct_find(int v) |
{ |
v -= TOK_IDENT; |
if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT)) |
return NULL; |
return table_ident[v]->sym_struct; |
} |
|
/* find an identifier */ |
ST_INLN Sym *sym_find(int v) |
{ |
v -= TOK_IDENT; |
if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT)) |
return NULL; |
return table_ident[v]->sym_identifier; |
} |
|
/* push a given symbol on the symbol stack */ |
ST_FUNC Sym *sym_push(int v, CType *type, int r, int c) |
{ |
Sym *s, **ps; |
TokenSym *ts; |
|
if (local_stack) |
ps = &local_stack; |
else |
ps = &global_stack; |
s = sym_push2(ps, v, type->t, c); |
s->type.ref = type->ref; |
s->r = r; |
/* don't record fields or anonymous symbols */ |
/* XXX: simplify */ |
if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) { |
/* record symbol in token array */ |
ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT]; |
if (v & SYM_STRUCT) |
ps = &ts->sym_struct; |
else |
ps = &ts->sym_identifier; |
s->prev_tok = *ps; |
*ps = s; |
} |
return s; |
} |
|
/* push a global identifier */ |
ST_FUNC Sym *global_identifier_push(int v, int t, int c) |
{ |
Sym *s, **ps; |
s = sym_push2(&global_stack, v, t, c); |
/* don't record anonymous symbol */ |
if (v < SYM_FIRST_ANOM) { |
ps = &table_ident[v - TOK_IDENT]->sym_identifier; |
/* modify the top most local identifier, so that |
sym_identifier will point to 's' when popped */ |
while (*ps != NULL) |
ps = &(*ps)->prev_tok; |
s->prev_tok = NULL; |
*ps = s; |
} |
return s; |
} |
|
/* pop symbols until top reaches 'b' */ |
ST_FUNC void sym_pop(Sym **ptop, Sym *b) |
{ |
Sym *s, *ss, **ps; |
TokenSym *ts; |
int v; |
|
s = *ptop; |
while(s != b) { |
ss = s->prev; |
v = s->v; |
/* remove symbol in token array */ |
/* XXX: simplify */ |
if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) { |
ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT]; |
if (v & SYM_STRUCT) |
ps = &ts->sym_struct; |
else |
ps = &ts->sym_identifier; |
*ps = s->prev_tok; |
} |
sym_free(s); |
s = ss; |
} |
*ptop = b; |
} |
|
static void weaken_symbol(Sym *sym) |
{ |
sym->type.t |= VT_WEAK; |
if (sym->c > 0) { |
int esym_type; |
ElfW(Sym) *esym; |
|
esym = &((ElfW(Sym) *)symtab_section->data)[sym->c]; |
esym_type = ELFW(ST_TYPE)(esym->st_info); |
esym->st_info = ELFW(ST_INFO)(STB_WEAK, esym_type); |
} |
} |
|
static void apply_visibility(Sym *sym, CType *type) |
{ |
int vis = sym->type.t & VT_VIS_MASK; |
int vis2 = type->t & VT_VIS_MASK; |
if (vis == (STV_DEFAULT << VT_VIS_SHIFT)) |
vis = vis2; |
else if (vis2 == (STV_DEFAULT << VT_VIS_SHIFT)) |
; |
else |
vis = (vis < vis2) ? vis : vis2; |
sym->type.t &= ~VT_VIS_MASK; |
sym->type.t |= vis; |
|
if (sym->c > 0) { |
ElfW(Sym) *esym; |
|
esym = &((ElfW(Sym) *)symtab_section->data)[sym->c]; |
vis >>= VT_VIS_SHIFT; |
esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1)) | vis; |
} |
} |
|
/* ------------------------------------------------------------------------- */ |
|
ST_FUNC void swap(int *p, int *q) |
{ |
int t; |
t = *p; |
*p = *q; |
*q = t; |
} |
|
static void vsetc(CType *type, int r, CValue *vc) |
{ |
int v; |
|
if (vtop >= vstack + (VSTACK_SIZE - 1)) |
tcc_error("memory full (vstack)"); |
/* cannot let cpu flags if other instruction are generated. Also |
avoid leaving VT_JMP anywhere except on the top of the stack |
because it would complicate the code generator. */ |
if (vtop >= vstack) { |
v = vtop->r & VT_VALMASK; |
if (v == VT_CMP || (v & ~1) == VT_JMP) |
gv(RC_INT); |
} |
vtop++; |
vtop->type = *type; |
vtop->r = r; |
vtop->r2 = VT_CONST; |
vtop->c = *vc; |
} |
|
/* push constant of type "type" with useless value */ |
ST_FUNC void vpush(CType *type) |
{ |
CValue cval; |
vsetc(type, VT_CONST, &cval); |
} |
|
/* push integer constant */ |
ST_FUNC void vpushi(int v) |
{ |
CValue cval; |
cval.i = v; |
vsetc(&int_type, VT_CONST, &cval); |
} |
|
/* push a pointer sized constant */ |
static void vpushs(addr_t v) |
{ |
CValue cval; |
cval.i = v; |
vsetc(&size_type, VT_CONST, &cval); |
} |
|
/* push arbitrary 64bit constant */ |
ST_FUNC void vpush64(int ty, unsigned long long v) |
{ |
CValue cval; |
CType ctype; |
ctype.t = ty; |
ctype.ref = NULL; |
cval.i = v; |
vsetc(&ctype, VT_CONST, &cval); |
} |
|
/* push long long constant */ |
static inline void vpushll(long long v) |
{ |
vpush64(VT_LLONG, v); |
} |
|
/* push a symbol value of TYPE */ |
static inline void vpushsym(CType *type, Sym *sym) |
{ |
CValue cval; |
cval.i = 0; |
vsetc(type, VT_CONST | VT_SYM, &cval); |
vtop->sym = sym; |
} |
|
/* Return a static symbol pointing to a section */ |
ST_FUNC Sym *get_sym_ref(CType *type, Section *sec, unsigned long offset, unsigned long size) |
{ |
int v; |
Sym *sym; |
|
v = anon_sym++; |
sym = global_identifier_push(v, type->t | VT_STATIC, 0); |
sym->type.ref = type->ref; |
sym->r = VT_CONST | VT_SYM; |
put_extern_sym(sym, sec, offset, size); |
return sym; |
} |
|
/* push a reference to a section offset by adding a dummy symbol */ |
static void vpush_ref(CType *type, Section *sec, unsigned long offset, unsigned long size) |
{ |
vpushsym(type, get_sym_ref(type, sec, offset, size)); |
} |
|
/* define a new external reference to a symbol 'v' of type 'u' */ |
ST_FUNC Sym *external_global_sym(int v, CType *type, int r) |
{ |
Sym *s; |
|
s = sym_find(v); |
if (!s) { |
/* push forward reference */ |
s = global_identifier_push(v, type->t | VT_EXTERN, 0); |
s->type.ref = type->ref; |
s->r = r | VT_CONST | VT_SYM; |
} |
return s; |
} |
|
/* define a new external reference to a symbol 'v' */ |
static Sym *external_sym(int v, CType *type, int r) |
{ |
Sym *s; |
|
s = sym_find(v); |
if (!s) { |
/* push forward reference */ |
s = sym_push(v, type, r | VT_CONST | VT_SYM, 0); |
s->type.t |= VT_EXTERN; |
} else if (s->type.ref == func_old_type.ref) { |
s->type.ref = type->ref; |
s->r = r | VT_CONST | VT_SYM; |
s->type.t |= VT_EXTERN; |
} else if (!is_compatible_types(&s->type, type)) { |
tcc_error("incompatible types for redefinition of '%s'", |
get_tok_str(v, NULL)); |
} |
/* Merge some storage attributes. */ |
if (type->t & VT_WEAK) |
weaken_symbol(s); |
|
if (type->t & VT_VIS_MASK) |
apply_visibility(s, type); |
|
return s; |
} |
|
/* push a reference to global symbol v */ |
ST_FUNC void vpush_global_sym(CType *type, int v) |
{ |
vpushsym(type, external_global_sym(v, type, 0)); |
} |
|
ST_FUNC void vset(CType *type, int r, int v) |
{ |
CValue cval; |
|
cval.i = v; |
vsetc(type, r, &cval); |
} |
|
static void vseti(int r, int v) |
{ |
CType type; |
type.t = VT_INT; |
type.ref = 0; |
vset(&type, r, v); |
} |
|
ST_FUNC void vswap(void) |
{ |
SValue tmp; |
/* cannot let cpu flags if other instruction are generated. Also |
avoid leaving VT_JMP anywhere except on the top of the stack |
because it would complicate the code generator. */ |
if (vtop >= vstack) { |
int v = vtop->r & VT_VALMASK; |
if (v == VT_CMP || (v & ~1) == VT_JMP) |
gv(RC_INT); |
} |
tmp = vtop[0]; |
vtop[0] = vtop[-1]; |
vtop[-1] = tmp; |
|
/* XXX: +2% overall speed possible with optimized memswap |
* |
* memswap(&vtop[0], &vtop[1], sizeof *vtop); |
*/ |
} |
|
ST_FUNC void vpushv(SValue *v) |
{ |
if (vtop >= vstack + (VSTACK_SIZE - 1)) |
tcc_error("memory full (vstack)"); |
vtop++; |
*vtop = *v; |
} |
|
static void vdup(void) |
{ |
vpushv(vtop); |
} |
|
/* save r to the memory stack, and mark it as being free */ |
ST_FUNC void save_reg(int r) |
{ |
int l, saved, size, align; |
SValue *p, sv; |
CType *type; |
|
/* modify all stack values */ |
saved = 0; |
l = 0; |
for(p=vstack;p<=vtop;p++) { |
if ((p->r & VT_VALMASK) == r || |
((p->type.t & VT_BTYPE) == VT_LLONG && (p->r2 & VT_VALMASK) == r)) { |
/* must save value on stack if not already done */ |
if (!saved) { |
/* NOTE: must reload 'r' because r might be equal to r2 */ |
r = p->r & VT_VALMASK; |
/* store register in the stack */ |
type = &p->type; |
if ((p->r & VT_LVAL) || |
(!is_float(type->t) && (type->t & VT_BTYPE) != VT_LLONG)) |
#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64) |
type = &char_pointer_type; |
#else |
type = &int_type; |
#endif |
size = type_size(type, &align); |
loc = (loc - size) & -align; |
sv.type.t = type->t; |
sv.r = VT_LOCAL | VT_LVAL; |
sv.c.i = loc; |
store(r, &sv); |
#if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64) |
/* x86 specific: need to pop fp register ST0 if saved */ |
if (r == TREG_ST0) { |
o(0xd8dd); /* fstp %st(0) */ |
} |
#endif |
#if !defined(TCC_TARGET_ARM64) && !defined(TCC_TARGET_X86_64) |
/* special long long case */ |
if ((type->t & VT_BTYPE) == VT_LLONG) { |
sv.c.i += 4; |
store(p->r2, &sv); |
} |
#endif |
l = loc; |
saved = 1; |
} |
/* mark that stack entry as being saved on the stack */ |
if (p->r & VT_LVAL) { |
/* also clear the bounded flag because the |
relocation address of the function was stored in |
p->c.i */ |
p->r = (p->r & ~(VT_VALMASK | VT_BOUNDED)) | VT_LLOCAL; |
} else { |
p->r = lvalue_type(p->type.t) | VT_LOCAL; |
} |
p->r2 = VT_CONST; |
p->c.i = l; |
} |
} |
} |
|
#ifdef TCC_TARGET_ARM |
/* find a register of class 'rc2' with at most one reference on stack. |
* If none, call get_reg(rc) */ |
ST_FUNC int get_reg_ex(int rc, int rc2) |
{ |
int r; |
SValue *p; |
|
for(r=0;r<NB_REGS;r++) { |
if (reg_classes[r] & rc2) { |
int n; |
n=0; |
for(p = vstack; p <= vtop; p++) { |
if ((p->r & VT_VALMASK) == r || |
(p->r2 & VT_VALMASK) == r) |
n++; |
} |
if (n <= 1) |
return r; |
} |
} |
return get_reg(rc); |
} |
#endif |
|
/* find a free register of class 'rc'. If none, save one register */ |
ST_FUNC int get_reg(int rc) |
{ |
int r; |
SValue *p; |
|
/* find a free register */ |
for(r=0;r<NB_REGS;r++) { |
if (reg_classes[r] & rc) { |
for(p=vstack;p<=vtop;p++) { |
if ((p->r & VT_VALMASK) == r || |
(p->r2 & VT_VALMASK) == r) |
goto notfound; |
} |
return r; |
} |
notfound: ; |
} |
|
/* no register left : free the first one on the stack (VERY |
IMPORTANT to start from the bottom to ensure that we don't |
spill registers used in gen_opi()) */ |
for(p=vstack;p<=vtop;p++) { |
/* look at second register (if long long) */ |
r = p->r2 & VT_VALMASK; |
if (r < VT_CONST && (reg_classes[r] & rc)) |
goto save_found; |
r = p->r & VT_VALMASK; |
if (r < VT_CONST && (reg_classes[r] & rc)) { |
save_found: |
save_reg(r); |
return r; |
} |
} |
/* Should never comes here */ |
return -1; |
} |
|
/* save registers up to (vtop - n) stack entry */ |
ST_FUNC void save_regs(int n) |
{ |
int r; |
SValue *p, *p1; |
p1 = vtop - n; |
for(p = vstack;p <= p1; p++) { |
r = p->r & VT_VALMASK; |
if (r < VT_CONST) { |
save_reg(r); |
} |
} |
} |
|
/* move register 's' (of type 't') to 'r', and flush previous value of r to memory |
if needed */ |
static void move_reg(int r, int s, int t) |
{ |
SValue sv; |
|
if (r != s) { |
save_reg(r); |
sv.type.t = t; |
sv.type.ref = NULL; |
sv.r = s; |
sv.c.i = 0; |
load(r, &sv); |
} |
} |
|
/* get address of vtop (vtop MUST BE an lvalue) */ |
ST_FUNC void gaddrof(void) |
{ |
if (vtop->r & VT_REF && !nocode_wanted) |
gv(RC_INT); |
vtop->r &= ~VT_LVAL; |
/* tricky: if saved lvalue, then we can go back to lvalue */ |
if ((vtop->r & VT_VALMASK) == VT_LLOCAL) |
vtop->r = (vtop->r & ~(VT_VALMASK | VT_LVAL_TYPE)) | VT_LOCAL | VT_LVAL; |
|
|
} |
|
#ifdef CONFIG_TCC_BCHECK |
/* generate lvalue bound code */ |
static void gbound(void) |
{ |
int lval_type; |
CType type1; |
|
vtop->r &= ~VT_MUSTBOUND; |
/* if lvalue, then use checking code before dereferencing */ |
if (vtop->r & VT_LVAL) { |
/* if not VT_BOUNDED value, then make one */ |
if (!(vtop->r & VT_BOUNDED)) { |
lval_type = vtop->r & (VT_LVAL_TYPE | VT_LVAL); |
/* must save type because we must set it to int to get pointer */ |
type1 = vtop->type; |
vtop->type.t = VT_PTR; |
gaddrof(); |
vpushi(0); |
gen_bounded_ptr_add(); |
vtop->r |= lval_type; |
vtop->type = type1; |
} |
/* then check for dereferencing */ |
gen_bounded_ptr_deref(); |
} |
} |
#endif |
|
/* store vtop a register belonging to class 'rc'. lvalues are |
converted to values. Cannot be used if cannot be converted to |
register value (such as structures). */ |
ST_FUNC int gv(int rc) |
{ |
int r, bit_pos, bit_size, size, align, i; |
int rc2; |
|
/* NOTE: get_reg can modify vstack[] */ |
if (vtop->type.t & VT_BITFIELD) { |
CType type; |
int bits = 32; |
bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f; |
bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f; |
/* remove bit field info to avoid loops */ |
vtop->type.t &= ~VT_BITFIELD & ((1 << VT_STRUCT_SHIFT) - 1); |
/* cast to int to propagate signedness in following ops */ |
if ((vtop->type.t & VT_BTYPE) == VT_LLONG) { |
type.t = VT_LLONG; |
bits = 64; |
} else |
type.t = VT_INT; |
if((vtop->type.t & VT_UNSIGNED) || |
(vtop->type.t & VT_BTYPE) == VT_BOOL) |
type.t |= VT_UNSIGNED; |
gen_cast(&type); |
/* generate shifts */ |
vpushi(bits - (bit_pos + bit_size)); |
gen_op(TOK_SHL); |
vpushi(bits - bit_size); |
/* NOTE: transformed to SHR if unsigned */ |
gen_op(TOK_SAR); |
r = gv(rc); |
} else { |
if (is_float(vtop->type.t) && |
(vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) { |
Sym *sym; |
int *ptr; |
unsigned long offset; |
#if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP) |
CValue check; |
#endif |
|
/* XXX: unify with initializers handling ? */ |
/* CPUs usually cannot use float constants, so we store them |
generically in data segment */ |
size = type_size(&vtop->type, &align); |
offset = (data_section->data_offset + align - 1) & -align; |
data_section->data_offset = offset; |
/* XXX: not portable yet */ |
#if defined(__i386__) || defined(__x86_64__) |
/* Zero pad x87 tenbyte long doubles */ |
if (size == LDOUBLE_SIZE) { |
vtop->c.tab[2] &= 0xffff; |
#if LDOUBLE_SIZE == 16 |
vtop->c.tab[3] = 0; |
#endif |
} |
#endif |
ptr = section_ptr_add(data_section, size); |
size = size >> 2; |
#if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP) |
check.d = 1; |
if(check.tab[0]) |
for(i=0;i<size;i++) |
ptr[i] = vtop->c.tab[size-1-i]; |
else |
#endif |
for(i=0;i<size;i++) |
ptr[i] = vtop->c.tab[i]; |
sym = get_sym_ref(&vtop->type, data_section, offset, size << 2); |
vtop->r |= VT_LVAL | VT_SYM; |
vtop->sym = sym; |
vtop->c.i = 0; |
} |
#ifdef CONFIG_TCC_BCHECK |
if (vtop->r & VT_MUSTBOUND) |
gbound(); |
#endif |
|
r = vtop->r & VT_VALMASK; |
rc2 = (rc & RC_FLOAT) ? RC_FLOAT : RC_INT; |
#ifndef TCC_TARGET_ARM64 |
if (rc == RC_IRET) |
rc2 = RC_LRET; |
#ifdef TCC_TARGET_X86_64 |
else if (rc == RC_FRET) |
rc2 = RC_QRET; |
#endif |
#endif |
|
/* need to reload if: |
- constant |
- lvalue (need to dereference pointer) |
- already a register, but not in the right class */ |
if (r >= VT_CONST |
|| (vtop->r & VT_LVAL) |
|| !(reg_classes[r] & rc) |
#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64) |
|| ((vtop->type.t & VT_BTYPE) == VT_QLONG && !(reg_classes[vtop->r2] & rc2)) |
|| ((vtop->type.t & VT_BTYPE) == VT_QFLOAT && !(reg_classes[vtop->r2] & rc2)) |
#else |
|| ((vtop->type.t & VT_BTYPE) == VT_LLONG && !(reg_classes[vtop->r2] & rc2)) |
#endif |
) |
{ |
r = get_reg(rc); |
#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64) |
if (((vtop->type.t & VT_BTYPE) == VT_QLONG) || ((vtop->type.t & VT_BTYPE) == VT_QFLOAT)) { |
int addr_type = VT_LLONG, load_size = 8, load_type = ((vtop->type.t & VT_BTYPE) == VT_QLONG) ? VT_LLONG : VT_DOUBLE; |
#else |
if ((vtop->type.t & VT_BTYPE) == VT_LLONG) { |
int addr_type = VT_INT, load_size = 4, load_type = VT_INT; |
unsigned long long ll; |
#endif |
int r2, original_type; |
original_type = vtop->type.t; |
/* two register type load : expand to two words |
temporarily */ |
#if !defined(TCC_TARGET_ARM64) && !defined(TCC_TARGET_X86_64) |
if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) { |
/* load constant */ |
ll = vtop->c.i; |
vtop->c.i = ll; /* first word */ |
load(r, vtop); |
vtop->r = r; /* save register value */ |
vpushi(ll >> 32); /* second word */ |
} else |
#endif |
if (r >= VT_CONST || /* XXX: test to VT_CONST incorrect ? */ |
(vtop->r & VT_LVAL)) { |
/* We do not want to modifier the long long |
pointer here, so the safest (and less |
efficient) is to save all the other registers |
in the stack. XXX: totally inefficient. */ |
save_regs(1); |
/* load from memory */ |
vtop->type.t = load_type; |
load(r, vtop); |
vdup(); |
vtop[-1].r = r; /* save register value */ |
/* increment pointer to get second word */ |
vtop->type.t = addr_type; |
gaddrof(); |
vpushi(load_size); |
gen_op('+'); |
vtop->r |= VT_LVAL; |
vtop->type.t = load_type; |
} else { |
/* move registers */ |
load(r, vtop); |
vdup(); |
vtop[-1].r = r; /* save register value */ |
vtop->r = vtop[-1].r2; |
} |
/* Allocate second register. Here we rely on the fact that |
get_reg() tries first to free r2 of an SValue. */ |
r2 = get_reg(rc2); |
load(r2, vtop); |
vpop(); |
/* write second register */ |
vtop->r2 = r2; |
vtop->type.t = original_type; |
} else if ((vtop->r & VT_LVAL) && !is_float(vtop->type.t)) { |
int t1, t; |
/* lvalue of scalar type : need to use lvalue type |
because of possible cast */ |
t = vtop->type.t; |
t1 = t; |
/* compute memory access type */ |
if (vtop->r & VT_REF) |
#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64) |
t = VT_PTR; |
#else |
t = VT_INT; |
#endif |
else if (vtop->r & VT_LVAL_BYTE) |
t = VT_BYTE; |
else if (vtop->r & VT_LVAL_SHORT) |
t = VT_SHORT; |
if (vtop->r & VT_LVAL_UNSIGNED) |
t |= VT_UNSIGNED; |
vtop->type.t = t; |
load(r, vtop); |
/* restore wanted type */ |
vtop->type.t = t1; |
} else { |
/* one register type load */ |
load(r, vtop); |
} |
} |
vtop->r = r; |
#ifdef TCC_TARGET_C67 |
/* uses register pairs for doubles */ |
if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE) |
vtop->r2 = r+1; |
#endif |
} |
return r; |
} |
|
/* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */ |
ST_FUNC void gv2(int rc1, int rc2) |
{ |
int v; |
|
/* generate more generic register first. But VT_JMP or VT_CMP |
values must be generated first in all cases to avoid possible |
reload errors */ |
v = vtop[0].r & VT_VALMASK; |
if (v != VT_CMP && (v & ~1) != VT_JMP && rc1 <= rc2) { |
vswap(); |
gv(rc1); |
vswap(); |
gv(rc2); |
/* test if reload is needed for first register */ |
if ((vtop[-1].r & VT_VALMASK) >= VT_CONST) { |
vswap(); |
gv(rc1); |
vswap(); |
} |
} else { |
gv(rc2); |
vswap(); |
gv(rc1); |
vswap(); |
/* test if reload is needed for first register */ |
if ((vtop[0].r & VT_VALMASK) >= VT_CONST) { |
gv(rc2); |
} |
} |
} |
|
#ifndef TCC_TARGET_ARM64 |
/* wrapper around RC_FRET to return a register by type */ |
static int rc_fret(int t) |
{ |
#ifdef TCC_TARGET_X86_64 |
if (t == VT_LDOUBLE) { |
return RC_ST0; |
} |
#endif |
return RC_FRET; |
} |
#endif |
|
/* wrapper around REG_FRET to return a register by type */ |
static int reg_fret(int t) |
{ |
#ifdef TCC_TARGET_X86_64 |
if (t == VT_LDOUBLE) { |
return TREG_ST0; |
} |
#endif |
return REG_FRET; |
} |
|
/* expand long long on stack in two int registers */ |
static void lexpand(void) |
{ |
int u; |
|
u = vtop->type.t & (VT_DEFSIGN | VT_UNSIGNED); |
gv(RC_INT); |
vdup(); |
vtop[0].r = vtop[-1].r2; |
vtop[0].r2 = VT_CONST; |
vtop[-1].r2 = VT_CONST; |
vtop[0].type.t = VT_INT | u; |
vtop[-1].type.t = VT_INT | u; |
} |
|
#ifdef TCC_TARGET_ARM |
/* expand long long on stack */ |
ST_FUNC void lexpand_nr(void) |
{ |
int u,v; |
|
u = vtop->type.t & (VT_DEFSIGN | VT_UNSIGNED); |
vdup(); |
vtop->r2 = VT_CONST; |
vtop->type.t = VT_INT | u; |
v=vtop[-1].r & (VT_VALMASK | VT_LVAL); |
if (v == VT_CONST) { |
vtop[-1].c.i = vtop->c.i; |
vtop->c.i = vtop->c.i >> 32; |
vtop->r = VT_CONST; |
} else if (v == (VT_LVAL|VT_CONST) || v == (VT_LVAL|VT_LOCAL)) { |
vtop->c.i += 4; |
vtop->r = vtop[-1].r; |
} else if (v > VT_CONST) { |
vtop--; |
lexpand(); |
} else |
vtop->r = vtop[-1].r2; |
vtop[-1].r2 = VT_CONST; |
vtop[-1].type.t = VT_INT | u; |
} |
#endif |
|
/* build a long long from two ints */ |
static void lbuild(int t) |
{ |
gv2(RC_INT, RC_INT); |
vtop[-1].r2 = vtop[0].r; |
vtop[-1].type.t = t; |
vpop(); |
} |
|
/* rotate n first stack elements to the bottom |
I1 ... In -> I2 ... In I1 [top is right] |
*/ |
ST_FUNC void vrotb(int n) |
{ |
int i; |
SValue tmp; |
|
tmp = vtop[-n + 1]; |
for(i=-n+1;i!=0;i++) |
vtop[i] = vtop[i+1]; |
vtop[0] = tmp; |
} |
|
/* rotate the n elements before entry e towards the top |
I1 ... In ... -> In I1 ... I(n-1) ... [top is right] |
*/ |
ST_FUNC void vrote(SValue *e, int n) |
{ |
int i; |
SValue tmp; |
|
tmp = *e; |
for(i = 0;i < n - 1; i++) |
e[-i] = e[-i - 1]; |
e[-n + 1] = tmp; |
} |
|
/* rotate n first stack elements to the top |
I1 ... In -> In I1 ... I(n-1) [top is right] |
*/ |
ST_FUNC void vrott(int n) |
{ |
vrote(vtop, n); |
} |
|
/* pop stack value */ |
ST_FUNC void vpop(void) |
{ |
int v; |
v = vtop->r & VT_VALMASK; |
#if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64) |
/* for x86, we need to pop the FP stack */ |
if (v == TREG_ST0 && !nocode_wanted) { |
o(0xd8dd); /* fstp %st(0) */ |
} else |
#endif |
if (v == VT_JMP || v == VT_JMPI) { |
/* need to put correct jump if && or || without test */ |
gsym(vtop->c.i); |
} |
vtop--; |
} |
|
/* convert stack entry to register and duplicate its value in another |
register */ |
static void gv_dup(void) |
{ |
int rc, t, r, r1; |
SValue sv; |
|
t = vtop->type.t; |
if ((t & VT_BTYPE) == VT_LLONG) { |
lexpand(); |
gv_dup(); |
vswap(); |
vrotb(3); |
gv_dup(); |
vrotb(4); |
/* stack: H L L1 H1 */ |
lbuild(t); |
vrotb(3); |
vrotb(3); |
vswap(); |
lbuild(t); |
vswap(); |
} else { |
/* duplicate value */ |
rc = RC_INT; |
sv.type.t = VT_INT; |
if (is_float(t)) { |
rc = RC_FLOAT; |
#ifdef TCC_TARGET_X86_64 |
if ((t & VT_BTYPE) == VT_LDOUBLE) { |
rc = RC_ST0; |
} |
#endif |
sv.type.t = t; |
} |
r = gv(rc); |
r1 = get_reg(rc); |
sv.r = r; |
sv.c.i = 0; |
load(r1, &sv); /* move r to r1 */ |
vdup(); |
/* duplicates value */ |
if (r != r1) |
vtop->r = r1; |
} |
} |
|
/* Generate value test |
* |
* Generate a test for any value (jump, comparison and integers) */ |
ST_FUNC int gvtst(int inv, int t) |
{ |
int v = vtop->r & VT_VALMASK; |
if (v != VT_CMP && v != VT_JMP && v != VT_JMPI) { |
vpushi(0); |
gen_op(TOK_NE); |
} |
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) { |
/* constant jmp optimization */ |
if ((vtop->c.i != 0) != inv) |
t = gjmp(t); |
vtop--; |
return t; |
} |
return gtst(inv, t); |
} |
|
#if !defined(TCC_TARGET_ARM64) && !defined(TCC_TARGET_X86_64) |
/* generate CPU independent (unsigned) long long operations */ |
static void gen_opl(int op) |
{ |
int t, a, b, op1, c, i; |
int func; |
unsigned short reg_iret = REG_IRET; |
unsigned short reg_lret = REG_LRET; |
SValue tmp; |
|
switch(op) { |
case '/': |
case TOK_PDIV: |
func = TOK___divdi3; |
goto gen_func; |
case TOK_UDIV: |
func = TOK___udivdi3; |
goto gen_func; |
case '%': |
func = TOK___moddi3; |
goto gen_mod_func; |
case TOK_UMOD: |
func = TOK___umoddi3; |
gen_mod_func: |
#ifdef TCC_ARM_EABI |
reg_iret = TREG_R2; |
reg_lret = TREG_R3; |
#endif |
gen_func: |
/* call generic long long function */ |
vpush_global_sym(&func_old_type, func); |
vrott(3); |
gfunc_call(2); |
vpushi(0); |
vtop->r = reg_iret; |
vtop->r2 = reg_lret; |
break; |
case '^': |
case '&': |
case '|': |
case '*': |
case '+': |
case '-': |
t = vtop->type.t; |
vswap(); |
lexpand(); |
vrotb(3); |
lexpand(); |
/* stack: L1 H1 L2 H2 */ |
tmp = vtop[0]; |
vtop[0] = vtop[-3]; |
vtop[-3] = tmp; |
tmp = vtop[-2]; |
vtop[-2] = vtop[-3]; |
vtop[-3] = tmp; |
vswap(); |
/* stack: H1 H2 L1 L2 */ |
if (op == '*') { |
vpushv(vtop - 1); |
vpushv(vtop - 1); |
gen_op(TOK_UMULL); |
lexpand(); |
/* stack: H1 H2 L1 L2 ML MH */ |
for(i=0;i<4;i++) |
vrotb(6); |
/* stack: ML MH H1 H2 L1 L2 */ |
tmp = vtop[0]; |
vtop[0] = vtop[-2]; |
vtop[-2] = tmp; |
/* stack: ML MH H1 L2 H2 L1 */ |
gen_op('*'); |
vrotb(3); |
vrotb(3); |
gen_op('*'); |
/* stack: ML MH M1 M2 */ |
gen_op('+'); |
gen_op('+'); |
} else if (op == '+' || op == '-') { |
/* XXX: add non carry method too (for MIPS or alpha) */ |
if (op == '+') |
op1 = TOK_ADDC1; |
else |
op1 = TOK_SUBC1; |
gen_op(op1); |
/* stack: H1 H2 (L1 op L2) */ |
vrotb(3); |
vrotb(3); |
gen_op(op1 + 1); /* TOK_xxxC2 */ |
} else { |
gen_op(op); |
/* stack: H1 H2 (L1 op L2) */ |
vrotb(3); |
vrotb(3); |
/* stack: (L1 op L2) H1 H2 */ |
gen_op(op); |
/* stack: (L1 op L2) (H1 op H2) */ |
} |
/* stack: L H */ |
lbuild(t); |
break; |
case TOK_SAR: |
case TOK_SHR: |
case TOK_SHL: |
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) { |
t = vtop[-1].type.t; |
vswap(); |
lexpand(); |
vrotb(3); |
/* stack: L H shift */ |
c = (int)vtop->c.i; |
/* constant: simpler */ |
/* NOTE: all comments are for SHL. the other cases are |
done by swaping words */ |
vpop(); |
if (op != TOK_SHL) |
vswap(); |
if (c >= 32) { |
/* stack: L H */ |
vpop(); |
if (c > 32) { |
vpushi(c - 32); |
gen_op(op); |
} |
if (op != TOK_SAR) { |
vpushi(0); |
} else { |
gv_dup(); |
vpushi(31); |
gen_op(TOK_SAR); |
} |
vswap(); |
} else { |
vswap(); |
gv_dup(); |
/* stack: H L L */ |
vpushi(c); |
gen_op(op); |
vswap(); |
vpushi(32 - c); |
if (op == TOK_SHL) |
gen_op(TOK_SHR); |
else |
gen_op(TOK_SHL); |
vrotb(3); |
/* stack: L L H */ |
vpushi(c); |
if (op == TOK_SHL) |
gen_op(TOK_SHL); |
else |
gen_op(TOK_SHR); |
gen_op('|'); |
} |
if (op != TOK_SHL) |
vswap(); |
lbuild(t); |
} else { |
/* XXX: should provide a faster fallback on x86 ? */ |
switch(op) { |
case TOK_SAR: |
func = TOK___ashrdi3; |
goto gen_func; |
case TOK_SHR: |
func = TOK___lshrdi3; |
goto gen_func; |
case TOK_SHL: |
func = TOK___ashldi3; |
goto gen_func; |
} |
} |
break; |
default: |
/* compare operations */ |
t = vtop->type.t; |
vswap(); |
lexpand(); |
vrotb(3); |
lexpand(); |
/* stack: L1 H1 L2 H2 */ |
tmp = vtop[-1]; |
vtop[-1] = vtop[-2]; |
vtop[-2] = tmp; |
/* stack: L1 L2 H1 H2 */ |
/* compare high */ |
op1 = op; |
/* when values are equal, we need to compare low words. since |
the jump is inverted, we invert the test too. */ |
if (op1 == TOK_LT) |
op1 = TOK_LE; |
else if (op1 == TOK_GT) |
op1 = TOK_GE; |
else if (op1 == TOK_ULT) |
op1 = TOK_ULE; |
else if (op1 == TOK_UGT) |
op1 = TOK_UGE; |
a = 0; |
b = 0; |
gen_op(op1); |
if (op1 != TOK_NE) { |
a = gvtst(1, 0); |
} |
if (op != TOK_EQ) { |
/* generate non equal test */ |
/* XXX: NOT PORTABLE yet */ |
if (a == 0) { |
b = gvtst(0, 0); |
} else { |
#if defined(TCC_TARGET_I386) |
b = psym(0x850f, 0); |
#elif defined(TCC_TARGET_ARM) |
b = ind; |
o(0x1A000000 | encbranch(ind, 0, 1)); |
#elif defined(TCC_TARGET_C67) || defined(TCC_TARGET_ARM64) |
tcc_error("not implemented"); |
#else |
#error not supported |
#endif |
} |
} |
/* compare low. Always unsigned */ |
op1 = op; |
if (op1 == TOK_LT) |
op1 = TOK_ULT; |
else if (op1 == TOK_LE) |
op1 = TOK_ULE; |
else if (op1 == TOK_GT) |
op1 = TOK_UGT; |
else if (op1 == TOK_GE) |
op1 = TOK_UGE; |
gen_op(op1); |
a = gvtst(1, a); |
gsym(b); |
vseti(VT_JMPI, a); |
break; |
} |
} |
#endif |
|
static uint64_t gen_opic_sdiv(uint64_t a, uint64_t b) |
{ |
uint64_t x = (a >> 63 ? -a : a) / (b >> 63 ? -b : b); |
return (a ^ b) >> 63 ? -x : x; |
} |
|
static int gen_opic_lt(uint64_t a, uint64_t b) |
{ |
return (a ^ (uint64_t)1 << 63) < (b ^ (uint64_t)1 << 63); |
} |
|
/* handle integer constant optimizations and various machine |
independent opt */ |
static void gen_opic(int op) |
{ |
SValue *v1 = vtop - 1; |
SValue *v2 = vtop; |
int t1 = v1->type.t & VT_BTYPE; |
int t2 = v2->type.t & VT_BTYPE; |
int c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST; |
int c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST; |
uint64_t l1 = c1 ? v1->c.i : 0; |
uint64_t l2 = c2 ? v2->c.i : 0; |
int shm = (t1 == VT_LLONG) ? 63 : 31; |
|
if (t1 != VT_LLONG) |
l1 = ((uint32_t)l1 | |
(v1->type.t & VT_UNSIGNED ? 0 : -(l1 & 0x80000000))); |
if (t2 != VT_LLONG) |
l2 = ((uint32_t)l2 | |
(v2->type.t & VT_UNSIGNED ? 0 : -(l2 & 0x80000000))); |
|
if (c1 && c2) { |
switch(op) { |
case '+': l1 += l2; break; |
case '-': l1 -= l2; break; |
case '&': l1 &= l2; break; |
case '^': l1 ^= l2; break; |
case '|': l1 |= l2; break; |
case '*': l1 *= l2; break; |
|
case TOK_PDIV: |
case '/': |
case '%': |
case TOK_UDIV: |
case TOK_UMOD: |
/* if division by zero, generate explicit division */ |
if (l2 == 0) { |
if (const_wanted) |
tcc_error("division by zero in constant"); |
goto general_case; |
} |
switch(op) { |
default: l1 = gen_opic_sdiv(l1, l2); break; |
case '%': l1 = l1 - l2 * gen_opic_sdiv(l1, l2); break; |
case TOK_UDIV: l1 = l1 / l2; break; |
case TOK_UMOD: l1 = l1 % l2; break; |
} |
break; |
case TOK_SHL: l1 <<= (l2 & shm); break; |
case TOK_SHR: l1 >>= (l2 & shm); break; |
case TOK_SAR: |
l1 = (l1 >> 63) ? ~(~l1 >> (l2 & shm)) : l1 >> (l2 & shm); |
break; |
/* tests */ |
case TOK_ULT: l1 = l1 < l2; break; |
case TOK_UGE: l1 = l1 >= l2; break; |
case TOK_EQ: l1 = l1 == l2; break; |
case TOK_NE: l1 = l1 != l2; break; |
case TOK_ULE: l1 = l1 <= l2; break; |
case TOK_UGT: l1 = l1 > l2; break; |
case TOK_LT: l1 = gen_opic_lt(l1, l2); break; |
case TOK_GE: l1 = !gen_opic_lt(l1, l2); break; |
case TOK_LE: l1 = !gen_opic_lt(l2, l1); break; |
case TOK_GT: l1 = gen_opic_lt(l2, l1); break; |
/* logical */ |
case TOK_LAND: l1 = l1 && l2; break; |
case TOK_LOR: l1 = l1 || l2; break; |
default: |
goto general_case; |
} |
v1->c.i = l1; |
vtop--; |
} else { |
/* if commutative ops, put c2 as constant */ |
if (c1 && (op == '+' || op == '&' || op == '^' || |
op == '|' || op == '*')) { |
vswap(); |
c2 = c1; //c = c1, c1 = c2, c2 = c; |
l2 = l1; //l = l1, l1 = l2, l2 = l; |
} |
if (!const_wanted && |
c1 && ((l1 == 0 && |
(op == TOK_SHL || op == TOK_SHR || op == TOK_SAR)) || |
(l1 == -1 && op == TOK_SAR))) { |
/* treat (0 << x), (0 >> x) and (-1 >> x) as constant */ |
vtop--; |
} else if (!const_wanted && |
c2 && ((l2 == 0 && (op == '&' || op == '*')) || |
(l2 == -1 && op == '|') || |
(l2 == 0xffffffff && t2 != VT_LLONG && op == '|') || |
(l2 == 1 && (op == '%' || op == TOK_UMOD)))) { |
/* treat (x & 0), (x * 0), (x | -1) and (x % 1) as constant */ |
if (l2 == 1) |
vtop->c.i = 0; |
vswap(); |
vtop--; |
} else if (c2 && (((op == '*' || op == '/' || op == TOK_UDIV || |
op == TOK_PDIV) && |
l2 == 1) || |
((op == '+' || op == '-' || op == '|' || op == '^' || |
op == TOK_SHL || op == TOK_SHR || op == TOK_SAR) && |
l2 == 0) || |
(op == '&' && |
l2 == -1))) { |
/* filter out NOP operations like x*1, x-0, x&-1... */ |
vtop--; |
} else if (c2 && (op == '*' || op == TOK_PDIV || op == TOK_UDIV)) { |
/* try to use shifts instead of muls or divs */ |
if (l2 > 0 && (l2 & (l2 - 1)) == 0) { |
int n = -1; |
while (l2) { |
l2 >>= 1; |
n++; |
} |
vtop->c.i = n; |
if (op == '*') |
op = TOK_SHL; |
else if (op == TOK_PDIV) |
op = TOK_SAR; |
else |
op = TOK_SHR; |
} |
goto general_case; |
} else if (c2 && (op == '+' || op == '-') && |
(((vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM)) == (VT_CONST | VT_SYM)) |
|| (vtop[-1].r & (VT_VALMASK | VT_LVAL)) == VT_LOCAL)) { |
/* symbol + constant case */ |
if (op == '-') |
l2 = -l2; |
vtop--; |
vtop->c.i += l2; |
} else { |
general_case: |
if (!nocode_wanted) { |
/* call low level op generator */ |
if (t1 == VT_LLONG || t2 == VT_LLONG || |
(PTR_SIZE == 8 && (t1 == VT_PTR || t2 == VT_PTR))) |
gen_opl(op); |
else |
gen_opi(op); |
} else { |
vtop--; |
} |
} |
} |
} |
|
/* generate a floating point operation with constant propagation */ |
static void gen_opif(int op) |
{ |
int c1, c2; |
SValue *v1, *v2; |
long double f1, f2; |
|
v1 = vtop - 1; |
v2 = vtop; |
/* currently, we cannot do computations with forward symbols */ |
c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST; |
c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST; |
if (c1 && c2) { |
if (v1->type.t == VT_FLOAT) { |
f1 = v1->c.f; |
f2 = v2->c.f; |
} else if (v1->type.t == VT_DOUBLE) { |
f1 = v1->c.d; |
f2 = v2->c.d; |
} else { |
f1 = v1->c.ld; |
f2 = v2->c.ld; |
} |
|
/* NOTE: we only do constant propagation if finite number (not |
NaN or infinity) (ANSI spec) */ |
if (!ieee_finite(f1) || !ieee_finite(f2)) |
goto general_case; |
|
switch(op) { |
case '+': f1 += f2; break; |
case '-': f1 -= f2; break; |
case '*': f1 *= f2; break; |
case '/': |
if (f2 == 0.0) { |
if (const_wanted) |
tcc_error("division by zero in constant"); |
goto general_case; |
} |
f1 /= f2; |
break; |
/* XXX: also handles tests ? */ |
default: |
goto general_case; |
} |
/* XXX: overflow test ? */ |
if (v1->type.t == VT_FLOAT) { |
v1->c.f = f1; |
} else if (v1->type.t == VT_DOUBLE) { |
v1->c.d = f1; |
} else { |
v1->c.ld = f1; |
} |
vtop--; |
} else { |
general_case: |
if (!nocode_wanted) { |
gen_opf(op); |
} else { |
vtop--; |
} |
} |
} |
|
static int pointed_size(CType *type) |
{ |
int align; |
return type_size(pointed_type(type), &align); |
} |
|
static void vla_runtime_pointed_size(CType *type) |
{ |
int align; |
vla_runtime_type_size(pointed_type(type), &align); |
} |
|
static inline int is_null_pointer(SValue *p) |
{ |
if ((p->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST) |
return 0; |
return ((p->type.t & VT_BTYPE) == VT_INT && (uint32_t)p->c.i == 0) || |
((p->type.t & VT_BTYPE) == VT_LLONG && p->c.i == 0) || |
((p->type.t & VT_BTYPE) == VT_PTR && |
(PTR_SIZE == 4 ? (uint32_t)p->c.i == 0 : p->c.i == 0)); |
} |
|
static inline int is_integer_btype(int bt) |
{ |
return (bt == VT_BYTE || bt == VT_SHORT || |
bt == VT_INT || bt == VT_LLONG); |
} |
|
/* check types for comparison or subtraction of pointers */ |
static void check_comparison_pointer_types(SValue *p1, SValue *p2, int op) |
{ |
CType *type1, *type2, tmp_type1, tmp_type2; |
int bt1, bt2; |
|
/* null pointers are accepted for all comparisons as gcc */ |
if (is_null_pointer(p1) || is_null_pointer(p2)) |
return; |
type1 = &p1->type; |
type2 = &p2->type; |
bt1 = type1->t & VT_BTYPE; |
bt2 = type2->t & VT_BTYPE; |
/* accept comparison between pointer and integer with a warning */ |
if ((is_integer_btype(bt1) || is_integer_btype(bt2)) && op != '-') { |
if (op != TOK_LOR && op != TOK_LAND ) |
tcc_warning("comparison between pointer and integer"); |
return; |
} |
|
/* both must be pointers or implicit function pointers */ |
if (bt1 == VT_PTR) { |
type1 = pointed_type(type1); |
} else if (bt1 != VT_FUNC) |
goto invalid_operands; |
|
if (bt2 == VT_PTR) { |
type2 = pointed_type(type2); |
} else if (bt2 != VT_FUNC) { |
invalid_operands: |
tcc_error("invalid operands to binary %s", get_tok_str(op, NULL)); |
} |
if ((type1->t & VT_BTYPE) == VT_VOID || |
(type2->t & VT_BTYPE) == VT_VOID) |
return; |
tmp_type1 = *type1; |
tmp_type2 = *type2; |
tmp_type1.t &= ~(VT_DEFSIGN | VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE); |
tmp_type2.t &= ~(VT_DEFSIGN | VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE); |
if (!is_compatible_types(&tmp_type1, &tmp_type2)) { |
/* gcc-like error if '-' is used */ |
if (op == '-') |
goto invalid_operands; |
else |
tcc_warning("comparison of distinct pointer types lacks a cast"); |
} |
} |
|
/* generic gen_op: handles types problems */ |
ST_FUNC void gen_op(int op) |
{ |
int u, t1, t2, bt1, bt2, t; |
CType type1; |
|
t1 = vtop[-1].type.t; |
t2 = vtop[0].type.t; |
bt1 = t1 & VT_BTYPE; |
bt2 = t2 & VT_BTYPE; |
|
if (bt1 == VT_PTR || bt2 == VT_PTR) { |
/* at least one operand is a pointer */ |
/* relationnal op: must be both pointers */ |
if (op >= TOK_ULT && op <= TOK_LOR) { |
check_comparison_pointer_types(vtop - 1, vtop, op); |
/* pointers are handled are unsigned */ |
#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64) |
t = VT_LLONG | VT_UNSIGNED; |
#else |
t = VT_INT | VT_UNSIGNED; |
#endif |
goto std_op; |
} |
/* if both pointers, then it must be the '-' op */ |
if (bt1 == VT_PTR && bt2 == VT_PTR) { |
if (op != '-') |
tcc_error("cannot use pointers here"); |
check_comparison_pointer_types(vtop - 1, vtop, op); |
/* XXX: check that types are compatible */ |
if (vtop[-1].type.t & VT_VLA) { |
vla_runtime_pointed_size(&vtop[-1].type); |
} else { |
vpushi(pointed_size(&vtop[-1].type)); |
} |
vrott(3); |
gen_opic(op); |
/* set to integer type */ |
#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64) |
vtop->type.t = VT_LLONG; |
#else |
vtop->type.t = VT_INT; |
#endif |
vswap(); |
gen_op(TOK_PDIV); |
} else { |
/* exactly one pointer : must be '+' or '-'. */ |
if (op != '-' && op != '+') |
tcc_error("cannot use pointers here"); |
/* Put pointer as first operand */ |
if (bt2 == VT_PTR) { |
vswap(); |
swap(&t1, &t2); |
} |
type1 = vtop[-1].type; |
type1.t &= ~VT_ARRAY; |
if (vtop[-1].type.t & VT_VLA) |
vla_runtime_pointed_size(&vtop[-1].type); |
else { |
u = pointed_size(&vtop[-1].type); |
if (u < 0) |
tcc_error("unknown array element size"); |
#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64) |
vpushll(u); |
#else |
/* XXX: cast to int ? (long long case) */ |
vpushi(u); |
#endif |
} |
gen_op('*'); |
#if 0 |
/* #ifdef CONFIG_TCC_BCHECK |
The main reason to removing this code: |
#include <stdio.h> |
int main () |
{ |
int v[10]; |
int i = 10; |
int j = 9; |
fprintf(stderr, "v+i-j = %p\n", v+i-j); |
fprintf(stderr, "v+(i-j) = %p\n", v+(i-j)); |
} |
When this code is on. then the output looks like |
v+i-j = 0xfffffffe |
v+(i-j) = 0xbff84000 |
*/ |
/* if evaluating constant expression, no code should be |
generated, so no bound check */ |
if (tcc_state->do_bounds_check && !const_wanted) { |
/* if bounded pointers, we generate a special code to |
test bounds */ |
if (op == '-') { |
vpushi(0); |
vswap(); |
gen_op('-'); |
} |
gen_bounded_ptr_add(); |
} else |
#endif |
{ |
gen_opic(op); |
} |
/* put again type if gen_opic() swaped operands */ |
vtop->type = type1; |
} |
} else if (is_float(bt1) || is_float(bt2)) { |
/* compute bigger type and do implicit casts */ |
if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) { |
t = VT_LDOUBLE; |
} else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) { |
t = VT_DOUBLE; |
} else { |
t = VT_FLOAT; |
} |
/* floats can only be used for a few operations */ |
if (op != '+' && op != '-' && op != '*' && op != '/' && |
(op < TOK_ULT || op > TOK_GT)) |
tcc_error("invalid operands for binary operation"); |
goto std_op; |
} else if (op == TOK_SHR || op == TOK_SAR || op == TOK_SHL) { |
t = bt1 == VT_LLONG ? VT_LLONG : VT_INT; |
if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (t | VT_UNSIGNED)) |
t |= VT_UNSIGNED; |
goto std_op; |
} else if (bt1 == VT_LLONG || bt2 == VT_LLONG) { |
/* cast to biggest op */ |
t = VT_LLONG; |
/* convert to unsigned if it does not fit in a long long */ |
if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED) || |
(t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED)) |
t |= VT_UNSIGNED; |
goto std_op; |
} else if (bt1 == VT_STRUCT || bt2 == VT_STRUCT) { |
tcc_error("comparison of struct"); |
} else { |
/* integer operations */ |
t = VT_INT; |
/* convert to unsigned if it does not fit in an integer */ |
if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED) || |
(t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED)) |
t |= VT_UNSIGNED; |
std_op: |
/* XXX: currently, some unsigned operations are explicit, so |
we modify them here */ |
if (t & VT_UNSIGNED) { |
if (op == TOK_SAR) |
op = TOK_SHR; |
else if (op == '/') |
op = TOK_UDIV; |
else if (op == '%') |
op = TOK_UMOD; |
else if (op == TOK_LT) |
op = TOK_ULT; |
else if (op == TOK_GT) |
op = TOK_UGT; |
else if (op == TOK_LE) |
op = TOK_ULE; |
else if (op == TOK_GE) |
op = TOK_UGE; |
} |
vswap(); |
type1.t = t; |
gen_cast(&type1); |
vswap(); |
/* special case for shifts and long long: we keep the shift as |
an integer */ |
if (op == TOK_SHR || op == TOK_SAR || op == TOK_SHL) |
type1.t = VT_INT; |
gen_cast(&type1); |
if (is_float(t)) |
gen_opif(op); |
else |
gen_opic(op); |
if (op >= TOK_ULT && op <= TOK_GT) { |
/* relationnal op: the result is an int */ |
vtop->type.t = VT_INT; |
} else { |
vtop->type.t = t; |
} |
} |
// Make sure that we have converted to an rvalue: |
if (vtop->r & VT_LVAL && !nocode_wanted) |
gv(is_float(vtop->type.t & VT_BTYPE) ? RC_FLOAT : RC_INT); |
} |
|
#ifndef TCC_TARGET_ARM |
/* generic itof for unsigned long long case */ |
static void gen_cvt_itof1(int t) |
{ |
#ifdef TCC_TARGET_ARM64 |
gen_cvt_itof(t); |
#else |
if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) == |
(VT_LLONG | VT_UNSIGNED)) { |
|
if (t == VT_FLOAT) |
vpush_global_sym(&func_old_type, TOK___floatundisf); |
#if LDOUBLE_SIZE != 8 |
else if (t == VT_LDOUBLE) |
vpush_global_sym(&func_old_type, TOK___floatundixf); |
#endif |
else |
vpush_global_sym(&func_old_type, TOK___floatundidf); |
vrott(2); |
gfunc_call(1); |
vpushi(0); |
vtop->r = reg_fret(t); |
} else { |
gen_cvt_itof(t); |
} |
#endif |
} |
#endif |
|
/* generic ftoi for unsigned long long case */ |
static void gen_cvt_ftoi1(int t) |
{ |
#ifdef TCC_TARGET_ARM64 |
gen_cvt_ftoi(t); |
#else |
int st; |
|
if (t == (VT_LLONG | VT_UNSIGNED)) { |
/* not handled natively */ |
st = vtop->type.t & VT_BTYPE; |
if (st == VT_FLOAT) |
vpush_global_sym(&func_old_type, TOK___fixunssfdi); |
#if LDOUBLE_SIZE != 8 |
else if (st == VT_LDOUBLE) |
vpush_global_sym(&func_old_type, TOK___fixunsxfdi); |
#endif |
else |
vpush_global_sym(&func_old_type, TOK___fixunsdfdi); |
vrott(2); |
gfunc_call(1); |
vpushi(0); |
vtop->r = REG_IRET; |
vtop->r2 = REG_LRET; |
} else { |
gen_cvt_ftoi(t); |
} |
#endif |
} |
|
/* force char or short cast */ |
static void force_charshort_cast(int t) |
{ |
int bits, dbt; |
dbt = t & VT_BTYPE; |
/* XXX: add optimization if lvalue : just change type and offset */ |
if (dbt == VT_BYTE) |
bits = 8; |
else |
bits = 16; |
if (t & VT_UNSIGNED) { |
vpushi((1 << bits) - 1); |
gen_op('&'); |
} else { |
bits = 32 - bits; |
vpushi(bits); |
gen_op(TOK_SHL); |
/* result must be signed or the SAR is converted to an SHL |
This was not the case when "t" was a signed short |
and the last value on the stack was an unsigned int */ |
vtop->type.t &= ~VT_UNSIGNED; |
vpushi(bits); |
gen_op(TOK_SAR); |
} |
} |
|
/* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */ |
static void gen_cast(CType *type) |
{ |
int sbt, dbt, sf, df, c, p; |
|
/* special delayed cast for char/short */ |
/* XXX: in some cases (multiple cascaded casts), it may still |
be incorrect */ |
if (vtop->r & VT_MUSTCAST) { |
vtop->r &= ~VT_MUSTCAST; |
force_charshort_cast(vtop->type.t); |
} |
|
/* bitfields first get cast to ints */ |
if (vtop->type.t & VT_BITFIELD && !nocode_wanted) { |
gv(RC_INT); |
} |
|
dbt = type->t & (VT_BTYPE | VT_UNSIGNED); |
sbt = vtop->type.t & (VT_BTYPE | VT_UNSIGNED); |
|
if (sbt != dbt) { |
sf = is_float(sbt); |
df = is_float(dbt); |
c = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST; |
p = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == (VT_CONST | VT_SYM); |
if (c) { |
/* constant case: we can do it now */ |
/* XXX: in ISOC, cannot do it if error in convert */ |
if (sbt == VT_FLOAT) |
vtop->c.ld = vtop->c.f; |
else if (sbt == VT_DOUBLE) |
vtop->c.ld = vtop->c.d; |
|
if (df) { |
if ((sbt & VT_BTYPE) == VT_LLONG) { |
if ((sbt & VT_UNSIGNED) || !(vtop->c.i >> 63)) |
vtop->c.ld = vtop->c.i; |
else |
vtop->c.ld = -(long double)-vtop->c.i; |
} else if(!sf) { |
if ((sbt & VT_UNSIGNED) || !(vtop->c.i >> 31)) |
vtop->c.ld = (uint32_t)vtop->c.i; |
else |
vtop->c.ld = -(long double)-(uint32_t)vtop->c.i; |
} |
|
if (dbt == VT_FLOAT) |
vtop->c.f = (float)vtop->c.ld; |
else if (dbt == VT_DOUBLE) |
vtop->c.d = (double)vtop->c.ld; |
} else if (sf && dbt == (VT_LLONG|VT_UNSIGNED)) { |
vtop->c.i = vtop->c.ld; |
} else if (sf && dbt == VT_BOOL) { |
vtop->c.i = (vtop->c.ld != 0); |
} else { |
if(sf) |
vtop->c.i = vtop->c.ld; |
else if (sbt == (VT_LLONG|VT_UNSIGNED)) |
; |
else if (sbt & VT_UNSIGNED) |
vtop->c.i = (uint32_t)vtop->c.i; |
#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64) |
else if (sbt == VT_PTR) |
; |
#endif |
else if (sbt != VT_LLONG) |
vtop->c.i = ((uint32_t)vtop->c.i | |
-(vtop->c.i & 0x80000000)); |
|
if (dbt == (VT_LLONG|VT_UNSIGNED)) |
; |
else if (dbt == VT_BOOL) |
vtop->c.i = (vtop->c.i != 0); |
#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64) |
else if (dbt == VT_PTR) |
; |
#endif |
else if (dbt != VT_LLONG) { |
uint32_t m = ((dbt & VT_BTYPE) == VT_BYTE ? 0xff : |
(dbt & VT_BTYPE) == VT_SHORT ? 0xffff : |
0xffffffff); |
vtop->c.i &= m; |
if (!(dbt & VT_UNSIGNED)) |
vtop->c.i |= -(vtop->c.i & ((m >> 1) + 1)); |
} |
} |
} else if (p && dbt == VT_BOOL) { |
vtop->r = VT_CONST; |
vtop->c.i = 1; |
} else if (!nocode_wanted) { |
/* non constant case: generate code */ |
if (sf && df) { |
/* convert from fp to fp */ |
gen_cvt_ftof(dbt); |
} else if (df) { |
/* convert int to fp */ |
gen_cvt_itof1(dbt); |
} else if (sf) { |
/* convert fp to int */ |
if (dbt == VT_BOOL) { |
vpushi(0); |
gen_op(TOK_NE); |
} else { |
/* we handle char/short/etc... with generic code */ |
if (dbt != (VT_INT | VT_UNSIGNED) && |
dbt != (VT_LLONG | VT_UNSIGNED) && |
dbt != VT_LLONG) |
dbt = VT_INT; |
gen_cvt_ftoi1(dbt); |
if (dbt == VT_INT && (type->t & (VT_BTYPE | VT_UNSIGNED)) != dbt) { |
/* additional cast for char/short... */ |
vtop->type.t = dbt; |
gen_cast(type); |
} |
} |
#if !defined(TCC_TARGET_ARM64) && !defined(TCC_TARGET_X86_64) |
} else if ((dbt & VT_BTYPE) == VT_LLONG) { |
if ((sbt & VT_BTYPE) != VT_LLONG && !nocode_wanted) { |
/* scalar to long long */ |
/* machine independent conversion */ |
gv(RC_INT); |
/* generate high word */ |
if (sbt == (VT_INT | VT_UNSIGNED)) { |
vpushi(0); |
gv(RC_INT); |
} else { |
if (sbt == VT_PTR) { |
/* cast from pointer to int before we apply |
shift operation, which pointers don't support*/ |
gen_cast(&int_type); |
} |
gv_dup(); |
vpushi(31); |
gen_op(TOK_SAR); |
} |
/* patch second register */ |
vtop[-1].r2 = vtop->r; |
vpop(); |
} |
#else |
} else if ((dbt & VT_BTYPE) == VT_LLONG || |
(dbt & VT_BTYPE) == VT_PTR || |
(dbt & VT_BTYPE) == VT_FUNC) { |
if ((sbt & VT_BTYPE) != VT_LLONG && |
(sbt & VT_BTYPE) != VT_PTR && |
(sbt & VT_BTYPE) != VT_FUNC && !nocode_wanted) { |
/* need to convert from 32bit to 64bit */ |
gv(RC_INT); |
if (sbt != (VT_INT | VT_UNSIGNED)) { |
#if defined(TCC_TARGET_ARM64) |
gen_cvt_sxtw(); |
#elif defined(TCC_TARGET_X86_64) |
int r = gv(RC_INT); |
/* x86_64 specific: movslq */ |
o(0x6348); |
o(0xc0 + (REG_VALUE(r) << 3) + REG_VALUE(r)); |
#else |
#error |
#endif |
} |
} |
#endif |
} else if (dbt == VT_BOOL) { |
/* scalar to bool */ |
vpushi(0); |
gen_op(TOK_NE); |
} else if ((dbt & VT_BTYPE) == VT_BYTE || |
(dbt & VT_BTYPE) == VT_SHORT) { |
if (sbt == VT_PTR) { |
vtop->type.t = VT_INT; |
tcc_warning("nonportable conversion from pointer to char/short"); |
} |
force_charshort_cast(dbt); |
} else if ((dbt & VT_BTYPE) == VT_INT) { |
/* scalar to int */ |
if (sbt == VT_LLONG && !nocode_wanted) { |
/* from long long: just take low order word */ |
lexpand(); |
vpop(); |
} |
/* if lvalue and single word type, nothing to do because |
the lvalue already contains the real type size (see |
VT_LVAL_xxx constants) */ |
} |
} |
} else if ((dbt & VT_BTYPE) == VT_PTR && !(vtop->r & VT_LVAL)) { |
/* if we are casting between pointer types, |
we must update the VT_LVAL_xxx size */ |
vtop->r = (vtop->r & ~VT_LVAL_TYPE) |
| (lvalue_type(type->ref->type.t) & VT_LVAL_TYPE); |
} |
vtop->type = *type; |
} |
|
/* return type size as known at compile time. Put alignment at 'a' */ |
ST_FUNC int type_size(CType *type, int *a) |
{ |
Sym *s; |
int bt; |
|
bt = type->t & VT_BTYPE; |
if (bt == VT_STRUCT) { |
/* struct/union */ |
s = type->ref; |
*a = s->r; |
return s->c; |
} else if (bt == VT_PTR) { |
if (type->t & VT_ARRAY) { |
int ts; |
|
s = type->ref; |
ts = type_size(&s->type, a); |
|
if (ts < 0 && s->c < 0) |
ts = -ts; |
|
return ts * s->c; |
} else { |
*a = PTR_SIZE; |
return PTR_SIZE; |
} |
} else if (bt == VT_LDOUBLE) { |
*a = LDOUBLE_ALIGN; |
return LDOUBLE_SIZE; |
} else if (bt == VT_DOUBLE || bt == VT_LLONG) { |
#ifdef TCC_TARGET_I386 |
#ifdef TCC_TARGET_PE |
*a = 8; |
#else |
*a = 4; |
#endif |
#elif defined(TCC_TARGET_ARM) |
#ifdef TCC_ARM_EABI |
*a = 8; |
#else |
*a = 4; |
#endif |
#else |
*a = 8; |
#endif |
return 8; |
} else if (bt == VT_INT || bt == VT_FLOAT) { |
*a = 4; |
return 4; |
} else if (bt == VT_SHORT) { |
*a = 2; |
return 2; |
} else if (bt == VT_QLONG || bt == VT_QFLOAT) { |
*a = 8; |
return 16; |
} else if (bt == VT_ENUM) { |
*a = 4; |
/* Enums might be incomplete, so don't just return '4' here. */ |
return type->ref->c; |
} else { |
/* char, void, function, _Bool */ |
*a = 1; |
return 1; |
} |
} |
|
/* push type size as known at runtime time on top of value stack. Put |
alignment at 'a' */ |
ST_FUNC void vla_runtime_type_size(CType *type, int *a) |
{ |
if (type->t & VT_VLA) { |
vset(&int_type, VT_LOCAL|VT_LVAL, type->ref->c); |
} else { |
vpushi(type_size(type, a)); |
} |
} |
|
static void vla_sp_restore(void) { |
if (vlas_in_scope) { |
gen_vla_sp_restore(vla_sp_loc); |
} |
} |
|
static void vla_sp_restore_root(void) { |
if (vlas_in_scope) { |
gen_vla_sp_restore(vla_sp_root_loc); |
} |
} |
|
/* return the pointed type of t */ |
static inline CType *pointed_type(CType *type) |
{ |
return &type->ref->type; |
} |
|
/* modify type so that its it is a pointer to type. */ |
ST_FUNC void mk_pointer(CType *type) |
{ |
Sym *s; |
s = sym_push(SYM_FIELD, type, 0, -1); |
type->t = VT_PTR | (type->t & ~VT_TYPE); |
type->ref = s; |
} |
|
/* compare function types. OLD functions match any new functions */ |
static int is_compatible_func(CType *type1, CType *type2) |
{ |
Sym *s1, *s2; |
|
s1 = type1->ref; |
s2 = type2->ref; |
if (!is_compatible_types(&s1->type, &s2->type)) |
return 0; |
/* check func_call */ |
if (s1->a.func_call != s2->a.func_call) |
return 0; |
/* XXX: not complete */ |
if (s1->c == FUNC_OLD || s2->c == FUNC_OLD) |
return 1; |
if (s1->c != s2->c) |
return 0; |
while (s1 != NULL) { |
if (s2 == NULL) |
return 0; |
if (!is_compatible_parameter_types(&s1->type, &s2->type)) |
return 0; |
s1 = s1->next; |
s2 = s2->next; |
} |
if (s2) |
return 0; |
return 1; |
} |
|
/* return true if type1 and type2 are the same. If unqualified is |
true, qualifiers on the types are ignored. |
|
- enums are not checked as gcc __builtin_types_compatible_p () |
*/ |
static int compare_types(CType *type1, CType *type2, int unqualified) |
{ |
int bt1, t1, t2; |
|
t1 = type1->t & VT_TYPE; |
t2 = type2->t & VT_TYPE; |
if (unqualified) { |
/* strip qualifiers before comparing */ |
t1 &= ~(VT_CONSTANT | VT_VOLATILE); |
t2 &= ~(VT_CONSTANT | VT_VOLATILE); |
} |
/* Default Vs explicit signedness only matters for char */ |
if ((t1 & VT_BTYPE) != VT_BYTE) { |
t1 &= ~VT_DEFSIGN; |
t2 &= ~VT_DEFSIGN; |
} |
/* XXX: bitfields ? */ |
if (t1 != t2) |
return 0; |
/* test more complicated cases */ |
bt1 = t1 & VT_BTYPE; |
if (bt1 == VT_PTR) { |
type1 = pointed_type(type1); |
type2 = pointed_type(type2); |
return is_compatible_types(type1, type2); |
} else if (bt1 == VT_STRUCT) { |
return (type1->ref == type2->ref); |
} else if (bt1 == VT_FUNC) { |
return is_compatible_func(type1, type2); |
} else { |
return 1; |
} |
} |
|
/* return true if type1 and type2 are exactly the same (including |
qualifiers). |
*/ |
static int is_compatible_types(CType *type1, CType *type2) |
{ |
return compare_types(type1,type2,0); |
} |
|
/* return true if type1 and type2 are the same (ignoring qualifiers). |
*/ |
static int is_compatible_parameter_types(CType *type1, CType *type2) |
{ |
return compare_types(type1,type2,1); |
} |
|
/* print a type. If 'varstr' is not NULL, then the variable is also |
printed in the type */ |
/* XXX: union */ |
/* XXX: add array and function pointers */ |
static void type_to_str(char *buf, int buf_size, |
CType *type, const char *varstr) |
{ |
int bt, v, t; |
Sym *s, *sa; |
char buf1[256]; |
const char *tstr; |
|
t = type->t & VT_TYPE; |
bt = t & VT_BTYPE; |
buf[0] = '\0'; |
if (t & VT_CONSTANT) |
pstrcat(buf, buf_size, "const "); |
if (t & VT_VOLATILE) |
pstrcat(buf, buf_size, "volatile "); |
if ((t & (VT_DEFSIGN | VT_UNSIGNED)) == (VT_DEFSIGN | VT_UNSIGNED)) |
pstrcat(buf, buf_size, "unsigned "); |
else if (t & VT_DEFSIGN) |
pstrcat(buf, buf_size, "signed "); |
switch(bt) { |
case VT_VOID: |
tstr = "void"; |
goto add_tstr; |
case VT_BOOL: |
tstr = "_Bool"; |
goto add_tstr; |
case VT_BYTE: |
tstr = "char"; |
goto add_tstr; |
case VT_SHORT: |
tstr = "short"; |
goto add_tstr; |
case VT_INT: |
tstr = "int"; |
goto add_tstr; |
case VT_LONG: |
tstr = "long"; |
goto add_tstr; |
case VT_LLONG: |
tstr = "long long"; |
goto add_tstr; |
case VT_FLOAT: |
tstr = "float"; |
goto add_tstr; |
case VT_DOUBLE: |
tstr = "double"; |
goto add_tstr; |
case VT_LDOUBLE: |
tstr = "long double"; |
add_tstr: |
pstrcat(buf, buf_size, tstr); |
break; |
case VT_ENUM: |
case VT_STRUCT: |
if (bt == VT_STRUCT) |
tstr = "struct "; |
else |
tstr = "enum "; |
pstrcat(buf, buf_size, tstr); |
v = type->ref->v & ~SYM_STRUCT; |
if (v >= SYM_FIRST_ANOM) |
pstrcat(buf, buf_size, "<anonymous>"); |
else |
pstrcat(buf, buf_size, get_tok_str(v, NULL)); |
break; |
case VT_FUNC: |
s = type->ref; |
type_to_str(buf, buf_size, &s->type, varstr); |
pstrcat(buf, buf_size, "("); |
sa = s->next; |
while (sa != NULL) { |
type_to_str(buf1, sizeof(buf1), &sa->type, NULL); |
pstrcat(buf, buf_size, buf1); |
sa = sa->next; |
if (sa) |
pstrcat(buf, buf_size, ", "); |
} |
pstrcat(buf, buf_size, ")"); |
goto no_var; |
case VT_PTR: |
s = type->ref; |
if (t & VT_ARRAY) { |
snprintf(buf1, sizeof(buf1), "%s[%ld]", varstr ? varstr : "", s->c); |
type_to_str(buf, buf_size, &s->type, buf1); |
goto no_var; |
} |
pstrcpy(buf1, sizeof(buf1), "*"); |
if (t & VT_CONSTANT) |
pstrcat(buf1, buf_size, "const "); |
if (t & VT_VOLATILE) |
pstrcat(buf1, buf_size, "volatile "); |
if (varstr) |
pstrcat(buf1, sizeof(buf1), varstr); |
type_to_str(buf, buf_size, &s->type, buf1); |
goto no_var; |
} |
if (varstr) { |
pstrcat(buf, buf_size, " "); |
pstrcat(buf, buf_size, varstr); |
} |
no_var: ; |
} |
|
/* verify type compatibility to store vtop in 'dt' type, and generate |
casts if needed. */ |
static void gen_assign_cast(CType *dt) |
{ |
CType *st, *type1, *type2, tmp_type1, tmp_type2; |
char buf1[256], buf2[256]; |
int dbt, sbt; |
|
st = &vtop->type; /* source type */ |
dbt = dt->t & VT_BTYPE; |
sbt = st->t & VT_BTYPE; |
if (sbt == VT_VOID || dbt == VT_VOID) { |
if (sbt == VT_VOID && dbt == VT_VOID) |
; /* |
It is Ok if both are void |
A test program: |
void func1() {} |
void func2() { |
return func1(); |
} |
gcc accepts this program |
*/ |
else |
tcc_error("cannot cast from/to void"); |
} |
if (dt->t & VT_CONSTANT) |
tcc_warning("assignment of read-only location"); |
switch(dbt) { |
case VT_PTR: |
/* special cases for pointers */ |
/* '0' can also be a pointer */ |
if (is_null_pointer(vtop)) |
goto type_ok; |
/* accept implicit pointer to integer cast with warning */ |
if (is_integer_btype(sbt)) { |
tcc_warning("assignment makes pointer from integer without a cast"); |
goto type_ok; |
} |
type1 = pointed_type(dt); |
/* a function is implicitely a function pointer */ |
if (sbt == VT_FUNC) { |
if ((type1->t & VT_BTYPE) != VT_VOID && |
!is_compatible_types(pointed_type(dt), st)) |
tcc_warning("assignment from incompatible pointer type"); |
goto type_ok; |
} |
if (sbt != VT_PTR) |
goto error; |
type2 = pointed_type(st); |
if ((type1->t & VT_BTYPE) == VT_VOID || |
(type2->t & VT_BTYPE) == VT_VOID) { |
/* void * can match anything */ |
} else { |
/* exact type match, except for unsigned */ |
tmp_type1 = *type1; |
tmp_type2 = *type2; |
tmp_type1.t &= ~(VT_DEFSIGN | VT_UNSIGNED | VT_CONSTANT | |
VT_VOLATILE); |
tmp_type2.t &= ~(VT_DEFSIGN | VT_UNSIGNED | VT_CONSTANT | |
VT_VOLATILE); |
if (!is_compatible_types(&tmp_type1, &tmp_type2)) |
tcc_warning("assignment from incompatible pointer type"); |
} |
/* check const and volatile */ |
if ((!(type1->t & VT_CONSTANT) && (type2->t & VT_CONSTANT)) || |
(!(type1->t & VT_VOLATILE) && (type2->t & VT_VOLATILE))) |
tcc_warning("assignment discards qualifiers from pointer target type"); |
break; |
case VT_BYTE: |
case VT_SHORT: |
case VT_INT: |
case VT_LLONG: |
if (sbt == VT_PTR || sbt == VT_FUNC) { |
tcc_warning("assignment makes integer from pointer without a cast"); |
} |
/* XXX: more tests */ |
break; |
case VT_STRUCT: |
tmp_type1 = *dt; |
tmp_type2 = *st; |
tmp_type1.t &= ~(VT_CONSTANT | VT_VOLATILE); |
tmp_type2.t &= ~(VT_CONSTANT | VT_VOLATILE); |
if (!is_compatible_types(&tmp_type1, &tmp_type2)) { |
error: |
type_to_str(buf1, sizeof(buf1), st, NULL); |
type_to_str(buf2, sizeof(buf2), dt, NULL); |
tcc_error("cannot cast '%s' to '%s'", buf1, buf2); |
} |
break; |
} |
type_ok: |
gen_cast(dt); |
} |
|
/* store vtop in lvalue pushed on stack */ |
ST_FUNC void vstore(void) |
{ |
int sbt, dbt, ft, r, t, size, align, bit_size, bit_pos, rc, delayed_cast; |
|
ft = vtop[-1].type.t; |
sbt = vtop->type.t & VT_BTYPE; |
dbt = ft & VT_BTYPE; |
if ((((sbt == VT_INT || sbt == VT_SHORT) && dbt == VT_BYTE) || |
(sbt == VT_INT && dbt == VT_SHORT)) |
&& !(vtop->type.t & VT_BITFIELD)) { |
/* optimize char/short casts */ |
delayed_cast = VT_MUSTCAST; |
vtop->type.t = (ft & VT_TYPE & ~VT_BITFIELD & |
((1 << VT_STRUCT_SHIFT) - 1)); |
/* XXX: factorize */ |
if (ft & VT_CONSTANT) |
tcc_warning("assignment of read-only location"); |
} else { |
delayed_cast = 0; |
if (!(ft & VT_BITFIELD)) |
gen_assign_cast(&vtop[-1].type); |
} |
|
if (sbt == VT_STRUCT) { |
/* if structure, only generate pointer */ |
/* structure assignment : generate memcpy */ |
/* XXX: optimize if small size */ |
if (!nocode_wanted) { |
size = type_size(&vtop->type, &align); |
|
/* destination */ |
vswap(); |
vtop->type.t = VT_PTR; |
gaddrof(); |
|
/* address of memcpy() */ |
#ifdef TCC_ARM_EABI |
if(!(align & 7)) |
vpush_global_sym(&func_old_type, TOK_memcpy8); |
else if(!(align & 3)) |
vpush_global_sym(&func_old_type, TOK_memcpy4); |
else |
#endif |
/* Use memmove, rather than memcpy, as dest and src may be same: */ |
vpush_global_sym(&func_old_type, TOK_memmove); |
|
vswap(); |
/* source */ |
vpushv(vtop - 2); |
vtop->type.t = VT_PTR; |
gaddrof(); |
/* type size */ |
vpushi(size); |
gfunc_call(3); |
} else { |
vswap(); |
vpop(); |
} |
/* leave source on stack */ |
} else if (ft & VT_BITFIELD) { |
/* bitfield store handling */ |
|
/* save lvalue as expression result (example: s.b = s.a = n;) */ |
vdup(), vtop[-1] = vtop[-2]; |
|
bit_pos = (ft >> VT_STRUCT_SHIFT) & 0x3f; |
bit_size = (ft >> (VT_STRUCT_SHIFT + 6)) & 0x3f; |
/* remove bit field info to avoid loops */ |
vtop[-1].type.t = ft & ~VT_BITFIELD & ((1 << VT_STRUCT_SHIFT) - 1); |
|
if((ft & VT_BTYPE) == VT_BOOL) { |
gen_cast(&vtop[-1].type); |
vtop[-1].type.t = (vtop[-1].type.t & ~VT_BTYPE) | (VT_BYTE | VT_UNSIGNED); |
} |
|
/* duplicate destination */ |
vdup(); |
vtop[-1] = vtop[-2]; |
|
/* mask and shift source */ |
if((ft & VT_BTYPE) != VT_BOOL) { |
if((ft & VT_BTYPE) == VT_LLONG) { |
vpushll((1ULL << bit_size) - 1ULL); |
} else { |
vpushi((1 << bit_size) - 1); |
} |
gen_op('&'); |
} |
vpushi(bit_pos); |
gen_op(TOK_SHL); |
/* load destination, mask and or with source */ |
vswap(); |
if((ft & VT_BTYPE) == VT_LLONG) { |
vpushll(~(((1ULL << bit_size) - 1ULL) << bit_pos)); |
} else { |
vpushi(~(((1 << bit_size) - 1) << bit_pos)); |
} |
gen_op('&'); |
gen_op('|'); |
/* store result */ |
vstore(); |
/* ... and discard */ |
vpop(); |
|
} else { |
if (!nocode_wanted) { |
#ifdef CONFIG_TCC_BCHECK |
/* bound check case */ |
if (vtop[-1].r & VT_MUSTBOUND) { |
vswap(); |
gbound(); |
vswap(); |
} |
#endif |
rc = RC_INT; |
if (is_float(ft)) { |
rc = RC_FLOAT; |
#ifdef TCC_TARGET_X86_64 |
if ((ft & VT_BTYPE) == VT_LDOUBLE) { |
rc = RC_ST0; |
} else if ((ft & VT_BTYPE) == VT_QFLOAT) { |
rc = RC_FRET; |
} |
#endif |
} |
r = gv(rc); /* generate value */ |
/* if lvalue was saved on stack, must read it */ |
if ((vtop[-1].r & VT_VALMASK) == VT_LLOCAL) { |
SValue sv; |
t = get_reg(RC_INT); |
#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64) |
sv.type.t = VT_PTR; |
#else |
sv.type.t = VT_INT; |
#endif |
sv.r = VT_LOCAL | VT_LVAL; |
sv.c.i = vtop[-1].c.i; |
load(t, &sv); |
vtop[-1].r = t | VT_LVAL; |
} |
/* two word case handling : store second register at word + 4 (or +8 for x86-64) */ |
#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64) |
if (((ft & VT_BTYPE) == VT_QLONG) || ((ft & VT_BTYPE) == VT_QFLOAT)) { |
int addr_type = VT_LLONG, load_size = 8, load_type = ((vtop->type.t & VT_BTYPE) == VT_QLONG) ? VT_LLONG : VT_DOUBLE; |
#else |
if ((ft & VT_BTYPE) == VT_LLONG) { |
int addr_type = VT_INT, load_size = 4, load_type = VT_INT; |
#endif |
vtop[-1].type.t = load_type; |
store(r, vtop - 1); |
vswap(); |
/* convert to int to increment easily */ |
vtop->type.t = addr_type; |
gaddrof(); |
vpushi(load_size); |
gen_op('+'); |
vtop->r |= VT_LVAL; |
vswap(); |
vtop[-1].type.t = load_type; |
/* XXX: it works because r2 is spilled last ! */ |
store(vtop->r2, vtop - 1); |
} else { |
store(r, vtop - 1); |
} |
} |
vswap(); |
vtop--; /* NOT vpop() because on x86 it would flush the fp stack */ |
vtop->r |= delayed_cast; |
} |
} |
|
/* post defines POST/PRE add. c is the token ++ or -- */ |
ST_FUNC void inc(int post, int c) |
{ |
test_lvalue(); |
vdup(); /* save lvalue */ |
if (post) { |
if (!nocode_wanted) |
gv_dup(); /* duplicate value */ |
else |
vdup(); /* duplicate value */ |
vrotb(3); |
vrotb(3); |
} |
/* add constant */ |
vpushi(c - TOK_MID); |
gen_op('+'); |
vstore(); /* store value */ |
if (post) |
vpop(); /* if post op, return saved value */ |
} |
|
/* Parse GNUC __attribute__ extension. Currently, the following |
extensions are recognized: |
- aligned(n) : set data/function alignment. |
- packed : force data alignment to 1 |
- section(x) : generate data/code in this section. |
- unused : currently ignored, but may be used someday. |
- regparm(n) : pass function parameters in registers (i386 only) |
*/ |
static void parse_attribute(AttributeDef *ad) |
{ |
int t, n; |
|
while (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2) { |
next(); |
skip('('); |
skip('('); |
while (tok != ')') { |
if (tok < TOK_IDENT) |
expect("attribute name"); |
t = tok; |
next(); |
switch(t) { |
case TOK_SECTION1: |
case TOK_SECTION2: |
skip('('); |
if (tok != TOK_STR) |
expect("section name"); |
ad->section = find_section(tcc_state, (char *)tokc.str.data); |
next(); |
skip(')'); |
break; |
case TOK_ALIAS1: |
case TOK_ALIAS2: |
skip('('); |
if (tok != TOK_STR) |
expect("alias(\"target\")"); |
ad->alias_target = /* save string as token, for later */ |
tok_alloc((char*)tokc.str.data, tokc.str.size-1)->tok; |
next(); |
skip(')'); |
break; |
case TOK_VISIBILITY1: |
case TOK_VISIBILITY2: |
skip('('); |
if (tok != TOK_STR) |
expect("visibility(\"default|hidden|internal|protected\")"); |
if (!strcmp (tokc.str.data, "default")) |
ad->a.visibility = STV_DEFAULT; |
else if (!strcmp (tokc.str.data, "hidden")) |
ad->a.visibility = STV_HIDDEN; |
else if (!strcmp (tokc.str.data, "internal")) |
ad->a.visibility = STV_INTERNAL; |
else if (!strcmp (tokc.str.data, "protected")) |
ad->a.visibility = STV_PROTECTED; |
else |
expect("visibility(\"default|hidden|internal|protected\")"); |
next(); |
skip(')'); |
break; |
case TOK_ALIGNED1: |
case TOK_ALIGNED2: |
if (tok == '(') { |
next(); |
n = expr_const(); |
if (n <= 0 || (n & (n - 1)) != 0) |
tcc_error("alignment must be a positive power of two"); |
skip(')'); |
} else { |
n = MAX_ALIGN; |
} |
ad->a.aligned = n; |
break; |
case TOK_PACKED1: |
case TOK_PACKED2: |
ad->a.packed = 1; |
break; |
case TOK_WEAK1: |
case TOK_WEAK2: |
ad->a.weak = 1; |
break; |
case TOK_UNUSED1: |
case TOK_UNUSED2: |
/* currently, no need to handle it because tcc does not |
track unused objects */ |
break; |
case TOK_NORETURN1: |
case TOK_NORETURN2: |
/* currently, no need to handle it because tcc does not |
track unused objects */ |
break; |
case TOK_CDECL1: |
case TOK_CDECL2: |
case TOK_CDECL3: |
ad->a.func_call = FUNC_CDECL; |
break; |
case TOK_STDCALL1: |
case TOK_STDCALL2: |
case TOK_STDCALL3: |
ad->a.func_call = FUNC_STDCALL; |
break; |
#ifdef TCC_TARGET_I386 |
case TOK_REGPARM1: |
case TOK_REGPARM2: |
skip('('); |
n = expr_const(); |
if (n > 3) |
n = 3; |
else if (n < 0) |
n = 0; |
if (n > 0) |
ad->a.func_call = FUNC_FASTCALL1 + n - 1; |
skip(')'); |
break; |
case TOK_FASTCALL1: |
case TOK_FASTCALL2: |
case TOK_FASTCALL3: |
ad->a.func_call = FUNC_FASTCALLW; |
break; |
#endif |
case TOK_MODE: |
skip('('); |
switch(tok) { |
case TOK_MODE_DI: |
ad->a.mode = VT_LLONG + 1; |
break; |
case TOK_MODE_HI: |
ad->a.mode = VT_SHORT + 1; |
break; |
case TOK_MODE_SI: |
ad->a.mode = VT_INT + 1; |
break; |
default: |
tcc_warning("__mode__(%s) not supported\n", get_tok_str(tok, NULL)); |
break; |
} |
next(); |
skip(')'); |
break; |
case TOK_DLLEXPORT: |
ad->a.func_export = 1; |
break; |
case TOK_DLLIMPORT: |
ad->a.func_import = 1; |
break; |
default: |
if (tcc_state->warn_unsupported) |
tcc_warning("'%s' attribute ignored", get_tok_str(t, NULL)); |
/* skip parameters */ |
if (tok == '(') { |
int parenthesis = 0; |
do { |
if (tok == '(') |
parenthesis++; |
else if (tok == ')') |
parenthesis--; |
next(); |
} while (parenthesis && tok != -1); |
} |
break; |
} |
if (tok != ',') |
break; |
next(); |
} |
skip(')'); |
skip(')'); |
} |
} |
|
/* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */ |
static void struct_decl(CType *type, AttributeDef *ad, int u) |
{ |
int a, v, size, align, maxalign, c, offset, flexible; |
int bit_size, bit_pos, bsize, bt, lbit_pos, prevbt; |
Sym *s, *ss, *ass, **ps; |
AttributeDef ad1; |
CType type1, btype; |
|
a = tok; /* save decl type */ |
next(); |
if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2) { |
parse_attribute(ad); |
next(); |
} |
if (tok != '{') { |
v = tok; |
next(); |
/* struct already defined ? return it */ |
if (v < TOK_IDENT) |
expect("struct/union/enum name"); |
s = struct_find(v); |
if (s) { |
if (s->type.t != a) |
tcc_error("invalid type"); |
goto do_decl; |
} |
} else { |
v = anon_sym++; |
} |
type1.t = a; |
type1.ref = NULL; |
/* we put an undefined size for struct/union */ |
s = sym_push(v | SYM_STRUCT, &type1, 0, -1); |
s->r = 0; /* default alignment is zero as gcc */ |
/* put struct/union/enum name in type */ |
do_decl: |
type->t = u; |
type->ref = s; |
|
if (tok == '{') { |
next(); |
if (s->c != -1) |
tcc_error("struct/union/enum already defined"); |
/* cannot be empty */ |
c = 0; |
/* non empty enums are not allowed */ |
if (a == TOK_ENUM) { |
for(;;) { |
v = tok; |
if (v < TOK_UIDENT) |
expect("identifier"); |
ss = sym_find(v); |
if (ss && !local_stack) |
tcc_error("redefinition of enumerator '%s'", |
get_tok_str(v, NULL)); |
next(); |
if (tok == '=') { |
next(); |
c = expr_const(); |
} |
/* enum symbols have static storage */ |
ss = sym_push(v, &int_type, VT_CONST, c); |
ss->type.t |= VT_STATIC; |
if (tok != ',') |
break; |
next(); |
c++; |
/* NOTE: we accept a trailing comma */ |
if (tok == '}') |
break; |
} |
s->c = type_size(&int_type, &align); |
skip('}'); |
} else { |
maxalign = 1; |
ps = &s->next; |
prevbt = VT_INT; |
bit_pos = 0; |
offset = 0; |
flexible = 0; |
while (tok != '}') { |
parse_btype(&btype, &ad1); |
while (1) { |
if (flexible) |
tcc_error("flexible array member '%s' not at the end of struct", |
get_tok_str(v, NULL)); |
bit_size = -1; |
v = 0; |
type1 = btype; |
if (tok != ':') { |
type_decl(&type1, &ad1, &v, TYPE_DIRECT | TYPE_ABSTRACT); |
if (v == 0) { |
if ((type1.t & VT_BTYPE) != VT_STRUCT) |
expect("identifier"); |
else { |
int v = btype.ref->v; |
if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) { |
if (tcc_state->ms_extensions == 0) |
expect("identifier"); |
} |
} |
} |
if (type_size(&type1, &align) < 0) { |
if ((a == TOK_STRUCT) && (type1.t & VT_ARRAY) && c) |
flexible = 1; |
else |
tcc_error("field '%s' has incomplete type", |
get_tok_str(v, NULL)); |
} |
if ((type1.t & VT_BTYPE) == VT_FUNC || |
(type1.t & (VT_TYPEDEF | VT_STATIC | VT_EXTERN | VT_INLINE))) |
tcc_error("invalid type for '%s'", |
get_tok_str(v, NULL)); |
} |
if (tok == ':') { |
next(); |
bit_size = expr_const(); |
/* XXX: handle v = 0 case for messages */ |
if (bit_size < 0) |
tcc_error("negative width in bit-field '%s'", |
get_tok_str(v, NULL)); |
if (v && bit_size == 0) |
tcc_error("zero width for bit-field '%s'", |
get_tok_str(v, NULL)); |
} |
size = type_size(&type1, &align); |
if (ad1.a.aligned) { |
if (align < ad1.a.aligned) |
align = ad1.a.aligned; |
} else if (ad1.a.packed) { |
align = 1; |
} else if (*tcc_state->pack_stack_ptr) { |
if (align > *tcc_state->pack_stack_ptr) |
align = *tcc_state->pack_stack_ptr; |
} |
lbit_pos = 0; |
if (bit_size >= 0) { |
bt = type1.t & VT_BTYPE; |
if (bt != VT_INT && |
bt != VT_BYTE && |
bt != VT_SHORT && |
bt != VT_BOOL && |
bt != VT_ENUM && |
bt != VT_LLONG) |
tcc_error("bitfields must have scalar type"); |
bsize = size * 8; |
if (bit_size > bsize) { |
tcc_error("width of '%s' exceeds its type", |
get_tok_str(v, NULL)); |
} else if (bit_size == bsize) { |
/* no need for bit fields */ |
bit_pos = 0; |
} else if (bit_size == 0) { |
/* XXX: what to do if only padding in a |
structure ? */ |
/* zero size: means to pad */ |
bit_pos = 0; |
} else { |
/* we do not have enough room ? |
did the type change? |
is it a union? */ |
if ((bit_pos + bit_size) > bsize || |
bt != prevbt || a == TOK_UNION) |
bit_pos = 0; |
lbit_pos = bit_pos; |
/* XXX: handle LSB first */ |
type1.t |= VT_BITFIELD | |
(bit_pos << VT_STRUCT_SHIFT) | |
(bit_size << (VT_STRUCT_SHIFT + 6)); |
bit_pos += bit_size; |
} |
prevbt = bt; |
} else { |
bit_pos = 0; |
} |
if (v != 0 || (type1.t & VT_BTYPE) == VT_STRUCT) { |
/* add new memory data only if starting |
bit field */ |
if (lbit_pos == 0) { |
if (a == TOK_STRUCT) { |
c = (c + align - 1) & -align; |
offset = c; |
if (size > 0) |
c += size; |
} else { |
offset = 0; |
if (size > c) |
c = size; |
} |
if (align > maxalign) |
maxalign = align; |
} |
#if 0 |
printf("add field %s offset=%d", |
get_tok_str(v, NULL), offset); |
if (type1.t & VT_BITFIELD) { |
printf(" pos=%d size=%d", |
(type1.t >> VT_STRUCT_SHIFT) & 0x3f, |
(type1.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f); |
} |
printf("\n"); |
#endif |
} |
if (v == 0 && (type1.t & VT_BTYPE) == VT_STRUCT) { |
ass = type1.ref; |
while ((ass = ass->next) != NULL) { |
ss = sym_push(ass->v, &ass->type, 0, offset + ass->c); |
*ps = ss; |
ps = &ss->next; |
} |
} else if (v) { |
ss = sym_push(v | SYM_FIELD, &type1, 0, offset); |
*ps = ss; |
ps = &ss->next; |
} |
if (tok == ';' || tok == TOK_EOF) |
break; |
skip(','); |
} |
skip(';'); |
} |
skip('}'); |
/* store size and alignment */ |
s->c = (c + maxalign - 1) & -maxalign; |
s->r = maxalign; |
} |
} |
} |
|
/* return 1 if basic type is a type size (short, long, long long) */ |
ST_FUNC int is_btype_size(int bt) |
{ |
return bt == VT_SHORT || bt == VT_LONG || bt == VT_LLONG; |
} |
|
/* Add type qualifiers to a type. If the type is an array then the qualifiers |
are added to the element type, copied because it could be a typedef. */ |
static void parse_btype_qualify(CType *type, int qualifiers) |
{ |
while (type->t & VT_ARRAY) { |
type->ref = sym_push(SYM_FIELD, &type->ref->type, 0, type->ref->c); |
type = &type->ref->type; |
} |
type->t |= qualifiers; |
} |
|
/* return 0 if no type declaration. otherwise, return the basic type |
and skip it. |
*/ |
static int parse_btype(CType *type, AttributeDef *ad) |
{ |
int t, u, bt_size, complete, type_found, typespec_found; |
Sym *s; |
CType type1; |
|
memset(ad, 0, sizeof(AttributeDef)); |
complete = 0; |
type_found = 0; |
typespec_found = 0; |
t = 0; |
while(1) { |
switch(tok) { |
case TOK_EXTENSION: |
/* currently, we really ignore extension */ |
next(); |
continue; |
|
/* basic types */ |
case TOK_CHAR: |
u = VT_BYTE; |
basic_type: |
next(); |
basic_type1: |
if (complete) |
tcc_error("too many basic types"); |
t |= u; |
bt_size = is_btype_size (u & VT_BTYPE); |
if (u == VT_INT || (!bt_size && !(t & VT_TYPEDEF))) |
complete = 1; |
typespec_found = 1; |
break; |
case TOK_VOID: |
u = VT_VOID; |
goto basic_type; |
case TOK_SHORT: |
u = VT_SHORT; |
goto basic_type; |
case TOK_INT: |
u = VT_INT; |
goto basic_type; |
case TOK_LONG: |
next(); |
if ((t & VT_BTYPE) == VT_DOUBLE) { |
/* siemargl not sure, needed long double or will fail ? FAIL */ |
#if !defined(TCC_TARGET_PE) && !defined(TCC_TARGET_MEOS) |
t = (t & ~VT_BTYPE) | VT_LDOUBLE; |
#endif |
} else if ((t & VT_BTYPE) == VT_LONG) { |
t = (t & ~VT_BTYPE) | VT_LLONG; |
} else { |
u = VT_LONG; |
goto basic_type1; |
} |
break; |
#ifdef TCC_TARGET_ARM64 |
case TOK_UINT128: |
/* GCC's __uint128_t appears in some Linux header files. Make it a |
synonym for long double to get the size and alignment right. */ |
u = VT_LDOUBLE; |
goto basic_type; |
#endif |
case TOK_BOOL: |
u = VT_BOOL; |
goto basic_type; |
case TOK_FLOAT: |
u = VT_FLOAT; |
goto basic_type; |
case TOK_DOUBLE: |
next(); |
if ((t & VT_BTYPE) == VT_LONG) { |
/* siemargl not sure, needed long double or will fail ? FAIL */ |
#if defined(TCC_TARGET_PE) || defined(TCC_TARGET_MEOS) |
t = (t & ~VT_BTYPE) | VT_DOUBLE; |
#else |
t = (t & ~VT_BTYPE) | VT_LDOUBLE; |
#endif |
} else { |
u = VT_DOUBLE; |
goto basic_type1; |
} |
break; |
case TOK_ENUM: |
struct_decl(&type1, ad, VT_ENUM); |
basic_type2: |
u = type1.t; |
type->ref = type1.ref; |
goto basic_type1; |
case TOK_STRUCT: |
case TOK_UNION: |
struct_decl(&type1, ad, VT_STRUCT); |
goto basic_type2; |
|
/* type modifiers */ |
case TOK_CONST1: |
case TOK_CONST2: |
case TOK_CONST3: |
type->t = t; |
parse_btype_qualify(type, VT_CONSTANT); |
t = type->t; |
next(); |
break; |
case TOK_VOLATILE1: |
case TOK_VOLATILE2: |
case TOK_VOLATILE3: |
type->t = t; |
parse_btype_qualify(type, VT_VOLATILE); |
t = type->t; |
next(); |
break; |
case TOK_SIGNED1: |
case TOK_SIGNED2: |
case TOK_SIGNED3: |
if ((t & (VT_DEFSIGN|VT_UNSIGNED)) == (VT_DEFSIGN|VT_UNSIGNED)) |
tcc_error("signed and unsigned modifier"); |
typespec_found = 1; |
t |= VT_DEFSIGN; |
next(); |
break; |
case TOK_REGISTER: |
case TOK_AUTO: |
case TOK_RESTRICT1: |
case TOK_RESTRICT2: |
case TOK_RESTRICT3: |
next(); |
break; |
case TOK_UNSIGNED: |
if ((t & (VT_DEFSIGN|VT_UNSIGNED)) == VT_DEFSIGN) |
tcc_error("signed and unsigned modifier"); |
t |= VT_DEFSIGN | VT_UNSIGNED; |
next(); |
typespec_found = 1; |
break; |
|
/* storage */ |
case TOK_EXTERN: |
t |= VT_EXTERN; |
next(); |
break; |
case TOK_STATIC: |
t |= VT_STATIC; |
next(); |
break; |
case TOK_TYPEDEF: |
t |= VT_TYPEDEF; |
next(); |
break; |
case TOK_INLINE1: |
case TOK_INLINE2: |
case TOK_INLINE3: |
t |= VT_INLINE; |
next(); |
break; |
|
/* GNUC attribute */ |
case TOK_ATTRIBUTE1: |
case TOK_ATTRIBUTE2: |
parse_attribute(ad); |
if (ad->a.mode) { |
u = ad->a.mode -1; |
t = (t & ~VT_BTYPE) | u; |
} |
break; |
/* GNUC typeof */ |
case TOK_TYPEOF1: |
case TOK_TYPEOF2: |
case TOK_TYPEOF3: |
next(); |
parse_expr_type(&type1); |
/* remove all storage modifiers except typedef */ |
type1.t &= ~(VT_STORAGE&~VT_TYPEDEF); |
goto basic_type2; |
default: |
if (typespec_found) |
goto the_end; |
s = sym_find(tok); |
if (!s || !(s->type.t & VT_TYPEDEF)) |
goto the_end; |
|
type->t = ((s->type.t & ~VT_TYPEDEF) | |
(t & ~(VT_CONSTANT | VT_VOLATILE))); |
type->ref = s->type.ref; |
if (t & (VT_CONSTANT | VT_VOLATILE)) |
parse_btype_qualify(type, t & (VT_CONSTANT | VT_VOLATILE)); |
t = type->t; |
|
if (s->r) { |
/* get attributes from typedef */ |
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; |
break; |
} |
type_found = 1; |
} |
the_end: |
if (tcc_state->char_is_unsigned) { |
if ((t & (VT_DEFSIGN|VT_BTYPE)) == VT_BYTE) |
t |= VT_UNSIGNED; |
} |
|
/* long is never used as type */ |
if ((t & VT_BTYPE) == VT_LONG) |
#if (!defined TCC_TARGET_X86_64 && !defined TCC_TARGET_ARM64) || \ |
defined TCC_TARGET_PE || defined TCC_TARGET_MEOS |
t = (t & ~VT_BTYPE) | VT_INT; |
#else |
t = (t & ~VT_BTYPE) | VT_LLONG; |
#endif |
type->t = t; |
return type_found; |
} |
|
/* convert a function parameter type (array to pointer and function to |
function pointer) */ |
static inline void convert_parameter_type(CType *pt) |
{ |
/* remove const and volatile qualifiers (XXX: const could be used |
to indicate a const function parameter */ |
pt->t &= ~(VT_CONSTANT | VT_VOLATILE); |
/* array must be transformed to pointer according to ANSI C */ |
pt->t &= ~VT_ARRAY; |
if ((pt->t & VT_BTYPE) == VT_FUNC) { |
mk_pointer(pt); |
} |
} |
|
ST_FUNC void parse_asm_str(CString *astr) |
{ |
skip('('); |
/* read the string */ |
if (tok != TOK_STR) |
expect("string constant"); |
cstr_new(astr); |
while (tok == TOK_STR) { |
/* XXX: add \0 handling too ? */ |
cstr_cat(astr, tokc.str.data, -1); |
next(); |
} |
cstr_ccat(astr, '\0'); |
} |
|
/* Parse an asm label and return the token */ |
static int asm_label_instr(void) |
{ |
int v; |
CString astr; |
|
next(); |
parse_asm_str(&astr); |
skip(')'); |
#ifdef ASM_DEBUG |
printf("asm_alias: \"%s\"\n", (char *)astr.data); |
#endif |
v = tok_alloc(astr.data, astr.size - 1)->tok; |
cstr_free(&astr); |
return v; |
} |
|
static void post_type(CType *type, AttributeDef *ad) |
{ |
int n, l, t1, arg_size, align; |
Sym **plast, *s, *first; |
AttributeDef ad1; |
CType pt; |
|
if (tok == '(') { |
/* function declaration */ |
next(); |
l = 0; |
first = NULL; |
plast = &first; |
arg_size = 0; |
if (tok != ')') { |
for(;;) { |
/* read param name and compute offset */ |
if (l != FUNC_OLD) { |
if (!parse_btype(&pt, &ad1)) { |
if (l) { |
tcc_error("invalid type"); |
} else { |
l = FUNC_OLD; |
goto old_proto; |
} |
} |
l = FUNC_NEW; |
if ((pt.t & VT_BTYPE) == VT_VOID && tok == ')') |
break; |
type_decl(&pt, &ad1, &n, TYPE_DIRECT | TYPE_ABSTRACT); |
if ((pt.t & VT_BTYPE) == VT_VOID) |
tcc_error("parameter declared as void"); |
arg_size += (type_size(&pt, &align) + PTR_SIZE - 1) / PTR_SIZE; |
} else { |
old_proto: |
n = tok; |
if (n < TOK_UIDENT) |
expect("identifier"); |
pt.t = VT_INT; |
next(); |
} |
convert_parameter_type(&pt); |
s = sym_push(n | SYM_FIELD, &pt, 0, 0); |
*plast = s; |
plast = &s->next; |
if (tok == ')') |
break; |
skip(','); |
if (l == FUNC_NEW && tok == TOK_DOTS) { |
l = FUNC_ELLIPSIS; |
next(); |
break; |
} |
} |
} |
/* if no parameters, then old type prototype */ |
if (l == 0) |
l = FUNC_OLD; |
skip(')'); |
/* NOTE: const is ignored in returned type as it has a special |
meaning in gcc / C++ */ |
type->t &= ~VT_CONSTANT; |
/* some ancient pre-K&R C allows a function to return an array |
and the array brackets to be put after the arguments, such |
that "int c()[]" means something like "int[] c()" */ |
if (tok == '[') { |
next(); |
skip(']'); /* only handle simple "[]" */ |
type->t |= VT_PTR; |
} |
/* we push a anonymous symbol which will contain the function prototype */ |
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; |
} else if (tok == '[') { |
/* array definition */ |
next(); |
if (tok == TOK_RESTRICT1) |
next(); |
n = -1; |
t1 = 0; |
if (tok != ']') { |
if (!local_stack || nocode_wanted) |
vpushi(expr_const()); |
else gexpr(); |
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) { |
n = vtop->c.i; |
if (n < 0) |
tcc_error("invalid array size"); |
} else { |
if (!is_integer_btype(vtop->type.t & VT_BTYPE)) |
tcc_error("size of variable length array should be an integer"); |
t1 = VT_VLA; |
} |
} |
skip(']'); |
/* parse next post type */ |
post_type(type, ad); |
if (type->t == VT_FUNC) |
tcc_error("declaration of an array of functions"); |
t1 |= type->t & VT_VLA; |
|
if (t1 & VT_VLA) { |
loc -= type_size(&int_type, &align); |
loc &= -align; |
n = loc; |
|
vla_runtime_type_size(type, &align); |
gen_op('*'); |
vset(&int_type, VT_LOCAL|VT_LVAL, n); |
vswap(); |
vstore(); |
} |
if (n != -1) |
vpop(); |
|
/* we push an anonymous symbol which will contain the array |
element type */ |
s = sym_push(SYM_FIELD, type, 0, n); |
type->t = (t1 ? VT_VLA : VT_ARRAY) | VT_PTR; |
type->ref = s; |
} |
} |
|
/* Parse a type declaration (except basic type), and return the type |
in 'type'. 'td' is a bitmask indicating which kind of type decl is |
expected. 'type' should contain the basic type. 'ad' is the |
attribute definition of the basic type. It can be modified by |
type_decl(). |
*/ |
static void type_decl(CType *type, AttributeDef *ad, int *v, int td) |
{ |
Sym *s; |
CType type1, *type2; |
int qualifiers, storage; |
|
while (tok == '*') { |
qualifiers = 0; |
redo: |
next(); |
switch(tok) { |
case TOK_CONST1: |
case TOK_CONST2: |
case TOK_CONST3: |
qualifiers |= VT_CONSTANT; |
goto redo; |
case TOK_VOLATILE1: |
case TOK_VOLATILE2: |
case TOK_VOLATILE3: |
qualifiers |= VT_VOLATILE; |
goto redo; |
case TOK_RESTRICT1: |
case TOK_RESTRICT2: |
case TOK_RESTRICT3: |
goto redo; |
} |
mk_pointer(type); |
type->t |= qualifiers; |
} |
|
/* XXX: clarify attribute handling */ |
if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2) |
parse_attribute(ad); |
|
/* recursive type */ |
/* XXX: incorrect if abstract type for functions (e.g. 'int ()') */ |
type1.t = 0; /* XXX: same as int */ |
if (tok == '(') { |
next(); |
/* XXX: this is not correct to modify 'ad' at this point, but |
the syntax is not clear */ |
if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2) |
parse_attribute(ad); |
type_decl(&type1, ad, v, td); |
skip(')'); |
} else { |
/* type identifier */ |
if (tok >= TOK_IDENT && (td & TYPE_DIRECT)) { |
*v = tok; |
next(); |
} else { |
if (!(td & TYPE_ABSTRACT)) |
expect("identifier"); |
*v = 0; |
} |
} |
storage = type->t & VT_STORAGE; |
type->t &= ~VT_STORAGE; |
if (storage & VT_STATIC) { |
int saved_nocode_wanted = nocode_wanted; |
nocode_wanted = 1; |
post_type(type, ad); |
nocode_wanted = saved_nocode_wanted; |
} else |
post_type(type, ad); |
type->t |= storage; |
if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2) |
parse_attribute(ad); |
|
if (!type1.t) |
return; |
/* append type at the end of type1 */ |
type2 = &type1; |
for(;;) { |
s = type2->ref; |
type2 = &s->type; |
if (!type2->t) { |
*type2 = *type; |
break; |
} |
} |
*type = type1; |
} |
|
/* compute the lvalue VT_LVAL_xxx needed to match type t. */ |
ST_FUNC int lvalue_type(int t) |
{ |
int bt, r; |
r = VT_LVAL; |
bt = t & VT_BTYPE; |
if (bt == VT_BYTE || bt == VT_BOOL) |
r |= VT_LVAL_BYTE; |
else if (bt == VT_SHORT) |
r |= VT_LVAL_SHORT; |
else |
return r; |
if (t & VT_UNSIGNED) |
r |= VT_LVAL_UNSIGNED; |
return r; |
} |
|
/* indirection with full error checking and bound check */ |
ST_FUNC void indir(void) |
{ |
if ((vtop->type.t & VT_BTYPE) != VT_PTR) { |
if ((vtop->type.t & VT_BTYPE) == VT_FUNC) |
return; |
expect("pointer"); |
} |
if ((vtop->r & VT_LVAL) && !nocode_wanted) |
gv(RC_INT); |
vtop->type = *pointed_type(&vtop->type); |
/* Arrays and functions are never lvalues */ |
if (!(vtop->type.t & VT_ARRAY) && !(vtop->type.t & VT_VLA) |
&& (vtop->type.t & VT_BTYPE) != VT_FUNC) { |
vtop->r |= lvalue_type(vtop->type.t); |
/* if bound checking, the referenced pointer must be checked */ |
#ifdef CONFIG_TCC_BCHECK |
if (tcc_state->do_bounds_check) |
vtop->r |= VT_MUSTBOUND; |
#endif |
} |
} |
|
/* pass a parameter to a function and do type checking and casting */ |
static void gfunc_param_typed(Sym *func, Sym *arg) |
{ |
int func_type; |
CType type; |
|
func_type = func->c; |
if (func_type == FUNC_OLD || |
(func_type == FUNC_ELLIPSIS && arg == NULL)) { |
/* default casting : only need to convert float to double */ |
if ((vtop->type.t & VT_BTYPE) == VT_FLOAT) { |
type.t = VT_DOUBLE; |
gen_cast(&type); |
} else if (vtop->type.t & VT_BITFIELD) { |
type.t = vtop->type.t & (VT_BTYPE | VT_UNSIGNED); |
gen_cast(&type); |
} |
} else if (arg == NULL) { |
tcc_error("too many arguments to function"); |
} else { |
type = arg->type; |
type.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */ |
gen_assign_cast(&type); |
} |
} |
|
/* parse an expression of the form '(type)' or '(expr)' and return its |
type */ |
static void parse_expr_type(CType *type) |
{ |
int n; |
AttributeDef ad; |
|
skip('('); |
if (parse_btype(type, &ad)) { |
type_decl(type, &ad, &n, TYPE_ABSTRACT); |
} else { |
expr_type(type); |
} |
skip(')'); |
} |
|
static void parse_type(CType *type) |
{ |
AttributeDef ad; |
int n; |
|
if (!parse_btype(type, &ad)) { |
expect("type"); |
} |
type_decl(type, &ad, &n, TYPE_ABSTRACT); |
} |
|
static void vpush_tokc(int t) |
{ |
CType type; |
type.t = t; |
type.ref = 0; |
vsetc(&type, VT_CONST, &tokc); |
} |
|
ST_FUNC void unary(void) |
{ |
int n, t, align, size, r, sizeof_caller; |
CType type; |
Sym *s; |
AttributeDef ad; |
static int in_sizeof = 0; |
|
sizeof_caller = in_sizeof; |
in_sizeof = 0; |
/* XXX: GCC 2.95.3 does not generate a table although it should be |
better here */ |
tok_next: |
switch(tok) { |
case TOK_EXTENSION: |
next(); |
goto tok_next; |
case TOK_CINT: |
case TOK_CCHAR: |
case TOK_LCHAR: |
vpushi(tokc.i); |
next(); |
break; |
case TOK_CUINT: |
vpush_tokc(VT_INT | VT_UNSIGNED); |
next(); |
break; |
case TOK_CLLONG: |
vpush_tokc(VT_LLONG); |
next(); |
break; |
case TOK_CULLONG: |
vpush_tokc(VT_LLONG | VT_UNSIGNED); |
next(); |
break; |
case TOK_CFLOAT: |
vpush_tokc(VT_FLOAT); |
next(); |
break; |
case TOK_CDOUBLE: |
vpush_tokc(VT_DOUBLE); |
next(); |
break; |
case TOK_CLDOUBLE: |
vpush_tokc(VT_LDOUBLE); |
next(); |
break; |
case TOK___FUNCTION__: |
if (!gnu_ext) |
goto tok_identifier; |
/* fall thru */ |
case TOK___FUNC__: |
{ |
void *ptr; |
int len; |
/* special function name identifier */ |
len = strlen(funcname) + 1; |
/* generate char[len] type */ |
type.t = VT_BYTE; |
mk_pointer(&type); |
type.t |= VT_ARRAY; |
type.ref->c = len; |
vpush_ref(&type, data_section, data_section->data_offset, len); |
ptr = section_ptr_add(data_section, len); |
memcpy(ptr, funcname, len); |
next(); |
} |
break; |
case TOK_LSTR: |
#ifdef TCC_TARGET_PE |
t = VT_SHORT | VT_UNSIGNED; |
#else |
t = VT_INT; |
#endif |
goto str_init; |
case TOK_STR: |
/* string parsing */ |
t = VT_BYTE; |
str_init: |
if (tcc_state->warn_write_strings) |
t |= VT_CONSTANT; |
type.t = t; |
mk_pointer(&type); |
type.t |= VT_ARRAY; |
memset(&ad, 0, sizeof(AttributeDef)); |
decl_initializer_alloc(&type, &ad, VT_CONST, 2, 0, 0); |
break; |
case '(': |
next(); |
/* cast ? */ |
if (parse_btype(&type, &ad)) { |
type_decl(&type, &ad, &n, TYPE_ABSTRACT); |
skip(')'); |
/* check ISOC99 compound literal */ |
if (tok == '{') { |
/* data is allocated locally by default */ |
if (global_expr) |
r = VT_CONST; |
else |
r = VT_LOCAL; |
/* all except arrays are lvalues */ |
if (!(type.t & VT_ARRAY)) |
r |= lvalue_type(type.t); |
memset(&ad, 0, sizeof(AttributeDef)); |
decl_initializer_alloc(&type, &ad, r, 1, 0, 0); |
} else { |
if (sizeof_caller) { |
vpush(&type); |
return; |
} |
unary(); |
gen_cast(&type); |
} |
} else if (tok == '{') { |
if (const_wanted) |
tcc_error("expected constant"); |
/* save all registers */ |
if (!nocode_wanted) |
save_regs(0); |
/* statement expression : we do not accept break/continue |
inside as GCC does */ |
block(NULL, NULL, NULL, NULL, 0, 1); |
skip(')'); |
} else { |
gexpr(); |
skip(')'); |
} |
break; |
case '*': |
next(); |
unary(); |
indir(); |
break; |
case '&': |
next(); |
unary(); |
/* functions names must be treated as function pointers, |
except for unary '&' and sizeof. Since we consider that |
functions are not lvalues, we only have to handle it |
there and in function calls. */ |
/* arrays can also be used although they are not lvalues */ |
if ((vtop->type.t & VT_BTYPE) != VT_FUNC && |
!(vtop->type.t & VT_ARRAY) && !(vtop->type.t & VT_LLOCAL)) |
test_lvalue(); |
mk_pointer(&vtop->type); |
gaddrof(); |
break; |
case '!': |
next(); |
unary(); |
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) { |
CType boolean; |
boolean.t = VT_BOOL; |
gen_cast(&boolean); |
vtop->c.i = !vtop->c.i; |
} else if ((vtop->r & VT_VALMASK) == VT_CMP) |
vtop->c.i ^= 1; |
else { |
save_regs(1); |
vseti(VT_JMP, gvtst(1, 0)); |
} |
break; |
case '~': |
next(); |
unary(); |
vpushi(-1); |
gen_op('^'); |
break; |
case '+': |
next(); |
unary(); |
if ((vtop->type.t & VT_BTYPE) == VT_PTR) |
tcc_error("pointer not accepted for unary plus"); |
/* In order to force cast, we add zero, except for floating point |
where we really need an noop (otherwise -0.0 will be transformed |
into +0.0). */ |
if (!is_float(vtop->type.t)) { |
vpushi(0); |
gen_op('+'); |
} |
break; |
case TOK_SIZEOF: |
case TOK_ALIGNOF1: |
case TOK_ALIGNOF2: |
t = tok; |
next(); |
in_sizeof++; |
unary_type(&type); // Perform a in_sizeof = 0; |
size = type_size(&type, &align); |
if (t == TOK_SIZEOF) { |
if (!(type.t & VT_VLA)) { |
if (size < 0) |
tcc_error("sizeof applied to an incomplete type"); |
vpushs(size); |
} else { |
vla_runtime_type_size(&type, &align); |
} |
} else { |
vpushs(align); |
} |
vtop->type.t |= VT_UNSIGNED; |
break; |
|
case TOK_builtin_expect: |
{ |
/* __builtin_expect is a no-op for now */ |
int saved_nocode_wanted; |
next(); |
skip('('); |
expr_eq(); |
skip(','); |
saved_nocode_wanted = nocode_wanted; |
nocode_wanted = 1; |
expr_lor_const(); |
vpop(); |
nocode_wanted = saved_nocode_wanted; |
skip(')'); |
} |
break; |
case TOK_builtin_types_compatible_p: |
{ |
CType type1, type2; |
next(); |
skip('('); |
parse_type(&type1); |
skip(','); |
parse_type(&type2); |
skip(')'); |
type1.t &= ~(VT_CONSTANT | VT_VOLATILE); |
type2.t &= ~(VT_CONSTANT | VT_VOLATILE); |
vpushi(is_compatible_types(&type1, &type2)); |
} |
break; |
case TOK_builtin_constant_p: |
{ |
int saved_nocode_wanted, res; |
next(); |
skip('('); |
saved_nocode_wanted = nocode_wanted; |
nocode_wanted = 1; |
gexpr(); |
res = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST; |
vpop(); |
nocode_wanted = saved_nocode_wanted; |
skip(')'); |
vpushi(res); |
} |
break; |
case TOK_builtin_frame_address: |
case TOK_builtin_return_address: |
{ |
int tok1 = tok; |
int level; |
CType type; |
next(); |
skip('('); |
if (tok != TOK_CINT) { |
tcc_error("%s only takes positive integers", |
tok1 == TOK_builtin_return_address ? |
"__builtin_return_address" : |
"__builtin_frame_address"); |
} |
level = (uint32_t)tokc.i; |
next(); |
skip(')'); |
type.t = VT_VOID; |
mk_pointer(&type); |
vset(&type, VT_LOCAL, 0); /* local frame */ |
while (level--) { |
mk_pointer(&vtop->type); |
indir(); /* -> parent frame */ |
} |
if (tok1 == TOK_builtin_return_address) { |
// assume return address is just above frame pointer on stack |
vpushi(PTR_SIZE); |
gen_op('+'); |
mk_pointer(&vtop->type); |
indir(); |
} |
} |
break; |
#ifdef TCC_TARGET_X86_64 |
#ifdef TCC_TARGET_PE |
case TOK_builtin_va_start: |
{ |
next(); |
skip('('); |
expr_eq(); |
skip(','); |
expr_eq(); |
skip(')'); |
if ((vtop->r & VT_VALMASK) != VT_LOCAL) |
tcc_error("__builtin_va_start expects a local variable"); |
vtop->r &= ~(VT_LVAL | VT_REF); |
vtop->type = char_pointer_type; |
vstore(); |
} |
break; |
#else |
case TOK_builtin_va_arg_types: |
{ |
CType type; |
next(); |
skip('('); |
parse_type(&type); |
skip(')'); |
vpushi(classify_x86_64_va_arg(&type)); |
} |
break; |
#endif |
#endif |
|
#ifdef TCC_TARGET_ARM64 |
case TOK___va_start: { |
if (nocode_wanted) |
tcc_error("statement in global scope"); |
next(); |
skip('('); |
expr_eq(); |
skip(','); |
expr_eq(); |
skip(')'); |
//xx check types |
gen_va_start(); |
vpushi(0); |
vtop->type.t = VT_VOID; |
break; |
} |
case TOK___va_arg: { |
CType type; |
if (nocode_wanted) |
tcc_error("statement in global scope"); |
next(); |
skip('('); |
expr_eq(); |
skip(','); |
parse_type(&type); |
skip(')'); |
//xx check types |
gen_va_arg(&type); |
vtop->type = type; |
break; |
} |
case TOK___arm64_clear_cache: { |
next(); |
skip('('); |
expr_eq(); |
skip(','); |
expr_eq(); |
skip(')'); |
gen_clear_cache(); |
vpushi(0); |
vtop->type.t = VT_VOID; |
break; |
} |
#endif |
/* pre operations */ |
case TOK_INC: |
case TOK_DEC: |
t = tok; |
next(); |
unary(); |
inc(0, t); |
break; |
case '-': |
next(); |
unary(); |
t = vtop->type.t & VT_BTYPE; |
if (is_float(t)) { |
/* In IEEE negate(x) isn't subtract(0,x), but rather |
subtract(-0, x). */ |
vpush(&vtop->type); |
if (t == VT_FLOAT) |
vtop->c.f = -0.0f; |
else if (t == VT_DOUBLE) |
vtop->c.d = -0.0; |
else |
vtop->c.ld = -0.0; |
} else |
vpushi(0); |
vswap(); |
gen_op('-'); |
break; |
case TOK_LAND: |
if (!gnu_ext) |
goto tok_identifier; |
next(); |
/* allow to take the address of a label */ |
if (tok < TOK_UIDENT) |
expect("label identifier"); |
s = label_find(tok); |
if (!s) { |
s = label_push(&global_label_stack, tok, LABEL_FORWARD); |
} else { |
if (s->r == LABEL_DECLARED) |
s->r = LABEL_FORWARD; |
} |
if (!s->type.t) { |
s->type.t = VT_VOID; |
mk_pointer(&s->type); |
s->type.t |= VT_STATIC; |
} |
vpushsym(&s->type, s); |
next(); |
break; |
|
// special qnan , snan and infinity values |
case TOK___NAN__: |
vpush64(VT_DOUBLE, 0x7ff8000000000000ULL); |
next(); |
break; |
case TOK___SNAN__: |
vpush64(VT_DOUBLE, 0x7ff0000000000001ULL); |
next(); |
break; |
case TOK___INF__: |
vpush64(VT_DOUBLE, 0x7ff0000000000000ULL); |
next(); |
break; |
|
default: |
tok_identifier: |
t = tok; |
next(); |
if (t < TOK_UIDENT) |
expect("identifier"); |
s = sym_find(t); |
if (!s) { |
const char *name = get_tok_str(t, NULL); |
if (tok != '(') |
tcc_error("'%s' undeclared", name); |
/* for simple function calls, we tolerate undeclared |
external reference to int() function */ |
if (tcc_state->warn_implicit_function_declaration |
#ifdef TCC_TARGET_PE |
/* people must be warned about using undeclared WINAPI functions |
(which usually start with uppercase letter) */ |
|| (name[0] >= 'A' && name[0] <= 'Z') |
#endif |
) |
tcc_warning("implicit declaration of function '%s'", name); |
s = external_global_sym(t, &func_old_type, 0); |
} |
if ((s->type.t & (VT_STATIC | VT_INLINE | VT_BTYPE)) == |
(VT_STATIC | VT_INLINE | VT_FUNC)) { |
/* if referencing an inline function, then we generate a |
symbol to it if not already done. It will have the |
effect to generate code for it at the end of the |
compilation unit. Inline function as always |
generated in the text section. */ |
if (!s->c) |
put_extern_sym(s, text_section, 0, 0); |
r = VT_SYM | VT_CONST; |
} else { |
r = s->r; |
} |
vset(&s->type, r, s->c); |
/* if forward reference, we must point to s */ |
if (vtop->r & VT_SYM) { |
vtop->sym = s; |
vtop->c.i = 0; |
} |
break; |
} |
|
/* post operations */ |
while (1) { |
if (tok == TOK_INC || tok == TOK_DEC) { |
inc(1, tok); |
next(); |
} else if (tok == '.' || tok == TOK_ARROW || tok == TOK_CDOUBLE) { |
int qualifiers; |
/* field */ |
if (tok == TOK_ARROW) |
indir(); |
qualifiers = vtop->type.t & (VT_CONSTANT | VT_VOLATILE); |
test_lvalue(); |
gaddrof(); |
/* expect pointer on structure */ |
if ((vtop->type.t & VT_BTYPE) != VT_STRUCT) |
expect("struct or union"); |
if (tok == TOK_CDOUBLE) |
expect("field name"); |
next(); |
if (tok == TOK_CINT || tok == TOK_CUINT) |
expect("field name"); |
s = vtop->type.ref; |
/* find field */ |
tok |= SYM_FIELD; |
while ((s = s->next) != NULL) { |
if (s->v == tok) |
break; |
} |
if (!s) |
tcc_error("field not found: %s", get_tok_str(tok & ~SYM_FIELD, &tokc)); |
/* add field offset to pointer */ |
vtop->type = char_pointer_type; /* change type to 'char *' */ |
vpushi(s->c); |
gen_op('+'); |
/* change type to field type, and set to lvalue */ |
vtop->type = s->type; |
vtop->type.t |= qualifiers; |
/* an array is never an lvalue */ |
if (!(vtop->type.t & VT_ARRAY)) { |
vtop->r |= lvalue_type(vtop->type.t); |
#ifdef CONFIG_TCC_BCHECK |
/* if bound checking, the referenced pointer must be checked */ |
if (tcc_state->do_bounds_check) |
vtop->r |= VT_MUSTBOUND; |
#endif |
} |
next(); |
} else if (tok == '[') { |
next(); |
gexpr(); |
gen_op('+'); |
indir(); |
skip(']'); |
} else if (tok == '(') { |
SValue ret; |
Sym *sa; |
int nb_args, ret_nregs, ret_align, regsize, variadic; |
|
/* function call */ |
if ((vtop->type.t & VT_BTYPE) != VT_FUNC) { |
/* pointer test (no array accepted) */ |
if ((vtop->type.t & (VT_BTYPE | VT_ARRAY)) == VT_PTR) { |
vtop->type = *pointed_type(&vtop->type); |
if ((vtop->type.t & VT_BTYPE) != VT_FUNC) |
goto error_func; |
} else { |
error_func: |
expect("function pointer"); |
} |
} else { |
vtop->r &= ~VT_LVAL; /* no lvalue */ |
} |
/* get return type */ |
s = vtop->type.ref; |
next(); |
sa = s->next; /* first parameter */ |
nb_args = 0; |
ret.r2 = VT_CONST; |
/* compute first implicit argument if a structure is returned */ |
if ((s->type.t & VT_BTYPE) == VT_STRUCT) { |
variadic = (s->c == FUNC_ELLIPSIS); |
ret_nregs = gfunc_sret(&s->type, variadic, &ret.type, |
&ret_align, ®size); |
if (!ret_nregs) { |
/* get some space for the returned structure */ |
size = type_size(&s->type, &align); |
#ifdef TCC_TARGET_ARM64 |
/* On arm64, a small struct is return in registers. |
It is much easier to write it to memory if we know |
that we are allowed to write some extra bytes, so |
round the allocated space up to a power of 2: */ |
if (size < 16) |
while (size & (size - 1)) |
size = (size | (size - 1)) + 1; |
#endif |
loc = (loc - size) & -align; |
ret.type = s->type; |
ret.r = VT_LOCAL | VT_LVAL; |
/* pass it as 'int' to avoid structure arg passing |
problems */ |
vseti(VT_LOCAL, loc); |
ret.c = vtop->c; |
nb_args++; |
} |
} else { |
ret_nregs = 1; |
ret.type = s->type; |
} |
|
if (ret_nregs) { |
/* return in register */ |
if (is_float(ret.type.t)) { |
ret.r = reg_fret(ret.type.t); |
#ifdef TCC_TARGET_X86_64 |
if ((ret.type.t & VT_BTYPE) == VT_QFLOAT) |
ret.r2 = REG_QRET; |
#endif |
} else { |
#ifndef TCC_TARGET_ARM64 |
#ifdef TCC_TARGET_X86_64 |
if ((ret.type.t & VT_BTYPE) == VT_QLONG) |
#else |
if ((ret.type.t & VT_BTYPE) == VT_LLONG) |
#endif |
ret.r2 = REG_LRET; |
#endif |
ret.r = REG_IRET; |
} |
ret.c.i = 0; |
} |
if (tok != ')') { |
for(;;) { |
expr_eq(); |
gfunc_param_typed(s, sa); |
nb_args++; |
if (sa) |
sa = sa->next; |
if (tok == ')') |
break; |
skip(','); |
} |
} |
if (sa) |
tcc_error("too few arguments to function"); |
skip(')'); |
if (!nocode_wanted) { |
gfunc_call(nb_args); |
} else { |
vtop -= (nb_args + 1); |
} |
|
/* return value */ |
for (r = ret.r + ret_nregs + !ret_nregs; r-- > ret.r;) { |
vsetc(&ret.type, r, &ret.c); |
vtop->r2 = ret.r2; /* Loop only happens when r2 is VT_CONST */ |
} |
|
/* handle packed struct return */ |
if (((s->type.t & VT_BTYPE) == VT_STRUCT) && ret_nregs) { |
int addr, offset; |
|
size = type_size(&s->type, &align); |
/* We're writing whole regs often, make sure there's enough |
space. Assume register size is power of 2. */ |
if (regsize > align) |
align = regsize; |
loc = (loc - size) & -align; |
addr = loc; |
offset = 0; |
for (;;) { |
vset(&ret.type, VT_LOCAL | VT_LVAL, addr + offset); |
vswap(); |
vstore(); |
vtop--; |
if (--ret_nregs == 0) |
break; |
offset += regsize; |
} |
vset(&s->type, VT_LOCAL | VT_LVAL, addr); |
} |
} else { |
break; |
} |
} |
} |
|
ST_FUNC void expr_prod(void) |
{ |
int t; |
|
unary(); |
while (tok == '*' || tok == '/' || tok == '%') { |
t = tok; |
next(); |
unary(); |
gen_op(t); |
} |
} |
|
ST_FUNC void expr_sum(void) |
{ |
int t; |
|
expr_prod(); |
while (tok == '+' || tok == '-') { |
t = tok; |
next(); |
expr_prod(); |
gen_op(t); |
} |
} |
|
static void expr_shift(void) |
{ |
int t; |
|
expr_sum(); |
while (tok == TOK_SHL || tok == TOK_SAR) { |
t = tok; |
next(); |
expr_sum(); |
gen_op(t); |
} |
} |
|
static void expr_cmp(void) |
{ |
int t; |
|
expr_shift(); |
while ((tok >= TOK_ULE && tok <= TOK_GT) || |
tok == TOK_ULT || tok == TOK_UGE) { |
t = tok; |
next(); |
expr_shift(); |
gen_op(t); |
} |
} |
|
static void expr_cmpeq(void) |
{ |
int t; |
|
expr_cmp(); |
while (tok == TOK_EQ || tok == TOK_NE) { |
t = tok; |
next(); |
expr_cmp(); |
gen_op(t); |
} |
} |
|
static void expr_and(void) |
{ |
expr_cmpeq(); |
while (tok == '&') { |
next(); |
expr_cmpeq(); |
gen_op('&'); |
} |
} |
|
static void expr_xor(void) |
{ |
expr_and(); |
while (tok == '^') { |
next(); |
expr_and(); |
gen_op('^'); |
} |
} |
|
static void expr_or(void) |
{ |
expr_xor(); |
while (tok == '|') { |
next(); |
expr_xor(); |
gen_op('|'); |
} |
} |
|
/* XXX: fix this mess */ |
static void expr_land_const(void) |
{ |
expr_or(); |
while (tok == TOK_LAND) { |
next(); |
expr_or(); |
gen_op(TOK_LAND); |
} |
} |
static void expr_lor_const(void) |
{ |
expr_land_const(); |
while (tok == TOK_LOR) { |
next(); |
expr_land_const(); |
gen_op(TOK_LOR); |
} |
} |
|
static void expr_land(void) |
{ |
expr_or(); |
if (tok == TOK_LAND) { |
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) { |
CType ctb, cti; |
ctb.t = VT_BOOL; |
cti.t = VT_INT; |
next(); |
gen_cast(&ctb); |
if (vtop->c.i) { |
vpop(); |
expr_land(); |
gen_cast(&ctb); |
} else { |
int saved_nocode_wanted = nocode_wanted; |
nocode_wanted = 1; |
expr_land(); |
vpop(); |
nocode_wanted = saved_nocode_wanted; |
} |
gen_cast(&cti); |
} else { |
int t = 0; |
save_regs(1); |
for(;;) { |
t = gvtst(1, t); |
if (tok != TOK_LAND) { |
vseti(VT_JMPI, t); |
break; |
} |
next(); |
expr_or(); |
} |
} |
} |
} |
|
static void expr_lor(void) |
{ |
expr_land(); |
if (tok == TOK_LOR) { |
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) { |
CType ctb, cti; |
ctb.t = VT_BOOL; |
cti.t = VT_INT; |
next(); |
gen_cast(&ctb); |
if (vtop->c.i) { |
int saved_nocode_wanted = nocode_wanted; |
nocode_wanted = 1; |
expr_lor(); |
vpop(); |
nocode_wanted = saved_nocode_wanted; |
} else { |
vpop(); |
expr_lor(); |
gen_cast(&ctb); |
} |
gen_cast(&cti); |
} else { |
int t = 0; |
save_regs(1); |
for(;;) { |
t = gvtst(0, t); |
if (tok != TOK_LOR) { |
vseti(VT_JMP, t); |
break; |
} |
next(); |
expr_land(); |
} |
} |
} |
} |
|
static void expr_cond(void) |
{ |
int tt, u, r1, r2, rc, t1, t2, bt1, bt2, islv; |
SValue sv; |
CType type, type1, type2; |
|
expr_lor(); |
if (tok == '?') { |
next(); |
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) { |
int saved_nocode_wanted = nocode_wanted; |
CType boolean; |
int c; |
boolean.t = VT_BOOL; |
vdup(); |
gen_cast(&boolean); |
c = vtop->c.i; |
vpop(); |
if (c) { |
if (tok != ':' || !gnu_ext) { |
vpop(); |
gexpr(); |
} |
skip(':'); |
nocode_wanted = 1; |
expr_cond(); |
vpop(); |
nocode_wanted = saved_nocode_wanted; |
} else { |
vpop(); |
if (tok != ':' || !gnu_ext) { |
nocode_wanted = 1; |
gexpr(); |
vpop(); |
nocode_wanted = saved_nocode_wanted; |
} |
skip(':'); |
expr_cond(); |
} |
} |
else { |
if (vtop != vstack) { |
/* needed to avoid having different registers saved in |
each branch */ |
if (is_float(vtop->type.t)) { |
rc = RC_FLOAT; |
#ifdef TCC_TARGET_X86_64 |
if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE) { |
rc = RC_ST0; |
} |
#endif |
} |
else |
rc = RC_INT; |
gv(rc); |
save_regs(1); |
} |
if (tok == ':' && gnu_ext) { |
gv_dup(); |
tt = gvtst(1, 0); |
} else { |
tt = gvtst(1, 0); |
gexpr(); |
} |
type1 = vtop->type; |
sv = *vtop; /* save value to handle it later */ |
vtop--; /* no vpop so that FP stack is not flushed */ |
skip(':'); |
u = gjmp(0); |
gsym(tt); |
expr_cond(); |
type2 = vtop->type; |
|
t1 = type1.t; |
bt1 = t1 & VT_BTYPE; |
t2 = type2.t; |
bt2 = t2 & VT_BTYPE; |
/* cast operands to correct type according to ISOC rules */ |
if (is_float(bt1) || is_float(bt2)) { |
if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) { |
type.t = VT_LDOUBLE; |
} else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) { |
type.t = VT_DOUBLE; |
} else { |
type.t = VT_FLOAT; |
} |
} else if (bt1 == VT_LLONG || bt2 == VT_LLONG) { |
/* cast to biggest op */ |
type.t = VT_LLONG; |
/* convert to unsigned if it does not fit in a long long */ |
if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED) || |
(t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED)) |
type.t |= VT_UNSIGNED; |
} else if (bt1 == VT_PTR || bt2 == VT_PTR) { |
/* If one is a null ptr constant the result type |
is the other. */ |
if (is_null_pointer (vtop)) |
type = type1; |
else if (is_null_pointer (&sv)) |
type = type2; |
/* XXX: test pointer compatibility, C99 has more elaborate |
rules here. */ |
else |
type = type1; |
} else if (bt1 == VT_FUNC || bt2 == VT_FUNC) { |
/* XXX: test function pointer compatibility */ |
type = bt1 == VT_FUNC ? type1 : type2; |
} else if (bt1 == VT_STRUCT || bt2 == VT_STRUCT) { |
/* XXX: test structure compatibility */ |
type = bt1 == VT_STRUCT ? type1 : type2; |
} else if (bt1 == VT_VOID || bt2 == VT_VOID) { |
/* NOTE: as an extension, we accept void on only one side */ |
type.t = VT_VOID; |
} else { |
/* integer operations */ |
type.t = VT_INT; |
/* convert to unsigned if it does not fit in an integer */ |
if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED) || |
(t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED)) |
type.t |= VT_UNSIGNED; |
} |
/* keep structs lvalue by transforming `(expr ? a : b)` to `*(expr ? &a : &b)` so |
that `(expr ? a : b).mem` does not error with "lvalue expected" */ |
islv = (vtop->r & VT_LVAL) && (sv.r & VT_LVAL) && VT_STRUCT == (type.t & VT_BTYPE); |
|
/* now we convert second operand */ |
gen_cast(&type); |
if (islv) { |
mk_pointer(&vtop->type); |
gaddrof(); |
} |
else if (VT_STRUCT == (vtop->type.t & VT_BTYPE)) |
gaddrof(); |
rc = RC_INT; |
if (is_float(type.t)) { |
rc = RC_FLOAT; |
#ifdef TCC_TARGET_X86_64 |
if ((type.t & VT_BTYPE) == VT_LDOUBLE) { |
rc = RC_ST0; |
} |
#endif |
} else if ((type.t & VT_BTYPE) == VT_LLONG) { |
/* for long longs, we use fixed registers to avoid having |
to handle a complicated move */ |
rc = RC_IRET; |
} |
|
r2 = gv(rc); |
/* this is horrible, but we must also convert first |
operand */ |
tt = gjmp(0); |
gsym(u); |
/* put again first value and cast it */ |
*vtop = sv; |
gen_cast(&type); |
if (islv) { |
mk_pointer(&vtop->type); |
gaddrof(); |
} |
else if (VT_STRUCT == (vtop->type.t & VT_BTYPE)) |
gaddrof(); |
r1 = gv(rc); |
move_reg(r2, r1, type.t); |
vtop->r = r2; |
gsym(tt); |
if (islv) |
indir(); |
} |
} |
} |
|
static void expr_eq(void) |
{ |
int t; |
|
expr_cond(); |
if (tok == '=' || |
(tok >= TOK_A_MOD && tok <= TOK_A_DIV) || |
tok == TOK_A_XOR || tok == TOK_A_OR || |
tok == TOK_A_SHL || tok == TOK_A_SAR) { |
test_lvalue(); |
t = tok; |
next(); |
if (t == '=') { |
expr_eq(); |
} else { |
vdup(); |
expr_eq(); |
gen_op(t & 0x7f); |
} |
vstore(); |
} |
} |
|
ST_FUNC void gexpr(void) |
{ |
while (1) { |
expr_eq(); |
if (tok != ',') |
break; |
vpop(); |
next(); |
} |
} |
|
/* parse an expression and return its type without any side effect. */ |
static void expr_type(CType *type) |
{ |
int saved_nocode_wanted; |
|
saved_nocode_wanted = nocode_wanted; |
nocode_wanted = 1; |
gexpr(); |
*type = vtop->type; |
vpop(); |
nocode_wanted = saved_nocode_wanted; |
} |
|
/* parse a unary expression and return its type without any side |
effect. */ |
static void unary_type(CType *type) |
{ |
int a; |
|
a = nocode_wanted; |
nocode_wanted = 1; |
unary(); |
*type = vtop->type; |
vpop(); |
nocode_wanted = a; |
} |
|
/* parse a constant expression and return value in vtop. */ |
static void expr_const1(void) |
{ |
int a; |
a = const_wanted; |
const_wanted = 1; |
expr_cond(); |
const_wanted = a; |
} |
|
/* parse an integer constant and return its value. */ |
ST_FUNC int expr_const(void) |
{ |
int c; |
expr_const1(); |
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST) |
expect("constant expression"); |
c = vtop->c.i; |
vpop(); |
return c; |
} |
|
/* return the label token if current token is a label, otherwise |
return zero */ |
static int is_label(void) |
{ |
int last_tok; |
|
/* fast test first */ |
if (tok < TOK_UIDENT) |
return 0; |
/* no need to save tokc because tok is an identifier */ |
last_tok = tok; |
next(); |
if (tok == ':') { |
next(); |
return last_tok; |
} else { |
unget_tok(last_tok); |
return 0; |
} |
} |
|
static void label_or_decl(int l) |
{ |
int last_tok; |
|
/* fast test first */ |
if (tok >= TOK_UIDENT) |
{ |
/* no need to save tokc because tok is an identifier */ |
last_tok = tok; |
next(); |
if (tok == ':') { |
unget_tok(last_tok); |
return; |
} |
unget_tok(last_tok); |
} |
decl(l); |
} |
|
static void block(int *bsym, int *csym, int *case_sym, int *def_sym, |
int case_reg, int is_expr) |
{ |
int a, b, c, d; |
Sym *s, *frame_bottom; |
|
/* generate line number info */ |
if (tcc_state->do_debug && |
(last_line_num != file->line_num || last_ind != ind)) { |
put_stabn(N_SLINE, 0, file->line_num, ind - func_ind); |
last_ind = ind; |
last_line_num = file->line_num; |
} |
|
if (is_expr) { |
/* default return value is (void) */ |
vpushi(0); |
vtop->type.t = VT_VOID; |
} |
|
if (tok == TOK_IF) { |
/* if test */ |
next(); |
skip('('); |
gexpr(); |
skip(')'); |
a = gvtst(1, 0); |
block(bsym, csym, case_sym, def_sym, case_reg, 0); |
c = tok; |
if (c == TOK_ELSE) { |
next(); |
d = gjmp(0); |
gsym(a); |
block(bsym, csym, case_sym, def_sym, case_reg, 0); |
gsym(d); /* patch else jmp */ |
} else |
gsym(a); |
} else if (tok == TOK_WHILE) { |
next(); |
d = ind; |
vla_sp_restore(); |
skip('('); |
gexpr(); |
skip(')'); |
a = gvtst(1, 0); |
b = 0; |
block(&a, &b, case_sym, def_sym, case_reg, 0); |
if(!nocode_wanted) |
gjmp_addr(d); |
gsym(a); |
gsym_addr(b, d); |
} else if (tok == '{') { |
Sym *llabel; |
int block_vla_sp_loc = vla_sp_loc, saved_vlas_in_scope = vlas_in_scope; |
|
next(); |
/* record local declaration stack position */ |
s = local_stack; |
frame_bottom = sym_push2(&local_stack, SYM_FIELD, 0, 0); |
frame_bottom->next = scope_stack_bottom; |
scope_stack_bottom = frame_bottom; |
llabel = local_label_stack; |
|
/* handle local labels declarations */ |
if (tok == TOK_LABEL) { |
next(); |
for(;;) { |
if (tok < TOK_UIDENT) |
expect("label identifier"); |
label_push(&local_label_stack, tok, LABEL_DECLARED); |
next(); |
if (tok == ',') { |
next(); |
} else { |
skip(';'); |
break; |
} |
} |
} |
while (tok != '}') { |
label_or_decl(VT_LOCAL); |
if (tok != '}') { |
if (is_expr) |
vpop(); |
block(bsym, csym, case_sym, def_sym, case_reg, is_expr); |
} |
} |
/* pop locally defined labels */ |
label_pop(&local_label_stack, llabel); |
if(is_expr) { |
/* XXX: this solution makes only valgrind happy... |
triggered by gcc.c-torture/execute/20000917-1.c */ |
Sym *p; |
switch(vtop->type.t & VT_BTYPE) { |
/* case VT_PTR: */ |
/* this breaks a compilation of the linux kernel v2.4.26 */ |
/* pmd_t *new = ({ __asm__ __volatile__("ud2\n") ; ((pmd_t *)1); }); */ |
/* Look a commit a80acab: Display error on statement expressions with complex return type */ |
/* A pointer is not a complex return type */ |
case VT_STRUCT: |
case VT_ENUM: |
case VT_FUNC: |
for(p=vtop->type.ref;p;p=p->prev) |
if(p->prev==s) |
tcc_error("unsupported expression type"); |
} |
} |
/* pop locally defined symbols */ |
scope_stack_bottom = scope_stack_bottom->next; |
sym_pop(&local_stack, s); |
|
/* Pop VLA frames and restore stack pointer if required */ |
if (vlas_in_scope > saved_vlas_in_scope) { |
vla_sp_loc = saved_vlas_in_scope ? block_vla_sp_loc : vla_sp_root_loc; |
vla_sp_restore(); |
} |
vlas_in_scope = saved_vlas_in_scope; |
|
next(); |
} else if (tok == TOK_RETURN) { |
next(); |
if (tok != ';') { |
gexpr(); |
gen_assign_cast(&func_vt); |
#ifdef TCC_TARGET_ARM64 |
// Perhaps it would be better to use this for all backends: |
greturn(); |
#else |
if ((func_vt.t & VT_BTYPE) == VT_STRUCT) { |
CType type, ret_type; |
int ret_align, ret_nregs, regsize; |
ret_nregs = gfunc_sret(&func_vt, func_var, &ret_type, |
&ret_align, ®size); |
if (0 == ret_nregs) { |
/* if returning structure, must copy it to implicit |
first pointer arg location */ |
type = func_vt; |
mk_pointer(&type); |
vset(&type, VT_LOCAL | VT_LVAL, func_vc); |
indir(); |
vswap(); |
/* copy structure value to pointer */ |
vstore(); |
} else { |
/* returning structure packed into registers */ |
int r, size, addr, align; |
size = type_size(&func_vt,&align); |
if ((vtop->r != (VT_LOCAL | VT_LVAL) || |
(vtop->c.i & (ret_align-1))) |
&& (align & (ret_align-1))) { |
loc = (loc - size) & -ret_align; |
addr = loc; |
type = func_vt; |
vset(&type, VT_LOCAL | VT_LVAL, addr); |
vswap(); |
vstore(); |
vpop(); |
vset(&ret_type, VT_LOCAL | VT_LVAL, addr); |
} |
vtop->type = ret_type; |
if (is_float(ret_type.t)) |
r = rc_fret(ret_type.t); |
else |
r = RC_IRET; |
|
for (;;) { |
gv(r); |
if (--ret_nregs == 0) |
break; |
/* We assume that when a structure is returned in multiple |
registers, their classes are consecutive values of the |
suite s(n) = 2^n */ |
r <<= 1; |
vtop->c.i += regsize; |
vtop->r = VT_LOCAL | VT_LVAL; |
} |
} |
} else if (is_float(func_vt.t)) { |
gv(rc_fret(func_vt.t)); |
} else { |
gv(RC_IRET); |
} |
#endif |
vtop--; /* NOT vpop() because on x86 it would flush the fp stack */ |
} |
skip(';'); |
rsym = gjmp(rsym); /* jmp */ |
} else if (tok == TOK_BREAK) { |
/* compute jump */ |
if (!bsym) |
tcc_error("cannot break"); |
*bsym = gjmp(*bsym); |
next(); |
skip(';'); |
} else if (tok == TOK_CONTINUE) { |
/* compute jump */ |
if (!csym) |
tcc_error("cannot continue"); |
vla_sp_restore_root(); |
*csym = gjmp(*csym); |
next(); |
skip(';'); |
} else if (tok == TOK_FOR) { |
int e; |
next(); |
skip('('); |
s = local_stack; |
frame_bottom = sym_push2(&local_stack, SYM_FIELD, 0, 0); |
frame_bottom->next = scope_stack_bottom; |
scope_stack_bottom = frame_bottom; |
if (tok != ';') { |
/* c99 for-loop init decl? */ |
if (!decl0(VT_LOCAL, 1)) { |
/* no, regular for-loop init expr */ |
gexpr(); |
vpop(); |
} |
} |
skip(';'); |
d = ind; |
c = ind; |
vla_sp_restore(); |
a = 0; |
b = 0; |
if (tok != ';') { |
gexpr(); |
a = gvtst(1, 0); |
} |
skip(';'); |
if (tok != ')') { |
e = gjmp(0); |
c = ind; |
vla_sp_restore(); |
gexpr(); |
vpop(); |
gjmp_addr(d); |
gsym(e); |
} |
skip(')'); |
block(&a, &b, case_sym, def_sym, case_reg, 0); |
if(!nocode_wanted) |
gjmp_addr(c); |
gsym(a); |
gsym_addr(b, c); |
scope_stack_bottom = scope_stack_bottom->next; |
sym_pop(&local_stack, s); |
} else |
if (tok == TOK_DO) { |
next(); |
a = 0; |
b = 0; |
d = ind; |
vla_sp_restore(); |
block(&a, &b, case_sym, def_sym, case_reg, 0); |
skip(TOK_WHILE); |
skip('('); |
gsym(b); |
gexpr(); |
c = gvtst(0, 0); |
gsym_addr(c, d); |
skip(')'); |
gsym(a); |
skip(';'); |
} else |
if (tok == TOK_SWITCH) { |
next(); |
skip('('); |
gexpr(); |
/* XXX: other types than integer */ |
case_reg = gv(RC_INT); |
vpop(); |
skip(')'); |
a = 0; |
b = gjmp(0); /* jump to first case */ |
c = 0; |
block(&a, csym, &b, &c, case_reg, 0); |
/* if no default, jmp after switch */ |
if (c == 0) |
c = ind; |
/* default label */ |
gsym_addr(b, c); |
/* break label */ |
gsym(a); |
} else |
if (tok == TOK_CASE) { |
int v1, v2; |
if (!case_sym) |
expect("switch"); |
next(); |
v1 = expr_const(); |
v2 = v1; |
if (gnu_ext && tok == TOK_DOTS) { |
next(); |
v2 = expr_const(); |
if (v2 < v1) |
tcc_warning("empty case range"); |
} |
/* since a case is like a label, we must skip it with a jmp */ |
b = gjmp(0); |
gsym(*case_sym); |
vseti(case_reg, 0); |
vdup(); |
vpushi(v1); |
if (v1 == v2) { |
gen_op(TOK_EQ); |
*case_sym = gtst(1, 0); |
} else { |
gen_op(TOK_GE); |
*case_sym = gtst(1, 0); |
vseti(case_reg, 0); |
vpushi(v2); |
gen_op(TOK_LE); |
*case_sym = gtst(1, *case_sym); |
} |
case_reg = gv(RC_INT); |
vpop(); |
gsym(b); |
skip(':'); |
is_expr = 0; |
goto block_after_label; |
} else |
if (tok == TOK_DEFAULT) { |
next(); |
skip(':'); |
if (!def_sym) |
expect("switch"); |
if (*def_sym) |
tcc_error("too many 'default'"); |
*def_sym = ind; |
is_expr = 0; |
goto block_after_label; |
} else |
if (tok == TOK_GOTO) { |
next(); |
if (tok == '*' && gnu_ext) { |
/* computed goto */ |
next(); |
gexpr(); |
if ((vtop->type.t & VT_BTYPE) != VT_PTR) |
expect("pointer"); |
ggoto(); |
} else if (tok >= TOK_UIDENT) { |
s = label_find(tok); |
/* put forward definition if needed */ |
if (!s) { |
s = label_push(&global_label_stack, tok, LABEL_FORWARD); |
} else { |
if (s->r == LABEL_DECLARED) |
s->r = LABEL_FORWARD; |
} |
vla_sp_restore_root(); |
if (s->r & LABEL_FORWARD) |
s->jnext = gjmp(s->jnext); |
else |
gjmp_addr(s->jnext); |
next(); |
} else { |
expect("label identifier"); |
} |
skip(';'); |
} else if (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3) { |
asm_instr(); |
} else { |
b = is_label(); |
if (b) { |
/* label case */ |
s = label_find(b); |
if (s) { |
if (s->r == LABEL_DEFINED) |
tcc_error("duplicate label '%s'", get_tok_str(s->v, NULL)); |
gsym(s->jnext); |
s->r = LABEL_DEFINED; |
} else { |
s = label_push(&global_label_stack, b, LABEL_DEFINED); |
} |
s->jnext = ind; |
vla_sp_restore(); |
/* we accept this, but it is a mistake */ |
block_after_label: |
if (tok == '}') { |
tcc_warning("deprecated use of label at end of compound statement"); |
} else { |
if (is_expr) |
vpop(); |
block(bsym, csym, case_sym, def_sym, case_reg, is_expr); |
} |
} else { |
/* expression case */ |
if (tok != ';') { |
if (is_expr) { |
vpop(); |
gexpr(); |
} else { |
gexpr(); |
vpop(); |
} |
} |
skip(';'); |
} |
} |
} |
|
/* t is the array or struct type. c is the array or struct |
address. cur_index/cur_field is the pointer to the current |
value. 'size_only' is true if only size info is needed (only used |
in arrays) */ |
static void decl_designator(CType *type, Section *sec, unsigned long c, |
int *cur_index, Sym **cur_field, |
int size_only) |
{ |
Sym *s, *f; |
int notfirst, index, index_last, align, l, nb_elems, elem_size; |
CType type1; |
|
notfirst = 0; |
elem_size = 0; |
nb_elems = 1; |
if (gnu_ext && (l = is_label()) != 0) |
goto struct_field; |
while (tok == '[' || tok == '.') { |
if (tok == '[') { |
if (!(type->t & VT_ARRAY)) |
expect("array type"); |
s = type->ref; |
next(); |
index = expr_const(); |
if (index < 0 || (s->c >= 0 && index >= s->c)) |
expect("invalid index"); |
if (tok == TOK_DOTS && gnu_ext) { |
next(); |
index_last = expr_const(); |
if (index_last < 0 || |
(s->c >= 0 && index_last >= s->c) || |
index_last < index) |
expect("invalid index"); |
} else { |
index_last = index; |
} |
skip(']'); |
if (!notfirst) |
*cur_index = index_last; |
type = pointed_type(type); |
elem_size = type_size(type, &align); |
c += index * elem_size; |
/* NOTE: we only support ranges for last designator */ |
nb_elems = index_last - index + 1; |
if (nb_elems != 1) { |
notfirst = 1; |
break; |
} |
} else { |
next(); |
l = tok; |
next(); |
struct_field: |
if ((type->t & VT_BTYPE) != VT_STRUCT) |
expect("struct/union type"); |
s = type->ref; |
l |= SYM_FIELD; |
f = s->next; |
while (f) { |
if (f->v == l) |
break; |
f = f->next; |
} |
if (!f) |
expect("field"); |
if (!notfirst) |
*cur_field = f; |
/* XXX: fix this mess by using explicit storage field */ |
type1 = f->type; |
type1.t |= (type->t & ~VT_TYPE); |
type = &type1; |
c += f->c; |
} |
notfirst = 1; |
} |
if (notfirst) { |
if (tok == '=') { |
next(); |
} else { |
if (!gnu_ext) |
expect("="); |
} |
} else { |
if (type->t & VT_ARRAY) { |
index = *cur_index; |
type = pointed_type(type); |
c += index * type_size(type, &align); |
} else { |
f = *cur_field; |
if (!f) |
tcc_error("too many field init"); |
/* XXX: fix this mess by using explicit storage field */ |
type1 = f->type; |
type1.t |= (type->t & ~VT_TYPE); |
type = &type1; |
c += f->c; |
} |
} |
decl_initializer(type, sec, c, 0, size_only); |
|
/* XXX: make it more general */ |
if (!size_only && nb_elems > 1) { |
unsigned long c_end; |
uint8_t *src, *dst; |
int i; |
|
if (!sec) |
tcc_error("range init not supported yet for dynamic storage"); |
c_end = c + nb_elems * elem_size; |
if (c_end > sec->data_allocated) |
section_realloc(sec, c_end); |
src = sec->data + c; |
dst = src; |
for(i = 1; i < nb_elems; i++) { |
dst += elem_size; |
memcpy(dst, src, elem_size); |
} |
} |
} |
|
#define EXPR_VAL 0 |
#define EXPR_CONST 1 |
#define EXPR_ANY 2 |
|
/* store a value or an expression directly in global data or in local array */ |
static void init_putv(CType *type, Section *sec, unsigned long c, |
int v, int expr_type) |
{ |
int saved_global_expr, bt, bit_pos, bit_size; |
void *ptr; |
unsigned long long bit_mask; |
CType dtype; |
|
switch(expr_type) { |
case EXPR_VAL: |
vpushi(v); |
break; |
case EXPR_CONST: |
/* compound literals must be allocated globally in this case */ |
saved_global_expr = global_expr; |
global_expr = 1; |
expr_const1(); |
global_expr = saved_global_expr; |
/* NOTE: symbols are accepted */ |
if ((vtop->r & (VT_VALMASK | VT_LVAL)) != VT_CONST) |
tcc_error("initializer element is not constant"); |
break; |
case EXPR_ANY: |
expr_eq(); |
break; |
} |
|
dtype = *type; |
dtype.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */ |
|
if (sec) { |
/* XXX: not portable */ |
/* XXX: generate error if incorrect relocation */ |
gen_assign_cast(&dtype); |
bt = type->t & VT_BTYPE; |
/* we'll write at most 16 bytes */ |
if (c + 16 > sec->data_allocated) { |
section_realloc(sec, c + 16); |
} |
ptr = sec->data + c; |
/* XXX: make code faster ? */ |
if (!(type->t & VT_BITFIELD)) { |
bit_pos = 0; |
bit_size = 32; |
bit_mask = -1LL; |
} else { |
bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f; |
bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f; |
bit_mask = (1LL << bit_size) - 1; |
} |
if ((vtop->r & VT_SYM) && |
(bt == VT_BYTE || |
bt == VT_SHORT || |
bt == VT_DOUBLE || |
bt == VT_LDOUBLE || |
bt == VT_LLONG || |
(bt == VT_INT && bit_size != 32))) |
tcc_error("initializer element is not computable at load time"); |
switch(bt) { |
/* XXX: when cross-compiling we assume that each type has the |
same representation on host and target, which is likely to |
be wrong in the case of long double */ |
case VT_BOOL: |
vtop->c.i = (vtop->c.i != 0); |
case VT_BYTE: |
*(char *)ptr |= (vtop->c.i & bit_mask) << bit_pos; |
break; |
case VT_SHORT: |
*(short *)ptr |= (vtop->c.i & bit_mask) << bit_pos; |
break; |
case VT_DOUBLE: |
*(double *)ptr = vtop->c.d; |
break; |
case VT_LDOUBLE: |
*(long double *)ptr = vtop->c.ld; |
break; |
case VT_LLONG: |
*(long long *)ptr |= (vtop->c.i & bit_mask) << bit_pos; |
break; |
case VT_PTR: { |
addr_t val = (vtop->c.i & bit_mask) << bit_pos; |
#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64) |
if (vtop->r & VT_SYM) |
greloca(sec, vtop->sym, c, R_DATA_PTR, val); |
else |
*(addr_t *)ptr |= val; |
#else |
if (vtop->r & VT_SYM) |
greloc(sec, vtop->sym, c, R_DATA_PTR); |
*(addr_t *)ptr |= val; |
#endif |
break; |
} |
default: { |
int val = (vtop->c.i & bit_mask) << bit_pos; |
#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64) |
if (vtop->r & VT_SYM) |
greloca(sec, vtop->sym, c, R_DATA_PTR, val); |
else |
*(int *)ptr |= val; |
#else |
if (vtop->r & VT_SYM) |
greloc(sec, vtop->sym, c, R_DATA_PTR); |
*(int *)ptr |= val; |
#endif |
break; |
} |
} |
vtop--; |
} else { |
vset(&dtype, VT_LOCAL|VT_LVAL, c); |
vswap(); |
vstore(); |
vpop(); |
} |
} |
|
/* put zeros for variable based init */ |
static void init_putz(CType *t, Section *sec, unsigned long c, int size) |
{ |
if (sec) { |
/* nothing to do because globals are already set to zero */ |
} else { |
vpush_global_sym(&func_old_type, TOK_memset); |
vseti(VT_LOCAL, c); |
#ifdef TCC_TARGET_ARM |
vpushs(size); |
vpushi(0); |
#else |
vpushi(0); |
vpushs(size); |
#endif |
gfunc_call(3); |
} |
} |
|
/* 't' contains the type and storage info. 'c' is the offset of the |
object in section 'sec'. If 'sec' is NULL, it means stack based |
allocation. 'first' is true if array '{' must be read (multi |
dimension implicit array init handling). 'size_only' is true if |
size only evaluation is wanted (only for arrays). */ |
static void decl_initializer(CType *type, Section *sec, unsigned long c, |
int first, int size_only) |
{ |
int index, array_length, n, no_oblock, nb, parlevel, parlevel1, i; |
int size1, align1, expr_type; |
Sym *s, *f; |
CType *t1; |
|
if (type->t & VT_VLA) { |
int a; |
|
/* save current stack pointer */ |
if (vlas_in_scope == 0) { |
if (vla_sp_root_loc == -1) |
vla_sp_root_loc = (loc -= PTR_SIZE); |
gen_vla_sp_save(vla_sp_root_loc); |
} |
|
vla_runtime_type_size(type, &a); |
gen_vla_alloc(type, a); |
gen_vla_sp_save(c); |
vla_sp_loc = c; |
vlas_in_scope++; |
} else if (type->t & VT_ARRAY) { |
s = type->ref; |
n = s->c; |
array_length = 0; |
t1 = pointed_type(type); |
size1 = type_size(t1, &align1); |
|
no_oblock = 1; |
if ((first && tok != TOK_LSTR && tok != TOK_STR) || |
tok == '{') { |
if (tok != '{') |
tcc_error("character array initializer must be a literal," |
" optionally enclosed in braces"); |
skip('{'); |
no_oblock = 0; |
} |
|
/* only parse strings here if correct type (otherwise: handle |
them as ((w)char *) expressions */ |
if ((tok == TOK_LSTR && |
#ifdef TCC_TARGET_PE |
(t1->t & VT_BTYPE) == VT_SHORT && (t1->t & VT_UNSIGNED) |
#else |
(t1->t & VT_BTYPE) == VT_INT |
#endif |
) || (tok == TOK_STR && (t1->t & VT_BTYPE) == VT_BYTE)) { |
while (tok == TOK_STR || tok == TOK_LSTR) { |
int cstr_len, ch; |
|
/* compute maximum number of chars wanted */ |
if (tok == TOK_STR) |
cstr_len = tokc.str.size; |
else |
cstr_len = tokc.str.size / sizeof(nwchar_t); |
cstr_len--; |
nb = cstr_len; |
if (n >= 0 && nb > (n - array_length)) |
nb = n - array_length; |
if (!size_only) { |
if (cstr_len > nb) |
tcc_warning("initializer-string for array is too long"); |
/* in order to go faster for common case (char |
string in global variable, we handle it |
specifically */ |
if (sec && tok == TOK_STR && size1 == 1) { |
memcpy(sec->data + c + array_length, tokc.str.data, nb); |
} else { |
for(i=0;i<nb;i++) { |
if (tok == TOK_STR) |
ch = ((unsigned char *)tokc.str.data)[i]; |
else |
ch = ((nwchar_t *)tokc.str.data)[i]; |
init_putv(t1, sec, c + (array_length + i) * size1, |
ch, EXPR_VAL); |
} |
} |
} |
array_length += nb; |
next(); |
} |
/* only add trailing zero if enough storage (no |
warning in this case since it is standard) */ |
if (n < 0 || array_length < n) { |
if (!size_only) { |
init_putv(t1, sec, c + (array_length * size1), 0, EXPR_VAL); |
} |
array_length++; |
} |
} else { |
index = 0; |
while (tok != '}') { |
decl_designator(type, sec, c, &index, NULL, size_only); |
if (n >= 0 && index >= n) |
tcc_error("index too large"); |
/* must put zero in holes (note that doing it that way |
ensures that it even works with designators) */ |
if (!size_only && array_length < index) { |
init_putz(t1, sec, c + array_length * size1, |
(index - array_length) * size1); |
} |
index++; |
if (index > array_length) |
array_length = index; |
/* special test for multi dimensional arrays (may not |
be strictly correct if designators are used at the |
same time) */ |
if (index >= n && no_oblock) |
break; |
if (tok == '}') |
break; |
skip(','); |
} |
} |
if (!no_oblock) |
skip('}'); |
/* put zeros at the end */ |
if (!size_only && n >= 0 && array_length < n) { |
init_putz(t1, sec, c + array_length * size1, |
(n - array_length) * size1); |
} |
/* patch type size if needed */ |
if (n < 0) |
s->c = array_length; |
} else if ((type->t & VT_BTYPE) == VT_STRUCT && |
(sec || !first || tok == '{')) { |
|
/* NOTE: the previous test is a specific case for automatic |
struct/union init */ |
/* XXX: union needs only one init */ |
|
int par_count = 0; |
if (tok == '(') { |
AttributeDef ad1; |
CType type1; |
next(); |
if (tcc_state->old_struct_init_code) { |
/* an old version of struct initialization. |
It have a problems. But with a new version |
linux 2.4.26 can't load ramdisk. |
*/ |
while (tok == '(') { |
par_count++; |
next(); |
} |
if (!parse_btype(&type1, &ad1)) |
expect("cast"); |
type_decl(&type1, &ad1, &n, TYPE_ABSTRACT); |
#if 0 |
if (!is_assignable_types(type, &type1)) |
tcc_error("invalid type for cast"); |
#endif |
skip(')'); |
} |
else |
{ |
if (tok != '(') { |
if (!parse_btype(&type1, &ad1)) |
expect("cast"); |
type_decl(&type1, &ad1, &n, TYPE_ABSTRACT); |
#if 0 |
if (!is_assignable_types(type, &type1)) |
tcc_error("invalid type for cast"); |
#endif |
skip(')'); |
} else |
unget_tok(tok); |
} |
} |
|
no_oblock = 1; |
if (first || tok == '{') { |
skip('{'); |
no_oblock = 0; |
} |
s = type->ref; |
f = s->next; |
array_length = 0; |
index = 0; |
n = s->c; |
while (tok != '}') { |
decl_designator(type, sec, c, NULL, &f, size_only); |
index = f->c; |
if (!size_only && array_length < index) { |
init_putz(type, sec, c + array_length, |
index - array_length); |
} |
index = index + type_size(&f->type, &align1); |
if (index > array_length) |
array_length = index; |
|
/* gr: skip fields from same union - ugly. */ |
while (f->next) { |
int align = 0; |
int f_size = type_size(&f->type, &align); |
int f_type = (f->type.t & VT_BTYPE); |
|
///printf("index: %2d %08x -- %2d %08x\n", f->c, f->type.t, f->next->c, f->next->type.t); |
/* test for same offset */ |
if (f->next->c != f->c) |
break; |
if ((f_type == VT_STRUCT) && (f_size == 0)) { |
/* |
Lets assume a structure of size 0 can't be a member of the union. |
This allow to compile the following code from a linux kernel v2.4.26 |
typedef struct { } rwlock_t; |
struct fs_struct { |
int count; |
rwlock_t lock; |
int umask; |
}; |
struct fs_struct init_fs = { { (1) }, (rwlock_t) {}, 0022, }; |
tcc-0.9.23 can succesfully compile this version of the kernel. |
gcc don't have problems with this code too. |
*/ |
break; |
} |
/* if yes, test for bitfield shift */ |
if ((f->type.t & VT_BITFIELD) && (f->next->type.t & VT_BITFIELD)) { |
int bit_pos_1 = (f->type.t >> VT_STRUCT_SHIFT) & 0x3f; |
int bit_pos_2 = (f->next->type.t >> VT_STRUCT_SHIFT) & 0x3f; |
//printf("bitfield %d %d\n", bit_pos_1, bit_pos_2); |
if (bit_pos_1 != bit_pos_2) |
break; |
} |
f = f->next; |
} |
|
f = f->next; |
if (no_oblock && f == NULL) |
break; |
if (tok == '}') |
break; |
skip(','); |
} |
/* put zeros at the end */ |
if (!size_only && array_length < n) { |
init_putz(type, sec, c + array_length, |
n - array_length); |
} |
if (!no_oblock) |
skip('}'); |
while (par_count) { |
skip(')'); |
par_count--; |
} |
} else if (tok == '{') { |
next(); |
decl_initializer(type, sec, c, first, size_only); |
skip('}'); |
} else if (size_only) { |
/* just skip expression */ |
parlevel = parlevel1 = 0; |
while ((parlevel > 0 || parlevel1 > 0 || |
(tok != '}' && tok != ',')) && tok != -1) { |
if (tok == '(') |
parlevel++; |
else if (tok == ')') { |
if (parlevel == 0 && parlevel1 == 0) |
break; |
parlevel--; |
} |
else if (tok == '{') |
parlevel1++; |
else if (tok == '}') { |
if (parlevel == 0 && parlevel1 == 0) |
break; |
parlevel1--; |
} |
next(); |
} |
} else { |
/* currently, we always use constant expression for globals |
(may change for scripting case) */ |
expr_type = EXPR_CONST; |
if (!sec) |
expr_type = EXPR_ANY; |
init_putv(type, sec, c, 0, expr_type); |
} |
} |
|
/* parse an initializer for type 't' if 'has_init' is non zero, and |
allocate space in local or global data space ('r' is either |
VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated |
variable 'v' of scope 'scope' is declared before initializers |
are parsed. If 'v' is zero, then a reference to the new object |
is put in the value stack. If 'has_init' is 2, a special parsing |
is done to handle string constants. */ |
static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, |
int has_init, int v, int scope) |
{ |
int size, align, addr, data_offset; |
int level; |
ParseState saved_parse_state = {0}; |
TokenString init_str; |
Section *sec; |
Sym *flexible_array; |
|
flexible_array = NULL; |
if ((type->t & VT_BTYPE) == VT_STRUCT) { |
Sym *field = type->ref->next; |
if (field) { |
while (field->next) |
field = field->next; |
if (field->type.t & VT_ARRAY && field->type.ref->c < 0) |
flexible_array = field; |
} |
} |
|
size = type_size(type, &align); |
/* If unknown size, we must evaluate it before |
evaluating initializers because |
initializers can generate global data too |
(e.g. string pointers or ISOC99 compound |
literals). It also simplifies local |
initializers handling */ |
tok_str_new(&init_str); |
if (size < 0 || (flexible_array && has_init)) { |
if (!has_init) |
tcc_error("unknown type size"); |
/* get all init string */ |
if (has_init == 2) { |
/* only get strings */ |
while (tok == TOK_STR || tok == TOK_LSTR) { |
tok_str_add_tok(&init_str); |
next(); |
} |
} else { |
level = 0; |
while (level > 0 || (tok != ',' && tok != ';')) { |
if (tok < 0) |
tcc_error("unexpected end of file in initializer"); |
tok_str_add_tok(&init_str); |
if (tok == '{') |
level++; |
else if (tok == '}') { |
level--; |
if (level <= 0) { |
next(); |
break; |
} |
} |
next(); |
} |
} |
tok_str_add(&init_str, -1); |
tok_str_add(&init_str, 0); |
|
/* compute size */ |
save_parse_state(&saved_parse_state); |
|
begin_macro(&init_str, 0); |
next(); |
decl_initializer(type, NULL, 0, 1, 1); |
/* prepare second initializer parsing */ |
macro_ptr = init_str.str; |
next(); |
|
/* if still unknown size, error */ |
size = type_size(type, &align); |
if (size < 0) |
tcc_error("unknown type size"); |
} |
/* If there's a flex member and it was used in the initializer |
adjust size. */ |
if (flexible_array && |
flexible_array->type.ref->c > 0) |
size += flexible_array->type.ref->c |
* pointed_size(&flexible_array->type); |
/* take into account specified alignment if bigger */ |
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) { |
sec = NULL; |
#ifdef CONFIG_TCC_BCHECK |
if (tcc_state->do_bounds_check && (type->t & VT_ARRAY)) { |
loc--; |
} |
#endif |
loc = (loc - size) & -align; |
addr = loc; |
#ifdef CONFIG_TCC_BCHECK |
/* handles bounds */ |
/* XXX: currently, since we do only one pass, we cannot track |
'&' operators, so we add only arrays */ |
if (tcc_state->do_bounds_check && (type->t & VT_ARRAY)) { |
addr_t *bounds_ptr; |
/* add padding between regions */ |
loc--; |
/* then add local bound info */ |
bounds_ptr = section_ptr_add(lbounds_section, 2 * sizeof(addr_t)); |
bounds_ptr[0] = addr; |
bounds_ptr[1] = size; |
} |
#endif |
if (v) { |
/* local variable */ |
sym_push(v, type, r, addr); |
} else { |
/* push local reference */ |
vset(type, r, addr); |
} |
} else { |
Sym *sym; |
|
sym = NULL; |
if (v && scope == VT_CONST) { |
/* see if the symbol was already defined */ |
sym = sym_find(v); |
if (sym) { |
if (!is_compatible_types(&sym->type, type)) |
tcc_error("incompatible types for redefinition of '%s'", |
get_tok_str(v, NULL)); |
if (sym->type.t & VT_EXTERN) { |
/* if the variable is extern, it was not allocated */ |
sym->type.t &= ~VT_EXTERN; |
/* set array size if it was omitted in extern |
declaration */ |
if ((sym->type.t & VT_ARRAY) && |
sym->type.ref->c < 0 && |
type->ref->c >= 0) |
sym->type.ref->c = type->ref->c; |
} else { |
/* we accept several definitions of the same |
global variable. this is tricky, because we |
must play with the SHN_COMMON type of the symbol */ |
/* XXX: should check if the variable was already |
initialized. It is incorrect to initialized it |
twice */ |
/* no init data, we won't add more to the symbol */ |
if (!has_init) |
goto no_alloc; |
} |
} |
} |
|
/* allocate symbol in corresponding section */ |
sec = ad->section; |
if (!sec) { |
if (has_init) |
sec = data_section; |
else if (tcc_state->nocommon) |
sec = bss_section; |
} |
if (sec) { |
data_offset = sec->data_offset; |
data_offset = (data_offset + align - 1) & -align; |
addr = data_offset; |
/* very important to increment global pointer at this time |
because initializers themselves can create new initializers */ |
data_offset += size; |
#ifdef CONFIG_TCC_BCHECK |
/* add padding if bound check */ |
if (tcc_state->do_bounds_check) |
data_offset++; |
#endif |
sec->data_offset = data_offset; |
/* allocate section space to put the data */ |
if (sec->sh_type != SHT_NOBITS && |
data_offset > sec->data_allocated) |
section_realloc(sec, data_offset); |
/* align section if needed */ |
if (align > sec->sh_addralign) |
sec->sh_addralign = align; |
} else { |
addr = 0; /* avoid warning */ |
} |
|
if (v) { |
if (scope != VT_CONST || !sym) { |
sym = sym_push(v, type, r | VT_SYM, 0); |
sym->asm_label = ad->asm_label; |
} |
/* update symbol definition */ |
if (sec) { |
put_extern_sym(sym, sec, addr, size); |
} else { |
ElfW(Sym) *esym; |
/* put a common area */ |
put_extern_sym(sym, NULL, align, size); |
/* XXX: find a nicer way */ |
esym = &((ElfW(Sym) *)symtab_section->data)[sym->c]; |
esym->st_shndx = SHN_COMMON; |
} |
} else { |
/* push global reference */ |
sym = get_sym_ref(type, sec, addr, size); |
vpushsym(type, sym); |
} |
/* patch symbol weakness */ |
if (type->t & VT_WEAK) |
weaken_symbol(sym); |
apply_visibility(sym, type); |
#ifdef CONFIG_TCC_BCHECK |
/* handles bounds now because the symbol must be defined |
before for the relocation */ |
if (tcc_state->do_bounds_check) { |
addr_t *bounds_ptr; |
|
greloc(bounds_section, sym, bounds_section->data_offset, R_DATA_PTR); |
/* then add global bound info */ |
bounds_ptr = section_ptr_add(bounds_section, 2 * sizeof(addr_t)); |
bounds_ptr[0] = 0; /* relocated */ |
bounds_ptr[1] = size; |
} |
#endif |
} |
if (has_init || (type->t & VT_VLA)) { |
decl_initializer(type, sec, addr, 1, 0); |
/* restore parse state if needed */ |
if (init_str.str) { |
end_macro(); |
restore_parse_state(&saved_parse_state); |
} |
/* patch flexible array member size back to -1, */ |
/* for possible subsequent similar declarations */ |
if (flexible_array) |
flexible_array->type.ref->c = -1; |
} |
no_alloc: ; |
} |
|
static void put_func_debug(Sym *sym) |
{ |
char buf[512]; |
|
/* stabs info */ |
/* XXX: we put here a dummy type */ |
snprintf(buf, sizeof(buf), "%s:%c1", |
funcname, sym->type.t & VT_STATIC ? 'f' : 'F'); |
put_stabs_r(buf, N_FUN, 0, file->line_num, 0, |
cur_text_section, sym->c); |
/* //gr gdb wants a line at the function */ |
put_stabn(N_SLINE, 0, file->line_num, 0); |
last_ind = 0; |
last_line_num = 0; |
} |
|
/* parse an old style function declaration list */ |
/* XXX: check multiple parameter */ |
static void func_decl_list(Sym *func_sym) |
{ |
AttributeDef ad; |
int v; |
Sym *s; |
CType btype, type; |
|
/* parse each declaration */ |
while (tok != '{' && tok != ';' && tok != ',' && tok != TOK_EOF && |
tok != TOK_ASM1 && tok != TOK_ASM2 && tok != TOK_ASM3) { |
if (!parse_btype(&btype, &ad)) |
expect("declaration list"); |
if (((btype.t & VT_BTYPE) == VT_ENUM || |
(btype.t & VT_BTYPE) == VT_STRUCT) && |
tok == ';') { |
/* we accept no variable after */ |
} else { |
for(;;) { |
type = btype; |
type_decl(&type, &ad, &v, TYPE_DIRECT); |
/* find parameter in function parameter list */ |
s = func_sym->next; |
while (s != NULL) { |
if ((s->v & ~SYM_FIELD) == v) |
goto found; |
s = s->next; |
} |
tcc_error("declaration for parameter '%s' but no such parameter", |
get_tok_str(v, NULL)); |
found: |
/* check that no storage specifier except 'register' was given */ |
if (type.t & VT_STORAGE) |
tcc_error("storage class specified for '%s'", get_tok_str(v, NULL)); |
convert_parameter_type(&type); |
/* we can add the type (NOTE: it could be local to the function) */ |
s->type = type; |
/* accept other parameters */ |
if (tok == ',') |
next(); |
else |
break; |
} |
} |
skip(';'); |
} |
} |
|
/* parse a function defined by symbol 'sym' and generate its code in |
'cur_text_section' */ |
static void gen_function(Sym *sym) |
{ |
int saved_nocode_wanted = nocode_wanted; |
|
nocode_wanted = 0; |
ind = cur_text_section->data_offset; |
/* NOTE: we patch the symbol size later */ |
put_extern_sym(sym, cur_text_section, ind, 0); |
funcname = get_tok_str(sym->v, NULL); |
func_ind = ind; |
/* Initialize VLA state */ |
vla_sp_loc = -1; |
vla_sp_root_loc = -1; |
/* put debug symbol */ |
if (tcc_state->do_debug) |
put_func_debug(sym); |
/* push a dummy symbol to enable local sym storage */ |
sym_push2(&local_stack, SYM_FIELD, 0, 0); |
gfunc_prolog(&sym->type); |
#ifdef CONFIG_TCC_BCHECK |
if (tcc_state->do_bounds_check && !strcmp(funcname, "main")) { |
int i; |
Sym *sym; |
for (i = 0, sym = local_stack; i < 2; i++, sym = sym->prev) { |
if (sym->v & SYM_FIELD || sym->prev->v & SYM_FIELD) |
break; |
vpush_global_sym(&func_old_type, TOK___bound_main_arg); |
vset(&sym->type, sym->r, sym->c); |
gfunc_call(1); |
} |
} |
#endif |
rsym = 0; |
block(NULL, NULL, NULL, NULL, 0, 0); |
gsym(rsym); |
gfunc_epilog(); |
cur_text_section->data_offset = ind; |
label_pop(&global_label_stack, NULL); |
/* reset local stack */ |
scope_stack_bottom = NULL; |
sym_pop(&local_stack, NULL); |
/* end of function */ |
/* patch symbol size */ |
((ElfW(Sym) *)symtab_section->data)[sym->c].st_size = |
ind - func_ind; |
/* patch symbol weakness (this definition overrules any prototype) */ |
if (sym->type.t & VT_WEAK) |
weaken_symbol(sym); |
apply_visibility(sym, &sym->type); |
if (tcc_state->do_debug) { |
put_stabn(N_FUN, 0, 0, ind - func_ind); |
} |
/* It's better to crash than to generate wrong code */ |
cur_text_section = NULL; |
funcname = ""; /* for safety */ |
func_vt.t = VT_VOID; /* for safety */ |
func_var = 0; /* for safety */ |
ind = 0; /* for safety */ |
nocode_wanted = saved_nocode_wanted; |
check_vstack(); |
} |
|
ST_FUNC void gen_inline_functions(void) |
{ |
Sym *sym; |
int inline_generated, i, ln; |
struct InlineFunc *fn; |
|
ln = file->line_num; |
/* iterate while inline function are referenced */ |
for(;;) { |
inline_generated = 0; |
for (i = 0; i < tcc_state->nb_inline_fns; ++i) { |
fn = tcc_state->inline_fns[i]; |
sym = fn->sym; |
if (sym && sym->c) { |
/* the function was used: generate its code and |
convert it to a normal function */ |
fn->sym = NULL; |
if (file) |
pstrcpy(file->filename, sizeof file->filename, fn->filename); |
sym->r = VT_SYM | VT_CONST; |
sym->type.t &= ~VT_INLINE; |
|
begin_macro(&fn->func_str, 0); |
next(); |
cur_text_section = text_section; |
gen_function(sym); |
end_macro(); |
|
inline_generated = 1; |
} |
} |
if (!inline_generated) |
break; |
} |
file->line_num = ln; |
/* free tokens of unused inline functions */ |
for (i = 0; i < tcc_state->nb_inline_fns; ++i) { |
fn = tcc_state->inline_fns[i]; |
if (fn->sym) |
tok_str_free(fn->func_str.str); |
} |
dynarray_reset(&tcc_state->inline_fns, &tcc_state->nb_inline_fns); |
} |
|
/* 'l' is VT_LOCAL or VT_CONST to define default storage type */ |
static int decl0(int l, int is_for_loop_init) |
{ |
int v, has_init, r; |
CType type, btype; |
Sym *sym; |
AttributeDef ad; |
|
while (1) { |
if (!parse_btype(&btype, &ad)) { |
if (is_for_loop_init) |
return 0; |
/* skip redundant ';' */ |
/* XXX: find more elegant solution */ |
if (tok == ';') { |
next(); |
continue; |
} |
if (l == VT_CONST && |
(tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3)) { |
/* global asm block */ |
asm_global_instr(); |
continue; |
} |
/* special test for old K&R protos without explicit int |
type. Only accepted when defining global data */ |
if (l == VT_LOCAL || tok < TOK_DEFINE) |
break; |
btype.t = VT_INT; |
} |
if (((btype.t & VT_BTYPE) == VT_ENUM || |
(btype.t & VT_BTYPE) == VT_STRUCT) && |
tok == ';') { |
if ((btype.t & VT_BTYPE) == VT_STRUCT) { |
int v = btype.ref->v; |
if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) >= SYM_FIRST_ANOM) |
tcc_warning("unnamed struct/union that defines no instances"); |
} |
next(); |
continue; |
} |
while (1) { /* iterate thru each declaration */ |
type = btype; |
type_decl(&type, &ad, &v, TYPE_DIRECT); |
#if 0 |
{ |
char buf[500]; |
type_to_str(buf, sizeof(buf), t, get_tok_str(v, NULL)); |
printf("type = '%s'\n", buf); |
} |
#endif |
if ((type.t & VT_BTYPE) == VT_FUNC) { |
if ((type.t & VT_STATIC) && (l == VT_LOCAL)) { |
tcc_error("function without file scope cannot be static"); |
} |
/* if old style function prototype, we accept a |
declaration list */ |
sym = type.ref; |
if (sym->c == FUNC_OLD) |
func_decl_list(sym); |
} |
|
if (gnu_ext && (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3)) { |
ad.asm_label = asm_label_instr(); |
/* parse one last attribute list, after asm label */ |
parse_attribute(&ad); |
if (tok == '{') |
expect(";"); |
} |
|
if (ad.a.weak) |
type.t |= VT_WEAK; |
#ifdef TCC_TARGET_PE |
if (ad.a.func_import) |
type.t |= VT_IMPORT; |
if (ad.a.func_export) |
type.t |= VT_EXPORT; |
#endif |
type.t |= ad.a.visibility << VT_VIS_SHIFT; |
|
if (tok == '{') { |
if (l == VT_LOCAL) |
tcc_error("cannot use local functions"); |
if ((type.t & VT_BTYPE) != VT_FUNC) |
expect("function definition"); |
|
/* reject abstract declarators in function definition */ |
sym = type.ref; |
while ((sym = sym->next) != NULL) |
if (!(sym->v & ~SYM_FIELD)) |
expect("identifier"); |
|
/* XXX: cannot do better now: convert extern line to static inline */ |
if ((type.t & (VT_EXTERN | VT_INLINE)) == (VT_EXTERN | VT_INLINE)) |
type.t = (type.t & ~VT_EXTERN) | VT_STATIC; |
|
sym = sym_find(v); |
if (sym) { |
Sym *ref; |
if ((sym->type.t & VT_BTYPE) != VT_FUNC) |
goto func_error1; |
|
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 (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 (ref->a.func_export) |
type.ref->a.func_export = 1; |
|
/* use static from prototype */ |
if (sym->type.t & VT_STATIC) |
type.t = (type.t & ~VT_EXTERN) | VT_STATIC; |
|
/* If the definition has no visibility use the |
one from prototype. */ |
if (! (type.t & VT_VIS_MASK)) |
type.t |= sym->type.t & VT_VIS_MASK; |
|
if (!is_compatible_types(&sym->type, &type)) { |
func_error1: |
tcc_error("incompatible types for redefinition of '%s'", |
get_tok_str(v, NULL)); |
} |
type.ref->a.func_proto = 0; |
/* if symbol is already defined, then put complete type */ |
sym->type = type; |
} else { |
/* put function symbol */ |
sym = global_identifier_push(v, type.t, 0); |
sym->type.ref = type.ref; |
} |
|
/* static inline functions are just recorded as a kind |
of macro. Their code will be emitted at the end of |
the compilation unit only if they are used */ |
if ((type.t & (VT_INLINE | VT_STATIC)) == |
(VT_INLINE | VT_STATIC)) { |
int block_level; |
struct InlineFunc *fn; |
const char *filename; |
|
filename = file ? file->filename : ""; |
fn = tcc_malloc(sizeof *fn + strlen(filename)); |
strcpy(fn->filename, filename); |
fn->sym = sym; |
tok_str_new(&fn->func_str); |
|
block_level = 0; |
for(;;) { |
int t; |
if (tok == TOK_EOF) |
tcc_error("unexpected end of file"); |
tok_str_add_tok(&fn->func_str); |
t = tok; |
next(); |
if (t == '{') { |
block_level++; |
} else if (t == '}') { |
block_level--; |
if (block_level == 0) |
break; |
} |
} |
tok_str_add(&fn->func_str, -1); |
tok_str_add(&fn->func_str, 0); |
dynarray_add((void ***)&tcc_state->inline_fns, &tcc_state->nb_inline_fns, fn); |
|
} else { |
/* compute text section */ |
cur_text_section = ad.section; |
if (!cur_text_section) |
cur_text_section = text_section; |
sym->r = VT_SYM | VT_CONST; |
gen_function(sym); |
} |
break; |
} else { |
if (btype.t & VT_TYPEDEF) { |
/* save typedefed type */ |
/* XXX: test storage specifiers ? */ |
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.a.func_proto = 1; |
type.ref->a = ad.a; |
} else if (!(type.t & VT_ARRAY)) { |
/* not lvalue if array */ |
r |= lvalue_type(type.t); |
} |
has_init = (tok == '='); |
if (has_init && (type.t & VT_VLA)) |
tcc_error("Variable length array cannot be initialized"); |
if ((btype.t & VT_EXTERN) || ((type.t & VT_BTYPE) == VT_FUNC) || |
((type.t & VT_ARRAY) && (type.t & VT_STATIC) && |
!has_init && l == VT_CONST && type.ref->c < 0)) { |
/* external variable or function */ |
/* NOTE: as GCC, uninitialized global static |
arrays of null size are considered as |
extern */ |
sym = external_sym(v, &type, r); |
sym->asm_label = ad.asm_label; |
|
if (ad.alias_target) { |
Section tsec; |
Elf32_Sym *esym; |
Sym *alias_target; |
|
alias_target = sym_find(ad.alias_target); |
if (!alias_target || !alias_target->c) |
tcc_error("unsupported forward __alias__ attribute"); |
esym = &((Elf32_Sym *)symtab_section->data)[alias_target->c]; |
tsec.sh_num = esym->st_shndx; |
put_extern_sym2(sym, &tsec, esym->st_value, esym->st_size, 0); |
} |
} else { |
type.t |= (btype.t & VT_STATIC); /* Retain "static". */ |
if (type.t & VT_STATIC) |
r |= VT_CONST; |
else |
r |= l; |
if (has_init) |
next(); |
decl_initializer_alloc(&type, &ad, r, has_init, v, l); |
} |
} |
if (tok != ',') { |
if (is_for_loop_init) |
return 1; |
skip(';'); |
break; |
} |
next(); |
} |
ad.a.aligned = 0; |
} |
} |
return 0; |
} |
|
ST_FUNC void decl(int l) |
{ |
decl0(l, 0); |
} |