WebSVN – Kolibri OS – Blame – /programs/develop/ktcc/trunk/source/tccgen.c

Rev	Author	Line No.	Line
6429	siemargl	1	/*
		2	* TCC - Tiny C Compiler
		3	*
		4	* Copyright (c) 2001-2004 Fabrice Bellard
		5	*
		6	* This library is free software; you can redistribute it and/or
		7	* modify it under the terms of the GNU Lesser General Public
		8	* License as published by the Free Software Foundation; either
		9	* version 2 of the License, or (at your option) any later version.
		10	*
		11	* This library is distributed in the hope that it will be useful,
		12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		14	* Lesser General Public License for more details.
		15	*
		16	* You should have received a copy of the GNU Lesser General Public
		17	* License along with this library; if not, write to the Free Software
		18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		19	*/
		20
		21	#include "tcc.h"
		22
		23	/********************************************************/
		24	/* global variables */
		25
		26	/* loc : local variable index
		27	ind : output code index
		28	rsym: return symbol
		29	anon_sym: anonymous symbol index
		30	*/
		31	ST_DATA int rsym, anon_sym, ind, loc;
		32
		33	ST_DATA Section text_section, data_section, bss_section; / predefined sections */
		34	ST_DATA Section cur_text_section; / current section where function code is generated */
		35	#ifdef CONFIG_TCC_ASM
		36	ST_DATA Section last_text_section; / to handle .previous asm directive */
		37	#endif
		38	#ifdef CONFIG_TCC_BCHECK
		39	/* bound check related sections */
		40	ST_DATA Section bounds_section; / contains global data bound description */
		41	ST_DATA Section lbounds_section; / contains local data bound description */
		42	#endif
		43	/* symbol sections */
		44	ST_DATA Section symtab_section, strtab_section;
		45	/* debug sections */
		46	ST_DATA Section stab_section, stabstr_section;
		47	ST_DATA Sym *sym_free_first;
		48	ST_DATA void **sym_pools;
		49	ST_DATA int nb_sym_pools;
		50
		51	ST_DATA Sym *global_stack;
		52	ST_DATA Sym *local_stack;
		53	ST_DATA Sym *scope_stack_bottom;
		54	ST_DATA Sym *define_stack;
		55	ST_DATA Sym *global_label_stack;
		56	ST_DATA Sym *local_label_stack;
		57
		58	ST_DATA int vlas_in_scope; /* number of VLAs that are currently in scope */
		59	ST_DATA int vla_sp_root_loc; /* vla_sp_loc for SP before any VLAs were pushed */
		60	ST_DATA int vla_sp_loc; /* Pointer to variable holding location to store stack pointer on the stack when modifying stack pointer */
		61
		62	ST_DATA SValue __vstack[1+VSTACK_SIZE], vtop, pvtop;
		63
		64	ST_DATA int const_wanted; /* true if constant wanted */
		65	ST_DATA int nocode_wanted; /* true if no code generation wanted for an expression */
		66	ST_DATA int global_expr; /* true if compound literals must be allocated globally (used during initializers parsing */
		67	ST_DATA CType func_vt; /* current function return type (used by return instruction) */
		68	ST_DATA int func_var; /* true if current function is variadic (used by return instruction) */
		69	ST_DATA int func_vc;
		70	ST_DATA int last_line_num, last_ind, func_ind; /* debug last line number and pc */
		71	ST_DATA const char *funcname;
		72
		73	ST_DATA CType char_pointer_type, func_old_type, int_type, size_type;
		74
		75	/* ------------------------------------------------------------------------- */
		76	static void gen_cast(CType *type);
		77	static inline CType pointed_type(CType type);
		78	static int is_compatible_types(CType type1, CType type2);
		79	static int parse_btype(CType type, AttributeDef ad);
		80	static void type_decl(CType type, AttributeDef ad, int *v, int td);
		81	static void parse_expr_type(CType *type);
		82	static void decl_initializer(CType type, Section sec, unsigned long c, int first, int size_only);
		83	static void block(int bsym, int csym, int case_sym, int def_sym, int case_reg, int is_expr);
		84	static void decl_initializer_alloc(CType type, AttributeDef ad, int r, int has_init, int v, int scope);
		85	static int decl0(int l, int is_for_loop_init);
		86	static void expr_eq(void);
		87	static void expr_lor_const(void);
		88	static void unary_type(CType *type);
		89	static void vla_runtime_type_size(CType type, int a);
		90	static void vla_sp_restore(void);
		91	static void vla_sp_restore_root(void);
		92	static int is_compatible_parameter_types(CType type1, CType type2);
		93	static void expr_type(CType *type);
		94	ST_FUNC void vpush64(int ty, unsigned long long v);
		95	ST_FUNC void vpush(CType *type);
		96	ST_FUNC int gvtst(int inv, int t);
		97	ST_FUNC int is_btype_size(int bt);
		98
		99	ST_INLN int is_float(int t)
		100	{
		101	int bt;
		102	bt = t & VT_BTYPE;
		103	return bt == VT_LDOUBLE \|\| bt == VT_DOUBLE \|\| bt == VT_FLOAT \|\| bt == VT_QFLOAT;
		104	}
		105
		106	/* we use our own 'finite' function to avoid potential problems with
		107	non standard math libs */
		108	/* XXX: endianness dependent */
		109	ST_FUNC int ieee_finite(double d)
		110	{
		111	int p[4];
		112	memcpy(p, &d, sizeof(double));
		113	return ((unsigned)((p[1] \| 0x800fffff) + 1)) >> 31;
		114	}
		115
		116	ST_FUNC void test_lvalue(void)
		117	{
		118	if (!(vtop->r & VT_LVAL))
		119	expect("lvalue");
		120	}
		121
		122	ST_FUNC void check_vstack(void)
		123	{
		124	if (pvtop != vtop)
		125	tcc_error("internal compiler error: vstack leak (%d)", vtop - pvtop);
		126	}
		127
		128	/* ------------------------------------------------------------------------- */
		129	/* symbol allocator */
		130	static Sym *__sym_malloc(void)
		131	{
		132	Sym sym_pool, sym, *last_sym;
		133	int i;
		134
		135	sym_pool = tcc_malloc(SYM_POOL_NB * sizeof(Sym));
		136	dynarray_add(&sym_pools, &nb_sym_pools, sym_pool);
		137
		138	last_sym = sym_free_first;
		139	sym = sym_pool;
		140	for(i = 0; i < SYM_POOL_NB; i++) {
		141	sym->next = last_sym;
		142	last_sym = sym;
		143	sym++;
		144	}
		145	sym_free_first = last_sym;
		146	return last_sym;
		147	}
		148
		149	static inline Sym *sym_malloc(void)
		150	{
		151	Sym *sym;
		152	sym = sym_free_first;
		153	if (!sym)
		154	sym = __sym_malloc();
		155	sym_free_first = sym->next;
		156	return sym;
		157	}
		158
		159	ST_INLN void sym_free(Sym *sym)
		160	{
		161	sym->next = sym_free_first;
		162	sym_free_first = sym;
		163	}
		164
		165	/* push, without hashing */
		166	ST_FUNC Sym sym_push2(Sym *ps, int v, int t, long c)
		167	{
		168	Sym *s;
		169	if (ps == &local_stack) {
		170	for (s = *ps; s && s != scope_stack_bottom; s = s->prev)
		171	if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM && s->v == v)
		172	tcc_error("incompatible types for redefinition of '%s'",
		173	get_tok_str(v, NULL));
		174	}
		175	s = sym_malloc();
		176	s->asm_label = 0;
		177	s->v = v;
		178	s->type.t = t;
		179	s->type.ref = NULL;
		180	#ifdef _WIN64
		181	s->d = NULL;
		182	#endif
		183	s->c = c;
		184	s->next = NULL;
		185	/* add in stack */
		186	s->prev = *ps;
		187	*ps = s;
		188	return s;
		189	}
		190
		191	/* find a symbol and return its associated structure. 's' is the top
		192	of the symbol stack */
		193	ST_FUNC Sym sym_find2(Sym s, int v)
		194	{
		195	while (s) {
		196	if (s->v == v)
		197	return s;
		198	else if (s->v == -1)
		199	return NULL;
		200	s = s->prev;
		201	}
		202	return NULL;
		203	}
		204
		205	/* structure lookup */
		206	ST_INLN Sym *struct_find(int v)
		207	{
		208	v -= TOK_IDENT;
		209	if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
		210	return NULL;
		211	return table_ident[v]->sym_struct;
		212	}
		213
		214	/* find an identifier */
		215	ST_INLN Sym *sym_find(int v)
		216	{
		217	v -= TOK_IDENT;
		218	if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
		219	return NULL;
		220	return table_ident[v]->sym_identifier;
		221	}
		222
		223	/* push a given symbol on the symbol stack */
		224	ST_FUNC Sym sym_push(int v, CType type, int r, int c)
		225	{
		226	Sym s, *ps;
		227	TokenSym *ts;
		228
		229	if (local_stack)
		230	ps = &local_stack;
		231	else
		232	ps = &global_stack;
		233	s = sym_push2(ps, v, type->t, c);
		234	s->type.ref = type->ref;
		235	s->r = r;
		236	/* don't record fields or anonymous symbols */
		237	/* XXX: simplify */
		238	if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
		239	/* record symbol in token array */
		240	ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT];
		241	if (v & SYM_STRUCT)
		242	ps = &ts->sym_struct;
		243	else
		244	ps = &ts->sym_identifier;
		245	s->prev_tok = *ps;
		246	*ps = s;
		247	}
		248	return s;
		249	}
		250
		251	/* push a global identifier */
		252	ST_FUNC Sym *global_identifier_push(int v, int t, int c)
		253	{
		254	Sym s, *ps;
		255	s = sym_push2(&global_stack, v, t, c);
		256	/* don't record anonymous symbol */
		257	if (v < SYM_FIRST_ANOM) {
		258	ps = &table_ident[v - TOK_IDENT]->sym_identifier;
		259	/* modify the top most local identifier, so that
		260	sym_identifier will point to 's' when popped */
		261	while (*ps != NULL)
		262	ps = &(*ps)->prev_tok;
		263	s->prev_tok = NULL;
		264	*ps = s;
		265	}
		266	return s;
		267	}
		268
		269	/* pop symbols until top reaches 'b' */
		270	ST_FUNC void sym_pop(Sym *ptop, Sym b)
		271	{
		272	Sym s, ss, **ps;
		273	TokenSym *ts;
		274	int v;
		275
		276	s = *ptop;
		277	while(s != b) {
		278	ss = s->prev;
		279	v = s->v;
		280	/* remove symbol in token array */
		281	/* XXX: simplify */
		282	if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
		283	ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT];
		284	if (v & SYM_STRUCT)
		285	ps = &ts->sym_struct;
		286	else
		287	ps = &ts->sym_identifier;
		288	*ps = s->prev_tok;
		289	}
		290	sym_free(s);
		291	s = ss;
		292	}
		293	*ptop = b;
		294	}
		295
		296	static void weaken_symbol(Sym *sym)
		297	{
		298	sym->type.t \|= VT_WEAK;
		299	if (sym->c > 0) {
		300	int esym_type;
		301	ElfW(Sym) *esym;
		302
		303	esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
		304	esym_type = ELFW(ST_TYPE)(esym->st_info);
		305	esym->st_info = ELFW(ST_INFO)(STB_WEAK, esym_type);
		306	}
		307	}
		308
		309	static void apply_visibility(Sym sym, CType type)
		310	{
		311	int vis = sym->type.t & VT_VIS_MASK;
		312	int vis2 = type->t & VT_VIS_MASK;
		313	if (vis == (STV_DEFAULT << VT_VIS_SHIFT))
		314	vis = vis2;
		315	else if (vis2 == (STV_DEFAULT << VT_VIS_SHIFT))
		316	;
		317	else
		318	vis = (vis < vis2) ? vis : vis2;
		319	sym->type.t &= ~VT_VIS_MASK;
		320	sym->type.t \|= vis;
		321
		322	if (sym->c > 0) {
		323	ElfW(Sym) *esym;
		324
		325	esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
		326	vis >>= VT_VIS_SHIFT;
		327	esym->st_other = (esym->st_other & ~ELFW(ST_VISIBILITY)(-1)) \| vis;
		328	}
		329	}
		330
		331	/* ------------------------------------------------------------------------- */
		332
		333	ST_FUNC void swap(int p, int q)
		334	{
		335	int t;
		336	t = *p;
		337	p = q;
		338	*q = t;
		339	}
		340
		341	static void vsetc(CType type, int r, CValue vc)
		342	{
		343	int v;
		344
		345	if (vtop >= vstack + (VSTACK_SIZE - 1))
		346	tcc_error("memory full (vstack)");
		347	/* cannot let cpu flags if other instruction are generated. Also
		348	avoid leaving VT_JMP anywhere except on the top of the stack
		349	because it would complicate the code generator. */
		350	if (vtop >= vstack) {
		351	v = vtop->r & VT_VALMASK;
		352	if (v == VT_CMP \|\| (v & ~1) == VT_JMP)
		353	gv(RC_INT);
		354	}
		355	vtop++;
		356	vtop->type = *type;
		357	vtop->r = r;
		358	vtop->r2 = VT_CONST;
		359	vtop->c = *vc;
		360	}
		361
		362	/* push constant of type "type" with useless value */
		363	ST_FUNC void vpush(CType *type)
		364	{
		365	CValue cval;
		366	vsetc(type, VT_CONST, &cval);
		367	}
		368
		369	/* push integer constant */
		370	ST_FUNC void vpushi(int v)
		371	{
		372	CValue cval;
		373	cval.i = v;
		374	vsetc(&int_type, VT_CONST, &cval);
		375	}
		376
		377	/* push a pointer sized constant */
		378	static void vpushs(addr_t v)
		379	{
		380	CValue cval;
		381	cval.i = v;
		382	vsetc(&size_type, VT_CONST, &cval);
		383	}
		384
		385	/* push arbitrary 64bit constant */
		386	ST_FUNC void vpush64(int ty, unsigned long long v)
		387	{
		388	CValue cval;
		389	CType ctype;
		390	ctype.t = ty;
		391	ctype.ref = NULL;
		392	cval.i = v;
		393	vsetc(&ctype, VT_CONST, &cval);
		394	}
		395
		396	/* push long long constant */
		397	static inline void vpushll(long long v)
		398	{
		399	vpush64(VT_LLONG, v);
		400	}
		401
		402	/* push a symbol value of TYPE */
		403	static inline void vpushsym(CType type, Sym sym)
		404	{
		405	CValue cval;
		406	cval.i = 0;
		407	vsetc(type, VT_CONST \| VT_SYM, &cval);
		408	vtop->sym = sym;
		409	}
		410
		411	/* Return a static symbol pointing to a section */
		412	ST_FUNC Sym get_sym_ref(CType type, Section *sec, unsigned long offset, unsigned long size)
		413	{
		414	int v;
		415	Sym *sym;
		416
		417	v = anon_sym++;
		418	sym = global_identifier_push(v, type->t \| VT_STATIC, 0);
		419	sym->type.ref = type->ref;
		420	sym->r = VT_CONST \| VT_SYM;
		421	put_extern_sym(sym, sec, offset, size);
		422	return sym;
		423	}
		424
		425	/* push a reference to a section offset by adding a dummy symbol */
		426	static void vpush_ref(CType type, Section sec, unsigned long offset, unsigned long size)
		427	{
		428	vpushsym(type, get_sym_ref(type, sec, offset, size));
		429	}
		430
		431	/* define a new external reference to a symbol 'v' of type 'u' */
		432	ST_FUNC Sym external_global_sym(int v, CType type, int r)
		433	{
		434	Sym *s;
		435
		436	s = sym_find(v);
		437	if (!s) {
		438	/* push forward reference */
		439	s = global_identifier_push(v, type->t \| VT_EXTERN, 0);
		440	s->type.ref = type->ref;
		441	s->r = r \| VT_CONST \| VT_SYM;
		442	}
		443	return s;
		444	}
		445
		446	/* define a new external reference to a symbol 'v' */
		447	static Sym external_sym(int v, CType type, int r)
		448	{
		449	Sym *s;
		450
		451	s = sym_find(v);
		452	if (!s) {
		453	/* push forward reference */
		454	s = sym_push(v, type, r \| VT_CONST \| VT_SYM, 0);
		455	s->type.t \|= VT_EXTERN;
		456	} else if (s->type.ref == func_old_type.ref) {
		457	s->type.ref = type->ref;
		458	s->r = r \| VT_CONST \| VT_SYM;
		459	s->type.t \|= VT_EXTERN;
		460	} else if (!is_compatible_types(&s->type, type)) {
		461	tcc_error("incompatible types for redefinition of '%s'",
		462	get_tok_str(v, NULL));
		463	}
		464	/* Merge some storage attributes. */
		465	if (type->t & VT_WEAK)
		466	weaken_symbol(s);
		467
		468	if (type->t & VT_VIS_MASK)
		469	apply_visibility(s, type);
		470
		471	return s;
		472	}
		473
		474	/* push a reference to global symbol v */
		475	ST_FUNC void vpush_global_sym(CType *type, int v)
		476	{
		477	vpushsym(type, external_global_sym(v, type, 0));
		478	}
		479
		480	ST_FUNC void vset(CType *type, int r, int v)
		481	{
		482	CValue cval;
		483
		484	cval.i = v;
		485	vsetc(type, r, &cval);
		486	}
		487
		488	static void vseti(int r, int v)
		489	{
		490	CType type;
		491	type.t = VT_INT;
		492	type.ref = 0;
		493	vset(&type, r, v);
		494	}
		495
		496	ST_FUNC void vswap(void)
		497	{
		498	SValue tmp;
		499	/* cannot let cpu flags if other instruction are generated. Also
		500	avoid leaving VT_JMP anywhere except on the top of the stack
		501	because it would complicate the code generator. */
		502	if (vtop >= vstack) {
		503	int v = vtop->r & VT_VALMASK;
		504	if (v == VT_CMP \|\| (v & ~1) == VT_JMP)
		505	gv(RC_INT);
		506	}
		507	tmp = vtop[0];
		508	vtop[0] = vtop[-1];
		509	vtop[-1] = tmp;
		510
		511	/* XXX: +2% overall speed possible with optimized memswap
		512	*
		513	* memswap(&vtop[0], &vtop[1], sizeof *vtop);
		514	*/
		515	}
		516
		517	ST_FUNC void vpushv(SValue *v)
		518	{
		519	if (vtop >= vstack + (VSTACK_SIZE - 1))
		520	tcc_error("memory full (vstack)");
		521	vtop++;
		522	vtop = v;
		523	}
		524
		525	static void vdup(void)
		526	{
		527	vpushv(vtop);
		528	}
		529
		530	/* save r to the memory stack, and mark it as being free */
		531	ST_FUNC void save_reg(int r)
		532	{
		533	int l, saved, size, align;
		534	SValue *p, sv;
		535	CType *type;
		536
		537	/* modify all stack values */
		538	saved = 0;
		539	l = 0;
		540	for(p=vstack;p<=vtop;p++) {
		541	if ((p->r & VT_VALMASK) == r \|\|
		542	((p->type.t & VT_BTYPE) == VT_LLONG && (p->r2 & VT_VALMASK) == r)) {
		543	/* must save value on stack if not already done */
		544	if (!saved) {
		545	/* NOTE: must reload 'r' because r might be equal to r2 */
		546	r = p->r & VT_VALMASK;
		547	/* store register in the stack */
		548	type = &p->type;
		549	if ((p->r & VT_LVAL) \|\|
		550	(!is_float(type->t) && (type->t & VT_BTYPE) != VT_LLONG))
		551	#if defined(TCC_TARGET_ARM64) \|\| defined(TCC_TARGET_X86_64)
		552	type = &char_pointer_type;
		553	#else
		554	type = &int_type;
		555	#endif
		556	size = type_size(type, &align);
		557	loc = (loc - size) & -align;
		558	sv.type.t = type->t;
		559	sv.r = VT_LOCAL \| VT_LVAL;
		560	sv.c.i = loc;
		561	store(r, &sv);
		562	#if defined(TCC_TARGET_I386) \|\| defined(TCC_TARGET_X86_64)
		563	/* x86 specific: need to pop fp register ST0 if saved */
		564	if (r == TREG_ST0) {
		565	o(0xd8dd); /* fstp %st(0) */
		566	}
		567	#endif
		568	#if !defined(TCC_TARGET_ARM64) && !defined(TCC_TARGET_X86_64)
		569	/* special long long case */
		570	if ((type->t & VT_BTYPE) == VT_LLONG) {
		571	sv.c.i += 4;
		572	store(p->r2, &sv);
		573	}
		574	#endif
		575	l = loc;
		576	saved = 1;
		577	}
		578	/* mark that stack entry as being saved on the stack */
		579	if (p->r & VT_LVAL) {
		580	/* also clear the bounded flag because the
		581	relocation address of the function was stored in
		582	p->c.i */
		583	p->r = (p->r & ~(VT_VALMASK \| VT_BOUNDED)) \| VT_LLOCAL;
		584	} else {
		585	p->r = lvalue_type(p->type.t) \| VT_LOCAL;
		586	}
		587	p->r2 = VT_CONST;
		588	p->c.i = l;
		589	}
		590	}
		591	}
		592
		593	#ifdef TCC_TARGET_ARM
		594	/* find a register of class 'rc2' with at most one reference on stack.
		595	* If none, call get_reg(rc) */
		596	ST_FUNC int get_reg_ex(int rc, int rc2)
		597	{
		598	int r;
		599	SValue *p;
		600
		601	for(r=0;r
		602	if (reg_classes[r] & rc2) {
		603	int n;
		604	n=0;
		605	for(p = vstack; p <= vtop; p++) {
		606	if ((p->r & VT_VALMASK) == r \|\|
		607	(p->r2 & VT_VALMASK) == r)
		608	n++;
		609	}
		610	if (n <= 1)
		611	return r;
		612	}
		613	}
		614	return get_reg(rc);
		615	}
		616	#endif
		617
		618	/* find a free register of class 'rc'. If none, save one register */
		619	ST_FUNC int get_reg(int rc)
		620	{
		621	int r;
		622	SValue *p;
		623
		624	/* find a free register */
		625	for(r=0;r
		626	if (reg_classes[r] & rc) {
		627	for(p=vstack;p<=vtop;p++) {
		628	if ((p->r & VT_VALMASK) == r \|\|
		629	(p->r2 & VT_VALMASK) == r)
		630	goto notfound;
		631	}
		632	return r;
		633	}
		634	notfound: ;
		635	}
		636
		637	/* no register left : free the first one on the stack (VERY
		638	IMPORTANT to start from the bottom to ensure that we don't
		639	spill registers used in gen_opi()) */
		640	for(p=vstack;p<=vtop;p++) {
		641	/* look at second register (if long long) */
		642	r = p->r2 & VT_VALMASK;
		643	if (r < VT_CONST && (reg_classes[r] & rc))
		644	goto save_found;
		645	r = p->r & VT_VALMASK;
		646	if (r < VT_CONST && (reg_classes[r] & rc)) {
		647	save_found:
		648	save_reg(r);
		649	return r;
		650	}
		651	}
		652	/* Should never comes here */
		653	return -1;
		654	}
		655
		656	/* save registers up to (vtop - n) stack entry */
		657	ST_FUNC void save_regs(int n)
		658	{
		659	int r;
		660	SValue p, p1;
		661	p1 = vtop - n;
		662	for(p = vstack;p <= p1; p++) {
		663	r = p->r & VT_VALMASK;
		664	if (r < VT_CONST) {
		665	save_reg(r);
		666	}
		667	}
		668	}
		669
		670	/* move register 's' (of type 't') to 'r', and flush previous value of r to memory
		671	if needed */
		672	static void move_reg(int r, int s, int t)
		673	{
		674	SValue sv;
		675
		676	if (r != s) {
		677	save_reg(r);
		678	sv.type.t = t;
		679	sv.type.ref = NULL;
		680	sv.r = s;
		681	sv.c.i = 0;
		682	load(r, &sv);
		683	}
		684	}
		685
		686	/* get address of vtop (vtop MUST BE an lvalue) */
		687	ST_FUNC void gaddrof(void)
		688	{
		689	if (vtop->r & VT_REF && !nocode_wanted)
		690	gv(RC_INT);
		691	vtop->r &= ~VT_LVAL;
		692	/* tricky: if saved lvalue, then we can go back to lvalue */
		693	if ((vtop->r & VT_VALMASK) == VT_LLOCAL)
		694	vtop->r = (vtop->r & ~(VT_VALMASK \| VT_LVAL_TYPE)) \| VT_LOCAL \| VT_LVAL;
		695
		696
		697	}
		698
		699	#ifdef CONFIG_TCC_BCHECK
		700	/* generate lvalue bound code */
		701	static void gbound(void)
		702	{
		703	int lval_type;
		704	CType type1;
		705
		706	vtop->r &= ~VT_MUSTBOUND;
		707	/* if lvalue, then use checking code before dereferencing */
		708	if (vtop->r & VT_LVAL) {
		709	/* if not VT_BOUNDED value, then make one */
		710	if (!(vtop->r & VT_BOUNDED)) {
		711	lval_type = vtop->r & (VT_LVAL_TYPE \| VT_LVAL);
		712	/* must save type because we must set it to int to get pointer */
		713	type1 = vtop->type;
		714	vtop->type.t = VT_PTR;
		715	gaddrof();
		716	vpushi(0);
		717	gen_bounded_ptr_add();
		718	vtop->r \|= lval_type;
		719	vtop->type = type1;
		720	}
		721	/* then check for dereferencing */
		722	gen_bounded_ptr_deref();
		723	}
		724	}
		725	#endif
		726
		727	/* store vtop a register belonging to class 'rc'. lvalues are
		728	converted to values. Cannot be used if cannot be converted to
		729	register value (such as structures). */
		730	ST_FUNC int gv(int rc)
		731	{
		732	int r, bit_pos, bit_size, size, align, i;
		733	int rc2;
		734
		735	/* NOTE: get_reg can modify vstack[] */
		736	if (vtop->type.t & VT_BITFIELD) {
		737	CType type;
		738	int bits = 32;
		739	bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f;
		740	bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
		741	/* remove bit field info to avoid loops */
		742	vtop->type.t &= ~VT_BITFIELD & ((1 << VT_STRUCT_SHIFT) - 1);
		743	/* cast to int to propagate signedness in following ops */
		744	if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
		745	type.t = VT_LLONG;
		746	bits = 64;
		747	} else
		748	type.t = VT_INT;
		749	if((vtop->type.t & VT_UNSIGNED) \|\|
		750	(vtop->type.t & VT_BTYPE) == VT_BOOL)
		751	type.t \|= VT_UNSIGNED;
		752	gen_cast(&type);
		753	/* generate shifts */
		754	vpushi(bits - (bit_pos + bit_size));
		755	gen_op(TOK_SHL);
		756	vpushi(bits - bit_size);
		757	/* NOTE: transformed to SHR if unsigned */
		758	gen_op(TOK_SAR);
		759	r = gv(rc);
		760	} else {
		761	if (is_float(vtop->type.t) &&
		762	(vtop->r & (VT_VALMASK \| VT_LVAL)) == VT_CONST) {
		763	Sym *sym;
		764	int *ptr;
		765	unsigned long offset;
		766	#if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
		767	CValue check;
		768	#endif
		769
		770	/* XXX: unify with initializers handling ? */
		771	/* CPUs usually cannot use float constants, so we store them
		772	generically in data segment */
		773	size = type_size(&vtop->type, &align);
		774	offset = (data_section->data_offset + align - 1) & -align;
		775	data_section->data_offset = offset;
		776	/* XXX: not portable yet */
		777	#if defined(__i386__) \|\| defined(__x86_64__)
		778	/* Zero pad x87 tenbyte long doubles */
		779	if (size == LDOUBLE_SIZE) {
		780	vtop->c.tab[2] &= 0xffff;
		781	#if LDOUBLE_SIZE == 16
		782	vtop->c.tab[3] = 0;
		783	#endif
		784	}
		785	#endif
		786	ptr = section_ptr_add(data_section, size);
		787	size = size >> 2;
		788	#if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
		789	check.d = 1;
		790	if(check.tab[0])
		791	for(i=0;i
		792	ptr[i] = vtop->c.tab[size-1-i];
		793	else
		794	#endif
		795	for(i=0;i
		796	ptr[i] = vtop->c.tab[i];
		797	sym = get_sym_ref(&vtop->type, data_section, offset, size << 2);
		798	vtop->r \|= VT_LVAL \| VT_SYM;
		799	vtop->sym = sym;
		800	vtop->c.i = 0;
		801	}
		802	#ifdef CONFIG_TCC_BCHECK
		803	if (vtop->r & VT_MUSTBOUND)
		804	gbound();
		805	#endif
		806
		807	r = vtop->r & VT_VALMASK;
		808	rc2 = (rc & RC_FLOAT) ? RC_FLOAT : RC_INT;
		809	#ifndef TCC_TARGET_ARM64
		810	if (rc == RC_IRET)
		811	rc2 = RC_LRET;
		812	#ifdef TCC_TARGET_X86_64
		813	else if (rc == RC_FRET)
		814	rc2 = RC_QRET;
		815	#endif
		816	#endif
		817
		818	/* need to reload if:
		819	- constant
		820	- lvalue (need to dereference pointer)
		821	- already a register, but not in the right class */
		822	if (r >= VT_CONST
		823	\|\| (vtop->r & VT_LVAL)
		824	\|\| !(reg_classes[r] & rc)
		825	#if defined(TCC_TARGET_ARM64) \|\| defined(TCC_TARGET_X86_64)
		826	\|\| ((vtop->type.t & VT_BTYPE) == VT_QLONG && !(reg_classes[vtop->r2] & rc2))
		827	\|\| ((vtop->type.t & VT_BTYPE) == VT_QFLOAT && !(reg_classes[vtop->r2] & rc2))
		828	#else
		829	\|\| ((vtop->type.t & VT_BTYPE) == VT_LLONG && !(reg_classes[vtop->r2] & rc2))
		830	#endif
		831	)
		832	{
		833	r = get_reg(rc);
		834	#if defined(TCC_TARGET_ARM64) \|\| defined(TCC_TARGET_X86_64)
		835	if (((vtop->type.t & VT_BTYPE) == VT_QLONG) \|\| ((vtop->type.t & VT_BTYPE) == VT_QFLOAT)) {
		836	int addr_type = VT_LLONG, load_size = 8, load_type = ((vtop->type.t & VT_BTYPE) == VT_QLONG) ? VT_LLONG : VT_DOUBLE;
		837	#else
		838	if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
		839	int addr_type = VT_INT, load_size = 4, load_type = VT_INT;
		840	unsigned long long ll;
		841	#endif
		842	int r2, original_type;
		843	original_type = vtop->type.t;
		844	/* two register type load : expand to two words
		845	temporarily */
		846	#if !defined(TCC_TARGET_ARM64) && !defined(TCC_TARGET_X86_64)
		847	if ((vtop->r & (VT_VALMASK \| VT_LVAL)) == VT_CONST) {
		848	/* load constant */
		849	ll = vtop->c.i;
		850	vtop->c.i = ll; /* first word */
		851	load(r, vtop);
		852	vtop->r = r; /* save register value */
		853	vpushi(ll >> 32); /* second word */
		854	} else
		855	#endif
		856	if (r >= VT_CONST \|\| /* XXX: test to VT_CONST incorrect ? */
		857	(vtop->r & VT_LVAL)) {
		858	/* We do not want to modifier the long long
		859	pointer here, so the safest (and less
		860	efficient) is to save all the other registers
		861	in the stack. XXX: totally inefficient. */
		862	save_regs(1);
		863	/* load from memory */
		864	vtop->type.t = load_type;
		865	load(r, vtop);
		866	vdup();
		867	vtop[-1].r = r; /* save register value */
		868	/* increment pointer to get second word */
		869	vtop->type.t = addr_type;
		870	gaddrof();
		871	vpushi(load_size);
		872	gen_op('+');
		873	vtop->r \|= VT_LVAL;
		874	vtop->type.t = load_type;
		875	} else {
		876	/* move registers */
		877	load(r, vtop);
		878	vdup();
		879	vtop[-1].r = r; /* save register value */
		880	vtop->r = vtop[-1].r2;
		881	}
		882	/* Allocate second register. Here we rely on the fact that
		883	get_reg() tries first to free r2 of an SValue. */
		884	r2 = get_reg(rc2);
		885	load(r2, vtop);
		886	vpop();
		887	/* write second register */
		888	vtop->r2 = r2;
		889	vtop->type.t = original_type;
		890	} else if ((vtop->r & VT_LVAL) && !is_float(vtop->type.t)) {
		891	int t1, t;
		892	/* lvalue of scalar type : need to use lvalue type
		893	because of possible cast */
		894	t = vtop->type.t;
		895	t1 = t;
		896	/* compute memory access type */
		897	if (vtop->r & VT_REF)
		898	#if defined(TCC_TARGET_ARM64) \|\| defined(TCC_TARGET_X86_64)
		899	t = VT_PTR;
		900	#else
		901	t = VT_INT;
		902	#endif
		903	else if (vtop->r & VT_LVAL_BYTE)
		904	t = VT_BYTE;
		905	else if (vtop->r & VT_LVAL_SHORT)
		906	t = VT_SHORT;
		907	if (vtop->r & VT_LVAL_UNSIGNED)
		908	t \|= VT_UNSIGNED;
		909	vtop->type.t = t;
		910	load(r, vtop);
		911	/* restore wanted type */
		912	vtop->type.t = t1;
		913	} else {
		914	/* one register type load */
		915	load(r, vtop);
		916	}
		917	}
		918	vtop->r = r;
		919	#ifdef TCC_TARGET_C67
		920	/* uses register pairs for doubles */
		921	if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
		922	vtop->r2 = r+1;
		923	#endif
		924	}
		925	return r;
		926	}
		927
		928	/* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
		929	ST_FUNC void gv2(int rc1, int rc2)
		930	{
		931	int v;
		932
		933	/* generate more generic register first. But VT_JMP or VT_CMP
		934	values must be generated first in all cases to avoid possible
		935	reload errors */
		936	v = vtop[0].r & VT_VALMASK;
		937	if (v != VT_CMP && (v & ~1) != VT_JMP && rc1 <= rc2) {
		938	vswap();
		939	gv(rc1);
		940	vswap();
		941	gv(rc2);
		942	/* test if reload is needed for first register */
		943	if ((vtop[-1].r & VT_VALMASK) >= VT_CONST) {
		944	vswap();
		945	gv(rc1);
		946	vswap();
		947	}
		948	} else {
		949	gv(rc2);
		950	vswap();
		951	gv(rc1);
		952	vswap();
		953	/* test if reload is needed for first register */
		954	if ((vtop[0].r & VT_VALMASK) >= VT_CONST) {
		955	gv(rc2);
		956	}
		957	}
		958	}
		959
		960	#ifndef TCC_TARGET_ARM64
		961	/* wrapper around RC_FRET to return a register by type */
		962	static int rc_fret(int t)
		963	{
		964	#ifdef TCC_TARGET_X86_64
		965	if (t == VT_LDOUBLE) {
		966	return RC_ST0;
		967	}
		968	#endif
		969	return RC_FRET;
		970	}
		971	#endif
		972
		973	/* wrapper around REG_FRET to return a register by type */
		974	static int reg_fret(int t)
		975	{
		976	#ifdef TCC_TARGET_X86_64
		977	if (t == VT_LDOUBLE) {
		978	return TREG_ST0;
		979	}
		980	#endif
		981	return REG_FRET;
		982	}
		983
		984	/* expand long long on stack in two int registers */
		985	static void lexpand(void)
		986	{
		987	int u;
		988
		989	u = vtop->type.t & (VT_DEFSIGN \| VT_UNSIGNED);
		990	gv(RC_INT);
		991	vdup();
		992	vtop[0].r = vtop[-1].r2;
		993	vtop[0].r2 = VT_CONST;
		994	vtop[-1].r2 = VT_CONST;
		995	vtop[0].type.t = VT_INT \| u;
		996	vtop[-1].type.t = VT_INT \| u;
		997	}
		998
		999	#ifdef TCC_TARGET_ARM
		1000	/* expand long long on stack */
		1001	ST_FUNC void lexpand_nr(void)
		1002	{
		1003	int u,v;
		1004
		1005	u = vtop->type.t & (VT_DEFSIGN \| VT_UNSIGNED);
		1006	vdup();
		1007	vtop->r2 = VT_CONST;
		1008	vtop->type.t = VT_INT \| u;
		1009	v=vtop[-1].r & (VT_VALMASK \| VT_LVAL);
		1010	if (v == VT_CONST) {
		1011	vtop[-1].c.i = vtop->c.i;
		1012	vtop->c.i = vtop->c.i >> 32;
		1013	vtop->r = VT_CONST;
		1014	} else if (v == (VT_LVAL\|VT_CONST) \|\| v == (VT_LVAL\|VT_LOCAL)) {
		1015	vtop->c.i += 4;
		1016	vtop->r = vtop[-1].r;
		1017	} else if (v > VT_CONST) {
		1018	vtop--;
		1019	lexpand();
		1020	} else
		1021	vtop->r = vtop[-1].r2;
		1022	vtop[-1].r2 = VT_CONST;
		1023	vtop[-1].type.t = VT_INT \| u;
		1024	}
		1025	#endif
		1026
		1027	/* build a long long from two ints */
		1028	static void lbuild(int t)
		1029	{
		1030	gv2(RC_INT, RC_INT);
		1031	vtop[-1].r2 = vtop[0].r;
		1032	vtop[-1].type.t = t;
		1033	vpop();
		1034	}
		1035
		1036	/* rotate n first stack elements to the bottom
		1037	I1 ... In -> I2 ... In I1 [top is right]
		1038	*/
		1039	ST_FUNC void vrotb(int n)
		1040	{
		1041	int i;
		1042	SValue tmp;
		1043
		1044	tmp = vtop[-n + 1];
		1045	for(i=-n+1;i!=0;i++)
		1046	vtop[i] = vtop[i+1];
		1047	vtop[0] = tmp;
		1048	}
		1049
		1050	/* rotate the n elements before entry e towards the top
		1051	I1 ... In ... -> In I1 ... I(n-1) ... [top is right]
		1052	*/
		1053	ST_FUNC void vrote(SValue *e, int n)
		1054	{
		1055	int i;
		1056	SValue tmp;
		1057
		1058	tmp = *e;
		1059	for(i = 0;i < n - 1; i++)
		1060	e[-i] = e[-i - 1];
		1061	e[-n + 1] = tmp;
		1062	}
		1063
		1064	/* rotate n first stack elements to the top
		1065	I1 ... In -> In I1 ... I(n-1) [top is right]
		1066	*/
		1067	ST_FUNC void vrott(int n)
		1068	{
		1069	vrote(vtop, n);
		1070	}
		1071
		1072	/* pop stack value */
		1073	ST_FUNC void vpop(void)
		1074	{
		1075	int v;
		1076	v = vtop->r & VT_VALMASK;
		1077	#if defined(TCC_TARGET_I386) \|\| defined(TCC_TARGET_X86_64)
		1078	/* for x86, we need to pop the FP stack */
		1079	if (v == TREG_ST0 && !nocode_wanted) {
		1080	o(0xd8dd); /* fstp %st(0) */
		1081	} else
		1082	#endif
		1083	if (v == VT_JMP \|\| v == VT_JMPI) {
		1084	/* need to put correct jump if && or \|\| without test */
		1085	gsym(vtop->c.i);
		1086	}
		1087	vtop--;
		1088	}
		1089
		1090	/* convert stack entry to register and duplicate its value in another
		1091	register */
		1092	static void gv_dup(void)
		1093	{
		1094	int rc, t, r, r1;
		1095	SValue sv;
		1096
		1097	t = vtop->type.t;
		1098	if ((t & VT_BTYPE) == VT_LLONG) {
		1099	lexpand();
		1100	gv_dup();
		1101	vswap();
		1102	vrotb(3);
		1103	gv_dup();
		1104	vrotb(4);
		1105	/* stack: H L L1 H1 */
		1106	lbuild(t);
		1107	vrotb(3);
		1108	vrotb(3);
		1109	vswap();
		1110	lbuild(t);
		1111	vswap();
		1112	} else {
		1113	/* duplicate value */
		1114	rc = RC_INT;
		1115	sv.type.t = VT_INT;
		1116	if (is_float(t)) {
		1117	rc = RC_FLOAT;
		1118	#ifdef TCC_TARGET_X86_64
		1119	if ((t & VT_BTYPE) == VT_LDOUBLE) {
		1120	rc = RC_ST0;
		1121	}
		1122	#endif
		1123	sv.type.t = t;
		1124	}
		1125	r = gv(rc);
		1126	r1 = get_reg(rc);
		1127	sv.r = r;
		1128	sv.c.i = 0;
		1129	load(r1, &sv); /* move r to r1 */
		1130	vdup();
		1131	/* duplicates value */
		1132	if (r != r1)
		1133	vtop->r = r1;
		1134	}
		1135	}
		1136
		1137	/* Generate value test
		1138	*
		1139	* Generate a test for any value (jump, comparison and integers) */
		1140	ST_FUNC int gvtst(int inv, int t)
		1141	{
		1142	int v = vtop->r & VT_VALMASK;
		1143	if (v != VT_CMP && v != VT_JMP && v != VT_JMPI) {
		1144	vpushi(0);
		1145	gen_op(TOK_NE);
		1146	}
		1147	if ((vtop->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == VT_CONST) {
		1148	/* constant jmp optimization */
		1149	if ((vtop->c.i != 0) != inv)
		1150	t = gjmp(t);
		1151	vtop--;
		1152	return t;
		1153	}
		1154	return gtst(inv, t);
		1155	}
		1156
		1157	#if !defined(TCC_TARGET_ARM64) && !defined(TCC_TARGET_X86_64)
		1158	/* generate CPU independent (unsigned) long long operations */
		1159	static void gen_opl(int op)
		1160	{
		1161	int t, a, b, op1, c, i;
		1162	int func;
		1163	unsigned short reg_iret = REG_IRET;
		1164	unsigned short reg_lret = REG_LRET;
		1165	SValue tmp;
		1166
		1167	switch(op) {
		1168	case '/':
		1169	case TOK_PDIV:
		1170	func = TOK___divdi3;
		1171	goto gen_func;
		1172	case TOK_UDIV:
		1173	func = TOK___udivdi3;
		1174	goto gen_func;
		1175	case '%':
		1176	func = TOK___moddi3;
		1177	goto gen_mod_func;
		1178	case TOK_UMOD:
		1179	func = TOK___umoddi3;
		1180	gen_mod_func:
		1181	#ifdef TCC_ARM_EABI
		1182	reg_iret = TREG_R2;
		1183	reg_lret = TREG_R3;
		1184	#endif
		1185	gen_func:
		1186	/* call generic long long function */
		1187	vpush_global_sym(&func_old_type, func);
		1188	vrott(3);
		1189	gfunc_call(2);
		1190	vpushi(0);
		1191	vtop->r = reg_iret;
		1192	vtop->r2 = reg_lret;
		1193	break;
		1194	case '^':
		1195	case '&':
		1196	case '\|':
		1197	case '*':
		1198	case '+':
		1199	case '-':
		1200	t = vtop->type.t;
		1201	vswap();
		1202	lexpand();
		1203	vrotb(3);
		1204	lexpand();
		1205	/* stack: L1 H1 L2 H2 */
		1206	tmp = vtop[0];
		1207	vtop[0] = vtop[-3];
		1208	vtop[-3] = tmp;
		1209	tmp = vtop[-2];
		1210	vtop[-2] = vtop[-3];
		1211	vtop[-3] = tmp;
		1212	vswap();
		1213	/* stack: H1 H2 L1 L2 */
		1214	if (op == '*') {
		1215	vpushv(vtop - 1);
		1216	vpushv(vtop - 1);
		1217	gen_op(TOK_UMULL);
		1218	lexpand();
		1219	/* stack: H1 H2 L1 L2 ML MH */
		1220	for(i=0;i<4;i++)
		1221	vrotb(6);
		1222	/* stack: ML MH H1 H2 L1 L2 */
		1223	tmp = vtop[0];
		1224	vtop[0] = vtop[-2];
		1225	vtop[-2] = tmp;
		1226	/* stack: ML MH H1 L2 H2 L1 */
		1227	gen_op('*');
		1228	vrotb(3);
		1229	vrotb(3);
		1230	gen_op('*');
		1231	/* stack: ML MH M1 M2 */
		1232	gen_op('+');
		1233	gen_op('+');
		1234	} else if (op == '+' \|\| op == '-') {
		1235	/* XXX: add non carry method too (for MIPS or alpha) */
		1236	if (op == '+')
		1237	op1 = TOK_ADDC1;
		1238	else
		1239	op1 = TOK_SUBC1;
		1240	gen_op(op1);
		1241	/* stack: H1 H2 (L1 op L2) */
		1242	vrotb(3);
		1243	vrotb(3);
		1244	gen_op(op1 + 1); /* TOK_xxxC2 */
		1245	} else {
		1246	gen_op(op);
		1247	/* stack: H1 H2 (L1 op L2) */
		1248	vrotb(3);
		1249	vrotb(3);
		1250	/* stack: (L1 op L2) H1 H2 */
		1251	gen_op(op);
		1252	/* stack: (L1 op L2) (H1 op H2) */
		1253	}
		1254	/* stack: L H */
		1255	lbuild(t);
		1256	break;
		1257	case TOK_SAR:
		1258	case TOK_SHR:
		1259	case TOK_SHL:
		1260	if ((vtop->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == VT_CONST) {
		1261	t = vtop[-1].type.t;
		1262	vswap();
		1263	lexpand();
		1264	vrotb(3);
		1265	/* stack: L H shift */
		1266	c = (int)vtop->c.i;
		1267	/* constant: simpler */
		1268	/* NOTE: all comments are for SHL. the other cases are
		1269	done by swaping words */
		1270	vpop();
		1271	if (op != TOK_SHL)
		1272	vswap();
		1273	if (c >= 32) {
		1274	/* stack: L H */
		1275	vpop();
		1276	if (c > 32) {
		1277	vpushi(c - 32);
		1278	gen_op(op);
		1279	}
		1280	if (op != TOK_SAR) {
		1281	vpushi(0);
		1282	} else {
		1283	gv_dup();
		1284	vpushi(31);
		1285	gen_op(TOK_SAR);
		1286	}
		1287	vswap();
		1288	} else {
		1289	vswap();
		1290	gv_dup();
		1291	/* stack: H L L */
		1292	vpushi(c);
		1293	gen_op(op);
		1294	vswap();
		1295	vpushi(32 - c);
		1296	if (op == TOK_SHL)
		1297	gen_op(TOK_SHR);
		1298	else
		1299	gen_op(TOK_SHL);
		1300	vrotb(3);
		1301	/* stack: L L H */
		1302	vpushi(c);
		1303	if (op == TOK_SHL)
		1304	gen_op(TOK_SHL);
		1305	else
		1306	gen_op(TOK_SHR);
		1307	gen_op('\|');
		1308	}
		1309	if (op != TOK_SHL)
		1310	vswap();
		1311	lbuild(t);
		1312	} else {
		1313	/* XXX: should provide a faster fallback on x86 ? */
		1314	switch(op) {
		1315	case TOK_SAR:
		1316	func = TOK___ashrdi3;
		1317	goto gen_func;
		1318	case TOK_SHR:
		1319	func = TOK___lshrdi3;
		1320	goto gen_func;
		1321	case TOK_SHL:
		1322	func = TOK___ashldi3;
		1323	goto gen_func;
		1324	}
		1325	}
		1326	break;
		1327	default:
		1328	/* compare operations */
		1329	t = vtop->type.t;
		1330	vswap();
		1331	lexpand();
		1332	vrotb(3);
		1333	lexpand();
		1334	/* stack: L1 H1 L2 H2 */
		1335	tmp = vtop[-1];
		1336	vtop[-1] = vtop[-2];
		1337	vtop[-2] = tmp;
		1338	/* stack: L1 L2 H1 H2 */
		1339	/* compare high */
		1340	op1 = op;
		1341	/* when values are equal, we need to compare low words. since
		1342	the jump is inverted, we invert the test too. */
		1343	if (op1 == TOK_LT)
		1344	op1 = TOK_LE;
		1345	else if (op1 == TOK_GT)
		1346	op1 = TOK_GE;
		1347	else if (op1 == TOK_ULT)
		1348	op1 = TOK_ULE;
		1349	else if (op1 == TOK_UGT)
		1350	op1 = TOK_UGE;
		1351	a = 0;
		1352	b = 0;
		1353	gen_op(op1);
		1354	if (op1 != TOK_NE) {
		1355	a = gvtst(1, 0);
		1356	}
		1357	if (op != TOK_EQ) {
		1358	/* generate non equal test */
		1359	/* XXX: NOT PORTABLE yet */
		1360	if (a == 0) {
		1361	b = gvtst(0, 0);
		1362	} else {
		1363	#if defined(TCC_TARGET_I386)
		1364	b = psym(0x850f, 0);
		1365	#elif defined(TCC_TARGET_ARM)
		1366	b = ind;
		1367	o(0x1A000000 \| encbranch(ind, 0, 1));
		1368	#elif defined(TCC_TARGET_C67) \|\| defined(TCC_TARGET_ARM64)
		1369	tcc_error("not implemented");
		1370	#else
		1371	#error not supported
		1372	#endif
		1373	}
		1374	}
		1375	/* compare low. Always unsigned */
		1376	op1 = op;
		1377	if (op1 == TOK_LT)
		1378	op1 = TOK_ULT;
		1379	else if (op1 == TOK_LE)
		1380	op1 = TOK_ULE;
		1381	else if (op1 == TOK_GT)
		1382	op1 = TOK_UGT;
		1383	else if (op1 == TOK_GE)
		1384	op1 = TOK_UGE;
		1385	gen_op(op1);
		1386	a = gvtst(1, a);
		1387	gsym(b);
		1388	vseti(VT_JMPI, a);
		1389	break;
		1390	}
		1391	}
		1392	#endif
		1393
		1394	static uint64_t gen_opic_sdiv(uint64_t a, uint64_t b)
		1395	{
		1396	uint64_t x = (a >> 63 ? -a : a) / (b >> 63 ? -b : b);
		1397	return (a ^ b) >> 63 ? -x : x;
		1398	}
		1399
		1400	static int gen_opic_lt(uint64_t a, uint64_t b)
		1401	{
		1402	return (a ^ (uint64_t)1 << 63) < (b ^ (uint64_t)1 << 63);
		1403	}
		1404
		1405	/* handle integer constant optimizations and various machine
		1406	independent opt */
		1407	static void gen_opic(int op)
		1408	{
		1409	SValue *v1 = vtop - 1;
		1410	SValue *v2 = vtop;
		1411	int t1 = v1->type.t & VT_BTYPE;
		1412	int t2 = v2->type.t & VT_BTYPE;
		1413	int c1 = (v1->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == VT_CONST;
		1414	int c2 = (v2->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == VT_CONST;
		1415	uint64_t l1 = c1 ? v1->c.i : 0;
		1416	uint64_t l2 = c2 ? v2->c.i : 0;
		1417	int shm = (t1 == VT_LLONG) ? 63 : 31;
		1418
		1419	if (t1 != VT_LLONG)
		1420	l1 = ((uint32_t)l1 \|
		1421	(v1->type.t & VT_UNSIGNED ? 0 : -(l1 & 0x80000000)));
		1422	if (t2 != VT_LLONG)
		1423	l2 = ((uint32_t)l2 \|
		1424	(v2->type.t & VT_UNSIGNED ? 0 : -(l2 & 0x80000000)));
		1425
		1426	if (c1 && c2) {
		1427	switch(op) {
		1428	case '+': l1 += l2; break;
		1429	case '-': l1 -= l2; break;
		1430	case '&': l1 &= l2; break;
		1431	case '^': l1 ^= l2; break;
		1432	case '\|': l1 \|= l2; break;
		1433	case '': l1 = l2; break;
		1434
		1435	case TOK_PDIV:
		1436	case '/':
		1437	case '%':
		1438	case TOK_UDIV:
		1439	case TOK_UMOD:
		1440	/* if division by zero, generate explicit division */
		1441	if (l2 == 0) {
		1442	if (const_wanted)
		1443	tcc_error("division by zero in constant");
		1444	goto general_case;
		1445	}
		1446	switch(op) {
		1447	default: l1 = gen_opic_sdiv(l1, l2); break;
		1448	case '%': l1 = l1 - l2 * gen_opic_sdiv(l1, l2); break;
		1449	case TOK_UDIV: l1 = l1 / l2; break;
		1450	case TOK_UMOD: l1 = l1 % l2; break;
		1451	}
		1452	break;
		1453	case TOK_SHL: l1 <<= (l2 & shm); break;
		1454	case TOK_SHR: l1 >>= (l2 & shm); break;
		1455	case TOK_SAR:
		1456	l1 = (l1 >> 63) ? ~(~l1 >> (l2 & shm)) : l1 >> (l2 & shm);
		1457	break;
		1458	/* tests */
		1459	case TOK_ULT: l1 = l1 < l2; break;
		1460	case TOK_UGE: l1 = l1 >= l2; break;
		1461	case TOK_EQ: l1 = l1 == l2; break;
		1462	case TOK_NE: l1 = l1 != l2; break;
		1463	case TOK_ULE: l1 = l1 <= l2; break;
		1464	case TOK_UGT: l1 = l1 > l2; break;
		1465	case TOK_LT: l1 = gen_opic_lt(l1, l2); break;
		1466	case TOK_GE: l1 = !gen_opic_lt(l1, l2); break;
		1467	case TOK_LE: l1 = !gen_opic_lt(l2, l1); break;
		1468	case TOK_GT: l1 = gen_opic_lt(l2, l1); break;
		1469	/* logical */
		1470	case TOK_LAND: l1 = l1 && l2; break;
		1471	case TOK_LOR: l1 = l1 \|\| l2; break;
		1472	default:
		1473	goto general_case;
		1474	}
		1475	v1->c.i = l1;
		1476	vtop--;
		1477	} else {
		1478	/* if commutative ops, put c2 as constant */
		1479	if (c1 && (op == '+' \|\| op == '&' \|\| op == '^' \|\|
		1480	op == '\|' \|\| op == '*')) {
		1481	vswap();
		1482	c2 = c1; //c = c1, c1 = c2, c2 = c;
		1483	l2 = l1; //l = l1, l1 = l2, l2 = l;
		1484	}
		1485	if (!const_wanted &&
		1486	c1 && ((l1 == 0 &&
		1487	(op == TOK_SHL \|\| op == TOK_SHR \|\| op == TOK_SAR)) \|\|
		1488	(l1 == -1 && op == TOK_SAR))) {
		1489	/* treat (0 << x), (0 >> x) and (-1 >> x) as constant */
		1490	vtop--;
		1491	} else if (!const_wanted &&
		1492	c2 && ((l2 == 0 && (op == '&' \|\| op == '*')) \|\|
		1493	(l2 == -1 && op == '\|') \|\|
		1494	(l2 == 0xffffffff && t2 != VT_LLONG && op == '\|') \|\|
		1495	(l2 == 1 && (op == '%' \|\| op == TOK_UMOD)))) {
		1496	/* treat (x & 0), (x * 0), (x \| -1) and (x % 1) as constant */
		1497	if (l2 == 1)
		1498	vtop->c.i = 0;
		1499	vswap();
		1500	vtop--;
		1501	} else if (c2 && (((op == '*' \|\| op == '/' \|\| op == TOK_UDIV \|\|
		1502	op == TOK_PDIV) &&
		1503	l2 == 1) \|\|
		1504	((op == '+' \|\| op == '-' \|\| op == '\|' \|\| op == '^' \|\|
		1505	op == TOK_SHL \|\| op == TOK_SHR \|\| op == TOK_SAR) &&
		1506	l2 == 0) \|\|
		1507	(op == '&' &&
		1508	l2 == -1))) {
		1509	/* filter out NOP operations like x1, x-0, x&-1... /
		1510	vtop--;
		1511	} else if (c2 && (op == '*' \|\| op == TOK_PDIV \|\| op == TOK_UDIV)) {
		1512	/* try to use shifts instead of muls or divs */
		1513	if (l2 > 0 && (l2 & (l2 - 1)) == 0) {
		1514	int n = -1;
		1515	while (l2) {
		1516	l2 >>= 1;
		1517	n++;
		1518	}
		1519	vtop->c.i = n;
		1520	if (op == '*')
		1521	op = TOK_SHL;
		1522	else if (op == TOK_PDIV)
		1523	op = TOK_SAR;
		1524	else
		1525	op = TOK_SHR;
		1526	}
		1527	goto general_case;
		1528	} else if (c2 && (op == '+' \|\| op == '-') &&
		1529	(((vtop[-1].r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == (VT_CONST \| VT_SYM))
		1530	\|\| (vtop[-1].r & (VT_VALMASK \| VT_LVAL)) == VT_LOCAL)) {
		1531	/* symbol + constant case */
		1532	if (op == '-')
		1533	l2 = -l2;
		1534	vtop--;
		1535	vtop->c.i += l2;
		1536	} else {
		1537	general_case:
		1538	if (!nocode_wanted) {
		1539	/* call low level op generator */
		1540	if (t1 == VT_LLONG \|\| t2 == VT_LLONG \|\|
		1541	(PTR_SIZE == 8 && (t1 == VT_PTR \|\| t2 == VT_PTR)))
		1542	gen_opl(op);
		1543	else
		1544	gen_opi(op);
		1545	} else {
		1546	vtop--;
		1547	}
		1548	}
		1549	}
		1550	}
		1551
		1552	/* generate a floating point operation with constant propagation */
		1553	static void gen_opif(int op)
		1554	{
		1555	int c1, c2;
		1556	SValue v1, v2;
		1557	long double f1, f2;
		1558
		1559	v1 = vtop - 1;
		1560	v2 = vtop;
		1561	/* currently, we cannot do computations with forward symbols */
		1562	c1 = (v1->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == VT_CONST;
		1563	c2 = (v2->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == VT_CONST;
		1564	if (c1 && c2) {
		1565	if (v1->type.t == VT_FLOAT) {
		1566	f1 = v1->c.f;
		1567	f2 = v2->c.f;
		1568	} else if (v1->type.t == VT_DOUBLE) {
		1569	f1 = v1->c.d;
		1570	f2 = v2->c.d;
		1571	} else {
		1572	f1 = v1->c.ld;
		1573	f2 = v2->c.ld;
		1574	}
		1575
		1576	/* NOTE: we only do constant propagation if finite number (not
		1577	NaN or infinity) (ANSI spec) */
		1578	if (!ieee_finite(f1) \|\| !ieee_finite(f2))
		1579	goto general_case;
		1580
		1581	switch(op) {
		1582	case '+': f1 += f2; break;
		1583	case '-': f1 -= f2; break;
		1584	case '': f1 = f2; break;
		1585	case '/':
		1586	if (f2 == 0.0) {
		1587	if (const_wanted)
		1588	tcc_error("division by zero in constant");
		1589	goto general_case;
		1590	}
		1591	f1 /= f2;
		1592	break;
		1593	/* XXX: also handles tests ? */
		1594	default:
		1595	goto general_case;
		1596	}
		1597	/* XXX: overflow test ? */
		1598	if (v1->type.t == VT_FLOAT) {
		1599	v1->c.f = f1;
		1600	} else if (v1->type.t == VT_DOUBLE) {
		1601	v1->c.d = f1;
		1602	} else {
		1603	v1->c.ld = f1;
		1604	}
		1605	vtop--;
		1606	} else {
		1607	general_case:
		1608	if (!nocode_wanted) {
		1609	gen_opf(op);
		1610	} else {
		1611	vtop--;
		1612	}
		1613	}
		1614	}
		1615
		1616	static int pointed_size(CType *type)
		1617	{
		1618	int align;
		1619	return type_size(pointed_type(type), &align);
		1620	}
		1621
		1622	static void vla_runtime_pointed_size(CType *type)
		1623	{
		1624	int align;
		1625	vla_runtime_type_size(pointed_type(type), &align);
		1626	}
		1627
		1628	static inline int is_null_pointer(SValue *p)
		1629	{
		1630	if ((p->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) != VT_CONST)
		1631	return 0;
		1632	return ((p->type.t & VT_BTYPE) == VT_INT && (uint32_t)p->c.i == 0) \|\|
		1633	((p->type.t & VT_BTYPE) == VT_LLONG && p->c.i == 0) \|\|
		1634	((p->type.t & VT_BTYPE) == VT_PTR &&
		1635	(PTR_SIZE == 4 ? (uint32_t)p->c.i == 0 : p->c.i == 0));
		1636	}
		1637
		1638	static inline int is_integer_btype(int bt)
		1639	{
		1640	return (bt == VT_BYTE \|\| bt == VT_SHORT \|\|
		1641	bt == VT_INT \|\| bt == VT_LLONG);
		1642	}
		1643
		1644	/* check types for comparison or subtraction of pointers */
		1645	static void check_comparison_pointer_types(SValue p1, SValue p2, int op)
		1646	{
		1647	CType type1, type2, tmp_type1, tmp_type2;
		1648	int bt1, bt2;
		1649
		1650	/* null pointers are accepted for all comparisons as gcc */
		1651	if (is_null_pointer(p1) \|\| is_null_pointer(p2))
		1652	return;
		1653	type1 = &p1->type;
		1654	type2 = &p2->type;
		1655	bt1 = type1->t & VT_BTYPE;
		1656	bt2 = type2->t & VT_BTYPE;
		1657	/* accept comparison between pointer and integer with a warning */
		1658	if ((is_integer_btype(bt1) \|\| is_integer_btype(bt2)) && op != '-') {
		1659	if (op != TOK_LOR && op != TOK_LAND )
		1660	tcc_warning("comparison between pointer and integer");
		1661	return;
		1662	}
		1663
		1664	/* both must be pointers or implicit function pointers */
		1665	if (bt1 == VT_PTR) {
		1666	type1 = pointed_type(type1);
		1667	} else if (bt1 != VT_FUNC)
		1668	goto invalid_operands;
		1669
		1670	if (bt2 == VT_PTR) {
		1671	type2 = pointed_type(type2);
		1672	} else if (bt2 != VT_FUNC) {
		1673	invalid_operands:
		1674	tcc_error("invalid operands to binary %s", get_tok_str(op, NULL));
		1675	}
		1676	if ((type1->t & VT_BTYPE) == VT_VOID \|\|
		1677	(type2->t & VT_BTYPE) == VT_VOID)
		1678	return;
		1679	tmp_type1 = *type1;
		1680	tmp_type2 = *type2;
		1681	tmp_type1.t &= ~(VT_DEFSIGN \| VT_UNSIGNED \| VT_CONSTANT \| VT_VOLATILE);
		1682	tmp_type2.t &= ~(VT_DEFSIGN \| VT_UNSIGNED \| VT_CONSTANT \| VT_VOLATILE);
		1683	if (!is_compatible_types(&tmp_type1, &tmp_type2)) {
		1684	/* gcc-like error if '-' is used */
		1685	if (op == '-')
		1686	goto invalid_operands;
		1687	else
		1688	tcc_warning("comparison of distinct pointer types lacks a cast");
		1689	}
		1690	}
		1691
		1692	/* generic gen_op: handles types problems */
		1693	ST_FUNC void gen_op(int op)
		1694	{
		1695	int u, t1, t2, bt1, bt2, t;
		1696	CType type1;
		1697
		1698	t1 = vtop[-1].type.t;
		1699	t2 = vtop[0].type.t;
		1700	bt1 = t1 & VT_BTYPE;
		1701	bt2 = t2 & VT_BTYPE;
		1702
		1703	if (bt1 == VT_PTR \|\| bt2 == VT_PTR) {
		1704	/* at least one operand is a pointer */
		1705	/* relationnal op: must be both pointers */
		1706	if (op >= TOK_ULT && op <= TOK_LOR) {
		1707	check_comparison_pointer_types(vtop - 1, vtop, op);
		1708	/* pointers are handled are unsigned */
		1709	#if defined(TCC_TARGET_ARM64) \|\| defined(TCC_TARGET_X86_64)
		1710	t = VT_LLONG \| VT_UNSIGNED;
		1711	#else
		1712	t = VT_INT \| VT_UNSIGNED;
		1713	#endif
		1714	goto std_op;
		1715	}
		1716	/* if both pointers, then it must be the '-' op */
		1717	if (bt1 == VT_PTR && bt2 == VT_PTR) {
		1718	if (op != '-')
		1719	tcc_error("cannot use pointers here");
		1720	check_comparison_pointer_types(vtop - 1, vtop, op);
		1721	/* XXX: check that types are compatible */
		1722	if (vtop[-1].type.t & VT_VLA) {
		1723	vla_runtime_pointed_size(&vtop[-1].type);
		1724	} else {
		1725	vpushi(pointed_size(&vtop[-1].type));
		1726	}
		1727	vrott(3);
		1728	gen_opic(op);
		1729	/* set to integer type */
		1730	#if defined(TCC_TARGET_ARM64) \|\| defined(TCC_TARGET_X86_64)
		1731	vtop->type.t = VT_LLONG;
		1732	#else
		1733	vtop->type.t = VT_INT;
		1734	#endif
		1735	vswap();
		1736	gen_op(TOK_PDIV);
		1737	} else {
		1738	/* exactly one pointer : must be '+' or '-'. */
		1739	if (op != '-' && op != '+')
		1740	tcc_error("cannot use pointers here");
		1741	/* Put pointer as first operand */
		1742	if (bt2 == VT_PTR) {
		1743	vswap();
		1744	swap(&t1, &t2);
		1745	}
		1746	type1 = vtop[-1].type;
		1747	type1.t &= ~VT_ARRAY;
		1748	if (vtop[-1].type.t & VT_VLA)
		1749	vla_runtime_pointed_size(&vtop[-1].type);
		1750	else {
		1751	u = pointed_size(&vtop[-1].type);
		1752	if (u < 0)
		1753	tcc_error("unknown array element size");
		1754	#if defined(TCC_TARGET_ARM64) \|\| defined(TCC_TARGET_X86_64)
		1755	vpushll(u);
		1756	#else
		1757	/* XXX: cast to int ? (long long case) */
		1758	vpushi(u);
		1759	#endif
		1760	}
		1761	gen_op('*');
		1762	#if 0
		1763	/* #ifdef CONFIG_TCC_BCHECK
		1764	The main reason to removing this code:
		1765	#include
		1766	int main ()
		1767	{
		1768	int v[10];
		1769	int i = 10;
		1770	int j = 9;
		1771	fprintf(stderr, "v+i-j = %p\n", v+i-j);
		1772	fprintf(stderr, "v+(i-j) = %p\n", v+(i-j));
		1773	}
		1774	When this code is on. then the output looks like
		1775	v+i-j = 0xfffffffe
		1776	v+(i-j) = 0xbff84000
		1777	*/
		1778	/* if evaluating constant expression, no code should be
		1779	generated, so no bound check */
		1780	if (tcc_state->do_bounds_check && !const_wanted) {
		1781	/* if bounded pointers, we generate a special code to
		1782	test bounds */
		1783	if (op == '-') {
		1784	vpushi(0);
		1785	vswap();
		1786	gen_op('-');
		1787	}
		1788	gen_bounded_ptr_add();
		1789	} else
		1790	#endif
		1791	{
		1792	gen_opic(op);
		1793	}
		1794	/* put again type if gen_opic() swaped operands */
		1795	vtop->type = type1;
		1796	}
		1797	} else if (is_float(bt1) \|\| is_float(bt2)) {
		1798	/* compute bigger type and do implicit casts */
		1799	if (bt1 == VT_LDOUBLE \|\| bt2 == VT_LDOUBLE) {
		1800	t = VT_LDOUBLE;
		1801	} else if (bt1 == VT_DOUBLE \|\| bt2 == VT_DOUBLE) {
		1802	t = VT_DOUBLE;
		1803	} else {
		1804	t = VT_FLOAT;
		1805	}
		1806	/* floats can only be used for a few operations */
		1807	if (op != '+' && op != '-' && op != '*' && op != '/' &&
		1808	(op < TOK_ULT \|\| op > TOK_GT))
		1809	tcc_error("invalid operands for binary operation");
		1810	goto std_op;
		1811	} else if (op == TOK_SHR \|\| op == TOK_SAR \|\| op == TOK_SHL) {
		1812	t = bt1 == VT_LLONG ? VT_LLONG : VT_INT;
		1813	if ((t1 & (VT_BTYPE \| VT_UNSIGNED)) == (t \| VT_UNSIGNED))
		1814	t \|= VT_UNSIGNED;
		1815	goto std_op;
		1816	} else if (bt1 == VT_LLONG \|\| bt2 == VT_LLONG) {
		1817	/* cast to biggest op */
		1818	t = VT_LLONG;
		1819	/* convert to unsigned if it does not fit in a long long */
		1820	if ((t1 & (VT_BTYPE \| VT_UNSIGNED)) == (VT_LLONG \| VT_UNSIGNED) \|\|
		1821	(t2 & (VT_BTYPE \| VT_UNSIGNED)) == (VT_LLONG \| VT_UNSIGNED))
		1822	t \|= VT_UNSIGNED;
		1823	goto std_op;
		1824	} else if (bt1 == VT_STRUCT \|\| bt2 == VT_STRUCT) {
		1825	tcc_error("comparison of struct");
		1826	} else {
		1827	/* integer operations */
		1828	t = VT_INT;
		1829	/* convert to unsigned if it does not fit in an integer */
		1830	if ((t1 & (VT_BTYPE \| VT_UNSIGNED)) == (VT_INT \| VT_UNSIGNED) \|\|
		1831	(t2 & (VT_BTYPE \| VT_UNSIGNED)) == (VT_INT \| VT_UNSIGNED))
		1832	t \|= VT_UNSIGNED;
		1833	std_op:
		1834	/* XXX: currently, some unsigned operations are explicit, so
		1835	we modify them here */
		1836	if (t & VT_UNSIGNED) {
		1837	if (op == TOK_SAR)
		1838	op = TOK_SHR;
		1839	else if (op == '/')
		1840	op = TOK_UDIV;
		1841	else if (op == '%')
		1842	op = TOK_UMOD;
		1843	else if (op == TOK_LT)
		1844	op = TOK_ULT;
		1845	else if (op == TOK_GT)
		1846	op = TOK_UGT;
		1847	else if (op == TOK_LE)
		1848	op = TOK_ULE;
		1849	else if (op == TOK_GE)
		1850	op = TOK_UGE;
		1851	}
		1852	vswap();
		1853	type1.t = t;
		1854	gen_cast(&type1);
		1855	vswap();
		1856	/* special case for shifts and long long: we keep the shift as
		1857	an integer */
		1858	if (op == TOK_SHR \|\| op == TOK_SAR \|\| op == TOK_SHL)
		1859	type1.t = VT_INT;
		1860	gen_cast(&type1);
		1861	if (is_float(t))
		1862	gen_opif(op);
		1863	else
		1864	gen_opic(op);
		1865	if (op >= TOK_ULT && op <= TOK_GT) {
		1866	/* relationnal op: the result is an int */
		1867	vtop->type.t = VT_INT;
		1868	} else {
		1869	vtop->type.t = t;
		1870	}
		1871	}
		1872	// Make sure that we have converted to an rvalue:
		1873	if (vtop->r & VT_LVAL && !nocode_wanted)
		1874	gv(is_float(vtop->type.t & VT_BTYPE) ? RC_FLOAT : RC_INT);
		1875	}
		1876
		1877	#ifndef TCC_TARGET_ARM
		1878	/* generic itof for unsigned long long case */
		1879	static void gen_cvt_itof1(int t)
		1880	{
		1881	#ifdef TCC_TARGET_ARM64
		1882	gen_cvt_itof(t);
		1883	#else
		1884	if ((vtop->type.t & (VT_BTYPE \| VT_UNSIGNED)) ==
		1885	(VT_LLONG \| VT_UNSIGNED)) {
		1886
		1887	if (t == VT_FLOAT)
		1888	vpush_global_sym(&func_old_type, TOK___floatundisf);
		1889	#if LDOUBLE_SIZE != 8
		1890	else if (t == VT_LDOUBLE)
		1891	vpush_global_sym(&func_old_type, TOK___floatundixf);
		1892	#endif
		1893	else
		1894	vpush_global_sym(&func_old_type, TOK___floatundidf);
		1895	vrott(2);
		1896	gfunc_call(1);
		1897	vpushi(0);
		1898	vtop->r = reg_fret(t);
		1899	} else {
		1900	gen_cvt_itof(t);
		1901	}
		1902	#endif
		1903	}
		1904	#endif
		1905
		1906	/* generic ftoi for unsigned long long case */
		1907	static void gen_cvt_ftoi1(int t)
		1908	{
		1909	#ifdef TCC_TARGET_ARM64
		1910	gen_cvt_ftoi(t);
		1911	#else
		1912	int st;
		1913
		1914	if (t == (VT_LLONG \| VT_UNSIGNED)) {
		1915	/* not handled natively */
		1916	st = vtop->type.t & VT_BTYPE;
		1917	if (st == VT_FLOAT)
		1918	vpush_global_sym(&func_old_type, TOK___fixunssfdi);
		1919	#if LDOUBLE_SIZE != 8
		1920	else if (st == VT_LDOUBLE)
		1921	vpush_global_sym(&func_old_type, TOK___fixunsxfdi);
		1922	#endif
		1923	else
		1924	vpush_global_sym(&func_old_type, TOK___fixunsdfdi);
		1925	vrott(2);
		1926	gfunc_call(1);
		1927	vpushi(0);
		1928	vtop->r = REG_IRET;
		1929	vtop->r2 = REG_LRET;
		1930	} else {
		1931	gen_cvt_ftoi(t);
		1932	}
		1933	#endif
		1934	}
		1935
		1936	/* force char or short cast */
		1937	static void force_charshort_cast(int t)
		1938	{
		1939	int bits, dbt;
		1940	dbt = t & VT_BTYPE;
		1941	/* XXX: add optimization if lvalue : just change type and offset */
		1942	if (dbt == VT_BYTE)
		1943	bits = 8;
		1944	else
		1945	bits = 16;
		1946	if (t & VT_UNSIGNED) {
		1947	vpushi((1 << bits) - 1);
		1948	gen_op('&');
		1949	} else {
		1950	bits = 32 - bits;
		1951	vpushi(bits);
		1952	gen_op(TOK_SHL);
		1953	/* result must be signed or the SAR is converted to an SHL
		1954	This was not the case when "t" was a signed short
		1955	and the last value on the stack was an unsigned int */
		1956	vtop->type.t &= ~VT_UNSIGNED;
		1957	vpushi(bits);
		1958	gen_op(TOK_SAR);
		1959	}
		1960	}
		1961
		1962	/* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
		1963	static void gen_cast(CType *type)
		1964	{
		1965	int sbt, dbt, sf, df, c, p;
		1966
		1967	/* special delayed cast for char/short */
		1968	/* XXX: in some cases (multiple cascaded casts), it may still
		1969	be incorrect */
		1970	if (vtop->r & VT_MUSTCAST) {
		1971	vtop->r &= ~VT_MUSTCAST;
		1972	force_charshort_cast(vtop->type.t);
		1973	}
		1974
		1975	/* bitfields first get cast to ints */
		1976	if (vtop->type.t & VT_BITFIELD && !nocode_wanted) {
		1977	gv(RC_INT);
		1978	}
		1979
		1980	dbt = type->t & (VT_BTYPE \| VT_UNSIGNED);
		1981	sbt = vtop->type.t & (VT_BTYPE \| VT_UNSIGNED);
		1982
		1983	if (sbt != dbt) {
		1984	sf = is_float(sbt);
		1985	df = is_float(dbt);
		1986	c = (vtop->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == VT_CONST;
		1987	p = (vtop->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == (VT_CONST \| VT_SYM);
		1988	if (c) {
		1989	/* constant case: we can do it now */
		1990	/* XXX: in ISOC, cannot do it if error in convert */
		1991	if (sbt == VT_FLOAT)
		1992	vtop->c.ld = vtop->c.f;
		1993	else if (sbt == VT_DOUBLE)
		1994	vtop->c.ld = vtop->c.d;
		1995
		1996	if (df) {
		1997	if ((sbt & VT_BTYPE) == VT_LLONG) {
		1998	if ((sbt & VT_UNSIGNED) \|\| !(vtop->c.i >> 63))
		1999	vtop->c.ld = vtop->c.i;
		2000	else
		2001	vtop->c.ld = -(long double)-vtop->c.i;
		2002	} else if(!sf) {
		2003	if ((sbt & VT_UNSIGNED) \|\| !(vtop->c.i >> 31))
		2004	vtop->c.ld = (uint32_t)vtop->c.i;
		2005	else
		2006	vtop->c.ld = -(long double)-(uint32_t)vtop->c.i;
		2007	}
		2008
		2009	if (dbt == VT_FLOAT)
		2010	vtop->c.f = (float)vtop->c.ld;
		2011	else if (dbt == VT_DOUBLE)
		2012	vtop->c.d = (double)vtop->c.ld;
		2013	} else if (sf && dbt == (VT_LLONG\|VT_UNSIGNED)) {
		2014	vtop->c.i = vtop->c.ld;
		2015	} else if (sf && dbt == VT_BOOL) {
		2016	vtop->c.i = (vtop->c.ld != 0);
		2017	} else {
		2018	if(sf)
		2019	vtop->c.i = vtop->c.ld;
		2020	else if (sbt == (VT_LLONG\|VT_UNSIGNED))
		2021	;
		2022	else if (sbt & VT_UNSIGNED)
		2023	vtop->c.i = (uint32_t)vtop->c.i;
		2024	#if defined(TCC_TARGET_ARM64) \|\| defined(TCC_TARGET_X86_64)
		2025	else if (sbt == VT_PTR)
		2026	;
		2027	#endif
		2028	else if (sbt != VT_LLONG)
		2029	vtop->c.i = ((uint32_t)vtop->c.i \|
		2030	-(vtop->c.i & 0x80000000));
		2031
		2032	if (dbt == (VT_LLONG\|VT_UNSIGNED))
		2033	;
		2034	else if (dbt == VT_BOOL)
		2035	vtop->c.i = (vtop->c.i != 0);
		2036	#if defined(TCC_TARGET_ARM64) \|\| defined(TCC_TARGET_X86_64)
		2037	else if (dbt == VT_PTR)
		2038	;
		2039	#endif
		2040	else if (dbt != VT_LLONG) {
		2041	uint32_t m = ((dbt & VT_BTYPE) == VT_BYTE ? 0xff :
		2042	(dbt & VT_BTYPE) == VT_SHORT ? 0xffff :
		2043	0xffffffff);
		2044	vtop->c.i &= m;
		2045	if (!(dbt & VT_UNSIGNED))
		2046	vtop->c.i \|= -(vtop->c.i & ((m >> 1) + 1));
		2047	}
		2048	}
		2049	} else if (p && dbt == VT_BOOL) {
		2050	vtop->r = VT_CONST;
		2051	vtop->c.i = 1;
		2052	} else if (!nocode_wanted) {
		2053	/* non constant case: generate code */
		2054	if (sf && df) {
		2055	/* convert from fp to fp */
		2056	gen_cvt_ftof(dbt);
		2057	} else if (df) {
		2058	/* convert int to fp */
		2059	gen_cvt_itof1(dbt);
		2060	} else if (sf) {
		2061	/* convert fp to int */
		2062	if (dbt == VT_BOOL) {
		2063	vpushi(0);
		2064	gen_op(TOK_NE);
		2065	} else {
		2066	/* we handle char/short/etc... with generic code */
		2067	if (dbt != (VT_INT \| VT_UNSIGNED) &&
		2068	dbt != (VT_LLONG \| VT_UNSIGNED) &&
		2069	dbt != VT_LLONG)
		2070	dbt = VT_INT;
		2071	gen_cvt_ftoi1(dbt);
		2072	if (dbt == VT_INT && (type->t & (VT_BTYPE \| VT_UNSIGNED)) != dbt) {
		2073	/* additional cast for char/short... */
		2074	vtop->type.t = dbt;
		2075	gen_cast(type);
		2076	}
		2077	}
		2078	#if !defined(TCC_TARGET_ARM64) && !defined(TCC_TARGET_X86_64)
		2079	} else if ((dbt & VT_BTYPE) == VT_LLONG) {
		2080	if ((sbt & VT_BTYPE) != VT_LLONG && !nocode_wanted) {
		2081	/* scalar to long long */
		2082	/* machine independent conversion */
		2083	gv(RC_INT);
		2084	/* generate high word */
		2085	if (sbt == (VT_INT \| VT_UNSIGNED)) {
		2086	vpushi(0);
		2087	gv(RC_INT);
		2088	} else {
		2089	if (sbt == VT_PTR) {
		2090	/* cast from pointer to int before we apply
		2091	shift operation, which pointers don't support*/
		2092	gen_cast(&int_type);
		2093	}
		2094	gv_dup();
		2095	vpushi(31);
		2096	gen_op(TOK_SAR);
		2097	}
		2098	/* patch second register */
		2099	vtop[-1].r2 = vtop->r;
		2100	vpop();
		2101	}
		2102	#else
		2103	} else if ((dbt & VT_BTYPE) == VT_LLONG \|\|
		2104	(dbt & VT_BTYPE) == VT_PTR \|\|
		2105	(dbt & VT_BTYPE) == VT_FUNC) {
		2106	if ((sbt & VT_BTYPE) != VT_LLONG &&
		2107	(sbt & VT_BTYPE) != VT_PTR &&
		2108	(sbt & VT_BTYPE) != VT_FUNC && !nocode_wanted) {
		2109	/* need to convert from 32bit to 64bit */
		2110	gv(RC_INT);
		2111	if (sbt != (VT_INT \| VT_UNSIGNED)) {
		2112	#if defined(TCC_TARGET_ARM64)
		2113	gen_cvt_sxtw();
		2114	#elif defined(TCC_TARGET_X86_64)
		2115	int r = gv(RC_INT);
		2116	/* x86_64 specific: movslq */
		2117	o(0x6348);
		2118	o(0xc0 + (REG_VALUE(r) << 3) + REG_VALUE(r));
		2119	#else
		2120	#error
		2121	#endif
		2122	}
		2123	}
		2124	#endif
		2125	} else if (dbt == VT_BOOL) {
		2126	/* scalar to bool */
		2127	vpushi(0);
		2128	gen_op(TOK_NE);
		2129	} else if ((dbt & VT_BTYPE) == VT_BYTE \|\|
		2130	(dbt & VT_BTYPE) == VT_SHORT) {
		2131	if (sbt == VT_PTR) {
		2132	vtop->type.t = VT_INT;
		2133	tcc_warning("nonportable conversion from pointer to char/short");
		2134	}
		2135	force_charshort_cast(dbt);
		2136	} else if ((dbt & VT_BTYPE) == VT_INT) {
		2137	/* scalar to int */
		2138	if (sbt == VT_LLONG && !nocode_wanted) {
		2139	/* from long long: just take low order word */
		2140	lexpand();
		2141	vpop();
		2142	}
		2143	/* if lvalue and single word type, nothing to do because
		2144	the lvalue already contains the real type size (see
		2145	VT_LVAL_xxx constants) */
		2146	}
		2147	}
		2148	} else if ((dbt & VT_BTYPE) == VT_PTR && !(vtop->r & VT_LVAL)) {
		2149	/* if we are casting between pointer types,
		2150	we must update the VT_LVAL_xxx size */
		2151	vtop->r = (vtop->r & ~VT_LVAL_TYPE)
		2152	\| (lvalue_type(type->ref->type.t) & VT_LVAL_TYPE);
		2153	}
		2154	vtop->type = *type;
		2155	}
		2156
		2157	/* return type size as known at compile time. Put alignment at 'a' */
		2158	ST_FUNC int type_size(CType type, int a)
		2159	{
		2160	Sym *s;
		2161	int bt;
		2162
		2163	bt = type->t & VT_BTYPE;
		2164	if (bt == VT_STRUCT) {
		2165	/* struct/union */
		2166	s = type->ref;
		2167	*a = s->r;
		2168	return s->c;
		2169	} else if (bt == VT_PTR) {
		2170	if (type->t & VT_ARRAY) {
		2171	int ts;
		2172
		2173	s = type->ref;
		2174	ts = type_size(&s->type, a);
		2175
		2176	if (ts < 0 && s->c < 0)
		2177	ts = -ts;
		2178
		2179	return ts * s->c;
		2180	} else {
		2181	*a = PTR_SIZE;
		2182	return PTR_SIZE;
		2183	}
		2184	} else if (bt == VT_LDOUBLE) {
		2185	*a = LDOUBLE_ALIGN;
		2186	return LDOUBLE_SIZE;
		2187	} else if (bt == VT_DOUBLE \|\| bt == VT_LLONG) {
		2188	#ifdef TCC_TARGET_I386
		2189	#ifdef TCC_TARGET_PE
		2190	*a = 8;
		2191	#else
		2192	*a = 4;
		2193	#endif
		2194	#elif defined(TCC_TARGET_ARM)
		2195	#ifdef TCC_ARM_EABI
		2196	*a = 8;
		2197	#else
		2198	*a = 4;
		2199	#endif
		2200	#else
		2201	*a = 8;
		2202	#endif
		2203	return 8;
		2204	} else if (bt == VT_INT \|\| bt == VT_FLOAT) {
		2205	*a = 4;
		2206	return 4;
		2207	} else if (bt == VT_SHORT) {
		2208	*a = 2;
		2209	return 2;
		2210	} else if (bt == VT_QLONG \|\| bt == VT_QFLOAT) {
		2211	*a = 8;
		2212	return 16;
		2213	} else if (bt == VT_ENUM) {
		2214	*a = 4;
		2215	/* Enums might be incomplete, so don't just return '4' here. */
		2216	return type->ref->c;
		2217	} else {
		2218	/* char, void, function, _Bool */
		2219	*a = 1;
		2220	return 1;
		2221	}
		2222	}
		2223
		2224	/* push type size as known at runtime time on top of value stack. Put
		2225	alignment at 'a' */
		2226	ST_FUNC void vla_runtime_type_size(CType type, int a)
		2227	{
		2228	if (type->t & VT_VLA) {
		2229	vset(&int_type, VT_LOCAL\|VT_LVAL, type->ref->c);
		2230	} else {
		2231	vpushi(type_size(type, a));
		2232	}
		2233	}
		2234
		2235	static void vla_sp_restore(void) {
		2236	if (vlas_in_scope) {
		2237	gen_vla_sp_restore(vla_sp_loc);
		2238	}
		2239	}
		2240
		2241	static void vla_sp_restore_root(void) {
		2242	if (vlas_in_scope) {
		2243	gen_vla_sp_restore(vla_sp_root_loc);
		2244	}
		2245	}
		2246
		2247	/* return the pointed type of t */
		2248	static inline CType pointed_type(CType type)
		2249	{
		2250	return &type->ref->type;
		2251	}
		2252
		2253	/* modify type so that its it is a pointer to type. */
		2254	ST_FUNC void mk_pointer(CType *type)
		2255	{
		2256	Sym *s;
		2257	s = sym_push(SYM_FIELD, type, 0, -1);
		2258	type->t = VT_PTR \| (type->t & ~VT_TYPE);
		2259	type->ref = s;
		2260	}
		2261
		2262	/* compare function types. OLD functions match any new functions */
		2263	static int is_compatible_func(CType type1, CType type2)
		2264	{
		2265	Sym s1, s2;
		2266
		2267	s1 = type1->ref;
		2268	s2 = type2->ref;
		2269	if (!is_compatible_types(&s1->type, &s2->type))
		2270	return 0;
		2271	/* check func_call */
		2272	if (s1->a.func_call != s2->a.func_call)
		2273	return 0;
		2274	/* XXX: not complete */
		2275	if (s1->c == FUNC_OLD \|\| s2->c == FUNC_OLD)
		2276	return 1;
		2277	if (s1->c != s2->c)
		2278	return 0;
		2279	while (s1 != NULL) {
		2280	if (s2 == NULL)
		2281	return 0;
		2282	if (!is_compatible_parameter_types(&s1->type, &s2->type))
		2283	return 0;
		2284	s1 = s1->next;
		2285	s2 = s2->next;
		2286	}
		2287	if (s2)
		2288	return 0;
		2289	return 1;
		2290	}
		2291
		2292	/* return true if type1 and type2 are the same. If unqualified is
		2293	true, qualifiers on the types are ignored.
		2294
		2295	- enums are not checked as gcc __builtin_types_compatible_p ()
		2296	*/
		2297	static int compare_types(CType type1, CType type2, int unqualified)
		2298	{
		2299	int bt1, t1, t2;
		2300
		2301	t1 = type1->t & VT_TYPE;
		2302	t2 = type2->t & VT_TYPE;
		2303	if (unqualified) {
		2304	/* strip qualifiers before comparing */
		2305	t1 &= ~(VT_CONSTANT \| VT_VOLATILE);
		2306	t2 &= ~(VT_CONSTANT \| VT_VOLATILE);
		2307	}
		2308	/* Default Vs explicit signedness only matters for char */
		2309	if ((t1 & VT_BTYPE) != VT_BYTE) {
		2310	t1 &= ~VT_DEFSIGN;
		2311	t2 &= ~VT_DEFSIGN;
		2312	}
		2313	/* XXX: bitfields ? */
		2314	if (t1 != t2)
		2315	return 0;
		2316	/* test more complicated cases */
		2317	bt1 = t1 & VT_BTYPE;
		2318	if (bt1 == VT_PTR) {
		2319	type1 = pointed_type(type1);
		2320	type2 = pointed_type(type2);
		2321	return is_compatible_types(type1, type2);
		2322	} else if (bt1 == VT_STRUCT) {
		2323	return (type1->ref == type2->ref);
		2324	} else if (bt1 == VT_FUNC) {
		2325	return is_compatible_func(type1, type2);
		2326	} else {
		2327	return 1;
		2328	}
		2329	}
		2330
		2331	/* return true if type1 and type2 are exactly the same (including
		2332	qualifiers).
		2333	*/
		2334	static int is_compatible_types(CType type1, CType type2)
		2335	{
		2336	return compare_types(type1,type2,0);
		2337	}
		2338
		2339	/* return true if type1 and type2 are the same (ignoring qualifiers).
		2340	*/
		2341	static int is_compatible_parameter_types(CType type1, CType type2)
		2342	{
		2343	return compare_types(type1,type2,1);
		2344	}
		2345
		2346	/* print a type. If 'varstr' is not NULL, then the variable is also
		2347	printed in the type */
		2348	/* XXX: union */
		2349	/* XXX: add array and function pointers */
		2350	static void type_to_str(char *buf, int buf_size,
		2351	CType type, const char varstr)
		2352	{
		2353	int bt, v, t;
		2354	Sym s, sa;
		2355	char buf1[256];
		2356	const char *tstr;
		2357
		2358	t = type->t & VT_TYPE;
		2359	bt = t & VT_BTYPE;
		2360	buf[0] = '\0';
		2361	if (t & VT_CONSTANT)
		2362	pstrcat(buf, buf_size, "const ");
		2363	if (t & VT_VOLATILE)
		2364	pstrcat(buf, buf_size, "volatile ");
		2365	if ((t & (VT_DEFSIGN \| VT_UNSIGNED)) == (VT_DEFSIGN \| VT_UNSIGNED))
		2366	pstrcat(buf, buf_size, "unsigned ");
		2367	else if (t & VT_DEFSIGN)
		2368	pstrcat(buf, buf_size, "signed ");
		2369	switch(bt) {
		2370	case VT_VOID:
		2371	tstr = "void";
		2372	goto add_tstr;
		2373	case VT_BOOL:
		2374	tstr = "_Bool";
		2375	goto add_tstr;
		2376	case VT_BYTE:
		2377	tstr = "char";
		2378	goto add_tstr;
		2379	case VT_SHORT:
		2380	tstr = "short";
		2381	goto add_tstr;
		2382	case VT_INT:
		2383	tstr = "int";
		2384	goto add_tstr;
		2385	case VT_LONG:
		2386	tstr = "long";
		2387	goto add_tstr;
		2388	case VT_LLONG:
		2389	tstr = "long long";
		2390	goto add_tstr;
		2391	case VT_FLOAT:
		2392	tstr = "float";
		2393	goto add_tstr;
		2394	case VT_DOUBLE:
		2395	tstr = "double";
		2396	goto add_tstr;
		2397	case VT_LDOUBLE:
		2398	tstr = "long double";
		2399	add_tstr:
		2400	pstrcat(buf, buf_size, tstr);
		2401	break;
		2402	case VT_ENUM:
		2403	case VT_STRUCT:
		2404	if (bt == VT_STRUCT)
		2405	tstr = "struct ";
		2406	else
		2407	tstr = "enum ";
		2408	pstrcat(buf, buf_size, tstr);
		2409	v = type->ref->v & ~SYM_STRUCT;
		2410	if (v >= SYM_FIRST_ANOM)
		2411	pstrcat(buf, buf_size, "");
		2412	else
		2413	pstrcat(buf, buf_size, get_tok_str(v, NULL));
		2414	break;
		2415	case VT_FUNC:
		2416	s = type->ref;
		2417	type_to_str(buf, buf_size, &s->type, varstr);
		2418	pstrcat(buf, buf_size, "(");
		2419	sa = s->next;
		2420	while (sa != NULL) {
		2421	type_to_str(buf1, sizeof(buf1), &sa->type, NULL);
		2422	pstrcat(buf, buf_size, buf1);
		2423	sa = sa->next;
		2424	if (sa)
		2425	pstrcat(buf, buf_size, ", ");
		2426	}
		2427	pstrcat(buf, buf_size, ")");
		2428	goto no_var;
		2429	case VT_PTR:
		2430	s = type->ref;
		2431	if (t & VT_ARRAY) {
		2432	snprintf(buf1, sizeof(buf1), "%s[%ld]", varstr ? varstr : "", s->c);
		2433	type_to_str(buf, buf_size, &s->type, buf1);
		2434	goto no_var;
		2435	}
		2436	pstrcpy(buf1, sizeof(buf1), "*");
		2437	if (t & VT_CONSTANT)
		2438	pstrcat(buf1, buf_size, "const ");
		2439	if (t & VT_VOLATILE)
		2440	pstrcat(buf1, buf_size, "volatile ");
		2441	if (varstr)
		2442	pstrcat(buf1, sizeof(buf1), varstr);
		2443	type_to_str(buf, buf_size, &s->type, buf1);
		2444	goto no_var;
		2445	}
		2446	if (varstr) {
		2447	pstrcat(buf, buf_size, " ");
		2448	pstrcat(buf, buf_size, varstr);
		2449	}
		2450	no_var: ;
		2451	}
		2452
		2453	/* verify type compatibility to store vtop in 'dt' type, and generate
		2454	casts if needed. */
		2455	static void gen_assign_cast(CType *dt)
		2456	{
		2457	CType st, type1, *type2, tmp_type1, tmp_type2;
		2458	char buf1[256], buf2[256];
		2459	int dbt, sbt;
		2460
		2461	st = &vtop->type; /* source type */
		2462	dbt = dt->t & VT_BTYPE;
		2463	sbt = st->t & VT_BTYPE;
		2464	if (sbt == VT_VOID \|\| dbt == VT_VOID) {
		2465	if (sbt == VT_VOID && dbt == VT_VOID)
		2466	; /*
		2467	It is Ok if both are void
		2468	A test program:
		2469	void func1() {}
		2470	void func2() {
		2471	return func1();
		2472	}
		2473	gcc accepts this program
		2474	*/
		2475	else
		2476	tcc_error("cannot cast from/to void");
		2477	}
		2478	if (dt->t & VT_CONSTANT)
		2479	tcc_warning("assignment of read-only location");
		2480	switch(dbt) {
		2481	case VT_PTR:
		2482	/* special cases for pointers */
		2483	/* '0' can also be a pointer */
		2484	if (is_null_pointer(vtop))
		2485	goto type_ok;
		2486	/* accept implicit pointer to integer cast with warning */
		2487	if (is_integer_btype(sbt)) {
		2488	tcc_warning("assignment makes pointer from integer without a cast");
		2489	goto type_ok;
		2490	}
		2491	type1 = pointed_type(dt);
		2492	/* a function is implicitely a function pointer */
		2493	if (sbt == VT_FUNC) {
		2494	if ((type1->t & VT_BTYPE) != VT_VOID &&
		2495	!is_compatible_types(pointed_type(dt), st))
		2496	tcc_warning("assignment from incompatible pointer type");
		2497	goto type_ok;
		2498	}
		2499	if (sbt != VT_PTR)
		2500	goto error;
		2501	type2 = pointed_type(st);
		2502	if ((type1->t & VT_BTYPE) == VT_VOID \|\|
		2503	(type2->t & VT_BTYPE) == VT_VOID) {
		2504	/* void * can match anything */
		2505	} else {
		2506	/* exact type match, except for unsigned */
		2507	tmp_type1 = *type1;
		2508	tmp_type2 = *type2;
		2509	tmp_type1.t &= ~(VT_DEFSIGN \| VT_UNSIGNED \| VT_CONSTANT \|
		2510	VT_VOLATILE);
		2511	tmp_type2.t &= ~(VT_DEFSIGN \| VT_UNSIGNED \| VT_CONSTANT \|
		2512	VT_VOLATILE);
		2513	if (!is_compatible_types(&tmp_type1, &tmp_type2))
		2514	tcc_warning("assignment from incompatible pointer type");
		2515	}
		2516	/* check const and volatile */
		2517	if ((!(type1->t & VT_CONSTANT) && (type2->t & VT_CONSTANT)) \|\|
		2518	(!(type1->t & VT_VOLATILE) && (type2->t & VT_VOLATILE)))
		2519	tcc_warning("assignment discards qualifiers from pointer target type");
		2520	break;
		2521	case VT_BYTE:
		2522	case VT_SHORT:
		2523	case VT_INT:
		2524	case VT_LLONG:
		2525	if (sbt == VT_PTR \|\| sbt == VT_FUNC) {
		2526	tcc_warning("assignment makes integer from pointer without a cast");
		2527	}
		2528	/* XXX: more tests */
		2529	break;
		2530	case VT_STRUCT:
		2531	tmp_type1 = *dt;
		2532	tmp_type2 = *st;
		2533	tmp_type1.t &= ~(VT_CONSTANT \| VT_VOLATILE);
		2534	tmp_type2.t &= ~(VT_CONSTANT \| VT_VOLATILE);
		2535	if (!is_compatible_types(&tmp_type1, &tmp_type2)) {
		2536	error:
		2537	type_to_str(buf1, sizeof(buf1), st, NULL);
		2538	type_to_str(buf2, sizeof(buf2), dt, NULL);
		2539	tcc_error("cannot cast '%s' to '%s'", buf1, buf2);
		2540	}
		2541	break;
		2542	}
		2543	type_ok:
		2544	gen_cast(dt);
		2545	}
		2546
		2547	/* store vtop in lvalue pushed on stack */
		2548	ST_FUNC void vstore(void)
		2549	{
		2550	int sbt, dbt, ft, r, t, size, align, bit_size, bit_pos, rc, delayed_cast;
		2551
		2552	ft = vtop[-1].type.t;
		2553	sbt = vtop->type.t & VT_BTYPE;
		2554	dbt = ft & VT_BTYPE;
		2555	if ((((sbt == VT_INT \|\| sbt == VT_SHORT) && dbt == VT_BYTE) \|\|
		2556	(sbt == VT_INT && dbt == VT_SHORT))
		2557	&& !(vtop->type.t & VT_BITFIELD)) {
		2558	/* optimize char/short casts */
		2559	delayed_cast = VT_MUSTCAST;
		2560	vtop->type.t = (ft & VT_TYPE & ~VT_BITFIELD &
		2561	((1 << VT_STRUCT_SHIFT) - 1));
		2562	/* XXX: factorize */
		2563	if (ft & VT_CONSTANT)
		2564	tcc_warning("assignment of read-only location");
		2565	} else {
		2566	delayed_cast = 0;
		2567	if (!(ft & VT_BITFIELD))
		2568	gen_assign_cast(&vtop[-1].type);
		2569	}
		2570
		2571	if (sbt == VT_STRUCT) {
		2572	/* if structure, only generate pointer */
		2573	/* structure assignment : generate memcpy */
		2574	/* XXX: optimize if small size */
		2575	if (!nocode_wanted) {
		2576	size = type_size(&vtop->type, &align);
		2577
		2578	/* destination */
		2579	vswap();
		2580	vtop->type.t = VT_PTR;
		2581	gaddrof();
		2582
		2583	/* address of memcpy() */
		2584	#ifdef TCC_ARM_EABI
		2585	if(!(align & 7))
		2586	vpush_global_sym(&func_old_type, TOK_memcpy8);
		2587	else if(!(align & 3))
		2588	vpush_global_sym(&func_old_type, TOK_memcpy4);
		2589	else
		2590	#endif
		2591	/* Use memmove, rather than memcpy, as dest and src may be same: */
		2592	vpush_global_sym(&func_old_type, TOK_memmove);
		2593
		2594	vswap();
		2595	/* source */
		2596	vpushv(vtop - 2);
		2597	vtop->type.t = VT_PTR;
		2598	gaddrof();
		2599	/* type size */
		2600	vpushi(size);
		2601	gfunc_call(3);
		2602	} else {
		2603	vswap();
		2604	vpop();
		2605	}
		2606	/* leave source on stack */
		2607	} else if (ft & VT_BITFIELD) {
		2608	/* bitfield store handling */
		2609
		2610	/* save lvalue as expression result (example: s.b = s.a = n;) */
		2611	vdup(), vtop[-1] = vtop[-2];
		2612
		2613	bit_pos = (ft >> VT_STRUCT_SHIFT) & 0x3f;
		2614	bit_size = (ft >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
		2615	/* remove bit field info to avoid loops */
		2616	vtop[-1].type.t = ft & ~VT_BITFIELD & ((1 << VT_STRUCT_SHIFT) - 1);
		2617
		2618	if((ft & VT_BTYPE) == VT_BOOL) {
		2619	gen_cast(&vtop[-1].type);
		2620	vtop[-1].type.t = (vtop[-1].type.t & ~VT_BTYPE) \| (VT_BYTE \| VT_UNSIGNED);
		2621	}
		2622
		2623	/* duplicate destination */
		2624	vdup();
		2625	vtop[-1] = vtop[-2];
		2626
		2627	/* mask and shift source */
		2628	if((ft & VT_BTYPE) != VT_BOOL) {
		2629	if((ft & VT_BTYPE) == VT_LLONG) {
		2630	vpushll((1ULL << bit_size) - 1ULL);
		2631	} else {
		2632	vpushi((1 << bit_size) - 1);
		2633	}
		2634	gen_op('&');
		2635	}
		2636	vpushi(bit_pos);
		2637	gen_op(TOK_SHL);
		2638	/* load destination, mask and or with source */
		2639	vswap();
		2640	if((ft & VT_BTYPE) == VT_LLONG) {
		2641	vpushll(~(((1ULL << bit_size) - 1ULL) << bit_pos));
		2642	} else {
		2643	vpushi(~(((1 << bit_size) - 1) << bit_pos));
		2644	}
		2645	gen_op('&');
		2646	gen_op('\|');
		2647	/* store result */
		2648	vstore();
		2649	/* ... and discard */
		2650	vpop();
		2651
		2652	} else {
		2653	if (!nocode_wanted) {
		2654	#ifdef CONFIG_TCC_BCHECK
		2655	/* bound check case */
		2656	if (vtop[-1].r & VT_MUSTBOUND) {
		2657	vswap();
		2658	gbound();
		2659	vswap();
		2660	}
		2661	#endif
		2662	rc = RC_INT;
		2663	if (is_float(ft)) {
		2664	rc = RC_FLOAT;
		2665	#ifdef TCC_TARGET_X86_64
		2666	if ((ft & VT_BTYPE) == VT_LDOUBLE) {
		2667	rc = RC_ST0;
		2668	} else if ((ft & VT_BTYPE) == VT_QFLOAT) {
		2669	rc = RC_FRET;
		2670	}
		2671	#endif
		2672	}
		2673	r = gv(rc); /* generate value */
		2674	/* if lvalue was saved on stack, must read it */
		2675	if ((vtop[-1].r & VT_VALMASK) == VT_LLOCAL) {
		2676	SValue sv;
		2677	t = get_reg(RC_INT);
		2678	#if defined(TCC_TARGET_ARM64) \|\| defined(TCC_TARGET_X86_64)
		2679	sv.type.t = VT_PTR;
		2680	#else
		2681	sv.type.t = VT_INT;
		2682	#endif
		2683	sv.r = VT_LOCAL \| VT_LVAL;
		2684	sv.c.i = vtop[-1].c.i;
		2685	load(t, &sv);
		2686	vtop[-1].r = t \| VT_LVAL;
		2687	}
		2688	/* two word case handling : store second register at word + 4 (or +8 for x86-64) */
		2689	#if defined(TCC_TARGET_ARM64) \|\| defined(TCC_TARGET_X86_64)
		2690	if (((ft & VT_BTYPE) == VT_QLONG) \|\| ((ft & VT_BTYPE) == VT_QFLOAT)) {
		2691	int addr_type = VT_LLONG, load_size = 8, load_type = ((vtop->type.t & VT_BTYPE) == VT_QLONG) ? VT_LLONG : VT_DOUBLE;
		2692	#else
		2693	if ((ft & VT_BTYPE) == VT_LLONG) {
		2694	int addr_type = VT_INT, load_size = 4, load_type = VT_INT;
		2695	#endif
		2696	vtop[-1].type.t = load_type;
		2697	store(r, vtop - 1);
		2698	vswap();
		2699	/* convert to int to increment easily */
		2700	vtop->type.t = addr_type;
		2701	gaddrof();
		2702	vpushi(load_size);
		2703	gen_op('+');
		2704	vtop->r \|= VT_LVAL;
		2705	vswap();
		2706	vtop[-1].type.t = load_type;
		2707	/* XXX: it works because r2 is spilled last ! */
		2708	store(vtop->r2, vtop - 1);
		2709	} else {
		2710	store(r, vtop - 1);
		2711	}
		2712	}
		2713	vswap();
		2714	vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
		2715	vtop->r \|= delayed_cast;
		2716	}
		2717	}
		2718
		2719	/* post defines POST/PRE add. c is the token ++ or -- */
		2720	ST_FUNC void inc(int post, int c)
		2721	{
		2722	test_lvalue();
		2723	vdup(); /* save lvalue */
		2724	if (post) {
		2725	if (!nocode_wanted)
		2726	gv_dup(); /* duplicate value */
		2727	else
		2728	vdup(); /* duplicate value */
		2729	vrotb(3);
		2730	vrotb(3);
		2731	}
		2732	/* add constant */
		2733	vpushi(c - TOK_MID);
		2734	gen_op('+');
		2735	vstore(); /* store value */
		2736	if (post)
		2737	vpop(); /* if post op, return saved value */
		2738	}
		2739
		2740	/* Parse GNUC __attribute__ extension. Currently, the following
		2741	extensions are recognized:
		2742	- aligned(n) : set data/function alignment.
		2743	- packed : force data alignment to 1
		2744	- section(x) : generate data/code in this section.
		2745	- unused : currently ignored, but may be used someday.
		2746	- regparm(n) : pass function parameters in registers (i386 only)
		2747	*/
		2748	static void parse_attribute(AttributeDef *ad)
		2749	{
		2750	int t, n;
		2751
		2752	while (tok == TOK_ATTRIBUTE1 \|\| tok == TOK_ATTRIBUTE2) {
		2753	next();
		2754	skip('(');
		2755	skip('(');
		2756	while (tok != ')') {
		2757	if (tok < TOK_IDENT)
		2758	expect("attribute name");
		2759	t = tok;
		2760	next();
		2761	switch(t) {
		2762	case TOK_SECTION1:
		2763	case TOK_SECTION2:
		2764	skip('(');
		2765	if (tok != TOK_STR)
		2766	expect("section name");
		2767	ad->section = find_section(tcc_state, (char *)tokc.str.data);
		2768	next();
		2769	skip(')');
		2770	break;
		2771	case TOK_ALIAS1:
		2772	case TOK_ALIAS2:
		2773	skip('(');
		2774	if (tok != TOK_STR)
		2775	expect("alias(\"target\")");
		2776	ad->alias_target = /* save string as token, for later */
		2777	tok_alloc((char*)tokc.str.data, tokc.str.size-1)->tok;
		2778	next();
		2779	skip(')');
		2780	break;
		2781	case TOK_VISIBILITY1:
		2782	case TOK_VISIBILITY2:
		2783	skip('(');
		2784	if (tok != TOK_STR)
		2785	expect("visibility(\"default\|hidden\|internal\|protected\")");
		2786	if (!strcmp (tokc.str.data, "default"))
		2787	ad->a.visibility = STV_DEFAULT;
		2788	else if (!strcmp (tokc.str.data, "hidden"))
		2789	ad->a.visibility = STV_HIDDEN;
		2790	else if (!strcmp (tokc.str.data, "internal"))
		2791	ad->a.visibility = STV_INTERNAL;
		2792	else if (!strcmp (tokc.str.data, "protected"))
		2793	ad->a.visibility = STV_PROTECTED;
		2794	else
		2795	expect("visibility(\"default\|hidden\|internal\|protected\")");
		2796	next();
		2797	skip(')');
		2798	break;
		2799	case TOK_ALIGNED1:
		2800	case TOK_ALIGNED2:
		2801	if (tok == '(') {
		2802	next();
		2803	n = expr_const();
		2804	if (n <= 0 \|\| (n & (n - 1)) != 0)
		2805	tcc_error("alignment must be a positive power of two");
		2806	skip(')');
		2807	} else {
		2808	n = MAX_ALIGN;
		2809	}
		2810	ad->a.aligned = n;
		2811	break;
		2812	case TOK_PACKED1:
		2813	case TOK_PACKED2:
		2814	ad->a.packed = 1;
		2815	break;
		2816	case TOK_WEAK1:
		2817	case TOK_WEAK2:
		2818	ad->a.weak = 1;
		2819	break;
		2820	case TOK_UNUSED1:
		2821	case TOK_UNUSED2:
		2822	/* currently, no need to handle it because tcc does not
		2823	track unused objects */
		2824	break;
		2825	case TOK_NORETURN1:
		2826	case TOK_NORETURN2:
		2827	/* currently, no need to handle it because tcc does not
		2828	track unused objects */
		2829	break;
		2830	case TOK_CDECL1:
		2831	case TOK_CDECL2:
		2832	case TOK_CDECL3:
		2833	ad->a.func_call = FUNC_CDECL;
		2834	break;
		2835	case TOK_STDCALL1:
		2836	case TOK_STDCALL2:
		2837	case TOK_STDCALL3:
		2838	ad->a.func_call = FUNC_STDCALL;
		2839	break;
		2840	#ifdef TCC_TARGET_I386
		2841	case TOK_REGPARM1:
		2842	case TOK_REGPARM2:
		2843	skip('(');
		2844	n = expr_const();
		2845	if (n > 3)
		2846	n = 3;
		2847	else if (n < 0)
		2848	n = 0;
		2849	if (n > 0)
		2850	ad->a.func_call = FUNC_FASTCALL1 + n - 1;
		2851	skip(')');
		2852	break;
		2853	case TOK_FASTCALL1:
		2854	case TOK_FASTCALL2:
		2855	case TOK_FASTCALL3:
		2856	ad->a.func_call = FUNC_FASTCALLW;
		2857	break;
		2858	#endif
		2859	case TOK_MODE:
		2860	skip('(');
		2861	switch(tok) {
		2862	case TOK_MODE_DI:
		2863	ad->a.mode = VT_LLONG + 1;
		2864	break;
		2865	case TOK_MODE_HI:
		2866	ad->a.mode = VT_SHORT + 1;
		2867	break;
		2868	case TOK_MODE_SI:
		2869	ad->a.mode = VT_INT + 1;
		2870	break;
		2871	default:
		2872	tcc_warning("__mode__(%s) not supported\n", get_tok_str(tok, NULL));
		2873	break;
		2874	}
		2875	next();
		2876	skip(')');
		2877	break;
		2878	case TOK_DLLEXPORT:
		2879	ad->a.func_export = 1;
		2880	break;
		2881	case TOK_DLLIMPORT:
		2882	ad->a.func_import = 1;
		2883	break;
		2884	default:
		2885	if (tcc_state->warn_unsupported)
		2886	tcc_warning("'%s' attribute ignored", get_tok_str(t, NULL));
		2887	/* skip parameters */
		2888	if (tok == '(') {
		2889	int parenthesis = 0;
		2890	do {
		2891	if (tok == '(')
		2892	parenthesis++;
		2893	else if (tok == ')')
		2894	parenthesis--;
		2895	next();
		2896	} while (parenthesis && tok != -1);
		2897	}
		2898	break;
		2899	}
		2900	if (tok != ',')
		2901	break;
		2902	next();
		2903	}
		2904	skip(')');
		2905	skip(')');
		2906	}
		2907	}
		2908
		2909	/* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
		2910	static void struct_decl(CType type, AttributeDef ad, int u)
		2911	{
		2912	int a, v, size, align, maxalign, c, offset, flexible;
		2913	int bit_size, bit_pos, bsize, bt, lbit_pos, prevbt;
		2914	Sym s, ss, ass, *ps;
		2915	AttributeDef ad1;
		2916	CType type1, btype;
		2917
		2918	a = tok; /* save decl type */
		2919	next();
		2920	if (tok == TOK_ATTRIBUTE1 \|\| tok == TOK_ATTRIBUTE2) {
		2921	parse_attribute(ad);
		2922	next();
		2923	}
		2924	if (tok != '{') {
		2925	v = tok;
		2926	next();
		2927	/* struct already defined ? return it */
		2928	if (v < TOK_IDENT)
		2929	expect("struct/union/enum name");
		2930	s = struct_find(v);
		2931	if (s) {
		2932	if (s->type.t != a)
		2933	tcc_error("invalid type");
		2934	goto do_decl;
		2935	}
		2936	} else {
		2937	v = anon_sym++;
		2938	}
		2939	type1.t = a;
		2940	type1.ref = NULL;
		2941	/* we put an undefined size for struct/union */
		2942	s = sym_push(v \| SYM_STRUCT, &type1, 0, -1);
		2943	s->r = 0; /* default alignment is zero as gcc */
		2944	/* put struct/union/enum name in type */
		2945	do_decl:
		2946	type->t = u;
		2947	type->ref = s;
		2948
		2949	if (tok == '{') {
		2950	next();
		2951	if (s->c != -1)
		2952	tcc_error("struct/union/enum already defined");
		2953	/* cannot be empty */
		2954	c = 0;
		2955	/* non empty enums are not allowed */
		2956	if (a == TOK_ENUM) {
		2957	for(;;) {
		2958	v = tok;
		2959	if (v < TOK_UIDENT)
		2960	expect("identifier");
		2961	ss = sym_find(v);
		2962	if (ss && !local_stack)
		2963	tcc_error("redefinition of enumerator '%s'",
		2964	get_tok_str(v, NULL));
		2965	next();
		2966	if (tok == '=') {
		2967	next();
		2968	c = expr_const();
		2969	}
		2970	/* enum symbols have static storage */
		2971	ss = sym_push(v, &int_type, VT_CONST, c);
		2972	ss->type.t \|= VT_STATIC;
		2973	if (tok != ',')
		2974	break;
		2975	next();
		2976	c++;
		2977	/* NOTE: we accept a trailing comma */
		2978	if (tok == '}')
		2979	break;
		2980	}
		2981	s->c = type_size(&int_type, &align);
		2982	skip('}');
		2983	} else {
		2984	maxalign = 1;
		2985	ps = &s->next;
		2986	prevbt = VT_INT;
		2987	bit_pos = 0;
		2988	offset = 0;
		2989	flexible = 0;
		2990	while (tok != '}') {
		2991	parse_btype(&btype, &ad1);
		2992	while (1) {
		2993	if (flexible)
		2994	tcc_error("flexible array member '%s' not at the end of struct",
		2995	get_tok_str(v, NULL));
		2996	bit_size = -1;
		2997	v = 0;
		2998	type1 = btype;
		2999	if (tok != ':') {
		3000	type_decl(&type1, &ad1, &v, TYPE_DIRECT \| TYPE_ABSTRACT);
		3001	if (v == 0) {
		3002	if ((type1.t & VT_BTYPE) != VT_STRUCT)
		3003	expect("identifier");
		3004	else {
		3005	int v = btype.ref->v;
		3006	if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
		3007	if (tcc_state->ms_extensions == 0)
		3008	expect("identifier");
		3009	}
		3010	}
		3011	}
		3012	if (type_size(&type1, &align) < 0) {
		3013	if ((a == TOK_STRUCT) && (type1.t & VT_ARRAY) && c)
		3014	flexible = 1;
		3015	else
		3016	tcc_error("field '%s' has incomplete type",
		3017	get_tok_str(v, NULL));
		3018	}
		3019	if ((type1.t & VT_BTYPE) == VT_FUNC \|\|
		3020	(type1.t & (VT_TYPEDEF \| VT_STATIC \| VT_EXTERN \| VT_INLINE)))
		3021	tcc_error("invalid type for '%s'",
		3022	get_tok_str(v, NULL));
		3023	}
		3024	if (tok == ':') {
		3025	next();
		3026	bit_size = expr_const();
		3027	/* XXX: handle v = 0 case for messages */
		3028	if (bit_size < 0)
		3029	tcc_error("negative width in bit-field '%s'",
		3030	get_tok_str(v, NULL));
		3031	if (v && bit_size == 0)
		3032	tcc_error("zero width for bit-field '%s'",
		3033	get_tok_str(v, NULL));
		3034	}
		3035	size = type_size(&type1, &align);
		3036	if (ad1.a.aligned) {
		3037	if (align < ad1.a.aligned)
		3038	align = ad1.a.aligned;
		3039	} else if (ad1.a.packed) {
		3040	align = 1;
		3041	} else if (*tcc_state->pack_stack_ptr) {
		3042	if (align > *tcc_state->pack_stack_ptr)
		3043	align = *tcc_state->pack_stack_ptr;
		3044	}
		3045	lbit_pos = 0;
		3046	if (bit_size >= 0) {
		3047	bt = type1.t & VT_BTYPE;
		3048	if (bt != VT_INT &&
		3049	bt != VT_BYTE &&
		3050	bt != VT_SHORT &&
		3051	bt != VT_BOOL &&
		3052	bt != VT_ENUM &&
		3053	bt != VT_LLONG)
		3054	tcc_error("bitfields must have scalar type");
		3055	bsize = size * 8;
		3056	if (bit_size > bsize) {
		3057	tcc_error("width of '%s' exceeds its type",
		3058	get_tok_str(v, NULL));
		3059	} else if (bit_size == bsize) {
		3060	/* no need for bit fields */
		3061	bit_pos = 0;
		3062	} else if (bit_size == 0) {
		3063	/* XXX: what to do if only padding in a
		3064	structure ? */
		3065	/* zero size: means to pad */
		3066	bit_pos = 0;
		3067	} else {
		3068	/* we do not have enough room ?
		3069	did the type change?
		3070	is it a union? */
		3071	if ((bit_pos + bit_size) > bsize \|\|
		3072	bt != prevbt \|\| a == TOK_UNION)
		3073	bit_pos = 0;
		3074	lbit_pos = bit_pos;
		3075	/* XXX: handle LSB first */
		3076	type1.t \|= VT_BITFIELD \|
		3077	(bit_pos << VT_STRUCT_SHIFT) \|
		3078	(bit_size << (VT_STRUCT_SHIFT + 6));
		3079	bit_pos += bit_size;
		3080	}
		3081	prevbt = bt;
		3082	} else {
		3083	bit_pos = 0;
		3084	}
		3085	if (v != 0 \|\| (type1.t & VT_BTYPE) == VT_STRUCT) {
		3086	/* add new memory data only if starting
		3087	bit field */
		3088	if (lbit_pos == 0) {
		3089	if (a == TOK_STRUCT) {
		3090	c = (c + align - 1) & -align;
		3091	offset = c;
		3092	if (size > 0)
		3093	c += size;
		3094	} else {
		3095	offset = 0;
		3096	if (size > c)
		3097	c = size;
		3098	}
		3099	if (align > maxalign)
		3100	maxalign = align;
		3101	}
		3102	#if 0
		3103	printf("add field %s offset=%d",
		3104	get_tok_str(v, NULL), offset);
		3105	if (type1.t & VT_BITFIELD) {
		3106	printf(" pos=%d size=%d",
		3107	(type1.t >> VT_STRUCT_SHIFT) & 0x3f,
		3108	(type1.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f);
		3109	}
		3110	printf("\n");
		3111	#endif
		3112	}
		3113	if (v == 0 && (type1.t & VT_BTYPE) == VT_STRUCT) {
		3114	ass = type1.ref;
		3115	while ((ass = ass->next) != NULL) {
		3116	ss = sym_push(ass->v, &ass->type, 0, offset + ass->c);
		3117	*ps = ss;
		3118	ps = &ss->next;
		3119	}
		3120	} else if (v) {
		3121	ss = sym_push(v \| SYM_FIELD, &type1, 0, offset);
		3122	*ps = ss;
		3123	ps = &ss->next;
		3124	}
		3125	if (tok == ';' \|\| tok == TOK_EOF)
		3126	break;
		3127	skip(',');
		3128	}
		3129	skip(';');
		3130	}
		3131	skip('}');
		3132	/* store size and alignment */
		3133	s->c = (c + maxalign - 1) & -maxalign;
		3134	s->r = maxalign;
		3135	}
		3136	}
		3137	}
		3138
		3139	/* return 1 if basic type is a type size (short, long, long long) */
		3140	ST_FUNC int is_btype_size(int bt)
		3141	{
		3142	return bt == VT_SHORT \|\| bt == VT_LONG \|\| bt == VT_LLONG;
		3143	}
		3144
		3145	/* Add type qualifiers to a type. If the type is an array then the qualifiers
		3146	are added to the element type, copied because it could be a typedef. */
		3147	static void parse_btype_qualify(CType *type, int qualifiers)
		3148	{
		3149	while (type->t & VT_ARRAY) {
		3150	type->ref = sym_push(SYM_FIELD, &type->ref->type, 0, type->ref->c);
		3151	type = &type->ref->type;
		3152	}
		3153	type->t \|= qualifiers;
		3154	}
		3155
		3156	/* return 0 if no type declaration. otherwise, return the basic type
		3157	and skip it.
		3158	*/
		3159	static int parse_btype(CType type, AttributeDef ad)
		3160	{
		3161	int t, u, bt_size, complete, type_found, typespec_found;
		3162	Sym *s;
		3163	CType type1;
		3164
		3165	memset(ad, 0, sizeof(AttributeDef));
		3166	complete = 0;
		3167	type_found = 0;
		3168	typespec_found = 0;
		3169	t = 0;
		3170	while(1) {
		3171	switch(tok) {
		3172	case TOK_EXTENSION:
		3173	/* currently, we really ignore extension */
		3174	next();
		3175	continue;
		3176
		3177	/* basic types */
		3178	case TOK_CHAR:
		3179	u = VT_BYTE;
		3180	basic_type:
		3181	next();
		3182	basic_type1:
		3183	if (complete)
		3184	tcc_error("too many basic types");
		3185	t \|= u;
		3186	bt_size = is_btype_size (u & VT_BTYPE);
		3187	if (u == VT_INT \|\| (!bt_size && !(t & VT_TYPEDEF)))
		3188	complete = 1;
		3189	typespec_found = 1;
		3190	break;
		3191	case TOK_VOID:
		3192	u = VT_VOID;
		3193	goto basic_type;
		3194	case TOK_SHORT:
		3195	u = VT_SHORT;
		3196	goto basic_type;
		3197	case TOK_INT:
		3198	u = VT_INT;
		3199	goto basic_type;
		3200	case TOK_LONG:
		3201	next();
		3202	if ((t & VT_BTYPE) == VT_DOUBLE) {
		3203	/* siemargl not sure, needed long double or will fail ? FAIL */
		3204	#if !defined(TCC_TARGET_PE) && !defined(TCC_TARGET_MEOS)
		3205	t = (t & ~VT_BTYPE) \| VT_LDOUBLE;
		3206	#endif
		3207	} else if ((t & VT_BTYPE) == VT_LONG) {
		3208	t = (t & ~VT_BTYPE) \| VT_LLONG;
		3209	} else {
		3210	u = VT_LONG;
		3211	goto basic_type1;
		3212	}
		3213	break;
		3214	#ifdef TCC_TARGET_ARM64
		3215	case TOK_UINT128:
		3216	/* GCC's __uint128_t appears in some Linux header files. Make it a
		3217	synonym for long double to get the size and alignment right. */
		3218	u = VT_LDOUBLE;
		3219	goto basic_type;
		3220	#endif
		3221	case TOK_BOOL:
		3222	u = VT_BOOL;
		3223	goto basic_type;
		3224	case TOK_FLOAT:
		3225	u = VT_FLOAT;
		3226	goto basic_type;
		3227	case TOK_DOUBLE:
		3228	next();
		3229	if ((t & VT_BTYPE) == VT_LONG) {
		3230	/* siemargl not sure, needed long double or will fail ? FAIL */
		3231	#if defined(TCC_TARGET_PE) \|\| defined(TCC_TARGET_MEOS)
		3232	t = (t & ~VT_BTYPE) \| VT_DOUBLE;
		3233	#else
		3234	t = (t & ~VT_BTYPE) \| VT_LDOUBLE;
		3235	#endif
		3236	} else {
		3237	u = VT_DOUBLE;
		3238	goto basic_type1;
		3239	}
		3240	break;
		3241	case TOK_ENUM:
		3242	struct_decl(&type1, ad, VT_ENUM);
		3243	basic_type2:
		3244	u = type1.t;
		3245	type->ref = type1.ref;
		3246	goto basic_type1;
		3247	case TOK_STRUCT:
		3248	case TOK_UNION:
		3249	struct_decl(&type1, ad, VT_STRUCT);
		3250	goto basic_type2;
		3251
		3252	/* type modifiers */
		3253	case TOK_CONST1:
		3254	case TOK_CONST2:
		3255	case TOK_CONST3:
		3256	type->t = t;
		3257	parse_btype_qualify(type, VT_CONSTANT);
		3258	t = type->t;
		3259	next();
		3260	break;
		3261	case TOK_VOLATILE1:
		3262	case TOK_VOLATILE2:
		3263	case TOK_VOLATILE3:
		3264	type->t = t;
		3265	parse_btype_qualify(type, VT_VOLATILE);
		3266	t = type->t;
		3267	next();
		3268	break;
		3269	case TOK_SIGNED1:
		3270	case TOK_SIGNED2:
		3271	case TOK_SIGNED3:
		3272	if ((t & (VT_DEFSIGN\|VT_UNSIGNED)) == (VT_DEFSIGN\|VT_UNSIGNED))
		3273	tcc_error("signed and unsigned modifier");
		3274	typespec_found = 1;
		3275	t \|= VT_DEFSIGN;
		3276	next();
		3277	break;
		3278	case TOK_REGISTER:
		3279	case TOK_AUTO:
		3280	case TOK_RESTRICT1:
		3281	case TOK_RESTRICT2:
		3282	case TOK_RESTRICT3:
		3283	next();
		3284	break;
		3285	case TOK_UNSIGNED:
		3286	if ((t & (VT_DEFSIGN\|VT_UNSIGNED)) == VT_DEFSIGN)
		3287	tcc_error("signed and unsigned modifier");
		3288	t \|= VT_DEFSIGN \| VT_UNSIGNED;
		3289	next();
		3290	typespec_found = 1;
		3291	break;
		3292
		3293	/* storage */
		3294	case TOK_EXTERN:
		3295	t \|= VT_EXTERN;
		3296	next();
		3297	break;
		3298	case TOK_STATIC:
		3299	t \|= VT_STATIC;
		3300	next();
		3301	break;
		3302	case TOK_TYPEDEF:
		3303	t \|= VT_TYPEDEF;
		3304	next();
		3305	break;
		3306	case TOK_INLINE1:
		3307	case TOK_INLINE2:
		3308	case TOK_INLINE3:
		3309	t \|= VT_INLINE;
		3310	next();
		3311	break;
		3312
		3313	/* GNUC attribute */
		3314	case TOK_ATTRIBUTE1:
		3315	case TOK_ATTRIBUTE2:
		3316	parse_attribute(ad);
		3317	if (ad->a.mode) {
		3318	u = ad->a.mode -1;
		3319	t = (t & ~VT_BTYPE) \| u;
		3320	}
		3321	break;
		3322	/* GNUC typeof */
		3323	case TOK_TYPEOF1:
		3324	case TOK_TYPEOF2:
		3325	case TOK_TYPEOF3:
		3326	next();
		3327	parse_expr_type(&type1);
		3328	/* remove all storage modifiers except typedef */
		3329	type1.t &= ~(VT_STORAGE&~VT_TYPEDEF);
		3330	goto basic_type2;
		3331	default:
		3332	if (typespec_found)
		3333	goto the_end;
		3334	s = sym_find(tok);
		3335	if (!s \|\| !(s->type.t & VT_TYPEDEF))
		3336	goto the_end;
		3337
		3338	type->t = ((s->type.t & ~VT_TYPEDEF) \|
		3339	(t & ~(VT_CONSTANT \| VT_VOLATILE)));
		3340	type->ref = s->type.ref;
		3341	if (t & (VT_CONSTANT \| VT_VOLATILE))
		3342	parse_btype_qualify(type, t & (VT_CONSTANT \| VT_VOLATILE));
		3343	t = type->t;
		3344
		3345	if (s->r) {
		3346	/* get attributes from typedef */
		3347	if (0 == ad->a.aligned)
		3348	ad->a.aligned = s->a.aligned;
		3349	if (0 == ad->a.func_call)
		3350	ad->a.func_call = s->a.func_call;
		3351	ad->a.packed \|= s->a.packed;
		3352	}
		3353	next();
		3354	typespec_found = 1;
		3355	break;
		3356	}
		3357	type_found = 1;
		3358	}
		3359	the_end:
		3360	if (tcc_state->char_is_unsigned) {
		3361	if ((t & (VT_DEFSIGN\|VT_BTYPE)) == VT_BYTE)
		3362	t \|= VT_UNSIGNED;
		3363	}
		3364
		3365	/* long is never used as type */
		3366	if ((t & VT_BTYPE) == VT_LONG)
		3367	#if (!defined TCC_TARGET_X86_64 && !defined TCC_TARGET_ARM64) \|\| \
		3368	defined TCC_TARGET_PE \|\| defined TCC_TARGET_MEOS
		3369	t = (t & ~VT_BTYPE) \| VT_INT;
		3370	#else
		3371	t = (t & ~VT_BTYPE) \| VT_LLONG;
		3372	#endif
		3373	type->t = t;
		3374	return type_found;
		3375	}
		3376
		3377	/* convert a function parameter type (array to pointer and function to
		3378	function pointer) */
		3379	static inline void convert_parameter_type(CType *pt)
		3380	{
		3381	/* remove const and volatile qualifiers (XXX: const could be used
		3382	to indicate a const function parameter */
		3383	pt->t &= ~(VT_CONSTANT \| VT_VOLATILE);
		3384	/* array must be transformed to pointer according to ANSI C */
		3385	pt->t &= ~VT_ARRAY;
		3386	if ((pt->t & VT_BTYPE) == VT_FUNC) {
		3387	mk_pointer(pt);
		3388	}
		3389	}
		3390
		3391	ST_FUNC void parse_asm_str(CString *astr)
		3392	{
		3393	skip('(');
		3394	/* read the string */
		3395	if (tok != TOK_STR)
		3396	expect("string constant");
		3397	cstr_new(astr);
		3398	while (tok == TOK_STR) {
		3399	/* XXX: add \0 handling too ? */
		3400	cstr_cat(astr, tokc.str.data, -1);
		3401	next();
		3402	}
		3403	cstr_ccat(astr, '\0');
		3404	}
		3405
		3406	/* Parse an asm label and return the token */
		3407	static int asm_label_instr(void)
		3408	{
		3409	int v;
		3410	CString astr;
		3411
		3412	next();
		3413	parse_asm_str(&astr);
		3414	skip(')');
		3415	#ifdef ASM_DEBUG
		3416	printf("asm_alias: \"%s\"\n", (char *)astr.data);
		3417	#endif
		3418	v = tok_alloc(astr.data, astr.size - 1)->tok;
		3419	cstr_free(&astr);
		3420	return v;
		3421	}
		3422
		3423	static void post_type(CType type, AttributeDef ad)
		3424	{
		3425	int n, l, t1, arg_size, align;
		3426	Sym *plast, s, *first;
		3427	AttributeDef ad1;
		3428	CType pt;
		3429
		3430	if (tok == '(') {
		3431	/* function declaration */
		3432	next();
		3433	l = 0;
		3434	first = NULL;
		3435	plast = &first;
		3436	arg_size = 0;
		3437	if (tok != ')') {
		3438	for(;;) {
		3439	/* read param name and compute offset */
		3440	if (l != FUNC_OLD) {
		3441	if (!parse_btype(&pt, &ad1)) {
		3442	if (l) {
		3443	tcc_error("invalid type");
		3444	} else {
		3445	l = FUNC_OLD;
		3446	goto old_proto;
		3447	}
		3448	}
		3449	l = FUNC_NEW;
		3450	if ((pt.t & VT_BTYPE) == VT_VOID && tok == ')')
		3451	break;
		3452	type_decl(&pt, &ad1, &n, TYPE_DIRECT \| TYPE_ABSTRACT);
		3453	if ((pt.t & VT_BTYPE) == VT_VOID)
		3454	tcc_error("parameter declared as void");
		3455	arg_size += (type_size(&pt, &align) + PTR_SIZE - 1) / PTR_SIZE;
		3456	} else {
		3457	old_proto:
		3458	n = tok;
		3459	if (n < TOK_UIDENT)
		3460	expect("identifier");
		3461	pt.t = VT_INT;
		3462	next();
		3463	}
		3464	convert_parameter_type(&pt);
		3465	s = sym_push(n \| SYM_FIELD, &pt, 0, 0);
		3466	*plast = s;
		3467	plast = &s->next;
		3468	if (tok == ')')
		3469	break;
		3470	skip(',');
		3471	if (l == FUNC_NEW && tok == TOK_DOTS) {
		3472	l = FUNC_ELLIPSIS;
		3473	next();
		3474	break;
		3475	}
		3476	}
		3477	}
		3478	/* if no parameters, then old type prototype */
		3479	if (l == 0)
		3480	l = FUNC_OLD;
		3481	skip(')');
		3482	/* NOTE: const is ignored in returned type as it has a special
		3483	meaning in gcc / C++ */
		3484	type->t &= ~VT_CONSTANT;
		3485	/* some ancient pre-K&R C allows a function to return an array
		3486	and the array brackets to be put after the arguments, such
		3487	that "int c()[]" means something like "int[] c()" */
		3488	if (tok == '[') {
		3489	next();
		3490	skip(']'); /* only handle simple "[]" */
		3491	type->t \|= VT_PTR;
		3492	}
		3493	/* we push a anonymous symbol which will contain the function prototype */
		3494	ad->a.func_args = arg_size;
		3495	s = sym_push(SYM_FIELD, type, 0, l);
		3496	s->a = ad->a;
		3497	s->next = first;
		3498	type->t = VT_FUNC;
		3499	type->ref = s;
		3500	} else if (tok == '[') {
		3501	/* array definition */
		3502	next();
		3503	if (tok == TOK_RESTRICT1)
		3504	next();
		3505	n = -1;
		3506	t1 = 0;
		3507	if (tok != ']') {
		3508	if (!local_stack \|\| nocode_wanted)
		3509	vpushi(expr_const());
		3510	else gexpr();
		3511	if ((vtop->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == VT_CONST) {
		3512	n = vtop->c.i;
		3513	if (n < 0)
		3514	tcc_error("invalid array size");
		3515	} else {
		3516	if (!is_integer_btype(vtop->type.t & VT_BTYPE))
		3517	tcc_error("size of variable length array should be an integer");
		3518	t1 = VT_VLA;
		3519	}
		3520	}
		3521	skip(']');
		3522	/* parse next post type */
		3523	post_type(type, ad);
		3524	if (type->t == VT_FUNC)
		3525	tcc_error("declaration of an array of functions");
		3526	t1 \|= type->t & VT_VLA;
		3527
		3528	if (t1 & VT_VLA) {
		3529	loc -= type_size(&int_type, &align);
		3530	loc &= -align;
		3531	n = loc;
		3532
		3533	vla_runtime_type_size(type, &align);
		3534	gen_op('*');
		3535	vset(&int_type, VT_LOCAL\|VT_LVAL, n);
		3536	vswap();
		3537	vstore();
		3538	}
		3539	if (n != -1)
		3540	vpop();
		3541
		3542	/* we push an anonymous symbol which will contain the array
		3543	element type */
		3544	s = sym_push(SYM_FIELD, type, 0, n);
		3545	type->t = (t1 ? VT_VLA : VT_ARRAY) \| VT_PTR;
		3546	type->ref = s;
		3547	}
		3548	}
		3549
		3550	/* Parse a type declaration (except basic type), and return the type
		3551	in 'type'. 'td' is a bitmask indicating which kind of type decl is
		3552	expected. 'type' should contain the basic type. 'ad' is the
		3553	attribute definition of the basic type. It can be modified by
		3554	type_decl().
		3555	*/
		3556	static void type_decl(CType type, AttributeDef ad, int *v, int td)
		3557	{
		3558	Sym *s;
		3559	CType type1, *type2;
		3560	int qualifiers, storage;
		3561
		3562	while (tok == '*') {
		3563	qualifiers = 0;
		3564	redo:
		3565	next();
		3566	switch(tok) {
		3567	case TOK_CONST1:
		3568	case TOK_CONST2:
		3569	case TOK_CONST3:
		3570	qualifiers \|= VT_CONSTANT;
		3571	goto redo;
		3572	case TOK_VOLATILE1:
		3573	case TOK_VOLATILE2:
		3574	case TOK_VOLATILE3:
		3575	qualifiers \|= VT_VOLATILE;
		3576	goto redo;
		3577	case TOK_RESTRICT1:
		3578	case TOK_RESTRICT2:
		3579	case TOK_RESTRICT3:
		3580	goto redo;
		3581	}
		3582	mk_pointer(type);
		3583	type->t \|= qualifiers;
		3584	}
		3585
		3586	/* XXX: clarify attribute handling */
		3587	if (tok == TOK_ATTRIBUTE1 \|\| tok == TOK_ATTRIBUTE2)
		3588	parse_attribute(ad);
		3589
		3590	/* recursive type */
		3591	/* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
		3592	type1.t = 0; /* XXX: same as int */
		3593	if (tok == '(') {
		3594	next();
		3595	/* XXX: this is not correct to modify 'ad' at this point, but
		3596	the syntax is not clear */
		3597	if (tok == TOK_ATTRIBUTE1 \|\| tok == TOK_ATTRIBUTE2)
		3598	parse_attribute(ad);
		3599	type_decl(&type1, ad, v, td);
		3600	skip(')');
		3601	} else {
		3602	/* type identifier */
		3603	if (tok >= TOK_IDENT && (td & TYPE_DIRECT)) {
		3604	*v = tok;
		3605	next();
		3606	} else {
		3607	if (!(td & TYPE_ABSTRACT))
		3608	expect("identifier");
		3609	*v = 0;
		3610	}
		3611	}
		3612	storage = type->t & VT_STORAGE;
		3613	type->t &= ~VT_STORAGE;
		3614	if (storage & VT_STATIC) {
		3615	int saved_nocode_wanted = nocode_wanted;
		3616	nocode_wanted = 1;
		3617	post_type(type, ad);
		3618	nocode_wanted = saved_nocode_wanted;
		3619	} else
		3620	post_type(type, ad);
		3621	type->t \|= storage;
		3622	if (tok == TOK_ATTRIBUTE1 \|\| tok == TOK_ATTRIBUTE2)
		3623	parse_attribute(ad);
		3624
		3625	if (!type1.t)
		3626	return;
		3627	/* append type at the end of type1 */
		3628	type2 = &type1;
		3629	for(;;) {
		3630	s = type2->ref;
		3631	type2 = &s->type;
		3632	if (!type2->t) {
		3633	type2 = type;
		3634	break;
		3635	}
		3636	}
		3637	*type = type1;
		3638	}
		3639
		3640	/* compute the lvalue VT_LVAL_xxx needed to match type t. */
		3641	ST_FUNC int lvalue_type(int t)
		3642	{
		3643	int bt, r;
		3644	r = VT_LVAL;
		3645	bt = t & VT_BTYPE;
		3646	if (bt == VT_BYTE \|\| bt == VT_BOOL)
		3647	r \|= VT_LVAL_BYTE;
		3648	else if (bt == VT_SHORT)
		3649	r \|= VT_LVAL_SHORT;
		3650	else
		3651	return r;
		3652	if (t & VT_UNSIGNED)
		3653	r \|= VT_LVAL_UNSIGNED;
		3654	return r;
		3655	}
		3656
		3657	/* indirection with full error checking and bound check */
		3658	ST_FUNC void indir(void)
		3659	{
		3660	if ((vtop->type.t & VT_BTYPE) != VT_PTR) {
		3661	if ((vtop->type.t & VT_BTYPE) == VT_FUNC)
		3662	return;
		3663	expect("pointer");
		3664	}
		3665	if ((vtop->r & VT_LVAL) && !nocode_wanted)
		3666	gv(RC_INT);
		3667	vtop->type = *pointed_type(&vtop->type);
		3668	/* Arrays and functions are never lvalues */
		3669	if (!(vtop->type.t & VT_ARRAY) && !(vtop->type.t & VT_VLA)
		3670	&& (vtop->type.t & VT_BTYPE) != VT_FUNC) {
		3671	vtop->r \|= lvalue_type(vtop->type.t);
		3672	/* if bound checking, the referenced pointer must be checked */
		3673	#ifdef CONFIG_TCC_BCHECK
		3674	if (tcc_state->do_bounds_check)
		3675	vtop->r \|= VT_MUSTBOUND;
		3676	#endif
		3677	}
		3678	}
		3679
		3680	/* pass a parameter to a function and do type checking and casting */
		3681	static void gfunc_param_typed(Sym func, Sym arg)
		3682	{
		3683	int func_type;
		3684	CType type;
		3685
		3686	func_type = func->c;
		3687	if (func_type == FUNC_OLD \|\|
		3688	(func_type == FUNC_ELLIPSIS && arg == NULL)) {
		3689	/* default casting : only need to convert float to double */
		3690	if ((vtop->type.t & VT_BTYPE) == VT_FLOAT) {
		3691	type.t = VT_DOUBLE;
		3692	gen_cast(&type);
		3693	} else if (vtop->type.t & VT_BITFIELD) {
		3694	type.t = vtop->type.t & (VT_BTYPE \| VT_UNSIGNED);
		3695	gen_cast(&type);
		3696	}
		3697	} else if (arg == NULL) {
		3698	tcc_error("too many arguments to function");
		3699	} else {
		3700	type = arg->type;
		3701	type.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */
		3702	gen_assign_cast(&type);
		3703	}
		3704	}
		3705
		3706	/* parse an expression of the form '(type)' or '(expr)' and return its
		3707	type */
		3708	static void parse_expr_type(CType *type)
		3709	{
		3710	int n;
		3711	AttributeDef ad;
		3712
		3713	skip('(');
		3714	if (parse_btype(type, &ad)) {
		3715	type_decl(type, &ad, &n, TYPE_ABSTRACT);
		3716	} else {
		3717	expr_type(type);
		3718	}
		3719	skip(')');
		3720	}
		3721
		3722	static void parse_type(CType *type)
		3723	{
		3724	AttributeDef ad;
		3725	int n;
		3726
		3727	if (!parse_btype(type, &ad)) {
		3728	expect("type");
		3729	}
		3730	type_decl(type, &ad, &n, TYPE_ABSTRACT);
		3731	}
		3732
		3733	static void vpush_tokc(int t)
		3734	{
		3735	CType type;
		3736	type.t = t;
		3737	type.ref = 0;
		3738	vsetc(&type, VT_CONST, &tokc);
		3739	}
		3740
		3741	ST_FUNC void unary(void)
		3742	{
		3743	int n, t, align, size, r, sizeof_caller;
		3744	CType type;
		3745	Sym *s;
		3746	AttributeDef ad;
		3747	static int in_sizeof = 0;
		3748
		3749	sizeof_caller = in_sizeof;
		3750	in_sizeof = 0;
		3751	/* XXX: GCC 2.95.3 does not generate a table although it should be
		3752	better here */
		3753	tok_next:
		3754	switch(tok) {
		3755	case TOK_EXTENSION:
		3756	next();
		3757	goto tok_next;
		3758	case TOK_CINT:
		3759	case TOK_CCHAR:
		3760	case TOK_LCHAR:
		3761	vpushi(tokc.i);
		3762	next();
		3763	break;
		3764	case TOK_CUINT:
		3765	vpush_tokc(VT_INT \| VT_UNSIGNED);
		3766	next();
		3767	break;
		3768	case TOK_CLLONG:
		3769	vpush_tokc(VT_LLONG);
		3770	next();
		3771	break;
		3772	case TOK_CULLONG:
		3773	vpush_tokc(VT_LLONG \| VT_UNSIGNED);
		3774	next();
		3775	break;
		3776	case TOK_CFLOAT:
		3777	vpush_tokc(VT_FLOAT);
		3778	next();
		3779	break;
		3780	case TOK_CDOUBLE:
		3781	vpush_tokc(VT_DOUBLE);
		3782	next();
		3783	break;
		3784	case TOK_CLDOUBLE:
		3785	vpush_tokc(VT_LDOUBLE);
		3786	next();
		3787	break;
		3788	case TOK___FUNCTION__:
		3789	if (!gnu_ext)
		3790	goto tok_identifier;
		3791	/* fall thru */
		3792	case TOK___FUNC__:
		3793	{
		3794	void *ptr;
		3795	int len;
		3796	/* special function name identifier */
		3797	len = strlen(funcname) + 1;
		3798	/* generate char[len] type */
		3799	type.t = VT_BYTE;
		3800	mk_pointer(&type);
		3801	type.t \|= VT_ARRAY;
		3802	type.ref->c = len;
		3803	vpush_ref(&type, data_section, data_section->data_offset, len);
		3804	ptr = section_ptr_add(data_section, len);
		3805	memcpy(ptr, funcname, len);
		3806	next();
		3807	}
		3808	break;
		3809	case TOK_LSTR:
		3810	#ifdef TCC_TARGET_PE
		3811	t = VT_SHORT \| VT_UNSIGNED;
		3812	#else
		3813	t = VT_INT;
		3814	#endif
		3815	goto str_init;
		3816	case TOK_STR:
		3817	/* string parsing */
		3818	t = VT_BYTE;
		3819	str_init:
		3820	if (tcc_state->warn_write_strings)
		3821	t \|= VT_CONSTANT;
		3822	type.t = t;
		3823	mk_pointer(&type);
		3824	type.t \|= VT_ARRAY;
		3825	memset(&ad, 0, sizeof(AttributeDef));
		3826	decl_initializer_alloc(&type, &ad, VT_CONST, 2, 0, 0);
		3827	break;
		3828	case '(':
		3829	next();
		3830	/* cast ? */
		3831	if (parse_btype(&type, &ad)) {
		3832	type_decl(&type, &ad, &n, TYPE_ABSTRACT);
		3833	skip(')');
		3834	/* check ISOC99 compound literal */
		3835	if (tok == '{') {
		3836	/* data is allocated locally by default */
		3837	if (global_expr)
		3838	r = VT_CONST;
		3839	else
		3840	r = VT_LOCAL;
		3841	/* all except arrays are lvalues */
		3842	if (!(type.t & VT_ARRAY))
		3843	r \|= lvalue_type(type.t);
		3844	memset(&ad, 0, sizeof(AttributeDef));
		3845	decl_initializer_alloc(&type, &ad, r, 1, 0, 0);
		3846	} else {
		3847	if (sizeof_caller) {
		3848	vpush(&type);
		3849	return;
		3850	}
		3851	unary();
		3852	gen_cast(&type);
		3853	}
		3854	} else if (tok == '{') {
		3855	if (const_wanted)
		3856	tcc_error("expected constant");
		3857	/* save all registers */
		3858	if (!nocode_wanted)
		3859	save_regs(0);
		3860	/* statement expression : we do not accept break/continue
		3861	inside as GCC does */
		3862	block(NULL, NULL, NULL, NULL, 0, 1);
		3863	skip(')');
		3864	} else {
		3865	gexpr();
		3866	skip(')');
		3867	}
		3868	break;
		3869	case '*':
		3870	next();
		3871	unary();
		3872	indir();
		3873	break;
		3874	case '&':
		3875	next();
		3876	unary();
		3877	/* functions names must be treated as function pointers,
		3878	except for unary '&' and sizeof. Since we consider that
		3879	functions are not lvalues, we only have to handle it
		3880	there and in function calls. */
		3881	/* arrays can also be used although they are not lvalues */
		3882	if ((vtop->type.t & VT_BTYPE) != VT_FUNC &&
		3883	!(vtop->type.t & VT_ARRAY) && !(vtop->type.t & VT_LLOCAL))
		3884	test_lvalue();
		3885	mk_pointer(&vtop->type);
		3886	gaddrof();
		3887	break;
		3888	case '!':
		3889	next();
		3890	unary();
		3891	if ((vtop->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == VT_CONST) {
		3892	CType boolean;
		3893	boolean.t = VT_BOOL;
		3894	gen_cast(&boolean);
		3895	vtop->c.i = !vtop->c.i;
		3896	} else if ((vtop->r & VT_VALMASK) == VT_CMP)
		3897	vtop->c.i ^= 1;
		3898	else {
		3899	save_regs(1);
		3900	vseti(VT_JMP, gvtst(1, 0));
		3901	}
		3902	break;
		3903	case '~':
		3904	next();
		3905	unary();
		3906	vpushi(-1);
		3907	gen_op('^');
		3908	break;
		3909	case '+':
		3910	next();
		3911	unary();
		3912	if ((vtop->type.t & VT_BTYPE) == VT_PTR)
		3913	tcc_error("pointer not accepted for unary plus");
		3914	/* In order to force cast, we add zero, except for floating point
		3915	where we really need an noop (otherwise -0.0 will be transformed
		3916	into +0.0). */
		3917	if (!is_float(vtop->type.t)) {
		3918	vpushi(0);
		3919	gen_op('+');
		3920	}
		3921	break;
		3922	case TOK_SIZEOF:
		3923	case TOK_ALIGNOF1:
		3924	case TOK_ALIGNOF2:
		3925	t = tok;
		3926	next();
		3927	in_sizeof++;
		3928	unary_type(&type); // Perform a in_sizeof = 0;
		3929	size = type_size(&type, &align);
		3930	if (t == TOK_SIZEOF) {
		3931	if (!(type.t & VT_VLA)) {
		3932	if (size < 0)
		3933	tcc_error("sizeof applied to an incomplete type");
		3934	vpushs(size);
		3935	} else {
		3936	vla_runtime_type_size(&type, &align);
		3937	}
		3938	} else {
		3939	vpushs(align);
		3940	}
		3941	vtop->type.t \|= VT_UNSIGNED;
		3942	break;
		3943
		3944	case TOK_builtin_expect:
		3945	{
		3946	/* __builtin_expect is a no-op for now */
		3947	int saved_nocode_wanted;
		3948	next();
		3949	skip('(');
		3950	expr_eq();
		3951	skip(',');
		3952	saved_nocode_wanted = nocode_wanted;
		3953	nocode_wanted = 1;
		3954	expr_lor_const();
		3955	vpop();
		3956	nocode_wanted = saved_nocode_wanted;
		3957	skip(')');
		3958	}
		3959	break;
		3960	case TOK_builtin_types_compatible_p:
		3961	{
		3962	CType type1, type2;
		3963	next();
		3964	skip('(');
		3965	parse_type(&type1);
		3966	skip(',');
		3967	parse_type(&type2);
		3968	skip(')');
		3969	type1.t &= ~(VT_CONSTANT \| VT_VOLATILE);
		3970	type2.t &= ~(VT_CONSTANT \| VT_VOLATILE);
		3971	vpushi(is_compatible_types(&type1, &type2));
		3972	}
		3973	break;
		3974	case TOK_builtin_constant_p:
		3975	{
		3976	int saved_nocode_wanted, res;
		3977	next();
		3978	skip('(');
		3979	saved_nocode_wanted = nocode_wanted;
		3980	nocode_wanted = 1;
		3981	gexpr();
		3982	res = (vtop->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == VT_CONST;
		3983	vpop();
		3984	nocode_wanted = saved_nocode_wanted;
		3985	skip(')');
		3986	vpushi(res);
		3987	}
		3988	break;
		3989	case TOK_builtin_frame_address:
		3990	case TOK_builtin_return_address:
		3991	{
		3992	int tok1 = tok;
		3993	int level;
		3994	CType type;
		3995	next();
		3996	skip('(');
		3997	if (tok != TOK_CINT) {
		3998	tcc_error("%s only takes positive integers",
		3999	tok1 == TOK_builtin_return_address ?
		4000	"__builtin_return_address" :
		4001	"__builtin_frame_address");
		4002	}
		4003	level = (uint32_t)tokc.i;
		4004	next();
		4005	skip(')');
		4006	type.t = VT_VOID;
		4007	mk_pointer(&type);
		4008	vset(&type, VT_LOCAL, 0); /* local frame */
		4009	while (level--) {
		4010	mk_pointer(&vtop->type);
		4011	indir(); /* -> parent frame */
		4012	}
		4013	if (tok1 == TOK_builtin_return_address) {
		4014	// assume return address is just above frame pointer on stack
		4015	vpushi(PTR_SIZE);
		4016	gen_op('+');
		4017	mk_pointer(&vtop->type);
		4018	indir();
		4019	}
		4020	}
		4021	break;
		4022	#ifdef TCC_TARGET_X86_64
		4023	#ifdef TCC_TARGET_PE
		4024	case TOK_builtin_va_start:
		4025	{
		4026	next();
		4027	skip('(');
		4028	expr_eq();
		4029	skip(',');
		4030	expr_eq();
		4031	skip(')');
		4032	if ((vtop->r & VT_VALMASK) != VT_LOCAL)
		4033	tcc_error("__builtin_va_start expects a local variable");
		4034	vtop->r &= ~(VT_LVAL \| VT_REF);
		4035	vtop->type = char_pointer_type;
		4036	vstore();
		4037	}
		4038	break;
		4039	#else
		4040	case TOK_builtin_va_arg_types:
		4041	{
		4042	CType type;
		4043	next();
		4044	skip('(');
		4045	parse_type(&type);
		4046	skip(')');
		4047	vpushi(classify_x86_64_va_arg(&type));
		4048	}
		4049	break;
		4050	#endif
		4051	#endif
		4052
		4053	#ifdef TCC_TARGET_ARM64
		4054	case TOK___va_start: {
		4055	if (nocode_wanted)
		4056	tcc_error("statement in global scope");
		4057	next();
		4058	skip('(');
		4059	expr_eq();
		4060	skip(',');
		4061	expr_eq();
		4062	skip(')');
		4063	//xx check types
		4064	gen_va_start();
		4065	vpushi(0);
		4066	vtop->type.t = VT_VOID;
		4067	break;
		4068	}
		4069	case TOK___va_arg: {
		4070	CType type;
		4071	if (nocode_wanted)
		4072	tcc_error("statement in global scope");
		4073	next();
		4074	skip('(');
		4075	expr_eq();
		4076	skip(',');
		4077	parse_type(&type);
		4078	skip(')');
		4079	//xx check types
		4080	gen_va_arg(&type);
		4081	vtop->type = type;
		4082	break;
		4083	}
		4084	case TOK___arm64_clear_cache: {
		4085	next();
		4086	skip('(');
		4087	expr_eq();
		4088	skip(',');
		4089	expr_eq();
		4090	skip(')');
		4091	gen_clear_cache();
		4092	vpushi(0);
		4093	vtop->type.t = VT_VOID;
		4094	break;
		4095	}
		4096	#endif
		4097	/* pre operations */
		4098	case TOK_INC:
		4099	case TOK_DEC:
		4100	t = tok;
		4101	next();
		4102	unary();
		4103	inc(0, t);
		4104	break;
		4105	case '-':
		4106	next();
		4107	unary();
		4108	t = vtop->type.t & VT_BTYPE;
		4109	if (is_float(t)) {
		4110	/* In IEEE negate(x) isn't subtract(0,x), but rather
		4111	subtract(-0, x). */
		4112	vpush(&vtop->type);
		4113	if (t == VT_FLOAT)
		4114	vtop->c.f = -0.0f;
		4115	else if (t == VT_DOUBLE)
		4116	vtop->c.d = -0.0;
		4117	else
		4118	vtop->c.ld = -0.0;
		4119	} else
		4120	vpushi(0);
		4121	vswap();
		4122	gen_op('-');
		4123	break;
		4124	case TOK_LAND:
		4125	if (!gnu_ext)
		4126	goto tok_identifier;
		4127	next();
		4128	/* allow to take the address of a label */
		4129	if (tok < TOK_UIDENT)
		4130	expect("label identifier");
		4131	s = label_find(tok);
		4132	if (!s) {
		4133	s = label_push(&global_label_stack, tok, LABEL_FORWARD);
		4134	} else {
		4135	if (s->r == LABEL_DECLARED)
		4136	s->r = LABEL_FORWARD;
		4137	}
		4138	if (!s->type.t) {
		4139	s->type.t = VT_VOID;
		4140	mk_pointer(&s->type);
		4141	s->type.t \|= VT_STATIC;
		4142	}
		4143	vpushsym(&s->type, s);
		4144	next();
		4145	break;
		4146
		4147	// special qnan , snan and infinity values
		4148	case TOK___NAN__:
		4149	vpush64(VT_DOUBLE, 0x7ff8000000000000ULL);
		4150	next();
		4151	break;
		4152	case TOK___SNAN__:
		4153	vpush64(VT_DOUBLE, 0x7ff0000000000001ULL);
		4154	next();
		4155	break;
		4156	case TOK___INF__:
		4157	vpush64(VT_DOUBLE, 0x7ff0000000000000ULL);
		4158	next();
		4159	break;
		4160
		4161	default:
		4162	tok_identifier:
		4163	t = tok;
		4164	next();
		4165	if (t < TOK_UIDENT)
		4166	expect("identifier");
		4167	s = sym_find(t);
		4168	if (!s) {
		4169	const char *name = get_tok_str(t, NULL);
		4170	if (tok != '(')
		4171	tcc_error("'%s' undeclared", name);
		4172	/* for simple function calls, we tolerate undeclared
		4173	external reference to int() function */
		4174	if (tcc_state->warn_implicit_function_declaration
		4175	#ifdef TCC_TARGET_PE
		4176	/* people must be warned about using undeclared WINAPI functions
		4177	(which usually start with uppercase letter) */
		4178	\|\| (name[0] >= 'A' && name[0] <= 'Z')
		4179	#endif
		4180	)
		4181	tcc_warning("implicit declaration of function '%s'", name);
		4182	s = external_global_sym(t, &func_old_type, 0);
		4183	}
		4184	if ((s->type.t & (VT_STATIC \| VT_INLINE \| VT_BTYPE)) ==
		4185	(VT_STATIC \| VT_INLINE \| VT_FUNC)) {
		4186	/* if referencing an inline function, then we generate a
		4187	symbol to it if not already done. It will have the
		4188	effect to generate code for it at the end of the
		4189	compilation unit. Inline function as always
		4190	generated in the text section. */
		4191	if (!s->c)
		4192	put_extern_sym(s, text_section, 0, 0);
		4193	r = VT_SYM \| VT_CONST;
		4194	} else {
		4195	r = s->r;
		4196	}
		4197	vset(&s->type, r, s->c);
		4198	/* if forward reference, we must point to s */
		4199	if (vtop->r & VT_SYM) {
		4200	vtop->sym = s;
		4201	vtop->c.i = 0;
		4202	}
		4203	break;
		4204	}
		4205
		4206	/* post operations */
		4207	while (1) {
		4208	if (tok == TOK_INC \|\| tok == TOK_DEC) {
		4209	inc(1, tok);
		4210	next();
		4211	} else if (tok == '.' \|\| tok == TOK_ARROW \|\| tok == TOK_CDOUBLE) {
		4212	int qualifiers;
		4213	/* field */
		4214	if (tok == TOK_ARROW)
		4215	indir();
		4216	qualifiers = vtop->type.t & (VT_CONSTANT \| VT_VOLATILE);
		4217	test_lvalue();
		4218	gaddrof();
		4219	/* expect pointer on structure */
		4220	if ((vtop->type.t & VT_BTYPE) != VT_STRUCT)
		4221	expect("struct or union");
		4222	if (tok == TOK_CDOUBLE)
		4223	expect("field name");
		4224	next();
		4225	if (tok == TOK_CINT \|\| tok == TOK_CUINT)
		4226	expect("field name");
		4227	s = vtop->type.ref;
		4228	/* find field */
		4229	tok \|= SYM_FIELD;
		4230	while ((s = s->next) != NULL) {
		4231	if (s->v == tok)
		4232	break;
		4233	}
		4234	if (!s)
		4235	tcc_error("field not found: %s", get_tok_str(tok & ~SYM_FIELD, &tokc));
		4236	/* add field offset to pointer */
		4237	vtop->type = char_pointer_type; /* change type to 'char ' /
		4238	vpushi(s->c);
		4239	gen_op('+');
		4240	/* change type to field type, and set to lvalue */
		4241	vtop->type = s->type;
		4242	vtop->type.t \|= qualifiers;
		4243	/* an array is never an lvalue */
		4244	if (!(vtop->type.t & VT_ARRAY)) {
		4245	vtop->r \|= lvalue_type(vtop->type.t);
		4246	#ifdef CONFIG_TCC_BCHECK
		4247	/* if bound checking, the referenced pointer must be checked */
		4248	if (tcc_state->do_bounds_check)
		4249	vtop->r \|= VT_MUSTBOUND;
		4250	#endif
		4251	}
		4252	next();
		4253	} else if (tok == '[') {
		4254	next();
		4255	gexpr();
		4256	gen_op('+');
		4257	indir();
		4258	skip(']');
		4259	} else if (tok == '(') {
		4260	SValue ret;
		4261	Sym *sa;
		4262	int nb_args, ret_nregs, ret_align, regsize, variadic;
		4263
		4264	/* function call */
		4265	if ((vtop->type.t & VT_BTYPE) != VT_FUNC) {
		4266	/* pointer test (no array accepted) */
		4267	if ((vtop->type.t & (VT_BTYPE \| VT_ARRAY)) == VT_PTR) {
		4268	vtop->type = *pointed_type(&vtop->type);
		4269	if ((vtop->type.t & VT_BTYPE) != VT_FUNC)
		4270	goto error_func;
		4271	} else {
		4272	error_func:
		4273	expect("function pointer");
		4274	}
		4275	} else {
		4276	vtop->r &= ~VT_LVAL; /* no lvalue */
		4277	}
		4278	/* get return type */
		4279	s = vtop->type.ref;
		4280	next();
		4281	sa = s->next; /* first parameter */
		4282	nb_args = 0;
		4283	ret.r2 = VT_CONST;
		4284	/* compute first implicit argument if a structure is returned */
		4285	if ((s->type.t & VT_BTYPE) == VT_STRUCT) {
		4286	variadic = (s->c == FUNC_ELLIPSIS);
		4287	ret_nregs = gfunc_sret(&s->type, variadic, &ret.type,
		4288	&ret_align, ®size);
		4289	if (!ret_nregs) {
		4290	/* get some space for the returned structure */
		4291	size = type_size(&s->type, &align);
		4292	#ifdef TCC_TARGET_ARM64
		4293	/* On arm64, a small struct is return in registers.
		4294	It is much easier to write it to memory if we know
		4295	that we are allowed to write some extra bytes, so
		4296	round the allocated space up to a power of 2: */
		4297	if (size < 16)
		4298	while (size & (size - 1))
		4299	size = (size \| (size - 1)) + 1;
		4300	#endif
		4301	loc = (loc - size) & -align;
		4302	ret.type = s->type;
		4303	ret.r = VT_LOCAL \| VT_LVAL;
		4304	/* pass it as 'int' to avoid structure arg passing
		4305	problems */
		4306	vseti(VT_LOCAL, loc);
		4307	ret.c = vtop->c;
		4308	nb_args++;
		4309	}
		4310	} else {
		4311	ret_nregs = 1;
		4312	ret.type = s->type;
		4313	}
		4314
		4315	if (ret_nregs) {
		4316	/* return in register */
		4317	if (is_float(ret.type.t)) {
		4318	ret.r = reg_fret(ret.type.t);
		4319	#ifdef TCC_TARGET_X86_64
		4320	if ((ret.type.t & VT_BTYPE) == VT_QFLOAT)
		4321	ret.r2 = REG_QRET;
		4322	#endif
		4323	} else {
		4324	#ifndef TCC_TARGET_ARM64
		4325	#ifdef TCC_TARGET_X86_64
		4326	if ((ret.type.t & VT_BTYPE) == VT_QLONG)
		4327	#else
		4328	if ((ret.type.t & VT_BTYPE) == VT_LLONG)
		4329	#endif
		4330	ret.r2 = REG_LRET;
		4331	#endif
		4332	ret.r = REG_IRET;
		4333	}
		4334	ret.c.i = 0;
		4335	}
		4336	if (tok != ')') {
		4337	for(;;) {
		4338	expr_eq();
		4339	gfunc_param_typed(s, sa);
		4340	nb_args++;
		4341	if (sa)
		4342	sa = sa->next;
		4343	if (tok == ')')
		4344	break;
		4345	skip(',');
		4346	}
		4347	}
		4348	if (sa)
		4349	tcc_error("too few arguments to function");
		4350	skip(')');
		4351	if (!nocode_wanted) {
		4352	gfunc_call(nb_args);
		4353	} else {
		4354	vtop -= (nb_args + 1);
		4355	}
		4356
		4357	/* return value */
		4358	for (r = ret.r + ret_nregs + !ret_nregs; r-- > ret.r;) {
		4359	vsetc(&ret.type, r, &ret.c);
		4360	vtop->r2 = ret.r2; /* Loop only happens when r2 is VT_CONST */
		4361	}
		4362
		4363	/* handle packed struct return */
		4364	if (((s->type.t & VT_BTYPE) == VT_STRUCT) && ret_nregs) {
		4365	int addr, offset;
		4366
		4367	size = type_size(&s->type, &align);
		4368	/* We're writing whole regs often, make sure there's enough
		4369	space. Assume register size is power of 2. */
		4370	if (regsize > align)
		4371	align = regsize;
		4372	loc = (loc - size) & -align;
		4373	addr = loc;
		4374	offset = 0;
		4375	for (;;) {
		4376	vset(&ret.type, VT_LOCAL \| VT_LVAL, addr + offset);
		4377	vswap();
		4378	vstore();
		4379	vtop--;
		4380	if (--ret_nregs == 0)
		4381	break;
		4382	offset += regsize;
		4383	}
		4384	vset(&s->type, VT_LOCAL \| VT_LVAL, addr);
		4385	}
		4386	} else {
		4387	break;
		4388	}
		4389	}
		4390	}
		4391
		4392	ST_FUNC void expr_prod(void)
		4393	{
		4394	int t;
		4395
		4396	unary();
		4397	while (tok == '*' \|\| tok == '/' \|\| tok == '%') {
		4398	t = tok;
		4399	next();
		4400	unary();
		4401	gen_op(t);
		4402	}
		4403	}
		4404
		4405	ST_FUNC void expr_sum(void)
		4406	{
		4407	int t;
		4408
		4409	expr_prod();
		4410	while (tok == '+' \|\| tok == '-') {
		4411	t = tok;
		4412	next();
		4413	expr_prod();
		4414	gen_op(t);
		4415	}
		4416	}
		4417
		4418	static void expr_shift(void)
		4419	{
		4420	int t;
		4421
		4422	expr_sum();
		4423	while (tok == TOK_SHL \|\| tok == TOK_SAR) {
		4424	t = tok;
		4425	next();
		4426	expr_sum();
		4427	gen_op(t);
		4428	}
		4429	}
		4430
		4431	static void expr_cmp(void)
		4432	{
		4433	int t;
		4434
		4435	expr_shift();
		4436	while ((tok >= TOK_ULE && tok <= TOK_GT) \|\|
		4437	tok == TOK_ULT \|\| tok == TOK_UGE) {
		4438	t = tok;
		4439	next();
		4440	expr_shift();
		4441	gen_op(t);
		4442	}
		4443	}
		4444
		4445	static void expr_cmpeq(void)
		4446	{
		4447	int t;
		4448
		4449	expr_cmp();
		4450	while (tok == TOK_EQ \|\| tok == TOK_NE) {
		4451	t = tok;
		4452	next();
		4453	expr_cmp();
		4454	gen_op(t);
		4455	}
		4456	}
		4457
		4458	static void expr_and(void)
		4459	{
		4460	expr_cmpeq();
		4461	while (tok == '&') {
		4462	next();
		4463	expr_cmpeq();
		4464	gen_op('&');
		4465	}
		4466	}
		4467
		4468	static void expr_xor(void)
		4469	{
		4470	expr_and();
		4471	while (tok == '^') {
		4472	next();
		4473	expr_and();
		4474	gen_op('^');
		4475	}
		4476	}
		4477
		4478	static void expr_or(void)
		4479	{
		4480	expr_xor();
		4481	while (tok == '\|') {
		4482	next();
		4483	expr_xor();
		4484	gen_op('\|');
		4485	}
		4486	}
		4487
		4488	/* XXX: fix this mess */
		4489	static void expr_land_const(void)
		4490	{
		4491	expr_or();
		4492	while (tok == TOK_LAND) {
		4493	next();
		4494	expr_or();
		4495	gen_op(TOK_LAND);
		4496	}
		4497	}
		4498	static void expr_lor_const(void)
		4499	{
		4500	expr_land_const();
		4501	while (tok == TOK_LOR) {
		4502	next();
		4503	expr_land_const();
		4504	gen_op(TOK_LOR);
		4505	}
		4506	}
		4507
		4508	static void expr_land(void)
		4509	{
		4510	expr_or();
		4511	if (tok == TOK_LAND) {
		4512	if ((vtop->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == VT_CONST) {
		4513	CType ctb, cti;
		4514	ctb.t = VT_BOOL;
		4515	cti.t = VT_INT;
		4516	next();
		4517	gen_cast(&ctb);
		4518	if (vtop->c.i) {
		4519	vpop();
		4520	expr_land();
		4521	gen_cast(&ctb);
		4522	} else {
		4523	int saved_nocode_wanted = nocode_wanted;
		4524	nocode_wanted = 1;
		4525	expr_land();
		4526	vpop();
		4527	nocode_wanted = saved_nocode_wanted;
		4528	}
		4529	gen_cast(&cti);
		4530	} else {
		4531	int t = 0;
		4532	save_regs(1);
		4533	for(;;) {
		4534	t = gvtst(1, t);
		4535	if (tok != TOK_LAND) {
		4536	vseti(VT_JMPI, t);
		4537	break;
		4538	}
		4539	next();
		4540	expr_or();
		4541	}
		4542	}
		4543	}
		4544	}
		4545
		4546	static void expr_lor(void)
		4547	{
		4548	expr_land();
		4549	if (tok == TOK_LOR) {
		4550	if ((vtop->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == VT_CONST) {
		4551	CType ctb, cti;
		4552	ctb.t = VT_BOOL;
		4553	cti.t = VT_INT;
		4554	next();
		4555	gen_cast(&ctb);
		4556	if (vtop->c.i) {
		4557	int saved_nocode_wanted = nocode_wanted;
		4558	nocode_wanted = 1;
		4559	expr_lor();
		4560	vpop();
		4561	nocode_wanted = saved_nocode_wanted;
		4562	} else {
		4563	vpop();
		4564	expr_lor();
		4565	gen_cast(&ctb);
		4566	}
		4567	gen_cast(&cti);
		4568	} else {
		4569	int t = 0;
		4570	save_regs(1);
		4571	for(;;) {
		4572	t = gvtst(0, t);
		4573	if (tok != TOK_LOR) {
		4574	vseti(VT_JMP, t);
		4575	break;
		4576	}
		4577	next();
		4578	expr_land();
		4579	}
		4580	}
		4581	}
		4582	}
		4583
		4584	static void expr_cond(void)
		4585	{
		4586	int tt, u, r1, r2, rc, t1, t2, bt1, bt2, islv;
		4587	SValue sv;
		4588	CType type, type1, type2;
		4589
		4590	expr_lor();
		4591	if (tok == '?') {
		4592	next();
		4593	if ((vtop->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) == VT_CONST) {
		4594	int saved_nocode_wanted = nocode_wanted;
		4595	CType boolean;
		4596	int c;
		4597	boolean.t = VT_BOOL;
		4598	vdup();
		4599	gen_cast(&boolean);
		4600	c = vtop->c.i;
		4601	vpop();
		4602	if (c) {
		4603	if (tok != ':' \|\| !gnu_ext) {
		4604	vpop();
		4605	gexpr();
		4606	}
		4607	skip(':');
		4608	nocode_wanted = 1;
		4609	expr_cond();
		4610	vpop();
		4611	nocode_wanted = saved_nocode_wanted;
		4612	} else {
		4613	vpop();
		4614	if (tok != ':' \|\| !gnu_ext) {
		4615	nocode_wanted = 1;
		4616	gexpr();
		4617	vpop();
		4618	nocode_wanted = saved_nocode_wanted;
		4619	}
		4620	skip(':');
		4621	expr_cond();
		4622	}
		4623	}
		4624	else {
		4625	if (vtop != vstack) {
		4626	/* needed to avoid having different registers saved in
		4627	each branch */
		4628	if (is_float(vtop->type.t)) {
		4629	rc = RC_FLOAT;
		4630	#ifdef TCC_TARGET_X86_64
		4631	if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE) {
		4632	rc = RC_ST0;
		4633	}
		4634	#endif
		4635	}
		4636	else
		4637	rc = RC_INT;
		4638	gv(rc);
		4639	save_regs(1);
		4640	}
		4641	if (tok == ':' && gnu_ext) {
		4642	gv_dup();
		4643	tt = gvtst(1, 0);
		4644	} else {
		4645	tt = gvtst(1, 0);
		4646	gexpr();
		4647	}
		4648	type1 = vtop->type;
		4649	sv = vtop; / save value to handle it later */
		4650	vtop--; /* no vpop so that FP stack is not flushed */
		4651	skip(':');
		4652	u = gjmp(0);
		4653	gsym(tt);
		4654	expr_cond();
		4655	type2 = vtop->type;
		4656
		4657	t1 = type1.t;
		4658	bt1 = t1 & VT_BTYPE;
		4659	t2 = type2.t;
		4660	bt2 = t2 & VT_BTYPE;
		4661	/* cast operands to correct type according to ISOC rules */
		4662	if (is_float(bt1) \|\| is_float(bt2)) {
		4663	if (bt1 == VT_LDOUBLE \|\| bt2 == VT_LDOUBLE) {
		4664	type.t = VT_LDOUBLE;
		4665	} else if (bt1 == VT_DOUBLE \|\| bt2 == VT_DOUBLE) {
		4666	type.t = VT_DOUBLE;
		4667	} else {
		4668	type.t = VT_FLOAT;
		4669	}
		4670	} else if (bt1 == VT_LLONG \|\| bt2 == VT_LLONG) {
		4671	/* cast to biggest op */
		4672	type.t = VT_LLONG;
		4673	/* convert to unsigned if it does not fit in a long long */
		4674	if ((t1 & (VT_BTYPE \| VT_UNSIGNED)) == (VT_LLONG \| VT_UNSIGNED) \|\|
		4675	(t2 & (VT_BTYPE \| VT_UNSIGNED)) == (VT_LLONG \| VT_UNSIGNED))
		4676	type.t \|= VT_UNSIGNED;
		4677	} else if (bt1 == VT_PTR \|\| bt2 == VT_PTR) {
		4678	/* If one is a null ptr constant the result type
		4679	is the other. */
		4680	if (is_null_pointer (vtop))
		4681	type = type1;
		4682	else if (is_null_pointer (&sv))
		4683	type = type2;
		4684	/* XXX: test pointer compatibility, C99 has more elaborate
		4685	rules here. */
		4686	else
		4687	type = type1;
		4688	} else if (bt1 == VT_FUNC \|\| bt2 == VT_FUNC) {
		4689	/* XXX: test function pointer compatibility */
		4690	type = bt1 == VT_FUNC ? type1 : type2;
		4691	} else if (bt1 == VT_STRUCT \|\| bt2 == VT_STRUCT) {
		4692	/* XXX: test structure compatibility */
		4693	type = bt1 == VT_STRUCT ? type1 : type2;
		4694	} else if (bt1 == VT_VOID \|\| bt2 == VT_VOID) {
		4695	/* NOTE: as an extension, we accept void on only one side */
		4696	type.t = VT_VOID;
		4697	} else {
		4698	/* integer operations */
		4699	type.t = VT_INT;
		4700	/* convert to unsigned if it does not fit in an integer */
		4701	if ((t1 & (VT_BTYPE \| VT_UNSIGNED)) == (VT_INT \| VT_UNSIGNED) \|\|
		4702	(t2 & (VT_BTYPE \| VT_UNSIGNED)) == (VT_INT \| VT_UNSIGNED))
		4703	type.t \|= VT_UNSIGNED;
		4704	}
		4705	/* keep structs lvalue by transforming `(expr ? a : b)` to `*(expr ? &a : &b)` so
		4706	that `(expr ? a : b).mem` does not error with "lvalue expected" */
		4707	islv = (vtop->r & VT_LVAL) && (sv.r & VT_LVAL) && VT_STRUCT == (type.t & VT_BTYPE);
		4708
		4709	/* now we convert second operand */
		4710	gen_cast(&type);
		4711	if (islv) {
		4712	mk_pointer(&vtop->type);
		4713	gaddrof();
		4714	}
		4715	else if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
		4716	gaddrof();
		4717	rc = RC_INT;
		4718	if (is_float(type.t)) {
		4719	rc = RC_FLOAT;
		4720	#ifdef TCC_TARGET_X86_64
		4721	if ((type.t & VT_BTYPE) == VT_LDOUBLE) {
		4722	rc = RC_ST0;
		4723	}
		4724	#endif
		4725	} else if ((type.t & VT_BTYPE) == VT_LLONG) {
		4726	/* for long longs, we use fixed registers to avoid having
		4727	to handle a complicated move */
		4728	rc = RC_IRET;
		4729	}
		4730
		4731	r2 = gv(rc);
		4732	/* this is horrible, but we must also convert first
		4733	operand */
		4734	tt = gjmp(0);
		4735	gsym(u);
		4736	/* put again first value and cast it */
		4737	*vtop = sv;
		4738	gen_cast(&type);
		4739	if (islv) {
		4740	mk_pointer(&vtop->type);
		4741	gaddrof();
		4742	}
		4743	else if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
		4744	gaddrof();
		4745	r1 = gv(rc);
		4746	move_reg(r2, r1, type.t);
		4747	vtop->r = r2;
		4748	gsym(tt);
		4749	if (islv)
		4750	indir();
		4751	}
		4752	}
		4753	}
		4754
		4755	static void expr_eq(void)
		4756	{
		4757	int t;
		4758
		4759	expr_cond();
		4760	if (tok == '=' \|\|
		4761	(tok >= TOK_A_MOD && tok <= TOK_A_DIV) \|\|
		4762	tok == TOK_A_XOR \|\| tok == TOK_A_OR \|\|
		4763	tok == TOK_A_SHL \|\| tok == TOK_A_SAR) {
		4764	test_lvalue();
		4765	t = tok;
		4766	next();
		4767	if (t == '=') {
		4768	expr_eq();
		4769	} else {
		4770	vdup();
		4771	expr_eq();
		4772	gen_op(t & 0x7f);
		4773	}
		4774	vstore();
		4775	}
		4776	}
		4777
		4778	ST_FUNC void gexpr(void)
		4779	{
		4780	while (1) {
		4781	expr_eq();
		4782	if (tok != ',')
		4783	break;
		4784	vpop();
		4785	next();
		4786	}
		4787	}
		4788
		4789	/* parse an expression and return its type without any side effect. */
		4790	static void expr_type(CType *type)
		4791	{
		4792	int saved_nocode_wanted;
		4793
		4794	saved_nocode_wanted = nocode_wanted;
		4795	nocode_wanted = 1;
		4796	gexpr();
		4797	*type = vtop->type;
		4798	vpop();
		4799	nocode_wanted = saved_nocode_wanted;
		4800	}
		4801
		4802	/* parse a unary expression and return its type without any side
		4803	effect. */
		4804	static void unary_type(CType *type)
		4805	{
		4806	int a;
		4807
		4808	a = nocode_wanted;
		4809	nocode_wanted = 1;
		4810	unary();
		4811	*type = vtop->type;
		4812	vpop();
		4813	nocode_wanted = a;
		4814	}
		4815
		4816	/* parse a constant expression and return value in vtop. */
		4817	static void expr_const1(void)
		4818	{
		4819	int a;
		4820	a = const_wanted;
		4821	const_wanted = 1;
		4822	expr_cond();
		4823	const_wanted = a;
		4824	}
		4825
		4826	/* parse an integer constant and return its value. */
		4827	ST_FUNC int expr_const(void)
		4828	{
		4829	int c;
		4830	expr_const1();
		4831	if ((vtop->r & (VT_VALMASK \| VT_LVAL \| VT_SYM)) != VT_CONST)
		4832	expect("constant expression");
		4833	c = vtop->c.i;
		4834	vpop();
		4835	return c;
		4836	}
		4837
		4838	/* return the label token if current token is a label, otherwise
		4839	return zero */
		4840	static int is_label(void)
		4841	{
		4842	int last_tok;
		4843
		4844	/* fast test first */
		4845	if (tok < TOK_UIDENT)
		4846	return 0;
		4847	/* no need to save tokc because tok is an identifier */
		4848	last_tok = tok;
		4849	next();
		4850	if (tok == ':') {
		4851	next();
		4852	return last_tok;
		4853	} else {
		4854	unget_tok(last_tok);
		4855	return 0;
		4856	}
		4857	}
		4858
		4859	static void label_or_decl(int l)
		4860	{
		4861	int last_tok;
		4862
		4863	/* fast test first */
		4864	if (tok >= TOK_UIDENT)
		4865	{
		4866	/* no need to save tokc because tok is an identifier */
		4867	last_tok = tok;
		4868	next();
		4869	if (tok == ':') {
		4870	unget_tok(last_tok);
		4871	return;
		4872	}
		4873	unget_tok(last_tok);
		4874	}
		4875	decl(l);
		4876	}
		4877
		4878	static void block(int bsym, int csym, int case_sym, int def_sym,
		4879	int case_reg, int is_expr)
		4880	{
		4881	int a, b, c, d;
		4882	Sym s, frame_bottom;
		4883
		4884	/* generate line number info */
		4885	if (tcc_state->do_debug &&
		4886	(last_line_num != file->line_num \|\| last_ind != ind)) {
		4887	put_stabn(N_SLINE, 0, file->line_num, ind - func_ind);
		4888	last_ind = ind;
		4889	last_line_num = file->line_num;
		4890	}
		4891
		4892	if (is_expr) {
		4893	/* default return value is (void) */
		4894	vpushi(0);
		4895	vtop->type.t = VT_VOID;
		4896	}
		4897
		4898	if (tok == TOK_IF) {
		4899	/* if test */
		4900	next();
		4901	skip('(');
		4902	gexpr();
		4903	skip(')');
		4904	a = gvtst(1, 0);
		4905	block(bsym, csym, case_sym, def_sym, case_reg, 0);
		4906	c = tok;
		4907	if (c == TOK_ELSE) {
		4908	next();
		4909	d = gjmp(0);
		4910	gsym(a);
		4911	block(bsym, csym, case_sym, def_sym, case_reg, 0);
		4912	gsym(d); /* patch else jmp */
		4913	} else
		4914	gsym(a);
		4915	} else if (tok == TOK_WHILE) {
		4916	next();
		4917	d = ind;
		4918	vla_sp_restore();
		4919	skip('(');
		4920	gexpr();
		4921	skip(')');
		4922	a = gvtst(1, 0);
		4923	b = 0;
		4924	block(&a, &b, case_sym, def_sym, case_reg, 0);
		4925	if(!nocode_wanted)
		4926	gjmp_addr(d);
		4927	gsym(a);
		4928	gsym_addr(b, d);
		4929	} else if (tok == '{') {
		4930	Sym *llabel;
		4931	int block_vla_sp_loc = vla_sp_loc, saved_vlas_in_scope = vlas_in_scope;
		4932
		4933	next();
		4934	/* record local declaration stack position */
		4935	s = local_stack;
		4936	frame_bottom = sym_push2(&local_stack, SYM_FIELD, 0, 0);
		4937	frame_bottom->next = scope_stack_bottom;
		4938	scope_stack_bottom = frame_bottom;
		4939	llabel = local_label_stack;
		4940
		4941	/* handle local labels declarations */
		4942	if (tok == TOK_LABEL) {
		4943	next();
		4944	for(;;) {
		4945	if (tok < TOK_UIDENT)
		4946	expect("label identifier");
		4947	label_push(&local_label_stack, tok, LABEL_DECLARED);
		4948	next();
		4949	if (tok == ',') {
		4950	next();
		4951	} else {
		4952	skip(';');
		4953	break;
		4954	}
		4955	}
		4956	}
		4957	while (tok != '}') {
		4958	label_or_decl(VT_LOCAL);
		4959	if (tok != '}') {
		4960	if (is_expr)
		4961	vpop();
		4962	block(bsym, csym, case_sym, def_sym, case_reg, is_expr);
		4963	}
		4964	}
		4965	/* pop locally defined labels */
		4966	label_pop(&local_label_stack, llabel);
		4967	if(is_expr) {
		4968	/* XXX: this solution makes only valgrind happy...
		4969	triggered by gcc.c-torture/execute/20000917-1.c */
		4970	Sym *p;
		4971	switch(vtop->type.t & VT_BTYPE) {
		4972	/* case VT_PTR: */
		4973	/* this breaks a compilation of the linux kernel v2.4.26 */
		4974	/* pmd_t new = ({ __asm__ __volatile__("ud2\n") ; ((pmd_t )1); }); */
		4975	/* Look a commit a80acab: Display error on statement expressions with complex return type */
		4976	/* A pointer is not a complex return type */
		4977	case VT_STRUCT:
		4978	case VT_ENUM:
		4979	case VT_FUNC:
		4980	for(p=vtop->type.ref;p;p=p->prev)
		4981	if(p->prev==s)
		4982	tcc_error("unsupported expression type");
		4983	}
		4984	}
		4985	/* pop locally defined symbols */
		4986	scope_stack_bottom = scope_stack_bottom->next;
		4987	sym_pop(&local_stack, s);
		4988
		4989	/* Pop VLA frames and restore stack pointer if required */
		4990	if (vlas_in_scope > saved_vlas_in_scope) {
		4991	vla_sp_loc = saved_vlas_in_scope ? block_vla_sp_loc : vla_sp_root_loc;
		4992	vla_sp_restore();
		4993	}
		4994	vlas_in_scope = saved_vlas_in_scope;
		4995
		4996	next();
		4997	} else if (tok == TOK_RETURN) {
		4998	next();
		4999	if (tok != ';') {
		5000	gexpr();
		5001	gen_assign_cast(&func_vt);
		5002	#ifdef TCC_TARGET_ARM64
		5003	// Perhaps it would be better to use this for all backends:
		5004	greturn();
		5005	#else
		5006	if ((func_vt.t & VT_BTYPE) == VT_STRUCT) {
		5007	CType type, ret_type;
		5008	int ret_align, ret_nregs, regsize;
		5009	ret_nregs = gfunc_sret(&func_vt, func_var, &ret_type,
		5010	&ret_align, ®size);
		5011	if (0 == ret_nregs) {
		5012	/* if returning structure, must copy it to implicit
		5013	first pointer arg location */
		5014	type = func_vt;
		5015	mk_pointer(&type);
		5016	vset(&type, VT_LOCAL \| VT_LVAL, func_vc);
		5017	indir();
		5018	vswap();
		5019	/* copy structure value to pointer */
		5020	vstore();
		5021	} else {
		5022	/* returning structure packed into registers */
		5023	int r, size, addr, align;
		5024	size = type_size(&func_vt,&align);
		5025	if ((vtop->r != (VT_LOCAL \| VT_LVAL) \|\|
		5026	(vtop->c.i & (ret_align-1)))
		5027	&& (align & (ret_align-1))) {
		5028	loc = (loc - size) & -ret_align;
		5029	addr = loc;
		5030	type = func_vt;
		5031	vset(&type, VT_LOCAL \| VT_LVAL, addr);
		5032	vswap();
		5033	vstore();
		5034	vpop();
		5035	vset(&ret_type, VT_LOCAL \| VT_LVAL, addr);
		5036	}
		5037	vtop->type = ret_type;
		5038	if (is_float(ret_type.t))
		5039	r = rc_fret(ret_type.t);
		5040	else
		5041	r = RC_IRET;
		5042
		5043	for (;;) {
		5044	gv(r);
		5045	if (--ret_nregs == 0)
		5046	break;
		5047	/* We assume that when a structure is returned in multiple
		5048	registers, their classes are consecutive values of the
		5049	suite s(n) = 2^n */
		5050	r <<= 1;
		5051	vtop->c.i += regsize;
		5052	vtop->r = VT_LOCAL \| VT_LVAL;
		5053	}
		5054	}
		5055	} else if (is_float(func_vt.t)) {
		5056	gv(rc_fret(func_vt.t));
		5057	} else {
		5058	gv(RC_IRET);
		5059	}
		5060	#endif
		5061	vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
		5062	}
		5063	skip(';');
		5064	rsym = gjmp(rsym); /* jmp */
		5065	} else if (tok == TOK_BREAK) {
		5066	/* compute jump */
		5067	if (!bsym)
		5068	tcc_error("cannot break");
		5069	bsym = gjmp(bsym);
		5070	next();
		5071	skip(';');
		5072	} else if (tok == TOK_CONTINUE) {
		5073	/* compute jump */
		5074	if (!csym)
		5075	tcc_error("cannot continue");
		5076	vla_sp_restore_root();
		5077	csym = gjmp(csym);
		5078	next();
		5079	skip(';');
		5080	} else if (tok == TOK_FOR) {
		5081	int e;
		5082	next();
		5083	skip('(');
		5084	s = local_stack;
		5085	frame_bottom = sym_push2(&local_stack, SYM_FIELD, 0, 0);
		5086	frame_bottom->next = scope_stack_bottom;
		5087	scope_stack_bottom = frame_bottom;
		5088	if (tok != ';') {
		5089	/* c99 for-loop init decl? */
		5090	if (!decl0(VT_LOCAL, 1)) {
		5091	/* no, regular for-loop init expr */
		5092	gexpr();
		5093	vpop();
		5094	}
		5095	}
		5096	skip(';');
		5097	d = ind;
		5098	c = ind;
		5099	vla_sp_restore();
		5100	a = 0;
		5101	b = 0;
		5102	if (tok != ';') {
		5103	gexpr();
		5104	a = gvtst(1, 0);
		5105	}
		5106	skip(';');
		5107	if (tok != ')') {
		5108	e = gjmp(0);
		5109	c = ind;
		5110	vla_sp_restore();
		5111	gexpr();
		5112	vpop();
		5113	gjmp_addr(d);
		5114	gsym(e);
		5115	}
		5116	skip(')');
		5117	block(&a, &b, case_sym, def_sym, case_reg, 0);
		5118	if(!nocode_wanted)
		5119	gjmp_addr(c);
		5120	gsym(a);
		5121	gsym_addr(b, c);
		5122	scope_stack_bottom = scope_stack_bottom->next;
		5123	sym_pop(&local_stack, s);
		5124	} else
		5125	if (tok == TOK_DO) {
		5126	next();
		5127	a = 0;
		5128	b = 0;
		5129	d = ind;
		5130	vla_sp_restore();
		5131	block(&a, &b, case_sym, def_sym, case_reg, 0);
		5132	skip(TOK_WHILE);
		5133	skip('(');
		5134	gsym(b);
		5135	gexpr();
		5136	c = gvtst(0, 0);
		5137	gsym_addr(c, d);
		5138	skip(')');
		5139	gsym(a);
		5140	skip(';');
		5141	} else
		5142	if (tok == TOK_SWITCH) {
		5143	next();
		5144	skip('(');
		5145	gexpr();
		5146	/* XXX: other types than integer */
		5147	case_reg = gv(RC_INT);
		5148	vpop();
		5149	skip(')');
		5150	a = 0;
		5151	b = gjmp(0); /* jump to first case */
		5152	c = 0;
		5153	block(&a, csym, &b, &c, case_reg, 0);
		5154	/* if no default, jmp after switch */
		5155	if (c == 0)
		5156	c = ind;
		5157	/* default label */
		5158	gsym_addr(b, c);
		5159	/* break label */
		5160	gsym(a);
		5161	} else
		5162	if (tok == TOK_CASE) {
		5163	int v1, v2;
		5164	if (!case_sym)
		5165	expect("switch");
		5166	next();
		5167	v1 = expr_const();
		5168	v2 = v1;
		5169	if (gnu_ext && tok == TOK_DOTS) {
		5170	next();
		5171	v2 = expr_const();
		5172	if (v2 < v1)
		5173	tcc_warning("empty case range");
		5174	}
		5175	/* since a case is like a label, we must skip it with a jmp */
		5176	b = gjmp(0);
		5177	gsym(*case_sym);
		5178	vseti(case_reg, 0);
		5179	vdup();
		5180	vpushi(v1);
		5181	if (v1 == v2) {
		5182	gen_op(TOK_EQ);
		5183	*case_sym = gtst(1, 0);
		5184	} else {
		5185	gen_op(TOK_GE);
		5186	*case_sym = gtst(1, 0);
		5187	vseti(case_reg, 0);
		5188	vpushi(v2);
		5189	gen_op(TOK_LE);
		5190	case_sym = gtst(1, case_sym);
		5191	}
		5192	case_reg = gv(RC_INT);
		5193	vpop();
		5194	gsym(b);
		5195	skip(':');
		5196	is_expr = 0;
		5197	goto block_after_label;
		5198	} else
		5199	if (tok == TOK_DEFAULT) {
		5200	next();
		5201	skip(':');
		5202	if (!def_sym)
		5203	expect("switch");
		5204	if (*def_sym)
		5205	tcc_error("too many 'default'");
		5206	*def_sym = ind;
		5207	is_expr = 0;
		5208	goto block_after_label;
		5209	} else
		5210	if (tok == TOK_GOTO) {
		5211	next();
		5212	if (tok == '*' && gnu_ext) {
		5213	/* computed goto */
		5214	next();
		5215	gexpr();
		5216	if ((vtop->type.t & VT_BTYPE) != VT_PTR)
		5217	expect("pointer");
		5218	ggoto();
		5219	} else if (tok >= TOK_UIDENT) {
		5220	s = label_find(tok);
		5221	/* put forward definition if needed */
		5222	if (!s) {
		5223	s = label_push(&global_label_stack, tok, LABEL_FORWARD);
		5224	} else {
		5225	if (s->r == LABEL_DECLARED)
		5226	s->r = LABEL_FORWARD;
		5227	}
		5228	vla_sp_restore_root();
		5229	if (s->r & LABEL_FORWARD)
		5230	s->jnext = gjmp(s->jnext);
		5231	else
		5232	gjmp_addr(s->jnext);
		5233	next();
		5234	} else {
		5235	expect("label identifier");
		5236	}
		5237	skip(';');
		5238	} else if (tok == TOK_ASM1 \|\| tok == TOK_ASM2 \|\| tok == TOK_ASM3) {
		5239	asm_instr();
		5240	} else {
		5241	b = is_label();
		5242	if (b) {
		5243	/* label case */
		5244	s = label_find(b);
		5245	if (s) {
		5246	if (s->r == LABEL_DEFINED)
		5247	tcc_error("duplicate label '%s'", get_tok_str(s->v, NULL));
		5248	gsym(s->jnext);
		5249	s->r = LABEL_DEFINED;
		5250	} else {
		5251	s = label_push(&global_label_stack, b, LABEL_DEFINED);
		5252	}
		5253	s->jnext = ind;
		5254	vla_sp_restore();
		5255	/* we accept this, but it is a mistake */
		5256	block_after_label:
		5257	if (tok == '}') {
		5258	tcc_warning("deprecated use of label at end of compound statement");
		5259	} else {
		5260	if (is_expr)
		5261	vpop();
		5262	block(bsym, csym, case_sym, def_sym, case_reg, is_expr);
		5263	}
		5264	} else {
		5265	/* expression case */
		5266	if (tok != ';') {
		5267	if (is_expr) {
		5268	vpop();
		5269	gexpr();
		5270	} else {
		5271	gexpr();
		5272	vpop();
		5273	}
		5274	}
		5275	skip(';');
		5276	}
		5277	}
		5278	}
		5279
		5280	/* t is the array or struct type. c is the array or struct
		5281	address. cur_index/cur_field is the pointer to the current
		5282	value. 'size_only' is true if only size info is needed (only used
		5283	in arrays) */
		5284	static void decl_designator(CType type, Section sec, unsigned long c,
		5285	int cur_index, Sym *cur_field,
		5286	int size_only)
		5287	{
		5288	Sym s, f;
		5289	int notfirst, index, index_last, align, l, nb_elems, elem_size;
		5290	CType type1;
		5291
		5292	notfirst = 0;
		5293	elem_size = 0;
		5294	nb_elems = 1;
		5295	if (gnu_ext && (l = is_label()) != 0)
		5296	goto struct_field;
		5297	while (tok == '[' \|\| tok == '.') {
		5298	if (tok == '[') {
		5299	if (!(type->t & VT_ARRAY))
		5300	expect("array type");
		5301	s = type->ref;
		5302	next();
		5303	index = expr_const();
		5304	if (index < 0 \|\| (s->c >= 0 && index >= s->c))
		5305	expect("invalid index");
		5306	if (tok == TOK_DOTS && gnu_ext) {
		5307	next();
		5308	index_last = expr_const();
		5309	if (index_last < 0 \|\|
		5310	(s->c >= 0 && index_last >= s->c) \|\|
		5311	index_last < index)
		5312	expect("invalid index");
		5313	} else {
		5314	index_last = index;
		5315	}
		5316	skip(']');
		5317	if (!notfirst)
		5318	*cur_index = index_last;
		5319	type = pointed_type(type);
		5320	elem_size = type_size(type, &align);
		5321	c += index * elem_size;
		5322	/* NOTE: we only support ranges for last designator */
		5323	nb_elems = index_last - index + 1;
		5324	if (nb_elems != 1) {
		5325	notfirst = 1;
		5326	break;
		5327	}
		5328	} else {
		5329	next();
		5330	l = tok;
		5331	next();
		5332	struct_field:
		5333	if ((type->t & VT_BTYPE) != VT_STRUCT)
		5334	expect("struct/union type");
		5335	s = type->ref;
		5336	l \|= SYM_FIELD;
		5337	f = s->next;
		5338	while (f) {
		5339	if (f->v == l)
		5340	break;
		5341	f = f->next;
		5342	}
		5343	if (!f)
		5344	expect("field");
		5345	if (!notfirst)
		5346	*cur_field = f;
		5347	/* XXX: fix this mess by using explicit storage field */
		5348	type1 = f->type;
		5349	type1.t \|= (type->t & ~VT_TYPE);
		5350	type = &type1;
		5351	c += f->c;
		5352	}
		5353	notfirst = 1;
		5354	}
		5355	if (notfirst) {
		5356	if (tok == '=') {
		5357	next();
		5358	} else {
		5359	if (!gnu_ext)
		5360	expect("=");
		5361	}
		5362	} else {
		5363	if (type->t & VT_ARRAY) {
		5364	index = *cur_index;
		5365	type = pointed_type(type);
		5366	c += index * type_size(type, &align);
		5367	} else {
		5368	f = *cur_field;
		5369	if (!f)
		5370	tcc_error("too many field init");
		5371	/* XXX: fix this mess by using explicit storage field */
		5372	type1 = f->type;
		5373	type1.t \|= (type->t & ~VT_TYPE);
		5374	type = &type1;
		5375	c += f->c;
		5376	}
		5377	}
		5378	decl_initializer(type, sec, c, 0, size_only);
		5379
		5380	/* XXX: make it more general */
		5381	if (!size_only && nb_elems > 1) {
		5382	unsigned long c_end;
		5383	uint8_t src, dst;
		5384	int i;
		5385
		5386	if (!sec)
		5387	tcc_error("range init not supported yet for dynamic storage");
		5388	c_end = c + nb_elems * elem_size;
		5389	if (c_end > sec->data_allocated)
		5390	section_realloc(sec, c_end);
		5391	src = sec->data + c;
		5392	dst = src;
		5393	for(i = 1; i < nb_elems; i++) {
		5394	dst += elem_size;
		5395	memcpy(dst, src, elem_size);
		5396	}
		5397	}
		5398	}
		5399
		5400	#define EXPR_VAL 0
		5401	#define EXPR_CONST 1
		5402	#define EXPR_ANY 2
		5403
		5404	/* store a value or an expression directly in global data or in local array */
		5405	static void init_putv(CType type, Section sec, unsigned long c,
		5406	int v, int expr_type)
		5407	{
		5408	int saved_global_expr, bt, bit_pos, bit_size;
		5409	void *ptr;
		5410	unsigned long long bit_mask;
		5411	CType dtype;
		5412
		5413	switch(expr_type) {
		5414	case EXPR_VAL:
		5415	vpushi(v);
		5416	break;
		5417	case EXPR_CONST:
		5418	/* compound literals must be allocated globally in this case */
		5419	saved_global_expr = global_expr;
		5420	global_expr = 1;
		5421	expr_const1();
		5422	global_expr = saved_global_expr;
		5423	/* NOTE: symbols are accepted */
		5424	if ((vtop->r & (VT_VALMASK \| VT_LVAL)) != VT_CONST)
		5425	tcc_error("initializer element is not constant");
		5426	break;
		5427	case EXPR_ANY:
		5428	expr_eq();
		5429	break;
		5430	}
		5431
		5432	dtype = *type;
		5433	dtype.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */
		5434
		5435	if (sec) {
		5436	/* XXX: not portable */
		5437	/* XXX: generate error if incorrect relocation */
		5438	gen_assign_cast(&dtype);
		5439	bt = type->t & VT_BTYPE;
		5440	/* we'll write at most 16 bytes */
		5441	if (c + 16 > sec->data_allocated) {
		5442	section_realloc(sec, c + 16);
		5443	}
		5444	ptr = sec->data + c;
		5445	/* XXX: make code faster ? */
		5446	if (!(type->t & VT_BITFIELD)) {
		5447	bit_pos = 0;
		5448	bit_size = 32;
		5449	bit_mask = -1LL;
		5450	} else {
		5451	bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f;
		5452	bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
		5453	bit_mask = (1LL << bit_size) - 1;
		5454	}
		5455	if ((vtop->r & VT_SYM) &&
		5456	(bt == VT_BYTE \|\|
		5457	bt == VT_SHORT \|\|
		5458	bt == VT_DOUBLE \|\|
		5459	bt == VT_LDOUBLE \|\|
		5460	bt == VT_LLONG \|\|
		5461	(bt == VT_INT && bit_size != 32)))
		5462	tcc_error("initializer element is not computable at load time");
		5463	switch(bt) {
		5464	/* XXX: when cross-compiling we assume that each type has the
		5465	same representation on host and target, which is likely to
		5466	be wrong in the case of long double */
		5467	case VT_BOOL:
		5468	vtop->c.i = (vtop->c.i != 0);
		5469	case VT_BYTE:
		5470	(char )ptr \|= (vtop->c.i & bit_mask) << bit_pos;
		5471	break;
		5472	case VT_SHORT:
		5473	(short )ptr \|= (vtop->c.i & bit_mask) << bit_pos;
		5474	break;
		5475	case VT_DOUBLE:
		5476	(double )ptr = vtop->c.d;
		5477	break;
		5478	case VT_LDOUBLE:
		5479	(long double )ptr = vtop->c.ld;
		5480	break;
		5481	case VT_LLONG:
		5482	(long long )ptr \|= (vtop->c.i & bit_mask) << bit_pos;
		5483	break;
		5484	case VT_PTR: {
		5485	addr_t val = (vtop->c.i & bit_mask) << bit_pos;
		5486	#if defined(TCC_TARGET_ARM64) \|\| defined(TCC_TARGET_X86_64)
		5487	if (vtop->r & VT_SYM)
		5488	greloca(sec, vtop->sym, c, R_DATA_PTR, val);
		5489	else
		5490	(addr_t )ptr \|= val;
		5491	#else
		5492	if (vtop->r & VT_SYM)
		5493	greloc(sec, vtop->sym, c, R_DATA_PTR);
		5494	(addr_t )ptr \|= val;
		5495	#endif
		5496	break;
		5497	}
		5498	default: {
		5499	int val = (vtop->c.i & bit_mask) << bit_pos;
		5500	#if defined(TCC_TARGET_ARM64) \|\| defined(TCC_TARGET_X86_64)
		5501	if (vtop->r & VT_SYM)
		5502	greloca(sec, vtop->sym, c, R_DATA_PTR, val);
		5503	else
		5504	(int )ptr \|= val;
		5505	#else
		5506	if (vtop->r & VT_SYM)
		5507	greloc(sec, vtop->sym, c, R_DATA_PTR);
		5508	(int )ptr \|= val;
		5509	#endif
		5510	break;
		5511	}
		5512	}
		5513	vtop--;
		5514	} else {
		5515	vset(&dtype, VT_LOCAL\|VT_LVAL, c);
		5516	vswap();
		5517	vstore();
		5518	vpop();
		5519	}
		5520	}
		5521
		5522	/* put zeros for variable based init */
		5523	static void init_putz(CType t, Section sec, unsigned long c, int size)
		5524	{
		5525	if (sec) {
		5526	/* nothing to do because globals are already set to zero */
		5527	} else {
		5528	vpush_global_sym(&func_old_type, TOK_memset);
		5529	vseti(VT_LOCAL, c);
		5530	#ifdef TCC_TARGET_ARM
		5531	vpushs(size);
		5532	vpushi(0);
		5533	#else
		5534	vpushi(0);
		5535	vpushs(size);
		5536	#endif
		5537	gfunc_call(3);
		5538	}
		5539	}
		5540
		5541	/* 't' contains the type and storage info. 'c' is the offset of the
		5542	object in section 'sec'. If 'sec' is NULL, it means stack based
		5543	allocation. 'first' is true if array '{' must be read (multi
		5544	dimension implicit array init handling). 'size_only' is true if
		5545	size only evaluation is wanted (only for arrays). */
		5546	static void decl_initializer(CType type, Section sec, unsigned long c,
		5547	int first, int size_only)
		5548	{
		5549	int index, array_length, n, no_oblock, nb, parlevel, parlevel1, i;
		5550	int size1, align1, expr_type;
		5551	Sym s, f;
		5552	CType *t1;
		5553
		5554	if (type->t & VT_VLA) {
		5555	int a;
		5556
		5557	/* save current stack pointer */
		5558	if (vlas_in_scope == 0) {
		5559	if (vla_sp_root_loc == -1)
		5560	vla_sp_root_loc = (loc -= PTR_SIZE);
		5561	gen_vla_sp_save(vla_sp_root_loc);
		5562	}
		5563
		5564	vla_runtime_type_size(type, &a);
		5565	gen_vla_alloc(type, a);
		5566	gen_vla_sp_save(c);
		5567	vla_sp_loc = c;
		5568	vlas_in_scope++;
		5569	} else if (type->t & VT_ARRAY) {
		5570	s = type->ref;
		5571	n = s->c;
		5572	array_length = 0;
		5573	t1 = pointed_type(type);
		5574	size1 = type_size(t1, &align1);
		5575
		5576	no_oblock = 1;
		5577	if ((first && tok != TOK_LSTR && tok != TOK_STR) \|\|
		5578	tok == '{') {
		5579	if (tok != '{')
		5580	tcc_error("character array initializer must be a literal,"
		5581	" optionally enclosed in braces");
		5582	skip('{');
		5583	no_oblock = 0;
		5584	}
		5585
		5586	/* only parse strings here if correct type (otherwise: handle
		5587	them as ((w)char ) expressions /
		5588	if ((tok == TOK_LSTR &&
		5589	#ifdef TCC_TARGET_PE
		5590	(t1->t & VT_BTYPE) == VT_SHORT && (t1->t & VT_UNSIGNED)
		5591	#else
		5592	(t1->t & VT_BTYPE) == VT_INT
		5593	#endif
		5594	) \|\| (tok == TOK_STR && (t1->t & VT_BTYPE) == VT_BYTE)) {
		5595	while (tok == TOK_STR \|\| tok == TOK_LSTR) {
		5596	int cstr_len, ch;
		5597
		5598	/* compute maximum number of chars wanted */
		5599	if (tok == TOK_STR)
		5600	cstr_len = tokc.str.size;
		5601	else
		5602	cstr_len = tokc.str.size / sizeof(nwchar_t);
		5603	cstr_len--;
		5604	nb = cstr_len;
		5605	if (n >= 0 && nb > (n - array_length))
		5606	nb = n - array_length;
		5607	if (!size_only) {
		5608	if (cstr_len > nb)
		5609	tcc_warning("initializer-string for array is too long");
		5610	/* in order to go faster for common case (char
		5611	string in global variable, we handle it
		5612	specifically */
		5613	if (sec && tok == TOK_STR && size1 == 1) {
		5614	memcpy(sec->data + c + array_length, tokc.str.data, nb);
		5615	} else {
		5616	for(i=0;i
		5617	if (tok == TOK_STR)
		5618	ch = ((unsigned char *)tokc.str.data)[i];
		5619	else
		5620	ch = ((nwchar_t *)tokc.str.data)[i];
		5621	init_putv(t1, sec, c + (array_length + i) * size1,
		5622	ch, EXPR_VAL);
		5623	}
		5624	}
		5625	}
		5626	array_length += nb;
		5627	next();
		5628	}
		5629	/* only add trailing zero if enough storage (no
		5630	warning in this case since it is standard) */
		5631	if (n < 0 \|\| array_length < n) {
		5632	if (!size_only) {
		5633	init_putv(t1, sec, c + (array_length * size1), 0, EXPR_VAL);
		5634	}
		5635	array_length++;
		5636	}
		5637	} else {
		5638	index = 0;
		5639	while (tok != '}') {
		5640	decl_designator(type, sec, c, &index, NULL, size_only);
		5641	if (n >= 0 && index >= n)
		5642	tcc_error("index too large");
		5643	/* must put zero in holes (note that doing it that way
		5644	ensures that it even works with designators) */
		5645	if (!size_only && array_length < index) {
		5646	init_putz(t1, sec, c + array_length * size1,
		5647	(index - array_length) * size1);
		5648	}
		5649	index++;
		5650	if (index > array_length)
		5651	array_length = index;
		5652	/* special test for multi dimensional arrays (may not
		5653	be strictly correct if designators are used at the
		5654	same time) */
		5655	if (index >= n && no_oblock)
		5656	break;
		5657	if (tok == '}')
		5658	break;
		5659	skip(',');
		5660	}
		5661	}
		5662	if (!no_oblock)
		5663	skip('}');
		5664	/* put zeros at the end */
		5665	if (!size_only && n >= 0 && array_length < n) {
		5666	init_putz(t1, sec, c + array_length * size1,
		5667	(n - array_length) * size1);
		5668	}
		5669	/* patch type size if needed */
		5670	if (n < 0)
		5671	s->c = array_length;
		5672	} else if ((type->t & VT_BTYPE) == VT_STRUCT &&
		5673	(sec \|\| !first \|\| tok == '{')) {
		5674
		5675	/* NOTE: the previous test is a specific case for automatic
		5676	struct/union init */
		5677	/* XXX: union needs only one init */
		5678
		5679	int par_count = 0;
		5680	if (tok == '(') {
		5681	AttributeDef ad1;
		5682	CType type1;
		5683	next();
		5684	if (tcc_state->old_struct_init_code) {
		5685	/* an old version of struct initialization.
		5686	It have a problems. But with a new version
		5687	linux 2.4.26 can't load ramdisk.
		5688	*/
		5689	while (tok == '(') {
		5690	par_count++;
		5691	next();
		5692	}
		5693	if (!parse_btype(&type1, &ad1))
		5694	expect("cast");
		5695	type_decl(&type1, &ad1, &n, TYPE_ABSTRACT);
		5696	#if 0
		5697	if (!is_assignable_types(type, &type1))
		5698	tcc_error("invalid type for cast");
		5699	#endif
		5700	skip(')');
		5701	}
		5702	else
		5703	{
		5704	if (tok != '(') {
		5705	if (!parse_btype(&type1, &ad1))
		5706	expect("cast");
		5707	type_decl(&type1, &ad1, &n, TYPE_ABSTRACT);
		5708	#if 0
		5709	if (!is_assignable_types(type, &type1))
		5710	tcc_error("invalid type for cast");
		5711	#endif
		5712	skip(')');
		5713	} else
		5714	unget_tok(tok);
		5715	}
		5716	}
		5717
		5718	no_oblock = 1;
		5719	if (first \|\| tok == '{') {
		5720	skip('{');
		5721	no_oblock = 0;
		5722	}
		5723	s = type->ref;
		5724	f = s->next;
		5725	array_length = 0;
		5726	index = 0;
		5727	n = s->c;
		5728	while (tok != '}') {
		5729	decl_designator(type, sec, c, NULL, &f, size_only);
		5730	index = f->c;
		5731	if (!size_only && array_length < index) {
		5732	init_putz(type, sec, c + array_length,
		5733	index - array_length);
		5734	}
		5735	index = index + type_size(&f->type, &align1);
		5736	if (index > array_length)
		5737	array_length = index;
		5738
		5739	/* gr: skip fields from same union - ugly. */
		5740	while (f->next) {
		5741	int align = 0;
		5742	int f_size = type_size(&f->type, &align);
		5743	int f_type = (f->type.t & VT_BTYPE);
		5744
		5745	///printf("index: %2d %08x -- %2d %08x\n", f->c, f->type.t, f->next->c, f->next->type.t);
		5746	/* test for same offset */
		5747	if (f->next->c != f->c)
		5748	break;
		5749	if ((f_type == VT_STRUCT) && (f_size == 0)) {
		5750	/*
		5751	Lets assume a structure of size 0 can't be a member of the union.
		5752	This allow to compile the following code from a linux kernel v2.4.26
		5753	typedef struct { } rwlock_t;
		5754	struct fs_struct {
		5755	int count;
		5756	rwlock_t lock;
		5757	int umask;
		5758	};
		5759	struct fs_struct init_fs = { { (1) }, (rwlock_t) {}, 0022, };
		5760	tcc-0.9.23 can succesfully compile this version of the kernel.
		5761	gcc don't have problems with this code too.
		5762	*/
		5763	break;
		5764	}
		5765	/* if yes, test for bitfield shift */
		5766	if ((f->type.t & VT_BITFIELD) && (f->next->type.t & VT_BITFIELD)) {
		5767	int bit_pos_1 = (f->type.t >> VT_STRUCT_SHIFT) & 0x3f;
		5768	int bit_pos_2 = (f->next->type.t >> VT_STRUCT_SHIFT) & 0x3f;
		5769	//printf("bitfield %d %d\n", bit_pos_1, bit_pos_2);
		5770	if (bit_pos_1 != bit_pos_2)
		5771	break;
		5772	}
		5773	f = f->next;
		5774	}
		5775
		5776	f = f->next;
		5777	if (no_oblock && f == NULL)
		5778	break;
		5779	if (tok == '}')
		5780	break;
		5781	skip(',');
		5782	}
		5783	/* put zeros at the end */
		5784	if (!size_only && array_length < n) {
		5785	init_putz(type, sec, c + array_length,
		5786	n - array_length);
		5787	}
		5788	if (!no_oblock)
		5789	skip('}');
		5790	while (par_count) {
		5791	skip(')');
		5792	par_count--;
		5793	}
		5794	} else if (tok == '{') {
		5795	next();
		5796	decl_initializer(type, sec, c, first, size_only);
		5797	skip('}');
		5798	} else if (size_only) {
		5799	/* just skip expression */
		5800	parlevel = parlevel1 = 0;
		5801	while ((parlevel > 0 \|\| parlevel1 > 0 \|\|
		5802	(tok != '}' && tok != ',')) && tok != -1) {
		5803	if (tok == '(')
		5804	parlevel++;
		5805	else if (tok == ')') {
		5806	if (parlevel == 0 && parlevel1 == 0)
		5807	break;
		5808	parlevel--;
		5809	}
		5810	else if (tok == '{')
		5811	parlevel1++;
		5812	else if (tok == '}') {
		5813	if (parlevel == 0 && parlevel1 == 0)
		5814	break;
		5815	parlevel1--;
		5816	}
		5817	next();
		5818	}
		5819	} else {
		5820	/* currently, we always use constant expression for globals
		5821	(may change for scripting case) */
		5822	expr_type = EXPR_CONST;
		5823	if (!sec)
		5824	expr_type = EXPR_ANY;
		5825	init_putv(type, sec, c, 0, expr_type);
		5826	}
		5827	}
		5828
		5829	/* parse an initializer for type 't' if 'has_init' is non zero, and
		5830	allocate space in local or global data space ('r' is either
		5831	VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
		5832	variable 'v' of scope 'scope' is declared before initializers
		5833	are parsed. If 'v' is zero, then a reference to the new object
		5834	is put in the value stack. If 'has_init' is 2, a special parsing
		5835	is done to handle string constants. */
		5836	static void decl_initializer_alloc(CType type, AttributeDef ad, int r,
		5837	int has_init, int v, int scope)
		5838	{
		5839	int size, align, addr, data_offset;
		5840	int level;
		5841	ParseState saved_parse_state = {0};
		5842	TokenString init_str;
		5843	Section *sec;
		5844	Sym *flexible_array;
		5845
		5846	flexible_array = NULL;
		5847	if ((type->t & VT_BTYPE) == VT_STRUCT) {
		5848	Sym *field = type->ref->next;
		5849	if (field) {
		5850	while (field->next)
		5851	field = field->next;
		5852	if (field->type.t & VT_ARRAY && field->type.ref->c < 0)
		5853	flexible_array = field;
		5854	}
		5855	}
		5856
		5857	size = type_size(type, &align);
		5858	/* If unknown size, we must evaluate it before
		5859	evaluating initializers because
		5860	initializers can generate global data too
		5861	(e.g. string pointers or ISOC99 compound
		5862	literals). It also simplifies local
		5863	initializers handling */
		5864	tok_str_new(&init_str);
		5865	if (size < 0 \|\| (flexible_array && has_init)) {
		5866	if (!has_init)
		5867	tcc_error("unknown type size");
		5868	/* get all init string */
		5869	if (has_init == 2) {
		5870	/* only get strings */
		5871	while (tok == TOK_STR \|\| tok == TOK_LSTR) {
		5872	tok_str_add_tok(&init_str);
		5873	next();
		5874	}
		5875	} else {
		5876	level = 0;
		5877	while (level > 0 \|\| (tok != ',' && tok != ';')) {
		5878	if (tok < 0)
		5879	tcc_error("unexpected end of file in initializer");
		5880	tok_str_add_tok(&init_str);
		5881	if (tok == '{')
		5882	level++;
		5883	else if (tok == '}') {
		5884	level--;
		5885	if (level <= 0) {
		5886	next();
		5887	break;
		5888	}
		5889	}
		5890	next();
		5891	}
		5892	}
		5893	tok_str_add(&init_str, -1);
		5894	tok_str_add(&init_str, 0);
		5895
		5896	/* compute size */
		5897	save_parse_state(&saved_parse_state);
		5898
		5899	begin_macro(&init_str, 0);
		5900	next();
		5901	decl_initializer(type, NULL, 0, 1, 1);
		5902	/* prepare second initializer parsing */
		5903	macro_ptr = init_str.str;
		5904	next();
		5905
		5906	/* if still unknown size, error */
		5907	size = type_size(type, &align);
		5908	if (size < 0)
		5909	tcc_error("unknown type size");
		5910	}
		5911	/* If there's a flex member and it was used in the initializer
		5912	adjust size. */
		5913	if (flexible_array &&
		5914	flexible_array->type.ref->c > 0)
		5915	size += flexible_array->type.ref->c
		5916	* pointed_size(&flexible_array->type);
		5917	/* take into account specified alignment if bigger */
		5918	if (ad->a.aligned) {
		5919	if (ad->a.aligned > align)
		5920	align = ad->a.aligned;
		5921	} else if (ad->a.packed) {
		5922	align = 1;
		5923	}
		5924	if ((r & VT_VALMASK) == VT_LOCAL) {
		5925	sec = NULL;
		5926	#ifdef CONFIG_TCC_BCHECK
		5927	if (tcc_state->do_bounds_check && (type->t & VT_ARRAY)) {
		5928	loc--;
		5929	}
		5930	#endif
		5931	loc = (loc - size) & -align;
		5932	addr = loc;
		5933	#ifdef CONFIG_TCC_BCHECK
		5934	/* handles bounds */
		5935	/* XXX: currently, since we do only one pass, we cannot track
		5936	'&' operators, so we add only arrays */
		5937	if (tcc_state->do_bounds_check && (type->t & VT_ARRAY)) {
		5938	addr_t *bounds_ptr;
		5939	/* add padding between regions */
		5940	loc--;
		5941	/* then add local bound info */
		5942	bounds_ptr = section_ptr_add(lbounds_section, 2 * sizeof(addr_t));
		5943	bounds_ptr[0] = addr;
		5944	bounds_ptr[1] = size;
		5945	}
		5946	#endif
		5947	if (v) {
		5948	/* local variable */
		5949	sym_push(v, type, r, addr);
		5950	} else {
		5951	/* push local reference */
		5952	vset(type, r, addr);
		5953	}
		5954	} else {
		5955	Sym *sym;
		5956
		5957	sym = NULL;
		5958	if (v && scope == VT_CONST) {
		5959	/* see if the symbol was already defined */
		5960	sym = sym_find(v);
		5961	if (sym) {
		5962	if (!is_compatible_types(&sym->type, type))
		5963	tcc_error("incompatible types for redefinition of '%s'",
		5964	get_tok_str(v, NULL));
		5965	if (sym->type.t & VT_EXTERN) {
		5966	/* if the variable is extern, it was not allocated */
		5967	sym->type.t &= ~VT_EXTERN;
		5968	/* set array size if it was omitted in extern
		5969	declaration */
		5970	if ((sym->type.t & VT_ARRAY) &&
		5971	sym->type.ref->c < 0 &&
		5972	type->ref->c >= 0)
		5973	sym->type.ref->c = type->ref->c;
		5974	} else {
		5975	/* we accept several definitions of the same
		5976	global variable. this is tricky, because we
		5977	must play with the SHN_COMMON type of the symbol */
		5978	/* XXX: should check if the variable was already
		5979	initialized. It is incorrect to initialized it
		5980	twice */
		5981	/* no init data, we won't add more to the symbol */
		5982	if (!has_init)
		5983	goto no_alloc;
		5984	}
		5985	}
		5986	}
		5987
		5988	/* allocate symbol in corresponding section */
		5989	sec = ad->section;
		5990	if (!sec) {
		5991	if (has_init)
		5992	sec = data_section;
		5993	else if (tcc_state->nocommon)
		5994	sec = bss_section;
		5995	}
		5996	if (sec) {
		5997	data_offset = sec->data_offset;
		5998	data_offset = (data_offset + align - 1) & -align;
		5999	addr = data_offset;
		6000	/* very important to increment global pointer at this time
		6001	because initializers themselves can create new initializers */
		6002	data_offset += size;
		6003	#ifdef CONFIG_TCC_BCHECK
		6004	/* add padding if bound check */
		6005	if (tcc_state->do_bounds_check)
		6006	data_offset++;
		6007	#endif
		6008	sec->data_offset = data_offset;
		6009	/* allocate section space to put the data */
		6010	if (sec->sh_type != SHT_NOBITS &&
		6011	data_offset > sec->data_allocated)
		6012	section_realloc(sec, data_offset);
		6013	/* align section if needed */
		6014	if (align > sec->sh_addralign)
		6015	sec->sh_addralign = align;
		6016	} else {
		6017	addr = 0; /* avoid warning */
		6018	}
		6019
		6020	if (v) {
		6021	if (scope != VT_CONST \|\| !sym) {
		6022	sym = sym_push(v, type, r \| VT_SYM, 0);
		6023	sym->asm_label = ad->asm_label;
		6024	}
		6025	/* update symbol definition */
		6026	if (sec) {
		6027	put_extern_sym(sym, sec, addr, size);
		6028	} else {
		6029	ElfW(Sym) *esym;
		6030	/* put a common area */
		6031	put_extern_sym(sym, NULL, align, size);
		6032	/* XXX: find a nicer way */
		6033	esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
		6034	esym->st_shndx = SHN_COMMON;
		6035	}
		6036	} else {
		6037	/* push global reference */
		6038	sym = get_sym_ref(type, sec, addr, size);
		6039	vpushsym(type, sym);
		6040	}
		6041	/* patch symbol weakness */
		6042	if (type->t & VT_WEAK)
		6043	weaken_symbol(sym);
		6044	apply_visibility(sym, type);
		6045	#ifdef CONFIG_TCC_BCHECK
		6046	/* handles bounds now because the symbol must be defined
		6047	before for the relocation */
		6048	if (tcc_state->do_bounds_check) {
		6049	addr_t *bounds_ptr;
		6050
		6051	greloc(bounds_section, sym, bounds_section->data_offset, R_DATA_PTR);
		6052	/* then add global bound info */
		6053	bounds_ptr = section_ptr_add(bounds_section, 2 * sizeof(addr_t));
		6054	bounds_ptr[0] = 0; /* relocated */
		6055	bounds_ptr[1] = size;
		6056	}
		6057	#endif
		6058	}
		6059	if (has_init \|\| (type->t & VT_VLA)) {
		6060	decl_initializer(type, sec, addr, 1, 0);
		6061	/* restore parse state if needed */
		6062	if (init_str.str) {
		6063	end_macro();
		6064	restore_parse_state(&saved_parse_state);
		6065	}
		6066	/* patch flexible array member size back to -1, */
		6067	/* for possible subsequent similar declarations */
		6068	if (flexible_array)
		6069	flexible_array->type.ref->c = -1;
		6070	}
		6071	no_alloc: ;
		6072	}
		6073
		6074	static void put_func_debug(Sym *sym)
		6075	{
		6076	char buf[512];
		6077
		6078	/* stabs info */
		6079	/* XXX: we put here a dummy type */
		6080	snprintf(buf, sizeof(buf), "%s:%c1",
		6081	funcname, sym->type.t & VT_STATIC ? 'f' : 'F');
		6082	put_stabs_r(buf, N_FUN, 0, file->line_num, 0,
		6083	cur_text_section, sym->c);
		6084	/* //gr gdb wants a line at the function */
		6085	put_stabn(N_SLINE, 0, file->line_num, 0);
		6086	last_ind = 0;
		6087	last_line_num = 0;
		6088	}
		6089
		6090	/* parse an old style function declaration list */
		6091	/* XXX: check multiple parameter */
		6092	static void func_decl_list(Sym *func_sym)
		6093	{
		6094	AttributeDef ad;
		6095	int v;
		6096	Sym *s;
		6097	CType btype, type;
		6098
		6099	/* parse each declaration */
		6100	while (tok != '{' && tok != ';' && tok != ',' && tok != TOK_EOF &&
		6101	tok != TOK_ASM1 && tok != TOK_ASM2 && tok != TOK_ASM3) {
		6102	if (!parse_btype(&btype, &ad))
		6103	expect("declaration list");
		6104	if (((btype.t & VT_BTYPE) == VT_ENUM \|\|
		6105	(btype.t & VT_BTYPE) == VT_STRUCT) &&
		6106	tok == ';') {
		6107	/* we accept no variable after */
		6108	} else {
		6109	for(;;) {
		6110	type = btype;
		6111	type_decl(&type, &ad, &v, TYPE_DIRECT);
		6112	/* find parameter in function parameter list */
		6113	s = func_sym->next;
		6114	while (s != NULL) {
		6115	if ((s->v & ~SYM_FIELD) == v)
		6116	goto found;
		6117	s = s->next;
		6118	}
		6119	tcc_error("declaration for parameter '%s' but no such parameter",
		6120	get_tok_str(v, NULL));
		6121	found:
		6122	/* check that no storage specifier except 'register' was given */
		6123	if (type.t & VT_STORAGE)
		6124	tcc_error("storage class specified for '%s'", get_tok_str(v, NULL));
		6125	convert_parameter_type(&type);
		6126	/* we can add the type (NOTE: it could be local to the function) */
		6127	s->type = type;
		6128	/* accept other parameters */
		6129	if (tok == ',')
		6130	next();
		6131	else
		6132	break;
		6133	}
		6134	}
		6135	skip(';');
		6136	}
		6137	}
		6138
		6139	/* parse a function defined by symbol 'sym' and generate its code in
		6140	'cur_text_section' */
		6141	static void gen_function(Sym *sym)
		6142	{
		6143	int saved_nocode_wanted = nocode_wanted;
		6144
		6145	nocode_wanted = 0;
		6146	ind = cur_text_section->data_offset;
		6147	/* NOTE: we patch the symbol size later */
		6148	put_extern_sym(sym, cur_text_section, ind, 0);
		6149	funcname = get_tok_str(sym->v, NULL);
		6150	func_ind = ind;
		6151	/* Initialize VLA state */
		6152	vla_sp_loc = -1;
		6153	vla_sp_root_loc = -1;
		6154	/* put debug symbol */
		6155	if (tcc_state->do_debug)
		6156	put_func_debug(sym);
		6157	/* push a dummy symbol to enable local sym storage */
		6158	sym_push2(&local_stack, SYM_FIELD, 0, 0);
		6159	gfunc_prolog(&sym->type);
		6160	#ifdef CONFIG_TCC_BCHECK
		6161	if (tcc_state->do_bounds_check && !strcmp(funcname, "main")) {
		6162	int i;
		6163	Sym *sym;
		6164	for (i = 0, sym = local_stack; i < 2; i++, sym = sym->prev) {
		6165	if (sym->v & SYM_FIELD \|\| sym->prev->v & SYM_FIELD)
		6166	break;
		6167	vpush_global_sym(&func_old_type, TOK___bound_main_arg);
		6168	vset(&sym->type, sym->r, sym->c);
		6169	gfunc_call(1);
		6170	}
		6171	}
		6172	#endif
		6173	rsym = 0;
		6174	block(NULL, NULL, NULL, NULL, 0, 0);
		6175	gsym(rsym);
		6176	gfunc_epilog();
		6177	cur_text_section->data_offset = ind;
		6178	label_pop(&global_label_stack, NULL);
		6179	/* reset local stack */
		6180	scope_stack_bottom = NULL;
		6181	sym_pop(&local_stack, NULL);
		6182	/* end of function */
		6183	/* patch symbol size */
		6184	((ElfW(Sym) *)symtab_section->data)[sym->c].st_size =
		6185	ind - func_ind;
		6186	/* patch symbol weakness (this definition overrules any prototype) */
		6187	if (sym->type.t & VT_WEAK)
		6188	weaken_symbol(sym);
		6189	apply_visibility(sym, &sym->type);
		6190	if (tcc_state->do_debug) {
		6191	put_stabn(N_FUN, 0, 0, ind - func_ind);
		6192	}
		6193	/* It's better to crash than to generate wrong code */
		6194	cur_text_section = NULL;
		6195	funcname = ""; /* for safety */
		6196	func_vt.t = VT_VOID; /* for safety */
		6197	func_var = 0; /* for safety */
		6198	ind = 0; /* for safety */
		6199	nocode_wanted = saved_nocode_wanted;
		6200	check_vstack();
		6201	}
		6202
		6203	ST_FUNC void gen_inline_functions(void)
		6204	{
		6205	Sym *sym;
		6206	int inline_generated, i, ln;
		6207	struct InlineFunc *fn;
		6208
		6209	ln = file->line_num;
		6210	/* iterate while inline function are referenced */
		6211	for(;;) {
		6212	inline_generated = 0;
		6213	for (i = 0; i < tcc_state->nb_inline_fns; ++i) {
		6214	fn = tcc_state->inline_fns[i];
		6215	sym = fn->sym;
		6216	if (sym && sym->c) {
		6217	/* the function was used: generate its code and
		6218	convert it to a normal function */
		6219	fn->sym = NULL;
		6220	if (file)
		6221	pstrcpy(file->filename, sizeof file->filename, fn->filename);
		6222	sym->r = VT_SYM \| VT_CONST;
		6223	sym->type.t &= ~VT_INLINE;
		6224
		6225	begin_macro(&fn->func_str, 0);
		6226	next();
		6227	cur_text_section = text_section;
		6228	gen_function(sym);
		6229	end_macro();
		6230
		6231	inline_generated = 1;
		6232	}
		6233	}
		6234	if (!inline_generated)
		6235	break;
		6236	}
		6237	file->line_num = ln;
		6238	/* free tokens of unused inline functions */
		6239	for (i = 0; i < tcc_state->nb_inline_fns; ++i) {
		6240	fn = tcc_state->inline_fns[i];
		6241	if (fn->sym)
		6242	tok_str_free(fn->func_str.str);
		6243	}
		6244	dynarray_reset(&tcc_state->inline_fns, &tcc_state->nb_inline_fns);
		6245	}
		6246
		6247	/* 'l' is VT_LOCAL or VT_CONST to define default storage type */
		6248	static int decl0(int l, int is_for_loop_init)
		6249	{
		6250	int v, has_init, r;
		6251	CType type, btype;
		6252	Sym *sym;
		6253	AttributeDef ad;
		6254
		6255	while (1) {
		6256	if (!parse_btype(&btype, &ad)) {
		6257	if (is_for_loop_init)
		6258	return 0;
		6259	/* skip redundant ';' */
		6260	/* XXX: find more elegant solution */
		6261	if (tok == ';') {
		6262	next();
		6263	continue;
		6264	}
		6265	if (l == VT_CONST &&
		6266	(tok == TOK_ASM1 \|\| tok == TOK_ASM2 \|\| tok == TOK_ASM3)) {
		6267	/* global asm block */
		6268	asm_global_instr();
		6269	continue;
		6270	}
		6271	/* special test for old K&R protos without explicit int
		6272	type. Only accepted when defining global data */
		6273	if (l == VT_LOCAL \|\| tok < TOK_DEFINE)
		6274	break;
		6275	btype.t = VT_INT;
		6276	}
		6277	if (((btype.t & VT_BTYPE) == VT_ENUM \|\|
		6278	(btype.t & VT_BTYPE) == VT_STRUCT) &&
		6279	tok == ';') {
		6280	if ((btype.t & VT_BTYPE) == VT_STRUCT) {
		6281	int v = btype.ref->v;
		6282	if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) >= SYM_FIRST_ANOM)
		6283	tcc_warning("unnamed struct/union that defines no instances");
		6284	}
		6285	next();
		6286	continue;
		6287	}
		6288	while (1) { /* iterate thru each declaration */
		6289	type = btype;
		6290	type_decl(&type, &ad, &v, TYPE_DIRECT);
		6291	#if 0
		6292	{
		6293	char buf[500];
		6294	type_to_str(buf, sizeof(buf), t, get_tok_str(v, NULL));
		6295	printf("type = '%s'\n", buf);
		6296	}
		6297	#endif
		6298	if ((type.t & VT_BTYPE) == VT_FUNC) {
		6299	if ((type.t & VT_STATIC) && (l == VT_LOCAL)) {
		6300	tcc_error("function without file scope cannot be static");
		6301	}
		6302	/* if old style function prototype, we accept a
		6303	declaration list */
		6304	sym = type.ref;
		6305	if (sym->c == FUNC_OLD)
		6306	func_decl_list(sym);
		6307	}
		6308
		6309	if (gnu_ext && (tok == TOK_ASM1 \|\| tok == TOK_ASM2 \|\| tok == TOK_ASM3)) {
		6310	ad.asm_label = asm_label_instr();
		6311	/* parse one last attribute list, after asm label */
		6312	parse_attribute(&ad);
		6313	if (tok == '{')
		6314	expect(";");
		6315	}
		6316
		6317	if (ad.a.weak)
		6318	type.t \|= VT_WEAK;
9782	Coldy	6319	#if defined(TCC_TARGET_PE) \|\| defined(TCC_TARGET_KX)
6429	siemargl	6320	if (ad.a.func_import)
		6321	type.t \|= VT_IMPORT;
		6322	if (ad.a.func_export)
		6323	type.t \|= VT_EXPORT;
		6324	#endif
		6325	type.t \|= ad.a.visibility << VT_VIS_SHIFT;
		6326
		6327	if (tok == '{') {
		6328	if (l == VT_LOCAL)
		6329	tcc_error("cannot use local functions");
		6330	if ((type.t & VT_BTYPE) != VT_FUNC)
		6331	expect("function definition");
		6332
		6333	/* reject abstract declarators in function definition */
		6334	sym = type.ref;
		6335	while ((sym = sym->next) != NULL)
		6336	if (!(sym->v & ~SYM_FIELD))
		6337	expect("identifier");
		6338
		6339	/* XXX: cannot do better now: convert extern line to static inline */
		6340	if ((type.t & (VT_EXTERN \| VT_INLINE)) == (VT_EXTERN \| VT_INLINE))
		6341	type.t = (type.t & ~VT_EXTERN) \| VT_STATIC;
		6342
		6343	sym = sym_find(v);
		6344	if (sym) {
		6345	Sym *ref;
		6346	if ((sym->type.t & VT_BTYPE) != VT_FUNC)
		6347	goto func_error1;
		6348
		6349	ref = sym->type.ref;
		6350	if (0 == ref->a.func_proto)
		6351	tcc_error("redefinition of '%s'", get_tok_str(v, NULL));
		6352
		6353	/* use func_call from prototype if not defined */
		6354	if (ref->a.func_call != FUNC_CDECL
		6355	&& type.ref->a.func_call == FUNC_CDECL)
		6356	type.ref->a.func_call = ref->a.func_call;
		6357
		6358	/* use export from prototype */
		6359	if (ref->a.func_export)
		6360	type.ref->a.func_export = 1;
		6361
		6362	/* use static from prototype */
		6363	if (sym->type.t & VT_STATIC)
		6364	type.t = (type.t & ~VT_EXTERN) \| VT_STATIC;
		6365
		6366	/* If the definition has no visibility use the
		6367	one from prototype. */
		6368	if (! (type.t & VT_VIS_MASK))
		6369	type.t \|= sym->type.t & VT_VIS_MASK;
		6370
		6371	if (!is_compatible_types(&sym->type, &type)) {
		6372	func_error1:
		6373	tcc_error("incompatible types for redefinition of '%s'",
		6374	get_tok_str(v, NULL));
		6375	}
		6376	type.ref->a.func_proto = 0;
		6377	/* if symbol is already defined, then put complete type */
		6378	sym->type = type;
		6379	} else {
		6380	/* put function symbol */
		6381	sym = global_identifier_push(v, type.t, 0);
		6382	sym->type.ref = type.ref;
		6383	}
		6384
		6385	/* static inline functions are just recorded as a kind
		6386	of macro. Their code will be emitted at the end of
		6387	the compilation unit only if they are used */
		6388	if ((type.t & (VT_INLINE \| VT_STATIC)) ==
		6389	(VT_INLINE \| VT_STATIC)) {
		6390	int block_level;
		6391	struct InlineFunc *fn;
		6392	const char *filename;
		6393
		6394	filename = file ? file->filename : "";
		6395	fn = tcc_malloc(sizeof *fn + strlen(filename));
		6396	strcpy(fn->filename, filename);
		6397	fn->sym = sym;
		6398	tok_str_new(&fn->func_str);
		6399
		6400	block_level = 0;
		6401	for(;;) {
		6402	int t;
		6403	if (tok == TOK_EOF)
		6404	tcc_error("unexpected end of file");
		6405	tok_str_add_tok(&fn->func_str);
		6406	t = tok;
		6407	next();
		6408	if (t == '{') {
		6409	block_level++;
		6410	} else if (t == '}') {
		6411	block_level--;
		6412	if (block_level == 0)
		6413	break;
		6414	}
		6415	}
		6416	tok_str_add(&fn->func_str, -1);
		6417	tok_str_add(&fn->func_str, 0);
		6418	dynarray_add((void ***)&tcc_state->inline_fns, &tcc_state->nb_inline_fns, fn);
		6419
		6420	} else {
		6421	/* compute text section */
		6422	cur_text_section = ad.section;
		6423	if (!cur_text_section)
		6424	cur_text_section = text_section;
		6425	sym->r = VT_SYM \| VT_CONST;
		6426	gen_function(sym);
		6427	}
		6428	break;
		6429	} else {
		6430	if (btype.t & VT_TYPEDEF) {
		6431	/* save typedefed type */
		6432	/* XXX: test storage specifiers ? */
		6433	sym = sym_push(v, &type, 0, 0);
		6434	sym->a = ad.a;
		6435	sym->type.t \|= VT_TYPEDEF;
		6436	} else {
		6437	r = 0;
		6438	if ((type.t & VT_BTYPE) == VT_FUNC) {
		6439	/* external function definition */
		6440	/* specific case for func_call attribute */
		6441	ad.a.func_proto = 1;
		6442	type.ref->a = ad.a;
		6443	} else if (!(type.t & VT_ARRAY)) {
		6444	/* not lvalue if array */
		6445	r \|= lvalue_type(type.t);
		6446	}
		6447	has_init = (tok == '=');
		6448	if (has_init && (type.t & VT_VLA))
		6449	tcc_error("Variable length array cannot be initialized");
		6450	if ((btype.t & VT_EXTERN) \|\| ((type.t & VT_BTYPE) == VT_FUNC) \|\|
		6451	((type.t & VT_ARRAY) && (type.t & VT_STATIC) &&
		6452	!has_init && l == VT_CONST && type.ref->c < 0)) {
		6453	/* external variable or function */
		6454	/* NOTE: as GCC, uninitialized global static
		6455	arrays of null size are considered as
		6456	extern */
		6457	sym = external_sym(v, &type, r);
		6458	sym->asm_label = ad.asm_label;
		6459
		6460	if (ad.alias_target) {
		6461	Section tsec;
		6462	Elf32_Sym *esym;
		6463	Sym *alias_target;
		6464
		6465	alias_target = sym_find(ad.alias_target);
		6466	if (!alias_target \|\| !alias_target->c)
		6467	tcc_error("unsupported forward __alias__ attribute");
		6468	esym = &((Elf32_Sym *)symtab_section->data)[alias_target->c];
		6469	tsec.sh_num = esym->st_shndx;
		6470	put_extern_sym2(sym, &tsec, esym->st_value, esym->st_size, 0);
		6471	}
		6472	} else {
		6473	type.t \|= (btype.t & VT_STATIC); /* Retain "static". */
		6474	if (type.t & VT_STATIC)
		6475	r \|= VT_CONST;
		6476	else
		6477	r \|= l;
		6478	if (has_init)
		6479	next();
		6480	decl_initializer_alloc(&type, &ad, r, has_init, v, l);
		6481	}
		6482	}
		6483	if (tok != ',') {
		6484	if (is_for_loop_init)
		6485	return 1;
		6486	skip(';');
		6487	break;
		6488	}
		6489	next();
		6490	}
		6491	ad.a.aligned = 0;
		6492	}
		6493	}
		6494	return 0;
		6495	}
		6496
		6497	ST_FUNC void decl(int l)
		6498	{
		6499	decl0(l, 0);
		6500	}

Subversion Repositories Kolibri OS

(root)/programs/develop/ktcc/trunk/source/tccgen.c – Rev 9782