2 * TCC - Tiny C Compiler
4 * Copyright (c) 2001-2004 Fabrice Bellard
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.
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.
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
21 void swap(int *p
, int *q
)
29 void vsetc(CType
*type
, int r
, CValue
*vc
)
33 if (vtop
>= vstack
+ (VSTACK_SIZE
- 1))
35 /* cannot let cpu flags if other instruction are generated. Also
36 avoid leaving VT_JMP anywhere except on the top of the stack
37 because it would complicate the code generator. */
39 v
= vtop
->r
& VT_VALMASK
;
40 if (v
== VT_CMP
|| (v
& ~1) == VT_JMP
)
50 /* push integer constant */
55 vsetc(&int_type
, VT_CONST
, &cval
);
58 /* push long long constant */
59 void vpushll(long long v
)
65 vsetc(&ctype
, VT_CONST
, &cval
);
68 /* Return a static symbol pointing to a section */
69 static Sym
*get_sym_ref(CType
*type
, Section
*sec
,
70 unsigned long offset
, unsigned long size
)
76 sym
= global_identifier_push(v
, type
->t
| VT_STATIC
, 0);
77 sym
->type
.ref
= type
->ref
;
78 sym
->r
= VT_CONST
| VT_SYM
;
79 put_extern_sym(sym
, sec
, offset
, size
);
83 /* push a reference to a section offset by adding a dummy symbol */
84 static void vpush_ref(CType
*type
, Section
*sec
, unsigned long offset
, unsigned long size
)
89 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
90 vtop
->sym
= get_sym_ref(type
, sec
, offset
, size
);
93 /* define a new external reference to a symbol 'v' of type 'u' */
94 static Sym
*external_global_sym(int v
, CType
*type
, int r
)
100 /* push forward reference */
101 s
= global_identifier_push(v
, type
->t
| VT_EXTERN
, 0);
102 s
->type
.ref
= type
->ref
;
103 s
->r
= r
| VT_CONST
| VT_SYM
;
108 /* define a new external reference to a symbol 'v' of type 'u' */
109 static Sym
*external_sym(int v
, CType
*type
, int r
)
115 /* push forward reference */
116 s
= sym_push(v
, type
, r
| VT_CONST
| VT_SYM
, 0);
117 s
->type
.t
|= VT_EXTERN
;
118 } else if (s
->type
.ref
== func_old_type
.ref
) {
119 s
->type
.ref
= type
->ref
;
120 s
->r
= r
| VT_CONST
| VT_SYM
;
121 s
->type
.t
|= VT_EXTERN
;
122 } else if (!is_compatible_types(&s
->type
, type
)) {
123 error("incompatible types for redefinition of '%s'",
124 get_tok_str(v
, NULL
));
129 /* push a reference to global symbol v */
130 static void vpush_global_sym(CType
*type
, int v
)
135 sym
= external_global_sym(v
, type
, 0);
137 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
141 void vset(CType
*type
, int r
, int v
)
146 vsetc(type
, r
, &cval
);
149 void vseti(int r
, int v
)
165 void vpushv(SValue
*v
)
167 if (vtop
>= vstack
+ (VSTACK_SIZE
- 1))
168 error("memory full");
178 /* save r to the memory stack, and mark it as being free */
181 int l
, saved
, size
, align
;
185 /* modify all stack values */
188 for(p
=vstack
;p
<=vtop
;p
++) {
189 if ((p
->r
& VT_VALMASK
) == r
||
190 ((p
->type
.t
& VT_BTYPE
) == VT_LLONG
&& (p
->r2
& VT_VALMASK
) == r
)) {
191 /* must save value on stack if not already done */
193 /* NOTE: must reload 'r' because r might be equal to r2 */
194 r
= p
->r
& VT_VALMASK
;
195 /* store register in the stack */
197 if ((p
->r
& VT_LVAL
) ||
198 (!is_float(type
->t
) && (type
->t
& VT_BTYPE
) != VT_LLONG
))
199 #ifdef TCC_TARGET_X86_64
200 type
= &char_pointer_type
;
204 size
= type_size(type
, &align
);
205 loc
= (loc
- size
) & -align
;
207 sv
.r
= VT_LOCAL
| VT_LVAL
;
210 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
211 /* x86 specific: need to pop fp register ST0 if saved */
213 o(0xd8dd); /* fstp %st(0) */
216 #ifndef TCC_TARGET_X86_64
217 /* special long long case */
218 if ((type
->t
& VT_BTYPE
) == VT_LLONG
) {
226 /* mark that stack entry as being saved on the stack */
227 if (p
->r
& VT_LVAL
) {
228 /* also clear the bounded flag because the
229 relocation address of the function was stored in
231 p
->r
= (p
->r
& ~(VT_VALMASK
| VT_BOUNDED
)) | VT_LLOCAL
;
233 p
->r
= lvalue_type(p
->type
.t
) | VT_LOCAL
;
241 /* find a register of class 'rc2' with at most one reference on stack.
242 * If none, call get_reg(rc) */
243 int get_reg_ex(int rc
, int rc2
)
248 for(r
=0;r
<NB_REGS
;r
++) {
249 if (reg_classes
[r
] & rc2
) {
252 for(p
= vstack
; p
<= vtop
; p
++) {
253 if ((p
->r
& VT_VALMASK
) == r
||
254 (p
->r2
& VT_VALMASK
) == r
)
264 /* find a free register of class 'rc'. If none, save one register */
270 /* find a free register */
271 for(r
=0;r
<NB_REGS
;r
++) {
272 if (reg_classes
[r
] & rc
) {
273 for(p
=vstack
;p
<=vtop
;p
++) {
274 if ((p
->r
& VT_VALMASK
) == r
||
275 (p
->r2
& VT_VALMASK
) == r
)
283 /* no register left : free the first one on the stack (VERY
284 IMPORTANT to start from the bottom to ensure that we don't
285 spill registers used in gen_opi()) */
286 for(p
=vstack
;p
<=vtop
;p
++) {
287 r
= p
->r
& VT_VALMASK
;
288 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
))
290 /* also look at second register (if long long) */
291 r
= p
->r2
& VT_VALMASK
;
292 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
)) {
298 /* Should never comes here */
302 /* save registers up to (vtop - n) stack entry */
303 void save_regs(int n
)
308 for(p
= vstack
;p
<= p1
; p
++) {
309 r
= p
->r
& VT_VALMASK
;
316 /* move register 's' to 'r', and flush previous value of r to memory
318 void move_reg(int r
, int s
)
331 /* get address of vtop (vtop MUST BE an lvalue) */
335 /* tricky: if saved lvalue, then we can go back to lvalue */
336 if ((vtop
->r
& VT_VALMASK
) == VT_LLOCAL
)
337 vtop
->r
= (vtop
->r
& ~(VT_VALMASK
| VT_LVAL_TYPE
)) | VT_LOCAL
| VT_LVAL
;
340 #ifdef CONFIG_TCC_BCHECK
341 /* generate lvalue bound code */
347 vtop
->r
&= ~VT_MUSTBOUND
;
348 /* if lvalue, then use checking code before dereferencing */
349 if (vtop
->r
& VT_LVAL
) {
350 /* if not VT_BOUNDED value, then make one */
351 if (!(vtop
->r
& VT_BOUNDED
)) {
352 lval_type
= vtop
->r
& (VT_LVAL_TYPE
| VT_LVAL
);
353 /* must save type because we must set it to int to get pointer */
355 vtop
->type
.t
= VT_INT
;
358 gen_bounded_ptr_add();
359 vtop
->r
|= lval_type
;
362 /* then check for dereferencing */
363 gen_bounded_ptr_deref();
368 /* store vtop a register belonging to class 'rc'. lvalues are
369 converted to values. Cannot be used if cannot be converted to
370 register value (such as structures). */
373 int r
, rc2
, bit_pos
, bit_size
, size
, align
, i
;
375 /* NOTE: get_reg can modify vstack[] */
376 if (vtop
->type
.t
& VT_BITFIELD
) {
379 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
380 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
381 /* remove bit field info to avoid loops */
382 vtop
->type
.t
&= ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
383 /* cast to int to propagate signedness in following ops */
384 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
389 if((vtop
->type
.t
& VT_UNSIGNED
) ||
390 (vtop
->type
.t
& VT_BTYPE
) == VT_BOOL
)
391 type
.t
|= VT_UNSIGNED
;
393 /* generate shifts */
394 vpushi(bits
- (bit_pos
+ bit_size
));
396 vpushi(bits
- bit_size
);
397 /* NOTE: transformed to SHR if unsigned */
401 if (is_float(vtop
->type
.t
) &&
402 (vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
405 unsigned long offset
;
406 #if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
410 /* XXX: unify with initializers handling ? */
411 /* CPUs usually cannot use float constants, so we store them
412 generically in data segment */
413 size
= type_size(&vtop
->type
, &align
);
414 offset
= (data_section
->data_offset
+ align
- 1) & -align
;
415 data_section
->data_offset
= offset
;
416 /* XXX: not portable yet */
417 #if defined(__i386__) || defined(__x86_64__)
418 /* Zero pad x87 tenbyte long doubles */
419 if (size
== LDOUBLE_SIZE
)
420 vtop
->c
.tab
[2] &= 0xffff;
422 ptr
= section_ptr_add(data_section
, size
);
424 #if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
428 ptr
[i
] = vtop
->c
.tab
[size
-1-i
];
432 ptr
[i
] = vtop
->c
.tab
[i
];
433 sym
= get_sym_ref(&vtop
->type
, data_section
, offset
, size
<< 2);
434 vtop
->r
|= VT_LVAL
| VT_SYM
;
438 #ifdef CONFIG_TCC_BCHECK
439 if (vtop
->r
& VT_MUSTBOUND
)
443 r
= vtop
->r
& VT_VALMASK
;
447 /* need to reload if:
449 - lvalue (need to dereference pointer)
450 - already a register, but not in the right class */
452 (vtop
->r
& VT_LVAL
) ||
453 !(reg_classes
[r
] & rc
) ||
454 ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
&&
455 !(reg_classes
[vtop
->r2
] & rc2
))) {
457 #ifndef TCC_TARGET_X86_64
458 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
460 unsigned long long ll
;
461 /* two register type load : expand to two words
463 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
466 vtop
->c
.ui
= ll
; /* first word */
468 vtop
->r
= r
; /* save register value */
469 vpushi(ll
>> 32); /* second word */
470 } else if (r
>= VT_CONST
|| /* XXX: test to VT_CONST incorrect ? */
471 (vtop
->r
& VT_LVAL
)) {
472 /* We do not want to modifier the long long
473 pointer here, so the safest (and less
474 efficient) is to save all the other registers
475 in the stack. XXX: totally inefficient. */
477 /* load from memory */
480 vtop
[-1].r
= r
; /* save register value */
481 /* increment pointer to get second word */
482 vtop
->type
.t
= VT_INT
;
491 vtop
[-1].r
= r
; /* save register value */
492 vtop
->r
= vtop
[-1].r2
;
494 /* allocate second register */
498 /* write second register */
502 if ((vtop
->r
& VT_LVAL
) && !is_float(vtop
->type
.t
)) {
504 /* lvalue of scalar type : need to use lvalue type
505 because of possible cast */
508 /* compute memory access type */
509 if (vtop
->r
& VT_LVAL_BYTE
)
511 else if (vtop
->r
& VT_LVAL_SHORT
)
513 if (vtop
->r
& VT_LVAL_UNSIGNED
)
517 /* restore wanted type */
520 /* one register type load */
525 #ifdef TCC_TARGET_C67
526 /* uses register pairs for doubles */
527 if ((vtop
->type
.t
& VT_BTYPE
) == VT_DOUBLE
)
534 /* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
535 void gv2(int rc1
, int rc2
)
539 /* generate more generic register first. But VT_JMP or VT_CMP
540 values must be generated first in all cases to avoid possible
542 v
= vtop
[0].r
& VT_VALMASK
;
543 if (v
!= VT_CMP
&& (v
& ~1) != VT_JMP
&& rc1
<= rc2
) {
548 /* test if reload is needed for first register */
549 if ((vtop
[-1].r
& VT_VALMASK
) >= VT_CONST
) {
559 /* test if reload is needed for first register */
560 if ((vtop
[0].r
& VT_VALMASK
) >= VT_CONST
) {
566 /* wrapper around RC_FRET to return a register by type */
569 #ifdef TCC_TARGET_X86_64
570 if (t
== VT_LDOUBLE
) {
577 /* wrapper around REG_FRET to return a register by type */
580 #ifdef TCC_TARGET_X86_64
581 if (t
== VT_LDOUBLE
) {
588 /* expand long long on stack in two int registers */
593 u
= vtop
->type
.t
& VT_UNSIGNED
;
596 vtop
[0].r
= vtop
[-1].r2
;
597 vtop
[0].r2
= VT_CONST
;
598 vtop
[-1].r2
= VT_CONST
;
599 vtop
[0].type
.t
= VT_INT
| u
;
600 vtop
[-1].type
.t
= VT_INT
| u
;
603 #ifdef TCC_TARGET_ARM
604 /* expand long long on stack */
605 void lexpand_nr(void)
609 u
= vtop
->type
.t
& VT_UNSIGNED
;
612 vtop
->type
.t
= VT_INT
| u
;
613 v
=vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
);
615 vtop
[-1].c
.ui
= vtop
->c
.ull
;
616 vtop
->c
.ui
= vtop
->c
.ull
>> 32;
618 } else if (v
== (VT_LVAL
|VT_CONST
) || v
== (VT_LVAL
|VT_LOCAL
)) {
620 vtop
->r
= vtop
[-1].r
;
621 } else if (v
> VT_CONST
) {
625 vtop
->r
= vtop
[-1].r2
;
626 vtop
[-1].r2
= VT_CONST
;
627 vtop
[-1].type
.t
= VT_INT
| u
;
631 /* build a long long from two ints */
635 vtop
[-1].r2
= vtop
[0].r
;
640 /* rotate n first stack elements to the bottom
641 I1 ... In -> I2 ... In I1 [top is right]
654 /* rotate n first stack elements to the top
655 I1 ... In -> In I1 ... I(n-1) [top is right]
663 for(i
= 0;i
< n
- 1; i
++)
664 vtop
[-i
] = vtop
[-i
- 1];
668 #ifdef TCC_TARGET_ARM
669 /* like vrott but in other direction
670 In ... I1 -> I(n-1) ... I1 In [top is right]
678 for(i
= n
- 1; i
> 0; i
--)
679 vtop
[-i
] = vtop
[-i
+ 1];
684 /* pop stack value */
688 v
= vtop
->r
& VT_VALMASK
;
689 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
690 /* for x86, we need to pop the FP stack */
691 if (v
== TREG_ST0
&& !nocode_wanted
) {
692 o(0xd8dd); /* fstp %st(0) */
695 if (v
== VT_JMP
|| v
== VT_JMPI
) {
696 /* need to put correct jump if && or || without test */
702 /* convert stack entry to register and duplicate its value in another
710 if ((t
& VT_BTYPE
) == VT_LLONG
) {
717 /* stack: H L L1 H1 */
725 /* duplicate value */
730 #ifdef TCC_TARGET_X86_64
731 if ((t
& VT_BTYPE
) == VT_LDOUBLE
) {
741 load(r1
, &sv
); /* move r to r1 */
743 /* duplicates value */
749 #ifndef TCC_TARGET_X86_64
750 /* generate CPU independent (unsigned) long long operations */
753 int t
, a
, b
, op1
, c
, i
;
755 unsigned short reg_iret
= REG_IRET
;
756 unsigned short reg_lret
= REG_LRET
;
765 func
= TOK___udivdi3
;
771 func
= TOK___umoddi3
;
778 /* call generic long long function */
779 vpush_global_sym(&func_old_type
, func
);
797 /* stack: L1 H1 L2 H2 */
805 /* stack: H1 H2 L1 L2 */
811 /* stack: H1 H2 L1 L2 ML MH */
814 /* stack: ML MH H1 H2 L1 L2 */
818 /* stack: ML MH H1 L2 H2 L1 */
823 /* stack: ML MH M1 M2 */
826 } else if (op
== '+' || op
== '-') {
827 /* XXX: add non carry method too (for MIPS or alpha) */
833 /* stack: H1 H2 (L1 op L2) */
836 gen_op(op1
+ 1); /* TOK_xxxC2 */
839 /* stack: H1 H2 (L1 op L2) */
842 /* stack: (L1 op L2) H1 H2 */
844 /* stack: (L1 op L2) (H1 op H2) */
852 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
857 /* stack: L H shift */
859 /* constant: simpler */
860 /* NOTE: all comments are for SHL. the other cases are
861 done by swaping words */
905 /* XXX: should provide a faster fallback on x86 ? */
908 func
= TOK___ashrdi3
;
911 func
= TOK___lshrdi3
;
914 func
= TOK___ashldi3
;
920 /* compare operations */
926 /* stack: L1 H1 L2 H2 */
930 /* stack: L1 L2 H1 H2 */
933 /* when values are equal, we need to compare low words. since
934 the jump is inverted, we invert the test too. */
937 else if (op1
== TOK_GT
)
939 else if (op1
== TOK_ULT
)
941 else if (op1
== TOK_UGT
)
950 /* generate non equal test */
951 /* XXX: NOT PORTABLE yet */
955 #if defined(TCC_TARGET_I386)
957 #elif defined(TCC_TARGET_ARM)
959 o(0x1A000000 | encbranch(ind
, 0, 1));
960 #elif defined(TCC_TARGET_C67)
961 error("not implemented");
967 /* compare low. Always unsigned */
971 else if (op1
== TOK_LE
)
973 else if (op1
== TOK_GT
)
975 else if (op1
== TOK_GE
)
986 /* handle integer constant optimizations and various machine
988 void gen_opic(int op
)
990 int c1
, c2
, t1
, t2
, n
;
993 typedef unsigned long long U
;
997 t1
= v1
->type
.t
& VT_BTYPE
;
998 t2
= v2
->type
.t
& VT_BTYPE
;
1002 else if (v1
->type
.t
& VT_UNSIGNED
)
1009 else if (v2
->type
.t
& VT_UNSIGNED
)
1014 /* currently, we cannot do computations with forward symbols */
1015 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
1016 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
1019 case '+': l1
+= l2
; break;
1020 case '-': l1
-= l2
; break;
1021 case '&': l1
&= l2
; break;
1022 case '^': l1
^= l2
; break;
1023 case '|': l1
|= l2
; break;
1024 case '*': l1
*= l2
; break;
1031 /* if division by zero, generate explicit division */
1034 error("division by zero in constant");
1038 default: l1
/= l2
; break;
1039 case '%': l1
%= l2
; break;
1040 case TOK_UDIV
: l1
= (U
)l1
/ l2
; break;
1041 case TOK_UMOD
: l1
= (U
)l1
% l2
; break;
1044 case TOK_SHL
: l1
<<= l2
; break;
1045 case TOK_SHR
: l1
= (U
)l1
>> l2
; break;
1046 case TOK_SAR
: l1
>>= l2
; break;
1048 case TOK_ULT
: l1
= (U
)l1
< (U
)l2
; break;
1049 case TOK_UGE
: l1
= (U
)l1
>= (U
)l2
; break;
1050 case TOK_EQ
: l1
= l1
== l2
; break;
1051 case TOK_NE
: l1
= l1
!= l2
; break;
1052 case TOK_ULE
: l1
= (U
)l1
<= (U
)l2
; break;
1053 case TOK_UGT
: l1
= (U
)l1
> (U
)l2
; break;
1054 case TOK_LT
: l1
= l1
< l2
; break;
1055 case TOK_GE
: l1
= l1
>= l2
; break;
1056 case TOK_LE
: l1
= l1
<= l2
; break;
1057 case TOK_GT
: l1
= l1
> l2
; break;
1059 case TOK_LAND
: l1
= l1
&& l2
; break;
1060 case TOK_LOR
: l1
= l1
|| l2
; break;
1067 /* if commutative ops, put c2 as constant */
1068 if (c1
&& (op
== '+' || op
== '&' || op
== '^' ||
1069 op
== '|' || op
== '*')) {
1071 c2
= c1
; //c = c1, c1 = c2, c2 = c;
1072 l2
= l1
; //l = l1, l1 = l2, l2 = l;
1074 /* Filter out NOP operations like x*1, x-0, x&-1... */
1075 if (c2
&& (((op
== '*' || op
== '/' || op
== TOK_UDIV
||
1078 ((op
== '+' || op
== '-' || op
== '|' || op
== '^' ||
1079 op
== TOK_SHL
|| op
== TOK_SHR
|| op
== TOK_SAR
) &&
1085 } else if (c2
&& (op
== '*' || op
== TOK_PDIV
|| op
== TOK_UDIV
)) {
1086 /* try to use shifts instead of muls or divs */
1087 if (l2
> 0 && (l2
& (l2
- 1)) == 0) {
1096 else if (op
== TOK_PDIV
)
1102 } else if (c2
&& (op
== '+' || op
== '-') &&
1103 (((vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == (VT_CONST
| VT_SYM
)
1104 && !(vtop
[-1].sym
->type
.t
& VT_IMPORT
))
1106 (vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
)) == VT_LOCAL
)) {
1107 /* symbol + constant case */
1114 if (!nocode_wanted
) {
1115 /* call low level op generator */
1116 if (t1
== VT_LLONG
|| t2
== VT_LLONG
)
1127 /* generate a floating point operation with constant propagation */
1128 void gen_opif(int op
)
1136 /* currently, we cannot do computations with forward symbols */
1137 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
1138 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
1140 if (v1
->type
.t
== VT_FLOAT
) {
1143 } else if (v1
->type
.t
== VT_DOUBLE
) {
1151 /* NOTE: we only do constant propagation if finite number (not
1152 NaN or infinity) (ANSI spec) */
1153 if (!ieee_finite(f1
) || !ieee_finite(f2
))
1157 case '+': f1
+= f2
; break;
1158 case '-': f1
-= f2
; break;
1159 case '*': f1
*= f2
; break;
1163 error("division by zero in constant");
1168 /* XXX: also handles tests ? */
1172 /* XXX: overflow test ? */
1173 if (v1
->type
.t
== VT_FLOAT
) {
1175 } else if (v1
->type
.t
== VT_DOUBLE
) {
1183 if (!nocode_wanted
) {
1191 static int pointed_size(CType
*type
)
1194 return type_size(pointed_type(type
), &align
);
1197 static inline int is_null_pointer(SValue
*p
)
1199 if ((p
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
1201 return ((p
->type
.t
& VT_BTYPE
) == VT_INT
&& p
->c
.i
== 0) ||
1202 ((p
->type
.t
& VT_BTYPE
) == VT_LLONG
&& p
->c
.ll
== 0);
1205 static inline int is_integer_btype(int bt
)
1207 return (bt
== VT_BYTE
|| bt
== VT_SHORT
||
1208 bt
== VT_INT
|| bt
== VT_LLONG
);
1211 /* check types for comparison or substraction of pointers */
1212 static void check_comparison_pointer_types(SValue
*p1
, SValue
*p2
, int op
)
1214 CType
*type1
, *type2
, tmp_type1
, tmp_type2
;
1217 /* null pointers are accepted for all comparisons as gcc */
1218 if (is_null_pointer(p1
) || is_null_pointer(p2
))
1222 bt1
= type1
->t
& VT_BTYPE
;
1223 bt2
= type2
->t
& VT_BTYPE
;
1224 /* accept comparison between pointer and integer with a warning */
1225 if ((is_integer_btype(bt1
) || is_integer_btype(bt2
)) && op
!= '-') {
1226 if (op
!= TOK_LOR
&& op
!= TOK_LAND
)
1227 warning("comparison between pointer and integer");
1231 /* both must be pointers or implicit function pointers */
1232 if (bt1
== VT_PTR
) {
1233 type1
= pointed_type(type1
);
1234 } else if (bt1
!= VT_FUNC
)
1235 goto invalid_operands
;
1237 if (bt2
== VT_PTR
) {
1238 type2
= pointed_type(type2
);
1239 } else if (bt2
!= VT_FUNC
) {
1241 error("invalid operands to binary %s", get_tok_str(op
, NULL
));
1243 if ((type1
->t
& VT_BTYPE
) == VT_VOID
||
1244 (type2
->t
& VT_BTYPE
) == VT_VOID
)
1248 tmp_type1
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
1249 tmp_type2
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
1250 if (!is_compatible_types(&tmp_type1
, &tmp_type2
)) {
1251 /* gcc-like error if '-' is used */
1253 goto invalid_operands
;
1255 warning("comparison of distinct pointer types lacks a cast");
1259 /* generic gen_op: handles types problems */
1262 int u
, t1
, t2
, bt1
, bt2
, t
;
1265 t1
= vtop
[-1].type
.t
;
1266 t2
= vtop
[0].type
.t
;
1267 bt1
= t1
& VT_BTYPE
;
1268 bt2
= t2
& VT_BTYPE
;
1270 if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
1271 /* at least one operand is a pointer */
1272 /* relationnal op: must be both pointers */
1273 if (op
>= TOK_ULT
&& op
<= TOK_LOR
) {
1274 check_comparison_pointer_types(vtop
- 1, vtop
, op
);
1275 /* pointers are handled are unsigned */
1276 #ifdef TCC_TARGET_X86_64
1277 t
= VT_LLONG
| VT_UNSIGNED
;
1279 t
= VT_INT
| VT_UNSIGNED
;
1283 /* if both pointers, then it must be the '-' op */
1284 if (bt1
== VT_PTR
&& bt2
== VT_PTR
) {
1286 error("cannot use pointers here");
1287 check_comparison_pointer_types(vtop
- 1, vtop
, op
);
1288 /* XXX: check that types are compatible */
1289 u
= pointed_size(&vtop
[-1].type
);
1291 /* set to integer type */
1292 #ifdef TCC_TARGET_X86_64
1293 vtop
->type
.t
= VT_LLONG
;
1295 vtop
->type
.t
= VT_INT
;
1300 /* exactly one pointer : must be '+' or '-'. */
1301 if (op
!= '-' && op
!= '+')
1302 error("cannot use pointers here");
1303 /* Put pointer as first operand */
1304 if (bt2
== VT_PTR
) {
1308 type1
= vtop
[-1].type
;
1309 type1
.t
&= ~VT_ARRAY
;
1310 #ifdef TCC_TARGET_X86_64
1311 vpushll(pointed_size(&vtop
[-1].type
));
1313 /* XXX: cast to int ? (long long case) */
1314 vpushi(pointed_size(&vtop
[-1].type
));
1317 #ifdef CONFIG_TCC_BCHECK
1318 /* if evaluating constant expression, no code should be
1319 generated, so no bound check */
1320 if (tcc_state
->do_bounds_check
&& !const_wanted
) {
1321 /* if bounded pointers, we generate a special code to
1328 gen_bounded_ptr_add();
1334 /* put again type if gen_opic() swaped operands */
1337 } else if (is_float(bt1
) || is_float(bt2
)) {
1338 /* compute bigger type and do implicit casts */
1339 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
1341 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
1346 /* floats can only be used for a few operations */
1347 if (op
!= '+' && op
!= '-' && op
!= '*' && op
!= '/' &&
1348 (op
< TOK_ULT
|| op
> TOK_GT
))
1349 error("invalid operands for binary operation");
1351 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
1352 /* cast to biggest op */
1354 /* convert to unsigned if it does not fit in a long long */
1355 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
1356 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
1360 /* integer operations */
1362 /* convert to unsigned if it does not fit in an integer */
1363 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
1364 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
1367 /* XXX: currently, some unsigned operations are explicit, so
1368 we modify them here */
1369 if (t
& VT_UNSIGNED
) {
1376 else if (op
== TOK_LT
)
1378 else if (op
== TOK_GT
)
1380 else if (op
== TOK_LE
)
1382 else if (op
== TOK_GE
)
1389 /* special case for shifts and long long: we keep the shift as
1391 if (op
== TOK_SHR
|| op
== TOK_SAR
|| op
== TOK_SHL
)
1398 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
1399 /* relationnal op: the result is an int */
1400 vtop
->type
.t
= VT_INT
;
1407 #ifndef TCC_TARGET_ARM
1408 /* generic itof for unsigned long long case */
1409 void gen_cvt_itof1(int t
)
1411 if ((vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
)) ==
1412 (VT_LLONG
| VT_UNSIGNED
)) {
1415 vpush_global_sym(&func_old_type
, TOK___floatundisf
);
1416 #if LDOUBLE_SIZE != 8
1417 else if (t
== VT_LDOUBLE
)
1418 vpush_global_sym(&func_old_type
, TOK___floatundixf
);
1421 vpush_global_sym(&func_old_type
, TOK___floatundidf
);
1425 vtop
->r
= reg_fret(t
);
1432 /* generic ftoi for unsigned long long case */
1433 void gen_cvt_ftoi1(int t
)
1437 if (t
== (VT_LLONG
| VT_UNSIGNED
)) {
1438 /* not handled natively */
1439 st
= vtop
->type
.t
& VT_BTYPE
;
1441 vpush_global_sym(&func_old_type
, TOK___fixunssfdi
);
1442 #if LDOUBLE_SIZE != 8
1443 else if (st
== VT_LDOUBLE
)
1444 vpush_global_sym(&func_old_type
, TOK___fixunsxfdi
);
1447 vpush_global_sym(&func_old_type
, TOK___fixunsdfdi
);
1452 vtop
->r2
= REG_LRET
;
1458 /* force char or short cast */
1459 void force_charshort_cast(int t
)
1463 /* XXX: add optimization if lvalue : just change type and offset */
1468 if (t
& VT_UNSIGNED
) {
1469 vpushi((1 << bits
) - 1);
1475 /* result must be signed or the SAR is converted to an SHL
1476 This was not the case when "t" was a signed short
1477 and the last value on the stack was an unsigned int */
1478 vtop
->type
.t
&= ~VT_UNSIGNED
;
1484 /* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
1485 static void gen_cast(CType
*type
)
1487 int sbt
, dbt
, sf
, df
, c
, p
;
1489 /* special delayed cast for char/short */
1490 /* XXX: in some cases (multiple cascaded casts), it may still
1492 if (vtop
->r
& VT_MUSTCAST
) {
1493 vtop
->r
&= ~VT_MUSTCAST
;
1494 force_charshort_cast(vtop
->type
.t
);
1497 /* bitfields first get cast to ints */
1498 if (vtop
->type
.t
& VT_BITFIELD
) {
1502 dbt
= type
->t
& (VT_BTYPE
| VT_UNSIGNED
);
1503 sbt
= vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
);
1508 c
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
1509 p
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == (VT_CONST
| VT_SYM
);
1511 /* constant case: we can do it now */
1512 /* XXX: in ISOC, cannot do it if error in convert */
1513 if (sbt
== VT_FLOAT
)
1514 vtop
->c
.ld
= vtop
->c
.f
;
1515 else if (sbt
== VT_DOUBLE
)
1516 vtop
->c
.ld
= vtop
->c
.d
;
1519 if ((sbt
& VT_BTYPE
) == VT_LLONG
) {
1520 if (sbt
& VT_UNSIGNED
)
1521 vtop
->c
.ld
= vtop
->c
.ull
;
1523 vtop
->c
.ld
= vtop
->c
.ll
;
1525 if (sbt
& VT_UNSIGNED
)
1526 vtop
->c
.ld
= vtop
->c
.ui
;
1528 vtop
->c
.ld
= vtop
->c
.i
;
1531 if (dbt
== VT_FLOAT
)
1532 vtop
->c
.f
= (float)vtop
->c
.ld
;
1533 else if (dbt
== VT_DOUBLE
)
1534 vtop
->c
.d
= (double)vtop
->c
.ld
;
1535 } else if (sf
&& dbt
== (VT_LLONG
|VT_UNSIGNED
)) {
1536 vtop
->c
.ull
= (unsigned long long)vtop
->c
.ld
;
1537 } else if (sf
&& dbt
== VT_BOOL
) {
1538 vtop
->c
.i
= (vtop
->c
.ld
!= 0);
1541 vtop
->c
.ll
= (long long)vtop
->c
.ld
;
1542 else if (sbt
== (VT_LLONG
|VT_UNSIGNED
))
1543 vtop
->c
.ll
= vtop
->c
.ull
;
1544 else if (sbt
& VT_UNSIGNED
)
1545 vtop
->c
.ll
= vtop
->c
.ui
;
1546 #ifdef TCC_TARGET_X86_64
1547 else if (sbt
== VT_PTR
)
1550 else if (sbt
!= VT_LLONG
)
1551 vtop
->c
.ll
= vtop
->c
.i
;
1553 if (dbt
== (VT_LLONG
|VT_UNSIGNED
))
1554 vtop
->c
.ull
= vtop
->c
.ll
;
1555 else if (dbt
== VT_BOOL
)
1556 vtop
->c
.i
= (vtop
->c
.ll
!= 0);
1557 else if (dbt
!= VT_LLONG
) {
1559 if ((dbt
& VT_BTYPE
) == VT_BYTE
)
1561 else if ((dbt
& VT_BTYPE
) == VT_SHORT
)
1564 if(dbt
& VT_UNSIGNED
)
1565 vtop
->c
.ui
= ((unsigned int)vtop
->c
.ll
<< s
) >> s
;
1567 vtop
->c
.i
= ((int)vtop
->c
.ll
<< s
) >> s
;
1570 } else if (p
&& dbt
== VT_BOOL
) {
1573 } else if (!nocode_wanted
) {
1574 /* non constant case: generate code */
1576 /* convert from fp to fp */
1579 /* convert int to fp */
1582 /* convert fp to int */
1583 if (dbt
== VT_BOOL
) {
1587 /* we handle char/short/etc... with generic code */
1588 if (dbt
!= (VT_INT
| VT_UNSIGNED
) &&
1589 dbt
!= (VT_LLONG
| VT_UNSIGNED
) &&
1593 if (dbt
== VT_INT
&& (type
->t
& (VT_BTYPE
| VT_UNSIGNED
)) != dbt
) {
1594 /* additional cast for char/short... */
1599 #ifndef TCC_TARGET_X86_64
1600 } else if ((dbt
& VT_BTYPE
) == VT_LLONG
) {
1601 if ((sbt
& VT_BTYPE
) != VT_LLONG
) {
1602 /* scalar to long long */
1603 /* machine independent conversion */
1605 /* generate high word */
1606 if (sbt
== (VT_INT
| VT_UNSIGNED
)) {
1610 if (sbt
== VT_PTR
) {
1611 /* cast from pointer to int before we apply
1612 shift operation, which pointers don't support*/
1613 gen_cast(&int_type
);
1619 /* patch second register */
1620 vtop
[-1].r2
= vtop
->r
;
1624 } else if ((dbt
& VT_BTYPE
) == VT_LLONG
||
1625 (dbt
& VT_BTYPE
) == VT_PTR
) {
1626 /* XXX: not sure if this is perfect... need more tests */
1627 if ((sbt
& VT_BTYPE
) != VT_LLONG
) {
1629 if (sbt
!= (VT_INT
| VT_UNSIGNED
) &&
1630 sbt
!= VT_PTR
&& sbt
!= VT_FUNC
) {
1631 /* x86_64 specific: movslq */
1633 o(0xc0 + (REG_VALUE(r
) << 3) + REG_VALUE(r
));
1637 } else if (dbt
== VT_BOOL
) {
1638 /* scalar to bool */
1641 } else if ((dbt
& VT_BTYPE
) == VT_BYTE
||
1642 (dbt
& VT_BTYPE
) == VT_SHORT
) {
1643 if (sbt
== VT_PTR
) {
1644 vtop
->type
.t
= VT_INT
;
1645 warning("nonportable conversion from pointer to char/short");
1647 force_charshort_cast(dbt
);
1648 } else if ((dbt
& VT_BTYPE
) == VT_INT
) {
1650 if (sbt
== VT_LLONG
) {
1651 /* from long long: just take low order word */
1655 /* if lvalue and single word type, nothing to do because
1656 the lvalue already contains the real type size (see
1657 VT_LVAL_xxx constants) */
1660 } else if ((dbt
& VT_BTYPE
) == VT_PTR
&& !(vtop
->r
& VT_LVAL
)) {
1661 /* if we are casting between pointer types,
1662 we must update the VT_LVAL_xxx size */
1663 vtop
->r
= (vtop
->r
& ~VT_LVAL_TYPE
)
1664 | (lvalue_type(type
->ref
->type
.t
) & VT_LVAL_TYPE
);
1669 /* return type size. Put alignment at 'a' */
1670 static int type_size(CType
*type
, int *a
)
1675 bt
= type
->t
& VT_BTYPE
;
1676 if (bt
== VT_STRUCT
) {
1681 } else if (bt
== VT_PTR
) {
1682 if (type
->t
& VT_ARRAY
) {
1686 ts
= type_size(&s
->type
, a
);
1688 if (ts
< 0 && s
->c
< 0)
1696 } else if (bt
== VT_LDOUBLE
) {
1698 return LDOUBLE_SIZE
;
1699 } else if (bt
== VT_DOUBLE
|| bt
== VT_LLONG
) {
1700 #ifdef TCC_TARGET_I386
1701 #ifdef TCC_TARGET_PE
1706 #elif defined(TCC_TARGET_ARM)
1716 } else if (bt
== VT_INT
|| bt
== VT_ENUM
|| bt
== VT_FLOAT
) {
1719 } else if (bt
== VT_SHORT
) {
1723 /* char, void, function, _Bool */
1729 /* return the pointed type of t */
1730 static inline CType
*pointed_type(CType
*type
)
1732 return &type
->ref
->type
;
1735 /* modify type so that its it is a pointer to type. */
1736 static void mk_pointer(CType
*type
)
1739 s
= sym_push(SYM_FIELD
, type
, 0, -1);
1740 type
->t
= VT_PTR
| (type
->t
& ~VT_TYPE
);
1744 /* compare function types. OLD functions match any new functions */
1745 static int is_compatible_func(CType
*type1
, CType
*type2
)
1751 if (!is_compatible_types(&s1
->type
, &s2
->type
))
1753 /* check func_call */
1754 if (FUNC_CALL(s1
->r
) != FUNC_CALL(s2
->r
))
1756 /* XXX: not complete */
1757 if (s1
->c
== FUNC_OLD
|| s2
->c
== FUNC_OLD
)
1761 while (s1
!= NULL
) {
1764 if (!is_compatible_parameter_types(&s1
->type
, &s2
->type
))
1774 /* return true if type1 and type2 are the same. If unqualified is
1775 true, qualifiers on the types are ignored.
1777 - enums are not checked as gcc __builtin_types_compatible_p ()
1779 static int compare_types(CType
*type1
, CType
*type2
, int unqualified
)
1783 t1
= type1
->t
& VT_TYPE
;
1784 t2
= type2
->t
& VT_TYPE
;
1786 /* strip qualifiers before comparing */
1787 t1
&= ~(VT_CONSTANT
| VT_VOLATILE
);
1788 t2
&= ~(VT_CONSTANT
| VT_VOLATILE
);
1790 /* XXX: bitfields ? */
1793 /* test more complicated cases */
1794 bt1
= t1
& VT_BTYPE
;
1795 if (bt1
== VT_PTR
) {
1796 type1
= pointed_type(type1
);
1797 type2
= pointed_type(type2
);
1798 return is_compatible_types(type1
, type2
);
1799 } else if (bt1
== VT_STRUCT
) {
1800 return (type1
->ref
== type2
->ref
);
1801 } else if (bt1
== VT_FUNC
) {
1802 return is_compatible_func(type1
, type2
);
1808 /* return true if type1 and type2 are exactly the same (including
1811 static int is_compatible_types(CType
*type1
, CType
*type2
)
1813 return compare_types(type1
,type2
,0);
1816 /* return true if type1 and type2 are the same (ignoring qualifiers).
1818 static int is_compatible_parameter_types(CType
*type1
, CType
*type2
)
1820 return compare_types(type1
,type2
,1);
1823 /* print a type. If 'varstr' is not NULL, then the variable is also
1824 printed in the type */
1826 /* XXX: add array and function pointers */
1827 void type_to_str(char *buf
, int buf_size
,
1828 CType
*type
, const char *varstr
)
1835 t
= type
->t
& VT_TYPE
;
1838 if (t
& VT_CONSTANT
)
1839 pstrcat(buf
, buf_size
, "const ");
1840 if (t
& VT_VOLATILE
)
1841 pstrcat(buf
, buf_size
, "volatile ");
1842 if (t
& VT_UNSIGNED
)
1843 pstrcat(buf
, buf_size
, "unsigned ");
1873 tstr
= "long double";
1875 pstrcat(buf
, buf_size
, tstr
);
1879 if (bt
== VT_STRUCT
)
1883 pstrcat(buf
, buf_size
, tstr
);
1884 v
= type
->ref
->v
& ~SYM_STRUCT
;
1885 if (v
>= SYM_FIRST_ANOM
)
1886 pstrcat(buf
, buf_size
, "<anonymous>");
1888 pstrcat(buf
, buf_size
, get_tok_str(v
, NULL
));
1892 type_to_str(buf
, buf_size
, &s
->type
, varstr
);
1893 pstrcat(buf
, buf_size
, "(");
1895 while (sa
!= NULL
) {
1896 type_to_str(buf1
, sizeof(buf1
), &sa
->type
, NULL
);
1897 pstrcat(buf
, buf_size
, buf1
);
1900 pstrcat(buf
, buf_size
, ", ");
1902 pstrcat(buf
, buf_size
, ")");
1906 pstrcpy(buf1
, sizeof(buf1
), "*");
1908 pstrcat(buf1
, sizeof(buf1
), varstr
);
1909 type_to_str(buf
, buf_size
, &s
->type
, buf1
);
1913 pstrcat(buf
, buf_size
, " ");
1914 pstrcat(buf
, buf_size
, varstr
);
1919 /* verify type compatibility to store vtop in 'dt' type, and generate
1921 static void gen_assign_cast(CType
*dt
)
1923 CType
*st
, *type1
, *type2
, tmp_type1
, tmp_type2
;
1924 char buf1
[256], buf2
[256];
1927 st
= &vtop
->type
; /* source type */
1928 dbt
= dt
->t
& VT_BTYPE
;
1929 sbt
= st
->t
& VT_BTYPE
;
1930 if (dt
->t
& VT_CONSTANT
)
1931 warning("assignment of read-only location");
1934 /* special cases for pointers */
1935 /* '0' can also be a pointer */
1936 if (is_null_pointer(vtop
))
1938 /* accept implicit pointer to integer cast with warning */
1939 if (is_integer_btype(sbt
)) {
1940 warning("assignment makes pointer from integer without a cast");
1943 type1
= pointed_type(dt
);
1944 /* a function is implicitely a function pointer */
1945 if (sbt
== VT_FUNC
) {
1946 if ((type1
->t
& VT_BTYPE
) != VT_VOID
&&
1947 !is_compatible_types(pointed_type(dt
), st
))
1948 warning("assignment from incompatible pointer type");
1953 type2
= pointed_type(st
);
1954 if ((type1
->t
& VT_BTYPE
) == VT_VOID
||
1955 (type2
->t
& VT_BTYPE
) == VT_VOID
) {
1956 /* void * can match anything */
1958 /* exact type match, except for unsigned */
1961 tmp_type1
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
1962 tmp_type2
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
1963 if (!is_compatible_types(&tmp_type1
, &tmp_type2
))
1964 warning("assignment from incompatible pointer type");
1966 /* check const and volatile */
1967 if ((!(type1
->t
& VT_CONSTANT
) && (type2
->t
& VT_CONSTANT
)) ||
1968 (!(type1
->t
& VT_VOLATILE
) && (type2
->t
& VT_VOLATILE
)))
1969 warning("assignment discards qualifiers from pointer target type");
1975 if (sbt
== VT_PTR
|| sbt
== VT_FUNC
) {
1976 warning("assignment makes integer from pointer without a cast");
1978 /* XXX: more tests */
1983 tmp_type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
1984 tmp_type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
1985 if (!is_compatible_types(&tmp_type1
, &tmp_type2
)) {
1987 type_to_str(buf1
, sizeof(buf1
), st
, NULL
);
1988 type_to_str(buf2
, sizeof(buf2
), dt
, NULL
);
1989 error("cannot cast '%s' to '%s'", buf1
, buf2
);
1997 /* store vtop in lvalue pushed on stack */
2000 int sbt
, dbt
, ft
, r
, t
, size
, align
, bit_size
, bit_pos
, rc
, delayed_cast
;
2002 ft
= vtop
[-1].type
.t
;
2003 sbt
= vtop
->type
.t
& VT_BTYPE
;
2004 dbt
= ft
& VT_BTYPE
;
2005 if (((sbt
== VT_INT
|| sbt
== VT_SHORT
) && dbt
== VT_BYTE
) ||
2006 (sbt
== VT_INT
&& dbt
== VT_SHORT
)) {
2007 /* optimize char/short casts */
2008 delayed_cast
= VT_MUSTCAST
;
2009 vtop
->type
.t
= ft
& (VT_TYPE
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
)));
2010 /* XXX: factorize */
2011 if (ft
& VT_CONSTANT
)
2012 warning("assignment of read-only location");
2015 if (!(ft
& VT_BITFIELD
))
2016 gen_assign_cast(&vtop
[-1].type
);
2019 if (sbt
== VT_STRUCT
) {
2020 /* if structure, only generate pointer */
2021 /* structure assignment : generate memcpy */
2022 /* XXX: optimize if small size */
2023 if (!nocode_wanted
) {
2024 size
= type_size(&vtop
->type
, &align
);
2028 vtop
->type
.t
= VT_PTR
;
2031 /* address of memcpy() */
2034 vpush_global_sym(&func_old_type
, TOK_memcpy8
);
2035 else if(!(align
& 3))
2036 vpush_global_sym(&func_old_type
, TOK_memcpy4
);
2039 vpush_global_sym(&func_old_type
, TOK_memcpy
);
2044 vtop
->type
.t
= VT_PTR
;
2053 /* leave source on stack */
2054 } else if (ft
& VT_BITFIELD
) {
2055 /* bitfield store handling */
2056 bit_pos
= (ft
>> VT_STRUCT_SHIFT
) & 0x3f;
2057 bit_size
= (ft
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
2058 /* remove bit field info to avoid loops */
2059 vtop
[-1].type
.t
= ft
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
2061 /* duplicate source into other register */
2066 if((ft
& VT_BTYPE
) == VT_BOOL
) {
2067 gen_cast(&vtop
[-1].type
);
2068 vtop
[-1].type
.t
= (vtop
[-1].type
.t
& ~VT_BTYPE
) | (VT_BYTE
| VT_UNSIGNED
);
2071 /* duplicate destination */
2073 vtop
[-1] = vtop
[-2];
2075 /* mask and shift source */
2076 if((ft
& VT_BTYPE
) != VT_BOOL
) {
2077 if((ft
& VT_BTYPE
) == VT_LLONG
) {
2078 vpushll((1ULL << bit_size
) - 1ULL);
2080 vpushi((1 << bit_size
) - 1);
2086 /* load destination, mask and or with source */
2088 if((ft
& VT_BTYPE
) == VT_LLONG
) {
2089 vpushll(~(((1ULL << bit_size
) - 1ULL) << bit_pos
));
2091 vpushi(~(((1 << bit_size
) - 1) << bit_pos
));
2098 /* pop off shifted source from "duplicate source..." above */
2102 #ifdef CONFIG_TCC_BCHECK
2103 /* bound check case */
2104 if (vtop
[-1].r
& VT_MUSTBOUND
) {
2110 if (!nocode_wanted
) {
2114 #ifdef TCC_TARGET_X86_64
2115 if ((ft
& VT_BTYPE
) == VT_LDOUBLE
) {
2120 r
= gv(rc
); /* generate value */
2121 /* if lvalue was saved on stack, must read it */
2122 if ((vtop
[-1].r
& VT_VALMASK
) == VT_LLOCAL
) {
2124 t
= get_reg(RC_INT
);
2125 #ifdef TCC_TARGET_X86_64
2130 sv
.r
= VT_LOCAL
| VT_LVAL
;
2131 sv
.c
.ul
= vtop
[-1].c
.ul
;
2133 vtop
[-1].r
= t
| VT_LVAL
;
2136 #ifndef TCC_TARGET_X86_64
2137 /* two word case handling : store second register at word + 4 */
2138 if ((ft
& VT_BTYPE
) == VT_LLONG
) {
2140 /* convert to int to increment easily */
2141 vtop
->type
.t
= VT_INT
;
2147 /* XXX: it works because r2 is spilled last ! */
2148 store(vtop
->r2
, vtop
- 1);
2153 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
2154 vtop
->r
|= delayed_cast
;
2158 /* post defines POST/PRE add. c is the token ++ or -- */
2159 void inc(int post
, int c
)
2162 vdup(); /* save lvalue */
2164 gv_dup(); /* duplicate value */
2169 vpushi(c
- TOK_MID
);
2171 vstore(); /* store value */
2173 vpop(); /* if post op, return saved value */
2176 /* Parse GNUC __attribute__ extension. Currently, the following
2177 extensions are recognized:
2178 - aligned(n) : set data/function alignment.
2179 - packed : force data alignment to 1
2180 - section(x) : generate data/code in this section.
2181 - unused : currently ignored, but may be used someday.
2182 - regparm(n) : pass function parameters in registers (i386 only)
2184 static void parse_attribute(AttributeDef
*ad
)
2188 while (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
) {
2192 while (tok
!= ')') {
2193 if (tok
< TOK_IDENT
)
2194 expect("attribute name");
2202 expect("section name");
2203 ad
->section
= find_section(tcc_state
, (char *)tokc
.cstr
->data
);
2212 if (n
<= 0 || (n
& (n
- 1)) != 0)
2213 error("alignment must be a positive power of two");
2226 /* currently, no need to handle it because tcc does not
2227 track unused objects */
2231 /* currently, no need to handle it because tcc does not
2232 track unused objects */
2237 ad
->func_call
= FUNC_CDECL
;
2242 ad
->func_call
= FUNC_STDCALL
;
2244 #ifdef TCC_TARGET_I386
2254 ad
->func_call
= FUNC_FASTCALL1
+ n
- 1;
2260 ad
->func_call
= FUNC_FASTCALLW
;
2264 ad
->func_export
= 1;
2267 ad
->func_import
= 1;
2270 if (tcc_state
->warn_unsupported
)
2271 warning("'%s' attribute ignored", get_tok_str(t
, NULL
));
2272 /* skip parameters */
2274 int parenthesis
= 0;
2278 else if (tok
== ')')
2281 } while (parenthesis
&& tok
!= -1);
2294 /* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
2295 static void struct_decl(CType
*type
, int u
)
2297 int a
, v
, size
, align
, maxalign
, c
, offset
;
2298 int bit_size
, bit_pos
, bsize
, bt
, lbit_pos
, prevbt
;
2299 Sym
*s
, *ss
, *ass
, **ps
;
2303 a
= tok
; /* save decl type */
2308 /* struct already defined ? return it */
2310 expect("struct/union/enum name");
2314 error("invalid type");
2321 /* we put an undefined size for struct/union */
2322 s
= sym_push(v
| SYM_STRUCT
, &type1
, 0, -1);
2323 s
->r
= 0; /* default alignment is zero as gcc */
2324 /* put struct/union/enum name in type */
2332 error("struct/union/enum already defined");
2333 /* cannot be empty */
2335 /* non empty enums are not allowed */
2336 if (a
== TOK_ENUM
) {
2340 expect("identifier");
2346 /* enum symbols have static storage */
2347 ss
= sym_push(v
, &int_type
, VT_CONST
, c
);
2348 ss
->type
.t
|= VT_STATIC
;
2353 /* NOTE: we accept a trailing comma */
2364 while (tok
!= '}') {
2365 parse_btype(&btype
, &ad
);
2371 type_decl(&type1
, &ad
, &v
, TYPE_DIRECT
| TYPE_ABSTRACT
);
2372 if (v
== 0 && (type1
.t
& VT_BTYPE
) != VT_STRUCT
)
2373 expect("identifier");
2374 if ((type1
.t
& VT_BTYPE
) == VT_FUNC
||
2375 (type1
.t
& (VT_TYPEDEF
| VT_STATIC
| VT_EXTERN
| VT_INLINE
)))
2376 error("invalid type for '%s'",
2377 get_tok_str(v
, NULL
));
2381 bit_size
= expr_const();
2382 /* XXX: handle v = 0 case for messages */
2384 error("negative width in bit-field '%s'",
2385 get_tok_str(v
, NULL
));
2386 if (v
&& bit_size
== 0)
2387 error("zero width for bit-field '%s'",
2388 get_tok_str(v
, NULL
));
2390 size
= type_size(&type1
, &align
);
2392 if (align
< ad
.aligned
)
2394 } else if (ad
.packed
) {
2396 } else if (*tcc_state
->pack_stack_ptr
) {
2397 if (align
> *tcc_state
->pack_stack_ptr
)
2398 align
= *tcc_state
->pack_stack_ptr
;
2401 if (bit_size
>= 0) {
2402 bt
= type1
.t
& VT_BTYPE
;
2409 error("bitfields must have scalar type");
2411 if (bit_size
> bsize
) {
2412 error("width of '%s' exceeds its type",
2413 get_tok_str(v
, NULL
));
2414 } else if (bit_size
== bsize
) {
2415 /* no need for bit fields */
2417 } else if (bit_size
== 0) {
2418 /* XXX: what to do if only padding in a
2420 /* zero size: means to pad */
2423 /* we do not have enough room ?
2424 did the type change?
2426 if ((bit_pos
+ bit_size
) > bsize
||
2427 bt
!= prevbt
|| a
== TOK_UNION
)
2430 /* XXX: handle LSB first */
2431 type1
.t
|= VT_BITFIELD
|
2432 (bit_pos
<< VT_STRUCT_SHIFT
) |
2433 (bit_size
<< (VT_STRUCT_SHIFT
+ 6));
2434 bit_pos
+= bit_size
;
2440 if (v
!= 0 || (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
2441 /* add new memory data only if starting
2443 if (lbit_pos
== 0) {
2444 if (a
== TOK_STRUCT
) {
2445 c
= (c
+ align
- 1) & -align
;
2454 if (align
> maxalign
)
2458 printf("add field %s offset=%d",
2459 get_tok_str(v
, NULL
), offset
);
2460 if (type1
.t
& VT_BITFIELD
) {
2461 printf(" pos=%d size=%d",
2462 (type1
.t
>> VT_STRUCT_SHIFT
) & 0x3f,
2463 (type1
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f);
2468 if (v
== 0 && (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
2470 while ((ass
= ass
->next
) != NULL
) {
2471 ss
= sym_push(ass
->v
, &ass
->type
, 0, offset
+ ass
->c
);
2476 ss
= sym_push(v
| SYM_FIELD
, &type1
, 0, offset
);
2480 if (tok
== ';' || tok
== TOK_EOF
)
2487 /* store size and alignment */
2488 s
->c
= (c
+ maxalign
- 1) & -maxalign
;
2494 /* return 0 if no type declaration. otherwise, return the basic type
2497 static int parse_btype(CType
*type
, AttributeDef
*ad
)
2499 int t
, u
, type_found
, typespec_found
, typedef_found
;
2503 memset(ad
, 0, sizeof(AttributeDef
));
2511 /* currently, we really ignore extension */
2521 if ((t
& VT_BTYPE
) != 0)
2522 error("too many basic types");
2538 if ((t
& VT_BTYPE
) == VT_DOUBLE
) {
2539 #ifndef TCC_TARGET_PE
2540 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
2542 } else if ((t
& VT_BTYPE
) == VT_LONG
) {
2543 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
2557 if ((t
& VT_BTYPE
) == VT_LONG
) {
2558 #ifdef TCC_TARGET_PE
2559 t
= (t
& ~VT_BTYPE
) | VT_DOUBLE
;
2561 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
2569 struct_decl(&type1
, VT_ENUM
);
2572 type
->ref
= type1
.ref
;
2576 struct_decl(&type1
, VT_STRUCT
);
2579 /* type modifiers */
2632 /* GNUC attribute */
2633 case TOK_ATTRIBUTE1
:
2634 case TOK_ATTRIBUTE2
:
2635 parse_attribute(ad
);
2642 parse_expr_type(&type1
);
2645 if (typespec_found
|| typedef_found
)
2648 if (!s
|| !(s
->type
.t
& VT_TYPEDEF
))
2651 t
|= (s
->type
.t
& ~VT_TYPEDEF
);
2652 type
->ref
= s
->type
.ref
;
2654 /* get attributes from typedef */
2655 if (0 == ad
->aligned
)
2656 ad
->aligned
= FUNC_ALIGN(s
->r
);
2657 if (0 == ad
->func_call
)
2658 ad
->func_call
= FUNC_CALL(s
->r
);
2659 ad
->packed
|= FUNC_PACKED(s
->r
);
2668 if ((t
& (VT_SIGNED
|VT_UNSIGNED
)) == (VT_SIGNED
|VT_UNSIGNED
))
2669 error("signed and unsigned modifier");
2670 if (tcc_state
->char_is_unsigned
) {
2671 if ((t
& (VT_SIGNED
|VT_UNSIGNED
|VT_BTYPE
)) == VT_BYTE
)
2676 /* long is never used as type */
2677 if ((t
& VT_BTYPE
) == VT_LONG
)
2678 #if !defined TCC_TARGET_X86_64 || defined TCC_TARGET_PE
2679 t
= (t
& ~VT_BTYPE
) | VT_INT
;
2681 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
2687 /* convert a function parameter type (array to pointer and function to
2688 function pointer) */
2689 static inline void convert_parameter_type(CType
*pt
)
2691 /* remove const and volatile qualifiers (XXX: const could be used
2692 to indicate a const function parameter */
2693 pt
->t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
2694 /* array must be transformed to pointer according to ANSI C */
2696 if ((pt
->t
& VT_BTYPE
) == VT_FUNC
) {
2701 static void post_type(CType
*type
, AttributeDef
*ad
)
2703 int n
, l
, t1
, arg_size
, align
;
2704 Sym
**plast
, *s
, *first
;
2709 /* function declaration */
2717 /* read param name and compute offset */
2718 if (l
!= FUNC_OLD
) {
2719 if (!parse_btype(&pt
, &ad1
)) {
2721 error("invalid type");
2728 if ((pt
.t
& VT_BTYPE
) == VT_VOID
&& tok
== ')')
2730 type_decl(&pt
, &ad1
, &n
, TYPE_DIRECT
| TYPE_ABSTRACT
);
2731 if ((pt
.t
& VT_BTYPE
) == VT_VOID
)
2732 error("parameter declared as void");
2733 arg_size
+= (type_size(&pt
, &align
) + 3) & ~3;
2738 expect("identifier");
2742 convert_parameter_type(&pt
);
2743 s
= sym_push(n
| SYM_FIELD
, &pt
, 0, 0);
2749 if (l
== FUNC_NEW
&& tok
== TOK_DOTS
) {
2756 /* if no parameters, then old type prototype */
2760 t1
= type
->t
& VT_STORAGE
;
2761 /* NOTE: const is ignored in returned type as it has a special
2762 meaning in gcc / C++ */
2763 type
->t
&= ~(VT_STORAGE
| VT_CONSTANT
);
2764 post_type(type
, ad
);
2765 /* we push a anonymous symbol which will contain the function prototype */
2766 ad
->func_args
= arg_size
;
2767 s
= sym_push(SYM_FIELD
, type
, INT_ATTR(ad
), l
);
2769 type
->t
= t1
| VT_FUNC
;
2771 } else if (tok
== '[') {
2772 /* array definition */
2774 if (tok
== TOK_RESTRICT1
)
2780 error("invalid array size");
2783 /* parse next post type */
2784 t1
= type
->t
& VT_STORAGE
;
2785 type
->t
&= ~VT_STORAGE
;
2786 post_type(type
, ad
);
2788 /* we push a anonymous symbol which will contain the array
2790 s
= sym_push(SYM_FIELD
, type
, 0, n
);
2791 type
->t
= t1
| VT_ARRAY
| VT_PTR
;
2796 /* Parse a type declaration (except basic type), and return the type
2797 in 'type'. 'td' is a bitmask indicating which kind of type decl is
2798 expected. 'type' should contain the basic type. 'ad' is the
2799 attribute definition of the basic type. It can be modified by
2802 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
)
2805 CType type1
, *type2
;
2808 while (tok
== '*') {
2816 qualifiers
|= VT_CONSTANT
;
2821 qualifiers
|= VT_VOLATILE
;
2829 type
->t
|= qualifiers
;
2832 /* XXX: clarify attribute handling */
2833 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
2834 parse_attribute(ad
);
2836 /* recursive type */
2837 /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
2838 type1
.t
= 0; /* XXX: same as int */
2841 /* XXX: this is not correct to modify 'ad' at this point, but
2842 the syntax is not clear */
2843 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
2844 parse_attribute(ad
);
2845 type_decl(&type1
, ad
, v
, td
);
2848 /* type identifier */
2849 if (tok
>= TOK_IDENT
&& (td
& TYPE_DIRECT
)) {
2853 if (!(td
& TYPE_ABSTRACT
))
2854 expect("identifier");
2858 post_type(type
, ad
);
2859 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
2860 parse_attribute(ad
);
2863 /* append type at the end of type1 */
2876 /* compute the lvalue VT_LVAL_xxx needed to match type t. */
2877 static int lvalue_type(int t
)
2882 if (bt
== VT_BYTE
|| bt
== VT_BOOL
)
2884 else if (bt
== VT_SHORT
)
2888 if (t
& VT_UNSIGNED
)
2889 r
|= VT_LVAL_UNSIGNED
;
2893 /* indirection with full error checking and bound check */
2894 static void indir(void)
2896 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
) {
2897 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FUNC
)
2901 if ((vtop
->r
& VT_LVAL
) && !nocode_wanted
)
2903 vtop
->type
= *pointed_type(&vtop
->type
);
2904 /* Arrays and functions are never lvalues */
2905 if (!(vtop
->type
.t
& VT_ARRAY
)
2906 && (vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
2907 vtop
->r
|= lvalue_type(vtop
->type
.t
);
2908 /* if bound checking, the referenced pointer must be checked */
2909 if (tcc_state
->do_bounds_check
)
2910 vtop
->r
|= VT_MUSTBOUND
;
2914 /* pass a parameter to a function and do type checking and casting */
2915 static void gfunc_param_typed(Sym
*func
, Sym
*arg
)
2920 func_type
= func
->c
;
2921 if (func_type
== FUNC_OLD
||
2922 (func_type
== FUNC_ELLIPSIS
&& arg
== NULL
)) {
2923 /* default casting : only need to convert float to double */
2924 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
) {
2928 } else if (arg
== NULL
) {
2929 error("too many arguments to function");
2932 type
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
2933 gen_assign_cast(&type
);
2937 /* parse an expression of the form '(type)' or '(expr)' and return its
2939 static void parse_expr_type(CType
*type
)
2945 if (parse_btype(type
, &ad
)) {
2946 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
2953 static void parse_type(CType
*type
)
2958 if (!parse_btype(type
, &ad
)) {
2961 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
2964 static void vpush_tokc(int t
)
2968 vsetc(&type
, VT_CONST
, &tokc
);
2971 static void unary(void)
2973 int n
, t
, align
, size
, r
;
2978 /* XXX: GCC 2.95.3 does not generate a table although it should be
2992 vpush_tokc(VT_INT
| VT_UNSIGNED
);
2996 vpush_tokc(VT_LLONG
);
3000 vpush_tokc(VT_LLONG
| VT_UNSIGNED
);
3004 vpush_tokc(VT_FLOAT
);
3008 vpush_tokc(VT_DOUBLE
);
3012 vpush_tokc(VT_LDOUBLE
);
3015 case TOK___FUNCTION__
:
3017 goto tok_identifier
;
3023 /* special function name identifier */
3024 len
= strlen(funcname
) + 1;
3025 /* generate char[len] type */
3030 vpush_ref(&type
, data_section
, data_section
->data_offset
, len
);
3031 ptr
= section_ptr_add(data_section
, len
);
3032 memcpy(ptr
, funcname
, len
);
3037 #ifdef TCC_TARGET_PE
3038 t
= VT_SHORT
| VT_UNSIGNED
;
3044 /* string parsing */
3047 if (tcc_state
->warn_write_strings
)
3052 memset(&ad
, 0, sizeof(AttributeDef
));
3053 decl_initializer_alloc(&type
, &ad
, VT_CONST
, 2, 0, 0);
3058 if (parse_btype(&type
, &ad
)) {
3059 type_decl(&type
, &ad
, &n
, TYPE_ABSTRACT
);
3061 /* check ISOC99 compound literal */
3063 /* data is allocated locally by default */
3068 /* all except arrays are lvalues */
3069 if (!(type
.t
& VT_ARRAY
))
3070 r
|= lvalue_type(type
.t
);
3071 memset(&ad
, 0, sizeof(AttributeDef
));
3072 decl_initializer_alloc(&type
, &ad
, r
, 1, 0, 0);
3077 } else if (tok
== '{') {
3078 /* save all registers */
3080 /* statement expression : we do not accept break/continue
3081 inside as GCC does */
3082 block(NULL
, NULL
, NULL
, NULL
, 0, 1);
3097 /* functions names must be treated as function pointers,
3098 except for unary '&' and sizeof. Since we consider that
3099 functions are not lvalues, we only have to handle it
3100 there and in function calls. */
3101 /* arrays can also be used although they are not lvalues */
3102 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
&&
3103 !(vtop
->type
.t
& VT_ARRAY
) && !(vtop
->type
.t
& VT_LLOCAL
))
3105 mk_pointer(&vtop
->type
);
3111 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
3113 boolean
.t
= VT_BOOL
;
3115 vtop
->c
.i
= !vtop
->c
.i
;
3116 } else if ((vtop
->r
& VT_VALMASK
) == VT_CMP
)
3117 vtop
->c
.i
= vtop
->c
.i
^ 1;
3120 vseti(VT_JMP
, gtst(1, 0));
3131 /* in order to force cast, we add zero */
3133 if ((vtop
->type
.t
& VT_BTYPE
) == VT_PTR
)
3134 error("pointer not accepted for unary plus");
3144 parse_expr_type(&type
);
3148 size
= type_size(&type
, &align
);
3149 if (t
== TOK_SIZEOF
) {
3151 error("sizeof applied to an incomplete type");
3156 vtop
->type
.t
|= VT_UNSIGNED
;
3159 case TOK_builtin_types_compatible_p
:
3168 type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
3169 type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
3170 vpushi(is_compatible_types(&type1
, &type2
));
3173 case TOK_builtin_constant_p
:
3175 int saved_nocode_wanted
, res
;
3178 saved_nocode_wanted
= nocode_wanted
;
3181 res
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
3183 nocode_wanted
= saved_nocode_wanted
;
3188 case TOK_builtin_frame_address
:
3193 if (tok
!= TOK_CINT
) {
3194 error("__builtin_frame_address only takes integers");
3197 error("TCC only supports __builtin_frame_address(0)");
3203 vset(&type
, VT_LOCAL
, 0);
3206 #ifdef TCC_TARGET_X86_64
3207 case TOK_builtin_malloc
:
3209 goto tok_identifier
;
3210 case TOK_builtin_free
:
3212 goto tok_identifier
;
3229 goto tok_identifier
;
3231 /* allow to take the address of a label */
3232 if (tok
< TOK_UIDENT
)
3233 expect("label identifier");
3234 s
= label_find(tok
);
3236 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
3238 if (s
->r
== LABEL_DECLARED
)
3239 s
->r
= LABEL_FORWARD
;
3242 s
->type
.t
= VT_VOID
;
3243 mk_pointer(&s
->type
);
3244 s
->type
.t
|= VT_STATIC
;
3246 vset(&s
->type
, VT_CONST
| VT_SYM
, 0);
3255 expect("identifier");
3259 error("'%s' undeclared", get_tok_str(t
, NULL
));
3260 /* for simple function calls, we tolerate undeclared
3261 external reference to int() function */
3262 if (tcc_state
->warn_implicit_function_declaration
)
3263 warning("implicit declaration of function '%s'",
3264 get_tok_str(t
, NULL
));
3265 s
= external_global_sym(t
, &func_old_type
, 0);
3267 if ((s
->type
.t
& (VT_STATIC
| VT_INLINE
| VT_BTYPE
)) ==
3268 (VT_STATIC
| VT_INLINE
| VT_FUNC
)) {
3269 /* if referencing an inline function, then we generate a
3270 symbol to it if not already done. It will have the
3271 effect to generate code for it at the end of the
3272 compilation unit. Inline function as always
3273 generated in the text section. */
3275 put_extern_sym(s
, text_section
, 0, 0);
3276 r
= VT_SYM
| VT_CONST
;
3280 vset(&s
->type
, r
, s
->c
);
3281 /* if forward reference, we must point to s */
3282 if (vtop
->r
& VT_SYM
) {
3289 /* post operations */
3291 if (tok
== TOK_INC
|| tok
== TOK_DEC
) {
3294 } else if (tok
== '.' || tok
== TOK_ARROW
) {
3297 if (tok
== TOK_ARROW
)
3299 qualifiers
= vtop
->type
.t
& (VT_CONSTANT
| VT_VOLATILE
);
3303 /* expect pointer on structure */
3304 if ((vtop
->type
.t
& VT_BTYPE
) != VT_STRUCT
)
3305 expect("struct or union");
3309 while ((s
= s
->next
) != NULL
) {
3314 error("field not found: %s", get_tok_str(tok
& ~SYM_FIELD
, NULL
));
3315 /* add field offset to pointer */
3316 vtop
->type
= char_pointer_type
; /* change type to 'char *' */
3319 /* change type to field type, and set to lvalue */
3320 vtop
->type
= s
->type
;
3321 vtop
->type
.t
|= qualifiers
;
3322 /* an array is never an lvalue */
3323 if (!(vtop
->type
.t
& VT_ARRAY
)) {
3324 vtop
->r
|= lvalue_type(vtop
->type
.t
);
3325 /* if bound checking, the referenced pointer must be checked */
3326 if (tcc_state
->do_bounds_check
)
3327 vtop
->r
|= VT_MUSTBOUND
;
3330 } else if (tok
== '[') {
3336 } else if (tok
== '(') {
3342 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
3343 /* pointer test (no array accepted) */
3344 if ((vtop
->type
.t
& (VT_BTYPE
| VT_ARRAY
)) == VT_PTR
) {
3345 vtop
->type
= *pointed_type(&vtop
->type
);
3346 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
)
3350 expect("function pointer");
3353 vtop
->r
&= ~VT_LVAL
; /* no lvalue */
3355 /* get return type */
3358 sa
= s
->next
; /* first parameter */
3361 /* compute first implicit argument if a structure is returned */
3362 if ((s
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
3363 /* get some space for the returned structure */
3364 size
= type_size(&s
->type
, &align
);
3365 loc
= (loc
- size
) & -align
;
3367 ret
.r
= VT_LOCAL
| VT_LVAL
;
3368 /* pass it as 'int' to avoid structure arg passing
3370 vseti(VT_LOCAL
, loc
);
3375 /* return in register */
3376 if (is_float(ret
.type
.t
)) {
3377 ret
.r
= reg_fret(ret
.type
.t
);
3379 if ((ret
.type
.t
& VT_BTYPE
) == VT_LLONG
)
3388 gfunc_param_typed(s
, sa
);
3398 error("too few arguments to function");
3400 if (!nocode_wanted
) {
3401 gfunc_call(nb_args
);
3403 vtop
-= (nb_args
+ 1);
3406 vsetc(&ret
.type
, ret
.r
, &ret
.c
);
3414 static void uneq(void)
3420 (tok
>= TOK_A_MOD
&& tok
<= TOK_A_DIV
) ||
3421 tok
== TOK_A_XOR
|| tok
== TOK_A_OR
||
3422 tok
== TOK_A_SHL
|| tok
== TOK_A_SAR
) {
3437 static void expr_prod(void)
3442 while (tok
== '*' || tok
== '/' || tok
== '%') {
3450 static void expr_sum(void)
3455 while (tok
== '+' || tok
== '-') {
3463 static void expr_shift(void)
3468 while (tok
== TOK_SHL
|| tok
== TOK_SAR
) {
3476 static void expr_cmp(void)
3481 while ((tok
>= TOK_ULE
&& tok
<= TOK_GT
) ||
3482 tok
== TOK_ULT
|| tok
== TOK_UGE
) {
3490 static void expr_cmpeq(void)
3495 while (tok
== TOK_EQ
|| tok
== TOK_NE
) {
3503 static void expr_and(void)
3506 while (tok
== '&') {
3513 static void expr_xor(void)
3516 while (tok
== '^') {
3523 static void expr_or(void)
3526 while (tok
== '|') {
3533 /* XXX: fix this mess */
3534 static void expr_land_const(void)
3537 while (tok
== TOK_LAND
) {
3544 /* XXX: fix this mess */
3545 static void expr_lor_const(void)
3548 while (tok
== TOK_LOR
) {
3555 /* only used if non constant */
3556 static void expr_land(void)
3561 if (tok
== TOK_LAND
) {
3566 if (tok
!= TOK_LAND
) {
3576 static void expr_lor(void)
3581 if (tok
== TOK_LOR
) {
3586 if (tok
!= TOK_LOR
) {
3596 /* XXX: better constant handling */
3597 static void expr_eq(void)
3599 int tt
, u
, r1
, r2
, rc
, t1
, t2
, bt1
, bt2
;
3601 CType type
, type1
, type2
;
3608 boolean
.t
= VT_BOOL
;
3614 if (tok
!= ':' || !gnu_ext
) {
3629 if (vtop
!= vstack
) {
3630 /* needed to avoid having different registers saved in
3632 if (is_float(vtop
->type
.t
)) {
3634 #ifdef TCC_TARGET_X86_64
3635 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LDOUBLE
) {
3645 if (tok
== ':' && gnu_ext
) {
3653 sv
= *vtop
; /* save value to handle it later */
3654 vtop
--; /* no vpop so that FP stack is not flushed */
3662 bt1
= t1
& VT_BTYPE
;
3664 bt2
= t2
& VT_BTYPE
;
3665 /* cast operands to correct type according to ISOC rules */
3666 if (is_float(bt1
) || is_float(bt2
)) {
3667 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
3668 type
.t
= VT_LDOUBLE
;
3669 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
3674 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
3675 /* cast to biggest op */
3677 /* convert to unsigned if it does not fit in a long long */
3678 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
3679 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
3680 type
.t
|= VT_UNSIGNED
;
3681 } else if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
3682 /* XXX: test pointer compatibility */
3684 } else if (bt1
== VT_FUNC
|| bt2
== VT_FUNC
) {
3685 /* XXX: test function pointer compatibility */
3687 } else if (bt1
== VT_STRUCT
|| bt2
== VT_STRUCT
) {
3688 /* XXX: test structure compatibility */
3690 } else if (bt1
== VT_VOID
|| bt2
== VT_VOID
) {
3691 /* NOTE: as an extension, we accept void on only one side */
3694 /* integer operations */
3696 /* convert to unsigned if it does not fit in an integer */
3697 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
3698 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
3699 type
.t
|= VT_UNSIGNED
;
3702 /* now we convert second operand */
3704 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
3707 if (is_float(type
.t
)) {
3709 #ifdef TCC_TARGET_X86_64
3710 if ((type
.t
& VT_BTYPE
) == VT_LDOUBLE
) {
3714 } else if ((type
.t
& VT_BTYPE
) == VT_LLONG
) {
3715 /* for long longs, we use fixed registers to avoid having
3716 to handle a complicated move */
3721 /* this is horrible, but we must also convert first
3725 /* put again first value and cast it */
3728 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
3738 static void gexpr(void)
3749 /* parse an expression and return its type without any side effect. */
3750 static void expr_type(CType
*type
)
3752 int saved_nocode_wanted
;
3754 saved_nocode_wanted
= nocode_wanted
;
3759 nocode_wanted
= saved_nocode_wanted
;
3762 /* parse a unary expression and return its type without any side
3764 static void unary_type(CType
*type
)
3776 /* parse a constant expression and return value in vtop. */
3777 static void expr_const1(void)
3786 /* parse an integer constant and return its value. */
3787 static int expr_const(void)
3791 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
3792 expect("constant expression");
3798 /* return the label token if current token is a label, otherwise
3800 static int is_label(void)
3804 /* fast test first */
3805 if (tok
< TOK_UIDENT
)
3807 /* no need to save tokc because tok is an identifier */
3814 unget_tok(last_tok
);
3819 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
,
3820 int case_reg
, int is_expr
)
3825 /* generate line number info */
3826 if (tcc_state
->do_debug
&&
3827 (last_line_num
!= file
->line_num
|| last_ind
!= ind
)) {
3828 put_stabn(N_SLINE
, 0, file
->line_num
, ind
- func_ind
);
3830 last_line_num
= file
->line_num
;
3834 /* default return value is (void) */
3836 vtop
->type
.t
= VT_VOID
;
3839 if (tok
== TOK_IF
) {
3846 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
3848 if (c
== TOK_ELSE
) {
3852 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
3853 gsym(d
); /* patch else jmp */
3856 } else if (tok
== TOK_WHILE
) {
3864 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
3868 } else if (tok
== '{') {
3872 /* record local declaration stack position */
3874 llabel
= local_label_stack
;
3875 /* handle local labels declarations */
3876 if (tok
== TOK_LABEL
) {
3879 if (tok
< TOK_UIDENT
)
3880 expect("label identifier");
3881 label_push(&local_label_stack
, tok
, LABEL_DECLARED
);
3891 while (tok
!= '}') {
3896 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
3899 /* pop locally defined labels */
3900 label_pop(&local_label_stack
, llabel
);
3901 /* pop locally defined symbols */
3903 /* XXX: this solution makes only valgrind happy...
3904 triggered by gcc.c-torture/execute/20000917-1.c */
3906 switch(vtop
->type
.t
& VT_BTYPE
) {
3911 for(p
=vtop
->type
.ref
;p
;p
=p
->prev
)
3913 error("unsupported expression type");
3916 sym_pop(&local_stack
, s
);
3918 } else if (tok
== TOK_RETURN
) {
3922 gen_assign_cast(&func_vt
);
3923 if ((func_vt
.t
& VT_BTYPE
) == VT_STRUCT
) {
3925 /* if returning structure, must copy it to implicit
3926 first pointer arg location */
3929 size
= type_size(&func_vt
,&align
);
3932 if((vtop
->r
!= (VT_LOCAL
| VT_LVAL
) || (vtop
->c
.i
& 3))
3936 loc
= (loc
- size
) & -4;
3939 vset(&type
, VT_LOCAL
| VT_LVAL
, addr
);
3942 vset(&int_type
, VT_LOCAL
| VT_LVAL
, addr
);
3944 vtop
->type
= int_type
;
3950 vset(&type
, VT_LOCAL
| VT_LVAL
, func_vc
);
3953 /* copy structure value to pointer */
3958 } else if (is_float(func_vt
.t
)) {
3959 gv(rc_fret(func_vt
.t
));
3963 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
3966 rsym
= gjmp(rsym
); /* jmp */
3967 } else if (tok
== TOK_BREAK
) {
3970 error("cannot break");
3971 *bsym
= gjmp(*bsym
);
3974 } else if (tok
== TOK_CONTINUE
) {
3977 error("cannot continue");
3978 *csym
= gjmp(*csym
);
3981 } else if (tok
== TOK_FOR
) {
4008 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
4013 if (tok
== TOK_DO
) {
4018 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
4029 if (tok
== TOK_SWITCH
) {
4033 /* XXX: other types than integer */
4034 case_reg
= gv(RC_INT
);
4038 b
= gjmp(0); /* jump to first case */
4040 block(&a
, csym
, &b
, &c
, case_reg
, 0);
4041 /* if no default, jmp after switch */
4049 if (tok
== TOK_CASE
) {
4056 if (gnu_ext
&& tok
== TOK_DOTS
) {
4060 warning("empty case range");
4062 /* since a case is like a label, we must skip it with a jmp */
4069 *case_sym
= gtst(1, 0);
4072 *case_sym
= gtst(1, 0);
4076 *case_sym
= gtst(1, *case_sym
);
4081 goto block_after_label
;
4083 if (tok
== TOK_DEFAULT
) {
4089 error("too many 'default'");
4092 goto block_after_label
;
4094 if (tok
== TOK_GOTO
) {
4096 if (tok
== '*' && gnu_ext
) {
4100 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
)
4103 } else if (tok
>= TOK_UIDENT
) {
4104 s
= label_find(tok
);
4105 /* put forward definition if needed */
4107 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
4109 if (s
->r
== LABEL_DECLARED
)
4110 s
->r
= LABEL_FORWARD
;
4112 /* label already defined */
4113 if (s
->r
& LABEL_FORWARD
)
4114 s
->jnext
= gjmp(s
->jnext
);
4116 gjmp_addr(s
->jnext
);
4119 expect("label identifier");
4122 } else if (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
) {
4130 if (s
->r
== LABEL_DEFINED
)
4131 error("duplicate label '%s'", get_tok_str(s
->v
, NULL
));
4133 s
->r
= LABEL_DEFINED
;
4135 s
= label_push(&global_label_stack
, b
, LABEL_DEFINED
);
4138 /* we accept this, but it is a mistake */
4141 warning("deprecated use of label at end of compound statement");
4145 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
4148 /* expression case */
4163 /* t is the array or struct type. c is the array or struct
4164 address. cur_index/cur_field is the pointer to the current
4165 value. 'size_only' is true if only size info is needed (only used
4167 static void decl_designator(CType
*type
, Section
*sec
, unsigned long c
,
4168 int *cur_index
, Sym
**cur_field
,
4172 int notfirst
, index
, index_last
, align
, l
, nb_elems
, elem_size
;
4178 if (gnu_ext
&& (l
= is_label()) != 0)
4180 while (tok
== '[' || tok
== '.') {
4182 if (!(type
->t
& VT_ARRAY
))
4183 expect("array type");
4186 index
= expr_const();
4187 if (index
< 0 || (s
->c
>= 0 && index
>= s
->c
))
4188 expect("invalid index");
4189 if (tok
== TOK_DOTS
&& gnu_ext
) {
4191 index_last
= expr_const();
4192 if (index_last
< 0 ||
4193 (s
->c
>= 0 && index_last
>= s
->c
) ||
4195 expect("invalid index");
4201 *cur_index
= index_last
;
4202 type
= pointed_type(type
);
4203 elem_size
= type_size(type
, &align
);
4204 c
+= index
* elem_size
;
4205 /* NOTE: we only support ranges for last designator */
4206 nb_elems
= index_last
- index
+ 1;
4207 if (nb_elems
!= 1) {
4216 if ((type
->t
& VT_BTYPE
) != VT_STRUCT
)
4217 expect("struct/union type");
4230 /* XXX: fix this mess by using explicit storage field */
4232 type1
.t
|= (type
->t
& ~VT_TYPE
);
4246 if (type
->t
& VT_ARRAY
) {
4248 type
= pointed_type(type
);
4249 c
+= index
* type_size(type
, &align
);
4253 error("too many field init");
4254 /* XXX: fix this mess by using explicit storage field */
4256 type1
.t
|= (type
->t
& ~VT_TYPE
);
4261 decl_initializer(type
, sec
, c
, 0, size_only
);
4263 /* XXX: make it more general */
4264 if (!size_only
&& nb_elems
> 1) {
4265 unsigned long c_end
;
4270 error("range init not supported yet for dynamic storage");
4271 c_end
= c
+ nb_elems
* elem_size
;
4272 if (c_end
> sec
->data_allocated
)
4273 section_realloc(sec
, c_end
);
4274 src
= sec
->data
+ c
;
4276 for(i
= 1; i
< nb_elems
; i
++) {
4278 memcpy(dst
, src
, elem_size
);
4284 #define EXPR_CONST 1
4287 /* store a value or an expression directly in global data or in local array */
4288 static void init_putv(CType
*type
, Section
*sec
, unsigned long c
,
4289 int v
, int expr_type
)
4291 int saved_global_expr
, bt
, bit_pos
, bit_size
;
4293 unsigned long long bit_mask
;
4301 /* compound literals must be allocated globally in this case */
4302 saved_global_expr
= global_expr
;
4305 global_expr
= saved_global_expr
;
4306 /* NOTE: symbols are accepted */
4307 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) != VT_CONST
)
4308 error("initializer element is not constant");
4316 dtype
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
4319 /* XXX: not portable */
4320 /* XXX: generate error if incorrect relocation */
4321 gen_assign_cast(&dtype
);
4322 bt
= type
->t
& VT_BTYPE
;
4323 /* we'll write at most 12 bytes */
4324 if (c
+ 12 > sec
->data_allocated
) {
4325 section_realloc(sec
, c
+ 12);
4327 ptr
= sec
->data
+ c
;
4328 /* XXX: make code faster ? */
4329 if (!(type
->t
& VT_BITFIELD
)) {
4334 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4335 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
4336 bit_mask
= (1LL << bit_size
) - 1;
4338 if ((vtop
->r
& VT_SYM
) &&
4344 (bt
== VT_INT
&& bit_size
!= 32)))
4345 error("initializer element is not computable at load time");
4348 vtop
->c
.i
= (vtop
->c
.i
!= 0);
4350 *(char *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
4353 *(short *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
4356 *(double *)ptr
= vtop
->c
.d
;
4359 *(long double *)ptr
= vtop
->c
.ld
;
4362 *(long long *)ptr
|= (vtop
->c
.ll
& bit_mask
) << bit_pos
;
4365 if (vtop
->r
& VT_SYM
) {
4366 greloc(sec
, vtop
->sym
, c
, R_DATA_PTR
);
4368 *(int *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
4373 vset(&dtype
, VT_LOCAL
|VT_LVAL
, c
);
4380 /* put zeros for variable based init */
4381 static void init_putz(CType
*t
, Section
*sec
, unsigned long c
, int size
)
4384 /* nothing to do because globals are already set to zero */
4386 vpush_global_sym(&func_old_type
, TOK_memset
);
4394 /* 't' contains the type and storage info. 'c' is the offset of the
4395 object in section 'sec'. If 'sec' is NULL, it means stack based
4396 allocation. 'first' is true if array '{' must be read (multi
4397 dimension implicit array init handling). 'size_only' is true if
4398 size only evaluation is wanted (only for arrays). */
4399 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
4400 int first
, int size_only
)
4402 int index
, array_length
, n
, no_oblock
, nb
, parlevel
, i
;
4403 int size1
, align1
, expr_type
;
4407 if (type
->t
& VT_ARRAY
) {
4411 t1
= pointed_type(type
);
4412 size1
= type_size(t1
, &align1
);
4415 if ((first
&& tok
!= TOK_LSTR
&& tok
!= TOK_STR
) ||
4421 /* only parse strings here if correct type (otherwise: handle
4422 them as ((w)char *) expressions */
4423 if ((tok
== TOK_LSTR
&&
4424 #ifdef TCC_TARGET_PE
4425 (t1
->t
& VT_BTYPE
) == VT_SHORT
&& (t1
->t
& VT_UNSIGNED
)
4427 (t1
->t
& VT_BTYPE
) == VT_INT
4429 ) || (tok
== TOK_STR
&& (t1
->t
& VT_BTYPE
) == VT_BYTE
)) {
4430 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
4435 /* compute maximum number of chars wanted */
4437 cstr_len
= cstr
->size
;
4439 cstr_len
= cstr
->size
/ sizeof(nwchar_t
);
4442 if (n
>= 0 && nb
> (n
- array_length
))
4443 nb
= n
- array_length
;
4446 warning("initializer-string for array is too long");
4447 /* in order to go faster for common case (char
4448 string in global variable, we handle it
4450 if (sec
&& tok
== TOK_STR
&& size1
== 1) {
4451 memcpy(sec
->data
+ c
+ array_length
, cstr
->data
, nb
);
4455 ch
= ((unsigned char *)cstr
->data
)[i
];
4457 ch
= ((nwchar_t
*)cstr
->data
)[i
];
4458 init_putv(t1
, sec
, c
+ (array_length
+ i
) * size1
,
4466 /* only add trailing zero if enough storage (no
4467 warning in this case since it is standard) */
4468 if (n
< 0 || array_length
< n
) {
4470 init_putv(t1
, sec
, c
+ (array_length
* size1
), 0, EXPR_VAL
);
4476 while (tok
!= '}') {
4477 decl_designator(type
, sec
, c
, &index
, NULL
, size_only
);
4478 if (n
>= 0 && index
>= n
)
4479 error("index too large");
4480 /* must put zero in holes (note that doing it that way
4481 ensures that it even works with designators) */
4482 if (!size_only
&& array_length
< index
) {
4483 init_putz(t1
, sec
, c
+ array_length
* size1
,
4484 (index
- array_length
) * size1
);
4487 if (index
> array_length
)
4488 array_length
= index
;
4489 /* special test for multi dimensional arrays (may not
4490 be strictly correct if designators are used at the
4492 if (index
>= n
&& no_oblock
)
4501 /* put zeros at the end */
4502 if (!size_only
&& n
>= 0 && array_length
< n
) {
4503 init_putz(t1
, sec
, c
+ array_length
* size1
,
4504 (n
- array_length
) * size1
);
4506 /* patch type size if needed */
4508 s
->c
= array_length
;
4509 } else if ((type
->t
& VT_BTYPE
) == VT_STRUCT
&&
4510 (sec
|| !first
|| tok
== '{')) {
4513 /* NOTE: the previous test is a specific case for automatic
4514 struct/union init */
4515 /* XXX: union needs only one init */
4517 /* XXX: this test is incorrect for local initializers
4518 beginning with ( without {. It would be much more difficult
4519 to do it correctly (ideally, the expression parser should
4520 be used in all cases) */
4526 while (tok
== '(') {
4530 if (!parse_btype(&type1
, &ad1
))
4532 type_decl(&type1
, &ad1
, &n
, TYPE_ABSTRACT
);
4534 if (!is_assignable_types(type
, &type1
))
4535 error("invalid type for cast");
4540 if (first
|| tok
== '{') {
4549 while (tok
!= '}') {
4550 decl_designator(type
, sec
, c
, NULL
, &f
, size_only
);
4552 if (!size_only
&& array_length
< index
) {
4553 init_putz(type
, sec
, c
+ array_length
,
4554 index
- array_length
);
4556 index
= index
+ type_size(&f
->type
, &align1
);
4557 if (index
> array_length
)
4558 array_length
= index
;
4560 /* gr: skip fields from same union - ugly. */
4562 ///printf("index: %2d %08x -- %2d %08x\n", f->c, f->type.t, f->next->c, f->next->type.t);
4563 /* test for same offset */
4564 if (f
->next
->c
!= f
->c
)
4566 /* if yes, test for bitfield shift */
4567 if ((f
->type
.t
& VT_BITFIELD
) && (f
->next
->type
.t
& VT_BITFIELD
)) {
4568 int bit_pos_1
= (f
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4569 int bit_pos_2
= (f
->next
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4570 //printf("bitfield %d %d\n", bit_pos_1, bit_pos_2);
4571 if (bit_pos_1
!= bit_pos_2
)
4578 if (no_oblock
&& f
== NULL
)
4584 /* put zeros at the end */
4585 if (!size_only
&& array_length
< n
) {
4586 init_putz(type
, sec
, c
+ array_length
,
4595 } else if (tok
== '{') {
4597 decl_initializer(type
, sec
, c
, first
, size_only
);
4599 } else if (size_only
) {
4600 /* just skip expression */
4602 while ((parlevel
> 0 || (tok
!= '}' && tok
!= ',')) &&
4606 else if (tok
== ')')
4611 /* currently, we always use constant expression for globals
4612 (may change for scripting case) */
4613 expr_type
= EXPR_CONST
;
4615 expr_type
= EXPR_ANY
;
4616 init_putv(type
, sec
, c
, 0, expr_type
);
4620 /* parse an initializer for type 't' if 'has_init' is non zero, and
4621 allocate space in local or global data space ('r' is either
4622 VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
4623 variable 'v' of scope 'scope' is declared before initializers are
4624 parsed. If 'v' is zero, then a reference to the new object is put
4625 in the value stack. If 'has_init' is 2, a special parsing is done
4626 to handle string constants. */
4627 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
4628 int has_init
, int v
, int scope
)
4630 int size
, align
, addr
, data_offset
;
4632 ParseState saved_parse_state
= {0};
4633 TokenString init_str
;
4636 size
= type_size(type
, &align
);
4637 /* If unknown size, we must evaluate it before
4638 evaluating initializers because
4639 initializers can generate global data too
4640 (e.g. string pointers or ISOC99 compound
4641 literals). It also simplifies local
4642 initializers handling */
4643 tok_str_new(&init_str
);
4646 error("unknown type size");
4647 /* get all init string */
4648 if (has_init
== 2) {
4649 /* only get strings */
4650 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
4651 tok_str_add_tok(&init_str
);
4656 while (level
> 0 || (tok
!= ',' && tok
!= ';')) {
4658 error("unexpected end of file in initializer");
4659 tok_str_add_tok(&init_str
);
4662 else if (tok
== '}') {
4672 tok_str_add(&init_str
, -1);
4673 tok_str_add(&init_str
, 0);
4676 save_parse_state(&saved_parse_state
);
4678 macro_ptr
= init_str
.str
;
4680 decl_initializer(type
, NULL
, 0, 1, 1);
4681 /* prepare second initializer parsing */
4682 macro_ptr
= init_str
.str
;
4685 /* if still unknown size, error */
4686 size
= type_size(type
, &align
);
4688 error("unknown type size");
4690 /* take into account specified alignment if bigger */
4692 if (ad
->aligned
> align
)
4693 align
= ad
->aligned
;
4694 } else if (ad
->packed
) {
4697 if ((r
& VT_VALMASK
) == VT_LOCAL
) {
4699 if (tcc_state
->do_bounds_check
&& (type
->t
& VT_ARRAY
))
4701 loc
= (loc
- size
) & -align
;
4703 /* handles bounds */
4704 /* XXX: currently, since we do only one pass, we cannot track
4705 '&' operators, so we add only arrays */
4706 if (tcc_state
->do_bounds_check
&& (type
->t
& VT_ARRAY
)) {
4707 unsigned long *bounds_ptr
;
4708 /* add padding between regions */
4710 /* then add local bound info */
4711 bounds_ptr
= section_ptr_add(lbounds_section
, 2 * sizeof(unsigned long));
4712 bounds_ptr
[0] = addr
;
4713 bounds_ptr
[1] = size
;
4716 /* local variable */
4717 sym_push(v
, type
, r
, addr
);
4719 /* push local reference */
4720 vset(type
, r
, addr
);
4726 if (v
&& scope
== VT_CONST
) {
4727 /* see if the symbol was already defined */
4730 if (!is_compatible_types(&sym
->type
, type
))
4731 error("incompatible types for redefinition of '%s'",
4732 get_tok_str(v
, NULL
));
4733 if (sym
->type
.t
& VT_EXTERN
) {
4734 /* if the variable is extern, it was not allocated */
4735 sym
->type
.t
&= ~VT_EXTERN
;
4736 /* set array size if it was ommited in extern
4738 if ((sym
->type
.t
& VT_ARRAY
) &&
4739 sym
->type
.ref
->c
< 0 &&
4741 sym
->type
.ref
->c
= type
->ref
->c
;
4743 /* we accept several definitions of the same
4744 global variable. this is tricky, because we
4745 must play with the SHN_COMMON type of the symbol */
4746 /* XXX: should check if the variable was already
4747 initialized. It is incorrect to initialized it
4749 /* no init data, we won't add more to the symbol */
4756 /* allocate symbol in corresponding section */
4761 else if (tcc_state
->nocommon
)
4765 data_offset
= sec
->data_offset
;
4766 data_offset
= (data_offset
+ align
- 1) & -align
;
4768 /* very important to increment global pointer at this time
4769 because initializers themselves can create new initializers */
4770 data_offset
+= size
;
4771 /* add padding if bound check */
4772 if (tcc_state
->do_bounds_check
)
4774 sec
->data_offset
= data_offset
;
4775 /* allocate section space to put the data */
4776 if (sec
->sh_type
!= SHT_NOBITS
&&
4777 data_offset
> sec
->data_allocated
)
4778 section_realloc(sec
, data_offset
);
4779 /* align section if needed */
4780 if (align
> sec
->sh_addralign
)
4781 sec
->sh_addralign
= align
;
4783 addr
= 0; /* avoid warning */
4787 if (scope
!= VT_CONST
|| !sym
) {
4788 sym
= sym_push(v
, type
, r
| VT_SYM
, 0);
4790 /* update symbol definition */
4792 put_extern_sym(sym
, sec
, addr
, size
);
4795 /* put a common area */
4796 put_extern_sym(sym
, NULL
, align
, size
);
4797 /* XXX: find a nicer way */
4798 esym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
];
4799 esym
->st_shndx
= SHN_COMMON
;
4804 /* push global reference */
4805 sym
= get_sym_ref(type
, sec
, addr
, size
);
4807 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
4811 /* handles bounds now because the symbol must be defined
4812 before for the relocation */
4813 if (tcc_state
->do_bounds_check
) {
4814 unsigned long *bounds_ptr
;
4816 greloc(bounds_section
, sym
, bounds_section
->data_offset
, R_DATA_PTR
);
4817 /* then add global bound info */
4818 bounds_ptr
= section_ptr_add(bounds_section
, 2 * sizeof(long));
4819 bounds_ptr
[0] = 0; /* relocated */
4820 bounds_ptr
[1] = size
;
4824 decl_initializer(type
, sec
, addr
, 1, 0);
4825 /* restore parse state if needed */
4827 tok_str_free(init_str
.str
);
4828 restore_parse_state(&saved_parse_state
);
4834 void put_func_debug(Sym
*sym
)
4839 /* XXX: we put here a dummy type */
4840 snprintf(buf
, sizeof(buf
), "%s:%c1",
4841 funcname
, sym
->type
.t
& VT_STATIC
? 'f' : 'F');
4842 put_stabs_r(buf
, N_FUN
, 0, file
->line_num
, 0,
4843 cur_text_section
, sym
->c
);
4844 /* //gr gdb wants a line at the function */
4845 put_stabn(N_SLINE
, 0, file
->line_num
, 0);
4850 /* parse an old style function declaration list */
4851 /* XXX: check multiple parameter */
4852 static void func_decl_list(Sym
*func_sym
)
4859 /* parse each declaration */
4860 while (tok
!= '{' && tok
!= ';' && tok
!= ',' && tok
!= TOK_EOF
) {
4861 if (!parse_btype(&btype
, &ad
))
4862 expect("declaration list");
4863 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
4864 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
4866 /* we accept no variable after */
4870 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
4871 /* find parameter in function parameter list */
4874 if ((s
->v
& ~SYM_FIELD
) == v
)
4878 error("declaration for parameter '%s' but no such parameter",
4879 get_tok_str(v
, NULL
));
4881 /* check that no storage specifier except 'register' was given */
4882 if (type
.t
& VT_STORAGE
)
4883 error("storage class specified for '%s'", get_tok_str(v
, NULL
));
4884 convert_parameter_type(&type
);
4885 /* we can add the type (NOTE: it could be local to the function) */
4887 /* accept other parameters */
4898 /* parse a function defined by symbol 'sym' and generate its code in
4899 'cur_text_section' */
4900 static void gen_function(Sym
*sym
)
4902 int saved_nocode_wanted
= nocode_wanted
;
4904 ind
= cur_text_section
->data_offset
;
4905 /* NOTE: we patch the symbol size later */
4906 put_extern_sym(sym
, cur_text_section
, ind
, 0);
4907 funcname
= get_tok_str(sym
->v
, NULL
);
4909 /* put debug symbol */
4910 if (tcc_state
->do_debug
)
4911 put_func_debug(sym
);
4912 /* push a dummy symbol to enable local sym storage */
4913 sym_push2(&local_stack
, SYM_FIELD
, 0, 0);
4914 gfunc_prolog(&sym
->type
);
4916 block(NULL
, NULL
, NULL
, NULL
, 0, 0);
4919 cur_text_section
->data_offset
= ind
;
4920 label_pop(&global_label_stack
, NULL
);
4921 sym_pop(&local_stack
, NULL
); /* reset local stack */
4922 /* end of function */
4923 /* patch symbol size */
4924 ((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
].st_size
=
4926 if (tcc_state
->do_debug
) {
4927 put_stabn(N_FUN
, 0, 0, ind
- func_ind
);
4929 /* It's better to crash than to generate wrong code */
4930 cur_text_section
= NULL
;
4931 funcname
= ""; /* for safety */
4932 func_vt
.t
= VT_VOID
; /* for safety */
4933 ind
= 0; /* for safety */
4934 nocode_wanted
= saved_nocode_wanted
;
4937 static void gen_inline_functions(void)
4940 int *str
, inline_generated
, i
;
4941 struct InlineFunc
*fn
;
4943 /* iterate while inline function are referenced */
4945 inline_generated
= 0;
4946 for (i
= 0; i
< tcc_state
->nb_inline_fns
; ++i
) {
4947 fn
= tcc_state
->inline_fns
[i
];
4949 if (sym
&& sym
->c
) {
4950 /* the function was used: generate its code and
4951 convert it to a normal function */
4952 str
= fn
->token_str
;
4955 strcpy(file
->filename
, fn
->filename
);
4956 sym
->r
= VT_SYM
| VT_CONST
;
4957 sym
->type
.t
&= ~VT_INLINE
;
4961 cur_text_section
= text_section
;
4963 macro_ptr
= NULL
; /* fail safe */
4965 inline_generated
= 1;
4968 if (!inline_generated
)
4971 for (i
= 0; i
< tcc_state
->nb_inline_fns
; ++i
) {
4972 fn
= tcc_state
->inline_fns
[i
];
4973 str
= fn
->token_str
;
4976 dynarray_reset(&tcc_state
->inline_fns
, &tcc_state
->nb_inline_fns
);
4979 /* 'l' is VT_LOCAL or VT_CONST to define default storage type */
4980 static void decl(int l
)
4988 if (!parse_btype(&btype
, &ad
)) {
4989 /* skip redundant ';' */
4990 /* XXX: find more elegant solution */
4995 if (l
== VT_CONST
&&
4996 (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
)) {
4997 /* global asm block */
5001 /* special test for old K&R protos without explicit int
5002 type. Only accepted when defining global data */
5003 if (l
== VT_LOCAL
|| tok
< TOK_DEFINE
)
5007 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
5008 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
5010 /* we accept no variable after */
5014 while (1) { /* iterate thru each declaration */
5016 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
5020 type_to_str(buf
, sizeof(buf
), t
, get_tok_str(v
, NULL
));
5021 printf("type = '%s'\n", buf
);
5024 if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
5025 /* if old style function prototype, we accept a
5028 if (sym
->c
== FUNC_OLD
)
5029 func_decl_list(sym
);
5034 error("cannot use local functions");
5035 if ((type
.t
& VT_BTYPE
) != VT_FUNC
)
5036 expect("function definition");
5038 /* reject abstract declarators in function definition */
5040 while ((sym
= sym
->next
) != NULL
)
5041 if (!(sym
->v
& ~SYM_FIELD
))
5042 expect("identifier");
5044 /* XXX: cannot do better now: convert extern line to static inline */
5045 if ((type
.t
& (VT_EXTERN
| VT_INLINE
)) == (VT_EXTERN
| VT_INLINE
))
5046 type
.t
= (type
.t
& ~VT_EXTERN
) | VT_STATIC
;
5050 if ((sym
->type
.t
& VT_BTYPE
) != VT_FUNC
)
5053 r
= sym
->type
.ref
->r
;
5054 /* use func_call from prototype if not defined */
5055 if (FUNC_CALL(r
) != FUNC_CDECL
5056 && FUNC_CALL(type
.ref
->r
) == FUNC_CDECL
)
5057 FUNC_CALL(type
.ref
->r
) = FUNC_CALL(r
);
5059 /* use export from prototype */
5061 FUNC_EXPORT(type
.ref
->r
) = 1;
5063 /* use static from prototype */
5064 if (sym
->type
.t
& VT_STATIC
)
5065 type
.t
= (type
.t
& ~VT_EXTERN
) | VT_STATIC
;
5067 if (!is_compatible_types(&sym
->type
, &type
)) {
5069 error("incompatible types for redefinition of '%s'",
5070 get_tok_str(v
, NULL
));
5072 /* if symbol is already defined, then put complete type */
5075 /* put function symbol */
5076 sym
= global_identifier_push(v
, type
.t
, 0);
5077 sym
->type
.ref
= type
.ref
;
5080 /* static inline functions are just recorded as a kind
5081 of macro. Their code will be emitted at the end of
5082 the compilation unit only if they are used */
5083 if ((type
.t
& (VT_INLINE
| VT_STATIC
)) ==
5084 (VT_INLINE
| VT_STATIC
)) {
5085 TokenString func_str
;
5087 struct InlineFunc
*fn
;
5088 const char *filename
;
5090 tok_str_new(&func_str
);
5096 error("unexpected end of file");
5097 tok_str_add_tok(&func_str
);
5102 } else if (t
== '}') {
5104 if (block_level
== 0)
5108 tok_str_add(&func_str
, -1);
5109 tok_str_add(&func_str
, 0);
5110 filename
= file
? file
->filename
: "";
5111 fn
= tcc_malloc(sizeof *fn
+ strlen(filename
));
5112 strcpy(fn
->filename
, filename
);
5114 fn
->token_str
= func_str
.str
;
5115 dynarray_add((void ***)&tcc_state
->inline_fns
, &tcc_state
->nb_inline_fns
, fn
);
5118 /* compute text section */
5119 cur_text_section
= ad
.section
;
5120 if (!cur_text_section
)
5121 cur_text_section
= text_section
;
5122 sym
->r
= VT_SYM
| VT_CONST
;
5127 if (btype
.t
& VT_TYPEDEF
) {
5128 /* save typedefed type */
5129 /* XXX: test storage specifiers ? */
5130 sym
= sym_push(v
, &type
, INT_ATTR(&ad
), 0);
5131 sym
->type
.t
|= VT_TYPEDEF
;
5132 } else if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
5133 /* external function definition */
5134 /* specific case for func_call attribute */
5135 type
.ref
->r
= INT_ATTR(&ad
);
5136 external_sym(v
, &type
, 0);
5138 /* not lvalue if array */
5140 if (!(type
.t
& VT_ARRAY
))
5141 r
|= lvalue_type(type
.t
);
5142 has_init
= (tok
== '=');
5143 if ((btype
.t
& VT_EXTERN
) ||
5144 ((type
.t
& VT_ARRAY
) && (type
.t
& VT_STATIC
) &&
5145 !has_init
&& l
== VT_CONST
&& type
.ref
->c
< 0)) {
5146 /* external variable */
5147 /* NOTE: as GCC, uninitialized global static
5148 arrays of null size are considered as
5150 #ifdef TCC_TARGET_PE
5152 type
.t
|= VT_IMPORT
;
5154 external_sym(v
, &type
, r
);
5156 type
.t
|= (btype
.t
& VT_STATIC
); /* Retain "static". */
5157 if (type
.t
& VT_STATIC
)
5163 decl_initializer_alloc(&type
, &ad
, r
,