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