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