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