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