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])))
1078 #define PATHCMP stricmp
1080 #define IS_PATHSEP(c) (c == '/')
1081 #define IS_ABSPATH(p) IS_PATHSEP(p[0])
1082 #define PATHCMP strcmp
1085 /* extract the basename of a file */
1086 static char *tcc_basename(const char *name
)
1088 char *p
= strchr(name
, 0);
1089 while (p
> name
&& !IS_PATHSEP(p
[-1]))
1094 static char *tcc_fileextension (const char *name
)
1096 char *b
= tcc_basename(name
);
1097 char *e
= strrchr(b
, '.');
1098 return e
? e
: strchr(b
, 0);
1102 char *normalize_slashes(char *path
)
1105 for (p
= path
; *p
; ++p
)
1111 char *w32_tcc_lib_path(void)
1113 /* on win32, we suppose the lib and includes are at the location
1115 char path
[1024], *p
;
1116 GetModuleFileNameA(NULL
, path
, sizeof path
);
1117 p
= tcc_basename(normalize_slashes(strlwr(path
)));
1118 if (p
- 5 > path
&& 0 == strncmp(p
- 5, "/bin/", 5))
1123 return strdup(path
);
1127 void set_pages_executable(void *ptr
, unsigned long length
)
1130 unsigned long old_protect
;
1131 VirtualProtect(ptr
, length
, PAGE_EXECUTE_READWRITE
, &old_protect
);
1133 unsigned long start
, end
;
1134 start
= (unsigned long)ptr
& ~(PAGESIZE
- 1);
1135 end
= (unsigned long)ptr
+ length
;
1136 end
= (end
+ PAGESIZE
- 1) & ~(PAGESIZE
- 1);
1137 mprotect((void *)start
, end
- start
, PROT_READ
| PROT_WRITE
| PROT_EXEC
);
1141 /* memory management */
1145 unsigned malloc_usable_size(void*);
1148 static inline void tcc_free(void *ptr
)
1151 mem_cur_size
-= malloc_usable_size(ptr
);
1156 static void *tcc_malloc(unsigned long size
)
1161 error("memory full");
1163 mem_cur_size
+= malloc_usable_size(ptr
);
1164 if (mem_cur_size
> mem_max_size
)
1165 mem_max_size
= mem_cur_size
;
1170 static void *tcc_mallocz(unsigned long size
)
1173 ptr
= tcc_malloc(size
);
1174 memset(ptr
, 0, size
);
1178 static inline void *tcc_realloc(void *ptr
, unsigned long size
)
1182 mem_cur_size
-= malloc_usable_size(ptr
);
1184 ptr1
= realloc(ptr
, size
);
1186 /* NOTE: count not correct if alloc error, but not critical */
1187 mem_cur_size
+= malloc_usable_size(ptr1
);
1188 if (mem_cur_size
> mem_max_size
)
1189 mem_max_size
= mem_cur_size
;
1194 static char *tcc_strdup(const char *str
)
1197 ptr
= tcc_malloc(strlen(str
) + 1);
1202 #define free(p) use_tcc_free(p)
1203 #define malloc(s) use_tcc_malloc(s)
1204 #define realloc(p, s) use_tcc_realloc(p, s)
1206 static void dynarray_add(void ***ptab
, int *nb_ptr
, void *data
)
1213 /* every power of two we double array size */
1214 if ((nb
& (nb
- 1)) == 0) {
1219 pp
= tcc_realloc(pp
, nb_alloc
* sizeof(void *));
1221 error("memory full");
1228 static void dynarray_reset(void *pp
, int *n
)
1231 for (p
= *(void***)pp
; *n
; ++p
, --*n
)
1234 tcc_free(*(void**)pp
);
1238 /* symbol allocator */
1239 static Sym
*__sym_malloc(void)
1241 Sym
*sym_pool
, *sym
, *last_sym
;
1244 sym_pool
= tcc_malloc(SYM_POOL_NB
* sizeof(Sym
));
1245 dynarray_add(&sym_pools
, &nb_sym_pools
, sym_pool
);
1247 last_sym
= sym_free_first
;
1249 for(i
= 0; i
< SYM_POOL_NB
; i
++) {
1250 sym
->next
= last_sym
;
1254 sym_free_first
= last_sym
;
1258 static inline Sym
*sym_malloc(void)
1261 sym
= sym_free_first
;
1263 sym
= __sym_malloc();
1264 sym_free_first
= sym
->next
;
1268 static inline void sym_free(Sym
*sym
)
1270 sym
->next
= sym_free_first
;
1271 sym_free_first
= sym
;
1274 Section
*new_section(TCCState
*s1
, const char *name
, int sh_type
, int sh_flags
)
1278 sec
= tcc_mallocz(sizeof(Section
) + strlen(name
));
1279 strcpy(sec
->name
, name
);
1280 sec
->sh_type
= sh_type
;
1281 sec
->sh_flags
= sh_flags
;
1289 sec
->sh_addralign
= 4;
1292 sec
->sh_addralign
= 1;
1295 sec
->sh_addralign
= 32; /* default conservative alignment */
1299 if (sh_flags
& SHF_PRIVATE
) {
1300 dynarray_add((void ***)&s1
->priv_sections
, &s1
->nb_priv_sections
, sec
);
1302 sec
->sh_num
= s1
->nb_sections
;
1303 dynarray_add((void ***)&s1
->sections
, &s1
->nb_sections
, sec
);
1309 static void free_section(Section
*s
)
1311 #ifdef TCC_TARGET_X86_64
1312 /* after tcc_relocate(), some sections share the data buffer.
1313 let's check if the data is allocated not to free the shared buffers */
1314 if (s
->data_allocated
)
1319 /* realloc section and set its content to zero */
1320 static void section_realloc(Section
*sec
, unsigned long new_size
)
1323 unsigned char *data
;
1325 size
= sec
->data_allocated
;
1328 while (size
< new_size
)
1330 data
= tcc_realloc(sec
->data
, size
);
1332 error("memory full");
1333 memset(data
+ sec
->data_allocated
, 0, size
- sec
->data_allocated
);
1335 sec
->data_allocated
= size
;
1338 /* reserve at least 'size' bytes in section 'sec' from
1339 sec->data_offset. */
1340 static void *section_ptr_add(Section
*sec
, unsigned long size
)
1342 unsigned long offset
, offset1
;
1344 offset
= sec
->data_offset
;
1345 offset1
= offset
+ size
;
1346 if (offset1
> sec
->data_allocated
)
1347 section_realloc(sec
, offset1
);
1348 sec
->data_offset
= offset1
;
1349 return sec
->data
+ offset
;
1352 /* return a reference to a section, and create it if it does not
1354 Section
*find_section(TCCState
*s1
, const char *name
)
1358 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1359 sec
= s1
->sections
[i
];
1360 if (!strcmp(name
, sec
->name
))
1363 /* sections are created as PROGBITS */
1364 return new_section(s1
, name
, SHT_PROGBITS
, SHF_ALLOC
);
1367 #define SECTION_ABS ((void *)1)
1369 /* update sym->c so that it points to an external symbol in section
1370 'section' with value 'value' */
1371 static void put_extern_sym2(Sym
*sym
, Section
*section
,
1372 unsigned long value
, unsigned long size
,
1373 int can_add_underscore
)
1375 int sym_type
, sym_bind
, sh_num
, info
, other
, attr
;
1380 if (section
== NULL
)
1382 else if (section
== SECTION_ABS
)
1385 sh_num
= section
->sh_num
;
1389 if ((sym
->type
.t
& VT_BTYPE
) == VT_FUNC
) {
1390 sym_type
= STT_FUNC
;
1391 #ifdef TCC_TARGET_PE
1393 attr
= sym
->type
.ref
->r
;
1394 if (FUNC_EXPORT(attr
))
1396 if (FUNC_CALL(attr
) == FUNC_STDCALL
)
1400 sym_type
= STT_OBJECT
;
1403 if (sym
->type
.t
& VT_STATIC
)
1404 sym_bind
= STB_LOCAL
;
1406 sym_bind
= STB_GLOBAL
;
1409 name
= get_tok_str(sym
->v
, NULL
);
1410 #ifdef CONFIG_TCC_BCHECK
1411 if (do_bounds_check
) {
1414 /* XXX: avoid doing that for statics ? */
1415 /* if bound checking is activated, we change some function
1416 names by adding the "__bound" prefix */
1419 /* XXX: we rely only on malloc hooks */
1432 strcpy(buf
, "__bound_");
1440 #ifdef TCC_TARGET_PE
1441 if ((other
& 2) && can_add_underscore
) {
1442 sprintf(buf1
, "_%s@%d", name
, FUNC_ARGS(attr
));
1446 if (tcc_state
->leading_underscore
&& can_add_underscore
) {
1448 pstrcpy(buf1
+ 1, sizeof(buf1
) - 1, name
);
1451 info
= ELFW(ST_INFO
)(sym_bind
, sym_type
);
1452 sym
->c
= add_elf_sym(symtab_section
, value
, size
, info
, other
, sh_num
, name
);
1454 esym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
];
1455 esym
->st_value
= value
;
1456 esym
->st_size
= size
;
1457 esym
->st_shndx
= sh_num
;
1458 esym
->st_other
|= other
;
1462 static void put_extern_sym(Sym
*sym
, Section
*section
,
1463 unsigned long value
, unsigned long size
)
1465 put_extern_sym2(sym
, section
, value
, size
, 1);
1468 /* add a new relocation entry to symbol 'sym' in section 's' */
1469 static void greloc(Section
*s
, Sym
*sym
, unsigned long offset
, int type
)
1472 put_extern_sym(sym
, NULL
, 0, 0);
1473 /* now we can add ELF relocation info */
1474 put_elf_reloc(symtab_section
, s
, offset
, type
, sym
->c
);
1477 static inline int isid(int c
)
1479 return (c
>= 'a' && c
<= 'z') ||
1480 (c
>= 'A' && c
<= 'Z') ||
1484 static inline int isnum(int c
)
1486 return c
>= '0' && c
<= '9';
1489 static inline int isoct(int c
)
1491 return c
>= '0' && c
<= '7';
1494 static inline int toup(int c
)
1496 if (c
>= 'a' && c
<= 'z')
1497 return c
- 'a' + 'A';
1502 static void strcat_vprintf(char *buf
, int buf_size
, const char *fmt
, va_list ap
)
1506 vsnprintf(buf
+ len
, buf_size
- len
, fmt
, ap
);
1509 static void strcat_printf(char *buf
, int buf_size
, const char *fmt
, ...)
1513 strcat_vprintf(buf
, buf_size
, fmt
, ap
);
1517 void error1(TCCState
*s1
, int is_warning
, const char *fmt
, va_list ap
)
1524 for(f
= s1
->include_stack
; f
< s1
->include_stack_ptr
; f
++)
1525 strcat_printf(buf
, sizeof(buf
), "In file included from %s:%d:\n",
1526 (*f
)->filename
, (*f
)->line_num
);
1527 if (file
->line_num
> 0) {
1528 strcat_printf(buf
, sizeof(buf
),
1529 "%s:%d: ", file
->filename
, file
->line_num
);
1531 strcat_printf(buf
, sizeof(buf
),
1532 "%s: ", file
->filename
);
1535 strcat_printf(buf
, sizeof(buf
),
1539 strcat_printf(buf
, sizeof(buf
), "warning: ");
1540 strcat_vprintf(buf
, sizeof(buf
), fmt
, ap
);
1542 if (!s1
->error_func
) {
1543 /* default case: stderr */
1544 fprintf(stderr
, "%s\n", buf
);
1546 s1
->error_func(s1
->error_opaque
, buf
);
1548 if (!is_warning
|| s1
->warn_error
)
1553 void tcc_set_error_func(TCCState
*s
, void *error_opaque
,
1554 void (*error_func
)(void *opaque
, const char *msg
))
1556 s
->error_opaque
= error_opaque
;
1557 s
->error_func
= error_func
;
1561 /* error without aborting current compilation */
1562 void error_noabort(const char *fmt
, ...)
1564 TCCState
*s1
= tcc_state
;
1568 error1(s1
, 0, fmt
, ap
);
1572 void error(const char *fmt
, ...)
1574 TCCState
*s1
= tcc_state
;
1578 error1(s1
, 0, fmt
, ap
);
1580 /* better than nothing: in some cases, we accept to handle errors */
1581 if (s1
->error_set_jmp_enabled
) {
1582 longjmp(s1
->error_jmp_buf
, 1);
1584 /* XXX: eliminate this someday */
1589 void expect(const char *msg
)
1591 error("%s expected", msg
);
1594 void warning(const char *fmt
, ...)
1596 TCCState
*s1
= tcc_state
;
1603 error1(s1
, 1, fmt
, ap
);
1610 error("'%c' expected", c
);
1614 static void test_lvalue(void)
1616 if (!(vtop
->r
& VT_LVAL
))
1620 /* allocate a new token */
1621 static TokenSym
*tok_alloc_new(TokenSym
**pts
, const char *str
, int len
)
1623 TokenSym
*ts
, **ptable
;
1626 if (tok_ident
>= SYM_FIRST_ANOM
)
1627 error("memory full");
1629 /* expand token table if needed */
1630 i
= tok_ident
- TOK_IDENT
;
1631 if ((i
% TOK_ALLOC_INCR
) == 0) {
1632 ptable
= tcc_realloc(table_ident
, (i
+ TOK_ALLOC_INCR
) * sizeof(TokenSym
*));
1634 error("memory full");
1635 table_ident
= ptable
;
1638 ts
= tcc_malloc(sizeof(TokenSym
) + len
);
1639 table_ident
[i
] = ts
;
1640 ts
->tok
= tok_ident
++;
1641 ts
->sym_define
= NULL
;
1642 ts
->sym_label
= NULL
;
1643 ts
->sym_struct
= NULL
;
1644 ts
->sym_identifier
= NULL
;
1646 ts
->hash_next
= NULL
;
1647 memcpy(ts
->str
, str
, len
);
1648 ts
->str
[len
] = '\0';
1653 #define TOK_HASH_INIT 1
1654 #define TOK_HASH_FUNC(h, c) ((h) * 263 + (c))
1656 /* find a token and add it if not found */
1657 static TokenSym
*tok_alloc(const char *str
, int len
)
1659 TokenSym
*ts
, **pts
;
1665 h
= TOK_HASH_FUNC(h
, ((unsigned char *)str
)[i
]);
1666 h
&= (TOK_HASH_SIZE
- 1);
1668 pts
= &hash_ident
[h
];
1673 if (ts
->len
== len
&& !memcmp(ts
->str
, str
, len
))
1675 pts
= &(ts
->hash_next
);
1677 return tok_alloc_new(pts
, str
, len
);
1680 /* CString handling */
1682 static void cstr_realloc(CString
*cstr
, int new_size
)
1687 size
= cstr
->size_allocated
;
1689 size
= 8; /* no need to allocate a too small first string */
1690 while (size
< new_size
)
1692 data
= tcc_realloc(cstr
->data_allocated
, size
);
1694 error("memory full");
1695 cstr
->data_allocated
= data
;
1696 cstr
->size_allocated
= size
;
1701 static inline void cstr_ccat(CString
*cstr
, int ch
)
1704 size
= cstr
->size
+ 1;
1705 if (size
> cstr
->size_allocated
)
1706 cstr_realloc(cstr
, size
);
1707 ((unsigned char *)cstr
->data
)[size
- 1] = ch
;
1711 static void cstr_cat(CString
*cstr
, const char *str
)
1723 /* add a wide char */
1724 static void cstr_wccat(CString
*cstr
, int ch
)
1727 size
= cstr
->size
+ sizeof(nwchar_t
);
1728 if (size
> cstr
->size_allocated
)
1729 cstr_realloc(cstr
, size
);
1730 *(nwchar_t
*)(((unsigned char *)cstr
->data
) + size
- sizeof(nwchar_t
)) = ch
;
1734 static void cstr_new(CString
*cstr
)
1736 memset(cstr
, 0, sizeof(CString
));
1739 /* free string and reset it to NULL */
1740 static void cstr_free(CString
*cstr
)
1742 tcc_free(cstr
->data_allocated
);
1746 #define cstr_reset(cstr) cstr_free(cstr)
1748 /* XXX: unicode ? */
1749 static void add_char(CString
*cstr
, int c
)
1751 if (c
== '\'' || c
== '\"' || c
== '\\') {
1752 /* XXX: could be more precise if char or string */
1753 cstr_ccat(cstr
, '\\');
1755 if (c
>= 32 && c
<= 126) {
1758 cstr_ccat(cstr
, '\\');
1760 cstr_ccat(cstr
, 'n');
1762 cstr_ccat(cstr
, '0' + ((c
>> 6) & 7));
1763 cstr_ccat(cstr
, '0' + ((c
>> 3) & 7));
1764 cstr_ccat(cstr
, '0' + (c
& 7));
1769 /* XXX: buffer overflow */
1770 /* XXX: float tokens */
1771 char *get_tok_str(int v
, CValue
*cv
)
1773 static char buf
[STRING_MAX_SIZE
+ 1];
1774 static CString cstr_buf
;
1780 /* NOTE: to go faster, we give a fixed buffer for small strings */
1781 cstr_reset(&cstr_buf
);
1782 cstr_buf
.data
= buf
;
1783 cstr_buf
.size_allocated
= sizeof(buf
);
1789 /* XXX: not quite exact, but only useful for testing */
1790 sprintf(p
, "%u", cv
->ui
);
1794 /* XXX: not quite exact, but only useful for testing */
1795 sprintf(p
, "%Lu", cv
->ull
);
1798 cstr_ccat(&cstr_buf
, 'L');
1800 cstr_ccat(&cstr_buf
, '\'');
1801 add_char(&cstr_buf
, cv
->i
);
1802 cstr_ccat(&cstr_buf
, '\'');
1803 cstr_ccat(&cstr_buf
, '\0');
1807 len
= cstr
->size
- 1;
1809 add_char(&cstr_buf
, ((unsigned char *)cstr
->data
)[i
]);
1810 cstr_ccat(&cstr_buf
, '\0');
1813 cstr_ccat(&cstr_buf
, 'L');
1816 cstr_ccat(&cstr_buf
, '\"');
1818 len
= cstr
->size
- 1;
1820 add_char(&cstr_buf
, ((unsigned char *)cstr
->data
)[i
]);
1822 len
= (cstr
->size
/ sizeof(nwchar_t
)) - 1;
1824 add_char(&cstr_buf
, ((nwchar_t
*)cstr
->data
)[i
]);
1826 cstr_ccat(&cstr_buf
, '\"');
1827 cstr_ccat(&cstr_buf
, '\0');
1836 return strcpy(p
, "...");
1838 return strcpy(p
, "<<=");
1840 return strcpy(p
, ">>=");
1842 if (v
< TOK_IDENT
) {
1843 /* search in two bytes table */
1857 } else if (v
< tok_ident
) {
1858 return table_ident
[v
- TOK_IDENT
]->str
;
1859 } else if (v
>= SYM_FIRST_ANOM
) {
1860 /* special name for anonymous symbol */
1861 sprintf(p
, "L.%u", v
- SYM_FIRST_ANOM
);
1863 /* should never happen */
1868 return cstr_buf
.data
;
1871 /* push, without hashing */
1872 static Sym
*sym_push2(Sym
**ps
, int v
, int t
, long c
)
1886 /* find a symbol and return its associated structure. 's' is the top
1887 of the symbol stack */
1888 static Sym
*sym_find2(Sym
*s
, int v
)
1898 /* structure lookup */
1899 static inline Sym
*struct_find(int v
)
1902 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1904 return table_ident
[v
]->sym_struct
;
1907 /* find an identifier */
1908 static inline Sym
*sym_find(int v
)
1911 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1913 return table_ident
[v
]->sym_identifier
;
1916 /* push a given symbol on the symbol stack */
1917 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
)
1926 s
= sym_push2(ps
, v
, type
->t
, c
);
1927 s
->type
.ref
= type
->ref
;
1929 /* don't record fields or anonymous symbols */
1931 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1932 /* record symbol in token array */
1933 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1935 ps
= &ts
->sym_struct
;
1937 ps
= &ts
->sym_identifier
;
1944 /* push a global identifier */
1945 static Sym
*global_identifier_push(int v
, int t
, int c
)
1948 s
= sym_push2(&global_stack
, v
, t
, c
);
1949 /* don't record anonymous symbol */
1950 if (v
< SYM_FIRST_ANOM
) {
1951 ps
= &table_ident
[v
- TOK_IDENT
]->sym_identifier
;
1952 /* modify the top most local identifier, so that
1953 sym_identifier will point to 's' when popped */
1955 ps
= &(*ps
)->prev_tok
;
1962 /* pop symbols until top reaches 'b' */
1963 static void sym_pop(Sym
**ptop
, Sym
*b
)
1973 /* remove symbol in token array */
1975 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1976 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1978 ps
= &ts
->sym_struct
;
1980 ps
= &ts
->sym_identifier
;
1991 BufferedFile
*tcc_open(TCCState
*s1
, const char *filename
)
1996 if (strcmp(filename
, "-") == 0)
1997 fd
= 0, filename
= "stdin";
1999 fd
= open(filename
, O_RDONLY
| O_BINARY
);
2000 if ((verbose
== 2 && fd
>= 0) || verbose
== 3)
2001 printf("%s %*s%s\n", fd
< 0 ? "nf":"->",
2002 (s1
->include_stack_ptr
- s1
->include_stack
), "", filename
);
2005 bf
= tcc_malloc(sizeof(BufferedFile
));
2007 bf
->buf_ptr
= bf
->buffer
;
2008 bf
->buf_end
= bf
->buffer
;
2009 bf
->buffer
[0] = CH_EOB
; /* put eob symbol */
2010 pstrcpy(bf
->filename
, sizeof(bf
->filename
), filename
);
2012 normalize_slashes(bf
->filename
);
2015 bf
->ifndef_macro
= 0;
2016 bf
->ifdef_stack_ptr
= s1
->ifdef_stack_ptr
;
2017 // printf("opening '%s'\n", filename);
2021 void tcc_close(BufferedFile
*bf
)
2023 total_lines
+= bf
->line_num
;
2028 /* fill input buffer and peek next char */
2029 static int tcc_peekc_slow(BufferedFile
*bf
)
2032 /* only tries to read if really end of buffer */
2033 if (bf
->buf_ptr
>= bf
->buf_end
) {
2035 #if defined(PARSE_DEBUG)
2040 len
= read(bf
->fd
, bf
->buffer
, len
);
2047 bf
->buf_ptr
= bf
->buffer
;
2048 bf
->buf_end
= bf
->buffer
+ len
;
2049 *bf
->buf_end
= CH_EOB
;
2051 if (bf
->buf_ptr
< bf
->buf_end
) {
2052 return bf
->buf_ptr
[0];
2054 bf
->buf_ptr
= bf
->buf_end
;
2059 /* return the current character, handling end of block if necessary
2061 static int handle_eob(void)
2063 return tcc_peekc_slow(file
);
2066 /* read next char from current input file and handle end of input buffer */
2067 static inline void inp(void)
2069 ch
= *(++(file
->buf_ptr
));
2070 /* end of buffer/file handling */
2075 /* handle '\[\r]\n' */
2076 static int handle_stray_noerror(void)
2078 while (ch
== '\\') {
2083 } else if (ch
== '\r') {
2097 static void handle_stray(void)
2099 if (handle_stray_noerror())
2100 error("stray '\\' in program");
2103 /* skip the stray and handle the \\n case. Output an error if
2104 incorrect char after the stray */
2105 static int handle_stray1(uint8_t *p
)
2109 if (p
>= file
->buf_end
) {
2126 /* handle just the EOB case, but not stray */
2127 #define PEEKC_EOB(c, p)\
2138 /* handle the complicated stray case */
2139 #define PEEKC(c, p)\
2144 c = handle_stray1(p);\
2149 /* input with '\[\r]\n' handling. Note that this function cannot
2150 handle other characters after '\', so you cannot call it inside
2151 strings or comments */
2152 static void minp(void)
2160 /* single line C++ comments */
2161 static uint8_t *parse_line_comment(uint8_t *p
)
2169 if (c
== '\n' || c
== CH_EOF
) {
2171 } else if (c
== '\\') {
2180 } else if (c
== '\r') {
2198 static uint8_t *parse_comment(uint8_t *p
)
2204 /* fast skip loop */
2207 if (c
== '\n' || c
== '*' || c
== '\\')
2211 if (c
== '\n' || c
== '*' || c
== '\\')
2215 /* now we can handle all the cases */
2219 } else if (c
== '*') {
2225 } else if (c
== '/') {
2226 goto end_of_comment
;
2227 } else if (c
== '\\') {
2232 /* skip '\[\r]\n', otherwise just skip the stray */
2238 } else if (c
== '\r') {
2255 /* stray, eob or eof */
2260 error("unexpected end of file in comment");
2261 } else if (c
== '\\') {
2273 /* space exlcuding newline */
2274 static inline int is_space(int ch
)
2276 return ch
== ' ' || ch
== '\t' || ch
== '\v' || ch
== '\f' || ch
== '\r';
2279 static inline void skip_spaces(void)
2281 while (is_space(ch
))
2285 /* parse a string without interpreting escapes */
2286 static uint8_t *parse_pp_string(uint8_t *p
,
2287 int sep
, CString
*str
)
2295 } else if (c
== '\\') {
2300 unterminated_string
:
2301 /* XXX: indicate line number of start of string */
2302 error("missing terminating %c character", sep
);
2303 } else if (c
== '\\') {
2304 /* escape : just skip \[\r]\n */
2309 } else if (c
== '\r') {
2312 expect("'\n' after '\r'");
2315 } else if (c
== CH_EOF
) {
2316 goto unterminated_string
;
2319 cstr_ccat(str
, '\\');
2325 } else if (c
== '\n') {
2328 } else if (c
== '\r') {
2332 cstr_ccat(str
, '\r');
2348 /* skip block of text until #else, #elif or #endif. skip also pairs of
2350 void preprocess_skip(void)
2352 int a
, start_of_line
, c
, in_warn_or_error
;
2359 in_warn_or_error
= 0;
2380 } else if (c
== '\\') {
2381 ch
= file
->buf_ptr
[0];
2382 handle_stray_noerror();
2389 if (in_warn_or_error
)
2391 p
= parse_pp_string(p
, c
, NULL
);
2395 if (in_warn_or_error
)
2402 p
= parse_comment(p
);
2403 } else if (ch
== '/') {
2404 p
= parse_line_comment(p
);
2409 if (start_of_line
) {
2414 (tok
== TOK_ELSE
|| tok
== TOK_ELIF
|| tok
== TOK_ENDIF
))
2416 if (tok
== TOK_IF
|| tok
== TOK_IFDEF
|| tok
== TOK_IFNDEF
)
2418 else if (tok
== TOK_ENDIF
)
2420 else if( tok
== TOK_ERROR
|| tok
== TOK_WARNING
)
2421 in_warn_or_error
= 1;
2435 /* ParseState handling */
2437 /* XXX: currently, no include file info is stored. Thus, we cannot display
2438 accurate messages if the function or data definition spans multiple
2441 /* save current parse state in 's' */
2442 void save_parse_state(ParseState
*s
)
2444 s
->line_num
= file
->line_num
;
2445 s
->macro_ptr
= macro_ptr
;
2450 /* restore parse state from 's' */
2451 void restore_parse_state(ParseState
*s
)
2453 file
->line_num
= s
->line_num
;
2454 macro_ptr
= s
->macro_ptr
;
2459 /* return the number of additional 'ints' necessary to store the
2461 static inline int tok_ext_size(int t
)
2475 error("unsupported token");
2482 return LDOUBLE_SIZE
/ 4;
2488 /* token string handling */
2490 static inline void tok_str_new(TokenString
*s
)
2494 s
->allocated_len
= 0;
2495 s
->last_line_num
= -1;
2498 static void tok_str_free(int *str
)
2503 static int *tok_str_realloc(TokenString
*s
)
2507 if (s
->allocated_len
== 0) {
2510 len
= s
->allocated_len
* 2;
2512 str
= tcc_realloc(s
->str
, len
* sizeof(int));
2514 error("memory full");
2515 s
->allocated_len
= len
;
2520 static void tok_str_add(TokenString
*s
, int t
)
2526 if (len
>= s
->allocated_len
)
2527 str
= tok_str_realloc(s
);
2532 static void tok_str_add2(TokenString
*s
, int t
, CValue
*cv
)
2539 /* allocate space for worst case */
2540 if (len
+ TOK_MAX_SIZE
> s
->allocated_len
)
2541 str
= tok_str_realloc(s
);
2550 str
[len
++] = cv
->tab
[0];
2559 nb_words
= (sizeof(CString
) + cv
->cstr
->size
+ 3) >> 2;
2560 while ((len
+ nb_words
) > s
->allocated_len
)
2561 str
= tok_str_realloc(s
);
2562 cstr
= (CString
*)(str
+ len
);
2564 cstr
->size
= cv
->cstr
->size
;
2565 cstr
->data_allocated
= NULL
;
2566 cstr
->size_allocated
= cstr
->size
;
2567 memcpy((char *)cstr
+ sizeof(CString
),
2568 cv
->cstr
->data
, cstr
->size
);
2575 #if LDOUBLE_SIZE == 8
2578 str
[len
++] = cv
->tab
[0];
2579 str
[len
++] = cv
->tab
[1];
2581 #if LDOUBLE_SIZE == 12
2583 str
[len
++] = cv
->tab
[0];
2584 str
[len
++] = cv
->tab
[1];
2585 str
[len
++] = cv
->tab
[2];
2586 #elif LDOUBLE_SIZE == 16
2588 str
[len
++] = cv
->tab
[0];
2589 str
[len
++] = cv
->tab
[1];
2590 str
[len
++] = cv
->tab
[2];
2591 str
[len
++] = cv
->tab
[3];
2592 #elif LDOUBLE_SIZE != 8
2593 #error add long double size support
2602 /* add the current parse token in token string 's' */
2603 static void tok_str_add_tok(TokenString
*s
)
2607 /* save line number info */
2608 if (file
->line_num
!= s
->last_line_num
) {
2609 s
->last_line_num
= file
->line_num
;
2610 cval
.i
= s
->last_line_num
;
2611 tok_str_add2(s
, TOK_LINENUM
, &cval
);
2613 tok_str_add2(s
, tok
, &tokc
);
2616 #if LDOUBLE_SIZE == 16
2617 #define LDOUBLE_GET(p, cv) \
2622 #elif LDOUBLE_SIZE == 12
2623 #define LDOUBLE_GET(p, cv) \
2627 #elif LDOUBLE_SIZE == 8
2628 #define LDOUBLE_GET(p, cv) \
2632 #error add long double size support
2636 /* get a token from an integer array and increment pointer
2637 accordingly. we code it as a macro to avoid pointer aliasing. */
2638 #define TOK_GET(t, p, cv) \
2653 cv.cstr = (CString *)p; \
2654 cv.cstr->data = (char *)p + sizeof(CString);\
2655 p += (sizeof(CString) + cv.cstr->size + 3) >> 2;\
2664 case TOK_CLDOUBLE: \
2665 LDOUBLE_GET(p, cv); \
2666 p += LDOUBLE_SIZE / 4; \
2673 /* defines handling */
2674 static inline void define_push(int v
, int macro_type
, int *str
, Sym
*first_arg
)
2678 s
= sym_push2(&define_stack
, v
, macro_type
, (long)str
);
2679 s
->next
= first_arg
;
2680 table_ident
[v
- TOK_IDENT
]->sym_define
= s
;
2683 /* undefined a define symbol. Its name is just set to zero */
2684 static void define_undef(Sym
*s
)
2688 if (v
>= TOK_IDENT
&& v
< tok_ident
)
2689 table_ident
[v
- TOK_IDENT
]->sym_define
= NULL
;
2693 static inline Sym
*define_find(int v
)
2696 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
2698 return table_ident
[v
]->sym_define
;
2701 /* free define stack until top reaches 'b' */
2702 static void free_defines(Sym
*b
)
2710 /* do not free args or predefined defines */
2712 tok_str_free((int *)top
->c
);
2714 if (v
>= TOK_IDENT
&& v
< tok_ident
)
2715 table_ident
[v
- TOK_IDENT
]->sym_define
= NULL
;
2723 static Sym
*label_find(int v
)
2726 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
2728 return table_ident
[v
]->sym_label
;
2731 static Sym
*label_push(Sym
**ptop
, int v
, int flags
)
2734 s
= sym_push2(ptop
, v
, 0, 0);
2736 ps
= &table_ident
[v
- TOK_IDENT
]->sym_label
;
2737 if (ptop
== &global_label_stack
) {
2738 /* modify the top most local identifier, so that
2739 sym_identifier will point to 's' when popped */
2741 ps
= &(*ps
)->prev_tok
;
2748 /* pop labels until element last is reached. Look if any labels are
2749 undefined. Define symbols if '&&label' was used. */
2750 static void label_pop(Sym
**ptop
, Sym
*slast
)
2753 for(s
= *ptop
; s
!= slast
; s
= s1
) {
2755 if (s
->r
== LABEL_DECLARED
) {
2756 warning("label '%s' declared but not used", get_tok_str(s
->v
, NULL
));
2757 } else if (s
->r
== LABEL_FORWARD
) {
2758 error("label '%s' used but not defined",
2759 get_tok_str(s
->v
, NULL
));
2762 /* define corresponding symbol. A size of
2764 put_extern_sym(s
, cur_text_section
, (long)s
->next
, 1);
2768 table_ident
[s
->v
- TOK_IDENT
]->sym_label
= s
->prev_tok
;
2774 /* eval an expression for #if/#elif */
2775 static int expr_preprocess(void)
2781 while (tok
!= TOK_LINEFEED
&& tok
!= TOK_EOF
) {
2782 next(); /* do macro subst */
2783 if (tok
== TOK_DEFINED
) {
2788 c
= define_find(tok
) != 0;
2793 } else if (tok
>= TOK_IDENT
) {
2794 /* if undefined macro */
2798 tok_str_add_tok(&str
);
2800 tok_str_add(&str
, -1); /* simulate end of file */
2801 tok_str_add(&str
, 0);
2802 /* now evaluate C constant expression */
2803 macro_ptr
= str
.str
;
2807 tok_str_free(str
.str
);
2811 #if defined(PARSE_DEBUG) || defined(PP_DEBUG)
2812 static void tok_print(int *str
)
2818 TOK_GET(t
, str
, cval
);
2821 printf(" %s", get_tok_str(t
, &cval
));
2827 /* parse after #define */
2828 static void parse_define(void)
2830 Sym
*s
, *first
, **ps
;
2831 int v
, t
, varg
, is_vaargs
, c
;
2836 error("invalid macro name '%s'", get_tok_str(tok
, &tokc
));
2837 /* XXX: should check if same macro (ANSI) */
2840 /* '(' must be just after macro definition for MACRO_FUNC */
2841 c
= file
->buf_ptr
[0];
2843 c
= handle_stray1(file
->buf_ptr
);
2848 while (tok
!= ')') {
2852 if (varg
== TOK_DOTS
) {
2853 varg
= TOK___VA_ARGS__
;
2855 } else if (tok
== TOK_DOTS
&& gnu_ext
) {
2859 if (varg
< TOK_IDENT
)
2860 error("badly punctuated parameter list");
2861 s
= sym_push2(&define_stack
, varg
| SYM_FIELD
, is_vaargs
, 0);
2872 /* EOF testing necessary for '-D' handling */
2873 while (tok
!= TOK_LINEFEED
&& tok
!= TOK_EOF
) {
2874 tok_str_add2(&str
, tok
, &tokc
);
2877 tok_str_add(&str
, 0);
2879 printf("define %s %d: ", get_tok_str(v
, NULL
), t
);
2882 define_push(v
, t
, str
.str
, first
);
2885 static inline int hash_cached_include(int type
, const char *filename
)
2887 const unsigned char *s
;
2891 h
= TOK_HASH_FUNC(h
, type
);
2894 h
= TOK_HASH_FUNC(h
, *s
);
2897 h
&= (CACHED_INCLUDES_HASH_SIZE
- 1);
2901 /* XXX: use a token or a hash table to accelerate matching ? */
2902 static CachedInclude
*search_cached_include(TCCState
*s1
,
2903 int type
, const char *filename
)
2907 h
= hash_cached_include(type
, filename
);
2908 i
= s1
->cached_includes_hash
[h
];
2912 e
= s1
->cached_includes
[i
- 1];
2913 if (e
->type
== type
&& !PATHCMP(e
->filename
, filename
))
2920 static inline void add_cached_include(TCCState
*s1
, int type
,
2921 const char *filename
, int ifndef_macro
)
2926 if (search_cached_include(s1
, type
, filename
))
2929 printf("adding cached '%s' %s\n", filename
, get_tok_str(ifndef_macro
, NULL
));
2931 e
= tcc_malloc(sizeof(CachedInclude
) + strlen(filename
));
2935 strcpy(e
->filename
, filename
);
2936 e
->ifndef_macro
= ifndef_macro
;
2937 dynarray_add((void ***)&s1
->cached_includes
, &s1
->nb_cached_includes
, e
);
2938 /* add in hash table */
2939 h
= hash_cached_include(type
, filename
);
2940 e
->hash_next
= s1
->cached_includes_hash
[h
];
2941 s1
->cached_includes_hash
[h
] = s1
->nb_cached_includes
;
2944 static void pragma_parse(TCCState
*s1
)
2949 if (tok
== TOK_pack
) {
2952 #pragma pack(1) // set
2953 #pragma pack() // reset to default
2954 #pragma pack(push,1) // push & set
2955 #pragma pack(pop) // restore previous
2959 if (tok
== TOK_ASM_pop
) {
2961 if (s1
->pack_stack_ptr
<= s1
->pack_stack
) {
2963 error("out of pack stack");
2965 s1
->pack_stack_ptr
--;
2969 if (tok
== TOK_ASM_push
) {
2971 if (s1
->pack_stack_ptr
>= s1
->pack_stack
+ PACK_STACK_SIZE
- 1)
2973 s1
->pack_stack_ptr
++;
2976 if (tok
!= TOK_CINT
) {
2978 error("invalid pack pragma");
2981 if (val
< 1 || val
> 16 || (val
& (val
- 1)) != 0)
2985 *s1
->pack_stack_ptr
= val
;
2991 /* is_bof is true if first non space token at beginning of file */
2992 static void preprocess(int is_bof
)
2994 TCCState
*s1
= tcc_state
;
2995 int size
, i
, c
, n
, saved_parse_flags
;
3002 saved_parse_flags
= parse_flags
;
3003 parse_flags
= PARSE_FLAG_PREPROCESS
| PARSE_FLAG_TOK_NUM
|
3004 PARSE_FLAG_LINEFEED
;
3014 s
= define_find(tok
);
3015 /* undefine symbol by putting an invalid name */
3020 case TOK_INCLUDE_NEXT
:
3021 ch
= file
->buf_ptr
[0];
3022 /* XXX: incorrect if comments : use next_nomacro with a special mode */
3027 } else if (ch
== '\"') {
3032 while (ch
!= c
&& ch
!= '\n' && ch
!= CH_EOF
) {
3033 if ((q
- buf
) < sizeof(buf
) - 1)
3036 if (handle_stray_noerror() == 0)
3044 /* eat all spaces and comments after include */
3045 /* XXX: slightly incorrect */
3046 while (ch1
!= '\n' && ch1
!= CH_EOF
)
3050 /* computed #include : either we have only strings or
3051 we have anything enclosed in '<>' */
3054 if (tok
== TOK_STR
) {
3055 while (tok
!= TOK_LINEFEED
) {
3056 if (tok
!= TOK_STR
) {
3058 error("'#include' expects \"FILENAME\" or <FILENAME>");
3060 pstrcat(buf
, sizeof(buf
), (char *)tokc
.cstr
->data
);
3066 while (tok
!= TOK_LINEFEED
) {
3067 pstrcat(buf
, sizeof(buf
), get_tok_str(tok
, &tokc
));
3071 /* check syntax and remove '<>' */
3072 if (len
< 2 || buf
[0] != '<' || buf
[len
- 1] != '>')
3073 goto include_syntax
;
3074 memmove(buf
, buf
+ 1, len
- 2);
3075 buf
[len
- 2] = '\0';
3080 e
= search_cached_include(s1
, c
, buf
);
3081 if (e
&& define_find(e
->ifndef_macro
)) {
3082 /* no need to parse the include because the 'ifndef macro'
3085 printf("%s: skipping %s\n", file
->filename
, buf
);
3088 if (s1
->include_stack_ptr
>= s1
->include_stack
+ INCLUDE_STACK_SIZE
)
3089 error("#include recursion too deep");
3090 /* push current file in stack */
3091 /* XXX: fix current line init */
3092 *s1
->include_stack_ptr
++ = file
;
3094 /* check absolute include path */
3095 if (IS_ABSPATH(buf
)) {
3096 f
= tcc_open(s1
, buf
);
3101 /* first search in current dir if "header.h" */
3102 size
= tcc_basename(file
->filename
) - file
->filename
;
3103 if (size
> sizeof(buf1
) - 1)
3104 size
= sizeof(buf1
) - 1;
3105 memcpy(buf1
, file
->filename
, size
);
3107 pstrcat(buf1
, sizeof(buf1
), buf
);
3108 f
= tcc_open(s1
, buf1
);
3110 if (tok
== TOK_INCLUDE_NEXT
)
3116 /* now search in all the include paths */
3117 n
= s1
->nb_include_paths
+ s1
->nb_sysinclude_paths
;
3118 for(i
= 0; i
< n
; i
++) {
3120 if (i
< s1
->nb_include_paths
)
3121 path
= s1
->include_paths
[i
];
3123 path
= s1
->sysinclude_paths
[i
- s1
->nb_include_paths
];
3124 pstrcpy(buf1
, sizeof(buf1
), path
);
3125 pstrcat(buf1
, sizeof(buf1
), "/");
3126 pstrcat(buf1
, sizeof(buf1
), buf
);
3127 f
= tcc_open(s1
, buf1
);
3129 if (tok
== TOK_INCLUDE_NEXT
)
3135 --s1
->include_stack_ptr
;
3136 error("include file '%s' not found", buf
);
3140 printf("%s: including %s\n", file
->filename
, buf1
);
3143 pstrcpy(f
->inc_filename
, sizeof(f
->inc_filename
), buf
);
3145 /* add include file debug info */
3147 put_stabs(file
->filename
, N_BINCL
, 0, 0, 0);
3149 tok_flags
|= TOK_FLAG_BOF
| TOK_FLAG_BOL
;
3150 ch
= file
->buf_ptr
[0];
3158 c
= expr_preprocess();
3164 if (tok
< TOK_IDENT
)
3165 error("invalid argument for '#if%sdef'", c
? "n" : "");
3169 printf("#ifndef %s\n", get_tok_str(tok
, NULL
));
3171 file
->ifndef_macro
= tok
;
3174 c
= (define_find(tok
) != 0) ^ c
;
3176 if (s1
->ifdef_stack_ptr
>= s1
->ifdef_stack
+ IFDEF_STACK_SIZE
)
3177 error("memory full");
3178 *s1
->ifdef_stack_ptr
++ = c
;
3181 if (s1
->ifdef_stack_ptr
== s1
->ifdef_stack
)
3182 error("#else without matching #if");
3183 if (s1
->ifdef_stack_ptr
[-1] & 2)
3184 error("#else after #else");
3185 c
= (s1
->ifdef_stack_ptr
[-1] ^= 3);
3188 if (s1
->ifdef_stack_ptr
== s1
->ifdef_stack
)
3189 error("#elif without matching #if");
3190 c
= s1
->ifdef_stack_ptr
[-1];
3192 error("#elif after #else");
3193 /* last #if/#elif expression was true: we skip */
3196 c
= expr_preprocess();
3197 s1
->ifdef_stack_ptr
[-1] = c
;
3207 if (s1
->ifdef_stack_ptr
<= file
->ifdef_stack_ptr
)
3208 error("#endif without matching #if");
3209 s1
->ifdef_stack_ptr
--;
3210 /* '#ifndef macro' was at the start of file. Now we check if
3211 an '#endif' is exactly at the end of file */
3212 if (file
->ifndef_macro
&&
3213 s1
->ifdef_stack_ptr
== file
->ifdef_stack_ptr
) {
3214 file
->ifndef_macro_saved
= file
->ifndef_macro
;
3215 /* need to set to zero to avoid false matches if another
3216 #ifndef at middle of file */
3217 file
->ifndef_macro
= 0;
3218 while (tok
!= TOK_LINEFEED
)
3220 tok_flags
|= TOK_FLAG_ENDIF
;
3226 if (tok
!= TOK_CINT
)
3228 file
->line_num
= tokc
.i
- 1; /* the line number will be incremented after */
3230 if (tok
!= TOK_LINEFEED
) {
3233 pstrcpy(file
->filename
, sizeof(file
->filename
),
3234 (char *)tokc
.cstr
->data
);
3240 ch
= file
->buf_ptr
[0];
3243 while (ch
!= '\n' && ch
!= CH_EOF
) {
3244 if ((q
- buf
) < sizeof(buf
) - 1)
3247 if (handle_stray_noerror() == 0)
3254 error("#error %s", buf
);
3256 warning("#warning %s", buf
);
3262 if (tok
== TOK_LINEFEED
|| tok
== '!' || tok
== TOK_CINT
) {
3263 /* '!' is ignored to allow C scripts. numbers are ignored
3264 to emulate cpp behaviour */
3266 if (!(saved_parse_flags
& PARSE_FLAG_ASM_COMMENTS
))
3267 warning("Ignoring unknown preprocessing directive #%s", get_tok_str(tok
, &tokc
));
3271 /* ignore other preprocess commands or #! for C scripts */
3272 while (tok
!= TOK_LINEFEED
)
3275 parse_flags
= saved_parse_flags
;
3278 /* evaluate escape codes in a string. */
3279 static void parse_escape_string(CString
*outstr
, const uint8_t *buf
, int is_long
)
3294 case '0': case '1': case '2': case '3':
3295 case '4': case '5': case '6': case '7':
3296 /* at most three octal digits */
3301 n
= n
* 8 + c
- '0';
3305 n
= n
* 8 + c
- '0';
3310 goto add_char_nonext
;
3318 if (c
>= 'a' && c
<= 'f')
3320 else if (c
>= 'A' && c
<= 'F')
3330 goto add_char_nonext
;
3354 goto invalid_escape
;
3364 if (c
>= '!' && c
<= '~')
3365 warning("unknown escape sequence: \'\\%c\'", c
);
3367 warning("unknown escape sequence: \'\\x%x\'", c
);
3374 cstr_ccat(outstr
, c
);
3376 cstr_wccat(outstr
, c
);
3378 /* add a trailing '\0' */
3380 cstr_ccat(outstr
, '\0');
3382 cstr_wccat(outstr
, '\0');
3385 /* we use 64 bit numbers */
3388 /* bn = (bn << shift) | or_val */
3389 void bn_lshift(unsigned int *bn
, int shift
, int or_val
)
3393 for(i
=0;i
<BN_SIZE
;i
++) {
3395 bn
[i
] = (v
<< shift
) | or_val
;
3396 or_val
= v
>> (32 - shift
);
3400 void bn_zero(unsigned int *bn
)
3403 for(i
=0;i
<BN_SIZE
;i
++) {
3408 /* parse number in null terminated string 'p' and return it in the
3410 void parse_number(const char *p
)
3412 int b
, t
, shift
, frac_bits
, s
, exp_val
, ch
;
3414 unsigned int bn
[BN_SIZE
];
3425 goto float_frac_parse
;
3426 } else if (t
== '0') {
3427 if (ch
== 'x' || ch
== 'X') {
3431 } else if (tcc_ext
&& (ch
== 'b' || ch
== 'B')) {
3437 /* parse all digits. cannot check octal numbers at this stage
3438 because of floating point constants */
3440 if (ch
>= 'a' && ch
<= 'f')
3442 else if (ch
>= 'A' && ch
<= 'F')
3450 if (q
>= token_buf
+ STRING_MAX_SIZE
) {
3452 error("number too long");
3458 ((ch
== 'e' || ch
== 'E') && b
== 10) ||
3459 ((ch
== 'p' || ch
== 'P') && (b
== 16 || b
== 2))) {
3461 /* NOTE: strtox should support that for hexa numbers, but
3462 non ISOC99 libcs do not support it, so we prefer to do
3464 /* hexadecimal or binary floats */
3465 /* XXX: handle overflows */
3477 } else if (t
>= 'a') {
3479 } else if (t
>= 'A') {
3484 bn_lshift(bn
, shift
, t
);
3491 if (t
>= 'a' && t
<= 'f') {
3493 } else if (t
>= 'A' && t
<= 'F') {
3495 } else if (t
>= '0' && t
<= '9') {
3501 error("invalid digit");
3502 bn_lshift(bn
, shift
, t
);
3507 if (ch
!= 'p' && ch
!= 'P')
3514 } else if (ch
== '-') {
3518 if (ch
< '0' || ch
> '9')
3519 expect("exponent digits");
3520 while (ch
>= '0' && ch
<= '9') {
3521 exp_val
= exp_val
* 10 + ch
- '0';
3524 exp_val
= exp_val
* s
;
3526 /* now we can generate the number */
3527 /* XXX: should patch directly float number */
3528 d
= (double)bn
[1] * 4294967296.0 + (double)bn
[0];
3529 d
= ldexp(d
, exp_val
- frac_bits
);
3534 /* float : should handle overflow */
3536 } else if (t
== 'L') {
3539 /* XXX: not large enough */
3540 tokc
.ld
= (long double)d
;
3546 /* decimal floats */
3548 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3553 while (ch
>= '0' && ch
<= '9') {
3554 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3560 if (ch
== 'e' || ch
== 'E') {
3561 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3565 if (ch
== '-' || ch
== '+') {
3566 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3571 if (ch
< '0' || ch
> '9')
3572 expect("exponent digits");
3573 while (ch
>= '0' && ch
<= '9') {
3574 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3586 tokc
.f
= strtof(token_buf
, NULL
);
3587 } else if (t
== 'L') {
3590 tokc
.ld
= strtold(token_buf
, NULL
);
3593 tokc
.d
= strtod(token_buf
, NULL
);
3597 unsigned long long n
, n1
;
3600 /* integer number */
3603 if (b
== 10 && *q
== '0') {
3610 /* no need for checks except for base 10 / 8 errors */
3613 } else if (t
>= 'a') {
3615 } else if (t
>= 'A') {
3620 error("invalid digit");
3624 /* detect overflow */
3625 /* XXX: this test is not reliable */
3627 error("integer constant overflow");
3630 /* XXX: not exactly ANSI compliant */
3631 if ((n
& 0xffffffff00000000LL
) != 0) {
3636 } else if (n
> 0x7fffffff) {
3647 error("three 'l's in integer constant");
3650 if (tok
== TOK_CINT
)
3652 else if (tok
== TOK_CUINT
)
3656 } else if (t
== 'U') {
3658 error("two 'u's in integer constant");
3660 if (tok
== TOK_CINT
)
3662 else if (tok
== TOK_CLLONG
)
3669 if (tok
== TOK_CINT
|| tok
== TOK_CUINT
)
3675 error("invalid number\n");
3679 #define PARSE2(c1, tok1, c2, tok2) \
3690 /* return next token without macro substitution */
3691 static inline void next_nomacro1(void)
3698 cstr_reset(&tok_spaces
);
3708 cstr_ccat(&tok_spaces
, c
);
3713 /* first look if it is in fact an end of buffer */
3714 if (p
>= file
->buf_end
) {
3718 if (p
>= file
->buf_end
)
3731 TCCState
*s1
= tcc_state
;
3732 if ((parse_flags
& PARSE_FLAG_LINEFEED
)
3733 && !(tok_flags
& TOK_FLAG_EOF
)) {
3734 tok_flags
|= TOK_FLAG_EOF
;
3736 goto keep_tok_flags
;
3737 } else if (s1
->include_stack_ptr
== s1
->include_stack
||
3738 !(parse_flags
& PARSE_FLAG_PREPROCESS
)) {
3739 /* no include left : end of file. */
3742 tok_flags
&= ~TOK_FLAG_EOF
;
3743 /* pop include file */
3745 /* test if previous '#endif' was after a #ifdef at
3747 if (tok_flags
& TOK_FLAG_ENDIF
) {
3749 printf("#endif %s\n", get_tok_str(file
->ifndef_macro_saved
, NULL
));
3751 add_cached_include(s1
, file
->inc_type
, file
->inc_filename
,
3752 file
->ifndef_macro_saved
);
3755 /* add end of include file debug info */
3757 put_stabd(N_EINCL
, 0, 0);
3759 /* pop include stack */
3761 s1
->include_stack_ptr
--;
3762 file
= *s1
->include_stack_ptr
;
3771 tok_flags
|= TOK_FLAG_BOL
;
3773 if (0 == (parse_flags
& PARSE_FLAG_LINEFEED
))
3776 goto keep_tok_flags
;
3781 if ((tok_flags
& TOK_FLAG_BOL
) &&
3782 (parse_flags
& PARSE_FLAG_PREPROCESS
)) {
3784 preprocess(tok_flags
& TOK_FLAG_BOF
);
3790 tok
= TOK_TWOSHARPS
;
3792 if (parse_flags
& PARSE_FLAG_ASM_COMMENTS
) {
3793 p
= parse_line_comment(p
- 1);
3802 case 'a': case 'b': case 'c': case 'd':
3803 case 'e': case 'f': case 'g': case 'h':
3804 case 'i': case 'j': case 'k': case 'l':
3805 case 'm': case 'n': case 'o': case 'p':
3806 case 'q': case 'r': case 's': case 't':
3807 case 'u': case 'v': case 'w': case 'x':
3809 case 'A': case 'B': case 'C': case 'D':
3810 case 'E': case 'F': case 'G': case 'H':
3811 case 'I': case 'J': case 'K':
3812 case 'M': case 'N': case 'O': case 'P':
3813 case 'Q': case 'R': case 'S': case 'T':
3814 case 'U': case 'V': case 'W': case 'X':
3820 h
= TOK_HASH_FUNC(h
, c
);
3824 if (!isidnum_table
[c
-CH_EOF
])
3826 h
= TOK_HASH_FUNC(h
, c
);
3833 /* fast case : no stray found, so we have the full token
3834 and we have already hashed it */
3836 h
&= (TOK_HASH_SIZE
- 1);
3837 pts
= &hash_ident
[h
];
3842 if (ts
->len
== len
&& !memcmp(ts
->str
, p1
, len
))
3844 pts
= &(ts
->hash_next
);
3846 ts
= tok_alloc_new(pts
, p1
, len
);
3850 cstr_reset(&tokcstr
);
3853 cstr_ccat(&tokcstr
, *p1
);
3859 while (isidnum_table
[c
-CH_EOF
]) {
3860 cstr_ccat(&tokcstr
, c
);
3863 ts
= tok_alloc(tokcstr
.data
, tokcstr
.size
);
3869 if (t
!= '\\' && t
!= '\'' && t
!= '\"') {
3871 goto parse_ident_fast
;
3874 if (c
== '\'' || c
== '\"') {
3878 cstr_reset(&tokcstr
);
3879 cstr_ccat(&tokcstr
, 'L');
3880 goto parse_ident_slow
;
3884 case '0': case '1': case '2': case '3':
3885 case '4': case '5': case '6': case '7':
3888 cstr_reset(&tokcstr
);
3889 /* after the first digit, accept digits, alpha, '.' or sign if
3890 prefixed by 'eEpP' */
3894 cstr_ccat(&tokcstr
, c
);
3896 if (!(isnum(c
) || isid(c
) || c
== '.' ||
3897 ((c
== '+' || c
== '-') &&
3898 (t
== 'e' || t
== 'E' || t
== 'p' || t
== 'P'))))
3901 /* We add a trailing '\0' to ease parsing */
3902 cstr_ccat(&tokcstr
, '\0');
3903 tokc
.cstr
= &tokcstr
;
3907 /* special dot handling because it can also start a number */
3910 cstr_reset(&tokcstr
);
3911 cstr_ccat(&tokcstr
, '.');
3913 } else if (c
== '.') {
3933 /* parse the string */
3935 p
= parse_pp_string(p
, sep
, &str
);
3936 cstr_ccat(&str
, '\0');
3938 /* eval the escape (should be done as TOK_PPNUM) */
3939 cstr_reset(&tokcstr
);
3940 parse_escape_string(&tokcstr
, str
.data
, is_long
);
3945 /* XXX: make it portable */
3949 char_size
= sizeof(nwchar_t
);
3950 if (tokcstr
.size
<= char_size
)
3951 error("empty character constant");
3952 if (tokcstr
.size
> 2 * char_size
)
3953 warning("multi-character character constant");
3955 tokc
.i
= *(int8_t *)tokcstr
.data
;
3958 tokc
.i
= *(nwchar_t
*)tokcstr
.data
;
3962 tokc
.cstr
= &tokcstr
;
3976 } else if (c
== '<') {
3994 } else if (c
== '>') {
4012 } else if (c
== '=') {
4025 } else if (c
== '=') {
4038 } else if (c
== '=') {
4051 } else if (c
== '=') {
4054 } else if (c
== '>') {
4062 PARSE2('!', '!', '=', TOK_NE
)
4063 PARSE2('=', '=', '=', TOK_EQ
)
4064 PARSE2('*', '*', '=', TOK_A_MUL
)
4065 PARSE2('%', '%', '=', TOK_A_MOD
)
4066 PARSE2('^', '^', '=', TOK_A_XOR
)
4068 /* comments or operator */
4072 p
= parse_comment(p
);
4074 } else if (c
== '/') {
4075 p
= parse_line_comment(p
);
4077 } else if (c
== '=') {
4097 case '$': /* only used in assembler */
4098 case '@': /* dito */
4103 error("unrecognized character \\x%02x", c
);
4109 #if defined(PARSE_DEBUG)
4110 printf("token = %s\n", get_tok_str(tok
, &tokc
));
4114 /* return next token without macro substitution. Can read input from
4116 static void next_nomacro(void)
4122 TOK_GET(tok
, macro_ptr
, tokc
);
4123 if (tok
== TOK_LINENUM
) {
4124 file
->line_num
= tokc
.i
;
4133 /* substitute args in macro_str and return allocated string */
4134 static int *macro_arg_subst(Sym
**nested_list
, int *macro_str
, Sym
*args
)
4136 int *st
, last_tok
, t
, notfirst
;
4145 TOK_GET(t
, macro_str
, cval
);
4150 TOK_GET(t
, macro_str
, cval
);
4153 s
= sym_find2(args
, t
);
4160 cstr_ccat(&cstr
, ' ');
4161 TOK_GET(t
, st
, cval
);
4162 cstr_cat(&cstr
, get_tok_str(t
, &cval
));
4167 cstr_ccat(&cstr
, '\0');
4169 printf("stringize: %s\n", (char *)cstr
.data
);
4173 tok_str_add2(&str
, TOK_STR
, &cval
);
4176 tok_str_add2(&str
, t
, &cval
);
4178 } else if (t
>= TOK_IDENT
) {
4179 s
= sym_find2(args
, t
);
4182 /* if '##' is present before or after, no arg substitution */
4183 if (*macro_str
== TOK_TWOSHARPS
|| last_tok
== TOK_TWOSHARPS
) {
4184 /* special case for var arg macros : ## eats the
4185 ',' if empty VA_ARGS variable. */
4186 /* XXX: test of the ',' is not 100%
4187 reliable. should fix it to avoid security
4189 if (gnu_ext
&& s
->type
.t
&&
4190 last_tok
== TOK_TWOSHARPS
&&
4191 str
.len
>= 2 && str
.str
[str
.len
- 2] == ',') {
4193 /* suppress ',' '##' */
4196 /* suppress '##' and add variable */
4204 TOK_GET(t1
, st
, cval
);
4207 tok_str_add2(&str
, t1
, &cval
);
4211 /* NOTE: the stream cannot be read when macro
4212 substituing an argument */
4213 macro_subst(&str
, nested_list
, st
, NULL
);
4216 tok_str_add(&str
, t
);
4219 tok_str_add2(&str
, t
, &cval
);
4223 tok_str_add(&str
, 0);
4227 static char const ab_month_name
[12][4] =
4229 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
4230 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
4233 /* do macro substitution of current token with macro 's' and add
4234 result to (tok_str,tok_len). 'nested_list' is the list of all
4235 macros we got inside to avoid recursing. Return non zero if no
4236 substitution needs to be done */
4237 static int macro_subst_tok(TokenString
*tok_str
,
4238 Sym
**nested_list
, Sym
*s
, struct macro_level
**can_read_stream
)
4240 Sym
*args
, *sa
, *sa1
;
4241 int mstr_allocated
, parlevel
, *mstr
, t
, t1
;
4248 /* if symbol is a macro, prepare substitution */
4249 /* special macros */
4250 if (tok
== TOK___LINE__
) {
4251 snprintf(buf
, sizeof(buf
), "%d", file
->line_num
);
4255 } else if (tok
== TOK___FILE__
) {
4256 cstrval
= file
->filename
;
4258 } else if (tok
== TOK___DATE__
|| tok
== TOK___TIME__
) {
4263 tm
= localtime(&ti
);
4264 if (tok
== TOK___DATE__
) {
4265 snprintf(buf
, sizeof(buf
), "%s %2d %d",
4266 ab_month_name
[tm
->tm_mon
], tm
->tm_mday
, tm
->tm_year
+ 1900);
4268 snprintf(buf
, sizeof(buf
), "%02d:%02d:%02d",
4269 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
4276 cstr_cat(&cstr
, cstrval
);
4277 cstr_ccat(&cstr
, '\0');
4279 tok_str_add2(tok_str
, t1
, &cval
);
4284 if (s
->type
.t
== MACRO_FUNC
) {
4285 /* NOTE: we do not use next_nomacro to avoid eating the
4286 next token. XXX: find better solution */
4290 if (t
== 0 && can_read_stream
) {
4291 /* end of macro stream: we must look at the token
4292 after in the file */
4293 struct macro_level
*ml
= *can_read_stream
;
4299 *can_read_stream
= ml
-> prev
;
4304 /* XXX: incorrect with comments */
4305 ch
= file
->buf_ptr
[0];
4306 while (is_space(ch
) || ch
== '\n')
4310 if (t
!= '(') /* no macro subst */
4313 /* argument macro */
4318 /* NOTE: empty args are allowed, except if no args */
4320 /* handle '()' case */
4321 if (!args
&& !sa
&& tok
== ')')
4324 error("macro '%s' used with too many args",
4325 get_tok_str(s
->v
, 0));
4328 /* NOTE: non zero sa->t indicates VA_ARGS */
4329 while ((parlevel
> 0 ||
4331 (tok
!= ',' || sa
->type
.t
))) &&
4335 else if (tok
== ')')
4337 if (tok
!= TOK_LINEFEED
)
4338 tok_str_add2(&str
, tok
, &tokc
);
4341 tok_str_add(&str
, 0);
4342 sym_push2(&args
, sa
->v
& ~SYM_FIELD
, sa
->type
.t
, (long)str
.str
);
4345 /* special case for gcc var args: add an empty
4346 var arg argument if it is omitted */
4347 if (sa
&& sa
->type
.t
&& gnu_ext
)
4357 error("macro '%s' used with too few args",
4358 get_tok_str(s
->v
, 0));
4361 /* now subst each arg */
4362 mstr
= macro_arg_subst(nested_list
, mstr
, args
);
4367 tok_str_free((int *)sa
->c
);
4373 sym_push2(nested_list
, s
->v
, 0, 0);
4374 macro_subst(tok_str
, nested_list
, mstr
, can_read_stream
);
4375 /* pop nested defined symbol */
4377 *nested_list
= sa1
->prev
;
4385 /* handle the '##' operator. Return NULL if no '##' seen. Otherwise
4386 return the resulting string (which must be freed). */
4387 static inline int *macro_twosharps(const int *macro_str
)
4390 const int *macro_ptr1
, *start_macro_ptr
, *ptr
, *saved_macro_ptr
;
4392 const char *p1
, *p2
;
4394 TokenString macro_str1
;
4397 start_macro_ptr
= macro_str
;
4398 /* we search the first '##' */
4400 macro_ptr1
= macro_str
;
4401 TOK_GET(t
, macro_str
, cval
);
4402 /* nothing more to do if end of string */
4405 if (*macro_str
== TOK_TWOSHARPS
)
4409 /* we saw '##', so we need more processing to handle it */
4411 tok_str_new(¯o_str1
);
4415 /* add all tokens seen so far */
4416 for(ptr
= start_macro_ptr
; ptr
< macro_ptr1
;) {
4417 TOK_GET(t
, ptr
, cval
);
4418 tok_str_add2(¯o_str1
, t
, &cval
);
4420 saved_macro_ptr
= macro_ptr
;
4421 /* XXX: get rid of the use of macro_ptr here */
4422 macro_ptr
= (int *)macro_str
;
4424 while (*macro_ptr
== TOK_TWOSHARPS
) {
4426 macro_ptr1
= macro_ptr
;
4429 TOK_GET(t
, macro_ptr
, cval
);
4430 /* We concatenate the two tokens if we have an
4431 identifier or a preprocessing number */
4433 p1
= get_tok_str(tok
, &tokc
);
4434 cstr_cat(&cstr
, p1
);
4435 p2
= get_tok_str(t
, &cval
);
4436 cstr_cat(&cstr
, p2
);
4437 cstr_ccat(&cstr
, '\0');
4439 if ((tok
>= TOK_IDENT
|| tok
== TOK_PPNUM
) &&
4440 (t
>= TOK_IDENT
|| t
== TOK_PPNUM
)) {
4441 if (tok
== TOK_PPNUM
) {
4442 /* if number, then create a number token */
4443 /* NOTE: no need to allocate because
4444 tok_str_add2() does it */
4445 cstr_reset(&tokcstr
);
4448 tokc
.cstr
= &tokcstr
;
4450 /* if identifier, we must do a test to
4451 validate we have a correct identifier */
4452 if (t
== TOK_PPNUM
) {
4462 if (!isnum(c
) && !isid(c
))
4466 ts
= tok_alloc(cstr
.data
, strlen(cstr
.data
));
4467 tok
= ts
->tok
; /* modify current token */
4470 const char *str
= cstr
.data
;
4471 const unsigned char *q
;
4473 /* we look for a valid token */
4474 /* XXX: do more extensive checks */
4475 if (!strcmp(str
, ">>=")) {
4477 } else if (!strcmp(str
, "<<=")) {
4479 } else if (strlen(str
) == 2) {
4480 /* search in two bytes table */
4485 if (q
[0] == str
[0] && q
[1] == str
[1])
4492 /* NOTE: because get_tok_str use a static buffer,
4495 p1
= get_tok_str(tok
, &tokc
);
4496 cstr_cat(&cstr
, p1
);
4497 cstr_ccat(&cstr
, '\0');
4498 p2
= get_tok_str(t
, &cval
);
4499 warning("pasting \"%s\" and \"%s\" does not give a valid preprocessing token", cstr
.data
, p2
);
4500 /* cannot merge tokens: just add them separately */
4501 tok_str_add2(¯o_str1
, tok
, &tokc
);
4502 /* XXX: free associated memory ? */
4509 tok_str_add2(¯o_str1
, tok
, &tokc
);
4514 macro_ptr
= (int *)saved_macro_ptr
;
4516 tok_str_add(¯o_str1
, 0);
4517 return macro_str1
.str
;
4521 /* do macro substitution of macro_str and add result to
4522 (tok_str,tok_len). 'nested_list' is the list of all macros we got
4523 inside to avoid recursing. */
4524 static void macro_subst(TokenString
*tok_str
, Sym
**nested_list
,
4525 const int *macro_str
, struct macro_level
** can_read_stream
)
4532 struct macro_level ml
;
4534 /* first scan for '##' operator handling */
4536 macro_str1
= macro_twosharps(ptr
);
4540 /* NOTE: ptr == NULL can only happen if tokens are read from
4541 file stream due to a macro function call */
4544 TOK_GET(t
, ptr
, cval
);
4549 /* if nested substitution, do nothing */
4550 if (sym_find2(*nested_list
, t
))
4553 if (can_read_stream
)
4554 ml
.prev
= *can_read_stream
, *can_read_stream
= &ml
;
4555 macro_ptr
= (int *)ptr
;
4557 ret
= macro_subst_tok(tok_str
, nested_list
, s
, can_read_stream
);
4558 ptr
= (int *)macro_ptr
;
4560 if (can_read_stream
&& *can_read_stream
== &ml
)
4561 *can_read_stream
= ml
.prev
;
4566 tok_str_add2(tok_str
, t
, &cval
);
4570 tok_str_free(macro_str1
);
4573 /* return next token with macro substitution */
4574 static void next(void)
4576 Sym
*nested_list
, *s
;
4578 struct macro_level
*ml
;
4583 /* if not reading from macro substituted string, then try
4584 to substitute macros */
4585 if (tok
>= TOK_IDENT
&&
4586 (parse_flags
& PARSE_FLAG_PREPROCESS
)) {
4587 s
= define_find(tok
);
4589 /* we have a macro: we try to substitute */
4593 if (macro_subst_tok(&str
, &nested_list
, s
, &ml
) == 0) {
4594 /* substitution done, NOTE: maybe empty */
4595 tok_str_add(&str
, 0);
4596 macro_ptr
= str
.str
;
4597 macro_ptr_allocated
= str
.str
;
4604 /* end of macro or end of unget buffer */
4605 if (unget_buffer_enabled
) {
4606 macro_ptr
= unget_saved_macro_ptr
;
4607 unget_buffer_enabled
= 0;
4609 /* end of macro string: free it */
4610 tok_str_free(macro_ptr_allocated
);
4617 /* convert preprocessor tokens into C tokens */
4618 if (tok
== TOK_PPNUM
&&
4619 (parse_flags
& PARSE_FLAG_TOK_NUM
)) {
4620 parse_number((char *)tokc
.cstr
->data
);
4624 /* push back current token and set current token to 'last_tok'. Only
4625 identifier case handled for labels. */
4626 static inline void unget_tok(int last_tok
)
4630 unget_saved_macro_ptr
= macro_ptr
;
4631 unget_buffer_enabled
= 1;
4632 q
= unget_saved_buffer
;
4635 n
= tok_ext_size(tok
) - 1;
4638 *q
= 0; /* end of token string */
4643 void swap(int *p
, int *q
)
4651 void vsetc(CType
*type
, int r
, CValue
*vc
)
4655 if (vtop
>= vstack
+ (VSTACK_SIZE
- 1))
4656 error("memory full");
4657 /* cannot let cpu flags if other instruction are generated. Also
4658 avoid leaving VT_JMP anywhere except on the top of the stack
4659 because it would complicate the code generator. */
4660 if (vtop
>= vstack
) {
4661 v
= vtop
->r
& VT_VALMASK
;
4662 if (v
== VT_CMP
|| (v
& ~1) == VT_JMP
)
4668 vtop
->r2
= VT_CONST
;
4672 /* push integer constant */
4677 vsetc(&int_type
, VT_CONST
, &cval
);
4680 /* push long long constant */
4681 void vpushll(long long v
)
4687 vsetc(&ctype
, VT_CONST
, &cval
);
4690 /* Return a static symbol pointing to a section */
4691 static Sym
*get_sym_ref(CType
*type
, Section
*sec
,
4692 unsigned long offset
, unsigned long size
)
4698 sym
= global_identifier_push(v
, type
->t
| VT_STATIC
, 0);
4699 sym
->type
.ref
= type
->ref
;
4700 sym
->r
= VT_CONST
| VT_SYM
;
4701 put_extern_sym(sym
, sec
, offset
, size
);
4705 /* push a reference to a section offset by adding a dummy symbol */
4706 static void vpush_ref(CType
*type
, Section
*sec
, unsigned long offset
, unsigned long size
)
4711 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
4712 vtop
->sym
= get_sym_ref(type
, sec
, offset
, size
);
4715 /* define a new external reference to a symbol 'v' of type 'u' */
4716 static Sym
*external_global_sym(int v
, CType
*type
, int r
)
4722 /* push forward reference */
4723 s
= global_identifier_push(v
, type
->t
| VT_EXTERN
, 0);
4724 s
->type
.ref
= type
->ref
;
4725 s
->r
= r
| VT_CONST
| VT_SYM
;
4730 /* define a new external reference to a symbol 'v' of type 'u' */
4731 static Sym
*external_sym(int v
, CType
*type
, int r
)
4737 /* push forward reference */
4738 s
= sym_push(v
, type
, r
| VT_CONST
| VT_SYM
, 0);
4739 s
->type
.t
|= VT_EXTERN
;
4741 if (!is_compatible_types(&s
->type
, type
))
4742 error("incompatible types for redefinition of '%s'",
4743 get_tok_str(v
, NULL
));
4748 /* push a reference to global symbol v */
4749 static void vpush_global_sym(CType
*type
, int v
)
4754 sym
= external_global_sym(v
, type
, 0);
4756 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
4760 void vset(CType
*type
, int r
, int v
)
4765 vsetc(type
, r
, &cval
);
4768 void vseti(int r
, int v
)
4784 void vpushv(SValue
*v
)
4786 if (vtop
>= vstack
+ (VSTACK_SIZE
- 1))
4787 error("memory full");
4797 /* save r to the memory stack, and mark it as being free */
4798 void save_reg(int r
)
4800 int l
, saved
, size
, align
;
4804 /* modify all stack values */
4807 for(p
=vstack
;p
<=vtop
;p
++) {
4808 if ((p
->r
& VT_VALMASK
) == r
||
4809 ((p
->type
.t
& VT_BTYPE
) == VT_LLONG
&& (p
->r2
& VT_VALMASK
) == r
)) {
4810 /* must save value on stack if not already done */
4812 /* NOTE: must reload 'r' because r might be equal to r2 */
4813 r
= p
->r
& VT_VALMASK
;
4814 /* store register in the stack */
4816 if ((p
->r
& VT_LVAL
) ||
4817 (!is_float(type
->t
) && (type
->t
& VT_BTYPE
) != VT_LLONG
))
4818 #ifdef TCC_TARGET_X86_64
4819 type
= &char_pointer_type
;
4823 size
= type_size(type
, &align
);
4824 loc
= (loc
- size
) & -align
;
4825 sv
.type
.t
= type
->t
;
4826 sv
.r
= VT_LOCAL
| VT_LVAL
;
4829 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
4830 /* x86 specific: need to pop fp register ST0 if saved */
4831 if (r
== TREG_ST0
) {
4832 o(0xd9dd); /* fstp %st(1) */
4835 #ifndef TCC_TARGET_X86_64
4836 /* special long long case */
4837 if ((type
->t
& VT_BTYPE
) == VT_LLONG
) {
4845 /* mark that stack entry as being saved on the stack */
4846 if (p
->r
& VT_LVAL
) {
4847 /* also clear the bounded flag because the
4848 relocation address of the function was stored in
4850 p
->r
= (p
->r
& ~(VT_VALMASK
| VT_BOUNDED
)) | VT_LLOCAL
;
4852 p
->r
= lvalue_type(p
->type
.t
) | VT_LOCAL
;
4860 /* find a register of class 'rc2' with at most one reference on stack.
4861 * If none, call get_reg(rc) */
4862 int get_reg_ex(int rc
, int rc2
)
4867 for(r
=0;r
<NB_REGS
;r
++) {
4868 if (reg_classes
[r
] & rc2
) {
4871 for(p
= vstack
; p
<= vtop
; p
++) {
4872 if ((p
->r
& VT_VALMASK
) == r
||
4873 (p
->r2
& VT_VALMASK
) == r
)
4883 /* find a free register of class 'rc'. If none, save one register */
4889 /* find a free register */
4890 for(r
=0;r
<NB_REGS
;r
++) {
4891 if (reg_classes
[r
] & rc
) {
4892 for(p
=vstack
;p
<=vtop
;p
++) {
4893 if ((p
->r
& VT_VALMASK
) == r
||
4894 (p
->r2
& VT_VALMASK
) == r
)
4902 /* no register left : free the first one on the stack (VERY
4903 IMPORTANT to start from the bottom to ensure that we don't
4904 spill registers used in gen_opi()) */
4905 for(p
=vstack
;p
<=vtop
;p
++) {
4906 r
= p
->r
& VT_VALMASK
;
4907 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
))
4909 /* also look at second register (if long long) */
4910 r
= p
->r2
& VT_VALMASK
;
4911 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
)) {
4917 /* Should never comes here */
4921 /* save registers up to (vtop - n) stack entry */
4922 void save_regs(int n
)
4927 for(p
= vstack
;p
<= p1
; p
++) {
4928 r
= p
->r
& VT_VALMASK
;
4935 /* move register 's' to 'r', and flush previous value of r to memory
4937 void move_reg(int r
, int s
)
4950 /* get address of vtop (vtop MUST BE an lvalue) */
4953 vtop
->r
&= ~VT_LVAL
;
4954 /* tricky: if saved lvalue, then we can go back to lvalue */
4955 if ((vtop
->r
& VT_VALMASK
) == VT_LLOCAL
)
4956 vtop
->r
= (vtop
->r
& ~(VT_VALMASK
| VT_LVAL_TYPE
)) | VT_LOCAL
| VT_LVAL
;
4959 #ifdef CONFIG_TCC_BCHECK
4960 /* generate lvalue bound code */
4966 vtop
->r
&= ~VT_MUSTBOUND
;
4967 /* if lvalue, then use checking code before dereferencing */
4968 if (vtop
->r
& VT_LVAL
) {
4969 /* if not VT_BOUNDED value, then make one */
4970 if (!(vtop
->r
& VT_BOUNDED
)) {
4971 lval_type
= vtop
->r
& (VT_LVAL_TYPE
| VT_LVAL
);
4972 /* must save type because we must set it to int to get pointer */
4974 vtop
->type
.t
= VT_INT
;
4977 gen_bounded_ptr_add();
4978 vtop
->r
|= lval_type
;
4981 /* then check for dereferencing */
4982 gen_bounded_ptr_deref();
4987 /* store vtop a register belonging to class 'rc'. lvalues are
4988 converted to values. Cannot be used if cannot be converted to
4989 register value (such as structures). */
4992 int r
, rc2
, bit_pos
, bit_size
, size
, align
, i
;
4994 /* NOTE: get_reg can modify vstack[] */
4995 if (vtop
->type
.t
& VT_BITFIELD
) {
4998 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4999 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
5000 /* remove bit field info to avoid loops */
5001 vtop
->type
.t
&= ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
5002 /* cast to int to propagate signedness in following ops */
5003 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
5008 if((vtop
->type
.t
& VT_UNSIGNED
) ||
5009 (vtop
->type
.t
& VT_BTYPE
) == VT_BOOL
)
5010 type
.t
|= VT_UNSIGNED
;
5012 /* generate shifts */
5013 vpushi(bits
- (bit_pos
+ bit_size
));
5015 vpushi(bits
- bit_size
);
5016 /* NOTE: transformed to SHR if unsigned */
5020 if (is_float(vtop
->type
.t
) &&
5021 (vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
5024 unsigned long offset
;
5025 #if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
5029 /* XXX: unify with initializers handling ? */
5030 /* CPUs usually cannot use float constants, so we store them
5031 generically in data segment */
5032 size
= type_size(&vtop
->type
, &align
);
5033 offset
= (data_section
->data_offset
+ align
- 1) & -align
;
5034 data_section
->data_offset
= offset
;
5035 /* XXX: not portable yet */
5036 #if defined(__i386__) || defined(__x86_64__)
5037 /* Zero pad x87 tenbyte long doubles */
5038 if (size
== LDOUBLE_SIZE
)
5039 vtop
->c
.tab
[2] &= 0xffff;
5041 ptr
= section_ptr_add(data_section
, size
);
5043 #if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
5047 ptr
[i
] = vtop
->c
.tab
[size
-1-i
];
5051 ptr
[i
] = vtop
->c
.tab
[i
];
5052 sym
= get_sym_ref(&vtop
->type
, data_section
, offset
, size
<< 2);
5053 vtop
->r
|= VT_LVAL
| VT_SYM
;
5057 #ifdef CONFIG_TCC_BCHECK
5058 if (vtop
->r
& VT_MUSTBOUND
)
5062 r
= vtop
->r
& VT_VALMASK
;
5066 /* need to reload if:
5068 - lvalue (need to dereference pointer)
5069 - already a register, but not in the right class */
5070 if (r
>= VT_CONST
||
5071 (vtop
->r
& VT_LVAL
) ||
5072 !(reg_classes
[r
] & rc
) ||
5073 ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
&&
5074 !(reg_classes
[vtop
->r2
] & rc2
))) {
5076 #ifndef TCC_TARGET_X86_64
5077 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
5079 unsigned long long ll
;
5080 /* two register type load : expand to two words
5082 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
5085 vtop
->c
.ui
= ll
; /* first word */
5087 vtop
->r
= r
; /* save register value */
5088 vpushi(ll
>> 32); /* second word */
5089 } else if (r
>= VT_CONST
|| /* XXX: test to VT_CONST incorrect ? */
5090 (vtop
->r
& VT_LVAL
)) {
5091 /* We do not want to modifier the long long
5092 pointer here, so the safest (and less
5093 efficient) is to save all the other registers
5094 in the stack. XXX: totally inefficient. */
5096 /* load from memory */
5099 vtop
[-1].r
= r
; /* save register value */
5100 /* increment pointer to get second word */
5101 vtop
->type
.t
= VT_INT
;
5107 /* move registers */
5110 vtop
[-1].r
= r
; /* save register value */
5111 vtop
->r
= vtop
[-1].r2
;
5113 /* allocate second register */
5117 /* write second register */
5121 if ((vtop
->r
& VT_LVAL
) && !is_float(vtop
->type
.t
)) {
5123 /* lvalue of scalar type : need to use lvalue type
5124 because of possible cast */
5127 /* compute memory access type */
5128 if (vtop
->r
& VT_LVAL_BYTE
)
5130 else if (vtop
->r
& VT_LVAL_SHORT
)
5132 if (vtop
->r
& VT_LVAL_UNSIGNED
)
5136 /* restore wanted type */
5139 /* one register type load */
5144 #ifdef TCC_TARGET_C67
5145 /* uses register pairs for doubles */
5146 if ((vtop
->type
.t
& VT_BTYPE
) == VT_DOUBLE
)
5153 /* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
5154 void gv2(int rc1
, int rc2
)
5158 /* generate more generic register first. But VT_JMP or VT_CMP
5159 values must be generated first in all cases to avoid possible
5161 v
= vtop
[0].r
& VT_VALMASK
;
5162 if (v
!= VT_CMP
&& (v
& ~1) != VT_JMP
&& rc1
<= rc2
) {
5167 /* test if reload is needed for first register */
5168 if ((vtop
[-1].r
& VT_VALMASK
) >= VT_CONST
) {
5178 /* test if reload is needed for first register */
5179 if ((vtop
[0].r
& VT_VALMASK
) >= VT_CONST
) {
5185 /* wrapper around RC_FRET to return a register by type */
5188 #ifdef TCC_TARGET_X86_64
5189 if (t
== VT_LDOUBLE
) {
5196 /* wrapper around REG_FRET to return a register by type */
5199 #ifdef TCC_TARGET_X86_64
5200 if (t
== VT_LDOUBLE
) {
5207 /* expand long long on stack in two int registers */
5212 u
= vtop
->type
.t
& VT_UNSIGNED
;
5215 vtop
[0].r
= vtop
[-1].r2
;
5216 vtop
[0].r2
= VT_CONST
;
5217 vtop
[-1].r2
= VT_CONST
;
5218 vtop
[0].type
.t
= VT_INT
| u
;
5219 vtop
[-1].type
.t
= VT_INT
| u
;
5222 #ifdef TCC_TARGET_ARM
5223 /* expand long long on stack */
5224 void lexpand_nr(void)
5228 u
= vtop
->type
.t
& VT_UNSIGNED
;
5230 vtop
->r2
= VT_CONST
;
5231 vtop
->type
.t
= VT_INT
| u
;
5232 v
=vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
);
5233 if (v
== VT_CONST
) {
5234 vtop
[-1].c
.ui
= vtop
->c
.ull
;
5235 vtop
->c
.ui
= vtop
->c
.ull
>> 32;
5237 } else if (v
== (VT_LVAL
|VT_CONST
) || v
== (VT_LVAL
|VT_LOCAL
)) {
5239 vtop
->r
= vtop
[-1].r
;
5240 } else if (v
> VT_CONST
) {
5244 vtop
->r
= vtop
[-1].r2
;
5245 vtop
[-1].r2
= VT_CONST
;
5246 vtop
[-1].type
.t
= VT_INT
| u
;
5250 /* build a long long from two ints */
5253 gv2(RC_INT
, RC_INT
);
5254 vtop
[-1].r2
= vtop
[0].r
;
5255 vtop
[-1].type
.t
= t
;
5259 /* rotate n first stack elements to the bottom
5260 I1 ... In -> I2 ... In I1 [top is right]
5268 for(i
=-n
+1;i
!=0;i
++)
5269 vtop
[i
] = vtop
[i
+1];
5273 /* rotate n first stack elements to the top
5274 I1 ... In -> In I1 ... I(n-1) [top is right]
5282 for(i
= 0;i
< n
- 1; i
++)
5283 vtop
[-i
] = vtop
[-i
- 1];
5287 #ifdef TCC_TARGET_ARM
5288 /* like vrott but in other direction
5289 In ... I1 -> I(n-1) ... I1 In [top is right]
5297 for(i
= n
- 1; i
> 0; i
--)
5298 vtop
[-i
] = vtop
[-i
+ 1];
5303 /* pop stack value */
5307 v
= vtop
->r
& VT_VALMASK
;
5308 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
5309 /* for x86, we need to pop the FP stack */
5310 if (v
== TREG_ST0
&& !nocode_wanted
) {
5311 o(0xd9dd); /* fstp %st(1) */
5314 if (v
== VT_JMP
|| v
== VT_JMPI
) {
5315 /* need to put correct jump if && or || without test */
5321 /* convert stack entry to register and duplicate its value in another
5329 if ((t
& VT_BTYPE
) == VT_LLONG
) {
5336 /* stack: H L L1 H1 */
5344 /* duplicate value */
5349 #ifdef TCC_TARGET_X86_64
5350 if ((t
& VT_BTYPE
) == VT_LDOUBLE
) {
5360 load(r1
, &sv
); /* move r to r1 */
5362 /* duplicates value */
5367 #ifndef TCC_TARGET_X86_64
5368 /* generate CPU independent (unsigned) long long operations */
5369 void gen_opl(int op
)
5371 int t
, a
, b
, op1
, c
, i
;
5373 unsigned short reg_iret
= REG_IRET
;
5374 unsigned short reg_lret
= REG_LRET
;
5380 func
= TOK___divdi3
;
5383 func
= TOK___udivdi3
;
5386 func
= TOK___moddi3
;
5389 func
= TOK___umoddi3
;
5396 /* call generic long long function */
5397 vpush_global_sym(&func_old_type
, func
);
5402 vtop
->r2
= reg_lret
;
5415 /* stack: L1 H1 L2 H2 */
5420 vtop
[-2] = vtop
[-3];
5423 /* stack: H1 H2 L1 L2 */
5429 /* stack: H1 H2 L1 L2 ML MH */
5432 /* stack: ML MH H1 H2 L1 L2 */
5436 /* stack: ML MH H1 L2 H2 L1 */
5441 /* stack: ML MH M1 M2 */
5444 } else if (op
== '+' || op
== '-') {
5445 /* XXX: add non carry method too (for MIPS or alpha) */
5451 /* stack: H1 H2 (L1 op L2) */
5454 gen_op(op1
+ 1); /* TOK_xxxC2 */
5457 /* stack: H1 H2 (L1 op L2) */
5460 /* stack: (L1 op L2) H1 H2 */
5462 /* stack: (L1 op L2) (H1 op H2) */
5470 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
5471 t
= vtop
[-1].type
.t
;
5475 /* stack: L H shift */
5477 /* constant: simpler */
5478 /* NOTE: all comments are for SHL. the other cases are
5479 done by swaping words */
5490 if (op
!= TOK_SAR
) {
5523 /* XXX: should provide a faster fallback on x86 ? */
5526 func
= TOK___ashrdi3
;
5529 func
= TOK___lshrdi3
;
5532 func
= TOK___ashldi3
;
5538 /* compare operations */
5544 /* stack: L1 H1 L2 H2 */
5546 vtop
[-1] = vtop
[-2];
5548 /* stack: L1 L2 H1 H2 */
5551 /* when values are equal, we need to compare low words. since
5552 the jump is inverted, we invert the test too. */
5555 else if (op1
== TOK_GT
)
5557 else if (op1
== TOK_ULT
)
5559 else if (op1
== TOK_UGT
)
5564 if (op1
!= TOK_NE
) {
5568 /* generate non equal test */
5569 /* XXX: NOT PORTABLE yet */
5573 #if defined(TCC_TARGET_I386)
5574 b
= psym(0x850f, 0);
5575 #elif defined(TCC_TARGET_ARM)
5577 o(0x1A000000 | encbranch(ind
, 0, 1));
5578 #elif defined(TCC_TARGET_C67)
5579 error("not implemented");
5581 #error not supported
5585 /* compare low. Always unsigned */
5589 else if (op1
== TOK_LE
)
5591 else if (op1
== TOK_GT
)
5593 else if (op1
== TOK_GE
)
5604 /* handle integer constant optimizations and various machine
5606 void gen_opic(int op
)
5608 int c1
, c2
, t1
, t2
, n
;
5611 typedef unsigned long long U
;
5615 t1
= v1
->type
.t
& VT_BTYPE
;
5616 t2
= v2
->type
.t
& VT_BTYPE
;
5620 else if (v1
->type
.t
& VT_UNSIGNED
)
5627 else if (v2
->type
.t
& VT_UNSIGNED
)
5632 /* currently, we cannot do computations with forward symbols */
5633 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5634 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5637 case '+': l1
+= l2
; break;
5638 case '-': l1
-= l2
; break;
5639 case '&': l1
&= l2
; break;
5640 case '^': l1
^= l2
; break;
5641 case '|': l1
|= l2
; break;
5642 case '*': l1
*= l2
; break;
5649 /* if division by zero, generate explicit division */
5652 error("division by zero in constant");
5656 default: l1
/= l2
; break;
5657 case '%': l1
%= l2
; break;
5658 case TOK_UDIV
: l1
= (U
)l1
/ l2
; break;
5659 case TOK_UMOD
: l1
= (U
)l1
% l2
; break;
5662 case TOK_SHL
: l1
<<= l2
; break;
5663 case TOK_SHR
: l1
= (U
)l1
>> l2
; break;
5664 case TOK_SAR
: l1
>>= l2
; break;
5666 case TOK_ULT
: l1
= (U
)l1
< (U
)l2
; break;
5667 case TOK_UGE
: l1
= (U
)l1
>= (U
)l2
; break;
5668 case TOK_EQ
: l1
= l1
== l2
; break;
5669 case TOK_NE
: l1
= l1
!= l2
; break;
5670 case TOK_ULE
: l1
= (U
)l1
<= (U
)l2
; break;
5671 case TOK_UGT
: l1
= (U
)l1
> (U
)l2
; break;
5672 case TOK_LT
: l1
= l1
< l2
; break;
5673 case TOK_GE
: l1
= l1
>= l2
; break;
5674 case TOK_LE
: l1
= l1
<= l2
; break;
5675 case TOK_GT
: l1
= l1
> l2
; break;
5677 case TOK_LAND
: l1
= l1
&& l2
; break;
5678 case TOK_LOR
: l1
= l1
|| l2
; break;
5685 /* if commutative ops, put c2 as constant */
5686 if (c1
&& (op
== '+' || op
== '&' || op
== '^' ||
5687 op
== '|' || op
== '*')) {
5689 c2
= c1
; //c = c1, c1 = c2, c2 = c;
5690 l2
= l1
; //l = l1, l1 = l2, l2 = l;
5692 /* Filter out NOP operations like x*1, x-0, x&-1... */
5693 if (c2
&& (((op
== '*' || op
== '/' || op
== TOK_UDIV
||
5696 ((op
== '+' || op
== '-' || op
== '|' || op
== '^' ||
5697 op
== TOK_SHL
|| op
== TOK_SHR
|| op
== TOK_SAR
) &&
5703 } else if (c2
&& (op
== '*' || op
== TOK_PDIV
|| op
== TOK_UDIV
)) {
5704 /* try to use shifts instead of muls or divs */
5705 if (l2
> 0 && (l2
& (l2
- 1)) == 0) {
5714 else if (op
== TOK_PDIV
)
5720 } else if (c2
&& (op
== '+' || op
== '-') &&
5721 ((vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) ==
5722 (VT_CONST
| VT_SYM
) ||
5723 (vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
)) == VT_LOCAL
)) {
5724 /* symbol + constant case */
5731 if (!nocode_wanted
) {
5732 /* call low level op generator */
5733 if (t1
== VT_LLONG
|| t2
== VT_LLONG
)
5744 /* generate a floating point operation with constant propagation */
5745 void gen_opif(int op
)
5753 /* currently, we cannot do computations with forward symbols */
5754 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5755 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5757 if (v1
->type
.t
== VT_FLOAT
) {
5760 } else if (v1
->type
.t
== VT_DOUBLE
) {
5768 /* NOTE: we only do constant propagation if finite number (not
5769 NaN or infinity) (ANSI spec) */
5770 if (!ieee_finite(f1
) || !ieee_finite(f2
))
5774 case '+': f1
+= f2
; break;
5775 case '-': f1
-= f2
; break;
5776 case '*': f1
*= f2
; break;
5780 error("division by zero in constant");
5785 /* XXX: also handles tests ? */
5789 /* XXX: overflow test ? */
5790 if (v1
->type
.t
== VT_FLOAT
) {
5792 } else if (v1
->type
.t
== VT_DOUBLE
) {
5800 if (!nocode_wanted
) {
5808 static int pointed_size(CType
*type
)
5811 return type_size(pointed_type(type
), &align
);
5814 static inline int is_null_pointer(SValue
*p
)
5816 if ((p
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
5818 return ((p
->type
.t
& VT_BTYPE
) == VT_INT
&& p
->c
.i
== 0) ||
5819 ((p
->type
.t
& VT_BTYPE
) == VT_LLONG
&& p
->c
.ll
== 0);
5822 static inline int is_integer_btype(int bt
)
5824 return (bt
== VT_BYTE
|| bt
== VT_SHORT
||
5825 bt
== VT_INT
|| bt
== VT_LLONG
);
5828 /* check types for comparison or substraction of pointers */
5829 static void check_comparison_pointer_types(SValue
*p1
, SValue
*p2
, int op
)
5831 CType
*type1
, *type2
, tmp_type1
, tmp_type2
;
5834 /* null pointers are accepted for all comparisons as gcc */
5835 if (is_null_pointer(p1
) || is_null_pointer(p2
))
5839 bt1
= type1
->t
& VT_BTYPE
;
5840 bt2
= type2
->t
& VT_BTYPE
;
5841 /* accept comparison between pointer and integer with a warning */
5842 if ((is_integer_btype(bt1
) || is_integer_btype(bt2
)) && op
!= '-') {
5843 if (op
!= TOK_LOR
&& op
!= TOK_LAND
)
5844 warning("comparison between pointer and integer");
5848 /* both must be pointers or implicit function pointers */
5849 if (bt1
== VT_PTR
) {
5850 type1
= pointed_type(type1
);
5851 } else if (bt1
!= VT_FUNC
)
5852 goto invalid_operands
;
5854 if (bt2
== VT_PTR
) {
5855 type2
= pointed_type(type2
);
5856 } else if (bt2
!= VT_FUNC
) {
5858 error("invalid operands to binary %s", get_tok_str(op
, NULL
));
5860 if ((type1
->t
& VT_BTYPE
) == VT_VOID
||
5861 (type2
->t
& VT_BTYPE
) == VT_VOID
)
5865 tmp_type1
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
5866 tmp_type2
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
5867 if (!is_compatible_types(&tmp_type1
, &tmp_type2
)) {
5868 /* gcc-like error if '-' is used */
5870 goto invalid_operands
;
5872 warning("comparison of distinct pointer types lacks a cast");
5876 /* generic gen_op: handles types problems */
5879 int u
, t1
, t2
, bt1
, bt2
, t
;
5882 t1
= vtop
[-1].type
.t
;
5883 t2
= vtop
[0].type
.t
;
5884 bt1
= t1
& VT_BTYPE
;
5885 bt2
= t2
& VT_BTYPE
;
5887 if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
5888 /* at least one operand is a pointer */
5889 /* relationnal op: must be both pointers */
5890 if (op
>= TOK_ULT
&& op
<= TOK_LOR
) {
5891 check_comparison_pointer_types(vtop
- 1, vtop
, op
);
5892 /* pointers are handled are unsigned */
5893 #ifdef TCC_TARGET_X86_64
5894 t
= VT_LLONG
| VT_UNSIGNED
;
5896 t
= VT_INT
| VT_UNSIGNED
;
5900 /* if both pointers, then it must be the '-' op */
5901 if (bt1
== VT_PTR
&& bt2
== VT_PTR
) {
5903 error("cannot use pointers here");
5904 check_comparison_pointer_types(vtop
- 1, vtop
, op
);
5905 /* XXX: check that types are compatible */
5906 u
= pointed_size(&vtop
[-1].type
);
5908 /* set to integer type */
5909 #ifdef TCC_TARGET_X86_64
5910 vtop
->type
.t
= VT_LLONG
;
5912 vtop
->type
.t
= VT_INT
;
5917 /* exactly one pointer : must be '+' or '-'. */
5918 if (op
!= '-' && op
!= '+')
5919 error("cannot use pointers here");
5920 /* Put pointer as first operand */
5921 if (bt2
== VT_PTR
) {
5925 type1
= vtop
[-1].type
;
5926 #ifdef TCC_TARGET_X86_64
5927 vpushll(pointed_size(&vtop
[-1].type
));
5929 /* XXX: cast to int ? (long long case) */
5930 vpushi(pointed_size(&vtop
[-1].type
));
5933 #ifdef CONFIG_TCC_BCHECK
5934 /* if evaluating constant expression, no code should be
5935 generated, so no bound check */
5936 if (do_bounds_check
&& !const_wanted
) {
5937 /* if bounded pointers, we generate a special code to
5944 gen_bounded_ptr_add();
5950 /* put again type if gen_opic() swaped operands */
5953 } else if (is_float(bt1
) || is_float(bt2
)) {
5954 /* compute bigger type and do implicit casts */
5955 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
5957 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
5962 /* floats can only be used for a few operations */
5963 if (op
!= '+' && op
!= '-' && op
!= '*' && op
!= '/' &&
5964 (op
< TOK_ULT
|| op
> TOK_GT
))
5965 error("invalid operands for binary operation");
5967 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
5968 /* cast to biggest op */
5970 /* convert to unsigned if it does not fit in a long long */
5971 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
5972 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
5976 /* integer operations */
5978 /* convert to unsigned if it does not fit in an integer */
5979 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
5980 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
5983 /* XXX: currently, some unsigned operations are explicit, so
5984 we modify them here */
5985 if (t
& VT_UNSIGNED
) {
5992 else if (op
== TOK_LT
)
5994 else if (op
== TOK_GT
)
5996 else if (op
== TOK_LE
)
5998 else if (op
== TOK_GE
)
6005 /* special case for shifts and long long: we keep the shift as
6007 if (op
== TOK_SHR
|| op
== TOK_SAR
|| op
== TOK_SHL
)
6014 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
6015 /* relationnal op: the result is an int */
6016 vtop
->type
.t
= VT_INT
;
6023 #ifndef TCC_TARGET_ARM
6024 /* generic itof for unsigned long long case */
6025 void gen_cvt_itof1(int t
)
6027 if ((vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
)) ==
6028 (VT_LLONG
| VT_UNSIGNED
)) {
6031 vpush_global_sym(&func_old_type
, TOK___floatundisf
);
6032 #if LDOUBLE_SIZE != 8
6033 else if (t
== VT_LDOUBLE
)
6034 vpush_global_sym(&func_old_type
, TOK___floatundixf
);
6037 vpush_global_sym(&func_old_type
, TOK___floatundidf
);
6041 vtop
->r
= reg_fret(t
);
6048 /* generic ftoi for unsigned long long case */
6049 void gen_cvt_ftoi1(int t
)
6053 if (t
== (VT_LLONG
| VT_UNSIGNED
)) {
6054 /* not handled natively */
6055 st
= vtop
->type
.t
& VT_BTYPE
;
6057 vpush_global_sym(&func_old_type
, TOK___fixunssfdi
);
6058 #if LDOUBLE_SIZE != 8
6059 else if (st
== VT_LDOUBLE
)
6060 vpush_global_sym(&func_old_type
, TOK___fixunsxfdi
);
6063 vpush_global_sym(&func_old_type
, TOK___fixunsdfdi
);
6068 vtop
->r2
= REG_LRET
;
6074 /* force char or short cast */
6075 void force_charshort_cast(int t
)
6079 /* XXX: add optimization if lvalue : just change type and offset */
6084 if (t
& VT_UNSIGNED
) {
6085 vpushi((1 << bits
) - 1);
6091 /* result must be signed or the SAR is converted to an SHL
6092 This was not the case when "t" was a signed short
6093 and the last value on the stack was an unsigned int */
6094 vtop
->type
.t
&= ~VT_UNSIGNED
;
6100 /* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
6101 static void gen_cast(CType
*type
)
6103 int sbt
, dbt
, sf
, df
, c
, p
;
6105 /* special delayed cast for char/short */
6106 /* XXX: in some cases (multiple cascaded casts), it may still
6108 if (vtop
->r
& VT_MUSTCAST
) {
6109 vtop
->r
&= ~VT_MUSTCAST
;
6110 force_charshort_cast(vtop
->type
.t
);
6113 /* bitfields first get cast to ints */
6114 if (vtop
->type
.t
& VT_BITFIELD
) {
6118 dbt
= type
->t
& (VT_BTYPE
| VT_UNSIGNED
);
6119 sbt
= vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
);
6124 c
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
6125 p
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == (VT_CONST
| VT_SYM
);
6127 /* constant case: we can do it now */
6128 /* XXX: in ISOC, cannot do it if error in convert */
6129 if (sbt
== VT_FLOAT
)
6130 vtop
->c
.ld
= vtop
->c
.f
;
6131 else if (sbt
== VT_DOUBLE
)
6132 vtop
->c
.ld
= vtop
->c
.d
;
6135 if ((sbt
& VT_BTYPE
) == VT_LLONG
) {
6136 if (sbt
& VT_UNSIGNED
)
6137 vtop
->c
.ld
= vtop
->c
.ull
;
6139 vtop
->c
.ld
= vtop
->c
.ll
;
6141 if (sbt
& VT_UNSIGNED
)
6142 vtop
->c
.ld
= vtop
->c
.ui
;
6144 vtop
->c
.ld
= vtop
->c
.i
;
6147 if (dbt
== VT_FLOAT
)
6148 vtop
->c
.f
= (float)vtop
->c
.ld
;
6149 else if (dbt
== VT_DOUBLE
)
6150 vtop
->c
.d
= (double)vtop
->c
.ld
;
6151 } else if (sf
&& dbt
== (VT_LLONG
|VT_UNSIGNED
)) {
6152 vtop
->c
.ull
= (unsigned long long)vtop
->c
.ld
;
6153 } else if (sf
&& dbt
== VT_BOOL
) {
6154 vtop
->c
.i
= (vtop
->c
.ld
!= 0);
6157 vtop
->c
.ll
= (long long)vtop
->c
.ld
;
6158 else if (sbt
== (VT_LLONG
|VT_UNSIGNED
))
6159 vtop
->c
.ll
= vtop
->c
.ull
;
6160 else if (sbt
& VT_UNSIGNED
)
6161 vtop
->c
.ll
= vtop
->c
.ui
;
6162 else if (sbt
!= VT_LLONG
)
6163 vtop
->c
.ll
= vtop
->c
.i
;
6165 if (dbt
== (VT_LLONG
|VT_UNSIGNED
))
6166 vtop
->c
.ull
= vtop
->c
.ll
;
6167 else if (dbt
== VT_BOOL
)
6168 vtop
->c
.i
= (vtop
->c
.ll
!= 0);
6169 else if (dbt
!= VT_LLONG
) {
6171 if ((dbt
& VT_BTYPE
) == VT_BYTE
)
6173 else if ((dbt
& VT_BTYPE
) == VT_SHORT
)
6176 if(dbt
& VT_UNSIGNED
)
6177 vtop
->c
.ui
= ((unsigned int)vtop
->c
.ll
<< s
) >> s
;
6179 vtop
->c
.i
= ((int)vtop
->c
.ll
<< s
) >> s
;
6182 } else if (p
&& dbt
== VT_BOOL
) {
6185 } else if (!nocode_wanted
) {
6186 /* non constant case: generate code */
6188 /* convert from fp to fp */
6191 /* convert int to fp */
6194 /* convert fp to int */
6195 if (dbt
== VT_BOOL
) {
6199 /* we handle char/short/etc... with generic code */
6200 if (dbt
!= (VT_INT
| VT_UNSIGNED
) &&
6201 dbt
!= (VT_LLONG
| VT_UNSIGNED
) &&
6205 if (dbt
== VT_INT
&& (type
->t
& (VT_BTYPE
| VT_UNSIGNED
)) != dbt
) {
6206 /* additional cast for char/short... */
6211 } else if ((dbt
& VT_BTYPE
) == VT_LLONG
) {
6212 if ((sbt
& VT_BTYPE
) != VT_LLONG
) {
6213 /* scalar to long long */
6214 #ifndef TCC_TARGET_X86_64
6215 /* machine independent conversion */
6217 /* generate high word */
6218 if (sbt
== (VT_INT
| VT_UNSIGNED
)) {
6222 if (sbt
== VT_PTR
) {
6223 /* cast from pointer to int before we apply
6224 shift operation, which pointers don't support*/
6225 gen_cast(&int_type
);
6231 /* patch second register */
6232 vtop
[-1].r2
= vtop
->r
;
6236 if (sbt
!= (VT_INT
| VT_UNSIGNED
) && sbt
!= VT_PTR
) {
6237 /* x86_64 specific: movslq */
6239 o(0xc0 + (REG_VALUE(r
) << 3) + REG_VALUE(r
));
6243 } else if (dbt
== VT_BOOL
) {
6244 /* scalar to bool */
6247 } else if ((dbt
& VT_BTYPE
) == VT_BYTE
||
6248 (dbt
& VT_BTYPE
) == VT_SHORT
) {
6249 if (sbt
== VT_PTR
) {
6250 vtop
->type
.t
= VT_INT
;
6251 warning("nonportable conversion from pointer to char/short");
6253 force_charshort_cast(dbt
);
6254 } else if ((dbt
& VT_BTYPE
) == VT_INT
) {
6256 if (sbt
== VT_LLONG
) {
6257 /* from long long: just take low order word */
6261 /* if lvalue and single word type, nothing to do because
6262 the lvalue already contains the real type size (see
6263 VT_LVAL_xxx constants) */
6266 } else if ((dbt
& VT_BTYPE
) == VT_PTR
&& !(vtop
->r
& VT_LVAL
)) {
6267 /* if we are casting between pointer types,
6268 we must update the VT_LVAL_xxx size */
6269 vtop
->r
= (vtop
->r
& ~VT_LVAL_TYPE
)
6270 | (lvalue_type(type
->ref
->type
.t
) & VT_LVAL_TYPE
);
6275 /* return type size. Put alignment at 'a' */
6276 static int type_size(CType
*type
, int *a
)
6281 bt
= type
->t
& VT_BTYPE
;
6282 if (bt
== VT_STRUCT
) {
6287 } else if (bt
== VT_PTR
) {
6288 if (type
->t
& VT_ARRAY
) {
6292 ts
= type_size(&s
->type
, a
);
6294 if (ts
< 0 && s
->c
< 0)
6302 } else if (bt
== VT_LDOUBLE
) {
6304 return LDOUBLE_SIZE
;
6305 } else if (bt
== VT_DOUBLE
|| bt
== VT_LLONG
) {
6306 #ifdef TCC_TARGET_I386
6307 #ifdef TCC_TARGET_PE
6312 #elif defined(TCC_TARGET_ARM)
6322 } else if (bt
== VT_INT
|| bt
== VT_ENUM
|| bt
== VT_FLOAT
) {
6325 } else if (bt
== VT_SHORT
) {
6329 /* char, void, function, _Bool */
6335 /* return the pointed type of t */
6336 static inline CType
*pointed_type(CType
*type
)
6338 return &type
->ref
->type
;
6341 /* modify type so that its it is a pointer to type. */
6342 static void mk_pointer(CType
*type
)
6345 s
= sym_push(SYM_FIELD
, type
, 0, -1);
6346 type
->t
= VT_PTR
| (type
->t
& ~VT_TYPE
);
6350 /* compare function types. OLD functions match any new functions */
6351 static int is_compatible_func(CType
*type1
, CType
*type2
)
6357 if (!is_compatible_types(&s1
->type
, &s2
->type
))
6359 /* check func_call */
6360 if (FUNC_CALL(s1
->r
) != FUNC_CALL(s2
->r
))
6362 /* XXX: not complete */
6363 if (s1
->c
== FUNC_OLD
|| s2
->c
== FUNC_OLD
)
6367 while (s1
!= NULL
) {
6370 if (!is_compatible_parameter_types(&s1
->type
, &s2
->type
))
6380 /* return true if type1 and type2 are the same. If unqualified is
6381 true, qualifiers on the types are ignored.
6383 - enums are not checked as gcc __builtin_types_compatible_p ()
6385 static int compare_types(CType
*type1
, CType
*type2
, int unqualified
)
6389 t1
= type1
->t
& VT_TYPE
;
6390 t2
= type2
->t
& VT_TYPE
;
6392 /* strip qualifiers before comparing */
6393 t1
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6394 t2
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6396 /* XXX: bitfields ? */
6399 /* test more complicated cases */
6400 bt1
= t1
& VT_BTYPE
;
6401 if (bt1
== VT_PTR
) {
6402 type1
= pointed_type(type1
);
6403 type2
= pointed_type(type2
);
6404 return is_compatible_types(type1
, type2
);
6405 } else if (bt1
== VT_STRUCT
) {
6406 return (type1
->ref
== type2
->ref
);
6407 } else if (bt1
== VT_FUNC
) {
6408 return is_compatible_func(type1
, type2
);
6414 /* return true if type1 and type2 are exactly the same (including
6417 static int is_compatible_types(CType
*type1
, CType
*type2
)
6419 return compare_types(type1
,type2
,0);
6422 /* return true if type1 and type2 are the same (ignoring qualifiers).
6424 static int is_compatible_parameter_types(CType
*type1
, CType
*type2
)
6426 return compare_types(type1
,type2
,1);
6429 /* print a type. If 'varstr' is not NULL, then the variable is also
6430 printed in the type */
6432 /* XXX: add array and function pointers */
6433 void type_to_str(char *buf
, int buf_size
,
6434 CType
*type
, const char *varstr
)
6441 t
= type
->t
& VT_TYPE
;
6444 if (t
& VT_CONSTANT
)
6445 pstrcat(buf
, buf_size
, "const ");
6446 if (t
& VT_VOLATILE
)
6447 pstrcat(buf
, buf_size
, "volatile ");
6448 if (t
& VT_UNSIGNED
)
6449 pstrcat(buf
, buf_size
, "unsigned ");
6479 tstr
= "long double";
6481 pstrcat(buf
, buf_size
, tstr
);
6485 if (bt
== VT_STRUCT
)
6489 pstrcat(buf
, buf_size
, tstr
);
6490 v
= type
->ref
->v
& ~SYM_STRUCT
;
6491 if (v
>= SYM_FIRST_ANOM
)
6492 pstrcat(buf
, buf_size
, "<anonymous>");
6494 pstrcat(buf
, buf_size
, get_tok_str(v
, NULL
));
6498 type_to_str(buf
, buf_size
, &s
->type
, varstr
);
6499 pstrcat(buf
, buf_size
, "(");
6501 while (sa
!= NULL
) {
6502 type_to_str(buf1
, sizeof(buf1
), &sa
->type
, NULL
);
6503 pstrcat(buf
, buf_size
, buf1
);
6506 pstrcat(buf
, buf_size
, ", ");
6508 pstrcat(buf
, buf_size
, ")");
6512 pstrcpy(buf1
, sizeof(buf1
), "*");
6514 pstrcat(buf1
, sizeof(buf1
), varstr
);
6515 type_to_str(buf
, buf_size
, &s
->type
, buf1
);
6519 pstrcat(buf
, buf_size
, " ");
6520 pstrcat(buf
, buf_size
, varstr
);
6525 /* verify type compatibility to store vtop in 'dt' type, and generate
6527 static void gen_assign_cast(CType
*dt
)
6529 CType
*st
, *type1
, *type2
, tmp_type1
, tmp_type2
;
6530 char buf1
[256], buf2
[256];
6533 st
= &vtop
->type
; /* source type */
6534 dbt
= dt
->t
& VT_BTYPE
;
6535 sbt
= st
->t
& VT_BTYPE
;
6536 if (dt
->t
& VT_CONSTANT
)
6537 warning("assignment of read-only location");
6540 /* special cases for pointers */
6541 /* '0' can also be a pointer */
6542 if (is_null_pointer(vtop
))
6544 /* accept implicit pointer to integer cast with warning */
6545 if (is_integer_btype(sbt
)) {
6546 warning("assignment makes pointer from integer without a cast");
6549 type1
= pointed_type(dt
);
6550 /* a function is implicitely a function pointer */
6551 if (sbt
== VT_FUNC
) {
6552 if ((type1
->t
& VT_BTYPE
) != VT_VOID
&&
6553 !is_compatible_types(pointed_type(dt
), st
))
6560 type2
= pointed_type(st
);
6561 if ((type1
->t
& VT_BTYPE
) == VT_VOID
||
6562 (type2
->t
& VT_BTYPE
) == VT_VOID
) {
6563 /* void * can match anything */
6565 /* exact type match, except for unsigned */
6568 tmp_type1
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
6569 tmp_type2
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
6570 if (!is_compatible_types(&tmp_type1
, &tmp_type2
))
6571 warning("assignment from incompatible pointer type");
6573 /* check const and volatile */
6574 if ((!(type1
->t
& VT_CONSTANT
) && (type2
->t
& VT_CONSTANT
)) ||
6575 (!(type1
->t
& VT_VOLATILE
) && (type2
->t
& VT_VOLATILE
)))
6576 warning("assignment discards qualifiers from pointer target type");
6582 if (sbt
== VT_PTR
|| sbt
== VT_FUNC
) {
6583 warning("assignment makes integer from pointer without a cast");
6585 /* XXX: more tests */
6590 tmp_type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6591 tmp_type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6592 if (!is_compatible_types(&tmp_type1
, &tmp_type2
)) {
6594 type_to_str(buf1
, sizeof(buf1
), st
, NULL
);
6595 type_to_str(buf2
, sizeof(buf2
), dt
, NULL
);
6596 error("cannot cast '%s' to '%s'", buf1
, buf2
);
6604 /* store vtop in lvalue pushed on stack */
6607 int sbt
, dbt
, ft
, r
, t
, size
, align
, bit_size
, bit_pos
, rc
, delayed_cast
;
6609 ft
= vtop
[-1].type
.t
;
6610 sbt
= vtop
->type
.t
& VT_BTYPE
;
6611 dbt
= ft
& VT_BTYPE
;
6612 if (((sbt
== VT_INT
|| sbt
== VT_SHORT
) && dbt
== VT_BYTE
) ||
6613 (sbt
== VT_INT
&& dbt
== VT_SHORT
)) {
6614 /* optimize char/short casts */
6615 delayed_cast
= VT_MUSTCAST
;
6616 vtop
->type
.t
= ft
& (VT_TYPE
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
)));
6617 /* XXX: factorize */
6618 if (ft
& VT_CONSTANT
)
6619 warning("assignment of read-only location");
6622 if (!(ft
& VT_BITFIELD
))
6623 gen_assign_cast(&vtop
[-1].type
);
6626 if (sbt
== VT_STRUCT
) {
6627 /* if structure, only generate pointer */
6628 /* structure assignment : generate memcpy */
6629 /* XXX: optimize if small size */
6630 if (!nocode_wanted
) {
6631 size
= type_size(&vtop
->type
, &align
);
6635 vpush_global_sym(&func_old_type
, TOK_memcpy8
);
6636 else if(!(align
& 3))
6637 vpush_global_sym(&func_old_type
, TOK_memcpy4
);
6640 vpush_global_sym(&func_old_type
, TOK_memcpy
);
6644 vtop
->type
.t
= VT_PTR
;
6648 vtop
->type
.t
= VT_PTR
;
6660 /* leave source on stack */
6661 } else if (ft
& VT_BITFIELD
) {
6662 /* bitfield store handling */
6663 bit_pos
= (ft
>> VT_STRUCT_SHIFT
) & 0x3f;
6664 bit_size
= (ft
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
6665 /* remove bit field info to avoid loops */
6666 vtop
[-1].type
.t
= ft
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
6668 /* duplicate source into other register */
6673 if((ft
& VT_BTYPE
) == VT_BOOL
) {
6674 gen_cast(&vtop
[-1].type
);
6675 vtop
[-1].type
.t
= (vtop
[-1].type
.t
& ~VT_BTYPE
) | (VT_BYTE
| VT_UNSIGNED
);
6678 /* duplicate destination */
6680 vtop
[-1] = vtop
[-2];
6682 /* mask and shift source */
6683 if((ft
& VT_BTYPE
) != VT_BOOL
) {
6684 if((ft
& VT_BTYPE
) == VT_LLONG
) {
6685 vpushll((1ULL << bit_size
) - 1ULL);
6687 vpushi((1 << bit_size
) - 1);
6693 /* load destination, mask and or with source */
6695 if((ft
& VT_BTYPE
) == VT_LLONG
) {
6696 vpushll(~(((1ULL << bit_size
) - 1ULL) << bit_pos
));
6698 vpushi(~(((1 << bit_size
) - 1) << bit_pos
));
6705 /* pop off shifted source from "duplicate source..." above */
6709 #ifdef CONFIG_TCC_BCHECK
6710 /* bound check case */
6711 if (vtop
[-1].r
& VT_MUSTBOUND
) {
6717 if (!nocode_wanted
) {
6721 #ifdef TCC_TARGET_X86_64
6722 if ((ft
& VT_BTYPE
) == VT_LDOUBLE
) {
6727 r
= gv(rc
); /* generate value */
6728 /* if lvalue was saved on stack, must read it */
6729 if ((vtop
[-1].r
& VT_VALMASK
) == VT_LLOCAL
) {
6731 t
= get_reg(RC_INT
);
6732 #ifdef TCC_TARGET_X86_64
6737 sv
.r
= VT_LOCAL
| VT_LVAL
;
6738 sv
.c
.ul
= vtop
[-1].c
.ul
;
6740 vtop
[-1].r
= t
| VT_LVAL
;
6743 #ifndef TCC_TARGET_X86_64
6744 /* two word case handling : store second register at word + 4 */
6745 if ((ft
& VT_BTYPE
) == VT_LLONG
) {
6747 /* convert to int to increment easily */
6748 vtop
->type
.t
= VT_INT
;
6754 /* XXX: it works because r2 is spilled last ! */
6755 store(vtop
->r2
, vtop
- 1);
6760 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
6761 vtop
->r
|= delayed_cast
;
6765 /* post defines POST/PRE add. c is the token ++ or -- */
6766 void inc(int post
, int c
)
6769 vdup(); /* save lvalue */
6771 gv_dup(); /* duplicate value */
6776 vpushi(c
- TOK_MID
);
6778 vstore(); /* store value */
6780 vpop(); /* if post op, return saved value */
6783 /* Parse GNUC __attribute__ extension. Currently, the following
6784 extensions are recognized:
6785 - aligned(n) : set data/function alignment.
6786 - packed : force data alignment to 1
6787 - section(x) : generate data/code in this section.
6788 - unused : currently ignored, but may be used someday.
6789 - regparm(n) : pass function parameters in registers (i386 only)
6791 static void parse_attribute(AttributeDef
*ad
)
6795 while (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
) {
6799 while (tok
!= ')') {
6800 if (tok
< TOK_IDENT
)
6801 expect("attribute name");
6809 expect("section name");
6810 ad
->section
= find_section(tcc_state
, (char *)tokc
.cstr
->data
);
6819 if (n
<= 0 || (n
& (n
- 1)) != 0)
6820 error("alignment must be a positive power of two");
6833 /* currently, no need to handle it because tcc does not
6834 track unused objects */
6838 /* currently, no need to handle it because tcc does not
6839 track unused objects */
6844 FUNC_CALL(ad
->func_attr
) = FUNC_CDECL
;
6849 FUNC_CALL(ad
->func_attr
) = FUNC_STDCALL
;
6851 #ifdef TCC_TARGET_I386
6861 FUNC_CALL(ad
->func_attr
) = FUNC_FASTCALL1
+ n
- 1;
6867 FUNC_CALL(ad
->func_attr
) = FUNC_FASTCALLW
;
6871 FUNC_EXPORT(ad
->func_attr
) = 1;
6874 if (tcc_state
->warn_unsupported
)
6875 warning("'%s' attribute ignored", get_tok_str(t
, NULL
));
6876 /* skip parameters */
6878 int parenthesis
= 0;
6882 else if (tok
== ')')
6885 } while (parenthesis
&& tok
!= -1);
6898 /* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
6899 static void struct_decl(CType
*type
, int u
)
6901 int a
, v
, size
, align
, maxalign
, c
, offset
;
6902 int bit_size
, bit_pos
, bsize
, bt
, lbit_pos
, prevbt
;
6903 Sym
*s
, *ss
, *ass
, **ps
;
6907 a
= tok
; /* save decl type */
6912 /* struct already defined ? return it */
6914 expect("struct/union/enum name");
6918 error("invalid type");
6925 /* we put an undefined size for struct/union */
6926 s
= sym_push(v
| SYM_STRUCT
, &type1
, 0, -1);
6927 s
->r
= 0; /* default alignment is zero as gcc */
6928 /* put struct/union/enum name in type */
6936 error("struct/union/enum already defined");
6937 /* cannot be empty */
6939 /* non empty enums are not allowed */
6940 if (a
== TOK_ENUM
) {
6944 expect("identifier");
6950 /* enum symbols have static storage */
6951 ss
= sym_push(v
, &int_type
, VT_CONST
, c
);
6952 ss
->type
.t
|= VT_STATIC
;
6957 /* NOTE: we accept a trailing comma */
6968 while (tok
!= '}') {
6969 parse_btype(&btype
, &ad
);
6975 type_decl(&type1
, &ad
, &v
, TYPE_DIRECT
| TYPE_ABSTRACT
);
6976 if (v
== 0 && (type1
.t
& VT_BTYPE
) != VT_STRUCT
)
6977 expect("identifier");
6978 if ((type1
.t
& VT_BTYPE
) == VT_FUNC
||
6979 (type1
.t
& (VT_TYPEDEF
| VT_STATIC
| VT_EXTERN
| VT_INLINE
)))
6980 error("invalid type for '%s'",
6981 get_tok_str(v
, NULL
));
6985 bit_size
= expr_const();
6986 /* XXX: handle v = 0 case for messages */
6988 error("negative width in bit-field '%s'",
6989 get_tok_str(v
, NULL
));
6990 if (v
&& bit_size
== 0)
6991 error("zero width for bit-field '%s'",
6992 get_tok_str(v
, NULL
));
6994 size
= type_size(&type1
, &align
);
6996 if (align
< ad
.aligned
)
6998 } else if (ad
.packed
) {
7000 } else if (*tcc_state
->pack_stack_ptr
) {
7001 if (align
> *tcc_state
->pack_stack_ptr
)
7002 align
= *tcc_state
->pack_stack_ptr
;
7005 if (bit_size
>= 0) {
7006 bt
= type1
.t
& VT_BTYPE
;
7013 error("bitfields must have scalar type");
7015 if (bit_size
> bsize
) {
7016 error("width of '%s' exceeds its type",
7017 get_tok_str(v
, NULL
));
7018 } else if (bit_size
== bsize
) {
7019 /* no need for bit fields */
7021 } else if (bit_size
== 0) {
7022 /* XXX: what to do if only padding in a
7024 /* zero size: means to pad */
7027 /* we do not have enough room ?
7028 did the type change?
7030 if ((bit_pos
+ bit_size
) > bsize
||
7031 bt
!= prevbt
|| a
== TOK_UNION
)
7034 /* XXX: handle LSB first */
7035 type1
.t
|= VT_BITFIELD
|
7036 (bit_pos
<< VT_STRUCT_SHIFT
) |
7037 (bit_size
<< (VT_STRUCT_SHIFT
+ 6));
7038 bit_pos
+= bit_size
;
7044 if (v
!= 0 || (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
7045 /* add new memory data only if starting
7047 if (lbit_pos
== 0) {
7048 if (a
== TOK_STRUCT
) {
7049 c
= (c
+ align
- 1) & -align
;
7058 if (align
> maxalign
)
7062 printf("add field %s offset=%d",
7063 get_tok_str(v
, NULL
), offset
);
7064 if (type1
.t
& VT_BITFIELD
) {
7065 printf(" pos=%d size=%d",
7066 (type1
.t
>> VT_STRUCT_SHIFT
) & 0x3f,
7067 (type1
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f);
7072 if (v
== 0 && (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
7074 while ((ass
= ass
->next
) != NULL
) {
7075 ss
= sym_push(ass
->v
, &ass
->type
, 0, offset
+ ass
->c
);
7080 ss
= sym_push(v
| SYM_FIELD
, &type1
, 0, offset
);
7084 if (tok
== ';' || tok
== TOK_EOF
)
7091 /* store size and alignment */
7092 s
->c
= (c
+ maxalign
- 1) & -maxalign
;
7098 /* return 0 if no type declaration. otherwise, return the basic type
7101 static int parse_btype(CType
*type
, AttributeDef
*ad
)
7103 int t
, u
, type_found
, typespec_found
, typedef_found
;
7107 memset(ad
, 0, sizeof(AttributeDef
));
7115 /* currently, we really ignore extension */
7125 if ((t
& VT_BTYPE
) != 0)
7126 error("too many basic types");
7142 if ((t
& VT_BTYPE
) == VT_DOUBLE
) {
7143 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
7144 } else if ((t
& VT_BTYPE
) == VT_LONG
) {
7145 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
7159 if ((t
& VT_BTYPE
) == VT_LONG
) {
7160 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
7167 struct_decl(&type1
, VT_ENUM
);
7170 type
->ref
= type1
.ref
;
7174 struct_decl(&type1
, VT_STRUCT
);
7177 /* type modifiers */
7230 /* GNUC attribute */
7231 case TOK_ATTRIBUTE1
:
7232 case TOK_ATTRIBUTE2
:
7233 parse_attribute(ad
);
7240 parse_expr_type(&type1
);
7243 if (typespec_found
|| typedef_found
)
7246 if (!s
|| !(s
->type
.t
& VT_TYPEDEF
))
7249 t
|= (s
->type
.t
& ~VT_TYPEDEF
);
7250 type
->ref
= s
->type
.ref
;
7258 if ((t
& (VT_SIGNED
|VT_UNSIGNED
)) == (VT_SIGNED
|VT_UNSIGNED
))
7259 error("signed and unsigned modifier");
7260 if (tcc_state
->char_is_unsigned
) {
7261 if ((t
& (VT_SIGNED
|VT_UNSIGNED
|VT_BTYPE
)) == VT_BYTE
)
7266 /* long is never used as type */
7267 if ((t
& VT_BTYPE
) == VT_LONG
)
7268 #ifndef TCC_TARGET_X86_64
7269 t
= (t
& ~VT_BTYPE
) | VT_INT
;
7271 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
7277 /* convert a function parameter type (array to pointer and function to
7278 function pointer) */
7279 static inline void convert_parameter_type(CType
*pt
)
7281 /* remove const and volatile qualifiers (XXX: const could be used
7282 to indicate a const function parameter */
7283 pt
->t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
7284 /* array must be transformed to pointer according to ANSI C */
7286 if ((pt
->t
& VT_BTYPE
) == VT_FUNC
) {
7291 static void post_type(CType
*type
, AttributeDef
*ad
)
7293 int n
, l
, t1
, arg_size
, align
;
7294 Sym
**plast
, *s
, *first
;
7299 /* function declaration */
7307 /* read param name and compute offset */
7308 if (l
!= FUNC_OLD
) {
7309 if (!parse_btype(&pt
, &ad1
)) {
7311 error("invalid type");
7318 if ((pt
.t
& VT_BTYPE
) == VT_VOID
&& tok
== ')')
7320 type_decl(&pt
, &ad1
, &n
, TYPE_DIRECT
| TYPE_ABSTRACT
);
7321 if ((pt
.t
& VT_BTYPE
) == VT_VOID
)
7322 error("parameter declared as void");
7323 arg_size
+= (type_size(&pt
, &align
) + 3) & ~3;
7328 expect("identifier");
7332 convert_parameter_type(&pt
);
7333 s
= sym_push(n
| SYM_FIELD
, &pt
, 0, 0);
7339 if (l
== FUNC_NEW
&& tok
== TOK_DOTS
) {
7346 /* if no parameters, then old type prototype */
7350 t1
= type
->t
& VT_STORAGE
;
7351 /* NOTE: const is ignored in returned type as it has a special
7352 meaning in gcc / C++ */
7353 type
->t
&= ~(VT_STORAGE
| VT_CONSTANT
);
7354 post_type(type
, ad
);
7355 /* we push a anonymous symbol which will contain the function prototype */
7356 FUNC_ARGS(ad
->func_attr
) = arg_size
;
7357 s
= sym_push(SYM_FIELD
, type
, ad
->func_attr
, l
);
7359 type
->t
= t1
| VT_FUNC
;
7361 } else if (tok
== '[') {
7362 /* array definition */
7364 if (tok
== TOK_RESTRICT1
)
7370 error("invalid array size");
7373 /* parse next post type */
7374 t1
= type
->t
& VT_STORAGE
;
7375 type
->t
&= ~VT_STORAGE
;
7376 post_type(type
, ad
);
7378 /* we push a anonymous symbol which will contain the array
7380 s
= sym_push(SYM_FIELD
, type
, 0, n
);
7381 type
->t
= t1
| VT_ARRAY
| VT_PTR
;
7386 /* Parse a type declaration (except basic type), and return the type
7387 in 'type'. 'td' is a bitmask indicating which kind of type decl is
7388 expected. 'type' should contain the basic type. 'ad' is the
7389 attribute definition of the basic type. It can be modified by
7392 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
)
7395 CType type1
, *type2
;
7398 while (tok
== '*') {
7406 qualifiers
|= VT_CONSTANT
;
7411 qualifiers
|= VT_VOLATILE
;
7419 type
->t
|= qualifiers
;
7422 /* XXX: clarify attribute handling */
7423 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
7424 parse_attribute(ad
);
7426 /* recursive type */
7427 /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
7428 type1
.t
= 0; /* XXX: same as int */
7431 /* XXX: this is not correct to modify 'ad' at this point, but
7432 the syntax is not clear */
7433 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
7434 parse_attribute(ad
);
7435 type_decl(&type1
, ad
, v
, td
);
7438 /* type identifier */
7439 if (tok
>= TOK_IDENT
&& (td
& TYPE_DIRECT
)) {
7443 if (!(td
& TYPE_ABSTRACT
))
7444 expect("identifier");
7448 post_type(type
, ad
);
7449 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
7450 parse_attribute(ad
);
7453 /* append type at the end of type1 */
7466 /* compute the lvalue VT_LVAL_xxx needed to match type t. */
7467 static int lvalue_type(int t
)
7472 if (bt
== VT_BYTE
|| bt
== VT_BOOL
)
7474 else if (bt
== VT_SHORT
)
7478 if (t
& VT_UNSIGNED
)
7479 r
|= VT_LVAL_UNSIGNED
;
7483 /* indirection with full error checking and bound check */
7484 static void indir(void)
7486 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
) {
7487 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FUNC
)
7491 if ((vtop
->r
& VT_LVAL
) && !nocode_wanted
)
7493 vtop
->type
= *pointed_type(&vtop
->type
);
7494 /* Arrays and functions are never lvalues */
7495 if (!(vtop
->type
.t
& VT_ARRAY
)
7496 && (vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
7497 vtop
->r
|= lvalue_type(vtop
->type
.t
);
7498 /* if bound checking, the referenced pointer must be checked */
7499 if (do_bounds_check
)
7500 vtop
->r
|= VT_MUSTBOUND
;
7504 /* pass a parameter to a function and do type checking and casting */
7505 static void gfunc_param_typed(Sym
*func
, Sym
*arg
)
7510 func_type
= func
->c
;
7511 if (func_type
== FUNC_OLD
||
7512 (func_type
== FUNC_ELLIPSIS
&& arg
== NULL
)) {
7513 /* default casting : only need to convert float to double */
7514 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
) {
7518 } else if (arg
== NULL
) {
7519 error("too many arguments to function");
7522 type
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
7523 gen_assign_cast(&type
);
7527 /* parse an expression of the form '(type)' or '(expr)' and return its
7529 static void parse_expr_type(CType
*type
)
7535 if (parse_btype(type
, &ad
)) {
7536 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
7543 static void parse_type(CType
*type
)
7548 if (!parse_btype(type
, &ad
)) {
7551 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
7554 static void vpush_tokc(int t
)
7558 vsetc(&type
, VT_CONST
, &tokc
);
7561 static void unary(void)
7563 int n
, t
, align
, size
, r
;
7568 /* XXX: GCC 2.95.3 does not generate a table although it should be
7582 vpush_tokc(VT_INT
| VT_UNSIGNED
);
7586 vpush_tokc(VT_LLONG
);
7590 vpush_tokc(VT_LLONG
| VT_UNSIGNED
);
7594 vpush_tokc(VT_FLOAT
);
7598 vpush_tokc(VT_DOUBLE
);
7602 vpush_tokc(VT_LDOUBLE
);
7605 case TOK___FUNCTION__
:
7607 goto tok_identifier
;
7613 /* special function name identifier */
7614 len
= strlen(funcname
) + 1;
7615 /* generate char[len] type */
7620 vpush_ref(&type
, data_section
, data_section
->data_offset
, len
);
7621 ptr
= section_ptr_add(data_section
, len
);
7622 memcpy(ptr
, funcname
, len
);
7627 #ifdef TCC_TARGET_PE
7628 t
= VT_SHORT
| VT_UNSIGNED
;
7634 /* string parsing */
7637 if (tcc_state
->warn_write_strings
)
7642 memset(&ad
, 0, sizeof(AttributeDef
));
7643 decl_initializer_alloc(&type
, &ad
, VT_CONST
, 2, 0, 0);
7648 if (parse_btype(&type
, &ad
)) {
7649 type_decl(&type
, &ad
, &n
, TYPE_ABSTRACT
);
7651 /* check ISOC99 compound literal */
7653 /* data is allocated locally by default */
7658 /* all except arrays are lvalues */
7659 if (!(type
.t
& VT_ARRAY
))
7660 r
|= lvalue_type(type
.t
);
7661 memset(&ad
, 0, sizeof(AttributeDef
));
7662 decl_initializer_alloc(&type
, &ad
, r
, 1, 0, 0);
7667 } else if (tok
== '{') {
7668 /* save all registers */
7670 /* statement expression : we do not accept break/continue
7671 inside as GCC does */
7672 block(NULL
, NULL
, NULL
, NULL
, 0, 1);
7687 /* functions names must be treated as function pointers,
7688 except for unary '&' and sizeof. Since we consider that
7689 functions are not lvalues, we only have to handle it
7690 there and in function calls. */
7691 /* arrays can also be used although they are not lvalues */
7692 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
&&
7693 !(vtop
->type
.t
& VT_ARRAY
) && !(vtop
->type
.t
& VT_LLOCAL
))
7695 mk_pointer(&vtop
->type
);
7701 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
7703 boolean
.t
= VT_BOOL
;
7705 vtop
->c
.i
= !vtop
->c
.i
;
7706 } else if ((vtop
->r
& VT_VALMASK
) == VT_CMP
)
7707 vtop
->c
.i
= vtop
->c
.i
^ 1;
7710 vseti(VT_JMP
, gtst(1, 0));
7721 /* in order to force cast, we add zero */
7723 if ((vtop
->type
.t
& VT_BTYPE
) == VT_PTR
)
7724 error("pointer not accepted for unary plus");
7734 parse_expr_type(&type
);
7738 size
= type_size(&type
, &align
);
7739 if (t
== TOK_SIZEOF
) {
7741 error("sizeof applied to an incomplete type");
7746 vtop
->type
.t
|= VT_UNSIGNED
;
7749 case TOK_builtin_types_compatible_p
:
7758 type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
7759 type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
7760 vpushi(is_compatible_types(&type1
, &type2
));
7763 case TOK_builtin_constant_p
:
7765 int saved_nocode_wanted
, res
;
7768 saved_nocode_wanted
= nocode_wanted
;
7771 res
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
7773 nocode_wanted
= saved_nocode_wanted
;
7778 case TOK_builtin_frame_address
:
7783 if (tok
!= TOK_CINT
) {
7784 error("__builtin_frame_address only takes integers");
7787 error("TCC only supports __builtin_frame_address(0)");
7793 vset(&type
, VT_LOCAL
, 0);
7796 #ifdef TCC_TARGET_X86_64
7797 case TOK_builtin_malloc
:
7799 char *p
= file
->buf_ptr
;
7800 file
->buf_ptr
= "malloc";
7803 goto tok_identifier
;
7805 case TOK_builtin_free
:
7807 char *p
= file
->buf_ptr
;
7808 file
->buf_ptr
= "free";
7811 goto tok_identifier
;
7829 goto tok_identifier
;
7831 /* allow to take the address of a label */
7832 if (tok
< TOK_UIDENT
)
7833 expect("label identifier");
7834 s
= label_find(tok
);
7836 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
7838 if (s
->r
== LABEL_DECLARED
)
7839 s
->r
= LABEL_FORWARD
;
7842 s
->type
.t
= VT_VOID
;
7843 mk_pointer(&s
->type
);
7844 s
->type
.t
|= VT_STATIC
;
7846 vset(&s
->type
, VT_CONST
| VT_SYM
, 0);
7855 expect("identifier");
7859 error("'%s' undeclared", get_tok_str(t
, NULL
));
7860 /* for simple function calls, we tolerate undeclared
7861 external reference to int() function */
7862 if (tcc_state
->warn_implicit_function_declaration
)
7863 warning("implicit declaration of function '%s'",
7864 get_tok_str(t
, NULL
));
7865 s
= external_global_sym(t
, &func_old_type
, 0);
7867 if ((s
->type
.t
& (VT_STATIC
| VT_INLINE
| VT_BTYPE
)) ==
7868 (VT_STATIC
| VT_INLINE
| VT_FUNC
)) {
7869 /* if referencing an inline function, then we generate a
7870 symbol to it if not already done. It will have the
7871 effect to generate code for it at the end of the
7872 compilation unit. Inline function as always
7873 generated in the text section. */
7875 put_extern_sym(s
, text_section
, 0, 0);
7876 r
= VT_SYM
| VT_CONST
;
7880 vset(&s
->type
, r
, s
->c
);
7881 /* if forward reference, we must point to s */
7882 if (vtop
->r
& VT_SYM
) {
7889 /* post operations */
7891 if (tok
== TOK_INC
|| tok
== TOK_DEC
) {
7894 } else if (tok
== '.' || tok
== TOK_ARROW
) {
7896 if (tok
== TOK_ARROW
)
7901 /* expect pointer on structure */
7902 if ((vtop
->type
.t
& VT_BTYPE
) != VT_STRUCT
)
7903 expect("struct or union");
7907 while ((s
= s
->next
) != NULL
) {
7912 error("field not found: %s", get_tok_str(tok
& ~SYM_FIELD
, NULL
));
7913 /* add field offset to pointer */
7914 vtop
->type
= char_pointer_type
; /* change type to 'char *' */
7917 /* change type to field type, and set to lvalue */
7918 vtop
->type
= s
->type
;
7919 /* an array is never an lvalue */
7920 if (!(vtop
->type
.t
& VT_ARRAY
)) {
7921 vtop
->r
|= lvalue_type(vtop
->type
.t
);
7922 /* if bound checking, the referenced pointer must be checked */
7923 if (do_bounds_check
)
7924 vtop
->r
|= VT_MUSTBOUND
;
7927 } else if (tok
== '[') {
7933 } else if (tok
== '(') {
7939 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
7940 /* pointer test (no array accepted) */
7941 if ((vtop
->type
.t
& (VT_BTYPE
| VT_ARRAY
)) == VT_PTR
) {
7942 vtop
->type
= *pointed_type(&vtop
->type
);
7943 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
)
7947 expect("function pointer");
7950 vtop
->r
&= ~VT_LVAL
; /* no lvalue */
7952 /* get return type */
7955 sa
= s
->next
; /* first parameter */
7958 /* compute first implicit argument if a structure is returned */
7959 if ((s
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
7960 /* get some space for the returned structure */
7961 size
= type_size(&s
->type
, &align
);
7962 loc
= (loc
- size
) & -align
;
7964 ret
.r
= VT_LOCAL
| VT_LVAL
;
7965 /* pass it as 'int' to avoid structure arg passing
7967 vseti(VT_LOCAL
, loc
);
7972 /* return in register */
7973 if (is_float(ret
.type
.t
)) {
7974 ret
.r
= reg_fret(ret
.type
.t
);
7976 if ((ret
.type
.t
& VT_BTYPE
) == VT_LLONG
)
7985 gfunc_param_typed(s
, sa
);
7995 error("too few arguments to function");
7997 if (!nocode_wanted
) {
7998 gfunc_call(nb_args
);
8000 vtop
-= (nb_args
+ 1);
8003 vsetc(&ret
.type
, ret
.r
, &ret
.c
);
8011 static void uneq(void)
8017 (tok
>= TOK_A_MOD
&& tok
<= TOK_A_DIV
) ||
8018 tok
== TOK_A_XOR
|| tok
== TOK_A_OR
||
8019 tok
== TOK_A_SHL
|| tok
== TOK_A_SAR
) {
8034 static void expr_prod(void)
8039 while (tok
== '*' || tok
== '/' || tok
== '%') {
8047 static void expr_sum(void)
8052 while (tok
== '+' || tok
== '-') {
8060 static void expr_shift(void)
8065 while (tok
== TOK_SHL
|| tok
== TOK_SAR
) {
8073 static void expr_cmp(void)
8078 while ((tok
>= TOK_ULE
&& tok
<= TOK_GT
) ||
8079 tok
== TOK_ULT
|| tok
== TOK_UGE
) {
8087 static void expr_cmpeq(void)
8092 while (tok
== TOK_EQ
|| tok
== TOK_NE
) {
8100 static void expr_and(void)
8103 while (tok
== '&') {
8110 static void expr_xor(void)
8113 while (tok
== '^') {
8120 static void expr_or(void)
8123 while (tok
== '|') {
8130 /* XXX: fix this mess */
8131 static void expr_land_const(void)
8134 while (tok
== TOK_LAND
) {
8141 /* XXX: fix this mess */
8142 static void expr_lor_const(void)
8145 while (tok
== TOK_LOR
) {
8152 /* only used if non constant */
8153 static void expr_land(void)
8158 if (tok
== TOK_LAND
) {
8163 if (tok
!= TOK_LAND
) {
8173 static void expr_lor(void)
8178 if (tok
== TOK_LOR
) {
8183 if (tok
!= TOK_LOR
) {
8193 /* XXX: better constant handling */
8194 static void expr_eq(void)
8196 int tt
, u
, r1
, r2
, rc
, t1
, t2
, bt1
, bt2
;
8198 CType type
, type1
, type2
;
8205 boolean
.t
= VT_BOOL
;
8211 if (tok
!= ':' || !gnu_ext
) {
8226 if (vtop
!= vstack
) {
8227 /* needed to avoid having different registers saved in
8229 if (is_float(vtop
->type
.t
)) {
8231 #ifdef TCC_TARGET_X86_64
8232 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LDOUBLE
) {
8242 if (tok
== ':' && gnu_ext
) {
8250 sv
= *vtop
; /* save value to handle it later */
8251 vtop
--; /* no vpop so that FP stack is not flushed */
8259 bt1
= t1
& VT_BTYPE
;
8261 bt2
= t2
& VT_BTYPE
;
8262 /* cast operands to correct type according to ISOC rules */
8263 if (is_float(bt1
) || is_float(bt2
)) {
8264 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
8265 type
.t
= VT_LDOUBLE
;
8266 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
8271 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
8272 /* cast to biggest op */
8274 /* convert to unsigned if it does not fit in a long long */
8275 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
8276 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
8277 type
.t
|= VT_UNSIGNED
;
8278 } else if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
8279 /* XXX: test pointer compatibility */
8281 } else if (bt1
== VT_FUNC
|| bt2
== VT_FUNC
) {
8282 /* XXX: test function pointer compatibility */
8284 } else if (bt1
== VT_STRUCT
|| bt2
== VT_STRUCT
) {
8285 /* XXX: test structure compatibility */
8287 } else if (bt1
== VT_VOID
|| bt2
== VT_VOID
) {
8288 /* NOTE: as an extension, we accept void on only one side */
8291 /* integer operations */
8293 /* convert to unsigned if it does not fit in an integer */
8294 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
8295 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
8296 type
.t
|= VT_UNSIGNED
;
8299 /* now we convert second operand */
8301 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
8304 if (is_float(type
.t
)) {
8306 #ifdef TCC_TARGET_X86_64
8307 if ((type
.t
& VT_BTYPE
) == VT_LDOUBLE
) {
8311 } else if ((type
.t
& VT_BTYPE
) == VT_LLONG
) {
8312 /* for long longs, we use fixed registers to avoid having
8313 to handle a complicated move */
8318 /* this is horrible, but we must also convert first
8322 /* put again first value and cast it */
8325 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
8335 static void gexpr(void)
8346 /* parse an expression and return its type without any side effect. */
8347 static void expr_type(CType
*type
)
8349 int saved_nocode_wanted
;
8351 saved_nocode_wanted
= nocode_wanted
;
8356 nocode_wanted
= saved_nocode_wanted
;
8359 /* parse a unary expression and return its type without any side
8361 static void unary_type(CType
*type
)
8373 /* parse a constant expression and return value in vtop. */
8374 static void expr_const1(void)
8383 /* parse an integer constant and return its value. */
8384 static int expr_const(void)
8388 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
8389 expect("constant expression");
8395 /* return the label token if current token is a label, otherwise
8397 static int is_label(void)
8401 /* fast test first */
8402 if (tok
< TOK_UIDENT
)
8404 /* no need to save tokc because tok is an identifier */
8411 unget_tok(last_tok
);
8416 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
,
8417 int case_reg
, int is_expr
)
8422 /* generate line number info */
8424 (last_line_num
!= file
->line_num
|| last_ind
!= ind
)) {
8425 put_stabn(N_SLINE
, 0, file
->line_num
, ind
- func_ind
);
8427 last_line_num
= file
->line_num
;
8431 /* default return value is (void) */
8433 vtop
->type
.t
= VT_VOID
;
8436 if (tok
== TOK_IF
) {
8443 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
8445 if (c
== TOK_ELSE
) {
8449 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
8450 gsym(d
); /* patch else jmp */
8453 } else if (tok
== TOK_WHILE
) {
8461 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
8465 } else if (tok
== '{') {
8469 /* record local declaration stack position */
8471 llabel
= local_label_stack
;
8472 /* handle local labels declarations */
8473 if (tok
== TOK_LABEL
) {
8476 if (tok
< TOK_UIDENT
)
8477 expect("label identifier");
8478 label_push(&local_label_stack
, tok
, LABEL_DECLARED
);
8488 while (tok
!= '}') {
8493 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
8496 /* pop locally defined labels */
8497 label_pop(&local_label_stack
, llabel
);
8498 /* pop locally defined symbols */
8500 /* XXX: this solution makes only valgrind happy...
8501 triggered by gcc.c-torture/execute/20000917-1.c */
8503 switch(vtop
->type
.t
& VT_BTYPE
) {
8508 for(p
=vtop
->type
.ref
;p
;p
=p
->prev
)
8510 error("unsupported expression type");
8513 sym_pop(&local_stack
, s
);
8515 } else if (tok
== TOK_RETURN
) {
8519 gen_assign_cast(&func_vt
);
8520 if ((func_vt
.t
& VT_BTYPE
) == VT_STRUCT
) {
8522 /* if returning structure, must copy it to implicit
8523 first pointer arg location */
8526 size
= type_size(&func_vt
,&align
);
8529 if((vtop
->r
!= (VT_LOCAL
| VT_LVAL
) || (vtop
->c
.i
& 3))
8533 loc
= (loc
- size
) & -4;
8536 vset(&type
, VT_LOCAL
| VT_LVAL
, addr
);
8539 vset(&int_type
, VT_LOCAL
| VT_LVAL
, addr
);
8541 vtop
->type
= int_type
;
8547 vset(&type
, VT_LOCAL
| VT_LVAL
, func_vc
);
8550 /* copy structure value to pointer */
8555 } else if (is_float(func_vt
.t
)) {
8556 gv(rc_fret(func_vt
.t
));
8560 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
8563 rsym
= gjmp(rsym
); /* jmp */
8564 } else if (tok
== TOK_BREAK
) {
8567 error("cannot break");
8568 *bsym
= gjmp(*bsym
);
8571 } else if (tok
== TOK_CONTINUE
) {
8574 error("cannot continue");
8575 *csym
= gjmp(*csym
);
8578 } else if (tok
== TOK_FOR
) {
8605 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
8610 if (tok
== TOK_DO
) {
8615 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
8626 if (tok
== TOK_SWITCH
) {
8630 /* XXX: other types than integer */
8631 case_reg
= gv(RC_INT
);
8635 b
= gjmp(0); /* jump to first case */
8637 block(&a
, csym
, &b
, &c
, case_reg
, 0);
8638 /* if no default, jmp after switch */
8646 if (tok
== TOK_CASE
) {
8653 if (gnu_ext
&& tok
== TOK_DOTS
) {
8657 warning("empty case range");
8659 /* since a case is like a label, we must skip it with a jmp */
8666 *case_sym
= gtst(1, 0);
8669 *case_sym
= gtst(1, 0);
8673 *case_sym
= gtst(1, *case_sym
);
8678 goto block_after_label
;
8680 if (tok
== TOK_DEFAULT
) {
8686 error("too many 'default'");
8689 goto block_after_label
;
8691 if (tok
== TOK_GOTO
) {
8693 if (tok
== '*' && gnu_ext
) {
8697 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
)
8700 } else if (tok
>= TOK_UIDENT
) {
8701 s
= label_find(tok
);
8702 /* put forward definition if needed */
8704 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
8706 if (s
->r
== LABEL_DECLARED
)
8707 s
->r
= LABEL_FORWARD
;
8709 /* label already defined */
8710 if (s
->r
& LABEL_FORWARD
)
8711 s
->next
= (void *)gjmp((long)s
->next
);
8713 gjmp_addr((long)s
->next
);
8716 expect("label identifier");
8719 } else if (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
) {
8727 if (s
->r
== LABEL_DEFINED
)
8728 error("duplicate label '%s'", get_tok_str(s
->v
, NULL
));
8729 gsym((long)s
->next
);
8730 s
->r
= LABEL_DEFINED
;
8732 s
= label_push(&global_label_stack
, b
, LABEL_DEFINED
);
8734 s
->next
= (void *)ind
;
8735 /* we accept this, but it is a mistake */
8738 warning("deprecated use of label at end of compound statement");
8742 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
8745 /* expression case */
8760 /* t is the array or struct type. c is the array or struct
8761 address. cur_index/cur_field is the pointer to the current
8762 value. 'size_only' is true if only size info is needed (only used
8764 static void decl_designator(CType
*type
, Section
*sec
, unsigned long c
,
8765 int *cur_index
, Sym
**cur_field
,
8769 int notfirst
, index
, index_last
, align
, l
, nb_elems
, elem_size
;
8775 if (gnu_ext
&& (l
= is_label()) != 0)
8777 while (tok
== '[' || tok
== '.') {
8779 if (!(type
->t
& VT_ARRAY
))
8780 expect("array type");
8783 index
= expr_const();
8784 if (index
< 0 || (s
->c
>= 0 && index
>= s
->c
))
8785 expect("invalid index");
8786 if (tok
== TOK_DOTS
&& gnu_ext
) {
8788 index_last
= expr_const();
8789 if (index_last
< 0 ||
8790 (s
->c
>= 0 && index_last
>= s
->c
) ||
8792 expect("invalid index");
8798 *cur_index
= index_last
;
8799 type
= pointed_type(type
);
8800 elem_size
= type_size(type
, &align
);
8801 c
+= index
* elem_size
;
8802 /* NOTE: we only support ranges for last designator */
8803 nb_elems
= index_last
- index
+ 1;
8804 if (nb_elems
!= 1) {
8813 if ((type
->t
& VT_BTYPE
) != VT_STRUCT
)
8814 expect("struct/union type");
8827 /* XXX: fix this mess by using explicit storage field */
8829 type1
.t
|= (type
->t
& ~VT_TYPE
);
8843 if (type
->t
& VT_ARRAY
) {
8845 type
= pointed_type(type
);
8846 c
+= index
* type_size(type
, &align
);
8850 error("too many field init");
8851 /* XXX: fix this mess by using explicit storage field */
8853 type1
.t
|= (type
->t
& ~VT_TYPE
);
8858 decl_initializer(type
, sec
, c
, 0, size_only
);
8860 /* XXX: make it more general */
8861 if (!size_only
&& nb_elems
> 1) {
8862 unsigned long c_end
;
8867 error("range init not supported yet for dynamic storage");
8868 c_end
= c
+ nb_elems
* elem_size
;
8869 if (c_end
> sec
->data_allocated
)
8870 section_realloc(sec
, c_end
);
8871 src
= sec
->data
+ c
;
8873 for(i
= 1; i
< nb_elems
; i
++) {
8875 memcpy(dst
, src
, elem_size
);
8881 #define EXPR_CONST 1
8884 /* store a value or an expression directly in global data or in local array */
8885 static void init_putv(CType
*type
, Section
*sec
, unsigned long c
,
8886 int v
, int expr_type
)
8888 int saved_global_expr
, bt
, bit_pos
, bit_size
;
8890 unsigned long long bit_mask
;
8898 /* compound literals must be allocated globally in this case */
8899 saved_global_expr
= global_expr
;
8902 global_expr
= saved_global_expr
;
8903 /* NOTE: symbols are accepted */
8904 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) != VT_CONST
)
8905 error("initializer element is not constant");
8913 dtype
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
8916 /* XXX: not portable */
8917 /* XXX: generate error if incorrect relocation */
8918 gen_assign_cast(&dtype
);
8919 bt
= type
->t
& VT_BTYPE
;
8920 /* we'll write at most 12 bytes */
8921 if (c
+ 12 > sec
->data_allocated
) {
8922 section_realloc(sec
, c
+ 12);
8924 ptr
= sec
->data
+ c
;
8925 /* XXX: make code faster ? */
8926 if (!(type
->t
& VT_BITFIELD
)) {
8931 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
8932 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
8933 bit_mask
= (1LL << bit_size
) - 1;
8935 if ((vtop
->r
& VT_SYM
) &&
8941 (bt
== VT_INT
&& bit_size
!= 32)))
8942 error("initializer element is not computable at load time");
8945 vtop
->c
.i
= (vtop
->c
.i
!= 0);
8947 *(char *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
8950 *(short *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
8953 *(double *)ptr
= vtop
->c
.d
;
8956 *(long double *)ptr
= vtop
->c
.ld
;
8959 *(long long *)ptr
|= (vtop
->c
.ll
& bit_mask
) << bit_pos
;
8962 if (vtop
->r
& VT_SYM
) {
8963 greloc(sec
, vtop
->sym
, c
, R_DATA_32
);
8965 *(int *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
8970 vset(&dtype
, VT_LOCAL
|VT_LVAL
, c
);
8977 /* put zeros for variable based init */
8978 static void init_putz(CType
*t
, Section
*sec
, unsigned long c
, int size
)
8981 /* nothing to do because globals are already set to zero */
8983 vpush_global_sym(&func_old_type
, TOK_memset
);
8991 /* 't' contains the type and storage info. 'c' is the offset of the
8992 object in section 'sec'. If 'sec' is NULL, it means stack based
8993 allocation. 'first' is true if array '{' must be read (multi
8994 dimension implicit array init handling). 'size_only' is true if
8995 size only evaluation is wanted (only for arrays). */
8996 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
8997 int first
, int size_only
)
8999 int index
, array_length
, n
, no_oblock
, nb
, parlevel
, i
;
9000 int size1
, align1
, expr_type
;
9004 if (type
->t
& VT_ARRAY
) {
9008 t1
= pointed_type(type
);
9009 size1
= type_size(t1
, &align1
);
9012 if ((first
&& tok
!= TOK_LSTR
&& tok
!= TOK_STR
) ||
9018 /* only parse strings here if correct type (otherwise: handle
9019 them as ((w)char *) expressions */
9020 if ((tok
== TOK_LSTR
&&
9021 #ifdef TCC_TARGET_PE
9022 (t1
->t
& VT_BTYPE
) == VT_SHORT
&& (t1
->t
& VT_UNSIGNED
)
9024 (t1
->t
& VT_BTYPE
) == VT_INT
9026 ) || (tok
== TOK_STR
&& (t1
->t
& VT_BTYPE
) == VT_BYTE
)) {
9027 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
9032 /* compute maximum number of chars wanted */
9034 cstr_len
= cstr
->size
;
9036 cstr_len
= cstr
->size
/ sizeof(nwchar_t
);
9039 if (n
>= 0 && nb
> (n
- array_length
))
9040 nb
= n
- array_length
;
9043 warning("initializer-string for array is too long");
9044 /* in order to go faster for common case (char
9045 string in global variable, we handle it
9047 if (sec
&& tok
== TOK_STR
&& size1
== 1) {
9048 memcpy(sec
->data
+ c
+ array_length
, cstr
->data
, nb
);
9052 ch
= ((unsigned char *)cstr
->data
)[i
];
9054 ch
= ((nwchar_t
*)cstr
->data
)[i
];
9055 init_putv(t1
, sec
, c
+ (array_length
+ i
) * size1
,
9063 /* only add trailing zero if enough storage (no
9064 warning in this case since it is standard) */
9065 if (n
< 0 || array_length
< n
) {
9067 init_putv(t1
, sec
, c
+ (array_length
* size1
), 0, EXPR_VAL
);
9073 while (tok
!= '}') {
9074 decl_designator(type
, sec
, c
, &index
, NULL
, size_only
);
9075 if (n
>= 0 && index
>= n
)
9076 error("index too large");
9077 /* must put zero in holes (note that doing it that way
9078 ensures that it even works with designators) */
9079 if (!size_only
&& array_length
< index
) {
9080 init_putz(t1
, sec
, c
+ array_length
* size1
,
9081 (index
- array_length
) * size1
);
9084 if (index
> array_length
)
9085 array_length
= index
;
9086 /* special test for multi dimensional arrays (may not
9087 be strictly correct if designators are used at the
9089 if (index
>= n
&& no_oblock
)
9098 /* put zeros at the end */
9099 if (!size_only
&& n
>= 0 && array_length
< n
) {
9100 init_putz(t1
, sec
, c
+ array_length
* size1
,
9101 (n
- array_length
) * size1
);
9103 /* patch type size if needed */
9105 s
->c
= array_length
;
9106 } else if ((type
->t
& VT_BTYPE
) == VT_STRUCT
&&
9107 (sec
|| !first
|| tok
== '{')) {
9110 /* NOTE: the previous test is a specific case for automatic
9111 struct/union init */
9112 /* XXX: union needs only one init */
9114 /* XXX: this test is incorrect for local initializers
9115 beginning with ( without {. It would be much more difficult
9116 to do it correctly (ideally, the expression parser should
9117 be used in all cases) */
9123 while (tok
== '(') {
9127 if (!parse_btype(&type1
, &ad1
))
9129 type_decl(&type1
, &ad1
, &n
, TYPE_ABSTRACT
);
9131 if (!is_assignable_types(type
, &type1
))
9132 error("invalid type for cast");
9137 if (first
|| tok
== '{') {
9146 while (tok
!= '}') {
9147 decl_designator(type
, sec
, c
, NULL
, &f
, size_only
);
9149 if (!size_only
&& array_length
< index
) {
9150 init_putz(type
, sec
, c
+ array_length
,
9151 index
- array_length
);
9153 index
= index
+ type_size(&f
->type
, &align1
);
9154 if (index
> array_length
)
9155 array_length
= index
;
9157 if (no_oblock
&& f
== NULL
)
9163 /* put zeros at the end */
9164 if (!size_only
&& array_length
< n
) {
9165 init_putz(type
, sec
, c
+ array_length
,
9174 } else if (tok
== '{') {
9176 decl_initializer(type
, sec
, c
, first
, size_only
);
9178 } else if (size_only
) {
9179 /* just skip expression */
9181 while ((parlevel
> 0 || (tok
!= '}' && tok
!= ',')) &&
9185 else if (tok
== ')')
9190 /* currently, we always use constant expression for globals
9191 (may change for scripting case) */
9192 expr_type
= EXPR_CONST
;
9194 expr_type
= EXPR_ANY
;
9195 init_putv(type
, sec
, c
, 0, expr_type
);
9199 /* parse an initializer for type 't' if 'has_init' is non zero, and
9200 allocate space in local or global data space ('r' is either
9201 VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
9202 variable 'v' of scope 'scope' is declared before initializers are
9203 parsed. If 'v' is zero, then a reference to the new object is put
9204 in the value stack. If 'has_init' is 2, a special parsing is done
9205 to handle string constants. */
9206 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
9207 int has_init
, int v
, int scope
)
9209 int size
, align
, addr
, data_offset
;
9211 ParseState saved_parse_state
;
9212 TokenString init_str
;
9215 size
= type_size(type
, &align
);
9216 /* If unknown size, we must evaluate it before
9217 evaluating initializers because
9218 initializers can generate global data too
9219 (e.g. string pointers or ISOC99 compound
9220 literals). It also simplifies local
9221 initializers handling */
9222 tok_str_new(&init_str
);
9225 error("unknown type size");
9226 /* get all init string */
9227 if (has_init
== 2) {
9228 /* only get strings */
9229 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
9230 tok_str_add_tok(&init_str
);
9235 while (level
> 0 || (tok
!= ',' && tok
!= ';')) {
9237 error("unexpected end of file in initializer");
9238 tok_str_add_tok(&init_str
);
9241 else if (tok
== '}') {
9251 tok_str_add(&init_str
, -1);
9252 tok_str_add(&init_str
, 0);
9255 save_parse_state(&saved_parse_state
);
9257 macro_ptr
= init_str
.str
;
9259 decl_initializer(type
, NULL
, 0, 1, 1);
9260 /* prepare second initializer parsing */
9261 macro_ptr
= init_str
.str
;
9264 /* if still unknown size, error */
9265 size
= type_size(type
, &align
);
9267 error("unknown type size");
9269 /* take into account specified alignment if bigger */
9271 if (ad
->aligned
> align
)
9272 align
= ad
->aligned
;
9273 } else if (ad
->packed
) {
9276 if ((r
& VT_VALMASK
) == VT_LOCAL
) {
9278 if (do_bounds_check
&& (type
->t
& VT_ARRAY
))
9280 loc
= (loc
- size
) & -align
;
9282 /* handles bounds */
9283 /* XXX: currently, since we do only one pass, we cannot track
9284 '&' operators, so we add only arrays */
9285 if (do_bounds_check
&& (type
->t
& VT_ARRAY
)) {
9286 unsigned long *bounds_ptr
;
9287 /* add padding between regions */
9289 /* then add local bound info */
9290 bounds_ptr
= section_ptr_add(lbounds_section
, 2 * sizeof(unsigned long));
9291 bounds_ptr
[0] = addr
;
9292 bounds_ptr
[1] = size
;
9295 /* local variable */
9296 sym_push(v
, type
, r
, addr
);
9298 /* push local reference */
9299 vset(type
, r
, addr
);
9305 if (v
&& scope
== VT_CONST
) {
9306 /* see if the symbol was already defined */
9309 if (!is_compatible_types(&sym
->type
, type
))
9310 error("incompatible types for redefinition of '%s'",
9311 get_tok_str(v
, NULL
));
9312 if (sym
->type
.t
& VT_EXTERN
) {
9313 /* if the variable is extern, it was not allocated */
9314 sym
->type
.t
&= ~VT_EXTERN
;
9315 /* set array size if it was ommited in extern
9317 if ((sym
->type
.t
& VT_ARRAY
) &&
9318 sym
->type
.ref
->c
< 0 &&
9320 sym
->type
.ref
->c
= type
->ref
->c
;
9322 /* we accept several definitions of the same
9323 global variable. this is tricky, because we
9324 must play with the SHN_COMMON type of the symbol */
9325 /* XXX: should check if the variable was already
9326 initialized. It is incorrect to initialized it
9328 /* no init data, we won't add more to the symbol */
9335 /* allocate symbol in corresponding section */
9340 else if (tcc_state
->nocommon
)
9344 data_offset
= sec
->data_offset
;
9345 data_offset
= (data_offset
+ align
- 1) & -align
;
9347 /* very important to increment global pointer at this time
9348 because initializers themselves can create new initializers */
9349 data_offset
+= size
;
9350 /* add padding if bound check */
9351 if (do_bounds_check
)
9353 sec
->data_offset
= data_offset
;
9354 /* allocate section space to put the data */
9355 if (sec
->sh_type
!= SHT_NOBITS
&&
9356 data_offset
> sec
->data_allocated
)
9357 section_realloc(sec
, data_offset
);
9358 /* align section if needed */
9359 if (align
> sec
->sh_addralign
)
9360 sec
->sh_addralign
= align
;
9362 addr
= 0; /* avoid warning */
9366 if (scope
!= VT_CONST
|| !sym
) {
9367 sym
= sym_push(v
, type
, r
| VT_SYM
, 0);
9369 /* update symbol definition */
9371 put_extern_sym(sym
, sec
, addr
, size
);
9374 /* put a common area */
9375 put_extern_sym(sym
, NULL
, align
, size
);
9376 /* XXX: find a nicer way */
9377 esym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
];
9378 esym
->st_shndx
= SHN_COMMON
;
9383 /* push global reference */
9384 sym
= get_sym_ref(type
, sec
, addr
, size
);
9386 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
9390 /* handles bounds now because the symbol must be defined
9391 before for the relocation */
9392 if (do_bounds_check
) {
9393 unsigned long *bounds_ptr
;
9395 greloc(bounds_section
, sym
, bounds_section
->data_offset
, R_DATA_32
);
9396 /* then add global bound info */
9397 bounds_ptr
= section_ptr_add(bounds_section
, 2 * sizeof(long));
9398 bounds_ptr
[0] = 0; /* relocated */
9399 bounds_ptr
[1] = size
;
9403 decl_initializer(type
, sec
, addr
, 1, 0);
9404 /* restore parse state if needed */
9406 tok_str_free(init_str
.str
);
9407 restore_parse_state(&saved_parse_state
);
9413 void put_func_debug(Sym
*sym
)
9418 /* XXX: we put here a dummy type */
9419 snprintf(buf
, sizeof(buf
), "%s:%c1",
9420 funcname
, sym
->type
.t
& VT_STATIC
? 'f' : 'F');
9421 put_stabs_r(buf
, N_FUN
, 0, file
->line_num
, 0,
9422 cur_text_section
, sym
->c
);
9423 /* //gr gdb wants a line at the function */
9424 put_stabn(N_SLINE
, 0, file
->line_num
, 0);
9429 /* parse an old style function declaration list */
9430 /* XXX: check multiple parameter */
9431 static void func_decl_list(Sym
*func_sym
)
9438 /* parse each declaration */
9439 while (tok
!= '{' && tok
!= ';' && tok
!= ',' && tok
!= TOK_EOF
) {
9440 if (!parse_btype(&btype
, &ad
))
9441 expect("declaration list");
9442 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
9443 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
9445 /* we accept no variable after */
9449 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
9450 /* find parameter in function parameter list */
9453 if ((s
->v
& ~SYM_FIELD
) == v
)
9457 error("declaration for parameter '%s' but no such parameter",
9458 get_tok_str(v
, NULL
));
9460 /* check that no storage specifier except 'register' was given */
9461 if (type
.t
& VT_STORAGE
)
9462 error("storage class specified for '%s'", get_tok_str(v
, NULL
));
9463 convert_parameter_type(&type
);
9464 /* we can add the type (NOTE: it could be local to the function) */
9466 /* accept other parameters */
9477 /* parse a function defined by symbol 'sym' and generate its code in
9478 'cur_text_section' */
9479 static void gen_function(Sym
*sym
)
9481 int saved_nocode_wanted
= nocode_wanted
;
9483 ind
= cur_text_section
->data_offset
;
9484 /* NOTE: we patch the symbol size later */
9485 put_extern_sym(sym
, cur_text_section
, ind
, 0);
9486 funcname
= get_tok_str(sym
->v
, NULL
);
9488 /* put debug symbol */
9490 put_func_debug(sym
);
9491 /* push a dummy symbol to enable local sym storage */
9492 sym_push2(&local_stack
, SYM_FIELD
, 0, 0);
9493 gfunc_prolog(&sym
->type
);
9495 block(NULL
, NULL
, NULL
, NULL
, 0, 0);
9498 cur_text_section
->data_offset
= ind
;
9499 label_pop(&global_label_stack
, NULL
);
9500 sym_pop(&local_stack
, NULL
); /* reset local stack */
9501 /* end of function */
9502 /* patch symbol size */
9503 ((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
].st_size
=
9506 put_stabn(N_FUN
, 0, 0, ind
- func_ind
);
9508 /* It's better to crash than to generate wrong code */
9509 cur_text_section
= NULL
;
9510 funcname
= ""; /* for safety */
9511 func_vt
.t
= VT_VOID
; /* for safety */
9512 ind
= 0; /* for safety */
9513 nocode_wanted
= saved_nocode_wanted
;
9516 static void gen_inline_functions(void)
9520 int *str
, inline_generated
;
9522 /* iterate while inline function are referenced */
9524 inline_generated
= 0;
9525 for(sym
= global_stack
; sym
!= NULL
; sym
= sym
->prev
) {
9527 if (((type
->t
& VT_BTYPE
) == VT_FUNC
) &&
9528 (type
->t
& (VT_STATIC
| VT_INLINE
)) ==
9529 (VT_STATIC
| VT_INLINE
) &&
9531 /* the function was used: generate its code and
9532 convert it to a normal function */
9533 str
= INLINE_DEF(sym
->r
);
9534 sym
->r
= VT_SYM
| VT_CONST
;
9535 sym
->type
.t
&= ~VT_INLINE
;
9539 cur_text_section
= text_section
;
9541 macro_ptr
= NULL
; /* fail safe */
9544 inline_generated
= 1;
9547 if (!inline_generated
)
9551 /* free all remaining inline function tokens */
9552 for(sym
= global_stack
; sym
!= NULL
; sym
= sym
->prev
) {
9554 if (((type
->t
& VT_BTYPE
) == VT_FUNC
) &&
9555 (type
->t
& (VT_STATIC
| VT_INLINE
)) ==
9556 (VT_STATIC
| VT_INLINE
)) {
9557 //gr printf("sym %d %s\n", sym->r, get_tok_str(sym->v, NULL));
9558 if (sym
->r
== (VT_SYM
| VT_CONST
)) //gr beware!
9560 str
= INLINE_DEF(sym
->r
);
9562 sym
->r
= 0; /* fail safe */
9567 /* 'l' is VT_LOCAL or VT_CONST to define default storage type */
9568 static void decl(int l
)
9576 if (!parse_btype(&btype
, &ad
)) {
9577 /* skip redundant ';' */
9578 /* XXX: find more elegant solution */
9583 if (l
== VT_CONST
&&
9584 (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
)) {
9585 /* global asm block */
9589 /* special test for old K&R protos without explicit int
9590 type. Only accepted when defining global data */
9591 if (l
== VT_LOCAL
|| tok
< TOK_DEFINE
)
9595 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
9596 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
9598 /* we accept no variable after */
9602 while (1) { /* iterate thru each declaration */
9604 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
9608 type_to_str(buf
, sizeof(buf
), t
, get_tok_str(v
, NULL
));
9609 printf("type = '%s'\n", buf
);
9612 if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
9613 /* if old style function prototype, we accept a
9616 if (sym
->c
== FUNC_OLD
)
9617 func_decl_list(sym
);
9622 error("cannot use local functions");
9623 if ((type
.t
& VT_BTYPE
) != VT_FUNC
)
9624 expect("function definition");
9626 /* reject abstract declarators in function definition */
9628 while ((sym
= sym
->next
) != NULL
)
9629 if (!(sym
->v
& ~SYM_FIELD
))
9630 expect("identifier");
9632 /* XXX: cannot do better now: convert extern line to static inline */
9633 if ((type
.t
& (VT_EXTERN
| VT_INLINE
)) == (VT_EXTERN
| VT_INLINE
))
9634 type
.t
= (type
.t
& ~VT_EXTERN
) | VT_STATIC
;
9638 if ((sym
->type
.t
& VT_BTYPE
) != VT_FUNC
)
9640 /* specific case: if not func_call defined, we put
9641 the one of the prototype */
9642 /* XXX: should have default value */
9643 r
= sym
->type
.ref
->r
;
9644 if (FUNC_CALL(r
) != FUNC_CDECL
9645 && FUNC_CALL(type
.ref
->r
) == FUNC_CDECL
)
9646 FUNC_CALL(type
.ref
->r
) = FUNC_CALL(r
);
9648 FUNC_EXPORT(type
.ref
->r
) = 1;
9650 if (!is_compatible_types(&sym
->type
, &type
)) {
9652 error("incompatible types for redefinition of '%s'",
9653 get_tok_str(v
, NULL
));
9655 /* if symbol is already defined, then put complete type */
9658 /* put function symbol */
9659 sym
= global_identifier_push(v
, type
.t
, 0);
9660 sym
->type
.ref
= type
.ref
;
9663 /* static inline functions are just recorded as a kind
9664 of macro. Their code will be emitted at the end of
9665 the compilation unit only if they are used */
9666 if ((type
.t
& (VT_INLINE
| VT_STATIC
)) ==
9667 (VT_INLINE
| VT_STATIC
)) {
9668 TokenString func_str
;
9671 tok_str_new(&func_str
);
9677 error("unexpected end of file");
9678 tok_str_add_tok(&func_str
);
9683 } else if (t
== '}') {
9685 if (block_level
== 0)
9689 tok_str_add(&func_str
, -1);
9690 tok_str_add(&func_str
, 0);
9691 INLINE_DEF(sym
->r
) = func_str
.str
;
9693 /* compute text section */
9694 cur_text_section
= ad
.section
;
9695 if (!cur_text_section
)
9696 cur_text_section
= text_section
;
9697 sym
->r
= VT_SYM
| VT_CONST
;
9702 if (btype
.t
& VT_TYPEDEF
) {
9703 /* save typedefed type */
9704 /* XXX: test storage specifiers ? */
9705 sym
= sym_push(v
, &type
, 0, 0);
9706 sym
->type
.t
|= VT_TYPEDEF
;
9707 } else if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
9708 /* external function definition */
9709 /* specific case for func_call attribute */
9711 type
.ref
->r
= ad
.func_attr
;
9712 external_sym(v
, &type
, 0);
9714 /* not lvalue if array */
9716 if (!(type
.t
& VT_ARRAY
))
9717 r
|= lvalue_type(type
.t
);
9718 has_init
= (tok
== '=');
9719 if ((btype
.t
& VT_EXTERN
) ||
9720 ((type
.t
& VT_ARRAY
) && (type
.t
& VT_STATIC
) &&
9721 !has_init
&& l
== VT_CONST
&& type
.ref
->c
< 0)) {
9722 /* external variable */
9723 /* NOTE: as GCC, uninitialized global static
9724 arrays of null size are considered as
9726 external_sym(v
, &type
, r
);
9728 type
.t
|= (btype
.t
& VT_STATIC
); /* Retain "static". */
9729 if (type
.t
& VT_STATIC
)
9735 decl_initializer_alloc(&type
, &ad
, r
,
9749 /* better than nothing, but needs extension to handle '-E' option
9751 static void preprocess_init(TCCState
*s1
)
9753 s1
->include_stack_ptr
= s1
->include_stack
;
9754 /* XXX: move that before to avoid having to initialize
9755 file->ifdef_stack_ptr ? */
9756 s1
->ifdef_stack_ptr
= s1
->ifdef_stack
;
9757 file
->ifdef_stack_ptr
= s1
->ifdef_stack_ptr
;
9759 /* XXX: not ANSI compliant: bound checking says error */
9761 s1
->pack_stack
[0] = 0;
9762 s1
->pack_stack_ptr
= s1
->pack_stack
;
9765 /* compile the C file opened in 'file'. Return non zero if errors. */
9766 static int tcc_compile(TCCState
*s1
)
9770 volatile int section_sym
;
9773 printf("%s: **** new file\n", file
->filename
);
9775 preprocess_init(s1
);
9777 cur_text_section
= NULL
;
9779 anon_sym
= SYM_FIRST_ANOM
;
9781 /* file info: full path + filename */
9782 section_sym
= 0; /* avoid warning */
9784 section_sym
= put_elf_sym(symtab_section
, 0, 0,
9785 ELFW(ST_INFO
)(STB_LOCAL
, STT_SECTION
), 0,
9786 text_section
->sh_num
, NULL
);
9787 getcwd(buf
, sizeof(buf
));
9789 normalize_slashes(buf
);
9791 pstrcat(buf
, sizeof(buf
), "/");
9792 put_stabs_r(buf
, N_SO
, 0, 0,
9793 text_section
->data_offset
, text_section
, section_sym
);
9794 put_stabs_r(file
->filename
, N_SO
, 0, 0,
9795 text_section
->data_offset
, text_section
, section_sym
);
9797 /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
9798 symbols can be safely used */
9799 put_elf_sym(symtab_section
, 0, 0,
9800 ELFW(ST_INFO
)(STB_LOCAL
, STT_FILE
), 0,
9801 SHN_ABS
, file
->filename
);
9803 /* define some often used types */
9804 int_type
.t
= VT_INT
;
9806 char_pointer_type
.t
= VT_BYTE
;
9807 mk_pointer(&char_pointer_type
);
9809 func_old_type
.t
= VT_FUNC
;
9810 func_old_type
.ref
= sym_push(SYM_FIELD
, &int_type
, FUNC_CDECL
, FUNC_OLD
);
9812 #if defined(TCC_ARM_EABI) && defined(TCC_ARM_VFP)
9813 float_type
.t
= VT_FLOAT
;
9814 double_type
.t
= VT_DOUBLE
;
9816 func_float_type
.t
= VT_FUNC
;
9817 func_float_type
.ref
= sym_push(SYM_FIELD
, &float_type
, FUNC_CDECL
, FUNC_OLD
);
9818 func_double_type
.t
= VT_FUNC
;
9819 func_double_type
.ref
= sym_push(SYM_FIELD
, &double_type
, FUNC_CDECL
, FUNC_OLD
);
9823 /* define 'void *alloca(unsigned int)' builtin function */
9828 sym
= sym_push(p
, mk_pointer(VT_VOID
), FUNC_CDECL
, FUNC_NEW
);
9829 s1
= sym_push(SYM_FIELD
, VT_UNSIGNED
| VT_INT
, 0, 0);
9832 sym_push(TOK_alloca
, VT_FUNC
| (p
<< VT_STRUCT_SHIFT
), VT_CONST
, 0);
9836 define_start
= define_stack
;
9839 if (setjmp(s1
->error_jmp_buf
) == 0) {
9841 s1
->error_set_jmp_enabled
= 1;
9843 ch
= file
->buf_ptr
[0];
9844 tok_flags
= TOK_FLAG_BOL
| TOK_FLAG_BOF
;
9845 parse_flags
= PARSE_FLAG_PREPROCESS
| PARSE_FLAG_TOK_NUM
;
9849 expect("declaration");
9851 /* end of translation unit info */
9853 put_stabs_r(NULL
, N_SO
, 0, 0,
9854 text_section
->data_offset
, text_section
, section_sym
);
9857 s1
->error_set_jmp_enabled
= 0;
9859 /* reset define stack, but leave -Dsymbols (may be incorrect if
9860 they are undefined) */
9861 free_defines(define_start
);
9863 gen_inline_functions();
9865 sym_pop(&global_stack
, NULL
);
9866 sym_pop(&local_stack
, NULL
);
9868 return s1
->nb_errors
!= 0 ? -1 : 0;
9871 /* Preprocess the current file */
9872 /* XXX: add line and file infos,
9873 * XXX: add options to preserve spaces (partly done, only spaces in macro are
9876 static int tcc_preprocess(TCCState
*s1
)
9879 BufferedFile
*file_ref
;
9880 int token_seen
, line_ref
;
9882 preprocess_init(s1
);
9883 define_start
= define_stack
;
9884 ch
= file
->buf_ptr
[0];
9886 tok_flags
= TOK_FLAG_BOL
| TOK_FLAG_BOF
;
9887 parse_flags
= PARSE_FLAG_ASM_COMMENTS
| PARSE_FLAG_PREPROCESS
|
9888 PARSE_FLAG_LINEFEED
;
9896 if (tok
== TOK_EOF
) {
9898 } else if (tok
== TOK_LINEFEED
) {
9903 } else if (token_seen
) {
9904 fwrite(tok_spaces
.data
, tok_spaces
.size
, 1, s1
->outfile
);
9906 int d
= file
->line_num
- line_ref
;
9907 if (file
!= file_ref
|| d
< 0 || d
>= 8)
9908 fprintf(s1
->outfile
, "# %d \"%s\"\n", file
->line_num
, file
->filename
);
9911 fputs("\n", s1
->outfile
), --d
;
9912 line_ref
= (file_ref
= file
)->line_num
;
9915 fputs(get_tok_str(tok
, &tokc
), s1
->outfile
);
9917 free_defines(define_start
);
9922 int tcc_compile_string(TCCState
*s
, const char *str
)
9924 BufferedFile bf1
, *bf
= &bf1
;
9928 /* init file structure */
9930 /* XXX: avoid copying */
9932 buf
= tcc_malloc(len
+ 1);
9935 memcpy(buf
, str
, len
);
9938 bf
->buf_end
= buf
+ len
;
9939 pstrcpy(bf
->filename
, sizeof(bf
->filename
), "<string>");
9942 ret
= tcc_compile(s
);
9946 /* currently, no need to close */
9951 /* define a preprocessor symbol. A value can also be provided with the '=' operator */
9952 void tcc_define_symbol(TCCState
*s1
, const char *sym
, const char *value
)
9954 BufferedFile bf1
, *bf
= &bf1
;
9956 pstrcpy(bf
->buffer
, IO_BUF_SIZE
, sym
);
9957 pstrcat(bf
->buffer
, IO_BUF_SIZE
, " ");
9961 pstrcat(bf
->buffer
, IO_BUF_SIZE
, value
);
9963 /* init file structure */
9965 bf
->buf_ptr
= bf
->buffer
;
9966 bf
->buf_end
= bf
->buffer
+ strlen(bf
->buffer
);
9967 *bf
->buf_end
= CH_EOB
;
9968 bf
->filename
[0] = '\0';
9972 s1
->include_stack_ptr
= s1
->include_stack
;
9974 /* parse with define parser */
9975 ch
= file
->buf_ptr
[0];
9981 /* undefine a preprocessor symbol */
9982 void tcc_undefine_symbol(TCCState
*s1
, const char *sym
)
9986 ts
= tok_alloc(sym
, strlen(sym
));
9987 s
= define_find(ts
->tok
);
9988 /* undefine symbol by putting an invalid name */
9993 #ifdef CONFIG_TCC_ASM
9995 #ifdef TCC_TARGET_I386
9996 #include "i386-asm.c"
10001 static void asm_instr(void)
10003 error("inline asm() not supported");
10005 static void asm_global_instr(void)
10007 error("inline asm() not supported");
10011 #include "tccelf.c"
10013 #ifdef TCC_TARGET_COFF
10014 #include "tcccoff.c"
10017 #ifdef TCC_TARGET_PE
10021 /* print the position in the source file of PC value 'pc' by reading
10022 the stabs debug information */
10023 static void rt_printline(unsigned long wanted_pc
)
10025 Stab_Sym
*sym
, *sym_end
;
10026 char func_name
[128], last_func_name
[128];
10027 unsigned long func_addr
, last_pc
, pc
;
10028 const char *incl_files
[INCLUDE_STACK_SIZE
];
10029 int incl_index
, len
, last_line_num
, i
;
10030 const char *str
, *p
;
10032 fprintf(stderr
, "0x%08lx:", wanted_pc
);
10034 func_name
[0] = '\0';
10037 last_func_name
[0] = '\0';
10038 last_pc
= 0xffffffff;
10040 sym
= (Stab_Sym
*)stab_section
->data
+ 1;
10041 sym_end
= (Stab_Sym
*)(stab_section
->data
+ stab_section
->data_offset
);
10042 while (sym
< sym_end
) {
10043 switch(sym
->n_type
) {
10044 /* function start or end */
10046 if (sym
->n_strx
== 0) {
10047 /* we test if between last line and end of function */
10048 pc
= sym
->n_value
+ func_addr
;
10049 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
10051 func_name
[0] = '\0';
10054 str
= stabstr_section
->data
+ sym
->n_strx
;
10055 p
= strchr(str
, ':');
10057 pstrcpy(func_name
, sizeof(func_name
), str
);
10060 if (len
> sizeof(func_name
) - 1)
10061 len
= sizeof(func_name
) - 1;
10062 memcpy(func_name
, str
, len
);
10063 func_name
[len
] = '\0';
10065 func_addr
= sym
->n_value
;
10068 /* line number info */
10070 pc
= sym
->n_value
+ func_addr
;
10071 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
10074 last_line_num
= sym
->n_desc
;
10076 strcpy(last_func_name
, func_name
);
10078 /* include files */
10080 str
= stabstr_section
->data
+ sym
->n_strx
;
10082 if (incl_index
< INCLUDE_STACK_SIZE
) {
10083 incl_files
[incl_index
++] = str
;
10087 if (incl_index
> 1)
10091 if (sym
->n_strx
== 0) {
10092 incl_index
= 0; /* end of translation unit */
10094 str
= stabstr_section
->data
+ sym
->n_strx
;
10095 /* do not add path */
10097 if (len
> 0 && str
[len
- 1] != '/')
10105 /* second pass: we try symtab symbols (no line number info) */
10108 ElfW(Sym
) *sym
, *sym_end
;
10111 sym_end
= (ElfW(Sym
) *)(symtab_section
->data
+ symtab_section
->data_offset
);
10112 for(sym
= (ElfW(Sym
) *)symtab_section
->data
+ 1;
10115 type
= ELFW(ST_TYPE
)(sym
->st_info
);
10116 if (type
== STT_FUNC
) {
10117 if (wanted_pc
>= sym
->st_value
&&
10118 wanted_pc
< sym
->st_value
+ sym
->st_size
) {
10119 pstrcpy(last_func_name
, sizeof(last_func_name
),
10120 strtab_section
->data
+ sym
->st_name
);
10126 /* did not find any info: */
10127 fprintf(stderr
, " ???\n");
10130 if (last_func_name
[0] != '\0') {
10131 fprintf(stderr
, " %s()", last_func_name
);
10133 if (incl_index
> 0) {
10134 fprintf(stderr
, " (%s:%d",
10135 incl_files
[incl_index
- 1], last_line_num
);
10136 for(i
= incl_index
- 2; i
>= 0; i
--)
10137 fprintf(stderr
, ", included from %s", incl_files
[i
]);
10138 fprintf(stderr
, ")");
10140 fprintf(stderr
, "\n");
10143 #if !defined(_WIN32) && !defined(CONFIG_TCCBOOT)
10147 /* fix for glibc 2.1 */
10149 #define REG_EIP EIP
10150 #define REG_EBP EBP
10153 /* return the PC at frame level 'level'. Return non zero if not found */
10154 static int rt_get_caller_pc(unsigned long *paddr
,
10155 ucontext_t
*uc
, int level
)
10161 #if defined(__FreeBSD__)
10162 *paddr
= uc
->uc_mcontext
.mc_eip
;
10163 #elif defined(__dietlibc__)
10164 *paddr
= uc
->uc_mcontext
.eip
;
10166 *paddr
= uc
->uc_mcontext
.gregs
[REG_EIP
];
10170 #if defined(__FreeBSD__)
10171 fp
= uc
->uc_mcontext
.mc_ebp
;
10172 #elif defined(__dietlibc__)
10173 fp
= uc
->uc_mcontext
.ebp
;
10175 fp
= uc
->uc_mcontext
.gregs
[REG_EBP
];
10177 for(i
=1;i
<level
;i
++) {
10178 /* XXX: check address validity with program info */
10179 if (fp
<= 0x1000 || fp
>= 0xc0000000)
10181 fp
= ((unsigned long *)fp
)[0];
10183 *paddr
= ((unsigned long *)fp
)[1];
10187 #elif defined(__x86_64__)
10188 /* return the PC at frame level 'level'. Return non zero if not found */
10189 static int rt_get_caller_pc(unsigned long *paddr
,
10190 ucontext_t
*uc
, int level
)
10196 /* XXX: only support linux */
10197 *paddr
= uc
->uc_mcontext
.gregs
[REG_RIP
];
10200 fp
= uc
->uc_mcontext
.gregs
[REG_RBP
];
10201 for(i
=1;i
<level
;i
++) {
10202 /* XXX: check address validity with program info */
10205 fp
= ((unsigned long *)fp
)[0];
10207 *paddr
= ((unsigned long *)fp
)[1];
10213 #warning add arch specific rt_get_caller_pc()
10215 static int rt_get_caller_pc(unsigned long *paddr
,
10216 ucontext_t
*uc
, int level
)
10222 /* emit a run time error at position 'pc' */
10223 void rt_error(ucontext_t
*uc
, const char *fmt
, ...)
10230 fprintf(stderr
, "Runtime error: ");
10231 vfprintf(stderr
, fmt
, ap
);
10232 fprintf(stderr
, "\n");
10233 for(i
=0;i
<num_callers
;i
++) {
10234 if (rt_get_caller_pc(&pc
, uc
, i
) < 0)
10237 fprintf(stderr
, "at ");
10239 fprintf(stderr
, "by ");
10246 /* signal handler for fatal errors */
10247 static void sig_error(int signum
, siginfo_t
*siginf
, void *puc
)
10249 ucontext_t
*uc
= puc
;
10253 switch(siginf
->si_code
) {
10256 rt_error(uc
, "division by zero");
10259 rt_error(uc
, "floating point exception");
10265 if (rt_bound_error_msg
&& *rt_bound_error_msg
)
10266 rt_error(uc
, *rt_bound_error_msg
);
10268 rt_error(uc
, "dereferencing invalid pointer");
10271 rt_error(uc
, "illegal instruction");
10274 rt_error(uc
, "abort() called");
10277 rt_error(uc
, "caught signal %d", signum
);
10284 /* do all relocations (needed before using tcc_get_symbol()) */
10285 int tcc_relocate(TCCState
*s1
)
10292 #ifdef TCC_TARGET_PE
10293 pe_add_runtime(s1
);
10295 tcc_add_runtime(s1
);
10298 relocate_common_syms();
10300 tcc_add_linker_symbols(s1
);
10301 #ifndef TCC_TARGET_PE
10302 build_got_entries(s1
);
10305 #ifdef TCC_TARGET_X86_64
10307 /* If the distance of two sections are longer than 32bit, our
10308 program will crash. Let's combine all sections which are
10309 necessary to run the program into a single buffer in the
10313 /* calculate the size of buffers we need */
10315 for(i
= 1; i
< s1
->nb_sections
; i
++) {
10316 s
= s1
->sections
[i
];
10317 if (s
->sh_flags
& SHF_ALLOC
) {
10318 size
+= s
->data_offset
;
10321 /* double the size of the buffer for got and plt entries
10322 XXX: calculate exact size for them? */
10323 section_realloc(text_section
, size
* 2);
10324 p
= text_section
->data
+ text_section
->data_offset
;
10325 /* we will put got and plt after this offset */
10326 text_section
->data_offset
= size
;
10328 for(i
= 1; i
< s1
->nb_sections
; i
++) {
10329 s
= s1
->sections
[i
];
10330 if (s
->sh_flags
& SHF_ALLOC
) {
10331 if (s
!= text_section
&& s
->data_offset
) {
10332 if (s
->sh_type
== SHT_NOBITS
) {
10333 /* for bss section */
10334 memset(p
, 0, s
->data_offset
);
10336 memcpy(p
, s
->data
, s
->data_offset
);
10340 /* we won't free s->data for this section */
10341 s
->data_allocated
= 0;
10342 p
+= s
->data_offset
;
10344 s
->sh_addr
= (unsigned long)s
->data
;
10349 /* compute relocation address : section are relocated in place. We
10350 also alloc the bss space */
10351 for(i
= 1; i
< s1
->nb_sections
; i
++) {
10352 s
= s1
->sections
[i
];
10353 if (s
->sh_flags
& SHF_ALLOC
) {
10354 if (s
->sh_type
== SHT_NOBITS
)
10355 s
->data
= tcc_mallocz(s
->data_offset
);
10356 s
->sh_addr
= (unsigned long)s
->data
;
10361 relocate_syms(s1
, 1);
10363 if (s1
->nb_errors
!= 0)
10366 /* relocate each section */
10367 for(i
= 1; i
< s1
->nb_sections
; i
++) {
10368 s
= s1
->sections
[i
];
10370 relocate_section(s1
, s
);
10373 /* mark executable sections as executable in memory */
10374 for(i
= 1; i
< s1
->nb_sections
; i
++) {
10375 s
= s1
->sections
[i
];
10376 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_EXECINSTR
)) ==
10377 (SHF_ALLOC
| SHF_EXECINSTR
))
10378 set_pages_executable(s
->data
, s
->data_offset
);
10383 /* launch the compiled program with the given arguments */
10384 int tcc_run(TCCState
*s1
, int argc
, char **argv
)
10386 int (*prog_main
)(int, char **);
10388 if (tcc_relocate(s1
) < 0)
10391 prog_main
= tcc_get_symbol_err(s1
, "main");
10394 #if defined(_WIN32) || defined(CONFIG_TCCBOOT)
10395 error("debug mode currently not available for Windows");
10397 struct sigaction sigact
;
10398 /* install TCC signal handlers to print debug info on fatal
10400 sigact
.sa_flags
= SA_SIGINFO
| SA_RESETHAND
;
10401 sigact
.sa_sigaction
= sig_error
;
10402 sigemptyset(&sigact
.sa_mask
);
10403 sigaction(SIGFPE
, &sigact
, NULL
);
10404 sigaction(SIGILL
, &sigact
, NULL
);
10405 sigaction(SIGSEGV
, &sigact
, NULL
);
10406 sigaction(SIGBUS
, &sigact
, NULL
);
10407 sigaction(SIGABRT
, &sigact
, NULL
);
10411 #ifdef CONFIG_TCC_BCHECK
10412 if (do_bounds_check
) {
10413 void (*bound_init
)(void);
10415 /* set error function */
10416 rt_bound_error_msg
= (void *)tcc_get_symbol_err(s1
,
10417 "__bound_error_msg");
10419 /* XXX: use .init section so that it also work in binary ? */
10420 bound_init
= (void *)tcc_get_symbol_err(s1
, "__bound_init");
10424 return (*prog_main
)(argc
, argv
);
10427 void tcc_memstats(void)
10430 printf("memory in use: %d\n", mem_cur_size
);
10434 static void tcc_cleanup(void)
10438 if (NULL
== tcc_state
)
10442 /* free -D defines */
10443 free_defines(NULL
);
10446 n
= tok_ident
- TOK_IDENT
;
10447 for(i
= 0; i
< n
; i
++)
10448 tcc_free(table_ident
[i
]);
10449 tcc_free(table_ident
);
10451 /* free sym_pools */
10452 dynarray_reset(&sym_pools
, &nb_sym_pools
);
10453 /* string buffer */
10454 cstr_free(&tokcstr
);
10455 /* reset symbol stack */
10456 sym_free_first
= NULL
;
10457 /* cleanup from error/setjmp */
10461 TCCState
*tcc_new(void)
10470 s
= tcc_mallocz(sizeof(TCCState
));
10474 s
->output_type
= TCC_OUTPUT_MEMORY
;
10476 /* init isid table */
10477 for(i
=CH_EOF
;i
<256;i
++)
10478 isidnum_table
[i
-CH_EOF
] = isid(i
) || isnum(i
);
10480 /* add all tokens */
10481 table_ident
= NULL
;
10482 memset(hash_ident
, 0, TOK_HASH_SIZE
* sizeof(TokenSym
*));
10484 tok_ident
= TOK_IDENT
;
10493 ts
= tok_alloc(p
, r
- p
- 1);
10497 /* we add dummy defines for some special macros to speed up tests
10498 and to have working defined() */
10499 define_push(TOK___LINE__
, MACRO_OBJ
, NULL
, NULL
);
10500 define_push(TOK___FILE__
, MACRO_OBJ
, NULL
, NULL
);
10501 define_push(TOK___DATE__
, MACRO_OBJ
, NULL
, NULL
);
10502 define_push(TOK___TIME__
, MACRO_OBJ
, NULL
, NULL
);
10504 /* standard defines */
10505 tcc_define_symbol(s
, "__STDC__", NULL
);
10506 tcc_define_symbol(s
, "__STDC_VERSION__", "199901L");
10507 #if defined(TCC_TARGET_I386)
10508 tcc_define_symbol(s
, "__i386__", NULL
);
10510 #if defined(TCC_TARGET_X86_64)
10511 tcc_define_symbol(s
, "__x86_64__", NULL
);
10513 #if defined(TCC_TARGET_ARM)
10514 tcc_define_symbol(s
, "__ARM_ARCH_4__", NULL
);
10515 tcc_define_symbol(s
, "__arm_elf__", NULL
);
10516 tcc_define_symbol(s
, "__arm_elf", NULL
);
10517 tcc_define_symbol(s
, "arm_elf", NULL
);
10518 tcc_define_symbol(s
, "__arm__", NULL
);
10519 tcc_define_symbol(s
, "__arm", NULL
);
10520 tcc_define_symbol(s
, "arm", NULL
);
10521 tcc_define_symbol(s
, "__APCS_32__", NULL
);
10523 #ifdef TCC_TARGET_PE
10524 tcc_define_symbol(s
, "_WIN32", NULL
);
10526 tcc_define_symbol(s
, "__unix__", NULL
);
10527 tcc_define_symbol(s
, "__unix", NULL
);
10528 #if defined(__linux)
10529 tcc_define_symbol(s
, "__linux__", NULL
);
10530 tcc_define_symbol(s
, "__linux", NULL
);
10533 /* tiny C specific defines */
10534 tcc_define_symbol(s
, "__TINYC__", NULL
);
10536 /* tiny C & gcc defines */
10537 tcc_define_symbol(s
, "__SIZE_TYPE__", "unsigned int");
10538 tcc_define_symbol(s
, "__PTRDIFF_TYPE__", "int");
10539 #ifdef TCC_TARGET_PE
10540 tcc_define_symbol(s
, "__WCHAR_TYPE__", "unsigned short");
10542 tcc_define_symbol(s
, "__WCHAR_TYPE__", "int");
10545 #ifndef TCC_TARGET_PE
10546 /* default library paths */
10547 tcc_add_library_path(s
, CONFIG_SYSROOT
"/usr/local/lib");
10548 tcc_add_library_path(s
, CONFIG_SYSROOT
"/usr/lib");
10549 tcc_add_library_path(s
, CONFIG_SYSROOT
"/lib");
10552 /* no section zero */
10553 dynarray_add((void ***)&s
->sections
, &s
->nb_sections
, NULL
);
10555 /* create standard sections */
10556 text_section
= new_section(s
, ".text", SHT_PROGBITS
, SHF_ALLOC
| SHF_EXECINSTR
);
10557 data_section
= new_section(s
, ".data", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
10558 bss_section
= new_section(s
, ".bss", SHT_NOBITS
, SHF_ALLOC
| SHF_WRITE
);
10560 /* symbols are always generated for linking stage */
10561 symtab_section
= new_symtab(s
, ".symtab", SHT_SYMTAB
, 0,
10563 ".hashtab", SHF_PRIVATE
);
10564 strtab_section
= symtab_section
->link
;
10566 /* private symbol table for dynamic symbols */
10567 s
->dynsymtab_section
= new_symtab(s
, ".dynsymtab", SHT_SYMTAB
, SHF_PRIVATE
,
10569 ".dynhashtab", SHF_PRIVATE
);
10570 s
->alacarte_link
= 1;
10572 #ifdef CHAR_IS_UNSIGNED
10573 s
->char_is_unsigned
= 1;
10575 #if defined(TCC_TARGET_PE) && 0
10576 /* XXX: currently the PE linker is not ready to support that */
10577 s
->leading_underscore
= 1;
10582 void tcc_delete(TCCState
*s1
)
10588 /* free all sections */
10589 for(i
= 1; i
< s1
->nb_sections
; i
++)
10590 free_section(s1
->sections
[i
]);
10591 dynarray_reset(&s1
->sections
, &s1
->nb_sections
);
10593 for(i
= 0; i
< s1
->nb_priv_sections
; i
++)
10594 free_section(s1
->priv_sections
[i
]);
10595 dynarray_reset(&s1
->priv_sections
, &s1
->nb_priv_sections
);
10597 /* free any loaded DLLs */
10598 for ( i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
10599 DLLReference
*ref
= s1
->loaded_dlls
[i
];
10601 dlclose(ref
->handle
);
10604 /* free loaded dlls array */
10605 dynarray_reset(&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
);
10607 /* free library paths */
10608 dynarray_reset(&s1
->library_paths
, &s1
->nb_library_paths
);
10610 /* free include paths */
10611 dynarray_reset(&s1
->cached_includes
, &s1
->nb_cached_includes
);
10612 dynarray_reset(&s1
->include_paths
, &s1
->nb_include_paths
);
10613 dynarray_reset(&s1
->sysinclude_paths
, &s1
->nb_sysinclude_paths
);
10618 int tcc_add_include_path(TCCState
*s1
, const char *pathname
)
10622 pathname1
= tcc_strdup(pathname
);
10623 dynarray_add((void ***)&s1
->include_paths
, &s1
->nb_include_paths
, pathname1
);
10627 int tcc_add_sysinclude_path(TCCState
*s1
, const char *pathname
)
10631 pathname1
= tcc_strdup(pathname
);
10632 dynarray_add((void ***)&s1
->sysinclude_paths
, &s1
->nb_sysinclude_paths
, pathname1
);
10636 static int tcc_add_file_internal(TCCState
*s1
, const char *filename
, int flags
)
10641 BufferedFile
*saved_file
;
10643 /* find source file type with extension */
10644 ext
= tcc_fileextension(filename
);
10648 /* open the file */
10650 file
= tcc_open(s1
, filename
);
10652 if (flags
& AFF_PRINT_ERROR
) {
10653 error_noabort("file '%s' not found", filename
);
10659 if (flags
& AFF_PREPROCESS
) {
10660 ret
= tcc_preprocess(s1
);
10661 } else if (!ext
[0] || !PATHCMP(ext
, "c")) {
10662 /* C file assumed */
10663 ret
= tcc_compile(s1
);
10665 #ifdef CONFIG_TCC_ASM
10666 if (!strcmp(ext
, "S")) {
10667 /* preprocessed assembler */
10668 ret
= tcc_assemble(s1
, 1);
10669 } else if (!strcmp(ext
, "s")) {
10670 /* non preprocessed assembler */
10671 ret
= tcc_assemble(s1
, 0);
10674 #ifdef TCC_TARGET_PE
10675 if (!PATHCMP(ext
, "def")) {
10676 ret
= pe_load_def_file(s1
, file
->fd
);
10681 /* assume executable format: auto guess file type */
10682 ret
= read(fd
, &ehdr
, sizeof(ehdr
));
10683 lseek(fd
, 0, SEEK_SET
);
10685 error_noabort("could not read header");
10687 } else if (ret
!= sizeof(ehdr
)) {
10688 goto try_load_script
;
10691 if (ehdr
.e_ident
[0] == ELFMAG0
&&
10692 ehdr
.e_ident
[1] == ELFMAG1
&&
10693 ehdr
.e_ident
[2] == ELFMAG2
&&
10694 ehdr
.e_ident
[3] == ELFMAG3
) {
10695 file
->line_num
= 0; /* do not display line number if error */
10696 if (ehdr
.e_type
== ET_REL
) {
10697 ret
= tcc_load_object_file(s1
, fd
, 0);
10698 } else if (ehdr
.e_type
== ET_DYN
) {
10699 if (s1
->output_type
== TCC_OUTPUT_MEMORY
) {
10700 #ifdef TCC_TARGET_PE
10704 h
= dlopen(filename
, RTLD_GLOBAL
| RTLD_LAZY
);
10711 ret
= tcc_load_dll(s1
, fd
, filename
,
10712 (flags
& AFF_REFERENCED_DLL
) != 0);
10715 error_noabort("unrecognized ELF file");
10718 } else if (memcmp((char *)&ehdr
, ARMAG
, 8) == 0) {
10719 file
->line_num
= 0; /* do not display line number if error */
10720 ret
= tcc_load_archive(s1
, fd
);
10722 #ifdef TCC_TARGET_COFF
10723 if (*(uint16_t *)(&ehdr
) == COFF_C67_MAGIC
) {
10724 ret
= tcc_load_coff(s1
, fd
);
10727 #ifdef TCC_TARGET_PE
10728 if (pe_test_res_file(&ehdr
, ret
)) {
10729 ret
= pe_load_res_file(s1
, fd
);
10733 /* as GNU ld, consider it is an ld script if not recognized */
10735 ret
= tcc_load_ldscript(s1
);
10737 error_noabort("unrecognized file type");
10752 int tcc_add_file(TCCState
*s
, const char *filename
)
10754 return tcc_add_file_internal(s
, filename
, AFF_PRINT_ERROR
);
10757 int tcc_add_library_path(TCCState
*s
, const char *pathname
)
10761 pathname1
= tcc_strdup(pathname
);
10762 dynarray_add((void ***)&s
->library_paths
, &s
->nb_library_paths
, pathname1
);
10766 /* find and load a dll. Return non zero if not found */
10767 /* XXX: add '-rpath' option support ? */
10768 static int tcc_add_dll(TCCState
*s
, const char *filename
, int flags
)
10773 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
10774 snprintf(buf
, sizeof(buf
), "%s/%s",
10775 s
->library_paths
[i
], filename
);
10776 if (tcc_add_file_internal(s
, buf
, flags
) == 0)
10782 /* the library name is the same as the argument of the '-l' option */
10783 int tcc_add_library(TCCState
*s
, const char *libraryname
)
10788 /* first we look for the dynamic library if not static linking */
10789 if (!s
->static_link
) {
10790 #ifdef TCC_TARGET_PE
10791 snprintf(buf
, sizeof(buf
), "%s.def", libraryname
);
10793 snprintf(buf
, sizeof(buf
), "lib%s.so", libraryname
);
10795 if (tcc_add_dll(s
, buf
, 0) == 0)
10799 /* then we look for the static library */
10800 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
10801 snprintf(buf
, sizeof(buf
), "%s/lib%s.a",
10802 s
->library_paths
[i
], libraryname
);
10803 if (tcc_add_file_internal(s
, buf
, 0) == 0)
10809 int tcc_add_symbol(TCCState
*s
, const char *name
, unsigned long val
)
10811 add_elf_sym(symtab_section
, val
, 0,
10812 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
10817 int tcc_set_output_type(TCCState
*s
, int output_type
)
10821 s
->output_type
= output_type
;
10823 if (!s
->nostdinc
) {
10824 /* default include paths */
10825 /* XXX: reverse order needed if -isystem support */
10826 #ifndef TCC_TARGET_PE
10827 tcc_add_sysinclude_path(s
, CONFIG_SYSROOT
"/usr/local/include");
10828 tcc_add_sysinclude_path(s
, CONFIG_SYSROOT
"/usr/include");
10830 snprintf(buf
, sizeof(buf
), "%s/include", tcc_lib_path
);
10831 tcc_add_sysinclude_path(s
, buf
);
10832 #ifdef TCC_TARGET_PE
10833 snprintf(buf
, sizeof(buf
), "%s/include/winapi", tcc_lib_path
);
10834 tcc_add_sysinclude_path(s
, buf
);
10838 /* if bound checking, then add corresponding sections */
10839 #ifdef CONFIG_TCC_BCHECK
10840 if (do_bounds_check
) {
10841 /* define symbol */
10842 tcc_define_symbol(s
, "__BOUNDS_CHECKING_ON", NULL
);
10843 /* create bounds sections */
10844 bounds_section
= new_section(s
, ".bounds",
10845 SHT_PROGBITS
, SHF_ALLOC
);
10846 lbounds_section
= new_section(s
, ".lbounds",
10847 SHT_PROGBITS
, SHF_ALLOC
);
10851 if (s
->char_is_unsigned
) {
10852 tcc_define_symbol(s
, "__CHAR_UNSIGNED__", NULL
);
10855 /* add debug sections */
10858 stab_section
= new_section(s
, ".stab", SHT_PROGBITS
, 0);
10859 stab_section
->sh_entsize
= sizeof(Stab_Sym
);
10860 stabstr_section
= new_section(s
, ".stabstr", SHT_STRTAB
, 0);
10861 put_elf_str(stabstr_section
, "");
10862 stab_section
->link
= stabstr_section
;
10863 /* put first entry */
10864 put_stabs("", 0, 0, 0, 0);
10867 /* add libc crt1/crti objects */
10868 #ifndef TCC_TARGET_PE
10869 if ((output_type
== TCC_OUTPUT_EXE
|| output_type
== TCC_OUTPUT_DLL
) &&
10871 if (output_type
!= TCC_OUTPUT_DLL
)
10872 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crt1.o");
10873 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crti.o");
10877 #ifdef TCC_TARGET_PE
10878 snprintf(buf
, sizeof(buf
), "%s/lib", tcc_lib_path
);
10879 tcc_add_library_path(s
, buf
);
10885 #define WD_ALL 0x0001 /* warning is activated when using -Wall */
10886 #define FD_INVERT 0x0002 /* invert value before storing */
10888 typedef struct FlagDef
{
10894 static const FlagDef warning_defs
[] = {
10895 { offsetof(TCCState
, warn_unsupported
), 0, "unsupported" },
10896 { offsetof(TCCState
, warn_write_strings
), 0, "write-strings" },
10897 { offsetof(TCCState
, warn_error
), 0, "error" },
10898 { offsetof(TCCState
, warn_implicit_function_declaration
), WD_ALL
,
10899 "implicit-function-declaration" },
10902 static int set_flag(TCCState
*s
, const FlagDef
*flags
, int nb_flags
,
10903 const char *name
, int value
)
10910 if (r
[0] == 'n' && r
[1] == 'o' && r
[2] == '-') {
10914 for(i
= 0, p
= flags
; i
< nb_flags
; i
++, p
++) {
10915 if (!strcmp(r
, p
->name
))
10920 if (p
->flags
& FD_INVERT
)
10922 *(int *)((uint8_t *)s
+ p
->offset
) = value
;
10927 /* set/reset a warning */
10928 int tcc_set_warning(TCCState
*s
, const char *warning_name
, int value
)
10933 if (!strcmp(warning_name
, "all")) {
10934 for(i
= 0, p
= warning_defs
; i
< countof(warning_defs
); i
++, p
++) {
10935 if (p
->flags
& WD_ALL
)
10936 *(int *)((uint8_t *)s
+ p
->offset
) = 1;
10940 return set_flag(s
, warning_defs
, countof(warning_defs
),
10941 warning_name
, value
);
10945 static const FlagDef flag_defs
[] = {
10946 { offsetof(TCCState
, char_is_unsigned
), 0, "unsigned-char" },
10947 { offsetof(TCCState
, char_is_unsigned
), FD_INVERT
, "signed-char" },
10948 { offsetof(TCCState
, nocommon
), FD_INVERT
, "common" },
10949 { offsetof(TCCState
, leading_underscore
), 0, "leading-underscore" },
10952 /* set/reset a flag */
10953 int tcc_set_flag(TCCState
*s
, const char *flag_name
, int value
)
10955 return set_flag(s
, flag_defs
, countof(flag_defs
),
10959 #if !defined(LIBTCC)
10961 static int64_t getclock_us(void)
10966 return (tb
.time
* 1000LL + tb
.millitm
) * 1000LL;
10969 gettimeofday(&tv
, NULL
);
10970 return tv
.tv_sec
* 1000000LL + tv
.tv_usec
;
10976 printf("tcc version " TCC_VERSION
" - Tiny C Compiler - Copyright (C) 2001-2006 Fabrice Bellard\n"
10977 "usage: tcc [-v] [-c] [-o outfile] [-Bdir] [-bench] [-Idir] [-Dsym[=val]] [-Usym]\n"
10978 " [-Wwarn] [-g] [-b] [-bt N] [-Ldir] [-llib] [-shared] [-soname name]\n"
10979 " [-static] [infile1 infile2...] [-run infile args...]\n"
10981 "General options:\n"
10982 " -v display current version, increase verbosity\n"
10983 " -c compile only - generate an object file\n"
10984 " -o outfile set output filename\n"
10985 " -Bdir set tcc internal library path\n"
10986 " -bench output compilation statistics\n"
10987 " -run run compiled source\n"
10988 " -fflag set or reset (with 'no-' prefix) 'flag' (see man page)\n"
10989 " -Wwarning set or reset (with 'no-' prefix) 'warning' (see man page)\n"
10990 " -w disable all warnings\n"
10991 "Preprocessor options:\n"
10992 " -E preprocess only\n"
10993 " -Idir add include path 'dir'\n"
10994 " -Dsym[=val] define 'sym' with value 'val'\n"
10995 " -Usym undefine 'sym'\n"
10996 "Linker options:\n"
10997 " -Ldir add library path 'dir'\n"
10998 " -llib link with dynamic or static library 'lib'\n"
10999 " -shared generate a shared library\n"
11000 " -soname set name for shared library to be used at runtime\n"
11001 " -static static linking\n"
11002 " -rdynamic export all global symbols to dynamic linker\n"
11003 " -r generate (relocatable) object file\n"
11004 "Debugger options:\n"
11005 " -g generate runtime debug info\n"
11006 #ifdef CONFIG_TCC_BCHECK
11007 " -b compile with built-in memory and bounds checker (implies -g)\n"
11009 " -bt N show N callers in stack traces\n"
11013 #define TCC_OPTION_HAS_ARG 0x0001
11014 #define TCC_OPTION_NOSEP 0x0002 /* cannot have space before option and arg */
11016 typedef struct TCCOption
{
11045 TCC_OPTION_nostdinc
,
11046 TCC_OPTION_nostdlib
,
11047 TCC_OPTION_print_search_dirs
,
11048 TCC_OPTION_rdynamic
,
11056 static const TCCOption tcc_options
[] = {
11057 { "h", TCC_OPTION_HELP
, 0 },
11058 { "?", TCC_OPTION_HELP
, 0 },
11059 { "I", TCC_OPTION_I
, TCC_OPTION_HAS_ARG
},
11060 { "D", TCC_OPTION_D
, TCC_OPTION_HAS_ARG
},
11061 { "U", TCC_OPTION_U
, TCC_OPTION_HAS_ARG
},
11062 { "L", TCC_OPTION_L
, TCC_OPTION_HAS_ARG
},
11063 { "B", TCC_OPTION_B
, TCC_OPTION_HAS_ARG
},
11064 { "l", TCC_OPTION_l
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11065 { "bench", TCC_OPTION_bench
, 0 },
11066 { "bt", TCC_OPTION_bt
, TCC_OPTION_HAS_ARG
},
11067 #ifdef CONFIG_TCC_BCHECK
11068 { "b", TCC_OPTION_b
, 0 },
11070 { "g", TCC_OPTION_g
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11071 { "c", TCC_OPTION_c
, 0 },
11072 { "static", TCC_OPTION_static
, 0 },
11073 { "shared", TCC_OPTION_shared
, 0 },
11074 { "soname", TCC_OPTION_soname
, TCC_OPTION_HAS_ARG
},
11075 { "o", TCC_OPTION_o
, TCC_OPTION_HAS_ARG
},
11076 { "run", TCC_OPTION_run
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11077 { "rdynamic", TCC_OPTION_rdynamic
, 0 },
11078 { "r", TCC_OPTION_r
, 0 },
11079 { "Wl,", TCC_OPTION_Wl
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11080 { "W", TCC_OPTION_W
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11081 { "O", TCC_OPTION_O
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11082 { "m", TCC_OPTION_m
, TCC_OPTION_HAS_ARG
},
11083 { "f", TCC_OPTION_f
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11084 { "nostdinc", TCC_OPTION_nostdinc
, 0 },
11085 { "nostdlib", TCC_OPTION_nostdlib
, 0 },
11086 { "print-search-dirs", TCC_OPTION_print_search_dirs
, 0 },
11087 { "v", TCC_OPTION_v
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11088 { "w", TCC_OPTION_w
, 0 },
11089 { "pipe", TCC_OPTION_pipe
, 0},
11090 { "E", TCC_OPTION_E
, 0},
11094 /* convert 'str' into an array of space separated strings */
11095 static int expand_args(char ***pargv
, const char *str
)
11104 while (is_space(*str
))
11109 while (*str
!= '\0' && !is_space(*str
))
11112 arg
= tcc_malloc(len
+ 1);
11113 memcpy(arg
, s1
, len
);
11115 dynarray_add((void ***)&argv
, &argc
, arg
);
11121 static char **files
;
11122 static int nb_files
, nb_libraries
;
11123 static int multiple_files
;
11124 static int print_search_dirs
;
11125 static int output_type
;
11126 static int reloc_output
;
11127 static const char *outfile
;
11129 int parse_args(TCCState
*s
, int argc
, char **argv
)
11132 const TCCOption
*popt
;
11133 const char *optarg
, *p1
, *r1
;
11137 while (optind
< argc
) {
11139 r
= argv
[optind
++];
11140 if (r
[0] != '-' || r
[1] == '\0') {
11141 /* add a new file */
11142 dynarray_add((void ***)&files
, &nb_files
, r
);
11143 if (!multiple_files
) {
11145 /* argv[0] will be this file */
11149 /* find option in table (match only the first chars */
11150 popt
= tcc_options
;
11154 error("invalid option -- '%s'", r
);
11167 if (popt
->flags
& TCC_OPTION_HAS_ARG
) {
11168 if (*r1
!= '\0' || (popt
->flags
& TCC_OPTION_NOSEP
)) {
11171 if (optind
>= argc
)
11172 error("argument to '%s' is missing", r
);
11173 optarg
= argv
[optind
++];
11181 switch(popt
->index
) {
11182 case TCC_OPTION_HELP
:
11186 if (tcc_add_include_path(s
, optarg
) < 0)
11187 error("too many include paths");
11192 sym
= (char *)optarg
;
11193 value
= strchr(sym
, '=');
11198 tcc_define_symbol(s
, sym
, value
);
11202 tcc_undefine_symbol(s
, optarg
);
11205 tcc_add_library_path(s
, optarg
);
11208 /* set tcc utilities path (mainly for tcc development) */
11209 tcc_lib_path
= optarg
;
11212 dynarray_add((void ***)&files
, &nb_files
, r
);
11215 case TCC_OPTION_bench
:
11218 case TCC_OPTION_bt
:
11219 num_callers
= atoi(optarg
);
11221 #ifdef CONFIG_TCC_BCHECK
11223 do_bounds_check
= 1;
11231 multiple_files
= 1;
11232 output_type
= TCC_OUTPUT_OBJ
;
11234 case TCC_OPTION_static
:
11235 s
->static_link
= 1;
11237 case TCC_OPTION_shared
:
11238 output_type
= TCC_OUTPUT_DLL
;
11240 case TCC_OPTION_soname
:
11241 s
->soname
= optarg
;
11244 multiple_files
= 1;
11248 /* generate a .o merging several output files */
11250 output_type
= TCC_OUTPUT_OBJ
;
11252 case TCC_OPTION_nostdinc
:
11255 case TCC_OPTION_nostdlib
:
11258 case TCC_OPTION_print_search_dirs
:
11259 print_search_dirs
= 1;
11261 case TCC_OPTION_run
:
11265 argc1
= expand_args(&argv1
, optarg
);
11267 parse_args(s
, argc1
, argv1
);
11269 multiple_files
= 0;
11270 output_type
= TCC_OUTPUT_MEMORY
;
11275 if (0 == verbose
++)
11276 printf("tcc version %s\n", TCC_VERSION
);
11277 } while (*optarg
++ == 'v');
11280 if (tcc_set_flag(s
, optarg
, 1) < 0 && s
->warn_unsupported
)
11281 goto unsupported_option
;
11284 if (tcc_set_warning(s
, optarg
, 1) < 0 &&
11285 s
->warn_unsupported
)
11286 goto unsupported_option
;
11291 case TCC_OPTION_rdynamic
:
11294 case TCC_OPTION_Wl
:
11297 if (strstart(optarg
, "-Ttext,", &p
)) {
11298 s
->text_addr
= strtoul(p
, NULL
, 16);
11299 s
->has_text_addr
= 1;
11300 } else if (strstart(optarg
, "--oformat,", &p
)) {
11301 if (strstart(p
, "elf32-", NULL
)) {
11302 s
->output_format
= TCC_OUTPUT_FORMAT_ELF
;
11303 } else if (!strcmp(p
, "binary")) {
11304 s
->output_format
= TCC_OUTPUT_FORMAT_BINARY
;
11306 #ifdef TCC_TARGET_COFF
11307 if (!strcmp(p
, "coff")) {
11308 s
->output_format
= TCC_OUTPUT_FORMAT_COFF
;
11312 error("target %s not found", p
);
11315 error("unsupported linker option '%s'", optarg
);
11320 output_type
= TCC_OUTPUT_PREPROCESS
;
11323 if (s
->warn_unsupported
) {
11324 unsupported_option
:
11325 warning("unsupported option '%s'", r
);
11334 int main(int argc
, char **argv
)
11338 int nb_objfiles
, ret
, optind
;
11339 char objfilename
[1024];
11340 int64_t start_time
= 0;
11343 tcc_lib_path
= w32_tcc_lib_path();
11347 output_type
= TCC_OUTPUT_EXE
;
11349 multiple_files
= 1;
11354 print_search_dirs
= 0;
11357 optind
= parse_args(s
, argc
- 1, argv
+ 1);
11358 if (print_search_dirs
) {
11359 /* enough for Linux kernel */
11360 printf("install: %s/\n", tcc_lib_path
);
11363 if (optind
== 0 || nb_files
== 0) {
11364 if (optind
&& verbose
)
11370 nb_objfiles
= nb_files
- nb_libraries
;
11372 /* if outfile provided without other options, we output an
11374 if (outfile
&& output_type
== TCC_OUTPUT_MEMORY
)
11375 output_type
= TCC_OUTPUT_EXE
;
11377 /* check -c consistency : only single file handled. XXX: checks file type */
11378 if (output_type
== TCC_OUTPUT_OBJ
&& !reloc_output
) {
11379 /* accepts only a single input file */
11380 if (nb_objfiles
!= 1)
11381 error("cannot specify multiple files with -c");
11382 if (nb_libraries
!= 0)
11383 error("cannot specify libraries with -c");
11387 if (output_type
== TCC_OUTPUT_PREPROCESS
) {
11389 s
->outfile
= stdout
;
11391 s
->outfile
= fopen(outfile
, "w");
11393 error("could not open '%s", outfile
);
11395 } else if (output_type
!= TCC_OUTPUT_MEMORY
) {
11397 /* compute default outfile name */
11400 strcmp(files
[0], "-") == 0 ? "a" : tcc_basename(files
[0]);
11401 pstrcpy(objfilename
, sizeof(objfilename
), name
);
11402 ext
= tcc_fileextension(objfilename
);
11403 #ifdef TCC_TARGET_PE
11404 if (output_type
== TCC_OUTPUT_DLL
)
11405 strcpy(ext
, ".dll");
11407 if (output_type
== TCC_OUTPUT_EXE
)
11408 strcpy(ext
, ".exe");
11411 if (output_type
== TCC_OUTPUT_OBJ
&& !reloc_output
&& *ext
)
11414 pstrcpy(objfilename
, sizeof(objfilename
), "a.out");
11415 outfile
= objfilename
;
11420 start_time
= getclock_us();
11423 tcc_set_output_type(s
, output_type
);
11425 /* compile or add each files or library */
11426 for(i
= 0; i
< nb_files
&& ret
== 0; i
++) {
11427 const char *filename
;
11429 filename
= files
[i
];
11430 if (output_type
== TCC_OUTPUT_PREPROCESS
) {
11431 if (tcc_add_file_internal(s
, filename
,
11432 AFF_PRINT_ERROR
| AFF_PREPROCESS
) < 0)
11434 } else if (filename
[0] == '-' && filename
[1]) {
11435 if (tcc_add_library(s
, filename
+ 2) < 0)
11436 error("cannot find %s", filename
);
11439 printf("-> %s\n", filename
);
11440 if (tcc_add_file(s
, filename
) < 0)
11445 /* free all files */
11453 total_time
= (double)(getclock_us() - start_time
) / 1000000.0;
11454 if (total_time
< 0.001)
11455 total_time
= 0.001;
11456 if (total_bytes
< 1)
11458 printf("%d idents, %d lines, %d bytes, %0.3f s, %d lines/s, %0.1f MB/s\n",
11459 tok_ident
- TOK_IDENT
, total_lines
, total_bytes
,
11460 total_time
, (int)(total_lines
/ total_time
),
11461 total_bytes
/ total_time
/ 1000000.0);
11464 if (s
->output_type
== TCC_OUTPUT_PREPROCESS
) {
11466 fclose(s
->outfile
);
11467 } else if (s
->output_type
== TCC_OUTPUT_MEMORY
) {
11468 ret
= tcc_run(s
, argc
- optind
, argv
+ optind
);
11470 ret
= tcc_output_file(s
, outfile
) ? 1 : 0;
11472 /* XXX: cannot do it with bound checking because of the malloc hooks */
11473 if (!do_bounds_check
)
11478 printf("memory: %d bytes, max = %d bytes\n", mem_cur_size
, mem_max_size
);