mirror of
https://github.com/frida/tinycc
synced 2024-11-27 10:09:42 +03:00
8b69059f66
- tcc.h: msvc doesn't grok __func__ (reverts previous commit)
- tccgen.c: fortify tcc against bogus code:
- n[sizeof({3;})]; // statement expression outside of function
- f(){"123"4}; // tokens with values following each other
(also, add "type defaults to int" warning for variables)
- tccpe.c: removed a check that caused BSS symbols not to be
exported. Whatever that check was meant to prevent.
- win32/build-tcc.bat: cmd.exe sometimes doesn't grok '-' in labels
- Revert "libtcc: no need to undef"
This reverts commit 2b7aa2a1e1.
- Revert "tcc.h libtcc.c: remove unused defines"
This reverts commit 985d963745.
The point of these "unused defines" is to be unused, that is
to remind people not to use malloc but please to "use_tcc_malloc",
instead.
8584 lines
249 KiB
C
8584 lines
249 KiB
C
/*
|
|
* 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;
|
|
static int in_sizeof;
|
|
static int in_generic;
|
|
static int section_sym;
|
|
|
|
ST_DATA SValue *vtop;
|
|
static SValue _vstack[1 + VSTACK_SIZE];
|
|
#define vstack (_vstack + 1)
|
|
|
|
ST_DATA int const_wanted; /* true if constant wanted */
|
|
ST_DATA int nocode_wanted; /* no code generation wanted */
|
|
#define unevalmask 0xffff /* unevaluated subexpression */
|
|
#define NODATA_WANTED (nocode_wanted > 0) /* no static data output wanted either */
|
|
#define STATIC_DATA_WANTED (nocode_wanted & 0xC0000000) /* only static data output */
|
|
|
|
/* Automagical code suppression ----> */
|
|
#define CODE_OFF() (nocode_wanted |= 0x20000000)
|
|
#define CODE_ON() (nocode_wanted &= ~0x20000000)
|
|
|
|
/* Clear 'nocode_wanted' at label if it was used */
|
|
ST_FUNC void gsym(int t) { if (t) { gsym_addr(t, ind); CODE_ON(); }}
|
|
static int gind(void) { CODE_ON(); return ind; }
|
|
|
|
/* Set 'nocode_wanted' after unconditional jumps */
|
|
static void gjmp_addr_acs(int t) { gjmp_addr(t); CODE_OFF(); }
|
|
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_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;
|
|
static int last_line_num, new_file, func_ind; /* debug info control */
|
|
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
|
|
|
|
ST_DATA 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 *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. */
|
|
ST_DATA 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];
|
|
short nb_temp_local_vars;
|
|
|
|
static struct scope {
|
|
struct scope *prev;
|
|
struct { int loc, 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;
|
|
|
|
/********************************************************/
|
|
/* stab debug support */
|
|
|
|
static const struct {
|
|
int type;
|
|
const char *name;
|
|
} default_debug[] = {
|
|
{ VT_INT, "int:t1=r1;-2147483648;2147483647;" },
|
|
{ VT_BYTE, "char:t2=r2;0;127;" },
|
|
#if LONG_SIZE == 4
|
|
{ VT_LONG | VT_INT, "long int:t3=r3;-2147483648;2147483647;" },
|
|
#else
|
|
{ VT_LLONG | VT_LONG, "long int:t3=r3;-9223372036854775808;9223372036854775807;" },
|
|
#endif
|
|
{ VT_INT | VT_UNSIGNED, "unsigned int:t4=r4;0;037777777777;" },
|
|
#if LONG_SIZE == 4
|
|
{ VT_LONG | VT_INT | VT_UNSIGNED, "long unsigned int:t5=r5;0;037777777777;" },
|
|
#else
|
|
/* use octal instead of -1 so size_t works (-gstabs+ in gcc) */
|
|
{ VT_LLONG | VT_LONG | VT_UNSIGNED, "long unsigned int:t5=r5;0;01777777777777777777777;" },
|
|
#endif
|
|
{ VT_QLONG, "__int128:t6=r6;0;-1;" },
|
|
{ VT_QLONG | VT_UNSIGNED, "__int128 unsigned:t7=r7;0;-1;" },
|
|
{ VT_LLONG, "long long int:t8=r8;-9223372036854775808;9223372036854775807;" },
|
|
{ VT_LLONG | VT_UNSIGNED, "long long unsigned int:t9=r9;0;01777777777777777777777;" },
|
|
{ VT_SHORT, "short int:t10=r10;-32768;32767;" },
|
|
{ VT_SHORT | VT_UNSIGNED, "short unsigned int:t11=r11;0;65535;" },
|
|
{ VT_BYTE | VT_DEFSIGN, "signed char:t12=r12;-128;127;" },
|
|
{ VT_BYTE | VT_DEFSIGN | VT_UNSIGNED, "unsigned char:t13=r13;0;255;" },
|
|
{ VT_FLOAT, "float:t14=r1;4;0;" },
|
|
{ VT_DOUBLE, "double:t15=r1;8;0;" },
|
|
{ VT_LDOUBLE, "long double:t16=r1;16;0;" },
|
|
{ -1, "_Float32:t17=r1;4;0;" },
|
|
{ -1, "_Float64:t18=r1;8;0;" },
|
|
{ -1, "_Float128:t19=r1;16;0;" },
|
|
{ -1, "_Float32x:t20=r1;8;0;" },
|
|
{ -1, "_Float64x:t21=r1;16;0;" },
|
|
{ -1, "_Decimal32:t22=r1;4;0;" },
|
|
{ -1, "_Decimal64:t23=r1;8;0;" },
|
|
{ -1, "_Decimal128:t24=r1;16;0;" },
|
|
/* if default char is unsigned */
|
|
{ VT_BYTE | VT_UNSIGNED, "unsigned char:t25=r25;0;255;" },
|
|
/* boolean type */
|
|
{ VT_BOOL, "bool:t26=r26;0;255;" },
|
|
{ VT_VOID, "void:t27=27" },
|
|
};
|
|
|
|
static int debug_next_type;
|
|
|
|
static struct debug_hash {
|
|
int debug_type;
|
|
Sym *type;
|
|
} *debug_hash;
|
|
|
|
static int n_debug_hash;
|
|
|
|
static struct debug_info {
|
|
int start;
|
|
int end;
|
|
int n_sym;
|
|
struct debug_sym {
|
|
int type;
|
|
unsigned long value;
|
|
char *str;
|
|
Section *sec;
|
|
int sym_index;
|
|
} *sym;
|
|
struct debug_info *child, *next, *last, *parent;
|
|
} *debug_info, *debug_info_root;
|
|
|
|
/********************************************************/
|
|
#if 1
|
|
#define precedence_parser
|
|
static void init_prec(void);
|
|
#endif
|
|
/********************************************************/
|
|
#ifndef CONFIG_TCC_ASM
|
|
ST_FUNC void asm_instr(void)
|
|
{
|
|
tcc_error("inline asm() not supported");
|
|
}
|
|
ST_FUNC void asm_global_instr(void)
|
|
{
|
|
tcc_error("inline asm() not supported");
|
|
}
|
|
#endif
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
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);
|
|
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 block(int is_expr);
|
|
static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, int has_init, int v, int scope);
|
|
static void decl(int l);
|
|
static int decl0(int l, int is_for_loop_init, Sym *);
|
|
static void expr_eq(void);
|
|
static void vla_runtime_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);
|
|
|
|
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
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* start of translation unit info */
|
|
ST_FUNC void tcc_debug_start(TCCState *s1)
|
|
{
|
|
if (s1->do_debug) {
|
|
int i;
|
|
char buf[512];
|
|
|
|
/* file info: full path + filename */
|
|
section_sym = put_elf_sym(symtab_section, 0, 0,
|
|
ELFW(ST_INFO)(STB_LOCAL, STT_SECTION), 0,
|
|
text_section->sh_num, NULL);
|
|
getcwd(buf, sizeof(buf));
|
|
#ifdef _WIN32
|
|
normalize_slashes(buf);
|
|
#endif
|
|
pstrcat(buf, sizeof(buf), "/");
|
|
put_stabs_r(s1, buf, N_SO, 0, 0,
|
|
text_section->data_offset, text_section, section_sym);
|
|
put_stabs_r(s1, file->prev ? file->prev->filename : file->filename,
|
|
N_SO, 0, 0,
|
|
text_section->data_offset, text_section, section_sym);
|
|
for (i = 0; i < sizeof (default_debug) / sizeof (default_debug[0]); i++)
|
|
put_stabs(s1, default_debug[i].name, N_LSYM, 0, 0, 0);
|
|
|
|
new_file = last_line_num = 0;
|
|
func_ind = -1;
|
|
debug_next_type = sizeof(default_debug) / sizeof(default_debug[0]);
|
|
debug_hash = NULL;
|
|
n_debug_hash = 0;
|
|
|
|
/* we're currently 'including' the <command line> */
|
|
tcc_debug_bincl(s1);
|
|
}
|
|
|
|
/* an elf symbol of type STT_FILE must be put so that STB_LOCAL
|
|
symbols can be safely used */
|
|
put_elf_sym(symtab_section, 0, 0,
|
|
ELFW(ST_INFO)(STB_LOCAL, STT_FILE), 0,
|
|
SHN_ABS, file->filename);
|
|
}
|
|
|
|
static void tcc_debug_stabs (TCCState *s1, const char *str, int type, unsigned long value,
|
|
Section *sec, int sym_index)
|
|
{
|
|
struct debug_sym *s;
|
|
|
|
if (debug_info) {
|
|
debug_info->sym =
|
|
(struct debug_sym *)tcc_realloc (debug_info->sym,
|
|
sizeof(struct debug_sym) *
|
|
(debug_info->n_sym + 1));
|
|
s = debug_info->sym + debug_info->n_sym++;
|
|
s->type = type;
|
|
s->value = value;
|
|
s->str = tcc_strdup(str);
|
|
s->sec = sec;
|
|
s->sym_index = sym_index;
|
|
}
|
|
else if (sec)
|
|
put_stabs_r (s1, str, type, 0, 0, value, sec, sym_index);
|
|
else
|
|
put_stabs (s1, str, type, 0, 0, value);
|
|
}
|
|
|
|
static void tcc_debug_stabn(int type, int value)
|
|
{
|
|
if (type == N_LBRAC) {
|
|
struct debug_info *info =
|
|
(struct debug_info *) tcc_mallocz(sizeof (*info));
|
|
|
|
info->start = value;
|
|
info->parent = debug_info;
|
|
if (debug_info) {
|
|
if (debug_info->child) {
|
|
if (debug_info->child->last)
|
|
debug_info->child->last->next = info;
|
|
else
|
|
debug_info->child->next = info;
|
|
debug_info->child->last = info;
|
|
}
|
|
else
|
|
debug_info->child = info;
|
|
}
|
|
else
|
|
debug_info_root = info;
|
|
debug_info = info;
|
|
}
|
|
else {
|
|
debug_info->end = value;
|
|
debug_info = debug_info->parent;
|
|
}
|
|
}
|
|
|
|
static void tcc_get_debug_info(TCCState *s1, Sym *s, CString *result)
|
|
{
|
|
int type;
|
|
int n = 0;
|
|
int debug_type = -1;
|
|
Sym *t = s;
|
|
CString str;
|
|
|
|
for (;;) {
|
|
type = t->type.t & ~(VT_STORAGE | VT_CONSTANT | VT_VOLATILE);
|
|
if ((type & VT_BTYPE) != VT_BYTE)
|
|
type &= ~VT_DEFSIGN;
|
|
if (type == VT_PTR || type == (VT_PTR | VT_ARRAY))
|
|
n++, t = t->type.ref;
|
|
else
|
|
break;
|
|
}
|
|
if ((type & VT_BTYPE) == VT_STRUCT) {
|
|
int i;
|
|
|
|
t = t->type.ref;
|
|
for (i = 0; i < n_debug_hash; i++) {
|
|
if (t == debug_hash[i].type) {
|
|
debug_type = debug_hash[i].debug_type;
|
|
break;
|
|
}
|
|
}
|
|
if (debug_type == -1) {
|
|
debug_type = ++debug_next_type;
|
|
debug_hash = (struct debug_hash *)
|
|
tcc_realloc (debug_hash,
|
|
(n_debug_hash + 1) * sizeof(*debug_hash));
|
|
debug_hash[n_debug_hash].debug_type = debug_type;
|
|
debug_hash[n_debug_hash++].type = t;
|
|
cstr_new (&str);
|
|
cstr_printf (&str, "%s:T%d=%c%d",
|
|
(t->v & ~SYM_STRUCT) >= SYM_FIRST_ANOM
|
|
? "" : get_tok_str(t->v & ~SYM_STRUCT, NULL),
|
|
debug_type,
|
|
IS_UNION (t->type.t) ? 'u' : 's',
|
|
t->c);
|
|
while (t->next) {
|
|
int pos, size, align;
|
|
|
|
t = t->next;
|
|
cstr_printf (&str, "%s:",
|
|
(t->v & ~SYM_FIELD) >= SYM_FIRST_ANOM
|
|
? "" : get_tok_str(t->v & ~SYM_FIELD, NULL));
|
|
tcc_get_debug_info (s1, t, &str);
|
|
if (t->type.t & VT_BITFIELD) {
|
|
pos = t->c * 8 + BIT_POS(t->type.t);
|
|
size = BIT_SIZE(t->type.t);
|
|
}
|
|
else {
|
|
pos = t->c * 8;
|
|
size = type_size(&t->type, &align) * 8;
|
|
}
|
|
cstr_printf (&str, ",%d,%d;", pos, size);
|
|
}
|
|
cstr_printf (&str, ";");
|
|
tcc_debug_stabs(s1, str.data, N_LSYM, 0, NULL, 0);
|
|
cstr_free (&str);
|
|
}
|
|
}
|
|
else if (IS_ENUM(type)) {
|
|
Sym *e = t = t->type.ref;
|
|
|
|
debug_type = ++debug_next_type;
|
|
cstr_new (&str);
|
|
cstr_printf (&str, "%s:T%d=e",
|
|
(t->v & ~SYM_STRUCT) >= SYM_FIRST_ANOM
|
|
? "" : get_tok_str(t->v & ~SYM_STRUCT, NULL),
|
|
debug_type);
|
|
while (t->next) {
|
|
t = t->next;
|
|
cstr_printf (&str, "%s:",
|
|
(t->v & ~SYM_FIELD) >= SYM_FIRST_ANOM
|
|
? "" : get_tok_str(t->v & ~SYM_FIELD, NULL));
|
|
cstr_printf (&str, e->type.t & VT_UNSIGNED ? "%u," : "%d,",
|
|
(int)t->enum_val);
|
|
}
|
|
cstr_printf (&str, ";");
|
|
tcc_debug_stabs(s1, str.data, N_LSYM, 0, NULL, 0);
|
|
cstr_free (&str);
|
|
}
|
|
else if ((type & VT_BTYPE) != VT_FUNC) {
|
|
type &= ~VT_STRUCT_MASK;
|
|
for (debug_type = 1;
|
|
debug_type <= sizeof(default_debug) / sizeof(default_debug[0]);
|
|
debug_type++)
|
|
if (default_debug[debug_type - 1].type == type)
|
|
break;
|
|
if (debug_type > sizeof(default_debug) / sizeof(default_debug[0]))
|
|
return;
|
|
}
|
|
if (n > 0)
|
|
cstr_printf (result, "%d=", ++debug_next_type);
|
|
t = s;
|
|
for (;;) {
|
|
type = t->type.t & ~(VT_STORAGE | VT_CONSTANT | VT_VOLATILE);
|
|
if ((type & VT_BTYPE) != VT_BYTE)
|
|
type &= ~VT_DEFSIGN;
|
|
if (type == VT_PTR)
|
|
cstr_printf (result, "%d=*", ++debug_next_type);
|
|
else if (type == (VT_PTR | VT_ARRAY))
|
|
cstr_printf (result, "%d=ar1;0;%d;",
|
|
++debug_next_type, t->type.ref->c - 1);
|
|
else if (type == VT_FUNC) {
|
|
cstr_printf (result, "%d=f", ++debug_next_type);
|
|
tcc_get_debug_info (s1, t->type.ref, result);
|
|
return;
|
|
}
|
|
else
|
|
break;
|
|
t = t->type.ref;
|
|
}
|
|
cstr_printf (result, "%d", debug_type);
|
|
}
|
|
|
|
static void tcc_debug_finish (TCCState *s1, struct debug_info *cur)
|
|
{
|
|
while (cur) {
|
|
int i;
|
|
struct debug_info *next = cur->next;
|
|
|
|
for (i = 0; i < cur->n_sym; i++) {
|
|
struct debug_sym *s = &cur->sym[i];
|
|
|
|
if (s->sec)
|
|
put_stabs_r(s1, s->str, s->type, 0, 0, s->value,
|
|
s->sec, s->sym_index);
|
|
else
|
|
put_stabs(s1, s->str, s->type, 0, 0, s->value);
|
|
tcc_free (s->str);
|
|
}
|
|
tcc_free (cur->sym);
|
|
put_stabn(s1, N_LBRAC, 0, 0, cur->start);
|
|
tcc_debug_finish (s1, cur->child);
|
|
put_stabn(s1, N_RBRAC, 0, 0, cur->end);
|
|
tcc_free (cur);
|
|
cur = next;
|
|
}
|
|
}
|
|
|
|
static void tcc_add_debug_info(TCCState *s1, int param, Sym *s, Sym *e)
|
|
{
|
|
CString debug_str;
|
|
cstr_new (&debug_str);
|
|
for (; s != e; s = s->prev) {
|
|
if (!s->v || (s->r & VT_VALMASK) != VT_LOCAL)
|
|
continue;
|
|
cstr_reset (&debug_str);
|
|
cstr_printf (&debug_str, "%s:%s", get_tok_str(s->v, NULL), param ? "p" : "");
|
|
tcc_get_debug_info(s1, s, &debug_str);
|
|
tcc_debug_stabs(s1, debug_str.data, param ? N_PSYM : N_LSYM, s->c, NULL, 0);
|
|
}
|
|
cstr_free (&debug_str);
|
|
}
|
|
|
|
static void tcc_debug_extern_sym(TCCState *s1, Sym *sym, int sh_num, int sym_bind)
|
|
{
|
|
Section *s = s1->sections[sh_num];
|
|
CString str;
|
|
|
|
cstr_new (&str);
|
|
cstr_printf (&str, "%s:%c",
|
|
get_tok_str(sym->v, NULL),
|
|
sym_bind == STB_GLOBAL ? 'G' : local_scope ? 'V' : 'S'
|
|
);
|
|
tcc_get_debug_info(s1, sym, &str);
|
|
if (sym_bind == STB_GLOBAL)
|
|
tcc_debug_stabs(s1, str.data, N_GSYM, 0, NULL, 0);
|
|
else
|
|
tcc_debug_stabs(s1, str.data,
|
|
(sym->type.t & VT_STATIC) && data_section == s
|
|
? N_STSYM : N_LCSYM, 0, s, sym->c);
|
|
cstr_free (&str);
|
|
}
|
|
|
|
static void tcc_debug_typedef(TCCState *s1, Sym *sym)
|
|
{
|
|
CString str;
|
|
|
|
cstr_new (&str);
|
|
cstr_printf (&str, "%s:t",
|
|
(sym->v & ~SYM_FIELD) >= SYM_FIRST_ANOM
|
|
? "" : get_tok_str(sym->v & ~SYM_FIELD, NULL));
|
|
tcc_get_debug_info(s1, sym, &str);
|
|
tcc_debug_stabs(s1, str.data, N_LSYM, 0, NULL, 0);
|
|
cstr_free (&str);
|
|
}
|
|
|
|
/* put end of translation unit info */
|
|
ST_FUNC void tcc_debug_end(TCCState *s1)
|
|
{
|
|
if (!s1->do_debug)
|
|
return;
|
|
put_stabs_r(s1, NULL, N_SO, 0, 0,
|
|
text_section->data_offset, text_section, section_sym);
|
|
tcc_free(debug_hash);
|
|
}
|
|
|
|
static BufferedFile* put_new_file(TCCState *s1)
|
|
{
|
|
BufferedFile *f = file;
|
|
/* use upper file if from inline ":asm:" */
|
|
if (f->filename[0] == ':')
|
|
f = f->prev;
|
|
if (f && new_file) {
|
|
put_stabs_r(s1, f->filename, N_SOL, 0, 0, ind, text_section, section_sym);
|
|
new_file = last_line_num = 0;
|
|
}
|
|
return f;
|
|
}
|
|
|
|
/* generate line number info */
|
|
ST_FUNC void tcc_debug_line(TCCState *s1)
|
|
{
|
|
BufferedFile *f;
|
|
if (!s1->do_debug
|
|
|| cur_text_section != text_section
|
|
|| !(f = put_new_file(s1))
|
|
|| last_line_num == f->line_num)
|
|
return;
|
|
if (func_ind != -1) {
|
|
put_stabn(s1, N_SLINE, 0, f->line_num, ind - func_ind);
|
|
} else {
|
|
/* from tcc_assemble */
|
|
put_stabs_r(s1, NULL, N_SLINE, 0, f->line_num, ind, text_section, section_sym);
|
|
}
|
|
last_line_num = f->line_num;
|
|
}
|
|
|
|
/* put function symbol */
|
|
ST_FUNC void tcc_debug_funcstart(TCCState *s1, Sym *sym)
|
|
{
|
|
CString debug_str;
|
|
BufferedFile *f;
|
|
if (!s1->do_debug)
|
|
return;
|
|
debug_info_root = NULL;
|
|
debug_info = NULL;
|
|
tcc_debug_stabn(N_LBRAC, ind - func_ind);
|
|
if (!(f = put_new_file(s1)))
|
|
return;
|
|
cstr_new (&debug_str);
|
|
cstr_printf(&debug_str, "%s:%c", funcname, sym->type.t & VT_STATIC ? 'f' : 'F');
|
|
tcc_get_debug_info(s1, sym->type.ref, &debug_str);
|
|
put_stabs_r(s1, debug_str.data, N_FUN, 0, f->line_num, 0, cur_text_section, sym->c);
|
|
cstr_free (&debug_str);
|
|
|
|
tcc_debug_line(s1);
|
|
}
|
|
|
|
/* put function size */
|
|
ST_FUNC void tcc_debug_funcend(TCCState *s1, int size)
|
|
{
|
|
if (!s1->do_debug)
|
|
return;
|
|
tcc_debug_stabn(N_RBRAC, size);
|
|
tcc_debug_finish (s1, debug_info_root);
|
|
}
|
|
|
|
/* put alternative filename */
|
|
ST_FUNC void tcc_debug_putfile(TCCState *s1, const char *filename)
|
|
{
|
|
if (0 == strcmp(file->filename, filename))
|
|
return;
|
|
pstrcpy(file->filename, sizeof(file->filename), filename);
|
|
new_file = 1;
|
|
}
|
|
|
|
/* begin of #include */
|
|
ST_FUNC void tcc_debug_bincl(TCCState *s1)
|
|
{
|
|
if (!s1->do_debug)
|
|
return;
|
|
put_stabs(s1, file->filename, N_BINCL, 0, 0, 0);
|
|
new_file = 1;
|
|
}
|
|
|
|
/* end of #include */
|
|
ST_FUNC void tcc_debug_eincl(TCCState *s1)
|
|
{
|
|
if (!s1->do_debug)
|
|
return;
|
|
put_stabn(s1, N_EINCL, 0, 0, 0);
|
|
new_file = 1;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* 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)
|
|
{
|
|
cur_text_section = NULL;
|
|
funcname = "";
|
|
anon_sym = SYM_FIRST_ANOM;
|
|
section_sym = 0;
|
|
const_wanted = 0;
|
|
nocode_wanted = 0x80000000;
|
|
local_scope = 0;
|
|
|
|
tcc_debug_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);
|
|
return 0;
|
|
}
|
|
|
|
ST_FUNC void tccgen_finish(TCCState *s1)
|
|
{
|
|
cstr_free(&initstr);
|
|
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);
|
|
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;
|
|
} 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 (tcc_state->do_debug
|
|
&& sym_type != STT_FUNC
|
|
&& sym->v < SYM_FIRST_ANOM)
|
|
tcc_debug_extern_sym(tcc_state, sym, sh_num, sym_bind);
|
|
|
|
} 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 *section,
|
|
addr_t value, unsigned long size)
|
|
{
|
|
int sh_num = section ? section->sh_num : SHN_UNDEF;
|
|
put_extern_sym2(sym, sh_num, 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;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
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. */
|
|
|
|
if (vtop->r == VT_CMP && !nocode_wanted)
|
|
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) {
|
|
/* 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));
|
|
} 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 */
|
|
static inline void vpushsym(CType *type, Sym *sym)
|
|
{
|
|
CValue cval;
|
|
cval.i = 0;
|
|
vsetc(type, VT_CONST | VT_SYM, &cval);
|
|
vtop->sym = sym;
|
|
}
|
|
|
|
/* Return a static symbol pointing to a section */
|
|
ST_FUNC Sym *get_sym_ref(CType *type, Section *sec, unsigned long offset, unsigned long size)
|
|
{
|
|
int v;
|
|
Sym *sym;
|
|
|
|
v = anon_sym++;
|
|
sym = 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;
|
|
}
|
|
|
|
/* 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;
|
|
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 (!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) {
|
|
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;
|
|
}
|
|
|
|
/* push a reference to global symbol v */
|
|
ST_FUNC void vpush_global_sym(CType *type, int v)
|
|
{
|
|
vpushsym(type, external_global_sym(v, type));
|
|
}
|
|
|
|
/* 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->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_global_sym(&func_old_type, 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_global_sym(func, &func_old_type);
|
|
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_global_sym(&func_old_type, 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
|
|
}
|
|
}
|
|
|
|
/* 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 **ptop, Sym *b, int keep, int ellipsis)
|
|
{
|
|
#ifdef CONFIG_TCC_BCHECK
|
|
if (tcc_state->do_bounds_check && !ellipsis && !keep)
|
|
add_local_bounds(*ptop, b);
|
|
#endif
|
|
if (tcc_state->do_debug)
|
|
tcc_add_debug_info (tcc_state, !local_scope, *ptop, b);
|
|
sym_pop(ptop, b, keep);
|
|
}
|
|
|
|
static void incr_bf_adr(int o)
|
|
{
|
|
vtop->type = char_pointer_type;
|
|
gaddrof();
|
|
vpushs(o);
|
|
gen_op('+');
|
|
vtop->type.t = VT_BYTE | VT_UNSIGNED;
|
|
vtop->r |= VT_LVAL;
|
|
}
|
|
|
|
/* 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 = { data_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)
|
|
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 */
|
|
vtop->type.t = VT_PTRDIFF_T;
|
|
gaddrof();
|
|
vpushs(PTR_SIZE);
|
|
gen_op('+');
|
|
vtop->r |= VT_LVAL;
|
|
vtop->type.t = load_type;
|
|
} 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_global_sym(&func_old_type, func);
|
|
vrott(3);
|
|
gfunc_call(2);
|
|
vpushi(0);
|
|
vtop->r = reg_iret;
|
|
vtop->r2 = reg_lret;
|
|
break;
|
|
case '^':
|
|
case '&':
|
|
case '|':
|
|
case '*':
|
|
case '+':
|
|
case '-':
|
|
//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;
|
|
|
|
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 && !(nocode_wanted & unevalmask))
|
|
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;
|
|
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 (!const_wanted &&
|
|
c1 && ((l1 == 0 &&
|
|
(op == TOK_SHL || op == TOK_SHR || op == TOK_SAR)) ||
|
|
(l1 == -1 && op == TOK_SAR))) {
|
|
/* treat (0 << x), (0 >> x) and (-1 >> x) as constant */
|
|
vtop--;
|
|
} else if (!const_wanted &&
|
|
c2 && ((l2 == 0 && (op == '&' || op == '*')) ||
|
|
(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 == '-') &&
|
|
(((vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM)) == (VT_CONST | VT_SYM))
|
|
|| (vtop[-1].r & (VT_VALMASK | VT_LVAL)) == VT_LOCAL)) {
|
|
/* symbol + constant case */
|
|
if (op == '-')
|
|
l2 = -l2;
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* generate a floating point operation with constant propagation */
|
|
static void gen_opif(int op)
|
|
{
|
|
int c1, c2;
|
|
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;
|
|
/* currently, we cannot do computations with forward symbols */
|
|
c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
|
|
c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
|
|
if (c1 && c2) {
|
|
if (v1->type.t == VT_FLOAT) {
|
|
f1 = v1->c.f;
|
|
f2 = v2->c.f;
|
|
} else if (v1->type.t == VT_DOUBLE) {
|
|
f1 = v1->c.d;
|
|
f2 = v2->c.d;
|
|
} else {
|
|
f1 = v1->c.ld;
|
|
f2 = v2->c.ld;
|
|
}
|
|
|
|
/* NOTE: we only do constant propagation if finite number (not
|
|
NaN or infinity) (ANSI spec) */
|
|
if (!ieee_finite(f1) || !ieee_finite(f2))
|
|
goto general_case;
|
|
|
|
switch(op) {
|
|
case '+': f1 += f2; break;
|
|
case '-': f1 -= f2; break;
|
|
case '*': f1 *= f2; break;
|
|
case '/':
|
|
if (f2 == 0.0) {
|
|
/* If not in initializer we need to potentially generate
|
|
FP exceptions at runtime, otherwise we want to fold. */
|
|
if (!const_wanted)
|
|
goto general_case;
|
|
}
|
|
f1 /= f2;
|
|
break;
|
|
/* XXX: also handles tests ? */
|
|
default:
|
|
goto general_case;
|
|
}
|
|
/* XXX: overflow test ? */
|
|
if (v1->type.t == VT_FLOAT) {
|
|
v1->c.f = f1;
|
|
} else if (v1->type.t == VT_DOUBLE) {
|
|
v1->c.d = f1;
|
|
} else {
|
|
v1->c.ld = f1;
|
|
}
|
|
vtop--;
|
|
} else {
|
|
general_case:
|
|
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 (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) {
|
|
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 void vla_runtime_pointed_size(CType *type)
|
|
{
|
|
int align;
|
|
vla_runtime_type_size(pointed_type(type), &align);
|
|
}
|
|
|
|
static inline int is_null_pointer(SValue *p)
|
|
{
|
|
if ((p->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
|
|
return 0;
|
|
return ((p->type.t & VT_BTYPE) == VT_INT && (uint32_t)p->c.i == 0) ||
|
|
((p->type.t & VT_BTYPE) == VT_LLONG && p->c.i == 0) ||
|
|
((p->type.t & VT_BTYPE) == VT_PTR &&
|
|
(PTR_SIZE == 4 ? (uint32_t)p->c.i == 0 : p->c.i == 0) &&
|
|
((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;
|
|
/* we should check the function return type for FUNC_OLD too
|
|
but that causes problems with the internally used support
|
|
functions such as TOK_memmove */
|
|
if (s1->f.func_type == FUNC_OLD && !s1->next)
|
|
return 1;
|
|
if (s2->f.func_type == FUNC_OLD && !s2->next)
|
|
return 1;
|
|
for (;;) {
|
|
if (!is_compatible_unqualified_types(&s1->type, &s2->type))
|
|
return 0;
|
|
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 u, 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_noabort("invalid operand types for binary operation");
|
|
vpop();
|
|
} else if (bt1 == VT_PTR || bt2 == VT_PTR) {
|
|
/* at least one operand is a pointer */
|
|
/* relational op: must be both pointers */
|
|
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");
|
|
if (vtop[-1].type.t & VT_VLA) {
|
|
vla_runtime_pointed_size(&vtop[-1].type);
|
|
} else {
|
|
vpushi(pointed_size(&vtop[-1].type));
|
|
}
|
|
vrott(3);
|
|
gen_opic(op);
|
|
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;
|
|
if (vtop[-1].type.t & VT_VLA)
|
|
vla_runtime_pointed_size(&vtop[-1].type);
|
|
else {
|
|
u = pointed_size(&vtop[-1].type);
|
|
if (u < 0)
|
|
tcc_error("unknown array element size");
|
|
#if PTR_SIZE == 8
|
|
vpushll(u);
|
|
#else
|
|
/* XXX: cast to int ? (long long case) */
|
|
vpushi(u);
|
|
#endif
|
|
}
|
|
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;
|
|
/* 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_global_sym(&func_old_type, TOK___floatundisf);
|
|
#if LDOUBLE_SIZE != 8
|
|
else if (t == VT_LDOUBLE)
|
|
vpush_global_sym(&func_old_type, TOK___floatundixf);
|
|
#endif
|
|
else
|
|
vpush_global_sym(&func_old_type, TOK___floatundidf);
|
|
vrott(2);
|
|
gfunc_call(1);
|
|
vpushi(0);
|
|
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_global_sym(&func_old_type, TOK___fixunssfdi);
|
|
#if LDOUBLE_SIZE != 8
|
|
else if (st == VT_LDOUBLE)
|
|
vpush_global_sym(&func_old_type, TOK___fixunsxfdi);
|
|
#endif
|
|
else
|
|
vpush_global_sym(&func_old_type, TOK___fixunsdfdi);
|
|
vrott(2);
|
|
gfunc_call(1);
|
|
vpushi(0);
|
|
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;
|
|
|
|
c = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
|
|
#if !defined TCC_IS_NATIVE && !defined TCC_IS_NATIVE_387
|
|
c &= (dbt != VT_LDOUBLE) | !!nocode_wanted;
|
|
#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 (STATIC_DATA_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) {
|
|
if (dbt_bt == VT_VOID)
|
|
goto done;
|
|
cast_error(&vtop->type, type);
|
|
}
|
|
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) {
|
|
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' */
|
|
ST_FUNC void vla_runtime_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 {
|
|
vpushi(type_size(type, a));
|
|
}
|
|
}
|
|
|
|
/* 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("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 */
|
|
/* XXX: optimize if small size */
|
|
size = type_size(&vtop->type, &align);
|
|
|
|
/* destination */
|
|
vswap();
|
|
#ifdef CONFIG_TCC_BCHECK
|
|
if (vtop->r & VT_MUSTBOUND)
|
|
gbound(); /* check would be wrong after gaddrof() */
|
|
#endif
|
|
vtop->type.t = VT_PTR;
|
|
gaddrof();
|
|
|
|
/* address of memcpy() */
|
|
#ifdef TCC_ARM_EABI
|
|
if(!(align & 7))
|
|
vpush_global_sym(&func_old_type, TOK_memmove8);
|
|
else if(!(align & 3))
|
|
vpush_global_sym(&func_old_type, TOK_memmove4);
|
|
else
|
|
#endif
|
|
/* Use memmove, rather than memcpy, as dest and src may be same: */
|
|
vpush_global_sym(&func_old_type, TOK_memmove);
|
|
|
|
vswap();
|
|
/* source */
|
|
vpushv(vtop - 2);
|
|
#ifdef CONFIG_TCC_BCHECK
|
|
if (vtop->r & VT_MUSTBOUND)
|
|
gbound();
|
|
#endif
|
|
vtop->type.t = VT_PTR;
|
|
gaddrof();
|
|
/* type size */
|
|
vpushi(size);
|
|
gfunc_call(3);
|
|
/* leave source on stack */
|
|
|
|
} else if (ft & VT_BITFIELD) {
|
|
/* bitfield store handling */
|
|
|
|
/* save lvalue as expression result (example: s.b = s.a = n;) */
|
|
vdup(), vtop[-1] = vtop[-2];
|
|
|
|
bit_pos = 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();
|
|
/* convert to int to increment easily */
|
|
vtop->type.t = VT_PTRDIFF_T;
|
|
gaddrof();
|
|
vpushs(PTR_SIZE);
|
|
gen_op('+');
|
|
vtop->r |= VT_LVAL;
|
|
vswap();
|
|
vtop[-1].type.t = load_type;
|
|
/* XXX: it works because r2 is spilled last ! */
|
|
store(vtop->r2, vtop - 1);
|
|
} else {
|
|
/* 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 void parse_mult_str (CString *astr, const char *msg)
|
|
{
|
|
/* read the string */
|
|
if (tok != TOK_STR)
|
|
expect(msg);
|
|
cstr_new(astr);
|
|
while (tok == TOK_STR) {
|
|
/* XXX: add \0 handling too ? */
|
|
cstr_cat(astr, tokc.str.data, -1);
|
|
next();
|
|
}
|
|
cstr_ccat(astr, '\0');
|
|
}
|
|
|
|
/* 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;
|
|
CString 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("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('(');
|
|
parse_mult_str(&astr, "section name");
|
|
ad->section = find_section(tcc_state, (char *)astr.data);
|
|
skip(')');
|
|
cstr_free(&astr);
|
|
break;
|
|
case TOK_ALIAS1:
|
|
case TOK_ALIAS2:
|
|
skip('(');
|
|
parse_mult_str(&astr, "alias(\"target\")");
|
|
ad->alias_target = /* save string as token, for later */
|
|
tok_alloc((char*)astr.data, astr.size-1)->tok;
|
|
skip(')');
|
|
cstr_free(&astr);
|
|
break;
|
|
case TOK_VISIBILITY1:
|
|
case TOK_VISIBILITY2:
|
|
skip('(');
|
|
parse_mult_str(&astr,
|
|
"visibility(\"default|hidden|internal|protected\")");
|
|
if (!strcmp (astr.data, "default"))
|
|
ad->a.visibility = STV_DEFAULT;
|
|
else if (!strcmp (astr.data, "hidden"))
|
|
ad->a.visibility = STV_HIDDEN;
|
|
else if (!strcmp (astr.data, "internal"))
|
|
ad->a.visibility = STV_INTERNAL;
|
|
else if (!strcmp (astr.data, "protected"))
|
|
ad->a.visibility = STV_PROTECTED;
|
|
else
|
|
expect("visibility(\"default|hidden|internal|protected\")");
|
|
skip(')');
|
|
cstr_free(&astr);
|
|
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_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:
|
|
if (tcc_state->warn_unsupported)
|
|
tcc_warning("'%s' attribute ignored", get_tok_str(t, NULL));
|
|
/* skip parameters */
|
|
if (tok == '(') {
|
|
int parenthesis = 0;
|
|
do {
|
|
if (tok == '(')
|
|
parenthesis++;
|
|
else if (tok == ')')
|
|
parenthesis--;
|
|
next();
|
|
} while (parenthesis && tok != -1);
|
|
}
|
|
break;
|
|
}
|
|
if (tok != ',')
|
|
break;
|
|
next();
|
|
}
|
|
skip(')');
|
|
skip(')');
|
|
goto redo;
|
|
}
|
|
|
|
static Sym * find_field (CType *type, int v, int *cumofs)
|
|
{
|
|
Sym *s = type->ref;
|
|
v |= SYM_FIELD;
|
|
while ((s = s->next) != NULL) {
|
|
if ((s->v & SYM_FIELD) &&
|
|
(s->type.t & VT_BTYPE) == VT_STRUCT &&
|
|
(s->v & ~SYM_FIELD) >= SYM_FIRST_ANOM) {
|
|
Sym *ret = find_field (&s->type, v, cumofs);
|
|
if (ret) {
|
|
*cumofs += s->c;
|
|
return ret;
|
|
}
|
|
}
|
|
if (s->v == v)
|
|
break;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
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)
|
|
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) {
|
|
/* 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
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 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)) {
|
|
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");
|
|
}
|
|
struct_layout(type, &ad);
|
|
}
|
|
}
|
|
}
|
|
|
|
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 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)) {
|
|
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_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_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;
|
|
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 == ':' && !in_generic) {
|
|
/* 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;
|
|
#if defined TCC_TARGET_PE || (defined _WIN32 && defined _MSC_VER)
|
|
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;
|
|
if ((pt->t & VT_BTYPE) == VT_FUNC) {
|
|
mk_pointer(pt);
|
|
}
|
|
}
|
|
|
|
ST_FUNC void parse_asm_str(CString *astr)
|
|
{
|
|
skip('(');
|
|
parse_mult_str(astr, "string constant");
|
|
}
|
|
|
|
/* Parse an asm label and return the token */
|
|
static int asm_label_instr(void)
|
|
{
|
|
int v;
|
|
CString astr;
|
|
|
|
next();
|
|
parse_asm_str(&astr);
|
|
skip(')');
|
|
#ifdef ASM_DEBUG
|
|
printf("asm_alias: \"%s\"\n", (char *)astr.data);
|
|
#endif
|
|
v = tok_alloc(astr.data, astr.size - 1)->tok;
|
|
cstr_free(&astr);
|
|
return v;
|
|
}
|
|
|
|
static int post_type(CType *type, AttributeDef *ad, int storage, int td)
|
|
{
|
|
int n, l, t1, arg_size, align, unused_align;
|
|
Sym **plast, *s, *first;
|
|
AttributeDef ad1;
|
|
CType pt;
|
|
|
|
if (tok == '(') {
|
|
/* function type, or recursive declarator (return if so) */
|
|
next();
|
|
if (td && !(td & TYPE_ABSTRACT))
|
|
return 0;
|
|
if (tok == ')')
|
|
l = 0;
|
|
else if (parse_btype(&pt, &ad1))
|
|
l = FUNC_NEW;
|
|
else if (td) {
|
|
merge_attr (ad, &ad1);
|
|
return 0;
|
|
} else
|
|
l = FUNC_OLD;
|
|
first = NULL;
|
|
plast = &first;
|
|
arg_size = 0;
|
|
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);
|
|
if ((pt.t & VT_BTYPE) == VT_VOID)
|
|
tcc_error("parameter declared as void");
|
|
} else {
|
|
n = tok;
|
|
if (n < TOK_UIDENT)
|
|
expect("identifier");
|
|
pt.t = VT_VOID; /* invalid type */
|
|
pt.ref = NULL;
|
|
next();
|
|
}
|
|
convert_parameter_type(&pt);
|
|
arg_size += (type_size(&pt, &align) + PTR_SIZE - 1) / PTR_SIZE;
|
|
s = sym_push(n | SYM_FIELD, &pt, 0, 0);
|
|
*plast = s;
|
|
plast = &s->next;
|
|
if (tok == ')')
|
|
break;
|
|
skip(',');
|
|
if (l == FUNC_NEW && tok == TOK_DOTS) {
|
|
l = FUNC_ELLIPSIS;
|
|
next();
|
|
break;
|
|
}
|
|
if (l == FUNC_NEW && !parse_btype(&pt, &ad1))
|
|
tcc_error("invalid type");
|
|
}
|
|
} else
|
|
/* if no parameters, then old type prototype */
|
|
l = FUNC_OLD;
|
|
skip(')');
|
|
/* NOTE: const is ignored in returned type as it has a special
|
|
meaning in gcc / C++ */
|
|
type->t &= ~VT_CONSTANT;
|
|
/* some ancient pre-K&R C allows a function to return an array
|
|
and the array brackets to be put after the arguments, such
|
|
that "int c()[]" means something like "int[] c()" */
|
|
if (tok == '[') {
|
|
next();
|
|
skip(']'); /* only handle simple "[]" */
|
|
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();
|
|
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;
|
|
}
|
|
break;
|
|
}
|
|
n = -1;
|
|
t1 = 0;
|
|
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();
|
|
}
|
|
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, 0);
|
|
|
|
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, &unused_align) < 0)
|
|
tcc_error("declaration of an array of incomplete type elements");
|
|
|
|
t1 |= type->t & VT_VLA;
|
|
|
|
if (t1 & VT_VLA) {
|
|
if (n < 0)
|
|
tcc_error("need explicit inner array size in VLAs");
|
|
loc -= type_size(&int_type, &align);
|
|
loc &= -align;
|
|
n = loc;
|
|
|
|
vla_runtime_type_size(type, &align);
|
|
gen_op('*');
|
|
vset(&int_type, VT_LOCAL|VT_LVAL, n);
|
|
vswap();
|
|
vstore();
|
|
}
|
|
if (n != -1)
|
|
vpop();
|
|
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;
|
|
}
|
|
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_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, storage, 0);
|
|
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)) {
|
|
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)) {
|
|
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--;
|
|
}
|
|
|
|
ST_FUNC void unary(void)
|
|
{
|
|
int n, t, align, size, r, sizeof_caller;
|
|
CType type;
|
|
Sym *s;
|
|
AttributeDef ad;
|
|
|
|
/* generate line number info */
|
|
if (tcc_state->do_debug)
|
|
tcc_debug_line(tcc_state);
|
|
|
|
sizeof_caller = in_sizeof;
|
|
in_sizeof = 0;
|
|
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:
|
|
t = VT_LDOUBLE;
|
|
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__:
|
|
{
|
|
void *ptr;
|
|
int len;
|
|
/* special function name identifier */
|
|
len = strlen(funcname) + 1;
|
|
/* generate char[len] type */
|
|
type.t = VT_BYTE;
|
|
mk_pointer(&type);
|
|
type.t |= VT_ARRAY;
|
|
type.ref->c = len;
|
|
vpush_ref(&type, data_section, data_section->data_offset, len);
|
|
if (!NODATA_WANTED) {
|
|
ptr = section_ptr_add(data_section, len);
|
|
memcpy(ptr, funcname, len);
|
|
}
|
|
next();
|
|
}
|
|
break;
|
|
case TOK_LSTR:
|
|
#ifdef TCC_TARGET_PE
|
|
t = VT_SHORT | VT_UNSIGNED;
|
|
#else
|
|
t = VT_INT;
|
|
#endif
|
|
goto str_init;
|
|
case TOK_STR:
|
|
/* string parsing */
|
|
t = VT_BYTE;
|
|
if (tcc_state->char_is_unsigned)
|
|
t = VT_BYTE | VT_UNSIGNED;
|
|
str_init:
|
|
if (tcc_state->warn_write_strings)
|
|
t |= VT_CONSTANT;
|
|
type.t = t;
|
|
mk_pointer(&type);
|
|
type.t |= VT_ARRAY;
|
|
memset(&ad, 0, sizeof(AttributeDef));
|
|
decl_initializer_alloc(&type, &ad, VT_CONST, 2, 0, 0);
|
|
break;
|
|
case '(':
|
|
next();
|
|
/* cast ? */
|
|
if (parse_btype(&type, &ad)) {
|
|
type_decl(&type, &ad, &n, TYPE_ABSTRACT);
|
|
skip(')');
|
|
/* check ISOC99 compound literal */
|
|
if (tok == '{') {
|
|
/* data is allocated locally by default */
|
|
if (global_expr)
|
|
r = VT_CONST;
|
|
else
|
|
r = VT_LOCAL;
|
|
/* all except arrays are lvalues */
|
|
if (!(type.t & VT_ARRAY))
|
|
r |= VT_LVAL;
|
|
memset(&ad, 0, sizeof(AttributeDef));
|
|
decl_initializer_alloc(&type, &ad, r, 1, 0, 0);
|
|
} else {
|
|
if (sizeof_caller) {
|
|
vpush(&type);
|
|
return;
|
|
}
|
|
unary();
|
|
gen_cast(&type);
|
|
}
|
|
} else if (tok == '{') {
|
|
int saved_nocode_wanted = nocode_wanted;
|
|
if (const_wanted && !(nocode_wanted & unevalmask))
|
|
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(1);
|
|
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))
|
|
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();
|
|
in_sizeof++;
|
|
expr_type(&type, unary); /* Perform a in_sizeof = 0; */
|
|
s = NULL;
|
|
if (vtop[1].r & VT_SYM)
|
|
s = vtop[1].sym; /* hack: accessing previous vtop */
|
|
size = type_size(&type, &align);
|
|
if (s && s->a.aligned)
|
|
align = 1 << (s->a.aligned - 1);
|
|
if (t == TOK_SIZEOF) {
|
|
if (!(type.t & VT_VLA)) {
|
|
if (size < 0)
|
|
tcc_error("sizeof applied to an incomplete type");
|
|
vpushs(size);
|
|
} else {
|
|
vla_runtime_type_size(&type, &align);
|
|
}
|
|
} else {
|
|
vpushs(align);
|
|
}
|
|
vtop->type.t |= VT_UNSIGNED;
|
|
break;
|
|
|
|
case TOK_builtin_expect:
|
|
/* __builtin_expect is a no-op for now */
|
|
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 = (vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST &&
|
|
!((vtop->r & VT_SYM) && vtop->sym->a.addrtaken);
|
|
vtop--;
|
|
vpushi(n);
|
|
break;
|
|
case TOK_builtin_frame_address:
|
|
case TOK_builtin_return_address:
|
|
{
|
|
int tok1 = tok;
|
|
int level;
|
|
next();
|
|
skip('(');
|
|
if (tok != TOK_CINT) {
|
|
tcc_error("%s only takes positive integers",
|
|
tok1 == TOK_builtin_return_address ?
|
|
"__builtin_return_address" :
|
|
"__builtin_frame_address");
|
|
}
|
|
level = (uint32_t)tokc.i;
|
|
next();
|
|
skip(')');
|
|
type.t = VT_VOID;
|
|
mk_pointer(&type);
|
|
vset(&type, VT_LOCAL, 0); /* local frame */
|
|
while (level--) {
|
|
#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
|
|
|
|
/* pre operations */
|
|
case TOK_INC:
|
|
case TOK_DEC:
|
|
t = tok;
|
|
next();
|
|
unary();
|
|
inc(0, t);
|
|
break;
|
|
case '-':
|
|
next();
|
|
unary();
|
|
t = vtop->type.t & VT_BTYPE;
|
|
if (is_float(t)) {
|
|
/* In IEEE negate(x) isn't subtract(0,x), but rather
|
|
subtract(-0, x). */
|
|
vpush(&vtop->type);
|
|
if (t == VT_FLOAT)
|
|
vtop->c.f = -1.0 * 0.0;
|
|
else if (t == VT_DOUBLE)
|
|
vtop->c.d = -1.0 * 0.0;
|
|
else
|
|
vtop->c.ld = -1.0 * 0.0;
|
|
} else
|
|
vpushi(0);
|
|
vswap();
|
|
gen_op('-');
|
|
break;
|
|
case TOK_LAND:
|
|
if (!gnu_ext)
|
|
goto tok_identifier;
|
|
next();
|
|
/* allow to take the address of a label */
|
|
if (tok < TOK_UIDENT)
|
|
expect("label identifier");
|
|
s = label_find(tok);
|
|
if (!s) {
|
|
s = label_push(&global_label_stack, tok, LABEL_FORWARD);
|
|
} else {
|
|
if (s->r == LABEL_DECLARED)
|
|
s->r = LABEL_FORWARD;
|
|
}
|
|
if (!s->type.t) {
|
|
s->type.t = VT_VOID;
|
|
mk_pointer(&s->type);
|
|
s->type.t |= VT_STATIC;
|
|
}
|
|
vpushsym(&s->type, s);
|
|
next();
|
|
break;
|
|
|
|
case TOK_GENERIC:
|
|
{
|
|
CType controlling_type;
|
|
int has_default = 0;
|
|
int has_match = 0;
|
|
int learn = 0;
|
|
TokenString *str = NULL;
|
|
int saved_const_wanted = const_wanted;
|
|
|
|
next();
|
|
skip('(');
|
|
const_wanted = 0;
|
|
expr_type(&controlling_type, expr_eq);
|
|
controlling_type.t &= ~(VT_CONSTANT | VT_VOLATILE | VT_ARRAY);
|
|
if ((controlling_type.t & VT_BTYPE) == VT_FUNC)
|
|
mk_pointer(&controlling_type);
|
|
const_wanted = saved_const_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;
|
|
|
|
in_generic++;
|
|
parse_btype(&cur_type, &ad_tmp);
|
|
in_generic--;
|
|
|
|
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:
|
|
t = tok;
|
|
next();
|
|
if (t < TOK_UIDENT)
|
|
expect("identifier");
|
|
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 */
|
|
if (tcc_state->warn_implicit_function_declaration
|
|
#ifdef TCC_TARGET_PE
|
|
/* people must be warned about using undeclared WINAPI functions
|
|
(which usually start with uppercase letter) */
|
|
|| (name[0] >= 'A' && name[0] <= 'Z')
|
|
#endif
|
|
)
|
|
tcc_warning("implicit declaration of function '%s'", name);
|
|
s = external_global_sym(t, &func_old_type);
|
|
}
|
|
|
|
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 || tok == TOK_CDOUBLE) {
|
|
int qualifiers, cumofs = 0;
|
|
/* field */
|
|
if (tok == TOK_ARROW)
|
|
indir();
|
|
qualifiers = vtop->type.t & (VT_CONSTANT | VT_VOLATILE);
|
|
test_lvalue();
|
|
gaddrof();
|
|
/* expect pointer on structure */
|
|
if ((vtop->type.t & VT_BTYPE) != VT_STRUCT)
|
|
expect("struct or union");
|
|
if (tok == TOK_CDOUBLE)
|
|
expect("field name");
|
|
next();
|
|
if (tok == TOK_CINT || tok == TOK_CUINT)
|
|
expect("field name");
|
|
s = find_field(&vtop->type, tok, &cumofs);
|
|
if (!s)
|
|
tcc_error("field not found: %s", get_tok_str(tok & ~SYM_FIELD, &tokc));
|
|
/* add field offset to pointer */
|
|
vtop->type = char_pointer_type; /* change type to 'char *' */
|
|
vpushi(cumofs + s->c);
|
|
gen_op('+');
|
|
/* change type to field type, and set to lvalue */
|
|
vtop->type = s->type;
|
|
vtop->type.t |= qualifiers;
|
|
/* an array is never an lvalue */
|
|
if (!(vtop->type.t & VT_ARRAY)) {
|
|
vtop->r |= 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, ®size);
|
|
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 */
|
|
for (r = ret.r + ret_nregs + !ret_nregs; r-- > ret.r;) {
|
|
vsetc(&ret.type, r, &ret.c);
|
|
vtop->r2 = ret.r2; /* Loop only happens when r2 is VT_CONST */
|
|
}
|
|
|
|
/* handle packed struct return */
|
|
if (((s->type.t & VT_BTYPE) == VT_STRUCT) && ret_nregs) {
|
|
int addr, offset;
|
|
|
|
size = type_size(&s->type, &align);
|
|
/* We're writing whole regs often, make sure there's enough
|
|
space. Assume register size is power of 2. */
|
|
if (regsize > align)
|
|
align = regsize;
|
|
loc = (loc - size) & -align;
|
|
addr = loc;
|
|
offset = 0;
|
|
for (;;) {
|
|
vset(&ret.type, VT_LOCAL | VT_LVAL, addr + offset);
|
|
vswap();
|
|
vstore();
|
|
vtop--;
|
|
if (--ret_nregs == 0)
|
|
break;
|
|
offset += regsize;
|
|
}
|
|
vset(&s->type, VT_LOCAL | VT_LVAL, addr);
|
|
}
|
|
|
|
/* 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)
|
|
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;
|
|
int ncw_prev;
|
|
|
|
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);
|
|
}
|
|
|
|
ncw_prev = nocode_wanted;
|
|
if (c == 0)
|
|
nocode_wanted++;
|
|
if (!g)
|
|
gexpr();
|
|
|
|
if (c < 0 && vtop->r == VT_CMP) {
|
|
t1 = gvtst(0, 0);
|
|
vpushi(0);
|
|
gvtst_set(0, t1);
|
|
gv(RC_INT);
|
|
}
|
|
|
|
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;
|
|
|
|
nocode_wanted = ncw_prev;
|
|
if (c == 1)
|
|
nocode_wanted++;
|
|
skip(':');
|
|
expr_cond();
|
|
|
|
if (c < 0 && is_cond_bool(vtop) && is_cond_bool(&sv)) {
|
|
if (sv.r == VT_CMP) {
|
|
t1 = sv.jtrue;
|
|
t2 = u;
|
|
} else {
|
|
t1 = gvtst(0, 0);
|
|
t2 = gjmp(0);
|
|
gsym(u);
|
|
vpushv(&sv);
|
|
}
|
|
gvtst_set(0, t1);
|
|
gvtst_set(1, t2);
|
|
nocode_wanted = ncw_prev;
|
|
// tcc_warning("two conditions expr_cond");
|
|
return;
|
|
}
|
|
|
|
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')");
|
|
/* 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);
|
|
nocode_wanted = ncw_prev;
|
|
|
|
/* 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)
|
|
{
|
|
while (1) {
|
|
expr_eq();
|
|
if (tok != ',')
|
|
break;
|
|
vpop();
|
|
next();
|
|
}
|
|
}
|
|
|
|
/* parse a constant expression and return value in vtop. */
|
|
static void expr_const1(void)
|
|
{
|
|
const_wanted++;
|
|
nocode_wanted += unevalmask + 1;
|
|
expr_cond();
|
|
nocode_wanted -= unevalmask + 1;
|
|
const_wanted--;
|
|
}
|
|
|
|
/* 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_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, ®size);
|
|
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;
|
|
size = type_size(func_type,&align);
|
|
if ((vtop->r != (VT_LOCAL | VT_LVAL) ||
|
|
(vtop->c.i & (ret_align-1)))
|
|
&& (align & (ret_align-1))) {
|
|
loc = (loc - size) & -ret_align;
|
|
addr = loc;
|
|
type = *func_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);
|
|
if (ret_nregs == 1)
|
|
gv(rc);
|
|
else {
|
|
for (;;) {
|
|
vdup();
|
|
gv(rc);
|
|
vpop();
|
|
if (--ret_nregs == 0)
|
|
break;
|
|
/* We assume that when a structure is returned in multiple
|
|
registers, their classes are consecutive values of the
|
|
suite s(n) = 2^n */
|
|
rc <<= 1;
|
|
vtop->c.i += regsize;
|
|
}
|
|
}
|
|
}
|
|
} 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);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* __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)
|
|
{
|
|
if (o->vla.num < cur_scope->vla.num)
|
|
vla_restore(o->vla.loc);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* local scopes */
|
|
|
|
void new_scope(struct scope *o)
|
|
{
|
|
/* copy and link previous scope */
|
|
*o = *cur_scope;
|
|
o->prev = cur_scope;
|
|
cur_scope = o;
|
|
|
|
/* record local declaration stack position */
|
|
o->lstk = local_stack;
|
|
o->llstk = local_label_stack;
|
|
|
|
++local_scope;
|
|
|
|
if (tcc_state->do_debug)
|
|
tcc_debug_stabn(N_LBRAC, ind - func_ind);
|
|
}
|
|
|
|
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(&local_stack, o->lstk, is_expr, 0);
|
|
cur_scope = o->prev;
|
|
--local_scope;
|
|
|
|
if (tcc_state->do_debug)
|
|
tcc_debug_stabn(N_RBRAC, ind - func_ind);
|
|
}
|
|
|
|
/* leave a scope via break/continue(/goto) */
|
|
void leave_scope(struct scope *o)
|
|
{
|
|
if (!o)
|
|
return;
|
|
try_call_scope_cleanup(o->cl.s);
|
|
vla_leave(o);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* 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 is_expr)
|
|
{
|
|
int a, b, c, d, e, t;
|
|
struct scope o;
|
|
Sym *s;
|
|
|
|
if (is_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 (t == TOK_IF) {
|
|
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);
|
|
}
|
|
|
|
} else if (t == TOK_WHILE) {
|
|
d = gind();
|
|
skip('(');
|
|
gexpr();
|
|
skip(')');
|
|
a = gvtst(1, 0);
|
|
b = 0;
|
|
lblock(&a, &b);
|
|
gjmp_addr(d);
|
|
gsym_addr(b, d);
|
|
gsym(a);
|
|
|
|
} else if (t == '{') {
|
|
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 (is_expr)
|
|
vpop();
|
|
block(is_expr);
|
|
}
|
|
}
|
|
|
|
prev_scope(&o, is_expr);
|
|
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);
|
|
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 (!decl0(VT_LOCAL, 1, NULL)) {
|
|
/* 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) {
|
|
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);
|
|
|
|
} 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;
|
|
cur_switch = sw;
|
|
|
|
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);
|
|
|
|
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);
|
|
/* break label */
|
|
gsym(a);
|
|
|
|
dynarray_reset(&sw->p, &sw->n);
|
|
cur_switch = sw->prev;
|
|
tcc_free(sw);
|
|
|
|
} else if (t == TOK_CASE) {
|
|
struct case_t *cr = tcc_malloc(sizeof(struct case_t));
|
|
if (!cur_switch)
|
|
expect("switch");
|
|
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");
|
|
}
|
|
cr->sym = gind();
|
|
dynarray_add(&cur_switch->p, &cur_switch->n, cr);
|
|
skip(':');
|
|
is_expr = 0;
|
|
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 = gind();
|
|
skip(':');
|
|
is_expr = 0;
|
|
goto block_after_label;
|
|
|
|
} else if (t == TOK_GOTO) {
|
|
vla_restore(root_scope->vla.loc);
|
|
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:
|
|
vla_restore(cur_scope->vla.loc);
|
|
/* we accept this, but it is a mistake */
|
|
if (tok == '}') {
|
|
tcc_warning("deprecated use of label at end of compound statement");
|
|
} else {
|
|
goto again;
|
|
}
|
|
|
|
} else {
|
|
/* expression case */
|
|
if (t != ';') {
|
|
unget_tok(t);
|
|
expr:
|
|
if (is_expr) {
|
|
vpop();
|
|
gexpr();
|
|
} else {
|
|
gexpr();
|
|
vpop();
|
|
}
|
|
skip(';');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 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 ((level > 0 || (tok != '}' && tok != ',' && tok != ';' && tok != ')'))) {
|
|
int t;
|
|
if (tok == TOK_EOF) {
|
|
if (str || level > 0)
|
|
tcc_error("unexpected end of file");
|
|
else
|
|
break;
|
|
}
|
|
if (str)
|
|
tok_str_add_tok(*str);
|
|
t = tok;
|
|
next();
|
|
if (t == '{' || t == '(') {
|
|
level++;
|
|
} else if (t == '}' || t == ')') {
|
|
level--;
|
|
if (level == 0 && braces && t == '}')
|
|
break;
|
|
}
|
|
}
|
|
if (str) {
|
|
tok_str_add(*str, -1);
|
|
tok_str_add(*str, 0);
|
|
}
|
|
}
|
|
|
|
#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_global_sym(&func_old_type, TOK_memset);
|
|
vseti(VT_LOCAL, c);
|
|
#ifdef TCC_TARGET_ARM
|
|
vpushs(size);
|
|
vpushi(0);
|
|
#else
|
|
vpushi(0);
|
|
vpushs(size);
|
|
#endif
|
|
gfunc_call(3);
|
|
}
|
|
}
|
|
|
|
#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();
|
|
if ((type->t & VT_BTYPE) != VT_STRUCT)
|
|
expect("struct/union type");
|
|
cumofs = 0;
|
|
f = find_field(type, l, &cumofs);
|
|
if (!f)
|
|
expect("field");
|
|
if (cur_field)
|
|
*cur_field = f;
|
|
type = &f->type;
|
|
c += cumofs + f->c;
|
|
}
|
|
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;
|
|
while (f && (f->v & SYM_FIRST_ANOM) && (f->type.t & VT_BITFIELD))
|
|
*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;
|
|
|
|
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 != VT_FUNC
|
|
&& (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;
|
|
|
|
/* 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. */
|
|
int num_relocs = ssec->reloc->data_offset / sizeof(*rel);
|
|
rel = (ElfW_Rel*)(ssec->reloc->data + ssec->reloc->data_offset);
|
|
while (num_relocs--) {
|
|
rel--;
|
|
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 = vtop->c.i >> 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) {
|
|
/* XXX: when cross-compiling we assume that each type has the
|
|
same representation on host and target, which is likely to
|
|
be wrong in the case of long double */
|
|
case VT_BOOL:
|
|
vtop->c.i = vtop->c.i != 0;
|
|
case VT_BYTE:
|
|
*(char *)ptr = vtop->c.i;
|
|
break;
|
|
case VT_SHORT:
|
|
*(short *)ptr = vtop->c.i;
|
|
break;
|
|
case VT_FLOAT:
|
|
*(float*)ptr = vtop->c.f;
|
|
break;
|
|
case VT_DOUBLE:
|
|
*(double *)ptr = vtop->c.d;
|
|
break;
|
|
case VT_LDOUBLE:
|
|
#if defined TCC_IS_NATIVE_387
|
|
if (sizeof (long double) >= 10) /* zero pad ten-byte LD */
|
|
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 if (vtop->c.ld == 0.0)
|
|
;
|
|
else
|
|
#endif
|
|
if (sizeof(long double) == LDOUBLE_SIZE)
|
|
*(long double*)ptr = vtop->c.ld;
|
|
else if (sizeof(double) == LDOUBLE_SIZE)
|
|
*(double *)ptr = (double)vtop->c.ld;
|
|
else
|
|
tcc_error("can't cross compile long double constants");
|
|
break;
|
|
#if PTR_SIZE != 8
|
|
case VT_LLONG:
|
|
*(long long *)ptr = vtop->c.i;
|
|
break;
|
|
#else
|
|
case VT_LLONG:
|
|
#endif
|
|
case VT_PTR:
|
|
{
|
|
addr_t val = vtop->c.i;
|
|
#if PTR_SIZE == 8
|
|
if (vtop->r & VT_SYM)
|
|
greloca(sec, vtop->sym, c, R_DATA_PTR, val);
|
|
else
|
|
*(addr_t *)ptr = val;
|
|
#else
|
|
if (vtop->r & VT_SYM)
|
|
greloc(sec, vtop->sym, c, R_DATA_PTR);
|
|
*(addr_t *)ptr = val;
|
|
#endif
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
int val = vtop->c.i;
|
|
#if PTR_SIZE == 8
|
|
if (vtop->r & VT_SYM)
|
|
greloca(sec, vtop->sym, c, R_DATA_PTR, val);
|
|
else
|
|
*(int *)ptr = val;
|
|
#else
|
|
if (vtop->r & VT_SYM)
|
|
greloc(sec, vtop->sym, c, R_DATA_PTR);
|
|
*(int *)ptr = val;
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
vtop--;
|
|
} else {
|
|
vset(&dtype, VT_LOCAL|VT_LVAL, c);
|
|
vswap();
|
|
vstore();
|
|
vpop();
|
|
}
|
|
}
|
|
|
|
/* '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 (!p->sec && tcc_state->do_debug)
|
|
tcc_debug_line(tcc_state);
|
|
|
|
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)) {
|
|
parse_init_elem(!p->sec ? EXPR_ANY : EXPR_CONST);
|
|
flags |= DIF_HAVE_ELEM;
|
|
}
|
|
|
|
if ((flags & DIF_HAVE_ELEM) &&
|
|
!(type->t & VT_ARRAY) &&
|
|
/* 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 init_putv;
|
|
|
|
} else 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;
|
|
}
|
|
|
|
if (!(flags & DIF_SIZE_ONLY)) {
|
|
int nb = n;
|
|
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 {
|
|
decl_design_flex(p, s, len);
|
|
}
|
|
} 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;
|
|
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 ((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 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 */
|
|
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);
|
|
}
|
|
init_putv:
|
|
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 scope)
|
|
{
|
|
int size, align, addr;
|
|
TokenString *init_str = NULL;
|
|
|
|
Section *sec;
|
|
Sym *flexible_array;
|
|
Sym *sym = NULL;
|
|
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 |= 0x80000000;
|
|
|
|
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) {
|
|
/* 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, -1);
|
|
tok_str_add(init_str, 0);
|
|
} 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--;
|
|
}
|
|
#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--;
|
|
}
|
|
#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 {
|
|
if (v && scope == VT_CONST) {
|
|
/* see if the symbol was already defined */
|
|
sym = sym_find(v);
|
|
if (sym) {
|
|
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) {
|
|
if (has_init)
|
|
sec = data_section;
|
|
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 current stack pointer */
|
|
if (root_scope->vla.loc == 0) {
|
|
struct scope *v = cur_scope;
|
|
gen_vla_sp_save(loc -= PTR_SIZE);
|
|
do v->vla.loc = loc; while ((v = v->prev));
|
|
}
|
|
|
|
vla_runtime_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;
|
|
}
|
|
|
|
/* 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);
|
|
}
|
|
/* 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);
|
|
|
|
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;
|
|
|
|
/* 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);
|
|
local_scope = 0;
|
|
rsym = 0;
|
|
clear_temp_local_var_list();
|
|
block(0);
|
|
gsym(rsym);
|
|
nocode_wanted = 0;
|
|
/* reset local stack */
|
|
pop_local_syms(&local_stack, NULL, 0, func_var);
|
|
gfunc_epilog();
|
|
cur_text_section->data_offset = ind;
|
|
local_scope = 0;
|
|
label_pop(&global_label_stack, NULL, 0);
|
|
sym_pop(&all_cleanups, NULL, 0);
|
|
/* patch symbol size */
|
|
elfsym(sym)->st_size = ind - func_ind;
|
|
/* end of function */
|
|
tcc_debug_funcend(tcc_state, ind - func_ind);
|
|
/* It's better to crash than to generate wrong code */
|
|
cur_text_section = NULL;
|
|
funcname = ""; /* for safety */
|
|
func_vt.t = VT_VOID; /* for safety */
|
|
func_var = 0; /* for safety */
|
|
ind = 0; /* for safety */
|
|
nocode_wanted = 0x80000000;
|
|
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);
|
|
}
|
|
|
|
/* 'l' is VT_LOCAL or VT_CONST to define default storage type, or VT_CMP
|
|
if parsing old style parameter decl list (and FUNC_SYM is set then) */
|
|
static int decl0(int l, int is_for_loop_init, Sym *func_sym)
|
|
{
|
|
int v, has_init, r, oldint;
|
|
CType type, btype;
|
|
Sym *sym;
|
|
AttributeDef ad, adbase;
|
|
|
|
while (1) {
|
|
if (tok == TOK_STATIC_ASSERT) {
|
|
CString error_str;
|
|
int c;
|
|
|
|
next();
|
|
skip('(');
|
|
c = expr_const();
|
|
|
|
if (tok == ')') {
|
|
if (!c)
|
|
tcc_error("_Static_assert fail");
|
|
next();
|
|
goto static_assert_out;
|
|
}
|
|
|
|
skip(',');
|
|
parse_mult_str(&error_str, "string constant");
|
|
if (c == 0)
|
|
tcc_error("%s", (char *)error_str.data);
|
|
cstr_free(&error_str);
|
|
skip(')');
|
|
static_assert_out:
|
|
skip(';');
|
|
continue;
|
|
}
|
|
|
|
oldint = 0;
|
|
if (!parse_btype(&btype, &adbase)) {
|
|
if (is_for_loop_init)
|
|
return 0;
|
|
/* skip redundant ';' if not in old parameter decl scope */
|
|
if (tok == ';' && l != VT_CMP) {
|
|
next();
|
|
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_LOCAL))
|
|
tcc_error("function without file scope cannot be static");
|
|
/* if old style function prototype, we accept a
|
|
declaration list */
|
|
sym = type.ref;
|
|
if (sym->f.func_type == FUNC_OLD && l == VT_CONST)
|
|
decl0(VT_CMP, 0, sym);
|
|
#ifdef TCC_TARGET_MACHO
|
|
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;
|
|
skip_or_save_block(&fn->func_str);
|
|
dynarray_add(&tcc_state->inline_fns,
|
|
&tcc_state->nb_inline_fns, fn);
|
|
} else {
|
|
/* compute text section */
|
|
cur_text_section = ad.section;
|
|
if (!cur_text_section)
|
|
cur_text_section = text_section;
|
|
gen_function(sym);
|
|
}
|
|
break;
|
|
} else {
|
|
if (l == VT_CMP) {
|
|
/* find parameter in function parameter list */
|
|
for (sym = func_sym->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;
|
|
sym->f = ad.f;
|
|
if (tcc_state->do_debug)
|
|
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 */
|
|
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);
|
|
if (ad.alias_target) {
|
|
/* 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, esym->st_shndx,
|
|
esym->st_value, esym->st_size, 1);
|
|
}
|
|
} else {
|
|
if (type.t & VT_STATIC)
|
|
r |= VT_CONST;
|
|
else
|
|
r |= l;
|
|
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);
|
|
}
|
|
}
|
|
if (tok != ',') {
|
|
if (is_for_loop_init)
|
|
return 1;
|
|
skip(';');
|
|
break;
|
|
}
|
|
next();
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void decl(int l)
|
|
{
|
|
decl0(l, 0, NULL);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
#undef gjmp_addr
|
|
#undef gjmp
|
|
/* ------------------------------------------------------------------------- */
|