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