2 * TCC - Tiny C Compiler
4 * Copyright (c) 2001-2004 Fabrice Bellard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #define CONFIG_TCC_STATIC
43 #include <sys/timeb.h>
45 #define inline __inline
52 #include <sys/ucontext.h>
56 #endif /* !CONFIG_TCCBOOT */
73 /* preprocessor debug */
75 /* include file debug */
83 /* target selection */
84 //#define TCC_TARGET_I386 /* i386 code generator */
85 //#define TCC_TARGET_ARM /* ARMv4 code generator */
86 //#define TCC_TARGET_C67 /* TMS320C67xx code generator */
87 //#define TCC_TARGET_X86_64 /* x86-64 code generator */
89 /* default target is I386 */
90 #if !defined(TCC_TARGET_I386) && !defined(TCC_TARGET_ARM) && \
91 !defined(TCC_TARGET_C67) && !defined(TCC_TARGET_X86_64)
92 #define TCC_TARGET_I386
95 #if !defined(_WIN32) && !defined(TCC_UCLIBC) && !defined(TCC_TARGET_ARM) && \
96 !defined(TCC_TARGET_C67) && !defined(TCC_TARGET_X86_64)
97 #define CONFIG_TCC_BCHECK /* enable bound checking code */
100 #if defined(_WIN32) && !defined(TCC_TARGET_PE)
101 #define CONFIG_TCC_STATIC
104 /* define it to include assembler support */
105 #if !defined(TCC_TARGET_ARM) && !defined(TCC_TARGET_C67) && \
106 !defined(TCC_TARGET_X86_64)
107 #define CONFIG_TCC_ASM
110 /* object format selection */
111 #if defined(TCC_TARGET_C67)
112 #define TCC_TARGET_COFF
121 /* path to find crt1.o, crti.o and crtn.o. Only needed when generating
122 executables or dlls */
123 #define CONFIG_TCC_CRT_PREFIX CONFIG_SYSROOT "/usr/lib"
125 #define INCLUDE_STACK_SIZE 32
126 #define IFDEF_STACK_SIZE 64
127 #define VSTACK_SIZE 256
128 #define STRING_MAX_SIZE 1024
129 #define PACK_STACK_SIZE 8
131 #define TOK_HASH_SIZE 8192 /* must be a power of two */
132 #define TOK_ALLOC_INCR 512 /* must be a power of two */
133 #define TOK_MAX_SIZE 4 /* token max size in int unit when stored in string */
135 /* token symbol management */
136 typedef struct TokenSym
{
137 struct TokenSym
*hash_next
;
138 struct Sym
*sym_define
; /* direct pointer to define */
139 struct Sym
*sym_label
; /* direct pointer to label */
140 struct Sym
*sym_struct
; /* direct pointer to structure */
141 struct Sym
*sym_identifier
; /* direct pointer to identifier */
142 int tok
; /* token number */
148 typedef unsigned short nwchar_t
;
150 typedef int nwchar_t
;
153 typedef struct CString
{
154 int size
; /* size in bytes */
155 void *data
; /* either 'char *' or 'nwchar_t *' */
157 void *data_allocated
; /* if non NULL, data has been malloced */
160 /* type definition */
161 typedef struct CType
{
167 typedef union CValue
{
173 unsigned int ul
; /* address (should be unsigned long on 64 bit cpu) */
175 unsigned long long ull
;
176 struct CString
*cstr
;
182 typedef struct SValue
{
183 CType type
; /* type */
184 unsigned short r
; /* register + flags */
185 unsigned short r2
; /* second register, used for 'long long'
186 type. If not used, set to VT_CONST */
187 CValue c
; /* constant, if VT_CONST */
188 struct Sym
*sym
; /* symbol, if (VT_SYM | VT_CONST) */
191 /* symbol management */
193 int v
; /* symbol token */
194 long r
; /* associated register */
195 long c
; /* associated number */
196 CType type
; /* associated type */
197 struct Sym
*next
; /* next related symbol */
198 struct Sym
*prev
; /* prev symbol in stack */
199 struct Sym
*prev_tok
; /* previous symbol for this token */
202 /* section definition */
203 /* XXX: use directly ELF structure for parameters ? */
204 /* special flag to indicate that the section should not be linked to
206 #define SHF_PRIVATE 0x80000000
208 typedef struct Section
{
209 unsigned long data_offset
; /* current data offset */
210 unsigned char *data
; /* section data */
211 unsigned long data_allocated
; /* used for realloc() handling */
212 int sh_name
; /* elf section name (only used during output) */
213 int sh_num
; /* elf section number */
214 int sh_type
; /* elf section type */
215 int sh_flags
; /* elf section flags */
216 int sh_info
; /* elf section info */
217 int sh_addralign
; /* elf section alignment */
218 int sh_entsize
; /* elf entry size */
219 unsigned long sh_size
; /* section size (only used during output) */
220 unsigned long sh_addr
; /* address at which the section is relocated */
221 unsigned long sh_offset
; /* file offset */
222 int nb_hashed_syms
; /* used to resize the hash table */
223 struct Section
*link
; /* link to another section */
224 struct Section
*reloc
; /* corresponding section for relocation, if any */
225 struct Section
*hash
; /* hash table for symbols */
226 struct Section
*next
;
227 char name
[1]; /* section name */
230 typedef struct DLLReference
{
236 /* GNUC attribute definition */
237 typedef struct AttributeDef
{
241 int func_attr
; /* calling convention, exports, ... */
244 /* -------------------------------------------------- */
245 /* gr: wrappers for casting sym->r for other purposes */
253 #define FUNC_CALL(r) (((func_attr_t*)&(r))->func_call)
254 #define FUNC_EXPORT(r) (((func_attr_t*)&(r))->func_export)
255 #define FUNC_ARGS(r) (((func_attr_t*)&(r))->func_args)
256 #define INLINE_DEF(r) (*(int **)&(r))
257 /* -------------------------------------------------- */
259 #define SYM_STRUCT 0x40000000 /* struct/union/enum symbol space */
260 #define SYM_FIELD 0x20000000 /* struct/union field symbol space */
261 #define SYM_FIRST_ANOM 0x10000000 /* first anonymous sym */
263 /* stored in 'Sym.c' field */
264 #define FUNC_NEW 1 /* ansi function prototype */
265 #define FUNC_OLD 2 /* old function prototype */
266 #define FUNC_ELLIPSIS 3 /* ansi function prototype with ... */
268 /* stored in 'Sym.r' field */
269 #define FUNC_CDECL 0 /* standard c call */
270 #define FUNC_STDCALL 1 /* pascal c call */
271 #define FUNC_FASTCALL1 2 /* first param in %eax */
272 #define FUNC_FASTCALL2 3 /* first parameters in %eax, %edx */
273 #define FUNC_FASTCALL3 4 /* first parameter in %eax, %edx, %ecx */
274 #define FUNC_FASTCALLW 5 /* first parameter in %ecx, %edx */
276 /* field 'Sym.t' for macros */
277 #define MACRO_OBJ 0 /* object like macro */
278 #define MACRO_FUNC 1 /* function like macro */
280 /* field 'Sym.r' for C labels */
281 #define LABEL_DEFINED 0 /* label is defined */
282 #define LABEL_FORWARD 1 /* label is forward defined */
283 #define LABEL_DECLARED 2 /* label is declared but never used */
285 /* type_decl() types */
286 #define TYPE_ABSTRACT 1 /* type without variable */
287 #define TYPE_DIRECT 2 /* type with variable */
289 #define IO_BUF_SIZE 8192
291 typedef struct BufferedFile
{
295 int line_num
; /* current line number - here to simplify code */
296 int ifndef_macro
; /* #ifndef macro / #endif search */
297 int ifndef_macro_saved
; /* saved ifndef_macro */
298 int *ifdef_stack_ptr
; /* ifdef_stack value at the start of the file */
299 char inc_type
; /* type of include */
300 char inc_filename
[512]; /* filename specified by the user */
301 char filename
[1024]; /* current filename - here to simplify code */
302 unsigned char buffer
[IO_BUF_SIZE
+ 1]; /* extra size for CH_EOB char */
305 #define CH_EOB '\\' /* end of buffer or '\0' char in file */
306 #define CH_EOF (-1) /* end of file */
308 /* parsing state (used to save parser state to reparse part of the
309 source several times) */
310 typedef struct ParseState
{
317 /* used to record tokens */
318 typedef struct TokenString
{
325 /* include file cache, used to find files faster and also to eliminate
326 inclusion if the include file is protected by #ifndef ... #endif */
327 typedef struct CachedInclude
{
329 int hash_next
; /* -1 if none */
330 char type
; /* '"' or '>' to give include type */
331 char filename
[1]; /* path specified in #include */
334 #define CACHED_INCLUDES_HASH_SIZE 512
337 static struct BufferedFile
*file
;
339 static CString tok_spaces
; /* spaces before current token */
341 static CString tokcstr
; /* current parsed string, if any */
342 /* additional informations about token */
343 static int tok_flags
;
344 #define TOK_FLAG_BOL 0x0001 /* beginning of line before */
345 #define TOK_FLAG_BOF 0x0002 /* beginning of file before */
346 #define TOK_FLAG_ENDIF 0x0004 /* a endif was found matching starting #ifdef */
347 #define TOK_FLAG_EOF 0x0008 /* end of file */
349 static int *macro_ptr
, *macro_ptr_allocated
;
350 static int *unget_saved_macro_ptr
;
351 static int unget_saved_buffer
[TOK_MAX_SIZE
+ 1];
352 static int unget_buffer_enabled
;
353 static int parse_flags
;
354 #define PARSE_FLAG_PREPROCESS 0x0001 /* activate preprocessing */
355 #define PARSE_FLAG_TOK_NUM 0x0002 /* return numbers instead of TOK_PPNUM */
356 #define PARSE_FLAG_LINEFEED 0x0004 /* line feed is returned as a
357 token. line feed is also
359 #define PARSE_FLAG_ASM_COMMENTS 0x0008 /* '#' can be used for line comment */
361 static Section
*text_section
, *data_section
, *bss_section
; /* predefined sections */
362 static Section
*cur_text_section
; /* current section where function code is
364 #ifdef CONFIG_TCC_ASM
365 static Section
*last_text_section
; /* to handle .previous asm directive */
367 /* bound check related sections */
368 static Section
*bounds_section
; /* contains global data bound description */
369 static Section
*lbounds_section
; /* contains local data bound description */
370 /* symbol sections */
371 static Section
*symtab_section
, *strtab_section
;
374 static Section
*stab_section
, *stabstr_section
;
376 /* loc : local variable index
377 ind : output code index
379 anon_sym: anonymous symbol index
381 static int rsym
, anon_sym
, ind
, loc
;
382 /* expression generation modifiers */
383 static int const_wanted
; /* true if constant wanted */
384 static int nocode_wanted
; /* true if no code generation wanted for an expression */
385 static int global_expr
; /* true if compound literals must be allocated
386 globally (used during initializers parsing */
387 static CType func_vt
; /* current function return type (used by return
390 static int last_line_num
, last_ind
, func_ind
; /* debug last line number and pc */
391 static int tok_ident
;
392 static TokenSym
**table_ident
;
393 static TokenSym
*hash_ident
[TOK_HASH_SIZE
];
394 static char token_buf
[STRING_MAX_SIZE
+ 1];
395 static char *funcname
;
396 static Sym
*global_stack
, *local_stack
;
397 static Sym
*define_stack
;
398 static Sym
*global_label_stack
, *local_label_stack
;
399 /* symbol allocator */
400 #define SYM_POOL_NB (8192 / sizeof(Sym))
401 static Sym
*sym_free_first
;
402 static void **sym_pools
;
403 static int nb_sym_pools
;
405 static SValue vstack
[VSTACK_SIZE
], *vtop
;
406 /* some predefined types */
407 static CType char_pointer_type
, func_old_type
, int_type
;
408 /* true if isid(c) || isnum(c) */
409 static unsigned char isidnum_table
[256-CH_EOF
];
411 /* display some information during compilation */
412 static int verbose
= 0;
414 /* compile with debug symbol (and use them if error during execution) */
415 static int do_debug
= 0;
417 /* compile with built-in memory and bounds checker */
418 static int do_bounds_check
= 0;
420 /* display benchmark infos */
422 static int do_bench
= 0;
424 static int total_lines
;
425 static int total_bytes
;
427 /* use GNU C extensions */
428 static int gnu_ext
= 1;
430 /* use Tiny C extensions */
431 static int tcc_ext
= 1;
433 /* max number of callers shown if error */
434 static int num_callers
= 6;
435 static const char **rt_bound_error_msg
;
437 /* XXX: get rid of this ASAP */
438 static struct TCCState
*tcc_state
;
440 /* give the path of the tcc libraries */
441 static const char *tcc_lib_path
= CONFIG_TCCDIR
;
446 BufferedFile
**include_stack_ptr
;
447 int *ifdef_stack_ptr
;
449 /* include file handling */
450 char **include_paths
;
451 int nb_include_paths
;
452 char **sysinclude_paths
;
453 int nb_sysinclude_paths
;
454 CachedInclude
**cached_includes
;
455 int nb_cached_includes
;
457 char **library_paths
;
458 int nb_library_paths
;
460 /* array of all loaded dlls (including those referenced by loaded
462 DLLReference
**loaded_dlls
;
467 int nb_sections
; /* number of sections, including first dummy section */
469 Section
**priv_sections
;
470 int nb_priv_sections
; /* number of private sections */
475 unsigned long *got_offsets
;
477 /* give the correspondance from symtab indexes to dynsym indexes */
478 int *symtab_to_dynsym
;
480 /* temporary dynamic symbol sections (for dll loading) */
481 Section
*dynsymtab_section
;
482 /* exported dynamic symbol section */
485 int nostdinc
; /* if true, no standard headers are added */
486 int nostdlib
; /* if true, no standard libraries are added */
488 int nocommon
; /* if true, do not use common symbols for .bss data */
490 /* if true, static linking is performed */
493 /* soname as specified on the command line (-soname) */
496 /* if true, all symbols are exported */
499 /* if true, only link in referenced objects from archive */
502 /* address of text section */
503 unsigned long text_addr
;
506 /* output format, see TCC_OUTPUT_FORMAT_xxx */
509 /* C language options */
510 int char_is_unsigned
;
511 int leading_underscore
;
513 /* warning switches */
514 int warn_write_strings
;
515 int warn_unsupported
;
518 int warn_implicit_function_declaration
;
522 void (*error_func
)(void *opaque
, const char *msg
);
523 int error_set_jmp_enabled
;
524 jmp_buf error_jmp_buf
;
527 /* tiny assembler state */
530 /* see include_stack_ptr */
531 BufferedFile
*include_stack
[INCLUDE_STACK_SIZE
];
533 /* see ifdef_stack_ptr */
534 int ifdef_stack
[IFDEF_STACK_SIZE
];
536 /* see cached_includes */
537 int cached_includes_hash
[CACHED_INCLUDES_HASH_SIZE
];
540 int pack_stack
[PACK_STACK_SIZE
];
543 /* output file for preprocessing */
547 /* The current value can be: */
548 #define VT_VALMASK 0x00ff
549 #define VT_CONST 0x00f0 /* constant in vc
550 (must be first non register value) */
551 #define VT_LLOCAL 0x00f1 /* lvalue, offset on stack */
552 #define VT_LOCAL 0x00f2 /* offset on stack */
553 #define VT_CMP 0x00f3 /* the value is stored in processor flags (in vc) */
554 #define VT_JMP 0x00f4 /* value is the consequence of jmp true (even) */
555 #define VT_JMPI 0x00f5 /* value is the consequence of jmp false (odd) */
556 #define VT_LVAL 0x0100 /* var is an lvalue */
557 #define VT_SYM 0x0200 /* a symbol value is added */
558 #define VT_MUSTCAST 0x0400 /* value must be casted to be correct (used for
559 char/short stored in integer registers) */
560 #define VT_MUSTBOUND 0x0800 /* bound checking must be done before
561 dereferencing value */
562 #define VT_BOUNDED 0x8000 /* value is bounded. The address of the
563 bounding function call point is in vc */
564 #define VT_LVAL_BYTE 0x1000 /* lvalue is a byte */
565 #define VT_LVAL_SHORT 0x2000 /* lvalue is a short */
566 #define VT_LVAL_UNSIGNED 0x4000 /* lvalue is unsigned */
567 #define VT_LVAL_TYPE (VT_LVAL_BYTE | VT_LVAL_SHORT | VT_LVAL_UNSIGNED)
570 #define VT_INT 0 /* integer type */
571 #define VT_BYTE 1 /* signed byte type */
572 #define VT_SHORT 2 /* short type */
573 #define VT_VOID 3 /* void type */
574 #define VT_PTR 4 /* pointer */
575 #define VT_ENUM 5 /* enum definition */
576 #define VT_FUNC 6 /* function type */
577 #define VT_STRUCT 7 /* struct/union definition */
578 #define VT_FLOAT 8 /* IEEE float */
579 #define VT_DOUBLE 9 /* IEEE double */
580 #define VT_LDOUBLE 10 /* IEEE long double */
581 #define VT_BOOL 11 /* ISOC99 boolean type */
582 #define VT_LLONG 12 /* 64 bit integer */
583 #define VT_LONG 13 /* long integer (NEVER USED as type, only
585 #define VT_BTYPE 0x000f /* mask for basic type */
586 #define VT_UNSIGNED 0x0010 /* unsigned type */
587 #define VT_ARRAY 0x0020 /* array type (also has VT_PTR) */
588 #define VT_BITFIELD 0x0040 /* bitfield modifier */
589 #define VT_CONSTANT 0x0800 /* const modifier */
590 #define VT_VOLATILE 0x1000 /* volatile modifier */
591 #define VT_SIGNED 0x2000 /* signed type */
594 #define VT_EXTERN 0x00000080 /* extern definition */
595 #define VT_STATIC 0x00000100 /* static variable */
596 #define VT_TYPEDEF 0x00000200 /* typedef definition */
597 #define VT_INLINE 0x00000400 /* inline definition */
599 #define VT_STRUCT_SHIFT 16 /* shift for bitfield shift values */
601 /* type mask (except storage) */
602 #define VT_STORAGE (VT_EXTERN | VT_STATIC | VT_TYPEDEF | VT_INLINE)
603 #define VT_TYPE (~(VT_STORAGE))
607 /* warning: the following compare tokens depend on i386 asm code */
614 #define TOK_Nset 0x98
615 #define TOK_Nclear 0x99
621 #define TOK_LAND 0xa0
625 #define TOK_MID 0xa3 /* inc/dec, to void constant */
627 #define TOK_UDIV 0xb0 /* unsigned division */
628 #define TOK_UMOD 0xb1 /* unsigned modulo */
629 #define TOK_PDIV 0xb2 /* fast division with undefined rounding for pointers */
630 #define TOK_CINT 0xb3 /* number in tokc */
631 #define TOK_CCHAR 0xb4 /* char constant in tokc */
632 #define TOK_STR 0xb5 /* pointer to string in tokc */
633 #define TOK_TWOSHARPS 0xb6 /* ## preprocessing token */
634 #define TOK_LCHAR 0xb7
635 #define TOK_LSTR 0xb8
636 #define TOK_CFLOAT 0xb9 /* float constant */
637 #define TOK_LINENUM 0xba /* line number info */
638 #define TOK_CDOUBLE 0xc0 /* double constant */
639 #define TOK_CLDOUBLE 0xc1 /* long double constant */
640 #define TOK_UMULL 0xc2 /* unsigned 32x32 -> 64 mul */
641 #define TOK_ADDC1 0xc3 /* add with carry generation */
642 #define TOK_ADDC2 0xc4 /* add with carry use */
643 #define TOK_SUBC1 0xc5 /* add with carry generation */
644 #define TOK_SUBC2 0xc6 /* add with carry use */
645 #define TOK_CUINT 0xc8 /* unsigned int constant */
646 #define TOK_CLLONG 0xc9 /* long long constant */
647 #define TOK_CULLONG 0xca /* unsigned long long constant */
648 #define TOK_ARROW 0xcb
649 #define TOK_DOTS 0xcc /* three dots */
650 #define TOK_SHR 0xcd /* unsigned shift right */
651 #define TOK_PPNUM 0xce /* preprocessor number */
653 #define TOK_SHL 0x01 /* shift left */
654 #define TOK_SAR 0x02 /* signed shift right */
656 /* assignement operators : normal operator or 0x80 */
657 #define TOK_A_MOD 0xa5
658 #define TOK_A_AND 0xa6
659 #define TOK_A_MUL 0xaa
660 #define TOK_A_ADD 0xab
661 #define TOK_A_SUB 0xad
662 #define TOK_A_DIV 0xaf
663 #define TOK_A_XOR 0xde
664 #define TOK_A_OR 0xfc
665 #define TOK_A_SHL 0x81
666 #define TOK_A_SAR 0x82
669 #define offsetof(type, field) ((size_t) &((type *)0)->field)
673 #define countof(tab) (sizeof(tab) / sizeof((tab)[0]))
676 /* WARNING: the content of this string encodes token numbers */
677 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";
679 #define TOK_EOF (-1) /* end of file */
680 #define TOK_LINEFEED 10 /* line feed */
682 /* all identificators and strings have token above that */
683 #define TOK_IDENT 256
685 /* only used for i386 asm opcodes definitions */
686 #define DEF_ASM(x) DEF(TOK_ASM_ ## x, #x)
689 DEF(TOK_ASM_ ## x ## b, #x "b") \
690 DEF(TOK_ASM_ ## x ## w, #x "w") \
691 DEF(TOK_ASM_ ## x ## l, #x "l") \
692 DEF(TOK_ASM_ ## x, #x)
695 DEF(TOK_ASM_ ## x ## w, #x "w") \
696 DEF(TOK_ASM_ ## x ## l, #x "l") \
697 DEF(TOK_ASM_ ## x, #x)
700 DEF(TOK_ASM_ ## f ## x ## s, "f" #x "s") \
701 DEF(TOK_ASM_ ## fi ## x ## l, "fi" #x "l") \
702 DEF(TOK_ASM_ ## f ## x ## l, "f" #x "l") \
703 DEF(TOK_ASM_ ## fi ## x ## s, "fi" #x "s")
706 DEF(TOK_ASM_ ## f ## x, "f" #x ) \
707 DEF(TOK_ASM_ ## f ## x ## p, "f" #x "p") \
710 #define DEF_ASMTEST(x) \
742 #define TOK_ASM_int TOK_INT
745 TOK_LAST
= TOK_IDENT
- 1,
746 #define DEF(id, str) id,
751 static const char tcc_keywords
[] =
752 #define DEF(id, str) str "\0"
757 #define TOK_UIDENT TOK_DEFINE
760 #define snprintf _snprintf
761 #define vsnprintf _vsnprintf
763 #define strtold (long double)strtod
764 #define strtof (float)strtod
765 #define strtoll (long long)strtol
767 #elif defined(TCC_UCLIBC) || defined(__FreeBSD__) || defined(__DragonFly__) \
768 || defined(__OpenBSD__)
769 /* currently incorrect */
770 long double strtold(const char *nptr
, char **endptr
)
772 return (long double)strtod(nptr
, endptr
);
774 float strtof(const char *nptr
, char **endptr
)
776 return (float)strtod(nptr
, endptr
);
779 /* XXX: need to define this to use them in non ISOC99 context */
780 extern float strtof (const char *__nptr
, char **__endptr
);
781 extern long double strtold (const char *__nptr
, char **__endptr
);
784 static char *pstrcpy(char *buf
, int buf_size
, const char *s
);
785 static char *pstrcat(char *buf
, int buf_size
, const char *s
);
786 static char *tcc_basename(const char *name
);
787 static char *tcc_fileextension (const char *p
);
789 static void next(void);
790 static void next_nomacro(void);
791 static void parse_expr_type(CType
*type
);
792 static void expr_type(CType
*type
);
793 static void unary_type(CType
*type
);
794 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
,
795 int case_reg
, int is_expr
);
796 static int expr_const(void);
797 static void expr_eq(void);
798 static void gexpr(void);
799 static void gen_inline_functions(void);
800 static void decl(int l
);
801 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
802 int first
, int size_only
);
803 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
804 int has_init
, int v
, int scope
);
806 void gv2(int rc1
, int rc2
);
807 void move_reg(int r
, int s
);
808 void save_regs(int n
);
809 void save_reg(int r
);
814 int get_reg_ex(int rc
,int rc2
);
817 struct macro_level
*prev
;
821 static void macro_subst(TokenString
*tok_str
, Sym
**nested_list
,
822 const int *macro_str
, struct macro_level
**can_read_stream
);
824 void force_charshort_cast(int t
);
825 static void gen_cast(CType
*type
);
827 static Sym
*sym_find(int v
);
828 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
);
831 static int type_size(CType
*type
, int *a
);
832 static inline CType
*pointed_type(CType
*type
);
833 static int pointed_size(CType
*type
);
834 static int lvalue_type(int t
);
835 static int parse_btype(CType
*type
, AttributeDef
*ad
);
836 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
);
837 static int compare_types(CType
*type1
, CType
*type2
, int unqualified
);
838 static int is_compatible_types(CType
*type1
, CType
*type2
);
839 static int is_compatible_parameter_types(CType
*type1
, CType
*type2
);
841 int ieee_finite(double d
);
842 void error(const char *fmt
, ...);
844 void vpushll(long long v
);
847 void lexpand_nr(void);
848 static void vpush_global_sym(CType
*type
, int v
);
849 void vset(CType
*type
, int r
, int v
);
850 void type_to_str(char *buf
, int buf_size
,
851 CType
*type
, const char *varstr
);
852 char *get_tok_str(int v
, CValue
*cv
);
853 static Sym
*get_sym_ref(CType
*type
, Section
*sec
,
854 unsigned long offset
, unsigned long size
);
855 static Sym
*external_global_sym(int v
, CType
*type
, int r
);
857 /* section generation */
858 static void section_realloc(Section
*sec
, unsigned long new_size
);
859 static void *section_ptr_add(Section
*sec
, unsigned long size
);
860 static void put_extern_sym(Sym
*sym
, Section
*section
,
861 unsigned long value
, unsigned long size
);
862 static void greloc(Section
*s
, Sym
*sym
, unsigned long addr
, int type
);
863 static int put_elf_str(Section
*s
, const char *sym
);
864 static int put_elf_sym(Section
*s
,
865 unsigned long value
, unsigned long size
,
866 int info
, int other
, int shndx
, const char *name
);
867 static int add_elf_sym(Section
*s
, unsigned long value
, unsigned long size
,
868 int info
, int other
, int sh_num
, const char *name
);
869 static void put_elf_reloc(Section
*symtab
, Section
*s
, unsigned long offset
,
870 int type
, int symbol
);
871 static void put_stabs(const char *str
, int type
, int other
, int desc
,
872 unsigned long value
);
873 static void put_stabs_r(const char *str
, int type
, int other
, int desc
,
874 unsigned long value
, Section
*sec
, int sym_index
);
875 static void put_stabn(int type
, int other
, int desc
, int value
);
876 static void put_stabd(int type
, int other
, int desc
);
877 static int tcc_add_dll(TCCState
*s
, const char *filename
, int flags
);
879 #define AFF_PRINT_ERROR 0x0001 /* print error if file not found */
880 #define AFF_REFERENCED_DLL 0x0002 /* load a referenced dll from another dll */
881 #define AFF_PREPROCESS 0x0004 /* preprocess file */
882 static int tcc_add_file_internal(TCCState
*s
, const char *filename
, int flags
);
885 int tcc_output_coff(TCCState
*s1
, FILE *f
);
888 void *resolve_sym(TCCState
*s1
, const char *sym
, int type
);
889 int pe_load_def_file(struct TCCState
*s1
, int fd
);
890 int pe_test_res_file(void *v
, int size
);
891 int pe_load_res_file(struct TCCState
*s1
, int fd
);
892 void pe_add_runtime(struct TCCState
*s1
);
893 void pe_guess_outfile(char *objfilename
, int output_type
);
894 int pe_output_file(struct TCCState
*s1
, const char *filename
);
898 #ifdef CONFIG_TCC_ASM
900 typedef struct ExprValue
{
905 #define MAX_ASM_OPERANDS 30
907 typedef struct ASMOperand
{
908 int id
; /* GCC 3 optionnal identifier (0 if number only supported */
910 char asm_str
[16]; /* computed asm string for operand */
911 SValue
*vt
; /* C value of the expression */
912 int ref_index
; /* if >= 0, gives reference to a output constraint */
913 int input_index
; /* if >= 0, gives reference to an input constraint */
914 int priority
; /* priority, used to assign registers */
915 int reg
; /* if >= 0, register number used for this operand */
916 int is_llong
; /* true if double register value */
917 int is_memory
; /* true if memory operand */
918 int is_rw
; /* for '+' modifier */
921 static void asm_expr(TCCState
*s1
, ExprValue
*pe
);
922 static int asm_int_expr(TCCState
*s1
);
923 static int find_constraint(ASMOperand
*operands
, int nb_operands
,
924 const char *name
, const char **pp
);
926 static int tcc_assemble(TCCState
*s1
, int do_preprocess
);
930 static void asm_instr(void);
931 static void asm_global_instr(void);
933 /* true if float/double/long double type */
934 static inline int is_float(int t
)
938 return bt
== VT_LDOUBLE
|| bt
== VT_DOUBLE
|| bt
== VT_FLOAT
;
941 #ifdef TCC_TARGET_I386
942 #include "i386-gen.c"
945 #ifdef TCC_TARGET_ARM
949 #ifdef TCC_TARGET_C67
953 #ifdef TCC_TARGET_X86_64
954 #include "x86_64-gen.c"
957 #ifdef CONFIG_TCC_STATIC
959 #define RTLD_LAZY 0x001
960 #define RTLD_NOW 0x002
961 #define RTLD_GLOBAL 0x100
962 #define RTLD_DEFAULT NULL
964 /* dummy function for profiling */
965 void *dlopen(const char *filename
, int flag
)
970 const char *dlerror(void)
975 typedef struct TCCSyms
{
980 #define TCCSYM(a) { #a, &a, },
982 /* add the symbol you want here if no dynamic linking is done */
983 static TCCSyms tcc_syms
[] = {
984 #if !defined(CONFIG_TCCBOOT)
993 void *resolve_sym(TCCState
*s1
, const char *symbol
, int type
)
997 while (p
->str
!= NULL
) {
998 if (!strcmp(p
->str
, symbol
))
1005 #elif !defined(_WIN32)
1009 void *resolve_sym(TCCState
*s1
, const char *sym
, int type
)
1011 return dlsym(RTLD_DEFAULT
, sym
);
1016 /********************************************************/
1018 /* we use our own 'finite' function to avoid potential problems with
1019 non standard math libs */
1020 /* XXX: endianness dependent */
1021 int ieee_finite(double d
)
1024 return ((unsigned)((p
[1] | 0x800fffff) + 1)) >> 31;
1027 /* copy a string and truncate it. */
1028 static char *pstrcpy(char *buf
, int buf_size
, const char *s
)
1035 q_end
= buf
+ buf_size
- 1;
1047 /* strcat and truncate. */
1048 static char *pstrcat(char *buf
, int buf_size
, const char *s
)
1053 pstrcpy(buf
+ len
, buf_size
- len
, s
);
1058 static int strstart(const char *str
, const char *val
, const char **ptr
)
1063 while (*q
!= '\0') {
1076 #define IS_PATHSEP(c) (c == '/' || c == '\\')
1077 #define IS_ABSPATH(p) (IS_PATHSEP(p[0]) || (p[0] && p[1] == ':' && IS_PATHSEP(p[2])))
1079 #define IS_PATHSEP(c) (c == '/')
1080 #define IS_ABSPATH(p) IS_PATHSEP(p[0])
1083 /* extract the basename of a file */
1084 static char *tcc_basename(const char *name
)
1086 char *p
= strchr(name
, 0);
1087 while (p
> name
&& !IS_PATHSEP(p
[-1]))
1092 static char *tcc_fileextension (const char *name
)
1094 char *b
= tcc_basename(name
);
1095 char *e
= strrchr(b
, '.');
1096 return e
? e
: strchr(b
, 0);
1100 char *normalize_slashes(char *path
)
1103 for (p
= path
; *p
; ++p
)
1109 char *w32_tcc_lib_path(void)
1111 /* on win32, we suppose the lib and includes are at the location
1113 char path
[1024], *p
;
1114 GetModuleFileNameA(NULL
, path
, sizeof path
);
1115 p
= tcc_basename(normalize_slashes(strlwr(path
)));
1116 if (p
- 5 > path
&& 0 == strncmp(p
- 5, "/bin/", 5))
1121 return strdup(path
);
1125 void set_pages_executable(void *ptr
, unsigned long length
)
1128 unsigned long old_protect
;
1129 VirtualProtect(ptr
, length
, PAGE_EXECUTE_READWRITE
, &old_protect
);
1131 unsigned long start
, end
;
1132 start
= (unsigned long)ptr
& ~(PAGESIZE
- 1);
1133 end
= (unsigned long)ptr
+ length
;
1134 end
= (end
+ PAGESIZE
- 1) & ~(PAGESIZE
- 1);
1135 mprotect((void *)start
, end
- start
, PROT_READ
| PROT_WRITE
| PROT_EXEC
);
1139 /* memory management */
1143 unsigned malloc_usable_size(void*);
1146 static inline void tcc_free(void *ptr
)
1149 mem_cur_size
-= malloc_usable_size(ptr
);
1154 static void *tcc_malloc(unsigned long size
)
1159 error("memory full");
1161 mem_cur_size
+= malloc_usable_size(ptr
);
1162 if (mem_cur_size
> mem_max_size
)
1163 mem_max_size
= mem_cur_size
;
1168 static void *tcc_mallocz(unsigned long size
)
1171 ptr
= tcc_malloc(size
);
1172 memset(ptr
, 0, size
);
1176 static inline void *tcc_realloc(void *ptr
, unsigned long size
)
1180 mem_cur_size
-= malloc_usable_size(ptr
);
1182 ptr1
= realloc(ptr
, size
);
1184 /* NOTE: count not correct if alloc error, but not critical */
1185 mem_cur_size
+= malloc_usable_size(ptr1
);
1186 if (mem_cur_size
> mem_max_size
)
1187 mem_max_size
= mem_cur_size
;
1192 static char *tcc_strdup(const char *str
)
1195 ptr
= tcc_malloc(strlen(str
) + 1);
1200 #define free(p) use_tcc_free(p)
1201 #define malloc(s) use_tcc_malloc(s)
1202 #define realloc(p, s) use_tcc_realloc(p, s)
1204 static void dynarray_add(void ***ptab
, int *nb_ptr
, void *data
)
1211 /* every power of two we double array size */
1212 if ((nb
& (nb
- 1)) == 0) {
1217 pp
= tcc_realloc(pp
, nb_alloc
* sizeof(void *));
1219 error("memory full");
1226 static void dynarray_reset(void *pp
, int *n
)
1229 for (p
= *(void***)pp
; *n
; ++p
, --*n
)
1232 tcc_free(*(void**)pp
);
1236 /* symbol allocator */
1237 static Sym
*__sym_malloc(void)
1239 Sym
*sym_pool
, *sym
, *last_sym
;
1242 sym_pool
= tcc_malloc(SYM_POOL_NB
* sizeof(Sym
));
1243 dynarray_add(&sym_pools
, &nb_sym_pools
, sym_pool
);
1245 last_sym
= sym_free_first
;
1247 for(i
= 0; i
< SYM_POOL_NB
; i
++) {
1248 sym
->next
= last_sym
;
1252 sym_free_first
= last_sym
;
1256 static inline Sym
*sym_malloc(void)
1259 sym
= sym_free_first
;
1261 sym
= __sym_malloc();
1262 sym_free_first
= sym
->next
;
1266 static inline void sym_free(Sym
*sym
)
1268 sym
->next
= sym_free_first
;
1269 sym_free_first
= sym
;
1272 Section
*new_section(TCCState
*s1
, const char *name
, int sh_type
, int sh_flags
)
1276 sec
= tcc_mallocz(sizeof(Section
) + strlen(name
));
1277 strcpy(sec
->name
, name
);
1278 sec
->sh_type
= sh_type
;
1279 sec
->sh_flags
= sh_flags
;
1287 sec
->sh_addralign
= 4;
1290 sec
->sh_addralign
= 1;
1293 sec
->sh_addralign
= 32; /* default conservative alignment */
1297 if (sh_flags
& SHF_PRIVATE
) {
1298 dynarray_add((void ***)&s1
->priv_sections
, &s1
->nb_priv_sections
, sec
);
1300 sec
->sh_num
= s1
->nb_sections
;
1301 dynarray_add((void ***)&s1
->sections
, &s1
->nb_sections
, sec
);
1307 static void free_section(Section
*s
)
1309 #ifdef TCC_TARGET_X86_64
1310 /* after tcc_relocate(), some sections share the data buffer.
1311 let's check if the data is allocated not to free the shared buffers */
1312 if (s
->data_allocated
)
1317 /* realloc section and set its content to zero */
1318 static void section_realloc(Section
*sec
, unsigned long new_size
)
1321 unsigned char *data
;
1323 size
= sec
->data_allocated
;
1326 while (size
< new_size
)
1328 data
= tcc_realloc(sec
->data
, size
);
1330 error("memory full");
1331 memset(data
+ sec
->data_allocated
, 0, size
- sec
->data_allocated
);
1333 sec
->data_allocated
= size
;
1336 /* reserve at least 'size' bytes in section 'sec' from
1337 sec->data_offset. */
1338 static void *section_ptr_add(Section
*sec
, unsigned long size
)
1340 unsigned long offset
, offset1
;
1342 offset
= sec
->data_offset
;
1343 offset1
= offset
+ size
;
1344 if (offset1
> sec
->data_allocated
)
1345 section_realloc(sec
, offset1
);
1346 sec
->data_offset
= offset1
;
1347 return sec
->data
+ offset
;
1350 /* return a reference to a section, and create it if it does not
1352 Section
*find_section(TCCState
*s1
, const char *name
)
1356 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1357 sec
= s1
->sections
[i
];
1358 if (!strcmp(name
, sec
->name
))
1361 /* sections are created as PROGBITS */
1362 return new_section(s1
, name
, SHT_PROGBITS
, SHF_ALLOC
);
1365 #define SECTION_ABS ((void *)1)
1367 /* update sym->c so that it points to an external symbol in section
1368 'section' with value 'value' */
1369 static void put_extern_sym2(Sym
*sym
, Section
*section
,
1370 unsigned long value
, unsigned long size
,
1371 int can_add_underscore
)
1373 int sym_type
, sym_bind
, sh_num
, info
, other
, attr
;
1378 if (section
== NULL
)
1380 else if (section
== SECTION_ABS
)
1383 sh_num
= section
->sh_num
;
1387 if ((sym
->type
.t
& VT_BTYPE
) == VT_FUNC
) {
1388 sym_type
= STT_FUNC
;
1389 #ifdef TCC_TARGET_PE
1391 attr
= sym
->type
.ref
->r
;
1392 if (FUNC_EXPORT(attr
))
1394 if (FUNC_CALL(attr
) == FUNC_STDCALL
)
1398 sym_type
= STT_OBJECT
;
1401 if (sym
->type
.t
& VT_STATIC
)
1402 sym_bind
= STB_LOCAL
;
1404 sym_bind
= STB_GLOBAL
;
1407 name
= get_tok_str(sym
->v
, NULL
);
1408 #ifdef CONFIG_TCC_BCHECK
1409 if (do_bounds_check
) {
1412 /* XXX: avoid doing that for statics ? */
1413 /* if bound checking is activated, we change some function
1414 names by adding the "__bound" prefix */
1417 /* XXX: we rely only on malloc hooks */
1430 strcpy(buf
, "__bound_");
1438 #ifdef TCC_TARGET_PE
1439 if ((other
& 2) && can_add_underscore
) {
1440 sprintf(buf1
, "_%s@%d", name
, FUNC_ARGS(attr
));
1444 if (tcc_state
->leading_underscore
&& can_add_underscore
) {
1446 pstrcpy(buf1
+ 1, sizeof(buf1
) - 1, name
);
1449 info
= ELFW(ST_INFO
)(sym_bind
, sym_type
);
1450 sym
->c
= add_elf_sym(symtab_section
, value
, size
, info
, other
, sh_num
, name
);
1452 esym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
];
1453 esym
->st_value
= value
;
1454 esym
->st_size
= size
;
1455 esym
->st_shndx
= sh_num
;
1456 esym
->st_other
|= other
;
1460 static void put_extern_sym(Sym
*sym
, Section
*section
,
1461 unsigned long value
, unsigned long size
)
1463 put_extern_sym2(sym
, section
, value
, size
, 1);
1466 /* add a new relocation entry to symbol 'sym' in section 's' */
1467 static void greloc(Section
*s
, Sym
*sym
, unsigned long offset
, int type
)
1470 put_extern_sym(sym
, NULL
, 0, 0);
1471 /* now we can add ELF relocation info */
1472 put_elf_reloc(symtab_section
, s
, offset
, type
, sym
->c
);
1475 static inline int isid(int c
)
1477 return (c
>= 'a' && c
<= 'z') ||
1478 (c
>= 'A' && c
<= 'Z') ||
1482 static inline int isnum(int c
)
1484 return c
>= '0' && c
<= '9';
1487 static inline int isoct(int c
)
1489 return c
>= '0' && c
<= '7';
1492 static inline int toup(int c
)
1494 if (c
>= 'a' && c
<= 'z')
1495 return c
- 'a' + 'A';
1500 static void strcat_vprintf(char *buf
, int buf_size
, const char *fmt
, va_list ap
)
1504 vsnprintf(buf
+ len
, buf_size
- len
, fmt
, ap
);
1507 static void strcat_printf(char *buf
, int buf_size
, const char *fmt
, ...)
1511 strcat_vprintf(buf
, buf_size
, fmt
, ap
);
1515 void error1(TCCState
*s1
, int is_warning
, const char *fmt
, va_list ap
)
1522 for(f
= s1
->include_stack
; f
< s1
->include_stack_ptr
; f
++)
1523 strcat_printf(buf
, sizeof(buf
), "In file included from %s:%d:\n",
1524 (*f
)->filename
, (*f
)->line_num
);
1525 if (file
->line_num
> 0) {
1526 strcat_printf(buf
, sizeof(buf
),
1527 "%s:%d: ", file
->filename
, file
->line_num
);
1529 strcat_printf(buf
, sizeof(buf
),
1530 "%s: ", file
->filename
);
1533 strcat_printf(buf
, sizeof(buf
),
1537 strcat_printf(buf
, sizeof(buf
), "warning: ");
1538 strcat_vprintf(buf
, sizeof(buf
), fmt
, ap
);
1540 if (!s1
->error_func
) {
1541 /* default case: stderr */
1542 fprintf(stderr
, "%s\n", buf
);
1544 s1
->error_func(s1
->error_opaque
, buf
);
1546 if (!is_warning
|| s1
->warn_error
)
1551 void tcc_set_error_func(TCCState
*s
, void *error_opaque
,
1552 void (*error_func
)(void *opaque
, const char *msg
))
1554 s
->error_opaque
= error_opaque
;
1555 s
->error_func
= error_func
;
1559 /* error without aborting current compilation */
1560 void error_noabort(const char *fmt
, ...)
1562 TCCState
*s1
= tcc_state
;
1566 error1(s1
, 0, fmt
, ap
);
1570 void error(const char *fmt
, ...)
1572 TCCState
*s1
= tcc_state
;
1576 error1(s1
, 0, fmt
, ap
);
1578 /* better than nothing: in some cases, we accept to handle errors */
1579 if (s1
->error_set_jmp_enabled
) {
1580 longjmp(s1
->error_jmp_buf
, 1);
1582 /* XXX: eliminate this someday */
1587 void expect(const char *msg
)
1589 error("%s expected", msg
);
1592 void warning(const char *fmt
, ...)
1594 TCCState
*s1
= tcc_state
;
1601 error1(s1
, 1, fmt
, ap
);
1608 error("'%c' expected", c
);
1612 static void test_lvalue(void)
1614 if (!(vtop
->r
& VT_LVAL
))
1618 /* allocate a new token */
1619 static TokenSym
*tok_alloc_new(TokenSym
**pts
, const char *str
, int len
)
1621 TokenSym
*ts
, **ptable
;
1624 if (tok_ident
>= SYM_FIRST_ANOM
)
1625 error("memory full");
1627 /* expand token table if needed */
1628 i
= tok_ident
- TOK_IDENT
;
1629 if ((i
% TOK_ALLOC_INCR
) == 0) {
1630 ptable
= tcc_realloc(table_ident
, (i
+ TOK_ALLOC_INCR
) * sizeof(TokenSym
*));
1632 error("memory full");
1633 table_ident
= ptable
;
1636 ts
= tcc_malloc(sizeof(TokenSym
) + len
);
1637 table_ident
[i
] = ts
;
1638 ts
->tok
= tok_ident
++;
1639 ts
->sym_define
= NULL
;
1640 ts
->sym_label
= NULL
;
1641 ts
->sym_struct
= NULL
;
1642 ts
->sym_identifier
= NULL
;
1644 ts
->hash_next
= NULL
;
1645 memcpy(ts
->str
, str
, len
);
1646 ts
->str
[len
] = '\0';
1651 #define TOK_HASH_INIT 1
1652 #define TOK_HASH_FUNC(h, c) ((h) * 263 + (c))
1654 /* find a token and add it if not found */
1655 static TokenSym
*tok_alloc(const char *str
, int len
)
1657 TokenSym
*ts
, **pts
;
1663 h
= TOK_HASH_FUNC(h
, ((unsigned char *)str
)[i
]);
1664 h
&= (TOK_HASH_SIZE
- 1);
1666 pts
= &hash_ident
[h
];
1671 if (ts
->len
== len
&& !memcmp(ts
->str
, str
, len
))
1673 pts
= &(ts
->hash_next
);
1675 return tok_alloc_new(pts
, str
, len
);
1678 /* CString handling */
1680 static void cstr_realloc(CString
*cstr
, int new_size
)
1685 size
= cstr
->size_allocated
;
1687 size
= 8; /* no need to allocate a too small first string */
1688 while (size
< new_size
)
1690 data
= tcc_realloc(cstr
->data_allocated
, size
);
1692 error("memory full");
1693 cstr
->data_allocated
= data
;
1694 cstr
->size_allocated
= size
;
1699 static inline void cstr_ccat(CString
*cstr
, int ch
)
1702 size
= cstr
->size
+ 1;
1703 if (size
> cstr
->size_allocated
)
1704 cstr_realloc(cstr
, size
);
1705 ((unsigned char *)cstr
->data
)[size
- 1] = ch
;
1709 static void cstr_cat(CString
*cstr
, const char *str
)
1721 /* add a wide char */
1722 static void cstr_wccat(CString
*cstr
, int ch
)
1725 size
= cstr
->size
+ sizeof(nwchar_t
);
1726 if (size
> cstr
->size_allocated
)
1727 cstr_realloc(cstr
, size
);
1728 *(nwchar_t
*)(((unsigned char *)cstr
->data
) + size
- sizeof(nwchar_t
)) = ch
;
1732 static void cstr_new(CString
*cstr
)
1734 memset(cstr
, 0, sizeof(CString
));
1737 /* free string and reset it to NULL */
1738 static void cstr_free(CString
*cstr
)
1740 tcc_free(cstr
->data_allocated
);
1744 #define cstr_reset(cstr) cstr_free(cstr)
1746 /* XXX: unicode ? */
1747 static void add_char(CString
*cstr
, int c
)
1749 if (c
== '\'' || c
== '\"' || c
== '\\') {
1750 /* XXX: could be more precise if char or string */
1751 cstr_ccat(cstr
, '\\');
1753 if (c
>= 32 && c
<= 126) {
1756 cstr_ccat(cstr
, '\\');
1758 cstr_ccat(cstr
, 'n');
1760 cstr_ccat(cstr
, '0' + ((c
>> 6) & 7));
1761 cstr_ccat(cstr
, '0' + ((c
>> 3) & 7));
1762 cstr_ccat(cstr
, '0' + (c
& 7));
1767 /* XXX: buffer overflow */
1768 /* XXX: float tokens */
1769 char *get_tok_str(int v
, CValue
*cv
)
1771 static char buf
[STRING_MAX_SIZE
+ 1];
1772 static CString cstr_buf
;
1778 /* NOTE: to go faster, we give a fixed buffer for small strings */
1779 cstr_reset(&cstr_buf
);
1780 cstr_buf
.data
= buf
;
1781 cstr_buf
.size_allocated
= sizeof(buf
);
1787 /* XXX: not quite exact, but only useful for testing */
1788 sprintf(p
, "%u", cv
->ui
);
1792 /* XXX: not quite exact, but only useful for testing */
1793 sprintf(p
, "%Lu", cv
->ull
);
1796 cstr_ccat(&cstr_buf
, 'L');
1798 cstr_ccat(&cstr_buf
, '\'');
1799 add_char(&cstr_buf
, cv
->i
);
1800 cstr_ccat(&cstr_buf
, '\'');
1801 cstr_ccat(&cstr_buf
, '\0');
1805 len
= cstr
->size
- 1;
1807 add_char(&cstr_buf
, ((unsigned char *)cstr
->data
)[i
]);
1808 cstr_ccat(&cstr_buf
, '\0');
1811 cstr_ccat(&cstr_buf
, 'L');
1814 cstr_ccat(&cstr_buf
, '\"');
1816 len
= cstr
->size
- 1;
1818 add_char(&cstr_buf
, ((unsigned char *)cstr
->data
)[i
]);
1820 len
= (cstr
->size
/ sizeof(nwchar_t
)) - 1;
1822 add_char(&cstr_buf
, ((nwchar_t
*)cstr
->data
)[i
]);
1824 cstr_ccat(&cstr_buf
, '\"');
1825 cstr_ccat(&cstr_buf
, '\0');
1834 return strcpy(p
, "...");
1836 return strcpy(p
, "<<=");
1838 return strcpy(p
, ">>=");
1840 if (v
< TOK_IDENT
) {
1841 /* search in two bytes table */
1855 } else if (v
< tok_ident
) {
1856 return table_ident
[v
- TOK_IDENT
]->str
;
1857 } else if (v
>= SYM_FIRST_ANOM
) {
1858 /* special name for anonymous symbol */
1859 sprintf(p
, "L.%u", v
- SYM_FIRST_ANOM
);
1861 /* should never happen */
1866 return cstr_buf
.data
;
1869 /* push, without hashing */
1870 static Sym
*sym_push2(Sym
**ps
, int v
, int t
, long c
)
1884 /* find a symbol and return its associated structure. 's' is the top
1885 of the symbol stack */
1886 static Sym
*sym_find2(Sym
*s
, int v
)
1896 /* structure lookup */
1897 static inline Sym
*struct_find(int v
)
1900 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1902 return table_ident
[v
]->sym_struct
;
1905 /* find an identifier */
1906 static inline Sym
*sym_find(int v
)
1909 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1911 return table_ident
[v
]->sym_identifier
;
1914 /* push a given symbol on the symbol stack */
1915 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
)
1924 s
= sym_push2(ps
, v
, type
->t
, c
);
1925 s
->type
.ref
= type
->ref
;
1927 /* don't record fields or anonymous symbols */
1929 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1930 /* record symbol in token array */
1931 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1933 ps
= &ts
->sym_struct
;
1935 ps
= &ts
->sym_identifier
;
1942 /* push a global identifier */
1943 static Sym
*global_identifier_push(int v
, int t
, int c
)
1946 s
= sym_push2(&global_stack
, v
, t
, c
);
1947 /* don't record anonymous symbol */
1948 if (v
< SYM_FIRST_ANOM
) {
1949 ps
= &table_ident
[v
- TOK_IDENT
]->sym_identifier
;
1950 /* modify the top most local identifier, so that
1951 sym_identifier will point to 's' when popped */
1953 ps
= &(*ps
)->prev_tok
;
1960 /* pop symbols until top reaches 'b' */
1961 static void sym_pop(Sym
**ptop
, Sym
*b
)
1971 /* remove symbol in token array */
1973 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1974 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1976 ps
= &ts
->sym_struct
;
1978 ps
= &ts
->sym_identifier
;
1989 BufferedFile
*tcc_open(TCCState
*s1
, const char *filename
)
1994 if (strcmp(filename
, "-") == 0)
1995 fd
= 0, filename
= "stdin";
1997 fd
= open(filename
, O_RDONLY
| O_BINARY
);
1998 if ((verbose
== 2 && fd
>= 0) || verbose
== 3)
1999 printf("%s %*s%s\n", fd
< 0 ? "nf":"->",
2000 (s1
->include_stack_ptr
- s1
->include_stack
), "", filename
);
2003 bf
= tcc_malloc(sizeof(BufferedFile
));
2005 bf
->buf_ptr
= bf
->buffer
;
2006 bf
->buf_end
= bf
->buffer
;
2007 bf
->buffer
[0] = CH_EOB
; /* put eob symbol */
2008 pstrcpy(bf
->filename
, sizeof(bf
->filename
), filename
);
2010 normalize_slashes(bf
->filename
);
2013 bf
->ifndef_macro
= 0;
2014 bf
->ifdef_stack_ptr
= s1
->ifdef_stack_ptr
;
2015 // printf("opening '%s'\n", filename);
2019 void tcc_close(BufferedFile
*bf
)
2021 total_lines
+= bf
->line_num
;
2026 /* fill input buffer and peek next char */
2027 static int tcc_peekc_slow(BufferedFile
*bf
)
2030 /* only tries to read if really end of buffer */
2031 if (bf
->buf_ptr
>= bf
->buf_end
) {
2033 #if defined(PARSE_DEBUG)
2038 len
= read(bf
->fd
, bf
->buffer
, len
);
2045 bf
->buf_ptr
= bf
->buffer
;
2046 bf
->buf_end
= bf
->buffer
+ len
;
2047 *bf
->buf_end
= CH_EOB
;
2049 if (bf
->buf_ptr
< bf
->buf_end
) {
2050 return bf
->buf_ptr
[0];
2052 bf
->buf_ptr
= bf
->buf_end
;
2057 /* return the current character, handling end of block if necessary
2059 static int handle_eob(void)
2061 return tcc_peekc_slow(file
);
2064 /* read next char from current input file and handle end of input buffer */
2065 static inline void inp(void)
2067 ch
= *(++(file
->buf_ptr
));
2068 /* end of buffer/file handling */
2073 /* handle '\[\r]\n' */
2074 static int handle_stray_noerror(void)
2076 while (ch
== '\\') {
2081 } else if (ch
== '\r') {
2095 static void handle_stray(void)
2097 if (handle_stray_noerror())
2098 error("stray '\\' in program");
2101 /* skip the stray and handle the \\n case. Output an error if
2102 incorrect char after the stray */
2103 static int handle_stray1(uint8_t *p
)
2107 if (p
>= file
->buf_end
) {
2124 /* handle just the EOB case, but not stray */
2125 #define PEEKC_EOB(c, p)\
2136 /* handle the complicated stray case */
2137 #define PEEKC(c, p)\
2142 c = handle_stray1(p);\
2147 /* input with '\[\r]\n' handling. Note that this function cannot
2148 handle other characters after '\', so you cannot call it inside
2149 strings or comments */
2150 static void minp(void)
2158 /* single line C++ comments */
2159 static uint8_t *parse_line_comment(uint8_t *p
)
2167 if (c
== '\n' || c
== CH_EOF
) {
2169 } else if (c
== '\\') {
2178 } else if (c
== '\r') {
2196 static uint8_t *parse_comment(uint8_t *p
)
2202 /* fast skip loop */
2205 if (c
== '\n' || c
== '*' || c
== '\\')
2209 if (c
== '\n' || c
== '*' || c
== '\\')
2213 /* now we can handle all the cases */
2217 } else if (c
== '*') {
2223 } else if (c
== '/') {
2224 goto end_of_comment
;
2225 } else if (c
== '\\') {
2230 /* skip '\[\r]\n', otherwise just skip the stray */
2236 } else if (c
== '\r') {
2253 /* stray, eob or eof */
2258 error("unexpected end of file in comment");
2259 } else if (c
== '\\') {
2271 /* space exlcuding newline */
2272 static inline int is_space(int ch
)
2274 return ch
== ' ' || ch
== '\t' || ch
== '\v' || ch
== '\f' || ch
== '\r';
2277 static inline void skip_spaces(void)
2279 while (is_space(ch
))
2283 /* parse a string without interpreting escapes */
2284 static uint8_t *parse_pp_string(uint8_t *p
,
2285 int sep
, CString
*str
)
2293 } else if (c
== '\\') {
2298 unterminated_string
:
2299 /* XXX: indicate line number of start of string */
2300 error("missing terminating %c character", sep
);
2301 } else if (c
== '\\') {
2302 /* escape : just skip \[\r]\n */
2307 } else if (c
== '\r') {
2310 expect("'\n' after '\r'");
2313 } else if (c
== CH_EOF
) {
2314 goto unterminated_string
;
2317 cstr_ccat(str
, '\\');
2323 } else if (c
== '\n') {
2326 } else if (c
== '\r') {
2330 cstr_ccat(str
, '\r');
2346 /* skip block of text until #else, #elif or #endif. skip also pairs of
2348 void preprocess_skip(void)
2350 int a
, start_of_line
, c
, in_warn_or_error
;
2357 in_warn_or_error
= 0;
2378 } else if (c
== '\\') {
2379 ch
= file
->buf_ptr
[0];
2380 handle_stray_noerror();
2387 if (in_warn_or_error
)
2389 p
= parse_pp_string(p
, c
, NULL
);
2393 if (in_warn_or_error
)
2400 p
= parse_comment(p
);
2401 } else if (ch
== '/') {
2402 p
= parse_line_comment(p
);
2407 if (start_of_line
) {
2412 (tok
== TOK_ELSE
|| tok
== TOK_ELIF
|| tok
== TOK_ENDIF
))
2414 if (tok
== TOK_IF
|| tok
== TOK_IFDEF
|| tok
== TOK_IFNDEF
)
2416 else if (tok
== TOK_ENDIF
)
2418 else if( tok
== TOK_ERROR
|| tok
== TOK_WARNING
)
2419 in_warn_or_error
= 1;
2433 /* ParseState handling */
2435 /* XXX: currently, no include file info is stored. Thus, we cannot display
2436 accurate messages if the function or data definition spans multiple
2439 /* save current parse state in 's' */
2440 void save_parse_state(ParseState
*s
)
2442 s
->line_num
= file
->line_num
;
2443 s
->macro_ptr
= macro_ptr
;
2448 /* restore parse state from 's' */
2449 void restore_parse_state(ParseState
*s
)
2451 file
->line_num
= s
->line_num
;
2452 macro_ptr
= s
->macro_ptr
;
2457 /* return the number of additional 'ints' necessary to store the
2459 static inline int tok_ext_size(int t
)
2473 error("unsupported token");
2480 return LDOUBLE_SIZE
/ 4;
2486 /* token string handling */
2488 static inline void tok_str_new(TokenString
*s
)
2492 s
->allocated_len
= 0;
2493 s
->last_line_num
= -1;
2496 static void tok_str_free(int *str
)
2501 static int *tok_str_realloc(TokenString
*s
)
2505 if (s
->allocated_len
== 0) {
2508 len
= s
->allocated_len
* 2;
2510 str
= tcc_realloc(s
->str
, len
* sizeof(int));
2512 error("memory full");
2513 s
->allocated_len
= len
;
2518 static void tok_str_add(TokenString
*s
, int t
)
2524 if (len
>= s
->allocated_len
)
2525 str
= tok_str_realloc(s
);
2530 static void tok_str_add2(TokenString
*s
, int t
, CValue
*cv
)
2537 /* allocate space for worst case */
2538 if (len
+ TOK_MAX_SIZE
> s
->allocated_len
)
2539 str
= tok_str_realloc(s
);
2548 str
[len
++] = cv
->tab
[0];
2557 nb_words
= (sizeof(CString
) + cv
->cstr
->size
+ 3) >> 2;
2558 while ((len
+ nb_words
) > s
->allocated_len
)
2559 str
= tok_str_realloc(s
);
2560 cstr
= (CString
*)(str
+ len
);
2562 cstr
->size
= cv
->cstr
->size
;
2563 cstr
->data_allocated
= NULL
;
2564 cstr
->size_allocated
= cstr
->size
;
2565 memcpy((char *)cstr
+ sizeof(CString
),
2566 cv
->cstr
->data
, cstr
->size
);
2573 #if LDOUBLE_SIZE == 8
2576 str
[len
++] = cv
->tab
[0];
2577 str
[len
++] = cv
->tab
[1];
2579 #if LDOUBLE_SIZE == 12
2581 str
[len
++] = cv
->tab
[0];
2582 str
[len
++] = cv
->tab
[1];
2583 str
[len
++] = cv
->tab
[2];
2584 #elif LDOUBLE_SIZE == 16
2586 str
[len
++] = cv
->tab
[0];
2587 str
[len
++] = cv
->tab
[1];
2588 str
[len
++] = cv
->tab
[2];
2589 str
[len
++] = cv
->tab
[3];
2590 #elif LDOUBLE_SIZE != 8
2591 #error add long double size support
2600 /* add the current parse token in token string 's' */
2601 static void tok_str_add_tok(TokenString
*s
)
2605 /* save line number info */
2606 if (file
->line_num
!= s
->last_line_num
) {
2607 s
->last_line_num
= file
->line_num
;
2608 cval
.i
= s
->last_line_num
;
2609 tok_str_add2(s
, TOK_LINENUM
, &cval
);
2611 tok_str_add2(s
, tok
, &tokc
);
2614 #if LDOUBLE_SIZE == 16
2615 #define LDOUBLE_GET(p, cv) \
2620 #elif LDOUBLE_SIZE == 12
2621 #define LDOUBLE_GET(p, cv) \
2625 #elif LDOUBLE_SIZE == 8
2626 #define LDOUBLE_GET(p, cv) \
2630 #error add long double size support
2634 /* get a token from an integer array and increment pointer
2635 accordingly. we code it as a macro to avoid pointer aliasing. */
2636 #define TOK_GET(t, p, cv) \
2651 cv.cstr = (CString *)p; \
2652 cv.cstr->data = (char *)p + sizeof(CString);\
2653 p += (sizeof(CString) + cv.cstr->size + 3) >> 2;\
2662 case TOK_CLDOUBLE: \
2663 LDOUBLE_GET(p, cv); \
2664 p += LDOUBLE_SIZE / 4; \
2671 /* defines handling */
2672 static inline void define_push(int v
, int macro_type
, int *str
, Sym
*first_arg
)
2676 s
= sym_push2(&define_stack
, v
, macro_type
, (long)str
);
2677 s
->next
= first_arg
;
2678 table_ident
[v
- TOK_IDENT
]->sym_define
= s
;
2681 /* undefined a define symbol. Its name is just set to zero */
2682 static void define_undef(Sym
*s
)
2686 if (v
>= TOK_IDENT
&& v
< tok_ident
)
2687 table_ident
[v
- TOK_IDENT
]->sym_define
= NULL
;
2691 static inline Sym
*define_find(int v
)
2694 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
2696 return table_ident
[v
]->sym_define
;
2699 /* free define stack until top reaches 'b' */
2700 static void free_defines(Sym
*b
)
2708 /* do not free args or predefined defines */
2710 tok_str_free((int *)top
->c
);
2712 if (v
>= TOK_IDENT
&& v
< tok_ident
)
2713 table_ident
[v
- TOK_IDENT
]->sym_define
= NULL
;
2721 static Sym
*label_find(int v
)
2724 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
2726 return table_ident
[v
]->sym_label
;
2729 static Sym
*label_push(Sym
**ptop
, int v
, int flags
)
2732 s
= sym_push2(ptop
, v
, 0, 0);
2734 ps
= &table_ident
[v
- TOK_IDENT
]->sym_label
;
2735 if (ptop
== &global_label_stack
) {
2736 /* modify the top most local identifier, so that
2737 sym_identifier will point to 's' when popped */
2739 ps
= &(*ps
)->prev_tok
;
2746 /* pop labels until element last is reached. Look if any labels are
2747 undefined. Define symbols if '&&label' was used. */
2748 static void label_pop(Sym
**ptop
, Sym
*slast
)
2751 for(s
= *ptop
; s
!= slast
; s
= s1
) {
2753 if (s
->r
== LABEL_DECLARED
) {
2754 warning("label '%s' declared but not used", get_tok_str(s
->v
, NULL
));
2755 } else if (s
->r
== LABEL_FORWARD
) {
2756 error("label '%s' used but not defined",
2757 get_tok_str(s
->v
, NULL
));
2760 /* define corresponding symbol. A size of
2762 put_extern_sym(s
, cur_text_section
, (long)s
->next
, 1);
2766 table_ident
[s
->v
- TOK_IDENT
]->sym_label
= s
->prev_tok
;
2772 /* eval an expression for #if/#elif */
2773 static int expr_preprocess(void)
2779 while (tok
!= TOK_LINEFEED
&& tok
!= TOK_EOF
) {
2780 next(); /* do macro subst */
2781 if (tok
== TOK_DEFINED
) {
2786 c
= define_find(tok
) != 0;
2791 } else if (tok
>= TOK_IDENT
) {
2792 /* if undefined macro */
2796 tok_str_add_tok(&str
);
2798 tok_str_add(&str
, -1); /* simulate end of file */
2799 tok_str_add(&str
, 0);
2800 /* now evaluate C constant expression */
2801 macro_ptr
= str
.str
;
2805 tok_str_free(str
.str
);
2809 #if defined(PARSE_DEBUG) || defined(PP_DEBUG)
2810 static void tok_print(int *str
)
2816 TOK_GET(t
, str
, cval
);
2819 printf(" %s", get_tok_str(t
, &cval
));
2825 /* parse after #define */
2826 static void parse_define(void)
2828 Sym
*s
, *first
, **ps
;
2829 int v
, t
, varg
, is_vaargs
, c
;
2834 error("invalid macro name '%s'", get_tok_str(tok
, &tokc
));
2835 /* XXX: should check if same macro (ANSI) */
2838 /* '(' must be just after macro definition for MACRO_FUNC */
2839 c
= file
->buf_ptr
[0];
2841 c
= handle_stray1(file
->buf_ptr
);
2846 while (tok
!= ')') {
2850 if (varg
== TOK_DOTS
) {
2851 varg
= TOK___VA_ARGS__
;
2853 } else if (tok
== TOK_DOTS
&& gnu_ext
) {
2857 if (varg
< TOK_IDENT
)
2858 error("badly punctuated parameter list");
2859 s
= sym_push2(&define_stack
, varg
| SYM_FIELD
, is_vaargs
, 0);
2870 /* EOF testing necessary for '-D' handling */
2871 while (tok
!= TOK_LINEFEED
&& tok
!= TOK_EOF
) {
2872 tok_str_add2(&str
, tok
, &tokc
);
2875 tok_str_add(&str
, 0);
2877 printf("define %s %d: ", get_tok_str(v
, NULL
), t
);
2880 define_push(v
, t
, str
.str
, first
);
2883 static inline int hash_cached_include(int type
, const char *filename
)
2885 const unsigned char *s
;
2889 h
= TOK_HASH_FUNC(h
, type
);
2892 h
= TOK_HASH_FUNC(h
, *s
);
2895 h
&= (CACHED_INCLUDES_HASH_SIZE
- 1);
2899 /* XXX: use a token or a hash table to accelerate matching ? */
2900 static CachedInclude
*search_cached_include(TCCState
*s1
,
2901 int type
, const char *filename
)
2905 h
= hash_cached_include(type
, filename
);
2906 i
= s1
->cached_includes_hash
[h
];
2910 e
= s1
->cached_includes
[i
- 1];
2911 if (e
->type
== type
&& !strcmp(e
->filename
, filename
))
2918 static inline void add_cached_include(TCCState
*s1
, int type
,
2919 const char *filename
, int ifndef_macro
)
2924 if (search_cached_include(s1
, type
, filename
))
2927 printf("adding cached '%s' %s\n", filename
, get_tok_str(ifndef_macro
, NULL
));
2929 e
= tcc_malloc(sizeof(CachedInclude
) + strlen(filename
));
2933 strcpy(e
->filename
, filename
);
2934 e
->ifndef_macro
= ifndef_macro
;
2935 dynarray_add((void ***)&s1
->cached_includes
, &s1
->nb_cached_includes
, e
);
2936 /* add in hash table */
2937 h
= hash_cached_include(type
, filename
);
2938 e
->hash_next
= s1
->cached_includes_hash
[h
];
2939 s1
->cached_includes_hash
[h
] = s1
->nb_cached_includes
;
2942 static void pragma_parse(TCCState
*s1
)
2947 if (tok
== TOK_pack
) {
2950 #pragma pack(1) // set
2951 #pragma pack() // reset to default
2952 #pragma pack(push,1) // push & set
2953 #pragma pack(pop) // restore previous
2957 if (tok
== TOK_ASM_pop
) {
2959 if (s1
->pack_stack_ptr
<= s1
->pack_stack
) {
2961 error("out of pack stack");
2963 s1
->pack_stack_ptr
--;
2967 if (tok
== TOK_ASM_push
) {
2969 if (s1
->pack_stack_ptr
>= s1
->pack_stack
+ PACK_STACK_SIZE
- 1)
2971 s1
->pack_stack_ptr
++;
2974 if (tok
!= TOK_CINT
) {
2976 error("invalid pack pragma");
2979 if (val
< 1 || val
> 16 || (val
& (val
- 1)) != 0)
2983 *s1
->pack_stack_ptr
= val
;
2989 /* is_bof is true if first non space token at beginning of file */
2990 static void preprocess(int is_bof
)
2992 TCCState
*s1
= tcc_state
;
2993 int size
, i
, c
, n
, saved_parse_flags
;
3000 saved_parse_flags
= parse_flags
;
3001 parse_flags
= PARSE_FLAG_PREPROCESS
| PARSE_FLAG_TOK_NUM
|
3002 PARSE_FLAG_LINEFEED
;
3012 s
= define_find(tok
);
3013 /* undefine symbol by putting an invalid name */
3018 case TOK_INCLUDE_NEXT
:
3019 ch
= file
->buf_ptr
[0];
3020 /* XXX: incorrect if comments : use next_nomacro with a special mode */
3025 } else if (ch
== '\"') {
3030 while (ch
!= c
&& ch
!= '\n' && ch
!= CH_EOF
) {
3031 if ((q
- buf
) < sizeof(buf
) - 1)
3034 if (handle_stray_noerror() == 0)
3042 /* eat all spaces and comments after include */
3043 /* XXX: slightly incorrect */
3044 while (ch1
!= '\n' && ch1
!= CH_EOF
)
3048 /* computed #include : either we have only strings or
3049 we have anything enclosed in '<>' */
3052 if (tok
== TOK_STR
) {
3053 while (tok
!= TOK_LINEFEED
) {
3054 if (tok
!= TOK_STR
) {
3056 error("'#include' expects \"FILENAME\" or <FILENAME>");
3058 pstrcat(buf
, sizeof(buf
), (char *)tokc
.cstr
->data
);
3064 while (tok
!= TOK_LINEFEED
) {
3065 pstrcat(buf
, sizeof(buf
), get_tok_str(tok
, &tokc
));
3069 /* check syntax and remove '<>' */
3070 if (len
< 2 || buf
[0] != '<' || buf
[len
- 1] != '>')
3071 goto include_syntax
;
3072 memmove(buf
, buf
+ 1, len
- 2);
3073 buf
[len
- 2] = '\0';
3078 e
= search_cached_include(s1
, c
, buf
);
3079 if (e
&& define_find(e
->ifndef_macro
)) {
3080 /* no need to parse the include because the 'ifndef macro'
3083 printf("%s: skipping %s\n", file
->filename
, buf
);
3086 if (s1
->include_stack_ptr
>= s1
->include_stack
+ INCLUDE_STACK_SIZE
)
3087 error("#include recursion too deep");
3088 /* push current file in stack */
3089 /* XXX: fix current line init */
3090 *s1
->include_stack_ptr
++ = file
;
3092 /* check absolute include path */
3093 if (IS_ABSPATH(buf
)) {
3094 f
= tcc_open(s1
, buf
);
3099 /* first search in current dir if "header.h" */
3100 size
= tcc_basename(file
->filename
) - file
->filename
;
3101 if (size
> sizeof(buf1
) - 1)
3102 size
= sizeof(buf1
) - 1;
3103 memcpy(buf1
, file
->filename
, size
);
3105 pstrcat(buf1
, sizeof(buf1
), buf
);
3106 f
= tcc_open(s1
, buf1
);
3108 if (tok
== TOK_INCLUDE_NEXT
)
3114 /* now search in all the include paths */
3115 n
= s1
->nb_include_paths
+ s1
->nb_sysinclude_paths
;
3116 for(i
= 0; i
< n
; i
++) {
3118 if (i
< s1
->nb_include_paths
)
3119 path
= s1
->include_paths
[i
];
3121 path
= s1
->sysinclude_paths
[i
- s1
->nb_include_paths
];
3122 pstrcpy(buf1
, sizeof(buf1
), path
);
3123 pstrcat(buf1
, sizeof(buf1
), "/");
3124 pstrcat(buf1
, sizeof(buf1
), buf
);
3125 f
= tcc_open(s1
, buf1
);
3127 if (tok
== TOK_INCLUDE_NEXT
)
3133 --s1
->include_stack_ptr
;
3134 error("include file '%s' not found", buf
);
3138 printf("%s: including %s\n", file
->filename
, buf1
);
3141 pstrcpy(f
->inc_filename
, sizeof(f
->inc_filename
), buf
);
3143 /* add include file debug info */
3145 put_stabs(file
->filename
, N_BINCL
, 0, 0, 0);
3147 tok_flags
|= TOK_FLAG_BOF
| TOK_FLAG_BOL
;
3148 ch
= file
->buf_ptr
[0];
3156 c
= expr_preprocess();
3162 if (tok
< TOK_IDENT
)
3163 error("invalid argument for '#if%sdef'", c
? "n" : "");
3167 printf("#ifndef %s\n", get_tok_str(tok
, NULL
));
3169 file
->ifndef_macro
= tok
;
3172 c
= (define_find(tok
) != 0) ^ c
;
3174 if (s1
->ifdef_stack_ptr
>= s1
->ifdef_stack
+ IFDEF_STACK_SIZE
)
3175 error("memory full");
3176 *s1
->ifdef_stack_ptr
++ = c
;
3179 if (s1
->ifdef_stack_ptr
== s1
->ifdef_stack
)
3180 error("#else without matching #if");
3181 if (s1
->ifdef_stack_ptr
[-1] & 2)
3182 error("#else after #else");
3183 c
= (s1
->ifdef_stack_ptr
[-1] ^= 3);
3186 if (s1
->ifdef_stack_ptr
== s1
->ifdef_stack
)
3187 error("#elif without matching #if");
3188 c
= s1
->ifdef_stack_ptr
[-1];
3190 error("#elif after #else");
3191 /* last #if/#elif expression was true: we skip */
3194 c
= expr_preprocess();
3195 s1
->ifdef_stack_ptr
[-1] = c
;
3205 if (s1
->ifdef_stack_ptr
<= file
->ifdef_stack_ptr
)
3206 error("#endif without matching #if");
3207 s1
->ifdef_stack_ptr
--;
3208 /* '#ifndef macro' was at the start of file. Now we check if
3209 an '#endif' is exactly at the end of file */
3210 if (file
->ifndef_macro
&&
3211 s1
->ifdef_stack_ptr
== file
->ifdef_stack_ptr
) {
3212 file
->ifndef_macro_saved
= file
->ifndef_macro
;
3213 /* need to set to zero to avoid false matches if another
3214 #ifndef at middle of file */
3215 file
->ifndef_macro
= 0;
3216 while (tok
!= TOK_LINEFEED
)
3218 tok_flags
|= TOK_FLAG_ENDIF
;
3224 if (tok
!= TOK_CINT
)
3226 file
->line_num
= tokc
.i
- 1; /* the line number will be incremented after */
3228 if (tok
!= TOK_LINEFEED
) {
3231 pstrcpy(file
->filename
, sizeof(file
->filename
),
3232 (char *)tokc
.cstr
->data
);
3238 ch
= file
->buf_ptr
[0];
3241 while (ch
!= '\n' && ch
!= CH_EOF
) {
3242 if ((q
- buf
) < sizeof(buf
) - 1)
3245 if (handle_stray_noerror() == 0)
3252 error("#error %s", buf
);
3254 warning("#warning %s", buf
);
3260 if (tok
== TOK_LINEFEED
|| tok
== '!' || tok
== TOK_CINT
) {
3261 /* '!' is ignored to allow C scripts. numbers are ignored
3262 to emulate cpp behaviour */
3264 if (!(saved_parse_flags
& PARSE_FLAG_ASM_COMMENTS
))
3265 warning("Ignoring unknown preprocessing directive #%s", get_tok_str(tok
, &tokc
));
3269 /* ignore other preprocess commands or #! for C scripts */
3270 while (tok
!= TOK_LINEFEED
)
3273 parse_flags
= saved_parse_flags
;
3276 /* evaluate escape codes in a string. */
3277 static void parse_escape_string(CString
*outstr
, const uint8_t *buf
, int is_long
)
3292 case '0': case '1': case '2': case '3':
3293 case '4': case '5': case '6': case '7':
3294 /* at most three octal digits */
3299 n
= n
* 8 + c
- '0';
3303 n
= n
* 8 + c
- '0';
3308 goto add_char_nonext
;
3316 if (c
>= 'a' && c
<= 'f')
3318 else if (c
>= 'A' && c
<= 'F')
3328 goto add_char_nonext
;
3352 goto invalid_escape
;
3362 if (c
>= '!' && c
<= '~')
3363 warning("unknown escape sequence: \'\\%c\'", c
);
3365 warning("unknown escape sequence: \'\\x%x\'", c
);
3372 cstr_ccat(outstr
, c
);
3374 cstr_wccat(outstr
, c
);
3376 /* add a trailing '\0' */
3378 cstr_ccat(outstr
, '\0');
3380 cstr_wccat(outstr
, '\0');
3383 /* we use 64 bit numbers */
3386 /* bn = (bn << shift) | or_val */
3387 void bn_lshift(unsigned int *bn
, int shift
, int or_val
)
3391 for(i
=0;i
<BN_SIZE
;i
++) {
3393 bn
[i
] = (v
<< shift
) | or_val
;
3394 or_val
= v
>> (32 - shift
);
3398 void bn_zero(unsigned int *bn
)
3401 for(i
=0;i
<BN_SIZE
;i
++) {
3406 /* parse number in null terminated string 'p' and return it in the
3408 void parse_number(const char *p
)
3410 int b
, t
, shift
, frac_bits
, s
, exp_val
, ch
;
3412 unsigned int bn
[BN_SIZE
];
3423 goto float_frac_parse
;
3424 } else if (t
== '0') {
3425 if (ch
== 'x' || ch
== 'X') {
3429 } else if (tcc_ext
&& (ch
== 'b' || ch
== 'B')) {
3435 /* parse all digits. cannot check octal numbers at this stage
3436 because of floating point constants */
3438 if (ch
>= 'a' && ch
<= 'f')
3440 else if (ch
>= 'A' && ch
<= 'F')
3448 if (q
>= token_buf
+ STRING_MAX_SIZE
) {
3450 error("number too long");
3456 ((ch
== 'e' || ch
== 'E') && b
== 10) ||
3457 ((ch
== 'p' || ch
== 'P') && (b
== 16 || b
== 2))) {
3459 /* NOTE: strtox should support that for hexa numbers, but
3460 non ISOC99 libcs do not support it, so we prefer to do
3462 /* hexadecimal or binary floats */
3463 /* XXX: handle overflows */
3475 } else if (t
>= 'a') {
3477 } else if (t
>= 'A') {
3482 bn_lshift(bn
, shift
, t
);
3489 if (t
>= 'a' && t
<= 'f') {
3491 } else if (t
>= 'A' && t
<= 'F') {
3493 } else if (t
>= '0' && t
<= '9') {
3499 error("invalid digit");
3500 bn_lshift(bn
, shift
, t
);
3505 if (ch
!= 'p' && ch
!= 'P')
3512 } else if (ch
== '-') {
3516 if (ch
< '0' || ch
> '9')
3517 expect("exponent digits");
3518 while (ch
>= '0' && ch
<= '9') {
3519 exp_val
= exp_val
* 10 + ch
- '0';
3522 exp_val
= exp_val
* s
;
3524 /* now we can generate the number */
3525 /* XXX: should patch directly float number */
3526 d
= (double)bn
[1] * 4294967296.0 + (double)bn
[0];
3527 d
= ldexp(d
, exp_val
- frac_bits
);
3532 /* float : should handle overflow */
3534 } else if (t
== 'L') {
3537 /* XXX: not large enough */
3538 tokc
.ld
= (long double)d
;
3544 /* decimal floats */
3546 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3551 while (ch
>= '0' && ch
<= '9') {
3552 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3558 if (ch
== 'e' || ch
== 'E') {
3559 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3563 if (ch
== '-' || ch
== '+') {
3564 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3569 if (ch
< '0' || ch
> '9')
3570 expect("exponent digits");
3571 while (ch
>= '0' && ch
<= '9') {
3572 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3584 tokc
.f
= strtof(token_buf
, NULL
);
3585 } else if (t
== 'L') {
3588 tokc
.ld
= strtold(token_buf
, NULL
);
3591 tokc
.d
= strtod(token_buf
, NULL
);
3595 unsigned long long n
, n1
;
3598 /* integer number */
3601 if (b
== 10 && *q
== '0') {
3608 /* no need for checks except for base 10 / 8 errors */
3611 } else if (t
>= 'a') {
3613 } else if (t
>= 'A') {
3618 error("invalid digit");
3622 /* detect overflow */
3623 /* XXX: this test is not reliable */
3625 error("integer constant overflow");
3628 /* XXX: not exactly ANSI compliant */
3629 if ((n
& 0xffffffff00000000LL
) != 0) {
3634 } else if (n
> 0x7fffffff) {
3645 error("three 'l's in integer constant");
3648 if (tok
== TOK_CINT
)
3650 else if (tok
== TOK_CUINT
)
3654 } else if (t
== 'U') {
3656 error("two 'u's in integer constant");
3658 if (tok
== TOK_CINT
)
3660 else if (tok
== TOK_CLLONG
)
3667 if (tok
== TOK_CINT
|| tok
== TOK_CUINT
)
3673 error("invalid number\n");
3677 #define PARSE2(c1, tok1, c2, tok2) \
3688 /* return next token without macro substitution */
3689 static inline void next_nomacro1(void)
3696 cstr_reset(&tok_spaces
);
3706 cstr_ccat(&tok_spaces
, c
);
3711 /* first look if it is in fact an end of buffer */
3712 if (p
>= file
->buf_end
) {
3716 if (p
>= file
->buf_end
)
3729 TCCState
*s1
= tcc_state
;
3730 if ((parse_flags
& PARSE_FLAG_LINEFEED
)
3731 && !(tok_flags
& TOK_FLAG_EOF
)) {
3732 tok_flags
|= TOK_FLAG_EOF
;
3734 goto keep_tok_flags
;
3735 } else if (s1
->include_stack_ptr
== s1
->include_stack
||
3736 !(parse_flags
& PARSE_FLAG_PREPROCESS
)) {
3737 /* no include left : end of file. */
3740 tok_flags
&= ~TOK_FLAG_EOF
;
3741 /* pop include file */
3743 /* test if previous '#endif' was after a #ifdef at
3745 if (tok_flags
& TOK_FLAG_ENDIF
) {
3747 printf("#endif %s\n", get_tok_str(file
->ifndef_macro_saved
, NULL
));
3749 add_cached_include(s1
, file
->inc_type
, file
->inc_filename
,
3750 file
->ifndef_macro_saved
);
3753 /* add end of include file debug info */
3755 put_stabd(N_EINCL
, 0, 0);
3757 /* pop include stack */
3759 s1
->include_stack_ptr
--;
3760 file
= *s1
->include_stack_ptr
;
3769 tok_flags
|= TOK_FLAG_BOL
;
3771 if (0 == (parse_flags
& PARSE_FLAG_LINEFEED
))
3774 goto keep_tok_flags
;
3779 if ((tok_flags
& TOK_FLAG_BOL
) &&
3780 (parse_flags
& PARSE_FLAG_PREPROCESS
)) {
3782 preprocess(tok_flags
& TOK_FLAG_BOF
);
3788 tok
= TOK_TWOSHARPS
;
3790 if (parse_flags
& PARSE_FLAG_ASM_COMMENTS
) {
3791 p
= parse_line_comment(p
- 1);
3800 case 'a': case 'b': case 'c': case 'd':
3801 case 'e': case 'f': case 'g': case 'h':
3802 case 'i': case 'j': case 'k': case 'l':
3803 case 'm': case 'n': case 'o': case 'p':
3804 case 'q': case 'r': case 's': case 't':
3805 case 'u': case 'v': case 'w': case 'x':
3807 case 'A': case 'B': case 'C': case 'D':
3808 case 'E': case 'F': case 'G': case 'H':
3809 case 'I': case 'J': case 'K':
3810 case 'M': case 'N': case 'O': case 'P':
3811 case 'Q': case 'R': case 'S': case 'T':
3812 case 'U': case 'V': case 'W': case 'X':
3818 h
= TOK_HASH_FUNC(h
, c
);
3822 if (!isidnum_table
[c
-CH_EOF
])
3824 h
= TOK_HASH_FUNC(h
, c
);
3831 /* fast case : no stray found, so we have the full token
3832 and we have already hashed it */
3834 h
&= (TOK_HASH_SIZE
- 1);
3835 pts
= &hash_ident
[h
];
3840 if (ts
->len
== len
&& !memcmp(ts
->str
, p1
, len
))
3842 pts
= &(ts
->hash_next
);
3844 ts
= tok_alloc_new(pts
, p1
, len
);
3848 cstr_reset(&tokcstr
);
3851 cstr_ccat(&tokcstr
, *p1
);
3857 while (isidnum_table
[c
-CH_EOF
]) {
3858 cstr_ccat(&tokcstr
, c
);
3861 ts
= tok_alloc(tokcstr
.data
, tokcstr
.size
);
3867 if (t
!= '\\' && t
!= '\'' && t
!= '\"') {
3869 goto parse_ident_fast
;
3872 if (c
== '\'' || c
== '\"') {
3876 cstr_reset(&tokcstr
);
3877 cstr_ccat(&tokcstr
, 'L');
3878 goto parse_ident_slow
;
3882 case '0': case '1': case '2': case '3':
3883 case '4': case '5': case '6': case '7':
3886 cstr_reset(&tokcstr
);
3887 /* after the first digit, accept digits, alpha, '.' or sign if
3888 prefixed by 'eEpP' */
3892 cstr_ccat(&tokcstr
, c
);
3894 if (!(isnum(c
) || isid(c
) || c
== '.' ||
3895 ((c
== '+' || c
== '-') &&
3896 (t
== 'e' || t
== 'E' || t
== 'p' || t
== 'P'))))
3899 /* We add a trailing '\0' to ease parsing */
3900 cstr_ccat(&tokcstr
, '\0');
3901 tokc
.cstr
= &tokcstr
;
3905 /* special dot handling because it can also start a number */
3908 cstr_reset(&tokcstr
);
3909 cstr_ccat(&tokcstr
, '.');
3911 } else if (c
== '.') {
3931 /* parse the string */
3933 p
= parse_pp_string(p
, sep
, &str
);
3934 cstr_ccat(&str
, '\0');
3936 /* eval the escape (should be done as TOK_PPNUM) */
3937 cstr_reset(&tokcstr
);
3938 parse_escape_string(&tokcstr
, str
.data
, is_long
);
3943 /* XXX: make it portable */
3947 char_size
= sizeof(nwchar_t
);
3948 if (tokcstr
.size
<= char_size
)
3949 error("empty character constant");
3950 if (tokcstr
.size
> 2 * char_size
)
3951 warning("multi-character character constant");
3953 tokc
.i
= *(int8_t *)tokcstr
.data
;
3956 tokc
.i
= *(nwchar_t
*)tokcstr
.data
;
3960 tokc
.cstr
= &tokcstr
;
3974 } else if (c
== '<') {
3992 } else if (c
== '>') {
4010 } else if (c
== '=') {
4023 } else if (c
== '=') {
4036 } else if (c
== '=') {
4049 } else if (c
== '=') {
4052 } else if (c
== '>') {
4060 PARSE2('!', '!', '=', TOK_NE
)
4061 PARSE2('=', '=', '=', TOK_EQ
)
4062 PARSE2('*', '*', '=', TOK_A_MUL
)
4063 PARSE2('%', '%', '=', TOK_A_MOD
)
4064 PARSE2('^', '^', '=', TOK_A_XOR
)
4066 /* comments or operator */
4070 p
= parse_comment(p
);
4072 } else if (c
== '/') {
4073 p
= parse_line_comment(p
);
4075 } else if (c
== '=') {
4095 case '$': /* only used in assembler */
4096 case '@': /* dito */
4101 error("unrecognized character \\x%02x", c
);
4107 #if defined(PARSE_DEBUG)
4108 printf("token = %s\n", get_tok_str(tok
, &tokc
));
4112 /* return next token without macro substitution. Can read input from
4114 static void next_nomacro(void)
4120 TOK_GET(tok
, macro_ptr
, tokc
);
4121 if (tok
== TOK_LINENUM
) {
4122 file
->line_num
= tokc
.i
;
4131 /* substitute args in macro_str and return allocated string */
4132 static int *macro_arg_subst(Sym
**nested_list
, int *macro_str
, Sym
*args
)
4134 int *st
, last_tok
, t
, notfirst
;
4143 TOK_GET(t
, macro_str
, cval
);
4148 TOK_GET(t
, macro_str
, cval
);
4151 s
= sym_find2(args
, t
);
4158 cstr_ccat(&cstr
, ' ');
4159 TOK_GET(t
, st
, cval
);
4160 cstr_cat(&cstr
, get_tok_str(t
, &cval
));
4165 cstr_ccat(&cstr
, '\0');
4167 printf("stringize: %s\n", (char *)cstr
.data
);
4171 tok_str_add2(&str
, TOK_STR
, &cval
);
4174 tok_str_add2(&str
, t
, &cval
);
4176 } else if (t
>= TOK_IDENT
) {
4177 s
= sym_find2(args
, t
);
4180 /* if '##' is present before or after, no arg substitution */
4181 if (*macro_str
== TOK_TWOSHARPS
|| last_tok
== TOK_TWOSHARPS
) {
4182 /* special case for var arg macros : ## eats the
4183 ',' if empty VA_ARGS variable. */
4184 /* XXX: test of the ',' is not 100%
4185 reliable. should fix it to avoid security
4187 if (gnu_ext
&& s
->type
.t
&&
4188 last_tok
== TOK_TWOSHARPS
&&
4189 str
.len
>= 2 && str
.str
[str
.len
- 2] == ',') {
4191 /* suppress ',' '##' */
4194 /* suppress '##' and add variable */
4202 TOK_GET(t1
, st
, cval
);
4205 tok_str_add2(&str
, t1
, &cval
);
4209 /* NOTE: the stream cannot be read when macro
4210 substituing an argument */
4211 macro_subst(&str
, nested_list
, st
, NULL
);
4214 tok_str_add(&str
, t
);
4217 tok_str_add2(&str
, t
, &cval
);
4221 tok_str_add(&str
, 0);
4225 static char const ab_month_name
[12][4] =
4227 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
4228 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
4231 /* do macro substitution of current token with macro 's' and add
4232 result to (tok_str,tok_len). 'nested_list' is the list of all
4233 macros we got inside to avoid recursing. Return non zero if no
4234 substitution needs to be done */
4235 static int macro_subst_tok(TokenString
*tok_str
,
4236 Sym
**nested_list
, Sym
*s
, struct macro_level
**can_read_stream
)
4238 Sym
*args
, *sa
, *sa1
;
4239 int mstr_allocated
, parlevel
, *mstr
, t
, t1
;
4246 /* if symbol is a macro, prepare substitution */
4247 /* special macros */
4248 if (tok
== TOK___LINE__
) {
4249 snprintf(buf
, sizeof(buf
), "%d", file
->line_num
);
4253 } else if (tok
== TOK___FILE__
) {
4254 cstrval
= file
->filename
;
4256 } else if (tok
== TOK___DATE__
|| tok
== TOK___TIME__
) {
4261 tm
= localtime(&ti
);
4262 if (tok
== TOK___DATE__
) {
4263 snprintf(buf
, sizeof(buf
), "%s %2d %d",
4264 ab_month_name
[tm
->tm_mon
], tm
->tm_mday
, tm
->tm_year
+ 1900);
4266 snprintf(buf
, sizeof(buf
), "%02d:%02d:%02d",
4267 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
4274 cstr_cat(&cstr
, cstrval
);
4275 cstr_ccat(&cstr
, '\0');
4277 tok_str_add2(tok_str
, t1
, &cval
);
4282 if (s
->type
.t
== MACRO_FUNC
) {
4283 /* NOTE: we do not use next_nomacro to avoid eating the
4284 next token. XXX: find better solution */
4288 if (t
== 0 && can_read_stream
) {
4289 /* end of macro stream: we must look at the token
4290 after in the file */
4291 struct macro_level
*ml
= *can_read_stream
;
4297 *can_read_stream
= ml
-> prev
;
4302 /* XXX: incorrect with comments */
4303 ch
= file
->buf_ptr
[0];
4304 while (is_space(ch
) || ch
== '\n')
4308 if (t
!= '(') /* no macro subst */
4311 /* argument macro */
4316 /* NOTE: empty args are allowed, except if no args */
4318 /* handle '()' case */
4319 if (!args
&& !sa
&& tok
== ')')
4322 error("macro '%s' used with too many args",
4323 get_tok_str(s
->v
, 0));
4326 /* NOTE: non zero sa->t indicates VA_ARGS */
4327 while ((parlevel
> 0 ||
4329 (tok
!= ',' || sa
->type
.t
))) &&
4333 else if (tok
== ')')
4335 if (tok
!= TOK_LINEFEED
)
4336 tok_str_add2(&str
, tok
, &tokc
);
4339 tok_str_add(&str
, 0);
4340 sym_push2(&args
, sa
->v
& ~SYM_FIELD
, sa
->type
.t
, (long)str
.str
);
4343 /* special case for gcc var args: add an empty
4344 var arg argument if it is omitted */
4345 if (sa
&& sa
->type
.t
&& gnu_ext
)
4355 error("macro '%s' used with too few args",
4356 get_tok_str(s
->v
, 0));
4359 /* now subst each arg */
4360 mstr
= macro_arg_subst(nested_list
, mstr
, args
);
4365 tok_str_free((int *)sa
->c
);
4371 sym_push2(nested_list
, s
->v
, 0, 0);
4372 macro_subst(tok_str
, nested_list
, mstr
, can_read_stream
);
4373 /* pop nested defined symbol */
4375 *nested_list
= sa1
->prev
;
4383 /* handle the '##' operator. Return NULL if no '##' seen. Otherwise
4384 return the resulting string (which must be freed). */
4385 static inline int *macro_twosharps(const int *macro_str
)
4388 const int *macro_ptr1
, *start_macro_ptr
, *ptr
, *saved_macro_ptr
;
4390 const char *p1
, *p2
;
4392 TokenString macro_str1
;
4395 start_macro_ptr
= macro_str
;
4396 /* we search the first '##' */
4398 macro_ptr1
= macro_str
;
4399 TOK_GET(t
, macro_str
, cval
);
4400 /* nothing more to do if end of string */
4403 if (*macro_str
== TOK_TWOSHARPS
)
4407 /* we saw '##', so we need more processing to handle it */
4409 tok_str_new(¯o_str1
);
4413 /* add all tokens seen so far */
4414 for(ptr
= start_macro_ptr
; ptr
< macro_ptr1
;) {
4415 TOK_GET(t
, ptr
, cval
);
4416 tok_str_add2(¯o_str1
, t
, &cval
);
4418 saved_macro_ptr
= macro_ptr
;
4419 /* XXX: get rid of the use of macro_ptr here */
4420 macro_ptr
= (int *)macro_str
;
4422 while (*macro_ptr
== TOK_TWOSHARPS
) {
4424 macro_ptr1
= macro_ptr
;
4427 TOK_GET(t
, macro_ptr
, cval
);
4428 /* We concatenate the two tokens if we have an
4429 identifier or a preprocessing number */
4431 p1
= get_tok_str(tok
, &tokc
);
4432 cstr_cat(&cstr
, p1
);
4433 p2
= get_tok_str(t
, &cval
);
4434 cstr_cat(&cstr
, p2
);
4435 cstr_ccat(&cstr
, '\0');
4437 if ((tok
>= TOK_IDENT
|| tok
== TOK_PPNUM
) &&
4438 (t
>= TOK_IDENT
|| t
== TOK_PPNUM
)) {
4439 if (tok
== TOK_PPNUM
) {
4440 /* if number, then create a number token */
4441 /* NOTE: no need to allocate because
4442 tok_str_add2() does it */
4443 cstr_reset(&tokcstr
);
4446 tokc
.cstr
= &tokcstr
;
4448 /* if identifier, we must do a test to
4449 validate we have a correct identifier */
4450 if (t
== TOK_PPNUM
) {
4460 if (!isnum(c
) && !isid(c
))
4464 ts
= tok_alloc(cstr
.data
, strlen(cstr
.data
));
4465 tok
= ts
->tok
; /* modify current token */
4468 const char *str
= cstr
.data
;
4469 const unsigned char *q
;
4471 /* we look for a valid token */
4472 /* XXX: do more extensive checks */
4473 if (!strcmp(str
, ">>=")) {
4475 } else if (!strcmp(str
, "<<=")) {
4477 } else if (strlen(str
) == 2) {
4478 /* search in two bytes table */
4483 if (q
[0] == str
[0] && q
[1] == str
[1])
4490 /* NOTE: because get_tok_str use a static buffer,
4493 p1
= get_tok_str(tok
, &tokc
);
4494 cstr_cat(&cstr
, p1
);
4495 cstr_ccat(&cstr
, '\0');
4496 p2
= get_tok_str(t
, &cval
);
4497 warning("pasting \"%s\" and \"%s\" does not give a valid preprocessing token", cstr
.data
, p2
);
4498 /* cannot merge tokens: just add them separately */
4499 tok_str_add2(¯o_str1
, tok
, &tokc
);
4500 /* XXX: free associated memory ? */
4507 tok_str_add2(¯o_str1
, tok
, &tokc
);
4512 macro_ptr
= (int *)saved_macro_ptr
;
4514 tok_str_add(¯o_str1
, 0);
4515 return macro_str1
.str
;
4519 /* do macro substitution of macro_str and add result to
4520 (tok_str,tok_len). 'nested_list' is the list of all macros we got
4521 inside to avoid recursing. */
4522 static void macro_subst(TokenString
*tok_str
, Sym
**nested_list
,
4523 const int *macro_str
, struct macro_level
** can_read_stream
)
4530 struct macro_level ml
;
4532 /* first scan for '##' operator handling */
4534 macro_str1
= macro_twosharps(ptr
);
4538 /* NOTE: ptr == NULL can only happen if tokens are read from
4539 file stream due to a macro function call */
4542 TOK_GET(t
, ptr
, cval
);
4547 /* if nested substitution, do nothing */
4548 if (sym_find2(*nested_list
, t
))
4551 if (can_read_stream
)
4552 ml
.prev
= *can_read_stream
, *can_read_stream
= &ml
;
4553 macro_ptr
= (int *)ptr
;
4555 ret
= macro_subst_tok(tok_str
, nested_list
, s
, can_read_stream
);
4556 ptr
= (int *)macro_ptr
;
4558 if (can_read_stream
&& *can_read_stream
== &ml
)
4559 *can_read_stream
= ml
.prev
;
4564 tok_str_add2(tok_str
, t
, &cval
);
4568 tok_str_free(macro_str1
);
4571 /* return next token with macro substitution */
4572 static void next(void)
4574 Sym
*nested_list
, *s
;
4576 struct macro_level
*ml
;
4581 /* if not reading from macro substituted string, then try
4582 to substitute macros */
4583 if (tok
>= TOK_IDENT
&&
4584 (parse_flags
& PARSE_FLAG_PREPROCESS
)) {
4585 s
= define_find(tok
);
4587 /* we have a macro: we try to substitute */
4591 if (macro_subst_tok(&str
, &nested_list
, s
, &ml
) == 0) {
4592 /* substitution done, NOTE: maybe empty */
4593 tok_str_add(&str
, 0);
4594 macro_ptr
= str
.str
;
4595 macro_ptr_allocated
= str
.str
;
4602 /* end of macro or end of unget buffer */
4603 if (unget_buffer_enabled
) {
4604 macro_ptr
= unget_saved_macro_ptr
;
4605 unget_buffer_enabled
= 0;
4607 /* end of macro string: free it */
4608 tok_str_free(macro_ptr_allocated
);
4615 /* convert preprocessor tokens into C tokens */
4616 if (tok
== TOK_PPNUM
&&
4617 (parse_flags
& PARSE_FLAG_TOK_NUM
)) {
4618 parse_number((char *)tokc
.cstr
->data
);
4622 /* push back current token and set current token to 'last_tok'. Only
4623 identifier case handled for labels. */
4624 static inline void unget_tok(int last_tok
)
4628 unget_saved_macro_ptr
= macro_ptr
;
4629 unget_buffer_enabled
= 1;
4630 q
= unget_saved_buffer
;
4633 n
= tok_ext_size(tok
) - 1;
4636 *q
= 0; /* end of token string */
4641 void swap(int *p
, int *q
)
4649 void vsetc(CType
*type
, int r
, CValue
*vc
)
4653 if (vtop
>= vstack
+ (VSTACK_SIZE
- 1))
4654 error("memory full");
4655 /* cannot let cpu flags if other instruction are generated. Also
4656 avoid leaving VT_JMP anywhere except on the top of the stack
4657 because it would complicate the code generator. */
4658 if (vtop
>= vstack
) {
4659 v
= vtop
->r
& VT_VALMASK
;
4660 if (v
== VT_CMP
|| (v
& ~1) == VT_JMP
)
4666 vtop
->r2
= VT_CONST
;
4670 /* push integer constant */
4675 vsetc(&int_type
, VT_CONST
, &cval
);
4678 /* push long long constant */
4679 void vpushll(long long v
)
4685 vsetc(&ctype
, VT_CONST
, &cval
);
4688 /* Return a static symbol pointing to a section */
4689 static Sym
*get_sym_ref(CType
*type
, Section
*sec
,
4690 unsigned long offset
, unsigned long size
)
4696 sym
= global_identifier_push(v
, type
->t
| VT_STATIC
, 0);
4697 sym
->type
.ref
= type
->ref
;
4698 sym
->r
= VT_CONST
| VT_SYM
;
4699 put_extern_sym(sym
, sec
, offset
, size
);
4703 /* push a reference to a section offset by adding a dummy symbol */
4704 static void vpush_ref(CType
*type
, Section
*sec
, unsigned long offset
, unsigned long size
)
4709 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
4710 vtop
->sym
= get_sym_ref(type
, sec
, offset
, size
);
4713 /* define a new external reference to a symbol 'v' of type 'u' */
4714 static Sym
*external_global_sym(int v
, CType
*type
, int r
)
4720 /* push forward reference */
4721 s
= global_identifier_push(v
, type
->t
| VT_EXTERN
, 0);
4722 s
->type
.ref
= type
->ref
;
4723 s
->r
= r
| VT_CONST
| VT_SYM
;
4728 /* define a new external reference to a symbol 'v' of type 'u' */
4729 static Sym
*external_sym(int v
, CType
*type
, int r
)
4735 /* push forward reference */
4736 s
= sym_push(v
, type
, r
| VT_CONST
| VT_SYM
, 0);
4737 s
->type
.t
|= VT_EXTERN
;
4739 if (!is_compatible_types(&s
->type
, type
))
4740 error("incompatible types for redefinition of '%s'",
4741 get_tok_str(v
, NULL
));
4746 /* push a reference to global symbol v */
4747 static void vpush_global_sym(CType
*type
, int v
)
4752 sym
= external_global_sym(v
, type
, 0);
4754 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
4758 void vset(CType
*type
, int r
, int v
)
4763 vsetc(type
, r
, &cval
);
4766 void vseti(int r
, int v
)
4782 void vpushv(SValue
*v
)
4784 if (vtop
>= vstack
+ (VSTACK_SIZE
- 1))
4785 error("memory full");
4795 /* save r to the memory stack, and mark it as being free */
4796 void save_reg(int r
)
4798 int l
, saved
, size
, align
;
4802 /* modify all stack values */
4805 for(p
=vstack
;p
<=vtop
;p
++) {
4806 if ((p
->r
& VT_VALMASK
) == r
||
4807 ((p
->type
.t
& VT_BTYPE
) == VT_LLONG
&& (p
->r2
& VT_VALMASK
) == r
)) {
4808 /* must save value on stack if not already done */
4810 /* NOTE: must reload 'r' because r might be equal to r2 */
4811 r
= p
->r
& VT_VALMASK
;
4812 /* store register in the stack */
4814 if ((p
->r
& VT_LVAL
) ||
4815 (!is_float(type
->t
) && (type
->t
& VT_BTYPE
) != VT_LLONG
))
4816 #ifdef TCC_TARGET_X86_64
4817 type
= &char_pointer_type
;
4821 size
= type_size(type
, &align
);
4822 loc
= (loc
- size
) & -align
;
4823 sv
.type
.t
= type
->t
;
4824 sv
.r
= VT_LOCAL
| VT_LVAL
;
4827 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
4828 /* x86 specific: need to pop fp register ST0 if saved */
4829 if (r
== TREG_ST0
) {
4830 o(0xd9dd); /* fstp %st(1) */
4833 #ifndef TCC_TARGET_X86_64
4834 /* special long long case */
4835 if ((type
->t
& VT_BTYPE
) == VT_LLONG
) {
4843 /* mark that stack entry as being saved on the stack */
4844 if (p
->r
& VT_LVAL
) {
4845 /* also clear the bounded flag because the
4846 relocation address of the function was stored in
4848 p
->r
= (p
->r
& ~(VT_VALMASK
| VT_BOUNDED
)) | VT_LLOCAL
;
4850 p
->r
= lvalue_type(p
->type
.t
) | VT_LOCAL
;
4858 /* find a register of class 'rc2' with at most one reference on stack.
4859 * If none, call get_reg(rc) */
4860 int get_reg_ex(int rc
, int rc2
)
4865 for(r
=0;r
<NB_REGS
;r
++) {
4866 if (reg_classes
[r
] & rc2
) {
4869 for(p
= vstack
; p
<= vtop
; p
++) {
4870 if ((p
->r
& VT_VALMASK
) == r
||
4871 (p
->r2
& VT_VALMASK
) == r
)
4881 /* find a free register of class 'rc'. If none, save one register */
4887 /* find a free register */
4888 for(r
=0;r
<NB_REGS
;r
++) {
4889 if (reg_classes
[r
] & rc
) {
4890 for(p
=vstack
;p
<=vtop
;p
++) {
4891 if ((p
->r
& VT_VALMASK
) == r
||
4892 (p
->r2
& VT_VALMASK
) == r
)
4900 /* no register left : free the first one on the stack (VERY
4901 IMPORTANT to start from the bottom to ensure that we don't
4902 spill registers used in gen_opi()) */
4903 for(p
=vstack
;p
<=vtop
;p
++) {
4904 r
= p
->r
& VT_VALMASK
;
4905 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
))
4907 /* also look at second register (if long long) */
4908 r
= p
->r2
& VT_VALMASK
;
4909 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
)) {
4915 /* Should never comes here */
4919 /* save registers up to (vtop - n) stack entry */
4920 void save_regs(int n
)
4925 for(p
= vstack
;p
<= p1
; p
++) {
4926 r
= p
->r
& VT_VALMASK
;
4933 /* move register 's' to 'r', and flush previous value of r to memory
4935 void move_reg(int r
, int s
)
4948 /* get address of vtop (vtop MUST BE an lvalue) */
4951 vtop
->r
&= ~VT_LVAL
;
4952 /* tricky: if saved lvalue, then we can go back to lvalue */
4953 if ((vtop
->r
& VT_VALMASK
) == VT_LLOCAL
)
4954 vtop
->r
= (vtop
->r
& ~(VT_VALMASK
| VT_LVAL_TYPE
)) | VT_LOCAL
| VT_LVAL
;
4957 #ifdef CONFIG_TCC_BCHECK
4958 /* generate lvalue bound code */
4964 vtop
->r
&= ~VT_MUSTBOUND
;
4965 /* if lvalue, then use checking code before dereferencing */
4966 if (vtop
->r
& VT_LVAL
) {
4967 /* if not VT_BOUNDED value, then make one */
4968 if (!(vtop
->r
& VT_BOUNDED
)) {
4969 lval_type
= vtop
->r
& (VT_LVAL_TYPE
| VT_LVAL
);
4970 /* must save type because we must set it to int to get pointer */
4972 vtop
->type
.t
= VT_INT
;
4975 gen_bounded_ptr_add();
4976 vtop
->r
|= lval_type
;
4979 /* then check for dereferencing */
4980 gen_bounded_ptr_deref();
4985 /* store vtop a register belonging to class 'rc'. lvalues are
4986 converted to values. Cannot be used if cannot be converted to
4987 register value (such as structures). */
4990 int r
, rc2
, bit_pos
, bit_size
, size
, align
, i
;
4992 /* NOTE: get_reg can modify vstack[] */
4993 if (vtop
->type
.t
& VT_BITFIELD
) {
4996 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4997 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
4998 /* remove bit field info to avoid loops */
4999 vtop
->type
.t
&= ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
5000 /* cast to int to propagate signedness in following ops */
5001 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
5006 if((vtop
->type
.t
& VT_UNSIGNED
) ||
5007 (vtop
->type
.t
& VT_BTYPE
) == VT_BOOL
)
5008 type
.t
|= VT_UNSIGNED
;
5010 /* generate shifts */
5011 vpushi(bits
- (bit_pos
+ bit_size
));
5013 vpushi(bits
- bit_size
);
5014 /* NOTE: transformed to SHR if unsigned */
5018 if (is_float(vtop
->type
.t
) &&
5019 (vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
5022 unsigned long offset
;
5023 #if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
5027 /* XXX: unify with initializers handling ? */
5028 /* CPUs usually cannot use float constants, so we store them
5029 generically in data segment */
5030 size
= type_size(&vtop
->type
, &align
);
5031 offset
= (data_section
->data_offset
+ align
- 1) & -align
;
5032 data_section
->data_offset
= offset
;
5033 /* XXX: not portable yet */
5034 #if defined(__i386__) || defined(__x86_64__)
5035 /* Zero pad x87 tenbyte long doubles */
5036 if (size
== LDOUBLE_SIZE
)
5037 vtop
->c
.tab
[2] &= 0xffff;
5039 ptr
= section_ptr_add(data_section
, size
);
5041 #if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
5045 ptr
[i
] = vtop
->c
.tab
[size
-1-i
];
5049 ptr
[i
] = vtop
->c
.tab
[i
];
5050 sym
= get_sym_ref(&vtop
->type
, data_section
, offset
, size
<< 2);
5051 vtop
->r
|= VT_LVAL
| VT_SYM
;
5055 #ifdef CONFIG_TCC_BCHECK
5056 if (vtop
->r
& VT_MUSTBOUND
)
5060 r
= vtop
->r
& VT_VALMASK
;
5064 /* need to reload if:
5066 - lvalue (need to dereference pointer)
5067 - already a register, but not in the right class */
5068 if (r
>= VT_CONST
||
5069 (vtop
->r
& VT_LVAL
) ||
5070 !(reg_classes
[r
] & rc
) ||
5071 ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
&&
5072 !(reg_classes
[vtop
->r2
] & rc2
))) {
5074 #ifndef TCC_TARGET_X86_64
5075 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
5077 unsigned long long ll
;
5078 /* two register type load : expand to two words
5080 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
5083 vtop
->c
.ui
= ll
; /* first word */
5085 vtop
->r
= r
; /* save register value */
5086 vpushi(ll
>> 32); /* second word */
5087 } else if (r
>= VT_CONST
|| /* XXX: test to VT_CONST incorrect ? */
5088 (vtop
->r
& VT_LVAL
)) {
5089 /* We do not want to modifier the long long
5090 pointer here, so the safest (and less
5091 efficient) is to save all the other registers
5092 in the stack. XXX: totally inefficient. */
5094 /* load from memory */
5097 vtop
[-1].r
= r
; /* save register value */
5098 /* increment pointer to get second word */
5099 vtop
->type
.t
= VT_INT
;
5105 /* move registers */
5108 vtop
[-1].r
= r
; /* save register value */
5109 vtop
->r
= vtop
[-1].r2
;
5111 /* allocate second register */
5115 /* write second register */
5119 if ((vtop
->r
& VT_LVAL
) && !is_float(vtop
->type
.t
)) {
5121 /* lvalue of scalar type : need to use lvalue type
5122 because of possible cast */
5125 /* compute memory access type */
5126 if (vtop
->r
& VT_LVAL_BYTE
)
5128 else if (vtop
->r
& VT_LVAL_SHORT
)
5130 if (vtop
->r
& VT_LVAL_UNSIGNED
)
5134 /* restore wanted type */
5137 /* one register type load */
5142 #ifdef TCC_TARGET_C67
5143 /* uses register pairs for doubles */
5144 if ((vtop
->type
.t
& VT_BTYPE
) == VT_DOUBLE
)
5151 /* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
5152 void gv2(int rc1
, int rc2
)
5156 /* generate more generic register first. But VT_JMP or VT_CMP
5157 values must be generated first in all cases to avoid possible
5159 v
= vtop
[0].r
& VT_VALMASK
;
5160 if (v
!= VT_CMP
&& (v
& ~1) != VT_JMP
&& rc1
<= rc2
) {
5165 /* test if reload is needed for first register */
5166 if ((vtop
[-1].r
& VT_VALMASK
) >= VT_CONST
) {
5176 /* test if reload is needed for first register */
5177 if ((vtop
[0].r
& VT_VALMASK
) >= VT_CONST
) {
5183 /* wrapper around RC_FRET to return a register by type */
5186 #ifdef TCC_TARGET_X86_64
5187 if (t
== VT_LDOUBLE
) {
5194 /* wrapper around REG_FRET to return a register by type */
5197 #ifdef TCC_TARGET_X86_64
5198 if (t
== VT_LDOUBLE
) {
5205 /* expand long long on stack in two int registers */
5210 u
= vtop
->type
.t
& VT_UNSIGNED
;
5213 vtop
[0].r
= vtop
[-1].r2
;
5214 vtop
[0].r2
= VT_CONST
;
5215 vtop
[-1].r2
= VT_CONST
;
5216 vtop
[0].type
.t
= VT_INT
| u
;
5217 vtop
[-1].type
.t
= VT_INT
| u
;
5220 #ifdef TCC_TARGET_ARM
5221 /* expand long long on stack */
5222 void lexpand_nr(void)
5226 u
= vtop
->type
.t
& VT_UNSIGNED
;
5228 vtop
->r2
= VT_CONST
;
5229 vtop
->type
.t
= VT_INT
| u
;
5230 v
=vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
);
5231 if (v
== VT_CONST
) {
5232 vtop
[-1].c
.ui
= vtop
->c
.ull
;
5233 vtop
->c
.ui
= vtop
->c
.ull
>> 32;
5235 } else if (v
== (VT_LVAL
|VT_CONST
) || v
== (VT_LVAL
|VT_LOCAL
)) {
5237 vtop
->r
= vtop
[-1].r
;
5238 } else if (v
> VT_CONST
) {
5242 vtop
->r
= vtop
[-1].r2
;
5243 vtop
[-1].r2
= VT_CONST
;
5244 vtop
[-1].type
.t
= VT_INT
| u
;
5248 /* build a long long from two ints */
5251 gv2(RC_INT
, RC_INT
);
5252 vtop
[-1].r2
= vtop
[0].r
;
5253 vtop
[-1].type
.t
= t
;
5257 /* rotate n first stack elements to the bottom
5258 I1 ... In -> I2 ... In I1 [top is right]
5266 for(i
=-n
+1;i
!=0;i
++)
5267 vtop
[i
] = vtop
[i
+1];
5271 /* rotate n first stack elements to the top
5272 I1 ... In -> In I1 ... I(n-1) [top is right]
5280 for(i
= 0;i
< n
- 1; i
++)
5281 vtop
[-i
] = vtop
[-i
- 1];
5285 #ifdef TCC_TARGET_ARM
5286 /* like vrott but in other direction
5287 In ... I1 -> I(n-1) ... I1 In [top is right]
5295 for(i
= n
- 1; i
> 0; i
--)
5296 vtop
[-i
] = vtop
[-i
+ 1];
5301 /* pop stack value */
5305 v
= vtop
->r
& VT_VALMASK
;
5306 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
5307 /* for x86, we need to pop the FP stack */
5308 if (v
== TREG_ST0
&& !nocode_wanted
) {
5309 o(0xd9dd); /* fstp %st(1) */
5312 if (v
== VT_JMP
|| v
== VT_JMPI
) {
5313 /* need to put correct jump if && or || without test */
5319 /* convert stack entry to register and duplicate its value in another
5327 if ((t
& VT_BTYPE
) == VT_LLONG
) {
5334 /* stack: H L L1 H1 */
5342 /* duplicate value */
5347 #ifdef TCC_TARGET_X86_64
5348 if ((t
& VT_BTYPE
) == VT_LDOUBLE
) {
5358 load(r1
, &sv
); /* move r to r1 */
5360 /* duplicates value */
5365 #ifndef TCC_TARGET_X86_64
5366 /* generate CPU independent (unsigned) long long operations */
5367 void gen_opl(int op
)
5369 int t
, a
, b
, op1
, c
, i
;
5371 unsigned short reg_iret
= REG_IRET
;
5372 unsigned short reg_lret
= REG_LRET
;
5378 func
= TOK___divdi3
;
5381 func
= TOK___udivdi3
;
5384 func
= TOK___moddi3
;
5387 func
= TOK___umoddi3
;
5394 /* call generic long long function */
5395 vpush_global_sym(&func_old_type
, func
);
5400 vtop
->r2
= reg_lret
;
5413 /* stack: L1 H1 L2 H2 */
5418 vtop
[-2] = vtop
[-3];
5421 /* stack: H1 H2 L1 L2 */
5427 /* stack: H1 H2 L1 L2 ML MH */
5430 /* stack: ML MH H1 H2 L1 L2 */
5434 /* stack: ML MH H1 L2 H2 L1 */
5439 /* stack: ML MH M1 M2 */
5442 } else if (op
== '+' || op
== '-') {
5443 /* XXX: add non carry method too (for MIPS or alpha) */
5449 /* stack: H1 H2 (L1 op L2) */
5452 gen_op(op1
+ 1); /* TOK_xxxC2 */
5455 /* stack: H1 H2 (L1 op L2) */
5458 /* stack: (L1 op L2) H1 H2 */
5460 /* stack: (L1 op L2) (H1 op H2) */
5468 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
5469 t
= vtop
[-1].type
.t
;
5473 /* stack: L H shift */
5475 /* constant: simpler */
5476 /* NOTE: all comments are for SHL. the other cases are
5477 done by swaping words */
5488 if (op
!= TOK_SAR
) {
5521 /* XXX: should provide a faster fallback on x86 ? */
5524 func
= TOK___ashrdi3
;
5527 func
= TOK___lshrdi3
;
5530 func
= TOK___ashldi3
;
5536 /* compare operations */
5542 /* stack: L1 H1 L2 H2 */
5544 vtop
[-1] = vtop
[-2];
5546 /* stack: L1 L2 H1 H2 */
5549 /* when values are equal, we need to compare low words. since
5550 the jump is inverted, we invert the test too. */
5553 else if (op1
== TOK_GT
)
5555 else if (op1
== TOK_ULT
)
5557 else if (op1
== TOK_UGT
)
5562 if (op1
!= TOK_NE
) {
5566 /* generate non equal test */
5567 /* XXX: NOT PORTABLE yet */
5571 #if defined(TCC_TARGET_I386)
5572 b
= psym(0x850f, 0);
5573 #elif defined(TCC_TARGET_ARM)
5575 o(0x1A000000 | encbranch(ind
, 0, 1));
5576 #elif defined(TCC_TARGET_C67)
5577 error("not implemented");
5579 #error not supported
5583 /* compare low. Always unsigned */
5587 else if (op1
== TOK_LE
)
5589 else if (op1
== TOK_GT
)
5591 else if (op1
== TOK_GE
)
5602 /* handle integer constant optimizations and various machine
5604 void gen_opic(int op
)
5606 int c1
, c2
, t1
, t2
, n
;
5609 typedef unsigned long long U
;
5613 t1
= v1
->type
.t
& VT_BTYPE
;
5614 t2
= v2
->type
.t
& VT_BTYPE
;
5618 else if (v1
->type
.t
& VT_UNSIGNED
)
5625 else if (v2
->type
.t
& VT_UNSIGNED
)
5630 /* currently, we cannot do computations with forward symbols */
5631 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5632 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5635 case '+': l1
+= l2
; break;
5636 case '-': l1
-= l2
; break;
5637 case '&': l1
&= l2
; break;
5638 case '^': l1
^= l2
; break;
5639 case '|': l1
|= l2
; break;
5640 case '*': l1
*= l2
; break;
5647 /* if division by zero, generate explicit division */
5650 error("division by zero in constant");
5654 default: l1
/= l2
; break;
5655 case '%': l1
%= l2
; break;
5656 case TOK_UDIV
: l1
= (U
)l1
/ l2
; break;
5657 case TOK_UMOD
: l1
= (U
)l1
% l2
; break;
5660 case TOK_SHL
: l1
<<= l2
; break;
5661 case TOK_SHR
: l1
= (U
)l1
>> l2
; break;
5662 case TOK_SAR
: l1
>>= l2
; break;
5664 case TOK_ULT
: l1
= (U
)l1
< (U
)l2
; break;
5665 case TOK_UGE
: l1
= (U
)l1
>= (U
)l2
; break;
5666 case TOK_EQ
: l1
= l1
== l2
; break;
5667 case TOK_NE
: l1
= l1
!= l2
; break;
5668 case TOK_ULE
: l1
= (U
)l1
<= (U
)l2
; break;
5669 case TOK_UGT
: l1
= (U
)l1
> (U
)l2
; break;
5670 case TOK_LT
: l1
= l1
< l2
; break;
5671 case TOK_GE
: l1
= l1
>= l2
; break;
5672 case TOK_LE
: l1
= l1
<= l2
; break;
5673 case TOK_GT
: l1
= l1
> l2
; break;
5675 case TOK_LAND
: l1
= l1
&& l2
; break;
5676 case TOK_LOR
: l1
= l1
|| l2
; break;
5683 /* if commutative ops, put c2 as constant */
5684 if (c1
&& (op
== '+' || op
== '&' || op
== '^' ||
5685 op
== '|' || op
== '*')) {
5687 c2
= c1
; //c = c1, c1 = c2, c2 = c;
5688 l2
= l1
; //l = l1, l1 = l2, l2 = l;
5690 /* Filter out NOP operations like x*1, x-0, x&-1... */
5691 if (c2
&& (((op
== '*' || op
== '/' || op
== TOK_UDIV
||
5694 ((op
== '+' || op
== '-' || op
== '|' || op
== '^' ||
5695 op
== TOK_SHL
|| op
== TOK_SHR
|| op
== TOK_SAR
) &&
5701 } else if (c2
&& (op
== '*' || op
== TOK_PDIV
|| op
== TOK_UDIV
)) {
5702 /* try to use shifts instead of muls or divs */
5703 if (l2
> 0 && (l2
& (l2
- 1)) == 0) {
5712 else if (op
== TOK_PDIV
)
5718 } else if (c2
&& (op
== '+' || op
== '-') &&
5719 ((vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) ==
5720 (VT_CONST
| VT_SYM
) ||
5721 (vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
)) == VT_LOCAL
)) {
5722 /* symbol + constant case */
5729 if (!nocode_wanted
) {
5730 /* call low level op generator */
5731 if (t1
== VT_LLONG
|| t2
== VT_LLONG
)
5742 /* generate a floating point operation with constant propagation */
5743 void gen_opif(int op
)
5751 /* currently, we cannot do computations with forward symbols */
5752 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5753 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5755 if (v1
->type
.t
== VT_FLOAT
) {
5758 } else if (v1
->type
.t
== VT_DOUBLE
) {
5766 /* NOTE: we only do constant propagation if finite number (not
5767 NaN or infinity) (ANSI spec) */
5768 if (!ieee_finite(f1
) || !ieee_finite(f2
))
5772 case '+': f1
+= f2
; break;
5773 case '-': f1
-= f2
; break;
5774 case '*': f1
*= f2
; break;
5778 error("division by zero in constant");
5783 /* XXX: also handles tests ? */
5787 /* XXX: overflow test ? */
5788 if (v1
->type
.t
== VT_FLOAT
) {
5790 } else if (v1
->type
.t
== VT_DOUBLE
) {
5798 if (!nocode_wanted
) {
5806 static int pointed_size(CType
*type
)
5809 return type_size(pointed_type(type
), &align
);
5812 static inline int is_null_pointer(SValue
*p
)
5814 if ((p
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
5816 return ((p
->type
.t
& VT_BTYPE
) == VT_INT
&& p
->c
.i
== 0) ||
5817 ((p
->type
.t
& VT_BTYPE
) == VT_LLONG
&& p
->c
.ll
== 0);
5820 static inline int is_integer_btype(int bt
)
5822 return (bt
== VT_BYTE
|| bt
== VT_SHORT
||
5823 bt
== VT_INT
|| bt
== VT_LLONG
);
5826 /* check types for comparison or substraction of pointers */
5827 static void check_comparison_pointer_types(SValue
*p1
, SValue
*p2
, int op
)
5829 CType
*type1
, *type2
, tmp_type1
, tmp_type2
;
5832 /* null pointers are accepted for all comparisons as gcc */
5833 if (is_null_pointer(p1
) || is_null_pointer(p2
))
5837 bt1
= type1
->t
& VT_BTYPE
;
5838 bt2
= type2
->t
& VT_BTYPE
;
5839 /* accept comparison between pointer and integer with a warning */
5840 if ((is_integer_btype(bt1
) || is_integer_btype(bt2
)) && op
!= '-') {
5841 if (op
!= TOK_LOR
&& op
!= TOK_LAND
)
5842 warning("comparison between pointer and integer");
5846 /* both must be pointers or implicit function pointers */
5847 if (bt1
== VT_PTR
) {
5848 type1
= pointed_type(type1
);
5849 } else if (bt1
!= VT_FUNC
)
5850 goto invalid_operands
;
5852 if (bt2
== VT_PTR
) {
5853 type2
= pointed_type(type2
);
5854 } else if (bt2
!= VT_FUNC
) {
5856 error("invalid operands to binary %s", get_tok_str(op
, NULL
));
5858 if ((type1
->t
& VT_BTYPE
) == VT_VOID
||
5859 (type2
->t
& VT_BTYPE
) == VT_VOID
)
5863 tmp_type1
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
5864 tmp_type2
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
5865 if (!is_compatible_types(&tmp_type1
, &tmp_type2
)) {
5866 /* gcc-like error if '-' is used */
5868 goto invalid_operands
;
5870 warning("comparison of distinct pointer types lacks a cast");
5874 /* generic gen_op: handles types problems */
5877 int u
, t1
, t2
, bt1
, bt2
, t
;
5880 t1
= vtop
[-1].type
.t
;
5881 t2
= vtop
[0].type
.t
;
5882 bt1
= t1
& VT_BTYPE
;
5883 bt2
= t2
& VT_BTYPE
;
5885 if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
5886 /* at least one operand is a pointer */
5887 /* relationnal op: must be both pointers */
5888 if (op
>= TOK_ULT
&& op
<= TOK_LOR
) {
5889 check_comparison_pointer_types(vtop
- 1, vtop
, op
);
5890 /* pointers are handled are unsigned */
5891 #ifdef TCC_TARGET_X86_64
5892 t
= VT_LLONG
| VT_UNSIGNED
;
5894 t
= VT_INT
| VT_UNSIGNED
;
5898 /* if both pointers, then it must be the '-' op */
5899 if (bt1
== VT_PTR
&& bt2
== VT_PTR
) {
5901 error("cannot use pointers here");
5902 check_comparison_pointer_types(vtop
- 1, vtop
, op
);
5903 /* XXX: check that types are compatible */
5904 u
= pointed_size(&vtop
[-1].type
);
5906 /* set to integer type */
5907 #ifdef TCC_TARGET_X86_64
5908 vtop
->type
.t
= VT_LLONG
;
5910 vtop
->type
.t
= VT_INT
;
5915 /* exactly one pointer : must be '+' or '-'. */
5916 if (op
!= '-' && op
!= '+')
5917 error("cannot use pointers here");
5918 /* Put pointer as first operand */
5919 if (bt2
== VT_PTR
) {
5923 type1
= vtop
[-1].type
;
5924 #ifdef TCC_TARGET_X86_64
5925 vpushll(pointed_size(&vtop
[-1].type
));
5927 /* XXX: cast to int ? (long long case) */
5928 vpushi(pointed_size(&vtop
[-1].type
));
5931 #ifdef CONFIG_TCC_BCHECK
5932 /* if evaluating constant expression, no code should be
5933 generated, so no bound check */
5934 if (do_bounds_check
&& !const_wanted
) {
5935 /* if bounded pointers, we generate a special code to
5942 gen_bounded_ptr_add();
5948 /* put again type if gen_opic() swaped operands */
5951 } else if (is_float(bt1
) || is_float(bt2
)) {
5952 /* compute bigger type and do implicit casts */
5953 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
5955 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
5960 /* floats can only be used for a few operations */
5961 if (op
!= '+' && op
!= '-' && op
!= '*' && op
!= '/' &&
5962 (op
< TOK_ULT
|| op
> TOK_GT
))
5963 error("invalid operands for binary operation");
5965 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
5966 /* cast to biggest op */
5968 /* convert to unsigned if it does not fit in a long long */
5969 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
5970 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
5974 /* integer operations */
5976 /* convert to unsigned if it does not fit in an integer */
5977 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
5978 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
5981 /* XXX: currently, some unsigned operations are explicit, so
5982 we modify them here */
5983 if (t
& VT_UNSIGNED
) {
5990 else if (op
== TOK_LT
)
5992 else if (op
== TOK_GT
)
5994 else if (op
== TOK_LE
)
5996 else if (op
== TOK_GE
)
6003 /* special case for shifts and long long: we keep the shift as
6005 if (op
== TOK_SHR
|| op
== TOK_SAR
|| op
== TOK_SHL
)
6012 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
6013 /* relationnal op: the result is an int */
6014 vtop
->type
.t
= VT_INT
;
6021 #ifndef TCC_TARGET_ARM
6022 /* generic itof for unsigned long long case */
6023 void gen_cvt_itof1(int t
)
6025 if ((vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
)) ==
6026 (VT_LLONG
| VT_UNSIGNED
)) {
6029 vpush_global_sym(&func_old_type
, TOK___floatundisf
);
6030 #if LDOUBLE_SIZE != 8
6031 else if (t
== VT_LDOUBLE
)
6032 vpush_global_sym(&func_old_type
, TOK___floatundixf
);
6035 vpush_global_sym(&func_old_type
, TOK___floatundidf
);
6039 vtop
->r
= reg_fret(t
);
6046 /* generic ftoi for unsigned long long case */
6047 void gen_cvt_ftoi1(int t
)
6051 if (t
== (VT_LLONG
| VT_UNSIGNED
)) {
6052 /* not handled natively */
6053 st
= vtop
->type
.t
& VT_BTYPE
;
6055 vpush_global_sym(&func_old_type
, TOK___fixunssfdi
);
6056 #if LDOUBLE_SIZE != 8
6057 else if (st
== VT_LDOUBLE
)
6058 vpush_global_sym(&func_old_type
, TOK___fixunsxfdi
);
6061 vpush_global_sym(&func_old_type
, TOK___fixunsdfdi
);
6066 vtop
->r2
= REG_LRET
;
6072 /* force char or short cast */
6073 void force_charshort_cast(int t
)
6077 /* XXX: add optimization if lvalue : just change type and offset */
6082 if (t
& VT_UNSIGNED
) {
6083 vpushi((1 << bits
) - 1);
6089 /* result must be signed or the SAR is converted to an SHL
6090 This was not the case when "t" was a signed short
6091 and the last value on the stack was an unsigned int */
6092 vtop
->type
.t
&= ~VT_UNSIGNED
;
6098 /* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
6099 static void gen_cast(CType
*type
)
6101 int sbt
, dbt
, sf
, df
, c
, p
;
6103 /* special delayed cast for char/short */
6104 /* XXX: in some cases (multiple cascaded casts), it may still
6106 if (vtop
->r
& VT_MUSTCAST
) {
6107 vtop
->r
&= ~VT_MUSTCAST
;
6108 force_charshort_cast(vtop
->type
.t
);
6111 /* bitfields first get cast to ints */
6112 if (vtop
->type
.t
& VT_BITFIELD
) {
6116 dbt
= type
->t
& (VT_BTYPE
| VT_UNSIGNED
);
6117 sbt
= vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
);
6122 c
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
6123 p
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == (VT_CONST
| VT_SYM
);
6125 /* constant case: we can do it now */
6126 /* XXX: in ISOC, cannot do it if error in convert */
6127 if (sbt
== VT_FLOAT
)
6128 vtop
->c
.ld
= vtop
->c
.f
;
6129 else if (sbt
== VT_DOUBLE
)
6130 vtop
->c
.ld
= vtop
->c
.d
;
6133 if ((sbt
& VT_BTYPE
) == VT_LLONG
) {
6134 if (sbt
& VT_UNSIGNED
)
6135 vtop
->c
.ld
= vtop
->c
.ull
;
6137 vtop
->c
.ld
= vtop
->c
.ll
;
6139 if (sbt
& VT_UNSIGNED
)
6140 vtop
->c
.ld
= vtop
->c
.ui
;
6142 vtop
->c
.ld
= vtop
->c
.i
;
6145 if (dbt
== VT_FLOAT
)
6146 vtop
->c
.f
= (float)vtop
->c
.ld
;
6147 else if (dbt
== VT_DOUBLE
)
6148 vtop
->c
.d
= (double)vtop
->c
.ld
;
6149 } else if (sf
&& dbt
== (VT_LLONG
|VT_UNSIGNED
)) {
6150 vtop
->c
.ull
= (unsigned long long)vtop
->c
.ld
;
6151 } else if (sf
&& dbt
== VT_BOOL
) {
6152 vtop
->c
.i
= (vtop
->c
.ld
!= 0);
6155 vtop
->c
.ll
= (long long)vtop
->c
.ld
;
6156 else if (sbt
== (VT_LLONG
|VT_UNSIGNED
))
6157 vtop
->c
.ll
= vtop
->c
.ull
;
6158 else if (sbt
& VT_UNSIGNED
)
6159 vtop
->c
.ll
= vtop
->c
.ui
;
6160 else if (sbt
!= VT_LLONG
)
6161 vtop
->c
.ll
= vtop
->c
.i
;
6163 if (dbt
== (VT_LLONG
|VT_UNSIGNED
))
6164 vtop
->c
.ull
= vtop
->c
.ll
;
6165 else if (dbt
== VT_BOOL
)
6166 vtop
->c
.i
= (vtop
->c
.ll
!= 0);
6167 else if (dbt
!= VT_LLONG
) {
6169 if ((dbt
& VT_BTYPE
) == VT_BYTE
)
6171 else if ((dbt
& VT_BTYPE
) == VT_SHORT
)
6174 if(dbt
& VT_UNSIGNED
)
6175 vtop
->c
.ui
= ((unsigned int)vtop
->c
.ll
<< s
) >> s
;
6177 vtop
->c
.i
= ((int)vtop
->c
.ll
<< s
) >> s
;
6180 } else if (p
&& dbt
== VT_BOOL
) {
6183 } else if (!nocode_wanted
) {
6184 /* non constant case: generate code */
6186 /* convert from fp to fp */
6189 /* convert int to fp */
6192 /* convert fp to int */
6193 if (dbt
== VT_BOOL
) {
6197 /* we handle char/short/etc... with generic code */
6198 if (dbt
!= (VT_INT
| VT_UNSIGNED
) &&
6199 dbt
!= (VT_LLONG
| VT_UNSIGNED
) &&
6203 if (dbt
== VT_INT
&& (type
->t
& (VT_BTYPE
| VT_UNSIGNED
)) != dbt
) {
6204 /* additional cast for char/short... */
6209 } else if ((dbt
& VT_BTYPE
) == VT_LLONG
) {
6210 if ((sbt
& VT_BTYPE
) != VT_LLONG
) {
6211 /* scalar to long long */
6212 #ifndef TCC_TARGET_X86_64
6213 /* machine independent conversion */
6215 /* generate high word */
6216 if (sbt
== (VT_INT
| VT_UNSIGNED
)) {
6224 /* patch second register */
6225 vtop
[-1].r2
= vtop
->r
;
6229 if (sbt
!= (VT_INT
| VT_UNSIGNED
)) {
6230 /* x86_64 specific: movslq */
6232 o(0xc0 + (REG_VALUE(r
) << 3) + REG_VALUE(r
));
6236 } else if (dbt
== VT_BOOL
) {
6237 /* scalar to bool */
6240 } else if ((dbt
& VT_BTYPE
) == VT_BYTE
||
6241 (dbt
& VT_BTYPE
) == VT_SHORT
) {
6242 if (sbt
== VT_PTR
) {
6243 vtop
->type
.t
= VT_INT
;
6244 warning("nonportable conversion from pointer to char/short");
6246 force_charshort_cast(dbt
);
6247 } else if ((dbt
& VT_BTYPE
) == VT_INT
) {
6249 if (sbt
== VT_LLONG
) {
6250 /* from long long: just take low order word */
6254 /* if lvalue and single word type, nothing to do because
6255 the lvalue already contains the real type size (see
6256 VT_LVAL_xxx constants) */
6259 } else if ((dbt
& VT_BTYPE
) == VT_PTR
&& !(vtop
->r
& VT_LVAL
)) {
6260 /* if we are casting between pointer types,
6261 we must update the VT_LVAL_xxx size */
6262 vtop
->r
= (vtop
->r
& ~VT_LVAL_TYPE
)
6263 | (lvalue_type(type
->ref
->type
.t
) & VT_LVAL_TYPE
);
6268 /* return type size. Put alignment at 'a' */
6269 static int type_size(CType
*type
, int *a
)
6274 bt
= type
->t
& VT_BTYPE
;
6275 if (bt
== VT_STRUCT
) {
6280 } else if (bt
== VT_PTR
) {
6281 if (type
->t
& VT_ARRAY
) {
6285 ts
= type_size(&s
->type
, a
);
6287 if (ts
< 0 && s
->c
< 0)
6295 } else if (bt
== VT_LDOUBLE
) {
6297 return LDOUBLE_SIZE
;
6298 } else if (bt
== VT_DOUBLE
|| bt
== VT_LLONG
) {
6299 #ifdef TCC_TARGET_I386
6300 #ifdef TCC_TARGET_PE
6305 #elif defined(TCC_TARGET_ARM)
6315 } else if (bt
== VT_INT
|| bt
== VT_ENUM
|| bt
== VT_FLOAT
) {
6318 } else if (bt
== VT_SHORT
) {
6322 /* char, void, function, _Bool */
6328 /* return the pointed type of t */
6329 static inline CType
*pointed_type(CType
*type
)
6331 return &type
->ref
->type
;
6334 /* modify type so that its it is a pointer to type. */
6335 static void mk_pointer(CType
*type
)
6338 s
= sym_push(SYM_FIELD
, type
, 0, -1);
6339 type
->t
= VT_PTR
| (type
->t
& ~VT_TYPE
);
6343 /* compare function types. OLD functions match any new functions */
6344 static int is_compatible_func(CType
*type1
, CType
*type2
)
6350 if (!is_compatible_types(&s1
->type
, &s2
->type
))
6352 /* check func_call */
6353 if (FUNC_CALL(s1
->r
) != FUNC_CALL(s2
->r
))
6355 /* XXX: not complete */
6356 if (s1
->c
== FUNC_OLD
|| s2
->c
== FUNC_OLD
)
6360 while (s1
!= NULL
) {
6363 if (!is_compatible_parameter_types(&s1
->type
, &s2
->type
))
6373 /* return true if type1 and type2 are the same. If unqualified is
6374 true, qualifiers on the types are ignored.
6376 - enums are not checked as gcc __builtin_types_compatible_p ()
6378 static int compare_types(CType
*type1
, CType
*type2
, int unqualified
)
6382 t1
= type1
->t
& VT_TYPE
;
6383 t2
= type2
->t
& VT_TYPE
;
6385 /* strip qualifiers before comparing */
6386 t1
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6387 t2
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6389 /* XXX: bitfields ? */
6392 /* test more complicated cases */
6393 bt1
= t1
& VT_BTYPE
;
6394 if (bt1
== VT_PTR
) {
6395 type1
= pointed_type(type1
);
6396 type2
= pointed_type(type2
);
6397 return is_compatible_types(type1
, type2
);
6398 } else if (bt1
== VT_STRUCT
) {
6399 return (type1
->ref
== type2
->ref
);
6400 } else if (bt1
== VT_FUNC
) {
6401 return is_compatible_func(type1
, type2
);
6407 /* return true if type1 and type2 are exactly the same (including
6410 static int is_compatible_types(CType
*type1
, CType
*type2
)
6412 return compare_types(type1
,type2
,0);
6415 /* return true if type1 and type2 are the same (ignoring qualifiers).
6417 static int is_compatible_parameter_types(CType
*type1
, CType
*type2
)
6419 return compare_types(type1
,type2
,1);
6422 /* print a type. If 'varstr' is not NULL, then the variable is also
6423 printed in the type */
6425 /* XXX: add array and function pointers */
6426 void type_to_str(char *buf
, int buf_size
,
6427 CType
*type
, const char *varstr
)
6434 t
= type
->t
& VT_TYPE
;
6437 if (t
& VT_CONSTANT
)
6438 pstrcat(buf
, buf_size
, "const ");
6439 if (t
& VT_VOLATILE
)
6440 pstrcat(buf
, buf_size
, "volatile ");
6441 if (t
& VT_UNSIGNED
)
6442 pstrcat(buf
, buf_size
, "unsigned ");
6472 tstr
= "long double";
6474 pstrcat(buf
, buf_size
, tstr
);
6478 if (bt
== VT_STRUCT
)
6482 pstrcat(buf
, buf_size
, tstr
);
6483 v
= type
->ref
->v
& ~SYM_STRUCT
;
6484 if (v
>= SYM_FIRST_ANOM
)
6485 pstrcat(buf
, buf_size
, "<anonymous>");
6487 pstrcat(buf
, buf_size
, get_tok_str(v
, NULL
));
6491 type_to_str(buf
, buf_size
, &s
->type
, varstr
);
6492 pstrcat(buf
, buf_size
, "(");
6494 while (sa
!= NULL
) {
6495 type_to_str(buf1
, sizeof(buf1
), &sa
->type
, NULL
);
6496 pstrcat(buf
, buf_size
, buf1
);
6499 pstrcat(buf
, buf_size
, ", ");
6501 pstrcat(buf
, buf_size
, ")");
6505 pstrcpy(buf1
, sizeof(buf1
), "*");
6507 pstrcat(buf1
, sizeof(buf1
), varstr
);
6508 type_to_str(buf
, buf_size
, &s
->type
, buf1
);
6512 pstrcat(buf
, buf_size
, " ");
6513 pstrcat(buf
, buf_size
, varstr
);
6518 /* verify type compatibility to store vtop in 'dt' type, and generate
6520 static void gen_assign_cast(CType
*dt
)
6522 CType
*st
, *type1
, *type2
, tmp_type1
, tmp_type2
;
6523 char buf1
[256], buf2
[256];
6526 st
= &vtop
->type
; /* source type */
6527 dbt
= dt
->t
& VT_BTYPE
;
6528 sbt
= st
->t
& VT_BTYPE
;
6529 if (dt
->t
& VT_CONSTANT
)
6530 warning("assignment of read-only location");
6533 /* special cases for pointers */
6534 /* '0' can also be a pointer */
6535 if (is_null_pointer(vtop
))
6537 /* accept implicit pointer to integer cast with warning */
6538 if (is_integer_btype(sbt
)) {
6539 warning("assignment makes pointer from integer without a cast");
6542 type1
= pointed_type(dt
);
6543 /* a function is implicitely a function pointer */
6544 if (sbt
== VT_FUNC
) {
6545 if ((type1
->t
& VT_BTYPE
) != VT_VOID
&&
6546 !is_compatible_types(pointed_type(dt
), st
))
6553 type2
= pointed_type(st
);
6554 if ((type1
->t
& VT_BTYPE
) == VT_VOID
||
6555 (type2
->t
& VT_BTYPE
) == VT_VOID
) {
6556 /* void * can match anything */
6558 /* exact type match, except for unsigned */
6561 tmp_type1
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
6562 tmp_type2
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
6563 if (!is_compatible_types(&tmp_type1
, &tmp_type2
))
6564 warning("assignment from incompatible pointer type");
6566 /* check const and volatile */
6567 if ((!(type1
->t
& VT_CONSTANT
) && (type2
->t
& VT_CONSTANT
)) ||
6568 (!(type1
->t
& VT_VOLATILE
) && (type2
->t
& VT_VOLATILE
)))
6569 warning("assignment discards qualifiers from pointer target type");
6575 if (sbt
== VT_PTR
|| sbt
== VT_FUNC
) {
6576 warning("assignment makes integer from pointer without a cast");
6578 /* XXX: more tests */
6583 tmp_type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6584 tmp_type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6585 if (!is_compatible_types(&tmp_type1
, &tmp_type2
)) {
6587 type_to_str(buf1
, sizeof(buf1
), st
, NULL
);
6588 type_to_str(buf2
, sizeof(buf2
), dt
, NULL
);
6589 error("cannot cast '%s' to '%s'", buf1
, buf2
);
6597 /* store vtop in lvalue pushed on stack */
6600 int sbt
, dbt
, ft
, r
, t
, size
, align
, bit_size
, bit_pos
, rc
, delayed_cast
;
6602 ft
= vtop
[-1].type
.t
;
6603 sbt
= vtop
->type
.t
& VT_BTYPE
;
6604 dbt
= ft
& VT_BTYPE
;
6605 if (((sbt
== VT_INT
|| sbt
== VT_SHORT
) && dbt
== VT_BYTE
) ||
6606 (sbt
== VT_INT
&& dbt
== VT_SHORT
)) {
6607 /* optimize char/short casts */
6608 delayed_cast
= VT_MUSTCAST
;
6609 vtop
->type
.t
= ft
& (VT_TYPE
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
)));
6610 /* XXX: factorize */
6611 if (ft
& VT_CONSTANT
)
6612 warning("assignment of read-only location");
6615 if (!(ft
& VT_BITFIELD
))
6616 gen_assign_cast(&vtop
[-1].type
);
6619 if (sbt
== VT_STRUCT
) {
6620 /* if structure, only generate pointer */
6621 /* structure assignment : generate memcpy */
6622 /* XXX: optimize if small size */
6623 if (!nocode_wanted
) {
6624 size
= type_size(&vtop
->type
, &align
);
6628 vpush_global_sym(&func_old_type
, TOK_memcpy8
);
6629 else if(!(align
& 3))
6630 vpush_global_sym(&func_old_type
, TOK_memcpy4
);
6633 vpush_global_sym(&func_old_type
, TOK_memcpy
);
6637 vtop
->type
.t
= VT_PTR
;
6641 vtop
->type
.t
= VT_PTR
;
6653 /* leave source on stack */
6654 } else if (ft
& VT_BITFIELD
) {
6655 /* bitfield store handling */
6656 bit_pos
= (ft
>> VT_STRUCT_SHIFT
) & 0x3f;
6657 bit_size
= (ft
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
6658 /* remove bit field info to avoid loops */
6659 vtop
[-1].type
.t
= ft
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
6661 /* duplicate source into other register */
6666 if((ft
& VT_BTYPE
) == VT_BOOL
) {
6667 gen_cast(&vtop
[-1].type
);
6668 vtop
[-1].type
.t
= (vtop
[-1].type
.t
& ~VT_BTYPE
) | (VT_BYTE
| VT_UNSIGNED
);
6671 /* duplicate destination */
6673 vtop
[-1] = vtop
[-2];
6675 /* mask and shift source */
6676 if((ft
& VT_BTYPE
) != VT_BOOL
) {
6677 if((ft
& VT_BTYPE
) == VT_LLONG
) {
6678 vpushll((1ULL << bit_size
) - 1ULL);
6680 vpushi((1 << bit_size
) - 1);
6686 /* load destination, mask and or with source */
6688 if((ft
& VT_BTYPE
) == VT_LLONG
) {
6689 vpushll(~(((1ULL << bit_size
) - 1ULL) << bit_pos
));
6691 vpushi(~(((1 << bit_size
) - 1) << bit_pos
));
6698 /* pop off shifted source from "duplicate source..." above */
6702 #ifdef CONFIG_TCC_BCHECK
6703 /* bound check case */
6704 if (vtop
[-1].r
& VT_MUSTBOUND
) {
6710 if (!nocode_wanted
) {
6714 #ifdef TCC_TARGET_X86_64
6715 if ((ft
& VT_BTYPE
) == VT_LDOUBLE
) {
6720 r
= gv(rc
); /* generate value */
6721 /* if lvalue was saved on stack, must read it */
6722 if ((vtop
[-1].r
& VT_VALMASK
) == VT_LLOCAL
) {
6724 t
= get_reg(RC_INT
);
6725 #ifdef TCC_TARGET_X86_64
6730 sv
.r
= VT_LOCAL
| VT_LVAL
;
6731 sv
.c
.ul
= vtop
[-1].c
.ul
;
6733 vtop
[-1].r
= t
| VT_LVAL
;
6736 #ifndef TCC_TARGET_X86_64
6737 /* two word case handling : store second register at word + 4 */
6738 if ((ft
& VT_BTYPE
) == VT_LLONG
) {
6740 /* convert to int to increment easily */
6741 vtop
->type
.t
= VT_INT
;
6747 /* XXX: it works because r2 is spilled last ! */
6748 store(vtop
->r2
, vtop
- 1);
6753 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
6754 vtop
->r
|= delayed_cast
;
6758 /* post defines POST/PRE add. c is the token ++ or -- */
6759 void inc(int post
, int c
)
6762 vdup(); /* save lvalue */
6764 gv_dup(); /* duplicate value */
6769 vpushi(c
- TOK_MID
);
6771 vstore(); /* store value */
6773 vpop(); /* if post op, return saved value */
6776 /* Parse GNUC __attribute__ extension. Currently, the following
6777 extensions are recognized:
6778 - aligned(n) : set data/function alignment.
6779 - packed : force data alignment to 1
6780 - section(x) : generate data/code in this section.
6781 - unused : currently ignored, but may be used someday.
6782 - regparm(n) : pass function parameters in registers (i386 only)
6784 static void parse_attribute(AttributeDef
*ad
)
6788 while (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
) {
6792 while (tok
!= ')') {
6793 if (tok
< TOK_IDENT
)
6794 expect("attribute name");
6802 expect("section name");
6803 ad
->section
= find_section(tcc_state
, (char *)tokc
.cstr
->data
);
6812 if (n
<= 0 || (n
& (n
- 1)) != 0)
6813 error("alignment must be a positive power of two");
6826 /* currently, no need to handle it because tcc does not
6827 track unused objects */
6831 /* currently, no need to handle it because tcc does not
6832 track unused objects */
6837 FUNC_CALL(ad
->func_attr
) = FUNC_CDECL
;
6842 FUNC_CALL(ad
->func_attr
) = FUNC_STDCALL
;
6844 #ifdef TCC_TARGET_I386
6854 FUNC_CALL(ad
->func_attr
) = FUNC_FASTCALL1
+ n
- 1;
6860 FUNC_CALL(ad
->func_attr
) = FUNC_FASTCALLW
;
6864 FUNC_EXPORT(ad
->func_attr
) = 1;
6867 if (tcc_state
->warn_unsupported
)
6868 warning("'%s' attribute ignored", get_tok_str(t
, NULL
));
6869 /* skip parameters */
6871 int parenthesis
= 0;
6875 else if (tok
== ')')
6878 } while (parenthesis
&& tok
!= -1);
6891 /* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
6892 static void struct_decl(CType
*type
, int u
)
6894 int a
, v
, size
, align
, maxalign
, c
, offset
;
6895 int bit_size
, bit_pos
, bsize
, bt
, lbit_pos
, prevbt
;
6896 Sym
*s
, *ss
, *ass
, **ps
;
6900 a
= tok
; /* save decl type */
6905 /* struct already defined ? return it */
6907 expect("struct/union/enum name");
6911 error("invalid type");
6918 /* we put an undefined size for struct/union */
6919 s
= sym_push(v
| SYM_STRUCT
, &type1
, 0, -1);
6920 s
->r
= 0; /* default alignment is zero as gcc */
6921 /* put struct/union/enum name in type */
6929 error("struct/union/enum already defined");
6930 /* cannot be empty */
6932 /* non empty enums are not allowed */
6933 if (a
== TOK_ENUM
) {
6937 expect("identifier");
6943 /* enum symbols have static storage */
6944 ss
= sym_push(v
, &int_type
, VT_CONST
, c
);
6945 ss
->type
.t
|= VT_STATIC
;
6950 /* NOTE: we accept a trailing comma */
6961 while (tok
!= '}') {
6962 parse_btype(&btype
, &ad
);
6968 type_decl(&type1
, &ad
, &v
, TYPE_DIRECT
| TYPE_ABSTRACT
);
6969 if (v
== 0 && (type1
.t
& VT_BTYPE
) != VT_STRUCT
)
6970 expect("identifier");
6971 if ((type1
.t
& VT_BTYPE
) == VT_FUNC
||
6972 (type1
.t
& (VT_TYPEDEF
| VT_STATIC
| VT_EXTERN
| VT_INLINE
)))
6973 error("invalid type for '%s'",
6974 get_tok_str(v
, NULL
));
6978 bit_size
= expr_const();
6979 /* XXX: handle v = 0 case for messages */
6981 error("negative width in bit-field '%s'",
6982 get_tok_str(v
, NULL
));
6983 if (v
&& bit_size
== 0)
6984 error("zero width for bit-field '%s'",
6985 get_tok_str(v
, NULL
));
6987 size
= type_size(&type1
, &align
);
6989 if (align
< ad
.aligned
)
6991 } else if (ad
.packed
) {
6993 } else if (*tcc_state
->pack_stack_ptr
) {
6994 if (align
> *tcc_state
->pack_stack_ptr
)
6995 align
= *tcc_state
->pack_stack_ptr
;
6998 if (bit_size
>= 0) {
6999 bt
= type1
.t
& VT_BTYPE
;
7006 error("bitfields must have scalar type");
7008 if (bit_size
> bsize
) {
7009 error("width of '%s' exceeds its type",
7010 get_tok_str(v
, NULL
));
7011 } else if (bit_size
== bsize
) {
7012 /* no need for bit fields */
7014 } else if (bit_size
== 0) {
7015 /* XXX: what to do if only padding in a
7017 /* zero size: means to pad */
7020 /* we do not have enough room ?
7021 did the type change?
7023 if ((bit_pos
+ bit_size
) > bsize
||
7024 bt
!= prevbt
|| a
== TOK_UNION
)
7027 /* XXX: handle LSB first */
7028 type1
.t
|= VT_BITFIELD
|
7029 (bit_pos
<< VT_STRUCT_SHIFT
) |
7030 (bit_size
<< (VT_STRUCT_SHIFT
+ 6));
7031 bit_pos
+= bit_size
;
7037 if (v
!= 0 || (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
7038 /* add new memory data only if starting
7040 if (lbit_pos
== 0) {
7041 if (a
== TOK_STRUCT
) {
7042 c
= (c
+ align
- 1) & -align
;
7051 if (align
> maxalign
)
7055 printf("add field %s offset=%d",
7056 get_tok_str(v
, NULL
), offset
);
7057 if (type1
.t
& VT_BITFIELD
) {
7058 printf(" pos=%d size=%d",
7059 (type1
.t
>> VT_STRUCT_SHIFT
) & 0x3f,
7060 (type1
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f);
7065 if (v
== 0 && (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
7067 while ((ass
= ass
->next
) != NULL
) {
7068 ss
= sym_push(ass
->v
, &ass
->type
, 0, offset
+ ass
->c
);
7073 ss
= sym_push(v
| SYM_FIELD
, &type1
, 0, offset
);
7077 if (tok
== ';' || tok
== TOK_EOF
)
7084 /* store size and alignment */
7085 s
->c
= (c
+ maxalign
- 1) & -maxalign
;
7091 /* return 0 if no type declaration. otherwise, return the basic type
7094 static int parse_btype(CType
*type
, AttributeDef
*ad
)
7096 int t
, u
, type_found
, typespec_found
, typedef_found
;
7100 memset(ad
, 0, sizeof(AttributeDef
));
7108 /* currently, we really ignore extension */
7118 if ((t
& VT_BTYPE
) != 0)
7119 error("too many basic types");
7135 if ((t
& VT_BTYPE
) == VT_DOUBLE
) {
7136 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
7137 } else if ((t
& VT_BTYPE
) == VT_LONG
) {
7138 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
7152 if ((t
& VT_BTYPE
) == VT_LONG
) {
7153 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
7160 struct_decl(&type1
, VT_ENUM
);
7163 type
->ref
= type1
.ref
;
7167 struct_decl(&type1
, VT_STRUCT
);
7170 /* type modifiers */
7223 /* GNUC attribute */
7224 case TOK_ATTRIBUTE1
:
7225 case TOK_ATTRIBUTE2
:
7226 parse_attribute(ad
);
7233 parse_expr_type(&type1
);
7236 if (typespec_found
|| typedef_found
)
7239 if (!s
|| !(s
->type
.t
& VT_TYPEDEF
))
7242 t
|= (s
->type
.t
& ~VT_TYPEDEF
);
7243 type
->ref
= s
->type
.ref
;
7251 if ((t
& (VT_SIGNED
|VT_UNSIGNED
)) == (VT_SIGNED
|VT_UNSIGNED
))
7252 error("signed and unsigned modifier");
7253 if (tcc_state
->char_is_unsigned
) {
7254 if ((t
& (VT_SIGNED
|VT_UNSIGNED
|VT_BTYPE
)) == VT_BYTE
)
7259 /* long is never used as type */
7260 if ((t
& VT_BTYPE
) == VT_LONG
)
7261 #ifndef TCC_TARGET_X86_64
7262 t
= (t
& ~VT_BTYPE
) | VT_INT
;
7264 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
7270 /* convert a function parameter type (array to pointer and function to
7271 function pointer) */
7272 static inline void convert_parameter_type(CType
*pt
)
7274 /* remove const and volatile qualifiers (XXX: const could be used
7275 to indicate a const function parameter */
7276 pt
->t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
7277 /* array must be transformed to pointer according to ANSI C */
7279 if ((pt
->t
& VT_BTYPE
) == VT_FUNC
) {
7284 static void post_type(CType
*type
, AttributeDef
*ad
)
7286 int n
, l
, t1
, arg_size
, align
;
7287 Sym
**plast
, *s
, *first
;
7292 /* function declaration */
7300 /* read param name and compute offset */
7301 if (l
!= FUNC_OLD
) {
7302 if (!parse_btype(&pt
, &ad1
)) {
7304 error("invalid type");
7311 if ((pt
.t
& VT_BTYPE
) == VT_VOID
&& tok
== ')')
7313 type_decl(&pt
, &ad1
, &n
, TYPE_DIRECT
| TYPE_ABSTRACT
);
7314 if ((pt
.t
& VT_BTYPE
) == VT_VOID
)
7315 error("parameter declared as void");
7316 arg_size
+= (type_size(&pt
, &align
) + 3) & ~3;
7321 expect("identifier");
7325 convert_parameter_type(&pt
);
7326 s
= sym_push(n
| SYM_FIELD
, &pt
, 0, 0);
7332 if (l
== FUNC_NEW
&& tok
== TOK_DOTS
) {
7339 /* if no parameters, then old type prototype */
7343 t1
= type
->t
& VT_STORAGE
;
7344 /* NOTE: const is ignored in returned type as it has a special
7345 meaning in gcc / C++ */
7346 type
->t
&= ~(VT_STORAGE
| VT_CONSTANT
);
7347 post_type(type
, ad
);
7348 /* we push a anonymous symbol which will contain the function prototype */
7349 FUNC_ARGS(ad
->func_attr
) = arg_size
;
7350 s
= sym_push(SYM_FIELD
, type
, ad
->func_attr
, l
);
7352 type
->t
= t1
| VT_FUNC
;
7354 } else if (tok
== '[') {
7355 /* array definition */
7357 if (tok
== TOK_RESTRICT1
)
7363 error("invalid array size");
7366 /* parse next post type */
7367 t1
= type
->t
& VT_STORAGE
;
7368 type
->t
&= ~VT_STORAGE
;
7369 post_type(type
, ad
);
7371 /* we push a anonymous symbol which will contain the array
7373 s
= sym_push(SYM_FIELD
, type
, 0, n
);
7374 type
->t
= t1
| VT_ARRAY
| VT_PTR
;
7379 /* Parse a type declaration (except basic type), and return the type
7380 in 'type'. 'td' is a bitmask indicating which kind of type decl is
7381 expected. 'type' should contain the basic type. 'ad' is the
7382 attribute definition of the basic type. It can be modified by
7385 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
)
7388 CType type1
, *type2
;
7391 while (tok
== '*') {
7399 qualifiers
|= VT_CONSTANT
;
7404 qualifiers
|= VT_VOLATILE
;
7412 type
->t
|= qualifiers
;
7415 /* XXX: clarify attribute handling */
7416 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
7417 parse_attribute(ad
);
7419 /* recursive type */
7420 /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
7421 type1
.t
= 0; /* XXX: same as int */
7424 /* XXX: this is not correct to modify 'ad' at this point, but
7425 the syntax is not clear */
7426 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
7427 parse_attribute(ad
);
7428 type_decl(&type1
, ad
, v
, td
);
7431 /* type identifier */
7432 if (tok
>= TOK_IDENT
&& (td
& TYPE_DIRECT
)) {
7436 if (!(td
& TYPE_ABSTRACT
))
7437 expect("identifier");
7441 post_type(type
, ad
);
7442 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
7443 parse_attribute(ad
);
7446 /* append type at the end of type1 */
7459 /* compute the lvalue VT_LVAL_xxx needed to match type t. */
7460 static int lvalue_type(int t
)
7465 if (bt
== VT_BYTE
|| bt
== VT_BOOL
)
7467 else if (bt
== VT_SHORT
)
7471 if (t
& VT_UNSIGNED
)
7472 r
|= VT_LVAL_UNSIGNED
;
7476 /* indirection with full error checking and bound check */
7477 static void indir(void)
7479 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
) {
7480 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FUNC
)
7484 if ((vtop
->r
& VT_LVAL
) && !nocode_wanted
)
7486 vtop
->type
= *pointed_type(&vtop
->type
);
7487 /* Arrays and functions are never lvalues */
7488 if (!(vtop
->type
.t
& VT_ARRAY
)
7489 && (vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
7490 vtop
->r
|= lvalue_type(vtop
->type
.t
);
7491 /* if bound checking, the referenced pointer must be checked */
7492 if (do_bounds_check
)
7493 vtop
->r
|= VT_MUSTBOUND
;
7497 /* pass a parameter to a function and do type checking and casting */
7498 static void gfunc_param_typed(Sym
*func
, Sym
*arg
)
7503 func_type
= func
->c
;
7504 if (func_type
== FUNC_OLD
||
7505 (func_type
== FUNC_ELLIPSIS
&& arg
== NULL
)) {
7506 /* default casting : only need to convert float to double */
7507 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
) {
7511 } else if (arg
== NULL
) {
7512 error("too many arguments to function");
7515 type
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
7516 gen_assign_cast(&type
);
7520 /* parse an expression of the form '(type)' or '(expr)' and return its
7522 static void parse_expr_type(CType
*type
)
7528 if (parse_btype(type
, &ad
)) {
7529 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
7536 static void parse_type(CType
*type
)
7541 if (!parse_btype(type
, &ad
)) {
7544 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
7547 static void vpush_tokc(int t
)
7551 vsetc(&type
, VT_CONST
, &tokc
);
7554 static void unary(void)
7556 int n
, t
, align
, size
, r
;
7561 /* XXX: GCC 2.95.3 does not generate a table although it should be
7575 vpush_tokc(VT_INT
| VT_UNSIGNED
);
7579 vpush_tokc(VT_LLONG
);
7583 vpush_tokc(VT_LLONG
| VT_UNSIGNED
);
7587 vpush_tokc(VT_FLOAT
);
7591 vpush_tokc(VT_DOUBLE
);
7595 vpush_tokc(VT_LDOUBLE
);
7598 case TOK___FUNCTION__
:
7600 goto tok_identifier
;
7606 /* special function name identifier */
7607 len
= strlen(funcname
) + 1;
7608 /* generate char[len] type */
7613 vpush_ref(&type
, data_section
, data_section
->data_offset
, len
);
7614 ptr
= section_ptr_add(data_section
, len
);
7615 memcpy(ptr
, funcname
, len
);
7620 #ifdef TCC_TARGET_PE
7621 t
= VT_SHORT
| VT_UNSIGNED
;
7627 /* string parsing */
7630 if (tcc_state
->warn_write_strings
)
7635 memset(&ad
, 0, sizeof(AttributeDef
));
7636 decl_initializer_alloc(&type
, &ad
, VT_CONST
, 2, 0, 0);
7641 if (parse_btype(&type
, &ad
)) {
7642 type_decl(&type
, &ad
, &n
, TYPE_ABSTRACT
);
7644 /* check ISOC99 compound literal */
7646 /* data is allocated locally by default */
7651 /* all except arrays are lvalues */
7652 if (!(type
.t
& VT_ARRAY
))
7653 r
|= lvalue_type(type
.t
);
7654 memset(&ad
, 0, sizeof(AttributeDef
));
7655 decl_initializer_alloc(&type
, &ad
, r
, 1, 0, 0);
7660 } else if (tok
== '{') {
7661 /* save all registers */
7663 /* statement expression : we do not accept break/continue
7664 inside as GCC does */
7665 block(NULL
, NULL
, NULL
, NULL
, 0, 1);
7680 /* functions names must be treated as function pointers,
7681 except for unary '&' and sizeof. Since we consider that
7682 functions are not lvalues, we only have to handle it
7683 there and in function calls. */
7684 /* arrays can also be used although they are not lvalues */
7685 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
&&
7686 !(vtop
->type
.t
& VT_ARRAY
) && !(vtop
->type
.t
& VT_LLOCAL
))
7688 mk_pointer(&vtop
->type
);
7694 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
7696 boolean
.t
= VT_BOOL
;
7698 vtop
->c
.i
= !vtop
->c
.i
;
7699 } else if ((vtop
->r
& VT_VALMASK
) == VT_CMP
)
7700 vtop
->c
.i
= vtop
->c
.i
^ 1;
7703 vseti(VT_JMP
, gtst(1, 0));
7714 /* in order to force cast, we add zero */
7716 if ((vtop
->type
.t
& VT_BTYPE
) == VT_PTR
)
7717 error("pointer not accepted for unary plus");
7727 parse_expr_type(&type
);
7731 size
= type_size(&type
, &align
);
7732 if (t
== TOK_SIZEOF
) {
7734 error("sizeof applied to an incomplete type");
7739 vtop
->type
.t
|= VT_UNSIGNED
;
7742 case TOK_builtin_types_compatible_p
:
7751 type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
7752 type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
7753 vpushi(is_compatible_types(&type1
, &type2
));
7756 case TOK_builtin_constant_p
:
7758 int saved_nocode_wanted
, res
;
7761 saved_nocode_wanted
= nocode_wanted
;
7764 res
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
7766 nocode_wanted
= saved_nocode_wanted
;
7771 case TOK_builtin_frame_address
:
7776 if (tok
!= TOK_CINT
) {
7777 error("__builtin_frame_address only takes integers");
7780 error("TCC only supports __builtin_frame_address(0)");
7786 vset(&type
, VT_LOCAL
, 0);
7789 #ifdef TCC_TARGET_X86_64
7790 case TOK_builtin_malloc
:
7792 char *p
= file
->buf_ptr
;
7793 file
->buf_ptr
= "malloc";
7796 goto tok_identifier
;
7798 case TOK_builtin_free
:
7800 char *p
= file
->buf_ptr
;
7801 file
->buf_ptr
= "free";
7804 goto tok_identifier
;
7822 goto tok_identifier
;
7824 /* allow to take the address of a label */
7825 if (tok
< TOK_UIDENT
)
7826 expect("label identifier");
7827 s
= label_find(tok
);
7829 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
7831 if (s
->r
== LABEL_DECLARED
)
7832 s
->r
= LABEL_FORWARD
;
7835 s
->type
.t
= VT_VOID
;
7836 mk_pointer(&s
->type
);
7837 s
->type
.t
|= VT_STATIC
;
7839 vset(&s
->type
, VT_CONST
| VT_SYM
, 0);
7848 expect("identifier");
7852 error("'%s' undeclared", get_tok_str(t
, NULL
));
7853 /* for simple function calls, we tolerate undeclared
7854 external reference to int() function */
7855 if (tcc_state
->warn_implicit_function_declaration
)
7856 warning("implicit declaration of function '%s'",
7857 get_tok_str(t
, NULL
));
7858 s
= external_global_sym(t
, &func_old_type
, 0);
7860 if ((s
->type
.t
& (VT_STATIC
| VT_INLINE
| VT_BTYPE
)) ==
7861 (VT_STATIC
| VT_INLINE
| VT_FUNC
)) {
7862 /* if referencing an inline function, then we generate a
7863 symbol to it if not already done. It will have the
7864 effect to generate code for it at the end of the
7865 compilation unit. Inline function as always
7866 generated in the text section. */
7868 put_extern_sym(s
, text_section
, 0, 0);
7869 r
= VT_SYM
| VT_CONST
;
7873 vset(&s
->type
, r
, s
->c
);
7874 /* if forward reference, we must point to s */
7875 if (vtop
->r
& VT_SYM
) {
7882 /* post operations */
7884 if (tok
== TOK_INC
|| tok
== TOK_DEC
) {
7887 } else if (tok
== '.' || tok
== TOK_ARROW
) {
7889 if (tok
== TOK_ARROW
)
7894 /* expect pointer on structure */
7895 if ((vtop
->type
.t
& VT_BTYPE
) != VT_STRUCT
)
7896 expect("struct or union");
7900 while ((s
= s
->next
) != NULL
) {
7905 error("field not found: %s", get_tok_str(tok
& ~SYM_FIELD
, NULL
));
7906 /* add field offset to pointer */
7907 vtop
->type
= char_pointer_type
; /* change type to 'char *' */
7910 /* change type to field type, and set to lvalue */
7911 vtop
->type
= s
->type
;
7912 /* an array is never an lvalue */
7913 if (!(vtop
->type
.t
& VT_ARRAY
)) {
7914 vtop
->r
|= lvalue_type(vtop
->type
.t
);
7915 /* if bound checking, the referenced pointer must be checked */
7916 if (do_bounds_check
)
7917 vtop
->r
|= VT_MUSTBOUND
;
7920 } else if (tok
== '[') {
7926 } else if (tok
== '(') {
7932 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
7933 /* pointer test (no array accepted) */
7934 if ((vtop
->type
.t
& (VT_BTYPE
| VT_ARRAY
)) == VT_PTR
) {
7935 vtop
->type
= *pointed_type(&vtop
->type
);
7936 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
)
7940 expect("function pointer");
7943 vtop
->r
&= ~VT_LVAL
; /* no lvalue */
7945 /* get return type */
7948 sa
= s
->next
; /* first parameter */
7951 /* compute first implicit argument if a structure is returned */
7952 if ((s
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
7953 /* get some space for the returned structure */
7954 size
= type_size(&s
->type
, &align
);
7955 loc
= (loc
- size
) & -align
;
7957 ret
.r
= VT_LOCAL
| VT_LVAL
;
7958 /* pass it as 'int' to avoid structure arg passing
7960 vseti(VT_LOCAL
, loc
);
7965 /* return in register */
7966 if (is_float(ret
.type
.t
)) {
7967 ret
.r
= reg_fret(ret
.type
.t
);
7969 if ((ret
.type
.t
& VT_BTYPE
) == VT_LLONG
)
7978 gfunc_param_typed(s
, sa
);
7988 error("too few arguments to function");
7990 if (!nocode_wanted
) {
7991 gfunc_call(nb_args
);
7993 vtop
-= (nb_args
+ 1);
7996 vsetc(&ret
.type
, ret
.r
, &ret
.c
);
8004 static void uneq(void)
8010 (tok
>= TOK_A_MOD
&& tok
<= TOK_A_DIV
) ||
8011 tok
== TOK_A_XOR
|| tok
== TOK_A_OR
||
8012 tok
== TOK_A_SHL
|| tok
== TOK_A_SAR
) {
8027 static void expr_prod(void)
8032 while (tok
== '*' || tok
== '/' || tok
== '%') {
8040 static void expr_sum(void)
8045 while (tok
== '+' || tok
== '-') {
8053 static void expr_shift(void)
8058 while (tok
== TOK_SHL
|| tok
== TOK_SAR
) {
8066 static void expr_cmp(void)
8071 while ((tok
>= TOK_ULE
&& tok
<= TOK_GT
) ||
8072 tok
== TOK_ULT
|| tok
== TOK_UGE
) {
8080 static void expr_cmpeq(void)
8085 while (tok
== TOK_EQ
|| tok
== TOK_NE
) {
8093 static void expr_and(void)
8096 while (tok
== '&') {
8103 static void expr_xor(void)
8106 while (tok
== '^') {
8113 static void expr_or(void)
8116 while (tok
== '|') {
8123 /* XXX: fix this mess */
8124 static void expr_land_const(void)
8127 while (tok
== TOK_LAND
) {
8134 /* XXX: fix this mess */
8135 static void expr_lor_const(void)
8138 while (tok
== TOK_LOR
) {
8145 /* only used if non constant */
8146 static void expr_land(void)
8151 if (tok
== TOK_LAND
) {
8156 if (tok
!= TOK_LAND
) {
8166 static void expr_lor(void)
8171 if (tok
== TOK_LOR
) {
8176 if (tok
!= TOK_LOR
) {
8186 /* XXX: better constant handling */
8187 static void expr_eq(void)
8189 int tt
, u
, r1
, r2
, rc
, t1
, t2
, bt1
, bt2
;
8191 CType type
, type1
, type2
;
8198 boolean
.t
= VT_BOOL
;
8204 if (tok
!= ':' || !gnu_ext
) {
8219 if (vtop
!= vstack
) {
8220 /* needed to avoid having different registers saved in
8222 if (is_float(vtop
->type
.t
)) {
8224 #ifdef TCC_TARGET_X86_64
8225 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LDOUBLE
) {
8235 if (tok
== ':' && gnu_ext
) {
8243 sv
= *vtop
; /* save value to handle it later */
8244 vtop
--; /* no vpop so that FP stack is not flushed */
8252 bt1
= t1
& VT_BTYPE
;
8254 bt2
= t2
& VT_BTYPE
;
8255 /* cast operands to correct type according to ISOC rules */
8256 if (is_float(bt1
) || is_float(bt2
)) {
8257 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
8258 type
.t
= VT_LDOUBLE
;
8259 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
8264 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
8265 /* cast to biggest op */
8267 /* convert to unsigned if it does not fit in a long long */
8268 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
8269 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
8270 type
.t
|= VT_UNSIGNED
;
8271 } else if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
8272 /* XXX: test pointer compatibility */
8274 } else if (bt1
== VT_FUNC
|| bt2
== VT_FUNC
) {
8275 /* XXX: test function pointer compatibility */
8277 } else if (bt1
== VT_STRUCT
|| bt2
== VT_STRUCT
) {
8278 /* XXX: test structure compatibility */
8280 } else if (bt1
== VT_VOID
|| bt2
== VT_VOID
) {
8281 /* NOTE: as an extension, we accept void on only one side */
8284 /* integer operations */
8286 /* convert to unsigned if it does not fit in an integer */
8287 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
8288 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
8289 type
.t
|= VT_UNSIGNED
;
8292 /* now we convert second operand */
8294 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
8297 if (is_float(type
.t
)) {
8299 #ifdef TCC_TARGET_X86_64
8300 if ((type
.t
& VT_BTYPE
) == VT_LDOUBLE
) {
8304 } else if ((type
.t
& VT_BTYPE
) == VT_LLONG
) {
8305 /* for long longs, we use fixed registers to avoid having
8306 to handle a complicated move */
8311 /* this is horrible, but we must also convert first
8315 /* put again first value and cast it */
8318 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
8328 static void gexpr(void)
8339 /* parse an expression and return its type without any side effect. */
8340 static void expr_type(CType
*type
)
8342 int saved_nocode_wanted
;
8344 saved_nocode_wanted
= nocode_wanted
;
8349 nocode_wanted
= saved_nocode_wanted
;
8352 /* parse a unary expression and return its type without any side
8354 static void unary_type(CType
*type
)
8366 /* parse a constant expression and return value in vtop. */
8367 static void expr_const1(void)
8376 /* parse an integer constant and return its value. */
8377 static int expr_const(void)
8381 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
8382 expect("constant expression");
8388 /* return the label token if current token is a label, otherwise
8390 static int is_label(void)
8394 /* fast test first */
8395 if (tok
< TOK_UIDENT
)
8397 /* no need to save tokc because tok is an identifier */
8404 unget_tok(last_tok
);
8409 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
,
8410 int case_reg
, int is_expr
)
8415 /* generate line number info */
8417 (last_line_num
!= file
->line_num
|| last_ind
!= ind
)) {
8418 put_stabn(N_SLINE
, 0, file
->line_num
, ind
- func_ind
);
8420 last_line_num
= file
->line_num
;
8424 /* default return value is (void) */
8426 vtop
->type
.t
= VT_VOID
;
8429 if (tok
== TOK_IF
) {
8436 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
8438 if (c
== TOK_ELSE
) {
8442 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
8443 gsym(d
); /* patch else jmp */
8446 } else if (tok
== TOK_WHILE
) {
8454 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
8458 } else if (tok
== '{') {
8462 /* record local declaration stack position */
8464 llabel
= local_label_stack
;
8465 /* handle local labels declarations */
8466 if (tok
== TOK_LABEL
) {
8469 if (tok
< TOK_UIDENT
)
8470 expect("label identifier");
8471 label_push(&local_label_stack
, tok
, LABEL_DECLARED
);
8481 while (tok
!= '}') {
8486 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
8489 /* pop locally defined labels */
8490 label_pop(&local_label_stack
, llabel
);
8491 /* pop locally defined symbols */
8493 /* XXX: this solution makes only valgrind happy...
8494 triggered by gcc.c-torture/execute/20000917-1.c */
8496 switch(vtop
->type
.t
& VT_BTYPE
) {
8501 for(p
=vtop
->type
.ref
;p
;p
=p
->prev
)
8503 error("unsupported expression type");
8506 sym_pop(&local_stack
, s
);
8508 } else if (tok
== TOK_RETURN
) {
8512 gen_assign_cast(&func_vt
);
8513 if ((func_vt
.t
& VT_BTYPE
) == VT_STRUCT
) {
8515 /* if returning structure, must copy it to implicit
8516 first pointer arg location */
8519 size
= type_size(&func_vt
,&align
);
8522 if((vtop
->r
!= (VT_LOCAL
| VT_LVAL
) || (vtop
->c
.i
& 3))
8526 loc
= (loc
- size
) & -4;
8529 vset(&type
, VT_LOCAL
| VT_LVAL
, addr
);
8532 vset(&int_type
, VT_LOCAL
| VT_LVAL
, addr
);
8534 vtop
->type
= int_type
;
8540 vset(&type
, VT_LOCAL
| VT_LVAL
, func_vc
);
8543 /* copy structure value to pointer */
8548 } else if (is_float(func_vt
.t
)) {
8549 gv(rc_fret(func_vt
.t
));
8553 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
8556 rsym
= gjmp(rsym
); /* jmp */
8557 } else if (tok
== TOK_BREAK
) {
8560 error("cannot break");
8561 *bsym
= gjmp(*bsym
);
8564 } else if (tok
== TOK_CONTINUE
) {
8567 error("cannot continue");
8568 *csym
= gjmp(*csym
);
8571 } else if (tok
== TOK_FOR
) {
8598 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
8603 if (tok
== TOK_DO
) {
8608 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
8619 if (tok
== TOK_SWITCH
) {
8623 /* XXX: other types than integer */
8624 case_reg
= gv(RC_INT
);
8628 b
= gjmp(0); /* jump to first case */
8630 block(&a
, csym
, &b
, &c
, case_reg
, 0);
8631 /* if no default, jmp after switch */
8639 if (tok
== TOK_CASE
) {
8646 if (gnu_ext
&& tok
== TOK_DOTS
) {
8650 warning("empty case range");
8652 /* since a case is like a label, we must skip it with a jmp */
8659 *case_sym
= gtst(1, 0);
8662 *case_sym
= gtst(1, 0);
8666 *case_sym
= gtst(1, *case_sym
);
8671 goto block_after_label
;
8673 if (tok
== TOK_DEFAULT
) {
8679 error("too many 'default'");
8682 goto block_after_label
;
8684 if (tok
== TOK_GOTO
) {
8686 if (tok
== '*' && gnu_ext
) {
8690 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
)
8693 } else if (tok
>= TOK_UIDENT
) {
8694 s
= label_find(tok
);
8695 /* put forward definition if needed */
8697 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
8699 if (s
->r
== LABEL_DECLARED
)
8700 s
->r
= LABEL_FORWARD
;
8702 /* label already defined */
8703 if (s
->r
& LABEL_FORWARD
)
8704 s
->next
= (void *)gjmp((long)s
->next
);
8706 gjmp_addr((long)s
->next
);
8709 expect("label identifier");
8712 } else if (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
) {
8720 if (s
->r
== LABEL_DEFINED
)
8721 error("duplicate label '%s'", get_tok_str(s
->v
, NULL
));
8722 gsym((long)s
->next
);
8723 s
->r
= LABEL_DEFINED
;
8725 s
= label_push(&global_label_stack
, b
, LABEL_DEFINED
);
8727 s
->next
= (void *)ind
;
8728 /* we accept this, but it is a mistake */
8731 warning("deprecated use of label at end of compound statement");
8735 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
8738 /* expression case */
8753 /* t is the array or struct type. c is the array or struct
8754 address. cur_index/cur_field is the pointer to the current
8755 value. 'size_only' is true if only size info is needed (only used
8757 static void decl_designator(CType
*type
, Section
*sec
, unsigned long c
,
8758 int *cur_index
, Sym
**cur_field
,
8762 int notfirst
, index
, index_last
, align
, l
, nb_elems
, elem_size
;
8768 if (gnu_ext
&& (l
= is_label()) != 0)
8770 while (tok
== '[' || tok
== '.') {
8772 if (!(type
->t
& VT_ARRAY
))
8773 expect("array type");
8776 index
= expr_const();
8777 if (index
< 0 || (s
->c
>= 0 && index
>= s
->c
))
8778 expect("invalid index");
8779 if (tok
== TOK_DOTS
&& gnu_ext
) {
8781 index_last
= expr_const();
8782 if (index_last
< 0 ||
8783 (s
->c
>= 0 && index_last
>= s
->c
) ||
8785 expect("invalid index");
8791 *cur_index
= index_last
;
8792 type
= pointed_type(type
);
8793 elem_size
= type_size(type
, &align
);
8794 c
+= index
* elem_size
;
8795 /* NOTE: we only support ranges for last designator */
8796 nb_elems
= index_last
- index
+ 1;
8797 if (nb_elems
!= 1) {
8806 if ((type
->t
& VT_BTYPE
) != VT_STRUCT
)
8807 expect("struct/union type");
8820 /* XXX: fix this mess by using explicit storage field */
8822 type1
.t
|= (type
->t
& ~VT_TYPE
);
8836 if (type
->t
& VT_ARRAY
) {
8838 type
= pointed_type(type
);
8839 c
+= index
* type_size(type
, &align
);
8843 error("too many field init");
8844 /* XXX: fix this mess by using explicit storage field */
8846 type1
.t
|= (type
->t
& ~VT_TYPE
);
8851 decl_initializer(type
, sec
, c
, 0, size_only
);
8853 /* XXX: make it more general */
8854 if (!size_only
&& nb_elems
> 1) {
8855 unsigned long c_end
;
8860 error("range init not supported yet for dynamic storage");
8861 c_end
= c
+ nb_elems
* elem_size
;
8862 if (c_end
> sec
->data_allocated
)
8863 section_realloc(sec
, c_end
);
8864 src
= sec
->data
+ c
;
8866 for(i
= 1; i
< nb_elems
; i
++) {
8868 memcpy(dst
, src
, elem_size
);
8874 #define EXPR_CONST 1
8877 /* store a value or an expression directly in global data or in local array */
8878 static void init_putv(CType
*type
, Section
*sec
, unsigned long c
,
8879 int v
, int expr_type
)
8881 int saved_global_expr
, bt
, bit_pos
, bit_size
;
8883 unsigned long long bit_mask
;
8891 /* compound literals must be allocated globally in this case */
8892 saved_global_expr
= global_expr
;
8895 global_expr
= saved_global_expr
;
8896 /* NOTE: symbols are accepted */
8897 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) != VT_CONST
)
8898 error("initializer element is not constant");
8906 dtype
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
8909 /* XXX: not portable */
8910 /* XXX: generate error if incorrect relocation */
8911 gen_assign_cast(&dtype
);
8912 bt
= type
->t
& VT_BTYPE
;
8913 /* we'll write at most 12 bytes */
8914 if (c
+ 12 > sec
->data_allocated
) {
8915 section_realloc(sec
, c
+ 12);
8917 ptr
= sec
->data
+ c
;
8918 /* XXX: make code faster ? */
8919 if (!(type
->t
& VT_BITFIELD
)) {
8924 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
8925 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
8926 bit_mask
= (1LL << bit_size
) - 1;
8928 if ((vtop
->r
& VT_SYM
) &&
8934 (bt
== VT_INT
&& bit_size
!= 32)))
8935 error("initializer element is not computable at load time");
8938 vtop
->c
.i
= (vtop
->c
.i
!= 0);
8940 *(char *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
8943 *(short *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
8946 *(double *)ptr
= vtop
->c
.d
;
8949 *(long double *)ptr
= vtop
->c
.ld
;
8952 *(long long *)ptr
|= (vtop
->c
.ll
& bit_mask
) << bit_pos
;
8955 if (vtop
->r
& VT_SYM
) {
8956 greloc(sec
, vtop
->sym
, c
, R_DATA_32
);
8958 *(int *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
8963 vset(&dtype
, VT_LOCAL
|VT_LVAL
, c
);
8970 /* put zeros for variable based init */
8971 static void init_putz(CType
*t
, Section
*sec
, unsigned long c
, int size
)
8974 /* nothing to do because globals are already set to zero */
8976 vpush_global_sym(&func_old_type
, TOK_memset
);
8984 /* 't' contains the type and storage info. 'c' is the offset of the
8985 object in section 'sec'. If 'sec' is NULL, it means stack based
8986 allocation. 'first' is true if array '{' must be read (multi
8987 dimension implicit array init handling). 'size_only' is true if
8988 size only evaluation is wanted (only for arrays). */
8989 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
8990 int first
, int size_only
)
8992 int index
, array_length
, n
, no_oblock
, nb
, parlevel
, i
;
8993 int size1
, align1
, expr_type
;
8997 if (type
->t
& VT_ARRAY
) {
9001 t1
= pointed_type(type
);
9002 size1
= type_size(t1
, &align1
);
9005 if ((first
&& tok
!= TOK_LSTR
&& tok
!= TOK_STR
) ||
9011 /* only parse strings here if correct type (otherwise: handle
9012 them as ((w)char *) expressions */
9013 if ((tok
== TOK_LSTR
&&
9014 #ifdef TCC_TARGET_PE
9015 (t1
->t
& VT_BTYPE
) == VT_SHORT
&& (t1
->t
& VT_UNSIGNED
)
9017 (t1
->t
& VT_BTYPE
) == VT_INT
9019 ) || (tok
== TOK_STR
&& (t1
->t
& VT_BTYPE
) == VT_BYTE
)) {
9020 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
9025 /* compute maximum number of chars wanted */
9027 cstr_len
= cstr
->size
;
9029 cstr_len
= cstr
->size
/ sizeof(nwchar_t
);
9032 if (n
>= 0 && nb
> (n
- array_length
))
9033 nb
= n
- array_length
;
9036 warning("initializer-string for array is too long");
9037 /* in order to go faster for common case (char
9038 string in global variable, we handle it
9040 if (sec
&& tok
== TOK_STR
&& size1
== 1) {
9041 memcpy(sec
->data
+ c
+ array_length
, cstr
->data
, nb
);
9045 ch
= ((unsigned char *)cstr
->data
)[i
];
9047 ch
= ((nwchar_t
*)cstr
->data
)[i
];
9048 init_putv(t1
, sec
, c
+ (array_length
+ i
) * size1
,
9056 /* only add trailing zero if enough storage (no
9057 warning in this case since it is standard) */
9058 if (n
< 0 || array_length
< n
) {
9060 init_putv(t1
, sec
, c
+ (array_length
* size1
), 0, EXPR_VAL
);
9066 while (tok
!= '}') {
9067 decl_designator(type
, sec
, c
, &index
, NULL
, size_only
);
9068 if (n
>= 0 && index
>= n
)
9069 error("index too large");
9070 /* must put zero in holes (note that doing it that way
9071 ensures that it even works with designators) */
9072 if (!size_only
&& array_length
< index
) {
9073 init_putz(t1
, sec
, c
+ array_length
* size1
,
9074 (index
- array_length
) * size1
);
9077 if (index
> array_length
)
9078 array_length
= index
;
9079 /* special test for multi dimensional arrays (may not
9080 be strictly correct if designators are used at the
9082 if (index
>= n
&& no_oblock
)
9091 /* put zeros at the end */
9092 if (!size_only
&& n
>= 0 && array_length
< n
) {
9093 init_putz(t1
, sec
, c
+ array_length
* size1
,
9094 (n
- array_length
) * size1
);
9096 /* patch type size if needed */
9098 s
->c
= array_length
;
9099 } else if ((type
->t
& VT_BTYPE
) == VT_STRUCT
&&
9100 (sec
|| !first
|| tok
== '{')) {
9103 /* NOTE: the previous test is a specific case for automatic
9104 struct/union init */
9105 /* XXX: union needs only one init */
9107 /* XXX: this test is incorrect for local initializers
9108 beginning with ( without {. It would be much more difficult
9109 to do it correctly (ideally, the expression parser should
9110 be used in all cases) */
9116 while (tok
== '(') {
9120 if (!parse_btype(&type1
, &ad1
))
9122 type_decl(&type1
, &ad1
, &n
, TYPE_ABSTRACT
);
9124 if (!is_assignable_types(type
, &type1
))
9125 error("invalid type for cast");
9130 if (first
|| tok
== '{') {
9139 while (tok
!= '}') {
9140 decl_designator(type
, sec
, c
, NULL
, &f
, size_only
);
9142 if (!size_only
&& array_length
< index
) {
9143 init_putz(type
, sec
, c
+ array_length
,
9144 index
- array_length
);
9146 index
= index
+ type_size(&f
->type
, &align1
);
9147 if (index
> array_length
)
9148 array_length
= index
;
9150 if (no_oblock
&& f
== NULL
)
9156 /* put zeros at the end */
9157 if (!size_only
&& array_length
< n
) {
9158 init_putz(type
, sec
, c
+ array_length
,
9167 } else if (tok
== '{') {
9169 decl_initializer(type
, sec
, c
, first
, size_only
);
9171 } else if (size_only
) {
9172 /* just skip expression */
9174 while ((parlevel
> 0 || (tok
!= '}' && tok
!= ',')) &&
9178 else if (tok
== ')')
9183 /* currently, we always use constant expression for globals
9184 (may change for scripting case) */
9185 expr_type
= EXPR_CONST
;
9187 expr_type
= EXPR_ANY
;
9188 init_putv(type
, sec
, c
, 0, expr_type
);
9192 /* parse an initializer for type 't' if 'has_init' is non zero, and
9193 allocate space in local or global data space ('r' is either
9194 VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
9195 variable 'v' of scope 'scope' is declared before initializers are
9196 parsed. If 'v' is zero, then a reference to the new object is put
9197 in the value stack. If 'has_init' is 2, a special parsing is done
9198 to handle string constants. */
9199 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
9200 int has_init
, int v
, int scope
)
9202 int size
, align
, addr
, data_offset
;
9204 ParseState saved_parse_state
;
9205 TokenString init_str
;
9208 size
= type_size(type
, &align
);
9209 /* If unknown size, we must evaluate it before
9210 evaluating initializers because
9211 initializers can generate global data too
9212 (e.g. string pointers or ISOC99 compound
9213 literals). It also simplifies local
9214 initializers handling */
9215 tok_str_new(&init_str
);
9218 error("unknown type size");
9219 /* get all init string */
9220 if (has_init
== 2) {
9221 /* only get strings */
9222 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
9223 tok_str_add_tok(&init_str
);
9228 while (level
> 0 || (tok
!= ',' && tok
!= ';')) {
9230 error("unexpected end of file in initializer");
9231 tok_str_add_tok(&init_str
);
9234 else if (tok
== '}') {
9244 tok_str_add(&init_str
, -1);
9245 tok_str_add(&init_str
, 0);
9248 save_parse_state(&saved_parse_state
);
9250 macro_ptr
= init_str
.str
;
9252 decl_initializer(type
, NULL
, 0, 1, 1);
9253 /* prepare second initializer parsing */
9254 macro_ptr
= init_str
.str
;
9257 /* if still unknown size, error */
9258 size
= type_size(type
, &align
);
9260 error("unknown type size");
9262 /* take into account specified alignment if bigger */
9264 if (ad
->aligned
> align
)
9265 align
= ad
->aligned
;
9266 } else if (ad
->packed
) {
9269 if ((r
& VT_VALMASK
) == VT_LOCAL
) {
9271 if (do_bounds_check
&& (type
->t
& VT_ARRAY
))
9273 loc
= (loc
- size
) & -align
;
9275 /* handles bounds */
9276 /* XXX: currently, since we do only one pass, we cannot track
9277 '&' operators, so we add only arrays */
9278 if (do_bounds_check
&& (type
->t
& VT_ARRAY
)) {
9279 unsigned long *bounds_ptr
;
9280 /* add padding between regions */
9282 /* then add local bound info */
9283 bounds_ptr
= section_ptr_add(lbounds_section
, 2 * sizeof(unsigned long));
9284 bounds_ptr
[0] = addr
;
9285 bounds_ptr
[1] = size
;
9288 /* local variable */
9289 sym_push(v
, type
, r
, addr
);
9291 /* push local reference */
9292 vset(type
, r
, addr
);
9298 if (v
&& scope
== VT_CONST
) {
9299 /* see if the symbol was already defined */
9302 if (!is_compatible_types(&sym
->type
, type
))
9303 error("incompatible types for redefinition of '%s'",
9304 get_tok_str(v
, NULL
));
9305 if (sym
->type
.t
& VT_EXTERN
) {
9306 /* if the variable is extern, it was not allocated */
9307 sym
->type
.t
&= ~VT_EXTERN
;
9308 /* set array size if it was ommited in extern
9310 if ((sym
->type
.t
& VT_ARRAY
) &&
9311 sym
->type
.ref
->c
< 0 &&
9313 sym
->type
.ref
->c
= type
->ref
->c
;
9315 /* we accept several definitions of the same
9316 global variable. this is tricky, because we
9317 must play with the SHN_COMMON type of the symbol */
9318 /* XXX: should check if the variable was already
9319 initialized. It is incorrect to initialized it
9321 /* no init data, we won't add more to the symbol */
9328 /* allocate symbol in corresponding section */
9333 else if (tcc_state
->nocommon
)
9337 data_offset
= sec
->data_offset
;
9338 data_offset
= (data_offset
+ align
- 1) & -align
;
9340 /* very important to increment global pointer at this time
9341 because initializers themselves can create new initializers */
9342 data_offset
+= size
;
9343 /* add padding if bound check */
9344 if (do_bounds_check
)
9346 sec
->data_offset
= data_offset
;
9347 /* allocate section space to put the data */
9348 if (sec
->sh_type
!= SHT_NOBITS
&&
9349 data_offset
> sec
->data_allocated
)
9350 section_realloc(sec
, data_offset
);
9351 /* align section if needed */
9352 if (align
> sec
->sh_addralign
)
9353 sec
->sh_addralign
= align
;
9355 addr
= 0; /* avoid warning */
9359 if (scope
!= VT_CONST
|| !sym
) {
9360 sym
= sym_push(v
, type
, r
| VT_SYM
, 0);
9362 /* update symbol definition */
9364 put_extern_sym(sym
, sec
, addr
, size
);
9367 /* put a common area */
9368 put_extern_sym(sym
, NULL
, align
, size
);
9369 /* XXX: find a nicer way */
9370 esym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
];
9371 esym
->st_shndx
= SHN_COMMON
;
9376 /* push global reference */
9377 sym
= get_sym_ref(type
, sec
, addr
, size
);
9379 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
9383 /* handles bounds now because the symbol must be defined
9384 before for the relocation */
9385 if (do_bounds_check
) {
9386 unsigned long *bounds_ptr
;
9388 greloc(bounds_section
, sym
, bounds_section
->data_offset
, R_DATA_32
);
9389 /* then add global bound info */
9390 bounds_ptr
= section_ptr_add(bounds_section
, 2 * sizeof(long));
9391 bounds_ptr
[0] = 0; /* relocated */
9392 bounds_ptr
[1] = size
;
9396 decl_initializer(type
, sec
, addr
, 1, 0);
9397 /* restore parse state if needed */
9399 tok_str_free(init_str
.str
);
9400 restore_parse_state(&saved_parse_state
);
9406 void put_func_debug(Sym
*sym
)
9411 /* XXX: we put here a dummy type */
9412 snprintf(buf
, sizeof(buf
), "%s:%c1",
9413 funcname
, sym
->type
.t
& VT_STATIC
? 'f' : 'F');
9414 put_stabs_r(buf
, N_FUN
, 0, file
->line_num
, 0,
9415 cur_text_section
, sym
->c
);
9416 /* //gr gdb wants a line at the function */
9417 put_stabn(N_SLINE
, 0, file
->line_num
, 0);
9422 /* parse an old style function declaration list */
9423 /* XXX: check multiple parameter */
9424 static void func_decl_list(Sym
*func_sym
)
9431 /* parse each declaration */
9432 while (tok
!= '{' && tok
!= ';' && tok
!= ',' && tok
!= TOK_EOF
) {
9433 if (!parse_btype(&btype
, &ad
))
9434 expect("declaration list");
9435 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
9436 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
9438 /* we accept no variable after */
9442 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
9443 /* find parameter in function parameter list */
9446 if ((s
->v
& ~SYM_FIELD
) == v
)
9450 error("declaration for parameter '%s' but no such parameter",
9451 get_tok_str(v
, NULL
));
9453 /* check that no storage specifier except 'register' was given */
9454 if (type
.t
& VT_STORAGE
)
9455 error("storage class specified for '%s'", get_tok_str(v
, NULL
));
9456 convert_parameter_type(&type
);
9457 /* we can add the type (NOTE: it could be local to the function) */
9459 /* accept other parameters */
9470 /* parse a function defined by symbol 'sym' and generate its code in
9471 'cur_text_section' */
9472 static void gen_function(Sym
*sym
)
9474 int saved_nocode_wanted
= nocode_wanted
;
9476 ind
= cur_text_section
->data_offset
;
9477 /* NOTE: we patch the symbol size later */
9478 put_extern_sym(sym
, cur_text_section
, ind
, 0);
9479 funcname
= get_tok_str(sym
->v
, NULL
);
9481 /* put debug symbol */
9483 put_func_debug(sym
);
9484 /* push a dummy symbol to enable local sym storage */
9485 sym_push2(&local_stack
, SYM_FIELD
, 0, 0);
9486 gfunc_prolog(&sym
->type
);
9488 block(NULL
, NULL
, NULL
, NULL
, 0, 0);
9491 cur_text_section
->data_offset
= ind
;
9492 label_pop(&global_label_stack
, NULL
);
9493 sym_pop(&local_stack
, NULL
); /* reset local stack */
9494 /* end of function */
9495 /* patch symbol size */
9496 ((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
].st_size
=
9499 put_stabn(N_FUN
, 0, 0, ind
- func_ind
);
9501 /* It's better to crash than to generate wrong code */
9502 cur_text_section
= NULL
;
9503 funcname
= ""; /* for safety */
9504 func_vt
.t
= VT_VOID
; /* for safety */
9505 ind
= 0; /* for safety */
9506 nocode_wanted
= saved_nocode_wanted
;
9509 static void gen_inline_functions(void)
9513 int *str
, inline_generated
;
9515 /* iterate while inline function are referenced */
9517 inline_generated
= 0;
9518 for(sym
= global_stack
; sym
!= NULL
; sym
= sym
->prev
) {
9520 if (((type
->t
& VT_BTYPE
) == VT_FUNC
) &&
9521 (type
->t
& (VT_STATIC
| VT_INLINE
)) ==
9522 (VT_STATIC
| VT_INLINE
) &&
9524 /* the function was used: generate its code and
9525 convert it to a normal function */
9526 str
= INLINE_DEF(sym
->r
);
9527 sym
->r
= VT_SYM
| VT_CONST
;
9528 sym
->type
.t
&= ~VT_INLINE
;
9532 cur_text_section
= text_section
;
9534 macro_ptr
= NULL
; /* fail safe */
9537 inline_generated
= 1;
9540 if (!inline_generated
)
9544 /* free all remaining inline function tokens */
9545 for(sym
= global_stack
; sym
!= NULL
; sym
= sym
->prev
) {
9547 if (((type
->t
& VT_BTYPE
) == VT_FUNC
) &&
9548 (type
->t
& (VT_STATIC
| VT_INLINE
)) ==
9549 (VT_STATIC
| VT_INLINE
)) {
9550 //gr printf("sym %d %s\n", sym->r, get_tok_str(sym->v, NULL));
9551 if (sym
->r
== (VT_SYM
| VT_CONST
)) //gr beware!
9553 str
= INLINE_DEF(sym
->r
);
9555 sym
->r
= 0; /* fail safe */
9560 /* 'l' is VT_LOCAL or VT_CONST to define default storage type */
9561 static void decl(int l
)
9569 if (!parse_btype(&btype
, &ad
)) {
9570 /* skip redundant ';' */
9571 /* XXX: find more elegant solution */
9576 if (l
== VT_CONST
&&
9577 (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
)) {
9578 /* global asm block */
9582 /* special test for old K&R protos without explicit int
9583 type. Only accepted when defining global data */
9584 if (l
== VT_LOCAL
|| tok
< TOK_DEFINE
)
9588 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
9589 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
9591 /* we accept no variable after */
9595 while (1) { /* iterate thru each declaration */
9597 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
9601 type_to_str(buf
, sizeof(buf
), t
, get_tok_str(v
, NULL
));
9602 printf("type = '%s'\n", buf
);
9605 if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
9606 /* if old style function prototype, we accept a
9609 if (sym
->c
== FUNC_OLD
)
9610 func_decl_list(sym
);
9615 error("cannot use local functions");
9616 if ((type
.t
& VT_BTYPE
) != VT_FUNC
)
9617 expect("function definition");
9619 /* reject abstract declarators in function definition */
9621 while ((sym
= sym
->next
) != NULL
)
9622 if (!(sym
->v
& ~SYM_FIELD
))
9623 expect("identifier");
9625 /* XXX: cannot do better now: convert extern line to static inline */
9626 if ((type
.t
& (VT_EXTERN
| VT_INLINE
)) == (VT_EXTERN
| VT_INLINE
))
9627 type
.t
= (type
.t
& ~VT_EXTERN
) | VT_STATIC
;
9631 if ((sym
->type
.t
& VT_BTYPE
) != VT_FUNC
)
9633 /* specific case: if not func_call defined, we put
9634 the one of the prototype */
9635 /* XXX: should have default value */
9636 r
= sym
->type
.ref
->r
;
9637 if (FUNC_CALL(r
) != FUNC_CDECL
9638 && FUNC_CALL(type
.ref
->r
) == FUNC_CDECL
)
9639 FUNC_CALL(type
.ref
->r
) = FUNC_CALL(r
);
9641 FUNC_EXPORT(type
.ref
->r
) = 1;
9643 if (!is_compatible_types(&sym
->type
, &type
)) {
9645 error("incompatible types for redefinition of '%s'",
9646 get_tok_str(v
, NULL
));
9648 /* if symbol is already defined, then put complete type */
9651 /* put function symbol */
9652 sym
= global_identifier_push(v
, type
.t
, 0);
9653 sym
->type
.ref
= type
.ref
;
9656 /* static inline functions are just recorded as a kind
9657 of macro. Their code will be emitted at the end of
9658 the compilation unit only if they are used */
9659 if ((type
.t
& (VT_INLINE
| VT_STATIC
)) ==
9660 (VT_INLINE
| VT_STATIC
)) {
9661 TokenString func_str
;
9664 tok_str_new(&func_str
);
9670 error("unexpected end of file");
9671 tok_str_add_tok(&func_str
);
9676 } else if (t
== '}') {
9678 if (block_level
== 0)
9682 tok_str_add(&func_str
, -1);
9683 tok_str_add(&func_str
, 0);
9684 INLINE_DEF(sym
->r
) = func_str
.str
;
9686 /* compute text section */
9687 cur_text_section
= ad
.section
;
9688 if (!cur_text_section
)
9689 cur_text_section
= text_section
;
9690 sym
->r
= VT_SYM
| VT_CONST
;
9695 if (btype
.t
& VT_TYPEDEF
) {
9696 /* save typedefed type */
9697 /* XXX: test storage specifiers ? */
9698 sym
= sym_push(v
, &type
, 0, 0);
9699 sym
->type
.t
|= VT_TYPEDEF
;
9700 } else if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
9701 /* external function definition */
9702 /* specific case for func_call attribute */
9704 type
.ref
->r
= ad
.func_attr
;
9705 external_sym(v
, &type
, 0);
9707 /* not lvalue if array */
9709 if (!(type
.t
& VT_ARRAY
))
9710 r
|= lvalue_type(type
.t
);
9711 has_init
= (tok
== '=');
9712 if ((btype
.t
& VT_EXTERN
) ||
9713 ((type
.t
& VT_ARRAY
) && (type
.t
& VT_STATIC
) &&
9714 !has_init
&& l
== VT_CONST
&& type
.ref
->c
< 0)) {
9715 /* external variable */
9716 /* NOTE: as GCC, uninitialized global static
9717 arrays of null size are considered as
9719 external_sym(v
, &type
, r
);
9721 type
.t
|= (btype
.t
& VT_STATIC
); /* Retain "static". */
9722 if (type
.t
& VT_STATIC
)
9728 decl_initializer_alloc(&type
, &ad
, r
,
9742 /* better than nothing, but needs extension to handle '-E' option
9744 static void preprocess_init(TCCState
*s1
)
9746 s1
->include_stack_ptr
= s1
->include_stack
;
9747 /* XXX: move that before to avoid having to initialize
9748 file->ifdef_stack_ptr ? */
9749 s1
->ifdef_stack_ptr
= s1
->ifdef_stack
;
9750 file
->ifdef_stack_ptr
= s1
->ifdef_stack_ptr
;
9752 /* XXX: not ANSI compliant: bound checking says error */
9754 s1
->pack_stack
[0] = 0;
9755 s1
->pack_stack_ptr
= s1
->pack_stack
;
9758 /* compile the C file opened in 'file'. Return non zero if errors. */
9759 static int tcc_compile(TCCState
*s1
)
9763 volatile int section_sym
;
9766 printf("%s: **** new file\n", file
->filename
);
9768 preprocess_init(s1
);
9770 cur_text_section
= NULL
;
9772 anon_sym
= SYM_FIRST_ANOM
;
9774 /* file info: full path + filename */
9775 section_sym
= 0; /* avoid warning */
9777 section_sym
= put_elf_sym(symtab_section
, 0, 0,
9778 ELFW(ST_INFO
)(STB_LOCAL
, STT_SECTION
), 0,
9779 text_section
->sh_num
, NULL
);
9780 getcwd(buf
, sizeof(buf
));
9782 normalize_slashes(buf
);
9784 pstrcat(buf
, sizeof(buf
), "/");
9785 put_stabs_r(buf
, N_SO
, 0, 0,
9786 text_section
->data_offset
, text_section
, section_sym
);
9787 put_stabs_r(file
->filename
, N_SO
, 0, 0,
9788 text_section
->data_offset
, text_section
, section_sym
);
9790 /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
9791 symbols can be safely used */
9792 put_elf_sym(symtab_section
, 0, 0,
9793 ELFW(ST_INFO
)(STB_LOCAL
, STT_FILE
), 0,
9794 SHN_ABS
, file
->filename
);
9796 /* define some often used types */
9797 int_type
.t
= VT_INT
;
9799 char_pointer_type
.t
= VT_BYTE
;
9800 mk_pointer(&char_pointer_type
);
9802 func_old_type
.t
= VT_FUNC
;
9803 func_old_type
.ref
= sym_push(SYM_FIELD
, &int_type
, FUNC_CDECL
, FUNC_OLD
);
9805 #if defined(TCC_ARM_EABI) && defined(TCC_ARM_VFP)
9806 float_type
.t
= VT_FLOAT
;
9807 double_type
.t
= VT_DOUBLE
;
9809 func_float_type
.t
= VT_FUNC
;
9810 func_float_type
.ref
= sym_push(SYM_FIELD
, &float_type
, FUNC_CDECL
, FUNC_OLD
);
9811 func_double_type
.t
= VT_FUNC
;
9812 func_double_type
.ref
= sym_push(SYM_FIELD
, &double_type
, FUNC_CDECL
, FUNC_OLD
);
9816 /* define 'void *alloca(unsigned int)' builtin function */
9821 sym
= sym_push(p
, mk_pointer(VT_VOID
), FUNC_CDECL
, FUNC_NEW
);
9822 s1
= sym_push(SYM_FIELD
, VT_UNSIGNED
| VT_INT
, 0, 0);
9825 sym_push(TOK_alloca
, VT_FUNC
| (p
<< VT_STRUCT_SHIFT
), VT_CONST
, 0);
9829 define_start
= define_stack
;
9832 if (setjmp(s1
->error_jmp_buf
) == 0) {
9834 s1
->error_set_jmp_enabled
= 1;
9836 ch
= file
->buf_ptr
[0];
9837 tok_flags
= TOK_FLAG_BOL
| TOK_FLAG_BOF
;
9838 parse_flags
= PARSE_FLAG_PREPROCESS
| PARSE_FLAG_TOK_NUM
;
9842 expect("declaration");
9844 /* end of translation unit info */
9846 put_stabs_r(NULL
, N_SO
, 0, 0,
9847 text_section
->data_offset
, text_section
, section_sym
);
9850 s1
->error_set_jmp_enabled
= 0;
9852 /* reset define stack, but leave -Dsymbols (may be incorrect if
9853 they are undefined) */
9854 free_defines(define_start
);
9856 gen_inline_functions();
9858 sym_pop(&global_stack
, NULL
);
9859 sym_pop(&local_stack
, NULL
);
9861 return s1
->nb_errors
!= 0 ? -1 : 0;
9864 /* Preprocess the current file */
9865 /* XXX: add line and file infos,
9866 * XXX: add options to preserve spaces (partly done, only spaces in macro are
9869 static int tcc_preprocess(TCCState
*s1
)
9872 BufferedFile
*file_ref
;
9873 int token_seen
, line_ref
;
9875 preprocess_init(s1
);
9876 define_start
= define_stack
;
9877 ch
= file
->buf_ptr
[0];
9879 tok_flags
= TOK_FLAG_BOL
| TOK_FLAG_BOF
;
9880 parse_flags
= PARSE_FLAG_ASM_COMMENTS
| PARSE_FLAG_PREPROCESS
|
9881 PARSE_FLAG_LINEFEED
;
9889 if (tok
== TOK_EOF
) {
9891 } else if (tok
== TOK_LINEFEED
) {
9896 } else if (token_seen
) {
9897 fwrite(tok_spaces
.data
, tok_spaces
.size
, 1, s1
->outfile
);
9899 int d
= file
->line_num
- line_ref
;
9900 if (file
!= file_ref
|| d
< 0 || d
>= 8)
9901 fprintf(s1
->outfile
, "# %d \"%s\"\n", file
->line_num
, file
->filename
);
9904 fputs("\n", s1
->outfile
), --d
;
9905 line_ref
= (file_ref
= file
)->line_num
;
9908 fputs(get_tok_str(tok
, &tokc
), s1
->outfile
);
9910 free_defines(define_start
);
9915 int tcc_compile_string(TCCState
*s
, const char *str
)
9917 BufferedFile bf1
, *bf
= &bf1
;
9921 /* init file structure */
9923 /* XXX: avoid copying */
9925 buf
= tcc_malloc(len
+ 1);
9928 memcpy(buf
, str
, len
);
9931 bf
->buf_end
= buf
+ len
;
9932 pstrcpy(bf
->filename
, sizeof(bf
->filename
), "<string>");
9935 ret
= tcc_compile(s
);
9939 /* currently, no need to close */
9944 /* define a preprocessor symbol. A value can also be provided with the '=' operator */
9945 void tcc_define_symbol(TCCState
*s1
, const char *sym
, const char *value
)
9947 BufferedFile bf1
, *bf
= &bf1
;
9949 pstrcpy(bf
->buffer
, IO_BUF_SIZE
, sym
);
9950 pstrcat(bf
->buffer
, IO_BUF_SIZE
, " ");
9954 pstrcat(bf
->buffer
, IO_BUF_SIZE
, value
);
9956 /* init file structure */
9958 bf
->buf_ptr
= bf
->buffer
;
9959 bf
->buf_end
= bf
->buffer
+ strlen(bf
->buffer
);
9960 *bf
->buf_end
= CH_EOB
;
9961 bf
->filename
[0] = '\0';
9965 s1
->include_stack_ptr
= s1
->include_stack
;
9967 /* parse with define parser */
9968 ch
= file
->buf_ptr
[0];
9974 /* undefine a preprocessor symbol */
9975 void tcc_undefine_symbol(TCCState
*s1
, const char *sym
)
9979 ts
= tok_alloc(sym
, strlen(sym
));
9980 s
= define_find(ts
->tok
);
9981 /* undefine symbol by putting an invalid name */
9986 #ifdef CONFIG_TCC_ASM
9988 #ifdef TCC_TARGET_I386
9989 #include "i386-asm.c"
9994 static void asm_instr(void)
9996 error("inline asm() not supported");
9998 static void asm_global_instr(void)
10000 error("inline asm() not supported");
10004 #include "tccelf.c"
10006 #ifdef TCC_TARGET_COFF
10007 #include "tcccoff.c"
10010 #ifdef TCC_TARGET_PE
10014 /* print the position in the source file of PC value 'pc' by reading
10015 the stabs debug information */
10016 static void rt_printline(unsigned long wanted_pc
)
10018 Stab_Sym
*sym
, *sym_end
;
10019 char func_name
[128], last_func_name
[128];
10020 unsigned long func_addr
, last_pc
, pc
;
10021 const char *incl_files
[INCLUDE_STACK_SIZE
];
10022 int incl_index
, len
, last_line_num
, i
;
10023 const char *str
, *p
;
10025 fprintf(stderr
, "0x%08lx:", wanted_pc
);
10027 func_name
[0] = '\0';
10030 last_func_name
[0] = '\0';
10031 last_pc
= 0xffffffff;
10033 sym
= (Stab_Sym
*)stab_section
->data
+ 1;
10034 sym_end
= (Stab_Sym
*)(stab_section
->data
+ stab_section
->data_offset
);
10035 while (sym
< sym_end
) {
10036 switch(sym
->n_type
) {
10037 /* function start or end */
10039 if (sym
->n_strx
== 0) {
10040 /* we test if between last line and end of function */
10041 pc
= sym
->n_value
+ func_addr
;
10042 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
10044 func_name
[0] = '\0';
10047 str
= stabstr_section
->data
+ sym
->n_strx
;
10048 p
= strchr(str
, ':');
10050 pstrcpy(func_name
, sizeof(func_name
), str
);
10053 if (len
> sizeof(func_name
) - 1)
10054 len
= sizeof(func_name
) - 1;
10055 memcpy(func_name
, str
, len
);
10056 func_name
[len
] = '\0';
10058 func_addr
= sym
->n_value
;
10061 /* line number info */
10063 pc
= sym
->n_value
+ func_addr
;
10064 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
10067 last_line_num
= sym
->n_desc
;
10069 strcpy(last_func_name
, func_name
);
10071 /* include files */
10073 str
= stabstr_section
->data
+ sym
->n_strx
;
10075 if (incl_index
< INCLUDE_STACK_SIZE
) {
10076 incl_files
[incl_index
++] = str
;
10080 if (incl_index
> 1)
10084 if (sym
->n_strx
== 0) {
10085 incl_index
= 0; /* end of translation unit */
10087 str
= stabstr_section
->data
+ sym
->n_strx
;
10088 /* do not add path */
10090 if (len
> 0 && str
[len
- 1] != '/')
10098 /* second pass: we try symtab symbols (no line number info) */
10101 ElfW(Sym
) *sym
, *sym_end
;
10104 sym_end
= (ElfW(Sym
) *)(symtab_section
->data
+ symtab_section
->data_offset
);
10105 for(sym
= (ElfW(Sym
) *)symtab_section
->data
+ 1;
10108 type
= ELFW(ST_TYPE
)(sym
->st_info
);
10109 if (type
== STT_FUNC
) {
10110 if (wanted_pc
>= sym
->st_value
&&
10111 wanted_pc
< sym
->st_value
+ sym
->st_size
) {
10112 pstrcpy(last_func_name
, sizeof(last_func_name
),
10113 strtab_section
->data
+ sym
->st_name
);
10119 /* did not find any info: */
10120 fprintf(stderr
, " ???\n");
10123 if (last_func_name
[0] != '\0') {
10124 fprintf(stderr
, " %s()", last_func_name
);
10126 if (incl_index
> 0) {
10127 fprintf(stderr
, " (%s:%d",
10128 incl_files
[incl_index
- 1], last_line_num
);
10129 for(i
= incl_index
- 2; i
>= 0; i
--)
10130 fprintf(stderr
, ", included from %s", incl_files
[i
]);
10131 fprintf(stderr
, ")");
10133 fprintf(stderr
, "\n");
10136 #if !defined(_WIN32) && !defined(CONFIG_TCCBOOT)
10140 /* fix for glibc 2.1 */
10142 #define REG_EIP EIP
10143 #define REG_EBP EBP
10146 /* return the PC at frame level 'level'. Return non zero if not found */
10147 static int rt_get_caller_pc(unsigned long *paddr
,
10148 ucontext_t
*uc
, int level
)
10154 #if defined(__FreeBSD__)
10155 *paddr
= uc
->uc_mcontext
.mc_eip
;
10156 #elif defined(__dietlibc__)
10157 *paddr
= uc
->uc_mcontext
.eip
;
10159 *paddr
= uc
->uc_mcontext
.gregs
[REG_EIP
];
10163 #if defined(__FreeBSD__)
10164 fp
= uc
->uc_mcontext
.mc_ebp
;
10165 #elif defined(__dietlibc__)
10166 fp
= uc
->uc_mcontext
.ebp
;
10168 fp
= uc
->uc_mcontext
.gregs
[REG_EBP
];
10170 for(i
=1;i
<level
;i
++) {
10171 /* XXX: check address validity with program info */
10172 if (fp
<= 0x1000 || fp
>= 0xc0000000)
10174 fp
= ((unsigned long *)fp
)[0];
10176 *paddr
= ((unsigned long *)fp
)[1];
10180 #elif defined(__x86_64__)
10181 /* return the PC at frame level 'level'. Return non zero if not found */
10182 static int rt_get_caller_pc(unsigned long *paddr
,
10183 ucontext_t
*uc
, int level
)
10189 /* XXX: only support linux */
10190 *paddr
= uc
->uc_mcontext
.gregs
[REG_RIP
];
10193 fp
= uc
->uc_mcontext
.gregs
[REG_RBP
];
10194 for(i
=1;i
<level
;i
++) {
10195 /* XXX: check address validity with program info */
10198 fp
= ((unsigned long *)fp
)[0];
10200 *paddr
= ((unsigned long *)fp
)[1];
10206 #warning add arch specific rt_get_caller_pc()
10208 static int rt_get_caller_pc(unsigned long *paddr
,
10209 ucontext_t
*uc
, int level
)
10215 /* emit a run time error at position 'pc' */
10216 void rt_error(ucontext_t
*uc
, const char *fmt
, ...)
10223 fprintf(stderr
, "Runtime error: ");
10224 vfprintf(stderr
, fmt
, ap
);
10225 fprintf(stderr
, "\n");
10226 for(i
=0;i
<num_callers
;i
++) {
10227 if (rt_get_caller_pc(&pc
, uc
, i
) < 0)
10230 fprintf(stderr
, "at ");
10232 fprintf(stderr
, "by ");
10239 /* signal handler for fatal errors */
10240 static void sig_error(int signum
, siginfo_t
*siginf
, void *puc
)
10242 ucontext_t
*uc
= puc
;
10246 switch(siginf
->si_code
) {
10249 rt_error(uc
, "division by zero");
10252 rt_error(uc
, "floating point exception");
10258 if (rt_bound_error_msg
&& *rt_bound_error_msg
)
10259 rt_error(uc
, *rt_bound_error_msg
);
10261 rt_error(uc
, "dereferencing invalid pointer");
10264 rt_error(uc
, "illegal instruction");
10267 rt_error(uc
, "abort() called");
10270 rt_error(uc
, "caught signal %d", signum
);
10277 /* do all relocations (needed before using tcc_get_symbol()) */
10278 int tcc_relocate(TCCState
*s1
)
10285 #ifdef TCC_TARGET_PE
10286 pe_add_runtime(s1
);
10288 tcc_add_runtime(s1
);
10291 relocate_common_syms();
10293 tcc_add_linker_symbols(s1
);
10294 #ifndef TCC_TARGET_PE
10295 build_got_entries(s1
);
10298 #ifdef TCC_TARGET_X86_64
10300 /* If the distance of two sections are longer than 32bit, our
10301 program will crash. Let's combine all sections which are
10302 necessary to run the program into a single buffer in the
10306 /* calculate the size of buffers we need */
10308 for(i
= 1; i
< s1
->nb_sections
; i
++) {
10309 s
= s1
->sections
[i
];
10310 if (s
->sh_flags
& SHF_ALLOC
) {
10311 size
+= s
->data_offset
;
10314 /* double the size of the buffer for got and plt entries
10315 XXX: calculate exact size for them? */
10316 section_realloc(text_section
, size
* 2);
10317 p
= text_section
->data
+ text_section
->data_offset
;
10318 /* we will put got and plt after this offset */
10319 text_section
->data_offset
= size
;
10321 for(i
= 1; i
< s1
->nb_sections
; i
++) {
10322 s
= s1
->sections
[i
];
10323 if (s
->sh_flags
& SHF_ALLOC
) {
10324 if (s
!= text_section
&& s
->data_offset
) {
10325 if (s
->sh_type
== SHT_NOBITS
) {
10326 /* for bss section */
10327 memset(p
, 0, s
->data_offset
);
10329 memcpy(p
, s
->data
, s
->data_offset
);
10333 /* we won't free s->data for this section */
10334 s
->data_allocated
= 0;
10335 p
+= s
->data_offset
;
10337 s
->sh_addr
= (unsigned long)s
->data
;
10342 /* compute relocation address : section are relocated in place. We
10343 also alloc the bss space */
10344 for(i
= 1; i
< s1
->nb_sections
; i
++) {
10345 s
= s1
->sections
[i
];
10346 if (s
->sh_flags
& SHF_ALLOC
) {
10347 if (s
->sh_type
== SHT_NOBITS
)
10348 s
->data
= tcc_mallocz(s
->data_offset
);
10349 s
->sh_addr
= (unsigned long)s
->data
;
10354 relocate_syms(s1
, 1);
10356 if (s1
->nb_errors
!= 0)
10359 /* relocate each section */
10360 for(i
= 1; i
< s1
->nb_sections
; i
++) {
10361 s
= s1
->sections
[i
];
10363 relocate_section(s1
, s
);
10366 /* mark executable sections as executable in memory */
10367 for(i
= 1; i
< s1
->nb_sections
; i
++) {
10368 s
= s1
->sections
[i
];
10369 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_EXECINSTR
)) ==
10370 (SHF_ALLOC
| SHF_EXECINSTR
))
10371 set_pages_executable(s
->data
, s
->data_offset
);
10376 /* launch the compiled program with the given arguments */
10377 int tcc_run(TCCState
*s1
, int argc
, char **argv
)
10379 int (*prog_main
)(int, char **);
10381 if (tcc_relocate(s1
) < 0)
10384 prog_main
= tcc_get_symbol_err(s1
, "main");
10387 #if defined(_WIN32) || defined(CONFIG_TCCBOOT)
10388 error("debug mode currently not available for Windows");
10390 struct sigaction sigact
;
10391 /* install TCC signal handlers to print debug info on fatal
10393 sigact
.sa_flags
= SA_SIGINFO
| SA_RESETHAND
;
10394 sigact
.sa_sigaction
= sig_error
;
10395 sigemptyset(&sigact
.sa_mask
);
10396 sigaction(SIGFPE
, &sigact
, NULL
);
10397 sigaction(SIGILL
, &sigact
, NULL
);
10398 sigaction(SIGSEGV
, &sigact
, NULL
);
10399 sigaction(SIGBUS
, &sigact
, NULL
);
10400 sigaction(SIGABRT
, &sigact
, NULL
);
10404 #ifdef CONFIG_TCC_BCHECK
10405 if (do_bounds_check
) {
10406 void (*bound_init
)(void);
10408 /* set error function */
10409 rt_bound_error_msg
= (void *)tcc_get_symbol_err(s1
,
10410 "__bound_error_msg");
10412 /* XXX: use .init section so that it also work in binary ? */
10413 bound_init
= (void *)tcc_get_symbol_err(s1
, "__bound_init");
10417 return (*prog_main
)(argc
, argv
);
10420 void tcc_memstats(void)
10423 printf("memory in use: %d\n", mem_cur_size
);
10427 static void tcc_cleanup(void)
10431 if (NULL
== tcc_state
)
10435 /* free -D defines */
10436 free_defines(NULL
);
10439 n
= tok_ident
- TOK_IDENT
;
10440 for(i
= 0; i
< n
; i
++)
10441 tcc_free(table_ident
[i
]);
10442 tcc_free(table_ident
);
10444 /* free sym_pools */
10445 dynarray_reset(&sym_pools
, &nb_sym_pools
);
10446 /* string buffer */
10447 cstr_free(&tokcstr
);
10448 /* reset symbol stack */
10449 sym_free_first
= NULL
;
10450 /* cleanup from error/setjmp */
10454 TCCState
*tcc_new(void)
10463 s
= tcc_mallocz(sizeof(TCCState
));
10467 s
->output_type
= TCC_OUTPUT_MEMORY
;
10469 /* init isid table */
10470 for(i
=CH_EOF
;i
<256;i
++)
10471 isidnum_table
[i
-CH_EOF
] = isid(i
) || isnum(i
);
10473 /* add all tokens */
10474 table_ident
= NULL
;
10475 memset(hash_ident
, 0, TOK_HASH_SIZE
* sizeof(TokenSym
*));
10477 tok_ident
= TOK_IDENT
;
10486 ts
= tok_alloc(p
, r
- p
- 1);
10490 /* we add dummy defines for some special macros to speed up tests
10491 and to have working defined() */
10492 define_push(TOK___LINE__
, MACRO_OBJ
, NULL
, NULL
);
10493 define_push(TOK___FILE__
, MACRO_OBJ
, NULL
, NULL
);
10494 define_push(TOK___DATE__
, MACRO_OBJ
, NULL
, NULL
);
10495 define_push(TOK___TIME__
, MACRO_OBJ
, NULL
, NULL
);
10497 /* standard defines */
10498 tcc_define_symbol(s
, "__STDC__", NULL
);
10499 tcc_define_symbol(s
, "__STDC_VERSION__", "199901L");
10500 #if defined(TCC_TARGET_I386)
10501 tcc_define_symbol(s
, "__i386__", NULL
);
10503 #if defined(TCC_TARGET_X86_64)
10504 tcc_define_symbol(s
, "__x86_64__", NULL
);
10506 #if defined(TCC_TARGET_ARM)
10507 tcc_define_symbol(s
, "__ARM_ARCH_4__", NULL
);
10508 tcc_define_symbol(s
, "__arm_elf__", NULL
);
10509 tcc_define_symbol(s
, "__arm_elf", NULL
);
10510 tcc_define_symbol(s
, "arm_elf", NULL
);
10511 tcc_define_symbol(s
, "__arm__", NULL
);
10512 tcc_define_symbol(s
, "__arm", NULL
);
10513 tcc_define_symbol(s
, "arm", NULL
);
10514 tcc_define_symbol(s
, "__APCS_32__", NULL
);
10516 #ifdef TCC_TARGET_PE
10517 tcc_define_symbol(s
, "_WIN32", NULL
);
10519 tcc_define_symbol(s
, "__unix__", NULL
);
10520 tcc_define_symbol(s
, "__unix", NULL
);
10521 #if defined(__linux)
10522 tcc_define_symbol(s
, "__linux__", NULL
);
10523 tcc_define_symbol(s
, "__linux", NULL
);
10526 /* tiny C specific defines */
10527 tcc_define_symbol(s
, "__TINYC__", NULL
);
10529 /* tiny C & gcc defines */
10530 tcc_define_symbol(s
, "__SIZE_TYPE__", "unsigned int");
10531 tcc_define_symbol(s
, "__PTRDIFF_TYPE__", "int");
10532 #ifdef TCC_TARGET_PE
10533 tcc_define_symbol(s
, "__WCHAR_TYPE__", "unsigned short");
10535 tcc_define_symbol(s
, "__WCHAR_TYPE__", "int");
10538 #ifndef TCC_TARGET_PE
10539 /* default library paths */
10540 tcc_add_library_path(s
, CONFIG_SYSROOT
"/usr/local/lib");
10541 tcc_add_library_path(s
, CONFIG_SYSROOT
"/usr/lib");
10542 tcc_add_library_path(s
, CONFIG_SYSROOT
"/lib");
10545 /* no section zero */
10546 dynarray_add((void ***)&s
->sections
, &s
->nb_sections
, NULL
);
10548 /* create standard sections */
10549 text_section
= new_section(s
, ".text", SHT_PROGBITS
, SHF_ALLOC
| SHF_EXECINSTR
);
10550 data_section
= new_section(s
, ".data", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
10551 bss_section
= new_section(s
, ".bss", SHT_NOBITS
, SHF_ALLOC
| SHF_WRITE
);
10553 /* symbols are always generated for linking stage */
10554 symtab_section
= new_symtab(s
, ".symtab", SHT_SYMTAB
, 0,
10556 ".hashtab", SHF_PRIVATE
);
10557 strtab_section
= symtab_section
->link
;
10559 /* private symbol table for dynamic symbols */
10560 s
->dynsymtab_section
= new_symtab(s
, ".dynsymtab", SHT_SYMTAB
, SHF_PRIVATE
,
10562 ".dynhashtab", SHF_PRIVATE
);
10563 s
->alacarte_link
= 1;
10565 #ifdef CHAR_IS_UNSIGNED
10566 s
->char_is_unsigned
= 1;
10568 #if defined(TCC_TARGET_PE) && 0
10569 /* XXX: currently the PE linker is not ready to support that */
10570 s
->leading_underscore
= 1;
10575 void tcc_delete(TCCState
*s1
)
10581 /* free all sections */
10582 for(i
= 1; i
< s1
->nb_sections
; i
++)
10583 free_section(s1
->sections
[i
]);
10584 dynarray_reset(&s1
->sections
, &s1
->nb_sections
);
10586 for(i
= 0; i
< s1
->nb_priv_sections
; i
++)
10587 free_section(s1
->priv_sections
[i
]);
10588 dynarray_reset(&s1
->priv_sections
, &s1
->nb_priv_sections
);
10590 /* free any loaded DLLs */
10591 for ( i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
10592 DLLReference
*ref
= s1
->loaded_dlls
[i
];
10594 dlclose(ref
->handle
);
10597 /* free loaded dlls array */
10598 dynarray_reset(&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
);
10600 /* free library paths */
10601 dynarray_reset(&s1
->library_paths
, &s1
->nb_library_paths
);
10603 /* free include paths */
10604 dynarray_reset(&s1
->cached_includes
, &s1
->nb_cached_includes
);
10605 dynarray_reset(&s1
->include_paths
, &s1
->nb_include_paths
);
10606 dynarray_reset(&s1
->sysinclude_paths
, &s1
->nb_sysinclude_paths
);
10611 int tcc_add_include_path(TCCState
*s1
, const char *pathname
)
10615 pathname1
= tcc_strdup(pathname
);
10616 dynarray_add((void ***)&s1
->include_paths
, &s1
->nb_include_paths
, pathname1
);
10620 int tcc_add_sysinclude_path(TCCState
*s1
, const char *pathname
)
10624 pathname1
= tcc_strdup(pathname
);
10625 dynarray_add((void ***)&s1
->sysinclude_paths
, &s1
->nb_sysinclude_paths
, pathname1
);
10629 static int tcc_add_file_internal(TCCState
*s1
, const char *filename
, int flags
)
10634 BufferedFile
*saved_file
;
10636 /* find source file type with extension */
10637 ext
= tcc_fileextension(filename
);
10641 /* open the file */
10643 file
= tcc_open(s1
, filename
);
10645 if (flags
& AFF_PRINT_ERROR
) {
10646 error_noabort("file '%s' not found", filename
);
10652 if (flags
& AFF_PREPROCESS
) {
10653 ret
= tcc_preprocess(s1
);
10654 } else if (!ext
[0] || !strcmp(ext
, "c")) {
10655 /* C file assumed */
10656 ret
= tcc_compile(s1
);
10658 #ifdef CONFIG_TCC_ASM
10659 if (!strcmp(ext
, "S")) {
10660 /* preprocessed assembler */
10661 ret
= tcc_assemble(s1
, 1);
10662 } else if (!strcmp(ext
, "s")) {
10663 /* non preprocessed assembler */
10664 ret
= tcc_assemble(s1
, 0);
10667 #ifdef TCC_TARGET_PE
10668 if (!strcmp(ext
, "def")) {
10669 ret
= pe_load_def_file(s1
, file
->fd
);
10674 /* assume executable format: auto guess file type */
10675 ret
= read(fd
, &ehdr
, sizeof(ehdr
));
10676 lseek(fd
, 0, SEEK_SET
);
10678 error_noabort("could not read header");
10680 } else if (ret
!= sizeof(ehdr
)) {
10681 goto try_load_script
;
10684 if (ehdr
.e_ident
[0] == ELFMAG0
&&
10685 ehdr
.e_ident
[1] == ELFMAG1
&&
10686 ehdr
.e_ident
[2] == ELFMAG2
&&
10687 ehdr
.e_ident
[3] == ELFMAG3
) {
10688 file
->line_num
= 0; /* do not display line number if error */
10689 if (ehdr
.e_type
== ET_REL
) {
10690 ret
= tcc_load_object_file(s1
, fd
, 0);
10691 } else if (ehdr
.e_type
== ET_DYN
) {
10692 if (s1
->output_type
== TCC_OUTPUT_MEMORY
) {
10693 #ifdef TCC_TARGET_PE
10697 h
= dlopen(filename
, RTLD_GLOBAL
| RTLD_LAZY
);
10704 ret
= tcc_load_dll(s1
, fd
, filename
,
10705 (flags
& AFF_REFERENCED_DLL
) != 0);
10708 error_noabort("unrecognized ELF file");
10711 } else if (memcmp((char *)&ehdr
, ARMAG
, 8) == 0) {
10712 file
->line_num
= 0; /* do not display line number if error */
10713 ret
= tcc_load_archive(s1
, fd
);
10715 #ifdef TCC_TARGET_COFF
10716 if (*(uint16_t *)(&ehdr
) == COFF_C67_MAGIC
) {
10717 ret
= tcc_load_coff(s1
, fd
);
10720 #ifdef TCC_TARGET_PE
10721 if (pe_test_res_file(&ehdr
, ret
)) {
10722 ret
= pe_load_res_file(s1
, fd
);
10726 /* as GNU ld, consider it is an ld script if not recognized */
10728 ret
= tcc_load_ldscript(s1
);
10730 error_noabort("unrecognized file type");
10745 int tcc_add_file(TCCState
*s
, const char *filename
)
10747 return tcc_add_file_internal(s
, filename
, AFF_PRINT_ERROR
);
10750 int tcc_add_library_path(TCCState
*s
, const char *pathname
)
10754 pathname1
= tcc_strdup(pathname
);
10755 dynarray_add((void ***)&s
->library_paths
, &s
->nb_library_paths
, pathname1
);
10759 /* find and load a dll. Return non zero if not found */
10760 /* XXX: add '-rpath' option support ? */
10761 static int tcc_add_dll(TCCState
*s
, const char *filename
, int flags
)
10766 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
10767 snprintf(buf
, sizeof(buf
), "%s/%s",
10768 s
->library_paths
[i
], filename
);
10769 if (tcc_add_file_internal(s
, buf
, flags
) == 0)
10775 /* the library name is the same as the argument of the '-l' option */
10776 int tcc_add_library(TCCState
*s
, const char *libraryname
)
10781 /* first we look for the dynamic library if not static linking */
10782 if (!s
->static_link
) {
10783 #ifdef TCC_TARGET_PE
10784 snprintf(buf
, sizeof(buf
), "%s.def", libraryname
);
10786 snprintf(buf
, sizeof(buf
), "lib%s.so", libraryname
);
10788 if (tcc_add_dll(s
, buf
, 0) == 0)
10792 /* then we look for the static library */
10793 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
10794 snprintf(buf
, sizeof(buf
), "%s/lib%s.a",
10795 s
->library_paths
[i
], libraryname
);
10796 if (tcc_add_file_internal(s
, buf
, 0) == 0)
10802 int tcc_add_symbol(TCCState
*s
, const char *name
, unsigned long val
)
10804 add_elf_sym(symtab_section
, val
, 0,
10805 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
10810 int tcc_set_output_type(TCCState
*s
, int output_type
)
10814 s
->output_type
= output_type
;
10816 if (!s
->nostdinc
) {
10817 /* default include paths */
10818 /* XXX: reverse order needed if -isystem support */
10819 #ifndef TCC_TARGET_PE
10820 tcc_add_sysinclude_path(s
, CONFIG_SYSROOT
"/usr/local/include");
10821 tcc_add_sysinclude_path(s
, CONFIG_SYSROOT
"/usr/include");
10823 snprintf(buf
, sizeof(buf
), "%s/include", tcc_lib_path
);
10824 tcc_add_sysinclude_path(s
, buf
);
10825 #ifdef TCC_TARGET_PE
10826 snprintf(buf
, sizeof(buf
), "%s/include/winapi", tcc_lib_path
);
10827 tcc_add_sysinclude_path(s
, buf
);
10831 /* if bound checking, then add corresponding sections */
10832 #ifdef CONFIG_TCC_BCHECK
10833 if (do_bounds_check
) {
10834 /* define symbol */
10835 tcc_define_symbol(s
, "__BOUNDS_CHECKING_ON", NULL
);
10836 /* create bounds sections */
10837 bounds_section
= new_section(s
, ".bounds",
10838 SHT_PROGBITS
, SHF_ALLOC
);
10839 lbounds_section
= new_section(s
, ".lbounds",
10840 SHT_PROGBITS
, SHF_ALLOC
);
10844 if (s
->char_is_unsigned
) {
10845 tcc_define_symbol(s
, "__CHAR_UNSIGNED__", NULL
);
10848 /* add debug sections */
10851 stab_section
= new_section(s
, ".stab", SHT_PROGBITS
, 0);
10852 stab_section
->sh_entsize
= sizeof(Stab_Sym
);
10853 stabstr_section
= new_section(s
, ".stabstr", SHT_STRTAB
, 0);
10854 put_elf_str(stabstr_section
, "");
10855 stab_section
->link
= stabstr_section
;
10856 /* put first entry */
10857 put_stabs("", 0, 0, 0, 0);
10860 /* add libc crt1/crti objects */
10861 #ifndef TCC_TARGET_PE
10862 if ((output_type
== TCC_OUTPUT_EXE
|| output_type
== TCC_OUTPUT_DLL
) &&
10864 if (output_type
!= TCC_OUTPUT_DLL
)
10865 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crt1.o");
10866 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crti.o");
10870 #ifdef TCC_TARGET_PE
10871 snprintf(buf
, sizeof(buf
), "%s/lib", tcc_lib_path
);
10872 tcc_add_library_path(s
, buf
);
10878 #define WD_ALL 0x0001 /* warning is activated when using -Wall */
10879 #define FD_INVERT 0x0002 /* invert value before storing */
10881 typedef struct FlagDef
{
10887 static const FlagDef warning_defs
[] = {
10888 { offsetof(TCCState
, warn_unsupported
), 0, "unsupported" },
10889 { offsetof(TCCState
, warn_write_strings
), 0, "write-strings" },
10890 { offsetof(TCCState
, warn_error
), 0, "error" },
10891 { offsetof(TCCState
, warn_implicit_function_declaration
), WD_ALL
,
10892 "implicit-function-declaration" },
10895 static int set_flag(TCCState
*s
, const FlagDef
*flags
, int nb_flags
,
10896 const char *name
, int value
)
10903 if (r
[0] == 'n' && r
[1] == 'o' && r
[2] == '-') {
10907 for(i
= 0, p
= flags
; i
< nb_flags
; i
++, p
++) {
10908 if (!strcmp(r
, p
->name
))
10913 if (p
->flags
& FD_INVERT
)
10915 *(int *)((uint8_t *)s
+ p
->offset
) = value
;
10920 /* set/reset a warning */
10921 int tcc_set_warning(TCCState
*s
, const char *warning_name
, int value
)
10926 if (!strcmp(warning_name
, "all")) {
10927 for(i
= 0, p
= warning_defs
; i
< countof(warning_defs
); i
++, p
++) {
10928 if (p
->flags
& WD_ALL
)
10929 *(int *)((uint8_t *)s
+ p
->offset
) = 1;
10933 return set_flag(s
, warning_defs
, countof(warning_defs
),
10934 warning_name
, value
);
10938 static const FlagDef flag_defs
[] = {
10939 { offsetof(TCCState
, char_is_unsigned
), 0, "unsigned-char" },
10940 { offsetof(TCCState
, char_is_unsigned
), FD_INVERT
, "signed-char" },
10941 { offsetof(TCCState
, nocommon
), FD_INVERT
, "common" },
10942 { offsetof(TCCState
, leading_underscore
), 0, "leading-underscore" },
10945 /* set/reset a flag */
10946 int tcc_set_flag(TCCState
*s
, const char *flag_name
, int value
)
10948 return set_flag(s
, flag_defs
, countof(flag_defs
),
10952 #if !defined(LIBTCC)
10954 static int64_t getclock_us(void)
10959 return (tb
.time
* 1000LL + tb
.millitm
) * 1000LL;
10962 gettimeofday(&tv
, NULL
);
10963 return tv
.tv_sec
* 1000000LL + tv
.tv_usec
;
10969 printf("tcc version " TCC_VERSION
" - Tiny C Compiler - Copyright (C) 2001-2006 Fabrice Bellard\n"
10970 "usage: tcc [-v] [-c] [-o outfile] [-Bdir] [-bench] [-Idir] [-Dsym[=val]] [-Usym]\n"
10971 " [-Wwarn] [-g] [-b] [-bt N] [-Ldir] [-llib] [-shared] [-soname name]\n"
10972 " [-static] [infile1 infile2...] [-run infile args...]\n"
10974 "General options:\n"
10975 " -v display current version, increase verbosity\n"
10976 " -c compile only - generate an object file\n"
10977 " -o outfile set output filename\n"
10978 " -Bdir set tcc internal library path\n"
10979 " -bench output compilation statistics\n"
10980 " -run run compiled source\n"
10981 " -fflag set or reset (with 'no-' prefix) 'flag' (see man page)\n"
10982 " -Wwarning set or reset (with 'no-' prefix) 'warning' (see man page)\n"
10983 " -w disable all warnings\n"
10984 "Preprocessor options:\n"
10985 " -E preprocess only\n"
10986 " -Idir add include path 'dir'\n"
10987 " -Dsym[=val] define 'sym' with value 'val'\n"
10988 " -Usym undefine 'sym'\n"
10989 "Linker options:\n"
10990 " -Ldir add library path 'dir'\n"
10991 " -llib link with dynamic or static library 'lib'\n"
10992 " -shared generate a shared library\n"
10993 " -soname set name for shared library to be used at runtime\n"
10994 " -static static linking\n"
10995 " -rdynamic export all global symbols to dynamic linker\n"
10996 " -r generate (relocatable) object file\n"
10997 "Debugger options:\n"
10998 " -g generate runtime debug info\n"
10999 #ifdef CONFIG_TCC_BCHECK
11000 " -b compile with built-in memory and bounds checker (implies -g)\n"
11002 " -bt N show N callers in stack traces\n"
11006 #define TCC_OPTION_HAS_ARG 0x0001
11007 #define TCC_OPTION_NOSEP 0x0002 /* cannot have space before option and arg */
11009 typedef struct TCCOption
{
11038 TCC_OPTION_nostdinc
,
11039 TCC_OPTION_nostdlib
,
11040 TCC_OPTION_print_search_dirs
,
11041 TCC_OPTION_rdynamic
,
11049 static const TCCOption tcc_options
[] = {
11050 { "h", TCC_OPTION_HELP
, 0 },
11051 { "?", TCC_OPTION_HELP
, 0 },
11052 { "I", TCC_OPTION_I
, TCC_OPTION_HAS_ARG
},
11053 { "D", TCC_OPTION_D
, TCC_OPTION_HAS_ARG
},
11054 { "U", TCC_OPTION_U
, TCC_OPTION_HAS_ARG
},
11055 { "L", TCC_OPTION_L
, TCC_OPTION_HAS_ARG
},
11056 { "B", TCC_OPTION_B
, TCC_OPTION_HAS_ARG
},
11057 { "l", TCC_OPTION_l
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11058 { "bench", TCC_OPTION_bench
, 0 },
11059 { "bt", TCC_OPTION_bt
, TCC_OPTION_HAS_ARG
},
11060 #ifdef CONFIG_TCC_BCHECK
11061 { "b", TCC_OPTION_b
, 0 },
11063 { "g", TCC_OPTION_g
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11064 { "c", TCC_OPTION_c
, 0 },
11065 { "static", TCC_OPTION_static
, 0 },
11066 { "shared", TCC_OPTION_shared
, 0 },
11067 { "soname", TCC_OPTION_soname
, TCC_OPTION_HAS_ARG
},
11068 { "o", TCC_OPTION_o
, TCC_OPTION_HAS_ARG
},
11069 { "run", TCC_OPTION_run
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11070 { "rdynamic", TCC_OPTION_rdynamic
, 0 },
11071 { "r", TCC_OPTION_r
, 0 },
11072 { "Wl,", TCC_OPTION_Wl
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11073 { "W", TCC_OPTION_W
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11074 { "O", TCC_OPTION_O
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11075 { "m", TCC_OPTION_m
, TCC_OPTION_HAS_ARG
},
11076 { "f", TCC_OPTION_f
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11077 { "nostdinc", TCC_OPTION_nostdinc
, 0 },
11078 { "nostdlib", TCC_OPTION_nostdlib
, 0 },
11079 { "print-search-dirs", TCC_OPTION_print_search_dirs
, 0 },
11080 { "v", TCC_OPTION_v
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11081 { "w", TCC_OPTION_w
, 0 },
11082 { "pipe", TCC_OPTION_pipe
, 0},
11083 { "E", TCC_OPTION_E
, 0},
11087 /* convert 'str' into an array of space separated strings */
11088 static int expand_args(char ***pargv
, const char *str
)
11097 while (is_space(*str
))
11102 while (*str
!= '\0' && !is_space(*str
))
11105 arg
= tcc_malloc(len
+ 1);
11106 memcpy(arg
, s1
, len
);
11108 dynarray_add((void ***)&argv
, &argc
, arg
);
11114 static char **files
;
11115 static int nb_files
, nb_libraries
;
11116 static int multiple_files
;
11117 static int print_search_dirs
;
11118 static int output_type
;
11119 static int reloc_output
;
11120 static const char *outfile
;
11122 int parse_args(TCCState
*s
, int argc
, char **argv
)
11125 const TCCOption
*popt
;
11126 const char *optarg
, *p1
, *r1
;
11130 while (optind
< argc
) {
11132 r
= argv
[optind
++];
11133 if (r
[0] != '-' || r
[1] == '\0') {
11134 /* add a new file */
11135 dynarray_add((void ***)&files
, &nb_files
, r
);
11136 if (!multiple_files
) {
11138 /* argv[0] will be this file */
11142 /* find option in table (match only the first chars */
11143 popt
= tcc_options
;
11147 error("invalid option -- '%s'", r
);
11160 if (popt
->flags
& TCC_OPTION_HAS_ARG
) {
11161 if (*r1
!= '\0' || (popt
->flags
& TCC_OPTION_NOSEP
)) {
11164 if (optind
>= argc
)
11165 error("argument to '%s' is missing", r
);
11166 optarg
= argv
[optind
++];
11174 switch(popt
->index
) {
11175 case TCC_OPTION_HELP
:
11179 if (tcc_add_include_path(s
, optarg
) < 0)
11180 error("too many include paths");
11185 sym
= (char *)optarg
;
11186 value
= strchr(sym
, '=');
11191 tcc_define_symbol(s
, sym
, value
);
11195 tcc_undefine_symbol(s
, optarg
);
11198 tcc_add_library_path(s
, optarg
);
11201 /* set tcc utilities path (mainly for tcc development) */
11202 tcc_lib_path
= optarg
;
11205 dynarray_add((void ***)&files
, &nb_files
, r
);
11208 case TCC_OPTION_bench
:
11211 case TCC_OPTION_bt
:
11212 num_callers
= atoi(optarg
);
11214 #ifdef CONFIG_TCC_BCHECK
11216 do_bounds_check
= 1;
11224 multiple_files
= 1;
11225 output_type
= TCC_OUTPUT_OBJ
;
11227 case TCC_OPTION_static
:
11228 s
->static_link
= 1;
11230 case TCC_OPTION_shared
:
11231 output_type
= TCC_OUTPUT_DLL
;
11233 case TCC_OPTION_soname
:
11234 s
->soname
= optarg
;
11237 multiple_files
= 1;
11241 /* generate a .o merging several output files */
11243 output_type
= TCC_OUTPUT_OBJ
;
11245 case TCC_OPTION_nostdinc
:
11248 case TCC_OPTION_nostdlib
:
11251 case TCC_OPTION_print_search_dirs
:
11252 print_search_dirs
= 1;
11254 case TCC_OPTION_run
:
11258 argc1
= expand_args(&argv1
, optarg
);
11260 parse_args(s
, argc1
, argv1
);
11262 multiple_files
= 0;
11263 output_type
= TCC_OUTPUT_MEMORY
;
11268 if (0 == verbose
++)
11269 printf("tcc version %s\n", TCC_VERSION
);
11270 } while (*optarg
++ == 'v');
11273 if (tcc_set_flag(s
, optarg
, 1) < 0 && s
->warn_unsupported
)
11274 goto unsupported_option
;
11277 if (tcc_set_warning(s
, optarg
, 1) < 0 &&
11278 s
->warn_unsupported
)
11279 goto unsupported_option
;
11284 case TCC_OPTION_rdynamic
:
11287 case TCC_OPTION_Wl
:
11290 if (strstart(optarg
, "-Ttext,", &p
)) {
11291 s
->text_addr
= strtoul(p
, NULL
, 16);
11292 s
->has_text_addr
= 1;
11293 } else if (strstart(optarg
, "--oformat,", &p
)) {
11294 if (strstart(p
, "elf32-", NULL
)) {
11295 s
->output_format
= TCC_OUTPUT_FORMAT_ELF
;
11296 } else if (!strcmp(p
, "binary")) {
11297 s
->output_format
= TCC_OUTPUT_FORMAT_BINARY
;
11299 #ifdef TCC_TARGET_COFF
11300 if (!strcmp(p
, "coff")) {
11301 s
->output_format
= TCC_OUTPUT_FORMAT_COFF
;
11305 error("target %s not found", p
);
11308 error("unsupported linker option '%s'", optarg
);
11313 output_type
= TCC_OUTPUT_PREPROCESS
;
11316 if (s
->warn_unsupported
) {
11317 unsupported_option
:
11318 warning("unsupported option '%s'", r
);
11327 int main(int argc
, char **argv
)
11331 int nb_objfiles
, ret
, optind
;
11332 char objfilename
[1024];
11333 int64_t start_time
= 0;
11336 tcc_lib_path
= w32_tcc_lib_path();
11340 output_type
= TCC_OUTPUT_EXE
;
11342 multiple_files
= 1;
11347 print_search_dirs
= 0;
11350 optind
= parse_args(s
, argc
- 1, argv
+ 1);
11351 if (print_search_dirs
) {
11352 /* enough for Linux kernel */
11353 printf("install: %s/\n", tcc_lib_path
);
11356 if (optind
== 0 || nb_files
== 0) {
11357 if (optind
&& verbose
)
11363 nb_objfiles
= nb_files
- nb_libraries
;
11365 /* if outfile provided without other options, we output an
11367 if (outfile
&& output_type
== TCC_OUTPUT_MEMORY
)
11368 output_type
= TCC_OUTPUT_EXE
;
11370 /* check -c consistency : only single file handled. XXX: checks file type */
11371 if (output_type
== TCC_OUTPUT_OBJ
&& !reloc_output
) {
11372 /* accepts only a single input file */
11373 if (nb_objfiles
!= 1)
11374 error("cannot specify multiple files with -c");
11375 if (nb_libraries
!= 0)
11376 error("cannot specify libraries with -c");
11380 if (output_type
== TCC_OUTPUT_PREPROCESS
) {
11382 s
->outfile
= stdout
;
11384 s
->outfile
= fopen(outfile
, "w");
11386 error("could not open '%s", outfile
);
11388 } else if (output_type
!= TCC_OUTPUT_MEMORY
) {
11390 /* compute default outfile name */
11393 strcmp(files
[0], "-") == 0 ? "a" : tcc_basename(files
[0]);
11394 pstrcpy(objfilename
, sizeof(objfilename
), name
);
11395 ext
= tcc_fileextension(objfilename
);
11396 #ifdef TCC_TARGET_PE
11397 if (output_type
== TCC_OUTPUT_DLL
)
11398 strcpy(ext
, ".dll");
11400 if (output_type
== TCC_OUTPUT_EXE
)
11401 strcpy(ext
, ".exe");
11404 if (output_type
== TCC_OUTPUT_OBJ
&& !reloc_output
&& *ext
)
11407 pstrcpy(objfilename
, sizeof(objfilename
), "a.out");
11408 outfile
= objfilename
;
11413 start_time
= getclock_us();
11416 tcc_set_output_type(s
, output_type
);
11418 /* compile or add each files or library */
11419 for(i
= 0; i
< nb_files
&& ret
== 0; i
++) {
11420 const char *filename
;
11422 filename
= files
[i
];
11423 if (output_type
== TCC_OUTPUT_PREPROCESS
) {
11424 if (tcc_add_file_internal(s
, filename
,
11425 AFF_PRINT_ERROR
| AFF_PREPROCESS
) < 0)
11427 } else if (filename
[0] == '-' && filename
[1]) {
11428 if (tcc_add_library(s
, filename
+ 2) < 0)
11429 error("cannot find %s", filename
);
11432 printf("-> %s\n", filename
);
11433 if (tcc_add_file(s
, filename
) < 0)
11438 /* free all files */
11446 total_time
= (double)(getclock_us() - start_time
) / 1000000.0;
11447 if (total_time
< 0.001)
11448 total_time
= 0.001;
11449 if (total_bytes
< 1)
11451 printf("%d idents, %d lines, %d bytes, %0.3f s, %d lines/s, %0.1f MB/s\n",
11452 tok_ident
- TOK_IDENT
, total_lines
, total_bytes
,
11453 total_time
, (int)(total_lines
/ total_time
),
11454 total_bytes
/ total_time
/ 1000000.0);
11457 if (s
->output_type
== TCC_OUTPUT_PREPROCESS
) {
11459 fclose(s
->outfile
);
11460 } else if (s
->output_type
== TCC_OUTPUT_MEMORY
) {
11461 ret
= tcc_run(s
, argc
- optind
, argv
+ optind
);
11463 ret
= tcc_output_file(s
, outfile
) ? 1 : 0;
11465 /* XXX: cannot do it with bound checking because of the malloc hooks */
11466 if (!do_bounds_check
)
11471 printf("memory: %d bytes, max = %d bytes\n", mem_cur_size
, mem_max_size
);