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
42 #include <sys/timeb.h>
43 // #include <windows.h>
47 #include <sys/ucontext.h>
51 #endif /* !CONFIG_TCCBOOT */
68 /* preprocessor debug */
70 /* include file debug */
78 /* target selection */
79 //#define TCC_TARGET_I386 /* i386 code generator */
80 //#define TCC_TARGET_ARM /* ARMv4 code generator */
81 //#define TCC_TARGET_C67 /* TMS320C67xx code generator */
83 /* default target is I386 */
84 #if !defined(TCC_TARGET_I386) && !defined(TCC_TARGET_ARM) && \
85 !defined(TCC_TARGET_C67)
86 #define TCC_TARGET_I386
89 #if !defined(_WIN32) && !defined(TCC_UCLIBC) && !defined(TCC_TARGET_ARM) && \
90 !defined(TCC_TARGET_C67)
91 #define CONFIG_TCC_BCHECK /* enable bound checking code */
94 #if defined(_WIN32) && !defined(TCC_TARGET_PE)
95 #define CONFIG_TCC_STATIC
98 /* define it to include assembler support */
99 #if !defined(TCC_TARGET_ARM) && !defined(TCC_TARGET_C67)
100 #define CONFIG_TCC_ASM
103 /* object format selection */
104 #if defined(TCC_TARGET_C67)
105 #define TCC_TARGET_COFF
114 /* path to find crt1.o, crti.o and crtn.o. Only needed when generating
115 executables or dlls */
116 #define CONFIG_TCC_CRT_PREFIX "/usr/lib"
118 #define INCLUDE_STACK_SIZE 32
119 #define IFDEF_STACK_SIZE 64
120 #define VSTACK_SIZE 256
121 #define STRING_MAX_SIZE 1024
122 #define PACK_STACK_SIZE 8
124 #define TOK_HASH_SIZE 8192 /* must be a power of two */
125 #define TOK_ALLOC_INCR 512 /* must be a power of two */
126 #define TOK_MAX_SIZE 4 /* token max size in int unit when stored in string */
128 /* token symbol management */
129 typedef struct TokenSym
{
130 struct TokenSym
*hash_next
;
131 struct Sym
*sym_define
; /* direct pointer to define */
132 struct Sym
*sym_label
; /* direct pointer to label */
133 struct Sym
*sym_struct
; /* direct pointer to structure */
134 struct Sym
*sym_identifier
; /* direct pointer to identifier */
135 int tok
; /* token number */
141 typedef unsigned short nwchar_t
;
143 typedef int nwchar_t
;
146 typedef struct CString
{
147 int size
; /* size in bytes */
148 void *data
; /* either 'char *' or 'nwchar_t *' */
150 void *data_allocated
; /* if non NULL, data has been malloced */
153 /* type definition */
154 typedef struct CType
{
160 typedef union CValue
{
166 unsigned int ul
; /* address (should be unsigned long on 64 bit cpu) */
168 unsigned long long ull
;
169 struct CString
*cstr
;
175 typedef struct SValue
{
176 CType type
; /* type */
177 unsigned short r
; /* register + flags */
178 unsigned short r2
; /* second register, used for 'long long'
179 type. If not used, set to VT_CONST */
180 CValue c
; /* constant, if VT_CONST */
181 struct Sym
*sym
; /* symbol, if (VT_SYM | VT_CONST) */
184 /* symbol management */
186 int v
; /* symbol token */
187 int r
; /* associated register */
188 int c
; /* associated number */
189 CType type
; /* associated type */
190 struct Sym
*next
; /* next related symbol */
191 struct Sym
*prev
; /* prev symbol in stack */
192 struct Sym
*prev_tok
; /* previous symbol for this token */
195 /* section definition */
196 /* XXX: use directly ELF structure for parameters ? */
197 /* special flag to indicate that the section should not be linked to
199 #define SHF_PRIVATE 0x80000000
201 typedef struct Section
{
202 unsigned long data_offset
; /* current data offset */
203 unsigned char *data
; /* section data */
204 unsigned long data_allocated
; /* used for realloc() handling */
205 int sh_name
; /* elf section name (only used during output) */
206 int sh_num
; /* elf section number */
207 int sh_type
; /* elf section type */
208 int sh_flags
; /* elf section flags */
209 int sh_info
; /* elf section info */
210 int sh_addralign
; /* elf section alignment */
211 int sh_entsize
; /* elf entry size */
212 unsigned long sh_size
; /* section size (only used during output) */
213 unsigned long sh_addr
; /* address at which the section is relocated */
214 unsigned long sh_offset
; /* file offset */
215 int nb_hashed_syms
; /* used to resize the hash table */
216 struct Section
*link
; /* link to another section */
217 struct Section
*reloc
; /* corresponding section for relocation, if any */
218 struct Section
*hash
; /* hash table for symbols */
219 struct Section
*next
;
220 char name
[1]; /* section name */
223 typedef struct DLLReference
{
228 /* GNUC attribute definition */
229 typedef struct AttributeDef
{
233 unsigned char func_call
; /* FUNC_CDECL, FUNC_STDCALL, FUNC_FASTCALLx */
234 unsigned char dllexport
;
237 #define SYM_STRUCT 0x40000000 /* struct/union/enum symbol space */
238 #define SYM_FIELD 0x20000000 /* struct/union field symbol space */
239 #define SYM_FIRST_ANOM 0x10000000 /* first anonymous sym */
241 /* stored in 'Sym.c' field */
242 #define FUNC_NEW 1 /* ansi function prototype */
243 #define FUNC_OLD 2 /* old function prototype */
244 #define FUNC_ELLIPSIS 3 /* ansi function prototype with ... */
246 /* stored in 'Sym.r' field */
247 #define FUNC_CDECL 0 /* standard c call */
248 #define FUNC_STDCALL 1 /* pascal c call */
249 #define FUNC_FASTCALL1 2 /* first param in %eax */
250 #define FUNC_FASTCALL2 3 /* first parameters in %eax, %edx */
251 #define FUNC_FASTCALL3 4 /* first parameter in %eax, %edx, %ecx */
252 #define FUNC_FASTCALLW 5 /* first parameter in %ecx, %edx */
254 /* field 'Sym.t' for macros */
255 #define MACRO_OBJ 0 /* object like macro */
256 #define MACRO_FUNC 1 /* function like macro */
258 /* field 'Sym.r' for C labels */
259 #define LABEL_DEFINED 0 /* label is defined */
260 #define LABEL_FORWARD 1 /* label is forward defined */
261 #define LABEL_DECLARED 2 /* label is declared but never used */
263 /* type_decl() types */
264 #define TYPE_ABSTRACT 1 /* type without variable */
265 #define TYPE_DIRECT 2 /* type with variable */
267 #define IO_BUF_SIZE 8192
269 typedef struct BufferedFile
{
273 int line_num
; /* current line number - here to simplify code */
274 int ifndef_macro
; /* #ifndef macro / #endif search */
275 int ifndef_macro_saved
; /* saved ifndef_macro */
276 int *ifdef_stack_ptr
; /* ifdef_stack value at the start of the file */
277 char inc_type
; /* type of include */
278 char inc_filename
[512]; /* filename specified by the user */
279 char filename
[1024]; /* current filename - here to simplify code */
280 unsigned char buffer
[IO_BUF_SIZE
+ 1]; /* extra size for CH_EOB char */
283 #define CH_EOB '\\' /* end of buffer or '\0' char in file */
284 #define CH_EOF (-1) /* end of file */
286 /* parsing state (used to save parser state to reparse part of the
287 source several times) */
288 typedef struct ParseState
{
295 /* used to record tokens */
296 typedef struct TokenString
{
303 /* include file cache, used to find files faster and also to eliminate
304 inclusion if the include file is protected by #ifndef ... #endif */
305 typedef struct CachedInclude
{
307 int hash_next
; /* -1 if none */
308 char type
; /* '"' or '>' to give include type */
309 char filename
[1]; /* path specified in #include */
312 #define CACHED_INCLUDES_HASH_SIZE 512
315 static struct BufferedFile
*file
;
318 static CString tokcstr
; /* current parsed string, if any */
319 /* additional informations about token */
320 static int tok_flags
;
321 #define TOK_FLAG_BOL 0x0001 /* beginning of line before */
322 #define TOK_FLAG_BOF 0x0002 /* beginning of file before */
323 #define TOK_FLAG_ENDIF 0x0004 /* a endif was found matching starting #ifdef */
324 #define TOK_FLAG_EOF 0x0008 /* end of file */
326 static int *macro_ptr
, *macro_ptr_allocated
;
327 static int *unget_saved_macro_ptr
;
328 static int unget_saved_buffer
[TOK_MAX_SIZE
+ 1];
329 static int unget_buffer_enabled
;
330 static int parse_flags
;
331 #define PARSE_FLAG_PREPROCESS 0x0001 /* activate preprocessing */
332 #define PARSE_FLAG_TOK_NUM 0x0002 /* return numbers instead of TOK_PPNUM */
333 #define PARSE_FLAG_LINEFEED 0x0004 /* line feed is returned as a
334 token. line feed is also
336 #define PARSE_FLAG_ASM_COMMENTS 0x0008 /* '#' can be used for line comment */
338 static Section
*text_section
, *data_section
, *bss_section
; /* predefined sections */
339 static Section
*cur_text_section
; /* current section where function code is
341 #ifdef CONFIG_TCC_ASM
342 static Section
*last_text_section
; /* to handle .previous asm directive */
344 /* bound check related sections */
345 static Section
*bounds_section
; /* contains global data bound description */
346 static Section
*lbounds_section
; /* contains local data bound description */
347 /* symbol sections */
348 static Section
*symtab_section
, *strtab_section
;
351 static Section
*stab_section
, *stabstr_section
;
353 /* loc : local variable index
354 ind : output code index
356 anon_sym: anonymous symbol index
358 static int rsym
, anon_sym
, ind
, loc
;
359 /* expression generation modifiers */
360 static int const_wanted
; /* true if constant wanted */
361 static int nocode_wanted
; /* true if no code generation wanted for an expression */
362 static int global_expr
; /* true if compound literals must be allocated
363 globally (used during initializers parsing */
364 static CType func_vt
; /* current function return type (used by return
367 static int last_line_num
, last_ind
, func_ind
; /* debug last line number and pc */
368 static int tok_ident
;
369 static TokenSym
**table_ident
;
370 static TokenSym
*hash_ident
[TOK_HASH_SIZE
];
371 static char token_buf
[STRING_MAX_SIZE
+ 1];
372 static char *funcname
;
373 static Sym
*global_stack
, *local_stack
;
374 static Sym
*define_stack
;
375 static Sym
*global_label_stack
, *local_label_stack
;
376 /* symbol allocator */
377 #define SYM_POOL_NB (8192 / sizeof(Sym))
378 static Sym
*sym_free_first
;
380 static SValue vstack
[VSTACK_SIZE
], *vtop
;
381 /* some predefined types */
382 static CType char_pointer_type
, func_old_type
, int_type
;
383 /* true if isid(c) || isnum(c) */
384 static unsigned char isidnum_table
[256];
386 /* compile with debug symbol (and use them if error during execution) */
387 static int do_debug
= 0;
389 /* compile with built-in memory and bounds checker */
390 static int do_bounds_check
= 0;
392 /* display benchmark infos */
394 static int do_bench
= 0;
396 static int total_lines
;
397 static int total_bytes
;
399 /* use GNU C extensions */
400 static int gnu_ext
= 1;
402 /* use Tiny C extensions */
403 static int tcc_ext
= 1;
405 /* max number of callers shown if error */
406 static int num_callers
= 6;
407 static const char **rt_bound_error_msg
;
409 /* XXX: get rid of this ASAP */
410 static struct TCCState
*tcc_state
;
412 /* give the path of the tcc libraries */
413 static const char *tcc_lib_path
= CONFIG_TCCDIR
;
418 BufferedFile
**include_stack_ptr
;
419 int *ifdef_stack_ptr
;
421 /* include file handling */
422 char **include_paths
;
423 int nb_include_paths
;
424 char **sysinclude_paths
;
425 int nb_sysinclude_paths
;
426 CachedInclude
**cached_includes
;
427 int nb_cached_includes
;
429 char **library_paths
;
430 int nb_library_paths
;
432 /* array of all loaded dlls (including those referenced by loaded
434 DLLReference
**loaded_dlls
;
439 int nb_sections
; /* number of sections, including first dummy section */
444 unsigned long *got_offsets
;
446 /* give the correspondance from symtab indexes to dynsym indexes */
447 int *symtab_to_dynsym
;
449 /* temporary dynamic symbol sections (for dll loading) */
450 Section
*dynsymtab_section
;
451 /* exported dynamic symbol section */
454 int nostdinc
; /* if true, no standard headers are added */
455 int nostdlib
; /* if true, no standard libraries are added */
457 int nocommon
; /* if true, do not use common symbols for .bss data */
459 /* if true, static linking is performed */
462 /* if true, all symbols are exported */
465 /* if true, only link in referenced objects from archive */
468 /* address of text section */
469 unsigned long text_addr
;
472 /* output format, see TCC_OUTPUT_FORMAT_xxx */
475 /* C language options */
476 int char_is_unsigned
;
477 int leading_underscore
;
479 /* warning switches */
480 int warn_write_strings
;
481 int warn_unsupported
;
484 int warn_implicit_function_declaration
;
488 void (*error_func
)(void *opaque
, const char *msg
);
489 int error_set_jmp_enabled
;
490 jmp_buf error_jmp_buf
;
493 /* tiny assembler state */
496 /* see include_stack_ptr */
497 BufferedFile
*include_stack
[INCLUDE_STACK_SIZE
];
499 /* see ifdef_stack_ptr */
500 int ifdef_stack
[IFDEF_STACK_SIZE
];
502 /* see cached_includes */
503 int cached_includes_hash
[CACHED_INCLUDES_HASH_SIZE
];
506 int pack_stack
[PACK_STACK_SIZE
];
509 /* output file for preprocessing */
513 /* The current value can be: */
514 #define VT_VALMASK 0x00ff
515 #define VT_CONST 0x00f0 /* constant in vc
516 (must be first non register value) */
517 #define VT_LLOCAL 0x00f1 /* lvalue, offset on stack */
518 #define VT_LOCAL 0x00f2 /* offset on stack */
519 #define VT_CMP 0x00f3 /* the value is stored in processor flags (in vc) */
520 #define VT_JMP 0x00f4 /* value is the consequence of jmp true (even) */
521 #define VT_JMPI 0x00f5 /* value is the consequence of jmp false (odd) */
522 #define VT_LVAL 0x0100 /* var is an lvalue */
523 #define VT_SYM 0x0200 /* a symbol value is added */
524 #define VT_MUSTCAST 0x0400 /* value must be casted to be correct (used for
525 char/short stored in integer registers) */
526 #define VT_MUSTBOUND 0x0800 /* bound checking must be done before
527 dereferencing value */
528 #define VT_BOUNDED 0x8000 /* value is bounded. The address of the
529 bounding function call point is in vc */
530 #define VT_LVAL_BYTE 0x1000 /* lvalue is a byte */
531 #define VT_LVAL_SHORT 0x2000 /* lvalue is a short */
532 #define VT_LVAL_UNSIGNED 0x4000 /* lvalue is unsigned */
533 #define VT_LVAL_TYPE (VT_LVAL_BYTE | VT_LVAL_SHORT | VT_LVAL_UNSIGNED)
536 #define VT_INT 0 /* integer type */
537 #define VT_BYTE 1 /* signed byte type */
538 #define VT_SHORT 2 /* short type */
539 #define VT_VOID 3 /* void type */
540 #define VT_PTR 4 /* pointer */
541 #define VT_ENUM 5 /* enum definition */
542 #define VT_FUNC 6 /* function type */
543 #define VT_STRUCT 7 /* struct/union definition */
544 #define VT_FLOAT 8 /* IEEE float */
545 #define VT_DOUBLE 9 /* IEEE double */
546 #define VT_LDOUBLE 10 /* IEEE long double */
547 #define VT_BOOL 11 /* ISOC99 boolean type */
548 #define VT_LLONG 12 /* 64 bit integer */
549 #define VT_LONG 13 /* long integer (NEVER USED as type, only
551 #define VT_BTYPE 0x000f /* mask for basic type */
552 #define VT_UNSIGNED 0x0010 /* unsigned type */
553 #define VT_ARRAY 0x0020 /* array type (also has VT_PTR) */
554 #define VT_BITFIELD 0x0040 /* bitfield modifier */
555 #define VT_CONSTANT 0x0800 /* const modifier */
556 #define VT_VOLATILE 0x1000 /* volatile modifier */
557 #define VT_SIGNED 0x2000 /* signed type */
560 #define VT_EXTERN 0x00000080 /* extern definition */
561 #define VT_STATIC 0x00000100 /* static variable */
562 #define VT_TYPEDEF 0x00000200 /* typedef definition */
563 #define VT_INLINE 0x00000400 /* inline definition */
565 #define VT_STRUCT_SHIFT 16 /* shift for bitfield shift values */
567 /* type mask (except storage) */
568 #define VT_STORAGE (VT_EXTERN | VT_STATIC | VT_TYPEDEF | VT_INLINE)
569 #define VT_TYPE (~(VT_STORAGE))
573 /* warning: the following compare tokens depend on i386 asm code */
580 #define TOK_Nset 0x98
581 #define TOK_Nclear 0x99
587 #define TOK_LAND 0xa0
591 #define TOK_MID 0xa3 /* inc/dec, to void constant */
593 #define TOK_UDIV 0xb0 /* unsigned division */
594 #define TOK_UMOD 0xb1 /* unsigned modulo */
595 #define TOK_PDIV 0xb2 /* fast division with undefined rounding for pointers */
596 #define TOK_CINT 0xb3 /* number in tokc */
597 #define TOK_CCHAR 0xb4 /* char constant in tokc */
598 #define TOK_STR 0xb5 /* pointer to string in tokc */
599 #define TOK_TWOSHARPS 0xb6 /* ## preprocessing token */
600 #define TOK_LCHAR 0xb7
601 #define TOK_LSTR 0xb8
602 #define TOK_CFLOAT 0xb9 /* float constant */
603 #define TOK_LINENUM 0xba /* line number info */
604 #define TOK_CDOUBLE 0xc0 /* double constant */
605 #define TOK_CLDOUBLE 0xc1 /* long double constant */
606 #define TOK_UMULL 0xc2 /* unsigned 32x32 -> 64 mul */
607 #define TOK_ADDC1 0xc3 /* add with carry generation */
608 #define TOK_ADDC2 0xc4 /* add with carry use */
609 #define TOK_SUBC1 0xc5 /* add with carry generation */
610 #define TOK_SUBC2 0xc6 /* add with carry use */
611 #define TOK_CUINT 0xc8 /* unsigned int constant */
612 #define TOK_CLLONG 0xc9 /* long long constant */
613 #define TOK_CULLONG 0xca /* unsigned long long constant */
614 #define TOK_ARROW 0xcb
615 #define TOK_DOTS 0xcc /* three dots */
616 #define TOK_SHR 0xcd /* unsigned shift right */
617 #define TOK_PPNUM 0xce /* preprocessor number */
619 #define TOK_SHL 0x01 /* shift left */
620 #define TOK_SAR 0x02 /* signed shift right */
622 /* assignement operators : normal operator or 0x80 */
623 #define TOK_A_MOD 0xa5
624 #define TOK_A_AND 0xa6
625 #define TOK_A_MUL 0xaa
626 #define TOK_A_ADD 0xab
627 #define TOK_A_SUB 0xad
628 #define TOK_A_DIV 0xaf
629 #define TOK_A_XOR 0xde
630 #define TOK_A_OR 0xfc
631 #define TOK_A_SHL 0x81
632 #define TOK_A_SAR 0x82
635 #define offsetof(type, field) ((size_t) &((type *)0)->field)
639 #define countof(tab) (sizeof(tab) / sizeof((tab)[0]))
642 /* WARNING: the content of this string encodes token numbers */
643 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";
645 #define TOK_EOF (-1) /* end of file */
646 #define TOK_LINEFEED 10 /* line feed */
648 /* all identificators and strings have token above that */
649 #define TOK_IDENT 256
651 /* only used for i386 asm opcodes definitions */
652 #define DEF_ASM(x) DEF(TOK_ASM_ ## x, #x)
655 DEF(TOK_ASM_ ## x ## b, #x "b") \
656 DEF(TOK_ASM_ ## x ## w, #x "w") \
657 DEF(TOK_ASM_ ## x ## l, #x "l") \
658 DEF(TOK_ASM_ ## x, #x)
661 DEF(TOK_ASM_ ## x ## w, #x "w") \
662 DEF(TOK_ASM_ ## x ## l, #x "l") \
663 DEF(TOK_ASM_ ## x, #x)
666 DEF(TOK_ASM_ ## f ## x ## s, "f" #x "s") \
667 DEF(TOK_ASM_ ## fi ## x ## l, "fi" #x "l") \
668 DEF(TOK_ASM_ ## f ## x ## l, "f" #x "l") \
669 DEF(TOK_ASM_ ## fi ## x ## s, "fi" #x "s")
672 DEF(TOK_ASM_ ## f ## x, "f" #x ) \
673 DEF(TOK_ASM_ ## f ## x ## p, "f" #x "p") \
676 #define DEF_ASMTEST(x) \
708 #define TOK_ASM_int TOK_INT
711 TOK_LAST
= TOK_IDENT
- 1,
712 #define DEF(id, str) id,
717 static const char tcc_keywords
[] =
718 #define DEF(id, str) str "\0"
723 #define TOK_UIDENT TOK_DEFINE
726 int __stdcall
GetModuleFileNameA(void *, char *, int);
727 void *__stdcall
GetProcAddress(void *, const char *);
728 void *__stdcall
GetModuleHandleA(const char *);
729 void *__stdcall
LoadLibraryA(const char *);
730 int __stdcall
FreeConsole(void);
731 int __stdcall
VirtualProtect(void*,unsigned long,unsigned long,unsigned long*);
732 #define PAGE_EXECUTE_READWRITE 0x0040
734 #define snprintf _snprintf
735 #define vsnprintf _vsnprintf
737 #define strtold (long double)strtod
738 #define strtof (float)strtod
739 #define strtoll (long long)strtol
741 #elif defined(TCC_UCLIBC) || defined(__FreeBSD__)
742 /* currently incorrect */
743 long double strtold(const char *nptr
, char **endptr
)
745 return (long double)strtod(nptr
, endptr
);
747 float strtof(const char *nptr
, char **endptr
)
749 return (float)strtod(nptr
, endptr
);
752 /* XXX: need to define this to use them in non ISOC99 context */
753 extern float strtof (const char *__nptr
, char **__endptr
);
754 extern long double strtold (const char *__nptr
, char **__endptr
);
757 static char *pstrcpy(char *buf
, int buf_size
, const char *s
);
758 static char *pstrcat(char *buf
, int buf_size
, const char *s
);
759 static char *tcc_basename(const char *name
);
761 static void next(void);
762 static void next_nomacro(void);
763 static void parse_expr_type(CType
*type
);
764 static void expr_type(CType
*type
);
765 static void unary_type(CType
*type
);
766 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
,
767 int case_reg
, int is_expr
);
768 static int expr_const(void);
769 static void expr_eq(void);
770 static void gexpr(void);
771 static void gen_inline_functions(void);
772 static void decl(int l
);
773 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
774 int first
, int size_only
);
775 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
776 int has_init
, int v
, int scope
);
778 void gv2(int rc1
, int rc2
);
779 void move_reg(int r
, int s
);
780 void save_regs(int n
);
781 void save_reg(int r
);
786 int get_reg_ex(int rc
,int rc2
);
789 struct macro_level
*prev
;
793 static void macro_subst(TokenString
*tok_str
, Sym
**nested_list
,
794 const int *macro_str
, struct macro_level
**can_read_stream
);
796 void force_charshort_cast(int t
);
797 static void gen_cast(CType
*type
);
799 static Sym
*sym_find(int v
);
800 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
);
803 static int type_size(CType
*type
, int *a
);
804 static inline CType
*pointed_type(CType
*type
);
805 static int pointed_size(CType
*type
);
806 static int lvalue_type(int t
);
807 static int parse_btype(CType
*type
, AttributeDef
*ad
);
808 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
);
809 static int compare_types(CType
*type1
, CType
*type2
, int unqualified
);
810 static int is_compatible_types(CType
*type1
, CType
*type2
);
811 static int is_compatible_parameter_types(CType
*type1
, CType
*type2
);
813 int ieee_finite(double d
);
814 void error(const char *fmt
, ...);
818 void lexpand_nr(void);
819 static void vpush_global_sym(CType
*type
, int v
);
820 void vset(CType
*type
, int r
, int v
);
821 void type_to_str(char *buf
, int buf_size
,
822 CType
*type
, const char *varstr
);
823 char *get_tok_str(int v
, CValue
*cv
);
824 static Sym
*get_sym_ref(CType
*type
, Section
*sec
,
825 unsigned long offset
, unsigned long size
);
826 static Sym
*external_global_sym(int v
, CType
*type
, int r
);
828 /* section generation */
829 static void section_realloc(Section
*sec
, unsigned long new_size
);
830 static void *section_ptr_add(Section
*sec
, unsigned long size
);
831 static void put_extern_sym(Sym
*sym
, Section
*section
,
832 unsigned long value
, unsigned long size
);
833 static void greloc(Section
*s
, Sym
*sym
, unsigned long addr
, int type
);
834 static int put_elf_str(Section
*s
, const char *sym
);
835 static int put_elf_sym(Section
*s
,
836 unsigned long value
, unsigned long size
,
837 int info
, int other
, int shndx
, const char *name
);
838 static int add_elf_sym(Section
*s
, unsigned long value
, unsigned long size
,
839 int info
, int other
, int sh_num
, const char *name
);
840 static void put_elf_reloc(Section
*symtab
, Section
*s
, unsigned long offset
,
841 int type
, int symbol
);
842 static void put_stabs(const char *str
, int type
, int other
, int desc
,
843 unsigned long value
);
844 static void put_stabs_r(const char *str
, int type
, int other
, int desc
,
845 unsigned long value
, Section
*sec
, int sym_index
);
846 static void put_stabn(int type
, int other
, int desc
, int value
);
847 static void put_stabd(int type
, int other
, int desc
);
848 static int tcc_add_dll(TCCState
*s
, const char *filename
, int flags
);
850 #define AFF_PRINT_ERROR 0x0001 /* print error if file not found */
851 #define AFF_REFERENCED_DLL 0x0002 /* load a referenced dll from another dll */
852 #define AFF_PREPROCESS 0x0004 /* preprocess file */
853 static int tcc_add_file_internal(TCCState
*s
, const char *filename
, int flags
);
856 int tcc_output_coff(TCCState
*s1
, FILE *f
);
859 void *resolve_sym(TCCState
*s1
, const char *sym
, int type
);
860 int pe_load_def_file(struct TCCState
*s1
, FILE *fp
);
861 void pe_setup_paths(struct TCCState
*s1
, int *p_output_type
, const char **p_outfile
, char *first_file
);
862 unsigned long pe_add_runtime(struct TCCState
*s1
);
863 int tcc_output_pe(struct TCCState
*s1
, const char *filename
);
867 #ifdef CONFIG_TCC_ASM
869 typedef struct ExprValue
{
874 #define MAX_ASM_OPERANDS 30
876 typedef struct ASMOperand
{
877 int id
; /* GCC 3 optionnal identifier (0 if number only supported */
879 char asm_str
[16]; /* computed asm string for operand */
880 SValue
*vt
; /* C value of the expression */
881 int ref_index
; /* if >= 0, gives reference to a output constraint */
882 int input_index
; /* if >= 0, gives reference to an input constraint */
883 int priority
; /* priority, used to assign registers */
884 int reg
; /* if >= 0, register number used for this operand */
885 int is_llong
; /* true if double register value */
886 int is_memory
; /* true if memory operand */
887 int is_rw
; /* for '+' modifier */
890 static void asm_expr(TCCState
*s1
, ExprValue
*pe
);
891 static int asm_int_expr(TCCState
*s1
);
892 static int find_constraint(ASMOperand
*operands
, int nb_operands
,
893 const char *name
, const char **pp
);
895 static int tcc_assemble(TCCState
*s1
, int do_preprocess
);
899 static void asm_instr(void);
900 static void asm_global_instr(void);
902 /* true if float/double/long double type */
903 static inline int is_float(int t
)
907 return bt
== VT_LDOUBLE
|| bt
== VT_DOUBLE
|| bt
== VT_FLOAT
;
910 #ifdef TCC_TARGET_I386
911 #include "i386-gen.c"
914 #ifdef TCC_TARGET_ARM
918 #ifdef TCC_TARGET_C67
922 #ifdef CONFIG_TCC_STATIC
924 #define RTLD_LAZY 0x001
925 #define RTLD_NOW 0x002
926 #define RTLD_GLOBAL 0x100
927 #define RTLD_DEFAULT NULL
929 /* dummy function for profiling */
930 void *dlopen(const char *filename
, int flag
)
935 const char *dlerror(void)
940 typedef struct TCCSyms
{
945 #define TCCSYM(a) { #a, &a, },
947 /* add the symbol you want here if no dynamic linking is done */
948 static TCCSyms tcc_syms
[] = {
949 #if !defined(CONFIG_TCCBOOT)
958 void *resolve_sym(TCCState
*s1
, const char *symbol
, int type
)
962 while (p
->str
!= NULL
) {
963 if (!strcmp(p
->str
, symbol
))
970 #elif !defined(_WIN32)
974 void *resolve_sym(TCCState
*s1
, const char *sym
, int type
)
976 return dlsym(RTLD_DEFAULT
, sym
);
981 /********************************************************/
983 /* we use our own 'finite' function to avoid potential problems with
984 non standard math libs */
985 /* XXX: endianness dependent */
986 int ieee_finite(double d
)
989 return ((unsigned)((p
[1] | 0x800fffff) + 1)) >> 31;
992 /* copy a string and truncate it. */
993 static char *pstrcpy(char *buf
, int buf_size
, const char *s
)
1000 q_end
= buf
+ buf_size
- 1;
1012 /* strcat and truncate. */
1013 static char *pstrcat(char *buf
, int buf_size
, const char *s
)
1018 pstrcpy(buf
+ len
, buf_size
- len
, s
);
1022 static int strstart(const char *str
, const char *val
, const char **ptr
)
1027 while (*q
!= '\0') {
1039 char *normalize_slashes(char *path
)
1042 for (p
= path
; *p
; ++p
)
1048 char *w32_tcc_lib_path(void)
1050 /* on win32, we suppose the lib and includes are at the location
1052 char path
[1024], *p
;
1053 GetModuleFileNameA(NULL
, path
, sizeof path
);
1054 p
= tcc_basename(normalize_slashes(strlwr(path
)));
1055 if (p
- 5 > path
&& 0 == strncmp(p
- 5, "/bin/", 5))
1060 return strdup(path
);
1064 void set_pages_executable(void *ptr
, unsigned long length
)
1067 unsigned long old_protect
;
1068 VirtualProtect(ptr
, length
, PAGE_EXECUTE_READWRITE
, &old_protect
);
1070 unsigned long start
, end
;
1071 start
= (unsigned long)ptr
& ~(PAGESIZE
- 1);
1072 end
= (unsigned long)ptr
+ length
;
1073 end
= (end
+ PAGESIZE
- 1) & ~(PAGESIZE
- 1);
1074 mprotect((void *)start
, end
- start
, PROT_READ
| PROT_WRITE
| PROT_EXEC
);
1078 /* memory management */
1084 static inline void tcc_free(void *ptr
)
1087 mem_cur_size
-= malloc_usable_size(ptr
);
1092 static void *tcc_malloc(unsigned long size
)
1097 error("memory full");
1099 mem_cur_size
+= malloc_usable_size(ptr
);
1100 if (mem_cur_size
> mem_max_size
)
1101 mem_max_size
= mem_cur_size
;
1106 static void *tcc_mallocz(unsigned long size
)
1109 ptr
= tcc_malloc(size
);
1110 memset(ptr
, 0, size
);
1114 static inline void *tcc_realloc(void *ptr
, unsigned long size
)
1118 mem_cur_size
-= malloc_usable_size(ptr
);
1120 ptr1
= realloc(ptr
, size
);
1122 /* NOTE: count not correct if alloc error, but not critical */
1123 mem_cur_size
+= malloc_usable_size(ptr1
);
1124 if (mem_cur_size
> mem_max_size
)
1125 mem_max_size
= mem_cur_size
;
1130 static char *tcc_strdup(const char *str
)
1133 ptr
= tcc_malloc(strlen(str
) + 1);
1138 #define free(p) use_tcc_free(p)
1139 #define malloc(s) use_tcc_malloc(s)
1140 #define realloc(p, s) use_tcc_realloc(p, s)
1142 static void dynarray_add(void ***ptab
, int *nb_ptr
, void *data
)
1149 /* every power of two we double array size */
1150 if ((nb
& (nb
- 1)) == 0) {
1155 pp
= tcc_realloc(pp
, nb_alloc
* sizeof(void *));
1157 error("memory full");
1164 /* symbol allocator */
1165 static Sym
*__sym_malloc(void)
1167 Sym
*sym_pool
, *sym
, *last_sym
;
1170 sym_pool
= tcc_malloc(SYM_POOL_NB
* sizeof(Sym
));
1172 last_sym
= sym_free_first
;
1174 for(i
= 0; i
< SYM_POOL_NB
; i
++) {
1175 sym
->next
= last_sym
;
1179 sym_free_first
= last_sym
;
1183 static inline Sym
*sym_malloc(void)
1186 sym
= sym_free_first
;
1188 sym
= __sym_malloc();
1189 sym_free_first
= sym
->next
;
1193 static inline void sym_free(Sym
*sym
)
1195 sym
->next
= sym_free_first
;
1196 sym_free_first
= sym
;
1199 Section
*new_section(TCCState
*s1
, const char *name
, int sh_type
, int sh_flags
)
1203 sec
= tcc_mallocz(sizeof(Section
) + strlen(name
));
1204 strcpy(sec
->name
, name
);
1205 sec
->sh_type
= sh_type
;
1206 sec
->sh_flags
= sh_flags
;
1213 sec
->sh_addralign
= 4;
1216 sec
->sh_addralign
= 1;
1219 sec
->sh_addralign
= 32; /* default conservative alignment */
1223 /* only add section if not private */
1224 if (!(sh_flags
& SHF_PRIVATE
)) {
1225 sec
->sh_num
= s1
->nb_sections
;
1226 dynarray_add((void ***)&s1
->sections
, &s1
->nb_sections
, sec
);
1231 static void free_section(Section
*s
)
1237 /* realloc section and set its content to zero */
1238 static void section_realloc(Section
*sec
, unsigned long new_size
)
1241 unsigned char *data
;
1243 size
= sec
->data_allocated
;
1246 while (size
< new_size
)
1248 data
= tcc_realloc(sec
->data
, size
);
1250 error("memory full");
1251 memset(data
+ sec
->data_allocated
, 0, size
- sec
->data_allocated
);
1253 sec
->data_allocated
= size
;
1256 /* reserve at least 'size' bytes in section 'sec' from
1257 sec->data_offset. */
1258 static void *section_ptr_add(Section
*sec
, unsigned long size
)
1260 unsigned long offset
, offset1
;
1262 offset
= sec
->data_offset
;
1263 offset1
= offset
+ size
;
1264 if (offset1
> sec
->data_allocated
)
1265 section_realloc(sec
, offset1
);
1266 sec
->data_offset
= offset1
;
1267 return sec
->data
+ offset
;
1270 /* return a reference to a section, and create it if it does not
1272 Section
*find_section(TCCState
*s1
, const char *name
)
1276 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1277 sec
= s1
->sections
[i
];
1278 if (!strcmp(name
, sec
->name
))
1281 /* sections are created as PROGBITS */
1282 return new_section(s1
, name
, SHT_PROGBITS
, SHF_ALLOC
);
1285 #define SECTION_ABS ((void *)1)
1287 /* update sym->c so that it points to an external symbol in section
1288 'section' with value 'value' */
1289 static void put_extern_sym2(Sym
*sym
, Section
*section
,
1290 unsigned long value
, unsigned long size
,
1291 int can_add_underscore
)
1293 int sym_type
, sym_bind
, sh_num
, info
;
1298 if (section
== NULL
)
1300 else if (section
== SECTION_ABS
)
1303 sh_num
= section
->sh_num
;
1305 if ((sym
->type
.t
& VT_BTYPE
) == VT_FUNC
)
1306 sym_type
= STT_FUNC
;
1308 sym_type
= STT_OBJECT
;
1309 if (sym
->type
.t
& VT_STATIC
)
1310 sym_bind
= STB_LOCAL
;
1312 sym_bind
= STB_GLOBAL
;
1314 name
= get_tok_str(sym
->v
, NULL
);
1315 #ifdef CONFIG_TCC_BCHECK
1316 if (do_bounds_check
) {
1319 /* XXX: avoid doing that for statics ? */
1320 /* if bound checking is activated, we change some function
1321 names by adding the "__bound" prefix */
1324 /* XXX: we rely only on malloc hooks */
1337 strcpy(buf
, "__bound_");
1344 if (tcc_state
->leading_underscore
&& can_add_underscore
) {
1346 pstrcpy(buf1
+ 1, sizeof(buf1
) - 1, name
);
1349 info
= ELF32_ST_INFO(sym_bind
, sym_type
);
1350 sym
->c
= add_elf_sym(symtab_section
, value
, size
, info
, 0, sh_num
, name
);
1352 esym
= &((Elf32_Sym
*)symtab_section
->data
)[sym
->c
];
1353 esym
->st_value
= value
;
1354 esym
->st_size
= size
;
1355 esym
->st_shndx
= sh_num
;
1359 static void put_extern_sym(Sym
*sym
, Section
*section
,
1360 unsigned long value
, unsigned long size
)
1362 put_extern_sym2(sym
, section
, value
, size
, 1);
1365 /* add a new relocation entry to symbol 'sym' in section 's' */
1366 static void greloc(Section
*s
, Sym
*sym
, unsigned long offset
, int type
)
1369 put_extern_sym(sym
, NULL
, 0, 0);
1370 /* now we can add ELF relocation info */
1371 put_elf_reloc(symtab_section
, s
, offset
, type
, sym
->c
);
1374 static inline int isid(int c
)
1376 return (c
>= 'a' && c
<= 'z') ||
1377 (c
>= 'A' && c
<= 'Z') ||
1381 static inline int isnum(int c
)
1383 return c
>= '0' && c
<= '9';
1386 static inline int isoct(int c
)
1388 return c
>= '0' && c
<= '7';
1391 static inline int toup(int c
)
1393 if (c
>= 'a' && c
<= 'z')
1394 return c
- 'a' + 'A';
1399 static void strcat_vprintf(char *buf
, int buf_size
, const char *fmt
, va_list ap
)
1403 vsnprintf(buf
+ len
, buf_size
- len
, fmt
, ap
);
1406 static void strcat_printf(char *buf
, int buf_size
, const char *fmt
, ...)
1410 strcat_vprintf(buf
, buf_size
, fmt
, ap
);
1414 void error1(TCCState
*s1
, int is_warning
, const char *fmt
, va_list ap
)
1421 for(f
= s1
->include_stack
; f
< s1
->include_stack_ptr
; f
++)
1422 strcat_printf(buf
, sizeof(buf
), "In file included from %s:%d:\n",
1423 (*f
)->filename
, (*f
)->line_num
);
1424 if (file
->line_num
> 0) {
1425 strcat_printf(buf
, sizeof(buf
),
1426 "%s:%d: ", file
->filename
, file
->line_num
);
1428 strcat_printf(buf
, sizeof(buf
),
1429 "%s: ", file
->filename
);
1432 strcat_printf(buf
, sizeof(buf
),
1436 strcat_printf(buf
, sizeof(buf
), "warning: ");
1437 strcat_vprintf(buf
, sizeof(buf
), fmt
, ap
);
1439 if (!s1
->error_func
) {
1440 /* default case: stderr */
1441 fprintf(stderr
, "%s\n", buf
);
1443 s1
->error_func(s1
->error_opaque
, buf
);
1445 if (!is_warning
|| s1
->warn_error
)
1450 void tcc_set_error_func(TCCState
*s
, void *error_opaque
,
1451 void (*error_func
)(void *opaque
, const char *msg
))
1453 s
->error_opaque
= error_opaque
;
1454 s
->error_func
= error_func
;
1458 /* error without aborting current compilation */
1459 void error_noabort(const char *fmt
, ...)
1461 TCCState
*s1
= tcc_state
;
1465 error1(s1
, 0, fmt
, ap
);
1469 void error(const char *fmt
, ...)
1471 TCCState
*s1
= tcc_state
;
1475 error1(s1
, 0, fmt
, ap
);
1477 /* better than nothing: in some cases, we accept to handle errors */
1478 if (s1
->error_set_jmp_enabled
) {
1479 longjmp(s1
->error_jmp_buf
, 1);
1481 /* XXX: eliminate this someday */
1486 void expect(const char *msg
)
1488 error("%s expected", msg
);
1491 void warning(const char *fmt
, ...)
1493 TCCState
*s1
= tcc_state
;
1500 error1(s1
, 1, fmt
, ap
);
1507 error("'%c' expected", c
);
1511 static void test_lvalue(void)
1513 if (!(vtop
->r
& VT_LVAL
))
1517 /* allocate a new token */
1518 static TokenSym
*tok_alloc_new(TokenSym
**pts
, const char *str
, int len
)
1520 TokenSym
*ts
, **ptable
;
1523 if (tok_ident
>= SYM_FIRST_ANOM
)
1524 error("memory full");
1526 /* expand token table if needed */
1527 i
= tok_ident
- TOK_IDENT
;
1528 if ((i
% TOK_ALLOC_INCR
) == 0) {
1529 ptable
= tcc_realloc(table_ident
, (i
+ TOK_ALLOC_INCR
) * sizeof(TokenSym
*));
1531 error("memory full");
1532 table_ident
= ptable
;
1535 ts
= tcc_malloc(sizeof(TokenSym
) + len
);
1536 table_ident
[i
] = ts
;
1537 ts
->tok
= tok_ident
++;
1538 ts
->sym_define
= NULL
;
1539 ts
->sym_label
= NULL
;
1540 ts
->sym_struct
= NULL
;
1541 ts
->sym_identifier
= NULL
;
1543 ts
->hash_next
= NULL
;
1544 memcpy(ts
->str
, str
, len
);
1545 ts
->str
[len
] = '\0';
1550 #define TOK_HASH_INIT 1
1551 #define TOK_HASH_FUNC(h, c) ((h) * 263 + (c))
1553 /* find a token and add it if not found */
1554 static TokenSym
*tok_alloc(const char *str
, int len
)
1556 TokenSym
*ts
, **pts
;
1562 h
= TOK_HASH_FUNC(h
, ((unsigned char *)str
)[i
]);
1563 h
&= (TOK_HASH_SIZE
- 1);
1565 pts
= &hash_ident
[h
];
1570 if (ts
->len
== len
&& !memcmp(ts
->str
, str
, len
))
1572 pts
= &(ts
->hash_next
);
1574 return tok_alloc_new(pts
, str
, len
);
1577 /* CString handling */
1579 static void cstr_realloc(CString
*cstr
, int new_size
)
1584 size
= cstr
->size_allocated
;
1586 size
= 8; /* no need to allocate a too small first string */
1587 while (size
< new_size
)
1589 data
= tcc_realloc(cstr
->data_allocated
, size
);
1591 error("memory full");
1592 cstr
->data_allocated
= data
;
1593 cstr
->size_allocated
= size
;
1598 static inline void cstr_ccat(CString
*cstr
, int ch
)
1601 size
= cstr
->size
+ 1;
1602 if (size
> cstr
->size_allocated
)
1603 cstr_realloc(cstr
, size
);
1604 ((unsigned char *)cstr
->data
)[size
- 1] = ch
;
1608 static void cstr_cat(CString
*cstr
, const char *str
)
1620 /* add a wide char */
1621 static void cstr_wccat(CString
*cstr
, int ch
)
1624 size
= cstr
->size
+ sizeof(nwchar_t
);
1625 if (size
> cstr
->size_allocated
)
1626 cstr_realloc(cstr
, size
);
1627 *(nwchar_t
*)(((unsigned char *)cstr
->data
) + size
- sizeof(nwchar_t
)) = ch
;
1631 static void cstr_new(CString
*cstr
)
1633 memset(cstr
, 0, sizeof(CString
));
1636 /* free string and reset it to NULL */
1637 static void cstr_free(CString
*cstr
)
1639 tcc_free(cstr
->data_allocated
);
1643 #define cstr_reset(cstr) cstr_free(cstr)
1645 /* XXX: unicode ? */
1646 static void add_char(CString
*cstr
, int c
)
1648 if (c
== '\'' || c
== '\"' || c
== '\\') {
1649 /* XXX: could be more precise if char or string */
1650 cstr_ccat(cstr
, '\\');
1652 if (c
>= 32 && c
<= 126) {
1655 cstr_ccat(cstr
, '\\');
1657 cstr_ccat(cstr
, 'n');
1659 cstr_ccat(cstr
, '0' + ((c
>> 6) & 7));
1660 cstr_ccat(cstr
, '0' + ((c
>> 3) & 7));
1661 cstr_ccat(cstr
, '0' + (c
& 7));
1666 /* XXX: buffer overflow */
1667 /* XXX: float tokens */
1668 char *get_tok_str(int v
, CValue
*cv
)
1670 static char buf
[STRING_MAX_SIZE
+ 1];
1671 static CString cstr_buf
;
1677 /* NOTE: to go faster, we give a fixed buffer for small strings */
1678 cstr_reset(&cstr_buf
);
1679 cstr_buf
.data
= buf
;
1680 cstr_buf
.size_allocated
= sizeof(buf
);
1686 /* XXX: not quite exact, but only useful for testing */
1687 sprintf(p
, "%u", cv
->ui
);
1691 /* XXX: not quite exact, but only useful for testing */
1692 sprintf(p
, "%Lu", cv
->ull
);
1696 cstr_ccat(&cstr_buf
, '\'');
1697 add_char(&cstr_buf
, cv
->i
);
1698 cstr_ccat(&cstr_buf
, '\'');
1699 cstr_ccat(&cstr_buf
, '\0');
1703 len
= cstr
->size
- 1;
1705 add_char(&cstr_buf
, ((unsigned char *)cstr
->data
)[i
]);
1706 cstr_ccat(&cstr_buf
, '\0');
1711 cstr_ccat(&cstr_buf
, '\"');
1713 len
= cstr
->size
- 1;
1715 add_char(&cstr_buf
, ((unsigned char *)cstr
->data
)[i
]);
1717 len
= (cstr
->size
/ sizeof(nwchar_t
)) - 1;
1719 add_char(&cstr_buf
, ((nwchar_t
*)cstr
->data
)[i
]);
1721 cstr_ccat(&cstr_buf
, '\"');
1722 cstr_ccat(&cstr_buf
, '\0');
1731 return strcpy(p
, "...");
1733 return strcpy(p
, "<<=");
1735 return strcpy(p
, ">>=");
1737 if (v
< TOK_IDENT
) {
1738 /* search in two bytes table */
1752 } else if (v
< tok_ident
) {
1753 return table_ident
[v
- TOK_IDENT
]->str
;
1754 } else if (v
>= SYM_FIRST_ANOM
) {
1755 /* special name for anonymous symbol */
1756 sprintf(p
, "L.%u", v
- SYM_FIRST_ANOM
);
1758 /* should never happen */
1763 return cstr_buf
.data
;
1766 /* push, without hashing */
1767 static Sym
*sym_push2(Sym
**ps
, int v
, int t
, int c
)
1781 /* find a symbol and return its associated structure. 's' is the top
1782 of the symbol stack */
1783 static Sym
*sym_find2(Sym
*s
, int v
)
1793 /* structure lookup */
1794 static inline Sym
*struct_find(int v
)
1797 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1799 return table_ident
[v
]->sym_struct
;
1802 /* find an identifier */
1803 static inline Sym
*sym_find(int v
)
1806 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1808 return table_ident
[v
]->sym_identifier
;
1811 /* push a given symbol on the symbol stack */
1812 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
)
1821 s
= sym_push2(ps
, v
, type
->t
, c
);
1822 s
->type
.ref
= type
->ref
;
1824 /* don't record fields or anonymous symbols */
1826 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1827 /* record symbol in token array */
1828 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1830 ps
= &ts
->sym_struct
;
1832 ps
= &ts
->sym_identifier
;
1839 /* push a global identifier */
1840 static Sym
*global_identifier_push(int v
, int t
, int c
)
1843 s
= sym_push2(&global_stack
, v
, t
, c
);
1844 /* don't record anonymous symbol */
1845 if (v
< SYM_FIRST_ANOM
) {
1846 ps
= &table_ident
[v
- TOK_IDENT
]->sym_identifier
;
1847 /* modify the top most local identifier, so that
1848 sym_identifier will point to 's' when popped */
1850 ps
= &(*ps
)->prev_tok
;
1857 /* pop symbols until top reaches 'b' */
1858 static void sym_pop(Sym
**ptop
, Sym
*b
)
1868 /* remove symbol in token array */
1870 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1871 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1873 ps
= &ts
->sym_struct
;
1875 ps
= &ts
->sym_identifier
;
1886 BufferedFile
*tcc_open(TCCState
*s1
, const char *filename
)
1891 fd
= open(filename
, O_RDONLY
| O_BINARY
);
1894 bf
= tcc_malloc(sizeof(BufferedFile
));
1900 bf
->buf_ptr
= bf
->buffer
;
1901 bf
->buf_end
= bf
->buffer
;
1902 bf
->buffer
[0] = CH_EOB
; /* put eob symbol */
1903 pstrcpy(bf
->filename
, sizeof(bf
->filename
), filename
);
1905 normalize_slashes(bf
->filename
);
1908 bf
->ifndef_macro
= 0;
1909 bf
->ifdef_stack_ptr
= s1
->ifdef_stack_ptr
;
1910 // printf("opening '%s'\n", filename);
1914 void tcc_close(BufferedFile
*bf
)
1916 total_lines
+= bf
->line_num
;
1921 /* fill input buffer and peek next char */
1922 static int tcc_peekc_slow(BufferedFile
*bf
)
1925 /* only tries to read if really end of buffer */
1926 if (bf
->buf_ptr
>= bf
->buf_end
) {
1928 #if defined(PARSE_DEBUG)
1933 len
= read(bf
->fd
, bf
->buffer
, len
);
1940 bf
->buf_ptr
= bf
->buffer
;
1941 bf
->buf_end
= bf
->buffer
+ len
;
1942 *bf
->buf_end
= CH_EOB
;
1944 if (bf
->buf_ptr
< bf
->buf_end
) {
1945 return bf
->buf_ptr
[0];
1947 bf
->buf_ptr
= bf
->buf_end
;
1952 /* return the current character, handling end of block if necessary
1954 static int handle_eob(void)
1956 return tcc_peekc_slow(file
);
1959 /* read next char from current input file and handle end of input buffer */
1960 static inline void inp(void)
1962 ch
= *(++(file
->buf_ptr
));
1963 /* end of buffer/file handling */
1968 /* handle '\[\r]\n' */
1969 static void handle_stray(void)
1971 while (ch
== '\\') {
1976 } else if (ch
== '\r') {
1984 error("stray '\\' in program");
1989 /* skip the stray and handle the \\n case. Output an error if
1990 incorrect char after the stray */
1991 static int handle_stray1(uint8_t *p
)
1995 if (p
>= file
->buf_end
) {
2012 /* handle just the EOB case, but not stray */
2013 #define PEEKC_EOB(c, p)\
2024 /* handle the complicated stray case */
2025 #define PEEKC(c, p)\
2030 c = handle_stray1(p);\
2035 /* input with '\[\r]\n' handling. Note that this function cannot
2036 handle other characters after '\', so you cannot call it inside
2037 strings or comments */
2038 static void minp(void)
2046 /* single line C++ comments */
2047 static uint8_t *parse_line_comment(uint8_t *p
)
2055 if (c
== '\n' || c
== CH_EOF
) {
2057 } else if (c
== '\\') {
2066 } else if (c
== '\r') {
2084 static uint8_t *parse_comment(uint8_t *p
)
2090 /* fast skip loop */
2093 if (c
== '\n' || c
== '*' || c
== '\\')
2097 if (c
== '\n' || c
== '*' || c
== '\\')
2101 /* now we can handle all the cases */
2105 } else if (c
== '*') {
2111 } else if (c
== '/') {
2112 goto end_of_comment
;
2113 } else if (c
== '\\') {
2118 /* skip '\[\r]\n', otherwise just skip the stray */
2124 } else if (c
== '\r') {
2141 /* stray, eob or eof */
2146 error("unexpected end of file in comment");
2147 } else if (c
== '\\') {
2159 /* space exlcuding newline */
2160 static inline int is_space(int ch
)
2162 return ch
== ' ' || ch
== '\t' || ch
== '\v' || ch
== '\f' || ch
== '\r';
2165 static inline void skip_spaces(void)
2167 while (is_space(ch
))
2171 /* parse a string without interpreting escapes */
2172 static uint8_t *parse_pp_string(uint8_t *p
,
2173 int sep
, CString
*str
)
2181 } else if (c
== '\\') {
2186 unterminated_string
:
2187 /* XXX: indicate line number of start of string */
2188 error("missing terminating %c character", sep
);
2189 } else if (c
== '\\') {
2190 /* escape : just skip \[\r]\n */
2195 } else if (c
== '\r') {
2198 expect("'\n' after '\r'");
2201 } else if (c
== CH_EOF
) {
2202 goto unterminated_string
;
2205 cstr_ccat(str
, '\\');
2211 } else if (c
== '\n') {
2214 } else if (c
== '\r') {
2218 cstr_ccat(str
, '\r');
2234 /* skip block of text until #else, #elif or #endif. skip also pairs of
2236 void preprocess_skip(void)
2238 int a
, start_of_line
, c
;
2265 } else if (c
== '\\') {
2266 /* XXX: incorrect: should not give an error */
2267 ch
= file
->buf_ptr
[0];
2275 p
= parse_pp_string(p
, c
, NULL
);
2284 p
= parse_comment(p
);
2285 } else if (ch
== '/') {
2286 p
= parse_line_comment(p
);
2292 if (start_of_line
) {
2297 (tok
== TOK_ELSE
|| tok
== TOK_ELIF
|| tok
== TOK_ENDIF
))
2299 if (tok
== TOK_IF
|| tok
== TOK_IFDEF
|| tok
== TOK_IFNDEF
)
2301 else if (tok
== TOK_ENDIF
)
2315 /* ParseState handling */
2317 /* XXX: currently, no include file info is stored. Thus, we cannot display
2318 accurate messages if the function or data definition spans multiple
2321 /* save current parse state in 's' */
2322 void save_parse_state(ParseState
*s
)
2324 s
->line_num
= file
->line_num
;
2325 s
->macro_ptr
= macro_ptr
;
2330 /* restore parse state from 's' */
2331 void restore_parse_state(ParseState
*s
)
2333 file
->line_num
= s
->line_num
;
2334 macro_ptr
= s
->macro_ptr
;
2339 /* return the number of additional 'ints' necessary to store the
2341 static inline int tok_ext_size(int t
)
2355 error("unsupported token");
2362 return LDOUBLE_SIZE
/ 4;
2368 /* token string handling */
2370 static inline void tok_str_new(TokenString
*s
)
2374 s
->allocated_len
= 0;
2375 s
->last_line_num
= -1;
2378 static void tok_str_free(int *str
)
2383 static int *tok_str_realloc(TokenString
*s
)
2387 if (s
->allocated_len
== 0) {
2390 len
= s
->allocated_len
* 2;
2392 str
= tcc_realloc(s
->str
, len
* sizeof(int));
2394 error("memory full");
2395 s
->allocated_len
= len
;
2400 static void tok_str_add(TokenString
*s
, int t
)
2406 if (len
>= s
->allocated_len
)
2407 str
= tok_str_realloc(s
);
2412 static void tok_str_add2(TokenString
*s
, int t
, CValue
*cv
)
2419 /* allocate space for worst case */
2420 if (len
+ TOK_MAX_SIZE
> s
->allocated_len
)
2421 str
= tok_str_realloc(s
);
2430 str
[len
++] = cv
->tab
[0];
2439 nb_words
= (sizeof(CString
) + cv
->cstr
->size
+ 3) >> 2;
2440 while ((len
+ nb_words
) > s
->allocated_len
)
2441 str
= tok_str_realloc(s
);
2442 cstr
= (CString
*)(str
+ len
);
2444 cstr
->size
= cv
->cstr
->size
;
2445 cstr
->data_allocated
= NULL
;
2446 cstr
->size_allocated
= cstr
->size
;
2447 memcpy((char *)cstr
+ sizeof(CString
),
2448 cv
->cstr
->data
, cstr
->size
);
2455 #if LDOUBLE_SIZE == 8
2458 str
[len
++] = cv
->tab
[0];
2459 str
[len
++] = cv
->tab
[1];
2461 #if LDOUBLE_SIZE == 12
2463 str
[len
++] = cv
->tab
[0];
2464 str
[len
++] = cv
->tab
[1];
2465 str
[len
++] = cv
->tab
[2];
2466 #elif LDOUBLE_SIZE != 8
2467 #error add long double size support
2476 /* add the current parse token in token string 's' */
2477 static void tok_str_add_tok(TokenString
*s
)
2481 /* save line number info */
2482 if (file
->line_num
!= s
->last_line_num
) {
2483 s
->last_line_num
= file
->line_num
;
2484 cval
.i
= s
->last_line_num
;
2485 tok_str_add2(s
, TOK_LINENUM
, &cval
);
2487 tok_str_add2(s
, tok
, &tokc
);
2490 #if LDOUBLE_SIZE == 12
2491 #define LDOUBLE_GET(p, cv) \
2495 #elif LDOUBLE_SIZE == 8
2496 #define LDOUBLE_GET(p, cv) \
2500 #error add long double size support
2504 /* get a token from an integer array and increment pointer
2505 accordingly. we code it as a macro to avoid pointer aliasing. */
2506 #define TOK_GET(t, p, cv) \
2521 cv.cstr = (CString *)p; \
2522 cv.cstr->data = (char *)p + sizeof(CString);\
2523 p += (sizeof(CString) + cv.cstr->size + 3) >> 2;\
2532 case TOK_CLDOUBLE: \
2533 LDOUBLE_GET(p, cv); \
2534 p += LDOUBLE_SIZE / 4; \
2541 /* defines handling */
2542 static inline void define_push(int v
, int macro_type
, int *str
, Sym
*first_arg
)
2546 s
= sym_push2(&define_stack
, v
, macro_type
, (int)str
);
2547 s
->next
= first_arg
;
2548 table_ident
[v
- TOK_IDENT
]->sym_define
= s
;
2551 /* undefined a define symbol. Its name is just set to zero */
2552 static void define_undef(Sym
*s
)
2556 if (v
>= TOK_IDENT
&& v
< tok_ident
)
2557 table_ident
[v
- TOK_IDENT
]->sym_define
= NULL
;
2561 static inline Sym
*define_find(int v
)
2564 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
2566 return table_ident
[v
]->sym_define
;
2569 /* free define stack until top reaches 'b' */
2570 static void free_defines(Sym
*b
)
2578 /* do not free args or predefined defines */
2580 tok_str_free((int *)top
->c
);
2582 if (v
>= TOK_IDENT
&& v
< tok_ident
)
2583 table_ident
[v
- TOK_IDENT
]->sym_define
= NULL
;
2591 static Sym
*label_find(int v
)
2594 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
2596 return table_ident
[v
]->sym_label
;
2599 static Sym
*label_push(Sym
**ptop
, int v
, int flags
)
2602 s
= sym_push2(ptop
, v
, 0, 0);
2604 ps
= &table_ident
[v
- TOK_IDENT
]->sym_label
;
2605 if (ptop
== &global_label_stack
) {
2606 /* modify the top most local identifier, so that
2607 sym_identifier will point to 's' when popped */
2609 ps
= &(*ps
)->prev_tok
;
2616 /* pop labels until element last is reached. Look if any labels are
2617 undefined. Define symbols if '&&label' was used. */
2618 static void label_pop(Sym
**ptop
, Sym
*slast
)
2621 for(s
= *ptop
; s
!= slast
; s
= s1
) {
2623 if (s
->r
== LABEL_DECLARED
) {
2624 warning("label '%s' declared but not used", get_tok_str(s
->v
, NULL
));
2625 } else if (s
->r
== LABEL_FORWARD
) {
2626 error("label '%s' used but not defined",
2627 get_tok_str(s
->v
, NULL
));
2630 /* define corresponding symbol. A size of
2632 put_extern_sym(s
, cur_text_section
, (long)s
->next
, 1);
2636 table_ident
[s
->v
- TOK_IDENT
]->sym_label
= s
->prev_tok
;
2642 /* eval an expression for #if/#elif */
2643 static int expr_preprocess(void)
2649 while (tok
!= TOK_LINEFEED
&& tok
!= TOK_EOF
) {
2650 next(); /* do macro subst */
2651 if (tok
== TOK_DEFINED
) {
2656 c
= define_find(tok
) != 0;
2661 } else if (tok
>= TOK_IDENT
) {
2662 /* if undefined macro */
2666 tok_str_add_tok(&str
);
2668 tok_str_add(&str
, -1); /* simulate end of file */
2669 tok_str_add(&str
, 0);
2670 /* now evaluate C constant expression */
2671 macro_ptr
= str
.str
;
2675 tok_str_free(str
.str
);
2679 #if defined(PARSE_DEBUG) || defined(PP_DEBUG)
2680 static void tok_print(int *str
)
2686 TOK_GET(t
, str
, cval
);
2689 printf(" %s", get_tok_str(t
, &cval
));
2695 /* parse after #define */
2696 static void parse_define(void)
2698 Sym
*s
, *first
, **ps
;
2699 int v
, t
, varg
, is_vaargs
, c
;
2704 error("invalid macro name '%s'", get_tok_str(tok
, &tokc
));
2705 /* XXX: should check if same macro (ANSI) */
2708 /* '(' must be just after macro definition for MACRO_FUNC */
2709 c
= file
->buf_ptr
[0];
2711 c
= handle_stray1(file
->buf_ptr
);
2716 while (tok
!= ')') {
2720 if (varg
== TOK_DOTS
) {
2721 varg
= TOK___VA_ARGS__
;
2723 } else if (tok
== TOK_DOTS
&& gnu_ext
) {
2727 if (varg
< TOK_IDENT
)
2728 error("badly punctuated parameter list");
2729 s
= sym_push2(&define_stack
, varg
| SYM_FIELD
, is_vaargs
, 0);
2740 /* EOF testing necessary for '-D' handling */
2741 while (tok
!= TOK_LINEFEED
&& tok
!= TOK_EOF
) {
2742 tok_str_add2(&str
, tok
, &tokc
);
2745 tok_str_add(&str
, 0);
2747 printf("define %s %d: ", get_tok_str(v
, NULL
), t
);
2750 define_push(v
, t
, str
.str
, first
);
2753 static inline int hash_cached_include(int type
, const char *filename
)
2755 const unsigned char *s
;
2759 h
= TOK_HASH_FUNC(h
, type
);
2762 h
= TOK_HASH_FUNC(h
, *s
);
2765 h
&= (CACHED_INCLUDES_HASH_SIZE
- 1);
2769 /* XXX: use a token or a hash table to accelerate matching ? */
2770 static CachedInclude
*search_cached_include(TCCState
*s1
,
2771 int type
, const char *filename
)
2775 h
= hash_cached_include(type
, filename
);
2776 i
= s1
->cached_includes_hash
[h
];
2780 e
= s1
->cached_includes
[i
- 1];
2781 if (e
->type
== type
&& !strcmp(e
->filename
, filename
))
2788 static inline void add_cached_include(TCCState
*s1
, int type
,
2789 const char *filename
, int ifndef_macro
)
2794 if (search_cached_include(s1
, type
, filename
))
2797 printf("adding cached '%s' %s\n", filename
, get_tok_str(ifndef_macro
, NULL
));
2799 e
= tcc_malloc(sizeof(CachedInclude
) + strlen(filename
));
2803 strcpy(e
->filename
, filename
);
2804 e
->ifndef_macro
= ifndef_macro
;
2805 dynarray_add((void ***)&s1
->cached_includes
, &s1
->nb_cached_includes
, e
);
2806 /* add in hash table */
2807 h
= hash_cached_include(type
, filename
);
2808 e
->hash_next
= s1
->cached_includes_hash
[h
];
2809 s1
->cached_includes_hash
[h
] = s1
->nb_cached_includes
;
2812 static void pragma_parse(TCCState
*s1
)
2817 if (tok
== TOK_pack
) {
2820 #pragma pack(1) // set
2821 #pragma pack() // reset to default
2822 #pragma pack(push,1) // push & set
2823 #pragma pack(pop) // restore previous
2827 if (tok
== TOK_ASM_pop
) {
2829 if (s1
->pack_stack_ptr
<= s1
->pack_stack
) {
2831 error("out of pack stack");
2833 s1
->pack_stack_ptr
--;
2837 if (tok
== TOK_ASM_push
) {
2839 if (s1
->pack_stack_ptr
>= s1
->pack_stack
+ PACK_STACK_SIZE
- 1)
2841 s1
->pack_stack_ptr
++;
2844 if (tok
!= TOK_CINT
) {
2846 error("invalid pack pragma");
2849 if (val
< 1 || val
> 16 || (val
& (val
- 1)) != 0)
2853 *s1
->pack_stack_ptr
= val
;
2859 /* is_bof is true if first non space token at beginning of file */
2860 static void preprocess(int is_bof
)
2862 TCCState
*s1
= tcc_state
;
2863 int size
, i
, c
, n
, saved_parse_flags
;
2864 char buf
[1024], *q
, *p
;
2870 saved_parse_flags
= parse_flags
;
2871 parse_flags
= PARSE_FLAG_PREPROCESS
| PARSE_FLAG_TOK_NUM
|
2872 PARSE_FLAG_LINEFEED
;
2882 s
= define_find(tok
);
2883 /* undefine symbol by putting an invalid name */
2888 case TOK_INCLUDE_NEXT
:
2889 ch
= file
->buf_ptr
[0];
2890 /* XXX: incorrect if comments : use next_nomacro with a special mode */
2895 } else if (ch
== '\"') {
2898 /* XXX: better stray handling */
2901 while (ch
!= c
&& ch
!= '\n' && ch
!= CH_EOF
) {
2902 if ((q
- buf
) < sizeof(buf
) - 1)
2909 /* eat all spaces and comments after include */
2910 /* XXX: slightly incorrect */
2911 while (ch1
!= '\n' && ch1
!= CH_EOF
)
2915 /* computed #include : either we have only strings or
2916 we have anything enclosed in '<>' */
2919 if (tok
== TOK_STR
) {
2920 while (tok
!= TOK_LINEFEED
) {
2921 if (tok
!= TOK_STR
) {
2923 error("'#include' expects \"FILENAME\" or <FILENAME>");
2925 pstrcat(buf
, sizeof(buf
), (char *)tokc
.cstr
->data
);
2931 while (tok
!= TOK_LINEFEED
) {
2932 pstrcat(buf
, sizeof(buf
), get_tok_str(tok
, &tokc
));
2936 /* check syntax and remove '<>' */
2937 if (len
< 2 || buf
[0] != '<' || buf
[len
- 1] != '>')
2938 goto include_syntax
;
2939 memmove(buf
, buf
+ 1, len
- 2);
2940 buf
[len
- 2] = '\0';
2945 e
= search_cached_include(s1
, c
, buf
);
2946 if (e
&& define_find(e
->ifndef_macro
)) {
2947 /* no need to parse the include because the 'ifndef macro'
2950 printf("%s: skipping %s\n", file
->filename
, buf
);
2954 /* first search in current dir if "header.h" */
2956 p
= strrchr(file
->filename
, '/');
2958 size
= p
+ 1 - file
->filename
;
2959 if (size
> sizeof(buf1
) - 1)
2960 size
= sizeof(buf1
) - 1;
2961 memcpy(buf1
, file
->filename
, size
);
2963 pstrcat(buf1
, sizeof(buf1
), buf
);
2964 f
= tcc_open(s1
, buf1
);
2966 if (tok
== TOK_INCLUDE_NEXT
)
2972 if (s1
->include_stack_ptr
>= s1
->include_stack
+ INCLUDE_STACK_SIZE
)
2973 error("#include recursion too deep");
2974 /* now search in all the include paths */
2975 n
= s1
->nb_include_paths
+ s1
->nb_sysinclude_paths
;
2976 for(i
= 0; i
< n
; i
++) {
2978 if (i
< s1
->nb_include_paths
)
2979 path
= s1
->include_paths
[i
];
2981 path
= s1
->sysinclude_paths
[i
- s1
->nb_include_paths
];
2982 pstrcpy(buf1
, sizeof(buf1
), path
);
2983 pstrcat(buf1
, sizeof(buf1
), "/");
2984 pstrcat(buf1
, sizeof(buf1
), buf
);
2985 f
= tcc_open(s1
, buf1
);
2987 if (tok
== TOK_INCLUDE_NEXT
)
2993 error("include file '%s' not found", buf
);
2997 printf("%s: including %s\n", file
->filename
, buf1
);
3000 pstrcpy(f
->inc_filename
, sizeof(f
->inc_filename
), buf
);
3001 /* push current file in stack */
3002 /* XXX: fix current line init */
3003 *s1
->include_stack_ptr
++ = file
;
3005 /* add include file debug info */
3007 put_stabs(file
->filename
, N_BINCL
, 0, 0, 0);
3009 tok_flags
|= TOK_FLAG_BOF
| TOK_FLAG_BOL
;
3010 ch
= file
->buf_ptr
[0];
3018 c
= expr_preprocess();
3024 if (tok
< TOK_IDENT
)
3025 error("invalid argument for '#if%sdef'", c
? "n" : "");
3029 printf("#ifndef %s\n", get_tok_str(tok
, NULL
));
3031 file
->ifndef_macro
= tok
;
3034 c
= (define_find(tok
) != 0) ^ c
;
3036 if (s1
->ifdef_stack_ptr
>= s1
->ifdef_stack
+ IFDEF_STACK_SIZE
)
3037 error("memory full");
3038 *s1
->ifdef_stack_ptr
++ = c
;
3041 if (s1
->ifdef_stack_ptr
== s1
->ifdef_stack
)
3042 error("#else without matching #if");
3043 if (s1
->ifdef_stack_ptr
[-1] & 2)
3044 error("#else after #else");
3045 c
= (s1
->ifdef_stack_ptr
[-1] ^= 3);
3048 if (s1
->ifdef_stack_ptr
== s1
->ifdef_stack
)
3049 error("#elif without matching #if");
3050 c
= s1
->ifdef_stack_ptr
[-1];
3052 error("#elif after #else");
3053 /* last #if/#elif expression was true: we skip */
3056 c
= expr_preprocess();
3057 s1
->ifdef_stack_ptr
[-1] = c
;
3067 if (s1
->ifdef_stack_ptr
<= file
->ifdef_stack_ptr
)
3068 error("#endif without matching #if");
3069 s1
->ifdef_stack_ptr
--;
3070 /* '#ifndef macro' was at the start of file. Now we check if
3071 an '#endif' is exactly at the end of file */
3072 if (file
->ifndef_macro
&&
3073 s1
->ifdef_stack_ptr
== file
->ifdef_stack_ptr
) {
3074 file
->ifndef_macro_saved
= file
->ifndef_macro
;
3075 /* need to set to zero to avoid false matches if another
3076 #ifndef at middle of file */
3077 file
->ifndef_macro
= 0;
3078 while (tok
!= TOK_LINEFEED
)
3080 tok_flags
|= TOK_FLAG_ENDIF
;
3086 if (tok
!= TOK_CINT
)
3088 file
->line_num
= tokc
.i
- 1; /* the line number will be incremented after */
3090 if (tok
!= TOK_LINEFEED
) {
3093 pstrcpy(file
->filename
, sizeof(file
->filename
),
3094 (char *)tokc
.cstr
->data
);
3100 ch
= file
->buf_ptr
[0];
3103 while (ch
!= '\n' && ch
!= CH_EOF
) {
3104 if ((q
- buf
) < sizeof(buf
) - 1)
3110 error("#error %s", buf
);
3112 warning("#warning %s", buf
);
3118 if (tok
== TOK_LINEFEED
|| tok
== '!' || tok
== TOK_CINT
) {
3119 /* '!' is ignored to allow C scripts. numbers are ignored
3120 to emulate cpp behaviour */
3122 if (!(saved_parse_flags
& PARSE_FLAG_ASM_COMMENTS
))
3123 error("invalid preprocessing directive #%s", get_tok_str(tok
, &tokc
));
3127 /* ignore other preprocess commands or #! for C scripts */
3128 while (tok
!= TOK_LINEFEED
)
3131 parse_flags
= saved_parse_flags
;
3134 /* evaluate escape codes in a string. */
3135 static void parse_escape_string(CString
*outstr
, const uint8_t *buf
, int is_long
)
3150 case '0': case '1': case '2': case '3':
3151 case '4': case '5': case '6': case '7':
3152 /* at most three octal digits */
3157 n
= n
* 8 + c
- '0';
3161 n
= n
* 8 + c
- '0';
3166 goto add_char_nonext
;
3174 if (c
>= 'a' && c
<= 'f')
3176 else if (c
>= 'A' && c
<= 'F')
3186 goto add_char_nonext
;
3210 goto invalid_escape
;
3220 if (c
>= '!' && c
<= '~')
3221 warning("unknown escape sequence: \'\\%c\'", c
);
3223 warning("unknown escape sequence: \'\\x%x\'", c
);
3230 cstr_ccat(outstr
, c
);
3232 cstr_wccat(outstr
, c
);
3234 /* add a trailing '\0' */
3236 cstr_ccat(outstr
, '\0');
3238 cstr_wccat(outstr
, '\0');
3241 /* we use 64 bit numbers */
3244 /* bn = (bn << shift) | or_val */
3245 void bn_lshift(unsigned int *bn
, int shift
, int or_val
)
3249 for(i
=0;i
<BN_SIZE
;i
++) {
3251 bn
[i
] = (v
<< shift
) | or_val
;
3252 or_val
= v
>> (32 - shift
);
3256 void bn_zero(unsigned int *bn
)
3259 for(i
=0;i
<BN_SIZE
;i
++) {
3264 /* parse number in null terminated string 'p' and return it in the
3266 void parse_number(const char *p
)
3268 int b
, t
, shift
, frac_bits
, s
, exp_val
, ch
;
3270 unsigned int bn
[BN_SIZE
];
3281 goto float_frac_parse
;
3282 } else if (t
== '0') {
3283 if (ch
== 'x' || ch
== 'X') {
3287 } else if (tcc_ext
&& (ch
== 'b' || ch
== 'B')) {
3293 /* parse all digits. cannot check octal numbers at this stage
3294 because of floating point constants */
3296 if (ch
>= 'a' && ch
<= 'f')
3298 else if (ch
>= 'A' && ch
<= 'F')
3306 if (q
>= token_buf
+ STRING_MAX_SIZE
) {
3308 error("number too long");
3314 ((ch
== 'e' || ch
== 'E') && b
== 10) ||
3315 ((ch
== 'p' || ch
== 'P') && (b
== 16 || b
== 2))) {
3317 /* NOTE: strtox should support that for hexa numbers, but
3318 non ISOC99 libcs do not support it, so we prefer to do
3320 /* hexadecimal or binary floats */
3321 /* XXX: handle overflows */
3333 } else if (t
>= 'a') {
3335 } else if (t
>= 'A') {
3340 bn_lshift(bn
, shift
, t
);
3347 if (t
>= 'a' && t
<= 'f') {
3349 } else if (t
>= 'A' && t
<= 'F') {
3351 } else if (t
>= '0' && t
<= '9') {
3357 error("invalid digit");
3358 bn_lshift(bn
, shift
, t
);
3363 if (ch
!= 'p' && ch
!= 'P')
3370 } else if (ch
== '-') {
3374 if (ch
< '0' || ch
> '9')
3375 expect("exponent digits");
3376 while (ch
>= '0' && ch
<= '9') {
3377 exp_val
= exp_val
* 10 + ch
- '0';
3380 exp_val
= exp_val
* s
;
3382 /* now we can generate the number */
3383 /* XXX: should patch directly float number */
3384 d
= (double)bn
[1] * 4294967296.0 + (double)bn
[0];
3385 d
= ldexp(d
, exp_val
- frac_bits
);
3390 /* float : should handle overflow */
3392 } else if (t
== 'L') {
3395 /* XXX: not large enough */
3396 tokc
.ld
= (long double)d
;
3402 /* decimal floats */
3404 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3409 while (ch
>= '0' && ch
<= '9') {
3410 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3416 if (ch
== 'e' || ch
== 'E') {
3417 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3421 if (ch
== '-' || ch
== '+') {
3422 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3427 if (ch
< '0' || ch
> '9')
3428 expect("exponent digits");
3429 while (ch
>= '0' && ch
<= '9') {
3430 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3442 tokc
.f
= strtof(token_buf
, NULL
);
3443 } else if (t
== 'L') {
3446 tokc
.ld
= strtold(token_buf
, NULL
);
3449 tokc
.d
= strtod(token_buf
, NULL
);
3453 unsigned long long n
, n1
;
3456 /* integer number */
3459 if (b
== 10 && *q
== '0') {
3466 /* no need for checks except for base 10 / 8 errors */
3469 } else if (t
>= 'a') {
3471 } else if (t
>= 'A') {
3476 error("invalid digit");
3480 /* detect overflow */
3481 /* XXX: this test is not reliable */
3483 error("integer constant overflow");
3486 /* XXX: not exactly ANSI compliant */
3487 if ((n
& 0xffffffff00000000LL
) != 0) {
3492 } else if (n
> 0x7fffffff) {
3503 error("three 'l's in integer constant");
3506 if (tok
== TOK_CINT
)
3508 else if (tok
== TOK_CUINT
)
3512 } else if (t
== 'U') {
3514 error("two 'u's in integer constant");
3516 if (tok
== TOK_CINT
)
3518 else if (tok
== TOK_CLLONG
)
3525 if (tok
== TOK_CINT
|| tok
== TOK_CUINT
)
3533 #define PARSE2(c1, tok1, c2, tok2) \
3544 /* return next token without macro substitution */
3545 static inline void next_nomacro1(void)
3565 /* first look if it is in fact an end of buffer */
3566 if (p
>= file
->buf_end
) {
3570 if (p
>= file
->buf_end
)
3583 TCCState
*s1
= tcc_state
;
3584 if ((parse_flags
& PARSE_FLAG_LINEFEED
)
3585 && !(tok_flags
& TOK_FLAG_EOF
)) {
3586 tok_flags
|= TOK_FLAG_EOF
;
3588 goto keep_tok_flags
;
3589 } else if (s1
->include_stack_ptr
== s1
->include_stack
||
3590 !(parse_flags
& PARSE_FLAG_PREPROCESS
)) {
3591 /* no include left : end of file. */
3594 tok_flags
&= ~TOK_FLAG_EOF
;
3595 /* pop include file */
3597 /* test if previous '#endif' was after a #ifdef at
3599 if (tok_flags
& TOK_FLAG_ENDIF
) {
3601 printf("#endif %s\n", get_tok_str(file
->ifndef_macro_saved
, NULL
));
3603 add_cached_include(s1
, file
->inc_type
, file
->inc_filename
,
3604 file
->ifndef_macro_saved
);
3607 /* add end of include file debug info */
3609 put_stabd(N_EINCL
, 0, 0);
3611 /* pop include stack */
3613 s1
->include_stack_ptr
--;
3614 file
= *s1
->include_stack_ptr
;
3623 tok_flags
|= TOK_FLAG_BOL
;
3625 if (0 == (parse_flags
& PARSE_FLAG_LINEFEED
))
3628 goto keep_tok_flags
;
3633 if ((tok_flags
& TOK_FLAG_BOL
) &&
3634 (parse_flags
& PARSE_FLAG_PREPROCESS
)) {
3636 preprocess(tok_flags
& TOK_FLAG_BOF
);
3642 tok
= TOK_TWOSHARPS
;
3644 if (parse_flags
& PARSE_FLAG_ASM_COMMENTS
) {
3645 p
= parse_line_comment(p
- 1);
3654 case 'a': case 'b': case 'c': case 'd':
3655 case 'e': case 'f': case 'g': case 'h':
3656 case 'i': case 'j': case 'k': case 'l':
3657 case 'm': case 'n': case 'o': case 'p':
3658 case 'q': case 'r': case 's': case 't':
3659 case 'u': case 'v': case 'w': case 'x':
3661 case 'A': case 'B': case 'C': case 'D':
3662 case 'E': case 'F': case 'G': case 'H':
3663 case 'I': case 'J': case 'K':
3664 case 'M': case 'N': case 'O': case 'P':
3665 case 'Q': case 'R': case 'S': case 'T':
3666 case 'U': case 'V': case 'W': case 'X':
3672 h
= TOK_HASH_FUNC(h
, c
);
3676 if (!isidnum_table
[c
])
3678 h
= TOK_HASH_FUNC(h
, c
);
3685 /* fast case : no stray found, so we have the full token
3686 and we have already hashed it */
3688 h
&= (TOK_HASH_SIZE
- 1);
3689 pts
= &hash_ident
[h
];
3694 if (ts
->len
== len
&& !memcmp(ts
->str
, p1
, len
))
3696 pts
= &(ts
->hash_next
);
3698 ts
= tok_alloc_new(pts
, p1
, len
);
3702 cstr_reset(&tokcstr
);
3705 cstr_ccat(&tokcstr
, *p1
);
3711 while (isidnum_table
[c
]) {
3712 cstr_ccat(&tokcstr
, c
);
3715 ts
= tok_alloc(tokcstr
.data
, tokcstr
.size
);
3721 if (t
!= '\\' && t
!= '\'' && t
!= '\"') {
3723 goto parse_ident_fast
;
3726 if (c
== '\'' || c
== '\"') {
3730 cstr_reset(&tokcstr
);
3731 cstr_ccat(&tokcstr
, 'L');
3732 goto parse_ident_slow
;
3736 case '0': case '1': case '2': case '3':
3737 case '4': case '5': case '6': case '7':
3740 cstr_reset(&tokcstr
);
3741 /* after the first digit, accept digits, alpha, '.' or sign if
3742 prefixed by 'eEpP' */
3746 cstr_ccat(&tokcstr
, c
);
3748 if (!(isnum(c
) || isid(c
) || c
== '.' ||
3749 ((c
== '+' || c
== '-') &&
3750 (t
== 'e' || t
== 'E' || t
== 'p' || t
== 'P'))))
3753 /* We add a trailing '\0' to ease parsing */
3754 cstr_ccat(&tokcstr
, '\0');
3755 tokc
.cstr
= &tokcstr
;
3759 /* special dot handling because it can also start a number */
3762 cstr_reset(&tokcstr
);
3763 cstr_ccat(&tokcstr
, '.');
3765 } else if (c
== '.') {
3785 /* parse the string */
3787 p
= parse_pp_string(p
, sep
, &str
);
3788 cstr_ccat(&str
, '\0');
3790 /* eval the escape (should be done as TOK_PPNUM) */
3791 cstr_reset(&tokcstr
);
3792 parse_escape_string(&tokcstr
, str
.data
, is_long
);
3797 /* XXX: make it portable */
3801 char_size
= sizeof(nwchar_t
);
3802 if (tokcstr
.size
<= char_size
)
3803 error("empty character constant");
3804 if (tokcstr
.size
> 2 * char_size
)
3805 warning("multi-character character constant");
3807 tokc
.i
= *(int8_t *)tokcstr
.data
;
3810 tokc
.i
= *(nwchar_t
*)tokcstr
.data
;
3814 tokc
.cstr
= &tokcstr
;
3828 } else if (c
== '<') {
3846 } else if (c
== '>') {
3864 } else if (c
== '=') {
3877 } else if (c
== '=') {
3890 } else if (c
== '=') {
3903 } else if (c
== '=') {
3906 } else if (c
== '>') {
3914 PARSE2('!', '!', '=', TOK_NE
)
3915 PARSE2('=', '=', '=', TOK_EQ
)
3916 PARSE2('*', '*', '=', TOK_A_MUL
)
3917 PARSE2('%', '%', '=', TOK_A_MOD
)
3918 PARSE2('^', '^', '=', TOK_A_XOR
)
3920 /* comments or operator */
3924 p
= parse_comment(p
);
3926 } else if (c
== '/') {
3927 p
= parse_line_comment(p
);
3929 } else if (c
== '=') {
3949 case '$': /* only used in assembler */
3950 case '@': /* dito */
3955 error("unrecognized character \\x%02x", c
);
3961 #if defined(PARSE_DEBUG)
3962 printf("token = %s\n", get_tok_str(tok
, &tokc
));
3966 /* return next token without macro substitution. Can read input from
3968 static void next_nomacro(void)
3974 TOK_GET(tok
, macro_ptr
, tokc
);
3975 if (tok
== TOK_LINENUM
) {
3976 file
->line_num
= tokc
.i
;
3985 /* substitute args in macro_str and return allocated string */
3986 static int *macro_arg_subst(Sym
**nested_list
, int *macro_str
, Sym
*args
)
3988 int *st
, last_tok
, t
, notfirst
;
3997 TOK_GET(t
, macro_str
, cval
);
4002 TOK_GET(t
, macro_str
, cval
);
4005 s
= sym_find2(args
, t
);
4012 cstr_ccat(&cstr
, ' ');
4013 TOK_GET(t
, st
, cval
);
4014 cstr_cat(&cstr
, get_tok_str(t
, &cval
));
4017 cstr_ccat(&cstr
, '\0');
4019 printf("stringize: %s\n", (char *)cstr
.data
);
4023 tok_str_add2(&str
, TOK_STR
, &cval
);
4026 tok_str_add2(&str
, t
, &cval
);
4028 } else if (t
>= TOK_IDENT
) {
4029 s
= sym_find2(args
, t
);
4032 /* if '##' is present before or after, no arg substitution */
4033 if (*macro_str
== TOK_TWOSHARPS
|| last_tok
== TOK_TWOSHARPS
) {
4034 /* special case for var arg macros : ## eats the
4035 ',' if empty VA_ARGS variable. */
4036 /* XXX: test of the ',' is not 100%
4037 reliable. should fix it to avoid security
4039 if (gnu_ext
&& s
->type
.t
&&
4040 last_tok
== TOK_TWOSHARPS
&&
4041 str
.len
>= 2 && str
.str
[str
.len
- 2] == ',') {
4043 /* suppress ',' '##' */
4046 /* suppress '##' and add variable */
4054 TOK_GET(t1
, st
, cval
);
4057 tok_str_add2(&str
, t1
, &cval
);
4061 /* NOTE: the stream cannot be read when macro
4062 substituing an argument */
4063 macro_subst(&str
, nested_list
, st
, NULL
);
4066 tok_str_add(&str
, t
);
4069 tok_str_add2(&str
, t
, &cval
);
4073 tok_str_add(&str
, 0);
4077 static char const ab_month_name
[12][4] =
4079 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
4080 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
4083 /* do macro substitution of current token with macro 's' and add
4084 result to (tok_str,tok_len). 'nested_list' is the list of all
4085 macros we got inside to avoid recursing. Return non zero if no
4086 substitution needs to be done */
4087 static int macro_subst_tok(TokenString
*tok_str
,
4088 Sym
**nested_list
, Sym
*s
, struct macro_level
**can_read_stream
)
4090 Sym
*args
, *sa
, *sa1
;
4091 int mstr_allocated
, parlevel
, *mstr
, t
, t1
;
4098 /* if symbol is a macro, prepare substitution */
4099 /* special macros */
4100 if (tok
== TOK___LINE__
) {
4101 snprintf(buf
, sizeof(buf
), "%d", file
->line_num
);
4105 } else if (tok
== TOK___FILE__
) {
4106 cstrval
= file
->filename
;
4108 } else if (tok
== TOK___DATE__
|| tok
== TOK___TIME__
) {
4113 tm
= localtime(&ti
);
4114 if (tok
== TOK___DATE__
) {
4115 snprintf(buf
, sizeof(buf
), "%s %2d %d",
4116 ab_month_name
[tm
->tm_mon
], tm
->tm_mday
, tm
->tm_year
+ 1900);
4118 snprintf(buf
, sizeof(buf
), "%02d:%02d:%02d",
4119 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
4126 cstr_cat(&cstr
, cstrval
);
4127 cstr_ccat(&cstr
, '\0');
4129 tok_str_add2(tok_str
, t1
, &cval
);
4134 if (s
->type
.t
== MACRO_FUNC
) {
4135 /* NOTE: we do not use next_nomacro to avoid eating the
4136 next token. XXX: find better solution */
4140 if (t
== 0 && can_read_stream
) {
4141 /* end of macro stream: we must look at the token
4142 after in the file */
4143 struct macro_level
*ml
= *can_read_stream
;
4149 *can_read_stream
= ml
-> prev
;
4154 /* XXX: incorrect with comments */
4155 ch
= file
->buf_ptr
[0];
4156 while (is_space(ch
) || ch
== '\n')
4160 if (t
!= '(') /* no macro subst */
4163 /* argument macro */
4168 /* NOTE: empty args are allowed, except if no args */
4170 /* handle '()' case */
4171 if (!args
&& !sa
&& tok
== ')')
4174 error("macro '%s' used with too many args",
4175 get_tok_str(s
->v
, 0));
4178 /* NOTE: non zero sa->t indicates VA_ARGS */
4179 while ((parlevel
> 0 ||
4181 (tok
!= ',' || sa
->type
.t
))) &&
4185 else if (tok
== ')')
4187 if (tok
!= TOK_LINEFEED
)
4188 tok_str_add2(&str
, tok
, &tokc
);
4191 tok_str_add(&str
, 0);
4192 sym_push2(&args
, sa
->v
& ~SYM_FIELD
, sa
->type
.t
, (int)str
.str
);
4195 /* special case for gcc var args: add an empty
4196 var arg argument if it is omitted */
4197 if (sa
&& sa
->type
.t
&& gnu_ext
)
4207 error("macro '%s' used with too few args",
4208 get_tok_str(s
->v
, 0));
4211 /* now subst each arg */
4212 mstr
= macro_arg_subst(nested_list
, mstr
, args
);
4217 tok_str_free((int *)sa
->c
);
4223 sym_push2(nested_list
, s
->v
, 0, 0);
4224 macro_subst(tok_str
, nested_list
, mstr
, can_read_stream
);
4225 /* pop nested defined symbol */
4227 *nested_list
= sa1
->prev
;
4235 /* handle the '##' operator. Return NULL if no '##' seen. Otherwise
4236 return the resulting string (which must be freed). */
4237 static inline int *macro_twosharps(const int *macro_str
)
4240 const int *macro_ptr1
, *start_macro_ptr
, *ptr
, *saved_macro_ptr
;
4242 const char *p1
, *p2
;
4244 TokenString macro_str1
;
4247 start_macro_ptr
= macro_str
;
4248 /* we search the first '##' */
4250 macro_ptr1
= macro_str
;
4251 TOK_GET(t
, macro_str
, cval
);
4252 /* nothing more to do if end of string */
4255 if (*macro_str
== TOK_TWOSHARPS
)
4259 /* we saw '##', so we need more processing to handle it */
4261 tok_str_new(¯o_str1
);
4265 /* add all tokens seen so far */
4266 for(ptr
= start_macro_ptr
; ptr
< macro_ptr1
;) {
4267 TOK_GET(t
, ptr
, cval
);
4268 tok_str_add2(¯o_str1
, t
, &cval
);
4270 saved_macro_ptr
= macro_ptr
;
4271 /* XXX: get rid of the use of macro_ptr here */
4272 macro_ptr
= (int *)macro_str
;
4274 while (*macro_ptr
== TOK_TWOSHARPS
) {
4276 macro_ptr1
= macro_ptr
;
4279 TOK_GET(t
, macro_ptr
, cval
);
4280 /* We concatenate the two tokens if we have an
4281 identifier or a preprocessing number */
4283 p1
= get_tok_str(tok
, &tokc
);
4284 cstr_cat(&cstr
, p1
);
4285 p2
= get_tok_str(t
, &cval
);
4286 cstr_cat(&cstr
, p2
);
4287 cstr_ccat(&cstr
, '\0');
4289 if ((tok
>= TOK_IDENT
|| tok
== TOK_PPNUM
) &&
4290 (t
>= TOK_IDENT
|| t
== TOK_PPNUM
)) {
4291 if (tok
== TOK_PPNUM
) {
4292 /* if number, then create a number token */
4293 /* NOTE: no need to allocate because
4294 tok_str_add2() does it */
4295 cstr_reset(&tokcstr
);
4298 tokc
.cstr
= &tokcstr
;
4300 /* if identifier, we must do a test to
4301 validate we have a correct identifier */
4302 if (t
== TOK_PPNUM
) {
4312 if (!isnum(c
) && !isid(c
))
4316 ts
= tok_alloc(cstr
.data
, strlen(cstr
.data
));
4317 tok
= ts
->tok
; /* modify current token */
4320 const char *str
= cstr
.data
;
4321 const unsigned char *q
;
4323 /* we look for a valid token */
4324 /* XXX: do more extensive checks */
4325 if (!strcmp(str
, ">>=")) {
4327 } else if (!strcmp(str
, "<<=")) {
4329 } else if (strlen(str
) == 2) {
4330 /* search in two bytes table */
4335 if (q
[0] == str
[0] && q
[1] == str
[1])
4342 /* NOTE: because get_tok_str use a static buffer,
4345 p1
= get_tok_str(tok
, &tokc
);
4346 cstr_cat(&cstr
, p1
);
4347 cstr_ccat(&cstr
, '\0');
4348 p2
= get_tok_str(t
, &cval
);
4349 warning("pasting \"%s\" and \"%s\" does not give a valid preprocessing token", cstr
.data
, p2
);
4350 /* cannot merge tokens: just add them separately */
4351 tok_str_add2(¯o_str1
, tok
, &tokc
);
4352 /* XXX: free associated memory ? */
4359 tok_str_add2(¯o_str1
, tok
, &tokc
);
4364 macro_ptr
= (int *)saved_macro_ptr
;
4366 tok_str_add(¯o_str1
, 0);
4367 return macro_str1
.str
;
4371 /* do macro substitution of macro_str and add result to
4372 (tok_str,tok_len). 'nested_list' is the list of all macros we got
4373 inside to avoid recursing. */
4374 static void macro_subst(TokenString
*tok_str
, Sym
**nested_list
,
4375 const int *macro_str
, struct macro_level
** can_read_stream
)
4382 struct macro_level ml
;
4384 /* first scan for '##' operator handling */
4386 macro_str1
= macro_twosharps(ptr
);
4390 /* NOTE: ptr == NULL can only happen if tokens are read from
4391 file stream due to a macro function call */
4394 TOK_GET(t
, ptr
, cval
);
4399 /* if nested substitution, do nothing */
4400 if (sym_find2(*nested_list
, t
))
4403 if (can_read_stream
)
4404 ml
.prev
= *can_read_stream
, *can_read_stream
= &ml
;
4405 macro_ptr
= (int *)ptr
;
4407 ret
= macro_subst_tok(tok_str
, nested_list
, s
, can_read_stream
);
4408 ptr
= (int *)macro_ptr
;
4410 if (can_read_stream
&& *can_read_stream
== &ml
)
4411 *can_read_stream
= ml
.prev
;
4416 tok_str_add2(tok_str
, t
, &cval
);
4420 tok_str_free(macro_str1
);
4423 /* return next token with macro substitution */
4424 static void next(void)
4426 Sym
*nested_list
, *s
;
4428 struct macro_level
*ml
;
4433 /* if not reading from macro substituted string, then try
4434 to substitute macros */
4435 if (tok
>= TOK_IDENT
&&
4436 (parse_flags
& PARSE_FLAG_PREPROCESS
)) {
4437 s
= define_find(tok
);
4439 /* we have a macro: we try to substitute */
4443 if (macro_subst_tok(&str
, &nested_list
, s
, &ml
) == 0) {
4444 /* substitution done, NOTE: maybe empty */
4445 tok_str_add(&str
, 0);
4446 macro_ptr
= str
.str
;
4447 macro_ptr_allocated
= str
.str
;
4454 /* end of macro or end of unget buffer */
4455 if (unget_buffer_enabled
) {
4456 macro_ptr
= unget_saved_macro_ptr
;
4457 unget_buffer_enabled
= 0;
4459 /* end of macro string: free it */
4460 tok_str_free(macro_ptr_allocated
);
4467 /* convert preprocessor tokens into C tokens */
4468 if (tok
== TOK_PPNUM
&&
4469 (parse_flags
& PARSE_FLAG_TOK_NUM
)) {
4470 parse_number((char *)tokc
.cstr
->data
);
4474 /* push back current token and set current token to 'last_tok'. Only
4475 identifier case handled for labels. */
4476 static inline void unget_tok(int last_tok
)
4480 unget_saved_macro_ptr
= macro_ptr
;
4481 unget_buffer_enabled
= 1;
4482 q
= unget_saved_buffer
;
4485 n
= tok_ext_size(tok
) - 1;
4488 *q
= 0; /* end of token string */
4493 void swap(int *p
, int *q
)
4501 void vsetc(CType
*type
, int r
, CValue
*vc
)
4505 if (vtop
>= vstack
+ (VSTACK_SIZE
- 1))
4506 error("memory full");
4507 /* cannot let cpu flags if other instruction are generated. Also
4508 avoid leaving VT_JMP anywhere except on the top of the stack
4509 because it would complicate the code generator. */
4510 if (vtop
>= vstack
) {
4511 v
= vtop
->r
& VT_VALMASK
;
4512 if (v
== VT_CMP
|| (v
& ~1) == VT_JMP
)
4518 vtop
->r2
= VT_CONST
;
4522 /* push integer constant */
4527 vsetc(&int_type
, VT_CONST
, &cval
);
4530 /* Return a static symbol pointing to a section */
4531 static Sym
*get_sym_ref(CType
*type
, Section
*sec
,
4532 unsigned long offset
, unsigned long size
)
4538 sym
= global_identifier_push(v
, type
->t
| VT_STATIC
, 0);
4539 sym
->type
.ref
= type
->ref
;
4540 sym
->r
= VT_CONST
| VT_SYM
;
4541 put_extern_sym(sym
, sec
, offset
, size
);
4545 /* push a reference to a section offset by adding a dummy symbol */
4546 static void vpush_ref(CType
*type
, Section
*sec
, unsigned long offset
, unsigned long size
)
4551 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
4552 vtop
->sym
= get_sym_ref(type
, sec
, offset
, size
);
4555 /* define a new external reference to a symbol 'v' of type 'u' */
4556 static Sym
*external_global_sym(int v
, CType
*type
, int r
)
4562 /* push forward reference */
4563 s
= global_identifier_push(v
, type
->t
| VT_EXTERN
, 0);
4564 s
->type
.ref
= type
->ref
;
4565 s
->r
= r
| VT_CONST
| VT_SYM
;
4570 /* define a new external reference to a symbol 'v' of type 'u' */
4571 static Sym
*external_sym(int v
, CType
*type
, int r
)
4577 /* push forward reference */
4578 s
= sym_push(v
, type
, r
| VT_CONST
| VT_SYM
, 0);
4579 s
->type
.t
|= VT_EXTERN
;
4581 if (!is_compatible_types(&s
->type
, type
))
4582 error("incompatible types for redefinition of '%s'",
4583 get_tok_str(v
, NULL
));
4588 /* push a reference to global symbol v */
4589 static void vpush_global_sym(CType
*type
, int v
)
4594 sym
= external_global_sym(v
, type
, 0);
4596 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
4600 void vset(CType
*type
, int r
, int v
)
4605 vsetc(type
, r
, &cval
);
4608 void vseti(int r
, int v
)
4624 void vpushv(SValue
*v
)
4626 if (vtop
>= vstack
+ (VSTACK_SIZE
- 1))
4627 error("memory full");
4637 /* save r to the memory stack, and mark it as being free */
4638 void save_reg(int r
)
4640 int l
, saved
, size
, align
;
4644 /* modify all stack values */
4647 for(p
=vstack
;p
<=vtop
;p
++) {
4648 if ((p
->r
& VT_VALMASK
) == r
||
4649 ((p
->type
.t
& VT_BTYPE
) == VT_LLONG
&& (p
->r2
& VT_VALMASK
) == r
)) {
4650 /* must save value on stack if not already done */
4652 /* NOTE: must reload 'r' because r might be equal to r2 */
4653 r
= p
->r
& VT_VALMASK
;
4654 /* store register in the stack */
4656 if ((p
->r
& VT_LVAL
) ||
4657 (!is_float(type
->t
) && (type
->t
& VT_BTYPE
) != VT_LLONG
))
4659 size
= type_size(type
, &align
);
4660 loc
= (loc
- size
) & -align
;
4661 sv
.type
.t
= type
->t
;
4662 sv
.r
= VT_LOCAL
| VT_LVAL
;
4665 #ifdef TCC_TARGET_I386
4666 /* x86 specific: need to pop fp register ST0 if saved */
4667 if (r
== TREG_ST0
) {
4668 o(0xd9dd); /* fstp %st(1) */
4671 /* special long long case */
4672 if ((type
->t
& VT_BTYPE
) == VT_LLONG
) {
4679 /* mark that stack entry as being saved on the stack */
4680 if (p
->r
& VT_LVAL
) {
4681 /* also clear the bounded flag because the
4682 relocation address of the function was stored in
4684 p
->r
= (p
->r
& ~(VT_VALMASK
| VT_BOUNDED
)) | VT_LLOCAL
;
4686 p
->r
= lvalue_type(p
->type
.t
) | VT_LOCAL
;
4694 /* find a register of class 'rc2' with at most one reference on stack.
4695 * If none, call get_reg(rc) */
4696 int get_reg_ex(int rc
, int rc2
)
4701 for(r
=0;r
<NB_REGS
;r
++) {
4702 if (reg_classes
[r
] & rc2
) {
4705 for(p
= vstack
; p
<= vtop
; p
++) {
4706 if ((p
->r
& VT_VALMASK
) == r
||
4707 (p
->r2
& VT_VALMASK
) == r
)
4717 /* find a free register of class 'rc'. If none, save one register */
4723 /* find a free register */
4724 for(r
=0;r
<NB_REGS
;r
++) {
4725 if (reg_classes
[r
] & rc
) {
4726 for(p
=vstack
;p
<=vtop
;p
++) {
4727 if ((p
->r
& VT_VALMASK
) == r
||
4728 (p
->r2
& VT_VALMASK
) == r
)
4736 /* no register left : free the first one on the stack (VERY
4737 IMPORTANT to start from the bottom to ensure that we don't
4738 spill registers used in gen_opi()) */
4739 for(p
=vstack
;p
<=vtop
;p
++) {
4740 r
= p
->r
& VT_VALMASK
;
4741 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
))
4743 /* also look at second register (if long long) */
4744 r
= p
->r2
& VT_VALMASK
;
4745 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
)) {
4751 /* Should never comes here */
4755 /* save registers up to (vtop - n) stack entry */
4756 void save_regs(int n
)
4761 for(p
= vstack
;p
<= p1
; p
++) {
4762 r
= p
->r
& VT_VALMASK
;
4769 /* move register 's' to 'r', and flush previous value of r to memory
4771 void move_reg(int r
, int s
)
4784 /* get address of vtop (vtop MUST BE an lvalue) */
4787 vtop
->r
&= ~VT_LVAL
;
4788 /* tricky: if saved lvalue, then we can go back to lvalue */
4789 if ((vtop
->r
& VT_VALMASK
) == VT_LLOCAL
)
4790 vtop
->r
= (vtop
->r
& ~(VT_VALMASK
| VT_LVAL_TYPE
)) | VT_LOCAL
| VT_LVAL
;
4793 #ifdef CONFIG_TCC_BCHECK
4794 /* generate lvalue bound code */
4800 vtop
->r
&= ~VT_MUSTBOUND
;
4801 /* if lvalue, then use checking code before dereferencing */
4802 if (vtop
->r
& VT_LVAL
) {
4803 /* if not VT_BOUNDED value, then make one */
4804 if (!(vtop
->r
& VT_BOUNDED
)) {
4805 lval_type
= vtop
->r
& (VT_LVAL_TYPE
| VT_LVAL
);
4806 /* must save type because we must set it to int to get pointer */
4808 vtop
->type
.t
= VT_INT
;
4811 gen_bounded_ptr_add();
4812 vtop
->r
|= lval_type
;
4815 /* then check for dereferencing */
4816 gen_bounded_ptr_deref();
4821 /* store vtop a register belonging to class 'rc'. lvalues are
4822 converted to values. Cannot be used if cannot be converted to
4823 register value (such as structures). */
4826 int r
, r2
, rc2
, bit_pos
, bit_size
, size
, align
, i
;
4827 unsigned long long ll
;
4829 /* NOTE: get_reg can modify vstack[] */
4830 if (vtop
->type
.t
& VT_BITFIELD
) {
4831 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4832 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
4833 /* remove bit field info to avoid loops */
4834 vtop
->type
.t
&= ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
4835 /* generate shifts */
4836 vpushi(32 - (bit_pos
+ bit_size
));
4838 vpushi(32 - bit_size
);
4839 /* NOTE: transformed to SHR if unsigned */
4843 if (is_float(vtop
->type
.t
) &&
4844 (vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
4847 unsigned long offset
;
4848 #if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
4852 /* XXX: unify with initializers handling ? */
4853 /* CPUs usually cannot use float constants, so we store them
4854 generically in data segment */
4855 size
= type_size(&vtop
->type
, &align
);
4856 offset
= (data_section
->data_offset
+ align
- 1) & -align
;
4857 data_section
->data_offset
= offset
;
4858 /* XXX: not portable yet */
4860 /* Zero pad x87 tenbyte long doubles */
4862 vtop
->c
.tab
[2] &= 0xffff;
4864 ptr
= section_ptr_add(data_section
, size
);
4866 #if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
4870 ptr
[i
] = vtop
->c
.tab
[size
-1-i
];
4874 ptr
[i
] = vtop
->c
.tab
[i
];
4875 sym
= get_sym_ref(&vtop
->type
, data_section
, offset
, size
<< 2);
4876 vtop
->r
|= VT_LVAL
| VT_SYM
;
4880 #ifdef CONFIG_TCC_BCHECK
4881 if (vtop
->r
& VT_MUSTBOUND
)
4885 r
= vtop
->r
& VT_VALMASK
;
4886 /* need to reload if:
4888 - lvalue (need to dereference pointer)
4889 - already a register, but not in the right class */
4890 if (r
>= VT_CONST
||
4891 (vtop
->r
& VT_LVAL
) ||
4892 !(reg_classes
[r
] & rc
) ||
4893 ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
&&
4894 !(reg_classes
[vtop
->r2
] & rc
))) {
4896 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
4897 /* two register type load : expand to two words
4899 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
4902 vtop
->c
.ui
= ll
; /* first word */
4904 vtop
->r
= r
; /* save register value */
4905 vpushi(ll
>> 32); /* second word */
4906 } else if (r
>= VT_CONST
|| /* XXX: test to VT_CONST incorrect ? */
4907 (vtop
->r
& VT_LVAL
)) {
4908 /* We do not want to modifier the long long
4909 pointer here, so the safest (and less
4910 efficient) is to save all the other registers
4911 in the stack. XXX: totally inefficient. */
4913 /* load from memory */
4916 vtop
[-1].r
= r
; /* save register value */
4917 /* increment pointer to get second word */
4918 vtop
->type
.t
= VT_INT
;
4924 /* move registers */
4927 vtop
[-1].r
= r
; /* save register value */
4928 vtop
->r
= vtop
[-1].r2
;
4930 /* allocate second register */
4937 /* write second register */
4939 } else if ((vtop
->r
& VT_LVAL
) && !is_float(vtop
->type
.t
)) {
4941 /* lvalue of scalar type : need to use lvalue type
4942 because of possible cast */
4945 /* compute memory access type */
4946 if (vtop
->r
& VT_LVAL_BYTE
)
4948 else if (vtop
->r
& VT_LVAL_SHORT
)
4950 if (vtop
->r
& VT_LVAL_UNSIGNED
)
4954 /* restore wanted type */
4957 /* one register type load */
4962 #ifdef TCC_TARGET_C67
4963 /* uses register pairs for doubles */
4964 if ((vtop
->type
.t
& VT_BTYPE
) == VT_DOUBLE
)
4971 /* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
4972 void gv2(int rc1
, int rc2
)
4976 /* generate more generic register first. But VT_JMP or VT_CMP
4977 values must be generated first in all cases to avoid possible
4979 v
= vtop
[0].r
& VT_VALMASK
;
4980 if (v
!= VT_CMP
&& (v
& ~1) != VT_JMP
&& rc1
<= rc2
) {
4985 /* test if reload is needed for first register */
4986 if ((vtop
[-1].r
& VT_VALMASK
) >= VT_CONST
) {
4996 /* test if reload is needed for first register */
4997 if ((vtop
[0].r
& VT_VALMASK
) >= VT_CONST
) {
5003 /* expand long long on stack in two int registers */
5008 u
= vtop
->type
.t
& VT_UNSIGNED
;
5011 vtop
[0].r
= vtop
[-1].r2
;
5012 vtop
[0].r2
= VT_CONST
;
5013 vtop
[-1].r2
= VT_CONST
;
5014 vtop
[0].type
.t
= VT_INT
| u
;
5015 vtop
[-1].type
.t
= VT_INT
| u
;
5018 #ifdef TCC_TARGET_ARM
5019 /* expand long long on stack */
5020 void lexpand_nr(void)
5024 u
= vtop
->type
.t
& VT_UNSIGNED
;
5026 vtop
->r2
= VT_CONST
;
5027 vtop
->type
.t
= VT_INT
| u
;
5028 v
=vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
);
5029 if (v
== VT_CONST
) {
5030 vtop
[-1].c
.ui
= vtop
->c
.ull
;
5031 vtop
->c
.ui
= vtop
->c
.ull
>> 32;
5033 } else if (v
== (VT_LVAL
|VT_CONST
) || v
== (VT_LVAL
|VT_LOCAL
)) {
5035 vtop
->r
= vtop
[-1].r
;
5036 } else if (v
> VT_CONST
) {
5040 vtop
->r
= vtop
[-1].r2
;
5041 vtop
[-1].r2
= VT_CONST
;
5042 vtop
[-1].type
.t
= VT_INT
| u
;
5046 /* build a long long from two ints */
5049 gv2(RC_INT
, RC_INT
);
5050 vtop
[-1].r2
= vtop
[0].r
;
5051 vtop
[-1].type
.t
= t
;
5055 /* rotate n first stack elements to the bottom
5056 I1 ... In -> I2 ... In I1 [top is right]
5064 for(i
=-n
+1;i
!=0;i
++)
5065 vtop
[i
] = vtop
[i
+1];
5069 /* rotate n first stack elements to the top
5070 I1 ... In -> In I1 ... I(n-1) [top is right]
5078 for(i
= 0;i
< n
- 1; i
++)
5079 vtop
[-i
] = vtop
[-i
- 1];
5083 #ifdef TCC_TARGET_ARM
5084 /* like vrott but in other direction
5085 In ... I1 -> I(n-1) ... I1 In [top is right]
5093 for(i
= n
- 1; i
> 0; i
--)
5094 vtop
[-i
] = vtop
[-i
+ 1];
5099 /* pop stack value */
5103 v
= vtop
->r
& VT_VALMASK
;
5104 #ifdef TCC_TARGET_I386
5105 /* for x86, we need to pop the FP stack */
5106 if (v
== TREG_ST0
&& !nocode_wanted
) {
5107 o(0xd9dd); /* fstp %st(1) */
5110 if (v
== VT_JMP
|| v
== VT_JMPI
) {
5111 /* need to put correct jump if && or || without test */
5117 /* convert stack entry to register and duplicate its value in another
5125 if ((t
& VT_BTYPE
) == VT_LLONG
) {
5132 /* stack: H L L1 H1 */
5140 /* duplicate value */
5151 load(r1
, &sv
); /* move r to r1 */
5153 /* duplicates value */
5158 /* generate CPU independent (unsigned) long long operations */
5159 void gen_opl(int op
)
5161 int t
, a
, b
, op1
, c
, i
;
5168 func
= TOK___divdi3
;
5171 func
= TOK___udivdi3
;
5174 func
= TOK___moddi3
;
5177 func
= TOK___umoddi3
;
5179 /* call generic long long function */
5180 vpush_global_sym(&func_old_type
, func
);
5185 vtop
->r2
= REG_LRET
;
5198 /* stack: L1 H1 L2 H2 */
5203 vtop
[-2] = vtop
[-3];
5206 /* stack: H1 H2 L1 L2 */
5212 /* stack: H1 H2 L1 L2 ML MH */
5215 /* stack: ML MH H1 H2 L1 L2 */
5219 /* stack: ML MH H1 L2 H2 L1 */
5224 /* stack: ML MH M1 M2 */
5227 } else if (op
== '+' || op
== '-') {
5228 /* XXX: add non carry method too (for MIPS or alpha) */
5234 /* stack: H1 H2 (L1 op L2) */
5237 gen_op(op1
+ 1); /* TOK_xxxC2 */
5240 /* stack: H1 H2 (L1 op L2) */
5243 /* stack: (L1 op L2) H1 H2 */
5245 /* stack: (L1 op L2) (H1 op H2) */
5253 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
5254 t
= vtop
[-1].type
.t
;
5258 /* stack: L H shift */
5260 /* constant: simpler */
5261 /* NOTE: all comments are for SHL. the other cases are
5262 done by swaping words */
5273 if (op
!= TOK_SAR
) {
5306 /* XXX: should provide a faster fallback on x86 ? */
5309 func
= TOK___sardi3
;
5312 func
= TOK___shrdi3
;
5315 func
= TOK___shldi3
;
5321 /* compare operations */
5327 /* stack: L1 H1 L2 H2 */
5329 vtop
[-1] = vtop
[-2];
5331 /* stack: L1 L2 H1 H2 */
5334 /* when values are equal, we need to compare low words. since
5335 the jump is inverted, we invert the test too. */
5338 else if (op1
== TOK_GT
)
5340 else if (op1
== TOK_ULT
)
5342 else if (op1
== TOK_UGT
)
5347 if (op1
!= TOK_NE
) {
5351 /* generate non equal test */
5352 /* XXX: NOT PORTABLE yet */
5356 #if defined(TCC_TARGET_I386)
5357 b
= psym(0x850f, 0);
5358 #elif defined(TCC_TARGET_ARM)
5360 o(0x1A000000 | encbranch(ind
, 0, 1));
5361 #elif defined(TCC_TARGET_C67)
5362 error("not implemented");
5364 #error not supported
5368 /* compare low. Always unsigned */
5372 else if (op1
== TOK_LE
)
5374 else if (op1
== TOK_GT
)
5376 else if (op1
== TOK_GE
)
5386 /* handle integer constant optimizations and various machine
5388 void gen_opic(int op
)
5390 int c1
, c2
, t1
, t2
, n
, c
;
5392 long long l1
, l2
, l
;
5393 typedef unsigned long long U
;
5397 t1
= v1
->type
.t
& VT_BTYPE
;
5398 t2
= v2
->type
.t
& VT_BTYPE
;
5399 l1
= (t1
== VT_LLONG
) ? v1
->c
.ll
: v1
->c
.i
;
5400 l2
= (t2
== VT_LLONG
) ? v2
->c
.ll
: v2
->c
.i
;
5402 /* currently, we cannot do computations with forward symbols */
5403 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5404 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5407 case '+': l1
+= l2
; break;
5408 case '-': l1
-= l2
; break;
5409 case '&': l1
&= l2
; break;
5410 case '^': l1
^= l2
; break;
5411 case '|': l1
|= l2
; break;
5412 case '*': l1
*= l2
; break;
5419 /* if division by zero, generate explicit division */
5422 error("division by zero in constant");
5426 default: l1
/= l2
; break;
5427 case '%': l1
%= l2
; break;
5428 case TOK_UDIV
: l1
= (U
)l1
/ l2
; break;
5429 case TOK_UMOD
: l1
= (U
)l1
% l2
; break;
5432 case TOK_SHL
: l1
<<= l2
; break;
5433 case TOK_SHR
: l1
= (U
)l1
>> l2
; break;
5434 case TOK_SAR
: l1
>>= l2
; break;
5436 case TOK_ULT
: l1
= (U
)l1
< (U
)l2
; break;
5437 case TOK_UGE
: l1
= (U
)l1
>= (U
)l2
; break;
5438 case TOK_EQ
: l1
= l1
== l2
; break;
5439 case TOK_NE
: l1
= l1
!= l2
; break;
5440 case TOK_ULE
: l1
= (U
)l1
<= (U
)l2
; break;
5441 case TOK_UGT
: l1
= (U
)l1
> (U
)l2
; break;
5442 case TOK_LT
: l1
= l1
< l2
; break;
5443 case TOK_GE
: l1
= l1
>= l2
; break;
5444 case TOK_LE
: l1
= l1
<= l2
; break;
5445 case TOK_GT
: l1
= l1
> l2
; break;
5447 case TOK_LAND
: l1
= l1
&& l2
; break;
5448 case TOK_LOR
: l1
= l1
|| l2
; break;
5455 /* if commutative ops, put c2 as constant */
5456 if (c1
&& (op
== '+' || op
== '&' || op
== '^' ||
5457 op
== '|' || op
== '*')) {
5459 c
= c1
, c1
= c2
, c2
= c
;
5460 l
= l1
, l1
= l2
, l2
= l
;
5462 /* Filter out NOP operations like x*1, x-0, x&-1... */
5463 if (c2
&& (((op
== '*' || op
== '/' || op
== TOK_UDIV
||
5466 ((op
== '+' || op
== '-' || op
== '|' || op
== '^' ||
5467 op
== TOK_SHL
|| op
== TOK_SHR
|| op
== TOK_SAR
) &&
5473 } else if (c2
&& (op
== '*' || op
== TOK_PDIV
|| op
== TOK_UDIV
)) {
5474 /* try to use shifts instead of muls or divs */
5475 if (l2
> 0 && (l2
& (l2
- 1)) == 0) {
5484 else if (op
== TOK_PDIV
)
5490 } else if (c2
&& (op
== '+' || op
== '-') &&
5491 (vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) ==
5492 (VT_CONST
| VT_SYM
)) {
5493 /* symbol + constant case */
5500 if (!nocode_wanted
) {
5501 /* call low level op generator */
5502 if (t1
== VT_LLONG
|| t2
== VT_LLONG
)
5513 /* generate a floating point operation with constant propagation */
5514 void gen_opif(int op
)
5522 /* currently, we cannot do computations with forward symbols */
5523 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5524 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5526 if (v1
->type
.t
== VT_FLOAT
) {
5529 } else if (v1
->type
.t
== VT_DOUBLE
) {
5537 /* NOTE: we only do constant propagation if finite number (not
5538 NaN or infinity) (ANSI spec) */
5539 if (!ieee_finite(f1
) || !ieee_finite(f2
))
5543 case '+': f1
+= f2
; break;
5544 case '-': f1
-= f2
; break;
5545 case '*': f1
*= f2
; break;
5549 error("division by zero in constant");
5554 /* XXX: also handles tests ? */
5558 /* XXX: overflow test ? */
5559 if (v1
->type
.t
== VT_FLOAT
) {
5561 } else if (v1
->type
.t
== VT_DOUBLE
) {
5569 if (!nocode_wanted
) {
5577 static int pointed_size(CType
*type
)
5580 return type_size(pointed_type(type
), &align
);
5583 static inline int is_null_pointer(SValue
*p
)
5585 if ((p
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
5587 return ((p
->type
.t
& VT_BTYPE
) == VT_INT
&& p
->c
.i
== 0) ||
5588 ((p
->type
.t
& VT_BTYPE
) == VT_LLONG
&& p
->c
.ll
== 0);
5591 static inline int is_integer_btype(int bt
)
5593 return (bt
== VT_BYTE
|| bt
== VT_SHORT
||
5594 bt
== VT_INT
|| bt
== VT_LLONG
);
5597 /* check types for comparison or substraction of pointers */
5598 static void check_comparison_pointer_types(SValue
*p1
, SValue
*p2
, int op
)
5600 CType
*type1
, *type2
, tmp_type1
, tmp_type2
;
5603 /* null pointers are accepted for all comparisons as gcc */
5604 if (is_null_pointer(p1
) || is_null_pointer(p2
))
5608 bt1
= type1
->t
& VT_BTYPE
;
5609 bt2
= type2
->t
& VT_BTYPE
;
5610 /* accept comparison between pointer and integer with a warning */
5611 if ((is_integer_btype(bt1
) || is_integer_btype(bt2
)) && op
!= '-') {
5612 if (op
!= TOK_LOR
&& op
!= TOK_LAND
)
5613 warning("comparison between pointer and integer");
5617 /* both must be pointers or implicit function pointers */
5618 if (bt1
== VT_PTR
) {
5619 type1
= pointed_type(type1
);
5620 } else if (bt1
!= VT_FUNC
)
5621 goto invalid_operands
;
5623 if (bt2
== VT_PTR
) {
5624 type2
= pointed_type(type2
);
5625 } else if (bt2
!= VT_FUNC
) {
5627 error("invalid operands to binary %s", get_tok_str(op
, NULL
));
5629 if ((type1
->t
& VT_BTYPE
) == VT_VOID
||
5630 (type2
->t
& VT_BTYPE
) == VT_VOID
)
5634 tmp_type1
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
5635 tmp_type2
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
5636 if (!is_compatible_types(&tmp_type1
, &tmp_type2
)) {
5637 /* gcc-like error if '-' is used */
5639 goto invalid_operands
;
5641 warning("comparison of distinct pointer types lacks a cast");
5645 /* generic gen_op: handles types problems */
5648 int u
, t1
, t2
, bt1
, bt2
, t
;
5651 t1
= vtop
[-1].type
.t
;
5652 t2
= vtop
[0].type
.t
;
5653 bt1
= t1
& VT_BTYPE
;
5654 bt2
= t2
& VT_BTYPE
;
5656 if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
5657 /* at least one operand is a pointer */
5658 /* relationnal op: must be both pointers */
5659 if (op
>= TOK_ULT
&& op
<= TOK_LOR
) {
5660 check_comparison_pointer_types(vtop
- 1, vtop
, op
);
5661 /* pointers are handled are unsigned */
5662 t
= VT_INT
| VT_UNSIGNED
;
5665 /* if both pointers, then it must be the '-' op */
5666 if (bt1
== VT_PTR
&& bt2
== VT_PTR
) {
5668 error("cannot use pointers here");
5669 check_comparison_pointer_types(vtop
- 1, vtop
, op
);
5670 /* XXX: check that types are compatible */
5671 u
= pointed_size(&vtop
[-1].type
);
5673 /* set to integer type */
5674 vtop
->type
.t
= VT_INT
;
5678 /* exactly one pointer : must be '+' or '-'. */
5679 if (op
!= '-' && op
!= '+')
5680 error("cannot use pointers here");
5681 /* Put pointer as first operand */
5682 if (bt2
== VT_PTR
) {
5686 type1
= vtop
[-1].type
;
5687 /* XXX: cast to int ? (long long case) */
5688 vpushi(pointed_size(&vtop
[-1].type
));
5690 #ifdef CONFIG_TCC_BCHECK
5691 /* if evaluating constant expression, no code should be
5692 generated, so no bound check */
5693 if (do_bounds_check
&& !const_wanted
) {
5694 /* if bounded pointers, we generate a special code to
5701 gen_bounded_ptr_add();
5707 /* put again type if gen_opic() swaped operands */
5710 } else if (is_float(bt1
) || is_float(bt2
)) {
5711 /* compute bigger type and do implicit casts */
5712 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
5714 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
5719 /* floats can only be used for a few operations */
5720 if (op
!= '+' && op
!= '-' && op
!= '*' && op
!= '/' &&
5721 (op
< TOK_ULT
|| op
> TOK_GT
))
5722 error("invalid operands for binary operation");
5724 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
5725 /* cast to biggest op */
5727 /* convert to unsigned if it does not fit in a long long */
5728 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
5729 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
5733 /* integer operations */
5735 /* convert to unsigned if it does not fit in an integer */
5736 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
5737 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
5740 /* XXX: currently, some unsigned operations are explicit, so
5741 we modify them here */
5742 if (t
& VT_UNSIGNED
) {
5749 else if (op
== TOK_LT
)
5751 else if (op
== TOK_GT
)
5753 else if (op
== TOK_LE
)
5755 else if (op
== TOK_GE
)
5762 /* special case for shifts and long long: we keep the shift as
5764 if (op
== TOK_SHR
|| op
== TOK_SAR
|| op
== TOK_SHL
)
5771 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
5772 /* relationnal op: the result is an int */
5773 vtop
->type
.t
= VT_INT
;
5780 /* generic itof for unsigned long long case */
5781 void gen_cvt_itof1(int t
)
5783 if ((vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
)) ==
5784 (VT_LLONG
| VT_UNSIGNED
)) {
5787 vpush_global_sym(&func_old_type
, TOK___ulltof
);
5788 else if (t
== VT_DOUBLE
)
5789 vpush_global_sym(&func_old_type
, TOK___ulltod
);
5791 vpush_global_sym(&func_old_type
, TOK___ulltold
);
5801 /* generic ftoi for unsigned long long case */
5802 void gen_cvt_ftoi1(int t
)
5806 if (t
== (VT_LLONG
| VT_UNSIGNED
)) {
5807 /* not handled natively */
5808 st
= vtop
->type
.t
& VT_BTYPE
;
5810 vpush_global_sym(&func_old_type
, TOK___fixunssfdi
);
5811 else if (st
== VT_DOUBLE
)
5812 vpush_global_sym(&func_old_type
, TOK___fixunsdfdi
);
5814 vpush_global_sym(&func_old_type
, TOK___fixunsxfdi
);
5819 vtop
->r2
= REG_LRET
;
5825 /* force char or short cast */
5826 void force_charshort_cast(int t
)
5830 /* XXX: add optimization if lvalue : just change type and offset */
5835 if (t
& VT_UNSIGNED
) {
5836 vpushi((1 << bits
) - 1);
5842 /* result must be signed or the SAR is converted to an SHL
5843 This was not the case when "t" was a signed short
5844 and the last value on the stack was an unsigned int */
5845 vtop
->type
.t
&= ~VT_UNSIGNED
;
5851 /* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
5852 static void gen_cast(CType
*type
)
5854 int sbt
, dbt
, sf
, df
, c
;
5856 /* special delayed cast for char/short */
5857 /* XXX: in some cases (multiple cascaded casts), it may still
5859 if (vtop
->r
& VT_MUSTCAST
) {
5860 vtop
->r
&= ~VT_MUSTCAST
;
5861 force_charshort_cast(vtop
->type
.t
);
5864 /* bitfields first get cast to ints */
5865 if (vtop
->type
.t
& VT_BITFIELD
) {
5869 dbt
= type
->t
& (VT_BTYPE
| VT_UNSIGNED
);
5870 sbt
= vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
);
5872 if (sbt
!= dbt
&& !nocode_wanted
) {
5875 c
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5877 /* convert from fp to fp */
5879 /* constant case: we can do it now */
5880 /* XXX: in ISOC, cannot do it if error in convert */
5881 if (dbt
== VT_FLOAT
&& sbt
== VT_DOUBLE
)
5882 vtop
->c
.f
= (float)vtop
->c
.d
;
5883 else if (dbt
== VT_FLOAT
&& sbt
== VT_LDOUBLE
)
5884 vtop
->c
.f
= (float)vtop
->c
.ld
;
5885 else if (dbt
== VT_DOUBLE
&& sbt
== VT_FLOAT
)
5886 vtop
->c
.d
= (double)vtop
->c
.f
;
5887 else if (dbt
== VT_DOUBLE
&& sbt
== VT_LDOUBLE
)
5888 vtop
->c
.d
= (double)vtop
->c
.ld
;
5889 else if (dbt
== VT_LDOUBLE
&& sbt
== VT_FLOAT
)
5890 vtop
->c
.ld
= (long double)vtop
->c
.f
;
5891 else if (dbt
== VT_LDOUBLE
&& sbt
== VT_DOUBLE
)
5892 vtop
->c
.ld
= (long double)vtop
->c
.d
;
5894 /* non constant case: generate code */
5898 /* convert int to fp */
5901 case VT_LLONG
| VT_UNSIGNED
:
5903 /* XXX: add const cases for long long */
5905 case VT_INT
| VT_UNSIGNED
:
5907 case VT_FLOAT
: vtop
->c
.f
= (float)vtop
->c
.ui
; break;
5908 case VT_DOUBLE
: vtop
->c
.d
= (double)vtop
->c
.ui
; break;
5909 case VT_LDOUBLE
: vtop
->c
.ld
= (long double)vtop
->c
.ui
; break;
5914 case VT_FLOAT
: vtop
->c
.f
= (float)vtop
->c
.i
; break;
5915 case VT_DOUBLE
: vtop
->c
.d
= (double)vtop
->c
.i
; break;
5916 case VT_LDOUBLE
: vtop
->c
.ld
= (long double)vtop
->c
.i
; break;
5922 #if !defined(TCC_TARGET_ARM)
5929 /* convert fp to int */
5930 if (dbt
== VT_BOOL
) {
5934 /* we handle char/short/etc... with generic code */
5935 if (dbt
!= (VT_INT
| VT_UNSIGNED
) &&
5936 dbt
!= (VT_LLONG
| VT_UNSIGNED
) &&
5941 case VT_LLONG
| VT_UNSIGNED
:
5943 /* XXX: add const cases for long long */
5945 case VT_INT
| VT_UNSIGNED
:
5947 case VT_FLOAT
: vtop
->c
.ui
= (unsigned int)vtop
->c
.d
; break;
5948 case VT_DOUBLE
: vtop
->c
.ui
= (unsigned int)vtop
->c
.d
; break;
5949 case VT_LDOUBLE
: vtop
->c
.ui
= (unsigned int)vtop
->c
.d
; break;
5955 case VT_FLOAT
: vtop
->c
.i
= (int)vtop
->c
.d
; break;
5956 case VT_DOUBLE
: vtop
->c
.i
= (int)vtop
->c
.d
; break;
5957 case VT_LDOUBLE
: vtop
->c
.i
= (int)vtop
->c
.d
; break;
5965 if (dbt
== VT_INT
&& (type
->t
& (VT_BTYPE
| VT_UNSIGNED
)) != dbt
) {
5966 /* additional cast for char/short... */
5971 } else if ((dbt
& VT_BTYPE
) == VT_LLONG
) {
5972 if ((sbt
& VT_BTYPE
) != VT_LLONG
) {
5973 /* scalar to long long */
5975 if (sbt
== (VT_INT
| VT_UNSIGNED
))
5976 vtop
->c
.ll
= vtop
->c
.ui
;
5978 vtop
->c
.ll
= vtop
->c
.i
;
5980 /* machine independent conversion */
5982 /* generate high word */
5983 if (sbt
== (VT_INT
| VT_UNSIGNED
)) {
5991 /* patch second register */
5992 vtop
[-1].r2
= vtop
->r
;
5996 } else if (dbt
== VT_BOOL
) {
5997 /* scalar to bool */
6000 } else if ((dbt
& VT_BTYPE
) == VT_BYTE
||
6001 (dbt
& VT_BTYPE
) == VT_SHORT
) {
6002 if (sbt
== VT_PTR
) {
6003 vtop
->type
.t
= VT_INT
;
6004 warning("nonportable conversion from pointer to char/short");
6006 force_charshort_cast(dbt
);
6007 } else if ((dbt
& VT_BTYPE
) == VT_INT
) {
6009 if (sbt
== VT_LLONG
) {
6010 /* from long long: just take low order word */
6014 /* if lvalue and single word type, nothing to do because
6015 the lvalue already contains the real type size (see
6016 VT_LVAL_xxx constants) */
6018 } else if ((dbt
& VT_BTYPE
) == VT_PTR
&& !(vtop
->r
& VT_LVAL
)) {
6019 /* if we are casting between pointer types,
6020 we must update the VT_LVAL_xxx size */
6021 vtop
->r
= (vtop
->r
& ~VT_LVAL_TYPE
)
6022 | (lvalue_type(type
->ref
->type
.t
) & VT_LVAL_TYPE
);
6027 /* return type size. Put alignment at 'a' */
6028 static int type_size(CType
*type
, int *a
)
6033 bt
= type
->t
& VT_BTYPE
;
6034 if (bt
== VT_STRUCT
) {
6039 } else if (bt
== VT_PTR
) {
6040 if (type
->t
& VT_ARRAY
) {
6042 return type_size(&s
->type
, a
) * s
->c
;
6047 } else if (bt
== VT_LDOUBLE
) {
6049 return LDOUBLE_SIZE
;
6050 } else if (bt
== VT_DOUBLE
|| bt
== VT_LLONG
) {
6051 #ifdef TCC_TARGET_I386
6053 #elif defined(TCC_TARGET_ARM)
6063 } else if (bt
== VT_INT
|| bt
== VT_ENUM
|| bt
== VT_FLOAT
) {
6066 } else if (bt
== VT_SHORT
) {
6070 /* char, void, function, _Bool */
6076 /* return the pointed type of t */
6077 static inline CType
*pointed_type(CType
*type
)
6079 return &type
->ref
->type
;
6082 /* modify type so that its it is a pointer to type. */
6083 static void mk_pointer(CType
*type
)
6086 s
= sym_push(SYM_FIELD
, type
, 0, -1);
6087 type
->t
= VT_PTR
| (type
->t
& ~VT_TYPE
);
6091 /* compare function types. OLD functions match any new functions */
6092 static int is_compatible_func(CType
*type1
, CType
*type2
)
6098 if (!is_compatible_types(&s1
->type
, &s2
->type
))
6100 /* check func_call */
6103 /* XXX: not complete */
6104 if (s1
->c
== FUNC_OLD
|| s2
->c
== FUNC_OLD
)
6108 while (s1
!= NULL
) {
6111 if (!is_compatible_parameter_types(&s1
->type
, &s2
->type
))
6121 /* return true if type1 and type2 are the same. If unqualified is
6122 true, qualifiers on the types are ignored.
6124 - enums are not checked as gcc __builtin_types_compatible_p ()
6126 static int compare_types(CType
*type1
, CType
*type2
, int unqualified
)
6130 t1
= type1
->t
& VT_TYPE
;
6131 t2
= type2
->t
& VT_TYPE
;
6133 /* strip qualifiers before comparing */
6134 t1
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6135 t2
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6137 /* XXX: bitfields ? */
6140 /* test more complicated cases */
6141 bt1
= t1
& VT_BTYPE
;
6142 if (bt1
== VT_PTR
) {
6143 type1
= pointed_type(type1
);
6144 type2
= pointed_type(type2
);
6145 return is_compatible_types(type1
, type2
);
6146 } else if (bt1
== VT_STRUCT
) {
6147 return (type1
->ref
== type2
->ref
);
6148 } else if (bt1
== VT_FUNC
) {
6149 return is_compatible_func(type1
, type2
);
6155 /* return true if type1 and type2 are exactly the same (including
6158 static int is_compatible_types(CType
*type1
, CType
*type2
)
6160 return compare_types(type1
,type2
,0);
6163 /* return true if type1 and type2 are the same (ignoring qualifiers).
6165 static int is_compatible_parameter_types(CType
*type1
, CType
*type2
)
6167 return compare_types(type1
,type2
,1);
6170 /* print a type. If 'varstr' is not NULL, then the variable is also
6171 printed in the type */
6173 /* XXX: add array and function pointers */
6174 void type_to_str(char *buf
, int buf_size
,
6175 CType
*type
, const char *varstr
)
6182 t
= type
->t
& VT_TYPE
;
6185 if (t
& VT_CONSTANT
)
6186 pstrcat(buf
, buf_size
, "const ");
6187 if (t
& VT_VOLATILE
)
6188 pstrcat(buf
, buf_size
, "volatile ");
6189 if (t
& VT_UNSIGNED
)
6190 pstrcat(buf
, buf_size
, "unsigned ");
6220 tstr
= "long double";
6222 pstrcat(buf
, buf_size
, tstr
);
6226 if (bt
== VT_STRUCT
)
6230 pstrcat(buf
, buf_size
, tstr
);
6231 v
= type
->ref
->v
& ~SYM_STRUCT
;
6232 if (v
>= SYM_FIRST_ANOM
)
6233 pstrcat(buf
, buf_size
, "<anonymous>");
6235 pstrcat(buf
, buf_size
, get_tok_str(v
, NULL
));
6239 type_to_str(buf
, buf_size
, &s
->type
, varstr
);
6240 pstrcat(buf
, buf_size
, "(");
6242 while (sa
!= NULL
) {
6243 type_to_str(buf1
, sizeof(buf1
), &sa
->type
, NULL
);
6244 pstrcat(buf
, buf_size
, buf1
);
6247 pstrcat(buf
, buf_size
, ", ");
6249 pstrcat(buf
, buf_size
, ")");
6253 pstrcpy(buf1
, sizeof(buf1
), "*");
6255 pstrcat(buf1
, sizeof(buf1
), varstr
);
6256 type_to_str(buf
, buf_size
, &s
->type
, buf1
);
6260 pstrcat(buf
, buf_size
, " ");
6261 pstrcat(buf
, buf_size
, varstr
);
6266 /* verify type compatibility to store vtop in 'dt' type, and generate
6268 static void gen_assign_cast(CType
*dt
)
6270 CType
*st
, *type1
, *type2
, tmp_type1
, tmp_type2
;
6271 char buf1
[256], buf2
[256];
6274 st
= &vtop
->type
; /* source type */
6275 dbt
= dt
->t
& VT_BTYPE
;
6276 sbt
= st
->t
& VT_BTYPE
;
6277 if (dt
->t
& VT_CONSTANT
)
6278 warning("assignment of read-only location");
6281 /* special cases for pointers */
6282 /* '0' can also be a pointer */
6283 if (is_null_pointer(vtop
))
6285 /* accept implicit pointer to integer cast with warning */
6286 if (is_integer_btype(sbt
)) {
6287 warning("assignment makes pointer from integer without a cast");
6290 type1
= pointed_type(dt
);
6291 /* a function is implicitely a function pointer */
6292 if (sbt
== VT_FUNC
) {
6293 if ((type1
->t
& VT_BTYPE
) != VT_VOID
&&
6294 !is_compatible_types(pointed_type(dt
), st
))
6301 type2
= pointed_type(st
);
6302 if ((type1
->t
& VT_BTYPE
) == VT_VOID
||
6303 (type2
->t
& VT_BTYPE
) == VT_VOID
) {
6304 /* void * can match anything */
6306 /* exact type match, except for unsigned */
6309 tmp_type1
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
6310 tmp_type2
.t
&= ~(VT_UNSIGNED
| VT_CONSTANT
| VT_VOLATILE
);
6311 if (!is_compatible_types(&tmp_type1
, &tmp_type2
))
6312 warning("assignment from incompatible pointer type");
6314 /* check const and volatile */
6315 if ((!(type1
->t
& VT_CONSTANT
) && (type2
->t
& VT_CONSTANT
)) ||
6316 (!(type1
->t
& VT_VOLATILE
) && (type2
->t
& VT_VOLATILE
)))
6317 warning("assignment discards qualifiers from pointer target type");
6323 if (sbt
== VT_PTR
|| sbt
== VT_FUNC
) {
6324 warning("assignment makes integer from pointer without a cast");
6326 /* XXX: more tests */
6331 tmp_type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6332 tmp_type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6333 if (!is_compatible_types(&tmp_type1
, &tmp_type2
)) {
6335 type_to_str(buf1
, sizeof(buf1
), st
, NULL
);
6336 type_to_str(buf2
, sizeof(buf2
), dt
, NULL
);
6337 error("cannot cast '%s' to '%s'", buf1
, buf2
);
6345 /* store vtop in lvalue pushed on stack */
6348 int sbt
, dbt
, ft
, r
, t
, size
, align
, bit_size
, bit_pos
, rc
, delayed_cast
;
6350 ft
= vtop
[-1].type
.t
;
6351 sbt
= vtop
->type
.t
& VT_BTYPE
;
6352 dbt
= ft
& VT_BTYPE
;
6353 if (((sbt
== VT_INT
|| sbt
== VT_SHORT
) && dbt
== VT_BYTE
) ||
6354 (sbt
== VT_INT
&& dbt
== VT_SHORT
)) {
6355 /* optimize char/short casts */
6356 delayed_cast
= VT_MUSTCAST
;
6357 vtop
->type
.t
= ft
& VT_TYPE
;
6358 /* XXX: factorize */
6359 if (ft
& VT_CONSTANT
)
6360 warning("assignment of read-only location");
6363 if (!(ft
& VT_BITFIELD
))
6364 gen_assign_cast(&vtop
[-1].type
);
6367 if (sbt
== VT_STRUCT
) {
6368 /* if structure, only generate pointer */
6369 /* structure assignment : generate memcpy */
6370 /* XXX: optimize if small size */
6371 if (!nocode_wanted
) {
6372 size
= type_size(&vtop
->type
, &align
);
6376 vpush_global_sym(&func_old_type
, TOK_memcpy8
);
6377 else if(!(align
& 3))
6378 vpush_global_sym(&func_old_type
, TOK_memcpy4
);
6381 vpush_global_sym(&func_old_type
, TOK_memcpy
);
6385 vtop
->type
.t
= VT_INT
;
6389 vtop
->type
.t
= VT_INT
;
6401 /* leave source on stack */
6402 } else if (ft
& VT_BITFIELD
) {
6403 /* bitfield store handling */
6404 bit_pos
= (ft
>> VT_STRUCT_SHIFT
) & 0x3f;
6405 bit_size
= (ft
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
6406 /* remove bit field info to avoid loops */
6407 vtop
[-1].type
.t
= ft
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
6409 /* duplicate source into other register */
6414 /* duplicate destination */
6416 vtop
[-1] = vtop
[-2];
6418 /* mask and shift source */
6419 vpushi((1 << bit_size
) - 1);
6423 /* load destination, mask and or with source */
6425 vpushi(~(((1 << bit_size
) - 1) << bit_pos
));
6431 /* pop off shifted source from "duplicate source..." above */
6435 #ifdef CONFIG_TCC_BCHECK
6436 /* bound check case */
6437 if (vtop
[-1].r
& VT_MUSTBOUND
) {
6443 if (!nocode_wanted
) {
6447 r
= gv(rc
); /* generate value */
6448 /* if lvalue was saved on stack, must read it */
6449 if ((vtop
[-1].r
& VT_VALMASK
) == VT_LLOCAL
) {
6451 t
= get_reg(RC_INT
);
6453 sv
.r
= VT_LOCAL
| VT_LVAL
;
6454 sv
.c
.ul
= vtop
[-1].c
.ul
;
6456 vtop
[-1].r
= t
| VT_LVAL
;
6459 /* two word case handling : store second register at word + 4 */
6460 if ((ft
& VT_BTYPE
) == VT_LLONG
) {
6462 /* convert to int to increment easily */
6463 vtop
->type
.t
= VT_INT
;
6469 /* XXX: it works because r2 is spilled last ! */
6470 store(vtop
->r2
, vtop
- 1);
6474 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
6475 vtop
->r
|= delayed_cast
;
6479 /* post defines POST/PRE add. c is the token ++ or -- */
6480 void inc(int post
, int c
)
6483 vdup(); /* save lvalue */
6485 gv_dup(); /* duplicate value */
6490 vpushi(c
- TOK_MID
);
6492 vstore(); /* store value */
6494 vpop(); /* if post op, return saved value */
6497 /* Parse GNUC __attribute__ extension. Currently, the following
6498 extensions are recognized:
6499 - aligned(n) : set data/function alignment.
6500 - packed : force data alignment to 1
6501 - section(x) : generate data/code in this section.
6502 - unused : currently ignored, but may be used someday.
6503 - regparm(n) : pass function parameters in registers (i386 only)
6505 static void parse_attribute(AttributeDef
*ad
)
6509 while (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
) {
6513 while (tok
!= ')') {
6514 if (tok
< TOK_IDENT
)
6515 expect("attribute name");
6523 expect("section name");
6524 ad
->section
= find_section(tcc_state
, (char *)tokc
.cstr
->data
);
6533 if (n
<= 0 || (n
& (n
- 1)) != 0)
6534 error("alignment must be a positive power of two");
6547 /* currently, no need to handle it because tcc does not
6548 track unused objects */
6552 /* currently, no need to handle it because tcc does not
6553 track unused objects */
6558 ad
->func_call
= FUNC_CDECL
;
6563 ad
->func_call
= FUNC_STDCALL
;
6565 #ifdef TCC_TARGET_I386
6575 ad
->func_call
= FUNC_FASTCALL1
+ n
- 1;
6581 ad
->func_call
= FUNC_FASTCALLW
;
6588 if (tcc_state
->warn_unsupported
)
6589 warning("'%s' attribute ignored", get_tok_str(t
, NULL
));
6590 /* skip parameters */
6592 int parenthesis
= 0;
6596 else if (tok
== ')')
6599 } while (parenthesis
&& tok
!= -1);
6612 /* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
6613 static void struct_decl(CType
*type
, int u
)
6615 int a
, v
, size
, align
, maxalign
, c
, offset
;
6616 int bit_size
, bit_pos
, bsize
, bt
, lbit_pos
;
6617 Sym
*s
, *ss
, *ass
, **ps
;
6621 a
= tok
; /* save decl type */
6626 /* struct already defined ? return it */
6628 expect("struct/union/enum name");
6632 error("invalid type");
6639 /* we put an undefined size for struct/union */
6640 s
= sym_push(v
| SYM_STRUCT
, &type1
, 0, -1);
6641 s
->r
= 0; /* default alignment is zero as gcc */
6642 /* put struct/union/enum name in type */
6650 error("struct/union/enum already defined");
6651 /* cannot be empty */
6653 /* non empty enums are not allowed */
6654 if (a
== TOK_ENUM
) {
6658 expect("identifier");
6664 /* enum symbols have static storage */
6665 ss
= sym_push(v
, &int_type
, VT_CONST
, c
);
6666 ss
->type
.t
|= VT_STATIC
;
6671 /* NOTE: we accept a trailing comma */
6681 while (tok
!= '}') {
6682 parse_btype(&btype
, &ad
);
6688 type_decl(&type1
, &ad
, &v
, TYPE_DIRECT
| TYPE_ABSTRACT
);
6689 if (v
== 0 && (type1
.t
& VT_BTYPE
) != VT_STRUCT
)
6690 expect("identifier");
6691 if ((type1
.t
& VT_BTYPE
) == VT_FUNC
||
6692 (type1
.t
& (VT_TYPEDEF
| VT_STATIC
| VT_EXTERN
| VT_INLINE
)))
6693 error("invalid type for '%s'",
6694 get_tok_str(v
, NULL
));
6698 bit_size
= expr_const();
6699 /* XXX: handle v = 0 case for messages */
6701 error("negative width in bit-field '%s'",
6702 get_tok_str(v
, NULL
));
6703 if (v
&& bit_size
== 0)
6704 error("zero width for bit-field '%s'",
6705 get_tok_str(v
, NULL
));
6707 size
= type_size(&type1
, &align
);
6709 if (align
< ad
.aligned
)
6711 } else if (ad
.packed
) {
6713 } else if (*tcc_state
->pack_stack_ptr
) {
6714 if (align
> *tcc_state
->pack_stack_ptr
)
6715 align
= *tcc_state
->pack_stack_ptr
;
6718 if (bit_size
>= 0) {
6719 bt
= type1
.t
& VT_BTYPE
;
6725 error("bitfields must have scalar type");
6727 if (bit_size
> bsize
) {
6728 error("width of '%s' exceeds its type",
6729 get_tok_str(v
, NULL
));
6730 } else if (bit_size
== bsize
) {
6731 /* no need for bit fields */
6733 } else if (bit_size
== 0) {
6734 /* XXX: what to do if only padding in a
6736 /* zero size: means to pad */
6740 /* we do not have enough room ? */
6741 if ((bit_pos
+ bit_size
) > bsize
)
6744 /* XXX: handle LSB first */
6745 type1
.t
|= VT_BITFIELD
|
6746 (bit_pos
<< VT_STRUCT_SHIFT
) |
6747 (bit_size
<< (VT_STRUCT_SHIFT
+ 6));
6748 bit_pos
+= bit_size
;
6753 if (v
!= 0 || (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
6754 /* add new memory data only if starting
6756 if (lbit_pos
== 0) {
6757 if (a
== TOK_STRUCT
) {
6758 c
= (c
+ align
- 1) & -align
;
6767 if (align
> maxalign
)
6771 printf("add field %s offset=%d",
6772 get_tok_str(v
, NULL
), offset
);
6773 if (type1
.t
& VT_BITFIELD
) {
6774 printf(" pos=%d size=%d",
6775 (type1
.t
>> VT_STRUCT_SHIFT
) & 0x3f,
6776 (type1
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f);
6781 if (v
== 0 && (type1
.t
& VT_BTYPE
) == VT_STRUCT
) {
6783 while ((ass
= ass
->next
) != NULL
) {
6784 ss
= sym_push(ass
->v
, &ass
->type
, 0, offset
+ ass
->c
);
6789 ss
= sym_push(v
| SYM_FIELD
, &type1
, 0, offset
);
6793 if (tok
== ';' || tok
== TOK_EOF
)
6800 /* store size and alignment */
6801 s
->c
= (c
+ maxalign
- 1) & -maxalign
;
6807 /* return 0 if no type declaration. otherwise, return the basic type
6810 static int parse_btype(CType
*type
, AttributeDef
*ad
)
6812 int t
, u
, type_found
, typespec_found
, typedef_found
;
6816 memset(ad
, 0, sizeof(AttributeDef
));
6824 /* currently, we really ignore extension */
6834 if ((t
& VT_BTYPE
) != 0)
6835 error("too many basic types");
6851 if ((t
& VT_BTYPE
) == VT_DOUBLE
) {
6852 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
6853 } else if ((t
& VT_BTYPE
) == VT_LONG
) {
6854 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
6868 if ((t
& VT_BTYPE
) == VT_LONG
) {
6869 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
6876 struct_decl(&type1
, VT_ENUM
);
6879 type
->ref
= type1
.ref
;
6883 struct_decl(&type1
, VT_STRUCT
);
6886 /* type modifiers */
6939 /* GNUC attribute */
6940 case TOK_ATTRIBUTE1
:
6941 case TOK_ATTRIBUTE2
:
6942 parse_attribute(ad
);
6949 parse_expr_type(&type1
);
6952 if (typespec_found
|| typedef_found
)
6955 if (!s
|| !(s
->type
.t
& VT_TYPEDEF
))
6958 t
|= (s
->type
.t
& ~VT_TYPEDEF
);
6959 type
->ref
= s
->type
.ref
;
6967 if ((t
& (VT_SIGNED
|VT_UNSIGNED
)) == (VT_SIGNED
|VT_UNSIGNED
))
6968 error("signed and unsigned modifier");
6969 if (tcc_state
->char_is_unsigned
) {
6970 if ((t
& (VT_SIGNED
|VT_UNSIGNED
|VT_BTYPE
)) == VT_BYTE
)
6975 /* long is never used as type */
6976 if ((t
& VT_BTYPE
) == VT_LONG
)
6977 t
= (t
& ~VT_BTYPE
) | VT_INT
;
6982 /* convert a function parameter type (array to pointer and function to
6983 function pointer) */
6984 static inline void convert_parameter_type(CType
*pt
)
6986 /* remove const and volatile qualifiers (XXX: const could be used
6987 to indicate a const function parameter */
6988 pt
->t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
6989 /* array must be transformed to pointer according to ANSI C */
6991 if ((pt
->t
& VT_BTYPE
) == VT_FUNC
) {
6996 static void post_type(CType
*type
, AttributeDef
*ad
)
6999 Sym
**plast
, *s
, *first
;
7004 /* function declaration */
7011 /* read param name and compute offset */
7012 if (l
!= FUNC_OLD
) {
7013 if (!parse_btype(&pt
, &ad1
)) {
7015 error("invalid type");
7022 if ((pt
.t
& VT_BTYPE
) == VT_VOID
&& tok
== ')')
7024 type_decl(&pt
, &ad1
, &n
, TYPE_DIRECT
| TYPE_ABSTRACT
);
7025 if ((pt
.t
& VT_BTYPE
) == VT_VOID
)
7026 error("parameter declared as void");
7031 expect("identifier");
7035 convert_parameter_type(&pt
);
7036 s
= sym_push(n
| SYM_FIELD
, &pt
, 0, 0);
7042 if (l
== FUNC_NEW
&& tok
== TOK_DOTS
) {
7049 /* if no parameters, then old type prototype */
7053 t1
= type
->t
& VT_STORAGE
;
7054 /* NOTE: const is ignored in returned type as it has a special
7055 meaning in gcc / C++ */
7056 type
->t
&= ~(VT_STORAGE
| VT_CONSTANT
);
7057 post_type(type
, ad
);
7058 /* we push a anonymous symbol which will contain the function prototype */
7059 s
= sym_push(SYM_FIELD
, type
, ad
->func_call
, l
);
7061 type
->t
= t1
| VT_FUNC
;
7063 } else if (tok
== '[') {
7064 /* array definition */
7070 error("invalid array size");
7073 /* parse next post type */
7074 t1
= type
->t
& VT_STORAGE
;
7075 type
->t
&= ~VT_STORAGE
;
7076 post_type(type
, ad
);
7078 /* we push a anonymous symbol which will contain the array
7080 s
= sym_push(SYM_FIELD
, type
, 0, n
);
7081 type
->t
= t1
| VT_ARRAY
| VT_PTR
;
7086 /* Parse a type declaration (except basic type), and return the type
7087 in 'type'. 'td' is a bitmask indicating which kind of type decl is
7088 expected. 'type' should contain the basic type. 'ad' is the
7089 attribute definition of the basic type. It can be modified by
7092 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
)
7095 CType type1
, *type2
;
7098 while (tok
== '*') {
7106 qualifiers
|= VT_CONSTANT
;
7111 qualifiers
|= VT_VOLATILE
;
7119 type
->t
|= qualifiers
;
7122 /* XXX: clarify attribute handling */
7123 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
7124 parse_attribute(ad
);
7126 /* recursive type */
7127 /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
7128 type1
.t
= 0; /* XXX: same as int */
7131 /* XXX: this is not correct to modify 'ad' at this point, but
7132 the syntax is not clear */
7133 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
7134 parse_attribute(ad
);
7135 type_decl(&type1
, ad
, v
, td
);
7138 /* type identifier */
7139 if (tok
>= TOK_IDENT
&& (td
& TYPE_DIRECT
)) {
7143 if (!(td
& TYPE_ABSTRACT
))
7144 expect("identifier");
7148 post_type(type
, ad
);
7149 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
7150 parse_attribute(ad
);
7153 /* append type at the end of type1 */
7166 /* compute the lvalue VT_LVAL_xxx needed to match type t. */
7167 static int lvalue_type(int t
)
7172 if (bt
== VT_BYTE
|| bt
== VT_BOOL
)
7174 else if (bt
== VT_SHORT
)
7178 if (t
& VT_UNSIGNED
)
7179 r
|= VT_LVAL_UNSIGNED
;
7183 /* indirection with full error checking and bound check */
7184 static void indir(void)
7186 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
) {
7187 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FUNC
)
7191 if ((vtop
->r
& VT_LVAL
) && !nocode_wanted
)
7193 vtop
->type
= *pointed_type(&vtop
->type
);
7194 /* Arrays and functions are never lvalues */
7195 if (!(vtop
->type
.t
& VT_ARRAY
)
7196 && (vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
7197 vtop
->r
|= lvalue_type(vtop
->type
.t
);
7198 /* if bound checking, the referenced pointer must be checked */
7199 if (do_bounds_check
)
7200 vtop
->r
|= VT_MUSTBOUND
;
7204 /* pass a parameter to a function and do type checking and casting */
7205 static void gfunc_param_typed(Sym
*func
, Sym
*arg
)
7210 func_type
= func
->c
;
7211 if (func_type
== FUNC_OLD
||
7212 (func_type
== FUNC_ELLIPSIS
&& arg
== NULL
)) {
7213 /* default casting : only need to convert float to double */
7214 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
) {
7218 } else if (arg
== NULL
) {
7219 error("too many arguments to function");
7222 type
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
7223 gen_assign_cast(&type
);
7227 /* parse an expression of the form '(type)' or '(expr)' and return its
7229 static void parse_expr_type(CType
*type
)
7235 if (parse_btype(type
, &ad
)) {
7236 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
7243 static void parse_type(CType
*type
)
7248 if (!parse_btype(type
, &ad
)) {
7251 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
7254 static void vpush_tokc(int t
)
7258 vsetc(&type
, VT_CONST
, &tokc
);
7261 static void unary(void)
7263 int n
, t
, align
, size
, r
;
7268 /* XXX: GCC 2.95.3 does not generate a table although it should be
7282 vpush_tokc(VT_INT
| VT_UNSIGNED
);
7286 vpush_tokc(VT_LLONG
);
7290 vpush_tokc(VT_LLONG
| VT_UNSIGNED
);
7294 vpush_tokc(VT_FLOAT
);
7298 vpush_tokc(VT_DOUBLE
);
7302 vpush_tokc(VT_LDOUBLE
);
7305 case TOK___FUNCTION__
:
7307 goto tok_identifier
;
7313 /* special function name identifier */
7314 len
= strlen(funcname
) + 1;
7315 /* generate char[len] type */
7320 vpush_ref(&type
, data_section
, data_section
->data_offset
, len
);
7321 ptr
= section_ptr_add(data_section
, len
);
7322 memcpy(ptr
, funcname
, len
);
7327 #ifdef TCC_TARGET_PE
7328 t
= VT_SHORT
| VT_UNSIGNED
;
7334 /* string parsing */
7337 if (tcc_state
->warn_write_strings
)
7342 memset(&ad
, 0, sizeof(AttributeDef
));
7343 decl_initializer_alloc(&type
, &ad
, VT_CONST
, 2, 0, 0);
7348 if (parse_btype(&type
, &ad
)) {
7349 type_decl(&type
, &ad
, &n
, TYPE_ABSTRACT
);
7351 /* check ISOC99 compound literal */
7353 /* data is allocated locally by default */
7358 /* all except arrays are lvalues */
7359 if (!(type
.t
& VT_ARRAY
))
7360 r
|= lvalue_type(type
.t
);
7361 memset(&ad
, 0, sizeof(AttributeDef
));
7362 decl_initializer_alloc(&type
, &ad
, r
, 1, 0, 0);
7367 } else if (tok
== '{') {
7368 /* save all registers */
7370 /* statement expression : we do not accept break/continue
7371 inside as GCC does */
7372 block(NULL
, NULL
, NULL
, NULL
, 0, 1);
7387 /* functions names must be treated as function pointers,
7388 except for unary '&' and sizeof. Since we consider that
7389 functions are not lvalues, we only have to handle it
7390 there and in function calls. */
7391 /* arrays can also be used although they are not lvalues */
7392 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
&&
7393 !(vtop
->type
.t
& VT_ARRAY
) && !(vtop
->type
.t
& VT_LLOCAL
))
7395 mk_pointer(&vtop
->type
);
7401 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
)
7402 vtop
->c
.i
= !vtop
->c
.i
;
7403 else if ((vtop
->r
& VT_VALMASK
) == VT_CMP
)
7404 vtop
->c
.i
= vtop
->c
.i
^ 1;
7407 vseti(VT_JMP
, gtst(1, 0));
7418 /* in order to force cast, we add zero */
7420 if ((vtop
->type
.t
& VT_BTYPE
) == VT_PTR
)
7421 error("pointer not accepted for unary plus");
7431 parse_expr_type(&type
);
7435 size
= type_size(&type
, &align
);
7436 if (t
== TOK_SIZEOF
) {
7438 error("sizeof applied to an incomplete type");
7443 vtop
->type
.t
|= VT_UNSIGNED
;
7446 case TOK_builtin_types_compatible_p
:
7455 type1
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
7456 type2
.t
&= ~(VT_CONSTANT
| VT_VOLATILE
);
7457 vpushi(is_compatible_types(&type1
, &type2
));
7460 case TOK_builtin_constant_p
:
7462 int saved_nocode_wanted
, res
;
7465 saved_nocode_wanted
= nocode_wanted
;
7468 res
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
7470 nocode_wanted
= saved_nocode_wanted
;
7490 goto tok_identifier
;
7492 /* allow to take the address of a label */
7493 if (tok
< TOK_UIDENT
)
7494 expect("label identifier");
7495 s
= label_find(tok
);
7497 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
7499 if (s
->r
== LABEL_DECLARED
)
7500 s
->r
= LABEL_FORWARD
;
7503 s
->type
.t
= VT_VOID
;
7504 mk_pointer(&s
->type
);
7505 s
->type
.t
|= VT_STATIC
;
7507 vset(&s
->type
, VT_CONST
| VT_SYM
, 0);
7516 expect("identifier");
7520 error("'%s' undeclared", get_tok_str(t
, NULL
));
7521 /* for simple function calls, we tolerate undeclared
7522 external reference to int() function */
7523 if (tcc_state
->warn_implicit_function_declaration
)
7524 warning("implicit declaration of function '%s'",
7525 get_tok_str(t
, NULL
));
7526 s
= external_global_sym(t
, &func_old_type
, 0);
7528 if ((s
->type
.t
& (VT_STATIC
| VT_INLINE
| VT_BTYPE
)) ==
7529 (VT_STATIC
| VT_INLINE
| VT_FUNC
)) {
7530 /* if referencing an inline function, then we generate a
7531 symbol to it if not already done. It will have the
7532 effect to generate code for it at the end of the
7533 compilation unit. Inline function as always
7534 generated in the text section. */
7536 put_extern_sym(s
, text_section
, 0, 0);
7537 r
= VT_SYM
| VT_CONST
;
7541 vset(&s
->type
, r
, s
->c
);
7542 /* if forward reference, we must point to s */
7543 if (vtop
->r
& VT_SYM
) {
7550 /* post operations */
7552 if (tok
== TOK_INC
|| tok
== TOK_DEC
) {
7555 } else if (tok
== '.' || tok
== TOK_ARROW
) {
7557 if (tok
== TOK_ARROW
)
7562 /* expect pointer on structure */
7563 if ((vtop
->type
.t
& VT_BTYPE
) != VT_STRUCT
)
7564 expect("struct or union");
7568 while ((s
= s
->next
) != NULL
) {
7573 error("field not found");
7574 /* add field offset to pointer */
7575 vtop
->type
= char_pointer_type
; /* change type to 'char *' */
7578 /* change type to field type, and set to lvalue */
7579 vtop
->type
= s
->type
;
7580 /* an array is never an lvalue */
7581 if (!(vtop
->type
.t
& VT_ARRAY
)) {
7582 vtop
->r
|= lvalue_type(vtop
->type
.t
);
7583 /* if bound checking, the referenced pointer must be checked */
7584 if (do_bounds_check
)
7585 vtop
->r
|= VT_MUSTBOUND
;
7588 } else if (tok
== '[') {
7594 } else if (tok
== '(') {
7600 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
7601 /* pointer test (no array accepted) */
7602 if ((vtop
->type
.t
& (VT_BTYPE
| VT_ARRAY
)) == VT_PTR
) {
7603 vtop
->type
= *pointed_type(&vtop
->type
);
7604 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
)
7608 expect("function pointer");
7611 vtop
->r
&= ~VT_LVAL
; /* no lvalue */
7613 /* get return type */
7616 sa
= s
->next
; /* first parameter */
7618 /* compute first implicit argument if a structure is returned */
7619 if ((s
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
7620 /* get some space for the returned structure */
7621 size
= type_size(&s
->type
, &align
);
7622 loc
= (loc
- size
) & -align
;
7624 ret
.r
= VT_LOCAL
| VT_LVAL
;
7625 /* pass it as 'int' to avoid structure arg passing
7627 vseti(VT_LOCAL
, loc
);
7633 /* return in register */
7634 if (is_float(ret
.type
.t
)) {
7637 if ((ret
.type
.t
& VT_BTYPE
) == VT_LLONG
)
7646 gfunc_param_typed(s
, sa
);
7656 error("too few arguments to function");
7658 if (!nocode_wanted
) {
7659 gfunc_call(nb_args
);
7661 vtop
-= (nb_args
+ 1);
7664 vsetc(&ret
.type
, ret
.r
, &ret
.c
);
7672 static void uneq(void)
7678 (tok
>= TOK_A_MOD
&& tok
<= TOK_A_DIV
) ||
7679 tok
== TOK_A_XOR
|| tok
== TOK_A_OR
||
7680 tok
== TOK_A_SHL
|| tok
== TOK_A_SAR
) {
7695 static void expr_prod(void)
7700 while (tok
== '*' || tok
== '/' || tok
== '%') {
7708 static void expr_sum(void)
7713 while (tok
== '+' || tok
== '-') {
7721 static void expr_shift(void)
7726 while (tok
== TOK_SHL
|| tok
== TOK_SAR
) {
7734 static void expr_cmp(void)
7739 while ((tok
>= TOK_ULE
&& tok
<= TOK_GT
) ||
7740 tok
== TOK_ULT
|| tok
== TOK_UGE
) {
7748 static void expr_cmpeq(void)
7753 while (tok
== TOK_EQ
|| tok
== TOK_NE
) {
7761 static void expr_and(void)
7764 while (tok
== '&') {
7771 static void expr_xor(void)
7774 while (tok
== '^') {
7781 static void expr_or(void)
7784 while (tok
== '|') {
7791 /* XXX: fix this mess */
7792 static void expr_land_const(void)
7795 while (tok
== TOK_LAND
) {
7802 /* XXX: fix this mess */
7803 static void expr_lor_const(void)
7806 while (tok
== TOK_LOR
) {
7813 /* only used if non constant */
7814 static void expr_land(void)
7819 if (tok
== TOK_LAND
) {
7824 if (tok
!= TOK_LAND
) {
7834 static void expr_lor(void)
7839 if (tok
== TOK_LOR
) {
7844 if (tok
!= TOK_LOR
) {
7854 /* XXX: better constant handling */
7855 static void expr_eq(void)
7857 int tt
, u
, r1
, r2
, rc
, t1
, t2
, bt1
, bt2
;
7859 CType type
, type1
, type2
;
7868 if (tok
== ':' && gnu_ext
) {
7884 if (vtop
!= vstack
) {
7885 /* needed to avoid having different registers saved in
7887 if (is_float(vtop
->type
.t
))
7894 if (tok
== ':' && gnu_ext
) {
7902 sv
= *vtop
; /* save value to handle it later */
7903 vtop
--; /* no vpop so that FP stack is not flushed */
7911 bt1
= t1
& VT_BTYPE
;
7913 bt2
= t2
& VT_BTYPE
;
7914 /* cast operands to correct type according to ISOC rules */
7915 if (is_float(bt1
) || is_float(bt2
)) {
7916 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
7917 type
.t
= VT_LDOUBLE
;
7918 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
7923 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
7924 /* cast to biggest op */
7926 /* convert to unsigned if it does not fit in a long long */
7927 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
7928 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
7929 type
.t
|= VT_UNSIGNED
;
7930 } else if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
7931 /* XXX: test pointer compatibility */
7933 } else if (bt1
== VT_FUNC
|| bt2
== VT_FUNC
) {
7934 /* XXX: test function pointer compatibility */
7936 } else if (bt1
== VT_STRUCT
|| bt2
== VT_STRUCT
) {
7937 /* XXX: test structure compatibility */
7939 } else if (bt1
== VT_VOID
|| bt2
== VT_VOID
) {
7940 /* NOTE: as an extension, we accept void on only one side */
7943 /* integer operations */
7945 /* convert to unsigned if it does not fit in an integer */
7946 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
7947 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
7948 type
.t
|= VT_UNSIGNED
;
7951 /* now we convert second operand */
7953 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
7956 if (is_float(type
.t
)) {
7958 } else if ((type
.t
& VT_BTYPE
) == VT_LLONG
) {
7959 /* for long longs, we use fixed registers to avoid having
7960 to handle a complicated move */
7965 /* this is horrible, but we must also convert first
7969 /* put again first value and cast it */
7972 if (VT_STRUCT
== (vtop
->type
.t
& VT_BTYPE
))
7982 static void gexpr(void)
7993 /* parse an expression and return its type without any side effect. */
7994 static void expr_type(CType
*type
)
7996 int saved_nocode_wanted
;
7998 saved_nocode_wanted
= nocode_wanted
;
8003 nocode_wanted
= saved_nocode_wanted
;
8006 /* parse a unary expression and return its type without any side
8008 static void unary_type(CType
*type
)
8020 /* parse a constant expression and return value in vtop. */
8021 static void expr_const1(void)
8030 /* parse an integer constant and return its value. */
8031 static int expr_const(void)
8035 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
8036 expect("constant expression");
8042 /* return the label token if current token is a label, otherwise
8044 static int is_label(void)
8048 /* fast test first */
8049 if (tok
< TOK_UIDENT
)
8051 /* no need to save tokc because tok is an identifier */
8058 unget_tok(last_tok
);
8063 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
,
8064 int case_reg
, int is_expr
)
8069 /* generate line number info */
8071 (last_line_num
!= file
->line_num
|| last_ind
!= ind
)) {
8072 put_stabn(N_SLINE
, 0, file
->line_num
, ind
- func_ind
);
8074 last_line_num
= file
->line_num
;
8078 /* default return value is (void) */
8080 vtop
->type
.t
= VT_VOID
;
8083 if (tok
== TOK_IF
) {
8090 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
8092 if (c
== TOK_ELSE
) {
8096 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
8097 gsym(d
); /* patch else jmp */
8100 } else if (tok
== TOK_WHILE
) {
8108 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
8112 } else if (tok
== '{') {
8116 /* record local declaration stack position */
8118 llabel
= local_label_stack
;
8119 /* handle local labels declarations */
8120 if (tok
== TOK_LABEL
) {
8123 if (tok
< TOK_UIDENT
)
8124 expect("label identifier");
8125 label_push(&local_label_stack
, tok
, LABEL_DECLARED
);
8135 while (tok
!= '}') {
8140 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
8143 /* pop locally defined labels */
8144 label_pop(&local_label_stack
, llabel
);
8145 /* pop locally defined symbols */
8146 sym_pop(&local_stack
, s
);
8148 } else if (tok
== TOK_RETURN
) {
8152 gen_assign_cast(&func_vt
);
8153 if ((func_vt
.t
& VT_BTYPE
) == VT_STRUCT
) {
8155 /* if returning structure, must copy it to implicit
8156 first pointer arg location */
8159 size
= type_size(&func_vt
,&align
);
8162 if((vtop
->r
!= (VT_LOCAL
| VT_LVAL
) || (vtop
->c
.i
& 3))
8166 loc
= (loc
- size
) & -4;
8169 vset(&type
, VT_LOCAL
| VT_LVAL
, addr
);
8172 vset(&int_type
, VT_LOCAL
| VT_LVAL
, addr
);
8174 vtop
->type
= int_type
;
8180 vset(&type
, VT_LOCAL
| VT_LVAL
, func_vc
);
8183 /* copy structure value to pointer */
8188 } else if (is_float(func_vt
.t
)) {
8193 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
8196 rsym
= gjmp(rsym
); /* jmp */
8197 } else if (tok
== TOK_BREAK
) {
8200 error("cannot break");
8201 *bsym
= gjmp(*bsym
);
8204 } else if (tok
== TOK_CONTINUE
) {
8207 error("cannot continue");
8208 *csym
= gjmp(*csym
);
8211 } else if (tok
== TOK_FOR
) {
8238 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
8243 if (tok
== TOK_DO
) {
8248 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
8259 if (tok
== TOK_SWITCH
) {
8263 /* XXX: other types than integer */
8264 case_reg
= gv(RC_INT
);
8268 b
= gjmp(0); /* jump to first case */
8270 block(&a
, csym
, &b
, &c
, case_reg
, 0);
8271 /* if no default, jmp after switch */
8279 if (tok
== TOK_CASE
) {
8286 if (gnu_ext
&& tok
== TOK_DOTS
) {
8290 warning("empty case range");
8292 /* since a case is like a label, we must skip it with a jmp */
8299 *case_sym
= gtst(1, 0);
8302 *case_sym
= gtst(1, 0);
8306 *case_sym
= gtst(1, *case_sym
);
8311 goto block_after_label
;
8313 if (tok
== TOK_DEFAULT
) {
8319 error("too many 'default'");
8322 goto block_after_label
;
8324 if (tok
== TOK_GOTO
) {
8326 if (tok
== '*' && gnu_ext
) {
8330 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
)
8333 } else if (tok
>= TOK_UIDENT
) {
8334 s
= label_find(tok
);
8335 /* put forward definition if needed */
8337 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
8339 if (s
->r
== LABEL_DECLARED
)
8340 s
->r
= LABEL_FORWARD
;
8342 /* label already defined */
8343 if (s
->r
& LABEL_FORWARD
)
8344 s
->next
= (void *)gjmp((long)s
->next
);
8346 gjmp_addr((long)s
->next
);
8349 expect("label identifier");
8352 } else if (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
) {
8360 if (s
->r
== LABEL_DEFINED
)
8361 error("duplicate label '%s'", get_tok_str(s
->v
, NULL
));
8362 gsym((long)s
->next
);
8363 s
->r
= LABEL_DEFINED
;
8365 s
= label_push(&global_label_stack
, b
, LABEL_DEFINED
);
8367 s
->next
= (void *)ind
;
8368 /* we accept this, but it is a mistake */
8371 warning("deprecated use of label at end of compound statement");
8375 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
8378 /* expression case */
8393 /* t is the array or struct type. c is the array or struct
8394 address. cur_index/cur_field is the pointer to the current
8395 value. 'size_only' is true if only size info is needed (only used
8397 static void decl_designator(CType
*type
, Section
*sec
, unsigned long c
,
8398 int *cur_index
, Sym
**cur_field
,
8402 int notfirst
, index
, index_last
, align
, l
, nb_elems
, elem_size
;
8408 if (gnu_ext
&& (l
= is_label()) != 0)
8410 while (tok
== '[' || tok
== '.') {
8412 if (!(type
->t
& VT_ARRAY
))
8413 expect("array type");
8416 index
= expr_const();
8417 if (index
< 0 || (s
->c
>= 0 && index
>= s
->c
))
8418 expect("invalid index");
8419 if (tok
== TOK_DOTS
&& gnu_ext
) {
8421 index_last
= expr_const();
8422 if (index_last
< 0 ||
8423 (s
->c
>= 0 && index_last
>= s
->c
) ||
8425 expect("invalid index");
8431 *cur_index
= index_last
;
8432 type
= pointed_type(type
);
8433 elem_size
= type_size(type
, &align
);
8434 c
+= index
* elem_size
;
8435 /* NOTE: we only support ranges for last designator */
8436 nb_elems
= index_last
- index
+ 1;
8437 if (nb_elems
!= 1) {
8446 if ((type
->t
& VT_BTYPE
) != VT_STRUCT
)
8447 expect("struct/union type");
8460 /* XXX: fix this mess by using explicit storage field */
8462 type1
.t
|= (type
->t
& ~VT_TYPE
);
8476 if (type
->t
& VT_ARRAY
) {
8478 type
= pointed_type(type
);
8479 c
+= index
* type_size(type
, &align
);
8483 error("too many field init");
8484 /* XXX: fix this mess by using explicit storage field */
8486 type1
.t
|= (type
->t
& ~VT_TYPE
);
8491 decl_initializer(type
, sec
, c
, 0, size_only
);
8493 /* XXX: make it more general */
8494 if (!size_only
&& nb_elems
> 1) {
8495 unsigned long c_end
;
8500 error("range init not supported yet for dynamic storage");
8501 c_end
= c
+ nb_elems
* elem_size
;
8502 if (c_end
> sec
->data_allocated
)
8503 section_realloc(sec
, c_end
);
8504 src
= sec
->data
+ c
;
8506 for(i
= 1; i
< nb_elems
; i
++) {
8508 memcpy(dst
, src
, elem_size
);
8514 #define EXPR_CONST 1
8517 /* store a value or an expression directly in global data or in local array */
8518 static void init_putv(CType
*type
, Section
*sec
, unsigned long c
,
8519 int v
, int expr_type
)
8521 int saved_global_expr
, bt
, bit_pos
, bit_size
;
8523 unsigned long long bit_mask
;
8531 /* compound literals must be allocated globally in this case */
8532 saved_global_expr
= global_expr
;
8535 global_expr
= saved_global_expr
;
8536 /* NOTE: symbols are accepted */
8537 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) != VT_CONST
)
8538 error("initializer element is not constant");
8546 dtype
.t
&= ~VT_CONSTANT
; /* need to do that to avoid false warning */
8549 /* XXX: not portable */
8550 /* XXX: generate error if incorrect relocation */
8551 gen_assign_cast(&dtype
);
8552 bt
= type
->t
& VT_BTYPE
;
8553 ptr
= sec
->data
+ c
;
8554 /* XXX: make code faster ? */
8555 if (!(type
->t
& VT_BITFIELD
)) {
8560 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
8561 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
8562 bit_mask
= (1LL << bit_size
) - 1;
8564 if ((vtop
->r
& VT_SYM
) &&
8570 (bt
== VT_INT
&& bit_size
!= 32)))
8571 error("initializer element is not computable at load time");
8574 *(char *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
8577 *(short *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
8580 *(double *)ptr
= vtop
->c
.d
;
8583 *(long double *)ptr
= vtop
->c
.ld
;
8586 *(long long *)ptr
|= (vtop
->c
.ll
& bit_mask
) << bit_pos
;
8589 if (vtop
->r
& VT_SYM
) {
8590 greloc(sec
, vtop
->sym
, c
, R_DATA_32
);
8592 *(int *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
8597 vset(&dtype
, VT_LOCAL
|VT_LVAL
, c
);
8604 /* put zeros for variable based init */
8605 static void init_putz(CType
*t
, Section
*sec
, unsigned long c
, int size
)
8608 /* nothing to do because globals are already set to zero */
8610 vpush_global_sym(&func_old_type
, TOK_memset
);
8618 /* 't' contains the type and storage info. 'c' is the offset of the
8619 object in section 'sec'. If 'sec' is NULL, it means stack based
8620 allocation. 'first' is true if array '{' must be read (multi
8621 dimension implicit array init handling). 'size_only' is true if
8622 size only evaluation is wanted (only for arrays). */
8623 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
8624 int first
, int size_only
)
8626 int index
, array_length
, n
, no_oblock
, nb
, parlevel
, i
;
8627 int size1
, align1
, expr_type
;
8631 if (type
->t
& VT_ARRAY
) {
8635 t1
= pointed_type(type
);
8636 size1
= type_size(t1
, &align1
);
8639 if ((first
&& tok
!= TOK_LSTR
&& tok
!= TOK_STR
) ||
8645 /* only parse strings here if correct type (otherwise: handle
8646 them as ((w)char *) expressions */
8647 if ((tok
== TOK_LSTR
&&
8648 #ifdef TCC_TARGET_PE
8649 (t1
->t
& VT_BTYPE
) == VT_SHORT
&& (t1
->t
& VT_UNSIGNED
)) ||
8651 (t1
->t
& VT_BTYPE
) == VT_INT
) ||
8654 (t1
->t
& VT_BTYPE
) == VT_BYTE
)) {
8655 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
8660 /* compute maximum number of chars wanted */
8662 cstr_len
= cstr
->size
;
8664 cstr_len
= cstr
->size
/ sizeof(nwchar_t
);
8667 if (n
>= 0 && nb
> (n
- array_length
))
8668 nb
= n
- array_length
;
8671 warning("initializer-string for array is too long");
8672 /* in order to go faster for common case (char
8673 string in global variable, we handle it
8675 if (sec
&& tok
== TOK_STR
&& size1
== 1) {
8676 memcpy(sec
->data
+ c
+ array_length
, cstr
->data
, nb
);
8680 ch
= ((unsigned char *)cstr
->data
)[i
];
8682 ch
= ((nwchar_t
*)cstr
->data
)[i
];
8683 init_putv(t1
, sec
, c
+ (array_length
+ i
) * size1
,
8691 /* only add trailing zero if enough storage (no
8692 warning in this case since it is standard) */
8693 if (n
< 0 || array_length
< n
) {
8695 init_putv(t1
, sec
, c
+ (array_length
* size1
), 0, EXPR_VAL
);
8701 while (tok
!= '}') {
8702 decl_designator(type
, sec
, c
, &index
, NULL
, size_only
);
8703 if (n
>= 0 && index
>= n
)
8704 error("index too large");
8705 /* must put zero in holes (note that doing it that way
8706 ensures that it even works with designators) */
8707 if (!size_only
&& array_length
< index
) {
8708 init_putz(t1
, sec
, c
+ array_length
* size1
,
8709 (index
- array_length
) * size1
);
8712 if (index
> array_length
)
8713 array_length
= index
;
8714 /* special test for multi dimensional arrays (may not
8715 be strictly correct if designators are used at the
8717 if (index
>= n
&& no_oblock
)
8726 /* put zeros at the end */
8727 if (!size_only
&& n
>= 0 && array_length
< n
) {
8728 init_putz(t1
, sec
, c
+ array_length
* size1
,
8729 (n
- array_length
) * size1
);
8731 /* patch type size if needed */
8733 s
->c
= array_length
;
8734 } else if ((type
->t
& VT_BTYPE
) == VT_STRUCT
&&
8735 (sec
|| !first
|| tok
== '{')) {
8738 /* NOTE: the previous test is a specific case for automatic
8739 struct/union init */
8740 /* XXX: union needs only one init */
8742 /* XXX: this test is incorrect for local initializers
8743 beginning with ( without {. It would be much more difficult
8744 to do it correctly (ideally, the expression parser should
8745 be used in all cases) */
8751 while (tok
== '(') {
8755 if (!parse_btype(&type1
, &ad1
))
8757 type_decl(&type1
, &ad1
, &n
, TYPE_ABSTRACT
);
8759 if (!is_assignable_types(type
, &type1
))
8760 error("invalid type for cast");
8765 if (first
|| tok
== '{') {
8774 while (tok
!= '}') {
8775 decl_designator(type
, sec
, c
, NULL
, &f
, size_only
);
8777 if (!size_only
&& array_length
< index
) {
8778 init_putz(type
, sec
, c
+ array_length
,
8779 index
- array_length
);
8781 index
= index
+ type_size(&f
->type
, &align1
);
8782 if (index
> array_length
)
8783 array_length
= index
;
8785 if (no_oblock
&& f
== NULL
)
8791 /* put zeros at the end */
8792 if (!size_only
&& array_length
< n
) {
8793 init_putz(type
, sec
, c
+ array_length
,
8802 } else if (tok
== '{') {
8804 decl_initializer(type
, sec
, c
, first
, size_only
);
8806 } else if (size_only
) {
8807 /* just skip expression */
8809 while ((parlevel
> 0 || (tok
!= '}' && tok
!= ',')) &&
8813 else if (tok
== ')')
8818 /* currently, we always use constant expression for globals
8819 (may change for scripting case) */
8820 expr_type
= EXPR_CONST
;
8822 expr_type
= EXPR_ANY
;
8823 init_putv(type
, sec
, c
, 0, expr_type
);
8827 /* parse an initializer for type 't' if 'has_init' is non zero, and
8828 allocate space in local or global data space ('r' is either
8829 VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
8830 variable 'v' of scope 'scope' is declared before initializers are
8831 parsed. If 'v' is zero, then a reference to the new object is put
8832 in the value stack. If 'has_init' is 2, a special parsing is done
8833 to handle string constants. */
8834 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
8835 int has_init
, int v
, int scope
)
8837 int size
, align
, addr
, data_offset
;
8839 ParseState saved_parse_state
;
8840 TokenString init_str
;
8843 size
= type_size(type
, &align
);
8844 /* If unknown size, we must evaluate it before
8845 evaluating initializers because
8846 initializers can generate global data too
8847 (e.g. string pointers or ISOC99 compound
8848 literals). It also simplifies local
8849 initializers handling */
8850 tok_str_new(&init_str
);
8853 error("unknown type size");
8854 /* get all init string */
8855 if (has_init
== 2) {
8856 /* only get strings */
8857 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
8858 tok_str_add_tok(&init_str
);
8863 while (level
> 0 || (tok
!= ',' && tok
!= ';')) {
8865 error("unexpected end of file in initializer");
8866 tok_str_add_tok(&init_str
);
8869 else if (tok
== '}') {
8877 tok_str_add(&init_str
, -1);
8878 tok_str_add(&init_str
, 0);
8881 save_parse_state(&saved_parse_state
);
8883 macro_ptr
= init_str
.str
;
8885 decl_initializer(type
, NULL
, 0, 1, 1);
8886 /* prepare second initializer parsing */
8887 macro_ptr
= init_str
.str
;
8890 /* if still unknown size, error */
8891 size
= type_size(type
, &align
);
8893 error("unknown type size");
8895 /* take into account specified alignment if bigger */
8897 if (ad
->aligned
> align
)
8898 align
= ad
->aligned
;
8899 } else if (ad
->packed
) {
8902 if ((r
& VT_VALMASK
) == VT_LOCAL
) {
8904 if (do_bounds_check
&& (type
->t
& VT_ARRAY
))
8906 loc
= (loc
- size
) & -align
;
8908 /* handles bounds */
8909 /* XXX: currently, since we do only one pass, we cannot track
8910 '&' operators, so we add only arrays */
8911 if (do_bounds_check
&& (type
->t
& VT_ARRAY
)) {
8912 unsigned long *bounds_ptr
;
8913 /* add padding between regions */
8915 /* then add local bound info */
8916 bounds_ptr
= section_ptr_add(lbounds_section
, 2 * sizeof(unsigned long));
8917 bounds_ptr
[0] = addr
;
8918 bounds_ptr
[1] = size
;
8921 /* local variable */
8922 sym_push(v
, type
, r
, addr
);
8924 /* push local reference */
8925 vset(type
, r
, addr
);
8931 if (v
&& scope
== VT_CONST
) {
8932 /* see if the symbol was already defined */
8935 if (!is_compatible_types(&sym
->type
, type
))
8936 error("incompatible types for redefinition of '%s'",
8937 get_tok_str(v
, NULL
));
8938 if (sym
->type
.t
& VT_EXTERN
) {
8939 /* if the variable is extern, it was not allocated */
8940 sym
->type
.t
&= ~VT_EXTERN
;
8941 /* set array size if it was ommited in extern
8943 if ((sym
->type
.t
& VT_ARRAY
) &&
8944 sym
->type
.ref
->c
< 0 &&
8946 sym
->type
.ref
->c
= type
->ref
->c
;
8948 /* we accept several definitions of the same
8949 global variable. this is tricky, because we
8950 must play with the SHN_COMMON type of the symbol */
8951 /* XXX: should check if the variable was already
8952 initialized. It is incorrect to initialized it
8954 /* no init data, we won't add more to the symbol */
8961 /* allocate symbol in corresponding section */
8966 else if (tcc_state
->nocommon
)
8970 data_offset
= sec
->data_offset
;
8971 data_offset
= (data_offset
+ align
- 1) & -align
;
8973 /* very important to increment global pointer at this time
8974 because initializers themselves can create new initializers */
8975 data_offset
+= size
;
8976 /* add padding if bound check */
8977 if (do_bounds_check
)
8979 sec
->data_offset
= data_offset
;
8980 /* allocate section space to put the data */
8981 if (sec
->sh_type
!= SHT_NOBITS
&&
8982 data_offset
> sec
->data_allocated
)
8983 section_realloc(sec
, data_offset
);
8984 /* align section if needed */
8985 if (align
> sec
->sh_addralign
)
8986 sec
->sh_addralign
= align
;
8988 addr
= 0; /* avoid warning */
8992 if (scope
!= VT_CONST
|| !sym
) {
8993 sym
= sym_push(v
, type
, r
| VT_SYM
, 0);
8995 /* update symbol definition */
8997 put_extern_sym(sym
, sec
, addr
, size
);
9000 /* put a common area */
9001 put_extern_sym(sym
, NULL
, align
, size
);
9002 /* XXX: find a nicer way */
9003 esym
= &((Elf32_Sym
*)symtab_section
->data
)[sym
->c
];
9004 esym
->st_shndx
= SHN_COMMON
;
9009 /* push global reference */
9010 sym
= get_sym_ref(type
, sec
, addr
, size
);
9012 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
9016 /* handles bounds now because the symbol must be defined
9017 before for the relocation */
9018 if (do_bounds_check
) {
9019 unsigned long *bounds_ptr
;
9021 greloc(bounds_section
, sym
, bounds_section
->data_offset
, R_DATA_32
);
9022 /* then add global bound info */
9023 bounds_ptr
= section_ptr_add(bounds_section
, 2 * sizeof(long));
9024 bounds_ptr
[0] = 0; /* relocated */
9025 bounds_ptr
[1] = size
;
9029 decl_initializer(type
, sec
, addr
, 1, 0);
9030 /* restore parse state if needed */
9032 tok_str_free(init_str
.str
);
9033 restore_parse_state(&saved_parse_state
);
9039 void put_func_debug(Sym
*sym
)
9044 /* XXX: we put here a dummy type */
9045 snprintf(buf
, sizeof(buf
), "%s:%c1",
9046 funcname
, sym
->type
.t
& VT_STATIC
? 'f' : 'F');
9047 put_stabs_r(buf
, N_FUN
, 0, file
->line_num
, 0,
9048 cur_text_section
, sym
->c
);
9053 /* parse an old style function declaration list */
9054 /* XXX: check multiple parameter */
9055 static void func_decl_list(Sym
*func_sym
)
9062 /* parse each declaration */
9063 while (tok
!= '{' && tok
!= ';' && tok
!= ',' && tok
!= TOK_EOF
) {
9064 if (!parse_btype(&btype
, &ad
))
9065 expect("declaration list");
9066 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
9067 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
9069 /* we accept no variable after */
9073 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
9074 /* find parameter in function parameter list */
9077 if ((s
->v
& ~SYM_FIELD
) == v
)
9081 error("declaration for parameter '%s' but no such parameter",
9082 get_tok_str(v
, NULL
));
9084 /* check that no storage specifier except 'register' was given */
9085 if (type
.t
& VT_STORAGE
)
9086 error("storage class specified for '%s'", get_tok_str(v
, NULL
));
9087 convert_parameter_type(&type
);
9088 /* we can add the type (NOTE: it could be local to the function) */
9090 /* accept other parameters */
9101 /* parse a function defined by symbol 'sym' and generate its code in
9102 'cur_text_section' */
9103 static void gen_function(Sym
*sym
)
9105 int saved_nocode_wanted
= nocode_wanted
;
9107 ind
= cur_text_section
->data_offset
;
9108 /* NOTE: we patch the symbol size later */
9109 put_extern_sym(sym
, cur_text_section
, ind
, 0);
9110 funcname
= get_tok_str(sym
->v
, NULL
);
9112 /* put debug symbol */
9114 put_func_debug(sym
);
9115 /* push a dummy symbol to enable local sym storage */
9116 sym_push2(&local_stack
, SYM_FIELD
, 0, 0);
9117 gfunc_prolog(&sym
->type
);
9119 block(NULL
, NULL
, NULL
, NULL
, 0, 0);
9122 cur_text_section
->data_offset
= ind
;
9123 label_pop(&global_label_stack
, NULL
);
9124 sym_pop(&local_stack
, NULL
); /* reset local stack */
9125 /* end of function */
9126 /* patch symbol size */
9127 ((Elf32_Sym
*)symtab_section
->data
)[sym
->c
].st_size
=
9130 put_stabn(N_FUN
, 0, 0, ind
- func_ind
);
9132 funcname
= ""; /* for safety */
9133 func_vt
.t
= VT_VOID
; /* for safety */
9134 ind
= 0; /* for safety */
9135 nocode_wanted
= saved_nocode_wanted
;
9138 static void gen_inline_functions(void)
9142 int *str
, inline_generated
;
9144 /* iterate while inline function are referenced */
9146 inline_generated
= 0;
9147 for(sym
= global_stack
; sym
!= NULL
; sym
= sym
->prev
) {
9149 if (((type
->t
& VT_BTYPE
) == VT_FUNC
) &&
9150 (type
->t
& (VT_STATIC
| VT_INLINE
)) ==
9151 (VT_STATIC
| VT_INLINE
) &&
9153 /* the function was used: generate its code and
9154 convert it to a normal function */
9155 str
= (int *)sym
->r
;
9156 sym
->r
= VT_SYM
| VT_CONST
;
9157 type
->t
&= ~VT_INLINE
;
9161 cur_text_section
= text_section
;
9163 macro_ptr
= NULL
; /* fail safe */
9166 inline_generated
= 1;
9169 if (!inline_generated
)
9173 /* free all remaining inline function tokens */
9174 for(sym
= global_stack
; sym
!= NULL
; sym
= sym
->prev
) {
9176 if (((type
->t
& VT_BTYPE
) == VT_FUNC
) &&
9177 (type
->t
& (VT_STATIC
| VT_INLINE
)) ==
9178 (VT_STATIC
| VT_INLINE
)) {
9179 str
= (int *)sym
->r
;
9181 sym
->r
= 0; /* fail safe */
9186 /* 'l' is VT_LOCAL or VT_CONST to define default storage type */
9187 static void decl(int l
)
9195 if (!parse_btype(&btype
, &ad
)) {
9196 /* skip redundant ';' */
9197 /* XXX: find more elegant solution */
9202 if (l
== VT_CONST
&&
9203 (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
)) {
9204 /* global asm block */
9208 /* special test for old K&R protos without explicit int
9209 type. Only accepted when defining global data */
9210 if (l
== VT_LOCAL
|| tok
< TOK_DEFINE
)
9214 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
9215 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
9217 /* we accept no variable after */
9221 while (1) { /* iterate thru each declaration */
9223 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
9227 type_to_str(buf
, sizeof(buf
), &type
, get_tok_str(v
, NULL
));
9228 printf("type = '%s'\n", buf
);
9231 if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
9232 /* if old style function prototype, we accept a
9235 if (sym
->c
== FUNC_OLD
)
9236 func_decl_list(sym
);
9241 error("cannot use local functions");
9242 if ((type
.t
& VT_BTYPE
) != VT_FUNC
)
9243 expect("function definition");
9245 /* reject abstract declarators in function definition */
9247 while ((sym
= sym
->next
) != NULL
)
9248 if (!(sym
->v
& ~SYM_FIELD
))
9249 expect("identifier");
9251 /* XXX: cannot do better now: convert extern line to static inline */
9252 if ((type
.t
& (VT_EXTERN
| VT_INLINE
)) == (VT_EXTERN
| VT_INLINE
))
9253 type
.t
= (type
.t
& ~VT_EXTERN
) | VT_STATIC
;
9257 if ((sym
->type
.t
& VT_BTYPE
) != VT_FUNC
)
9259 /* specific case: if not func_call defined, we put
9260 the one of the prototype */
9261 /* XXX: should have default value */
9262 if (sym
->type
.ref
->r
!= FUNC_CDECL
&&
9263 type
.ref
->r
== FUNC_CDECL
)
9264 type
.ref
->r
= sym
->type
.ref
->r
;
9265 if (!is_compatible_types(&sym
->type
, &type
)) {
9267 error("incompatible types for redefinition of '%s'",
9268 get_tok_str(v
, NULL
));
9270 /* if symbol is already defined, then put complete type */
9273 /* put function symbol */
9274 sym
= global_identifier_push(v
, type
.t
, 0);
9275 sym
->type
.ref
= type
.ref
;
9278 /* static inline functions are just recorded as a kind
9279 of macro. Their code will be emitted at the end of
9280 the compilation unit only if they are used */
9281 if ((type
.t
& (VT_INLINE
| VT_STATIC
)) ==
9282 (VT_INLINE
| VT_STATIC
)) {
9283 TokenString func_str
;
9286 tok_str_new(&func_str
);
9292 error("unexpected end of file");
9293 tok_str_add_tok(&func_str
);
9298 } else if (t
== '}') {
9300 if (block_level
== 0)
9304 tok_str_add(&func_str
, -1);
9305 tok_str_add(&func_str
, 0);
9306 sym
->r
= (int)func_str
.str
;
9308 /* compute text section */
9309 cur_text_section
= ad
.section
;
9310 if (!cur_text_section
)
9311 cur_text_section
= text_section
;
9312 sym
->r
= VT_SYM
| VT_CONST
;
9314 #ifdef TCC_TARGET_PE
9316 ((Elf32_Sym
*)symtab_section
->data
)[sym
->c
].st_other
|= 1;
9322 if (btype
.t
& VT_TYPEDEF
) {
9323 /* save typedefed type */
9324 /* XXX: test storage specifiers ? */
9325 sym
= sym_push(v
, &type
, 0, 0);
9326 sym
->type
.t
|= VT_TYPEDEF
;
9327 } else if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
9328 /* external function definition */
9329 /* specific case for func_call attribute */
9331 type
.ref
->r
= ad
.func_call
;
9332 external_sym(v
, &type
, 0);
9334 /* not lvalue if array */
9336 if (!(type
.t
& VT_ARRAY
))
9337 r
|= lvalue_type(type
.t
);
9338 has_init
= (tok
== '=');
9339 if ((btype
.t
& VT_EXTERN
) ||
9340 ((type
.t
& VT_ARRAY
) && (type
.t
& VT_STATIC
) &&
9341 !has_init
&& l
== VT_CONST
&& type
.ref
->c
< 0)) {
9342 /* external variable */
9343 /* NOTE: as GCC, uninitialized global static
9344 arrays of null size are considered as
9346 external_sym(v
, &type
, r
);
9348 type
.t
|= (btype
.t
& VT_STATIC
); /* Retain "static". */
9349 if (type
.t
& VT_STATIC
)
9355 decl_initializer_alloc(&type
, &ad
, r
,
9369 /* better than nothing, but needs extension to handle '-E' option
9371 static void preprocess_init(TCCState
*s1
)
9373 s1
->include_stack_ptr
= s1
->include_stack
;
9374 /* XXX: move that before to avoid having to initialize
9375 file->ifdef_stack_ptr ? */
9376 s1
->ifdef_stack_ptr
= s1
->ifdef_stack
;
9377 file
->ifdef_stack_ptr
= s1
->ifdef_stack_ptr
;
9379 /* XXX: not ANSI compliant: bound checking says error */
9381 s1
->pack_stack
[0] = 0;
9382 s1
->pack_stack_ptr
= s1
->pack_stack
;
9385 /* compile the C file opened in 'file'. Return non zero if errors. */
9386 static int tcc_compile(TCCState
*s1
)
9390 volatile int section_sym
;
9393 printf("%s: **** new file\n", file
->filename
);
9395 preprocess_init(s1
);
9398 anon_sym
= SYM_FIRST_ANOM
;
9400 /* file info: full path + filename */
9401 section_sym
= 0; /* avoid warning */
9403 section_sym
= put_elf_sym(symtab_section
, 0, 0,
9404 ELF32_ST_INFO(STB_LOCAL
, STT_SECTION
), 0,
9405 text_section
->sh_num
, NULL
);
9406 getcwd(buf
, sizeof(buf
));
9408 normalize_slashes(buf
);
9410 pstrcat(buf
, sizeof(buf
), "/");
9411 put_stabs_r(buf
, N_SO
, 0, 0,
9412 text_section
->data_offset
, text_section
, section_sym
);
9413 put_stabs_r(file
->filename
, N_SO
, 0, 0,
9414 text_section
->data_offset
, text_section
, section_sym
);
9416 /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
9417 symbols can be safely used */
9418 put_elf_sym(symtab_section
, 0, 0,
9419 ELF32_ST_INFO(STB_LOCAL
, STT_FILE
), 0,
9420 SHN_ABS
, file
->filename
);
9422 /* define some often used types */
9423 int_type
.t
= VT_INT
;
9425 char_pointer_type
.t
= VT_BYTE
;
9426 mk_pointer(&char_pointer_type
);
9428 func_old_type
.t
= VT_FUNC
;
9429 func_old_type
.ref
= sym_push(SYM_FIELD
, &int_type
, FUNC_CDECL
, FUNC_OLD
);
9431 #if defined(TCC_ARM_EABI) && defined(TCC_ARM_VFP)
9432 float_type
.t
= VT_FLOAT
;
9433 double_type
.t
= VT_DOUBLE
;
9435 func_float_type
.t
= VT_FUNC
;
9436 func_float_type
.ref
= sym_push(SYM_FIELD
, &float_type
, FUNC_CDECL
, FUNC_OLD
);
9437 func_double_type
.t
= VT_FUNC
;
9438 func_double_type
.ref
= sym_push(SYM_FIELD
, &double_type
, FUNC_CDECL
, FUNC_OLD
);
9442 /* define 'void *alloca(unsigned int)' builtin function */
9447 sym
= sym_push(p
, mk_pointer(VT_VOID
), FUNC_CDECL
, FUNC_NEW
);
9448 s1
= sym_push(SYM_FIELD
, VT_UNSIGNED
| VT_INT
, 0, 0);
9451 sym_push(TOK_alloca
, VT_FUNC
| (p
<< VT_STRUCT_SHIFT
), VT_CONST
, 0);
9455 define_start
= define_stack
;
9458 if (setjmp(s1
->error_jmp_buf
) == 0) {
9460 s1
->error_set_jmp_enabled
= 1;
9462 ch
= file
->buf_ptr
[0];
9463 tok_flags
= TOK_FLAG_BOL
| TOK_FLAG_BOF
;
9464 parse_flags
= PARSE_FLAG_PREPROCESS
| PARSE_FLAG_TOK_NUM
;
9468 expect("declaration");
9470 /* end of translation unit info */
9472 put_stabs_r(NULL
, N_SO
, 0, 0,
9473 text_section
->data_offset
, text_section
, section_sym
);
9476 s1
->error_set_jmp_enabled
= 0;
9478 /* reset define stack, but leave -Dsymbols (may be incorrect if
9479 they are undefined) */
9480 free_defines(define_start
);
9482 gen_inline_functions();
9484 sym_pop(&global_stack
, NULL
);
9486 return s1
->nb_errors
!= 0 ? -1 : 0;
9489 /* Preprocess the current file */
9490 /* XXX: add line and file infos, add options to preserve spaces */
9491 static int tcc_preprocess(TCCState
*s1
)
9496 preprocess_init(s1
);
9498 define_start
= define_stack
;
9500 ch
= file
->buf_ptr
[0];
9501 tok_flags
= TOK_FLAG_BOL
| TOK_FLAG_BOF
;
9502 parse_flags
= PARSE_FLAG_ASM_COMMENTS
| PARSE_FLAG_PREPROCESS
|
9503 PARSE_FLAG_LINEFEED
;
9507 if (tok
== TOK_EOF
) {
9509 } else if (tok
== TOK_LINEFEED
) {
9513 fputc(' ', s1
->outfile
);
9516 fputs(get_tok_str(tok
, &tokc
), s1
->outfile
);
9519 free_defines(define_start
);
9524 int tcc_compile_string(TCCState
*s
, const char *str
)
9526 BufferedFile bf1
, *bf
= &bf1
;
9530 /* init file structure */
9532 /* XXX: avoid copying */
9534 buf
= tcc_malloc(len
+ 1);
9537 memcpy(buf
, str
, len
);
9540 bf
->buf_end
= buf
+ len
;
9541 pstrcpy(bf
->filename
, sizeof(bf
->filename
), "<string>");
9545 ret
= tcc_compile(s
);
9549 /* currently, no need to close */
9554 /* define a preprocessor symbol. A value can also be provided with the '=' operator */
9555 void tcc_define_symbol(TCCState
*s1
, const char *sym
, const char *value
)
9557 BufferedFile bf1
, *bf
= &bf1
;
9559 pstrcpy(bf
->buffer
, IO_BUF_SIZE
, sym
);
9560 pstrcat(bf
->buffer
, IO_BUF_SIZE
, " ");
9564 pstrcat(bf
->buffer
, IO_BUF_SIZE
, value
);
9566 /* init file structure */
9568 bf
->buf_ptr
= bf
->buffer
;
9569 bf
->buf_end
= bf
->buffer
+ strlen(bf
->buffer
);
9570 *bf
->buf_end
= CH_EOB
;
9571 bf
->filename
[0] = '\0';
9575 s1
->include_stack_ptr
= s1
->include_stack
;
9577 /* parse with define parser */
9578 ch
= file
->buf_ptr
[0];
9584 /* undefine a preprocessor symbol */
9585 void tcc_undefine_symbol(TCCState
*s1
, const char *sym
)
9589 ts
= tok_alloc(sym
, strlen(sym
));
9590 s
= define_find(ts
->tok
);
9591 /* undefine symbol by putting an invalid name */
9596 #ifdef CONFIG_TCC_ASM
9598 #ifdef TCC_TARGET_I386
9599 #include "i386-asm.c"
9604 static void asm_instr(void)
9606 error("inline asm() not supported");
9608 static void asm_global_instr(void)
9610 error("inline asm() not supported");
9616 #ifdef TCC_TARGET_COFF
9617 #include "tcccoff.c"
9620 #ifdef TCC_TARGET_PE
9624 /* print the position in the source file of PC value 'pc' by reading
9625 the stabs debug information */
9626 static void rt_printline(unsigned long wanted_pc
)
9628 Stab_Sym
*sym
, *sym_end
;
9629 char func_name
[128], last_func_name
[128];
9630 unsigned long func_addr
, last_pc
, pc
;
9631 const char *incl_files
[INCLUDE_STACK_SIZE
];
9632 int incl_index
, len
, last_line_num
, i
;
9633 const char *str
, *p
;
9635 fprintf(stderr
, "0x%08lx:", wanted_pc
);
9637 func_name
[0] = '\0';
9640 last_func_name
[0] = '\0';
9641 last_pc
= 0xffffffff;
9643 sym
= (Stab_Sym
*)stab_section
->data
+ 1;
9644 sym_end
= (Stab_Sym
*)(stab_section
->data
+ stab_section
->data_offset
);
9645 while (sym
< sym_end
) {
9646 switch(sym
->n_type
) {
9647 /* function start or end */
9649 if (sym
->n_strx
== 0) {
9650 /* we test if between last line and end of function */
9651 pc
= sym
->n_value
+ func_addr
;
9652 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
9654 func_name
[0] = '\0';
9657 str
= stabstr_section
->data
+ sym
->n_strx
;
9658 p
= strchr(str
, ':');
9660 pstrcpy(func_name
, sizeof(func_name
), str
);
9663 if (len
> sizeof(func_name
) - 1)
9664 len
= sizeof(func_name
) - 1;
9665 memcpy(func_name
, str
, len
);
9666 func_name
[len
] = '\0';
9668 func_addr
= sym
->n_value
;
9671 /* line number info */
9673 pc
= sym
->n_value
+ func_addr
;
9674 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
9677 last_line_num
= sym
->n_desc
;
9679 strcpy(last_func_name
, func_name
);
9683 str
= stabstr_section
->data
+ sym
->n_strx
;
9685 if (incl_index
< INCLUDE_STACK_SIZE
) {
9686 incl_files
[incl_index
++] = str
;
9694 if (sym
->n_strx
== 0) {
9695 incl_index
= 0; /* end of translation unit */
9697 str
= stabstr_section
->data
+ sym
->n_strx
;
9698 /* do not add path */
9700 if (len
> 0 && str
[len
- 1] != '/')
9708 /* second pass: we try symtab symbols (no line number info) */
9711 Elf32_Sym
*sym
, *sym_end
;
9714 sym_end
= (Elf32_Sym
*)(symtab_section
->data
+ symtab_section
->data_offset
);
9715 for(sym
= (Elf32_Sym
*)symtab_section
->data
+ 1;
9718 type
= ELF32_ST_TYPE(sym
->st_info
);
9719 if (type
== STT_FUNC
) {
9720 if (wanted_pc
>= sym
->st_value
&&
9721 wanted_pc
< sym
->st_value
+ sym
->st_size
) {
9722 pstrcpy(last_func_name
, sizeof(last_func_name
),
9723 strtab_section
->data
+ sym
->st_name
);
9729 /* did not find any info: */
9730 fprintf(stderr
, " ???\n");
9733 if (last_func_name
[0] != '\0') {
9734 fprintf(stderr
, " %s()", last_func_name
);
9736 if (incl_index
> 0) {
9737 fprintf(stderr
, " (%s:%d",
9738 incl_files
[incl_index
- 1], last_line_num
);
9739 for(i
= incl_index
- 2; i
>= 0; i
--)
9740 fprintf(stderr
, ", included from %s", incl_files
[i
]);
9741 fprintf(stderr
, ")");
9743 fprintf(stderr
, "\n");
9746 #if !defined(_WIN32) && !defined(CONFIG_TCCBOOT)
9750 /* fix for glibc 2.1 */
9756 /* return the PC at frame level 'level'. Return non zero if not found */
9757 static int rt_get_caller_pc(unsigned long *paddr
,
9758 ucontext_t
*uc
, int level
)
9764 #if defined(__FreeBSD__)
9765 *paddr
= uc
->uc_mcontext
.mc_eip
;
9766 #elif defined(__dietlibc__)
9767 *paddr
= uc
->uc_mcontext
.eip
;
9769 *paddr
= uc
->uc_mcontext
.gregs
[REG_EIP
];
9773 #if defined(__FreeBSD__)
9774 fp
= uc
->uc_mcontext
.mc_ebp
;
9775 #elif defined(__dietlibc__)
9776 fp
= uc
->uc_mcontext
.ebp
;
9778 fp
= uc
->uc_mcontext
.gregs
[REG_EBP
];
9780 for(i
=1;i
<level
;i
++) {
9781 /* XXX: check address validity with program info */
9782 if (fp
<= 0x1000 || fp
>= 0xc0000000)
9784 fp
= ((unsigned long *)fp
)[0];
9786 *paddr
= ((unsigned long *)fp
)[1];
9792 #warning add arch specific rt_get_caller_pc()
9794 static int rt_get_caller_pc(unsigned long *paddr
,
9795 ucontext_t
*uc
, int level
)
9801 /* emit a run time error at position 'pc' */
9802 void rt_error(ucontext_t
*uc
, const char *fmt
, ...)
9809 fprintf(stderr
, "Runtime error: ");
9810 vfprintf(stderr
, fmt
, ap
);
9811 fprintf(stderr
, "\n");
9812 for(i
=0;i
<num_callers
;i
++) {
9813 if (rt_get_caller_pc(&pc
, uc
, i
) < 0)
9816 fprintf(stderr
, "at ");
9818 fprintf(stderr
, "by ");
9825 /* signal handler for fatal errors */
9826 static void sig_error(int signum
, siginfo_t
*siginf
, void *puc
)
9828 ucontext_t
*uc
= puc
;
9832 switch(siginf
->si_code
) {
9835 rt_error(uc
, "division by zero");
9838 rt_error(uc
, "floating point exception");
9844 if (rt_bound_error_msg
&& *rt_bound_error_msg
)
9845 rt_error(uc
, *rt_bound_error_msg
);
9847 rt_error(uc
, "dereferencing invalid pointer");
9850 rt_error(uc
, "illegal instruction");
9853 rt_error(uc
, "abort() called");
9856 rt_error(uc
, "caught signal %d", signum
);
9863 /* do all relocations (needed before using tcc_get_symbol()) */
9864 int tcc_relocate(TCCState
*s1
)
9871 #ifdef TCC_TARGET_PE
9874 tcc_add_runtime(s1
);
9877 relocate_common_syms();
9879 tcc_add_linker_symbols(s1
);
9881 build_got_entries(s1
);
9883 /* compute relocation address : section are relocated in place. We
9884 also alloc the bss space */
9885 for(i
= 1; i
< s1
->nb_sections
; i
++) {
9886 s
= s1
->sections
[i
];
9887 if (s
->sh_flags
& SHF_ALLOC
) {
9888 if (s
->sh_type
== SHT_NOBITS
)
9889 s
->data
= tcc_mallocz(s
->data_offset
);
9890 s
->sh_addr
= (unsigned long)s
->data
;
9894 relocate_syms(s1
, 1);
9896 if (s1
->nb_errors
!= 0)
9899 /* relocate each section */
9900 for(i
= 1; i
< s1
->nb_sections
; i
++) {
9901 s
= s1
->sections
[i
];
9903 relocate_section(s1
, s
);
9906 /* mark executable sections as executable in memory */
9907 for(i
= 1; i
< s1
->nb_sections
; i
++) {
9908 s
= s1
->sections
[i
];
9909 if ((s
->sh_flags
& (SHF_ALLOC
| SHF_EXECINSTR
)) ==
9910 (SHF_ALLOC
| SHF_EXECINSTR
))
9911 set_pages_executable(s
->data
, s
->data_offset
);
9916 /* launch the compiled program with the given arguments */
9917 int tcc_run(TCCState
*s1
, int argc
, char **argv
)
9919 int (*prog_main
)(int, char **);
9921 if (tcc_relocate(s1
) < 0)
9924 prog_main
= tcc_get_symbol_err(s1
, "main");
9927 #if defined(_WIN32) || defined(CONFIG_TCCBOOT)
9928 error("debug mode currently not available for Windows");
9930 struct sigaction sigact
;
9931 /* install TCC signal handlers to print debug info on fatal
9933 sigact
.sa_flags
= SA_SIGINFO
| SA_RESETHAND
;
9934 sigact
.sa_sigaction
= sig_error
;
9935 sigemptyset(&sigact
.sa_mask
);
9936 sigaction(SIGFPE
, &sigact
, NULL
);
9937 sigaction(SIGILL
, &sigact
, NULL
);
9938 sigaction(SIGSEGV
, &sigact
, NULL
);
9939 sigaction(SIGBUS
, &sigact
, NULL
);
9940 sigaction(SIGABRT
, &sigact
, NULL
);
9944 #ifdef CONFIG_TCC_BCHECK
9945 if (do_bounds_check
) {
9946 void (*bound_init
)(void);
9948 /* set error function */
9949 rt_bound_error_msg
= (void *)tcc_get_symbol_err(s1
,
9950 "__bound_error_msg");
9952 /* XXX: use .init section so that it also work in binary ? */
9953 bound_init
= (void *)tcc_get_symbol_err(s1
, "__bound_init");
9957 return (*prog_main
)(argc
, argv
);
9960 TCCState
*tcc_new(void)
9967 s
= tcc_mallocz(sizeof(TCCState
));
9971 s
->output_type
= TCC_OUTPUT_MEMORY
;
9973 /* init isid table */
9975 isidnum_table
[i
] = isid(i
) || isnum(i
);
9977 /* add all tokens */
9979 memset(hash_ident
, 0, TOK_HASH_SIZE
* sizeof(TokenSym
*));
9981 tok_ident
= TOK_IDENT
;
9990 ts
= tok_alloc(p
, r
- p
- 1);
9994 /* we add dummy defines for some special macros to speed up tests
9995 and to have working defined() */
9996 define_push(TOK___LINE__
, MACRO_OBJ
, NULL
, NULL
);
9997 define_push(TOK___FILE__
, MACRO_OBJ
, NULL
, NULL
);
9998 define_push(TOK___DATE__
, MACRO_OBJ
, NULL
, NULL
);
9999 define_push(TOK___TIME__
, MACRO_OBJ
, NULL
, NULL
);
10001 /* standard defines */
10002 tcc_define_symbol(s
, "__STDC__", NULL
);
10003 #if defined(TCC_TARGET_I386)
10004 tcc_define_symbol(s
, "__i386__", NULL
);
10006 #if defined(TCC_TARGET_ARM)
10007 tcc_define_symbol(s
, "__ARM_ARCH_4__", NULL
);
10008 tcc_define_symbol(s
, "__arm_elf__", NULL
);
10009 tcc_define_symbol(s
, "__arm_elf", NULL
);
10010 tcc_define_symbol(s
, "arm_elf", NULL
);
10011 tcc_define_symbol(s
, "__arm__", NULL
);
10012 tcc_define_symbol(s
, "__arm", NULL
);
10013 tcc_define_symbol(s
, "arm", NULL
);
10014 tcc_define_symbol(s
, "__APCS_32__", NULL
);
10017 tcc_define_symbol(s
, "__linux__", NULL
);
10018 tcc_define_symbol(s
, "linux", NULL
);
10020 /* tiny C specific defines */
10021 tcc_define_symbol(s
, "__TINYC__", NULL
);
10023 /* tiny C & gcc defines */
10024 tcc_define_symbol(s
, "__SIZE_TYPE__", "unsigned int");
10025 tcc_define_symbol(s
, "__PTRDIFF_TYPE__", "int");
10026 #ifdef TCC_TARGET_PE
10027 tcc_define_symbol(s
, "__WCHAR_TYPE__", "unsigned short");
10028 tcc_define_symbol(s
, "_WIN32", NULL
);
10030 tcc_define_symbol(s
, "__WCHAR_TYPE__", "int");
10033 /* default library paths */
10034 #ifdef TCC_TARGET_PE
10037 snprintf(buf
, sizeof(buf
), "%s/lib", tcc_lib_path
);
10038 tcc_add_library_path(s
, buf
);
10041 tcc_add_library_path(s
, "/usr/local/lib");
10042 tcc_add_library_path(s
, "/usr/lib");
10043 tcc_add_library_path(s
, "/lib");
10046 /* no section zero */
10047 dynarray_add((void ***)&s
->sections
, &s
->nb_sections
, NULL
);
10049 /* create standard sections */
10050 text_section
= new_section(s
, ".text", SHT_PROGBITS
, SHF_ALLOC
| SHF_EXECINSTR
);
10051 data_section
= new_section(s
, ".data", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
10052 bss_section
= new_section(s
, ".bss", SHT_NOBITS
, SHF_ALLOC
| SHF_WRITE
);
10054 /* symbols are always generated for linking stage */
10055 symtab_section
= new_symtab(s
, ".symtab", SHT_SYMTAB
, 0,
10057 ".hashtab", SHF_PRIVATE
);
10058 strtab_section
= symtab_section
->link
;
10060 /* private symbol table for dynamic symbols */
10061 s
->dynsymtab_section
= new_symtab(s
, ".dynsymtab", SHT_SYMTAB
, SHF_PRIVATE
,
10063 ".dynhashtab", SHF_PRIVATE
);
10064 s
->alacarte_link
= 1;
10066 #ifdef CHAR_IS_UNSIGNED
10067 s
->char_is_unsigned
= 1;
10069 #if defined(TCC_TARGET_PE) && 0
10070 /* XXX: currently the PE linker is not ready to support that */
10071 s
->leading_underscore
= 1;
10076 void tcc_delete(TCCState
*s1
)
10080 /* free -D defines */
10081 free_defines(NULL
);
10084 n
= tok_ident
- TOK_IDENT
;
10085 for(i
= 0; i
< n
; i
++)
10086 tcc_free(table_ident
[i
]);
10087 tcc_free(table_ident
);
10089 /* free all sections */
10091 free_section(symtab_section
->hash
);
10093 free_section(s1
->dynsymtab_section
->hash
);
10094 free_section(s1
->dynsymtab_section
->link
);
10095 free_section(s1
->dynsymtab_section
);
10097 for(i
= 1; i
< s1
->nb_sections
; i
++)
10098 free_section(s1
->sections
[i
]);
10099 tcc_free(s1
->sections
);
10101 /* free loaded dlls array */
10102 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++)
10103 tcc_free(s1
->loaded_dlls
[i
]);
10104 tcc_free(s1
->loaded_dlls
);
10106 /* library paths */
10107 for(i
= 0; i
< s1
->nb_library_paths
; i
++)
10108 tcc_free(s1
->library_paths
[i
]);
10109 tcc_free(s1
->library_paths
);
10111 /* cached includes */
10112 for(i
= 0; i
< s1
->nb_cached_includes
; i
++)
10113 tcc_free(s1
->cached_includes
[i
]);
10114 tcc_free(s1
->cached_includes
);
10116 for(i
= 0; i
< s1
->nb_include_paths
; i
++)
10117 tcc_free(s1
->include_paths
[i
]);
10118 tcc_free(s1
->include_paths
);
10120 for(i
= 0; i
< s1
->nb_sysinclude_paths
; i
++)
10121 tcc_free(s1
->sysinclude_paths
[i
]);
10122 tcc_free(s1
->sysinclude_paths
);
10127 int tcc_add_include_path(TCCState
*s1
, const char *pathname
)
10131 pathname1
= tcc_strdup(pathname
);
10132 dynarray_add((void ***)&s1
->include_paths
, &s1
->nb_include_paths
, pathname1
);
10136 int tcc_add_sysinclude_path(TCCState
*s1
, const char *pathname
)
10140 pathname1
= tcc_strdup(pathname
);
10141 dynarray_add((void ***)&s1
->sysinclude_paths
, &s1
->nb_sysinclude_paths
, pathname1
);
10145 static int tcc_add_file_internal(TCCState
*s1
, const char *filename
, int flags
)
10147 const char *ext
, *filename1
;
10150 BufferedFile
*saved_file
;
10152 /* find source file type with extension */
10153 filename1
= strrchr(filename
, '/');
10157 filename1
= filename
;
10158 ext
= strrchr(filename1
, '.');
10162 /* open the file */
10164 file
= tcc_open(s1
, filename
);
10166 if (flags
& AFF_PRINT_ERROR
) {
10167 error_noabort("file '%s' not found", filename
);
10173 if (flags
& AFF_PREPROCESS
) {
10174 ret
= tcc_preprocess(s1
);
10175 } else if (!ext
|| !strcmp(ext
, "c")) {
10176 /* C file assumed */
10177 ret
= tcc_compile(s1
);
10179 #ifdef CONFIG_TCC_ASM
10180 if (!strcmp(ext
, "S")) {
10181 /* preprocessed assembler */
10182 ret
= tcc_assemble(s1
, 1);
10183 } else if (!strcmp(ext
, "s")) {
10184 /* non preprocessed assembler */
10185 ret
= tcc_assemble(s1
, 0);
10188 #ifdef TCC_TARGET_PE
10189 if (!strcmp(ext
, "def")) {
10190 ret
= pe_load_def_file(s1
, fdopen(file
->fd
, "rb"));
10195 /* assume executable format: auto guess file type */
10196 ret
= read(fd
, &ehdr
, sizeof(ehdr
));
10197 lseek(fd
, 0, SEEK_SET
);
10199 error_noabort("could not read header");
10201 } else if (ret
!= sizeof(ehdr
)) {
10202 goto try_load_script
;
10205 if (ehdr
.e_ident
[0] == ELFMAG0
&&
10206 ehdr
.e_ident
[1] == ELFMAG1
&&
10207 ehdr
.e_ident
[2] == ELFMAG2
&&
10208 ehdr
.e_ident
[3] == ELFMAG3
) {
10209 file
->line_num
= 0; /* do not display line number if error */
10210 if (ehdr
.e_type
== ET_REL
) {
10211 ret
= tcc_load_object_file(s1
, fd
, 0);
10212 } else if (ehdr
.e_type
== ET_DYN
) {
10213 if (s1
->output_type
== TCC_OUTPUT_MEMORY
) {
10214 #ifdef TCC_TARGET_PE
10218 h
= dlopen(filename
, RTLD_GLOBAL
| RTLD_LAZY
);
10225 ret
= tcc_load_dll(s1
, fd
, filename
,
10226 (flags
& AFF_REFERENCED_DLL
) != 0);
10229 error_noabort("unrecognized ELF file");
10232 } else if (memcmp((char *)&ehdr
, ARMAG
, 8) == 0) {
10233 file
->line_num
= 0; /* do not display line number if error */
10234 ret
= tcc_load_archive(s1
, fd
);
10236 #ifdef TCC_TARGET_COFF
10237 if (*(uint16_t *)(&ehdr
) == COFF_C67_MAGIC
) {
10238 ret
= tcc_load_coff(s1
, fd
);
10242 /* as GNU ld, consider it is an ld script if not recognized */
10244 ret
= tcc_load_ldscript(s1
);
10246 error_noabort("unrecognized file type");
10261 int tcc_add_file(TCCState
*s
, const char *filename
)
10263 return tcc_add_file_internal(s
, filename
, AFF_PRINT_ERROR
);
10266 int tcc_add_library_path(TCCState
*s
, const char *pathname
)
10270 pathname1
= tcc_strdup(pathname
);
10271 dynarray_add((void ***)&s
->library_paths
, &s
->nb_library_paths
, pathname1
);
10275 /* find and load a dll. Return non zero if not found */
10276 /* XXX: add '-rpath' option support ? */
10277 static int tcc_add_dll(TCCState
*s
, const char *filename
, int flags
)
10282 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
10283 snprintf(buf
, sizeof(buf
), "%s/%s",
10284 s
->library_paths
[i
], filename
);
10285 if (tcc_add_file_internal(s
, buf
, flags
) == 0)
10291 /* the library name is the same as the argument of the '-l' option */
10292 int tcc_add_library(TCCState
*s
, const char *libraryname
)
10297 /* first we look for the dynamic library if not static linking */
10298 if (!s
->static_link
) {
10299 #ifdef TCC_TARGET_PE
10300 snprintf(buf
, sizeof(buf
), "%s.def", libraryname
);
10302 snprintf(buf
, sizeof(buf
), "lib%s.so", libraryname
);
10304 if (tcc_add_dll(s
, buf
, 0) == 0)
10308 /* then we look for the static library */
10309 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
10310 snprintf(buf
, sizeof(buf
), "%s/lib%s.a",
10311 s
->library_paths
[i
], libraryname
);
10312 if (tcc_add_file_internal(s
, buf
, 0) == 0)
10318 int tcc_add_symbol(TCCState
*s
, const char *name
, unsigned long val
)
10320 add_elf_sym(symtab_section
, val
, 0,
10321 ELF32_ST_INFO(STB_GLOBAL
, STT_NOTYPE
), 0,
10326 int tcc_set_output_type(TCCState
*s
, int output_type
)
10328 s
->output_type
= output_type
;
10330 if (!s
->nostdinc
) {
10333 /* default include paths */
10334 /* XXX: reverse order needed if -isystem support */
10335 #ifndef TCC_TARGET_PE
10336 tcc_add_sysinclude_path(s
, "/usr/local/include");
10337 tcc_add_sysinclude_path(s
, "/usr/include");
10339 snprintf(buf
, sizeof(buf
), "%s/include", tcc_lib_path
);
10340 tcc_add_sysinclude_path(s
, buf
);
10341 #ifdef TCC_TARGET_PE
10342 snprintf(buf
, sizeof(buf
), "%s/include/winapi", tcc_lib_path
);
10343 tcc_add_sysinclude_path(s
, buf
);
10347 /* if bound checking, then add corresponding sections */
10348 #ifdef CONFIG_TCC_BCHECK
10349 if (do_bounds_check
) {
10350 /* define symbol */
10351 tcc_define_symbol(s
, "__BOUNDS_CHECKING_ON", NULL
);
10352 /* create bounds sections */
10353 bounds_section
= new_section(s
, ".bounds",
10354 SHT_PROGBITS
, SHF_ALLOC
);
10355 lbounds_section
= new_section(s
, ".lbounds",
10356 SHT_PROGBITS
, SHF_ALLOC
);
10360 if (s
->char_is_unsigned
) {
10361 tcc_define_symbol(s
, "__CHAR_UNSIGNED__", NULL
);
10364 /* add debug sections */
10367 stab_section
= new_section(s
, ".stab", SHT_PROGBITS
, 0);
10368 stab_section
->sh_entsize
= sizeof(Stab_Sym
);
10369 stabstr_section
= new_section(s
, ".stabstr", SHT_STRTAB
, 0);
10370 put_elf_str(stabstr_section
, "");
10371 stab_section
->link
= stabstr_section
;
10372 /* put first entry */
10373 put_stabs("", 0, 0, 0, 0);
10376 /* add libc crt1/crti objects */
10377 #ifndef TCC_TARGET_PE
10378 if ((output_type
== TCC_OUTPUT_EXE
|| output_type
== TCC_OUTPUT_DLL
) &&
10380 if (output_type
!= TCC_OUTPUT_DLL
)
10381 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crt1.o");
10382 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crti.o");
10388 #define WD_ALL 0x0001 /* warning is activated when using -Wall */
10389 #define FD_INVERT 0x0002 /* invert value before storing */
10391 typedef struct FlagDef
{
10397 static const FlagDef warning_defs
[] = {
10398 { offsetof(TCCState
, warn_unsupported
), 0, "unsupported" },
10399 { offsetof(TCCState
, warn_write_strings
), 0, "write-strings" },
10400 { offsetof(TCCState
, warn_error
), 0, "error" },
10401 { offsetof(TCCState
, warn_implicit_function_declaration
), WD_ALL
,
10402 "implicit-function-declaration" },
10405 static int set_flag(TCCState
*s
, const FlagDef
*flags
, int nb_flags
,
10406 const char *name
, int value
)
10413 if (r
[0] == 'n' && r
[1] == 'o' && r
[2] == '-') {
10417 for(i
= 0, p
= flags
; i
< nb_flags
; i
++, p
++) {
10418 if (!strcmp(r
, p
->name
))
10423 if (p
->flags
& FD_INVERT
)
10425 *(int *)((uint8_t *)s
+ p
->offset
) = value
;
10430 /* set/reset a warning */
10431 int tcc_set_warning(TCCState
*s
, const char *warning_name
, int value
)
10436 if (!strcmp(warning_name
, "all")) {
10437 for(i
= 0, p
= warning_defs
; i
< countof(warning_defs
); i
++, p
++) {
10438 if (p
->flags
& WD_ALL
)
10439 *(int *)((uint8_t *)s
+ p
->offset
) = 1;
10443 return set_flag(s
, warning_defs
, countof(warning_defs
),
10444 warning_name
, value
);
10448 static const FlagDef flag_defs
[] = {
10449 { offsetof(TCCState
, char_is_unsigned
), 0, "unsigned-char" },
10450 { offsetof(TCCState
, char_is_unsigned
), FD_INVERT
, "signed-char" },
10451 { offsetof(TCCState
, nocommon
), FD_INVERT
, "common" },
10452 { offsetof(TCCState
, leading_underscore
), 0, "leading-underscore" },
10455 /* set/reset a flag */
10456 int tcc_set_flag(TCCState
*s
, const char *flag_name
, int value
)
10458 return set_flag(s
, flag_defs
, countof(flag_defs
),
10462 /* extract the basename of a file */
10463 static char *tcc_basename(const char *name
)
10465 char *p
= strchr(name
, 0);
10476 #if !defined(LIBTCC)
10478 static int64_t getclock_us(void)
10483 return (tb
.time
* 1000LL + tb
.millitm
) * 1000LL;
10486 gettimeofday(&tv
, NULL
);
10487 return tv
.tv_sec
* 1000000LL + tv
.tv_usec
;
10493 printf("tcc version " TCC_VERSION
" - Tiny C Compiler - Copyright (C) 2001-2006 Fabrice Bellard\n"
10494 "usage: tcc [-v] [-c] [-o outfile] [-Bdir] [-bench] [-Idir] [-Dsym[=val]] [-Usym]\n"
10495 " [-Wwarn] [-g] [-b] [-bt N] [-Ldir] [-llib] [-shared] [-static]\n"
10496 " [infile1 infile2...] [-run infile args...]\n"
10498 "General options:\n"
10499 " -v display current version\n"
10500 " -c compile only - generate an object file\n"
10501 " -o outfile set output filename\n"
10502 " -Bdir set tcc internal library path\n"
10503 " -bench output compilation statistics\n"
10504 " -run run compiled source\n"
10505 " -fflag set or reset (with 'no-' prefix) 'flag' (see man page)\n"
10506 " -Wwarning set or reset (with 'no-' prefix) 'warning' (see man page)\n"
10507 " -w disable all warnings\n"
10508 "Preprocessor options:\n"
10509 " -E preprocess only\n"
10510 " -Idir add include path 'dir'\n"
10511 " -Dsym[=val] define 'sym' with value 'val'\n"
10512 " -Usym undefine 'sym'\n"
10513 "Linker options:\n"
10514 " -Ldir add library path 'dir'\n"
10515 " -llib link with dynamic or static library 'lib'\n"
10516 " -shared generate a shared library\n"
10517 " -static static linking\n"
10518 " -rdynamic export all global symbols to dynamic linker\n"
10519 " -r relocatable output\n"
10520 "Debugger options:\n"
10521 " -g generate runtime debug info\n"
10522 #ifdef CONFIG_TCC_BCHECK
10523 " -b compile with built-in memory and bounds checker (implies -g)\n"
10525 " -bt N show N callers in stack traces\n"
10529 #define TCC_OPTION_HAS_ARG 0x0001
10530 #define TCC_OPTION_NOSEP 0x0002 /* cannot have space before option and arg */
10532 typedef struct TCCOption
{
10560 TCC_OPTION_nostdinc
,
10561 TCC_OPTION_nostdlib
,
10562 TCC_OPTION_print_search_dirs
,
10563 TCC_OPTION_rdynamic
,
10571 static const TCCOption tcc_options
[] = {
10572 { "h", TCC_OPTION_HELP
, 0 },
10573 { "?", TCC_OPTION_HELP
, 0 },
10574 { "I", TCC_OPTION_I
, TCC_OPTION_HAS_ARG
},
10575 { "D", TCC_OPTION_D
, TCC_OPTION_HAS_ARG
},
10576 { "U", TCC_OPTION_U
, TCC_OPTION_HAS_ARG
},
10577 { "L", TCC_OPTION_L
, TCC_OPTION_HAS_ARG
},
10578 { "B", TCC_OPTION_B
, TCC_OPTION_HAS_ARG
},
10579 { "l", TCC_OPTION_l
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
10580 { "bench", TCC_OPTION_bench
, 0 },
10581 { "bt", TCC_OPTION_bt
, TCC_OPTION_HAS_ARG
},
10582 #ifdef CONFIG_TCC_BCHECK
10583 { "b", TCC_OPTION_b
, 0 },
10585 { "g", TCC_OPTION_g
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
10586 { "c", TCC_OPTION_c
, 0 },
10587 { "static", TCC_OPTION_static
, 0 },
10588 { "shared", TCC_OPTION_shared
, 0 },
10589 { "o", TCC_OPTION_o
, TCC_OPTION_HAS_ARG
},
10590 { "run", TCC_OPTION_run
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
10591 { "rdynamic", TCC_OPTION_rdynamic
, 0 },
10592 { "r", TCC_OPTION_r
, 0 },
10593 { "Wl,", TCC_OPTION_Wl
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
10594 { "W", TCC_OPTION_W
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
10595 { "O", TCC_OPTION_O
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
10596 { "m", TCC_OPTION_m
, TCC_OPTION_HAS_ARG
},
10597 { "f", TCC_OPTION_f
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
10598 { "nostdinc", TCC_OPTION_nostdinc
, 0 },
10599 { "nostdlib", TCC_OPTION_nostdlib
, 0 },
10600 { "print-search-dirs", TCC_OPTION_print_search_dirs
, 0 },
10601 { "v", TCC_OPTION_v
, 0 },
10602 { "w", TCC_OPTION_w
, 0 },
10603 { "pipe", TCC_OPTION_pipe
, 0},
10604 { "E", TCC_OPTION_E
, 0},
10608 /* convert 'str' into an array of space separated strings */
10609 static int expand_args(char ***pargv
, const char *str
)
10618 while (is_space(*str
))
10623 while (*str
!= '\0' && !is_space(*str
))
10626 arg
= tcc_malloc(len
+ 1);
10627 memcpy(arg
, s1
, len
);
10629 dynarray_add((void ***)&argv
, &argc
, arg
);
10635 static char **files
;
10636 static int nb_files
, nb_libraries
;
10637 static int multiple_files
;
10638 static int print_search_dirs
;
10639 static int output_type
;
10640 static int reloc_output
;
10641 static const char *outfile
;
10643 int parse_args(TCCState
*s
, int argc
, char **argv
)
10646 const TCCOption
*popt
;
10647 const char *optarg
, *p1
, *r1
;
10652 if (optind
>= argc
) {
10653 if (nb_files
== 0 && !print_search_dirs
)
10658 r
= argv
[optind
++];
10660 /* add a new file */
10661 dynarray_add((void ***)&files
, &nb_files
, r
);
10662 if (!multiple_files
) {
10664 /* argv[0] will be this file */
10668 /* find option in table (match only the first chars */
10669 popt
= tcc_options
;
10673 error("invalid option -- '%s'", r
);
10686 if (popt
->flags
& TCC_OPTION_HAS_ARG
) {
10687 if (*r1
!= '\0' || (popt
->flags
& TCC_OPTION_NOSEP
)) {
10690 if (optind
>= argc
)
10691 error("argument to '%s' is missing", r
);
10692 optarg
= argv
[optind
++];
10700 switch(popt
->index
) {
10701 case TCC_OPTION_HELP
:
10706 if (tcc_add_include_path(s
, optarg
) < 0)
10707 error("too many include paths");
10712 sym
= (char *)optarg
;
10713 value
= strchr(sym
, '=');
10718 tcc_define_symbol(s
, sym
, value
);
10722 tcc_undefine_symbol(s
, optarg
);
10725 tcc_add_library_path(s
, optarg
);
10728 /* set tcc utilities path (mainly for tcc development) */
10729 tcc_lib_path
= optarg
;
10732 dynarray_add((void ***)&files
, &nb_files
, r
);
10735 case TCC_OPTION_bench
:
10738 case TCC_OPTION_bt
:
10739 num_callers
= atoi(optarg
);
10741 #ifdef CONFIG_TCC_BCHECK
10743 do_bounds_check
= 1;
10751 multiple_files
= 1;
10752 output_type
= TCC_OUTPUT_OBJ
;
10754 case TCC_OPTION_static
:
10755 s
->static_link
= 1;
10757 case TCC_OPTION_shared
:
10758 output_type
= TCC_OUTPUT_DLL
;
10761 multiple_files
= 1;
10765 /* generate a .o merging several output files */
10767 output_type
= TCC_OUTPUT_OBJ
;
10769 case TCC_OPTION_nostdinc
:
10772 case TCC_OPTION_nostdlib
:
10775 case TCC_OPTION_print_search_dirs
:
10776 print_search_dirs
= 1;
10778 case TCC_OPTION_run
:
10782 argc1
= expand_args(&argv1
, optarg
);
10784 parse_args(s
, argc1
, argv1
);
10786 multiple_files
= 0;
10787 output_type
= TCC_OUTPUT_MEMORY
;
10791 printf("tcc version %s\n", TCC_VERSION
);
10794 if (tcc_set_flag(s
, optarg
, 1) < 0 && s
->warn_unsupported
)
10795 goto unsupported_option
;
10798 if (tcc_set_warning(s
, optarg
, 1) < 0 &&
10799 s
->warn_unsupported
)
10800 goto unsupported_option
;
10805 case TCC_OPTION_rdynamic
:
10808 case TCC_OPTION_Wl
:
10811 if (strstart(optarg
, "-Ttext,", &p
)) {
10812 s
->text_addr
= strtoul(p
, NULL
, 16);
10813 s
->has_text_addr
= 1;
10814 } else if (strstart(optarg
, "--oformat,", &p
)) {
10815 if (strstart(p
, "elf32-", NULL
)) {
10816 s
->output_format
= TCC_OUTPUT_FORMAT_ELF
;
10817 } else if (!strcmp(p
, "binary")) {
10818 s
->output_format
= TCC_OUTPUT_FORMAT_BINARY
;
10820 #ifdef TCC_TARGET_COFF
10821 if (!strcmp(p
, "coff")) {
10822 s
->output_format
= TCC_OUTPUT_FORMAT_COFF
;
10826 error("target %s not found", p
);
10829 error("unsupported linker option '%s'", optarg
);
10834 output_type
= TCC_OUTPUT_PREPROCESS
;
10837 if (s
->warn_unsupported
) {
10838 unsupported_option
:
10839 warning("unsupported option '%s'", r
);
10848 int main(int argc
, char **argv
)
10852 int nb_objfiles
, ret
, optind
;
10853 char objfilename
[1024];
10854 int64_t start_time
= 0;
10857 tcc_lib_path
= w32_tcc_lib_path();
10861 output_type
= TCC_OUTPUT_EXE
;
10863 multiple_files
= 1;
10868 print_search_dirs
= 0;
10870 optind
= parse_args(s
, argc
- 1, argv
+ 1) + 1;
10872 if (print_search_dirs
) {
10873 /* enough for Linux kernel */
10874 printf("install: %s/\n", tcc_lib_path
);
10878 nb_objfiles
= nb_files
- nb_libraries
;
10880 /* if outfile provided without other options, we output an
10882 if (outfile
&& output_type
== TCC_OUTPUT_MEMORY
)
10883 output_type
= TCC_OUTPUT_EXE
;
10885 /* check -c consistency : only single file handled. XXX: checks file type */
10886 if (output_type
== TCC_OUTPUT_OBJ
&& !reloc_output
) {
10887 /* accepts only a single input file */
10888 if (nb_objfiles
!= 1)
10889 error("cannot specify multiple files with -c");
10890 if (nb_libraries
!= 0)
10891 error("cannot specify libraries with -c");
10895 if (output_type
== TCC_OUTPUT_PREPROCESS
) {
10897 s
->outfile
= stdout
;
10899 s
->outfile
= fopen(outfile
, "wb");
10901 error("could not open '%s", outfile
);
10903 } else if (output_type
!= TCC_OUTPUT_MEMORY
) {
10905 /* compute default outfile name */
10906 pstrcpy(objfilename
, sizeof(objfilename
) - 1,
10908 tcc_basename(files
[0]));
10909 #ifdef TCC_TARGET_PE
10910 pe_guess_outfile(objfilename
, output_type
);
10912 if (output_type
== TCC_OUTPUT_OBJ
&& !reloc_output
) {
10913 char *ext
= strrchr(objfilename
, '.');
10915 goto default_outfile
;
10916 /* add .o extension */
10917 strcpy(ext
+ 1, "o");
10920 pstrcpy(objfilename
, sizeof(objfilename
), "a.out");
10923 outfile
= objfilename
;
10928 start_time
= getclock_us();
10931 tcc_set_output_type(s
, output_type
);
10933 /* compile or add each files or library */
10934 for(i
= 0;i
< nb_files
; i
++) {
10935 const char *filename
;
10937 filename
= files
[i
];
10938 if (output_type
== TCC_OUTPUT_PREPROCESS
) {
10939 tcc_add_file_internal(s
, filename
,
10940 AFF_PRINT_ERROR
| AFF_PREPROCESS
);
10942 if (filename
[0] == '-') {
10943 if (tcc_add_library(s
, filename
+ 2) < 0)
10944 error("cannot find %s", filename
);
10946 if (tcc_add_file(s
, filename
) < 0) {
10954 /* free all files */
10959 total_time
= (double)(getclock_us() - start_time
) / 1000000.0;
10960 if (total_time
< 0.001)
10961 total_time
= 0.001;
10962 if (total_bytes
< 1)
10964 printf("%d idents, %d lines, %d bytes, %0.3f s, %d lines/s, %0.1f MB/s\n",
10965 tok_ident
- TOK_IDENT
, total_lines
, total_bytes
,
10966 total_time
, (int)(total_lines
/ total_time
),
10967 total_bytes
/ total_time
/ 1000000.0);
10970 if (s
->output_type
== TCC_OUTPUT_PREPROCESS
) {
10972 fclose(s
->outfile
);
10974 } else if (s
->output_type
== TCC_OUTPUT_MEMORY
) {
10975 ret
= tcc_run(s
, argc
- optind
, argv
+ optind
);
10977 #ifdef TCC_TARGET_PE
10978 if (s
->output_type
!= TCC_OUTPUT_OBJ
) {
10979 ret
= tcc_output_pe(s
, outfile
);
10983 ret
= tcc_output_file(s
, outfile
) ? 1 : 0;
10986 /* XXX: cannot do it with bound checking because of the malloc hooks */
10987 if (!do_bounds_check
)
10992 printf("memory: %d bytes, max = %d bytes\n", mem_cur_size
, mem_max_size
);