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
24 /********************************************************/
25 /* global variables */
27 /* loc : local variable index
28 ind : output code index
30 anon_sym: anonymous symbol index
32 ST_DATA
int rsym
, anon_sym
, ind
, loc
;
34 ST_DATA Sym
*global_stack
;
35 ST_DATA Sym
*local_stack
;
36 ST_DATA Sym
*define_stack
;
37 ST_DATA Sym
*global_label_stack
;
38 ST_DATA Sym
*local_label_stack
;
40 static Sym
*sym_free_first
;
41 static void **sym_pools
;
42 static int nb_sym_pools
;
44 static Sym
*all_cleanups
, *pending_gotos
;
45 static int local_scope
;
47 static int in_generic
;
48 static int section_sym
;
49 ST_DATA
char debug_modes
;
52 static SValue _vstack
[1 + VSTACK_SIZE
];
53 #define vstack (_vstack + 1)
55 ST_DATA
int const_wanted
; /* true if constant wanted */
56 ST_DATA
int nocode_wanted
; /* no code generation wanted */
57 #define unevalmask 0xffff /* unevaluated subexpression */
58 #define NODATA_WANTED (nocode_wanted > 0) /* no static data output wanted either */
59 #define STATIC_DATA_WANTED (nocode_wanted & 0xC0000000) /* only static data output */
61 /* Automagical code suppression ----> */
62 #define CODE_OFF() (nocode_wanted |= 0x20000000)
63 #define CODE_ON() (nocode_wanted &= ~0x20000000)
65 static void tcc_tcov_block_begin(void);
67 /* Clear 'nocode_wanted' at label if it was used */
68 ST_FUNC
void gsym(int t
) { if (t
) { gsym_addr(t
, ind
); CODE_ON(); }}
69 static int gind(void) { int t
= ind
; CODE_ON(); if (debug_modes
) tcc_tcov_block_begin(); return t
; }
71 /* Set 'nocode_wanted' after unconditional jumps */
72 static void gjmp_addr_acs(int t
) { gjmp_addr(t
); CODE_OFF(); }
73 static int gjmp_acs(int t
) { t
= gjmp(t
); CODE_OFF(); return t
; }
75 /* These are #undef'd at the end of this file */
76 #define gjmp_addr gjmp_addr_acs
80 ST_DATA
int global_expr
; /* true if compound literals must be allocated globally (used during initializers parsing */
81 ST_DATA CType func_vt
; /* current function return type (used by return instruction) */
82 ST_DATA
int func_var
; /* true if current function is variadic (used by return instruction) */
84 static int last_line_num
, new_file
, func_ind
; /* debug info control */
85 ST_DATA
const char *funcname
;
86 ST_DATA CType int_type
, func_old_type
, char_type
, char_pointer_type
;
87 static CString initstr
;
90 #define VT_SIZE_T (VT_INT | VT_UNSIGNED)
91 #define VT_PTRDIFF_T VT_INT
93 #define VT_SIZE_T (VT_LLONG | VT_UNSIGNED)
94 #define VT_PTRDIFF_T VT_LLONG
96 #define VT_SIZE_T (VT_LONG | VT_LLONG | VT_UNSIGNED)
97 #define VT_PTRDIFF_T (VT_LONG | VT_LLONG)
100 ST_DATA
struct switch_t
{
104 } **p
; int n
; /* list of case ranges */
105 int def_sym
; /* default symbol */
108 struct switch_t
*prev
;
110 } *cur_switch
; /* current switch */
112 #define MAX_TEMP_LOCAL_VARIABLE_NUMBER 8
113 /*list of temporary local variables on the stack in current function. */
114 ST_DATA
struct temp_local_variable
{
115 int location
; //offset on stack. Svalue.c.i
118 } arr_temp_local_vars
[MAX_TEMP_LOCAL_VARIABLE_NUMBER
];
119 short nb_temp_local_vars
;
121 static struct scope
{
123 struct { int loc
, locorig
, num
; } vla
;
124 struct { Sym
*s
; int n
; } cl
;
127 } *cur_scope
, *loop_scope
, *root_scope
;
135 /********************************************************/
136 /* stab debug support */
138 static const struct {
141 } default_debug
[] = {
142 { VT_INT
, "int:t1=r1;-2147483648;2147483647;" },
143 { VT_BYTE
, "char:t2=r2;0;127;" },
145 { VT_LONG
| VT_INT
, "long int:t3=r3;-2147483648;2147483647;" },
147 { VT_LLONG
| VT_LONG
, "long int:t3=r3;-9223372036854775808;9223372036854775807;" },
149 { VT_INT
| VT_UNSIGNED
, "unsigned int:t4=r4;0;037777777777;" },
151 { VT_LONG
| VT_INT
| VT_UNSIGNED
, "long unsigned int:t5=r5;0;037777777777;" },
153 /* use octal instead of -1 so size_t works (-gstabs+ in gcc) */
154 { VT_LLONG
| VT_LONG
| VT_UNSIGNED
, "long unsigned int:t5=r5;0;01777777777777777777777;" },
156 { VT_QLONG
, "__int128:t6=r6;0;-1;" },
157 { VT_QLONG
| VT_UNSIGNED
, "__int128 unsigned:t7=r7;0;-1;" },
158 { VT_LLONG
, "long long int:t8=r8;-9223372036854775808;9223372036854775807;" },
159 { VT_LLONG
| VT_UNSIGNED
, "long long unsigned int:t9=r9;0;01777777777777777777777;" },
160 { VT_SHORT
, "short int:t10=r10;-32768;32767;" },
161 { VT_SHORT
| VT_UNSIGNED
, "short unsigned int:t11=r11;0;65535;" },
162 { VT_BYTE
| VT_DEFSIGN
, "signed char:t12=r12;-128;127;" },
163 { VT_BYTE
| VT_DEFSIGN
| VT_UNSIGNED
, "unsigned char:t13=r13;0;255;" },
164 { VT_FLOAT
, "float:t14=r1;4;0;" },
165 { VT_DOUBLE
, "double:t15=r1;8;0;" },
166 #ifdef TCC_USING_DOUBLE_FOR_LDOUBLE
167 { VT_DOUBLE
| VT_LONG
, "long double:t16=r1;8;0;" },
169 { VT_LDOUBLE
, "long double:t16=r1;16;0;" },
171 { -1, "_Float32:t17=r1;4;0;" },
172 { -1, "_Float64:t18=r1;8;0;" },
173 { -1, "_Float128:t19=r1;16;0;" },
174 { -1, "_Float32x:t20=r1;8;0;" },
175 { -1, "_Float64x:t21=r1;16;0;" },
176 { -1, "_Decimal32:t22=r1;4;0;" },
177 { -1, "_Decimal64:t23=r1;8;0;" },
178 { -1, "_Decimal128:t24=r1;16;0;" },
179 /* if default char is unsigned */
180 { VT_BYTE
| VT_UNSIGNED
, "unsigned char:t25=r25;0;255;" },
182 { VT_BOOL
, "bool:t26=r26;0;255;" },
183 { VT_VOID
, "void:t27=27" },
186 static int debug_next_type
;
188 static struct debug_hash
{
193 static int n_debug_hash
;
195 static struct debug_info
{
206 struct debug_info
*child
, *next
, *last
, *parent
;
207 } *debug_info
, *debug_info_root
;
210 unsigned long offset
;
211 unsigned long last_file_name
;
212 unsigned long last_func_name
;
217 /********************************************************/
219 #define precedence_parser
220 static void init_prec(void);
222 /********************************************************/
223 #ifndef CONFIG_TCC_ASM
224 ST_FUNC
void asm_instr(void)
226 tcc_error("inline asm() not supported");
228 ST_FUNC
void asm_global_instr(void)
230 tcc_error("inline asm() not supported");
234 /* ------------------------------------------------------------------------- */
235 static void gen_cast(CType
*type
);
236 static void gen_cast_s(int t
);
237 static inline CType
*pointed_type(CType
*type
);
238 static int is_compatible_types(CType
*type1
, CType
*type2
);
239 static int parse_btype(CType
*type
, AttributeDef
*ad
);
240 static CType
*type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
);
241 static void parse_expr_type(CType
*type
);
242 static void init_putv(init_params
*p
, CType
*type
, unsigned long c
);
243 static void decl_initializer(init_params
*p
, CType
*type
, unsigned long c
, int flags
);
244 static void block(int is_expr
);
245 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
, int has_init
, int v
, int scope
);
246 static void decl(int l
);
247 static int decl0(int l
, int is_for_loop_init
, Sym
*);
248 static void expr_eq(void);
249 static void vla_runtime_type_size(CType
*type
, int *a
);
250 static int is_compatible_unqualified_types(CType
*type1
, CType
*type2
);
251 static inline int64_t expr_const64(void);
252 static void vpush64(int ty
, unsigned long long v
);
253 static void vpush(CType
*type
);
254 static int gvtst(int inv
, int t
);
255 static void gen_inline_functions(TCCState
*s
);
256 static void free_inline_functions(TCCState
*s
);
257 static void skip_or_save_block(TokenString
**str
);
258 static void gv_dup(void);
259 static int get_temp_local_var(int size
,int align
);
260 static void clear_temp_local_var_list();
261 static void cast_error(CType
*st
, CType
*dt
);
263 ST_INLN
int is_float(int t
)
265 int bt
= t
& VT_BTYPE
;
266 return bt
== VT_LDOUBLE
272 static inline int is_integer_btype(int bt
)
281 static int btype_size(int bt
)
283 return bt
== VT_BYTE
|| bt
== VT_BOOL
? 1 :
287 bt
== VT_PTR
? PTR_SIZE
: 0;
290 /* returns function return register from type */
291 static int R_RET(int t
)
295 #ifdef TCC_TARGET_X86_64
296 if ((t
& VT_BTYPE
) == VT_LDOUBLE
)
298 #elif defined TCC_TARGET_RISCV64
299 if ((t
& VT_BTYPE
) == VT_LDOUBLE
)
305 /* returns 2nd function return register, if any */
306 static int R2_RET(int t
)
312 #elif defined TCC_TARGET_X86_64
317 #elif defined TCC_TARGET_RISCV64
324 /* returns true for two-word types */
325 #define USING_TWO_WORDS(t) (R2_RET(t) != VT_CONST)
327 /* put function return registers to stack value */
328 static void PUT_R_RET(SValue
*sv
, int t
)
330 sv
->r
= R_RET(t
), sv
->r2
= R2_RET(t
);
333 /* returns function return register class for type t */
334 static int RC_RET(int t
)
336 return reg_classes
[R_RET(t
)] & ~(RC_FLOAT
| RC_INT
);
339 /* returns generic register class for type t */
340 static int RC_TYPE(int t
)
344 #ifdef TCC_TARGET_X86_64
345 if ((t
& VT_BTYPE
) == VT_LDOUBLE
)
347 if ((t
& VT_BTYPE
) == VT_QFLOAT
)
349 #elif defined TCC_TARGET_RISCV64
350 if ((t
& VT_BTYPE
) == VT_LDOUBLE
)
356 /* returns 2nd register class corresponding to t and rc */
357 static int RC2_TYPE(int t
, int rc
)
359 if (!USING_TWO_WORDS(t
))
374 /* we use our own 'finite' function to avoid potential problems with
375 non standard math libs */
376 /* XXX: endianness dependent */
377 ST_FUNC
int ieee_finite(double d
)
380 memcpy(p
, &d
, sizeof(double));
381 return ((unsigned)((p
[1] | 0x800fffff) + 1)) >> 31;
384 /* compiling intel long double natively */
385 #if (defined __i386__ || defined __x86_64__) \
386 && (defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64)
387 # define TCC_IS_NATIVE_387
390 ST_FUNC
void test_lvalue(void)
392 if (!(vtop
->r
& VT_LVAL
))
396 ST_FUNC
void check_vstack(void)
398 if (vtop
!= vstack
- 1)
399 tcc_error("internal compiler error: vstack leak (%d)",
400 (int)(vtop
- vstack
+ 1));
403 /* ------------------------------------------------------------------------- */
404 /* vstack debugging aid */
407 void pv (const char *lbl
, int a
, int b
)
410 for (i
= a
; i
< a
+ b
; ++i
) {
411 SValue
*p
= &vtop
[-i
];
412 printf("%s vtop[-%d] : type.t:%04x r:%04x r2:%04x c.i:%d\n",
413 lbl
, i
, p
->type
.t
, p
->r
, p
->r2
, (int)p
->c
.i
);
418 /* ------------------------------------------------------------------------- */
419 /* start of translation unit info */
420 ST_FUNC
void tcc_debug_start(TCCState
*s1
)
426 /* file info: full path + filename */
427 section_sym
= put_elf_sym(symtab_section
, 0, 0,
428 ELFW(ST_INFO
)(STB_LOCAL
, STT_SECTION
), 0,
429 text_section
->sh_num
, NULL
);
430 getcwd(buf
, sizeof(buf
));
432 normalize_slashes(buf
);
434 pstrcat(buf
, sizeof(buf
), "/");
435 put_stabs_r(s1
, buf
, N_SO
, 0, 0,
436 text_section
->data_offset
, text_section
, section_sym
);
437 put_stabs_r(s1
, file
->prev
? file
->prev
->filename
: file
->filename
,
439 text_section
->data_offset
, text_section
, section_sym
);
440 for (i
= 0; i
< sizeof (default_debug
) / sizeof (default_debug
[0]); i
++)
441 put_stabs(s1
, default_debug
[i
].name
, N_LSYM
, 0, 0, 0);
443 new_file
= last_line_num
= 0;
445 debug_next_type
= sizeof(default_debug
) / sizeof(default_debug
[0]);
449 /* we're currently 'including' the <command line> */
453 /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
454 symbols can be safely used */
455 put_elf_sym(symtab_section
, 0, 0,
456 ELFW(ST_INFO
)(STB_LOCAL
, STT_FILE
), 0,
457 SHN_ABS
, file
->filename
);
460 /* put end of translation unit info */
461 ST_FUNC
void tcc_debug_end(TCCState
*s1
)
465 put_stabs_r(s1
, NULL
, N_SO
, 0, 0,
466 text_section
->data_offset
, text_section
, section_sym
);
467 tcc_free(debug_hash
);
470 static BufferedFile
* put_new_file(TCCState
*s1
)
472 BufferedFile
*f
= file
;
473 /* use upper file if from inline ":asm:" */
474 if (f
->filename
[0] == ':')
477 put_stabs_r(s1
, f
->filename
, N_SOL
, 0, 0, ind
, text_section
, section_sym
);
478 new_file
= last_line_num
= 0;
483 /* put alternative filename */
484 ST_FUNC
void tcc_debug_putfile(TCCState
*s1
, const char *filename
)
486 if (0 == strcmp(file
->filename
, filename
))
488 pstrcpy(file
->filename
, sizeof(file
->filename
), filename
);
492 /* begin of #include */
493 ST_FUNC
void tcc_debug_bincl(TCCState
*s1
)
497 put_stabs(s1
, file
->filename
, N_BINCL
, 0, 0, 0);
501 /* end of #include */
502 ST_FUNC
void tcc_debug_eincl(TCCState
*s1
)
506 put_stabn(s1
, N_EINCL
, 0, 0, 0);
510 /* generate line number info */
511 static void tcc_debug_line(TCCState
*s1
)
515 || cur_text_section
!= text_section
516 || !(f
= put_new_file(s1
))
517 || last_line_num
== f
->line_num
)
519 if (func_ind
!= -1) {
520 put_stabn(s1
, N_SLINE
, 0, f
->line_num
, ind
- func_ind
);
522 /* from tcc_assemble */
523 put_stabs_r(s1
, NULL
, N_SLINE
, 0, f
->line_num
, ind
, text_section
, section_sym
);
525 last_line_num
= f
->line_num
;
528 static void tcc_debug_stabs (TCCState
*s1
, const char *str
, int type
, unsigned long value
,
529 Section
*sec
, int sym_index
)
535 (struct debug_sym
*)tcc_realloc (debug_info
->sym
,
536 sizeof(struct debug_sym
) *
537 (debug_info
->n_sym
+ 1));
538 s
= debug_info
->sym
+ debug_info
->n_sym
++;
541 s
->str
= tcc_strdup(str
);
543 s
->sym_index
= sym_index
;
546 put_stabs_r (s1
, str
, type
, 0, 0, value
, sec
, sym_index
);
548 put_stabs (s1
, str
, type
, 0, 0, value
);
551 static void tcc_debug_stabn(TCCState
*s1
, int type
, int value
)
555 if (type
== N_LBRAC
) {
556 struct debug_info
*info
=
557 (struct debug_info
*) tcc_mallocz(sizeof (*info
));
560 info
->parent
= debug_info
;
562 if (debug_info
->child
) {
563 if (debug_info
->child
->last
)
564 debug_info
->child
->last
->next
= info
;
566 debug_info
->child
->next
= info
;
567 debug_info
->child
->last
= info
;
570 debug_info
->child
= info
;
573 debug_info_root
= info
;
577 debug_info
->end
= value
;
578 debug_info
= debug_info
->parent
;
582 static void tcc_get_debug_info(TCCState
*s1
, Sym
*s
, CString
*result
)
591 type
= t
->type
.t
& ~(VT_STORAGE
| VT_CONSTANT
| VT_VOLATILE
);
592 if ((type
& VT_BTYPE
) != VT_BYTE
)
594 if (type
== VT_PTR
|| type
== (VT_PTR
| VT_ARRAY
))
595 n
++, t
= t
->type
.ref
;
599 if ((type
& VT_BTYPE
) == VT_STRUCT
) {
603 for (i
= 0; i
< n_debug_hash
; i
++) {
604 if (t
== debug_hash
[i
].type
) {
605 debug_type
= debug_hash
[i
].debug_type
;
609 if (debug_type
== -1) {
610 debug_type
= ++debug_next_type
;
611 debug_hash
= (struct debug_hash
*)
612 tcc_realloc (debug_hash
,
613 (n_debug_hash
+ 1) * sizeof(*debug_hash
));
614 debug_hash
[n_debug_hash
].debug_type
= debug_type
;
615 debug_hash
[n_debug_hash
++].type
= t
;
617 cstr_printf (&str
, "%s:T%d=%c%d",
618 (t
->v
& ~SYM_STRUCT
) >= SYM_FIRST_ANOM
619 ? "" : get_tok_str(t
->v
& ~SYM_STRUCT
, NULL
),
621 IS_UNION (t
->type
.t
) ? 'u' : 's',
624 int pos
, size
, align
;
627 cstr_printf (&str
, "%s:",
628 (t
->v
& ~SYM_FIELD
) >= SYM_FIRST_ANOM
629 ? "" : get_tok_str(t
->v
& ~SYM_FIELD
, NULL
));
630 tcc_get_debug_info (s1
, t
, &str
);
631 if (t
->type
.t
& VT_BITFIELD
) {
632 pos
= t
->c
* 8 + BIT_POS(t
->type
.t
);
633 size
= BIT_SIZE(t
->type
.t
);
637 size
= type_size(&t
->type
, &align
) * 8;
639 cstr_printf (&str
, ",%d,%d;", pos
, size
);
641 cstr_printf (&str
, ";");
642 tcc_debug_stabs(s1
, str
.data
, N_LSYM
, 0, NULL
, 0);
646 else if (IS_ENUM(type
)) {
647 Sym
*e
= t
= t
->type
.ref
;
649 debug_type
= ++debug_next_type
;
651 cstr_printf (&str
, "%s:T%d=e",
652 (t
->v
& ~SYM_STRUCT
) >= SYM_FIRST_ANOM
653 ? "" : get_tok_str(t
->v
& ~SYM_STRUCT
, NULL
),
657 cstr_printf (&str
, "%s:",
658 (t
->v
& ~SYM_FIELD
) >= SYM_FIRST_ANOM
659 ? "" : get_tok_str(t
->v
& ~SYM_FIELD
, NULL
));
660 cstr_printf (&str
, e
->type
.t
& VT_UNSIGNED
? "%u," : "%d,",
663 cstr_printf (&str
, ";");
664 tcc_debug_stabs(s1
, str
.data
, N_LSYM
, 0, NULL
, 0);
667 else if ((type
& VT_BTYPE
) != VT_FUNC
) {
668 type
&= ~VT_STRUCT_MASK
;
670 debug_type
<= sizeof(default_debug
) / sizeof(default_debug
[0]);
672 if (default_debug
[debug_type
- 1].type
== type
)
674 if (debug_type
> sizeof(default_debug
) / sizeof(default_debug
[0]))
678 cstr_printf (result
, "%d=", ++debug_next_type
);
681 type
= t
->type
.t
& ~(VT_STORAGE
| VT_CONSTANT
| VT_VOLATILE
);
682 if ((type
& VT_BTYPE
) != VT_BYTE
)
685 cstr_printf (result
, "%d=*", ++debug_next_type
);
686 else if (type
== (VT_PTR
| VT_ARRAY
))
687 cstr_printf (result
, "%d=ar1;0;%d;",
688 ++debug_next_type
, t
->type
.ref
->c
- 1);
689 else if (type
== VT_FUNC
) {
690 cstr_printf (result
, "%d=f", ++debug_next_type
);
691 tcc_get_debug_info (s1
, t
->type
.ref
, result
);
698 cstr_printf (result
, "%d", debug_type
);
701 static void tcc_debug_finish (TCCState
*s1
, struct debug_info
*cur
)
705 struct debug_info
*next
= cur
->next
;
707 for (i
= 0; i
< cur
->n_sym
; i
++) {
708 struct debug_sym
*s
= &cur
->sym
[i
];
711 put_stabs_r(s1
, s
->str
, s
->type
, 0, 0, s
->value
,
712 s
->sec
, s
->sym_index
);
714 put_stabs(s1
, s
->str
, s
->type
, 0, 0, s
->value
);
718 put_stabn(s1
, N_LBRAC
, 0, 0, cur
->start
);
719 tcc_debug_finish (s1
, cur
->child
);
720 put_stabn(s1
, N_RBRAC
, 0, 0, cur
->end
);
726 static void tcc_add_debug_info(TCCState
*s1
, int param
, Sym
*s
, Sym
*e
)
731 cstr_new (&debug_str
);
732 for (; s
!= e
; s
= s
->prev
) {
733 if (!s
->v
|| (s
->r
& VT_VALMASK
) != VT_LOCAL
)
735 cstr_reset (&debug_str
);
736 cstr_printf (&debug_str
, "%s:%s", get_tok_str(s
->v
, NULL
), param
? "p" : "");
737 tcc_get_debug_info(s1
, s
, &debug_str
);
738 tcc_debug_stabs(s1
, debug_str
.data
, param
? N_PSYM
: N_LSYM
, s
->c
, NULL
, 0);
740 cstr_free (&debug_str
);
743 /* put function symbol */
744 static void tcc_debug_funcstart(TCCState
*s1
, Sym
*sym
)
750 debug_info_root
= NULL
;
752 tcc_debug_stabn(s1
, N_LBRAC
, ind
- func_ind
);
753 if (!(f
= put_new_file(s1
)))
755 cstr_new (&debug_str
);
756 cstr_printf(&debug_str
, "%s:%c", funcname
, sym
->type
.t
& VT_STATIC
? 'f' : 'F');
757 tcc_get_debug_info(s1
, sym
->type
.ref
, &debug_str
);
758 put_stabs_r(s1
, debug_str
.data
, N_FUN
, 0, f
->line_num
, 0, cur_text_section
, sym
->c
);
759 cstr_free (&debug_str
);
764 /* put function size */
765 static void tcc_debug_funcend(TCCState
*s1
, int size
)
769 tcc_debug_stabn(s1
, N_RBRAC
, size
);
770 tcc_debug_finish (s1
, debug_info_root
);
774 static void tcc_debug_extern_sym(TCCState
*s1
, Sym
*sym
, int sh_num
, int sym_bind
, int sym_type
)
781 if (sym_type
== STT_FUNC
|| sym
->v
>= SYM_FIRST_ANOM
)
783 s
= s1
->sections
[sh_num
];
786 cstr_printf (&str
, "%s:%c",
787 get_tok_str(sym
->v
, NULL
),
788 sym_bind
== STB_GLOBAL
? 'G' : local_scope
? 'V' : 'S'
790 tcc_get_debug_info(s1
, sym
, &str
);
791 if (sym_bind
== STB_GLOBAL
)
792 tcc_debug_stabs(s1
, str
.data
, N_GSYM
, 0, NULL
, 0);
794 tcc_debug_stabs(s1
, str
.data
,
795 (sym
->type
.t
& VT_STATIC
) && data_section
== s
796 ? N_STSYM
: N_LCSYM
, 0, s
, sym
->c
);
800 static void tcc_debug_typedef(TCCState
*s1
, Sym
*sym
)
807 cstr_printf (&str
, "%s:t",
808 (sym
->v
& ~SYM_FIELD
) >= SYM_FIRST_ANOM
809 ? "" : get_tok_str(sym
->v
& ~SYM_FIELD
, NULL
));
810 tcc_get_debug_info(s1
, sym
, &str
);
811 tcc_debug_stabs(s1
, str
.data
, N_LSYM
, 0, NULL
, 0);
815 /* ------------------------------------------------------------------------- */
816 /* for section layout see lib/tcov.c */
818 static void tcc_tcov_block_end(int line
);
820 static void tcc_tcov_block_begin(void)
824 unsigned long last_offset
= tcov_data
.offset
;
826 tcc_tcov_block_end (0);
827 if (tcc_state
->test_coverage
== 0 || nocode_wanted
)
830 if (tcov_data
.last_file_name
== 0 ||
831 strcmp ((const char *)(tcov_section
->data
+ tcov_data
.last_file_name
),
832 file
->true_filename
) != 0) {
836 if (tcov_data
.last_func_name
)
837 section_ptr_add(tcov_section
, 1);
838 if (tcov_data
.last_file_name
)
839 section_ptr_add(tcov_section
, 1);
840 tcov_data
.last_func_name
= 0;
842 if (file
->true_filename
[0] == '/') {
843 tcov_data
.last_file_name
= tcov_section
->data_offset
;
844 cstr_printf (&cstr
, "%s", file
->true_filename
);
847 getcwd (wd
, sizeof(wd
));
848 tcov_data
.last_file_name
= tcov_section
->data_offset
+ strlen(wd
) + 1;
849 cstr_printf (&cstr
, "%s/%s", wd
, file
->true_filename
);
851 ptr
= section_ptr_add(tcov_section
, cstr
.size
+ 1);
852 strcpy((char *)ptr
, cstr
.data
);
854 normalize_slashes((char *)ptr
);
858 if (tcov_data
.last_func_name
== 0 ||
859 strcmp ((const char *)(tcov_section
->data
+ tcov_data
.last_func_name
),
863 if (tcov_data
.last_func_name
)
864 section_ptr_add(tcov_section
, 1);
865 tcov_data
.last_func_name
= tcov_section
->data_offset
;
866 len
= strlen (funcname
);
867 ptr
= section_ptr_add(tcov_section
, len
+ 1);
868 strcpy((char *)ptr
, funcname
);
869 section_ptr_add(tcov_section
, -tcov_section
->data_offset
& 7);
870 ptr
= section_ptr_add(tcov_section
, 8);
871 write64le (ptr
, file
->line_num
);
873 if (ind
== tcov_data
.ind
&& tcov_data
.line
== file
->line_num
)
874 tcov_data
.offset
= last_offset
;
877 label
.type
.t
= VT_LLONG
| VT_STATIC
;
879 ptr
= section_ptr_add(tcov_section
, 16);
880 tcov_data
.line
= file
->line_num
;
881 write64le (ptr
, (tcov_data
.line
<< 8) | 0xff);
882 put_extern_sym(&label
, tcov_section
,
883 ((unsigned char *)ptr
- tcov_section
->data
) + 8, 0);
884 sv
.type
= label
.type
;
885 sv
.r
= VT_SYM
| VT_LVAL
| VT_CONST
;
889 #if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64 || \
890 defined TCC_TARGET_ARM || defined TCC_TARGET_ARM64 || \
891 defined TCC_TARGET_RISCV64
892 gen_increment_tcov (&sv
);
898 tcov_data
.offset
= (unsigned char *)ptr
- tcov_section
->data
;
903 static void tcc_tcov_block_end(int line
)
905 if (tcc_state
->test_coverage
== 0)
907 if (tcov_data
.offset
) {
908 void *ptr
= tcov_section
->data
+ tcov_data
.offset
;
909 unsigned long long nline
= line
? line
: file
->line_num
;
911 write64le (ptr
, (read64le (ptr
) & 0xfffffffffull
) | (nline
<< 36));
912 tcov_data
.offset
= 0;
916 static void tcc_tcov_check_line(int start
)
918 if (tcc_state
->test_coverage
== 0)
920 if (tcov_data
.line
!= file
->line_num
) {
921 if ((tcov_data
.line
+ 1) != file
->line_num
) {
922 tcc_tcov_block_end (tcov_data
.line
);
924 tcc_tcov_block_begin ();
927 tcov_data
.line
= file
->line_num
;
931 static void tcc_tcov_start(void)
933 if (tcc_state
->test_coverage
== 0)
935 memset (&tcov_data
, 0, sizeof (tcov_data
));
936 if (tcov_section
== NULL
) {
937 tcov_section
= new_section(tcc_state
, ".tcov", SHT_PROGBITS
,
938 SHF_ALLOC
| SHF_WRITE
);
939 section_ptr_add(tcov_section
, 4); // pointer to executable name
943 static void tcc_tcov_end(void)
945 if (tcc_state
->test_coverage
== 0)
947 if (tcov_data
.last_func_name
)
948 section_ptr_add(tcov_section
, 1);
949 if (tcov_data
.last_file_name
)
950 section_ptr_add(tcov_section
, 1);
953 /* ------------------------------------------------------------------------- */
954 /* initialize vstack and types. This must be done also for tcc -E */
955 ST_FUNC
void tccgen_init(TCCState
*s1
)
958 memset(vtop
, 0, sizeof *vtop
);
960 /* define some often used types */
963 char_type
.t
= VT_BYTE
;
964 if (s1
->char_is_unsigned
)
965 char_type
.t
|= VT_UNSIGNED
;
966 char_pointer_type
= char_type
;
967 mk_pointer(&char_pointer_type
);
969 func_old_type
.t
= VT_FUNC
;
970 func_old_type
.ref
= sym_push(SYM_FIELD
, &int_type
, 0, 0);
971 func_old_type
.ref
->f
.func_call
= FUNC_CDECL
;
972 func_old_type
.ref
->f
.func_type
= FUNC_OLD
;
973 #ifdef precedence_parser
979 ST_FUNC
int tccgen_compile(TCCState
*s1
)
981 cur_text_section
= NULL
;
983 anon_sym
= SYM_FIRST_ANOM
;
986 nocode_wanted
= 0x80000000;
988 debug_modes
= s1
->do_debug
| s1
->test_coverage
<< 1;
992 #ifdef TCC_TARGET_ARM
996 printf("%s: **** new file\n", file
->filename
);
998 parse_flags
= PARSE_FLAG_PREPROCESS
| PARSE_FLAG_TOK_NUM
| PARSE_FLAG_TOK_STR
;
1001 gen_inline_functions(s1
);
1003 /* end of translation unit info */
1009 ST_FUNC
void tccgen_finish(TCCState
*s1
)
1011 cstr_free(&initstr
);
1012 free_inline_functions(s1
);
1013 sym_pop(&global_stack
, NULL
, 0);
1014 sym_pop(&local_stack
, NULL
, 0);
1015 /* free preprocessor macros */
1017 /* free sym_pools */
1018 dynarray_reset(&sym_pools
, &nb_sym_pools
);
1019 sym_free_first
= NULL
;
1022 /* ------------------------------------------------------------------------- */
1023 ST_FUNC ElfSym
*elfsym(Sym
*s
)
1027 return &((ElfSym
*)symtab_section
->data
)[s
->c
];
1030 /* apply storage attributes to Elf symbol */
1031 ST_FUNC
void update_storage(Sym
*sym
)
1034 int sym_bind
, old_sym_bind
;
1040 if (sym
->a
.visibility
)
1041 esym
->st_other
= (esym
->st_other
& ~ELFW(ST_VISIBILITY
)(-1))
1042 | sym
->a
.visibility
;
1044 if (sym
->type
.t
& (VT_STATIC
| VT_INLINE
))
1045 sym_bind
= STB_LOCAL
;
1046 else if (sym
->a
.weak
)
1047 sym_bind
= STB_WEAK
;
1049 sym_bind
= STB_GLOBAL
;
1050 old_sym_bind
= ELFW(ST_BIND
)(esym
->st_info
);
1051 if (sym_bind
!= old_sym_bind
) {
1052 esym
->st_info
= ELFW(ST_INFO
)(sym_bind
, ELFW(ST_TYPE
)(esym
->st_info
));
1055 #ifdef TCC_TARGET_PE
1056 if (sym
->a
.dllimport
)
1057 esym
->st_other
|= ST_PE_IMPORT
;
1058 if (sym
->a
.dllexport
)
1059 esym
->st_other
|= ST_PE_EXPORT
;
1063 printf("storage %s: bind=%c vis=%d exp=%d imp=%d\n",
1064 get_tok_str(sym
->v
, NULL
),
1065 sym_bind
== STB_WEAK
? 'w' : sym_bind
== STB_LOCAL
? 'l' : 'g',
1073 /* ------------------------------------------------------------------------- */
1074 /* update sym->c so that it points to an external symbol in section
1075 'section' with value 'value' */
1077 ST_FUNC
void put_extern_sym2(Sym
*sym
, int sh_num
,
1078 addr_t value
, unsigned long size
,
1079 int can_add_underscore
)
1081 int sym_type
, sym_bind
, info
, other
, t
;
1087 name
= get_tok_str(sym
->v
, NULL
);
1089 if ((t
& VT_BTYPE
) == VT_FUNC
) {
1090 sym_type
= STT_FUNC
;
1091 } else if ((t
& VT_BTYPE
) == VT_VOID
) {
1092 sym_type
= STT_NOTYPE
;
1093 if ((t
& (VT_BTYPE
|VT_ASM_FUNC
)) == VT_ASM_FUNC
)
1094 sym_type
= STT_FUNC
;
1096 sym_type
= STT_OBJECT
;
1098 if (t
& (VT_STATIC
| VT_INLINE
))
1099 sym_bind
= STB_LOCAL
;
1101 sym_bind
= STB_GLOBAL
;
1104 #ifdef TCC_TARGET_PE
1105 if (sym_type
== STT_FUNC
&& sym
->type
.ref
) {
1106 Sym
*ref
= sym
->type
.ref
;
1107 if (ref
->a
.nodecorate
) {
1108 can_add_underscore
= 0;
1110 if (ref
->f
.func_call
== FUNC_STDCALL
&& can_add_underscore
) {
1111 sprintf(buf1
, "_%s@%d", name
, ref
->f
.func_args
* PTR_SIZE
);
1113 other
|= ST_PE_STDCALL
;
1114 can_add_underscore
= 0;
1119 if (sym
->asm_label
) {
1120 name
= get_tok_str(sym
->asm_label
, NULL
);
1121 can_add_underscore
= 0;
1124 if (tcc_state
->leading_underscore
&& can_add_underscore
) {
1126 pstrcpy(buf1
+ 1, sizeof(buf1
) - 1, name
);
1130 info
= ELFW(ST_INFO
)(sym_bind
, sym_type
);
1131 sym
->c
= put_elf_sym(symtab_section
, value
, size
, info
, other
, sh_num
, name
);
1134 tcc_debug_extern_sym(tcc_state
, sym
, sh_num
, sym_bind
, sym_type
);
1138 esym
->st_value
= value
;
1139 esym
->st_size
= size
;
1140 esym
->st_shndx
= sh_num
;
1142 update_storage(sym
);
1145 ST_FUNC
void put_extern_sym(Sym
*sym
, Section
*section
,
1146 addr_t value
, unsigned long size
)
1148 int sh_num
= section
? section
->sh_num
: SHN_UNDEF
;
1149 put_extern_sym2(sym
, sh_num
, value
, size
, 1);
1152 /* add a new relocation entry to symbol 'sym' in section 's' */
1153 ST_FUNC
void greloca(Section
*s
, Sym
*sym
, unsigned long offset
, int type
,
1158 if (nocode_wanted
&& s
== cur_text_section
)
1163 put_extern_sym(sym
, NULL
, 0, 0);
1167 /* now we can add ELF relocation info */
1168 put_elf_reloca(symtab_section
, s
, offset
, type
, c
, addend
);
1172 ST_FUNC
void greloc(Section
*s
, Sym
*sym
, unsigned long offset
, int type
)
1174 greloca(s
, sym
, offset
, type
, 0);
1178 /* ------------------------------------------------------------------------- */
1179 /* symbol allocator */
1180 static Sym
*__sym_malloc(void)
1182 Sym
*sym_pool
, *sym
, *last_sym
;
1185 sym_pool
= tcc_malloc(SYM_POOL_NB
* sizeof(Sym
));
1186 dynarray_add(&sym_pools
, &nb_sym_pools
, sym_pool
);
1188 last_sym
= sym_free_first
;
1190 for(i
= 0; i
< SYM_POOL_NB
; i
++) {
1191 sym
->next
= last_sym
;
1195 sym_free_first
= last_sym
;
1199 static inline Sym
*sym_malloc(void)
1203 sym
= sym_free_first
;
1205 sym
= __sym_malloc();
1206 sym_free_first
= sym
->next
;
1209 sym
= tcc_malloc(sizeof(Sym
));
1214 ST_INLN
void sym_free(Sym
*sym
)
1217 sym
->next
= sym_free_first
;
1218 sym_free_first
= sym
;
1224 /* push, without hashing */
1225 ST_FUNC Sym
*sym_push2(Sym
**ps
, int v
, int t
, int c
)
1230 memset(s
, 0, sizeof *s
);
1240 /* find a symbol and return its associated structure. 's' is the top
1241 of the symbol stack */
1242 ST_FUNC Sym
*sym_find2(Sym
*s
, int v
)
1247 else if (s
->v
== -1)
1254 /* structure lookup */
1255 ST_INLN Sym
*struct_find(int v
)
1258 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1260 return table_ident
[v
]->sym_struct
;
1263 /* find an identifier */
1264 ST_INLN Sym
*sym_find(int v
)
1267 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1269 return table_ident
[v
]->sym_identifier
;
1272 static int sym_scope(Sym
*s
)
1274 if (IS_ENUM_VAL (s
->type
.t
))
1275 return s
->type
.ref
->sym_scope
;
1277 return s
->sym_scope
;
1280 /* push a given symbol on the symbol stack */
1281 ST_FUNC Sym
*sym_push(int v
, CType
*type
, int r
, int c
)
1290 s
= sym_push2(ps
, v
, type
->t
, c
);
1291 s
->type
.ref
= type
->ref
;
1293 /* don't record fields or anonymous symbols */
1295 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1296 /* record symbol in token array */
1297 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1299 ps
= &ts
->sym_struct
;
1301 ps
= &ts
->sym_identifier
;
1304 s
->sym_scope
= local_scope
;
1305 if (s
->prev_tok
&& sym_scope(s
->prev_tok
) == s
->sym_scope
)
1306 tcc_error("redeclaration of '%s'",
1307 get_tok_str(v
& ~SYM_STRUCT
, NULL
));
1312 /* push a global identifier */
1313 ST_FUNC Sym
*global_identifier_push(int v
, int t
, int c
)
1316 s
= sym_push2(&global_stack
, v
, t
, c
);
1317 s
->r
= VT_CONST
| VT_SYM
;
1318 /* don't record anonymous symbol */
1319 if (v
< SYM_FIRST_ANOM
) {
1320 ps
= &table_ident
[v
- TOK_IDENT
]->sym_identifier
;
1321 /* modify the top most local identifier, so that sym_identifier will
1322 point to 's' when popped; happens when called from inline asm */
1323 while (*ps
!= NULL
&& (*ps
)->sym_scope
)
1324 ps
= &(*ps
)->prev_tok
;
1331 /* pop symbols until top reaches 'b'. If KEEP is non-zero don't really
1332 pop them yet from the list, but do remove them from the token array. */
1333 ST_FUNC
void sym_pop(Sym
**ptop
, Sym
*b
, int keep
)
1343 /* remove symbol in token array */
1345 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1346 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1348 ps
= &ts
->sym_struct
;
1350 ps
= &ts
->sym_identifier
;
1361 /* ------------------------------------------------------------------------- */
1362 static void vcheck_cmp(void)
1364 /* cannot let cpu flags if other instruction are generated. Also
1365 avoid leaving VT_JMP anywhere except on the top of the stack
1366 because it would complicate the code generator.
1368 Don't do this when nocode_wanted. vtop might come from
1369 !nocode_wanted regions (see 88_codeopt.c) and transforming
1370 it to a register without actually generating code is wrong
1371 as their value might still be used for real. All values
1372 we push under nocode_wanted will eventually be popped
1373 again, so that the VT_CMP/VT_JMP value will be in vtop
1374 when code is unsuppressed again. */
1376 if (vtop
->r
== VT_CMP
&& !nocode_wanted
)
1380 static void vsetc(CType
*type
, int r
, CValue
*vc
)
1382 if (vtop
>= vstack
+ (VSTACK_SIZE
- 1))
1383 tcc_error("memory full (vstack)");
1388 vtop
->r2
= VT_CONST
;
1393 ST_FUNC
void vswap(void)
1403 /* pop stack value */
1404 ST_FUNC
void vpop(void)
1407 v
= vtop
->r
& VT_VALMASK
;
1408 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
1409 /* for x86, we need to pop the FP stack */
1410 if (v
== TREG_ST0
) {
1411 o(0xd8dd); /* fstp %st(0) */
1415 /* need to put correct jump if && or || without test */
1422 /* push constant of type "type" with useless value */
1423 static void vpush(CType
*type
)
1425 vset(type
, VT_CONST
, 0);
1428 /* push arbitrary 64bit constant */
1429 static void vpush64(int ty
, unsigned long long v
)
1436 vsetc(&ctype
, VT_CONST
, &cval
);
1439 /* push integer constant */
1440 ST_FUNC
void vpushi(int v
)
1445 /* push a pointer sized constant */
1446 static void vpushs(addr_t v
)
1448 vpush64(VT_SIZE_T
, v
);
1451 /* push long long constant */
1452 static inline void vpushll(long long v
)
1454 vpush64(VT_LLONG
, v
);
1457 ST_FUNC
void vset(CType
*type
, int r
, int v
)
1461 vsetc(type
, r
, &cval
);
1464 static void vseti(int r
, int v
)
1472 ST_FUNC
void vpushv(SValue
*v
)
1474 if (vtop
>= vstack
+ (VSTACK_SIZE
- 1))
1475 tcc_error("memory full (vstack)");
1480 static void vdup(void)
1485 /* rotate n first stack elements to the bottom
1486 I1 ... In -> I2 ... In I1 [top is right]
1488 ST_FUNC
void vrotb(int n
)
1495 for(i
=-n
+1;i
!=0;i
++)
1496 vtop
[i
] = vtop
[i
+1];
1500 /* rotate the n elements before entry e towards the top
1501 I1 ... In ... -> In I1 ... I(n-1) ... [top is right]
1503 ST_FUNC
void vrote(SValue
*e
, int n
)
1510 for(i
= 0;i
< n
- 1; i
++)
1515 /* rotate n first stack elements to the top
1516 I1 ... In -> In I1 ... I(n-1) [top is right]
1518 ST_FUNC
void vrott(int n
)
1523 /* ------------------------------------------------------------------------- */
1524 /* vtop->r = VT_CMP means CPU-flags have been set from comparison or test. */
1526 /* called from generators to set the result from relational ops */
1527 ST_FUNC
void vset_VT_CMP(int op
)
1535 /* called once before asking generators to load VT_CMP to a register */
1536 static void vset_VT_JMP(void)
1538 int op
= vtop
->cmp_op
;
1540 if (vtop
->jtrue
|| vtop
->jfalse
) {
1541 /* we need to jump to 'mov $0,%R' or 'mov $1,%R' */
1542 int inv
= op
& (op
< 2); /* small optimization */
1543 vseti(VT_JMP
+inv
, gvtst(inv
, 0));
1545 /* otherwise convert flags (rsp. 0/1) to register */
1547 if (op
< 2) /* doesn't seem to happen */
1552 /* Set CPU Flags, doesn't yet jump */
1553 static void gvtst_set(int inv
, int t
)
1557 if (vtop
->r
!= VT_CMP
) {
1560 if (vtop
->r
!= VT_CMP
) /* must be VT_CONST then */
1561 vset_VT_CMP(vtop
->c
.i
!= 0);
1564 p
= inv
? &vtop
->jfalse
: &vtop
->jtrue
;
1565 *p
= gjmp_append(*p
, t
);
1568 /* Generate value test
1570 * Generate a test for any value (jump, comparison and integers) */
1571 static int gvtst(int inv
, int t
)
1576 t
= vtop
->jtrue
, u
= vtop
->jfalse
;
1578 x
= u
, u
= t
, t
= x
;
1581 /* jump to the wanted target */
1583 t
= gjmp_cond(op
^ inv
, t
);
1586 /* resolve complementary jumps to here */
1593 /* generate a zero or nozero test */
1594 static void gen_test_zero(int op
)
1596 if (vtop
->r
== VT_CMP
) {
1600 vtop
->jfalse
= vtop
->jtrue
;
1610 /* ------------------------------------------------------------------------- */
1611 /* push a symbol value of TYPE */
1612 ST_FUNC
void vpushsym(CType
*type
, Sym
*sym
)
1616 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
1620 /* Return a static symbol pointing to a section */
1621 ST_FUNC Sym
*get_sym_ref(CType
*type
, Section
*sec
, unsigned long offset
, unsigned long size
)
1627 sym
= sym_push(v
, type
, VT_CONST
| VT_SYM
, 0);
1628 sym
->type
.t
|= VT_STATIC
;
1629 put_extern_sym(sym
, sec
, offset
, size
);
1633 /* push a reference to a section offset by adding a dummy symbol */
1634 static void vpush_ref(CType
*type
, Section
*sec
, unsigned long offset
, unsigned long size
)
1636 vpushsym(type
, get_sym_ref(type
, sec
, offset
, size
));
1639 /* define a new external reference to a symbol 'v' of type 'u' */
1640 ST_FUNC Sym
*external_global_sym(int v
, CType
*type
)
1646 /* push forward reference */
1647 s
= global_identifier_push(v
, type
->t
| VT_EXTERN
, 0);
1648 s
->type
.ref
= type
->ref
;
1649 } else if (IS_ASM_SYM(s
)) {
1650 s
->type
.t
= type
->t
| (s
->type
.t
& VT_EXTERN
);
1651 s
->type
.ref
= type
->ref
;
1657 /* create an external reference with no specific type similar to asm labels.
1658 This avoids type conflicts if the symbol is used from C too */
1659 ST_FUNC Sym
*external_helper_sym(int v
)
1661 CType ct
= { VT_ASM_FUNC
, NULL
};
1662 return external_global_sym(v
, &ct
);
1665 /* push a reference to an helper function (such as memmove) */
1666 ST_FUNC
void vpush_helper_func(int v
)
1668 vpushsym(&func_old_type
, external_helper_sym(v
));
1671 /* Merge symbol attributes. */
1672 static void merge_symattr(struct SymAttr
*sa
, struct SymAttr
*sa1
)
1674 if (sa1
->aligned
&& !sa
->aligned
)
1675 sa
->aligned
= sa1
->aligned
;
1676 sa
->packed
|= sa1
->packed
;
1677 sa
->weak
|= sa1
->weak
;
1678 if (sa1
->visibility
!= STV_DEFAULT
) {
1679 int vis
= sa
->visibility
;
1680 if (vis
== STV_DEFAULT
1681 || vis
> sa1
->visibility
)
1682 vis
= sa1
->visibility
;
1683 sa
->visibility
= vis
;
1685 sa
->dllexport
|= sa1
->dllexport
;
1686 sa
->nodecorate
|= sa1
->nodecorate
;
1687 sa
->dllimport
|= sa1
->dllimport
;
1690 /* Merge function attributes. */
1691 static void merge_funcattr(struct FuncAttr
*fa
, struct FuncAttr
*fa1
)
1693 if (fa1
->func_call
&& !fa
->func_call
)
1694 fa
->func_call
= fa1
->func_call
;
1695 if (fa1
->func_type
&& !fa
->func_type
)
1696 fa
->func_type
= fa1
->func_type
;
1697 if (fa1
->func_args
&& !fa
->func_args
)
1698 fa
->func_args
= fa1
->func_args
;
1699 if (fa1
->func_noreturn
)
1700 fa
->func_noreturn
= 1;
1707 /* Merge attributes. */
1708 static void merge_attr(AttributeDef
*ad
, AttributeDef
*ad1
)
1710 merge_symattr(&ad
->a
, &ad1
->a
);
1711 merge_funcattr(&ad
->f
, &ad1
->f
);
1714 ad
->section
= ad1
->section
;
1715 if (ad1
->alias_target
)
1716 ad
->alias_target
= ad1
->alias_target
;
1718 ad
->asm_label
= ad1
->asm_label
;
1720 ad
->attr_mode
= ad1
->attr_mode
;
1723 /* Merge some type attributes. */
1724 static void patch_type(Sym
*sym
, CType
*type
)
1726 if (!(type
->t
& VT_EXTERN
) || IS_ENUM_VAL(sym
->type
.t
)) {
1727 if (!(sym
->type
.t
& VT_EXTERN
))
1728 tcc_error("redefinition of '%s'", get_tok_str(sym
->v
, NULL
));
1729 sym
->type
.t
&= ~VT_EXTERN
;
1732 if (IS_ASM_SYM(sym
)) {
1733 /* stay static if both are static */
1734 sym
->type
.t
= type
->t
& (sym
->type
.t
| ~VT_STATIC
);
1735 sym
->type
.ref
= type
->ref
;
1738 if (!is_compatible_types(&sym
->type
, type
)) {
1739 tcc_error("incompatible types for redefinition of '%s'",
1740 get_tok_str(sym
->v
, NULL
));
1742 } else if ((sym
->type
.t
& VT_BTYPE
) == VT_FUNC
) {
1743 int static_proto
= sym
->type
.t
& VT_STATIC
;
1744 /* warn if static follows non-static function declaration */
1745 if ((type
->t
& VT_STATIC
) && !static_proto
1746 /* XXX this test for inline shouldn't be here. Until we
1747 implement gnu-inline mode again it silences a warning for
1748 mingw caused by our workarounds. */
1749 && !((type
->t
| sym
->type
.t
) & VT_INLINE
))
1750 tcc_warning("static storage ignored for redefinition of '%s'",
1751 get_tok_str(sym
->v
, NULL
));
1753 /* set 'inline' if both agree or if one has static */
1754 if ((type
->t
| sym
->type
.t
) & VT_INLINE
) {
1755 if (!((type
->t
^ sym
->type
.t
) & VT_INLINE
)
1756 || ((type
->t
| sym
->type
.t
) & VT_STATIC
))
1757 static_proto
|= VT_INLINE
;
1760 if (0 == (type
->t
& VT_EXTERN
)) {
1761 struct FuncAttr f
= sym
->type
.ref
->f
;
1762 /* put complete type, use static from prototype */
1763 sym
->type
.t
= (type
->t
& ~(VT_STATIC
|VT_INLINE
)) | static_proto
;
1764 sym
->type
.ref
= type
->ref
;
1765 merge_funcattr(&sym
->type
.ref
->f
, &f
);
1767 sym
->type
.t
&= ~VT_INLINE
| static_proto
;
1770 if (sym
->type
.ref
->f
.func_type
== FUNC_OLD
1771 && type
->ref
->f
.func_type
!= FUNC_OLD
) {
1772 sym
->type
.ref
= type
->ref
;
1776 if ((sym
->type
.t
& VT_ARRAY
) && type
->ref
->c
>= 0) {
1777 /* set array size if it was omitted in extern declaration */
1778 sym
->type
.ref
->c
= type
->ref
->c
;
1780 if ((type
->t
^ sym
->type
.t
) & VT_STATIC
)
1781 tcc_warning("storage mismatch for redefinition of '%s'",
1782 get_tok_str(sym
->v
, NULL
));
1786 /* Merge some storage attributes. */
1787 static void patch_storage(Sym
*sym
, AttributeDef
*ad
, CType
*type
)
1790 patch_type(sym
, type
);
1792 #ifdef TCC_TARGET_PE
1793 if (sym
->a
.dllimport
!= ad
->a
.dllimport
)
1794 tcc_error("incompatible dll linkage for redefinition of '%s'",
1795 get_tok_str(sym
->v
, NULL
));
1797 merge_symattr(&sym
->a
, &ad
->a
);
1799 sym
->asm_label
= ad
->asm_label
;
1800 update_storage(sym
);
1803 /* copy sym to other stack */
1804 static Sym
*sym_copy(Sym
*s0
, Sym
**ps
)
1807 s
= sym_malloc(), *s
= *s0
;
1808 s
->prev
= *ps
, *ps
= s
;
1809 if (s
->v
< SYM_FIRST_ANOM
) {
1810 ps
= &table_ident
[s
->v
- TOK_IDENT
]->sym_identifier
;
1811 s
->prev_tok
= *ps
, *ps
= s
;
1816 /* copy s->type.ref to stack 'ps' for VT_FUNC and VT_PTR */
1817 static void sym_copy_ref(Sym
*s
, Sym
**ps
)
1819 int bt
= s
->type
.t
& VT_BTYPE
;
1820 if (bt
== VT_FUNC
|| bt
== VT_PTR
|| (bt
== VT_STRUCT
&& s
->sym_scope
)) {
1821 Sym
**sp
= &s
->type
.ref
;
1822 for (s
= *sp
, *sp
= NULL
; s
; s
= s
->next
) {
1823 Sym
*s2
= sym_copy(s
, ps
);
1824 sp
= &(*sp
= s2
)->next
;
1825 sym_copy_ref(s2
, ps
);
1830 /* define a new external reference to a symbol 'v' */
1831 static Sym
*external_sym(int v
, CType
*type
, int r
, AttributeDef
*ad
)
1835 /* look for global symbol */
1837 while (s
&& s
->sym_scope
)
1841 /* push forward reference */
1842 s
= global_identifier_push(v
, type
->t
, 0);
1845 s
->asm_label
= ad
->asm_label
;
1846 s
->type
.ref
= type
->ref
;
1847 /* copy type to the global stack */
1849 sym_copy_ref(s
, &global_stack
);
1851 patch_storage(s
, ad
, type
);
1853 /* push variables on local_stack if any */
1854 if (local_stack
&& (s
->type
.t
& VT_BTYPE
) != VT_FUNC
)
1855 s
= sym_copy(s
, &local_stack
);
1859 /* save registers up to (vtop - n) stack entry */
1860 ST_FUNC
void save_regs(int n
)
1863 for(p
= vstack
, p1
= vtop
- n
; p
<= p1
; p
++)
1867 /* save r to the memory stack, and mark it as being free */
1868 ST_FUNC
void save_reg(int r
)
1870 save_reg_upstack(r
, 0);
1873 /* save r to the memory stack, and mark it as being free,
1874 if seen up to (vtop - n) stack entry */
1875 ST_FUNC
void save_reg_upstack(int r
, int n
)
1877 int l
, size
, align
, bt
;
1880 if ((r
&= VT_VALMASK
) >= VT_CONST
)
1885 for(p
= vstack
, p1
= vtop
- n
; p
<= p1
; p
++) {
1886 if ((p
->r
& VT_VALMASK
) == r
|| p
->r2
== r
) {
1887 /* must save value on stack if not already done */
1889 bt
= p
->type
.t
& VT_BTYPE
;
1892 if ((p
->r
& VT_LVAL
) || bt
== VT_FUNC
)
1895 size
= type_size(&sv
.type
, &align
);
1896 l
= get_temp_local_var(size
,align
);
1897 sv
.r
= VT_LOCAL
| VT_LVAL
;
1899 store(p
->r
& VT_VALMASK
, &sv
);
1900 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
1901 /* x86 specific: need to pop fp register ST0 if saved */
1902 if (r
== TREG_ST0
) {
1903 o(0xd8dd); /* fstp %st(0) */
1906 /* special long long case */
1907 if (p
->r2
< VT_CONST
&& USING_TWO_WORDS(bt
)) {
1912 /* mark that stack entry as being saved on the stack */
1913 if (p
->r
& VT_LVAL
) {
1914 /* also clear the bounded flag because the
1915 relocation address of the function was stored in
1917 p
->r
= (p
->r
& ~(VT_VALMASK
| VT_BOUNDED
)) | VT_LLOCAL
;
1919 p
->r
= VT_LVAL
| VT_LOCAL
;
1928 #ifdef TCC_TARGET_ARM
1929 /* find a register of class 'rc2' with at most one reference on stack.
1930 * If none, call get_reg(rc) */
1931 ST_FUNC
int get_reg_ex(int rc
, int rc2
)
1936 for(r
=0;r
<NB_REGS
;r
++) {
1937 if (reg_classes
[r
] & rc2
) {
1940 for(p
= vstack
; p
<= vtop
; p
++) {
1941 if ((p
->r
& VT_VALMASK
) == r
||
1953 /* find a free register of class 'rc'. If none, save one register */
1954 ST_FUNC
int get_reg(int rc
)
1959 /* find a free register */
1960 for(r
=0;r
<NB_REGS
;r
++) {
1961 if (reg_classes
[r
] & rc
) {
1964 for(p
=vstack
;p
<=vtop
;p
++) {
1965 if ((p
->r
& VT_VALMASK
) == r
||
1974 /* no register left : free the first one on the stack (VERY
1975 IMPORTANT to start from the bottom to ensure that we don't
1976 spill registers used in gen_opi()) */
1977 for(p
=vstack
;p
<=vtop
;p
++) {
1978 /* look at second register (if long long) */
1980 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
))
1982 r
= p
->r
& VT_VALMASK
;
1983 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
)) {
1989 /* Should never comes here */
1993 /* find a free temporary local variable (return the offset on stack) match the size and align. If none, add new temporary stack variable*/
1994 static int get_temp_local_var(int size
,int align
){
1996 struct temp_local_variable
*temp_var
;
2003 for(i
=0;i
<nb_temp_local_vars
;i
++){
2004 temp_var
=&arr_temp_local_vars
[i
];
2005 if(temp_var
->size
<size
||align
!=temp_var
->align
){
2008 /*check if temp_var is free*/
2010 for(p
=vstack
;p
<=vtop
;p
++) {
2012 if(r
==VT_LOCAL
||r
==VT_LLOCAL
){
2013 if(p
->c
.i
==temp_var
->location
){
2020 found_var
=temp_var
->location
;
2026 loc
= (loc
- size
) & -align
;
2027 if(nb_temp_local_vars
<MAX_TEMP_LOCAL_VARIABLE_NUMBER
){
2028 temp_var
=&arr_temp_local_vars
[i
];
2029 temp_var
->location
=loc
;
2030 temp_var
->size
=size
;
2031 temp_var
->align
=align
;
2032 nb_temp_local_vars
++;
2039 static void clear_temp_local_var_list(){
2040 nb_temp_local_vars
=0;
2043 /* move register 's' (of type 't') to 'r', and flush previous value of r to memory
2045 static void move_reg(int r
, int s
, int t
)
2059 /* get address of vtop (vtop MUST BE an lvalue) */
2060 ST_FUNC
void gaddrof(void)
2062 vtop
->r
&= ~VT_LVAL
;
2063 /* tricky: if saved lvalue, then we can go back to lvalue */
2064 if ((vtop
->r
& VT_VALMASK
) == VT_LLOCAL
)
2065 vtop
->r
= (vtop
->r
& ~VT_VALMASK
) | VT_LOCAL
| VT_LVAL
;
2068 #ifdef CONFIG_TCC_BCHECK
2069 /* generate a bounded pointer addition */
2070 static void gen_bounded_ptr_add(void)
2072 int save
= (vtop
[-1].r
& VT_VALMASK
) == VT_LOCAL
;
2077 vpush_helper_func(TOK___bound_ptr_add
);
2082 /* returned pointer is in REG_IRET */
2083 vtop
->r
= REG_IRET
| VT_BOUNDED
;
2086 /* relocation offset of the bounding function call point */
2087 vtop
->c
.i
= (cur_text_section
->reloc
->data_offset
- sizeof(ElfW_Rel
));
2090 /* patch pointer addition in vtop so that pointer dereferencing is
2092 static void gen_bounded_ptr_deref(void)
2102 size
= type_size(&vtop
->type
, &align
);
2104 case 1: func
= TOK___bound_ptr_indir1
; break;
2105 case 2: func
= TOK___bound_ptr_indir2
; break;
2106 case 4: func
= TOK___bound_ptr_indir4
; break;
2107 case 8: func
= TOK___bound_ptr_indir8
; break;
2108 case 12: func
= TOK___bound_ptr_indir12
; break;
2109 case 16: func
= TOK___bound_ptr_indir16
; break;
2111 /* may happen with struct member access */
2114 sym
= external_helper_sym(func
);
2116 put_extern_sym(sym
, NULL
, 0, 0);
2117 /* patch relocation */
2118 /* XXX: find a better solution ? */
2119 rel
= (ElfW_Rel
*)(cur_text_section
->reloc
->data
+ vtop
->c
.i
);
2120 rel
->r_info
= ELFW(R_INFO
)(sym
->c
, ELFW(R_TYPE
)(rel
->r_info
));
2123 /* generate lvalue bound code */
2124 static void gbound(void)
2128 vtop
->r
&= ~VT_MUSTBOUND
;
2129 /* if lvalue, then use checking code before dereferencing */
2130 if (vtop
->r
& VT_LVAL
) {
2131 /* if not VT_BOUNDED value, then make one */
2132 if (!(vtop
->r
& VT_BOUNDED
)) {
2133 /* must save type because we must set it to int to get pointer */
2135 vtop
->type
.t
= VT_PTR
;
2138 gen_bounded_ptr_add();
2142 /* then check for dereferencing */
2143 gen_bounded_ptr_deref();
2147 /* we need to call __bound_ptr_add before we start to load function
2148 args into registers */
2149 ST_FUNC
void gbound_args(int nb_args
)
2154 for (i
= 1; i
<= nb_args
; ++i
)
2155 if (vtop
[1 - i
].r
& VT_MUSTBOUND
) {
2161 sv
= vtop
- nb_args
;
2162 if (sv
->r
& VT_SYM
) {
2166 #ifndef TCC_TARGET_PE
2167 || v
== TOK_sigsetjmp
2168 || v
== TOK___sigsetjmp
2171 vpush_helper_func(TOK___bound_setjmp
);
2174 func_bound_add_epilog
= 1;
2176 #if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64
2177 if (v
== TOK_alloca
)
2178 func_bound_add_epilog
= 1;
2181 if (v
== TOK_longjmp
) /* undo rename to __longjmp14 */
2182 sv
->sym
->asm_label
= TOK___bound_longjmp
;
2187 /* Add bounds for local symbols from S to E (via ->prev) */
2188 static void add_local_bounds(Sym
*s
, Sym
*e
)
2190 for (; s
!= e
; s
= s
->prev
) {
2191 if (!s
->v
|| (s
->r
& VT_VALMASK
) != VT_LOCAL
)
2193 /* Add arrays/structs/unions because we always take address */
2194 if ((s
->type
.t
& VT_ARRAY
)
2195 || (s
->type
.t
& VT_BTYPE
) == VT_STRUCT
2196 || s
->a
.addrtaken
) {
2197 /* add local bound info */
2198 int align
, size
= type_size(&s
->type
, &align
);
2199 addr_t
*bounds_ptr
= section_ptr_add(lbounds_section
,
2200 2 * sizeof(addr_t
));
2201 bounds_ptr
[0] = s
->c
;
2202 bounds_ptr
[1] = size
;
2208 /* Wrapper around sym_pop, that potentially also registers local bounds. */
2209 static void pop_local_syms(Sym
*b
, int keep
)
2211 #ifdef CONFIG_TCC_BCHECK
2212 if (tcc_state
->do_bounds_check
&& !keep
&& (local_scope
|| !func_var
))
2213 add_local_bounds(local_stack
, b
);
2216 tcc_add_debug_info (tcc_state
, !local_scope
, local_stack
, b
);
2217 sym_pop(&local_stack
, b
, keep
);
2220 static void incr_bf_adr(int o
)
2222 vtop
->type
= char_pointer_type
;
2226 vtop
->type
.t
= VT_BYTE
| VT_UNSIGNED
;
2230 /* single-byte load mode for packed or otherwise unaligned bitfields */
2231 static void load_packed_bf(CType
*type
, int bit_pos
, int bit_size
)
2234 save_reg_upstack(vtop
->r
, 1);
2235 vpush64(type
->t
& VT_BTYPE
, 0); // B X
2236 bits
= 0, o
= bit_pos
>> 3, bit_pos
&= 7;
2245 vpushi(bit_pos
), gen_op(TOK_SHR
), bit_pos
= 0; // X B Y
2247 vpushi((1 << n
) - 1), gen_op('&');
2250 vpushi(bits
), gen_op(TOK_SHL
);
2253 bits
+= n
, bit_size
-= n
, o
= 1;
2256 if (!(type
->t
& VT_UNSIGNED
)) {
2257 n
= ((type
->t
& VT_BTYPE
) == VT_LLONG
? 64 : 32) - bits
;
2258 vpushi(n
), gen_op(TOK_SHL
);
2259 vpushi(n
), gen_op(TOK_SAR
);
2263 /* single-byte store mode for packed or otherwise unaligned bitfields */
2264 static void store_packed_bf(int bit_pos
, int bit_size
)
2266 int bits
, n
, o
, m
, c
;
2267 c
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
2269 save_reg_upstack(vtop
->r
, 1);
2270 bits
= 0, o
= bit_pos
>> 3, bit_pos
&= 7;
2272 incr_bf_adr(o
); // X B
2274 c
? vdup() : gv_dup(); // B V X
2277 vpushi(bits
), gen_op(TOK_SHR
);
2279 vpushi(bit_pos
), gen_op(TOK_SHL
);
2284 m
= ((1 << n
) - 1) << bit_pos
;
2285 vpushi(m
), gen_op('&'); // X B V1
2286 vpushv(vtop
-1); // X B V1 B
2287 vpushi(m
& 0x80 ? ~m
& 0x7f : ~m
);
2288 gen_op('&'); // X B V1 B1
2289 gen_op('|'); // X B V2
2291 vdup(), vtop
[-1] = vtop
[-2]; // X B B V2
2292 vstore(), vpop(); // X B
2293 bits
+= n
, bit_size
-= n
, bit_pos
= 0, o
= 1;
2298 static int adjust_bf(SValue
*sv
, int bit_pos
, int bit_size
)
2301 if (0 == sv
->type
.ref
)
2303 t
= sv
->type
.ref
->auxtype
;
2304 if (t
!= -1 && t
!= VT_STRUCT
) {
2305 sv
->type
.t
= (sv
->type
.t
& ~(VT_BTYPE
| VT_LONG
)) | t
;
2311 /* store vtop a register belonging to class 'rc'. lvalues are
2312 converted to values. Cannot be used if cannot be converted to
2313 register value (such as structures). */
2314 ST_FUNC
int gv(int rc
)
2316 int r
, r2
, r_ok
, r2_ok
, rc2
, bt
;
2317 int bit_pos
, bit_size
, size
, align
;
2319 /* NOTE: get_reg can modify vstack[] */
2320 if (vtop
->type
.t
& VT_BITFIELD
) {
2323 bit_pos
= BIT_POS(vtop
->type
.t
);
2324 bit_size
= BIT_SIZE(vtop
->type
.t
);
2325 /* remove bit field info to avoid loops */
2326 vtop
->type
.t
&= ~VT_STRUCT_MASK
;
2329 type
.t
= vtop
->type
.t
& VT_UNSIGNED
;
2330 if ((vtop
->type
.t
& VT_BTYPE
) == VT_BOOL
)
2331 type
.t
|= VT_UNSIGNED
;
2333 r
= adjust_bf(vtop
, bit_pos
, bit_size
);
2335 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
)
2340 if (r
== VT_STRUCT
) {
2341 load_packed_bf(&type
, bit_pos
, bit_size
);
2343 int bits
= (type
.t
& VT_BTYPE
) == VT_LLONG
? 64 : 32;
2344 /* cast to int to propagate signedness in following ops */
2346 /* generate shifts */
2347 vpushi(bits
- (bit_pos
+ bit_size
));
2349 vpushi(bits
- bit_size
);
2350 /* NOTE: transformed to SHR if unsigned */
2355 if (is_float(vtop
->type
.t
) &&
2356 (vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
2357 /* CPUs usually cannot use float constants, so we store them
2358 generically in data segment */
2359 init_params p
= { rodata_section
};
2360 unsigned long offset
;
2361 size
= type_size(&vtop
->type
, &align
);
2363 size
= 0, align
= 1;
2364 offset
= section_add(p
.sec
, size
, align
);
2365 vpush_ref(&vtop
->type
, p
.sec
, offset
, size
);
2367 init_putv(&p
, &vtop
->type
, offset
);
2370 #ifdef CONFIG_TCC_BCHECK
2371 if (vtop
->r
& VT_MUSTBOUND
)
2375 bt
= vtop
->type
.t
& VT_BTYPE
;
2377 #ifdef TCC_TARGET_RISCV64
2379 if (bt
== VT_LDOUBLE
&& rc
== RC_FLOAT
)
2382 rc2
= RC2_TYPE(bt
, rc
);
2384 /* need to reload if:
2386 - lvalue (need to dereference pointer)
2387 - already a register, but not in the right class */
2388 r
= vtop
->r
& VT_VALMASK
;
2389 r_ok
= !(vtop
->r
& VT_LVAL
) && (r
< VT_CONST
) && (reg_classes
[r
] & rc
);
2390 r2_ok
= !rc2
|| ((vtop
->r2
< VT_CONST
) && (reg_classes
[vtop
->r2
] & rc2
));
2392 if (!r_ok
|| !r2_ok
) {
2396 int load_type
= (bt
== VT_QFLOAT
) ? VT_DOUBLE
: VT_PTRDIFF_T
;
2397 int original_type
= vtop
->type
.t
;
2399 /* two register type load :
2400 expand to two words temporarily */
2401 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
2403 unsigned long long ll
= vtop
->c
.i
;
2404 vtop
->c
.i
= ll
; /* first word */
2406 vtop
->r
= r
; /* save register value */
2407 vpushi(ll
>> 32); /* second word */
2408 } else if (vtop
->r
& VT_LVAL
) {
2409 /* We do not want to modifier the long long pointer here.
2410 So we save any other instances down the stack */
2411 save_reg_upstack(vtop
->r
, 1);
2412 /* load from memory */
2413 vtop
->type
.t
= load_type
;
2416 vtop
[-1].r
= r
; /* save register value */
2417 /* increment pointer to get second word */
2418 vtop
->type
.t
= VT_PTRDIFF_T
;
2423 vtop
->type
.t
= load_type
;
2425 /* move registers */
2428 if (r2_ok
&& vtop
->r2
< VT_CONST
)
2431 vtop
[-1].r
= r
; /* save register value */
2432 vtop
->r
= vtop
[-1].r2
;
2434 /* Allocate second register. Here we rely on the fact that
2435 get_reg() tries first to free r2 of an SValue. */
2439 /* write second register */
2442 vtop
->type
.t
= original_type
;
2444 if (vtop
->r
== VT_CMP
)
2446 /* one register type load */
2451 #ifdef TCC_TARGET_C67
2452 /* uses register pairs for doubles */
2453 if (bt
== VT_DOUBLE
)
2460 /* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
2461 ST_FUNC
void gv2(int rc1
, int rc2
)
2463 /* generate more generic register first. But VT_JMP or VT_CMP
2464 values must be generated first in all cases to avoid possible
2466 if (vtop
->r
!= VT_CMP
&& rc1
<= rc2
) {
2471 /* test if reload is needed for first register */
2472 if ((vtop
[-1].r
& VT_VALMASK
) >= VT_CONST
) {
2482 /* test if reload is needed for first register */
2483 if ((vtop
[0].r
& VT_VALMASK
) >= VT_CONST
) {
2490 /* expand 64bit on stack in two ints */
2491 ST_FUNC
void lexpand(void)
2494 u
= vtop
->type
.t
& (VT_DEFSIGN
| VT_UNSIGNED
);
2495 v
= vtop
->r
& (VT_VALMASK
| VT_LVAL
);
2496 if (v
== VT_CONST
) {
2499 } else if (v
== (VT_LVAL
|VT_CONST
) || v
== (VT_LVAL
|VT_LOCAL
)) {
2505 vtop
[0].r
= vtop
[-1].r2
;
2506 vtop
[0].r2
= vtop
[-1].r2
= VT_CONST
;
2508 vtop
[0].type
.t
= vtop
[-1].type
.t
= VT_INT
| u
;
2513 /* build a long long from two ints */
2514 static void lbuild(int t
)
2516 gv2(RC_INT
, RC_INT
);
2517 vtop
[-1].r2
= vtop
[0].r
;
2518 vtop
[-1].type
.t
= t
;
2523 /* convert stack entry to register and duplicate its value in another
2525 static void gv_dup(void)
2531 if ((t
& VT_BTYPE
) == VT_LLONG
) {
2532 if (t
& VT_BITFIELD
) {
2542 /* stack: H L L1 H1 */
2552 /* duplicate value */
2562 /* generate CPU independent (unsigned) long long operations */
2563 static void gen_opl(int op
)
2565 int t
, a
, b
, op1
, c
, i
;
2567 unsigned short reg_iret
= REG_IRET
;
2568 unsigned short reg_lret
= REG_IRE2
;
2574 func
= TOK___divdi3
;
2577 func
= TOK___udivdi3
;
2580 func
= TOK___moddi3
;
2583 func
= TOK___umoddi3
;
2590 /* call generic long long function */
2591 vpush_helper_func(func
);
2596 vtop
->r2
= reg_lret
;
2604 //pv("gen_opl A",0,2);
2610 /* stack: L1 H1 L2 H2 */
2615 vtop
[-2] = vtop
[-3];
2618 /* stack: H1 H2 L1 L2 */
2619 //pv("gen_opl B",0,4);
2625 /* stack: H1 H2 L1 L2 ML MH */
2628 /* stack: ML MH H1 H2 L1 L2 */
2632 /* stack: ML MH H1 L2 H2 L1 */
2637 /* stack: ML MH M1 M2 */
2640 } else if (op
== '+' || op
== '-') {
2641 /* XXX: add non carry method too (for MIPS or alpha) */
2647 /* stack: H1 H2 (L1 op L2) */
2650 gen_op(op1
+ 1); /* TOK_xxxC2 */
2653 /* stack: H1 H2 (L1 op L2) */
2656 /* stack: (L1 op L2) H1 H2 */
2658 /* stack: (L1 op L2) (H1 op H2) */
2666 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
2667 t
= vtop
[-1].type
.t
;
2671 /* stack: L H shift */
2673 /* constant: simpler */
2674 /* NOTE: all comments are for SHL. the other cases are
2675 done by swapping words */
2686 if (op
!= TOK_SAR
) {
2719 /* XXX: should provide a faster fallback on x86 ? */
2722 func
= TOK___ashrdi3
;
2725 func
= TOK___lshrdi3
;
2728 func
= TOK___ashldi3
;
2734 /* compare operations */
2740 /* stack: L1 H1 L2 H2 */
2742 vtop
[-1] = vtop
[-2];
2744 /* stack: L1 L2 H1 H2 */
2748 /* when values are equal, we need to compare low words. since
2749 the jump is inverted, we invert the test too. */
2752 else if (op1
== TOK_GT
)
2754 else if (op1
== TOK_ULT
)
2756 else if (op1
== TOK_UGT
)
2766 /* generate non equal test */
2768 vset_VT_CMP(TOK_NE
);
2772 /* compare low. Always unsigned */
2776 else if (op1
== TOK_LE
)
2778 else if (op1
== TOK_GT
)
2780 else if (op1
== TOK_GE
)
2783 #if 0//def TCC_TARGET_I386
2784 if (op
== TOK_NE
) { gsym(b
); break; }
2785 if (op
== TOK_EQ
) { gsym(a
); break; }
2794 static uint64_t gen_opic_sdiv(uint64_t a
, uint64_t b
)
2796 uint64_t x
= (a
>> 63 ? -a
: a
) / (b
>> 63 ? -b
: b
);
2797 return (a
^ b
) >> 63 ? -x
: x
;
2800 static int gen_opic_lt(uint64_t a
, uint64_t b
)
2802 return (a
^ (uint64_t)1 << 63) < (b
^ (uint64_t)1 << 63);
2805 /* handle integer constant optimizations and various machine
2807 static void gen_opic(int op
)
2809 SValue
*v1
= vtop
- 1;
2811 int t1
= v1
->type
.t
& VT_BTYPE
;
2812 int t2
= v2
->type
.t
& VT_BTYPE
;
2813 int c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
2814 int c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
2815 uint64_t l1
= c1
? v1
->c
.i
: 0;
2816 uint64_t l2
= c2
? v2
->c
.i
: 0;
2817 int shm
= (t1
== VT_LLONG
) ? 63 : 31;
2819 if (t1
!= VT_LLONG
&& (PTR_SIZE
!= 8 || t1
!= VT_PTR
))
2820 l1
= ((uint32_t)l1
|
2821 (v1
->type
.t
& VT_UNSIGNED
? 0 : -(l1
& 0x80000000)));
2822 if (t2
!= VT_LLONG
&& (PTR_SIZE
!= 8 || t2
!= VT_PTR
))
2823 l2
= ((uint32_t)l2
|
2824 (v2
->type
.t
& VT_UNSIGNED
? 0 : -(l2
& 0x80000000)));
2828 case '+': l1
+= l2
; break;
2829 case '-': l1
-= l2
; break;
2830 case '&': l1
&= l2
; break;
2831 case '^': l1
^= l2
; break;
2832 case '|': l1
|= l2
; break;
2833 case '*': l1
*= l2
; break;
2840 /* if division by zero, generate explicit division */
2842 if (const_wanted
&& !(nocode_wanted
& unevalmask
))
2843 tcc_error("division by zero in constant");
2847 default: l1
= gen_opic_sdiv(l1
, l2
); break;
2848 case '%': l1
= l1
- l2
* gen_opic_sdiv(l1
, l2
); break;
2849 case TOK_UDIV
: l1
= l1
/ l2
; break;
2850 case TOK_UMOD
: l1
= l1
% l2
; break;
2853 case TOK_SHL
: l1
<<= (l2
& shm
); break;
2854 case TOK_SHR
: l1
>>= (l2
& shm
); break;
2856 l1
= (l1
>> 63) ? ~(~l1
>> (l2
& shm
)) : l1
>> (l2
& shm
);
2859 case TOK_ULT
: l1
= l1
< l2
; break;
2860 case TOK_UGE
: l1
= l1
>= l2
; break;
2861 case TOK_EQ
: l1
= l1
== l2
; break;
2862 case TOK_NE
: l1
= l1
!= l2
; break;
2863 case TOK_ULE
: l1
= l1
<= l2
; break;
2864 case TOK_UGT
: l1
= l1
> l2
; break;
2865 case TOK_LT
: l1
= gen_opic_lt(l1
, l2
); break;
2866 case TOK_GE
: l1
= !gen_opic_lt(l1
, l2
); break;
2867 case TOK_LE
: l1
= !gen_opic_lt(l2
, l1
); break;
2868 case TOK_GT
: l1
= gen_opic_lt(l2
, l1
); break;
2870 case TOK_LAND
: l1
= l1
&& l2
; break;
2871 case TOK_LOR
: l1
= l1
|| l2
; break;
2875 if (t1
!= VT_LLONG
&& (PTR_SIZE
!= 8 || t1
!= VT_PTR
))
2876 l1
= ((uint32_t)l1
|
2877 (v1
->type
.t
& VT_UNSIGNED
? 0 : -(l1
& 0x80000000)));
2881 /* if commutative ops, put c2 as constant */
2882 if (c1
&& (op
== '+' || op
== '&' || op
== '^' ||
2883 op
== '|' || op
== '*' || op
== TOK_EQ
|| op
== TOK_NE
)) {
2885 c2
= c1
; //c = c1, c1 = c2, c2 = c;
2886 l2
= l1
; //l = l1, l1 = l2, l2 = l;
2888 if (!const_wanted
&&
2890 (op
== TOK_SHL
|| op
== TOK_SHR
|| op
== TOK_SAR
)) ||
2891 (l1
== -1 && op
== TOK_SAR
))) {
2892 /* treat (0 << x), (0 >> x) and (-1 >> x) as constant */
2894 } else if (!const_wanted
&&
2895 c2
&& ((l2
== 0 && (op
== '&' || op
== '*')) ||
2897 (l2
== -1 || (l2
== 0xFFFFFFFF && t2
!= VT_LLONG
))) ||
2898 (l2
== 1 && (op
== '%' || op
== TOK_UMOD
)))) {
2899 /* treat (x & 0), (x * 0), (x | -1) and (x % 1) as constant */
2904 } else if (c2
&& (((op
== '*' || op
== '/' || op
== TOK_UDIV
||
2907 ((op
== '+' || op
== '-' || op
== '|' || op
== '^' ||
2908 op
== TOK_SHL
|| op
== TOK_SHR
|| op
== TOK_SAR
) &&
2911 (l2
== -1 || (l2
== 0xFFFFFFFF && t2
!= VT_LLONG
))))) {
2912 /* filter out NOP operations like x*1, x-0, x&-1... */
2914 } else if (c2
&& (op
== '*' || op
== TOK_PDIV
|| op
== TOK_UDIV
)) {
2915 /* try to use shifts instead of muls or divs */
2916 if (l2
> 0 && (l2
& (l2
- 1)) == 0) {
2925 else if (op
== TOK_PDIV
)
2931 } else if (c2
&& (op
== '+' || op
== '-') &&
2932 (((vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == (VT_CONST
| VT_SYM
))
2933 || (vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
)) == VT_LOCAL
)) {
2934 /* symbol + constant case */
2938 /* The backends can't always deal with addends to symbols
2939 larger than +-1<<31. Don't construct such. */
2946 /* call low level op generator */
2947 if (t1
== VT_LLONG
|| t2
== VT_LLONG
||
2948 (PTR_SIZE
== 8 && (t1
== VT_PTR
|| t2
== VT_PTR
)))
2956 #if defined TCC_TARGET_X86_64 || defined TCC_TARGET_I386
2957 # define gen_negf gen_opf
2958 #elif defined TCC_TARGET_ARM
2959 void gen_negf(int op
)
2961 /* arm will detect 0-x and replace by vneg */
2962 vpushi(0), vswap(), gen_op('-');
2965 /* XXX: implement in gen_opf() for other backends too */
2966 void gen_negf(int op
)
2968 /* In IEEE negate(x) isn't subtract(0,x). Without NaNs it's
2969 subtract(-0, x), but with them it's really a sign flip
2970 operation. We implement this with bit manipulation and have
2971 to do some type reinterpretation for this, which TCC can do
2974 int align
, size
, bt
;
2976 size
= type_size(&vtop
->type
, &align
);
2977 bt
= vtop
->type
.t
& VT_BTYPE
;
2978 save_reg(gv(RC_TYPE(bt
)));
2980 incr_bf_adr(size
- 1);
2982 vpushi(0x80); /* flip sign */
2989 /* generate a floating point operation with constant propagation */
2990 static void gen_opif(int op
)
2994 #if defined _MSC_VER && defined __x86_64__
2995 /* avoid bad optimization with f1 -= f2 for f1:-0.0, f2:0.0 */
3005 /* currently, we cannot do computations with forward symbols */
3006 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
3007 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
3009 if (v1
->type
.t
== VT_FLOAT
) {
3012 } else if (v1
->type
.t
== VT_DOUBLE
) {
3019 /* NOTE: we only do constant propagation if finite number (not
3020 NaN or infinity) (ANSI spec) */
3021 if (!(ieee_finite(f1
) || !ieee_finite(f2
)) && !const_wanted
)
3024 case '+': f1
+= f2
; break;
3025 case '-': f1
-= f2
; break;
3026 case '*': f1
*= f2
; break;
3029 union { float f
; unsigned u
; } x1
, x2
, y
;
3030 /* If not in initializer we need to potentially generate
3031 FP exceptions at runtime, otherwise we want to fold. */
3034 /* the run-time result of 0.0/0.0 on x87, also of other compilers
3035 when used to compile the f1 /= f2 below, would be -nan */
3036 x1
.f
= f1
, x2
.f
= f2
;
3038 y
.u
= 0x7fc00000; /* nan */
3040 y
.u
= 0x7f800000; /* infinity */
3041 y
.u
|= (x1
.u
^ x2
.u
) & 0x80000000; /* set sign */
3050 /* XXX: also handles tests ? */
3056 /* XXX: overflow test ? */
3057 if (v1
->type
.t
== VT_FLOAT
) {
3059 } else if (v1
->type
.t
== VT_DOUBLE
) {
3066 if (op
== TOK_NEG
) {
3074 /* print a type. If 'varstr' is not NULL, then the variable is also
3075 printed in the type */
3077 /* XXX: add array and function pointers */
3078 static void type_to_str(char *buf
, int buf_size
,
3079 CType
*type
, const char *varstr
)
3091 pstrcat(buf
, buf_size
, "extern ");
3093 pstrcat(buf
, buf_size
, "static ");
3095 pstrcat(buf
, buf_size
, "typedef ");
3097 pstrcat(buf
, buf_size
, "inline ");
3099 if (t
& VT_VOLATILE
)
3100 pstrcat(buf
, buf_size
, "volatile ");
3101 if (t
& VT_CONSTANT
)
3102 pstrcat(buf
, buf_size
, "const ");
3104 if (((t
& VT_DEFSIGN
) && bt
== VT_BYTE
)
3105 || ((t
& VT_UNSIGNED
)
3106 && (bt
== VT_SHORT
|| bt
== VT_INT
|| bt
== VT_LLONG
)
3109 pstrcat(buf
, buf_size
, (t
& VT_UNSIGNED
) ? "unsigned " : "signed ");
3111 buf_size
-= strlen(buf
);
3147 tstr
= "long double";
3149 pstrcat(buf
, buf_size
, tstr
);
3156 pstrcat(buf
, buf_size
, tstr
);
3157 v
= type
->ref
->v
& ~SYM_STRUCT
;
3158 if (v
>= SYM_FIRST_ANOM
)
3159 pstrcat(buf
, buf_size
, "<anonymous>");
3161 pstrcat(buf
, buf_size
, get_tok_str(v
, NULL
));
3166 if (varstr
&& '*' == *varstr
) {
3167 pstrcat(buf1
, sizeof(buf1
), "(");
3168 pstrcat(buf1
, sizeof(buf1
), varstr
);
3169 pstrcat(buf1
, sizeof(buf1
), ")");
3171 pstrcat(buf1
, buf_size
, "(");
3173 while (sa
!= NULL
) {
3175 type_to_str(buf2
, sizeof(buf2
), &sa
->type
, NULL
);
3176 pstrcat(buf1
, sizeof(buf1
), buf2
);
3179 pstrcat(buf1
, sizeof(buf1
), ", ");
3181 if (s
->f
.func_type
== FUNC_ELLIPSIS
)
3182 pstrcat(buf1
, sizeof(buf1
), ", ...");
3183 pstrcat(buf1
, sizeof(buf1
), ")");
3184 type_to_str(buf
, buf_size
, &s
->type
, buf1
);
3189 if (varstr
&& '*' == *varstr
)
3190 snprintf(buf1
, sizeof(buf1
), "(%s)[%d]", varstr
, s
->c
);
3192 snprintf(buf1
, sizeof(buf1
), "%s[%d]", varstr
? varstr
: "", s
->c
);
3193 type_to_str(buf
, buf_size
, &s
->type
, buf1
);
3196 pstrcpy(buf1
, sizeof(buf1
), "*");
3197 if (t
& VT_CONSTANT
)
3198 pstrcat(buf1
, buf_size
, "const ");
3199 if (t
& VT_VOLATILE
)
3200 pstrcat(buf1
, buf_size
, "volatile ");
3202 pstrcat(buf1
, sizeof(buf1
), varstr
);
3203 type_to_str(buf
, buf_size
, &s
->type
, buf1
);
3207 pstrcat(buf
, buf_size
, " ");
3208 pstrcat(buf
, buf_size
, varstr
);
3213 static void type_incompatibility_error(CType
* st
, CType
* dt
, const char* fmt
)
3215 char buf1
[256], buf2
[256];
3216 type_to_str(buf1
, sizeof(buf1
), st
, NULL
);
3217 type_to_str(buf2
, sizeof(buf2
), dt
, NULL
);
3218 tcc_error(fmt
, buf1
, buf2
);
3221 static void type_incompatibility_warning(CType
* st
, CType
* dt
, const char* fmt
)
3223 char buf1
[256], buf2
[256];
3224 type_to_str(buf1
, sizeof(buf1
), st
, NULL
);
3225 type_to_str(buf2
, sizeof(buf2
), dt
, NULL
);
3226 tcc_warning(fmt
, buf1
, buf2
);
3229 static int pointed_size(CType
*type
)
3232 return type_size(pointed_type(type
), &align
);
3235 static void vla_runtime_pointed_size(CType
*type
)
3238 vla_runtime_type_size(pointed_type(type
), &align
);
3241 static inline int is_null_pointer(SValue
*p
)
3243 if ((p
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
3245 return ((p
->type
.t
& VT_BTYPE
) == VT_INT
&& (uint32_t)p
->c
.i
== 0) ||
3246 ((p
->type
.t
& VT_BTYPE
) == VT_LLONG
&& p
->c
.i
== 0) ||
3247 ((p
->type
.t
& VT_BTYPE
) == VT_PTR
&&
3248 (PTR_SIZE
== 4 ? (uint32_t)p
->c
.i
== 0 : p
->c
.i
== 0) &&
3249 ((pointed_type(&p
->type
)->t
& VT_BTYPE
) == VT_VOID
) &&
3250 0 == (pointed_type(&p
->type
)->t
& (VT_CONSTANT
| VT_VOLATILE
))
3254 /* compare function types. OLD functions match any new functions */
3255 static int is_compatible_func(CType
*type1
, CType
*type2
)
3261 if (s1
->f
.func_call
!= s2
->f
.func_call
)
3263 if (s1
->f
.func_type
!= s2
->f
.func_type
3264 && s1
->f
.func_type
!= FUNC_OLD
3265 && s2
->f
.func_type
!= FUNC_OLD
)
3268 if (!is_compatible_unqualified_types(&s1
->type
, &s2
->type
))
3270 if (s1
->f
.func_type
== FUNC_OLD
|| s2
->f
.func_type
== FUNC_OLD
)
3281 /* return true if type1 and type2 are the same. If unqualified is
3282 true, qualifiers on the types are ignored.
3284 static int compare_types(CType
*type1
, CType
*type2
, int unqualified
)
3288 t1
= type1
->t
& VT_TYPE
;
3289 t2
= type2
->t
& VT_TYPE
;
3291 /* strip qualifiers before comparing */
3292 t1
&= ~(VT_CONSTANT
| VT_VOLATILE
);
3293 t2
&= ~(VT_CONSTANT
| VT_VOLATILE
);
3296 /* Default Vs explicit signedness only matters for char */
3297 if ((t1
& VT_BTYPE
) != VT_BYTE
) {
3301 /* XXX: bitfields ? */
3306 && !(type1
->ref
->c
< 0
3307 || type2
->ref
->c
< 0
3308 || type1
->ref
->c
== type2
->ref
->c
))
3311 /* test more complicated cases */
3312 bt1
= t1
& VT_BTYPE
;
3313 if (bt1
== VT_PTR
) {
3314 type1
= pointed_type(type1
);
3315 type2
= pointed_type(type2
);
3316 return is_compatible_types(type1
, type2
);
3317 } else if (bt1
== VT_STRUCT
) {
3318 return (type1
->ref
== type2
->ref
);
3319 } else if (bt1
== VT_FUNC
) {
3320 return is_compatible_func(type1
, type2
);
3321 } else if (IS_ENUM(type1
->t
) && IS_ENUM(type2
->t
)) {
3322 /* If both are enums then they must be the same, if only one is then
3323 t1 and t2 must be equal, which was checked above already. */
3324 return type1
->ref
== type2
->ref
;
3330 /* Check if OP1 and OP2 can be "combined" with operation OP, the combined
3331 type is stored in DEST if non-null (except for pointer plus/minus) . */
3332 static int combine_types(CType
*dest
, SValue
*op1
, SValue
*op2
, int op
)
3334 CType
*type1
= &op1
->type
, *type2
= &op2
->type
, type
;
3335 int t1
= type1
->t
, t2
= type2
->t
, bt1
= t1
& VT_BTYPE
, bt2
= t2
& VT_BTYPE
;
3341 if (bt1
== VT_VOID
|| bt2
== VT_VOID
) {
3342 ret
= op
== '?' ? 1 : 0;
3343 /* NOTE: as an extension, we accept void on only one side */
3345 } else if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
3346 if (op
== '+') ; /* Handled in caller */
3347 /* http://port70.net/~nsz/c/c99/n1256.html#6.5.15p6 */
3348 /* If one is a null ptr constant the result type is the other. */
3349 else if (is_null_pointer (op2
)) type
= *type1
;
3350 else if (is_null_pointer (op1
)) type
= *type2
;
3351 else if (bt1
!= bt2
) {
3352 /* accept comparison or cond-expr between pointer and integer
3354 if ((op
== '?' || TOK_ISCOND(op
))
3355 && (is_integer_btype(bt1
) || is_integer_btype(bt2
)))
3356 tcc_warning("pointer/integer mismatch in %s",
3357 op
== '?' ? "conditional expression" : "comparison");
3358 else if (op
!= '-' || !is_integer_btype(bt2
))
3360 type
= *(bt1
== VT_PTR
? type1
: type2
);
3362 CType
*pt1
= pointed_type(type1
);
3363 CType
*pt2
= pointed_type(type2
);
3364 int pbt1
= pt1
->t
& VT_BTYPE
;
3365 int pbt2
= pt2
->t
& VT_BTYPE
;
3366 int newquals
, copied
= 0;
3367 if (pbt1
!= VT_VOID
&& pbt2
!= VT_VOID
3368 && !compare_types(pt1
, pt2
, 1/*unqualif*/)) {
3369 if (op
!= '?' && !TOK_ISCOND(op
))
3372 type_incompatibility_warning(type1
, type2
,
3374 ? "pointer type mismatch in conditional expression ('%s' and '%s')"
3375 : "pointer type mismatch in comparison('%s' and '%s')");
3378 /* pointers to void get preferred, otherwise the
3379 pointed to types minus qualifs should be compatible */
3380 type
= *((pbt1
== VT_VOID
) ? type1
: type2
);
3381 /* combine qualifs */
3382 newquals
= ((pt1
->t
| pt2
->t
) & (VT_CONSTANT
| VT_VOLATILE
));
3383 if ((~pointed_type(&type
)->t
& (VT_CONSTANT
| VT_VOLATILE
))
3386 /* copy the pointer target symbol */
3387 type
.ref
= sym_push(SYM_FIELD
, &type
.ref
->type
,
3390 pointed_type(&type
)->t
|= newquals
;
3392 /* pointers to incomplete arrays get converted to
3393 pointers to completed ones if possible */
3394 if (pt1
->t
& VT_ARRAY
3395 && pt2
->t
& VT_ARRAY
3396 && pointed_type(&type
)->ref
->c
< 0
3397 && (pt1
->ref
->c
> 0 || pt2
->ref
->c
> 0))
3400 type
.ref
= sym_push(SYM_FIELD
, &type
.ref
->type
,
3402 pointed_type(&type
)->ref
=
3403 sym_push(SYM_FIELD
, &pointed_type(&type
)->ref
->type
,
3404 0, pointed_type(&type
)->ref
->c
);
3405 pointed_type(&type
)->ref
->c
=
3406 0 < pt1
->ref
->c
? pt1
->ref
->c
: pt2
->ref
->c
;
3412 } else if (bt1
== VT_STRUCT
|| bt2
== VT_STRUCT
) {
3413 if (op
!= '?' || !compare_types(type1
, type2
, 1))
3416 } else if (is_float(bt1
) || is_float(bt2
)) {
3417 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
3418 type
.t
= VT_LDOUBLE
;
3419 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
3424 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
3425 /* cast to biggest op */
3426 type
.t
= VT_LLONG
| VT_LONG
;
3427 if (bt1
== VT_LLONG
)
3429 if (bt2
== VT_LLONG
)
3431 /* convert to unsigned if it does not fit in a long long */
3432 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
| VT_BITFIELD
)) == (VT_LLONG
| VT_UNSIGNED
) ||
3433 (t2
& (VT_BTYPE
| VT_UNSIGNED
| VT_BITFIELD
)) == (VT_LLONG
| VT_UNSIGNED
))
3434 type
.t
|= VT_UNSIGNED
;
3436 /* integer operations */
3437 type
.t
= VT_INT
| (VT_LONG
& (t1
| t2
));
3438 /* convert to unsigned if it does not fit in an integer */
3439 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
| VT_BITFIELD
)) == (VT_INT
| VT_UNSIGNED
) ||
3440 (t2
& (VT_BTYPE
| VT_UNSIGNED
| VT_BITFIELD
)) == (VT_INT
| VT_UNSIGNED
))
3441 type
.t
|= VT_UNSIGNED
;
3448 /* generic gen_op: handles types problems */
3449 ST_FUNC
void gen_op(int op
)
3451 int u
, t1
, t2
, bt1
, bt2
, t
;
3452 CType type1
, combtype
;
3455 t1
= vtop
[-1].type
.t
;
3456 t2
= vtop
[0].type
.t
;
3457 bt1
= t1
& VT_BTYPE
;
3458 bt2
= t2
& VT_BTYPE
;
3460 if (bt1
== VT_FUNC
|| bt2
== VT_FUNC
) {
3461 if (bt2
== VT_FUNC
) {
3462 mk_pointer(&vtop
->type
);
3465 if (bt1
== VT_FUNC
) {
3467 mk_pointer(&vtop
->type
);
3472 } else if (!combine_types(&combtype
, vtop
- 1, vtop
, op
)) {
3473 tcc_error_noabort("invalid operand types for binary operation");
3475 } else if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
3476 /* at least one operand is a pointer */
3477 /* relational op: must be both pointers */
3480 /* if both pointers, then it must be the '-' op */
3481 if (bt1
== VT_PTR
&& bt2
== VT_PTR
) {
3483 tcc_error("cannot use pointers here");
3484 if (vtop
[-1].type
.t
& VT_VLA
) {
3485 vla_runtime_pointed_size(&vtop
[-1].type
);
3487 vpushi(pointed_size(&vtop
[-1].type
));
3491 vtop
->type
.t
= VT_PTRDIFF_T
;
3495 /* exactly one pointer : must be '+' or '-'. */
3496 if (op
!= '-' && op
!= '+')
3497 tcc_error("cannot use pointers here");
3498 /* Put pointer as first operand */
3499 if (bt2
== VT_PTR
) {
3501 t
= t1
, t1
= t2
, t2
= t
;
3504 if ((vtop
[0].type
.t
& VT_BTYPE
) == VT_LLONG
)
3505 /* XXX: truncate here because gen_opl can't handle ptr + long long */
3508 type1
= vtop
[-1].type
;
3509 if (vtop
[-1].type
.t
& VT_VLA
)
3510 vla_runtime_pointed_size(&vtop
[-1].type
);
3512 u
= pointed_size(&vtop
[-1].type
);
3514 tcc_error("unknown array element size");
3518 /* XXX: cast to int ? (long long case) */
3523 #ifdef CONFIG_TCC_BCHECK
3524 if (tcc_state
->do_bounds_check
&& !const_wanted
) {
3525 /* if bounded pointers, we generate a special code to
3532 gen_bounded_ptr_add();
3538 type1
.t
&= ~VT_ARRAY
;
3539 /* put again type if gen_opic() swaped operands */
3543 /* floats can only be used for a few operations */
3544 if (is_float(combtype
.t
)
3545 && op
!= '+' && op
!= '-' && op
!= '*' && op
!= '/'
3547 tcc_error("invalid operands for binary operation");
3548 else if (op
== TOK_SHR
|| op
== TOK_SAR
|| op
== TOK_SHL
) {
3549 t
= bt1
== VT_LLONG
? VT_LLONG
: VT_INT
;
3550 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
| VT_BITFIELD
)) == (t
| VT_UNSIGNED
))
3552 t
|= (VT_LONG
& t1
);
3556 t
= t2
= combtype
.t
;
3557 /* XXX: currently, some unsigned operations are explicit, so
3558 we modify them here */
3559 if (t
& VT_UNSIGNED
) {
3566 else if (op
== TOK_LT
)
3568 else if (op
== TOK_GT
)
3570 else if (op
== TOK_LE
)
3572 else if (op
== TOK_GE
)
3578 /* special case for shifts and long long: we keep the shift as
3580 if (op
== TOK_SHR
|| op
== TOK_SAR
|| op
== TOK_SHL
)
3587 if (TOK_ISCOND(op
)) {
3588 /* relational op: the result is an int */
3589 vtop
->type
.t
= VT_INT
;
3594 // Make sure that we have converted to an rvalue:
3595 if (vtop
->r
& VT_LVAL
)
3596 gv(is_float(vtop
->type
.t
& VT_BTYPE
) ? RC_FLOAT
: RC_INT
);
3599 #if defined TCC_TARGET_ARM64 || defined TCC_TARGET_RISCV64 || defined TCC_TARGET_ARM
3600 #define gen_cvt_itof1 gen_cvt_itof
3602 /* generic itof for unsigned long long case */
3603 static void gen_cvt_itof1(int t
)
3605 if ((vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
)) ==
3606 (VT_LLONG
| VT_UNSIGNED
)) {
3609 vpush_helper_func(TOK___floatundisf
);
3610 #if LDOUBLE_SIZE != 8
3611 else if (t
== VT_LDOUBLE
)
3612 vpush_helper_func(TOK___floatundixf
);
3615 vpush_helper_func(TOK___floatundidf
);
3626 #if defined TCC_TARGET_ARM64 || defined TCC_TARGET_RISCV64
3627 #define gen_cvt_ftoi1 gen_cvt_ftoi
3629 /* generic ftoi for unsigned long long case */
3630 static void gen_cvt_ftoi1(int t
)
3633 if (t
== (VT_LLONG
| VT_UNSIGNED
)) {
3634 /* not handled natively */
3635 st
= vtop
->type
.t
& VT_BTYPE
;
3637 vpush_helper_func(TOK___fixunssfdi
);
3638 #if LDOUBLE_SIZE != 8
3639 else if (st
== VT_LDOUBLE
)
3640 vpush_helper_func(TOK___fixunsxfdi
);
3643 vpush_helper_func(TOK___fixunsdfdi
);
3654 /* special delayed cast for char/short */
3655 static void force_charshort_cast(void)
3657 int sbt
= BFGET(vtop
->r
, VT_MUSTCAST
) == 2 ? VT_LLONG
: VT_INT
;
3658 int dbt
= vtop
->type
.t
;
3659 vtop
->r
&= ~VT_MUSTCAST
;
3661 gen_cast_s(dbt
== VT_BOOL
? VT_BYTE
|VT_UNSIGNED
: dbt
);
3665 static void gen_cast_s(int t
)
3673 /* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
3674 static void gen_cast(CType
*type
)
3676 int sbt
, dbt
, sf
, df
, c
;
3677 int dbt_bt
, sbt_bt
, ds
, ss
, bits
, trunc
;
3679 /* special delayed cast for char/short */
3680 if (vtop
->r
& VT_MUSTCAST
)
3681 force_charshort_cast();
3683 /* bitfields first get cast to ints */
3684 if (vtop
->type
.t
& VT_BITFIELD
)
3687 dbt
= type
->t
& (VT_BTYPE
| VT_UNSIGNED
);
3688 sbt
= vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
);
3696 dbt_bt
= dbt
& VT_BTYPE
;
3697 sbt_bt
= sbt
& VT_BTYPE
;
3698 if (dbt_bt
== VT_VOID
)
3700 if (sbt_bt
== VT_VOID
) {
3702 cast_error(&vtop
->type
, type
);
3705 c
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
3706 #if !defined TCC_IS_NATIVE && !defined TCC_IS_NATIVE_387
3707 c
&= (dbt
!= VT_LDOUBLE
) | !!nocode_wanted
;
3710 /* constant case: we can do it now */
3711 /* XXX: in ISOC, cannot do it if error in convert */
3712 if (sbt
== VT_FLOAT
)
3713 vtop
->c
.ld
= vtop
->c
.f
;
3714 else if (sbt
== VT_DOUBLE
)
3715 vtop
->c
.ld
= vtop
->c
.d
;
3718 if (sbt_bt
== VT_LLONG
) {
3719 if ((sbt
& VT_UNSIGNED
) || !(vtop
->c
.i
>> 63))
3720 vtop
->c
.ld
= vtop
->c
.i
;
3722 vtop
->c
.ld
= -(long double)-vtop
->c
.i
;
3724 if ((sbt
& VT_UNSIGNED
) || !(vtop
->c
.i
>> 31))
3725 vtop
->c
.ld
= (uint32_t)vtop
->c
.i
;
3727 vtop
->c
.ld
= -(long double)-(uint32_t)vtop
->c
.i
;
3730 if (dbt
== VT_FLOAT
)
3731 vtop
->c
.f
= (float)vtop
->c
.ld
;
3732 else if (dbt
== VT_DOUBLE
)
3733 vtop
->c
.d
= (double)vtop
->c
.ld
;
3734 } else if (sf
&& dbt
== VT_BOOL
) {
3735 vtop
->c
.i
= (vtop
->c
.ld
!= 0);
3738 vtop
->c
.i
= vtop
->c
.ld
;
3739 else if (sbt_bt
== VT_LLONG
|| (PTR_SIZE
== 8 && sbt
== VT_PTR
))
3741 else if (sbt
& VT_UNSIGNED
)
3742 vtop
->c
.i
= (uint32_t)vtop
->c
.i
;
3744 vtop
->c
.i
= ((uint32_t)vtop
->c
.i
| -(vtop
->c
.i
& 0x80000000));
3746 if (dbt_bt
== VT_LLONG
|| (PTR_SIZE
== 8 && dbt
== VT_PTR
))
3748 else if (dbt
== VT_BOOL
)
3749 vtop
->c
.i
= (vtop
->c
.i
!= 0);
3751 uint32_t m
= dbt_bt
== VT_BYTE
? 0xff :
3752 dbt_bt
== VT_SHORT
? 0xffff :
3755 if (!(dbt
& VT_UNSIGNED
))
3756 vtop
->c
.i
|= -(vtop
->c
.i
& ((m
>> 1) + 1));
3761 } else if (dbt
== VT_BOOL
3762 && (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
))
3763 == (VT_CONST
| VT_SYM
)) {
3764 /* addresses are considered non-zero (see tcctest.c:sinit23) */
3770 /* cannot generate code for global or static initializers */
3771 if (STATIC_DATA_WANTED
)
3774 /* non constant case: generate code */
3775 if (dbt
== VT_BOOL
) {
3776 gen_test_zero(TOK_NE
);
3782 /* convert from fp to fp */
3785 /* convert int to fp */
3788 /* convert fp to int */
3790 if (dbt_bt
!= VT_LLONG
&& dbt_bt
!= VT_INT
)
3793 goto again
; /* may need char/short cast */
3798 ds
= btype_size(dbt_bt
);
3799 ss
= btype_size(sbt_bt
);
3800 if (ds
== 0 || ss
== 0)
3803 if (IS_ENUM(type
->t
) && type
->ref
->c
< 0)
3804 tcc_error("cast to incomplete type");
3806 /* same size and no sign conversion needed */
3807 if (ds
== ss
&& ds
>= 4)
3809 if (dbt_bt
== VT_PTR
|| sbt_bt
== VT_PTR
) {
3810 tcc_warning("cast between pointer and integer of different size");
3811 if (sbt_bt
== VT_PTR
) {
3812 /* put integer type to allow logical operations below */
3813 vtop
->type
.t
= (PTR_SIZE
== 8 ? VT_LLONG
: VT_INT
);
3817 /* processor allows { int a = 0, b = *(char*)&a; }
3818 That means that if we cast to less width, we can just
3819 change the type and read it still later. */
3820 #define ALLOW_SUBTYPE_ACCESS 1
3822 if (ALLOW_SUBTYPE_ACCESS
&& (vtop
->r
& VT_LVAL
)) {
3823 /* value still in memory */
3827 if (ds
<= 4 && !(dbt
== (VT_SHORT
| VT_UNSIGNED
) && sbt
== VT_BYTE
)) {
3829 goto done
; /* no 64bit envolved */
3837 /* generate high word */
3838 if (sbt
& VT_UNSIGNED
) {
3847 } else if (ss
== 8) {
3848 /* from long long: just take low order word */
3856 /* need to convert from 32bit to 64bit */
3857 if (sbt
& VT_UNSIGNED
) {
3858 #if defined(TCC_TARGET_RISCV64)
3859 /* RISC-V keeps 32bit vals in registers sign-extended.
3860 So here we need a zero-extension. */
3869 ss
= ds
, ds
= 4, dbt
= sbt
;
3870 } else if (ss
== 8) {
3871 /* RISC-V keeps 32bit vals in registers sign-extended.
3872 So here we need a sign-extension for signed types and
3873 zero-extension. for unsigned types. */
3874 #if !defined(TCC_TARGET_RISCV64)
3875 trunc
= 32; /* zero upper 32 bits for non RISC-V targets */
3884 #if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64 || defined TCC_TARGET_ARM64
3890 bits
= (ss
- ds
) * 8;
3891 /* for unsigned, gen_op will convert SAR to SHR */
3892 vtop
->type
.t
= (ss
== 8 ? VT_LLONG
: VT_INT
) | (dbt
& VT_UNSIGNED
);
3895 vpushi(bits
- trunc
);
3902 vtop
->type
.t
&= ~ ( VT_CONSTANT
| VT_VOLATILE
| VT_ARRAY
);
3905 /* return type size as known at compile time. Put alignment at 'a' */
3906 ST_FUNC
int type_size(CType
*type
, int *a
)
3911 bt
= type
->t
& VT_BTYPE
;
3912 if (bt
== VT_STRUCT
) {
3917 } else if (bt
== VT_PTR
) {
3918 if (type
->t
& VT_ARRAY
) {
3922 ts
= type_size(&s
->type
, a
);
3924 if (ts
< 0 && s
->c
< 0)
3932 } else if (IS_ENUM(type
->t
) && type
->ref
->c
< 0) {
3933 return -1; /* incomplete enum */
3934 } else if (bt
== VT_LDOUBLE
) {
3936 return LDOUBLE_SIZE
;
3937 } else if (bt
== VT_DOUBLE
|| bt
== VT_LLONG
) {
3938 #ifdef TCC_TARGET_I386
3939 #ifdef TCC_TARGET_PE
3944 #elif defined(TCC_TARGET_ARM)
3954 } else if (bt
== VT_INT
|| bt
== VT_FLOAT
) {
3957 } else if (bt
== VT_SHORT
) {
3960 } else if (bt
== VT_QLONG
|| bt
== VT_QFLOAT
) {
3964 /* char, void, function, _Bool */
3970 /* push type size as known at runtime time on top of value stack. Put
3972 ST_FUNC
void vla_runtime_type_size(CType
*type
, int *a
)
3974 if (type
->t
& VT_VLA
) {
3975 type_size(&type
->ref
->type
, a
);
3976 vset(&int_type
, VT_LOCAL
|VT_LVAL
, type
->ref
->c
);
3978 vpushi(type_size(type
, a
));
3982 /* return the pointed type of t */
3983 static inline CType
*pointed_type(CType
*type
)
3985 return &type
->ref
->type
;
3988 /* modify type so that its it is a pointer to type. */
3989 ST_FUNC
void mk_pointer(CType
*type
)
3992 s
= sym_push(SYM_FIELD
, type
, 0, -1);
3993 type
->t
= VT_PTR
| (type
->t
& VT_STORAGE
);
3997 /* return true if type1 and type2 are exactly the same (including
4000 static int is_compatible_types(CType
*type1
, CType
*type2
)
4002 return compare_types(type1
,type2
,0);
4005 /* return true if type1 and type2 are the same (ignoring qualifiers).
4007 static int is_compatible_unqualified_types(CType
*type1
, CType
*type2
)
4009 return compare_types(type1
,type2
,1);
4012 static void cast_error(CType
*st
, CType
*dt
)
4014 type_incompatibility_error(st
, dt
, "cannot convert '%s' to '%s'");
4017 /* verify type compatibility to store vtop in 'dt' type */
4018 static void verify_assign_cast(CType
*dt
)
4020 CType
*st
, *type1
, *type2
;
4021 int dbt
, sbt
, qualwarn
, lvl
;
4023 st
= &vtop
->type
; /* source type */
4024 dbt
= dt
->t
& VT_BTYPE
;
4025 sbt
= st
->t
& VT_BTYPE
;
4026 if (dt
->t
& VT_CONSTANT
)
4027 tcc_warning("assignment of read-only location");
4031 tcc_error("assignment to void expression");
4034 /* special cases for pointers */
4035 /* '0' can also be a pointer */
4036 if (is_null_pointer(vtop
))
4038 /* accept implicit pointer to integer cast with warning */
4039 if (is_integer_btype(sbt
)) {
4040 tcc_warning("assignment makes pointer from integer without a cast");
4043 type1
= pointed_type(dt
);
4045 type2
= pointed_type(st
);
4046 else if (sbt
== VT_FUNC
)
4047 type2
= st
; /* a function is implicitly a function pointer */
4050 if (is_compatible_types(type1
, type2
))
4052 for (qualwarn
= lvl
= 0;; ++lvl
) {
4053 if (((type2
->t
& VT_CONSTANT
) && !(type1
->t
& VT_CONSTANT
)) ||
4054 ((type2
->t
& VT_VOLATILE
) && !(type1
->t
& VT_VOLATILE
)))
4056 dbt
= type1
->t
& (VT_BTYPE
|VT_LONG
);
4057 sbt
= type2
->t
& (VT_BTYPE
|VT_LONG
);
4058 if (dbt
!= VT_PTR
|| sbt
!= VT_PTR
)
4060 type1
= pointed_type(type1
);
4061 type2
= pointed_type(type2
);
4063 if (!is_compatible_unqualified_types(type1
, type2
)) {
4064 if ((dbt
== VT_VOID
|| sbt
== VT_VOID
) && lvl
== 0) {
4065 /* void * can match anything */
4066 } else if (dbt
== sbt
4067 && is_integer_btype(sbt
& VT_BTYPE
)
4068 && IS_ENUM(type1
->t
) + IS_ENUM(type2
->t
)
4069 + !!((type1
->t
^ type2
->t
) & VT_UNSIGNED
) < 2) {
4070 /* Like GCC don't warn by default for merely changes
4071 in pointer target signedness. Do warn for different
4072 base types, though, in particular for unsigned enums
4073 and signed int targets. */
4075 tcc_warning("assignment from incompatible pointer type");
4080 tcc_warning_c(warn_discarded_qualifiers
)("assignment discards qualifiers from pointer target type");
4086 if (sbt
== VT_PTR
|| sbt
== VT_FUNC
) {
4087 tcc_warning("assignment makes integer from pointer without a cast");
4088 } else if (sbt
== VT_STRUCT
) {
4089 goto case_VT_STRUCT
;
4091 /* XXX: more tests */
4095 if (!is_compatible_unqualified_types(dt
, st
)) {
4103 static void gen_assign_cast(CType
*dt
)
4105 verify_assign_cast(dt
);
4109 /* store vtop in lvalue pushed on stack */
4110 ST_FUNC
void vstore(void)
4112 int sbt
, dbt
, ft
, r
, size
, align
, bit_size
, bit_pos
, delayed_cast
;
4114 ft
= vtop
[-1].type
.t
;
4115 sbt
= vtop
->type
.t
& VT_BTYPE
;
4116 dbt
= ft
& VT_BTYPE
;
4118 verify_assign_cast(&vtop
[-1].type
);
4120 if (sbt
== VT_STRUCT
) {
4121 /* if structure, only generate pointer */
4122 /* structure assignment : generate memcpy */
4123 /* XXX: optimize if small size */
4124 size
= type_size(&vtop
->type
, &align
);
4128 #ifdef CONFIG_TCC_BCHECK
4129 if (vtop
->r
& VT_MUSTBOUND
)
4130 gbound(); /* check would be wrong after gaddrof() */
4132 vtop
->type
.t
= VT_PTR
;
4135 /* address of memcpy() */
4138 vpush_helper_func(TOK_memmove8
);
4139 else if(!(align
& 3))
4140 vpush_helper_func(TOK_memmove4
);
4143 /* Use memmove, rather than memcpy, as dest and src may be same: */
4144 vpush_helper_func(TOK_memmove
);
4149 #ifdef CONFIG_TCC_BCHECK
4150 if (vtop
->r
& VT_MUSTBOUND
)
4153 vtop
->type
.t
= VT_PTR
;
4158 /* leave source on stack */
4160 } else if (ft
& VT_BITFIELD
) {
4161 /* bitfield store handling */
4163 /* save lvalue as expression result (example: s.b = s.a = n;) */
4164 vdup(), vtop
[-1] = vtop
[-2];
4166 bit_pos
= BIT_POS(ft
);
4167 bit_size
= BIT_SIZE(ft
);
4168 /* remove bit field info to avoid loops */
4169 vtop
[-1].type
.t
= ft
& ~VT_STRUCT_MASK
;
4171 if (dbt
== VT_BOOL
) {
4172 gen_cast(&vtop
[-1].type
);
4173 vtop
[-1].type
.t
= (vtop
[-1].type
.t
& ~VT_BTYPE
) | (VT_BYTE
| VT_UNSIGNED
);
4175 r
= adjust_bf(vtop
- 1, bit_pos
, bit_size
);
4176 if (dbt
!= VT_BOOL
) {
4177 gen_cast(&vtop
[-1].type
);
4178 dbt
= vtop
[-1].type
.t
& VT_BTYPE
;
4180 if (r
== VT_STRUCT
) {
4181 store_packed_bf(bit_pos
, bit_size
);
4183 unsigned long long mask
= (1ULL << bit_size
) - 1;
4184 if (dbt
!= VT_BOOL
) {
4186 if (dbt
== VT_LLONG
)
4189 vpushi((unsigned)mask
);
4196 /* duplicate destination */
4199 /* load destination, mask and or with source */
4200 if (dbt
== VT_LLONG
)
4201 vpushll(~(mask
<< bit_pos
));
4203 vpushi(~((unsigned)mask
<< bit_pos
));
4208 /* ... and discard */
4211 } else if (dbt
== VT_VOID
) {
4214 /* optimize char/short casts */
4216 if ((dbt
== VT_BYTE
|| dbt
== VT_SHORT
)
4217 && is_integer_btype(sbt
)
4219 if ((vtop
->r
& VT_MUSTCAST
)
4220 && btype_size(dbt
) > btype_size(sbt
)
4222 force_charshort_cast();
4225 gen_cast(&vtop
[-1].type
);
4228 #ifdef CONFIG_TCC_BCHECK
4229 /* bound check case */
4230 if (vtop
[-1].r
& VT_MUSTBOUND
) {
4236 gv(RC_TYPE(dbt
)); /* generate value */
4239 vtop
->r
|= BFVAL(VT_MUSTCAST
, (sbt
== VT_LLONG
) + 1);
4240 //tcc_warning("deley cast %x -> %x", sbt, dbt);
4241 vtop
->type
.t
= ft
& VT_TYPE
;
4244 /* if lvalue was saved on stack, must read it */
4245 if ((vtop
[-1].r
& VT_VALMASK
) == VT_LLOCAL
) {
4247 r
= get_reg(RC_INT
);
4248 sv
.type
.t
= VT_PTRDIFF_T
;
4249 sv
.r
= VT_LOCAL
| VT_LVAL
;
4250 sv
.c
.i
= vtop
[-1].c
.i
;
4252 vtop
[-1].r
= r
| VT_LVAL
;
4255 r
= vtop
->r
& VT_VALMASK
;
4256 /* two word case handling :
4257 store second register at word + 4 (or +8 for x86-64) */
4258 if (USING_TWO_WORDS(dbt
)) {
4259 int load_type
= (dbt
== VT_QFLOAT
) ? VT_DOUBLE
: VT_PTRDIFF_T
;
4260 vtop
[-1].type
.t
= load_type
;
4263 /* convert to int to increment easily */
4264 vtop
->type
.t
= VT_PTRDIFF_T
;
4270 vtop
[-1].type
.t
= load_type
;
4271 /* XXX: it works because r2 is spilled last ! */
4272 store(vtop
->r2
, vtop
- 1);
4278 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
4282 /* post defines POST/PRE add. c is the token ++ or -- */
4283 ST_FUNC
void inc(int post
, int c
)
4286 vdup(); /* save lvalue */
4288 gv_dup(); /* duplicate value */
4293 vpushi(c
- TOK_MID
);
4295 vstore(); /* store value */
4297 vpop(); /* if post op, return saved value */
4300 ST_FUNC
void parse_mult_str (CString
*astr
, const char *msg
)
4302 /* read the string */
4306 while (tok
== TOK_STR
) {
4307 /* XXX: add \0 handling too ? */
4308 cstr_cat(astr
, tokc
.str
.data
, -1);
4311 cstr_ccat(astr
, '\0');
4314 /* If I is >= 1 and a power of two, returns log2(i)+1.
4315 If I is 0 returns 0. */
4316 ST_FUNC
int exact_log2p1(int i
)
4321 for (ret
= 1; i
>= 1 << 8; ret
+= 8)
4332 /* Parse __attribute__((...)) GNUC extension. */
4333 static void parse_attribute(AttributeDef
*ad
)
4339 if (tok
!= TOK_ATTRIBUTE1
&& tok
!= TOK_ATTRIBUTE2
)
4344 while (tok
!= ')') {
4345 if (tok
< TOK_IDENT
)
4346 expect("attribute name");
4358 tcc_warning_c(warn_implicit_function_declaration
)(
4359 "implicit declaration of function '%s'", get_tok_str(tok
, &tokc
));
4360 s
= external_global_sym(tok
, &func_old_type
);
4361 } else if ((s
->type
.t
& VT_BTYPE
) != VT_FUNC
)
4362 tcc_error("'%s' is not declared as function", get_tok_str(tok
, &tokc
));
4363 ad
->cleanup_func
= s
;
4368 case TOK_CONSTRUCTOR1
:
4369 case TOK_CONSTRUCTOR2
:
4370 ad
->f
.func_ctor
= 1;
4372 case TOK_DESTRUCTOR1
:
4373 case TOK_DESTRUCTOR2
:
4374 ad
->f
.func_dtor
= 1;
4376 case TOK_ALWAYS_INLINE1
:
4377 case TOK_ALWAYS_INLINE2
:
4378 ad
->f
.func_alwinl
= 1;
4383 parse_mult_str(&astr
, "section name");
4384 ad
->section
= find_section(tcc_state
, (char *)astr
.data
);
4391 parse_mult_str(&astr
, "alias(\"target\")");
4392 ad
->alias_target
= /* save string as token, for later */
4393 tok_alloc((char*)astr
.data
, astr
.size
-1)->tok
;
4397 case TOK_VISIBILITY1
:
4398 case TOK_VISIBILITY2
:
4400 parse_mult_str(&astr
,
4401 "visibility(\"default|hidden|internal|protected\")");
4402 if (!strcmp (astr
.data
, "default"))
4403 ad
->a
.visibility
= STV_DEFAULT
;
4404 else if (!strcmp (astr
.data
, "hidden"))
4405 ad
->a
.visibility
= STV_HIDDEN
;
4406 else if (!strcmp (astr
.data
, "internal"))
4407 ad
->a
.visibility
= STV_INTERNAL
;
4408 else if (!strcmp (astr
.data
, "protected"))
4409 ad
->a
.visibility
= STV_PROTECTED
;
4411 expect("visibility(\"default|hidden|internal|protected\")");
4420 if (n
<= 0 || (n
& (n
- 1)) != 0)
4421 tcc_error("alignment must be a positive power of two");
4426 ad
->a
.aligned
= exact_log2p1(n
);
4427 if (n
!= 1 << (ad
->a
.aligned
- 1))
4428 tcc_error("alignment of %d is larger than implemented", n
);
4440 /* currently, no need to handle it because tcc does not
4441 track unused objects */
4445 ad
->f
.func_noreturn
= 1;
4450 ad
->f
.func_call
= FUNC_CDECL
;
4455 ad
->f
.func_call
= FUNC_STDCALL
;
4457 #ifdef TCC_TARGET_I386
4467 ad
->f
.func_call
= FUNC_FASTCALL1
+ n
- 1;
4473 ad
->f
.func_call
= FUNC_FASTCALLW
;
4480 ad
->attr_mode
= VT_LLONG
+ 1;
4483 ad
->attr_mode
= VT_BYTE
+ 1;
4486 ad
->attr_mode
= VT_SHORT
+ 1;
4490 ad
->attr_mode
= VT_INT
+ 1;
4493 tcc_warning("__mode__(%s) not supported\n", get_tok_str(tok
, NULL
));
4500 ad
->a
.dllexport
= 1;
4502 case TOK_NODECORATE
:
4503 ad
->a
.nodecorate
= 1;
4506 ad
->a
.dllimport
= 1;
4509 tcc_warning_c(warn_unsupported
)("'%s' attribute ignored", get_tok_str(t
, NULL
));
4510 /* skip parameters */
4512 int parenthesis
= 0;
4516 else if (tok
== ')')
4519 } while (parenthesis
&& tok
!= -1);
4532 static Sym
* find_field (CType
*type
, int v
, int *cumofs
)
4536 while ((s
= s
->next
) != NULL
) {
4537 if ((s
->v
& SYM_FIELD
) &&
4538 (s
->type
.t
& VT_BTYPE
) == VT_STRUCT
&&
4539 (s
->v
& ~SYM_FIELD
) >= SYM_FIRST_ANOM
) {
4540 Sym
*ret
= find_field (&s
->type
, v
, cumofs
);
4552 static void check_fields (CType
*type
, int check
)
4556 while ((s
= s
->next
) != NULL
) {
4557 int v
= s
->v
& ~SYM_FIELD
;
4558 if (v
< SYM_FIRST_ANOM
) {
4559 TokenSym
*ts
= table_ident
[v
- TOK_IDENT
];
4560 if (check
&& (ts
->tok
& SYM_FIELD
))
4561 tcc_error("duplicate member '%s'", get_tok_str(v
, NULL
));
4562 ts
->tok
^= SYM_FIELD
;
4563 } else if ((s
->type
.t
& VT_BTYPE
) == VT_STRUCT
)
4564 check_fields (&s
->type
, check
);
4568 static void struct_layout(CType
*type
, AttributeDef
*ad
)
4570 int size
, align
, maxalign
, offset
, c
, bit_pos
, bit_size
;
4571 int packed
, a
, bt
, prevbt
, prev_bit_size
;
4572 int pcc
= !tcc_state
->ms_bitfields
;
4573 int pragma_pack
= *tcc_state
->pack_stack_ptr
;
4580 prevbt
= VT_STRUCT
; /* make it never match */
4585 for (f
= type
->ref
->next
; f
; f
= f
->next
) {
4586 if (f
->type
.t
& VT_BITFIELD
)
4587 bit_size
= BIT_SIZE(f
->type
.t
);
4590 size
= type_size(&f
->type
, &align
);
4591 a
= f
->a
.aligned
? 1 << (f
->a
.aligned
- 1) : 0;
4594 if (pcc
&& bit_size
== 0) {
4595 /* in pcc mode, packing does not affect zero-width bitfields */
4598 /* in pcc mode, attribute packed overrides if set. */
4599 if (pcc
&& (f
->a
.packed
|| ad
->a
.packed
))
4602 /* pragma pack overrides align if lesser and packs bitfields always */
4605 if (pragma_pack
< align
)
4606 align
= pragma_pack
;
4607 /* in pcc mode pragma pack also overrides individual align */
4608 if (pcc
&& pragma_pack
< a
)
4612 /* some individual align was specified */
4616 if (type
->ref
->type
.t
== VT_UNION
) {
4617 if (pcc
&& bit_size
>= 0)
4618 size
= (bit_size
+ 7) >> 3;
4623 } else if (bit_size
< 0) {
4625 c
+= (bit_pos
+ 7) >> 3;
4626 c
= (c
+ align
- 1) & -align
;
4635 /* A bit-field. Layout is more complicated. There are two
4636 options: PCC (GCC) compatible and MS compatible */
4638 /* In PCC layout a bit-field is placed adjacent to the
4639 preceding bit-fields, except if:
4641 - an individual alignment was given
4642 - it would overflow its base type container and
4643 there is no packing */
4644 if (bit_size
== 0) {
4646 c
= (c
+ ((bit_pos
+ 7) >> 3) + align
- 1) & -align
;
4648 } else if (f
->a
.aligned
) {
4650 } else if (!packed
) {
4652 int ofs
= ((c
* 8 + bit_pos
) % a8
+ bit_size
+ a8
- 1) / a8
;
4653 if (ofs
> size
/ align
)
4657 /* in pcc mode, long long bitfields have type int if they fit */
4658 if (size
== 8 && bit_size
<= 32)
4659 f
->type
.t
= (f
->type
.t
& ~VT_BTYPE
) | VT_INT
, size
= 4;
4661 while (bit_pos
>= align
* 8)
4662 c
+= align
, bit_pos
-= align
* 8;
4665 /* In PCC layout named bit-fields influence the alignment
4666 of the containing struct using the base types alignment,
4667 except for packed fields (which here have correct align). */
4668 if (f
->v
& SYM_FIRST_ANOM
4669 // && bit_size // ??? gcc on ARM/rpi does that
4674 bt
= f
->type
.t
& VT_BTYPE
;
4675 if ((bit_pos
+ bit_size
> size
* 8)
4676 || (bit_size
> 0) == (bt
!= prevbt
)
4678 c
= (c
+ align
- 1) & -align
;
4681 /* In MS bitfield mode a bit-field run always uses
4682 at least as many bits as the underlying type.
4683 To start a new run it's also required that this
4684 or the last bit-field had non-zero width. */
4685 if (bit_size
|| prev_bit_size
)
4688 /* In MS layout the records alignment is normally
4689 influenced by the field, except for a zero-width
4690 field at the start of a run (but by further zero-width
4691 fields it is again). */
4692 if (bit_size
== 0 && prevbt
!= bt
)
4695 prev_bit_size
= bit_size
;
4698 f
->type
.t
= (f
->type
.t
& ~(0x3f << VT_STRUCT_SHIFT
))
4699 | (bit_pos
<< VT_STRUCT_SHIFT
);
4700 bit_pos
+= bit_size
;
4702 if (align
> maxalign
)
4706 printf("set field %s offset %-2d size %-2d align %-2d",
4707 get_tok_str(f
->v
& ~SYM_FIELD
, NULL
), offset
, size
, align
);
4708 if (f
->type
.t
& VT_BITFIELD
) {
4709 printf(" pos %-2d bits %-2d",
4722 c
+= (bit_pos
+ 7) >> 3;
4724 /* store size and alignment */
4725 a
= bt
= ad
->a
.aligned
? 1 << (ad
->a
.aligned
- 1) : 1;
4729 if (pragma_pack
&& pragma_pack
< maxalign
&& 0 == pcc
) {
4730 /* can happen if individual align for some member was given. In
4731 this case MSVC ignores maxalign when aligning the size */
4736 c
= (c
+ a
- 1) & -a
;
4740 printf("struct size %-2d align %-2d\n\n", c
, a
), fflush(stdout
);
4743 /* check whether we can access bitfields by their type */
4744 for (f
= type
->ref
->next
; f
; f
= f
->next
) {
4748 if (0 == (f
->type
.t
& VT_BITFIELD
))
4752 bit_size
= BIT_SIZE(f
->type
.t
);
4755 bit_pos
= BIT_POS(f
->type
.t
);
4756 size
= type_size(&f
->type
, &align
);
4758 if (bit_pos
+ bit_size
<= size
* 8 && f
->c
+ size
<= c
4759 #ifdef TCC_TARGET_ARM
4760 && !(f
->c
& (align
- 1))
4765 /* try to access the field using a different type */
4766 c0
= -1, s
= align
= 1;
4769 px
= f
->c
* 8 + bit_pos
;
4770 cx
= (px
>> 3) & -align
;
4771 px
= px
- (cx
<< 3);
4774 s
= (px
+ bit_size
+ 7) >> 3;
4784 s
= type_size(&t
, &align
);
4788 if (px
+ bit_size
<= s
* 8 && cx
+ s
<= c
4789 #ifdef TCC_TARGET_ARM
4790 && !(cx
& (align
- 1))
4793 /* update offset and bit position */
4796 f
->type
.t
= (f
->type
.t
& ~(0x3f << VT_STRUCT_SHIFT
))
4797 | (bit_pos
<< VT_STRUCT_SHIFT
);
4801 printf("FIX field %s offset %-2d size %-2d align %-2d "
4802 "pos %-2d bits %-2d\n",
4803 get_tok_str(f
->v
& ~SYM_FIELD
, NULL
),
4804 cx
, s
, align
, px
, bit_size
);
4807 /* fall back to load/store single-byte wise */
4808 f
->auxtype
= VT_STRUCT
;
4810 printf("FIX field %s : load byte-wise\n",
4811 get_tok_str(f
->v
& ~SYM_FIELD
, NULL
));
4817 /* enum/struct/union declaration. u is VT_ENUM/VT_STRUCT/VT_UNION */
4818 static void struct_decl(CType
*type
, int u
)
4820 int v
, c
, size
, align
, flexible
;
4821 int bit_size
, bsize
, bt
;
4823 AttributeDef ad
, ad1
;
4826 memset(&ad
, 0, sizeof ad
);
4828 parse_attribute(&ad
);
4832 /* struct already defined ? return it */
4834 expect("struct/union/enum name");
4836 if (s
&& (s
->sym_scope
== local_scope
|| tok
!= '{')) {
4839 if (u
== VT_ENUM
&& IS_ENUM(s
->type
.t
))
4841 tcc_error("redefinition of '%s'", get_tok_str(v
, NULL
));
4846 /* Record the original enum/struct/union token. */
4847 type1
.t
= u
== VT_ENUM
? u
| VT_INT
| VT_UNSIGNED
: u
;
4849 /* we put an undefined size for struct/union */
4850 s
= sym_push(v
| SYM_STRUCT
, &type1
, 0, -1);
4851 s
->r
= 0; /* default alignment is zero as gcc */
4853 type
->t
= s
->type
.t
;
4859 tcc_error("struct/union/enum already defined");
4861 /* cannot be empty */
4862 /* non empty enums are not allowed */
4865 long long ll
= 0, pl
= 0, nl
= 0;
4868 /* enum symbols have static storage */
4869 t
.t
= VT_INT
|VT_STATIC
|VT_ENUM_VAL
;
4873 expect("identifier");
4875 if (ss
&& !local_stack
)
4876 tcc_error("redefinition of enumerator '%s'",
4877 get_tok_str(v
, NULL
));
4881 ll
= expr_const64();
4883 ss
= sym_push(v
, &t
, VT_CONST
, 0);
4885 *ps
= ss
, ps
= &ss
->next
;
4894 /* NOTE: we accept a trailing comma */
4899 /* set integral type of the enum */
4902 if (pl
!= (unsigned)pl
)
4903 t
.t
= (LONG_SIZE
==8 ? VT_LLONG
|VT_LONG
: VT_LLONG
);
4905 } else if (pl
!= (int)pl
|| nl
!= (int)nl
)
4906 t
.t
= (LONG_SIZE
==8 ? VT_LLONG
|VT_LONG
: VT_LLONG
);
4907 s
->type
.t
= type
->t
= t
.t
| VT_ENUM
;
4909 /* set type for enum members */
4910 for (ss
= s
->next
; ss
; ss
= ss
->next
) {
4912 if (ll
== (int)ll
) /* default is int if it fits */
4914 if (t
.t
& VT_UNSIGNED
) {
4915 ss
->type
.t
|= VT_UNSIGNED
;
4916 if (ll
== (unsigned)ll
)
4919 ss
->type
.t
= (ss
->type
.t
& ~VT_BTYPE
)
4920 | (LONG_SIZE
==8 ? VT_LLONG
|VT_LONG
: VT_LLONG
);
4925 while (tok
!= '}') {
4926 if (!parse_btype(&btype
, &ad1
)) {
4932 tcc_error("flexible array member '%s' not at the end of struct",
4933 get_tok_str(v
, NULL
));
4939 type_decl(&type1
, &ad1
, &v
, TYPE_DIRECT
);
4941 if ((type1
.t
& VT_BTYPE
) != VT_STRUCT
)
4942 expect("identifier");
4944 int v
= btype
.ref
->v
;
4945 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
4946 if (tcc_state
->ms_extensions
== 0)
4947 expect("identifier");
4951 if (type_size(&type1
, &align
) < 0) {
4952 if ((u
== VT_STRUCT
) && (type1
.t
& VT_ARRAY
) && c
)
4955 tcc_error("field '%s' has incomplete type",
4956 get_tok_str(v
, NULL
));
4958 if ((type1
.t
& VT_BTYPE
) == VT_FUNC
||
4959 (type1
.t
& VT_BTYPE
) == VT_VOID
||
4960 (type1
.t
& VT_STORAGE
))
4961 tcc_error("invalid type for '%s'",
4962 get_tok_str(v
, NULL
));
4966 bit_size
= expr_const();
4967 /* XXX: handle v = 0 case for messages */
4969 tcc_error("negative width in bit-field '%s'",
4970 get_tok_str(v
, NULL
));
4971 if (v
&& bit_size
== 0)
4972 tcc_error("zero width for bit-field '%s'",
4973 get_tok_str(v
, NULL
));
4974 parse_attribute(&ad1
);
4976 size
= type_size(&type1
, &align
);
4977 if (bit_size
>= 0) {
4978 bt
= type1
.t
& VT_BTYPE
;
4984 tcc_error("bitfields must have scalar type");
4986 if (bit_size
> bsize
) {
4987 tcc_error("width of '%s' exceeds its type",
4988 get_tok_str(v
, NULL
));
4989 } else if (bit_size
== bsize
4990 && !ad
.a
.packed
&& !ad1
.a
.packed
) {
4991 /* no need for bit fields */
4993 } else if (bit_size
== 64) {
4994 tcc_error("field width 64 not implemented");
4996 type1
.t
= (type1
.t
& ~VT_STRUCT_MASK
)
4998 | (bit_size
<< (VT_STRUCT_SHIFT
+ 6));
5001 if (v
!= 0 || (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
5002 /* Remember we've seen a real field to check
5003 for placement of flexible array member. */
5006 /* If member is a struct or bit-field, enforce
5007 placing into the struct (as anonymous). */
5009 ((type1
.t
& VT_BTYPE
) == VT_STRUCT
||
5014 ss
= sym_push(v
| SYM_FIELD
, &type1
, 0, 0);
5019 if (tok
== ';' || tok
== TOK_EOF
)
5026 parse_attribute(&ad
);
5027 if (ad
.cleanup_func
) {
5028 tcc_warning("attribute '__cleanup__' ignored on type");
5030 check_fields(type
, 1);
5031 check_fields(type
, 0);
5032 struct_layout(type
, &ad
);
5037 static void sym_to_attr(AttributeDef
*ad
, Sym
*s
)
5039 merge_symattr(&ad
->a
, &s
->a
);
5040 merge_funcattr(&ad
->f
, &s
->f
);
5043 /* Add type qualifiers to a type. If the type is an array then the qualifiers
5044 are added to the element type, copied because it could be a typedef. */
5045 static void parse_btype_qualify(CType
*type
, int qualifiers
)
5047 while (type
->t
& VT_ARRAY
) {
5048 type
->ref
= sym_push(SYM_FIELD
, &type
->ref
->type
, 0, type
->ref
->c
);
5049 type
= &type
->ref
->type
;
5051 type
->t
|= qualifiers
;
5054 /* return 0 if no type declaration. otherwise, return the basic type
5057 static int parse_btype(CType
*type
, AttributeDef
*ad
)
5059 int t
, u
, bt
, st
, type_found
, typespec_found
, g
, n
;
5063 memset(ad
, 0, sizeof(AttributeDef
));
5073 /* currently, we really ignore extension */
5083 if (u
== VT_SHORT
|| u
== VT_LONG
) {
5084 if (st
!= -1 || (bt
!= -1 && bt
!= VT_INT
))
5085 tmbt
: tcc_error("too many basic types");
5088 if (bt
!= -1 || (st
!= -1 && u
!= VT_INT
))
5093 t
= (t
& ~(VT_BTYPE
|VT_LONG
)) | u
;
5110 memset(&ad1
, 0, sizeof(AttributeDef
));
5111 if (parse_btype(&type1
, &ad1
)) {
5112 type_decl(&type1
, &ad1
, &n
, TYPE_ABSTRACT
);
5114 n
= 1 << (ad1
.a
.aligned
- 1);
5116 type_size(&type1
, &n
);
5119 if (n
<= 0 || (n
& (n
- 1)) != 0)
5120 tcc_error("alignment must be a positive power of two");
5123 ad
->a
.aligned
= exact_log2p1(n
);
5127 if ((t
& VT_BTYPE
) == VT_DOUBLE
) {
5128 t
= (t
& ~(VT_BTYPE
|VT_LONG
)) | VT_LDOUBLE
;
5129 } else if ((t
& (VT_BTYPE
|VT_LONG
)) == VT_LONG
) {
5130 t
= (t
& ~(VT_BTYPE
|VT_LONG
)) | VT_LLONG
;
5137 #ifdef TCC_TARGET_ARM64
5139 /* GCC's __uint128_t appears in some Linux header files. Make it a
5140 synonym for long double to get the size and alignment right. */
5151 if ((t
& (VT_BTYPE
|VT_LONG
)) == VT_LONG
) {
5152 t
= (t
& ~(VT_BTYPE
|VT_LONG
)) | VT_LDOUBLE
;
5160 struct_decl(&type1
, VT_ENUM
);
5163 type
->ref
= type1
.ref
;
5166 struct_decl(&type1
, VT_STRUCT
);
5169 struct_decl(&type1
, VT_UNION
);
5172 /* type modifiers */
5176 parse_btype_qualify(type
, VT_ATOMIC
);
5179 parse_expr_type(&type1
);
5180 /* remove all storage modifiers except typedef */
5181 type1
.t
&= ~(VT_STORAGE
&~VT_TYPEDEF
);
5183 sym_to_attr(ad
, type1
.ref
);
5191 parse_btype_qualify(type
, VT_CONSTANT
);
5199 parse_btype_qualify(type
, VT_VOLATILE
);
5206 if ((t
& (VT_DEFSIGN
|VT_UNSIGNED
)) == (VT_DEFSIGN
|VT_UNSIGNED
))
5207 tcc_error("signed and unsigned modifier");
5220 if ((t
& (VT_DEFSIGN
|VT_UNSIGNED
)) == VT_DEFSIGN
)
5221 tcc_error("signed and unsigned modifier");
5222 t
|= VT_DEFSIGN
| VT_UNSIGNED
;
5238 if (t
& (VT_EXTERN
|VT_STATIC
|VT_TYPEDEF
) & ~g
)
5239 tcc_error("multiple storage classes");
5251 ad
->f
.func_noreturn
= 1;
5253 /* GNUC attribute */
5254 case TOK_ATTRIBUTE1
:
5255 case TOK_ATTRIBUTE2
:
5256 parse_attribute(ad
);
5257 if (ad
->attr_mode
) {
5258 u
= ad
->attr_mode
-1;
5259 t
= (t
& ~(VT_BTYPE
|VT_LONG
)) | u
;
5267 parse_expr_type(&type1
);
5268 /* remove all storage modifiers except typedef */
5269 type1
.t
&= ~(VT_STORAGE
&~VT_TYPEDEF
);
5271 sym_to_attr(ad
, type1
.ref
);
5277 if (!s
|| !(s
->type
.t
& VT_TYPEDEF
))
5281 if (tok
== ':' && !in_generic
) {
5282 /* ignore if it's a label */
5287 t
&= ~(VT_BTYPE
|VT_LONG
);
5288 u
= t
& ~(VT_CONSTANT
| VT_VOLATILE
), t
^= u
;
5289 type
->t
= (s
->type
.t
& ~VT_TYPEDEF
) | u
;
5290 type
->ref
= s
->type
.ref
;
5292 parse_btype_qualify(type
, t
);
5294 /* get attributes from typedef */
5303 if (tcc_state
->char_is_unsigned
) {
5304 if ((t
& (VT_DEFSIGN
|VT_BTYPE
)) == VT_BYTE
)
5307 /* VT_LONG is used just as a modifier for VT_INT / VT_LLONG */
5308 bt
= t
& (VT_BTYPE
|VT_LONG
);
5310 t
|= LONG_SIZE
== 8 ? VT_LLONG
: VT_INT
;
5311 #ifdef TCC_USING_DOUBLE_FOR_LDOUBLE
5312 if (bt
== VT_LDOUBLE
)
5313 t
= (t
& ~(VT_BTYPE
|VT_LONG
)) | (VT_DOUBLE
|VT_LONG
);
5319 /* convert a function parameter type (array to pointer and function to
5320 function pointer) */
5321 static inline void convert_parameter_type(CType
*pt
)
5323 /* remove const and volatile qualifiers (XXX: const could be used
5324 to indicate a const function parameter */
5325 pt
->t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
5326 /* array must be transformed to pointer according to ANSI C */
5328 if ((pt
->t
& VT_BTYPE
) == VT_FUNC
) {
5333 ST_FUNC
void parse_asm_str(CString
*astr
)
5336 parse_mult_str(astr
, "string constant");
5339 /* Parse an asm label and return the token */
5340 static int asm_label_instr(void)
5346 parse_asm_str(&astr
);
5349 printf("asm_alias: \"%s\"\n", (char *)astr
.data
);
5351 v
= tok_alloc(astr
.data
, astr
.size
- 1)->tok
;
5356 static int post_type(CType
*type
, AttributeDef
*ad
, int storage
, int td
)
5358 int n
, l
, t1
, arg_size
, align
, unused_align
;
5359 Sym
**plast
, *s
, *first
;
5364 /* function type, or recursive declarator (return if so) */
5366 if (td
&& !(td
& TYPE_ABSTRACT
))
5370 else if (parse_btype(&pt
, &ad1
))
5373 merge_attr (ad
, &ad1
);
5382 /* read param name and compute offset */
5383 if (l
!= FUNC_OLD
) {
5384 if ((pt
.t
& VT_BTYPE
) == VT_VOID
&& tok
== ')')
5386 type_decl(&pt
, &ad1
, &n
, TYPE_DIRECT
| TYPE_ABSTRACT
);
5387 if ((pt
.t
& VT_BTYPE
) == VT_VOID
)
5388 tcc_error("parameter declared as void");
5392 expect("identifier");
5393 pt
.t
= VT_VOID
; /* invalid type */
5397 convert_parameter_type(&pt
);
5398 arg_size
+= (type_size(&pt
, &align
) + PTR_SIZE
- 1) / PTR_SIZE
;
5399 s
= sym_push(n
| SYM_FIELD
, &pt
, 0, 0);
5405 if (l
== FUNC_NEW
&& tok
== TOK_DOTS
) {
5410 if (l
== FUNC_NEW
&& !parse_btype(&pt
, &ad1
))
5411 tcc_error("invalid type");
5414 /* if no parameters, then old type prototype */
5417 /* NOTE: const is ignored in returned type as it has a special
5418 meaning in gcc / C++ */
5419 type
->t
&= ~VT_CONSTANT
;
5420 /* some ancient pre-K&R C allows a function to return an array
5421 and the array brackets to be put after the arguments, such
5422 that "int c()[]" means something like "int[] c()" */
5425 skip(']'); /* only handle simple "[]" */
5428 /* we push a anonymous symbol which will contain the function prototype */
5429 ad
->f
.func_args
= arg_size
;
5430 ad
->f
.func_type
= l
;
5431 s
= sym_push(SYM_FIELD
, type
, 0, 0);
5437 } else if (tok
== '[') {
5438 int saved_nocode_wanted
= nocode_wanted
;
5439 /* array definition */
5442 /* XXX The optional type-quals and static should only be accepted
5443 in parameter decls. The '*' as well, and then even only
5444 in prototypes (not function defs). */
5446 case TOK_RESTRICT1
: case TOK_RESTRICT2
: case TOK_RESTRICT3
:
5461 if (!local_stack
|| (storage
& VT_STATIC
))
5462 vpushi(expr_const());
5464 /* VLAs (which can only happen with local_stack && !VT_STATIC)
5465 length must always be evaluated, even under nocode_wanted,
5466 so that its size slot is initialized (e.g. under sizeof
5471 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
5474 tcc_error("invalid array size");
5476 if (!is_integer_btype(vtop
->type
.t
& VT_BTYPE
))
5477 tcc_error("size of variable length array should be an integer");
5483 /* parse next post type */
5484 post_type(type
, ad
, storage
, 0);
5486 if ((type
->t
& VT_BTYPE
) == VT_FUNC
)
5487 tcc_error("declaration of an array of functions");
5488 if ((type
->t
& VT_BTYPE
) == VT_VOID
5489 || type_size(type
, &unused_align
) < 0)
5490 tcc_error("declaration of an array of incomplete type elements");
5492 t1
|= type
->t
& VT_VLA
;
5496 tcc_error("need explicit inner array size in VLAs");
5497 loc
-= type_size(&int_type
, &align
);
5501 vla_runtime_type_size(type
, &align
);
5503 vset(&int_type
, VT_LOCAL
|VT_LVAL
, n
);
5509 nocode_wanted
= saved_nocode_wanted
;
5511 /* we push an anonymous symbol which will contain the array
5513 s
= sym_push(SYM_FIELD
, type
, 0, n
);
5514 type
->t
= (t1
? VT_VLA
: VT_ARRAY
) | VT_PTR
;
5520 /* Parse a type declarator (except basic type), and return the type
5521 in 'type'. 'td' is a bitmask indicating which kind of type decl is
5522 expected. 'type' should contain the basic type. 'ad' is the
5523 attribute definition of the basic type. It can be modified by
5524 type_decl(). If this (possibly abstract) declarator is a pointer chain
5525 it returns the innermost pointed to type (equals *type, but is a different
5526 pointer), otherwise returns type itself, that's used for recursive calls. */
5527 static CType
*type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
)
5530 int qualifiers
, storage
;
5532 /* recursive type, remove storage bits first, apply them later again */
5533 storage
= type
->t
& VT_STORAGE
;
5534 type
->t
&= ~VT_STORAGE
;
5537 while (tok
== '*') {
5543 qualifiers
|= VT_ATOMIC
;
5548 qualifiers
|= VT_CONSTANT
;
5553 qualifiers
|= VT_VOLATILE
;
5559 /* XXX: clarify attribute handling */
5560 case TOK_ATTRIBUTE1
:
5561 case TOK_ATTRIBUTE2
:
5562 parse_attribute(ad
);
5566 type
->t
|= qualifiers
;
5568 /* innermost pointed to type is the one for the first derivation */
5569 ret
= pointed_type(type
);
5573 /* This is possibly a parameter type list for abstract declarators
5574 ('int ()'), use post_type for testing this. */
5575 if (!post_type(type
, ad
, 0, td
)) {
5576 /* It's not, so it's a nested declarator, and the post operations
5577 apply to the innermost pointed to type (if any). */
5578 /* XXX: this is not correct to modify 'ad' at this point, but
5579 the syntax is not clear */
5580 parse_attribute(ad
);
5581 post
= type_decl(type
, ad
, v
, td
);
5585 } else if (tok
>= TOK_IDENT
&& (td
& TYPE_DIRECT
)) {
5586 /* type identifier */
5591 if (!(td
& TYPE_ABSTRACT
))
5592 expect("identifier");
5595 post_type(post
, ad
, storage
, 0);
5596 parse_attribute(ad
);
5601 /* indirection with full error checking and bound check */
5602 ST_FUNC
void indir(void)
5604 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
) {
5605 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FUNC
)
5609 if (vtop
->r
& VT_LVAL
)
5611 vtop
->type
= *pointed_type(&vtop
->type
);
5612 /* Arrays and functions are never lvalues */
5613 if (!(vtop
->type
.t
& (VT_ARRAY
| VT_VLA
))
5614 && (vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
5616 /* if bound checking, the referenced pointer must be checked */
5617 #ifdef CONFIG_TCC_BCHECK
5618 if (tcc_state
->do_bounds_check
)
5619 vtop
->r
|= VT_MUSTBOUND
;
5624 /* pass a parameter to a function and do type checking and casting */
5625 static void gfunc_param_typed(Sym
*func
, Sym
*arg
)
5630 func_type
= func
->f
.func_type
;
5631 if (func_type
== FUNC_OLD
||
5632 (func_type
== FUNC_ELLIPSIS
&& arg
== NULL
)) {
5633 /* default casting : only need to convert float to double */
5634 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
) {
5635 gen_cast_s(VT_DOUBLE
);
5636 } else if (vtop
->type
.t
& VT_BITFIELD
) {
5637 type
.t
= vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
);
5638 type
.ref
= vtop
->type
.ref
;
5640 } else if (vtop
->r
& VT_MUSTCAST
) {
5641 force_charshort_cast();
5643 } else if (arg
== NULL
) {
5644 tcc_error("too many arguments to function");
5647 type
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
5648 gen_assign_cast(&type
);
5652 /* parse an expression and return its type without any side effect. */
5653 static void expr_type(CType
*type
, void (*expr_fn
)(void))
5662 /* parse an expression of the form '(type)' or '(expr)' and return its
5664 static void parse_expr_type(CType
*type
)
5670 if (parse_btype(type
, &ad
)) {
5671 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
5673 expr_type(type
, gexpr
);
5678 static void parse_type(CType
*type
)
5683 if (!parse_btype(type
, &ad
)) {
5686 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
5689 static void parse_builtin_params(int nc
, const char *args
)
5698 while ((c
= *args
++)) {
5713 type
.t
= VT_CONSTANT
;
5719 type
.t
= VT_CONSTANT
;
5721 type
.t
|= char_type
.t
;
5733 gen_assign_cast(&type
);
5740 static void parse_atomic(int atok
)
5742 int size
, align
, arg
;
5743 CType
*atom
, *atom_ptr
, ct
= {0};
5745 static const char *const templates
[] = {
5747 * Each entry consists of callback and function template.
5748 * The template represents argument types and return type.
5750 * ? void (return-only)
5753 * A read-only atomic
5754 * p pointer to memory
5759 /* keep in order of appearance in tcctok.h: */
5760 /* __atomic_store */ "avm.?",
5761 /* __atomic_load */ "Am.v",
5762 /* __atomic_exchange */ "avm.v",
5763 /* __atomic_compare_exchange */ "apvbmm.b",
5764 /* __atomic_fetch_add */ "avm.v",
5765 /* __atomic_fetch_sub */ "avm.v",
5766 /* __atomic_fetch_or */ "avm.v",
5767 /* __atomic_fetch_xor */ "avm.v",
5768 /* __atomic_fetch_and */ "avm.v"
5770 const char *template = templates
[(atok
- TOK___atomic_store
)];
5772 atom
= atom_ptr
= NULL
;
5773 size
= 0; /* pacify compiler */
5778 switch (template[arg
]) {
5781 atom_ptr
= &vtop
->type
;
5782 if ((atom_ptr
->t
& VT_BTYPE
) != VT_PTR
)
5784 atom
= pointed_type(atom_ptr
);
5785 size
= type_size(atom
, &align
);
5787 || (size
& (size
- 1))
5788 || (atok
> TOK___atomic_compare_exchange
5789 && (0 == btype_size(atom
->t
& VT_BTYPE
)
5790 || (atom
->t
& VT_BTYPE
) == VT_PTR
)))
5791 expect("integral or integer-sized pointer target type");
5792 /* GCC does not care either: */
5793 /* if (!(atom->t & VT_ATOMIC))
5794 tcc_warning("pointer target declaration is missing '_Atomic'"); */
5798 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
5799 || type_size(pointed_type(&vtop
->type
), &align
) != size
)
5800 tcc_error("pointer target type mismatch in argument %d", arg
+ 1);
5801 gen_assign_cast(atom_ptr
);
5804 gen_assign_cast(atom
);
5807 gen_assign_cast(&int_type
);
5811 gen_assign_cast(&ct
);
5814 if ('.' == template[++arg
])
5821 switch (template[arg
+ 1]) {
5830 sprintf(buf
, "%s_%d", get_tok_str(atok
, 0), size
);
5831 vpush_helper_func(tok_alloc_const(buf
));
5836 PUT_R_RET(vtop
, ct
.t
);
5837 if (ct
.t
== VT_BOOL
) {
5839 vtop
->r
|= BFVAL(VT_MUSTCAST
, 1);
5841 vtop
->type
.t
= VT_INT
;
5846 ST_FUNC
void unary(void)
5848 int n
, t
, align
, size
, r
, sizeof_caller
;
5853 /* generate line number info */
5855 tcc_debug_line(tcc_state
), tcc_tcov_check_line (1);
5857 sizeof_caller
= in_sizeof
;
5860 /* XXX: GCC 2.95.3 does not generate a table although it should be
5868 #ifdef TCC_TARGET_PE
5869 t
= VT_SHORT
|VT_UNSIGNED
;
5877 vsetc(&type
, VT_CONST
, &tokc
);
5881 t
= VT_INT
| VT_UNSIGNED
;
5887 t
= VT_LLONG
| VT_UNSIGNED
;
5899 t
= (LONG_SIZE
== 8 ? VT_LLONG
: VT_INT
) | VT_LONG
;
5902 t
= (LONG_SIZE
== 8 ? VT_LLONG
: VT_INT
) | VT_LONG
| VT_UNSIGNED
;
5904 case TOK___FUNCTION__
:
5906 goto tok_identifier
;
5912 /* special function name identifier */
5913 len
= strlen(funcname
) + 1;
5914 /* generate char[len] type */
5915 type
.t
= char_type
.t
;
5916 if (tcc_state
->warn_write_strings
& WARN_ON
)
5917 type
.t
|= VT_CONSTANT
;
5921 sec
= rodata_section
;
5922 vpush_ref(&type
, sec
, sec
->data_offset
, len
);
5924 memcpy(section_ptr_add(sec
, len
), funcname
, len
);
5929 #ifdef TCC_TARGET_PE
5930 t
= VT_SHORT
| VT_UNSIGNED
;
5936 /* string parsing */
5939 if (tcc_state
->warn_write_strings
& WARN_ON
)
5944 memset(&ad
, 0, sizeof(AttributeDef
));
5945 ad
.section
= rodata_section
;
5946 decl_initializer_alloc(&type
, &ad
, VT_CONST
, 2, 0, 0);
5951 if (parse_btype(&type
, &ad
)) {
5952 type_decl(&type
, &ad
, &n
, TYPE_ABSTRACT
);
5954 /* check ISOC99 compound literal */
5956 /* data is allocated locally by default */
5961 /* all except arrays are lvalues */
5962 if (!(type
.t
& VT_ARRAY
))
5964 memset(&ad
, 0, sizeof(AttributeDef
));
5965 decl_initializer_alloc(&type
, &ad
, r
, 1, 0, 0);
5967 if (sizeof_caller
) {
5974 } else if (tok
== '{') {
5975 int saved_nocode_wanted
= nocode_wanted
;
5976 if (const_wanted
&& !(nocode_wanted
& unevalmask
))
5978 if (0 == local_scope
)
5979 tcc_error("statement expression outside of function");
5980 /* save all registers */
5982 /* statement expression : we do not accept break/continue
5983 inside as GCC does. We do retain the nocode_wanted state,
5984 as statement expressions can't ever be entered from the
5985 outside, so any reactivation of code emission (from labels
5986 or loop heads) can be disabled again after the end of it. */
5988 nocode_wanted
= saved_nocode_wanted
;
6003 /* functions names must be treated as function pointers,
6004 except for unary '&' and sizeof. Since we consider that
6005 functions are not lvalues, we only have to handle it
6006 there and in function calls. */
6007 /* arrays can also be used although they are not lvalues */
6008 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
&&
6009 !(vtop
->type
.t
& VT_ARRAY
))
6012 vtop
->sym
->a
.addrtaken
= 1;
6013 mk_pointer(&vtop
->type
);
6019 gen_test_zero(TOK_EQ
);
6030 if ((vtop
->type
.t
& VT_BTYPE
) == VT_PTR
)
6031 tcc_error("pointer not accepted for unary plus");
6032 /* In order to force cast, we add zero, except for floating point
6033 where we really need an noop (otherwise -0.0 will be transformed
6035 if (!is_float(vtop
->type
.t
)) {
6047 expr_type(&type
, unary
); /* Perform a in_sizeof = 0; */
6049 if (vtop
[1].r
& VT_SYM
)
6050 s
= vtop
[1].sym
; /* hack: accessing previous vtop */
6051 size
= type_size(&type
, &align
);
6052 if (s
&& s
->a
.aligned
)
6053 align
= 1 << (s
->a
.aligned
- 1);
6054 if (t
== TOK_SIZEOF
) {
6055 if (!(type
.t
& VT_VLA
)) {
6057 tcc_error("sizeof applied to an incomplete type");
6060 vla_runtime_type_size(&type
, &align
);
6065 vtop
->type
.t
|= VT_UNSIGNED
;
6068 case TOK_builtin_expect
:
6069 /* __builtin_expect is a no-op for now */
6070 parse_builtin_params(0, "ee");
6073 case TOK_builtin_types_compatible_p
:
6074 parse_builtin_params(0, "tt");
6075 vtop
[-1].type
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6076 vtop
[0].type
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6077 n
= is_compatible_types(&vtop
[-1].type
, &vtop
[0].type
);
6081 case TOK_builtin_choose_expr
:
6108 case TOK_builtin_constant_p
:
6109 parse_builtin_params(1, "e");
6110 n
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
&&
6111 !((vtop
->r
& VT_SYM
) && vtop
->sym
->a
.addrtaken
);
6115 case TOK_builtin_frame_address
:
6116 case TOK_builtin_return_address
:
6122 if (tok
!= TOK_CINT
) {
6123 tcc_error("%s only takes positive integers",
6124 tok1
== TOK_builtin_return_address
?
6125 "__builtin_return_address" :
6126 "__builtin_frame_address");
6128 level
= (uint32_t)tokc
.i
;
6133 vset(&type
, VT_LOCAL
, 0); /* local frame */
6135 #ifdef TCC_TARGET_RISCV64
6139 mk_pointer(&vtop
->type
);
6140 indir(); /* -> parent frame */
6142 if (tok1
== TOK_builtin_return_address
) {
6143 // assume return address is just above frame pointer on stack
6144 #ifdef TCC_TARGET_ARM
6147 #elif defined TCC_TARGET_RISCV64
6154 mk_pointer(&vtop
->type
);
6159 #ifdef TCC_TARGET_RISCV64
6160 case TOK_builtin_va_start
:
6161 parse_builtin_params(0, "ee");
6162 r
= vtop
->r
& VT_VALMASK
;
6166 tcc_error("__builtin_va_start expects a local variable");
6171 #ifdef TCC_TARGET_X86_64
6172 #ifdef TCC_TARGET_PE
6173 case TOK_builtin_va_start
:
6174 parse_builtin_params(0, "ee");
6175 r
= vtop
->r
& VT_VALMASK
;
6179 tcc_error("__builtin_va_start expects a local variable");
6181 vtop
->type
= char_pointer_type
;
6186 case TOK_builtin_va_arg_types
:
6187 parse_builtin_params(0, "t");
6188 vpushi(classify_x86_64_va_arg(&vtop
->type
));
6195 #ifdef TCC_TARGET_ARM64
6196 case TOK_builtin_va_start
: {
6197 parse_builtin_params(0, "ee");
6201 vtop
->type
.t
= VT_VOID
;
6204 case TOK_builtin_va_arg
: {
6205 parse_builtin_params(0, "et");
6213 case TOK___arm64_clear_cache
: {
6214 parse_builtin_params(0, "ee");
6217 vtop
->type
.t
= VT_VOID
;
6222 /* atomic operations */
6223 case TOK___atomic_store
:
6224 case TOK___atomic_load
:
6225 case TOK___atomic_exchange
:
6226 case TOK___atomic_compare_exchange
:
6227 case TOK___atomic_fetch_add
:
6228 case TOK___atomic_fetch_sub
:
6229 case TOK___atomic_fetch_or
:
6230 case TOK___atomic_fetch_xor
:
6231 case TOK___atomic_fetch_and
:
6235 /* pre operations */
6246 if (is_float(vtop
->type
.t
)) {
6256 goto tok_identifier
;
6258 /* allow to take the address of a label */
6259 if (tok
< TOK_UIDENT
)
6260 expect("label identifier");
6261 s
= label_find(tok
);
6263 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
6265 if (s
->r
== LABEL_DECLARED
)
6266 s
->r
= LABEL_FORWARD
;
6269 s
->type
.t
= VT_VOID
;
6270 mk_pointer(&s
->type
);
6271 s
->type
.t
|= VT_STATIC
;
6273 vpushsym(&s
->type
, s
);
6279 CType controlling_type
;
6280 int has_default
= 0;
6283 TokenString
*str
= NULL
;
6284 int saved_const_wanted
= const_wanted
;
6289 expr_type(&controlling_type
, expr_eq
);
6290 controlling_type
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
| VT_ARRAY
);
6291 if ((controlling_type
.t
& VT_BTYPE
) == VT_FUNC
)
6292 mk_pointer(&controlling_type
);
6293 const_wanted
= saved_const_wanted
;
6297 if (tok
== TOK_DEFAULT
) {
6299 tcc_error("too many 'default'");
6305 AttributeDef ad_tmp
;
6310 parse_btype(&cur_type
, &ad_tmp
);
6313 type_decl(&cur_type
, &ad_tmp
, &itmp
, TYPE_ABSTRACT
);
6314 if (compare_types(&controlling_type
, &cur_type
, 0)) {
6316 tcc_error("type match twice");
6326 skip_or_save_block(&str
);
6328 skip_or_save_block(NULL
);
6335 type_to_str(buf
, sizeof buf
, &controlling_type
, NULL
);
6336 tcc_error("type '%s' does not match any association", buf
);
6338 begin_macro(str
, 1);
6347 // special qnan , snan and infinity values
6352 vtop
->type
.t
= VT_FLOAT
;
6357 goto special_math_val
;
6360 goto special_math_val
;
6367 expect("identifier");
6369 if (!s
|| IS_ASM_SYM(s
)) {
6370 const char *name
= get_tok_str(t
, NULL
);
6372 tcc_error("'%s' undeclared", name
);
6373 /* for simple function calls, we tolerate undeclared
6374 external reference to int() function */
6375 tcc_warning_c(warn_implicit_function_declaration
)(
6376 "implicit declaration of function '%s'", name
);
6377 s
= external_global_sym(t
, &func_old_type
);
6381 /* A symbol that has a register is a local register variable,
6382 which starts out as VT_LOCAL value. */
6383 if ((r
& VT_VALMASK
) < VT_CONST
)
6384 r
= (r
& ~VT_VALMASK
) | VT_LOCAL
;
6386 vset(&s
->type
, r
, s
->c
);
6387 /* Point to s as backpointer (even without r&VT_SYM).
6388 Will be used by at least the x86 inline asm parser for
6394 } else if (r
== VT_CONST
&& IS_ENUM_VAL(s
->type
.t
)) {
6395 vtop
->c
.i
= s
->enum_val
;
6400 /* post operations */
6402 if (tok
== TOK_INC
|| tok
== TOK_DEC
) {
6405 } else if (tok
== '.' || tok
== TOK_ARROW
|| tok
== TOK_CDOUBLE
) {
6406 int qualifiers
, cumofs
= 0;
6408 if (tok
== TOK_ARROW
)
6410 qualifiers
= vtop
->type
.t
& (VT_CONSTANT
| VT_VOLATILE
);
6413 /* expect pointer on structure */
6414 if ((vtop
->type
.t
& VT_BTYPE
) != VT_STRUCT
)
6415 expect("struct or union");
6416 if (tok
== TOK_CDOUBLE
)
6417 expect("field name");
6419 if (tok
== TOK_CINT
|| tok
== TOK_CUINT
)
6420 expect("field name");
6421 s
= find_field(&vtop
->type
, tok
, &cumofs
);
6423 tcc_error("field not found: %s", get_tok_str(tok
& ~SYM_FIELD
, &tokc
));
6424 /* add field offset to pointer */
6425 vtop
->type
= char_pointer_type
; /* change type to 'char *' */
6426 vpushi(cumofs
+ s
->c
);
6428 /* change type to field type, and set to lvalue */
6429 vtop
->type
= s
->type
;
6430 vtop
->type
.t
|= qualifiers
;
6431 /* an array is never an lvalue */
6432 if (!(vtop
->type
.t
& VT_ARRAY
)) {
6434 #ifdef CONFIG_TCC_BCHECK
6435 /* if bound checking, the referenced pointer must be checked */
6436 if (tcc_state
->do_bounds_check
)
6437 vtop
->r
|= VT_MUSTBOUND
;
6441 } else if (tok
== '[') {
6447 } else if (tok
== '(') {
6450 int nb_args
, ret_nregs
, ret_align
, regsize
, variadic
;
6453 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
6454 /* pointer test (no array accepted) */
6455 if ((vtop
->type
.t
& (VT_BTYPE
| VT_ARRAY
)) == VT_PTR
) {
6456 vtop
->type
= *pointed_type(&vtop
->type
);
6457 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
)
6461 expect("function pointer");
6464 vtop
->r
&= ~VT_LVAL
; /* no lvalue */
6466 /* get return type */
6469 sa
= s
->next
; /* first parameter */
6470 nb_args
= regsize
= 0;
6472 /* compute first implicit argument if a structure is returned */
6473 if ((s
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
6474 variadic
= (s
->f
.func_type
== FUNC_ELLIPSIS
);
6475 ret_nregs
= gfunc_sret(&s
->type
, variadic
, &ret
.type
,
6476 &ret_align
, ®size
);
6477 if (ret_nregs
<= 0) {
6478 /* get some space for the returned structure */
6479 size
= type_size(&s
->type
, &align
);
6480 #ifdef TCC_TARGET_ARM64
6481 /* On arm64, a small struct is return in registers.
6482 It is much easier to write it to memory if we know
6483 that we are allowed to write some extra bytes, so
6484 round the allocated space up to a power of 2: */
6486 while (size
& (size
- 1))
6487 size
= (size
| (size
- 1)) + 1;
6489 loc
= (loc
- size
) & -align
;
6491 ret
.r
= VT_LOCAL
| VT_LVAL
;
6492 /* pass it as 'int' to avoid structure arg passing
6494 vseti(VT_LOCAL
, loc
);
6495 #ifdef CONFIG_TCC_BCHECK
6496 if (tcc_state
->do_bounds_check
)
6510 if (ret_nregs
> 0) {
6511 /* return in register */
6513 PUT_R_RET(&ret
, ret
.type
.t
);
6518 gfunc_param_typed(s
, sa
);
6528 tcc_error("too few arguments to function");
6530 gfunc_call(nb_args
);
6532 if (ret_nregs
< 0) {
6533 vsetc(&ret
.type
, ret
.r
, &ret
.c
);
6534 #ifdef TCC_TARGET_RISCV64
6535 arch_transfer_ret_regs(1);
6539 for (r
= ret
.r
+ ret_nregs
+ !ret_nregs
; r
-- > ret
.r
;) {
6540 vsetc(&ret
.type
, r
, &ret
.c
);
6541 vtop
->r2
= ret
.r2
; /* Loop only happens when r2 is VT_CONST */
6544 /* handle packed struct return */
6545 if (((s
->type
.t
& VT_BTYPE
) == VT_STRUCT
) && ret_nregs
) {
6548 size
= type_size(&s
->type
, &align
);
6549 /* We're writing whole regs often, make sure there's enough
6550 space. Assume register size is power of 2. */
6551 if (regsize
> align
)
6553 loc
= (loc
- size
) & -align
;
6557 vset(&ret
.type
, VT_LOCAL
| VT_LVAL
, addr
+ offset
);
6561 if (--ret_nregs
== 0)
6565 vset(&s
->type
, VT_LOCAL
| VT_LVAL
, addr
);
6568 /* Promote char/short return values. This is matters only
6569 for calling function that were not compiled by TCC and
6570 only on some architectures. For those where it doesn't
6571 matter we expect things to be already promoted to int,
6573 t
= s
->type
.t
& VT_BTYPE
;
6574 if (t
== VT_BYTE
|| t
== VT_SHORT
|| t
== VT_BOOL
) {
6576 vtop
->r
|= BFVAL(VT_MUSTCAST
, 1);
6578 vtop
->type
.t
= VT_INT
;
6582 if (s
->f
.func_noreturn
) {
6584 tcc_tcov_block_end (tcov_data
.line
);
6593 #ifndef precedence_parser /* original top-down parser */
6595 static void expr_prod(void)
6600 while ((t
= tok
) == '*' || t
== '/' || t
== '%') {
6607 static void expr_sum(void)
6612 while ((t
= tok
) == '+' || t
== '-') {
6619 static void expr_shift(void)
6624 while ((t
= tok
) == TOK_SHL
|| t
== TOK_SAR
) {
6631 static void expr_cmp(void)
6636 while (((t
= tok
) >= TOK_ULE
&& t
<= TOK_GT
) ||
6637 t
== TOK_ULT
|| t
== TOK_UGE
) {
6644 static void expr_cmpeq(void)
6649 while ((t
= tok
) == TOK_EQ
|| t
== TOK_NE
) {
6656 static void expr_and(void)
6659 while (tok
== '&') {
6666 static void expr_xor(void)
6669 while (tok
== '^') {
6676 static void expr_or(void)
6679 while (tok
== '|') {
6686 static void expr_landor(int op
);
6688 static void expr_land(void)
6691 if (tok
== TOK_LAND
)
6695 static void expr_lor(void)
6702 # define expr_landor_next(op) op == TOK_LAND ? expr_or() : expr_land()
6703 #else /* defined precedence_parser */
6704 # define expr_landor_next(op) unary(), expr_infix(precedence(op) + 1)
6705 # define expr_lor() unary(), expr_infix(1)
6707 static int precedence(int tok
)
6710 case TOK_LOR
: return 1;
6711 case TOK_LAND
: return 2;
6715 case TOK_EQ
: case TOK_NE
: return 6;
6716 relat
: case TOK_ULT
: case TOK_UGE
: return 7;
6717 case TOK_SHL
: case TOK_SAR
: return 8;
6718 case '+': case '-': return 9;
6719 case '*': case '/': case '%': return 10;
6721 if (tok
>= TOK_ULE
&& tok
<= TOK_GT
)
6726 static unsigned char prec
[256];
6727 static void init_prec(void)
6730 for (i
= 0; i
< 256; i
++)
6731 prec
[i
] = precedence(i
);
6733 #define precedence(i) ((unsigned)i < 256 ? prec[i] : 0)
6735 static void expr_landor(int op
);
6737 static void expr_infix(int p
)
6740 while ((p2
= precedence(t
)) >= p
) {
6741 if (t
== TOK_LOR
|| t
== TOK_LAND
) {
6746 if (precedence(tok
) > p2
)
6755 /* Assuming vtop is a value used in a conditional context
6756 (i.e. compared with zero) return 0 if it's false, 1 if
6757 true and -1 if it can't be statically determined. */
6758 static int condition_3way(void)
6761 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
&&
6762 (!(vtop
->r
& VT_SYM
) || !vtop
->sym
->a
.weak
)) {
6764 gen_cast_s(VT_BOOL
);
6771 static void expr_landor(int op
)
6773 int t
= 0, cc
= 1, f
= 0, i
= op
== TOK_LAND
, c
;
6775 c
= f
? i
: condition_3way();
6777 save_regs(1), cc
= 0;
6779 nocode_wanted
++, f
= 1;
6787 expr_landor_next(op
);
6799 static int is_cond_bool(SValue
*sv
)
6801 if ((sv
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
6802 && (sv
->type
.t
& VT_BTYPE
) == VT_INT
)
6803 return (unsigned)sv
->c
.i
< 2;
6804 if (sv
->r
== VT_CMP
)
6809 static void expr_cond(void)
6811 int tt
, u
, r1
, r2
, rc
, t1
, t2
, islv
, c
, g
;
6819 c
= condition_3way();
6820 g
= (tok
== ':' && gnu_ext
);
6830 /* needed to avoid having different registers saved in
6837 ncw_prev
= nocode_wanted
;
6843 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FUNC
)
6844 mk_pointer(&vtop
->type
);
6845 sv
= *vtop
; /* save value to handle it later */
6846 vtop
--; /* no vpop so that FP stack is not flushed */
6856 nocode_wanted
= ncw_prev
;
6862 if (c
< 0 && is_cond_bool(vtop
) && is_cond_bool(&sv
)) {
6863 /* optimize "if (f ? a > b : c || d) ..." for example, where normally
6864 "a < b" and "c || d" would be forced to "(int)0/1" first, whereas
6865 this code jumps directly to the if's then/else branches. */
6870 /* combine jump targets of 2nd op with VT_CMP of 1st op */
6873 nocode_wanted
= ncw_prev
;
6874 // tcc_warning("two conditions expr_cond");
6878 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FUNC
)
6879 mk_pointer(&vtop
->type
);
6881 /* cast operands to correct type according to ISOC rules */
6882 if (!combine_types(&type
, &sv
, vtop
, '?'))
6883 type_incompatibility_error(&sv
.type
, &vtop
->type
,
6884 "type mismatch in conditional expression (have '%s' and '%s')");
6885 /* keep structs lvalue by transforming `(expr ? a : b)` to `*(expr ? &a : &b)` so
6886 that `(expr ? a : b).mem` does not error with "lvalue expected" */
6887 islv
= (vtop
->r
& VT_LVAL
) && (sv
.r
& VT_LVAL
) && VT_STRUCT
== (type
.t
& VT_BTYPE
);
6889 /* now we convert second operand */
6893 mk_pointer(&vtop
->type
);
6895 } else if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
6899 rc
= RC_TYPE(type
.t
);
6900 /* for long longs, we use fixed registers to avoid having
6901 to handle a complicated move */
6902 if (USING_TWO_WORDS(type
.t
))
6903 rc
= RC_RET(type
.t
);
6911 nocode_wanted
= ncw_prev
;
6913 /* this is horrible, but we must also convert first
6919 mk_pointer(&vtop
->type
);
6921 } else if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
6927 move_reg(r2
, r1
, islv
? VT_PTR
: type
.t
);
6937 static void expr_eq(void)
6942 if ((t
= tok
) == '=' || TOK_ASSIGN(t
)) {
6950 gen_op(TOK_ASSIGN_OP(t
));
6956 ST_FUNC
void gexpr(void)
6967 /* parse a constant expression and return value in vtop. */
6968 static void expr_const1(void)
6971 nocode_wanted
+= unevalmask
+ 1;
6973 nocode_wanted
-= unevalmask
+ 1;
6977 /* parse an integer constant and return its value. */
6978 static inline int64_t expr_const64(void)
6982 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
6983 expect("constant expression");
6989 /* parse an integer constant and return its value.
6990 Complain if it doesn't fit 32bit (signed or unsigned). */
6991 ST_FUNC
int expr_const(void)
6994 int64_t wc
= expr_const64();
6996 if (c
!= wc
&& (unsigned)c
!= wc
)
6997 tcc_error("constant exceeds 32 bit");
7001 /* ------------------------------------------------------------------------- */
7002 /* return from function */
7004 #ifndef TCC_TARGET_ARM64
7005 static void gfunc_return(CType
*func_type
)
7007 if ((func_type
->t
& VT_BTYPE
) == VT_STRUCT
) {
7008 CType type
, ret_type
;
7009 int ret_align
, ret_nregs
, regsize
;
7010 ret_nregs
= gfunc_sret(func_type
, func_var
, &ret_type
,
7011 &ret_align
, ®size
);
7012 if (ret_nregs
< 0) {
7013 #ifdef TCC_TARGET_RISCV64
7014 arch_transfer_ret_regs(0);
7016 } else if (0 == ret_nregs
) {
7017 /* if returning structure, must copy it to implicit
7018 first pointer arg location */
7021 vset(&type
, VT_LOCAL
| VT_LVAL
, func_vc
);
7024 /* copy structure value to pointer */
7027 /* returning structure packed into registers */
7028 int size
, addr
, align
, rc
;
7029 size
= type_size(func_type
,&align
);
7030 if ((vtop
->r
!= (VT_LOCAL
| VT_LVAL
) ||
7031 (vtop
->c
.i
& (ret_align
-1)))
7032 && (align
& (ret_align
-1))) {
7033 loc
= (loc
- size
) & -ret_align
;
7036 vset(&type
, VT_LOCAL
| VT_LVAL
, addr
);
7040 vset(&ret_type
, VT_LOCAL
| VT_LVAL
, addr
);
7042 vtop
->type
= ret_type
;
7043 rc
= RC_RET(ret_type
.t
);
7051 if (--ret_nregs
== 0)
7053 /* We assume that when a structure is returned in multiple
7054 registers, their classes are consecutive values of the
7057 vtop
->c
.i
+= regsize
;
7062 gv(RC_RET(func_type
->t
));
7064 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
7068 static void check_func_return(void)
7070 if ((func_vt
.t
& VT_BTYPE
) == VT_VOID
)
7072 if (!strcmp (funcname
, "main")
7073 && (func_vt
.t
& VT_BTYPE
) == VT_INT
) {
7074 /* main returns 0 by default */
7076 gen_assign_cast(&func_vt
);
7077 gfunc_return(&func_vt
);
7079 tcc_warning("function might return no value: '%s'", funcname
);
7083 /* ------------------------------------------------------------------------- */
7086 static int case_cmpi(const void *pa
, const void *pb
)
7088 int64_t a
= (*(struct case_t
**) pa
)->v1
;
7089 int64_t b
= (*(struct case_t
**) pb
)->v1
;
7090 return a
< b
? -1 : a
> b
;
7093 static int case_cmpu(const void *pa
, const void *pb
)
7095 uint64_t a
= (uint64_t)(*(struct case_t
**) pa
)->v1
;
7096 uint64_t b
= (uint64_t)(*(struct case_t
**) pb
)->v1
;
7097 return a
< b
? -1 : a
> b
;
7100 static void gtst_addr(int t
, int a
)
7102 gsym_addr(gvtst(0, t
), a
);
7105 static void gcase(struct case_t
**base
, int len
, int *bsym
)
7109 int ll
= (vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
;
7126 gtst_addr(0, p
->sym
); /* v1 <= x <= v2 */
7128 gcase(base
, len
/2, bsym
);
7132 base
+= e
; len
-= e
;
7142 if (p
->v1
== p
->v2
) {
7144 gtst_addr(0, p
->sym
);
7154 gtst_addr(0, p
->sym
);
7158 *bsym
= gjmp(*bsym
);
7161 /* ------------------------------------------------------------------------- */
7162 /* __attribute__((cleanup(fn))) */
7164 static void try_call_scope_cleanup(Sym
*stop
)
7166 Sym
*cls
= cur_scope
->cl
.s
;
7168 for (; cls
!= stop
; cls
= cls
->ncl
) {
7169 Sym
*fs
= cls
->next
;
7170 Sym
*vs
= cls
->prev_tok
;
7172 vpushsym(&fs
->type
, fs
);
7173 vset(&vs
->type
, vs
->r
, vs
->c
);
7175 mk_pointer(&vtop
->type
);
7181 static void try_call_cleanup_goto(Sym
*cleanupstate
)
7186 if (!cur_scope
->cl
.s
)
7189 /* search NCA of both cleanup chains given parents and initial depth */
7190 ocd
= cleanupstate
? cleanupstate
->v
& ~SYM_FIELD
: 0;
7191 for (ccd
= cur_scope
->cl
.n
, oc
= cleanupstate
; ocd
> ccd
; --ocd
, oc
= oc
->ncl
)
7193 for (cc
= cur_scope
->cl
.s
; ccd
> ocd
; --ccd
, cc
= cc
->ncl
)
7195 for (; cc
!= oc
; cc
= cc
->ncl
, oc
= oc
->ncl
, --ccd
)
7198 try_call_scope_cleanup(cc
);
7201 /* call 'func' for each __attribute__((cleanup(func))) */
7202 static void block_cleanup(struct scope
*o
)
7206 for (pg
= &pending_gotos
; (g
= *pg
) && g
->c
> o
->cl
.n
;) {
7207 if (g
->prev_tok
->r
& LABEL_FORWARD
) {
7212 try_call_scope_cleanup(o
->cl
.s
);
7213 pcl
->jnext
= gjmp(0);
7215 goto remove_pending
;
7225 try_call_scope_cleanup(o
->cl
.s
);
7228 /* ------------------------------------------------------------------------- */
7231 static void vla_restore(int loc
)
7234 gen_vla_sp_restore(loc
);
7237 static void vla_leave(struct scope
*o
)
7239 struct scope
*c
= cur_scope
, *v
= NULL
;
7240 for (; c
!= o
&& c
; c
= c
->prev
)
7244 vla_restore(v
->vla
.locorig
);
7247 /* ------------------------------------------------------------------------- */
7250 void new_scope(struct scope
*o
)
7252 /* copy and link previous scope */
7254 o
->prev
= cur_scope
;
7256 cur_scope
->vla
.num
= 0;
7258 /* record local declaration stack position */
7259 o
->lstk
= local_stack
;
7260 o
->llstk
= local_label_stack
;
7264 tcc_debug_stabn(tcc_state
, N_LBRAC
, ind
- func_ind
);
7267 void prev_scope(struct scope
*o
, int is_expr
)
7271 if (o
->cl
.s
!= o
->prev
->cl
.s
)
7272 block_cleanup(o
->prev
);
7274 /* pop locally defined labels */
7275 label_pop(&local_label_stack
, o
->llstk
, is_expr
);
7277 /* In the is_expr case (a statement expression is finished here),
7278 vtop might refer to symbols on the local_stack. Either via the
7279 type or via vtop->sym. We can't pop those nor any that in turn
7280 might be referred to. To make it easier we don't roll back
7281 any symbols in that case; some upper level call to block() will
7282 do that. We do have to remove such symbols from the lookup
7283 tables, though. sym_pop will do that. */
7285 /* pop locally defined symbols */
7286 pop_local_syms(o
->lstk
, is_expr
);
7287 cur_scope
= o
->prev
;
7291 tcc_debug_stabn(tcc_state
, N_RBRAC
, ind
- func_ind
);
7294 /* leave a scope via break/continue(/goto) */
7295 void leave_scope(struct scope
*o
)
7299 try_call_scope_cleanup(o
->cl
.s
);
7303 /* ------------------------------------------------------------------------- */
7304 /* call block from 'for do while' loops */
7306 static void lblock(int *bsym
, int *csym
)
7308 struct scope
*lo
= loop_scope
, *co
= cur_scope
;
7309 int *b
= co
->bsym
, *c
= co
->csym
;
7323 static void block(int is_expr
)
7325 int a
, b
, c
, d
, e
, t
;
7330 /* default return value is (void) */
7332 vtop
->type
.t
= VT_VOID
;
7337 /* If the token carries a value, next() might destroy it. Only with
7338 invalid code such as f(){"123"4;} */
7339 if (TOK_HAS_VALUE(t
))
7344 tcc_tcov_check_line (0), tcc_tcov_block_begin ();
7352 if (tok
== TOK_ELSE
) {
7357 gsym(d
); /* patch else jmp */
7362 } else if (t
== TOK_WHILE
) {
7374 } else if (t
== '{') {
7377 /* handle local labels declarations */
7378 while (tok
== TOK_LABEL
) {
7381 if (tok
< TOK_UIDENT
)
7382 expect("label identifier");
7383 label_push(&local_label_stack
, tok
, LABEL_DECLARED
);
7385 } while (tok
== ',');
7389 while (tok
!= '}') {
7398 prev_scope(&o
, is_expr
);
7401 else if (!nocode_wanted
)
7402 check_func_return();
7404 } else if (t
== TOK_RETURN
) {
7405 b
= (func_vt
.t
& VT_BTYPE
) != VT_VOID
;
7409 gen_assign_cast(&func_vt
);
7411 if (vtop
->type
.t
!= VT_VOID
)
7412 tcc_warning("void function returns a value");
7416 tcc_warning("'return' with no value");
7419 leave_scope(root_scope
);
7421 gfunc_return(&func_vt
);
7423 /* jump unless last stmt in top-level block */
7424 if (tok
!= '}' || local_scope
!= 1)
7427 tcc_tcov_block_end (tcov_data
.line
);
7430 } else if (t
== TOK_BREAK
) {
7432 if (!cur_scope
->bsym
)
7433 tcc_error("cannot break");
7434 if (cur_switch
&& cur_scope
->bsym
== cur_switch
->bsym
)
7435 leave_scope(cur_switch
->scope
);
7437 leave_scope(loop_scope
);
7438 *cur_scope
->bsym
= gjmp(*cur_scope
->bsym
);
7441 } else if (t
== TOK_CONTINUE
) {
7443 if (!cur_scope
->csym
)
7444 tcc_error("cannot continue");
7445 leave_scope(loop_scope
);
7446 *cur_scope
->csym
= gjmp(*cur_scope
->csym
);
7449 } else if (t
== TOK_FOR
) {
7454 /* c99 for-loop init decl? */
7455 if (!decl0(VT_LOCAL
, 1, NULL
)) {
7456 /* no, regular for-loop init expr */
7484 } else if (t
== TOK_DO
) {
7498 } else if (t
== TOK_SWITCH
) {
7499 struct switch_t
*sw
;
7501 sw
= tcc_mallocz(sizeof *sw
);
7503 sw
->scope
= cur_scope
;
7504 sw
->prev
= cur_switch
;
7510 sw
->sv
= *vtop
--; /* save switch value */
7513 b
= gjmp(0); /* jump to first case */
7515 a
= gjmp(a
); /* add implicit break */
7519 if (sw
->sv
.type
.t
& VT_UNSIGNED
)
7520 qsort(sw
->p
, sw
->n
, sizeof(void*), case_cmpu
);
7522 qsort(sw
->p
, sw
->n
, sizeof(void*), case_cmpi
);
7524 for (b
= 1; b
< sw
->n
; b
++)
7525 if (sw
->sv
.type
.t
& VT_UNSIGNED
7526 ? (uint64_t)sw
->p
[b
- 1]->v2
>= (uint64_t)sw
->p
[b
]->v1
7527 : sw
->p
[b
- 1]->v2
>= sw
->p
[b
]->v1
)
7528 tcc_error("duplicate case value");
7532 d
= 0, gcase(sw
->p
, sw
->n
, &d
);
7535 gsym_addr(d
, sw
->def_sym
);
7541 dynarray_reset(&sw
->p
, &sw
->n
);
7542 cur_switch
= sw
->prev
;
7545 } else if (t
== TOK_CASE
) {
7546 struct case_t
*cr
= tcc_malloc(sizeof(struct case_t
));
7549 cr
->v1
= cr
->v2
= expr_const64();
7550 if (gnu_ext
&& tok
== TOK_DOTS
) {
7552 cr
->v2
= expr_const64();
7553 if ((!(cur_switch
->sv
.type
.t
& VT_UNSIGNED
) && cr
->v2
< cr
->v1
)
7554 || (cur_switch
->sv
.type
.t
& VT_UNSIGNED
&& (uint64_t)cr
->v2
< (uint64_t)cr
->v1
))
7555 tcc_warning("empty case range");
7559 dynarray_add(&cur_switch
->p
, &cur_switch
->n
, cr
);
7562 goto block_after_label
;
7564 } else if (t
== TOK_DEFAULT
) {
7567 if (cur_switch
->def_sym
)
7568 tcc_error("too many 'default'");
7570 cur_switch
->def_sym
= gind();
7573 goto block_after_label
;
7575 } else if (t
== TOK_GOTO
) {
7576 if (cur_scope
->vla
.num
)
7577 vla_restore(cur_scope
->vla
.locorig
);
7578 if (tok
== '*' && gnu_ext
) {
7582 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
)
7586 } else if (tok
>= TOK_UIDENT
) {
7587 s
= label_find(tok
);
7588 /* put forward definition if needed */
7590 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
7591 else if (s
->r
== LABEL_DECLARED
)
7592 s
->r
= LABEL_FORWARD
;
7594 if (s
->r
& LABEL_FORWARD
) {
7595 /* start new goto chain for cleanups, linked via label->next */
7596 if (cur_scope
->cl
.s
&& !nocode_wanted
) {
7597 sym_push2(&pending_gotos
, SYM_FIELD
, 0, cur_scope
->cl
.n
);
7598 pending_gotos
->prev_tok
= s
;
7599 s
= sym_push2(&s
->next
, SYM_FIELD
, 0, 0);
7600 pending_gotos
->next
= s
;
7602 s
->jnext
= gjmp(s
->jnext
);
7604 try_call_cleanup_goto(s
->cleanupstate
);
7605 gjmp_addr(s
->jnext
);
7610 expect("label identifier");
7614 } else if (t
== TOK_ASM1
|| t
== TOK_ASM2
|| t
== TOK_ASM3
) {
7618 if (tok
== ':' && t
>= TOK_UIDENT
) {
7623 if (s
->r
== LABEL_DEFINED
)
7624 tcc_error("duplicate label '%s'", get_tok_str(s
->v
, NULL
));
7625 s
->r
= LABEL_DEFINED
;
7627 Sym
*pcl
; /* pending cleanup goto */
7628 for (pcl
= s
->next
; pcl
; pcl
= pcl
->prev
)
7630 sym_pop(&s
->next
, NULL
, 0);
7634 s
= label_push(&global_label_stack
, t
, LABEL_DEFINED
);
7637 s
->cleanupstate
= cur_scope
->cl
.s
;
7640 vla_restore(cur_scope
->vla
.loc
);
7643 /* we accept this, but it is a mistake */
7644 tcc_warning_c(warn_all
)("deprecated use of label at end of compound statement");
7647 /* expression case */
7664 tcc_tcov_check_line (0), tcc_tcov_block_end (0);
7667 /* This skips over a stream of tokens containing balanced {} and ()
7668 pairs, stopping at outer ',' ';' and '}' (or matching '}' if we started
7669 with a '{'). If STR then allocates and stores the skipped tokens
7670 in *STR. This doesn't check if () and {} are nested correctly,
7671 i.e. "({)}" is accepted. */
7672 static void skip_or_save_block(TokenString
**str
)
7674 int braces
= tok
== '{';
7677 *str
= tok_str_alloc();
7679 while ((level
> 0 || (tok
!= '}' && tok
!= ',' && tok
!= ';' && tok
!= ')'))) {
7681 if (tok
== TOK_EOF
) {
7682 if (str
|| level
> 0)
7683 tcc_error("unexpected end of file");
7688 tok_str_add_tok(*str
);
7691 if (t
== '{' || t
== '(') {
7693 } else if (t
== '}' || t
== ')') {
7695 if (level
== 0 && braces
&& t
== '}')
7700 tok_str_add(*str
, -1);
7701 tok_str_add(*str
, 0);
7705 #define EXPR_CONST 1
7708 static void parse_init_elem(int expr_type
)
7710 int saved_global_expr
;
7713 /* compound literals must be allocated globally in this case */
7714 saved_global_expr
= global_expr
;
7717 global_expr
= saved_global_expr
;
7718 /* NOTE: symbols are accepted, as well as lvalue for anon symbols
7719 (compound literals). */
7720 if (((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) != VT_CONST
7721 && ((vtop
->r
& (VT_SYM
|VT_LVAL
)) != (VT_SYM
|VT_LVAL
)
7722 || vtop
->sym
->v
< SYM_FIRST_ANOM
))
7723 #ifdef TCC_TARGET_PE
7724 || ((vtop
->r
& VT_SYM
) && vtop
->sym
->a
.dllimport
)
7727 tcc_error("initializer element is not constant");
7736 static void init_assert(init_params
*p
, int offset
)
7738 if (p
->sec
? !NODATA_WANTED
&& offset
> p
->sec
->data_offset
7739 : !nocode_wanted
&& offset
> p
->local_offset
)
7740 tcc_internal_error("initializer overflow");
7743 #define init_assert(sec, offset)
7746 /* put zeros for variable based init */
7747 static void init_putz(init_params
*p
, unsigned long c
, int size
)
7749 init_assert(p
, c
+ size
);
7751 /* nothing to do because globals are already set to zero */
7753 vpush_helper_func(TOK_memset
);
7755 #ifdef TCC_TARGET_ARM
7767 #define DIF_SIZE_ONLY 2
7768 #define DIF_HAVE_ELEM 4
7771 /* delete relocations for specified range c ... c + size. Unfortunatly
7772 in very special cases, relocations may occur unordered */
7773 static void decl_design_delrels(Section
*sec
, int c
, int size
)
7775 ElfW_Rel
*rel
, *rel2
, *rel_end
;
7776 if (!sec
|| !sec
->reloc
)
7778 rel
= rel2
= (ElfW_Rel
*)sec
->reloc
->data
;
7779 rel_end
= (ElfW_Rel
*)(sec
->reloc
->data
+ sec
->reloc
->data_offset
);
7780 while (rel
< rel_end
) {
7781 if (rel
->r_offset
>= c
&& rel
->r_offset
< c
+ size
) {
7782 sec
->reloc
->data_offset
-= sizeof *rel
;
7785 memcpy(rel2
, rel
, sizeof *rel
);
7792 static void decl_design_flex(init_params
*p
, Sym
*ref
, int index
)
7794 if (ref
== p
->flex_array_ref
) {
7795 if (index
>= ref
->c
)
7797 } else if (ref
->c
< 0)
7798 tcc_error("flexible array has zero size in this context");
7801 /* t is the array or struct type. c is the array or struct
7802 address. cur_field is the pointer to the current
7803 field, for arrays the 'c' member contains the current start
7804 index. 'flags' is as in decl_initializer.
7805 'al' contains the already initialized length of the
7806 current container (starting at c). This returns the new length of that. */
7807 static int decl_designator(init_params
*p
, CType
*type
, unsigned long c
,
7808 Sym
**cur_field
, int flags
, int al
)
7811 int index
, index_last
, align
, l
, nb_elems
, elem_size
;
7812 unsigned long corig
= c
;
7817 if (flags
& DIF_HAVE_ELEM
)
7820 if (gnu_ext
&& tok
>= TOK_UIDENT
) {
7827 /* NOTE: we only support ranges for last designator */
7828 while (nb_elems
== 1 && (tok
== '[' || tok
== '.')) {
7830 if (!(type
->t
& VT_ARRAY
))
7831 expect("array type");
7833 index
= index_last
= expr_const();
7834 if (tok
== TOK_DOTS
&& gnu_ext
) {
7836 index_last
= expr_const();
7840 decl_design_flex(p
, s
, index_last
);
7841 if (index
< 0 || index_last
>= s
->c
|| index_last
< index
)
7842 tcc_error("index exceeds array bounds or range is empty");
7844 (*cur_field
)->c
= index_last
;
7845 type
= pointed_type(type
);
7846 elem_size
= type_size(type
, &align
);
7847 c
+= index
* elem_size
;
7848 nb_elems
= index_last
- index
+ 1;
7855 if ((type
->t
& VT_BTYPE
) != VT_STRUCT
)
7856 expect("struct/union type");
7858 f
= find_field(type
, l
, &cumofs
);
7871 } else if (!gnu_ext
) {
7876 if (type
->t
& VT_ARRAY
) {
7877 index
= (*cur_field
)->c
;
7879 decl_design_flex(p
, s
, index
);
7881 tcc_error("too many initializers");
7882 type
= pointed_type(type
);
7883 elem_size
= type_size(type
, &align
);
7884 c
+= index
* elem_size
;
7887 while (f
&& (f
->v
& SYM_FIRST_ANOM
) && (f
->type
.t
& VT_BITFIELD
))
7888 *cur_field
= f
= f
->next
;
7890 tcc_error("too many initializers");
7896 if (!elem_size
) /* for structs */
7897 elem_size
= type_size(type
, &align
);
7899 /* Using designators the same element can be initialized more
7900 than once. In that case we need to delete possibly already
7901 existing relocations. */
7902 if (!(flags
& DIF_SIZE_ONLY
) && c
- corig
< al
) {
7903 decl_design_delrels(p
->sec
, c
, elem_size
* nb_elems
);
7904 flags
&= ~DIF_CLEAR
; /* mark stack dirty too */
7907 decl_initializer(p
, type
, c
, flags
& ~DIF_FIRST
);
7909 if (!(flags
& DIF_SIZE_ONLY
) && nb_elems
> 1) {
7913 if (p
->sec
|| (type
->t
& VT_ARRAY
)) {
7914 /* make init_putv/vstore believe it were a struct */
7916 t1
.t
= VT_STRUCT
, t1
.ref
= &aref
;
7920 vpush_ref(type
, p
->sec
, c
, elem_size
);
7922 vset(type
, VT_LOCAL
|VT_LVAL
, c
);
7923 for (i
= 1; i
< nb_elems
; i
++) {
7925 init_putv(p
, type
, c
+ elem_size
* i
);
7930 c
+= nb_elems
* elem_size
;
7936 /* store a value or an expression directly in global data or in local array */
7937 static void init_putv(init_params
*p
, CType
*type
, unsigned long c
)
7943 Section
*sec
= p
->sec
;
7947 dtype
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
7949 size
= type_size(type
, &align
);
7950 if (type
->t
& VT_BITFIELD
)
7951 size
= (BIT_POS(type
->t
) + BIT_SIZE(type
->t
) + 7) / 8;
7952 init_assert(p
, c
+ size
);
7955 /* XXX: not portable */
7956 /* XXX: generate error if incorrect relocation */
7957 gen_assign_cast(&dtype
);
7958 bt
= type
->t
& VT_BTYPE
;
7960 if ((vtop
->r
& VT_SYM
)
7962 && (bt
!= (PTR_SIZE
== 8 ? VT_LLONG
: VT_INT
)
7963 || (type
->t
& VT_BITFIELD
))
7964 && !((vtop
->r
& VT_CONST
) && vtop
->sym
->v
>= SYM_FIRST_ANOM
)
7966 tcc_error("initializer element is not computable at load time");
7968 if (NODATA_WANTED
) {
7973 ptr
= sec
->data
+ c
;
7976 /* XXX: make code faster ? */
7977 if ((vtop
->r
& (VT_SYM
|VT_CONST
)) == (VT_SYM
|VT_CONST
) &&
7978 vtop
->sym
->v
>= SYM_FIRST_ANOM
&&
7979 /* XXX This rejects compound literals like
7980 '(void *){ptr}'. The problem is that '&sym' is
7981 represented the same way, which would be ruled out
7982 by the SYM_FIRST_ANOM check above, but also '"string"'
7983 in 'char *p = "string"' is represented the same
7984 with the type being VT_PTR and the symbol being an
7985 anonymous one. That is, there's no difference in vtop
7986 between '(void *){x}' and '&(void *){x}'. Ignore
7987 pointer typed entities here. Hopefully no real code
7988 will ever use compound literals with scalar type. */
7989 (vtop
->type
.t
& VT_BTYPE
) != VT_PTR
) {
7990 /* These come from compound literals, memcpy stuff over. */
7994 esym
= elfsym(vtop
->sym
);
7995 ssec
= tcc_state
->sections
[esym
->st_shndx
];
7996 memmove (ptr
, ssec
->data
+ esym
->st_value
+ (int)vtop
->c
.i
, size
);
7998 /* We need to copy over all memory contents, and that
7999 includes relocations. Use the fact that relocs are
8000 created it order, so look from the end of relocs
8001 until we hit one before the copied region. */
8002 unsigned long relofs
= ssec
->reloc
->data_offset
;
8003 while (relofs
>= sizeof(*rel
)) {
8004 relofs
-= sizeof(*rel
);
8005 rel
= (ElfW_Rel
*)(ssec
->reloc
->data
+ relofs
);
8006 if (rel
->r_offset
>= esym
->st_value
+ size
)
8008 if (rel
->r_offset
< esym
->st_value
)
8010 put_elf_reloca(symtab_section
, sec
,
8011 c
+ rel
->r_offset
- esym
->st_value
,
8012 ELFW(R_TYPE
)(rel
->r_info
),
8013 ELFW(R_SYM
)(rel
->r_info
),
8023 if (type
->t
& VT_BITFIELD
) {
8024 int bit_pos
, bit_size
, bits
, n
;
8025 unsigned char *p
, v
, m
;
8026 bit_pos
= BIT_POS(vtop
->type
.t
);
8027 bit_size
= BIT_SIZE(vtop
->type
.t
);
8028 p
= (unsigned char*)ptr
+ (bit_pos
>> 3);
8029 bit_pos
&= 7, bits
= 0;
8034 v
= val
>> bits
<< bit_pos
;
8035 m
= ((1 << n
) - 1) << bit_pos
;
8036 *p
= (*p
& ~m
) | (v
& m
);
8037 bits
+= n
, bit_size
-= n
, bit_pos
= 0, ++p
;
8042 *(char *)ptr
= val
!= 0;
8048 write16le(ptr
, val
);
8051 write32le(ptr
, val
);
8054 write64le(ptr
, val
);
8057 #if defined TCC_IS_NATIVE_387
8058 /* Host and target platform may be different but both have x87.
8059 On windows, tcc does not use VT_LDOUBLE, except when it is a
8060 cross compiler. In this case a mingw gcc as host compiler
8061 comes here with 10-byte long doubles, while msvc or tcc won't.
8062 tcc itself can still translate by asm.
8063 In any case we avoid possibly random bytes 11 and 12.
8065 if (sizeof (long double) >= 10)
8066 memcpy(ptr
, &vtop
->c
.ld
, 10);
8068 else if (sizeof (long double) == sizeof (double))
8069 __asm__("fldl %1\nfstpt %0\n" : "=m" (*ptr
) : "m" (vtop
->c
.ld
));
8071 else if (vtop
->c
.ld
== 0.0)
8075 /* For other platforms it should work natively, but may not work
8076 for cross compilers */
8077 if (sizeof(long double) == LDOUBLE_SIZE
)
8078 memcpy(ptr
, &vtop
->c
.ld
, LDOUBLE_SIZE
);
8079 else if (sizeof(double) == LDOUBLE_SIZE
)
8080 memcpy(ptr
, &vtop
->c
.ld
, LDOUBLE_SIZE
);
8081 #ifndef TCC_CROSS_TEST
8083 tcc_error("can't cross compile long double constants");
8088 /* intptr_t may need a reloc too, see tcctest.c:relocation_test() */
8091 if (vtop
->r
& VT_SYM
)
8092 greloca(sec
, vtop
->sym
, c
, R_DATA_PTR
, val
);
8094 write64le(ptr
, val
);
8097 write32le(ptr
, val
);
8101 write64le(ptr
, val
);
8105 if (vtop
->r
& VT_SYM
)
8106 greloc(sec
, vtop
->sym
, c
, R_DATA_PTR
);
8107 write32le(ptr
, val
);
8111 //tcc_internal_error("unexpected type");
8117 vset(&dtype
, VT_LOCAL
|VT_LVAL
, c
);
8124 /* 't' contains the type and storage info. 'c' is the offset of the
8125 object in section 'sec'. If 'sec' is NULL, it means stack based
8126 allocation. 'flags & DIF_FIRST' is true if array '{' must be read (multi
8127 dimension implicit array init handling). 'flags & DIF_SIZE_ONLY' is true if
8128 size only evaluation is wanted (only for arrays). */
8129 static void decl_initializer(init_params
*p
, CType
*type
, unsigned long c
, int flags
)
8131 int len
, n
, no_oblock
, i
;
8137 /* generate line number info */
8138 if (debug_modes
&& !p
->sec
)
8139 tcc_debug_line(tcc_state
), tcc_tcov_check_line (1);
8141 if (!(flags
& DIF_HAVE_ELEM
) && tok
!= '{' &&
8142 /* In case of strings we have special handling for arrays, so
8143 don't consume them as initializer value (which would commit them
8144 to some anonymous symbol). */
8145 tok
!= TOK_LSTR
&& tok
!= TOK_STR
&&
8146 !(flags
& DIF_SIZE_ONLY
)) {
8147 parse_init_elem(!p
->sec
? EXPR_ANY
: EXPR_CONST
);
8148 flags
|= DIF_HAVE_ELEM
;
8151 if ((flags
& DIF_HAVE_ELEM
) &&
8152 !(type
->t
& VT_ARRAY
) &&
8153 /* Use i_c_parameter_t, to strip toplevel qualifiers.
8154 The source type might have VT_CONSTANT set, which is
8155 of course assignable to non-const elements. */
8156 is_compatible_unqualified_types(type
, &vtop
->type
)) {
8159 } else if (type
->t
& VT_ARRAY
) {
8161 if (((flags
& DIF_FIRST
) && tok
!= TOK_LSTR
&& tok
!= TOK_STR
) ||
8169 t1
= pointed_type(type
);
8170 size1
= type_size(t1
, &align1
);
8172 /* only parse strings here if correct type (otherwise: handle
8173 them as ((w)char *) expressions */
8174 if ((tok
== TOK_LSTR
&&
8175 #ifdef TCC_TARGET_PE
8176 (t1
->t
& VT_BTYPE
) == VT_SHORT
&& (t1
->t
& VT_UNSIGNED
)
8178 (t1
->t
& VT_BTYPE
) == VT_INT
8180 ) || (tok
== TOK_STR
&& (t1
->t
& VT_BTYPE
) == VT_BYTE
)) {
8182 cstr_reset(&initstr
);
8183 if (size1
!= (tok
== TOK_STR
? 1 : sizeof(nwchar_t
)))
8184 tcc_error("unhandled string literal merging");
8185 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
8187 initstr
.size
-= size1
;
8189 len
+= tokc
.str
.size
;
8191 len
+= tokc
.str
.size
/ sizeof(nwchar_t
);
8193 cstr_cat(&initstr
, tokc
.str
.data
, tokc
.str
.size
);
8196 if (tok
!= ')' && tok
!= '}' && tok
!= ',' && tok
!= ';'
8197 && tok
!= TOK_EOF
) {
8198 /* Not a lone literal but part of a bigger expression. */
8199 unget_tok(size1
== 1 ? TOK_STR
: TOK_LSTR
);
8200 tokc
.str
.size
= initstr
.size
;
8201 tokc
.str
.data
= initstr
.data
;
8205 decl_design_flex(p
, s
, len
);
8206 if (!(flags
& DIF_SIZE_ONLY
)) {
8211 tcc_warning("initializer-string for array is too long");
8212 /* in order to go faster for common case (char
8213 string in global variable, we handle it
8215 if (p
->sec
&& size1
== 1) {
8216 init_assert(p
, c
+ nb
);
8218 memcpy(p
->sec
->data
+ c
, initstr
.data
, nb
);
8222 /* only add trailing zero if enough storage (no
8223 warning in this case since it is standard) */
8224 if (flags
& DIF_CLEAR
)
8227 init_putz(p
, c
+ i
* size1
, (n
- i
) * size1
);
8231 } else if (size1
== 1)
8232 ch
= ((unsigned char *)initstr
.data
)[i
];
8234 ch
= ((nwchar_t
*)initstr
.data
)[i
];
8236 init_putv(p
, t1
, c
+ i
* size1
);
8247 /* zero memory once in advance */
8248 if (!(flags
& (DIF_CLEAR
| DIF_SIZE_ONLY
))) {
8249 init_putz(p
, c
, n
*size1
);
8254 while (tok
!= '}' || (flags
& DIF_HAVE_ELEM
)) {
8255 len
= decl_designator(p
, type
, c
, &f
, flags
, len
);
8256 flags
&= ~DIF_HAVE_ELEM
;
8257 if (type
->t
& VT_ARRAY
) {
8259 /* special test for multi dimensional arrays (may not
8260 be strictly correct if designators are used at the
8262 if (no_oblock
&& len
>= n
*size1
)
8265 if (s
->type
.t
== VT_UNION
)
8269 if (no_oblock
&& f
== NULL
)
8280 } else if ((type
->t
& VT_BTYPE
) == VT_STRUCT
) {
8282 if ((flags
& DIF_FIRST
) || tok
== '{') {
8291 } else if (tok
== '{') {
8292 if (flags
& DIF_HAVE_ELEM
)
8295 decl_initializer(p
, type
, c
, flags
& ~DIF_HAVE_ELEM
);
8297 } else if ((flags
& DIF_SIZE_ONLY
)) {
8298 /* If we supported only ISO C we wouldn't have to accept calling
8299 this on anything than an array if DIF_SIZE_ONLY (and even then
8300 only on the outermost level, so no recursion would be needed),
8301 because initializing a flex array member isn't supported.
8302 But GNU C supports it, so we need to recurse even into
8303 subfields of structs and arrays when DIF_SIZE_ONLY is set. */
8304 /* just skip expression */
8305 skip_or_save_block(NULL
);
8307 if (!(flags
& DIF_HAVE_ELEM
)) {
8308 /* This should happen only when we haven't parsed
8309 the init element above for fear of committing a
8310 string constant to memory too early. */
8311 if (tok
!= TOK_STR
&& tok
!= TOK_LSTR
)
8312 expect("string constant");
8313 parse_init_elem(!p
->sec
? EXPR_ANY
: EXPR_CONST
);
8316 if (!p
->sec
&& (flags
& DIF_CLEAR
) /* container was already zero'd */
8317 && (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
8319 && btype_size(type
->t
& VT_BTYPE
) /* not for fp constants */
8323 init_putv(p
, type
, c
);
8327 /* parse an initializer for type 't' if 'has_init' is non zero, and
8328 allocate space in local or global data space ('r' is either
8329 VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
8330 variable 'v' of scope 'scope' is declared before initializers
8331 are parsed. If 'v' is zero, then a reference to the new object
8332 is put in the value stack. If 'has_init' is 2, a special parsing
8333 is done to handle string constants. */
8334 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
8335 int has_init
, int v
, int scope
)
8337 int size
, align
, addr
;
8338 TokenString
*init_str
= NULL
;
8341 Sym
*flexible_array
;
8343 int saved_nocode_wanted
= nocode_wanted
;
8344 #ifdef CONFIG_TCC_BCHECK
8345 int bcheck
= tcc_state
->do_bounds_check
&& !NODATA_WANTED
;
8347 init_params p
= {0};
8349 /* Always allocate static or global variables */
8350 if (v
&& (r
& VT_VALMASK
) == VT_CONST
)
8351 nocode_wanted
|= 0x80000000;
8353 flexible_array
= NULL
;
8354 size
= type_size(type
, &align
);
8356 /* exactly one flexible array may be initialized, either the
8357 toplevel array or the last member of the toplevel struct */
8360 /* If the base type itself was an array type of unspecified size
8361 (like in 'typedef int arr[]; arr x = {1};') then we will
8362 overwrite the unknown size by the real one for this decl.
8363 We need to unshare the ref symbol holding that size. */
8364 type
->ref
= sym_push(SYM_FIELD
, &type
->ref
->type
, 0, type
->ref
->c
);
8365 p
.flex_array_ref
= type
->ref
;
8367 } else if (has_init
&& (type
->t
& VT_BTYPE
) == VT_STRUCT
) {
8368 Sym
*field
= type
->ref
->next
;
8371 field
= field
->next
;
8372 if (field
->type
.t
& VT_ARRAY
&& field
->type
.ref
->c
< 0) {
8373 flexible_array
= field
;
8374 p
.flex_array_ref
= field
->type
.ref
;
8381 /* If unknown size, do a dry-run 1st pass */
8383 tcc_error("unknown type size");
8384 if (has_init
== 2) {
8385 /* only get strings */
8386 init_str
= tok_str_alloc();
8387 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
8388 tok_str_add_tok(init_str
);
8391 tok_str_add(init_str
, -1);
8392 tok_str_add(init_str
, 0);
8394 skip_or_save_block(&init_str
);
8398 begin_macro(init_str
, 1);
8400 decl_initializer(&p
, type
, 0, DIF_FIRST
| DIF_SIZE_ONLY
);
8401 /* prepare second initializer parsing */
8402 macro_ptr
= init_str
->str
;
8405 /* if still unknown size, error */
8406 size
= type_size(type
, &align
);
8408 tcc_error("unknown type size");
8410 /* If there's a flex member and it was used in the initializer
8412 if (flexible_array
&& flexible_array
->type
.ref
->c
> 0)
8413 size
+= flexible_array
->type
.ref
->c
8414 * pointed_size(&flexible_array
->type
);
8417 /* take into account specified alignment if bigger */
8418 if (ad
->a
.aligned
) {
8419 int speca
= 1 << (ad
->a
.aligned
- 1);
8422 } else if (ad
->a
.packed
) {
8426 if (!v
&& NODATA_WANTED
)
8427 size
= 0, align
= 1;
8429 if ((r
& VT_VALMASK
) == VT_LOCAL
) {
8431 #ifdef CONFIG_TCC_BCHECK
8433 /* add padding between stack variables for bound checking */
8437 loc
= (loc
- size
) & -align
;
8439 p
.local_offset
= addr
+ size
;
8440 #ifdef CONFIG_TCC_BCHECK
8442 /* add padding between stack variables for bound checking */
8447 /* local variable */
8448 #ifdef CONFIG_TCC_ASM
8449 if (ad
->asm_label
) {
8450 int reg
= asm_parse_regvar(ad
->asm_label
);
8452 r
= (r
& ~VT_VALMASK
) | reg
;
8455 sym
= sym_push(v
, type
, r
, addr
);
8456 if (ad
->cleanup_func
) {
8457 Sym
*cls
= sym_push2(&all_cleanups
,
8458 SYM_FIELD
| ++cur_scope
->cl
.n
, 0, 0);
8459 cls
->prev_tok
= sym
;
8460 cls
->next
= ad
->cleanup_func
;
8461 cls
->ncl
= cur_scope
->cl
.s
;
8462 cur_scope
->cl
.s
= cls
;
8467 /* push local reference */
8468 vset(type
, r
, addr
);
8472 if (v
&& scope
== VT_CONST
) {
8473 /* see if the symbol was already defined */
8476 if (p
.flex_array_ref
&& (sym
->type
.t
& type
->t
& VT_ARRAY
)
8477 && sym
->type
.ref
->c
> type
->ref
->c
) {
8478 /* flex array was already declared with explicit size
8480 int arr[] = { 1,2,3 }; */
8481 type
->ref
->c
= sym
->type
.ref
->c
;
8482 size
= type_size(type
, &align
);
8484 patch_storage(sym
, ad
, type
);
8485 /* we accept several definitions of the same global variable. */
8486 if (!has_init
&& sym
->c
&& elfsym(sym
)->st_shndx
!= SHN_UNDEF
)
8491 /* allocate symbol in corresponding section */
8495 while ((tp
->t
& (VT_BTYPE
|VT_ARRAY
)) == (VT_PTR
|VT_ARRAY
))
8496 tp
= &tp
->ref
->type
;
8497 if (tp
->t
& VT_CONSTANT
) {
8498 sec
= rodata_section
;
8499 } else if (has_init
) {
8501 /*if (tcc_state->g_debug & 4)
8502 tcc_warning("rw data: %s", get_tok_str(v, 0));*/
8503 } else if (tcc_state
->nocommon
)
8508 addr
= section_add(sec
, size
, align
);
8509 #ifdef CONFIG_TCC_BCHECK
8510 /* add padding if bound check */
8512 section_add(sec
, 1, 1);
8515 addr
= align
; /* SHN_COMMON is special, symbol value is align */
8516 sec
= common_section
;
8521 sym
= sym_push(v
, type
, r
| VT_SYM
, 0);
8522 patch_storage(sym
, ad
, NULL
);
8524 /* update symbol definition */
8525 put_extern_sym(sym
, sec
, addr
, size
);
8527 /* push global reference */
8528 vpush_ref(type
, sec
, addr
, size
);
8533 #ifdef CONFIG_TCC_BCHECK
8534 /* handles bounds now because the symbol must be defined
8535 before for the relocation */
8539 greloca(bounds_section
, sym
, bounds_section
->data_offset
, R_DATA_PTR
, 0);
8540 /* then add global bound info */
8541 bounds_ptr
= section_ptr_add(bounds_section
, 2 * sizeof(addr_t
));
8542 bounds_ptr
[0] = 0; /* relocated */
8543 bounds_ptr
[1] = size
;
8548 if (type
->t
& VT_VLA
) {
8554 /* save before-VLA stack pointer if needed */
8555 if (cur_scope
->vla
.num
== 0) {
8556 if (cur_scope
->prev
&& cur_scope
->prev
->vla
.num
) {
8557 cur_scope
->vla
.locorig
= cur_scope
->prev
->vla
.loc
;
8559 gen_vla_sp_save(loc
-= PTR_SIZE
);
8560 cur_scope
->vla
.locorig
= loc
;
8564 vla_runtime_type_size(type
, &a
);
8565 gen_vla_alloc(type
, a
);
8566 #if defined TCC_TARGET_PE && defined TCC_TARGET_X86_64
8567 /* on _WIN64, because of the function args scratch area, the
8568 result of alloca differs from RSP and is returned in RAX. */
8569 gen_vla_result(addr
), addr
= (loc
-= PTR_SIZE
);
8571 gen_vla_sp_save(addr
);
8572 cur_scope
->vla
.loc
= addr
;
8573 cur_scope
->vla
.num
++;
8574 } else if (has_init
) {
8576 decl_initializer(&p
, type
, addr
, DIF_FIRST
);
8577 /* patch flexible array member size back to -1, */
8578 /* for possible subsequent similar declarations */
8580 flexible_array
->type
.ref
->c
= -1;
8584 /* restore parse state if needed */
8590 nocode_wanted
= saved_nocode_wanted
;
8593 /* parse a function defined by symbol 'sym' and generate its code in
8594 'cur_text_section' */
8595 static void gen_function(Sym
*sym
)
8597 struct scope f
= { 0 };
8598 cur_scope
= root_scope
= &f
;
8600 ind
= cur_text_section
->data_offset
;
8601 if (sym
->a
.aligned
) {
8602 size_t newoff
= section_add(cur_text_section
, 0,
8603 1 << (sym
->a
.aligned
- 1));
8604 gen_fill_nops(newoff
- ind
);
8606 /* NOTE: we patch the symbol size later */
8607 put_extern_sym(sym
, cur_text_section
, ind
, 0);
8608 if (sym
->type
.ref
->f
.func_ctor
)
8609 add_array (tcc_state
, ".init_array", sym
->c
);
8610 if (sym
->type
.ref
->f
.func_dtor
)
8611 add_array (tcc_state
, ".fini_array", sym
->c
);
8613 funcname
= get_tok_str(sym
->v
, NULL
);
8615 func_vt
= sym
->type
.ref
->type
;
8616 func_var
= sym
->type
.ref
->f
.func_type
== FUNC_ELLIPSIS
;
8618 /* put debug symbol */
8619 tcc_debug_funcstart(tcc_state
, sym
);
8620 /* push a dummy symbol to enable local sym storage */
8621 sym_push2(&local_stack
, SYM_FIELD
, 0, 0);
8622 local_scope
= 1; /* for function parameters */
8626 clear_temp_local_var_list();
8630 /* reset local stack */
8631 pop_local_syms(NULL
, 0);
8633 cur_text_section
->data_offset
= ind
;
8635 label_pop(&global_label_stack
, NULL
, 0);
8636 sym_pop(&all_cleanups
, NULL
, 0);
8637 /* patch symbol size */
8638 elfsym(sym
)->st_size
= ind
- func_ind
;
8639 /* end of function */
8640 tcc_debug_funcend(tcc_state
, ind
- func_ind
);
8641 /* It's better to crash than to generate wrong code */
8642 cur_text_section
= NULL
;
8643 funcname
= ""; /* for safety */
8644 func_vt
.t
= VT_VOID
; /* for safety */
8645 func_var
= 0; /* for safety */
8646 ind
= 0; /* for safety */
8647 nocode_wanted
= 0x80000000;
8649 /* do this after funcend debug info */
8653 static void gen_inline_functions(TCCState
*s
)
8656 int inline_generated
, i
;
8657 struct InlineFunc
*fn
;
8659 tcc_open_bf(s
, ":inline:", 0);
8660 /* iterate while inline function are referenced */
8662 inline_generated
= 0;
8663 for (i
= 0; i
< s
->nb_inline_fns
; ++i
) {
8664 fn
= s
->inline_fns
[i
];
8666 if (sym
&& (sym
->c
|| !(sym
->type
.t
& VT_INLINE
))) {
8667 /* the function was used or forced (and then not internal):
8668 generate its code and convert it to a normal function */
8670 tcc_debug_putfile(s
, fn
->filename
);
8671 begin_macro(fn
->func_str
, 1);
8673 cur_text_section
= text_section
;
8677 inline_generated
= 1;
8680 } while (inline_generated
);
8684 static void free_inline_functions(TCCState
*s
)
8687 /* free tokens of unused inline functions */
8688 for (i
= 0; i
< s
->nb_inline_fns
; ++i
) {
8689 struct InlineFunc
*fn
= s
->inline_fns
[i
];
8691 tok_str_free(fn
->func_str
);
8693 dynarray_reset(&s
->inline_fns
, &s
->nb_inline_fns
);
8696 /* 'l' is VT_LOCAL or VT_CONST to define default storage type, or VT_CMP
8697 if parsing old style parameter decl list (and FUNC_SYM is set then) */
8698 static int decl0(int l
, int is_for_loop_init
, Sym
*func_sym
)
8700 int v
, has_init
, r
, oldint
;
8703 AttributeDef ad
, adbase
;
8706 if (tok
== TOK_STATIC_ASSERT
) {
8716 tcc_error("_Static_assert fail");
8718 goto static_assert_out
;
8722 parse_mult_str(&error_str
, "string constant");
8724 tcc_error("%s", (char *)error_str
.data
);
8725 cstr_free(&error_str
);
8733 if (!parse_btype(&btype
, &adbase
)) {
8734 if (is_for_loop_init
)
8736 /* skip redundant ';' if not in old parameter decl scope */
8737 if (tok
== ';' && l
!= VT_CMP
) {
8743 if (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
) {
8744 /* global asm block */
8748 if (tok
>= TOK_UIDENT
) {
8749 /* special test for old K&R protos without explicit int
8750 type. Only accepted when defining global data */
8755 expect("declaration");
8761 if ((btype
.t
& VT_BTYPE
) == VT_STRUCT
) {
8763 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) >= SYM_FIRST_ANOM
)
8764 tcc_warning("unnamed struct/union that defines no instances");
8768 if (IS_ENUM(btype
.t
)) {
8774 while (1) { /* iterate thru each declaration */
8777 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
8781 type_to_str(buf
, sizeof(buf
), &type
, get_tok_str(v
, NULL
));
8782 printf("type = '%s'\n", buf
);
8785 if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
8786 if ((type
.t
& VT_STATIC
) && (l
== VT_LOCAL
))
8787 tcc_error("function without file scope cannot be static");
8788 /* if old style function prototype, we accept a
8791 if (sym
->f
.func_type
== FUNC_OLD
&& l
== VT_CONST
)
8792 decl0(VT_CMP
, 0, sym
);
8793 #ifdef TCC_TARGET_MACHO
8794 if (sym
->f
.func_alwinl
8795 && ((type
.t
& (VT_EXTERN
| VT_INLINE
))
8796 == (VT_EXTERN
| VT_INLINE
))) {
8797 /* always_inline functions must be handled as if they
8798 don't generate multiple global defs, even if extern
8799 inline, i.e. GNU inline semantics for those. Rewrite
8800 them into static inline. */
8801 type
.t
&= ~VT_EXTERN
;
8802 type
.t
|= VT_STATIC
;
8805 /* always compile 'extern inline' */
8806 if (type
.t
& VT_EXTERN
)
8807 type
.t
&= ~VT_INLINE
;
8809 } else if (oldint
) {
8810 tcc_warning("type defaults to int");
8813 if (gnu_ext
&& (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
)) {
8814 ad
.asm_label
= asm_label_instr();
8815 /* parse one last attribute list, after asm label */
8816 parse_attribute(&ad
);
8818 /* gcc does not allow __asm__("label") with function definition,
8825 #ifdef TCC_TARGET_PE
8826 if (ad
.a
.dllimport
|| ad
.a
.dllexport
) {
8827 if (type
.t
& VT_STATIC
)
8828 tcc_error("cannot have dll linkage with static");
8829 if (type
.t
& VT_TYPEDEF
) {
8830 tcc_warning("'%s' attribute ignored for typedef",
8831 ad
.a
.dllimport
? (ad
.a
.dllimport
= 0, "dllimport") :
8832 (ad
.a
.dllexport
= 0, "dllexport"));
8833 } else if (ad
.a
.dllimport
) {
8834 if ((type
.t
& VT_BTYPE
) == VT_FUNC
)
8837 type
.t
|= VT_EXTERN
;
8843 tcc_error("cannot use local functions");
8844 if ((type
.t
& VT_BTYPE
) != VT_FUNC
)
8845 expect("function definition");
8847 /* reject abstract declarators in function definition
8848 make old style params without decl have int type */
8850 while ((sym
= sym
->next
) != NULL
) {
8851 if (!(sym
->v
& ~SYM_FIELD
))
8852 expect("identifier");
8853 if (sym
->type
.t
== VT_VOID
)
8854 sym
->type
= int_type
;
8857 /* apply post-declaraton attributes */
8858 merge_funcattr(&type
.ref
->f
, &ad
.f
);
8860 /* put function symbol */
8861 type
.t
&= ~VT_EXTERN
;
8862 sym
= external_sym(v
, &type
, 0, &ad
);
8864 /* static inline functions are just recorded as a kind
8865 of macro. Their code will be emitted at the end of
8866 the compilation unit only if they are used */
8867 if (sym
->type
.t
& VT_INLINE
) {
8868 struct InlineFunc
*fn
;
8869 fn
= tcc_malloc(sizeof *fn
+ strlen(file
->filename
));
8870 strcpy(fn
->filename
, file
->filename
);
8872 skip_or_save_block(&fn
->func_str
);
8873 dynarray_add(&tcc_state
->inline_fns
,
8874 &tcc_state
->nb_inline_fns
, fn
);
8876 /* compute text section */
8877 cur_text_section
= ad
.section
;
8878 if (!cur_text_section
)
8879 cur_text_section
= text_section
;
8885 /* find parameter in function parameter list */
8886 for (sym
= func_sym
->next
; sym
; sym
= sym
->next
)
8887 if ((sym
->v
& ~SYM_FIELD
) == v
)
8889 tcc_error("declaration for parameter '%s' but no such parameter",
8890 get_tok_str(v
, NULL
));
8892 if (type
.t
& VT_STORAGE
) /* 'register' is okay */
8893 tcc_error("storage class specified for '%s'",
8894 get_tok_str(v
, NULL
));
8895 if (sym
->type
.t
!= VT_VOID
)
8896 tcc_error("redefinition of parameter '%s'",
8897 get_tok_str(v
, NULL
));
8898 convert_parameter_type(&type
);
8900 } else if (type
.t
& VT_TYPEDEF
) {
8901 /* save typedefed type */
8902 /* XXX: test storage specifiers ? */
8904 if (sym
&& sym
->sym_scope
== local_scope
) {
8905 if (!is_compatible_types(&sym
->type
, &type
)
8906 || !(sym
->type
.t
& VT_TYPEDEF
))
8907 tcc_error("incompatible redefinition of '%s'",
8908 get_tok_str(v
, NULL
));
8911 sym
= sym_push(v
, &type
, 0, 0);
8916 tcc_debug_typedef (tcc_state
, sym
);
8917 } else if ((type
.t
& VT_BTYPE
) == VT_VOID
8918 && !(type
.t
& VT_EXTERN
)) {
8919 tcc_error("declaration of void object");
8922 if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
8923 /* external function definition */
8924 /* specific case for func_call attribute */
8926 } else if (!(type
.t
& VT_ARRAY
)) {
8927 /* not lvalue if array */
8930 has_init
= (tok
== '=');
8931 if (has_init
&& (type
.t
& VT_VLA
))
8932 tcc_error("variable length array cannot be initialized");
8933 if (((type
.t
& VT_EXTERN
) && (!has_init
|| l
!= VT_CONST
))
8934 || (type
.t
& VT_BTYPE
) == VT_FUNC
8935 /* as with GCC, uninitialized global arrays with no size
8936 are considered extern: */
8937 || ((type
.t
& VT_ARRAY
) && !has_init
8938 && l
== VT_CONST
&& type
.ref
->c
< 0)
8940 /* external variable or function */
8941 type
.t
|= VT_EXTERN
;
8942 sym
= external_sym(v
, &type
, r
, &ad
);
8943 if (ad
.alias_target
) {
8944 /* Aliases need to be emitted when their target
8945 symbol is emitted, even if perhaps unreferenced.
8946 We only support the case where the base is
8947 already defined, otherwise we would need
8948 deferring to emit the aliases until the end of
8949 the compile unit. */
8950 Sym
*alias_target
= sym_find(ad
.alias_target
);
8951 ElfSym
*esym
= elfsym(alias_target
);
8953 tcc_error("unsupported forward __alias__ attribute");
8954 put_extern_sym2(sym
, esym
->st_shndx
,
8955 esym
->st_value
, esym
->st_size
, 1);
8958 if (type
.t
& VT_STATIC
)
8964 else if (l
== VT_CONST
)
8965 /* uninitialized global variables may be overridden */
8966 type
.t
|= VT_EXTERN
;
8967 decl_initializer_alloc(&type
, &ad
, r
, has_init
, v
, l
);
8971 if (is_for_loop_init
)
8983 static void decl(int l
)
8988 /* ------------------------------------------------------------------------- */
8991 /* ------------------------------------------------------------------------- */