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
)) ==
1104 (VT_CONST
| VT_SYM
) ||
1105 (vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
)) == VT_LOCAL
)) {
1106 /* symbol + constant case */
1113 if (!nocode_wanted
) {
1114 /* call low level op generator */
1115 if (t1
== VT_LLONG
|| t2
== VT_LLONG
)
1126 /* generate a floating point operation with constant propagation */
1127 void gen_opif(int op
)
1135 /* currently, we cannot do computations with forward symbols */
1136 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
1137 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
1139 if (v1
->type
.t
== VT_FLOAT
) {
1142 } else if (v1
->type
.t
== VT_DOUBLE
) {
1150 /* NOTE: we only do constant propagation if finite number (not
1151 NaN or infinity) (ANSI spec) */
1152 if (!ieee_finite(f1
) || !ieee_finite(f2
))
1156 case '+': f1
+= f2
; break;
1157 case '-': f1
-= f2
; break;
1158 case '*': f1
*= f2
; break;
1162 error("division by zero in constant");
1167 /* XXX: also handles tests ? */
1171 /* XXX: overflow test ? */
1172 if (v1
->type
.t
== VT_FLOAT
) {
1174 } else if (v1
->type
.t
== VT_DOUBLE
) {
1182 if (!nocode_wanted
) {
1190 static int pointed_size(CType
*type
)
1193 return type_size(pointed_type(type
), &align
);
1196 static inline int is_null_pointer(SValue
*p
)
1198 if ((p
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
1200 return ((p
->type
.t
& VT_BTYPE
) == VT_INT
&& p
->c
.i
== 0) ||
1201 ((p
->type
.t
& VT_BTYPE
) == VT_LLONG
&& p
->c
.ll
== 0);
1204 static inline int is_integer_btype(int bt
)
1206 return (bt
== VT_BYTE
|| bt
== VT_SHORT
||
1207 bt
== VT_INT
|| bt
== VT_LLONG
);
1210 /* check types for comparison or substraction of pointers */
1211 static void check_comparison_pointer_types(SValue
*p1
, SValue
*p2
, int op
)
1213 CType
*type1
, *type2
, tmp_type1
, tmp_type2
;
1216 /* null pointers are accepted for all comparisons as gcc */
1217 if (is_null_pointer(p1
) || is_null_pointer(p2
))
1221 bt1
= type1
->t
& VT_BTYPE
;
1222 bt2
= type2
->t
& VT_BTYPE
;
1223 /* accept comparison between pointer and integer with a warning */
1224 if ((is_integer_btype(bt1
) || is_integer_btype(bt2
)) && op
!= '-') {
1225 if (op
!= TOK_LOR
&& op
!= TOK_LAND
)
1226 warning("comparison between pointer and integer");
1230 /* both must be pointers or implicit function pointers */
1231 if (bt1
== VT_PTR
) {
1232 type1
= pointed_type(type1
);
1233 } else if (bt1
!= VT_FUNC
)
1234 goto invalid_operands
;
1236 if (bt2
== VT_PTR
) {
1237 type2
= pointed_type(type2
);
1238 } else if (bt2
!= VT_FUNC
) {
1240 error("invalid operands to binary %s", get_tok_str(op
, NULL
));
1242 if ((type1
->t
& VT_BTYPE
) == VT_VOID
||
1243 (type2
->t
& VT_BTYPE
) == VT_VOID
)
1247 tmp_type1
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
1248 tmp_type2
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
1249 if (!is_compatible_types(&tmp_type1
, &tmp_type2
)) {
1250 /* gcc-like error if '-' is used */
1252 goto invalid_operands
;
1254 warning("comparison of distinct pointer types lacks a cast");
1258 /* generic gen_op: handles types problems */
1261 int u
, t1
, t2
, bt1
, bt2
, t
;
1264 t1
= vtop
[-1].type
.t
;
1265 t2
= vtop
[0].type
.t
;
1266 bt1
= t1
& VT_BTYPE
;
1267 bt2
= t2
& VT_BTYPE
;
1269 if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
1270 /* at least one operand is a pointer */
1271 /* relationnal op: must be both pointers */
1272 if (op
>= TOK_ULT
&& op
<= TOK_LOR
) {
1273 check_comparison_pointer_types(vtop
- 1, vtop
, op
);
1274 /* pointers are handled are unsigned */
1275 #ifdef TCC_TARGET_X86_64
1276 t
= VT_LLONG
| VT_UNSIGNED
;
1278 t
= VT_INT
| VT_UNSIGNED
;
1282 /* if both pointers, then it must be the '-' op */
1283 if (bt1
== VT_PTR
&& bt2
== VT_PTR
) {
1285 error("cannot use pointers here");
1286 check_comparison_pointer_types(vtop
- 1, vtop
, op
);
1287 /* XXX: check that types are compatible */
1288 u
= pointed_size(&vtop
[-1].type
);
1290 /* set to integer type */
1291 #ifdef TCC_TARGET_X86_64
1292 vtop
->type
.t
= VT_LLONG
;
1294 vtop
->type
.t
= VT_INT
;
1299 /* exactly one pointer : must be '+' or '-'. */
1300 if (op
!= '-' && op
!= '+')
1301 error("cannot use pointers here");
1302 /* Put pointer as first operand */
1303 if (bt2
== VT_PTR
) {
1307 type1
= vtop
[-1].type
;
1308 #ifdef TCC_TARGET_X86_64
1309 vpushll(pointed_size(&vtop
[-1].type
));
1311 /* XXX: cast to int ? (long long case) */
1312 vpushi(pointed_size(&vtop
[-1].type
));
1315 #ifdef CONFIG_TCC_BCHECK
1316 /* if evaluating constant expression, no code should be
1317 generated, so no bound check */
1318 if (tcc_state
->do_bounds_check
&& !const_wanted
) {
1319 /* if bounded pointers, we generate a special code to
1326 gen_bounded_ptr_add();
1332 /* put again type if gen_opic() swaped operands */
1335 } else if (is_float(bt1
) || is_float(bt2
)) {
1336 /* compute bigger type and do implicit casts */
1337 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
1339 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
1344 /* floats can only be used for a few operations */
1345 if (op
!= '+' && op
!= '-' && op
!= '*' && op
!= '/' &&
1346 (op
< TOK_ULT
|| op
> TOK_GT
))
1347 error("invalid operands for binary operation");
1349 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
1350 /* cast to biggest op */
1352 /* convert to unsigned if it does not fit in a long long */
1353 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
1354 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
1358 /* integer operations */
1360 /* convert to unsigned if it does not fit in an integer */
1361 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
1362 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
1365 /* XXX: currently, some unsigned operations are explicit, so
1366 we modify them here */
1367 if (t
& VT_UNSIGNED
) {
1374 else if (op
== TOK_LT
)
1376 else if (op
== TOK_GT
)
1378 else if (op
== TOK_LE
)
1380 else if (op
== TOK_GE
)
1387 /* special case for shifts and long long: we keep the shift as
1389 if (op
== TOK_SHR
|| op
== TOK_SAR
|| op
== TOK_SHL
)
1396 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
1397 /* relationnal op: the result is an int */
1398 vtop
->type
.t
= VT_INT
;
1405 #ifndef TCC_TARGET_ARM
1406 /* generic itof for unsigned long long case */
1407 void gen_cvt_itof1(int t
)
1409 if ((vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
)) ==
1410 (VT_LLONG
| VT_UNSIGNED
)) {
1413 vpush_global_sym(&func_old_type
, TOK___floatundisf
);
1414 #if LDOUBLE_SIZE != 8
1415 else if (t
== VT_LDOUBLE
)
1416 vpush_global_sym(&func_old_type
, TOK___floatundixf
);
1419 vpush_global_sym(&func_old_type
, TOK___floatundidf
);
1423 vtop
->r
= reg_fret(t
);
1430 /* generic ftoi for unsigned long long case */
1431 void gen_cvt_ftoi1(int t
)
1435 if (t
== (VT_LLONG
| VT_UNSIGNED
)) {
1436 /* not handled natively */
1437 st
= vtop
->type
.t
& VT_BTYPE
;
1439 vpush_global_sym(&func_old_type
, TOK___fixunssfdi
);
1440 #if LDOUBLE_SIZE != 8
1441 else if (st
== VT_LDOUBLE
)
1442 vpush_global_sym(&func_old_type
, TOK___fixunsxfdi
);
1445 vpush_global_sym(&func_old_type
, TOK___fixunsdfdi
);
1450 vtop
->r2
= REG_LRET
;
1456 /* force char or short cast */
1457 void force_charshort_cast(int t
)
1461 /* XXX: add optimization if lvalue : just change type and offset */
1466 if (t
& VT_UNSIGNED
) {
1467 vpushi((1 << bits
) - 1);
1473 /* result must be signed or the SAR is converted to an SHL
1474 This was not the case when "t" was a signed short
1475 and the last value on the stack was an unsigned int */
1476 vtop
->type
.t
&= ~VT_UNSIGNED
;
1482 /* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
1483 static void gen_cast(CType
*type
)
1485 int sbt
, dbt
, sf
, df
, c
, p
;
1487 /* special delayed cast for char/short */
1488 /* XXX: in some cases (multiple cascaded casts), it may still
1490 if (vtop
->r
& VT_MUSTCAST
) {
1491 vtop
->r
&= ~VT_MUSTCAST
;
1492 force_charshort_cast(vtop
->type
.t
);
1495 /* bitfields first get cast to ints */
1496 if (vtop
->type
.t
& VT_BITFIELD
) {
1500 dbt
= type
->t
& (VT_BTYPE
| VT_UNSIGNED
);
1501 sbt
= vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
);
1506 c
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
1507 p
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == (VT_CONST
| VT_SYM
);
1509 /* constant case: we can do it now */
1510 /* XXX: in ISOC, cannot do it if error in convert */
1511 if (sbt
== VT_FLOAT
)
1512 vtop
->c
.ld
= vtop
->c
.f
;
1513 else if (sbt
== VT_DOUBLE
)
1514 vtop
->c
.ld
= vtop
->c
.d
;
1517 if ((sbt
& VT_BTYPE
) == VT_LLONG
) {
1518 if (sbt
& VT_UNSIGNED
)
1519 vtop
->c
.ld
= vtop
->c
.ull
;
1521 vtop
->c
.ld
= vtop
->c
.ll
;
1523 if (sbt
& VT_UNSIGNED
)
1524 vtop
->c
.ld
= vtop
->c
.ui
;
1526 vtop
->c
.ld
= vtop
->c
.i
;
1529 if (dbt
== VT_FLOAT
)
1530 vtop
->c
.f
= (float)vtop
->c
.ld
;
1531 else if (dbt
== VT_DOUBLE
)
1532 vtop
->c
.d
= (double)vtop
->c
.ld
;
1533 } else if (sf
&& dbt
== (VT_LLONG
|VT_UNSIGNED
)) {
1534 vtop
->c
.ull
= (unsigned long long)vtop
->c
.ld
;
1535 } else if (sf
&& dbt
== VT_BOOL
) {
1536 vtop
->c
.i
= (vtop
->c
.ld
!= 0);
1539 vtop
->c
.ll
= (long long)vtop
->c
.ld
;
1540 else if (sbt
== (VT_LLONG
|VT_UNSIGNED
))
1541 vtop
->c
.ll
= vtop
->c
.ull
;
1542 else if (sbt
& VT_UNSIGNED
)
1543 vtop
->c
.ll
= vtop
->c
.ui
;
1544 else if (sbt
!= VT_LLONG
)
1545 vtop
->c
.ll
= vtop
->c
.i
;
1547 if (dbt
== (VT_LLONG
|VT_UNSIGNED
))
1548 vtop
->c
.ull
= vtop
->c
.ll
;
1549 else if (dbt
== VT_BOOL
)
1550 vtop
->c
.i
= (vtop
->c
.ll
!= 0);
1551 else if (dbt
!= VT_LLONG
) {
1553 if ((dbt
& VT_BTYPE
) == VT_BYTE
)
1555 else if ((dbt
& VT_BTYPE
) == VT_SHORT
)
1558 if(dbt
& VT_UNSIGNED
)
1559 vtop
->c
.ui
= ((unsigned int)vtop
->c
.ll
<< s
) >> s
;
1561 vtop
->c
.i
= ((int)vtop
->c
.ll
<< s
) >> s
;
1564 } else if (p
&& dbt
== VT_BOOL
) {
1567 } else if (!nocode_wanted
) {
1568 /* non constant case: generate code */
1570 /* convert from fp to fp */
1573 /* convert int to fp */
1576 /* convert fp to int */
1577 if (dbt
== VT_BOOL
) {
1581 /* we handle char/short/etc... with generic code */
1582 if (dbt
!= (VT_INT
| VT_UNSIGNED
) &&
1583 dbt
!= (VT_LLONG
| VT_UNSIGNED
) &&
1587 if (dbt
== VT_INT
&& (type
->t
& (VT_BTYPE
| VT_UNSIGNED
)) != dbt
) {
1588 /* additional cast for char/short... */
1593 #ifndef TCC_TARGET_X86_64
1594 } else if ((dbt
& VT_BTYPE
) == VT_LLONG
) {
1595 if ((sbt
& VT_BTYPE
) != VT_LLONG
) {
1596 /* scalar to long long */
1597 /* machine independent conversion */
1599 /* generate high word */
1600 if (sbt
== (VT_INT
| VT_UNSIGNED
)) {
1604 if (sbt
== VT_PTR
) {
1605 /* cast from pointer to int before we apply
1606 shift operation, which pointers don't support*/
1607 gen_cast(&int_type
);
1613 /* patch second register */
1614 vtop
[-1].r2
= vtop
->r
;
1618 } else if ((dbt
& VT_BTYPE
) == VT_LLONG
||
1619 (dbt
& VT_BTYPE
) == VT_PTR
) {
1620 /* XXX: not sure if this is perfect... need more tests */
1621 if ((sbt
& VT_BTYPE
) != VT_LLONG
) {
1623 if (sbt
!= (VT_INT
| VT_UNSIGNED
) &&
1624 sbt
!= VT_PTR
&& sbt
!= VT_FUNC
) {
1625 /* x86_64 specific: movslq */
1627 o(0xc0 + (REG_VALUE(r
) << 3) + REG_VALUE(r
));
1631 } else if (dbt
== VT_BOOL
) {
1632 /* scalar to bool */
1635 } else if ((dbt
& VT_BTYPE
) == VT_BYTE
||
1636 (dbt
& VT_BTYPE
) == VT_SHORT
) {
1637 if (sbt
== VT_PTR
) {
1638 vtop
->type
.t
= VT_INT
;
1639 warning("nonportable conversion from pointer to char/short");
1641 force_charshort_cast(dbt
);
1642 } else if ((dbt
& VT_BTYPE
) == VT_INT
) {
1644 if (sbt
== VT_LLONG
) {
1645 /* from long long: just take low order word */
1649 /* if lvalue and single word type, nothing to do because
1650 the lvalue already contains the real type size (see
1651 VT_LVAL_xxx constants) */
1654 } else if ((dbt
& VT_BTYPE
) == VT_PTR
&& !(vtop
->r
& VT_LVAL
)) {
1655 /* if we are casting between pointer types,
1656 we must update the VT_LVAL_xxx size */
1657 vtop
->r
= (vtop
->r
& ~VT_LVAL_TYPE
)
1658 | (lvalue_type(type
->ref
->type
.t
) & VT_LVAL_TYPE
);
1663 /* return type size. Put alignment at 'a' */
1664 static int type_size(CType
*type
, int *a
)
1669 bt
= type
->t
& VT_BTYPE
;
1670 if (bt
== VT_STRUCT
) {
1675 } else if (bt
== VT_PTR
) {
1676 if (type
->t
& VT_ARRAY
) {
1680 ts
= type_size(&s
->type
, a
);
1682 if (ts
< 0 && s
->c
< 0)
1690 } else if (bt
== VT_LDOUBLE
) {
1692 return LDOUBLE_SIZE
;
1693 } else if (bt
== VT_DOUBLE
|| bt
== VT_LLONG
) {
1694 #ifdef TCC_TARGET_I386
1695 #ifdef TCC_TARGET_PE
1700 #elif defined(TCC_TARGET_ARM)
1710 } else if (bt
== VT_INT
|| bt
== VT_ENUM
|| bt
== VT_FLOAT
) {
1713 } else if (bt
== VT_SHORT
) {
1717 /* char, void, function, _Bool */
1723 /* return the pointed type of t */
1724 static inline CType
*pointed_type(CType
*type
)
1726 return &type
->ref
->type
;
1729 /* modify type so that its it is a pointer to type. */
1730 static void mk_pointer(CType
*type
)
1733 s
= sym_push(SYM_FIELD
, type
, 0, -1);
1734 type
->t
= VT_PTR
| (type
->t
& ~VT_TYPE
);
1738 /* compare function types. OLD functions match any new functions */
1739 static int is_compatible_func(CType
*type1
, CType
*type2
)
1745 if (!is_compatible_types(&s1
->type
, &s2
->type
))
1747 /* check func_call */
1748 if (FUNC_CALL(s1
->r
) != FUNC_CALL(s2
->r
))
1750 /* XXX: not complete */
1751 if (s1
->c
== FUNC_OLD
|| s2
->c
== FUNC_OLD
)
1755 while (s1
!= NULL
) {
1758 if (!is_compatible_parameter_types(&s1
->type
, &s2
->type
))
1768 /* return true if type1 and type2 are the same. If unqualified is
1769 true, qualifiers on the types are ignored.
1771 - enums are not checked as gcc __builtin_types_compatible_p ()
1773 static int compare_types(CType
*type1
, CType
*type2
, int unqualified
)
1777 t1
= type1
->t
& VT_TYPE
;
1778 t2
= type2
->t
& VT_TYPE
;
1780 /* strip qualifiers before comparing */
1781 t1
&= ~(VT_CONSTANT
| VT_VOLATILE
);
1782 t2
&= ~(VT_CONSTANT
| VT_VOLATILE
);
1784 /* XXX: bitfields ? */
1787 /* test more complicated cases */
1788 bt1
= t1
& VT_BTYPE
;
1789 if (bt1
== VT_PTR
) {
1790 type1
= pointed_type(type1
);
1791 type2
= pointed_type(type2
);
1792 return is_compatible_types(type1
, type2
);
1793 } else if (bt1
== VT_STRUCT
) {
1794 return (type1
->ref
== type2
->ref
);
1795 } else if (bt1
== VT_FUNC
) {
1796 return is_compatible_func(type1
, type2
);
1802 /* return true if type1 and type2 are exactly the same (including
1805 static int is_compatible_types(CType
*type1
, CType
*type2
)
1807 return compare_types(type1
,type2
,0);
1810 /* return true if type1 and type2 are the same (ignoring qualifiers).
1812 static int is_compatible_parameter_types(CType
*type1
, CType
*type2
)
1814 return compare_types(type1
,type2
,1);
1817 /* print a type. If 'varstr' is not NULL, then the variable is also
1818 printed in the type */
1820 /* XXX: add array and function pointers */
1821 void type_to_str(char *buf
, int buf_size
,
1822 CType
*type
, const char *varstr
)
1829 t
= type
->t
& VT_TYPE
;
1832 if (t
& VT_CONSTANT
)
1833 pstrcat(buf
, buf_size
, "const ");
1834 if (t
& VT_VOLATILE
)
1835 pstrcat(buf
, buf_size
, "volatile ");
1836 if (t
& VT_UNSIGNED
)
1837 pstrcat(buf
, buf_size
, "unsigned ");
1867 tstr
= "long double";
1869 pstrcat(buf
, buf_size
, tstr
);
1873 if (bt
== VT_STRUCT
)
1877 pstrcat(buf
, buf_size
, tstr
);
1878 v
= type
->ref
->v
& ~SYM_STRUCT
;
1879 if (v
>= SYM_FIRST_ANOM
)
1880 pstrcat(buf
, buf_size
, "<anonymous>");
1882 pstrcat(buf
, buf_size
, get_tok_str(v
, NULL
));
1886 type_to_str(buf
, buf_size
, &s
->type
, varstr
);
1887 pstrcat(buf
, buf_size
, "(");
1889 while (sa
!= NULL
) {
1890 type_to_str(buf1
, sizeof(buf1
), &sa
->type
, NULL
);
1891 pstrcat(buf
, buf_size
, buf1
);
1894 pstrcat(buf
, buf_size
, ", ");
1896 pstrcat(buf
, buf_size
, ")");
1900 pstrcpy(buf1
, sizeof(buf1
), "*");
1902 pstrcat(buf1
, sizeof(buf1
), varstr
);
1903 type_to_str(buf
, buf_size
, &s
->type
, buf1
);
1907 pstrcat(buf
, buf_size
, " ");
1908 pstrcat(buf
, buf_size
, varstr
);
1913 /* verify type compatibility to store vtop in 'dt' type, and generate
1915 static void gen_assign_cast(CType
*dt
)
1917 CType
*st
, *type1
, *type2
, tmp_type1
, tmp_type2
;
1918 char buf1
[256], buf2
[256];
1921 st
= &vtop
->type
; /* source type */
1922 dbt
= dt
->t
& VT_BTYPE
;
1923 sbt
= st
->t
& VT_BTYPE
;
1924 if (dt
->t
& VT_CONSTANT
)
1925 warning("assignment of read-only location");
1928 /* special cases for pointers */
1929 /* '0' can also be a pointer */
1930 if (is_null_pointer(vtop
))
1932 /* accept implicit pointer to integer cast with warning */
1933 if (is_integer_btype(sbt
)) {
1934 warning("assignment makes pointer from integer without a cast");
1937 type1
= pointed_type(dt
);
1938 /* a function is implicitely a function pointer */
1939 if (sbt
== VT_FUNC
) {
1940 if ((type1
->t
& VT_BTYPE
) != VT_VOID
&&
1941 !is_compatible_types(pointed_type(dt
), st
))
1948 type2
= pointed_type(st
);
1949 if ((type1
->t
& VT_BTYPE
) == VT_VOID
||
1950 (type2
->t
& VT_BTYPE
) == VT_VOID
) {
1951 /* void * can match anything */
1953 /* exact type match, except for unsigned */
1956 tmp_type1
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
1957 tmp_type2
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
1958 if (!is_compatible_types(&tmp_type1
, &tmp_type2
))
1959 warning("assignment from incompatible pointer type");
1961 /* check const and volatile */
1962 if ((!(type1
->t
& VT_CONSTANT
) && (type2
->t
& VT_CONSTANT
)) ||
1963 (!(type1
->t
& VT_VOLATILE
) && (type2
->t
& VT_VOLATILE
)))
1964 warning("assignment discards qualifiers from pointer target type");
1970 if (sbt
== VT_PTR
|| sbt
== VT_FUNC
) {
1971 warning("assignment makes integer from pointer without a cast");
1973 /* XXX: more tests */
1978 tmp_type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
1979 tmp_type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
1980 if (!is_compatible_types(&tmp_type1
, &tmp_type2
)) {
1982 type_to_str(buf1
, sizeof(buf1
), st
, NULL
);
1983 type_to_str(buf2
, sizeof(buf2
), dt
, NULL
);
1984 error("cannot cast '%s' to '%s'", buf1
, buf2
);
1992 /* store vtop in lvalue pushed on stack */
1995 int sbt
, dbt
, ft
, r
, t
, size
, align
, bit_size
, bit_pos
, rc
, delayed_cast
;
1997 ft
= vtop
[-1].type
.t
;
1998 sbt
= vtop
->type
.t
& VT_BTYPE
;
1999 dbt
= ft
& VT_BTYPE
;
2000 if (((sbt
== VT_INT
|| sbt
== VT_SHORT
) && dbt
== VT_BYTE
) ||
2001 (sbt
== VT_INT
&& dbt
== VT_SHORT
)) {
2002 /* optimize char/short casts */
2003 delayed_cast
= VT_MUSTCAST
;
2004 vtop
->type
.t
= ft
& (VT_TYPE
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
)));
2005 /* XXX: factorize */
2006 if (ft
& VT_CONSTANT
)
2007 warning("assignment of read-only location");
2010 if (!(ft
& VT_BITFIELD
))
2011 gen_assign_cast(&vtop
[-1].type
);
2014 if (sbt
== VT_STRUCT
) {
2015 /* if structure, only generate pointer */
2016 /* structure assignment : generate memcpy */
2017 /* XXX: optimize if small size */
2018 if (!nocode_wanted
) {
2019 size
= type_size(&vtop
->type
, &align
);
2023 vpush_global_sym(&func_old_type
, TOK_memcpy8
);
2024 else if(!(align
& 3))
2025 vpush_global_sym(&func_old_type
, TOK_memcpy4
);
2028 vpush_global_sym(&func_old_type
, TOK_memcpy
);
2032 vtop
->type
.t
= VT_PTR
;
2036 vtop
->type
.t
= VT_PTR
;
2048 /* leave source on stack */
2049 } else if (ft
& VT_BITFIELD
) {
2050 /* bitfield store handling */
2051 bit_pos
= (ft
>> VT_STRUCT_SHIFT
) & 0x3f;
2052 bit_size
= (ft
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
2053 /* remove bit field info to avoid loops */
2054 vtop
[-1].type
.t
= ft
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
2056 /* duplicate source into other register */
2061 if((ft
& VT_BTYPE
) == VT_BOOL
) {
2062 gen_cast(&vtop
[-1].type
);
2063 vtop
[-1].type
.t
= (vtop
[-1].type
.t
& ~VT_BTYPE
) | (VT_BYTE
| VT_UNSIGNED
);
2066 /* duplicate destination */
2068 vtop
[-1] = vtop
[-2];
2070 /* mask and shift source */
2071 if((ft
& VT_BTYPE
) != VT_BOOL
) {
2072 if((ft
& VT_BTYPE
) == VT_LLONG
) {
2073 vpushll((1ULL << bit_size
) - 1ULL);
2075 vpushi((1 << bit_size
) - 1);
2081 /* load destination, mask and or with source */
2083 if((ft
& VT_BTYPE
) == VT_LLONG
) {
2084 vpushll(~(((1ULL << bit_size
) - 1ULL) << bit_pos
));
2086 vpushi(~(((1 << bit_size
) - 1) << bit_pos
));
2093 /* pop off shifted source from "duplicate source..." above */
2097 #ifdef CONFIG_TCC_BCHECK
2098 /* bound check case */
2099 if (vtop
[-1].r
& VT_MUSTBOUND
) {
2105 if (!nocode_wanted
) {
2109 #ifdef TCC_TARGET_X86_64
2110 if ((ft
& VT_BTYPE
) == VT_LDOUBLE
) {
2115 r
= gv(rc
); /* generate value */
2116 /* if lvalue was saved on stack, must read it */
2117 if ((vtop
[-1].r
& VT_VALMASK
) == VT_LLOCAL
) {
2119 t
= get_reg(RC_INT
);
2120 #ifdef TCC_TARGET_X86_64
2125 sv
.r
= VT_LOCAL
| VT_LVAL
;
2126 sv
.c
.ul
= vtop
[-1].c
.ul
;
2128 vtop
[-1].r
= t
| VT_LVAL
;
2131 #ifndef TCC_TARGET_X86_64
2132 /* two word case handling : store second register at word + 4 */
2133 if ((ft
& VT_BTYPE
) == VT_LLONG
) {
2135 /* convert to int to increment easily */
2136 vtop
->type
.t
= VT_INT
;
2142 /* XXX: it works because r2 is spilled last ! */
2143 store(vtop
->r2
, vtop
- 1);
2148 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
2149 vtop
->r
|= delayed_cast
;
2153 /* post defines POST/PRE add. c is the token ++ or -- */
2154 void inc(int post
, int c
)
2157 vdup(); /* save lvalue */
2159 gv_dup(); /* duplicate value */
2164 vpushi(c
- TOK_MID
);
2166 vstore(); /* store value */
2168 vpop(); /* if post op, return saved value */
2171 /* Parse GNUC __attribute__ extension. Currently, the following
2172 extensions are recognized:
2173 - aligned(n) : set data/function alignment.
2174 - packed : force data alignment to 1
2175 - section(x) : generate data/code in this section.
2176 - unused : currently ignored, but may be used someday.
2177 - regparm(n) : pass function parameters in registers (i386 only)
2179 static void parse_attribute(AttributeDef
*ad
)
2183 while (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
) {
2187 while (tok
!= ')') {
2188 if (tok
< TOK_IDENT
)
2189 expect("attribute name");
2197 expect("section name");
2198 ad
->section
= find_section(tcc_state
, (char *)tokc
.cstr
->data
);
2207 if (n
<= 0 || (n
& (n
- 1)) != 0)
2208 error("alignment must be a positive power of two");
2221 /* currently, no need to handle it because tcc does not
2222 track unused objects */
2226 /* currently, no need to handle it because tcc does not
2227 track unused objects */
2232 FUNC_CALL(ad
->func_attr
) = FUNC_CDECL
;
2237 FUNC_CALL(ad
->func_attr
) = FUNC_STDCALL
;
2239 #ifdef TCC_TARGET_I386
2249 FUNC_CALL(ad
->func_attr
) = FUNC_FASTCALL1
+ n
- 1;
2255 FUNC_CALL(ad
->func_attr
) = FUNC_FASTCALLW
;
2259 FUNC_EXPORT(ad
->func_attr
) = 1;
2262 if (tcc_state
->warn_unsupported
)
2263 warning("'%s' attribute ignored", get_tok_str(t
, NULL
));
2264 /* skip parameters */
2266 int parenthesis
= 0;
2270 else if (tok
== ')')
2273 } while (parenthesis
&& tok
!= -1);
2286 /* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
2287 static void struct_decl(CType
*type
, int u
)
2289 int a
, v
, size
, align
, maxalign
, c
, offset
;
2290 int bit_size
, bit_pos
, bsize
, bt
, lbit_pos
, prevbt
;
2291 Sym
*s
, *ss
, *ass
, **ps
;
2295 a
= tok
; /* save decl type */
2300 /* struct already defined ? return it */
2302 expect("struct/union/enum name");
2306 error("invalid type");
2313 /* we put an undefined size for struct/union */
2314 s
= sym_push(v
| SYM_STRUCT
, &type1
, 0, -1);
2315 s
->r
= 0; /* default alignment is zero as gcc */
2316 /* put struct/union/enum name in type */
2324 error("struct/union/enum already defined");
2325 /* cannot be empty */
2327 /* non empty enums are not allowed */
2328 if (a
== TOK_ENUM
) {
2332 expect("identifier");
2338 /* enum symbols have static storage */
2339 ss
= sym_push(v
, &int_type
, VT_CONST
, c
);
2340 ss
->type
.t
|= VT_STATIC
;
2345 /* NOTE: we accept a trailing comma */
2356 while (tok
!= '}') {
2357 parse_btype(&btype
, &ad
);
2363 type_decl(&type1
, &ad
, &v
, TYPE_DIRECT
| TYPE_ABSTRACT
);
2364 if (v
== 0 && (type1
.t
& VT_BTYPE
) != VT_STRUCT
)
2365 expect("identifier");
2366 if ((type1
.t
& VT_BTYPE
) == VT_FUNC
||
2367 (type1
.t
& (VT_TYPEDEF
| VT_STATIC
| VT_EXTERN
| VT_INLINE
)))
2368 error("invalid type for '%s'",
2369 get_tok_str(v
, NULL
));
2373 bit_size
= expr_const();
2374 /* XXX: handle v = 0 case for messages */
2376 error("negative width in bit-field '%s'",
2377 get_tok_str(v
, NULL
));
2378 if (v
&& bit_size
== 0)
2379 error("zero width for bit-field '%s'",
2380 get_tok_str(v
, NULL
));
2382 size
= type_size(&type1
, &align
);
2384 if (align
< ad
.aligned
)
2386 } else if (ad
.packed
) {
2388 } else if (*tcc_state
->pack_stack_ptr
) {
2389 if (align
> *tcc_state
->pack_stack_ptr
)
2390 align
= *tcc_state
->pack_stack_ptr
;
2393 if (bit_size
>= 0) {
2394 bt
= type1
.t
& VT_BTYPE
;
2401 error("bitfields must have scalar type");
2403 if (bit_size
> bsize
) {
2404 error("width of '%s' exceeds its type",
2405 get_tok_str(v
, NULL
));
2406 } else if (bit_size
== bsize
) {
2407 /* no need for bit fields */
2409 } else if (bit_size
== 0) {
2410 /* XXX: what to do if only padding in a
2412 /* zero size: means to pad */
2415 /* we do not have enough room ?
2416 did the type change?
2418 if ((bit_pos
+ bit_size
) > bsize
||
2419 bt
!= prevbt
|| a
== TOK_UNION
)
2422 /* XXX: handle LSB first */
2423 type1
.t
|= VT_BITFIELD
|
2424 (bit_pos
<< VT_STRUCT_SHIFT
) |
2425 (bit_size
<< (VT_STRUCT_SHIFT
+ 6));
2426 bit_pos
+= bit_size
;
2432 if (v
!= 0 || (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
2433 /* add new memory data only if starting
2435 if (lbit_pos
== 0) {
2436 if (a
== TOK_STRUCT
) {
2437 c
= (c
+ align
- 1) & -align
;
2446 if (align
> maxalign
)
2450 printf("add field %s offset=%d",
2451 get_tok_str(v
, NULL
), offset
);
2452 if (type1
.t
& VT_BITFIELD
) {
2453 printf(" pos=%d size=%d",
2454 (type1
.t
>> VT_STRUCT_SHIFT
) & 0x3f,
2455 (type1
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f);
2460 if (v
== 0 && (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
2462 while ((ass
= ass
->next
) != NULL
) {
2463 ss
= sym_push(ass
->v
, &ass
->type
, 0, offset
+ ass
->c
);
2468 ss
= sym_push(v
| SYM_FIELD
, &type1
, 0, offset
);
2472 if (tok
== ';' || tok
== TOK_EOF
)
2479 /* store size and alignment */
2480 s
->c
= (c
+ maxalign
- 1) & -maxalign
;
2486 /* return 0 if no type declaration. otherwise, return the basic type
2489 static int parse_btype(CType
*type
, AttributeDef
*ad
)
2491 int t
, u
, type_found
, typespec_found
, typedef_found
;
2495 memset(ad
, 0, sizeof(AttributeDef
));
2503 /* currently, we really ignore extension */
2513 if ((t
& VT_BTYPE
) != 0)
2514 error("too many basic types");
2530 if ((t
& VT_BTYPE
) == VT_DOUBLE
) {
2531 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
2532 } else if ((t
& VT_BTYPE
) == VT_LONG
) {
2533 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
2547 if ((t
& VT_BTYPE
) == VT_LONG
) {
2548 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
2555 struct_decl(&type1
, VT_ENUM
);
2558 type
->ref
= type1
.ref
;
2562 struct_decl(&type1
, VT_STRUCT
);
2565 /* type modifiers */
2618 /* GNUC attribute */
2619 case TOK_ATTRIBUTE1
:
2620 case TOK_ATTRIBUTE2
:
2621 parse_attribute(ad
);
2628 parse_expr_type(&type1
);
2631 if (typespec_found
|| typedef_found
)
2634 if (!s
|| !(s
->type
.t
& VT_TYPEDEF
))
2637 t
|= (s
->type
.t
& ~VT_TYPEDEF
);
2638 type
->ref
= s
->type
.ref
;
2646 if ((t
& (VT_SIGNED
|VT_UNSIGNED
)) == (VT_SIGNED
|VT_UNSIGNED
))
2647 error("signed and unsigned modifier");
2648 if (tcc_state
->char_is_unsigned
) {
2649 if ((t
& (VT_SIGNED
|VT_UNSIGNED
|VT_BTYPE
)) == VT_BYTE
)
2654 /* long is never used as type */
2655 if ((t
& VT_BTYPE
) == VT_LONG
)
2656 #ifndef TCC_TARGET_X86_64
2657 t
= (t
& ~VT_BTYPE
) | VT_INT
;
2659 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
2665 /* convert a function parameter type (array to pointer and function to
2666 function pointer) */
2667 static inline void convert_parameter_type(CType
*pt
)
2669 /* remove const and volatile qualifiers (XXX: const could be used
2670 to indicate a const function parameter */
2671 pt
->t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
2672 /* array must be transformed to pointer according to ANSI C */
2674 if ((pt
->t
& VT_BTYPE
) == VT_FUNC
) {
2679 static void post_type(CType
*type
, AttributeDef
*ad
)
2681 int n
, l
, t1
, arg_size
, align
;
2682 Sym
**plast
, *s
, *first
;
2687 /* function declaration */
2695 /* read param name and compute offset */
2696 if (l
!= FUNC_OLD
) {
2697 if (!parse_btype(&pt
, &ad1
)) {
2699 error("invalid type");
2706 if ((pt
.t
& VT_BTYPE
) == VT_VOID
&& tok
== ')')
2708 type_decl(&pt
, &ad1
, &n
, TYPE_DIRECT
| TYPE_ABSTRACT
);
2709 if ((pt
.t
& VT_BTYPE
) == VT_VOID
)
2710 error("parameter declared as void");
2711 arg_size
+= (type_size(&pt
, &align
) + 3) & ~3;
2716 expect("identifier");
2720 convert_parameter_type(&pt
);
2721 s
= sym_push(n
| SYM_FIELD
, &pt
, 0, 0);
2727 if (l
== FUNC_NEW
&& tok
== TOK_DOTS
) {
2734 /* if no parameters, then old type prototype */
2738 t1
= type
->t
& VT_STORAGE
;
2739 /* NOTE: const is ignored in returned type as it has a special
2740 meaning in gcc / C++ */
2741 type
->t
&= ~(VT_STORAGE
| VT_CONSTANT
);
2742 post_type(type
, ad
);
2743 /* we push a anonymous symbol which will contain the function prototype */
2744 FUNC_ARGS(ad
->func_attr
) = arg_size
;
2745 s
= sym_push(SYM_FIELD
, type
, ad
->func_attr
, l
);
2747 type
->t
= t1
| VT_FUNC
;
2749 } else if (tok
== '[') {
2750 /* array definition */
2752 if (tok
== TOK_RESTRICT1
)
2758 error("invalid array size");
2761 /* parse next post type */
2762 t1
= type
->t
& VT_STORAGE
;
2763 type
->t
&= ~VT_STORAGE
;
2764 post_type(type
, ad
);
2766 /* we push a anonymous symbol which will contain the array
2768 s
= sym_push(SYM_FIELD
, type
, 0, n
);
2769 type
->t
= t1
| VT_ARRAY
| VT_PTR
;
2774 /* Parse a type declaration (except basic type), and return the type
2775 in 'type'. 'td' is a bitmask indicating which kind of type decl is
2776 expected. 'type' should contain the basic type. 'ad' is the
2777 attribute definition of the basic type. It can be modified by
2780 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
)
2783 CType type1
, *type2
;
2786 while (tok
== '*') {
2794 qualifiers
|= VT_CONSTANT
;
2799 qualifiers
|= VT_VOLATILE
;
2807 type
->t
|= qualifiers
;
2810 /* XXX: clarify attribute handling */
2811 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
2812 parse_attribute(ad
);
2814 /* recursive type */
2815 /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
2816 type1
.t
= 0; /* XXX: same as int */
2819 /* XXX: this is not correct to modify 'ad' at this point, but
2820 the syntax is not clear */
2821 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
2822 parse_attribute(ad
);
2823 type_decl(&type1
, ad
, v
, td
);
2826 /* type identifier */
2827 if (tok
>= TOK_IDENT
&& (td
& TYPE_DIRECT
)) {
2831 if (!(td
& TYPE_ABSTRACT
))
2832 expect("identifier");
2836 post_type(type
, ad
);
2837 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
2838 parse_attribute(ad
);
2841 /* append type at the end of type1 */
2854 /* compute the lvalue VT_LVAL_xxx needed to match type t. */
2855 static int lvalue_type(int t
)
2860 if (bt
== VT_BYTE
|| bt
== VT_BOOL
)
2862 else if (bt
== VT_SHORT
)
2866 if (t
& VT_UNSIGNED
)
2867 r
|= VT_LVAL_UNSIGNED
;
2871 /* indirection with full error checking and bound check */
2872 static void indir(void)
2874 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
) {
2875 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FUNC
)
2879 if ((vtop
->r
& VT_LVAL
) && !nocode_wanted
)
2881 vtop
->type
= *pointed_type(&vtop
->type
);
2882 /* Arrays and functions are never lvalues */
2883 if (!(vtop
->type
.t
& VT_ARRAY
)
2884 && (vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
2885 vtop
->r
|= lvalue_type(vtop
->type
.t
);
2886 /* if bound checking, the referenced pointer must be checked */
2887 if (tcc_state
->do_bounds_check
)
2888 vtop
->r
|= VT_MUSTBOUND
;
2892 /* pass a parameter to a function and do type checking and casting */
2893 static void gfunc_param_typed(Sym
*func
, Sym
*arg
)
2898 func_type
= func
->c
;
2899 if (func_type
== FUNC_OLD
||
2900 (func_type
== FUNC_ELLIPSIS
&& arg
== NULL
)) {
2901 /* default casting : only need to convert float to double */
2902 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
) {
2906 } else if (arg
== NULL
) {
2907 error("too many arguments to function");
2910 type
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
2911 gen_assign_cast(&type
);
2915 /* parse an expression of the form '(type)' or '(expr)' and return its
2917 static void parse_expr_type(CType
*type
)
2923 if (parse_btype(type
, &ad
)) {
2924 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
2931 static void parse_type(CType
*type
)
2936 if (!parse_btype(type
, &ad
)) {
2939 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
2942 static void vpush_tokc(int t
)
2946 vsetc(&type
, VT_CONST
, &tokc
);
2949 static void unary(void)
2951 int n
, t
, align
, size
, r
;
2956 /* XXX: GCC 2.95.3 does not generate a table although it should be
2970 vpush_tokc(VT_INT
| VT_UNSIGNED
);
2974 vpush_tokc(VT_LLONG
);
2978 vpush_tokc(VT_LLONG
| VT_UNSIGNED
);
2982 vpush_tokc(VT_FLOAT
);
2986 vpush_tokc(VT_DOUBLE
);
2990 vpush_tokc(VT_LDOUBLE
);
2993 case TOK___FUNCTION__
:
2995 goto tok_identifier
;
3001 /* special function name identifier */
3002 len
= strlen(funcname
) + 1;
3003 /* generate char[len] type */
3008 vpush_ref(&type
, data_section
, data_section
->data_offset
, len
);
3009 ptr
= section_ptr_add(data_section
, len
);
3010 memcpy(ptr
, funcname
, len
);
3015 #ifdef TCC_TARGET_PE
3016 t
= VT_SHORT
| VT_UNSIGNED
;
3022 /* string parsing */
3025 if (tcc_state
->warn_write_strings
)
3030 memset(&ad
, 0, sizeof(AttributeDef
));
3031 decl_initializer_alloc(&type
, &ad
, VT_CONST
, 2, 0, 0);
3036 if (parse_btype(&type
, &ad
)) {
3037 type_decl(&type
, &ad
, &n
, TYPE_ABSTRACT
);
3039 /* check ISOC99 compound literal */
3041 /* data is allocated locally by default */
3046 /* all except arrays are lvalues */
3047 if (!(type
.t
& VT_ARRAY
))
3048 r
|= lvalue_type(type
.t
);
3049 memset(&ad
, 0, sizeof(AttributeDef
));
3050 decl_initializer_alloc(&type
, &ad
, r
, 1, 0, 0);
3055 } else if (tok
== '{') {
3056 /* save all registers */
3058 /* statement expression : we do not accept break/continue
3059 inside as GCC does */
3060 block(NULL
, NULL
, NULL
, NULL
, 0, 1);
3075 /* functions names must be treated as function pointers,
3076 except for unary '&' and sizeof. Since we consider that
3077 functions are not lvalues, we only have to handle it
3078 there and in function calls. */
3079 /* arrays can also be used although they are not lvalues */
3080 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
&&
3081 !(vtop
->type
.t
& VT_ARRAY
) && !(vtop
->type
.t
& VT_LLOCAL
))
3083 mk_pointer(&vtop
->type
);
3089 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
3091 boolean
.t
= VT_BOOL
;
3093 vtop
->c
.i
= !vtop
->c
.i
;
3094 } else if ((vtop
->r
& VT_VALMASK
) == VT_CMP
)
3095 vtop
->c
.i
= vtop
->c
.i
^ 1;
3098 vseti(VT_JMP
, gtst(1, 0));
3109 /* in order to force cast, we add zero */
3111 if ((vtop
->type
.t
& VT_BTYPE
) == VT_PTR
)
3112 error("pointer not accepted for unary plus");
3122 parse_expr_type(&type
);
3126 size
= type_size(&type
, &align
);
3127 if (t
== TOK_SIZEOF
) {
3129 error("sizeof applied to an incomplete type");
3134 vtop
->type
.t
|= VT_UNSIGNED
;
3137 case TOK_builtin_types_compatible_p
:
3146 type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
3147 type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
3148 vpushi(is_compatible_types(&type1
, &type2
));
3151 case TOK_builtin_constant_p
:
3153 int saved_nocode_wanted
, res
;
3156 saved_nocode_wanted
= nocode_wanted
;
3159 res
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
3161 nocode_wanted
= saved_nocode_wanted
;
3166 case TOK_builtin_frame_address
:
3171 if (tok
!= TOK_CINT
) {
3172 error("__builtin_frame_address only takes integers");
3175 error("TCC only supports __builtin_frame_address(0)");
3181 vset(&type
, VT_LOCAL
, 0);
3184 #ifdef TCC_TARGET_X86_64
3185 case TOK_builtin_malloc
:
3187 goto tok_identifier
;
3188 case TOK_builtin_free
:
3190 goto tok_identifier
;
3207 goto tok_identifier
;
3209 /* allow to take the address of a label */
3210 if (tok
< TOK_UIDENT
)
3211 expect("label identifier");
3212 s
= label_find(tok
);
3214 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
3216 if (s
->r
== LABEL_DECLARED
)
3217 s
->r
= LABEL_FORWARD
;
3220 s
->type
.t
= VT_VOID
;
3221 mk_pointer(&s
->type
);
3222 s
->type
.t
|= VT_STATIC
;
3224 vset(&s
->type
, VT_CONST
| VT_SYM
, 0);
3233 expect("identifier");
3237 error("'%s' undeclared", get_tok_str(t
, NULL
));
3238 /* for simple function calls, we tolerate undeclared
3239 external reference to int() function */
3240 if (tcc_state
->warn_implicit_function_declaration
)
3241 warning("implicit declaration of function '%s'",
3242 get_tok_str(t
, NULL
));
3243 s
= external_global_sym(t
, &func_old_type
, 0);
3245 if ((s
->type
.t
& (VT_STATIC
| VT_INLINE
| VT_BTYPE
)) ==
3246 (VT_STATIC
| VT_INLINE
| VT_FUNC
)) {
3247 /* if referencing an inline function, then we generate a
3248 symbol to it if not already done. It will have the
3249 effect to generate code for it at the end of the
3250 compilation unit. Inline function as always
3251 generated in the text section. */
3253 put_extern_sym(s
, text_section
, 0, 0);
3254 r
= VT_SYM
| VT_CONST
;
3258 vset(&s
->type
, r
, s
->c
);
3259 /* if forward reference, we must point to s */
3260 if (vtop
->r
& VT_SYM
) {
3267 /* post operations */
3269 if (tok
== TOK_INC
|| tok
== TOK_DEC
) {
3272 } else if (tok
== '.' || tok
== TOK_ARROW
) {
3275 if (tok
== TOK_ARROW
)
3277 qualifiers
= vtop
->type
.t
& (VT_CONSTANT
| VT_VOLATILE
);
3281 /* expect pointer on structure */
3282 if ((vtop
->type
.t
& VT_BTYPE
) != VT_STRUCT
)
3283 expect("struct or union");
3287 while ((s
= s
->next
) != NULL
) {
3292 error("field not found: %s", get_tok_str(tok
& ~SYM_FIELD
, NULL
));
3293 /* add field offset to pointer */
3294 vtop
->type
= char_pointer_type
; /* change type to 'char *' */
3297 /* change type to field type, and set to lvalue */
3298 vtop
->type
= s
->type
;
3299 vtop
->type
.t
|= qualifiers
;
3300 /* an array is never an lvalue */
3301 if (!(vtop
->type
.t
& VT_ARRAY
)) {
3302 vtop
->r
|= lvalue_type(vtop
->type
.t
);
3303 /* if bound checking, the referenced pointer must be checked */
3304 if (tcc_state
->do_bounds_check
)
3305 vtop
->r
|= VT_MUSTBOUND
;
3308 } else if (tok
== '[') {
3314 } else if (tok
== '(') {
3320 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
3321 /* pointer test (no array accepted) */
3322 if ((vtop
->type
.t
& (VT_BTYPE
| VT_ARRAY
)) == VT_PTR
) {
3323 vtop
->type
= *pointed_type(&vtop
->type
);
3324 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
)
3328 expect("function pointer");
3331 vtop
->r
&= ~VT_LVAL
; /* no lvalue */
3333 /* get return type */
3336 sa
= s
->next
; /* first parameter */
3339 /* compute first implicit argument if a structure is returned */
3340 if ((s
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
3341 /* get some space for the returned structure */
3342 size
= type_size(&s
->type
, &align
);
3343 loc
= (loc
- size
) & -align
;
3345 ret
.r
= VT_LOCAL
| VT_LVAL
;
3346 /* pass it as 'int' to avoid structure arg passing
3348 vseti(VT_LOCAL
, loc
);
3353 /* return in register */
3354 if (is_float(ret
.type
.t
)) {
3355 ret
.r
= reg_fret(ret
.type
.t
);
3357 if ((ret
.type
.t
& VT_BTYPE
) == VT_LLONG
)
3366 gfunc_param_typed(s
, sa
);
3376 error("too few arguments to function");
3378 if (!nocode_wanted
) {
3379 gfunc_call(nb_args
);
3381 vtop
-= (nb_args
+ 1);
3384 vsetc(&ret
.type
, ret
.r
, &ret
.c
);
3392 static void uneq(void)
3398 (tok
>= TOK_A_MOD
&& tok
<= TOK_A_DIV
) ||
3399 tok
== TOK_A_XOR
|| tok
== TOK_A_OR
||
3400 tok
== TOK_A_SHL
|| tok
== TOK_A_SAR
) {
3415 static void expr_prod(void)
3420 while (tok
== '*' || tok
== '/' || tok
== '%') {
3428 static void expr_sum(void)
3433 while (tok
== '+' || tok
== '-') {
3441 static void expr_shift(void)
3446 while (tok
== TOK_SHL
|| tok
== TOK_SAR
) {
3454 static void expr_cmp(void)
3459 while ((tok
>= TOK_ULE
&& tok
<= TOK_GT
) ||
3460 tok
== TOK_ULT
|| tok
== TOK_UGE
) {
3468 static void expr_cmpeq(void)
3473 while (tok
== TOK_EQ
|| tok
== TOK_NE
) {
3481 static void expr_and(void)
3484 while (tok
== '&') {
3491 static void expr_xor(void)
3494 while (tok
== '^') {
3501 static void expr_or(void)
3504 while (tok
== '|') {
3511 /* XXX: fix this mess */
3512 static void expr_land_const(void)
3515 while (tok
== TOK_LAND
) {
3522 /* XXX: fix this mess */
3523 static void expr_lor_const(void)
3526 while (tok
== TOK_LOR
) {
3533 /* only used if non constant */
3534 static void expr_land(void)
3539 if (tok
== TOK_LAND
) {
3544 if (tok
!= TOK_LAND
) {
3554 static void expr_lor(void)
3559 if (tok
== TOK_LOR
) {
3564 if (tok
!= TOK_LOR
) {
3574 /* XXX: better constant handling */
3575 static void expr_eq(void)
3577 int tt
, u
, r1
, r2
, rc
, t1
, t2
, bt1
, bt2
;
3579 CType type
, type1
, type2
;
3586 boolean
.t
= VT_BOOL
;
3592 if (tok
!= ':' || !gnu_ext
) {
3607 if (vtop
!= vstack
) {
3608 /* needed to avoid having different registers saved in
3610 if (is_float(vtop
->type
.t
)) {
3612 #ifdef TCC_TARGET_X86_64
3613 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LDOUBLE
) {
3623 if (tok
== ':' && gnu_ext
) {
3631 sv
= *vtop
; /* save value to handle it later */
3632 vtop
--; /* no vpop so that FP stack is not flushed */
3640 bt1
= t1
& VT_BTYPE
;
3642 bt2
= t2
& VT_BTYPE
;
3643 /* cast operands to correct type according to ISOC rules */
3644 if (is_float(bt1
) || is_float(bt2
)) {
3645 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
3646 type
.t
= VT_LDOUBLE
;
3647 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
3652 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
3653 /* cast to biggest op */
3655 /* convert to unsigned if it does not fit in a long long */
3656 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
3657 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
3658 type
.t
|= VT_UNSIGNED
;
3659 } else if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
3660 /* XXX: test pointer compatibility */
3662 } else if (bt1
== VT_FUNC
|| bt2
== VT_FUNC
) {
3663 /* XXX: test function pointer compatibility */
3665 } else if (bt1
== VT_STRUCT
|| bt2
== VT_STRUCT
) {
3666 /* XXX: test structure compatibility */
3668 } else if (bt1
== VT_VOID
|| bt2
== VT_VOID
) {
3669 /* NOTE: as an extension, we accept void on only one side */
3672 /* integer operations */
3674 /* convert to unsigned if it does not fit in an integer */
3675 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
3676 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
3677 type
.t
|= VT_UNSIGNED
;
3680 /* now we convert second operand */
3682 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
3685 if (is_float(type
.t
)) {
3687 #ifdef TCC_TARGET_X86_64
3688 if ((type
.t
& VT_BTYPE
) == VT_LDOUBLE
) {
3692 } else if ((type
.t
& VT_BTYPE
) == VT_LLONG
) {
3693 /* for long longs, we use fixed registers to avoid having
3694 to handle a complicated move */
3699 /* this is horrible, but we must also convert first
3703 /* put again first value and cast it */
3706 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
3716 static void gexpr(void)
3727 /* parse an expression and return its type without any side effect. */
3728 static void expr_type(CType
*type
)
3730 int saved_nocode_wanted
;
3732 saved_nocode_wanted
= nocode_wanted
;
3737 nocode_wanted
= saved_nocode_wanted
;
3740 /* parse a unary expression and return its type without any side
3742 static void unary_type(CType
*type
)
3754 /* parse a constant expression and return value in vtop. */
3755 static void expr_const1(void)
3764 /* parse an integer constant and return its value. */
3765 static int expr_const(void)
3769 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
3770 expect("constant expression");
3776 /* return the label token if current token is a label, otherwise
3778 static int is_label(void)
3782 /* fast test first */
3783 if (tok
< TOK_UIDENT
)
3785 /* no need to save tokc because tok is an identifier */
3792 unget_tok(last_tok
);
3797 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
,
3798 int case_reg
, int is_expr
)
3803 /* generate line number info */
3804 if (tcc_state
->do_debug
&&
3805 (last_line_num
!= file
->line_num
|| last_ind
!= ind
)) {
3806 put_stabn(N_SLINE
, 0, file
->line_num
, ind
- func_ind
);
3808 last_line_num
= file
->line_num
;
3812 /* default return value is (void) */
3814 vtop
->type
.t
= VT_VOID
;
3817 if (tok
== TOK_IF
) {
3824 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
3826 if (c
== TOK_ELSE
) {
3830 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
3831 gsym(d
); /* patch else jmp */
3834 } else if (tok
== TOK_WHILE
) {
3842 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
3846 } else if (tok
== '{') {
3850 /* record local declaration stack position */
3852 llabel
= local_label_stack
;
3853 /* handle local labels declarations */
3854 if (tok
== TOK_LABEL
) {
3857 if (tok
< TOK_UIDENT
)
3858 expect("label identifier");
3859 label_push(&local_label_stack
, tok
, LABEL_DECLARED
);
3869 while (tok
!= '}') {
3874 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
3877 /* pop locally defined labels */
3878 label_pop(&local_label_stack
, llabel
);
3879 /* pop locally defined symbols */
3881 /* XXX: this solution makes only valgrind happy...
3882 triggered by gcc.c-torture/execute/20000917-1.c */
3884 switch(vtop
->type
.t
& VT_BTYPE
) {
3889 for(p
=vtop
->type
.ref
;p
;p
=p
->prev
)
3891 error("unsupported expression type");
3894 sym_pop(&local_stack
, s
);
3896 } else if (tok
== TOK_RETURN
) {
3900 gen_assign_cast(&func_vt
);
3901 if ((func_vt
.t
& VT_BTYPE
) == VT_STRUCT
) {
3903 /* if returning structure, must copy it to implicit
3904 first pointer arg location */
3907 size
= type_size(&func_vt
,&align
);
3910 if((vtop
->r
!= (VT_LOCAL
| VT_LVAL
) || (vtop
->c
.i
& 3))
3914 loc
= (loc
- size
) & -4;
3917 vset(&type
, VT_LOCAL
| VT_LVAL
, addr
);
3920 vset(&int_type
, VT_LOCAL
| VT_LVAL
, addr
);
3922 vtop
->type
= int_type
;
3928 vset(&type
, VT_LOCAL
| VT_LVAL
, func_vc
);
3931 /* copy structure value to pointer */
3936 } else if (is_float(func_vt
.t
)) {
3937 gv(rc_fret(func_vt
.t
));
3941 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
3944 rsym
= gjmp(rsym
); /* jmp */
3945 } else if (tok
== TOK_BREAK
) {
3948 error("cannot break");
3949 *bsym
= gjmp(*bsym
);
3952 } else if (tok
== TOK_CONTINUE
) {
3955 error("cannot continue");
3956 *csym
= gjmp(*csym
);
3959 } else if (tok
== TOK_FOR
) {
3986 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
3991 if (tok
== TOK_DO
) {
3996 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
4007 if (tok
== TOK_SWITCH
) {
4011 /* XXX: other types than integer */
4012 case_reg
= gv(RC_INT
);
4016 b
= gjmp(0); /* jump to first case */
4018 block(&a
, csym
, &b
, &c
, case_reg
, 0);
4019 /* if no default, jmp after switch */
4027 if (tok
== TOK_CASE
) {
4034 if (gnu_ext
&& tok
== TOK_DOTS
) {
4038 warning("empty case range");
4040 /* since a case is like a label, we must skip it with a jmp */
4047 *case_sym
= gtst(1, 0);
4050 *case_sym
= gtst(1, 0);
4054 *case_sym
= gtst(1, *case_sym
);
4059 goto block_after_label
;
4061 if (tok
== TOK_DEFAULT
) {
4067 error("too many 'default'");
4070 goto block_after_label
;
4072 if (tok
== TOK_GOTO
) {
4074 if (tok
== '*' && gnu_ext
) {
4078 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
)
4081 } else if (tok
>= TOK_UIDENT
) {
4082 s
= label_find(tok
);
4083 /* put forward definition if needed */
4085 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
4087 if (s
->r
== LABEL_DECLARED
)
4088 s
->r
= LABEL_FORWARD
;
4090 /* label already defined */
4091 if (s
->r
& LABEL_FORWARD
)
4092 s
->next
= (void *)gjmp((long)s
->next
);
4094 gjmp_addr((long)s
->next
);
4097 expect("label identifier");
4100 } else if (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
) {
4108 if (s
->r
== LABEL_DEFINED
)
4109 error("duplicate label '%s'", get_tok_str(s
->v
, NULL
));
4110 gsym((long)s
->next
);
4111 s
->r
= LABEL_DEFINED
;
4113 s
= label_push(&global_label_stack
, b
, LABEL_DEFINED
);
4115 s
->next
= (void *)ind
;
4116 /* we accept this, but it is a mistake */
4119 warning("deprecated use of label at end of compound statement");
4123 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
4126 /* expression case */
4141 /* t is the array or struct type. c is the array or struct
4142 address. cur_index/cur_field is the pointer to the current
4143 value. 'size_only' is true if only size info is needed (only used
4145 static void decl_designator(CType
*type
, Section
*sec
, unsigned long c
,
4146 int *cur_index
, Sym
**cur_field
,
4150 int notfirst
, index
, index_last
, align
, l
, nb_elems
, elem_size
;
4156 if (gnu_ext
&& (l
= is_label()) != 0)
4158 while (tok
== '[' || tok
== '.') {
4160 if (!(type
->t
& VT_ARRAY
))
4161 expect("array type");
4164 index
= expr_const();
4165 if (index
< 0 || (s
->c
>= 0 && index
>= s
->c
))
4166 expect("invalid index");
4167 if (tok
== TOK_DOTS
&& gnu_ext
) {
4169 index_last
= expr_const();
4170 if (index_last
< 0 ||
4171 (s
->c
>= 0 && index_last
>= s
->c
) ||
4173 expect("invalid index");
4179 *cur_index
= index_last
;
4180 type
= pointed_type(type
);
4181 elem_size
= type_size(type
, &align
);
4182 c
+= index
* elem_size
;
4183 /* NOTE: we only support ranges for last designator */
4184 nb_elems
= index_last
- index
+ 1;
4185 if (nb_elems
!= 1) {
4194 if ((type
->t
& VT_BTYPE
) != VT_STRUCT
)
4195 expect("struct/union type");
4208 /* XXX: fix this mess by using explicit storage field */
4210 type1
.t
|= (type
->t
& ~VT_TYPE
);
4224 if (type
->t
& VT_ARRAY
) {
4226 type
= pointed_type(type
);
4227 c
+= index
* type_size(type
, &align
);
4231 error("too many field init");
4232 /* XXX: fix this mess by using explicit storage field */
4234 type1
.t
|= (type
->t
& ~VT_TYPE
);
4239 decl_initializer(type
, sec
, c
, 0, size_only
);
4241 /* XXX: make it more general */
4242 if (!size_only
&& nb_elems
> 1) {
4243 unsigned long c_end
;
4248 error("range init not supported yet for dynamic storage");
4249 c_end
= c
+ nb_elems
* elem_size
;
4250 if (c_end
> sec
->data_allocated
)
4251 section_realloc(sec
, c_end
);
4252 src
= sec
->data
+ c
;
4254 for(i
= 1; i
< nb_elems
; i
++) {
4256 memcpy(dst
, src
, elem_size
);
4262 #define EXPR_CONST 1
4265 /* store a value or an expression directly in global data or in local array */
4266 static void init_putv(CType
*type
, Section
*sec
, unsigned long c
,
4267 int v
, int expr_type
)
4269 int saved_global_expr
, bt
, bit_pos
, bit_size
;
4271 unsigned long long bit_mask
;
4279 /* compound literals must be allocated globally in this case */
4280 saved_global_expr
= global_expr
;
4283 global_expr
= saved_global_expr
;
4284 /* NOTE: symbols are accepted */
4285 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) != VT_CONST
)
4286 error("initializer element is not constant");
4294 dtype
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
4297 /* XXX: not portable */
4298 /* XXX: generate error if incorrect relocation */
4299 gen_assign_cast(&dtype
);
4300 bt
= type
->t
& VT_BTYPE
;
4301 /* we'll write at most 12 bytes */
4302 if (c
+ 12 > sec
->data_allocated
) {
4303 section_realloc(sec
, c
+ 12);
4305 ptr
= sec
->data
+ c
;
4306 /* XXX: make code faster ? */
4307 if (!(type
->t
& VT_BITFIELD
)) {
4312 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4313 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
4314 bit_mask
= (1LL << bit_size
) - 1;
4316 if ((vtop
->r
& VT_SYM
) &&
4322 (bt
== VT_INT
&& bit_size
!= 32)))
4323 error("initializer element is not computable at load time");
4326 vtop
->c
.i
= (vtop
->c
.i
!= 0);
4328 *(char *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
4331 *(short *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
4334 *(double *)ptr
= vtop
->c
.d
;
4337 *(long double *)ptr
= vtop
->c
.ld
;
4340 *(long long *)ptr
|= (vtop
->c
.ll
& bit_mask
) << bit_pos
;
4343 if (vtop
->r
& VT_SYM
) {
4344 greloc(sec
, vtop
->sym
, c
, R_DATA_32
);
4346 *(int *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
4351 vset(&dtype
, VT_LOCAL
|VT_LVAL
, c
);
4358 /* put zeros for variable based init */
4359 static void init_putz(CType
*t
, Section
*sec
, unsigned long c
, int size
)
4362 /* nothing to do because globals are already set to zero */
4364 vpush_global_sym(&func_old_type
, TOK_memset
);
4372 /* 't' contains the type and storage info. 'c' is the offset of the
4373 object in section 'sec'. If 'sec' is NULL, it means stack based
4374 allocation. 'first' is true if array '{' must be read (multi
4375 dimension implicit array init handling). 'size_only' is true if
4376 size only evaluation is wanted (only for arrays). */
4377 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
4378 int first
, int size_only
)
4380 int index
, array_length
, n
, no_oblock
, nb
, parlevel
, i
;
4381 int size1
, align1
, expr_type
;
4385 if (type
->t
& VT_ARRAY
) {
4389 t1
= pointed_type(type
);
4390 size1
= type_size(t1
, &align1
);
4393 if ((first
&& tok
!= TOK_LSTR
&& tok
!= TOK_STR
) ||
4399 /* only parse strings here if correct type (otherwise: handle
4400 them as ((w)char *) expressions */
4401 if ((tok
== TOK_LSTR
&&
4402 #ifdef TCC_TARGET_PE
4403 (t1
->t
& VT_BTYPE
) == VT_SHORT
&& (t1
->t
& VT_UNSIGNED
)
4405 (t1
->t
& VT_BTYPE
) == VT_INT
4407 ) || (tok
== TOK_STR
&& (t1
->t
& VT_BTYPE
) == VT_BYTE
)) {
4408 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
4413 /* compute maximum number of chars wanted */
4415 cstr_len
= cstr
->size
;
4417 cstr_len
= cstr
->size
/ sizeof(nwchar_t
);
4420 if (n
>= 0 && nb
> (n
- array_length
))
4421 nb
= n
- array_length
;
4424 warning("initializer-string for array is too long");
4425 /* in order to go faster for common case (char
4426 string in global variable, we handle it
4428 if (sec
&& tok
== TOK_STR
&& size1
== 1) {
4429 memcpy(sec
->data
+ c
+ array_length
, cstr
->data
, nb
);
4433 ch
= ((unsigned char *)cstr
->data
)[i
];
4435 ch
= ((nwchar_t
*)cstr
->data
)[i
];
4436 init_putv(t1
, sec
, c
+ (array_length
+ i
) * size1
,
4444 /* only add trailing zero if enough storage (no
4445 warning in this case since it is standard) */
4446 if (n
< 0 || array_length
< n
) {
4448 init_putv(t1
, sec
, c
+ (array_length
* size1
), 0, EXPR_VAL
);
4454 while (tok
!= '}') {
4455 decl_designator(type
, sec
, c
, &index
, NULL
, size_only
);
4456 if (n
>= 0 && index
>= n
)
4457 error("index too large");
4458 /* must put zero in holes (note that doing it that way
4459 ensures that it even works with designators) */
4460 if (!size_only
&& array_length
< index
) {
4461 init_putz(t1
, sec
, c
+ array_length
* size1
,
4462 (index
- array_length
) * size1
);
4465 if (index
> array_length
)
4466 array_length
= index
;
4467 /* special test for multi dimensional arrays (may not
4468 be strictly correct if designators are used at the
4470 if (index
>= n
&& no_oblock
)
4479 /* put zeros at the end */
4480 if (!size_only
&& n
>= 0 && array_length
< n
) {
4481 init_putz(t1
, sec
, c
+ array_length
* size1
,
4482 (n
- array_length
) * size1
);
4484 /* patch type size if needed */
4486 s
->c
= array_length
;
4487 } else if ((type
->t
& VT_BTYPE
) == VT_STRUCT
&&
4488 (sec
|| !first
|| tok
== '{')) {
4491 /* NOTE: the previous test is a specific case for automatic
4492 struct/union init */
4493 /* XXX: union needs only one init */
4495 /* XXX: this test is incorrect for local initializers
4496 beginning with ( without {. It would be much more difficult
4497 to do it correctly (ideally, the expression parser should
4498 be used in all cases) */
4504 while (tok
== '(') {
4508 if (!parse_btype(&type1
, &ad1
))
4510 type_decl(&type1
, &ad1
, &n
, TYPE_ABSTRACT
);
4512 if (!is_assignable_types(type
, &type1
))
4513 error("invalid type for cast");
4518 if (first
|| tok
== '{') {
4527 while (tok
!= '}') {
4528 decl_designator(type
, sec
, c
, NULL
, &f
, size_only
);
4530 if (!size_only
&& array_length
< index
) {
4531 init_putz(type
, sec
, c
+ array_length
,
4532 index
- array_length
);
4534 index
= index
+ type_size(&f
->type
, &align1
);
4535 if (index
> array_length
)
4536 array_length
= index
;
4538 /* gr: skip fields from same union - ugly. */
4540 ///printf("index: %2d %08x -- %2d %08x\n", f->c, f->type.t, f->next->c, f->next->type.t);
4541 /* test for same offset */
4542 if (f
->next
->c
!= f
->c
)
4544 /* if yes, test for bitfield shift */
4545 if ((f
->type
.t
& VT_BITFIELD
) && (f
->next
->type
.t
& VT_BITFIELD
)) {
4546 int bit_pos_1
= (f
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4547 int bit_pos_2
= (f
->next
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4548 //printf("bitfield %d %d\n", bit_pos_1, bit_pos_2);
4549 if (bit_pos_1
!= bit_pos_2
)
4556 if (no_oblock
&& f
== NULL
)
4562 /* put zeros at the end */
4563 if (!size_only
&& array_length
< n
) {
4564 init_putz(type
, sec
, c
+ array_length
,
4573 } else if (tok
== '{') {
4575 decl_initializer(type
, sec
, c
, first
, size_only
);
4577 } else if (size_only
) {
4578 /* just skip expression */
4580 while ((parlevel
> 0 || (tok
!= '}' && tok
!= ',')) &&
4584 else if (tok
== ')')
4589 /* currently, we always use constant expression for globals
4590 (may change for scripting case) */
4591 expr_type
= EXPR_CONST
;
4593 expr_type
= EXPR_ANY
;
4594 init_putv(type
, sec
, c
, 0, expr_type
);
4598 /* parse an initializer for type 't' if 'has_init' is non zero, and
4599 allocate space in local or global data space ('r' is either
4600 VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
4601 variable 'v' of scope 'scope' is declared before initializers are
4602 parsed. If 'v' is zero, then a reference to the new object is put
4603 in the value stack. If 'has_init' is 2, a special parsing is done
4604 to handle string constants. */
4605 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
4606 int has_init
, int v
, int scope
)
4608 int size
, align
, addr
, data_offset
;
4610 ParseState saved_parse_state
= {0};
4611 TokenString init_str
;
4614 size
= type_size(type
, &align
);
4615 /* If unknown size, we must evaluate it before
4616 evaluating initializers because
4617 initializers can generate global data too
4618 (e.g. string pointers or ISOC99 compound
4619 literals). It also simplifies local
4620 initializers handling */
4621 tok_str_new(&init_str
);
4624 error("unknown type size");
4625 /* get all init string */
4626 if (has_init
== 2) {
4627 /* only get strings */
4628 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
4629 tok_str_add_tok(&init_str
);
4634 while (level
> 0 || (tok
!= ',' && tok
!= ';')) {
4636 error("unexpected end of file in initializer");
4637 tok_str_add_tok(&init_str
);
4640 else if (tok
== '}') {
4650 tok_str_add(&init_str
, -1);
4651 tok_str_add(&init_str
, 0);
4654 save_parse_state(&saved_parse_state
);
4656 macro_ptr
= init_str
.str
;
4658 decl_initializer(type
, NULL
, 0, 1, 1);
4659 /* prepare second initializer parsing */
4660 macro_ptr
= init_str
.str
;
4663 /* if still unknown size, error */
4664 size
= type_size(type
, &align
);
4666 error("unknown type size");
4668 /* take into account specified alignment if bigger */
4670 if (ad
->aligned
> align
)
4671 align
= ad
->aligned
;
4672 } else if (ad
->packed
) {
4675 if ((r
& VT_VALMASK
) == VT_LOCAL
) {
4677 if (tcc_state
->do_bounds_check
&& (type
->t
& VT_ARRAY
))
4679 loc
= (loc
- size
) & -align
;
4681 /* handles bounds */
4682 /* XXX: currently, since we do only one pass, we cannot track
4683 '&' operators, so we add only arrays */
4684 if (tcc_state
->do_bounds_check
&& (type
->t
& VT_ARRAY
)) {
4685 unsigned long *bounds_ptr
;
4686 /* add padding between regions */
4688 /* then add local bound info */
4689 bounds_ptr
= section_ptr_add(lbounds_section
, 2 * sizeof(unsigned long));
4690 bounds_ptr
[0] = addr
;
4691 bounds_ptr
[1] = size
;
4694 /* local variable */
4695 sym_push(v
, type
, r
, addr
);
4697 /* push local reference */
4698 vset(type
, r
, addr
);
4704 if (v
&& scope
== VT_CONST
) {
4705 /* see if the symbol was already defined */
4708 if (!is_compatible_types(&sym
->type
, type
))
4709 error("incompatible types for redefinition of '%s'",
4710 get_tok_str(v
, NULL
));
4711 if (sym
->type
.t
& VT_EXTERN
) {
4712 /* if the variable is extern, it was not allocated */
4713 sym
->type
.t
&= ~VT_EXTERN
;
4714 /* set array size if it was ommited in extern
4716 if ((sym
->type
.t
& VT_ARRAY
) &&
4717 sym
->type
.ref
->c
< 0 &&
4719 sym
->type
.ref
->c
= type
->ref
->c
;
4721 /* we accept several definitions of the same
4722 global variable. this is tricky, because we
4723 must play with the SHN_COMMON type of the symbol */
4724 /* XXX: should check if the variable was already
4725 initialized. It is incorrect to initialized it
4727 /* no init data, we won't add more to the symbol */
4734 /* allocate symbol in corresponding section */
4739 else if (tcc_state
->nocommon
)
4743 data_offset
= sec
->data_offset
;
4744 data_offset
= (data_offset
+ align
- 1) & -align
;
4746 /* very important to increment global pointer at this time
4747 because initializers themselves can create new initializers */
4748 data_offset
+= size
;
4749 /* add padding if bound check */
4750 if (tcc_state
->do_bounds_check
)
4752 sec
->data_offset
= data_offset
;
4753 /* allocate section space to put the data */
4754 if (sec
->sh_type
!= SHT_NOBITS
&&
4755 data_offset
> sec
->data_allocated
)
4756 section_realloc(sec
, data_offset
);
4757 /* align section if needed */
4758 if (align
> sec
->sh_addralign
)
4759 sec
->sh_addralign
= align
;
4761 addr
= 0; /* avoid warning */
4765 if (scope
!= VT_CONST
|| !sym
) {
4766 sym
= sym_push(v
, type
, r
| VT_SYM
, 0);
4768 /* update symbol definition */
4770 put_extern_sym(sym
, sec
, addr
, size
);
4773 /* put a common area */
4774 put_extern_sym(sym
, NULL
, align
, size
);
4775 /* XXX: find a nicer way */
4776 esym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
];
4777 esym
->st_shndx
= SHN_COMMON
;
4782 /* push global reference */
4783 sym
= get_sym_ref(type
, sec
, addr
, size
);
4785 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
4789 /* handles bounds now because the symbol must be defined
4790 before for the relocation */
4791 if (tcc_state
->do_bounds_check
) {
4792 unsigned long *bounds_ptr
;
4794 greloc(bounds_section
, sym
, bounds_section
->data_offset
, R_DATA_32
);
4795 /* then add global bound info */
4796 bounds_ptr
= section_ptr_add(bounds_section
, 2 * sizeof(long));
4797 bounds_ptr
[0] = 0; /* relocated */
4798 bounds_ptr
[1] = size
;
4802 decl_initializer(type
, sec
, addr
, 1, 0);
4803 /* restore parse state if needed */
4805 tok_str_free(init_str
.str
);
4806 restore_parse_state(&saved_parse_state
);
4812 void put_func_debug(Sym
*sym
)
4817 /* XXX: we put here a dummy type */
4818 snprintf(buf
, sizeof(buf
), "%s:%c1",
4819 funcname
, sym
->type
.t
& VT_STATIC
? 'f' : 'F');
4820 put_stabs_r(buf
, N_FUN
, 0, file
->line_num
, 0,
4821 cur_text_section
, sym
->c
);
4822 /* //gr gdb wants a line at the function */
4823 put_stabn(N_SLINE
, 0, file
->line_num
, 0);
4828 /* parse an old style function declaration list */
4829 /* XXX: check multiple parameter */
4830 static void func_decl_list(Sym
*func_sym
)
4837 /* parse each declaration */
4838 while (tok
!= '{' && tok
!= ';' && tok
!= ',' && tok
!= TOK_EOF
) {
4839 if (!parse_btype(&btype
, &ad
))
4840 expect("declaration list");
4841 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
4842 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
4844 /* we accept no variable after */
4848 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
4849 /* find parameter in function parameter list */
4852 if ((s
->v
& ~SYM_FIELD
) == v
)
4856 error("declaration for parameter '%s' but no such parameter",
4857 get_tok_str(v
, NULL
));
4859 /* check that no storage specifier except 'register' was given */
4860 if (type
.t
& VT_STORAGE
)
4861 error("storage class specified for '%s'", get_tok_str(v
, NULL
));
4862 convert_parameter_type(&type
);
4863 /* we can add the type (NOTE: it could be local to the function) */
4865 /* accept other parameters */
4876 /* parse a function defined by symbol 'sym' and generate its code in
4877 'cur_text_section' */
4878 static void gen_function(Sym
*sym
)
4880 int saved_nocode_wanted
= nocode_wanted
;
4882 ind
= cur_text_section
->data_offset
;
4883 /* NOTE: we patch the symbol size later */
4884 put_extern_sym(sym
, cur_text_section
, ind
, 0);
4885 funcname
= get_tok_str(sym
->v
, NULL
);
4887 /* put debug symbol */
4888 if (tcc_state
->do_debug
)
4889 put_func_debug(sym
);
4890 /* push a dummy symbol to enable local sym storage */
4891 sym_push2(&local_stack
, SYM_FIELD
, 0, 0);
4892 gfunc_prolog(&sym
->type
);
4894 block(NULL
, NULL
, NULL
, NULL
, 0, 0);
4897 cur_text_section
->data_offset
= ind
;
4898 label_pop(&global_label_stack
, NULL
);
4899 sym_pop(&local_stack
, NULL
); /* reset local stack */
4900 /* end of function */
4901 /* patch symbol size */
4902 ((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
].st_size
=
4904 if (tcc_state
->do_debug
) {
4905 put_stabn(N_FUN
, 0, 0, ind
- func_ind
);
4907 /* It's better to crash than to generate wrong code */
4908 cur_text_section
= NULL
;
4909 funcname
= ""; /* for safety */
4910 func_vt
.t
= VT_VOID
; /* for safety */
4911 ind
= 0; /* for safety */
4912 nocode_wanted
= saved_nocode_wanted
;
4915 static void gen_inline_functions(void)
4919 int *str
, inline_generated
;
4921 /* iterate while inline function are referenced */
4923 inline_generated
= 0;
4924 for(sym
= global_stack
; sym
!= NULL
; sym
= sym
->prev
) {
4926 if (((type
->t
& VT_BTYPE
) == VT_FUNC
) &&
4927 (type
->t
& (VT_STATIC
| VT_INLINE
)) ==
4928 (VT_STATIC
| VT_INLINE
) &&
4930 /* the function was used: generate its code and
4931 convert it to a normal function */
4932 str
= INLINE_DEF(sym
->r
);
4933 sym
->r
= VT_SYM
| VT_CONST
;
4934 sym
->type
.t
&= ~VT_INLINE
;
4938 cur_text_section
= text_section
;
4940 macro_ptr
= NULL
; /* fail safe */
4943 inline_generated
= 1;
4946 if (!inline_generated
)
4950 /* free all remaining inline function tokens */
4951 for(sym
= global_stack
; sym
!= NULL
; sym
= sym
->prev
) {
4953 if (((type
->t
& VT_BTYPE
) == VT_FUNC
) &&
4954 (type
->t
& (VT_STATIC
| VT_INLINE
)) ==
4955 (VT_STATIC
| VT_INLINE
)) {
4956 //gr printf("sym %d %s\n", sym->r, get_tok_str(sym->v, NULL));
4957 if (sym
->r
== (VT_SYM
| VT_CONST
)) //gr beware!
4959 str
= INLINE_DEF(sym
->r
);
4961 sym
->r
= 0; /* fail safe */
4966 /* 'l' is VT_LOCAL or VT_CONST to define default storage type */
4967 static void decl(int l
)
4975 if (!parse_btype(&btype
, &ad
)) {
4976 /* skip redundant ';' */
4977 /* XXX: find more elegant solution */
4982 if (l
== VT_CONST
&&
4983 (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
)) {
4984 /* global asm block */
4988 /* special test for old K&R protos without explicit int
4989 type. Only accepted when defining global data */
4990 if (l
== VT_LOCAL
|| tok
< TOK_DEFINE
)
4994 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
4995 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
4997 /* we accept no variable after */
5001 while (1) { /* iterate thru each declaration */
5003 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
5007 type_to_str(buf
, sizeof(buf
), t
, get_tok_str(v
, NULL
));
5008 printf("type = '%s'\n", buf
);
5011 if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
5012 /* if old style function prototype, we accept a
5015 if (sym
->c
== FUNC_OLD
)
5016 func_decl_list(sym
);
5021 error("cannot use local functions");
5022 if ((type
.t
& VT_BTYPE
) != VT_FUNC
)
5023 expect("function definition");
5025 /* reject abstract declarators in function definition */
5027 while ((sym
= sym
->next
) != NULL
)
5028 if (!(sym
->v
& ~SYM_FIELD
))
5029 expect("identifier");
5031 /* XXX: cannot do better now: convert extern line to static inline */
5032 if ((type
.t
& (VT_EXTERN
| VT_INLINE
)) == (VT_EXTERN
| VT_INLINE
))
5033 type
.t
= (type
.t
& ~VT_EXTERN
) | VT_STATIC
;
5037 if ((sym
->type
.t
& VT_BTYPE
) != VT_FUNC
)
5040 r
= sym
->type
.ref
->r
;
5041 /* use func_call from prototype if not defined */
5042 if (FUNC_CALL(r
) != FUNC_CDECL
5043 && FUNC_CALL(type
.ref
->r
) == FUNC_CDECL
)
5044 FUNC_CALL(type
.ref
->r
) = FUNC_CALL(r
);
5046 /* use export from prototype */
5048 FUNC_EXPORT(type
.ref
->r
) = 1;
5050 /* use static from prototype */
5051 if (sym
->type
.t
& VT_STATIC
)
5052 type
.t
= (type
.t
& ~VT_EXTERN
) | VT_STATIC
;
5054 if (!is_compatible_types(&sym
->type
, &type
)) {
5056 error("incompatible types for redefinition of '%s'",
5057 get_tok_str(v
, NULL
));
5059 /* if symbol is already defined, then put complete type */
5062 /* put function symbol */
5063 sym
= global_identifier_push(v
, type
.t
, 0);
5064 sym
->type
.ref
= type
.ref
;
5067 /* static inline functions are just recorded as a kind
5068 of macro. Their code will be emitted at the end of
5069 the compilation unit only if they are used */
5070 if ((type
.t
& (VT_INLINE
| VT_STATIC
)) ==
5071 (VT_INLINE
| VT_STATIC
)) {
5072 TokenString func_str
;
5075 tok_str_new(&func_str
);
5081 error("unexpected end of file");
5082 tok_str_add_tok(&func_str
);
5087 } else if (t
== '}') {
5089 if (block_level
== 0)
5093 tok_str_add(&func_str
, -1);
5094 tok_str_add(&func_str
, 0);
5095 INLINE_DEF(sym
->r
) = func_str
.str
;
5097 /* compute text section */
5098 cur_text_section
= ad
.section
;
5099 if (!cur_text_section
)
5100 cur_text_section
= text_section
;
5101 sym
->r
= VT_SYM
| VT_CONST
;
5106 if (btype
.t
& VT_TYPEDEF
) {
5107 /* save typedefed type */
5108 /* XXX: test storage specifiers ? */
5109 sym
= sym_push(v
, &type
, 0, 0);
5110 sym
->type
.t
|= VT_TYPEDEF
;
5111 } else if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
5112 /* external function definition */
5113 /* specific case for func_call attribute */
5115 type
.ref
->r
= ad
.func_attr
;
5116 external_sym(v
, &type
, 0);
5118 /* not lvalue if array */
5120 if (!(type
.t
& VT_ARRAY
))
5121 r
|= lvalue_type(type
.t
);
5122 has_init
= (tok
== '=');
5123 if ((btype
.t
& VT_EXTERN
) ||
5124 ((type
.t
& VT_ARRAY
) && (type
.t
& VT_STATIC
) &&
5125 !has_init
&& l
== VT_CONST
&& type
.ref
->c
< 0)) {
5126 /* external variable */
5127 /* NOTE: as GCC, uninitialized global static
5128 arrays of null size are considered as
5130 external_sym(v
, &type
, r
);
5132 type
.t
|= (btype
.t
& VT_STATIC
); /* Retain "static". */
5133 if (type
.t
& VT_STATIC
)
5139 decl_initializer_alloc(&type
, &ad
, r
,