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 */
546 #ifdef TCC_TARGET_X86_64
547 /* buffer to store jump tables */
553 /* The current value can be: */
554 #define VT_VALMASK 0x00ff
555 #define VT_CONST 0x00f0 /* constant in vc
556 (must be first non register value) */
557 #define VT_LLOCAL 0x00f1 /* lvalue, offset on stack */
558 #define VT_LOCAL 0x00f2 /* offset on stack */
559 #define VT_CMP 0x00f3 /* the value is stored in processor flags (in vc) */
560 #define VT_JMP 0x00f4 /* value is the consequence of jmp true (even) */
561 #define VT_JMPI 0x00f5 /* value is the consequence of jmp false (odd) */
562 #define VT_LVAL 0x0100 /* var is an lvalue */
563 #define VT_SYM 0x0200 /* a symbol value is added */
564 #define VT_MUSTCAST 0x0400 /* value must be casted to be correct (used for
565 char/short stored in integer registers) */
566 #define VT_MUSTBOUND 0x0800 /* bound checking must be done before
567 dereferencing value */
568 #define VT_BOUNDED 0x8000 /* value is bounded. The address of the
569 bounding function call point is in vc */
570 #define VT_LVAL_BYTE 0x1000 /* lvalue is a byte */
571 #define VT_LVAL_SHORT 0x2000 /* lvalue is a short */
572 #define VT_LVAL_UNSIGNED 0x4000 /* lvalue is unsigned */
573 #define VT_LVAL_TYPE (VT_LVAL_BYTE | VT_LVAL_SHORT | VT_LVAL_UNSIGNED)
576 #define VT_INT 0 /* integer type */
577 #define VT_BYTE 1 /* signed byte type */
578 #define VT_SHORT 2 /* short type */
579 #define VT_VOID 3 /* void type */
580 #define VT_PTR 4 /* pointer */
581 #define VT_ENUM 5 /* enum definition */
582 #define VT_FUNC 6 /* function type */
583 #define VT_STRUCT 7 /* struct/union definition */
584 #define VT_FLOAT 8 /* IEEE float */
585 #define VT_DOUBLE 9 /* IEEE double */
586 #define VT_LDOUBLE 10 /* IEEE long double */
587 #define VT_BOOL 11 /* ISOC99 boolean type */
588 #define VT_LLONG 12 /* 64 bit integer */
589 #define VT_LONG 13 /* long integer (NEVER USED as type, only
591 #define VT_BTYPE 0x000f /* mask for basic type */
592 #define VT_UNSIGNED 0x0010 /* unsigned type */
593 #define VT_ARRAY 0x0020 /* array type (also has VT_PTR) */
594 #define VT_BITFIELD 0x0040 /* bitfield modifier */
595 #define VT_CONSTANT 0x0800 /* const modifier */
596 #define VT_VOLATILE 0x1000 /* volatile modifier */
597 #define VT_SIGNED 0x2000 /* signed type */
600 #define VT_EXTERN 0x00000080 /* extern definition */
601 #define VT_STATIC 0x00000100 /* static variable */
602 #define VT_TYPEDEF 0x00000200 /* typedef definition */
603 #define VT_INLINE 0x00000400 /* inline definition */
605 #define VT_STRUCT_SHIFT 16 /* shift for bitfield shift values */
607 /* type mask (except storage) */
608 #define VT_STORAGE (VT_EXTERN | VT_STATIC | VT_TYPEDEF | VT_INLINE)
609 #define VT_TYPE (~(VT_STORAGE))
613 /* warning: the following compare tokens depend on i386 asm code */
620 #define TOK_Nset 0x98
621 #define TOK_Nclear 0x99
627 #define TOK_LAND 0xa0
631 #define TOK_MID 0xa3 /* inc/dec, to void constant */
633 #define TOK_UDIV 0xb0 /* unsigned division */
634 #define TOK_UMOD 0xb1 /* unsigned modulo */
635 #define TOK_PDIV 0xb2 /* fast division with undefined rounding for pointers */
636 #define TOK_CINT 0xb3 /* number in tokc */
637 #define TOK_CCHAR 0xb4 /* char constant in tokc */
638 #define TOK_STR 0xb5 /* pointer to string in tokc */
639 #define TOK_TWOSHARPS 0xb6 /* ## preprocessing token */
640 #define TOK_LCHAR 0xb7
641 #define TOK_LSTR 0xb8
642 #define TOK_CFLOAT 0xb9 /* float constant */
643 #define TOK_LINENUM 0xba /* line number info */
644 #define TOK_CDOUBLE 0xc0 /* double constant */
645 #define TOK_CLDOUBLE 0xc1 /* long double constant */
646 #define TOK_UMULL 0xc2 /* unsigned 32x32 -> 64 mul */
647 #define TOK_ADDC1 0xc3 /* add with carry generation */
648 #define TOK_ADDC2 0xc4 /* add with carry use */
649 #define TOK_SUBC1 0xc5 /* add with carry generation */
650 #define TOK_SUBC2 0xc6 /* add with carry use */
651 #define TOK_CUINT 0xc8 /* unsigned int constant */
652 #define TOK_CLLONG 0xc9 /* long long constant */
653 #define TOK_CULLONG 0xca /* unsigned long long constant */
654 #define TOK_ARROW 0xcb
655 #define TOK_DOTS 0xcc /* three dots */
656 #define TOK_SHR 0xcd /* unsigned shift right */
657 #define TOK_PPNUM 0xce /* preprocessor number */
659 #define TOK_SHL 0x01 /* shift left */
660 #define TOK_SAR 0x02 /* signed shift right */
662 /* assignement operators : normal operator or 0x80 */
663 #define TOK_A_MOD 0xa5
664 #define TOK_A_AND 0xa6
665 #define TOK_A_MUL 0xaa
666 #define TOK_A_ADD 0xab
667 #define TOK_A_SUB 0xad
668 #define TOK_A_DIV 0xaf
669 #define TOK_A_XOR 0xde
670 #define TOK_A_OR 0xfc
671 #define TOK_A_SHL 0x81
672 #define TOK_A_SAR 0x82
675 #define offsetof(type, field) ((size_t) &((type *)0)->field)
679 #define countof(tab) (sizeof(tab) / sizeof((tab)[0]))
682 /* WARNING: the content of this string encodes token numbers */
683 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";
685 #define TOK_EOF (-1) /* end of file */
686 #define TOK_LINEFEED 10 /* line feed */
688 /* all identificators and strings have token above that */
689 #define TOK_IDENT 256
691 /* only used for i386 asm opcodes definitions */
692 #define DEF_ASM(x) DEF(TOK_ASM_ ## x, #x)
695 DEF(TOK_ASM_ ## x ## b, #x "b") \
696 DEF(TOK_ASM_ ## x ## w, #x "w") \
697 DEF(TOK_ASM_ ## x ## l, #x "l") \
698 DEF(TOK_ASM_ ## x, #x)
701 DEF(TOK_ASM_ ## x ## w, #x "w") \
702 DEF(TOK_ASM_ ## x ## l, #x "l") \
703 DEF(TOK_ASM_ ## x, #x)
706 DEF(TOK_ASM_ ## f ## x ## s, "f" #x "s") \
707 DEF(TOK_ASM_ ## fi ## x ## l, "fi" #x "l") \
708 DEF(TOK_ASM_ ## f ## x ## l, "f" #x "l") \
709 DEF(TOK_ASM_ ## fi ## x ## s, "fi" #x "s")
712 DEF(TOK_ASM_ ## f ## x, "f" #x ) \
713 DEF(TOK_ASM_ ## f ## x ## p, "f" #x "p") \
716 #define DEF_ASMTEST(x) \
748 #define TOK_ASM_int TOK_INT
751 TOK_LAST
= TOK_IDENT
- 1,
752 #define DEF(id, str) id,
757 static const char tcc_keywords
[] =
758 #define DEF(id, str) str "\0"
763 #define TOK_UIDENT TOK_DEFINE
766 #define snprintf _snprintf
767 #define vsnprintf _vsnprintf
769 #define strtold (long double)strtod
770 #define strtof (float)strtod
771 #define strtoll (long long)strtol
773 #elif defined(TCC_UCLIBC) || defined(__FreeBSD__) || defined(__DragonFly__) \
774 || defined(__OpenBSD__)
775 /* currently incorrect */
776 long double strtold(const char *nptr
, char **endptr
)
778 return (long double)strtod(nptr
, endptr
);
780 float strtof(const char *nptr
, char **endptr
)
782 return (float)strtod(nptr
, endptr
);
785 /* XXX: need to define this to use them in non ISOC99 context */
786 extern float strtof (const char *__nptr
, char **__endptr
);
787 extern long double strtold (const char *__nptr
, char **__endptr
);
790 static char *pstrcpy(char *buf
, int buf_size
, const char *s
);
791 static char *pstrcat(char *buf
, int buf_size
, const char *s
);
792 static char *tcc_basename(const char *name
);
793 static char *tcc_fileextension (const char *p
);
795 static void next(void);
796 static void next_nomacro(void);
797 static void parse_expr_type(CType
*type
);
798 static void expr_type(CType
*type
);
799 static void unary_type(CType
*type
);
800 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
,
801 int case_reg
, int is_expr
);
802 static int expr_const(void);
803 static void expr_eq(void);
804 static void gexpr(void);
805 static void gen_inline_functions(void);
806 static void decl(int l
);
807 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
808 int first
, int size_only
);
809 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
810 int has_init
, int v
, int scope
);
812 void gv2(int rc1
, int rc2
);
813 void move_reg(int r
, int s
);
814 void save_regs(int n
);
815 void save_reg(int r
);
820 int get_reg_ex(int rc
,int rc2
);
823 struct macro_level
*prev
;
827 static void macro_subst(TokenString
*tok_str
, Sym
**nested_list
,
828 const int *macro_str
, struct macro_level
**can_read_stream
);
830 void force_charshort_cast(int t
);
831 static void gen_cast(CType
*type
);
833 static Sym
*sym_find(int v
);
834 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
);
837 static int type_size(CType
*type
, int *a
);
838 static inline CType
*pointed_type(CType
*type
);
839 static int pointed_size(CType
*type
);
840 static int lvalue_type(int t
);
841 static int parse_btype(CType
*type
, AttributeDef
*ad
);
842 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
);
843 static int compare_types(CType
*type1
, CType
*type2
, int unqualified
);
844 static int is_compatible_types(CType
*type1
, CType
*type2
);
845 static int is_compatible_parameter_types(CType
*type1
, CType
*type2
);
847 int ieee_finite(double d
);
848 void error(const char *fmt
, ...);
850 void vpushll(long long v
);
853 void lexpand_nr(void);
854 static void vpush_global_sym(CType
*type
, int v
);
855 void vset(CType
*type
, int r
, int v
);
856 void type_to_str(char *buf
, int buf_size
,
857 CType
*type
, const char *varstr
);
858 char *get_tok_str(int v
, CValue
*cv
);
859 static Sym
*get_sym_ref(CType
*type
, Section
*sec
,
860 unsigned long offset
, unsigned long size
);
861 static Sym
*external_global_sym(int v
, CType
*type
, int r
);
863 /* section generation */
864 static void section_realloc(Section
*sec
, unsigned long new_size
);
865 static void *section_ptr_add(Section
*sec
, unsigned long size
);
866 static void put_extern_sym(Sym
*sym
, Section
*section
,
867 unsigned long value
, unsigned long size
);
868 static void greloc(Section
*s
, Sym
*sym
, unsigned long addr
, int type
);
869 static int put_elf_str(Section
*s
, const char *sym
);
870 static int put_elf_sym(Section
*s
,
871 unsigned long value
, unsigned long size
,
872 int info
, int other
, int shndx
, const char *name
);
873 static int add_elf_sym(Section
*s
, unsigned long value
, unsigned long size
,
874 int info
, int other
, int sh_num
, const char *name
);
875 static void put_elf_reloc(Section
*symtab
, Section
*s
, unsigned long offset
,
876 int type
, int symbol
);
877 static void put_stabs(const char *str
, int type
, int other
, int desc
,
878 unsigned long value
);
879 static void put_stabs_r(const char *str
, int type
, int other
, int desc
,
880 unsigned long value
, Section
*sec
, int sym_index
);
881 static void put_stabn(int type
, int other
, int desc
, int value
);
882 static void put_stabd(int type
, int other
, int desc
);
883 static int tcc_add_dll(TCCState
*s
, const char *filename
, int flags
);
885 #define AFF_PRINT_ERROR 0x0001 /* print error if file not found */
886 #define AFF_REFERENCED_DLL 0x0002 /* load a referenced dll from another dll */
887 #define AFF_PREPROCESS 0x0004 /* preprocess file */
888 static int tcc_add_file_internal(TCCState
*s
, const char *filename
, int flags
);
891 int tcc_output_coff(TCCState
*s1
, FILE *f
);
894 void *resolve_sym(TCCState
*s1
, const char *sym
, int type
);
895 int pe_load_def_file(struct TCCState
*s1
, int fd
);
896 int pe_test_res_file(void *v
, int size
);
897 int pe_load_res_file(struct TCCState
*s1
, int fd
);
898 void pe_add_runtime(struct TCCState
*s1
);
899 void pe_guess_outfile(char *objfilename
, int output_type
);
900 int pe_output_file(struct TCCState
*s1
, const char *filename
);
904 #ifdef CONFIG_TCC_ASM
906 typedef struct ExprValue
{
911 #define MAX_ASM_OPERANDS 30
913 typedef struct ASMOperand
{
914 int id
; /* GCC 3 optionnal identifier (0 if number only supported */
916 char asm_str
[16]; /* computed asm string for operand */
917 SValue
*vt
; /* C value of the expression */
918 int ref_index
; /* if >= 0, gives reference to a output constraint */
919 int input_index
; /* if >= 0, gives reference to an input constraint */
920 int priority
; /* priority, used to assign registers */
921 int reg
; /* if >= 0, register number used for this operand */
922 int is_llong
; /* true if double register value */
923 int is_memory
; /* true if memory operand */
924 int is_rw
; /* for '+' modifier */
927 static void asm_expr(TCCState
*s1
, ExprValue
*pe
);
928 static int asm_int_expr(TCCState
*s1
);
929 static int find_constraint(ASMOperand
*operands
, int nb_operands
,
930 const char *name
, const char **pp
);
932 static int tcc_assemble(TCCState
*s1
, int do_preprocess
);
936 static void asm_instr(void);
937 static void asm_global_instr(void);
939 /* true if float/double/long double type */
940 static inline int is_float(int t
)
944 return bt
== VT_LDOUBLE
|| bt
== VT_DOUBLE
|| bt
== VT_FLOAT
;
947 #ifdef TCC_TARGET_I386
948 #include "i386-gen.c"
951 #ifdef TCC_TARGET_ARM
955 #ifdef TCC_TARGET_C67
959 #ifdef TCC_TARGET_X86_64
960 #include "x86_64-gen.c"
963 #ifdef CONFIG_TCC_STATIC
965 #define RTLD_LAZY 0x001
966 #define RTLD_NOW 0x002
967 #define RTLD_GLOBAL 0x100
968 #define RTLD_DEFAULT NULL
970 /* dummy function for profiling */
971 void *dlopen(const char *filename
, int flag
)
976 const char *dlerror(void)
981 typedef struct TCCSyms
{
986 #define TCCSYM(a) { #a, &a, },
988 /* add the symbol you want here if no dynamic linking is done */
989 static TCCSyms tcc_syms
[] = {
990 #if !defined(CONFIG_TCCBOOT)
999 void *resolve_sym(TCCState
*s1
, const char *symbol
, int type
)
1003 while (p
->str
!= NULL
) {
1004 if (!strcmp(p
->str
, symbol
))
1011 #elif !defined(_WIN32)
1015 void *resolve_sym(TCCState
*s1
, const char *sym
, int type
)
1017 return dlsym(RTLD_DEFAULT
, sym
);
1022 /********************************************************/
1024 /* we use our own 'finite' function to avoid potential problems with
1025 non standard math libs */
1026 /* XXX: endianness dependent */
1027 int ieee_finite(double d
)
1030 return ((unsigned)((p
[1] | 0x800fffff) + 1)) >> 31;
1033 /* copy a string and truncate it. */
1034 static char *pstrcpy(char *buf
, int buf_size
, const char *s
)
1041 q_end
= buf
+ buf_size
- 1;
1053 /* strcat and truncate. */
1054 static char *pstrcat(char *buf
, int buf_size
, const char *s
)
1059 pstrcpy(buf
+ len
, buf_size
- len
, s
);
1064 static int strstart(const char *str
, const char *val
, const char **ptr
)
1069 while (*q
!= '\0') {
1081 /* extract the basename of a file */
1082 static char *tcc_basename(const char *name
)
1084 char *p
= strchr(name
, 0);
1095 static char *tcc_fileextension (const char *name
)
1097 char *b
= tcc_basename(name
);
1098 char *e
= strrchr(b
, '.');
1099 return e
? e
: strchr(b
, 0);
1103 char *normalize_slashes(char *path
)
1106 for (p
= path
; *p
; ++p
)
1112 char *w32_tcc_lib_path(void)
1114 /* on win32, we suppose the lib and includes are at the location
1116 char path
[1024], *p
;
1117 GetModuleFileNameA(NULL
, path
, sizeof path
);
1118 p
= tcc_basename(normalize_slashes(strlwr(path
)));
1119 if (p
- 5 > path
&& 0 == strncmp(p
- 5, "/bin/", 5))
1124 return strdup(path
);
1128 void set_pages_executable(void *ptr
, unsigned long length
)
1131 unsigned long old_protect
;
1132 VirtualProtect(ptr
, length
, PAGE_EXECUTE_READWRITE
, &old_protect
);
1134 unsigned long start
, end
;
1135 start
= (unsigned long)ptr
& ~(PAGESIZE
- 1);
1136 end
= (unsigned long)ptr
+ length
;
1137 end
= (end
+ PAGESIZE
- 1) & ~(PAGESIZE
- 1);
1138 mprotect((void *)start
, end
- start
, PROT_READ
| PROT_WRITE
| PROT_EXEC
);
1142 /* memory management */
1146 unsigned malloc_usable_size(void*);
1149 static inline void tcc_free(void *ptr
)
1152 mem_cur_size
-= malloc_usable_size(ptr
);
1157 static void *tcc_malloc(unsigned long size
)
1162 error("memory full");
1164 mem_cur_size
+= malloc_usable_size(ptr
);
1165 if (mem_cur_size
> mem_max_size
)
1166 mem_max_size
= mem_cur_size
;
1171 static void *tcc_mallocz(unsigned long size
)
1174 ptr
= tcc_malloc(size
);
1175 memset(ptr
, 0, size
);
1179 static inline void *tcc_realloc(void *ptr
, unsigned long size
)
1183 mem_cur_size
-= malloc_usable_size(ptr
);
1185 ptr1
= realloc(ptr
, size
);
1187 /* NOTE: count not correct if alloc error, but not critical */
1188 mem_cur_size
+= malloc_usable_size(ptr1
);
1189 if (mem_cur_size
> mem_max_size
)
1190 mem_max_size
= mem_cur_size
;
1195 static char *tcc_strdup(const char *str
)
1198 ptr
= tcc_malloc(strlen(str
) + 1);
1203 #define free(p) use_tcc_free(p)
1204 #define malloc(s) use_tcc_malloc(s)
1205 #define realloc(p, s) use_tcc_realloc(p, s)
1207 static void dynarray_add(void ***ptab
, int *nb_ptr
, void *data
)
1214 /* every power of two we double array size */
1215 if ((nb
& (nb
- 1)) == 0) {
1220 pp
= tcc_realloc(pp
, nb_alloc
* sizeof(void *));
1222 error("memory full");
1229 static void dynarray_reset(void *pp
, int *n
)
1232 for (p
= *(void***)pp
; *n
; ++p
, --*n
)
1235 tcc_free(*(void**)pp
);
1239 /* symbol allocator */
1240 static Sym
*__sym_malloc(void)
1242 Sym
*sym_pool
, *sym
, *last_sym
;
1245 sym_pool
= tcc_malloc(SYM_POOL_NB
* sizeof(Sym
));
1246 dynarray_add(&sym_pools
, &nb_sym_pools
, sym_pool
);
1248 last_sym
= sym_free_first
;
1250 for(i
= 0; i
< SYM_POOL_NB
; i
++) {
1251 sym
->next
= last_sym
;
1255 sym_free_first
= last_sym
;
1259 static inline Sym
*sym_malloc(void)
1262 sym
= sym_free_first
;
1264 sym
= __sym_malloc();
1265 sym_free_first
= sym
->next
;
1269 static inline void sym_free(Sym
*sym
)
1271 sym
->next
= sym_free_first
;
1272 sym_free_first
= sym
;
1275 Section
*new_section(TCCState
*s1
, const char *name
, int sh_type
, int sh_flags
)
1279 sec
= tcc_mallocz(sizeof(Section
) + strlen(name
));
1280 strcpy(sec
->name
, name
);
1281 sec
->sh_type
= sh_type
;
1282 sec
->sh_flags
= sh_flags
;
1290 sec
->sh_addralign
= 4;
1293 sec
->sh_addralign
= 1;
1296 sec
->sh_addralign
= 32; /* default conservative alignment */
1300 if (sh_flags
& SHF_PRIVATE
) {
1301 dynarray_add((void ***)&s1
->priv_sections
, &s1
->nb_priv_sections
, sec
);
1303 sec
->sh_num
= s1
->nb_sections
;
1304 dynarray_add((void ***)&s1
->sections
, &s1
->nb_sections
, sec
);
1310 static void free_section(Section
*s
)
1315 /* realloc section and set its content to zero */
1316 static void section_realloc(Section
*sec
, unsigned long new_size
)
1319 unsigned char *data
;
1321 size
= sec
->data_allocated
;
1324 while (size
< new_size
)
1326 data
= tcc_realloc(sec
->data
, size
);
1328 error("memory full");
1329 memset(data
+ sec
->data_allocated
, 0, size
- sec
->data_allocated
);
1331 sec
->data_allocated
= size
;
1334 /* reserve at least 'size' bytes in section 'sec' from
1335 sec->data_offset. */
1336 static void *section_ptr_add(Section
*sec
, unsigned long size
)
1338 unsigned long offset
, offset1
;
1340 offset
= sec
->data_offset
;
1341 offset1
= offset
+ size
;
1342 if (offset1
> sec
->data_allocated
)
1343 section_realloc(sec
, offset1
);
1344 sec
->data_offset
= offset1
;
1345 return sec
->data
+ offset
;
1348 /* return a reference to a section, and create it if it does not
1350 Section
*find_section(TCCState
*s1
, const char *name
)
1354 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1355 sec
= s1
->sections
[i
];
1356 if (!strcmp(name
, sec
->name
))
1359 /* sections are created as PROGBITS */
1360 return new_section(s1
, name
, SHT_PROGBITS
, SHF_ALLOC
);
1363 #define SECTION_ABS ((void *)1)
1365 /* update sym->c so that it points to an external symbol in section
1366 'section' with value 'value' */
1367 static void put_extern_sym2(Sym
*sym
, Section
*section
,
1368 unsigned long value
, unsigned long size
,
1369 int can_add_underscore
)
1371 int sym_type
, sym_bind
, sh_num
, info
, other
, attr
;
1376 if (section
== NULL
)
1378 else if (section
== SECTION_ABS
)
1381 sh_num
= section
->sh_num
;
1385 if ((sym
->type
.t
& VT_BTYPE
) == VT_FUNC
) {
1386 sym_type
= STT_FUNC
;
1387 #ifdef TCC_TARGET_PE
1389 attr
= sym
->type
.ref
->r
;
1390 if (FUNC_EXPORT(attr
))
1392 if (FUNC_CALL(attr
) == FUNC_STDCALL
)
1396 sym_type
= STT_OBJECT
;
1399 if (sym
->type
.t
& VT_STATIC
)
1400 sym_bind
= STB_LOCAL
;
1402 sym_bind
= STB_GLOBAL
;
1405 name
= get_tok_str(sym
->v
, NULL
);
1406 #ifdef CONFIG_TCC_BCHECK
1407 if (do_bounds_check
) {
1410 /* XXX: avoid doing that for statics ? */
1411 /* if bound checking is activated, we change some function
1412 names by adding the "__bound" prefix */
1415 /* XXX: we rely only on malloc hooks */
1428 strcpy(buf
, "__bound_");
1436 #ifdef TCC_TARGET_PE
1437 if ((other
& 2) && can_add_underscore
) {
1438 sprintf(buf1
, "_%s@%d", name
, FUNC_ARGS(attr
));
1442 if (tcc_state
->leading_underscore
&& can_add_underscore
) {
1444 pstrcpy(buf1
+ 1, sizeof(buf1
) - 1, name
);
1447 info
= ELFW(ST_INFO
)(sym_bind
, sym_type
);
1448 sym
->c
= add_elf_sym(symtab_section
, value
, size
, info
, other
, sh_num
, name
);
1450 esym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
];
1451 esym
->st_value
= value
;
1452 esym
->st_size
= size
;
1453 esym
->st_shndx
= sh_num
;
1454 esym
->st_other
|= other
;
1458 static void put_extern_sym(Sym
*sym
, Section
*section
,
1459 unsigned long value
, unsigned long size
)
1461 put_extern_sym2(sym
, section
, value
, size
, 1);
1464 /* add a new relocation entry to symbol 'sym' in section 's' */
1465 static void greloc(Section
*s
, Sym
*sym
, unsigned long offset
, int type
)
1468 put_extern_sym(sym
, NULL
, 0, 0);
1469 /* now we can add ELF relocation info */
1470 put_elf_reloc(symtab_section
, s
, offset
, type
, sym
->c
);
1473 static inline int isid(int c
)
1475 return (c
>= 'a' && c
<= 'z') ||
1476 (c
>= 'A' && c
<= 'Z') ||
1480 static inline int isnum(int c
)
1482 return c
>= '0' && c
<= '9';
1485 static inline int isoct(int c
)
1487 return c
>= '0' && c
<= '7';
1490 static inline int toup(int c
)
1492 if (c
>= 'a' && c
<= 'z')
1493 return c
- 'a' + 'A';
1498 static void strcat_vprintf(char *buf
, int buf_size
, const char *fmt
, va_list ap
)
1502 vsnprintf(buf
+ len
, buf_size
- len
, fmt
, ap
);
1505 static void strcat_printf(char *buf
, int buf_size
, const char *fmt
, ...)
1509 strcat_vprintf(buf
, buf_size
, fmt
, ap
);
1513 void error1(TCCState
*s1
, int is_warning
, const char *fmt
, va_list ap
)
1520 for(f
= s1
->include_stack
; f
< s1
->include_stack_ptr
; f
++)
1521 strcat_printf(buf
, sizeof(buf
), "In file included from %s:%d:\n",
1522 (*f
)->filename
, (*f
)->line_num
);
1523 if (file
->line_num
> 0) {
1524 strcat_printf(buf
, sizeof(buf
),
1525 "%s:%d: ", file
->filename
, file
->line_num
);
1527 strcat_printf(buf
, sizeof(buf
),
1528 "%s: ", file
->filename
);
1531 strcat_printf(buf
, sizeof(buf
),
1535 strcat_printf(buf
, sizeof(buf
), "warning: ");
1536 strcat_vprintf(buf
, sizeof(buf
), fmt
, ap
);
1538 if (!s1
->error_func
) {
1539 /* default case: stderr */
1540 fprintf(stderr
, "%s\n", buf
);
1542 s1
->error_func(s1
->error_opaque
, buf
);
1544 if (!is_warning
|| s1
->warn_error
)
1549 void tcc_set_error_func(TCCState
*s
, void *error_opaque
,
1550 void (*error_func
)(void *opaque
, const char *msg
))
1552 s
->error_opaque
= error_opaque
;
1553 s
->error_func
= error_func
;
1557 /* error without aborting current compilation */
1558 void error_noabort(const char *fmt
, ...)
1560 TCCState
*s1
= tcc_state
;
1564 error1(s1
, 0, fmt
, ap
);
1568 void error(const char *fmt
, ...)
1570 TCCState
*s1
= tcc_state
;
1574 error1(s1
, 0, fmt
, ap
);
1576 /* better than nothing: in some cases, we accept to handle errors */
1577 if (s1
->error_set_jmp_enabled
) {
1578 longjmp(s1
->error_jmp_buf
, 1);
1580 /* XXX: eliminate this someday */
1585 void expect(const char *msg
)
1587 error("%s expected", msg
);
1590 void warning(const char *fmt
, ...)
1592 TCCState
*s1
= tcc_state
;
1599 error1(s1
, 1, fmt
, ap
);
1606 error("'%c' expected", c
);
1610 static void test_lvalue(void)
1612 if (!(vtop
->r
& VT_LVAL
))
1616 /* allocate a new token */
1617 static TokenSym
*tok_alloc_new(TokenSym
**pts
, const char *str
, int len
)
1619 TokenSym
*ts
, **ptable
;
1622 if (tok_ident
>= SYM_FIRST_ANOM
)
1623 error("memory full");
1625 /* expand token table if needed */
1626 i
= tok_ident
- TOK_IDENT
;
1627 if ((i
% TOK_ALLOC_INCR
) == 0) {
1628 ptable
= tcc_realloc(table_ident
, (i
+ TOK_ALLOC_INCR
) * sizeof(TokenSym
*));
1630 error("memory full");
1631 table_ident
= ptable
;
1634 ts
= tcc_malloc(sizeof(TokenSym
) + len
);
1635 table_ident
[i
] = ts
;
1636 ts
->tok
= tok_ident
++;
1637 ts
->sym_define
= NULL
;
1638 ts
->sym_label
= NULL
;
1639 ts
->sym_struct
= NULL
;
1640 ts
->sym_identifier
= NULL
;
1642 ts
->hash_next
= NULL
;
1643 memcpy(ts
->str
, str
, len
);
1644 ts
->str
[len
] = '\0';
1649 #define TOK_HASH_INIT 1
1650 #define TOK_HASH_FUNC(h, c) ((h) * 263 + (c))
1652 /* find a token and add it if not found */
1653 static TokenSym
*tok_alloc(const char *str
, int len
)
1655 TokenSym
*ts
, **pts
;
1661 h
= TOK_HASH_FUNC(h
, ((unsigned char *)str
)[i
]);
1662 h
&= (TOK_HASH_SIZE
- 1);
1664 pts
= &hash_ident
[h
];
1669 if (ts
->len
== len
&& !memcmp(ts
->str
, str
, len
))
1671 pts
= &(ts
->hash_next
);
1673 return tok_alloc_new(pts
, str
, len
);
1676 /* CString handling */
1678 static void cstr_realloc(CString
*cstr
, int new_size
)
1683 size
= cstr
->size_allocated
;
1685 size
= 8; /* no need to allocate a too small first string */
1686 while (size
< new_size
)
1688 data
= tcc_realloc(cstr
->data_allocated
, size
);
1690 error("memory full");
1691 cstr
->data_allocated
= data
;
1692 cstr
->size_allocated
= size
;
1697 static inline void cstr_ccat(CString
*cstr
, int ch
)
1700 size
= cstr
->size
+ 1;
1701 if (size
> cstr
->size_allocated
)
1702 cstr_realloc(cstr
, size
);
1703 ((unsigned char *)cstr
->data
)[size
- 1] = ch
;
1707 static void cstr_cat(CString
*cstr
, const char *str
)
1719 /* add a wide char */
1720 static void cstr_wccat(CString
*cstr
, int ch
)
1723 size
= cstr
->size
+ sizeof(nwchar_t
);
1724 if (size
> cstr
->size_allocated
)
1725 cstr_realloc(cstr
, size
);
1726 *(nwchar_t
*)(((unsigned char *)cstr
->data
) + size
- sizeof(nwchar_t
)) = ch
;
1730 static void cstr_new(CString
*cstr
)
1732 memset(cstr
, 0, sizeof(CString
));
1735 /* free string and reset it to NULL */
1736 static void cstr_free(CString
*cstr
)
1738 tcc_free(cstr
->data_allocated
);
1742 #define cstr_reset(cstr) cstr_free(cstr)
1744 /* XXX: unicode ? */
1745 static void add_char(CString
*cstr
, int c
)
1747 if (c
== '\'' || c
== '\"' || c
== '\\') {
1748 /* XXX: could be more precise if char or string */
1749 cstr_ccat(cstr
, '\\');
1751 if (c
>= 32 && c
<= 126) {
1754 cstr_ccat(cstr
, '\\');
1756 cstr_ccat(cstr
, 'n');
1758 cstr_ccat(cstr
, '0' + ((c
>> 6) & 7));
1759 cstr_ccat(cstr
, '0' + ((c
>> 3) & 7));
1760 cstr_ccat(cstr
, '0' + (c
& 7));
1765 /* XXX: buffer overflow */
1766 /* XXX: float tokens */
1767 char *get_tok_str(int v
, CValue
*cv
)
1769 static char buf
[STRING_MAX_SIZE
+ 1];
1770 static CString cstr_buf
;
1776 /* NOTE: to go faster, we give a fixed buffer for small strings */
1777 cstr_reset(&cstr_buf
);
1778 cstr_buf
.data
= buf
;
1779 cstr_buf
.size_allocated
= sizeof(buf
);
1785 /* XXX: not quite exact, but only useful for testing */
1786 sprintf(p
, "%u", cv
->ui
);
1790 /* XXX: not quite exact, but only useful for testing */
1791 sprintf(p
, "%Lu", cv
->ull
);
1794 cstr_ccat(&cstr_buf
, 'L');
1796 cstr_ccat(&cstr_buf
, '\'');
1797 add_char(&cstr_buf
, cv
->i
);
1798 cstr_ccat(&cstr_buf
, '\'');
1799 cstr_ccat(&cstr_buf
, '\0');
1803 len
= cstr
->size
- 1;
1805 add_char(&cstr_buf
, ((unsigned char *)cstr
->data
)[i
]);
1806 cstr_ccat(&cstr_buf
, '\0');
1809 cstr_ccat(&cstr_buf
, 'L');
1812 cstr_ccat(&cstr_buf
, '\"');
1814 len
= cstr
->size
- 1;
1816 add_char(&cstr_buf
, ((unsigned char *)cstr
->data
)[i
]);
1818 len
= (cstr
->size
/ sizeof(nwchar_t
)) - 1;
1820 add_char(&cstr_buf
, ((nwchar_t
*)cstr
->data
)[i
]);
1822 cstr_ccat(&cstr_buf
, '\"');
1823 cstr_ccat(&cstr_buf
, '\0');
1832 return strcpy(p
, "...");
1834 return strcpy(p
, "<<=");
1836 return strcpy(p
, ">>=");
1838 if (v
< TOK_IDENT
) {
1839 /* search in two bytes table */
1853 } else if (v
< tok_ident
) {
1854 return table_ident
[v
- TOK_IDENT
]->str
;
1855 } else if (v
>= SYM_FIRST_ANOM
) {
1856 /* special name for anonymous symbol */
1857 sprintf(p
, "L.%u", v
- SYM_FIRST_ANOM
);
1859 /* should never happen */
1864 return cstr_buf
.data
;
1867 /* push, without hashing */
1868 static Sym
*sym_push2(Sym
**ps
, int v
, int t
, long c
)
1882 /* find a symbol and return its associated structure. 's' is the top
1883 of the symbol stack */
1884 static Sym
*sym_find2(Sym
*s
, int v
)
1894 /* structure lookup */
1895 static inline Sym
*struct_find(int v
)
1898 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1900 return table_ident
[v
]->sym_struct
;
1903 /* find an identifier */
1904 static inline Sym
*sym_find(int v
)
1907 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1909 return table_ident
[v
]->sym_identifier
;
1912 /* push a given symbol on the symbol stack */
1913 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
)
1922 s
= sym_push2(ps
, v
, type
->t
, c
);
1923 s
->type
.ref
= type
->ref
;
1925 /* don't record fields or anonymous symbols */
1927 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1928 /* record symbol in token array */
1929 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1931 ps
= &ts
->sym_struct
;
1933 ps
= &ts
->sym_identifier
;
1940 /* push a global identifier */
1941 static Sym
*global_identifier_push(int v
, int t
, int c
)
1944 s
= sym_push2(&global_stack
, v
, t
, c
);
1945 /* don't record anonymous symbol */
1946 if (v
< SYM_FIRST_ANOM
) {
1947 ps
= &table_ident
[v
- TOK_IDENT
]->sym_identifier
;
1948 /* modify the top most local identifier, so that
1949 sym_identifier will point to 's' when popped */
1951 ps
= &(*ps
)->prev_tok
;
1958 /* pop symbols until top reaches 'b' */
1959 static void sym_pop(Sym
**ptop
, Sym
*b
)
1969 /* remove symbol in token array */
1971 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1972 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1974 ps
= &ts
->sym_struct
;
1976 ps
= &ts
->sym_identifier
;
1987 BufferedFile
*tcc_open(TCCState
*s1
, const char *filename
)
1992 if (strcmp(filename
, "-") == 0)
1993 fd
= 0, filename
= "stdin";
1995 fd
= open(filename
, O_RDONLY
| O_BINARY
);
1996 if ((verbose
== 2 && fd
>= 0) || verbose
== 3)
1997 printf("%s %*s%s\n", fd
< 0 ? "nf":"->",
1998 (s1
->include_stack_ptr
- s1
->include_stack
), "", filename
);
2001 bf
= tcc_malloc(sizeof(BufferedFile
));
2003 bf
->buf_ptr
= bf
->buffer
;
2004 bf
->buf_end
= bf
->buffer
;
2005 bf
->buffer
[0] = CH_EOB
; /* put eob symbol */
2006 pstrcpy(bf
->filename
, sizeof(bf
->filename
), filename
);
2008 normalize_slashes(bf
->filename
);
2011 bf
->ifndef_macro
= 0;
2012 bf
->ifdef_stack_ptr
= s1
->ifdef_stack_ptr
;
2013 // printf("opening '%s'\n", filename);
2017 void tcc_close(BufferedFile
*bf
)
2019 total_lines
+= bf
->line_num
;
2024 /* fill input buffer and peek next char */
2025 static int tcc_peekc_slow(BufferedFile
*bf
)
2028 /* only tries to read if really end of buffer */
2029 if (bf
->buf_ptr
>= bf
->buf_end
) {
2031 #if defined(PARSE_DEBUG)
2036 len
= read(bf
->fd
, bf
->buffer
, len
);
2043 bf
->buf_ptr
= bf
->buffer
;
2044 bf
->buf_end
= bf
->buffer
+ len
;
2045 *bf
->buf_end
= CH_EOB
;
2047 if (bf
->buf_ptr
< bf
->buf_end
) {
2048 return bf
->buf_ptr
[0];
2050 bf
->buf_ptr
= bf
->buf_end
;
2055 /* return the current character, handling end of block if necessary
2057 static int handle_eob(void)
2059 return tcc_peekc_slow(file
);
2062 /* read next char from current input file and handle end of input buffer */
2063 static inline void inp(void)
2065 ch
= *(++(file
->buf_ptr
));
2066 /* end of buffer/file handling */
2071 /* handle '\[\r]\n' */
2072 static int handle_stray_noerror(void)
2074 while (ch
== '\\') {
2079 } else if (ch
== '\r') {
2093 static void handle_stray(void)
2095 if (handle_stray_noerror())
2096 error("stray '\\' in program");
2099 /* skip the stray and handle the \\n case. Output an error if
2100 incorrect char after the stray */
2101 static int handle_stray1(uint8_t *p
)
2105 if (p
>= file
->buf_end
) {
2122 /* handle just the EOB case, but not stray */
2123 #define PEEKC_EOB(c, p)\
2134 /* handle the complicated stray case */
2135 #define PEEKC(c, p)\
2140 c = handle_stray1(p);\
2145 /* input with '\[\r]\n' handling. Note that this function cannot
2146 handle other characters after '\', so you cannot call it inside
2147 strings or comments */
2148 static void minp(void)
2156 /* single line C++ comments */
2157 static uint8_t *parse_line_comment(uint8_t *p
)
2165 if (c
== '\n' || c
== CH_EOF
) {
2167 } else if (c
== '\\') {
2176 } else if (c
== '\r') {
2194 static uint8_t *parse_comment(uint8_t *p
)
2200 /* fast skip loop */
2203 if (c
== '\n' || c
== '*' || c
== '\\')
2207 if (c
== '\n' || c
== '*' || c
== '\\')
2211 /* now we can handle all the cases */
2215 } else if (c
== '*') {
2221 } else if (c
== '/') {
2222 goto end_of_comment
;
2223 } else if (c
== '\\') {
2228 /* skip '\[\r]\n', otherwise just skip the stray */
2234 } else if (c
== '\r') {
2251 /* stray, eob or eof */
2256 error("unexpected end of file in comment");
2257 } else if (c
== '\\') {
2269 /* space exlcuding newline */
2270 static inline int is_space(int ch
)
2272 return ch
== ' ' || ch
== '\t' || ch
== '\v' || ch
== '\f' || ch
== '\r';
2275 static inline void skip_spaces(void)
2277 while (is_space(ch
))
2281 /* parse a string without interpreting escapes */
2282 static uint8_t *parse_pp_string(uint8_t *p
,
2283 int sep
, CString
*str
)
2291 } else if (c
== '\\') {
2296 unterminated_string
:
2297 /* XXX: indicate line number of start of string */
2298 error("missing terminating %c character", sep
);
2299 } else if (c
== '\\') {
2300 /* escape : just skip \[\r]\n */
2305 } else if (c
== '\r') {
2308 expect("'\n' after '\r'");
2311 } else if (c
== CH_EOF
) {
2312 goto unterminated_string
;
2315 cstr_ccat(str
, '\\');
2321 } else if (c
== '\n') {
2324 } else if (c
== '\r') {
2328 cstr_ccat(str
, '\r');
2344 /* skip block of text until #else, #elif or #endif. skip also pairs of
2346 void preprocess_skip(void)
2348 int a
, start_of_line
, c
, in_warn_or_error
;
2355 in_warn_or_error
= 0;
2376 } else if (c
== '\\') {
2377 ch
= file
->buf_ptr
[0];
2378 handle_stray_noerror();
2385 if (in_warn_or_error
)
2387 p
= parse_pp_string(p
, c
, NULL
);
2391 if (in_warn_or_error
)
2398 p
= parse_comment(p
);
2399 } else if (ch
== '/') {
2400 p
= parse_line_comment(p
);
2405 if (start_of_line
) {
2410 (tok
== TOK_ELSE
|| tok
== TOK_ELIF
|| tok
== TOK_ENDIF
))
2412 if (tok
== TOK_IF
|| tok
== TOK_IFDEF
|| tok
== TOK_IFNDEF
)
2414 else if (tok
== TOK_ENDIF
)
2416 else if( tok
== TOK_ERROR
|| tok
== TOK_WARNING
)
2417 in_warn_or_error
= 1;
2431 /* ParseState handling */
2433 /* XXX: currently, no include file info is stored. Thus, we cannot display
2434 accurate messages if the function or data definition spans multiple
2437 /* save current parse state in 's' */
2438 void save_parse_state(ParseState
*s
)
2440 s
->line_num
= file
->line_num
;
2441 s
->macro_ptr
= macro_ptr
;
2446 /* restore parse state from 's' */
2447 void restore_parse_state(ParseState
*s
)
2449 file
->line_num
= s
->line_num
;
2450 macro_ptr
= s
->macro_ptr
;
2455 /* return the number of additional 'ints' necessary to store the
2457 static inline int tok_ext_size(int t
)
2471 error("unsupported token");
2478 return LDOUBLE_SIZE
/ 4;
2484 /* token string handling */
2486 static inline void tok_str_new(TokenString
*s
)
2490 s
->allocated_len
= 0;
2491 s
->last_line_num
= -1;
2494 static void tok_str_free(int *str
)
2499 static int *tok_str_realloc(TokenString
*s
)
2503 if (s
->allocated_len
== 0) {
2506 len
= s
->allocated_len
* 2;
2508 str
= tcc_realloc(s
->str
, len
* sizeof(int));
2510 error("memory full");
2511 s
->allocated_len
= len
;
2516 static void tok_str_add(TokenString
*s
, int t
)
2522 if (len
>= s
->allocated_len
)
2523 str
= tok_str_realloc(s
);
2528 static void tok_str_add2(TokenString
*s
, int t
, CValue
*cv
)
2535 /* allocate space for worst case */
2536 if (len
+ TOK_MAX_SIZE
> s
->allocated_len
)
2537 str
= tok_str_realloc(s
);
2546 str
[len
++] = cv
->tab
[0];
2555 nb_words
= (sizeof(CString
) + cv
->cstr
->size
+ 3) >> 2;
2556 while ((len
+ nb_words
) > s
->allocated_len
)
2557 str
= tok_str_realloc(s
);
2558 cstr
= (CString
*)(str
+ len
);
2560 cstr
->size
= cv
->cstr
->size
;
2561 cstr
->data_allocated
= NULL
;
2562 cstr
->size_allocated
= cstr
->size
;
2563 memcpy((char *)cstr
+ sizeof(CString
),
2564 cv
->cstr
->data
, cstr
->size
);
2571 #if LDOUBLE_SIZE == 8
2574 str
[len
++] = cv
->tab
[0];
2575 str
[len
++] = cv
->tab
[1];
2577 #if LDOUBLE_SIZE == 12
2579 str
[len
++] = cv
->tab
[0];
2580 str
[len
++] = cv
->tab
[1];
2581 str
[len
++] = cv
->tab
[2];
2582 #elif LDOUBLE_SIZE == 16
2584 str
[len
++] = cv
->tab
[0];
2585 str
[len
++] = cv
->tab
[1];
2586 str
[len
++] = cv
->tab
[2];
2587 str
[len
++] = cv
->tab
[3];
2588 #elif LDOUBLE_SIZE != 8
2589 #error add long double size support
2598 /* add the current parse token in token string 's' */
2599 static void tok_str_add_tok(TokenString
*s
)
2603 /* save line number info */
2604 if (file
->line_num
!= s
->last_line_num
) {
2605 s
->last_line_num
= file
->line_num
;
2606 cval
.i
= s
->last_line_num
;
2607 tok_str_add2(s
, TOK_LINENUM
, &cval
);
2609 tok_str_add2(s
, tok
, &tokc
);
2612 #if LDOUBLE_SIZE == 16
2613 #define LDOUBLE_GET(p, cv) \
2618 #elif LDOUBLE_SIZE == 12
2619 #define LDOUBLE_GET(p, cv) \
2623 #elif LDOUBLE_SIZE == 8
2624 #define LDOUBLE_GET(p, cv) \
2628 #error add long double size support
2632 /* get a token from an integer array and increment pointer
2633 accordingly. we code it as a macro to avoid pointer aliasing. */
2634 #define TOK_GET(t, p, cv) \
2649 cv.cstr = (CString *)p; \
2650 cv.cstr->data = (char *)p + sizeof(CString);\
2651 p += (sizeof(CString) + cv.cstr->size + 3) >> 2;\
2660 case TOK_CLDOUBLE: \
2661 LDOUBLE_GET(p, cv); \
2662 p += LDOUBLE_SIZE / 4; \
2669 /* defines handling */
2670 static inline void define_push(int v
, int macro_type
, int *str
, Sym
*first_arg
)
2674 s
= sym_push2(&define_stack
, v
, macro_type
, (long)str
);
2675 s
->next
= first_arg
;
2676 table_ident
[v
- TOK_IDENT
]->sym_define
= s
;
2679 /* undefined a define symbol. Its name is just set to zero */
2680 static void define_undef(Sym
*s
)
2684 if (v
>= TOK_IDENT
&& v
< tok_ident
)
2685 table_ident
[v
- TOK_IDENT
]->sym_define
= NULL
;
2689 static inline Sym
*define_find(int v
)
2692 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
2694 return table_ident
[v
]->sym_define
;
2697 /* free define stack until top reaches 'b' */
2698 static void free_defines(Sym
*b
)
2706 /* do not free args or predefined defines */
2708 tok_str_free((int *)top
->c
);
2710 if (v
>= TOK_IDENT
&& v
< tok_ident
)
2711 table_ident
[v
- TOK_IDENT
]->sym_define
= NULL
;
2719 static Sym
*label_find(int v
)
2722 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
2724 return table_ident
[v
]->sym_label
;
2727 static Sym
*label_push(Sym
**ptop
, int v
, int flags
)
2730 s
= sym_push2(ptop
, v
, 0, 0);
2732 ps
= &table_ident
[v
- TOK_IDENT
]->sym_label
;
2733 if (ptop
== &global_label_stack
) {
2734 /* modify the top most local identifier, so that
2735 sym_identifier will point to 's' when popped */
2737 ps
= &(*ps
)->prev_tok
;
2744 /* pop labels until element last is reached. Look if any labels are
2745 undefined. Define symbols if '&&label' was used. */
2746 static void label_pop(Sym
**ptop
, Sym
*slast
)
2749 for(s
= *ptop
; s
!= slast
; s
= s1
) {
2751 if (s
->r
== LABEL_DECLARED
) {
2752 warning("label '%s' declared but not used", get_tok_str(s
->v
, NULL
));
2753 } else if (s
->r
== LABEL_FORWARD
) {
2754 error("label '%s' used but not defined",
2755 get_tok_str(s
->v
, NULL
));
2758 /* define corresponding symbol. A size of
2760 put_extern_sym(s
, cur_text_section
, (long)s
->next
, 1);
2764 table_ident
[s
->v
- TOK_IDENT
]->sym_label
= s
->prev_tok
;
2770 /* eval an expression for #if/#elif */
2771 static int expr_preprocess(void)
2777 while (tok
!= TOK_LINEFEED
&& tok
!= TOK_EOF
) {
2778 next(); /* do macro subst */
2779 if (tok
== TOK_DEFINED
) {
2784 c
= define_find(tok
) != 0;
2789 } else if (tok
>= TOK_IDENT
) {
2790 /* if undefined macro */
2794 tok_str_add_tok(&str
);
2796 tok_str_add(&str
, -1); /* simulate end of file */
2797 tok_str_add(&str
, 0);
2798 /* now evaluate C constant expression */
2799 macro_ptr
= str
.str
;
2803 tok_str_free(str
.str
);
2807 #if defined(PARSE_DEBUG) || defined(PP_DEBUG)
2808 static void tok_print(int *str
)
2814 TOK_GET(t
, str
, cval
);
2817 printf(" %s", get_tok_str(t
, &cval
));
2823 /* parse after #define */
2824 static void parse_define(void)
2826 Sym
*s
, *first
, **ps
;
2827 int v
, t
, varg
, is_vaargs
, c
;
2832 error("invalid macro name '%s'", get_tok_str(tok
, &tokc
));
2833 /* XXX: should check if same macro (ANSI) */
2836 /* '(' must be just after macro definition for MACRO_FUNC */
2837 c
= file
->buf_ptr
[0];
2839 c
= handle_stray1(file
->buf_ptr
);
2844 while (tok
!= ')') {
2848 if (varg
== TOK_DOTS
) {
2849 varg
= TOK___VA_ARGS__
;
2851 } else if (tok
== TOK_DOTS
&& gnu_ext
) {
2855 if (varg
< TOK_IDENT
)
2856 error("badly punctuated parameter list");
2857 s
= sym_push2(&define_stack
, varg
| SYM_FIELD
, is_vaargs
, 0);
2868 /* EOF testing necessary for '-D' handling */
2869 while (tok
!= TOK_LINEFEED
&& tok
!= TOK_EOF
) {
2870 tok_str_add2(&str
, tok
, &tokc
);
2873 tok_str_add(&str
, 0);
2875 printf("define %s %d: ", get_tok_str(v
, NULL
), t
);
2878 define_push(v
, t
, str
.str
, first
);
2881 static inline int hash_cached_include(int type
, const char *filename
)
2883 const unsigned char *s
;
2887 h
= TOK_HASH_FUNC(h
, type
);
2890 h
= TOK_HASH_FUNC(h
, *s
);
2893 h
&= (CACHED_INCLUDES_HASH_SIZE
- 1);
2897 /* XXX: use a token or a hash table to accelerate matching ? */
2898 static CachedInclude
*search_cached_include(TCCState
*s1
,
2899 int type
, const char *filename
)
2903 h
= hash_cached_include(type
, filename
);
2904 i
= s1
->cached_includes_hash
[h
];
2908 e
= s1
->cached_includes
[i
- 1];
2909 if (e
->type
== type
&& !strcmp(e
->filename
, filename
))
2916 static inline void add_cached_include(TCCState
*s1
, int type
,
2917 const char *filename
, int ifndef_macro
)
2922 if (search_cached_include(s1
, type
, filename
))
2925 printf("adding cached '%s' %s\n", filename
, get_tok_str(ifndef_macro
, NULL
));
2927 e
= tcc_malloc(sizeof(CachedInclude
) + strlen(filename
));
2931 strcpy(e
->filename
, filename
);
2932 e
->ifndef_macro
= ifndef_macro
;
2933 dynarray_add((void ***)&s1
->cached_includes
, &s1
->nb_cached_includes
, e
);
2934 /* add in hash table */
2935 h
= hash_cached_include(type
, filename
);
2936 e
->hash_next
= s1
->cached_includes_hash
[h
];
2937 s1
->cached_includes_hash
[h
] = s1
->nb_cached_includes
;
2940 static void pragma_parse(TCCState
*s1
)
2945 if (tok
== TOK_pack
) {
2948 #pragma pack(1) // set
2949 #pragma pack() // reset to default
2950 #pragma pack(push,1) // push & set
2951 #pragma pack(pop) // restore previous
2955 if (tok
== TOK_ASM_pop
) {
2957 if (s1
->pack_stack_ptr
<= s1
->pack_stack
) {
2959 error("out of pack stack");
2961 s1
->pack_stack_ptr
--;
2965 if (tok
== TOK_ASM_push
) {
2967 if (s1
->pack_stack_ptr
>= s1
->pack_stack
+ PACK_STACK_SIZE
- 1)
2969 s1
->pack_stack_ptr
++;
2972 if (tok
!= TOK_CINT
) {
2974 error("invalid pack pragma");
2977 if (val
< 1 || val
> 16 || (val
& (val
- 1)) != 0)
2981 *s1
->pack_stack_ptr
= val
;
2987 /* is_bof is true if first non space token at beginning of file */
2988 static void preprocess(int is_bof
)
2990 TCCState
*s1
= tcc_state
;
2991 int size
, i
, c
, n
, saved_parse_flags
;
2998 saved_parse_flags
= parse_flags
;
2999 parse_flags
= PARSE_FLAG_PREPROCESS
| PARSE_FLAG_TOK_NUM
|
3000 PARSE_FLAG_LINEFEED
;
3010 s
= define_find(tok
);
3011 /* undefine symbol by putting an invalid name */
3016 case TOK_INCLUDE_NEXT
:
3017 ch
= file
->buf_ptr
[0];
3018 /* XXX: incorrect if comments : use next_nomacro with a special mode */
3023 } else if (ch
== '\"') {
3028 while (ch
!= c
&& ch
!= '\n' && ch
!= CH_EOF
) {
3029 if ((q
- buf
) < sizeof(buf
) - 1)
3032 if (handle_stray_noerror() == 0)
3040 /* eat all spaces and comments after include */
3041 /* XXX: slightly incorrect */
3042 while (ch1
!= '\n' && ch1
!= CH_EOF
)
3046 /* computed #include : either we have only strings or
3047 we have anything enclosed in '<>' */
3050 if (tok
== TOK_STR
) {
3051 while (tok
!= TOK_LINEFEED
) {
3052 if (tok
!= TOK_STR
) {
3054 error("'#include' expects \"FILENAME\" or <FILENAME>");
3056 pstrcat(buf
, sizeof(buf
), (char *)tokc
.cstr
->data
);
3062 while (tok
!= TOK_LINEFEED
) {
3063 pstrcat(buf
, sizeof(buf
), get_tok_str(tok
, &tokc
));
3067 /* check syntax and remove '<>' */
3068 if (len
< 2 || buf
[0] != '<' || buf
[len
- 1] != '>')
3069 goto include_syntax
;
3070 memmove(buf
, buf
+ 1, len
- 2);
3071 buf
[len
- 2] = '\0';
3076 e
= search_cached_include(s1
, c
, buf
);
3077 if (e
&& define_find(e
->ifndef_macro
)) {
3078 /* no need to parse the include because the 'ifndef macro'
3081 printf("%s: skipping %s\n", file
->filename
, buf
);
3084 if (s1
->include_stack_ptr
>= s1
->include_stack
+ INCLUDE_STACK_SIZE
)
3085 error("#include recursion too deep");
3086 /* push current file in stack */
3087 /* XXX: fix current line init */
3088 *s1
->include_stack_ptr
++ = file
;
3090 /* first search in current dir if "header.h" */
3091 size
= tcc_basename(file
->filename
) - file
->filename
;
3092 if (size
> sizeof(buf1
) - 1)
3093 size
= sizeof(buf1
) - 1;
3094 memcpy(buf1
, file
->filename
, size
);
3096 pstrcat(buf1
, sizeof(buf1
), buf
);
3097 f
= tcc_open(s1
, buf1
);
3099 if (tok
== TOK_INCLUDE_NEXT
)
3105 /* now search in all the include paths */
3106 n
= s1
->nb_include_paths
+ s1
->nb_sysinclude_paths
;
3107 for(i
= 0; i
< n
; i
++) {
3109 if (i
< s1
->nb_include_paths
)
3110 path
= s1
->include_paths
[i
];
3112 path
= s1
->sysinclude_paths
[i
- s1
->nb_include_paths
];
3113 pstrcpy(buf1
, sizeof(buf1
), path
);
3114 pstrcat(buf1
, sizeof(buf1
), "/");
3115 pstrcat(buf1
, sizeof(buf1
), buf
);
3116 f
= tcc_open(s1
, buf1
);
3118 if (tok
== TOK_INCLUDE_NEXT
)
3124 --s1
->include_stack_ptr
;
3125 error("include file '%s' not found", buf
);
3129 printf("%s: including %s\n", file
->filename
, buf1
);
3132 pstrcpy(f
->inc_filename
, sizeof(f
->inc_filename
), buf
);
3134 /* add include file debug info */
3136 put_stabs(file
->filename
, N_BINCL
, 0, 0, 0);
3138 tok_flags
|= TOK_FLAG_BOF
| TOK_FLAG_BOL
;
3139 ch
= file
->buf_ptr
[0];
3147 c
= expr_preprocess();
3153 if (tok
< TOK_IDENT
)
3154 error("invalid argument for '#if%sdef'", c
? "n" : "");
3158 printf("#ifndef %s\n", get_tok_str(tok
, NULL
));
3160 file
->ifndef_macro
= tok
;
3163 c
= (define_find(tok
) != 0) ^ c
;
3165 if (s1
->ifdef_stack_ptr
>= s1
->ifdef_stack
+ IFDEF_STACK_SIZE
)
3166 error("memory full");
3167 *s1
->ifdef_stack_ptr
++ = c
;
3170 if (s1
->ifdef_stack_ptr
== s1
->ifdef_stack
)
3171 error("#else without matching #if");
3172 if (s1
->ifdef_stack_ptr
[-1] & 2)
3173 error("#else after #else");
3174 c
= (s1
->ifdef_stack_ptr
[-1] ^= 3);
3177 if (s1
->ifdef_stack_ptr
== s1
->ifdef_stack
)
3178 error("#elif without matching #if");
3179 c
= s1
->ifdef_stack_ptr
[-1];
3181 error("#elif after #else");
3182 /* last #if/#elif expression was true: we skip */
3185 c
= expr_preprocess();
3186 s1
->ifdef_stack_ptr
[-1] = c
;
3196 if (s1
->ifdef_stack_ptr
<= file
->ifdef_stack_ptr
)
3197 error("#endif without matching #if");
3198 s1
->ifdef_stack_ptr
--;
3199 /* '#ifndef macro' was at the start of file. Now we check if
3200 an '#endif' is exactly at the end of file */
3201 if (file
->ifndef_macro
&&
3202 s1
->ifdef_stack_ptr
== file
->ifdef_stack_ptr
) {
3203 file
->ifndef_macro_saved
= file
->ifndef_macro
;
3204 /* need to set to zero to avoid false matches if another
3205 #ifndef at middle of file */
3206 file
->ifndef_macro
= 0;
3207 while (tok
!= TOK_LINEFEED
)
3209 tok_flags
|= TOK_FLAG_ENDIF
;
3215 if (tok
!= TOK_CINT
)
3217 file
->line_num
= tokc
.i
- 1; /* the line number will be incremented after */
3219 if (tok
!= TOK_LINEFEED
) {
3222 pstrcpy(file
->filename
, sizeof(file
->filename
),
3223 (char *)tokc
.cstr
->data
);
3229 ch
= file
->buf_ptr
[0];
3232 while (ch
!= '\n' && ch
!= CH_EOF
) {
3233 if ((q
- buf
) < sizeof(buf
) - 1)
3236 if (handle_stray_noerror() == 0)
3243 error("#error %s", buf
);
3245 warning("#warning %s", buf
);
3251 if (tok
== TOK_LINEFEED
|| tok
== '!' || tok
== TOK_CINT
) {
3252 /* '!' is ignored to allow C scripts. numbers are ignored
3253 to emulate cpp behaviour */
3255 if (!(saved_parse_flags
& PARSE_FLAG_ASM_COMMENTS
))
3256 warning("Ignoring unknown preprocessing directive #%s", get_tok_str(tok
, &tokc
));
3260 /* ignore other preprocess commands or #! for C scripts */
3261 while (tok
!= TOK_LINEFEED
)
3264 parse_flags
= saved_parse_flags
;
3267 /* evaluate escape codes in a string. */
3268 static void parse_escape_string(CString
*outstr
, const uint8_t *buf
, int is_long
)
3283 case '0': case '1': case '2': case '3':
3284 case '4': case '5': case '6': case '7':
3285 /* at most three octal digits */
3290 n
= n
* 8 + c
- '0';
3294 n
= n
* 8 + c
- '0';
3299 goto add_char_nonext
;
3307 if (c
>= 'a' && c
<= 'f')
3309 else if (c
>= 'A' && c
<= 'F')
3319 goto add_char_nonext
;
3343 goto invalid_escape
;
3353 if (c
>= '!' && c
<= '~')
3354 warning("unknown escape sequence: \'\\%c\'", c
);
3356 warning("unknown escape sequence: \'\\x%x\'", c
);
3363 cstr_ccat(outstr
, c
);
3365 cstr_wccat(outstr
, c
);
3367 /* add a trailing '\0' */
3369 cstr_ccat(outstr
, '\0');
3371 cstr_wccat(outstr
, '\0');
3374 /* we use 64 bit numbers */
3377 /* bn = (bn << shift) | or_val */
3378 void bn_lshift(unsigned int *bn
, int shift
, int or_val
)
3382 for(i
=0;i
<BN_SIZE
;i
++) {
3384 bn
[i
] = (v
<< shift
) | or_val
;
3385 or_val
= v
>> (32 - shift
);
3389 void bn_zero(unsigned int *bn
)
3392 for(i
=0;i
<BN_SIZE
;i
++) {
3397 /* parse number in null terminated string 'p' and return it in the
3399 void parse_number(const char *p
)
3401 int b
, t
, shift
, frac_bits
, s
, exp_val
, ch
;
3403 unsigned int bn
[BN_SIZE
];
3414 goto float_frac_parse
;
3415 } else if (t
== '0') {
3416 if (ch
== 'x' || ch
== 'X') {
3420 } else if (tcc_ext
&& (ch
== 'b' || ch
== 'B')) {
3426 /* parse all digits. cannot check octal numbers at this stage
3427 because of floating point constants */
3429 if (ch
>= 'a' && ch
<= 'f')
3431 else if (ch
>= 'A' && ch
<= 'F')
3439 if (q
>= token_buf
+ STRING_MAX_SIZE
) {
3441 error("number too long");
3447 ((ch
== 'e' || ch
== 'E') && b
== 10) ||
3448 ((ch
== 'p' || ch
== 'P') && (b
== 16 || b
== 2))) {
3450 /* NOTE: strtox should support that for hexa numbers, but
3451 non ISOC99 libcs do not support it, so we prefer to do
3453 /* hexadecimal or binary floats */
3454 /* XXX: handle overflows */
3466 } else if (t
>= 'a') {
3468 } else if (t
>= 'A') {
3473 bn_lshift(bn
, shift
, t
);
3480 if (t
>= 'a' && t
<= 'f') {
3482 } else if (t
>= 'A' && t
<= 'F') {
3484 } else if (t
>= '0' && t
<= '9') {
3490 error("invalid digit");
3491 bn_lshift(bn
, shift
, t
);
3496 if (ch
!= 'p' && ch
!= 'P')
3503 } else if (ch
== '-') {
3507 if (ch
< '0' || ch
> '9')
3508 expect("exponent digits");
3509 while (ch
>= '0' && ch
<= '9') {
3510 exp_val
= exp_val
* 10 + ch
- '0';
3513 exp_val
= exp_val
* s
;
3515 /* now we can generate the number */
3516 /* XXX: should patch directly float number */
3517 d
= (double)bn
[1] * 4294967296.0 + (double)bn
[0];
3518 d
= ldexp(d
, exp_val
- frac_bits
);
3523 /* float : should handle overflow */
3525 } else if (t
== 'L') {
3528 /* XXX: not large enough */
3529 tokc
.ld
= (long double)d
;
3535 /* decimal floats */
3537 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3542 while (ch
>= '0' && ch
<= '9') {
3543 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3549 if (ch
== 'e' || ch
== 'E') {
3550 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3554 if (ch
== '-' || ch
== '+') {
3555 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3560 if (ch
< '0' || ch
> '9')
3561 expect("exponent digits");
3562 while (ch
>= '0' && ch
<= '9') {
3563 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3575 tokc
.f
= strtof(token_buf
, NULL
);
3576 } else if (t
== 'L') {
3579 tokc
.ld
= strtold(token_buf
, NULL
);
3582 tokc
.d
= strtod(token_buf
, NULL
);
3586 unsigned long long n
, n1
;
3589 /* integer number */
3592 if (b
== 10 && *q
== '0') {
3599 /* no need for checks except for base 10 / 8 errors */
3602 } else if (t
>= 'a') {
3604 } else if (t
>= 'A') {
3609 error("invalid digit");
3613 /* detect overflow */
3614 /* XXX: this test is not reliable */
3616 error("integer constant overflow");
3619 /* XXX: not exactly ANSI compliant */
3620 if ((n
& 0xffffffff00000000LL
) != 0) {
3625 } else if (n
> 0x7fffffff) {
3636 error("three 'l's in integer constant");
3639 if (tok
== TOK_CINT
)
3641 else if (tok
== TOK_CUINT
)
3645 } else if (t
== 'U') {
3647 error("two 'u's in integer constant");
3649 if (tok
== TOK_CINT
)
3651 else if (tok
== TOK_CLLONG
)
3658 if (tok
== TOK_CINT
|| tok
== TOK_CUINT
)
3664 error("invalid number\n");
3668 #define PARSE2(c1, tok1, c2, tok2) \
3679 /* return next token without macro substitution */
3680 static inline void next_nomacro1(void)
3687 cstr_reset(&tok_spaces
);
3697 cstr_ccat(&tok_spaces
, c
);
3702 /* first look if it is in fact an end of buffer */
3703 if (p
>= file
->buf_end
) {
3707 if (p
>= file
->buf_end
)
3720 TCCState
*s1
= tcc_state
;
3721 if ((parse_flags
& PARSE_FLAG_LINEFEED
)
3722 && !(tok_flags
& TOK_FLAG_EOF
)) {
3723 tok_flags
|= TOK_FLAG_EOF
;
3725 goto keep_tok_flags
;
3726 } else if (s1
->include_stack_ptr
== s1
->include_stack
||
3727 !(parse_flags
& PARSE_FLAG_PREPROCESS
)) {
3728 /* no include left : end of file. */
3731 tok_flags
&= ~TOK_FLAG_EOF
;
3732 /* pop include file */
3734 /* test if previous '#endif' was after a #ifdef at
3736 if (tok_flags
& TOK_FLAG_ENDIF
) {
3738 printf("#endif %s\n", get_tok_str(file
->ifndef_macro_saved
, NULL
));
3740 add_cached_include(s1
, file
->inc_type
, file
->inc_filename
,
3741 file
->ifndef_macro_saved
);
3744 /* add end of include file debug info */
3746 put_stabd(N_EINCL
, 0, 0);
3748 /* pop include stack */
3750 s1
->include_stack_ptr
--;
3751 file
= *s1
->include_stack_ptr
;
3760 tok_flags
|= TOK_FLAG_BOL
;
3762 if (0 == (parse_flags
& PARSE_FLAG_LINEFEED
))
3765 goto keep_tok_flags
;
3770 if ((tok_flags
& TOK_FLAG_BOL
) &&
3771 (parse_flags
& PARSE_FLAG_PREPROCESS
)) {
3773 preprocess(tok_flags
& TOK_FLAG_BOF
);
3779 tok
= TOK_TWOSHARPS
;
3781 if (parse_flags
& PARSE_FLAG_ASM_COMMENTS
) {
3782 p
= parse_line_comment(p
- 1);
3791 case 'a': case 'b': case 'c': case 'd':
3792 case 'e': case 'f': case 'g': case 'h':
3793 case 'i': case 'j': case 'k': case 'l':
3794 case 'm': case 'n': case 'o': case 'p':
3795 case 'q': case 'r': case 's': case 't':
3796 case 'u': case 'v': case 'w': case 'x':
3798 case 'A': case 'B': case 'C': case 'D':
3799 case 'E': case 'F': case 'G': case 'H':
3800 case 'I': case 'J': case 'K':
3801 case 'M': case 'N': case 'O': case 'P':
3802 case 'Q': case 'R': case 'S': case 'T':
3803 case 'U': case 'V': case 'W': case 'X':
3809 h
= TOK_HASH_FUNC(h
, c
);
3813 if (!isidnum_table
[c
-CH_EOF
])
3815 h
= TOK_HASH_FUNC(h
, c
);
3822 /* fast case : no stray found, so we have the full token
3823 and we have already hashed it */
3825 h
&= (TOK_HASH_SIZE
- 1);
3826 pts
= &hash_ident
[h
];
3831 if (ts
->len
== len
&& !memcmp(ts
->str
, p1
, len
))
3833 pts
= &(ts
->hash_next
);
3835 ts
= tok_alloc_new(pts
, p1
, len
);
3839 cstr_reset(&tokcstr
);
3842 cstr_ccat(&tokcstr
, *p1
);
3848 while (isidnum_table
[c
-CH_EOF
]) {
3849 cstr_ccat(&tokcstr
, c
);
3852 ts
= tok_alloc(tokcstr
.data
, tokcstr
.size
);
3858 if (t
!= '\\' && t
!= '\'' && t
!= '\"') {
3860 goto parse_ident_fast
;
3863 if (c
== '\'' || c
== '\"') {
3867 cstr_reset(&tokcstr
);
3868 cstr_ccat(&tokcstr
, 'L');
3869 goto parse_ident_slow
;
3873 case '0': case '1': case '2': case '3':
3874 case '4': case '5': case '6': case '7':
3877 cstr_reset(&tokcstr
);
3878 /* after the first digit, accept digits, alpha, '.' or sign if
3879 prefixed by 'eEpP' */
3883 cstr_ccat(&tokcstr
, c
);
3885 if (!(isnum(c
) || isid(c
) || c
== '.' ||
3886 ((c
== '+' || c
== '-') &&
3887 (t
== 'e' || t
== 'E' || t
== 'p' || t
== 'P'))))
3890 /* We add a trailing '\0' to ease parsing */
3891 cstr_ccat(&tokcstr
, '\0');
3892 tokc
.cstr
= &tokcstr
;
3896 /* special dot handling because it can also start a number */
3899 cstr_reset(&tokcstr
);
3900 cstr_ccat(&tokcstr
, '.');
3902 } else if (c
== '.') {
3922 /* parse the string */
3924 p
= parse_pp_string(p
, sep
, &str
);
3925 cstr_ccat(&str
, '\0');
3927 /* eval the escape (should be done as TOK_PPNUM) */
3928 cstr_reset(&tokcstr
);
3929 parse_escape_string(&tokcstr
, str
.data
, is_long
);
3934 /* XXX: make it portable */
3938 char_size
= sizeof(nwchar_t
);
3939 if (tokcstr
.size
<= char_size
)
3940 error("empty character constant");
3941 if (tokcstr
.size
> 2 * char_size
)
3942 warning("multi-character character constant");
3944 tokc
.i
= *(int8_t *)tokcstr
.data
;
3947 tokc
.i
= *(nwchar_t
*)tokcstr
.data
;
3951 tokc
.cstr
= &tokcstr
;
3965 } else if (c
== '<') {
3983 } else if (c
== '>') {
4001 } else if (c
== '=') {
4014 } else if (c
== '=') {
4027 } else if (c
== '=') {
4040 } else if (c
== '=') {
4043 } else if (c
== '>') {
4051 PARSE2('!', '!', '=', TOK_NE
)
4052 PARSE2('=', '=', '=', TOK_EQ
)
4053 PARSE2('*', '*', '=', TOK_A_MUL
)
4054 PARSE2('%', '%', '=', TOK_A_MOD
)
4055 PARSE2('^', '^', '=', TOK_A_XOR
)
4057 /* comments or operator */
4061 p
= parse_comment(p
);
4063 } else if (c
== '/') {
4064 p
= parse_line_comment(p
);
4066 } else if (c
== '=') {
4086 case '$': /* only used in assembler */
4087 case '@': /* dito */
4092 error("unrecognized character \\x%02x", c
);
4098 #if defined(PARSE_DEBUG)
4099 printf("token = %s\n", get_tok_str(tok
, &tokc
));
4103 /* return next token without macro substitution. Can read input from
4105 static void next_nomacro(void)
4111 TOK_GET(tok
, macro_ptr
, tokc
);
4112 if (tok
== TOK_LINENUM
) {
4113 file
->line_num
= tokc
.i
;
4122 /* substitute args in macro_str and return allocated string */
4123 static int *macro_arg_subst(Sym
**nested_list
, int *macro_str
, Sym
*args
)
4125 int *st
, last_tok
, t
, notfirst
;
4134 TOK_GET(t
, macro_str
, cval
);
4139 TOK_GET(t
, macro_str
, cval
);
4142 s
= sym_find2(args
, t
);
4149 cstr_ccat(&cstr
, ' ');
4150 TOK_GET(t
, st
, cval
);
4151 cstr_cat(&cstr
, get_tok_str(t
, &cval
));
4156 cstr_ccat(&cstr
, '\0');
4158 printf("stringize: %s\n", (char *)cstr
.data
);
4162 tok_str_add2(&str
, TOK_STR
, &cval
);
4165 tok_str_add2(&str
, t
, &cval
);
4167 } else if (t
>= TOK_IDENT
) {
4168 s
= sym_find2(args
, t
);
4171 /* if '##' is present before or after, no arg substitution */
4172 if (*macro_str
== TOK_TWOSHARPS
|| last_tok
== TOK_TWOSHARPS
) {
4173 /* special case for var arg macros : ## eats the
4174 ',' if empty VA_ARGS variable. */
4175 /* XXX: test of the ',' is not 100%
4176 reliable. should fix it to avoid security
4178 if (gnu_ext
&& s
->type
.t
&&
4179 last_tok
== TOK_TWOSHARPS
&&
4180 str
.len
>= 2 && str
.str
[str
.len
- 2] == ',') {
4182 /* suppress ',' '##' */
4185 /* suppress '##' and add variable */
4193 TOK_GET(t1
, st
, cval
);
4196 tok_str_add2(&str
, t1
, &cval
);
4200 /* NOTE: the stream cannot be read when macro
4201 substituing an argument */
4202 macro_subst(&str
, nested_list
, st
, NULL
);
4205 tok_str_add(&str
, t
);
4208 tok_str_add2(&str
, t
, &cval
);
4212 tok_str_add(&str
, 0);
4216 static char const ab_month_name
[12][4] =
4218 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
4219 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
4222 /* do macro substitution of current token with macro 's' and add
4223 result to (tok_str,tok_len). 'nested_list' is the list of all
4224 macros we got inside to avoid recursing. Return non zero if no
4225 substitution needs to be done */
4226 static int macro_subst_tok(TokenString
*tok_str
,
4227 Sym
**nested_list
, Sym
*s
, struct macro_level
**can_read_stream
)
4229 Sym
*args
, *sa
, *sa1
;
4230 int mstr_allocated
, parlevel
, *mstr
, t
, t1
;
4237 /* if symbol is a macro, prepare substitution */
4238 /* special macros */
4239 if (tok
== TOK___LINE__
) {
4240 snprintf(buf
, sizeof(buf
), "%d", file
->line_num
);
4244 } else if (tok
== TOK___FILE__
) {
4245 cstrval
= file
->filename
;
4247 } else if (tok
== TOK___DATE__
|| tok
== TOK___TIME__
) {
4252 tm
= localtime(&ti
);
4253 if (tok
== TOK___DATE__
) {
4254 snprintf(buf
, sizeof(buf
), "%s %2d %d",
4255 ab_month_name
[tm
->tm_mon
], tm
->tm_mday
, tm
->tm_year
+ 1900);
4257 snprintf(buf
, sizeof(buf
), "%02d:%02d:%02d",
4258 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
4265 cstr_cat(&cstr
, cstrval
);
4266 cstr_ccat(&cstr
, '\0');
4268 tok_str_add2(tok_str
, t1
, &cval
);
4273 if (s
->type
.t
== MACRO_FUNC
) {
4274 /* NOTE: we do not use next_nomacro to avoid eating the
4275 next token. XXX: find better solution */
4279 if (t
== 0 && can_read_stream
) {
4280 /* end of macro stream: we must look at the token
4281 after in the file */
4282 struct macro_level
*ml
= *can_read_stream
;
4288 *can_read_stream
= ml
-> prev
;
4293 /* XXX: incorrect with comments */
4294 ch
= file
->buf_ptr
[0];
4295 while (is_space(ch
) || ch
== '\n')
4299 if (t
!= '(') /* no macro subst */
4302 /* argument macro */
4307 /* NOTE: empty args are allowed, except if no args */
4309 /* handle '()' case */
4310 if (!args
&& !sa
&& tok
== ')')
4313 error("macro '%s' used with too many args",
4314 get_tok_str(s
->v
, 0));
4317 /* NOTE: non zero sa->t indicates VA_ARGS */
4318 while ((parlevel
> 0 ||
4320 (tok
!= ',' || sa
->type
.t
))) &&
4324 else if (tok
== ')')
4326 if (tok
!= TOK_LINEFEED
)
4327 tok_str_add2(&str
, tok
, &tokc
);
4330 tok_str_add(&str
, 0);
4331 sym_push2(&args
, sa
->v
& ~SYM_FIELD
, sa
->type
.t
, (long)str
.str
);
4334 /* special case for gcc var args: add an empty
4335 var arg argument if it is omitted */
4336 if (sa
&& sa
->type
.t
&& gnu_ext
)
4346 error("macro '%s' used with too few args",
4347 get_tok_str(s
->v
, 0));
4350 /* now subst each arg */
4351 mstr
= macro_arg_subst(nested_list
, mstr
, args
);
4356 tok_str_free((int *)sa
->c
);
4362 sym_push2(nested_list
, s
->v
, 0, 0);
4363 macro_subst(tok_str
, nested_list
, mstr
, can_read_stream
);
4364 /* pop nested defined symbol */
4366 *nested_list
= sa1
->prev
;
4374 /* handle the '##' operator. Return NULL if no '##' seen. Otherwise
4375 return the resulting string (which must be freed). */
4376 static inline int *macro_twosharps(const int *macro_str
)
4379 const int *macro_ptr1
, *start_macro_ptr
, *ptr
, *saved_macro_ptr
;
4381 const char *p1
, *p2
;
4383 TokenString macro_str1
;
4386 start_macro_ptr
= macro_str
;
4387 /* we search the first '##' */
4389 macro_ptr1
= macro_str
;
4390 TOK_GET(t
, macro_str
, cval
);
4391 /* nothing more to do if end of string */
4394 if (*macro_str
== TOK_TWOSHARPS
)
4398 /* we saw '##', so we need more processing to handle it */
4400 tok_str_new(¯o_str1
);
4404 /* add all tokens seen so far */
4405 for(ptr
= start_macro_ptr
; ptr
< macro_ptr1
;) {
4406 TOK_GET(t
, ptr
, cval
);
4407 tok_str_add2(¯o_str1
, t
, &cval
);
4409 saved_macro_ptr
= macro_ptr
;
4410 /* XXX: get rid of the use of macro_ptr here */
4411 macro_ptr
= (int *)macro_str
;
4413 while (*macro_ptr
== TOK_TWOSHARPS
) {
4415 macro_ptr1
= macro_ptr
;
4418 TOK_GET(t
, macro_ptr
, cval
);
4419 /* We concatenate the two tokens if we have an
4420 identifier or a preprocessing number */
4422 p1
= get_tok_str(tok
, &tokc
);
4423 cstr_cat(&cstr
, p1
);
4424 p2
= get_tok_str(t
, &cval
);
4425 cstr_cat(&cstr
, p2
);
4426 cstr_ccat(&cstr
, '\0');
4428 if ((tok
>= TOK_IDENT
|| tok
== TOK_PPNUM
) &&
4429 (t
>= TOK_IDENT
|| t
== TOK_PPNUM
)) {
4430 if (tok
== TOK_PPNUM
) {
4431 /* if number, then create a number token */
4432 /* NOTE: no need to allocate because
4433 tok_str_add2() does it */
4434 cstr_reset(&tokcstr
);
4437 tokc
.cstr
= &tokcstr
;
4439 /* if identifier, we must do a test to
4440 validate we have a correct identifier */
4441 if (t
== TOK_PPNUM
) {
4451 if (!isnum(c
) && !isid(c
))
4455 ts
= tok_alloc(cstr
.data
, strlen(cstr
.data
));
4456 tok
= ts
->tok
; /* modify current token */
4459 const char *str
= cstr
.data
;
4460 const unsigned char *q
;
4462 /* we look for a valid token */
4463 /* XXX: do more extensive checks */
4464 if (!strcmp(str
, ">>=")) {
4466 } else if (!strcmp(str
, "<<=")) {
4468 } else if (strlen(str
) == 2) {
4469 /* search in two bytes table */
4474 if (q
[0] == str
[0] && q
[1] == str
[1])
4481 /* NOTE: because get_tok_str use a static buffer,
4484 p1
= get_tok_str(tok
, &tokc
);
4485 cstr_cat(&cstr
, p1
);
4486 cstr_ccat(&cstr
, '\0');
4487 p2
= get_tok_str(t
, &cval
);
4488 warning("pasting \"%s\" and \"%s\" does not give a valid preprocessing token", cstr
.data
, p2
);
4489 /* cannot merge tokens: just add them separately */
4490 tok_str_add2(¯o_str1
, tok
, &tokc
);
4491 /* XXX: free associated memory ? */
4498 tok_str_add2(¯o_str1
, tok
, &tokc
);
4503 macro_ptr
= (int *)saved_macro_ptr
;
4505 tok_str_add(¯o_str1
, 0);
4506 return macro_str1
.str
;
4510 /* do macro substitution of macro_str and add result to
4511 (tok_str,tok_len). 'nested_list' is the list of all macros we got
4512 inside to avoid recursing. */
4513 static void macro_subst(TokenString
*tok_str
, Sym
**nested_list
,
4514 const int *macro_str
, struct macro_level
** can_read_stream
)
4521 struct macro_level ml
;
4523 /* first scan for '##' operator handling */
4525 macro_str1
= macro_twosharps(ptr
);
4529 /* NOTE: ptr == NULL can only happen if tokens are read from
4530 file stream due to a macro function call */
4533 TOK_GET(t
, ptr
, cval
);
4538 /* if nested substitution, do nothing */
4539 if (sym_find2(*nested_list
, t
))
4542 if (can_read_stream
)
4543 ml
.prev
= *can_read_stream
, *can_read_stream
= &ml
;
4544 macro_ptr
= (int *)ptr
;
4546 ret
= macro_subst_tok(tok_str
, nested_list
, s
, can_read_stream
);
4547 ptr
= (int *)macro_ptr
;
4549 if (can_read_stream
&& *can_read_stream
== &ml
)
4550 *can_read_stream
= ml
.prev
;
4555 tok_str_add2(tok_str
, t
, &cval
);
4559 tok_str_free(macro_str1
);
4562 /* return next token with macro substitution */
4563 static void next(void)
4565 Sym
*nested_list
, *s
;
4567 struct macro_level
*ml
;
4572 /* if not reading from macro substituted string, then try
4573 to substitute macros */
4574 if (tok
>= TOK_IDENT
&&
4575 (parse_flags
& PARSE_FLAG_PREPROCESS
)) {
4576 s
= define_find(tok
);
4578 /* we have a macro: we try to substitute */
4582 if (macro_subst_tok(&str
, &nested_list
, s
, &ml
) == 0) {
4583 /* substitution done, NOTE: maybe empty */
4584 tok_str_add(&str
, 0);
4585 macro_ptr
= str
.str
;
4586 macro_ptr_allocated
= str
.str
;
4593 /* end of macro or end of unget buffer */
4594 if (unget_buffer_enabled
) {
4595 macro_ptr
= unget_saved_macro_ptr
;
4596 unget_buffer_enabled
= 0;
4598 /* end of macro string: free it */
4599 tok_str_free(macro_ptr_allocated
);
4606 /* convert preprocessor tokens into C tokens */
4607 if (tok
== TOK_PPNUM
&&
4608 (parse_flags
& PARSE_FLAG_TOK_NUM
)) {
4609 parse_number((char *)tokc
.cstr
->data
);
4613 /* push back current token and set current token to 'last_tok'. Only
4614 identifier case handled for labels. */
4615 static inline void unget_tok(int last_tok
)
4619 unget_saved_macro_ptr
= macro_ptr
;
4620 unget_buffer_enabled
= 1;
4621 q
= unget_saved_buffer
;
4624 n
= tok_ext_size(tok
) - 1;
4627 *q
= 0; /* end of token string */
4632 void swap(int *p
, int *q
)
4640 void vsetc(CType
*type
, int r
, CValue
*vc
)
4644 if (vtop
>= vstack
+ (VSTACK_SIZE
- 1))
4645 error("memory full");
4646 /* cannot let cpu flags if other instruction are generated. Also
4647 avoid leaving VT_JMP anywhere except on the top of the stack
4648 because it would complicate the code generator. */
4649 if (vtop
>= vstack
) {
4650 v
= vtop
->r
& VT_VALMASK
;
4651 if (v
== VT_CMP
|| (v
& ~1) == VT_JMP
)
4657 vtop
->r2
= VT_CONST
;
4661 /* push integer constant */
4666 vsetc(&int_type
, VT_CONST
, &cval
);
4669 /* push long long constant */
4670 void vpushll(long long v
)
4676 vsetc(&ctype
, VT_CONST
, &cval
);
4679 /* Return a static symbol pointing to a section */
4680 static Sym
*get_sym_ref(CType
*type
, Section
*sec
,
4681 unsigned long offset
, unsigned long size
)
4687 sym
= global_identifier_push(v
, type
->t
| VT_STATIC
, 0);
4688 sym
->type
.ref
= type
->ref
;
4689 sym
->r
= VT_CONST
| VT_SYM
;
4690 put_extern_sym(sym
, sec
, offset
, size
);
4694 /* push a reference to a section offset by adding a dummy symbol */
4695 static void vpush_ref(CType
*type
, Section
*sec
, unsigned long offset
, unsigned long size
)
4700 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
4701 vtop
->sym
= get_sym_ref(type
, sec
, offset
, size
);
4704 /* define a new external reference to a symbol 'v' of type 'u' */
4705 static Sym
*external_global_sym(int v
, CType
*type
, int r
)
4711 /* push forward reference */
4712 s
= global_identifier_push(v
, type
->t
| VT_EXTERN
, 0);
4713 s
->type
.ref
= type
->ref
;
4714 s
->r
= r
| VT_CONST
| VT_SYM
;
4719 /* define a new external reference to a symbol 'v' of type 'u' */
4720 static Sym
*external_sym(int v
, CType
*type
, int r
)
4726 /* push forward reference */
4727 s
= sym_push(v
, type
, r
| VT_CONST
| VT_SYM
, 0);
4728 s
->type
.t
|= VT_EXTERN
;
4730 if (!is_compatible_types(&s
->type
, type
))
4731 error("incompatible types for redefinition of '%s'",
4732 get_tok_str(v
, NULL
));
4737 /* push a reference to global symbol v */
4738 static void vpush_global_sym(CType
*type
, int v
)
4743 sym
= external_global_sym(v
, type
, 0);
4745 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
4749 void vset(CType
*type
, int r
, int v
)
4754 vsetc(type
, r
, &cval
);
4757 void vseti(int r
, int v
)
4773 void vpushv(SValue
*v
)
4775 if (vtop
>= vstack
+ (VSTACK_SIZE
- 1))
4776 error("memory full");
4786 /* save r to the memory stack, and mark it as being free */
4787 void save_reg(int r
)
4789 int l
, saved
, size
, align
;
4793 /* modify all stack values */
4796 for(p
=vstack
;p
<=vtop
;p
++) {
4797 if ((p
->r
& VT_VALMASK
) == r
||
4798 ((p
->type
.t
& VT_BTYPE
) == VT_LLONG
&& (p
->r2
& VT_VALMASK
) == r
)) {
4799 /* must save value on stack if not already done */
4801 /* NOTE: must reload 'r' because r might be equal to r2 */
4802 r
= p
->r
& VT_VALMASK
;
4803 /* store register in the stack */
4805 if ((p
->r
& VT_LVAL
) ||
4806 (!is_float(type
->t
) && (type
->t
& VT_BTYPE
) != VT_LLONG
))
4807 #ifdef TCC_TARGET_X86_64
4808 type
= &char_pointer_type
;
4812 size
= type_size(type
, &align
);
4813 loc
= (loc
- size
) & -align
;
4814 sv
.type
.t
= type
->t
;
4815 sv
.r
= VT_LOCAL
| VT_LVAL
;
4818 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
4819 /* x86 specific: need to pop fp register ST0 if saved */
4820 if (r
== TREG_ST0
) {
4821 o(0xd9dd); /* fstp %st(1) */
4824 #ifndef TCC_TARGET_X86_64
4825 /* special long long case */
4826 if ((type
->t
& VT_BTYPE
) == VT_LLONG
) {
4834 /* mark that stack entry as being saved on the stack */
4835 if (p
->r
& VT_LVAL
) {
4836 /* also clear the bounded flag because the
4837 relocation address of the function was stored in
4839 p
->r
= (p
->r
& ~(VT_VALMASK
| VT_BOUNDED
)) | VT_LLOCAL
;
4841 p
->r
= lvalue_type(p
->type
.t
) | VT_LOCAL
;
4849 /* find a register of class 'rc2' with at most one reference on stack.
4850 * If none, call get_reg(rc) */
4851 int get_reg_ex(int rc
, int rc2
)
4856 for(r
=0;r
<NB_REGS
;r
++) {
4857 if (reg_classes
[r
] & rc2
) {
4860 for(p
= vstack
; p
<= vtop
; p
++) {
4861 if ((p
->r
& VT_VALMASK
) == r
||
4862 (p
->r2
& VT_VALMASK
) == r
)
4872 /* find a free register of class 'rc'. If none, save one register */
4878 /* find a free register */
4879 for(r
=0;r
<NB_REGS
;r
++) {
4880 if (reg_classes
[r
] & rc
) {
4881 for(p
=vstack
;p
<=vtop
;p
++) {
4882 if ((p
->r
& VT_VALMASK
) == r
||
4883 (p
->r2
& VT_VALMASK
) == r
)
4891 /* no register left : free the first one on the stack (VERY
4892 IMPORTANT to start from the bottom to ensure that we don't
4893 spill registers used in gen_opi()) */
4894 for(p
=vstack
;p
<=vtop
;p
++) {
4895 r
= p
->r
& VT_VALMASK
;
4896 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
))
4898 /* also look at second register (if long long) */
4899 r
= p
->r2
& VT_VALMASK
;
4900 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
)) {
4906 /* Should never comes here */
4910 /* save registers up to (vtop - n) stack entry */
4911 void save_regs(int n
)
4916 for(p
= vstack
;p
<= p1
; p
++) {
4917 r
= p
->r
& VT_VALMASK
;
4924 /* move register 's' to 'r', and flush previous value of r to memory
4926 void move_reg(int r
, int s
)
4939 /* get address of vtop (vtop MUST BE an lvalue) */
4942 vtop
->r
&= ~VT_LVAL
;
4943 /* tricky: if saved lvalue, then we can go back to lvalue */
4944 if ((vtop
->r
& VT_VALMASK
) == VT_LLOCAL
)
4945 vtop
->r
= (vtop
->r
& ~(VT_VALMASK
| VT_LVAL_TYPE
)) | VT_LOCAL
| VT_LVAL
;
4948 #ifdef CONFIG_TCC_BCHECK
4949 /* generate lvalue bound code */
4955 vtop
->r
&= ~VT_MUSTBOUND
;
4956 /* if lvalue, then use checking code before dereferencing */
4957 if (vtop
->r
& VT_LVAL
) {
4958 /* if not VT_BOUNDED value, then make one */
4959 if (!(vtop
->r
& VT_BOUNDED
)) {
4960 lval_type
= vtop
->r
& (VT_LVAL_TYPE
| VT_LVAL
);
4961 /* must save type because we must set it to int to get pointer */
4963 vtop
->type
.t
= VT_INT
;
4966 gen_bounded_ptr_add();
4967 vtop
->r
|= lval_type
;
4970 /* then check for dereferencing */
4971 gen_bounded_ptr_deref();
4976 /* store vtop a register belonging to class 'rc'. lvalues are
4977 converted to values. Cannot be used if cannot be converted to
4978 register value (such as structures). */
4981 int r
, rc2
, bit_pos
, bit_size
, size
, align
, i
;
4983 /* NOTE: get_reg can modify vstack[] */
4984 if (vtop
->type
.t
& VT_BITFIELD
) {
4987 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4988 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
4989 /* remove bit field info to avoid loops */
4990 vtop
->type
.t
&= ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
4991 /* cast to int to propagate signedness in following ops */
4992 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
4997 if((vtop
->type
.t
& VT_UNSIGNED
) ||
4998 (vtop
->type
.t
& VT_BTYPE
) == VT_BOOL
)
4999 type
.t
|= VT_UNSIGNED
;
5001 /* generate shifts */
5002 vpushi(bits
- (bit_pos
+ bit_size
));
5004 vpushi(bits
- bit_size
);
5005 /* NOTE: transformed to SHR if unsigned */
5009 if (is_float(vtop
->type
.t
) &&
5010 (vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
5013 unsigned long offset
;
5014 #if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
5018 /* XXX: unify with initializers handling ? */
5019 /* CPUs usually cannot use float constants, so we store them
5020 generically in data segment */
5021 size
= type_size(&vtop
->type
, &align
);
5022 offset
= (data_section
->data_offset
+ align
- 1) & -align
;
5023 data_section
->data_offset
= offset
;
5024 /* XXX: not portable yet */
5025 #if defined(__i386__) || defined(__x86_64__)
5026 /* Zero pad x87 tenbyte long doubles */
5027 if (size
== LDOUBLE_SIZE
)
5028 vtop
->c
.tab
[2] &= 0xffff;
5030 ptr
= section_ptr_add(data_section
, size
);
5032 #if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
5036 ptr
[i
] = vtop
->c
.tab
[size
-1-i
];
5040 ptr
[i
] = vtop
->c
.tab
[i
];
5041 sym
= get_sym_ref(&vtop
->type
, data_section
, offset
, size
<< 2);
5042 vtop
->r
|= VT_LVAL
| VT_SYM
;
5046 #ifdef CONFIG_TCC_BCHECK
5047 if (vtop
->r
& VT_MUSTBOUND
)
5051 r
= vtop
->r
& VT_VALMASK
;
5055 /* need to reload if:
5057 - lvalue (need to dereference pointer)
5058 - already a register, but not in the right class */
5059 if (r
>= VT_CONST
||
5060 (vtop
->r
& VT_LVAL
) ||
5061 !(reg_classes
[r
] & rc
) ||
5062 ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
&&
5063 !(reg_classes
[vtop
->r2
] & rc2
))) {
5065 #ifndef TCC_TARGET_X86_64
5066 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
5068 unsigned long long ll
;
5069 /* two register type load : expand to two words
5071 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
5074 vtop
->c
.ui
= ll
; /* first word */
5076 vtop
->r
= r
; /* save register value */
5077 vpushi(ll
>> 32); /* second word */
5078 } else if (r
>= VT_CONST
|| /* XXX: test to VT_CONST incorrect ? */
5079 (vtop
->r
& VT_LVAL
)) {
5080 /* We do not want to modifier the long long
5081 pointer here, so the safest (and less
5082 efficient) is to save all the other registers
5083 in the stack. XXX: totally inefficient. */
5085 /* load from memory */
5088 vtop
[-1].r
= r
; /* save register value */
5089 /* increment pointer to get second word */
5090 vtop
->type
.t
= VT_INT
;
5096 /* move registers */
5099 vtop
[-1].r
= r
; /* save register value */
5100 vtop
->r
= vtop
[-1].r2
;
5102 /* allocate second register */
5106 /* write second register */
5110 if ((vtop
->r
& VT_LVAL
) && !is_float(vtop
->type
.t
)) {
5112 /* lvalue of scalar type : need to use lvalue type
5113 because of possible cast */
5116 /* compute memory access type */
5117 if (vtop
->r
& VT_LVAL_BYTE
)
5119 else if (vtop
->r
& VT_LVAL_SHORT
)
5121 if (vtop
->r
& VT_LVAL_UNSIGNED
)
5125 /* restore wanted type */
5128 /* one register type load */
5133 #ifdef TCC_TARGET_C67
5134 /* uses register pairs for doubles */
5135 if ((vtop
->type
.t
& VT_BTYPE
) == VT_DOUBLE
)
5142 /* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
5143 void gv2(int rc1
, int rc2
)
5147 /* generate more generic register first. But VT_JMP or VT_CMP
5148 values must be generated first in all cases to avoid possible
5150 v
= vtop
[0].r
& VT_VALMASK
;
5151 if (v
!= VT_CMP
&& (v
& ~1) != VT_JMP
&& rc1
<= rc2
) {
5156 /* test if reload is needed for first register */
5157 if ((vtop
[-1].r
& VT_VALMASK
) >= VT_CONST
) {
5167 /* test if reload is needed for first register */
5168 if ((vtop
[0].r
& VT_VALMASK
) >= VT_CONST
) {
5174 /* expand long long on stack in two int registers */
5179 u
= vtop
->type
.t
& VT_UNSIGNED
;
5182 vtop
[0].r
= vtop
[-1].r2
;
5183 vtop
[0].r2
= VT_CONST
;
5184 vtop
[-1].r2
= VT_CONST
;
5185 vtop
[0].type
.t
= VT_INT
| u
;
5186 vtop
[-1].type
.t
= VT_INT
| u
;
5189 #ifdef TCC_TARGET_ARM
5190 /* expand long long on stack */
5191 void lexpand_nr(void)
5195 u
= vtop
->type
.t
& VT_UNSIGNED
;
5197 vtop
->r2
= VT_CONST
;
5198 vtop
->type
.t
= VT_INT
| u
;
5199 v
=vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
);
5200 if (v
== VT_CONST
) {
5201 vtop
[-1].c
.ui
= vtop
->c
.ull
;
5202 vtop
->c
.ui
= vtop
->c
.ull
>> 32;
5204 } else if (v
== (VT_LVAL
|VT_CONST
) || v
== (VT_LVAL
|VT_LOCAL
)) {
5206 vtop
->r
= vtop
[-1].r
;
5207 } else if (v
> VT_CONST
) {
5211 vtop
->r
= vtop
[-1].r2
;
5212 vtop
[-1].r2
= VT_CONST
;
5213 vtop
[-1].type
.t
= VT_INT
| u
;
5217 /* build a long long from two ints */
5220 gv2(RC_INT
, RC_INT
);
5221 vtop
[-1].r2
= vtop
[0].r
;
5222 vtop
[-1].type
.t
= t
;
5226 /* rotate n first stack elements to the bottom
5227 I1 ... In -> I2 ... In I1 [top is right]
5235 for(i
=-n
+1;i
!=0;i
++)
5236 vtop
[i
] = vtop
[i
+1];
5240 /* rotate n first stack elements to the top
5241 I1 ... In -> In I1 ... I(n-1) [top is right]
5249 for(i
= 0;i
< n
- 1; i
++)
5250 vtop
[-i
] = vtop
[-i
- 1];
5254 #ifdef TCC_TARGET_ARM
5255 /* like vrott but in other direction
5256 In ... I1 -> I(n-1) ... I1 In [top is right]
5264 for(i
= n
- 1; i
> 0; i
--)
5265 vtop
[-i
] = vtop
[-i
+ 1];
5270 /* pop stack value */
5274 v
= vtop
->r
& VT_VALMASK
;
5275 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
5276 /* for x86, we need to pop the FP stack */
5277 if (v
== TREG_ST0
&& !nocode_wanted
) {
5278 o(0xd9dd); /* fstp %st(1) */
5281 if (v
== VT_JMP
|| v
== VT_JMPI
) {
5282 /* need to put correct jump if && or || without test */
5288 /* convert stack entry to register and duplicate its value in another
5296 if ((t
& VT_BTYPE
) == VT_LLONG
) {
5303 /* stack: H L L1 H1 */
5311 /* duplicate value */
5316 #ifdef TCC_TARGET_X86_64
5317 if ((t
& VT_BTYPE
) == VT_LDOUBLE
) {
5327 load(r1
, &sv
); /* move r to r1 */
5329 /* duplicates value */
5334 #ifndef TCC_TARGET_X86_64
5335 /* generate CPU independent (unsigned) long long operations */
5336 void gen_opl(int op
)
5338 int t
, a
, b
, op1
, c
, i
;
5340 unsigned short reg_iret
= REG_IRET
;
5341 unsigned short reg_lret
= REG_LRET
;
5347 func
= TOK___divdi3
;
5350 func
= TOK___udivdi3
;
5353 func
= TOK___moddi3
;
5356 func
= TOK___umoddi3
;
5363 /* call generic long long function */
5364 vpush_global_sym(&func_old_type
, func
);
5369 vtop
->r2
= reg_lret
;
5382 /* stack: L1 H1 L2 H2 */
5387 vtop
[-2] = vtop
[-3];
5390 /* stack: H1 H2 L1 L2 */
5396 /* stack: H1 H2 L1 L2 ML MH */
5399 /* stack: ML MH H1 H2 L1 L2 */
5403 /* stack: ML MH H1 L2 H2 L1 */
5408 /* stack: ML MH M1 M2 */
5411 } else if (op
== '+' || op
== '-') {
5412 /* XXX: add non carry method too (for MIPS or alpha) */
5418 /* stack: H1 H2 (L1 op L2) */
5421 gen_op(op1
+ 1); /* TOK_xxxC2 */
5424 /* stack: H1 H2 (L1 op L2) */
5427 /* stack: (L1 op L2) H1 H2 */
5429 /* stack: (L1 op L2) (H1 op H2) */
5437 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
5438 t
= vtop
[-1].type
.t
;
5442 /* stack: L H shift */
5444 /* constant: simpler */
5445 /* NOTE: all comments are for SHL. the other cases are
5446 done by swaping words */
5457 if (op
!= TOK_SAR
) {
5490 /* XXX: should provide a faster fallback on x86 ? */
5493 func
= TOK___ashrdi3
;
5496 func
= TOK___lshrdi3
;
5499 func
= TOK___ashldi3
;
5505 /* compare operations */
5511 /* stack: L1 H1 L2 H2 */
5513 vtop
[-1] = vtop
[-2];
5515 /* stack: L1 L2 H1 H2 */
5518 /* when values are equal, we need to compare low words. since
5519 the jump is inverted, we invert the test too. */
5522 else if (op1
== TOK_GT
)
5524 else if (op1
== TOK_ULT
)
5526 else if (op1
== TOK_UGT
)
5531 if (op1
!= TOK_NE
) {
5535 /* generate non equal test */
5536 /* XXX: NOT PORTABLE yet */
5540 #if defined(TCC_TARGET_I386)
5541 b
= psym(0x850f, 0);
5542 #elif defined(TCC_TARGET_ARM)
5544 o(0x1A000000 | encbranch(ind
, 0, 1));
5545 #elif defined(TCC_TARGET_C67)
5546 error("not implemented");
5548 #error not supported
5552 /* compare low. Always unsigned */
5556 else if (op1
== TOK_LE
)
5558 else if (op1
== TOK_GT
)
5560 else if (op1
== TOK_GE
)
5571 /* handle integer constant optimizations and various machine
5573 void gen_opic(int op
)
5575 int c1
, c2
, t1
, t2
, n
;
5578 typedef unsigned long long U
;
5582 t1
= v1
->type
.t
& VT_BTYPE
;
5583 t2
= v2
->type
.t
& VT_BTYPE
;
5587 else if (v1
->type
.t
& VT_UNSIGNED
)
5594 else if (v2
->type
.t
& VT_UNSIGNED
)
5599 /* currently, we cannot do computations with forward symbols */
5600 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5601 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5604 case '+': l1
+= l2
; break;
5605 case '-': l1
-= l2
; break;
5606 case '&': l1
&= l2
; break;
5607 case '^': l1
^= l2
; break;
5608 case '|': l1
|= l2
; break;
5609 case '*': l1
*= l2
; break;
5616 /* if division by zero, generate explicit division */
5619 error("division by zero in constant");
5623 default: l1
/= l2
; break;
5624 case '%': l1
%= l2
; break;
5625 case TOK_UDIV
: l1
= (U
)l1
/ l2
; break;
5626 case TOK_UMOD
: l1
= (U
)l1
% l2
; break;
5629 case TOK_SHL
: l1
<<= l2
; break;
5630 case TOK_SHR
: l1
= (U
)l1
>> l2
; break;
5631 case TOK_SAR
: l1
>>= l2
; break;
5633 case TOK_ULT
: l1
= (U
)l1
< (U
)l2
; break;
5634 case TOK_UGE
: l1
= (U
)l1
>= (U
)l2
; break;
5635 case TOK_EQ
: l1
= l1
== l2
; break;
5636 case TOK_NE
: l1
= l1
!= l2
; break;
5637 case TOK_ULE
: l1
= (U
)l1
<= (U
)l2
; break;
5638 case TOK_UGT
: l1
= (U
)l1
> (U
)l2
; break;
5639 case TOK_LT
: l1
= l1
< l2
; break;
5640 case TOK_GE
: l1
= l1
>= l2
; break;
5641 case TOK_LE
: l1
= l1
<= l2
; break;
5642 case TOK_GT
: l1
= l1
> l2
; break;
5644 case TOK_LAND
: l1
= l1
&& l2
; break;
5645 case TOK_LOR
: l1
= l1
|| l2
; break;
5652 /* if commutative ops, put c2 as constant */
5653 if (c1
&& (op
== '+' || op
== '&' || op
== '^' ||
5654 op
== '|' || op
== '*')) {
5656 c2
= c1
; //c = c1, c1 = c2, c2 = c;
5657 l2
= l1
; //l = l1, l1 = l2, l2 = l;
5659 /* Filter out NOP operations like x*1, x-0, x&-1... */
5660 if (c2
&& (((op
== '*' || op
== '/' || op
== TOK_UDIV
||
5663 ((op
== '+' || op
== '-' || op
== '|' || op
== '^' ||
5664 op
== TOK_SHL
|| op
== TOK_SHR
|| op
== TOK_SAR
) &&
5670 } else if (c2
&& (op
== '*' || op
== TOK_PDIV
|| op
== TOK_UDIV
)) {
5671 /* try to use shifts instead of muls or divs */
5672 if (l2
> 0 && (l2
& (l2
- 1)) == 0) {
5681 else if (op
== TOK_PDIV
)
5687 } else if (c2
&& (op
== '+' || op
== '-') &&
5688 ((vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) ==
5689 (VT_CONST
| VT_SYM
) ||
5690 (vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
)) == VT_LOCAL
)) {
5691 /* symbol + constant case */
5698 if (!nocode_wanted
) {
5699 /* call low level op generator */
5700 if (t1
== VT_LLONG
|| t2
== VT_LLONG
)
5711 /* generate a floating point operation with constant propagation */
5712 void gen_opif(int op
)
5720 /* currently, we cannot do computations with forward symbols */
5721 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5722 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5724 if (v1
->type
.t
== VT_FLOAT
) {
5727 } else if (v1
->type
.t
== VT_DOUBLE
) {
5735 /* NOTE: we only do constant propagation if finite number (not
5736 NaN or infinity) (ANSI spec) */
5737 if (!ieee_finite(f1
) || !ieee_finite(f2
))
5741 case '+': f1
+= f2
; break;
5742 case '-': f1
-= f2
; break;
5743 case '*': f1
*= f2
; break;
5747 error("division by zero in constant");
5752 /* XXX: also handles tests ? */
5756 /* XXX: overflow test ? */
5757 if (v1
->type
.t
== VT_FLOAT
) {
5759 } else if (v1
->type
.t
== VT_DOUBLE
) {
5767 if (!nocode_wanted
) {
5775 static int pointed_size(CType
*type
)
5778 return type_size(pointed_type(type
), &align
);
5781 static inline int is_null_pointer(SValue
*p
)
5783 if ((p
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
5785 return ((p
->type
.t
& VT_BTYPE
) == VT_INT
&& p
->c
.i
== 0) ||
5786 ((p
->type
.t
& VT_BTYPE
) == VT_LLONG
&& p
->c
.ll
== 0);
5789 static inline int is_integer_btype(int bt
)
5791 return (bt
== VT_BYTE
|| bt
== VT_SHORT
||
5792 bt
== VT_INT
|| bt
== VT_LLONG
);
5795 /* check types for comparison or substraction of pointers */
5796 static void check_comparison_pointer_types(SValue
*p1
, SValue
*p2
, int op
)
5798 CType
*type1
, *type2
, tmp_type1
, tmp_type2
;
5801 /* null pointers are accepted for all comparisons as gcc */
5802 if (is_null_pointer(p1
) || is_null_pointer(p2
))
5806 bt1
= type1
->t
& VT_BTYPE
;
5807 bt2
= type2
->t
& VT_BTYPE
;
5808 /* accept comparison between pointer and integer with a warning */
5809 if ((is_integer_btype(bt1
) || is_integer_btype(bt2
)) && op
!= '-') {
5810 if (op
!= TOK_LOR
&& op
!= TOK_LAND
)
5811 warning("comparison between pointer and integer");
5815 /* both must be pointers or implicit function pointers */
5816 if (bt1
== VT_PTR
) {
5817 type1
= pointed_type(type1
);
5818 } else if (bt1
!= VT_FUNC
)
5819 goto invalid_operands
;
5821 if (bt2
== VT_PTR
) {
5822 type2
= pointed_type(type2
);
5823 } else if (bt2
!= VT_FUNC
) {
5825 error("invalid operands to binary %s", get_tok_str(op
, NULL
));
5827 if ((type1
->t
& VT_BTYPE
) == VT_VOID
||
5828 (type2
->t
& VT_BTYPE
) == VT_VOID
)
5832 tmp_type1
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
5833 tmp_type2
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
5834 if (!is_compatible_types(&tmp_type1
, &tmp_type2
)) {
5835 /* gcc-like error if '-' is used */
5837 goto invalid_operands
;
5839 warning("comparison of distinct pointer types lacks a cast");
5843 /* generic gen_op: handles types problems */
5846 int u
, t1
, t2
, bt1
, bt2
, t
;
5849 t1
= vtop
[-1].type
.t
;
5850 t2
= vtop
[0].type
.t
;
5851 bt1
= t1
& VT_BTYPE
;
5852 bt2
= t2
& VT_BTYPE
;
5854 if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
5855 /* at least one operand is a pointer */
5856 /* relationnal op: must be both pointers */
5857 if (op
>= TOK_ULT
&& op
<= TOK_LOR
) {
5858 check_comparison_pointer_types(vtop
- 1, vtop
, op
);
5859 /* pointers are handled are unsigned */
5860 #ifdef TCC_TARGET_X86_64
5861 t
= VT_LLONG
| VT_UNSIGNED
;
5863 t
= VT_INT
| VT_UNSIGNED
;
5867 /* if both pointers, then it must be the '-' op */
5868 if (bt1
== VT_PTR
&& bt2
== VT_PTR
) {
5870 error("cannot use pointers here");
5871 check_comparison_pointer_types(vtop
- 1, vtop
, op
);
5872 /* XXX: check that types are compatible */
5873 u
= pointed_size(&vtop
[-1].type
);
5875 /* set to integer type */
5876 #ifdef TCC_TARGET_X86_64
5877 vtop
->type
.t
= VT_LLONG
;
5879 vtop
->type
.t
= VT_INT
;
5884 /* exactly one pointer : must be '+' or '-'. */
5885 if (op
!= '-' && op
!= '+')
5886 error("cannot use pointers here");
5887 /* Put pointer as first operand */
5888 if (bt2
== VT_PTR
) {
5892 type1
= vtop
[-1].type
;
5893 #ifdef TCC_TARGET_X86_64
5894 vpushll(pointed_size(&vtop
[-1].type
));
5896 /* XXX: cast to int ? (long long case) */
5897 vpushi(pointed_size(&vtop
[-1].type
));
5900 #ifdef CONFIG_TCC_BCHECK
5901 /* if evaluating constant expression, no code should be
5902 generated, so no bound check */
5903 if (do_bounds_check
&& !const_wanted
) {
5904 /* if bounded pointers, we generate a special code to
5911 gen_bounded_ptr_add();
5917 /* put again type if gen_opic() swaped operands */
5920 } else if (is_float(bt1
) || is_float(bt2
)) {
5921 /* compute bigger type and do implicit casts */
5922 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
5924 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
5929 /* floats can only be used for a few operations */
5930 if (op
!= '+' && op
!= '-' && op
!= '*' && op
!= '/' &&
5931 (op
< TOK_ULT
|| op
> TOK_GT
))
5932 error("invalid operands for binary operation");
5934 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
5935 /* cast to biggest op */
5937 /* convert to unsigned if it does not fit in a long long */
5938 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
5939 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
5943 /* integer operations */
5945 /* convert to unsigned if it does not fit in an integer */
5946 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
5947 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
5950 /* XXX: currently, some unsigned operations are explicit, so
5951 we modify them here */
5952 if (t
& VT_UNSIGNED
) {
5959 else if (op
== TOK_LT
)
5961 else if (op
== TOK_GT
)
5963 else if (op
== TOK_LE
)
5965 else if (op
== TOK_GE
)
5972 /* special case for shifts and long long: we keep the shift as
5974 if (op
== TOK_SHR
|| op
== TOK_SAR
|| op
== TOK_SHL
)
5981 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
5982 /* relationnal op: the result is an int */
5983 vtop
->type
.t
= VT_INT
;
5990 #ifndef TCC_TARGET_ARM
5991 /* generic itof for unsigned long long case */
5992 void gen_cvt_itof1(int t
)
5994 if ((vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
)) ==
5995 (VT_LLONG
| VT_UNSIGNED
)) {
5998 vpush_global_sym(&func_old_type
, TOK___floatundisf
);
5999 #if LDOUBLE_SIZE != 8
6000 else if (t
== VT_LDOUBLE
)
6001 vpush_global_sym(&func_old_type
, TOK___floatundixf
);
6004 vpush_global_sym(&func_old_type
, TOK___floatundidf
);
6015 /* generic ftoi for unsigned long long case */
6016 void gen_cvt_ftoi1(int t
)
6020 if (t
== (VT_LLONG
| VT_UNSIGNED
)) {
6021 /* not handled natively */
6022 st
= vtop
->type
.t
& VT_BTYPE
;
6024 vpush_global_sym(&func_old_type
, TOK___fixunssfdi
);
6025 #if LDOUBLE_SIZE != 8
6026 else if (st
== VT_LDOUBLE
)
6027 vpush_global_sym(&func_old_type
, TOK___fixunsxfdi
);
6030 vpush_global_sym(&func_old_type
, TOK___fixunsdfdi
);
6035 vtop
->r2
= REG_LRET
;
6041 /* force char or short cast */
6042 void force_charshort_cast(int t
)
6046 /* XXX: add optimization if lvalue : just change type and offset */
6051 if (t
& VT_UNSIGNED
) {
6052 vpushi((1 << bits
) - 1);
6058 /* result must be signed or the SAR is converted to an SHL
6059 This was not the case when "t" was a signed short
6060 and the last value on the stack was an unsigned int */
6061 vtop
->type
.t
&= ~VT_UNSIGNED
;
6067 /* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
6068 static void gen_cast(CType
*type
)
6070 int sbt
, dbt
, sf
, df
, c
, p
;
6072 /* special delayed cast for char/short */
6073 /* XXX: in some cases (multiple cascaded casts), it may still
6075 if (vtop
->r
& VT_MUSTCAST
) {
6076 vtop
->r
&= ~VT_MUSTCAST
;
6077 force_charshort_cast(vtop
->type
.t
);
6080 /* bitfields first get cast to ints */
6081 if (vtop
->type
.t
& VT_BITFIELD
) {
6085 dbt
= type
->t
& (VT_BTYPE
| VT_UNSIGNED
);
6086 sbt
= vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
);
6091 c
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
6092 p
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == (VT_CONST
| VT_SYM
);
6094 /* constant case: we can do it now */
6095 /* XXX: in ISOC, cannot do it if error in convert */
6096 if (sbt
== VT_FLOAT
)
6097 vtop
->c
.ld
= vtop
->c
.f
;
6098 else if (sbt
== VT_DOUBLE
)
6099 vtop
->c
.ld
= vtop
->c
.d
;
6102 if ((sbt
& VT_BTYPE
) == VT_LLONG
) {
6103 if (sbt
& VT_UNSIGNED
)
6104 vtop
->c
.ld
= vtop
->c
.ull
;
6106 vtop
->c
.ld
= vtop
->c
.ll
;
6108 if (sbt
& VT_UNSIGNED
)
6109 vtop
->c
.ld
= vtop
->c
.ui
;
6111 vtop
->c
.ld
= vtop
->c
.i
;
6114 if (dbt
== VT_FLOAT
)
6115 vtop
->c
.f
= (float)vtop
->c
.ld
;
6116 else if (dbt
== VT_DOUBLE
)
6117 vtop
->c
.d
= (double)vtop
->c
.ld
;
6118 } else if (sf
&& dbt
== (VT_LLONG
|VT_UNSIGNED
)) {
6119 vtop
->c
.ull
= (unsigned long long)vtop
->c
.ld
;
6120 } else if (sf
&& dbt
== VT_BOOL
) {
6121 vtop
->c
.i
= (vtop
->c
.ld
!= 0);
6124 vtop
->c
.ll
= (long long)vtop
->c
.ld
;
6125 else if (sbt
== (VT_LLONG
|VT_UNSIGNED
))
6126 vtop
->c
.ll
= vtop
->c
.ull
;
6127 else if (sbt
& VT_UNSIGNED
)
6128 vtop
->c
.ll
= vtop
->c
.ui
;
6129 else if (sbt
!= VT_LLONG
)
6130 vtop
->c
.ll
= vtop
->c
.i
;
6132 if (dbt
== (VT_LLONG
|VT_UNSIGNED
))
6133 vtop
->c
.ull
= vtop
->c
.ll
;
6134 else if (dbt
== VT_BOOL
)
6135 vtop
->c
.i
= (vtop
->c
.ll
!= 0);
6136 else if (dbt
!= VT_LLONG
) {
6138 if ((dbt
& VT_BTYPE
) == VT_BYTE
)
6140 else if ((dbt
& VT_BTYPE
) == VT_SHORT
)
6143 if(dbt
& VT_UNSIGNED
)
6144 vtop
->c
.ui
= ((unsigned int)vtop
->c
.ll
<< s
) >> s
;
6146 vtop
->c
.i
= ((int)vtop
->c
.ll
<< s
) >> s
;
6149 } else if (p
&& dbt
== VT_BOOL
) {
6152 } else if (!nocode_wanted
) {
6153 /* non constant case: generate code */
6155 /* convert from fp to fp */
6158 /* convert int to fp */
6161 /* convert fp to int */
6162 if (dbt
== VT_BOOL
) {
6166 /* we handle char/short/etc... with generic code */
6167 if (dbt
!= (VT_INT
| VT_UNSIGNED
) &&
6168 dbt
!= (VT_LLONG
| VT_UNSIGNED
) &&
6172 if (dbt
== VT_INT
&& (type
->t
& (VT_BTYPE
| VT_UNSIGNED
)) != dbt
) {
6173 /* additional cast for char/short... */
6178 } else if ((dbt
& VT_BTYPE
) == VT_LLONG
) {
6179 if ((sbt
& VT_BTYPE
) != VT_LLONG
) {
6180 /* scalar to long long */
6181 #ifndef TCC_TARGET_X86_64
6182 /* machine independent conversion */
6184 /* generate high word */
6185 if (sbt
== (VT_INT
| VT_UNSIGNED
)) {
6193 /* patch second register */
6194 vtop
[-1].r2
= vtop
->r
;
6198 if (sbt
!= (VT_INT
| VT_UNSIGNED
)) {
6199 /* x86_64 specific: movslq */
6201 o(0xc0 + (REG_VALUE(r
) << 3) + REG_VALUE(r
));
6205 } else if (dbt
== VT_BOOL
) {
6206 /* scalar to bool */
6209 } else if ((dbt
& VT_BTYPE
) == VT_BYTE
||
6210 (dbt
& VT_BTYPE
) == VT_SHORT
) {
6211 if (sbt
== VT_PTR
) {
6212 vtop
->type
.t
= VT_INT
;
6213 warning("nonportable conversion from pointer to char/short");
6215 force_charshort_cast(dbt
);
6216 } else if ((dbt
& VT_BTYPE
) == VT_INT
) {
6218 if (sbt
== VT_LLONG
) {
6219 /* from long long: just take low order word */
6223 /* if lvalue and single word type, nothing to do because
6224 the lvalue already contains the real type size (see
6225 VT_LVAL_xxx constants) */
6228 } else if ((dbt
& VT_BTYPE
) == VT_PTR
&& !(vtop
->r
& VT_LVAL
)) {
6229 /* if we are casting between pointer types,
6230 we must update the VT_LVAL_xxx size */
6231 vtop
->r
= (vtop
->r
& ~VT_LVAL_TYPE
)
6232 | (lvalue_type(type
->ref
->type
.t
) & VT_LVAL_TYPE
);
6237 /* return type size. Put alignment at 'a' */
6238 static int type_size(CType
*type
, int *a
)
6243 bt
= type
->t
& VT_BTYPE
;
6244 if (bt
== VT_STRUCT
) {
6249 } else if (bt
== VT_PTR
) {
6250 if (type
->t
& VT_ARRAY
) {
6254 ts
= type_size(&s
->type
, a
);
6256 if (ts
< 0 && s
->c
< 0)
6264 } else if (bt
== VT_LDOUBLE
) {
6266 return LDOUBLE_SIZE
;
6267 } else if (bt
== VT_DOUBLE
|| bt
== VT_LLONG
) {
6268 #ifdef TCC_TARGET_I386
6269 #ifdef TCC_TARGET_PE
6274 #elif defined(TCC_TARGET_ARM)
6284 } else if (bt
== VT_INT
|| bt
== VT_ENUM
|| bt
== VT_FLOAT
) {
6287 } else if (bt
== VT_SHORT
) {
6291 /* char, void, function, _Bool */
6297 /* return the pointed type of t */
6298 static inline CType
*pointed_type(CType
*type
)
6300 return &type
->ref
->type
;
6303 /* modify type so that its it is a pointer to type. */
6304 static void mk_pointer(CType
*type
)
6307 s
= sym_push(SYM_FIELD
, type
, 0, -1);
6308 type
->t
= VT_PTR
| (type
->t
& ~VT_TYPE
);
6312 /* compare function types. OLD functions match any new functions */
6313 static int is_compatible_func(CType
*type1
, CType
*type2
)
6319 if (!is_compatible_types(&s1
->type
, &s2
->type
))
6321 /* check func_call */
6322 if (FUNC_CALL(s1
->r
) != FUNC_CALL(s2
->r
))
6324 /* XXX: not complete */
6325 if (s1
->c
== FUNC_OLD
|| s2
->c
== FUNC_OLD
)
6329 while (s1
!= NULL
) {
6332 if (!is_compatible_parameter_types(&s1
->type
, &s2
->type
))
6342 /* return true if type1 and type2 are the same. If unqualified is
6343 true, qualifiers on the types are ignored.
6345 - enums are not checked as gcc __builtin_types_compatible_p ()
6347 static int compare_types(CType
*type1
, CType
*type2
, int unqualified
)
6351 t1
= type1
->t
& VT_TYPE
;
6352 t2
= type2
->t
& VT_TYPE
;
6354 /* strip qualifiers before comparing */
6355 t1
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6356 t2
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6358 /* XXX: bitfields ? */
6361 /* test more complicated cases */
6362 bt1
= t1
& VT_BTYPE
;
6363 if (bt1
== VT_PTR
) {
6364 type1
= pointed_type(type1
);
6365 type2
= pointed_type(type2
);
6366 return is_compatible_types(type1
, type2
);
6367 } else if (bt1
== VT_STRUCT
) {
6368 return (type1
->ref
== type2
->ref
);
6369 } else if (bt1
== VT_FUNC
) {
6370 return is_compatible_func(type1
, type2
);
6376 /* return true if type1 and type2 are exactly the same (including
6379 static int is_compatible_types(CType
*type1
, CType
*type2
)
6381 return compare_types(type1
,type2
,0);
6384 /* return true if type1 and type2 are the same (ignoring qualifiers).
6386 static int is_compatible_parameter_types(CType
*type1
, CType
*type2
)
6388 return compare_types(type1
,type2
,1);
6391 /* print a type. If 'varstr' is not NULL, then the variable is also
6392 printed in the type */
6394 /* XXX: add array and function pointers */
6395 void type_to_str(char *buf
, int buf_size
,
6396 CType
*type
, const char *varstr
)
6403 t
= type
->t
& VT_TYPE
;
6406 if (t
& VT_CONSTANT
)
6407 pstrcat(buf
, buf_size
, "const ");
6408 if (t
& VT_VOLATILE
)
6409 pstrcat(buf
, buf_size
, "volatile ");
6410 if (t
& VT_UNSIGNED
)
6411 pstrcat(buf
, buf_size
, "unsigned ");
6441 tstr
= "long double";
6443 pstrcat(buf
, buf_size
, tstr
);
6447 if (bt
== VT_STRUCT
)
6451 pstrcat(buf
, buf_size
, tstr
);
6452 v
= type
->ref
->v
& ~SYM_STRUCT
;
6453 if (v
>= SYM_FIRST_ANOM
)
6454 pstrcat(buf
, buf_size
, "<anonymous>");
6456 pstrcat(buf
, buf_size
, get_tok_str(v
, NULL
));
6460 type_to_str(buf
, buf_size
, &s
->type
, varstr
);
6461 pstrcat(buf
, buf_size
, "(");
6463 while (sa
!= NULL
) {
6464 type_to_str(buf1
, sizeof(buf1
), &sa
->type
, NULL
);
6465 pstrcat(buf
, buf_size
, buf1
);
6468 pstrcat(buf
, buf_size
, ", ");
6470 pstrcat(buf
, buf_size
, ")");
6474 pstrcpy(buf1
, sizeof(buf1
), "*");
6476 pstrcat(buf1
, sizeof(buf1
), varstr
);
6477 type_to_str(buf
, buf_size
, &s
->type
, buf1
);
6481 pstrcat(buf
, buf_size
, " ");
6482 pstrcat(buf
, buf_size
, varstr
);
6487 /* verify type compatibility to store vtop in 'dt' type, and generate
6489 static void gen_assign_cast(CType
*dt
)
6491 CType
*st
, *type1
, *type2
, tmp_type1
, tmp_type2
;
6492 char buf1
[256], buf2
[256];
6495 st
= &vtop
->type
; /* source type */
6496 dbt
= dt
->t
& VT_BTYPE
;
6497 sbt
= st
->t
& VT_BTYPE
;
6498 if (dt
->t
& VT_CONSTANT
)
6499 warning("assignment of read-only location");
6502 /* special cases for pointers */
6503 /* '0' can also be a pointer */
6504 if (is_null_pointer(vtop
))
6506 /* accept implicit pointer to integer cast with warning */
6507 if (is_integer_btype(sbt
)) {
6508 warning("assignment makes pointer from integer without a cast");
6511 type1
= pointed_type(dt
);
6512 /* a function is implicitely a function pointer */
6513 if (sbt
== VT_FUNC
) {
6514 if ((type1
->t
& VT_BTYPE
) != VT_VOID
&&
6515 !is_compatible_types(pointed_type(dt
), st
))
6522 type2
= pointed_type(st
);
6523 if ((type1
->t
& VT_BTYPE
) == VT_VOID
||
6524 (type2
->t
& VT_BTYPE
) == VT_VOID
) {
6525 /* void * can match anything */
6527 /* exact type match, except for unsigned */
6530 tmp_type1
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
6531 tmp_type2
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
6532 if (!is_compatible_types(&tmp_type1
, &tmp_type2
))
6533 warning("assignment from incompatible pointer type");
6535 /* check const and volatile */
6536 if ((!(type1
->t
& VT_CONSTANT
) && (type2
->t
& VT_CONSTANT
)) ||
6537 (!(type1
->t
& VT_VOLATILE
) && (type2
->t
& VT_VOLATILE
)))
6538 warning("assignment discards qualifiers from pointer target type");
6544 if (sbt
== VT_PTR
|| sbt
== VT_FUNC
) {
6545 warning("assignment makes integer from pointer without a cast");
6547 /* XXX: more tests */
6552 tmp_type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6553 tmp_type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6554 if (!is_compatible_types(&tmp_type1
, &tmp_type2
)) {
6556 type_to_str(buf1
, sizeof(buf1
), st
, NULL
);
6557 type_to_str(buf2
, sizeof(buf2
), dt
, NULL
);
6558 error("cannot cast '%s' to '%s'", buf1
, buf2
);
6566 /* store vtop in lvalue pushed on stack */
6569 int sbt
, dbt
, ft
, r
, t
, size
, align
, bit_size
, bit_pos
, rc
, delayed_cast
;
6571 ft
= vtop
[-1].type
.t
;
6572 sbt
= vtop
->type
.t
& VT_BTYPE
;
6573 dbt
= ft
& VT_BTYPE
;
6574 if (((sbt
== VT_INT
|| sbt
== VT_SHORT
) && dbt
== VT_BYTE
) ||
6575 (sbt
== VT_INT
&& dbt
== VT_SHORT
)) {
6576 /* optimize char/short casts */
6577 delayed_cast
= VT_MUSTCAST
;
6578 vtop
->type
.t
= ft
& (VT_TYPE
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
)));
6579 /* XXX: factorize */
6580 if (ft
& VT_CONSTANT
)
6581 warning("assignment of read-only location");
6584 if (!(ft
& VT_BITFIELD
))
6585 gen_assign_cast(&vtop
[-1].type
);
6588 if (sbt
== VT_STRUCT
) {
6589 /* if structure, only generate pointer */
6590 /* structure assignment : generate memcpy */
6591 /* XXX: optimize if small size */
6592 if (!nocode_wanted
) {
6593 size
= type_size(&vtop
->type
, &align
);
6597 vpush_global_sym(&func_old_type
, TOK_memcpy8
);
6598 else if(!(align
& 3))
6599 vpush_global_sym(&func_old_type
, TOK_memcpy4
);
6602 vpush_global_sym(&func_old_type
, TOK_memcpy
);
6606 vtop
->type
.t
= VT_INT
;
6610 vtop
->type
.t
= VT_INT
;
6622 /* leave source on stack */
6623 } else if (ft
& VT_BITFIELD
) {
6624 /* bitfield store handling */
6625 bit_pos
= (ft
>> VT_STRUCT_SHIFT
) & 0x3f;
6626 bit_size
= (ft
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
6627 /* remove bit field info to avoid loops */
6628 vtop
[-1].type
.t
= ft
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
6630 /* duplicate source into other register */
6635 if((ft
& VT_BTYPE
) == VT_BOOL
) {
6636 gen_cast(&vtop
[-1].type
);
6637 vtop
[-1].type
.t
= (vtop
[-1].type
.t
& ~VT_BTYPE
) | (VT_BYTE
| VT_UNSIGNED
);
6640 /* duplicate destination */
6642 vtop
[-1] = vtop
[-2];
6644 /* mask and shift source */
6645 if((ft
& VT_BTYPE
) != VT_BOOL
) {
6646 if((ft
& VT_BTYPE
) == VT_LLONG
) {
6647 vpushll((1ULL << bit_size
) - 1ULL);
6649 vpushi((1 << bit_size
) - 1);
6655 /* load destination, mask and or with source */
6657 if((ft
& VT_BTYPE
) == VT_LLONG
) {
6658 vpushll(~(((1ULL << bit_size
) - 1ULL) << bit_pos
));
6660 vpushi(~(((1 << bit_size
) - 1) << bit_pos
));
6667 /* pop off shifted source from "duplicate source..." above */
6671 #ifdef CONFIG_TCC_BCHECK
6672 /* bound check case */
6673 if (vtop
[-1].r
& VT_MUSTBOUND
) {
6679 if (!nocode_wanted
) {
6683 #ifdef TCC_TARGET_X86_64
6684 if ((ft
& VT_BTYPE
) == VT_LDOUBLE
) {
6689 r
= gv(rc
); /* generate value */
6690 /* if lvalue was saved on stack, must read it */
6691 if ((vtop
[-1].r
& VT_VALMASK
) == VT_LLOCAL
) {
6693 t
= get_reg(RC_INT
);
6694 #ifdef TCC_TARGET_X86_64
6699 sv
.r
= VT_LOCAL
| VT_LVAL
;
6700 sv
.c
.ul
= vtop
[-1].c
.ul
;
6702 vtop
[-1].r
= t
| VT_LVAL
;
6705 #ifndef TCC_TARGET_X86_64
6706 /* two word case handling : store second register at word + 4 */
6707 if ((ft
& VT_BTYPE
) == VT_LLONG
) {
6709 /* convert to int to increment easily */
6710 vtop
->type
.t
= VT_INT
;
6716 /* XXX: it works because r2 is spilled last ! */
6717 store(vtop
->r2
, vtop
- 1);
6722 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
6723 vtop
->r
|= delayed_cast
;
6727 /* post defines POST/PRE add. c is the token ++ or -- */
6728 void inc(int post
, int c
)
6731 vdup(); /* save lvalue */
6733 gv_dup(); /* duplicate value */
6738 vpushi(c
- TOK_MID
);
6740 vstore(); /* store value */
6742 vpop(); /* if post op, return saved value */
6745 /* Parse GNUC __attribute__ extension. Currently, the following
6746 extensions are recognized:
6747 - aligned(n) : set data/function alignment.
6748 - packed : force data alignment to 1
6749 - section(x) : generate data/code in this section.
6750 - unused : currently ignored, but may be used someday.
6751 - regparm(n) : pass function parameters in registers (i386 only)
6753 static void parse_attribute(AttributeDef
*ad
)
6757 while (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
) {
6761 while (tok
!= ')') {
6762 if (tok
< TOK_IDENT
)
6763 expect("attribute name");
6771 expect("section name");
6772 ad
->section
= find_section(tcc_state
, (char *)tokc
.cstr
->data
);
6781 if (n
<= 0 || (n
& (n
- 1)) != 0)
6782 error("alignment must be a positive power of two");
6795 /* currently, no need to handle it because tcc does not
6796 track unused objects */
6800 /* currently, no need to handle it because tcc does not
6801 track unused objects */
6806 FUNC_CALL(ad
->func_attr
) = FUNC_CDECL
;
6811 FUNC_CALL(ad
->func_attr
) = FUNC_STDCALL
;
6813 #ifdef TCC_TARGET_I386
6823 FUNC_CALL(ad
->func_attr
) = FUNC_FASTCALL1
+ n
- 1;
6829 FUNC_CALL(ad
->func_attr
) = FUNC_FASTCALLW
;
6833 FUNC_EXPORT(ad
->func_attr
) = 1;
6836 if (tcc_state
->warn_unsupported
)
6837 warning("'%s' attribute ignored", get_tok_str(t
, NULL
));
6838 /* skip parameters */
6840 int parenthesis
= 0;
6844 else if (tok
== ')')
6847 } while (parenthesis
&& tok
!= -1);
6860 /* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
6861 static void struct_decl(CType
*type
, int u
)
6863 int a
, v
, size
, align
, maxalign
, c
, offset
;
6864 int bit_size
, bit_pos
, bsize
, bt
, lbit_pos
, prevbt
;
6865 Sym
*s
, *ss
, *ass
, **ps
;
6869 a
= tok
; /* save decl type */
6874 /* struct already defined ? return it */
6876 expect("struct/union/enum name");
6880 error("invalid type");
6887 /* we put an undefined size for struct/union */
6888 s
= sym_push(v
| SYM_STRUCT
, &type1
, 0, -1);
6889 s
->r
= 0; /* default alignment is zero as gcc */
6890 /* put struct/union/enum name in type */
6898 error("struct/union/enum already defined");
6899 /* cannot be empty */
6901 /* non empty enums are not allowed */
6902 if (a
== TOK_ENUM
) {
6906 expect("identifier");
6912 /* enum symbols have static storage */
6913 ss
= sym_push(v
, &int_type
, VT_CONST
, c
);
6914 ss
->type
.t
|= VT_STATIC
;
6919 /* NOTE: we accept a trailing comma */
6930 while (tok
!= '}') {
6931 parse_btype(&btype
, &ad
);
6937 type_decl(&type1
, &ad
, &v
, TYPE_DIRECT
| TYPE_ABSTRACT
);
6938 if (v
== 0 && (type1
.t
& VT_BTYPE
) != VT_STRUCT
)
6939 expect("identifier");
6940 if ((type1
.t
& VT_BTYPE
) == VT_FUNC
||
6941 (type1
.t
& (VT_TYPEDEF
| VT_STATIC
| VT_EXTERN
| VT_INLINE
)))
6942 error("invalid type for '%s'",
6943 get_tok_str(v
, NULL
));
6947 bit_size
= expr_const();
6948 /* XXX: handle v = 0 case for messages */
6950 error("negative width in bit-field '%s'",
6951 get_tok_str(v
, NULL
));
6952 if (v
&& bit_size
== 0)
6953 error("zero width for bit-field '%s'",
6954 get_tok_str(v
, NULL
));
6956 size
= type_size(&type1
, &align
);
6958 if (align
< ad
.aligned
)
6960 } else if (ad
.packed
) {
6962 } else if (*tcc_state
->pack_stack_ptr
) {
6963 if (align
> *tcc_state
->pack_stack_ptr
)
6964 align
= *tcc_state
->pack_stack_ptr
;
6967 if (bit_size
>= 0) {
6968 bt
= type1
.t
& VT_BTYPE
;
6975 error("bitfields must have scalar type");
6977 if (bit_size
> bsize
) {
6978 error("width of '%s' exceeds its type",
6979 get_tok_str(v
, NULL
));
6980 } else if (bit_size
== bsize
) {
6981 /* no need for bit fields */
6983 } else if (bit_size
== 0) {
6984 /* XXX: what to do if only padding in a
6986 /* zero size: means to pad */
6989 /* we do not have enough room ?
6990 did the type change?
6992 if ((bit_pos
+ bit_size
) > bsize
||
6993 bt
!= prevbt
|| a
== TOK_UNION
)
6996 /* XXX: handle LSB first */
6997 type1
.t
|= VT_BITFIELD
|
6998 (bit_pos
<< VT_STRUCT_SHIFT
) |
6999 (bit_size
<< (VT_STRUCT_SHIFT
+ 6));
7000 bit_pos
+= bit_size
;
7006 if (v
!= 0 || (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
7007 /* add new memory data only if starting
7009 if (lbit_pos
== 0) {
7010 if (a
== TOK_STRUCT
) {
7011 c
= (c
+ align
- 1) & -align
;
7020 if (align
> maxalign
)
7024 printf("add field %s offset=%d",
7025 get_tok_str(v
, NULL
), offset
);
7026 if (type1
.t
& VT_BITFIELD
) {
7027 printf(" pos=%d size=%d",
7028 (type1
.t
>> VT_STRUCT_SHIFT
) & 0x3f,
7029 (type1
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f);
7034 if (v
== 0 && (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
7036 while ((ass
= ass
->next
) != NULL
) {
7037 ss
= sym_push(ass
->v
, &ass
->type
, 0, offset
+ ass
->c
);
7042 ss
= sym_push(v
| SYM_FIELD
, &type1
, 0, offset
);
7046 if (tok
== ';' || tok
== TOK_EOF
)
7053 /* store size and alignment */
7054 s
->c
= (c
+ maxalign
- 1) & -maxalign
;
7060 /* return 0 if no type declaration. otherwise, return the basic type
7063 static int parse_btype(CType
*type
, AttributeDef
*ad
)
7065 int t
, u
, type_found
, typespec_found
, typedef_found
;
7069 memset(ad
, 0, sizeof(AttributeDef
));
7077 /* currently, we really ignore extension */
7087 if ((t
& VT_BTYPE
) != 0)
7088 error("too many basic types");
7104 if ((t
& VT_BTYPE
) == VT_DOUBLE
) {
7105 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
7106 } else if ((t
& VT_BTYPE
) == VT_LONG
) {
7107 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
7121 if ((t
& VT_BTYPE
) == VT_LONG
) {
7122 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
7129 struct_decl(&type1
, VT_ENUM
);
7132 type
->ref
= type1
.ref
;
7136 struct_decl(&type1
, VT_STRUCT
);
7139 /* type modifiers */
7192 /* GNUC attribute */
7193 case TOK_ATTRIBUTE1
:
7194 case TOK_ATTRIBUTE2
:
7195 parse_attribute(ad
);
7202 parse_expr_type(&type1
);
7205 if (typespec_found
|| typedef_found
)
7208 if (!s
|| !(s
->type
.t
& VT_TYPEDEF
))
7211 t
|= (s
->type
.t
& ~VT_TYPEDEF
);
7212 type
->ref
= s
->type
.ref
;
7220 if ((t
& (VT_SIGNED
|VT_UNSIGNED
)) == (VT_SIGNED
|VT_UNSIGNED
))
7221 error("signed and unsigned modifier");
7222 if (tcc_state
->char_is_unsigned
) {
7223 if ((t
& (VT_SIGNED
|VT_UNSIGNED
|VT_BTYPE
)) == VT_BYTE
)
7228 /* long is never used as type */
7229 if ((t
& VT_BTYPE
) == VT_LONG
)
7230 #ifndef TCC_TARGET_X86_64
7231 t
= (t
& ~VT_BTYPE
) | VT_INT
;
7233 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
7239 /* convert a function parameter type (array to pointer and function to
7240 function pointer) */
7241 static inline void convert_parameter_type(CType
*pt
)
7243 /* remove const and volatile qualifiers (XXX: const could be used
7244 to indicate a const function parameter */
7245 pt
->t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
7246 /* array must be transformed to pointer according to ANSI C */
7248 if ((pt
->t
& VT_BTYPE
) == VT_FUNC
) {
7253 static void post_type(CType
*type
, AttributeDef
*ad
)
7255 int n
, l
, t1
, arg_size
, align
;
7256 Sym
**plast
, *s
, *first
;
7261 /* function declaration */
7269 /* read param name and compute offset */
7270 if (l
!= FUNC_OLD
) {
7271 if (!parse_btype(&pt
, &ad1
)) {
7273 error("invalid type");
7280 if ((pt
.t
& VT_BTYPE
) == VT_VOID
&& tok
== ')')
7282 type_decl(&pt
, &ad1
, &n
, TYPE_DIRECT
| TYPE_ABSTRACT
);
7283 if ((pt
.t
& VT_BTYPE
) == VT_VOID
)
7284 error("parameter declared as void");
7285 arg_size
+= (type_size(&pt
, &align
) + 3) & ~3;
7290 expect("identifier");
7294 convert_parameter_type(&pt
);
7295 s
= sym_push(n
| SYM_FIELD
, &pt
, 0, 0);
7301 if (l
== FUNC_NEW
&& tok
== TOK_DOTS
) {
7308 /* if no parameters, then old type prototype */
7312 t1
= type
->t
& VT_STORAGE
;
7313 /* NOTE: const is ignored in returned type as it has a special
7314 meaning in gcc / C++ */
7315 type
->t
&= ~(VT_STORAGE
| VT_CONSTANT
);
7316 post_type(type
, ad
);
7317 /* we push a anonymous symbol which will contain the function prototype */
7318 FUNC_ARGS(ad
->func_attr
) = arg_size
;
7319 s
= sym_push(SYM_FIELD
, type
, ad
->func_attr
, l
);
7321 type
->t
= t1
| VT_FUNC
;
7323 } else if (tok
== '[') {
7324 /* array definition */
7326 if (tok
== TOK_RESTRICT1
)
7332 error("invalid array size");
7335 /* parse next post type */
7336 t1
= type
->t
& VT_STORAGE
;
7337 type
->t
&= ~VT_STORAGE
;
7338 post_type(type
, ad
);
7340 /* we push a anonymous symbol which will contain the array
7342 s
= sym_push(SYM_FIELD
, type
, 0, n
);
7343 type
->t
= t1
| VT_ARRAY
| VT_PTR
;
7348 /* Parse a type declaration (except basic type), and return the type
7349 in 'type'. 'td' is a bitmask indicating which kind of type decl is
7350 expected. 'type' should contain the basic type. 'ad' is the
7351 attribute definition of the basic type. It can be modified by
7354 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
)
7357 CType type1
, *type2
;
7360 while (tok
== '*') {
7368 qualifiers
|= VT_CONSTANT
;
7373 qualifiers
|= VT_VOLATILE
;
7381 type
->t
|= qualifiers
;
7384 /* XXX: clarify attribute handling */
7385 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
7386 parse_attribute(ad
);
7388 /* recursive type */
7389 /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
7390 type1
.t
= 0; /* XXX: same as int */
7393 /* XXX: this is not correct to modify 'ad' at this point, but
7394 the syntax is not clear */
7395 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
7396 parse_attribute(ad
);
7397 type_decl(&type1
, ad
, v
, td
);
7400 /* type identifier */
7401 if (tok
>= TOK_IDENT
&& (td
& TYPE_DIRECT
)) {
7405 if (!(td
& TYPE_ABSTRACT
))
7406 expect("identifier");
7410 post_type(type
, ad
);
7411 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
7412 parse_attribute(ad
);
7415 /* append type at the end of type1 */
7428 /* compute the lvalue VT_LVAL_xxx needed to match type t. */
7429 static int lvalue_type(int t
)
7434 if (bt
== VT_BYTE
|| bt
== VT_BOOL
)
7436 else if (bt
== VT_SHORT
)
7440 if (t
& VT_UNSIGNED
)
7441 r
|= VT_LVAL_UNSIGNED
;
7445 /* indirection with full error checking and bound check */
7446 static void indir(void)
7448 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
) {
7449 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FUNC
)
7453 if ((vtop
->r
& VT_LVAL
) && !nocode_wanted
)
7455 vtop
->type
= *pointed_type(&vtop
->type
);
7456 /* Arrays and functions are never lvalues */
7457 if (!(vtop
->type
.t
& VT_ARRAY
)
7458 && (vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
7459 vtop
->r
|= lvalue_type(vtop
->type
.t
);
7460 /* if bound checking, the referenced pointer must be checked */
7461 if (do_bounds_check
)
7462 vtop
->r
|= VT_MUSTBOUND
;
7466 /* pass a parameter to a function and do type checking and casting */
7467 static void gfunc_param_typed(Sym
*func
, Sym
*arg
)
7472 func_type
= func
->c
;
7473 if (func_type
== FUNC_OLD
||
7474 (func_type
== FUNC_ELLIPSIS
&& arg
== NULL
)) {
7475 /* default casting : only need to convert float to double */
7476 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
) {
7480 } else if (arg
== NULL
) {
7481 error("too many arguments to function");
7484 type
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
7485 gen_assign_cast(&type
);
7489 /* parse an expression of the form '(type)' or '(expr)' and return its
7491 static void parse_expr_type(CType
*type
)
7497 if (parse_btype(type
, &ad
)) {
7498 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
7505 static void parse_type(CType
*type
)
7510 if (!parse_btype(type
, &ad
)) {
7513 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
7516 static void vpush_tokc(int t
)
7520 vsetc(&type
, VT_CONST
, &tokc
);
7523 static void unary(void)
7525 int n
, t
, align
, size
, r
;
7530 /* XXX: GCC 2.95.3 does not generate a table although it should be
7544 vpush_tokc(VT_INT
| VT_UNSIGNED
);
7548 vpush_tokc(VT_LLONG
);
7552 vpush_tokc(VT_LLONG
| VT_UNSIGNED
);
7556 vpush_tokc(VT_FLOAT
);
7560 vpush_tokc(VT_DOUBLE
);
7564 vpush_tokc(VT_LDOUBLE
);
7567 case TOK___FUNCTION__
:
7569 goto tok_identifier
;
7575 /* special function name identifier */
7576 len
= strlen(funcname
) + 1;
7577 /* generate char[len] type */
7582 vpush_ref(&type
, data_section
, data_section
->data_offset
, len
);
7583 ptr
= section_ptr_add(data_section
, len
);
7584 memcpy(ptr
, funcname
, len
);
7589 #ifdef TCC_TARGET_PE
7590 t
= VT_SHORT
| VT_UNSIGNED
;
7596 /* string parsing */
7599 if (tcc_state
->warn_write_strings
)
7604 memset(&ad
, 0, sizeof(AttributeDef
));
7605 decl_initializer_alloc(&type
, &ad
, VT_CONST
, 2, 0, 0);
7610 if (parse_btype(&type
, &ad
)) {
7611 type_decl(&type
, &ad
, &n
, TYPE_ABSTRACT
);
7613 /* check ISOC99 compound literal */
7615 /* data is allocated locally by default */
7620 /* all except arrays are lvalues */
7621 if (!(type
.t
& VT_ARRAY
))
7622 r
|= lvalue_type(type
.t
);
7623 memset(&ad
, 0, sizeof(AttributeDef
));
7624 decl_initializer_alloc(&type
, &ad
, r
, 1, 0, 0);
7629 } else if (tok
== '{') {
7630 /* save all registers */
7632 /* statement expression : we do not accept break/continue
7633 inside as GCC does */
7634 block(NULL
, NULL
, NULL
, NULL
, 0, 1);
7649 /* functions names must be treated as function pointers,
7650 except for unary '&' and sizeof. Since we consider that
7651 functions are not lvalues, we only have to handle it
7652 there and in function calls. */
7653 /* arrays can also be used although they are not lvalues */
7654 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
&&
7655 !(vtop
->type
.t
& VT_ARRAY
) && !(vtop
->type
.t
& VT_LLOCAL
))
7657 mk_pointer(&vtop
->type
);
7663 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
7665 boolean
.t
= VT_BOOL
;
7667 vtop
->c
.i
= !vtop
->c
.i
;
7668 } else if ((vtop
->r
& VT_VALMASK
) == VT_CMP
)
7669 vtop
->c
.i
= vtop
->c
.i
^ 1;
7672 vseti(VT_JMP
, gtst(1, 0));
7683 /* in order to force cast, we add zero */
7685 if ((vtop
->type
.t
& VT_BTYPE
) == VT_PTR
)
7686 error("pointer not accepted for unary plus");
7696 parse_expr_type(&type
);
7700 size
= type_size(&type
, &align
);
7701 if (t
== TOK_SIZEOF
) {
7703 error("sizeof applied to an incomplete type");
7708 vtop
->type
.t
|= VT_UNSIGNED
;
7711 case TOK_builtin_types_compatible_p
:
7720 type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
7721 type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
7722 vpushi(is_compatible_types(&type1
, &type2
));
7725 case TOK_builtin_constant_p
:
7727 int saved_nocode_wanted
, res
;
7730 saved_nocode_wanted
= nocode_wanted
;
7733 res
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
7735 nocode_wanted
= saved_nocode_wanted
;
7740 case TOK_builtin_frame_address
:
7745 if (tok
!= TOK_CINT
) {
7746 error("__builtin_frame_address only takes integers");
7749 error("TCC only supports __builtin_frame_address(0)");
7755 vset(&type
, VT_LOCAL
, 0);
7758 #ifdef TCC_TARGET_X86_64
7759 case TOK_builtin_malloc
:
7761 char *p
= file
->buf_ptr
;
7762 file
->buf_ptr
= "malloc";
7765 goto tok_identifier
;
7767 case TOK_builtin_free
:
7769 char *p
= file
->buf_ptr
;
7770 file
->buf_ptr
= "free";
7773 goto tok_identifier
;
7791 goto tok_identifier
;
7793 /* allow to take the address of a label */
7794 if (tok
< TOK_UIDENT
)
7795 expect("label identifier");
7796 s
= label_find(tok
);
7798 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
7800 if (s
->r
== LABEL_DECLARED
)
7801 s
->r
= LABEL_FORWARD
;
7804 s
->type
.t
= VT_VOID
;
7805 mk_pointer(&s
->type
);
7806 s
->type
.t
|= VT_STATIC
;
7808 vset(&s
->type
, VT_CONST
| VT_SYM
, 0);
7817 expect("identifier");
7821 error("'%s' undeclared", get_tok_str(t
, NULL
));
7822 /* for simple function calls, we tolerate undeclared
7823 external reference to int() function */
7824 if (tcc_state
->warn_implicit_function_declaration
)
7825 warning("implicit declaration of function '%s'",
7826 get_tok_str(t
, NULL
));
7827 s
= external_global_sym(t
, &func_old_type
, 0);
7829 if ((s
->type
.t
& (VT_STATIC
| VT_INLINE
| VT_BTYPE
)) ==
7830 (VT_STATIC
| VT_INLINE
| VT_FUNC
)) {
7831 /* if referencing an inline function, then we generate a
7832 symbol to it if not already done. It will have the
7833 effect to generate code for it at the end of the
7834 compilation unit. Inline function as always
7835 generated in the text section. */
7837 put_extern_sym(s
, text_section
, 0, 0);
7838 r
= VT_SYM
| VT_CONST
;
7842 vset(&s
->type
, r
, s
->c
);
7843 /* if forward reference, we must point to s */
7844 if (vtop
->r
& VT_SYM
) {
7851 /* post operations */
7853 if (tok
== TOK_INC
|| tok
== TOK_DEC
) {
7856 } else if (tok
== '.' || tok
== TOK_ARROW
) {
7858 if (tok
== TOK_ARROW
)
7863 /* expect pointer on structure */
7864 if ((vtop
->type
.t
& VT_BTYPE
) != VT_STRUCT
)
7865 expect("struct or union");
7869 while ((s
= s
->next
) != NULL
) {
7874 error("field not found: %s", get_tok_str(tok
& ~SYM_FIELD
, NULL
));
7875 /* add field offset to pointer */
7876 vtop
->type
= char_pointer_type
; /* change type to 'char *' */
7879 /* change type to field type, and set to lvalue */
7880 vtop
->type
= s
->type
;
7881 /* an array is never an lvalue */
7882 if (!(vtop
->type
.t
& VT_ARRAY
)) {
7883 vtop
->r
|= lvalue_type(vtop
->type
.t
);
7884 /* if bound checking, the referenced pointer must be checked */
7885 if (do_bounds_check
)
7886 vtop
->r
|= VT_MUSTBOUND
;
7889 } else if (tok
== '[') {
7895 } else if (tok
== '(') {
7901 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
7902 /* pointer test (no array accepted) */
7903 if ((vtop
->type
.t
& (VT_BTYPE
| VT_ARRAY
)) == VT_PTR
) {
7904 vtop
->type
= *pointed_type(&vtop
->type
);
7905 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
)
7909 expect("function pointer");
7912 vtop
->r
&= ~VT_LVAL
; /* no lvalue */
7914 /* get return type */
7917 sa
= s
->next
; /* first parameter */
7920 /* compute first implicit argument if a structure is returned */
7921 if ((s
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
7922 /* get some space for the returned structure */
7923 size
= type_size(&s
->type
, &align
);
7924 loc
= (loc
- size
) & -align
;
7926 ret
.r
= VT_LOCAL
| VT_LVAL
;
7927 /* pass it as 'int' to avoid structure arg passing
7929 vseti(VT_LOCAL
, loc
);
7934 /* return in register */
7935 if (is_float(ret
.type
.t
)) {
7938 if ((ret
.type
.t
& VT_BTYPE
) == VT_LLONG
)
7947 gfunc_param_typed(s
, sa
);
7957 error("too few arguments to function");
7959 if (!nocode_wanted
) {
7960 gfunc_call(nb_args
);
7962 vtop
-= (nb_args
+ 1);
7965 vsetc(&ret
.type
, ret
.r
, &ret
.c
);
7973 static void uneq(void)
7979 (tok
>= TOK_A_MOD
&& tok
<= TOK_A_DIV
) ||
7980 tok
== TOK_A_XOR
|| tok
== TOK_A_OR
||
7981 tok
== TOK_A_SHL
|| tok
== TOK_A_SAR
) {
7996 static void expr_prod(void)
8001 while (tok
== '*' || tok
== '/' || tok
== '%') {
8009 static void expr_sum(void)
8014 while (tok
== '+' || tok
== '-') {
8022 static void expr_shift(void)
8027 while (tok
== TOK_SHL
|| tok
== TOK_SAR
) {
8035 static void expr_cmp(void)
8040 while ((tok
>= TOK_ULE
&& tok
<= TOK_GT
) ||
8041 tok
== TOK_ULT
|| tok
== TOK_UGE
) {
8049 static void expr_cmpeq(void)
8054 while (tok
== TOK_EQ
|| tok
== TOK_NE
) {
8062 static void expr_and(void)
8065 while (tok
== '&') {
8072 static void expr_xor(void)
8075 while (tok
== '^') {
8082 static void expr_or(void)
8085 while (tok
== '|') {
8092 /* XXX: fix this mess */
8093 static void expr_land_const(void)
8096 while (tok
== TOK_LAND
) {
8103 /* XXX: fix this mess */
8104 static void expr_lor_const(void)
8107 while (tok
== TOK_LOR
) {
8114 /* only used if non constant */
8115 static void expr_land(void)
8120 if (tok
== TOK_LAND
) {
8125 if (tok
!= TOK_LAND
) {
8135 static void expr_lor(void)
8140 if (tok
== TOK_LOR
) {
8145 if (tok
!= TOK_LOR
) {
8155 /* XXX: better constant handling */
8156 static void expr_eq(void)
8158 int tt
, u
, r1
, r2
, rc
, t1
, t2
, bt1
, bt2
;
8160 CType type
, type1
, type2
;
8167 boolean
.t
= VT_BOOL
;
8173 if (tok
!= ':' || !gnu_ext
) {
8188 if (vtop
!= vstack
) {
8189 /* needed to avoid having different registers saved in
8191 if (is_float(vtop
->type
.t
)) {
8193 #ifdef TCC_TARGET_X86_64
8194 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LDOUBLE
) {
8204 if (tok
== ':' && gnu_ext
) {
8212 sv
= *vtop
; /* save value to handle it later */
8213 vtop
--; /* no vpop so that FP stack is not flushed */
8221 bt1
= t1
& VT_BTYPE
;
8223 bt2
= t2
& VT_BTYPE
;
8224 /* cast operands to correct type according to ISOC rules */
8225 if (is_float(bt1
) || is_float(bt2
)) {
8226 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
8227 type
.t
= VT_LDOUBLE
;
8228 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
8233 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
8234 /* cast to biggest op */
8236 /* convert to unsigned if it does not fit in a long long */
8237 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
8238 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
8239 type
.t
|= VT_UNSIGNED
;
8240 } else if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
8241 /* XXX: test pointer compatibility */
8243 } else if (bt1
== VT_FUNC
|| bt2
== VT_FUNC
) {
8244 /* XXX: test function pointer compatibility */
8246 } else if (bt1
== VT_STRUCT
|| bt2
== VT_STRUCT
) {
8247 /* XXX: test structure compatibility */
8249 } else if (bt1
== VT_VOID
|| bt2
== VT_VOID
) {
8250 /* NOTE: as an extension, we accept void on only one side */
8253 /* integer operations */
8255 /* convert to unsigned if it does not fit in an integer */
8256 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
8257 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
8258 type
.t
|= VT_UNSIGNED
;
8261 /* now we convert second operand */
8263 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
8266 if (is_float(type
.t
)) {
8268 #ifdef TCC_TARGET_X86_64
8269 if ((type
.t
& VT_BTYPE
) == VT_LDOUBLE
) {
8273 } else if ((type
.t
& VT_BTYPE
) == VT_LLONG
) {
8274 /* for long longs, we use fixed registers to avoid having
8275 to handle a complicated move */
8280 /* this is horrible, but we must also convert first
8284 /* put again first value and cast it */
8287 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
8297 static void gexpr(void)
8308 /* parse an expression and return its type without any side effect. */
8309 static void expr_type(CType
*type
)
8311 int saved_nocode_wanted
;
8313 saved_nocode_wanted
= nocode_wanted
;
8318 nocode_wanted
= saved_nocode_wanted
;
8321 /* parse a unary expression and return its type without any side
8323 static void unary_type(CType
*type
)
8335 /* parse a constant expression and return value in vtop. */
8336 static void expr_const1(void)
8345 /* parse an integer constant and return its value. */
8346 static int expr_const(void)
8350 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
8351 expect("constant expression");
8357 /* return the label token if current token is a label, otherwise
8359 static int is_label(void)
8363 /* fast test first */
8364 if (tok
< TOK_UIDENT
)
8366 /* no need to save tokc because tok is an identifier */
8373 unget_tok(last_tok
);
8378 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
,
8379 int case_reg
, int is_expr
)
8384 /* generate line number info */
8386 (last_line_num
!= file
->line_num
|| last_ind
!= ind
)) {
8387 put_stabn(N_SLINE
, 0, file
->line_num
, ind
- func_ind
);
8389 last_line_num
= file
->line_num
;
8393 /* default return value is (void) */
8395 vtop
->type
.t
= VT_VOID
;
8398 if (tok
== TOK_IF
) {
8405 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
8407 if (c
== TOK_ELSE
) {
8411 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
8412 gsym(d
); /* patch else jmp */
8415 } else if (tok
== TOK_WHILE
) {
8423 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
8427 } else if (tok
== '{') {
8431 /* record local declaration stack position */
8433 llabel
= local_label_stack
;
8434 /* handle local labels declarations */
8435 if (tok
== TOK_LABEL
) {
8438 if (tok
< TOK_UIDENT
)
8439 expect("label identifier");
8440 label_push(&local_label_stack
, tok
, LABEL_DECLARED
);
8450 while (tok
!= '}') {
8455 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
8458 /* pop locally defined labels */
8459 label_pop(&local_label_stack
, llabel
);
8460 /* pop locally defined symbols */
8462 /* XXX: this solution makes only valgrind happy...
8463 triggered by gcc.c-torture/execute/20000917-1.c */
8465 switch(vtop
->type
.t
& VT_BTYPE
) {
8470 for(p
=vtop
->type
.ref
;p
;p
=p
->prev
)
8472 error("unsupported expression type");
8475 sym_pop(&local_stack
, s
);
8477 } else if (tok
== TOK_RETURN
) {
8481 gen_assign_cast(&func_vt
);
8482 if ((func_vt
.t
& VT_BTYPE
) == VT_STRUCT
) {
8484 /* if returning structure, must copy it to implicit
8485 first pointer arg location */
8488 size
= type_size(&func_vt
,&align
);
8491 if((vtop
->r
!= (VT_LOCAL
| VT_LVAL
) || (vtop
->c
.i
& 3))
8495 loc
= (loc
- size
) & -4;
8498 vset(&type
, VT_LOCAL
| VT_LVAL
, addr
);
8501 vset(&int_type
, VT_LOCAL
| VT_LVAL
, addr
);
8503 vtop
->type
= int_type
;
8509 vset(&type
, VT_LOCAL
| VT_LVAL
, func_vc
);
8512 /* copy structure value to pointer */
8517 } else if (is_float(func_vt
.t
)) {
8522 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
8525 rsym
= gjmp(rsym
); /* jmp */
8526 } else if (tok
== TOK_BREAK
) {
8529 error("cannot break");
8530 *bsym
= gjmp(*bsym
);
8533 } else if (tok
== TOK_CONTINUE
) {
8536 error("cannot continue");
8537 *csym
= gjmp(*csym
);
8540 } else if (tok
== TOK_FOR
) {
8567 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
8572 if (tok
== TOK_DO
) {
8577 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
8588 if (tok
== TOK_SWITCH
) {
8592 /* XXX: other types than integer */
8593 case_reg
= gv(RC_INT
);
8597 b
= gjmp(0); /* jump to first case */
8599 block(&a
, csym
, &b
, &c
, case_reg
, 0);
8600 /* if no default, jmp after switch */
8608 if (tok
== TOK_CASE
) {
8615 if (gnu_ext
&& tok
== TOK_DOTS
) {
8619 warning("empty case range");
8621 /* since a case is like a label, we must skip it with a jmp */
8628 *case_sym
= gtst(1, 0);
8631 *case_sym
= gtst(1, 0);
8635 *case_sym
= gtst(1, *case_sym
);
8640 goto block_after_label
;
8642 if (tok
== TOK_DEFAULT
) {
8648 error("too many 'default'");
8651 goto block_after_label
;
8653 if (tok
== TOK_GOTO
) {
8655 if (tok
== '*' && gnu_ext
) {
8659 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
)
8662 } else if (tok
>= TOK_UIDENT
) {
8663 s
= label_find(tok
);
8664 /* put forward definition if needed */
8666 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
8668 if (s
->r
== LABEL_DECLARED
)
8669 s
->r
= LABEL_FORWARD
;
8671 /* label already defined */
8672 if (s
->r
& LABEL_FORWARD
)
8673 s
->next
= (void *)gjmp((long)s
->next
);
8675 gjmp_addr((long)s
->next
);
8678 expect("label identifier");
8681 } else if (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
) {
8689 if (s
->r
== LABEL_DEFINED
)
8690 error("duplicate label '%s'", get_tok_str(s
->v
, NULL
));
8691 gsym((long)s
->next
);
8692 s
->r
= LABEL_DEFINED
;
8694 s
= label_push(&global_label_stack
, b
, LABEL_DEFINED
);
8696 s
->next
= (void *)ind
;
8697 /* we accept this, but it is a mistake */
8700 warning("deprecated use of label at end of compound statement");
8704 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
8707 /* expression case */
8722 /* t is the array or struct type. c is the array or struct
8723 address. cur_index/cur_field is the pointer to the current
8724 value. 'size_only' is true if only size info is needed (only used
8726 static void decl_designator(CType
*type
, Section
*sec
, unsigned long c
,
8727 int *cur_index
, Sym
**cur_field
,
8731 int notfirst
, index
, index_last
, align
, l
, nb_elems
, elem_size
;
8737 if (gnu_ext
&& (l
= is_label()) != 0)
8739 while (tok
== '[' || tok
== '.') {
8741 if (!(type
->t
& VT_ARRAY
))
8742 expect("array type");
8745 index
= expr_const();
8746 if (index
< 0 || (s
->c
>= 0 && index
>= s
->c
))
8747 expect("invalid index");
8748 if (tok
== TOK_DOTS
&& gnu_ext
) {
8750 index_last
= expr_const();
8751 if (index_last
< 0 ||
8752 (s
->c
>= 0 && index_last
>= s
->c
) ||
8754 expect("invalid index");
8760 *cur_index
= index_last
;
8761 type
= pointed_type(type
);
8762 elem_size
= type_size(type
, &align
);
8763 c
+= index
* elem_size
;
8764 /* NOTE: we only support ranges for last designator */
8765 nb_elems
= index_last
- index
+ 1;
8766 if (nb_elems
!= 1) {
8775 if ((type
->t
& VT_BTYPE
) != VT_STRUCT
)
8776 expect("struct/union type");
8789 /* XXX: fix this mess by using explicit storage field */
8791 type1
.t
|= (type
->t
& ~VT_TYPE
);
8805 if (type
->t
& VT_ARRAY
) {
8807 type
= pointed_type(type
);
8808 c
+= index
* type_size(type
, &align
);
8812 error("too many field init");
8813 /* XXX: fix this mess by using explicit storage field */
8815 type1
.t
|= (type
->t
& ~VT_TYPE
);
8820 decl_initializer(type
, sec
, c
, 0, size_only
);
8822 /* XXX: make it more general */
8823 if (!size_only
&& nb_elems
> 1) {
8824 unsigned long c_end
;
8829 error("range init not supported yet for dynamic storage");
8830 c_end
= c
+ nb_elems
* elem_size
;
8831 if (c_end
> sec
->data_allocated
)
8832 section_realloc(sec
, c_end
);
8833 src
= sec
->data
+ c
;
8835 for(i
= 1; i
< nb_elems
; i
++) {
8837 memcpy(dst
, src
, elem_size
);
8843 #define EXPR_CONST 1
8846 /* store a value or an expression directly in global data or in local array */
8847 static void init_putv(CType
*type
, Section
*sec
, unsigned long c
,
8848 int v
, int expr_type
)
8850 int saved_global_expr
, bt
, bit_pos
, bit_size
;
8852 unsigned long long bit_mask
;
8860 /* compound literals must be allocated globally in this case */
8861 saved_global_expr
= global_expr
;
8864 global_expr
= saved_global_expr
;
8865 /* NOTE: symbols are accepted */
8866 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) != VT_CONST
)
8867 error("initializer element is not constant");
8875 dtype
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
8878 /* XXX: not portable */
8879 /* XXX: generate error if incorrect relocation */
8880 gen_assign_cast(&dtype
);
8881 bt
= type
->t
& VT_BTYPE
;
8882 /* we'll write at most 12 bytes */
8883 if (c
+ 12 > sec
->data_allocated
) {
8884 section_realloc(sec
, c
+ 12);
8886 ptr
= sec
->data
+ c
;
8887 /* XXX: make code faster ? */
8888 if (!(type
->t
& VT_BITFIELD
)) {
8893 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
8894 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
8895 bit_mask
= (1LL << bit_size
) - 1;
8897 if ((vtop
->r
& VT_SYM
) &&
8903 (bt
== VT_INT
&& bit_size
!= 32)))
8904 error("initializer element is not computable at load time");
8907 vtop
->c
.i
= (vtop
->c
.i
!= 0);
8909 *(char *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
8912 *(short *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
8915 *(double *)ptr
= vtop
->c
.d
;
8918 *(long double *)ptr
= vtop
->c
.ld
;
8921 *(long long *)ptr
|= (vtop
->c
.ll
& bit_mask
) << bit_pos
;
8924 if (vtop
->r
& VT_SYM
) {
8925 greloc(sec
, vtop
->sym
, c
, R_DATA_32
);
8927 *(int *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
8932 vset(&dtype
, VT_LOCAL
|VT_LVAL
, c
);
8939 /* put zeros for variable based init */
8940 static void init_putz(CType
*t
, Section
*sec
, unsigned long c
, int size
)
8943 /* nothing to do because globals are already set to zero */
8945 vpush_global_sym(&func_old_type
, TOK_memset
);
8953 /* 't' contains the type and storage info. 'c' is the offset of the
8954 object in section 'sec'. If 'sec' is NULL, it means stack based
8955 allocation. 'first' is true if array '{' must be read (multi
8956 dimension implicit array init handling). 'size_only' is true if
8957 size only evaluation is wanted (only for arrays). */
8958 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
8959 int first
, int size_only
)
8961 int index
, array_length
, n
, no_oblock
, nb
, parlevel
, i
;
8962 int size1
, align1
, expr_type
;
8966 if (type
->t
& VT_ARRAY
) {
8970 t1
= pointed_type(type
);
8971 size1
= type_size(t1
, &align1
);
8974 if ((first
&& tok
!= TOK_LSTR
&& tok
!= TOK_STR
) ||
8980 /* only parse strings here if correct type (otherwise: handle
8981 them as ((w)char *) expressions */
8982 if ((tok
== TOK_LSTR
&&
8983 #ifdef TCC_TARGET_PE
8984 (t1
->t
& VT_BTYPE
) == VT_SHORT
&& (t1
->t
& VT_UNSIGNED
)
8986 (t1
->t
& VT_BTYPE
) == VT_INT
8988 ) || (tok
== TOK_STR
&& (t1
->t
& VT_BTYPE
) == VT_BYTE
)) {
8989 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
8994 /* compute maximum number of chars wanted */
8996 cstr_len
= cstr
->size
;
8998 cstr_len
= cstr
->size
/ sizeof(nwchar_t
);
9001 if (n
>= 0 && nb
> (n
- array_length
))
9002 nb
= n
- array_length
;
9005 warning("initializer-string for array is too long");
9006 /* in order to go faster for common case (char
9007 string in global variable, we handle it
9009 if (sec
&& tok
== TOK_STR
&& size1
== 1) {
9010 memcpy(sec
->data
+ c
+ array_length
, cstr
->data
, nb
);
9014 ch
= ((unsigned char *)cstr
->data
)[i
];
9016 ch
= ((nwchar_t
*)cstr
->data
)[i
];
9017 init_putv(t1
, sec
, c
+ (array_length
+ i
) * size1
,
9025 /* only add trailing zero if enough storage (no
9026 warning in this case since it is standard) */
9027 if (n
< 0 || array_length
< n
) {
9029 init_putv(t1
, sec
, c
+ (array_length
* size1
), 0, EXPR_VAL
);
9035 while (tok
!= '}') {
9036 decl_designator(type
, sec
, c
, &index
, NULL
, size_only
);
9037 if (n
>= 0 && index
>= n
)
9038 error("index too large");
9039 /* must put zero in holes (note that doing it that way
9040 ensures that it even works with designators) */
9041 if (!size_only
&& array_length
< index
) {
9042 init_putz(t1
, sec
, c
+ array_length
* size1
,
9043 (index
- array_length
) * size1
);
9046 if (index
> array_length
)
9047 array_length
= index
;
9048 /* special test for multi dimensional arrays (may not
9049 be strictly correct if designators are used at the
9051 if (index
>= n
&& no_oblock
)
9060 /* put zeros at the end */
9061 if (!size_only
&& n
>= 0 && array_length
< n
) {
9062 init_putz(t1
, sec
, c
+ array_length
* size1
,
9063 (n
- array_length
) * size1
);
9065 /* patch type size if needed */
9067 s
->c
= array_length
;
9068 } else if ((type
->t
& VT_BTYPE
) == VT_STRUCT
&&
9069 (sec
|| !first
|| tok
== '{')) {
9072 /* NOTE: the previous test is a specific case for automatic
9073 struct/union init */
9074 /* XXX: union needs only one init */
9076 /* XXX: this test is incorrect for local initializers
9077 beginning with ( without {. It would be much more difficult
9078 to do it correctly (ideally, the expression parser should
9079 be used in all cases) */
9085 while (tok
== '(') {
9089 if (!parse_btype(&type1
, &ad1
))
9091 type_decl(&type1
, &ad1
, &n
, TYPE_ABSTRACT
);
9093 if (!is_assignable_types(type
, &type1
))
9094 error("invalid type for cast");
9099 if (first
|| tok
== '{') {
9108 while (tok
!= '}') {
9109 decl_designator(type
, sec
, c
, NULL
, &f
, size_only
);
9111 if (!size_only
&& array_length
< index
) {
9112 init_putz(type
, sec
, c
+ array_length
,
9113 index
- array_length
);
9115 index
= index
+ type_size(&f
->type
, &align1
);
9116 if (index
> array_length
)
9117 array_length
= index
;
9119 if (no_oblock
&& f
== NULL
)
9125 /* put zeros at the end */
9126 if (!size_only
&& array_length
< n
) {
9127 init_putz(type
, sec
, c
+ array_length
,
9136 } else if (tok
== '{') {
9138 decl_initializer(type
, sec
, c
, first
, size_only
);
9140 } else if (size_only
) {
9141 /* just skip expression */
9143 while ((parlevel
> 0 || (tok
!= '}' && tok
!= ',')) &&
9147 else if (tok
== ')')
9152 /* currently, we always use constant expression for globals
9153 (may change for scripting case) */
9154 expr_type
= EXPR_CONST
;
9156 expr_type
= EXPR_ANY
;
9157 init_putv(type
, sec
, c
, 0, expr_type
);
9161 /* parse an initializer for type 't' if 'has_init' is non zero, and
9162 allocate space in local or global data space ('r' is either
9163 VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
9164 variable 'v' of scope 'scope' is declared before initializers are
9165 parsed. If 'v' is zero, then a reference to the new object is put
9166 in the value stack. If 'has_init' is 2, a special parsing is done
9167 to handle string constants. */
9168 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
9169 int has_init
, int v
, int scope
)
9171 int size
, align
, addr
, data_offset
;
9173 ParseState saved_parse_state
;
9174 TokenString init_str
;
9177 size
= type_size(type
, &align
);
9178 /* If unknown size, we must evaluate it before
9179 evaluating initializers because
9180 initializers can generate global data too
9181 (e.g. string pointers or ISOC99 compound
9182 literals). It also simplifies local
9183 initializers handling */
9184 tok_str_new(&init_str
);
9187 error("unknown type size");
9188 /* get all init string */
9189 if (has_init
== 2) {
9190 /* only get strings */
9191 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
9192 tok_str_add_tok(&init_str
);
9197 while (level
> 0 || (tok
!= ',' && tok
!= ';')) {
9199 error("unexpected end of file in initializer");
9200 tok_str_add_tok(&init_str
);
9203 else if (tok
== '}') {
9213 tok_str_add(&init_str
, -1);
9214 tok_str_add(&init_str
, 0);
9217 save_parse_state(&saved_parse_state
);
9219 macro_ptr
= init_str
.str
;
9221 decl_initializer(type
, NULL
, 0, 1, 1);
9222 /* prepare second initializer parsing */
9223 macro_ptr
= init_str
.str
;
9226 /* if still unknown size, error */
9227 size
= type_size(type
, &align
);
9229 error("unknown type size");
9231 /* take into account specified alignment if bigger */
9233 if (ad
->aligned
> align
)
9234 align
= ad
->aligned
;
9235 } else if (ad
->packed
) {
9238 if ((r
& VT_VALMASK
) == VT_LOCAL
) {
9240 if (do_bounds_check
&& (type
->t
& VT_ARRAY
))
9242 loc
= (loc
- size
) & -align
;
9244 /* handles bounds */
9245 /* XXX: currently, since we do only one pass, we cannot track
9246 '&' operators, so we add only arrays */
9247 if (do_bounds_check
&& (type
->t
& VT_ARRAY
)) {
9248 unsigned long *bounds_ptr
;
9249 /* add padding between regions */
9251 /* then add local bound info */
9252 bounds_ptr
= section_ptr_add(lbounds_section
, 2 * sizeof(unsigned long));
9253 bounds_ptr
[0] = addr
;
9254 bounds_ptr
[1] = size
;
9257 /* local variable */
9258 sym_push(v
, type
, r
, addr
);
9260 /* push local reference */
9261 vset(type
, r
, addr
);
9267 if (v
&& scope
== VT_CONST
) {
9268 /* see if the symbol was already defined */
9271 if (!is_compatible_types(&sym
->type
, type
))
9272 error("incompatible types for redefinition of '%s'",
9273 get_tok_str(v
, NULL
));
9274 if (sym
->type
.t
& VT_EXTERN
) {
9275 /* if the variable is extern, it was not allocated */
9276 sym
->type
.t
&= ~VT_EXTERN
;
9277 /* set array size if it was ommited in extern
9279 if ((sym
->type
.t
& VT_ARRAY
) &&
9280 sym
->type
.ref
->c
< 0 &&
9282 sym
->type
.ref
->c
= type
->ref
->c
;
9284 /* we accept several definitions of the same
9285 global variable. this is tricky, because we
9286 must play with the SHN_COMMON type of the symbol */
9287 /* XXX: should check if the variable was already
9288 initialized. It is incorrect to initialized it
9290 /* no init data, we won't add more to the symbol */
9297 /* allocate symbol in corresponding section */
9302 else if (tcc_state
->nocommon
)
9306 data_offset
= sec
->data_offset
;
9307 data_offset
= (data_offset
+ align
- 1) & -align
;
9309 /* very important to increment global pointer at this time
9310 because initializers themselves can create new initializers */
9311 data_offset
+= size
;
9312 /* add padding if bound check */
9313 if (do_bounds_check
)
9315 sec
->data_offset
= data_offset
;
9316 /* allocate section space to put the data */
9317 if (sec
->sh_type
!= SHT_NOBITS
&&
9318 data_offset
> sec
->data_allocated
)
9319 section_realloc(sec
, data_offset
);
9320 /* align section if needed */
9321 if (align
> sec
->sh_addralign
)
9322 sec
->sh_addralign
= align
;
9324 addr
= 0; /* avoid warning */
9328 if (scope
!= VT_CONST
|| !sym
) {
9329 sym
= sym_push(v
, type
, r
| VT_SYM
, 0);
9331 /* update symbol definition */
9333 put_extern_sym(sym
, sec
, addr
, size
);
9336 /* put a common area */
9337 put_extern_sym(sym
, NULL
, align
, size
);
9338 /* XXX: find a nicer way */
9339 esym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
];
9340 esym
->st_shndx
= SHN_COMMON
;
9345 /* push global reference */
9346 sym
= get_sym_ref(type
, sec
, addr
, size
);
9348 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
9352 /* handles bounds now because the symbol must be defined
9353 before for the relocation */
9354 if (do_bounds_check
) {
9355 unsigned long *bounds_ptr
;
9357 greloc(bounds_section
, sym
, bounds_section
->data_offset
, R_DATA_32
);
9358 /* then add global bound info */
9359 bounds_ptr
= section_ptr_add(bounds_section
, 2 * sizeof(long));
9360 bounds_ptr
[0] = 0; /* relocated */
9361 bounds_ptr
[1] = size
;
9365 decl_initializer(type
, sec
, addr
, 1, 0);
9366 /* restore parse state if needed */
9368 tok_str_free(init_str
.str
);
9369 restore_parse_state(&saved_parse_state
);
9375 void put_func_debug(Sym
*sym
)
9380 /* XXX: we put here a dummy type */
9381 snprintf(buf
, sizeof(buf
), "%s:%c1",
9382 funcname
, sym
->type
.t
& VT_STATIC
? 'f' : 'F');
9383 put_stabs_r(buf
, N_FUN
, 0, file
->line_num
, 0,
9384 cur_text_section
, sym
->c
);
9385 /* //gr gdb wants a line at the function */
9386 put_stabn(N_SLINE
, 0, file
->line_num
, 0);
9391 /* parse an old style function declaration list */
9392 /* XXX: check multiple parameter */
9393 static void func_decl_list(Sym
*func_sym
)
9400 /* parse each declaration */
9401 while (tok
!= '{' && tok
!= ';' && tok
!= ',' && tok
!= TOK_EOF
) {
9402 if (!parse_btype(&btype
, &ad
))
9403 expect("declaration list");
9404 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
9405 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
9407 /* we accept no variable after */
9411 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
9412 /* find parameter in function parameter list */
9415 if ((s
->v
& ~SYM_FIELD
) == v
)
9419 error("declaration for parameter '%s' but no such parameter",
9420 get_tok_str(v
, NULL
));
9422 /* check that no storage specifier except 'register' was given */
9423 if (type
.t
& VT_STORAGE
)
9424 error("storage class specified for '%s'", get_tok_str(v
, NULL
));
9425 convert_parameter_type(&type
);
9426 /* we can add the type (NOTE: it could be local to the function) */
9428 /* accept other parameters */
9439 /* parse a function defined by symbol 'sym' and generate its code in
9440 'cur_text_section' */
9441 static void gen_function(Sym
*sym
)
9443 int saved_nocode_wanted
= nocode_wanted
;
9445 ind
= cur_text_section
->data_offset
;
9446 /* NOTE: we patch the symbol size later */
9447 put_extern_sym(sym
, cur_text_section
, ind
, 0);
9448 funcname
= get_tok_str(sym
->v
, NULL
);
9450 /* put debug symbol */
9452 put_func_debug(sym
);
9453 /* push a dummy symbol to enable local sym storage */
9454 sym_push2(&local_stack
, SYM_FIELD
, 0, 0);
9455 gfunc_prolog(&sym
->type
);
9457 block(NULL
, NULL
, NULL
, NULL
, 0, 0);
9460 cur_text_section
->data_offset
= ind
;
9461 label_pop(&global_label_stack
, NULL
);
9462 sym_pop(&local_stack
, NULL
); /* reset local stack */
9463 /* end of function */
9464 /* patch symbol size */
9465 ((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
].st_size
=
9468 put_stabn(N_FUN
, 0, 0, ind
- func_ind
);
9470 /* It's better to crash than to generate wrong code */
9471 cur_text_section
= NULL
;
9472 funcname
= ""; /* for safety */
9473 func_vt
.t
= VT_VOID
; /* for safety */
9474 ind
= 0; /* for safety */
9475 nocode_wanted
= saved_nocode_wanted
;
9478 static void gen_inline_functions(void)
9482 int *str
, inline_generated
;
9484 /* iterate while inline function are referenced */
9486 inline_generated
= 0;
9487 for(sym
= global_stack
; sym
!= NULL
; sym
= sym
->prev
) {
9489 if (((type
->t
& VT_BTYPE
) == VT_FUNC
) &&
9490 (type
->t
& (VT_STATIC
| VT_INLINE
)) ==
9491 (VT_STATIC
| VT_INLINE
) &&
9493 /* the function was used: generate its code and
9494 convert it to a normal function */
9495 str
= INLINE_DEF(sym
->r
);
9496 sym
->r
= VT_SYM
| VT_CONST
;
9497 sym
->type
.t
&= ~VT_INLINE
;
9501 cur_text_section
= text_section
;
9503 macro_ptr
= NULL
; /* fail safe */
9506 inline_generated
= 1;
9509 if (!inline_generated
)
9513 /* free all remaining inline function tokens */
9514 for(sym
= global_stack
; sym
!= NULL
; sym
= sym
->prev
) {
9516 if (((type
->t
& VT_BTYPE
) == VT_FUNC
) &&
9517 (type
->t
& (VT_STATIC
| VT_INLINE
)) ==
9518 (VT_STATIC
| VT_INLINE
)) {
9519 //gr printf("sym %d %s\n", sym->r, get_tok_str(sym->v, NULL));
9520 if (sym
->r
== (VT_SYM
| VT_CONST
)) //gr beware!
9522 str
= INLINE_DEF(sym
->r
);
9524 sym
->r
= 0; /* fail safe */
9529 /* 'l' is VT_LOCAL or VT_CONST to define default storage type */
9530 static void decl(int l
)
9538 if (!parse_btype(&btype
, &ad
)) {
9539 /* skip redundant ';' */
9540 /* XXX: find more elegant solution */
9545 if (l
== VT_CONST
&&
9546 (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
)) {
9547 /* global asm block */
9551 /* special test for old K&R protos without explicit int
9552 type. Only accepted when defining global data */
9553 if (l
== VT_LOCAL
|| tok
< TOK_DEFINE
)
9557 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
9558 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
9560 /* we accept no variable after */
9564 while (1) { /* iterate thru each declaration */
9566 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
9570 type_to_str(buf
, sizeof(buf
), t
, get_tok_str(v
, NULL
));
9571 printf("type = '%s'\n", buf
);
9574 if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
9575 /* if old style function prototype, we accept a
9578 if (sym
->c
== FUNC_OLD
)
9579 func_decl_list(sym
);
9584 error("cannot use local functions");
9585 if ((type
.t
& VT_BTYPE
) != VT_FUNC
)
9586 expect("function definition");
9588 /* reject abstract declarators in function definition */
9590 while ((sym
= sym
->next
) != NULL
)
9591 if (!(sym
->v
& ~SYM_FIELD
))
9592 expect("identifier");
9594 /* XXX: cannot do better now: convert extern line to static inline */
9595 if ((type
.t
& (VT_EXTERN
| VT_INLINE
)) == (VT_EXTERN
| VT_INLINE
))
9596 type
.t
= (type
.t
& ~VT_EXTERN
) | VT_STATIC
;
9600 if ((sym
->type
.t
& VT_BTYPE
) != VT_FUNC
)
9602 /* specific case: if not func_call defined, we put
9603 the one of the prototype */
9604 /* XXX: should have default value */
9605 r
= sym
->type
.ref
->r
;
9606 if (FUNC_CALL(r
) != FUNC_CDECL
9607 && FUNC_CALL(type
.ref
->r
) == FUNC_CDECL
)
9608 FUNC_CALL(type
.ref
->r
) = FUNC_CALL(r
);
9610 FUNC_EXPORT(type
.ref
->r
) = 1;
9612 if (!is_compatible_types(&sym
->type
, &type
)) {
9614 error("incompatible types for redefinition of '%s'",
9615 get_tok_str(v
, NULL
));
9617 /* if symbol is already defined, then put complete type */
9620 /* put function symbol */
9621 sym
= global_identifier_push(v
, type
.t
, 0);
9622 sym
->type
.ref
= type
.ref
;
9625 /* static inline functions are just recorded as a kind
9626 of macro. Their code will be emitted at the end of
9627 the compilation unit only if they are used */
9628 if ((type
.t
& (VT_INLINE
| VT_STATIC
)) ==
9629 (VT_INLINE
| VT_STATIC
)) {
9630 TokenString func_str
;
9633 tok_str_new(&func_str
);
9639 error("unexpected end of file");
9640 tok_str_add_tok(&func_str
);
9645 } else if (t
== '}') {
9647 if (block_level
== 0)
9651 tok_str_add(&func_str
, -1);
9652 tok_str_add(&func_str
, 0);
9653 INLINE_DEF(sym
->r
) = func_str
.str
;
9655 /* compute text section */
9656 cur_text_section
= ad
.section
;
9657 if (!cur_text_section
)
9658 cur_text_section
= text_section
;
9659 sym
->r
= VT_SYM
| VT_CONST
;
9664 if (btype
.t
& VT_TYPEDEF
) {
9665 /* save typedefed type */
9666 /* XXX: test storage specifiers ? */
9667 sym
= sym_push(v
, &type
, 0, 0);
9668 sym
->type
.t
|= VT_TYPEDEF
;
9669 } else if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
9670 /* external function definition */
9671 /* specific case for func_call attribute */
9673 type
.ref
->r
= ad
.func_attr
;
9674 external_sym(v
, &type
, 0);
9676 /* not lvalue if array */
9678 if (!(type
.t
& VT_ARRAY
))
9679 r
|= lvalue_type(type
.t
);
9680 has_init
= (tok
== '=');
9681 if ((btype
.t
& VT_EXTERN
) ||
9682 ((type
.t
& VT_ARRAY
) && (type
.t
& VT_STATIC
) &&
9683 !has_init
&& l
== VT_CONST
&& type
.ref
->c
< 0)) {
9684 /* external variable */
9685 /* NOTE: as GCC, uninitialized global static
9686 arrays of null size are considered as
9688 external_sym(v
, &type
, r
);
9690 type
.t
|= (btype
.t
& VT_STATIC
); /* Retain "static". */
9691 if (type
.t
& VT_STATIC
)
9697 decl_initializer_alloc(&type
, &ad
, r
,
9711 /* better than nothing, but needs extension to handle '-E' option
9713 static void preprocess_init(TCCState
*s1
)
9715 s1
->include_stack_ptr
= s1
->include_stack
;
9716 /* XXX: move that before to avoid having to initialize
9717 file->ifdef_stack_ptr ? */
9718 s1
->ifdef_stack_ptr
= s1
->ifdef_stack
;
9719 file
->ifdef_stack_ptr
= s1
->ifdef_stack_ptr
;
9721 /* XXX: not ANSI compliant: bound checking says error */
9723 s1
->pack_stack
[0] = 0;
9724 s1
->pack_stack_ptr
= s1
->pack_stack
;
9727 /* compile the C file opened in 'file'. Return non zero if errors. */
9728 static int tcc_compile(TCCState
*s1
)
9732 volatile int section_sym
;
9735 printf("%s: **** new file\n", file
->filename
);
9737 preprocess_init(s1
);
9739 cur_text_section
= NULL
;
9741 anon_sym
= SYM_FIRST_ANOM
;
9743 /* file info: full path + filename */
9744 section_sym
= 0; /* avoid warning */
9746 section_sym
= put_elf_sym(symtab_section
, 0, 0,
9747 ELFW(ST_INFO
)(STB_LOCAL
, STT_SECTION
), 0,
9748 text_section
->sh_num
, NULL
);
9749 getcwd(buf
, sizeof(buf
));
9751 normalize_slashes(buf
);
9753 pstrcat(buf
, sizeof(buf
), "/");
9754 put_stabs_r(buf
, N_SO
, 0, 0,
9755 text_section
->data_offset
, text_section
, section_sym
);
9756 put_stabs_r(file
->filename
, N_SO
, 0, 0,
9757 text_section
->data_offset
, text_section
, section_sym
);
9759 /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
9760 symbols can be safely used */
9761 put_elf_sym(symtab_section
, 0, 0,
9762 ELFW(ST_INFO
)(STB_LOCAL
, STT_FILE
), 0,
9763 SHN_ABS
, file
->filename
);
9765 /* define some often used types */
9766 int_type
.t
= VT_INT
;
9768 char_pointer_type
.t
= VT_BYTE
;
9769 mk_pointer(&char_pointer_type
);
9771 func_old_type
.t
= VT_FUNC
;
9772 func_old_type
.ref
= sym_push(SYM_FIELD
, &int_type
, FUNC_CDECL
, FUNC_OLD
);
9774 #if defined(TCC_ARM_EABI) && defined(TCC_ARM_VFP)
9775 float_type
.t
= VT_FLOAT
;
9776 double_type
.t
= VT_DOUBLE
;
9778 func_float_type
.t
= VT_FUNC
;
9779 func_float_type
.ref
= sym_push(SYM_FIELD
, &float_type
, FUNC_CDECL
, FUNC_OLD
);
9780 func_double_type
.t
= VT_FUNC
;
9781 func_double_type
.ref
= sym_push(SYM_FIELD
, &double_type
, FUNC_CDECL
, FUNC_OLD
);
9785 /* define 'void *alloca(unsigned int)' builtin function */
9790 sym
= sym_push(p
, mk_pointer(VT_VOID
), FUNC_CDECL
, FUNC_NEW
);
9791 s1
= sym_push(SYM_FIELD
, VT_UNSIGNED
| VT_INT
, 0, 0);
9794 sym_push(TOK_alloca
, VT_FUNC
| (p
<< VT_STRUCT_SHIFT
), VT_CONST
, 0);
9798 define_start
= define_stack
;
9801 if (setjmp(s1
->error_jmp_buf
) == 0) {
9803 s1
->error_set_jmp_enabled
= 1;
9805 ch
= file
->buf_ptr
[0];
9806 tok_flags
= TOK_FLAG_BOL
| TOK_FLAG_BOF
;
9807 parse_flags
= PARSE_FLAG_PREPROCESS
| PARSE_FLAG_TOK_NUM
;
9811 expect("declaration");
9813 /* end of translation unit info */
9815 put_stabs_r(NULL
, N_SO
, 0, 0,
9816 text_section
->data_offset
, text_section
, section_sym
);
9819 s1
->error_set_jmp_enabled
= 0;
9821 /* reset define stack, but leave -Dsymbols (may be incorrect if
9822 they are undefined) */
9823 free_defines(define_start
);
9825 gen_inline_functions();
9827 sym_pop(&global_stack
, NULL
);
9828 sym_pop(&local_stack
, NULL
);
9830 return s1
->nb_errors
!= 0 ? -1 : 0;
9833 /* Preprocess the current file */
9834 /* XXX: add line and file infos,
9835 * XXX: add options to preserve spaces (partly done, only spaces in macro are
9838 static int tcc_preprocess(TCCState
*s1
)
9841 BufferedFile
*file_ref
;
9842 int token_seen
, line_ref
;
9844 preprocess_init(s1
);
9845 define_start
= define_stack
;
9846 ch
= file
->buf_ptr
[0];
9848 tok_flags
= TOK_FLAG_BOL
| TOK_FLAG_BOF
;
9849 parse_flags
= PARSE_FLAG_ASM_COMMENTS
| PARSE_FLAG_PREPROCESS
|
9850 PARSE_FLAG_LINEFEED
;
9858 if (tok
== TOK_EOF
) {
9860 } else if (tok
== TOK_LINEFEED
) {
9865 } else if (token_seen
) {
9866 fwrite(tok_spaces
.data
, tok_spaces
.size
, 1, s1
->outfile
);
9868 int d
= file
->line_num
- line_ref
;
9869 if (file
!= file_ref
|| d
< 0 || d
>= 8)
9870 fprintf(s1
->outfile
, "# %d \"%s\"\n", file
->line_num
, file
->filename
);
9873 fputs("\n", s1
->outfile
), --d
;
9874 line_ref
= (file_ref
= file
)->line_num
;
9877 fputs(get_tok_str(tok
, &tokc
), s1
->outfile
);
9879 free_defines(define_start
);
9884 int tcc_compile_string(TCCState
*s
, const char *str
)
9886 BufferedFile bf1
, *bf
= &bf1
;
9890 /* init file structure */
9892 /* XXX: avoid copying */
9894 buf
= tcc_malloc(len
+ 1);
9897 memcpy(buf
, str
, len
);
9900 bf
->buf_end
= buf
+ len
;
9901 pstrcpy(bf
->filename
, sizeof(bf
->filename
), "<string>");
9904 ret
= tcc_compile(s
);
9908 /* currently, no need to close */
9913 /* define a preprocessor symbol. A value can also be provided with the '=' operator */
9914 void tcc_define_symbol(TCCState
*s1
, const char *sym
, const char *value
)
9916 BufferedFile bf1
, *bf
= &bf1
;
9918 pstrcpy(bf
->buffer
, IO_BUF_SIZE
, sym
);
9919 pstrcat(bf
->buffer
, IO_BUF_SIZE
, " ");
9923 pstrcat(bf
->buffer
, IO_BUF_SIZE
, value
);
9925 /* init file structure */
9927 bf
->buf_ptr
= bf
->buffer
;
9928 bf
->buf_end
= bf
->buffer
+ strlen(bf
->buffer
);
9929 *bf
->buf_end
= CH_EOB
;
9930 bf
->filename
[0] = '\0';
9934 s1
->include_stack_ptr
= s1
->include_stack
;
9936 /* parse with define parser */
9937 ch
= file
->buf_ptr
[0];
9943 /* undefine a preprocessor symbol */
9944 void tcc_undefine_symbol(TCCState
*s1
, const char *sym
)
9948 ts
= tok_alloc(sym
, strlen(sym
));
9949 s
= define_find(ts
->tok
);
9950 /* undefine symbol by putting an invalid name */
9955 #ifdef CONFIG_TCC_ASM
9957 #ifdef TCC_TARGET_I386
9958 #include "i386-asm.c"
9963 static void asm_instr(void)
9965 error("inline asm() not supported");
9967 static void asm_global_instr(void)
9969 error("inline asm() not supported");
9975 #ifdef TCC_TARGET_COFF
9976 #include "tcccoff.c"
9979 #ifdef TCC_TARGET_PE
9983 /* print the position in the source file of PC value 'pc' by reading
9984 the stabs debug information */
9985 static void rt_printline(unsigned long wanted_pc
)
9987 Stab_Sym
*sym
, *sym_end
;
9988 char func_name
[128], last_func_name
[128];
9989 unsigned long func_addr
, last_pc
, pc
;
9990 const char *incl_files
[INCLUDE_STACK_SIZE
];
9991 int incl_index
, len
, last_line_num
, i
;
9992 const char *str
, *p
;
9994 fprintf(stderr
, "0x%08lx:", wanted_pc
);
9996 func_name
[0] = '\0';
9999 last_func_name
[0] = '\0';
10000 last_pc
= 0xffffffff;
10002 sym
= (Stab_Sym
*)stab_section
->data
+ 1;
10003 sym_end
= (Stab_Sym
*)(stab_section
->data
+ stab_section
->data_offset
);
10004 while (sym
< sym_end
) {
10005 switch(sym
->n_type
) {
10006 /* function start or end */
10008 if (sym
->n_strx
== 0) {
10009 /* we test if between last line and end of function */
10010 pc
= sym
->n_value
+ func_addr
;
10011 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
10013 func_name
[0] = '\0';
10016 str
= stabstr_section
->data
+ sym
->n_strx
;
10017 p
= strchr(str
, ':');
10019 pstrcpy(func_name
, sizeof(func_name
), str
);
10022 if (len
> sizeof(func_name
) - 1)
10023 len
= sizeof(func_name
) - 1;
10024 memcpy(func_name
, str
, len
);
10025 func_name
[len
] = '\0';
10027 func_addr
= sym
->n_value
;
10030 /* line number info */
10032 pc
= sym
->n_value
+ func_addr
;
10033 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
10036 last_line_num
= sym
->n_desc
;
10038 strcpy(last_func_name
, func_name
);
10040 /* include files */
10042 str
= stabstr_section
->data
+ sym
->n_strx
;
10044 if (incl_index
< INCLUDE_STACK_SIZE
) {
10045 incl_files
[incl_index
++] = str
;
10049 if (incl_index
> 1)
10053 if (sym
->n_strx
== 0) {
10054 incl_index
= 0; /* end of translation unit */
10056 str
= stabstr_section
->data
+ sym
->n_strx
;
10057 /* do not add path */
10059 if (len
> 0 && str
[len
- 1] != '/')
10067 /* second pass: we try symtab symbols (no line number info) */
10070 ElfW(Sym
) *sym
, *sym_end
;
10073 sym_end
= (ElfW(Sym
) *)(symtab_section
->data
+ symtab_section
->data_offset
);
10074 for(sym
= (ElfW(Sym
) *)symtab_section
->data
+ 1;
10077 type
= ELFW(ST_TYPE
)(sym
->st_info
);
10078 if (type
== STT_FUNC
) {
10079 if (wanted_pc
>= sym
->st_value
&&
10080 wanted_pc
< sym
->st_value
+ sym
->st_size
) {
10081 pstrcpy(last_func_name
, sizeof(last_func_name
),
10082 strtab_section
->data
+ sym
->st_name
);
10088 /* did not find any info: */
10089 fprintf(stderr
, " ???\n");
10092 if (last_func_name
[0] != '\0') {
10093 fprintf(stderr
, " %s()", last_func_name
);
10095 if (incl_index
> 0) {
10096 fprintf(stderr
, " (%s:%d",
10097 incl_files
[incl_index
- 1], last_line_num
);
10098 for(i
= incl_index
- 2; i
>= 0; i
--)
10099 fprintf(stderr
, ", included from %s", incl_files
[i
]);
10100 fprintf(stderr
, ")");
10102 fprintf(stderr
, "\n");
10105 #if !defined(_WIN32) && !defined(CONFIG_TCCBOOT)
10109 /* fix for glibc 2.1 */
10111 #define REG_EIP EIP
10112 #define REG_EBP EBP
10115 /* return the PC at frame level 'level'. Return non zero if not found */
10116 static int rt_get_caller_pc(unsigned long *paddr
,
10117 ucontext_t
*uc
, int level
)
10123 #if defined(__FreeBSD__)
10124 *paddr
= uc
->uc_mcontext
.mc_eip
;
10125 #elif defined(__dietlibc__)
10126 *paddr
= uc
->uc_mcontext
.eip
;
10128 *paddr
= uc
->uc_mcontext
.gregs
[REG_EIP
];
10132 #if defined(__FreeBSD__)
10133 fp
= uc
->uc_mcontext
.mc_ebp
;
10134 #elif defined(__dietlibc__)
10135 fp
= uc
->uc_mcontext
.ebp
;
10137 fp
= uc
->uc_mcontext
.gregs
[REG_EBP
];
10139 for(i
=1;i
<level
;i
++) {
10140 /* XXX: check address validity with program info */
10141 if (fp
<= 0x1000 || fp
>= 0xc0000000)
10143 fp
= ((unsigned long *)fp
)[0];
10145 *paddr
= ((unsigned long *)fp
)[1];
10149 #elif defined(__x86_64__)
10150 /* return the PC at frame level 'level'. Return non zero if not found */
10151 static int rt_get_caller_pc(unsigned long *paddr
,
10152 ucontext_t
*uc
, int level
)
10158 /* XXX: only support linux */
10159 *paddr
= uc
->uc_mcontext
.gregs
[REG_RIP
];
10162 fp
= uc
->uc_mcontext
.gregs
[REG_RBP
];
10163 for(i
=1;i
<level
;i
++) {
10164 /* XXX: check address validity with program info */
10165 if (fp
<= 0x1000 || fp
>= 0xc0000000)
10167 fp
= ((unsigned long *)fp
)[0];
10169 *paddr
= ((unsigned long *)fp
)[1];
10175 #warning add arch specific rt_get_caller_pc()
10177 static int rt_get_caller_pc(unsigned long *paddr
,
10178 ucontext_t
*uc
, int level
)
10184 /* emit a run time error at position 'pc' */
10185 void rt_error(ucontext_t
*uc
, const char *fmt
, ...)
10192 fprintf(stderr
, "Runtime error: ");
10193 vfprintf(stderr
, fmt
, ap
);
10194 fprintf(stderr
, "\n");
10195 for(i
=0;i
<num_callers
;i
++) {
10196 if (rt_get_caller_pc(&pc
, uc
, i
) < 0)
10199 fprintf(stderr
, "at ");
10201 fprintf(stderr
, "by ");
10208 /* signal handler for fatal errors */
10209 static void sig_error(int signum
, siginfo_t
*siginf
, void *puc
)
10211 ucontext_t
*uc
= puc
;
10215 switch(siginf
->si_code
) {
10218 rt_error(uc
, "division by zero");
10221 rt_error(uc
, "floating point exception");
10227 if (rt_bound_error_msg
&& *rt_bound_error_msg
)
10228 rt_error(uc
, *rt_bound_error_msg
);
10230 rt_error(uc
, "dereferencing invalid pointer");
10233 rt_error(uc
, "illegal instruction");
10236 rt_error(uc
, "abort() called");
10239 rt_error(uc
, "caught signal %d", signum
);
10246 /* do all relocations (needed before using tcc_get_symbol()) */
10247 int tcc_relocate(TCCState
*s1
)
10254 #ifdef TCC_TARGET_PE
10255 pe_add_runtime(s1
);
10257 tcc_add_runtime(s1
);
10260 relocate_common_syms();
10262 tcc_add_linker_symbols(s1
);
10263 #ifndef TCC_TARGET_PE
10264 build_got_entries(s1
);
10266 /* compute relocation address : section are relocated in place. We
10267 also alloc the bss space */
10268 for(i
= 1; i
< s1
->nb_sections
; i
++) {
10269 s
= s1
->sections
[i
];
10270 if (s
->sh_flags
& SHF_ALLOC
) {
10271 if (s
->sh_type
== SHT_NOBITS
)
10272 s
->data
= tcc_mallocz(s
->data_offset
);
10273 s
->sh_addr
= (unsigned long)s
->data
;
10277 relocate_syms(s1
, 1);
10279 if (s1
->nb_errors
!= 0)
10282 /* relocate each section */
10283 for(i
= 1; i
< s1
->nb_sections
; i
++) {
10284 s
= s1
->sections
[i
];
10286 relocate_section(s1
, s
);
10289 /* mark executable sections as executable in memory */
10290 for(i
= 1; i
< s1
->nb_sections
; i
++) {
10291 s
= s1
->sections
[i
];
10292 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_EXECINSTR
)) ==
10293 (SHF_ALLOC
| SHF_EXECINSTR
))
10294 set_pages_executable(s
->data
, s
->data_offset
);
10299 /* launch the compiled program with the given arguments */
10300 int tcc_run(TCCState
*s1
, int argc
, char **argv
)
10302 int (*prog_main
)(int, char **);
10304 if (tcc_relocate(s1
) < 0)
10307 prog_main
= tcc_get_symbol_err(s1
, "main");
10310 #if defined(_WIN32) || defined(CONFIG_TCCBOOT)
10311 error("debug mode currently not available for Windows");
10313 struct sigaction sigact
;
10314 /* install TCC signal handlers to print debug info on fatal
10316 sigact
.sa_flags
= SA_SIGINFO
| SA_RESETHAND
;
10317 sigact
.sa_sigaction
= sig_error
;
10318 sigemptyset(&sigact
.sa_mask
);
10319 sigaction(SIGFPE
, &sigact
, NULL
);
10320 sigaction(SIGILL
, &sigact
, NULL
);
10321 sigaction(SIGSEGV
, &sigact
, NULL
);
10322 sigaction(SIGBUS
, &sigact
, NULL
);
10323 sigaction(SIGABRT
, &sigact
, NULL
);
10327 #ifdef CONFIG_TCC_BCHECK
10328 if (do_bounds_check
) {
10329 void (*bound_init
)(void);
10331 /* set error function */
10332 rt_bound_error_msg
= (void *)tcc_get_symbol_err(s1
,
10333 "__bound_error_msg");
10335 /* XXX: use .init section so that it also work in binary ? */
10336 bound_init
= (void *)tcc_get_symbol_err(s1
, "__bound_init");
10340 return (*prog_main
)(argc
, argv
);
10343 void tcc_memstats(void)
10346 printf("memory in use: %d\n", mem_cur_size
);
10350 static void tcc_cleanup(void)
10354 if (NULL
== tcc_state
)
10358 /* free -D defines */
10359 free_defines(NULL
);
10362 n
= tok_ident
- TOK_IDENT
;
10363 for(i
= 0; i
< n
; i
++)
10364 tcc_free(table_ident
[i
]);
10365 tcc_free(table_ident
);
10367 /* free sym_pools */
10368 dynarray_reset(&sym_pools
, &nb_sym_pools
);
10369 /* string buffer */
10370 cstr_free(&tokcstr
);
10371 /* reset symbol stack */
10372 sym_free_first
= NULL
;
10373 /* cleanup from error/setjmp */
10377 TCCState
*tcc_new(void)
10386 s
= tcc_mallocz(sizeof(TCCState
));
10390 s
->output_type
= TCC_OUTPUT_MEMORY
;
10392 /* init isid table */
10393 for(i
=CH_EOF
;i
<256;i
++)
10394 isidnum_table
[i
-CH_EOF
] = isid(i
) || isnum(i
);
10396 /* add all tokens */
10397 table_ident
= NULL
;
10398 memset(hash_ident
, 0, TOK_HASH_SIZE
* sizeof(TokenSym
*));
10400 tok_ident
= TOK_IDENT
;
10409 ts
= tok_alloc(p
, r
- p
- 1);
10413 /* we add dummy defines for some special macros to speed up tests
10414 and to have working defined() */
10415 define_push(TOK___LINE__
, MACRO_OBJ
, NULL
, NULL
);
10416 define_push(TOK___FILE__
, MACRO_OBJ
, NULL
, NULL
);
10417 define_push(TOK___DATE__
, MACRO_OBJ
, NULL
, NULL
);
10418 define_push(TOK___TIME__
, MACRO_OBJ
, NULL
, NULL
);
10420 /* standard defines */
10421 tcc_define_symbol(s
, "__STDC__", NULL
);
10422 tcc_define_symbol(s
, "__STDC_VERSION__", "199901L");
10423 #if defined(TCC_TARGET_I386)
10424 tcc_define_symbol(s
, "__i386__", NULL
);
10426 #if defined(TCC_TARGET_X86_64)
10427 tcc_define_symbol(s
, "__x86_64__", NULL
);
10429 #if defined(TCC_TARGET_ARM)
10430 tcc_define_symbol(s
, "__ARM_ARCH_4__", NULL
);
10431 tcc_define_symbol(s
, "__arm_elf__", NULL
);
10432 tcc_define_symbol(s
, "__arm_elf", NULL
);
10433 tcc_define_symbol(s
, "arm_elf", NULL
);
10434 tcc_define_symbol(s
, "__arm__", NULL
);
10435 tcc_define_symbol(s
, "__arm", NULL
);
10436 tcc_define_symbol(s
, "arm", NULL
);
10437 tcc_define_symbol(s
, "__APCS_32__", NULL
);
10439 #ifdef TCC_TARGET_PE
10440 tcc_define_symbol(s
, "_WIN32", NULL
);
10442 tcc_define_symbol(s
, "__unix__", NULL
);
10443 tcc_define_symbol(s
, "__unix", NULL
);
10444 #if defined(__linux)
10445 tcc_define_symbol(s
, "__linux__", NULL
);
10446 tcc_define_symbol(s
, "__linux", NULL
);
10449 /* tiny C specific defines */
10450 tcc_define_symbol(s
, "__TINYC__", NULL
);
10452 /* tiny C & gcc defines */
10453 tcc_define_symbol(s
, "__SIZE_TYPE__", "unsigned int");
10454 tcc_define_symbol(s
, "__PTRDIFF_TYPE__", "int");
10455 #ifdef TCC_TARGET_PE
10456 tcc_define_symbol(s
, "__WCHAR_TYPE__", "unsigned short");
10458 tcc_define_symbol(s
, "__WCHAR_TYPE__", "int");
10461 #ifndef TCC_TARGET_PE
10462 /* default library paths */
10463 tcc_add_library_path(s
, CONFIG_SYSROOT
"/usr/local/lib");
10464 tcc_add_library_path(s
, CONFIG_SYSROOT
"/usr/lib");
10465 tcc_add_library_path(s
, CONFIG_SYSROOT
"/lib");
10468 /* no section zero */
10469 dynarray_add((void ***)&s
->sections
, &s
->nb_sections
, NULL
);
10471 /* create standard sections */
10472 text_section
= new_section(s
, ".text", SHT_PROGBITS
, SHF_ALLOC
| SHF_EXECINSTR
);
10473 data_section
= new_section(s
, ".data", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
10474 bss_section
= new_section(s
, ".bss", SHT_NOBITS
, SHF_ALLOC
| SHF_WRITE
);
10476 /* symbols are always generated for linking stage */
10477 symtab_section
= new_symtab(s
, ".symtab", SHT_SYMTAB
, 0,
10479 ".hashtab", SHF_PRIVATE
);
10480 strtab_section
= symtab_section
->link
;
10482 /* private symbol table for dynamic symbols */
10483 s
->dynsymtab_section
= new_symtab(s
, ".dynsymtab", SHT_SYMTAB
, SHF_PRIVATE
,
10485 ".dynhashtab", SHF_PRIVATE
);
10486 s
->alacarte_link
= 1;
10488 #ifdef CHAR_IS_UNSIGNED
10489 s
->char_is_unsigned
= 1;
10491 #if defined(TCC_TARGET_PE) && 0
10492 /* XXX: currently the PE linker is not ready to support that */
10493 s
->leading_underscore
= 1;
10496 #ifdef TCC_TARGET_X86_64
10497 s
->jmp_table
= NULL
;
10502 void tcc_delete(TCCState
*s1
)
10508 /* free all sections */
10509 for(i
= 1; i
< s1
->nb_sections
; i
++)
10510 free_section(s1
->sections
[i
]);
10511 dynarray_reset(&s1
->sections
, &s1
->nb_sections
);
10513 for(i
= 0; i
< s1
->nb_priv_sections
; i
++)
10514 free_section(s1
->priv_sections
[i
]);
10515 dynarray_reset(&s1
->priv_sections
, &s1
->nb_priv_sections
);
10517 /* free any loaded DLLs */
10518 for ( i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
10519 DLLReference
*ref
= s1
->loaded_dlls
[i
];
10521 dlclose(ref
->handle
);
10524 /* free loaded dlls array */
10525 dynarray_reset(&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
);
10527 /* free library paths */
10528 dynarray_reset(&s1
->library_paths
, &s1
->nb_library_paths
);
10530 /* free include paths */
10531 dynarray_reset(&s1
->cached_includes
, &s1
->nb_cached_includes
);
10532 dynarray_reset(&s1
->include_paths
, &s1
->nb_include_paths
);
10533 dynarray_reset(&s1
->sysinclude_paths
, &s1
->nb_sysinclude_paths
);
10535 #ifdef TCC_TARGET_X86_64
10536 tcc_free(s1
->jmp_table
);
10541 int tcc_add_include_path(TCCState
*s1
, const char *pathname
)
10545 pathname1
= tcc_strdup(pathname
);
10546 dynarray_add((void ***)&s1
->include_paths
, &s1
->nb_include_paths
, pathname1
);
10550 int tcc_add_sysinclude_path(TCCState
*s1
, const char *pathname
)
10554 pathname1
= tcc_strdup(pathname
);
10555 dynarray_add((void ***)&s1
->sysinclude_paths
, &s1
->nb_sysinclude_paths
, pathname1
);
10559 static int tcc_add_file_internal(TCCState
*s1
, const char *filename
, int flags
)
10564 BufferedFile
*saved_file
;
10566 /* find source file type with extension */
10567 ext
= tcc_fileextension(filename
);
10571 /* open the file */
10573 file
= tcc_open(s1
, filename
);
10575 if (flags
& AFF_PRINT_ERROR
) {
10576 error_noabort("file '%s' not found", filename
);
10582 if (flags
& AFF_PREPROCESS
) {
10583 ret
= tcc_preprocess(s1
);
10584 } else if (!ext
[0] || !strcmp(ext
, "c")) {
10585 /* C file assumed */
10586 ret
= tcc_compile(s1
);
10588 #ifdef CONFIG_TCC_ASM
10589 if (!strcmp(ext
, "S")) {
10590 /* preprocessed assembler */
10591 ret
= tcc_assemble(s1
, 1);
10592 } else if (!strcmp(ext
, "s")) {
10593 /* non preprocessed assembler */
10594 ret
= tcc_assemble(s1
, 0);
10597 #ifdef TCC_TARGET_PE
10598 if (!strcmp(ext
, "def")) {
10599 ret
= pe_load_def_file(s1
, file
->fd
);
10604 /* assume executable format: auto guess file type */
10605 ret
= read(fd
, &ehdr
, sizeof(ehdr
));
10606 lseek(fd
, 0, SEEK_SET
);
10608 error_noabort("could not read header");
10610 } else if (ret
!= sizeof(ehdr
)) {
10611 goto try_load_script
;
10614 if (ehdr
.e_ident
[0] == ELFMAG0
&&
10615 ehdr
.e_ident
[1] == ELFMAG1
&&
10616 ehdr
.e_ident
[2] == ELFMAG2
&&
10617 ehdr
.e_ident
[3] == ELFMAG3
) {
10618 file
->line_num
= 0; /* do not display line number if error */
10619 if (ehdr
.e_type
== ET_REL
) {
10620 ret
= tcc_load_object_file(s1
, fd
, 0);
10621 } else if (ehdr
.e_type
== ET_DYN
) {
10622 if (s1
->output_type
== TCC_OUTPUT_MEMORY
) {
10623 #ifdef TCC_TARGET_PE
10627 h
= dlopen(filename
, RTLD_GLOBAL
| RTLD_LAZY
);
10634 ret
= tcc_load_dll(s1
, fd
, filename
,
10635 (flags
& AFF_REFERENCED_DLL
) != 0);
10638 error_noabort("unrecognized ELF file");
10641 } else if (memcmp((char *)&ehdr
, ARMAG
, 8) == 0) {
10642 file
->line_num
= 0; /* do not display line number if error */
10643 ret
= tcc_load_archive(s1
, fd
);
10645 #ifdef TCC_TARGET_COFF
10646 if (*(uint16_t *)(&ehdr
) == COFF_C67_MAGIC
) {
10647 ret
= tcc_load_coff(s1
, fd
);
10650 #ifdef TCC_TARGET_PE
10651 if (pe_test_res_file(&ehdr
, ret
)) {
10652 ret
= pe_load_res_file(s1
, fd
);
10656 /* as GNU ld, consider it is an ld script if not recognized */
10658 ret
= tcc_load_ldscript(s1
);
10660 error_noabort("unrecognized file type");
10675 int tcc_add_file(TCCState
*s
, const char *filename
)
10677 return tcc_add_file_internal(s
, filename
, AFF_PRINT_ERROR
);
10680 int tcc_add_library_path(TCCState
*s
, const char *pathname
)
10684 pathname1
= tcc_strdup(pathname
);
10685 dynarray_add((void ***)&s
->library_paths
, &s
->nb_library_paths
, pathname1
);
10689 /* find and load a dll. Return non zero if not found */
10690 /* XXX: add '-rpath' option support ? */
10691 static int tcc_add_dll(TCCState
*s
, const char *filename
, int flags
)
10696 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
10697 snprintf(buf
, sizeof(buf
), "%s/%s",
10698 s
->library_paths
[i
], filename
);
10699 if (tcc_add_file_internal(s
, buf
, flags
) == 0)
10705 /* the library name is the same as the argument of the '-l' option */
10706 int tcc_add_library(TCCState
*s
, const char *libraryname
)
10711 /* first we look for the dynamic library if not static linking */
10712 if (!s
->static_link
) {
10713 #ifdef TCC_TARGET_PE
10714 snprintf(buf
, sizeof(buf
), "%s.def", libraryname
);
10716 snprintf(buf
, sizeof(buf
), "lib%s.so", libraryname
);
10718 if (tcc_add_dll(s
, buf
, 0) == 0)
10722 /* then we look for the static library */
10723 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
10724 snprintf(buf
, sizeof(buf
), "%s/lib%s.a",
10725 s
->library_paths
[i
], libraryname
);
10726 if (tcc_add_file_internal(s
, buf
, 0) == 0)
10732 int tcc_add_symbol(TCCState
*s
, const char *name
, unsigned long val
)
10734 add_elf_sym(symtab_section
, val
, 0,
10735 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
10740 int tcc_set_output_type(TCCState
*s
, int output_type
)
10744 s
->output_type
= output_type
;
10746 if (!s
->nostdinc
) {
10747 /* default include paths */
10748 /* XXX: reverse order needed if -isystem support */
10749 #ifndef TCC_TARGET_PE
10750 tcc_add_sysinclude_path(s
, CONFIG_SYSROOT
"/usr/local/include");
10751 tcc_add_sysinclude_path(s
, CONFIG_SYSROOT
"/usr/include");
10753 snprintf(buf
, sizeof(buf
), "%s/include", tcc_lib_path
);
10754 tcc_add_sysinclude_path(s
, buf
);
10755 #ifdef TCC_TARGET_PE
10756 snprintf(buf
, sizeof(buf
), "%s/include/winapi", tcc_lib_path
);
10757 tcc_add_sysinclude_path(s
, buf
);
10761 /* if bound checking, then add corresponding sections */
10762 #ifdef CONFIG_TCC_BCHECK
10763 if (do_bounds_check
) {
10764 /* define symbol */
10765 tcc_define_symbol(s
, "__BOUNDS_CHECKING_ON", NULL
);
10766 /* create bounds sections */
10767 bounds_section
= new_section(s
, ".bounds",
10768 SHT_PROGBITS
, SHF_ALLOC
);
10769 lbounds_section
= new_section(s
, ".lbounds",
10770 SHT_PROGBITS
, SHF_ALLOC
);
10774 if (s
->char_is_unsigned
) {
10775 tcc_define_symbol(s
, "__CHAR_UNSIGNED__", NULL
);
10778 /* add debug sections */
10781 stab_section
= new_section(s
, ".stab", SHT_PROGBITS
, 0);
10782 stab_section
->sh_entsize
= sizeof(Stab_Sym
);
10783 stabstr_section
= new_section(s
, ".stabstr", SHT_STRTAB
, 0);
10784 put_elf_str(stabstr_section
, "");
10785 stab_section
->link
= stabstr_section
;
10786 /* put first entry */
10787 put_stabs("", 0, 0, 0, 0);
10790 /* add libc crt1/crti objects */
10791 #ifndef TCC_TARGET_PE
10792 if ((output_type
== TCC_OUTPUT_EXE
|| output_type
== TCC_OUTPUT_DLL
) &&
10794 if (output_type
!= TCC_OUTPUT_DLL
)
10795 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crt1.o");
10796 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crti.o");
10800 #ifdef TCC_TARGET_PE
10801 snprintf(buf
, sizeof(buf
), "%s/lib", tcc_lib_path
);
10802 tcc_add_library_path(s
, buf
);
10808 #define WD_ALL 0x0001 /* warning is activated when using -Wall */
10809 #define FD_INVERT 0x0002 /* invert value before storing */
10811 typedef struct FlagDef
{
10817 static const FlagDef warning_defs
[] = {
10818 { offsetof(TCCState
, warn_unsupported
), 0, "unsupported" },
10819 { offsetof(TCCState
, warn_write_strings
), 0, "write-strings" },
10820 { offsetof(TCCState
, warn_error
), 0, "error" },
10821 { offsetof(TCCState
, warn_implicit_function_declaration
), WD_ALL
,
10822 "implicit-function-declaration" },
10825 static int set_flag(TCCState
*s
, const FlagDef
*flags
, int nb_flags
,
10826 const char *name
, int value
)
10833 if (r
[0] == 'n' && r
[1] == 'o' && r
[2] == '-') {
10837 for(i
= 0, p
= flags
; i
< nb_flags
; i
++, p
++) {
10838 if (!strcmp(r
, p
->name
))
10843 if (p
->flags
& FD_INVERT
)
10845 *(int *)((uint8_t *)s
+ p
->offset
) = value
;
10850 /* set/reset a warning */
10851 int tcc_set_warning(TCCState
*s
, const char *warning_name
, int value
)
10856 if (!strcmp(warning_name
, "all")) {
10857 for(i
= 0, p
= warning_defs
; i
< countof(warning_defs
); i
++, p
++) {
10858 if (p
->flags
& WD_ALL
)
10859 *(int *)((uint8_t *)s
+ p
->offset
) = 1;
10863 return set_flag(s
, warning_defs
, countof(warning_defs
),
10864 warning_name
, value
);
10868 static const FlagDef flag_defs
[] = {
10869 { offsetof(TCCState
, char_is_unsigned
), 0, "unsigned-char" },
10870 { offsetof(TCCState
, char_is_unsigned
), FD_INVERT
, "signed-char" },
10871 { offsetof(TCCState
, nocommon
), FD_INVERT
, "common" },
10872 { offsetof(TCCState
, leading_underscore
), 0, "leading-underscore" },
10875 /* set/reset a flag */
10876 int tcc_set_flag(TCCState
*s
, const char *flag_name
, int value
)
10878 return set_flag(s
, flag_defs
, countof(flag_defs
),
10882 #if !defined(LIBTCC)
10884 static int64_t getclock_us(void)
10889 return (tb
.time
* 1000LL + tb
.millitm
) * 1000LL;
10892 gettimeofday(&tv
, NULL
);
10893 return tv
.tv_sec
* 1000000LL + tv
.tv_usec
;
10899 printf("tcc version " TCC_VERSION
" - Tiny C Compiler - Copyright (C) 2001-2006 Fabrice Bellard\n"
10900 "usage: tcc [-v] [-c] [-o outfile] [-Bdir] [-bench] [-Idir] [-Dsym[=val]] [-Usym]\n"
10901 " [-Wwarn] [-g] [-b] [-bt N] [-Ldir] [-llib] [-shared] [-soname name]\n"
10902 " [-static] [infile1 infile2...] [-run infile args...]\n"
10904 "General options:\n"
10905 " -v display current version, increase verbosity\n"
10906 " -c compile only - generate an object file\n"
10907 " -o outfile set output filename\n"
10908 " -Bdir set tcc internal library path\n"
10909 " -bench output compilation statistics\n"
10910 " -run run compiled source\n"
10911 " -fflag set or reset (with 'no-' prefix) 'flag' (see man page)\n"
10912 " -Wwarning set or reset (with 'no-' prefix) 'warning' (see man page)\n"
10913 " -w disable all warnings\n"
10914 "Preprocessor options:\n"
10915 " -E preprocess only\n"
10916 " -Idir add include path 'dir'\n"
10917 " -Dsym[=val] define 'sym' with value 'val'\n"
10918 " -Usym undefine 'sym'\n"
10919 "Linker options:\n"
10920 " -Ldir add library path 'dir'\n"
10921 " -llib link with dynamic or static library 'lib'\n"
10922 " -shared generate a shared library\n"
10923 " -soname set name for shared library to be used at runtime\n"
10924 " -static static linking\n"
10925 " -rdynamic export all global symbols to dynamic linker\n"
10926 " -r generate (relocatable) object file\n"
10927 "Debugger options:\n"
10928 " -g generate runtime debug info\n"
10929 #ifdef CONFIG_TCC_BCHECK
10930 " -b compile with built-in memory and bounds checker (implies -g)\n"
10932 " -bt N show N callers in stack traces\n"
10936 #define TCC_OPTION_HAS_ARG 0x0001
10937 #define TCC_OPTION_NOSEP 0x0002 /* cannot have space before option and arg */
10939 typedef struct TCCOption
{
10968 TCC_OPTION_nostdinc
,
10969 TCC_OPTION_nostdlib
,
10970 TCC_OPTION_print_search_dirs
,
10971 TCC_OPTION_rdynamic
,
10979 static const TCCOption tcc_options
[] = {
10980 { "h", TCC_OPTION_HELP
, 0 },
10981 { "?", TCC_OPTION_HELP
, 0 },
10982 { "I", TCC_OPTION_I
, TCC_OPTION_HAS_ARG
},
10983 { "D", TCC_OPTION_D
, TCC_OPTION_HAS_ARG
},
10984 { "U", TCC_OPTION_U
, TCC_OPTION_HAS_ARG
},
10985 { "L", TCC_OPTION_L
, TCC_OPTION_HAS_ARG
},
10986 { "B", TCC_OPTION_B
, TCC_OPTION_HAS_ARG
},
10987 { "l", TCC_OPTION_l
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
10988 { "bench", TCC_OPTION_bench
, 0 },
10989 { "bt", TCC_OPTION_bt
, TCC_OPTION_HAS_ARG
},
10990 #ifdef CONFIG_TCC_BCHECK
10991 { "b", TCC_OPTION_b
, 0 },
10993 { "g", TCC_OPTION_g
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
10994 { "c", TCC_OPTION_c
, 0 },
10995 { "static", TCC_OPTION_static
, 0 },
10996 { "shared", TCC_OPTION_shared
, 0 },
10997 { "soname", TCC_OPTION_soname
, TCC_OPTION_HAS_ARG
},
10998 { "o", TCC_OPTION_o
, TCC_OPTION_HAS_ARG
},
10999 { "run", TCC_OPTION_run
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11000 { "rdynamic", TCC_OPTION_rdynamic
, 0 },
11001 { "r", TCC_OPTION_r
, 0 },
11002 { "Wl,", TCC_OPTION_Wl
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11003 { "W", TCC_OPTION_W
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11004 { "O", TCC_OPTION_O
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11005 { "m", TCC_OPTION_m
, TCC_OPTION_HAS_ARG
},
11006 { "f", TCC_OPTION_f
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11007 { "nostdinc", TCC_OPTION_nostdinc
, 0 },
11008 { "nostdlib", TCC_OPTION_nostdlib
, 0 },
11009 { "print-search-dirs", TCC_OPTION_print_search_dirs
, 0 },
11010 { "v", TCC_OPTION_v
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
11011 { "w", TCC_OPTION_w
, 0 },
11012 { "pipe", TCC_OPTION_pipe
, 0},
11013 { "E", TCC_OPTION_E
, 0},
11017 /* convert 'str' into an array of space separated strings */
11018 static int expand_args(char ***pargv
, const char *str
)
11027 while (is_space(*str
))
11032 while (*str
!= '\0' && !is_space(*str
))
11035 arg
= tcc_malloc(len
+ 1);
11036 memcpy(arg
, s1
, len
);
11038 dynarray_add((void ***)&argv
, &argc
, arg
);
11044 static char **files
;
11045 static int nb_files
, nb_libraries
;
11046 static int multiple_files
;
11047 static int print_search_dirs
;
11048 static int output_type
;
11049 static int reloc_output
;
11050 static const char *outfile
;
11052 int parse_args(TCCState
*s
, int argc
, char **argv
)
11055 const TCCOption
*popt
;
11056 const char *optarg
, *p1
, *r1
;
11060 while (optind
< argc
) {
11062 r
= argv
[optind
++];
11063 if (r
[0] != '-' || r
[1] == '\0') {
11064 /* add a new file */
11065 dynarray_add((void ***)&files
, &nb_files
, r
);
11066 if (!multiple_files
) {
11068 /* argv[0] will be this file */
11072 /* find option in table (match only the first chars */
11073 popt
= tcc_options
;
11077 error("invalid option -- '%s'", r
);
11090 if (popt
->flags
& TCC_OPTION_HAS_ARG
) {
11091 if (*r1
!= '\0' || (popt
->flags
& TCC_OPTION_NOSEP
)) {
11094 if (optind
>= argc
)
11095 error("argument to '%s' is missing", r
);
11096 optarg
= argv
[optind
++];
11104 switch(popt
->index
) {
11105 case TCC_OPTION_HELP
:
11109 if (tcc_add_include_path(s
, optarg
) < 0)
11110 error("too many include paths");
11115 sym
= (char *)optarg
;
11116 value
= strchr(sym
, '=');
11121 tcc_define_symbol(s
, sym
, value
);
11125 tcc_undefine_symbol(s
, optarg
);
11128 tcc_add_library_path(s
, optarg
);
11131 /* set tcc utilities path (mainly for tcc development) */
11132 tcc_lib_path
= optarg
;
11135 dynarray_add((void ***)&files
, &nb_files
, r
);
11138 case TCC_OPTION_bench
:
11141 case TCC_OPTION_bt
:
11142 num_callers
= atoi(optarg
);
11144 #ifdef CONFIG_TCC_BCHECK
11146 do_bounds_check
= 1;
11154 multiple_files
= 1;
11155 output_type
= TCC_OUTPUT_OBJ
;
11157 case TCC_OPTION_static
:
11158 s
->static_link
= 1;
11160 case TCC_OPTION_shared
:
11161 output_type
= TCC_OUTPUT_DLL
;
11163 case TCC_OPTION_soname
:
11164 s
->soname
= optarg
;
11167 multiple_files
= 1;
11171 /* generate a .o merging several output files */
11173 output_type
= TCC_OUTPUT_OBJ
;
11175 case TCC_OPTION_nostdinc
:
11178 case TCC_OPTION_nostdlib
:
11181 case TCC_OPTION_print_search_dirs
:
11182 print_search_dirs
= 1;
11184 case TCC_OPTION_run
:
11188 argc1
= expand_args(&argv1
, optarg
);
11190 parse_args(s
, argc1
, argv1
);
11192 multiple_files
= 0;
11193 output_type
= TCC_OUTPUT_MEMORY
;
11198 if (0 == verbose
++)
11199 printf("tcc version %s\n", TCC_VERSION
);
11200 } while (*optarg
++ == 'v');
11203 if (tcc_set_flag(s
, optarg
, 1) < 0 && s
->warn_unsupported
)
11204 goto unsupported_option
;
11207 if (tcc_set_warning(s
, optarg
, 1) < 0 &&
11208 s
->warn_unsupported
)
11209 goto unsupported_option
;
11214 case TCC_OPTION_rdynamic
:
11217 case TCC_OPTION_Wl
:
11220 if (strstart(optarg
, "-Ttext,", &p
)) {
11221 s
->text_addr
= strtoul(p
, NULL
, 16);
11222 s
->has_text_addr
= 1;
11223 } else if (strstart(optarg
, "--oformat,", &p
)) {
11224 if (strstart(p
, "elf32-", NULL
)) {
11225 s
->output_format
= TCC_OUTPUT_FORMAT_ELF
;
11226 } else if (!strcmp(p
, "binary")) {
11227 s
->output_format
= TCC_OUTPUT_FORMAT_BINARY
;
11229 #ifdef TCC_TARGET_COFF
11230 if (!strcmp(p
, "coff")) {
11231 s
->output_format
= TCC_OUTPUT_FORMAT_COFF
;
11235 error("target %s not found", p
);
11238 error("unsupported linker option '%s'", optarg
);
11243 output_type
= TCC_OUTPUT_PREPROCESS
;
11246 if (s
->warn_unsupported
) {
11247 unsupported_option
:
11248 warning("unsupported option '%s'", r
);
11257 int main(int argc
, char **argv
)
11261 int nb_objfiles
, ret
, optind
;
11262 char objfilename
[1024];
11263 int64_t start_time
= 0;
11266 tcc_lib_path
= w32_tcc_lib_path();
11270 output_type
= TCC_OUTPUT_EXE
;
11272 multiple_files
= 1;
11277 print_search_dirs
= 0;
11280 optind
= parse_args(s
, argc
- 1, argv
+ 1);
11281 if (print_search_dirs
) {
11282 /* enough for Linux kernel */
11283 printf("install: %s/\n", tcc_lib_path
);
11286 if (optind
== 0 || nb_files
== 0) {
11287 if (optind
&& verbose
)
11293 nb_objfiles
= nb_files
- nb_libraries
;
11295 /* if outfile provided without other options, we output an
11297 if (outfile
&& output_type
== TCC_OUTPUT_MEMORY
)
11298 output_type
= TCC_OUTPUT_EXE
;
11300 /* check -c consistency : only single file handled. XXX: checks file type */
11301 if (output_type
== TCC_OUTPUT_OBJ
&& !reloc_output
) {
11302 /* accepts only a single input file */
11303 if (nb_objfiles
!= 1)
11304 error("cannot specify multiple files with -c");
11305 if (nb_libraries
!= 0)
11306 error("cannot specify libraries with -c");
11310 if (output_type
== TCC_OUTPUT_PREPROCESS
) {
11312 s
->outfile
= stdout
;
11314 s
->outfile
= fopen(outfile
, "w");
11316 error("could not open '%s", outfile
);
11318 } else if (output_type
!= TCC_OUTPUT_MEMORY
) {
11320 /* compute default outfile name */
11323 strcmp(files
[0], "-") == 0 ? "a" : tcc_basename(files
[0]);
11324 pstrcpy(objfilename
, sizeof(objfilename
), name
);
11325 ext
= tcc_fileextension(objfilename
);
11326 #ifdef TCC_TARGET_PE
11327 if (output_type
== TCC_OUTPUT_DLL
)
11328 strcpy(ext
, ".dll");
11330 if (output_type
== TCC_OUTPUT_EXE
)
11331 strcpy(ext
, ".exe");
11334 if (output_type
== TCC_OUTPUT_OBJ
&& !reloc_output
&& *ext
)
11337 pstrcpy(objfilename
, sizeof(objfilename
), "a.out");
11338 outfile
= objfilename
;
11343 start_time
= getclock_us();
11346 tcc_set_output_type(s
, output_type
);
11348 /* compile or add each files or library */
11349 for(i
= 0; i
< nb_files
&& ret
== 0; i
++) {
11350 const char *filename
;
11352 filename
= files
[i
];
11353 if (output_type
== TCC_OUTPUT_PREPROCESS
) {
11354 if (tcc_add_file_internal(s
, filename
,
11355 AFF_PRINT_ERROR
| AFF_PREPROCESS
) < 0)
11357 } else if (filename
[0] == '-' && filename
[1]) {
11358 if (tcc_add_library(s
, filename
+ 2) < 0)
11359 error("cannot find %s", filename
);
11362 printf("-> %s\n", filename
);
11363 if (tcc_add_file(s
, filename
) < 0)
11368 /* free all files */
11376 total_time
= (double)(getclock_us() - start_time
) / 1000000.0;
11377 if (total_time
< 0.001)
11378 total_time
= 0.001;
11379 if (total_bytes
< 1)
11381 printf("%d idents, %d lines, %d bytes, %0.3f s, %d lines/s, %0.1f MB/s\n",
11382 tok_ident
- TOK_IDENT
, total_lines
, total_bytes
,
11383 total_time
, (int)(total_lines
/ total_time
),
11384 total_bytes
/ total_time
/ 1000000.0);
11387 if (s
->output_type
== TCC_OUTPUT_PREPROCESS
) {
11389 fclose(s
->outfile
);
11390 } else if (s
->output_type
== TCC_OUTPUT_MEMORY
) {
11391 ret
= tcc_run(s
, argc
- optind
, argv
+ optind
);
11393 ret
= tcc_output_file(s
, outfile
) ? 1 : 0;
11395 /* XXX: cannot do it with bound checking because of the malloc hooks */
11396 if (!do_bounds_check
)
11401 printf("memory: %d bytes, max = %d bytes\n", mem_cur_size
, mem_max_size
);