?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tccasm: support alternate .type syntaxes
[tinycc/miki.git] / tccgen.c
blobb84e7b6cc2546a47e83c1951971f23e69e8c7486
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->weak) {
2931 t |= VT_WEAK;
2932 }
2933 if (ad->mode) {
2934 u = ad->mode -1;
2935 t = (t & ~VT_BTYPE) | u;
2936 }
2937 break;
2938 /* GNUC typeof */
2939 case TOK_TYPEOF1:
2940 case TOK_TYPEOF2:
2941 case TOK_TYPEOF3:
2942 next();
2943 parse_expr_type(&type1);
2944 goto basic_type2;
2945 default:
2946 if (typespec_found || typedef_found)
2947 goto the_end;
2948 s = sym_find(tok);
2949 if (!s || !(s->type.t & VT_TYPEDEF))
2950 goto the_end;
2951 typedef_found = 1;
2952 t |= (s->type.t & ~VT_TYPEDEF);
2953 type->ref = s->type.ref;
2954 if (s->r) {
2955 /* get attributes from typedef */
2956 if (0 == ad->aligned)
2957 ad->aligned = FUNC_ALIGN(s->r);
2958 if (0 == ad->func_call)
2959 ad->func_call = FUNC_CALL(s->r);
2960 ad->packed |= FUNC_PACKED(s->r);
2961 }
2962 next();
2963 typespec_found = 1;
2964 break;
2965 }
2966 type_found = 1;
2967 }
2968 the_end:
2969 if ((t & (VT_SIGNED|VT_UNSIGNED)) == (VT_SIGNED|VT_UNSIGNED))
2970 error("signed and unsigned modifier");
2971 if (tcc_state->char_is_unsigned) {
2972 if ((t & (VT_SIGNED|VT_UNSIGNED|VT_BTYPE)) == VT_BYTE)
2973 t |= VT_UNSIGNED;
2974 }
2975 t &= ~VT_SIGNED;
2976
2977 /* long is never used as type */
2978 if ((t & VT_BTYPE) == VT_LONG)
2979 #if !defined TCC_TARGET_X86_64 || defined TCC_TARGET_PE
2980 t = (t & ~VT_BTYPE) | VT_INT;
2981 #else
2982 t = (t & ~VT_BTYPE) | VT_LLONG;
2983 #endif
2984 type->t = t;
2985 return type_found;
2986 }
2987
2988 /* convert a function parameter type (array to pointer and function to
2989 function pointer) */
2990 static inline void convert_parameter_type(CType *pt)
2991 {
2992 /* remove const and volatile qualifiers (XXX: const could be used
2993 to indicate a const function parameter */
2994 pt->t &= ~(VT_CONSTANT | VT_VOLATILE);
2995 /* array must be transformed to pointer according to ANSI C */
2996 pt->t &= ~VT_ARRAY;
2997 if ((pt->t & VT_BTYPE) == VT_FUNC) {
2998 mk_pointer(pt);
2999 }
3000 }
3001
3002 ST_FUNC void parse_asm_str(CString *astr)
3003 {
3004 skip('(');
3005 /* read the string */
3006 if (tok != TOK_STR)
3007 expect("string constant");
3008 cstr_new(astr);
3009 while (tok == TOK_STR) {
3010 /* XXX: add \0 handling too ? */
3011 cstr_cat(astr, tokc.cstr->data);
3012 next();
3013 }
3014 cstr_ccat(astr, '\0');
3015 }
3016
3017 /* Parse an asm label and return the label
3018 * Don't forget to free the CString in the caller! */
3019 static void asm_label_instr(CString *astr)
3020 {
3021 next();
3022 parse_asm_str(astr);
3023 skip(')');
3024 #ifdef ASM_DEBUG
3025 printf("asm_alias: \"%s\"\n", (char *)astr->data);
3026 #endif
3027 }
3028
3029 static void post_type(CType *type, AttributeDef *ad)
3030 {
3031 int n, l, t1, arg_size, align;
3032 Sym **plast, *s, *first;
3033 AttributeDef ad1;
3034 CType pt;
3035
3036 if (tok == '(') {
3037 /* function declaration */
3038 next();
3039 l = 0;
3040 first = NULL;
3041 plast = &first;
3042 arg_size = 0;
3043 if (tok != ')') {
3044 for(;;) {
3045 /* read param name and compute offset */
3046 if (l != FUNC_OLD) {
3047 if (!parse_btype(&pt, &ad1)) {
3048 if (l) {
3049 error("invalid type");
3050 } else {
3051 l = FUNC_OLD;
3052 goto old_proto;
3053 }
3054 }
3055 l = FUNC_NEW;
3056 if ((pt.t & VT_BTYPE) == VT_VOID && tok == ')')
3057 break;
3058 type_decl(&pt, &ad1, &n, TYPE_DIRECT | TYPE_ABSTRACT);
3059 if ((pt.t & VT_BTYPE) == VT_VOID)
3060 error("parameter declared as void");
3061 arg_size += (type_size(&pt, &align) + PTR_SIZE - 1) / PTR_SIZE;
3062 } else {
3063 old_proto:
3064 n = tok;
3065 if (n < TOK_UIDENT)
3066 expect("identifier");
3067 pt.t = VT_INT;
3068 next();
3069 }
3070 convert_parameter_type(&pt);
3071 s = sym_push(n | SYM_FIELD, &pt, 0, 0);
3072 *plast = s;
3073 plast = &s->next;
3074 if (tok == ')')
3075 break;
3076 skip(',');
3077 if (l == FUNC_NEW && tok == TOK_DOTS) {
3078 l = FUNC_ELLIPSIS;
3079 next();
3080 break;
3081 }
3082 }
3083 }
3084 /* if no parameters, then old type prototype */
3085 if (l == 0)
3086 l = FUNC_OLD;
3087 skip(')');
3088 t1 = type->t & VT_STORAGE;
3089 /* NOTE: const is ignored in returned type as it has a special
3090 meaning in gcc / C++ */
3091 type->t &= ~(VT_STORAGE | VT_CONSTANT);
3092 post_type(type, ad);
3093 /* we push a anonymous symbol which will contain the function prototype */
3094 ad->func_args = arg_size;
3095 s = sym_push(SYM_FIELD, type, INT_ATTR(ad), l);
3096 s->next = first;
3097 type->t = t1 | VT_FUNC;
3098 type->ref = s;
3099 } else if (tok == '[') {
3100 /* array definition */
3101 next();
3102 if (tok == TOK_RESTRICT1)
3103 next();
3104 n = -1;
3105 if (tok != ']') {
3106 n = expr_const();
3107 if (n < 0)
3108 error("invalid array size");
3109 }
3110 skip(']');
3111 /* parse next post type */
3112 t1 = type->t & VT_STORAGE;
3113 type->t &= ~VT_STORAGE;
3114 post_type(type, ad);
3115
3116 /* we push a anonymous symbol which will contain the array
3117 element type */
3118 s = sym_push(SYM_FIELD, type, 0, n);
3119 if (n < 0)
3120 ARRAY_RESIZE(s->r) = 1;
3121 type->t = t1 | VT_ARRAY | VT_PTR;
3122 type->ref = s;
3123 }
3124 }
3125
3126 /* Parse a type declaration (except basic type), and return the type
3127 in 'type'. 'td' is a bitmask indicating which kind of type decl is
3128 expected. 'type' should contain the basic type. 'ad' is the
3129 attribute definition of the basic type. It can be modified by
3130 type_decl().
3131 */
3132 static void type_decl(CType *type, AttributeDef *ad, int *v, int td)
3133 {
3134 Sym *s;
3135 CType type1, *type2;
3136 int qualifiers;
3137
3138 while (tok == '*') {
3139 qualifiers = 0;
3140 redo:
3141 next();
3142 switch(tok) {
3143 case TOK_CONST1:
3144 case TOK_CONST2:
3145 case TOK_CONST3:
3146 qualifiers |= VT_CONSTANT;
3147 goto redo;
3148 case TOK_VOLATILE1:
3149 case TOK_VOLATILE2:
3150 case TOK_VOLATILE3:
3151 qualifiers |= VT_VOLATILE;
3152 goto redo;
3153 case TOK_RESTRICT1:
3154 case TOK_RESTRICT2:
3155 case TOK_RESTRICT3:
3156 goto redo;
3157 }
3158 mk_pointer(type);
3159 type->t |= qualifiers;
3160 }
3161
3162 /* XXX: clarify attribute handling */
3163 if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2)
3164 parse_attribute(ad);
3165
3166 /* recursive type */
3167 /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
3168 type1.t = 0; /* XXX: same as int */
3169 if (tok == '(') {
3170 next();
3171 /* XXX: this is not correct to modify 'ad' at this point, but
3172 the syntax is not clear */
3173 if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2)
3174 parse_attribute(ad);
3175 type_decl(&type1, ad, v, td);
3176 skip(')');
3177 } else {
3178 /* type identifier */
3179 if (tok >= TOK_IDENT && (td & TYPE_DIRECT)) {
3180 *v = tok;
3181 next();
3182 } else {
3183 if (!(td & TYPE_ABSTRACT))
3184 expect("identifier");
3185 *v = 0;
3186 }
3187 }
3188 post_type(type, ad);
3189 if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2)
3190 parse_attribute(ad);
3191
3192 if (ad->weak)
3193 type->t |= VT_WEAK;
3194
3195 if (!type1.t)
3196 return;
3197 /* append type at the end of type1 */
3198 type2 = &type1;
3199 for(;;) {
3200 s = type2->ref;
3201 type2 = &s->type;
3202 if (!type2->t) {
3203 *type2 = *type;
3204 break;
3205 }
3206 }
3207 *type = type1;
3208 }
3209
3210 /* compute the lvalue VT_LVAL_xxx needed to match type t. */
3211 ST_FUNC int lvalue_type(int t)
3212 {
3213 int bt, r;
3214 r = VT_LVAL;
3215 bt = t & VT_BTYPE;
3216 if (bt == VT_BYTE || bt == VT_BOOL)
3217 r |= VT_LVAL_BYTE;
3218 else if (bt == VT_SHORT)
3219 r |= VT_LVAL_SHORT;
3220 else
3221 return r;
3222 if (t & VT_UNSIGNED)
3223 r |= VT_LVAL_UNSIGNED;
3224 return r;
3225 }
3226
3227 /* indirection with full error checking and bound check */
3228 ST_FUNC void indir(void)
3229 {
3230 if ((vtop->type.t & VT_BTYPE) != VT_PTR) {
3231 if ((vtop->type.t & VT_BTYPE) == VT_FUNC)
3232 return;
3233 expect("pointer");
3234 }
3235 if ((vtop->r & VT_LVAL) && !nocode_wanted)
3236 gv(RC_INT);
3237 vtop->type = *pointed_type(&vtop->type);
3238 /* Arrays and functions are never lvalues */
3239 if (!(vtop->type.t & VT_ARRAY)
3240 && (vtop->type.t & VT_BTYPE) != VT_FUNC) {
3241 vtop->r |= lvalue_type(vtop->type.t);
3242 /* if bound checking, the referenced pointer must be checked */
3243 #ifdef CONFIG_TCC_BCHECK
3244 if (tcc_state->do_bounds_check)
3245 vtop->r |= VT_MUSTBOUND;
3246 #endif
3247 }
3248 }
3249
3250 /* pass a parameter to a function and do type checking and casting */
3251 static void gfunc_param_typed(Sym *func, Sym *arg)
3252 {
3253 int func_type;
3254 CType type;
3255
3256 func_type = func->c;
3257 if (func_type == FUNC_OLD ||
3258 (func_type == FUNC_ELLIPSIS && arg == NULL)) {
3259 /* default casting : only need to convert float to double */
3260 if ((vtop->type.t & VT_BTYPE) == VT_FLOAT) {
3261 type.t = VT_DOUBLE;
3262 gen_cast(&type);
3263 }
3264 } else if (arg == NULL) {
3265 error("too many arguments to function");
3266 } else {
3267 type = arg->type;
3268 type.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */
3269 gen_assign_cast(&type);
3270 }
3271 }
3272
3273 /* parse an expression of the form '(type)' or '(expr)' and return its
3274 type */
3275 static void parse_expr_type(CType *type)
3276 {
3277 int n;
3278 AttributeDef ad;
3279
3280 skip('(');
3281 if (parse_btype(type, &ad)) {
3282 type_decl(type, &ad, &n, TYPE_ABSTRACT);
3283 } else {
3284 expr_type(type);
3285 }
3286 skip(')');
3287 }
3288
3289 static void parse_type(CType *type)
3290 {
3291 AttributeDef ad;
3292 int n;
3293
3294 if (!parse_btype(type, &ad)) {
3295 expect("type");
3296 }
3297 type_decl(type, &ad, &n, TYPE_ABSTRACT);
3298 }
3299
3300 static void vpush_tokc(int t)
3301 {
3302 CType type;
3303 type.t = t;
3304 type.ref = 0;
3305 vsetc(&type, VT_CONST, &tokc);
3306 }
3307
3308 ST_FUNC void unary(void)
3309 {
3310 int n, t, align, size, r, sizeof_caller;
3311 CType type;
3312 Sym *s;
3313 AttributeDef ad;
3314 static int in_sizeof = 0;
3315
3316 sizeof_caller = in_sizeof;
3317 in_sizeof = 0;
3318 /* XXX: GCC 2.95.3 does not generate a table although it should be
3319 better here */
3320 tok_next:
3321 switch(tok) {
3322 case TOK_EXTENSION:
3323 next();
3324 goto tok_next;
3325 case TOK_CINT:
3326 case TOK_CCHAR:
3327 case TOK_LCHAR:
3328 vpushi(tokc.i);
3329 next();
3330 break;
3331 case TOK_CUINT:
3332 vpush_tokc(VT_INT | VT_UNSIGNED);
3333 next();
3334 break;
3335 case TOK_CLLONG:
3336 vpush_tokc(VT_LLONG);
3337 next();
3338 break;
3339 case TOK_CULLONG:
3340 vpush_tokc(VT_LLONG | VT_UNSIGNED);
3341 next();
3342 break;
3343 case TOK_CFLOAT:
3344 vpush_tokc(VT_FLOAT);
3345 next();
3346 break;
3347 case TOK_CDOUBLE:
3348 vpush_tokc(VT_DOUBLE);
3349 next();
3350 break;
3351 case TOK_CLDOUBLE:
3352 vpush_tokc(VT_LDOUBLE);
3353 next();
3354 break;
3355 case TOK___FUNCTION__:
3356 if (!gnu_ext)
3357 goto tok_identifier;
3358 /* fall thru */
3359 case TOK___FUNC__:
3360 {
3361 void *ptr;
3362 int len;
3363 /* special function name identifier */
3364 len = strlen(funcname) + 1;
3365 /* generate char[len] type */
3366 type.t = VT_BYTE;
3367 mk_pointer(&type);
3368 type.t |= VT_ARRAY;
3369 type.ref->c = len;
3370 vpush_ref(&type, data_section, data_section->data_offset, len);
3371 ptr = section_ptr_add(data_section, len);
3372 memcpy(ptr, funcname, len);
3373 next();
3374 }
3375 break;
3376 case TOK_LSTR:
3377 #ifdef TCC_TARGET_PE
3378 t = VT_SHORT | VT_UNSIGNED;
3379 #else
3380 t = VT_INT;
3381 #endif
3382 goto str_init;
3383 case TOK_STR:
3384 /* string parsing */
3385 t = VT_BYTE;
3386 str_init:
3387 if (tcc_state->warn_write_strings)
3388 t |= VT_CONSTANT;
3389 type.t = t;
3390 mk_pointer(&type);
3391 type.t |= VT_ARRAY;
3392 memset(&ad, 0, sizeof(AttributeDef));
3393 decl_initializer_alloc(&type, &ad, VT_CONST, 2, 0, NULL, 0);
3394 break;
3395 case '(':
3396 next();
3397 /* cast ? */
3398 if (parse_btype(&type, &ad)) {
3399 type_decl(&type, &ad, &n, TYPE_ABSTRACT);
3400 skip(')');
3401 /* check ISOC99 compound literal */
3402 if (tok == '{') {
3403 /* data is allocated locally by default */
3404 if (global_expr)
3405 r = VT_CONST;
3406 else
3407 r = VT_LOCAL;
3408 /* all except arrays are lvalues */
3409 if (!(type.t & VT_ARRAY))
3410 r |= lvalue_type(type.t);
3411 memset(&ad, 0, sizeof(AttributeDef));
3412 decl_initializer_alloc(&type, &ad, r, 1, 0, NULL, 0);
3413 } else {
3414 if (sizeof_caller) {
3415 vpush(&type);
3416 return;
3417 }
3418 unary();
3419 gen_cast(&type);
3420 }
3421 } else if (tok == '{') {
3422 /* save all registers */
3423 save_regs(0);
3424 /* statement expression : we do not accept break/continue
3425 inside as GCC does */
3426 block(NULL, NULL, NULL, NULL, 0, 1);
3427 skip(')');
3428 } else {
3429 gexpr();
3430 skip(')');
3431 }
3432 break;
3433 case '*':
3434 next();
3435 unary();
3436 indir();
3437 break;
3438 case '&':
3439 next();
3440 unary();
3441 /* functions names must be treated as function pointers,
3442 except for unary '&' and sizeof. Since we consider that
3443 functions are not lvalues, we only have to handle it
3444 there and in function calls. */
3445 /* arrays can also be used although they are not lvalues */
3446 if ((vtop->type.t & VT_BTYPE) != VT_FUNC &&
3447 !(vtop->type.t & VT_ARRAY) && !(vtop->type.t & VT_LLOCAL))
3448 test_lvalue();
3449 mk_pointer(&vtop->type);
3450 gaddrof();
3451 break;
3452 case '!':
3453 next();
3454 unary();
3455 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
3456 CType boolean;
3457 boolean.t = VT_BOOL;
3458 gen_cast(&boolean);
3459 vtop->c.i = !vtop->c.i;
3460 } else if ((vtop->r & VT_VALMASK) == VT_CMP)
3461 vtop->c.i = vtop->c.i ^ 1;
3462 else {
3463 save_regs(1);
3464 vseti(VT_JMP, gtst(1, 0));
3465 }
3466 break;
3467 case '~':
3468 next();
3469 unary();
3470 vpushi(-1);
3471 gen_op('^');
3472 break;
3473 case '+':
3474 next();
3475 /* in order to force cast, we add zero */
3476 unary();
3477 if ((vtop->type.t & VT_BTYPE) == VT_PTR)
3478 error("pointer not accepted for unary plus");
3479 vpushi(0);
3480 gen_op('+');
3481 break;
3482 case TOK_SIZEOF:
3483 case TOK_ALIGNOF1:
3484 case TOK_ALIGNOF2:
3485 t = tok;
3486 next();
3487 in_sizeof++;
3488 unary_type(&type); // Perform a in_sizeof = 0;
3489 size = type_size(&type, &align);
3490 if (t == TOK_SIZEOF) {
3491 if (size < 0)
3492 error("sizeof applied to an incomplete type");
3493 vpushi(size);
3494 } else {
3495 vpushi(align);
3496 }
3497 vtop->type.t |= VT_UNSIGNED;
3498 break;
3499
3500 case TOK_builtin_types_compatible_p:
3501 {
3502 CType type1, type2;
3503 next();
3504 skip('(');
3505 parse_type(&type1);
3506 skip(',');
3507 parse_type(&type2);
3508 skip(')');
3509 type1.t &= ~(VT_CONSTANT | VT_VOLATILE);
3510 type2.t &= ~(VT_CONSTANT | VT_VOLATILE);
3511 vpushi(is_compatible_types(&type1, &type2));
3512 }
3513 break;
3514 case TOK_builtin_constant_p:
3515 {
3516 int saved_nocode_wanted, res;
3517 next();
3518 skip('(');
3519 saved_nocode_wanted = nocode_wanted;
3520 nocode_wanted = 1;
3521 gexpr();
3522 res = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
3523 vpop();
3524 nocode_wanted = saved_nocode_wanted;
3525 skip(')');
3526 vpushi(res);
3527 }
3528 break;
3529 case TOK_builtin_frame_address:
3530 {
3531 CType type;
3532 next();
3533 skip('(');
3534 if (tok != TOK_CINT) {
3535 error("__builtin_frame_address only takes integers");
3536 }
3537 if (tokc.i != 0) {
3538 error("TCC only supports __builtin_frame_address(0)");
3539 }
3540 next();
3541 skip(')');
3542 type.t = VT_VOID;
3543 mk_pointer(&type);
3544 vset(&type, VT_LOCAL, 0);
3545 }
3546 break;
3547 #ifdef TCC_TARGET_X86_64
3548 case TOK_builtin_va_arg_types:
3549 {
3550 /* This definition must be synced with stdarg.h */
3551 enum __va_arg_type {
3552 __va_gen_reg, __va_float_reg, __va_stack
3553 };
3554 CType type;
3555 int bt;
3556 next();
3557 skip('(');
3558 parse_type(&type);
3559 skip(')');
3560 bt = type.t & VT_BTYPE;
3561 if (bt == VT_STRUCT || bt == VT_LDOUBLE) {
3562 vpushi(__va_stack);
3563 } else if (bt == VT_FLOAT || bt == VT_DOUBLE) {
3564 vpushi(__va_float_reg);
3565 } else {
3566 vpushi(__va_gen_reg);
3567 }
3568 }
3569 break;
3570 #endif
3571 case TOK_INC:
3572 case TOK_DEC:
3573 t = tok;
3574 next();
3575 unary();
3576 inc(0, t);
3577 break;
3578 case '-':
3579 next();
3580 vpushi(0);
3581 unary();
3582 gen_op('-');
3583 break;
3584 case TOK_LAND:
3585 if (!gnu_ext)
3586 goto tok_identifier;
3587 next();
3588 /* allow to take the address of a label */
3589 if (tok < TOK_UIDENT)
3590 expect("label identifier");
3591 s = label_find(tok);
3592 if (!s) {
3593 s = label_push(&global_label_stack, tok, LABEL_FORWARD);
3594 } else {
3595 if (s->r == LABEL_DECLARED)
3596 s->r = LABEL_FORWARD;
3597 }
3598 if (!s->type.t) {
3599 s->type.t = VT_VOID;
3600 mk_pointer(&s->type);
3601 s->type.t |= VT_STATIC;
3602 }
3603 vset(&s->type, VT_CONST | VT_SYM, 0);
3604 vtop->sym = s;
3605 next();
3606 break;
3607
3608 // special qnan , snan and infinity values
3609 case TOK___NAN__:
3610 vpush64(VT_DOUBLE, 0x7ff8000000000000ULL);
3611 next();
3612 break;
3613 case TOK___SNAN__:
3614 vpush64(VT_DOUBLE, 0x7ff0000000000001ULL);
3615 next();
3616 break;
3617 case TOK___INF__:
3618 vpush64(VT_DOUBLE, 0x7ff0000000000000ULL);
3619 next();
3620 break;
3621
3622 default:
3623 tok_identifier:
3624 t = tok;
3625 next();
3626 if (t < TOK_UIDENT)
3627 expect("identifier");
3628 s = sym_find(t);
3629 if (!s) {
3630 if (tok != '(')
3631 error("'%s' undeclared", get_tok_str(t, NULL));
3632 /* for simple function calls, we tolerate undeclared
3633 external reference to int() function */
3634 if (tcc_state->warn_implicit_function_declaration)
3635 warning("implicit declaration of function '%s'",
3636 get_tok_str(t, NULL));
3637 s = external_global_sym(t, &func_old_type, 0);
3638 }
3639 if ((s->type.t & (VT_STATIC | VT_INLINE | VT_BTYPE)) ==
3640 (VT_STATIC | VT_INLINE | VT_FUNC)) {
3641 /* if referencing an inline function, then we generate a
3642 symbol to it if not already done. It will have the
3643 effect to generate code for it at the end of the
3644 compilation unit. Inline function as always
3645 generated in the text section. */
3646 if (!s->c)
3647 put_extern_sym(s, text_section, 0, 0);
3648 r = VT_SYM | VT_CONST;
3649 } else {
3650 r = s->r;
3651 }
3652 vset(&s->type, r, s->c);
3653 /* if forward reference, we must point to s */
3654 if (vtop->r & VT_SYM) {
3655 vtop->sym = s;
3656 vtop->c.ul = 0;
3657 }
3658 break;
3659 }
3660
3661 /* post operations */
3662 while (1) {
3663 if (tok == TOK_INC || tok == TOK_DEC) {
3664 inc(1, tok);
3665 next();
3666 } else if (tok == '.' || tok == TOK_ARROW) {
3667 int qualifiers;
3668 /* field */
3669 if (tok == TOK_ARROW)
3670 indir();
3671 qualifiers = vtop->type.t & (VT_CONSTANT | VT_VOLATILE);
3672 test_lvalue();
3673 gaddrof();
3674 next();
3675 /* expect pointer on structure */
3676 if ((vtop->type.t & VT_BTYPE) != VT_STRUCT)
3677 expect("struct or union");
3678 s = vtop->type.ref;
3679 /* find field */
3680 tok |= SYM_FIELD;
3681 while ((s = s->next) != NULL) {
3682 if (s->v == tok)
3683 break;
3684 }
3685 if (!s)
3686 error("field not found: %s", get_tok_str(tok & ~SYM_FIELD, NULL));
3687 /* add field offset to pointer */
3688 vtop->type = char_pointer_type; /* change type to 'char *' */
3689 vpushi(s->c);
3690 gen_op('+');
3691 /* change type to field type, and set to lvalue */
3692 vtop->type = s->type;
3693 vtop->type.t |= qualifiers;
3694 /* an array is never an lvalue */
3695 if (!(vtop->type.t & VT_ARRAY)) {
3696 vtop->r |= lvalue_type(vtop->type.t);
3697 #ifdef CONFIG_TCC_BCHECK
3698 /* if bound checking, the referenced pointer must be checked */
3699 if (tcc_state->do_bounds_check)
3700 vtop->r |= VT_MUSTBOUND;
3701 #endif
3702 }
3703 next();
3704 } else if (tok == '[') {
3705 next();
3706 gexpr();
3707 gen_op('+');
3708 indir();
3709 skip(']');
3710 } else if (tok == '(') {
3711 SValue ret;
3712 Sym *sa;
3713 int nb_args;
3714
3715 /* function call */
3716 if ((vtop->type.t & VT_BTYPE) != VT_FUNC) {
3717 /* pointer test (no array accepted) */
3718 if ((vtop->type.t & (VT_BTYPE | VT_ARRAY)) == VT_PTR) {
3719 vtop->type = *pointed_type(&vtop->type);
3720 if ((vtop->type.t & VT_BTYPE) != VT_FUNC)
3721 goto error_func;
3722 } else {
3723 error_func:
3724 expect("function pointer");
3725 }
3726 } else {
3727 vtop->r &= ~VT_LVAL; /* no lvalue */
3728 }
3729 /* get return type */
3730 s = vtop->type.ref;
3731 next();
3732 sa = s->next; /* first parameter */
3733 nb_args = 0;
3734 ret.r2 = VT_CONST;
3735 /* compute first implicit argument if a structure is returned */
3736 if ((s->type.t & VT_BTYPE) == VT_STRUCT) {
3737 /* get some space for the returned structure */
3738 size = type_size(&s->type, &align);
3739 loc = (loc - size) & -align;
3740 ret.type = s->type;
3741 ret.r = VT_LOCAL | VT_LVAL;
3742 /* pass it as 'int' to avoid structure arg passing
3743 problems */
3744 vseti(VT_LOCAL, loc);
3745 ret.c = vtop->c;
3746 nb_args++;
3747 } else {
3748 ret.type = s->type;
3749 /* return in register */
3750 if (is_float(ret.type.t)) {
3751 ret.r = reg_fret(ret.type.t);
3752 } else {
3753 if ((ret.type.t & VT_BTYPE) == VT_LLONG)
3754 ret.r2 = REG_LRET;
3755 ret.r = REG_IRET;
3756 }
3757 ret.c.i = 0;
3758 }
3759 if (tok != ')') {
3760 for(;;) {
3761 expr_eq();
3762 gfunc_param_typed(s, sa);
3763 nb_args++;
3764 if (sa)
3765 sa = sa->next;
3766 if (tok == ')')
3767 break;
3768 skip(',');
3769 }
3770 }
3771 if (sa)
3772 error("too few arguments to function");
3773 skip(')');
3774 if (!nocode_wanted) {
3775 gfunc_call(nb_args);
3776 } else {
3777 vtop -= (nb_args + 1);
3778 }
3779 /* return value */
3780 vsetc(&ret.type, ret.r, &ret.c);
3781 vtop->r2 = ret.r2;
3782 } else {
3783 break;
3784 }
3785 }
3786 }
3787
3788 ST_FUNC void expr_prod(void)
3789 {
3790 int t;
3791
3792 unary();
3793 while (tok == '*' || tok == '/' || tok == '%') {
3794 t = tok;
3795 next();
3796 unary();
3797 gen_op(t);
3798 }
3799 }
3800
3801 ST_FUNC void expr_sum(void)
3802 {
3803 int t;
3804
3805 expr_prod();
3806 while (tok == '+' || tok == '-') {
3807 t = tok;
3808 next();
3809 expr_prod();
3810 gen_op(t);
3811 }
3812 }
3813
3814 static void expr_shift(void)
3815 {
3816 int t;
3817
3818 expr_sum();
3819 while (tok == TOK_SHL || tok == TOK_SAR) {
3820 t = tok;
3821 next();
3822 expr_sum();
3823 gen_op(t);
3824 }
3825 }
3826
3827 static void expr_cmp(void)
3828 {
3829 int t;
3830
3831 expr_shift();
3832 while ((tok >= TOK_ULE && tok <= TOK_GT) ||
3833 tok == TOK_ULT || tok == TOK_UGE) {
3834 t = tok;
3835 next();
3836 expr_shift();
3837 gen_op(t);
3838 }
3839 }
3840
3841 static void expr_cmpeq(void)
3842 {
3843 int t;
3844
3845 expr_cmp();
3846 while (tok == TOK_EQ || tok == TOK_NE) {
3847 t = tok;
3848 next();
3849 expr_cmp();
3850 gen_op(t);
3851 }
3852 }
3853
3854 static void expr_and(void)
3855 {
3856 expr_cmpeq();
3857 while (tok == '&') {
3858 next();
3859 expr_cmpeq();
3860 gen_op('&');
3861 }
3862 }
3863
3864 static void expr_xor(void)
3865 {
3866 expr_and();
3867 while (tok == '^') {
3868 next();
3869 expr_and();
3870 gen_op('^');
3871 }
3872 }
3873
3874 static void expr_or(void)
3875 {
3876 expr_xor();
3877 while (tok == '|') {
3878 next();
3879 expr_xor();
3880 gen_op('|');
3881 }
3882 }
3883
3884 /* XXX: fix this mess */
3885 static void expr_land_const(void)
3886 {
3887 expr_or();
3888 while (tok == TOK_LAND) {
3889 next();
3890 expr_or();
3891 gen_op(TOK_LAND);
3892 }
3893 }
3894
3895 /* XXX: fix this mess */
3896 static void expr_lor_const(void)
3897 {
3898 expr_land_const();
3899 while (tok == TOK_LOR) {
3900 next();
3901 expr_land_const();
3902 gen_op(TOK_LOR);
3903 }
3904 }
3905
3906 /* only used if non constant */
3907 static void expr_land(void)
3908 {
3909 int t;
3910
3911 expr_or();
3912 if (tok == TOK_LAND) {
3913 t = 0;
3914 save_regs(1);
3915 for(;;) {
3916 t = gtst(1, t);
3917 if (tok != TOK_LAND) {
3918 vseti(VT_JMPI, t);
3919 break;
3920 }
3921 next();
3922 expr_or();
3923 }
3924 }
3925 }
3926
3927 static void expr_lor(void)
3928 {
3929 int t;
3930
3931 expr_land();
3932 if (tok == TOK_LOR) {
3933 t = 0;
3934 save_regs(1);
3935 for(;;) {
3936 t = gtst(0, t);
3937 if (tok != TOK_LOR) {
3938 vseti(VT_JMP, t);
3939 break;
3940 }
3941 next();
3942 expr_land();
3943 }
3944 }
3945 }
3946
3947 /* XXX: better constant handling */
3948 static void expr_cond(void)
3949 {
3950 int tt, u, r1, r2, rc, t1, t2, bt1, bt2;
3951 SValue sv;
3952 CType type, type1, type2;
3953
3954 if (const_wanted) {
3955 expr_lor_const();
3956 if (tok == '?') {
3957 CType boolean;
3958 int c;
3959 boolean.t = VT_BOOL;
3960 vdup();
3961 gen_cast(&boolean);
3962 c = vtop->c.i;
3963 vpop();
3964 next();
3965 if (tok != ':' || !gnu_ext) {
3966 vpop();
3967 gexpr();
3968 }
3969 if (!c)
3970 vpop();
3971 skip(':');
3972 expr_cond();
3973 if (c)
3974 vpop();
3975 }
3976 } else {
3977 expr_lor();
3978 if (tok == '?') {
3979 next();
3980 if (vtop != vstack) {
3981 /* needed to avoid having different registers saved in
3982 each branch */
3983 if (is_float(vtop->type.t)) {
3984 rc = RC_FLOAT;
3985 #ifdef TCC_TARGET_X86_64
3986 if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE) {
3987 rc = RC_ST0;
3988 }
3989 #endif
3990 }
3991 else
3992 rc = RC_INT;
3993 gv(rc);
3994 save_regs(1);
3995 }
3996 if (tok == ':' && gnu_ext) {
3997 gv_dup();
3998 tt = gtst(1, 0);
3999 } else {
4000 tt = gtst(1, 0);
4001 gexpr();
4002 }
4003 type1 = vtop->type;
4004 sv = *vtop; /* save value to handle it later */
4005 vtop--; /* no vpop so that FP stack is not flushed */
4006 skip(':');
4007 u = gjmp(0);
4008 gsym(tt);
4009 expr_cond();
4010 type2 = vtop->type;
4011
4012 t1 = type1.t;
4013 bt1 = t1 & VT_BTYPE;
4014 t2 = type2.t;
4015 bt2 = t2 & VT_BTYPE;
4016 /* cast operands to correct type according to ISOC rules */
4017 if (is_float(bt1) || is_float(bt2)) {
4018 if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) {
4019 type.t = VT_LDOUBLE;
4020 } else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) {
4021 type.t = VT_DOUBLE;
4022 } else {
4023 type.t = VT_FLOAT;
4024 }
4025 } else if (bt1 == VT_LLONG || bt2 == VT_LLONG) {
4026 /* cast to biggest op */
4027 type.t = VT_LLONG;
4028 /* convert to unsigned if it does not fit in a long long */
4029 if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED) ||
4030 (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED))
4031 type.t |= VT_UNSIGNED;
4032 } else if (bt1 == VT_PTR || bt2 == VT_PTR) {
4033 /* XXX: test pointer compatibility */
4034 type = type1;
4035 } else if (bt1 == VT_FUNC || bt2 == VT_FUNC) {
4036 /* XXX: test function pointer compatibility */
4037 type = type1;
4038 } else if (bt1 == VT_STRUCT || bt2 == VT_STRUCT) {
4039 /* XXX: test structure compatibility */
4040 type = type1;
4041 } else if (bt1 == VT_VOID || bt2 == VT_VOID) {
4042 /* NOTE: as an extension, we accept void on only one side */
4043 type.t = VT_VOID;
4044 } else {
4045 /* integer operations */
4046 type.t = VT_INT;
4047 /* convert to unsigned if it does not fit in an integer */
4048 if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED) ||
4049 (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED))
4050 type.t |= VT_UNSIGNED;
4051 }
4052
4053 /* now we convert second operand */
4054 gen_cast(&type);
4055 if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
4056 gaddrof();
4057 rc = RC_INT;
4058 if (is_float(type.t)) {
4059 rc = RC_FLOAT;
4060 #ifdef TCC_TARGET_X86_64
4061 if ((type.t & VT_BTYPE) == VT_LDOUBLE) {
4062 rc = RC_ST0;
4063 }
4064 #endif
4065 } else if ((type.t & VT_BTYPE) == VT_LLONG) {
4066 /* for long longs, we use fixed registers to avoid having
4067 to handle a complicated move */
4068 rc = RC_IRET;
4069 }
4070
4071 r2 = gv(rc);
4072 /* this is horrible, but we must also convert first
4073 operand */
4074 tt = gjmp(0);
4075 gsym(u);
4076 /* put again first value and cast it */
4077 *vtop = sv;
4078 gen_cast(&type);
4079 if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
4080 gaddrof();
4081 r1 = gv(rc);
4082 move_reg(r2, r1);
4083 vtop->r = r2;
4084 gsym(tt);
4085 }
4086 }
4087 }
4088
4089 static void expr_eq(void)
4090 {
4091 int t;
4092
4093 expr_cond();
4094 if (tok == '=' ||
4095 (tok >= TOK_A_MOD && tok <= TOK_A_DIV) ||
4096 tok == TOK_A_XOR || tok == TOK_A_OR ||
4097 tok == TOK_A_SHL || tok == TOK_A_SAR) {
4098 test_lvalue();
4099 t = tok;
4100 next();
4101 if (t == '=') {
4102 expr_eq();
4103 } else {
4104 vdup();
4105 expr_eq();
4106 gen_op(t & 0x7f);
4107 }
4108 vstore();
4109 }
4110 }
4111
4112 ST_FUNC void gexpr(void)
4113 {
4114 while (1) {
4115 expr_eq();
4116 if (tok != ',')
4117 break;
4118 vpop();
4119 next();
4120 }
4121 }
4122
4123 /* parse an expression and return its type without any side effect. */
4124 static void expr_type(CType *type)
4125 {
4126 int saved_nocode_wanted;
4127
4128 saved_nocode_wanted = nocode_wanted;
4129 nocode_wanted = 1;
4130 gexpr();
4131 *type = vtop->type;
4132 vpop();
4133 nocode_wanted = saved_nocode_wanted;
4134 }
4135
4136 /* parse a unary expression and return its type without any side
4137 effect. */
4138 static void unary_type(CType *type)
4139 {
4140 int a;
4141
4142 a = nocode_wanted;
4143 nocode_wanted = 1;
4144 unary();
4145 *type = vtop->type;
4146 vpop();
4147 nocode_wanted = a;
4148 }
4149
4150 /* parse a constant expression and return value in vtop. */
4151 static void expr_const1(void)
4152 {
4153 int a;
4154 a = const_wanted;
4155 const_wanted = 1;
4156 expr_cond();
4157 const_wanted = a;
4158 }
4159
4160 /* parse an integer constant and return its value. */
4161 ST_FUNC int expr_const(void)
4162 {
4163 int c;
4164 expr_const1();
4165 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
4166 expect("constant expression");
4167 c = vtop->c.i;
4168 vpop();
4169 return c;
4170 }
4171
4172 /* return the label token if current token is a label, otherwise
4173 return zero */
4174 static int is_label(void)
4175 {
4176 int last_tok;
4177
4178 /* fast test first */
4179 if (tok < TOK_UIDENT)
4180 return 0;
4181 /* no need to save tokc because tok is an identifier */
4182 last_tok = tok;
4183 next();
4184 if (tok == ':') {
4185 next();
4186 return last_tok;
4187 } else {
4188 unget_tok(last_tok);
4189 return 0;
4190 }
4191 }
4192
4193 static void block(int *bsym, int *csym, int *case_sym, int *def_sym,
4194 int case_reg, int is_expr)
4195 {
4196 int a, b, c, d;
4197 Sym *s;
4198
4199 /* generate line number info */
4200 if (tcc_state->do_debug &&
4201 (last_line_num != file->line_num || last_ind != ind)) {
4202 put_stabn(N_SLINE, 0, file->line_num, ind - func_ind);
4203 last_ind = ind;
4204 last_line_num = file->line_num;
4205 }
4206
4207 if (is_expr) {
4208 /* default return value is (void) */
4209 vpushi(0);
4210 vtop->type.t = VT_VOID;
4211 }
4212
4213 if (tok == TOK_IF) {
4214 /* if test */
4215 next();
4216 skip('(');
4217 gexpr();
4218 skip(')');
4219 a = gtst(1, 0);
4220 block(bsym, csym, case_sym, def_sym, case_reg, 0);
4221 c = tok;
4222 if (c == TOK_ELSE) {
4223 next();
4224 d = gjmp(0);
4225 gsym(a);
4226 block(bsym, csym, case_sym, def_sym, case_reg, 0);
4227 gsym(d); /* patch else jmp */
4228 } else
4229 gsym(a);
4230 } else if (tok == TOK_WHILE) {
4231 next();
4232 d = ind;
4233 skip('(');
4234 gexpr();
4235 skip(')');
4236 a = gtst(1, 0);
4237 b = 0;
4238 block(&a, &b, case_sym, def_sym, case_reg, 0);
4239 gjmp_addr(d);
4240 gsym(a);
4241 gsym_addr(b, d);
4242 } else if (tok == '{') {
4243 Sym *llabel;
4244
4245 next();
4246 /* record local declaration stack position */
4247 s = local_stack;
4248 llabel = local_label_stack;
4249 /* handle local labels declarations */
4250 if (tok == TOK_LABEL) {
4251 next();
4252 for(;;) {
4253 if (tok < TOK_UIDENT)
4254 expect("label identifier");
4255 label_push(&local_label_stack, tok, LABEL_DECLARED);
4256 next();
4257 if (tok == ',') {
4258 next();
4259 } else {
4260 skip(';');
4261 break;
4262 }
4263 }
4264 }
4265 while (tok != '}') {
4266 decl(VT_LOCAL);
4267 if (tok != '}') {
4268 if (is_expr)
4269 vpop();
4270 block(bsym, csym, case_sym, def_sym, case_reg, is_expr);
4271 }
4272 }
4273 /* pop locally defined labels */
4274 label_pop(&local_label_stack, llabel);
4275 /* pop locally defined symbols */
4276 if(is_expr) {
4277 /* XXX: this solution makes only valgrind happy...
4278 triggered by gcc.c-torture/execute/20000917-1.c */
4279 Sym *p;
4280 switch(vtop->type.t & VT_BTYPE) {
4281 case VT_PTR:
4282 case VT_STRUCT:
4283 case VT_ENUM:
4284 case VT_FUNC:
4285 for(p=vtop->type.ref;p;p=p->prev)
4286 if(p->prev==s)
4287 error("unsupported expression type");
4288 }
4289 }
4290 sym_pop(&local_stack, s);
4291 next();
4292 } else if (tok == TOK_RETURN) {
4293 next();
4294 if (tok != ';') {
4295 gexpr();
4296 gen_assign_cast(&func_vt);
4297 if ((func_vt.t & VT_BTYPE) == VT_STRUCT) {
4298 CType type;
4299 /* if returning structure, must copy it to implicit
4300 first pointer arg location */
4301 #ifdef TCC_ARM_EABI
4302 int align, size;
4303 size = type_size(&func_vt,&align);
4304 if(size <= 4)
4305 {
4306 if((vtop->r != (VT_LOCAL | VT_LVAL) || (vtop->c.i & 3))
4307 && (align & 3))
4308 {
4309 int addr;
4310 loc = (loc - size) & -4;
4311 addr = loc;
4312 type = func_vt;
4313 vset(&type, VT_LOCAL | VT_LVAL, addr);
4314 vswap();
4315 vstore();
4316 vset(&int_type, VT_LOCAL | VT_LVAL, addr);
4317 }
4318 vtop->type = int_type;
4319 gv(RC_IRET);
4320 } else {
4321 #endif
4322 type = func_vt;
4323 mk_pointer(&type);
4324 vset(&type, VT_LOCAL | VT_LVAL, func_vc);
4325 indir();
4326 vswap();
4327 /* copy structure value to pointer */
4328 vstore();
4329 #ifdef TCC_ARM_EABI
4330 }
4331 #endif
4332 } else if (is_float(func_vt.t)) {
4333 gv(rc_fret(func_vt.t));
4334 } else {
4335 gv(RC_IRET);
4336 }
4337 vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
4338 }
4339 skip(';');
4340 rsym = gjmp(rsym); /* jmp */
4341 } else if (tok == TOK_BREAK) {
4342 /* compute jump */
4343 if (!bsym)
4344 error("cannot break");
4345 *bsym = gjmp(*bsym);
4346 next();
4347 skip(';');
4348 } else if (tok == TOK_CONTINUE) {
4349 /* compute jump */
4350 if (!csym)
4351 error("cannot continue");
4352 *csym = gjmp(*csym);
4353 next();
4354 skip(';');
4355 } else if (tok == TOK_FOR) {
4356 int e;
4357 next();
4358 skip('(');
4359 if (tok != ';') {
4360 gexpr();
4361 vpop();
4362 }
4363 skip(';');
4364 d = ind;
4365 c = ind;
4366 a = 0;
4367 b = 0;
4368 if (tok != ';') {
4369 gexpr();
4370 a = gtst(1, 0);
4371 }
4372 skip(';');
4373 if (tok != ')') {
4374 e = gjmp(0);
4375 c = ind;
4376 gexpr();
4377 vpop();
4378 gjmp_addr(d);
4379 gsym(e);
4380 }
4381 skip(')');
4382 block(&a, &b, case_sym, def_sym, case_reg, 0);
4383 gjmp_addr(c);
4384 gsym(a);
4385 gsym_addr(b, c);
4386 } else
4387 if (tok == TOK_DO) {
4388 next();
4389 a = 0;
4390 b = 0;
4391 d = ind;
4392 block(&a, &b, case_sym, def_sym, case_reg, 0);
4393 skip(TOK_WHILE);
4394 skip('(');
4395 gsym(b);
4396 gexpr();
4397 c = gtst(0, 0);
4398 gsym_addr(c, d);
4399 skip(')');
4400 gsym(a);
4401 skip(';');
4402 } else
4403 if (tok == TOK_SWITCH) {
4404 next();
4405 skip('(');
4406 gexpr();
4407 /* XXX: other types than integer */
4408 case_reg = gv(RC_INT);
4409 vpop();
4410 skip(')');
4411 a = 0;
4412 b = gjmp(0); /* jump to first case */
4413 c = 0;
4414 block(&a, csym, &b, &c, case_reg, 0);
4415 /* if no default, jmp after switch */
4416 if (c == 0)
4417 c = ind;
4418 /* default label */
4419 gsym_addr(b, c);
4420 /* break label */
4421 gsym(a);
4422 } else
4423 if (tok == TOK_CASE) {
4424 int v1, v2;
4425 if (!case_sym)
4426 expect("switch");
4427 next();
4428 v1 = expr_const();
4429 v2 = v1;
4430 if (gnu_ext && tok == TOK_DOTS) {
4431 next();
4432 v2 = expr_const();
4433 if (v2 < v1)
4434 warning("empty case range");
4435 }
4436 /* since a case is like a label, we must skip it with a jmp */
4437 b = gjmp(0);
4438 gsym(*case_sym);
4439 vseti(case_reg, 0);
4440 vpushi(v1);
4441 if (v1 == v2) {
4442 gen_op(TOK_EQ);
4443 *case_sym = gtst(1, 0);
4444 } else {
4445 gen_op(TOK_GE);
4446 *case_sym = gtst(1, 0);
4447 vseti(case_reg, 0);
4448 vpushi(v2);
4449 gen_op(TOK_LE);
4450 *case_sym = gtst(1, *case_sym);
4451 }
4452 gsym(b);
4453 skip(':');
4454 is_expr = 0;
4455 goto block_after_label;
4456 } else
4457 if (tok == TOK_DEFAULT) {
4458 next();
4459 skip(':');
4460 if (!def_sym)
4461 expect("switch");
4462 if (*def_sym)
4463 error("too many 'default'");
4464 *def_sym = ind;
4465 is_expr = 0;
4466 goto block_after_label;
4467 } else
4468 if (tok == TOK_GOTO) {
4469 next();
4470 if (tok == '*' && gnu_ext) {
4471 /* computed goto */
4472 next();
4473 gexpr();
4474 if ((vtop->type.t & VT_BTYPE) != VT_PTR)
4475 expect("pointer");
4476 ggoto();
4477 } else if (tok >= TOK_UIDENT) {
4478 s = label_find(tok);
4479 /* put forward definition if needed */
4480 if (!s) {
4481 s = label_push(&global_label_stack, tok, LABEL_FORWARD);
4482 } else {
4483 if (s->r == LABEL_DECLARED)
4484 s->r = LABEL_FORWARD;
4485 }
4486 /* label already defined */
4487 if (s->r & LABEL_FORWARD)
4488 s->jnext = gjmp(s->jnext);
4489 else
4490 gjmp_addr(s->jnext);
4491 next();
4492 } else {
4493 expect("label identifier");
4494 }
4495 skip(';');
4496 } else if (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3) {
4497 asm_instr();
4498 } else {
4499 b = is_label();
4500 if (b) {
4501 /* label case */
4502 s = label_find(b);
4503 if (s) {
4504 if (s->r == LABEL_DEFINED)
4505 error("duplicate label '%s'", get_tok_str(s->v, NULL));
4506 gsym(s->jnext);
4507 s->r = LABEL_DEFINED;
4508 } else {
4509 s = label_push(&global_label_stack, b, LABEL_DEFINED);
4510 }
4511 s->jnext = ind;
4512 /* we accept this, but it is a mistake */
4513 block_after_label:
4514 if (tok == '}') {
4515 warning("deprecated use of label at end of compound statement");
4516 } else {
4517 if (is_expr)
4518 vpop();
4519 block(bsym, csym, case_sym, def_sym, case_reg, is_expr);
4520 }
4521 } else {
4522 /* expression case */
4523 if (tok != ';') {
4524 if (is_expr) {
4525 vpop();
4526 gexpr();
4527 } else {
4528 gexpr();
4529 vpop();
4530 }
4531 }
4532 skip(';');
4533 }
4534 }
4535 }
4536
4537 /* t is the array or struct type. c is the array or struct
4538 address. cur_index/cur_field is the pointer to the current
4539 value. 'size_only' is true if only size info is needed (only used
4540 in arrays) */
4541 static void decl_designator(CType *type, Section *sec, unsigned long c,
4542 int *cur_index, Sym **cur_field,
4543 int size_only)
4544 {
4545 Sym *s, *f;
4546 int notfirst, index, index_last, align, l, nb_elems, elem_size;
4547 CType type1;
4548
4549 notfirst = 0;
4550 elem_size = 0;
4551 nb_elems = 1;
4552 if (gnu_ext && (l = is_label()) != 0)
4553 goto struct_field;
4554 while (tok == '[' || tok == '.') {
4555 if (tok == '[') {
4556 if (!(type->t & VT_ARRAY))
4557 expect("array type");
4558 s = type->ref;
4559 next();
4560 index = expr_const();
4561 if (index < 0 || (s->c >= 0 && index >= s->c))
4562 expect("invalid index");
4563 if (tok == TOK_DOTS && gnu_ext) {
4564 next();
4565 index_last = expr_const();
4566 if (index_last < 0 ||
4567 (s->c >= 0 && index_last >= s->c) ||
4568 index_last < index)
4569 expect("invalid index");
4570 } else {
4571 index_last = index;
4572 }
4573 skip(']');
4574 if (!notfirst)
4575 *cur_index = index_last;
4576 type = pointed_type(type);
4577 elem_size = type_size(type, &align);
4578 c += index * elem_size;
4579 /* NOTE: we only support ranges for last designator */
4580 nb_elems = index_last - index + 1;
4581 if (nb_elems != 1) {
4582 notfirst = 1;
4583 break;
4584 }
4585 } else {
4586 next();
4587 l = tok;
4588 next();
4589 struct_field:
4590 if ((type->t & VT_BTYPE) != VT_STRUCT)
4591 expect("struct/union type");
4592 s = type->ref;
4593 l |= SYM_FIELD;
4594 f = s->next;
4595 while (f) {
4596 if (f->v == l)
4597 break;
4598 f = f->next;
4599 }
4600 if (!f)
4601 expect("field");
4602 if (!notfirst)
4603 *cur_field = f;
4604 /* XXX: fix this mess by using explicit storage field */
4605 type1 = f->type;
4606 type1.t |= (type->t & ~VT_TYPE);
4607 type = &type1;
4608 c += f->c;
4609 }
4610 notfirst = 1;
4611 }
4612 if (notfirst) {
4613 if (tok == '=') {
4614 next();
4615 } else {
4616 if (!gnu_ext)
4617 expect("=");
4618 }
4619 } else {
4620 if (type->t & VT_ARRAY) {
4621 index = *cur_index;
4622 type = pointed_type(type);
4623 c += index * type_size(type, &align);
4624 } else {
4625 f = *cur_field;
4626 if (!f)
4627 error("too many field init");
4628 /* XXX: fix this mess by using explicit storage field */
4629 type1 = f->type;
4630 type1.t |= (type->t & ~VT_TYPE);
4631 type = &type1;
4632 c += f->c;
4633 }
4634 }
4635 decl_initializer(type, sec, c, 0, size_only);
4636
4637 /* XXX: make it more general */
4638 if (!size_only && nb_elems > 1) {
4639 unsigned long c_end;
4640 uint8_t *src, *dst;
4641 int i;
4642
4643 if (!sec)
4644 error("range init not supported yet for dynamic storage");
4645 c_end = c + nb_elems * elem_size;
4646 if (c_end > sec->data_allocated)
4647 section_realloc(sec, c_end);
4648 src = sec->data + c;
4649 dst = src;
4650 for(i = 1; i < nb_elems; i++) {
4651 dst += elem_size;
4652 memcpy(dst, src, elem_size);
4653 }
4654 }
4655 }
4656
4657 #define EXPR_VAL 0
4658 #define EXPR_CONST 1
4659 #define EXPR_ANY 2
4660
4661 /* store a value or an expression directly in global data or in local array */
4662 static void init_putv(CType *type, Section *sec, unsigned long c,
4663 int v, int expr_type)
4664 {
4665 int saved_global_expr, bt, bit_pos, bit_size;
4666 void *ptr;
4667 unsigned long long bit_mask;
4668 CType dtype;
4669
4670 switch(expr_type) {
4671 case EXPR_VAL:
4672 vpushi(v);
4673 break;
4674 case EXPR_CONST:
4675 /* compound literals must be allocated globally in this case */
4676 saved_global_expr = global_expr;
4677 global_expr = 1;
4678 expr_const1();
4679 global_expr = saved_global_expr;
4680 /* NOTE: symbols are accepted */
4681 if ((vtop->r & (VT_VALMASK | VT_LVAL)) != VT_CONST)
4682 error("initializer element is not constant");
4683 break;
4684 case EXPR_ANY:
4685 expr_eq();
4686 break;
4687 }
4688
4689 dtype = *type;
4690 dtype.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */
4691
4692 if (sec) {
4693 /* XXX: not portable */
4694 /* XXX: generate error if incorrect relocation */
4695 gen_assign_cast(&dtype);
4696 bt = type->t & VT_BTYPE;
4697 /* we'll write at most 12 bytes */
4698 if (c + 12 > sec->data_allocated) {
4699 section_realloc(sec, c + 12);
4700 }
4701 ptr = sec->data + c;
4702 /* XXX: make code faster ? */
4703 if (!(type->t & VT_BITFIELD)) {
4704 bit_pos = 0;
4705 bit_size = 32;
4706 bit_mask = -1LL;
4707 } else {
4708 bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f;
4709 bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
4710 bit_mask = (1LL << bit_size) - 1;
4711 }
4712 if ((vtop->r & VT_SYM) &&
4713 (bt == VT_BYTE ||
4714 bt == VT_SHORT ||
4715 bt == VT_DOUBLE ||
4716 bt == VT_LDOUBLE ||
4717 bt == VT_LLONG ||
4718 (bt == VT_INT && bit_size != 32)))
4719 error("initializer element is not computable at load time");
4720 switch(bt) {
4721 case VT_BOOL:
4722 vtop->c.i = (vtop->c.i != 0);
4723 case VT_BYTE:
4724 *(char *)ptr |= (vtop->c.i & bit_mask) << bit_pos;
4725 break;
4726 case VT_SHORT:
4727 *(short *)ptr |= (vtop->c.i & bit_mask) << bit_pos;
4728 break;
4729 case VT_DOUBLE:
4730 *(double *)ptr = vtop->c.d;
4731 break;
4732 case VT_LDOUBLE:
4733 *(long double *)ptr = vtop->c.ld;
4734 break;
4735 case VT_LLONG:
4736 *(long long *)ptr |= (vtop->c.ll & bit_mask) << bit_pos;
4737 break;
4738 default:
4739 if (vtop->r & VT_SYM) {
4740 greloc(sec, vtop->sym, c, R_DATA_PTR);
4741 }
4742 *(int *)ptr |= (vtop->c.i & bit_mask) << bit_pos;
4743 break;
4744 }
4745 vtop--;
4746 } else {
4747 vset(&dtype, VT_LOCAL|VT_LVAL, c);
4748 vswap();
4749 vstore();
4750 vpop();
4751 }
4752 }
4753
4754 /* put zeros for variable based init */
4755 static void init_putz(CType *t, Section *sec, unsigned long c, int size)
4756 {
4757 if (sec) {
4758 /* nothing to do because globals are already set to zero */
4759 } else {
4760 vpush_global_sym(&func_old_type, TOK_memset);
4761 vseti(VT_LOCAL, c);
4762 vpushi(0);
4763 vpushi(size);
4764 gfunc_call(3);
4765 }
4766 }
4767
4768 /* 't' contains the type and storage info. 'c' is the offset of the
4769 object in section 'sec'. If 'sec' is NULL, it means stack based
4770 allocation. 'first' is true if array '{' must be read (multi
4771 dimension implicit array init handling). 'size_only' is true if
4772 size only evaluation is wanted (only for arrays). */
4773 static void decl_initializer(CType *type, Section *sec, unsigned long c,
4774 int first, int size_only)
4775 {
4776 int index, array_length, n, no_oblock, nb, parlevel, parlevel1, i;
4777 int size1, align1, expr_type;
4778 Sym *s, *f;
4779 CType *t1;
4780
4781 if (type->t & VT_ARRAY) {
4782 s = type->ref;
4783 n = s->c;
4784 array_length = 0;
4785 t1 = pointed_type(type);
4786 size1 = type_size(t1, &align1);
4787
4788 no_oblock = 1;
4789 if ((first && tok != TOK_LSTR && tok != TOK_STR) ||
4790 tok == '{') {
4791 if (tok != '{')
4792 error("character array initializer must be a literal,"
4793 " optionally enclosed in braces");
4794 skip('{');
4795 no_oblock = 0;
4796 }
4797
4798 /* only parse strings here if correct type (otherwise: handle
4799 them as ((w)char *) expressions */
4800 if ((tok == TOK_LSTR &&
4801 #ifdef TCC_TARGET_PE
4802 (t1->t & VT_BTYPE) == VT_SHORT && (t1->t & VT_UNSIGNED)
4803 #else
4804 (t1->t & VT_BTYPE) == VT_INT
4805 #endif
4806 ) || (tok == TOK_STR && (t1->t & VT_BTYPE) == VT_BYTE)) {
4807 while (tok == TOK_STR || tok == TOK_LSTR) {
4808 int cstr_len, ch;
4809 CString *cstr;
4810
4811 cstr = tokc.cstr;
4812 /* compute maximum number of chars wanted */
4813 if (tok == TOK_STR)
4814 cstr_len = cstr->size;
4815 else
4816 cstr_len = cstr->size / sizeof(nwchar_t);
4817 cstr_len--;
4818 nb = cstr_len;
4819 if (n >= 0 && nb > (n - array_length))
4820 nb = n - array_length;
4821 if (!size_only) {
4822 if (cstr_len > nb)
4823 warning("initializer-string for array is too long");
4824 /* in order to go faster for common case (char
4825 string in global variable, we handle it
4826 specifically */
4827 if (sec && tok == TOK_STR && size1 == 1) {
4828 memcpy(sec->data + c + array_length, cstr->data, nb);
4829 } else {
4830 for(i=0;i<nb;i++) {
4831 if (tok == TOK_STR)
4832 ch = ((unsigned char *)cstr->data)[i];
4833 else
4834 ch = ((nwchar_t *)cstr->data)[i];
4835 init_putv(t1, sec, c + (array_length + i) * size1,
4836 ch, EXPR_VAL);
4837 }
4838 }
4839 }
4840 array_length += nb;
4841 next();
4842 }
4843 /* only add trailing zero if enough storage (no
4844 warning in this case since it is standard) */
4845 if (n < 0 || array_length < n) {
4846 if (!size_only) {
4847 init_putv(t1, sec, c + (array_length * size1), 0, EXPR_VAL);
4848 }
4849 array_length++;
4850 }
4851 } else {
4852 index = 0;
4853 if (ARRAY_RESIZE(s->r))
4854 n = -1;
4855 while (tok != '}') {
4856 decl_designator(type, sec, c, &index, NULL, size_only);
4857 if (n >= 0 && index >= n)
4858 error("index too large");
4859 /* must put zero in holes (note that doing it that way
4860 ensures that it even works with designators) */
4861 if (!size_only && array_length < index) {
4862 init_putz(t1, sec, c + array_length * size1,
4863 (index - array_length) * size1);
4864 }
4865 index++;
4866 if (index > array_length)
4867 array_length = index;
4868 /* special test for multi dimensional arrays (may not
4869 be strictly correct if designators are used at the
4870 same time) */
4871 if (index >= n && no_oblock)
4872 break;
4873 if (tok == '}')
4874 break;
4875 skip(',');
4876 }
4877 }
4878 if (!no_oblock)
4879 skip('}');
4880 /* put zeros at the end */
4881 if (!size_only && n >= 0 && array_length < n) {
4882 init_putz(t1, sec, c + array_length * size1,
4883 (n - array_length) * size1);
4884 }
4885 /* patch type size if needed */
4886 if (n < 0)
4887 s->c = array_length;
4888 } else if ((type->t & VT_BTYPE) == VT_STRUCT &&
4889 (sec || !first || tok == '{')) {
4890 int par_count;
4891
4892 /* NOTE: the previous test is a specific case for automatic
4893 struct/union init */
4894 /* XXX: union needs only one init */
4895
4896 /* XXX: this test is incorrect for local initializers
4897 beginning with ( without {. It would be much more difficult
4898 to do it correctly (ideally, the expression parser should
4899 be used in all cases) */
4900 par_count = 0;
4901 if (tok == '(') {
4902 AttributeDef ad1;
4903 CType type1;
4904 next();
4905 while (tok == '(') {
4906 par_count++;
4907 next();
4908 }
4909 if (!parse_btype(&type1, &ad1))
4910 expect("cast");
4911 type_decl(&type1, &ad1, &n, TYPE_ABSTRACT);
4912 #if 0
4913 if (!is_assignable_types(type, &type1))
4914 error("invalid type for cast");
4915 #endif
4916 skip(')');
4917 }
4918 no_oblock = 1;
4919 if (first || tok == '{') {
4920 skip('{');
4921 no_oblock = 0;
4922 }
4923 s = type->ref;
4924 f = s->next;
4925 array_length = 0;
4926 index = 0;
4927 n = s->c;
4928 if (s->r & (1<<31))
4929 n = -1;
4930 while (tok != '}') {
4931 decl_designator(type, sec, c, NULL, &f, size_only);
4932 index = f->c;
4933 if (!size_only && array_length < index) {
4934 init_putz(type, sec, c + array_length,
4935 index - array_length);
4936 }
4937 index = index + type_size(&f->type, &align1);
4938 if (index > array_length)
4939 array_length = index;
4940
4941 /* gr: skip fields from same union - ugly. */
4942 while (f->next) {
4943 ///printf("index: %2d %08x -- %2d %08x\n", f->c, f->type.t, f->next->c, f->next->type.t);
4944 /* test for same offset */
4945 if (f->next->c != f->c)
4946 break;
4947 /* if yes, test for bitfield shift */
4948 if ((f->type.t & VT_BITFIELD) && (f->next->type.t & VT_BITFIELD)) {
4949 int bit_pos_1 = (f->type.t >> VT_STRUCT_SHIFT) & 0x3f;
4950 int bit_pos_2 = (f->next->type.t >> VT_STRUCT_SHIFT) & 0x3f;
4951 //printf("bitfield %d %d\n", bit_pos_1, bit_pos_2);
4952 if (bit_pos_1 != bit_pos_2)
4953 break;
4954 }
4955 f = f->next;
4956 }
4957
4958 f = f->next;
4959 if (no_oblock && f == NULL)
4960 break;
4961 if (tok == '}')
4962 break;
4963 skip(',');
4964 }
4965 /* put zeros at the end */
4966 if (!size_only && n >= 0 && array_length < n) {
4967 init_putz(type, sec, c + array_length,
4968 n - array_length);
4969 }
4970 if (!no_oblock)
4971 skip('}');
4972 while (par_count) {
4973 skip(')');
4974 par_count--;
4975 }
4976 if (n < 0)
4977 s->c = array_length;
4978 } else if (tok == '{') {
4979 next();
4980 decl_initializer(type, sec, c, first, size_only);
4981 skip('}');
4982 } else if (size_only) {
4983 /* just skip expression */
4984 parlevel = parlevel1 = 0;
4985 while ((parlevel > 0 || parlevel1 > 0 ||
4986 (tok != '}' && tok != ',')) && tok != -1) {
4987 if (tok == '(')
4988 parlevel++;
4989 else if (tok == ')')
4990 parlevel--;
4991 else if (tok == '{')
4992 parlevel1++;
4993 else if (tok == '}')
4994 parlevel1--;
4995 next();
4996 }
4997 } else {
4998 /* currently, we always use constant expression for globals
4999 (may change for scripting case) */
5000 expr_type = EXPR_CONST;
5001 if (!sec)
5002 expr_type = EXPR_ANY;
5003 init_putv(type, sec, c, 0, expr_type);
5004 }
5005 }
5006
5007 /* parse an initializer for type 't' if 'has_init' is non zero, and
5008 allocate space in local or global data space ('r' is either
5009 VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
5010 variable 'v' with an associated name represented by 'asm_label' of
5011 scope 'scope' is declared before initializers are parsed. If 'v' is
5012 zero, then a reference to the new object is put in the value stack.
5013 If 'has_init' is 2, a special parsing is done to handle string
5014 constants. */
5015 static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
5016 int has_init, int v, char *asm_label,
5017 int scope)
5018 {
5019 int size, align, addr, data_offset;
5020 int level;
5021 ParseState saved_parse_state = {0};
5022 TokenString init_str;
5023 Section *sec;
5024
5025 /* resize the struct */
5026 if ((type->t & VT_BTYPE) == VT_STRUCT && (type->ref->r & (1<<31)) != 0)
5027 type->ref->c = -1;
5028 size = type_size(type, &align);
5029 /* If unknown size, we must evaluate it before
5030 evaluating initializers because
5031 initializers can generate global data too
5032 (e.g. string pointers or ISOC99 compound
5033 literals). It also simplifies local
5034 initializers handling */
5035 tok_str_new(&init_str);
5036 if (size < 0) {
5037 if (!has_init)
5038 error("unknown type size");
5039 /* get all init string */
5040 if (has_init == 2) {
5041 /* only get strings */
5042 while (tok == TOK_STR || tok == TOK_LSTR) {
5043 tok_str_add_tok(&init_str);
5044 next();
5045 }
5046 } else {
5047 level = 0;
5048 while (level > 0 || (tok != ',' && tok != ';')) {
5049 if (tok < 0)
5050 error("unexpected end of file in initializer");
5051 tok_str_add_tok(&init_str);
5052 if (tok == '{')
5053 level++;
5054 else if (tok == '}') {
5055 level--;
5056 if (level <= 0) {
5057 next();
5058 break;
5059 }
5060 }
5061 next();
5062 }
5063 }
5064 tok_str_add(&init_str, -1);
5065 tok_str_add(&init_str, 0);
5066
5067 /* compute size */
5068 save_parse_state(&saved_parse_state);
5069
5070 macro_ptr = init_str.str;
5071 next();
5072 decl_initializer(type, NULL, 0, 1, 1);
5073 /* prepare second initializer parsing */
5074 macro_ptr = init_str.str;
5075 next();
5076
5077 /* if still unknown size, error */
5078 size = type_size(type, &align);
5079 if (size < 0)
5080 error("unknown type size");
5081 }
5082 /* take into account specified alignment if bigger */
5083 if (ad->aligned) {
5084 if (ad->aligned > align)
5085 align = ad->aligned;
5086 } else if (ad->packed) {
5087 align = 1;
5088 }
5089 if ((r & VT_VALMASK) == VT_LOCAL) {
5090 sec = NULL;
5091 #ifdef CONFIG_TCC_BCHECK
5092 if (tcc_state->do_bounds_check && (type->t & VT_ARRAY))
5093 loc--;
5094 #endif
5095 loc = (loc - size) & -align;
5096 addr = loc;
5097 #ifdef CONFIG_TCC_BCHECK
5098 /* handles bounds */
5099 /* XXX: currently, since we do only one pass, we cannot track
5100 '&' operators, so we add only arrays */
5101 if (tcc_state->do_bounds_check && (type->t & VT_ARRAY)) {
5102 unsigned long *bounds_ptr;
5103 /* add padding between regions */
5104 loc--;
5105 /* then add local bound info */
5106 bounds_ptr = section_ptr_add(lbounds_section, 2 * sizeof(unsigned long));
5107 bounds_ptr[0] = addr;
5108 bounds_ptr[1] = size;
5109 }
5110 #endif
5111 if (v) {
5112 /* local variable */
5113 sym_push(v, type, r, addr);
5114 } else {
5115 /* push local reference */
5116 vset(type, r, addr);
5117 }
5118 } else {
5119 Sym *sym;
5120
5121 sym = NULL;
5122 if (v && scope == VT_CONST) {
5123 /* see if the symbol was already defined */
5124 sym = sym_find(v);
5125 if (sym) {
5126 if (!is_compatible_types(&sym->type, type))
5127 error("incompatible types for redefinition of '%s'",
5128 get_tok_str(v, NULL));
5129 if (sym->type.t & VT_EXTERN) {
5130 /* if the variable is extern, it was not allocated */
5131 sym->type.t &= ~VT_EXTERN;
5132 /* set array size if it was ommited in extern
5133 declaration */
5134 if ((sym->type.t & VT_ARRAY) &&
5135 sym->type.ref->c < 0 &&
5136 type->ref->c >= 0)
5137 sym->type.ref->c = type->ref->c;
5138 } else {
5139 /* we accept several definitions of the same
5140 global variable. this is tricky, because we
5141 must play with the SHN_COMMON type of the symbol */
5142 /* XXX: should check if the variable was already
5143 initialized. It is incorrect to initialized it
5144 twice */
5145 /* no init data, we won't add more to the symbol */
5146 if (!has_init)
5147 goto no_alloc;
5148 }
5149 }
5150 }
5151
5152 /* allocate symbol in corresponding section */
5153 sec = ad->section;
5154 if (!sec) {
5155 if (has_init)
5156 sec = data_section;
5157 else if (tcc_state->nocommon)
5158 sec = bss_section;
5159 }
5160 if (sec) {
5161 data_offset = sec->data_offset;
5162 data_offset = (data_offset + align - 1) & -align;
5163 addr = data_offset;
5164 /* very important to increment global pointer at this time
5165 because initializers themselves can create new initializers */
5166 data_offset += size;
5167 #ifdef CONFIG_TCC_BCHECK
5168 /* add padding if bound check */
5169 if (tcc_state->do_bounds_check)
5170 data_offset++;
5171 #endif
5172 sec->data_offset = data_offset;
5173 /* allocate section space to put the data */
5174 if (sec->sh_type != SHT_NOBITS &&
5175 data_offset > sec->data_allocated)
5176 section_realloc(sec, data_offset);
5177 /* align section if needed */
5178 if (align > sec->sh_addralign)
5179 sec->sh_addralign = align;
5180 } else {
5181 addr = 0; /* avoid warning */
5182 }
5183
5184 if (v) {
5185 if (scope != VT_CONST || !sym) {
5186 sym = sym_push(v, type, r | VT_SYM, 0);
5187 sym->asm_label = asm_label;
5188 }
5189 /* update symbol definition */
5190 if (sec) {
5191 put_extern_sym(sym, sec, addr, size);
5192 } else {
5193 ElfW(Sym) *esym;
5194 /* put a common area */
5195 put_extern_sym(sym, NULL, align, size);
5196 /* XXX: find a nicer way */
5197 esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
5198 esym->st_shndx = SHN_COMMON;
5199 }
5200 } else {
5201 CValue cval;
5202
5203 /* push global reference */
5204 sym = get_sym_ref(type, sec, addr, size);
5205 cval.ul = 0;
5206 vsetc(type, VT_CONST | VT_SYM, &cval);
5207 vtop->sym = sym;
5208 }
5209 /* patch symbol weakness */
5210 if (type->t & VT_WEAK) {
5211 unsigned char *st_info =
5212 &((ElfW(Sym) *)symtab_section->data)[sym->c].st_info;
5213 *st_info = ELF32_ST_INFO(STB_WEAK, ELF32_ST_TYPE(*st_info));
5214 }
5215 #ifdef CONFIG_TCC_BCHECK
5216 /* handles bounds now because the symbol must be defined
5217 before for the relocation */
5218 if (tcc_state->do_bounds_check) {
5219 unsigned long *bounds_ptr;
5220
5221 greloc(bounds_section, sym, bounds_section->data_offset, R_DATA_PTR);
5222 /* then add global bound info */
5223 bounds_ptr = section_ptr_add(bounds_section, 2 * sizeof(long));
5224 bounds_ptr[0] = 0; /* relocated */
5225 bounds_ptr[1] = size;
5226 }
5227 #endif
5228 }
5229 if (has_init) {
5230 decl_initializer(type, sec, addr, 1, 0);
5231 /* restore parse state if needed */
5232 if (init_str.str) {
5233 tok_str_free(init_str.str);
5234 restore_parse_state(&saved_parse_state);
5235 }
5236 }
5237 no_alloc: ;
5238 }
5239
5240 static void put_func_debug(Sym *sym)
5241 {
5242 char buf[512];
5243
5244 /* stabs info */
5245 /* XXX: we put here a dummy type */
5246 snprintf(buf, sizeof(buf), "%s:%c1",
5247 funcname, sym->type.t & VT_STATIC ? 'f' : 'F');
5248 put_stabs_r(buf, N_FUN, 0, file->line_num, 0,
5249 cur_text_section, sym->c);
5250 /* //gr gdb wants a line at the function */
5251 put_stabn(N_SLINE, 0, file->line_num, 0);
5252 last_ind = 0;
5253 last_line_num = 0;
5254 }
5255
5256 /* parse an old style function declaration list */
5257 /* XXX: check multiple parameter */
5258 static void func_decl_list(Sym *func_sym)
5259 {
5260 AttributeDef ad;
5261 int v;
5262 Sym *s;
5263 CType btype, type;
5264
5265 /* parse each declaration */
5266 while (tok != '{' && tok != ';' && tok != ',' && tok != TOK_EOF &&
5267 tok != TOK_ASM1 && tok != TOK_ASM2 && tok != TOK_ASM3) {
5268 if (!parse_btype(&btype, &ad))
5269 expect("declaration list");
5270 if (((btype.t & VT_BTYPE) == VT_ENUM ||
5271 (btype.t & VT_BTYPE) == VT_STRUCT) &&
5272 tok == ';') {
5273 /* we accept no variable after */
5274 } else {
5275 for(;;) {
5276 type = btype;
5277 type_decl(&type, &ad, &v, TYPE_DIRECT);
5278 /* find parameter in function parameter list */
5279 s = func_sym->next;
5280 while (s != NULL) {
5281 if ((s->v & ~SYM_FIELD) == v)
5282 goto found;
5283 s = s->next;
5284 }
5285 error("declaration for parameter '%s' but no such parameter",
5286 get_tok_str(v, NULL));
5287 found:
5288 /* check that no storage specifier except 'register' was given */
5289 if (type.t & VT_STORAGE)
5290 error("storage class specified for '%s'", get_tok_str(v, NULL));
5291 convert_parameter_type(&type);
5292 /* we can add the type (NOTE: it could be local to the function) */
5293 s->type = type;
5294 /* accept other parameters */
5295 if (tok == ',')
5296 next();
5297 else
5298 break;
5299 }
5300 }
5301 skip(';');
5302 }
5303 }
5304
5305 /* parse a function defined by symbol 'sym' and generate its code in
5306 'cur_text_section' */
5307 static void gen_function(Sym *sym)
5308 {
5309 int saved_nocode_wanted = nocode_wanted;
5310 nocode_wanted = 0;
5311 ind = cur_text_section->data_offset;
5312 /* NOTE: we patch the symbol size later */
5313 put_extern_sym(sym, cur_text_section, ind, 0);
5314 funcname = get_tok_str(sym->v, NULL);
5315 func_ind = ind;
5316 /* put debug symbol */
5317 if (tcc_state->do_debug)
5318 put_func_debug(sym);
5319 /* push a dummy symbol to enable local sym storage */
5320 sym_push2(&local_stack, SYM_FIELD, 0, 0);
5321 gfunc_prolog(&sym->type);
5322 rsym = 0;
5323 block(NULL, NULL, NULL, NULL, 0, 0);
5324 gsym(rsym);
5325 gfunc_epilog();
5326 cur_text_section->data_offset = ind;
5327 label_pop(&global_label_stack, NULL);
5328 sym_pop(&local_stack, NULL); /* reset local stack */
5329 /* end of function */
5330 /* patch symbol size */
5331 ((ElfW(Sym) *)symtab_section->data)[sym->c].st_size =
5332 ind - func_ind;
5333 /* patch symbol weakness (this definition overrules any prototype) */
5334 if (sym->type.t & VT_WEAK) {
5335 unsigned char *st_info =
5336 &((ElfW(Sym) *)symtab_section->data)[sym->c].st_info;
5337 *st_info = ELF32_ST_INFO(STB_WEAK, ELF32_ST_TYPE(*st_info));
5338 }
5339 if (tcc_state->do_debug) {
5340 put_stabn(N_FUN, 0, 0, ind - func_ind);
5341 }
5342 /* It's better to crash than to generate wrong code */
5343 cur_text_section = NULL;
5344 funcname = ""; /* for safety */
5345 func_vt.t = VT_VOID; /* for safety */
5346 ind = 0; /* for safety */
5347 nocode_wanted = saved_nocode_wanted;
5348 }
5349
5350 ST_FUNC void gen_inline_functions(void)
5351 {
5352 Sym *sym;
5353 int *str, inline_generated, i;
5354 struct InlineFunc *fn;
5355
5356 /* iterate while inline function are referenced */
5357 for(;;) {
5358 inline_generated = 0;
5359 for (i = 0; i < tcc_state->nb_inline_fns; ++i) {
5360 fn = tcc_state->inline_fns[i];
5361 sym = fn->sym;
5362 if (sym && sym->c) {
5363 /* the function was used: generate its code and
5364 convert it to a normal function */
5365 str = fn->token_str;
5366 fn->sym = NULL;
5367 if (file)
5368 strcpy(file->filename, fn->filename);
5369 sym->r = VT_SYM | VT_CONST;
5370 sym->type.t &= ~VT_INLINE;
5371
5372 macro_ptr = str;
5373 next();
5374 cur_text_section = text_section;
5375 gen_function(sym);
5376 macro_ptr = NULL; /* fail safe */
5377
5378 inline_generated = 1;
5379 }
5380 }
5381 if (!inline_generated)
5382 break;
5383 }
5384 for (i = 0; i < tcc_state->nb_inline_fns; ++i) {
5385 fn = tcc_state->inline_fns[i];
5386 str = fn->token_str;
5387 tok_str_free(str);
5388 }
5389 dynarray_reset(&tcc_state->inline_fns, &tcc_state->nb_inline_fns);
5390 }
5391
5392 /* 'l' is VT_LOCAL or VT_CONST to define default storage type */
5393 ST_FUNC void decl(int l)
5394 {
5395 int v, has_init, r;
5396 CType type, btype;
5397 Sym *sym;
5398 AttributeDef ad;
5399
5400 while (1) {
5401 if (!parse_btype(&btype, &ad)) {
5402 /* skip redundant ';' */
5403 /* XXX: find more elegant solution */
5404 if (tok == ';') {
5405 next();
5406 continue;
5407 }
5408 if (l == VT_CONST &&
5409 (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3)) {
5410 /* global asm block */
5411 asm_global_instr();
5412 continue;
5413 }
5414 /* special test for old K&R protos without explicit int
5415 type. Only accepted when defining global data */
5416 if (l == VT_LOCAL || tok < TOK_DEFINE)
5417 break;
5418 btype.t = VT_INT;
5419 }
5420 if (((btype.t & VT_BTYPE) == VT_ENUM ||
5421 (btype.t & VT_BTYPE) == VT_STRUCT) &&
5422 tok == ';') {
5423 /* we accept no variable after */
5424 next();
5425 continue;
5426 }
5427 while (1) { /* iterate thru each declaration */
5428 type = btype;
5429 type_decl(&type, &ad, &v, TYPE_DIRECT);
5430 #if 0
5431 {
5432 char buf[500];
5433 type_to_str(buf, sizeof(buf), t, get_tok_str(v, NULL));
5434 printf("type = '%s'\n", buf);
5435 }
5436 #endif
5437 if ((type.t & VT_BTYPE) == VT_FUNC) {
5438 if ((type.t & VT_STATIC) && (l == VT_LOCAL)) {
5439 error("function without file scope cannot be static");
5440 }
5441 /* if old style function prototype, we accept a
5442 declaration list */
5443 sym = type.ref;
5444 if (sym->c == FUNC_OLD)
5445 func_decl_list(sym);
5446 }
5447
5448 #ifdef TCC_TARGET_PE
5449 if (ad.func_import)
5450 type.t |= VT_IMPORT;
5451 if (ad.func_export)
5452 type.t |= VT_EXPORT;
5453 #endif
5454 if (tok == '{') {
5455 if (l == VT_LOCAL)
5456 error("cannot use local functions");
5457 if ((type.t & VT_BTYPE) != VT_FUNC)
5458 expect("function definition");
5459
5460 /* reject abstract declarators in function definition */
5461 sym = type.ref;
5462 while ((sym = sym->next) != NULL)
5463 if (!(sym->v & ~SYM_FIELD))
5464 expect("identifier");
5465
5466 /* XXX: cannot do better now: convert extern line to static inline */
5467 if ((type.t & (VT_EXTERN | VT_INLINE)) == (VT_EXTERN | VT_INLINE))
5468 type.t = (type.t & ~VT_EXTERN) | VT_STATIC;
5469
5470 sym = sym_find(v);
5471 if (sym) {
5472 if ((sym->type.t & VT_BTYPE) != VT_FUNC)
5473 goto func_error1;
5474
5475 r = sym->type.ref->r;
5476 /* use func_call from prototype if not defined */
5477 if (FUNC_CALL(r) != FUNC_CDECL
5478 && FUNC_CALL(type.ref->r) == FUNC_CDECL)
5479 FUNC_CALL(type.ref->r) = FUNC_CALL(r);
5480
5481 /* use export from prototype */
5482 if (FUNC_EXPORT(r))
5483 FUNC_EXPORT(type.ref->r) = 1;
5484
5485 /* use static from prototype */
5486 if (sym->type.t & VT_STATIC)
5487 type.t = (type.t & ~VT_EXTERN) | VT_STATIC;
5488
5489 if (!is_compatible_types(&sym->type, &type)) {
5490 func_error1:
5491 error("incompatible types for redefinition of '%s'",
5492 get_tok_str(v, NULL));
5493 }
5494 /* if symbol is already defined, then put complete type */
5495 sym->type = type;
5496 } else {
5497 /* put function symbol */
5498 sym = global_identifier_push(v, type.t, 0);
5499 sym->type.ref = type.ref;
5500 }
5501
5502 /* static inline functions are just recorded as a kind
5503 of macro. Their code will be emitted at the end of
5504 the compilation unit only if they are used */
5505 if ((type.t & (VT_INLINE | VT_STATIC)) ==
5506 (VT_INLINE | VT_STATIC)) {
5507 TokenString func_str;
5508 int block_level;
5509 struct InlineFunc *fn;
5510 const char *filename;
5511
5512 tok_str_new(&func_str);
5513
5514 block_level = 0;
5515 for(;;) {
5516 int t;
5517 if (tok == TOK_EOF)
5518 error("unexpected end of file");
5519 tok_str_add_tok(&func_str);
5520 t = tok;
5521 next();
5522 if (t == '{') {
5523 block_level++;
5524 } else if (t == '}') {
5525 block_level--;
5526 if (block_level == 0)
5527 break;
5528 }
5529 }
5530 tok_str_add(&func_str, -1);
5531 tok_str_add(&func_str, 0);
5532 filename = file ? file->filename : "";
5533 fn = tcc_malloc(sizeof *fn + strlen(filename));
5534 strcpy(fn->filename, filename);
5535 fn->sym = sym;
5536 fn->token_str = func_str.str;
5537 dynarray_add((void ***)&tcc_state->inline_fns, &tcc_state->nb_inline_fns, fn);
5538
5539 } else {
5540 /* compute text section */
5541 cur_text_section = ad.section;
5542 if (!cur_text_section)
5543 cur_text_section = text_section;
5544 sym->r = VT_SYM | VT_CONST;
5545 gen_function(sym);
5546 }
5547 break;
5548 } else {
5549 if (btype.t & VT_TYPEDEF) {
5550 /* save typedefed type */
5551 /* XXX: test storage specifiers ? */
5552 sym = sym_push(v, &type, INT_ATTR(&ad), 0);
5553 sym->type.t |= VT_TYPEDEF;
5554 } else if ((type.t & VT_BTYPE) == VT_FUNC) {
5555 char *asm_label; // associated asm label
5556 Sym *fn;
5557
5558 asm_label = NULL;
5559 /* external function definition */
5560 /* specific case for func_call attribute */
5561 type.ref->r = INT_ATTR(&ad);
5562
5563 if (gnu_ext && (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3)) {
5564 CString astr;
5565
5566 asm_label_instr(&astr);
5567 asm_label = tcc_strdup(astr.data);
5568 cstr_free(&astr);
5569 }
5570 fn = external_sym(v, &type, 0, asm_label);
5571 if (gnu_ext && (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2))
5572 parse_attribute((AttributeDef *) &fn->type.ref->r);
5573 } else {
5574 char *asm_label; // associated asm label
5575
5576 /* not lvalue if array */
5577 r = 0;
5578 asm_label = NULL;
5579 if (!(type.t & VT_ARRAY))
5580 r |= lvalue_type(type.t);
5581 if (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3) {
5582 CString astr;
5583
5584 asm_label_instr(&astr);
5585 asm_label = tcc_strdup(astr.data);
5586 cstr_free(&astr);
5587 }
5588 has_init = (tok == '=');
5589 if ((btype.t & VT_EXTERN) ||
5590 ((type.t & VT_ARRAY) && (type.t & VT_STATIC) &&
5591 !has_init && l == VT_CONST && type.ref->c < 0)) {
5592 /* external variable */
5593 /* NOTE: as GCC, uninitialized global static
5594 arrays of null size are considered as
5595 extern */
5596 external_sym(v, &type, r, asm_label);
5597 } else {
5598 type.t |= (btype.t & VT_STATIC); /* Retain "static". */
5599 if (type.t & VT_STATIC)
5600 r |= VT_CONST;
5601 else
5602 r |= l;
5603 if (has_init)
5604 next();
5605 decl_initializer_alloc(&type, &ad, r, has_init, v, asm_label, l);
5606 }
5607 }
5608 if (tok != ',') {
5609 skip(';');
5610 break;
5611 }
5612 next();
5613 }
5614 }
5615 }
5616 }
tinycc fork to help me test changes before commit to mob