2 * TCC - Tiny C Compiler
4 * Copyright (c) 2001-2004 Fabrice Bellard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 /********************************************************/
24 /* global variables */
26 /* display benchmark infos */
31 static struct BufferedFile
*file
;
34 static CString tokcstr
; /* current parsed string, if any */
35 /* additional informations about token */
37 #define TOK_FLAG_BOL 0x0001 /* beginning of line before */
38 #define TOK_FLAG_BOF 0x0002 /* beginning of file before */
39 #define TOK_FLAG_ENDIF 0x0004 /* a endif was found matching starting #ifdef */
40 #define TOK_FLAG_EOF 0x0008 /* end of file */
42 static int *macro_ptr
, *macro_ptr_allocated
;
43 static int *unget_saved_macro_ptr
;
44 static int unget_saved_buffer
[TOK_MAX_SIZE
+ 1];
45 static int unget_buffer_enabled
;
46 static int parse_flags
;
47 #define PARSE_FLAG_PREPROCESS 0x0001 /* activate preprocessing */
48 #define PARSE_FLAG_TOK_NUM 0x0002 /* return numbers instead of TOK_PPNUM */
49 #define PARSE_FLAG_LINEFEED 0x0004 /* line feed is returned as a
50 token. line feed is also
52 #define PARSE_FLAG_ASM_COMMENTS 0x0008 /* '#' can be used for line comment */
53 #define PARSE_FLAG_SPACES 0x0010 /* next() returns space tokens (for -E) */
55 static Section
*text_section
, *data_section
, *bss_section
; /* predefined sections */
56 static Section
*cur_text_section
; /* current section where function code is
59 static Section
*last_text_section
; /* to handle .previous asm directive */
61 /* bound check related sections */
62 static Section
*bounds_section
; /* contains global data bound description */
63 static Section
*lbounds_section
; /* contains local data bound description */
65 static Section
*symtab_section
, *strtab_section
;
68 static Section
*stab_section
, *stabstr_section
;
70 /* loc : local variable index
71 ind : output code index
73 anon_sym: anonymous symbol index
75 static int rsym
, anon_sym
, ind
, loc
;
76 /* expression generation modifiers */
77 static int const_wanted
; /* true if constant wanted */
78 static int nocode_wanted
; /* true if no code generation wanted for an expression */
79 static int global_expr
; /* true if compound literals must be allocated
80 globally (used during initializers parsing */
81 static CType func_vt
; /* current function return type (used by return
84 static int last_line_num
, last_ind
, func_ind
; /* debug last line number and pc */
86 static TokenSym
**table_ident
;
87 static TokenSym
*hash_ident
[TOK_HASH_SIZE
];
88 static char token_buf
[STRING_MAX_SIZE
+ 1];
89 static char *funcname
;
90 static Sym
*global_stack
, *local_stack
;
91 static Sym
*define_stack
;
92 static Sym
*global_label_stack
, *local_label_stack
;
93 /* symbol allocator */
94 #define SYM_POOL_NB (8192 / sizeof(Sym))
95 static Sym
*sym_free_first
;
96 static void **sym_pools
;
97 static int nb_sym_pools
;
99 static SValue vstack
[VSTACK_SIZE
], *vtop
;
100 /* some predefined types */
101 static CType char_pointer_type
, func_old_type
, int_type
;
103 /* use GNU C extensions */
104 static int gnu_ext
= 1;
106 /* use Tiny C extensions */
107 static int tcc_ext
= 1;
109 /* max number of callers shown if error */
110 #ifdef CONFIG_TCC_BACKTRACE
112 const char **rt_bound_error_msg
;
113 unsigned long rt_prog_main
;
116 /* XXX: get rid of this ASAP */
117 static struct TCCState
*tcc_state
;
119 /********************************************************/
120 /* function prototypes */
123 static void next(void);
124 char *get_tok_str(int v
, CValue
*cv
);
127 static void parse_expr_type(CType
*type
);
128 static void expr_type(CType
*type
);
129 static void unary_type(CType
*type
);
130 static void block(int *bsym
, int *csym
, int *case_sym
, int *def_sym
,
131 int case_reg
, int is_expr
);
132 static int expr_const(void);
133 static void expr_eq(void);
134 static void gexpr(void);
135 static void gen_inline_functions(void);
136 static void decl(int l
);
137 static void decl_initializer(CType
*type
, Section
*sec
, unsigned long c
,
138 int first
, int size_only
);
139 static void decl_initializer_alloc(CType
*type
, AttributeDef
*ad
, int r
,
140 int has_init
, int v
, int scope
);
142 void gv2(int rc1
, int rc2
);
143 void move_reg(int r
, int s
);
144 void save_regs(int n
);
145 void save_reg(int r
);
150 int get_reg_ex(int rc
,int rc2
);
153 void force_charshort_cast(int t
);
154 static void gen_cast(CType
*type
);
156 static Sym
*sym_find(int v
);
157 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
);
160 static int type_size(CType
*type
, int *a
);
161 static inline CType
*pointed_type(CType
*type
);
162 static int pointed_size(CType
*type
);
163 static int lvalue_type(int t
);
164 static int parse_btype(CType
*type
, AttributeDef
*ad
);
165 static void type_decl(CType
*type
, AttributeDef
*ad
, int *v
, int td
);
166 static int compare_types(CType
*type1
, CType
*type2
, int unqualified
);
167 static int is_compatible_types(CType
*type1
, CType
*type2
);
168 static int is_compatible_parameter_types(CType
*type1
, CType
*type2
);
170 int ieee_finite(double d
);
172 void vpushll(long long v
);
175 void lexpand_nr(void);
176 static void vpush_global_sym(CType
*type
, int v
);
177 void vset(CType
*type
, int r
, int v
);
178 void type_to_str(char *buf
, int buf_size
,
179 CType
*type
, const char *varstr
);
180 static Sym
*get_sym_ref(CType
*type
, Section
*sec
,
181 unsigned long offset
, unsigned long size
);
182 static Sym
*external_global_sym(int v
, CType
*type
, int r
);
184 /* section generation */
185 static void section_realloc(Section
*sec
, unsigned long new_size
);
186 static void *section_ptr_add(Section
*sec
, unsigned long size
);
187 static void put_extern_sym(Sym
*sym
, Section
*section
,
188 unsigned long value
, unsigned long size
);
189 static void greloc(Section
*s
, Sym
*sym
, unsigned long addr
, int type
);
190 static int put_elf_str(Section
*s
, const char *sym
);
191 static int put_elf_sym(Section
*s
,
192 unsigned long value
, unsigned long size
,
193 int info
, int other
, int shndx
, const char *name
);
194 static int add_elf_sym(Section
*s
, uplong value
, unsigned long size
,
195 int info
, int other
, int sh_num
, const char *name
);
196 static void put_elf_reloc(Section
*symtab
, Section
*s
, unsigned long offset
,
197 int type
, int symbol
);
198 static void put_stabs(const char *str
, int type
, int other
, int desc
,
199 unsigned long value
);
200 static void put_stabs_r(const char *str
, int type
, int other
, int desc
,
201 unsigned long value
, Section
*sec
, int sym_index
);
202 static void put_stabn(int type
, int other
, int desc
, int value
);
203 static void put_stabd(int type
, int other
, int desc
);
204 static int tcc_add_dll(TCCState
*s
, const char *filename
, int flags
);
206 #define AFF_PRINT_ERROR 0x0001 /* print error if file not found */
207 #define AFF_REFERENCED_DLL 0x0002 /* load a referenced dll from another dll */
208 #define AFF_PREPROCESS 0x0004 /* preprocess file */
209 static int tcc_add_file_internal(TCCState
*s
, const char *filename
, int flags
);
212 int tcc_output_coff(TCCState
*s1
, FILE *f
);
215 int pe_load_file(struct TCCState
*s1
, const char *filename
, int fd
);
216 int pe_output_file(struct TCCState
*s1
, const char *filename
);
217 int pe_dllimport(int r
, SValue
*sv
, void (*fn
)(int r
, SValue
*sv
));
220 #ifdef CONFIG_TCC_ASM
221 static void asm_expr(TCCState
*s1
, ExprValue
*pe
);
222 static int asm_int_expr(TCCState
*s1
);
223 static int find_constraint(ASMOperand
*operands
, int nb_operands
,
224 const char *name
, const char **pp
);
226 static int tcc_assemble(TCCState
*s1
, int do_preprocess
);
229 static void asm_instr(void);
230 static void asm_global_instr(void);
232 /********************************************************/
235 static Sym
*__sym_malloc(void);
236 static inline Sym
*sym_malloc(void);
237 static inline void sym_free(Sym
*sym
);
238 Section
*new_section(TCCState
*s1
, const char *name
, int sh_type
, int sh_flags
);
239 static void free_section(Section
*s
);
240 static void section_realloc(Section
*sec
, unsigned long new_size
);
241 static void *section_ptr_add(Section
*sec
, unsigned long size
);
242 Section
*find_section(TCCState
*s1
, const char *name
);
243 static void put_extern_sym2(
244 Sym
*sym
, Section
*section
,
245 unsigned long value
, unsigned long size
, int can_add_underscore
);
246 static void put_extern_sym(
247 Sym
*sym
, Section
*section
,
248 unsigned long value
, unsigned long size
);
249 static void greloc(Section
*s
, Sym
*sym
, unsigned long offset
, int type
);
251 static void strcat_vprintf(char *buf
, int buf_size
, const char *fmt
, va_list ap
);
252 static void strcat_printf(char *buf
, int buf_size
, const char *fmt
, ...);
254 /* CString handling */
255 static void cstr_realloc(CString
*cstr
, int new_size
);
256 static inline void cstr_ccat(CString
*cstr
, int ch
);
257 static void cstr_cat(CString
*cstr
, const char *str
);
258 static void cstr_wccat(CString
*cstr
, int ch
);
259 static void cstr_new(CString
*cstr
);
260 static void cstr_free(CString
*cstr
);
261 #define cstr_reset(cstr) cstr_free(cstr)
262 static void add_char(CString
*cstr
, int c
);
264 static Sym
*sym_push2(Sym
**ps
, int v
, int t
, long c
);
265 static Sym
*sym_find2(Sym
*s
, int v
);
266 static inline Sym
*struct_find(int v
);
267 static inline Sym
*sym_find(int v
);
268 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
);
269 static Sym
*global_identifier_push(int v
, int t
, int c
);
270 static void sym_pop(Sym
**ptop
, Sym
*b
);
272 BufferedFile
*tcc_open(TCCState
*s1
, const char *filename
);
273 void tcc_close(BufferedFile
*bf
);
274 static int tcc_compile(TCCState
*s1
);
276 void expect(const char *msg
);
278 static void test_lvalue(void);
279 void *resolve_sym(TCCState
*s1
, const char *sym
);
281 static inline int isid(int c
)
283 return (c
>= 'a' && c
<= 'z')
284 || (c
>= 'A' && c
<= 'Z')
288 static inline int isnum(int c
)
290 return c
>= '0' && c
<= '9';
293 static inline int isoct(int c
)
295 return c
>= '0' && c
<= '7';
298 static inline int toup(int c
)
300 if (c
>= 'a' && c
<= 'z')
301 return c
- 'a' + 'A';
306 /********************************************************/
308 #ifdef TCC_TARGET_I386
309 #include "i386-gen.c"
312 #ifdef TCC_TARGET_ARM
316 #ifdef TCC_TARGET_C67
320 #ifdef TCC_TARGET_X86_64
321 #include "x86_64-gen.c"
327 #ifdef CONFIG_TCC_ASM
329 #if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64
330 #include "i386-asm.c"
335 static void asm_instr(void)
337 error("inline asm() not supported");
339 static void asm_global_instr(void)
341 error("inline asm() not supported");
347 #ifdef TCC_TARGET_COFF
355 /********************************************************/
357 char *normalize_slashes(char *path
)
360 for (p
= path
; *p
; ++p
)
368 /* on win32, we suppose the lib and includes are at the location of 'tcc.exe' */
369 void tcc_set_lib_path_w32(TCCState
*s
)
372 GetModuleFileNameA(tcc_module
, path
, sizeof path
);
373 p
= tcc_basename(normalize_slashes(strlwr(path
)));
374 if (p
- 5 > path
&& 0 == strncmp(p
- 5, "/bin/", 5))
379 tcc_set_lib_path(s
, path
);
383 BOOL WINAPI
DllMain (HANDLE hDll
, DWORD dwReason
, LPVOID lpReserved
)
385 if (DLL_PROCESS_ATTACH
== dwReason
)
392 /********************************************************/
393 #ifdef CONFIG_TCC_STATIC
395 #define RTLD_LAZY 0x001
396 #define RTLD_NOW 0x002
397 #define RTLD_GLOBAL 0x100
398 #define RTLD_DEFAULT NULL
400 /* dummy function for profiling */
401 void *dlopen(const char *filename
, int flag
)
406 void dlclose(void *p
)
410 const char *dlerror(void)
415 typedef struct TCCSyms
{
420 #define TCCSYM(a) { #a, &a, },
422 /* add the symbol you want here if no dynamic linking is done */
423 static TCCSyms tcc_syms
[] = {
424 #if !defined(CONFIG_TCCBOOT)
433 void *resolve_sym(TCCState
*s1
, const char *symbol
)
437 while (p
->str
!= NULL
) {
438 if (!strcmp(p
->str
, symbol
))
445 #elif defined(_WIN32)
446 #define dlclose FreeLibrary
451 void *resolve_sym(TCCState
*s1
, const char *sym
)
453 return dlsym(RTLD_DEFAULT
, sym
);
458 /********************************************************/
460 /* we use our own 'finite' function to avoid potential problems with
461 non standard math libs */
462 /* XXX: endianness dependent */
463 int ieee_finite(double d
)
466 return ((unsigned)((p
[1] | 0x800fffff) + 1)) >> 31;
469 /* copy a string and truncate it. */
470 char *pstrcpy(char *buf
, int buf_size
, const char *s
)
477 q_end
= buf
+ buf_size
- 1;
489 /* strcat and truncate. */
490 char *pstrcat(char *buf
, int buf_size
, const char *s
)
495 pstrcpy(buf
+ len
, buf_size
- len
, s
);
499 /* extract the basename of a file */
500 char *tcc_basename(const char *name
)
502 char *p
= strchr(name
, 0);
503 while (p
> name
&& !IS_PATHSEP(p
[-1]))
508 char *tcc_fileextension (const char *name
)
510 char *b
= tcc_basename(name
);
511 char *e
= strrchr(b
, '.');
512 return e
? e
: strchr(b
, 0);
515 void set_pages_executable(void *ptr
, unsigned long length
)
518 unsigned long old_protect
;
519 VirtualProtect(ptr
, length
, PAGE_EXECUTE_READWRITE
, &old_protect
);
521 unsigned long start
, end
;
522 start
= (unsigned long)ptr
& ~(PAGESIZE
- 1);
523 end
= (unsigned long)ptr
+ length
;
524 end
= (end
+ PAGESIZE
- 1) & ~(PAGESIZE
- 1);
525 mprotect((void *)start
, end
- start
, PROT_READ
| PROT_WRITE
| PROT_EXEC
);
529 /* memory management */
533 unsigned malloc_usable_size(void*);
536 void tcc_free(void *ptr
)
539 mem_cur_size
-= malloc_usable_size(ptr
);
544 void *tcc_malloc(unsigned long size
)
549 error("memory full");
551 mem_cur_size
+= malloc_usable_size(ptr
);
552 if (mem_cur_size
> mem_max_size
)
553 mem_max_size
= mem_cur_size
;
558 void *tcc_mallocz(unsigned long size
)
561 ptr
= tcc_malloc(size
);
562 memset(ptr
, 0, size
);
566 void *tcc_realloc(void *ptr
, unsigned long size
)
570 mem_cur_size
-= malloc_usable_size(ptr
);
572 ptr1
= realloc(ptr
, size
);
574 /* NOTE: count not correct if alloc error, but not critical */
575 mem_cur_size
+= malloc_usable_size(ptr1
);
576 if (mem_cur_size
> mem_max_size
)
577 mem_max_size
= mem_cur_size
;
582 char *tcc_strdup(const char *str
)
585 ptr
= tcc_malloc(strlen(str
) + 1);
590 #define free(p) use_tcc_free(p)
591 #define malloc(s) use_tcc_malloc(s)
592 #define realloc(p, s) use_tcc_realloc(p, s)
594 void dynarray_add(void ***ptab
, int *nb_ptr
, void *data
)
601 /* every power of two we double array size */
602 if ((nb
& (nb
- 1)) == 0) {
607 pp
= tcc_realloc(pp
, nb_alloc
* sizeof(void *));
609 error("memory full");
616 void dynarray_reset(void *pp
, int *n
)
619 for (p
= *(void***)pp
; *n
; ++p
, --*n
)
622 tcc_free(*(void**)pp
);
626 /* symbol allocator */
627 static Sym
*__sym_malloc(void)
629 Sym
*sym_pool
, *sym
, *last_sym
;
632 sym_pool
= tcc_malloc(SYM_POOL_NB
* sizeof(Sym
));
633 dynarray_add(&sym_pools
, &nb_sym_pools
, sym_pool
);
635 last_sym
= sym_free_first
;
637 for(i
= 0; i
< SYM_POOL_NB
; i
++) {
638 sym
->next
= last_sym
;
642 sym_free_first
= last_sym
;
646 static inline Sym
*sym_malloc(void)
649 sym
= sym_free_first
;
651 sym
= __sym_malloc();
652 sym_free_first
= sym
->next
;
656 static inline void sym_free(Sym
*sym
)
658 sym
->next
= sym_free_first
;
659 sym_free_first
= sym
;
662 Section
*new_section(TCCState
*s1
, const char *name
, int sh_type
, int sh_flags
)
666 sec
= tcc_mallocz(sizeof(Section
) + strlen(name
));
667 strcpy(sec
->name
, name
);
668 sec
->sh_type
= sh_type
;
669 sec
->sh_flags
= sh_flags
;
677 sec
->sh_addralign
= 4;
680 sec
->sh_addralign
= 1;
683 sec
->sh_addralign
= 32; /* default conservative alignment */
687 if (sh_flags
& SHF_PRIVATE
) {
688 dynarray_add((void ***)&s1
->priv_sections
, &s1
->nb_priv_sections
, sec
);
690 sec
->sh_num
= s1
->nb_sections
;
691 dynarray_add((void ***)&s1
->sections
, &s1
->nb_sections
, sec
);
697 static void free_section(Section
*s
)
702 /* realloc section and set its content to zero */
703 static void section_realloc(Section
*sec
, unsigned long new_size
)
708 size
= sec
->data_allocated
;
711 while (size
< new_size
)
713 data
= tcc_realloc(sec
->data
, size
);
715 error("memory full");
716 memset(data
+ sec
->data_allocated
, 0, size
- sec
->data_allocated
);
718 sec
->data_allocated
= size
;
721 /* reserve at least 'size' bytes in section 'sec' from
723 static void *section_ptr_add(Section
*sec
, unsigned long size
)
725 unsigned long offset
, offset1
;
727 offset
= sec
->data_offset
;
728 offset1
= offset
+ size
;
729 if (offset1
> sec
->data_allocated
)
730 section_realloc(sec
, offset1
);
731 sec
->data_offset
= offset1
;
732 return sec
->data
+ offset
;
735 /* return a reference to a section, and create it if it does not
737 Section
*find_section(TCCState
*s1
, const char *name
)
741 for(i
= 1; i
< s1
->nb_sections
; i
++) {
742 sec
= s1
->sections
[i
];
743 if (!strcmp(name
, sec
->name
))
746 /* sections are created as PROGBITS */
747 return new_section(s1
, name
, SHT_PROGBITS
, SHF_ALLOC
);
750 /* update sym->c so that it points to an external symbol in section
751 'section' with value 'value' */
752 static void put_extern_sym2(Sym
*sym
, Section
*section
,
753 unsigned long value
, unsigned long size
,
754 int can_add_underscore
)
756 int sym_type
, sym_bind
, sh_num
, info
, other
, attr
;
763 else if (section
== SECTION_ABS
)
766 sh_num
= section
->sh_num
;
770 if ((sym
->type
.t
& VT_BTYPE
) == VT_FUNC
) {
774 attr
= sym
->type
.ref
->r
;
775 if (FUNC_EXPORT(attr
))
777 if (FUNC_CALL(attr
) == FUNC_STDCALL
)
780 } else if ((sym
->type
.t
& VT_BTYPE
) == VT_VOID
) {
781 sym_type
= STT_NOTYPE
;
783 sym_type
= STT_OBJECT
;
785 if (sym
->type
.t
& VT_EXPORT
)
790 if (sym
->type
.t
& VT_STATIC
)
791 sym_bind
= STB_LOCAL
;
793 sym_bind
= STB_GLOBAL
;
796 name
= get_tok_str(sym
->v
, NULL
);
797 #ifdef CONFIG_TCC_BCHECK
798 if (tcc_state
->do_bounds_check
) {
801 /* XXX: avoid doing that for statics ? */
802 /* if bound checking is activated, we change some function
803 names by adding the "__bound" prefix */
806 /* XXX: we rely only on malloc hooks */
819 strcpy(buf
, "__bound_");
828 if ((other
& 2) && can_add_underscore
) {
829 sprintf(buf1
, "_%s@%d", name
, FUNC_ARGS(attr
));
833 if (tcc_state
->leading_underscore
&& can_add_underscore
) {
835 pstrcpy(buf1
+ 1, sizeof(buf1
) - 1, name
);
838 info
= ELFW(ST_INFO
)(sym_bind
, sym_type
);
839 sym
->c
= add_elf_sym(symtab_section
, value
, size
, info
, other
, sh_num
, name
);
841 esym
= &((ElfW(Sym
) *)symtab_section
->data
)[sym
->c
];
842 esym
->st_value
= value
;
843 esym
->st_size
= size
;
844 esym
->st_shndx
= sh_num
;
845 esym
->st_other
|= other
;
849 static void put_extern_sym(Sym
*sym
, Section
*section
,
850 unsigned long value
, unsigned long size
)
852 put_extern_sym2(sym
, section
, value
, size
, 1);
855 /* add a new relocation entry to symbol 'sym' in section 's' */
856 static void greloc(Section
*s
, Sym
*sym
, unsigned long offset
, int type
)
861 put_extern_sym(sym
, NULL
, 0, 0);
864 /* now we can add ELF relocation info */
865 put_elf_reloc(symtab_section
, s
, offset
, type
, c
);
868 static void strcat_vprintf(char *buf
, int buf_size
, const char *fmt
, va_list ap
)
872 vsnprintf(buf
+ len
, buf_size
- len
, fmt
, ap
);
875 static void strcat_printf(char *buf
, int buf_size
, const char *fmt
, ...)
879 strcat_vprintf(buf
, buf_size
, fmt
, ap
);
883 void error1(TCCState
*s1
, int is_warning
, const char *fmt
, va_list ap
)
890 for(f
= s1
->include_stack
; f
< s1
->include_stack_ptr
; f
++)
891 strcat_printf(buf
, sizeof(buf
), "In file included from %s:%d:\n",
892 (*f
)->filename
, (*f
)->line_num
);
893 if (file
->line_num
> 0) {
894 strcat_printf(buf
, sizeof(buf
),
895 "%s:%d: ", file
->filename
, file
->line_num
);
897 strcat_printf(buf
, sizeof(buf
),
898 "%s: ", file
->filename
);
901 strcat_printf(buf
, sizeof(buf
),
905 strcat_printf(buf
, sizeof(buf
), "warning: ");
907 strcat_printf(buf
, sizeof(buf
), "error: ");
908 strcat_vprintf(buf
, sizeof(buf
), fmt
, ap
);
910 if (!s1
->error_func
) {
911 /* default case: stderr */
912 fprintf(stderr
, "%s\n", buf
);
914 s1
->error_func(s1
->error_opaque
, buf
);
916 if (!is_warning
|| s1
->warn_error
)
920 void tcc_set_error_func(TCCState
*s
, void *error_opaque
,
921 void (*error_func
)(void *opaque
, const char *msg
))
923 s
->error_opaque
= error_opaque
;
924 s
->error_func
= error_func
;
927 /* error without aborting current compilation */
928 void error_noabort(const char *fmt
, ...)
930 TCCState
*s1
= tcc_state
;
934 error1(s1
, 0, fmt
, ap
);
938 void error(const char *fmt
, ...)
940 TCCState
*s1
= tcc_state
;
944 error1(s1
, 0, fmt
, ap
);
946 /* better than nothing: in some cases, we accept to handle errors */
947 if (s1
->error_set_jmp_enabled
) {
948 longjmp(s1
->error_jmp_buf
, 1);
950 /* XXX: eliminate this someday */
955 void expect(const char *msg
)
957 error("%s expected", msg
);
960 void warning(const char *fmt
, ...)
962 TCCState
*s1
= tcc_state
;
969 error1(s1
, 1, fmt
, ap
);
976 error("'%c' expected", c
);
980 static void test_lvalue(void)
982 if (!(vtop
->r
& VT_LVAL
))
986 /* CString handling */
988 static void cstr_realloc(CString
*cstr
, int new_size
)
993 size
= cstr
->size_allocated
;
995 size
= 8; /* no need to allocate a too small first string */
996 while (size
< new_size
)
998 data
= tcc_realloc(cstr
->data_allocated
, size
);
1000 error("memory full");
1001 cstr
->data_allocated
= data
;
1002 cstr
->size_allocated
= size
;
1007 static inline void cstr_ccat(CString
*cstr
, int ch
)
1010 size
= cstr
->size
+ 1;
1011 if (size
> cstr
->size_allocated
)
1012 cstr_realloc(cstr
, size
);
1013 ((unsigned char *)cstr
->data
)[size
- 1] = ch
;
1017 static void cstr_cat(CString
*cstr
, const char *str
)
1029 /* add a wide char */
1030 static void cstr_wccat(CString
*cstr
, int ch
)
1033 size
= cstr
->size
+ sizeof(nwchar_t
);
1034 if (size
> cstr
->size_allocated
)
1035 cstr_realloc(cstr
, size
);
1036 *(nwchar_t
*)(((unsigned char *)cstr
->data
) + size
- sizeof(nwchar_t
)) = ch
;
1040 static void cstr_new(CString
*cstr
)
1042 memset(cstr
, 0, sizeof(CString
));
1045 /* free string and reset it to NULL */
1046 static void cstr_free(CString
*cstr
)
1048 tcc_free(cstr
->data_allocated
);
1052 #define cstr_reset(cstr) cstr_free(cstr)
1054 /* XXX: unicode ? */
1055 static void add_char(CString
*cstr
, int c
)
1057 if (c
== '\'' || c
== '\"' || c
== '\\') {
1058 /* XXX: could be more precise if char or string */
1059 cstr_ccat(cstr
, '\\');
1061 if (c
>= 32 && c
<= 126) {
1064 cstr_ccat(cstr
, '\\');
1066 cstr_ccat(cstr
, 'n');
1068 cstr_ccat(cstr
, '0' + ((c
>> 6) & 7));
1069 cstr_ccat(cstr
, '0' + ((c
>> 3) & 7));
1070 cstr_ccat(cstr
, '0' + (c
& 7));
1075 /* push, without hashing */
1076 static Sym
*sym_push2(Sym
**ps
, int v
, int t
, long c
)
1094 /* find a symbol and return its associated structure. 's' is the top
1095 of the symbol stack */
1096 static Sym
*sym_find2(Sym
*s
, int v
)
1106 /* structure lookup */
1107 static inline Sym
*struct_find(int v
)
1110 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1112 return table_ident
[v
]->sym_struct
;
1115 /* find an identifier */
1116 static inline Sym
*sym_find(int v
)
1119 if ((unsigned)v
>= (unsigned)(tok_ident
- TOK_IDENT
))
1121 return table_ident
[v
]->sym_identifier
;
1124 /* push a given symbol on the symbol stack */
1125 static Sym
*sym_push(int v
, CType
*type
, int r
, int c
)
1134 s
= sym_push2(ps
, v
, type
->t
, c
);
1135 s
->type
.ref
= type
->ref
;
1137 /* don't record fields or anonymous symbols */
1139 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1140 /* record symbol in token array */
1141 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1143 ps
= &ts
->sym_struct
;
1145 ps
= &ts
->sym_identifier
;
1152 /* push a global identifier */
1153 static Sym
*global_identifier_push(int v
, int t
, int c
)
1156 s
= sym_push2(&global_stack
, v
, t
, c
);
1157 /* don't record anonymous symbol */
1158 if (v
< SYM_FIRST_ANOM
) {
1159 ps
= &table_ident
[v
- TOK_IDENT
]->sym_identifier
;
1160 /* modify the top most local identifier, so that
1161 sym_identifier will point to 's' when popped */
1163 ps
= &(*ps
)->prev_tok
;
1170 /* pop symbols until top reaches 'b' */
1171 static void sym_pop(Sym
**ptop
, Sym
*b
)
1181 /* remove symbol in token array */
1183 if (!(v
& SYM_FIELD
) && (v
& ~SYM_STRUCT
) < SYM_FIRST_ANOM
) {
1184 ts
= table_ident
[(v
& ~SYM_STRUCT
) - TOK_IDENT
];
1186 ps
= &ts
->sym_struct
;
1188 ps
= &ts
->sym_identifier
;
1199 BufferedFile
*tcc_open(TCCState
*s1
, const char *filename
)
1204 if (strcmp(filename
, "-") == 0)
1205 fd
= 0, filename
= "stdin";
1207 fd
= open(filename
, O_RDONLY
| O_BINARY
);
1208 if ((s1
->verbose
== 2 && fd
>= 0) || s1
->verbose
== 3)
1209 printf("%s %*s%s\n", fd
< 0 ? "nf":"->",
1210 (int)(s1
->include_stack_ptr
- s1
->include_stack
), "", filename
);
1213 bf
= tcc_malloc(sizeof(BufferedFile
));
1215 bf
->buf_ptr
= bf
->buffer
;
1216 bf
->buf_end
= bf
->buffer
;
1217 bf
->buffer
[0] = CH_EOB
; /* put eob symbol */
1218 pstrcpy(bf
->filename
, sizeof(bf
->filename
), filename
);
1220 normalize_slashes(bf
->filename
);
1223 bf
->ifndef_macro
= 0;
1224 bf
->ifdef_stack_ptr
= s1
->ifdef_stack_ptr
;
1225 // printf("opening '%s'\n", filename);
1229 void tcc_close(BufferedFile
*bf
)
1231 total_lines
+= bf
->line_num
;
1236 /* compile the C file opened in 'file'. Return non zero if errors. */
1237 static int tcc_compile(TCCState
*s1
)
1241 volatile int section_sym
;
1244 printf("%s: **** new file\n", file
->filename
);
1246 preprocess_init(s1
);
1248 cur_text_section
= NULL
;
1250 anon_sym
= SYM_FIRST_ANOM
;
1252 /* file info: full path + filename */
1253 section_sym
= 0; /* avoid warning */
1255 section_sym
= put_elf_sym(symtab_section
, 0, 0,
1256 ELFW(ST_INFO
)(STB_LOCAL
, STT_SECTION
), 0,
1257 text_section
->sh_num
, NULL
);
1258 getcwd(buf
, sizeof(buf
));
1260 normalize_slashes(buf
);
1262 pstrcat(buf
, sizeof(buf
), "/");
1263 put_stabs_r(buf
, N_SO
, 0, 0,
1264 text_section
->data_offset
, text_section
, section_sym
);
1265 put_stabs_r(file
->filename
, N_SO
, 0, 0,
1266 text_section
->data_offset
, text_section
, section_sym
);
1268 /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
1269 symbols can be safely used */
1270 put_elf_sym(symtab_section
, 0, 0,
1271 ELFW(ST_INFO
)(STB_LOCAL
, STT_FILE
), 0,
1272 SHN_ABS
, file
->filename
);
1274 /* define some often used types */
1275 int_type
.t
= VT_INT
;
1277 char_pointer_type
.t
= VT_BYTE
;
1278 mk_pointer(&char_pointer_type
);
1280 func_old_type
.t
= VT_FUNC
;
1281 func_old_type
.ref
= sym_push(SYM_FIELD
, &int_type
, FUNC_CDECL
, FUNC_OLD
);
1283 #if defined(TCC_ARM_EABI) && defined(TCC_ARM_VFP)
1284 float_type
.t
= VT_FLOAT
;
1285 double_type
.t
= VT_DOUBLE
;
1287 func_float_type
.t
= VT_FUNC
;
1288 func_float_type
.ref
= sym_push(SYM_FIELD
, &float_type
, FUNC_CDECL
, FUNC_OLD
);
1289 func_double_type
.t
= VT_FUNC
;
1290 func_double_type
.ref
= sym_push(SYM_FIELD
, &double_type
, FUNC_CDECL
, FUNC_OLD
);
1294 /* define 'void *alloca(unsigned int)' builtin function */
1299 sym
= sym_push(p
, mk_pointer(VT_VOID
), FUNC_CDECL
, FUNC_NEW
);
1300 s1
= sym_push(SYM_FIELD
, VT_UNSIGNED
| VT_INT
, 0, 0);
1303 sym_push(TOK_alloca
, VT_FUNC
| (p
<< VT_STRUCT_SHIFT
), VT_CONST
, 0);
1307 define_start
= define_stack
;
1310 if (setjmp(s1
->error_jmp_buf
) == 0) {
1312 s1
->error_set_jmp_enabled
= 1;
1314 ch
= file
->buf_ptr
[0];
1315 tok_flags
= TOK_FLAG_BOL
| TOK_FLAG_BOF
;
1316 parse_flags
= PARSE_FLAG_PREPROCESS
| PARSE_FLAG_TOK_NUM
;
1320 expect("declaration");
1322 /* end of translation unit info */
1324 put_stabs_r(NULL
, N_SO
, 0, 0,
1325 text_section
->data_offset
, text_section
, section_sym
);
1328 s1
->error_set_jmp_enabled
= 0;
1330 /* reset define stack, but leave -Dsymbols (may be incorrect if
1331 they are undefined) */
1332 free_defines(define_start
);
1334 gen_inline_functions();
1336 sym_pop(&global_stack
, NULL
);
1337 sym_pop(&local_stack
, NULL
);
1339 return s1
->nb_errors
!= 0 ? -1 : 0;
1342 int tcc_compile_string(TCCState
*s
, const char *str
)
1344 BufferedFile bf1
, *bf
= &bf1
;
1348 /* init file structure */
1350 /* XXX: avoid copying */
1352 buf
= tcc_malloc(len
+ 1);
1355 memcpy(buf
, str
, len
);
1358 bf
->buf_end
= buf
+ len
;
1359 pstrcpy(bf
->filename
, sizeof(bf
->filename
), "<string>");
1362 ret
= tcc_compile(s
);
1366 /* currently, no need to close */
1370 /* define a preprocessor symbol. A value can also be provided with the '=' operator */
1371 void tcc_define_symbol(TCCState
*s1
, const char *sym
, const char *value
)
1373 BufferedFile bf1
, *bf
= &bf1
;
1375 pstrcpy(bf
->buffer
, IO_BUF_SIZE
, sym
);
1376 pstrcat(bf
->buffer
, IO_BUF_SIZE
, " ");
1380 pstrcat(bf
->buffer
, IO_BUF_SIZE
, value
);
1382 /* init file structure */
1384 bf
->buf_ptr
= bf
->buffer
;
1385 bf
->buf_end
= bf
->buffer
+ strlen(bf
->buffer
);
1386 *bf
->buf_end
= CH_EOB
;
1387 bf
->filename
[0] = '\0';
1391 s1
->include_stack_ptr
= s1
->include_stack
;
1393 /* parse with define parser */
1394 ch
= file
->buf_ptr
[0];
1400 /* undefine a preprocessor symbol */
1401 void tcc_undefine_symbol(TCCState
*s1
, const char *sym
)
1405 ts
= tok_alloc(sym
, strlen(sym
));
1406 s
= define_find(ts
->tok
);
1407 /* undefine symbol by putting an invalid name */
1413 #ifdef CONFIG_TCC_BACKTRACE
1414 /* print the position in the source file of PC value 'pc' by reading
1415 the stabs debug information */
1416 static unsigned long rt_printline(unsigned long wanted_pc
)
1418 Stab_Sym
*sym
, *sym_end
;
1419 char func_name
[128], last_func_name
[128];
1420 unsigned long func_addr
, last_pc
, pc
;
1421 const char *incl_files
[INCLUDE_STACK_SIZE
];
1422 int incl_index
, len
, last_line_num
, i
;
1423 const char *str
, *p
;
1425 fprintf(stderr
, "0x%08lx:", wanted_pc
);
1427 func_name
[0] = '\0';
1430 last_func_name
[0] = '\0';
1431 last_pc
= 0xffffffff;
1433 sym
= (Stab_Sym
*)stab_section
->data
+ 1;
1434 sym_end
= (Stab_Sym
*)(stab_section
->data
+ stab_section
->data_offset
);
1435 while (sym
< sym_end
) {
1436 switch(sym
->n_type
) {
1437 /* function start or end */
1439 if (sym
->n_strx
== 0) {
1440 /* we test if between last line and end of function */
1441 pc
= sym
->n_value
+ func_addr
;
1442 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
1444 func_name
[0] = '\0';
1447 str
= stabstr_section
->data
+ sym
->n_strx
;
1448 p
= strchr(str
, ':');
1450 pstrcpy(func_name
, sizeof(func_name
), str
);
1453 if (len
> sizeof(func_name
) - 1)
1454 len
= sizeof(func_name
) - 1;
1455 memcpy(func_name
, str
, len
);
1456 func_name
[len
] = '\0';
1458 func_addr
= sym
->n_value
;
1461 /* line number info */
1463 pc
= sym
->n_value
+ func_addr
;
1464 if (wanted_pc
>= last_pc
&& wanted_pc
< pc
)
1467 last_line_num
= sym
->n_desc
;
1469 strcpy(last_func_name
, func_name
);
1473 str
= stabstr_section
->data
+ sym
->n_strx
;
1475 if (incl_index
< INCLUDE_STACK_SIZE
) {
1476 incl_files
[incl_index
++] = str
;
1484 if (sym
->n_strx
== 0) {
1485 incl_index
= 0; /* end of translation unit */
1487 str
= stabstr_section
->data
+ sym
->n_strx
;
1488 /* do not add path */
1490 if (len
> 0 && str
[len
- 1] != '/')
1498 /* second pass: we try symtab symbols (no line number info) */
1501 ElfW(Sym
) *sym
, *sym_end
;
1504 sym_end
= (ElfW(Sym
) *)(symtab_section
->data
+ symtab_section
->data_offset
);
1505 for(sym
= (ElfW(Sym
) *)symtab_section
->data
+ 1;
1508 type
= ELFW(ST_TYPE
)(sym
->st_info
);
1509 if (type
== STT_FUNC
) {
1510 if (wanted_pc
>= sym
->st_value
&&
1511 wanted_pc
< sym
->st_value
+ sym
->st_size
) {
1512 pstrcpy(last_func_name
, sizeof(last_func_name
),
1513 strtab_section
->data
+ sym
->st_name
);
1514 func_addr
= sym
->st_value
;
1520 /* did not find any info: */
1521 fprintf(stderr
, " ???\n");
1524 if (last_func_name
[0] != '\0') {
1525 fprintf(stderr
, " %s()", last_func_name
);
1527 if (incl_index
> 0) {
1528 fprintf(stderr
, " (%s:%d",
1529 incl_files
[incl_index
- 1], last_line_num
);
1530 for(i
= incl_index
- 2; i
>= 0; i
--)
1531 fprintf(stderr
, ", included from %s", incl_files
[i
]);
1532 fprintf(stderr
, ")");
1534 fprintf(stderr
, "\n");
1539 /* fix for glibc 2.1 */
1545 /* return the PC at frame level 'level'. Return non zero if not found */
1546 static int rt_get_caller_pc(unsigned long *paddr
,
1547 ucontext_t
*uc
, int level
)
1553 #if defined(__FreeBSD__)
1554 *paddr
= uc
->uc_mcontext
.mc_eip
;
1555 #elif defined(__dietlibc__)
1556 *paddr
= uc
->uc_mcontext
.eip
;
1558 *paddr
= uc
->uc_mcontext
.gregs
[REG_EIP
];
1562 #if defined(__FreeBSD__)
1563 fp
= uc
->uc_mcontext
.mc_ebp
;
1564 #elif defined(__dietlibc__)
1565 fp
= uc
->uc_mcontext
.ebp
;
1567 fp
= uc
->uc_mcontext
.gregs
[REG_EBP
];
1569 for(i
=1;i
<level
;i
++) {
1570 /* XXX: check address validity with program info */
1571 if (fp
<= 0x1000 || fp
>= 0xc0000000)
1573 fp
= ((unsigned long *)fp
)[0];
1575 *paddr
= ((unsigned long *)fp
)[1];
1579 #elif defined(__x86_64__)
1580 /* return the PC at frame level 'level'. Return non zero if not found */
1581 static int rt_get_caller_pc(unsigned long *paddr
,
1582 ucontext_t
*uc
, int level
)
1588 /* XXX: only support linux */
1589 #if defined(__FreeBSD__)
1590 *paddr
= uc
->uc_mcontext
.mc_rip
;
1592 *paddr
= uc
->uc_mcontext
.gregs
[REG_RIP
];
1596 #if defined(__FreeBSD__)
1597 fp
= uc
->uc_mcontext
.mc_rbp
;
1599 fp
= uc
->uc_mcontext
.gregs
[REG_RBP
];
1601 for(i
=1;i
<level
;i
++) {
1602 /* XXX: check address validity with program info */
1605 fp
= ((unsigned long *)fp
)[0];
1607 *paddr
= ((unsigned long *)fp
)[1];
1612 #warning add arch specific rt_get_caller_pc()
1613 static int rt_get_caller_pc(unsigned long *paddr
,
1614 ucontext_t
*uc
, int level
)
1620 /* emit a run time error at position 'pc' */
1621 void rt_error(ucontext_t
*uc
, const char *fmt
, ...)
1628 fprintf(stderr
, "Runtime error: ");
1629 vfprintf(stderr
, fmt
, ap
);
1630 fprintf(stderr
, "\n");
1631 for(i
=0;i
<num_callers
;i
++) {
1632 if (rt_get_caller_pc(&pc
, uc
, i
) < 0)
1635 fprintf(stderr
, "at ");
1637 fprintf(stderr
, "by ");
1638 pc
= rt_printline(pc
);
1639 if (pc
== rt_prog_main
&& pc
)
1646 /* signal handler for fatal errors */
1647 static void sig_error(int signum
, siginfo_t
*siginf
, void *puc
)
1649 ucontext_t
*uc
= puc
;
1653 switch(siginf
->si_code
) {
1656 rt_error(uc
, "division by zero");
1659 rt_error(uc
, "floating point exception");
1665 if (rt_bound_error_msg
&& *rt_bound_error_msg
)
1666 rt_error(uc
, *rt_bound_error_msg
);
1668 rt_error(uc
, "dereferencing invalid pointer");
1671 rt_error(uc
, "illegal instruction");
1674 rt_error(uc
, "abort() called");
1677 rt_error(uc
, "caught signal %d", signum
);
1685 /* copy code into memory passed in by the caller and do all relocations
1686 (needed before using tcc_get_symbol()).
1687 returns -1 on error and required size if ptr is NULL */
1688 int tcc_relocate(TCCState
*s1
, void *ptr
)
1691 unsigned long offset
, length
;
1695 if (0 == s1
->runtime_added
) {
1696 s1
->runtime_added
= 1;
1698 #ifdef TCC_TARGET_PE
1699 pe_output_file(s1
, NULL
);
1701 tcc_add_runtime(s1
);
1702 relocate_common_syms();
1703 tcc_add_linker_symbols(s1
);
1704 build_got_entries(s1
);
1710 offset
= 0, mem
= (uplong
)ptr
;
1711 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1712 s
= s1
->sections
[i
];
1713 if (0 == (s
->sh_flags
& SHF_ALLOC
))
1715 length
= s
->data_offset
;
1716 s
->sh_addr
= mem
? (mem
+ offset
+ 15) & ~15 : 0;
1717 offset
= (offset
+ length
+ 15) & ~15;
1720 /* relocate symbols */
1721 relocate_syms(s1
, 1);
1725 #ifndef TCC_TARGET_PE
1726 #ifdef TCC_TARGET_X86_64
1727 s1
->runtime_plt_and_got_offset
= 0;
1728 s1
->runtime_plt_and_got
= (char *)(mem
+ offset
);
1729 /* double the size of the buffer for got and plt entries
1730 XXX: calculate exact size for them? */
1738 /* relocate each section */
1739 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1740 s
= s1
->sections
[i
];
1742 relocate_section(s1
, s
);
1745 for(i
= 1; i
< s1
->nb_sections
; i
++) {
1746 s
= s1
->sections
[i
];
1747 if (0 == (s
->sh_flags
& SHF_ALLOC
))
1749 length
= s
->data_offset
;
1750 // printf("%-12s %08x %04x\n", s->name, s->sh_addr, length);
1751 ptr
= (void*)(uplong
)s
->sh_addr
;
1752 if (NULL
== s
->data
|| s
->sh_type
== SHT_NOBITS
)
1753 memset(ptr
, 0, length
);
1755 memcpy(ptr
, s
->data
, length
);
1756 /* mark executable sections as executable in memory */
1757 if (s
->sh_flags
& SHF_EXECINSTR
)
1758 set_pages_executable(ptr
, length
);
1760 #ifndef TCC_TARGET_PE
1761 #ifdef TCC_TARGET_X86_64
1762 set_pages_executable(s1
->runtime_plt_and_got
,
1763 s1
->runtime_plt_and_got_offset
);
1769 /* launch the compiled program with the given arguments */
1770 int tcc_run(TCCState
*s1
, int argc
, char **argv
)
1772 int (*prog_main
)(int, char **);
1776 ret
= tcc_relocate(s1
, NULL
);
1779 ptr
= tcc_malloc(ret
);
1780 tcc_relocate(s1
, ptr
);
1782 prog_main
= tcc_get_symbol_err(s1
, "main");
1785 #ifdef CONFIG_TCC_BACKTRACE
1786 struct sigaction sigact
;
1787 /* install TCC signal handlers to print debug info on fatal
1789 sigact
.sa_flags
= SA_SIGINFO
| SA_RESETHAND
;
1790 sigact
.sa_sigaction
= sig_error
;
1791 sigemptyset(&sigact
.sa_mask
);
1792 sigaction(SIGFPE
, &sigact
, NULL
);
1793 sigaction(SIGILL
, &sigact
, NULL
);
1794 sigaction(SIGSEGV
, &sigact
, NULL
);
1795 sigaction(SIGBUS
, &sigact
, NULL
);
1796 sigaction(SIGABRT
, &sigact
, NULL
);
1798 error("debug mode not available");
1802 #ifdef CONFIG_TCC_BCHECK
1803 if (s1
->do_bounds_check
) {
1804 void (*bound_init
)(void);
1805 void (*bound_exit
)(void);
1806 /* set error function */
1807 rt_bound_error_msg
= tcc_get_symbol_err(s1
, "__bound_error_msg");
1808 rt_prog_main
= (unsigned long)prog_main
;
1809 /* XXX: use .init section so that it also work in binary ? */
1810 bound_init
= tcc_get_symbol_err(s1
, "__bound_init");
1811 bound_exit
= tcc_get_symbol_err(s1
, "__bound_exit");
1813 ret
= (*prog_main
)(argc
, argv
);
1817 ret
= (*prog_main
)(argc
, argv
);
1822 void tcc_memstats(void)
1825 printf("memory in use: %d\n", mem_cur_size
);
1829 static void tcc_cleanup(void)
1833 if (NULL
== tcc_state
)
1837 /* free -D defines */
1841 n
= tok_ident
- TOK_IDENT
;
1842 for(i
= 0; i
< n
; i
++)
1843 tcc_free(table_ident
[i
]);
1844 tcc_free(table_ident
);
1846 /* free sym_pools */
1847 dynarray_reset(&sym_pools
, &nb_sym_pools
);
1849 cstr_free(&tokcstr
);
1850 /* reset symbol stack */
1851 sym_free_first
= NULL
;
1852 /* cleanup from error/setjmp */
1856 TCCState
*tcc_new(void)
1864 s
= tcc_mallocz(sizeof(TCCState
));
1869 tcc_set_lib_path_w32(s
);
1871 tcc_set_lib_path(s
, CONFIG_TCCDIR
);
1873 s
->output_type
= TCC_OUTPUT_MEMORY
;
1876 /* we add dummy defines for some special macros to speed up tests
1877 and to have working defined() */
1878 define_push(TOK___LINE__
, MACRO_OBJ
, NULL
, NULL
);
1879 define_push(TOK___FILE__
, MACRO_OBJ
, NULL
, NULL
);
1880 define_push(TOK___DATE__
, MACRO_OBJ
, NULL
, NULL
);
1881 define_push(TOK___TIME__
, MACRO_OBJ
, NULL
, NULL
);
1883 /* standard defines */
1884 tcc_define_symbol(s
, "__STDC__", NULL
);
1885 tcc_define_symbol(s
, "__STDC_VERSION__", "199901L");
1886 #if defined(TCC_TARGET_I386)
1887 tcc_define_symbol(s
, "__i386__", "1");
1888 tcc_define_symbol(s
, "__i386", "1");
1889 tcc_define_symbol(s
, "i386", "1");
1891 #if defined(TCC_TARGET_X86_64)
1892 tcc_define_symbol(s
, "__x86_64__", NULL
);
1894 #if defined(TCC_TARGET_ARM)
1895 tcc_define_symbol(s
, "__ARM_ARCH_4__", NULL
);
1896 tcc_define_symbol(s
, "__arm_elf__", NULL
);
1897 tcc_define_symbol(s
, "__arm_elf", NULL
);
1898 tcc_define_symbol(s
, "arm_elf", NULL
);
1899 tcc_define_symbol(s
, "__arm__", NULL
);
1900 tcc_define_symbol(s
, "__arm", NULL
);
1901 tcc_define_symbol(s
, "arm", NULL
);
1902 tcc_define_symbol(s
, "__APCS_32__", NULL
);
1904 #ifdef TCC_TARGET_PE
1905 tcc_define_symbol(s
, "_WIN32", NULL
);
1906 #ifdef TCC_TARGET_X86_64
1907 tcc_define_symbol(s
, "_WIN64", NULL
);
1910 tcc_define_symbol(s
, "__unix__", "1");
1911 tcc_define_symbol(s
, "__unix", "1");
1912 tcc_define_symbol(s
, "unix", "1");
1913 #if defined(__FreeBSD__)
1915 tcc_define_symbol(s
, "__FreeBSD__", str( __FreeBSD__
));
1916 tcc_define_symbol(s
, "__INTEL_COMPILER", "1");
1919 #if defined(__linux)
1920 tcc_define_symbol(s
, "__linux__", NULL
);
1921 tcc_define_symbol(s
, "__linux", NULL
);
1924 /* tiny C specific defines */
1925 sscanf(TCC_VERSION
, "%d.%d.%d", &a
, &b
, &c
);
1926 sprintf(buffer
, "%d", a
*10000 + b
*100 + c
);
1927 tcc_define_symbol(s
, "__TINYC__", buffer
);
1929 /* tiny C & gcc defines */
1930 tcc_define_symbol(s
, "__SIZE_TYPE__", "unsigned long");
1931 tcc_define_symbol(s
, "__PTRDIFF_TYPE__", "long");
1932 #ifdef TCC_TARGET_PE
1933 tcc_define_symbol(s
, "__WCHAR_TYPE__", "unsigned short");
1935 tcc_define_symbol(s
, "__WCHAR_TYPE__", "int");
1938 #ifndef TCC_TARGET_PE
1939 /* default library paths */
1940 tcc_add_library_path(s
, CONFIG_SYSROOT
"/usr/local/lib");
1941 tcc_add_library_path(s
, CONFIG_SYSROOT
"/usr/lib");
1942 tcc_add_library_path(s
, CONFIG_SYSROOT
"/lib");
1945 /* no section zero */
1946 dynarray_add((void ***)&s
->sections
, &s
->nb_sections
, NULL
);
1948 /* create standard sections */
1949 text_section
= new_section(s
, ".text", SHT_PROGBITS
, SHF_ALLOC
| SHF_EXECINSTR
);
1950 data_section
= new_section(s
, ".data", SHT_PROGBITS
, SHF_ALLOC
| SHF_WRITE
);
1951 bss_section
= new_section(s
, ".bss", SHT_NOBITS
, SHF_ALLOC
| SHF_WRITE
);
1953 /* symbols are always generated for linking stage */
1954 symtab_section
= new_symtab(s
, ".symtab", SHT_SYMTAB
, 0,
1956 ".hashtab", SHF_PRIVATE
);
1957 strtab_section
= symtab_section
->link
;
1959 /* private symbol table for dynamic symbols */
1960 s
->dynsymtab_section
= new_symtab(s
, ".dynsymtab", SHT_SYMTAB
, SHF_PRIVATE
,
1962 ".dynhashtab", SHF_PRIVATE
);
1963 s
->alacarte_link
= 1;
1965 #ifdef CHAR_IS_UNSIGNED
1966 s
->char_is_unsigned
= 1;
1968 #if defined(TCC_TARGET_PE) && 0
1969 /* XXX: currently the PE linker is not ready to support that */
1970 s
->leading_underscore
= 1;
1973 if (s
->section_align
== 0)
1974 s
->section_align
= ELF_PAGE_SIZE
;
1976 #ifdef TCC_TARGET_I386
1982 void tcc_delete(TCCState
*s1
)
1988 /* free all sections */
1989 for(i
= 1; i
< s1
->nb_sections
; i
++)
1990 free_section(s1
->sections
[i
]);
1991 dynarray_reset(&s1
->sections
, &s1
->nb_sections
);
1993 for(i
= 0; i
< s1
->nb_priv_sections
; i
++)
1994 free_section(s1
->priv_sections
[i
]);
1995 dynarray_reset(&s1
->priv_sections
, &s1
->nb_priv_sections
);
1997 /* free any loaded DLLs */
1998 for ( i
= 0; i
< s1
->nb_loaded_dlls
; i
++) {
1999 DLLReference
*ref
= s1
->loaded_dlls
[i
];
2001 dlclose(ref
->handle
);
2004 /* free loaded dlls array */
2005 dynarray_reset(&s1
->loaded_dlls
, &s1
->nb_loaded_dlls
);
2007 /* free library paths */
2008 dynarray_reset(&s1
->library_paths
, &s1
->nb_library_paths
);
2010 /* free include paths */
2011 dynarray_reset(&s1
->cached_includes
, &s1
->nb_cached_includes
);
2012 dynarray_reset(&s1
->include_paths
, &s1
->nb_include_paths
);
2013 dynarray_reset(&s1
->sysinclude_paths
, &s1
->nb_sysinclude_paths
);
2015 tcc_free(s1
->tcc_lib_path
);
2019 int tcc_add_include_path(TCCState
*s1
, const char *pathname
)
2023 pathname1
= tcc_strdup(pathname
);
2024 dynarray_add((void ***)&s1
->include_paths
, &s1
->nb_include_paths
, pathname1
);
2028 int tcc_add_sysinclude_path(TCCState
*s1
, const char *pathname
)
2032 pathname1
= tcc_strdup(pathname
);
2033 dynarray_add((void ***)&s1
->sysinclude_paths
, &s1
->nb_sysinclude_paths
, pathname1
);
2037 static int tcc_add_file_internal(TCCState
*s1
, const char *filename
, int flags
)
2042 BufferedFile
*saved_file
;
2046 /* find source file type with extension */
2047 ext
= tcc_fileextension(filename
);
2053 file
= tcc_open(s1
, filename
);
2055 if (flags
& AFF_PRINT_ERROR
)
2056 error_noabort("file '%s' not found", filename
);
2060 if (flags
& AFF_PREPROCESS
) {
2061 ret
= tcc_preprocess(s1
);
2065 if (!ext
[0] || !PATHCMP(ext
, "c")) {
2066 /* C file assumed */
2067 ret
= tcc_compile(s1
);
2071 #ifdef CONFIG_TCC_ASM
2072 if (!strcmp(ext
, "S")) {
2073 /* preprocessed assembler */
2074 ret
= tcc_assemble(s1
, 1);
2078 if (!strcmp(ext
, "s")) {
2079 /* non preprocessed assembler */
2080 ret
= tcc_assemble(s1
, 0);
2086 /* assume executable format: auto guess file type */
2087 size
= read(fd
, &ehdr
, sizeof(ehdr
));
2088 lseek(fd
, 0, SEEK_SET
);
2090 error_noabort("could not read header");
2094 if (size
== sizeof(ehdr
) &&
2095 ehdr
.e_ident
[0] == ELFMAG0
&&
2096 ehdr
.e_ident
[1] == ELFMAG1
&&
2097 ehdr
.e_ident
[2] == ELFMAG2
&&
2098 ehdr
.e_ident
[3] == ELFMAG3
) {
2100 /* do not display line number if error */
2102 if (ehdr
.e_type
== ET_REL
) {
2103 ret
= tcc_load_object_file(s1
, fd
, 0);
2107 #ifndef TCC_TARGET_PE
2108 if (ehdr
.e_type
== ET_DYN
) {
2109 if (s1
->output_type
== TCC_OUTPUT_MEMORY
) {
2111 h
= dlopen(filename
, RTLD_GLOBAL
| RTLD_LAZY
);
2115 ret
= tcc_load_dll(s1
, fd
, filename
,
2116 (flags
& AFF_REFERENCED_DLL
) != 0);
2121 error_noabort("unrecognized ELF file");
2125 if (memcmp((char *)&ehdr
, ARMAG
, 8) == 0) {
2126 file
->line_num
= 0; /* do not display line number if error */
2127 ret
= tcc_load_archive(s1
, fd
);
2131 #ifdef TCC_TARGET_COFF
2132 if (*(uint16_t *)(&ehdr
) == COFF_C67_MAGIC
) {
2133 ret
= tcc_load_coff(s1
, fd
);
2138 #ifdef TCC_TARGET_PE
2139 ret
= pe_load_file(s1
, filename
, fd
);
2141 /* as GNU ld, consider it is an ld script if not recognized */
2142 ret
= tcc_load_ldscript(s1
);
2145 error_noabort("unrecognized file type");
2154 int tcc_add_file(TCCState
*s
, const char *filename
)
2156 if (s
->output_type
== TCC_OUTPUT_PREPROCESS
)
2157 return tcc_add_file_internal(s
, filename
, AFF_PRINT_ERROR
| AFF_PREPROCESS
);
2159 return tcc_add_file_internal(s
, filename
, AFF_PRINT_ERROR
);
2162 int tcc_add_library_path(TCCState
*s
, const char *pathname
)
2166 pathname1
= tcc_strdup(pathname
);
2167 dynarray_add((void ***)&s
->library_paths
, &s
->nb_library_paths
, pathname1
);
2171 /* find and load a dll. Return non zero if not found */
2172 /* XXX: add '-rpath' option support ? */
2173 static int tcc_add_dll(TCCState
*s
, const char *filename
, int flags
)
2178 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
2179 snprintf(buf
, sizeof(buf
), "%s/%s",
2180 s
->library_paths
[i
], filename
);
2181 if (tcc_add_file_internal(s
, buf
, flags
) == 0)
2187 /* the library name is the same as the argument of the '-l' option */
2188 int tcc_add_library(TCCState
*s
, const char *libraryname
)
2193 /* first we look for the dynamic library if not static linking */
2194 if (!s
->static_link
) {
2195 #ifdef TCC_TARGET_PE
2196 if (pe_add_dll(s
, libraryname
) == 0)
2199 snprintf(buf
, sizeof(buf
), "lib%s.so", libraryname
);
2200 if (tcc_add_dll(s
, buf
, 0) == 0)
2204 /* then we look for the static library */
2205 for(i
= 0; i
< s
->nb_library_paths
; i
++) {
2206 snprintf(buf
, sizeof(buf
), "%s/lib%s.a",
2207 s
->library_paths
[i
], libraryname
);
2208 if (tcc_add_file_internal(s
, buf
, 0) == 0)
2214 int tcc_add_symbol(TCCState
*s
, const char *name
, void *val
)
2216 add_elf_sym(symtab_section
, (uplong
)val
, 0,
2217 ELFW(ST_INFO
)(STB_GLOBAL
, STT_NOTYPE
), 0,
2222 int tcc_set_output_type(TCCState
*s
, int output_type
)
2226 s
->output_type
= output_type
;
2229 /* default include paths */
2230 /* XXX: reverse order needed if -isystem support */
2231 #ifndef TCC_TARGET_PE
2232 tcc_add_sysinclude_path(s
, CONFIG_SYSROOT
"/usr/local/include");
2233 tcc_add_sysinclude_path(s
, CONFIG_SYSROOT
"/usr/include");
2235 snprintf(buf
, sizeof(buf
), "%s/include", s
->tcc_lib_path
);
2236 tcc_add_sysinclude_path(s
, buf
);
2237 #ifdef TCC_TARGET_PE
2238 snprintf(buf
, sizeof(buf
), "%s/include/winapi", s
->tcc_lib_path
);
2239 tcc_add_sysinclude_path(s
, buf
);
2243 /* if bound checking, then add corresponding sections */
2244 #ifdef CONFIG_TCC_BCHECK
2245 if (s
->do_bounds_check
) {
2247 tcc_define_symbol(s
, "__BOUNDS_CHECKING_ON", NULL
);
2248 /* create bounds sections */
2249 bounds_section
= new_section(s
, ".bounds",
2250 SHT_PROGBITS
, SHF_ALLOC
);
2251 lbounds_section
= new_section(s
, ".lbounds",
2252 SHT_PROGBITS
, SHF_ALLOC
);
2256 if (s
->char_is_unsigned
) {
2257 tcc_define_symbol(s
, "__CHAR_UNSIGNED__", NULL
);
2260 /* add debug sections */
2263 stab_section
= new_section(s
, ".stab", SHT_PROGBITS
, 0);
2264 stab_section
->sh_entsize
= sizeof(Stab_Sym
);
2265 stabstr_section
= new_section(s
, ".stabstr", SHT_STRTAB
, 0);
2266 put_elf_str(stabstr_section
, "");
2267 stab_section
->link
= stabstr_section
;
2268 /* put first entry */
2269 put_stabs("", 0, 0, 0, 0);
2272 /* add libc crt1/crti objects */
2273 #ifndef TCC_TARGET_PE
2274 if ((output_type
== TCC_OUTPUT_EXE
|| output_type
== TCC_OUTPUT_DLL
) &&
2276 if (output_type
!= TCC_OUTPUT_DLL
)
2277 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crt1.o");
2278 tcc_add_file(s
, CONFIG_TCC_CRT_PREFIX
"/crti.o");
2282 #ifdef TCC_TARGET_PE
2283 snprintf(buf
, sizeof(buf
), "%s/lib", s
->tcc_lib_path
);
2284 tcc_add_library_path(s
, buf
);
2286 if (GetSystemDirectory(buf
, sizeof buf
))
2287 tcc_add_library_path(s
, buf
);
2294 #define WD_ALL 0x0001 /* warning is activated when using -Wall */
2295 #define FD_INVERT 0x0002 /* invert value before storing */
2297 typedef struct FlagDef
{
2303 static const FlagDef warning_defs
[] = {
2304 { offsetof(TCCState
, warn_unsupported
), 0, "unsupported" },
2305 { offsetof(TCCState
, warn_write_strings
), 0, "write-strings" },
2306 { offsetof(TCCState
, warn_error
), 0, "error" },
2307 { offsetof(TCCState
, warn_implicit_function_declaration
), WD_ALL
,
2308 "implicit-function-declaration" },
2311 static int set_flag(TCCState
*s
, const FlagDef
*flags
, int nb_flags
,
2312 const char *name
, int value
)
2319 if (r
[0] == 'n' && r
[1] == 'o' && r
[2] == '-') {
2323 for(i
= 0, p
= flags
; i
< nb_flags
; i
++, p
++) {
2324 if (!strcmp(r
, p
->name
))
2329 if (p
->flags
& FD_INVERT
)
2331 *(int *)((uint8_t *)s
+ p
->offset
) = value
;
2336 /* set/reset a warning */
2337 int tcc_set_warning(TCCState
*s
, const char *warning_name
, int value
)
2342 if (!strcmp(warning_name
, "all")) {
2343 for(i
= 0, p
= warning_defs
; i
< countof(warning_defs
); i
++, p
++) {
2344 if (p
->flags
& WD_ALL
)
2345 *(int *)((uint8_t *)s
+ p
->offset
) = 1;
2349 return set_flag(s
, warning_defs
, countof(warning_defs
),
2350 warning_name
, value
);
2354 static const FlagDef flag_defs
[] = {
2355 { offsetof(TCCState
, char_is_unsigned
), 0, "unsigned-char" },
2356 { offsetof(TCCState
, char_is_unsigned
), FD_INVERT
, "signed-char" },
2357 { offsetof(TCCState
, nocommon
), FD_INVERT
, "common" },
2358 { offsetof(TCCState
, leading_underscore
), 0, "leading-underscore" },
2361 /* set/reset a flag */
2362 int tcc_set_flag(TCCState
*s
, const char *flag_name
, int value
)
2364 return set_flag(s
, flag_defs
, countof(flag_defs
),
2368 /* set CONFIG_TCCDIR at runtime */
2369 void tcc_set_lib_path(TCCState
*s
, const char *path
)
2371 tcc_free(s
->tcc_lib_path
);
2372 s
->tcc_lib_path
= tcc_strdup(path
);
2375 void tcc_print_stats(TCCState
*s
, int64_t total_time
)
2378 tt
= (double)total_time
/ 1000000.0;
2381 if (total_bytes
< 1)
2383 printf("%d idents, %d lines, %d bytes, %0.3f s, %d lines/s, %0.1f MB/s\n",
2384 tok_ident
- TOK_IDENT
, total_lines
, total_bytes
,
2385 tt
, (int)(total_lines
/ tt
),
2386 total_bytes
/ tt
/ 1000000.0);