2 * TCC - Tiny C Compiler
4 * Copyright (c) 2001, 2002 Fabrice Bellard
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program 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
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
32 #include <sys/timeb.h>
36 #include <sys/ucontext.h>
40 #ifndef CONFIG_TCC_STATIC
48 /* preprocessor debug */
50 /* include file debug */
55 /* target selection */
56 //#define TCC_TARGET_I386 /* i386 code generator */
57 //#define TCC_TARGET_IL /* .NET CLI generator */
59 /* default target is I386 */
60 #if !defined(TCC_TARGET_I386) && !defined(TCC_TARGET_IL)
61 #define TCC_TARGET_I386
64 #if !defined(WIN32) && !defined(TCC_UCLIBC) && !defined(TCC_TARGET_IL)
65 #define CONFIG_TCC_BCHECK /* enable bound checking code */
68 #ifndef CONFIG_TCC_PREFIX
69 #define CONFIG_TCC_PREFIX "/usr/local"
72 /* path to find crt1.o, crti.o and crtn.o. Only needed when generating
73 executables or dlls */
74 #define CONFIG_TCC_CRT_PREFIX "/usr/lib"
76 #define INCLUDE_STACK_SIZE 32
77 #define IFDEF_STACK_SIZE 64
78 #define VSTACK_SIZE 64
79 #define STRING_MAX_SIZE 1024
81 #define TOK_HASH_SIZE 2048 /* must be a power of two */
82 #define TOK_ALLOC_INCR 512 /* must be a power of two */
83 #define TOK_STR_ALLOC_INCR_BITS 6
84 #define TOK_STR_ALLOC_INCR (1 << TOK_STR_ALLOC_INCR_BITS)
85 #define TOK_MAX_SIZE 4 /* token max size in int unit when stored in string */
87 /* token symbol management */
88 typedef struct TokenSym
{
89 struct TokenSym
*hash_next
;
90 struct Sym
*sym_define
; /* direct pointer to define */
91 struct Sym
*sym_label
; /* direct pointer to label */
92 struct Sym
*sym_struct
; /* direct pointer to structure */
93 struct Sym
*sym_identifier
; /* direct pointer to identifier */
94 int tok
; /* token number */
99 typedef struct CString
{
100 int size
; /* size in bytes */
101 void *data
; /* either 'char *' or 'int *' */
103 void *data_allocated
; /* if non NULL, data has been malloced */
106 /* type definition */
107 typedef struct CType
{
113 typedef union CValue
{
119 unsigned int ul
; /* address (should be unsigned long on 64 bit cpu) */
121 unsigned long long ull
;
122 struct CString
*cstr
;
128 typedef struct SValue
{
129 CType type
; /* type */
130 unsigned short r
; /* register + flags */
131 unsigned short r2
; /* second register, used for 'long long'
132 type. If not used, set to VT_CONST */
133 CValue c
; /* constant, if VT_CONST */
134 struct Sym
*sym
; /* symbol, if (VT_SYM | VT_CONST) */
137 /* symbol management */
139 int v
; /* symbol token */
140 int r
; /* associated register */
141 int c
; /* associated number */
142 CType type
; /* associated type */
143 struct Sym
*next
; /* next related symbol */
144 struct Sym
*prev
; /* prev symbol in stack */
145 struct Sym
*prev_tok
; /* previous symbol for this token */
148 /* section definition */
149 /* XXX: use directly ELF structure for parameters ? */
150 /* special flag to indicate that the section should not be linked to
152 #define SHF_PRIVATE 0x80000000
154 typedef struct Section
{
155 unsigned long data_offset
; /* current data offset */
156 unsigned char *data
; /* section data */
157 unsigned long data_allocated
; /* used for realloc() handling */
158 int sh_name
; /* elf section name (only used during output) */
159 int sh_num
; /* elf section number */
160 int sh_type
; /* elf section type */
161 int sh_flags
; /* elf section flags */
162 int sh_info
; /* elf section info */
163 int sh_addralign
; /* elf section alignment */
164 int sh_entsize
; /* elf entry size */
165 unsigned long sh_size
; /* section size (only used during output) */
166 unsigned long sh_addr
; /* address at which the section is relocated */
167 unsigned long sh_offset
; /* address at which the section is relocated */
168 int nb_hashed_syms
; /* used to resize the hash table */
169 struct Section
*link
; /* link to another section */
170 struct Section
*reloc
; /* corresponding section for relocation, if any */
171 struct Section
*hash
; /* hash table for symbols */
172 struct Section
*next
;
173 char name
[64]; /* section name */
176 typedef struct DLLReference
{
181 /* GNUC attribute definition */
182 typedef struct AttributeDef
{
185 unsigned char func_call
; /* FUNC_CDECL or FUNC_STDCALL */
188 #define SYM_STRUCT 0x40000000 /* struct/union/enum symbol space */
189 #define SYM_FIELD 0x20000000 /* struct/union field symbol space */
190 #define SYM_FIRST_ANOM (1 << (31 - VT_STRUCT_SHIFT)) /* first anonymous sym */
192 /* stored in 'Sym.c' field */
193 #define FUNC_NEW 1 /* ansi function prototype */
194 #define FUNC_OLD 2 /* old function prototype */
195 #define FUNC_ELLIPSIS 3 /* ansi function prototype with ... */
197 /* stored in 'Sym.r' field */
198 #define FUNC_CDECL 0 /* standard c call */
199 #define FUNC_STDCALL 1 /* pascal c call */
201 /* field 'Sym.t' for macros */
202 #define MACRO_OBJ 0 /* object like macro */
203 #define MACRO_FUNC 1 /* function like macro */
205 /* field 'Sym.r' for labels */
206 #define LABEL_FORWARD 1 /* label is forward defined */
208 /* type_decl() types */
209 #define TYPE_ABSTRACT 1 /* type without variable */
210 #define TYPE_DIRECT 2 /* type with variable */
212 #define IO_BUF_SIZE 8192
214 typedef struct BufferedFile
{
218 int line_num
; /* current line number - here to simply code */
219 int ifndef_macro
; /* #ifndef macro / #endif search */
220 int ifndef_macro_saved
; /* saved ifndef_macro */
221 int *ifdef_stack_ptr
; /* ifdef_stack value at the start of the file */
222 char inc_type
; /* type of include */
223 char inc_filename
[512]; /* filename specified by the user */
224 char filename
[1024]; /* current filename - here to simplify code */
225 unsigned char buffer
[IO_BUF_SIZE
+ 1]; /* extra size for CH_EOB char */
228 #define CH_EOB '\\' /* end of buffer or '\0' char in file */
229 #define CH_EOF (-1) /* end of file */
231 /* parsing state (used to save parser state to reparse part of the
232 source several times) */
233 typedef struct ParseState
{
240 /* used to record tokens */
241 typedef struct TokenString
{
248 /* include file cache, used to find files faster and also to eliminate
249 inclusion if the include file is protected by #ifndef ... #endif */
250 typedef struct CachedInclude
{
252 char type
; /* '"' or '>' to give include type */
253 char filename
[1]; /* path specified in #include */
257 static struct BufferedFile
*file
;
258 static int ch
, tok
, tok1
;
259 static CValue tokc
, tok1c
;
260 static CString tokcstr
; /* current parsed string, if any */
261 /* additionnal informations about token */
262 static int tok_flags
;
263 #define TOK_FLAG_BOL 0x0001 /* beginning of line before */
264 #define TOK_FLAG_BOF 0x0002 /* beginning of file before */
265 #define TOK_FLAG_ENDIF 0x0004 /* a endif was found matching starting #ifdef */
267 /* if true, line feed is returned as a token. line feed is also
269 static int return_linefeed
;
270 static Section
*text_section
, *data_section
, *bss_section
; /* predefined sections */
271 static Section
*cur_text_section
; /* current section where function code is
273 /* bound check related sections */
274 static Section
*bounds_section
; /* contains global data bound description */
275 static Section
*lbounds_section
; /* contains local data bound description */
276 /* symbol sections */
277 static Section
*symtab_section
, *strtab_section
;
280 static Section
*stab_section
, *stabstr_section
;
282 /* loc : local variable index
283 ind : output code index
285 anon_sym: anonymous symbol index
287 static int rsym
, anon_sym
, ind
, loc
;
288 /* expression generation modifiers */
289 static int const_wanted
; /* true if constant wanted */
290 static int nocode_wanted
; /* true if no code generation wanted for an expression */
291 static int global_expr
; /* true if compound literals must be allocated
292 globally (used during initializers parsing */
293 static CType func_vt
; /* current function return type (used by return
296 static int last_line_num
, last_ind
, func_ind
; /* debug last line number and pc */
297 static int tok_ident
;
298 static TokenSym
**table_ident
;
299 static TokenSym
*hash_ident
[TOK_HASH_SIZE
];
300 static char token_buf
[STRING_MAX_SIZE
+ 1];
301 static char *funcname
;
302 static Sym
*global_stack
, *local_stack
;
303 static Sym
*define_stack
;
304 static Sym
*label_stack
;
306 static SValue vstack
[VSTACK_SIZE
], *vtop
;
307 static int *macro_ptr
, *macro_ptr_allocated
;
308 /* some predefined types */
309 static CType char_pointer_type
, func_old_type
, int_type
;
311 /* compile with debug symbol (and use them if error during execution) */
312 static int do_debug
= 0;
314 /* compile with built-in memory and bounds checker */
315 static int do_bounds_check
= 0;
317 /* display benchmark infos */
318 static int do_bench
= 0;
319 static int total_lines
;
320 static int total_bytes
;
322 /* use GNU C extensions */
323 static int gnu_ext
= 1;
325 /* use Tiny C extensions */
326 static int tcc_ext
= 1;
328 /* max number of callers shown if error */
329 static int num_callers
= 6;
330 static const char **rt_bound_error_msg
;
332 /* XXX: suppress that ASAP */
333 static struct TCCState
*tcc_state
;
335 /* give the path of the tcc libraries */
336 static const char *tcc_lib_path
= CONFIG_TCC_PREFIX
"/lib/tcc";
341 BufferedFile
**include_stack_ptr
;
342 int *ifdef_stack_ptr
;
344 /* include file handling */
345 char **include_paths
;
346 int nb_include_paths
;
347 char **sysinclude_paths
;
348 int nb_sysinclude_paths
;
349 CachedInclude
**cached_includes
;
350 int nb_cached_includes
;
352 char **library_paths
;
353 int nb_library_paths
;
355 /* array of all loaded dlls (including those referenced by loaded
357 DLLReference
**loaded_dlls
;
362 int nb_sections
; /* number of sections, including first dummy section */
366 unsigned long *got_offsets
;
369 /* give the correspondance from symtab indexes to dynsym indexes */
370 int *symtab_to_dynsym
;
372 /* temporary dynamic symbol sections (for dll loading) */
373 Section
*dynsymtab_section
;
374 /* exported dynamic symbol section */
377 /* if true, static linking is performed */
382 void (*error_func
)(void *opaque
, const char *msg
);
383 int error_set_jmp_enabled
;
384 jmp_buf error_jmp_buf
;
387 /* see include_stack_ptr */
388 BufferedFile
*include_stack
[INCLUDE_STACK_SIZE
];
390 /* see ifdef_stack_ptr */
391 int ifdef_stack
[IFDEF_STACK_SIZE
];
394 /* The current value can be: */
395 #define VT_VALMASK 0x00ff
396 #define VT_CONST 0x00f0 /* constant in vc
397 (must be first non register value) */
398 #define VT_LLOCAL 0x00f1 /* lvalue, offset on stack */
399 #define VT_LOCAL 0x00f2 /* offset on stack */
400 #define VT_CMP 0x00f3 /* the value is stored in processor flags (in vc) */
401 #define VT_JMP 0x00f4 /* value is the consequence of jmp true (even) */
402 #define VT_JMPI 0x00f5 /* value is the consequence of jmp false (odd) */
403 #define VT_LVAL 0x0100 /* var is an lvalue */
404 #define VT_SYM 0x0200 /* a symbol value is added */
405 #define VT_MUSTCAST 0x0400 /* value must be casted to be correct (used for
406 char/short stored in integer registers) */
407 #define VT_MUSTBOUND 0x0800 /* bound checking must be done before
408 dereferencing value */
409 #define VT_BOUNDED 0x8000 /* value is bounded. The address of the
410 bounding function call point is in vc */
411 #define VT_LVAL_BYTE 0x1000 /* lvalue is a byte */
412 #define VT_LVAL_SHORT 0x2000 /* lvalue is a short */
413 #define VT_LVAL_UNSIGNED 0x4000 /* lvalue is unsigned */
414 #define VT_LVAL_TYPE (VT_LVAL_BYTE | VT_LVAL_SHORT | VT_LVAL_UNSIGNED)
417 #define VT_STRUCT_SHIFT 12 /* structure/enum name shift (20 bits left) */
419 #define VT_INT 0 /* integer type */
420 #define VT_BYTE 1 /* signed byte type */
421 #define VT_SHORT 2 /* short type */
422 #define VT_VOID 3 /* void type */
423 #define VT_PTR 4 /* pointer */
424 #define VT_ENUM 5 /* enum definition */
425 #define VT_FUNC 6 /* function type */
426 #define VT_STRUCT 7 /* struct/union definition */
427 #define VT_FLOAT 8 /* IEEE float */
428 #define VT_DOUBLE 9 /* IEEE double */
429 #define VT_LDOUBLE 10 /* IEEE long double */
430 #define VT_BOOL 11 /* ISOC99 boolean type */
431 #define VT_LLONG 12 /* 64 bit integer */
432 #define VT_LONG 13 /* long integer (NEVER USED as type, only
434 #define VT_BTYPE 0x000f /* mask for basic type */
435 #define VT_UNSIGNED 0x0010 /* unsigned type */
436 #define VT_ARRAY 0x0020 /* array type (also has VT_PTR) */
437 #define VT_BITFIELD 0x0040 /* bitfield modifier */
440 #define VT_EXTERN 0x00000080 /* extern definition */
441 #define VT_STATIC 0x00000100 /* static variable */
442 #define VT_TYPEDEF 0x00000200 /* typedef definition */
444 /* type mask (except storage) */
445 #define VT_TYPE (~(VT_EXTERN | VT_STATIC | VT_TYPEDEF))
449 /* warning: the following compare tokens depend on i386 asm code */
461 #define TOK_LAND 0xa0
465 #define TOK_MID 0xa3 /* inc/dec, to void constant */
467 #define TOK_UDIV 0xb0 /* unsigned division */
468 #define TOK_UMOD 0xb1 /* unsigned modulo */
469 #define TOK_PDIV 0xb2 /* fast division with undefined rounding for pointers */
470 #define TOK_CINT 0xb3 /* number in tokc */
471 #define TOK_CCHAR 0xb4 /* char constant in tokc */
472 #define TOK_STR 0xb5 /* pointer to string in tokc */
473 #define TOK_TWOSHARPS 0xb6 /* ## preprocessing token */
474 #define TOK_LCHAR 0xb7
475 #define TOK_LSTR 0xb8
476 #define TOK_CFLOAT 0xb9 /* float constant */
477 #define TOK_LINENUM 0xba /* line number info */
478 #define TOK_CDOUBLE 0xc0 /* double constant */
479 #define TOK_CLDOUBLE 0xc1 /* long double constant */
480 #define TOK_UMULL 0xc2 /* unsigned 32x32 -> 64 mul */
481 #define TOK_ADDC1 0xc3 /* add with carry generation */
482 #define TOK_ADDC2 0xc4 /* add with carry use */
483 #define TOK_SUBC1 0xc5 /* add with carry generation */
484 #define TOK_SUBC2 0xc6 /* add with carry use */
485 #define TOK_CUINT 0xc8 /* unsigned int constant */
486 #define TOK_CLLONG 0xc9 /* long long constant */
487 #define TOK_CULLONG 0xca /* unsigned long long constant */
488 #define TOK_ARROW 0xcb
489 #define TOK_DOTS 0xcc /* three dots */
490 #define TOK_SHR 0xcd /* unsigned shift right */
491 #define TOK_PPNUM 0xce /* preprocessor number */
493 #define TOK_SHL 0x01 /* shift left */
494 #define TOK_SAR 0x02 /* signed shift right */
496 /* assignement operators : normal operator or 0x80 */
497 #define TOK_A_MOD 0xa5
498 #define TOK_A_AND 0xa6
499 #define TOK_A_MUL 0xaa
500 #define TOK_A_ADD 0xab
501 #define TOK_A_SUB 0xad
502 #define TOK_A_DIV 0xaf
503 #define TOK_A_XOR 0xde
504 #define TOK_A_OR 0xfc
505 #define TOK_A_SHL 0x81
506 #define TOK_A_SAR 0x82
508 /* WARNING: the content of this string encodes token numbers */
509 static char tok_two_chars
[] = "<=\236>=\235!=\225&&\240||\241++\244--\242==\224<<\1>>\2+=\253-=\255*=\252/=\257%=\245&=\246^=\336|=\374->\313..\250##\266";
511 #define TOK_EOF (-1) /* end of file */
512 #define TOK_LINEFEED 10 /* line feed */
514 /* all identificators and strings have token above that */
515 #define TOK_IDENT 256
518 TOK_LAST
= TOK_IDENT
- 1,
519 #define DEF(id, str) id,
524 static const char *tcc_keywords
=
525 #define DEF(id, str) str "\0"
530 #define TOK_UIDENT TOK_DEFINE
533 #define snprintf _snprintf
534 #define vsnprintf _vsnprintf
537 #if defined(WIN32) || defined(TCC_UCLIBC)
538 /* currently incorrect */
539 long double strtold(const char *nptr
, char **endptr
)
541 return (long double)strtod(nptr
, endptr
);
543 float strtof(const char *nptr
, char **endptr
)
545 return (float)strtod(nptr
, endptr
);
548 /* XXX: need to define this to use them in non ISOC99 context */
549 extern float strtof (const char *__nptr
, char **__endptr
);
550 extern long double strtold (const char *__nptr
, char **__endptr
);
553 static char *pstrcpy(char *buf
, int buf_size
, const char *s
);
554 static char *pstrcat(char *buf
, int buf_size
, const char *s
);
556 static void next(void);
557 static void next_nomacro(void);
558 static void parse_expr_type(CType
*type
);
559 static void expr_type(CType
*type
);
560 static void unary_type(CType
*type
);
561 static int expr_const(void);
562 static void expr_eq(void);
563 static void gexpr(void);
564 static void decl(int l
);
565 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
566 int first
, int size_only
);
567 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
568 int has_init
, int v
, int scope
);
570 void gv2(int rc1
, int rc2
);
571 void move_reg(int r
, int s
);
572 void save_regs(int n
);
573 void save_reg(int r
);
579 static void macro_subst(TokenString
*tok_str
,
580 Sym
**nested_list
, int *macro_str
);
581 int save_reg_forced(int r
);
583 void force_charshort_cast(int t
);
584 static void gen_cast(CType
*type
);
586 static Sym
*sym_find(int v
);
587 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
);
590 static int type_size(CType
*type
, int *a
);
591 static inline CType
*pointed_type(CType
*type
);
592 static int pointed_size(CType
*type
);
593 static int lvalue_type(int t
);
594 static int is_compatible_types(CType
*type1
, CType
*type2
);
595 static int parse_btype(CType
*type
, AttributeDef
*ad
);
596 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
);
598 void error(const char *fmt
, ...);
600 void vset(CType
*type
, int r
, int v
);
601 void type_to_str(char *buf
, int buf_size
,
602 CType
*type
, const char *varstr
);
603 char *get_tok_str(int v
, CValue
*cv
);
604 static Sym
*get_sym_ref(CType
*type
, Section
*sec
,
605 unsigned long offset
, unsigned long size
);
606 static Sym
*external_global_sym(int v
, CType
*type
, int r
);
608 /* section generation */
609 static void section_realloc(Section
*sec
, unsigned long new_size
);
610 static void *section_ptr_add(Section
*sec
, unsigned long size
);
611 static void put_extern_sym(Sym
*sym
, Section
*section
,
612 unsigned long value
, unsigned long size
);
613 static void greloc(Section
*s
, Sym
*sym
, unsigned long addr
, int type
);
614 static int put_elf_str(Section
*s
, const char *sym
);
615 static int put_elf_sym(Section
*s
,
616 unsigned long value
, unsigned long size
,
617 int info
, int other
, int shndx
, const char *name
);
618 static int add_elf_sym(Section
*s
, unsigned long value
, unsigned long size
,
619 int info
, int sh_num
, const char *name
);
620 static void put_elf_reloc(Section
*symtab
, Section
*s
, unsigned long offset
,
621 int type
, int symbol
);
622 static void put_stabs(const char *str
, int type
, int other
, int desc
,
623 unsigned long value
);
624 static void put_stabs_r(const char *str
, int type
, int other
, int desc
,
625 unsigned long value
, Section
*sec
, int sym_index
);
626 static void put_stabn(int type
, int other
, int desc
, int value
);
627 static void put_stabd(int type
, int other
, int desc
);
628 static int tcc_add_dll(TCCState
*s
, const char *filename
, int flags
);
630 #define AFF_PRINT_ERROR 0x0001 /* print error if file not found */
631 #define AFF_REFERENCED_DLL 0x0002 /* load a referenced dll from another dll */
632 static int tcc_add_file_internal(TCCState
*s
, const char *filename
, int flags
);
634 /* true if float/double/long double type */
635 static inline int is_float(int t
)
639 return bt
== VT_LDOUBLE
|| bt
== VT_DOUBLE
|| bt
== VT_FLOAT
;
642 #ifdef TCC_TARGET_I386
643 #include "i386-gen.c"
649 #ifdef CONFIG_TCC_STATIC
651 #define RTLD_LAZY 0x001
652 #define RTLD_NOW 0x002
653 #define RTLD_GLOBAL 0x100
654 #define RTLD_DEFAULT NULL
656 /* dummy function for profiling */
657 void *dlopen(const char *filename
, int flag
)
662 const char *dlerror(void)
667 typedef struct TCCSyms
{
672 #define TCCSYM(a) { #a, &a, },
674 /* add the symbol you want here if no dynamic linking is done */
675 static TCCSyms tcc_syms
[] = {
683 void *dlsym(void *handle
, const char *symbol
)
687 while (p
->str
!= NULL
) {
688 if (!strcmp(p
->str
, symbol
))
697 /********************************************************/
699 /* we use our own 'finite' function to avoid potential problems with
700 non standard math libs */
701 /* XXX: endianness dependant */
702 int ieee_finite(double d
)
705 return ((unsigned)((p
[1] | 0x800fffff) + 1)) >> 31;
708 /* copy a string and truncate it. */
709 static char *pstrcpy(char *buf
, int buf_size
, const char *s
)
716 q_end
= buf
+ buf_size
- 1;
728 /* strcat and truncate. */
729 static char *pstrcat(char *buf
, int buf_size
, const char *s
)
734 pstrcpy(buf
+ len
, buf_size
- len
, s
);
738 /* memory management */
744 static inline void tcc_free(void *ptr
)
747 mem_cur_size
-= malloc_usable_size(ptr
);
752 static void *tcc_malloc(unsigned long size
)
757 error("memory full");
759 mem_cur_size
+= malloc_usable_size(ptr
);
760 if (mem_cur_size
> mem_max_size
)
761 mem_max_size
= mem_cur_size
;
766 static void *tcc_mallocz(unsigned long size
)
769 ptr
= tcc_malloc(size
);
770 memset(ptr
, 0, size
);
774 static inline void *tcc_realloc(void *ptr
, unsigned long size
)
778 mem_cur_size
-= malloc_usable_size(ptr
);
780 ptr1
= realloc(ptr
, size
);
782 /* NOTE: count not correct if alloc error, but not critical */
783 mem_cur_size
+= malloc_usable_size(ptr1
);
784 if (mem_cur_size
> mem_max_size
)
785 mem_max_size
= mem_cur_size
;
790 static char *tcc_strdup(const char *str
)
793 ptr
= tcc_malloc(strlen(str
) + 1);
798 #define free(p) use_tcc_free(p)
799 #define malloc(s) use_tcc_malloc(s)
800 #define realloc(p, s) use_tcc_realloc(p, s)
802 static void dynarray_add(void ***ptab
, int *nb_ptr
, void *data
)
809 /* every power of two we double array size */
810 if ((nb
& (nb
- 1)) == 0) {
815 pp
= tcc_realloc(pp
, nb_alloc
* sizeof(void *));
817 error("memory full");
824 Section
*new_section(TCCState
*s1
, const char *name
, int sh_type
, int sh_flags
)
828 sec
= tcc_mallocz(sizeof(Section
));
829 pstrcpy(sec
->name
, sizeof(sec
->name
), name
);
830 sec
->sh_type
= sh_type
;
831 sec
->sh_flags
= sh_flags
;
838 sec
->sh_addralign
= 4;
841 sec
->sh_addralign
= 1;
844 sec
->sh_addralign
= 32; /* default conservative alignment */
848 /* only add section if not private */
849 if (!(sh_flags
& SHF_PRIVATE
)) {
850 sec
->sh_num
= s1
->nb_sections
;
851 dynarray_add((void ***)&s1
->sections
, &s1
->nb_sections
, sec
);
856 static void free_section(Section
*s
)
862 /* realloc section and set its content to zero */
863 static void section_realloc(Section
*sec
, unsigned long new_size
)
868 size
= sec
->data_allocated
;
871 while (size
< new_size
)
873 data
= tcc_realloc(sec
->data
, size
);
875 error("memory full");
876 memset(data
+ sec
->data_allocated
, 0, size
- sec
->data_allocated
);
878 sec
->data_allocated
= size
;
881 /* reserve at least 'size' bytes in section 'sec' from
883 static void *section_ptr_add(Section
*sec
, unsigned long size
)
885 unsigned long offset
, offset1
;
887 offset
= sec
->data_offset
;
888 offset1
= offset
+ size
;
889 if (offset1
> sec
->data_allocated
)
890 section_realloc(sec
, offset1
);
891 sec
->data_offset
= offset1
;
892 return sec
->data
+ offset
;
895 /* return a reference to a section, and create it if it does not
897 Section
*find_section(TCCState
*s1
, const char *name
)
901 for(i
= 1; i
< s1
->nb_sections
; i
++) {
902 sec
= s1
->sections
[i
];
903 if (!strcmp(name
, sec
->name
))
906 /* sections are created as PROGBITS */
907 return new_section(s1
, name
, SHT_PROGBITS
, SHF_ALLOC
);
910 /* update sym->c so that it points to an external symbol in section
911 'section' with value 'value' */
912 static void put_extern_sym(Sym
*sym
, Section
*section
,
913 unsigned long value
, unsigned long size
)
915 int sym_type
, sym_bind
, sh_num
, info
;
920 sh_num
= section
->sh_num
;
924 if ((sym
->type
.t
& VT_BTYPE
) == VT_FUNC
)
927 sym_type
= STT_OBJECT
;
928 if (sym
->type
.t
& VT_STATIC
)
929 sym_bind
= STB_LOCAL
;
931 sym_bind
= STB_GLOBAL
;
933 name
= get_tok_str(sym
->v
, NULL
);
934 #ifdef CONFIG_TCC_BCHECK
935 if (do_bounds_check
) {
938 /* XXX: avoid doing that for statics ? */
939 /* if bound checking is activated, we change some function
940 names by adding the "__bound" prefix */
943 /* XXX: we rely only on malloc hooks */
955 strcpy(buf
, "__bound_");
962 info
= ELF32_ST_INFO(sym_bind
, sym_type
);
963 sym
->c
= add_elf_sym(symtab_section
, value
, size
, info
, sh_num
, name
);
965 esym
= &((Elf32_Sym
*)symtab_section
->data
)[sym
->c
];
966 esym
->st_value
= value
;
967 esym
->st_size
= size
;
968 esym
->st_shndx
= sh_num
;
972 /* add a new relocation entry to symbol 'sym' in section 's' */
973 static void greloc(Section
*s
, Sym
*sym
, unsigned long offset
, int type
)
976 put_extern_sym(sym
, NULL
, 0, 0);
977 /* now we can add ELF relocation info */
978 put_elf_reloc(symtab_section
, s
, offset
, type
, sym
->c
);
981 static inline int isid(int c
)
983 return (c
>= 'a' && c
<= 'z') ||
984 (c
>= 'A' && c
<= 'Z') ||
988 static inline int isnum(int c
)
990 return c
>= '0' && c
<= '9';
993 static inline int isoct(int c
)
995 return c
>= '0' && c
<= '7';
998 static inline int toup(int c
)
1000 if (c
>= 'a' && c
<= 'z')
1001 return c
- 'a' + 'A';
1006 static void strcat_vprintf(char *buf
, int buf_size
, const char *fmt
, va_list ap
)
1010 vsnprintf(buf
+ len
, buf_size
- len
, fmt
, ap
);
1013 static void strcat_printf(char *buf
, int buf_size
, const char *fmt
, ...)
1017 strcat_vprintf(buf
, buf_size
, fmt
, ap
);
1021 void error1(TCCState
*s1
, int is_warning
, const char *fmt
, va_list ap
)
1028 for(f
= s1
->include_stack
; f
< s1
->include_stack_ptr
; f
++)
1029 strcat_printf(buf
, sizeof(buf
), "In file included from %s:%d:\n",
1030 (*f
)->filename
, (*f
)->line_num
);
1031 if (file
->line_num
> 0) {
1032 strcat_printf(buf
, sizeof(buf
),
1033 "%s:%d: ", file
->filename
, file
->line_num
);
1035 strcat_printf(buf
, sizeof(buf
),
1036 "%s: ", file
->filename
);
1039 strcat_printf(buf
, sizeof(buf
),
1043 strcat_printf(buf
, sizeof(buf
), "warning: ");
1044 strcat_vprintf(buf
, sizeof(buf
), fmt
, ap
);
1046 if (!s1
->error_func
) {
1047 /* default case: stderr */
1048 fprintf(stderr
, "%s\n", buf
);
1050 s1
->error_func(s1
->error_opaque
, buf
);
1057 void tcc_set_error_func(TCCState
*s
, void *error_opaque
,
1058 void (*error_func
)(void *opaque
, const char *msg
))
1060 s
->error_opaque
= error_opaque
;
1061 s
->error_func
= error_func
;
1065 /* error without aborting current compilation */
1066 void error_noabort(const char *fmt
, ...)
1068 TCCState
*s1
= tcc_state
;
1072 error1(s1
, 0, fmt
, ap
);
1076 void error(const char *fmt
, ...)
1078 TCCState
*s1
= tcc_state
;
1082 error1(s1
, 0, fmt
, ap
);
1084 /* better than nothing: in some cases, we accept to handle errors */
1085 if (s1
->error_set_jmp_enabled
) {
1086 longjmp(s1
->error_jmp_buf
, 1);
1088 /* XXX: suppress it someday */
1093 void expect(const char *msg
)
1095 error("%s expected", msg
);
1098 void warning(const char *fmt
, ...)
1100 TCCState
*s1
= tcc_state
;
1104 error1(s1
, 1, fmt
, ap
);
1111 error("'%c' expected", c
);
1115 void test_lvalue(void)
1117 if (!(vtop
->r
& VT_LVAL
))
1121 /* allocate a new token */
1122 static TokenSym
*tok_alloc_new(TokenSym
**pts
, const char *str
, int len
)
1124 TokenSym
*ts
, **ptable
;
1127 if (tok_ident
>= SYM_FIRST_ANOM
)
1128 error("memory full");
1130 /* expand token table if needed */
1131 i
= tok_ident
- TOK_IDENT
;
1132 if ((i
% TOK_ALLOC_INCR
) == 0) {
1133 ptable
= tcc_realloc(table_ident
, (i
+ TOK_ALLOC_INCR
) * sizeof(TokenSym
*));
1135 error("memory full");
1136 table_ident
= ptable
;
1139 ts
= tcc_malloc(sizeof(TokenSym
) + len
);
1140 table_ident
[i
] = ts
;
1141 ts
->tok
= tok_ident
++;
1142 ts
->sym_define
= NULL
;
1143 ts
->sym_label
= NULL
;
1144 ts
->sym_struct
= NULL
;
1145 ts
->sym_identifier
= NULL
;
1147 ts
->hash_next
= NULL
;
1148 memcpy(ts
->str
, str
, len
);
1149 ts
->str
[len
] = '\0';
1154 #define TOK_HASH_INIT 1
1155 #define TOK_HASH_FUNC(h, c) ((h) * 263 + (c))
1157 /* find a token and add it if not found */
1158 static TokenSym
*tok_alloc(const char *str
, int len
)
1160 TokenSym
*ts
, **pts
;
1166 h
= TOK_HASH_FUNC(h
, ((unsigned char *)str
)[i
]);
1167 h
&= (TOK_HASH_SIZE
- 1);
1169 pts
= &hash_ident
[h
];
1174 if (ts
->len
== len
&& !memcmp(ts
->str
, str
, len
))
1176 pts
= &(ts
->hash_next
);
1178 return tok_alloc_new(pts
, str
, len
);
1181 /* CString handling */
1183 static void cstr_realloc(CString
*cstr
, int new_size
)
1188 size
= cstr
->size_allocated
;
1190 size
= 8; /* no need to allocate a too small first string */
1191 while (size
< new_size
)
1193 data
= tcc_realloc(cstr
->data_allocated
, size
);
1195 error("memory full");
1196 cstr
->data_allocated
= data
;
1197 cstr
->size_allocated
= size
;
1202 static void cstr_ccat(CString
*cstr
, int ch
)
1205 size
= cstr
->size
+ 1;
1206 if (size
> cstr
->size_allocated
)
1207 cstr_realloc(cstr
, size
);
1208 ((unsigned char *)cstr
->data
)[size
- 1] = ch
;
1212 static void cstr_cat(CString
*cstr
, const char *str
)
1224 /* add a wide char */
1225 static void cstr_wccat(CString
*cstr
, int ch
)
1228 size
= cstr
->size
+ sizeof(int);
1229 if (size
> cstr
->size_allocated
)
1230 cstr_realloc(cstr
, size
);
1231 *(int *)(((unsigned char *)cstr
->data
) + size
- sizeof(int)) = ch
;
1235 static void cstr_new(CString
*cstr
)
1237 memset(cstr
, 0, sizeof(CString
));
1240 /* free string and reset it to NULL */
1241 static void cstr_free(CString
*cstr
)
1243 tcc_free(cstr
->data_allocated
);
1247 #define cstr_reset(cstr) cstr_free(cstr)
1249 static CString
*cstr_dup(CString
*cstr1
)
1254 cstr
= tcc_malloc(sizeof(CString
));
1257 cstr
->size_allocated
= size
;
1258 cstr
->data_allocated
= tcc_malloc(size
);
1259 cstr
->data
= cstr
->data_allocated
;
1260 memcpy(cstr
->data_allocated
, cstr1
->data_allocated
, size
);
1264 /* XXX: unicode ? */
1265 static void add_char(CString
*cstr
, int c
)
1267 if (c
== '\'' || c
== '\"' || c
== '\\') {
1268 /* XXX: could be more precise if char or string */
1269 cstr_ccat(cstr
, '\\');
1271 if (c
>= 32 && c
<= 126) {
1274 cstr_ccat(cstr
, '\\');
1276 cstr_ccat(cstr
, 'n');
1278 cstr_ccat(cstr
, '0' + ((c
>> 6) & 7));
1279 cstr_ccat(cstr
, '0' + ((c
>> 3) & 7));
1280 cstr_ccat(cstr
, '0' + (c
& 7));
1285 /* XXX: buffer overflow */
1286 /* XXX: float tokens */
1287 char *get_tok_str(int v
, CValue
*cv
)
1289 static char buf
[STRING_MAX_SIZE
+ 1];
1290 static CString cstr_buf
;
1296 /* NOTE: to go faster, we give a fixed buffer for small strings */
1297 cstr_reset(&cstr_buf
);
1298 cstr_buf
.data
= buf
;
1299 cstr_buf
.size_allocated
= sizeof(buf
);
1305 /* XXX: not quite exact, but only useful for testing */
1306 sprintf(p
, "%u", cv
->ui
);
1310 /* XXX: not quite exact, but only useful for testing */
1311 sprintf(p
, "%Lu", cv
->ull
);
1315 cstr_ccat(&cstr_buf
, '\'');
1316 add_char(&cstr_buf
, cv
->i
);
1317 cstr_ccat(&cstr_buf
, '\'');
1318 cstr_ccat(&cstr_buf
, '\0');
1322 len
= cstr
->size
- 1;
1324 add_char(&cstr_buf
, ((unsigned char *)cstr
->data
)[i
]);
1325 cstr_ccat(&cstr_buf
, '\0');
1330 cstr_ccat(&cstr_buf
, '\"');
1332 len
= cstr
->size
- 1;
1334 add_char(&cstr_buf
, ((unsigned char *)cstr
->data
)[i
]);
1336 len
= (cstr
->size
/ sizeof(int)) - 1;
1338 add_char(&cstr_buf
, ((int *)cstr
->data
)[i
]);
1340 cstr_ccat(&cstr_buf
, '\"');
1341 cstr_ccat(&cstr_buf
, '\0');
1350 return strcpy(p
, "<<=");
1352 return strcpy(p
, ">>=");
1354 if (v
< TOK_IDENT
) {
1355 /* search in two bytes table */
1369 } else if (v
< tok_ident
) {
1370 return table_ident
[v
- TOK_IDENT
]->str
;
1371 } else if (v
>= SYM_FIRST_ANOM
) {
1372 /* special name for anonymous symbol */
1373 sprintf(p
, "L.%u", v
- SYM_FIRST_ANOM
);
1375 /* should never happen */
1380 return cstr_buf
.data
;
1383 /* push, without hashing */
1384 static Sym
*sym_push2(Sym
**ps
, int v
, int t
, int c
)
1387 s
= tcc_malloc(sizeof(Sym
));
1398 /* find a symbol and return its associated structure. 's' is the top
1399 of the symbol stack */
1400 static Sym
*sym_find2(Sym
*s
, int v
)
1410 /* structure lookup */
1411 static Sym
*struct_find(int v
)
1414 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1416 return table_ident
[v
]->sym_struct
;
1419 /* find an identifier */
1420 static inline Sym
*sym_find(int v
)
1423 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1425 return table_ident
[v
]->sym_identifier
;
1428 /* push a given symbol on the symbol stack */
1429 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
)
1438 s
= sym_push2(ps
, v
, type
->t
, c
);
1439 s
->type
.ref
= type
->ref
;
1441 /* don't record fields or anonymous symbols */
1443 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1444 /* record symbol in token array */
1445 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1447 ps
= &ts
->sym_struct
;
1449 ps
= &ts
->sym_identifier
;
1456 /* push a global identifier */
1457 static Sym
*global_identifier_push(int v
, int t
, int c
)
1460 s
= sym_push2(&global_stack
, v
, t
, c
);
1461 /* don't record anonymous symbol */
1462 if (v
< SYM_FIRST_ANOM
) {
1463 ps
= &table_ident
[v
- TOK_IDENT
]->sym_identifier
;
1464 /* modify the top most local identifier, so that
1465 sym_identifier will point to 's' when popped */
1467 ps
= &(*ps
)->prev_tok
;
1474 /* pop symbols until top reaches 'b' */
1475 static void sym_pop(Sym
**ptop
, Sym
*b
)
1485 /* remove symbol in token array */
1487 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1488 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1490 ps
= &ts
->sym_struct
;
1492 ps
= &ts
->sym_identifier
;
1503 BufferedFile
*tcc_open(TCCState
*s1
, const char *filename
)
1508 fd
= open(filename
, O_RDONLY
);
1511 bf
= tcc_malloc(sizeof(BufferedFile
));
1517 bf
->buf_ptr
= bf
->buffer
;
1518 bf
->buf_end
= bf
->buffer
;
1519 bf
->buffer
[0] = CH_EOB
; /* put eob symbol */
1520 pstrcpy(bf
->filename
, sizeof(bf
->filename
), filename
);
1522 bf
->ifndef_macro
= 0;
1523 bf
->ifdef_stack_ptr
= s1
->ifdef_stack_ptr
;
1524 // printf("opening '%s'\n", filename);
1528 void tcc_close(BufferedFile
*bf
)
1530 total_lines
+= bf
->line_num
;
1535 /* fill input buffer and peek next char */
1536 static int tcc_peekc_slow(BufferedFile
*bf
)
1539 /* only tries to read if really end of buffer */
1540 if (bf
->buf_ptr
>= bf
->buf_end
) {
1542 #if defined(PARSE_DEBUG)
1547 len
= read(bf
->fd
, bf
->buffer
, len
);
1554 bf
->buf_ptr
= bf
->buffer
;
1555 bf
->buf_end
= bf
->buffer
+ len
;
1556 *bf
->buf_end
= CH_EOB
;
1558 if (bf
->buf_ptr
< bf
->buf_end
) {
1559 return bf
->buf_ptr
[0];
1561 bf
->buf_ptr
= bf
->buf_end
;
1566 /* return the current character, handling end of block if necessary
1568 static int handle_eob(void)
1570 return tcc_peekc_slow(file
);
1573 /* read next char from current input file and handle end of input buffer */
1574 static inline void inp(void)
1576 ch
= *(++(file
->buf_ptr
));
1577 /* end of buffer/file handling */
1582 /* handle '\[\r]\n' */
1583 static void handle_stray(void)
1585 while (ch
== '\\') {
1590 } else if (ch
== '\r') {
1598 error("stray '\\' in program");
1603 /* skip the stray and handle the \\n case. Output an error if
1604 incorrect char after the stray */
1605 static int handle_stray1(uint8_t *p
)
1609 if (p
>= file
->buf_end
) {
1626 /* handle the complicated stray case */
1627 #define PEEKC(c, p)\
1632 c = handle_stray1(p);\
1637 /* input with '\[\r]\n' handling. Note that this function cannot
1638 handle other characters after '\', so you cannot call it inside
1639 strings or comments */
1640 static void minp(void)
1648 static void parse_line_comment(void)
1650 /* single line C++ comments */
1651 /* XXX: accept '\\\n' ? */
1653 while (ch
!= '\n' && ch
!= CH_EOF
)
1657 static void parse_comment(void)
1666 /* fast skip loop */
1669 if (c
== '\n' || c
== '*' || c
== '\\')
1673 if (c
== '\n' || c
== '*' || c
== '\\')
1677 /* now we can handle all the cases */
1681 } else if (c
== '*') {
1687 } else if (c
== '/') {
1688 goto end_of_comment
;
1689 } else if (c
== '\\') {
1693 /* skip '\\n', but if '\' followed but another
1694 char, behave asif a stray was parsed */
1695 ch
= file
->buf_ptr
[0];
1696 while (ch
== '\\') {
1701 } else if (ch
== '\r') {
1719 /* stray, eob or eof */
1724 error("unexpected end of file in comment");
1725 } else if (c
== '\\') {
1738 /* space exlcuding newline */
1739 static inline int is_space(int ch
)
1741 return ch
== ' ' || ch
== '\t' || ch
== '\v' || ch
== '\f' || ch
== '\r';
1744 static inline void skip_spaces(void)
1746 while (is_space(ch
))
1750 /* skip block of text until #else, #elif or #endif. skip also pairs of
1752 void preprocess_skip(void)
1754 int a
, start_of_line
, sep
, c
;
1781 } else if (c
== '\\') {
1782 /* XXX: incorrect: should not give an error */
1783 ch
= file
->buf_ptr
[0];
1797 } else if (c
== '\\') {
1802 /* XXX: better error message */
1803 error("unterminated string");
1804 } else if (c
== '\\') {
1805 /* ignore next char */
1815 else if (c
!= CH_EOF
)
1818 } else if (c
== '\n') {
1834 } else if (ch
== '/') {
1835 parse_line_comment();
1842 if (start_of_line
) {
1847 (tok
== TOK_ELSE
|| tok
== TOK_ELIF
|| tok
== TOK_ENDIF
))
1849 if (tok
== TOK_IF
|| tok
== TOK_IFDEF
|| tok
== TOK_IFNDEF
)
1851 else if (tok
== TOK_ENDIF
)
1865 /* ParseState handling */
1867 /* XXX: currently, no include file info is stored. Thus, we cannot display
1868 accurate messages if the function or data definition spans multiple
1871 /* save current parse state in 's' */
1872 void save_parse_state(ParseState
*s
)
1874 s
->line_num
= file
->line_num
;
1875 s
->macro_ptr
= macro_ptr
;
1880 /* restore parse state from 's' */
1881 void restore_parse_state(ParseState
*s
)
1883 file
->line_num
= s
->line_num
;
1884 macro_ptr
= s
->macro_ptr
;
1889 /* return the number of additionnal 'ints' necessary to store the
1891 static inline int tok_ext_size(int t
)
1910 return LDOUBLE_SIZE
/ 4;
1916 /* token string handling */
1918 static inline void tok_str_new(TokenString
*s
)
1922 s
->allocated_len
= 0;
1923 s
->last_line_num
= -1;
1926 static void tok_str_free(int *str
)
1935 /* NOTE: we test zero separately so that GCC can generate a
1936 table for the following switch */
1951 /* XXX: use a macro to be portable on 64 bit ? */
1952 cstr
= (CString
*)p
[1];
1963 p
+= 1 + (LDOUBLE_SIZE
/ 4);
1973 static int *tok_str_realloc(TokenString
*s
)
1977 len
= s
->allocated_len
+ TOK_STR_ALLOC_INCR
;
1978 str
= tcc_realloc(s
->str
, len
* sizeof(int));
1980 error("memory full");
1981 s
->allocated_len
= len
;
1986 static void tok_str_add(TokenString
*s
, int t
)
1992 if (len
>= s
->allocated_len
)
1993 str
= tok_str_realloc(s
);
1998 static void tok_str_add2(TokenString
*s
, int t
, CValue
*cv
)
2005 /* allocate space for worst case */
2006 if (len
+ TOK_MAX_SIZE
> s
->allocated_len
)
2007 str
= tok_str_realloc(s
);
2016 str
[len
++] = cv
->tab
[0];
2021 str
[len
++] = (int)cstr_dup(cv
->cstr
);
2026 str
[len
++] = cv
->tab
[0];
2027 str
[len
++] = cv
->tab
[1];
2030 #if LDOUBLE_SIZE == 12
2031 str
[len
++] = cv
->tab
[0];
2032 str
[len
++] = cv
->tab
[1];
2033 str
[len
++] = cv
->tab
[2];
2035 #error add long double size support
2044 /* add the current parse token in token string 's' */
2045 static void tok_str_add_tok(TokenString
*s
)
2049 /* save line number info */
2050 if (file
->line_num
!= s
->last_line_num
) {
2051 s
->last_line_num
= file
->line_num
;
2052 cval
.i
= s
->last_line_num
;
2053 tok_str_add2(s
, TOK_LINENUM
, &cval
);
2055 tok_str_add2(s
, tok
, &tokc
);
2058 #if LDOUBLE_SIZE == 12
2059 #define LDOUBLE_GET(p, cv) \
2064 #error add long double size support
2068 /* get a token from an integer array and increment pointer
2069 accordingly. we code it as a macro to avoid pointer aliasing. */
2070 #define TOK_GET(t, p, cv) \
2092 case TOK_CLDOUBLE: \
2093 LDOUBLE_GET(p, cv); \
2094 p += LDOUBLE_SIZE / 4; \
2101 /* defines handling */
2102 static inline void define_push(int v
, int macro_type
, int *str
, Sym
*first_arg
)
2106 s
= sym_push2(&define_stack
, v
, macro_type
, (int)str
);
2107 s
->next
= first_arg
;
2108 table_ident
[v
- TOK_IDENT
]->sym_define
= s
;
2111 /* undefined a define symbol. Its name is just set to zero */
2112 static void define_undef(Sym
*s
)
2116 if (v
>= TOK_IDENT
&& v
< tok_ident
)
2117 table_ident
[v
- TOK_IDENT
]->sym_define
= NULL
;
2121 static inline Sym
*define_find(int v
)
2124 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
2126 return table_ident
[v
]->sym_define
;
2129 /* free define stack until top reaches 'b' */
2130 static void free_defines(Sym
*b
)
2138 /* do not free args or predefined defines */
2140 tok_str_free((int *)top
->c
);
2142 if (v
>= TOK_IDENT
&& v
< tok_ident
)
2143 table_ident
[v
- TOK_IDENT
]->sym_define
= NULL
;
2151 static Sym
*label_find(int v
)
2154 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
2156 return table_ident
[v
]->sym_label
;
2159 static Sym
*label_push(int v
, int flags
)
2162 s
= sym_push2(&label_stack
, v
, 0, 0);
2164 table_ident
[v
- TOK_IDENT
]->sym_label
= s
;
2168 /* eval an expression for #if/#elif */
2169 static int expr_preprocess(void)
2175 while (tok
!= TOK_LINEFEED
&& tok
!= TOK_EOF
) {
2176 next(); /* do macro subst */
2177 if (tok
== TOK_DEFINED
) {
2182 c
= define_find(tok
) != 0;
2187 } else if (tok
>= TOK_IDENT
) {
2188 /* if undefined macro */
2192 tok_str_add_tok(&str
);
2194 tok_str_add(&str
, -1); /* simulate end of file */
2195 tok_str_add(&str
, 0);
2196 /* now evaluate C constant expression */
2197 macro_ptr
= str
.str
;
2201 tok_str_free(str
.str
);
2205 #if defined(PARSE_DEBUG) || defined(PP_DEBUG)
2206 static void tok_print(int *str
)
2212 TOK_GET(t
, str
, cval
);
2215 printf(" %s", get_tok_str(t
, &cval
));
2221 /* parse after #define */
2222 static void parse_define(void)
2224 Sym
*s
, *first
, **ps
;
2225 int v
, t
, varg
, is_vaargs
, c
;
2230 error("invalid macro name '%s'", get_tok_str(tok
, &tokc
));
2231 /* XXX: should check if same macro (ANSI) */
2234 /* '(' must be just after macro definition for MACRO_FUNC */
2235 c
= file
->buf_ptr
[0];
2237 c
= handle_stray1(file
->buf_ptr
);
2242 while (tok
!= ')') {
2246 if (varg
== TOK_DOTS
) {
2247 varg
= TOK___VA_ARGS__
;
2249 } else if (tok
== TOK_DOTS
&& gnu_ext
) {
2253 if (varg
< TOK_IDENT
)
2254 error("badly punctuated parameter list");
2255 s
= sym_push2(&define_stack
, varg
| SYM_FIELD
, is_vaargs
, 0);
2266 /* EOF testing necessary for '-D' handling */
2267 while (tok
!= TOK_LINEFEED
&& tok
!= TOK_EOF
) {
2268 tok_str_add2(&str
, tok
, &tokc
);
2271 tok_str_add(&str
, 0);
2273 printf("define %s %d: ", get_tok_str(v
, NULL
), t
);
2276 define_push(v
, t
, str
.str
, first
);
2279 /* XXX: use a token or a hash table to accelerate matching ? */
2280 static CachedInclude
*search_cached_include(TCCState
*s1
,
2281 int type
, const char *filename
)
2286 for(i
= 0;i
< s1
->nb_cached_includes
; i
++) {
2287 e
= s1
->cached_includes
[i
];
2288 if (e
->type
== type
&& !strcmp(e
->filename
, filename
))
2294 static inline void add_cached_include(TCCState
*s1
, int type
,
2295 const char *filename
, int ifndef_macro
)
2299 if (search_cached_include(s1
, type
, filename
))
2302 printf("adding cached '%s' %s\n", filename
, get_tok_str(ifndef_macro
, NULL
));
2304 e
= tcc_malloc(sizeof(CachedInclude
) + strlen(filename
));
2308 strcpy(e
->filename
, filename
);
2309 e
->ifndef_macro
= ifndef_macro
;
2310 dynarray_add((void ***)&s1
->cached_includes
, &s1
->nb_cached_includes
, e
);
2313 /* is_bof is true if first non space token at beginning of file */
2314 static void preprocess(int is_bof
)
2316 TCCState
*s1
= tcc_state
;
2318 char buf
[1024], *q
, *p
;
2324 return_linefeed
= 1; /* linefeed will be returned as a
2325 token. EOF is also returned as line feed */
2335 s
= define_find(tok
);
2336 /* undefine symbol by putting an invalid name */
2341 ch
= file
->buf_ptr
[0];
2342 /* XXX: incorrect if comments : use next_nomacro with a special mode */
2347 } else if (ch
== '\"') {
2350 /* XXX: better stray handling */
2353 while (ch
!= c
&& ch
!= '\n' && ch
!= CH_EOF
) {
2354 if ((q
- buf
) < sizeof(buf
) - 1)
2361 /* eat all spaces and comments after include */
2362 /* XXX: slightly incorrect */
2363 while (ch1
!= '\n' && ch1
!= CH_EOF
)
2367 /* computed #include : either we have only strings or
2368 we have anything enclosed in '<>' */
2371 if (tok
== TOK_STR
) {
2372 while (tok
!= TOK_LINEFEED
) {
2373 if (tok
!= TOK_STR
) {
2375 error("'#include' expects \"FILENAME\" or <FILENAME>");
2377 pstrcat(buf
, sizeof(buf
), (char *)tokc
.cstr
->data
);
2383 while (tok
!= TOK_LINEFEED
) {
2384 pstrcat(buf
, sizeof(buf
), get_tok_str(tok
, &tokc
));
2388 /* check syntax and remove '<>' */
2389 if (len
< 2 || buf
[0] != '<' || buf
[len
- 1] != '>')
2390 goto include_syntax
;
2391 memmove(buf
, buf
+ 1, len
- 2);
2392 buf
[len
- 2] = '\0';
2397 e
= search_cached_include(s1
, c
, buf
);
2398 if (e
&& define_find(e
->ifndef_macro
)) {
2399 /* no need to parse the include because the 'ifndef macro'
2402 printf("%s: skipping %s\n", file
->filename
, buf
);
2406 /* first search in current dir if "header.h" */
2408 p
= strrchr(file
->filename
, '/');
2410 size
= p
+ 1 - file
->filename
;
2411 if (size
> sizeof(buf1
) - 1)
2412 size
= sizeof(buf1
) - 1;
2413 memcpy(buf1
, file
->filename
, size
);
2415 pstrcat(buf1
, sizeof(buf1
), buf
);
2416 f
= tcc_open(s1
, buf1
);
2420 if (s1
->include_stack_ptr
>= s1
->include_stack
+ INCLUDE_STACK_SIZE
)
2421 error("#include recursion too deep");
2422 /* now search in all the include paths */
2423 n
= s1
->nb_include_paths
+ s1
->nb_sysinclude_paths
;
2424 for(i
= 0; i
< n
; i
++) {
2426 if (i
< s1
->nb_include_paths
)
2427 path
= s1
->include_paths
[i
];
2429 path
= s1
->sysinclude_paths
[i
- s1
->nb_include_paths
];
2430 pstrcpy(buf1
, sizeof(buf1
), path
);
2431 pstrcat(buf1
, sizeof(buf1
), "/");
2432 pstrcat(buf1
, sizeof(buf1
), buf
);
2433 f
= tcc_open(s1
, buf1
);
2437 error("include file '%s' not found", buf
);
2441 printf("%s: including %s\n", file
->filename
, buf1
);
2444 pstrcpy(f
->inc_filename
, sizeof(f
->inc_filename
), buf
);
2445 /* push current file in stack */
2446 /* XXX: fix current line init */
2447 *s1
->include_stack_ptr
++ = file
;
2449 /* add include file debug info */
2451 put_stabs(file
->filename
, N_BINCL
, 0, 0, 0);
2453 tok_flags
|= TOK_FLAG_BOF
| TOK_FLAG_BOL
;
2454 ch
= file
->buf_ptr
[0];
2462 c
= expr_preprocess();
2468 if (tok
< TOK_IDENT
)
2469 error("invalid argument for '#if%sdef'", c
? "n" : "");
2473 printf("#ifndef %s\n", get_tok_str(tok
, NULL
));
2475 file
->ifndef_macro
= tok
;
2478 c
= (define_find(tok
) != 0) ^ c
;
2480 if (s1
->ifdef_stack_ptr
>= s1
->ifdef_stack
+ IFDEF_STACK_SIZE
)
2481 error("memory full");
2482 *s1
->ifdef_stack_ptr
++ = c
;
2485 if (s1
->ifdef_stack_ptr
== s1
->ifdef_stack
)
2486 error("#else without matching #if");
2487 if (s1
->ifdef_stack_ptr
[-1] & 2)
2488 error("#else after #else");
2489 c
= (s1
->ifdef_stack_ptr
[-1] ^= 3);
2492 if (s1
->ifdef_stack_ptr
== s1
->ifdef_stack
)
2493 error("#elif without matching #if");
2494 c
= s1
->ifdef_stack_ptr
[-1];
2496 error("#elif after #else");
2497 /* last #if/#elif expression was true: we skip */
2500 c
= expr_preprocess();
2501 s1
->ifdef_stack_ptr
[-1] = c
;
2511 if (s1
->ifdef_stack_ptr
<= file
->ifdef_stack_ptr
)
2512 error("#endif without matching #if");
2513 s1
->ifdef_stack_ptr
--;
2514 /* '#ifndef macro' was at the start of file. Now we check if
2515 an '#endif' is exactly at the end of file */
2516 if (file
->ifndef_macro
&&
2517 s1
->ifdef_stack_ptr
== file
->ifdef_stack_ptr
) {
2518 file
->ifndef_macro_saved
= file
->ifndef_macro
;
2519 /* need to set to zero to avoid false matches if another
2520 #ifndef at middle of file */
2521 file
->ifndef_macro
= 0;
2522 while (tok
!= TOK_LINEFEED
)
2524 tok_flags
|= TOK_FLAG_ENDIF
;
2530 if (tok
!= TOK_CINT
)
2532 file
->line_num
= tokc
.i
- 1; /* the line number will be incremented after */
2534 if (tok
!= TOK_LINEFEED
) {
2537 pstrcpy(file
->filename
, sizeof(file
->filename
),
2538 (char *)tokc
.cstr
->data
);
2544 ch
= file
->buf_ptr
[0];
2547 while (ch
!= '\n' && ch
!= CH_EOF
) {
2548 if ((q
- buf
) < sizeof(buf
) - 1)
2554 error("#error %s", buf
);
2556 warning("#warning %s", buf
);
2562 if (tok
== TOK_LINEFEED
|| tok
== '!' || tok
== TOK_CINT
) {
2563 /* '!' is ignored to allow C scripts. numbers are ignored
2564 to emulate cpp behaviour */
2566 error("invalid preprocessing directive #%s", get_tok_str(tok
, &tokc
));
2570 /* ignore other preprocess commands or #! for C scripts */
2571 while (tok
!= TOK_LINEFEED
)
2574 return_linefeed
= 0;
2577 /* read a number in base b */
2578 static int getn(int b
)
2583 if (ch
>= 'a' && ch
<= 'f')
2585 else if (ch
>= 'A' && ch
<= 'F')
2591 if (t
< 0 || t
>= b
)
2599 /* read a character for string or char constant and eval escape codes */
2600 static int getq(void)
2609 case '0': case '1': case '2': case '3':
2610 case '4': case '5': case '6': case '7':
2611 /* at most three octal digits */
2615 c
= c
* 8 + ch
- '0';
2618 c
= c
* 8 + ch
- '0';
2649 goto invalid_escape
;
2664 goto invalid_escape
;
2669 error("invalid escaped char");
2672 } else if (c
== '\r' && ch
== '\n') {
2679 /* we use 64 bit numbers */
2682 /* bn = (bn << shift) | or_val */
2683 void bn_lshift(unsigned int *bn
, int shift
, int or_val
)
2687 for(i
=0;i
<BN_SIZE
;i
++) {
2689 bn
[i
] = (v
<< shift
) | or_val
;
2690 or_val
= v
>> (32 - shift
);
2694 void bn_zero(unsigned int *bn
)
2697 for(i
=0;i
<BN_SIZE
;i
++) {
2702 /* parse number in null terminated string 'p' and return it in the
2704 void parse_number(const char *p
)
2706 int b
, t
, shift
, frac_bits
, s
, exp_val
, ch
;
2708 unsigned int bn
[BN_SIZE
];
2719 goto float_frac_parse
;
2720 } else if (t
== '0') {
2721 if (ch
== 'x' || ch
== 'X') {
2725 } else if (tcc_ext
&& (ch
== 'b' || ch
== 'B')) {
2731 /* parse all digits. cannot check octal numbers at this stage
2732 because of floating point constants */
2734 if (ch
>= 'a' && ch
<= 'f')
2736 else if (ch
>= 'A' && ch
<= 'F')
2744 if (q
>= token_buf
+ STRING_MAX_SIZE
) {
2746 error("number too long");
2752 ((ch
== 'e' || ch
== 'E') && b
== 10) ||
2753 ((ch
== 'p' || ch
== 'P') && (b
== 16 || b
== 2))) {
2755 /* NOTE: strtox should support that for hexa numbers, but
2756 non ISOC99 libcs do not support it, so we prefer to do
2758 /* hexadecimal or binary floats */
2759 /* XXX: handle overflows */
2771 } else if (t
>= 'a') {
2773 } else if (t
>= 'A') {
2778 bn_lshift(bn
, shift
, t
);
2785 if (t
>= 'a' && t
<= 'f') {
2787 } else if (t
>= 'A' && t
<= 'F') {
2789 } else if (t
>= '0' && t
<= '9') {
2795 error("invalid digit");
2796 bn_lshift(bn
, shift
, t
);
2801 if (ch
!= 'p' && ch
!= 'P')
2808 } else if (ch
== '-') {
2812 if (ch
< '0' || ch
> '9')
2813 expect("exponent digits");
2814 while (ch
>= '0' && ch
<= '9') {
2815 exp_val
= exp_val
* 10 + ch
- '0';
2818 exp_val
= exp_val
* s
;
2820 /* now we can generate the number */
2821 /* XXX: should patch directly float number */
2822 d
= (double)bn
[1] * 4294967296.0 + (double)bn
[0];
2823 d
= ldexp(d
, exp_val
- frac_bits
);
2828 /* float : should handle overflow */
2830 } else if (t
== 'L') {
2833 /* XXX: not large enough */
2834 tokc
.ld
= (long double)d
;
2840 /* decimal floats */
2842 if (q
>= token_buf
+ STRING_MAX_SIZE
)
2847 while (ch
>= '0' && ch
<= '9') {
2848 if (q
>= token_buf
+ STRING_MAX_SIZE
)
2854 if (ch
== 'e' || ch
== 'E') {
2855 if (q
>= token_buf
+ STRING_MAX_SIZE
)
2859 if (ch
== '-' || ch
== '+') {
2860 if (q
>= token_buf
+ STRING_MAX_SIZE
)
2865 if (ch
< '0' || ch
> '9')
2866 expect("exponent digits");
2867 while (ch
>= '0' && ch
<= '9') {
2868 if (q
>= token_buf
+ STRING_MAX_SIZE
)
2880 tokc
.f
= strtof(token_buf
, NULL
);
2881 } else if (t
== 'L') {
2884 tokc
.ld
= strtold(token_buf
, NULL
);
2887 tokc
.d
= strtod(token_buf
, NULL
);
2891 unsigned long long n
, n1
;
2894 /* integer number */
2897 if (b
== 10 && *q
== '0') {
2904 /* no need for checks except for base 10 / 8 errors */
2907 } else if (t
>= 'a') {
2909 } else if (t
>= 'A') {
2914 error("invalid digit");
2918 /* detect overflow */
2919 /* XXX: this test is not reliable */
2921 error("integer constant overflow");
2924 /* XXX: not exactly ANSI compliant */
2925 if ((n
& 0xffffffff00000000LL
) != 0) {
2930 } else if (n
> 0x7fffffff) {
2941 error("three 'l's in integer constant");
2944 if (tok
== TOK_CINT
)
2946 else if (tok
== TOK_CUINT
)
2950 } else if (t
== 'U') {
2952 error("two 'u's in integer constant");
2954 if (tok
== TOK_CINT
)
2956 else if (tok
== TOK_CLLONG
)
2963 if (tok
== TOK_CINT
|| tok
== TOK_CUINT
)
2971 #define PARSE2(c1, tok1, c2, tok2) \
2982 /* return next token without macro substitution */
2983 static inline void next_nomacro1(void)
3003 /* first look if it is in fact an end of buffer */
3004 if (p
>= file
->buf_end
) {
3008 if (p
>= file
->buf_end
)
3021 TCCState
*s1
= tcc_state
;
3023 if (return_linefeed
) {
3025 } else if (s1
->include_stack_ptr
== s1
->include_stack
) {
3026 /* no include left : end of file */
3029 /* pop include file */
3031 /* test if previous '#endif' was after a #ifdef at
3033 if (tok_flags
& TOK_FLAG_ENDIF
) {
3035 printf("#endif %s\n", get_tok_str(file
->ifndef_macro_saved
, NULL
));
3037 add_cached_include(s1
, file
->inc_type
, file
->inc_filename
,
3038 file
->ifndef_macro_saved
);
3041 /* add end of include file debug info */
3043 put_stabd(N_EINCL
, 0, 0);
3045 /* pop include stack */
3047 s1
->include_stack_ptr
--;
3048 file
= *s1
->include_stack_ptr
;
3056 if (return_linefeed
) {
3060 tok_flags
|= TOK_FLAG_BOL
;
3069 if (tok_flags
& TOK_FLAG_BOL
) {
3071 preprocess(tok_flags
& TOK_FLAG_BOF
);
3077 tok
= TOK_TWOSHARPS
;
3084 case 'a': case 'b': case 'c': case 'd':
3085 case 'e': case 'f': case 'g': case 'h':
3086 case 'i': case 'j': case 'k': case 'l':
3087 case 'm': case 'n': case 'o': case 'p':
3088 case 'q': case 'r': case 's': case 't':
3089 case 'u': case 'v': case 'w': case 'x':
3091 case 'A': case 'B': case 'C': case 'D':
3092 case 'E': case 'F': case 'G': case 'H':
3093 case 'I': case 'J': case 'K':
3094 case 'M': case 'N': case 'O': case 'P':
3095 case 'Q': case 'R': case 'S': case 'T':
3096 case 'U': case 'V': case 'W': case 'X':
3102 h
= TOK_HASH_FUNC(h
, c
);
3106 if (!isid(c
) && !isnum(c
))
3108 h
= TOK_HASH_FUNC(h
, c
);
3115 /* fast case : no stray found, so we have the full token
3116 and we have already hashed it */
3118 h
&= (TOK_HASH_SIZE
- 1);
3119 pts
= &hash_ident
[h
];
3124 if (ts
->len
== len
&& !memcmp(ts
->str
, p1
, len
))
3126 pts
= &(ts
->hash_next
);
3128 ts
= tok_alloc_new(pts
, p1
, len
);
3132 cstr_reset(&tokcstr
);
3135 cstr_ccat(&tokcstr
, *p1
);
3141 while (isid(c
) || isnum(c
)) {
3142 cstr_ccat(&tokcstr
, c
);
3145 ts
= tok_alloc(tokcstr
.data
, tokcstr
.size
);
3151 if (t
!= '\\' && t
!= '\'' && t
!= '\"') {
3153 goto parse_ident_fast
;
3159 } else if (c
== '\"') {
3163 cstr_reset(&tokcstr
);
3164 cstr_ccat(&tokcstr
, 'L');
3165 goto parse_ident_slow
;
3169 case '0': case '1': case '2': case '3':
3170 case '4': case '5': case '6': case '7':
3173 cstr_reset(&tokcstr
);
3174 /* after the first digit, accept digits, alpha, '.' or sign if
3175 prefixed by 'eEpP' */
3179 cstr_ccat(&tokcstr
, c
);
3181 if (!(isnum(c
) || isid(c
) || c
== '.' ||
3182 ((c
== '+' || c
== '-') &&
3183 (t
== 'e' || t
== 'E' || t
== 'p' || t
== 'P'))))
3186 /* We add a trailing '\0' to ease parsing */
3187 cstr_ccat(&tokcstr
, '\0');
3188 tokc
.cstr
= &tokcstr
;
3192 /* special dot handling because it can also start a number */
3195 cstr_reset(&tokcstr
);
3196 cstr_ccat(&tokcstr
, '.');
3198 } else if (c
== '.') {
3214 /* this cast is needed if >= 128 */
3215 if (tok
== TOK_CCHAR
)
3219 error("unterminated character constant");
3228 cstr_reset(&tokcstr
);
3229 while (ch
!= '\"') {
3232 error("unterminated string");
3234 cstr_ccat(&tokcstr
, b
);
3236 cstr_wccat(&tokcstr
, b
);
3239 cstr_ccat(&tokcstr
, '\0');
3241 cstr_wccat(&tokcstr
, '\0');
3242 tokc
.cstr
= &tokcstr
;
3252 } else if (c
== '<') {
3270 } else if (c
== '>') {
3288 } else if (c
== '=') {
3301 } else if (c
== '=') {
3314 } else if (c
== '=') {
3327 } else if (c
== '=') {
3330 } else if (c
== '>') {
3338 PARSE2('!', '!', '=', TOK_NE
)
3339 PARSE2('=', '=', '=', TOK_EQ
)
3340 PARSE2('*', '*', '=', TOK_A_MUL
)
3341 PARSE2('%', '%', '=', TOK_A_MOD
)
3342 PARSE2('^', '^', '=', TOK_A_XOR
)
3344 /* comments or operator */
3352 } else if (c
== '/') {
3354 parse_line_comment();
3357 } else if (c
== '=') {
3381 error("unrecognized character \\x%02x", c
);
3386 #if defined(PARSE_DEBUG)
3387 printf("token = %s\n", get_tok_str(tok
, &tokc
));
3391 /* return next token without macro substitution. Can read input from
3393 static void next_nomacro(void)
3399 TOK_GET(tok
, macro_ptr
, tokc
);
3400 if (tok
== TOK_LINENUM
) {
3401 file
->line_num
= tokc
.i
;
3410 /* substitute args in macro_str and return allocated string */
3411 static int *macro_arg_subst(Sym
**nested_list
, int *macro_str
, Sym
*args
)
3413 int *st
, last_tok
, t
, notfirst
;
3422 TOK_GET(t
, macro_str
, cval
);
3427 TOK_GET(t
, macro_str
, cval
);
3430 s
= sym_find2(args
, t
);
3437 cstr_ccat(&cstr
, ' ');
3438 TOK_GET(t
, st
, cval
);
3439 cstr_cat(&cstr
, get_tok_str(t
, &cval
));
3442 cstr_ccat(&cstr
, '\0');
3444 printf("stringize: %s\n", (char *)cstr
.data
);
3448 tok_str_add2(&str
, TOK_STR
, &cval
);
3451 tok_str_add2(&str
, t
, &cval
);
3453 } else if (t
>= TOK_IDENT
) {
3454 s
= sym_find2(args
, t
);
3457 /* if '##' is present before or after, no arg substitution */
3458 if (*macro_str
== TOK_TWOSHARPS
|| last_tok
== TOK_TWOSHARPS
) {
3459 /* special case for var arg macros : ## eats the
3460 ',' if empty VA_ARGS variable. */
3461 /* XXX: test of the ',' is not 100%
3462 reliable. should fix it to avoid security
3464 if (gnu_ext
&& s
->type
.t
&&
3465 last_tok
== TOK_TWOSHARPS
&&
3466 str
.len
>= 2 && str
.str
[str
.len
- 2] == ',') {
3468 /* suppress ',' '##' */
3471 /* suppress '##' and add variable */
3479 TOK_GET(t1
, st
, cval
);
3482 tok_str_add2(&str
, t1
, &cval
);
3486 macro_subst(&str
, nested_list
, st
);
3489 tok_str_add(&str
, t
);
3492 tok_str_add2(&str
, t
, &cval
);
3496 tok_str_add(&str
, 0);
3500 /* handle the '##' operator */
3501 static int *macro_twosharps(void)
3506 const char *p1
, *p2
;
3508 TokenString macro_str1
;
3512 tok_str_new(¯o_str1
);
3518 while (*macro_ptr
== TOK_TWOSHARPS
) {
3520 macro_ptr1
= macro_ptr
;
3523 TOK_GET(t
, macro_ptr
, cval
);
3525 /* We concatenate the two tokens if we have an
3526 identifier or a preprocessing number */
3528 p1
= get_tok_str(tok
, &tokc
);
3529 cstr_cat(&cstr
, p1
);
3530 p2
= get_tok_str(t
, &cval
);
3531 cstr_cat(&cstr
, p2
);
3532 cstr_ccat(&cstr
, '\0');
3534 if ((tok
>= TOK_IDENT
|| tok
== TOK_PPNUM
) &&
3535 (t
>= TOK_IDENT
|| t
== TOK_PPNUM
)) {
3536 if (tok
== TOK_PPNUM
) {
3537 /* if number, then create a number token */
3538 /* NOTE: no need to allocate because
3539 tok_str_add2() does it */
3542 /* if identifier, we must do a test to
3543 validate we have a correct identifier */
3544 if (t
== TOK_PPNUM
) {
3554 if (!isnum(c
) && !isid(c
))
3558 ts
= tok_alloc(cstr
.data
, strlen(cstr
.data
));
3559 tok
= ts
->tok
; /* modify current token */
3562 const char *str
= cstr
.data
;
3563 const unsigned char *q
;
3565 /* we look for a valid token */
3566 /* XXX: do more extensive checks */
3567 if (!strcmp(str
, ">>=")) {
3569 } else if (!strcmp(str
, "<<=")) {
3571 } else if (strlen(str
) == 2) {
3572 /* search in two bytes table */
3577 if (q
[0] == str
[0] && q
[1] == str
[1])
3584 /* NOTE: because get_tok_str use a static buffer,
3587 p1
= get_tok_str(tok
, &tokc
);
3588 cstr_cat(&cstr
, p1
);
3589 cstr_ccat(&cstr
, '\0');
3590 p2
= get_tok_str(t
, &cval
);
3591 warning("pasting \"%s\" and \"%s\" does not give a valid preprocessing token", cstr
.data
, p2
);
3592 /* cannot merge tokens: just add them separately */
3593 tok_str_add2(¯o_str1
, tok
, &tokc
);
3594 /* XXX: free associated memory ? */
3601 tok_str_add2(¯o_str1
, tok
, &tokc
);
3604 tok_str_add(¯o_str1
, 0);
3605 return macro_str1
.str
;
3609 /* do macro substitution of current token with macro 's' and add
3610 result to (tok_str,tok_len). 'nested_list' is the list of all
3611 macros we got inside to avoid recursing. Return non zero if no
3612 substitution needs to be done */
3613 static int macro_subst_tok(TokenString
*tok_str
,
3614 Sym
**nested_list
, Sym
*s
)
3616 Sym
*args
, *sa
, *sa1
;
3617 int mstr_allocated
, parlevel
, *mstr
, t
;
3623 /* if symbol is a macro, prepare substitution */
3624 /* if nested substitution, do nothing */
3625 if (sym_find2(*nested_list
, tok
))
3628 /* special macros */
3629 if (tok
== TOK___LINE__
) {
3630 cval
.i
= file
->line_num
;
3631 tok_str_add2(tok_str
, TOK_CINT
, &cval
);
3632 } else if (tok
== TOK___FILE__
) {
3633 cstrval
= file
->filename
;
3635 tok_str_add2(tok_str
, TOK_STR
, &cval
);
3636 } else if (tok
== TOK___DATE__
) {
3637 cstrval
= "Jan 1 2002";
3639 } else if (tok
== TOK___TIME__
) {
3640 cstrval
= "00:00:00";
3643 cstr_cat(&cstr
, cstrval
);
3644 cstr_ccat(&cstr
, '\0');
3646 tok_str_add2(tok_str
, TOK_STR
, &cval
);
3651 if (s
->type
.t
== MACRO_FUNC
) {
3652 /* NOTE: we do not use next_nomacro to avoid eating the
3653 next token. XXX: find better solution */
3657 /* XXX: incorrect with comments */
3658 ch
= file
->buf_ptr
[0];
3659 while (is_space(ch
) || ch
== '\n')
3663 if (t
!= '(') /* no macro subst */
3666 /* argument macro */
3671 /* NOTE: empty args are allowed, except if no args */
3673 /* handle '()' case */
3674 if (!args
&& tok
== ')')
3677 error("macro '%s' used with too many args",
3678 get_tok_str(s
->v
, 0));
3681 /* NOTE: non zero sa->t indicates VA_ARGS */
3682 while ((parlevel
> 0 ||
3684 (tok
!= ',' || sa
->type
.t
))) &&
3688 else if (tok
== ')')
3690 tok_str_add2(&str
, tok
, &tokc
);
3693 tok_str_add(&str
, 0);
3694 sym_push2(&args
, sa
->v
& ~SYM_FIELD
, sa
->type
.t
, (int)str
.str
);
3697 /* special case for gcc var args: add an empty
3698 var arg argument if it is omitted */
3699 if (sa
&& sa
->type
.t
&& gnu_ext
)
3709 error("macro '%s' used with too few args",
3710 get_tok_str(s
->v
, 0));
3713 /* now subst each arg */
3714 mstr
= macro_arg_subst(nested_list
, mstr
, args
);
3719 tok_str_free((int *)sa
->c
);
3725 sym_push2(nested_list
, s
->v
, 0, 0);
3726 macro_subst(tok_str
, nested_list
, mstr
);
3727 /* pop nested defined symbol */
3729 *nested_list
= sa1
->prev
;
3737 /* do macro substitution of macro_str and add result to
3738 (tok_str,tok_len). 'nested_list' is the list of all macros we got
3739 inside to avoid recursing. */
3740 static void macro_subst(TokenString
*tok_str
,
3741 Sym
**nested_list
, int *macro_str
)
3744 int *saved_macro_ptr
;
3747 saved_macro_ptr
= macro_ptr
;
3748 macro_ptr
= macro_str
;
3749 /* first scan for '##' operator handling */
3750 macro_str1
= macro_twosharps();
3751 macro_ptr
= macro_str1
;
3757 s
= define_find(tok
);
3759 if (macro_subst_tok(tok_str
, nested_list
, s
) != 0)
3763 tok_str_add2(tok_str
, tok
, &tokc
);
3766 macro_ptr
= saved_macro_ptr
;
3767 tok_str_free(macro_str1
);
3770 /* return next token with macro substitution */
3771 static void next(void)
3773 Sym
*nested_list
, *s
;
3776 /* special 'ungettok' case for label parsing */
3785 /* if not reading from macro substituted string, then try
3786 to substitute macros */
3787 if (tok
>= TOK_IDENT
) {
3788 s
= define_find(tok
);
3790 /* we have a macro: we try to substitute */
3793 if (macro_subst_tok(&str
, &nested_list
, s
) == 0) {
3794 /* substitution done, NOTE: maybe empty */
3795 tok_str_add(&str
, 0);
3796 macro_ptr
= str
.str
;
3797 macro_ptr_allocated
= str
.str
;
3804 /* end of macro string: free it */
3805 tok_str_free(macro_ptr_allocated
);
3811 /* convert preprocessor tokens into C tokens */
3812 if (tok
== TOK_PPNUM
) {
3813 parse_number((char *)tokc
.cstr
->data
);
3818 void swap(int *p
, int *q
)
3826 void vsetc(CType
*type
, int r
, CValue
*vc
)
3830 if (vtop
>= vstack
+ VSTACK_SIZE
)
3831 error("memory full");
3832 /* cannot let cpu flags if other instruction are generated. Also
3833 avoid leaving VT_JMP anywhere except on the top of the stack
3834 because it would complicate the code generator. */
3835 if (vtop
>= vstack
) {
3836 v
= vtop
->r
& VT_VALMASK
;
3837 if (v
== VT_CMP
|| (v
& ~1) == VT_JMP
)
3843 vtop
->r2
= VT_CONST
;
3847 /* push integer constant */
3852 vsetc(&int_type
, VT_CONST
, &cval
);
3855 /* Return a static symbol pointing to a section */
3856 static Sym
*get_sym_ref(CType
*type
, Section
*sec
,
3857 unsigned long offset
, unsigned long size
)
3863 sym
= global_identifier_push(v
, type
->t
| VT_STATIC
, 0);
3864 sym
->type
.ref
= type
->ref
;
3865 sym
->r
= VT_CONST
| VT_SYM
;
3866 put_extern_sym(sym
, sec
, offset
, size
);
3870 /* push a reference to a section offset by adding a dummy symbol */
3871 static void vpush_ref(CType
*type
, Section
*sec
, unsigned long offset
, unsigned long size
)
3876 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
3877 vtop
->sym
= get_sym_ref(type
, sec
, offset
, size
);
3880 /* define a new external reference to a symbol 'v' of type 'u' */
3881 static Sym
*external_global_sym(int v
, CType
*type
, int r
)
3887 /* push forward reference */
3888 s
= global_identifier_push(v
, type
->t
| VT_EXTERN
, 0);
3889 s
->type
.ref
= type
->ref
;
3890 s
->r
= r
| VT_CONST
| VT_SYM
;
3895 /* define a new external reference to a symbol 'v' of type 'u' */
3896 static Sym
*external_sym(int v
, CType
*type
, int r
)
3902 /* push forward reference */
3903 s
= sym_push(v
, type
, r
| VT_CONST
| VT_SYM
, 0);
3904 s
->type
.t
|= VT_EXTERN
;
3909 /* push a reference to global symbol v */
3910 static void vpush_global_sym(CType
*type
, int v
)
3915 sym
= external_global_sym(v
, type
, 0);
3917 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
3921 void vset(CType
*type
, int r
, int v
)
3926 vsetc(type
, r
, &cval
);
3929 void vseti(int r
, int v
)
3945 void vpushv(SValue
*v
)
3947 if (vtop
>= vstack
+ VSTACK_SIZE
)
3948 error("memory full");
3958 /* save r to the memory stack, and mark it as being free */
3959 void save_reg(int r
)
3961 int l
, saved
, size
, align
;
3965 /* modify all stack values */
3968 for(p
=vstack
;p
<=vtop
;p
++) {
3969 if ((p
->r
& VT_VALMASK
) == r
||
3970 (p
->r2
& VT_VALMASK
) == r
) {
3971 /* must save value on stack if not already done */
3973 /* NOTE: must reload 'r' because r might be equal to r2 */
3974 r
= p
->r
& VT_VALMASK
;
3975 /* store register in the stack */
3977 if ((p
->r
& VT_LVAL
) ||
3978 (!is_float(type
->t
) && (type
->t
& VT_BTYPE
) != VT_LLONG
))
3980 size
= type_size(type
, &align
);
3981 loc
= (loc
- size
) & -align
;
3982 sv
.type
.t
= type
->t
;
3983 sv
.r
= VT_LOCAL
| VT_LVAL
;
3986 #ifdef TCC_TARGET_I386
3987 /* x86 specific: need to pop fp register ST0 if saved */
3989 o(0xd9dd); /* fstp %st(1) */
3992 /* special long long case */
3993 if ((type
->t
& VT_BTYPE
) == VT_LLONG
) {
4000 /* mark that stack entry as being saved on the stack */
4001 if (p
->r
& VT_LVAL
) {
4002 /* also suppress the bounded flag because the
4003 relocation address of the function was stored in
4005 p
->r
= (p
->r
& ~(VT_VALMASK
| VT_BOUNDED
)) | VT_LLOCAL
;
4007 p
->r
= lvalue_type(p
->type
.t
) | VT_LOCAL
;
4015 /* find a free register of class 'rc'. If none, save one register */
4021 /* find a free register */
4022 for(r
=0;r
<NB_REGS
;r
++) {
4023 if (reg_classes
[r
] & rc
) {
4024 for(p
=vstack
;p
<=vtop
;p
++) {
4025 if ((p
->r
& VT_VALMASK
) == r
||
4026 (p
->r2
& VT_VALMASK
) == r
)
4034 /* no register left : free the first one on the stack (VERY
4035 IMPORTANT to start from the bottom to ensure that we don't
4036 spill registers used in gen_opi()) */
4037 for(p
=vstack
;p
<=vtop
;p
++) {
4038 r
= p
->r
& VT_VALMASK
;
4039 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
))
4041 /* also look at second register (if long long) */
4042 r
= p
->r2
& VT_VALMASK
;
4043 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
)) {
4049 /* Should never comes here */
4053 /* save registers up to (vtop - n) stack entry */
4054 void save_regs(int n
)
4059 for(p
= vstack
;p
<= p1
; p
++) {
4060 r
= p
->r
& VT_VALMASK
;
4067 /* move register 's' to 'r', and flush previous value of r to memory
4069 void move_reg(int r
, int s
)
4082 /* get address of vtop (vtop MUST BE an lvalue) */
4085 vtop
->r
&= ~VT_LVAL
;
4086 /* tricky: if saved lvalue, then we can go back to lvalue */
4087 if ((vtop
->r
& VT_VALMASK
) == VT_LLOCAL
)
4088 vtop
->r
= (vtop
->r
& ~(VT_VALMASK
| VT_LVAL_TYPE
)) | VT_LOCAL
| VT_LVAL
;
4091 #ifdef CONFIG_TCC_BCHECK
4092 /* generate lvalue bound code */
4098 vtop
->r
&= ~VT_MUSTBOUND
;
4099 /* if lvalue, then use checking code before dereferencing */
4100 if (vtop
->r
& VT_LVAL
) {
4101 /* if not VT_BOUNDED value, then make one */
4102 if (!(vtop
->r
& VT_BOUNDED
)) {
4103 lval_type
= vtop
->r
& (VT_LVAL_TYPE
| VT_LVAL
);
4104 /* must save type because we must set it to int to get pointer */
4106 vtop
->type
.t
= VT_INT
;
4109 gen_bounded_ptr_add();
4110 vtop
->r
|= lval_type
;
4113 /* then check for dereferencing */
4114 gen_bounded_ptr_deref();
4119 /* store vtop a register belonging to class 'rc'. lvalues are
4120 converted to values. Cannot be used if cannot be converted to
4121 register value (such as structures). */
4124 int r
, r2
, rc2
, bit_pos
, bit_size
, size
, align
, i
;
4125 unsigned long long ll
;
4127 /* NOTE: get_reg can modify vstack[] */
4128 if (vtop
->type
.t
& VT_BITFIELD
) {
4129 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4130 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
4131 /* remove bit field info to avoid loops */
4132 vtop
->type
.t
&= ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
4133 /* generate shifts */
4134 vpushi(32 - (bit_pos
+ bit_size
));
4136 vpushi(32 - bit_size
);
4137 /* NOTE: transformed to SHR if unsigned */
4141 if (is_float(vtop
->type
.t
) &&
4142 (vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
4145 unsigned long offset
;
4147 /* XXX: unify with initializers handling ? */
4148 /* CPUs usually cannot use float constants, so we store them
4149 generically in data segment */
4150 size
= type_size(&vtop
->type
, &align
);
4151 offset
= (data_section
->data_offset
+ align
- 1) & -align
;
4152 data_section
->data_offset
= offset
;
4153 /* XXX: not portable yet */
4154 ptr
= section_ptr_add(data_section
, size
);
4157 ptr
[i
] = vtop
->c
.tab
[i
];
4158 sym
= get_sym_ref(&vtop
->type
, data_section
, offset
, size
<< 2);
4159 vtop
->r
|= VT_LVAL
| VT_SYM
;
4163 #ifdef CONFIG_TCC_BCHECK
4164 if (vtop
->r
& VT_MUSTBOUND
)
4168 r
= vtop
->r
& VT_VALMASK
;
4169 /* need to reload if:
4171 - lvalue (need to dereference pointer)
4172 - already a register, but not in the right class */
4173 if (r
>= VT_CONST
||
4174 (vtop
->r
& VT_LVAL
) ||
4175 !(reg_classes
[r
] & rc
) ||
4176 ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
&&
4177 !(reg_classes
[vtop
->r2
] & rc
))) {
4179 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
4180 /* two register type load : expand to two words
4182 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
4185 vtop
->c
.ui
= ll
; /* first word */
4187 vtop
->r
= r
; /* save register value */
4188 vpushi(ll
>> 32); /* second word */
4189 } else if (r
>= VT_CONST
||
4190 (vtop
->r
& VT_LVAL
)) {
4191 /* load from memory */
4194 vtop
[-1].r
= r
; /* save register value */
4195 /* increment pointer to get second word */
4196 vtop
->type
.t
= VT_INT
;
4202 /* move registers */
4205 vtop
[-1].r
= r
; /* save register value */
4206 vtop
->r
= vtop
[-1].r2
;
4208 /* allocate second register */
4215 /* write second register */
4217 } else if ((vtop
->r
& VT_LVAL
) && !is_float(vtop
->type
.t
)) {
4219 /* lvalue of scalar type : need to use lvalue type
4220 because of possible cast */
4223 /* compute memory access type */
4224 if (vtop
->r
& VT_LVAL_BYTE
)
4226 else if (vtop
->r
& VT_LVAL_SHORT
)
4228 if (vtop
->r
& VT_LVAL_UNSIGNED
)
4232 /* restore wanted type */
4235 /* one register type load */
4244 /* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
4245 void gv2(int rc1
, int rc2
)
4249 /* generate more generic register first. But VT_JMP or VT_CMP
4250 values must be generated first in all cases to avoid possible
4252 v
= vtop
[0].r
& VT_VALMASK
;
4253 if (v
!= VT_CMP
&& (v
& ~1) != VT_JMP
&& rc1
<= rc2
) {
4258 /* test if reload is needed for first register */
4259 if ((vtop
[-1].r
& VT_VALMASK
) >= VT_CONST
) {
4269 /* test if reload is needed for first register */
4270 if ((vtop
[0].r
& VT_VALMASK
) >= VT_CONST
) {
4276 /* expand long long on stack in two int registers */
4281 u
= vtop
->type
.t
& VT_UNSIGNED
;
4284 vtop
[0].r
= vtop
[-1].r2
;
4285 vtop
[0].r2
= VT_CONST
;
4286 vtop
[-1].r2
= VT_CONST
;
4287 vtop
[0].type
.t
= VT_INT
| u
;
4288 vtop
[-1].type
.t
= VT_INT
| u
;
4291 /* build a long long from two ints */
4294 gv2(RC_INT
, RC_INT
);
4295 vtop
[-1].r2
= vtop
[0].r
;
4296 vtop
[-1].type
.t
= t
;
4300 /* rotate n first stack elements to the bottom */
4307 for(i
=-n
+1;i
!=0;i
++)
4308 vtop
[i
] = vtop
[i
+1];
4312 /* pop stack value */
4316 v
= vtop
->r
& VT_VALMASK
;
4317 #ifdef TCC_TARGET_I386
4318 /* for x86, we need to pop the FP stack */
4319 if (v
== REG_ST0
&& !nocode_wanted
) {
4320 o(0xd9dd); /* fstp %st(1) */
4323 if (v
== VT_JMP
|| v
== VT_JMPI
) {
4324 /* need to put correct jump if && or || without test */
4330 /* convert stack entry to register and duplicate its value in another
4338 if ((t
& VT_BTYPE
) == VT_LLONG
) {
4345 /* stack: H L L1 H1 */
4353 /* duplicate value */
4364 load(r1
, &sv
); /* move r to r1 */
4366 /* duplicates value */
4371 /* generate CPU independent (unsigned) long long operations */
4372 void gen_opl(int op
)
4374 int t
, a
, b
, op1
, c
, i
;
4382 func
= TOK___divdi3
;
4385 func
= TOK___udivdi3
;
4388 func
= TOK___moddi3
;
4391 func
= TOK___umoddi3
;
4393 /* call generic long long function */
4394 gfunc_start(&gf
, FUNC_CDECL
);
4397 vpush_global_sym(&func_old_type
, func
);
4401 vtop
->r2
= REG_LRET
;
4414 /* stack: L1 H1 L2 H2 */
4419 vtop
[-2] = vtop
[-3];
4422 /* stack: H1 H2 L1 L2 */
4428 /* stack: H1 H2 L1 L2 ML MH */
4431 /* stack: ML MH H1 H2 L1 L2 */
4435 /* stack: ML MH H1 L2 H2 L1 */
4440 /* stack: ML MH M1 M2 */
4443 } else if (op
== '+' || op
== '-') {
4444 /* XXX: add non carry method too (for MIPS or alpha) */
4450 /* stack: H1 H2 (L1 op L2) */
4453 gen_op(op1
+ 1); /* TOK_xxxC2 */
4456 /* stack: H1 H2 (L1 op L2) */
4459 /* stack: (L1 op L2) H1 H2 */
4461 /* stack: (L1 op L2) (H1 op H2) */
4469 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
4470 t
= vtop
[-1].type
.t
;
4474 /* stack: L H shift */
4476 /* constant: simpler */
4477 /* NOTE: all comments are for SHL. the other cases are
4478 done by swaping words */
4489 if (op
!= TOK_SAR
) {
4522 /* XXX: should provide a faster fallback on x86 ? */
4525 func
= TOK___sardi3
;
4528 func
= TOK___shrdi3
;
4531 func
= TOK___shldi3
;
4537 /* compare operations */
4543 /* stack: L1 H1 L2 H2 */
4545 vtop
[-1] = vtop
[-2];
4547 /* stack: L1 L2 H1 H2 */
4550 /* when values are equal, we need to compare low words. since
4551 the jump is inverted, we invert the test too. */
4554 else if (op1
== TOK_GT
)
4556 else if (op1
== TOK_ULT
)
4558 else if (op1
== TOK_UGT
)
4563 if (op1
!= TOK_NE
) {
4567 /* generate non equal test */
4568 /* XXX: NOT PORTABLE yet */
4572 #ifdef TCC_TARGET_I386
4573 b
= psym(0x850f, 0);
4575 error("not implemented");
4579 /* compare low. Always unsigned */
4583 else if (op1
== TOK_LE
)
4585 else if (op1
== TOK_GT
)
4587 else if (op1
== TOK_GE
)
4597 /* handle integer constant optimizations and various machine
4599 void gen_opic(int op
)
4606 /* currently, we cannot do computations with forward symbols */
4607 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
4608 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
4612 case '+': v1
->c
.i
+= fc
; break;
4613 case '-': v1
->c
.i
-= fc
; break;
4614 case '&': v1
->c
.i
&= fc
; break;
4615 case '^': v1
->c
.i
^= fc
; break;
4616 case '|': v1
->c
.i
|= fc
; break;
4617 case '*': v1
->c
.i
*= fc
; break;
4624 /* if division by zero, generate explicit division */
4627 error("division by zero in constant");
4631 default: v1
->c
.i
/= fc
; break;
4632 case '%': v1
->c
.i
%= fc
; break;
4633 case TOK_UDIV
: v1
->c
.i
= (unsigned)v1
->c
.i
/ fc
; break;
4634 case TOK_UMOD
: v1
->c
.i
= (unsigned)v1
->c
.i
% fc
; break;
4637 case TOK_SHL
: v1
->c
.i
<<= fc
; break;
4638 case TOK_SHR
: v1
->c
.i
= (unsigned)v1
->c
.i
>> fc
; break;
4639 case TOK_SAR
: v1
->c
.i
>>= fc
; break;
4641 case TOK_ULT
: v1
->c
.i
= (unsigned)v1
->c
.i
< (unsigned)fc
; break;
4642 case TOK_UGE
: v1
->c
.i
= (unsigned)v1
->c
.i
>= (unsigned)fc
; break;
4643 case TOK_EQ
: v1
->c
.i
= v1
->c
.i
== fc
; break;
4644 case TOK_NE
: v1
->c
.i
= v1
->c
.i
!= fc
; break;
4645 case TOK_ULE
: v1
->c
.i
= (unsigned)v1
->c
.i
<= (unsigned)fc
; break;
4646 case TOK_UGT
: v1
->c
.i
= (unsigned)v1
->c
.i
> (unsigned)fc
; break;
4647 case TOK_LT
: v1
->c
.i
= v1
->c
.i
< fc
; break;
4648 case TOK_GE
: v1
->c
.i
= v1
->c
.i
>= fc
; break;
4649 case TOK_LE
: v1
->c
.i
= v1
->c
.i
<= fc
; break;
4650 case TOK_GT
: v1
->c
.i
= v1
->c
.i
> fc
; break;
4652 case TOK_LAND
: v1
->c
.i
= v1
->c
.i
&& fc
; break;
4653 case TOK_LOR
: v1
->c
.i
= v1
->c
.i
|| fc
; break;
4659 /* if commutative ops, put c2 as constant */
4660 if (c1
&& (op
== '+' || op
== '&' || op
== '^' ||
4661 op
== '|' || op
== '*')) {
4666 if (c2
&& (((op
== '*' || op
== '/' || op
== TOK_UDIV
||
4669 ((op
== '+' || op
== '-' || op
== '|' || op
== '^' ||
4670 op
== TOK_SHL
|| op
== TOK_SHR
|| op
== TOK_SAR
) &&
4676 } else if (c2
&& (op
== '*' || op
== TOK_PDIV
|| op
== TOK_UDIV
)) {
4677 /* try to use shifts instead of muls or divs */
4678 if (fc
> 0 && (fc
& (fc
- 1)) == 0) {
4687 else if (op
== TOK_PDIV
)
4693 } else if (c2
&& (op
== '+' || op
== '-') &&
4694 (vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) ==
4695 (VT_CONST
| VT_SYM
)) {
4696 /* symbol + constant case */
4703 if (!nocode_wanted
) {
4704 /* call low level op generator */
4713 /* generate a floating point operation with constant propagation */
4714 void gen_opif(int op
)
4722 /* currently, we cannot do computations with forward symbols */
4723 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
4724 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
4726 if (v1
->type
.t
== VT_FLOAT
) {
4729 } else if (v1
->type
.t
== VT_DOUBLE
) {
4737 /* NOTE: we only do constant propagation if finite number (not
4738 NaN or infinity) (ANSI spec) */
4739 if (!ieee_finite(f1
) || !ieee_finite(f2
))
4743 case '+': f1
+= f2
; break;
4744 case '-': f1
-= f2
; break;
4745 case '*': f1
*= f2
; break;
4749 error("division by zero in constant");
4754 /* XXX: also handles tests ? */
4758 /* XXX: overflow test ? */
4759 if (v1
->type
.t
== VT_FLOAT
) {
4761 } else if (v1
->type
.t
== VT_DOUBLE
) {
4769 if (!nocode_wanted
) {
4777 static int pointed_size(CType
*type
)
4780 return type_size(pointed_type(type
), &align
);
4784 void check_pointer_types(SValue
*p1
, SValue
*p2
)
4786 char buf1
[256], buf2
[256];
4790 if (!is_compatible_types(t1
, t2
)) {
4791 type_to_str(buf1
, sizeof(buf1
), t1
, NULL
);
4792 type_to_str(buf2
, sizeof(buf2
), t2
, NULL
);
4793 error("incompatible pointers '%s' and '%s'", buf1
, buf2
);
4798 /* generic gen_op: handles types problems */
4801 int u
, t1
, t2
, bt1
, bt2
, t
;
4804 t1
= vtop
[-1].type
.t
;
4805 t2
= vtop
[0].type
.t
;
4806 bt1
= t1
& VT_BTYPE
;
4807 bt2
= t2
& VT_BTYPE
;
4809 if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
4810 /* at least one operand is a pointer */
4811 /* relationnal op: must be both pointers */
4812 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
4813 // check_pointer_types(vtop, vtop - 1);
4814 /* pointers are handled are unsigned */
4815 t
= VT_INT
| VT_UNSIGNED
;
4818 /* if both pointers, then it must be the '-' op */
4819 if (bt1
== VT_PTR
&& bt2
== VT_PTR
) {
4821 error("cannot use pointers here");
4822 // check_pointer_types(vtop - 1, vtop);
4823 /* XXX: check that types are compatible */
4824 u
= pointed_size(&vtop
[-1].type
);
4826 /* set to integer type */
4827 vtop
->type
.t
= VT_INT
;
4831 /* exactly one pointer : must be '+' or '-'. */
4832 if (op
!= '-' && op
!= '+')
4833 error("cannot use pointers here");
4834 /* Put pointer as first operand */
4835 if (bt2
== VT_PTR
) {
4839 type1
= vtop
[-1].type
;
4840 /* XXX: cast to int ? (long long case) */
4841 vpushi(pointed_size(&vtop
[-1].type
));
4843 #ifdef CONFIG_TCC_BCHECK
4844 /* if evaluating constant expression, no code should be
4845 generated, so no bound check */
4846 if (do_bounds_check
&& !const_wanted
) {
4847 /* if bounded pointers, we generate a special code to
4854 gen_bounded_ptr_add();
4860 /* put again type if gen_opic() swaped operands */
4863 } else if (is_float(bt1
) || is_float(bt2
)) {
4864 /* compute bigger type and do implicit casts */
4865 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
4867 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
4872 /* floats can only be used for a few operations */
4873 if (op
!= '+' && op
!= '-' && op
!= '*' && op
!= '/' &&
4874 (op
< TOK_ULT
|| op
> TOK_GT
))
4875 error("invalid operands for binary operation");
4877 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
4878 /* cast to biggest op */
4880 /* convert to unsigned if it does not fit in a long long */
4881 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
4882 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
4886 /* integer operations */
4888 /* convert to unsigned if it does not fit in an integer */
4889 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
4890 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
4893 /* XXX: currently, some unsigned operations are explicit, so
4894 we modify them here */
4895 if (t
& VT_UNSIGNED
) {
4902 else if (op
== TOK_LT
)
4904 else if (op
== TOK_GT
)
4906 else if (op
== TOK_LE
)
4908 else if (op
== TOK_GE
)
4915 /* special case for shifts and long long: we keep the shift as
4917 if (op
== TOK_SHR
|| op
== TOK_SAR
|| op
== TOK_SHL
)
4922 else if ((t
& VT_BTYPE
) == VT_LLONG
)
4926 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
4927 /* relationnal op: the result is an int */
4928 vtop
->type
.t
= VT_INT
;
4935 /* generic itof for unsigned long long case */
4936 void gen_cvt_itof1(int t
)
4940 if ((vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
)) ==
4941 (VT_LLONG
| VT_UNSIGNED
)) {
4943 gfunc_start(&gf
, FUNC_CDECL
);
4946 vpush_global_sym(&func_old_type
, TOK___ulltof
);
4947 else if (t
== VT_DOUBLE
)
4948 vpush_global_sym(&func_old_type
, TOK___ulltod
);
4950 vpush_global_sym(&func_old_type
, TOK___ulltold
);
4959 /* generic ftoi for unsigned long long case */
4960 void gen_cvt_ftoi1(int t
)
4965 if (t
== (VT_LLONG
| VT_UNSIGNED
)) {
4966 /* not handled natively */
4967 gfunc_start(&gf
, FUNC_CDECL
);
4968 st
= vtop
->type
.t
& VT_BTYPE
;
4971 vpush_global_sym(&func_old_type
, TOK___fixunssfdi
);
4972 else if (st
== VT_DOUBLE
)
4973 vpush_global_sym(&func_old_type
, TOK___fixunsdfdi
);
4975 vpush_global_sym(&func_old_type
, TOK___fixunsxfdi
);
4979 vtop
->r2
= REG_LRET
;
4985 /* force char or short cast */
4986 void force_charshort_cast(int t
)
4990 /* XXX: add optimization if lvalue : just change type and offset */
4995 if (t
& VT_UNSIGNED
) {
4996 vpushi((1 << bits
) - 1);
5007 /* cast 'vtop' to 'type' */
5008 static void gen_cast(CType
*type
)
5010 int sbt
, dbt
, sf
, df
, c
;
5012 /* special delayed cast for char/short */
5013 /* XXX: in some cases (multiple cascaded casts), it may still
5015 if (vtop
->r
& VT_MUSTCAST
) {
5016 vtop
->r
&= ~VT_MUSTCAST
;
5017 force_charshort_cast(vtop
->type
.t
);
5020 dbt
= type
->t
& (VT_BTYPE
| VT_UNSIGNED
);
5021 sbt
= vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
);
5023 if (sbt
!= dbt
&& !nocode_wanted
) {
5026 c
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5028 /* convert from fp to fp */
5030 /* constant case: we can do it now */
5031 /* XXX: in ISOC, cannot do it if error in convert */
5032 if (dbt
== VT_FLOAT
&& sbt
== VT_DOUBLE
)
5033 vtop
->c
.f
= (float)vtop
->c
.d
;
5034 else if (dbt
== VT_FLOAT
&& sbt
== VT_LDOUBLE
)
5035 vtop
->c
.f
= (float)vtop
->c
.ld
;
5036 else if (dbt
== VT_DOUBLE
&& sbt
== VT_FLOAT
)
5037 vtop
->c
.d
= (double)vtop
->c
.f
;
5038 else if (dbt
== VT_DOUBLE
&& sbt
== VT_LDOUBLE
)
5039 vtop
->c
.d
= (double)vtop
->c
.ld
;
5040 else if (dbt
== VT_LDOUBLE
&& sbt
== VT_FLOAT
)
5041 vtop
->c
.ld
= (long double)vtop
->c
.f
;
5042 else if (dbt
== VT_LDOUBLE
&& sbt
== VT_DOUBLE
)
5043 vtop
->c
.ld
= (long double)vtop
->c
.d
;
5045 /* non constant case: generate code */
5049 /* convert int to fp */
5052 case VT_LLONG
| VT_UNSIGNED
:
5054 /* XXX: add const cases for long long */
5056 case VT_INT
| VT_UNSIGNED
:
5058 case VT_FLOAT
: vtop
->c
.f
= (float)vtop
->c
.ui
; break;
5059 case VT_DOUBLE
: vtop
->c
.d
= (double)vtop
->c
.ui
; break;
5060 case VT_LDOUBLE
: vtop
->c
.ld
= (long double)vtop
->c
.ui
; break;
5065 case VT_FLOAT
: vtop
->c
.f
= (float)vtop
->c
.i
; break;
5066 case VT_DOUBLE
: vtop
->c
.d
= (double)vtop
->c
.i
; break;
5067 case VT_LDOUBLE
: vtop
->c
.ld
= (long double)vtop
->c
.i
; break;
5076 /* convert fp to int */
5077 /* we handle char/short/etc... with generic code */
5078 if (dbt
!= (VT_INT
| VT_UNSIGNED
) &&
5079 dbt
!= (VT_LLONG
| VT_UNSIGNED
) &&
5084 case VT_LLONG
| VT_UNSIGNED
:
5086 /* XXX: add const cases for long long */
5088 case VT_INT
| VT_UNSIGNED
:
5090 case VT_FLOAT
: vtop
->c
.ui
= (unsigned int)vtop
->c
.d
; break;
5091 case VT_DOUBLE
: vtop
->c
.ui
= (unsigned int)vtop
->c
.d
; break;
5092 case VT_LDOUBLE
: vtop
->c
.ui
= (unsigned int)vtop
->c
.d
; break;
5098 case VT_FLOAT
: vtop
->c
.i
= (int)vtop
->c
.d
; break;
5099 case VT_DOUBLE
: vtop
->c
.i
= (int)vtop
->c
.d
; break;
5100 case VT_LDOUBLE
: vtop
->c
.i
= (int)vtop
->c
.d
; break;
5108 if (dbt
== VT_INT
&& (type
->t
& (VT_BTYPE
| VT_UNSIGNED
)) != dbt
) {
5109 /* additionnal cast for char/short/bool... */
5113 } else if ((dbt
& VT_BTYPE
) == VT_LLONG
) {
5114 if ((sbt
& VT_BTYPE
) != VT_LLONG
) {
5115 /* scalar to long long */
5117 if (sbt
== (VT_INT
| VT_UNSIGNED
))
5118 vtop
->c
.ll
= vtop
->c
.ui
;
5120 vtop
->c
.ll
= vtop
->c
.i
;
5122 /* machine independant conversion */
5124 /* generate high word */
5125 if (sbt
== (VT_INT
| VT_UNSIGNED
)) {
5133 /* patch second register */
5134 vtop
[-1].r2
= vtop
->r
;
5138 } else if (dbt
== VT_BOOL
) {
5139 /* scalar to bool */
5142 } else if ((dbt
& VT_BTYPE
) == VT_BYTE
||
5143 (dbt
& VT_BTYPE
) == VT_SHORT
) {
5144 force_charshort_cast(dbt
);
5145 } else if ((dbt
& VT_BTYPE
) == VT_INT
) {
5147 if (sbt
== VT_LLONG
) {
5148 /* from long long: just take low order word */
5152 /* if lvalue and single word type, nothing to do because
5153 the lvalue already contains the real type size (see
5154 VT_LVAL_xxx constants) */
5160 /* return type size. Put alignment at 'a' */
5161 static int type_size(CType
*type
, int *a
)
5166 bt
= type
->t
& VT_BTYPE
;
5167 if (bt
== VT_STRUCT
) {
5172 } else if (bt
== VT_PTR
) {
5173 if (type
->t
& VT_ARRAY
) {
5175 return type_size(&s
->type
, a
) * s
->c
;
5180 } else if (bt
== VT_LDOUBLE
) {
5182 return LDOUBLE_SIZE
;
5183 } else if (bt
== VT_DOUBLE
|| bt
== VT_LLONG
) {
5184 *a
= 4; /* XXX: i386 specific */
5186 } else if (bt
== VT_INT
|| bt
== VT_ENUM
|| bt
== VT_FLOAT
) {
5189 } else if (bt
== VT_SHORT
) {
5193 /* char, void, function, _Bool */
5199 /* return the pointed type of t */
5200 static inline CType
*pointed_type(CType
*type
)
5202 return &type
->ref
->type
;
5205 /* modify type so that its it is a pointer to type. */
5206 static void mk_pointer(CType
*type
)
5209 s
= sym_push(SYM_FIELD
, type
, 0, -1);
5210 type
->t
= VT_PTR
| (type
->t
& ~VT_TYPE
);
5214 static int is_compatible_types(CType
*type1
, CType
*type2
)
5217 int bt1
, bt2
, t1
, t2
;
5219 t1
= type1
->t
& VT_TYPE
;
5220 t2
= type2
->t
& VT_TYPE
;
5221 bt1
= t1
& VT_BTYPE
;
5222 bt2
= t2
& VT_BTYPE
;
5223 if (bt1
== VT_PTR
) {
5224 type1
= pointed_type(type1
);
5225 /* if function, then convert implicitely to function pointer */
5226 if (bt2
!= VT_FUNC
) {
5229 type2
= pointed_type(type2
);
5231 /* void matches everything */
5232 /* XXX: not fully compliant */
5233 if ((type1
->t
& VT_TYPE
) == VT_VOID
|| (type2
->t
& VT_TYPE
) == VT_VOID
)
5235 return is_compatible_types(type1
, type2
);
5236 } else if (bt1
== VT_STRUCT
|| bt2
== VT_STRUCT
) {
5237 return (type1
->ref
== type2
->ref
);
5238 } else if (bt1
== VT_FUNC
) {
5243 if (!is_compatible_types(&s1
->type
, &s2
->type
))
5245 /* XXX: not complete */
5246 if (s1
->c
== FUNC_OLD
|| s2
->c
== FUNC_OLD
)
5250 while (s1
!= NULL
) {
5253 if (!is_compatible_types(&s1
->type
, &s2
->type
))
5262 /* XXX: not complete */
5267 /* print a type. If 'varstr' is not NULL, then the variable is also
5268 printed in the type */
5270 /* XXX: add array and function pointers */
5271 void type_to_str(char *buf
, int buf_size
,
5272 CType
*type
, const char *varstr
)
5279 t
= type
->t
& VT_TYPE
;
5282 if (t
& VT_UNSIGNED
)
5283 pstrcat(buf
, buf_size
, "unsigned ");
5313 tstr
= "long double";
5315 pstrcat(buf
, buf_size
, tstr
);
5319 if (bt
== VT_STRUCT
)
5323 pstrcat(buf
, buf_size
, tstr
);
5324 v
= type
->ref
->v
& ~SYM_STRUCT
;
5325 if (v
>= SYM_FIRST_ANOM
)
5326 pstrcat(buf
, buf_size
, "<anonymous>");
5328 pstrcat(buf
, buf_size
, get_tok_str(v
, NULL
));
5332 type_to_str(buf
, buf_size
, &s
->type
, varstr
);
5333 pstrcat(buf
, buf_size
, "(");
5335 while (sa
!= NULL
) {
5336 type_to_str(buf1
, sizeof(buf1
), &sa
->type
, NULL
);
5337 pstrcat(buf
, buf_size
, buf1
);
5340 pstrcat(buf
, buf_size
, ", ");
5342 pstrcat(buf
, buf_size
, ")");
5346 pstrcpy(buf1
, sizeof(buf1
), "*");
5348 pstrcat(buf1
, sizeof(buf1
), varstr
);
5349 type_to_str(buf
, buf_size
, &s
->type
, buf1
);
5353 pstrcat(buf
, buf_size
, " ");
5354 pstrcat(buf
, buf_size
, varstr
);
5359 /* verify type compatibility to store vtop in 'dt' type, and generate
5361 static void gen_assign_cast(CType
*dt
)
5364 char buf1
[256], buf2
[256];
5367 st
= &vtop
->type
; /* source type */
5368 dbt
= dt
->t
& VT_BTYPE
;
5369 sbt
= st
->t
& VT_BTYPE
;
5370 if (dbt
== VT_PTR
) {
5371 /* special cases for pointers */
5372 /* a function is implicitely a function pointer */
5373 if (sbt
== VT_FUNC
) {
5374 if (!is_compatible_types(pointed_type(dt
), st
))
5379 /* '0' can also be a pointer */
5380 if (sbt
== VT_INT
&&
5381 ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) &&
5384 /* accept implicit pointer to integer cast with warning */
5385 if (sbt
== VT_BYTE
|| sbt
== VT_SHORT
||
5386 sbt
== VT_INT
|| sbt
== VT_LLONG
) {
5387 warning("assignment makes pointer from integer without a cast");
5390 } else if (dbt
== VT_BYTE
|| dbt
== VT_SHORT
||
5391 dbt
== VT_INT
|| dbt
== VT_LLONG
) {
5392 if (sbt
== VT_PTR
|| sbt
== VT_FUNC
) {
5393 warning("assignment makes integer from pointer without a cast");
5397 if (!is_compatible_types(dt
, st
)) {
5399 type_to_str(buf1
, sizeof(buf1
), st
, NULL
);
5400 type_to_str(buf2
, sizeof(buf2
), dt
, NULL
);
5401 error("cannot cast '%s' to '%s'", buf1
, buf2
);
5407 /* store vtop in lvalue pushed on stack */
5410 int sbt
, dbt
, ft
, r
, t
, size
, align
, bit_size
, bit_pos
, rc
, delayed_cast
;
5413 ft
= vtop
[-1].type
.t
;
5414 sbt
= vtop
->type
.t
& VT_BTYPE
;
5415 dbt
= ft
& VT_BTYPE
;
5416 if (((sbt
== VT_INT
|| sbt
== VT_SHORT
) && dbt
== VT_BYTE
) ||
5417 (sbt
== VT_INT
&& dbt
== VT_SHORT
)) {
5418 /* optimize char/short casts */
5419 delayed_cast
= VT_MUSTCAST
;
5420 vtop
->type
.t
= ft
& VT_TYPE
;
5423 gen_assign_cast(&vtop
[-1].type
);
5426 if (sbt
== VT_STRUCT
) {
5427 /* if structure, only generate pointer */
5428 /* structure assignment : generate memcpy */
5429 /* XXX: optimize if small size */
5430 if (!nocode_wanted
) {
5432 gfunc_start(&gf
, FUNC_CDECL
);
5434 size
= type_size(&vtop
->type
, &align
);
5438 vtop
->type
.t
= VT_INT
;
5443 vtop
->type
.t
= VT_INT
;
5448 vpush_global_sym(&func_old_type
, TOK_memcpy
);
5454 /* leave source on stack */
5455 } else if (ft
& VT_BITFIELD
) {
5456 /* bitfield store handling */
5457 bit_pos
= (ft
>> VT_STRUCT_SHIFT
) & 0x3f;
5458 bit_size
= (ft
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
5459 /* remove bit field info to avoid loops */
5460 vtop
[-1].type
.t
= ft
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
5462 /* duplicate destination */
5464 vtop
[-1] = vtop
[-2];
5466 /* mask and shift source */
5467 vpushi((1 << bit_size
) - 1);
5471 /* load destination, mask and or with source */
5473 vpushi(~(((1 << bit_size
) - 1) << bit_pos
));
5479 #ifdef CONFIG_TCC_BCHECK
5480 /* bound check case */
5481 if (vtop
[-1].r
& VT_MUSTBOUND
) {
5487 if (!nocode_wanted
) {
5491 r
= gv(rc
); /* generate value */
5492 /* if lvalue was saved on stack, must read it */
5493 if ((vtop
[-1].r
& VT_VALMASK
) == VT_LLOCAL
) {
5495 t
= get_reg(RC_INT
);
5497 sv
.r
= VT_LOCAL
| VT_LVAL
;
5498 sv
.c
.ul
= vtop
[-1].c
.ul
;
5500 vtop
[-1].r
= t
| VT_LVAL
;
5503 /* two word case handling : store second register at word + 4 */
5504 if ((ft
& VT_BTYPE
) == VT_LLONG
) {
5506 /* convert to int to increment easily */
5507 vtop
->type
.t
= VT_INT
;
5513 /* XXX: it works because r2 is spilled last ! */
5514 store(vtop
->r2
, vtop
- 1);
5518 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
5519 vtop
->r
|= delayed_cast
;
5523 /* post defines POST/PRE add. c is the token ++ or -- */
5524 void inc(int post
, int c
)
5527 vdup(); /* save lvalue */
5529 gv_dup(); /* duplicate value */
5534 vpushi(c
- TOK_MID
);
5536 vstore(); /* store value */
5538 vpop(); /* if post op, return saved value */
5541 /* Parse GNUC __attribute__ extension. Currently, the following
5542 extensions are recognized:
5543 - aligned(n) : set data/function alignment.
5544 - section(x) : generate data/code in this section.
5545 - unused : currently ignored, but may be used someday.
5547 void parse_attribute(AttributeDef
*ad
)
5554 while (tok
!= ')') {
5555 if (tok
< TOK_IDENT
)
5556 expect("attribute name");
5561 case TOK___SECTION__
:
5564 expect("section name");
5565 ad
->section
= find_section(tcc_state
, (char *)tokc
.cstr
->data
);
5570 case TOK___ALIGNED__
:
5574 if (n
<= 0 || (n
& (n
- 1)) != 0)
5575 error("alignment must be a positive power of two");
5583 case TOK___UNUSED__
:
5584 /* currently, no need to handle it because tcc does not
5585 track unused objects */
5588 case TOK___NORETURN__
:
5589 /* currently, no need to handle it because tcc does not
5590 track unused objects */
5595 ad
->func_call
= FUNC_CDECL
;
5599 case TOK___STDCALL__
:
5600 ad
->func_call
= FUNC_STDCALL
;
5603 warning("'%s' attribute ignored", get_tok_str(t
, NULL
));
5604 /* skip parameters */
5605 /* XXX: skip parenthesis too */
5608 while (tok
!= ')' && tok
!= -1)
5622 /* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
5623 static void struct_decl(CType
*type
, int u
)
5625 int a
, v
, size
, align
, maxalign
, c
, offset
;
5626 int bit_size
, bit_pos
, bsize
, bt
, lbit_pos
;
5631 a
= tok
; /* save decl type */
5636 /* struct already defined ? return it */
5637 /* XXX: check consistency */
5641 error("invalid type");
5648 s
= sym_push(v
| SYM_STRUCT
, &type1
, 0, 0);
5649 /* put struct/union/enum name in type */
5657 error("struct/union/enum already defined");
5658 /* cannot be empty */
5660 /* non empty enums are not allowed */
5661 if (a
== TOK_ENUM
) {
5665 expect("identifier");
5671 /* enum symbols have static storage */
5672 ss
= sym_push(v
, &int_type
, VT_CONST
, c
);
5673 ss
->type
.t
|= VT_STATIC
;
5678 /* NOTE: we accept a trailing comma */
5688 while (tok
!= '}') {
5689 parse_btype(&btype
, &ad
);
5695 type_decl(&type1
, &ad
, &v
, TYPE_DIRECT
);
5696 if ((type1
.t
& VT_BTYPE
) == VT_FUNC
||
5697 (type1
.t
& (VT_TYPEDEF
| VT_STATIC
| VT_EXTERN
)))
5698 error("invalid type for '%s'",
5699 get_tok_str(v
, NULL
));
5703 bit_size
= expr_const();
5704 /* XXX: handle v = 0 case for messages */
5706 error("negative width in bit-field '%s'",
5707 get_tok_str(v
, NULL
));
5708 if (v
&& bit_size
== 0)
5709 error("zero width for bit-field '%s'",
5710 get_tok_str(v
, NULL
));
5712 size
= type_size(&type1
, &align
);
5714 if (bit_size
>= 0) {
5715 bt
= type1
.t
& VT_BTYPE
;
5720 error("bitfields must have scalar type");
5722 if (bit_size
> bsize
) {
5723 error("width of '%s' exceeds its type",
5724 get_tok_str(v
, NULL
));
5725 } else if (bit_size
== bsize
) {
5726 /* no need for bit fields */
5728 } else if (bit_size
== 0) {
5729 /* XXX: what to do if only padding in a
5731 /* zero size: means to pad */
5735 /* we do not have enough room ? */
5736 if ((bit_pos
+ bit_size
) > bsize
)
5739 /* XXX: handle LSB first */
5740 type1
.t
|= VT_BITFIELD
|
5741 (bit_pos
<< VT_STRUCT_SHIFT
) |
5742 (bit_size
<< (VT_STRUCT_SHIFT
+ 6));
5743 bit_pos
+= bit_size
;
5749 /* add new memory data only if starting
5751 if (lbit_pos
== 0) {
5752 if (a
== TOK_STRUCT
) {
5753 c
= (c
+ align
- 1) & -align
;
5761 if (align
> maxalign
)
5765 printf("add field %s offset=%d",
5766 get_tok_str(v
, NULL
), offset
);
5767 if (type1
.t
& VT_BITFIELD
) {
5768 printf(" pos=%d size=%d",
5769 (type1
.t
>> VT_STRUCT_SHIFT
) & 0x3f,
5770 (type1
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f);
5774 ss
= sym_push(v
| SYM_FIELD
, &type1
, 0, offset
);
5778 if (tok
== ';' || tok
== TOK_EOF
)
5785 /* store size and alignment */
5786 s
->c
= (c
+ maxalign
- 1) & -maxalign
;
5792 /* return 0 if no type declaration. otherwise, return the basic type
5795 static int parse_btype(CType
*type
, AttributeDef
*ad
)
5797 int t
, u
, type_found
;
5801 memset(ad
, 0, sizeof(AttributeDef
));
5812 if ((t
& VT_BTYPE
) != 0)
5813 error("too many basic types");
5827 if ((t
& VT_BTYPE
) == VT_DOUBLE
) {
5828 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
5829 } else if ((t
& VT_BTYPE
) == VT_LONG
) {
5830 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
5844 if ((t
& VT_BTYPE
) == VT_LONG
) {
5845 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
5852 struct_decl(&type1
, VT_ENUM
);
5855 type
->ref
= type1
.ref
;
5859 struct_decl(&type1
, VT_STRUCT
);
5862 /* type modifiers */
5867 case TOK___SIGNED__
:
5870 case TOK___INLINE__
:
5892 /* GNUC attribute */
5893 case TOK___ATTRIBUTE__
:
5894 parse_attribute(ad
);
5899 parse_expr_type(&type1
);
5903 if (!s
|| !(s
->type
.t
& VT_TYPEDEF
))
5905 t
|= (s
->type
.t
& ~VT_TYPEDEF
);
5906 type
->ref
= s
->type
.ref
;
5913 /* long is never used as type */
5914 if ((t
& VT_BTYPE
) == VT_LONG
)
5915 t
= (t
& ~VT_BTYPE
) | VT_INT
;
5920 static void post_type(CType
*type
, AttributeDef
*ad
)
5923 Sym
**plast
, *s
, *first
;
5928 /* function declaration */
5933 while (tok
!= ')') {
5934 /* read param name and compute offset */
5935 if (l
!= FUNC_OLD
) {
5936 if (!parse_btype(&pt
, &ad1
)) {
5938 error("invalid type");
5945 if ((pt
.t
& VT_BTYPE
) == VT_VOID
&& tok
== ')')
5947 type_decl(&pt
, &ad1
, &n
, TYPE_DIRECT
| TYPE_ABSTRACT
);
5948 if ((pt
.t
& VT_BTYPE
) == VT_VOID
)
5949 error("parameter declared as void");
5956 /* array must be transformed to pointer according to ANSI C */
5958 s
= sym_push(n
| SYM_FIELD
, &pt
, 0, 0);
5963 if (l
== FUNC_NEW
&& tok
== TOK_DOTS
) {
5970 /* if no parameters, then old type prototype */
5974 t1
= type
->t
& (VT_TYPEDEF
| VT_STATIC
| VT_EXTERN
);
5975 type
->t
&= ~(VT_TYPEDEF
| VT_STATIC
| VT_EXTERN
);
5976 post_type(type
, ad
);
5977 /* we push a anonymous symbol which will contain the function prototype */
5978 s
= sym_push(SYM_FIELD
, type
, ad
->func_call
, l
);
5980 type
->t
= t1
| VT_FUNC
;
5982 } else if (tok
== '[') {
5983 /* array definition */
5989 error("invalid array size");
5992 /* parse next post type */
5993 t1
= type
->t
& (VT_TYPEDEF
| VT_STATIC
| VT_EXTERN
);
5994 type
->t
&= ~(VT_TYPEDEF
| VT_STATIC
| VT_EXTERN
);
5995 post_type(type
, ad
);
5997 /* we push a anonymous symbol which will contain the array
5999 s
= sym_push(SYM_FIELD
, type
, 0, n
);
6000 type
->t
= t1
| VT_ARRAY
| VT_PTR
;
6005 /* Parse a type declaration (except basic type), and return the type
6006 in 'type'. 'td' is a bitmask indicating which kind of type decl is
6007 expected. 'type' should contain the basic type. 'ad' is the
6008 attribute definition of the basic type. It can be modified by
6011 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
)
6014 CType type1
, *type2
;
6016 while (tok
== '*') {
6018 while (tok
== TOK_CONST
|| tok
== TOK_VOLATILE
|| tok
== TOK_RESTRICT
)
6023 /* recursive type */
6024 /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
6025 type1
.t
= 0; /* XXX: same as int */
6028 /* XXX: this is not correct to modify 'ad' at this point, but
6029 the syntax is not clear */
6030 if (tok
== TOK___ATTRIBUTE__
)
6031 parse_attribute(ad
);
6032 type_decl(&type1
, ad
, v
, td
);
6035 /* type identifier */
6036 if (tok
>= TOK_IDENT
&& (td
& TYPE_DIRECT
)) {
6040 if (!(td
& TYPE_ABSTRACT
))
6041 expect("identifier");
6045 post_type(type
, ad
);
6046 if (tok
== TOK___ATTRIBUTE__
)
6047 parse_attribute(ad
);
6050 /* append type at the end of type1 */
6063 /* compute the lvalue VT_LVAL_xxx needed to match type t. */
6064 static int lvalue_type(int t
)
6071 else if (bt
== VT_SHORT
)
6075 if (t
& VT_UNSIGNED
)
6076 r
|= VT_LVAL_UNSIGNED
;
6080 /* indirection with full error checking and bound check */
6081 static void indir(void)
6083 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
)
6085 if ((vtop
->r
& VT_LVAL
) && !nocode_wanted
)
6087 vtop
->type
= *pointed_type(&vtop
->type
);
6088 /* an array is never an lvalue */
6089 if (!(vtop
->type
.t
& VT_ARRAY
)) {
6090 vtop
->r
|= lvalue_type(vtop
->type
.t
);
6091 /* if bound checking, the referenced pointer must be checked */
6092 if (do_bounds_check
)
6093 vtop
->r
|= VT_MUSTBOUND
;
6097 /* pass a parameter to a function and do type checking and casting */
6098 void gfunc_param_typed(GFuncContext
*gf
, Sym
*func
, Sym
*arg
)
6103 func_type
= func
->c
;
6104 if (func_type
== FUNC_OLD
||
6105 (func_type
== FUNC_ELLIPSIS
&& arg
== NULL
)) {
6106 /* default casting : only need to convert float to double */
6107 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
) {
6111 } else if (arg
== NULL
) {
6112 error("too many arguments to function");
6114 gen_assign_cast(&arg
->type
);
6116 if (!nocode_wanted
) {
6123 /* parse an expression of the form '(type)' or '(expr)' and return its
6125 static void parse_expr_type(CType
*type
)
6131 if (parse_btype(type
, &ad
)) {
6132 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
6139 static void vpush_tokc(int t
)
6143 vsetc(&type
, VT_CONST
, &tokc
);
6146 static void unary(void)
6148 int n
, t
, align
, size
, r
;
6154 /* XXX: GCC 2.95.3 does not generate a table although it should be
6164 vpush_tokc(VT_INT
| VT_UNSIGNED
);
6168 vpush_tokc(VT_LLONG
);
6172 vpush_tokc(VT_LLONG
| VT_UNSIGNED
);
6176 vpush_tokc(VT_FLOAT
);
6180 vpush_tokc(VT_DOUBLE
);
6184 vpush_tokc(VT_LDOUBLE
);
6187 case TOK___FUNCTION__
:
6189 goto tok_identifier
;
6195 /* special function name identifier */
6196 len
= strlen(funcname
) + 1;
6197 /* generate char[len] type */
6202 vpush_ref(&type
, data_section
, data_section
->data_offset
, len
);
6203 ptr
= section_ptr_add(data_section
, len
);
6204 memcpy(ptr
, funcname
, len
);
6212 /* string parsing */
6218 memset(&ad
, 0, sizeof(AttributeDef
));
6219 decl_initializer_alloc(&type
, &ad
, VT_CONST
, 2, 0, 0);
6224 if (parse_btype(&type
, &ad
)) {
6225 type_decl(&type
, &ad
, &n
, TYPE_ABSTRACT
);
6227 /* check ISOC99 compound literal */
6229 /* data is allocated locally by default */
6234 /* all except arrays are lvalues */
6235 if (!(type
.t
& VT_ARRAY
))
6236 r
|= lvalue_type(type
.t
);
6237 memset(&ad
, 0, sizeof(AttributeDef
));
6238 decl_initializer_alloc(&type
, &ad
, r
, 1, 0, 0);
6256 /* functions names must be treated as function pointers,
6257 except for unary '&' and sizeof. Since we consider that
6258 functions are not lvalues, we only have to handle it
6259 there and in function calls. */
6260 /* arrays can also be used although they are not lvalues */
6261 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
&&
6262 !(vtop
->type
.t
& VT_ARRAY
))
6264 mk_pointer(&vtop
->type
);
6270 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
)
6271 vtop
->c
.i
= !vtop
->c
.i
;
6272 else if ((vtop
->r
& VT_VALMASK
) == VT_CMP
)
6273 vtop
->c
.i
= vtop
->c
.i
^ 1;
6275 vseti(VT_JMP
, gtst(1, 0));
6285 /* in order to force cast, we add zero */
6287 if ((vtop
->type
.t
& VT_BTYPE
) == VT_PTR
)
6288 error("pointer not accepted for unary plus");
6297 parse_expr_type(&type
);
6301 size
= type_size(&type
, &align
);
6302 if (t
== TOK_SIZEOF
)
6323 goto tok_identifier
;
6325 /* allow to take the address of a label */
6326 if (tok
< TOK_UIDENT
)
6327 expect("label identifier");
6328 s
= label_find(tok
);
6330 s
= label_push(tok
, LABEL_FORWARD
);
6333 s
->type
.t
= VT_VOID
;
6334 mk_pointer(&s
->type
);
6335 s
->type
.t
|= VT_STATIC
;
6337 vset(&s
->type
, VT_CONST
| VT_SYM
, 0);
6346 expect("identifier");
6350 error("'%s' undeclared", get_tok_str(t
, NULL
));
6351 /* for simple function calls, we tolerate undeclared
6352 external reference to int() function */
6353 s
= external_global_sym(t
, &func_old_type
, 0);
6355 vset(&s
->type
, s
->r
, s
->c
);
6356 /* if forward reference, we must point to s */
6357 if (vtop
->r
& VT_SYM
) {
6364 /* post operations */
6366 if (tok
== TOK_INC
|| tok
== TOK_DEC
) {
6369 } else if (tok
== '.' || tok
== TOK_ARROW
) {
6371 if (tok
== TOK_ARROW
)
6376 /* expect pointer on structure */
6377 if ((vtop
->type
.t
& VT_BTYPE
) != VT_STRUCT
)
6378 expect("struct or union");
6382 while ((s
= s
->next
) != NULL
) {
6387 error("field not found");
6388 /* add field offset to pointer */
6389 vtop
->type
= char_pointer_type
; /* change type to 'char *' */
6392 /* change type to field type, and set to lvalue */
6393 vtop
->type
= s
->type
;
6394 /* an array is never an lvalue */
6395 if (!(vtop
->type
.t
& VT_ARRAY
)) {
6396 vtop
->r
|= lvalue_type(vtop
->type
.t
);
6397 /* if bound checking, the referenced pointer must be checked */
6398 if (do_bounds_check
)
6399 vtop
->r
|= VT_MUSTBOUND
;
6402 } else if (tok
== '[') {
6408 } else if (tok
== '(') {
6413 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
6414 /* pointer test (no array accepted) */
6415 if ((vtop
->type
.t
& (VT_BTYPE
| VT_ARRAY
)) == VT_PTR
) {
6416 vtop
->type
= *pointed_type(&vtop
->type
);
6417 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
)
6421 expect("function pointer");
6424 vtop
->r
&= ~VT_LVAL
; /* no lvalue */
6426 /* get return type */
6428 if (!nocode_wanted
) {
6429 save_regs(0); /* save used temporary registers */
6430 gfunc_start(&gf
, s
->r
);
6433 sa
= s
->next
; /* first parameter */
6434 #ifdef INVERT_FUNC_PARAMS
6438 ParseState saved_parse_state
;
6441 /* read each argument and store it on a stack */
6447 while ((parlevel
> 0 || (tok
!= ')' && tok
!= ',')) &&
6451 else if (tok
== ')')
6453 tok_str_add_tok(&str
);
6456 tok_str_add(&str
, -1); /* end of file added */
6457 tok_str_add(&str
, 0);
6458 s1
= sym_push2(&args
, 0, 0, (int)str
.str
);
6459 s1
->next
= sa
; /* add reference to argument */
6468 /* now generate code in reverse order by reading the stack */
6469 save_parse_state(&saved_parse_state
);
6471 macro_ptr
= (int *)args
->c
;
6475 expect("',' or ')'");
6476 gfunc_param_typed(&gf
, s
, args
->next
);
6478 tok_str_free((int *)args
->c
);
6482 restore_parse_state(&saved_parse_state
);
6485 /* compute first implicit argument if a structure is returned */
6486 if ((s
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
6487 /* get some space for the returned structure */
6488 size
= type_size(&s
->type
, &align
);
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
);
6503 /* return in register */
6504 if (is_float(ret
.type
.t
)) {
6507 if ((ret
.type
.t
& VT_BTYPE
) == VT_LLONG
)
6513 #ifndef INVERT_FUNC_PARAMS
6517 gfunc_param_typed(&gf
, s
, sa
);
6527 error("too few arguments to function");
6534 vsetc(&ret
.type
, ret
.r
, &ret
.c
);
6542 static void uneq(void)
6548 (tok
>= TOK_A_MOD
&& tok
<= TOK_A_DIV
) ||
6549 tok
== TOK_A_XOR
|| tok
== TOK_A_OR
||
6550 tok
== TOK_A_SHL
|| tok
== TOK_A_SAR
) {
6565 static void expr_prod(void)
6570 while (tok
== '*' || tok
== '/' || tok
== '%') {
6578 static void expr_sum(void)
6583 while (tok
== '+' || tok
== '-') {
6591 static void expr_shift(void)
6596 while (tok
== TOK_SHL
|| tok
== TOK_SAR
) {
6604 static void expr_cmp(void)
6609 while ((tok
>= TOK_ULE
&& tok
<= TOK_GT
) ||
6610 tok
== TOK_ULT
|| tok
== TOK_UGE
) {
6618 static void expr_cmpeq(void)
6623 while (tok
== TOK_EQ
|| tok
== TOK_NE
) {
6631 static void expr_and(void)
6634 while (tok
== '&') {
6641 static void expr_xor(void)
6644 while (tok
== '^') {
6651 static void expr_or(void)
6654 while (tok
== '|') {
6661 /* XXX: suppress this mess */
6662 static void expr_land_const(void)
6665 while (tok
== TOK_LAND
) {
6672 /* XXX: suppress this mess */
6673 static void expr_lor_const(void)
6676 while (tok
== TOK_LOR
) {
6683 /* only used if non constant */
6684 static void expr_land(void)
6689 if (tok
== TOK_LAND
) {
6693 if (tok
!= TOK_LAND
) {
6703 static void expr_lor(void)
6708 if (tok
== TOK_LOR
) {
6712 if (tok
!= TOK_LOR
) {
6722 /* XXX: better constant handling */
6723 static void expr_eq(void)
6725 int tt
, u
, r1
, r2
, rc
, t1
, t2
, bt1
, bt2
;
6727 CType type
, type1
, type2
;
6748 if (vtop
!= vstack
) {
6749 /* needed to avoid having different registers saved in
6751 if (is_float(vtop
->type
.t
))
6761 sv
= *vtop
; /* save value to handle it later */
6762 vtop
--; /* no vpop so that FP stack is not flushed */
6770 bt1
= t1
& VT_BTYPE
;
6772 bt2
= t2
& VT_BTYPE
;
6773 /* cast operands to correct type according to ISOC rules */
6774 if (is_float(bt1
) || is_float(bt2
)) {
6775 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
6776 type
.t
= VT_LDOUBLE
;
6777 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
6782 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
6783 /* cast to biggest op */
6785 /* convert to unsigned if it does not fit in a long long */
6786 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
6787 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
6788 type
.t
|= VT_UNSIGNED
;
6789 } else if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
6790 /* XXX: test pointer compatibility */
6792 } else if (bt1
== VT_STRUCT
|| bt2
== VT_STRUCT
) {
6793 /* XXX: test structure compatibility */
6795 } else if (bt1
== VT_VOID
|| bt2
== VT_VOID
) {
6796 /* NOTE: as an extension, we accept void on only one side */
6799 /* integer operations */
6801 /* convert to unsigned if it does not fit in an integer */
6802 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
6803 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
6804 type
.t
|= VT_UNSIGNED
;
6807 /* now we convert second operand */
6810 if (is_float(type
.t
)) {
6812 } else if ((type
.t
& VT_BTYPE
) == VT_LLONG
) {
6813 /* for long longs, we use fixed registers to avoid having
6814 to handle a complicated move */
6819 /* this is horrible, but we must also convert first
6823 /* put again first value and cast it */
6834 static void gexpr(void)
6845 /* parse an expression and return its type without any side effect. */
6846 static void expr_type(CType
*type
)
6858 /* parse a unary expression and return its type without any side
6860 static void unary_type(CType
*type
)
6872 /* parse a constant expression and return value in vtop. */
6873 static void expr_const1(void)
6882 /* parse an integer constant and return its value. */
6883 static int expr_const(void)
6887 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
6888 expect("constant expression");
6894 /* return the label token if current token is a label, otherwise
6896 static int is_label(void)
6901 /* fast test first */
6902 if (tok
< TOK_UIDENT
)
6904 /* no need to save tokc since we expect an identifier */
6912 /* XXX: may not work in all cases (macros ?) */
6921 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
, int case_reg
)
6926 /* generate line number info */
6928 (last_line_num
!= file
->line_num
|| last_ind
!= ind
)) {
6929 put_stabn(N_SLINE
, 0, file
->line_num
, ind
- func_ind
);
6931 last_line_num
= file
->line_num
;
6934 if (tok
== TOK_IF
) {
6941 block(bsym
, csym
, case_sym
, def_sym
, case_reg
);
6943 if (c
== TOK_ELSE
) {
6947 block(bsym
, csym
, case_sym
, def_sym
, case_reg
);
6948 gsym(d
); /* patch else jmp */
6951 } else if (tok
== TOK_WHILE
) {
6959 block(&a
, &b
, case_sym
, def_sym
, case_reg
);
6963 } else if (tok
== '{') {
6967 while (tok
!= '}') {
6970 block(bsym
, csym
, case_sym
, def_sym
, case_reg
);
6972 /* pop locally defined symbols */
6973 sym_pop(&local_stack
, s
);
6975 } else if (tok
== TOK_RETURN
) {
6979 gen_assign_cast(&func_vt
);
6980 if ((func_vt
.t
& VT_BTYPE
) == VT_STRUCT
) {
6982 /* if returning structure, must copy it to implicit
6983 first pointer arg location */
6986 vset(&type
, VT_LOCAL
| VT_LVAL
, func_vc
);
6989 /* copy structure value to pointer */
6991 } else if (is_float(func_vt
.t
)) {
6996 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
6999 rsym
= gjmp(rsym
); /* jmp */
7000 } else if (tok
== TOK_BREAK
) {
7003 error("cannot break");
7004 *bsym
= gjmp(*bsym
);
7007 } else if (tok
== TOK_CONTINUE
) {
7010 error("cannot continue");
7011 *csym
= gjmp(*csym
);
7014 } else if (tok
== TOK_FOR
) {
7041 block(&a
, &b
, case_sym
, def_sym
, case_reg
);
7046 if (tok
== TOK_DO
) {
7051 block(&a
, &b
, case_sym
, def_sym
, case_reg
);
7062 if (tok
== TOK_SWITCH
) {
7066 /* XXX: other types than integer */
7067 case_reg
= gv(RC_INT
);
7071 b
= gjmp(0); /* jump to first case */
7073 block(&a
, csym
, &b
, &c
, case_reg
);
7074 /* if no default, jmp after switch */
7082 if (tok
== TOK_CASE
) {
7089 if (gnu_ext
&& tok
== TOK_DOTS
) {
7093 warning("empty case range");
7095 /* since a case is like a label, we must skip it with a jmp */
7102 *case_sym
= gtst(1, 0);
7105 *case_sym
= gtst(1, 0);
7109 *case_sym
= gtst(1, *case_sym
);
7113 block(bsym
, csym
, case_sym
, def_sym
, case_reg
);
7115 if (tok
== TOK_DEFAULT
) {
7121 error("too many 'default'");
7123 block(bsym
, csym
, case_sym
, def_sym
, case_reg
);
7125 if (tok
== TOK_GOTO
) {
7127 if (tok
== '*' && gnu_ext
) {
7131 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
)
7134 } else if (tok
>= TOK_UIDENT
) {
7135 s
= label_find(tok
);
7136 /* put forward definition if needed */
7138 s
= label_push(tok
, LABEL_FORWARD
);
7140 /* label already defined */
7141 if (s
->r
& LABEL_FORWARD
)
7142 s
->next
= (void *)gjmp((long)s
->next
);
7144 gjmp_addr((long)s
->next
);
7147 expect("label identifier");
7156 if (!(s
->r
& LABEL_FORWARD
))
7157 error("multiple defined label");
7158 gsym((long)s
->next
);
7160 s
= label_push(b
, 0);
7162 s
->next
= (void *)ind
;
7164 /* we accept this, but it is a mistake */
7166 warning("deprecated use of label at end of compound statement");
7168 block(bsym
, csym
, case_sym
, def_sym
, case_reg
);
7170 /* expression case */
7180 /* t is the array or struct type. c is the array or struct
7181 address. cur_index/cur_field is the pointer to the current
7182 value. 'size_only' is true if only size info is needed (only used
7184 static void decl_designator(CType
*type
, Section
*sec
, unsigned long c
,
7185 int *cur_index
, Sym
**cur_field
,
7189 int notfirst
, index
, align
, l
;
7193 if (gnu_ext
&& (l
= is_label()) != 0)
7196 while (tok
== '[' || tok
== '.') {
7198 if (!(type
->t
& VT_ARRAY
))
7199 expect("array type");
7202 index
= expr_const();
7203 if (index
< 0 || (s
->c
>= 0 && index
>= s
->c
))
7204 expect("invalid index");
7208 type
= pointed_type(type
);
7209 c
+= index
* type_size(type
, &align
);
7215 if ((type
->t
& VT_BTYPE
) != VT_STRUCT
)
7216 expect("struct/union type");
7229 /* XXX: suppress this mess by using explicit storage field */
7231 type1
.t
|= (type
->t
& ~VT_TYPE
);
7245 if (type
->t
& VT_ARRAY
) {
7247 type
= pointed_type(type
);
7248 c
+= index
* type_size(type
, &align
);
7252 error("too many field init");
7253 /* XXX: suppress this mess by using explicit storage field */
7255 type1
.t
|= (type
->t
& ~VT_TYPE
);
7260 decl_initializer(type
, sec
, c
, 0, size_only
);
7264 #define EXPR_CONST 1
7267 /* store a value or an expression directly in global data or in local array */
7268 static void init_putv(CType
*type
, Section
*sec
, unsigned long c
,
7269 int v
, int expr_type
)
7271 int saved_global_expr
, bt
, bit_pos
, bit_size
;
7273 unsigned long long bit_mask
;
7280 /* compound literals must be allocated globally in this case */
7281 saved_global_expr
= global_expr
;
7284 global_expr
= saved_global_expr
;
7285 /* NOTE: symbols are accepted */
7286 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) != VT_CONST
)
7287 error("initializer element is not constant");
7295 /* XXX: not portable */
7296 /* XXX: generate error if incorrect relocation */
7297 gen_assign_cast(type
);
7298 bt
= type
->t
& VT_BTYPE
;
7299 ptr
= sec
->data
+ c
;
7300 /* XXX: make code faster ? */
7301 if (!(type
->t
& VT_BITFIELD
)) {
7306 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
7307 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
7308 bit_mask
= (1LL << bit_size
) - 1;
7310 if ((vtop
->r
& VT_SYM
) &&
7316 (bt
== VT_INT
&& bit_size
!= 32)))
7317 error("initializer element is not computable at load time");
7320 *(char *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
7323 *(short *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
7326 *(double *)ptr
= vtop
->c
.d
;
7329 *(long double *)ptr
= vtop
->c
.ld
;
7332 *(long long *)ptr
|= (vtop
->c
.ll
& bit_mask
) << bit_pos
;
7335 if (vtop
->r
& VT_SYM
) {
7336 greloc(sec
, vtop
->sym
, c
, R_DATA_32
);
7338 *(int *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
7343 vset(type
, VT_LOCAL
, c
);
7350 /* put zeros for variable based init */
7351 static void init_putz(CType
*t
, Section
*sec
, unsigned long c
, int size
)
7356 /* nothing to do because globals are already set to zero */
7358 gfunc_start(&gf
, FUNC_CDECL
);
7365 vpush_global_sym(&func_old_type
, TOK_memset
);
7370 /* 't' contains the type and storage info. 'c' is the offset of the
7371 object in section 'sec'. If 'sec' is NULL, it means stack based
7372 allocation. 'first' is true if array '{' must be read (multi
7373 dimension implicit array init handling). 'size_only' is true if
7374 size only evaluation is wanted (only for arrays). */
7375 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
7376 int first
, int size_only
)
7378 int index
, array_length
, n
, no_oblock
, nb
, parlevel
, i
;
7379 int size1
, align1
, expr_type
;
7383 if (type
->t
& VT_ARRAY
) {
7387 t1
= pointed_type(type
);
7388 size1
= type_size(t1
, &align1
);
7391 if ((first
&& tok
!= TOK_LSTR
&& tok
!= TOK_STR
) ||
7397 /* only parse strings here if correct type (otherwise: handle
7398 them as ((w)char *) expressions */
7399 if ((tok
== TOK_LSTR
&&
7400 (t1
->t
& VT_BTYPE
) == VT_INT
) ||
7402 (t1
->t
& VT_BTYPE
) == VT_BYTE
)) {
7403 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
7408 /* compute maximum number of chars wanted */
7410 cstr_len
= cstr
->size
;
7412 cstr_len
= cstr
->size
/ sizeof(int);
7415 if (n
>= 0 && nb
> (n
- array_length
))
7416 nb
= n
- array_length
;
7419 warning("initializer-string for array is too long");
7420 /* in order to go faster for common case (char
7421 string in global variable, we handle it
7423 if (sec
&& tok
== TOK_STR
&& size1
== 1) {
7424 memcpy(sec
->data
+ c
+ array_length
, cstr
->data
, nb
);
7428 ch
= ((unsigned char *)cstr
->data
)[i
];
7430 ch
= ((int *)cstr
->data
)[i
];
7431 init_putv(t1
, sec
, c
+ (array_length
+ i
) * size1
,
7439 /* only add trailing zero if enough storage (no
7440 warning in this case since it is standard) */
7441 if (n
< 0 || array_length
< n
) {
7443 init_putv(t1
, sec
, c
+ (array_length
* size1
), 0, EXPR_VAL
);
7449 while (tok
!= '}') {
7450 decl_designator(type
, sec
, c
, &index
, NULL
, size_only
);
7451 if (n
>= 0 && index
>= n
)
7452 error("index too large");
7453 /* must put zero in holes (note that doing it that way
7454 ensures that it even works with designators) */
7455 if (!size_only
&& array_length
< index
) {
7456 init_putz(t1
, sec
, c
+ array_length
* size1
,
7457 (index
- array_length
) * size1
);
7460 if (index
> array_length
)
7461 array_length
= index
;
7462 /* special test for multi dimensional arrays (may not
7463 be strictly correct if designators are used at the
7465 if (index
>= n
&& no_oblock
)
7474 /* put zeros at the end */
7475 if (!size_only
&& n
>= 0 && array_length
< n
) {
7476 init_putz(t1
, sec
, c
+ array_length
* size1
,
7477 (n
- array_length
) * size1
);
7479 /* patch type size if needed */
7481 s
->c
= array_length
;
7482 } else if ((type
->t
& VT_BTYPE
) == VT_STRUCT
&&
7483 (sec
|| !first
|| tok
== '{')) {
7484 /* NOTE: the previous test is a specific case for automatic
7485 struct/union init */
7486 /* XXX: union needs only one init */
7488 if (first
|| tok
== '{') {
7497 while (tok
!= '}') {
7498 decl_designator(type
, sec
, c
, NULL
, &f
, size_only
);
7500 if (!size_only
&& array_length
< index
) {
7501 init_putz(type
, sec
, c
+ array_length
,
7502 index
- array_length
);
7504 index
= index
+ type_size(&f
->type
, &align1
);
7505 if (index
> array_length
)
7506 array_length
= index
;
7508 if (no_oblock
&& f
== NULL
)
7514 /* put zeros at the end */
7515 if (!size_only
&& array_length
< n
) {
7516 init_putz(type
, sec
, c
+ array_length
,
7521 } else if (tok
== '{') {
7523 decl_initializer(type
, sec
, c
, first
, size_only
);
7525 } else if (size_only
) {
7526 /* just skip expression */
7528 while ((parlevel
> 0 || (tok
!= '}' && tok
!= ',')) &&
7532 else if (tok
== ')')
7537 /* currently, we always use constant expression for globals
7538 (may change for scripting case) */
7539 expr_type
= EXPR_CONST
;
7541 expr_type
= EXPR_ANY
;
7542 init_putv(type
, sec
, c
, 0, expr_type
);
7546 /* parse an initializer for type 't' if 'has_init' is non zero, and
7547 allocate space in local or global data space ('r' is either
7548 VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
7549 variable 'v' of scope 'scope' is declared before initializers are
7550 parsed. If 'v' is zero, then a reference to the new object is put
7551 in the value stack. If 'has_init' is 2, a special parsing is done
7552 to handle string constants. */
7553 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
7554 int has_init
, int v
, int scope
)
7556 int size
, align
, addr
, data_offset
;
7558 ParseState saved_parse_state
;
7559 TokenString init_str
;
7562 size
= type_size(type
, &align
);
7563 /* If unknown size, we must evaluate it before
7564 evaluating initializers because
7565 initializers can generate global data too
7566 (e.g. string pointers or ISOC99 compound
7567 literals). It also simplifies local
7568 initializers handling */
7569 tok_str_new(&init_str
);
7572 error("unknown type size");
7573 /* get all init string */
7574 if (has_init
== 2) {
7575 /* only get strings */
7576 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
7577 tok_str_add_tok(&init_str
);
7582 while (level
> 0 || (tok
!= ',' && tok
!= ';')) {
7584 error("unexpected end of file in initializer");
7585 tok_str_add_tok(&init_str
);
7588 else if (tok
== '}') {
7596 tok_str_add(&init_str
, -1);
7597 tok_str_add(&init_str
, 0);
7600 save_parse_state(&saved_parse_state
);
7602 macro_ptr
= init_str
.str
;
7604 decl_initializer(type
, NULL
, 0, 1, 1);
7605 /* prepare second initializer parsing */
7606 macro_ptr
= init_str
.str
;
7609 /* if still unknown size, error */
7610 size
= type_size(type
, &align
);
7612 error("unknown type size");
7614 /* take into account specified alignment if bigger */
7615 if (ad
->aligned
> align
)
7616 align
= ad
->aligned
;
7617 if ((r
& VT_VALMASK
) == VT_LOCAL
) {
7619 if (do_bounds_check
&& (type
->t
& VT_ARRAY
))
7621 #ifdef TCC_TARGET_IL
7622 /* XXX: ugly patch to allocate local variables for IL, just
7627 loc
= (loc
- size
) & -align
;
7630 /* handles bounds */
7631 /* XXX: currently, since we do only one pass, we cannot track
7632 '&' operators, so we add only arrays */
7633 if (do_bounds_check
&& (type
->t
& VT_ARRAY
)) {
7634 unsigned long *bounds_ptr
;
7635 /* add padding between regions */
7637 /* then add local bound info */
7638 bounds_ptr
= section_ptr_add(lbounds_section
, 2 * sizeof(unsigned long));
7639 bounds_ptr
[0] = addr
;
7640 bounds_ptr
[1] = size
;
7643 /* compute section */
7651 data_offset
= sec
->data_offset
;
7652 data_offset
= (data_offset
+ align
- 1) & -align
;
7654 /* very important to increment global pointer at this time
7655 because initializers themselves can create new initializers */
7656 data_offset
+= size
;
7657 /* add padding if bound check */
7658 if (do_bounds_check
)
7660 sec
->data_offset
= data_offset
;
7661 /* allocate section space to put the data */
7662 if (sec
->sh_type
!= SHT_NOBITS
&&
7663 data_offset
> sec
->data_allocated
)
7664 section_realloc(sec
, data_offset
);
7668 /* local variable */
7669 sym_push(v
, type
, r
, addr
);
7671 /* push local reference */
7672 vset(type
, r
, addr
);
7678 if (scope
== VT_CONST
) {
7679 /* global scope: see if already defined */
7683 if (!is_compatible_types(&sym
->type
, type
))
7684 error("incompatible types for redefinition of '%s'",
7685 get_tok_str(v
, NULL
));
7686 if (!(sym
->type
.t
& VT_EXTERN
))
7687 error("redefinition of '%s'", get_tok_str(v
, NULL
));
7688 sym
->type
.t
&= ~VT_EXTERN
;
7691 sym
= sym_push(v
, type
, r
| VT_SYM
, 0);
7693 put_extern_sym(sym
, sec
, addr
, size
);
7697 /* push global reference */
7698 sym
= get_sym_ref(type
, sec
, addr
, size
);
7700 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
7704 /* handles bounds now because the symbol must be defined
7705 before for the relocation */
7706 if (do_bounds_check
) {
7707 unsigned long *bounds_ptr
;
7709 greloc(bounds_section
, sym
, bounds_section
->data_offset
, R_DATA_32
);
7710 /* then add global bound info */
7711 bounds_ptr
= section_ptr_add(bounds_section
, 2 * sizeof(long));
7712 bounds_ptr
[0] = 0; /* relocated */
7713 bounds_ptr
[1] = size
;
7717 decl_initializer(type
, sec
, addr
, 1, 0);
7718 /* restore parse state if needed */
7720 tok_str_free(init_str
.str
);
7721 restore_parse_state(&saved_parse_state
);
7726 void put_func_debug(Sym
*sym
)
7731 /* XXX: we put here a dummy type */
7732 snprintf(buf
, sizeof(buf
), "%s:%c1",
7733 funcname
, sym
->type
.t
& VT_STATIC
? 'f' : 'F');
7734 put_stabs_r(buf
, N_FUN
, 0, file
->line_num
, 0,
7735 cur_text_section
, sym
->c
);
7740 /* not finished : try to put some local vars in registers */
7741 //#define CONFIG_REG_VARS
7743 #ifdef CONFIG_REG_VARS
7744 void add_var_ref(int t
)
7746 printf("%s:%d: &%s\n",
7747 file
->filename
, file
->line_num
,
7748 get_tok_str(t
, NULL
));
7751 /* first pass on a function with heuristic to extract variable usage
7752 and pointer references to local variables for register allocation */
7753 void analyse_function(void)
7760 /* any symbol coming after '&' is considered as being a
7761 variable whose reference is taken. It is highly unaccurate
7762 but it is difficult to do better without a complete parse */
7765 /* if '& number', then no need to examine next tokens */
7766 if (tok
== TOK_CINT
||
7768 tok
== TOK_CLLONG
||
7769 tok
== TOK_CULLONG
) {
7771 } else if (tok
>= TOK_UIDENT
) {
7772 /* if '& ident [' or '& ident ->', then ident address
7776 if (tok
!= '[' && tok
!= TOK_ARROW
)
7780 while (tok
!= '}' && tok
!= ';' &&
7781 !((tok
== ',' || tok
== ')') && level
== 0)) {
7782 if (tok
>= TOK_UIDENT
) {
7784 } else if (tok
== '(') {
7786 } else if (tok
== ')') {
7799 /* parse an old style function declaration list */
7800 /* XXX: check multiple parameter */
7801 static void func_decl_list(Sym
*func_sym
)
7808 /* parse each declaration */
7809 while (tok
!= '{' && tok
!= ';' && tok
!= ',' && tok
!= TOK_EOF
) {
7810 if (!parse_btype(&btype
, &ad
))
7811 expect("declaration list");
7812 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
7813 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
7815 /* we accept no variable after */
7819 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
7820 /* find parameter in function parameter list */
7823 if ((s
->v
& ~SYM_FIELD
) == v
)
7827 error("declaration for parameter '%s' but no such parameter",
7828 get_tok_str(v
, NULL
));
7830 /* check that no storage specifier except 'register' was given */
7831 if (type
.t
& (VT_EXTERN
| VT_STATIC
| VT_TYPEDEF
))
7832 error("storage class specified for '%s'", get_tok_str(v
, NULL
));
7833 /* we can add the type (NOTE: it could be local to the function) */
7835 /* accept other parameters */
7846 /* 'l' is VT_LOCAL or VT_CONST to define default storage type */
7847 static void decl(int l
)
7855 if (!parse_btype(&btype
, &ad
)) {
7856 /* skip redundant ';' */
7857 /* XXX: find more elegant solution */
7862 /* special test for old K&R protos without explicit int
7863 type. Only accepted when defining global data */
7864 if (l
== VT_LOCAL
|| tok
< TOK_DEFINE
)
7868 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
7869 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
7871 /* we accept no variable after */
7875 while (1) { /* iterate thru each declaration */
7877 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
7881 type_to_str(buf
, sizeof(buf
), t
, get_tok_str(v
, NULL
));
7882 printf("type = '%s'\n", buf
);
7885 if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
7886 /* if old style function prototype, we accept a
7889 if (sym
->c
== FUNC_OLD
)
7890 func_decl_list(sym
);
7894 #ifdef CONFIG_REG_VARS
7895 TokenString func_str
;
7896 ParseState saved_parse_state
;
7901 error("cannot use local functions");
7902 if (!(type
.t
& VT_FUNC
))
7903 expect("function definition");
7905 #ifdef CONFIG_REG_VARS
7906 /* parse all function code and record it */
7908 tok_str_new(&func_str
);
7914 error("unexpected end of file");
7915 tok_str_add_tok(&func_str
);
7920 } else if (t
== '}') {
7922 if (block_level
== 0)
7926 tok_str_add(&func_str
, -1);
7927 tok_str_add(&func_str
, 0);
7929 save_parse_state(&saved_parse_state
);
7931 macro_ptr
= func_str
.str
;
7936 /* compute text section */
7937 cur_text_section
= ad
.section
;
7938 if (!cur_text_section
)
7939 cur_text_section
= text_section
;
7940 ind
= cur_text_section
->data_offset
;
7941 funcname
= get_tok_str(v
, NULL
);
7944 /* if symbol is already defined, then put complete type */
7947 /* put function symbol */
7948 sym
= global_identifier_push(v
, type
.t
, 0);
7949 sym
->type
.ref
= type
.ref
;
7951 /* NOTE: we patch the symbol size later */
7952 put_extern_sym(sym
, cur_text_section
, ind
, 0);
7954 sym
->r
= VT_SYM
| VT_CONST
;
7955 /* put debug symbol */
7957 put_func_debug(sym
);
7958 /* push a dummy symbol to enable local sym storage */
7959 sym_push2(&local_stack
, SYM_FIELD
, 0, 0);
7960 gfunc_prolog(&type
);
7963 #ifdef CONFIG_REG_VARS
7964 macro_ptr
= func_str
.str
;
7967 block(NULL
, NULL
, NULL
, NULL
, 0);
7970 cur_text_section
->data_offset
= ind
;
7971 /* look if any labels are undefined. Define symbols if
7972 '&&label' was used. */
7975 for(s
= label_stack
; s
!= NULL
; s
= s1
) {
7977 if (s
->r
& LABEL_FORWARD
) {
7978 error("label '%s' used but not defined",
7979 get_tok_str(s
->v
, NULL
));
7982 /* define corresponding symbol. A size of
7984 put_extern_sym(s
, cur_text_section
, (long)s
->next
, 1);
7987 table_ident
[s
->v
- TOK_IDENT
]->sym_label
= NULL
;
7992 sym_pop(&local_stack
, NULL
); /* reset local stack */
7993 /* end of function */
7994 /* patch symbol size */
7995 ((Elf32_Sym
*)symtab_section
->data
)[sym
->c
].st_size
=
7998 put_stabn(N_FUN
, 0, 0, ind
- func_ind
);
8000 funcname
= ""; /* for safety */
8001 func_vt
.t
= VT_VOID
; /* for safety */
8002 ind
= 0; /* for safety */
8004 #ifdef CONFIG_REG_VARS
8005 tok_str_free(func_str
.str
);
8006 restore_parse_state(&saved_parse_state
);
8010 if (btype
.t
& VT_TYPEDEF
) {
8011 /* save typedefed type */
8012 /* XXX: test storage specifiers ? */
8013 sym
= sym_push(v
, &type
, 0, 0);
8014 sym
->type
.t
|= VT_TYPEDEF
;
8015 } else if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
8016 /* external function definition */
8017 external_sym(v
, &type
, 0);
8019 /* not lvalue if array */
8021 if (!(type
.t
& VT_ARRAY
))
8022 r
|= lvalue_type(type
.t
);
8023 if (btype
.t
& VT_EXTERN
) {
8024 /* external variable */
8025 external_sym(v
, &type
, r
);
8027 if (type
.t
& VT_STATIC
)
8031 has_init
= (tok
== '=');
8034 decl_initializer_alloc(&type
, &ad
, r
,
8048 /* compile the C file opened in 'file'. Return non zero if errors. */
8049 static int tcc_compile(TCCState
*s1
)
8053 volatile int section_sym
;
8056 printf("%s: **** new file\n", file
->filename
);
8059 s1
->include_stack_ptr
= s1
->include_stack
;
8060 /* XXX: move that before to avoid having to initialize
8061 file->ifdef_stack_ptr ? */
8062 s1
->ifdef_stack_ptr
= s1
->ifdef_stack
;
8063 file
->ifdef_stack_ptr
= s1
->ifdef_stack_ptr
;
8065 /* XXX: not ANSI compliant: bound checking says error */
8067 anon_sym
= SYM_FIRST_ANOM
;
8069 /* file info: full path + filename */
8070 section_sym
= 0; /* avoid warning */
8072 section_sym
= put_elf_sym(symtab_section
, 0, 0,
8073 ELF32_ST_INFO(STB_LOCAL
, STT_SECTION
), 0,
8074 text_section
->sh_num
, NULL
);
8075 getcwd(buf
, sizeof(buf
));
8076 pstrcat(buf
, sizeof(buf
), "/");
8077 put_stabs_r(buf
, N_SO
, 0, 0,
8078 text_section
->data_offset
, text_section
, section_sym
);
8079 put_stabs_r(file
->filename
, N_SO
, 0, 0,
8080 text_section
->data_offset
, text_section
, section_sym
);
8082 /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
8083 symbols can be safely used */
8084 put_elf_sym(symtab_section
, 0, 0,
8085 ELF32_ST_INFO(STB_LOCAL
, STT_FILE
), 0,
8086 SHN_ABS
, file
->filename
);
8088 /* define some often used types */
8089 int_type
.t
= VT_INT
;
8091 char_pointer_type
.t
= VT_BYTE
;
8092 mk_pointer(&char_pointer_type
);
8094 func_old_type
.t
= VT_FUNC
;
8095 func_old_type
.ref
= sym_push(SYM_FIELD
, &int_type
, FUNC_CDECL
, FUNC_OLD
);
8098 /* define 'void *alloca(unsigned int)' builtin function */
8103 sym
= sym_push(p
, mk_pointer(VT_VOID
), FUNC_CDECL
, FUNC_NEW
);
8104 s1
= sym_push(SYM_FIELD
, VT_UNSIGNED
| VT_INT
, 0, 0);
8107 sym_push(TOK_alloca
, VT_FUNC
| (p
<< VT_STRUCT_SHIFT
), VT_CONST
, 0);
8111 define_start
= define_stack
;
8113 if (setjmp(s1
->error_jmp_buf
) == 0) {
8115 s1
->error_set_jmp_enabled
= 1;
8117 ch
= file
->buf_ptr
[0];
8118 tok_flags
= TOK_FLAG_BOL
| TOK_FLAG_BOF
;
8122 expect("declaration");
8124 /* end of translation unit info */
8126 put_stabs_r(NULL
, N_SO
, 0, 0,
8127 text_section
->data_offset
, text_section
, section_sym
);
8130 s1
->error_set_jmp_enabled
= 0;
8132 /* reset define stack, but leave -Dsymbols (may be incorrect if
8133 they are undefined) */
8134 free_defines(define_start
);
8136 sym_pop(&global_stack
, NULL
);
8138 return s1
->nb_errors
!= 0 ? -1 : 0;
8142 int tcc_compile_string(TCCState
*s
, const char *str
)
8144 BufferedFile bf1
, *bf
= &bf1
;
8148 /* init file structure */
8150 /* XXX: avoid copying */
8152 buf
= tcc_malloc(len
+ 1);
8157 bf
->buf_end
= buf
+ len
;
8158 pstrcpy(bf
->filename
, sizeof(bf
->filename
), "<string>");
8162 ret
= tcc_compile(s
);
8166 /* currently, no need to close */
8171 /* define a preprocessor symbol. A value can also be provided with the '=' operator */
8172 void tcc_define_symbol(TCCState
*s1
, const char *sym
, const char *value
)
8174 BufferedFile bf1
, *bf
= &bf1
;
8176 pstrcpy(bf
->buffer
, IO_BUF_SIZE
, sym
);
8177 pstrcat(bf
->buffer
, IO_BUF_SIZE
, " ");
8181 pstrcat(bf
->buffer
, IO_BUF_SIZE
, value
);
8183 /* init file structure */
8185 bf
->buf_ptr
= bf
->buffer
;
8186 bf
->buf_end
= bf
->buffer
+ strlen(bf
->buffer
);
8187 *bf
->buf_end
= CH_EOB
;
8188 bf
->filename
[0] = '\0';
8192 s1
->include_stack_ptr
= s1
->include_stack
;
8194 /* parse with define parser */
8195 ch
= file
->buf_ptr
[0];
8201 /* undefine a preprocessor symbol */
8202 void tcc_undefine_symbol(TCCState
*s1
, const char *sym
)
8206 ts
= tok_alloc(sym
, strlen(sym
));
8207 s
= define_find(ts
->tok
);
8208 /* undefine symbol by putting an invalid name */
8215 /* print the position in the source file of PC value 'pc' by reading
8216 the stabs debug information */
8217 static void rt_printline(unsigned long wanted_pc
)
8219 Stab_Sym
*sym
, *sym_end
;
8220 char func_name
[128], last_func_name
[128];
8221 unsigned long func_addr
, last_pc
, pc
;
8222 const char *incl_files
[INCLUDE_STACK_SIZE
];
8223 int incl_index
, len
, last_line_num
, i
;
8224 const char *str
, *p
;
8226 fprintf(stderr
, "0x%08lx:", wanted_pc
);
8228 func_name
[0] = '\0';
8231 last_func_name
[0] = '\0';
8232 last_pc
= 0xffffffff;
8234 sym
= (Stab_Sym
*)stab_section
->data
+ 1;
8235 sym_end
= (Stab_Sym
*)(stab_section
->data
+ stab_section
->data_offset
);
8236 while (sym
< sym_end
) {
8237 switch(sym
->n_type
) {
8238 /* function start or end */
8240 if (sym
->n_strx
== 0) {
8241 /* we test if between last line and end of function */
8242 pc
= sym
->n_value
+ func_addr
;
8243 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
8245 func_name
[0] = '\0';
8248 str
= stabstr_section
->data
+ sym
->n_strx
;
8249 p
= strchr(str
, ':');
8251 pstrcpy(func_name
, sizeof(func_name
), str
);
8254 if (len
> sizeof(func_name
) - 1)
8255 len
= sizeof(func_name
) - 1;
8256 memcpy(func_name
, str
, len
);
8257 func_name
[len
] = '\0';
8259 func_addr
= sym
->n_value
;
8262 /* line number info */
8264 pc
= sym
->n_value
+ func_addr
;
8265 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
8268 last_line_num
= sym
->n_desc
;
8270 strcpy(last_func_name
, func_name
);
8274 str
= stabstr_section
->data
+ sym
->n_strx
;
8276 if (incl_index
< INCLUDE_STACK_SIZE
) {
8277 incl_files
[incl_index
++] = str
;
8285 if (sym
->n_strx
== 0) {
8286 incl_index
= 0; /* end of translation unit */
8288 str
= stabstr_section
->data
+ sym
->n_strx
;
8289 /* do not add path */
8291 if (len
> 0 && str
[len
- 1] != '/')
8299 /* second pass: we try symtab symbols (no line number info) */
8302 Elf32_Sym
*sym
, *sym_end
;
8305 sym_end
= (Elf32_Sym
*)(symtab_section
->data
+ symtab_section
->data_offset
);
8306 for(sym
= (Elf32_Sym
*)symtab_section
->data
+ 1;
8309 type
= ELF32_ST_TYPE(sym
->st_info
);
8310 if (type
== STT_FUNC
) {
8311 if (wanted_pc
>= sym
->st_value
&&
8312 wanted_pc
< sym
->st_value
+ sym
->st_size
) {
8313 pstrcpy(last_func_name
, sizeof(last_func_name
),
8314 strtab_section
->data
+ sym
->st_name
);
8320 /* did not find any info: */
8321 fprintf(stderr
, " ???\n");
8324 if (last_func_name
[0] != '\0') {
8325 fprintf(stderr
, " %s()", last_func_name
);
8327 if (incl_index
> 0) {
8328 fprintf(stderr
, " (%s:%d",
8329 incl_files
[incl_index
- 1], last_line_num
);
8330 for(i
= incl_index
- 2; i
>= 0; i
--)
8331 fprintf(stderr
, ", included from %s", incl_files
[i
]);
8332 fprintf(stderr
, ")");
8334 fprintf(stderr
, "\n");
8346 /* return the PC at frame level 'level'. Return non zero if not found */
8347 static int rt_get_caller_pc(unsigned long *paddr
,
8348 struct ucontext
*uc
, int level
)
8354 *paddr
= uc
->uc_mcontext
.gregs
[EIP
];
8357 fp
= uc
->uc_mcontext
.gregs
[EBP
];
8358 for(i
=1;i
<level
;i
++) {
8359 /* XXX: check address validity with program info */
8360 if (fp
<= 0x1000 || fp
>= 0xc0000000)
8362 fp
= ((unsigned long *)fp
)[0];
8364 *paddr
= ((unsigned long *)fp
)[1];
8369 #error add arch specific rt_get_caller_pc()
8372 /* emit a run time error at position 'pc' */
8373 void rt_error(struct ucontext
*uc
, const char *fmt
, ...)
8380 fprintf(stderr
, "Runtime error: ");
8381 vfprintf(stderr
, fmt
, ap
);
8382 fprintf(stderr
, "\n");
8383 for(i
=0;i
<num_callers
;i
++) {
8384 if (rt_get_caller_pc(&pc
, uc
, i
) < 0)
8387 fprintf(stderr
, "at ");
8389 fprintf(stderr
, "by ");
8396 /* signal handler for fatal errors */
8397 static void sig_error(int signum
, siginfo_t
*siginf
, void *puc
)
8399 struct ucontext
*uc
= puc
;
8403 switch(siginf
->si_code
) {
8406 rt_error(uc
, "division by zero");
8409 rt_error(uc
, "floating point exception");
8415 if (rt_bound_error_msg
&& *rt_bound_error_msg
)
8416 rt_error(uc
, *rt_bound_error_msg
);
8418 rt_error(uc
, "dereferencing invalid pointer");
8421 rt_error(uc
, "illegal instruction");
8424 rt_error(uc
, "abort() called");
8427 rt_error(uc
, "caught signal %d", signum
);
8434 /* do all relocations (needed before using tcc_get_symbol()) */
8435 int tcc_relocate(TCCState
*s1
)
8442 tcc_add_runtime(s1
);
8444 relocate_common_syms();
8446 /* compute relocation address : section are relocated in place. We
8447 also alloc the bss space */
8448 for(i
= 1; i
< s1
->nb_sections
; i
++) {
8449 s
= s1
->sections
[i
];
8450 if (s
->sh_flags
& SHF_ALLOC
) {
8451 if (s
->sh_type
== SHT_NOBITS
)
8452 s
->data
= tcc_mallocz(s
->data_offset
);
8453 s
->sh_addr
= (unsigned long)s
->data
;
8457 relocate_syms(s1
, 1);
8459 if (s1
->nb_errors
!= 0)
8462 /* relocate each section */
8463 for(i
= 1; i
< s1
->nb_sections
; i
++) {
8464 s
= s1
->sections
[i
];
8466 relocate_section(s1
, s
);
8471 /* launch the compiled program with the given arguments */
8472 int tcc_run(TCCState
*s1
, int argc
, char **argv
)
8474 int (*prog_main
)(int, char **);
8476 if (tcc_relocate(s1
) < 0)
8479 prog_main
= tcc_get_symbol(s1
, "main");
8483 error("debug mode currently not available for Windows");
8485 struct sigaction sigact
;
8486 /* install TCC signal handlers to print debug info on fatal
8488 sigact
.sa_flags
= SA_SIGINFO
| SA_ONESHOT
;
8489 sigact
.sa_sigaction
= sig_error
;
8490 sigemptyset(&sigact
.sa_mask
);
8491 sigaction(SIGFPE
, &sigact
, NULL
);
8492 sigaction(SIGILL
, &sigact
, NULL
);
8493 sigaction(SIGSEGV
, &sigact
, NULL
);
8494 sigaction(SIGBUS
, &sigact
, NULL
);
8495 sigaction(SIGABRT
, &sigact
, NULL
);
8499 #ifdef CONFIG_TCC_BCHECK
8500 if (do_bounds_check
) {
8501 void (*bound_init
)(void);
8503 /* set error function */
8504 rt_bound_error_msg
= (void *)tcc_get_symbol(s1
, "__bound_error_msg");
8506 /* XXX: use .init section so that it also work in binary ? */
8507 bound_init
= (void *)tcc_get_symbol(s1
, "__bound_init");
8511 return (*prog_main
)(argc
, argv
);
8514 TCCState
*tcc_new(void)
8519 s
= tcc_mallocz(sizeof(TCCState
));
8523 s
->output_type
= TCC_OUTPUT_MEMORY
;
8525 /* default include paths */
8526 tcc_add_sysinclude_path(s
, "/usr/local/include");
8527 tcc_add_sysinclude_path(s
, "/usr/include");
8528 tcc_add_sysinclude_path(s
, CONFIG_TCC_PREFIX
"/lib/tcc/include");
8530 /* add all tokens */
8532 memset(hash_ident
, 0, TOK_HASH_SIZE
* sizeof(TokenSym
*));
8534 tok_ident
= TOK_IDENT
;
8539 tok_alloc(p
, r
- p
- 1);
8543 /* we add dummy defines for some special macros to speed up tests
8544 and to have working defined() */
8545 define_push(TOK___LINE__
, MACRO_OBJ
, NULL
, NULL
);
8546 define_push(TOK___FILE__
, MACRO_OBJ
, NULL
, NULL
);
8547 define_push(TOK___DATE__
, MACRO_OBJ
, NULL
, NULL
);
8548 define_push(TOK___TIME__
, MACRO_OBJ
, NULL
, NULL
);
8550 /* standard defines */
8551 tcc_define_symbol(s
, "__STDC__", NULL
);
8552 #if defined(TCC_TARGET_I386)
8553 tcc_define_symbol(s
, "__i386__", NULL
);
8556 tcc_define_symbol(s
, "linux", NULL
);
8558 /* tiny C specific defines */
8559 tcc_define_symbol(s
, "__TINYC__", NULL
);
8561 /* tiny C & gcc defines */
8562 tcc_define_symbol(s
, "__SIZE_TYPE__", "unsigned int");
8563 tcc_define_symbol(s
, "__PTRDIFF_TYPE__", "int");
8564 tcc_define_symbol(s
, "__WCHAR_TYPE__", "int");
8566 /* default library paths */
8567 tcc_add_library_path(s
, "/usr/local/lib");
8568 tcc_add_library_path(s
, "/usr/lib");
8569 tcc_add_library_path(s
, "/lib");
8571 /* no section zero */
8572 dynarray_add((void ***)&s
->sections
, &s
->nb_sections
, NULL
);
8574 /* create standard sections */
8575 text_section
= new_section(s
, ".text", SHT_PROGBITS
, SHF_ALLOC
| SHF_EXECINSTR
);
8576 data_section
= new_section(s
, ".data", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
8577 bss_section
= new_section(s
, ".bss", SHT_NOBITS
, SHF_ALLOC
| SHF_WRITE
);
8579 /* symbols are always generated for linking stage */
8580 symtab_section
= new_symtab(s
, ".symtab", SHT_SYMTAB
, 0,
8582 ".hashtab", SHF_PRIVATE
);
8583 strtab_section
= symtab_section
->link
;
8585 /* private symbol table for dynamic symbols */
8586 s
->dynsymtab_section
= new_symtab(s
, ".dynsymtab", SHT_SYMTAB
, SHF_PRIVATE
,
8588 ".dynhashtab", SHF_PRIVATE
);
8592 void tcc_delete(TCCState
*s1
)
8596 /* free -D defines */
8600 n
= tok_ident
- TOK_IDENT
;
8601 for(i
= 0; i
< n
; i
++)
8602 tcc_free(table_ident
[i
]);
8603 tcc_free(table_ident
);
8605 /* free all sections */
8607 free_section(symtab_section
->hash
);
8609 free_section(s1
->dynsymtab_section
->hash
);
8610 free_section(s1
->dynsymtab_section
->link
);
8611 free_section(s1
->dynsymtab_section
);
8613 for(i
= 1; i
< s1
->nb_sections
; i
++)
8614 free_section(s1
->sections
[i
]);
8615 tcc_free(s1
->sections
);
8617 /* free loaded dlls array */
8618 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++)
8619 tcc_free(s1
->loaded_dlls
[i
]);
8620 tcc_free(s1
->loaded_dlls
);
8623 for(i
= 0; i
< s1
->nb_library_paths
; i
++)
8624 tcc_free(s1
->library_paths
[i
]);
8625 tcc_free(s1
->library_paths
);
8627 /* cached includes */
8628 for(i
= 0; i
< s1
->nb_cached_includes
; i
++)
8629 tcc_free(s1
->cached_includes
[i
]);
8630 tcc_free(s1
->cached_includes
);
8632 for(i
= 0; i
< s1
->nb_include_paths
; i
++)
8633 tcc_free(s1
->include_paths
[i
]);
8634 tcc_free(s1
->include_paths
);
8636 for(i
= 0; i
< s1
->nb_sysinclude_paths
; i
++)
8637 tcc_free(s1
->sysinclude_paths
[i
]);
8638 tcc_free(s1
->sysinclude_paths
);
8643 int tcc_add_include_path(TCCState
*s1
, const char *pathname
)
8647 pathname1
= tcc_strdup(pathname
);
8648 dynarray_add((void ***)&s1
->include_paths
, &s1
->nb_include_paths
, pathname1
);
8652 int tcc_add_sysinclude_path(TCCState
*s1
, const char *pathname
)
8656 pathname1
= tcc_strdup(pathname
);
8657 dynarray_add((void ***)&s1
->sysinclude_paths
, &s1
->nb_sysinclude_paths
, pathname1
);
8661 static int tcc_add_file_internal(TCCState
*s1
, const char *filename
, int flags
)
8666 BufferedFile
*saved_file
;
8668 /* find source file type with extension */
8669 ext
= strrchr(filename
, '.');
8675 file
= tcc_open(s1
, filename
);
8677 if (flags
& AFF_PRINT_ERROR
) {
8678 error_noabort("file '%s' not found", filename
);
8684 if (!ext
|| !strcmp(ext
, "c")) {
8685 /* C file assumed */
8686 ret
= tcc_compile(s1
);
8689 /* assume executable format: auto guess file type */
8690 if (read(fd
, &ehdr
, sizeof(ehdr
)) != sizeof(ehdr
)) {
8691 error_noabort("could not read header");
8694 lseek(fd
, 0, SEEK_SET
);
8696 if (ehdr
.e_ident
[0] == ELFMAG0
&&
8697 ehdr
.e_ident
[1] == ELFMAG1
&&
8698 ehdr
.e_ident
[2] == ELFMAG2
&&
8699 ehdr
.e_ident
[3] == ELFMAG3
) {
8700 file
->line_num
= 0; /* do not display line number if error */
8701 if (ehdr
.e_type
== ET_REL
) {
8702 ret
= tcc_load_object_file(s1
, fd
, 0);
8703 } else if (ehdr
.e_type
== ET_DYN
) {
8704 ret
= tcc_load_dll(s1
, fd
, filename
,
8705 (flags
& AFF_REFERENCED_DLL
) != 0);
8707 error_noabort("unrecognized ELF file");
8710 } else if (memcmp((char *)&ehdr
, ARMAG
, 8) == 0) {
8711 file
->line_num
= 0; /* do not display line number if error */
8712 ret
= tcc_load_archive(s1
, fd
);
8714 /* as GNU ld, consider it is an ld script if not recognized */
8715 ret
= tcc_load_ldscript(s1
);
8717 error_noabort("unrecognized file type");
8732 int tcc_add_file(TCCState
*s
, const char *filename
)
8734 return tcc_add_file_internal(s
, filename
, AFF_PRINT_ERROR
);
8737 int tcc_add_library_path(TCCState
*s
, const char *pathname
)
8741 pathname1
= tcc_strdup(pathname
);
8742 dynarray_add((void ***)&s
->library_paths
, &s
->nb_library_paths
, pathname1
);
8746 /* find and load a dll. Return non zero if not found */
8747 /* XXX: add '-rpath' option support ? */
8748 static int tcc_add_dll(TCCState
*s
, const char *filename
, int flags
)
8753 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
8754 snprintf(buf
, sizeof(buf
), "%s/%s",
8755 s
->library_paths
[i
], filename
);
8756 if (tcc_add_file_internal(s
, buf
, flags
) == 0)
8762 /* the library name is the same as the argument of the '-l' option */
8763 int tcc_add_library(TCCState
*s
, const char *libraryname
)
8769 /* first we look for the dynamic library if not static linking */
8770 if (!s
->static_link
) {
8771 snprintf(buf
, sizeof(buf
), "lib%s.so", libraryname
);
8772 /* if we output to memory, then we simply we dlopen(). */
8773 if (s
->output_type
== TCC_OUTPUT_MEMORY
) {
8774 /* Since the libc is already loaded, we don't need to load it again */
8775 if (!strcmp(libraryname
, "c"))
8777 h
= dlopen(buf
, RTLD_GLOBAL
| RTLD_LAZY
);
8781 if (tcc_add_dll(s
, buf
, 0) == 0)
8786 /* then we look for the static library */
8787 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
8788 snprintf(buf
, sizeof(buf
), "%s/lib%s.a",
8789 s
->library_paths
[i
], libraryname
);
8790 if (tcc_add_file_internal(s
, buf
, 0) == 0)
8796 int tcc_add_symbol(TCCState
*s
, const char *name
, unsigned long val
)
8798 add_elf_sym(symtab_section
, val
, 0,
8799 ELF32_ST_INFO(STB_GLOBAL
, STT_NOTYPE
),
8804 int tcc_set_output_type(TCCState
*s
, int output_type
)
8806 s
->output_type
= output_type
;
8808 /* if bound checking, then add corresponding sections */
8809 #ifdef CONFIG_TCC_BCHECK
8810 if (do_bounds_check
) {
8812 tcc_define_symbol(s
, "__BOUNDS_CHECKING_ON", NULL
);
8813 /* create bounds sections */
8814 bounds_section
= new_section(s
, ".bounds",
8815 SHT_PROGBITS
, SHF_ALLOC
);
8816 lbounds_section
= new_section(s
, ".lbounds",
8817 SHT_PROGBITS
, SHF_ALLOC
);
8821 /* add debug sections */
8824 stab_section
= new_section(s
, ".stab", SHT_PROGBITS
, 0);
8825 stab_section
->sh_entsize
= sizeof(Stab_Sym
);
8826 stabstr_section
= new_section(s
, ".stabstr", SHT_STRTAB
, 0);
8827 put_elf_str(stabstr_section
, "");
8828 stab_section
->link
= stabstr_section
;
8829 /* put first entry */
8830 put_stabs("", 0, 0, 0, 0);
8833 /* add libc crt1/crti objects */
8834 if (output_type
== TCC_OUTPUT_EXE
||
8835 output_type
== TCC_OUTPUT_DLL
) {
8836 if (output_type
!= TCC_OUTPUT_DLL
)
8837 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crt1.o");
8838 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crti.o");
8843 #if !defined(LIBTCC)
8845 static int64_t getclock_us(void)
8850 return (tb
.time
* 1000LL + tb
.millitm
) * 1000LL;
8853 gettimeofday(&tv
, NULL
);
8854 return tv
.tv_sec
* 1000000LL + tv
.tv_usec
;
8860 printf("tcc version 0.9.14 - Tiny C Compiler - Copyright (C) 2001, 2002 Fabrice Bellard\n"
8861 "usage: tcc [-c] [-o outfile] [-Bdir] [-bench] [-Idir] [-Dsym[=val]] [-Usym]\n"
8862 " [-g] [-b] [-bt N] [-Ldir] [-llib] [-shared] [-static]\n"
8863 " [--] infile1 [infile2... --] [infile_args...]\n"
8865 "General options:\n"
8866 " -c compile only - generate an object file\n"
8867 " -o outfile set output filename\n"
8868 " -- allows multiples input files if no -o option given. Also\n"
8869 " separate input files from runtime arguments\n"
8870 " -Bdir set tcc internal library path\n"
8871 " -bench output compilation statistics\n"
8872 "Preprocessor options:\n"
8873 " -Idir add include path 'dir'\n"
8874 " -Dsym[=val] define 'sym' with value 'val'\n"
8875 " -Usym undefine 'sym'\n"
8877 " -Ldir add library path 'dir'\n"
8878 " -llib link with dynamic or static library 'lib'\n"
8879 " -shared generate a shared library\n"
8880 " -static static linking\n"
8881 " -r relocatable output\n"
8882 "Debugger options:\n"
8883 " -g generate runtime debug info\n"
8884 #ifdef CONFIG_TCC_BCHECK
8885 " -b compile with built-in memory and bounds checker (implies -g)\n"
8887 " -bt N show N callers in stack traces\n"
8891 int main(int argc
, char **argv
)
8894 int optind
, output_type
, multiple_files
, i
, reloc_output
;
8897 int nb_files
, nb_libraries
, nb_objfiles
, dminus
, ret
;
8898 char objfilename
[1024];
8899 int64_t start_time
= 0;
8902 output_type
= TCC_OUTPUT_MEMORY
;
8913 if (optind
>= argc
) {
8921 /* add a new file */
8922 dynarray_add((void ***)&files
, &nb_files
, r
);
8923 if (!multiple_files
) {
8925 /* argv[0] will be this file */
8928 } else if (r
[1] == '-') {
8929 /* '--' enables multiple files input and also ends several file input */
8930 if (dminus
&& multiple_files
) {
8931 optind
--; /* argv[0] will be '--' */
8936 } else if (r
[1] == 'h' || r
[1] == '?') {
8940 } else if (r
[1] == 'I') {
8941 if (tcc_add_include_path(s
, r
+ 2) < 0)
8942 error("too many include paths");
8943 } else if (r
[1] == 'D') {
8946 value
= strchr(sym
, '=');
8951 tcc_define_symbol(s
, sym
, value
);
8952 } else if (r
[1] == 'U') {
8953 tcc_undefine_symbol(s
, r
+ 2);
8954 } else if (r
[1] == 'L') {
8955 tcc_add_library_path(s
, r
+ 2);
8956 } else if (r
[1] == 'B') {
8957 /* set tcc utilities path (mainly for tcc development) */
8958 tcc_lib_path
= r
+ 2;
8959 } else if (r
[1] == 'l') {
8960 dynarray_add((void ***)&files
, &nb_files
, r
);
8962 } else if (!strcmp(r
+ 1, "bench")) {
8964 } else if (!strcmp(r
+ 1, "bt")) {
8965 num_callers
= atoi(argv
[optind
++]);
8967 #ifdef CONFIG_TCC_BCHECK
8969 do_bounds_check
= 1;
8975 } else if (r
[1] == 'c') {
8977 output_type
= TCC_OUTPUT_OBJ
;
8978 } else if (!strcmp(r
+ 1, "static")) {
8980 } else if (!strcmp(r
+ 1, "shared")) {
8981 output_type
= TCC_OUTPUT_DLL
;
8982 } else if (r
[1] == 'o') {
8986 outfile
= argv
[optind
++];
8987 } else if (r
[1] == 'r') {
8988 /* generate a .o merging several output files */
8990 output_type
= TCC_OUTPUT_OBJ
;
8991 } else if (r
[1] == 'W' || r
[1] == 'O' || r
[1] == 'm' || r
[1] == 'f') {
8992 /* ignore those options to be a drop-in replacement for gcc */
8994 error("invalid option -- '%s'", r
);
8998 nb_objfiles
= nb_files
- nb_libraries
;
9000 /* if outfile provided without other options, we output an
9002 if (outfile
&& output_type
== TCC_OUTPUT_MEMORY
)
9003 output_type
= TCC_OUTPUT_EXE
;
9005 /* check -c consistency : only single file handled. XXX: checks file type */
9006 if (output_type
== TCC_OUTPUT_OBJ
&& !reloc_output
) {
9007 /* accepts only a single input file */
9008 if (nb_objfiles
!= 1)
9009 error("cannot specify multiple files with -c");
9010 if (nb_libraries
!= 0)
9011 error("cannot specify libraries with -c");
9014 /* compute default outfile name */
9015 if (output_type
!= TCC_OUTPUT_MEMORY
&& !outfile
) {
9016 if (output_type
== TCC_OUTPUT_OBJ
&& !reloc_output
) {
9018 /* add .o extension */
9019 pstrcpy(objfilename
, sizeof(objfilename
) - 1, files
[0]);
9020 ext
= strrchr(objfilename
, '.');
9022 goto default_outfile
;
9023 strcpy(ext
+ 1, "o");
9026 pstrcpy(objfilename
, sizeof(objfilename
), "a.out");
9028 outfile
= objfilename
;
9032 start_time
= getclock_us();
9035 tcc_set_output_type(s
, output_type
);
9037 /* compile or add each files or library */
9038 for(i
= 0;i
< nb_files
; i
++) {
9039 const char *filename
;
9041 filename
= files
[i
];
9042 if (filename
[0] == '-') {
9043 if (tcc_add_library(s
, filename
+ 2) < 0)
9044 error("cannot find %s", filename
);
9046 if (tcc_add_file(s
, filename
) < 0) {
9053 /* free all files */
9058 total_time
= (double)(getclock_us() - start_time
) / 1000000.0;
9059 if (total_time
< 0.001)
9061 if (total_bytes
< 1)
9063 printf("%d idents, %d lines, %d bytes, %0.3f s, %d lines/s, %0.1f MB/s\n",
9064 tok_ident
- TOK_IDENT
, total_lines
, total_bytes
,
9065 total_time
, (int)(total_lines
/ total_time
),
9066 total_bytes
/ total_time
/ 1000000.0);
9069 if (s
->output_type
!= TCC_OUTPUT_MEMORY
) {
9070 tcc_output_file(s
, outfile
);
9073 ret
= tcc_run(s
, argc
- optind
, argv
+ optind
);
9076 /* XXX: cannot do it with bound checking because of the malloc hooks */
9077 if (!do_bounds_check
)
9082 printf("memory: %d bytes, max = %d bytes\n", mem_cur_size
, mem_max_size
);