2 * TCC - Tiny C Compiler
4 * Copyright (c) 2001, 2002 Fabrice Bellard
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
35 #include <sys/timeb.h>
39 #include <sys/ucontext.h>
43 #ifndef CONFIG_TCC_STATIC
51 /* preprocessor debug */
53 /* include file debug */
61 /* target selection */
62 //#define TCC_TARGET_I386 /* i386 code generator */
64 /* default target is I386 */
65 #if !defined(TCC_TARGET_I386)
66 #define TCC_TARGET_I386
69 #if !defined(WIN32) && !defined(TCC_UCLIBC)
70 #define CONFIG_TCC_BCHECK /* enable bound checking code */
73 /* define it to include assembler support */
74 #define CONFIG_TCC_ASM
76 /* path to find crt1.o, crti.o and crtn.o. Only needed when generating
77 executables or dlls */
78 #define CONFIG_TCC_CRT_PREFIX "/usr/lib"
80 #define INCLUDE_STACK_SIZE 32
81 #define IFDEF_STACK_SIZE 64
82 #define VSTACK_SIZE 64
83 #define STRING_MAX_SIZE 1024
85 #define TOK_HASH_SIZE 2048 /* must be a power of two */
86 #define TOK_ALLOC_INCR 512 /* must be a power of two */
87 #define TOK_STR_ALLOC_INCR_BITS 6
88 #define TOK_STR_ALLOC_INCR (1 << TOK_STR_ALLOC_INCR_BITS)
89 #define TOK_MAX_SIZE 4 /* token max size in int unit when stored in string */
91 /* token symbol management */
92 typedef struct TokenSym
{
93 struct TokenSym
*hash_next
;
94 struct Sym
*sym_define
; /* direct pointer to define */
95 struct Sym
*sym_label
; /* direct pointer to label */
96 struct Sym
*sym_struct
; /* direct pointer to structure */
97 struct Sym
*sym_identifier
; /* direct pointer to identifier */
98 int tok
; /* token number */
103 typedef struct CString
{
104 int size
; /* size in bytes */
105 void *data
; /* either 'char *' or 'int *' */
107 void *data_allocated
; /* if non NULL, data has been malloced */
110 /* type definition */
111 typedef struct CType
{
117 typedef union CValue
{
123 unsigned int ul
; /* address (should be unsigned long on 64 bit cpu) */
125 unsigned long long ull
;
126 struct CString
*cstr
;
132 typedef struct SValue
{
133 CType type
; /* type */
134 unsigned short r
; /* register + flags */
135 unsigned short r2
; /* second register, used for 'long long'
136 type. If not used, set to VT_CONST */
137 CValue c
; /* constant, if VT_CONST */
138 struct Sym
*sym
; /* symbol, if (VT_SYM | VT_CONST) */
141 /* symbol management */
143 int v
; /* symbol token */
144 int r
; /* associated register */
145 int c
; /* associated number */
146 CType type
; /* associated type */
147 struct Sym
*next
; /* next related symbol */
148 struct Sym
*prev
; /* prev symbol in stack */
149 struct Sym
*prev_tok
; /* previous symbol for this token */
152 /* section definition */
153 /* XXX: use directly ELF structure for parameters ? */
154 /* special flag to indicate that the section should not be linked to
156 #define SHF_PRIVATE 0x80000000
158 typedef struct Section
{
159 unsigned long data_offset
; /* current data offset */
160 unsigned char *data
; /* section data */
161 unsigned long data_allocated
; /* used for realloc() handling */
162 int sh_name
; /* elf section name (only used during output) */
163 int sh_num
; /* elf section number */
164 int sh_type
; /* elf section type */
165 int sh_flags
; /* elf section flags */
166 int sh_info
; /* elf section info */
167 int sh_addralign
; /* elf section alignment */
168 int sh_entsize
; /* elf entry size */
169 unsigned long sh_size
; /* section size (only used during output) */
170 unsigned long sh_addr
; /* address at which the section is relocated */
171 unsigned long sh_offset
; /* address at which the section is relocated */
172 int nb_hashed_syms
; /* used to resize the hash table */
173 struct Section
*link
; /* link to another section */
174 struct Section
*reloc
; /* corresponding section for relocation, if any */
175 struct Section
*hash
; /* hash table for symbols */
176 struct Section
*next
;
177 char name
[64]; /* section name */
180 typedef struct DLLReference
{
185 /* GNUC attribute definition */
186 typedef struct AttributeDef
{
189 unsigned char func_call
; /* FUNC_CDECL or FUNC_STDCALL */
192 #define SYM_STRUCT 0x40000000 /* struct/union/enum symbol space */
193 #define SYM_FIELD 0x20000000 /* struct/union field symbol space */
194 #define SYM_FIRST_ANOM (1 << (31 - VT_STRUCT_SHIFT)) /* first anonymous sym */
196 /* stored in 'Sym.c' field */
197 #define FUNC_NEW 1 /* ansi function prototype */
198 #define FUNC_OLD 2 /* old function prototype */
199 #define FUNC_ELLIPSIS 3 /* ansi function prototype with ... */
201 /* stored in 'Sym.r' field */
202 #define FUNC_CDECL 0 /* standard c call */
203 #define FUNC_STDCALL 1 /* pascal c call */
205 /* field 'Sym.t' for macros */
206 #define MACRO_OBJ 0 /* object like macro */
207 #define MACRO_FUNC 1 /* function like macro */
209 /* field 'Sym.r' for C labels */
210 #define LABEL_DEFINED 0 /* label is defined */
211 #define LABEL_FORWARD 1 /* label is forward defined */
212 #define LABEL_DECLARED 2 /* label is declared but never used */
214 /* type_decl() types */
215 #define TYPE_ABSTRACT 1 /* type without variable */
216 #define TYPE_DIRECT 2 /* type with variable */
218 #define IO_BUF_SIZE 8192
220 typedef struct BufferedFile
{
224 int line_num
; /* current line number - here to simplify code */
225 int ifndef_macro
; /* #ifndef macro / #endif search */
226 int ifndef_macro_saved
; /* saved ifndef_macro */
227 int *ifdef_stack_ptr
; /* ifdef_stack value at the start of the file */
228 char inc_type
; /* type of include */
229 char inc_filename
[512]; /* filename specified by the user */
230 char filename
[1024]; /* current filename - here to simplify code */
231 unsigned char buffer
[IO_BUF_SIZE
+ 1]; /* extra size for CH_EOB char */
234 #define CH_EOB '\\' /* end of buffer or '\0' char in file */
235 #define CH_EOF (-1) /* end of file */
237 /* parsing state (used to save parser state to reparse part of the
238 source several times) */
239 typedef struct ParseState
{
246 /* used to record tokens */
247 typedef struct TokenString
{
254 /* include file cache, used to find files faster and also to eliminate
255 inclusion if the include file is protected by #ifndef ... #endif */
256 typedef struct CachedInclude
{
258 char type
; /* '"' or '>' to give include type */
259 char filename
[1]; /* path specified in #include */
263 static struct BufferedFile
*file
;
266 static CString tokcstr
; /* current parsed string, if any */
267 /* additional informations about token */
268 static int tok_flags
;
269 #define TOK_FLAG_BOL 0x0001 /* beginning of line before */
270 #define TOK_FLAG_BOF 0x0002 /* beginning of file before */
271 #define TOK_FLAG_ENDIF 0x0004 /* a endif was found matching starting #ifdef */
273 static int *macro_ptr
, *macro_ptr_allocated
;
274 static int *unget_saved_macro_ptr
;
275 static int unget_saved_buffer
[TOK_MAX_SIZE
+ 1];
276 static int unget_buffer_enabled
;
277 static int parse_flags
;
278 #define PARSE_FLAG_PREPROCESS 0x0001 /* activate preprocessing */
279 #define PARSE_FLAG_TOK_NUM 0x0002 /* return numbers instead of TOK_PPNUM */
280 #define PARSE_FLAG_LINEFEED 0x0004 /* line feed is returned as a
281 token. line feed is also
284 static Section
*text_section
, *data_section
, *bss_section
; /* predefined sections */
285 static Section
*cur_text_section
; /* current section where function code is
287 /* bound check related sections */
288 static Section
*bounds_section
; /* contains global data bound description */
289 static Section
*lbounds_section
; /* contains local data bound description */
290 /* symbol sections */
291 static Section
*symtab_section
, *strtab_section
;
294 static Section
*stab_section
, *stabstr_section
;
296 /* loc : local variable index
297 ind : output code index
299 anon_sym: anonymous symbol index
301 static int rsym
, anon_sym
, ind
, loc
;
302 /* expression generation modifiers */
303 static int const_wanted
; /* true if constant wanted */
304 static int nocode_wanted
; /* true if no code generation wanted for an expression */
305 static int global_expr
; /* true if compound literals must be allocated
306 globally (used during initializers parsing */
307 static CType func_vt
; /* current function return type (used by return
310 static int last_line_num
, last_ind
, func_ind
; /* debug last line number and pc */
311 static int tok_ident
;
312 static TokenSym
**table_ident
;
313 static TokenSym
*hash_ident
[TOK_HASH_SIZE
];
314 static char token_buf
[STRING_MAX_SIZE
+ 1];
315 static char *funcname
;
316 static Sym
*global_stack
, *local_stack
;
317 static Sym
*define_stack
;
318 static Sym
*global_label_stack
, *local_label_stack
;
320 static SValue vstack
[VSTACK_SIZE
], *vtop
;
321 /* some predefined types */
322 static CType char_pointer_type
, func_old_type
, int_type
;
323 /* true if isid(c) || isnum(c) */
324 static unsigned char isidnum_table
[256];
326 /* compile with debug symbol (and use them if error during execution) */
327 static int do_debug
= 0;
329 /* compile with built-in memory and bounds checker */
330 static int do_bounds_check
= 0;
332 /* display benchmark infos */
334 static int do_bench
= 0;
336 static int total_lines
;
337 static int total_bytes
;
339 /* use GNU C extensions */
340 static int gnu_ext
= 1;
342 /* use Tiny C extensions */
343 static int tcc_ext
= 1;
345 /* max number of callers shown if error */
346 static int num_callers
= 6;
347 static const char **rt_bound_error_msg
;
349 /* XXX: get rid of this ASAP */
350 static struct TCCState
*tcc_state
;
352 /* give the path of the tcc libraries */
353 static const char *tcc_lib_path
= CONFIG_TCC_LIBDIR
"/tcc";
358 BufferedFile
**include_stack_ptr
;
359 int *ifdef_stack_ptr
;
361 /* include file handling */
362 char **include_paths
;
363 int nb_include_paths
;
364 char **sysinclude_paths
;
365 int nb_sysinclude_paths
;
366 CachedInclude
**cached_includes
;
367 int nb_cached_includes
;
369 char **library_paths
;
370 int nb_library_paths
;
372 /* array of all loaded dlls (including those referenced by loaded
374 DLLReference
**loaded_dlls
;
379 int nb_sections
; /* number of sections, including first dummy section */
384 unsigned long *got_offsets
;
386 /* give the correspondance from symtab indexes to dynsym indexes */
387 int *symtab_to_dynsym
;
389 /* temporary dynamic symbol sections (for dll loading) */
390 Section
*dynsymtab_section
;
391 /* exported dynamic symbol section */
394 /* if true, no standard headers are added */
397 /* if true, static linking is performed */
402 void (*error_func
)(void *opaque
, const char *msg
);
403 int error_set_jmp_enabled
;
404 jmp_buf error_jmp_buf
;
407 /* tiny assembler state */
410 /* see include_stack_ptr */
411 BufferedFile
*include_stack
[INCLUDE_STACK_SIZE
];
413 /* see ifdef_stack_ptr */
414 int ifdef_stack
[IFDEF_STACK_SIZE
];
417 /* The current value can be: */
418 #define VT_VALMASK 0x00ff
419 #define VT_CONST 0x00f0 /* constant in vc
420 (must be first non register value) */
421 #define VT_LLOCAL 0x00f1 /* lvalue, offset on stack */
422 #define VT_LOCAL 0x00f2 /* offset on stack */
423 #define VT_CMP 0x00f3 /* the value is stored in processor flags (in vc) */
424 #define VT_JMP 0x00f4 /* value is the consequence of jmp true (even) */
425 #define VT_JMPI 0x00f5 /* value is the consequence of jmp false (odd) */
426 #define VT_LVAL 0x0100 /* var is an lvalue */
427 #define VT_SYM 0x0200 /* a symbol value is added */
428 #define VT_MUSTCAST 0x0400 /* value must be casted to be correct (used for
429 char/short stored in integer registers) */
430 #define VT_MUSTBOUND 0x0800 /* bound checking must be done before
431 dereferencing value */
432 #define VT_BOUNDED 0x8000 /* value is bounded. The address of the
433 bounding function call point is in vc */
434 #define VT_LVAL_BYTE 0x1000 /* lvalue is a byte */
435 #define VT_LVAL_SHORT 0x2000 /* lvalue is a short */
436 #define VT_LVAL_UNSIGNED 0x4000 /* lvalue is unsigned */
437 #define VT_LVAL_TYPE (VT_LVAL_BYTE | VT_LVAL_SHORT | VT_LVAL_UNSIGNED)
440 #define VT_STRUCT_SHIFT 12 /* structure/enum name shift (20 bits left) */
442 #define VT_INT 0 /* integer type */
443 #define VT_BYTE 1 /* signed byte type */
444 #define VT_SHORT 2 /* short type */
445 #define VT_VOID 3 /* void type */
446 #define VT_PTR 4 /* pointer */
447 #define VT_ENUM 5 /* enum definition */
448 #define VT_FUNC 6 /* function type */
449 #define VT_STRUCT 7 /* struct/union definition */
450 #define VT_FLOAT 8 /* IEEE float */
451 #define VT_DOUBLE 9 /* IEEE double */
452 #define VT_LDOUBLE 10 /* IEEE long double */
453 #define VT_BOOL 11 /* ISOC99 boolean type */
454 #define VT_LLONG 12 /* 64 bit integer */
455 #define VT_LONG 13 /* long integer (NEVER USED as type, only
457 #define VT_BTYPE 0x000f /* mask for basic type */
458 #define VT_UNSIGNED 0x0010 /* unsigned type */
459 #define VT_ARRAY 0x0020 /* array type (also has VT_PTR) */
460 #define VT_BITFIELD 0x0040 /* bitfield modifier */
463 #define VT_EXTERN 0x00000080 /* extern definition */
464 #define VT_STATIC 0x00000100 /* static variable */
465 #define VT_TYPEDEF 0x00000200 /* typedef definition */
466 #define VT_INLINE 0x00000400 /* inline definition */
468 /* type mask (except storage) */
469 #define VT_STORAGE (VT_EXTERN | VT_STATIC | VT_TYPEDEF | VT_INLINE)
470 #define VT_TYPE (~(VT_STORAGE))
474 /* warning: the following compare tokens depend on i386 asm code */
486 #define TOK_LAND 0xa0
490 #define TOK_MID 0xa3 /* inc/dec, to void constant */
492 #define TOK_UDIV 0xb0 /* unsigned division */
493 #define TOK_UMOD 0xb1 /* unsigned modulo */
494 #define TOK_PDIV 0xb2 /* fast division with undefined rounding for pointers */
495 #define TOK_CINT 0xb3 /* number in tokc */
496 #define TOK_CCHAR 0xb4 /* char constant in tokc */
497 #define TOK_STR 0xb5 /* pointer to string in tokc */
498 #define TOK_TWOSHARPS 0xb6 /* ## preprocessing token */
499 #define TOK_LCHAR 0xb7
500 #define TOK_LSTR 0xb8
501 #define TOK_CFLOAT 0xb9 /* float constant */
502 #define TOK_LINENUM 0xba /* line number info */
503 #define TOK_CDOUBLE 0xc0 /* double constant */
504 #define TOK_CLDOUBLE 0xc1 /* long double constant */
505 #define TOK_UMULL 0xc2 /* unsigned 32x32 -> 64 mul */
506 #define TOK_ADDC1 0xc3 /* add with carry generation */
507 #define TOK_ADDC2 0xc4 /* add with carry use */
508 #define TOK_SUBC1 0xc5 /* add with carry generation */
509 #define TOK_SUBC2 0xc6 /* add with carry use */
510 #define TOK_CUINT 0xc8 /* unsigned int constant */
511 #define TOK_CLLONG 0xc9 /* long long constant */
512 #define TOK_CULLONG 0xca /* unsigned long long constant */
513 #define TOK_ARROW 0xcb
514 #define TOK_DOTS 0xcc /* three dots */
515 #define TOK_SHR 0xcd /* unsigned shift right */
516 #define TOK_PPNUM 0xce /* preprocessor number */
518 #define TOK_SHL 0x01 /* shift left */
519 #define TOK_SAR 0x02 /* signed shift right */
521 /* assignement operators : normal operator or 0x80 */
522 #define TOK_A_MOD 0xa5
523 #define TOK_A_AND 0xa6
524 #define TOK_A_MUL 0xaa
525 #define TOK_A_ADD 0xab
526 #define TOK_A_SUB 0xad
527 #define TOK_A_DIV 0xaf
528 #define TOK_A_XOR 0xde
529 #define TOK_A_OR 0xfc
530 #define TOK_A_SHL 0x81
531 #define TOK_A_SAR 0x82
533 /* WARNING: the content of this string encodes token numbers */
534 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";
536 #define TOK_EOF (-1) /* end of file */
537 #define TOK_LINEFEED 10 /* line feed */
539 /* all identificators and strings have token above that */
540 #define TOK_IDENT 256
542 /* only used for i386 asm opcodes definitions */
543 #define DEF_ASM(x) DEF(TOK_ASM_ ## x, #x)
546 DEF(TOK_ASM_ ## x ## b, #x "b") \
547 DEF(TOK_ASM_ ## x ## w, #x "w") \
548 DEF(TOK_ASM_ ## x ## l, #x "l") \
549 DEF(TOK_ASM_ ## x, #x)
552 DEF(TOK_ASM_ ## x ## w, #x "w") \
553 DEF(TOK_ASM_ ## x ## l, #x "l") \
554 DEF(TOK_ASM_ ## x, #x)
557 DEF(TOK_ASM_ ## f ## x ## s, "f" #x "s") \
558 DEF(TOK_ASM_ ## fi ## x ## l, "fi" #x "l") \
559 DEF(TOK_ASM_ ## f ## x ## l, "f" #x "l") \
560 DEF(TOK_ASM_ ## fi ## x ## s, "fi" #x "s")
563 DEF(TOK_ASM_ ## f ## x, "f" #x ) \
564 DEF(TOK_ASM_ ## f ## x ## p, "f" #x "p") \
567 #define DEF_ASMTEST(x) \
599 #define TOK_ASM_int TOK_INT
602 TOK_LAST
= TOK_IDENT
- 1,
603 #define DEF(id, str) id,
608 static const char tcc_keywords
[] =
609 #define DEF(id, str) str "\0"
614 #define TOK_UIDENT TOK_DEFINE
617 #define snprintf _snprintf
618 #define vsnprintf _vsnprintf
621 #if defined(WIN32) || defined(TCC_UCLIBC) || defined(__FreeBSD__)
622 /* currently incorrect */
623 long double strtold(const char *nptr
, char **endptr
)
625 return (long double)strtod(nptr
, endptr
);
627 float strtof(const char *nptr
, char **endptr
)
629 return (float)strtod(nptr
, endptr
);
632 /* XXX: need to define this to use them in non ISOC99 context */
633 extern float strtof (const char *__nptr
, char **__endptr
);
634 extern long double strtold (const char *__nptr
, char **__endptr
);
637 static char *pstrcpy(char *buf
, int buf_size
, const char *s
);
638 static char *pstrcat(char *buf
, int buf_size
, const char *s
);
640 static void next(void);
641 static void next_nomacro(void);
642 static void parse_expr_type(CType
*type
);
643 static void expr_type(CType
*type
);
644 static void unary_type(CType
*type
);
645 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
,
646 int case_reg
, int is_expr
);
647 static int expr_const(void);
648 static void expr_eq(void);
649 static void gexpr(void);
650 static void decl(int l
);
651 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
652 int first
, int size_only
);
653 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
654 int has_init
, int v
, int scope
);
656 void gv2(int rc1
, int rc2
);
657 void move_reg(int r
, int s
);
658 void save_regs(int n
);
659 void save_reg(int r
);
665 static void macro_subst(TokenString
*tok_str
,
666 Sym
**nested_list
, const int *macro_str
);
667 int save_reg_forced(int r
);
669 void force_charshort_cast(int t
);
670 static void gen_cast(CType
*type
);
672 static Sym
*sym_find(int v
);
673 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
);
676 static int type_size(CType
*type
, int *a
);
677 static inline CType
*pointed_type(CType
*type
);
678 static int pointed_size(CType
*type
);
679 static int lvalue_type(int t
);
680 static int is_compatible_types(CType
*type1
, CType
*type2
);
681 static int parse_btype(CType
*type
, AttributeDef
*ad
);
682 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
);
684 void error(const char *fmt
, ...);
686 void vset(CType
*type
, int r
, int v
);
687 void type_to_str(char *buf
, int buf_size
,
688 CType
*type
, const char *varstr
);
689 char *get_tok_str(int v
, CValue
*cv
);
690 static Sym
*get_sym_ref(CType
*type
, Section
*sec
,
691 unsigned long offset
, unsigned long size
);
692 static Sym
*external_global_sym(int v
, CType
*type
, int r
);
694 /* section generation */
695 static void section_realloc(Section
*sec
, unsigned long new_size
);
696 static void *section_ptr_add(Section
*sec
, unsigned long size
);
697 static void put_extern_sym(Sym
*sym
, Section
*section
,
698 unsigned long value
, unsigned long size
);
699 static void greloc(Section
*s
, Sym
*sym
, unsigned long addr
, int type
);
700 static int put_elf_str(Section
*s
, const char *sym
);
701 static int put_elf_sym(Section
*s
,
702 unsigned long value
, unsigned long size
,
703 int info
, int other
, int shndx
, const char *name
);
704 static int add_elf_sym(Section
*s
, unsigned long value
, unsigned long size
,
705 int info
, int sh_num
, const char *name
);
706 static void put_elf_reloc(Section
*symtab
, Section
*s
, unsigned long offset
,
707 int type
, int symbol
);
708 static void put_stabs(const char *str
, int type
, int other
, int desc
,
709 unsigned long value
);
710 static void put_stabs_r(const char *str
, int type
, int other
, int desc
,
711 unsigned long value
, Section
*sec
, int sym_index
);
712 static void put_stabn(int type
, int other
, int desc
, int value
);
713 static void put_stabd(int type
, int other
, int desc
);
714 static int tcc_add_dll(TCCState
*s
, const char *filename
, int flags
);
716 #define AFF_PRINT_ERROR 0x0001 /* print error if file not found */
717 #define AFF_REFERENCED_DLL 0x0002 /* load a referenced dll from another dll */
718 static int tcc_add_file_internal(TCCState
*s
, const char *filename
, int flags
);
722 #ifdef CONFIG_TCC_ASM
724 typedef struct ExprValue
{
729 #define MAX_ASM_OPERANDS 30
731 typedef struct ASMOperand
{
732 int id
; /* GCC 3 optionnal identifier (0 if number only supported */
734 char asm_str
[16]; /* computed asm string for operand */
735 SValue
*vt
; /* C value of the expression */
736 int ref_index
; /* if >= 0, gives reference to a output constraint */
737 int priority
; /* priority, used to assign registers */
738 int reg
; /* if >= 0, register number used for this operand */
741 static void asm_expr(TCCState
*s1
, ExprValue
*pe
);
742 static int asm_int_expr(TCCState
*s1
);
743 static int find_constraint(ASMOperand
*operands
, int nb_operands
,
744 const char *name
, const char **pp
);
746 static int tcc_assemble(TCCState
*s1
, int do_preprocess
);
750 static void asm_instr(void);
752 /* true if float/double/long double type */
753 static inline int is_float(int t
)
757 return bt
== VT_LDOUBLE
|| bt
== VT_DOUBLE
|| bt
== VT_FLOAT
;
760 #ifdef TCC_TARGET_I386
761 #include "i386-gen.c"
764 #ifdef CONFIG_TCC_STATIC
766 #define RTLD_LAZY 0x001
767 #define RTLD_NOW 0x002
768 #define RTLD_GLOBAL 0x100
769 #define RTLD_DEFAULT NULL
771 /* dummy function for profiling */
772 void *dlopen(const char *filename
, int flag
)
777 const char *dlerror(void)
782 typedef struct TCCSyms
{
787 #define TCCSYM(a) { #a, &a, },
789 /* add the symbol you want here if no dynamic linking is done */
790 static TCCSyms tcc_syms
[] = {
798 void *dlsym(void *handle
, const char *symbol
)
802 while (p
->str
!= NULL
) {
803 if (!strcmp(p
->str
, symbol
))
812 /********************************************************/
814 /* we use our own 'finite' function to avoid potential problems with
815 non standard math libs */
816 /* XXX: endianness dependent */
817 int ieee_finite(double d
)
820 return ((unsigned)((p
[1] | 0x800fffff) + 1)) >> 31;
823 /* copy a string and truncate it. */
824 static char *pstrcpy(char *buf
, int buf_size
, const char *s
)
831 q_end
= buf
+ buf_size
- 1;
843 /* strcat and truncate. */
844 static char *pstrcat(char *buf
, int buf_size
, const char *s
)
849 pstrcpy(buf
+ len
, buf_size
- len
, s
);
853 /* memory management */
859 static inline void tcc_free(void *ptr
)
862 mem_cur_size
-= malloc_usable_size(ptr
);
867 static void *tcc_malloc(unsigned long size
)
872 error("memory full");
874 mem_cur_size
+= malloc_usable_size(ptr
);
875 if (mem_cur_size
> mem_max_size
)
876 mem_max_size
= mem_cur_size
;
881 static void *tcc_mallocz(unsigned long size
)
884 ptr
= tcc_malloc(size
);
885 memset(ptr
, 0, size
);
889 static inline void *tcc_realloc(void *ptr
, unsigned long size
)
893 mem_cur_size
-= malloc_usable_size(ptr
);
895 ptr1
= realloc(ptr
, size
);
897 /* NOTE: count not correct if alloc error, but not critical */
898 mem_cur_size
+= malloc_usable_size(ptr1
);
899 if (mem_cur_size
> mem_max_size
)
900 mem_max_size
= mem_cur_size
;
905 static char *tcc_strdup(const char *str
)
908 ptr
= tcc_malloc(strlen(str
) + 1);
913 #define free(p) use_tcc_free(p)
914 #define malloc(s) use_tcc_malloc(s)
915 #define realloc(p, s) use_tcc_realloc(p, s)
917 static void dynarray_add(void ***ptab
, int *nb_ptr
, void *data
)
924 /* every power of two we double array size */
925 if ((nb
& (nb
- 1)) == 0) {
930 pp
= tcc_realloc(pp
, nb_alloc
* sizeof(void *));
932 error("memory full");
939 Section
*new_section(TCCState
*s1
, const char *name
, int sh_type
, int sh_flags
)
943 sec
= tcc_mallocz(sizeof(Section
));
944 pstrcpy(sec
->name
, sizeof(sec
->name
), name
);
945 sec
->sh_type
= sh_type
;
946 sec
->sh_flags
= sh_flags
;
953 sec
->sh_addralign
= 4;
956 sec
->sh_addralign
= 1;
959 sec
->sh_addralign
= 32; /* default conservative alignment */
963 /* only add section if not private */
964 if (!(sh_flags
& SHF_PRIVATE
)) {
965 sec
->sh_num
= s1
->nb_sections
;
966 dynarray_add((void ***)&s1
->sections
, &s1
->nb_sections
, sec
);
971 static void free_section(Section
*s
)
977 /* realloc section and set its content to zero */
978 static void section_realloc(Section
*sec
, unsigned long new_size
)
983 size
= sec
->data_allocated
;
986 while (size
< new_size
)
988 data
= tcc_realloc(sec
->data
, size
);
990 error("memory full");
991 memset(data
+ sec
->data_allocated
, 0, size
- sec
->data_allocated
);
993 sec
->data_allocated
= size
;
996 /* reserve at least 'size' bytes in section 'sec' from
998 static void *section_ptr_add(Section
*sec
, unsigned long size
)
1000 unsigned long offset
, offset1
;
1002 offset
= sec
->data_offset
;
1003 offset1
= offset
+ size
;
1004 if (offset1
> sec
->data_allocated
)
1005 section_realloc(sec
, offset1
);
1006 sec
->data_offset
= offset1
;
1007 return sec
->data
+ offset
;
1010 /* return a reference to a section, and create it if it does not
1012 Section
*find_section(TCCState
*s1
, const char *name
)
1016 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1017 sec
= s1
->sections
[i
];
1018 if (!strcmp(name
, sec
->name
))
1021 /* sections are created as PROGBITS */
1022 return new_section(s1
, name
, SHT_PROGBITS
, SHF_ALLOC
);
1025 /* update sym->c so that it points to an external symbol in section
1026 'section' with value 'value' */
1027 static void put_extern_sym(Sym
*sym
, Section
*section
,
1028 unsigned long value
, unsigned long size
)
1030 int sym_type
, sym_bind
, sh_num
, info
;
1035 sh_num
= section
->sh_num
;
1039 if ((sym
->type
.t
& VT_BTYPE
) == VT_FUNC
)
1040 sym_type
= STT_FUNC
;
1042 sym_type
= STT_OBJECT
;
1043 if (sym
->type
.t
& VT_STATIC
)
1044 sym_bind
= STB_LOCAL
;
1046 sym_bind
= STB_GLOBAL
;
1048 name
= get_tok_str(sym
->v
, NULL
);
1049 #ifdef CONFIG_TCC_BCHECK
1050 if (do_bounds_check
) {
1053 /* XXX: avoid doing that for statics ? */
1054 /* if bound checking is activated, we change some function
1055 names by adding the "__bound" prefix */
1058 /* XXX: we rely only on malloc hooks */
1070 strcpy(buf
, "__bound_");
1077 info
= ELF32_ST_INFO(sym_bind
, sym_type
);
1078 sym
->c
= add_elf_sym(symtab_section
, value
, size
, info
, sh_num
, name
);
1080 esym
= &((Elf32_Sym
*)symtab_section
->data
)[sym
->c
];
1081 esym
->st_value
= value
;
1082 esym
->st_size
= size
;
1083 esym
->st_shndx
= sh_num
;
1087 /* add a new relocation entry to symbol 'sym' in section 's' */
1088 static void greloc(Section
*s
, Sym
*sym
, unsigned long offset
, int type
)
1091 put_extern_sym(sym
, NULL
, 0, 0);
1092 /* now we can add ELF relocation info */
1093 put_elf_reloc(symtab_section
, s
, offset
, type
, sym
->c
);
1096 static inline int isid(int c
)
1098 return (c
>= 'a' && c
<= 'z') ||
1099 (c
>= 'A' && c
<= 'Z') ||
1103 static inline int isnum(int c
)
1105 return c
>= '0' && c
<= '9';
1108 static inline int isoct(int c
)
1110 return c
>= '0' && c
<= '7';
1113 static inline int toup(int c
)
1115 if (c
>= 'a' && c
<= 'z')
1116 return c
- 'a' + 'A';
1121 static void strcat_vprintf(char *buf
, int buf_size
, const char *fmt
, va_list ap
)
1125 vsnprintf(buf
+ len
, buf_size
- len
, fmt
, ap
);
1128 static void strcat_printf(char *buf
, int buf_size
, const char *fmt
, ...)
1132 strcat_vprintf(buf
, buf_size
, fmt
, ap
);
1136 void error1(TCCState
*s1
, int is_warning
, const char *fmt
, va_list ap
)
1143 for(f
= s1
->include_stack
; f
< s1
->include_stack_ptr
; f
++)
1144 strcat_printf(buf
, sizeof(buf
), "In file included from %s:%d:\n",
1145 (*f
)->filename
, (*f
)->line_num
);
1146 if (file
->line_num
> 0) {
1147 strcat_printf(buf
, sizeof(buf
),
1148 "%s:%d: ", file
->filename
, file
->line_num
);
1150 strcat_printf(buf
, sizeof(buf
),
1151 "%s: ", file
->filename
);
1154 strcat_printf(buf
, sizeof(buf
),
1158 strcat_printf(buf
, sizeof(buf
), "warning: ");
1159 strcat_vprintf(buf
, sizeof(buf
), fmt
, ap
);
1161 if (!s1
->error_func
) {
1162 /* default case: stderr */
1163 fprintf(stderr
, "%s\n", buf
);
1165 s1
->error_func(s1
->error_opaque
, buf
);
1172 void tcc_set_error_func(TCCState
*s
, void *error_opaque
,
1173 void (*error_func
)(void *opaque
, const char *msg
))
1175 s
->error_opaque
= error_opaque
;
1176 s
->error_func
= error_func
;
1180 /* error without aborting current compilation */
1181 void error_noabort(const char *fmt
, ...)
1183 TCCState
*s1
= tcc_state
;
1187 error1(s1
, 0, fmt
, ap
);
1191 void error(const char *fmt
, ...)
1193 TCCState
*s1
= tcc_state
;
1197 error1(s1
, 0, fmt
, ap
);
1199 /* better than nothing: in some cases, we accept to handle errors */
1200 if (s1
->error_set_jmp_enabled
) {
1201 longjmp(s1
->error_jmp_buf
, 1);
1203 /* XXX: eliminate this someday */
1208 void expect(const char *msg
)
1210 error("%s expected", msg
);
1213 void warning(const char *fmt
, ...)
1215 TCCState
*s1
= tcc_state
;
1219 error1(s1
, 1, fmt
, ap
);
1226 error("'%c' expected", c
);
1230 static void test_lvalue(void)
1232 if (!(vtop
->r
& VT_LVAL
))
1236 /* allocate a new token */
1237 static TokenSym
*tok_alloc_new(TokenSym
**pts
, const char *str
, int len
)
1239 TokenSym
*ts
, **ptable
;
1242 if (tok_ident
>= SYM_FIRST_ANOM
)
1243 error("memory full");
1245 /* expand token table if needed */
1246 i
= tok_ident
- TOK_IDENT
;
1247 if ((i
% TOK_ALLOC_INCR
) == 0) {
1248 ptable
= tcc_realloc(table_ident
, (i
+ TOK_ALLOC_INCR
) * sizeof(TokenSym
*));
1250 error("memory full");
1251 table_ident
= ptable
;
1254 ts
= tcc_malloc(sizeof(TokenSym
) + len
);
1255 table_ident
[i
] = ts
;
1256 ts
->tok
= tok_ident
++;
1257 ts
->sym_define
= NULL
;
1258 ts
->sym_label
= NULL
;
1259 ts
->sym_struct
= NULL
;
1260 ts
->sym_identifier
= NULL
;
1262 ts
->hash_next
= NULL
;
1263 memcpy(ts
->str
, str
, len
);
1264 ts
->str
[len
] = '\0';
1269 #define TOK_HASH_INIT 1
1270 #define TOK_HASH_FUNC(h, c) ((h) * 263 + (c))
1272 /* find a token and add it if not found */
1273 static TokenSym
*tok_alloc(const char *str
, int len
)
1275 TokenSym
*ts
, **pts
;
1281 h
= TOK_HASH_FUNC(h
, ((unsigned char *)str
)[i
]);
1282 h
&= (TOK_HASH_SIZE
- 1);
1284 pts
= &hash_ident
[h
];
1289 if (ts
->len
== len
&& !memcmp(ts
->str
, str
, len
))
1291 pts
= &(ts
->hash_next
);
1293 return tok_alloc_new(pts
, str
, len
);
1296 /* CString handling */
1298 static void cstr_realloc(CString
*cstr
, int new_size
)
1303 size
= cstr
->size_allocated
;
1305 size
= 8; /* no need to allocate a too small first string */
1306 while (size
< new_size
)
1308 data
= tcc_realloc(cstr
->data_allocated
, size
);
1310 error("memory full");
1311 cstr
->data_allocated
= data
;
1312 cstr
->size_allocated
= size
;
1317 static void cstr_ccat(CString
*cstr
, int ch
)
1320 size
= cstr
->size
+ 1;
1321 if (size
> cstr
->size_allocated
)
1322 cstr_realloc(cstr
, size
);
1323 ((unsigned char *)cstr
->data
)[size
- 1] = ch
;
1327 static void cstr_cat(CString
*cstr
, const char *str
)
1339 /* add a wide char */
1340 static void cstr_wccat(CString
*cstr
, int ch
)
1343 size
= cstr
->size
+ sizeof(int);
1344 if (size
> cstr
->size_allocated
)
1345 cstr_realloc(cstr
, size
);
1346 *(int *)(((unsigned char *)cstr
->data
) + size
- sizeof(int)) = ch
;
1350 static void cstr_new(CString
*cstr
)
1352 memset(cstr
, 0, sizeof(CString
));
1355 /* free string and reset it to NULL */
1356 static void cstr_free(CString
*cstr
)
1358 tcc_free(cstr
->data_allocated
);
1362 #define cstr_reset(cstr) cstr_free(cstr)
1364 static CString
*cstr_dup(CString
*cstr1
)
1369 cstr
= tcc_malloc(sizeof(CString
));
1372 cstr
->size_allocated
= size
;
1373 cstr
->data_allocated
= tcc_malloc(size
);
1374 cstr
->data
= cstr
->data_allocated
;
1375 memcpy(cstr
->data_allocated
, cstr1
->data_allocated
, size
);
1379 /* XXX: unicode ? */
1380 static void add_char(CString
*cstr
, int c
)
1382 if (c
== '\'' || c
== '\"' || c
== '\\') {
1383 /* XXX: could be more precise if char or string */
1384 cstr_ccat(cstr
, '\\');
1386 if (c
>= 32 && c
<= 126) {
1389 cstr_ccat(cstr
, '\\');
1391 cstr_ccat(cstr
, 'n');
1393 cstr_ccat(cstr
, '0' + ((c
>> 6) & 7));
1394 cstr_ccat(cstr
, '0' + ((c
>> 3) & 7));
1395 cstr_ccat(cstr
, '0' + (c
& 7));
1400 /* XXX: buffer overflow */
1401 /* XXX: float tokens */
1402 char *get_tok_str(int v
, CValue
*cv
)
1404 static char buf
[STRING_MAX_SIZE
+ 1];
1405 static CString cstr_buf
;
1411 /* NOTE: to go faster, we give a fixed buffer for small strings */
1412 cstr_reset(&cstr_buf
);
1413 cstr_buf
.data
= buf
;
1414 cstr_buf
.size_allocated
= sizeof(buf
);
1420 /* XXX: not quite exact, but only useful for testing */
1421 sprintf(p
, "%u", cv
->ui
);
1425 /* XXX: not quite exact, but only useful for testing */
1426 sprintf(p
, "%Lu", cv
->ull
);
1430 cstr_ccat(&cstr_buf
, '\'');
1431 add_char(&cstr_buf
, cv
->i
);
1432 cstr_ccat(&cstr_buf
, '\'');
1433 cstr_ccat(&cstr_buf
, '\0');
1437 len
= cstr
->size
- 1;
1439 add_char(&cstr_buf
, ((unsigned char *)cstr
->data
)[i
]);
1440 cstr_ccat(&cstr_buf
, '\0');
1445 cstr_ccat(&cstr_buf
, '\"');
1447 len
= cstr
->size
- 1;
1449 add_char(&cstr_buf
, ((unsigned char *)cstr
->data
)[i
]);
1451 len
= (cstr
->size
/ sizeof(int)) - 1;
1453 add_char(&cstr_buf
, ((int *)cstr
->data
)[i
]);
1455 cstr_ccat(&cstr_buf
, '\"');
1456 cstr_ccat(&cstr_buf
, '\0');
1465 return strcpy(p
, "<<=");
1467 return strcpy(p
, ">>=");
1469 if (v
< TOK_IDENT
) {
1470 /* search in two bytes table */
1484 } else if (v
< tok_ident
) {
1485 return table_ident
[v
- TOK_IDENT
]->str
;
1486 } else if (v
>= SYM_FIRST_ANOM
) {
1487 /* special name for anonymous symbol */
1488 sprintf(p
, "L.%u", v
- SYM_FIRST_ANOM
);
1490 /* should never happen */
1495 return cstr_buf
.data
;
1498 /* push, without hashing */
1499 static Sym
*sym_push2(Sym
**ps
, int v
, int t
, int c
)
1502 s
= tcc_malloc(sizeof(Sym
));
1513 /* find a symbol and return its associated structure. 's' is the top
1514 of the symbol stack */
1515 static Sym
*sym_find2(Sym
*s
, int v
)
1525 /* structure lookup */
1526 static inline Sym
*struct_find(int v
)
1529 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1531 return table_ident
[v
]->sym_struct
;
1534 /* find an identifier */
1535 static inline Sym
*sym_find(int v
)
1538 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1540 return table_ident
[v
]->sym_identifier
;
1543 /* push a given symbol on the symbol stack */
1544 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
)
1553 s
= sym_push2(ps
, v
, type
->t
, c
);
1554 s
->type
.ref
= type
->ref
;
1556 /* don't record fields or anonymous symbols */
1558 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1559 /* record symbol in token array */
1560 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1562 ps
= &ts
->sym_struct
;
1564 ps
= &ts
->sym_identifier
;
1571 /* push a global identifier */
1572 static Sym
*global_identifier_push(int v
, int t
, int c
)
1575 s
= sym_push2(&global_stack
, v
, t
, c
);
1576 /* don't record anonymous symbol */
1577 if (v
< SYM_FIRST_ANOM
) {
1578 ps
= &table_ident
[v
- TOK_IDENT
]->sym_identifier
;
1579 /* modify the top most local identifier, so that
1580 sym_identifier will point to 's' when popped */
1582 ps
= &(*ps
)->prev_tok
;
1589 /* pop symbols until top reaches 'b' */
1590 static void sym_pop(Sym
**ptop
, Sym
*b
)
1600 /* remove symbol in token array */
1602 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1603 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1605 ps
= &ts
->sym_struct
;
1607 ps
= &ts
->sym_identifier
;
1618 BufferedFile
*tcc_open(TCCState
*s1
, const char *filename
)
1623 fd
= open(filename
, O_RDONLY
);
1626 bf
= tcc_malloc(sizeof(BufferedFile
));
1632 bf
->buf_ptr
= bf
->buffer
;
1633 bf
->buf_end
= bf
->buffer
;
1634 bf
->buffer
[0] = CH_EOB
; /* put eob symbol */
1635 pstrcpy(bf
->filename
, sizeof(bf
->filename
), filename
);
1637 bf
->ifndef_macro
= 0;
1638 bf
->ifdef_stack_ptr
= s1
->ifdef_stack_ptr
;
1639 // printf("opening '%s'\n", filename);
1643 void tcc_close(BufferedFile
*bf
)
1645 total_lines
+= bf
->line_num
;
1650 /* fill input buffer and peek next char */
1651 static int tcc_peekc_slow(BufferedFile
*bf
)
1654 /* only tries to read if really end of buffer */
1655 if (bf
->buf_ptr
>= bf
->buf_end
) {
1657 #if defined(PARSE_DEBUG)
1662 len
= read(bf
->fd
, bf
->buffer
, len
);
1669 bf
->buf_ptr
= bf
->buffer
;
1670 bf
->buf_end
= bf
->buffer
+ len
;
1671 *bf
->buf_end
= CH_EOB
;
1673 if (bf
->buf_ptr
< bf
->buf_end
) {
1674 return bf
->buf_ptr
[0];
1676 bf
->buf_ptr
= bf
->buf_end
;
1681 /* return the current character, handling end of block if necessary
1683 static int handle_eob(void)
1685 return tcc_peekc_slow(file
);
1688 /* read next char from current input file and handle end of input buffer */
1689 static inline void inp(void)
1691 ch
= *(++(file
->buf_ptr
));
1692 /* end of buffer/file handling */
1697 /* handle '\[\r]\n' */
1698 static void handle_stray(void)
1700 while (ch
== '\\') {
1705 } else if (ch
== '\r') {
1713 error("stray '\\' in program");
1718 /* skip the stray and handle the \\n case. Output an error if
1719 incorrect char after the stray */
1720 static int handle_stray1(uint8_t *p
)
1724 if (p
>= file
->buf_end
) {
1741 /* handle just the EOB case, but not stray */
1742 #define PEEKC_EOB(c, p)\
1753 /* handle the complicated stray case */
1754 #define PEEKC(c, p)\
1759 c = handle_stray1(p);\
1764 /* input with '\[\r]\n' handling. Note that this function cannot
1765 handle other characters after '\', so you cannot call it inside
1766 strings or comments */
1767 static void minp(void)
1775 /* single line C++ comments */
1776 static uint8_t *parse_line_comment(uint8_t *p
)
1783 if (c
== '\n' || c
== CH_EOF
) {
1785 } else if (c
== '\\') {
1790 } else if (c
== '\r') {
1805 static uint8_t *parse_comment(uint8_t *p
)
1811 /* fast skip loop */
1814 if (c
== '\n' || c
== '*' || c
== '\\')
1818 if (c
== '\n' || c
== '*' || c
== '\\')
1822 /* now we can handle all the cases */
1826 } else if (c
== '*') {
1832 } else if (c
== '/') {
1833 goto end_of_comment
;
1834 } else if (c
== '\\') {
1839 /* skip '\[\r]\n', otherwise just skip the stray */
1845 } else if (c
== '\r') {
1862 /* stray, eob or eof */
1867 error("unexpected end of file in comment");
1868 } else if (c
== '\\') {
1880 /* space exlcuding newline */
1881 static inline int is_space(int ch
)
1883 return ch
== ' ' || ch
== '\t' || ch
== '\v' || ch
== '\f' || ch
== '\r';
1886 static inline void skip_spaces(void)
1888 while (is_space(ch
))
1892 /* parse a string without interpreting escapes */
1893 static uint8_t *parse_pp_string(uint8_t *p
,
1894 int sep
, CString
*str
)
1902 } else if (c
== '\\') {
1907 unterminated_string
:
1908 /* XXX: indicate line number of start of string */
1909 error("missing terminating %c character", sep
);
1910 } else if (c
== '\\') {
1911 /* escape : just skip \[\r]\n */
1916 } else if (c
== '\r') {
1919 expect("'\n' after '\r'");
1922 } else if (c
== CH_EOF
) {
1923 goto unterminated_string
;
1926 cstr_ccat(str
, '\\');
1932 } else if (c
== '\n') {
1935 } else if (c
== '\r') {
1938 cstr_ccat(str
, '\r');
1954 /* skip block of text until #else, #elif or #endif. skip also pairs of
1956 void preprocess_skip(void)
1958 int a
, start_of_line
, c
;
1985 } else if (c
== '\\') {
1986 /* XXX: incorrect: should not give an error */
1987 ch
= file
->buf_ptr
[0];
1995 p
= parse_pp_string(p
, c
, NULL
);
2004 p
= parse_comment(p
);
2005 } else if (ch
== '/') {
2006 p
= parse_line_comment(p
);
2012 if (start_of_line
) {
2017 (tok
== TOK_ELSE
|| tok
== TOK_ELIF
|| tok
== TOK_ENDIF
))
2019 if (tok
== TOK_IF
|| tok
== TOK_IFDEF
|| tok
== TOK_IFNDEF
)
2021 else if (tok
== TOK_ENDIF
)
2035 /* ParseState handling */
2037 /* XXX: currently, no include file info is stored. Thus, we cannot display
2038 accurate messages if the function or data definition spans multiple
2041 /* save current parse state in 's' */
2042 void save_parse_state(ParseState
*s
)
2044 s
->line_num
= file
->line_num
;
2045 s
->macro_ptr
= macro_ptr
;
2050 /* restore parse state from 's' */
2051 void restore_parse_state(ParseState
*s
)
2053 file
->line_num
= s
->line_num
;
2054 macro_ptr
= s
->macro_ptr
;
2059 /* return the number of additional 'ints' necessary to store the
2061 static inline int tok_ext_size(int t
)
2080 return LDOUBLE_SIZE
/ 4;
2086 /* token string handling */
2088 static inline void tok_str_new(TokenString
*s
)
2092 s
->allocated_len
= 0;
2093 s
->last_line_num
= -1;
2096 static void tok_str_free(int *str
)
2105 /* NOTE: we test zero separately so that GCC can generate a
2106 table for the following switch */
2121 /* XXX: use a macro to be portable on 64 bit ? */
2122 cstr
= (CString
*)p
[1];
2133 p
+= 1 + (LDOUBLE_SIZE
/ 4);
2143 static int *tok_str_realloc(TokenString
*s
)
2147 len
= s
->allocated_len
+ TOK_STR_ALLOC_INCR
;
2148 str
= tcc_realloc(s
->str
, len
* sizeof(int));
2150 error("memory full");
2151 s
->allocated_len
= len
;
2156 static void tok_str_add(TokenString
*s
, int t
)
2162 if (len
>= s
->allocated_len
)
2163 str
= tok_str_realloc(s
);
2168 static void tok_str_add2(TokenString
*s
, int t
, CValue
*cv
)
2175 /* allocate space for worst case */
2176 if (len
+ TOK_MAX_SIZE
> s
->allocated_len
)
2177 str
= tok_str_realloc(s
);
2186 str
[len
++] = cv
->tab
[0];
2191 str
[len
++] = (int)cstr_dup(cv
->cstr
);
2196 str
[len
++] = cv
->tab
[0];
2197 str
[len
++] = cv
->tab
[1];
2200 #if LDOUBLE_SIZE == 12
2201 str
[len
++] = cv
->tab
[0];
2202 str
[len
++] = cv
->tab
[1];
2203 str
[len
++] = cv
->tab
[2];
2205 #error add long double size support
2214 /* add the current parse token in token string 's' */
2215 static void tok_str_add_tok(TokenString
*s
)
2219 /* save line number info */
2220 if (file
->line_num
!= s
->last_line_num
) {
2221 s
->last_line_num
= file
->line_num
;
2222 cval
.i
= s
->last_line_num
;
2223 tok_str_add2(s
, TOK_LINENUM
, &cval
);
2225 tok_str_add2(s
, tok
, &tokc
);
2228 #if LDOUBLE_SIZE == 12
2229 #define LDOUBLE_GET(p, cv) \
2234 #error add long double size support
2238 /* get a token from an integer array and increment pointer
2239 accordingly. we code it as a macro to avoid pointer aliasing. */
2240 #define TOK_GET(t, p, cv) \
2262 case TOK_CLDOUBLE: \
2263 LDOUBLE_GET(p, cv); \
2264 p += LDOUBLE_SIZE / 4; \
2271 /* defines handling */
2272 static inline void define_push(int v
, int macro_type
, int *str
, Sym
*first_arg
)
2276 s
= sym_push2(&define_stack
, v
, macro_type
, (int)str
);
2277 s
->next
= first_arg
;
2278 table_ident
[v
- TOK_IDENT
]->sym_define
= s
;
2281 /* undefined a define symbol. Its name is just set to zero */
2282 static void define_undef(Sym
*s
)
2286 if (v
>= TOK_IDENT
&& v
< tok_ident
)
2287 table_ident
[v
- TOK_IDENT
]->sym_define
= NULL
;
2291 static inline Sym
*define_find(int v
)
2294 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
2296 return table_ident
[v
]->sym_define
;
2299 /* free define stack until top reaches 'b' */
2300 static void free_defines(Sym
*b
)
2308 /* do not free args or predefined defines */
2310 tok_str_free((int *)top
->c
);
2312 if (v
>= TOK_IDENT
&& v
< tok_ident
)
2313 table_ident
[v
- TOK_IDENT
]->sym_define
= NULL
;
2321 static Sym
*label_find(int v
)
2324 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
2326 return table_ident
[v
]->sym_label
;
2329 static Sym
*label_push(Sym
**ptop
, int v
, int flags
)
2332 s
= sym_push2(ptop
, v
, 0, 0);
2334 ps
= &table_ident
[v
- TOK_IDENT
]->sym_label
;
2335 if (ptop
== &global_label_stack
) {
2336 /* modify the top most local identifier, so that
2337 sym_identifier will point to 's' when popped */
2339 ps
= &(*ps
)->prev_tok
;
2346 /* pop labels until element last is reached. Look if any labels are
2347 undefined. Define symbols if '&&label' was used. */
2348 static void label_pop(Sym
**ptop
, Sym
*slast
)
2351 for(s
= *ptop
; s
!= slast
; s
= s1
) {
2353 if (s
->r
== LABEL_DECLARED
) {
2354 warning("label '%s' declared but not used", get_tok_str(s
->v
, NULL
));
2355 } else if (s
->r
== LABEL_FORWARD
) {
2356 error("label '%s' used but not defined",
2357 get_tok_str(s
->v
, NULL
));
2360 /* define corresponding symbol. A size of
2362 put_extern_sym(s
, cur_text_section
, (long)s
->next
, 1);
2366 table_ident
[s
->v
- TOK_IDENT
]->sym_label
= s
->prev_tok
;
2372 /* eval an expression for #if/#elif */
2373 static int expr_preprocess(void)
2379 while (tok
!= TOK_LINEFEED
&& tok
!= TOK_EOF
) {
2380 next(); /* do macro subst */
2381 if (tok
== TOK_DEFINED
) {
2386 c
= define_find(tok
) != 0;
2391 } else if (tok
>= TOK_IDENT
) {
2392 /* if undefined macro */
2396 tok_str_add_tok(&str
);
2398 tok_str_add(&str
, -1); /* simulate end of file */
2399 tok_str_add(&str
, 0);
2400 /* now evaluate C constant expression */
2401 macro_ptr
= str
.str
;
2405 tok_str_free(str
.str
);
2409 #if defined(PARSE_DEBUG) || defined(PP_DEBUG)
2410 static void tok_print(int *str
)
2416 TOK_GET(t
, str
, cval
);
2419 printf(" %s", get_tok_str(t
, &cval
));
2425 /* parse after #define */
2426 static void parse_define(void)
2428 Sym
*s
, *first
, **ps
;
2429 int v
, t
, varg
, is_vaargs
, c
;
2434 error("invalid macro name '%s'", get_tok_str(tok
, &tokc
));
2435 /* XXX: should check if same macro (ANSI) */
2438 /* '(' must be just after macro definition for MACRO_FUNC */
2439 c
= file
->buf_ptr
[0];
2441 c
= handle_stray1(file
->buf_ptr
);
2446 while (tok
!= ')') {
2450 if (varg
== TOK_DOTS
) {
2451 varg
= TOK___VA_ARGS__
;
2453 } else if (tok
== TOK_DOTS
&& gnu_ext
) {
2457 if (varg
< TOK_IDENT
)
2458 error("badly punctuated parameter list");
2459 s
= sym_push2(&define_stack
, varg
| SYM_FIELD
, is_vaargs
, 0);
2470 /* EOF testing necessary for '-D' handling */
2471 while (tok
!= TOK_LINEFEED
&& tok
!= TOK_EOF
) {
2472 tok_str_add2(&str
, tok
, &tokc
);
2475 tok_str_add(&str
, 0);
2477 printf("define %s %d: ", get_tok_str(v
, NULL
), t
);
2480 define_push(v
, t
, str
.str
, first
);
2483 /* XXX: use a token or a hash table to accelerate matching ? */
2484 static CachedInclude
*search_cached_include(TCCState
*s1
,
2485 int type
, const char *filename
)
2490 for(i
= 0;i
< s1
->nb_cached_includes
; i
++) {
2491 e
= s1
->cached_includes
[i
];
2492 if (e
->type
== type
&& !strcmp(e
->filename
, filename
))
2498 static inline void add_cached_include(TCCState
*s1
, int type
,
2499 const char *filename
, int ifndef_macro
)
2503 if (search_cached_include(s1
, type
, filename
))
2506 printf("adding cached '%s' %s\n", filename
, get_tok_str(ifndef_macro
, NULL
));
2508 e
= tcc_malloc(sizeof(CachedInclude
) + strlen(filename
));
2512 strcpy(e
->filename
, filename
);
2513 e
->ifndef_macro
= ifndef_macro
;
2514 dynarray_add((void ***)&s1
->cached_includes
, &s1
->nb_cached_includes
, e
);
2517 /* is_bof is true if first non space token at beginning of file */
2518 static void preprocess(int is_bof
)
2520 TCCState
*s1
= tcc_state
;
2521 int size
, i
, c
, n
, saved_parse_flags
;
2522 char buf
[1024], *q
, *p
;
2528 saved_parse_flags
= parse_flags
;
2529 parse_flags
= PARSE_FLAG_PREPROCESS
| PARSE_FLAG_TOK_NUM
|
2530 PARSE_FLAG_LINEFEED
;
2540 s
= define_find(tok
);
2541 /* undefine symbol by putting an invalid name */
2546 ch
= file
->buf_ptr
[0];
2547 /* XXX: incorrect if comments : use next_nomacro with a special mode */
2552 } else if (ch
== '\"') {
2555 /* XXX: better stray handling */
2558 while (ch
!= c
&& ch
!= '\n' && ch
!= CH_EOF
) {
2559 if ((q
- buf
) < sizeof(buf
) - 1)
2566 /* eat all spaces and comments after include */
2567 /* XXX: slightly incorrect */
2568 while (ch1
!= '\n' && ch1
!= CH_EOF
)
2572 /* computed #include : either we have only strings or
2573 we have anything enclosed in '<>' */
2576 if (tok
== TOK_STR
) {
2577 while (tok
!= TOK_LINEFEED
) {
2578 if (tok
!= TOK_STR
) {
2580 error("'#include' expects \"FILENAME\" or <FILENAME>");
2582 pstrcat(buf
, sizeof(buf
), (char *)tokc
.cstr
->data
);
2588 while (tok
!= TOK_LINEFEED
) {
2589 pstrcat(buf
, sizeof(buf
), get_tok_str(tok
, &tokc
));
2593 /* check syntax and remove '<>' */
2594 if (len
< 2 || buf
[0] != '<' || buf
[len
- 1] != '>')
2595 goto include_syntax
;
2596 memmove(buf
, buf
+ 1, len
- 2);
2597 buf
[len
- 2] = '\0';
2602 e
= search_cached_include(s1
, c
, buf
);
2603 if (e
&& define_find(e
->ifndef_macro
)) {
2604 /* no need to parse the include because the 'ifndef macro'
2607 printf("%s: skipping %s\n", file
->filename
, buf
);
2611 /* first search in current dir if "header.h" */
2613 p
= strrchr(file
->filename
, '/');
2615 size
= p
+ 1 - file
->filename
;
2616 if (size
> sizeof(buf1
) - 1)
2617 size
= sizeof(buf1
) - 1;
2618 memcpy(buf1
, file
->filename
, size
);
2620 pstrcat(buf1
, sizeof(buf1
), buf
);
2621 f
= tcc_open(s1
, buf1
);
2625 if (s1
->include_stack_ptr
>= s1
->include_stack
+ INCLUDE_STACK_SIZE
)
2626 error("#include recursion too deep");
2627 /* now search in all the include paths */
2628 n
= s1
->nb_include_paths
+ s1
->nb_sysinclude_paths
;
2629 for(i
= 0; i
< n
; i
++) {
2631 if (i
< s1
->nb_include_paths
)
2632 path
= s1
->include_paths
[i
];
2634 path
= s1
->sysinclude_paths
[i
- s1
->nb_include_paths
];
2635 pstrcpy(buf1
, sizeof(buf1
), path
);
2636 pstrcat(buf1
, sizeof(buf1
), "/");
2637 pstrcat(buf1
, sizeof(buf1
), buf
);
2638 f
= tcc_open(s1
, buf1
);
2642 error("include file '%s' not found", buf
);
2646 printf("%s: including %s\n", file
->filename
, buf1
);
2649 pstrcpy(f
->inc_filename
, sizeof(f
->inc_filename
), buf
);
2650 /* push current file in stack */
2651 /* XXX: fix current line init */
2652 *s1
->include_stack_ptr
++ = file
;
2654 /* add include file debug info */
2656 put_stabs(file
->filename
, N_BINCL
, 0, 0, 0);
2658 tok_flags
|= TOK_FLAG_BOF
| TOK_FLAG_BOL
;
2659 ch
= file
->buf_ptr
[0];
2667 c
= expr_preprocess();
2673 if (tok
< TOK_IDENT
)
2674 error("invalid argument for '#if%sdef'", c
? "n" : "");
2678 printf("#ifndef %s\n", get_tok_str(tok
, NULL
));
2680 file
->ifndef_macro
= tok
;
2683 c
= (define_find(tok
) != 0) ^ c
;
2685 if (s1
->ifdef_stack_ptr
>= s1
->ifdef_stack
+ IFDEF_STACK_SIZE
)
2686 error("memory full");
2687 *s1
->ifdef_stack_ptr
++ = c
;
2690 if (s1
->ifdef_stack_ptr
== s1
->ifdef_stack
)
2691 error("#else without matching #if");
2692 if (s1
->ifdef_stack_ptr
[-1] & 2)
2693 error("#else after #else");
2694 c
= (s1
->ifdef_stack_ptr
[-1] ^= 3);
2697 if (s1
->ifdef_stack_ptr
== s1
->ifdef_stack
)
2698 error("#elif without matching #if");
2699 c
= s1
->ifdef_stack_ptr
[-1];
2701 error("#elif after #else");
2702 /* last #if/#elif expression was true: we skip */
2705 c
= expr_preprocess();
2706 s1
->ifdef_stack_ptr
[-1] = c
;
2716 if (s1
->ifdef_stack_ptr
<= file
->ifdef_stack_ptr
)
2717 error("#endif without matching #if");
2718 s1
->ifdef_stack_ptr
--;
2719 /* '#ifndef macro' was at the start of file. Now we check if
2720 an '#endif' is exactly at the end of file */
2721 if (file
->ifndef_macro
&&
2722 s1
->ifdef_stack_ptr
== file
->ifdef_stack_ptr
) {
2723 file
->ifndef_macro_saved
= file
->ifndef_macro
;
2724 /* need to set to zero to avoid false matches if another
2725 #ifndef at middle of file */
2726 file
->ifndef_macro
= 0;
2727 while (tok
!= TOK_LINEFEED
)
2729 tok_flags
|= TOK_FLAG_ENDIF
;
2735 if (tok
!= TOK_CINT
)
2737 file
->line_num
= tokc
.i
- 1; /* the line number will be incremented after */
2739 if (tok
!= TOK_LINEFEED
) {
2742 pstrcpy(file
->filename
, sizeof(file
->filename
),
2743 (char *)tokc
.cstr
->data
);
2749 ch
= file
->buf_ptr
[0];
2752 while (ch
!= '\n' && ch
!= CH_EOF
) {
2753 if ((q
- buf
) < sizeof(buf
) - 1)
2759 error("#error %s", buf
);
2761 warning("#warning %s", buf
);
2767 if (tok
== TOK_LINEFEED
|| tok
== '!' || tok
== TOK_CINT
) {
2768 /* '!' is ignored to allow C scripts. numbers are ignored
2769 to emulate cpp behaviour */
2771 error("invalid preprocessing directive #%s", get_tok_str(tok
, &tokc
));
2775 /* ignore other preprocess commands or #! for C scripts */
2776 while (tok
!= TOK_LINEFEED
)
2779 parse_flags
= saved_parse_flags
;
2782 /* evaluate escape codes in a string. */
2783 static void parse_escape_string(CString
*outstr
, const uint8_t *buf
, int is_long
)
2798 case '0': case '1': case '2': case '3':
2799 case '4': case '5': case '6': case '7':
2800 /* at most three octal digits */
2805 n
= n
* 8 + c
- '0';
2809 n
= n
* 8 + c
- '0';
2814 goto add_char_nonext
;
2820 if (c
>= 'a' && c
<= 'f')
2822 else if (c
>= 'A' && c
<= 'F')
2832 goto add_char_nonext
;
2856 goto invalid_escape
;
2866 error("invalid escaped char");
2872 cstr_ccat(outstr
, c
);
2874 cstr_wccat(outstr
, c
);
2876 /* add a trailing '\0' */
2878 cstr_ccat(outstr
, '\0');
2880 cstr_wccat(outstr
, '\0');
2883 /* we use 64 bit numbers */
2886 /* bn = (bn << shift) | or_val */
2887 void bn_lshift(unsigned int *bn
, int shift
, int or_val
)
2891 for(i
=0;i
<BN_SIZE
;i
++) {
2893 bn
[i
] = (v
<< shift
) | or_val
;
2894 or_val
= v
>> (32 - shift
);
2898 void bn_zero(unsigned int *bn
)
2901 for(i
=0;i
<BN_SIZE
;i
++) {
2906 /* parse number in null terminated string 'p' and return it in the
2908 void parse_number(const char *p
)
2910 int b
, t
, shift
, frac_bits
, s
, exp_val
, ch
;
2912 unsigned int bn
[BN_SIZE
];
2923 goto float_frac_parse
;
2924 } else if (t
== '0') {
2925 if (ch
== 'x' || ch
== 'X') {
2929 } else if (tcc_ext
&& (ch
== 'b' || ch
== 'B')) {
2935 /* parse all digits. cannot check octal numbers at this stage
2936 because of floating point constants */
2938 if (ch
>= 'a' && ch
<= 'f')
2940 else if (ch
>= 'A' && ch
<= 'F')
2948 if (q
>= token_buf
+ STRING_MAX_SIZE
) {
2950 error("number too long");
2956 ((ch
== 'e' || ch
== 'E') && b
== 10) ||
2957 ((ch
== 'p' || ch
== 'P') && (b
== 16 || b
== 2))) {
2959 /* NOTE: strtox should support that for hexa numbers, but
2960 non ISOC99 libcs do not support it, so we prefer to do
2962 /* hexadecimal or binary floats */
2963 /* XXX: handle overflows */
2975 } else if (t
>= 'a') {
2977 } else if (t
>= 'A') {
2982 bn_lshift(bn
, shift
, t
);
2989 if (t
>= 'a' && t
<= 'f') {
2991 } else if (t
>= 'A' && t
<= 'F') {
2993 } else if (t
>= '0' && t
<= '9') {
2999 error("invalid digit");
3000 bn_lshift(bn
, shift
, t
);
3005 if (ch
!= 'p' && ch
!= 'P')
3012 } else if (ch
== '-') {
3016 if (ch
< '0' || ch
> '9')
3017 expect("exponent digits");
3018 while (ch
>= '0' && ch
<= '9') {
3019 exp_val
= exp_val
* 10 + ch
- '0';
3022 exp_val
= exp_val
* s
;
3024 /* now we can generate the number */
3025 /* XXX: should patch directly float number */
3026 d
= (double)bn
[1] * 4294967296.0 + (double)bn
[0];
3027 d
= ldexp(d
, exp_val
- frac_bits
);
3032 /* float : should handle overflow */
3034 } else if (t
== 'L') {
3037 /* XXX: not large enough */
3038 tokc
.ld
= (long double)d
;
3044 /* decimal floats */
3046 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3051 while (ch
>= '0' && ch
<= '9') {
3052 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3058 if (ch
== 'e' || ch
== 'E') {
3059 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3063 if (ch
== '-' || ch
== '+') {
3064 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3069 if (ch
< '0' || ch
> '9')
3070 expect("exponent digits");
3071 while (ch
>= '0' && ch
<= '9') {
3072 if (q
>= token_buf
+ STRING_MAX_SIZE
)
3084 tokc
.f
= strtof(token_buf
, NULL
);
3085 } else if (t
== 'L') {
3088 tokc
.ld
= strtold(token_buf
, NULL
);
3091 tokc
.d
= strtod(token_buf
, NULL
);
3095 unsigned long long n
, n1
;
3098 /* integer number */
3101 if (b
== 10 && *q
== '0') {
3108 /* no need for checks except for base 10 / 8 errors */
3111 } else if (t
>= 'a') {
3113 } else if (t
>= 'A') {
3118 error("invalid digit");
3122 /* detect overflow */
3123 /* XXX: this test is not reliable */
3125 error("integer constant overflow");
3128 /* XXX: not exactly ANSI compliant */
3129 if ((n
& 0xffffffff00000000LL
) != 0) {
3134 } else if (n
> 0x7fffffff) {
3145 error("three 'l's in integer constant");
3148 if (tok
== TOK_CINT
)
3150 else if (tok
== TOK_CUINT
)
3154 } else if (t
== 'U') {
3156 error("two 'u's in integer constant");
3158 if (tok
== TOK_CINT
)
3160 else if (tok
== TOK_CLLONG
)
3167 if (tok
== TOK_CINT
|| tok
== TOK_CUINT
)
3175 #define PARSE2(c1, tok1, c2, tok2) \
3186 /* return next token without macro substitution */
3187 static inline void next_nomacro1(void)
3207 /* first look if it is in fact an end of buffer */
3208 if (p
>= file
->buf_end
) {
3212 if (p
>= file
->buf_end
)
3225 TCCState
*s1
= tcc_state
;
3226 if (parse_flags
& PARSE_FLAG_LINEFEED
) {
3228 } else if (s1
->include_stack_ptr
== s1
->include_stack
||
3229 !(parse_flags
& PARSE_FLAG_PREPROCESS
)) {
3230 /* no include left : end of file. */
3233 /* pop include file */
3235 /* test if previous '#endif' was after a #ifdef at
3237 if (tok_flags
& TOK_FLAG_ENDIF
) {
3239 printf("#endif %s\n", get_tok_str(file
->ifndef_macro_saved
, NULL
));
3241 add_cached_include(s1
, file
->inc_type
, file
->inc_filename
,
3242 file
->ifndef_macro_saved
);
3245 /* add end of include file debug info */
3247 put_stabd(N_EINCL
, 0, 0);
3249 /* pop include stack */
3251 s1
->include_stack_ptr
--;
3252 file
= *s1
->include_stack_ptr
;
3260 if (parse_flags
& PARSE_FLAG_LINEFEED
) {
3264 tok_flags
|= TOK_FLAG_BOL
;
3273 if ((tok_flags
& TOK_FLAG_BOL
) &&
3274 (parse_flags
& PARSE_FLAG_PREPROCESS
)) {
3276 preprocess(tok_flags
& TOK_FLAG_BOF
);
3282 tok
= TOK_TWOSHARPS
;
3289 case 'a': case 'b': case 'c': case 'd':
3290 case 'e': case 'f': case 'g': case 'h':
3291 case 'i': case 'j': case 'k': case 'l':
3292 case 'm': case 'n': case 'o': case 'p':
3293 case 'q': case 'r': case 's': case 't':
3294 case 'u': case 'v': case 'w': case 'x':
3296 case 'A': case 'B': case 'C': case 'D':
3297 case 'E': case 'F': case 'G': case 'H':
3298 case 'I': case 'J': case 'K':
3299 case 'M': case 'N': case 'O': case 'P':
3300 case 'Q': case 'R': case 'S': case 'T':
3301 case 'U': case 'V': case 'W': case 'X':
3307 h
= TOK_HASH_FUNC(h
, c
);
3311 if (!isidnum_table
[c
])
3313 h
= TOK_HASH_FUNC(h
, c
);
3320 /* fast case : no stray found, so we have the full token
3321 and we have already hashed it */
3323 h
&= (TOK_HASH_SIZE
- 1);
3324 pts
= &hash_ident
[h
];
3329 if (ts
->len
== len
&& !memcmp(ts
->str
, p1
, len
))
3331 pts
= &(ts
->hash_next
);
3333 ts
= tok_alloc_new(pts
, p1
, len
);
3337 cstr_reset(&tokcstr
);
3340 cstr_ccat(&tokcstr
, *p1
);
3346 while (isidnum_table
[c
]) {
3347 cstr_ccat(&tokcstr
, c
);
3350 ts
= tok_alloc(tokcstr
.data
, tokcstr
.size
);
3356 if (t
!= '\\' && t
!= '\'' && t
!= '\"') {
3358 goto parse_ident_fast
;
3361 if (c
== '\'' || c
== '\"') {
3365 cstr_reset(&tokcstr
);
3366 cstr_ccat(&tokcstr
, 'L');
3367 goto parse_ident_slow
;
3371 case '0': case '1': case '2': case '3':
3372 case '4': case '5': case '6': case '7':
3375 cstr_reset(&tokcstr
);
3376 /* after the first digit, accept digits, alpha, '.' or sign if
3377 prefixed by 'eEpP' */
3381 cstr_ccat(&tokcstr
, c
);
3383 if (!(isnum(c
) || isid(c
) || c
== '.' ||
3384 ((c
== '+' || c
== '-') &&
3385 (t
== 'e' || t
== 'E' || t
== 'p' || t
== 'P'))))
3388 /* We add a trailing '\0' to ease parsing */
3389 cstr_ccat(&tokcstr
, '\0');
3390 tokc
.cstr
= &tokcstr
;
3394 /* special dot handling because it can also start a number */
3397 cstr_reset(&tokcstr
);
3398 cstr_ccat(&tokcstr
, '.');
3400 } else if (c
== '.') {
3420 /* parse the string */
3422 p
= parse_pp_string(p
, sep
, &str
);
3423 cstr_ccat(&str
, '\0');
3425 /* eval the escape (should be done as TOK_PPNUM) */
3426 cstr_reset(&tokcstr
);
3427 parse_escape_string(&tokcstr
, str
.data
, is_long
);
3432 /* XXX: make it portable */
3436 char_size
= sizeof(int);
3437 if (tokcstr
.size
<= char_size
)
3438 error("empty character constant");
3439 if (tokcstr
.size
> 2 * char_size
)
3440 warning("multi-character character constant");
3442 tokc
.i
= *(int8_t *)tokcstr
.data
;
3445 tokc
.i
= *(int *)tokcstr
.data
;
3449 tokc
.cstr
= &tokcstr
;
3463 } else if (c
== '<') {
3481 } else if (c
== '>') {
3499 } else if (c
== '=') {
3512 } else if (c
== '=') {
3525 } else if (c
== '=') {
3538 } else if (c
== '=') {
3541 } else if (c
== '>') {
3549 PARSE2('!', '!', '=', TOK_NE
)
3550 PARSE2('=', '=', '=', TOK_EQ
)
3551 PARSE2('*', '*', '=', TOK_A_MUL
)
3552 PARSE2('%', '%', '=', TOK_A_MOD
)
3553 PARSE2('^', '^', '=', TOK_A_XOR
)
3555 /* comments or operator */
3559 p
= parse_comment(p
);
3561 } else if (c
== '/') {
3562 p
= parse_line_comment(p
);
3564 } else if (c
== '=') {
3584 case '$': /* only used in assembler */
3589 error("unrecognized character \\x%02x", c
);
3594 #if defined(PARSE_DEBUG)
3595 printf("token = %s\n", get_tok_str(tok
, &tokc
));
3599 /* return next token without macro substitution. Can read input from
3601 static void next_nomacro(void)
3607 TOK_GET(tok
, macro_ptr
, tokc
);
3608 if (tok
== TOK_LINENUM
) {
3609 file
->line_num
= tokc
.i
;
3618 /* substitute args in macro_str and return allocated string */
3619 static int *macro_arg_subst(Sym
**nested_list
, int *macro_str
, Sym
*args
)
3621 int *st
, last_tok
, t
, notfirst
;
3630 TOK_GET(t
, macro_str
, cval
);
3635 TOK_GET(t
, macro_str
, cval
);
3638 s
= sym_find2(args
, t
);
3645 cstr_ccat(&cstr
, ' ');
3646 TOK_GET(t
, st
, cval
);
3647 cstr_cat(&cstr
, get_tok_str(t
, &cval
));
3650 cstr_ccat(&cstr
, '\0');
3652 printf("stringize: %s\n", (char *)cstr
.data
);
3656 tok_str_add2(&str
, TOK_STR
, &cval
);
3659 tok_str_add2(&str
, t
, &cval
);
3661 } else if (t
>= TOK_IDENT
) {
3662 s
= sym_find2(args
, t
);
3665 /* if '##' is present before or after, no arg substitution */
3666 if (*macro_str
== TOK_TWOSHARPS
|| last_tok
== TOK_TWOSHARPS
) {
3667 /* special case for var arg macros : ## eats the
3668 ',' if empty VA_ARGS variable. */
3669 /* XXX: test of the ',' is not 100%
3670 reliable. should fix it to avoid security
3672 if (gnu_ext
&& s
->type
.t
&&
3673 last_tok
== TOK_TWOSHARPS
&&
3674 str
.len
>= 2 && str
.str
[str
.len
- 2] == ',') {
3676 /* suppress ',' '##' */
3679 /* suppress '##' and add variable */
3687 TOK_GET(t1
, st
, cval
);
3690 tok_str_add2(&str
, t1
, &cval
);
3694 macro_subst(&str
, nested_list
, st
);
3697 tok_str_add(&str
, t
);
3700 tok_str_add2(&str
, t
, &cval
);
3704 tok_str_add(&str
, 0);
3708 static char const ab_month_name
[12][4] =
3710 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
3711 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
3714 /* do macro substitution of current token with macro 's' and add
3715 result to (tok_str,tok_len). 'nested_list' is the list of all
3716 macros we got inside to avoid recursing. Return non zero if no
3717 substitution needs to be done */
3718 static int macro_subst_tok(TokenString
*tok_str
,
3719 Sym
**nested_list
, Sym
*s
)
3721 Sym
*args
, *sa
, *sa1
;
3722 int mstr_allocated
, parlevel
, *mstr
, t
;
3728 /* if symbol is a macro, prepare substitution */
3730 /* special macros */
3731 if (tok
== TOK___LINE__
) {
3732 cval
.i
= file
->line_num
;
3733 tok_str_add2(tok_str
, TOK_CINT
, &cval
);
3734 } else if (tok
== TOK___FILE__
) {
3735 cstrval
= file
->filename
;
3737 tok_str_add2(tok_str
, TOK_STR
, &cval
);
3738 } else if (tok
== TOK___DATE__
|| tok
== TOK___TIME__
) {
3744 tm
= localtime(&ti
);
3745 if (tok
== TOK___DATE__
) {
3746 snprintf(buf
, sizeof(buf
), "%s %2d %d",
3747 ab_month_name
[tm
->tm_mon
], tm
->tm_mday
, tm
->tm_year
+ 1900);
3749 snprintf(buf
, sizeof(buf
), "%02d:%02d:%02d",
3750 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
3755 cstr_cat(&cstr
, cstrval
);
3756 cstr_ccat(&cstr
, '\0');
3758 tok_str_add2(tok_str
, TOK_STR
, &cval
);
3763 if (s
->type
.t
== MACRO_FUNC
) {
3764 /* NOTE: we do not use next_nomacro to avoid eating the
3765 next token. XXX: find better solution */
3769 /* end of macro stream: we must look at the token
3770 after in the file */
3776 /* XXX: incorrect with comments */
3777 ch
= file
->buf_ptr
[0];
3778 while (is_space(ch
) || ch
== '\n')
3782 if (t
!= '(') /* no macro subst */
3785 /* argument macro */
3790 /* NOTE: empty args are allowed, except if no args */
3792 /* handle '()' case */
3793 if (!args
&& tok
== ')')
3796 error("macro '%s' used with too many args",
3797 get_tok_str(s
->v
, 0));
3800 /* NOTE: non zero sa->t indicates VA_ARGS */
3801 while ((parlevel
> 0 ||
3803 (tok
!= ',' || sa
->type
.t
))) &&
3807 else if (tok
== ')')
3809 tok_str_add2(&str
, tok
, &tokc
);
3812 tok_str_add(&str
, 0);
3813 sym_push2(&args
, sa
->v
& ~SYM_FIELD
, sa
->type
.t
, (int)str
.str
);
3816 /* special case for gcc var args: add an empty
3817 var arg argument if it is omitted */
3818 if (sa
&& sa
->type
.t
&& gnu_ext
)
3828 error("macro '%s' used with too few args",
3829 get_tok_str(s
->v
, 0));
3832 /* now subst each arg */
3833 mstr
= macro_arg_subst(nested_list
, mstr
, args
);
3838 tok_str_free((int *)sa
->c
);
3844 sym_push2(nested_list
, s
->v
, 0, 0);
3845 macro_subst(tok_str
, nested_list
, mstr
);
3846 /* pop nested defined symbol */
3848 *nested_list
= sa1
->prev
;
3856 /* handle the '##' operator. Return NULL if no '##' seen. Otherwise
3857 return the resulting string (which must be freed). */
3858 static inline int *macro_twosharps(const int *macro_str
)
3861 const int *macro_ptr1
, *start_macro_ptr
, *ptr
, *saved_macro_ptr
;
3863 const char *p1
, *p2
;
3865 TokenString macro_str1
;
3868 start_macro_ptr
= macro_str
;
3869 /* we search the first '##' */
3871 macro_ptr1
= macro_str
;
3872 TOK_GET(t
, macro_str
, cval
);
3873 /* nothing more to do if end of string */
3876 if (*macro_str
== TOK_TWOSHARPS
)
3880 /* we saw '##', so we need more processing to handle it */
3882 tok_str_new(¯o_str1
);
3886 /* add all tokens seen so far */
3887 for(ptr
= start_macro_ptr
; ptr
< macro_ptr1
;) {
3888 TOK_GET(t
, ptr
, cval
);
3889 tok_str_add2(¯o_str1
, t
, &cval
);
3891 saved_macro_ptr
= macro_ptr
;
3892 /* XXX: get rid of the use of macro_ptr here */
3893 macro_ptr
= (int *)macro_str
;
3895 while (*macro_ptr
== TOK_TWOSHARPS
) {
3897 macro_ptr1
= macro_ptr
;
3900 TOK_GET(t
, macro_ptr
, cval
);
3901 /* We concatenate the two tokens if we have an
3902 identifier or a preprocessing number */
3904 p1
= get_tok_str(tok
, &tokc
);
3905 cstr_cat(&cstr
, p1
);
3906 p2
= get_tok_str(t
, &cval
);
3907 cstr_cat(&cstr
, p2
);
3908 cstr_ccat(&cstr
, '\0');
3910 if ((tok
>= TOK_IDENT
|| tok
== TOK_PPNUM
) &&
3911 (t
>= TOK_IDENT
|| t
== TOK_PPNUM
)) {
3912 if (tok
== TOK_PPNUM
) {
3913 /* if number, then create a number token */
3914 /* NOTE: no need to allocate because
3915 tok_str_add2() does it */
3918 /* if identifier, we must do a test to
3919 validate we have a correct identifier */
3920 if (t
== TOK_PPNUM
) {
3930 if (!isnum(c
) && !isid(c
))
3934 ts
= tok_alloc(cstr
.data
, strlen(cstr
.data
));
3935 tok
= ts
->tok
; /* modify current token */
3938 const char *str
= cstr
.data
;
3939 const unsigned char *q
;
3941 /* we look for a valid token */
3942 /* XXX: do more extensive checks */
3943 if (!strcmp(str
, ">>=")) {
3945 } else if (!strcmp(str
, "<<=")) {
3947 } else if (strlen(str
) == 2) {
3948 /* search in two bytes table */
3953 if (q
[0] == str
[0] && q
[1] == str
[1])
3960 /* NOTE: because get_tok_str use a static buffer,
3963 p1
= get_tok_str(tok
, &tokc
);
3964 cstr_cat(&cstr
, p1
);
3965 cstr_ccat(&cstr
, '\0');
3966 p2
= get_tok_str(t
, &cval
);
3967 warning("pasting \"%s\" and \"%s\" does not give a valid preprocessing token", cstr
.data
, p2
);
3968 /* cannot merge tokens: just add them separately */
3969 tok_str_add2(¯o_str1
, tok
, &tokc
);
3970 /* XXX: free associated memory ? */
3977 tok_str_add2(¯o_str1
, tok
, &tokc
);
3982 macro_ptr
= (int *)saved_macro_ptr
;
3984 tok_str_add(¯o_str1
, 0);
3985 return macro_str1
.str
;
3989 /* do macro substitution of macro_str and add result to
3990 (tok_str,tok_len). 'nested_list' is the list of all macros we got
3991 inside to avoid recursing. */
3992 static void macro_subst(TokenString
*tok_str
,
3993 Sym
**nested_list
, const int *macro_str
)
3996 int *saved_macro_ptr
, *macro_str1
;
4001 /* first scan for '##' operator handling */
4003 macro_str1
= macro_twosharps(ptr
);
4007 /* NOTE: ptr == NULL can only happen if tokens are read from
4008 file stream due to a macro function call */
4011 TOK_GET(t
, ptr
, cval
);
4016 /* if nested substitution, do nothing */
4017 if (sym_find2(*nested_list
, t
))
4019 saved_macro_ptr
= macro_ptr
;
4020 macro_ptr
= (int *)ptr
;
4022 ret
= macro_subst_tok(tok_str
, nested_list
, s
);
4023 ptr
= (int *)macro_ptr
;
4024 macro_ptr
= saved_macro_ptr
;
4029 tok_str_add2(tok_str
, t
, &cval
);
4033 tok_str_free(macro_str1
);
4036 /* return next token with macro substitution */
4037 static void next(void)
4039 Sym
*nested_list
, *s
;
4045 /* if not reading from macro substituted string, then try
4046 to substitute macros */
4047 if (tok
>= TOK_IDENT
&&
4048 (parse_flags
& PARSE_FLAG_PREPROCESS
)) {
4049 s
= define_find(tok
);
4051 /* we have a macro: we try to substitute */
4054 if (macro_subst_tok(&str
, &nested_list
, s
) == 0) {
4055 /* substitution done, NOTE: maybe empty */
4056 tok_str_add(&str
, 0);
4057 macro_ptr
= str
.str
;
4058 macro_ptr_allocated
= str
.str
;
4065 /* end of macro or end of unget buffer */
4066 if (unget_buffer_enabled
) {
4067 macro_ptr
= unget_saved_macro_ptr
;
4068 unget_buffer_enabled
= 0;
4070 /* end of macro string: free it */
4071 tok_str_free(macro_ptr_allocated
);
4078 /* convert preprocessor tokens into C tokens */
4079 if (tok
== TOK_PPNUM
&&
4080 (parse_flags
& PARSE_FLAG_TOK_NUM
)) {
4081 parse_number((char *)tokc
.cstr
->data
);
4085 /* push back current token and set current token to 'last_tok'. Only
4086 identifier case handled for labels. */
4087 static inline void unget_tok(int last_tok
)
4091 unget_saved_macro_ptr
= macro_ptr
;
4092 unget_buffer_enabled
= 1;
4093 q
= unget_saved_buffer
;
4096 n
= tok_ext_size(tok
) - 1;
4099 *q
= 0; /* end of token string */
4104 void swap(int *p
, int *q
)
4112 void vsetc(CType
*type
, int r
, CValue
*vc
)
4116 if (vtop
>= vstack
+ VSTACK_SIZE
)
4117 error("memory full");
4118 /* cannot let cpu flags if other instruction are generated. Also
4119 avoid leaving VT_JMP anywhere except on the top of the stack
4120 because it would complicate the code generator. */
4121 if (vtop
>= vstack
) {
4122 v
= vtop
->r
& VT_VALMASK
;
4123 if (v
== VT_CMP
|| (v
& ~1) == VT_JMP
)
4129 vtop
->r2
= VT_CONST
;
4133 /* push integer constant */
4138 vsetc(&int_type
, VT_CONST
, &cval
);
4141 /* Return a static symbol pointing to a section */
4142 static Sym
*get_sym_ref(CType
*type
, Section
*sec
,
4143 unsigned long offset
, unsigned long size
)
4149 sym
= global_identifier_push(v
, type
->t
| VT_STATIC
, 0);
4150 sym
->type
.ref
= type
->ref
;
4151 sym
->r
= VT_CONST
| VT_SYM
;
4152 put_extern_sym(sym
, sec
, offset
, size
);
4156 /* push a reference to a section offset by adding a dummy symbol */
4157 static void vpush_ref(CType
*type
, Section
*sec
, unsigned long offset
, unsigned long size
)
4162 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
4163 vtop
->sym
= get_sym_ref(type
, sec
, offset
, size
);
4166 /* define a new external reference to a symbol 'v' of type 'u' */
4167 static Sym
*external_global_sym(int v
, CType
*type
, int r
)
4173 /* push forward reference */
4174 s
= global_identifier_push(v
, type
->t
| VT_EXTERN
, 0);
4175 s
->type
.ref
= type
->ref
;
4176 s
->r
= r
| VT_CONST
| VT_SYM
;
4181 /* define a new external reference to a symbol 'v' of type 'u' */
4182 static Sym
*external_sym(int v
, CType
*type
, int r
)
4188 /* push forward reference */
4189 s
= sym_push(v
, type
, r
| VT_CONST
| VT_SYM
, 0);
4190 s
->type
.t
|= VT_EXTERN
;
4192 if (!is_compatible_types(&s
->type
, type
))
4193 error("incompatible types for redefinition of '%s'",
4194 get_tok_str(v
, NULL
));
4199 /* push a reference to global symbol v */
4200 static void vpush_global_sym(CType
*type
, int v
)
4205 sym
= external_global_sym(v
, type
, 0);
4207 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
4211 void vset(CType
*type
, int r
, int v
)
4216 vsetc(type
, r
, &cval
);
4219 void vseti(int r
, int v
)
4235 void vpushv(SValue
*v
)
4237 if (vtop
>= vstack
+ VSTACK_SIZE
)
4238 error("memory full");
4248 /* save r to the memory stack, and mark it as being free */
4249 void save_reg(int r
)
4251 int l
, saved
, size
, align
;
4255 /* modify all stack values */
4258 for(p
=vstack
;p
<=vtop
;p
++) {
4259 if ((p
->r
& VT_VALMASK
) == r
||
4260 (p
->r2
& VT_VALMASK
) == r
) {
4261 /* must save value on stack if not already done */
4263 /* NOTE: must reload 'r' because r might be equal to r2 */
4264 r
= p
->r
& VT_VALMASK
;
4265 /* store register in the stack */
4267 if ((p
->r
& VT_LVAL
) ||
4268 (!is_float(type
->t
) && (type
->t
& VT_BTYPE
) != VT_LLONG
))
4270 size
= type_size(type
, &align
);
4271 loc
= (loc
- size
) & -align
;
4272 sv
.type
.t
= type
->t
;
4273 sv
.r
= VT_LOCAL
| VT_LVAL
;
4276 #ifdef TCC_TARGET_I386
4277 /* x86 specific: need to pop fp register ST0 if saved */
4278 if (r
== TREG_ST0
) {
4279 o(0xd9dd); /* fstp %st(1) */
4282 /* special long long case */
4283 if ((type
->t
& VT_BTYPE
) == VT_LLONG
) {
4290 /* mark that stack entry as being saved on the stack */
4291 if (p
->r
& VT_LVAL
) {
4292 /* also clear the bounded flag because the
4293 relocation address of the function was stored in
4295 p
->r
= (p
->r
& ~(VT_VALMASK
| VT_BOUNDED
)) | VT_LLOCAL
;
4297 p
->r
= lvalue_type(p
->type
.t
) | VT_LOCAL
;
4305 /* find a free register of class 'rc'. If none, save one register */
4311 /* find a free register */
4312 for(r
=0;r
<NB_REGS
;r
++) {
4313 if (reg_classes
[r
] & rc
) {
4314 for(p
=vstack
;p
<=vtop
;p
++) {
4315 if ((p
->r
& VT_VALMASK
) == r
||
4316 (p
->r2
& VT_VALMASK
) == r
)
4324 /* no register left : free the first one on the stack (VERY
4325 IMPORTANT to start from the bottom to ensure that we don't
4326 spill registers used in gen_opi()) */
4327 for(p
=vstack
;p
<=vtop
;p
++) {
4328 r
= p
->r
& VT_VALMASK
;
4329 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
))
4331 /* also look at second register (if long long) */
4332 r
= p
->r2
& VT_VALMASK
;
4333 if (r
< VT_CONST
&& (reg_classes
[r
] & rc
)) {
4339 /* Should never comes here */
4343 /* save registers up to (vtop - n) stack entry */
4344 void save_regs(int n
)
4349 for(p
= vstack
;p
<= p1
; p
++) {
4350 r
= p
->r
& VT_VALMASK
;
4357 /* move register 's' to 'r', and flush previous value of r to memory
4359 void move_reg(int r
, int s
)
4372 /* get address of vtop (vtop MUST BE an lvalue) */
4375 vtop
->r
&= ~VT_LVAL
;
4376 /* tricky: if saved lvalue, then we can go back to lvalue */
4377 if ((vtop
->r
& VT_VALMASK
) == VT_LLOCAL
)
4378 vtop
->r
= (vtop
->r
& ~(VT_VALMASK
| VT_LVAL_TYPE
)) | VT_LOCAL
| VT_LVAL
;
4381 #ifdef CONFIG_TCC_BCHECK
4382 /* generate lvalue bound code */
4388 vtop
->r
&= ~VT_MUSTBOUND
;
4389 /* if lvalue, then use checking code before dereferencing */
4390 if (vtop
->r
& VT_LVAL
) {
4391 /* if not VT_BOUNDED value, then make one */
4392 if (!(vtop
->r
& VT_BOUNDED
)) {
4393 lval_type
= vtop
->r
& (VT_LVAL_TYPE
| VT_LVAL
);
4394 /* must save type because we must set it to int to get pointer */
4396 vtop
->type
.t
= VT_INT
;
4399 gen_bounded_ptr_add();
4400 vtop
->r
|= lval_type
;
4403 /* then check for dereferencing */
4404 gen_bounded_ptr_deref();
4409 /* store vtop a register belonging to class 'rc'. lvalues are
4410 converted to values. Cannot be used if cannot be converted to
4411 register value (such as structures). */
4414 int r
, r2
, rc2
, bit_pos
, bit_size
, size
, align
, i
;
4415 unsigned long long ll
;
4417 /* NOTE: get_reg can modify vstack[] */
4418 if (vtop
->type
.t
& VT_BITFIELD
) {
4419 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
4420 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
4421 /* remove bit field info to avoid loops */
4422 vtop
->type
.t
&= ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
4423 /* generate shifts */
4424 vpushi(32 - (bit_pos
+ bit_size
));
4426 vpushi(32 - bit_size
);
4427 /* NOTE: transformed to SHR if unsigned */
4431 if (is_float(vtop
->type
.t
) &&
4432 (vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
4435 unsigned long offset
;
4437 /* XXX: unify with initializers handling ? */
4438 /* CPUs usually cannot use float constants, so we store them
4439 generically in data segment */
4440 size
= type_size(&vtop
->type
, &align
);
4441 offset
= (data_section
->data_offset
+ align
- 1) & -align
;
4442 data_section
->data_offset
= offset
;
4443 /* XXX: not portable yet */
4444 ptr
= section_ptr_add(data_section
, size
);
4447 ptr
[i
] = vtop
->c
.tab
[i
];
4448 sym
= get_sym_ref(&vtop
->type
, data_section
, offset
, size
<< 2);
4449 vtop
->r
|= VT_LVAL
| VT_SYM
;
4453 #ifdef CONFIG_TCC_BCHECK
4454 if (vtop
->r
& VT_MUSTBOUND
)
4458 r
= vtop
->r
& VT_VALMASK
;
4459 /* need to reload if:
4461 - lvalue (need to dereference pointer)
4462 - already a register, but not in the right class */
4463 if (r
>= VT_CONST
||
4464 (vtop
->r
& VT_LVAL
) ||
4465 !(reg_classes
[r
] & rc
) ||
4466 ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
&&
4467 !(reg_classes
[vtop
->r2
] & rc
))) {
4469 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
4470 /* two register type load : expand to two words
4472 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
4475 vtop
->c
.ui
= ll
; /* first word */
4477 vtop
->r
= r
; /* save register value */
4478 vpushi(ll
>> 32); /* second word */
4479 } else if (r
>= VT_CONST
||
4480 (vtop
->r
& VT_LVAL
)) {
4481 /* load from memory */
4484 vtop
[-1].r
= r
; /* save register value */
4485 /* increment pointer to get second word */
4486 vtop
->type
.t
= VT_INT
;
4492 /* move registers */
4495 vtop
[-1].r
= r
; /* save register value */
4496 vtop
->r
= vtop
[-1].r2
;
4498 /* allocate second register */
4505 /* write second register */
4507 } else if ((vtop
->r
& VT_LVAL
) && !is_float(vtop
->type
.t
)) {
4509 /* lvalue of scalar type : need to use lvalue type
4510 because of possible cast */
4513 /* compute memory access type */
4514 if (vtop
->r
& VT_LVAL_BYTE
)
4516 else if (vtop
->r
& VT_LVAL_SHORT
)
4518 if (vtop
->r
& VT_LVAL_UNSIGNED
)
4522 /* restore wanted type */
4525 /* one register type load */
4534 /* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
4535 void gv2(int rc1
, int rc2
)
4539 /* generate more generic register first. But VT_JMP or VT_CMP
4540 values must be generated first in all cases to avoid possible
4542 v
= vtop
[0].r
& VT_VALMASK
;
4543 if (v
!= VT_CMP
&& (v
& ~1) != VT_JMP
&& rc1
<= rc2
) {
4548 /* test if reload is needed for first register */
4549 if ((vtop
[-1].r
& VT_VALMASK
) >= VT_CONST
) {
4559 /* test if reload is needed for first register */
4560 if ((vtop
[0].r
& VT_VALMASK
) >= VT_CONST
) {
4566 /* expand long long on stack in two int registers */
4571 u
= vtop
->type
.t
& VT_UNSIGNED
;
4574 vtop
[0].r
= vtop
[-1].r2
;
4575 vtop
[0].r2
= VT_CONST
;
4576 vtop
[-1].r2
= VT_CONST
;
4577 vtop
[0].type
.t
= VT_INT
| u
;
4578 vtop
[-1].type
.t
= VT_INT
| u
;
4581 /* build a long long from two ints */
4584 gv2(RC_INT
, RC_INT
);
4585 vtop
[-1].r2
= vtop
[0].r
;
4586 vtop
[-1].type
.t
= t
;
4590 /* rotate n first stack elements to the bottom */
4597 for(i
=-n
+1;i
!=0;i
++)
4598 vtop
[i
] = vtop
[i
+1];
4602 /* pop stack value */
4606 v
= vtop
->r
& VT_VALMASK
;
4607 #ifdef TCC_TARGET_I386
4608 /* for x86, we need to pop the FP stack */
4609 if (v
== TREG_ST0
&& !nocode_wanted
) {
4610 o(0xd9dd); /* fstp %st(1) */
4613 if (v
== VT_JMP
|| v
== VT_JMPI
) {
4614 /* need to put correct jump if && or || without test */
4620 /* convert stack entry to register and duplicate its value in another
4628 if ((t
& VT_BTYPE
) == VT_LLONG
) {
4635 /* stack: H L L1 H1 */
4643 /* duplicate value */
4654 load(r1
, &sv
); /* move r to r1 */
4656 /* duplicates value */
4661 /* generate CPU independent (unsigned) long long operations */
4662 void gen_opl(int op
)
4664 int t
, a
, b
, op1
, c
, i
;
4672 func
= TOK___divdi3
;
4675 func
= TOK___udivdi3
;
4678 func
= TOK___moddi3
;
4681 func
= TOK___umoddi3
;
4683 /* call generic long long function */
4684 gfunc_start(&gf
, FUNC_CDECL
);
4687 vpush_global_sym(&func_old_type
, func
);
4691 vtop
->r2
= REG_LRET
;
4704 /* stack: L1 H1 L2 H2 */
4709 vtop
[-2] = vtop
[-3];
4712 /* stack: H1 H2 L1 L2 */
4718 /* stack: H1 H2 L1 L2 ML MH */
4721 /* stack: ML MH H1 H2 L1 L2 */
4725 /* stack: ML MH H1 L2 H2 L1 */
4730 /* stack: ML MH M1 M2 */
4733 } else if (op
== '+' || op
== '-') {
4734 /* XXX: add non carry method too (for MIPS or alpha) */
4740 /* stack: H1 H2 (L1 op L2) */
4743 gen_op(op1
+ 1); /* TOK_xxxC2 */
4746 /* stack: H1 H2 (L1 op L2) */
4749 /* stack: (L1 op L2) H1 H2 */
4751 /* stack: (L1 op L2) (H1 op H2) */
4759 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
4760 t
= vtop
[-1].type
.t
;
4764 /* stack: L H shift */
4766 /* constant: simpler */
4767 /* NOTE: all comments are for SHL. the other cases are
4768 done by swaping words */
4779 if (op
!= TOK_SAR
) {
4812 /* XXX: should provide a faster fallback on x86 ? */
4815 func
= TOK___sardi3
;
4818 func
= TOK___shrdi3
;
4821 func
= TOK___shldi3
;
4827 /* compare operations */
4833 /* stack: L1 H1 L2 H2 */
4835 vtop
[-1] = vtop
[-2];
4837 /* stack: L1 L2 H1 H2 */
4840 /* when values are equal, we need to compare low words. since
4841 the jump is inverted, we invert the test too. */
4844 else if (op1
== TOK_GT
)
4846 else if (op1
== TOK_ULT
)
4848 else if (op1
== TOK_UGT
)
4853 if (op1
!= TOK_NE
) {
4857 /* generate non equal test */
4858 /* XXX: NOT PORTABLE yet */
4862 #ifdef TCC_TARGET_I386
4863 b
= psym(0x850f, 0);
4865 error("not implemented");
4869 /* compare low. Always unsigned */
4873 else if (op1
== TOK_LE
)
4875 else if (op1
== TOK_GT
)
4877 else if (op1
== TOK_GE
)
4887 /* handle integer constant optimizations and various machine
4889 void gen_opic(int op
)
4896 /* currently, we cannot do computations with forward symbols */
4897 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
4898 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
4902 case '+': v1
->c
.i
+= fc
; break;
4903 case '-': v1
->c
.i
-= fc
; break;
4904 case '&': v1
->c
.i
&= fc
; break;
4905 case '^': v1
->c
.i
^= fc
; break;
4906 case '|': v1
->c
.i
|= fc
; break;
4907 case '*': v1
->c
.i
*= fc
; break;
4914 /* if division by zero, generate explicit division */
4917 error("division by zero in constant");
4921 default: v1
->c
.i
/= fc
; break;
4922 case '%': v1
->c
.i
%= fc
; break;
4923 case TOK_UDIV
: v1
->c
.i
= (unsigned)v1
->c
.i
/ fc
; break;
4924 case TOK_UMOD
: v1
->c
.i
= (unsigned)v1
->c
.i
% fc
; break;
4927 case TOK_SHL
: v1
->c
.i
<<= fc
; break;
4928 case TOK_SHR
: v1
->c
.i
= (unsigned)v1
->c
.i
>> fc
; break;
4929 case TOK_SAR
: v1
->c
.i
>>= fc
; break;
4931 case TOK_ULT
: v1
->c
.i
= (unsigned)v1
->c
.i
< (unsigned)fc
; break;
4932 case TOK_UGE
: v1
->c
.i
= (unsigned)v1
->c
.i
>= (unsigned)fc
; break;
4933 case TOK_EQ
: v1
->c
.i
= v1
->c
.i
== fc
; break;
4934 case TOK_NE
: v1
->c
.i
= v1
->c
.i
!= fc
; break;
4935 case TOK_ULE
: v1
->c
.i
= (unsigned)v1
->c
.i
<= (unsigned)fc
; break;
4936 case TOK_UGT
: v1
->c
.i
= (unsigned)v1
->c
.i
> (unsigned)fc
; break;
4937 case TOK_LT
: v1
->c
.i
= v1
->c
.i
< fc
; break;
4938 case TOK_GE
: v1
->c
.i
= v1
->c
.i
>= fc
; break;
4939 case TOK_LE
: v1
->c
.i
= v1
->c
.i
<= fc
; break;
4940 case TOK_GT
: v1
->c
.i
= v1
->c
.i
> fc
; break;
4942 case TOK_LAND
: v1
->c
.i
= v1
->c
.i
&& fc
; break;
4943 case TOK_LOR
: v1
->c
.i
= v1
->c
.i
|| fc
; break;
4949 /* if commutative ops, put c2 as constant */
4950 if (c1
&& (op
== '+' || op
== '&' || op
== '^' ||
4951 op
== '|' || op
== '*')) {
4956 if (c2
&& (((op
== '*' || op
== '/' || op
== TOK_UDIV
||
4959 ((op
== '+' || op
== '-' || op
== '|' || op
== '^' ||
4960 op
== TOK_SHL
|| op
== TOK_SHR
|| op
== TOK_SAR
) &&
4966 } else if (c2
&& (op
== '*' || op
== TOK_PDIV
|| op
== TOK_UDIV
)) {
4967 /* try to use shifts instead of muls or divs */
4968 if (fc
> 0 && (fc
& (fc
- 1)) == 0) {
4977 else if (op
== TOK_PDIV
)
4983 } else if (c2
&& (op
== '+' || op
== '-') &&
4984 (vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) ==
4985 (VT_CONST
| VT_SYM
)) {
4986 /* symbol + constant case */
4993 if (!nocode_wanted
) {
4994 /* call low level op generator */
5003 /* generate a floating point operation with constant propagation */
5004 void gen_opif(int op
)
5012 /* currently, we cannot do computations with forward symbols */
5013 c1
= (v1
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5014 c2
= (v2
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5016 if (v1
->type
.t
== VT_FLOAT
) {
5019 } else if (v1
->type
.t
== VT_DOUBLE
) {
5027 /* NOTE: we only do constant propagation if finite number (not
5028 NaN or infinity) (ANSI spec) */
5029 if (!ieee_finite(f1
) || !ieee_finite(f2
))
5033 case '+': f1
+= f2
; break;
5034 case '-': f1
-= f2
; break;
5035 case '*': f1
*= f2
; break;
5039 error("division by zero in constant");
5044 /* XXX: also handles tests ? */
5048 /* XXX: overflow test ? */
5049 if (v1
->type
.t
== VT_FLOAT
) {
5051 } else if (v1
->type
.t
== VT_DOUBLE
) {
5059 if (!nocode_wanted
) {
5067 static int pointed_size(CType
*type
)
5070 return type_size(pointed_type(type
), &align
);
5074 void check_pointer_types(SValue
*p1
, SValue
*p2
)
5076 char buf1
[256], buf2
[256];
5080 if (!is_compatible_types(t1
, t2
)) {
5081 type_to_str(buf1
, sizeof(buf1
), t1
, NULL
);
5082 type_to_str(buf2
, sizeof(buf2
), t2
, NULL
);
5083 error("incompatible pointers '%s' and '%s'", buf1
, buf2
);
5088 /* generic gen_op: handles types problems */
5091 int u
, t1
, t2
, bt1
, bt2
, t
;
5094 t1
= vtop
[-1].type
.t
;
5095 t2
= vtop
[0].type
.t
;
5096 bt1
= t1
& VT_BTYPE
;
5097 bt2
= t2
& VT_BTYPE
;
5099 if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
5100 /* at least one operand is a pointer */
5101 /* relationnal op: must be both pointers */
5102 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
5103 // check_pointer_types(vtop, vtop - 1);
5104 /* pointers are handled are unsigned */
5105 t
= VT_INT
| VT_UNSIGNED
;
5108 /* if both pointers, then it must be the '-' op */
5109 if (bt1
== VT_PTR
&& bt2
== VT_PTR
) {
5111 error("cannot use pointers here");
5112 // check_pointer_types(vtop - 1, vtop);
5113 /* XXX: check that types are compatible */
5114 u
= pointed_size(&vtop
[-1].type
);
5116 /* set to integer type */
5117 vtop
->type
.t
= VT_INT
;
5121 /* exactly one pointer : must be '+' or '-'. */
5122 if (op
!= '-' && op
!= '+')
5123 error("cannot use pointers here");
5124 /* Put pointer as first operand */
5125 if (bt2
== VT_PTR
) {
5129 type1
= vtop
[-1].type
;
5130 /* XXX: cast to int ? (long long case) */
5131 vpushi(pointed_size(&vtop
[-1].type
));
5133 #ifdef CONFIG_TCC_BCHECK
5134 /* if evaluating constant expression, no code should be
5135 generated, so no bound check */
5136 if (do_bounds_check
&& !const_wanted
) {
5137 /* if bounded pointers, we generate a special code to
5144 gen_bounded_ptr_add();
5150 /* put again type if gen_opic() swaped operands */
5153 } else if (is_float(bt1
) || is_float(bt2
)) {
5154 /* compute bigger type and do implicit casts */
5155 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
5157 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
5162 /* floats can only be used for a few operations */
5163 if (op
!= '+' && op
!= '-' && op
!= '*' && op
!= '/' &&
5164 (op
< TOK_ULT
|| op
> TOK_GT
))
5165 error("invalid operands for binary operation");
5167 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
5168 /* cast to biggest op */
5170 /* convert to unsigned if it does not fit in a long long */
5171 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
5172 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
5176 /* integer operations */
5178 /* convert to unsigned if it does not fit in an integer */
5179 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
5180 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
5183 /* XXX: currently, some unsigned operations are explicit, so
5184 we modify them here */
5185 if (t
& VT_UNSIGNED
) {
5192 else if (op
== TOK_LT
)
5194 else if (op
== TOK_GT
)
5196 else if (op
== TOK_LE
)
5198 else if (op
== TOK_GE
)
5205 /* special case for shifts and long long: we keep the shift as
5207 if (op
== TOK_SHR
|| op
== TOK_SAR
|| op
== TOK_SHL
)
5212 else if ((t
& VT_BTYPE
) == VT_LLONG
)
5216 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
5217 /* relationnal op: the result is an int */
5218 vtop
->type
.t
= VT_INT
;
5225 /* generic itof for unsigned long long case */
5226 void gen_cvt_itof1(int t
)
5230 if ((vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
)) ==
5231 (VT_LLONG
| VT_UNSIGNED
)) {
5233 gfunc_start(&gf
, FUNC_CDECL
);
5236 vpush_global_sym(&func_old_type
, TOK___ulltof
);
5237 else if (t
== VT_DOUBLE
)
5238 vpush_global_sym(&func_old_type
, TOK___ulltod
);
5240 vpush_global_sym(&func_old_type
, TOK___ulltold
);
5249 /* generic ftoi for unsigned long long case */
5250 void gen_cvt_ftoi1(int t
)
5255 if (t
== (VT_LLONG
| VT_UNSIGNED
)) {
5256 /* not handled natively */
5257 gfunc_start(&gf
, FUNC_CDECL
);
5258 st
= vtop
->type
.t
& VT_BTYPE
;
5261 vpush_global_sym(&func_old_type
, TOK___fixunssfdi
);
5262 else if (st
== VT_DOUBLE
)
5263 vpush_global_sym(&func_old_type
, TOK___fixunsdfdi
);
5265 vpush_global_sym(&func_old_type
, TOK___fixunsxfdi
);
5269 vtop
->r2
= REG_LRET
;
5275 /* force char or short cast */
5276 void force_charshort_cast(int t
)
5280 /* XXX: add optimization if lvalue : just change type and offset */
5285 if (t
& VT_UNSIGNED
) {
5286 vpushi((1 << bits
) - 1);
5297 /* cast 'vtop' to 'type' */
5298 static void gen_cast(CType
*type
)
5300 int sbt
, dbt
, sf
, df
, c
;
5302 /* special delayed cast for char/short */
5303 /* XXX: in some cases (multiple cascaded casts), it may still
5305 if (vtop
->r
& VT_MUSTCAST
) {
5306 vtop
->r
&= ~VT_MUSTCAST
;
5307 force_charshort_cast(vtop
->type
.t
);
5310 dbt
= type
->t
& (VT_BTYPE
| VT_UNSIGNED
);
5311 sbt
= vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
);
5313 if (sbt
!= dbt
&& !nocode_wanted
) {
5316 c
= (vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
;
5318 /* convert from fp to fp */
5320 /* constant case: we can do it now */
5321 /* XXX: in ISOC, cannot do it if error in convert */
5322 if (dbt
== VT_FLOAT
&& sbt
== VT_DOUBLE
)
5323 vtop
->c
.f
= (float)vtop
->c
.d
;
5324 else if (dbt
== VT_FLOAT
&& sbt
== VT_LDOUBLE
)
5325 vtop
->c
.f
= (float)vtop
->c
.ld
;
5326 else if (dbt
== VT_DOUBLE
&& sbt
== VT_FLOAT
)
5327 vtop
->c
.d
= (double)vtop
->c
.f
;
5328 else if (dbt
== VT_DOUBLE
&& sbt
== VT_LDOUBLE
)
5329 vtop
->c
.d
= (double)vtop
->c
.ld
;
5330 else if (dbt
== VT_LDOUBLE
&& sbt
== VT_FLOAT
)
5331 vtop
->c
.ld
= (long double)vtop
->c
.f
;
5332 else if (dbt
== VT_LDOUBLE
&& sbt
== VT_DOUBLE
)
5333 vtop
->c
.ld
= (long double)vtop
->c
.d
;
5335 /* non constant case: generate code */
5339 /* convert int to fp */
5342 case VT_LLONG
| VT_UNSIGNED
:
5344 /* XXX: add const cases for long long */
5346 case VT_INT
| VT_UNSIGNED
:
5348 case VT_FLOAT
: vtop
->c
.f
= (float)vtop
->c
.ui
; break;
5349 case VT_DOUBLE
: vtop
->c
.d
= (double)vtop
->c
.ui
; break;
5350 case VT_LDOUBLE
: vtop
->c
.ld
= (long double)vtop
->c
.ui
; break;
5355 case VT_FLOAT
: vtop
->c
.f
= (float)vtop
->c
.i
; break;
5356 case VT_DOUBLE
: vtop
->c
.d
= (double)vtop
->c
.i
; break;
5357 case VT_LDOUBLE
: vtop
->c
.ld
= (long double)vtop
->c
.i
; break;
5366 /* convert fp to int */
5367 /* we handle char/short/etc... with generic code */
5368 if (dbt
!= (VT_INT
| VT_UNSIGNED
) &&
5369 dbt
!= (VT_LLONG
| VT_UNSIGNED
) &&
5374 case VT_LLONG
| VT_UNSIGNED
:
5376 /* XXX: add const cases for long long */
5378 case VT_INT
| VT_UNSIGNED
:
5380 case VT_FLOAT
: vtop
->c
.ui
= (unsigned int)vtop
->c
.d
; break;
5381 case VT_DOUBLE
: vtop
->c
.ui
= (unsigned int)vtop
->c
.d
; break;
5382 case VT_LDOUBLE
: vtop
->c
.ui
= (unsigned int)vtop
->c
.d
; break;
5388 case VT_FLOAT
: vtop
->c
.i
= (int)vtop
->c
.d
; break;
5389 case VT_DOUBLE
: vtop
->c
.i
= (int)vtop
->c
.d
; break;
5390 case VT_LDOUBLE
: vtop
->c
.i
= (int)vtop
->c
.d
; break;
5398 if (dbt
== VT_INT
&& (type
->t
& (VT_BTYPE
| VT_UNSIGNED
)) != dbt
) {
5399 /* additional cast for char/short/bool... */
5403 } else if ((dbt
& VT_BTYPE
) == VT_LLONG
) {
5404 if ((sbt
& VT_BTYPE
) != VT_LLONG
) {
5405 /* scalar to long long */
5407 if (sbt
== (VT_INT
| VT_UNSIGNED
))
5408 vtop
->c
.ll
= vtop
->c
.ui
;
5410 vtop
->c
.ll
= vtop
->c
.i
;
5412 /* machine independent conversion */
5414 /* generate high word */
5415 if (sbt
== (VT_INT
| VT_UNSIGNED
)) {
5423 /* patch second register */
5424 vtop
[-1].r2
= vtop
->r
;
5428 } else if (dbt
== VT_BOOL
) {
5429 /* scalar to bool */
5432 } else if ((dbt
& VT_BTYPE
) == VT_BYTE
||
5433 (dbt
& VT_BTYPE
) == VT_SHORT
) {
5434 force_charshort_cast(dbt
);
5435 } else if ((dbt
& VT_BTYPE
) == VT_INT
) {
5437 if (sbt
== VT_LLONG
) {
5438 /* from long long: just take low order word */
5442 /* if lvalue and single word type, nothing to do because
5443 the lvalue already contains the real type size (see
5444 VT_LVAL_xxx constants) */
5450 /* return type size. Put alignment at 'a' */
5451 static int type_size(CType
*type
, int *a
)
5456 bt
= type
->t
& VT_BTYPE
;
5457 if (bt
== VT_STRUCT
) {
5462 } else if (bt
== VT_PTR
) {
5463 if (type
->t
& VT_ARRAY
) {
5465 return type_size(&s
->type
, a
) * s
->c
;
5470 } else if (bt
== VT_LDOUBLE
) {
5472 return LDOUBLE_SIZE
;
5473 } else if (bt
== VT_DOUBLE
|| bt
== VT_LLONG
) {
5474 *a
= 4; /* XXX: i386 specific */
5476 } else if (bt
== VT_INT
|| bt
== VT_ENUM
|| bt
== VT_FLOAT
) {
5479 } else if (bt
== VT_SHORT
) {
5483 /* char, void, function, _Bool */
5489 /* return the pointed type of t */
5490 static inline CType
*pointed_type(CType
*type
)
5492 return &type
->ref
->type
;
5495 /* modify type so that its it is a pointer to type. */
5496 static void mk_pointer(CType
*type
)
5499 s
= sym_push(SYM_FIELD
, type
, 0, -1);
5500 type
->t
= VT_PTR
| (type
->t
& ~VT_TYPE
);
5504 static int is_compatible_types(CType
*type1
, CType
*type2
)
5507 int bt1
, bt2
, t1
, t2
;
5509 t1
= type1
->t
& VT_TYPE
;
5510 t2
= type2
->t
& VT_TYPE
;
5511 bt1
= t1
& VT_BTYPE
;
5512 bt2
= t2
& VT_BTYPE
;
5513 if (bt1
== VT_PTR
) {
5514 type1
= pointed_type(type1
);
5515 /* if function, then convert implicitely to function pointer */
5516 if (bt2
!= VT_FUNC
) {
5519 type2
= pointed_type(type2
);
5521 /* void matches everything */
5522 /* XXX: not fully compliant */
5523 if ((type1
->t
& VT_TYPE
) == VT_VOID
|| (type2
->t
& VT_TYPE
) == VT_VOID
)
5525 return is_compatible_types(type1
, type2
);
5526 } else if (bt1
== VT_STRUCT
|| bt2
== VT_STRUCT
) {
5527 return (type1
->ref
== type2
->ref
);
5528 } else if (bt1
== VT_FUNC
) {
5533 if (!is_compatible_types(&s1
->type
, &s2
->type
))
5535 /* XXX: not complete */
5536 if (s1
->c
== FUNC_OLD
|| s2
->c
== FUNC_OLD
)
5540 while (s1
!= NULL
) {
5543 if (!is_compatible_types(&s1
->type
, &s2
->type
))
5552 /* XXX: not complete */
5557 /* print a type. If 'varstr' is not NULL, then the variable is also
5558 printed in the type */
5560 /* XXX: add array and function pointers */
5561 void type_to_str(char *buf
, int buf_size
,
5562 CType
*type
, const char *varstr
)
5569 t
= type
->t
& VT_TYPE
;
5572 if (t
& VT_UNSIGNED
)
5573 pstrcat(buf
, buf_size
, "unsigned ");
5603 tstr
= "long double";
5605 pstrcat(buf
, buf_size
, tstr
);
5609 if (bt
== VT_STRUCT
)
5613 pstrcat(buf
, buf_size
, tstr
);
5614 v
= type
->ref
->v
& ~SYM_STRUCT
;
5615 if (v
>= SYM_FIRST_ANOM
)
5616 pstrcat(buf
, buf_size
, "<anonymous>");
5618 pstrcat(buf
, buf_size
, get_tok_str(v
, NULL
));
5622 type_to_str(buf
, buf_size
, &s
->type
, varstr
);
5623 pstrcat(buf
, buf_size
, "(");
5625 while (sa
!= NULL
) {
5626 type_to_str(buf1
, sizeof(buf1
), &sa
->type
, NULL
);
5627 pstrcat(buf
, buf_size
, buf1
);
5630 pstrcat(buf
, buf_size
, ", ");
5632 pstrcat(buf
, buf_size
, ")");
5636 pstrcpy(buf1
, sizeof(buf1
), "*");
5638 pstrcat(buf1
, sizeof(buf1
), varstr
);
5639 type_to_str(buf
, buf_size
, &s
->type
, buf1
);
5643 pstrcat(buf
, buf_size
, " ");
5644 pstrcat(buf
, buf_size
, varstr
);
5649 /* verify type compatibility to store vtop in 'dt' type, and generate
5651 static void gen_assign_cast(CType
*dt
)
5654 char buf1
[256], buf2
[256];
5657 st
= &vtop
->type
; /* source type */
5658 dbt
= dt
->t
& VT_BTYPE
;
5659 sbt
= st
->t
& VT_BTYPE
;
5660 if (dbt
== VT_PTR
) {
5661 /* special cases for pointers */
5662 /* a function is implicitely a function pointer */
5663 if (sbt
== VT_FUNC
) {
5664 if (!is_compatible_types(pointed_type(dt
), st
))
5669 /* '0' can also be a pointer */
5670 if (sbt
== VT_INT
&&
5671 ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) &&
5674 /* accept implicit pointer to integer cast with warning */
5675 if (sbt
== VT_BYTE
|| sbt
== VT_SHORT
||
5676 sbt
== VT_INT
|| sbt
== VT_LLONG
) {
5677 warning("assignment makes pointer from integer without a cast");
5680 } else if (dbt
== VT_BYTE
|| dbt
== VT_SHORT
||
5681 dbt
== VT_INT
|| dbt
== VT_LLONG
) {
5682 if (sbt
== VT_PTR
|| sbt
== VT_FUNC
) {
5683 warning("assignment makes integer from pointer without a cast");
5687 if (!is_compatible_types(dt
, st
)) {
5689 type_to_str(buf1
, sizeof(buf1
), st
, NULL
);
5690 type_to_str(buf2
, sizeof(buf2
), dt
, NULL
);
5691 error("cannot cast '%s' to '%s'", buf1
, buf2
);
5697 /* store vtop in lvalue pushed on stack */
5700 int sbt
, dbt
, ft
, r
, t
, size
, align
, bit_size
, bit_pos
, rc
, delayed_cast
;
5703 ft
= vtop
[-1].type
.t
;
5704 sbt
= vtop
->type
.t
& VT_BTYPE
;
5705 dbt
= ft
& VT_BTYPE
;
5706 if (((sbt
== VT_INT
|| sbt
== VT_SHORT
) && dbt
== VT_BYTE
) ||
5707 (sbt
== VT_INT
&& dbt
== VT_SHORT
)) {
5708 /* optimize char/short casts */
5709 delayed_cast
= VT_MUSTCAST
;
5710 vtop
->type
.t
= ft
& VT_TYPE
;
5713 gen_assign_cast(&vtop
[-1].type
);
5716 if (sbt
== VT_STRUCT
) {
5717 /* if structure, only generate pointer */
5718 /* structure assignment : generate memcpy */
5719 /* XXX: optimize if small size */
5720 if (!nocode_wanted
) {
5722 gfunc_start(&gf
, FUNC_CDECL
);
5724 size
= type_size(&vtop
->type
, &align
);
5728 vtop
->type
.t
= VT_INT
;
5733 vtop
->type
.t
= VT_INT
;
5738 vpush_global_sym(&func_old_type
, TOK_memcpy
);
5744 /* leave source on stack */
5745 } else if (ft
& VT_BITFIELD
) {
5746 /* bitfield store handling */
5747 bit_pos
= (ft
>> VT_STRUCT_SHIFT
) & 0x3f;
5748 bit_size
= (ft
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
5749 /* remove bit field info to avoid loops */
5750 vtop
[-1].type
.t
= ft
& ~(VT_BITFIELD
| (-1 << VT_STRUCT_SHIFT
));
5752 /* duplicate destination */
5754 vtop
[-1] = vtop
[-2];
5756 /* mask and shift source */
5757 vpushi((1 << bit_size
) - 1);
5761 /* load destination, mask and or with source */
5763 vpushi(~(((1 << bit_size
) - 1) << bit_pos
));
5769 #ifdef CONFIG_TCC_BCHECK
5770 /* bound check case */
5771 if (vtop
[-1].r
& VT_MUSTBOUND
) {
5777 if (!nocode_wanted
) {
5781 r
= gv(rc
); /* generate value */
5782 /* if lvalue was saved on stack, must read it */
5783 if ((vtop
[-1].r
& VT_VALMASK
) == VT_LLOCAL
) {
5785 t
= get_reg(RC_INT
);
5787 sv
.r
= VT_LOCAL
| VT_LVAL
;
5788 sv
.c
.ul
= vtop
[-1].c
.ul
;
5790 vtop
[-1].r
= t
| VT_LVAL
;
5793 /* two word case handling : store second register at word + 4 */
5794 if ((ft
& VT_BTYPE
) == VT_LLONG
) {
5796 /* convert to int to increment easily */
5797 vtop
->type
.t
= VT_INT
;
5803 /* XXX: it works because r2 is spilled last ! */
5804 store(vtop
->r2
, vtop
- 1);
5808 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
5809 vtop
->r
|= delayed_cast
;
5813 /* post defines POST/PRE add. c is the token ++ or -- */
5814 void inc(int post
, int c
)
5817 vdup(); /* save lvalue */
5819 gv_dup(); /* duplicate value */
5824 vpushi(c
- TOK_MID
);
5826 vstore(); /* store value */
5828 vpop(); /* if post op, return saved value */
5831 /* Parse GNUC __attribute__ extension. Currently, the following
5832 extensions are recognized:
5833 - aligned(n) : set data/function alignment.
5834 - section(x) : generate data/code in this section.
5835 - unused : currently ignored, but may be used someday.
5837 static void parse_attribute(AttributeDef
*ad
)
5841 while (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
) {
5845 while (tok
!= ')') {
5846 if (tok
< TOK_IDENT
)
5847 expect("attribute name");
5855 expect("section name");
5856 ad
->section
= find_section(tcc_state
, (char *)tokc
.cstr
->data
);
5865 if (n
<= 0 || (n
& (n
- 1)) != 0)
5866 error("alignment must be a positive power of two");
5875 /* currently, no need to handle it because tcc does not
5876 track unused objects */
5880 /* currently, no need to handle it because tcc does not
5881 track unused objects */
5886 ad
->func_call
= FUNC_CDECL
;
5891 ad
->func_call
= FUNC_STDCALL
;
5894 // warning("'%s' attribute ignored", get_tok_str(t, NULL));
5895 /* skip parameters */
5896 /* XXX: skip parenthesis too */
5899 while (tok
!= ')' && tok
!= -1)
5914 /* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
5915 static void struct_decl(CType
*type
, int u
)
5917 int a
, v
, size
, align
, maxalign
, c
, offset
;
5918 int bit_size
, bit_pos
, bsize
, bt
, lbit_pos
;
5923 a
= tok
; /* save decl type */
5928 /* struct already defined ? return it */
5930 expect("struct/union/enum name");
5934 error("invalid type");
5941 s
= sym_push(v
| SYM_STRUCT
, &type1
, 0, 0);
5942 /* put struct/union/enum name in type */
5950 error("struct/union/enum already defined");
5951 /* cannot be empty */
5953 /* non empty enums are not allowed */
5954 if (a
== TOK_ENUM
) {
5958 expect("identifier");
5964 /* enum symbols have static storage */
5965 ss
= sym_push(v
, &int_type
, VT_CONST
, c
);
5966 ss
->type
.t
|= VT_STATIC
;
5971 /* NOTE: we accept a trailing comma */
5981 while (tok
!= '}') {
5982 parse_btype(&btype
, &ad
);
5988 type_decl(&type1
, &ad
, &v
, TYPE_DIRECT
);
5989 if ((type1
.t
& VT_BTYPE
) == VT_FUNC
||
5990 (type1
.t
& (VT_TYPEDEF
| VT_STATIC
| VT_EXTERN
| VT_INLINE
)))
5991 error("invalid type for '%s'",
5992 get_tok_str(v
, NULL
));
5996 bit_size
= expr_const();
5997 /* XXX: handle v = 0 case for messages */
5999 error("negative width in bit-field '%s'",
6000 get_tok_str(v
, NULL
));
6001 if (v
&& bit_size
== 0)
6002 error("zero width for bit-field '%s'",
6003 get_tok_str(v
, NULL
));
6005 size
= type_size(&type1
, &align
);
6007 if (bit_size
>= 0) {
6008 bt
= type1
.t
& VT_BTYPE
;
6013 error("bitfields must have scalar type");
6015 if (bit_size
> bsize
) {
6016 error("width of '%s' exceeds its type",
6017 get_tok_str(v
, NULL
));
6018 } else if (bit_size
== bsize
) {
6019 /* no need for bit fields */
6021 } else if (bit_size
== 0) {
6022 /* XXX: what to do if only padding in a
6024 /* zero size: means to pad */
6028 /* we do not have enough room ? */
6029 if ((bit_pos
+ bit_size
) > bsize
)
6032 /* XXX: handle LSB first */
6033 type1
.t
|= VT_BITFIELD
|
6034 (bit_pos
<< VT_STRUCT_SHIFT
) |
6035 (bit_size
<< (VT_STRUCT_SHIFT
+ 6));
6036 bit_pos
+= bit_size
;
6042 /* add new memory data only if starting
6044 if (lbit_pos
== 0) {
6045 if (a
== TOK_STRUCT
) {
6046 c
= (c
+ align
- 1) & -align
;
6054 if (align
> maxalign
)
6058 printf("add field %s offset=%d",
6059 get_tok_str(v
, NULL
), offset
);
6060 if (type1
.t
& VT_BITFIELD
) {
6061 printf(" pos=%d size=%d",
6062 (type1
.t
>> VT_STRUCT_SHIFT
) & 0x3f,
6063 (type1
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f);
6067 ss
= sym_push(v
| SYM_FIELD
, &type1
, 0, offset
);
6071 if (tok
== ';' || tok
== TOK_EOF
)
6078 /* store size and alignment */
6079 s
->c
= (c
+ maxalign
- 1) & -maxalign
;
6085 /* return 0 if no type declaration. otherwise, return the basic type
6088 static int parse_btype(CType
*type
, AttributeDef
*ad
)
6090 int t
, u
, type_found
;
6094 memset(ad
, 0, sizeof(AttributeDef
));
6100 /* currently, we really ignore extension */
6110 if ((t
& VT_BTYPE
) != 0)
6111 error("too many basic types");
6125 if ((t
& VT_BTYPE
) == VT_DOUBLE
) {
6126 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
6127 } else if ((t
& VT_BTYPE
) == VT_LONG
) {
6128 t
= (t
& ~VT_BTYPE
) | VT_LLONG
;
6142 if ((t
& VT_BTYPE
) == VT_LONG
) {
6143 t
= (t
& ~VT_BTYPE
) | VT_LDOUBLE
;
6150 struct_decl(&type1
, VT_ENUM
);
6153 type
->ref
= type1
.ref
;
6157 struct_decl(&type1
, VT_STRUCT
);
6160 /* type modifiers */
6202 /* GNUC attribute */
6203 case TOK_ATTRIBUTE1
:
6204 case TOK_ATTRIBUTE2
:
6205 parse_attribute(ad
);
6212 parse_expr_type(&type1
);
6216 if (!s
|| !(s
->type
.t
& VT_TYPEDEF
))
6218 t
|= (s
->type
.t
& ~VT_TYPEDEF
);
6219 type
->ref
= s
->type
.ref
;
6226 /* long is never used as type */
6227 if ((t
& VT_BTYPE
) == VT_LONG
)
6228 t
= (t
& ~VT_BTYPE
) | VT_INT
;
6233 /* convert a function parameter type (array to pointer and function to
6234 function pointer) */
6235 static inline void convert_parameter_type(CType
*pt
)
6237 /* array must be transformed to pointer according to ANSI C */
6239 if ((pt
->t
& VT_BTYPE
) == VT_FUNC
) {
6244 static void post_type(CType
*type
, AttributeDef
*ad
)
6247 Sym
**plast
, *s
, *first
;
6252 /* function declaration */
6257 while (tok
!= ')') {
6258 /* read param name and compute offset */
6259 if (l
!= FUNC_OLD
) {
6260 if (!parse_btype(&pt
, &ad1
)) {
6262 error("invalid type");
6269 if ((pt
.t
& VT_BTYPE
) == VT_VOID
&& tok
== ')')
6271 type_decl(&pt
, &ad1
, &n
, TYPE_DIRECT
| TYPE_ABSTRACT
);
6272 if ((pt
.t
& VT_BTYPE
) == VT_VOID
)
6273 error("parameter declared as void");
6280 convert_parameter_type(&pt
);
6281 s
= sym_push(n
| SYM_FIELD
, &pt
, 0, 0);
6286 if (l
== FUNC_NEW
&& tok
== TOK_DOTS
) {
6293 /* if no parameters, then old type prototype */
6297 t1
= type
->t
& VT_STORAGE
;
6298 type
->t
&= ~VT_STORAGE
;
6299 post_type(type
, ad
);
6300 /* we push a anonymous symbol which will contain the function prototype */
6301 s
= sym_push(SYM_FIELD
, type
, ad
->func_call
, l
);
6303 type
->t
= t1
| VT_FUNC
;
6305 } else if (tok
== '[') {
6306 /* array definition */
6312 error("invalid array size");
6315 /* parse next post type */
6316 t1
= type
->t
& VT_STORAGE
;
6317 type
->t
&= ~VT_STORAGE
;
6318 post_type(type
, ad
);
6320 /* we push a anonymous symbol which will contain the array
6322 s
= sym_push(SYM_FIELD
, type
, 0, n
);
6323 type
->t
= t1
| VT_ARRAY
| VT_PTR
;
6328 /* Parse a type declaration (except basic type), and return the type
6329 in 'type'. 'td' is a bitmask indicating which kind of type decl is
6330 expected. 'type' should contain the basic type. 'ad' is the
6331 attribute definition of the basic type. It can be modified by
6334 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
)
6337 CType type1
, *type2
;
6339 while (tok
== '*') {
6358 /* XXX: clarify attribute handling */
6359 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
6360 parse_attribute(ad
);
6362 /* recursive type */
6363 /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
6364 type1
.t
= 0; /* XXX: same as int */
6367 /* XXX: this is not correct to modify 'ad' at this point, but
6368 the syntax is not clear */
6369 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
6370 parse_attribute(ad
);
6371 type_decl(&type1
, ad
, v
, td
);
6374 /* type identifier */
6375 if (tok
>= TOK_IDENT
&& (td
& TYPE_DIRECT
)) {
6379 if (!(td
& TYPE_ABSTRACT
))
6380 expect("identifier");
6384 post_type(type
, ad
);
6385 if (tok
== TOK_ATTRIBUTE1
|| tok
== TOK_ATTRIBUTE2
)
6386 parse_attribute(ad
);
6389 /* append type at the end of type1 */
6402 /* compute the lvalue VT_LVAL_xxx needed to match type t. */
6403 static int lvalue_type(int t
)
6408 if (bt
== VT_BYTE
|| bt
== VT_BOOL
)
6410 else if (bt
== VT_SHORT
)
6414 if (t
& VT_UNSIGNED
)
6415 r
|= VT_LVAL_UNSIGNED
;
6419 /* indirection with full error checking and bound check */
6420 static void indir(void)
6422 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
)
6424 if ((vtop
->r
& VT_LVAL
) && !nocode_wanted
)
6426 vtop
->type
= *pointed_type(&vtop
->type
);
6427 /* an array is never an lvalue */
6428 if (!(vtop
->type
.t
& VT_ARRAY
)) {
6429 vtop
->r
|= lvalue_type(vtop
->type
.t
);
6430 /* if bound checking, the referenced pointer must be checked */
6431 if (do_bounds_check
)
6432 vtop
->r
|= VT_MUSTBOUND
;
6436 /* pass a parameter to a function and do type checking and casting */
6437 void gfunc_param_typed(GFuncContext
*gf
, Sym
*func
, Sym
*arg
)
6442 func_type
= func
->c
;
6443 if (func_type
== FUNC_OLD
||
6444 (func_type
== FUNC_ELLIPSIS
&& arg
== NULL
)) {
6445 /* default casting : only need to convert float to double */
6446 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
) {
6450 } else if (arg
== NULL
) {
6451 error("too many arguments to function");
6453 gen_assign_cast(&arg
->type
);
6455 if (!nocode_wanted
) {
6462 /* parse an expression of the form '(type)' or '(expr)' and return its
6464 static void parse_expr_type(CType
*type
)
6470 if (parse_btype(type
, &ad
)) {
6471 type_decl(type
, &ad
, &n
, TYPE_ABSTRACT
);
6478 static void vpush_tokc(int t
)
6482 vsetc(&type
, VT_CONST
, &tokc
);
6485 static void unary(void)
6487 int n
, t
, align
, size
, r
;
6493 /* XXX: GCC 2.95.3 does not generate a table although it should be
6507 vpush_tokc(VT_INT
| VT_UNSIGNED
);
6511 vpush_tokc(VT_LLONG
);
6515 vpush_tokc(VT_LLONG
| VT_UNSIGNED
);
6519 vpush_tokc(VT_FLOAT
);
6523 vpush_tokc(VT_DOUBLE
);
6527 vpush_tokc(VT_LDOUBLE
);
6530 case TOK___FUNCTION__
:
6532 goto tok_identifier
;
6538 /* special function name identifier */
6539 len
= strlen(funcname
) + 1;
6540 /* generate char[len] type */
6545 vpush_ref(&type
, data_section
, data_section
->data_offset
, len
);
6546 ptr
= section_ptr_add(data_section
, len
);
6547 memcpy(ptr
, funcname
, len
);
6555 /* string parsing */
6561 memset(&ad
, 0, sizeof(AttributeDef
));
6562 decl_initializer_alloc(&type
, &ad
, VT_CONST
, 2, 0, 0);
6567 if (parse_btype(&type
, &ad
)) {
6568 type_decl(&type
, &ad
, &n
, TYPE_ABSTRACT
);
6570 /* check ISOC99 compound literal */
6572 /* data is allocated locally by default */
6577 /* all except arrays are lvalues */
6578 if (!(type
.t
& VT_ARRAY
))
6579 r
|= lvalue_type(type
.t
);
6580 memset(&ad
, 0, sizeof(AttributeDef
));
6581 decl_initializer_alloc(&type
, &ad
, r
, 1, 0, 0);
6586 } else if (tok
== '{') {
6587 /* save all registers */
6589 /* statement expression : we do not accept break/continue
6590 inside as GCC does */
6591 block(NULL
, NULL
, NULL
, NULL
, 0, 1);
6606 /* functions names must be treated as function pointers,
6607 except for unary '&' and sizeof. Since we consider that
6608 functions are not lvalues, we only have to handle it
6609 there and in function calls. */
6610 /* arrays can also be used although they are not lvalues */
6611 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
&&
6612 !(vtop
->type
.t
& VT_ARRAY
))
6614 mk_pointer(&vtop
->type
);
6620 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
)
6621 vtop
->c
.i
= !vtop
->c
.i
;
6622 else if ((vtop
->r
& VT_VALMASK
) == VT_CMP
)
6623 vtop
->c
.i
= vtop
->c
.i
^ 1;
6625 vseti(VT_JMP
, gtst(1, 0));
6635 /* in order to force cast, we add zero */
6637 if ((vtop
->type
.t
& VT_BTYPE
) == VT_PTR
)
6638 error("pointer not accepted for unary plus");
6648 parse_expr_type(&type
);
6652 size
= type_size(&type
, &align
);
6653 if (t
== TOK_SIZEOF
)
6674 goto tok_identifier
;
6676 /* allow to take the address of a label */
6677 if (tok
< TOK_UIDENT
)
6678 expect("label identifier");
6679 s
= label_find(tok
);
6681 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
6683 if (s
->r
== LABEL_DECLARED
)
6684 s
->r
= LABEL_FORWARD
;
6687 s
->type
.t
= VT_VOID
;
6688 mk_pointer(&s
->type
);
6689 s
->type
.t
|= VT_STATIC
;
6691 vset(&s
->type
, VT_CONST
| VT_SYM
, 0);
6700 expect("identifier");
6704 error("'%s' undeclared", get_tok_str(t
, NULL
));
6705 /* for simple function calls, we tolerate undeclared
6706 external reference to int() function */
6707 s
= external_global_sym(t
, &func_old_type
, 0);
6709 vset(&s
->type
, s
->r
, s
->c
);
6710 /* if forward reference, we must point to s */
6711 if (vtop
->r
& VT_SYM
) {
6718 /* post operations */
6720 if (tok
== TOK_INC
|| tok
== TOK_DEC
) {
6723 } else if (tok
== '.' || tok
== TOK_ARROW
) {
6725 if (tok
== TOK_ARROW
)
6730 /* expect pointer on structure */
6731 if ((vtop
->type
.t
& VT_BTYPE
) != VT_STRUCT
)
6732 expect("struct or union");
6736 while ((s
= s
->next
) != NULL
) {
6741 error("field not found");
6742 /* add field offset to pointer */
6743 vtop
->type
= char_pointer_type
; /* change type to 'char *' */
6746 /* change type to field type, and set to lvalue */
6747 vtop
->type
= s
->type
;
6748 /* an array is never an lvalue */
6749 if (!(vtop
->type
.t
& VT_ARRAY
)) {
6750 vtop
->r
|= lvalue_type(vtop
->type
.t
);
6751 /* if bound checking, the referenced pointer must be checked */
6752 if (do_bounds_check
)
6753 vtop
->r
|= VT_MUSTBOUND
;
6756 } else if (tok
== '[') {
6762 } else if (tok
== '(') {
6767 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
) {
6768 /* pointer test (no array accepted) */
6769 if ((vtop
->type
.t
& (VT_BTYPE
| VT_ARRAY
)) == VT_PTR
) {
6770 vtop
->type
= *pointed_type(&vtop
->type
);
6771 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FUNC
)
6775 expect("function pointer");
6778 vtop
->r
&= ~VT_LVAL
; /* no lvalue */
6780 /* get return type */
6782 if (!nocode_wanted
) {
6783 save_regs(0); /* save used temporary registers */
6784 gfunc_start(&gf
, s
->r
);
6787 sa
= s
->next
; /* first parameter */
6788 #ifdef INVERT_FUNC_PARAMS
6792 ParseState saved_parse_state
;
6795 /* read each argument and store it on a stack */
6801 while ((parlevel
> 0 || (tok
!= ')' && tok
!= ',')) &&
6805 else if (tok
== ')')
6807 tok_str_add_tok(&str
);
6810 tok_str_add(&str
, -1); /* end of file added */
6811 tok_str_add(&str
, 0);
6812 s1
= sym_push2(&args
, 0, 0, (int)str
.str
);
6813 s1
->next
= sa
; /* add reference to argument */
6822 /* now generate code in reverse order by reading the stack */
6823 save_parse_state(&saved_parse_state
);
6825 macro_ptr
= (int *)args
->c
;
6829 expect("',' or ')'");
6830 gfunc_param_typed(&gf
, s
, args
->next
);
6832 tok_str_free((int *)args
->c
);
6836 restore_parse_state(&saved_parse_state
);
6839 /* compute first implicit argument if a structure is returned */
6840 if ((s
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
6841 /* get some space for the returned structure */
6842 size
= type_size(&s
->type
, &align
);
6843 loc
= (loc
- size
) & -align
;
6845 ret
.r
= VT_LOCAL
| VT_LVAL
;
6846 /* pass it as 'int' to avoid structure arg passing
6848 vseti(VT_LOCAL
, loc
);
6857 /* return in register */
6858 if (is_float(ret
.type
.t
)) {
6861 if ((ret
.type
.t
& VT_BTYPE
) == VT_LLONG
)
6867 #ifndef INVERT_FUNC_PARAMS
6871 gfunc_param_typed(&gf
, s
, sa
);
6881 error("too few arguments to function");
6888 vsetc(&ret
.type
, ret
.r
, &ret
.c
);
6896 static void uneq(void)
6902 (tok
>= TOK_A_MOD
&& tok
<= TOK_A_DIV
) ||
6903 tok
== TOK_A_XOR
|| tok
== TOK_A_OR
||
6904 tok
== TOK_A_SHL
|| tok
== TOK_A_SAR
) {
6919 static void expr_prod(void)
6924 while (tok
== '*' || tok
== '/' || tok
== '%') {
6932 static void expr_sum(void)
6937 while (tok
== '+' || tok
== '-') {
6945 static void expr_shift(void)
6950 while (tok
== TOK_SHL
|| tok
== TOK_SAR
) {
6958 static void expr_cmp(void)
6963 while ((tok
>= TOK_ULE
&& tok
<= TOK_GT
) ||
6964 tok
== TOK_ULT
|| tok
== TOK_UGE
) {
6972 static void expr_cmpeq(void)
6977 while (tok
== TOK_EQ
|| tok
== TOK_NE
) {
6985 static void expr_and(void)
6988 while (tok
== '&') {
6995 static void expr_xor(void)
6998 while (tok
== '^') {
7005 static void expr_or(void)
7008 while (tok
== '|') {
7015 /* XXX: fix this mess */
7016 static void expr_land_const(void)
7019 while (tok
== TOK_LAND
) {
7026 /* XXX: fix this mess */
7027 static void expr_lor_const(void)
7030 while (tok
== TOK_LOR
) {
7037 /* only used if non constant */
7038 static void expr_land(void)
7043 if (tok
== TOK_LAND
) {
7047 if (tok
!= TOK_LAND
) {
7057 static void expr_lor(void)
7062 if (tok
== TOK_LOR
) {
7066 if (tok
!= TOK_LOR
) {
7076 /* XXX: better constant handling */
7077 static void expr_eq(void)
7079 int tt
, u
, r1
, r2
, rc
, t1
, t2
, bt1
, bt2
;
7081 CType type
, type1
, type2
;
7090 if (tok
== ':' && gnu_ext
) {
7106 if (vtop
!= vstack
) {
7107 /* needed to avoid having different registers saved in
7109 if (is_float(vtop
->type
.t
))
7116 if (tok
== ':' && gnu_ext
) {
7124 sv
= *vtop
; /* save value to handle it later */
7125 vtop
--; /* no vpop so that FP stack is not flushed */
7133 bt1
= t1
& VT_BTYPE
;
7135 bt2
= t2
& VT_BTYPE
;
7136 /* cast operands to correct type according to ISOC rules */
7137 if (is_float(bt1
) || is_float(bt2
)) {
7138 if (bt1
== VT_LDOUBLE
|| bt2
== VT_LDOUBLE
) {
7139 type
.t
= VT_LDOUBLE
;
7140 } else if (bt1
== VT_DOUBLE
|| bt2
== VT_DOUBLE
) {
7145 } else if (bt1
== VT_LLONG
|| bt2
== VT_LLONG
) {
7146 /* cast to biggest op */
7148 /* convert to unsigned if it does not fit in a long long */
7149 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
) ||
7150 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_LLONG
| VT_UNSIGNED
))
7151 type
.t
|= VT_UNSIGNED
;
7152 } else if (bt1
== VT_PTR
|| bt2
== VT_PTR
) {
7153 /* XXX: test pointer compatibility */
7155 } else if (bt1
== VT_STRUCT
|| bt2
== VT_STRUCT
) {
7156 /* XXX: test structure compatibility */
7158 } else if (bt1
== VT_VOID
|| bt2
== VT_VOID
) {
7159 /* NOTE: as an extension, we accept void on only one side */
7162 /* integer operations */
7164 /* convert to unsigned if it does not fit in an integer */
7165 if ((t1
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
) ||
7166 (t2
& (VT_BTYPE
| VT_UNSIGNED
)) == (VT_INT
| VT_UNSIGNED
))
7167 type
.t
|= VT_UNSIGNED
;
7170 /* now we convert second operand */
7173 if (is_float(type
.t
)) {
7175 } else if ((type
.t
& VT_BTYPE
) == VT_LLONG
) {
7176 /* for long longs, we use fixed registers to avoid having
7177 to handle a complicated move */
7182 /* this is horrible, but we must also convert first
7186 /* put again first value and cast it */
7197 static void gexpr(void)
7208 /* parse an expression and return its type without any side effect. */
7209 static void expr_type(CType
*type
)
7221 /* parse a unary expression and return its type without any side
7223 static void unary_type(CType
*type
)
7235 /* parse a constant expression and return value in vtop. */
7236 static void expr_const1(void)
7245 /* parse an integer constant and return its value. */
7246 static int expr_const(void)
7250 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
7251 expect("constant expression");
7257 /* return the label token if current token is a label, otherwise
7259 static int is_label(void)
7263 /* fast test first */
7264 if (tok
< TOK_UIDENT
)
7266 /* no need to save tokc because tok is an identifier */
7273 unget_tok(last_tok
);
7278 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
,
7279 int case_reg
, int is_expr
)
7284 /* generate line number info */
7286 (last_line_num
!= file
->line_num
|| last_ind
!= ind
)) {
7287 put_stabn(N_SLINE
, 0, file
->line_num
, ind
- func_ind
);
7289 last_line_num
= file
->line_num
;
7293 /* default return value is (void) */
7295 vtop
->type
.t
= VT_VOID
;
7298 if (tok
== TOK_IF
) {
7305 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
7307 if (c
== TOK_ELSE
) {
7311 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
7312 gsym(d
); /* patch else jmp */
7315 } else if (tok
== TOK_WHILE
) {
7323 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
7327 } else if (tok
== '{') {
7331 /* record local declaration stack position */
7333 llabel
= local_label_stack
;
7334 /* handle local labels declarations */
7335 if (tok
== TOK_LABEL
) {
7338 if (tok
< TOK_UIDENT
)
7339 expect("label identifier");
7340 label_push(&local_label_stack
, tok
, LABEL_DECLARED
);
7350 while (tok
!= '}') {
7355 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
7358 /* pop locally defined labels */
7359 label_pop(&local_label_stack
, llabel
);
7360 /* pop locally defined symbols */
7361 sym_pop(&local_stack
, s
);
7363 } else if (tok
== TOK_RETURN
) {
7367 gen_assign_cast(&func_vt
);
7368 if ((func_vt
.t
& VT_BTYPE
) == VT_STRUCT
) {
7370 /* if returning structure, must copy it to implicit
7371 first pointer arg location */
7374 vset(&type
, VT_LOCAL
| VT_LVAL
, func_vc
);
7377 /* copy structure value to pointer */
7379 } else if (is_float(func_vt
.t
)) {
7384 vtop
--; /* NOT vpop() because on x86 it would flush the fp stack */
7387 rsym
= gjmp(rsym
); /* jmp */
7388 } else if (tok
== TOK_BREAK
) {
7391 error("cannot break");
7392 *bsym
= gjmp(*bsym
);
7395 } else if (tok
== TOK_CONTINUE
) {
7398 error("cannot continue");
7399 *csym
= gjmp(*csym
);
7402 } else if (tok
== TOK_FOR
) {
7429 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
7434 if (tok
== TOK_DO
) {
7439 block(&a
, &b
, case_sym
, def_sym
, case_reg
, 0);
7450 if (tok
== TOK_SWITCH
) {
7454 /* XXX: other types than integer */
7455 case_reg
= gv(RC_INT
);
7459 b
= gjmp(0); /* jump to first case */
7461 block(&a
, csym
, &b
, &c
, case_reg
, 0);
7462 /* if no default, jmp after switch */
7470 if (tok
== TOK_CASE
) {
7477 if (gnu_ext
&& tok
== TOK_DOTS
) {
7481 warning("empty case range");
7483 /* since a case is like a label, we must skip it with a jmp */
7490 *case_sym
= gtst(1, 0);
7493 *case_sym
= gtst(1, 0);
7497 *case_sym
= gtst(1, *case_sym
);
7501 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
7503 if (tok
== TOK_DEFAULT
) {
7509 error("too many 'default'");
7511 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, 0);
7513 if (tok
== TOK_GOTO
) {
7515 if (tok
== '*' && gnu_ext
) {
7519 if ((vtop
->type
.t
& VT_BTYPE
) != VT_PTR
)
7522 } else if (tok
>= TOK_UIDENT
) {
7523 s
= label_find(tok
);
7524 /* put forward definition if needed */
7526 s
= label_push(&global_label_stack
, tok
, LABEL_FORWARD
);
7528 if (s
->r
== LABEL_DECLARED
)
7529 s
->r
= LABEL_FORWARD
;
7531 /* label already defined */
7532 if (s
->r
& LABEL_FORWARD
)
7533 s
->next
= (void *)gjmp((long)s
->next
);
7535 gjmp_addr((long)s
->next
);
7538 expect("label identifier");
7541 } else if (tok
== TOK_ASM1
|| tok
== TOK_ASM2
|| tok
== TOK_ASM3
) {
7549 if (s
->r
== LABEL_DEFINED
)
7550 error("duplicate label '%s'", get_tok_str(s
->v
, NULL
));
7551 gsym((long)s
->next
);
7552 s
->r
= LABEL_DEFINED
;
7554 s
= label_push(&global_label_stack
, b
, LABEL_DEFINED
);
7556 s
->next
= (void *)ind
;
7557 /* we accept this, but it is a mistake */
7559 warning("deprecated use of label at end of compound statement");
7563 block(bsym
, csym
, case_sym
, def_sym
, case_reg
, is_expr
);
7566 /* expression case */
7581 /* t is the array or struct type. c is the array or struct
7582 address. cur_index/cur_field is the pointer to the current
7583 value. 'size_only' is true if only size info is needed (only used
7585 static void decl_designator(CType
*type
, Section
*sec
, unsigned long c
,
7586 int *cur_index
, Sym
**cur_field
,
7590 int notfirst
, index
, index_last
, align
, l
, nb_elems
, elem_size
;
7596 if (gnu_ext
&& (l
= is_label()) != 0)
7598 while (tok
== '[' || tok
== '.') {
7600 if (!(type
->t
& VT_ARRAY
))
7601 expect("array type");
7604 index
= expr_const();
7605 if (index
< 0 || (s
->c
>= 0 && index
>= s
->c
))
7606 expect("invalid index");
7607 if (tok
== TOK_DOTS
&& gnu_ext
) {
7609 index_last
= expr_const();
7610 if (index_last
< 0 ||
7611 (s
->c
>= 0 && index_last
>= s
->c
) ||
7613 expect("invalid index");
7619 *cur_index
= index_last
;
7620 type
= pointed_type(type
);
7621 elem_size
= type_size(type
, &align
);
7622 c
+= index
* elem_size
;
7623 /* NOTE: we only support ranges for last designator */
7624 nb_elems
= index_last
- index
+ 1;
7625 if (nb_elems
!= 1) {
7634 if ((type
->t
& VT_BTYPE
) != VT_STRUCT
)
7635 expect("struct/union type");
7648 /* XXX: fix this mess by using explicit storage field */
7650 type1
.t
|= (type
->t
& ~VT_TYPE
);
7664 if (type
->t
& VT_ARRAY
) {
7666 type
= pointed_type(type
);
7667 c
+= index
* type_size(type
, &align
);
7671 error("too many field init");
7672 /* XXX: fix this mess by using explicit storage field */
7674 type1
.t
|= (type
->t
& ~VT_TYPE
);
7679 decl_initializer(type
, sec
, c
, 0, size_only
);
7681 /* XXX: make it more general */
7682 if (!size_only
&& nb_elems
> 1) {
7683 unsigned long c_end
;
7688 error("range init not supported yet for dynamic storage");
7689 c_end
= c
+ nb_elems
* elem_size
;
7690 if (c_end
> sec
->data_allocated
)
7691 section_realloc(sec
, c_end
);
7692 src
= sec
->data
+ c
;
7694 for(i
= 1; i
< nb_elems
; i
++) {
7696 memcpy(dst
, src
, elem_size
);
7702 #define EXPR_CONST 1
7705 /* store a value or an expression directly in global data or in local array */
7706 static void init_putv(CType
*type
, Section
*sec
, unsigned long c
,
7707 int v
, int expr_type
)
7709 int saved_global_expr
, bt
, bit_pos
, bit_size
;
7711 unsigned long long bit_mask
;
7718 /* compound literals must be allocated globally in this case */
7719 saved_global_expr
= global_expr
;
7722 global_expr
= saved_global_expr
;
7723 /* NOTE: symbols are accepted */
7724 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) != VT_CONST
)
7725 error("initializer element is not constant");
7733 /* XXX: not portable */
7734 /* XXX: generate error if incorrect relocation */
7735 gen_assign_cast(type
);
7736 bt
= type
->t
& VT_BTYPE
;
7737 ptr
= sec
->data
+ c
;
7738 /* XXX: make code faster ? */
7739 if (!(type
->t
& VT_BITFIELD
)) {
7744 bit_pos
= (vtop
->type
.t
>> VT_STRUCT_SHIFT
) & 0x3f;
7745 bit_size
= (vtop
->type
.t
>> (VT_STRUCT_SHIFT
+ 6)) & 0x3f;
7746 bit_mask
= (1LL << bit_size
) - 1;
7748 if ((vtop
->r
& VT_SYM
) &&
7754 (bt
== VT_INT
&& bit_size
!= 32)))
7755 error("initializer element is not computable at load time");
7758 *(char *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
7761 *(short *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
7764 *(double *)ptr
= vtop
->c
.d
;
7767 *(long double *)ptr
= vtop
->c
.ld
;
7770 *(long long *)ptr
|= (vtop
->c
.ll
& bit_mask
) << bit_pos
;
7773 if (vtop
->r
& VT_SYM
) {
7774 greloc(sec
, vtop
->sym
, c
, R_DATA_32
);
7776 *(int *)ptr
|= (vtop
->c
.i
& bit_mask
) << bit_pos
;
7781 vset(type
, VT_LOCAL
, c
);
7788 /* put zeros for variable based init */
7789 static void init_putz(CType
*t
, Section
*sec
, unsigned long c
, int size
)
7794 /* nothing to do because globals are already set to zero */
7796 gfunc_start(&gf
, FUNC_CDECL
);
7803 vpush_global_sym(&func_old_type
, TOK_memset
);
7808 /* 't' contains the type and storage info. 'c' is the offset of the
7809 object in section 'sec'. If 'sec' is NULL, it means stack based
7810 allocation. 'first' is true if array '{' must be read (multi
7811 dimension implicit array init handling). 'size_only' is true if
7812 size only evaluation is wanted (only for arrays). */
7813 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
7814 int first
, int size_only
)
7816 int index
, array_length
, n
, no_oblock
, nb
, parlevel
, i
;
7817 int size1
, align1
, expr_type
;
7821 if (type
->t
& VT_ARRAY
) {
7825 t1
= pointed_type(type
);
7826 size1
= type_size(t1
, &align1
);
7829 if ((first
&& tok
!= TOK_LSTR
&& tok
!= TOK_STR
) ||
7835 /* only parse strings here if correct type (otherwise: handle
7836 them as ((w)char *) expressions */
7837 if ((tok
== TOK_LSTR
&&
7838 (t1
->t
& VT_BTYPE
) == VT_INT
) ||
7840 (t1
->t
& VT_BTYPE
) == VT_BYTE
)) {
7841 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
7846 /* compute maximum number of chars wanted */
7848 cstr_len
= cstr
->size
;
7850 cstr_len
= cstr
->size
/ sizeof(int);
7853 if (n
>= 0 && nb
> (n
- array_length
))
7854 nb
= n
- array_length
;
7857 warning("initializer-string for array is too long");
7858 /* in order to go faster for common case (char
7859 string in global variable, we handle it
7861 if (sec
&& tok
== TOK_STR
&& size1
== 1) {
7862 memcpy(sec
->data
+ c
+ array_length
, cstr
->data
, nb
);
7866 ch
= ((unsigned char *)cstr
->data
)[i
];
7868 ch
= ((int *)cstr
->data
)[i
];
7869 init_putv(t1
, sec
, c
+ (array_length
+ i
) * size1
,
7877 /* only add trailing zero if enough storage (no
7878 warning in this case since it is standard) */
7879 if (n
< 0 || array_length
< n
) {
7881 init_putv(t1
, sec
, c
+ (array_length
* size1
), 0, EXPR_VAL
);
7887 while (tok
!= '}') {
7888 decl_designator(type
, sec
, c
, &index
, NULL
, size_only
);
7889 if (n
>= 0 && index
>= n
)
7890 error("index too large");
7891 /* must put zero in holes (note that doing it that way
7892 ensures that it even works with designators) */
7893 if (!size_only
&& array_length
< index
) {
7894 init_putz(t1
, sec
, c
+ array_length
* size1
,
7895 (index
- array_length
) * size1
);
7898 if (index
> array_length
)
7899 array_length
= index
;
7900 /* special test for multi dimensional arrays (may not
7901 be strictly correct if designators are used at the
7903 if (index
>= n
&& no_oblock
)
7912 /* put zeros at the end */
7913 if (!size_only
&& n
>= 0 && array_length
< n
) {
7914 init_putz(t1
, sec
, c
+ array_length
* size1
,
7915 (n
- array_length
) * size1
);
7917 /* patch type size if needed */
7919 s
->c
= array_length
;
7920 } else if ((type
->t
& VT_BTYPE
) == VT_STRUCT
&&
7921 (sec
|| !first
|| tok
== '{')) {
7924 /* NOTE: the previous test is a specific case for automatic
7925 struct/union init */
7926 /* XXX: union needs only one init */
7928 /* XXX: this test is incorrect for local initializers
7929 beginning with ( without {. It would be much more difficult
7930 to do it correctly (ideally, the expression parser should
7931 be used in all cases) */
7937 while (tok
== '(') {
7941 if (!parse_btype(&type1
, &ad1
))
7943 type_decl(&type1
, &ad1
, &n
, TYPE_ABSTRACT
);
7944 if (!is_compatible_types(type
, &type1
))
7945 error("invalid type for cast");
7949 if (first
|| tok
== '{') {
7958 while (tok
!= '}') {
7959 decl_designator(type
, sec
, c
, NULL
, &f
, size_only
);
7961 if (!size_only
&& array_length
< index
) {
7962 init_putz(type
, sec
, c
+ array_length
,
7963 index
- array_length
);
7965 index
= index
+ type_size(&f
->type
, &align1
);
7966 if (index
> array_length
)
7967 array_length
= index
;
7969 if (no_oblock
&& f
== NULL
)
7975 /* put zeros at the end */
7976 if (!size_only
&& array_length
< n
) {
7977 init_putz(type
, sec
, c
+ array_length
,
7986 } else if (tok
== '{') {
7988 decl_initializer(type
, sec
, c
, first
, size_only
);
7990 } else if (size_only
) {
7991 /* just skip expression */
7993 while ((parlevel
> 0 || (tok
!= '}' && tok
!= ',')) &&
7997 else if (tok
== ')')
8002 /* currently, we always use constant expression for globals
8003 (may change for scripting case) */
8004 expr_type
= EXPR_CONST
;
8006 expr_type
= EXPR_ANY
;
8007 init_putv(type
, sec
, c
, 0, expr_type
);
8011 /* parse an initializer for type 't' if 'has_init' is non zero, and
8012 allocate space in local or global data space ('r' is either
8013 VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
8014 variable 'v' of scope 'scope' is declared before initializers are
8015 parsed. If 'v' is zero, then a reference to the new object is put
8016 in the value stack. If 'has_init' is 2, a special parsing is done
8017 to handle string constants. */
8018 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
8019 int has_init
, int v
, int scope
)
8021 int size
, align
, addr
, data_offset
;
8023 ParseState saved_parse_state
;
8024 TokenString init_str
;
8027 size
= type_size(type
, &align
);
8028 /* If unknown size, we must evaluate it before
8029 evaluating initializers because
8030 initializers can generate global data too
8031 (e.g. string pointers or ISOC99 compound
8032 literals). It also simplifies local
8033 initializers handling */
8034 tok_str_new(&init_str
);
8037 error("unknown type size");
8038 /* get all init string */
8039 if (has_init
== 2) {
8040 /* only get strings */
8041 while (tok
== TOK_STR
|| tok
== TOK_LSTR
) {
8042 tok_str_add_tok(&init_str
);
8047 while (level
> 0 || (tok
!= ',' && tok
!= ';')) {
8049 error("unexpected end of file in initializer");
8050 tok_str_add_tok(&init_str
);
8053 else if (tok
== '}') {
8061 tok_str_add(&init_str
, -1);
8062 tok_str_add(&init_str
, 0);
8065 save_parse_state(&saved_parse_state
);
8067 macro_ptr
= init_str
.str
;
8069 decl_initializer(type
, NULL
, 0, 1, 1);
8070 /* prepare second initializer parsing */
8071 macro_ptr
= init_str
.str
;
8074 /* if still unknown size, error */
8075 size
= type_size(type
, &align
);
8077 error("unknown type size");
8079 /* take into account specified alignment if bigger */
8080 if (ad
->aligned
> align
)
8081 align
= ad
->aligned
;
8082 if ((r
& VT_VALMASK
) == VT_LOCAL
) {
8084 if (do_bounds_check
&& (type
->t
& VT_ARRAY
))
8086 loc
= (loc
- size
) & -align
;
8088 /* handles bounds */
8089 /* XXX: currently, since we do only one pass, we cannot track
8090 '&' operators, so we add only arrays */
8091 if (do_bounds_check
&& (type
->t
& VT_ARRAY
)) {
8092 unsigned long *bounds_ptr
;
8093 /* add padding between regions */
8095 /* then add local bound info */
8096 bounds_ptr
= section_ptr_add(lbounds_section
, 2 * sizeof(unsigned long));
8097 bounds_ptr
[0] = addr
;
8098 bounds_ptr
[1] = size
;
8101 /* local variable */
8102 sym_push(v
, type
, r
, addr
);
8104 /* push local reference */
8105 vset(type
, r
, addr
);
8111 if (v
&& scope
== VT_CONST
) {
8112 /* see if the symbol was already defined */
8115 if (!is_compatible_types(&sym
->type
, type
))
8116 error("incompatible types for redefinition of '%s'",
8117 get_tok_str(v
, NULL
));
8118 if (sym
->type
.t
& VT_EXTERN
) {
8119 /* if the variable is extern, it was not allocated */
8120 sym
->type
.t
&= ~VT_EXTERN
;
8122 /* we accept several definitions of the same
8123 global variable. this is tricky, because we
8124 must play with the SHN_COMMON type of the symbol */
8125 /* XXX: should check if the variable was already
8126 initialized. It is incorrect to initialized it
8128 /* no init data, we won't add more to the symbol */
8135 /* allocate symbol in corresponding section */
8142 data_offset
= sec
->data_offset
;
8143 data_offset
= (data_offset
+ align
- 1) & -align
;
8145 /* very important to increment global pointer at this time
8146 because initializers themselves can create new initializers */
8147 data_offset
+= size
;
8148 /* add padding if bound check */
8149 if (do_bounds_check
)
8151 sec
->data_offset
= data_offset
;
8152 /* allocate section space to put the data */
8153 if (sec
->sh_type
!= SHT_NOBITS
&&
8154 data_offset
> sec
->data_allocated
)
8155 section_realloc(sec
, data_offset
);
8157 addr
= 0; /* avoid warning */
8161 if (scope
== VT_CONST
) {
8166 sym
= sym_push(v
, type
, r
| VT_SYM
, 0);
8168 /* update symbol definition */
8170 put_extern_sym(sym
, sec
, addr
, size
);
8173 /* put a common area */
8174 put_extern_sym(sym
, NULL
, align
, size
);
8175 /* XXX: find a nicer way */
8176 esym
= &((Elf32_Sym
*)symtab_section
->data
)[sym
->c
];
8177 esym
->st_shndx
= SHN_COMMON
;
8182 /* push global reference */
8183 sym
= get_sym_ref(type
, sec
, addr
, size
);
8185 vsetc(type
, VT_CONST
| VT_SYM
, &cval
);
8189 /* handles bounds now because the symbol must be defined
8190 before for the relocation */
8191 if (do_bounds_check
) {
8192 unsigned long *bounds_ptr
;
8194 greloc(bounds_section
, sym
, bounds_section
->data_offset
, R_DATA_32
);
8195 /* then add global bound info */
8196 bounds_ptr
= section_ptr_add(bounds_section
, 2 * sizeof(long));
8197 bounds_ptr
[0] = 0; /* relocated */
8198 bounds_ptr
[1] = size
;
8202 decl_initializer(type
, sec
, addr
, 1, 0);
8203 /* restore parse state if needed */
8205 tok_str_free(init_str
.str
);
8206 restore_parse_state(&saved_parse_state
);
8212 void put_func_debug(Sym
*sym
)
8217 /* XXX: we put here a dummy type */
8218 snprintf(buf
, sizeof(buf
), "%s:%c1",
8219 funcname
, sym
->type
.t
& VT_STATIC
? 'f' : 'F');
8220 put_stabs_r(buf
, N_FUN
, 0, file
->line_num
, 0,
8221 cur_text_section
, sym
->c
);
8226 /* not finished : try to put some local vars in registers */
8227 //#define CONFIG_REG_VARS
8229 #ifdef CONFIG_REG_VARS
8230 void add_var_ref(int t
)
8232 printf("%s:%d: &%s\n",
8233 file
->filename
, file
->line_num
,
8234 get_tok_str(t
, NULL
));
8237 /* first pass on a function with heuristic to extract variable usage
8238 and pointer references to local variables for register allocation */
8239 void analyse_function(void)
8246 /* any symbol coming after '&' is considered as being a
8247 variable whose reference is taken. It is highly unaccurate
8248 but it is difficult to do better without a complete parse */
8251 /* if '& number', then no need to examine next tokens */
8252 if (tok
== TOK_CINT
||
8254 tok
== TOK_CLLONG
||
8255 tok
== TOK_CULLONG
) {
8257 } else if (tok
>= TOK_UIDENT
) {
8258 /* if '& ident [' or '& ident ->', then ident address
8262 if (tok
!= '[' && tok
!= TOK_ARROW
)
8266 while (tok
!= '}' && tok
!= ';' &&
8267 !((tok
== ',' || tok
== ')') && level
== 0)) {
8268 if (tok
>= TOK_UIDENT
) {
8270 } else if (tok
== '(') {
8272 } else if (tok
== ')') {
8285 /* parse an old style function declaration list */
8286 /* XXX: check multiple parameter */
8287 static void func_decl_list(Sym
*func_sym
)
8294 /* parse each declaration */
8295 while (tok
!= '{' && tok
!= ';' && tok
!= ',' && tok
!= TOK_EOF
) {
8296 if (!parse_btype(&btype
, &ad
))
8297 expect("declaration list");
8298 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
8299 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
8301 /* we accept no variable after */
8305 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
8306 /* find parameter in function parameter list */
8309 if ((s
->v
& ~SYM_FIELD
) == v
)
8313 error("declaration for parameter '%s' but no such parameter",
8314 get_tok_str(v
, NULL
));
8316 /* check that no storage specifier except 'register' was given */
8317 if (type
.t
& VT_STORAGE
)
8318 error("storage class specified for '%s'", get_tok_str(v
, NULL
));
8319 convert_parameter_type(&type
);
8320 /* we can add the type (NOTE: it could be local to the function) */
8322 /* accept other parameters */
8333 /* 'l' is VT_LOCAL or VT_CONST to define default storage type */
8334 static void decl(int l
)
8342 if (!parse_btype(&btype
, &ad
)) {
8343 /* skip redundant ';' */
8344 /* XXX: find more elegant solution */
8349 /* special test for old K&R protos without explicit int
8350 type. Only accepted when defining global data */
8351 if (l
== VT_LOCAL
|| tok
< TOK_DEFINE
)
8355 if (((btype
.t
& VT_BTYPE
) == VT_ENUM
||
8356 (btype
.t
& VT_BTYPE
) == VT_STRUCT
) &&
8358 /* we accept no variable after */
8362 while (1) { /* iterate thru each declaration */
8364 type_decl(&type
, &ad
, &v
, TYPE_DIRECT
);
8368 type_to_str(buf
, sizeof(buf
), t
, get_tok_str(v
, NULL
));
8369 printf("type = '%s'\n", buf
);
8372 if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
8373 /* if old style function prototype, we accept a
8376 if (sym
->c
== FUNC_OLD
)
8377 func_decl_list(sym
);
8381 #ifdef CONFIG_REG_VARS
8382 TokenString func_str
;
8383 ParseState saved_parse_state
;
8388 error("cannot use local functions");
8389 if (!(type
.t
& VT_FUNC
))
8390 expect("function definition");
8391 /* XXX: cannot do better now: convert extern line to static inline */
8392 if ((type
.t
& (VT_EXTERN
| VT_INLINE
)) == (VT_EXTERN
| VT_INLINE
))
8393 type
.t
= (type
.t
& ~VT_EXTERN
) | VT_STATIC
;
8395 #ifdef CONFIG_REG_VARS
8396 /* parse all function code and record it */
8398 tok_str_new(&func_str
);
8404 error("unexpected end of file");
8405 tok_str_add_tok(&func_str
);
8410 } else if (t
== '}') {
8412 if (block_level
== 0)
8416 tok_str_add(&func_str
, -1);
8417 tok_str_add(&func_str
, 0);
8419 save_parse_state(&saved_parse_state
);
8421 macro_ptr
= func_str
.str
;
8426 /* compute text section */
8427 cur_text_section
= ad
.section
;
8428 if (!cur_text_section
)
8429 cur_text_section
= text_section
;
8430 ind
= cur_text_section
->data_offset
;
8431 funcname
= get_tok_str(v
, NULL
);
8434 /* if symbol is already defined, then put complete type */
8437 /* put function symbol */
8438 sym
= global_identifier_push(v
, type
.t
, 0);
8439 sym
->type
.ref
= type
.ref
;
8441 /* NOTE: we patch the symbol size later */
8442 put_extern_sym(sym
, cur_text_section
, ind
, 0);
8444 sym
->r
= VT_SYM
| VT_CONST
;
8445 /* put debug symbol */
8447 put_func_debug(sym
);
8448 /* push a dummy symbol to enable local sym storage */
8449 sym_push2(&local_stack
, SYM_FIELD
, 0, 0);
8450 gfunc_prolog(&type
);
8453 #ifdef CONFIG_REG_VARS
8454 macro_ptr
= func_str
.str
;
8457 block(NULL
, NULL
, NULL
, NULL
, 0, 0);
8460 cur_text_section
->data_offset
= ind
;
8461 label_pop(&global_label_stack
, NULL
);
8462 sym_pop(&local_stack
, NULL
); /* reset local stack */
8463 /* end of function */
8464 /* patch symbol size */
8465 ((Elf32_Sym
*)symtab_section
->data
)[sym
->c
].st_size
=
8468 put_stabn(N_FUN
, 0, 0, ind
- func_ind
);
8470 funcname
= ""; /* for safety */
8471 func_vt
.t
= VT_VOID
; /* for safety */
8472 ind
= 0; /* for safety */
8474 #ifdef CONFIG_REG_VARS
8475 tok_str_free(func_str
.str
);
8476 restore_parse_state(&saved_parse_state
);
8480 if (btype
.t
& VT_TYPEDEF
) {
8481 /* save typedefed type */
8482 /* XXX: test storage specifiers ? */
8483 sym
= sym_push(v
, &type
, 0, 0);
8484 sym
->type
.t
|= VT_TYPEDEF
;
8485 } else if ((type
.t
& VT_BTYPE
) == VT_FUNC
) {
8486 /* external function definition */
8487 external_sym(v
, &type
, 0);
8489 /* not lvalue if array */
8491 if (!(type
.t
& VT_ARRAY
))
8492 r
|= lvalue_type(type
.t
);
8493 has_init
= (tok
== '=');
8494 if ((btype
.t
& VT_EXTERN
) ||
8495 ((type
.t
& VT_ARRAY
) && (type
.t
& VT_STATIC
) &&
8496 !has_init
&& l
== VT_CONST
&& type
.ref
->c
< 0)) {
8497 /* external variable */
8498 /* NOTE: as GCC, uninitialized global static
8499 arrays of null size are considered as
8501 external_sym(v
, &type
, r
);
8503 if (type
.t
& VT_STATIC
)
8509 decl_initializer_alloc(&type
, &ad
, r
,
8523 /* better than nothing, but needs extension to handle '-E' option
8525 static void preprocess_init(TCCState
*s1
)
8527 s1
->include_stack_ptr
= s1
->include_stack
;
8528 /* XXX: move that before to avoid having to initialize
8529 file->ifdef_stack_ptr ? */
8530 s1
->ifdef_stack_ptr
= s1
->ifdef_stack
;
8531 file
->ifdef_stack_ptr
= s1
->ifdef_stack_ptr
;
8533 /* XXX: not ANSI compliant: bound checking says error */
8537 /* compile the C file opened in 'file'. Return non zero if errors. */
8538 static int tcc_compile(TCCState
*s1
)
8542 volatile int section_sym
;
8545 printf("%s: **** new file\n", file
->filename
);
8547 preprocess_init(s1
);
8550 anon_sym
= SYM_FIRST_ANOM
;
8552 /* file info: full path + filename */
8553 section_sym
= 0; /* avoid warning */
8555 section_sym
= put_elf_sym(symtab_section
, 0, 0,
8556 ELF32_ST_INFO(STB_LOCAL
, STT_SECTION
), 0,
8557 text_section
->sh_num
, NULL
);
8558 getcwd(buf
, sizeof(buf
));
8559 pstrcat(buf
, sizeof(buf
), "/");
8560 put_stabs_r(buf
, N_SO
, 0, 0,
8561 text_section
->data_offset
, text_section
, section_sym
);
8562 put_stabs_r(file
->filename
, N_SO
, 0, 0,
8563 text_section
->data_offset
, text_section
, section_sym
);
8565 /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
8566 symbols can be safely used */
8567 put_elf_sym(symtab_section
, 0, 0,
8568 ELF32_ST_INFO(STB_LOCAL
, STT_FILE
), 0,
8569 SHN_ABS
, file
->filename
);
8571 /* define some often used types */
8572 int_type
.t
= VT_INT
;
8574 char_pointer_type
.t
= VT_BYTE
;
8575 mk_pointer(&char_pointer_type
);
8577 func_old_type
.t
= VT_FUNC
;
8578 func_old_type
.ref
= sym_push(SYM_FIELD
, &int_type
, FUNC_CDECL
, FUNC_OLD
);
8581 /* define 'void *alloca(unsigned int)' builtin function */
8586 sym
= sym_push(p
, mk_pointer(VT_VOID
), FUNC_CDECL
, FUNC_NEW
);
8587 s1
= sym_push(SYM_FIELD
, VT_UNSIGNED
| VT_INT
, 0, 0);
8590 sym_push(TOK_alloca
, VT_FUNC
| (p
<< VT_STRUCT_SHIFT
), VT_CONST
, 0);
8594 define_start
= define_stack
;
8596 if (setjmp(s1
->error_jmp_buf
) == 0) {
8598 s1
->error_set_jmp_enabled
= 1;
8600 ch
= file
->buf_ptr
[0];
8601 tok_flags
= TOK_FLAG_BOL
| TOK_FLAG_BOF
;
8602 parse_flags
= PARSE_FLAG_PREPROCESS
| PARSE_FLAG_TOK_NUM
;
8606 expect("declaration");
8608 /* end of translation unit info */
8610 put_stabs_r(NULL
, N_SO
, 0, 0,
8611 text_section
->data_offset
, text_section
, section_sym
);
8614 s1
->error_set_jmp_enabled
= 0;
8616 /* reset define stack, but leave -Dsymbols (may be incorrect if
8617 they are undefined) */
8618 free_defines(define_start
);
8620 sym_pop(&global_stack
, NULL
);
8622 return s1
->nb_errors
!= 0 ? -1 : 0;
8626 int tcc_compile_string(TCCState
*s
, const char *str
)
8628 BufferedFile bf1
, *bf
= &bf1
;
8632 /* init file structure */
8634 /* XXX: avoid copying */
8636 buf
= tcc_malloc(len
+ 1);
8639 memcpy(buf
, str
, len
);
8642 bf
->buf_end
= buf
+ len
;
8643 pstrcpy(bf
->filename
, sizeof(bf
->filename
), "<string>");
8647 ret
= tcc_compile(s
);
8651 /* currently, no need to close */
8656 /* define a preprocessor symbol. A value can also be provided with the '=' operator */
8657 void tcc_define_symbol(TCCState
*s1
, const char *sym
, const char *value
)
8659 BufferedFile bf1
, *bf
= &bf1
;
8661 pstrcpy(bf
->buffer
, IO_BUF_SIZE
, sym
);
8662 pstrcat(bf
->buffer
, IO_BUF_SIZE
, " ");
8666 pstrcat(bf
->buffer
, IO_BUF_SIZE
, value
);
8668 /* init file structure */
8670 bf
->buf_ptr
= bf
->buffer
;
8671 bf
->buf_end
= bf
->buffer
+ strlen(bf
->buffer
);
8672 *bf
->buf_end
= CH_EOB
;
8673 bf
->filename
[0] = '\0';
8677 s1
->include_stack_ptr
= s1
->include_stack
;
8679 /* parse with define parser */
8680 ch
= file
->buf_ptr
[0];
8686 /* undefine a preprocessor symbol */
8687 void tcc_undefine_symbol(TCCState
*s1
, const char *sym
)
8691 ts
= tok_alloc(sym
, strlen(sym
));
8692 s
= define_find(ts
->tok
);
8693 /* undefine symbol by putting an invalid name */
8698 #ifdef CONFIG_TCC_ASM
8700 #include "i386-asm.c"
8704 static void asm_instr(void)
8706 error("inline asm() not supported");
8712 /* print the position in the source file of PC value 'pc' by reading
8713 the stabs debug information */
8714 static void rt_printline(unsigned long wanted_pc
)
8716 Stab_Sym
*sym
, *sym_end
;
8717 char func_name
[128], last_func_name
[128];
8718 unsigned long func_addr
, last_pc
, pc
;
8719 const char *incl_files
[INCLUDE_STACK_SIZE
];
8720 int incl_index
, len
, last_line_num
, i
;
8721 const char *str
, *p
;
8723 fprintf(stderr
, "0x%08lx:", wanted_pc
);
8725 func_name
[0] = '\0';
8728 last_func_name
[0] = '\0';
8729 last_pc
= 0xffffffff;
8731 sym
= (Stab_Sym
*)stab_section
->data
+ 1;
8732 sym_end
= (Stab_Sym
*)(stab_section
->data
+ stab_section
->data_offset
);
8733 while (sym
< sym_end
) {
8734 switch(sym
->n_type
) {
8735 /* function start or end */
8737 if (sym
->n_strx
== 0) {
8738 /* we test if between last line and end of function */
8739 pc
= sym
->n_value
+ func_addr
;
8740 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
8742 func_name
[0] = '\0';
8745 str
= stabstr_section
->data
+ sym
->n_strx
;
8746 p
= strchr(str
, ':');
8748 pstrcpy(func_name
, sizeof(func_name
), str
);
8751 if (len
> sizeof(func_name
) - 1)
8752 len
= sizeof(func_name
) - 1;
8753 memcpy(func_name
, str
, len
);
8754 func_name
[len
] = '\0';
8756 func_addr
= sym
->n_value
;
8759 /* line number info */
8761 pc
= sym
->n_value
+ func_addr
;
8762 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
8765 last_line_num
= sym
->n_desc
;
8767 strcpy(last_func_name
, func_name
);
8771 str
= stabstr_section
->data
+ sym
->n_strx
;
8773 if (incl_index
< INCLUDE_STACK_SIZE
) {
8774 incl_files
[incl_index
++] = str
;
8782 if (sym
->n_strx
== 0) {
8783 incl_index
= 0; /* end of translation unit */
8785 str
= stabstr_section
->data
+ sym
->n_strx
;
8786 /* do not add path */
8788 if (len
> 0 && str
[len
- 1] != '/')
8796 /* second pass: we try symtab symbols (no line number info) */
8799 Elf32_Sym
*sym
, *sym_end
;
8802 sym_end
= (Elf32_Sym
*)(symtab_section
->data
+ symtab_section
->data_offset
);
8803 for(sym
= (Elf32_Sym
*)symtab_section
->data
+ 1;
8806 type
= ELF32_ST_TYPE(sym
->st_info
);
8807 if (type
== STT_FUNC
) {
8808 if (wanted_pc
>= sym
->st_value
&&
8809 wanted_pc
< sym
->st_value
+ sym
->st_size
) {
8810 pstrcpy(last_func_name
, sizeof(last_func_name
),
8811 strtab_section
->data
+ sym
->st_name
);
8817 /* did not find any info: */
8818 fprintf(stderr
, " ???\n");
8821 if (last_func_name
[0] != '\0') {
8822 fprintf(stderr
, " %s()", last_func_name
);
8824 if (incl_index
> 0) {
8825 fprintf(stderr
, " (%s:%d",
8826 incl_files
[incl_index
- 1], last_line_num
);
8827 for(i
= incl_index
- 2; i
>= 0; i
--)
8828 fprintf(stderr
, ", included from %s", incl_files
[i
]);
8829 fprintf(stderr
, ")");
8831 fprintf(stderr
, "\n");
8838 /* fix for glibc 2.1 */
8844 /* return the PC at frame level 'level'. Return non zero if not found */
8845 static int rt_get_caller_pc(unsigned long *paddr
,
8846 ucontext_t
*uc
, int level
)
8853 *paddr
= uc
->uc_mcontext
.mc_eip
;
8855 *paddr
= uc
->uc_mcontext
.gregs
[REG_EIP
];
8860 fp
= uc
->uc_mcontext
.mc_ebp
;
8862 fp
= uc
->uc_mcontext
.gregs
[REG_EBP
];
8864 for(i
=1;i
<level
;i
++) {
8865 /* XXX: check address validity with program info */
8866 if (fp
<= 0x1000 || fp
>= 0xc0000000)
8868 fp
= ((unsigned long *)fp
)[0];
8870 *paddr
= ((unsigned long *)fp
)[1];
8875 #error add arch specific rt_get_caller_pc()
8878 /* emit a run time error at position 'pc' */
8879 void rt_error(ucontext_t
*uc
, const char *fmt
, ...)
8886 fprintf(stderr
, "Runtime error: ");
8887 vfprintf(stderr
, fmt
, ap
);
8888 fprintf(stderr
, "\n");
8889 for(i
=0;i
<num_callers
;i
++) {
8890 if (rt_get_caller_pc(&pc
, uc
, i
) < 0)
8893 fprintf(stderr
, "at ");
8895 fprintf(stderr
, "by ");
8902 /* signal handler for fatal errors */
8903 static void sig_error(int signum
, siginfo_t
*siginf
, void *puc
)
8905 ucontext_t
*uc
= puc
;
8909 switch(siginf
->si_code
) {
8912 rt_error(uc
, "division by zero");
8915 rt_error(uc
, "floating point exception");
8921 if (rt_bound_error_msg
&& *rt_bound_error_msg
)
8922 rt_error(uc
, *rt_bound_error_msg
);
8924 rt_error(uc
, "dereferencing invalid pointer");
8927 rt_error(uc
, "illegal instruction");
8930 rt_error(uc
, "abort() called");
8933 rt_error(uc
, "caught signal %d", signum
);
8940 /* do all relocations (needed before using tcc_get_symbol()) */
8941 int tcc_relocate(TCCState
*s1
)
8948 tcc_add_runtime(s1
);
8950 relocate_common_syms();
8952 /* compute relocation address : section are relocated in place. We
8953 also alloc the bss space */
8954 for(i
= 1; i
< s1
->nb_sections
; i
++) {
8955 s
= s1
->sections
[i
];
8956 if (s
->sh_flags
& SHF_ALLOC
) {
8957 if (s
->sh_type
== SHT_NOBITS
)
8958 s
->data
= tcc_mallocz(s
->data_offset
);
8959 s
->sh_addr
= (unsigned long)s
->data
;
8963 relocate_syms(s1
, 1);
8965 if (s1
->nb_errors
!= 0)
8968 /* relocate each section */
8969 for(i
= 1; i
< s1
->nb_sections
; i
++) {
8970 s
= s1
->sections
[i
];
8972 relocate_section(s1
, s
);
8977 /* launch the compiled program with the given arguments */
8978 int tcc_run(TCCState
*s1
, int argc
, char **argv
)
8980 int (*prog_main
)(int, char **);
8982 if (tcc_relocate(s1
) < 0)
8985 prog_main
= tcc_get_symbol(s1
, "main");
8989 error("debug mode currently not available for Windows");
8991 struct sigaction sigact
;
8992 /* install TCC signal handlers to print debug info on fatal
8994 sigact
.sa_flags
= SA_SIGINFO
| SA_RESETHAND
;
8995 sigact
.sa_sigaction
= sig_error
;
8996 sigemptyset(&sigact
.sa_mask
);
8997 sigaction(SIGFPE
, &sigact
, NULL
);
8998 sigaction(SIGILL
, &sigact
, NULL
);
8999 sigaction(SIGSEGV
, &sigact
, NULL
);
9000 sigaction(SIGBUS
, &sigact
, NULL
);
9001 sigaction(SIGABRT
, &sigact
, NULL
);
9005 #ifdef CONFIG_TCC_BCHECK
9006 if (do_bounds_check
) {
9007 void (*bound_init
)(void);
9009 /* set error function */
9010 rt_bound_error_msg
= (void *)tcc_get_symbol(s1
, "__bound_error_msg");
9012 /* XXX: use .init section so that it also work in binary ? */
9013 bound_init
= (void *)tcc_get_symbol(s1
, "__bound_init");
9017 return (*prog_main
)(argc
, argv
);
9020 TCCState
*tcc_new(void)
9027 s
= tcc_mallocz(sizeof(TCCState
));
9031 s
->output_type
= TCC_OUTPUT_MEMORY
;
9033 /* init isid table */
9035 isidnum_table
[i
] = isid(i
) || isnum(i
);
9037 /* add all tokens */
9039 memset(hash_ident
, 0, TOK_HASH_SIZE
* sizeof(TokenSym
*));
9041 tok_ident
= TOK_IDENT
;
9050 ts
= tok_alloc(p
, r
- p
- 1);
9054 /* we add dummy defines for some special macros to speed up tests
9055 and to have working defined() */
9056 define_push(TOK___LINE__
, MACRO_OBJ
, NULL
, NULL
);
9057 define_push(TOK___FILE__
, MACRO_OBJ
, NULL
, NULL
);
9058 define_push(TOK___DATE__
, MACRO_OBJ
, NULL
, NULL
);
9059 define_push(TOK___TIME__
, MACRO_OBJ
, NULL
, NULL
);
9061 /* standard defines */
9062 tcc_define_symbol(s
, "__STDC__", NULL
);
9063 #if defined(TCC_TARGET_I386)
9064 tcc_define_symbol(s
, "__i386__", NULL
);
9067 tcc_define_symbol(s
, "__linux__", NULL
);
9068 tcc_define_symbol(s
, "linux", NULL
);
9070 /* tiny C specific defines */
9071 tcc_define_symbol(s
, "__TINYC__", NULL
);
9073 /* tiny C & gcc defines */
9074 tcc_define_symbol(s
, "__SIZE_TYPE__", "unsigned int");
9075 tcc_define_symbol(s
, "__PTRDIFF_TYPE__", "int");
9076 tcc_define_symbol(s
, "__WCHAR_TYPE__", "int");
9078 /* default library paths */
9079 tcc_add_library_path(s
, "/usr/local/lib");
9080 tcc_add_library_path(s
, "/usr/lib");
9081 tcc_add_library_path(s
, "/lib");
9083 /* no section zero */
9084 dynarray_add((void ***)&s
->sections
, &s
->nb_sections
, NULL
);
9086 /* create standard sections */
9087 text_section
= new_section(s
, ".text", SHT_PROGBITS
, SHF_ALLOC
| SHF_EXECINSTR
);
9088 data_section
= new_section(s
, ".data", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
9089 bss_section
= new_section(s
, ".bss", SHT_NOBITS
, SHF_ALLOC
| SHF_WRITE
);
9091 /* symbols are always generated for linking stage */
9092 symtab_section
= new_symtab(s
, ".symtab", SHT_SYMTAB
, 0,
9094 ".hashtab", SHF_PRIVATE
);
9095 strtab_section
= symtab_section
->link
;
9097 /* private symbol table for dynamic symbols */
9098 s
->dynsymtab_section
= new_symtab(s
, ".dynsymtab", SHT_SYMTAB
, SHF_PRIVATE
,
9100 ".dynhashtab", SHF_PRIVATE
);
9104 void tcc_delete(TCCState
*s1
)
9108 /* free -D defines */
9112 n
= tok_ident
- TOK_IDENT
;
9113 for(i
= 0; i
< n
; i
++)
9114 tcc_free(table_ident
[i
]);
9115 tcc_free(table_ident
);
9117 /* free all sections */
9119 free_section(symtab_section
->hash
);
9121 free_section(s1
->dynsymtab_section
->hash
);
9122 free_section(s1
->dynsymtab_section
->link
);
9123 free_section(s1
->dynsymtab_section
);
9125 for(i
= 1; i
< s1
->nb_sections
; i
++)
9126 free_section(s1
->sections
[i
]);
9127 tcc_free(s1
->sections
);
9129 /* free loaded dlls array */
9130 for(i
= 0; i
< s1
->nb_loaded_dlls
; i
++)
9131 tcc_free(s1
->loaded_dlls
[i
]);
9132 tcc_free(s1
->loaded_dlls
);
9135 for(i
= 0; i
< s1
->nb_library_paths
; i
++)
9136 tcc_free(s1
->library_paths
[i
]);
9137 tcc_free(s1
->library_paths
);
9139 /* cached includes */
9140 for(i
= 0; i
< s1
->nb_cached_includes
; i
++)
9141 tcc_free(s1
->cached_includes
[i
]);
9142 tcc_free(s1
->cached_includes
);
9144 for(i
= 0; i
< s1
->nb_include_paths
; i
++)
9145 tcc_free(s1
->include_paths
[i
]);
9146 tcc_free(s1
->include_paths
);
9148 for(i
= 0; i
< s1
->nb_sysinclude_paths
; i
++)
9149 tcc_free(s1
->sysinclude_paths
[i
]);
9150 tcc_free(s1
->sysinclude_paths
);
9155 int tcc_add_include_path(TCCState
*s1
, const char *pathname
)
9159 pathname1
= tcc_strdup(pathname
);
9160 dynarray_add((void ***)&s1
->include_paths
, &s1
->nb_include_paths
, pathname1
);
9164 int tcc_add_sysinclude_path(TCCState
*s1
, const char *pathname
)
9168 pathname1
= tcc_strdup(pathname
);
9169 dynarray_add((void ***)&s1
->sysinclude_paths
, &s1
->nb_sysinclude_paths
, pathname1
);
9173 static int tcc_add_file_internal(TCCState
*s1
, const char *filename
, int flags
)
9175 const char *ext
, *filename1
;
9178 BufferedFile
*saved_file
;
9180 /* find source file type with extension */
9181 filename1
= strrchr(filename
, '/');
9185 filename1
= filename
;
9186 ext
= strrchr(filename1
, '.');
9192 file
= tcc_open(s1
, filename
);
9194 if (flags
& AFF_PRINT_ERROR
) {
9195 error_noabort("file '%s' not found", filename
);
9201 if (!ext
|| !strcmp(ext
, "c")) {
9202 /* C file assumed */
9203 ret
= tcc_compile(s1
);
9205 #ifdef CONFIG_TCC_ASM
9206 if (!strcmp(ext
, "S")) {
9207 /* preprocessed assembler */
9208 ret
= tcc_assemble(s1
, 1);
9209 } else if (!strcmp(ext
, "s")) {
9210 /* non preprocessed assembler */
9211 ret
= tcc_assemble(s1
, 0);
9216 /* assume executable format: auto guess file type */
9217 if (read(fd
, &ehdr
, sizeof(ehdr
)) != sizeof(ehdr
)) {
9218 error_noabort("could not read header");
9221 lseek(fd
, 0, SEEK_SET
);
9223 if (ehdr
.e_ident
[0] == ELFMAG0
&&
9224 ehdr
.e_ident
[1] == ELFMAG1
&&
9225 ehdr
.e_ident
[2] == ELFMAG2
&&
9226 ehdr
.e_ident
[3] == ELFMAG3
) {
9227 file
->line_num
= 0; /* do not display line number if error */
9228 if (ehdr
.e_type
== ET_REL
) {
9229 ret
= tcc_load_object_file(s1
, fd
, 0);
9230 } else if (ehdr
.e_type
== ET_DYN
) {
9231 ret
= tcc_load_dll(s1
, fd
, filename
,
9232 (flags
& AFF_REFERENCED_DLL
) != 0);
9234 error_noabort("unrecognized ELF file");
9237 } else if (memcmp((char *)&ehdr
, ARMAG
, 8) == 0) {
9238 file
->line_num
= 0; /* do not display line number if error */
9239 ret
= tcc_load_archive(s1
, fd
);
9241 /* as GNU ld, consider it is an ld script if not recognized */
9242 ret
= tcc_load_ldscript(s1
);
9244 error_noabort("unrecognized file type");
9259 int tcc_add_file(TCCState
*s
, const char *filename
)
9261 return tcc_add_file_internal(s
, filename
, AFF_PRINT_ERROR
);
9264 int tcc_add_library_path(TCCState
*s
, const char *pathname
)
9268 pathname1
= tcc_strdup(pathname
);
9269 dynarray_add((void ***)&s
->library_paths
, &s
->nb_library_paths
, pathname1
);
9273 /* find and load a dll. Return non zero if not found */
9274 /* XXX: add '-rpath' option support ? */
9275 static int tcc_add_dll(TCCState
*s
, const char *filename
, int flags
)
9280 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
9281 snprintf(buf
, sizeof(buf
), "%s/%s",
9282 s
->library_paths
[i
], filename
);
9283 if (tcc_add_file_internal(s
, buf
, flags
) == 0)
9289 /* the library name is the same as the argument of the '-l' option */
9290 int tcc_add_library(TCCState
*s
, const char *libraryname
)
9296 /* first we look for the dynamic library if not static linking */
9297 if (!s
->static_link
) {
9298 snprintf(buf
, sizeof(buf
), "lib%s.so", libraryname
);
9299 /* if we output to memory, then we simply we dlopen(). */
9300 if (s
->output_type
== TCC_OUTPUT_MEMORY
) {
9301 /* Since the libc is already loaded, we don't need to load it again */
9302 if (!strcmp(libraryname
, "c"))
9304 h
= dlopen(buf
, RTLD_GLOBAL
| RTLD_LAZY
);
9308 if (tcc_add_dll(s
, buf
, 0) == 0)
9313 /* then we look for the static library */
9314 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
9315 snprintf(buf
, sizeof(buf
), "%s/lib%s.a",
9316 s
->library_paths
[i
], libraryname
);
9317 if (tcc_add_file_internal(s
, buf
, 0) == 0)
9323 int tcc_add_symbol(TCCState
*s
, const char *name
, unsigned long val
)
9325 add_elf_sym(symtab_section
, val
, 0,
9326 ELF32_ST_INFO(STB_GLOBAL
, STT_NOTYPE
),
9331 int tcc_set_output_type(TCCState
*s
, int output_type
)
9335 s
->output_type
= output_type
;
9338 /* default include paths */
9339 /* XXX: reverse order needed if -isystem support */
9340 tcc_add_sysinclude_path(s
, "/usr/local/include");
9341 tcc_add_sysinclude_path(s
, "/usr/include");
9342 snprintf(buf
, sizeof(buf
), "%s/include", tcc_lib_path
);
9343 tcc_add_sysinclude_path(s
, buf
);
9346 /* if bound checking, then add corresponding sections */
9347 #ifdef CONFIG_TCC_BCHECK
9348 if (do_bounds_check
) {
9350 tcc_define_symbol(s
, "__BOUNDS_CHECKING_ON", NULL
);
9351 /* create bounds sections */
9352 bounds_section
= new_section(s
, ".bounds",
9353 SHT_PROGBITS
, SHF_ALLOC
);
9354 lbounds_section
= new_section(s
, ".lbounds",
9355 SHT_PROGBITS
, SHF_ALLOC
);
9359 /* add debug sections */
9362 stab_section
= new_section(s
, ".stab", SHT_PROGBITS
, 0);
9363 stab_section
->sh_entsize
= sizeof(Stab_Sym
);
9364 stabstr_section
= new_section(s
, ".stabstr", SHT_STRTAB
, 0);
9365 put_elf_str(stabstr_section
, "");
9366 stab_section
->link
= stabstr_section
;
9367 /* put first entry */
9368 put_stabs("", 0, 0, 0, 0);
9371 /* add libc crt1/crti objects */
9372 if (output_type
== TCC_OUTPUT_EXE
||
9373 output_type
== TCC_OUTPUT_DLL
) {
9374 if (output_type
!= TCC_OUTPUT_DLL
)
9375 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crt1.o");
9376 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crti.o");
9381 #if !defined(LIBTCC)
9383 static int64_t getclock_us(void)
9388 return (tb
.time
* 1000LL + tb
.millitm
) * 1000LL;
9391 gettimeofday(&tv
, NULL
);
9392 return tv
.tv_sec
* 1000000LL + tv
.tv_usec
;
9398 printf("tcc version " TCC_VERSION
" - Tiny C Compiler - Copyright (C) 2001, 2002 Fabrice Bellard\n"
9399 "usage: tcc [-v] [-c] [-o outfile] [-Bdir] [-bench] [-Idir] [-Dsym[=val]] [-Usym]\n"
9400 " [-g] [-b] [-bt N] [-Ldir] [-llib] [-shared] [-static]\n"
9401 " [infile1 infile2...] [-run infile args...]\n"
9403 "General options:\n"
9404 " -v display current version\n"
9405 " -c compile only - generate an object file\n"
9406 " -o outfile set output filename\n"
9407 " -Bdir set tcc internal library path\n"
9408 " -bench output compilation statistics\n"
9409 " -run run compiled source\n"
9410 "Preprocessor options:\n"
9411 " -Idir add include path 'dir'\n"
9412 " -Dsym[=val] define 'sym' with value 'val'\n"
9413 " -Usym undefine 'sym'\n"
9415 " -Ldir add library path 'dir'\n"
9416 " -llib link with dynamic or static library 'lib'\n"
9417 " -shared generate a shared library\n"
9418 " -static static linking\n"
9419 " -r relocatable output\n"
9420 "Debugger options:\n"
9421 " -g generate runtime debug info\n"
9422 #ifdef CONFIG_TCC_BCHECK
9423 " -b compile with built-in memory and bounds checker (implies -g)\n"
9425 " -bt N show N callers in stack traces\n"
9429 #define TCC_OPTION_HAS_ARG 0x0001
9430 #define TCC_OPTION_NOSEP 0x0002 /* cannot have space before option and arg */
9432 typedef struct TCCOption
{
9459 TCC_OPTION_nostdinc
,
9460 TCC_OPTION_print_search_dirs
,
9461 TCC_OPTION_rdynamic
,
9466 static const TCCOption tcc_options
[] = {
9467 { "h", TCC_OPTION_HELP
, 0 },
9468 { "?", TCC_OPTION_HELP
, 0 },
9469 { "I", TCC_OPTION_I
, TCC_OPTION_HAS_ARG
},
9470 { "D", TCC_OPTION_D
, TCC_OPTION_HAS_ARG
},
9471 { "U", TCC_OPTION_U
, TCC_OPTION_HAS_ARG
},
9472 { "L", TCC_OPTION_L
, TCC_OPTION_HAS_ARG
},
9473 { "B", TCC_OPTION_B
, TCC_OPTION_HAS_ARG
},
9474 { "l", TCC_OPTION_l
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
9475 { "bench", TCC_OPTION_bench
, 0 },
9476 { "bt", TCC_OPTION_bt
, TCC_OPTION_HAS_ARG
},
9477 #ifdef CONFIG_TCC_BCHECK
9478 { "b", TCC_OPTION_b
, 0 },
9480 { "g", TCC_OPTION_g
, 0 },
9481 { "c", TCC_OPTION_c
, 0 },
9482 { "static", TCC_OPTION_static
, 0 },
9483 { "shared", TCC_OPTION_shared
, 0 },
9484 { "o", TCC_OPTION_o
, TCC_OPTION_HAS_ARG
},
9485 { "run", TCC_OPTION_run
, 0 },
9486 { "rdynamic", TCC_OPTION_rdynamic
, 0 }, /* currently ignored */
9487 { "r", TCC_OPTION_r
, 0 },
9488 { "W", TCC_OPTION_W
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
9489 { "O", TCC_OPTION_O
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
9490 { "m", TCC_OPTION_m
, TCC_OPTION_HAS_ARG
},
9491 { "f", TCC_OPTION_f
, TCC_OPTION_HAS_ARG
| TCC_OPTION_NOSEP
},
9492 { "nostdinc", TCC_OPTION_nostdinc
, 0 },
9493 { "print-search-dirs", TCC_OPTION_print_search_dirs
, 0 },
9494 { "v", TCC_OPTION_v
, 0 },
9498 int main(int argc
, char **argv
)
9501 int optind
, output_type
, multiple_files
, i
, reloc_output
;
9504 int nb_files
, nb_libraries
, nb_objfiles
, dminus
, ret
;
9505 char objfilename
[1024];
9506 int64_t start_time
= 0;
9507 const TCCOption
*popt
;
9508 const char *optarg
, *p1
, *r1
, *outfile
;
9509 int print_search_dirs
;
9512 output_type
= TCC_OUTPUT_EXE
;
9522 print_search_dirs
= 0;
9524 if (optind
>= argc
) {
9525 if (nb_files
== 0 && !print_search_dirs
)
9532 /* add a new file */
9533 dynarray_add((void ***)&files
, &nb_files
, r
);
9534 if (!multiple_files
) {
9536 /* argv[0] will be this file */
9540 /* find option in table (match only the first chars */
9545 error("invalid option -- '%s'", r
);
9558 if (popt
->flags
& TCC_OPTION_HAS_ARG
) {
9559 if (*r1
!= '\0' || (popt
->flags
& TCC_OPTION_NOSEP
)) {
9563 error("argument to '%s' is missing", r
);
9564 optarg
= argv
[optind
++];
9572 switch(popt
->index
) {
9573 case TCC_OPTION_HELP
:
9578 if (tcc_add_include_path(s
, optarg
) < 0)
9579 error("too many include paths");
9584 sym
= (char *)optarg
;
9585 value
= strchr(sym
, '=');
9590 tcc_define_symbol(s
, sym
, value
);
9594 tcc_undefine_symbol(s
, optarg
);
9597 tcc_add_library_path(s
, optarg
);
9600 /* set tcc utilities path (mainly for tcc development) */
9601 tcc_lib_path
= optarg
;
9604 dynarray_add((void ***)&files
, &nb_files
, r
);
9607 case TCC_OPTION_bench
:
9611 num_callers
= atoi(optarg
);
9613 #ifdef CONFIG_TCC_BCHECK
9615 do_bounds_check
= 1;
9624 output_type
= TCC_OUTPUT_OBJ
;
9626 case TCC_OPTION_static
:
9629 case TCC_OPTION_shared
:
9630 output_type
= TCC_OUTPUT_DLL
;
9637 /* generate a .o merging several output files */
9639 output_type
= TCC_OUTPUT_OBJ
;
9641 case TCC_OPTION_nostdinc
:
9644 case TCC_OPTION_print_search_dirs
:
9645 print_search_dirs
= 1;
9647 case TCC_OPTION_run
:
9649 output_type
= TCC_OUTPUT_MEMORY
;
9652 printf("tcc version %s\n", TCC_VERSION
);
9659 if (print_search_dirs
) {
9660 /* enough for Linux kernel */
9661 printf("install: %s/\n", tcc_lib_path
);
9665 nb_objfiles
= nb_files
- nb_libraries
;
9667 /* if outfile provided without other options, we output an
9669 if (outfile
&& output_type
== TCC_OUTPUT_MEMORY
)
9670 output_type
= TCC_OUTPUT_EXE
;
9672 /* check -c consistency : only single file handled. XXX: checks file type */
9673 if (output_type
== TCC_OUTPUT_OBJ
&& !reloc_output
) {
9674 /* accepts only a single input file */
9675 if (nb_objfiles
!= 1)
9676 error("cannot specify multiple files with -c");
9677 if (nb_libraries
!= 0)
9678 error("cannot specify libraries with -c");
9681 /* compute default outfile name */
9682 if (output_type
!= TCC_OUTPUT_MEMORY
&& !outfile
) {
9683 if (output_type
== TCC_OUTPUT_OBJ
&& !reloc_output
) {
9685 /* add .o extension */
9686 pstrcpy(objfilename
, sizeof(objfilename
) - 1, files
[0]);
9687 ext
= strrchr(objfilename
, '.');
9689 goto default_outfile
;
9690 strcpy(ext
+ 1, "o");
9693 pstrcpy(objfilename
, sizeof(objfilename
), "a.out");
9695 outfile
= objfilename
;
9699 start_time
= getclock_us();
9702 tcc_set_output_type(s
, output_type
);
9704 /* compile or add each files or library */
9705 for(i
= 0;i
< nb_files
; i
++) {
9706 const char *filename
;
9708 filename
= files
[i
];
9709 if (filename
[0] == '-') {
9710 if (tcc_add_library(s
, filename
+ 2) < 0)
9711 error("cannot find %s", filename
);
9713 if (tcc_add_file(s
, filename
) < 0) {
9720 /* free all files */
9725 total_time
= (double)(getclock_us() - start_time
) / 1000000.0;
9726 if (total_time
< 0.001)
9728 if (total_bytes
< 1)
9730 printf("%d idents, %d lines, %d bytes, %0.3f s, %d lines/s, %0.1f MB/s\n",
9731 tok_ident
- TOK_IDENT
, total_lines
, total_bytes
,
9732 total_time
, (int)(total_lines
/ total_time
),
9733 total_bytes
/ total_time
/ 1000000.0);
9736 if (s
->output_type
!= TCC_OUTPUT_MEMORY
) {
9737 tcc_output_file(s
, outfile
);
9740 ret
= tcc_run(s
, argc
- optind
, argv
+ optind
);
9743 /* XXX: cannot do it with bound checking because of the malloc hooks */
9744 if (!do_bounds_check
)
9749 printf("memory: %d bytes, max = %d bytes\n", mem_cur_size
, mem_max_size
);