?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added empty structs support - changed double align to 4 (i386 default ABI) - added...
[tinycc.git] / tcc.c
blob53da6d53397d4f720da5e3223d1df02e198c2c97
1 /*
2 * TCC - Tiny C Compiler
3 *
4 * Copyright (c) 2001, 2002 Fabrice Bellard
5 *
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.
10 *
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.
15 *
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.
19 */
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <stdarg.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <math.h>
26 #include <unistd.h>
27 #include <signal.h>
28 #include <unistd.h>
29 #include <fcntl.h>
30 #include <setjmp.h>
31 #ifdef WIN32
32 #include <sys/timeb.h>
33 #endif
34 #ifndef WIN32
35 #include <sys/time.h>
36 #include <sys/ucontext.h>
37 #endif
38 #include "elf.h"
39 #include "stab.h"
40 #ifndef CONFIG_TCC_STATIC
41 #include <dlfcn.h>
42 #endif
43
44 #include "libtcc.h"
45
46 /* parser debug */
47 //#define PARSE_DEBUG
48 /* preprocessor debug */
49 //#define PP_DEBUG
50 /* include file debug */
51 //#define INC_DEBUG
52
53 //#define MEM_DEBUG
54
55 /* target selection */
56 //#define TCC_TARGET_I386 /* i386 code generator */
57 //#define TCC_TARGET_IL /* .NET CLI generator */
58
59 /* default target is I386 */
60 #if !defined(TCC_TARGET_I386) && !defined(TCC_TARGET_IL)
61 #define TCC_TARGET_I386
62 #endif
63
64 #if !defined(WIN32) && !defined(TCC_UCLIBC) && !defined(TCC_TARGET_IL)
65 #define CONFIG_TCC_BCHECK /* enable bound checking code */
66 #endif
67
68 #ifndef CONFIG_TCC_PREFIX
69 #define CONFIG_TCC_PREFIX "/usr/local"
70 #endif
71
72 /* path to find crt1.o, crti.o and crtn.o. Only needed when generating
73 executables or dlls */
74 #define CONFIG_TCC_CRT_PREFIX "/usr/lib"
75
76 #define INCLUDE_STACK_SIZE 32
77 #define IFDEF_STACK_SIZE 64
78 #define VSTACK_SIZE 64
79 #define STRING_MAX_SIZE 1024
80
81 #define TOK_HASH_SIZE 2048 /* must be a power of two */
82 #define TOK_ALLOC_INCR 512 /* must be a power of two */
83 #define TOK_STR_ALLOC_INCR_BITS 6
84 #define TOK_STR_ALLOC_INCR (1 << TOK_STR_ALLOC_INCR_BITS)
85 #define TOK_MAX_SIZE 4 /* token max size in int unit when stored in string */
86
87 /* token symbol management */
88 typedef struct TokenSym {
89 struct TokenSym *hash_next;
90 struct Sym *sym_define; /* direct pointer to define */
91 struct Sym *sym_label; /* direct pointer to label */
92 struct Sym *sym_struct; /* direct pointer to structure */
93 struct Sym *sym_identifier; /* direct pointer to identifier */
94 int tok; /* token number */
95 int len;
96 char str[1];
97 } TokenSym;
98
99 typedef struct CString {
100 int size; /* size in bytes */
101 void *data; /* either 'char *' or 'int *' */
102 int size_allocated;
103 void *data_allocated; /* if non NULL, data has been malloced */
104 } CString;
105
106 /* type definition */
107 typedef struct CType {
108 int t;
109 struct Sym *ref;
110 } CType;
111
112 /* constant value */
113 typedef union CValue {
114 long double ld;
115 double d;
116 float f;
117 int i;
118 unsigned int ui;
119 unsigned int ul; /* address (should be unsigned long on 64 bit cpu) */
120 long long ll;
121 unsigned long long ull;
122 struct CString *cstr;
123 void *ptr;
124 int tab[1];
125 } CValue;
126
127 /* value on stack */
128 typedef struct SValue {
129 CType type; /* type */
130 unsigned short r; /* register + flags */
131 unsigned short r2; /* second register, used for 'long long'
132 type. If not used, set to VT_CONST */
133 CValue c; /* constant, if VT_CONST */
134 struct Sym *sym; /* symbol, if (VT_SYM | VT_CONST) */
135 } SValue;
136
137 /* symbol management */
138 typedef struct Sym {
139 int v; /* symbol token */
140 int r; /* associated register */
141 int c; /* associated number */
142 CType type; /* associated type */
143 struct Sym *next; /* next related symbol */
144 struct Sym *prev; /* prev symbol in stack */
145 struct Sym *prev_tok; /* previous symbol for this token */
146 } Sym;
147
148 /* section definition */
149 /* XXX: use directly ELF structure for parameters ? */
150 /* special flag to indicate that the section should not be linked to
151 the other ones */
152 #define SHF_PRIVATE 0x80000000
153
154 typedef struct Section {
155 unsigned long data_offset; /* current data offset */
156 unsigned char *data; /* section data */
157 unsigned long data_allocated; /* used for realloc() handling */
158 int sh_name; /* elf section name (only used during output) */
159 int sh_num; /* elf section number */
160 int sh_type; /* elf section type */
161 int sh_flags; /* elf section flags */
162 int sh_info; /* elf section info */
163 int sh_addralign; /* elf section alignment */
164 int sh_entsize; /* elf entry size */
165 unsigned long sh_size; /* section size (only used during output) */
166 unsigned long sh_addr; /* address at which the section is relocated */
167 unsigned long sh_offset; /* address at which the section is relocated */
168 int nb_hashed_syms; /* used to resize the hash table */
169 struct Section *link; /* link to another section */
170 struct Section *reloc; /* corresponding section for relocation, if any */
171 struct Section *hash; /* hash table for symbols */
172 struct Section *next;
173 char name[64]; /* section name */
174 } Section;
175
176 typedef struct DLLReference {
177 int level;
178 char name[1];
179 } DLLReference;
180
181 /* GNUC attribute definition */
182 typedef struct AttributeDef {
183 int aligned;
184 Section *section;
185 unsigned char func_call; /* FUNC_CDECL or FUNC_STDCALL */
186 } AttributeDef;
187
188 #define SYM_STRUCT 0x40000000 /* struct/union/enum symbol space */
189 #define SYM_FIELD 0x20000000 /* struct/union field symbol space */
190 #define SYM_FIRST_ANOM (1 << (31 - VT_STRUCT_SHIFT)) /* first anonymous sym */
191
192 /* stored in 'Sym.c' field */
193 #define FUNC_NEW 1 /* ansi function prototype */
194 #define FUNC_OLD 2 /* old function prototype */
195 #define FUNC_ELLIPSIS 3 /* ansi function prototype with ... */
196
197 /* stored in 'Sym.r' field */
198 #define FUNC_CDECL 0 /* standard c call */
199 #define FUNC_STDCALL 1 /* pascal c call */
200
201 /* field 'Sym.t' for macros */
202 #define MACRO_OBJ 0 /* object like macro */
203 #define MACRO_FUNC 1 /* function like macro */
204
205 /* field 'Sym.r' for labels */
206 #define LABEL_FORWARD 1 /* label is forward defined */
207
208 /* type_decl() types */
209 #define TYPE_ABSTRACT 1 /* type without variable */
210 #define TYPE_DIRECT 2 /* type with variable */
211
212 #define IO_BUF_SIZE 8192
213
214 typedef struct BufferedFile {
215 uint8_t *buf_ptr;
216 uint8_t *buf_end;
217 int fd;
218 int line_num; /* current line number - here to simply code */
219 int ifndef_macro; /* #ifndef macro / #endif search */
220 int ifndef_macro_saved; /* saved ifndef_macro */
221 int *ifdef_stack_ptr; /* ifdef_stack value at the start of the file */
222 char inc_type; /* type of include */
223 char inc_filename[512]; /* filename specified by the user */
224 char filename[1024]; /* current filename - here to simplify code */
225 unsigned char buffer[IO_BUF_SIZE + 1]; /* extra size for CH_EOB char */
226 } BufferedFile;
227
228 #define CH_EOB '\\' /* end of buffer or '\0' char in file */
229 #define CH_EOF (-1) /* end of file */
230
231 /* parsing state (used to save parser state to reparse part of the
232 source several times) */
233 typedef struct ParseState {
234 int *macro_ptr;
235 int line_num;
236 int tok;
237 CValue tokc;
238 } ParseState;
239
240 /* used to record tokens */
241 typedef struct TokenString {
242 int *str;
243 int len;
244 int allocated_len;
245 int last_line_num;
246 } TokenString;
247
248 /* include file cache, used to find files faster and also to eliminate
249 inclusion if the include file is protected by #ifndef ... #endif */
250 typedef struct CachedInclude {
251 int ifndef_macro;
252 char type; /* '"' or '>' to give include type */
253 char filename[1]; /* path specified in #include */
254 } CachedInclude;
255
256 /* parser */
257 static struct BufferedFile *file;
258 static int ch, tok, tok1;
259 static CValue tokc, tok1c;
260 static CString tokcstr; /* current parsed string, if any */
261 /* additionnal informations about token */
262 static int tok_flags;
263 #define TOK_FLAG_BOL 0x0001 /* beginning of line before */
264 #define TOK_FLAG_BOF 0x0002 /* beginning of file before */
265 #define TOK_FLAG_ENDIF 0x0004 /* a endif was found matching starting #ifdef */
266
267 /* if true, line feed is returned as a token. line feed is also
268 returned at eof */
269 static int return_linefeed;
270 static Section *text_section, *data_section, *bss_section; /* predefined sections */
271 static Section *cur_text_section; /* current section where function code is
272 generated */
273 /* bound check related sections */
274 static Section *bounds_section; /* contains global data bound description */
275 static Section *lbounds_section; /* contains local data bound description */
276 /* symbol sections */
277 static Section *symtab_section, *strtab_section;
278
279 /* debug sections */
280 static Section *stab_section, *stabstr_section;
281
282 /* loc : local variable index
283 ind : output code index
284 rsym: return symbol
285 anon_sym: anonymous symbol index
286 */
287 static int rsym, anon_sym, ind, loc;
288 /* expression generation modifiers */
289 static int const_wanted; /* true if constant wanted */
290 static int nocode_wanted; /* true if no code generation wanted for an expression */
291 static int global_expr; /* true if compound literals must be allocated
292 globally (used during initializers parsing */
293 static CType func_vt; /* current function return type (used by return
294 instruction) */
295 static int func_vc;
296 static int last_line_num, last_ind, func_ind; /* debug last line number and pc */
297 static int tok_ident;
298 static TokenSym **table_ident;
299 static TokenSym *hash_ident[TOK_HASH_SIZE];
300 static char token_buf[STRING_MAX_SIZE + 1];
301 static char *funcname;
302 static Sym *global_stack, *local_stack;
303 static Sym *define_stack;
304 static Sym *label_stack;
305
306 static SValue vstack[VSTACK_SIZE], *vtop;
307 static int *macro_ptr, *macro_ptr_allocated;
308 /* some predefined types */
309 static CType char_pointer_type, func_old_type, int_type;
310
311 /* compile with debug symbol (and use them if error during execution) */
312 static int do_debug = 0;
313
314 /* compile with built-in memory and bounds checker */
315 static int do_bounds_check = 0;
316
317 /* display benchmark infos */
318 static int do_bench = 0;
319 static int total_lines;
320 static int total_bytes;
321
322 /* use GNU C extensions */
323 static int gnu_ext = 1;
324
325 /* use Tiny C extensions */
326 static int tcc_ext = 1;
327
328 /* max number of callers shown if error */
329 static int num_callers = 6;
330 static const char **rt_bound_error_msg;
331
332 /* XXX: suppress that ASAP */
333 static struct TCCState *tcc_state;
334
335 /* give the path of the tcc libraries */
336 static const char *tcc_lib_path = CONFIG_TCC_PREFIX "/lib/tcc";
337
338 struct TCCState {
339 int output_type;
340
341 BufferedFile **include_stack_ptr;
342 int *ifdef_stack_ptr;
343
344 /* include file handling */
345 char **include_paths;
346 int nb_include_paths;
347 char **sysinclude_paths;
348 int nb_sysinclude_paths;
349 CachedInclude **cached_includes;
350 int nb_cached_includes;
351
352 char **library_paths;
353 int nb_library_paths;
354
355 /* array of all loaded dlls (including those referenced by loaded
356 dlls) */
357 DLLReference **loaded_dlls;
358 int nb_loaded_dlls;
359
360 /* sections */
361 Section **sections;
362 int nb_sections; /* number of sections, including first dummy section */
363
364 /* got handling */
365 Section *got;
366 unsigned long *got_offsets;
367 int nb_got_offsets;
368 int nb_plt_entries;
369 /* give the correspondance from symtab indexes to dynsym indexes */
370 int *symtab_to_dynsym;
371
372 /* temporary dynamic symbol sections (for dll loading) */
373 Section *dynsymtab_section;
374 /* exported dynamic symbol section */
375 Section *dynsym;
376
377 /* if true, static linking is performed */
378 int static_link;
379
380 /* error handling */
381 void *error_opaque;
382 void (*error_func)(void *opaque, const char *msg);
383 int error_set_jmp_enabled;
384 jmp_buf error_jmp_buf;
385 int nb_errors;
386
387 /* see include_stack_ptr */
388 BufferedFile *include_stack[INCLUDE_STACK_SIZE];
389
390 /* see ifdef_stack_ptr */
391 int ifdef_stack[IFDEF_STACK_SIZE];
392 };
393
394 /* The current value can be: */
395 #define VT_VALMASK 0x00ff
396 #define VT_CONST 0x00f0 /* constant in vc
397 (must be first non register value) */
398 #define VT_LLOCAL 0x00f1 /* lvalue, offset on stack */
399 #define VT_LOCAL 0x00f2 /* offset on stack */
400 #define VT_CMP 0x00f3 /* the value is stored in processor flags (in vc) */
401 #define VT_JMP 0x00f4 /* value is the consequence of jmp true (even) */
402 #define VT_JMPI 0x00f5 /* value is the consequence of jmp false (odd) */
403 #define VT_LVAL 0x0100 /* var is an lvalue */
404 #define VT_SYM 0x0200 /* a symbol value is added */
405 #define VT_MUSTCAST 0x0400 /* value must be casted to be correct (used for
406 char/short stored in integer registers) */
407 #define VT_MUSTBOUND 0x0800 /* bound checking must be done before
408 dereferencing value */
409 #define VT_BOUNDED 0x8000 /* value is bounded. The address of the
410 bounding function call point is in vc */
411 #define VT_LVAL_BYTE 0x1000 /* lvalue is a byte */
412 #define VT_LVAL_SHORT 0x2000 /* lvalue is a short */
413 #define VT_LVAL_UNSIGNED 0x4000 /* lvalue is unsigned */
414 #define VT_LVAL_TYPE (VT_LVAL_BYTE | VT_LVAL_SHORT | VT_LVAL_UNSIGNED)
415
416 /* types */
417 #define VT_STRUCT_SHIFT 12 /* structure/enum name shift (20 bits left) */
418
419 #define VT_INT 0 /* integer type */
420 #define VT_BYTE 1 /* signed byte type */
421 #define VT_SHORT 2 /* short type */
422 #define VT_VOID 3 /* void type */
423 #define VT_PTR 4 /* pointer */
424 #define VT_ENUM 5 /* enum definition */
425 #define VT_FUNC 6 /* function type */
426 #define VT_STRUCT 7 /* struct/union definition */
427 #define VT_FLOAT 8 /* IEEE float */
428 #define VT_DOUBLE 9 /* IEEE double */
429 #define VT_LDOUBLE 10 /* IEEE long double */
430 #define VT_BOOL 11 /* ISOC99 boolean type */
431 #define VT_LLONG 12 /* 64 bit integer */
432 #define VT_LONG 13 /* long integer (NEVER USED as type, only
433 during parsing) */
434 #define VT_BTYPE 0x000f /* mask for basic type */
435 #define VT_UNSIGNED 0x0010 /* unsigned type */
436 #define VT_ARRAY 0x0020 /* array type (also has VT_PTR) */
437 #define VT_BITFIELD 0x0040 /* bitfield modifier */
438
439 /* storage */
440 #define VT_EXTERN 0x00000080 /* extern definition */
441 #define VT_STATIC 0x00000100 /* static variable */
442 #define VT_TYPEDEF 0x00000200 /* typedef definition */
443
444 /* type mask (except storage) */
445 #define VT_TYPE (~(VT_EXTERN | VT_STATIC | VT_TYPEDEF))
446
447 /* token values */
448
449 /* warning: the following compare tokens depend on i386 asm code */
450 #define TOK_ULT 0x92
451 #define TOK_UGE 0x93
452 #define TOK_EQ 0x94
453 #define TOK_NE 0x95
454 #define TOK_ULE 0x96
455 #define TOK_UGT 0x97
456 #define TOK_LT 0x9c
457 #define TOK_GE 0x9d
458 #define TOK_LE 0x9e
459 #define TOK_GT 0x9f
460
461 #define TOK_LAND 0xa0
462 #define TOK_LOR 0xa1
463
464 #define TOK_DEC 0xa2
465 #define TOK_MID 0xa3 /* inc/dec, to void constant */
466 #define TOK_INC 0xa4
467 #define TOK_UDIV 0xb0 /* unsigned division */
468 #define TOK_UMOD 0xb1 /* unsigned modulo */
469 #define TOK_PDIV 0xb2 /* fast division with undefined rounding for pointers */
470 #define TOK_CINT 0xb3 /* number in tokc */
471 #define TOK_CCHAR 0xb4 /* char constant in tokc */
472 #define TOK_STR 0xb5 /* pointer to string in tokc */
473 #define TOK_TWOSHARPS 0xb6 /* ## preprocessing token */
474 #define TOK_LCHAR 0xb7
475 #define TOK_LSTR 0xb8
476 #define TOK_CFLOAT 0xb9 /* float constant */
477 #define TOK_LINENUM 0xba /* line number info */
478 #define TOK_CDOUBLE 0xc0 /* double constant */
479 #define TOK_CLDOUBLE 0xc1 /* long double constant */
480 #define TOK_UMULL 0xc2 /* unsigned 32x32 -> 64 mul */
481 #define TOK_ADDC1 0xc3 /* add with carry generation */
482 #define TOK_ADDC2 0xc4 /* add with carry use */
483 #define TOK_SUBC1 0xc5 /* add with carry generation */
484 #define TOK_SUBC2 0xc6 /* add with carry use */
485 #define TOK_CUINT 0xc8 /* unsigned int constant */
486 #define TOK_CLLONG 0xc9 /* long long constant */
487 #define TOK_CULLONG 0xca /* unsigned long long constant */
488 #define TOK_ARROW 0xcb
489 #define TOK_DOTS 0xcc /* three dots */
490 #define TOK_SHR 0xcd /* unsigned shift right */
491 #define TOK_PPNUM 0xce /* preprocessor number */
492
493 #define TOK_SHL 0x01 /* shift left */
494 #define TOK_SAR 0x02 /* signed shift right */
495
496 /* assignement operators : normal operator or 0x80 */
497 #define TOK_A_MOD 0xa5
498 #define TOK_A_AND 0xa6
499 #define TOK_A_MUL 0xaa
500 #define TOK_A_ADD 0xab
501 #define TOK_A_SUB 0xad
502 #define TOK_A_DIV 0xaf
503 #define TOK_A_XOR 0xde
504 #define TOK_A_OR 0xfc
505 #define TOK_A_SHL 0x81
506 #define TOK_A_SAR 0x82
507
508 /* WARNING: the content of this string encodes token numbers */
509 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";
510
511 #define TOK_EOF (-1) /* end of file */
512 #define TOK_LINEFEED 10 /* line feed */
513
514 /* all identificators and strings have token above that */
515 #define TOK_IDENT 256
516
517 enum {
518 TOK_LAST = TOK_IDENT - 1,
519 #define DEF(id, str) id,
520 #include "tcctok.h"
521 #undef DEF
522 };
523
524 static const char *tcc_keywords =
525 #define DEF(id, str) str "\0"
526 #include "tcctok.h"
527 #undef DEF
528 ;
529
530 #define TOK_UIDENT TOK_DEFINE
531
532 #ifdef WIN32
533 #define snprintf _snprintf
534 #define vsnprintf _vsnprintf
535 #endif
536
537 #if defined(WIN32) || defined(TCC_UCLIBC)
538 /* currently incorrect */
539 long double strtold(const char *nptr, char **endptr)
540 {
541 return (long double)strtod(nptr, endptr);
542 }
543 float strtof(const char *nptr, char **endptr)
544 {
545 return (float)strtod(nptr, endptr);
546 }
547 #else
548 /* XXX: need to define this to use them in non ISOC99 context */
549 extern float strtof (const char *__nptr, char **__endptr);
550 extern long double strtold (const char *__nptr, char **__endptr);
551 #endif
552
553 static char *pstrcpy(char *buf, int buf_size, const char *s);
554 static char *pstrcat(char *buf, int buf_size, const char *s);
555
556 static void next(void);
557 static void next_nomacro(void);
558 static void parse_expr_type(CType *type);
559 static void expr_type(CType *type);
560 static void unary_type(CType *type);
561 static int expr_const(void);
562 static void expr_eq(void);
563 static void gexpr(void);
564 static void decl(int l);
565 static void decl_initializer(CType *type, Section *sec, unsigned long c,
566 int first, int size_only);
567 static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
568 int has_init, int v, int scope);
569 int gv(int rc);
570 void gv2(int rc1, int rc2);
571 void move_reg(int r, int s);
572 void save_regs(int n);
573 void save_reg(int r);
574 void vpop(void);
575 void vswap(void);
576 void vdup(void);
577 int get_reg(int rc);
578
579 static void macro_subst(TokenString *tok_str,
580 Sym **nested_list, int *macro_str);
581 int save_reg_forced(int r);
582 void gen_op(int op);
583 void force_charshort_cast(int t);
584 static void gen_cast(CType *type);
585 void vstore(void);
586 static Sym *sym_find(int v);
587 static Sym *sym_push(int v, CType *type, int r, int c);
588
589 /* type handling */
590 static int type_size(CType *type, int *a);
591 static inline CType *pointed_type(CType *type);
592 static int pointed_size(CType *type);
593 static int lvalue_type(int t);
594 static int is_compatible_types(CType *type1, CType *type2);
595 static int parse_btype(CType *type, AttributeDef *ad);
596 static void type_decl(CType *type, AttributeDef *ad, int *v, int td);
597
598 void error(const char *fmt, ...);
599 void vpushi(int v);
600 void vset(CType *type, int r, int v);
601 void type_to_str(char *buf, int buf_size,
602 CType *type, const char *varstr);
603 char *get_tok_str(int v, CValue *cv);
604 static Sym *get_sym_ref(CType *type, Section *sec,
605 unsigned long offset, unsigned long size);
606 static Sym *external_global_sym(int v, CType *type, int r);
607
608 /* section generation */
609 static void section_realloc(Section *sec, unsigned long new_size);
610 static void *section_ptr_add(Section *sec, unsigned long size);
611 static void put_extern_sym(Sym *sym, Section *section,
612 unsigned long value, unsigned long size);
613 static void greloc(Section *s, Sym *sym, unsigned long addr, int type);
614 static int put_elf_str(Section *s, const char *sym);
615 static int put_elf_sym(Section *s,
616 unsigned long value, unsigned long size,
617 int info, int other, int shndx, const char *name);
618 static int add_elf_sym(Section *s, unsigned long value, unsigned long size,
619 int info, int sh_num, const char *name);
620 static void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
621 int type, int symbol);
622 static void put_stabs(const char *str, int type, int other, int desc,
623 unsigned long value);
624 static void put_stabs_r(const char *str, int type, int other, int desc,
625 unsigned long value, Section *sec, int sym_index);
626 static void put_stabn(int type, int other, int desc, int value);
627 static void put_stabd(int type, int other, int desc);
628 static int tcc_add_dll(TCCState *s, const char *filename, int flags);
629
630 #define AFF_PRINT_ERROR 0x0001 /* print error if file not found */
631 #define AFF_REFERENCED_DLL 0x0002 /* load a referenced dll from another dll */
632 static int tcc_add_file_internal(TCCState *s, const char *filename, int flags);
633
634 /* true if float/double/long double type */
635 static inline int is_float(int t)
636 {
637 int bt;
638 bt = t & VT_BTYPE;
639 return bt == VT_LDOUBLE || bt == VT_DOUBLE || bt == VT_FLOAT;
640 }
641
642 #ifdef TCC_TARGET_I386
643 #include "i386-gen.c"
644 #endif
645 #ifdef TCC_TARGET_IL
646 #include "il-gen.c"
647 #endif
648
649 #ifdef CONFIG_TCC_STATIC
650
651 #define RTLD_LAZY 0x001
652 #define RTLD_NOW 0x002
653 #define RTLD_GLOBAL 0x100
654 #define RTLD_DEFAULT NULL
655
656 /* dummy function for profiling */
657 void *dlopen(const char *filename, int flag)
658 {
659 return NULL;
660 }
661
662 const char *dlerror(void)
663 {
664 return "error";
665 }
666
667 typedef struct TCCSyms {
668 char *str;
669 void *ptr;
670 } TCCSyms;
671
672 #define TCCSYM(a) { #a, &a, },
673
674 /* add the symbol you want here if no dynamic linking is done */
675 static TCCSyms tcc_syms[] = {
676 TCCSYM(printf)
677 TCCSYM(fprintf)
678 TCCSYM(fopen)
679 TCCSYM(fclose)
680 { NULL, NULL },
681 };
682
683 void *dlsym(void *handle, const char *symbol)
684 {
685 TCCSyms *p;
686 p = tcc_syms;
687 while (p->str != NULL) {
688 if (!strcmp(p->str, symbol))
689 return p->ptr;
690 p++;
691 }
692 return NULL;
693 }
694
695 #endif
696
697 /********************************************************/
698
699 /* we use our own 'finite' function to avoid potential problems with
700 non standard math libs */
701 /* XXX: endianness dependant */
702 int ieee_finite(double d)
703 {
704 int *p = (int *)&d;
705 return ((unsigned)((p[1] | 0x800fffff) + 1)) >> 31;
706 }
707
708 /* copy a string and truncate it. */
709 static char *pstrcpy(char *buf, int buf_size, const char *s)
710 {
711 char *q, *q_end;
712 int c;
713
714 if (buf_size > 0) {
715 q = buf;
716 q_end = buf + buf_size - 1;
717 while (q < q_end) {
718 c = *s++;
719 if (c == '\0')
720 break;
721 *q++ = c;
722 }
723 *q = '\0';
724 }
725 return buf;
726 }
727
728 /* strcat and truncate. */
729 static char *pstrcat(char *buf, int buf_size, const char *s)
730 {
731 int len;
732 len = strlen(buf);
733 if (len < buf_size)
734 pstrcpy(buf + len, buf_size - len, s);
735 return buf;
736 }
737
738 /* memory management */
739 #ifdef MEM_DEBUG
740 int mem_cur_size;
741 int mem_max_size;
742 #endif
743
744 static inline void tcc_free(void *ptr)
745 {
746 #ifdef MEM_DEBUG
747 mem_cur_size -= malloc_usable_size(ptr);
748 #endif
749 free(ptr);
750 }
751
752 static void *tcc_malloc(unsigned long size)
753 {
754 void *ptr;
755 ptr = malloc(size);
756 if (!ptr && size)
757 error("memory full");
758 #ifdef MEM_DEBUG
759 mem_cur_size += malloc_usable_size(ptr);
760 if (mem_cur_size > mem_max_size)
761 mem_max_size = mem_cur_size;
762 #endif
763 return ptr;
764 }
765
766 static void *tcc_mallocz(unsigned long size)
767 {
768 void *ptr;
769 ptr = tcc_malloc(size);
770 memset(ptr, 0, size);
771 return ptr;
772 }
773
774 static inline void *tcc_realloc(void *ptr, unsigned long size)
775 {
776 void *ptr1;
777 #ifdef MEM_DEBUG
778 mem_cur_size -= malloc_usable_size(ptr);
779 #endif
780 ptr1 = realloc(ptr, size);
781 #ifdef MEM_DEBUG
782 /* NOTE: count not correct if alloc error, but not critical */
783 mem_cur_size += malloc_usable_size(ptr1);
784 if (mem_cur_size > mem_max_size)
785 mem_max_size = mem_cur_size;
786 #endif
787 return ptr1;
788 }
789
790 static char *tcc_strdup(const char *str)
791 {
792 char *ptr;
793 ptr = tcc_malloc(strlen(str) + 1);
794 strcpy(ptr, str);
795 return ptr;
796 }
797
798 #define free(p) use_tcc_free(p)
799 #define malloc(s) use_tcc_malloc(s)
800 #define realloc(p, s) use_tcc_realloc(p, s)
801
802 static void dynarray_add(void ***ptab, int *nb_ptr, void *data)
803 {
804 int nb, nb_alloc;
805 void **pp;
806
807 nb = *nb_ptr;
808 pp = *ptab;
809 /* every power of two we double array size */
810 if ((nb & (nb - 1)) == 0) {
811 if (!nb)
812 nb_alloc = 1;
813 else
814 nb_alloc = nb * 2;
815 pp = tcc_realloc(pp, nb_alloc * sizeof(void *));
816 if (!pp)
817 error("memory full");
818 *ptab = pp;
819 }
820 pp[nb++] = data;
821 *nb_ptr = nb;
822 }
823
824 Section *new_section(TCCState *s1, const char *name, int sh_type, int sh_flags)
825 {
826 Section *sec;
827
828 sec = tcc_mallocz(sizeof(Section));
829 pstrcpy(sec->name, sizeof(sec->name), name);
830 sec->sh_type = sh_type;
831 sec->sh_flags = sh_flags;
832 switch(sh_type) {
833 case SHT_HASH:
834 case SHT_REL:
835 case SHT_DYNSYM:
836 case SHT_SYMTAB:
837 case SHT_DYNAMIC:
838 sec->sh_addralign = 4;
839 break;
840 case SHT_STRTAB:
841 sec->sh_addralign = 1;
842 break;
843 default:
844 sec->sh_addralign = 32; /* default conservative alignment */
845 break;
846 }
847
848 /* only add section if not private */
849 if (!(sh_flags & SHF_PRIVATE)) {
850 sec->sh_num = s1->nb_sections;
851 dynarray_add((void ***)&s1->sections, &s1->nb_sections, sec);
852 }
853 return sec;
854 }
855
856 static void free_section(Section *s)
857 {
858 tcc_free(s->data);
859 tcc_free(s);
860 }
861
862 /* realloc section and set its content to zero */
863 static void section_realloc(Section *sec, unsigned long new_size)
864 {
865 unsigned long size;
866 unsigned char *data;
867
868 size = sec->data_allocated;
869 if (size == 0)
870 size = 1;
871 while (size < new_size)
872 size = size * 2;
873 data = tcc_realloc(sec->data, size);
874 if (!data)
875 error("memory full");
876 memset(data + sec->data_allocated, 0, size - sec->data_allocated);
877 sec->data = data;
878 sec->data_allocated = size;
879 }
880
881 /* reserve at least 'size' bytes in section 'sec' from
882 sec->data_offset. */
883 static void *section_ptr_add(Section *sec, unsigned long size)
884 {
885 unsigned long offset, offset1;
886
887 offset = sec->data_offset;
888 offset1 = offset + size;
889 if (offset1 > sec->data_allocated)
890 section_realloc(sec, offset1);
891 sec->data_offset = offset1;
892 return sec->data + offset;
893 }
894
895 /* return a reference to a section, and create it if it does not
896 exists */
897 Section *find_section(TCCState *s1, const char *name)
898 {
899 Section *sec;
900 int i;
901 for(i = 1; i < s1->nb_sections; i++) {
902 sec = s1->sections[i];
903 if (!strcmp(name, sec->name))
904 return sec;
905 }
906 /* sections are created as PROGBITS */
907 return new_section(s1, name, SHT_PROGBITS, SHF_ALLOC);
908 }
909
910 /* update sym->c so that it points to an external symbol in section
911 'section' with value 'value' */
912 static void put_extern_sym(Sym *sym, Section *section,
913 unsigned long value, unsigned long size)
914 {
915 int sym_type, sym_bind, sh_num, info;
916 Elf32_Sym *esym;
917 const char *name;
918
919 if (section)
920 sh_num = section->sh_num;
921 else
922 sh_num = SHN_UNDEF;
923 if (!sym->c) {
924 if ((sym->type.t & VT_BTYPE) == VT_FUNC)
925 sym_type = STT_FUNC;
926 else
927 sym_type = STT_OBJECT;
928 if (sym->type.t & VT_STATIC)
929 sym_bind = STB_LOCAL;
930 else
931 sym_bind = STB_GLOBAL;
932
933 name = get_tok_str(sym->v, NULL);
934 #ifdef CONFIG_TCC_BCHECK
935 if (do_bounds_check) {
936 char buf[32];
937
938 /* XXX: avoid doing that for statics ? */
939 /* if bound checking is activated, we change some function
940 names by adding the "__bound" prefix */
941 switch(sym->v) {
942 #if 0
943 /* XXX: we rely only on malloc hooks */
944 case TOK_malloc:
945 case TOK_free:
946 case TOK_realloc:
947 case TOK_memalign:
948 case TOK_calloc:
949 #endif
950 case TOK_memcpy:
951 case TOK_memmove:
952 case TOK_memset:
953 case TOK_strlen:
954 case TOK_strcpy:
955 strcpy(buf, "__bound_");
956 strcat(buf, name);
957 name = buf;
958 break;
959 }
960 }
961 #endif
962 info = ELF32_ST_INFO(sym_bind, sym_type);
963 sym->c = add_elf_sym(symtab_section, value, size, info, sh_num, name);
964 } else {
965 esym = &((Elf32_Sym *)symtab_section->data)[sym->c];
966 esym->st_value = value;
967 esym->st_size = size;
968 esym->st_shndx = sh_num;
969 }
970 }
971
972 /* add a new relocation entry to symbol 'sym' in section 's' */
973 static void greloc(Section *s, Sym *sym, unsigned long offset, int type)
974 {
975 if (!sym->c)
976 put_extern_sym(sym, NULL, 0, 0);
977 /* now we can add ELF relocation info */
978 put_elf_reloc(symtab_section, s, offset, type, sym->c);
979 }
980
981 static inline int isid(int c)
982 {
983 return (c >= 'a' && c <= 'z') ||
984 (c >= 'A' && c <= 'Z') ||
985 c == '_';
986 }
987
988 static inline int isnum(int c)
989 {
990 return c >= '0' && c <= '9';
991 }
992
993 static inline int isoct(int c)
994 {
995 return c >= '0' && c <= '7';
996 }
997
998 static inline int toup(int c)
999 {
1000 if (c >= 'a' && c <= 'z')
1001 return c - 'a' + 'A';
1002 else
1003 return c;
1004 }
1005
1006 static void strcat_vprintf(char *buf, int buf_size, const char *fmt, va_list ap)
1007 {
1008 int len;
1009 len = strlen(buf);
1010 vsnprintf(buf + len, buf_size - len, fmt, ap);
1011 }
1012
1013 static void strcat_printf(char *buf, int buf_size, const char *fmt, ...)
1014 {
1015 va_list ap;
1016 va_start(ap, fmt);
1017 strcat_vprintf(buf, buf_size, fmt, ap);
1018 va_end(ap);
1019 }
1020
1021 void error1(TCCState *s1, int is_warning, const char *fmt, va_list ap)
1022 {
1023 char buf[2048];
1024 BufferedFile **f;
1025
1026 buf[0] = '\0';
1027 if (file) {
1028 for(f = s1->include_stack; f < s1->include_stack_ptr; f++)
1029 strcat_printf(buf, sizeof(buf), "In file included from %s:%d:\n",
1030 (*f)->filename, (*f)->line_num);
1031 if (file->line_num > 0) {
1032 strcat_printf(buf, sizeof(buf),
1033 "%s:%d: ", file->filename, file->line_num);
1034 } else {
1035 strcat_printf(buf, sizeof(buf),
1036 "%s: ", file->filename);
1037 }
1038 } else {
1039 strcat_printf(buf, sizeof(buf),
1040 "tcc: ");
1041 }
1042 if (is_warning)
1043 strcat_printf(buf, sizeof(buf), "warning: ");
1044 strcat_vprintf(buf, sizeof(buf), fmt, ap);
1045
1046 if (!s1->error_func) {
1047 /* default case: stderr */
1048 fprintf(stderr, "%s\n", buf);
1049 } else {
1050 s1->error_func(s1->error_opaque, buf);
1051 }
1052 if (!is_warning)
1053 s1->nb_errors++;
1054 }
1055
1056 #ifdef LIBTCC
1057 void tcc_set_error_func(TCCState *s, void *error_opaque,
1058 void (*error_func)(void *opaque, const char *msg))
1059 {
1060 s->error_opaque = error_opaque;
1061 s->error_func = error_func;
1062 }
1063 #endif
1064
1065 /* error without aborting current compilation */
1066 void error_noabort(const char *fmt, ...)
1067 {
1068 TCCState *s1 = tcc_state;
1069 va_list ap;
1070
1071 va_start(ap, fmt);
1072 error1(s1, 0, fmt, ap);
1073 va_end(ap);
1074 }
1075
1076 void error(const char *fmt, ...)
1077 {
1078 TCCState *s1 = tcc_state;
1079 va_list ap;
1080
1081 va_start(ap, fmt);
1082 error1(s1, 0, fmt, ap);
1083 va_end(ap);
1084 /* better than nothing: in some cases, we accept to handle errors */
1085 if (s1->error_set_jmp_enabled) {
1086 longjmp(s1->error_jmp_buf, 1);
1087 } else {
1088 /* XXX: suppress it someday */
1089 exit(1);
1090 }
1091 }
1092
1093 void expect(const char *msg)
1094 {
1095 error("%s expected", msg);
1096 }
1097
1098 void warning(const char *fmt, ...)
1099 {
1100 TCCState *s1 = tcc_state;
1101 va_list ap;
1102
1103 va_start(ap, fmt);
1104 error1(s1, 1, fmt, ap);
1105 va_end(ap);
1106 }
1107
1108 void skip(int c)
1109 {
1110 if (tok != c)
1111 error("'%c' expected", c);
1112 next();
1113 }
1114
1115 void test_lvalue(void)
1116 {
1117 if (!(vtop->r & VT_LVAL))
1118 expect("lvalue");
1119 }
1120
1121 /* allocate a new token */
1122 static TokenSym *tok_alloc_new(TokenSym **pts, const char *str, int len)
1123 {
1124 TokenSym *ts, **ptable;
1125 int i;
1126
1127 if (tok_ident >= SYM_FIRST_ANOM)
1128 error("memory full");
1129
1130 /* expand token table if needed */
1131 i = tok_ident - TOK_IDENT;
1132 if ((i % TOK_ALLOC_INCR) == 0) {
1133 ptable = tcc_realloc(table_ident, (i + TOK_ALLOC_INCR) * sizeof(TokenSym *));
1134 if (!ptable)
1135 error("memory full");
1136 table_ident = ptable;
1137 }
1138
1139 ts = tcc_malloc(sizeof(TokenSym) + len);
1140 table_ident[i] = ts;
1141 ts->tok = tok_ident++;
1142 ts->sym_define = NULL;
1143 ts->sym_label = NULL;
1144 ts->sym_struct = NULL;
1145 ts->sym_identifier = NULL;
1146 ts->len = len;
1147 ts->hash_next = NULL;
1148 memcpy(ts->str, str, len);
1149 ts->str[len] = '\0';
1150 *pts = ts;
1151 return ts;
1152 }
1153
1154 #define TOK_HASH_INIT 1
1155 #define TOK_HASH_FUNC(h, c) ((h) * 263 + (c))
1156
1157 /* find a token and add it if not found */
1158 static TokenSym *tok_alloc(const char *str, int len)
1159 {
1160 TokenSym *ts, **pts;
1161 int i;
1162 unsigned int h;
1163
1164 h = TOK_HASH_INIT;
1165 for(i=0;i<len;i++)
1166 h = TOK_HASH_FUNC(h, ((unsigned char *)str)[i]);
1167 h &= (TOK_HASH_SIZE - 1);
1168
1169 pts = &hash_ident[h];
1170 for(;;) {
1171 ts = *pts;
1172 if (!ts)
1173 break;
1174 if (ts->len == len && !memcmp(ts->str, str, len))
1175 return ts;
1176 pts = &(ts->hash_next);
1177 }
1178 return tok_alloc_new(pts, str, len);
1179 }
1180
1181 /* CString handling */
1182
1183 static void cstr_realloc(CString *cstr, int new_size)
1184 {
1185 int size;
1186 void *data;
1187
1188 size = cstr->size_allocated;
1189 if (size == 0)
1190 size = 8; /* no need to allocate a too small first string */
1191 while (size < new_size)
1192 size = size * 2;
1193 data = tcc_realloc(cstr->data_allocated, size);
1194 if (!data)
1195 error("memory full");
1196 cstr->data_allocated = data;
1197 cstr->size_allocated = size;
1198 cstr->data = data;
1199 }
1200
1201 /* add a byte */
1202 static void cstr_ccat(CString *cstr, int ch)
1203 {
1204 int size;
1205 size = cstr->size + 1;
1206 if (size > cstr->size_allocated)
1207 cstr_realloc(cstr, size);
1208 ((unsigned char *)cstr->data)[size - 1] = ch;
1209 cstr->size = size;
1210 }
1211
1212 static void cstr_cat(CString *cstr, const char *str)
1213 {
1214 int c;
1215 for(;;) {
1216 c = *str;
1217 if (c == '\0')
1218 break;
1219 cstr_ccat(cstr, c);
1220 str++;
1221 }
1222 }
1223
1224 /* add a wide char */
1225 static void cstr_wccat(CString *cstr, int ch)
1226 {
1227 int size;
1228 size = cstr->size + sizeof(int);
1229 if (size > cstr->size_allocated)
1230 cstr_realloc(cstr, size);
1231 *(int *)(((unsigned char *)cstr->data) + size - sizeof(int)) = ch;
1232 cstr->size = size;
1233 }
1234
1235 static void cstr_new(CString *cstr)
1236 {
1237 memset(cstr, 0, sizeof(CString));
1238 }
1239
1240 /* free string and reset it to NULL */
1241 static void cstr_free(CString *cstr)
1242 {
1243 tcc_free(cstr->data_allocated);
1244 cstr_new(cstr);
1245 }
1246
1247 #define cstr_reset(cstr) cstr_free(cstr)
1248
1249 static CString *cstr_dup(CString *cstr1)
1250 {
1251 CString *cstr;
1252 int size;
1253
1254 cstr = tcc_malloc(sizeof(CString));
1255 size = cstr1->size;
1256 cstr->size = size;
1257 cstr->size_allocated = size;
1258 cstr->data_allocated = tcc_malloc(size);
1259 cstr->data = cstr->data_allocated;
1260 memcpy(cstr->data_allocated, cstr1->data_allocated, size);
1261 return cstr;
1262 }
1263
1264 /* XXX: unicode ? */
1265 static void add_char(CString *cstr, int c)
1266 {
1267 if (c == '\'' || c == '\"' || c == '\\') {
1268 /* XXX: could be more precise if char or string */
1269 cstr_ccat(cstr, '\\');
1270 }
1271 if (c >= 32 && c <= 126) {
1272 cstr_ccat(cstr, c);
1273 } else {
1274 cstr_ccat(cstr, '\\');
1275 if (c == '\n') {
1276 cstr_ccat(cstr, 'n');
1277 } else {
1278 cstr_ccat(cstr, '0' + ((c >> 6) & 7));
1279 cstr_ccat(cstr, '0' + ((c >> 3) & 7));
1280 cstr_ccat(cstr, '0' + (c & 7));
1281 }
1282 }
1283 }
1284
1285 /* XXX: buffer overflow */
1286 /* XXX: float tokens */
1287 char *get_tok_str(int v, CValue *cv)
1288 {
1289 static char buf[STRING_MAX_SIZE + 1];
1290 static CString cstr_buf;
1291 CString *cstr;
1292 unsigned char *q;
1293 char *p;
1294 int i, len;
1295
1296 /* NOTE: to go faster, we give a fixed buffer for small strings */
1297 cstr_reset(&cstr_buf);
1298 cstr_buf.data = buf;
1299 cstr_buf.size_allocated = sizeof(buf);
1300 p = buf;
1301
1302 switch(v) {
1303 case TOK_CINT:
1304 case TOK_CUINT:
1305 /* XXX: not quite exact, but only useful for testing */
1306 sprintf(p, "%u", cv->ui);
1307 break;
1308 case TOK_CLLONG:
1309 case TOK_CULLONG:
1310 /* XXX: not quite exact, but only useful for testing */
1311 sprintf(p, "%Lu", cv->ull);
1312 break;
1313 case TOK_CCHAR:
1314 case TOK_LCHAR:
1315 cstr_ccat(&cstr_buf, '\'');
1316 add_char(&cstr_buf, cv->i);
1317 cstr_ccat(&cstr_buf, '\'');
1318 cstr_ccat(&cstr_buf, '\0');
1319 break;
1320 case TOK_PPNUM:
1321 cstr = cv->cstr;
1322 len = cstr->size - 1;
1323 for(i=0;i<len;i++)
1324 add_char(&cstr_buf, ((unsigned char *)cstr->data)[i]);
1325 cstr_ccat(&cstr_buf, '\0');
1326 break;
1327 case TOK_STR:
1328 case TOK_LSTR:
1329 cstr = cv->cstr;
1330 cstr_ccat(&cstr_buf, '\"');
1331 if (v == TOK_STR) {
1332 len = cstr->size - 1;
1333 for(i=0;i<len;i++)
1334 add_char(&cstr_buf, ((unsigned char *)cstr->data)[i]);
1335 } else {
1336 len = (cstr->size / sizeof(int)) - 1;
1337 for(i=0;i<len;i++)
1338 add_char(&cstr_buf, ((int *)cstr->data)[i]);
1339 }
1340 cstr_ccat(&cstr_buf, '\"');
1341 cstr_ccat(&cstr_buf, '\0');
1342 break;
1343 case TOK_LT:
1344 v = '<';
1345 goto addv;
1346 case TOK_GT:
1347 v = '>';
1348 goto addv;
1349 case TOK_A_SHL:
1350 return strcpy(p, "<<=");
1351 case TOK_A_SAR:
1352 return strcpy(p, ">>=");
1353 default:
1354 if (v < TOK_IDENT) {
1355 /* search in two bytes table */
1356 q = tok_two_chars;
1357 while (*q) {
1358 if (q[2] == v) {
1359 *p++ = q[0];
1360 *p++ = q[1];
1361 *p = '\0';
1362 return buf;
1363 }
1364 q += 3;
1365 }
1366 addv:
1367 *p++ = v;
1368 *p = '\0';
1369 } else if (v < tok_ident) {
1370 return table_ident[v - TOK_IDENT]->str;
1371 } else if (v >= SYM_FIRST_ANOM) {
1372 /* special name for anonymous symbol */
1373 sprintf(p, "L.%u", v - SYM_FIRST_ANOM);
1374 } else {
1375 /* should never happen */
1376 return NULL;
1377 }
1378 break;
1379 }
1380 return cstr_buf.data;
1381 }
1382
1383 /* push, without hashing */
1384 static Sym *sym_push2(Sym **ps, int v, int t, int c)
1385 {
1386 Sym *s;
1387 s = tcc_malloc(sizeof(Sym));
1388 s->v = v;
1389 s->type.t = t;
1390 s->c = c;
1391 s->next = NULL;
1392 /* add in stack */
1393 s->prev = *ps;
1394 *ps = s;
1395 return s;
1396 }
1397
1398 /* find a symbol and return its associated structure. 's' is the top
1399 of the symbol stack */
1400 static Sym *sym_find2(Sym *s, int v)
1401 {
1402 while (s) {
1403 if (s->v == v)
1404 return s;
1405 s = s->prev;
1406 }
1407 return NULL;
1408 }
1409
1410 /* structure lookup */
1411 static Sym *struct_find(int v)
1412 {
1413 v -= TOK_IDENT;
1414 if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
1415 return NULL;
1416 return table_ident[v]->sym_struct;
1417 }
1418
1419 /* find an identifier */
1420 static inline Sym *sym_find(int v)
1421 {
1422 v -= TOK_IDENT;
1423 if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
1424 return NULL;
1425 return table_ident[v]->sym_identifier;
1426 }
1427
1428 /* push a given symbol on the symbol stack */
1429 static Sym *sym_push(int v, CType *type, int r, int c)
1430 {
1431 Sym *s, **ps;
1432 TokenSym *ts;
1433
1434 if (local_stack)
1435 ps = &local_stack;
1436 else
1437 ps = &global_stack;
1438 s = sym_push2(ps, v, type->t, c);
1439 s->type.ref = type->ref;
1440 s->r = r;
1441 /* don't record fields or anonymous symbols */
1442 /* XXX: simplify */
1443 if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
1444 /* record symbol in token array */
1445 ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT];
1446 if (v & SYM_STRUCT)
1447 ps = &ts->sym_struct;
1448 else
1449 ps = &ts->sym_identifier;
1450 s->prev_tok = *ps;
1451 *ps = s;
1452 }
1453 return s;
1454 }
1455
1456 /* push a global identifier */
1457 static Sym *global_identifier_push(int v, int t, int c)
1458 {
1459 Sym *s, **ps;
1460 s = sym_push2(&global_stack, v, t, c);
1461 /* don't record anonymous symbol */
1462 if (v < SYM_FIRST_ANOM) {
1463 ps = &table_ident[v - TOK_IDENT]->sym_identifier;
1464 /* modify the top most local identifier, so that
1465 sym_identifier will point to 's' when popped */
1466 while (*ps != NULL)
1467 ps = &(*ps)->prev_tok;
1468 s->prev_tok = NULL;
1469 *ps = s;
1470 }
1471 return s;
1472 }
1473
1474 /* pop symbols until top reaches 'b' */
1475 static void sym_pop(Sym **ptop, Sym *b)
1476 {
1477 Sym *s, *ss, **ps;
1478 TokenSym *ts;
1479 int v;
1480
1481 s = *ptop;
1482 while(s != b) {
1483 ss = s->prev;
1484 v = s->v;
1485 /* remove symbol in token array */
1486 /* XXX: simplify */
1487 if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
1488 ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT];
1489 if (v & SYM_STRUCT)
1490 ps = &ts->sym_struct;
1491 else
1492 ps = &ts->sym_identifier;
1493 *ps = s->prev_tok;
1494 }
1495 tcc_free(s);
1496 s = ss;
1497 }
1498 *ptop = b;
1499 }
1500
1501 /* I/O layer */
1502
1503 BufferedFile *tcc_open(TCCState *s1, const char *filename)
1504 {
1505 int fd;
1506 BufferedFile *bf;
1507
1508 fd = open(filename, O_RDONLY);
1509 if (fd < 0)
1510 return NULL;
1511 bf = tcc_malloc(sizeof(BufferedFile));
1512 if (!bf) {
1513 close(fd);
1514 return NULL;
1515 }
1516 bf->fd = fd;
1517 bf->buf_ptr = bf->buffer;
1518 bf->buf_end = bf->buffer;
1519 bf->buffer[0] = CH_EOB; /* put eob symbol */
1520 pstrcpy(bf->filename, sizeof(bf->filename), filename);
1521 bf->line_num = 1;
1522 bf->ifndef_macro = 0;
1523 bf->ifdef_stack_ptr = s1->ifdef_stack_ptr;
1524 // printf("opening '%s'\n", filename);
1525 return bf;
1526 }
1527
1528 void tcc_close(BufferedFile *bf)
1529 {
1530 total_lines += bf->line_num;
1531 close(bf->fd);
1532 tcc_free(bf);
1533 }
1534
1535 /* fill input buffer and peek next char */
1536 static int tcc_peekc_slow(BufferedFile *bf)
1537 {
1538 int len;
1539 /* only tries to read if really end of buffer */
1540 if (bf->buf_ptr >= bf->buf_end) {
1541 if (bf->fd != -1) {
1542 #if defined(PARSE_DEBUG)
1543 len = 8;
1544 #else
1545 len = IO_BUF_SIZE;
1546 #endif
1547 len = read(bf->fd, bf->buffer, len);
1548 if (len < 0)
1549 len = 0;
1550 } else {
1551 len = 0;
1552 }
1553 total_bytes += len;
1554 bf->buf_ptr = bf->buffer;
1555 bf->buf_end = bf->buffer + len;
1556 *bf->buf_end = CH_EOB;
1557 }
1558 if (bf->buf_ptr < bf->buf_end) {
1559 return bf->buf_ptr[0];
1560 } else {
1561 bf->buf_ptr = bf->buf_end;
1562 return CH_EOF;
1563 }
1564 }
1565
1566 /* return the current character, handling end of block if necessary
1567 (but not stray) */
1568 static int handle_eob(void)
1569 {
1570 return tcc_peekc_slow(file);
1571 }
1572
1573 /* read next char from current input file and handle end of input buffer */
1574 static inline void inp(void)
1575 {
1576 ch = *(++(file->buf_ptr));
1577 /* end of buffer/file handling */
1578 if (ch == CH_EOB)
1579 ch = handle_eob();
1580 }
1581
1582 /* handle '\[\r]\n' */
1583 static void handle_stray(void)
1584 {
1585 while (ch == '\\') {
1586 inp();
1587 if (ch == '\n') {
1588 file->line_num++;
1589 inp();
1590 } else if (ch == '\r') {
1591 inp();
1592 if (ch != '\n')
1593 goto fail;
1594 file->line_num++;
1595 inp();
1596 } else {
1597 fail:
1598 error("stray '\\' in program");
1599 }
1600 }
1601 }
1602
1603 /* skip the stray and handle the \\n case. Output an error if
1604 incorrect char after the stray */
1605 static int handle_stray1(uint8_t *p)
1606 {
1607 int c;
1608
1609 if (p >= file->buf_end) {
1610 file->buf_ptr = p;
1611 c = handle_eob();
1612 p = file->buf_ptr;
1613 if (c == '\\')
1614 goto parse_stray;
1615 } else {
1616 parse_stray:
1617 file->buf_ptr = p;
1618 ch = *p;
1619 handle_stray();
1620 p = file->buf_ptr;
1621 c = *p;
1622 }
1623 return c;
1624 }
1625
1626 /* handle the complicated stray case */
1627 #define PEEKC(c, p)\
1628 {\
1629 p++;\
1630 c = *p;\
1631 if (c == '\\') {\
1632 c = handle_stray1(p);\
1633 p = file->buf_ptr;\
1634 }\
1635 }
1636
1637 /* input with '\[\r]\n' handling. Note that this function cannot
1638 handle other characters after '\', so you cannot call it inside
1639 strings or comments */
1640 static void minp(void)
1641 {
1642 inp();
1643 if (ch == '\\')
1644 handle_stray();
1645 }
1646
1647
1648 static void parse_line_comment(void)
1649 {
1650 /* single line C++ comments */
1651 /* XXX: accept '\\\n' ? */
1652 inp();
1653 while (ch != '\n' && ch != CH_EOF)
1654 inp();
1655 }
1656
1657 static void parse_comment(void)
1658 {
1659 uint8_t *p;
1660 int c;
1661
1662 /* C comments */
1663 p = file->buf_ptr;
1664 p++;
1665 for(;;) {
1666 /* fast skip loop */
1667 for(;;) {
1668 c = *p;
1669 if (c == '\n' || c == '*' || c == '\\')
1670 break;
1671 p++;
1672 c = *p;
1673 if (c == '\n' || c == '*' || c == '\\')
1674 break;
1675 p++;
1676 }
1677 /* now we can handle all the cases */
1678 if (c == '\n') {
1679 file->line_num++;
1680 p++;
1681 } else if (c == '*') {
1682 p++;
1683 for(;;) {
1684 c = *p;
1685 if (c == '*') {
1686 p++;
1687 } else if (c == '/') {
1688 goto end_of_comment;
1689 } else if (c == '\\') {
1690 file->buf_ptr = p;
1691 c = handle_eob();
1692 if (c == '\\') {
1693 /* skip '\\n', but if '\' followed but another
1694 char, behave asif a stray was parsed */
1695 ch = file->buf_ptr[0];
1696 while (ch == '\\') {
1697 inp();
1698 if (ch == '\n') {
1699 file->line_num++;
1700 inp();
1701 } else if (ch == '\r') {
1702 inp();
1703 if (ch == '\n') {
1704 file->line_num++;
1705 inp();
1706 }
1707 } else {
1708 p = file->buf_ptr;
1709 break;
1710 }
1711 }
1712 }
1713 p = file->buf_ptr;
1714 } else {
1715 break;
1716 }
1717 }
1718 } else {
1719 /* stray, eob or eof */
1720 file->buf_ptr = p;
1721 c = handle_eob();
1722 p = file->buf_ptr;
1723 if (c == CH_EOF) {
1724 error("unexpected end of file in comment");
1725 } else if (c == '\\') {
1726 p++;
1727 }
1728 }
1729 }
1730 end_of_comment:
1731 p++;
1732 file->buf_ptr = p;
1733 ch = *p;
1734 }
1735
1736 #define cinp minp
1737
1738 /* space exlcuding newline */
1739 static inline int is_space(int ch)
1740 {
1741 return ch == ' ' || ch == '\t' || ch == '\v' || ch == '\f' || ch == '\r';
1742 }
1743
1744 static inline void skip_spaces(void)
1745 {
1746 while (is_space(ch))
1747 cinp();
1748 }
1749
1750 /* skip block of text until #else, #elif or #endif. skip also pairs of
1751 #if/#endif */
1752 void preprocess_skip(void)
1753 {
1754 int a, start_of_line, sep, c;
1755 uint8_t *p;
1756
1757 p = file->buf_ptr;
1758 start_of_line = 1;
1759 a = 0;
1760 for(;;) {
1761 redo_no_start:
1762 c = *p;
1763 switch(c) {
1764 case ' ':
1765 case '\t':
1766 case '\f':
1767 case '\v':
1768 case '\r':
1769 p++;
1770 goto redo_no_start;
1771 case '\n':
1772 start_of_line = 1;
1773 file->line_num++;
1774 p++;
1775 goto redo_no_start;
1776 case '\\':
1777 file->buf_ptr = p;
1778 c = handle_eob();
1779 if (c == CH_EOF) {
1780 expect("#endif");
1781 } else if (c == '\\') {
1782 /* XXX: incorrect: should not give an error */
1783 ch = file->buf_ptr[0];
1784 handle_stray();
1785 }
1786 p = file->buf_ptr;
1787 goto redo_no_start;
1788 /* skip strings */
1789 case '\"':
1790 case '\'':
1791 sep = c;
1792 p++;
1793 for(;;) {
1794 c = *p;
1795 if (c == sep) {
1796 break;
1797 } else if (c == '\\') {
1798 file->buf_ptr = p;
1799 c = handle_eob();
1800 p = file->buf_ptr;
1801 if (c == CH_EOF) {
1802 /* XXX: better error message */
1803 error("unterminated string");
1804 } else if (c == '\\') {
1805 /* ignore next char */
1806 p++;
1807 c = *p;
1808 if (c == '\\') {
1809 file->buf_ptr = p;
1810 c = handle_eob();
1811 p = file->buf_ptr;
1812 }
1813 if (c == '\n')
1814 file->line_num++;
1815 else if (c != CH_EOF)
1816 p++;
1817 }
1818 } else if (c == '\n') {
1819 file->line_num++;
1820 p++;
1821 } else {
1822 p++;
1823 }
1824 }
1825 p++;
1826 break;
1827 /* skip comments */
1828 case '/':
1829 file->buf_ptr = p;
1830 ch = *p;
1831 minp();
1832 if (ch == '*') {
1833 parse_comment();
1834 } else if (ch == '/') {
1835 parse_line_comment();
1836 }
1837 p = file->buf_ptr;
1838 break;
1839
1840 case '#':
1841 p++;
1842 if (start_of_line) {
1843 file->buf_ptr = p;
1844 next_nomacro();
1845 p = file->buf_ptr;
1846 if (a == 0 &&
1847 (tok == TOK_ELSE || tok == TOK_ELIF || tok == TOK_ENDIF))
1848 goto the_end;
1849 if (tok == TOK_IF || tok == TOK_IFDEF || tok == TOK_IFNDEF)
1850 a++;
1851 else if (tok == TOK_ENDIF)
1852 a--;
1853 }
1854 break;
1855 default:
1856 p++;
1857 break;
1858 }
1859 start_of_line = 0;
1860 }
1861 the_end: ;
1862 file->buf_ptr = p;
1863 }
1864
1865 /* ParseState handling */
1866
1867 /* XXX: currently, no include file info is stored. Thus, we cannot display
1868 accurate messages if the function or data definition spans multiple
1869 files */
1870
1871 /* save current parse state in 's' */
1872 void save_parse_state(ParseState *s)
1873 {
1874 s->line_num = file->line_num;
1875 s->macro_ptr = macro_ptr;
1876 s->tok = tok;
1877 s->tokc = tokc;
1878 }
1879
1880 /* restore parse state from 's' */
1881 void restore_parse_state(ParseState *s)
1882 {
1883 file->line_num = s->line_num;
1884 macro_ptr = s->macro_ptr;
1885 tok = s->tok;
1886 tokc = s->tokc;
1887 }
1888
1889 /* return the number of additionnal 'ints' necessary to store the
1890 token */
1891 static inline int tok_ext_size(int t)
1892 {
1893 switch(t) {
1894 /* 4 bytes */
1895 case TOK_CINT:
1896 case TOK_CUINT:
1897 case TOK_CCHAR:
1898 case TOK_LCHAR:
1899 case TOK_STR:
1900 case TOK_LSTR:
1901 case TOK_CFLOAT:
1902 case TOK_LINENUM:
1903 case TOK_PPNUM:
1904 return 1;
1905 case TOK_CDOUBLE:
1906 case TOK_CLLONG:
1907 case TOK_CULLONG:
1908 return 2;
1909 case TOK_CLDOUBLE:
1910 return LDOUBLE_SIZE / 4;
1911 default:
1912 return 0;
1913 }
1914 }
1915
1916 /* token string handling */
1917
1918 static inline void tok_str_new(TokenString *s)
1919 {
1920 s->str = NULL;
1921 s->len = 0;
1922 s->allocated_len = 0;
1923 s->last_line_num = -1;
1924 }
1925
1926 static void tok_str_free(int *str)
1927 {
1928 const int *p;
1929 CString *cstr;
1930 int t;
1931
1932 p = str;
1933 for(;;) {
1934 t = *p;
1935 /* NOTE: we test zero separately so that GCC can generate a
1936 table for the following switch */
1937 if (t == 0)
1938 break;
1939 switch(t) {
1940 case TOK_CINT:
1941 case TOK_CUINT:
1942 case TOK_CCHAR:
1943 case TOK_LCHAR:
1944 case TOK_CFLOAT:
1945 case TOK_LINENUM:
1946 p += 2;
1947 break;
1948 case TOK_PPNUM:
1949 case TOK_STR:
1950 case TOK_LSTR:
1951 /* XXX: use a macro to be portable on 64 bit ? */
1952 cstr = (CString *)p[1];
1953 cstr_free(cstr);
1954 tcc_free(cstr);
1955 p += 2;
1956 break;
1957 case TOK_CDOUBLE:
1958 case TOK_CLLONG:
1959 case TOK_CULLONG:
1960 p += 3;
1961 break;
1962 case TOK_CLDOUBLE:
1963 p += 1 + (LDOUBLE_SIZE / 4);
1964 break;
1965 default:
1966 p++;
1967 break;
1968 }
1969 }
1970 tcc_free(str);
1971 }
1972
1973 static int *tok_str_realloc(TokenString *s)
1974 {
1975 int *str, len;
1976
1977 len = s->allocated_len + TOK_STR_ALLOC_INCR;
1978 str = tcc_realloc(s->str, len * sizeof(int));
1979 if (!str)
1980 error("memory full");
1981 s->allocated_len = len;
1982 s->str = str;
1983 return str;
1984 }
1985
1986 static void tok_str_add(TokenString *s, int t)
1987 {
1988 int len, *str;
1989
1990 len = s->len;
1991 str = s->str;
1992 if (len >= s->allocated_len)
1993 str = tok_str_realloc(s);
1994 str[len++] = t;
1995 s->len = len;
1996 }
1997
1998 static void tok_str_add2(TokenString *s, int t, CValue *cv)
1999 {
2000 int len, *str;
2001
2002 len = s->len;
2003 str = s->str;
2004
2005 /* allocate space for worst case */
2006 if (len + TOK_MAX_SIZE > s->allocated_len)
2007 str = tok_str_realloc(s);
2008 str[len++] = t;
2009 switch(t) {
2010 case TOK_CINT:
2011 case TOK_CUINT:
2012 case TOK_CCHAR:
2013 case TOK_LCHAR:
2014 case TOK_CFLOAT:
2015 case TOK_LINENUM:
2016 str[len++] = cv->tab[0];
2017 break;
2018 case TOK_PPNUM:
2019 case TOK_STR:
2020 case TOK_LSTR:
2021 str[len++] = (int)cstr_dup(cv->cstr);
2022 break;
2023 case TOK_CDOUBLE:
2024 case TOK_CLLONG:
2025 case TOK_CULLONG:
2026 str[len++] = cv->tab[0];
2027 str[len++] = cv->tab[1];
2028 break;
2029 case TOK_CLDOUBLE:
2030 #if LDOUBLE_SIZE == 12
2031 str[len++] = cv->tab[0];
2032 str[len++] = cv->tab[1];
2033 str[len++] = cv->tab[2];
2034 #else
2035 #error add long double size support
2036 #endif
2037 break;
2038 default:
2039 break;
2040 }
2041 s->len = len;
2042 }
2043
2044 /* add the current parse token in token string 's' */
2045 static void tok_str_add_tok(TokenString *s)
2046 {
2047 CValue cval;
2048
2049 /* save line number info */
2050 if (file->line_num != s->last_line_num) {
2051 s->last_line_num = file->line_num;
2052 cval.i = s->last_line_num;
2053 tok_str_add2(s, TOK_LINENUM, &cval);
2054 }
2055 tok_str_add2(s, tok, &tokc);
2056 }
2057
2058 #if LDOUBLE_SIZE == 12
2059 #define LDOUBLE_GET(p, cv) \
2060 cv.tab[0] = p[0]; \
2061 cv.tab[1] = p[1]; \
2062 cv.tab[2] = p[2];
2063 #else
2064 #error add long double size support
2065 #endif
2066
2067
2068 /* get a token from an integer array and increment pointer
2069 accordingly. we code it as a macro to avoid pointer aliasing. */
2070 #define TOK_GET(t, p, cv) \
2071 { \
2072 t = *p++; \
2073 switch(t) { \
2074 case TOK_CINT: \
2075 case TOK_CUINT: \
2076 case TOK_CCHAR: \
2077 case TOK_LCHAR: \
2078 case TOK_CFLOAT: \
2079 case TOK_LINENUM: \
2080 case TOK_STR: \
2081 case TOK_LSTR: \
2082 case TOK_PPNUM: \
2083 cv.tab[0] = *p++; \
2084 break; \
2085 case TOK_CDOUBLE: \
2086 case TOK_CLLONG: \
2087 case TOK_CULLONG: \
2088 cv.tab[0] = p[0]; \
2089 cv.tab[1] = p[1]; \
2090 p += 2; \
2091 break; \
2092 case TOK_CLDOUBLE: \
2093 LDOUBLE_GET(p, cv); \
2094 p += LDOUBLE_SIZE / 4; \
2095 break; \
2096 default: \
2097 break; \
2098 } \
2099 }
2100
2101 /* defines handling */
2102 static inline void define_push(int v, int macro_type, int *str, Sym *first_arg)
2103 {
2104 Sym *s;
2105
2106 s = sym_push2(&define_stack, v, macro_type, (int)str);
2107 s->next = first_arg;
2108 table_ident[v - TOK_IDENT]->sym_define = s;
2109 }
2110
2111 /* undefined a define symbol. Its name is just set to zero */
2112 static void define_undef(Sym *s)
2113 {
2114 int v;
2115 v = s->v;
2116 if (v >= TOK_IDENT && v < tok_ident)
2117 table_ident[v - TOK_IDENT]->sym_define = NULL;
2118 s->v = 0;
2119 }
2120
2121 static inline Sym *define_find(int v)
2122 {
2123 v -= TOK_IDENT;
2124 if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
2125 return NULL;
2126 return table_ident[v]->sym_define;
2127 }
2128
2129 /* free define stack until top reaches 'b' */
2130 static void free_defines(Sym *b)
2131 {
2132 Sym *top, *top1;
2133 int v;
2134
2135 top = define_stack;
2136 while (top != b) {
2137 top1 = top->prev;
2138 /* do not free args or predefined defines */
2139 if (top->c)
2140 tok_str_free((int *)top->c);
2141 v = top->v;
2142 if (v >= TOK_IDENT && v < tok_ident)
2143 table_ident[v - TOK_IDENT]->sym_define = NULL;
2144 tcc_free(top);
2145 top = top1;
2146 }
2147 define_stack = b;
2148 }
2149
2150 /* label lookup */
2151 static Sym *label_find(int v)
2152 {
2153 v -= TOK_IDENT;
2154 if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
2155 return NULL;
2156 return table_ident[v]->sym_label;
2157 }
2158
2159 static Sym *label_push(int v, int flags)
2160 {
2161 Sym *s;
2162 s = sym_push2(&label_stack, v, 0, 0);
2163 s->r = flags;
2164 table_ident[v - TOK_IDENT]->sym_label = s;
2165 return s;
2166 }
2167
2168 /* eval an expression for #if/#elif */
2169 static int expr_preprocess(void)
2170 {
2171 int c, t;
2172 TokenString str;
2173
2174 tok_str_new(&str);
2175 while (tok != TOK_LINEFEED && tok != TOK_EOF) {
2176 next(); /* do macro subst */
2177 if (tok == TOK_DEFINED) {
2178 next_nomacro();
2179 t = tok;
2180 if (t == '(')
2181 next_nomacro();
2182 c = define_find(tok) != 0;
2183 if (t == '(')
2184 next_nomacro();
2185 tok = TOK_CINT;
2186 tokc.i = c;
2187 } else if (tok >= TOK_IDENT) {
2188 /* if undefined macro */
2189 tok = TOK_CINT;
2190 tokc.i = 0;
2191 }
2192 tok_str_add_tok(&str);
2193 }
2194 tok_str_add(&str, -1); /* simulate end of file */
2195 tok_str_add(&str, 0);
2196 /* now evaluate C constant expression */
2197 macro_ptr = str.str;
2198 next();
2199 c = expr_const();
2200 macro_ptr = NULL;
2201 tok_str_free(str.str);
2202 return c != 0;
2203 }
2204
2205 #if defined(PARSE_DEBUG) || defined(PP_DEBUG)
2206 static void tok_print(int *str)
2207 {
2208 int t;
2209 CValue cval;
2210
2211 while (1) {
2212 TOK_GET(t, str, cval);
2213 if (!t)
2214 break;
2215 printf(" %s", get_tok_str(t, &cval));
2216 }
2217 printf("\n");
2218 }
2219 #endif
2220
2221 /* parse after #define */
2222 static void parse_define(void)
2223 {
2224 Sym *s, *first, **ps;
2225 int v, t, varg, is_vaargs, c;
2226 TokenString str;
2227
2228 v = tok;
2229 if (v < TOK_IDENT)
2230 error("invalid macro name '%s'", get_tok_str(tok, &tokc));
2231 /* XXX: should check if same macro (ANSI) */
2232 first = NULL;
2233 t = MACRO_OBJ;
2234 /* '(' must be just after macro definition for MACRO_FUNC */
2235 c = file->buf_ptr[0];
2236 if (c == '\\')
2237 c = handle_stray1(file->buf_ptr);
2238 if (c == '(') {
2239 next_nomacro();
2240 next_nomacro();
2241 ps = &first;
2242 while (tok != ')') {
2243 varg = tok;
2244 next_nomacro();
2245 is_vaargs = 0;
2246 if (varg == TOK_DOTS) {
2247 varg = TOK___VA_ARGS__;
2248 is_vaargs = 1;
2249 } else if (tok == TOK_DOTS && gnu_ext) {
2250 is_vaargs = 1;
2251 next_nomacro();
2252 }
2253 if (varg < TOK_IDENT)
2254 error("badly punctuated parameter list");
2255 s = sym_push2(&define_stack, varg | SYM_FIELD, is_vaargs, 0);
2256 *ps = s;
2257 ps = &s->next;
2258 if (tok != ',')
2259 break;
2260 next_nomacro();
2261 }
2262 t = MACRO_FUNC;
2263 }
2264 tok_str_new(&str);
2265 next_nomacro();
2266 /* EOF testing necessary for '-D' handling */
2267 while (tok != TOK_LINEFEED && tok != TOK_EOF) {
2268 tok_str_add2(&str, tok, &tokc);
2269 next_nomacro();
2270 }
2271 tok_str_add(&str, 0);
2272 #ifdef PP_DEBUG
2273 printf("define %s %d: ", get_tok_str(v, NULL), t);
2274 tok_print(str.str);
2275 #endif
2276 define_push(v, t, str.str, first);
2277 }
2278
2279 /* XXX: use a token or a hash table to accelerate matching ? */
2280 static CachedInclude *search_cached_include(TCCState *s1,
2281 int type, const char *filename)
2282 {
2283 CachedInclude *e;
2284 int i;
2285
2286 for(i = 0;i < s1->nb_cached_includes; i++) {
2287 e = s1->cached_includes[i];
2288 if (e->type == type && !strcmp(e->filename, filename))
2289 return e;
2290 }
2291 return NULL;
2292 }
2293
2294 static inline void add_cached_include(TCCState *s1, int type,
2295 const char *filename, int ifndef_macro)
2296 {
2297 CachedInclude *e;
2298
2299 if (search_cached_include(s1, type, filename))
2300 return;
2301 #ifdef INC_DEBUG
2302 printf("adding cached '%s' %s\n", filename, get_tok_str(ifndef_macro, NULL));
2303 #endif
2304 e = tcc_malloc(sizeof(CachedInclude) + strlen(filename));
2305 if (!e)
2306 return;
2307 e->type = type;
2308 strcpy(e->filename, filename);
2309 e->ifndef_macro = ifndef_macro;
2310 dynarray_add((void ***)&s1->cached_includes, &s1->nb_cached_includes, e);
2311 }
2312
2313 /* is_bof is true if first non space token at beginning of file */
2314 static void preprocess(int is_bof)
2315 {
2316 TCCState *s1 = tcc_state;
2317 int size, i, c, n;
2318 char buf[1024], *q, *p;
2319 char buf1[1024];
2320 BufferedFile *f;
2321 Sym *s;
2322 CachedInclude *e;
2323
2324 return_linefeed = 1; /* linefeed will be returned as a
2325 token. EOF is also returned as line feed */
2326 next_nomacro();
2327 redo:
2328 switch(tok) {
2329 case TOK_DEFINE:
2330 next_nomacro();
2331 parse_define();
2332 break;
2333 case TOK_UNDEF:
2334 next_nomacro();
2335 s = define_find(tok);
2336 /* undefine symbol by putting an invalid name */
2337 if (s)
2338 define_undef(s);
2339 break;
2340 case TOK_INCLUDE:
2341 ch = file->buf_ptr[0];
2342 /* XXX: incorrect if comments : use next_nomacro with a special mode */
2343 skip_spaces();
2344 if (ch == '<') {
2345 c = '>';
2346 goto read_name;
2347 } else if (ch == '\"') {
2348 c = ch;
2349 read_name:
2350 /* XXX: better stray handling */
2351 minp();
2352 q = buf;
2353 while (ch != c && ch != '\n' && ch != CH_EOF) {
2354 if ((q - buf) < sizeof(buf) - 1)
2355 *q++ = ch;
2356 minp();
2357 }
2358 *q = '\0';
2359 minp();
2360 #if 0
2361 /* eat all spaces and comments after include */
2362 /* XXX: slightly incorrect */
2363 while (ch1 != '\n' && ch1 != CH_EOF)
2364 inp();
2365 #endif
2366 } else {
2367 /* computed #include : either we have only strings or
2368 we have anything enclosed in '<>' */
2369 next();
2370 buf[0] = '\0';
2371 if (tok == TOK_STR) {
2372 while (tok != TOK_LINEFEED) {
2373 if (tok != TOK_STR) {
2374 include_syntax:
2375 error("'#include' expects \"FILENAME\" or <FILENAME>");
2376 }
2377 pstrcat(buf, sizeof(buf), (char *)tokc.cstr->data);
2378 next();
2379 }
2380 c = '\"';
2381 } else {
2382 int len;
2383 while (tok != TOK_LINEFEED) {
2384 pstrcat(buf, sizeof(buf), get_tok_str(tok, &tokc));
2385 next();
2386 }
2387 len = strlen(buf);
2388 /* check syntax and remove '<>' */
2389 if (len < 2 || buf[0] != '<' || buf[len - 1] != '>')
2390 goto include_syntax;
2391 memmove(buf, buf + 1, len - 2);
2392 buf[len - 2] = '\0';
2393 c = '>';
2394 }
2395 }
2396
2397 e = search_cached_include(s1, c, buf);
2398 if (e && define_find(e->ifndef_macro)) {
2399 /* no need to parse the include because the 'ifndef macro'
2400 is defined */
2401 #ifdef INC_DEBUG
2402 printf("%s: skipping %s\n", file->filename, buf);
2403 #endif
2404 } else {
2405 if (c == '\"') {
2406 /* first search in current dir if "header.h" */
2407 size = 0;
2408 p = strrchr(file->filename, '/');
2409 if (p)
2410 size = p + 1 - file->filename;
2411 if (size > sizeof(buf1) - 1)
2412 size = sizeof(buf1) - 1;
2413 memcpy(buf1, file->filename, size);
2414 buf1[size] = '\0';
2415 pstrcat(buf1, sizeof(buf1), buf);
2416 f = tcc_open(s1, buf1);
2417 if (f)
2418 goto found;
2419 }
2420 if (s1->include_stack_ptr >= s1->include_stack + INCLUDE_STACK_SIZE)
2421 error("#include recursion too deep");
2422 /* now search in all the include paths */
2423 n = s1->nb_include_paths + s1->nb_sysinclude_paths;
2424 for(i = 0; i < n; i++) {
2425 const char *path;
2426 if (i < s1->nb_include_paths)
2427 path = s1->include_paths[i];
2428 else
2429 path = s1->sysinclude_paths[i - s1->nb_include_paths];
2430 pstrcpy(buf1, sizeof(buf1), path);
2431 pstrcat(buf1, sizeof(buf1), "/");
2432 pstrcat(buf1, sizeof(buf1), buf);
2433 f = tcc_open(s1, buf1);
2434 if (f)
2435 goto found;
2436 }
2437 error("include file '%s' not found", buf);
2438 f = NULL;
2439 found:
2440 #ifdef INC_DEBUG
2441 printf("%s: including %s\n", file->filename, buf1);
2442 #endif
2443 f->inc_type = c;
2444 pstrcpy(f->inc_filename, sizeof(f->inc_filename), buf);
2445 /* push current file in stack */
2446 /* XXX: fix current line init */
2447 *s1->include_stack_ptr++ = file;
2448 file = f;
2449 /* add include file debug info */
2450 if (do_debug) {
2451 put_stabs(file->filename, N_BINCL, 0, 0, 0);
2452 }
2453 tok_flags |= TOK_FLAG_BOF | TOK_FLAG_BOL;
2454 ch = file->buf_ptr[0];
2455 goto the_end;
2456 }
2457 break;
2458 case TOK_IFNDEF:
2459 c = 1;
2460 goto do_ifdef;
2461 case TOK_IF:
2462 c = expr_preprocess();
2463 goto do_if;
2464 case TOK_IFDEF:
2465 c = 0;
2466 do_ifdef:
2467 next_nomacro();
2468 if (tok < TOK_IDENT)
2469 error("invalid argument for '#if%sdef'", c ? "n" : "");
2470 if (is_bof) {
2471 if (c) {
2472 #ifdef INC_DEBUG
2473 printf("#ifndef %s\n", get_tok_str(tok, NULL));
2474 #endif
2475 file->ifndef_macro = tok;
2476 }
2477 }
2478 c = (define_find(tok) != 0) ^ c;
2479 do_if:
2480 if (s1->ifdef_stack_ptr >= s1->ifdef_stack + IFDEF_STACK_SIZE)
2481 error("memory full");
2482 *s1->ifdef_stack_ptr++ = c;
2483 goto test_skip;
2484 case TOK_ELSE:
2485 if (s1->ifdef_stack_ptr == s1->ifdef_stack)
2486 error("#else without matching #if");
2487 if (s1->ifdef_stack_ptr[-1] & 2)
2488 error("#else after #else");
2489 c = (s1->ifdef_stack_ptr[-1] ^= 3);
2490 goto test_skip;
2491 case TOK_ELIF:
2492 if (s1->ifdef_stack_ptr == s1->ifdef_stack)
2493 error("#elif without matching #if");
2494 c = s1->ifdef_stack_ptr[-1];
2495 if (c > 1)
2496 error("#elif after #else");
2497 /* last #if/#elif expression was true: we skip */
2498 if (c == 1)
2499 goto skip;
2500 c = expr_preprocess();
2501 s1->ifdef_stack_ptr[-1] = c;
2502 test_skip:
2503 if (!(c & 1)) {
2504 skip:
2505 preprocess_skip();
2506 is_bof = 0;
2507 goto redo;
2508 }
2509 break;
2510 case TOK_ENDIF:
2511 if (s1->ifdef_stack_ptr <= file->ifdef_stack_ptr)
2512 error("#endif without matching #if");
2513 s1->ifdef_stack_ptr--;
2514 /* '#ifndef macro' was at the start of file. Now we check if
2515 an '#endif' is exactly at the end of file */
2516 if (file->ifndef_macro &&
2517 s1->ifdef_stack_ptr == file->ifdef_stack_ptr) {
2518 file->ifndef_macro_saved = file->ifndef_macro;
2519 /* need to set to zero to avoid false matches if another
2520 #ifndef at middle of file */
2521 file->ifndef_macro = 0;
2522 while (tok != TOK_LINEFEED)
2523 next_nomacro();
2524 tok_flags |= TOK_FLAG_ENDIF;
2525 goto the_end;
2526 }
2527 break;
2528 case TOK_LINE:
2529 next();
2530 if (tok != TOK_CINT)
2531 error("#line");
2532 file->line_num = tokc.i - 1; /* the line number will be incremented after */
2533 next();
2534 if (tok != TOK_LINEFEED) {
2535 if (tok != TOK_STR)
2536 error("#line");
2537 pstrcpy(file->filename, sizeof(file->filename),
2538 (char *)tokc.cstr->data);
2539 }
2540 break;
2541 case TOK_ERROR:
2542 case TOK_WARNING:
2543 c = tok;
2544 skip_spaces();
2545 q = buf;
2546 while (ch != '\n' && ch != CH_EOF) {
2547 if ((q - buf) < sizeof(buf) - 1)
2548 *q++ = ch;
2549 minp();
2550 }
2551 *q = '\0';
2552 if (c == TOK_ERROR)
2553 error("#error %s", buf);
2554 else
2555 warning("#warning %s", buf);
2556 break;
2557 case TOK_PRAGMA:
2558 /* ignored */
2559 break;
2560 default:
2561 if (tok == TOK_LINEFEED || tok == '!' || tok == TOK_CINT) {
2562 /* '!' is ignored to allow C scripts. numbers are ignored
2563 to emulate cpp behaviour */
2564 } else {
2565 error("invalid preprocessing directive #%s", get_tok_str(tok, &tokc));
2566 }
2567 break;
2568 }
2569 /* ignore other preprocess commands or #! for C scripts */
2570 while (tok != TOK_LINEFEED)
2571 next_nomacro();
2572 the_end:
2573 return_linefeed = 0;
2574 }
2575
2576 /* read a number in base b */
2577 static int getn(int b)
2578 {
2579 int n, t;
2580 n = 0;
2581 while (1) {
2582 if (ch >= 'a' && ch <= 'f')
2583 t = ch - 'a' + 10;
2584 else if (ch >= 'A' && ch <= 'F')
2585 t = ch - 'A' + 10;
2586 else if (isnum(ch))
2587 t = ch - '0';
2588 else
2589 break;
2590 if (t < 0 || t >= b)
2591 break;
2592 n = n * b + t;
2593 inp();
2594 }
2595 return n;
2596 }
2597
2598 /* read a character for string or char constant and eval escape codes */
2599 static int getq(void)
2600 {
2601 int c;
2602
2603 redo:
2604 c = ch;
2605 inp();
2606 if (c == '\\') {
2607 switch(ch) {
2608 case '0': case '1': case '2': case '3':
2609 case '4': case '5': case '6': case '7':
2610 /* at most three octal digits */
2611 c = ch - '0';
2612 inp();
2613 if (isoct(ch)) {
2614 c = c * 8 + ch - '0';
2615 inp();
2616 if (isoct(ch)) {
2617 c = c * 8 + ch - '0';
2618 inp();
2619 }
2620 }
2621 return c;
2622 case 'x':
2623 inp();
2624 return getn(16);
2625 case 'a':
2626 c = '\a';
2627 break;
2628 case 'b':
2629 c = '\b';
2630 break;
2631 case 'f':
2632 c = '\f';
2633 break;
2634 case 'n':
2635 c = '\n';
2636 break;
2637 case 'r':
2638 c = '\r';
2639 break;
2640 case 't':
2641 c = '\t';
2642 break;
2643 case 'v':
2644 c = '\v';
2645 break;
2646 case 'e':
2647 if (!gnu_ext)
2648 goto invalid_escape;
2649 c = 27;
2650 break;
2651 case '\'':
2652 case '\"':
2653 case '\\':
2654 case '?':
2655 c = ch;
2656 break;
2657 case '\n':
2658 inp();
2659 goto redo;
2660 case '\r':
2661 inp();
2662 if (ch != '\n')
2663 goto invalid_escape;
2664 inp();
2665 goto redo;
2666 default:
2667 invalid_escape:
2668 error("invalid escaped char");
2669 }
2670 inp();
2671 } else if (c == '\r' && ch == '\n') {
2672 inp();
2673 c = '\n';
2674 }
2675 return c;
2676 }
2677
2678 /* we use 64 bit numbers */
2679 #define BN_SIZE 2
2680
2681 /* bn = (bn << shift) | or_val */
2682 void bn_lshift(unsigned int *bn, int shift, int or_val)
2683 {
2684 int i;
2685 unsigned int v;
2686 for(i=0;i<BN_SIZE;i++) {
2687 v = bn[i];
2688 bn[i] = (v << shift) | or_val;
2689 or_val = v >> (32 - shift);
2690 }
2691 }
2692
2693 void bn_zero(unsigned int *bn)
2694 {
2695 int i;
2696 for(i=0;i<BN_SIZE;i++) {
2697 bn[i] = 0;
2698 }
2699 }
2700
2701 /* parse number in null terminated string 'p' and return it in the
2702 current token */
2703 void parse_number(const char *p)
2704 {
2705 int b, t, shift, frac_bits, s, exp_val, ch;
2706 char *q;
2707 unsigned int bn[BN_SIZE];
2708 double d;
2709
2710 /* number */
2711 q = token_buf;
2712 ch = *p++;
2713 t = ch;
2714 ch = *p++;
2715 *q++ = t;
2716 b = 10;
2717 if (t == '.') {
2718 goto float_frac_parse;
2719 } else if (t == '0') {
2720 if (ch == 'x' || ch == 'X') {
2721 q--;
2722 ch = *p++;
2723 b = 16;
2724 } else if (tcc_ext && (ch == 'b' || ch == 'B')) {
2725 q--;
2726 ch = *p++;
2727 b = 2;
2728 }
2729 }
2730 /* parse all digits. cannot check octal numbers at this stage
2731 because of floating point constants */
2732 while (1) {
2733 if (ch >= 'a' && ch <= 'f')
2734 t = ch - 'a' + 10;
2735 else if (ch >= 'A' && ch <= 'F')
2736 t = ch - 'A' + 10;
2737 else if (isnum(ch))
2738 t = ch - '0';
2739 else
2740 break;
2741 if (t >= b)
2742 break;
2743 if (q >= token_buf + STRING_MAX_SIZE) {
2744 num_too_long:
2745 error("number too long");
2746 }
2747 *q++ = ch;
2748 ch = *p++;
2749 }
2750 if (ch == '.' ||
2751 ((ch == 'e' || ch == 'E') && b == 10) ||
2752 ((ch == 'p' || ch == 'P') && (b == 16 || b == 2))) {
2753 if (b != 10) {
2754 /* NOTE: strtox should support that for hexa numbers, but
2755 non ISOC99 libcs do not support it, so we prefer to do
2756 it by hand */
2757 /* hexadecimal or binary floats */
2758 /* XXX: handle overflows */
2759 *q = '\0';
2760 if (b == 16)
2761 shift = 4;
2762 else
2763 shift = 2;
2764 bn_zero(bn);
2765 q = token_buf;
2766 while (1) {
2767 t = *q++;
2768 if (t == '\0') {
2769 break;
2770 } else if (t >= 'a') {
2771 t = t - 'a' + 10;
2772 } else if (t >= 'A') {
2773 t = t - 'A' + 10;
2774 } else {
2775 t = t - '0';
2776 }
2777 bn_lshift(bn, shift, t);
2778 }
2779 frac_bits = 0;
2780 if (ch == '.') {
2781 ch = *p++;
2782 while (1) {
2783 t = ch;
2784 if (t >= 'a' && t <= 'f') {
2785 t = t - 'a' + 10;
2786 } else if (t >= 'A' && t <= 'F') {
2787 t = t - 'A' + 10;
2788 } else if (t >= '0' && t <= '9') {
2789 t = t - '0';
2790 } else {
2791 break;
2792 }
2793 if (t >= b)
2794 error("invalid digit");
2795 bn_lshift(bn, shift, t);
2796 frac_bits += shift;
2797 ch = *p++;
2798 }
2799 }
2800 if (ch != 'p' && ch != 'P')
2801 expect("exponent");
2802 ch = *p++;
2803 s = 1;
2804 exp_val = 0;
2805 if (ch == '+') {
2806 ch = *p++;
2807 } else if (ch == '-') {
2808 s = -1;
2809 ch = *p++;
2810 }
2811 if (ch < '0' || ch > '9')
2812 expect("exponent digits");
2813 while (ch >= '0' && ch <= '9') {
2814 exp_val = exp_val * 10 + ch - '0';
2815 ch = *p++;
2816 }
2817 exp_val = exp_val * s;
2818
2819 /* now we can generate the number */
2820 /* XXX: should patch directly float number */
2821 d = (double)bn[1] * 4294967296.0 + (double)bn[0];
2822 d = ldexp(d, exp_val - frac_bits);
2823 t = toup(ch);
2824 if (t == 'F') {
2825 ch = *p++;
2826 tok = TOK_CFLOAT;
2827 /* float : should handle overflow */
2828 tokc.f = (float)d;
2829 } else if (t == 'L') {
2830 ch = *p++;
2831 tok = TOK_CLDOUBLE;
2832 /* XXX: not large enough */
2833 tokc.ld = (long double)d;
2834 } else {
2835 tok = TOK_CDOUBLE;
2836 tokc.d = d;
2837 }
2838 } else {
2839 /* decimal floats */
2840 if (ch == '.') {
2841 if (q >= token_buf + STRING_MAX_SIZE)
2842 goto num_too_long;
2843 *q++ = ch;
2844 ch = *p++;
2845 float_frac_parse:
2846 while (ch >= '0' && ch <= '9') {
2847 if (q >= token_buf + STRING_MAX_SIZE)
2848 goto num_too_long;
2849 *q++ = ch;
2850 ch = *p++;
2851 }
2852 }
2853 if (ch == 'e' || ch == 'E') {
2854 if (q >= token_buf + STRING_MAX_SIZE)
2855 goto num_too_long;
2856 *q++ = ch;
2857 ch = *p++;
2858 if (ch == '-' || ch == '+') {
2859 if (q >= token_buf + STRING_MAX_SIZE)
2860 goto num_too_long;
2861 *q++ = ch;
2862 ch = *p++;
2863 }
2864 if (ch < '0' || ch > '9')
2865 expect("exponent digits");
2866 while (ch >= '0' && ch <= '9') {
2867 if (q >= token_buf + STRING_MAX_SIZE)
2868 goto num_too_long;
2869 *q++ = ch;
2870 ch = *p++;
2871 }
2872 }
2873 *q = '\0';
2874 t = toup(ch);
2875 errno = 0;
2876 if (t == 'F') {
2877 ch = *p++;
2878 tok = TOK_CFLOAT;
2879 tokc.f = strtof(token_buf, NULL);
2880 } else if (t == 'L') {
2881 ch = *p++;
2882 tok = TOK_CLDOUBLE;
2883 tokc.ld = strtold(token_buf, NULL);
2884 } else {
2885 tok = TOK_CDOUBLE;
2886 tokc.d = strtod(token_buf, NULL);
2887 }
2888 }
2889 } else {
2890 unsigned long long n, n1;
2891 int lcount, ucount;
2892
2893 /* integer number */
2894 *q = '\0';
2895 q = token_buf;
2896 if (b == 10 && *q == '0') {
2897 b = 8;
2898 q++;
2899 }
2900 n = 0;
2901 while(1) {
2902 t = *q++;
2903 /* no need for checks except for base 10 / 8 errors */
2904 if (t == '\0') {
2905 break;
2906 } else if (t >= 'a') {
2907 t = t - 'a' + 10;
2908 } else if (t >= 'A') {
2909 t = t - 'A' + 10;
2910 } else {
2911 t = t - '0';
2912 if (t >= b)
2913 error("invalid digit");
2914 }
2915 n1 = n;
2916 n = n * b + t;
2917 /* detect overflow */
2918 /* XXX: this test is not reliable */
2919 if (n < n1)
2920 error("integer constant overflow");
2921 }
2922
2923 /* XXX: not exactly ANSI compliant */
2924 if ((n & 0xffffffff00000000LL) != 0) {
2925 if ((n >> 63) != 0)
2926 tok = TOK_CULLONG;
2927 else
2928 tok = TOK_CLLONG;
2929 } else if (n > 0x7fffffff) {
2930 tok = TOK_CUINT;
2931 } else {
2932 tok = TOK_CINT;
2933 }
2934 lcount = 0;
2935 ucount = 0;
2936 for(;;) {
2937 t = toup(ch);
2938 if (t == 'L') {
2939 if (lcount >= 2)
2940 error("three 'l's in integer constant");
2941 lcount++;
2942 if (lcount == 2) {
2943 if (tok == TOK_CINT)
2944 tok = TOK_CLLONG;
2945 else if (tok == TOK_CUINT)
2946 tok = TOK_CULLONG;
2947 }
2948 ch = *p++;
2949 } else if (t == 'U') {
2950 if (ucount >= 1)
2951 error("two 'u's in integer constant");
2952 ucount++;
2953 if (tok == TOK_CINT)
2954 tok = TOK_CUINT;
2955 else if (tok == TOK_CLLONG)
2956 tok = TOK_CULLONG;
2957 ch = *p++;
2958 } else {
2959 break;
2960 }
2961 }
2962 if (tok == TOK_CINT || tok == TOK_CUINT)
2963 tokc.ui = n;
2964 else
2965 tokc.ull = n;
2966 }
2967 }
2968
2969
2970 #define PARSE2(c1, tok1, c2, tok2) \
2971 case c1: \
2972 PEEKC(c, p); \
2973 if (c == c2) { \
2974 p++; \
2975 tok = tok2; \
2976 } else { \
2977 tok = tok1; \
2978 } \
2979 break;
2980
2981 /* return next token without macro substitution */
2982 static inline void next_nomacro1(void)
2983 {
2984 int b, t, c;
2985 TokenSym *ts;
2986 uint8_t *p, *p1;
2987 unsigned int h;
2988
2989 p = file->buf_ptr;
2990 redo_no_start:
2991 c = *p;
2992 switch(c) {
2993 case ' ':
2994 case '\t':
2995 case '\f':
2996 case '\v':
2997 case '\r':
2998 p++;
2999 goto redo_no_start;
3000
3001 case '\\':
3002 /* first look if it is in fact an end of buffer */
3003 if (p >= file->buf_end) {
3004 file->buf_ptr = p;
3005 handle_eob();
3006 p = file->buf_ptr;
3007 if (p >= file->buf_end)
3008 goto parse_eof;
3009 else
3010 goto redo_no_start;
3011 } else {
3012 file->buf_ptr = p;
3013 ch = *p;
3014 handle_stray();
3015 p = file->buf_ptr;
3016 goto redo_no_start;
3017 }
3018 parse_eof:
3019 {
3020 TCCState *s1 = tcc_state;
3021
3022 if (return_linefeed) {
3023 tok = TOK_LINEFEED;
3024 } else if (s1->include_stack_ptr == s1->include_stack) {
3025 /* no include left : end of file */
3026 tok = TOK_EOF;
3027 } else {
3028 /* pop include file */
3029
3030 /* test if previous '#endif' was after a #ifdef at
3031 start of file */
3032 if (tok_flags & TOK_FLAG_ENDIF) {
3033 #ifdef INC_DEBUG
3034 printf("#endif %s\n", get_tok_str(file->ifndef_macro_saved, NULL));
3035 #endif
3036 add_cached_include(s1, file->inc_type, file->inc_filename,
3037 file->ifndef_macro_saved);
3038 }
3039
3040 /* add end of include file debug info */
3041 if (do_debug) {
3042 put_stabd(N_EINCL, 0, 0);
3043 }
3044 /* pop include stack */
3045 tcc_close(file);
3046 s1->include_stack_ptr--;
3047 file = *s1->include_stack_ptr;
3048 p = file->buf_ptr;
3049 goto redo_no_start;
3050 }
3051 }
3052 break;
3053
3054 case '\n':
3055 if (return_linefeed) {
3056 tok = TOK_LINEFEED;
3057 } else {
3058 file->line_num++;
3059 tok_flags |= TOK_FLAG_BOL;
3060 p++;
3061 goto redo_no_start;
3062 }
3063 break;
3064
3065 case '#':
3066 /* XXX: simplify */
3067 PEEKC(c, p);
3068 if (tok_flags & TOK_FLAG_BOL) {
3069 file->buf_ptr = p;
3070 preprocess(tok_flags & TOK_FLAG_BOF);
3071 p = file->buf_ptr;
3072 goto redo_no_start;
3073 } else {
3074 if (c == '#') {
3075 p++;
3076 tok = TOK_TWOSHARPS;
3077 } else {
3078 tok = '#';
3079 }
3080 }
3081 break;
3082
3083 case 'a': case 'b': case 'c': case 'd':
3084 case 'e': case 'f': case 'g': case 'h':
3085 case 'i': case 'j': case 'k': case 'l':
3086 case 'm': case 'n': case 'o': case 'p':
3087 case 'q': case 'r': case 's': case 't':
3088 case 'u': case 'v': case 'w': case 'x':
3089 case 'y': case 'z':
3090 case 'A': case 'B': case 'C': case 'D':
3091 case 'E': case 'F': case 'G': case 'H':
3092 case 'I': case 'J': case 'K':
3093 case 'M': case 'N': case 'O': case 'P':
3094 case 'Q': case 'R': case 'S': case 'T':
3095 case 'U': case 'V': case 'W': case 'X':
3096 case 'Y': case 'Z':
3097 case '_':
3098 parse_ident_fast:
3099 p1 = p;
3100 h = TOK_HASH_INIT;
3101 h = TOK_HASH_FUNC(h, c);
3102 p++;
3103 for(;;) {
3104 c = *p;
3105 if (!isid(c) && !isnum(c))
3106 break;
3107 h = TOK_HASH_FUNC(h, c);
3108 p++;
3109 }
3110 if (c != '\\') {
3111 TokenSym **pts;
3112 int len;
3113
3114 /* fast case : no stray found, so we have the full token
3115 and we have already hashed it */
3116 len = p - p1;
3117 h &= (TOK_HASH_SIZE - 1);
3118 pts = &hash_ident[h];
3119 for(;;) {
3120 ts = *pts;
3121 if (!ts)
3122 break;
3123 if (ts->len == len && !memcmp(ts->str, p1, len))
3124 goto token_found;
3125 pts = &(ts->hash_next);
3126 }
3127 ts = tok_alloc_new(pts, p1, len);
3128 token_found: ;
3129 } else {
3130 /* slower case */
3131 cstr_reset(&tokcstr);
3132
3133 while (p1 < p) {
3134 cstr_ccat(&tokcstr, *p1);
3135 p1++;
3136 }
3137 p--;
3138 PEEKC(c, p);
3139 parse_ident_slow:
3140 while (isid(c) || isnum(c)) {
3141 cstr_ccat(&tokcstr, c);
3142 PEEKC(c, p);
3143 }
3144 ts = tok_alloc(tokcstr.data, tokcstr.size);
3145 }
3146 tok = ts->tok;
3147 break;
3148 case 'L':
3149 t = p[1];
3150 if (t != '\\' && t != '\'' && t != '\"') {
3151 /* fast case */
3152 goto parse_ident_fast;
3153 } else {
3154 PEEKC(c, p);
3155 if (c == '\'') {
3156 tok = TOK_LCHAR;
3157 goto char_const;
3158 } else if (c == '\"') {
3159 tok = TOK_LSTR;
3160 goto str_const;
3161 } else {
3162 cstr_reset(&tokcstr);
3163 cstr_ccat(&tokcstr, 'L');
3164 goto parse_ident_slow;
3165 }
3166 }
3167 break;
3168 case '0': case '1': case '2': case '3':
3169 case '4': case '5': case '6': case '7':
3170 case '8': case '9':
3171
3172 cstr_reset(&tokcstr);
3173 /* after the first digit, accept digits, alpha, '.' or sign if
3174 prefixed by 'eEpP' */
3175 parse_num:
3176 for(;;) {
3177 t = c;
3178 cstr_ccat(&tokcstr, c);
3179 PEEKC(c, p);
3180 if (!(isnum(c) || isid(c) || c == '.' ||
3181 ((c == '+' || c == '-') &&
3182 (t == 'e' || t == 'E' || t == 'p' || t == 'P'))))
3183 break;
3184 }
3185 /* We add a trailing '\0' to ease parsing */
3186 cstr_ccat(&tokcstr, '\0');
3187 tokc.cstr = &tokcstr;
3188 tok = TOK_PPNUM;
3189 break;
3190 case '.':
3191 /* special dot handling because it can also start a number */
3192 PEEKC(c, p);
3193 if (isnum(c)) {
3194 cstr_reset(&tokcstr);
3195 cstr_ccat(&tokcstr, '.');
3196 goto parse_num;
3197 } else if (c == '.') {
3198 PEEKC(c, p);
3199 if (c != '.')
3200 expect("'.'");
3201 PEEKC(c, p);
3202 tok = TOK_DOTS;
3203 } else {
3204 tok = '.';
3205 }
3206 break;
3207 case '\'':
3208 tok = TOK_CCHAR;
3209 char_const:
3210 file->buf_ptr = p;
3211 inp();
3212 b = getq();
3213 /* this cast is needed if >= 128 */
3214 if (tok == TOK_CCHAR)
3215 b = (char)b;
3216 tokc.i = b;
3217 if (ch != '\'')
3218 error("unterminated character constant");
3219 p = file->buf_ptr;
3220 p++;
3221 break;
3222 case '\"':
3223 tok = TOK_STR;
3224 str_const:
3225 file->buf_ptr = p;
3226 inp();
3227 cstr_reset(&tokcstr);
3228 while (ch != '\"') {
3229 b = getq();
3230 if (ch == CH_EOF)
3231 error("unterminated string");
3232 if (tok == TOK_STR)
3233 cstr_ccat(&tokcstr, b);
3234 else
3235 cstr_wccat(&tokcstr, b);
3236 }
3237 if (tok == TOK_STR)
3238 cstr_ccat(&tokcstr, '\0');
3239 else
3240 cstr_wccat(&tokcstr, '\0');
3241 tokc.cstr = &tokcstr;
3242 p = file->buf_ptr;
3243 p++;
3244 break;
3245
3246 case '<':
3247 PEEKC(c, p);
3248 if (c == '=') {
3249 p++;
3250 tok = TOK_LE;
3251 } else if (c == '<') {
3252 PEEKC(c, p);
3253 if (c == '=') {
3254 p++;
3255 tok = TOK_A_SHL;
3256 } else {
3257 tok = TOK_SHL;
3258 }
3259 } else {
3260 tok = TOK_LT;
3261 }
3262 break;
3263
3264 case '>':
3265 PEEKC(c, p);
3266 if (c == '=') {
3267 p++;
3268 tok = TOK_GE;
3269 } else if (c == '>') {
3270 PEEKC(c, p);
3271 if (c == '=') {
3272 p++;
3273 tok = TOK_A_SAR;
3274 } else {
3275 tok = TOK_SAR;
3276 }
3277 } else {
3278 tok = TOK_GT;
3279 }
3280 break;
3281
3282 case '&':
3283 PEEKC(c, p);
3284 if (c == '&') {
3285 p++;
3286 tok = TOK_LAND;
3287 } else if (c == '=') {
3288 p++;
3289 tok = TOK_A_AND;
3290 } else {
3291 tok = '&';
3292 }
3293 break;
3294
3295 case '|':
3296 PEEKC(c, p);
3297 if (c == '|') {
3298 p++;
3299 tok = TOK_LOR;
3300 } else if (c == '=') {
3301 p++;
3302 tok = TOK_A_OR;
3303 } else {
3304 tok = '|';
3305 }
3306 break;
3307
3308 case '+':
3309 PEEKC(c, p);
3310 if (c == '+') {
3311 p++;
3312 tok = TOK_INC;
3313 } else if (c == '=') {
3314 p++;
3315 tok = TOK_A_ADD;
3316 } else {
3317 tok = '+';
3318 }
3319 break;
3320
3321 case '-':
3322 PEEKC(c, p);
3323 if (c == '-') {
3324 p++;
3325 tok = TOK_DEC;
3326 } else if (c == '=') {
3327 p++;
3328 tok = TOK_A_SUB;
3329 } else if (c == '>') {
3330 p++;
3331 tok = TOK_ARROW;
3332 } else {
3333 tok = '-';
3334 }
3335 break;
3336
3337 PARSE2('!', '!', '=', TOK_NE)
3338 PARSE2('=', '=', '=', TOK_EQ)
3339 PARSE2('*', '*', '=', TOK_A_MUL)
3340 PARSE2('%', '%', '=', TOK_A_MOD)
3341 PARSE2('^', '^', '=', TOK_A_XOR)
3342
3343 /* comments or operator */
3344 case '/':
3345 PEEKC(c, p);
3346 if (c == '*') {
3347 file->buf_ptr = p;
3348 parse_comment();
3349 p = file->buf_ptr;
3350 goto redo_no_start;
3351 } else if (c == '/') {
3352 file->buf_ptr = p;
3353 parse_line_comment();
3354 p = file->buf_ptr;
3355 goto redo_no_start;
3356 } else if (c == '=') {
3357 p++;
3358 tok = TOK_A_DIV;
3359 } else {
3360 tok = '/';
3361 }
3362 break;
3363
3364 /* simple tokens */
3365 case '(':
3366 case ')':
3367 case '[':
3368 case ']':
3369 case '{':
3370 case '}':
3371 case ',':
3372 case ';':
3373 case ':':
3374 case '?':
3375 case '~':
3376 tok = c;
3377 p++;
3378 break;
3379 default:
3380 error("unrecognized character \\x%02x", c);
3381 break;
3382 }
3383 file->buf_ptr = p;
3384 tok_flags = 0;
3385 #if defined(PARSE_DEBUG)
3386 printf("token = %s\n", get_tok_str(tok, &tokc));
3387 #endif
3388 }
3389
3390 /* return next token without macro substitution. Can read input from
3391 macro_ptr buffer */
3392 static void next_nomacro(void)
3393 {
3394 if (macro_ptr) {
3395 redo:
3396 tok = *macro_ptr;
3397 if (tok) {
3398 TOK_GET(tok, macro_ptr, tokc);
3399 if (tok == TOK_LINENUM) {
3400 file->line_num = tokc.i;
3401 goto redo;
3402 }
3403 }
3404 } else {
3405 next_nomacro1();
3406 }
3407 }
3408
3409 /* substitute args in macro_str and return allocated string */
3410 static int *macro_arg_subst(Sym **nested_list, int *macro_str, Sym *args)
3411 {
3412 int *st, last_tok, t, notfirst;
3413 Sym *s;
3414 CValue cval;
3415 TokenString str;
3416 CString cstr;
3417
3418 tok_str_new(&str);
3419 last_tok = 0;
3420 while(1) {
3421 TOK_GET(t, macro_str, cval);
3422 if (!t)
3423 break;
3424 if (t == '#') {
3425 /* stringize */
3426 TOK_GET(t, macro_str, cval);
3427 if (!t)
3428 break;
3429 s = sym_find2(args, t);
3430 if (s) {
3431 cstr_new(&cstr);
3432 st = (int *)s->c;
3433 notfirst = 0;
3434 while (*st) {
3435 if (notfirst)
3436 cstr_ccat(&cstr, ' ');
3437 TOK_GET(t, st, cval);
3438 cstr_cat(&cstr, get_tok_str(t, &cval));
3439 notfirst = 1;
3440 }
3441 cstr_ccat(&cstr, '\0');
3442 #ifdef PP_DEBUG
3443 printf("stringize: %s\n", (char *)cstr.data);
3444 #endif
3445 /* add string */
3446 cval.cstr = &cstr;
3447 tok_str_add2(&str, TOK_STR, &cval);
3448 cstr_free(&cstr);
3449 } else {
3450 tok_str_add2(&str, t, &cval);
3451 }
3452 } else if (t >= TOK_IDENT) {
3453 s = sym_find2(args, t);
3454 if (s) {
3455 st = (int *)s->c;
3456 /* if '##' is present before or after, no arg substitution */
3457 if (*macro_str == TOK_TWOSHARPS || last_tok == TOK_TWOSHARPS) {
3458 /* special case for var arg macros : ## eats the
3459 ',' if empty VA_ARGS variable. */
3460 /* XXX: test of the ',' is not 100%
3461 reliable. should fix it to avoid security
3462 problems */
3463 if (gnu_ext && s->type.t &&
3464 last_tok == TOK_TWOSHARPS &&
3465 str.len >= 2 && str.str[str.len - 2] == ',') {
3466 if (*st == 0) {
3467 /* suppress ',' '##' */
3468 str.len -= 2;
3469 } else {
3470 /* suppress '##' and add variable */
3471 str.len--;
3472 goto add_var;
3473 }
3474 } else {
3475 int t1;
3476 add_var:
3477 for(;;) {
3478 TOK_GET(t1, st, cval);
3479 if (!t1)
3480 break;
3481 tok_str_add2(&str, t1, &cval);
3482 }
3483 }
3484 } else {
3485 macro_subst(&str, nested_list, st);
3486 }
3487 } else {
3488 tok_str_add(&str, t);
3489 }
3490 } else {
3491 tok_str_add2(&str, t, &cval);
3492 }
3493 last_tok = t;
3494 }
3495 tok_str_add(&str, 0);
3496 return str.str;
3497 }
3498
3499 /* handle the '##' operator */
3500 static int *macro_twosharps(void)
3501 {
3502 TokenSym *ts;
3503 int *macro_ptr1;
3504 int t;
3505 const char *p1, *p2;
3506 CValue cval;
3507 TokenString macro_str1;
3508 CString cstr;
3509
3510 cstr_new(&cstr);
3511 tok_str_new(&macro_str1);
3512 tok = 0;
3513 while (1) {
3514 next_nomacro();
3515 if (tok == 0)
3516 break;
3517 while (*macro_ptr == TOK_TWOSHARPS) {
3518 macro_ptr++;
3519 macro_ptr1 = macro_ptr;
3520 t = *macro_ptr;
3521 if (t) {
3522 TOK_GET(t, macro_ptr, cval);
3523
3524 /* We concatenate the two tokens if we have an
3525 identifier or a preprocessing number */
3526 cstr_reset(&cstr);
3527 p1 = get_tok_str(tok, &tokc);
3528 cstr_cat(&cstr, p1);
3529 p2 = get_tok_str(t, &cval);
3530 cstr_cat(&cstr, p2);
3531 cstr_ccat(&cstr, '\0');
3532
3533 if ((tok >= TOK_IDENT || tok == TOK_PPNUM) &&
3534 (t >= TOK_IDENT || t == TOK_PPNUM)) {
3535 if (tok == TOK_PPNUM) {
3536 /* if number, then create a number token */
3537 /* NOTE: no need to allocate because
3538 tok_str_add2() does it */
3539 tokc.cstr = &cstr;
3540 } else {
3541 /* if identifier, we must do a test to
3542 validate we have a correct identifier */
3543 if (t == TOK_PPNUM) {
3544 const char *p;
3545 int c;
3546
3547 p = p2;
3548 for(;;) {
3549 c = *p;
3550 if (c == '\0')
3551 break;
3552 p++;
3553 if (!isnum(c) && !isid(c))
3554 goto error_pasting;
3555 }
3556 }
3557 ts = tok_alloc(cstr.data, strlen(cstr.data));
3558 tok = ts->tok; /* modify current token */
3559 }
3560 } else {
3561 const char *str = cstr.data;
3562 const unsigned char *q;
3563
3564 /* we look for a valid token */
3565 /* XXX: do more extensive checks */
3566 if (!strcmp(str, ">>=")) {
3567 tok = TOK_A_SAR;
3568 } else if (!strcmp(str, "<<=")) {
3569 tok = TOK_A_SHL;
3570 } else if (strlen(str) == 2) {
3571 /* search in two bytes table */
3572 q = tok_two_chars;
3573 for(;;) {
3574 if (!*q)
3575 goto error_pasting;
3576 if (q[0] == str[0] && q[1] == str[1])
3577 break;
3578 q += 3;
3579 }
3580 tok = q[2];
3581 } else {
3582 error_pasting:
3583 /* NOTE: because get_tok_str use a static buffer,
3584 we must save it */
3585 cstr_reset(&cstr);
3586 p1 = get_tok_str(tok, &tokc);
3587 cstr_cat(&cstr, p1);
3588 cstr_ccat(&cstr, '\0');
3589 p2 = get_tok_str(t, &cval);
3590 warning("pasting \"%s\" and \"%s\" does not give a valid preprocessing token", cstr.data, p2);
3591 /* cannot merge tokens: just add them separately */
3592 tok_str_add2(&macro_str1, tok, &tokc);
3593 /* XXX: free associated memory ? */
3594 tok = t;
3595 tokc = cval;
3596 }
3597 }
3598 }
3599 }
3600 tok_str_add2(&macro_str1, tok, &tokc);
3601 }
3602 cstr_free(&cstr);
3603 tok_str_add(&macro_str1, 0);
3604 return macro_str1.str;
3605 }
3606
3607
3608 /* do macro substitution of current token with macro 's' and add
3609 result to (tok_str,tok_len). 'nested_list' is the list of all
3610 macros we got inside to avoid recursing. Return non zero if no
3611 substitution needs to be done */
3612 static int macro_subst_tok(TokenString *tok_str,
3613 Sym **nested_list, Sym *s)
3614 {
3615 Sym *args, *sa, *sa1;
3616 int mstr_allocated, parlevel, *mstr, t;
3617 TokenString str;
3618 char *cstrval;
3619 CValue cval;
3620 CString cstr;
3621
3622 /* if symbol is a macro, prepare substitution */
3623 /* if nested substitution, do nothing */
3624 if (sym_find2(*nested_list, tok))
3625 return -1;
3626
3627 /* special macros */
3628 if (tok == TOK___LINE__) {
3629 cval.i = file->line_num;
3630 tok_str_add2(tok_str, TOK_CINT, &cval);
3631 } else if (tok == TOK___FILE__) {
3632 cstrval = file->filename;
3633 goto add_cstr;
3634 tok_str_add2(tok_str, TOK_STR, &cval);
3635 } else if (tok == TOK___DATE__) {
3636 cstrval = "Jan 1 2002";
3637 goto add_cstr;
3638 } else if (tok == TOK___TIME__) {
3639 cstrval = "00:00:00";
3640 add_cstr:
3641 cstr_new(&cstr);
3642 cstr_cat(&cstr, cstrval);
3643 cstr_ccat(&cstr, '\0');
3644 cval.cstr = &cstr;
3645 tok_str_add2(tok_str, TOK_STR, &cval);
3646 cstr_free(&cstr);
3647 } else {
3648 mstr = (int *)s->c;
3649 mstr_allocated = 0;
3650 if (s->type.t == MACRO_FUNC) {
3651 /* NOTE: we do not use next_nomacro to avoid eating the
3652 next token. XXX: find better solution */
3653 if (macro_ptr) {
3654 t = *macro_ptr;
3655 } else {
3656 /* XXX: incorrect with comments */
3657 ch = file->buf_ptr[0];
3658 while (is_space(ch) || ch == '\n')
3659 cinp();
3660 t = ch;
3661 }
3662 if (t != '(') /* no macro subst */
3663 return -1;
3664
3665 /* argument macro */
3666 next_nomacro();
3667 next_nomacro();
3668 args = NULL;
3669 sa = s->next;
3670 /* NOTE: empty args are allowed, except if no args */
3671 for(;;) {
3672 /* handle '()' case */
3673 if (!args && tok == ')')
3674 break;
3675 if (!sa)
3676 error("macro '%s' used with too many args",
3677 get_tok_str(s->v, 0));
3678 tok_str_new(&str);
3679 parlevel = 0;
3680 /* NOTE: non zero sa->t indicates VA_ARGS */
3681 while ((parlevel > 0 ||
3682 (tok != ')' &&
3683 (tok != ',' || sa->type.t))) &&
3684 tok != -1) {
3685 if (tok == '(')
3686 parlevel++;
3687 else if (tok == ')')
3688 parlevel--;
3689 tok_str_add2(&str, tok, &tokc);
3690 next_nomacro();
3691 }
3692 tok_str_add(&str, 0);
3693 sym_push2(&args, sa->v & ~SYM_FIELD, sa->type.t, (int)str.str);
3694 sa = sa->next;
3695 if (tok == ')') {
3696 /* special case for gcc var args: add an empty
3697 var arg argument if it is omitted */
3698 if (sa && sa->type.t && gnu_ext)
3699 continue;
3700 else
3701 break;
3702 }
3703 if (tok != ',')
3704 expect(",");
3705 next_nomacro();
3706 }
3707 if (sa) {
3708 error("macro '%s' used with too few args",
3709 get_tok_str(s->v, 0));
3710 }
3711
3712 /* now subst each arg */
3713 mstr = macro_arg_subst(nested_list, mstr, args);
3714 /* free memory */
3715 sa = args;
3716 while (sa) {
3717 sa1 = sa->prev;
3718 tok_str_free((int *)sa->c);
3719 tcc_free(sa);
3720 sa = sa1;
3721 }
3722 mstr_allocated = 1;
3723 }
3724 sym_push2(nested_list, s->v, 0, 0);
3725 macro_subst(tok_str, nested_list, mstr);
3726 /* pop nested defined symbol */
3727 sa1 = *nested_list;
3728 *nested_list = sa1->prev;
3729 tcc_free(sa1);
3730 if (mstr_allocated)
3731 tok_str_free(mstr);
3732 }
3733 return 0;
3734 }
3735
3736 /* do macro substitution of macro_str and add result to
3737 (tok_str,tok_len). 'nested_list' is the list of all macros we got
3738 inside to avoid recursing. */
3739 static void macro_subst(TokenString *tok_str,
3740 Sym **nested_list, int *macro_str)
3741 {
3742 Sym *s;
3743 int *saved_macro_ptr;
3744 int *macro_str1;
3745
3746 saved_macro_ptr = macro_ptr;
3747 macro_ptr = macro_str;
3748 /* first scan for '##' operator handling */
3749 macro_str1 = macro_twosharps();
3750 macro_ptr = macro_str1;
3751
3752 while (1) {
3753 next_nomacro();
3754 if (tok == 0)
3755 break;
3756 s = define_find(tok);
3757 if (s != NULL) {
3758 if (macro_subst_tok(tok_str, nested_list, s) != 0)
3759 goto no_subst;
3760 } else {
3761 no_subst:
3762 tok_str_add2(tok_str, tok, &tokc);
3763 }
3764 }
3765 macro_ptr = saved_macro_ptr;
3766 tok_str_free(macro_str1);
3767 }
3768
3769 /* return next token with macro substitution */
3770 static void next(void)
3771 {
3772 Sym *nested_list, *s;
3773 TokenString str;
3774
3775 /* special 'ungettok' case for label parsing */
3776 if (tok1) {
3777 tok = tok1;
3778 tokc = tok1c;
3779 tok1 = 0;
3780 } else {
3781 redo:
3782 next_nomacro();
3783 if (!macro_ptr) {
3784 /* if not reading from macro substituted string, then try
3785 to substitute macros */
3786 if (tok >= TOK_IDENT) {
3787 s = define_find(tok);
3788 if (s) {
3789 /* we have a macro: we try to substitute */
3790 tok_str_new(&str);
3791 nested_list = NULL;
3792 if (macro_subst_tok(&str, &nested_list, s) == 0) {
3793 /* substitution done, NOTE: maybe empty */
3794 tok_str_add(&str, 0);
3795 macro_ptr = str.str;
3796 macro_ptr_allocated = str.str;
3797 goto redo;
3798 }
3799 }
3800 }
3801 } else {
3802 if (tok == 0) {
3803 /* end of macro string: free it */
3804 tok_str_free(macro_ptr_allocated);
3805 macro_ptr = NULL;
3806 goto redo;
3807 }
3808 }
3809
3810 /* convert preprocessor tokens into C tokens */
3811 if (tok == TOK_PPNUM) {
3812 parse_number((char *)tokc.cstr->data);
3813 }
3814 }
3815 }
3816
3817 void swap(int *p, int *q)
3818 {
3819 int t;
3820 t = *p;
3821 *p = *q;
3822 *q = t;
3823 }
3824
3825 void vsetc(CType *type, int r, CValue *vc)
3826 {
3827 int v;
3828
3829 if (vtop >= vstack + VSTACK_SIZE)
3830 error("memory full");
3831 /* cannot let cpu flags if other instruction are generated. Also
3832 avoid leaving VT_JMP anywhere except on the top of the stack
3833 because it would complicate the code generator. */
3834 if (vtop >= vstack) {
3835 v = vtop->r & VT_VALMASK;
3836 if (v == VT_CMP || (v & ~1) == VT_JMP)
3837 gv(RC_INT);
3838 }
3839 vtop++;
3840 vtop->type = *type;
3841 vtop->r = r;
3842 vtop->r2 = VT_CONST;
3843 vtop->c = *vc;
3844 }
3845
3846 /* push integer constant */
3847 void vpushi(int v)
3848 {
3849 CValue cval;
3850 cval.i = v;
3851 vsetc(&int_type, VT_CONST, &cval);
3852 }
3853
3854 /* Return a static symbol pointing to a section */
3855 static Sym *get_sym_ref(CType *type, Section *sec,
3856 unsigned long offset, unsigned long size)
3857 {
3858 int v;
3859 Sym *sym;
3860
3861 v = anon_sym++;
3862 sym = global_identifier_push(v, type->t | VT_STATIC, 0);
3863 sym->type.ref = type->ref;
3864 sym->r = VT_CONST | VT_SYM;
3865 put_extern_sym(sym, sec, offset, size);
3866 return sym;
3867 }
3868
3869 /* push a reference to a section offset by adding a dummy symbol */
3870 static void vpush_ref(CType *type, Section *sec, unsigned long offset, unsigned long size)
3871 {
3872 CValue cval;
3873
3874 cval.ul = 0;
3875 vsetc(type, VT_CONST | VT_SYM, &cval);
3876 vtop->sym = get_sym_ref(type, sec, offset, size);
3877 }
3878
3879 /* define a new external reference to a symbol 'v' of type 'u' */
3880 static Sym *external_global_sym(int v, CType *type, int r)
3881 {
3882 Sym *s;
3883
3884 s = sym_find(v);
3885 if (!s) {
3886 /* push forward reference */
3887 s = global_identifier_push(v, type->t | VT_EXTERN, 0);
3888 s->type.ref = type->ref;
3889 s->r = r | VT_CONST | VT_SYM;
3890 }
3891 return s;
3892 }
3893
3894 /* define a new external reference to a symbol 'v' of type 'u' */
3895 static Sym *external_sym(int v, CType *type, int r)
3896 {
3897 Sym *s;
3898
3899 s = sym_find(v);
3900 if (!s) {
3901 /* push forward reference */
3902 s = sym_push(v, type, r | VT_CONST | VT_SYM, 0);
3903 s->type.t |= VT_EXTERN;
3904 }
3905 return s;
3906 }
3907
3908 /* push a reference to global symbol v */
3909 static void vpush_global_sym(CType *type, int v)
3910 {
3911 Sym *sym;
3912 CValue cval;
3913
3914 sym = external_global_sym(v, type, 0);
3915 cval.ul = 0;
3916 vsetc(type, VT_CONST | VT_SYM, &cval);
3917 vtop->sym = sym;
3918 }
3919
3920 void vset(CType *type, int r, int v)
3921 {
3922 CValue cval;
3923
3924 cval.i = v;
3925 vsetc(type, r, &cval);
3926 }
3927
3928 void vseti(int r, int v)
3929 {
3930 CType type;
3931 type.t = VT_INT;
3932 vset(&type, r, v);
3933 }
3934
3935 void vswap(void)
3936 {
3937 SValue tmp;
3938
3939 tmp = vtop[0];
3940 vtop[0] = vtop[-1];
3941 vtop[-1] = tmp;
3942 }
3943
3944 void vpushv(SValue *v)
3945 {
3946 if (vtop >= vstack + VSTACK_SIZE)
3947 error("memory full");
3948 vtop++;
3949 *vtop = *v;
3950 }
3951
3952 void vdup(void)
3953 {
3954 vpushv(vtop);
3955 }
3956
3957 /* save r to the memory stack, and mark it as being free */
3958 void save_reg(int r)
3959 {
3960 int l, saved, size, align;
3961 SValue *p, sv;
3962 CType *type;
3963
3964 /* modify all stack values */
3965 saved = 0;
3966 l = 0;
3967 for(p=vstack;p<=vtop;p++) {
3968 if ((p->r & VT_VALMASK) == r ||
3969 (p->r2 & VT_VALMASK) == r) {
3970 /* must save value on stack if not already done */
3971 if (!saved) {
3972 /* NOTE: must reload 'r' because r might be equal to r2 */
3973 r = p->r & VT_VALMASK;
3974 /* store register in the stack */
3975 type = &p->type;
3976 if ((p->r & VT_LVAL) ||
3977 (!is_float(type->t) && (type->t & VT_BTYPE) != VT_LLONG))
3978 type = &int_type;
3979 size = type_size(type, &align);
3980 loc = (loc - size) & -align;
3981 sv.type.t = type->t;
3982 sv.r = VT_LOCAL | VT_LVAL;
3983 sv.c.ul = loc;
3984 store(r, &sv);
3985 #ifdef TCC_TARGET_I386
3986 /* x86 specific: need to pop fp register ST0 if saved */
3987 if (r == REG_ST0) {
3988 o(0xd9dd); /* fstp %st(1) */
3989 }
3990 #endif
3991 /* special long long case */
3992 if ((type->t & VT_BTYPE) == VT_LLONG) {
3993 sv.c.ul += 4;
3994 store(p->r2, &sv);
3995 }
3996 l = loc;
3997 saved = 1;
3998 }
3999 /* mark that stack entry as being saved on the stack */
4000 if (p->r & VT_LVAL) {
4001 /* also suppress the bounded flag because the
4002 relocation address of the function was stored in
4003 p->c.ul */
4004 p->r = (p->r & ~(VT_VALMASK | VT_BOUNDED)) | VT_LLOCAL;
4005 } else {
4006 p->r = lvalue_type(p->type.t) | VT_LOCAL;
4007 }
4008 p->r2 = VT_CONST;
4009 p->c.ul = l;
4010 }
4011 }
4012 }
4013
4014 /* find a free register of class 'rc'. If none, save one register */
4015 int get_reg(int rc)
4016 {
4017 int r;
4018 SValue *p;
4019
4020 /* find a free register */
4021 for(r=0;r<NB_REGS;r++) {
4022 if (reg_classes[r] & rc) {
4023 for(p=vstack;p<=vtop;p++) {
4024 if ((p->r & VT_VALMASK) == r ||
4025 (p->r2 & VT_VALMASK) == r)
4026 goto notfound;
4027 }
4028 return r;
4029 }
4030 notfound: ;
4031 }
4032
4033 /* no register left : free the first one on the stack (VERY
4034 IMPORTANT to start from the bottom to ensure that we don't
4035 spill registers used in gen_opi()) */
4036 for(p=vstack;p<=vtop;p++) {
4037 r = p->r & VT_VALMASK;
4038 if (r < VT_CONST && (reg_classes[r] & rc))
4039 goto save_found;
4040 /* also look at second register (if long long) */
4041 r = p->r2 & VT_VALMASK;
4042 if (r < VT_CONST && (reg_classes[r] & rc)) {
4043 save_found:
4044 save_reg(r);
4045 return r;
4046 }
4047 }
4048 /* Should never comes here */
4049 return -1;
4050 }
4051
4052 /* save registers up to (vtop - n) stack entry */
4053 void save_regs(int n)
4054 {
4055 int r;
4056 SValue *p, *p1;
4057 p1 = vtop - n;
4058 for(p = vstack;p <= p1; p++) {
4059 r = p->r & VT_VALMASK;
4060 if (r < VT_CONST) {
4061 save_reg(r);
4062 }
4063 }
4064 }
4065
4066 /* move register 's' to 'r', and flush previous value of r to memory
4067 if needed */
4068 void move_reg(int r, int s)
4069 {
4070 SValue sv;
4071
4072 if (r != s) {
4073 save_reg(r);
4074 sv.type.t = VT_INT;
4075 sv.r = s;
4076 sv.c.ul = 0;
4077 load(r, &sv);
4078 }
4079 }
4080
4081 /* get address of vtop (vtop MUST BE an lvalue) */
4082 void gaddrof(void)
4083 {
4084 vtop->r &= ~VT_LVAL;
4085 /* tricky: if saved lvalue, then we can go back to lvalue */
4086 if ((vtop->r & VT_VALMASK) == VT_LLOCAL)
4087 vtop->r = (vtop->r & ~(VT_VALMASK | VT_LVAL_TYPE)) | VT_LOCAL | VT_LVAL;
4088 }
4089
4090 #ifdef CONFIG_TCC_BCHECK
4091 /* generate lvalue bound code */
4092 void gbound(void)
4093 {
4094 int lval_type;
4095 CType type1;
4096
4097 vtop->r &= ~VT_MUSTBOUND;
4098 /* if lvalue, then use checking code before dereferencing */
4099 if (vtop->r & VT_LVAL) {
4100 /* if not VT_BOUNDED value, then make one */
4101 if (!(vtop->r & VT_BOUNDED)) {
4102 lval_type = vtop->r & (VT_LVAL_TYPE | VT_LVAL);
4103 /* must save type because we must set it to int to get pointer */
4104 type1 = vtop->type;
4105 vtop->type.t = VT_INT;
4106 gaddrof();
4107 vpushi(0);
4108 gen_bounded_ptr_add();
4109 vtop->r |= lval_type;
4110 vtop->type = type1;
4111 }
4112 /* then check for dereferencing */
4113 gen_bounded_ptr_deref();
4114 }
4115 }
4116 #endif
4117
4118 /* store vtop a register belonging to class 'rc'. lvalues are
4119 converted to values. Cannot be used if cannot be converted to
4120 register value (such as structures). */
4121 int gv(int rc)
4122 {
4123 int r, r2, rc2, bit_pos, bit_size, size, align, i;
4124 unsigned long long ll;
4125
4126 /* NOTE: get_reg can modify vstack[] */
4127 if (vtop->type.t & VT_BITFIELD) {
4128 bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f;
4129 bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
4130 /* remove bit field info to avoid loops */
4131 vtop->type.t &= ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT));
4132 /* generate shifts */
4133 vpushi(32 - (bit_pos + bit_size));
4134 gen_op(TOK_SHL);
4135 vpushi(32 - bit_size);
4136 /* NOTE: transformed to SHR if unsigned */
4137 gen_op(TOK_SAR);
4138 r = gv(rc);
4139 } else {
4140 if (is_float(vtop->type.t) &&
4141 (vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
4142 Sym *sym;
4143 int *ptr;
4144 unsigned long offset;
4145
4146 /* XXX: unify with initializers handling ? */
4147 /* CPUs usually cannot use float constants, so we store them
4148 generically in data segment */
4149 size = type_size(&vtop->type, &align);
4150 offset = (data_section->data_offset + align - 1) & -align;
4151 data_section->data_offset = offset;
4152 /* XXX: not portable yet */
4153 ptr = section_ptr_add(data_section, size);
4154 size = size >> 2;
4155 for(i=0;i<size;i++)
4156 ptr[i] = vtop->c.tab[i];
4157 sym = get_sym_ref(&vtop->type, data_section, offset, size << 2);
4158 vtop->r |= VT_LVAL | VT_SYM;
4159 vtop->sym = sym;
4160 vtop->c.ul = 0;
4161 }
4162 #ifdef CONFIG_TCC_BCHECK
4163 if (vtop->r & VT_MUSTBOUND)
4164 gbound();
4165 #endif
4166
4167 r = vtop->r & VT_VALMASK;
4168 /* need to reload if:
4169 - constant
4170 - lvalue (need to dereference pointer)
4171 - already a register, but not in the right class */
4172 if (r >= VT_CONST ||
4173 (vtop->r & VT_LVAL) ||
4174 !(reg_classes[r] & rc) ||
4175 ((vtop->type.t & VT_BTYPE) == VT_LLONG &&
4176 !(reg_classes[vtop->r2] & rc))) {
4177 r = get_reg(rc);
4178 if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
4179 /* two register type load : expand to two words
4180 temporarily */
4181 if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
4182 /* load constant */
4183 ll = vtop->c.ull;
4184 vtop->c.ui = ll; /* first word */
4185 load(r, vtop);
4186 vtop->r = r; /* save register value */
4187 vpushi(ll >> 32); /* second word */
4188 } else if (r >= VT_CONST ||
4189 (vtop->r & VT_LVAL)) {
4190 /* load from memory */
4191 load(r, vtop);
4192 vdup();
4193 vtop[-1].r = r; /* save register value */
4194 /* increment pointer to get second word */
4195 vtop->type.t = VT_INT;
4196 gaddrof();
4197 vpushi(4);
4198 gen_op('+');
4199 vtop->r |= VT_LVAL;
4200 } else {
4201 /* move registers */
4202 load(r, vtop);
4203 vdup();
4204 vtop[-1].r = r; /* save register value */
4205 vtop->r = vtop[-1].r2;
4206 }
4207 /* allocate second register */
4208 rc2 = RC_INT;
4209 if (rc == RC_IRET)
4210 rc2 = RC_LRET;
4211 r2 = get_reg(rc2);
4212 load(r2, vtop);
4213 vpop();
4214 /* write second register */
4215 vtop->r2 = r2;
4216 } else if ((vtop->r & VT_LVAL) && !is_float(vtop->type.t)) {
4217 int t1, t;
4218 /* lvalue of scalar type : need to use lvalue type
4219 because of possible cast */
4220 t = vtop->type.t;
4221 t1 = t;
4222 /* compute memory access type */
4223 if (vtop->r & VT_LVAL_BYTE)
4224 t = VT_BYTE;
4225 else if (vtop->r & VT_LVAL_SHORT)
4226 t = VT_SHORT;
4227 if (vtop->r & VT_LVAL_UNSIGNED)
4228 t |= VT_UNSIGNED;
4229 vtop->type.t = t;
4230 load(r, vtop);
4231 /* restore wanted type */
4232 vtop->type.t = t1;
4233 } else {
4234 /* one register type load */
4235 load(r, vtop);
4236 }
4237 }
4238 vtop->r = r;
4239 }
4240 return r;
4241 }
4242
4243 /* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
4244 void gv2(int rc1, int rc2)
4245 {
4246 int v;
4247
4248 /* generate more generic register first. But VT_JMP or VT_CMP
4249 values must be generated first in all cases to avoid possible
4250 reload errors */
4251 v = vtop[0].r & VT_VALMASK;
4252 if (v != VT_CMP && (v & ~1) != VT_JMP && rc1 <= rc2) {
4253 vswap();
4254 gv(rc1);
4255 vswap();
4256 gv(rc2);
4257 /* test if reload is needed for first register */
4258 if ((vtop[-1].r & VT_VALMASK) >= VT_CONST) {
4259 vswap();
4260 gv(rc1);
4261 vswap();
4262 }
4263 } else {
4264 gv(rc2);
4265 vswap();
4266 gv(rc1);
4267 vswap();
4268 /* test if reload is needed for first register */
4269 if ((vtop[0].r & VT_VALMASK) >= VT_CONST) {
4270 gv(rc2);
4271 }
4272 }
4273 }
4274
4275 /* expand long long on stack in two int registers */
4276 void lexpand(void)
4277 {
4278 int u;
4279
4280 u = vtop->type.t & VT_UNSIGNED;
4281 gv(RC_INT);
4282 vdup();
4283 vtop[0].r = vtop[-1].r2;
4284 vtop[0].r2 = VT_CONST;
4285 vtop[-1].r2 = VT_CONST;
4286 vtop[0].type.t = VT_INT | u;
4287 vtop[-1].type.t = VT_INT | u;
4288 }
4289
4290 /* build a long long from two ints */
4291 void lbuild(int t)
4292 {
4293 gv2(RC_INT, RC_INT);
4294 vtop[-1].r2 = vtop[0].r;
4295 vtop[-1].type.t = t;
4296 vpop();
4297 }
4298
4299 /* rotate n first stack elements to the bottom */
4300 void vrotb(int n)
4301 {
4302 int i;
4303 SValue tmp;
4304
4305 tmp = vtop[-n + 1];
4306 for(i=-n+1;i!=0;i++)
4307 vtop[i] = vtop[i+1];
4308 vtop[0] = tmp;
4309 }
4310
4311 /* pop stack value */
4312 void vpop(void)
4313 {
4314 int v;
4315 v = vtop->r & VT_VALMASK;
4316 #ifdef TCC_TARGET_I386
4317 /* for x86, we need to pop the FP stack */
4318 if (v == REG_ST0 && !nocode_wanted) {
4319 o(0xd9dd); /* fstp %st(1) */
4320 } else
4321 #endif
4322 if (v == VT_JMP || v == VT_JMPI) {
4323 /* need to put correct jump if && or || without test */
4324 gsym(vtop->c.ul);
4325 }
4326 vtop--;
4327 }
4328
4329 /* convert stack entry to register and duplicate its value in another
4330 register */
4331 void gv_dup(void)
4332 {
4333 int rc, t, r, r1;
4334 SValue sv;
4335
4336 t = vtop->type.t;
4337 if ((t & VT_BTYPE) == VT_LLONG) {
4338 lexpand();
4339 gv_dup();
4340 vswap();
4341 vrotb(3);
4342 gv_dup();
4343 vrotb(4);
4344 /* stack: H L L1 H1 */
4345 lbuild(t);
4346 vrotb(3);
4347 vrotb(3);
4348 vswap();
4349 lbuild(t);
4350 vswap();
4351 } else {
4352 /* duplicate value */
4353 rc = RC_INT;
4354 sv.type.t = VT_INT;
4355 if (is_float(t)) {
4356 rc = RC_FLOAT;
4357 sv.type.t = t;
4358 }
4359 r = gv(rc);
4360 r1 = get_reg(rc);
4361 sv.r = r;
4362 sv.c.ul = 0;
4363 load(r1, &sv); /* move r to r1 */
4364 vdup();
4365 /* duplicates value */
4366 vtop->r = r1;
4367 }
4368 }
4369
4370 /* generate CPU independent (unsigned) long long operations */
4371 void gen_opl(int op)
4372 {
4373 int t, a, b, op1, c, i;
4374 int func;
4375 GFuncContext gf;
4376 SValue tmp;
4377
4378 switch(op) {
4379 case '/':
4380 case TOK_PDIV:
4381 func = TOK___divdi3;
4382 goto gen_func;
4383 case TOK_UDIV:
4384 func = TOK___udivdi3;
4385 goto gen_func;
4386 case '%':
4387 func = TOK___moddi3;
4388 goto gen_func;
4389 case TOK_UMOD:
4390 func = TOK___umoddi3;
4391 gen_func:
4392 /* call generic long long function */
4393 gfunc_start(&gf, FUNC_CDECL);
4394 gfunc_param(&gf);
4395 gfunc_param(&gf);
4396 vpush_global_sym(&func_old_type, func);
4397 gfunc_call(&gf);
4398 vpushi(0);
4399 vtop->r = REG_IRET;
4400 vtop->r2 = REG_LRET;
4401 break;
4402 case '^':
4403 case '&':
4404 case '|':
4405 case '*':
4406 case '+':
4407 case '-':
4408 t = vtop->type.t;
4409 vswap();
4410 lexpand();
4411 vrotb(3);
4412 lexpand();
4413 /* stack: L1 H1 L2 H2 */
4414 tmp = vtop[0];
4415 vtop[0] = vtop[-3];
4416 vtop[-3] = tmp;
4417 tmp = vtop[-2];
4418 vtop[-2] = vtop[-3];
4419 vtop[-3] = tmp;
4420 vswap();
4421 /* stack: H1 H2 L1 L2 */
4422 if (op == '*') {
4423 vpushv(vtop - 1);
4424 vpushv(vtop - 1);
4425 gen_op(TOK_UMULL);
4426 lexpand();
4427 /* stack: H1 H2 L1 L2 ML MH */
4428 for(i=0;i<4;i++)
4429 vrotb(6);
4430 /* stack: ML MH H1 H2 L1 L2 */
4431 tmp = vtop[0];
4432 vtop[0] = vtop[-2];
4433 vtop[-2] = tmp;
4434 /* stack: ML MH H1 L2 H2 L1 */
4435 gen_op('*');
4436 vrotb(3);
4437 vrotb(3);
4438 gen_op('*');
4439 /* stack: ML MH M1 M2 */
4440 gen_op('+');
4441 gen_op('+');
4442 } else if (op == '+' || op == '-') {
4443 /* XXX: add non carry method too (for MIPS or alpha) */
4444 if (op == '+')
4445 op1 = TOK_ADDC1;
4446 else
4447 op1 = TOK_SUBC1;
4448 gen_op(op1);
4449 /* stack: H1 H2 (L1 op L2) */
4450 vrotb(3);
4451 vrotb(3);
4452 gen_op(op1 + 1); /* TOK_xxxC2 */
4453 } else {
4454 gen_op(op);
4455 /* stack: H1 H2 (L1 op L2) */
4456 vrotb(3);
4457 vrotb(3);
4458 /* stack: (L1 op L2) H1 H2 */
4459 gen_op(op);
4460 /* stack: (L1 op L2) (H1 op H2) */
4461 }
4462 /* stack: L H */
4463 lbuild(t);
4464 break;
4465 case TOK_SAR:
4466 case TOK_SHR:
4467 case TOK_SHL:
4468 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
4469 t = vtop[-1].type.t;
4470 vswap();
4471 lexpand();
4472 vrotb(3);
4473 /* stack: L H shift */
4474 c = (int)vtop->c.i;
4475 /* constant: simpler */
4476 /* NOTE: all comments are for SHL. the other cases are
4477 done by swaping words */
4478 vpop();
4479 if (op != TOK_SHL)
4480 vswap();
4481 if (c >= 32) {
4482 /* stack: L H */
4483 vpop();
4484 if (c > 32) {
4485 vpushi(c - 32);
4486 gen_op(op);
4487 }
4488 if (op != TOK_SAR) {
4489 vpushi(0);
4490 } else {
4491 gv_dup();
4492 vpushi(31);
4493 gen_op(TOK_SAR);
4494 }
4495 vswap();
4496 } else {
4497 vswap();
4498 gv_dup();
4499 /* stack: H L L */
4500 vpushi(c);
4501 gen_op(op);
4502 vswap();
4503 vpushi(32 - c);
4504 if (op == TOK_SHL)
4505 gen_op(TOK_SHR);
4506 else
4507 gen_op(TOK_SHL);
4508 vrotb(3);
4509 /* stack: L L H */
4510 vpushi(c);
4511 if (op == TOK_SHL)
4512 gen_op(TOK_SHL);
4513 else
4514 gen_op(TOK_SHR);
4515 gen_op('|');
4516 }
4517 if (op != TOK_SHL)
4518 vswap();
4519 lbuild(t);
4520 } else {
4521 /* XXX: should provide a faster fallback on x86 ? */
4522 switch(op) {
4523 case TOK_SAR:
4524 func = TOK___sardi3;
4525 goto gen_func;
4526 case TOK_SHR:
4527 func = TOK___shrdi3;
4528 goto gen_func;
4529 case TOK_SHL:
4530 func = TOK___shldi3;
4531 goto gen_func;
4532 }
4533 }
4534 break;
4535 default:
4536 /* compare operations */
4537 t = vtop->type.t;
4538 vswap();
4539 lexpand();
4540 vrotb(3);
4541 lexpand();
4542 /* stack: L1 H1 L2 H2 */
4543 tmp = vtop[-1];
4544 vtop[-1] = vtop[-2];
4545 vtop[-2] = tmp;
4546 /* stack: L1 L2 H1 H2 */
4547 /* compare high */
4548 op1 = op;
4549 /* when values are equal, we need to compare low words. since
4550 the jump is inverted, we invert the test too. */
4551 if (op1 == TOK_LT)
4552 op1 = TOK_LE;
4553 else if (op1 == TOK_GT)
4554 op1 = TOK_GE;
4555 else if (op1 == TOK_ULT)
4556 op1 = TOK_ULE;
4557 else if (op1 == TOK_UGT)
4558 op1 = TOK_UGE;
4559 a = 0;
4560 b = 0;
4561 gen_op(op1);
4562 if (op1 != TOK_NE) {
4563 a = gtst(1, 0);
4564 }
4565 if (op != TOK_EQ) {
4566 /* generate non equal test */
4567 /* XXX: NOT PORTABLE yet */
4568 if (a == 0) {
4569 b = gtst(0, 0);
4570 } else {
4571 #ifdef TCC_TARGET_I386
4572 b = psym(0x850f, 0);
4573 #else
4574 error("not implemented");
4575 #endif
4576 }
4577 }
4578 /* compare low. Always unsigned */
4579 op1 = op;
4580 if (op1 == TOK_LT)
4581 op1 = TOK_ULT;
4582 else if (op1 == TOK_LE)
4583 op1 = TOK_ULE;
4584 else if (op1 == TOK_GT)
4585 op1 = TOK_UGT;
4586 else if (op1 == TOK_GE)
4587 op1 = TOK_UGE;
4588 gen_op(op1);
4589 a = gtst(1, a);
4590 gsym(b);
4591 vseti(VT_JMPI, a);
4592 break;
4593 }
4594 }
4595
4596 /* handle integer constant optimizations and various machine
4597 independant opt */
4598 void gen_opic(int op)
4599 {
4600 int fc, c1, c2, n;
4601 SValue *v1, *v2;
4602
4603 v1 = vtop - 1;
4604 v2 = vtop;
4605 /* currently, we cannot do computations with forward symbols */
4606 c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
4607 c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
4608 if (c1 && c2) {
4609 fc = v2->c.i;
4610 switch(op) {
4611 case '+': v1->c.i += fc; break;
4612 case '-': v1->c.i -= fc; break;
4613 case '&': v1->c.i &= fc; break;
4614 case '^': v1->c.i ^= fc; break;
4615 case '|': v1->c.i |= fc; break;
4616 case '*': v1->c.i *= fc; break;
4617
4618 case TOK_PDIV:
4619 case '/':
4620 case '%':
4621 case TOK_UDIV:
4622 case TOK_UMOD:
4623 /* if division by zero, generate explicit division */
4624 if (fc == 0) {
4625 if (const_wanted)
4626 error("division by zero in constant");
4627 goto general_case;
4628 }
4629 switch(op) {
4630 default: v1->c.i /= fc; break;
4631 case '%': v1->c.i %= fc; break;
4632 case TOK_UDIV: v1->c.i = (unsigned)v1->c.i / fc; break;
4633 case TOK_UMOD: v1->c.i = (unsigned)v1->c.i % fc; break;
4634 }
4635 break;
4636 case TOK_SHL: v1->c.i <<= fc; break;
4637 case TOK_SHR: v1->c.i = (unsigned)v1->c.i >> fc; break;
4638 case TOK_SAR: v1->c.i >>= fc; break;
4639 /* tests */
4640 case TOK_ULT: v1->c.i = (unsigned)v1->c.i < (unsigned)fc; break;
4641 case TOK_UGE: v1->c.i = (unsigned)v1->c.i >= (unsigned)fc; break;
4642 case TOK_EQ: v1->c.i = v1->c.i == fc; break;
4643 case TOK_NE: v1->c.i = v1->c.i != fc; break;
4644 case TOK_ULE: v1->c.i = (unsigned)v1->c.i <= (unsigned)fc; break;
4645 case TOK_UGT: v1->c.i = (unsigned)v1->c.i > (unsigned)fc; break;
4646 case TOK_LT: v1->c.i = v1->c.i < fc; break;
4647 case TOK_GE: v1->c.i = v1->c.i >= fc; break;
4648 case TOK_LE: v1->c.i = v1->c.i <= fc; break;
4649 case TOK_GT: v1->c.i = v1->c.i > fc; break;
4650 /* logical */
4651 case TOK_LAND: v1->c.i = v1->c.i && fc; break;
4652 case TOK_LOR: v1->c.i = v1->c.i || fc; break;
4653 default:
4654 goto general_case;
4655 }
4656 vtop--;
4657 } else {
4658 /* if commutative ops, put c2 as constant */
4659 if (c1 && (op == '+' || op == '&' || op == '^' ||
4660 op == '|' || op == '*')) {
4661 vswap();
4662 swap(&c1, &c2);
4663 }
4664 fc = vtop->c.i;
4665 if (c2 && (((op == '*' || op == '/' || op == TOK_UDIV ||
4666 op == TOK_PDIV) &&
4667 fc == 1) ||
4668 ((op == '+' || op == '-' || op == '|' || op == '^' ||
4669 op == TOK_SHL || op == TOK_SHR || op == TOK_SAR) &&
4670 fc == 0) ||
4671 (op == '&' &&
4672 fc == -1))) {
4673 /* nothing to do */
4674 vtop--;
4675 } else if (c2 && (op == '*' || op == TOK_PDIV || op == TOK_UDIV)) {
4676 /* try to use shifts instead of muls or divs */
4677 if (fc > 0 && (fc & (fc - 1)) == 0) {
4678 n = -1;
4679 while (fc) {
4680 fc >>= 1;
4681 n++;
4682 }
4683 vtop->c.i = n;
4684 if (op == '*')
4685 op = TOK_SHL;
4686 else if (op == TOK_PDIV)
4687 op = TOK_SAR;
4688 else
4689 op = TOK_SHR;
4690 }
4691 goto general_case;
4692 } else if (c2 && (op == '+' || op == '-') &&
4693 (vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM)) ==
4694 (VT_CONST | VT_SYM)) {
4695 /* symbol + constant case */
4696 if (op == '-')
4697 fc = -fc;
4698 vtop--;
4699 vtop->c.i += fc;
4700 } else {
4701 general_case:
4702 if (!nocode_wanted) {
4703 /* call low level op generator */
4704 gen_opi(op);
4705 } else {
4706 vtop--;
4707 }
4708 }
4709 }
4710 }
4711
4712 /* generate a floating point operation with constant propagation */
4713 void gen_opif(int op)
4714 {
4715 int c1, c2;
4716 SValue *v1, *v2;
4717 long double f1, f2;
4718
4719 v1 = vtop - 1;
4720 v2 = vtop;
4721 /* currently, we cannot do computations with forward symbols */
4722 c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
4723 c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
4724 if (c1 && c2) {
4725 if (v1->type.t == VT_FLOAT) {
4726 f1 = v1->c.f;
4727 f2 = v2->c.f;
4728 } else if (v1->type.t == VT_DOUBLE) {
4729 f1 = v1->c.d;
4730 f2 = v2->c.d;
4731 } else {
4732 f1 = v1->c.ld;
4733 f2 = v2->c.ld;
4734 }
4735
4736 /* NOTE: we only do constant propagation if finite number (not
4737 NaN or infinity) (ANSI spec) */
4738 if (!ieee_finite(f1) || !ieee_finite(f2))
4739 goto general_case;
4740
4741 switch(op) {
4742 case '+': f1 += f2; break;
4743 case '-': f1 -= f2; break;
4744 case '*': f1 *= f2; break;
4745 case '/':
4746 if (f2 == 0.0) {
4747 if (const_wanted)
4748 error("division by zero in constant");
4749 goto general_case;
4750 }
4751 f1 /= f2;
4752 break;
4753 /* XXX: also handles tests ? */
4754 default:
4755 goto general_case;
4756 }
4757 /* XXX: overflow test ? */
4758 if (v1->type.t == VT_FLOAT) {
4759 v1->c.f = f1;
4760 } else if (v1->type.t == VT_DOUBLE) {
4761 v1->c.d = f1;
4762 } else {
4763 v1->c.ld = f1;
4764 }
4765 vtop--;
4766 } else {
4767 general_case:
4768 if (!nocode_wanted) {
4769 gen_opf(op);
4770 } else {
4771 vtop--;
4772 }
4773 }
4774 }
4775
4776 static int pointed_size(CType *type)
4777 {
4778 int align;
4779 return type_size(pointed_type(type), &align);
4780 }
4781
4782 #if 0
4783 void check_pointer_types(SValue *p1, SValue *p2)
4784 {
4785 char buf1[256], buf2[256];
4786 int t1, t2;
4787 t1 = p1->t;
4788 t2 = p2->t;
4789 if (!is_compatible_types(t1, t2)) {
4790 type_to_str(buf1, sizeof(buf1), t1, NULL);
4791 type_to_str(buf2, sizeof(buf2), t2, NULL);
4792 error("incompatible pointers '%s' and '%s'", buf1, buf2);
4793 }
4794 }
4795 #endif
4796
4797 /* generic gen_op: handles types problems */
4798 void gen_op(int op)
4799 {
4800 int u, t1, t2, bt1, bt2, t;
4801 CType type1;
4802
4803 t1 = vtop[-1].type.t;
4804 t2 = vtop[0].type.t;
4805 bt1 = t1 & VT_BTYPE;
4806 bt2 = t2 & VT_BTYPE;
4807
4808 if (bt1 == VT_PTR || bt2 == VT_PTR) {
4809 /* at least one operand is a pointer */
4810 /* relationnal op: must be both pointers */
4811 if (op >= TOK_ULT && op <= TOK_GT) {
4812 // check_pointer_types(vtop, vtop - 1);
4813 /* pointers are handled are unsigned */
4814 t = VT_INT | VT_UNSIGNED;
4815 goto std_op;
4816 }
4817 /* if both pointers, then it must be the '-' op */
4818 if (bt1 == VT_PTR && bt2 == VT_PTR) {
4819 if (op != '-')
4820 error("cannot use pointers here");
4821 // check_pointer_types(vtop - 1, vtop);
4822 /* XXX: check that types are compatible */
4823 u = pointed_size(&vtop[-1].type);
4824 gen_opic(op);
4825 /* set to integer type */
4826 vtop->type.t = VT_INT;
4827 vpushi(u);
4828 gen_op(TOK_PDIV);
4829 } else {
4830 /* exactly one pointer : must be '+' or '-'. */
4831 if (op != '-' && op != '+')
4832 error("cannot use pointers here");
4833 /* Put pointer as first operand */
4834 if (bt2 == VT_PTR) {
4835 vswap();
4836 swap(&t1, &t2);
4837 }
4838 type1 = vtop[-1].type;
4839 /* XXX: cast to int ? (long long case) */
4840 vpushi(pointed_size(&vtop[-1].type));
4841 gen_op('*');
4842 #ifdef CONFIG_TCC_BCHECK
4843 /* if evaluating constant expression, no code should be
4844 generated, so no bound check */
4845 if (do_bounds_check && !const_wanted) {
4846 /* if bounded pointers, we generate a special code to
4847 test bounds */
4848 if (op == '-') {
4849 vpushi(0);
4850 vswap();
4851 gen_op('-');
4852 }
4853 gen_bounded_ptr_add();
4854 } else
4855 #endif
4856 {
4857 gen_opic(op);
4858 }
4859 /* put again type if gen_opic() swaped operands */
4860 vtop->type = type1;
4861 }
4862 } else if (is_float(bt1) || is_float(bt2)) {
4863 /* compute bigger type and do implicit casts */
4864 if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) {
4865 t = VT_LDOUBLE;
4866 } else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) {
4867 t = VT_DOUBLE;
4868 } else {
4869 t = VT_FLOAT;
4870 }
4871 /* floats can only be used for a few operations */
4872 if (op != '+' && op != '-' && op != '*' && op != '/' &&
4873 (op < TOK_ULT || op > TOK_GT))
4874 error("invalid operands for binary operation");
4875 goto std_op;
4876 } else if (bt1 == VT_LLONG || bt2 == VT_LLONG) {
4877 /* cast to biggest op */
4878 t = VT_LLONG;
4879 /* convert to unsigned if it does not fit in a long long */
4880 if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED) ||
4881 (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED))
4882 t |= VT_UNSIGNED;
4883 goto std_op;
4884 } else {
4885 /* integer operations */
4886 t = VT_INT;
4887 /* convert to unsigned if it does not fit in an integer */
4888 if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED) ||
4889 (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED))
4890 t |= VT_UNSIGNED;
4891 std_op:
4892 /* XXX: currently, some unsigned operations are explicit, so
4893 we modify them here */
4894 if (t & VT_UNSIGNED) {
4895 if (op == TOK_SAR)
4896 op = TOK_SHR;
4897 else if (op == '/')
4898 op = TOK_UDIV;
4899 else if (op == '%')
4900 op = TOK_UMOD;
4901 else if (op == TOK_LT)
4902 op = TOK_ULT;
4903 else if (op == TOK_GT)
4904 op = TOK_UGT;
4905 else if (op == TOK_LE)
4906 op = TOK_ULE;
4907 else if (op == TOK_GE)
4908 op = TOK_UGE;
4909 }
4910 vswap();
4911 type1.t = t;
4912 gen_cast(&type1);
4913 vswap();
4914 /* special case for shifts and long long: we keep the shift as
4915 an integer */
4916 if (op == TOK_SHR || op == TOK_SAR || op == TOK_SHL)
4917 type1.t = VT_INT;
4918 gen_cast(&type1);
4919 if (is_float(t))
4920 gen_opif(op);
4921 else if ((t & VT_BTYPE) == VT_LLONG)
4922 gen_opl(op);
4923 else
4924 gen_opic(op);
4925 if (op >= TOK_ULT && op <= TOK_GT) {
4926 /* relationnal op: the result is an int */
4927 vtop->type.t = VT_INT;
4928 } else {
4929 vtop->type.t = t;
4930 }
4931 }
4932 }
4933
4934 /* generic itof for unsigned long long case */
4935 void gen_cvt_itof1(int t)
4936 {
4937 GFuncContext gf;
4938
4939 if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) ==
4940 (VT_LLONG | VT_UNSIGNED)) {
4941
4942 gfunc_start(&gf, FUNC_CDECL);
4943 gfunc_param(&gf);
4944 if (t == VT_FLOAT)
4945 vpush_global_sym(&func_old_type, TOK___ulltof);
4946 else if (t == VT_DOUBLE)
4947 vpush_global_sym(&func_old_type, TOK___ulltod);
4948 else
4949 vpush_global_sym(&func_old_type, TOK___ulltold);
4950 gfunc_call(&gf);
4951 vpushi(0);
4952 vtop->r = REG_FRET;
4953 } else {
4954 gen_cvt_itof(t);
4955 }
4956 }
4957
4958 /* generic ftoi for unsigned long long case */
4959 void gen_cvt_ftoi1(int t)
4960 {
4961 GFuncContext gf;
4962 int st;
4963
4964 if (t == (VT_LLONG | VT_UNSIGNED)) {
4965 /* not handled natively */
4966 gfunc_start(&gf, FUNC_CDECL);
4967 st = vtop->type.t & VT_BTYPE;
4968 gfunc_param(&gf);
4969 if (st == VT_FLOAT)
4970 vpush_global_sym(&func_old_type, TOK___fixunssfdi);
4971 else if (st == VT_DOUBLE)
4972 vpush_global_sym(&func_old_type, TOK___fixunsdfdi);
4973 else
4974 vpush_global_sym(&func_old_type, TOK___fixunsxfdi);
4975 gfunc_call(&gf);
4976 vpushi(0);
4977 vtop->r = REG_IRET;
4978 vtop->r2 = REG_LRET;
4979 } else {
4980 gen_cvt_ftoi(t);
4981 }
4982 }
4983
4984 /* force char or short cast */
4985 void force_charshort_cast(int t)
4986 {
4987 int bits, dbt;
4988 dbt = t & VT_BTYPE;
4989 /* XXX: add optimization if lvalue : just change type and offset */
4990 if (dbt == VT_BYTE)
4991 bits = 8;
4992 else
4993 bits = 16;
4994 if (t & VT_UNSIGNED) {
4995 vpushi((1 << bits) - 1);
4996 gen_op('&');
4997 } else {
4998 bits = 32 - bits;
4999 vpushi(bits);
5000 gen_op(TOK_SHL);
5001 vpushi(bits);
5002 gen_op(TOK_SAR);
5003 }
5004 }
5005
5006 /* cast 'vtop' to 'type' */
5007 static void gen_cast(CType *type)
5008 {
5009 int sbt, dbt, sf, df, c;
5010
5011 /* special delayed cast for char/short */
5012 /* XXX: in some cases (multiple cascaded casts), it may still
5013 be incorrect */
5014 if (vtop->r & VT_MUSTCAST) {
5015 vtop->r &= ~VT_MUSTCAST;
5016 force_charshort_cast(vtop->type.t);
5017 }
5018
5019 dbt = type->t & (VT_BTYPE | VT_UNSIGNED);
5020 sbt = vtop->type.t & (VT_BTYPE | VT_UNSIGNED);
5021
5022 if (sbt != dbt && !nocode_wanted) {
5023 sf = is_float(sbt);
5024 df = is_float(dbt);
5025 c = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
5026 if (sf && df) {
5027 /* convert from fp to fp */
5028 if (c) {
5029 /* constant case: we can do it now */
5030 /* XXX: in ISOC, cannot do it if error in convert */
5031 if (dbt == VT_FLOAT && sbt == VT_DOUBLE)
5032 vtop->c.f = (float)vtop->c.d;
5033 else if (dbt == VT_FLOAT && sbt == VT_LDOUBLE)
5034 vtop->c.f = (float)vtop->c.ld;
5035 else if (dbt == VT_DOUBLE && sbt == VT_FLOAT)
5036 vtop->c.d = (double)vtop->c.f;
5037 else if (dbt == VT_DOUBLE && sbt == VT_LDOUBLE)
5038 vtop->c.d = (double)vtop->c.ld;
5039 else if (dbt == VT_LDOUBLE && sbt == VT_FLOAT)
5040 vtop->c.ld = (long double)vtop->c.f;
5041 else if (dbt == VT_LDOUBLE && sbt == VT_DOUBLE)
5042 vtop->c.ld = (long double)vtop->c.d;
5043 } else {
5044 /* non constant case: generate code */
5045 gen_cvt_ftof(dbt);
5046 }
5047 } else if (df) {
5048 /* convert int to fp */
5049 if (c) {
5050 switch(sbt) {
5051 case VT_LLONG | VT_UNSIGNED:
5052 case VT_LLONG:
5053 /* XXX: add const cases for long long */
5054 goto do_itof;
5055 case VT_INT | VT_UNSIGNED:
5056 switch(dbt) {
5057 case VT_FLOAT: vtop->c.f = (float)vtop->c.ui; break;
5058 case VT_DOUBLE: vtop->c.d = (double)vtop->c.ui; break;
5059 case VT_LDOUBLE: vtop->c.ld = (long double)vtop->c.ui; break;
5060 }
5061 break;
5062 default:
5063 switch(dbt) {
5064 case VT_FLOAT: vtop->c.f = (float)vtop->c.i; break;
5065 case VT_DOUBLE: vtop->c.d = (double)vtop->c.i; break;
5066 case VT_LDOUBLE: vtop->c.ld = (long double)vtop->c.i; break;
5067 }
5068 break;
5069 }
5070 } else {
5071 do_itof:
5072 gen_cvt_itof1(dbt);
5073 }
5074 } else if (sf) {
5075 /* convert fp to int */
5076 /* we handle char/short/etc... with generic code */
5077 if (dbt != (VT_INT | VT_UNSIGNED) &&
5078 dbt != (VT_LLONG | VT_UNSIGNED) &&
5079 dbt != VT_LLONG)
5080 dbt = VT_INT;
5081 if (c) {
5082 switch(dbt) {
5083 case VT_LLONG | VT_UNSIGNED:
5084 case VT_LLONG:
5085 /* XXX: add const cases for long long */
5086 goto do_ftoi;
5087 case VT_INT | VT_UNSIGNED:
5088 switch(sbt) {
5089 case VT_FLOAT: vtop->c.ui = (unsigned int)vtop->c.d; break;
5090 case VT_DOUBLE: vtop->c.ui = (unsigned int)vtop->c.d; break;
5091 case VT_LDOUBLE: vtop->c.ui = (unsigned int)vtop->c.d; break;
5092 }
5093 break;
5094 default:
5095 /* int case */
5096 switch(sbt) {
5097 case VT_FLOAT: vtop->c.i = (int)vtop->c.d; break;
5098 case VT_DOUBLE: vtop->c.i = (int)vtop->c.d; break;
5099 case VT_LDOUBLE: vtop->c.i = (int)vtop->c.d; break;
5100 }
5101 break;
5102 }
5103 } else {
5104 do_ftoi:
5105 gen_cvt_ftoi1(dbt);
5106 }
5107 if (dbt == VT_INT && (type->t & (VT_BTYPE | VT_UNSIGNED)) != dbt) {
5108 /* additionnal cast for char/short/bool... */
5109 vtop->type.t = dbt;
5110 gen_cast(type);
5111 }
5112 } else if ((dbt & VT_BTYPE) == VT_LLONG) {
5113 if ((sbt & VT_BTYPE) != VT_LLONG) {
5114 /* scalar to long long */
5115 if (c) {
5116 if (sbt == (VT_INT | VT_UNSIGNED))
5117 vtop->c.ll = vtop->c.ui;
5118 else
5119 vtop->c.ll = vtop->c.i;
5120 } else {
5121 /* machine independant conversion */
5122 gv(RC_INT);
5123 /* generate high word */
5124 if (sbt == (VT_INT | VT_UNSIGNED)) {
5125 vpushi(0);
5126 gv(RC_INT);
5127 } else {
5128 gv_dup();
5129 vpushi(31);
5130 gen_op(TOK_SAR);
5131 }
5132 /* patch second register */
5133 vtop[-1].r2 = vtop->r;
5134 vpop();
5135 }
5136 }
5137 } else if (dbt == VT_BOOL) {
5138 /* scalar to bool */
5139 vpushi(0);
5140 gen_op(TOK_NE);
5141 } else if ((dbt & VT_BTYPE) == VT_BYTE ||
5142 (dbt & VT_BTYPE) == VT_SHORT) {
5143 force_charshort_cast(dbt);
5144 } else if ((dbt & VT_BTYPE) == VT_INT) {
5145 /* scalar to int */
5146 if (sbt == VT_LLONG) {
5147 /* from long long: just take low order word */
5148 lexpand();
5149 vpop();
5150 }
5151 /* if lvalue and single word type, nothing to do because
5152 the lvalue already contains the real type size (see
5153 VT_LVAL_xxx constants) */
5154 }
5155 }
5156 vtop->type = *type;
5157 }
5158
5159 /* return type size. Put alignment at 'a' */
5160 static int type_size(CType *type, int *a)
5161 {
5162 Sym *s;
5163 int bt;
5164
5165 bt = type->t & VT_BTYPE;
5166 if (bt == VT_STRUCT) {
5167 /* struct/union */
5168 s = type->ref;
5169 *a = s->r;
5170 return s->c;
5171 } else if (bt == VT_PTR) {
5172 if (type->t & VT_ARRAY) {
5173 s = type->ref;
5174 return type_size(&s->type, a) * s->c;
5175 } else {
5176 *a = PTR_SIZE;
5177 return PTR_SIZE;
5178 }
5179 } else if (bt == VT_LDOUBLE) {
5180 *a = LDOUBLE_ALIGN;
5181 return LDOUBLE_SIZE;
5182 } else if (bt == VT_DOUBLE || bt == VT_LLONG) {
5183 *a = 4; /* XXX: i386 specific */
5184 return 8;
5185 } else if (bt == VT_INT || bt == VT_ENUM || bt == VT_FLOAT) {
5186 *a = 4;
5187 return 4;
5188 } else if (bt == VT_SHORT) {
5189 *a = 2;
5190 return 2;
5191 } else {
5192 /* char, void, function, _Bool */
5193 *a = 1;
5194 return 1;
5195 }
5196 }
5197
5198 /* return the pointed type of t */
5199 static inline CType *pointed_type(CType *type)
5200 {
5201 return &type->ref->type;
5202 }
5203
5204 /* modify type so that its it is a pointer to type. */
5205 static void mk_pointer(CType *type)
5206 {
5207 Sym *s;
5208 s = sym_push(SYM_FIELD, type, 0, -1);
5209 type->t = VT_PTR | (type->t & ~VT_TYPE);
5210 type->ref = s;
5211 }
5212
5213 static int is_compatible_types(CType *type1, CType *type2)
5214 {
5215 Sym *s1, *s2;
5216 int bt1, bt2, t1, t2;
5217
5218 t1 = type1->t & VT_TYPE;
5219 t2 = type2->t & VT_TYPE;
5220 bt1 = t1 & VT_BTYPE;
5221 bt2 = t2 & VT_BTYPE;
5222 if (bt1 == VT_PTR) {
5223 type1 = pointed_type(type1);
5224 /* if function, then convert implicitely to function pointer */
5225 if (bt2 != VT_FUNC) {
5226 if (bt2 != VT_PTR)
5227 return 0;
5228 type2 = pointed_type(type2);
5229 }
5230 /* void matches everything */
5231 /* XXX: not fully compliant */
5232 if ((type1->t & VT_TYPE) == VT_VOID || (type2->t & VT_TYPE) == VT_VOID)
5233 return 1;
5234 return is_compatible_types(type1, type2);
5235 } else if (bt1 == VT_STRUCT || bt2 == VT_STRUCT) {
5236 return (t2 == t1);
5237 } else if (bt1 == VT_FUNC) {
5238 if (bt2 != VT_FUNC)
5239 return 0;
5240 s1 = type1->ref;
5241 s2 = type2->ref;
5242 if (!is_compatible_types(&s1->type, &s2->type))
5243 return 0;
5244 /* XXX: not complete */
5245 if (s1->c == FUNC_OLD || s2->c == FUNC_OLD)
5246 return 1;
5247 if (s1->c != s2->c)
5248 return 0;
5249 while (s1 != NULL) {
5250 if (s2 == NULL)
5251 return 0;
5252 if (!is_compatible_types(&s1->type, &s2->type))
5253 return 0;
5254 s1 = s1->next;
5255 s2 = s2->next;
5256 }
5257 if (s2)
5258 return 0;
5259 return 1;
5260 } else {
5261 /* XXX: not complete */
5262 return 1;
5263 }
5264 }
5265
5266 /* print a type. If 'varstr' is not NULL, then the variable is also
5267 printed in the type */
5268 /* XXX: union */
5269 /* XXX: add array and function pointers */
5270 void type_to_str(char *buf, int buf_size,
5271 CType *type, const char *varstr)
5272 {
5273 int bt, v, t;
5274 Sym *s, *sa;
5275 char buf1[256];
5276 const char *tstr;
5277
5278 t = type->t & VT_TYPE;
5279 bt = t & VT_BTYPE;
5280 buf[0] = '\0';
5281 if (t & VT_UNSIGNED)
5282 pstrcat(buf, buf_size, "unsigned ");
5283 switch(bt) {
5284 case VT_VOID:
5285 tstr = "void";
5286 goto add_tstr;
5287 case VT_BOOL:
5288 tstr = "_Bool";
5289 goto add_tstr;
5290 case VT_BYTE:
5291 tstr = "char";
5292 goto add_tstr;
5293 case VT_SHORT:
5294 tstr = "short";
5295 goto add_tstr;
5296 case VT_INT:
5297 tstr = "int";
5298 goto add_tstr;
5299 case VT_LONG:
5300 tstr = "long";
5301 goto add_tstr;
5302 case VT_LLONG:
5303 tstr = "long long";
5304 goto add_tstr;
5305 case VT_FLOAT:
5306 tstr = "float";
5307 goto add_tstr;
5308 case VT_DOUBLE:
5309 tstr = "double";
5310 goto add_tstr;
5311 case VT_LDOUBLE:
5312 tstr = "long double";
5313 add_tstr:
5314 pstrcat(buf, buf_size, tstr);
5315 break;
5316 case VT_ENUM:
5317 case VT_STRUCT:
5318 if (bt == VT_STRUCT)
5319 tstr = "struct ";
5320 else
5321 tstr = "enum ";
5322 pstrcat(buf, buf_size, tstr);
5323 v = type->ref->v & ~SYM_STRUCT;
5324 if (v >= SYM_FIRST_ANOM)
5325 pstrcat(buf, buf_size, "<anonymous>");
5326 else
5327 pstrcat(buf, buf_size, get_tok_str(v, NULL));
5328 break;
5329 case VT_FUNC:
5330 s = type->ref;
5331 type_to_str(buf, buf_size, &s->type, varstr);
5332 pstrcat(buf, buf_size, "(");
5333 sa = s->next;
5334 while (sa != NULL) {
5335 type_to_str(buf1, sizeof(buf1), &sa->type, NULL);
5336 pstrcat(buf, buf_size, buf1);
5337 sa = sa->next;
5338 if (sa)
5339 pstrcat(buf, buf_size, ", ");
5340 }
5341 pstrcat(buf, buf_size, ")");
5342 goto no_var;
5343 case VT_PTR:
5344 s = type->ref;
5345 pstrcpy(buf1, sizeof(buf1), "*");
5346 if (varstr)
5347 pstrcat(buf1, sizeof(buf1), varstr);
5348 type_to_str(buf, buf_size, &s->type, buf1);
5349 goto no_var;
5350 }
5351 if (varstr) {
5352 pstrcat(buf, buf_size, " ");
5353 pstrcat(buf, buf_size, varstr);
5354 }
5355 no_var: ;
5356 }
5357
5358 /* verify type compatibility to store vtop in 'dt' type, and generate
5359 casts if needed. */
5360 void gen_assign_cast(CType *dt)
5361 {
5362 CType *st;
5363 char buf1[256], buf2[256];
5364
5365 st = &vtop->type; /* source type */
5366 if ((dt->t & VT_BTYPE) == VT_PTR) {
5367 /* special cases for pointers */
5368 /* a function is implicitely a function pointer */
5369 if ((st->t & VT_BTYPE) == VT_FUNC) {
5370 if (!is_compatible_types(pointed_type(dt), st))
5371 goto error;
5372 else
5373 goto type_ok;
5374 }
5375 /* '0' can also be a pointer */
5376 if ((st->t & VT_BTYPE) == VT_INT &&
5377 ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) &&
5378 vtop->c.i == 0)
5379 goto type_ok;
5380 }
5381 if (!is_compatible_types(dt, st)) {
5382 error:
5383 type_to_str(buf1, sizeof(buf1), st, NULL);
5384 type_to_str(buf2, sizeof(buf2), dt, NULL);
5385 error("cannot cast '%s' to '%s'", buf1, buf2);
5386 }
5387 type_ok:
5388 gen_cast(dt);
5389 }
5390
5391 /* store vtop in lvalue pushed on stack */
5392 void vstore(void)
5393 {
5394 int sbt, dbt, ft, r, t, size, align, bit_size, bit_pos, rc, delayed_cast;
5395 GFuncContext gf;
5396
5397 ft = vtop[-1].type.t;
5398 sbt = vtop->type.t & VT_BTYPE;
5399 dbt = ft & VT_BTYPE;
5400 if (((sbt == VT_INT || sbt == VT_SHORT) && dbt == VT_BYTE) ||
5401 (sbt == VT_INT && dbt == VT_SHORT)) {
5402 /* optimize char/short casts */
5403 delayed_cast = VT_MUSTCAST;
5404 vtop->type.t = ft & VT_TYPE;
5405 } else {
5406 delayed_cast = 0;
5407 gen_assign_cast(&vtop[-1].type);
5408 }
5409
5410 if (sbt == VT_STRUCT) {
5411 /* if structure, only generate pointer */
5412 /* structure assignment : generate memcpy */
5413 /* XXX: optimize if small size */
5414 if (!nocode_wanted) {
5415 vdup();
5416 gfunc_start(&gf, FUNC_CDECL);
5417 /* type size */
5418 size = type_size(&vtop->type, &align);
5419 vpushi(size);
5420 gfunc_param(&gf);
5421 /* source */
5422 vtop->type.t = VT_INT;
5423 gaddrof();
5424 gfunc_param(&gf);
5425 /* destination */
5426 vswap();
5427 vtop->type.t = VT_INT;
5428 gaddrof();
5429 gfunc_param(&gf);
5430
5431 save_regs(0);
5432 vpush_global_sym(&func_old_type, TOK_memcpy);
5433 gfunc_call(&gf);
5434 } else {
5435 vswap();
5436 vpop();
5437 }
5438 /* leave source on stack */
5439 } else if (ft & VT_BITFIELD) {
5440 /* bitfield store handling */
5441 bit_pos = (ft >> VT_STRUCT_SHIFT) & 0x3f;
5442 bit_size = (ft >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
5443 /* remove bit field info to avoid loops */
5444 vtop[-1].type.t = ft & ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT));
5445
5446 /* duplicate destination */
5447 vdup();
5448 vtop[-1] = vtop[-2];
5449
5450 /* mask and shift source */
5451 vpushi((1 << bit_size) - 1);
5452 gen_op('&');
5453 vpushi(bit_pos);
5454 gen_op(TOK_SHL);
5455 /* load destination, mask and or with source */
5456 vswap();
5457 vpushi(~(((1 << bit_size) - 1) << bit_pos));
5458 gen_op('&');
5459 gen_op('|');
5460 /* store result */
5461 vstore();
5462 } else {
5463 #ifdef CONFIG_TCC_BCHECK
5464 /* bound check case */
5465 if (vtop[-1].r & VT_MUSTBOUND) {
5466 vswap();
5467 gbound();
5468 vswap();
5469 }
5470 #endif
5471 if (!nocode_wanted) {
5472 rc = RC_INT;
5473 if (is_float(ft))
5474 rc = RC_FLOAT;
5475 r = gv(rc); /* generate value */
5476 /* if lvalue was saved on stack, must read it */
5477 if ((vtop[-1].r & VT_VALMASK) == VT_LLOCAL) {
5478 SValue sv;
5479 t = get_reg(RC_INT);
5480 sv.type.t = VT_INT;
5481 sv.r = VT_LOCAL | VT_LVAL;
5482 sv.c.ul = vtop[-1].c.ul;
5483 load(t, &sv);
5484 vtop[-1].r = t | VT_LVAL;
5485 }
5486 store(r, vtop - 1);
5487 /* two word case handling : store second register at word + 4 */
5488 if ((ft & VT_BTYPE) == VT_LLONG) {
5489 vswap();
5490 /* convert to int to increment easily */
5491 vtop->type.t = VT_INT;
5492 gaddrof();
5493 vpushi(4);
5494 gen_op('+');
5495 vtop->r |= VT_LVAL;
5496 vswap();
5497 /* XXX: it works because r2 is spilled last ! */
5498 store(vtop->r2, vtop - 1);
5499 }
5500 }
5501 vswap();
5502 vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
5503 vtop->r |= delayed_cast;
5504 }
5505 }
5506
5507 /* post defines POST/PRE add. c is the token ++ or -- */
5508 void inc(int post, int c)
5509 {
5510 test_lvalue();
5511 vdup(); /* save lvalue */
5512 if (post) {
5513 gv_dup(); /* duplicate value */
5514 vrotb(3);
5515 vrotb(3);
5516 }
5517 /* add constant */
5518 vpushi(c - TOK_MID);
5519 gen_op('+');
5520 vstore(); /* store value */
5521 if (post)
5522 vpop(); /* if post op, return saved value */
5523 }
5524
5525 /* Parse GNUC __attribute__ extension. Currently, the following
5526 extensions are recognized:
5527 - aligned(n) : set data/function alignment.
5528 - section(x) : generate data/code in this section.
5529 - unused : currently ignored, but may be used someday.
5530 */
5531 void parse_attribute(AttributeDef *ad)
5532 {
5533 int t, n;
5534
5535 next();
5536 skip('(');
5537 skip('(');
5538 while (tok != ')') {
5539 if (tok < TOK_IDENT)
5540 expect("attribute name");
5541 t = tok;
5542 next();
5543 switch(t) {
5544 case TOK_SECTION:
5545 case TOK___SECTION__:
5546 skip('(');
5547 if (tok != TOK_STR)
5548 expect("section name");
5549 ad->section = find_section(tcc_state, (char *)tokc.cstr->data);
5550 next();
5551 skip(')');
5552 break;
5553 case TOK_ALIGNED:
5554 case TOK___ALIGNED__:
5555 skip('(');
5556 n = expr_const();
5557 if (n <= 0 || (n & (n - 1)) != 0)
5558 error("alignment must be a positive power of two");
5559 ad->aligned = n;
5560 skip(')');
5561 break;
5562 case TOK_UNUSED:
5563 case TOK___UNUSED__:
5564 /* currently, no need to handle it because tcc does not
5565 track unused objects */
5566 break;
5567 case TOK_NORETURN:
5568 case TOK___NORETURN__:
5569 /* currently, no need to handle it because tcc does not
5570 track unused objects */
5571 break;
5572 case TOK_CDECL:
5573 case TOK___CDECL:
5574 case TOK___CDECL__:
5575 ad->func_call = FUNC_CDECL;
5576 break;
5577 case TOK_STDCALL:
5578 case TOK___STDCALL:
5579 case TOK___STDCALL__:
5580 ad->func_call = FUNC_STDCALL;
5581 break;
5582 default:
5583 warning("'%s' attribute ignored", get_tok_str(t, NULL));
5584 /* skip parameters */
5585 /* XXX: skip parenthesis too */
5586 if (tok == '(') {
5587 next();
5588 while (tok != ')' && tok != -1)
5589 next();
5590 next();
5591 }
5592 break;
5593 }
5594 if (tok != ',')
5595 break;
5596 next();
5597 }
5598 skip(')');
5599 skip(')');
5600 }
5601
5602 /* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
5603 static void struct_decl(CType *type, int u)
5604 {
5605 int a, v, size, align, maxalign, c, offset;
5606 int bit_size, bit_pos, bsize, bt, lbit_pos;
5607 Sym *s, *ss, **ps;
5608 AttributeDef ad;
5609 CType type1, btype;
5610
5611 a = tok; /* save decl type */
5612 next();
5613 if (tok != '{') {
5614 v = tok;
5615 next();
5616 /* struct already defined ? return it */
5617 /* XXX: check consistency */
5618 s = struct_find(v);
5619 if (s) {
5620 if (s->type.t != a)
5621 error("invalid type");
5622 goto do_decl;
5623 }
5624 } else {
5625 v = anon_sym++;
5626 }
5627 type1.t = a;
5628 s = sym_push(v | SYM_STRUCT, &type1, 0, 0);
5629 /* put struct/union/enum name in type */
5630 do_decl:
5631 type->t = u;
5632 type->ref = s;
5633
5634 if (tok == '{') {
5635 next();
5636 if (s->c)
5637 error("struct/union/enum already defined");
5638 /* cannot be empty */
5639 c = 0;
5640 /* non empty enums are not allowed */
5641 if (a == TOK_ENUM) {
5642 for(;;) {
5643 v = tok;
5644 next();
5645 if (tok == '=') {
5646 next();
5647 c = expr_const();
5648 }
5649 /* enum symbols have static storage */
5650 ss = sym_push(v, &int_type, VT_CONST, c);
5651 ss->type.t |= VT_STATIC;
5652 if (tok == ',')
5653 next();
5654 c++;
5655 if (tok == '}')
5656 break;
5657 }
5658 skip('}');
5659 } else {
5660 maxalign = 1;
5661 ps = &s->next;
5662 bit_pos = 0;
5663 offset = 0;
5664 while (tok != '}') {
5665 parse_btype(&btype, &ad);
5666 while (1) {
5667 bit_size = -1;
5668 v = 0;
5669 type1 = btype;
5670 if (tok != ':') {
5671 type_decl(&type1, &ad, &v, TYPE_DIRECT);
5672 if ((type1.t & VT_BTYPE) == VT_FUNC ||
5673 (type1.t & (VT_TYPEDEF | VT_STATIC | VT_EXTERN)))
5674 error("invalid type for '%s'",
5675 get_tok_str(v, NULL));
5676 }
5677 if (tok == ':') {
5678 next();
5679 bit_size = expr_const();
5680 /* XXX: handle v = 0 case for messages */
5681 if (bit_size < 0)
5682 error("negative width in bit-field '%s'",
5683 get_tok_str(v, NULL));
5684 if (v && bit_size == 0)
5685 error("zero width for bit-field '%s'",
5686 get_tok_str(v, NULL));
5687 }
5688 size = type_size(&type1, &align);
5689 lbit_pos = 0;
5690 if (bit_size >= 0) {
5691 bt = type1.t & VT_BTYPE;
5692 if (bt != VT_INT &&
5693 bt != VT_BYTE &&
5694 bt != VT_SHORT &&
5695 bt != VT_ENUM)
5696 error("bitfields must have scalar type");
5697 bsize = size * 8;
5698 if (bit_size > bsize) {
5699 error("width of '%s' exceeds its type",
5700 get_tok_str(v, NULL));
5701 } else if (bit_size == bsize) {
5702 /* no need for bit fields */
5703 bit_pos = 0;
5704 } else if (bit_size == 0) {
5705 /* XXX: what to do if only padding in a
5706 structure ? */
5707 /* zero size: means to pad */
5708 if (bit_pos > 0)
5709 bit_pos = bsize;
5710 } else {
5711 /* we do not have enough room ? */
5712 if ((bit_pos + bit_size) > bsize)
5713 bit_pos = 0;
5714 lbit_pos = bit_pos;
5715 /* XXX: handle LSB first */
5716 type1.t |= VT_BITFIELD |
5717 (bit_pos << VT_STRUCT_SHIFT) |
5718 (bit_size << (VT_STRUCT_SHIFT + 6));
5719 bit_pos += bit_size;
5720 }
5721 } else {
5722 bit_pos = 0;
5723 }
5724 if (v) {
5725 /* add new memory data only if starting
5726 bit field */
5727 if (lbit_pos == 0) {
5728 if (a == TOK_STRUCT) {
5729 c = (c + align - 1) & -align;
5730 offset = c;
5731 c += size;
5732 } else {
5733 offset = 0;
5734 if (size > c)
5735 c = size;
5736 }
5737 if (align > maxalign)
5738 maxalign = align;
5739 }
5740 #if 0
5741 printf("add field %s offset=%d",
5742 get_tok_str(v, NULL), offset);
5743 if (type1.t & VT_BITFIELD) {
5744 printf(" pos=%d size=%d",
5745 (type1.t >> VT_STRUCT_SHIFT) & 0x3f,
5746 (type1.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f);
5747 }
5748 printf("\n");
5749 #endif
5750 ss = sym_push(v | SYM_FIELD, &type1, 0, offset);
5751 *ps = ss;
5752 ps = &ss->next;
5753 }
5754 if (tok == ';' || tok == TOK_EOF)
5755 break;
5756 skip(',');
5757 }
5758 skip(';');
5759 }
5760 skip('}');
5761 /* store size and alignment */
5762 s->c = (c + maxalign - 1) & -maxalign;
5763 s->r = maxalign;
5764 }
5765 }
5766 }
5767
5768 /* return 0 if no type declaration. otherwise, return the basic type
5769 and skip it.
5770 */
5771 static int parse_btype(CType *type, AttributeDef *ad)
5772 {
5773 int t, u, type_found;
5774 Sym *s;
5775 CType type1;
5776
5777 memset(ad, 0, sizeof(AttributeDef));
5778 type_found = 0;
5779 t = 0;
5780 while(1) {
5781 switch(tok) {
5782 /* basic types */
5783 case TOK_CHAR:
5784 u = VT_BYTE;
5785 basic_type:
5786 next();
5787 basic_type1:
5788 if ((t & VT_BTYPE) != 0)
5789 error("too many basic types");
5790 t |= u;
5791 break;
5792 case TOK_VOID:
5793 u = VT_VOID;
5794 goto basic_type;
5795 case TOK_SHORT:
5796 u = VT_SHORT;
5797 goto basic_type;
5798 case TOK_INT:
5799 next();
5800 break;
5801 case TOK_LONG:
5802 next();
5803 if ((t & VT_BTYPE) == VT_DOUBLE) {
5804 t = (t & ~VT_BTYPE) | VT_LDOUBLE;
5805 } else if ((t & VT_BTYPE) == VT_LONG) {
5806 t = (t & ~VT_BTYPE) | VT_LLONG;
5807 } else {
5808 u = VT_LONG;
5809 goto basic_type1;
5810 }
5811 break;
5812 case TOK_BOOL:
5813 u = VT_BOOL;
5814 goto basic_type;
5815 case TOK_FLOAT:
5816 u = VT_FLOAT;
5817 goto basic_type;
5818 case TOK_DOUBLE:
5819 next();
5820 if ((t & VT_BTYPE) == VT_LONG) {
5821 t = (t & ~VT_BTYPE) | VT_LDOUBLE;
5822 } else {
5823 u = VT_DOUBLE;
5824 goto basic_type1;
5825 }
5826 break;
5827 case TOK_ENUM:
5828 struct_decl(&type1, VT_ENUM);
5829 basic_type2:
5830 u = type1.t;
5831 type->ref = type1.ref;
5832 goto basic_type1;
5833 case TOK_STRUCT:
5834 case TOK_UNION:
5835 struct_decl(&type1, VT_STRUCT);
5836 goto basic_type2;
5837
5838 /* type modifiers */
5839 case TOK_CONST:
5840 case TOK_VOLATILE:
5841 case TOK_REGISTER:
5842 case TOK_SIGNED:
5843 case TOK___SIGNED__:
5844 case TOK_AUTO:
5845 case TOK_INLINE:
5846 case TOK___INLINE__:
5847 case TOK_RESTRICT:
5848 next();
5849 break;
5850 case TOK_UNSIGNED:
5851 t |= VT_UNSIGNED;
5852 next();
5853 break;
5854
5855 /* storage */
5856 case TOK_EXTERN:
5857 t |= VT_EXTERN;
5858 next();
5859 break;
5860 case TOK_STATIC:
5861 t |= VT_STATIC;
5862 next();
5863 break;
5864 case TOK_TYPEDEF:
5865 t |= VT_TYPEDEF;
5866 next();
5867 break;
5868 /* GNUC attribute */
5869 case TOK___ATTRIBUTE__:
5870 parse_attribute(ad);
5871 break;
5872 /* GNUC typeof */
5873 case TOK_TYPEOF:
5874 next();
5875 parse_expr_type(&type1);
5876 goto basic_type2;
5877 default:
5878 s = sym_find(tok);
5879 if (!s || !(s->type.t & VT_TYPEDEF))
5880 goto the_end;
5881 t |= (s->type.t & ~VT_TYPEDEF);
5882 type->ref = s->type.ref;
5883 next();
5884 break;
5885 }
5886 type_found = 1;
5887 }
5888 the_end:
5889 /* long is never used as type */
5890 if ((t & VT_BTYPE) == VT_LONG)
5891 t = (t & ~VT_BTYPE) | VT_INT;
5892 type->t = t;
5893 return type_found;
5894 }
5895
5896 static void post_type(CType *type, AttributeDef *ad)
5897 {
5898 int n, l, t1;
5899 Sym **plast, *s, *first;
5900 AttributeDef ad1;
5901 CType pt;
5902
5903 if (tok == '(') {
5904 /* function declaration */
5905 next();
5906 l = 0;
5907 first = NULL;
5908 plast = &first;
5909 while (tok != ')') {
5910 /* read param name and compute offset */
5911 if (l != FUNC_OLD) {
5912 if (!parse_btype(&pt, &ad1)) {
5913 if (l) {
5914 error("invalid type");
5915 } else {
5916 l = FUNC_OLD;
5917 goto old_proto;
5918 }
5919 }
5920 l = FUNC_NEW;
5921 if ((pt.t & VT_BTYPE) == VT_VOID && tok == ')')
5922 break;
5923 type_decl(&pt, &ad1, &n, TYPE_DIRECT | TYPE_ABSTRACT);
5924 if ((pt.t & VT_BTYPE) == VT_VOID)
5925 error("parameter declared as void");
5926 } else {
5927 old_proto:
5928 n = tok;
5929 pt.t = VT_INT;
5930 next();
5931 }
5932 /* array must be transformed to pointer according to ANSI C */
5933 pt.t &= ~VT_ARRAY;
5934 s = sym_push(n | SYM_FIELD, &pt, 0, 0);
5935 *plast = s;
5936 plast = &s->next;
5937 if (tok == ',') {
5938 next();
5939 if (l == FUNC_NEW && tok == TOK_DOTS) {
5940 l = FUNC_ELLIPSIS;
5941 next();
5942 break;
5943 }
5944 }
5945 }
5946 /* if no parameters, then old type prototype */
5947 if (l == 0)
5948 l = FUNC_OLD;
5949 skip(')');
5950 t1 = type->t & (VT_TYPEDEF | VT_STATIC | VT_EXTERN);
5951 type->t &= ~(VT_TYPEDEF | VT_STATIC | VT_EXTERN);
5952 post_type(type, ad);
5953 /* we push a anonymous symbol which will contain the function prototype */
5954 s = sym_push(SYM_FIELD, type, ad->func_call, l);
5955 s->next = first;
5956 type->t = t1 | VT_FUNC;
5957 type->ref = s;
5958 } else if (tok == '[') {
5959 /* array definition */
5960 next();
5961 n = -1;
5962 if (tok != ']') {
5963 n = expr_const();
5964 if (n < 0)
5965 error("invalid array size");
5966 }
5967 skip(']');
5968 /* parse next post type */
5969 t1 = type->t & (VT_TYPEDEF | VT_STATIC | VT_EXTERN);
5970 type->t &= ~(VT_TYPEDEF | VT_STATIC | VT_EXTERN);
5971 post_type(type, ad);
5972
5973 /* we push a anonymous symbol which will contain the array
5974 element type */
5975 s = sym_push(SYM_FIELD, type, 0, n);
5976 type->t = t1 | VT_ARRAY | VT_PTR;
5977 type->ref = s;
5978 }
5979 }
5980
5981 /* Parse a type declaration (except basic type), and return the type
5982 in 'type'. 'td' is a bitmask indicating which kind of type decl is
5983 expected. 'type' should contain the basic type. 'ad' is the
5984 attribute definition of the basic type. It can be modified by
5985 type_decl().
5986 */
5987 static void type_decl(CType *type, AttributeDef *ad, int *v, int td)
5988 {
5989 Sym *s;
5990 CType type1, *type2;
5991
5992 while (tok == '*') {
5993 next();
5994 while (tok == TOK_CONST || tok == TOK_VOLATILE || tok == TOK_RESTRICT)
5995 next();
5996 mk_pointer(type);
5997 }
5998
5999 /* recursive type */
6000 /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
6001 type1.t = 0; /* XXX: same as int */
6002 if (tok == '(') {
6003 next();
6004 /* XXX: this is not correct to modify 'ad' at this point, but
6005 the syntax is not clear */
6006 if (tok == TOK___ATTRIBUTE__)
6007 parse_attribute(ad);
6008 type_decl(&type1, ad, v, td);
6009 skip(')');
6010 } else {
6011 /* type identifier */
6012 if (tok >= TOK_IDENT && (td & TYPE_DIRECT)) {
6013 *v = tok;
6014 next();
6015 } else {
6016 if (!(td & TYPE_ABSTRACT))
6017 expect("identifier");
6018 *v = 0;
6019 }
6020 }
6021 post_type(type, ad);
6022 if (tok == TOK___ATTRIBUTE__)
6023 parse_attribute(ad);
6024 if (!type1.t)
6025 return;
6026 /* append type at the end of type1 */
6027 type2 = &type1;
6028 for(;;) {
6029 s = type2->ref;
6030 type2 = &s->type;
6031 if (!type2->t) {
6032 *type2 = *type;
6033 break;
6034 }
6035 }
6036 *type = type1;
6037 }
6038
6039 /* compute the lvalue VT_LVAL_xxx needed to match type t. */
6040 static int lvalue_type(int t)
6041 {
6042 int bt, r;
6043 r = VT_LVAL;
6044 bt = t & VT_BTYPE;
6045 if (bt == VT_BYTE)
6046 r |= VT_LVAL_BYTE;
6047 else if (bt == VT_SHORT)
6048 r |= VT_LVAL_SHORT;
6049 else
6050 return r;
6051 if (t & VT_UNSIGNED)
6052 r |= VT_LVAL_UNSIGNED;
6053 return r;
6054 }
6055
6056 /* indirection with full error checking and bound check */
6057 static void indir(void)
6058 {
6059 if ((vtop->type.t & VT_BTYPE) != VT_PTR)
6060 expect("pointer");
6061 if ((vtop->r & VT_LVAL) && !nocode_wanted)
6062 gv(RC_INT);
6063 vtop->type = *pointed_type(&vtop->type);
6064 /* an array is never an lvalue */
6065 if (!(vtop->type.t & VT_ARRAY)) {
6066 vtop->r |= lvalue_type(vtop->type.t);
6067 /* if bound checking, the referenced pointer must be checked */
6068 if (do_bounds_check)
6069 vtop->r |= VT_MUSTBOUND;
6070 }
6071 }
6072
6073 /* pass a parameter to a function and do type checking and casting */
6074 void gfunc_param_typed(GFuncContext *gf, Sym *func, Sym *arg)
6075 {
6076 int func_type;
6077 CType type;
6078
6079 func_type = func->c;
6080 if (func_type == FUNC_OLD ||
6081 (func_type == FUNC_ELLIPSIS && arg == NULL)) {
6082 /* default casting : only need to convert float to double */
6083 if ((vtop->type.t & VT_BTYPE) == VT_FLOAT) {
6084 type.t = VT_DOUBLE;
6085 gen_cast(&type);
6086 }
6087 } else if (arg == NULL) {
6088 error("too many arguments to function");
6089 } else {
6090 gen_assign_cast(&arg->type);
6091 }
6092 if (!nocode_wanted) {
6093 gfunc_param(gf);
6094 } else {
6095 vpop();
6096 }
6097 }
6098
6099 /* parse an expression of the form '(type)' or '(expr)' and return its
6100 type */
6101 static void parse_expr_type(CType *type)
6102 {
6103 int n;
6104 AttributeDef ad;
6105
6106 skip('(');
6107 if (parse_btype(type, &ad)) {
6108 type_decl(type, &ad, &n, TYPE_ABSTRACT);
6109 } else {
6110 expr_type(type);
6111 }
6112 skip(')');
6113 }
6114
6115 static void vpush_tokc(int t)
6116 {
6117 CType type;
6118 type.t = t;
6119 vsetc(&type, VT_CONST, &tokc);
6120 }
6121
6122 static void unary(void)
6123 {
6124 int n, t, align, size, r;
6125 CType type;
6126 Sym *s;
6127 GFuncContext gf;
6128 AttributeDef ad;
6129
6130 /* XXX: GCC 2.95.3 does not generate a table although it should be
6131 better here */
6132 switch(tok) {
6133 case TOK_CINT:
6134 case TOK_CCHAR:
6135 case TOK_LCHAR:
6136 vpushi(tokc.i);
6137 next();
6138 break;
6139 case TOK_CUINT:
6140 vpush_tokc(VT_INT | VT_UNSIGNED);
6141 next();
6142 break;
6143 case TOK_CLLONG:
6144 vpush_tokc(VT_LLONG);
6145 next();
6146 break;
6147 case TOK_CULLONG:
6148 vpush_tokc(VT_LLONG | VT_UNSIGNED);
6149 next();
6150 break;
6151 case TOK_CFLOAT:
6152 vpush_tokc(VT_FLOAT);
6153 next();
6154 break;
6155 case TOK_CDOUBLE:
6156 vpush_tokc(VT_DOUBLE);
6157 next();
6158 break;
6159 case TOK_CLDOUBLE:
6160 vpush_tokc(VT_LDOUBLE);
6161 next();
6162 break;
6163 case TOK___FUNCTION__:
6164 if (!gnu_ext)
6165 goto tok_identifier;
6166 /* fall thru */
6167 case TOK___FUNC__:
6168 {
6169 void *ptr;
6170 int len;
6171 /* special function name identifier */
6172 len = strlen(funcname) + 1;
6173 /* generate char[len] type */
6174 type.t = VT_BYTE;
6175 mk_pointer(&type);
6176 type.t |= VT_ARRAY;
6177 type.ref->c = len;
6178 vpush_ref(&type, data_section, data_section->data_offset, len);
6179 ptr = section_ptr_add(data_section, len);
6180 memcpy(ptr, funcname, len);
6181 next();
6182 }
6183 break;
6184 case TOK_LSTR:
6185 t = VT_INT;
6186 goto str_init;
6187 case TOK_STR:
6188 /* string parsing */
6189 t = VT_BYTE;
6190 str_init:
6191 type.t = t;
6192 mk_pointer(&type);
6193 type.t |= VT_ARRAY;
6194 memset(&ad, 0, sizeof(AttributeDef));
6195 decl_initializer_alloc(&type, &ad, VT_CONST, 2, 0, 0);
6196 break;
6197 case '(':
6198 next();
6199 /* cast ? */
6200 if (parse_btype(&type, &ad)) {
6201 type_decl(&type, &ad, &n, TYPE_ABSTRACT);
6202 skip(')');
6203 /* check ISOC99 compound literal */
6204 if (tok == '{') {
6205 /* data is allocated locally by default */
6206 if (global_expr)
6207 r = VT_CONST;
6208 else
6209 r = VT_LOCAL;
6210 /* all except arrays are lvalues */
6211 if (!(type.t & VT_ARRAY))
6212 r |= lvalue_type(type.t);
6213 memset(&ad, 0, sizeof(AttributeDef));
6214 decl_initializer_alloc(&type, &ad, r, 1, 0, 0);
6215 } else {
6216 unary();
6217 gen_cast(&type);
6218 }
6219 } else {
6220 gexpr();
6221 skip(')');
6222 }
6223 break;
6224 case '*':
6225 next();
6226 unary();
6227 indir();
6228 break;
6229 case '&':
6230 next();
6231 unary();
6232 /* functions names must be treated as function pointers,
6233 except for unary '&' and sizeof. Since we consider that
6234 functions are not lvalues, we only have to handle it
6235 there and in function calls. */
6236 /* arrays can also be used although they are not lvalues */
6237 if ((vtop->type.t & VT_BTYPE) != VT_FUNC &&
6238 !(vtop->type.t & VT_ARRAY))
6239 test_lvalue();
6240 mk_pointer(&vtop->type);
6241 gaddrof();
6242 break;
6243 case '!':
6244 next();
6245 unary();
6246 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST)
6247 vtop->c.i = !vtop->c.i;
6248 else if ((vtop->r & VT_VALMASK) == VT_CMP)
6249 vtop->c.i = vtop->c.i ^ 1;
6250 else
6251 vseti(VT_JMP, gtst(1, 0));
6252 break;
6253 case '~':
6254 next();
6255 unary();
6256 vpushi(-1);
6257 gen_op('^');
6258 break;
6259 case '+':
6260 next();
6261 /* in order to force cast, we add zero */
6262 unary();
6263 if ((vtop->type.t & VT_BTYPE) == VT_PTR)
6264 error("pointer not accepted for unary plus");
6265 vpushi(0);
6266 gen_op('+');
6267 break;
6268 case TOK_SIZEOF:
6269 case TOK_ALIGNOF:
6270 t = tok;
6271 next();
6272 if (tok == '(') {
6273 parse_expr_type(&type);
6274 } else {
6275 unary_type(&type);
6276 }
6277 size = type_size(&type, &align);
6278 if (t == TOK_SIZEOF)
6279 vpushi(size);
6280 else
6281 vpushi(align);
6282 break;
6283
6284 case TOK_INC:
6285 case TOK_DEC:
6286 t = tok;
6287 next();
6288 unary();
6289 inc(0, t);
6290 break;
6291 case '-':
6292 next();
6293 vpushi(0);
6294 unary();
6295 gen_op('-');
6296 break;
6297 case TOK_LAND:
6298 if (!gnu_ext)
6299 goto tok_identifier;
6300 next();
6301 /* allow to take the address of a label */
6302 if (tok < TOK_UIDENT)
6303 expect("label identifier");
6304 s = label_find(tok);
6305 if (!s) {
6306 s = label_push(tok, LABEL_FORWARD);
6307 }
6308 if (!s->type.t) {
6309 s->type.t = VT_VOID;
6310 mk_pointer(&s->type);
6311 s->type.t |= VT_STATIC;
6312 }
6313 vset(&s->type, VT_CONST | VT_SYM, 0);
6314 vtop->sym = s;
6315 next();
6316 break;
6317 default:
6318 tok_identifier:
6319 t = tok;
6320 next();
6321 if (t < TOK_UIDENT)
6322 expect("identifier");
6323 s = sym_find(t);
6324 if (!s) {
6325 if (tok != '(')
6326 error("'%s' undeclared", get_tok_str(t, NULL));
6327 /* for simple function calls, we tolerate undeclared
6328 external reference to int() function */
6329 s = external_global_sym(t, &func_old_type, 0);
6330 }
6331 vset(&s->type, s->r, s->c);
6332 /* if forward reference, we must point to s */
6333 if (vtop->r & VT_SYM) {
6334 vtop->sym = s;
6335 vtop->c.ul = 0;
6336 }
6337 break;
6338 }
6339
6340 /* post operations */
6341 while (1) {
6342 if (tok == TOK_INC || tok == TOK_DEC) {
6343 inc(1, tok);
6344 next();
6345 } else if (tok == '.' || tok == TOK_ARROW) {
6346 /* field */
6347 if (tok == TOK_ARROW)
6348 indir();
6349 test_lvalue();
6350 gaddrof();
6351 next();
6352 /* expect pointer on structure */
6353 if ((vtop->type.t & VT_BTYPE) != VT_STRUCT)
6354 expect("struct or union");
6355 s = vtop->type.ref;
6356 /* find field */
6357 tok |= SYM_FIELD;
6358 while ((s = s->next) != NULL) {
6359 if (s->v == tok)
6360 break;
6361 }
6362 if (!s)
6363 error("field not found");
6364 /* add field offset to pointer */
6365 vtop->type = char_pointer_type; /* change type to 'char *' */
6366 vpushi(s->c);
6367 gen_op('+');
6368 /* change type to field type, and set to lvalue */
6369 vtop->type = s->type;
6370 /* an array is never an lvalue */
6371 if (!(vtop->type.t & VT_ARRAY)) {
6372 vtop->r |= lvalue_type(vtop->type.t);
6373 /* if bound checking, the referenced pointer must be checked */
6374 if (do_bounds_check)
6375 vtop->r |= VT_MUSTBOUND;
6376 }
6377 next();
6378 } else if (tok == '[') {
6379 next();
6380 gexpr();
6381 gen_op('+');
6382 indir();
6383 skip(']');
6384 } else if (tok == '(') {
6385 SValue ret;
6386 Sym *sa;
6387
6388 /* function call */
6389 if ((vtop->type.t & VT_BTYPE) != VT_FUNC) {
6390 /* pointer test (no array accepted) */
6391 if ((vtop->type.t & (VT_BTYPE | VT_ARRAY)) == VT_PTR) {
6392 vtop->type = *pointed_type(&vtop->type);
6393 if ((vtop->type.t & VT_BTYPE) != VT_FUNC)
6394 goto error_func;
6395 } else {
6396 error_func:
6397 expect("function pointer");
6398 }
6399 } else {
6400 vtop->r &= ~VT_LVAL; /* no lvalue */
6401 }
6402 /* get return type */
6403 s = vtop->type.ref;
6404 if (!nocode_wanted) {
6405 save_regs(0); /* save used temporary registers */
6406 gfunc_start(&gf, s->r);
6407 }
6408 next();
6409 sa = s->next; /* first parameter */
6410 #ifdef INVERT_FUNC_PARAMS
6411 {
6412 int parlevel;
6413 Sym *args, *s1;
6414 ParseState saved_parse_state;
6415 TokenString str;
6416
6417 /* read each argument and store it on a stack */
6418 args = NULL;
6419 if (tok != ')') {
6420 for(;;) {
6421 tok_str_new(&str);
6422 parlevel = 0;
6423 while ((parlevel > 0 || (tok != ')' && tok != ',')) &&
6424 tok != TOK_EOF) {
6425 if (tok == '(')
6426 parlevel++;
6427 else if (tok == ')')
6428 parlevel--;
6429 tok_str_add_tok(&str);
6430 next();
6431 }
6432 tok_str_add(&str, -1); /* end of file added */
6433 tok_str_add(&str, 0);
6434 s1 = sym_push2(&args, 0, 0, (int)str.str);
6435 s1->next = sa; /* add reference to argument */
6436 if (sa)
6437 sa = sa->next;
6438 if (tok == ')')
6439 break;
6440 skip(',');
6441 }
6442 }
6443
6444 /* now generate code in reverse order by reading the stack */
6445 save_parse_state(&saved_parse_state);
6446 while (args) {
6447 macro_ptr = (int *)args->c;
6448 next();
6449 expr_eq();
6450 if (tok != -1)
6451 expect("',' or ')'");
6452 gfunc_param_typed(&gf, s, args->next);
6453 s1 = args->prev;
6454 tok_str_free((int *)args->c);
6455 tcc_free(args);
6456 args = s1;
6457 }
6458 restore_parse_state(&saved_parse_state);
6459 }
6460 #endif
6461 /* compute first implicit argument if a structure is returned */
6462 if ((s->type.t & VT_BTYPE) == VT_STRUCT) {
6463 /* get some space for the returned structure */
6464 size = type_size(&s->type, &align);
6465 loc = (loc - size) & -align;
6466 ret.type = s->type;
6467 ret.r = VT_LOCAL | VT_LVAL;
6468 /* pass it as 'int' to avoid structure arg passing
6469 problems */
6470 vseti(VT_LOCAL, loc);
6471 ret.c = vtop->c;
6472 if (!nocode_wanted)
6473 gfunc_param(&gf);
6474 else
6475 vtop--;
6476 } else {
6477 ret.type = s->type;
6478 ret.r2 = VT_CONST;
6479 /* return in register */
6480 if (is_float(ret.type.t)) {
6481 ret.r = REG_FRET;
6482 } else {
6483 if ((ret.type.t & VT_BTYPE) == VT_LLONG)
6484 ret.r2 = REG_LRET;
6485 ret.r = REG_IRET;
6486 }
6487 ret.c.i = 0;
6488 }
6489 #ifndef INVERT_FUNC_PARAMS
6490 if (tok != ')') {
6491 for(;;) {
6492 expr_eq();
6493 gfunc_param_typed(&gf, s, sa);
6494 if (sa)
6495 sa = sa->next;
6496 if (tok == ')')
6497 break;
6498 skip(',');
6499 }
6500 }
6501 #endif
6502 if (sa)
6503 error("too few arguments to function");
6504 skip(')');
6505 if (!nocode_wanted)
6506 gfunc_call(&gf);
6507 else
6508 vtop--;
6509 /* return value */
6510 vsetc(&ret.type, ret.r, &ret.c);
6511 vtop->r2 = ret.r2;
6512 } else {
6513 break;
6514 }
6515 }
6516 }
6517
6518 static void uneq(void)
6519 {
6520 int t;
6521
6522 unary();
6523 if (tok == '=' ||
6524 (tok >= TOK_A_MOD && tok <= TOK_A_DIV) ||
6525 tok == TOK_A_XOR || tok == TOK_A_OR ||
6526 tok == TOK_A_SHL || tok == TOK_A_SAR) {
6527 test_lvalue();
6528 t = tok;
6529 next();
6530 if (t == '=') {
6531 expr_eq();
6532 } else {
6533 vdup();
6534 expr_eq();
6535 gen_op(t & 0x7f);
6536 }
6537 vstore();
6538 }
6539 }
6540
6541 static void expr_prod(void)
6542 {
6543 int t;
6544
6545 uneq();
6546 while (tok == '*' || tok == '/' || tok == '%') {
6547 t = tok;
6548 next();
6549 uneq();
6550 gen_op(t);
6551 }
6552 }
6553
6554 static void expr_sum(void)
6555 {
6556 int t;
6557
6558 expr_prod();
6559 while (tok == '+' || tok == '-') {
6560 t = tok;
6561 next();
6562 expr_prod();
6563 gen_op(t);
6564 }
6565 }
6566
6567 static void expr_shift(void)
6568 {
6569 int t;
6570
6571 expr_sum();
6572 while (tok == TOK_SHL || tok == TOK_SAR) {
6573 t = tok;
6574 next();
6575 expr_sum();
6576 gen_op(t);
6577 }
6578 }
6579
6580 static void expr_cmp(void)
6581 {
6582 int t;
6583
6584 expr_shift();
6585 while ((tok >= TOK_ULE && tok <= TOK_GT) ||
6586 tok == TOK_ULT || tok == TOK_UGE) {
6587 t = tok;
6588 next();
6589 expr_shift();
6590 gen_op(t);
6591 }
6592 }
6593
6594 static void expr_cmpeq(void)
6595 {
6596 int t;
6597
6598 expr_cmp();
6599 while (tok == TOK_EQ || tok == TOK_NE) {
6600 t = tok;
6601 next();
6602 expr_cmp();
6603 gen_op(t);
6604 }
6605 }
6606
6607 static void expr_and(void)
6608 {
6609 expr_cmpeq();
6610 while (tok == '&') {
6611 next();
6612 expr_cmpeq();
6613 gen_op('&');
6614 }
6615 }
6616
6617 static void expr_xor(void)
6618 {
6619 expr_and();
6620 while (tok == '^') {
6621 next();
6622 expr_and();
6623 gen_op('^');
6624 }
6625 }
6626
6627 static void expr_or(void)
6628 {
6629 expr_xor();
6630 while (tok == '|') {
6631 next();
6632 expr_xor();
6633 gen_op('|');
6634 }
6635 }
6636
6637 /* XXX: suppress this mess */
6638 static void expr_land_const(void)
6639 {
6640 expr_or();
6641 while (tok == TOK_LAND) {
6642 next();
6643 expr_or();
6644 gen_op(TOK_LAND);
6645 }
6646 }
6647
6648 /* XXX: suppress this mess */
6649 static void expr_lor_const(void)
6650 {
6651 expr_land_const();
6652 while (tok == TOK_LOR) {
6653 next();
6654 expr_land_const();
6655 gen_op(TOK_LOR);
6656 }
6657 }
6658
6659 /* only used if non constant */
6660 static void expr_land(void)
6661 {
6662 int t;
6663
6664 expr_or();
6665 if (tok == TOK_LAND) {
6666 t = 0;
6667 for(;;) {
6668 t = gtst(1, t);
6669 if (tok != TOK_LAND) {
6670 vseti(VT_JMPI, t);
6671 break;
6672 }
6673 next();
6674 expr_or();
6675 }
6676 }
6677 }
6678
6679 static void expr_lor(void)
6680 {
6681 int t;
6682
6683 expr_land();
6684 if (tok == TOK_LOR) {
6685 t = 0;
6686 for(;;) {
6687 t = gtst(0, t);
6688 if (tok != TOK_LOR) {
6689 vseti(VT_JMP, t);
6690 break;
6691 }
6692 next();
6693 expr_land();
6694 }
6695 }
6696 }
6697
6698 /* XXX: better constant handling */
6699 static void expr_eq(void)
6700 {
6701 int tt, u, r1, r2, rc, t1, t2, bt1, bt2;
6702 SValue sv;
6703 CType type, type1, type2;
6704
6705 if (const_wanted) {
6706 int c1, c;
6707 expr_lor_const();
6708 if (tok == '?') {
6709 c = vtop->c.i;
6710 vpop();
6711 next();
6712 gexpr();
6713 c1 = vtop->c.i;
6714 vpop();
6715 skip(':');
6716 expr_eq();
6717 if (c)
6718 vtop->c.i = c1;
6719 }
6720 } else {
6721 expr_lor();
6722 if (tok == '?') {
6723 next();
6724 if (vtop != vstack) {
6725 /* needed to avoid having different registers saved in
6726 each branch */
6727 if (is_float(vtop->type.t))
6728 rc = RC_FLOAT;
6729 else
6730 rc = RC_INT;
6731 gv(rc);
6732 save_regs(1);
6733 }
6734 tt = gtst(1, 0);
6735 gexpr();
6736 type1 = vtop->type;
6737 sv = *vtop; /* save value to handle it later */
6738 vtop--; /* no vpop so that FP stack is not flushed */
6739 skip(':');
6740 u = gjmp(0);
6741 gsym(tt);
6742 expr_eq();
6743 type2 = vtop->type;
6744
6745 t1 = type1.t;
6746 bt1 = t1 & VT_BTYPE;
6747 t2 = type2.t;
6748 bt2 = t2 & VT_BTYPE;
6749 /* cast operands to correct type according to ISOC rules */
6750 if (is_float(bt1) || is_float(bt2)) {
6751 if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) {
6752 type.t = VT_LDOUBLE;
6753 } else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) {
6754 type.t = VT_DOUBLE;
6755 } else {
6756 type.t = VT_FLOAT;
6757 }
6758 } else if (bt1 == VT_LLONG || bt2 == VT_LLONG) {
6759 /* cast to biggest op */
6760 type.t = VT_LLONG;
6761 /* convert to unsigned if it does not fit in a long long */
6762 if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED) ||
6763 (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED))
6764 type.t |= VT_UNSIGNED;
6765 } else if (bt1 == VT_PTR || bt2 == VT_PTR) {
6766 /* XXX: test pointer compatibility */
6767 type = type1;
6768 } else if (bt1 == VT_STRUCT || bt2 == VT_STRUCT) {
6769 /* XXX: test structure compatibility */
6770 type = type1;
6771 } else if (bt1 == VT_VOID || bt2 == VT_VOID) {
6772 /* NOTE: as an extension, we accept void on only one side */
6773 type.t = VT_VOID;
6774 } else {
6775 /* integer operations */
6776 type.t = VT_INT;
6777 /* convert to unsigned if it does not fit in an integer */
6778 if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED) ||
6779 (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED))
6780 type.t |= VT_UNSIGNED;
6781 }
6782
6783 /* now we convert second operand */
6784 gen_cast(&type);
6785 rc = RC_INT;
6786 if (is_float(type.t)) {
6787 rc = RC_FLOAT;
6788 } else if ((type.t & VT_BTYPE) == VT_LLONG) {
6789 /* for long longs, we use fixed registers to avoid having
6790 to handle a complicated move */
6791 rc = RC_IRET;
6792 }
6793
6794 r2 = gv(rc);
6795 /* this is horrible, but we must also convert first
6796 operand */
6797 tt = gjmp(0);
6798 gsym(u);
6799 /* put again first value and cast it */
6800 *vtop = sv;
6801 gen_cast(&type);
6802 r1 = gv(rc);
6803 move_reg(r2, r1);
6804 vtop->r = r2;
6805 gsym(tt);
6806 }
6807 }
6808 }
6809
6810 static void gexpr(void)
6811 {
6812 while (1) {
6813 expr_eq();
6814 if (tok != ',')
6815 break;
6816 vpop();
6817 next();
6818 }
6819 }
6820
6821 /* parse an expression and return its type without any side effect. */
6822 static void expr_type(CType *type)
6823 {
6824 int a;
6825
6826 a = nocode_wanted;
6827 nocode_wanted = 1;
6828 gexpr();
6829 *type = vtop->type;
6830 vpop();
6831 nocode_wanted = a;
6832 }
6833
6834 /* parse a unary expression and return its type without any side
6835 effect. */
6836 static void unary_type(CType *type)
6837 {
6838 int a;
6839
6840 a = nocode_wanted;
6841 nocode_wanted = 1;
6842 unary();
6843 *type = vtop->type;
6844 vpop();
6845 nocode_wanted = a;
6846 }
6847
6848 /* parse a constant expression and return value in vtop. */
6849 static void expr_const1(void)
6850 {
6851 int a;
6852 a = const_wanted;
6853 const_wanted = 1;
6854 expr_eq();
6855 const_wanted = a;
6856 }
6857
6858 /* parse an integer constant and return its value. */
6859 static int expr_const(void)
6860 {
6861 int c;
6862 expr_const1();
6863 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
6864 expect("constant expression");
6865 c = vtop->c.i;
6866 vpop();
6867 return c;
6868 }
6869
6870 /* return the label token if current token is a label, otherwise
6871 return zero */
6872 static int is_label(void)
6873 {
6874 int t;
6875 CValue c;
6876
6877 /* fast test first */
6878 if (tok < TOK_UIDENT)
6879 return 0;
6880 /* no need to save tokc since we expect an identifier */
6881 t = tok;
6882 c = tokc;
6883 next();
6884 if (tok == ':') {
6885 next();
6886 return t;
6887 } else {
6888 /* XXX: may not work in all cases (macros ?) */
6889 tok1 = tok;
6890 tok1c = tokc;
6891 tok = t;
6892 tokc = c;
6893 return 0;
6894 }
6895 }
6896
6897 static void block(int *bsym, int *csym, int *case_sym, int *def_sym, int case_reg)
6898 {
6899 int a, b, c, d;
6900 Sym *s;
6901
6902 /* generate line number info */
6903 if (do_debug &&
6904 (last_line_num != file->line_num || last_ind != ind)) {
6905 put_stabn(N_SLINE, 0, file->line_num, ind - func_ind);
6906 last_ind = ind;
6907 last_line_num = file->line_num;
6908 }
6909
6910 if (tok == TOK_IF) {
6911 /* if test */
6912 next();
6913 skip('(');
6914 gexpr();
6915 skip(')');
6916 a = gtst(1, 0);
6917 block(bsym, csym, case_sym, def_sym, case_reg);
6918 c = tok;
6919 if (c == TOK_ELSE) {
6920 next();
6921 d = gjmp(0);
6922 gsym(a);
6923 block(bsym, csym, case_sym, def_sym, case_reg);
6924 gsym(d); /* patch else jmp */
6925 } else
6926 gsym(a);
6927 } else if (tok == TOK_WHILE) {
6928 next();
6929 d = ind;
6930 skip('(');
6931 gexpr();
6932 skip(')');
6933 a = gtst(1, 0);
6934 b = 0;
6935 block(&a, &b, case_sym, def_sym, case_reg);
6936 gjmp_addr(d);
6937 gsym(a);
6938 gsym_addr(b, d);
6939 } else if (tok == '{') {
6940 next();
6941 /* declarations */
6942 s = local_stack;
6943 while (tok != '}') {
6944 decl(VT_LOCAL);
6945 if (tok != '}')
6946 block(bsym, csym, case_sym, def_sym, case_reg);
6947 }
6948 /* pop locally defined symbols */
6949 sym_pop(&local_stack, s);
6950 next();
6951 } else if (tok == TOK_RETURN) {
6952 next();
6953 if (tok != ';') {
6954 gexpr();
6955 gen_assign_cast(&func_vt);
6956 if ((func_vt.t & VT_BTYPE) == VT_STRUCT) {
6957 CType type;
6958 /* if returning structure, must copy it to implicit
6959 first pointer arg location */
6960 type = func_vt;
6961 mk_pointer(&type);
6962 vset(&type, VT_LOCAL | VT_LVAL, func_vc);
6963 indir();
6964 vswap();
6965 /* copy structure value to pointer */
6966 vstore();
6967 } else if (is_float(func_vt.t)) {
6968 gv(RC_FRET);
6969 } else {
6970 gv(RC_IRET);
6971 }
6972 vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
6973 }
6974 skip(';');
6975 rsym = gjmp(rsym); /* jmp */
6976 } else if (tok == TOK_BREAK) {
6977 /* compute jump */
6978 if (!bsym)
6979 error("cannot break");
6980 *bsym = gjmp(*bsym);
6981 next();
6982 skip(';');
6983 } else if (tok == TOK_CONTINUE) {
6984 /* compute jump */
6985 if (!csym)
6986 error("cannot continue");
6987 *csym = gjmp(*csym);
6988 next();
6989 skip(';');
6990 } else if (tok == TOK_FOR) {
6991 int e;
6992 next();
6993 skip('(');
6994 if (tok != ';') {
6995 gexpr();
6996 vpop();
6997 }
6998 skip(';');
6999 d = ind;
7000 c = ind;
7001 a = 0;
7002 b = 0;
7003 if (tok != ';') {
7004 gexpr();
7005 a = gtst(1, 0);
7006 }
7007 skip(';');
7008 if (tok != ')') {
7009 e = gjmp(0);
7010 c = ind;
7011 gexpr();
7012 vpop();
7013 gjmp_addr(d);
7014 gsym(e);
7015 }
7016 skip(')');
7017 block(&a, &b, case_sym, def_sym, case_reg);
7018 gjmp_addr(c);
7019 gsym(a);
7020 gsym_addr(b, c);
7021 } else
7022 if (tok == TOK_DO) {
7023 next();
7024 a = 0;
7025 b = 0;
7026 d = ind;
7027 block(&a, &b, case_sym, def_sym, case_reg);
7028 skip(TOK_WHILE);
7029 skip('(');
7030 gsym(b);
7031 gexpr();
7032 c = gtst(0, 0);
7033 gsym_addr(c, d);
7034 skip(')');
7035 gsym(a);
7036 skip(';');
7037 } else
7038 if (tok == TOK_SWITCH) {
7039 next();
7040 skip('(');
7041 gexpr();
7042 /* XXX: other types than integer */
7043 case_reg = gv(RC_INT);
7044 vpop();
7045 skip(')');
7046 a = 0;
7047 b = gjmp(0); /* jump to first case */
7048 c = 0;
7049 block(&a, csym, &b, &c, case_reg);
7050 /* if no default, jmp after switch */
7051 if (c == 0)
7052 c = ind;
7053 /* default label */
7054 gsym_addr(b, c);
7055 /* break label */
7056 gsym(a);
7057 } else
7058 if (tok == TOK_CASE) {
7059 int v1, v2;
7060 if (!case_sym)
7061 expect("switch");
7062 next();
7063 v1 = expr_const();
7064 v2 = v1;
7065 if (gnu_ext && tok == TOK_DOTS) {
7066 next();
7067 v2 = expr_const();
7068 if (v2 < v1)
7069 warning("empty case range");
7070 }
7071 /* since a case is like a label, we must skip it with a jmp */
7072 b = gjmp(0);
7073 gsym(*case_sym);
7074 vseti(case_reg, 0);
7075 vpushi(v1);
7076 if (v1 == v2) {
7077 gen_op(TOK_EQ);
7078 *case_sym = gtst(1, 0);
7079 } else {
7080 gen_op(TOK_GE);
7081 *case_sym = gtst(1, 0);
7082 vseti(case_reg, 0);
7083 vpushi(v2);
7084 gen_op(TOK_LE);
7085 *case_sym = gtst(1, *case_sym);
7086 }
7087 gsym(b);
7088 skip(':');
7089 block(bsym, csym, case_sym, def_sym, case_reg);
7090 } else
7091 if (tok == TOK_DEFAULT) {
7092 next();
7093 skip(':');
7094 if (!def_sym)
7095 expect("switch");
7096 if (*def_sym)
7097 error("too many 'default'");
7098 *def_sym = ind;
7099 block(bsym, csym, case_sym, def_sym, case_reg);
7100 } else
7101 if (tok == TOK_GOTO) {
7102 next();
7103 if (tok == '*' && gnu_ext) {
7104 /* computed goto */
7105 next();
7106 gexpr();
7107 if ((vtop->type.t & VT_BTYPE) != VT_PTR)
7108 expect("pointer");
7109 ggoto();
7110 } else if (tok >= TOK_UIDENT) {
7111 s = label_find(tok);
7112 /* put forward definition if needed */
7113 if (!s) {
7114 s = label_push(tok, LABEL_FORWARD);
7115 }
7116 /* label already defined */
7117 if (s->r & LABEL_FORWARD)
7118 s->next = (void *)gjmp((long)s->next);
7119 else
7120 gjmp_addr((long)s->next);
7121 next();
7122 } else {
7123 expect("label identifier");
7124 }
7125 skip(';');
7126 } else {
7127 b = is_label();
7128 if (b) {
7129 /* label case */
7130 s = label_find(b);
7131 if (s) {
7132 if (!(s->r & LABEL_FORWARD))
7133 error("multiple defined label");
7134 gsym((long)s->next);
7135 } else {
7136 s = label_push(b, 0);
7137 }
7138 s->next = (void *)ind;
7139 s->r = 0;
7140 /* we accept this, but it is a mistake */
7141 if (tok == '}')
7142 warning("deprecated use of label at end of compound statement");
7143 else
7144 block(bsym, csym, case_sym, def_sym, case_reg);
7145 } else {
7146 /* expression case */
7147 if (tok != ';') {
7148 gexpr();
7149 vpop();
7150 }
7151 skip(';');
7152 }
7153 }
7154 }
7155
7156 /* t is the array or struct type. c is the array or struct
7157 address. cur_index/cur_field is the pointer to the current
7158 value. 'size_only' is true if only size info is needed (only used
7159 in arrays) */
7160 static void decl_designator(CType *type, Section *sec, unsigned long c,
7161 int *cur_index, Sym **cur_field,
7162 int size_only)
7163 {
7164 Sym *s, *f;
7165 int notfirst, index, align, l;
7166 CType type1;
7167
7168 notfirst = 0;
7169 if (gnu_ext && (l = is_label()) != 0)
7170 goto struct_field;
7171
7172 while (tok == '[' || tok == '.') {
7173 if (tok == '[') {
7174 if (!(type->t & VT_ARRAY))
7175 expect("array type");
7176 s = type->ref;
7177 next();
7178 index = expr_const();
7179 if (index < 0 || (s->c >= 0 && index >= s->c))
7180 expect("invalid index");
7181 skip(']');
7182 if (!notfirst)
7183 *cur_index = index;
7184 type = pointed_type(type);
7185 c += index * type_size(type, &align);
7186 } else {
7187 next();
7188 l = tok;
7189 next();
7190 struct_field:
7191 if ((type->t & VT_BTYPE) != VT_STRUCT)
7192 expect("struct/union type");
7193 s = type->ref;
7194 l |= SYM_FIELD;
7195 f = s->next;
7196 while (f) {
7197 if (f->v == l)
7198 break;
7199 f = f->next;
7200 }
7201 if (!f)
7202 expect("field");
7203 if (!notfirst)
7204 *cur_field = f;
7205 /* XXX: suppress this mess by using explicit storage field */
7206 type1 = f->type;
7207 type1.t |= (type->t & ~VT_TYPE);
7208 type = &type1;
7209 c += f->c;
7210 }
7211 notfirst = 1;
7212 }
7213 if (notfirst) {
7214 if (tok == '=') {
7215 next();
7216 } else {
7217 if (!gnu_ext)
7218 expect("=");
7219 }
7220 } else {
7221 if (type->t & VT_ARRAY) {
7222 index = *cur_index;
7223 type = pointed_type(type);
7224 c += index * type_size(type, &align);
7225 } else {
7226 f = *cur_field;
7227 if (!f)
7228 error("too many field init");
7229 /* XXX: suppress this mess by using explicit storage field */
7230 type1 = f->type;
7231 type1.t |= (type->t & ~VT_TYPE);
7232 type = &type1;
7233 c += f->c;
7234 }
7235 }
7236 decl_initializer(type, sec, c, 0, size_only);
7237 }
7238
7239 #define EXPR_VAL 0
7240 #define EXPR_CONST 1
7241 #define EXPR_ANY 2
7242
7243 /* store a value or an expression directly in global data or in local array */
7244 static void init_putv(CType *type, Section *sec, unsigned long c,
7245 int v, int expr_type)
7246 {
7247 int saved_global_expr, bt;
7248 void *ptr;
7249
7250 switch(expr_type) {
7251 case EXPR_VAL:
7252 vpushi(v);
7253 break;
7254 case EXPR_CONST:
7255 /* compound literals must be allocated globally in this case */
7256 saved_global_expr = global_expr;
7257 global_expr = 1;
7258 expr_const1();
7259 global_expr = saved_global_expr;
7260 /* NOTE: symbols are accepted */
7261 if ((vtop->r & (VT_VALMASK | VT_LVAL)) != VT_CONST)
7262 error("initializer element is not constant");
7263 break;
7264 case EXPR_ANY:
7265 expr_eq();
7266 break;
7267 }
7268
7269 if (sec) {
7270 /* XXX: not portable */
7271 /* XXX: generate error if incorrect relocation */
7272 gen_assign_cast(type);
7273 bt = type->t & VT_BTYPE;
7274 ptr = sec->data + c;
7275 if ((vtop->r & VT_SYM) &&
7276 (bt == VT_BYTE ||
7277 bt == VT_SHORT ||
7278 bt == VT_DOUBLE ||
7279 bt == VT_LDOUBLE ||
7280 bt == VT_LLONG))
7281 error("initializer element is not computable at load time");
7282 switch(bt) {
7283 case VT_BYTE:
7284 *(char *)ptr = vtop->c.i;
7285 break;
7286 case VT_SHORT:
7287 *(short *)ptr = vtop->c.i;
7288 break;
7289 case VT_DOUBLE:
7290 *(double *)ptr = vtop->c.d;
7291 break;
7292 case VT_LDOUBLE:
7293 *(long double *)ptr = vtop->c.ld;
7294 break;
7295 case VT_LLONG:
7296 *(long long *)ptr = vtop->c.ll;
7297 break;
7298 default:
7299 if (vtop->r & VT_SYM) {
7300 greloc(sec, vtop->sym, c, R_DATA_32);
7301 }
7302 *(int *)ptr = vtop->c.i;
7303 break;
7304 }
7305 vtop--;
7306 } else {
7307 vset(type, VT_LOCAL, c);
7308 vswap();
7309 vstore();
7310 vpop();
7311 }
7312 }
7313
7314 /* put zeros for variable based init */
7315 static void init_putz(CType *t, Section *sec, unsigned long c, int size)
7316 {
7317 GFuncContext gf;
7318
7319 if (sec) {
7320 /* nothing to do because globals are already set to zero */
7321 } else {
7322 gfunc_start(&gf, FUNC_CDECL);
7323 vpushi(size);
7324 gfunc_param(&gf);
7325 vpushi(0);
7326 gfunc_param(&gf);
7327 vseti(VT_LOCAL, c);
7328 gfunc_param(&gf);
7329 vpush_global_sym(&func_old_type, TOK_memset);
7330 gfunc_call(&gf);
7331 }
7332 }
7333
7334 /* 't' contains the type and storage info. 'c' is the offset of the
7335 object in section 'sec'. If 'sec' is NULL, it means stack based
7336 allocation. 'first' is true if array '{' must be read (multi
7337 dimension implicit array init handling). 'size_only' is true if
7338 size only evaluation is wanted (only for arrays). */
7339 static void decl_initializer(CType *type, Section *sec, unsigned long c,
7340 int first, int size_only)
7341 {
7342 int index, array_length, n, no_oblock, nb, parlevel, i;
7343 int size1, align1, expr_type;
7344 Sym *s, *f;
7345 CType *t1;
7346
7347 if (type->t & VT_ARRAY) {
7348 s = type->ref;
7349 n = s->c;
7350 array_length = 0;
7351 t1 = pointed_type(type);
7352 size1 = type_size(t1, &align1);
7353
7354 no_oblock = 1;
7355 if ((first && tok != TOK_LSTR && tok != TOK_STR) ||
7356 tok == '{') {
7357 skip('{');
7358 no_oblock = 0;
7359 }
7360
7361 /* only parse strings here if correct type (otherwise: handle
7362 them as ((w)char *) expressions */
7363 if ((tok == TOK_LSTR &&
7364 (t1->t & VT_BTYPE) == VT_INT) ||
7365 (tok == TOK_STR &&
7366 (t1->t & VT_BTYPE) == VT_BYTE)) {
7367 while (tok == TOK_STR || tok == TOK_LSTR) {
7368 int cstr_len, ch;
7369 CString *cstr;
7370
7371 cstr = tokc.cstr;
7372 /* compute maximum number of chars wanted */
7373 if (tok == TOK_STR)
7374 cstr_len = cstr->size;
7375 else
7376 cstr_len = cstr->size / sizeof(int);
7377 cstr_len--;
7378 nb = cstr_len;
7379 if (n >= 0 && nb > (n - array_length))
7380 nb = n - array_length;
7381 if (!size_only) {
7382 if (cstr_len > nb)
7383 warning("initializer-string for array is too long");
7384 /* in order to go faster for common case (char
7385 string in global variable, we handle it
7386 specifically */
7387 if (sec && tok == TOK_STR && size1 == 1) {
7388 memcpy(sec->data + c + array_length, cstr->data, nb);
7389 } else {
7390 for(i=0;i<nb;i++) {
7391 if (tok == TOK_STR)
7392 ch = ((unsigned char *)cstr->data)[i];
7393 else
7394 ch = ((int *)cstr->data)[i];
7395 init_putv(t1, sec, c + (array_length + i) * size1,
7396 ch, EXPR_VAL);
7397 }
7398 }
7399 }
7400 array_length += nb;
7401 next();
7402 }
7403 /* only add trailing zero if enough storage (no
7404 warning in this case since it is standard) */
7405 if (n < 0 || array_length < n) {
7406 if (!size_only) {
7407 init_putv(t1, sec, c + (array_length * size1), 0, EXPR_VAL);
7408 }
7409 array_length++;
7410 }
7411 } else {
7412 index = 0;
7413 while (tok != '}') {
7414 decl_designator(type, sec, c, &index, NULL, size_only);
7415 if (n >= 0 && index >= n)
7416 error("index too large");
7417 /* must put zero in holes (note that doing it that way
7418 ensures that it even works with designators) */
7419 if (!size_only && array_length < index) {
7420 init_putz(t1, sec, c + array_length * size1,
7421 (index - array_length) * size1);
7422 }
7423 index++;
7424 if (index > array_length)
7425 array_length = index;
7426 /* special test for multi dimensional arrays (may not
7427 be strictly correct if designators are used at the
7428 same time) */
7429 if (index >= n && no_oblock)
7430 break;
7431 if (tok == '}')
7432 break;
7433 skip(',');
7434 }
7435 }
7436 if (!no_oblock)
7437 skip('}');
7438 /* put zeros at the end */
7439 if (!size_only && n >= 0 && array_length < n) {
7440 init_putz(t1, sec, c + array_length * size1,
7441 (n - array_length) * size1);
7442 }
7443 /* patch type size if needed */
7444 if (n < 0)
7445 s->c = array_length;
7446 } else if ((type->t & VT_BTYPE) == VT_STRUCT &&
7447 (sec || !first || tok == '{')) {
7448 /* NOTE: the previous test is a specific case for automatic
7449 struct/union init */
7450 /* XXX: union needs only one init */
7451 /* XXX: handle bit fields */
7452 no_oblock = 1;
7453 if (first || tok == '{') {
7454 skip('{');
7455 no_oblock = 0;
7456 }
7457 s = type->ref;
7458 f = s->next;
7459 array_length = 0;
7460 index = 0;
7461 n = s->c;
7462 while (tok != '}') {
7463 decl_designator(type, sec, c, NULL, &f, size_only);
7464 /* XXX: bitfields ? */
7465 /* fill with zero between fields */
7466 index = f->c;
7467 if (!size_only && array_length < index) {
7468 init_putz(type, sec, c + array_length,
7469 index - array_length);
7470 }
7471 index = index + type_size(&f->type, &align1);
7472 if (index > array_length)
7473 array_length = index;
7474 if (no_oblock && f->next == NULL)
7475 break;
7476 if (tok == '}')
7477 break;
7478 skip(',');
7479 f = f->next;
7480 }
7481 /* put zeros at the end */
7482 if (!size_only && array_length < n) {
7483 init_putz(type, sec, c + array_length,
7484 n - array_length);
7485 }
7486 if (!no_oblock)
7487 skip('}');
7488 } else if (tok == '{') {
7489 next();
7490 decl_initializer(type, sec, c, first, size_only);
7491 skip('}');
7492 } else if (size_only) {
7493 /* just skip expression */
7494 parlevel = 0;
7495 while ((parlevel > 0 || (tok != '}' && tok != ',')) &&
7496 tok != -1) {
7497 if (tok == '(')
7498 parlevel++;
7499 else if (tok == ')')
7500 parlevel--;
7501 next();
7502 }
7503 } else {
7504 /* currently, we always use constant expression for globals
7505 (may change for scripting case) */
7506 expr_type = EXPR_CONST;
7507 if (!sec)
7508 expr_type = EXPR_ANY;
7509 init_putv(type, sec, c, 0, expr_type);
7510 }
7511 }
7512
7513 /* parse an initializer for type 't' if 'has_init' is non zero, and
7514 allocate space in local or global data space ('r' is either
7515 VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
7516 variable 'v' of scope 'scope' is declared before initializers are
7517 parsed. If 'v' is zero, then a reference to the new object is put
7518 in the value stack. If 'has_init' is 2, a special parsing is done
7519 to handle string constants. */
7520 static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
7521 int has_init, int v, int scope)
7522 {
7523 int size, align, addr, data_offset;
7524 int level;
7525 ParseState saved_parse_state;
7526 TokenString init_str;
7527 Section *sec;
7528
7529 size = type_size(type, &align);
7530 /* If unknown size, we must evaluate it before
7531 evaluating initializers because
7532 initializers can generate global data too
7533 (e.g. string pointers or ISOC99 compound
7534 literals). It also simplifies local
7535 initializers handling */
7536 tok_str_new(&init_str);
7537 if (size < 0) {
7538 if (!has_init)
7539 error("unknown type size");
7540 /* get all init string */
7541 if (has_init == 2) {
7542 /* only get strings */
7543 while (tok == TOK_STR || tok == TOK_LSTR) {
7544 tok_str_add_tok(&init_str);
7545 next();
7546 }
7547 } else {
7548 level = 0;
7549 while (level > 0 || (tok != ',' && tok != ';')) {
7550 if (tok < 0)
7551 error("unexpected end of file in initializer");
7552 tok_str_add_tok(&init_str);
7553 if (tok == '{')
7554 level++;
7555 else if (tok == '}') {
7556 if (level == 0)
7557 break;
7558 level--;
7559 }
7560 next();
7561 }
7562 }
7563 tok_str_add(&init_str, -1);
7564 tok_str_add(&init_str, 0);
7565
7566 /* compute size */
7567 save_parse_state(&saved_parse_state);
7568
7569 macro_ptr = init_str.str;
7570 next();
7571 decl_initializer(type, NULL, 0, 1, 1);
7572 /* prepare second initializer parsing */
7573 macro_ptr = init_str.str;
7574 next();
7575
7576 /* if still unknown size, error */
7577 size = type_size(type, &align);
7578 if (size < 0)
7579 error("unknown type size");
7580 }
7581 /* take into account specified alignment if bigger */
7582 if (ad->aligned > align)
7583 align = ad->aligned;
7584 if ((r & VT_VALMASK) == VT_LOCAL) {
7585 sec = NULL;
7586 if (do_bounds_check && (type->t & VT_ARRAY))
7587 loc--;
7588 #ifdef TCC_TARGET_IL
7589 /* XXX: ugly patch to allocate local variables for IL, just
7590 for testing */
7591 addr = loc;
7592 loc++;
7593 #else
7594 loc = (loc - size) & -align;
7595 addr = loc;
7596 #endif
7597 /* handles bounds */
7598 /* XXX: currently, since we do only one pass, we cannot track
7599 '&' operators, so we add only arrays */
7600 if (do_bounds_check && (type->t & VT_ARRAY)) {
7601 unsigned long *bounds_ptr;
7602 /* add padding between regions */
7603 loc--;
7604 /* then add local bound info */
7605 bounds_ptr = section_ptr_add(lbounds_section, 2 * sizeof(unsigned long));
7606 bounds_ptr[0] = addr;
7607 bounds_ptr[1] = size;
7608 }
7609 } else {
7610 /* compute section */
7611 sec = ad->section;
7612 if (!sec) {
7613 if (has_init)
7614 sec = data_section;
7615 else
7616 sec = bss_section;
7617 }
7618 data_offset = sec->data_offset;
7619 data_offset = (data_offset + align - 1) & -align;
7620 addr = data_offset;
7621 /* very important to increment global pointer at this time
7622 because initializers themselves can create new initializers */
7623 data_offset += size;
7624 /* add padding if bound check */
7625 if (do_bounds_check)
7626 data_offset++;
7627 sec->data_offset = data_offset;
7628 /* allocate section space to put the data */
7629 if (sec->sh_type != SHT_NOBITS &&
7630 data_offset > sec->data_allocated)
7631 section_realloc(sec, data_offset);
7632 }
7633 if (!sec) {
7634 if (v) {
7635 /* local variable */
7636 sym_push(v, type, r, addr);
7637 } else {
7638 /* push local reference */
7639 vset(type, r, addr);
7640 }
7641 } else {
7642 Sym *sym;
7643
7644 if (v) {
7645 if (scope == VT_CONST) {
7646 /* global scope: see if already defined */
7647 sym = sym_find(v);
7648 if (!sym)
7649 goto do_def;
7650 if (!is_compatible_types(&sym->type, type))
7651 error("incompatible types for redefinition of '%s'",
7652 get_tok_str(v, NULL));
7653 if (!(sym->type.t & VT_EXTERN))
7654 error("redefinition of '%s'", get_tok_str(v, NULL));
7655 sym->type.t &= ~VT_EXTERN;
7656 } else {
7657 do_def:
7658 sym = sym_push(v, type, r | VT_SYM, 0);
7659 }
7660 put_extern_sym(sym, sec, addr, size);
7661 } else {
7662 CValue cval;
7663
7664 /* push global reference */
7665 sym = get_sym_ref(type, sec, addr, size);
7666 cval.ul = 0;
7667 vsetc(type, VT_CONST | VT_SYM, &cval);
7668 vtop->sym = sym;
7669 }
7670
7671 /* handles bounds now because the symbol must be defined
7672 before for the relocation */
7673 if (do_bounds_check) {
7674 unsigned long *bounds_ptr;
7675
7676 greloc(bounds_section, sym, bounds_section->data_offset, R_DATA_32);
7677 /* then add global bound info */
7678 bounds_ptr = section_ptr_add(bounds_section, 2 * sizeof(long));
7679 bounds_ptr[0] = 0; /* relocated */
7680 bounds_ptr[1] = size;
7681 }
7682 }
7683 if (has_init) {
7684 decl_initializer(type, sec, addr, 1, 0);
7685 /* restore parse state if needed */
7686 if (init_str.str) {
7687 tok_str_free(init_str.str);
7688 restore_parse_state(&saved_parse_state);
7689 }
7690 }
7691 }
7692
7693 void put_func_debug(Sym *sym)
7694 {
7695 char buf[512];
7696
7697 /* stabs info */
7698 /* XXX: we put here a dummy type */
7699 snprintf(buf, sizeof(buf), "%s:%c1",
7700 funcname, sym->type.t & VT_STATIC ? 'f' : 'F');
7701 put_stabs_r(buf, N_FUN, 0, file->line_num, 0,
7702 cur_text_section, sym->c);
7703 last_ind = 0;
7704 last_line_num = 0;
7705 }
7706
7707 /* not finished : try to put some local vars in registers */
7708 //#define CONFIG_REG_VARS
7709
7710 #ifdef CONFIG_REG_VARS
7711 void add_var_ref(int t)
7712 {
7713 printf("%s:%d: &%s\n",
7714 file->filename, file->line_num,
7715 get_tok_str(t, NULL));
7716 }
7717
7718 /* first pass on a function with heuristic to extract variable usage
7719 and pointer references to local variables for register allocation */
7720 void analyse_function(void)
7721 {
7722 int level, t;
7723
7724 for(;;) {
7725 if (tok == -1)
7726 break;
7727 /* any symbol coming after '&' is considered as being a
7728 variable whose reference is taken. It is highly unaccurate
7729 but it is difficult to do better without a complete parse */
7730 if (tok == '&') {
7731 next();
7732 /* if '& number', then no need to examine next tokens */
7733 if (tok == TOK_CINT ||
7734 tok == TOK_CUINT ||
7735 tok == TOK_CLLONG ||
7736 tok == TOK_CULLONG) {
7737 continue;
7738 } else if (tok >= TOK_UIDENT) {
7739 /* if '& ident [' or '& ident ->', then ident address
7740 is not needed */
7741 t = tok;
7742 next();
7743 if (tok != '[' && tok != TOK_ARROW)
7744 add_var_ref(t);
7745 } else {
7746 level = 0;
7747 while (tok != '}' && tok != ';' &&
7748 !((tok == ',' || tok == ')') && level == 0)) {
7749 if (tok >= TOK_UIDENT) {
7750 add_var_ref(tok);
7751 } else if (tok == '(') {
7752 level++;
7753 } else if (tok == ')') {
7754 level--;
7755 }
7756 next();
7757 }
7758 }
7759 } else {
7760 next();
7761 }
7762 }
7763 }
7764 #endif
7765
7766 /* parse an old style function declaration list */
7767 /* XXX: check multiple parameter */
7768 static void func_decl_list(Sym *func_sym)
7769 {
7770 AttributeDef ad;
7771 int v;
7772 Sym *s;
7773 CType btype, type;
7774
7775 /* parse each declaration */
7776 while (tok != '{' && tok != ';' && tok != ',' && tok != TOK_EOF) {
7777 if (!parse_btype(&btype, &ad))
7778 expect("declaration list");
7779 if (((btype.t & VT_BTYPE) == VT_ENUM ||
7780 (btype.t & VT_BTYPE) == VT_STRUCT) &&
7781 tok == ';') {
7782 /* we accept no variable after */
7783 } else {
7784 for(;;) {
7785 type = btype;
7786 type_decl(&type, &ad, &v, TYPE_DIRECT);
7787 /* find parameter in function parameter list */
7788 s = func_sym->next;
7789 while (s != NULL) {
7790 if ((s->v & ~SYM_FIELD) == v)
7791 goto found;
7792 s = s->next;
7793 }
7794 error("declaration for parameter '%s' but no such parameter",
7795 get_tok_str(v, NULL));
7796 found:
7797 /* check that no storage specifier except 'register' was given */
7798 if (type.t & (VT_EXTERN | VT_STATIC | VT_TYPEDEF))
7799 error("storage class specified for '%s'", get_tok_str(v, NULL));
7800 /* we can add the type (NOTE: it could be local to the function) */
7801 s->type = type;
7802 /* accept other parameters */
7803 if (tok == ',')
7804 next();
7805 else
7806 break;
7807 }
7808 }
7809 skip(';');
7810 }
7811 }
7812
7813 /* 'l' is VT_LOCAL or VT_CONST to define default storage type */
7814 static void decl(int l)
7815 {
7816 int v, has_init, r;
7817 CType type, btype;
7818 Sym *sym;
7819 AttributeDef ad;
7820
7821 while (1) {
7822 if (!parse_btype(&btype, &ad)) {
7823 /* skip redundant ';' */
7824 /* XXX: find more elegant solution */
7825 if (tok == ';') {
7826 next();
7827 continue;
7828 }
7829 /* special test for old K&R protos without explicit int
7830 type. Only accepted when defining global data */
7831 if (l == VT_LOCAL || tok < TOK_DEFINE)
7832 break;
7833 btype.t = VT_INT;
7834 }
7835 if (((btype.t & VT_BTYPE) == VT_ENUM ||
7836 (btype.t & VT_BTYPE) == VT_STRUCT) &&
7837 tok == ';') {
7838 /* we accept no variable after */
7839 next();
7840 continue;
7841 }
7842 while (1) { /* iterate thru each declaration */
7843 type = btype;
7844 type_decl(&type, &ad, &v, TYPE_DIRECT);
7845 #if 0
7846 {
7847 char buf[500];
7848 type_to_str(buf, sizeof(buf), t, get_tok_str(v, NULL));
7849 printf("type = '%s'\n", buf);
7850 }
7851 #endif
7852 if ((type.t & VT_BTYPE) == VT_FUNC) {
7853 /* if old style function prototype, we accept a
7854 declaration list */
7855 sym = type.ref;
7856 if (sym->c == FUNC_OLD)
7857 func_decl_list(sym);
7858 }
7859
7860 if (tok == '{') {
7861 #ifdef CONFIG_REG_VARS
7862 TokenString func_str;
7863 ParseState saved_parse_state;
7864 int block_level;
7865 #endif
7866
7867 if (l == VT_LOCAL)
7868 error("cannot use local functions");
7869 if (!(type.t & VT_FUNC))
7870 expect("function definition");
7871
7872 #ifdef CONFIG_REG_VARS
7873 /* parse all function code and record it */
7874
7875 tok_str_new(&func_str);
7876
7877 block_level = 0;
7878 for(;;) {
7879 int t;
7880 if (tok == -1)
7881 error("unexpected end of file");
7882 tok_str_add_tok(&func_str);
7883 t = tok;
7884 next();
7885 if (t == '{') {
7886 block_level++;
7887 } else if (t == '}') {
7888 block_level--;
7889 if (block_level == 0)
7890 break;
7891 }
7892 }
7893 tok_str_add(&func_str, -1);
7894 tok_str_add(&func_str, 0);
7895
7896 save_parse_state(&saved_parse_state);
7897
7898 macro_ptr = func_str.str;
7899 next();
7900 analyse_function();
7901 #endif
7902
7903 /* compute text section */
7904 cur_text_section = ad.section;
7905 if (!cur_text_section)
7906 cur_text_section = text_section;
7907 ind = cur_text_section->data_offset;
7908 funcname = get_tok_str(v, NULL);
7909 sym = sym_find(v);
7910 if (sym) {
7911 /* if symbol is already defined, then put complete type */
7912 sym->type = type;
7913 } else {
7914 /* put function symbol */
7915 sym = global_identifier_push(v, type.t, 0);
7916 sym->type.ref = type.ref;
7917 }
7918 /* NOTE: we patch the symbol size later */
7919 put_extern_sym(sym, cur_text_section, ind, 0);
7920 func_ind = ind;
7921 sym->r = VT_SYM | VT_CONST;
7922 /* put debug symbol */
7923 if (do_debug)
7924 put_func_debug(sym);
7925 /* push a dummy symbol to enable local sym storage */
7926 sym_push2(&local_stack, SYM_FIELD, 0, 0);
7927 gfunc_prolog(&type);
7928 loc = 0;
7929 rsym = 0;
7930 #ifdef CONFIG_REG_VARS
7931 macro_ptr = func_str.str;
7932 next();
7933 #endif
7934 block(NULL, NULL, NULL, NULL, 0);
7935 gsym(rsym);
7936 gfunc_epilog();
7937 cur_text_section->data_offset = ind;
7938 /* look if any labels are undefined. Define symbols if
7939 '&&label' was used. */
7940 {
7941 Sym *s, *s1;
7942 for(s = label_stack; s != NULL; s = s1) {
7943 s1 = s->prev;
7944 if (s->r & LABEL_FORWARD) {
7945 error("label '%s' used but not defined",
7946 get_tok_str(s->v, NULL));
7947 }
7948 if (s->c) {
7949 /* define corresponding symbol. A size of
7950 1 is put. */
7951 put_extern_sym(s, cur_text_section, (long)s->next, 1);
7952 }
7953 /* remove label */
7954 table_ident[s->v - TOK_IDENT]->sym_label = NULL;
7955 tcc_free(s);
7956 }
7957 label_stack = NULL;
7958 }
7959 sym_pop(&local_stack, NULL); /* reset local stack */
7960 /* end of function */
7961 /* patch symbol size */
7962 ((Elf32_Sym *)symtab_section->data)[sym->c].st_size =
7963 ind - func_ind;
7964 if (do_debug) {
7965 put_stabn(N_FUN, 0, 0, ind - func_ind);
7966 }
7967 funcname = ""; /* for safety */
7968 func_vt.t = VT_VOID; /* for safety */
7969 ind = 0; /* for safety */
7970
7971 #ifdef CONFIG_REG_VARS
7972 tok_str_free(func_str.str);
7973 restore_parse_state(&saved_parse_state);
7974 #endif
7975 break;
7976 } else {
7977 if (btype.t & VT_TYPEDEF) {
7978 /* save typedefed type */
7979 /* XXX: test storage specifiers ? */
7980 sym = sym_push(v, &type, 0, 0);
7981 sym->type.t |= VT_TYPEDEF;
7982 } else if ((type.t & VT_BTYPE) == VT_FUNC) {
7983 /* external function definition */
7984 external_sym(v, &type, 0);
7985 } else {
7986 /* not lvalue if array */
7987 r = 0;
7988 if (!(type.t & VT_ARRAY))
7989 r |= lvalue_type(type.t);
7990 if (btype.t & VT_EXTERN) {
7991 /* external variable */
7992 external_sym(v, &type, r);
7993 } else {
7994 if (type.t & VT_STATIC)
7995 r |= VT_CONST;
7996 else
7997 r |= l;
7998 has_init = (tok == '=');
7999 if (has_init)
8000 next();
8001 decl_initializer_alloc(&type, &ad, r,
8002 has_init, v, l);
8003 }
8004 }
8005 if (tok != ',') {
8006 skip(';');
8007 break;
8008 }
8009 next();
8010 }
8011 }
8012 }
8013 }
8014
8015 /* compile the C file opened in 'file'. Return non zero if errors. */
8016 static int tcc_compile(TCCState *s1)
8017 {
8018 Sym *define_start;
8019 char buf[512];
8020 volatile int section_sym;
8021
8022 #ifdef INC_DEBUG
8023 printf("%s: **** new file\n", file->filename);
8024 #endif
8025 funcname = "";
8026 s1->include_stack_ptr = s1->include_stack;
8027 /* XXX: move that before to avoid having to initialize
8028 file->ifdef_stack_ptr ? */
8029 s1->ifdef_stack_ptr = s1->ifdef_stack;
8030 file->ifdef_stack_ptr = s1->ifdef_stack_ptr;
8031
8032 /* XXX: not ANSI compliant: bound checking says error */
8033 vtop = vstack - 1;
8034 anon_sym = SYM_FIRST_ANOM;
8035
8036 /* file info: full path + filename */
8037 section_sym = 0; /* avoid warning */
8038 if (do_debug) {
8039 section_sym = put_elf_sym(symtab_section, 0, 0,
8040 ELF32_ST_INFO(STB_LOCAL, STT_SECTION), 0,
8041 text_section->sh_num, NULL);
8042 getcwd(buf, sizeof(buf));
8043 pstrcat(buf, sizeof(buf), "/");
8044 put_stabs_r(buf, N_SO, 0, 0,
8045 text_section->data_offset, text_section, section_sym);
8046 put_stabs_r(file->filename, N_SO, 0, 0,
8047 text_section->data_offset, text_section, section_sym);
8048 }
8049 /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
8050 symbols can be safely used */
8051 put_elf_sym(symtab_section, 0, 0,
8052 ELF32_ST_INFO(STB_LOCAL, STT_FILE), 0,
8053 SHN_ABS, file->filename);
8054
8055 /* define some often used types */
8056 int_type.t = VT_INT;
8057
8058 char_pointer_type.t = VT_BYTE;
8059 mk_pointer(&char_pointer_type);
8060
8061 func_old_type.t = VT_FUNC;
8062 func_old_type.ref = sym_push(SYM_FIELD, &int_type, FUNC_CDECL, FUNC_OLD);
8063
8064 #if 0
8065 /* define 'void *alloca(unsigned int)' builtin function */
8066 {
8067 Sym *s1;
8068
8069 p = anon_sym++;
8070 sym = sym_push(p, mk_pointer(VT_VOID), FUNC_CDECL, FUNC_NEW);
8071 s1 = sym_push(SYM_FIELD, VT_UNSIGNED | VT_INT, 0, 0);
8072 s1->next = NULL;
8073 sym->next = s1;
8074 sym_push(TOK_alloca, VT_FUNC | (p << VT_STRUCT_SHIFT), VT_CONST, 0);
8075 }
8076 #endif
8077
8078 define_start = define_stack;
8079
8080 if (setjmp(s1->error_jmp_buf) == 0) {
8081 s1->nb_errors = 0;
8082 s1->error_set_jmp_enabled = 1;
8083
8084 ch = file->buf_ptr[0];
8085 tok_flags = TOK_FLAG_BOL | TOK_FLAG_BOF;
8086 next();
8087 decl(VT_CONST);
8088 if (tok != -1)
8089 expect("declaration");
8090
8091 /* end of translation unit info */
8092 if (do_debug) {
8093 put_stabs_r(NULL, N_SO, 0, 0,
8094 text_section->data_offset, text_section, section_sym);
8095 }
8096 }
8097 s1->error_set_jmp_enabled = 0;
8098
8099 /* reset define stack, but leave -Dsymbols (may be incorrect if
8100 they are undefined) */
8101 free_defines(define_start);
8102
8103 sym_pop(&global_stack, NULL);
8104
8105 return s1->nb_errors != 0 ? -1 : 0;
8106 }
8107
8108 #ifdef LIBTCC
8109 int tcc_compile_string(TCCState *s, const char *str)
8110 {
8111 BufferedFile bf1, *bf = &bf1;
8112 int ret, len;
8113 char *buf;
8114
8115 /* init file structure */
8116 bf->fd = -1;
8117 /* XXX: avoid copying */
8118 len = strlen(str);
8119 buf = tcc_malloc(len + 1);
8120 if (!buf)
8121 return -1;
8122 buf[len] = CH_EOB;
8123 bf->buf_ptr = buf;
8124 bf->buf_end = buf + len;
8125 pstrcpy(bf->filename, sizeof(bf->filename), "<string>");
8126 bf->line_num = 1;
8127 file = bf;
8128
8129 ret = tcc_compile(s);
8130
8131 tcc_free(buf);
8132
8133 /* currently, no need to close */
8134 return ret;
8135 }
8136 #endif
8137
8138 /* define a preprocessor symbol. A value can also be provided with the '=' operator */
8139 void tcc_define_symbol(TCCState *s1, const char *sym, const char *value)
8140 {
8141 BufferedFile bf1, *bf = &bf1;
8142
8143 pstrcpy(bf->buffer, IO_BUF_SIZE, sym);
8144 pstrcat(bf->buffer, IO_BUF_SIZE, " ");
8145 /* default value */
8146 if (!value)
8147 value = "1";
8148 pstrcat(bf->buffer, IO_BUF_SIZE, value);
8149
8150 /* init file structure */
8151 bf->fd = -1;
8152 bf->buf_ptr = bf->buffer;
8153 bf->buf_end = bf->buffer + strlen(bf->buffer);
8154 *bf->buf_end = CH_EOB;
8155 bf->filename[0] = '\0';
8156 bf->line_num = 1;
8157 file = bf;
8158
8159 s1->include_stack_ptr = s1->include_stack;
8160
8161 /* parse with define parser */
8162 ch = file->buf_ptr[0];
8163 next_nomacro();
8164 parse_define();
8165 file = NULL;
8166 }
8167
8168 /* undefine a preprocessor symbol */
8169 void tcc_undefine_symbol(TCCState *s1, const char *sym)
8170 {
8171 TokenSym *ts;
8172 Sym *s;
8173 ts = tok_alloc(sym, strlen(sym));
8174 s = define_find(ts->tok);
8175 /* undefine symbol by putting an invalid name */
8176 if (s)
8177 define_undef(s);
8178 }
8179
8180 #include "tccelf.c"
8181
8182 /* print the position in the source file of PC value 'pc' by reading
8183 the stabs debug information */
8184 static void rt_printline(unsigned long wanted_pc)
8185 {
8186 Stab_Sym *sym, *sym_end;
8187 char func_name[128], last_func_name[128];
8188 unsigned long func_addr, last_pc, pc;
8189 const char *incl_files[INCLUDE_STACK_SIZE];
8190 int incl_index, len, last_line_num, i;
8191 const char *str, *p;
8192
8193 fprintf(stderr, "0x%08lx:", wanted_pc);
8194
8195 func_name[0] = '\0';
8196 func_addr = 0;
8197 incl_index = 0;
8198 last_func_name[0] = '\0';
8199 last_pc = 0xffffffff;
8200 last_line_num = 1;
8201 sym = (Stab_Sym *)stab_section->data + 1;
8202 sym_end = (Stab_Sym *)(stab_section->data + stab_section->data_offset);
8203 while (sym < sym_end) {
8204 switch(sym->n_type) {
8205 /* function start or end */
8206 case N_FUN:
8207 if (sym->n_strx == 0) {
8208 /* we test if between last line and end of function */
8209 pc = sym->n_value + func_addr;
8210 if (wanted_pc >= last_pc && wanted_pc < pc)
8211 goto found;
8212 func_name[0] = '\0';
8213 func_addr = 0;
8214 } else {
8215 str = stabstr_section->data + sym->n_strx;
8216 p = strchr(str, ':');
8217 if (!p) {
8218 pstrcpy(func_name, sizeof(func_name), str);
8219 } else {
8220 len = p - str;
8221 if (len > sizeof(func_name) - 1)
8222 len = sizeof(func_name) - 1;
8223 memcpy(func_name, str, len);
8224 func_name[len] = '\0';
8225 }
8226 func_addr = sym->n_value;
8227 }
8228 break;
8229 /* line number info */
8230 case N_SLINE:
8231 pc = sym->n_value + func_addr;
8232 if (wanted_pc >= last_pc && wanted_pc < pc)
8233 goto found;
8234 last_pc = pc;
8235 last_line_num = sym->n_desc;
8236 /* XXX: slow! */
8237 strcpy(last_func_name, func_name);
8238 break;
8239 /* include files */
8240 case N_BINCL:
8241 str = stabstr_section->data + sym->n_strx;
8242 add_incl:
8243 if (incl_index < INCLUDE_STACK_SIZE) {
8244 incl_files[incl_index++] = str;
8245 }
8246 break;
8247 case N_EINCL:
8248 if (incl_index > 1)
8249 incl_index--;
8250 break;
8251 case N_SO:
8252 if (sym->n_strx == 0) {
8253 incl_index = 0; /* end of translation unit */
8254 } else {
8255 str = stabstr_section->data + sym->n_strx;
8256 /* do not add path */
8257 len = strlen(str);
8258 if (len > 0 && str[len - 1] != '/')
8259 goto add_incl;
8260 }
8261 break;
8262 }
8263 sym++;
8264 }
8265
8266 /* second pass: we try symtab symbols (no line number info) */
8267 incl_index = 0;
8268 {
8269 Elf32_Sym *sym, *sym_end;
8270 int type;
8271
8272 sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset);
8273 for(sym = (Elf32_Sym *)symtab_section->data + 1;
8274 sym < sym_end;
8275 sym++) {
8276 type = ELF32_ST_TYPE(sym->st_info);
8277 if (type == STT_FUNC) {
8278 if (wanted_pc >= sym->st_value &&
8279 wanted_pc < sym->st_value + sym->st_size) {
8280 pstrcpy(last_func_name, sizeof(last_func_name),
8281 strtab_section->data + sym->st_name);
8282 goto found;
8283 }
8284 }
8285 }
8286 }
8287 /* did not find any info: */
8288 fprintf(stderr, " ???\n");
8289 return;
8290 found:
8291 if (last_func_name[0] != '\0') {
8292 fprintf(stderr, " %s()", last_func_name);
8293 }
8294 if (incl_index > 0) {
8295 fprintf(stderr, " (%s:%d",
8296 incl_files[incl_index - 1], last_line_num);
8297 for(i = incl_index - 2; i >= 0; i--)
8298 fprintf(stderr, ", included from %s", incl_files[i]);
8299 fprintf(stderr, ")");
8300 }
8301 fprintf(stderr, "\n");
8302 }
8303
8304 #ifndef WIN32
8305
8306 #ifdef __i386__
8307
8308 #ifndef EIP
8309 #define EIP 14
8310 #define EBP 6
8311 #endif
8312
8313 /* return the PC at frame level 'level'. Return non zero if not found */
8314 static int rt_get_caller_pc(unsigned long *paddr,
8315 struct ucontext *uc, int level)
8316 {
8317 unsigned long fp;
8318 int i;
8319
8320 if (level == 0) {
8321 *paddr = uc->uc_mcontext.gregs[EIP];
8322 return 0;
8323 } else {
8324 fp = uc->uc_mcontext.gregs[EBP];
8325 for(i=1;i<level;i++) {
8326 /* XXX: check address validity with program info */
8327 if (fp <= 0x1000 || fp >= 0xc0000000)
8328 return -1;
8329 fp = ((unsigned long *)fp)[0];
8330 }
8331 *paddr = ((unsigned long *)fp)[1];
8332 return 0;
8333 }
8334 }
8335 #else
8336 #error add arch specific rt_get_caller_pc()
8337 #endif
8338
8339 /* emit a run time error at position 'pc' */
8340 void rt_error(struct ucontext *uc, const char *fmt, ...)
8341 {
8342 va_list ap;
8343 unsigned long pc;
8344 int i;
8345
8346 va_start(ap, fmt);
8347 fprintf(stderr, "Runtime error: ");
8348 vfprintf(stderr, fmt, ap);
8349 fprintf(stderr, "\n");
8350 for(i=0;i<num_callers;i++) {
8351 if (rt_get_caller_pc(&pc, uc, i) < 0)
8352 break;
8353 if (i == 0)
8354 fprintf(stderr, "at ");
8355 else
8356 fprintf(stderr, "by ");
8357 rt_printline(pc);
8358 }
8359 exit(255);
8360 va_end(ap);
8361 }
8362
8363 /* signal handler for fatal errors */
8364 static void sig_error(int signum, siginfo_t *siginf, void *puc)
8365 {
8366 struct ucontext *uc = puc;
8367
8368 switch(signum) {
8369 case SIGFPE:
8370 switch(siginf->si_code) {
8371 case FPE_INTDIV:
8372 case FPE_FLTDIV:
8373 rt_error(uc, "division by zero");
8374 break;
8375 default:
8376 rt_error(uc, "floating point exception");
8377 break;
8378 }
8379 break;
8380 case SIGBUS:
8381 case SIGSEGV:
8382 if (rt_bound_error_msg && *rt_bound_error_msg)
8383 rt_error(uc, *rt_bound_error_msg);
8384 else
8385 rt_error(uc, "dereferencing invalid pointer");
8386 break;
8387 case SIGILL:
8388 rt_error(uc, "illegal instruction");
8389 break;
8390 case SIGABRT:
8391 rt_error(uc, "abort() called");
8392 break;
8393 default:
8394 rt_error(uc, "caught signal %d", signum);
8395 break;
8396 }
8397 exit(255);
8398 }
8399 #endif
8400
8401 /* do all relocations (needed before using tcc_get_symbol()) */
8402 int tcc_relocate(TCCState *s1)
8403 {
8404 Section *s;
8405 int i;
8406
8407 s1->nb_errors = 0;
8408
8409 tcc_add_runtime(s1);
8410
8411 relocate_common_syms();
8412
8413 /* compute relocation address : section are relocated in place. We
8414 also alloc the bss space */
8415 for(i = 1; i < s1->nb_sections; i++) {
8416 s = s1->sections[i];
8417 if (s->sh_flags & SHF_ALLOC) {
8418 if (s->sh_type == SHT_NOBITS)
8419 s->data = tcc_mallocz(s->data_offset);
8420 s->sh_addr = (unsigned long)s->data;
8421 }
8422 }
8423
8424 relocate_syms(s1, 1);
8425
8426 if (s1->nb_errors != 0)
8427 return -1;
8428
8429 /* relocate each section */
8430 for(i = 1; i < s1->nb_sections; i++) {
8431 s = s1->sections[i];
8432 if (s->reloc)
8433 relocate_section(s1, s);
8434 }
8435 return 0;
8436 }
8437
8438 /* launch the compiled program with the given arguments */
8439 int tcc_run(TCCState *s1, int argc, char **argv)
8440 {
8441 int (*prog_main)(int, char **);
8442
8443 if (tcc_relocate(s1) < 0)
8444 return -1;
8445
8446 prog_main = tcc_get_symbol(s1, "main");
8447
8448 if (do_debug) {
8449 #ifdef WIN32
8450 error("debug mode currently not available for Windows");
8451 #else
8452 struct sigaction sigact;
8453 /* install TCC signal handlers to print debug info on fatal
8454 runtime errors */
8455 sigact.sa_flags = SA_SIGINFO | SA_ONESHOT;
8456 sigact.sa_sigaction = sig_error;
8457 sigemptyset(&sigact.sa_mask);
8458 sigaction(SIGFPE, &sigact, NULL);
8459 sigaction(SIGILL, &sigact, NULL);
8460 sigaction(SIGSEGV, &sigact, NULL);
8461 sigaction(SIGBUS, &sigact, NULL);
8462 sigaction(SIGABRT, &sigact, NULL);
8463 #endif
8464 }
8465
8466 #ifdef CONFIG_TCC_BCHECK
8467 if (do_bounds_check) {
8468 void (*bound_init)(void);
8469
8470 /* set error function */
8471 rt_bound_error_msg = (void *)tcc_get_symbol(s1, "__bound_error_msg");
8472
8473 /* XXX: use .init section so that it also work in binary ? */
8474 bound_init = (void *)tcc_get_symbol(s1, "__bound_init");
8475 bound_init();
8476 }
8477 #endif
8478 return (*prog_main)(argc, argv);
8479 }
8480
8481 TCCState *tcc_new(void)
8482 {
8483 const char *p, *r;
8484 TCCState *s;
8485
8486 s = tcc_mallocz(sizeof(TCCState));
8487 if (!s)
8488 return NULL;
8489 tcc_state = s;
8490 s->output_type = TCC_OUTPUT_MEMORY;
8491
8492 /* default include paths */
8493 tcc_add_sysinclude_path(s, "/usr/local/include");
8494 tcc_add_sysinclude_path(s, "/usr/include");
8495 tcc_add_sysinclude_path(s, CONFIG_TCC_PREFIX "/lib/tcc/include");
8496
8497 /* add all tokens */
8498 table_ident = NULL;
8499 memset(hash_ident, 0, TOK_HASH_SIZE * sizeof(TokenSym *));
8500
8501 tok_ident = TOK_IDENT;
8502 p = tcc_keywords;
8503 while (*p) {
8504 r = p;
8505 while (*r++);
8506 tok_alloc(p, r - p - 1);
8507 p = r;
8508 }
8509
8510 /* we add dummy defines for some special macros to speed up tests
8511 and to have working defined() */
8512 define_push(TOK___LINE__, MACRO_OBJ, NULL, NULL);
8513 define_push(TOK___FILE__, MACRO_OBJ, NULL, NULL);
8514 define_push(TOK___DATE__, MACRO_OBJ, NULL, NULL);
8515 define_push(TOK___TIME__, MACRO_OBJ, NULL, NULL);
8516
8517 /* standard defines */
8518 tcc_define_symbol(s, "__STDC__", NULL);
8519 #if defined(TCC_TARGET_I386)
8520 tcc_define_symbol(s, "__i386__", NULL);
8521 #endif
8522 #if defined(linux)
8523 tcc_define_symbol(s, "linux", NULL);
8524 #endif
8525 /* tiny C specific defines */
8526 tcc_define_symbol(s, "__TINYC__", NULL);
8527
8528 /* tiny C & gcc defines */
8529 tcc_define_symbol(s, "__SIZE_TYPE__", "unsigned int");
8530 tcc_define_symbol(s, "__PTRDIFF_TYPE__", "int");
8531 tcc_define_symbol(s, "__WCHAR_TYPE__", "int");
8532
8533 /* default library paths */
8534 tcc_add_library_path(s, "/usr/local/lib");
8535 tcc_add_library_path(s, "/usr/lib");
8536 tcc_add_library_path(s, "/lib");
8537
8538 /* no section zero */
8539 dynarray_add((void ***)&s->sections, &s->nb_sections, NULL);
8540
8541 /* create standard sections */
8542 text_section = new_section(s, ".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR);
8543 data_section = new_section(s, ".data", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
8544 bss_section = new_section(s, ".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
8545
8546 /* symbols are always generated for linking stage */
8547 symtab_section = new_symtab(s, ".symtab", SHT_SYMTAB, 0,
8548 ".strtab",
8549 ".hashtab", SHF_PRIVATE);
8550 strtab_section = symtab_section->link;
8551
8552 /* private symbol table for dynamic symbols */
8553 s->dynsymtab_section = new_symtab(s, ".dynsymtab", SHT_SYMTAB, SHF_PRIVATE,
8554 ".dynstrtab",
8555 ".dynhashtab", SHF_PRIVATE);
8556 return s;
8557 }
8558
8559 void tcc_delete(TCCState *s1)
8560 {
8561 int i, n;
8562
8563 /* free -D defines */
8564 free_defines(NULL);
8565
8566 /* free tokens */
8567 n = tok_ident - TOK_IDENT;
8568 for(i = 0; i < n; i++)
8569 tcc_free(table_ident[i]);
8570 tcc_free(table_ident);
8571
8572 /* free all sections */
8573
8574 free_section(symtab_section->hash);
8575
8576 free_section(s1->dynsymtab_section->hash);
8577 free_section(s1->dynsymtab_section->link);
8578 free_section(s1->dynsymtab_section);
8579
8580 for(i = 1; i < s1->nb_sections; i++)
8581 free_section(s1->sections[i]);
8582 tcc_free(s1->sections);
8583
8584 /* free loaded dlls array */
8585 for(i = 0; i < s1->nb_loaded_dlls; i++)
8586 tcc_free(s1->loaded_dlls[i]);
8587 tcc_free(s1->loaded_dlls);
8588
8589 /* library paths */
8590 for(i = 0; i < s1->nb_library_paths; i++)
8591 tcc_free(s1->library_paths[i]);
8592 tcc_free(s1->library_paths);
8593
8594 /* cached includes */
8595 for(i = 0; i < s1->nb_cached_includes; i++)
8596 tcc_free(s1->cached_includes[i]);
8597 tcc_free(s1->cached_includes);
8598
8599 for(i = 0; i < s1->nb_include_paths; i++)
8600 tcc_free(s1->include_paths[i]);
8601 tcc_free(s1->include_paths);
8602
8603 for(i = 0; i < s1->nb_sysinclude_paths; i++)
8604 tcc_free(s1->sysinclude_paths[i]);
8605 tcc_free(s1->sysinclude_paths);
8606
8607 tcc_free(s1);
8608 }
8609
8610 int tcc_add_include_path(TCCState *s1, const char *pathname)
8611 {
8612 char *pathname1;
8613
8614 pathname1 = tcc_strdup(pathname);
8615 dynarray_add((void ***)&s1->include_paths, &s1->nb_include_paths, pathname1);
8616 return 0;
8617 }
8618
8619 int tcc_add_sysinclude_path(TCCState *s1, const char *pathname)
8620 {
8621 char *pathname1;
8622
8623 pathname1 = tcc_strdup(pathname);
8624 dynarray_add((void ***)&s1->sysinclude_paths, &s1->nb_sysinclude_paths, pathname1);
8625 return 0;
8626 }
8627
8628 static int tcc_add_file_internal(TCCState *s1, const char *filename, int flags)
8629 {
8630 const char *ext;
8631 Elf32_Ehdr ehdr;
8632 int fd, ret;
8633 BufferedFile *saved_file;
8634
8635 /* find source file type with extension */
8636 ext = strrchr(filename, '.');
8637 if (ext)
8638 ext++;
8639
8640 /* open the file */
8641 saved_file = file;
8642 file = tcc_open(s1, filename);
8643 if (!file) {
8644 if (flags & AFF_PRINT_ERROR) {
8645 error_noabort("file '%s' not found", filename);
8646 }
8647 ret = -1;
8648 goto fail1;
8649 }
8650
8651 if (!ext || !strcmp(ext, "c")) {
8652 /* C file assumed */
8653 ret = tcc_compile(s1);
8654 } else {
8655 fd = file->fd;
8656 /* assume executable format: auto guess file type */
8657 if (read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr)) {
8658 error_noabort("could not read header");
8659 goto fail;
8660 }
8661 lseek(fd, 0, SEEK_SET);
8662
8663 if (ehdr.e_ident[0] == ELFMAG0 &&
8664 ehdr.e_ident[1] == ELFMAG1 &&
8665 ehdr.e_ident[2] == ELFMAG2 &&
8666 ehdr.e_ident[3] == ELFMAG3) {
8667 file->line_num = 0; /* do not display line number if error */
8668 if (ehdr.e_type == ET_REL) {
8669 ret = tcc_load_object_file(s1, fd, 0);
8670 } else if (ehdr.e_type == ET_DYN) {
8671 ret = tcc_load_dll(s1, fd, filename,
8672 (flags & AFF_REFERENCED_DLL) != 0);
8673 } else {
8674 error_noabort("unrecognized ELF file");
8675 goto fail;
8676 }
8677 } else if (memcmp((char *)&ehdr, ARMAG, 8) == 0) {
8678 file->line_num = 0; /* do not display line number if error */
8679 ret = tcc_load_archive(s1, fd);
8680 } else {
8681 /* as GNU ld, consider it is an ld script if not recognized */
8682 ret = tcc_load_ldscript(s1);
8683 if (ret < 0) {
8684 error_noabort("unrecognized file type");
8685 goto fail;
8686 }
8687 }
8688 }
8689 the_end:
8690 tcc_close(file);
8691 fail1:
8692 file = saved_file;
8693 return ret;
8694 fail:
8695 ret = -1;
8696 goto the_end;
8697 }
8698
8699 int tcc_add_file(TCCState *s, const char *filename)
8700 {
8701 return tcc_add_file_internal(s, filename, AFF_PRINT_ERROR);
8702 }
8703
8704 int tcc_add_library_path(TCCState *s, const char *pathname)
8705 {
8706 char *pathname1;
8707
8708 pathname1 = tcc_strdup(pathname);
8709 dynarray_add((void ***)&s->library_paths, &s->nb_library_paths, pathname1);
8710 return 0;
8711 }
8712
8713 /* find and load a dll. Return non zero if not found */
8714 /* XXX: add '-rpath' option support ? */
8715 static int tcc_add_dll(TCCState *s, const char *filename, int flags)
8716 {
8717 char buf[1024];
8718 int i;
8719
8720 for(i = 0; i < s->nb_library_paths; i++) {
8721 snprintf(buf, sizeof(buf), "%s/%s",
8722 s->library_paths[i], filename);
8723 if (tcc_add_file_internal(s, buf, flags) == 0)
8724 return 0;
8725 }
8726 return -1;
8727 }
8728
8729 /* the library name is the same as the argument of the '-l' option */
8730 int tcc_add_library(TCCState *s, const char *libraryname)
8731 {
8732 char buf[1024];
8733 int i;
8734 void *h;
8735
8736 /* first we look for the dynamic library if not static linking */
8737 if (!s->static_link) {
8738 snprintf(buf, sizeof(buf), "lib%s.so", libraryname);
8739 /* if we output to memory, then we simply we dlopen(). */
8740 if (s->output_type == TCC_OUTPUT_MEMORY) {
8741 /* Since the libc is already loaded, we don't need to load it again */
8742 if (!strcmp(libraryname, "c"))
8743 return 0;
8744 h = dlopen(buf, RTLD_GLOBAL | RTLD_LAZY);
8745 if (h)
8746 return 0;
8747 } else {
8748 if (tcc_add_dll(s, buf, 0) == 0)
8749 return 0;
8750 }
8751 }
8752
8753 /* then we look for the static library */
8754 for(i = 0; i < s->nb_library_paths; i++) {
8755 snprintf(buf, sizeof(buf), "%s/lib%s.a",
8756 s->library_paths[i], libraryname);
8757 if (tcc_add_file_internal(s, buf, 0) == 0)
8758 return 0;
8759 }
8760 return -1;
8761 }
8762
8763 int tcc_add_symbol(TCCState *s, const char *name, unsigned long val)
8764 {
8765 add_elf_sym(symtab_section, val, 0,
8766 ELF32_ST_INFO(STB_GLOBAL, STT_NOTYPE),
8767 SHN_ABS, name);
8768 return 0;
8769 }
8770
8771 int tcc_set_output_type(TCCState *s, int output_type)
8772 {
8773 s->output_type = output_type;
8774
8775 /* if bound checking, then add corresponding sections */
8776 #ifdef CONFIG_TCC_BCHECK
8777 if (do_bounds_check) {
8778 /* define symbol */
8779 tcc_define_symbol(s, "__BOUNDS_CHECKING_ON", NULL);
8780 /* create bounds sections */
8781 bounds_section = new_section(s, ".bounds",
8782 SHT_PROGBITS, SHF_ALLOC);
8783 lbounds_section = new_section(s, ".lbounds",
8784 SHT_PROGBITS, SHF_ALLOC);
8785 }
8786 #endif
8787
8788 /* add debug sections */
8789 if (do_debug) {
8790 /* stab symbols */
8791 stab_section = new_section(s, ".stab", SHT_PROGBITS, 0);
8792 stab_section->sh_entsize = sizeof(Stab_Sym);
8793 stabstr_section = new_section(s, ".stabstr", SHT_STRTAB, 0);
8794 put_elf_str(stabstr_section, "");
8795 stab_section->link = stabstr_section;
8796 /* put first entry */
8797 put_stabs("", 0, 0, 0, 0);
8798 }
8799
8800 /* add libc crt1/crti objects */
8801 if (output_type == TCC_OUTPUT_EXE ||
8802 output_type == TCC_OUTPUT_DLL) {
8803 if (output_type != TCC_OUTPUT_DLL)
8804 tcc_add_file(s, CONFIG_TCC_CRT_PREFIX "/crt1.o");
8805 tcc_add_file(s, CONFIG_TCC_CRT_PREFIX "/crti.o");
8806 }
8807 return 0;
8808 }
8809
8810 #if !defined(LIBTCC)
8811
8812 static int64_t getclock_us(void)
8813 {
8814 #ifdef WIN32
8815 struct _timeb tb;
8816 _ftime(&tb);
8817 return (tb.time * 1000LL + tb.millitm) * 1000LL;
8818 #else
8819 struct timeval tv;
8820 gettimeofday(&tv, NULL);
8821 return tv.tv_sec * 1000000LL + tv.tv_usec;
8822 #endif
8823 }
8824
8825 void help(void)
8826 {
8827 printf("tcc version 0.9.13 - Tiny C Compiler - Copyright (C) 2001, 2002 Fabrice Bellard\n"
8828 "usage: tcc [-c] [-o outfile] [-Bdir] [-bench] [-Idir] [-Dsym[=val]] [-Usym]\n"
8829 " [-g] [-b] [-bt N] [-Ldir] [-llib] [-shared] [-static]\n"
8830 " [--] infile1 [infile2... --] [infile_args...]\n"
8831 "\n"
8832 "General options:\n"
8833 " -c compile only - generate an object file\n"
8834 " -o outfile set output filename\n"
8835 " -- allows multiples input files if no -o option given. Also\n"
8836 " separate input files from runtime arguments\n"
8837 " -Bdir set tcc internal library path\n"
8838 " -bench output compilation statistics\n"
8839 "Preprocessor options:\n"
8840 " -Idir add include path 'dir'\n"
8841 " -Dsym[=val] define 'sym' with value 'val'\n"
8842 " -Usym undefine 'sym'\n"
8843 "Linker options:\n"
8844 " -Ldir add library path 'dir'\n"
8845 " -llib link with dynamic or static library 'lib'\n"
8846 " -shared generate a shared library\n"
8847 " -static static linking\n"
8848 " -r relocatable output\n"
8849 "Debugger options:\n"
8850 " -g generate runtime debug info\n"
8851 #ifdef CONFIG_TCC_BCHECK
8852 " -b compile with built-in memory and bounds checker (implies -g)\n"
8853 #endif
8854 " -bt N show N callers in stack traces\n"
8855 );
8856 }
8857
8858 int main(int argc, char **argv)
8859 {
8860 char *r, *outfile;
8861 int optind, output_type, multiple_files, i, reloc_output;
8862 TCCState *s;
8863 char **files;
8864 int nb_files, nb_libraries, nb_objfiles, dminus, ret;
8865 char objfilename[1024];
8866 int64_t start_time = 0;
8867
8868 s = tcc_new();
8869 output_type = TCC_OUTPUT_MEMORY;
8870
8871 optind = 1;
8872 outfile = NULL;
8873 multiple_files = 0;
8874 dminus = 0;
8875 files = NULL;
8876 nb_files = 0;
8877 nb_libraries = 0;
8878 reloc_output = 0;
8879 while (1) {
8880 if (optind >= argc) {
8881 if (nb_files == 0)
8882 goto show_help;
8883 else
8884 break;
8885 }
8886 r = argv[optind++];
8887 if (r[0] != '-') {
8888 /* add a new file */
8889 dynarray_add((void ***)&files, &nb_files, r);
8890 if (!multiple_files) {
8891 optind--;
8892 /* argv[0] will be this file */
8893 break;
8894 }
8895 } else if (r[1] == '-') {
8896 /* '--' enables multiple files input and also ends several file input */
8897 if (dminus && multiple_files) {
8898 optind--; /* argv[0] will be '--' */
8899 break;
8900 }
8901 dminus = 1;
8902 multiple_files = 1;
8903 } else if (r[1] == 'h' || r[1] == '?') {
8904 show_help:
8905 help();
8906 return 1;
8907 } else if (r[1] == 'I') {
8908 if (tcc_add_include_path(s, r + 2) < 0)
8909 error("too many include paths");
8910 } else if (r[1] == 'D') {
8911 char *sym, *value;
8912 sym = r + 2;
8913 value = strchr(sym, '=');
8914 if (value) {
8915 *value = '\0';
8916 value++;
8917 }
8918 tcc_define_symbol(s, sym, value);
8919 } else if (r[1] == 'U') {
8920 tcc_undefine_symbol(s, r + 2);
8921 } else if (r[1] == 'L') {
8922 tcc_add_library_path(s, r + 2);
8923 } else if (r[1] == 'B') {
8924 /* set tcc utilities path (mainly for tcc development) */
8925 tcc_lib_path = r + 2;
8926 } else if (r[1] == 'l') {
8927 dynarray_add((void ***)&files, &nb_files, r);
8928 nb_libraries++;
8929 } else if (!strcmp(r + 1, "bench")) {
8930 do_bench = 1;
8931 } else if (!strcmp(r + 1, "bt")) {
8932 num_callers = atoi(argv[optind++]);
8933 } else
8934 #ifdef CONFIG_TCC_BCHECK
8935 if (r[1] == 'b') {
8936 do_bounds_check = 1;
8937 do_debug = 1;
8938 } else
8939 #endif
8940 if (r[1] == 'g') {
8941 do_debug = 1;
8942 } else if (r[1] == 'c') {
8943 multiple_files = 1;
8944 output_type = TCC_OUTPUT_OBJ;
8945 } else if (!strcmp(r + 1, "static")) {
8946 s->static_link = 1;
8947 } else if (!strcmp(r + 1, "shared")) {
8948 output_type = TCC_OUTPUT_DLL;
8949 } else if (r[1] == 'o') {
8950 if (optind >= argc)
8951 goto show_help;
8952 multiple_files = 1;
8953 outfile = argv[optind++];
8954 } else if (r[1] == 'r') {
8955 /* generate a .o merging several output files */
8956 reloc_output = 1;
8957 output_type = TCC_OUTPUT_OBJ;
8958 } else if (r[1] == 'W' || r[1] == 'O' || r[1] == 'm' || r[1] == 'f') {
8959 /* ignore those options to be a drop-in replacement for gcc */
8960 } else {
8961 error("invalid option -- '%s'", r);
8962 }
8963 }
8964
8965 nb_objfiles = nb_files - nb_libraries;
8966
8967 /* if outfile provided without other options, we output an
8968 executable */
8969 if (outfile && output_type == TCC_OUTPUT_MEMORY)
8970 output_type = TCC_OUTPUT_EXE;
8971
8972 /* check -c consistency : only single file handled. XXX: checks file type */
8973 if (output_type == TCC_OUTPUT_OBJ && !reloc_output) {
8974 /* accepts only a single input file */
8975 if (nb_objfiles != 1)
8976 error("cannot specify multiple files with -c");
8977 if (nb_libraries != 0)
8978 error("cannot specify libraries with -c");
8979 }
8980
8981 /* compute default outfile name */
8982 if (output_type != TCC_OUTPUT_MEMORY && !outfile) {
8983 if (output_type == TCC_OUTPUT_OBJ && !reloc_output) {
8984 char *ext;
8985 /* add .o extension */
8986 pstrcpy(objfilename, sizeof(objfilename) - 1, files[0]);
8987 ext = strrchr(objfilename, '.');
8988 if (!ext)
8989 goto default_outfile;
8990 strcpy(ext + 1, "o");
8991 } else {
8992 default_outfile:
8993 pstrcpy(objfilename, sizeof(objfilename), "a.out");
8994 }
8995 outfile = objfilename;
8996 }
8997
8998 if (do_bench) {
8999 start_time = getclock_us();
9000 }
9001
9002 tcc_set_output_type(s, output_type);
9003
9004 /* compile or add each files or library */
9005 for(i = 0;i < nb_files; i++) {
9006 const char *filename;
9007
9008 filename = files[i];
9009 if (filename[0] == '-') {
9010 if (tcc_add_library(s, filename + 2) < 0)
9011 error("cannot find %s", filename);
9012 } else {
9013 if (tcc_add_file(s, filename) < 0) {
9014 ret = 1;
9015 goto the_end;
9016 }
9017 }
9018 }
9019
9020 /* free all files */
9021 tcc_free(files);
9022
9023 if (do_bench) {
9024 double total_time;
9025 total_time = (double)(getclock_us() - start_time) / 1000000.0;
9026 if (total_time < 0.001)
9027 total_time = 0.001;
9028 if (total_bytes < 1)
9029 total_bytes = 1;
9030 printf("%d idents, %d lines, %d bytes, %0.3f s, %d lines/s, %0.1f MB/s\n",
9031 tok_ident - TOK_IDENT, total_lines, total_bytes,
9032 total_time, (int)(total_lines / total_time),
9033 total_bytes / total_time / 1000000.0);
9034 }
9035
9036 if (s->output_type != TCC_OUTPUT_MEMORY) {
9037 tcc_output_file(s, outfile);
9038 ret = 0;
9039 } else {
9040 ret = tcc_run(s, argc - optind, argv + optind);
9041 }
9042 the_end:
9043 /* XXX: cannot do it with bound checking because of the malloc hooks */
9044 if (!do_bounds_check)
9045 tcc_delete(s);
9046
9047 #ifdef MEM_DEBUG
9048 if (do_bench) {
9049 printf("memory: %d bytes, max = %d bytes\n", mem_cur_size, mem_max_size);
9050 }
9051 #endif
9052 return ret;
9053 }
9054
9055 #endif
Tiny C Compiler main repository