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 else if (sbt
!= VT_LLONG
)
1547 vtop
->c
.ll
= vtop
->c
.i
;
1549 if (dbt
== (VT_LLONG
|VT_UNSIGNED
))
1550 vtop
->c
.ull
= vtop
->c
.ll
;
1551 else if (dbt
== VT_BOOL
)
1552 vtop
->c
.i
= (vtop
->c
.ll
!= 0);
1553 else if (dbt
!= VT_LLONG
) {
1555 if ((dbt
& VT_BTYPE
) == VT_BYTE
)
1557 else if ((dbt
& VT_BTYPE
) == VT_SHORT
)
1560 if(dbt
& VT_UNSIGNED
)
1561 vtop
->c
.ui
= ((unsigned int)vtop
->c
.ll
<< s
) >> s
;
1563 vtop
->c
.i
= ((int)vtop
->c
.ll
<< s
) >> s
;
1566 } else if (p
&& dbt
== VT_BOOL
) {
1569 } else if (!nocode_wanted
) {
1570 /* non constant case: generate code */
1572 /* convert from fp to fp */
1575 /* convert int to fp */
1578 /* convert fp to int */
1579 if (dbt
== VT_BOOL
) {
1583 /* we handle char/short/etc... with generic code */
1584 if (dbt
!= (VT_INT
| VT_UNSIGNED
) &&
1585 dbt
!= (VT_LLONG
| VT_UNSIGNED
) &&
1589 if (dbt
== VT_INT
&& (type
->t
& (VT_BTYPE
| VT_UNSIGNED
)) != dbt
) {
1590 /* additional cast for char/short... */
1595 #ifndef TCC_TARGET_X86_64
1596 } else if ((dbt
& VT_BTYPE
) == VT_LLONG
) {
1597 if ((sbt
& VT_BTYPE
) != VT_LLONG
) {
1598 /* scalar to long long */
1599 /* machine independent conversion */
1601 /* generate high word */
1602 if (sbt
== (VT_INT
| VT_UNSIGNED
)) {
1606 if (sbt
== VT_PTR
) {
1607 /* cast from pointer to int before we apply
1608 shift operation, which pointers don't support*/
1609 gen_cast(&int_type
);
1615 /* patch second register */
1616 vtop
[-1].r2
= vtop
->r
;
1620 } else if ((dbt
& VT_BTYPE
) == VT_LLONG
||
1621 (dbt
& VT_BTYPE
) == VT_PTR
) {
1622 /* XXX: not sure if this is perfect... need more tests */
1623 if ((sbt
& VT_BTYPE
) != VT_LLONG
) {
1625 if (sbt
!= (VT_INT
| VT_UNSIGNED
) &&
1626 sbt
!= VT_PTR
&& sbt
!= VT_FUNC
) {
1627 /* x86_64 specific: movslq */
1629 o(0xc0 + (REG_VALUE(r
) << 3) + REG_VALUE(r
));
1633 } else if (dbt
== VT_BOOL
) {
1634 /* scalar to bool */
1637 } else if ((dbt
& VT_BTYPE
) == VT_BYTE
||
1638 (dbt
& VT_BTYPE
) == VT_SHORT
) {
1639 if (sbt
== VT_PTR
) {
1640 vtop
->type
.t
= VT_INT
;
1641 warning("nonportable conversion from pointer to char/short");
1643 force_charshort_cast(dbt
);
1644 } else if ((dbt
& VT_BTYPE
) == VT_INT
) {
1646 if (sbt
== VT_LLONG
) {
1647 /* from long long: just take low order word */
1651 /* if lvalue and single word type, nothing to do because
1652 the lvalue already contains the real type size (see
1653 VT_LVAL_xxx constants) */
1656 } else if ((dbt
& VT_BTYPE
) == VT_PTR
&& !(vtop
->r
& VT_LVAL
)) {
1657 /* if we are casting between pointer types,
1658 we must update the VT_LVAL_xxx size */
1659 vtop
->r
= (vtop
->r
& ~VT_LVAL_TYPE
)
1660 | (lvalue_type(type
->ref
->type
.t
) & VT_LVAL_TYPE
);
1665 /* return type size. Put alignment at 'a' */
1666 static int type_size(CType
*type
, int *a
)
1671 bt
= type
->t
& VT_BTYPE
;
1672 if (bt
== VT_STRUCT
) {
1677 } else if (bt
== VT_PTR
) {
1678 if (type
->t
& VT_ARRAY
) {
1682 ts
= type_size(&s
->type
, a
);
1684 if (ts
< 0 && s
->c
< 0)
1692 } else if (bt
== VT_LDOUBLE
) {
1694 return LDOUBLE_SIZE
;
1695 } else if (bt
== VT_DOUBLE
|| bt
== VT_LLONG
) {
1696 #ifdef TCC_TARGET_I386
1697 #ifdef TCC_TARGET_PE
1702 #elif defined(TCC_TARGET_ARM)
1712 } else if (bt
== VT_INT
|| bt
== VT_ENUM
|| bt
== VT_FLOAT
) {
1715 } else if (bt
== VT_SHORT
) {
1719 /* char, void, function, _Bool */
1725 /* return the pointed type of t */
1726 static inline CType
*pointed_type(CType
*type
)
1728 return &type
->ref
->type
;
1731 /* modify type so that its it is a pointer to type. */
1732 static void mk_pointer(CType
*type
)
1735 s
= sym_push(SYM_FIELD
, type
, 0, -1);
1736 type
->t
= VT_PTR
| (type
->t
& ~VT_TYPE
);
1740 /* compare function types. OLD functions match any new functions */
1741 static int is_compatible_func(CType
*type1
, CType
*type2
)
1747 if (!is_compatible_types(&s1
->type
, &s2
->type
))
1749 /* check func_call */
1750 if (FUNC_CALL(s1
->r
) != FUNC_CALL(s2
->r
))
1752 /* XXX: not complete */
1753 if (s1
->c
== FUNC_OLD
|| s2
->c
== FUNC_OLD
)
1757 while (s1
!= NULL
) {
1760 if (!is_compatible_parameter_types(&s1
->type
, &s2
->type
))
1770 /* return true if type1 and type2 are the same. If unqualified is
1771 true, qualifiers on the types are ignored.
1773 - enums are not checked as gcc __builtin_types_compatible_p ()
1775 static int compare_types(CType
*type1
, CType
*type2
, int unqualified
)
1779 t1
= type1
->t
& VT_TYPE
;
1780 t2
= type2
->t
& VT_TYPE
;
1782 /* strip qualifiers before comparing */
1783 t1
&= ~(VT_CONSTANT
| VT_VOLATILE
);
1784 t2
&= ~(VT_CONSTANT
| VT_VOLATILE
);
1786 /* XXX: bitfields ? */
1789 /* test more complicated cases */
1790 bt1
= t1
& VT_BTYPE
;
1791 if (bt1
== VT_PTR
) {
1792 type1
= pointed_type(type1
);
1793 type2
= pointed_type(type2
);
1794 return is_compatible_types(type1
, type2
);
1795 } else if (bt1
== VT_STRUCT
) {
1796 return (type1
->ref
== type2
->ref
);
1797 } else if (bt1
== VT_FUNC
) {
1798 return is_compatible_func(type1
, type2
);
1804 /* return true if type1 and type2 are exactly the same (including
1807 static int is_compatible_types(CType
*type1
, CType
*type2
)
1809 return compare_types(type1
,type2
,0);
1812 /* return true if type1 and type2 are the same (ignoring qualifiers).
1814 static int is_compatible_parameter_types(CType
*type1
, CType
*type2
)
1816 return compare_types(type1
,type2
,1);
1819 /* print a type. If 'varstr' is not NULL, then the variable is also
1820 printed in the type */
1822 /* XXX: add array and function pointers */
1823 void type_to_str(char *buf
, int buf_size
,
1824 CType
*type
, const char *varstr
)
1831 t
= type
->t
& VT_TYPE
;
1834 if (t
& VT_CONSTANT
)
1835 pstrcat(buf
, buf_size
, "const ");
1836 if (t
& VT_VOLATILE
)
1837 pstrcat(buf
, buf_size
, "volatile ");
1838 if (t
& VT_UNSIGNED
)
1839 pstrcat(buf
, buf_size
, "unsigned ");
1869 tstr
= "long double";
1871 pstrcat(buf
, buf_size
, tstr
);
1875 if (bt
== VT_STRUCT
)
1879 pstrcat(buf
, buf_size
, tstr
);
1880 v
= type
->ref
->v
& ~SYM_STRUCT
;
1881 if (v
>= SYM_FIRST_ANOM
)
1882 pstrcat(buf
, buf_size
, "<anonymous>");
1884 pstrcat(buf
, buf_size
, get_tok_str(v
, NULL
));
1888 type_to_str(buf
, buf_size
, &s
->type
, varstr
);
1889 pstrcat(buf
, buf_size
, "(");
1891 while (sa
!= NULL
) {
1892 type_to_str(buf1
, sizeof(buf1
), &sa
->type
, NULL
);
1893 pstrcat(buf
, buf_size
, buf1
);
1896 pstrcat(buf
, buf_size
, ", ");
1898 pstrcat(buf
, buf_size
, ")");
1902 pstrcpy(buf1
, sizeof(buf1
), "*");
1904 pstrcat(buf1
, sizeof(buf1
), varstr
);
1905 type_to_str(buf
, buf_size
, &s
->type
, buf1
);
1909 pstrcat(buf
, buf_size
, " ");
1910 pstrcat(buf
, buf_size
, varstr
);
1915 /* verify type compatibility to store vtop in 'dt' type, and generate
1917 static void gen_assign_cast(CType
*dt
)
1919 CType
*st
, *type1
, *type2
, tmp_type1
, tmp_type2
;
1920 char buf1
[256], buf2
[256];
1923 st
= &vtop
->type
; /* source type */
1924 dbt
= dt
->t
& VT_BTYPE
;
1925 sbt
= st
->t
& VT_BTYPE
;
1926 if (dt
->t
& VT_CONSTANT
)
1927 warning("assignment of read-only location");
1930 /* special cases for pointers */
1931 /* '0' can also be a pointer */
1932 if (is_null_pointer(vtop
))
1934 /* accept implicit pointer to integer cast with warning */
1935 if (is_integer_btype(sbt
)) {
1936 warning("assignment makes pointer from integer without a cast");
1939 type1
= pointed_type(dt
);
1940 /* a function is implicitely a function pointer */
1941 if (sbt
== VT_FUNC
) {
1942 if ((type1
->t
& VT_BTYPE
) != VT_VOID
&&
1943 !is_compatible_types(pointed_type(dt
), st
))
1944 warning("assignment from incompatible pointer type");
1949 type2
= pointed_type(st
);
1950 if ((type1
->t
& VT_BTYPE
) == VT_VOID
||
1951 (type2
->t
& VT_BTYPE
) == VT_VOID
) {
1952 /* void * can match anything */
1954 /* exact type match, except for unsigned */
1957 tmp_type1
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
1958 tmp_type2
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
1959 if (!is_compatible_types(&tmp_type1
, &tmp_type2
))
1960 warning("assignment from incompatible pointer type");
1962 /* check const and volatile */
1963 if ((!(type1
->t
& VT_CONSTANT
) && (type2
->t
& VT_CONSTANT
)) ||
1964 (!(type1
->t
& VT_VOLATILE
) && (type2
->t
& VT_VOLATILE
)))
1965 warning("assignment discards qualifiers from pointer target type");
1971 if (sbt
== VT_PTR
|| sbt
== VT_FUNC
) {
1972 warning("assignment makes integer from pointer without a cast");
1974 /* XXX: more tests */
1979 tmp_type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
1980 tmp_type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
1981 if (!is_compatible_types(&tmp_type1
, &tmp_type2
)) {
1983 type_to_str(buf1
, sizeof(buf1
), st
, NULL
);
1984 type_to_str(buf2
, sizeof(buf2
), dt
, NULL
);
1985 error("cannot cast '%s' to '%s'", buf1
, buf2
);
1993 /* store vtop in lvalue pushed on stack */
1996 int sbt
, dbt
, ft
, r
, t
, size
, align
, bit_size
, bit_pos
, rc
, delayed_cast
;
1998 ft
= vtop
[-1].type
.t
;
1999 sbt
= vtop
->type
.t
& VT_BTYPE
;
2000 dbt
= ft
& VT_BTYPE
;
2001 if (((sbt
== VT_INT
|| sbt
== VT_SHORT
) && dbt
== VT_BYTE
) ||
2002 (sbt
== VT_INT
&& dbt
== VT_SHORT
)) {
2003 /* optimize char/short casts */
2004 delayed_cast
= VT_MUSTCAST
;
2005 vtop
->type
.t
= ft
& (VT_TYPE
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
)));
2006 /* XXX: factorize */
2007 if (ft
& VT_CONSTANT
)
2008 warning("assignment of read-only location");
2011 if (!(ft
& VT_BITFIELD
))
2012 gen_assign_cast(&vtop
[-1].type
);
2015 if (sbt
== VT_STRUCT
) {
2016 /* if structure, only generate pointer */
2017 /* structure assignment : generate memcpy */
2018 /* XXX: optimize if small size */
2019 if (!nocode_wanted
) {
2020 size
= type_size(&vtop
->type
, &align
);
2024 vpush_global_sym(&func_old_type
, TOK_memcpy8
);
2025 else if(!(align
& 3))
2026 vpush_global_sym(&func_old_type
, TOK_memcpy4
);
2029 vpush_global_sym(&func_old_type
, TOK_memcpy
);
2033 vtop
->type
.t
= VT_PTR
;
2037 vtop
->type
.t
= VT_PTR
;
2049 /* leave source on stack */
2050 } else if (ft
& VT_BITFIELD
) {
2051 /* bitfield store handling */
2052 bit_pos
= (ft
>> VT_STRUCT_SHIFT
) & 0x3f;
2053 bit_size
= (ft
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
2054 /* remove bit field info to avoid loops */
2055 vtop
[-1].type
.t
= ft
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
2057 /* duplicate source into other register */
2062 if((ft
& VT_BTYPE
) == VT_BOOL
) {
2063 gen_cast(&vtop
[-1].type
);
2064 vtop
[-1].type
.t
= (vtop
[-1].type
.t
& ~VT_BTYPE
) | (VT_BYTE
| VT_UNSIGNED
);
2067 /* duplicate destination */
2069 vtop
[-1] = vtop
[-2];
2071 /* mask and shift source */
2072 if((ft
& VT_BTYPE
) != VT_BOOL
) {
2073 if((ft
& VT_BTYPE
) == VT_LLONG
) {
2074 vpushll((1ULL << bit_size
) - 1ULL);
2076 vpushi((1 << bit_size
) - 1);
2082 /* load destination, mask and or with source */
2084 if((ft
& VT_BTYPE
) == VT_LLONG
) {
2085 vpushll(~(((1ULL << bit_size
) - 1ULL) << bit_pos
));
2087 vpushi(~(((1 << bit_size
) - 1) << bit_pos
));
2094 /* pop off shifted source from "duplicate source..." above */
2098 #ifdef CONFIG_TCC_BCHECK
2099 /* bound check case */
2100 if (vtop
[-1].r
& VT_MUSTBOUND
) {
2106 if (!nocode_wanted
) {
2110 #ifdef TCC_TARGET_X86_64
2111 if ((ft
& VT_BTYPE
) == VT_LDOUBLE
) {
2116 r
= gv(rc
); /* generate value */
2117 /* if lvalue was saved on stack, must read it */
2118 if ((vtop
[-1].r
& VT_VALMASK
) == VT_LLOCAL
) {
2120 t
= get_reg(RC_INT
);
2121 #ifdef TCC_TARGET_X86_64
2126 sv
.r
= VT_LOCAL
| VT_LVAL
;
2127 sv
.c
.ul
= vtop
[-1].c
.ul
;
2129 vtop
[-1].r
= t
| VT_LVAL
;
2132 #ifndef TCC_TARGET_X86_64
2133 /* two word case handling : store second register at word + 4 */
2134 if ((ft
& VT_BTYPE
) == VT_LLONG
) {
2136 /* convert to int to increment easily */
2137 vtop
->type
.t
= VT_INT
;
2143 /* XXX: it works because r2 is spilled last ! */
2144 store(vtop
->r2
, vtop
- 1);
2149 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
2150 vtop
->r
|= delayed_cast
;
2154 /* post defines POST/PRE add. c is the token ++ or -- */
2155 void inc(int post
, int c
)
2158 vdup(); /* save lvalue */
2160 gv_dup(); /* duplicate value */
2165 vpushi(c
- TOK_MID
);
2167 vstore(); /* store value */
2169 vpop(); /* if post op, return saved value */
2172 /* Parse GNUC __attribute__ extension. Currently, the following
2173 extensions are recognized:
2174 - aligned(n) : set data/function alignment.
2175 - packed : force data alignment to 1
2176 - section(x) : generate data/code in this section.
2177 - unused : currently ignored, but may be used someday.
2178 - regparm(n) : pass function parameters in registers (i386 only)
2180 static void parse_attribute(AttributeDef
*ad
)
2184 while (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
) {
2188 while (tok
!= ')') {
2189 if (tok
< TOK_IDENT
)
2190 expect("attribute name");
2198 expect("section name");
2199 ad
->section
= find_section(tcc_state
, (char *)tokc
.cstr
->data
);
2208 if (n
<= 0 || (n
& (n
- 1)) != 0)
2209 error("alignment must be a positive power of two");
2222 /* currently, no need to handle it because tcc does not
2223 track unused objects */
2227 /* currently, no need to handle it because tcc does not
2228 track unused objects */
2233 FUNC_CALL(ad
->func_attr
) = FUNC_CDECL
;
2238 FUNC_CALL(ad
->func_attr
) = FUNC_STDCALL
;
2240 #ifdef TCC_TARGET_I386
2250 FUNC_CALL(ad
->func_attr
) = FUNC_FASTCALL1
+ n
- 1;
2256 FUNC_CALL(ad
->func_attr
) = FUNC_FASTCALLW
;
2260 FUNC_EXPORT(ad
->func_attr
) = 1;
2263 FUNC_IMPORT(ad
->func_attr
) = 1;
2266 if (tcc_state
->warn_unsupported
)
2267 warning("'%s' attribute ignored", get_tok_str(t
, NULL
));
2268 /* skip parameters */
2270 int parenthesis
= 0;
2274 else if (tok
== ')')
2277 } while (parenthesis
&& tok
!= -1);
2290 /* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
2291 static void struct_decl(CType
*type
, int u
)
2293 int a
, v
, size
, align
, maxalign
, c
, offset
;
2294 int bit_size
, bit_pos
, bsize
, bt
, lbit_pos
, prevbt
;
2295 Sym
*s
, *ss
, *ass
, **ps
;
2299 a
= tok
; /* save decl type */
2304 /* struct already defined ? return it */
2306 expect("struct/union/enum name");
2310 error("invalid type");
2317 /* we put an undefined size for struct/union */
2318 s
= sym_push(v
| SYM_STRUCT
, &type1
, 0, -1);
2319 s
->r
= 0; /* default alignment is zero as gcc */
2320 /* put struct/union/enum name in type */
2328 error("struct/union/enum already defined");
2329 /* cannot be empty */
2331 /* non empty enums are not allowed */
2332 if (a
== TOK_ENUM
) {
2336 expect("identifier");
2342 /* enum symbols have static storage */
2343 ss
= sym_push(v
, &int_type
, VT_CONST
, c
);
2344 ss
->type
.t
|= VT_STATIC
;
2349 /* NOTE: we accept a trailing comma */
2360 while (tok
!= '}') {
2361 parse_btype(&btype
, &ad
);
2367 type_decl(&type1
, &ad
, &v
, TYPE_DIRECT
| TYPE_ABSTRACT
);
2368 if (v
== 0 && (type1
.t
& VT_BTYPE
) != VT_STRUCT
)
2369 expect("identifier");
2370 if ((type1
.t
& VT_BTYPE
) == VT_FUNC
||
2371 (type1
.t
& (VT_TYPEDEF
| VT_STATIC
| VT_EXTERN
| VT_INLINE
)))
2372 error("invalid type for '%s'",
2373 get_tok_str(v
, NULL
));
2377 bit_size
= expr_const();
2378 /* XXX: handle v = 0 case for messages */
2380 error("negative width in bit-field '%s'",
2381 get_tok_str(v
, NULL
));
2382 if (v
&& bit_size
== 0)
2383 error("zero width for bit-field '%s'",
2384 get_tok_str(v
, NULL
));
2386 size
= type_size(&type1
, &align
);
2388 if (align
< ad
.aligned
)
2390 } else if (ad
.packed
) {
2392 } else if (*tcc_state
->pack_stack_ptr
) {
2393 if (align
> *tcc_state
->pack_stack_ptr
)
2394 align
= *tcc_state
->pack_stack_ptr
;
2397 if (bit_size
>= 0) {
2398 bt
= type1
.t
& VT_BTYPE
;
2405 error("bitfields must have scalar type");
2407 if (bit_size
> bsize
) {
2408 error("width of '%s' exceeds its type",
2409 get_tok_str(v
, NULL
));
2410 } else if (bit_size
== bsize
) {
2411 /* no need for bit fields */
2413 } else if (bit_size
== 0) {
2414 /* XXX: what to do if only padding in a
2416 /* zero size: means to pad */
2419 /* we do not have enough room ?
2420 did the type change?
2422 if ((bit_pos
+ bit_size
) > bsize
||
2423 bt
!= prevbt
|| a
== TOK_UNION
)
2426 /* XXX: handle LSB first */
2427 type1
.t
|= VT_BITFIELD
|
2428 (bit_pos
<< VT_STRUCT_SHIFT
) |
2429 (bit_size
<< (VT_STRUCT_SHIFT
+ 6));
2430 bit_pos
+= bit_size
;
2436 if (v
!= 0 || (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
2437 /* add new memory data only if starting
2439 if (lbit_pos
== 0) {
2440 if (a
== TOK_STRUCT
) {
2441 c
= (c
+ align
- 1) & -align
;
2450 if (align
> maxalign
)
2454 printf("add field %s offset=%d",
2455 get_tok_str(v
, NULL
), offset
);
2456 if (type1
.t
& VT_BITFIELD
) {
2457 printf(" pos=%d size=%d",
2458 (type1
.t
>> VT_STRUCT_SHIFT
) & 0x3f,
2459 (type1
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f);
2464 if (v
== 0 && (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
2466 while ((ass
= ass
->next
) != NULL
) {
2467 ss
= sym_push(ass
->v
, &ass
->type
, 0, offset
+ ass
->c
);
2472 ss
= sym_push(v
| SYM_FIELD
, &type1
, 0, offset
);
2476 if (tok
== ';' || tok
== TOK_EOF
)
2483 /* store size and alignment */
2484 s
->c
= (c
+ maxalign
- 1) & -maxalign
;
2490 /* return 0 if no type declaration. otherwise, return the basic type
2493 static int parse_btype(CType
*type
, AttributeDef
*ad
)
2495 int t
, u
, type_found
, typespec_found
, typedef_found
;
2499 memset(ad
, 0, sizeof(AttributeDef
));
2507 /* currently, we really ignore extension */
2517 if ((t
& VT_BTYPE
) != 0)
2518 error("too many basic types");
2534 if ((t
& VT_BTYPE
) == VT_DOUBLE
) {
2535 #ifndef TCC_TARGET_PE
2536 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
2538 } else if ((t
& VT_BTYPE
) == VT_LONG
) {
2539 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
2553 if ((t
& VT_BTYPE
) == VT_LONG
) {
2554 #ifdef TCC_TARGET_PE
2555 t
= (t
& ~VT_BTYPE
) | VT_DOUBLE
;
2557 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
2565 struct_decl(&type1
, VT_ENUM
);
2568 type
->ref
= type1
.ref
;
2572 struct_decl(&type1
, VT_STRUCT
);
2575 /* type modifiers */
2628 /* GNUC attribute */
2629 case TOK_ATTRIBUTE1
:
2630 case TOK_ATTRIBUTE2
:
2631 parse_attribute(ad
);
2638 parse_expr_type(&type1
);
2641 if (typespec_found
|| typedef_found
)
2644 if (!s
|| !(s
->type
.t
& VT_TYPEDEF
))
2647 t
|= (s
->type
.t
& ~VT_TYPEDEF
);
2648 type
->ref
= s
->type
.ref
;
2656 if ((t
& (VT_SIGNED
|VT_UNSIGNED
)) == (VT_SIGNED
|VT_UNSIGNED
))
2657 error("signed and unsigned modifier");
2658 if (tcc_state
->char_is_unsigned
) {
2659 if ((t
& (VT_SIGNED
|VT_UNSIGNED
|VT_BTYPE
)) == VT_BYTE
)
2664 /* long is never used as type */
2665 if ((t
& VT_BTYPE
) == VT_LONG
)
2666 #if !defined TCC_TARGET_X86_64 || defined TCC_TARGET_PE
2667 t
= (t
& ~VT_BTYPE
) | VT_INT
;
2669 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
2675 /* convert a function parameter type (array to pointer and function to
2676 function pointer) */
2677 static inline void convert_parameter_type(CType
*pt
)
2679 /* remove const and volatile qualifiers (XXX: const could be used
2680 to indicate a const function parameter */
2681 pt
->t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
2682 /* array must be transformed to pointer according to ANSI C */
2684 if ((pt
->t
& VT_BTYPE
) == VT_FUNC
) {
2689 static void post_type(CType
*type
, AttributeDef
*ad
)
2691 int n
, l
, t1
, arg_size
, align
;
2692 Sym
**plast
, *s
, *first
;
2697 /* function declaration */
2705 /* read param name and compute offset */
2706 if (l
!= FUNC_OLD
) {
2707 if (!parse_btype(&pt
, &ad1
)) {
2709 error("invalid type");
2716 if ((pt
.t
& VT_BTYPE
) == VT_VOID
&& tok
== ')')
2718 type_decl(&pt
, &ad1
, &n
, TYPE_DIRECT
| TYPE_ABSTRACT
);
2719 if ((pt
.t
& VT_BTYPE
) == VT_VOID
)
2720 error("parameter declared as void");
2721 arg_size
+= (type_size(&pt
, &align
) + 3) & ~3;
2726 expect("identifier");
2730 convert_parameter_type(&pt
);
2731 s
= sym_push(n
| SYM_FIELD
, &pt
, 0, 0);
2737 if (l
== FUNC_NEW
&& tok
== TOK_DOTS
) {
2744 /* if no parameters, then old type prototype */
2748 t1
= type
->t
& VT_STORAGE
;
2749 /* NOTE: const is ignored in returned type as it has a special
2750 meaning in gcc / C++ */
2751 type
->t
&= ~(VT_STORAGE
| VT_CONSTANT
);
2752 post_type(type
, ad
);
2753 /* we push a anonymous symbol which will contain the function prototype */
2754 FUNC_ARGS(ad
->func_attr
) = arg_size
;
2755 s
= sym_push(SYM_FIELD
, type
, ad
->func_attr
, l
);
2757 type
->t
= t1
| VT_FUNC
;
2759 } else if (tok
== '[') {
2760 /* array definition */
2762 if (tok
== TOK_RESTRICT1
)
2768 error("invalid array size");
2771 /* parse next post type */
2772 t1
= type
->t
& VT_STORAGE
;
2773 type
->t
&= ~VT_STORAGE
;
2774 post_type(type
, ad
);
2776 /* we push a anonymous symbol which will contain the array
2778 s
= sym_push(SYM_FIELD
, type
, 0, n
);
2779 type
->t
= t1
| VT_ARRAY
| VT_PTR
;
2784 /* Parse a type declaration (except basic type), and return the type
2785 in 'type'. 'td' is a bitmask indicating which kind of type decl is
2786 expected. 'type' should contain the basic type. 'ad' is the
2787 attribute definition of the basic type. It can be modified by
2790 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
)
2793 CType type1
, *type2
;
2796 while (tok
== '*') {
2804 qualifiers
|= VT_CONSTANT
;
2809 qualifiers
|= VT_VOLATILE
;
2817 type
->t
|= qualifiers
;
2820 /* XXX: clarify attribute handling */
2821 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
2822 parse_attribute(ad
);
2824 /* recursive type */
2825 /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
2826 type1
.t
= 0; /* XXX: same as int */
2829 /* XXX: this is not correct to modify 'ad' at this point, but
2830 the syntax is not clear */
2831 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
2832 parse_attribute(ad
);
2833 type_decl(&type1
, ad
, v
, td
);
2836 /* type identifier */
2837 if (tok
>= TOK_IDENT
&& (td
& TYPE_DIRECT
)) {
2841 if (!(td
& TYPE_ABSTRACT
))
2842 expect("identifier");
2846 post_type(type
, ad
);
2847 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
2848 parse_attribute(ad
);
2851 /* append type at the end of type1 */
2864 /* compute the lvalue VT_LVAL_xxx needed to match type t. */
2865 static int lvalue_type(int t
)
2870 if (bt
== VT_BYTE
|| bt
== VT_BOOL
)
2872 else if (bt
== VT_SHORT
)
2876 if (t
& VT_UNSIGNED
)
2877 r
|= VT_LVAL_UNSIGNED
;
2881 /* indirection with full error checking and bound check */
2882 static void indir(void)
2884 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
) {
2885 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FUNC
)
2889 if ((vtop
->r
& VT_LVAL
) && !nocode_wanted
)
2891 vtop
->type
= *pointed_type(&vtop
->type
);
2892 /* Arrays and functions are never lvalues */
2893 if (!(vtop
->type
.t
& VT_ARRAY
)
2894 && (vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
2895 vtop
->r
|= lvalue_type(vtop
->type
.t
);
2896 /* if bound checking, the referenced pointer must be checked */
2897 if (tcc_state
->do_bounds_check
)
2898 vtop
->r
|= VT_MUSTBOUND
;
2902 /* pass a parameter to a function and do type checking and casting */
2903 static void gfunc_param_typed(Sym
*func
, Sym
*arg
)
2908 func_type
= func
->c
;
2909 if (func_type
== FUNC_OLD
||
2910 (func_type
== FUNC_ELLIPSIS
&& arg
== NULL
)) {
2911 /* default casting : only need to convert float to double */
2912 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
) {
2916 } else if (arg
== NULL
) {
2917 error("too many arguments to function");
2920 type
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
2921 gen_assign_cast(&type
);
2925 /* parse an expression of the form '(type)' or '(expr)' and return its
2927 static void parse_expr_type(CType
*type
)
2933 if (parse_btype(type
, &ad
)) {
2934 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
2941 static void parse_type(CType
*type
)
2946 if (!parse_btype(type
, &ad
)) {
2949 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
2952 static void vpush_tokc(int t
)
2956 vsetc(&type
, VT_CONST
, &tokc
);
2959 static void unary(void)
2961 int n
, t
, align
, size
, r
;
2966 /* XXX: GCC 2.95.3 does not generate a table although it should be
2980 vpush_tokc(VT_INT
| VT_UNSIGNED
);
2984 vpush_tokc(VT_LLONG
);
2988 vpush_tokc(VT_LLONG
| VT_UNSIGNED
);
2992 vpush_tokc(VT_FLOAT
);
2996 vpush_tokc(VT_DOUBLE
);
3000 vpush_tokc(VT_LDOUBLE
);
3003 case TOK___FUNCTION__
:
3005 goto tok_identifier
;
3011 /* special function name identifier */
3012 len
= strlen(funcname
) + 1;
3013 /* generate char[len] type */
3018 vpush_ref(&type
, data_section
, data_section
->data_offset
, len
);
3019 ptr
= section_ptr_add(data_section
, len
);
3020 memcpy(ptr
, funcname
, len
);
3025 #ifdef TCC_TARGET_PE
3026 t
= VT_SHORT
| VT_UNSIGNED
;
3032 /* string parsing */
3035 if (tcc_state
->warn_write_strings
)
3040 memset(&ad
, 0, sizeof(AttributeDef
));
3041 decl_initializer_alloc(&type
, &ad
, VT_CONST
, 2, 0, 0);
3046 if (parse_btype(&type
, &ad
)) {
3047 type_decl(&type
, &ad
, &n
, TYPE_ABSTRACT
);
3049 /* check ISOC99 compound literal */
3051 /* data is allocated locally by default */
3056 /* all except arrays are lvalues */
3057 if (!(type
.t
& VT_ARRAY
))
3058 r
|= lvalue_type(type
.t
);
3059 memset(&ad
, 0, sizeof(AttributeDef
));
3060 decl_initializer_alloc(&type
, &ad
, r
, 1, 0, 0);
3065 } else if (tok
== '{') {
3066 /* save all registers */
3068 /* statement expression : we do not accept break/continue
3069 inside as GCC does */
3070 block(NULL
, NULL
, NULL
, NULL
, 0, 1);
3085 /* functions names must be treated as function pointers,
3086 except for unary '&' and sizeof. Since we consider that
3087 functions are not lvalues, we only have to handle it
3088 there and in function calls. */
3089 /* arrays can also be used although they are not lvalues */
3090 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
&&
3091 !(vtop
->type
.t
& VT_ARRAY
) && !(vtop
->type
.t
& VT_LLOCAL
))
3093 mk_pointer(&vtop
->type
);
3099 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
3101 boolean
.t
= VT_BOOL
;
3103 vtop
->c
.i
= !vtop
->c
.i
;
3104 } else if ((vtop
->r
& VT_VALMASK
) == VT_CMP
)
3105 vtop
->c
.i
= vtop
->c
.i
^ 1;
3108 vseti(VT_JMP
, gtst(1, 0));
3119 /* in order to force cast, we add zero */
3121 if ((vtop
->type
.t
& VT_BTYPE
) == VT_PTR
)
3122 error("pointer not accepted for unary plus");
3132 parse_expr_type(&type
);
3136 size
= type_size(&type
, &align
);
3137 if (t
== TOK_SIZEOF
) {
3139 error("sizeof applied to an incomplete type");
3144 vtop
->type
.t
|= VT_UNSIGNED
;
3147 case TOK_builtin_types_compatible_p
:
3156 type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
3157 type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
3158 vpushi(is_compatible_types(&type1
, &type2
));
3161 case TOK_builtin_constant_p
:
3163 int saved_nocode_wanted
, res
;
3166 saved_nocode_wanted
= nocode_wanted
;
3169 res
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
3171 nocode_wanted
= saved_nocode_wanted
;
3176 case TOK_builtin_frame_address
:
3181 if (tok
!= TOK_CINT
) {
3182 error("__builtin_frame_address only takes integers");
3185 error("TCC only supports __builtin_frame_address(0)");
3191 vset(&type
, VT_LOCAL
, 0);
3194 #ifdef TCC_TARGET_X86_64
3195 case TOK_builtin_malloc
:
3197 goto tok_identifier
;
3198 case TOK_builtin_free
:
3200 goto tok_identifier
;
3217 goto tok_identifier
;
3219 /* allow to take the address of a label */
3220 if (tok
< TOK_UIDENT
)
3221 expect("label identifier");
3222 s
= label_find(tok
);
3224 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
3226 if (s
->r
== LABEL_DECLARED
)
3227 s
->r
= LABEL_FORWARD
;
3230 s
->type
.t
= VT_VOID
;
3231 mk_pointer(&s
->type
);
3232 s
->type
.t
|= VT_STATIC
;
3234 vset(&s
->type
, VT_CONST
| VT_SYM
, 0);
3243 expect("identifier");
3247 error("'%s' undeclared", get_tok_str(t
, NULL
));
3248 /* for simple function calls, we tolerate undeclared
3249 external reference to int() function */
3250 if (tcc_state
->warn_implicit_function_declaration
)
3251 warning("implicit declaration of function '%s'",
3252 get_tok_str(t
, NULL
));
3253 s
= external_global_sym(t
, &func_old_type
, 0);
3255 if ((s
->type
.t
& (VT_STATIC
| VT_INLINE
| VT_BTYPE
)) ==
3256 (VT_STATIC
| VT_INLINE
| VT_FUNC
)) {
3257 /* if referencing an inline function, then we generate a
3258 symbol to it if not already done. It will have the
3259 effect to generate code for it at the end of the
3260 compilation unit. Inline function as always
3261 generated in the text section. */
3263 put_extern_sym(s
, text_section
, 0, 0);
3264 r
= VT_SYM
| VT_CONST
;
3268 vset(&s
->type
, r
, s
->c
);
3269 /* if forward reference, we must point to s */
3270 if (vtop
->r
& VT_SYM
) {
3277 /* post operations */
3279 if (tok
== TOK_INC
|| tok
== TOK_DEC
) {
3282 } else if (tok
== '.' || tok
== TOK_ARROW
) {
3285 if (tok
== TOK_ARROW
)
3287 qualifiers
= vtop
->type
.t
& (VT_CONSTANT
| VT_VOLATILE
);
3291 /* expect pointer on structure */
3292 if ((vtop
->type
.t
& VT_BTYPE
) != VT_STRUCT
)
3293 expect("struct or union");
3297 while ((s
= s
->next
) != NULL
) {
3302 error("field not found: %s", get_tok_str(tok
& ~SYM_FIELD
, NULL
));
3303 /* add field offset to pointer */
3304 vtop
->type
= char_pointer_type
; /* change type to 'char *' */
3307 /* change type to field type, and set to lvalue */
3308 vtop
->type
= s
->type
;
3309 vtop
->type
.t
|= qualifiers
;
3310 /* an array is never an lvalue */
3311 if (!(vtop
->type
.t
& VT_ARRAY
)) {
3312 vtop
->r
|= lvalue_type(vtop
->type
.t
);
3313 /* if bound checking, the referenced pointer must be checked */
3314 if (tcc_state
->do_bounds_check
)
3315 vtop
->r
|= VT_MUSTBOUND
;
3318 } else if (tok
== '[') {
3324 } else if (tok
== '(') {
3330 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
3331 /* pointer test (no array accepted) */
3332 if ((vtop
->type
.t
& (VT_BTYPE
| VT_ARRAY
)) == VT_PTR
) {
3333 vtop
->type
= *pointed_type(&vtop
->type
);
3334 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
)
3338 expect("function pointer");
3341 vtop
->r
&= ~VT_LVAL
; /* no lvalue */
3343 /* get return type */
3346 sa
= s
->next
; /* first parameter */
3349 /* compute first implicit argument if a structure is returned */
3350 if ((s
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
3351 /* get some space for the returned structure */
3352 size
= type_size(&s
->type
, &align
);
3353 loc
= (loc
- size
) & -align
;
3355 ret
.r
= VT_LOCAL
| VT_LVAL
;
3356 /* pass it as 'int' to avoid structure arg passing
3358 vseti(VT_LOCAL
, loc
);
3363 /* return in register */
3364 if (is_float(ret
.type
.t
)) {
3365 ret
.r
= reg_fret(ret
.type
.t
);
3367 if ((ret
.type
.t
& VT_BTYPE
) == VT_LLONG
)
3376 gfunc_param_typed(s
, sa
);
3386 error("too few arguments to function");
3388 if (!nocode_wanted
) {
3389 gfunc_call(nb_args
);
3391 vtop
-= (nb_args
+ 1);
3394 vsetc(&ret
.type
, ret
.r
, &ret
.c
);
3402 static void uneq(void)
3408 (tok
>= TOK_A_MOD
&& tok
<= TOK_A_DIV
) ||
3409 tok
== TOK_A_XOR
|| tok
== TOK_A_OR
||
3410 tok
== TOK_A_SHL
|| tok
== TOK_A_SAR
) {
3425 static void expr_prod(void)
3430 while (tok
== '*' || tok
== '/' || tok
== '%') {
3438 static void expr_sum(void)
3443 while (tok
== '+' || tok
== '-') {
3451 static void expr_shift(void)
3456 while (tok
== TOK_SHL
|| tok
== TOK_SAR
) {
3464 static void expr_cmp(void)
3469 while ((tok
>= TOK_ULE
&& tok
<= TOK_GT
) ||
3470 tok
== TOK_ULT
|| tok
== TOK_UGE
) {
3478 static void expr_cmpeq(void)
3483 while (tok
== TOK_EQ
|| tok
== TOK_NE
) {
3491 static void expr_and(void)
3494 while (tok
== '&') {
3501 static void expr_xor(void)
3504 while (tok
== '^') {
3511 static void expr_or(void)
3514 while (tok
== '|') {
3521 /* XXX: fix this mess */
3522 static void expr_land_const(void)
3525 while (tok
== TOK_LAND
) {
3532 /* XXX: fix this mess */
3533 static void expr_lor_const(void)
3536 while (tok
== TOK_LOR
) {
3543 /* only used if non constant */
3544 static void expr_land(void)
3549 if (tok
== TOK_LAND
) {
3554 if (tok
!= TOK_LAND
) {
3564 static void expr_lor(void)
3569 if (tok
== TOK_LOR
) {
3574 if (tok
!= TOK_LOR
) {
3584 /* XXX: better constant handling */
3585 static void expr_eq(void)
3587 int tt
, u
, r1
, r2
, rc
, t1
, t2
, bt1
, bt2
;
3589 CType type
, type1
, type2
;
3596 boolean
.t
= VT_BOOL
;
3602 if (tok
!= ':' || !gnu_ext
) {
3617 if (vtop
!= vstack
) {
3618 /* needed to avoid having different registers saved in
3620 if (is_float(vtop
->type
.t
)) {
3622 #ifdef TCC_TARGET_X86_64
3623 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LDOUBLE
) {
3633 if (tok
== ':' && gnu_ext
) {
3641 sv
= *vtop
; /* save value to handle it later */
3642 vtop
--; /* no vpop so that FP stack is not flushed */
3650 bt1
= t1
& VT_BTYPE
;
3652 bt2
= t2
& VT_BTYPE
;
3653 /* cast operands to correct type according to ISOC rules */
3654 if (is_float(bt1
) || is_float(bt2
)) {
3655 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
3656 type
.t
= VT_LDOUBLE
;
3657 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
3662 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
3663 /* cast to biggest op */
3665 /* convert to unsigned if it does not fit in a long long */
3666 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
3667 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
3668 type
.t
|= VT_UNSIGNED
;
3669 } else if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
3670 /* XXX: test pointer compatibility */
3672 } else if (bt1
== VT_FUNC
|| bt2
== VT_FUNC
) {
3673 /* XXX: test function pointer compatibility */
3675 } else if (bt1
== VT_STRUCT
|| bt2
== VT_STRUCT
) {
3676 /* XXX: test structure compatibility */
3678 } else if (bt1
== VT_VOID
|| bt2
== VT_VOID
) {
3679 /* NOTE: as an extension, we accept void on only one side */
3682 /* integer operations */
3684 /* convert to unsigned if it does not fit in an integer */
3685 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
3686 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
3687 type
.t
|= VT_UNSIGNED
;
3690 /* now we convert second operand */
3692 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
3695 if (is_float(type
.t
)) {
3697 #ifdef TCC_TARGET_X86_64
3698 if ((type
.t
& VT_BTYPE
) == VT_LDOUBLE
) {
3702 } else if ((type
.t
& VT_BTYPE
) == VT_LLONG
) {
3703 /* for long longs, we use fixed registers to avoid having
3704 to handle a complicated move */
3709 /* this is horrible, but we must also convert first
3713 /* put again first value and cast it */
3716 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
3726 static void gexpr(void)
3737 /* parse an expression and return its type without any side effect. */
3738 static void expr_type(CType
*type
)
3740 int saved_nocode_wanted
;
3742 saved_nocode_wanted
= nocode_wanted
;
3747 nocode_wanted
= saved_nocode_wanted
;
3750 /* parse a unary expression and return its type without any side
3752 static void unary_type(CType
*type
)
3764 /* parse a constant expression and return value in vtop. */
3765 static void expr_const1(void)
3774 /* parse an integer constant and return its value. */
3775 static int expr_const(void)
3779 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
3780 expect("constant expression");
3786 /* return the label token if current token is a label, otherwise
3788 static int is_label(void)
3792 /* fast test first */
3793 if (tok
< TOK_UIDENT
)
3795 /* no need to save tokc because tok is an identifier */
3802 unget_tok(last_tok
);
3807 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
,
3808 int case_reg
, int is_expr
)
3813 /* generate line number info */
3814 if (tcc_state
->do_debug
&&
3815 (last_line_num
!= file
->line_num
|| last_ind
!= ind
)) {
3816 put_stabn(N_SLINE
, 0, file
->line_num
, ind
- func_ind
);
3818 last_line_num
= file
->line_num
;
3822 /* default return value is (void) */
3824 vtop
->type
.t
= VT_VOID
;
3827 if (tok
== TOK_IF
) {
3834 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
3836 if (c
== TOK_ELSE
) {
3840 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
3841 gsym(d
); /* patch else jmp */
3844 } else if (tok
== TOK_WHILE
) {
3852 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
3856 } else if (tok
== '{') {
3860 /* record local declaration stack position */
3862 llabel
= local_label_stack
;
3863 /* handle local labels declarations */
3864 if (tok
== TOK_LABEL
) {
3867 if (tok
< TOK_UIDENT
)
3868 expect("label identifier");
3869 label_push(&local_label_stack
, tok
, LABEL_DECLARED
);
3879 while (tok
!= '}') {
3884 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
3887 /* pop locally defined labels */
3888 label_pop(&local_label_stack
, llabel
);
3889 /* pop locally defined symbols */
3891 /* XXX: this solution makes only valgrind happy...
3892 triggered by gcc.c-torture/execute/20000917-1.c */
3894 switch(vtop
->type
.t
& VT_BTYPE
) {
3899 for(p
=vtop
->type
.ref
;p
;p
=p
->prev
)
3901 error("unsupported expression type");
3904 sym_pop(&local_stack
, s
);
3906 } else if (tok
== TOK_RETURN
) {
3910 gen_assign_cast(&func_vt
);
3911 if ((func_vt
.t
& VT_BTYPE
) == VT_STRUCT
) {
3913 /* if returning structure, must copy it to implicit
3914 first pointer arg location */
3917 size
= type_size(&func_vt
,&align
);
3920 if((vtop
->r
!= (VT_LOCAL
| VT_LVAL
) || (vtop
->c
.i
& 3))
3924 loc
= (loc
- size
) & -4;
3927 vset(&type
, VT_LOCAL
| VT_LVAL
, addr
);
3930 vset(&int_type
, VT_LOCAL
| VT_LVAL
, addr
);
3932 vtop
->type
= int_type
;
3938 vset(&type
, VT_LOCAL
| VT_LVAL
, func_vc
);
3941 /* copy structure value to pointer */
3946 } else if (is_float(func_vt
.t
)) {
3947 gv(rc_fret(func_vt
.t
));
3951 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
3954 rsym
= gjmp(rsym
); /* jmp */
3955 } else if (tok
== TOK_BREAK
) {
3958 error("cannot break");
3959 *bsym
= gjmp(*bsym
);
3962 } else if (tok
== TOK_CONTINUE
) {
3965 error("cannot continue");
3966 *csym
= gjmp(*csym
);
3969 } else if (tok
== TOK_FOR
) {
3996 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
4001 if (tok
== TOK_DO
) {
4006 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
4017 if (tok
== TOK_SWITCH
) {
4021 /* XXX: other types than integer */
4022 case_reg
= gv(RC_INT
);
4026 b
= gjmp(0); /* jump to first case */
4028 block(&a
, csym
, &b
, &c
, case_reg
, 0);
4029 /* if no default, jmp after switch */
4037 if (tok
== TOK_CASE
) {
4044 if (gnu_ext
&& tok
== TOK_DOTS
) {
4048 warning("empty case range");
4050 /* since a case is like a label, we must skip it with a jmp */
4057 *case_sym
= gtst(1, 0);
4060 *case_sym
= gtst(1, 0);
4064 *case_sym
= gtst(1, *case_sym
);
4069 goto block_after_label
;
4071 if (tok
== TOK_DEFAULT
) {
4077 error("too many 'default'");
4080 goto block_after_label
;
4082 if (tok
== TOK_GOTO
) {
4084 if (tok
== '*' && gnu_ext
) {
4088 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
)
4091 } else if (tok
>= TOK_UIDENT
) {
4092 s
= label_find(tok
);
4093 /* put forward definition if needed */
4095 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
4097 if (s
->r
== LABEL_DECLARED
)
4098 s
->r
= LABEL_FORWARD
;
4100 /* label already defined */
4101 if (s
->r
& LABEL_FORWARD
)
4102 s
->jnext
= gjmp(s
->jnext
);
4104 gjmp_addr(s
->jnext
);
4107 expect("label identifier");
4110 } else if (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
) {
4118 if (s
->r
== LABEL_DEFINED
)
4119 error("duplicate label '%s'", get_tok_str(s
->v
, NULL
));
4121 s
->r
= LABEL_DEFINED
;
4123 s
= label_push(&global_label_stack
, b
, LABEL_DEFINED
);
4126 /* we accept this, but it is a mistake */
4129 warning("deprecated use of label at end of compound statement");
4133 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
4136 /* expression case */
4151 /* t is the array or struct type. c is the array or struct
4152 address. cur_index/cur_field is the pointer to the current
4153 value. 'size_only' is true if only size info is needed (only used
4155 static void decl_designator(CType
*type
, Section
*sec
, unsigned long c
,
4156 int *cur_index
, Sym
**cur_field
,
4160 int notfirst
, index
, index_last
, align
, l
, nb_elems
, elem_size
;
4166 if (gnu_ext
&& (l
= is_label()) != 0)
4168 while (tok
== '[' || tok
== '.') {
4170 if (!(type
->t
& VT_ARRAY
))
4171 expect("array type");
4174 index
= expr_const();
4175 if (index
< 0 || (s
->c
>= 0 && index
>= s
->c
))
4176 expect("invalid index");
4177 if (tok
== TOK_DOTS
&& gnu_ext
) {
4179 index_last
= expr_const();
4180 if (index_last
< 0 ||
4181 (s
->c
>= 0 && index_last
>= s
->c
) ||
4183 expect("invalid index");
4189 *cur_index
= index_last
;
4190 type
= pointed_type(type
);
4191 elem_size
= type_size(type
, &align
);
4192 c
+= index
* elem_size
;
4193 /* NOTE: we only support ranges for last designator */
4194 nb_elems
= index_last
- index
+ 1;
4195 if (nb_elems
!= 1) {
4204 if ((type
->t
& VT_BTYPE
) != VT_STRUCT
)
4205 expect("struct/union type");
4218 /* XXX: fix this mess by using explicit storage field */
4220 type1
.t
|= (type
->t
& ~VT_TYPE
);
4234 if (type
->t
& VT_ARRAY
) {
4236 type
= pointed_type(type
);
4237 c
+= index
* type_size(type
, &align
);
4241 error("too many field init");
4242 /* XXX: fix this mess by using explicit storage field */
4244 type1
.t
|= (type
->t
& ~VT_TYPE
);
4249 decl_initializer(type
, sec
, c
, 0, size_only
);
4251 /* XXX: make it more general */
4252 if (!size_only
&& nb_elems
> 1) {
4253 unsigned long c_end
;
4258 error("range init not supported yet for dynamic storage");
4259 c_end
= c
+ nb_elems
* elem_size
;
4260 if (c_end
> sec
->data_allocated
)
4261 section_realloc(sec
, c_end
);
4262 src
= sec
->data
+ c
;
4264 for(i
= 1; i
< nb_elems
; i
++) {
4266 memcpy(dst
, src
, elem_size
);
4272 #define EXPR_CONST 1
4275 /* store a value or an expression directly in global data or in local array */
4276 static void init_putv(CType
*type
, Section
*sec
, unsigned long c
,
4277 int v
, int expr_type
)
4279 int saved_global_expr
, bt
, bit_pos
, bit_size
;
4281 unsigned long long bit_mask
;
4289 /* compound literals must be allocated globally in this case */
4290 saved_global_expr
= global_expr
;
4293 global_expr
= saved_global_expr
;
4294 /* NOTE: symbols are accepted */
4295 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) != VT_CONST
)
4296 error("initializer element is not constant");
4304 dtype
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
4307 /* XXX: not portable */
4308 /* XXX: generate error if incorrect relocation */
4309 gen_assign_cast(&dtype
);
4310 bt
= type
->t
& VT_BTYPE
;
4311 /* we'll write at most 12 bytes */
4312 if (c
+ 12 > sec
->data_allocated
) {
4313 section_realloc(sec
, c
+ 12);
4315 ptr
= sec
->data
+ c
;
4316 /* XXX: make code faster ? */
4317 if (!(type
->t
& VT_BITFIELD
)) {
4322 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4323 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
4324 bit_mask
= (1LL << bit_size
) - 1;
4326 if ((vtop
->r
& VT_SYM
) &&
4332 (bt
== VT_INT
&& bit_size
!= 32)))
4333 error("initializer element is not computable at load time");
4336 vtop
->c
.i
= (vtop
->c
.i
!= 0);
4338 *(char *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
4341 *(short *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
4344 *(double *)ptr
= vtop
->c
.d
;
4347 *(long double *)ptr
= vtop
->c
.ld
;
4350 *(long long *)ptr
|= (vtop
->c
.ll
& bit_mask
) << bit_pos
;
4353 if (vtop
->r
& VT_SYM
) {
4354 greloc(sec
, vtop
->sym
, c
, R_DATA_PTR
);
4356 *(int *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
4361 vset(&dtype
, VT_LOCAL
|VT_LVAL
, c
);
4368 /* put zeros for variable based init */
4369 static void init_putz(CType
*t
, Section
*sec
, unsigned long c
, int size
)
4372 /* nothing to do because globals are already set to zero */
4374 vpush_global_sym(&func_old_type
, TOK_memset
);
4382 /* 't' contains the type and storage info. 'c' is the offset of the
4383 object in section 'sec'. If 'sec' is NULL, it means stack based
4384 allocation. 'first' is true if array '{' must be read (multi
4385 dimension implicit array init handling). 'size_only' is true if
4386 size only evaluation is wanted (only for arrays). */
4387 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
4388 int first
, int size_only
)
4390 int index
, array_length
, n
, no_oblock
, nb
, parlevel
, i
;
4391 int size1
, align1
, expr_type
;
4395 if (type
->t
& VT_ARRAY
) {
4399 t1
= pointed_type(type
);
4400 size1
= type_size(t1
, &align1
);
4403 if ((first
&& tok
!= TOK_LSTR
&& tok
!= TOK_STR
) ||
4409 /* only parse strings here if correct type (otherwise: handle
4410 them as ((w)char *) expressions */
4411 if ((tok
== TOK_LSTR
&&
4412 #ifdef TCC_TARGET_PE
4413 (t1
->t
& VT_BTYPE
) == VT_SHORT
&& (t1
->t
& VT_UNSIGNED
)
4415 (t1
->t
& VT_BTYPE
) == VT_INT
4417 ) || (tok
== TOK_STR
&& (t1
->t
& VT_BTYPE
) == VT_BYTE
)) {
4418 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
4423 /* compute maximum number of chars wanted */
4425 cstr_len
= cstr
->size
;
4427 cstr_len
= cstr
->size
/ sizeof(nwchar_t
);
4430 if (n
>= 0 && nb
> (n
- array_length
))
4431 nb
= n
- array_length
;
4434 warning("initializer-string for array is too long");
4435 /* in order to go faster for common case (char
4436 string in global variable, we handle it
4438 if (sec
&& tok
== TOK_STR
&& size1
== 1) {
4439 memcpy(sec
->data
+ c
+ array_length
, cstr
->data
, nb
);
4443 ch
= ((unsigned char *)cstr
->data
)[i
];
4445 ch
= ((nwchar_t
*)cstr
->data
)[i
];
4446 init_putv(t1
, sec
, c
+ (array_length
+ i
) * size1
,
4454 /* only add trailing zero if enough storage (no
4455 warning in this case since it is standard) */
4456 if (n
< 0 || array_length
< n
) {
4458 init_putv(t1
, sec
, c
+ (array_length
* size1
), 0, EXPR_VAL
);
4464 while (tok
!= '}') {
4465 decl_designator(type
, sec
, c
, &index
, NULL
, size_only
);
4466 if (n
>= 0 && index
>= n
)
4467 error("index too large");
4468 /* must put zero in holes (note that doing it that way
4469 ensures that it even works with designators) */
4470 if (!size_only
&& array_length
< index
) {
4471 init_putz(t1
, sec
, c
+ array_length
* size1
,
4472 (index
- array_length
) * size1
);
4475 if (index
> array_length
)
4476 array_length
= index
;
4477 /* special test for multi dimensional arrays (may not
4478 be strictly correct if designators are used at the
4480 if (index
>= n
&& no_oblock
)
4489 /* put zeros at the end */
4490 if (!size_only
&& n
>= 0 && array_length
< n
) {
4491 init_putz(t1
, sec
, c
+ array_length
* size1
,
4492 (n
- array_length
) * size1
);
4494 /* patch type size if needed */
4496 s
->c
= array_length
;
4497 } else if ((type
->t
& VT_BTYPE
) == VT_STRUCT
&&
4498 (sec
|| !first
|| tok
== '{')) {
4501 /* NOTE: the previous test is a specific case for automatic
4502 struct/union init */
4503 /* XXX: union needs only one init */
4505 /* XXX: this test is incorrect for local initializers
4506 beginning with ( without {. It would be much more difficult
4507 to do it correctly (ideally, the expression parser should
4508 be used in all cases) */
4514 while (tok
== '(') {
4518 if (!parse_btype(&type1
, &ad1
))
4520 type_decl(&type1
, &ad1
, &n
, TYPE_ABSTRACT
);
4522 if (!is_assignable_types(type
, &type1
))
4523 error("invalid type for cast");
4528 if (first
|| tok
== '{') {
4537 while (tok
!= '}') {
4538 decl_designator(type
, sec
, c
, NULL
, &f
, size_only
);
4540 if (!size_only
&& array_length
< index
) {
4541 init_putz(type
, sec
, c
+ array_length
,
4542 index
- array_length
);
4544 index
= index
+ type_size(&f
->type
, &align1
);
4545 if (index
> array_length
)
4546 array_length
= index
;
4548 /* gr: skip fields from same union - ugly. */
4550 ///printf("index: %2d %08x -- %2d %08x\n", f->c, f->type.t, f->next->c, f->next->type.t);
4551 /* test for same offset */
4552 if (f
->next
->c
!= f
->c
)
4554 /* if yes, test for bitfield shift */
4555 if ((f
->type
.t
& VT_BITFIELD
) && (f
->next
->type
.t
& VT_BITFIELD
)) {
4556 int bit_pos_1
= (f
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4557 int bit_pos_2
= (f
->next
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4558 //printf("bitfield %d %d\n", bit_pos_1, bit_pos_2);
4559 if (bit_pos_1
!= bit_pos_2
)
4566 if (no_oblock
&& f
== NULL
)
4572 /* put zeros at the end */
4573 if (!size_only
&& array_length
< n
) {
4574 init_putz(type
, sec
, c
+ array_length
,
4583 } else if (tok
== '{') {
4585 decl_initializer(type
, sec
, c
, first
, size_only
);
4587 } else if (size_only
) {
4588 /* just skip expression */
4590 while ((parlevel
> 0 || (tok
!= '}' && tok
!= ',')) &&
4594 else if (tok
== ')')
4599 /* currently, we always use constant expression for globals
4600 (may change for scripting case) */
4601 expr_type
= EXPR_CONST
;
4603 expr_type
= EXPR_ANY
;
4604 init_putv(type
, sec
, c
, 0, expr_type
);
4608 /* parse an initializer for type 't' if 'has_init' is non zero, and
4609 allocate space in local or global data space ('r' is either
4610 VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
4611 variable 'v' of scope 'scope' is declared before initializers are
4612 parsed. If 'v' is zero, then a reference to the new object is put
4613 in the value stack. If 'has_init' is 2, a special parsing is done
4614 to handle string constants. */
4615 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
4616 int has_init
, int v
, int scope
)
4618 int size
, align
, addr
, data_offset
;
4620 ParseState saved_parse_state
= {0};
4621 TokenString init_str
;
4624 size
= type_size(type
, &align
);
4625 /* If unknown size, we must evaluate it before
4626 evaluating initializers because
4627 initializers can generate global data too
4628 (e.g. string pointers or ISOC99 compound
4629 literals). It also simplifies local
4630 initializers handling */
4631 tok_str_new(&init_str
);
4634 error("unknown type size");
4635 /* get all init string */
4636 if (has_init
== 2) {
4637 /* only get strings */
4638 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
4639 tok_str_add_tok(&init_str
);
4644 while (level
> 0 || (tok
!= ',' && tok
!= ';')) {
4646 error("unexpected end of file in initializer");
4647 tok_str_add_tok(&init_str
);
4650 else if (tok
== '}') {
4660 tok_str_add(&init_str
, -1);
4661 tok_str_add(&init_str
, 0);
4664 save_parse_state(&saved_parse_state
);
4666 macro_ptr
= init_str
.str
;
4668 decl_initializer(type
, NULL
, 0, 1, 1);
4669 /* prepare second initializer parsing */
4670 macro_ptr
= init_str
.str
;
4673 /* if still unknown size, error */
4674 size
= type_size(type
, &align
);
4676 error("unknown type size");
4678 /* take into account specified alignment if bigger */
4680 if (ad
->aligned
> align
)
4681 align
= ad
->aligned
;
4682 } else if (ad
->packed
) {
4685 if ((r
& VT_VALMASK
) == VT_LOCAL
) {
4687 if (tcc_state
->do_bounds_check
&& (type
->t
& VT_ARRAY
))
4689 loc
= (loc
- size
) & -align
;
4691 /* handles bounds */
4692 /* XXX: currently, since we do only one pass, we cannot track
4693 '&' operators, so we add only arrays */
4694 if (tcc_state
->do_bounds_check
&& (type
->t
& VT_ARRAY
)) {
4695 unsigned long *bounds_ptr
;
4696 /* add padding between regions */
4698 /* then add local bound info */
4699 bounds_ptr
= section_ptr_add(lbounds_section
, 2 * sizeof(unsigned long));
4700 bounds_ptr
[0] = addr
;
4701 bounds_ptr
[1] = size
;
4704 /* local variable */
4705 sym_push(v
, type
, r
, addr
);
4707 /* push local reference */
4708 vset(type
, r
, addr
);
4714 if (v
&& scope
== VT_CONST
) {
4715 /* see if the symbol was already defined */
4718 if (!is_compatible_types(&sym
->type
, type
))
4719 error("incompatible types for redefinition of '%s'",
4720 get_tok_str(v
, NULL
));
4721 if (sym
->type
.t
& VT_EXTERN
) {
4722 /* if the variable is extern, it was not allocated */
4723 sym
->type
.t
&= ~VT_EXTERN
;
4724 /* set array size if it was ommited in extern
4726 if ((sym
->type
.t
& VT_ARRAY
) &&
4727 sym
->type
.ref
->c
< 0 &&
4729 sym
->type
.ref
->c
= type
->ref
->c
;
4731 /* we accept several definitions of the same
4732 global variable. this is tricky, because we
4733 must play with the SHN_COMMON type of the symbol */
4734 /* XXX: should check if the variable was already
4735 initialized. It is incorrect to initialized it
4737 /* no init data, we won't add more to the symbol */
4744 /* allocate symbol in corresponding section */
4749 else if (tcc_state
->nocommon
)
4753 data_offset
= sec
->data_offset
;
4754 data_offset
= (data_offset
+ align
- 1) & -align
;
4756 /* very important to increment global pointer at this time
4757 because initializers themselves can create new initializers */
4758 data_offset
+= size
;
4759 /* add padding if bound check */
4760 if (tcc_state
->do_bounds_check
)
4762 sec
->data_offset
= data_offset
;
4763 /* allocate section space to put the data */
4764 if (sec
->sh_type
!= SHT_NOBITS
&&
4765 data_offset
> sec
->data_allocated
)
4766 section_realloc(sec
, data_offset
);
4767 /* align section if needed */
4768 if (align
> sec
->sh_addralign
)
4769 sec
->sh_addralign
= align
;
4771 addr
= 0; /* avoid warning */
4775 if (scope
!= VT_CONST
|| !sym
) {
4776 sym
= sym_push(v
, type
, r
| VT_SYM
, 0);
4778 /* update symbol definition */
4780 put_extern_sym(sym
, sec
, addr
, size
);
4783 /* put a common area */
4784 put_extern_sym(sym
, NULL
, align
, size
);
4785 /* XXX: find a nicer way */
4786 esym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
];
4787 esym
->st_shndx
= SHN_COMMON
;
4792 /* push global reference */
4793 sym
= get_sym_ref(type
, sec
, addr
, size
);
4795 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
4799 /* handles bounds now because the symbol must be defined
4800 before for the relocation */
4801 if (tcc_state
->do_bounds_check
) {
4802 unsigned long *bounds_ptr
;
4804 greloc(bounds_section
, sym
, bounds_section
->data_offset
, R_DATA_PTR
);
4805 /* then add global bound info */
4806 bounds_ptr
= section_ptr_add(bounds_section
, 2 * sizeof(long));
4807 bounds_ptr
[0] = 0; /* relocated */
4808 bounds_ptr
[1] = size
;
4812 decl_initializer(type
, sec
, addr
, 1, 0);
4813 /* restore parse state if needed */
4815 tok_str_free(init_str
.str
);
4816 restore_parse_state(&saved_parse_state
);
4822 void put_func_debug(Sym
*sym
)
4827 /* XXX: we put here a dummy type */
4828 snprintf(buf
, sizeof(buf
), "%s:%c1",
4829 funcname
, sym
->type
.t
& VT_STATIC
? 'f' : 'F');
4830 put_stabs_r(buf
, N_FUN
, 0, file
->line_num
, 0,
4831 cur_text_section
, sym
->c
);
4832 /* //gr gdb wants a line at the function */
4833 put_stabn(N_SLINE
, 0, file
->line_num
, 0);
4838 /* parse an old style function declaration list */
4839 /* XXX: check multiple parameter */
4840 static void func_decl_list(Sym
*func_sym
)
4847 /* parse each declaration */
4848 while (tok
!= '{' && tok
!= ';' && tok
!= ',' && tok
!= TOK_EOF
) {
4849 if (!parse_btype(&btype
, &ad
))
4850 expect("declaration list");
4851 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
4852 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
4854 /* we accept no variable after */
4858 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
4859 /* find parameter in function parameter list */
4862 if ((s
->v
& ~SYM_FIELD
) == v
)
4866 error("declaration for parameter '%s' but no such parameter",
4867 get_tok_str(v
, NULL
));
4869 /* check that no storage specifier except 'register' was given */
4870 if (type
.t
& VT_STORAGE
)
4871 error("storage class specified for '%s'", get_tok_str(v
, NULL
));
4872 convert_parameter_type(&type
);
4873 /* we can add the type (NOTE: it could be local to the function) */
4875 /* accept other parameters */
4886 /* parse a function defined by symbol 'sym' and generate its code in
4887 'cur_text_section' */
4888 static void gen_function(Sym
*sym
)
4890 int saved_nocode_wanted
= nocode_wanted
;
4892 ind
= cur_text_section
->data_offset
;
4893 /* NOTE: we patch the symbol size later */
4894 put_extern_sym(sym
, cur_text_section
, ind
, 0);
4895 funcname
= get_tok_str(sym
->v
, NULL
);
4897 /* put debug symbol */
4898 if (tcc_state
->do_debug
)
4899 put_func_debug(sym
);
4900 /* push a dummy symbol to enable local sym storage */
4901 sym_push2(&local_stack
, SYM_FIELD
, 0, 0);
4902 gfunc_prolog(&sym
->type
);
4904 block(NULL
, NULL
, NULL
, NULL
, 0, 0);
4907 cur_text_section
->data_offset
= ind
;
4908 label_pop(&global_label_stack
, NULL
);
4909 sym_pop(&local_stack
, NULL
); /* reset local stack */
4910 /* end of function */
4911 /* patch symbol size */
4912 ((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
].st_size
=
4914 if (tcc_state
->do_debug
) {
4915 put_stabn(N_FUN
, 0, 0, ind
- func_ind
);
4917 /* It's better to crash than to generate wrong code */
4918 cur_text_section
= NULL
;
4919 funcname
= ""; /* for safety */
4920 func_vt
.t
= VT_VOID
; /* for safety */
4921 ind
= 0; /* for safety */
4922 nocode_wanted
= saved_nocode_wanted
;
4925 static void gen_inline_functions(void)
4928 int *str
, inline_generated
, i
;
4929 struct InlineFunc
*fn
;
4931 /* iterate while inline function are referenced */
4933 inline_generated
= 0;
4934 for (i
= 0; i
< tcc_state
->nb_inline_fns
; ++i
) {
4935 fn
= tcc_state
->inline_fns
[i
];
4937 if (sym
&& sym
->c
) {
4938 /* the function was used: generate its code and
4939 convert it to a normal function */
4940 str
= fn
->token_str
;
4943 strcpy(file
->filename
, fn
->filename
);
4944 sym
->r
= VT_SYM
| VT_CONST
;
4945 sym
->type
.t
&= ~VT_INLINE
;
4949 cur_text_section
= text_section
;
4951 macro_ptr
= NULL
; /* fail safe */
4953 inline_generated
= 1;
4956 if (!inline_generated
)
4959 for (i
= 0; i
< tcc_state
->nb_inline_fns
; ++i
) {
4960 fn
= tcc_state
->inline_fns
[i
];
4961 str
= fn
->token_str
;
4964 dynarray_reset(&tcc_state
->inline_fns
, &tcc_state
->nb_inline_fns
);
4967 /* 'l' is VT_LOCAL or VT_CONST to define default storage type */
4968 static void decl(int l
)
4976 if (!parse_btype(&btype
, &ad
)) {
4977 /* skip redundant ';' */
4978 /* XXX: find more elegant solution */
4983 if (l
== VT_CONST
&&
4984 (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
)) {
4985 /* global asm block */
4989 /* special test for old K&R protos without explicit int
4990 type. Only accepted when defining global data */
4991 if (l
== VT_LOCAL
|| tok
< TOK_DEFINE
)
4995 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
4996 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
4998 /* we accept no variable after */
5002 while (1) { /* iterate thru each declaration */
5004 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
5008 type_to_str(buf
, sizeof(buf
), t
, get_tok_str(v
, NULL
));
5009 printf("type = '%s'\n", buf
);
5012 if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
5013 /* if old style function prototype, we accept a
5016 if (sym
->c
== FUNC_OLD
)
5017 func_decl_list(sym
);
5022 error("cannot use local functions");
5023 if ((type
.t
& VT_BTYPE
) != VT_FUNC
)
5024 expect("function definition");
5026 /* reject abstract declarators in function definition */
5028 while ((sym
= sym
->next
) != NULL
)
5029 if (!(sym
->v
& ~SYM_FIELD
))
5030 expect("identifier");
5032 /* XXX: cannot do better now: convert extern line to static inline */
5033 if ((type
.t
& (VT_EXTERN
| VT_INLINE
)) == (VT_EXTERN
| VT_INLINE
))
5034 type
.t
= (type
.t
& ~VT_EXTERN
) | VT_STATIC
;
5038 if ((sym
->type
.t
& VT_BTYPE
) != VT_FUNC
)
5041 r
= sym
->type
.ref
->r
;
5042 /* use func_call from prototype if not defined */
5043 if (FUNC_CALL(r
) != FUNC_CDECL
5044 && FUNC_CALL(type
.ref
->r
) == FUNC_CDECL
)
5045 FUNC_CALL(type
.ref
->r
) = FUNC_CALL(r
);
5047 /* use export from prototype */
5049 FUNC_EXPORT(type
.ref
->r
) = 1;
5051 /* use static from prototype */
5052 if (sym
->type
.t
& VT_STATIC
)
5053 type
.t
= (type
.t
& ~VT_EXTERN
) | VT_STATIC
;
5055 if (!is_compatible_types(&sym
->type
, &type
)) {
5057 error("incompatible types for redefinition of '%s'",
5058 get_tok_str(v
, NULL
));
5060 /* if symbol is already defined, then put complete type */
5063 /* put function symbol */
5064 sym
= global_identifier_push(v
, type
.t
, 0);
5065 sym
->type
.ref
= type
.ref
;
5068 /* static inline functions are just recorded as a kind
5069 of macro. Their code will be emitted at the end of
5070 the compilation unit only if they are used */
5071 if ((type
.t
& (VT_INLINE
| VT_STATIC
)) ==
5072 (VT_INLINE
| VT_STATIC
)) {
5073 TokenString func_str
;
5075 struct InlineFunc
*fn
;
5076 const char *filename
;
5078 tok_str_new(&func_str
);
5084 error("unexpected end of file");
5085 tok_str_add_tok(&func_str
);
5090 } else if (t
== '}') {
5092 if (block_level
== 0)
5096 tok_str_add(&func_str
, -1);
5097 tok_str_add(&func_str
, 0);
5098 filename
= file
? file
->filename
: "";
5099 fn
= tcc_malloc(sizeof *fn
+ strlen(filename
));
5100 strcpy(fn
->filename
, filename
);
5102 fn
->token_str
= func_str
.str
;
5103 dynarray_add((void ***)&tcc_state
->inline_fns
, &tcc_state
->nb_inline_fns
, fn
);
5106 /* compute text section */
5107 cur_text_section
= ad
.section
;
5108 if (!cur_text_section
)
5109 cur_text_section
= text_section
;
5110 sym
->r
= VT_SYM
| VT_CONST
;
5115 if (btype
.t
& VT_TYPEDEF
) {
5116 /* save typedefed type */
5117 /* XXX: test storage specifiers ? */
5118 sym
= sym_push(v
, &type
, 0, 0);
5119 sym
->type
.t
|= VT_TYPEDEF
;
5120 } else if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
5121 /* external function definition */
5122 /* specific case for func_call attribute */
5124 type
.ref
->r
= ad
.func_attr
;
5125 external_sym(v
, &type
, 0);
5127 /* not lvalue if array */
5129 if (!(type
.t
& VT_ARRAY
))
5130 r
|= lvalue_type(type
.t
);
5131 has_init
= (tok
== '=');
5132 if ((btype
.t
& VT_EXTERN
) ||
5133 ((type
.t
& VT_ARRAY
) && (type
.t
& VT_STATIC
) &&
5134 !has_init
&& l
== VT_CONST
&& type
.ref
->c
< 0)) {
5135 /* external variable */
5136 /* NOTE: as GCC, uninitialized global static
5137 arrays of null size are considered as
5139 #ifdef TCC_TARGET_PE
5140 if (FUNC_IMPORT(ad
.func_attr
))
5141 type
.t
|= VT_IMPORT
;
5143 external_sym(v
, &type
, r
);
5145 type
.t
|= (btype
.t
& VT_STATIC
); /* Retain "static". */
5146 if (type
.t
& VT_STATIC
)
5152 decl_initializer_alloc(&type
, &ad
, r
,