roska
/
tinycc
mirror of https://repo.or.cz/tinycc.git
1
0
Fork 0
Code
tinycc/tccgen.c

8708 lines
253 KiB
C
Raw Permalink Blame History

/*
* 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
*/
#define USING_GLOBALS
#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 Sym *global_stack;
ST_DATA Sym *local_stack;
ST_DATA Sym *define_stack;
ST_DATA Sym *global_label_stack;
ST_DATA Sym *local_label_stack;
static Sym *sym_free_first;
static void **sym_pools;
static int nb_sym_pools;
static Sym *all_cleanups, *pending_gotos;
static int local_scope;
ST_DATA char debug_modes;
ST_DATA SValue *vtop;
static SValue _vstack[1 + VSTACK_SIZE];
#define vstack (_vstack + 1)
ST_DATA int nocode_wanted; /* no code generation wanted */
#define NODATA_WANTED (nocode_wanted > 0) /* no static data output wanted either */
#define DATA_ONLY_WANTED 0x80000000 /* ON outside of functions and for static initializers */
/* no code output after unconditional jumps such as with if (0) ... */
#define CODE_OFF_BIT 0x20000000
#define CODE_OFF() if(!nocode_wanted)(nocode_wanted |= CODE_OFF_BIT)
#define CODE_ON() (nocode_wanted &= ~CODE_OFF_BIT)
/* no code output when parsing sizeof()/typeof() etc. (using nocode_wanted++/--) */
#define NOEVAL_MASK 0x0000FFFF
#define NOEVAL_WANTED (nocode_wanted & NOEVAL_MASK)
/* no code output when parsing constant expressions */
#define CONST_WANTED_BIT 0x00010000
#define CONST_WANTED_MASK 0x0FFF0000
#define CONST_WANTED (nocode_wanted & CONST_WANTED_MASK)
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 func_ind;
ST_DATA const char *funcname;
ST_DATA CType int_type, func_old_type, char_type, char_pointer_type;
static CString initstr;
#if PTR_SIZE == 4
#define VT_SIZE_T (VT_INT | VT_UNSIGNED)
#define VT_PTRDIFF_T VT_INT
#elif LONG_SIZE == 4
#define VT_SIZE_T (VT_LLONG | VT_UNSIGNED)
#define VT_PTRDIFF_T VT_LLONG
#else
#define VT_SIZE_T (VT_LONG | VT_LLONG | VT_UNSIGNED)
#define VT_PTRDIFF_T (VT_LONG | VT_LLONG)
#endif
static struct switch_t {
struct case_t {
int64_t v1, v2;
int sym;
} **p; int n; /* list of case ranges */
int def_sym; /* default symbol */
int nocode_wanted;
int *bsym;
struct scope *scope;
struct switch_t *prev;
SValue sv;
} *cur_switch; /* current switch */
#define MAX_TEMP_LOCAL_VARIABLE_NUMBER 8
/*list of temporary local variables on the stack in current function. */
static struct temp_local_variable {
int location; //offset on stack. Svalue.c.i
short size;
short align;
} arr_temp_local_vars[MAX_TEMP_LOCAL_VARIABLE_NUMBER];
static int nb_temp_local_vars;
static struct scope {
struct scope *prev;
struct { int loc, locorig, num; } vla;
struct { Sym *s; int n; } cl;
int *bsym, *csym;
Sym *lstk, *llstk;
} *cur_scope, *loop_scope, *root_scope;
typedef struct {
Section *sec;
int local_offset;
Sym *flex_array_ref;
} init_params;
#if 1
#define precedence_parser
static void init_prec(void);
#endif
static void block(int flags);
#define STMT_EXPR 1
#define STMT_COMPOUND 2
static void gen_cast(CType *type);
static void gen_cast_s(int t);
static inline CType *pointed_type(CType *type);
static int is_compatible_types(CType *type1, CType *type2);
static int parse_btype(CType *type, AttributeDef *ad, int ignore_label);
static CType *type_decl(CType *type, AttributeDef *ad, int *v, int td);
static void parse_expr_type(CType *type);
static void init_putv(init_params *p, CType *type, unsigned long c);
static void decl_initializer(init_params *p, CType *type, unsigned long c, int flags);
static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, int has_init, int v, int scope);
static int decl(int l);
static void expr_eq(void);
static void vpush_type_size(CType *type, int *a);
static int is_compatible_unqualified_types(CType *type1, CType *type2);
static inline int64_t expr_const64(void);
static void vpush64(int ty, unsigned long long v);
static void vpush(CType *type);
static int gvtst(int inv, int t);
static void gen_inline_functions(TCCState *s);
static void free_inline_functions(TCCState *s);
static void skip_or_save_block(TokenString **str);
static void gv_dup(void);
static int get_temp_local_var(int size,int align);
static void clear_temp_local_var_list();
static void cast_error(CType *st, CType *dt);
static void end_switch(void);
/* ------------------------------------------------------------------------- */
/* Automagical code suppression */
/* Clear 'nocode_wanted' at forward label if it was used */
ST_FUNC void gsym(int t)
{
if (t) {
gsym_addr(t, ind);
CODE_ON();
}
}
/* Clear 'nocode_wanted' if current pc is a label */
static int gind()
{
int t = ind;
CODE_ON();
if (debug_modes)
tcc_tcov_block_begin(tcc_state);
return t;
}
/* Set 'nocode_wanted' after unconditional (backwards) jump */
static void gjmp_addr_acs(int t)
{
gjmp_addr(t);
CODE_OFF();
}
/* Set 'nocode_wanted' after unconditional (forwards) jump */
static int gjmp_acs(int t)
{
t = gjmp(t);
CODE_OFF();
return t;
}
/* These are #undef'd at the end of this file */
#define gjmp_addr gjmp_addr_acs
#define gjmp gjmp_acs
/* ------------------------------------------------------------------------- */
ST_INLN int is_float(int t)
{
int bt = t & VT_BTYPE;
return bt == VT_LDOUBLE
|| bt == VT_DOUBLE
|| bt == VT_FLOAT
|| bt == VT_QFLOAT;
}
static inline int is_integer_btype(int bt)
{
return bt == VT_BYTE
|| bt == VT_BOOL
|| bt == VT_SHORT
|| bt == VT_INT
|| bt == VT_LLONG;
}
static int btype_size(int bt)
{
return bt == VT_BYTE || bt == VT_BOOL ? 1 :
bt == VT_SHORT ? 2 :
bt == VT_INT ? 4 :
bt == VT_LLONG ? 8 :
bt == VT_PTR ? PTR_SIZE : 0;
}
/* returns function return register from type */
static int R_RET(int t)
{
if (!is_float(t))
return REG_IRET;
#ifdef TCC_TARGET_X86_64
if ((t & VT_BTYPE) == VT_LDOUBLE)
return TREG_ST0;
#elif defined TCC_TARGET_RISCV64
if ((t & VT_BTYPE) == VT_LDOUBLE)
return REG_IRET;
#endif
return REG_FRET;
}
/* returns 2nd function return register, if any */
static int R2_RET(int t)
{
t &= VT_BTYPE;
#if PTR_SIZE == 4
if (t == VT_LLONG)
return REG_IRE2;
#elif defined TCC_TARGET_X86_64
if (t == VT_QLONG)
return REG_IRE2;
if (t == VT_QFLOAT)
return REG_FRE2;
#elif defined TCC_TARGET_RISCV64
if (t == VT_LDOUBLE)
return REG_IRE2;
#endif
return VT_CONST;
}
/* returns true for two-word types */
#define USING_TWO_WORDS(t) (R2_RET(t) != VT_CONST)
/* put function return registers to stack value */
static void PUT_R_RET(SValue *sv, int t)
{
sv->r = R_RET(t), sv->r2 = R2_RET(t);
}
/* returns function return register class for type t */
static int RC_RET(int t)
{
return reg_classes[R_RET(t)] & ~(RC_FLOAT | RC_INT);
}
/* returns generic register class for type t */
static int RC_TYPE(int t)
{
if (!is_float(t))
return RC_INT;
#ifdef TCC_TARGET_X86_64
if ((t & VT_BTYPE) == VT_LDOUBLE)
return RC_ST0;
if ((t & VT_BTYPE) == VT_QFLOAT)
return RC_FRET;
#elif defined TCC_TARGET_RISCV64
if ((t & VT_BTYPE) == VT_LDOUBLE)
return RC_INT;
#endif
return RC_FLOAT;
}
/* returns 2nd register class corresponding to t and rc */
static int RC2_TYPE(int t, int rc)
{
if (!USING_TWO_WORDS(t))
return 0;
#ifdef RC_IRE2
if (rc == RC_IRET)
return RC_IRE2;
#endif
#ifdef RC_FRE2
if (rc == RC_FRET)
return RC_FRE2;
#endif
if (rc & RC_FLOAT)
return RC_FLOAT;
return RC_INT;
}
/* 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;
}
/* compiling intel long double natively */
#if (defined __i386__ || defined __x86_64__) \
&& (defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64)
# define TCC_IS_NATIVE_387
#endif
ST_FUNC void test_lvalue(void)
{
if (!(vtop->r & VT_LVAL))
expect("lvalue");
}
ST_FUNC void check_vstack(void)
{
if (vtop != vstack - 1)
tcc_error("internal compiler error: vstack leak (%d)",
(int)(vtop - vstack + 1));
}
/* vstack debugging aid */
#if 0
void pv (const char *lbl, int a, int b)
{
int i;
for (i = a; i < a + b; ++i) {
SValue *p = &vtop[-i];
printf("%s vtop[-%d] : type.t:%04x r:%04x r2:%04x c.i:%d\n",
lbl, i, p->type.t, p->r, p->r2, (int)p->c.i);
}
}
#endif
/* ------------------------------------------------------------------------- */
/* initialize vstack and types. This must be done also for tcc -E */
ST_FUNC void tccgen_init(TCCState *s1)
{
vtop = vstack - 1;
memset(vtop, 0, sizeof *vtop);
/* define some often used types */
int_type.t = VT_INT;
char_type.t = VT_BYTE;
if (s1->char_is_unsigned)
char_type.t |= VT_UNSIGNED;
char_pointer_type = char_type;
mk_pointer(&char_pointer_type);
func_old_type.t = VT_FUNC;
func_old_type.ref = sym_push(SYM_FIELD, &int_type, 0, 0);
func_old_type.ref->f.func_call = FUNC_CDECL;
func_old_type.ref->f.func_type = FUNC_OLD;
#ifdef precedence_parser
init_prec();
#endif
cstr_new(&initstr);
}
ST_FUNC int tccgen_compile(TCCState *s1)
{
funcname = "";
func_ind = -1;
anon_sym = SYM_FIRST_ANOM;
nocode_wanted = DATA_ONLY_WANTED; /* no code outside of functions */
debug_modes = (s1->do_debug ? 1 : 0) | s1->test_coverage << 1;
tcc_debug_start(s1);
tcc_tcov_start (s1);
#ifdef TCC_TARGET_ARM
arm_init(s1);
#endif
#ifdef INC_DEBUG
printf("%s: **** new file\n", file->filename);
#endif
parse_flags = PARSE_FLAG_PREPROCESS | PARSE_FLAG_TOK_NUM | PARSE_FLAG_TOK_STR;
next();
decl(VT_CONST);
gen_inline_functions(s1);
check_vstack();
/* end of translation unit info */
tcc_debug_end(s1);
tcc_tcov_end(s1);
return 0;
}
ST_FUNC void tccgen_finish(TCCState *s1)
{
tcc_debug_end(s1); /* just in case of errors: free memory */
free_inline_functions(s1);
sym_pop(&global_stack, NULL, 0);
sym_pop(&local_stack, NULL, 0);
/* free preprocessor macros */
free_defines(NULL);
/* free sym_pools */
dynarray_reset(&sym_pools, &nb_sym_pools);
cstr_free(&initstr);
dynarray_reset(&stk_data, &nb_stk_data);
while (cur_switch)
end_switch();
local_scope = 0;
loop_scope = NULL;
all_cleanups = NULL;
pending_gotos = NULL;
nb_temp_local_vars = 0;
global_label_stack = NULL;
local_label_stack = NULL;
cur_text_section = NULL;
sym_free_first = NULL;
}
/* ------------------------------------------------------------------------- */
ST_FUNC ElfSym *elfsym(Sym *s)
{
if (!s || !s->c)
return NULL;
return &((ElfSym *)symtab_section->data)[s->c];
}
/* apply storage attributes to Elf symbol */
ST_FUNC void update_storage(Sym *sym)
{
ElfSym *esym;
int sym_bind, old_sym_bind;
esym = elfsym(sym);
if (!esym)
return;
if (sym->a.visibility)
esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1))
| sym->a.visibility;
if (sym->type.t & (VT_STATIC | VT_INLINE))
sym_bind = STB_LOCAL;
else if (sym->a.weak)
sym_bind = STB_WEAK;
else
sym_bind = STB_GLOBAL;
old_sym_bind = ELFW(ST_BIND)(esym->st_info);
if (sym_bind != old_sym_bind) {
esym->st_info = ELFW(ST_INFO)(sym_bind, ELFW(ST_TYPE)(esym->st_info));
}
#ifdef TCC_TARGET_PE
if (sym->a.dllimport)
esym->st_other |= ST_PE_IMPORT;
if (sym->a.dllexport)
esym->st_other |= ST_PE_EXPORT;
#endif
#if 0
printf("storage %s: bind=%c vis=%d exp=%d imp=%d\n",
get_tok_str(sym->v, NULL),
sym_bind == STB_WEAK ? 'w' : sym_bind == STB_LOCAL ? 'l' : 'g',
sym->a.visibility,
sym->a.dllexport,
sym->a.dllimport
);
#endif
}
/* ------------------------------------------------------------------------- */
/* update sym->c so that it points to an external symbol in section
'section' with value 'value' */
ST_FUNC void put_extern_sym2(Sym *sym, int sh_num,
addr_t value, unsigned long size,
int can_add_underscore)
{
int sym_type, sym_bind, info, other, t;
ElfSym *esym;
const char *name;
char buf1[256];
if (!sym->c) {
name = get_tok_str(sym->v, NULL);
t = sym->type.t;
if ((t & VT_BTYPE) == VT_FUNC) {
sym_type = STT_FUNC;
} else if ((t & VT_BTYPE) == VT_VOID) {
sym_type = STT_NOTYPE;
if ((t & (VT_BTYPE|VT_ASM_FUNC)) == VT_ASM_FUNC)
sym_type = STT_FUNC;
} else {
sym_type = STT_OBJECT;
}
if (t & (VT_STATIC | VT_INLINE))
sym_bind = STB_LOCAL;
else
sym_bind = STB_GLOBAL;
other = 0;
#ifdef TCC_TARGET_PE
if (sym_type == STT_FUNC && sym->type.ref) {
Sym *ref = sym->type.ref;
if (ref->a.nodecorate) {
can_add_underscore = 0;
}
if (ref->f.func_call == FUNC_STDCALL && can_add_underscore) {
sprintf(buf1, "_%s@%d", name, ref->f.func_args * PTR_SIZE);
name = buf1;
other |= ST_PE_STDCALL;
can_add_underscore = 0;
}
}
#endif
if (sym->asm_label) {
name = get_tok_str(sym->asm_label, NULL);
can_add_underscore = 0;
}
if (tcc_state->leading_underscore && can_add_underscore) {
buf1[0] = '_';
pstrcpy(buf1 + 1, sizeof(buf1) - 1, name);
name = buf1;
}
info = ELFW(ST_INFO)(sym_bind, sym_type);
sym->c = put_elf_sym(symtab_section, value, size, info, other, sh_num, name);
if (debug_modes)
tcc_debug_extern_sym(tcc_state, sym, sh_num, sym_bind, sym_type);
} else {
esym = elfsym(sym);
esym->st_value = value;
esym->st_size = size;
esym->st_shndx = sh_num;
}
update_storage(sym);
}
ST_FUNC void put_extern_sym(Sym *sym, Section *s, addr_t value, unsigned long size)
{
if (nocode_wanted && (NODATA_WANTED || (s && s == cur_text_section)))
return;
put_extern_sym2(sym, s ? s->sh_num : SHN_UNDEF, value, size, 1);
}
/* add a new relocation entry to symbol 'sym' in section 's' */
ST_FUNC void greloca(Section *s, Sym *sym, unsigned long offset, int type,
addr_t addend)
{
int c = 0;
if (nocode_wanted && s == cur_text_section)
return;
if (sym) {
if (0 == sym->c)
put_extern_sym(sym, NULL, 0, 0);
c = sym->c;
}
/* now we can add ELF relocation info */
put_elf_reloca(symtab_section, s, offset, type, c, addend);
}
#if PTR_SIZE == 4
ST_FUNC void greloc(Section *s, Sym *sym, unsigned long offset, int type)
{
greloca(s, sym, offset, type, 0);
}
#endif
/* ------------------------------------------------------------------------- */
/* 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;
#ifndef SYM_DEBUG
sym = sym_free_first;
if (!sym)
sym = __sym_malloc();
sym_free_first = sym->next;
return sym;
#else
sym = tcc_malloc(sizeof(Sym));
return sym;
#endif
}
ST_INLN void sym_free(Sym *sym)
{
#ifndef SYM_DEBUG
sym->next = sym_free_first;
sym_free_first = sym;
#else
tcc_free(sym);
#endif
}
/* push, without hashing */
ST_FUNC Sym *sym_push2(Sym **ps, int v, int t, int c)
{
Sym *s;
s = sym_malloc();
memset(s, 0, sizeof *s);
s->v = v;
s->type.t = t;
s->c = c;
/* 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;
}
static int sym_scope(Sym *s)
{
if (IS_ENUM_VAL (s->type.t))
return s->type.ref->sym_scope;
else
return s->sym_scope;
}
/* 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;
s->sym_scope = local_scope;
if (s->prev_tok && sym_scope(s->prev_tok) == s->sym_scope)
tcc_error("redeclaration of '%s'",
get_tok_str(v & ~SYM_STRUCT, NULL));
}
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);
s->r = VT_CONST | VT_SYM;
/* 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; happens when called from inline asm */
while (*ps != NULL && (*ps)->sym_scope)
ps = &(*ps)->prev_tok;
s->prev_tok = *ps;
*ps = s;
}
return s;
}
/* pop symbols until top reaches 'b'. If KEEP is non-zero don't really
pop them yet from the list, but do remove them from the token array. */
ST_FUNC void sym_pop(Sym **ptop, Sym *b, int keep)
{
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;
}
if (!keep)
sym_free(s);
s = ss;
}
if (!keep)
*ptop = b;
}
/* label lookup */
ST_FUNC Sym *label_find(int v)
{
v -= TOK_IDENT;
if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
return NULL;
return table_ident[v]->sym_label;
}
ST_FUNC Sym *label_push(Sym **ptop, int v, int flags)
{
Sym *s, **ps;
s = sym_push2(ptop, v, VT_STATIC, 0);
s->r = flags;
ps = &table_ident[v - TOK_IDENT]->sym_label;
if (ptop == &global_label_stack) {
/* 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 = *ps;
*ps = s;
return s;
}
/* pop labels until element last is reached. Look if any labels are
undefined. Define symbols if '&&label' was used. */
ST_FUNC void label_pop(Sym **ptop, Sym *slast, int keep)
{
Sym *s, *s1;
for(s = *ptop; s != slast; s = s1) {
s1 = s->prev;
if (s->r == LABEL_DECLARED) {
tcc_warning_c(warn_all)("label '%s' declared but not used", get_tok_str(s->v, NULL));
} else if (s->r == LABEL_FORWARD) {
tcc_error("label '%s' used but not defined",
get_tok_str(s->v, NULL));
} else {
if (s->c) {
/* define corresponding symbol. A size of
1 is put. */
put_extern_sym(s, cur_text_section, s->jnext, 1);
}
}
/* remove label */
if (s->r != LABEL_GONE)
table_ident[s->v - TOK_IDENT]->sym_label = s->prev_tok;
if (!keep)
sym_free(s);
else
s->r = LABEL_GONE;
}
if (!keep)
*ptop = slast;
}
/* ------------------------------------------------------------------------- */
static void vcheck_cmp(void)
{
/* 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.
Don't do this when nocode_wanted. vtop might come from
!nocode_wanted regions (see 88_codeopt.c) and transforming
it to a register without actually generating code is wrong
as their value might still be used for real. All values
we push under nocode_wanted will eventually be popped
again, so that the VT_CMP/VT_JMP value will be in vtop
when code is unsuppressed again. */
/* However if it's just automatic suppression via CODE_OFF/ON()
then it seems that we better let things work undisturbed.
How can it work at all under nocode_wanted? Well, gv() will
actually clear it at the gsym() in load()/VT_JMP in the
generator backends */
if (vtop->r == VT_CMP && 0 == (nocode_wanted & ~CODE_OFF_BIT))
gv(RC_INT);
}
static void vsetc(CType *type, int r, CValue *vc)
{
if (vtop >= vstack + (VSTACK_SIZE - 1))
tcc_error("memory full (vstack)");
vcheck_cmp();
vtop++;
vtop->type = *type;
vtop->r = r;
vtop->r2 = VT_CONST;
vtop->c = *vc;
vtop->sym = NULL;
}
ST_FUNC void vswap(void)
{
SValue tmp;
vcheck_cmp();
tmp = vtop[0];
vtop[0] = vtop[-1];
vtop[-1] = tmp;
}
/* 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) {
o(0xd8dd); /* fstp %st(0) */
} else
#endif
if (v == VT_CMP) {
/* need to put correct jump if && or || without test */
gsym(vtop->jtrue);
gsym(vtop->jfalse);
}
vtop--;
}
/* push constant of type "type" with useless value */
static void vpush(CType *type)
{
vset(type, VT_CONST, 0);
}
/* push arbitrary 64bit constant */
static 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 integer constant */
ST_FUNC void vpushi(int v)
{
vpush64(VT_INT, v);
}
/* push a pointer sized constant */
static void vpushs(addr_t v)
{
vpush64(VT_SIZE_T, v);
}
/* push long long constant */
static inline void vpushll(long long v)
{
vpush64(VT_LLONG, v);
}
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 = NULL;
vset(&type, r, v);
}
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);
}
/* 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;
vcheck_cmp();
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;
vcheck_cmp();
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);
}
/* ------------------------------------------------------------------------- */
/* vtop->r = VT_CMP means CPU-flags have been set from comparison or test. */
/* called from generators to set the result from relational ops */
ST_FUNC void vset_VT_CMP(int op)
{
vtop->r = VT_CMP;
vtop->cmp_op = op;
vtop->jfalse = 0;
vtop->jtrue = 0;
}
/* called once before asking generators to load VT_CMP to a register */
static void vset_VT_JMP(void)
{
int op = vtop->cmp_op;
if (vtop->jtrue || vtop->jfalse) {
int origt = vtop->type.t;
/* we need to jump to 'mov $0,%R' or 'mov $1,%R' */
int inv = op & (op < 2); /* small optimization */
vseti(VT_JMP+inv, gvtst(inv, 0));
vtop->type.t |= origt & (VT_UNSIGNED | VT_DEFSIGN);
} else {
/* otherwise convert flags (rsp. 0/1) to register */
vtop->c.i = op;
if (op < 2) /* doesn't seem to happen */
vtop->r = VT_CONST;
}
}
/* Set CPU Flags, doesn't yet jump */
static void gvtst_set(int inv, int t)
{
int *p;
if (vtop->r != VT_CMP) {
vpushi(0);
gen_op(TOK_NE);
if (vtop->r != VT_CMP) /* must be VT_CONST then */
vset_VT_CMP(vtop->c.i != 0);
}
p = inv ? &vtop->jfalse : &vtop->jtrue;
*p = gjmp_append(*p, t);
}
/* Generate value test
*
* Generate a test for any value (jump, comparison and integers) */
static int gvtst(int inv, int t)
{
int op, x, u;
gvtst_set(inv, t);
t = vtop->jtrue, u = vtop->jfalse;
if (inv)
x = u, u = t, t = x;
op = vtop->cmp_op;
/* jump to the wanted target */
if (op > 1)
t = gjmp_cond(op ^ inv, t);
else if (op != inv)
t = gjmp(t);
/* resolve complementary jumps to here */
gsym(u);
vtop--;
return t;
}
/* generate a zero or nozero test */
static void gen_test_zero(int op)
{
if (vtop->r == VT_CMP) {
int j;
if (op == TOK_EQ) {
j = vtop->jfalse;
vtop->jfalse = vtop->jtrue;
vtop->jtrue = j;
vtop->cmp_op ^= 1;
}
} else {
vpushi(0);
gen_op(op);
}
}
/* ------------------------------------------------------------------------- */
/* push a symbol value of TYPE */
ST_FUNC 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 = sym_push(v, type, VT_CONST | VT_SYM, 0);
sym->type.t |= VT_STATIC;
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)
{
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;
} else if (IS_ASM_SYM(s)) {
s->type.t = type->t | (s->type.t & VT_EXTERN);
s->type.ref = type->ref;
update_storage(s);
}
return s;
}
/* create an external reference with no specific type similar to asm labels.
This avoids type conflicts if the symbol is used from C too */
ST_FUNC Sym *external_helper_sym(int v)
{
CType ct = { VT_ASM_FUNC, NULL };
return external_global_sym(v, &ct);
}
/* push a reference to an helper function (such as memmove) */
ST_FUNC void vpush_helper_func(int v)
{
vpushsym(&func_old_type, external_helper_sym(v));
}
/* Merge symbol attributes. */
static void merge_symattr(struct SymAttr *sa, struct SymAttr *sa1)
{
if (sa1->aligned && !sa->aligned)
sa->aligned = sa1->aligned;
sa->packed |= sa1->packed;
sa->weak |= sa1->weak;
sa->nodebug |= sa1->nodebug;
if (sa1->visibility != STV_DEFAULT) {
int vis = sa->visibility;
if (vis == STV_DEFAULT
|| vis > sa1->visibility)
vis = sa1->visibility;
sa->visibility = vis;
}
sa->dllexport |= sa1->dllexport;
sa->nodecorate |= sa1->nodecorate;
sa->dllimport |= sa1->dllimport;
}
/* Merge function attributes. */
static void merge_funcattr(struct FuncAttr *fa, struct FuncAttr *fa1)
{
if (fa1->func_call && !fa->func_call)
fa->func_call = fa1->func_call;
if (fa1->func_type && !fa->func_type)
fa->func_type = fa1->func_type;
if (fa1->func_args && !fa->func_args)
fa->func_args = fa1->func_args;
if (fa1->func_noreturn)
fa->func_noreturn = 1;
if (fa1->func_ctor)
fa->func_ctor = 1;
if (fa1->func_dtor)
fa->func_dtor = 1;
}
/* Merge attributes. */
static void merge_attr(AttributeDef *ad, AttributeDef *ad1)
{
merge_symattr(&ad->a, &ad1->a);
merge_funcattr(&ad->f, &ad1->f);
if (ad1->section)
ad->section = ad1->section;
if (ad1->alias_target)
ad->alias_target = ad1->alias_target;
if (ad1->asm_label)
ad->asm_label = ad1->asm_label;
if (ad1->attr_mode)
ad->attr_mode = ad1->attr_mode;
}
/* Merge some type attributes. */
static void patch_type(Sym *sym, CType *type)
{
if (!(type->t & VT_EXTERN) || IS_ENUM_VAL(sym->type.t)) {
if (!(sym->type.t & VT_EXTERN))
tcc_error("redefinition of '%s'", get_tok_str(sym->v, NULL));
sym->type.t &= ~VT_EXTERN;
}
if (IS_ASM_SYM(sym)) {
/* stay static if both are static */
sym->type.t = type->t & (sym->type.t | ~VT_STATIC);
sym->type.ref = type->ref;
if ((type->t & VT_BTYPE) != VT_FUNC && !(type->t & VT_ARRAY))
sym->r |= VT_LVAL;
}
if (!is_compatible_types(&sym->type, type)) {
tcc_error("incompatible types for redefinition of '%s'",
get_tok_str(sym->v, NULL));
} else if ((sym->type.t & VT_BTYPE) == VT_FUNC) {
int static_proto = sym->type.t & VT_STATIC;
/* warn if static follows non-static function declaration */
if ((type->t & VT_STATIC) && !static_proto
/* XXX this test for inline shouldn't be here. Until we
implement gnu-inline mode again it silences a warning for
mingw caused by our workarounds. */
&& !((type->t | sym->type.t) & VT_INLINE))
tcc_warning("static storage ignored for redefinition of '%s'",
get_tok_str(sym->v, NULL));
/* set 'inline' if both agree or if one has static */
if ((type->t | sym->type.t) & VT_INLINE) {
if (!((type->t ^ sym->type.t) & VT_INLINE)
|| ((type->t | sym->type.t) & VT_STATIC))
static_proto |= VT_INLINE;
}
if (0 == (type->t & VT_EXTERN)) {
struct FuncAttr f = sym->type.ref->f;
/* put complete type, use static from prototype */
sym->type.t = (type->t & ~(VT_STATIC|VT_INLINE)) | static_proto;
sym->type.ref = type->ref;
merge_funcattr(&sym->type.ref->f, &f);
} else {
sym->type.t &= ~VT_INLINE | static_proto;
}
if (sym->type.ref->f.func_type == FUNC_OLD
&& type->ref->f.func_type != FUNC_OLD) {
sym->type.ref = type->ref;
}
} else {
if ((sym->type.t & VT_ARRAY) && type->ref->c >= 0) {
/* set array size if it was omitted in extern declaration */
sym->type.ref->c = type->ref->c;
}
if ((type->t ^ sym->type.t) & VT_STATIC)
tcc_warning("storage mismatch for redefinition of '%s'",
get_tok_str(sym->v, NULL));
}
}
/* Merge some storage attributes. */
static void patch_storage(Sym *sym, AttributeDef *ad, CType *type)
{
if (type)
patch_type(sym, type);
#ifdef TCC_TARGET_PE
if (sym->a.dllimport != ad->a.dllimport)
tcc_error("incompatible dll linkage for redefinition of '%s'",
get_tok_str(sym->v, NULL));
#endif
merge_symattr(&sym->a, &ad->a);
if (ad->asm_label)
sym->asm_label = ad->asm_label;
update_storage(sym);
}
/* copy sym to other stack */
static Sym *sym_copy(Sym *s0, Sym **ps)
{
Sym *s;
s = sym_malloc(), *s = *s0;
s->prev = *ps, *ps = s;
if (s->v < SYM_FIRST_ANOM) {
ps = &table_ident[s->v - TOK_IDENT]->sym_identifier;
s->prev_tok = *ps, *ps = s;
}
return s;
}
/* copy s->type.ref to stack 'ps' for VT_FUNC and VT_PTR */
static void sym_copy_ref(Sym *s, Sym **ps)
{
int bt = s->type.t & VT_BTYPE;
if (bt == VT_FUNC || bt == VT_PTR || (bt == VT_STRUCT && s->sym_scope)) {
Sym **sp = &s->type.ref;
for (s = *sp, *sp = NULL; s; s = s->next) {
Sym *s2 = sym_copy(s, ps);
sp = &(*sp = s2)->next;
sym_copy_ref(s2, ps);
}
}
}
/* define a new external reference to a symbol 'v' */
static Sym *external_sym(int v, CType *type, int r, AttributeDef *ad)
{
Sym *s;
/* look for global symbol */
s = sym_find(v);
while (s && s->sym_scope)
s = s->prev_tok;
if (!s) {
/* push forward reference */
s = global_identifier_push(v, type->t, 0);
s->r |= r;
s->a = ad->a;
s->asm_label = ad->asm_label;
s->type.ref = type->ref;
/* copy type to the global stack */
if (local_stack)
sym_copy_ref(s, &global_stack);
} else {
patch_storage(s, ad, type);
}
/* push variables on local_stack if any */
if (local_stack && (s->type.t & VT_BTYPE) != VT_FUNC)
s = sym_copy(s, &local_stack);
return s;
}
/* save registers up to (vtop - n) stack entry */
ST_FUNC void save_regs(int n)
{
SValue *p, *p1;
for(p = vstack, p1 = vtop - n; p <= p1; p++)
save_reg(p->r);
}
/* save r to the memory stack, and mark it as being free */
ST_FUNC void save_reg(int r)
{
save_reg_upstack(r, 0);
}
/* save r to the memory stack, and mark it as being free,
if seen up to (vtop - n) stack entry */
ST_FUNC void save_reg_upstack(int r, int n)
{
int l, size, align, bt;
SValue *p, *p1, sv;
if ((r &= VT_VALMASK) >= VT_CONST)
return;
if (nocode_wanted)
return;
l = 0;
for(p = vstack, p1 = vtop - n; p <= p1; p++) {
if ((p->r & VT_VALMASK) == r || p->r2 == r) {
/* must save value on stack if not already done */
if (!l) {
bt = p->type.t & VT_BTYPE;
if (bt == VT_VOID)
continue;
if ((p->r & VT_LVAL) || bt == VT_FUNC)
bt = VT_PTR;
sv.type.t = bt;
size = type_size(&sv.type, &align);
l = get_temp_local_var(size,align);
sv.r = VT_LOCAL | VT_LVAL;
sv.c.i = l;
store(p->r & VT_VALMASK, &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
/* special long long case */
if (p->r2 < VT_CONST && USING_TWO_WORDS(bt)) {
sv.c.i += PTR_SIZE;
store(p->r2, &sv);
}
}
/* 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 = VT_LVAL | VT_LOCAL;
}
p->sym = NULL;
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 == 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) {
if (nocode_wanted)
return r;
for(p=vstack;p<=vtop;p++) {
if ((p->r & VT_VALMASK) == r ||
p->r2 == 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;
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;
}
/* find a free temporary local variable (return the offset on stack) match the size and align. If none, add new temporary stack variable*/
static int get_temp_local_var(int size,int align){
int i;
struct temp_local_variable *temp_var;
int found_var;
SValue *p;
int r;
char free;
char found;
found=0;
for(i=0;i<nb_temp_local_vars;i++){
temp_var=&arr_temp_local_vars[i];
if(temp_var->size<size||align!=temp_var->align){
continue;
}
/*check if temp_var is free*/
free=1;
for(p=vstack;p<=vtop;p++) {
r=p->r&VT_VALMASK;
if(r==VT_LOCAL||r==VT_LLOCAL){
if(p->c.i==temp_var->location){
free=0;
break;
}
}
}
if(free){
found_var=temp_var->location;
found=1;
break;
}
}
if(!found){
loc = (loc - size) & -align;
if(nb_temp_local_vars<MAX_TEMP_LOCAL_VARIABLE_NUMBER){
temp_var=&arr_temp_local_vars[i];
temp_var->location=loc;
temp_var->size=size;
temp_var->align=align;
nb_temp_local_vars++;
}
found_var=loc;
}
return found_var;
}
static void clear_temp_local_var_list(){
nb_temp_local_vars=0;
}
/* 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)
{
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_LOCAL | VT_LVAL;
}
#ifdef CONFIG_TCC_BCHECK
/* generate a bounded pointer addition */
static void gen_bounded_ptr_add(void)
{
int save = (vtop[-1].r & VT_VALMASK) == VT_LOCAL;
if (save) {
vpushv(&vtop[-1]);
vrott(3);
}
vpush_helper_func(TOK___bound_ptr_add);
vrott(3);
gfunc_call(2);
vtop -= save;
vpushi(0);
/* returned pointer is in REG_IRET */
vtop->r = REG_IRET | VT_BOUNDED;
if (nocode_wanted)
return;
/* relocation offset of the bounding function call point */
vtop->c.i = (cur_text_section->reloc->data_offset - sizeof(ElfW_Rel));
}
/* patch pointer addition in vtop so that pointer dereferencing is
also tested */
static void gen_bounded_ptr_deref(void)
{
addr_t func;
int size, align;
ElfW_Rel *rel;
Sym *sym;
if (nocode_wanted)
return;
size = type_size(&vtop->type, &align);
switch(size) {
case 1: func = TOK___bound_ptr_indir1; break;
case 2: func = TOK___bound_ptr_indir2; break;
case 4: func = TOK___bound_ptr_indir4; break;
case 8: func = TOK___bound_ptr_indir8; break;
case 12: func = TOK___bound_ptr_indir12; break;
case 16: func = TOK___bound_ptr_indir16; break;
default:
/* may happen with struct member access */
return;
}
sym = external_helper_sym(func);
if (!sym->c)
put_extern_sym(sym, NULL, 0, 0);
/* patch relocation */
/* XXX: find a better solution ? */
rel = (ElfW_Rel *)(cur_text_section->reloc->data + vtop->c.i);
rel->r_info = ELFW(R_INFO)(sym->c, ELFW(R_TYPE)(rel->r_info));
}
/* generate lvalue bound code */
static void gbound(void)
{
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)) {
/* 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 |= VT_LVAL;
vtop->type = type1;
}
/* then check for dereferencing */
gen_bounded_ptr_deref();
}
}
/* we need to call __bound_ptr_add before we start to load function
args into registers */
ST_FUNC void gbound_args(int nb_args)
{
int i, v;
SValue *sv;
for (i = 1; i <= nb_args; ++i)
if (vtop[1 - i].r & VT_MUSTBOUND) {
vrotb(i);
gbound();
vrott(i);
}
sv = vtop - nb_args;
if (sv->r & VT_SYM) {
v = sv->sym->v;
if (v == TOK_setjmp
|| v == TOK__setjmp
#ifndef TCC_TARGET_PE
|| v == TOK_sigsetjmp
|| v == TOK___sigsetjmp
#endif
) {
vpush_helper_func(TOK___bound_setjmp);
vpushv(sv + 1);
gfunc_call(1);
func_bound_add_epilog = 1;
}
#if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64
if (v == TOK_alloca)
func_bound_add_epilog = 1;
#endif
#if TARGETOS_NetBSD
if (v == TOK_longjmp) /* undo rename to __longjmp14 */
sv->sym->asm_label = TOK___bound_longjmp;
#endif
}
}
/* Add bounds for local symbols from S to E (via ->prev) */
static void add_local_bounds(Sym *s, Sym *e)
{
for (; s != e; s = s->prev) {
if (!s->v || (s->r & VT_VALMASK) != VT_LOCAL)
continue;
/* Add arrays/structs/unions because we always take address */
if ((s->type.t & VT_ARRAY)
|| (s->type.t & VT_BTYPE) == VT_STRUCT
|| s->a.addrtaken) {
/* add local bound info */
int align, size = type_size(&s->type, &align);
addr_t *bounds_ptr = section_ptr_add(lbounds_section,
2 * sizeof(addr_t));
bounds_ptr[0] = s->c;
bounds_ptr[1] = size;
}
}
}
#endif
/* Wrapper around sym_pop, that potentially also registers local bounds. */
static void pop_local_syms(Sym *b, int keep)
{
#ifdef CONFIG_TCC_BCHECK
if (tcc_state->do_bounds_check && !keep && (local_scope || !func_var))
add_local_bounds(local_stack, b);
#endif
if (debug_modes)
tcc_add_debug_info (tcc_state, !local_scope, local_stack, b);
sym_pop(&local_stack, b, keep);
}
/* increment an lvalue pointer */
static void incr_offset(int offset)
{
int t = vtop->type.t;
gaddrof(); /* remove VT_LVAL */
vtop->type.t = VT_PTRDIFF_T; /* set scalar type */
vpushs(offset);
gen_op('+');
vtop->r |= VT_LVAL;
vtop->type.t = t;
}
static void incr_bf_adr(int o)
{
vtop->type.t = VT_BYTE | VT_UNSIGNED;
incr_offset(o);
}
/* single-byte load mode for packed or otherwise unaligned bitfields */
static void load_packed_bf(CType *type, int bit_pos, int bit_size)
{
int n, o, bits;
save_reg_upstack(vtop->r, 1);
vpush64(type->t & VT_BTYPE, 0); // B X
bits = 0, o = bit_pos >> 3, bit_pos &= 7;
do {
vswap(); // X B
incr_bf_adr(o);
vdup(); // X B B
n = 8 - bit_pos;
if (n > bit_size)
n = bit_size;
if (bit_pos)
vpushi(bit_pos), gen_op(TOK_SHR), bit_pos = 0; // X B Y
if (n < 8)
vpushi((1 << n) - 1), gen_op('&');
gen_cast(type);
if (bits)
vpushi(bits), gen_op(TOK_SHL);
vrotb(3); // B Y X
gen_op('|'); // B X
bits += n, bit_size -= n, o = 1;
} while (bit_size);
vswap(), vpop();
if (!(type->t & VT_UNSIGNED)) {
n = ((type->t & VT_BTYPE) == VT_LLONG ? 64 : 32) - bits;
vpushi(n), gen_op(TOK_SHL);
vpushi(n), gen_op(TOK_SAR);
}
}
/* single-byte store mode for packed or otherwise unaligned bitfields */
static void store_packed_bf(int bit_pos, int bit_size)
{
int bits, n, o, m, c;
c = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
vswap(); // X B
save_reg_upstack(vtop->r, 1);
bits = 0, o = bit_pos >> 3, bit_pos &= 7;
do {
incr_bf_adr(o); // X B
vswap(); //B X
c ? vdup() : gv_dup(); // B V X
vrott(3); // X B V
if (bits)
vpushi(bits), gen_op(TOK_SHR);
if (bit_pos)
vpushi(bit_pos), gen_op(TOK_SHL);
n = 8 - bit_pos;
if (n > bit_size)
n = bit_size;
if (n < 8) {
m = ((1 << n) - 1) << bit_pos;
vpushi(m), gen_op('&'); // X B V1
vpushv(vtop-1); // X B V1 B
vpushi(m & 0x80 ? ~m & 0x7f : ~m);
gen_op('&'); // X B V1 B1
gen_op('|'); // X B V2
}
vdup(), vtop[-1] = vtop[-2]; // X B B V2
vstore(), vpop(); // X B
bits += n, bit_size -= n, bit_pos = 0, o = 1;
} while (bit_size);
vpop(), vpop();
}
static int adjust_bf(SValue *sv, int bit_pos, int bit_size)
{
int t;
if (0 == sv->type.ref)
return 0;
t = sv->type.ref->auxtype;
if (t != -1 && t != VT_STRUCT) {
sv->type.t = (sv->type.t & ~(VT_BTYPE | VT_LONG)) | t;
sv->r |= VT_LVAL;
}
return t;
}
/* 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, r2, r_ok, r2_ok, rc2, bt;
int bit_pos, bit_size, size, align;
/* NOTE: get_reg can modify vstack[] */
if (vtop->type.t & VT_BITFIELD) {
CType type;
bit_pos = BIT_POS(vtop->type.t);
bit_size = BIT_SIZE(vtop->type.t);
/* remove bit field info to avoid loops */
vtop->type.t &= ~VT_STRUCT_MASK;
type.ref = NULL;
type.t = vtop->type.t & VT_UNSIGNED;
if ((vtop->type.t & VT_BTYPE) == VT_BOOL)
type.t |= VT_UNSIGNED;
r = adjust_bf(vtop, bit_pos, bit_size);
if ((vtop->type.t & VT_BTYPE) == VT_LLONG)
type.t |= VT_LLONG;
else
type.t |= VT_INT;
if (r == VT_STRUCT) {
load_packed_bf(&type, bit_pos, bit_size);
} else {
int bits = (type.t & VT_BTYPE) == VT_LLONG ? 64 : 32;
/* cast to int to propagate signedness in following ops */
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) {
/* CPUs usually cannot use float constants, so we store them
generically in data segment */
init_params p = { rodata_section };
unsigned long offset;
size = type_size(&vtop->type, &align);
if (NODATA_WANTED)
size = 0, align = 1;
offset = section_add(p.sec, size, align);
vpush_ref(&vtop->type, p.sec, offset, size);
vswap();
init_putv(&p, &vtop->type, offset);
vtop->r |= VT_LVAL;
}
#ifdef CONFIG_TCC_BCHECK
if (vtop->r & VT_MUSTBOUND)
gbound();
#endif
bt = vtop->type.t & VT_BTYPE;
#ifdef TCC_TARGET_RISCV64
/* XXX mega hack */
if (bt == VT_LDOUBLE && rc == RC_FLOAT)
rc = RC_INT;
#endif
rc2 = RC2_TYPE(bt, rc);
/* need to reload if:
- constant
- lvalue (need to dereference pointer)
- already a register, but not in the right class */
r = vtop->r & VT_VALMASK;
r_ok = !(vtop->r & VT_LVAL) && (r < VT_CONST) && (reg_classes[r] & rc);
r2_ok = !rc2 || ((vtop->r2 < VT_CONST) && (reg_classes[vtop->r2] & rc2));
if (!r_ok || !r2_ok) {
if (!r_ok) {
if (1 /* we can 'mov (r),r' in cases */
&& r < VT_CONST
&& (reg_classes[r] & rc)
&& !rc2
)
save_reg_upstack(r, 1);
else
r = get_reg(rc);
}
if (rc2) {
int load_type = (bt == VT_QFLOAT) ? VT_DOUBLE : VT_PTRDIFF_T;
int original_type = vtop->type.t;
/* two register type load :
expand to two words temporarily */
if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
/* load constant */
unsigned long long 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 if (vtop->r & VT_LVAL) {
/* We do not want to modifier the long long pointer here.
So we save any other instances down the stack */
save_reg_upstack(vtop->r, 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 */
incr_offset(PTR_SIZE);
} else {
/* move registers */
if (!r_ok)
load(r, vtop);
if (r2_ok && vtop->r2 < VT_CONST)
goto done;
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;
done:
vtop->type.t = original_type;
} else {
if (vtop->r == VT_CMP)
vset_VT_JMP();
/* one register type load */
load(r, vtop);
}
}
vtop->r = r;
#ifdef TCC_TARGET_C67
/* uses register pairs for doubles */
if (bt == 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)
{
/* generate more generic register first. But VT_JMP or VT_CMP
values must be generated first in all cases to avoid possible
reload errors */
if (vtop->r != VT_CMP && 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);
}
}
}
#if PTR_SIZE == 4
/* expand 64bit on stack in two ints */
ST_FUNC void lexpand(void)
{
int u, v;
u = vtop->type.t & (VT_DEFSIGN | VT_UNSIGNED);
v = vtop->r & (VT_VALMASK | VT_LVAL);
if (v == VT_CONST) {
vdup();
vtop[0].c.i >>= 32;
} else if (v == (VT_LVAL|VT_CONST) || v == (VT_LVAL|VT_LOCAL)) {
vdup();
vtop[0].c.i += 4;
} else {
gv(RC_INT);
vdup();
vtop[0].r = vtop[-1].r2;
vtop[0].r2 = vtop[-1].r2 = VT_CONST;
}
vtop[0].type.t = vtop[-1].type.t = VT_INT | u;
}
#endif
#if PTR_SIZE == 4
/* 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();
}
#endif
/* convert stack entry to register and duplicate its value in another
register */
static void gv_dup(void)
{
int t, rc, r;
t = vtop->type.t;
#if PTR_SIZE == 4
if ((t & VT_BTYPE) == VT_LLONG) {
if (t & VT_BITFIELD) {
gv(RC_INT);
t = vtop->type.t;
}
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();
return;
}
#endif
/* duplicate value */
rc = RC_TYPE(t);
gv(rc);
r = get_reg(rc);
vdup();
load(r, vtop);
vtop->r = r;
}
#if PTR_SIZE == 4
/* 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_IRE2;
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_helper_func(func);
vrott(3);
gfunc_call(2);
vpushi(0);
vtop->r = reg_iret;
vtop->r2 = reg_lret;
break;
case '^':
case '&':
case '|':
case '*':
case '+':
case '-':
//pv("gen_opl A",0,2);
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 */
//pv("gen_opl B",0,4);
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 swapping 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 */
save_regs(4);
/* 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 (op == TOK_NE) {
b = gvtst(0, 0);
} else {
a = gvtst(1, 0);
if (op != TOK_EQ) {
/* generate non equal test */
vpushi(0);
vset_VT_CMP(TOK_NE);
b = gvtst(0, 0);
}
}
/* 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);
#if 0//def TCC_TARGET_I386
if (op == TOK_NE) { gsym(b); break; }
if (op == TOK_EQ) { gsym(a); break; }
#endif
gvtst_set(1, a);
gvtst_set(0, b);
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;
int r;
if (t1 != VT_LLONG && (PTR_SIZE != 8 || t1 != VT_PTR))
l1 = ((uint32_t)l1 |
(v1->type.t & VT_UNSIGNED ? 0 : -(l1 & 0x80000000)));
if (t2 != VT_LLONG && (PTR_SIZE != 8 || t2 != VT_PTR))
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 && !NOEVAL_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;
}
if (t1 != VT_LLONG && (PTR_SIZE != 8 || t1 != VT_PTR))
l1 = ((uint32_t)l1 |
(v1->type.t & VT_UNSIGNED ? 0 : -(l1 & 0x80000000)));
v1->c.i = l1;
v1->r |= v2->r & VT_NONCONST;
vtop--;
} else {
/* if commutative ops, put c2 as constant */
if (c1 && (op == '+' || op == '&' || op == '^' ||
op == '|' || op == '*' || op == TOK_EQ || op == TOK_NE)) {
vswap();
c2 = c1; //c = c1, c1 = c2, c2 = c;
l2 = l1; //l = l1, l1 = l2, l2 = l;
}
if (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 */
vpop();
} else if (c2 && ((l2 == 0 && (op == '&' || op == '*')) ||
(op == '|' &&
(l2 == -1 || (l2 == 0xFFFFFFFF && t2 != VT_LLONG))) ||
(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 || (l2 == 0xFFFFFFFF && t2 != VT_LLONG))))) {
/* 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 == '-') &&
(r = vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM),
r == (VT_CONST | VT_SYM) || r == VT_LOCAL)) {
/* symbol + constant case */
if (op == '-')
l2 = -l2;
l2 += vtop[-1].c.i;
/* The backends can't always deal with addends to symbols
larger than +-1<<31. Don't construct such. */
if ((int)l2 != l2)
goto general_case;
vtop--;
vtop->c.i = l2;
} else {
general_case:
/* 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);
}
if (vtop->r == VT_CONST)
vtop->r |= VT_NONCONST; /* is const, but only by optimization */
}
}
#if defined TCC_TARGET_X86_64 || defined TCC_TARGET_I386
# define gen_negf gen_opf
#elif defined TCC_TARGET_ARM
void gen_negf(int op)
{
/* arm will detect 0-x and replace by vneg */
vpushi(0), vswap(), gen_op('-');
}
#else
/* XXX: implement in gen_opf() for other backends too */
void gen_negf(int op)
{
/* In IEEE negate(x) isn't subtract(0,x). Without NaNs it's
subtract(-0, x), but with them it's really a sign flip
operation. We implement this with bit manipulation and have
to do some type reinterpretation for this, which TCC can do
only via memory. */
int align, size, bt;
size = type_size(&vtop->type, &align);
bt = vtop->type.t & VT_BTYPE;
save_reg(gv(RC_TYPE(bt)));
vdup();
incr_bf_adr(size - 1);
vdup();
vpushi(0x80); /* flip sign */
gen_op('^');
vstore();
vpop();
}
#endif
/* generate a floating point operation with constant propagation */
static void gen_opif(int op)
{
int c1, c2, i, bt;
SValue *v1, *v2;
#if defined _MSC_VER && defined __x86_64__
/* avoid bad optimization with f1 -= f2 for f1:-0.0, f2:0.0 */
volatile
#endif
long double f1, f2;
v1 = vtop - 1;
v2 = vtop;
if (op == TOK_NEG)
v1 = v2;
bt = v1->type.t & VT_BTYPE;
/* 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 (bt == VT_FLOAT) {
f1 = v1->c.f;
f2 = v2->c.f;
} else if (bt == 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)) && !CONST_WANTED)
goto general_case;
switch(op) {
case '+': f1 += f2; break;
case '-': f1 -= f2; break;
case '*': f1 *= f2; break;
case '/':
if (f2 == 0.0) {
union { float f; unsigned u; } x1, x2, y;
/* If not in initializer we need to potentially generate
FP exceptions at runtime, otherwise we want to fold. */
if (!CONST_WANTED)
goto general_case;
/* the run-time result of 0.0/0.0 on x87, also of other compilers
when used to compile the f1 /= f2 below, would be -nan */
x1.f = f1, x2.f = f2;
if (f1 == 0.0)
y.u = 0x7fc00000; /* nan */
else
y.u = 0x7f800000; /* infinity */
y.u |= (x1.u ^ x2.u) & 0x80000000; /* set sign */
f1 = y.f;
break;
}
f1 /= f2;
break;
case TOK_NEG:
f1 = -f1;
goto unary_result;
case TOK_EQ:
i = f1 == f2;
make_int:
vtop -= 2;
vpushi(i);
return;
case TOK_NE:
i = f1 != f2;
goto make_int;
case TOK_LT:
i = f1 < f2;
goto make_int;
case TOK_GE:
i = f1 >= f2;
goto make_int;
case TOK_LE:
i = f1 <= f2;
goto make_int;
case TOK_GT:
i = f1 > f2;
goto make_int;
default:
goto general_case;
}
vtop--;
unary_result:
/* XXX: overflow test ? */
if (bt == VT_FLOAT) {
v1->c.f = f1;
} else if (bt == VT_DOUBLE) {
v1->c.d = f1;
} else {
v1->c.ld = f1;
}
} else {
general_case:
if (op == TOK_NEG) {
gen_negf(op);
} else {
gen_opf(op);
}
}
}
/* 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;
bt = t & VT_BTYPE;
buf[0] = '\0';
if (t & VT_EXTERN)
pstrcat(buf, buf_size, "extern ");
if (t & VT_STATIC)
pstrcat(buf, buf_size, "static ");
if (t & VT_TYPEDEF)
pstrcat(buf, buf_size, "typedef ");
if (t & VT_INLINE)
pstrcat(buf, buf_size, "inline ");
if (bt != VT_PTR) {
if (t & VT_VOLATILE)
pstrcat(buf, buf_size, "volatile ");
if (t & VT_CONSTANT)
pstrcat(buf, buf_size, "const ");
}
if (((t & VT_DEFSIGN) && bt == VT_BYTE)
|| ((t & VT_UNSIGNED)
&& (bt == VT_SHORT || bt == VT_INT || bt == VT_LLONG)
&& !IS_ENUM(t)
))
pstrcat(buf, buf_size, (t & VT_UNSIGNED) ? "unsigned " : "signed ");
buf_size -= strlen(buf);
buf += strlen(buf);
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 maybe_long;
case VT_LLONG:
tstr = "long long";
maybe_long:
if (t & VT_LONG)
tstr = "long";
if (!IS_ENUM(t))
goto add_tstr;
tstr = "enum ";
goto tstruct;
case VT_FLOAT:
tstr = "float";
goto add_tstr;
case VT_DOUBLE:
tstr = "double";
if (!(t & VT_LONG))
goto add_tstr;
case VT_LDOUBLE:
tstr = "long double";
add_tstr:
pstrcat(buf, buf_size, tstr);
break;
case VT_STRUCT:
tstr = "struct ";
if (IS_UNION(t))
tstr = "union ";
tstruct:
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;
buf1[0]=0;
if (varstr && '*' == *varstr) {
pstrcat(buf1, sizeof(buf1), "(");
pstrcat(buf1, sizeof(buf1), varstr);
pstrcat(buf1, sizeof(buf1), ")");
}
pstrcat(buf1, buf_size, "(");
sa = s->next;
while (sa != NULL) {
char buf2[256];
type_to_str(buf2, sizeof(buf2), &sa->type, NULL);
pstrcat(buf1, sizeof(buf1), buf2);
sa = sa->next;
if (sa)
pstrcat(buf1, sizeof(buf1), ", ");
}
if (s->f.func_type == FUNC_ELLIPSIS)
pstrcat(buf1, sizeof(buf1), ", ...");
pstrcat(buf1, sizeof(buf1), ")");
type_to_str(buf, buf_size, &s->type, buf1);
goto no_var;
case VT_PTR:
s = type->ref;
if (t & (VT_ARRAY|VT_VLA)) {
if (varstr && '*' == *varstr)
snprintf(buf1, sizeof(buf1), "(%s)[%d]", varstr, s->c);
else
snprintf(buf1, sizeof(buf1), "%s[%d]", 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: ;
}
static void type_incompatibility_error(CType* st, CType* dt, const char* fmt)
{
char buf1[256], buf2[256];
type_to_str(buf1, sizeof(buf1), st, NULL);
type_to_str(buf2, sizeof(buf2), dt, NULL);
tcc_error(fmt, buf1, buf2);
}
static void type_incompatibility_warning(CType* st, CType* dt, const char* fmt)
{
char buf1[256], buf2[256];
type_to_str(buf1, sizeof(buf1), st, NULL);
type_to_str(buf2, sizeof(buf2), dt, NULL);
tcc_warning(fmt, buf1, buf2);
}
static int pointed_size(CType *type)
{
int align;
return type_size(pointed_type(type), &align);
}
static inline int is_null_pointer(SValue *p)
{
if ((p->r & (VT_VALMASK | VT_LVAL | VT_SYM | VT_NONCONST)) != 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) &&
((pointed_type(&p->type)->t & VT_BTYPE) == VT_VOID) &&
0 == (pointed_type(&p->type)->t & (VT_CONSTANT | VT_VOLATILE))
);
}
/* 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 (s1->f.func_call != s2->f.func_call)
return 0;
if (s1->f.func_type != s2->f.func_type
&& s1->f.func_type != FUNC_OLD
&& s2->f.func_type != FUNC_OLD)
return 0;
for (;;) {
if (!is_compatible_unqualified_types(&s1->type, &s2->type))
return 0;
if (s1->f.func_type == FUNC_OLD || s2->f.func_type == FUNC_OLD )
return 1;
s1 = s1->next;
s2 = s2->next;
if (!s1)
return !s2;
if (!s2)
return 0;
}
}
/* return true if type1 and type2 are the same. If unqualified is
true, qualifiers on the types are ignored.
*/
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;
if ((t1 & VT_ARRAY)
&& !(type1->ref->c < 0
|| type2->ref->c < 0
|| type1->ref->c == type2->ref->c))
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 if (IS_ENUM(type1->t) && IS_ENUM(type2->t)) {
/* If both are enums then they must be the same, if only one is then
t1 and t2 must be equal, which was checked above already. */
return type1->ref == type2->ref;
} else {
return 1;
}
}
/* Check if OP1 and OP2 can be "combined" with operation OP, the combined
type is stored in DEST if non-null (except for pointer plus/minus) . */
static int combine_types(CType *dest, SValue *op1, SValue *op2, int op)
{
CType *type1 = &op1->type, *type2 = &op2->type, type;
int t1 = type1->t, t2 = type2->t, bt1 = t1 & VT_BTYPE, bt2 = t2 & VT_BTYPE;
int ret = 1;
type.t = VT_VOID;
type.ref = NULL;
if (bt1 == VT_VOID || bt2 == VT_VOID) {
ret = op == '?' ? 1 : 0;
/* NOTE: as an extension, we accept void on only one side */
type.t = VT_VOID;
} else if (bt1 == VT_PTR || bt2 == VT_PTR) {
if (op == '+') ; /* Handled in caller */
/* http://port70.net/~nsz/c/c99/n1256.html#6.5.15p6 */
/* If one is a null ptr constant the result type is the other. */
else if (is_null_pointer (op2)) type = *type1;
else if (is_null_pointer (op1)) type = *type2;
else if (bt1 != bt2) {
/* accept comparison or cond-expr between pointer and integer
with a warning */
if ((op == '?' || TOK_ISCOND(op))
&& (is_integer_btype(bt1) || is_integer_btype(bt2)))
tcc_warning("pointer/integer mismatch in %s",
op == '?' ? "conditional expression" : "comparison");
else if (op != '-' || !is_integer_btype(bt2))
ret = 0;
type = *(bt1 == VT_PTR ? type1 : type2);
} else {
CType *pt1 = pointed_type(type1);
CType *pt2 = pointed_type(type2);
int pbt1 = pt1->t & VT_BTYPE;
int pbt2 = pt2->t & VT_BTYPE;
int newquals, copied = 0;
if (pbt1 != VT_VOID && pbt2 != VT_VOID
&& !compare_types(pt1, pt2, 1/*unqualif*/)) {
if (op != '?' && !TOK_ISCOND(op))
ret = 0;
else
type_incompatibility_warning(type1, type2,
op == '?'
? "pointer type mismatch in conditional expression ('%s' and '%s')"
: "pointer type mismatch in comparison('%s' and '%s')");
}
if (op == '?') {
/* pointers to void get preferred, otherwise the
pointed to types minus qualifs should be compatible */
type = *((pbt1 == VT_VOID) ? type1 : type2);
/* combine qualifs */
newquals = ((pt1->t | pt2->t) & (VT_CONSTANT | VT_VOLATILE));
if ((~pointed_type(&type)->t & (VT_CONSTANT | VT_VOLATILE))
& newquals)
{
/* copy the pointer target symbol */
type.ref = sym_push(SYM_FIELD, &type.ref->type,
0, type.ref->c);
copied = 1;
pointed_type(&type)->t |= newquals;
}
/* pointers to incomplete arrays get converted to
pointers to completed ones if possible */
if (pt1->t & VT_ARRAY
&& pt2->t & VT_ARRAY
&& pointed_type(&type)->ref->c < 0
&& (pt1->ref->c > 0 || pt2->ref->c > 0))
{
if (!copied)
type.ref = sym_push(SYM_FIELD, &type.ref->type,
0, type.ref->c);
pointed_type(&type)->ref =
sym_push(SYM_FIELD, &pointed_type(&type)->ref->type,
0, pointed_type(&type)->ref->c);
pointed_type(&type)->ref->c =
0 < pt1->ref->c ? pt1->ref->c : pt2->ref->c;
}
}
}
if (TOK_ISCOND(op))
type.t = VT_SIZE_T;
} else if (bt1 == VT_STRUCT || bt2 == VT_STRUCT) {
if (op != '?' || !compare_types(type1, type2, 1))
ret = 0;
type = *type1;
} else 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 | VT_LONG;
if (bt1 == VT_LLONG)
type.t &= t1;
if (bt2 == VT_LLONG)
type.t &= t2;
/* convert to unsigned if it does not fit in a long long */
if ((t1 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_LLONG | VT_UNSIGNED) ||
(t2 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_LLONG | VT_UNSIGNED))
type.t |= VT_UNSIGNED;
} else {
/* integer operations */
type.t = VT_INT | (VT_LONG & (t1 | t2));
/* convert to unsigned if it does not fit in an integer */
if ((t1 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_INT | VT_UNSIGNED) ||
(t2 & (VT_BTYPE | VT_UNSIGNED | VT_BITFIELD)) == (VT_INT | VT_UNSIGNED))
type.t |= VT_UNSIGNED;
}
if (dest)
*dest = type;
return ret;
}
/* generic gen_op: handles types problems */
ST_FUNC void gen_op(int op)
{
int t1, t2, bt1, bt2, t;
CType type1, combtype;
redo:
t1 = vtop[-1].type.t;
t2 = vtop[0].type.t;
bt1 = t1 & VT_BTYPE;
bt2 = t2 & VT_BTYPE;
if (bt1 == VT_FUNC || bt2 == VT_FUNC) {
if (bt2 == VT_FUNC) {
mk_pointer(&vtop->type);
gaddrof();
}
if (bt1 == VT_FUNC) {
vswap();
mk_pointer(&vtop->type);
gaddrof();
vswap();
}
goto redo;
} else if (!combine_types(&combtype, vtop - 1, vtop, op)) {
tcc_error("invalid operand types for binary operation");
} else if (bt1 == VT_PTR || bt2 == VT_PTR) {
/* at least one operand is a pointer */
/* relational op: must be both pointers */
int align;
if (TOK_ISCOND(op))
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");
vpush_type_size(pointed_type(&vtop[-1].type), &align);
vtop->type.t &= ~VT_UNSIGNED;
vrott(3);
gen_opic(op);
vtop->type.t = VT_PTRDIFF_T;
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();
t = t1, t1 = t2, t2 = t;
}
#if PTR_SIZE == 4
if ((vtop[0].type.t & VT_BTYPE) == VT_LLONG)
/* XXX: truncate here because gen_opl can't handle ptr + long long */
gen_cast_s(VT_INT);
#endif
type1 = vtop[-1].type;
vpush_type_size(pointed_type(&vtop[-1].type), &align);
gen_op('*');
#ifdef CONFIG_TCC_BCHECK
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);
}
type1.t &= ~(VT_ARRAY|VT_VLA);
/* put again type if gen_opic() swaped operands */
vtop->type = type1;
}
} else {
/* floats can only be used for a few operations */
if (is_float(combtype.t)
&& op != '+' && op != '-' && op != '*' && op != '/'
&& !TOK_ISCOND(op))
tcc_error("invalid operands for binary operation");
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 | VT_BITFIELD)) == (t | VT_UNSIGNED))
t |= VT_UNSIGNED;
t |= (VT_LONG & t1);
combtype.t = t;
}
std_op:
t = t2 = combtype.t;
/* 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();
gen_cast_s(t);
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)
t2 = VT_INT;
gen_cast_s(t2);
if (is_float(t))
gen_opif(op);
else
gen_opic(op);
if (TOK_ISCOND(op)) {
/* relational 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)
gv(is_float(vtop->type.t & VT_BTYPE) ? RC_FLOAT : RC_INT);
}
#if defined TCC_TARGET_ARM64 || defined TCC_TARGET_RISCV64 || defined TCC_TARGET_ARM
#define gen_cvt_itof1 gen_cvt_itof
#else
/* generic itof for unsigned long long case */
static void gen_cvt_itof1(int t)
{
if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) ==
(VT_LLONG | VT_UNSIGNED)) {
if (t == VT_FLOAT)
vpush_helper_func(TOK___floatundisf);
#if LDOUBLE_SIZE != 8
else if (t == VT_LDOUBLE)
vpush_helper_func(TOK___floatundixf);
#endif
else
vpush_helper_func(TOK___floatundidf);
vrott(2);
gfunc_call(1);
vpushi(0);
PUT_R_RET(vtop, t);
} else {
gen_cvt_itof(t);
}
}
#endif
#if defined TCC_TARGET_ARM64 || defined TCC_TARGET_RISCV64
#define gen_cvt_ftoi1 gen_cvt_ftoi
#else
/* generic ftoi for unsigned long long case */
static void gen_cvt_ftoi1(int t)
{
int st;
if (t == (VT_LLONG | VT_UNSIGNED)) {
/* not handled natively */
st = vtop->type.t & VT_BTYPE;
if (st == VT_FLOAT)
vpush_helper_func(TOK___fixunssfdi);
#if LDOUBLE_SIZE != 8
else if (st == VT_LDOUBLE)
vpush_helper_func(TOK___fixunsxfdi);
#endif
else
vpush_helper_func(TOK___fixunsdfdi);
vrott(2);
gfunc_call(1);
vpushi(0);
PUT_R_RET(vtop, t);
} else {
gen_cvt_ftoi(t);
}
}
#endif
/* special delayed cast for char/short */
static void force_charshort_cast(void)
{
int sbt = BFGET(vtop->r, VT_MUSTCAST) == 2 ? VT_LLONG : VT_INT;
int dbt = vtop->type.t;
vtop->r &= ~VT_MUSTCAST;
vtop->type.t = sbt;
gen_cast_s(dbt == VT_BOOL ? VT_BYTE|VT_UNSIGNED : dbt);
vtop->type.t = dbt;
}
static void gen_cast_s(int t)
{
CType type;
type.t = t;
type.ref = NULL;
gen_cast(&type);
}
/* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
static void gen_cast(CType *type)
{
int sbt, dbt, sf, df, c;
int dbt_bt, sbt_bt, ds, ss, bits, trunc;
/* special delayed cast for char/short */
if (vtop->r & VT_MUSTCAST)
force_charshort_cast();
/* bitfields first get cast to ints */
if (vtop->type.t & VT_BITFIELD)
gv(RC_INT);
dbt = type->t & (VT_BTYPE | VT_UNSIGNED);
sbt = vtop->type.t & (VT_BTYPE | VT_UNSIGNED);
if (sbt == VT_FUNC)
sbt = VT_PTR;
again:
if (sbt != dbt) {
sf = is_float(sbt);
df = is_float(dbt);
dbt_bt = dbt & VT_BTYPE;
sbt_bt = sbt & VT_BTYPE;
if (dbt_bt == VT_VOID)
goto done;
if (sbt_bt == VT_VOID) {
error:
cast_error(&vtop->type, type);
}
c = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
#if !defined TCC_IS_NATIVE && !defined TCC_IS_NATIVE_387
/* don't try to convert to ldouble when cross-compiling
(except when it's '0' which is needed for arm:gen_negf()) */
if (dbt_bt == VT_LDOUBLE && !nocode_wanted && (sf || vtop->c.i != 0))
c = 0;
#endif
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_bt == 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_BOOL) {
vtop->c.i = (vtop->c.ld != 0);
} else {
if(sf)
vtop->c.i = vtop->c.ld;
else if (sbt_bt == VT_LLONG || (PTR_SIZE == 8 && sbt == VT_PTR))
;
else if (sbt & VT_UNSIGNED)
vtop->c.i = (uint32_t)vtop->c.i;
else
vtop->c.i = ((uint32_t)vtop->c.i | -(vtop->c.i & 0x80000000));
if (dbt_bt == VT_LLONG || (PTR_SIZE == 8 && dbt == VT_PTR))
;
else if (dbt == VT_BOOL)
vtop->c.i = (vtop->c.i != 0);
else {
uint32_t m = dbt_bt == VT_BYTE ? 0xff :
dbt_bt == VT_SHORT ? 0xffff :
0xffffffff;
vtop->c.i &= m;
if (!(dbt & VT_UNSIGNED))
vtop->c.i |= -(vtop->c.i & ((m >> 1) + 1));
}
}
goto done;
} else if (dbt == VT_BOOL
&& (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM))
== (VT_CONST | VT_SYM)) {
/* addresses are considered non-zero (see tcctest.c:sinit23) */
vtop->r = VT_CONST;
vtop->c.i = 1;
goto done;
}
/* cannot generate code for global or static initializers */
if (nocode_wanted & DATA_ONLY_WANTED)
goto done;
/* non constant case: generate code */
if (dbt == VT_BOOL) {
gen_test_zero(TOK_NE);
goto done;
}
if (sf || df) {
if (sf && df) {
/* convert from fp to fp */
gen_cvt_ftof(dbt);
} else if (df) {
/* convert int to fp */
gen_cvt_itof1(dbt);
} else {
/* convert fp to int */
sbt = dbt;
if (dbt_bt != VT_LLONG && dbt_bt != VT_INT)
sbt = VT_INT;
gen_cvt_ftoi1(sbt);
goto again; /* may need char/short cast */
}
goto done;
}
ds = btype_size(dbt_bt);
ss = btype_size(sbt_bt);
if (ds == 0 || ss == 0)
goto error;
if (IS_ENUM(type->t) && type->ref->c < 0)
tcc_error("cast to incomplete type");
/* same size and no sign conversion needed */
if (ds == ss && ds >= 4)
goto done;
if (dbt_bt == VT_PTR || sbt_bt == VT_PTR) {
tcc_warning("cast between pointer and integer of different size");
if (sbt_bt == VT_PTR) {
/* put integer type to allow logical operations below */
vtop->type.t = (PTR_SIZE == 8 ? VT_LLONG : VT_INT);
}
}
/* processor allows { int a = 0, b = *(char*)&a; }
That means that if we cast to less width, we can just
change the type and read it still later. */
#define ALLOW_SUBTYPE_ACCESS 1
if (ALLOW_SUBTYPE_ACCESS && (vtop->r & VT_LVAL)) {
/* value still in memory */
if (ds <= ss)
goto done;
/* ss <= 4 here */
if (ds <= 4 && !(dbt == (VT_SHORT | VT_UNSIGNED) && sbt == VT_BYTE)) {
gv(RC_INT);
goto done; /* no 64bit envolved */
}
}
gv(RC_INT);
trunc = 0;
#if PTR_SIZE == 4
if (ds == 8) {
/* generate high word */
if (sbt & VT_UNSIGNED) {
vpushi(0);
gv(RC_INT);
} else {
gv_dup();
vpushi(31);
gen_op(TOK_SAR);
}
lbuild(dbt);
} else if (ss == 8) {
/* from long long: just take low order word */
lexpand();
vpop();
}
ss = 4;
#elif PTR_SIZE == 8
if (ds == 8) {
/* need to convert from 32bit to 64bit */
if (sbt & VT_UNSIGNED) {
#if defined(TCC_TARGET_RISCV64)
/* RISC-V keeps 32bit vals in registers sign-extended.
So here we need a zero-extension. */
trunc = 32;
#else
goto done;
#endif
} else {
gen_cvt_sxtw();
goto done;
}
ss = ds, ds = 4, dbt = sbt;
} else if (ss == 8) {
/* RISC-V keeps 32bit vals in registers sign-extended.
So here we need a sign-extension for signed types and
zero-extension. for unsigned types. */
#if !defined(TCC_TARGET_RISCV64)
trunc = 32; /* zero upper 32 bits for non RISC-V targets */
#endif
} else {
ss = 4;
}
#endif
if (ds >= ss)
goto done;
#if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64 || defined TCC_TARGET_ARM64
if (ss == 4) {
gen_cvt_csti(dbt);
goto done;
}
#endif
bits = (ss - ds) * 8;
/* for unsigned, gen_op will convert SAR to SHR */
vtop->type.t = (ss == 8 ? VT_LLONG : VT_INT) | (dbt & VT_UNSIGNED);
vpushi(bits);
gen_op(TOK_SHL);
vpushi(bits - trunc);
gen_op(TOK_SAR);
vpushi(trunc);
gen_op(TOK_SHR);
}
done:
vtop->type = *type;
vtop->type.t &= ~ ( VT_CONSTANT | VT_VOLATILE | VT_ARRAY );
}
/* 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 (IS_ENUM(type->t) && type->ref->c < 0) {
*a = 0;
return -1; /* incomplete enum */
} 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 {
/* 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' */
static void vpush_type_size(CType *type, int *a)
{
if (type->t & VT_VLA) {
type_size(&type->ref->type, a);
vset(&int_type, VT_LOCAL|VT_LVAL, type->ref->c);
} else {
int size = type_size(type, a);
if (size < 0)
tcc_error("unknown type size");
vpushs(size);
}
}
/* 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_STORAGE);
type->ref = s;
}
/* 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_unqualified_types(CType *type1, CType *type2)
{
return compare_types(type1,type2,1);
}
static void cast_error(CType *st, CType *dt)
{
type_incompatibility_error(st, dt, "cannot convert '%s' to '%s'");
}
/* verify type compatibility to store vtop in 'dt' type */
static void verify_assign_cast(CType *dt)
{
CType *st, *type1, *type2;
int dbt, sbt, qualwarn, lvl;
st = &vtop->type; /* source type */
dbt = dt->t & VT_BTYPE;
sbt = st->t & VT_BTYPE;
if (dt->t & VT_CONSTANT)
tcc_warning("assignment of read-only location");
switch(dbt) {
case VT_VOID:
if (sbt != dbt)
tcc_error("assignment to void expression");
break;
case VT_PTR:
/* special cases for pointers */
/* '0' can also be a pointer */
if (is_null_pointer(vtop))
break;
/* accept implicit pointer to integer cast with warning */
if (is_integer_btype(sbt)) {
tcc_warning("assignment makes pointer from integer without a cast");
break;
}
type1 = pointed_type(dt);
if (sbt == VT_PTR)
type2 = pointed_type(st);
else if (sbt == VT_FUNC)
type2 = st; /* a function is implicitly a function pointer */
else
goto error;
if (is_compatible_types(type1, type2))
break;
for (qualwarn = lvl = 0;; ++lvl) {
if (((type2->t & VT_CONSTANT) && !(type1->t & VT_CONSTANT)) ||
((type2->t & VT_VOLATILE) && !(type1->t & VT_VOLATILE)))
qualwarn = 1;
dbt = type1->t & (VT_BTYPE|VT_LONG);
sbt = type2->t & (VT_BTYPE|VT_LONG);
if (dbt != VT_PTR || sbt != VT_PTR)
break;
type1 = pointed_type(type1);
type2 = pointed_type(type2);
}
if (!is_compatible_unqualified_types(type1, type2)) {
if ((dbt == VT_VOID || sbt == VT_VOID) && lvl == 0) {
/* void * can match anything */
} else if (dbt == sbt
&& is_integer_btype(sbt & VT_BTYPE)
&& IS_ENUM(type1->t) + IS_ENUM(type2->t)
+ !!((type1->t ^ type2->t) & VT_UNSIGNED) < 2) {
/* Like GCC don't warn by default for merely changes
in pointer target signedness. Do warn for different
base types, though, in particular for unsigned enums
and signed int targets. */
} else {
tcc_warning("assignment from incompatible pointer type");
break;
}
}
if (qualwarn)
tcc_warning_c(warn_discarded_qualifiers)("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");
} else if (sbt == VT_STRUCT) {
goto case_VT_STRUCT;
}
/* XXX: more tests */
break;
case VT_STRUCT:
case_VT_STRUCT:
if (!is_compatible_unqualified_types(dt, st)) {
error:
cast_error(st, dt);
}
break;
}
}
static void gen_assign_cast(CType *dt)
{
verify_assign_cast(dt);
gen_cast(dt);
}
/* store vtop in lvalue pushed on stack */
ST_FUNC void vstore(void)
{
int sbt, dbt, ft, r, size, align, bit_size, bit_pos, delayed_cast;
ft = vtop[-1].type.t;
sbt = vtop->type.t & VT_BTYPE;
dbt = ft & VT_BTYPE;
verify_assign_cast(&vtop[-1].type);
if (sbt == VT_STRUCT) {
/* if structure, only generate pointer */
/* structure assignment : generate memcpy */
size = type_size(&vtop->type, &align);
/* destination, keep on stack() as result */
vpushv(vtop - 1);
#ifdef CONFIG_TCC_BCHECK
if (vtop->r & VT_MUSTBOUND)
gbound(); /* check would be wrong after gaddrof() */
#endif
vtop->type.t = VT_PTR;
gaddrof();
/* source */
vswap();
#ifdef CONFIG_TCC_BCHECK
if (vtop->r & VT_MUSTBOUND)
gbound();
#endif
vtop->type.t = VT_PTR;
gaddrof();
#ifdef TCC_TARGET_NATIVE_STRUCT_COPY
if (1
#ifdef CONFIG_TCC_BCHECK
&& !tcc_state->do_bounds_check
#endif
) {
gen_struct_copy(size);
} else
#endif
{
/* type size */
vpushi(size);
/* Use memmove, rather than memcpy, as dest and src may be same: */
#ifdef TCC_ARM_EABI
if(!(align & 7))
vpush_helper_func(TOK_memmove8);
else if(!(align & 3))
vpush_helper_func(TOK_memmove4);
else
#endif
vpush_helper_func(TOK_memmove);
vrott(4);
gfunc_call(3);
}
} 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 = BIT_POS(ft);
bit_size = BIT_SIZE(ft);
/* remove bit field info to avoid loops */
vtop[-1].type.t = ft & ~VT_STRUCT_MASK;
if (dbt == VT_BOOL) {
gen_cast(&vtop[-1].type);
vtop[-1].type.t = (vtop[-1].type.t & ~VT_BTYPE) | (VT_BYTE | VT_UNSIGNED);
}
r = adjust_bf(vtop - 1, bit_pos, bit_size);
if (dbt != VT_BOOL) {
gen_cast(&vtop[-1].type);
dbt = vtop[-1].type.t & VT_BTYPE;
}
if (r == VT_STRUCT) {
store_packed_bf(bit_pos, bit_size);
} else {
unsigned long long mask = (1ULL << bit_size) - 1;
if (dbt != VT_BOOL) {
/* mask source */
if (dbt == VT_LLONG)
vpushll(mask);
else
vpushi((unsigned)mask);
gen_op('&');
}
/* shift source */
vpushi(bit_pos);
gen_op(TOK_SHL);
vswap();
/* duplicate destination */
vdup();
vrott(3);
/* load destination, mask and or with source */
if (dbt == VT_LLONG)
vpushll(~(mask << bit_pos));
else
vpushi(~((unsigned)mask << bit_pos));
gen_op('&');
gen_op('|');
/* store result */
vstore();
/* ... and discard */
vpop();
}
} else if (dbt == VT_VOID) {
--vtop;
} else {
/* optimize char/short casts */
delayed_cast = 0;
if ((dbt == VT_BYTE || dbt == VT_SHORT)
&& is_integer_btype(sbt)
) {
if ((vtop->r & VT_MUSTCAST)
&& btype_size(dbt) > btype_size(sbt)
)
force_charshort_cast();
delayed_cast = 1;
} else {
gen_cast(&vtop[-1].type);
}
#ifdef CONFIG_TCC_BCHECK
/* bound check case */
if (vtop[-1].r & VT_MUSTBOUND) {
vswap();
gbound();
vswap();
}
#endif
gv(RC_TYPE(dbt)); /* generate value */
if (delayed_cast) {
vtop->r |= BFVAL(VT_MUSTCAST, (sbt == VT_LLONG) + 1);
//tcc_warning("deley cast %x -> %x", sbt, dbt);
vtop->type.t = ft & VT_TYPE;
}
/* if lvalue was saved on stack, must read it */
if ((vtop[-1].r & VT_VALMASK) == VT_LLOCAL) {
SValue sv;
r = get_reg(RC_INT);
sv.type.t = VT_PTRDIFF_T;
sv.r = VT_LOCAL | VT_LVAL;
sv.c.i = vtop[-1].c.i;
load(r, &sv);
vtop[-1].r = r | VT_LVAL;
}
r = vtop->r & VT_VALMASK;
/* two word case handling :
store second register at word + 4 (or +8 for x86-64) */
if (USING_TWO_WORDS(dbt)) {
int load_type = (dbt == VT_QFLOAT) ? VT_DOUBLE : VT_PTRDIFF_T;
vtop[-1].type.t = load_type;
store(r, vtop - 1);
vswap();
incr_offset(PTR_SIZE);
vswap();
/* XXX: it works because r2 is spilled last ! */
store(vtop->r2, vtop - 1);
} else {
/* single word */
store(r, vtop - 1);
}
vswap();
vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
}
}
/* 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) {
gv_dup(); /* 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 */
}
ST_FUNC CString* parse_mult_str (const char *msg)
{
/* read the string */
if (tok != TOK_STR)
expect(msg);
cstr_reset(&initstr);
while (tok == TOK_STR) {
/* XXX: add \0 handling too ? */
cstr_cat(&initstr, tokc.str.data, -1);
next();
}
cstr_ccat(&initstr, '\0');
return &initstr;
}
/* If I is >= 1 and a power of two, returns log2(i)+1.
If I is 0 returns 0. */
ST_FUNC int exact_log2p1(int i)
{
int ret;
if (!i)
return 0;
for (ret = 1; i >= 1 << 8; ret += 8)
i >>= 8;
if (i >= 1 << 4)
ret += 4, i >>= 4;
if (i >= 1 << 2)
ret += 2, i >>= 2;
if (i >= 1 << 1)
ret++;
return ret;
}
/* Parse __attribute__((...)) GNUC extension. */
static void parse_attribute(AttributeDef *ad)
{
int t, n;
char *astr;
redo:
if (tok != TOK_ATTRIBUTE1 && tok != TOK_ATTRIBUTE2)
return;
next();
skip('(');
skip('(');
while (tok != ')') {
if (tok < TOK_IDENT)
expect("attribute name");
t = tok;
next();
switch(t) {
case TOK_CLEANUP1:
case TOK_CLEANUP2:
{
Sym *s;
skip('(');
s = sym_find(tok);
if (!s) {
tcc_warning_c(warn_implicit_function_declaration)(
"implicit declaration of function '%s'", get_tok_str(tok, &tokc));
s = external_global_sym(tok, &func_old_type);
} else if ((s->type.t & VT_BTYPE) != VT_FUNC)
tcc_error("'%s' is not declared as function", get_tok_str(tok, &tokc));
ad->cleanup_func = s;
next();
skip(')');
break;
}
case TOK_CONSTRUCTOR1:
case TOK_CONSTRUCTOR2:
ad->f.func_ctor = 1;
break;
case TOK_DESTRUCTOR1:
case TOK_DESTRUCTOR2:
ad->f.func_dtor = 1;
break;
case TOK_ALWAYS_INLINE1:
case TOK_ALWAYS_INLINE2:
ad->f.func_alwinl = 1;
break;
case TOK_SECTION1:
case TOK_SECTION2:
skip('(');
astr = parse_mult_str("section name")->data;
ad->section = find_section(tcc_state, astr);
skip(')');
break;
case TOK_ALIAS1:
case TOK_ALIAS2:
skip('(');
astr = parse_mult_str("alias(\"target\")")->data;
/* save string as token, for later */
ad->alias_target = tok_alloc_const(astr);
skip(')');
break;
case TOK_VISIBILITY1:
case TOK_VISIBILITY2:
skip('(');
astr = parse_mult_str("visibility(\"default|hidden|internal|protected\")")->data;
if (!strcmp (astr, "default"))
ad->a.visibility = STV_DEFAULT;
else if (!strcmp (astr, "hidden"))
ad->a.visibility = STV_HIDDEN;
else if (!strcmp (astr, "internal"))
ad->a.visibility = STV_INTERNAL;
else if (!strcmp (astr, "protected"))
ad->a.visibility = STV_PROTECTED;
else
expect("visibility(\"default|hidden|internal|protected\")");
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 = exact_log2p1(n);
if (n != 1 << (ad->a.aligned - 1))
tcc_error("alignment of %d is larger than implemented", 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_NODEBUG1:
case TOK_NODEBUG2:
ad->a.nodebug = 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:
ad->f.func_noreturn = 1;
break;
case TOK_CDECL1:
case TOK_CDECL2:
case TOK_CDECL3:
ad->f.func_call = FUNC_CDECL;
break;
case TOK_STDCALL1:
case TOK_STDCALL2:
case TOK_STDCALL3:
ad->f.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->f.func_call = FUNC_FASTCALL1 + n - 1;
skip(')');
break;
case TOK_FASTCALL1:
case TOK_FASTCALL2:
case TOK_FASTCALL3:
ad->f.func_call = FUNC_FASTCALLW;
break;
#endif
case TOK_MODE:
skip('(');
switch(tok) {
case TOK_MODE_DI:
ad->attr_mode = VT_LLONG + 1;
break;
case TOK_MODE_QI:
ad->attr_mode = VT_BYTE + 1;
break;
case TOK_MODE_HI:
ad->attr_mode = VT_SHORT + 1;
break;
case TOK_MODE_SI:
case TOK_MODE_word:
ad->attr_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.dllexport = 1;
break;
case TOK_NODECORATE:
ad->a.nodecorate = 1;
break;
case TOK_DLLIMPORT:
ad->a.dllimport = 1;
break;
default:
tcc_warning_c(warn_unsupported)("'%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(')');
goto redo;
}
static Sym * find_field (CType *type, int v, int *cumofs)
{
Sym *s = type->ref;
int v1 = v | SYM_FIELD;
if (!(v & SYM_FIELD)) { /* top-level call */
if ((type->t & VT_BTYPE) != VT_STRUCT)
expect("struct or union");
if (v < TOK_UIDENT)
expect("field name");
if (s->c < 0)
tcc_error("dereferencing incomplete type '%s'",
get_tok_str(s->v & ~SYM_STRUCT, 0));
}
while ((s = s->next) != NULL) {
if (s->v == v1) {
*cumofs = s->c;
return s;
}
if ((s->type.t & VT_BTYPE) == VT_STRUCT
&& s->v >= (SYM_FIRST_ANOM | SYM_FIELD)) {
/* try to find field in anonymous sub-struct/union */
Sym *ret = find_field (&s->type, v1, cumofs);
if (ret) {
*cumofs += s->c;
return ret;
}
}
}
if (!(v & SYM_FIELD))
tcc_error("field not found: %s", get_tok_str(v, NULL));
return s;
}
static void check_fields (CType *type, int check)
{
Sym *s = type->ref;
while ((s = s->next) != NULL) {
int v = s->v & ~SYM_FIELD;
if (v < SYM_FIRST_ANOM) {
TokenSym *ts = table_ident[v - TOK_IDENT];
if (check && (ts->tok & SYM_FIELD))
tcc_error("duplicate member '%s'", get_tok_str(v, NULL));
ts->tok ^= SYM_FIELD;
} else if ((s->type.t & VT_BTYPE) == VT_STRUCT)
check_fields (&s->type, check);
}
}
static void struct_layout(CType *type, AttributeDef *ad)
{
int size, align, maxalign, offset, c, bit_pos, bit_size;
int packed, a, bt, prevbt, prev_bit_size;
int pcc = !tcc_state->ms_bitfields;
int pragma_pack = *tcc_state->pack_stack_ptr;
Sym *f;
maxalign = 1;
offset = 0;
c = 0;
bit_pos = 0;
prevbt = VT_STRUCT; /* make it never match */
prev_bit_size = 0;
//#define BF_DEBUG
for (f = type->ref->next; f; f = f->next) {
if (f->type.t & VT_BITFIELD)
bit_size = BIT_SIZE(f->type.t);
else
bit_size = -1;
size = type_size(&f->type, &align);
a = f->a.aligned ? 1 << (f->a.aligned - 1) : 0;
packed = 0;
if (pcc && bit_size == 0) {
/* in pcc mode, packing does not affect zero-width bitfields */
} else {
/* in pcc mode, attribute packed overrides if set. */
if (pcc && (f->a.packed || ad->a.packed))
align = packed = 1;
/* pragma pack overrides align if lesser and packs bitfields always */
if (pragma_pack) {
packed = 1;
if (pragma_pack < align)
align = pragma_pack;
/* in pcc mode pragma pack also overrides individual align */
if (pcc && pragma_pack < a)
a = 0;
}
}
/* some individual align was specified */
if (a)
align = a;
if (type->ref->type.t == VT_UNION) {
if (pcc && bit_size >= 0)
size = (bit_size + 7) >> 3;
offset = 0;
if (size > c)
c = size;
} else if (bit_size < 0) {
if (pcc)
c += (bit_pos + 7) >> 3;
c = (c + align - 1) & -align;
offset = c;
if (size > 0)
c += size;
bit_pos = 0;
prevbt = VT_STRUCT;
prev_bit_size = 0;
} else {
/* A bit-field. Layout is more complicated. There are two
options: PCC (GCC) compatible and MS compatible */
if (pcc) {
/* In PCC layout a bit-field is placed adjacent to the
preceding bit-fields, except if:
- it has zero-width
- an individual alignment was given
- it would overflow its base type container and
there is no packing */
if (bit_size == 0) {
new_field:
c = (c + ((bit_pos + 7) >> 3) + align - 1) & -align;
bit_pos = 0;
} else if (f->a.aligned) {
goto new_field;
} else if (!packed) {
int a8 = align * 8;
int ofs = ((c * 8 + bit_pos) % a8 + bit_size + a8 - 1) / a8;
if (ofs > size / align)
goto new_field;
}
/* in pcc mode, long long bitfields have type int if they fit */
if (size == 8 && bit_size <= 32)
f->type.t = (f->type.t & ~VT_BTYPE) | VT_INT, size = 4;
while (bit_pos >= align * 8)
c += align, bit_pos -= align * 8;
offset = c;
/* In PCC layout named bit-fields influence the alignment
of the containing struct using the base types alignment,
except for packed fields (which here have correct align). */
if (f->v & SYM_FIRST_ANOM
// && bit_size // ??? gcc on ARM/rpi does that
)
align = 1;
} else {
bt = f->type.t & VT_BTYPE;
if ((bit_pos + bit_size > size * 8)
|| (bit_size > 0) == (bt != prevbt)
) {
c = (c + align - 1) & -align;
offset = c;
bit_pos = 0;
/* In MS bitfield mode a bit-field run always uses
at least as many bits as the underlying type.
To start a new run it's also required that this
or the last bit-field had non-zero width. */
if (bit_size || prev_bit_size)
c += size;
}
/* In MS layout the records alignment is normally
influenced by the field, except for a zero-width
field at the start of a run (but by further zero-width
fields it is again). */
if (bit_size == 0 && prevbt != bt)
align = 1;
prevbt = bt;
prev_bit_size = bit_size;
}
f->type.t = (f->type.t & ~(0x3f << VT_STRUCT_SHIFT))
| (bit_pos << VT_STRUCT_SHIFT);
bit_pos += bit_size;
}
if (align > maxalign)
maxalign = align;
#ifdef BF_DEBUG
printf("set field %s offset %-2d size %-2d align %-2d",
get_tok_str(f->v & ~SYM_FIELD, NULL), offset, size, align);
if (f->type.t & VT_BITFIELD) {
printf(" pos %-2d bits %-2d",
BIT_POS(f->type.t),
BIT_SIZE(f->type.t)
);
}
printf("\n");
#endif
f->c = offset;
f->r = 0;
}
if (pcc)
c += (bit_pos + 7) >> 3;
/* store size and alignment */
a = bt = ad->a.aligned ? 1 << (ad->a.aligned - 1) : 1;
if (a < maxalign)
a = maxalign;
type->ref->r = a;
if (pragma_pack && pragma_pack < maxalign && 0 == pcc) {
/* can happen if individual align for some member was given. In
this case MSVC ignores maxalign when aligning the size */
a = pragma_pack;
if (a < bt)
a = bt;
}
c = (c + a - 1) & -a;
type->ref->c = c;
#ifdef BF_DEBUG
printf("struct size %-2d align %-2d\n\n", c, a), fflush(stdout);
#endif
/* check whether we can access bitfields by their type */
for (f = type->ref->next; f; f = f->next) {
int s, px, cx, c0;
CType t;
if (0 == (f->type.t & VT_BITFIELD))
continue;
f->type.ref = f;
f->auxtype = -1;
bit_size = BIT_SIZE(f->type.t);
if (bit_size == 0)
continue;
bit_pos = BIT_POS(f->type.t);
size = type_size(&f->type, &align);
if (bit_pos + bit_size <= size * 8 && f->c + size <= c
#ifdef TCC_TARGET_ARM
&& !(f->c & (align - 1))
#endif
)
continue;
/* try to access the field using a different type */
c0 = -1, s = align = 1;
t.t = VT_BYTE;
for (;;) {
px = f->c * 8 + bit_pos;
cx = (px >> 3) & -align;
px = px - (cx << 3);
if (c0 == cx)
break;
s = (px + bit_size + 7) >> 3;
if (s > 4) {
t.t = VT_LLONG;
} else if (s > 2) {
t.t = VT_INT;
} else if (s > 1) {
t.t = VT_SHORT;
} else {
t.t = VT_BYTE;
}
s = type_size(&t, &align);
c0 = cx;
}
if (px + bit_size <= s * 8 && cx + s <= c
#ifdef TCC_TARGET_ARM
&& !(cx & (align - 1))
#endif
) {
/* update offset and bit position */
f->c = cx;
bit_pos = px;
f->type.t = (f->type.t & ~(0x3f << VT_STRUCT_SHIFT))
| (bit_pos << VT_STRUCT_SHIFT);
if (s != size)
f->auxtype = t.t;
#ifdef BF_DEBUG
printf("FIX field %s offset %-2d size %-2d align %-2d "
"pos %-2d bits %-2d\n",
get_tok_str(f->v & ~SYM_FIELD, NULL),
cx, s, align, px, bit_size);
#endif
} else {
/* fall back to load/store single-byte wise */
f->auxtype = VT_STRUCT;
#ifdef BF_DEBUG
printf("FIX field %s : load byte-wise\n",
get_tok_str(f->v & ~SYM_FIELD, NULL));
#endif
}
}
}
static void do_Static_assert(void);
/* enum/struct/union declaration. u is VT_ENUM/VT_STRUCT/VT_UNION */
static void struct_decl(CType *type, int u)
{
int v, c, size, align, flexible;
int bit_size, bsize, bt;
Sym *s, *ss, **ps;
AttributeDef ad, ad1;
CType type1, btype;
memset(&ad, 0, sizeof ad);
next();
parse_attribute(&ad);
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 && (s->sym_scope == local_scope || tok != '{')) {
if (u == s->type.t)
goto do_decl;
if (u == VT_ENUM && IS_ENUM(s->type.t))
goto do_decl;
tcc_error("redefinition of '%s'", get_tok_str(v, NULL));
}
} else {
v = anon_sym++;
}
/* Record the original enum/struct/union token. */
type1.t = u == VT_ENUM ? u | VT_INT | VT_UNSIGNED : u;
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 */
do_decl:
type->t = s->type.t;
type->ref = s;
if (tok == '{') {
next();
if (s->c != -1)
tcc_error("struct/union/enum already defined");
s->c = -2;
/* cannot be empty */
/* non empty enums are not allowed */
ps = &s->next;
if (u == VT_ENUM) {
long long ll = 0, pl = 0, nl = 0;
CType t;
t.ref = s;
/* enum symbols have static storage */
t.t = VT_INT|VT_STATIC|VT_ENUM_VAL;
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();
ll = expr_const64();
}
ss = sym_push(v, &t, VT_CONST, 0);
ss->enum_val = ll;
*ps = ss, ps = &ss->next;
if (ll < nl)
nl = ll;
if (ll > pl)
pl = ll;
if (tok != ',')
break;
next();
ll++;
/* NOTE: we accept a trailing comma */
if (tok == '}')
break;
}
skip('}');
/* set integral type of the enum */
t.t = VT_INT;
if (nl >= 0) {
if (pl != (unsigned)pl)
t.t = (LONG_SIZE==8 ? VT_LLONG|VT_LONG : VT_LLONG);
t.t |= VT_UNSIGNED;
} else if (pl != (int)pl || nl != (int)nl)
t.t = (LONG_SIZE==8 ? VT_LLONG|VT_LONG : VT_LLONG);
s->type.t = type->t = t.t | VT_ENUM;
s->c = 0;
/* set type for enum members */
for (ss = s->next; ss; ss = ss->next) {
ll = ss->enum_val;
if (ll == (int)ll) /* default is int if it fits */
continue;
if (t.t & VT_UNSIGNED) {
ss->type.t |= VT_UNSIGNED;
if (ll == (unsigned)ll)
continue;
}
ss->type.t = (ss->type.t & ~VT_BTYPE)
| (LONG_SIZE==8 ? VT_LLONG|VT_LONG : VT_LLONG);
}
} else {
c = 0;
flexible = 0;
while (tok != '}') {
if (!parse_btype(&btype, &ad1, 0)) {
if (tok == TOK_STATIC_ASSERT) {
do_Static_assert();
continue;
}
skip(';');
continue;
}
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 != ':') {
if (tok != ';')
type_decl(&type1, &ad1, &v, TYPE_DIRECT);
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 ((u == VT_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_BTYPE) == VT_VOID ||
(type1.t & VT_STORAGE))
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));
parse_attribute(&ad1);
}
size = type_size(&type1, &align);
if (bit_size >= 0) {
bt = type1.t & VT_BTYPE;
if (bt != VT_INT &&
bt != VT_BYTE &&
bt != VT_SHORT &&
bt != VT_BOOL &&
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
&& !ad.a.packed && !ad1.a.packed) {
/* no need for bit fields */
;
} else if (bit_size == 64) {
tcc_error("field width 64 not implemented");
} else {
type1.t = (type1.t & ~VT_STRUCT_MASK)
| VT_BITFIELD
| (bit_size << (VT_STRUCT_SHIFT + 6));
}
}
if (v != 0 || (type1.t & VT_BTYPE) == VT_STRUCT) {
/* Remember we've seen a real field to check
for placement of flexible array member. */
c = 1;
}
/* If member is a struct or bit-field, enforce
placing into the struct (as anonymous). */
if (v == 0 &&
((type1.t & VT_BTYPE) == VT_STRUCT ||
bit_size >= 0)) {
v = anon_sym++;
}
if (v) {
ss = sym_push(v | SYM_FIELD, &type1, 0, 0);
ss->a = ad1.a;
*ps = ss;
ps = &ss->next;
}
if (tok == ';' || tok == TOK_EOF)
break;
skip(',');
}
skip(';');
}
skip('}');
parse_attribute(&ad);
if (ad.cleanup_func) {
tcc_warning("attribute '__cleanup__' ignored on type");
}
check_fields(type, 1);
check_fields(type, 0);
struct_layout(type, &ad);
if (debug_modes)
tcc_debug_fix_anon(tcc_state, type);
}
}
}
static void sym_to_attr(AttributeDef *ad, Sym *s)
{
merge_symattr(&ad->a, &s->a);
merge_funcattr(&ad->f, &s->f);
}
/* 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 ignore_label)
{
int t, u, bt, st, type_found, typespec_found, g, n;
Sym *s;
CType type1;
memset(ad, 0, sizeof(AttributeDef));
type_found = 0;
typespec_found = 0;
t = VT_INT;
bt = st = -1;
type->ref = NULL;
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 (u == VT_SHORT || u == VT_LONG) {
if (st != -1 || (bt != -1 && bt != VT_INT))
tmbt: tcc_error("too many basic types");
st = u;
} else {
if (bt != -1 || (st != -1 && u != VT_INT))
goto tmbt;
bt = u;
}
if (u != VT_INT)
t = (t & ~(VT_BTYPE|VT_LONG)) | u;
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_ALIGNAS:
{ int n;
AttributeDef ad1;
next();
skip('(');
memset(&ad1, 0, sizeof(AttributeDef));
if (parse_btype(&type1, &ad1, 0)) {
type_decl(&type1, &ad1, &n, TYPE_ABSTRACT);
if (ad1.a.aligned)
n = 1 << (ad1.a.aligned - 1);
else
type_size(&type1, &n);
} else {
n = expr_const();
if (n < 0 || (n & (n - 1)) != 0)
tcc_error("alignment must be a positive power of two");
}
skip(')');
ad->a.aligned = exact_log2p1(n);
}
continue;
case TOK_LONG:
if ((t & VT_BTYPE) == VT_DOUBLE) {
t = (t & ~(VT_BTYPE|VT_LONG)) | VT_LDOUBLE;
} else if ((t & (VT_BTYPE|VT_LONG)) == VT_LONG) {
t = (t & ~(VT_BTYPE|VT_LONG)) | VT_LLONG;
} else {
u = VT_LONG;
goto basic_type;
}
next();
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_COMPLEX:
tcc_error("_Complex is not yet supported");
case TOK_FLOAT:
u = VT_FLOAT;
goto basic_type;
case TOK_DOUBLE:
if ((t & (VT_BTYPE|VT_LONG)) == VT_LONG) {
t = (t & ~(VT_BTYPE|VT_LONG)) | VT_LDOUBLE;
} else {
u = VT_DOUBLE;
goto basic_type;
}
next();
break;
case TOK_ENUM:
struct_decl(&type1, VT_ENUM);
basic_type2:
u = type1.t;
type->ref = type1.ref;
goto basic_type1;
case TOK_STRUCT:
struct_decl(&type1, VT_STRUCT);
goto basic_type2;
case TOK_UNION:
struct_decl(&type1, VT_UNION);
goto basic_type2;
/* type modifiers */
case TOK__Atomic:
next();
type->t = t;
parse_btype_qualify(type, VT_ATOMIC);
t = type->t;
if (tok == '(') {
parse_expr_type(&type1);
/* remove all storage modifiers except typedef */
type1.t &= ~(VT_STORAGE&~VT_TYPEDEF);
if (type1.ref)
sym_to_attr(ad, type1.ref);
goto basic_type2;
}
break;
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");
t |= VT_DEFSIGN;
next();
typespec_found = 1;
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:
g = VT_EXTERN;
goto storage;
case TOK_STATIC:
g = VT_STATIC;
goto storage;
case TOK_TYPEDEF:
g = VT_TYPEDEF;
goto storage;
storage:
if (t & (VT_EXTERN|VT_STATIC|VT_TYPEDEF) & ~g)
tcc_error("multiple storage classes");
t |= g;
next();
break;
case TOK_INLINE1:
case TOK_INLINE2:
case TOK_INLINE3:
t |= VT_INLINE;
next();
break;
case TOK_NORETURN3:
next();
ad->f.func_noreturn = 1;
break;
/* GNUC attribute */
case TOK_ATTRIBUTE1:
case TOK_ATTRIBUTE2:
parse_attribute(ad);
if (ad->attr_mode) {
u = ad->attr_mode -1;
t = (t & ~(VT_BTYPE|VT_LONG)) | u;
}
continue;
/* 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);
if (type1.ref)
sym_to_attr(ad, type1.ref);
goto basic_type2;
case TOK_THREAD_LOCAL:
tcc_error("_Thread_local is not implemented");
default:
if (typespec_found)
goto the_end;
s = sym_find(tok);
if (!s || !(s->type.t & VT_TYPEDEF))
goto the_end;
n = tok, next();
if (tok == ':' && ignore_label) {
/* ignore if it's a label */
unget_tok(n);
goto the_end;
}
t &= ~(VT_BTYPE|VT_LONG);
u = t & ~(VT_CONSTANT | VT_VOLATILE), t ^= u;
type->t = (s->type.t & ~VT_TYPEDEF) | u;
type->ref = s->type.ref;
if (t)
parse_btype_qualify(type, t);
t = type->t;
/* get attributes from typedef */
sym_to_attr(ad, s);
typespec_found = 1;
st = bt = -2;
break;
}
type_found = 1;
}
the_end:
if (tcc_state->char_is_unsigned) {
if ((t & (VT_DEFSIGN|VT_BTYPE)) == VT_BYTE)
t |= VT_UNSIGNED;
}
/* VT_LONG is used just as a modifier for VT_INT / VT_LLONG */
bt = t & (VT_BTYPE|VT_LONG);
if (bt == VT_LONG)
t |= LONG_SIZE == 8 ? VT_LLONG : VT_INT;
#ifdef TCC_USING_DOUBLE_FOR_LDOUBLE
if (bt == VT_LDOUBLE)
t = (t & ~(VT_BTYPE|VT_LONG)) | (VT_DOUBLE|VT_LONG);
#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 | VT_VLA);
if ((pt->t & VT_BTYPE) == VT_FUNC) {
mk_pointer(pt);
}
}
ST_FUNC CString* parse_asm_str(void)
{
skip('(');
return parse_mult_str("string constant");
}
/* Parse an asm label and return the token */
static int asm_label_instr(void)
{
int v;
char *astr;
next();
astr = parse_asm_str()->data;
skip(')');
#ifdef ASM_DEBUG
printf("asm_alias: \"%s\"\n", astr);
#endif
v = tok_alloc_const(astr);
return v;
}
static int post_type(CType *type, AttributeDef *ad, int storage, int td)
{
int n, l, t1, arg_size, align;
Sym **plast, *s, *first;
AttributeDef ad1;
CType pt;
TokenString *vla_array_tok = NULL;
int *vla_array_str = NULL;
if (tok == '(') {
/* function type, or recursive declarator (return if so) */
next();
if (TYPE_DIRECT == (td & (TYPE_DIRECT|TYPE_ABSTRACT)))
return 0;
if (tok == ')')
l = 0;
else if (parse_btype(&pt, &ad1, 0))
l = FUNC_NEW;
else if (td & (TYPE_DIRECT|TYPE_ABSTRACT)) {
merge_attr (ad, &ad1);
return 0;
} else
l = FUNC_OLD;
first = NULL;
plast = &first;
arg_size = 0;
++local_scope;
if (l) {
for(;;) {
/* read param name and compute offset */
if (l != FUNC_OLD) {
if ((pt.t & VT_BTYPE) == VT_VOID && tok == ')')
break;
type_decl(&pt, &ad1, &n, TYPE_DIRECT | TYPE_ABSTRACT | TYPE_PARAM);
if ((pt.t & VT_BTYPE) == VT_VOID)
tcc_error("parameter declared as void");
if (n == 0)
n = SYM_FIELD;
} else {
n = tok;
pt.t = VT_VOID; /* invalid type */
pt.ref = NULL;
next();
}
if (n < TOK_UIDENT)
expect("identifier");
convert_parameter_type(&pt);
arg_size += (type_size(&pt, &align) + PTR_SIZE - 1) / PTR_SIZE;
/* these symbols may be evaluated for VLArrays (see below, under
nocode_wanted) which is why we push them here as normal symbols
temporarily. Example: int func(int a, int b[++a]); */
s = sym_push(n, &pt, VT_LOCAL|VT_LVAL, 0);
*plast = s;
plast = &s->next;
if (tok == ')')
break;
skip(',');
if (l == FUNC_NEW && tok == TOK_DOTS) {
l = FUNC_ELLIPSIS;
next();
break;
}
if (l == FUNC_NEW && !parse_btype(&pt, &ad1, 0))
tcc_error("invalid type");
}
} else
/* if no parameters, then old type prototype */
l = FUNC_OLD;
skip(')');
/* remove parameter symbols from token table, keep on stack */
if (first) {
sym_pop(local_stack ? &local_stack : &global_stack, first->prev, 1);
for (s = first; s; s = s->next)
s->v |= SYM_FIELD;
}
--local_scope;
/* 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 "[]" */
mk_pointer(type);
}
/* we push a anonymous symbol which will contain the function prototype */
ad->f.func_args = arg_size;
ad->f.func_type = l;
s = sym_push(SYM_FIELD, type, 0, 0);
s->a = ad->a;
s->f = ad->f;
s->next = first;
type->t = VT_FUNC;
type->ref = s;
} else if (tok == '[') {
int saved_nocode_wanted = nocode_wanted;
/* array definition */
next();
n = -1;
t1 = 0;
if (td & TYPE_PARAM) while (1) {
/* XXX The optional type-quals and static should only be accepted
in parameter decls. The '*' as well, and then even only
in prototypes (not function defs). */
switch (tok) {
case TOK_RESTRICT1: case TOK_RESTRICT2: case TOK_RESTRICT3:
case TOK_CONST1:
case TOK_VOLATILE1:
case TOK_STATIC:
case '*':
next();
continue;
default:
break;
}
if (tok != ']') {
/* Code generation is not done now but has to be done
at start of function. Save code here for later use. */
nocode_wanted = 1;
skip_or_save_block(&vla_array_tok);
unget_tok(0);
vla_array_str = vla_array_tok->str;
begin_macro(vla_array_tok, 2);
next();
gexpr();
end_macro();
next();
goto check;
}
break;
} else if (tok != ']') {
if (!local_stack || (storage & VT_STATIC))
vpushi(expr_const());
else {
/* VLAs (which can only happen with local_stack && !VT_STATIC)
length must always be evaluated, even under nocode_wanted,
so that its size slot is initialized (e.g. under sizeof
or typeof). */
nocode_wanted = 0;
gexpr();
}
check:
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");
n = 0;
t1 = VT_VLA;
}
}
skip(']');
/* parse next post type */
post_type(type, ad, storage, (td & ~(TYPE_DIRECT|TYPE_ABSTRACT)) | TYPE_NEST);
if ((type->t & VT_BTYPE) == VT_FUNC)
tcc_error("declaration of an array of functions");
if ((type->t & VT_BTYPE) == VT_VOID
|| type_size(type, &align) < 0)
tcc_error("declaration of an array of incomplete type elements");
t1 |= type->t & VT_VLA;
if (t1 & VT_VLA) {
if (n < 0) {
if (td & TYPE_NEST)
tcc_error("need explicit inner array size in VLAs");
}
else {
loc -= type_size(&int_type, &align);
loc &= -align;
n = loc;
vpush_type_size(type, &align);
gen_op('*');
vset(&int_type, VT_LOCAL|VT_LVAL, n);
vswap();
vstore();
}
}
if (n != -1)
vpop();
nocode_wanted = saved_nocode_wanted;
/* 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;
if (vla_array_str) {
/* for function args, the top dimension is converted to pointer */
if ((t1 & VT_VLA) && (td & TYPE_NEST))
s->vla_array_str = vla_array_str;
else
tok_str_free_str(vla_array_str);
}
}
return 1;
}
/* Parse a type declarator (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(). If this (possibly abstract) declarator is a pointer chain
it returns the innermost pointed to type (equals *type, but is a different
pointer), otherwise returns type itself, that's used for recursive calls. */
static CType *type_decl(CType *type, AttributeDef *ad, int *v, int td)
{
CType *post, *ret;
int qualifiers, storage;
/* recursive type, remove storage bits first, apply them later again */
storage = type->t & VT_STORAGE;
type->t &= ~VT_STORAGE;
post = ret = type;
while (tok == '*') {
qualifiers = 0;
redo:
next();
switch(tok) {
case TOK__Atomic:
qualifiers |= VT_ATOMIC;
goto redo;
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;
/* XXX: clarify attribute handling */
case TOK_ATTRIBUTE1:
case TOK_ATTRIBUTE2:
parse_attribute(ad);
break;
}
mk_pointer(type);
type->t |= qualifiers;
if (ret == type)
/* innermost pointed to type is the one for the first derivation */
ret = pointed_type(type);
}
if (tok == '(') {
/* This is possibly a parameter type list for abstract declarators
('int ()'), use post_type for testing this. */
if (!post_type(type, ad, 0, td)) {
/* It's not, so it's a nested declarator, and the post operations
apply to the innermost pointed to type (if any). */
/* XXX: this is not correct to modify 'ad' at this point, but
the syntax is not clear */
parse_attribute(ad);
post = type_decl(type, ad, v, td);
skip(')');
} else
goto abstract;
} else if (tok >= TOK_IDENT && (td & TYPE_DIRECT)) {
/* type identifier */
*v = tok;
next();
} else {
abstract:
if (!(td & TYPE_ABSTRACT))
expect("identifier");
*v = 0;
}
post_type(post, ad, post != ret ? 0 : storage,
td & ~(TYPE_DIRECT|TYPE_ABSTRACT));
parse_attribute(ad);
type->t |= storage;
return ret;
}
/* 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)
gv(RC_INT);
vtop->type = *pointed_type(&vtop->type);
/* Arrays and functions are never lvalues */
if (!(vtop->type.t & (VT_ARRAY | VT_VLA))
&& (vtop->type.t & VT_BTYPE) != VT_FUNC) {
vtop->r |= VT_LVAL;
/* 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->f.func_type;
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) {
gen_cast_s(VT_DOUBLE);
} else if (vtop->type.t & VT_BITFIELD) {
type.t = vtop->type.t & (VT_BTYPE | VT_UNSIGNED);
type.ref = vtop->type.ref;
gen_cast(&type);
} else if (vtop->r & VT_MUSTCAST) {
force_charshort_cast();
}
} 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 and return its type without any side effect. */
static void expr_type(CType *type, void (*expr_fn)(void))
{
nocode_wanted++;
expr_fn();
*type = vtop->type;
vpop();
nocode_wanted--;
}
/* 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, 0)) {
type_decl(type, &ad, &n, TYPE_ABSTRACT);
} else {
expr_type(type, gexpr);
}
skip(')');
}
static void parse_type(CType *type)
{
AttributeDef ad;
int n;
if (!parse_btype(type, &ad, 0)) {
expect("type");
}
type_decl(type, &ad, &n, TYPE_ABSTRACT);
}
static void parse_builtin_params(int nc, const char *args)
{
char c, sep = '(';
CType type;
if (nc)
nocode_wanted++;
next();
if (*args == 0)
skip(sep);
while ((c = *args++)) {
skip(sep);
sep = ',';
if (c == 't') {
parse_type(&type);
vpush(&type);
continue;
}
expr_eq();
type.ref = NULL;
type.t = 0;
switch (c) {
case 'e':
continue;
case 'V':
type.t = VT_CONSTANT;
case 'v':
type.t |= VT_VOID;
mk_pointer (&type);
break;
case 'S':
type.t = VT_CONSTANT;
case 's':
type.t |= char_type.t;
mk_pointer (&type);
break;
case 'i':
type.t = VT_INT;
break;
case 'l':
type.t = VT_SIZE_T;
break;
default:
break;
}
gen_assign_cast(&type);
}
skip(')');
if (nc)
nocode_wanted--;
}
static void parse_atomic(int atok)
{
int size, align, arg, t, save = 0;
CType *atom, *atom_ptr, ct = {0};
SValue store;
char buf[40];
static const char *const templates[] = {
/*
* Each entry consists of callback and function template.
* The template represents argument types and return type.
*
* ? void (return-only)
* b bool
* a atomic
* A read-only atomic
* p pointer to memory
* v value
* l load pointer
* s save pointer
* m memory model
*/
/* keep in order of appearance in tcctok.h: */
/* __atomic_store */ "alm.?",
/* __atomic_load */ "Asm.v",
/* __atomic_exchange */ "alsm.v",
/* __atomic_compare_exchange */ "aplbmm.b",
/* __atomic_fetch_add */ "avm.v",
/* __atomic_fetch_sub */ "avm.v",
/* __atomic_fetch_or */ "avm.v",
/* __atomic_fetch_xor */ "avm.v",
/* __atomic_fetch_and */ "avm.v",
/* __atomic_fetch_nand */ "avm.v",
/* __atomic_and_fetch */ "avm.v",
/* __atomic_sub_fetch */ "avm.v",
/* __atomic_or_fetch */ "avm.v",
/* __atomic_xor_fetch */ "avm.v",
/* __atomic_and_fetch */ "avm.v",
/* __atomic_nand_fetch */ "avm.v"
};
const char *template = templates[(atok - TOK___atomic_store)];
atom = atom_ptr = NULL;
size = 0; /* pacify compiler */
next();
skip('(');
for (arg = 0;;) {
expr_eq();
switch (template[arg]) {
case 'a':
case 'A':
atom_ptr = &vtop->type;
if ((atom_ptr->t & VT_BTYPE) != VT_PTR)
expect("pointer");
atom = pointed_type(atom_ptr);
size = type_size(atom, &align);
if (size > 8
|| (size & (size - 1))
|| (atok > TOK___atomic_compare_exchange
&& (0 == btype_size(atom->t & VT_BTYPE)
|| (atom->t & VT_BTYPE) == VT_PTR)))
expect("integral or integer-sized pointer target type");
/* GCC does not care either: */
/* if (!(atom->t & VT_ATOMIC))
tcc_warning("pointer target declaration is missing '_Atomic'"); */
break;
case 'p':
if ((vtop->type.t & VT_BTYPE) != VT_PTR
|| type_size(pointed_type(&vtop->type), &align) != size)
tcc_error("pointer target type mismatch in argument %d", arg + 1);
gen_assign_cast(atom_ptr);
break;
case 'v':
gen_assign_cast(atom);
break;
case 'l':
indir();
gen_assign_cast(atom);
break;
case 's':
save = 1;
indir();
store = *vtop;
vpop();
break;
case 'm':
gen_assign_cast(&int_type);
break;
case 'b':
ct.t = VT_BOOL;
gen_assign_cast(&ct);
break;
}
if ('.' == template[++arg])
break;
skip(',');
}
skip(')');
ct.t = VT_VOID;
switch (template[arg + 1]) {
case 'b':
ct.t = VT_BOOL;
break;
case 'v':
ct = *atom;
break;
}
sprintf(buf, "%s_%d", get_tok_str(atok, 0), size);
vpush_helper_func(tok_alloc_const(buf));
vrott(arg - save + 1);
gfunc_call(arg - save);
vpush(&ct);
PUT_R_RET(vtop, ct.t);
t = ct.t & VT_BTYPE;
if (t == VT_BYTE || t == VT_SHORT || t == VT_BOOL) {
#ifdef PROMOTE_RET
vtop->r |= BFVAL(VT_MUSTCAST, 1);
#else
vtop->type.t = VT_INT;
#endif
}
gen_cast(&ct);
if (save) {
vpush(&ct);
*vtop = store;
vswap();
vstore();
}
}
ST_FUNC void unary(void)
{
int n, t, align, size, r;
CType type;
Sym *s;
AttributeDef ad;
/* generate line number info */
if (debug_modes)
tcc_debug_line(tcc_state), tcc_tcov_check_line (tcc_state, 1);
type.ref = NULL;
/* 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_LCHAR:
#ifdef TCC_TARGET_PE
t = VT_SHORT|VT_UNSIGNED;
goto push_tokc;
#endif
case TOK_CINT:
case TOK_CCHAR:
t = VT_INT;
push_tokc:
type.t = t;
vsetc(&type, VT_CONST, &tokc);
next();
break;
case TOK_CUINT:
t = VT_INT | VT_UNSIGNED;
goto push_tokc;
case TOK_CLLONG:
t = VT_LLONG;
goto push_tokc;
case TOK_CULLONG:
t = VT_LLONG | VT_UNSIGNED;
goto push_tokc;
case TOK_CFLOAT:
t = VT_FLOAT;
goto push_tokc;
case TOK_CDOUBLE:
t = VT_DOUBLE;
goto push_tokc;
case TOK_CLDOUBLE:
#ifdef TCC_USING_DOUBLE_FOR_LDOUBLE
t = VT_DOUBLE | VT_LONG;
#else
t = VT_LDOUBLE;
#endif
goto push_tokc;
case TOK_CLONG:
t = (LONG_SIZE == 8 ? VT_LLONG : VT_INT) | VT_LONG;
goto push_tokc;
case TOK_CULONG:
t = (LONG_SIZE == 8 ? VT_LLONG : VT_INT) | VT_LONG | VT_UNSIGNED;
goto push_tokc;
case TOK___FUNCTION__:
if (!gnu_ext)
goto tok_identifier;
/* fall thru */
case TOK___FUNC__:
tok = TOK_STR;
cstr_reset(&tokcstr);
cstr_cat(&tokcstr, funcname, 0);
tokc.str.size = tokcstr.size;
tokc.str.data = tokcstr.data;
goto case_TOK_STR;
case TOK_LSTR:
#ifdef TCC_TARGET_PE
t = VT_SHORT | VT_UNSIGNED;
#else
t = VT_INT;
#endif
goto str_init;
case TOK_STR:
case_TOK_STR:
/* string parsing */
t = char_type.t;
str_init:
if (tcc_state->warn_write_strings & WARN_ON)
t |= VT_CONSTANT;
type.t = t;
mk_pointer(&type);
type.t |= VT_ARRAY;
memset(&ad, 0, sizeof(AttributeDef));
ad.section = rodata_section;
decl_initializer_alloc(&type, &ad, VT_CONST, 2, 0, 0);
break;
case TOK_SOTYPE:
case '(':
t = tok;
next();
/* cast ? */
if (parse_btype(&type, &ad, 0)) {
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 |= VT_LVAL;
memset(&ad, 0, sizeof(AttributeDef));
decl_initializer_alloc(&type, &ad, r, 1, 0, 0);
} else if (t == TOK_SOTYPE) { /* from sizeof/alignof (...) */
vpush(&type);
return;
} else {
unary();
gen_cast(&type);
}
} else if (tok == '{') {
int saved_nocode_wanted = nocode_wanted;
if (CONST_WANTED && !NOEVAL_WANTED)
expect("constant");
if (0 == local_scope)
tcc_error("statement expression outside of function");
/* save all registers */
save_regs(0);
/* statement expression : we do not accept break/continue
inside as GCC does. We do retain the nocode_wanted state,
as statement expressions can't ever be entered from the
outside, so any reactivation of code emission (from labels
or loop heads) can be disabled again after the end of it. */
block(STMT_EXPR);
/* If the statement expr can be entered, then we retain the current
nocode_wanted state (from e.g. a 'return 0;' in the stmt-expr).
If it can't be entered then the state is that from before the
statement expression. */
if (saved_nocode_wanted)
nocode_wanted = saved_nocode_wanted;
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 | VT_VLA)))
test_lvalue();
if (vtop->sym)
vtop->sym->a.addrtaken = 1;
mk_pointer(&vtop->type);
gaddrof();
break;
case '!':
next();
unary();
gen_test_zero(TOK_EQ);
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:
case TOK_ALIGNOF3:
t = tok;
next();
if (tok == '(')
tok = TOK_SOTYPE;
expr_type(&type, unary);
if (t == TOK_SIZEOF) {
vpush_type_size(&type, &align);
gen_cast_s(VT_SIZE_T);
} else {
type_size(&type, &align);
s = NULL;
if (vtop[1].r & VT_SYM)
s = vtop[1].sym; /* hack: accessing previous vtop */
if (s && s->a.aligned)
align = 1 << (s->a.aligned - 1);
vpushs(align);
}
break;
case TOK_builtin_expect:
/* __builtin_expect is a no-op for now */
parse_builtin_params(0, "ee");
vpop();
break;
case TOK_builtin_types_compatible_p:
parse_builtin_params(0, "tt");
vtop[-1].type.t &= ~(VT_CONSTANT | VT_VOLATILE);
vtop[0].type.t &= ~(VT_CONSTANT | VT_VOLATILE);
n = is_compatible_types(&vtop[-1].type, &vtop[0].type);
vtop -= 2;
vpushi(n);
break;
case TOK_builtin_choose_expr:
{
int64_t c;
next();
skip('(');
c = expr_const64();
skip(',');
if (!c) {
nocode_wanted++;
}
expr_eq();
if (!c) {
vpop();
nocode_wanted--;
}
skip(',');
if (c) {
nocode_wanted++;
}
expr_eq();
if (c) {
vpop();
nocode_wanted--;
}
skip(')');
}
break;
case TOK_builtin_constant_p:
parse_builtin_params(1, "e");
n = 1;
if ((vtop->r & (VT_VALMASK | VT_LVAL)) != VT_CONST
|| ((vtop->r & VT_SYM) && vtop->sym->a.addrtaken)
)
n = 0;
vtop--;
vpushi(n);
break;
case TOK_builtin_frame_address:
case TOK_builtin_return_address:
{
int tok1 = tok;
int64_t level;
next();
skip('(');
level = expr_const64();
if (level < 0) {
tcc_error("%s only takes positive integers",
tok1 == TOK_builtin_return_address ?
"__builtin_return_address" :
"__builtin_frame_address");
}
skip(')');
type.t = VT_VOID;
mk_pointer(&type);
vset(&type, VT_LOCAL, 0); /* local frame */
while (level--) {
#ifdef TCC_TARGET_RISCV64
vpushi(2*PTR_SIZE);
gen_op('-');
#endif
mk_pointer(&vtop->type);
indir(); /* -> parent frame */
}
if (tok1 == TOK_builtin_return_address) {
// assume return address is just above frame pointer on stack
#ifdef TCC_TARGET_ARM
vpushi(2*PTR_SIZE);
gen_op('+');
#elif defined TCC_TARGET_RISCV64
vpushi(PTR_SIZE);
gen_op('-');
#else
vpushi(PTR_SIZE);
gen_op('+');
#endif
mk_pointer(&vtop->type);
indir();
}
}
break;
#ifdef TCC_TARGET_RISCV64
case TOK_builtin_va_start:
parse_builtin_params(0, "ee");
r = vtop->r & VT_VALMASK;
if (r == VT_LLOCAL)
r = VT_LOCAL;
if (r != VT_LOCAL)
tcc_error("__builtin_va_start expects a local variable");
gen_va_start();
vstore();
break;
#endif
#ifdef TCC_TARGET_X86_64
#ifdef TCC_TARGET_PE
case TOK_builtin_va_start:
parse_builtin_params(0, "ee");
r = vtop->r & VT_VALMASK;
if (r == VT_LLOCAL)
r = VT_LOCAL;
if (r != VT_LOCAL)
tcc_error("__builtin_va_start expects a local variable");
vtop->r = r;
vtop->type = char_pointer_type;
vtop->c.i += 8;
vstore();
break;
#else
case TOK_builtin_va_arg_types:
parse_builtin_params(0, "t");
vpushi(classify_x86_64_va_arg(&vtop->type));
vswap();
vpop();
break;
#endif
#endif
#ifdef TCC_TARGET_ARM64
case TOK_builtin_va_start: {
parse_builtin_params(0, "ee");
//xx check types
gen_va_start();
vpushi(0);
vtop->type.t = VT_VOID;
break;
}
case TOK_builtin_va_arg: {
parse_builtin_params(0, "et");
type = vtop->type;
vpop();
//xx check types
gen_va_arg(&type);
vtop->type = type;
break;
}
case TOK___arm64_clear_cache: {
parse_builtin_params(0, "ee");
gen_clear_cache();
vpushi(0);
vtop->type.t = VT_VOID;
break;
}
#endif
/* atomic operations */
case TOK___atomic_store:
case TOK___atomic_load:
case TOK___atomic_exchange:
case TOK___atomic_compare_exchange:
case TOK___atomic_fetch_add:
case TOK___atomic_fetch_sub:
case TOK___atomic_fetch_or:
case TOK___atomic_fetch_xor:
case TOK___atomic_fetch_and:
case TOK___atomic_fetch_nand:
case TOK___atomic_add_fetch:
case TOK___atomic_sub_fetch:
case TOK___atomic_or_fetch:
case TOK___atomic_xor_fetch:
case TOK___atomic_and_fetch:
case TOK___atomic_nand_fetch:
parse_atomic(tok);
break;
/* pre operations */
case TOK_INC:
case TOK_DEC:
t = tok;
next();
unary();
inc(0, t);
break;
case '-':
next();
unary();
if (is_float(vtop->type.t)) {
gen_opif(TOK_NEG);
} 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 & VT_BTYPE) != VT_PTR) {
s->type.t = VT_VOID;
mk_pointer(&s->type);
s->type.t |= VT_STATIC;
}
vpushsym(&s->type, s);
next();
break;
case TOK_GENERIC:
{
CType controlling_type;
int has_default = 0;
int has_match = 0;
int learn = 0;
TokenString *str = NULL;
int saved_nocode_wanted = nocode_wanted;
nocode_wanted &= ~CONST_WANTED_MASK;
next();
skip('(');
expr_type(&controlling_type, expr_eq);
convert_parameter_type (&controlling_type);
nocode_wanted = saved_nocode_wanted;
for (;;) {
learn = 0;
skip(',');
if (tok == TOK_DEFAULT) {
if (has_default)
tcc_error("too many 'default'");
has_default = 1;
if (!has_match)
learn = 1;
next();
} else {
AttributeDef ad_tmp;
int itmp;
CType cur_type;
parse_btype(&cur_type, &ad_tmp, 0);
type_decl(&cur_type, &ad_tmp, &itmp, TYPE_ABSTRACT);
if (compare_types(&controlling_type, &cur_type, 0)) {
if (has_match) {
tcc_error("type match twice");
}
has_match = 1;
learn = 1;
}
}
skip(':');
if (learn) {
if (str)
tok_str_free(str);
skip_or_save_block(&str);
} else {
skip_or_save_block(NULL);
}
if (tok == ')')
break;
}
if (!str) {
char buf[60];
type_to_str(buf, sizeof buf, &controlling_type, NULL);
tcc_error("type '%s' does not match any association", buf);
}
begin_macro(str, 1);
next();
expr_eq();
if (tok != TOK_EOF)
expect(",");
end_macro();
next();
break;
}
// special qnan , snan and infinity values
case TOK___NAN__:
n = 0x7fc00000;
special_math_val:
vpushi(n);
vtop->type.t = VT_FLOAT;
next();
break;
case TOK___SNAN__:
n = 0x7f800001;
goto special_math_val;
case TOK___INF__:
n = 0x7f800000;
goto special_math_val;
default:
tok_identifier:
if (tok < TOK_UIDENT)
tcc_error("expression expected before '%s'", get_tok_str(tok, &tokc));
t = tok;
next();
s = sym_find(t);
if (!s || IS_ASM_SYM(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 */
tcc_warning_c(warn_implicit_function_declaration)(
"implicit declaration of function '%s'", name);
s = external_global_sym(t, &func_old_type);
}
r = s->r;
/* A symbol that has a register is a local register variable,
which starts out as VT_LOCAL value. */
if ((r & VT_VALMASK) < VT_CONST)
r = (r & ~VT_VALMASK) | VT_LOCAL;
vset(&s->type, r, s->c);
/* Point to s as backpointer (even without r&VT_SYM).
Will be used by at least the x86 inline asm parser for
regvars. */
vtop->sym = s;
if (r & VT_SYM) {
vtop->c.i = 0;
} else if (r == VT_CONST && IS_ENUM_VAL(s->type.t)) {
vtop->c.i = s->enum_val;
}
break;
}
/* post operations */
while (1) {
if (tok == TOK_INC || tok == TOK_DEC) {
inc(1, tok);
next();
} else if (tok == '.' || tok == TOK_ARROW) {
int qualifiers, cumofs;
/* field */
if (tok == TOK_ARROW)
indir();
qualifiers = vtop->type.t & (VT_CONSTANT | VT_VOLATILE);
test_lvalue();
/* expect pointer on structure */
next();
s = find_field(&vtop->type, tok, &cumofs);
/* add field offset to pointer */
gaddrof();
vtop->type = char_pointer_type; /* change type to 'char *' */
vpushi(cumofs);
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 |= VT_LVAL;
#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 = regsize = 0;
ret.r2 = VT_CONST;
/* compute first implicit argument if a structure is returned */
if ((s->type.t & VT_BTYPE) == VT_STRUCT) {
variadic = (s->f.func_type == FUNC_ELLIPSIS);
ret_nregs = gfunc_sret(&s->type, variadic, &ret.type,
&ret_align, &regsize);
if (ret_nregs <= 0) {
/* 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);
#ifdef CONFIG_TCC_BCHECK
if (tcc_state->do_bounds_check)
--loc;
#endif
ret.c = vtop->c;
if (ret_nregs < 0)
vtop--;
else
nb_args++;
}
} else {
ret_nregs = 1;
ret.type = s->type;
}
if (ret_nregs > 0) {
/* return in register */
ret.c.i = 0;
PUT_R_RET(&ret, ret.type.t);
}
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(')');
gfunc_call(nb_args);
if (ret_nregs < 0) {
vsetc(&ret.type, ret.r, &ret.c);
#ifdef TCC_TARGET_RISCV64
arch_transfer_ret_regs(1);
#endif
} else {
/* return value */
n = ret_nregs;
while (n > 1) {
int rc = reg_classes[ret.r] & ~(RC_INT | RC_FLOAT);
/* We assume that when a structure is returned in multiple
registers, their classes are consecutive values of the
suite s(n) = 2^n */
rc <<= --n;
for (r = 0; r < NB_REGS; ++r)
if (reg_classes[r] & rc)
break;
vsetc(&ret.type, r, &ret.c);
}
vsetc(&ret.type, ret.r, &ret.c);
vtop->r2 = ret.r2;
/* 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. */
size = (size + regsize - 1) & -regsize;
if (ret_align > align)
align = ret_align;
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);
}
/* Promote char/short return values. This is matters only
for calling function that were not compiled by TCC and
only on some architectures. For those where it doesn't
matter we expect things to be already promoted to int,
but not larger. */
t = s->type.t & VT_BTYPE;
if (t == VT_BYTE || t == VT_SHORT || t == VT_BOOL) {
#ifdef PROMOTE_RET
vtop->r |= BFVAL(VT_MUSTCAST, 1);
#else
vtop->type.t = VT_INT;
#endif
}
}
if (s->f.func_noreturn) {
if (debug_modes)
tcc_tcov_block_end(tcc_state, -1);
CODE_OFF();
}
} else {
break;
}
}
}
#ifndef precedence_parser /* original top-down parser */
static void expr_prod(void)
{
int t;
unary();
while ((t = tok) == '*' || t == '/' || t == '%') {
next();
unary();
gen_op(t);
}
}
static void expr_sum(void)
{
int t;
expr_prod();
while ((t = tok) == '+' || t == '-') {
next();
expr_prod();
gen_op(t);
}
}
static void expr_shift(void)
{
int t;
expr_sum();
while ((t = tok) == TOK_SHL || t == TOK_SAR) {
next();
expr_sum();
gen_op(t);
}
}
static void expr_cmp(void)
{
int t;
expr_shift();
while (((t = tok) >= TOK_ULE && t <= TOK_GT) ||
t == TOK_ULT || t == TOK_UGE) {
next();
expr_shift();
gen_op(t);
}
}
static void expr_cmpeq(void)
{
int t;
expr_cmp();
while ((t = tok) == TOK_EQ || t == TOK_NE) {
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('|');
}
}
static void expr_landor(int op);
static void expr_land(void)
{
expr_or();
if (tok == TOK_LAND)
expr_landor(tok);
}
static void expr_lor(void)
{
expr_land();
if (tok == TOK_LOR)
expr_landor(tok);
}
# define expr_landor_next(op) op == TOK_LAND ? expr_or() : expr_land()
#else /* defined precedence_parser */
# define expr_landor_next(op) unary(), expr_infix(precedence(op) + 1)
# define expr_lor() unary(), expr_infix(1)
static int precedence(int tok)
{
switch (tok) {
case TOK_LOR: return 1;
case TOK_LAND: return 2;
case '|': return 3;
case '^': return 4;
case '&': return 5;
case TOK_EQ: case TOK_NE: return 6;
relat: case TOK_ULT: case TOK_UGE: return 7;
case TOK_SHL: case TOK_SAR: return 8;
case '+': case '-': return 9;
case '*': case '/': case '%': return 10;
default:
if (tok >= TOK_ULE && tok <= TOK_GT)
goto relat;
return 0;
}
}
static unsigned char prec[256];
static void init_prec(void)
{
int i;
for (i = 0; i < 256; i++)
prec[i] = precedence(i);
}
#define precedence(i) ((unsigned)i < 256 ? prec[i] : 0)
static void expr_landor(int op);
static void expr_infix(int p)
{
int t = tok, p2;
while ((p2 = precedence(t)) >= p) {
if (t == TOK_LOR || t == TOK_LAND) {
expr_landor(t);
} else {
next();
unary();
if (precedence(tok) > p2)
expr_infix(p2 + 1);
gen_op(t);
}
t = tok;
}
}
#endif
/* Assuming vtop is a value used in a conditional context
(i.e. compared with zero) return 0 if it's false, 1 if
true and -1 if it can't be statically determined. */
static int condition_3way(void)
{
int c = -1;
if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST &&
(!(vtop->r & VT_SYM) || !vtop->sym->a.weak)) {
vdup();
gen_cast_s(VT_BOOL);
c = vtop->c.i;
vpop();
}
return c;
}
static void expr_landor(int op)
{
int t = 0, cc = 1, f = 0, i = op == TOK_LAND, c;
for(;;) {
c = f ? i : condition_3way();
if (c < 0)
save_regs(1), cc = 0;
else if (c != i)
nocode_wanted++, f = 1;
if (tok != op)
break;
if (c < 0)
t = gvtst(i, t);
else
vpop();
next();
expr_landor_next(op);
}
if (cc || f) {
vpop();
vpushi(i ^ f);
gsym(t);
nocode_wanted -= f;
} else {
gvtst_set(i, t);
}
}
static int is_cond_bool(SValue *sv)
{
if ((sv->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST
&& (sv->type.t & VT_BTYPE) == VT_INT)
return (unsigned)sv->c.i < 2;
if (sv->r == VT_CMP)
return 1;
return 0;
}
static void expr_cond(void)
{
int tt, u, r1, r2, rc, t1, t2, islv, c, g;
SValue sv;
CType type;
expr_lor();
if (tok == '?') {
next();
c = condition_3way();
g = (tok == ':' && gnu_ext);
tt = 0;
if (!g) {
if (c < 0) {
save_regs(1);
tt = gvtst(1, 0);
} else {
vpop();
}
} else if (c < 0) {
/* needed to avoid having different registers saved in
each branch */
save_regs(1);
gv_dup();
tt = gvtst(0, 0);
}
if (c == 0)
nocode_wanted++;
if (!g)
gexpr();
if ((vtop->type.t & VT_BTYPE) == VT_FUNC)
mk_pointer(&vtop->type);
sv = *vtop; /* save value to handle it later */
vtop--; /* no vpop so that FP stack is not flushed */
if (g) {
u = tt;
} else if (c < 0) {
u = gjmp(0);
gsym(tt);
} else
u = 0;
if (c == 0)
nocode_wanted--;
if (c == 1)
nocode_wanted++;
skip(':');
expr_cond();
if ((vtop->type.t & VT_BTYPE) == VT_FUNC)
mk_pointer(&vtop->type);
/* cast operands to correct type according to ISOC rules */
if (!combine_types(&type, &sv, vtop, '?'))
type_incompatibility_error(&sv.type, &vtop->type,
"type mismatch in conditional expression (have '%s' and '%s')");
if (c < 0 && is_cond_bool(vtop) && is_cond_bool(&sv)) {
/* optimize "if (f ? a > b : c || d) ..." for example, where normally
"a < b" and "c || d" would be forced to "(int)0/1" first, whereas
this code jumps directly to the if's then/else branches. */
t1 = gvtst(0, 0);
t2 = gjmp(0);
gsym(u);
vpushv(&sv);
/* combine jump targets of 2nd op with VT_CMP of 1st op */
gvtst_set(0, t1);
gvtst_set(1, t2);
gen_cast(&type);
// tcc_warning("two conditions expr_cond");
return;
}
/* 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 */
if (c != 1) {
gen_cast(&type);
if (islv) {
mk_pointer(&vtop->type);
gaddrof();
} else if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
gaddrof();
}
rc = RC_TYPE(type.t);
/* for long longs, we use fixed registers to avoid having
to handle a complicated move */
if (USING_TWO_WORDS(type.t))
rc = RC_RET(type.t);
tt = r2 = 0;
if (c < 0) {
r2 = gv(rc);
tt = gjmp(0);
}
gsym(u);
if (c == 1)
nocode_wanted--;
/* this is horrible, but we must also convert first
operand */
if (c != 0) {
*vtop = sv;
gen_cast(&type);
if (islv) {
mk_pointer(&vtop->type);
gaddrof();
} else if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
gaddrof();
}
if (c < 0) {
r1 = gv(rc);
move_reg(r2, r1, islv ? VT_PTR : type.t);
vtop->r = r2;
gsym(tt);
}
if (islv)
indir();
}
}
static void expr_eq(void)
{
int t;
expr_cond();
if ((t = tok) == '=' || TOK_ASSIGN(t)) {
test_lvalue();
next();
if (t == '=') {
expr_eq();
} else {
vdup();
expr_eq();
gen_op(TOK_ASSIGN_OP(t));
}
vstore();
}
}
ST_FUNC void gexpr(void)
{
expr_eq();
if (tok == ',') {
do {
vpop();
next();
expr_eq();
} while (tok == ',');
/* convert array & function to pointer */
convert_parameter_type(&vtop->type);
/* make builtin_constant_p((1,2)) return 0 (like on gcc) */
if ((vtop->r & VT_VALMASK) == VT_CONST && nocode_wanted && !CONST_WANTED)
gv(RC_TYPE(vtop->type.t));
}
}
/* parse a constant expression and return value in vtop. */
static void expr_const1(void)
{
nocode_wanted += CONST_WANTED_BIT;
expr_cond();
nocode_wanted -= CONST_WANTED_BIT;
}
/* parse an integer constant and return its value. */
static inline int64_t expr_const64(void)
{
int64_t c;
expr_const1();
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM | VT_NONCONST)) != VT_CONST)
expect("constant expression");
c = vtop->c.i;
vpop();
return c;
}
/* parse an integer constant and return its value.
Complain if it doesn't fit 32bit (signed or unsigned). */
ST_FUNC int expr_const(void)
{
int c;
int64_t wc = expr_const64();
c = wc;
if (c != wc && (unsigned)c != wc)
tcc_error("constant exceeds 32 bit");
return c;
}
/* ------------------------------------------------------------------------- */
/* return from function */
#ifndef TCC_TARGET_ARM64
static void gfunc_return(CType *func_type)
{
if ((func_type->t & VT_BTYPE) == VT_STRUCT) {
CType type, ret_type;
int ret_align, ret_nregs, regsize;
ret_nregs = gfunc_sret(func_type, func_var, &ret_type,
&ret_align, &regsize);
if (ret_nregs < 0) {
#ifdef TCC_TARGET_RISCV64
arch_transfer_ret_regs(0);
#endif
} else if (0 == ret_nregs) {
/* if returning structure, must copy it to implicit
first pointer arg location */
type = *func_type;
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 size, addr, align, rc, n;
size = type_size(func_type,&align);
if ((align & (ret_align - 1))
&& ((vtop->r & VT_VALMASK) < VT_CONST /* pointer to struct */
|| (vtop->c.i & (ret_align - 1))
)) {
loc = (loc - size) & -ret_align;
addr = loc;
type = *func_type;
vset(&type, VT_LOCAL | VT_LVAL, addr);
vswap();
vstore();
vpop();
vset(&ret_type, VT_LOCAL | VT_LVAL, addr);
}
vtop->type = ret_type;
rc = RC_RET(ret_type.t);
//printf("struct return: n:%d t:%02x rc:%02x\n", ret_nregs, ret_type.t, rc);
for (n = ret_nregs; --n > 0;) {
vdup();
gv(rc);
vswap();
incr_offset(regsize);
/* We assume that when a structure is returned in multiple
registers, their classes are consecutive values of the
suite s(n) = 2^n */
rc <<= 1;
}
gv(rc);
vtop -= ret_nregs - 1;
}
} else {
gv(RC_RET(func_type->t));
}
vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
}
#endif
static void check_func_return(void)
{
if ((func_vt.t & VT_BTYPE) == VT_VOID)
return;
if (!strcmp (funcname, "main")
&& (func_vt.t & VT_BTYPE) == VT_INT) {
/* main returns 0 by default */
vpushi(0);
gen_assign_cast(&func_vt);
gfunc_return(&func_vt);
} else {
tcc_warning("function might return no value: '%s'", funcname);
}
}
/* ------------------------------------------------------------------------- */
/* switch/case */
static int case_cmpi(const void *pa, const void *pb)
{
int64_t a = (*(struct case_t**) pa)->v1;
int64_t b = (*(struct case_t**) pb)->v1;
return a < b ? -1 : a > b;
}
static int case_cmpu(const void *pa, const void *pb)
{
uint64_t a = (uint64_t)(*(struct case_t**) pa)->v1;
uint64_t b = (uint64_t)(*(struct case_t**) pb)->v1;
return a < b ? -1 : a > b;
}
static void gtst_addr(int t, int a)
{
gsym_addr(gvtst(0, t), a);
}
static void gcase(struct case_t **base, int len, int *bsym)
{
struct case_t *p;
int e;
int ll = (vtop->type.t & VT_BTYPE) == VT_LLONG;
while (len > 8) {
/* binary search */
p = base[len/2];
vdup();
if (ll)
vpushll(p->v2);
else
vpushi(p->v2);
gen_op(TOK_LE);
e = gvtst(1, 0);
vdup();
if (ll)
vpushll(p->v1);
else
vpushi(p->v1);
gen_op(TOK_GE);
gtst_addr(0, p->sym); /* v1 <= x <= v2 */
/* x < v1 */
gcase(base, len/2, bsym);
/* x > v2 */
gsym(e);
e = len/2 + 1;
base += e; len -= e;
}
/* linear scan */
while (len--) {
p = *base++;
vdup();
if (ll)
vpushll(p->v2);
else
vpushi(p->v2);
if (p->v1 == p->v2) {
gen_op(TOK_EQ);
gtst_addr(0, p->sym);
} else {
gen_op(TOK_LE);
e = gvtst(1, 0);
vdup();
if (ll)
vpushll(p->v1);
else
vpushi(p->v1);
gen_op(TOK_GE);
gtst_addr(0, p->sym);
gsym(e);
}
}
*bsym = gjmp(*bsym);
}
static void end_switch(void)
{
struct switch_t *sw = cur_switch;
dynarray_reset(&sw->p, &sw->n);
cur_switch = sw->prev;
tcc_free(sw);
}
/* ------------------------------------------------------------------------- */
/* __attribute__((cleanup(fn))) */
static void try_call_scope_cleanup(Sym *stop)
{
Sym *cls = cur_scope->cl.s;
for (; cls != stop; cls = cls->ncl) {
Sym *fs = cls->next;
Sym *vs = cls->prev_tok;
vpushsym(&fs->type, fs);
vset(&vs->type, vs->r, vs->c);
vtop->sym = vs;
mk_pointer(&vtop->type);
gaddrof();
gfunc_call(1);
}
}
static void try_call_cleanup_goto(Sym *cleanupstate)
{
Sym *oc, *cc;
int ocd, ccd;
if (!cur_scope->cl.s)
return;
/* search NCA of both cleanup chains given parents and initial depth */
ocd = cleanupstate ? cleanupstate->v & ~SYM_FIELD : 0;
for (ccd = cur_scope->cl.n, oc = cleanupstate; ocd > ccd; --ocd, oc = oc->ncl)
;
for (cc = cur_scope->cl.s; ccd > ocd; --ccd, cc = cc->ncl)
;
for (; cc != oc; cc = cc->ncl, oc = oc->ncl, --ccd)
;
try_call_scope_cleanup(cc);
}
/* call 'func' for each __attribute__((cleanup(func))) */
static void block_cleanup(struct scope *o)
{
int jmp = 0;
Sym *g, **pg;
for (pg = &pending_gotos; (g = *pg) && g->c > o->cl.n;) {
if (g->prev_tok->r & LABEL_FORWARD) {
Sym *pcl = g->next;
if (!jmp)
jmp = gjmp(0);
gsym(pcl->jnext);
try_call_scope_cleanup(o->cl.s);
pcl->jnext = gjmp(0);
if (!o->cl.n)
goto remove_pending;
g->c = o->cl.n;
pg = &g->prev;
} else {
remove_pending:
*pg = g->prev;
sym_free(g);
}
}
gsym(jmp);
try_call_scope_cleanup(o->cl.s);
}
/* ------------------------------------------------------------------------- */
/* VLA */
static void vla_restore(int loc)
{
if (loc)
gen_vla_sp_restore(loc);
}
static void vla_leave(struct scope *o)
{
struct scope *c = cur_scope, *v = NULL;
for (; c != o && c; c = c->prev)
if (c->vla.num)
v = c;
if (v)
vla_restore(v->vla.locorig);
}
/* ------------------------------------------------------------------------- */
/* local scopes */
static void new_scope(struct scope *o)
{
/* copy and link previous scope */
*o = *cur_scope;
o->prev = cur_scope;
cur_scope = o;
cur_scope->vla.num = 0;
/* record local declaration stack position */
o->lstk = local_stack;
o->llstk = local_label_stack;
++local_scope;
}
static void prev_scope(struct scope *o, int is_expr)
{
vla_leave(o->prev);
if (o->cl.s != o->prev->cl.s)
block_cleanup(o->prev);
/* pop locally defined labels */
label_pop(&local_label_stack, o->llstk, is_expr);
/* In the is_expr case (a statement expression is finished here),
vtop might refer to symbols on the local_stack. Either via the
type or via vtop->sym. We can't pop those nor any that in turn
might be referred to. To make it easier we don't roll back
any symbols in that case; some upper level call to block() will
do that. We do have to remove such symbols from the lookup
tables, though. sym_pop will do that. */
/* pop locally defined symbols */
pop_local_syms(o->lstk, is_expr);
cur_scope = o->prev;
--local_scope;
}
/* leave a scope via break/continue(/goto) */
static void leave_scope(struct scope *o)
{
if (!o)
return;
try_call_scope_cleanup(o->cl.s);
vla_leave(o);
}
/* short versiona for scopes with 'if/do/while/switch' which can
declare only types (of struct/union/enum) */
static void new_scope_s(struct scope *o)
{
o->lstk = local_stack;
++local_scope;
}
static void prev_scope_s(struct scope *o)
{
sym_pop(&local_stack, o->lstk, 0);
--local_scope;
}
/* ------------------------------------------------------------------------- */
/* call block from 'for do while' loops */
static void lblock(int *bsym, int *csym)
{
struct scope *lo = loop_scope, *co = cur_scope;
int *b = co->bsym, *c = co->csym;
if (csym) {
co->csym = csym;
loop_scope = co;
}
co->bsym = bsym;
block(0);
co->bsym = b;
if (csym) {
co->csym = c;
loop_scope = lo;
}
}
static void block(int flags)
{
int a, b, c, d, e, t;
struct scope o;
Sym *s;
if (flags & STMT_EXPR) {
/* default return value is (void) */
vpushi(0);
vtop->type.t = VT_VOID;
}
again:
t = tok;
/* If the token carries a value, next() might destroy it. Only with
invalid code such as f(){"123"4;} */
if (TOK_HAS_VALUE(t))
goto expr;
next();
if (debug_modes)
tcc_tcov_check_line (tcc_state, 0), tcc_tcov_block_begin (tcc_state);
if (t == TOK_IF) {
new_scope_s(&o);
skip('(');
gexpr();
skip(')');
a = gvtst(1, 0);
block(0);
if (tok == TOK_ELSE) {
d = gjmp(0);
gsym(a);
next();
block(0);
gsym(d); /* patch else jmp */
} else {
gsym(a);
}
prev_scope_s(&o);
} else if (t == TOK_WHILE) {
new_scope_s(&o);
d = gind();
skip('(');
gexpr();
skip(')');
a = gvtst(1, 0);
b = 0;
lblock(&a, &b);
gjmp_addr(d);
gsym_addr(b, d);
gsym(a);
prev_scope_s(&o);
} else if (t == '{') {
if (debug_modes)
tcc_debug_stabn(tcc_state, N_LBRAC, ind - func_ind);
new_scope(&o);
/* handle local labels declarations */
while (tok == TOK_LABEL) {
do {
next();
if (tok < TOK_UIDENT)
expect("label identifier");
label_push(&local_label_stack, tok, LABEL_DECLARED);
next();
} while (tok == ',');
skip(';');
}
while (tok != '}') {
decl(VT_LOCAL);
if (tok != '}') {
if (flags & STMT_EXPR)
vpop();
block(flags | STMT_COMPOUND);
}
}
prev_scope(&o, flags & STMT_EXPR);
if (debug_modes)
tcc_debug_stabn(tcc_state, N_RBRAC, ind - func_ind);
if (local_scope)
next();
else if (!nocode_wanted)
check_func_return();
} else if (t == TOK_RETURN) {
b = (func_vt.t & VT_BTYPE) != VT_VOID;
if (tok != ';') {
gexpr();
if (b) {
gen_assign_cast(&func_vt);
} else {
if (vtop->type.t != VT_VOID)
tcc_warning("void function returns a value");
vtop--;
}
} else if (b) {
tcc_warning("'return' with no value");
b = 0;
}
leave_scope(root_scope);
if (b)
gfunc_return(&func_vt);
skip(';');
/* jump unless last stmt in top-level block */
if (tok != '}' || local_scope != 1)
rsym = gjmp(rsym);
if (debug_modes)
tcc_tcov_block_end (tcc_state, -1);
CODE_OFF();
} else if (t == TOK_BREAK) {
/* compute jump */
if (!cur_scope->bsym)
tcc_error("cannot break");
if (cur_switch && cur_scope->bsym == cur_switch->bsym)
leave_scope(cur_switch->scope);
else
leave_scope(loop_scope);
*cur_scope->bsym = gjmp(*cur_scope->bsym);
skip(';');
} else if (t == TOK_CONTINUE) {
/* compute jump */
if (!cur_scope->csym)
tcc_error("cannot continue");
leave_scope(loop_scope);
*cur_scope->csym = gjmp(*cur_scope->csym);
skip(';');
} else if (t == TOK_FOR) {
new_scope(&o);
skip('(');
if (tok != ';') {
/* c99 for-loop init decl? */
if (!decl(VT_JMP)) {
/* no, regular for-loop init expr */
gexpr();
vpop();
}
}
skip(';');
a = b = 0;
c = d = gind();
if (tok != ';') {
gexpr();
a = gvtst(1, 0);
}
skip(';');
if (tok != ')') {
e = gjmp(0);
d = gind();
gexpr();
vpop();
gjmp_addr(c);
gsym(e);
}
skip(')');
lblock(&a, &b);
gjmp_addr(d);
gsym_addr(b, d);
gsym(a);
prev_scope(&o, 0);
} else if (t == TOK_DO) {
new_scope_s(&o);
a = b = 0;
d = gind();
lblock(&a, &b);
gsym(b);
skip(TOK_WHILE);
skip('(');
gexpr();
skip(')');
skip(';');
c = gvtst(0, 0);
gsym_addr(c, d);
gsym(a);
prev_scope_s(&o);
} else if (t == TOK_SWITCH) {
struct switch_t *sw;
sw = tcc_mallocz(sizeof *sw);
sw->bsym = &a;
sw->scope = cur_scope;
sw->prev = cur_switch;
sw->nocode_wanted = nocode_wanted;
cur_switch = sw;
new_scope_s(&o);
skip('(');
gexpr();
skip(')');
sw->sv = *vtop--; /* save switch value */
a = 0;
b = gjmp(0); /* jump to first case */
lblock(&a, NULL);
a = gjmp(a); /* add implicit break */
/* case lookup */
gsym(b);
prev_scope_s(&o);
if (sw->nocode_wanted)
goto skip_switch;
if (sw->sv.type.t & VT_UNSIGNED)
qsort(sw->p, sw->n, sizeof(void*), case_cmpu);
else
qsort(sw->p, sw->n, sizeof(void*), case_cmpi);
for (b = 1; b < sw->n; b++)
if (sw->sv.type.t & VT_UNSIGNED
? (uint64_t)sw->p[b - 1]->v2 >= (uint64_t)sw->p[b]->v1
: sw->p[b - 1]->v2 >= sw->p[b]->v1)
tcc_error("duplicate case value");
vpushv(&sw->sv);
gv(RC_INT);
d = 0, gcase(sw->p, sw->n, &d);
vpop();
if (sw->def_sym)
gsym_addr(d, sw->def_sym);
else
gsym(d);
skip_switch:
/* break label */
gsym(a);
end_switch();
} else if (t == TOK_CASE) {
struct case_t *cr;
if (!cur_switch)
expect("switch");
cr = tcc_malloc(sizeof(struct case_t));
dynarray_add(&cur_switch->p, &cur_switch->n, cr);
cr->v1 = cr->v2 = expr_const64();
if (gnu_ext && tok == TOK_DOTS) {
next();
cr->v2 = expr_const64();
if ((!(cur_switch->sv.type.t & VT_UNSIGNED) && cr->v2 < cr->v1)
|| (cur_switch->sv.type.t & VT_UNSIGNED && (uint64_t)cr->v2 < (uint64_t)cr->v1))
tcc_warning("empty case range");
}
/* case and default are unreachable from a switch under nocode_wanted */
if (!cur_switch->nocode_wanted)
cr->sym = gind();
skip(':');
goto block_after_label;
} else if (t == TOK_DEFAULT) {
if (!cur_switch)
expect("switch");
if (cur_switch->def_sym)
tcc_error("too many 'default'");
cur_switch->def_sym = cur_switch->nocode_wanted ? 1 : gind();
skip(':');
goto block_after_label;
} else if (t == TOK_GOTO) {
vla_restore(cur_scope->vla.locorig);
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;
if (s->r & LABEL_FORWARD) {
/* start new goto chain for cleanups, linked via label->next */
if (cur_scope->cl.s && !nocode_wanted) {
sym_push2(&pending_gotos, SYM_FIELD, 0, cur_scope->cl.n);
pending_gotos->prev_tok = s;
s = sym_push2(&s->next, SYM_FIELD, 0, 0);
pending_gotos->next = s;
}
s->jnext = gjmp(s->jnext);
} else {
try_call_cleanup_goto(s->cleanupstate);
gjmp_addr(s->jnext);
}
next();
} else {
expect("label identifier");
}
skip(';');
} else if (t == TOK_ASM1 || t == TOK_ASM2 || t == TOK_ASM3) {
asm_instr();
} else {
if (tok == ':' && t >= TOK_UIDENT) {
/* label case */
next();
s = label_find(t);
if (s) {
if (s->r == LABEL_DEFINED)
tcc_error("duplicate label '%s'", get_tok_str(s->v, NULL));
s->r = LABEL_DEFINED;
if (s->next) {
Sym *pcl; /* pending cleanup goto */
for (pcl = s->next; pcl; pcl = pcl->prev)
gsym(pcl->jnext);
sym_pop(&s->next, NULL, 0);
} else
gsym(s->jnext);
} else {
s = label_push(&global_label_stack, t, LABEL_DEFINED);
}
s->jnext = gind();
s->cleanupstate = cur_scope->cl.s;
block_after_label:
{
/* Accept attributes after labels (e.g. 'unused') */
AttributeDef ad_tmp;
parse_attribute(&ad_tmp);
}
if (debug_modes)
tcc_tcov_reset_ind(tcc_state);
vla_restore(cur_scope->vla.loc);
if (tok != '}') {
if (0 == (flags & STMT_COMPOUND))
goto again;
/* C23: insert implicit null-statement whithin compound statement */
} else {
/* we accept this, but it is a mistake */
tcc_warning_c(warn_all)("deprecated use of label at end of compound statement");
}
} else {
/* expression case */
if (t != ';') {
unget_tok(t);
expr:
if (flags & STMT_EXPR) {
vpop();
gexpr();
} else {
gexpr();
vpop();
}
skip(';');
}
}
}
if (debug_modes)
tcc_tcov_check_line (tcc_state, 0), tcc_tcov_block_end (tcc_state, 0);
}
/* This skips over a stream of tokens containing balanced {} and ()
pairs, stopping at outer ',' ';' and '}' (or matching '}' if we started
with a '{'). If STR then allocates and stores the skipped tokens
in *STR. This doesn't check if () and {} are nested correctly,
i.e. "({)}" is accepted. */
static void skip_or_save_block(TokenString **str)
{
int braces = tok == '{';
int level = 0;
if (str)
*str = tok_str_alloc();
while (1) {
int t = tok;
if (level == 0
&& (t == ','
|| t == ';'
|| t == '}'
|| t == ')'
|| t == ']'))
break;
if (t == TOK_EOF) {
if (str || level > 0)
tcc_error("unexpected end of file");
else
break;
}
if (str)
tok_str_add_tok(*str);
next();
if (t == '{' || t == '(' || t == '[') {
level++;
} else if (t == '}' || t == ')' || t == ']') {
level--;
if (level == 0 && braces && t == '}')
break;
}
}
if (str)
tok_str_add(*str, TOK_EOF);
}
#define EXPR_CONST 1
#define EXPR_ANY 2
static void parse_init_elem(int expr_type)
{
int saved_global_expr;
switch(expr_type) {
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, as well as lvalue for anon symbols
(compound literals). */
if (((vtop->r & (VT_VALMASK | VT_LVAL)) != VT_CONST
&& ((vtop->r & (VT_SYM|VT_LVAL)) != (VT_SYM|VT_LVAL)
|| vtop->sym->v < SYM_FIRST_ANOM))
#ifdef TCC_TARGET_PE
|| ((vtop->r & VT_SYM) && vtop->sym->a.dllimport)
#endif
)
tcc_error("initializer element is not constant");
break;
case EXPR_ANY:
expr_eq();
break;
}
}
#if 1
static void init_assert(init_params *p, int offset)
{
if (p->sec ? !NODATA_WANTED && offset > p->sec->data_offset
: !nocode_wanted && offset > p->local_offset)
tcc_internal_error("initializer overflow");
}
#else
#define init_assert(sec, offset)
#endif
/* put zeros for variable based init */
static void init_putz(init_params *p, unsigned long c, int size)
{
init_assert(p, c + size);
if (p->sec) {
/* nothing to do because globals are already set to zero */
} else {
vpush_helper_func(TOK_memset);
vseti(VT_LOCAL, c);
#ifdef TCC_TARGET_ARM
vpushs(size);
vpushi(0);
#else
vpushi(0);
vpushs(size);
#endif
gfunc_call(3);
}
}
#define DIF_FIRST 1
#define DIF_SIZE_ONLY 2
#define DIF_HAVE_ELEM 4
#define DIF_CLEAR 8
/* delete relocations for specified range c ... c + size. Unfortunatly
in very special cases, relocations may occur unordered */
static void decl_design_delrels(Section *sec, int c, int size)
{
ElfW_Rel *rel, *rel2, *rel_end;
if (!sec || !sec->reloc)
return;
rel = rel2 = (ElfW_Rel*)sec->reloc->data;
rel_end = (ElfW_Rel*)(sec->reloc->data + sec->reloc->data_offset);
while (rel < rel_end) {
if (rel->r_offset >= c && rel->r_offset < c + size) {
sec->reloc->data_offset -= sizeof *rel;
} else {
if (rel2 != rel)
memcpy(rel2, rel, sizeof *rel);
++rel2;
}
++rel;
}
}
static void decl_design_flex(init_params *p, Sym *ref, int index)
{
if (ref == p->flex_array_ref) {
if (index >= ref->c)
ref->c = index + 1;
} else if (ref->c < 0)
tcc_error("flexible array has zero size in this context");
}
/* t is the array or struct type. c is the array or struct
address. cur_field is the pointer to the current
field, for arrays the 'c' member contains the current start
index. 'flags' is as in decl_initializer.
'al' contains the already initialized length of the
current container (starting at c). This returns the new length of that. */
static int decl_designator(init_params *p, CType *type, unsigned long c,
Sym **cur_field, int flags, int al)
{
Sym *s, *f;
int index, index_last, align, l, nb_elems, elem_size;
unsigned long corig = c;
elem_size = 0;
nb_elems = 1;
if (flags & DIF_HAVE_ELEM)
goto no_designator;
if (gnu_ext && tok >= TOK_UIDENT) {
l = tok, next();
if (tok == ':')
goto struct_field;
unget_tok(l);
}
/* NOTE: we only support ranges for last designator */
while (nb_elems == 1 && (tok == '[' || tok == '.')) {
if (tok == '[') {
if (!(type->t & VT_ARRAY))
expect("array type");
next();
index = index_last = expr_const();
if (tok == TOK_DOTS && gnu_ext) {
next();
index_last = expr_const();
}
skip(']');
s = type->ref;
decl_design_flex(p, s, index_last);
if (index < 0 || index_last >= s->c || index_last < index)
tcc_error("index exceeds array bounds or range is empty");
if (cur_field)
(*cur_field)->c = index_last;
type = pointed_type(type);
elem_size = type_size(type, &align);
c += index * elem_size;
nb_elems = index_last - index + 1;
} else {
int cumofs;
next();
l = tok;
struct_field:
next();
f = find_field(type, l, &cumofs);
if (cur_field)
*cur_field = f;
type = &f->type;
c += cumofs;
}
cur_field = NULL;
}
if (!cur_field) {
if (tok == '=') {
next();
} else if (!gnu_ext) {
expect("=");
}
} else {
no_designator:
if (type->t & VT_ARRAY) {
index = (*cur_field)->c;
s = type->ref;
decl_design_flex(p, s, index);
if (index >= s->c)
tcc_error("too many initializers");
type = pointed_type(type);
elem_size = type_size(type, &align);
c += index * elem_size;
} else {
f = *cur_field;
/* Skip bitfield padding. Also with size 32 and 64. */
while (f && (f->v & SYM_FIRST_ANOM) &&
is_integer_btype(f->type.t & VT_BTYPE))
*cur_field = f = f->next;
if (!f)
tcc_error("too many initializers");
type = &f->type;
c += f->c;
}
}
if (!elem_size) /* for structs */
elem_size = type_size(type, &align);
/* Using designators the same element can be initialized more
than once. In that case we need to delete possibly already
existing relocations. */
if (!(flags & DIF_SIZE_ONLY) && c - corig < al) {
decl_design_delrels(p->sec, c, elem_size * nb_elems);
flags &= ~DIF_CLEAR; /* mark stack dirty too */
}
decl_initializer(p, type, c, flags & ~DIF_FIRST);
if (!(flags & DIF_SIZE_ONLY) && nb_elems > 1) {
Sym aref = {0};
CType t1;
int i;
if (p->sec || (type->t & VT_ARRAY)) {
/* make init_putv/vstore believe it were a struct */
aref.c = elem_size;
t1.t = VT_STRUCT, t1.ref = &aref;
type = &t1;
}
if (p->sec)
vpush_ref(type, p->sec, c, elem_size);
else
vset(type, VT_LOCAL|VT_LVAL, c);
for (i = 1; i < nb_elems; i++) {
vdup();
init_putv(p, type, c + elem_size * i);
}
vpop();
}
c += nb_elems * elem_size;
if (c - corig > al)
al = c - corig;
return al;
}
/* store a value or an expression directly in global data or in local array */
static void init_putv(init_params *p, CType *type, unsigned long c)
{
int bt;
void *ptr;
CType dtype;
int size, align;
Section *sec = p->sec;
uint64_t val;
dtype = *type;
dtype.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */
size = type_size(type, &align);
if (type->t & VT_BITFIELD)
size = (BIT_POS(type->t) + BIT_SIZE(type->t) + 7) / 8;
init_assert(p, c + size);
if (sec) {
/* XXX: not portable */
/* XXX: generate error if incorrect relocation */
gen_assign_cast(&dtype);
bt = type->t & VT_BTYPE;
if ((vtop->r & VT_SYM)
&& bt != VT_PTR
&& (bt != (PTR_SIZE == 8 ? VT_LLONG : VT_INT)
|| (type->t & VT_BITFIELD))
&& !((vtop->r & VT_CONST) && vtop->sym->v >= SYM_FIRST_ANOM)
)
tcc_error("initializer element is not computable at load time");
if (NODATA_WANTED) {
vtop--;
return;
}
ptr = sec->data + c;
val = vtop->c.i;
/* XXX: make code faster ? */
if ((vtop->r & (VT_SYM|VT_CONST)) == (VT_SYM|VT_CONST) &&
vtop->sym->v >= SYM_FIRST_ANOM &&
/* XXX This rejects compound literals like
'(void *){ptr}'. The problem is that '&sym' is
represented the same way, which would be ruled out
by the SYM_FIRST_ANOM check above, but also '"string"'
in 'char *p = "string"' is represented the same
with the type being VT_PTR and the symbol being an
anonymous one. That is, there's no difference in vtop
between '(void *){x}' and '&(void *){x}'. Ignore
pointer typed entities here. Hopefully no real code
will ever use compound literals with scalar type. */
(vtop->type.t & VT_BTYPE) != VT_PTR) {
/* These come from compound literals, memcpy stuff over. */
Section *ssec;
ElfSym *esym;
ElfW_Rel *rel;
esym = elfsym(vtop->sym);
ssec = tcc_state->sections[esym->st_shndx];
memmove (ptr, ssec->data + esym->st_value + (int)vtop->c.i, size);
if (ssec->reloc) {
/* We need to copy over all memory contents, and that
includes relocations. Use the fact that relocs are
created it order, so look from the end of relocs
until we hit one before the copied region. */
unsigned long relofs = ssec->reloc->data_offset;
while (relofs >= sizeof(*rel)) {
relofs -= sizeof(*rel);
rel = (ElfW_Rel*)(ssec->reloc->data + relofs);
if (rel->r_offset >= esym->st_value + size)
continue;
if (rel->r_offset < esym->st_value)
break;
put_elf_reloca(symtab_section, sec,
c + rel->r_offset - esym->st_value,
ELFW(R_TYPE)(rel->r_info),
ELFW(R_SYM)(rel->r_info),
#if PTR_SIZE == 8
rel->r_addend
#else
0
#endif
);
}
}
} else {
if (type->t & VT_BITFIELD) {
int bit_pos, bit_size, bits, n;
unsigned char *p, v, m;
bit_pos = BIT_POS(vtop->type.t);
bit_size = BIT_SIZE(vtop->type.t);
p = (unsigned char*)ptr + (bit_pos >> 3);
bit_pos &= 7, bits = 0;
while (bit_size) {
n = 8 - bit_pos;
if (n > bit_size)
n = bit_size;
v = val >> bits << bit_pos;
m = ((1 << n) - 1) << bit_pos;
*p = (*p & ~m) | (v & m);
bits += n, bit_size -= n, bit_pos = 0, ++p;
}
} else
switch(bt) {
case VT_BOOL:
*(char *)ptr = val != 0;
break;
case VT_BYTE:
*(char *)ptr = val;
break;
case VT_SHORT:
write16le(ptr, val);
break;
case VT_FLOAT:
write32le(ptr, val);
break;
case VT_DOUBLE:
write64le(ptr, val);
break;
case VT_LDOUBLE:
#if defined TCC_IS_NATIVE_387
/* Host and target platform may be different but both have x87.
On windows, tcc does not use VT_LDOUBLE, except when it is a
cross compiler. In this case a mingw gcc as host compiler
comes here with 10-byte long doubles, while msvc or tcc won't.
tcc itself can still translate by asm.
In any case we avoid possibly random bytes 11 and 12.
*/
if (sizeof (long double) >= 10)
memcpy(ptr, &vtop->c.ld, 10);
#ifdef __TINYC__
else if (sizeof (long double) == sizeof (double))
__asm__("fldl %1\nfstpt %0\n" : "=m" (*ptr) : "m" (vtop->c.ld));
#endif
else
#endif
/* For other platforms it should work natively, but may not work
for cross compilers */
if (sizeof(long double) == LDOUBLE_SIZE)
memcpy(ptr, &vtop->c.ld, LDOUBLE_SIZE);
else if (sizeof(double) == LDOUBLE_SIZE)
*(double*)ptr = (double)vtop->c.ld;
else if (0 == memcmp(ptr, &vtop->c.ld, LDOUBLE_SIZE))
; /* nothing to do for 0.0 */
#ifndef TCC_CROSS_TEST
else
tcc_error("can't cross compile long double constants");
#endif
break;
#if PTR_SIZE == 8
/* intptr_t may need a reloc too, see tcctest.c:relocation_test() */
case VT_LLONG:
case VT_PTR:
if (vtop->r & VT_SYM)
greloca(sec, vtop->sym, c, R_DATA_PTR, val);
else
write64le(ptr, val);
break;
case VT_INT:
write32le(ptr, val);
break;
#else
case VT_LLONG:
write64le(ptr, val);
break;
case VT_PTR:
case VT_INT:
if (vtop->r & VT_SYM)
greloc(sec, vtop->sym, c, R_DATA_PTR);
write32le(ptr, val);
break;
#endif
default:
//tcc_internal_error("unexpected type");
break;
}
}
vtop--;
} else {
vset(&dtype, VT_LOCAL|VT_LVAL, c);
vswap();
vstore();
vpop();
}
}
/* '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. 'flags & DIF_FIRST' is true if array '{' must be read (multi
dimension implicit array init handling). 'flags & DIF_SIZE_ONLY' is true if
size only evaluation is wanted (only for arrays). */
static void decl_initializer(init_params *p, CType *type, unsigned long c, int flags)
{
int len, n, no_oblock, i;
int size1, align1;
Sym *s, *f;
Sym indexsym;
CType *t1;
/* generate line number info */
if (debug_modes && !(flags & DIF_SIZE_ONLY) && !p->sec)
tcc_debug_line(tcc_state), tcc_tcov_check_line (tcc_state, 1);
if (!(flags & DIF_HAVE_ELEM) && tok != '{' &&
/* In case of strings we have special handling for arrays, so
don't consume them as initializer value (which would commit them
to some anonymous symbol). */
tok != TOK_LSTR && tok != TOK_STR &&
(!(flags & DIF_SIZE_ONLY)
/* a struct may be initialized from a struct of same type, as in
struct {int x,y;} a = {1,2}, b = {3,4}, c[] = {a,b};
In that case we need to parse the element in order to check
it for compatibility below */
|| (type->t & VT_BTYPE) == VT_STRUCT)
) {
int ncw_prev = nocode_wanted;
if ((flags & DIF_SIZE_ONLY) && !p->sec)
++nocode_wanted;
parse_init_elem(!p->sec ? EXPR_ANY : EXPR_CONST);
nocode_wanted = ncw_prev;
flags |= DIF_HAVE_ELEM;
}
if (type->t & VT_ARRAY) {
no_oblock = 1;
if (((flags & DIF_FIRST) && tok != TOK_LSTR && tok != TOK_STR) ||
tok == '{') {
skip('{');
no_oblock = 0;
}
s = type->ref;
n = s->c;
t1 = pointed_type(type);
size1 = type_size(t1, &align1);
/* 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)) {
len = 0;
cstr_reset(&initstr);
if (size1 != (tok == TOK_STR ? 1 : sizeof(nwchar_t)))
tcc_error("unhandled string literal merging");
while (tok == TOK_STR || tok == TOK_LSTR) {
if (initstr.size)
initstr.size -= size1;
if (tok == TOK_STR)
len += tokc.str.size;
else
len += tokc.str.size / sizeof(nwchar_t);
len--;
cstr_cat(&initstr, tokc.str.data, tokc.str.size);
next();
}
if (tok != ')' && tok != '}' && tok != ',' && tok != ';'
&& tok != TOK_EOF) {
/* Not a lone literal but part of a bigger expression. */
unget_tok(size1 == 1 ? TOK_STR : TOK_LSTR);
tokc.str.size = initstr.size;
tokc.str.data = initstr.data;
goto do_init_array;
}
decl_design_flex(p, s, len);
if (!(flags & DIF_SIZE_ONLY)) {
int nb = n, ch;
if (len < nb)
nb = len;
if (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 (p->sec && size1 == 1) {
init_assert(p, c + nb);
if (!NODATA_WANTED)
memcpy(p->sec->data + c, initstr.data, nb);
} else {
for(i=0;i<n;i++) {
if (i >= nb) {
/* only add trailing zero if enough storage (no
warning in this case since it is standard) */
if (flags & DIF_CLEAR)
break;
if (n - i >= 4) {
init_putz(p, c + i * size1, (n - i) * size1);
break;
}
ch = 0;
} else if (size1 == 1)
ch = ((unsigned char *)initstr.data)[i];
else
ch = ((nwchar_t *)initstr.data)[i];
vpushi(ch);
init_putv(p, t1, c + i * size1);
}
}
}
} else {
do_init_array:
indexsym.c = 0;
f = &indexsym;
do_init_list:
/* zero memory once in advance */
if (!(flags & (DIF_CLEAR | DIF_SIZE_ONLY))) {
init_putz(p, c, n*size1);
flags |= DIF_CLEAR;
}
len = 0;
/* GNU extension: if the initializer is empty for a flex array,
it's size is zero. We won't enter the loop, so set the size
now. */
decl_design_flex(p, s, len);
while (tok != '}' || (flags & DIF_HAVE_ELEM)) {
len = decl_designator(p, type, c, &f, flags, len);
flags &= ~DIF_HAVE_ELEM;
if (type->t & VT_ARRAY) {
++indexsym.c;
/* special test for multi dimensional arrays (may not
be strictly correct if designators are used at the
same time) */
if (no_oblock && len >= n*size1)
break;
} else {
if (s->type.t == VT_UNION)
f = NULL;
else
f = f->next;
if (no_oblock && f == NULL)
break;
}
if (tok == '}')
break;
skip(',');
}
}
if (!no_oblock)
skip('}');
} else if ((flags & DIF_HAVE_ELEM)
/* Use i_c_parameter_t, to strip toplevel qualifiers.
The source type might have VT_CONSTANT set, which is
of course assignable to non-const elements. */
&& is_compatible_unqualified_types(type, &vtop->type)) {
goto one_elem;
} else if ((type->t & VT_BTYPE) == VT_STRUCT) {
no_oblock = 1;
if ((flags & DIF_FIRST) || tok == '{') {
skip('{');
no_oblock = 0;
}
s = type->ref;
f = s->next;
n = s->c;
size1 = 1;
goto do_init_list;
} else if (tok == '{') {
if (flags & DIF_HAVE_ELEM)
skip(';');
next();
decl_initializer(p, type, c, flags & ~DIF_HAVE_ELEM);
skip('}');
} else one_elem: if ((flags & DIF_SIZE_ONLY)) {
/* If we supported only ISO C we wouldn't have to accept calling
this on anything than an array if DIF_SIZE_ONLY (and even then
only on the outermost level, so no recursion would be needed),
because initializing a flex array member isn't supported.
But GNU C supports it, so we need to recurse even into
subfields of structs and arrays when DIF_SIZE_ONLY is set. */
/* just skip expression */
if (flags & DIF_HAVE_ELEM)
vpop();
else
skip_or_save_block(NULL);
} else {
if (!(flags & DIF_HAVE_ELEM)) {
/* This should happen only when we haven't parsed
the init element above for fear of committing a
string constant to memory too early. */
if (tok != TOK_STR && tok != TOK_LSTR)
expect("string constant");
parse_init_elem(!p->sec ? EXPR_ANY : EXPR_CONST);
}
if (!p->sec && (flags & DIF_CLEAR) /* container was already zero'd */
&& (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST
&& vtop->c.i == 0
&& btype_size(type->t & VT_BTYPE) /* not for fp constants */
)
vpop();
else
init_putv(p, type, c);
}
}
/* 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 global)
{
int size, align, addr;
TokenString *init_str = NULL;
Section *sec;
Sym *flexible_array;
Sym *sym;
int saved_nocode_wanted = nocode_wanted;
#ifdef CONFIG_TCC_BCHECK
int bcheck = tcc_state->do_bounds_check && !NODATA_WANTED;
#endif
init_params p = {0};
/* Always allocate static or global variables */
if (v && (r & VT_VALMASK) == VT_CONST)
nocode_wanted |= DATA_ONLY_WANTED;
flexible_array = NULL;
size = type_size(type, &align);
/* exactly one flexible array may be initialized, either the
toplevel array or the last member of the toplevel struct */
if (size < 0) {
// error out except for top-level incomplete arrays
// (arrays of incomplete types are handled in array parsing)
if (!(type->t & VT_ARRAY))
tcc_error("initialization of incomplete type");
/* If the base type itself was an array type of unspecified size
(like in 'typedef int arr[]; arr x = {1};') then we will
overwrite the unknown size by the real one for this decl.
We need to unshare the ref symbol holding that size. */
type->ref = sym_push(SYM_FIELD, &type->ref->type, 0, type->ref->c);
p.flex_array_ref = type->ref;
} else if (has_init && (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;
p.flex_array_ref = field->type.ref;
size = -1;
}
}
}
if (size < 0) {
/* If unknown size, do a dry-run 1st pass */
if (!has_init)
tcc_error("unknown type size");
if (has_init == 2) {
/* only get strings */
init_str = tok_str_alloc();
while (tok == TOK_STR || tok == TOK_LSTR) {
tok_str_add_tok(init_str);
next();
}
tok_str_add(init_str, TOK_EOF);
} else
skip_or_save_block(&init_str);
unget_tok(0);
/* compute size */
begin_macro(init_str, 1);
next();
decl_initializer(&p, type, 0, DIF_FIRST | DIF_SIZE_ONLY);
/* 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) {
int speca = 1 << (ad->a.aligned - 1);
if (speca > align)
align = speca;
} else if (ad->a.packed) {
align = 1;
}
if (!v && NODATA_WANTED)
size = 0, align = 1;
if ((r & VT_VALMASK) == VT_LOCAL) {
sec = NULL;
#ifdef CONFIG_TCC_BCHECK
if (bcheck && v) {
/* add padding between stack variables for bound checking */
loc -= align;
}
#endif
loc = (loc - size) & -align;
addr = loc;
p.local_offset = addr + size;
#ifdef CONFIG_TCC_BCHECK
if (bcheck && v) {
/* add padding between stack variables for bound checking */
loc -= align;
}
#endif
if (v) {
/* local variable */
#ifdef CONFIG_TCC_ASM
if (ad->asm_label) {
int reg = asm_parse_regvar(ad->asm_label);
if (reg >= 0)
r = (r & ~VT_VALMASK) | reg;
}
#endif
sym = sym_push(v, type, r, addr);
if (ad->cleanup_func) {
Sym *cls = sym_push2(&all_cleanups,
SYM_FIELD | ++cur_scope->cl.n, 0, 0);
cls->prev_tok = sym;
cls->next = ad->cleanup_func;
cls->ncl = cur_scope->cl.s;
cur_scope->cl.s = cls;
}
sym->a = ad->a;
} else {
/* push local reference */
vset(type, r, addr);
}
} else {
sym = NULL;
if (v && global) {
/* see if the symbol was already defined */
sym = sym_find(v);
if (sym) {
if (p.flex_array_ref && (sym->type.t & type->t & VT_ARRAY)
&& sym->type.ref->c > type->ref->c) {
/* flex array was already declared with explicit size
extern int arr[10];
int arr[] = { 1,2,3 }; */
type->ref->c = sym->type.ref->c;
size = type_size(type, &align);
}
patch_storage(sym, ad, type);
/* we accept several definitions of the same global variable. */
if (!has_init && sym->c && elfsym(sym)->st_shndx != SHN_UNDEF)
goto no_alloc;
}
}
/* allocate symbol in corresponding section */
sec = ad->section;
if (!sec) {
CType *tp = type;
while ((tp->t & (VT_BTYPE|VT_ARRAY)) == (VT_PTR|VT_ARRAY))
tp = &tp->ref->type;
if (tp->t & VT_CONSTANT) {
sec = rodata_section;
} else if (has_init) {
sec = data_section;
/*if (tcc_state->g_debug & 4)
tcc_warning("rw data: %s", get_tok_str(v, 0));*/
} else if (tcc_state->nocommon)
sec = bss_section;
}
if (sec) {
addr = section_add(sec, size, align);
#ifdef CONFIG_TCC_BCHECK
/* add padding if bound check */
if (bcheck)
section_add(sec, 1, 1);
#endif
} else {
addr = align; /* SHN_COMMON is special, symbol value is align */
sec = common_section;
}
if (v) {
if (!sym) {
sym = sym_push(v, type, r | VT_SYM, 0);
patch_storage(sym, ad, NULL);
}
/* update symbol definition */
put_extern_sym(sym, sec, addr, size);
} else {
/* push global reference */
vpush_ref(type, sec, addr, size);
sym = vtop->sym;
vtop->r |= r;
}
#ifdef CONFIG_TCC_BCHECK
/* handles bounds now because the symbol must be defined
before for the relocation */
if (bcheck) {
addr_t *bounds_ptr;
greloca(bounds_section, sym, bounds_section->data_offset, R_DATA_PTR, 0);
/* 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 (type->t & VT_VLA) {
int a;
if (NODATA_WANTED)
goto no_alloc;
/* save before-VLA stack pointer if needed */
if (cur_scope->vla.num == 0) {
if (cur_scope->prev && cur_scope->prev->vla.num) {
cur_scope->vla.locorig = cur_scope->prev->vla.loc;
} else {
gen_vla_sp_save(loc -= PTR_SIZE);
cur_scope->vla.locorig = loc;
}
}
vpush_type_size(type, &a);
gen_vla_alloc(type, a);
#if defined TCC_TARGET_PE && defined TCC_TARGET_X86_64
/* on _WIN64, because of the function args scratch area, the
result of alloca differs from RSP and is returned in RAX. */
gen_vla_result(addr), addr = (loc -= PTR_SIZE);
#endif
gen_vla_sp_save(addr);
cur_scope->vla.loc = addr;
cur_scope->vla.num++;
} else if (has_init) {
p.sec = sec;
decl_initializer(&p, type, addr, DIF_FIRST);
/* patch flexible array member size back to -1, */
/* for possible subsequent similar declarations */
if (flexible_array)
flexible_array->type.ref->c = -1;
}
no_alloc:
/* restore parse state if needed */
if (init_str) {
end_macro();
next();
}
nocode_wanted = saved_nocode_wanted;
}
/* generate vla code saved in post_type() */
static void func_vla_arg_code(Sym *arg)
{
int align;
TokenString *vla_array_tok = NULL;
if (arg->type.ref)
func_vla_arg_code(arg->type.ref);
if ((arg->type.t & VT_VLA) && arg->type.ref->vla_array_str) {
loc -= type_size(&int_type, &align);
loc &= -align;
arg->type.ref->c = loc;
unget_tok(0);
vla_array_tok = tok_str_alloc();
vla_array_tok->str = arg->type.ref->vla_array_str;
begin_macro(vla_array_tok, 1);
next();
gexpr();
end_macro();
next();
vpush_type_size(&arg->type.ref->type, &align);
gen_op('*');
vset(&int_type, VT_LOCAL|VT_LVAL, arg->type.ref->c);
vswap();
vstore();
vpop();
}
}
static void func_vla_arg(Sym *sym)
{
Sym *arg;
for (arg = sym->type.ref->next; arg; arg = arg->next)
if ((arg->type.t & VT_BTYPE) == VT_PTR && (arg->type.ref->type.t & VT_VLA))
func_vla_arg_code(arg->type.ref);
}
/* parse a function defined by symbol 'sym' and generate its code in
'cur_text_section' */
static void gen_function(Sym *sym)
{
struct scope f = { 0 };
cur_scope = root_scope = &f;
nocode_wanted = 0;
ind = cur_text_section->data_offset;
if (sym->a.aligned) {
size_t newoff = section_add(cur_text_section, 0,
1 << (sym->a.aligned - 1));
gen_fill_nops(newoff - ind);
}
funcname = get_tok_str(sym->v, NULL);
func_ind = ind;
func_vt = sym->type.ref->type;
func_var = sym->type.ref->f.func_type == FUNC_ELLIPSIS;
/* NOTE: we patch the symbol size later */
put_extern_sym(sym, cur_text_section, ind, 0);
if (sym->type.ref->f.func_ctor)
add_array (tcc_state, ".init_array", sym->c);
if (sym->type.ref->f.func_dtor)
add_array (tcc_state, ".fini_array", sym->c);
/* put debug symbol */
tcc_debug_funcstart(tcc_state, sym);
/* push a dummy symbol to enable local sym storage */
sym_push2(&local_stack, SYM_FIELD, 0, 0);
local_scope = 1; /* for function parameters */
gfunc_prolog(sym);
tcc_debug_prolog_epilog(tcc_state, 0);
local_scope = 0;
rsym = 0;
clear_temp_local_var_list();
func_vla_arg(sym);
block(0);
gsym(rsym);
nocode_wanted = 0;
/* reset local stack */
pop_local_syms(NULL, 0);
tcc_debug_prolog_epilog(tcc_state, 1);
gfunc_epilog();
/* end of function */
tcc_debug_funcend(tcc_state, ind - func_ind);
/* patch symbol size */
elfsym(sym)->st_size = ind - func_ind;
cur_text_section->data_offset = ind;
local_scope = 0;
label_pop(&global_label_stack, NULL, 0);
sym_pop(&all_cleanups, NULL, 0);
/* 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 */
func_ind = -1;
nocode_wanted = DATA_ONLY_WANTED;
check_vstack();
/* do this after funcend debug info */
next();
}
static void gen_inline_functions(TCCState *s)
{
Sym *sym;
int inline_generated, i;
struct InlineFunc *fn;
tcc_open_bf(s, ":inline:", 0);
/* iterate while inline function are referenced */
do {
inline_generated = 0;
for (i = 0; i < s->nb_inline_fns; ++i) {
fn = s->inline_fns[i];
sym = fn->sym;
if (sym && (sym->c || !(sym->type.t & VT_INLINE))) {
/* the function was used or forced (and then not internal):
generate its code and convert it to a normal function */
fn->sym = NULL;
tcc_debug_putfile(s, fn->filename);
begin_macro(fn->func_str, 1);
next();
cur_text_section = text_section;
gen_function(sym);
end_macro();
inline_generated = 1;
}
}
} while (inline_generated);
tcc_close();
}
static void free_inline_functions(TCCState *s)
{
int i;
/* free tokens of unused inline functions */
for (i = 0; i < s->nb_inline_fns; ++i) {
struct InlineFunc *fn = s->inline_fns[i];
if (fn->sym)
tok_str_free(fn->func_str);
}
dynarray_reset(&s->inline_fns, &s->nb_inline_fns);
}
static void do_Static_assert(void)
{
int c;
const char *msg;
next();
skip('(');
c = expr_const();
msg = "_Static_assert fail";
if (tok == ',') {
next();
msg = parse_mult_str("string constant")->data;
}
skip(')');
if (c == 0)
tcc_error("%s", msg);
skip(';');
}
/* 'l' is VT_LOCAL or VT_CONST to define default storage type
or VT_CMP if parsing old style parameter list
or VT_JMP if parsing c99 for decl: for (int i = 0, ...) */
static int decl(int l)
{
int v, has_init, r, oldint;
CType type, btype;
Sym *sym;
AttributeDef ad, adbase;
while (1) {
oldint = 0;
if (!parse_btype(&btype, &adbase, l == VT_LOCAL)) {
if (l == VT_JMP)
return 0;
/* skip redundant ';' if not in old parameter decl scope */
if (tok == ';' && l != VT_CMP) {
next();
continue;
}
if (tok == TOK_STATIC_ASSERT) {
do_Static_assert();
continue;
}
if (l != VT_CONST)
break;
if (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3) {
/* global asm block */
asm_global_instr();
continue;
}
if (tok >= TOK_UIDENT) {
/* special test for old K&R protos without explicit int
type. Only accepted when defining global data */
btype.t = VT_INT;
oldint = 1;
} else {
if (tok != TOK_EOF)
expect("declaration");
break;
}
}
if (tok == ';') {
if ((btype.t & VT_BTYPE) == VT_STRUCT) {
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;
}
if (IS_ENUM(btype.t)) {
next();
continue;
}
}
while (1) { /* iterate thru each declaration */
type = btype;
ad = adbase;
type_decl(&type, &ad, &v, TYPE_DIRECT);
#if 0
{
char buf[500];
type_to_str(buf, sizeof(buf), &type, 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_CONST))
tcc_error("function without file scope cannot be static");
/* if old style function prototype, we accept a
declaration list */
sym = type.ref;
if (sym->f.func_type == FUNC_OLD && l == VT_CONST) {
func_vt = type;
decl(VT_CMP);
}
#if defined TCC_TARGET_MACHO || defined TARGETOS_ANDROID
if (sym->f.func_alwinl
&& ((type.t & (VT_EXTERN | VT_INLINE))
== (VT_EXTERN | VT_INLINE))) {
/* always_inline functions must be handled as if they
don't generate multiple global defs, even if extern
inline, i.e. GNU inline semantics for those. Rewrite
them into static inline. */
type.t &= ~VT_EXTERN;
type.t |= VT_STATIC;
}
#endif
/* always compile 'extern inline' */
if (type.t & VT_EXTERN)
type.t &= ~VT_INLINE;
} else if (oldint) {
tcc_warning("type defaults to int");
}
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 0
/* gcc does not allow __asm__("label") with function definition,
but why not ... */
if (tok == '{')
expect(";");
#endif
}
#ifdef TCC_TARGET_PE
if (ad.a.dllimport || ad.a.dllexport) {
if (type.t & VT_STATIC)
tcc_error("cannot have dll linkage with static");
if (type.t & VT_TYPEDEF) {
tcc_warning("'%s' attribute ignored for typedef",
ad.a.dllimport ? (ad.a.dllimport = 0, "dllimport") :
(ad.a.dllexport = 0, "dllexport"));
} else if (ad.a.dllimport) {
if ((type.t & VT_BTYPE) == VT_FUNC)
ad.a.dllimport = 0;
else
type.t |= VT_EXTERN;
}
}
#endif
if (tok == '{') {
if (l != VT_CONST)
tcc_error("cannot use local functions");
if ((type.t & VT_BTYPE) != VT_FUNC)
expect("function definition");
/* reject abstract declarators in function definition
make old style params without decl have int type */
sym = type.ref;
while ((sym = sym->next) != NULL) {
if (!(sym->v & ~SYM_FIELD))
expect("identifier");
if (sym->type.t == VT_VOID)
sym->type = int_type;
}
/* apply post-declaraton attributes */
merge_funcattr(&type.ref->f, &ad.f);
/* put function symbol */
type.t &= ~VT_EXTERN;
sym = external_sym(v, &type, 0, &ad);
/* 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 (sym->type.t & VT_INLINE) {
struct InlineFunc *fn;
fn = tcc_malloc(sizeof *fn + strlen(file->filename));
strcpy(fn->filename, file->filename);
fn->sym = sym;
dynarray_add(&tcc_state->inline_fns,
&tcc_state->nb_inline_fns, fn);
skip_or_save_block(&fn->func_str);
} else {
/* compute text section */
cur_text_section = ad.section;
if (!cur_text_section)
cur_text_section = text_section;
gen_function(sym);
}
break;
} else {
if (l == VT_CMP) {
/* find parameter in function parameter list */
for (sym = func_vt.ref->next; sym; sym = sym->next)
if ((sym->v & ~SYM_FIELD) == v)
goto found;
tcc_error("declaration for parameter '%s' but no such parameter",
get_tok_str(v, NULL));
found:
if (type.t & VT_STORAGE) /* 'register' is okay */
tcc_error("storage class specified for '%s'",
get_tok_str(v, NULL));
if (sym->type.t != VT_VOID)
tcc_error("redefinition of parameter '%s'",
get_tok_str(v, NULL));
convert_parameter_type(&type);
sym->type = type;
} else if (type.t & VT_TYPEDEF) {
/* save typedefed type */
/* XXX: test storage specifiers ? */
sym = sym_find(v);
if (sym && sym->sym_scope == local_scope) {
if (!is_compatible_types(&sym->type, &type)
|| !(sym->type.t & VT_TYPEDEF))
tcc_error("incompatible redefinition of '%s'",
get_tok_str(v, NULL));
sym->type = type;
} else {
sym = sym_push(v, &type, 0, 0);
}
sym->a = ad.a;
if ((type.t & VT_BTYPE) == VT_FUNC)
merge_funcattr(&sym->type.ref->f, &ad.f);
if (debug_modes)
tcc_debug_typedef (tcc_state, sym);
} else if ((type.t & VT_BTYPE) == VT_VOID
&& !(type.t & VT_EXTERN)) {
tcc_error("declaration of void object");
} else {
r = 0;
if ((type.t & VT_BTYPE) == VT_FUNC) {
/* external function definition */
/* specific case for func_call attribute */
merge_funcattr(&type.ref->f, &ad.f);
} else if (!(type.t & VT_ARRAY)) {
/* not lvalue if array */
r |= VT_LVAL;
}
has_init = (tok == '=');
if (has_init && (type.t & VT_VLA))
tcc_error("variable length array cannot be initialized");
if (((type.t & VT_EXTERN) && (!has_init || l != VT_CONST))
|| (type.t & VT_BTYPE) == VT_FUNC
/* as with GCC, uninitialized global arrays with no size
are considered extern: */
|| ((type.t & VT_ARRAY) && !has_init
&& l == VT_CONST && type.ref->c < 0)
) {
/* external variable or function */
type.t |= VT_EXTERN;
sym = external_sym(v, &type, r, &ad);
} else {
if (l == VT_CONST || (type.t & VT_STATIC))
r |= VT_CONST;
else
r |= VT_LOCAL;
if (has_init)
next();
else if (l == VT_CONST)
/* uninitialized global variables may be overridden */
type.t |= VT_EXTERN;
decl_initializer_alloc(&type, &ad, r, has_init, v, l == VT_CONST);
}
if (ad.alias_target && l == VT_CONST) {
/* Aliases need to be emitted when their target symbol
is emitted, even if perhaps unreferenced.
We only support the case where the base is already
defined, otherwise we would need deferring to emit
the aliases until the end of the compile unit. */
Sym *alias_target = sym_find(ad.alias_target);
ElfSym *esym = elfsym(alias_target);
if (!esym)
tcc_error("unsupported forward __alias__ attribute");
put_extern_sym2(sym_find(v), esym->st_shndx,
esym->st_value, esym->st_size, 1);
}
}
if (tok != ',') {
if (l == VT_JMP)
return 1;
skip(';');
break;
}
next();
}
}
}
return 0;
}
/* ------------------------------------------------------------------------- */
#undef gjmp_addr
#undef gjmp
/* ------------------------------------------------------------------------- */
View Git Blame Copy Permalink