?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Improve the test coverage: !val for float/double/long long f.
[tinycc/kirr.git] / tcc.c
blob1b0b72bebc5c0c4c18eb2e479c8c840ee7cf6f23
1 /*
2 * TCC - Tiny C Compiler
3 *
4 * Copyright (c) 2001-2004 Fabrice Bellard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20 #define _GNU_SOURCE
21 #include "config.h"
22
23 #ifdef CONFIG_TCCBOOT
24
25 #include "tccboot.h"
26 #define CONFIG_TCC_STATIC
27
28 #else
29
30 #include <stdlib.h>
31 #include <stdio.h>
32 #include <stdarg.h>
33 #include <string.h>
34 #include <errno.h>
35 #include <math.h>
36 #include <signal.h>
37 #include <fcntl.h>
38 #include <setjmp.h>
39 #include <time.h>
40
41 #ifdef _WIN32
42 #include <windows.h>
43 #include <sys/timeb.h>
44 #ifdef _MSC_VER
45 #define inline __inline
46 #endif
47 #endif
48
49 #ifndef _WIN32
50 #include <unistd.h>
51 #include <sys/time.h>
52 #include <sys/ucontext.h>
53 #include <sys/mman.h>
54 #endif
55
56 #endif /* !CONFIG_TCCBOOT */
57
58 #ifndef PAGESIZE
59 #define PAGESIZE 4096
60 #endif
61
62 #include "elf.h"
63 #include "stab.h"
64
65 #ifndef O_BINARY
66 #define O_BINARY 0
67 #endif
68
69 #include "libtcc.h"
70
71 /* parser debug */
72 //#define PARSE_DEBUG
73 /* preprocessor debug */
74 //#define PP_DEBUG
75 /* include file debug */
76 //#define INC_DEBUG
77
78 //#define MEM_DEBUG
79
80 /* assembler debug */
81 //#define ASM_DEBUG
82
83 /* target selection */
84 //#define TCC_TARGET_I386 /* i386 code generator */
85 //#define TCC_TARGET_ARM /* ARMv4 code generator */
86 //#define TCC_TARGET_C67 /* TMS320C67xx code generator */
87 //#define TCC_TARGET_X86_64 /* x86-64 code generator */
88
89 /* default target is I386 */
90 #if !defined(TCC_TARGET_I386) && !defined(TCC_TARGET_ARM) && \
91 !defined(TCC_TARGET_C67) && !defined(TCC_TARGET_X86_64)
92 #define TCC_TARGET_I386
93 #endif
94
95 #if !defined(_WIN32) && !defined(TCC_UCLIBC) && !defined(TCC_TARGET_ARM) && \
96 !defined(TCC_TARGET_C67) && !defined(TCC_TARGET_X86_64)
97 #define CONFIG_TCC_BCHECK /* enable bound checking code */
98 #endif
99
100 #if defined(_WIN32) && !defined(TCC_TARGET_PE)
101 #define CONFIG_TCC_STATIC
102 #endif
103
104 /* define it to include assembler support */
105 #if !defined(TCC_TARGET_ARM) && !defined(TCC_TARGET_C67) && \
106 !defined(TCC_TARGET_X86_64)
107 #define CONFIG_TCC_ASM
108 #endif
109
110 /* object format selection */
111 #if defined(TCC_TARGET_C67)
112 #define TCC_TARGET_COFF
113 #endif
114
115 #define FALSE 0
116 #define false 0
117 #define TRUE 1
118 #define true 1
119 typedef int BOOL;
120
121 /* path to find crt1.o, crti.o and crtn.o. Only needed when generating
122 executables or dlls */
123 #define CONFIG_TCC_CRT_PREFIX CONFIG_SYSROOT "/usr/lib"
124
125 #define INCLUDE_STACK_SIZE 32
126 #define IFDEF_STACK_SIZE 64
127 #define VSTACK_SIZE 256
128 #define STRING_MAX_SIZE 1024
129 #define PACK_STACK_SIZE 8
130
131 #define TOK_HASH_SIZE 8192 /* must be a power of two */
132 #define TOK_ALLOC_INCR 512 /* must be a power of two */
133 #define TOK_MAX_SIZE 4 /* token max size in int unit when stored in string */
134
135 /* token symbol management */
136 typedef struct TokenSym {
137 struct TokenSym *hash_next;
138 struct Sym *sym_define; /* direct pointer to define */
139 struct Sym *sym_label; /* direct pointer to label */
140 struct Sym *sym_struct; /* direct pointer to structure */
141 struct Sym *sym_identifier; /* direct pointer to identifier */
142 int tok; /* token number */
143 int len;
144 char str[1];
145 } TokenSym;
146
147 #ifdef TCC_TARGET_PE
148 typedef unsigned short nwchar_t;
149 #else
150 typedef int nwchar_t;
151 #endif
152
153 typedef struct CString {
154 int size; /* size in bytes */
155 void *data; /* either 'char *' or 'nwchar_t *' */
156 int size_allocated;
157 void *data_allocated; /* if non NULL, data has been malloced */
158 } CString;
159
160 /* type definition */
161 typedef struct CType {
162 int t;
163 struct Sym *ref;
164 } CType;
165
166 /* constant value */
167 typedef union CValue {
168 long double ld;
169 double d;
170 float f;
171 int i;
172 unsigned int ui;
173 unsigned int ul; /* address (should be unsigned long on 64 bit cpu) */
174 long long ll;
175 unsigned long long ull;
176 struct CString *cstr;
177 void *ptr;
178 int tab[1];
179 } CValue;
180
181 /* value on stack */
182 typedef struct SValue {
183 CType type; /* type */
184 unsigned short r; /* register + flags */
185 unsigned short r2; /* second register, used for 'long long'
186 type. If not used, set to VT_CONST */
187 CValue c; /* constant, if VT_CONST */
188 struct Sym *sym; /* symbol, if (VT_SYM | VT_CONST) */
189 } SValue;
190
191 /* symbol management */
192 typedef struct Sym {
193 int v; /* symbol token */
194 long r; /* associated register */
195 long c; /* associated number */
196 CType type; /* associated type */
197 struct Sym *next; /* next related symbol */
198 struct Sym *prev; /* prev symbol in stack */
199 struct Sym *prev_tok; /* previous symbol for this token */
200 } Sym;
201
202 /* section definition */
203 /* XXX: use directly ELF structure for parameters ? */
204 /* special flag to indicate that the section should not be linked to
205 the other ones */
206 #define SHF_PRIVATE 0x80000000
207
208 typedef struct Section {
209 unsigned long data_offset; /* current data offset */
210 unsigned char *data; /* section data */
211 unsigned long data_allocated; /* used for realloc() handling */
212 int sh_name; /* elf section name (only used during output) */
213 int sh_num; /* elf section number */
214 int sh_type; /* elf section type */
215 int sh_flags; /* elf section flags */
216 int sh_info; /* elf section info */
217 int sh_addralign; /* elf section alignment */
218 int sh_entsize; /* elf entry size */
219 unsigned long sh_size; /* section size (only used during output) */
220 unsigned long sh_addr; /* address at which the section is relocated */
221 unsigned long sh_offset; /* file offset */
222 int nb_hashed_syms; /* used to resize the hash table */
223 struct Section *link; /* link to another section */
224 struct Section *reloc; /* corresponding section for relocation, if any */
225 struct Section *hash; /* hash table for symbols */
226 struct Section *next;
227 char name[1]; /* section name */
228 } Section;
229
230 typedef struct DLLReference {
231 int level;
232 void *handle;
233 char name[1];
234 } DLLReference;
235
236 /* GNUC attribute definition */
237 typedef struct AttributeDef {
238 int aligned;
239 int packed;
240 Section *section;
241 int func_attr; /* calling convention, exports, ... */
242 } AttributeDef;
243
244 /* -------------------------------------------------- */
245 /* gr: wrappers for casting sym->r for other purposes */
246 typedef struct {
247 unsigned
248 func_call : 8,
249 func_args : 8,
250 func_export : 1;
251 } func_attr_t;
252
253 #define FUNC_CALL(r) (((func_attr_t*)&(r))->func_call)
254 #define FUNC_EXPORT(r) (((func_attr_t*)&(r))->func_export)
255 #define FUNC_ARGS(r) (((func_attr_t*)&(r))->func_args)
256 #define INLINE_DEF(r) (*(int **)&(r))
257 /* -------------------------------------------------- */
258
259 #define SYM_STRUCT 0x40000000 /* struct/union/enum symbol space */
260 #define SYM_FIELD 0x20000000 /* struct/union field symbol space */
261 #define SYM_FIRST_ANOM 0x10000000 /* first anonymous sym */
262
263 /* stored in 'Sym.c' field */
264 #define FUNC_NEW 1 /* ansi function prototype */
265 #define FUNC_OLD 2 /* old function prototype */
266 #define FUNC_ELLIPSIS 3 /* ansi function prototype with ... */
267
268 /* stored in 'Sym.r' field */
269 #define FUNC_CDECL 0 /* standard c call */
270 #define FUNC_STDCALL 1 /* pascal c call */
271 #define FUNC_FASTCALL1 2 /* first param in %eax */
272 #define FUNC_FASTCALL2 3 /* first parameters in %eax, %edx */
273 #define FUNC_FASTCALL3 4 /* first parameter in %eax, %edx, %ecx */
274 #define FUNC_FASTCALLW 5 /* first parameter in %ecx, %edx */
275
276 /* field 'Sym.t' for macros */
277 #define MACRO_OBJ 0 /* object like macro */
278 #define MACRO_FUNC 1 /* function like macro */
279
280 /* field 'Sym.r' for C labels */
281 #define LABEL_DEFINED 0 /* label is defined */
282 #define LABEL_FORWARD 1 /* label is forward defined */
283 #define LABEL_DECLARED 2 /* label is declared but never used */
284
285 /* type_decl() types */
286 #define TYPE_ABSTRACT 1 /* type without variable */
287 #define TYPE_DIRECT 2 /* type with variable */
288
289 #define IO_BUF_SIZE 8192
290
291 typedef struct BufferedFile {
292 uint8_t *buf_ptr;
293 uint8_t *buf_end;
294 int fd;
295 int line_num; /* current line number - here to simplify code */
296 int ifndef_macro; /* #ifndef macro / #endif search */
297 int ifndef_macro_saved; /* saved ifndef_macro */
298 int *ifdef_stack_ptr; /* ifdef_stack value at the start of the file */
299 char inc_type; /* type of include */
300 char inc_filename[512]; /* filename specified by the user */
301 char filename[1024]; /* current filename - here to simplify code */
302 unsigned char buffer[IO_BUF_SIZE + 1]; /* extra size for CH_EOB char */
303 } BufferedFile;
304
305 #define CH_EOB '\\' /* end of buffer or '\0' char in file */
306 #define CH_EOF (-1) /* end of file */
307
308 /* parsing state (used to save parser state to reparse part of the
309 source several times) */
310 typedef struct ParseState {
311 int *macro_ptr;
312 int line_num;
313 int tok;
314 CValue tokc;
315 } ParseState;
316
317 /* used to record tokens */
318 typedef struct TokenString {
319 int *str;
320 int len;
321 int allocated_len;
322 int last_line_num;
323 } TokenString;
324
325 /* include file cache, used to find files faster and also to eliminate
326 inclusion if the include file is protected by #ifndef ... #endif */
327 typedef struct CachedInclude {
328 int ifndef_macro;
329 int hash_next; /* -1 if none */
330 char type; /* '"' or '>' to give include type */
331 char filename[1]; /* path specified in #include */
332 } CachedInclude;
333
334 #define CACHED_INCLUDES_HASH_SIZE 512
335
336 /* parser */
337 static struct BufferedFile *file;
338 static int ch, tok;
339 static CString tok_spaces; /* spaces before current token */
340 static CValue tokc;
341 static CString tokcstr; /* current parsed string, if any */
342 /* additional informations about token */
343 static int tok_flags;
344 #define TOK_FLAG_BOL 0x0001 /* beginning of line before */
345 #define TOK_FLAG_BOF 0x0002 /* beginning of file before */
346 #define TOK_FLAG_ENDIF 0x0004 /* a endif was found matching starting #ifdef */
347 #define TOK_FLAG_EOF 0x0008 /* end of file */
348
349 static int *macro_ptr, *macro_ptr_allocated;
350 static int *unget_saved_macro_ptr;
351 static int unget_saved_buffer[TOK_MAX_SIZE + 1];
352 static int unget_buffer_enabled;
353 static int parse_flags;
354 #define PARSE_FLAG_PREPROCESS 0x0001 /* activate preprocessing */
355 #define PARSE_FLAG_TOK_NUM 0x0002 /* return numbers instead of TOK_PPNUM */
356 #define PARSE_FLAG_LINEFEED 0x0004 /* line feed is returned as a
357 token. line feed is also
358 returned at eof */
359 #define PARSE_FLAG_ASM_COMMENTS 0x0008 /* '#' can be used for line comment */
360
361 static Section *text_section, *data_section, *bss_section; /* predefined sections */
362 static Section *cur_text_section; /* current section where function code is
363 generated */
364 #ifdef CONFIG_TCC_ASM
365 static Section *last_text_section; /* to handle .previous asm directive */
366 #endif
367 /* bound check related sections */
368 static Section *bounds_section; /* contains global data bound description */
369 static Section *lbounds_section; /* contains local data bound description */
370 /* symbol sections */
371 static Section *symtab_section, *strtab_section;
372
373 /* debug sections */
374 static Section *stab_section, *stabstr_section;
375
376 /* loc : local variable index
377 ind : output code index
378 rsym: return symbol
379 anon_sym: anonymous symbol index
380 */
381 static int rsym, anon_sym, ind, loc;
382 /* expression generation modifiers */
383 static int const_wanted; /* true if constant wanted */
384 static int nocode_wanted; /* true if no code generation wanted for an expression */
385 static int global_expr; /* true if compound literals must be allocated
386 globally (used during initializers parsing */
387 static CType func_vt; /* current function return type (used by return
388 instruction) */
389 static int func_vc;
390 static int last_line_num, last_ind, func_ind; /* debug last line number and pc */
391 static int tok_ident;
392 static TokenSym **table_ident;
393 static TokenSym *hash_ident[TOK_HASH_SIZE];
394 static char token_buf[STRING_MAX_SIZE + 1];
395 static char *funcname;
396 static Sym *global_stack, *local_stack;
397 static Sym *define_stack;
398 static Sym *global_label_stack, *local_label_stack;
399 /* symbol allocator */
400 #define SYM_POOL_NB (8192 / sizeof(Sym))
401 static Sym *sym_free_first;
402 static void **sym_pools;
403 static int nb_sym_pools;
404
405 static SValue vstack[VSTACK_SIZE], *vtop;
406 /* some predefined types */
407 static CType char_pointer_type, func_old_type, int_type;
408 /* true if isid(c) || isnum(c) */
409 static unsigned char isidnum_table[256-CH_EOF];
410
411 /* display some information during compilation */
412 static int verbose = 0;
413
414 /* compile with debug symbol (and use them if error during execution) */
415 static int do_debug = 0;
416
417 /* compile with built-in memory and bounds checker */
418 static int do_bounds_check = 0;
419
420 /* display benchmark infos */
421 #if !defined(LIBTCC)
422 static int do_bench = 0;
423 #endif
424 static int total_lines;
425 static int total_bytes;
426
427 /* use GNU C extensions */
428 static int gnu_ext = 1;
429
430 /* use Tiny C extensions */
431 static int tcc_ext = 1;
432
433 /* max number of callers shown if error */
434 static int num_callers = 6;
435 static const char **rt_bound_error_msg;
436
437 /* XXX: get rid of this ASAP */
438 static struct TCCState *tcc_state;
439
440 /* give the path of the tcc libraries */
441 static const char *tcc_lib_path = CONFIG_TCCDIR;
442
443 struct TCCState {
444 int output_type;
445
446 BufferedFile **include_stack_ptr;
447 int *ifdef_stack_ptr;
448
449 /* include file handling */
450 char **include_paths;
451 int nb_include_paths;
452 char **sysinclude_paths;
453 int nb_sysinclude_paths;
454 CachedInclude **cached_includes;
455 int nb_cached_includes;
456
457 char **library_paths;
458 int nb_library_paths;
459
460 /* array of all loaded dlls (including those referenced by loaded
461 dlls) */
462 DLLReference **loaded_dlls;
463 int nb_loaded_dlls;
464
465 /* sections */
466 Section **sections;
467 int nb_sections; /* number of sections, including first dummy section */
468
469 Section **priv_sections;
470 int nb_priv_sections; /* number of private sections */
471
472 /* got handling */
473 Section *got;
474 Section *plt;
475 unsigned long *got_offsets;
476 int nb_got_offsets;
477 /* give the correspondance from symtab indexes to dynsym indexes */
478 int *symtab_to_dynsym;
479
480 /* temporary dynamic symbol sections (for dll loading) */
481 Section *dynsymtab_section;
482 /* exported dynamic symbol section */
483 Section *dynsym;
484
485 int nostdinc; /* if true, no standard headers are added */
486 int nostdlib; /* if true, no standard libraries are added */
487
488 int nocommon; /* if true, do not use common symbols for .bss data */
489
490 /* if true, static linking is performed */
491 int static_link;
492
493 /* soname as specified on the command line (-soname) */
494 const char *soname;
495
496 /* if true, all symbols are exported */
497 int rdynamic;
498
499 /* if true, only link in referenced objects from archive */
500 int alacarte_link;
501
502 /* address of text section */
503 unsigned long text_addr;
504 int has_text_addr;
505
506 /* output format, see TCC_OUTPUT_FORMAT_xxx */
507 int output_format;
508
509 /* C language options */
510 int char_is_unsigned;
511 int leading_underscore;
512
513 /* warning switches */
514 int warn_write_strings;
515 int warn_unsupported;
516 int warn_error;
517 int warn_none;
518 int warn_implicit_function_declaration;
519
520 /* error handling */
521 void *error_opaque;
522 void (*error_func)(void *opaque, const char *msg);
523 int error_set_jmp_enabled;
524 jmp_buf error_jmp_buf;
525 int nb_errors;
526
527 /* tiny assembler state */
528 Sym *asm_labels;
529
530 /* see include_stack_ptr */
531 BufferedFile *include_stack[INCLUDE_STACK_SIZE];
532
533 /* see ifdef_stack_ptr */
534 int ifdef_stack[IFDEF_STACK_SIZE];
535
536 /* see cached_includes */
537 int cached_includes_hash[CACHED_INCLUDES_HASH_SIZE];
538
539 /* pack stack */
540 int pack_stack[PACK_STACK_SIZE];
541 int *pack_stack_ptr;
542
543 /* output file for preprocessing */
544 FILE *outfile;
545 };
546
547 /* The current value can be: */
548 #define VT_VALMASK 0x00ff
549 #define VT_CONST 0x00f0 /* constant in vc
550 (must be first non register value) */
551 #define VT_LLOCAL 0x00f1 /* lvalue, offset on stack */
552 #define VT_LOCAL 0x00f2 /* offset on stack */
553 #define VT_CMP 0x00f3 /* the value is stored in processor flags (in vc) */
554 #define VT_JMP 0x00f4 /* value is the consequence of jmp true (even) */
555 #define VT_JMPI 0x00f5 /* value is the consequence of jmp false (odd) */
556 #define VT_LVAL 0x0100 /* var is an lvalue */
557 #define VT_SYM 0x0200 /* a symbol value is added */
558 #define VT_MUSTCAST 0x0400 /* value must be casted to be correct (used for
559 char/short stored in integer registers) */
560 #define VT_MUSTBOUND 0x0800 /* bound checking must be done before
561 dereferencing value */
562 #define VT_BOUNDED 0x8000 /* value is bounded. The address of the
563 bounding function call point is in vc */
564 #define VT_LVAL_BYTE 0x1000 /* lvalue is a byte */
565 #define VT_LVAL_SHORT 0x2000 /* lvalue is a short */
566 #define VT_LVAL_UNSIGNED 0x4000 /* lvalue is unsigned */
567 #define VT_LVAL_TYPE (VT_LVAL_BYTE | VT_LVAL_SHORT | VT_LVAL_UNSIGNED)
568
569 /* types */
570 #define VT_INT 0 /* integer type */
571 #define VT_BYTE 1 /* signed byte type */
572 #define VT_SHORT 2 /* short type */
573 #define VT_VOID 3 /* void type */
574 #define VT_PTR 4 /* pointer */
575 #define VT_ENUM 5 /* enum definition */
576 #define VT_FUNC 6 /* function type */
577 #define VT_STRUCT 7 /* struct/union definition */
578 #define VT_FLOAT 8 /* IEEE float */
579 #define VT_DOUBLE 9 /* IEEE double */
580 #define VT_LDOUBLE 10 /* IEEE long double */
581 #define VT_BOOL 11 /* ISOC99 boolean type */
582 #define VT_LLONG 12 /* 64 bit integer */
583 #define VT_LONG 13 /* long integer (NEVER USED as type, only
584 during parsing) */
585 #define VT_BTYPE 0x000f /* mask for basic type */
586 #define VT_UNSIGNED 0x0010 /* unsigned type */
587 #define VT_ARRAY 0x0020 /* array type (also has VT_PTR) */
588 #define VT_BITFIELD 0x0040 /* bitfield modifier */
589 #define VT_CONSTANT 0x0800 /* const modifier */
590 #define VT_VOLATILE 0x1000 /* volatile modifier */
591 #define VT_SIGNED 0x2000 /* signed type */
592
593 /* storage */
594 #define VT_EXTERN 0x00000080 /* extern definition */
595 #define VT_STATIC 0x00000100 /* static variable */
596 #define VT_TYPEDEF 0x00000200 /* typedef definition */
597 #define VT_INLINE 0x00000400 /* inline definition */
598
599 #define VT_STRUCT_SHIFT 16 /* shift for bitfield shift values */
600
601 /* type mask (except storage) */
602 #define VT_STORAGE (VT_EXTERN | VT_STATIC | VT_TYPEDEF | VT_INLINE)
603 #define VT_TYPE (~(VT_STORAGE))
604
605 /* token values */
606
607 /* warning: the following compare tokens depend on i386 asm code */
608 #define TOK_ULT 0x92
609 #define TOK_UGE 0x93
610 #define TOK_EQ 0x94
611 #define TOK_NE 0x95
612 #define TOK_ULE 0x96
613 #define TOK_UGT 0x97
614 #define TOK_Nset 0x98
615 #define TOK_Nclear 0x99
616 #define TOK_LT 0x9c
617 #define TOK_GE 0x9d
618 #define TOK_LE 0x9e
619 #define TOK_GT 0x9f
620
621 #define TOK_LAND 0xa0
622 #define TOK_LOR 0xa1
623
624 #define TOK_DEC 0xa2
625 #define TOK_MID 0xa3 /* inc/dec, to void constant */
626 #define TOK_INC 0xa4
627 #define TOK_UDIV 0xb0 /* unsigned division */
628 #define TOK_UMOD 0xb1 /* unsigned modulo */
629 #define TOK_PDIV 0xb2 /* fast division with undefined rounding for pointers */
630 #define TOK_CINT 0xb3 /* number in tokc */
631 #define TOK_CCHAR 0xb4 /* char constant in tokc */
632 #define TOK_STR 0xb5 /* pointer to string in tokc */
633 #define TOK_TWOSHARPS 0xb6 /* ## preprocessing token */
634 #define TOK_LCHAR 0xb7
635 #define TOK_LSTR 0xb8
636 #define TOK_CFLOAT 0xb9 /* float constant */
637 #define TOK_LINENUM 0xba /* line number info */
638 #define TOK_CDOUBLE 0xc0 /* double constant */
639 #define TOK_CLDOUBLE 0xc1 /* long double constant */
640 #define TOK_UMULL 0xc2 /* unsigned 32x32 -> 64 mul */
641 #define TOK_ADDC1 0xc3 /* add with carry generation */
642 #define TOK_ADDC2 0xc4 /* add with carry use */
643 #define TOK_SUBC1 0xc5 /* add with carry generation */
644 #define TOK_SUBC2 0xc6 /* add with carry use */
645 #define TOK_CUINT 0xc8 /* unsigned int constant */
646 #define TOK_CLLONG 0xc9 /* long long constant */
647 #define TOK_CULLONG 0xca /* unsigned long long constant */
648 #define TOK_ARROW 0xcb
649 #define TOK_DOTS 0xcc /* three dots */
650 #define TOK_SHR 0xcd /* unsigned shift right */
651 #define TOK_PPNUM 0xce /* preprocessor number */
652
653 #define TOK_SHL 0x01 /* shift left */
654 #define TOK_SAR 0x02 /* signed shift right */
655
656 /* assignement operators : normal operator or 0x80 */
657 #define TOK_A_MOD 0xa5
658 #define TOK_A_AND 0xa6
659 #define TOK_A_MUL 0xaa
660 #define TOK_A_ADD 0xab
661 #define TOK_A_SUB 0xad
662 #define TOK_A_DIV 0xaf
663 #define TOK_A_XOR 0xde
664 #define TOK_A_OR 0xfc
665 #define TOK_A_SHL 0x81
666 #define TOK_A_SAR 0x82
667
668 #ifndef offsetof
669 #define offsetof(type, field) ((size_t) &((type *)0)->field)
670 #endif
671
672 #ifndef countof
673 #define countof(tab) (sizeof(tab) / sizeof((tab)[0]))
674 #endif
675
676 /* WARNING: the content of this string encodes token numbers */
677 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";
678
679 #define TOK_EOF (-1) /* end of file */
680 #define TOK_LINEFEED 10 /* line feed */
681
682 /* all identificators and strings have token above that */
683 #define TOK_IDENT 256
684
685 /* only used for i386 asm opcodes definitions */
686 #define DEF_ASM(x) DEF(TOK_ASM_ ## x, #x)
687
688 #define DEF_BWL(x) \
689 DEF(TOK_ASM_ ## x ## b, #x "b") \
690 DEF(TOK_ASM_ ## x ## w, #x "w") \
691 DEF(TOK_ASM_ ## x ## l, #x "l") \
692 DEF(TOK_ASM_ ## x, #x)
693
694 #define DEF_WL(x) \
695 DEF(TOK_ASM_ ## x ## w, #x "w") \
696 DEF(TOK_ASM_ ## x ## l, #x "l") \
697 DEF(TOK_ASM_ ## x, #x)
698
699 #define DEF_FP1(x) \
700 DEF(TOK_ASM_ ## f ## x ## s, "f" #x "s") \
701 DEF(TOK_ASM_ ## fi ## x ## l, "fi" #x "l") \
702 DEF(TOK_ASM_ ## f ## x ## l, "f" #x "l") \
703 DEF(TOK_ASM_ ## fi ## x ## s, "fi" #x "s")
704
705 #define DEF_FP(x) \
706 DEF(TOK_ASM_ ## f ## x, "f" #x ) \
707 DEF(TOK_ASM_ ## f ## x ## p, "f" #x "p") \
708 DEF_FP1(x)
709
710 #define DEF_ASMTEST(x) \
711 DEF_ASM(x ## o) \
712 DEF_ASM(x ## no) \
713 DEF_ASM(x ## b) \
714 DEF_ASM(x ## c) \
715 DEF_ASM(x ## nae) \
716 DEF_ASM(x ## nb) \
717 DEF_ASM(x ## nc) \
718 DEF_ASM(x ## ae) \
719 DEF_ASM(x ## e) \
720 DEF_ASM(x ## z) \
721 DEF_ASM(x ## ne) \
722 DEF_ASM(x ## nz) \
723 DEF_ASM(x ## be) \
724 DEF_ASM(x ## na) \
725 DEF_ASM(x ## nbe) \
726 DEF_ASM(x ## a) \
727 DEF_ASM(x ## s) \
728 DEF_ASM(x ## ns) \
729 DEF_ASM(x ## p) \
730 DEF_ASM(x ## pe) \
731 DEF_ASM(x ## np) \
732 DEF_ASM(x ## po) \
733 DEF_ASM(x ## l) \
734 DEF_ASM(x ## nge) \
735 DEF_ASM(x ## nl) \
736 DEF_ASM(x ## ge) \
737 DEF_ASM(x ## le) \
738 DEF_ASM(x ## ng) \
739 DEF_ASM(x ## nle) \
740 DEF_ASM(x ## g)
741
742 #define TOK_ASM_int TOK_INT
743
744 enum tcc_token {
745 TOK_LAST = TOK_IDENT - 1,
746 #define DEF(id, str) id,
747 #include "tcctok.h"
748 #undef DEF
749 };
750
751 static const char tcc_keywords[] =
752 #define DEF(id, str) str "\0"
753 #include "tcctok.h"
754 #undef DEF
755 ;
756
757 #define TOK_UIDENT TOK_DEFINE
758
759 #ifdef _WIN32
760 #define snprintf _snprintf
761 #define vsnprintf _vsnprintf
762 #ifndef __GNUC__
763 #define strtold (long double)strtod
764 #define strtof (float)strtod
765 #define strtoll (long long)strtol
766 #endif
767 #elif defined(TCC_UCLIBC) || defined(__FreeBSD__) || defined(__DragonFly__) \
768 || defined(__OpenBSD__)
769 /* currently incorrect */
770 long double strtold(const char *nptr, char **endptr)
771 {
772 return (long double)strtod(nptr, endptr);
773 }
774 float strtof(const char *nptr, char **endptr)
775 {
776 return (float)strtod(nptr, endptr);
777 }
778 #else
779 /* XXX: need to define this to use them in non ISOC99 context */
780 extern float strtof (const char *__nptr, char **__endptr);
781 extern long double strtold (const char *__nptr, char **__endptr);
782 #endif
783
784 static char *pstrcpy(char *buf, int buf_size, const char *s);
785 static char *pstrcat(char *buf, int buf_size, const char *s);
786 static char *tcc_basename(const char *name);
787 static char *tcc_fileextension (const char *p);
788
789 static void next(void);
790 static void next_nomacro(void);
791 static void parse_expr_type(CType *type);
792 static void expr_type(CType *type);
793 static void unary_type(CType *type);
794 static void block(int *bsym, int *csym, int *case_sym, int *def_sym,
795 int case_reg, int is_expr);
796 static int expr_const(void);
797 static void expr_eq(void);
798 static void gexpr(void);
799 static void gen_inline_functions(void);
800 static void decl(int l);
801 static void decl_initializer(CType *type, Section *sec, unsigned long c,
802 int first, int size_only);
803 static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
804 int has_init, int v, int scope);
805 int gv(int rc);
806 void gv2(int rc1, int rc2);
807 void move_reg(int r, int s);
808 void save_regs(int n);
809 void save_reg(int r);
810 void vpop(void);
811 void vswap(void);
812 void vdup(void);
813 int get_reg(int rc);
814 int get_reg_ex(int rc,int rc2);
815
816 struct macro_level {
817 struct macro_level *prev;
818 int *p;
819 };
820
821 static void macro_subst(TokenString *tok_str, Sym **nested_list,
822 const int *macro_str, struct macro_level **can_read_stream);
823 void gen_op(int op);
824 void force_charshort_cast(int t);
825 static void gen_cast(CType *type);
826 void vstore(void);
827 static Sym *sym_find(int v);
828 static Sym *sym_push(int v, CType *type, int r, int c);
829
830 /* type handling */
831 static int type_size(CType *type, int *a);
832 static inline CType *pointed_type(CType *type);
833 static int pointed_size(CType *type);
834 static int lvalue_type(int t);
835 static int parse_btype(CType *type, AttributeDef *ad);
836 static void type_decl(CType *type, AttributeDef *ad, int *v, int td);
837 static int compare_types(CType *type1, CType *type2, int unqualified);
838 static int is_compatible_types(CType *type1, CType *type2);
839 static int is_compatible_parameter_types(CType *type1, CType *type2);
840
841 int ieee_finite(double d);
842 void error(const char *fmt, ...);
843 void vpushi(int v);
844 void vpushll(long long v);
845 void vrott(int n);
846 void vnrott(int n);
847 void lexpand_nr(void);
848 static void vpush_global_sym(CType *type, int v);
849 void vset(CType *type, int r, int v);
850 void type_to_str(char *buf, int buf_size,
851 CType *type, const char *varstr);
852 char *get_tok_str(int v, CValue *cv);
853 static Sym *get_sym_ref(CType *type, Section *sec,
854 unsigned long offset, unsigned long size);
855 static Sym *external_global_sym(int v, CType *type, int r);
856
857 /* section generation */
858 static void section_realloc(Section *sec, unsigned long new_size);
859 static void *section_ptr_add(Section *sec, unsigned long size);
860 static void put_extern_sym(Sym *sym, Section *section,
861 unsigned long value, unsigned long size);
862 static void greloc(Section *s, Sym *sym, unsigned long addr, int type);
863 static int put_elf_str(Section *s, const char *sym);
864 static int put_elf_sym(Section *s,
865 unsigned long value, unsigned long size,
866 int info, int other, int shndx, const char *name);
867 static int add_elf_sym(Section *s, unsigned long value, unsigned long size,
868 int info, int other, int sh_num, const char *name);
869 static void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
870 int type, int symbol);
871 static void put_stabs(const char *str, int type, int other, int desc,
872 unsigned long value);
873 static void put_stabs_r(const char *str, int type, int other, int desc,
874 unsigned long value, Section *sec, int sym_index);
875 static void put_stabn(int type, int other, int desc, int value);
876 static void put_stabd(int type, int other, int desc);
877 static int tcc_add_dll(TCCState *s, const char *filename, int flags);
878
879 #define AFF_PRINT_ERROR 0x0001 /* print error if file not found */
880 #define AFF_REFERENCED_DLL 0x0002 /* load a referenced dll from another dll */
881 #define AFF_PREPROCESS 0x0004 /* preprocess file */
882 static int tcc_add_file_internal(TCCState *s, const char *filename, int flags);
883
884 /* tcccoff.c */
885 int tcc_output_coff(TCCState *s1, FILE *f);
886
887 /* tccpe.c */
888 void *resolve_sym(TCCState *s1, const char *sym, int type);
889 int pe_load_def_file(struct TCCState *s1, int fd);
890 int pe_test_res_file(void *v, int size);
891 int pe_load_res_file(struct TCCState *s1, int fd);
892 void pe_add_runtime(struct TCCState *s1);
893 void pe_guess_outfile(char *objfilename, int output_type);
894 int pe_output_file(struct TCCState *s1, const char *filename);
895
896 /* tccasm.c */
897
898 #ifdef CONFIG_TCC_ASM
899
900 typedef struct ExprValue {
901 uint32_t v;
902 Sym *sym;
903 } ExprValue;
904
905 #define MAX_ASM_OPERANDS 30
906
907 typedef struct ASMOperand {
908 int id; /* GCC 3 optionnal identifier (0 if number only supported */
909 char *constraint;
910 char asm_str[16]; /* computed asm string for operand */
911 SValue *vt; /* C value of the expression */
912 int ref_index; /* if >= 0, gives reference to a output constraint */
913 int input_index; /* if >= 0, gives reference to an input constraint */
914 int priority; /* priority, used to assign registers */
915 int reg; /* if >= 0, register number used for this operand */
916 int is_llong; /* true if double register value */
917 int is_memory; /* true if memory operand */
918 int is_rw; /* for '+' modifier */
919 } ASMOperand;
920
921 static void asm_expr(TCCState *s1, ExprValue *pe);
922 static int asm_int_expr(TCCState *s1);
923 static int find_constraint(ASMOperand *operands, int nb_operands,
924 const char *name, const char **pp);
925
926 static int tcc_assemble(TCCState *s1, int do_preprocess);
927
928 #endif
929
930 static void asm_instr(void);
931 static void asm_global_instr(void);
932
933 /* true if float/double/long double type */
934 static inline int is_float(int t)
935 {
936 int bt;
937 bt = t & VT_BTYPE;
938 return bt == VT_LDOUBLE || bt == VT_DOUBLE || bt == VT_FLOAT;
939 }
940
941 #ifdef TCC_TARGET_I386
942 #include "i386-gen.c"
943 #endif
944
945 #ifdef TCC_TARGET_ARM
946 #include "arm-gen.c"
947 #endif
948
949 #ifdef TCC_TARGET_C67
950 #include "c67-gen.c"
951 #endif
952
953 #ifdef TCC_TARGET_X86_64
954 #include "x86_64-gen.c"
955 #endif
956
957 #ifdef CONFIG_TCC_STATIC
958
959 #define RTLD_LAZY 0x001
960 #define RTLD_NOW 0x002
961 #define RTLD_GLOBAL 0x100
962 #define RTLD_DEFAULT NULL
963
964 /* dummy function for profiling */
965 void *dlopen(const char *filename, int flag)
966 {
967 return NULL;
968 }
969
970 const char *dlerror(void)
971 {
972 return "error";
973 }
974
975 typedef struct TCCSyms {
976 char *str;
977 void *ptr;
978 } TCCSyms;
979
980 #define TCCSYM(a) { #a, &a, },
981
982 /* add the symbol you want here if no dynamic linking is done */
983 static TCCSyms tcc_syms[] = {
984 #if !defined(CONFIG_TCCBOOT)
985 TCCSYM(printf)
986 TCCSYM(fprintf)
987 TCCSYM(fopen)
988 TCCSYM(fclose)
989 #endif
990 { NULL, NULL },
991 };
992
993 void *resolve_sym(TCCState *s1, const char *symbol, int type)
994 {
995 TCCSyms *p;
996 p = tcc_syms;
997 while (p->str != NULL) {
998 if (!strcmp(p->str, symbol))
999 return p->ptr;
1000 p++;
1001 }
1002 return NULL;
1003 }
1004
1005 #elif !defined(_WIN32)
1006
1007 #include <dlfcn.h>
1008
1009 void *resolve_sym(TCCState *s1, const char *sym, int type)
1010 {
1011 return dlsym(RTLD_DEFAULT, sym);
1012 }
1013
1014 #endif
1015
1016 /********************************************************/
1017
1018 /* we use our own 'finite' function to avoid potential problems with
1019 non standard math libs */
1020 /* XXX: endianness dependent */
1021 int ieee_finite(double d)
1022 {
1023 int *p = (int *)&d;
1024 return ((unsigned)((p[1] | 0x800fffff) + 1)) >> 31;
1025 }
1026
1027 /* copy a string and truncate it. */
1028 static char *pstrcpy(char *buf, int buf_size, const char *s)
1029 {
1030 char *q, *q_end;
1031 int c;
1032
1033 if (buf_size > 0) {
1034 q = buf;
1035 q_end = buf + buf_size - 1;
1036 while (q < q_end) {
1037 c = *s++;
1038 if (c == '\0')
1039 break;
1040 *q++ = c;
1041 }
1042 *q = '\0';
1043 }
1044 return buf;
1045 }
1046
1047 /* strcat and truncate. */
1048 static char *pstrcat(char *buf, int buf_size, const char *s)
1049 {
1050 int len;
1051 len = strlen(buf);
1052 if (len < buf_size)
1053 pstrcpy(buf + len, buf_size - len, s);
1054 return buf;
1055 }
1056
1057 #ifndef LIBTCC
1058 static int strstart(const char *str, const char *val, const char **ptr)
1059 {
1060 const char *p, *q;
1061 p = str;
1062 q = val;
1063 while (*q != '\0') {
1064 if (*p != *q)
1065 return 0;
1066 p++;
1067 q++;
1068 }
1069 if (ptr)
1070 *ptr = p;
1071 return 1;
1072 }
1073 #endif
1074
1075 #ifdef _WIN32
1076 #define IS_PATHSEP(c) (c == '/' || c == '\\')
1077 #define IS_ABSPATH(p) (IS_PATHSEP(p[0]) || (p[0] && p[1] == ':' && IS_PATHSEP(p[2])))
1078 #else
1079 #define IS_PATHSEP(c) (c == '/')
1080 #define IS_ABSPATH(p) IS_PATHSEP(p[0])
1081 #endif
1082
1083 /* extract the basename of a file */
1084 static char *tcc_basename(const char *name)
1085 {
1086 char *p = strchr(name, 0);
1087 while (p > name && !IS_PATHSEP(p[-1]))
1088 --p;
1089 return p;
1090 }
1091
1092 static char *tcc_fileextension (const char *name)
1093 {
1094 char *b = tcc_basename(name);
1095 char *e = strrchr(b, '.');
1096 return e ? e : strchr(b, 0);
1097 }
1098
1099 #ifdef _WIN32
1100 char *normalize_slashes(char *path)
1101 {
1102 char *p;
1103 for (p = path; *p; ++p)
1104 if (*p == '\\')
1105 *p = '/';
1106 return path;
1107 }
1108
1109 char *w32_tcc_lib_path(void)
1110 {
1111 /* on win32, we suppose the lib and includes are at the location
1112 of 'tcc.exe' */
1113 char path[1024], *p;
1114 GetModuleFileNameA(NULL, path, sizeof path);
1115 p = tcc_basename(normalize_slashes(strlwr(path)));
1116 if (p - 5 > path && 0 == strncmp(p - 5, "/bin/", 5))
1117 p -= 5;
1118 else if (p > path)
1119 p--;
1120 *p = 0;
1121 return strdup(path);
1122 }
1123 #endif
1124
1125 void set_pages_executable(void *ptr, unsigned long length)
1126 {
1127 #ifdef _WIN32
1128 unsigned long old_protect;
1129 VirtualProtect(ptr, length, PAGE_EXECUTE_READWRITE, &old_protect);
1130 #else
1131 unsigned long start, end;
1132 start = (unsigned long)ptr & ~(PAGESIZE - 1);
1133 end = (unsigned long)ptr + length;
1134 end = (end + PAGESIZE - 1) & ~(PAGESIZE - 1);
1135 mprotect((void *)start, end - start, PROT_READ | PROT_WRITE | PROT_EXEC);
1136 #endif
1137 }
1138
1139 /* memory management */
1140 #ifdef MEM_DEBUG
1141 int mem_cur_size;
1142 int mem_max_size;
1143 unsigned malloc_usable_size(void*);
1144 #endif
1145
1146 static inline void tcc_free(void *ptr)
1147 {
1148 #ifdef MEM_DEBUG
1149 mem_cur_size -= malloc_usable_size(ptr);
1150 #endif
1151 free(ptr);
1152 }
1153
1154 static void *tcc_malloc(unsigned long size)
1155 {
1156 void *ptr;
1157 ptr = malloc(size);
1158 if (!ptr && size)
1159 error("memory full");
1160 #ifdef MEM_DEBUG
1161 mem_cur_size += malloc_usable_size(ptr);
1162 if (mem_cur_size > mem_max_size)
1163 mem_max_size = mem_cur_size;
1164 #endif
1165 return ptr;
1166 }
1167
1168 static void *tcc_mallocz(unsigned long size)
1169 {
1170 void *ptr;
1171 ptr = tcc_malloc(size);
1172 memset(ptr, 0, size);
1173 return ptr;
1174 }
1175
1176 static inline void *tcc_realloc(void *ptr, unsigned long size)
1177 {
1178 void *ptr1;
1179 #ifdef MEM_DEBUG
1180 mem_cur_size -= malloc_usable_size(ptr);
1181 #endif
1182 ptr1 = realloc(ptr, size);
1183 #ifdef MEM_DEBUG
1184 /* NOTE: count not correct if alloc error, but not critical */
1185 mem_cur_size += malloc_usable_size(ptr1);
1186 if (mem_cur_size > mem_max_size)
1187 mem_max_size = mem_cur_size;
1188 #endif
1189 return ptr1;
1190 }
1191
1192 static char *tcc_strdup(const char *str)
1193 {
1194 char *ptr;
1195 ptr = tcc_malloc(strlen(str) + 1);
1196 strcpy(ptr, str);
1197 return ptr;
1198 }
1199
1200 #define free(p) use_tcc_free(p)
1201 #define malloc(s) use_tcc_malloc(s)
1202 #define realloc(p, s) use_tcc_realloc(p, s)
1203
1204 static void dynarray_add(void ***ptab, int *nb_ptr, void *data)
1205 {
1206 int nb, nb_alloc;
1207 void **pp;
1208
1209 nb = *nb_ptr;
1210 pp = *ptab;
1211 /* every power of two we double array size */
1212 if ((nb & (nb - 1)) == 0) {
1213 if (!nb)
1214 nb_alloc = 1;
1215 else
1216 nb_alloc = nb * 2;
1217 pp = tcc_realloc(pp, nb_alloc * sizeof(void *));
1218 if (!pp)
1219 error("memory full");
1220 *ptab = pp;
1221 }
1222 pp[nb++] = data;
1223 *nb_ptr = nb;
1224 }
1225
1226 static void dynarray_reset(void *pp, int *n)
1227 {
1228 void **p;
1229 for (p = *(void***)pp; *n; ++p, --*n)
1230 if (*p)
1231 tcc_free(*p);
1232 tcc_free(*(void**)pp);
1233 *(void**)pp = NULL;
1234 }
1235
1236 /* symbol allocator */
1237 static Sym *__sym_malloc(void)
1238 {
1239 Sym *sym_pool, *sym, *last_sym;
1240 int i;
1241
1242 sym_pool = tcc_malloc(SYM_POOL_NB * sizeof(Sym));
1243 dynarray_add(&sym_pools, &nb_sym_pools, sym_pool);
1244
1245 last_sym = sym_free_first;
1246 sym = sym_pool;
1247 for(i = 0; i < SYM_POOL_NB; i++) {
1248 sym->next = last_sym;
1249 last_sym = sym;
1250 sym++;
1251 }
1252 sym_free_first = last_sym;
1253 return last_sym;
1254 }
1255
1256 static inline Sym *sym_malloc(void)
1257 {
1258 Sym *sym;
1259 sym = sym_free_first;
1260 if (!sym)
1261 sym = __sym_malloc();
1262 sym_free_first = sym->next;
1263 return sym;
1264 }
1265
1266 static inline void sym_free(Sym *sym)
1267 {
1268 sym->next = sym_free_first;
1269 sym_free_first = sym;
1270 }
1271
1272 Section *new_section(TCCState *s1, const char *name, int sh_type, int sh_flags)
1273 {
1274 Section *sec;
1275
1276 sec = tcc_mallocz(sizeof(Section) + strlen(name));
1277 strcpy(sec->name, name);
1278 sec->sh_type = sh_type;
1279 sec->sh_flags = sh_flags;
1280 switch(sh_type) {
1281 case SHT_HASH:
1282 case SHT_REL:
1283 case SHT_RELA:
1284 case SHT_DYNSYM:
1285 case SHT_SYMTAB:
1286 case SHT_DYNAMIC:
1287 sec->sh_addralign = 4;
1288 break;
1289 case SHT_STRTAB:
1290 sec->sh_addralign = 1;
1291 break;
1292 default:
1293 sec->sh_addralign = 32; /* default conservative alignment */
1294 break;
1295 }
1296
1297 if (sh_flags & SHF_PRIVATE) {
1298 dynarray_add((void ***)&s1->priv_sections, &s1->nb_priv_sections, sec);
1299 } else {
1300 sec->sh_num = s1->nb_sections;
1301 dynarray_add((void ***)&s1->sections, &s1->nb_sections, sec);
1302 }
1303
1304 return sec;
1305 }
1306
1307 static void free_section(Section *s)
1308 {
1309 #ifdef TCC_TARGET_X86_64
1310 /* after tcc_relocate(), some sections share the data buffer.
1311 let's check if the data is allocated not to free the shared buffers */
1312 if (s->data_allocated)
1313 #endif
1314 tcc_free(s->data);
1315 }
1316
1317 /* realloc section and set its content to zero */
1318 static void section_realloc(Section *sec, unsigned long new_size)
1319 {
1320 unsigned long size;
1321 unsigned char *data;
1322
1323 size = sec->data_allocated;
1324 if (size == 0)
1325 size = 1;
1326 while (size < new_size)
1327 size = size * 2;
1328 data = tcc_realloc(sec->data, size);
1329 if (!data)
1330 error("memory full");
1331 memset(data + sec->data_allocated, 0, size - sec->data_allocated);
1332 sec->data = data;
1333 sec->data_allocated = size;
1334 }
1335
1336 /* reserve at least 'size' bytes in section 'sec' from
1337 sec->data_offset. */
1338 static void *section_ptr_add(Section *sec, unsigned long size)
1339 {
1340 unsigned long offset, offset1;
1341
1342 offset = sec->data_offset;
1343 offset1 = offset + size;
1344 if (offset1 > sec->data_allocated)
1345 section_realloc(sec, offset1);
1346 sec->data_offset = offset1;
1347 return sec->data + offset;
1348 }
1349
1350 /* return a reference to a section, and create it if it does not
1351 exists */
1352 Section *find_section(TCCState *s1, const char *name)
1353 {
1354 Section *sec;
1355 int i;
1356 for(i = 1; i < s1->nb_sections; i++) {
1357 sec = s1->sections[i];
1358 if (!strcmp(name, sec->name))
1359 return sec;
1360 }
1361 /* sections are created as PROGBITS */
1362 return new_section(s1, name, SHT_PROGBITS, SHF_ALLOC);
1363 }
1364
1365 #define SECTION_ABS ((void *)1)
1366
1367 /* update sym->c so that it points to an external symbol in section
1368 'section' with value 'value' */
1369 static void put_extern_sym2(Sym *sym, Section *section,
1370 unsigned long value, unsigned long size,
1371 int can_add_underscore)
1372 {
1373 int sym_type, sym_bind, sh_num, info, other, attr;
1374 ElfW(Sym) *esym;
1375 const char *name;
1376 char buf1[256];
1377
1378 if (section == NULL)
1379 sh_num = SHN_UNDEF;
1380 else if (section == SECTION_ABS)
1381 sh_num = SHN_ABS;
1382 else
1383 sh_num = section->sh_num;
1384
1385 other = attr = 0;
1386
1387 if ((sym->type.t & VT_BTYPE) == VT_FUNC) {
1388 sym_type = STT_FUNC;
1389 #ifdef TCC_TARGET_PE
1390 if (sym->type.ref)
1391 attr = sym->type.ref->r;
1392 if (FUNC_EXPORT(attr))
1393 other |= 1;
1394 if (FUNC_CALL(attr) == FUNC_STDCALL)
1395 other |= 2;
1396 #endif
1397 } else {
1398 sym_type = STT_OBJECT;
1399 }
1400
1401 if (sym->type.t & VT_STATIC)
1402 sym_bind = STB_LOCAL;
1403 else
1404 sym_bind = STB_GLOBAL;
1405
1406 if (!sym->c) {
1407 name = get_tok_str(sym->v, NULL);
1408 #ifdef CONFIG_TCC_BCHECK
1409 if (do_bounds_check) {
1410 char buf[32];
1411
1412 /* XXX: avoid doing that for statics ? */
1413 /* if bound checking is activated, we change some function
1414 names by adding the "__bound" prefix */
1415 switch(sym->v) {
1416 #if 0
1417 /* XXX: we rely only on malloc hooks */
1418 case TOK_malloc:
1419 case TOK_free:
1420 case TOK_realloc:
1421 case TOK_memalign:
1422 case TOK_calloc:
1423 #endif
1424 case TOK_memcpy:
1425 case TOK_memmove:
1426 case TOK_memset:
1427 case TOK_strlen:
1428 case TOK_strcpy:
1429 case TOK__alloca:
1430 strcpy(buf, "__bound_");
1431 strcat(buf, name);
1432 name = buf;
1433 break;
1434 }
1435 }
1436 #endif
1437
1438 #ifdef TCC_TARGET_PE
1439 if ((other & 2) && can_add_underscore) {
1440 sprintf(buf1, "_%s@%d", name, FUNC_ARGS(attr));
1441 name = buf1;
1442 } else
1443 #endif
1444 if (tcc_state->leading_underscore && can_add_underscore) {
1445 buf1[0] = '_';
1446 pstrcpy(buf1 + 1, sizeof(buf1) - 1, name);
1447 name = buf1;
1448 }
1449 info = ELFW(ST_INFO)(sym_bind, sym_type);
1450 sym->c = add_elf_sym(symtab_section, value, size, info, other, sh_num, name);
1451 } else {
1452 esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
1453 esym->st_value = value;
1454 esym->st_size = size;
1455 esym->st_shndx = sh_num;
1456 esym->st_other |= other;
1457 }
1458 }
1459
1460 static void put_extern_sym(Sym *sym, Section *section,
1461 unsigned long value, unsigned long size)
1462 {
1463 put_extern_sym2(sym, section, value, size, 1);
1464 }
1465
1466 /* add a new relocation entry to symbol 'sym' in section 's' */
1467 static void greloc(Section *s, Sym *sym, unsigned long offset, int type)
1468 {
1469 if (!sym->c)
1470 put_extern_sym(sym, NULL, 0, 0);
1471 /* now we can add ELF relocation info */
1472 put_elf_reloc(symtab_section, s, offset, type, sym->c);
1473 }
1474
1475 static inline int isid(int c)
1476 {
1477 return (c >= 'a' && c <= 'z') ||
1478 (c >= 'A' && c <= 'Z') ||
1479 c == '_';
1480 }
1481
1482 static inline int isnum(int c)
1483 {
1484 return c >= '0' && c <= '9';
1485 }
1486
1487 static inline int isoct(int c)
1488 {
1489 return c >= '0' && c <= '7';
1490 }
1491
1492 static inline int toup(int c)
1493 {
1494 if (c >= 'a' && c <= 'z')
1495 return c - 'a' + 'A';
1496 else
1497 return c;
1498 }
1499
1500 static void strcat_vprintf(char *buf, int buf_size, const char *fmt, va_list ap)
1501 {
1502 int len;
1503 len = strlen(buf);
1504 vsnprintf(buf + len, buf_size - len, fmt, ap);
1505 }
1506
1507 static void strcat_printf(char *buf, int buf_size, const char *fmt, ...)
1508 {
1509 va_list ap;
1510 va_start(ap, fmt);
1511 strcat_vprintf(buf, buf_size, fmt, ap);
1512 va_end(ap);
1513 }
1514
1515 void error1(TCCState *s1, int is_warning, const char *fmt, va_list ap)
1516 {
1517 char buf[2048];
1518 BufferedFile **f;
1519
1520 buf[0] = '\0';
1521 if (file) {
1522 for(f = s1->include_stack; f < s1->include_stack_ptr; f++)
1523 strcat_printf(buf, sizeof(buf), "In file included from %s:%d:\n",
1524 (*f)->filename, (*f)->line_num);
1525 if (file->line_num > 0) {
1526 strcat_printf(buf, sizeof(buf),
1527 "%s:%d: ", file->filename, file->line_num);
1528 } else {
1529 strcat_printf(buf, sizeof(buf),
1530 "%s: ", file->filename);
1531 }
1532 } else {
1533 strcat_printf(buf, sizeof(buf),
1534 "tcc: ");
1535 }
1536 if (is_warning)
1537 strcat_printf(buf, sizeof(buf), "warning: ");
1538 strcat_vprintf(buf, sizeof(buf), fmt, ap);
1539
1540 if (!s1->error_func) {
1541 /* default case: stderr */
1542 fprintf(stderr, "%s\n", buf);
1543 } else {
1544 s1->error_func(s1->error_opaque, buf);
1545 }
1546 if (!is_warning || s1->warn_error)
1547 s1->nb_errors++;
1548 }
1549
1550 #ifdef LIBTCC
1551 void tcc_set_error_func(TCCState *s, void *error_opaque,
1552 void (*error_func)(void *opaque, const char *msg))
1553 {
1554 s->error_opaque = error_opaque;
1555 s->error_func = error_func;
1556 }
1557 #endif
1558
1559 /* error without aborting current compilation */
1560 void error_noabort(const char *fmt, ...)
1561 {
1562 TCCState *s1 = tcc_state;
1563 va_list ap;
1564
1565 va_start(ap, fmt);
1566 error1(s1, 0, fmt, ap);
1567 va_end(ap);
1568 }
1569
1570 void error(const char *fmt, ...)
1571 {
1572 TCCState *s1 = tcc_state;
1573 va_list ap;
1574
1575 va_start(ap, fmt);
1576 error1(s1, 0, fmt, ap);
1577 va_end(ap);
1578 /* better than nothing: in some cases, we accept to handle errors */
1579 if (s1->error_set_jmp_enabled) {
1580 longjmp(s1->error_jmp_buf, 1);
1581 } else {
1582 /* XXX: eliminate this someday */
1583 exit(1);
1584 }
1585 }
1586
1587 void expect(const char *msg)
1588 {
1589 error("%s expected", msg);
1590 }
1591
1592 void warning(const char *fmt, ...)
1593 {
1594 TCCState *s1 = tcc_state;
1595 va_list ap;
1596
1597 if (s1->warn_none)
1598 return;
1599
1600 va_start(ap, fmt);
1601 error1(s1, 1, fmt, ap);
1602 va_end(ap);
1603 }
1604
1605 void skip(int c)
1606 {
1607 if (tok != c)
1608 error("'%c' expected", c);
1609 next();
1610 }
1611
1612 static void test_lvalue(void)
1613 {
1614 if (!(vtop->r & VT_LVAL))
1615 expect("lvalue");
1616 }
1617
1618 /* allocate a new token */
1619 static TokenSym *tok_alloc_new(TokenSym **pts, const char *str, int len)
1620 {
1621 TokenSym *ts, **ptable;
1622 int i;
1623
1624 if (tok_ident >= SYM_FIRST_ANOM)
1625 error("memory full");
1626
1627 /* expand token table if needed */
1628 i = tok_ident - TOK_IDENT;
1629 if ((i % TOK_ALLOC_INCR) == 0) {
1630 ptable = tcc_realloc(table_ident, (i + TOK_ALLOC_INCR) * sizeof(TokenSym *));
1631 if (!ptable)
1632 error("memory full");
1633 table_ident = ptable;
1634 }
1635
1636 ts = tcc_malloc(sizeof(TokenSym) + len);
1637 table_ident[i] = ts;
1638 ts->tok = tok_ident++;
1639 ts->sym_define = NULL;
1640 ts->sym_label = NULL;
1641 ts->sym_struct = NULL;
1642 ts->sym_identifier = NULL;
1643 ts->len = len;
1644 ts->hash_next = NULL;
1645 memcpy(ts->str, str, len);
1646 ts->str[len] = '\0';
1647 *pts = ts;
1648 return ts;
1649 }
1650
1651 #define TOK_HASH_INIT 1
1652 #define TOK_HASH_FUNC(h, c) ((h) * 263 + (c))
1653
1654 /* find a token and add it if not found */
1655 static TokenSym *tok_alloc(const char *str, int len)
1656 {
1657 TokenSym *ts, **pts;
1658 int i;
1659 unsigned int h;
1660
1661 h = TOK_HASH_INIT;
1662 for(i=0;i<len;i++)
1663 h = TOK_HASH_FUNC(h, ((unsigned char *)str)[i]);
1664 h &= (TOK_HASH_SIZE - 1);
1665
1666 pts = &hash_ident[h];
1667 for(;;) {
1668 ts = *pts;
1669 if (!ts)
1670 break;
1671 if (ts->len == len && !memcmp(ts->str, str, len))
1672 return ts;
1673 pts = &(ts->hash_next);
1674 }
1675 return tok_alloc_new(pts, str, len);
1676 }
1677
1678 /* CString handling */
1679
1680 static void cstr_realloc(CString *cstr, int new_size)
1681 {
1682 int size;
1683 void *data;
1684
1685 size = cstr->size_allocated;
1686 if (size == 0)
1687 size = 8; /* no need to allocate a too small first string */
1688 while (size < new_size)
1689 size = size * 2;
1690 data = tcc_realloc(cstr->data_allocated, size);
1691 if (!data)
1692 error("memory full");
1693 cstr->data_allocated = data;
1694 cstr->size_allocated = size;
1695 cstr->data = data;
1696 }
1697
1698 /* add a byte */
1699 static inline void cstr_ccat(CString *cstr, int ch)
1700 {
1701 int size;
1702 size = cstr->size + 1;
1703 if (size > cstr->size_allocated)
1704 cstr_realloc(cstr, size);
1705 ((unsigned char *)cstr->data)[size - 1] = ch;
1706 cstr->size = size;
1707 }
1708
1709 static void cstr_cat(CString *cstr, const char *str)
1710 {
1711 int c;
1712 for(;;) {
1713 c = *str;
1714 if (c == '\0')
1715 break;
1716 cstr_ccat(cstr, c);
1717 str++;
1718 }
1719 }
1720
1721 /* add a wide char */
1722 static void cstr_wccat(CString *cstr, int ch)
1723 {
1724 int size;
1725 size = cstr->size + sizeof(nwchar_t);
1726 if (size > cstr->size_allocated)
1727 cstr_realloc(cstr, size);
1728 *(nwchar_t *)(((unsigned char *)cstr->data) + size - sizeof(nwchar_t)) = ch;
1729 cstr->size = size;
1730 }
1731
1732 static void cstr_new(CString *cstr)
1733 {
1734 memset(cstr, 0, sizeof(CString));
1735 }
1736
1737 /* free string and reset it to NULL */
1738 static void cstr_free(CString *cstr)
1739 {
1740 tcc_free(cstr->data_allocated);
1741 cstr_new(cstr);
1742 }
1743
1744 #define cstr_reset(cstr) cstr_free(cstr)
1745
1746 /* XXX: unicode ? */
1747 static void add_char(CString *cstr, int c)
1748 {
1749 if (c == '\'' || c == '\"' || c == '\\') {
1750 /* XXX: could be more precise if char or string */
1751 cstr_ccat(cstr, '\\');
1752 }
1753 if (c >= 32 && c <= 126) {
1754 cstr_ccat(cstr, c);
1755 } else {
1756 cstr_ccat(cstr, '\\');
1757 if (c == '\n') {
1758 cstr_ccat(cstr, 'n');
1759 } else {
1760 cstr_ccat(cstr, '0' + ((c >> 6) & 7));
1761 cstr_ccat(cstr, '0' + ((c >> 3) & 7));
1762 cstr_ccat(cstr, '0' + (c & 7));
1763 }
1764 }
1765 }
1766
1767 /* XXX: buffer overflow */
1768 /* XXX: float tokens */
1769 char *get_tok_str(int v, CValue *cv)
1770 {
1771 static char buf[STRING_MAX_SIZE + 1];
1772 static CString cstr_buf;
1773 CString *cstr;
1774 unsigned char *q;
1775 char *p;
1776 int i, len;
1777
1778 /* NOTE: to go faster, we give a fixed buffer for small strings */
1779 cstr_reset(&cstr_buf);
1780 cstr_buf.data = buf;
1781 cstr_buf.size_allocated = sizeof(buf);
1782 p = buf;
1783
1784 switch(v) {
1785 case TOK_CINT:
1786 case TOK_CUINT:
1787 /* XXX: not quite exact, but only useful for testing */
1788 sprintf(p, "%u", cv->ui);
1789 break;
1790 case TOK_CLLONG:
1791 case TOK_CULLONG:
1792 /* XXX: not quite exact, but only useful for testing */
1793 sprintf(p, "%Lu", cv->ull);
1794 break;
1795 case TOK_LCHAR:
1796 cstr_ccat(&cstr_buf, 'L');
1797 case TOK_CCHAR:
1798 cstr_ccat(&cstr_buf, '\'');
1799 add_char(&cstr_buf, cv->i);
1800 cstr_ccat(&cstr_buf, '\'');
1801 cstr_ccat(&cstr_buf, '\0');
1802 break;
1803 case TOK_PPNUM:
1804 cstr = cv->cstr;
1805 len = cstr->size - 1;
1806 for(i=0;i<len;i++)
1807 add_char(&cstr_buf, ((unsigned char *)cstr->data)[i]);
1808 cstr_ccat(&cstr_buf, '\0');
1809 break;
1810 case TOK_LSTR:
1811 cstr_ccat(&cstr_buf, 'L');
1812 case TOK_STR:
1813 cstr = cv->cstr;
1814 cstr_ccat(&cstr_buf, '\"');
1815 if (v == TOK_STR) {
1816 len = cstr->size - 1;
1817 for(i=0;i<len;i++)
1818 add_char(&cstr_buf, ((unsigned char *)cstr->data)[i]);
1819 } else {
1820 len = (cstr->size / sizeof(nwchar_t)) - 1;
1821 for(i=0;i<len;i++)
1822 add_char(&cstr_buf, ((nwchar_t *)cstr->data)[i]);
1823 }
1824 cstr_ccat(&cstr_buf, '\"');
1825 cstr_ccat(&cstr_buf, '\0');
1826 break;
1827 case TOK_LT:
1828 v = '<';
1829 goto addv;
1830 case TOK_GT:
1831 v = '>';
1832 goto addv;
1833 case TOK_DOTS:
1834 return strcpy(p, "...");
1835 case TOK_A_SHL:
1836 return strcpy(p, "<<=");
1837 case TOK_A_SAR:
1838 return strcpy(p, ">>=");
1839 default:
1840 if (v < TOK_IDENT) {
1841 /* search in two bytes table */
1842 q = tok_two_chars;
1843 while (*q) {
1844 if (q[2] == v) {
1845 *p++ = q[0];
1846 *p++ = q[1];
1847 *p = '\0';
1848 return buf;
1849 }
1850 q += 3;
1851 }
1852 addv:
1853 *p++ = v;
1854 *p = '\0';
1855 } else if (v < tok_ident) {
1856 return table_ident[v - TOK_IDENT]->str;
1857 } else if (v >= SYM_FIRST_ANOM) {
1858 /* special name for anonymous symbol */
1859 sprintf(p, "L.%u", v - SYM_FIRST_ANOM);
1860 } else {
1861 /* should never happen */
1862 return NULL;
1863 }
1864 break;
1865 }
1866 return cstr_buf.data;
1867 }
1868
1869 /* push, without hashing */
1870 static Sym *sym_push2(Sym **ps, int v, int t, long c)
1871 {
1872 Sym *s;
1873 s = sym_malloc();
1874 s->v = v;
1875 s->type.t = t;
1876 s->c = c;
1877 s->next = NULL;
1878 /* add in stack */
1879 s->prev = *ps;
1880 *ps = s;
1881 return s;
1882 }
1883
1884 /* find a symbol and return its associated structure. 's' is the top
1885 of the symbol stack */
1886 static Sym *sym_find2(Sym *s, int v)
1887 {
1888 while (s) {
1889 if (s->v == v)
1890 return s;
1891 s = s->prev;
1892 }
1893 return NULL;
1894 }
1895
1896 /* structure lookup */
1897 static inline Sym *struct_find(int v)
1898 {
1899 v -= TOK_IDENT;
1900 if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
1901 return NULL;
1902 return table_ident[v]->sym_struct;
1903 }
1904
1905 /* find an identifier */
1906 static inline Sym *sym_find(int v)
1907 {
1908 v -= TOK_IDENT;
1909 if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
1910 return NULL;
1911 return table_ident[v]->sym_identifier;
1912 }
1913
1914 /* push a given symbol on the symbol stack */
1915 static Sym *sym_push(int v, CType *type, int r, int c)
1916 {
1917 Sym *s, **ps;
1918 TokenSym *ts;
1919
1920 if (local_stack)
1921 ps = &local_stack;
1922 else
1923 ps = &global_stack;
1924 s = sym_push2(ps, v, type->t, c);
1925 s->type.ref = type->ref;
1926 s->r = r;
1927 /* don't record fields or anonymous symbols */
1928 /* XXX: simplify */
1929 if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
1930 /* record symbol in token array */
1931 ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT];
1932 if (v & SYM_STRUCT)
1933 ps = &ts->sym_struct;
1934 else
1935 ps = &ts->sym_identifier;
1936 s->prev_tok = *ps;
1937 *ps = s;
1938 }
1939 return s;
1940 }
1941
1942 /* push a global identifier */
1943 static Sym *global_identifier_push(int v, int t, int c)
1944 {
1945 Sym *s, **ps;
1946 s = sym_push2(&global_stack, v, t, c);
1947 /* don't record anonymous symbol */
1948 if (v < SYM_FIRST_ANOM) {
1949 ps = &table_ident[v - TOK_IDENT]->sym_identifier;
1950 /* modify the top most local identifier, so that
1951 sym_identifier will point to 's' when popped */
1952 while (*ps != NULL)
1953 ps = &(*ps)->prev_tok;
1954 s->prev_tok = NULL;
1955 *ps = s;
1956 }
1957 return s;
1958 }
1959
1960 /* pop symbols until top reaches 'b' */
1961 static void sym_pop(Sym **ptop, Sym *b)
1962 {
1963 Sym *s, *ss, **ps;
1964 TokenSym *ts;
1965 int v;
1966
1967 s = *ptop;
1968 while(s != b) {
1969 ss = s->prev;
1970 v = s->v;
1971 /* remove symbol in token array */
1972 /* XXX: simplify */
1973 if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
1974 ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT];
1975 if (v & SYM_STRUCT)
1976 ps = &ts->sym_struct;
1977 else
1978 ps = &ts->sym_identifier;
1979 *ps = s->prev_tok;
1980 }
1981 sym_free(s);
1982 s = ss;
1983 }
1984 *ptop = b;
1985 }
1986
1987 /* I/O layer */
1988
1989 BufferedFile *tcc_open(TCCState *s1, const char *filename)
1990 {
1991 int fd;
1992 BufferedFile *bf;
1993
1994 if (strcmp(filename, "-") == 0)
1995 fd = 0, filename = "stdin";
1996 else
1997 fd = open(filename, O_RDONLY | O_BINARY);
1998 if ((verbose == 2 && fd >= 0) || verbose == 3)
1999 printf("%s %*s%s\n", fd < 0 ? "nf":"->",
2000 (s1->include_stack_ptr - s1->include_stack), "", filename);
2001 if (fd < 0)
2002 return NULL;
2003 bf = tcc_malloc(sizeof(BufferedFile));
2004 bf->fd = fd;
2005 bf->buf_ptr = bf->buffer;
2006 bf->buf_end = bf->buffer;
2007 bf->buffer[0] = CH_EOB; /* put eob symbol */
2008 pstrcpy(bf->filename, sizeof(bf->filename), filename);
2009 #ifdef _WIN32
2010 normalize_slashes(bf->filename);
2011 #endif
2012 bf->line_num = 1;
2013 bf->ifndef_macro = 0;
2014 bf->ifdef_stack_ptr = s1->ifdef_stack_ptr;
2015 // printf("opening '%s'\n", filename);
2016 return bf;
2017 }
2018
2019 void tcc_close(BufferedFile *bf)
2020 {
2021 total_lines += bf->line_num;
2022 close(bf->fd);
2023 tcc_free(bf);
2024 }
2025
2026 /* fill input buffer and peek next char */
2027 static int tcc_peekc_slow(BufferedFile *bf)
2028 {
2029 int len;
2030 /* only tries to read if really end of buffer */
2031 if (bf->buf_ptr >= bf->buf_end) {
2032 if (bf->fd != -1) {
2033 #if defined(PARSE_DEBUG)
2034 len = 8;
2035 #else
2036 len = IO_BUF_SIZE;
2037 #endif
2038 len = read(bf->fd, bf->buffer, len);
2039 if (len < 0)
2040 len = 0;
2041 } else {
2042 len = 0;
2043 }
2044 total_bytes += len;
2045 bf->buf_ptr = bf->buffer;
2046 bf->buf_end = bf->buffer + len;
2047 *bf->buf_end = CH_EOB;
2048 }
2049 if (bf->buf_ptr < bf->buf_end) {
2050 return bf->buf_ptr[0];
2051 } else {
2052 bf->buf_ptr = bf->buf_end;
2053 return CH_EOF;
2054 }
2055 }
2056
2057 /* return the current character, handling end of block if necessary
2058 (but not stray) */
2059 static int handle_eob(void)
2060 {
2061 return tcc_peekc_slow(file);
2062 }
2063
2064 /* read next char from current input file and handle end of input buffer */
2065 static inline void inp(void)
2066 {
2067 ch = *(++(file->buf_ptr));
2068 /* end of buffer/file handling */
2069 if (ch == CH_EOB)
2070 ch = handle_eob();
2071 }
2072
2073 /* handle '\[\r]\n' */
2074 static int handle_stray_noerror(void)
2075 {
2076 while (ch == '\\') {
2077 inp();
2078 if (ch == '\n') {
2079 file->line_num++;
2080 inp();
2081 } else if (ch == '\r') {
2082 inp();
2083 if (ch != '\n')
2084 goto fail;
2085 file->line_num++;
2086 inp();
2087 } else {
2088 fail:
2089 return 1;
2090 }
2091 }
2092 return 0;
2093 }
2094
2095 static void handle_stray(void)
2096 {
2097 if (handle_stray_noerror())
2098 error("stray '\\' in program");
2099 }
2100
2101 /* skip the stray and handle the \\n case. Output an error if
2102 incorrect char after the stray */
2103 static int handle_stray1(uint8_t *p)
2104 {
2105 int c;
2106
2107 if (p >= file->buf_end) {
2108 file->buf_ptr = p;
2109 c = handle_eob();
2110 p = file->buf_ptr;
2111 if (c == '\\')
2112 goto parse_stray;
2113 } else {
2114 parse_stray:
2115 file->buf_ptr = p;
2116 ch = *p;
2117 handle_stray();
2118 p = file->buf_ptr;
2119 c = *p;
2120 }
2121 return c;
2122 }
2123
2124 /* handle just the EOB case, but not stray */
2125 #define PEEKC_EOB(c, p)\
2126 {\
2127 p++;\
2128 c = *p;\
2129 if (c == '\\') {\
2130 file->buf_ptr = p;\
2131 c = handle_eob();\
2132 p = file->buf_ptr;\
2133 }\
2134 }
2135
2136 /* handle the complicated stray case */
2137 #define PEEKC(c, p)\
2138 {\
2139 p++;\
2140 c = *p;\
2141 if (c == '\\') {\
2142 c = handle_stray1(p);\
2143 p = file->buf_ptr;\
2144 }\
2145 }
2146
2147 /* input with '\[\r]\n' handling. Note that this function cannot
2148 handle other characters after '\', so you cannot call it inside
2149 strings or comments */
2150 static void minp(void)
2151 {
2152 inp();
2153 if (ch == '\\')
2154 handle_stray();
2155 }
2156
2157
2158 /* single line C++ comments */
2159 static uint8_t *parse_line_comment(uint8_t *p)
2160 {
2161 int c;
2162
2163 p++;
2164 for(;;) {
2165 c = *p;
2166 redo:
2167 if (c == '\n' || c == CH_EOF) {
2168 break;
2169 } else if (c == '\\') {
2170 file->buf_ptr = p;
2171 c = handle_eob();
2172 p = file->buf_ptr;
2173 if (c == '\\') {
2174 PEEKC_EOB(c, p);
2175 if (c == '\n') {
2176 file->line_num++;
2177 PEEKC_EOB(c, p);
2178 } else if (c == '\r') {
2179 PEEKC_EOB(c, p);
2180 if (c == '\n') {
2181 file->line_num++;
2182 PEEKC_EOB(c, p);
2183 }
2184 }
2185 } else {
2186 goto redo;
2187 }
2188 } else {
2189 p++;
2190 }
2191 }
2192 return p;
2193 }
2194
2195 /* C comments */
2196 static uint8_t *parse_comment(uint8_t *p)
2197 {
2198 int c;
2199
2200 p++;
2201 for(;;) {
2202 /* fast skip loop */
2203 for(;;) {
2204 c = *p;
2205 if (c == '\n' || c == '*' || c == '\\')
2206 break;
2207 p++;
2208 c = *p;
2209 if (c == '\n' || c == '*' || c == '\\')
2210 break;
2211 p++;
2212 }
2213 /* now we can handle all the cases */
2214 if (c == '\n') {
2215 file->line_num++;
2216 p++;
2217 } else if (c == '*') {
2218 p++;
2219 for(;;) {
2220 c = *p;
2221 if (c == '*') {
2222 p++;
2223 } else if (c == '/') {
2224 goto end_of_comment;
2225 } else if (c == '\\') {
2226 file->buf_ptr = p;
2227 c = handle_eob();
2228 p = file->buf_ptr;
2229 if (c == '\\') {
2230 /* skip '\[\r]\n', otherwise just skip the stray */
2231 while (c == '\\') {
2232 PEEKC_EOB(c, p);
2233 if (c == '\n') {
2234 file->line_num++;
2235 PEEKC_EOB(c, p);
2236 } else if (c == '\r') {
2237 PEEKC_EOB(c, p);
2238 if (c == '\n') {
2239 file->line_num++;
2240 PEEKC_EOB(c, p);
2241 }
2242 } else {
2243 goto after_star;
2244 }
2245 }
2246 }
2247 } else {
2248 break;
2249 }
2250 }
2251 after_star: ;
2252 } else {
2253 /* stray, eob or eof */
2254 file->buf_ptr = p;
2255 c = handle_eob();
2256 p = file->buf_ptr;
2257 if (c == CH_EOF) {
2258 error("unexpected end of file in comment");
2259 } else if (c == '\\') {
2260 p++;
2261 }
2262 }
2263 }
2264 end_of_comment:
2265 p++;
2266 return p;
2267 }
2268
2269 #define cinp minp
2270
2271 /* space exlcuding newline */
2272 static inline int is_space(int ch)
2273 {
2274 return ch == ' ' || ch == '\t' || ch == '\v' || ch == '\f' || ch == '\r';
2275 }
2276
2277 static inline void skip_spaces(void)
2278 {
2279 while (is_space(ch))
2280 cinp();
2281 }
2282
2283 /* parse a string without interpreting escapes */
2284 static uint8_t *parse_pp_string(uint8_t *p,
2285 int sep, CString *str)
2286 {
2287 int c;
2288 p++;
2289 for(;;) {
2290 c = *p;
2291 if (c == sep) {
2292 break;
2293 } else if (c == '\\') {
2294 file->buf_ptr = p;
2295 c = handle_eob();
2296 p = file->buf_ptr;
2297 if (c == CH_EOF) {
2298 unterminated_string:
2299 /* XXX: indicate line number of start of string */
2300 error("missing terminating %c character", sep);
2301 } else if (c == '\\') {
2302 /* escape : just skip \[\r]\n */
2303 PEEKC_EOB(c, p);
2304 if (c == '\n') {
2305 file->line_num++;
2306 p++;
2307 } else if (c == '\r') {
2308 PEEKC_EOB(c, p);
2309 if (c != '\n')
2310 expect("'\n' after '\r'");
2311 file->line_num++;
2312 p++;
2313 } else if (c == CH_EOF) {
2314 goto unterminated_string;
2315 } else {
2316 if (str) {
2317 cstr_ccat(str, '\\');
2318 cstr_ccat(str, c);
2319 }
2320 p++;
2321 }
2322 }
2323 } else if (c == '\n') {
2324 file->line_num++;
2325 goto add_char;
2326 } else if (c == '\r') {
2327 PEEKC_EOB(c, p);
2328 if (c != '\n') {
2329 if (str)
2330 cstr_ccat(str, '\r');
2331 } else {
2332 file->line_num++;
2333 goto add_char;
2334 }
2335 } else {
2336 add_char:
2337 if (str)
2338 cstr_ccat(str, c);
2339 p++;
2340 }
2341 }
2342 p++;
2343 return p;
2344 }
2345
2346 /* skip block of text until #else, #elif or #endif. skip also pairs of
2347 #if/#endif */
2348 void preprocess_skip(void)
2349 {
2350 int a, start_of_line, c, in_warn_or_error;
2351 uint8_t *p;
2352
2353 p = file->buf_ptr;
2354 a = 0;
2355 redo_start:
2356 start_of_line = 1;
2357 in_warn_or_error = 0;
2358 for(;;) {
2359 redo_no_start:
2360 c = *p;
2361 switch(c) {
2362 case ' ':
2363 case '\t':
2364 case '\f':
2365 case '\v':
2366 case '\r':
2367 p++;
2368 goto redo_no_start;
2369 case '\n':
2370 file->line_num++;
2371 p++;
2372 goto redo_start;
2373 case '\\':
2374 file->buf_ptr = p;
2375 c = handle_eob();
2376 if (c == CH_EOF) {
2377 expect("#endif");
2378 } else if (c == '\\') {
2379 ch = file->buf_ptr[0];
2380 handle_stray_noerror();
2381 }
2382 p = file->buf_ptr;
2383 goto redo_no_start;
2384 /* skip strings */
2385 case '\"':
2386 case '\'':
2387 if (in_warn_or_error)
2388 goto _default;
2389 p = parse_pp_string(p, c, NULL);
2390 break;
2391 /* skip comments */
2392 case '/':
2393 if (in_warn_or_error)
2394 goto _default;
2395 file->buf_ptr = p;
2396 ch = *p;
2397 minp();
2398 p = file->buf_ptr;
2399 if (ch == '*') {
2400 p = parse_comment(p);
2401 } else if (ch == '/') {
2402 p = parse_line_comment(p);
2403 }
2404 break;
2405 case '#':
2406 p++;
2407 if (start_of_line) {
2408 file->buf_ptr = p;
2409 next_nomacro();
2410 p = file->buf_ptr;
2411 if (a == 0 &&
2412 (tok == TOK_ELSE || tok == TOK_ELIF || tok == TOK_ENDIF))
2413 goto the_end;
2414 if (tok == TOK_IF || tok == TOK_IFDEF || tok == TOK_IFNDEF)
2415 a++;
2416 else if (tok == TOK_ENDIF)
2417 a--;
2418 else if( tok == TOK_ERROR || tok == TOK_WARNING)
2419 in_warn_or_error = 1;
2420 }
2421 break;
2422 _default:
2423 default:
2424 p++;
2425 break;
2426 }
2427 start_of_line = 0;
2428 }
2429 the_end: ;
2430 file->buf_ptr = p;
2431 }
2432
2433 /* ParseState handling */
2434
2435 /* XXX: currently, no include file info is stored. Thus, we cannot display
2436 accurate messages if the function or data definition spans multiple
2437 files */
2438
2439 /* save current parse state in 's' */
2440 void save_parse_state(ParseState *s)
2441 {
2442 s->line_num = file->line_num;
2443 s->macro_ptr = macro_ptr;
2444 s->tok = tok;
2445 s->tokc = tokc;
2446 }
2447
2448 /* restore parse state from 's' */
2449 void restore_parse_state(ParseState *s)
2450 {
2451 file->line_num = s->line_num;
2452 macro_ptr = s->macro_ptr;
2453 tok = s->tok;
2454 tokc = s->tokc;
2455 }
2456
2457 /* return the number of additional 'ints' necessary to store the
2458 token */
2459 static inline int tok_ext_size(int t)
2460 {
2461 switch(t) {
2462 /* 4 bytes */
2463 case TOK_CINT:
2464 case TOK_CUINT:
2465 case TOK_CCHAR:
2466 case TOK_LCHAR:
2467 case TOK_CFLOAT:
2468 case TOK_LINENUM:
2469 return 1;
2470 case TOK_STR:
2471 case TOK_LSTR:
2472 case TOK_PPNUM:
2473 error("unsupported token");
2474 return 1;
2475 case TOK_CDOUBLE:
2476 case TOK_CLLONG:
2477 case TOK_CULLONG:
2478 return 2;
2479 case TOK_CLDOUBLE:
2480 return LDOUBLE_SIZE / 4;
2481 default:
2482 return 0;
2483 }
2484 }
2485
2486 /* token string handling */
2487
2488 static inline void tok_str_new(TokenString *s)
2489 {
2490 s->str = NULL;
2491 s->len = 0;
2492 s->allocated_len = 0;
2493 s->last_line_num = -1;
2494 }
2495
2496 static void tok_str_free(int *str)
2497 {
2498 tcc_free(str);
2499 }
2500
2501 static int *tok_str_realloc(TokenString *s)
2502 {
2503 int *str, len;
2504
2505 if (s->allocated_len == 0) {
2506 len = 8;
2507 } else {
2508 len = s->allocated_len * 2;
2509 }
2510 str = tcc_realloc(s->str, len * sizeof(int));
2511 if (!str)
2512 error("memory full");
2513 s->allocated_len = len;
2514 s->str = str;
2515 return str;
2516 }
2517
2518 static void tok_str_add(TokenString *s, int t)
2519 {
2520 int len, *str;
2521
2522 len = s->len;
2523 str = s->str;
2524 if (len >= s->allocated_len)
2525 str = tok_str_realloc(s);
2526 str[len++] = t;
2527 s->len = len;
2528 }
2529
2530 static void tok_str_add2(TokenString *s, int t, CValue *cv)
2531 {
2532 int len, *str;
2533
2534 len = s->len;
2535 str = s->str;
2536
2537 /* allocate space for worst case */
2538 if (len + TOK_MAX_SIZE > s->allocated_len)
2539 str = tok_str_realloc(s);
2540 str[len++] = t;
2541 switch(t) {
2542 case TOK_CINT:
2543 case TOK_CUINT:
2544 case TOK_CCHAR:
2545 case TOK_LCHAR:
2546 case TOK_CFLOAT:
2547 case TOK_LINENUM:
2548 str[len++] = cv->tab[0];
2549 break;
2550 case TOK_PPNUM:
2551 case TOK_STR:
2552 case TOK_LSTR:
2553 {
2554 int nb_words;
2555 CString *cstr;
2556
2557 nb_words = (sizeof(CString) + cv->cstr->size + 3) >> 2;
2558 while ((len + nb_words) > s->allocated_len)
2559 str = tok_str_realloc(s);
2560 cstr = (CString *)(str + len);
2561 cstr->data = NULL;
2562 cstr->size = cv->cstr->size;
2563 cstr->data_allocated = NULL;
2564 cstr->size_allocated = cstr->size;
2565 memcpy((char *)cstr + sizeof(CString),
2566 cv->cstr->data, cstr->size);
2567 len += nb_words;
2568 }
2569 break;
2570 case TOK_CDOUBLE:
2571 case TOK_CLLONG:
2572 case TOK_CULLONG:
2573 #if LDOUBLE_SIZE == 8
2574 case TOK_CLDOUBLE:
2575 #endif
2576 str[len++] = cv->tab[0];
2577 str[len++] = cv->tab[1];
2578 break;
2579 #if LDOUBLE_SIZE == 12
2580 case TOK_CLDOUBLE:
2581 str[len++] = cv->tab[0];
2582 str[len++] = cv->tab[1];
2583 str[len++] = cv->tab[2];
2584 #elif LDOUBLE_SIZE == 16
2585 case TOK_CLDOUBLE:
2586 str[len++] = cv->tab[0];
2587 str[len++] = cv->tab[1];
2588 str[len++] = cv->tab[2];
2589 str[len++] = cv->tab[3];
2590 #elif LDOUBLE_SIZE != 8
2591 #error add long double size support
2592 #endif
2593 break;
2594 default:
2595 break;
2596 }
2597 s->len = len;
2598 }
2599
2600 /* add the current parse token in token string 's' */
2601 static void tok_str_add_tok(TokenString *s)
2602 {
2603 CValue cval;
2604
2605 /* save line number info */
2606 if (file->line_num != s->last_line_num) {
2607 s->last_line_num = file->line_num;
2608 cval.i = s->last_line_num;
2609 tok_str_add2(s, TOK_LINENUM, &cval);
2610 }
2611 tok_str_add2(s, tok, &tokc);
2612 }
2613
2614 #if LDOUBLE_SIZE == 16
2615 #define LDOUBLE_GET(p, cv) \
2616 cv.tab[0] = p[0]; \
2617 cv.tab[1] = p[1]; \
2618 cv.tab[2] = p[2]; \
2619 cv.tab[3] = p[3];
2620 #elif LDOUBLE_SIZE == 12
2621 #define LDOUBLE_GET(p, cv) \
2622 cv.tab[0] = p[0]; \
2623 cv.tab[1] = p[1]; \
2624 cv.tab[2] = p[2];
2625 #elif LDOUBLE_SIZE == 8
2626 #define LDOUBLE_GET(p, cv) \
2627 cv.tab[0] = p[0]; \
2628 cv.tab[1] = p[1];
2629 #else
2630 #error add long double size support
2631 #endif
2632
2633
2634 /* get a token from an integer array and increment pointer
2635 accordingly. we code it as a macro to avoid pointer aliasing. */
2636 #define TOK_GET(t, p, cv) \
2637 { \
2638 t = *p++; \
2639 switch(t) { \
2640 case TOK_CINT: \
2641 case TOK_CUINT: \
2642 case TOK_CCHAR: \
2643 case TOK_LCHAR: \
2644 case TOK_CFLOAT: \
2645 case TOK_LINENUM: \
2646 cv.tab[0] = *p++; \
2647 break; \
2648 case TOK_STR: \
2649 case TOK_LSTR: \
2650 case TOK_PPNUM: \
2651 cv.cstr = (CString *)p; \
2652 cv.cstr->data = (char *)p + sizeof(CString);\
2653 p += (sizeof(CString) + cv.cstr->size + 3) >> 2;\
2654 break; \
2655 case TOK_CDOUBLE: \
2656 case TOK_CLLONG: \
2657 case TOK_CULLONG: \
2658 cv.tab[0] = p[0]; \
2659 cv.tab[1] = p[1]; \
2660 p += 2; \
2661 break; \
2662 case TOK_CLDOUBLE: \
2663 LDOUBLE_GET(p, cv); \
2664 p += LDOUBLE_SIZE / 4; \
2665 break; \
2666 default: \
2667 break; \
2668 } \
2669 }
2670
2671 /* defines handling */
2672 static inline void define_push(int v, int macro_type, int *str, Sym *first_arg)
2673 {
2674 Sym *s;
2675
2676 s = sym_push2(&define_stack, v, macro_type, (long)str);
2677 s->next = first_arg;
2678 table_ident[v - TOK_IDENT]->sym_define = s;
2679 }
2680
2681 /* undefined a define symbol. Its name is just set to zero */
2682 static void define_undef(Sym *s)
2683 {
2684 int v;
2685 v = s->v;
2686 if (v >= TOK_IDENT && v < tok_ident)
2687 table_ident[v - TOK_IDENT]->sym_define = NULL;
2688 s->v = 0;
2689 }
2690
2691 static inline Sym *define_find(int v)
2692 {
2693 v -= TOK_IDENT;
2694 if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
2695 return NULL;
2696 return table_ident[v]->sym_define;
2697 }
2698
2699 /* free define stack until top reaches 'b' */
2700 static void free_defines(Sym *b)
2701 {
2702 Sym *top, *top1;
2703 int v;
2704
2705 top = define_stack;
2706 while (top != b) {
2707 top1 = top->prev;
2708 /* do not free args or predefined defines */
2709 if (top->c)
2710 tok_str_free((int *)top->c);
2711 v = top->v;
2712 if (v >= TOK_IDENT && v < tok_ident)
2713 table_ident[v - TOK_IDENT]->sym_define = NULL;
2714 sym_free(top);
2715 top = top1;
2716 }
2717 define_stack = b;
2718 }
2719
2720 /* label lookup */
2721 static Sym *label_find(int v)
2722 {
2723 v -= TOK_IDENT;
2724 if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
2725 return NULL;
2726 return table_ident[v]->sym_label;
2727 }
2728
2729 static Sym *label_push(Sym **ptop, int v, int flags)
2730 {
2731 Sym *s, **ps;
2732 s = sym_push2(ptop, v, 0, 0);
2733 s->r = flags;
2734 ps = &table_ident[v - TOK_IDENT]->sym_label;
2735 if (ptop == &global_label_stack) {
2736 /* modify the top most local identifier, so that
2737 sym_identifier will point to 's' when popped */
2738 while (*ps != NULL)
2739 ps = &(*ps)->prev_tok;
2740 }
2741 s->prev_tok = *ps;
2742 *ps = s;
2743 return s;
2744 }
2745
2746 /* pop labels until element last is reached. Look if any labels are
2747 undefined. Define symbols if '&&label' was used. */
2748 static void label_pop(Sym **ptop, Sym *slast)
2749 {
2750 Sym *s, *s1;
2751 for(s = *ptop; s != slast; s = s1) {
2752 s1 = s->prev;
2753 if (s->r == LABEL_DECLARED) {
2754 warning("label '%s' declared but not used", get_tok_str(s->v, NULL));
2755 } else if (s->r == LABEL_FORWARD) {
2756 error("label '%s' used but not defined",
2757 get_tok_str(s->v, NULL));
2758 } else {
2759 if (s->c) {
2760 /* define corresponding symbol. A size of
2761 1 is put. */
2762 put_extern_sym(s, cur_text_section, (long)s->next, 1);
2763 }
2764 }
2765 /* remove label */
2766 table_ident[s->v - TOK_IDENT]->sym_label = s->prev_tok;
2767 sym_free(s);
2768 }
2769 *ptop = slast;
2770 }
2771
2772 /* eval an expression for #if/#elif */
2773 static int expr_preprocess(void)
2774 {
2775 int c, t;
2776 TokenString str;
2777
2778 tok_str_new(&str);
2779 while (tok != TOK_LINEFEED && tok != TOK_EOF) {
2780 next(); /* do macro subst */
2781 if (tok == TOK_DEFINED) {
2782 next_nomacro();
2783 t = tok;
2784 if (t == '(')
2785 next_nomacro();
2786 c = define_find(tok) != 0;
2787 if (t == '(')
2788 next_nomacro();
2789 tok = TOK_CINT;
2790 tokc.i = c;
2791 } else if (tok >= TOK_IDENT) {
2792 /* if undefined macro */
2793 tok = TOK_CINT;
2794 tokc.i = 0;
2795 }
2796 tok_str_add_tok(&str);
2797 }
2798 tok_str_add(&str, -1); /* simulate end of file */
2799 tok_str_add(&str, 0);
2800 /* now evaluate C constant expression */
2801 macro_ptr = str.str;
2802 next();
2803 c = expr_const();
2804 macro_ptr = NULL;
2805 tok_str_free(str.str);
2806 return c != 0;
2807 }
2808
2809 #if defined(PARSE_DEBUG) || defined(PP_DEBUG)
2810 static void tok_print(int *str)
2811 {
2812 int t;
2813 CValue cval;
2814
2815 while (1) {
2816 TOK_GET(t, str, cval);
2817 if (!t)
2818 break;
2819 printf(" %s", get_tok_str(t, &cval));
2820 }
2821 printf("\n");
2822 }
2823 #endif
2824
2825 /* parse after #define */
2826 static void parse_define(void)
2827 {
2828 Sym *s, *first, **ps;
2829 int v, t, varg, is_vaargs, c;
2830 TokenString str;
2831
2832 v = tok;
2833 if (v < TOK_IDENT)
2834 error("invalid macro name '%s'", get_tok_str(tok, &tokc));
2835 /* XXX: should check if same macro (ANSI) */
2836 first = NULL;
2837 t = MACRO_OBJ;
2838 /* '(' must be just after macro definition for MACRO_FUNC */
2839 c = file->buf_ptr[0];
2840 if (c == '\\')
2841 c = handle_stray1(file->buf_ptr);
2842 if (c == '(') {
2843 next_nomacro();
2844 next_nomacro();
2845 ps = &first;
2846 while (tok != ')') {
2847 varg = tok;
2848 next_nomacro();
2849 is_vaargs = 0;
2850 if (varg == TOK_DOTS) {
2851 varg = TOK___VA_ARGS__;
2852 is_vaargs = 1;
2853 } else if (tok == TOK_DOTS && gnu_ext) {
2854 is_vaargs = 1;
2855 next_nomacro();
2856 }
2857 if (varg < TOK_IDENT)
2858 error("badly punctuated parameter list");
2859 s = sym_push2(&define_stack, varg | SYM_FIELD, is_vaargs, 0);
2860 *ps = s;
2861 ps = &s->next;
2862 if (tok != ',')
2863 break;
2864 next_nomacro();
2865 }
2866 t = MACRO_FUNC;
2867 }
2868 tok_str_new(&str);
2869 next_nomacro();
2870 /* EOF testing necessary for '-D' handling */
2871 while (tok != TOK_LINEFEED && tok != TOK_EOF) {
2872 tok_str_add2(&str, tok, &tokc);
2873 next_nomacro();
2874 }
2875 tok_str_add(&str, 0);
2876 #ifdef PP_DEBUG
2877 printf("define %s %d: ", get_tok_str(v, NULL), t);
2878 tok_print(str.str);
2879 #endif
2880 define_push(v, t, str.str, first);
2881 }
2882
2883 static inline int hash_cached_include(int type, const char *filename)
2884 {
2885 const unsigned char *s;
2886 unsigned int h;
2887
2888 h = TOK_HASH_INIT;
2889 h = TOK_HASH_FUNC(h, type);
2890 s = filename;
2891 while (*s) {
2892 h = TOK_HASH_FUNC(h, *s);
2893 s++;
2894 }
2895 h &= (CACHED_INCLUDES_HASH_SIZE - 1);
2896 return h;
2897 }
2898
2899 /* XXX: use a token or a hash table to accelerate matching ? */
2900 static CachedInclude *search_cached_include(TCCState *s1,
2901 int type, const char *filename)
2902 {
2903 CachedInclude *e;
2904 int i, h;
2905 h = hash_cached_include(type, filename);
2906 i = s1->cached_includes_hash[h];
2907 for(;;) {
2908 if (i == 0)
2909 break;
2910 e = s1->cached_includes[i - 1];
2911 if (e->type == type && !strcmp(e->filename, filename))
2912 return e;
2913 i = e->hash_next;
2914 }
2915 return NULL;
2916 }
2917
2918 static inline void add_cached_include(TCCState *s1, int type,
2919 const char *filename, int ifndef_macro)
2920 {
2921 CachedInclude *e;
2922 int h;
2923
2924 if (search_cached_include(s1, type, filename))
2925 return;
2926 #ifdef INC_DEBUG
2927 printf("adding cached '%s' %s\n", filename, get_tok_str(ifndef_macro, NULL));
2928 #endif
2929 e = tcc_malloc(sizeof(CachedInclude) + strlen(filename));
2930 if (!e)
2931 return;
2932 e->type = type;
2933 strcpy(e->filename, filename);
2934 e->ifndef_macro = ifndef_macro;
2935 dynarray_add((void ***)&s1->cached_includes, &s1->nb_cached_includes, e);
2936 /* add in hash table */
2937 h = hash_cached_include(type, filename);
2938 e->hash_next = s1->cached_includes_hash[h];
2939 s1->cached_includes_hash[h] = s1->nb_cached_includes;
2940 }
2941
2942 static void pragma_parse(TCCState *s1)
2943 {
2944 int val;
2945
2946 next();
2947 if (tok == TOK_pack) {
2948 /*
2949 This may be:
2950 #pragma pack(1) // set
2951 #pragma pack() // reset to default
2952 #pragma pack(push,1) // push & set
2953 #pragma pack(pop) // restore previous
2954 */
2955 next();
2956 skip('(');
2957 if (tok == TOK_ASM_pop) {
2958 next();
2959 if (s1->pack_stack_ptr <= s1->pack_stack) {
2960 stk_error:
2961 error("out of pack stack");
2962 }
2963 s1->pack_stack_ptr--;
2964 } else {
2965 val = 0;
2966 if (tok != ')') {
2967 if (tok == TOK_ASM_push) {
2968 next();
2969 if (s1->pack_stack_ptr >= s1->pack_stack + PACK_STACK_SIZE - 1)
2970 goto stk_error;
2971 s1->pack_stack_ptr++;
2972 skip(',');
2973 }
2974 if (tok != TOK_CINT) {
2975 pack_error:
2976 error("invalid pack pragma");
2977 }
2978 val = tokc.i;
2979 if (val < 1 || val > 16 || (val & (val - 1)) != 0)
2980 goto pack_error;
2981 next();
2982 }
2983 *s1->pack_stack_ptr = val;
2984 skip(')');
2985 }
2986 }
2987 }
2988
2989 /* is_bof is true if first non space token at beginning of file */
2990 static void preprocess(int is_bof)
2991 {
2992 TCCState *s1 = tcc_state;
2993 int size, i, c, n, saved_parse_flags;
2994 char buf[1024], *q;
2995 char buf1[1024];
2996 BufferedFile *f;
2997 Sym *s;
2998 CachedInclude *e;
2999
3000 saved_parse_flags = parse_flags;
3001 parse_flags = PARSE_FLAG_PREPROCESS | PARSE_FLAG_TOK_NUM |
3002 PARSE_FLAG_LINEFEED;
3003 next_nomacro();
3004 redo:
3005 switch(tok) {
3006 case TOK_DEFINE:
3007 next_nomacro();
3008 parse_define();
3009 break;
3010 case TOK_UNDEF:
3011 next_nomacro();
3012 s = define_find(tok);
3013 /* undefine symbol by putting an invalid name */
3014 if (s)
3015 define_undef(s);
3016 break;
3017 case TOK_INCLUDE:
3018 case TOK_INCLUDE_NEXT:
3019 ch = file->buf_ptr[0];
3020 /* XXX: incorrect if comments : use next_nomacro with a special mode */
3021 skip_spaces();
3022 if (ch == '<') {
3023 c = '>';
3024 goto read_name;
3025 } else if (ch == '\"') {
3026 c = ch;
3027 read_name:
3028 inp();
3029 q = buf;
3030 while (ch != c && ch != '\n' && ch != CH_EOF) {
3031 if ((q - buf) < sizeof(buf) - 1)
3032 *q++ = ch;
3033 if (ch == '\\') {
3034 if (handle_stray_noerror() == 0)
3035 --q;
3036 } else
3037 inp();
3038 }
3039 *q = '\0';
3040 minp();
3041 #if 0
3042 /* eat all spaces and comments after include */
3043 /* XXX: slightly incorrect */
3044 while (ch1 != '\n' && ch1 != CH_EOF)
3045 inp();
3046 #endif
3047 } else {
3048 /* computed #include : either we have only strings or
3049 we have anything enclosed in '<>' */
3050 next();
3051 buf[0] = '\0';
3052 if (tok == TOK_STR) {
3053 while (tok != TOK_LINEFEED) {
3054 if (tok != TOK_STR) {
3055 include_syntax:
3056 error("'#include' expects \"FILENAME\" or <FILENAME>");
3057 }
3058 pstrcat(buf, sizeof(buf), (char *)tokc.cstr->data);
3059 next();
3060 }
3061 c = '\"';
3062 } else {
3063 int len;
3064 while (tok != TOK_LINEFEED) {
3065 pstrcat(buf, sizeof(buf), get_tok_str(tok, &tokc));
3066 next();
3067 }
3068 len = strlen(buf);
3069 /* check syntax and remove '<>' */
3070 if (len < 2 || buf[0] != '<' || buf[len - 1] != '>')
3071 goto include_syntax;
3072 memmove(buf, buf + 1, len - 2);
3073 buf[len - 2] = '\0';
3074 c = '>';
3075 }
3076 }
3077
3078 e = search_cached_include(s1, c, buf);
3079 if (e && define_find(e->ifndef_macro)) {
3080 /* no need to parse the include because the 'ifndef macro'
3081 is defined */
3082 #ifdef INC_DEBUG
3083 printf("%s: skipping %s\n", file->filename, buf);
3084 #endif
3085 } else {
3086 if (s1->include_stack_ptr >= s1->include_stack + INCLUDE_STACK_SIZE)
3087 error("#include recursion too deep");
3088 /* push current file in stack */
3089 /* XXX: fix current line init */
3090 *s1->include_stack_ptr++ = file;
3091
3092 /* check absolute include path */
3093 if (IS_ABSPATH(buf)) {
3094 f = tcc_open(s1, buf);
3095 if (f)
3096 goto found;
3097 }
3098 if (c == '\"') {
3099 /* first search in current dir if "header.h" */
3100 size = tcc_basename(file->filename) - file->filename;
3101 if (size > sizeof(buf1) - 1)
3102 size = sizeof(buf1) - 1;
3103 memcpy(buf1, file->filename, size);
3104 buf1[size] = '\0';
3105 pstrcat(buf1, sizeof(buf1), buf);
3106 f = tcc_open(s1, buf1);
3107 if (f) {
3108 if (tok == TOK_INCLUDE_NEXT)
3109 tok = TOK_INCLUDE;
3110 else
3111 goto found;
3112 }
3113 }
3114 /* now search in all the include paths */
3115 n = s1->nb_include_paths + s1->nb_sysinclude_paths;
3116 for(i = 0; i < n; i++) {
3117 const char *path;
3118 if (i < s1->nb_include_paths)
3119 path = s1->include_paths[i];
3120 else
3121 path = s1->sysinclude_paths[i - s1->nb_include_paths];
3122 pstrcpy(buf1, sizeof(buf1), path);
3123 pstrcat(buf1, sizeof(buf1), "/");
3124 pstrcat(buf1, sizeof(buf1), buf);
3125 f = tcc_open(s1, buf1);
3126 if (f) {
3127 if (tok == TOK_INCLUDE_NEXT)
3128 tok = TOK_INCLUDE;
3129 else
3130 goto found;
3131 }
3132 }
3133 --s1->include_stack_ptr;
3134 error("include file '%s' not found", buf);
3135 break;
3136 found:
3137 #ifdef INC_DEBUG
3138 printf("%s: including %s\n", file->filename, buf1);
3139 #endif
3140 f->inc_type = c;
3141 pstrcpy(f->inc_filename, sizeof(f->inc_filename), buf);
3142 file = f;
3143 /* add include file debug info */
3144 if (do_debug) {
3145 put_stabs(file->filename, N_BINCL, 0, 0, 0);
3146 }
3147 tok_flags |= TOK_FLAG_BOF | TOK_FLAG_BOL;
3148 ch = file->buf_ptr[0];
3149 goto the_end;
3150 }
3151 break;
3152 case TOK_IFNDEF:
3153 c = 1;
3154 goto do_ifdef;
3155 case TOK_IF:
3156 c = expr_preprocess();
3157 goto do_if;
3158 case TOK_IFDEF:
3159 c = 0;
3160 do_ifdef:
3161 next_nomacro();
3162 if (tok < TOK_IDENT)
3163 error("invalid argument for '#if%sdef'", c ? "n" : "");
3164 if (is_bof) {
3165 if (c) {
3166 #ifdef INC_DEBUG
3167 printf("#ifndef %s\n", get_tok_str(tok, NULL));
3168 #endif
3169 file->ifndef_macro = tok;
3170 }
3171 }
3172 c = (define_find(tok) != 0) ^ c;
3173 do_if:
3174 if (s1->ifdef_stack_ptr >= s1->ifdef_stack + IFDEF_STACK_SIZE)
3175 error("memory full");
3176 *s1->ifdef_stack_ptr++ = c;
3177 goto test_skip;
3178 case TOK_ELSE:
3179 if (s1->ifdef_stack_ptr == s1->ifdef_stack)
3180 error("#else without matching #if");
3181 if (s1->ifdef_stack_ptr[-1] & 2)
3182 error("#else after #else");
3183 c = (s1->ifdef_stack_ptr[-1] ^= 3);
3184 goto test_skip;
3185 case TOK_ELIF:
3186 if (s1->ifdef_stack_ptr == s1->ifdef_stack)
3187 error("#elif without matching #if");
3188 c = s1->ifdef_stack_ptr[-1];
3189 if (c > 1)
3190 error("#elif after #else");
3191 /* last #if/#elif expression was true: we skip */
3192 if (c == 1)
3193 goto skip;
3194 c = expr_preprocess();
3195 s1->ifdef_stack_ptr[-1] = c;
3196 test_skip:
3197 if (!(c & 1)) {
3198 skip:
3199 preprocess_skip();
3200 is_bof = 0;
3201 goto redo;
3202 }
3203 break;
3204 case TOK_ENDIF:
3205 if (s1->ifdef_stack_ptr <= file->ifdef_stack_ptr)
3206 error("#endif without matching #if");
3207 s1->ifdef_stack_ptr--;
3208 /* '#ifndef macro' was at the start of file. Now we check if
3209 an '#endif' is exactly at the end of file */
3210 if (file->ifndef_macro &&
3211 s1->ifdef_stack_ptr == file->ifdef_stack_ptr) {
3212 file->ifndef_macro_saved = file->ifndef_macro;
3213 /* need to set to zero to avoid false matches if another
3214 #ifndef at middle of file */
3215 file->ifndef_macro = 0;
3216 while (tok != TOK_LINEFEED)
3217 next_nomacro();
3218 tok_flags |= TOK_FLAG_ENDIF;
3219 goto the_end;
3220 }
3221 break;
3222 case TOK_LINE:
3223 next();
3224 if (tok != TOK_CINT)
3225 error("#line");
3226 file->line_num = tokc.i - 1; /* the line number will be incremented after */
3227 next();
3228 if (tok != TOK_LINEFEED) {
3229 if (tok != TOK_STR)
3230 error("#line");
3231 pstrcpy(file->filename, sizeof(file->filename),
3232 (char *)tokc.cstr->data);
3233 }
3234 break;
3235 case TOK_ERROR:
3236 case TOK_WARNING:
3237 c = tok;
3238 ch = file->buf_ptr[0];
3239 skip_spaces();
3240 q = buf;
3241 while (ch != '\n' && ch != CH_EOF) {
3242 if ((q - buf) < sizeof(buf) - 1)
3243 *q++ = ch;
3244 if (ch == '\\') {
3245 if (handle_stray_noerror() == 0)
3246 --q;
3247 } else
3248 inp();
3249 }
3250 *q = '\0';
3251 if (c == TOK_ERROR)
3252 error("#error %s", buf);
3253 else
3254 warning("#warning %s", buf);
3255 break;
3256 case TOK_PRAGMA:
3257 pragma_parse(s1);
3258 break;
3259 default:
3260 if (tok == TOK_LINEFEED || tok == '!' || tok == TOK_CINT) {
3261 /* '!' is ignored to allow C scripts. numbers are ignored
3262 to emulate cpp behaviour */
3263 } else {
3264 if (!(saved_parse_flags & PARSE_FLAG_ASM_COMMENTS))
3265 warning("Ignoring unknown preprocessing directive #%s", get_tok_str(tok, &tokc));
3266 }
3267 break;
3268 }
3269 /* ignore other preprocess commands or #! for C scripts */
3270 while (tok != TOK_LINEFEED)
3271 next_nomacro();
3272 the_end:
3273 parse_flags = saved_parse_flags;
3274 }
3275
3276 /* evaluate escape codes in a string. */
3277 static void parse_escape_string(CString *outstr, const uint8_t *buf, int is_long)
3278 {
3279 int c, n;
3280 const uint8_t *p;
3281
3282 p = buf;
3283 for(;;) {
3284 c = *p;
3285 if (c == '\0')
3286 break;
3287 if (c == '\\') {
3288 p++;
3289 /* escape */
3290 c = *p;
3291 switch(c) {
3292 case '0': case '1': case '2': case '3':
3293 case '4': case '5': case '6': case '7':
3294 /* at most three octal digits */
3295 n = c - '0';
3296 p++;
3297 c = *p;
3298 if (isoct(c)) {
3299 n = n * 8 + c - '0';
3300 p++;
3301 c = *p;
3302 if (isoct(c)) {
3303 n = n * 8 + c - '0';
3304 p++;
3305 }
3306 }
3307 c = n;
3308 goto add_char_nonext;
3309 case 'x':
3310 case 'u':
3311 case 'U':
3312 p++;
3313 n = 0;
3314 for(;;) {
3315 c = *p;
3316 if (c >= 'a' && c <= 'f')
3317 c = c - 'a' + 10;
3318 else if (c >= 'A' && c <= 'F')
3319 c = c - 'A' + 10;
3320 else if (isnum(c))
3321 c = c - '0';
3322 else
3323 break;
3324 n = n * 16 + c;
3325 p++;
3326 }
3327 c = n;
3328 goto add_char_nonext;
3329 case 'a':
3330 c = '\a';
3331 break;
3332 case 'b':
3333 c = '\b';
3334 break;
3335 case 'f':
3336 c = '\f';
3337 break;
3338 case 'n':
3339 c = '\n';
3340 break;
3341 case 'r':
3342 c = '\r';
3343 break;
3344 case 't':
3345 c = '\t';
3346 break;
3347 case 'v':
3348 c = '\v';
3349 break;
3350 case 'e':
3351 if (!gnu_ext)
3352 goto invalid_escape;
3353 c = 27;
3354 break;
3355 case '\'':
3356 case '\"':
3357 case '\\':
3358 case '?':
3359 break;
3360 default:
3361 invalid_escape:
3362 if (c >= '!' && c <= '~')
3363 warning("unknown escape sequence: \'\\%c\'", c);
3364 else
3365 warning("unknown escape sequence: \'\\x%x\'", c);
3366 break;
3367 }
3368 }
3369 p++;
3370 add_char_nonext:
3371 if (!is_long)
3372 cstr_ccat(outstr, c);
3373 else
3374 cstr_wccat(outstr, c);
3375 }
3376 /* add a trailing '\0' */
3377 if (!is_long)
3378 cstr_ccat(outstr, '\0');
3379 else
3380 cstr_wccat(outstr, '\0');
3381 }
3382
3383 /* we use 64 bit numbers */
3384 #define BN_SIZE 2
3385
3386 /* bn = (bn << shift) | or_val */
3387 void bn_lshift(unsigned int *bn, int shift, int or_val)
3388 {
3389 int i;
3390 unsigned int v;
3391 for(i=0;i<BN_SIZE;i++) {
3392 v = bn[i];
3393 bn[i] = (v << shift) | or_val;
3394 or_val = v >> (32 - shift);
3395 }
3396 }
3397
3398 void bn_zero(unsigned int *bn)
3399 {
3400 int i;
3401 for(i=0;i<BN_SIZE;i++) {
3402 bn[i] = 0;
3403 }
3404 }
3405
3406 /* parse number in null terminated string 'p' and return it in the
3407 current token */
3408 void parse_number(const char *p)
3409 {
3410 int b, t, shift, frac_bits, s, exp_val, ch;
3411 char *q;
3412 unsigned int bn[BN_SIZE];
3413 double d;
3414
3415 /* number */
3416 q = token_buf;
3417 ch = *p++;
3418 t = ch;
3419 ch = *p++;
3420 *q++ = t;
3421 b = 10;
3422 if (t == '.') {
3423 goto float_frac_parse;
3424 } else if (t == '0') {
3425 if (ch == 'x' || ch == 'X') {
3426 q--;
3427 ch = *p++;
3428 b = 16;
3429 } else if (tcc_ext && (ch == 'b' || ch == 'B')) {
3430 q--;
3431 ch = *p++;
3432 b = 2;
3433 }
3434 }
3435 /* parse all digits. cannot check octal numbers at this stage
3436 because of floating point constants */
3437 while (1) {
3438 if (ch >= 'a' && ch <= 'f')
3439 t = ch - 'a' + 10;
3440 else if (ch >= 'A' && ch <= 'F')
3441 t = ch - 'A' + 10;
3442 else if (isnum(ch))
3443 t = ch - '0';
3444 else
3445 break;
3446 if (t >= b)
3447 break;
3448 if (q >= token_buf + STRING_MAX_SIZE) {
3449 num_too_long:
3450 error("number too long");
3451 }
3452 *q++ = ch;
3453 ch = *p++;
3454 }
3455 if (ch == '.' ||
3456 ((ch == 'e' || ch == 'E') && b == 10) ||
3457 ((ch == 'p' || ch == 'P') && (b == 16 || b == 2))) {
3458 if (b != 10) {
3459 /* NOTE: strtox should support that for hexa numbers, but
3460 non ISOC99 libcs do not support it, so we prefer to do
3461 it by hand */
3462 /* hexadecimal or binary floats */
3463 /* XXX: handle overflows */
3464 *q = '\0';
3465 if (b == 16)
3466 shift = 4;
3467 else
3468 shift = 2;
3469 bn_zero(bn);
3470 q = token_buf;
3471 while (1) {
3472 t = *q++;
3473 if (t == '\0') {
3474 break;
3475 } else if (t >= 'a') {
3476 t = t - 'a' + 10;
3477 } else if (t >= 'A') {
3478 t = t - 'A' + 10;
3479 } else {
3480 t = t - '0';
3481 }
3482 bn_lshift(bn, shift, t);
3483 }
3484 frac_bits = 0;
3485 if (ch == '.') {
3486 ch = *p++;
3487 while (1) {
3488 t = ch;
3489 if (t >= 'a' && t <= 'f') {
3490 t = t - 'a' + 10;
3491 } else if (t >= 'A' && t <= 'F') {
3492 t = t - 'A' + 10;
3493 } else if (t >= '0' && t <= '9') {
3494 t = t - '0';
3495 } else {
3496 break;
3497 }
3498 if (t >= b)
3499 error("invalid digit");
3500 bn_lshift(bn, shift, t);
3501 frac_bits += shift;
3502 ch = *p++;
3503 }
3504 }
3505 if (ch != 'p' && ch != 'P')
3506 expect("exponent");
3507 ch = *p++;
3508 s = 1;
3509 exp_val = 0;
3510 if (ch == '+') {
3511 ch = *p++;
3512 } else if (ch == '-') {
3513 s = -1;
3514 ch = *p++;
3515 }
3516 if (ch < '0' || ch > '9')
3517 expect("exponent digits");
3518 while (ch >= '0' && ch <= '9') {
3519 exp_val = exp_val * 10 + ch - '0';
3520 ch = *p++;
3521 }
3522 exp_val = exp_val * s;
3523
3524 /* now we can generate the number */
3525 /* XXX: should patch directly float number */
3526 d = (double)bn[1] * 4294967296.0 + (double)bn[0];
3527 d = ldexp(d, exp_val - frac_bits);
3528 t = toup(ch);
3529 if (t == 'F') {
3530 ch = *p++;
3531 tok = TOK_CFLOAT;
3532 /* float : should handle overflow */
3533 tokc.f = (float)d;
3534 } else if (t == 'L') {
3535 ch = *p++;
3536 tok = TOK_CLDOUBLE;
3537 /* XXX: not large enough */
3538 tokc.ld = (long double)d;
3539 } else {
3540 tok = TOK_CDOUBLE;
3541 tokc.d = d;
3542 }
3543 } else {
3544 /* decimal floats */
3545 if (ch == '.') {
3546 if (q >= token_buf + STRING_MAX_SIZE)
3547 goto num_too_long;
3548 *q++ = ch;
3549 ch = *p++;
3550 float_frac_parse:
3551 while (ch >= '0' && ch <= '9') {
3552 if (q >= token_buf + STRING_MAX_SIZE)
3553 goto num_too_long;
3554 *q++ = ch;
3555 ch = *p++;
3556 }
3557 }
3558 if (ch == 'e' || ch == 'E') {
3559 if (q >= token_buf + STRING_MAX_SIZE)
3560 goto num_too_long;
3561 *q++ = ch;
3562 ch = *p++;
3563 if (ch == '-' || ch == '+') {
3564 if (q >= token_buf + STRING_MAX_SIZE)
3565 goto num_too_long;
3566 *q++ = ch;
3567 ch = *p++;
3568 }
3569 if (ch < '0' || ch > '9')
3570 expect("exponent digits");
3571 while (ch >= '0' && ch <= '9') {
3572 if (q >= token_buf + STRING_MAX_SIZE)
3573 goto num_too_long;
3574 *q++ = ch;
3575 ch = *p++;
3576 }
3577 }
3578 *q = '\0';
3579 t = toup(ch);
3580 errno = 0;
3581 if (t == 'F') {
3582 ch = *p++;
3583 tok = TOK_CFLOAT;
3584 tokc.f = strtof(token_buf, NULL);
3585 } else if (t == 'L') {
3586 ch = *p++;
3587 tok = TOK_CLDOUBLE;
3588 tokc.ld = strtold(token_buf, NULL);
3589 } else {
3590 tok = TOK_CDOUBLE;
3591 tokc.d = strtod(token_buf, NULL);
3592 }
3593 }
3594 } else {
3595 unsigned long long n, n1;
3596 int lcount, ucount;
3597
3598 /* integer number */
3599 *q = '\0';
3600 q = token_buf;
3601 if (b == 10 && *q == '0') {
3602 b = 8;
3603 q++;
3604 }
3605 n = 0;
3606 while(1) {
3607 t = *q++;
3608 /* no need for checks except for base 10 / 8 errors */
3609 if (t == '\0') {
3610 break;
3611 } else if (t >= 'a') {
3612 t = t - 'a' + 10;
3613 } else if (t >= 'A') {
3614 t = t - 'A' + 10;
3615 } else {
3616 t = t - '0';
3617 if (t >= b)
3618 error("invalid digit");
3619 }
3620 n1 = n;
3621 n = n * b + t;
3622 /* detect overflow */
3623 /* XXX: this test is not reliable */
3624 if (n < n1)
3625 error("integer constant overflow");
3626 }
3627
3628 /* XXX: not exactly ANSI compliant */
3629 if ((n & 0xffffffff00000000LL) != 0) {
3630 if ((n >> 63) != 0)
3631 tok = TOK_CULLONG;
3632 else
3633 tok = TOK_CLLONG;
3634 } else if (n > 0x7fffffff) {
3635 tok = TOK_CUINT;
3636 } else {
3637 tok = TOK_CINT;
3638 }
3639 lcount = 0;
3640 ucount = 0;
3641 for(;;) {
3642 t = toup(ch);
3643 if (t == 'L') {
3644 if (lcount >= 2)
3645 error("three 'l's in integer constant");
3646 lcount++;
3647 if (lcount == 2) {
3648 if (tok == TOK_CINT)
3649 tok = TOK_CLLONG;
3650 else if (tok == TOK_CUINT)
3651 tok = TOK_CULLONG;
3652 }
3653 ch = *p++;
3654 } else if (t == 'U') {
3655 if (ucount >= 1)
3656 error("two 'u's in integer constant");
3657 ucount++;
3658 if (tok == TOK_CINT)
3659 tok = TOK_CUINT;
3660 else if (tok == TOK_CLLONG)
3661 tok = TOK_CULLONG;
3662 ch = *p++;
3663 } else {
3664 break;
3665 }
3666 }
3667 if (tok == TOK_CINT || tok == TOK_CUINT)
3668 tokc.ui = n;
3669 else
3670 tokc.ull = n;
3671 }
3672 if (ch)
3673 error("invalid number\n");
3674 }
3675
3676
3677 #define PARSE2(c1, tok1, c2, tok2) \
3678 case c1: \
3679 PEEKC(c, p); \
3680 if (c == c2) { \
3681 p++; \
3682 tok = tok2; \
3683 } else { \
3684 tok = tok1; \
3685 } \
3686 break;
3687
3688 /* return next token without macro substitution */
3689 static inline void next_nomacro1(void)
3690 {
3691 int t, c, is_long;
3692 TokenSym *ts;
3693 uint8_t *p, *p1;
3694 unsigned int h;
3695
3696 cstr_reset(&tok_spaces);
3697 p = file->buf_ptr;
3698 redo_no_start:
3699 c = *p;
3700 switch(c) {
3701 case ' ':
3702 case '\t':
3703 case '\f':
3704 case '\v':
3705 case '\r':
3706 cstr_ccat(&tok_spaces, c);
3707 p++;
3708 goto redo_no_start;
3709
3710 case '\\':
3711 /* first look if it is in fact an end of buffer */
3712 if (p >= file->buf_end) {
3713 file->buf_ptr = p;
3714 handle_eob();
3715 p = file->buf_ptr;
3716 if (p >= file->buf_end)
3717 goto parse_eof;
3718 else
3719 goto redo_no_start;
3720 } else {
3721 file->buf_ptr = p;
3722 ch = *p;
3723 handle_stray();
3724 p = file->buf_ptr;
3725 goto redo_no_start;
3726 }
3727 parse_eof:
3728 {
3729 TCCState *s1 = tcc_state;
3730 if ((parse_flags & PARSE_FLAG_LINEFEED)
3731 && !(tok_flags & TOK_FLAG_EOF)) {
3732 tok_flags |= TOK_FLAG_EOF;
3733 tok = TOK_LINEFEED;
3734 goto keep_tok_flags;
3735 } else if (s1->include_stack_ptr == s1->include_stack ||
3736 !(parse_flags & PARSE_FLAG_PREPROCESS)) {
3737 /* no include left : end of file. */
3738 tok = TOK_EOF;
3739 } else {
3740 tok_flags &= ~TOK_FLAG_EOF;
3741 /* pop include file */
3742
3743 /* test if previous '#endif' was after a #ifdef at
3744 start of file */
3745 if (tok_flags & TOK_FLAG_ENDIF) {
3746 #ifdef INC_DEBUG
3747 printf("#endif %s\n", get_tok_str(file->ifndef_macro_saved, NULL));
3748 #endif
3749 add_cached_include(s1, file->inc_type, file->inc_filename,
3750 file->ifndef_macro_saved);
3751 }
3752
3753 /* add end of include file debug info */
3754 if (do_debug) {
3755 put_stabd(N_EINCL, 0, 0);
3756 }
3757 /* pop include stack */
3758 tcc_close(file);
3759 s1->include_stack_ptr--;
3760 file = *s1->include_stack_ptr;
3761 p = file->buf_ptr;
3762 goto redo_no_start;
3763 }
3764 }
3765 break;
3766
3767 case '\n':
3768 file->line_num++;
3769 tok_flags |= TOK_FLAG_BOL;
3770 p++;
3771 if (0 == (parse_flags & PARSE_FLAG_LINEFEED))
3772 goto redo_no_start;
3773 tok = TOK_LINEFEED;
3774 goto keep_tok_flags;
3775
3776 case '#':
3777 /* XXX: simplify */
3778 PEEKC(c, p);
3779 if ((tok_flags & TOK_FLAG_BOL) &&
3780 (parse_flags & PARSE_FLAG_PREPROCESS)) {
3781 file->buf_ptr = p;
3782 preprocess(tok_flags & TOK_FLAG_BOF);
3783 p = file->buf_ptr;
3784 goto redo_no_start;
3785 } else {
3786 if (c == '#') {
3787 p++;
3788 tok = TOK_TWOSHARPS;
3789 } else {
3790 if (parse_flags & PARSE_FLAG_ASM_COMMENTS) {
3791 p = parse_line_comment(p - 1);
3792 goto redo_no_start;
3793 } else {
3794 tok = '#';
3795 }
3796 }
3797 }
3798 break;
3799
3800 case 'a': case 'b': case 'c': case 'd':
3801 case 'e': case 'f': case 'g': case 'h':
3802 case 'i': case 'j': case 'k': case 'l':
3803 case 'm': case 'n': case 'o': case 'p':
3804 case 'q': case 'r': case 's': case 't':
3805 case 'u': case 'v': case 'w': case 'x':
3806 case 'y': case 'z':
3807 case 'A': case 'B': case 'C': case 'D':
3808 case 'E': case 'F': case 'G': case 'H':
3809 case 'I': case 'J': case 'K':
3810 case 'M': case 'N': case 'O': case 'P':
3811 case 'Q': case 'R': case 'S': case 'T':
3812 case 'U': case 'V': case 'W': case 'X':
3813 case 'Y': case 'Z':
3814 case '_':
3815 parse_ident_fast:
3816 p1 = p;
3817 h = TOK_HASH_INIT;
3818 h = TOK_HASH_FUNC(h, c);
3819 p++;
3820 for(;;) {
3821 c = *p;
3822 if (!isidnum_table[c-CH_EOF])
3823 break;
3824 h = TOK_HASH_FUNC(h, c);
3825 p++;
3826 }
3827 if (c != '\\') {
3828 TokenSym **pts;
3829 int len;
3830
3831 /* fast case : no stray found, so we have the full token
3832 and we have already hashed it */
3833 len = p - p1;
3834 h &= (TOK_HASH_SIZE - 1);
3835 pts = &hash_ident[h];
3836 for(;;) {
3837 ts = *pts;
3838 if (!ts)
3839 break;
3840 if (ts->len == len && !memcmp(ts->str, p1, len))
3841 goto token_found;
3842 pts = &(ts->hash_next);
3843 }
3844 ts = tok_alloc_new(pts, p1, len);
3845 token_found: ;
3846 } else {
3847 /* slower case */
3848 cstr_reset(&tokcstr);
3849
3850 while (p1 < p) {
3851 cstr_ccat(&tokcstr, *p1);
3852 p1++;
3853 }
3854 p--;
3855 PEEKC(c, p);
3856 parse_ident_slow:
3857 while (isidnum_table[c-CH_EOF]) {
3858 cstr_ccat(&tokcstr, c);
3859 PEEKC(c, p);
3860 }
3861 ts = tok_alloc(tokcstr.data, tokcstr.size);
3862 }
3863 tok = ts->tok;
3864 break;
3865 case 'L':
3866 t = p[1];
3867 if (t != '\\' && t != '\'' && t != '\"') {
3868 /* fast case */
3869 goto parse_ident_fast;
3870 } else {
3871 PEEKC(c, p);
3872 if (c == '\'' || c == '\"') {
3873 is_long = 1;
3874 goto str_const;
3875 } else {
3876 cstr_reset(&tokcstr);
3877 cstr_ccat(&tokcstr, 'L');
3878 goto parse_ident_slow;
3879 }
3880 }
3881 break;
3882 case '0': case '1': case '2': case '3':
3883 case '4': case '5': case '6': case '7':
3884 case '8': case '9':
3885
3886 cstr_reset(&tokcstr);
3887 /* after the first digit, accept digits, alpha, '.' or sign if
3888 prefixed by 'eEpP' */
3889 parse_num:
3890 for(;;) {
3891 t = c;
3892 cstr_ccat(&tokcstr, c);
3893 PEEKC(c, p);
3894 if (!(isnum(c) || isid(c) || c == '.' ||
3895 ((c == '+' || c == '-') &&
3896 (t == 'e' || t == 'E' || t == 'p' || t == 'P'))))
3897 break;
3898 }
3899 /* We add a trailing '\0' to ease parsing */
3900 cstr_ccat(&tokcstr, '\0');
3901 tokc.cstr = &tokcstr;
3902 tok = TOK_PPNUM;
3903 break;
3904 case '.':
3905 /* special dot handling because it can also start a number */
3906 PEEKC(c, p);
3907 if (isnum(c)) {
3908 cstr_reset(&tokcstr);
3909 cstr_ccat(&tokcstr, '.');
3910 goto parse_num;
3911 } else if (c == '.') {
3912 PEEKC(c, p);
3913 if (c != '.')
3914 expect("'.'");
3915 PEEKC(c, p);
3916 tok = TOK_DOTS;
3917 } else {
3918 tok = '.';
3919 }
3920 break;
3921 case '\'':
3922 case '\"':
3923 is_long = 0;
3924 str_const:
3925 {
3926 CString str;
3927 int sep;
3928
3929 sep = c;
3930
3931 /* parse the string */
3932 cstr_new(&str);
3933 p = parse_pp_string(p, sep, &str);
3934 cstr_ccat(&str, '\0');
3935
3936 /* eval the escape (should be done as TOK_PPNUM) */
3937 cstr_reset(&tokcstr);
3938 parse_escape_string(&tokcstr, str.data, is_long);
3939 cstr_free(&str);
3940
3941 if (sep == '\'') {
3942 int char_size;
3943 /* XXX: make it portable */
3944 if (!is_long)
3945 char_size = 1;
3946 else
3947 char_size = sizeof(nwchar_t);
3948 if (tokcstr.size <= char_size)
3949 error("empty character constant");
3950 if (tokcstr.size > 2 * char_size)
3951 warning("multi-character character constant");
3952 if (!is_long) {
3953 tokc.i = *(int8_t *)tokcstr.data;
3954 tok = TOK_CCHAR;
3955 } else {
3956 tokc.i = *(nwchar_t *)tokcstr.data;
3957 tok = TOK_LCHAR;
3958 }
3959 } else {
3960 tokc.cstr = &tokcstr;
3961 if (!is_long)
3962 tok = TOK_STR;
3963 else
3964 tok = TOK_LSTR;
3965 }
3966 }
3967 break;
3968
3969 case '<':
3970 PEEKC(c, p);
3971 if (c == '=') {
3972 p++;
3973 tok = TOK_LE;
3974 } else if (c == '<') {
3975 PEEKC(c, p);
3976 if (c == '=') {
3977 p++;
3978 tok = TOK_A_SHL;
3979 } else {
3980 tok = TOK_SHL;
3981 }
3982 } else {
3983 tok = TOK_LT;
3984 }
3985 break;
3986
3987 case '>':
3988 PEEKC(c, p);
3989 if (c == '=') {
3990 p++;
3991 tok = TOK_GE;
3992 } else if (c == '>') {
3993 PEEKC(c, p);
3994 if (c == '=') {
3995 p++;
3996 tok = TOK_A_SAR;
3997 } else {
3998 tok = TOK_SAR;
3999 }
4000 } else {
4001 tok = TOK_GT;
4002 }
4003 break;
4004
4005 case '&':
4006 PEEKC(c, p);
4007 if (c == '&') {
4008 p++;
4009 tok = TOK_LAND;
4010 } else if (c == '=') {
4011 p++;
4012 tok = TOK_A_AND;
4013 } else {
4014 tok = '&';
4015 }
4016 break;
4017
4018 case '|':
4019 PEEKC(c, p);
4020 if (c == '|') {
4021 p++;
4022 tok = TOK_LOR;
4023 } else if (c == '=') {
4024 p++;
4025 tok = TOK_A_OR;
4026 } else {
4027 tok = '|';
4028 }
4029 break;
4030
4031 case '+':
4032 PEEKC(c, p);
4033 if (c == '+') {
4034 p++;
4035 tok = TOK_INC;
4036 } else if (c == '=') {
4037 p++;
4038 tok = TOK_A_ADD;
4039 } else {
4040 tok = '+';
4041 }
4042 break;
4043
4044 case '-':
4045 PEEKC(c, p);
4046 if (c == '-') {
4047 p++;
4048 tok = TOK_DEC;
4049 } else if (c == '=') {
4050 p++;
4051 tok = TOK_A_SUB;
4052 } else if (c == '>') {
4053 p++;
4054 tok = TOK_ARROW;
4055 } else {
4056 tok = '-';
4057 }
4058 break;
4059
4060 PARSE2('!', '!', '=', TOK_NE)
4061 PARSE2('=', '=', '=', TOK_EQ)
4062 PARSE2('*', '*', '=', TOK_A_MUL)
4063 PARSE2('%', '%', '=', TOK_A_MOD)
4064 PARSE2('^', '^', '=', TOK_A_XOR)
4065
4066 /* comments or operator */
4067 case '/':
4068 PEEKC(c, p);
4069 if (c == '*') {
4070 p = parse_comment(p);
4071 goto redo_no_start;
4072 } else if (c == '/') {
4073 p = parse_line_comment(p);
4074 goto redo_no_start;
4075 } else if (c == '=') {
4076 p++;
4077 tok = TOK_A_DIV;
4078 } else {
4079 tok = '/';
4080 }
4081 break;
4082
4083 /* simple tokens */
4084 case '(':
4085 case ')':
4086 case '[':
4087 case ']':
4088 case '{':
4089 case '}':
4090 case ',':
4091 case ';':
4092 case ':':
4093 case '?':
4094 case '~':
4095 case '$': /* only used in assembler */
4096 case '@': /* dito */
4097 tok = c;
4098 p++;
4099 break;
4100 default:
4101 error("unrecognized character \\x%02x", c);
4102 break;
4103 }
4104 tok_flags = 0;
4105 keep_tok_flags:
4106 file->buf_ptr = p;
4107 #if defined(PARSE_DEBUG)
4108 printf("token = %s\n", get_tok_str(tok, &tokc));
4109 #endif
4110 }
4111
4112 /* return next token without macro substitution. Can read input from
4113 macro_ptr buffer */
4114 static void next_nomacro(void)
4115 {
4116 if (macro_ptr) {
4117 redo:
4118 tok = *macro_ptr;
4119 if (tok) {
4120 TOK_GET(tok, macro_ptr, tokc);
4121 if (tok == TOK_LINENUM) {
4122 file->line_num = tokc.i;
4123 goto redo;
4124 }
4125 }
4126 } else {
4127 next_nomacro1();
4128 }
4129 }
4130
4131 /* substitute args in macro_str and return allocated string */
4132 static int *macro_arg_subst(Sym **nested_list, int *macro_str, Sym *args)
4133 {
4134 int *st, last_tok, t, notfirst;
4135 Sym *s;
4136 CValue cval;
4137 TokenString str;
4138 CString cstr;
4139
4140 tok_str_new(&str);
4141 last_tok = 0;
4142 while(1) {
4143 TOK_GET(t, macro_str, cval);
4144 if (!t)
4145 break;
4146 if (t == '#') {
4147 /* stringize */
4148 TOK_GET(t, macro_str, cval);
4149 if (!t)
4150 break;
4151 s = sym_find2(args, t);
4152 if (s) {
4153 cstr_new(&cstr);
4154 st = (int *)s->c;
4155 notfirst = 0;
4156 while (*st) {
4157 if (notfirst)
4158 cstr_ccat(&cstr, ' ');
4159 TOK_GET(t, st, cval);
4160 cstr_cat(&cstr, get_tok_str(t, &cval));
4161 #ifndef PP_NOSPACES
4162 notfirst = 1;
4163 #endif
4164 }
4165 cstr_ccat(&cstr, '\0');
4166 #ifdef PP_DEBUG
4167 printf("stringize: %s\n", (char *)cstr.data);
4168 #endif
4169 /* add string */
4170 cval.cstr = &cstr;
4171 tok_str_add2(&str, TOK_STR, &cval);
4172 cstr_free(&cstr);
4173 } else {
4174 tok_str_add2(&str, t, &cval);
4175 }
4176 } else if (t >= TOK_IDENT) {
4177 s = sym_find2(args, t);
4178 if (s) {
4179 st = (int *)s->c;
4180 /* if '##' is present before or after, no arg substitution */
4181 if (*macro_str == TOK_TWOSHARPS || last_tok == TOK_TWOSHARPS) {
4182 /* special case for var arg macros : ## eats the
4183 ',' if empty VA_ARGS variable. */
4184 /* XXX: test of the ',' is not 100%
4185 reliable. should fix it to avoid security
4186 problems */
4187 if (gnu_ext && s->type.t &&
4188 last_tok == TOK_TWOSHARPS &&
4189 str.len >= 2 && str.str[str.len - 2] == ',') {
4190 if (*st == 0) {
4191 /* suppress ',' '##' */
4192 str.len -= 2;
4193 } else {
4194 /* suppress '##' and add variable */
4195 str.len--;
4196 goto add_var;
4197 }
4198 } else {
4199 int t1;
4200 add_var:
4201 for(;;) {
4202 TOK_GET(t1, st, cval);
4203 if (!t1)
4204 break;
4205 tok_str_add2(&str, t1, &cval);
4206 }
4207 }
4208 } else {
4209 /* NOTE: the stream cannot be read when macro
4210 substituing an argument */
4211 macro_subst(&str, nested_list, st, NULL);
4212 }
4213 } else {
4214 tok_str_add(&str, t);
4215 }
4216 } else {
4217 tok_str_add2(&str, t, &cval);
4218 }
4219 last_tok = t;
4220 }
4221 tok_str_add(&str, 0);
4222 return str.str;
4223 }
4224
4225 static char const ab_month_name[12][4] =
4226 {
4227 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
4228 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
4229 };
4230
4231 /* do macro substitution of current token with macro 's' and add
4232 result to (tok_str,tok_len). 'nested_list' is the list of all
4233 macros we got inside to avoid recursing. Return non zero if no
4234 substitution needs to be done */
4235 static int macro_subst_tok(TokenString *tok_str,
4236 Sym **nested_list, Sym *s, struct macro_level **can_read_stream)
4237 {
4238 Sym *args, *sa, *sa1;
4239 int mstr_allocated, parlevel, *mstr, t, t1;
4240 TokenString str;
4241 char *cstrval;
4242 CValue cval;
4243 CString cstr;
4244 char buf[32];
4245
4246 /* if symbol is a macro, prepare substitution */
4247 /* special macros */
4248 if (tok == TOK___LINE__) {
4249 snprintf(buf, sizeof(buf), "%d", file->line_num);
4250 cstrval = buf;
4251 t1 = TOK_PPNUM;
4252 goto add_cstr1;
4253 } else if (tok == TOK___FILE__) {
4254 cstrval = file->filename;
4255 goto add_cstr;
4256 } else if (tok == TOK___DATE__ || tok == TOK___TIME__) {
4257 time_t ti;
4258 struct tm *tm;
4259
4260 time(&ti);
4261 tm = localtime(&ti);
4262 if (tok == TOK___DATE__) {
4263 snprintf(buf, sizeof(buf), "%s %2d %d",
4264 ab_month_name[tm->tm_mon], tm->tm_mday, tm->tm_year + 1900);
4265 } else {
4266 snprintf(buf, sizeof(buf), "%02d:%02d:%02d",
4267 tm->tm_hour, tm->tm_min, tm->tm_sec);
4268 }
4269 cstrval = buf;
4270 add_cstr:
4271 t1 = TOK_STR;
4272 add_cstr1:
4273 cstr_new(&cstr);
4274 cstr_cat(&cstr, cstrval);
4275 cstr_ccat(&cstr, '\0');
4276 cval.cstr = &cstr;
4277 tok_str_add2(tok_str, t1, &cval);
4278 cstr_free(&cstr);
4279 } else {
4280 mstr = (int *)s->c;
4281 mstr_allocated = 0;
4282 if (s->type.t == MACRO_FUNC) {
4283 /* NOTE: we do not use next_nomacro to avoid eating the
4284 next token. XXX: find better solution */
4285 redo:
4286 if (macro_ptr) {
4287 t = *macro_ptr;
4288 if (t == 0 && can_read_stream) {
4289 /* end of macro stream: we must look at the token
4290 after in the file */
4291 struct macro_level *ml = *can_read_stream;
4292 macro_ptr = NULL;
4293 if (ml)
4294 {
4295 macro_ptr = ml->p;
4296 ml->p = NULL;
4297 *can_read_stream = ml -> prev;
4298 }
4299 goto redo;
4300 }
4301 } else {
4302 /* XXX: incorrect with comments */
4303 ch = file->buf_ptr[0];
4304 while (is_space(ch) || ch == '\n')
4305 cinp();
4306 t = ch;
4307 }
4308 if (t != '(') /* no macro subst */
4309 return -1;
4310
4311 /* argument macro */
4312 next_nomacro();
4313 next_nomacro();
4314 args = NULL;
4315 sa = s->next;
4316 /* NOTE: empty args are allowed, except if no args */
4317 for(;;) {
4318 /* handle '()' case */
4319 if (!args && !sa && tok == ')')
4320 break;
4321 if (!sa)
4322 error("macro '%s' used with too many args",
4323 get_tok_str(s->v, 0));
4324 tok_str_new(&str);
4325 parlevel = 0;
4326 /* NOTE: non zero sa->t indicates VA_ARGS */
4327 while ((parlevel > 0 ||
4328 (tok != ')' &&
4329 (tok != ',' || sa->type.t))) &&
4330 tok != -1) {
4331 if (tok == '(')
4332 parlevel++;
4333 else if (tok == ')')
4334 parlevel--;
4335 if (tok != TOK_LINEFEED)
4336 tok_str_add2(&str, tok, &tokc);
4337 next_nomacro();
4338 }
4339 tok_str_add(&str, 0);
4340 sym_push2(&args, sa->v & ~SYM_FIELD, sa->type.t, (long)str.str);
4341 sa = sa->next;
4342 if (tok == ')') {
4343 /* special case for gcc var args: add an empty
4344 var arg argument if it is omitted */
4345 if (sa && sa->type.t && gnu_ext)
4346 continue;
4347 else
4348 break;
4349 }
4350 if (tok != ',')
4351 expect(",");
4352 next_nomacro();
4353 }
4354 if (sa) {
4355 error("macro '%s' used with too few args",
4356 get_tok_str(s->v, 0));
4357 }
4358
4359 /* now subst each arg */
4360 mstr = macro_arg_subst(nested_list, mstr, args);
4361 /* free memory */
4362 sa = args;
4363 while (sa) {
4364 sa1 = sa->prev;
4365 tok_str_free((int *)sa->c);
4366 sym_free(sa);
4367 sa = sa1;
4368 }
4369 mstr_allocated = 1;
4370 }
4371 sym_push2(nested_list, s->v, 0, 0);
4372 macro_subst(tok_str, nested_list, mstr, can_read_stream);
4373 /* pop nested defined symbol */
4374 sa1 = *nested_list;
4375 *nested_list = sa1->prev;
4376 sym_free(sa1);
4377 if (mstr_allocated)
4378 tok_str_free(mstr);
4379 }
4380 return 0;
4381 }
4382
4383 /* handle the '##' operator. Return NULL if no '##' seen. Otherwise
4384 return the resulting string (which must be freed). */
4385 static inline int *macro_twosharps(const int *macro_str)
4386 {
4387 TokenSym *ts;
4388 const int *macro_ptr1, *start_macro_ptr, *ptr, *saved_macro_ptr;
4389 int t;
4390 const char *p1, *p2;
4391 CValue cval;
4392 TokenString macro_str1;
4393 CString cstr;
4394
4395 start_macro_ptr = macro_str;
4396 /* we search the first '##' */
4397 for(;;) {
4398 macro_ptr1 = macro_str;
4399 TOK_GET(t, macro_str, cval);
4400 /* nothing more to do if end of string */
4401 if (t == 0)
4402 return NULL;
4403 if (*macro_str == TOK_TWOSHARPS)
4404 break;
4405 }
4406
4407 /* we saw '##', so we need more processing to handle it */
4408 cstr_new(&cstr);
4409 tok_str_new(&macro_str1);
4410 tok = t;
4411 tokc = cval;
4412
4413 /* add all tokens seen so far */
4414 for(ptr = start_macro_ptr; ptr < macro_ptr1;) {
4415 TOK_GET(t, ptr, cval);
4416 tok_str_add2(&macro_str1, t, &cval);
4417 }
4418 saved_macro_ptr = macro_ptr;
4419 /* XXX: get rid of the use of macro_ptr here */
4420 macro_ptr = (int *)macro_str;
4421 for(;;) {
4422 while (*macro_ptr == TOK_TWOSHARPS) {
4423 macro_ptr++;
4424 macro_ptr1 = macro_ptr;
4425 t = *macro_ptr;
4426 if (t) {
4427 TOK_GET(t, macro_ptr, cval);
4428 /* We concatenate the two tokens if we have an
4429 identifier or a preprocessing number */
4430 cstr_reset(&cstr);
4431 p1 = get_tok_str(tok, &tokc);
4432 cstr_cat(&cstr, p1);
4433 p2 = get_tok_str(t, &cval);
4434 cstr_cat(&cstr, p2);
4435 cstr_ccat(&cstr, '\0');
4436
4437 if ((tok >= TOK_IDENT || tok == TOK_PPNUM) &&
4438 (t >= TOK_IDENT || t == TOK_PPNUM)) {
4439 if (tok == TOK_PPNUM) {
4440 /* if number, then create a number token */
4441 /* NOTE: no need to allocate because
4442 tok_str_add2() does it */
4443 cstr_reset(&tokcstr);
4444 tokcstr = cstr;
4445 cstr_new(&cstr);
4446 tokc.cstr = &tokcstr;
4447 } else {
4448 /* if identifier, we must do a test to
4449 validate we have a correct identifier */
4450 if (t == TOK_PPNUM) {
4451 const char *p;
4452 int c;
4453
4454 p = p2;
4455 for(;;) {
4456 c = *p;
4457 if (c == '\0')
4458 break;
4459 p++;
4460 if (!isnum(c) && !isid(c))
4461 goto error_pasting;
4462 }
4463 }
4464 ts = tok_alloc(cstr.data, strlen(cstr.data));
4465 tok = ts->tok; /* modify current token */
4466 }
4467 } else {
4468 const char *str = cstr.data;
4469 const unsigned char *q;
4470
4471 /* we look for a valid token */
4472 /* XXX: do more extensive checks */
4473 if (!strcmp(str, ">>=")) {
4474 tok = TOK_A_SAR;
4475 } else if (!strcmp(str, "<<=")) {
4476 tok = TOK_A_SHL;
4477 } else if (strlen(str) == 2) {
4478 /* search in two bytes table */
4479 q = tok_two_chars;
4480 for(;;) {
4481 if (!*q)
4482 goto error_pasting;
4483 if (q[0] == str[0] && q[1] == str[1])
4484 break;
4485 q += 3;
4486 }
4487 tok = q[2];
4488 } else {
4489 error_pasting:
4490 /* NOTE: because get_tok_str use a static buffer,
4491 we must save it */
4492 cstr_reset(&cstr);
4493 p1 = get_tok_str(tok, &tokc);
4494 cstr_cat(&cstr, p1);
4495 cstr_ccat(&cstr, '\0');
4496 p2 = get_tok_str(t, &cval);
4497 warning("pasting \"%s\" and \"%s\" does not give a valid preprocessing token", cstr.data, p2);
4498 /* cannot merge tokens: just add them separately */
4499 tok_str_add2(&macro_str1, tok, &tokc);
4500 /* XXX: free associated memory ? */
4501 tok = t;
4502 tokc = cval;
4503 }
4504 }
4505 }
4506 }
4507 tok_str_add2(&macro_str1, tok, &tokc);
4508 next_nomacro();
4509 if (tok == 0)
4510 break;
4511 }
4512 macro_ptr = (int *)saved_macro_ptr;
4513 cstr_free(&cstr);
4514 tok_str_add(&macro_str1, 0);
4515 return macro_str1.str;
4516 }
4517
4518
4519 /* do macro substitution of macro_str and add result to
4520 (tok_str,tok_len). 'nested_list' is the list of all macros we got
4521 inside to avoid recursing. */
4522 static void macro_subst(TokenString *tok_str, Sym **nested_list,
4523 const int *macro_str, struct macro_level ** can_read_stream)
4524 {
4525 Sym *s;
4526 int *macro_str1;
4527 const int *ptr;
4528 int t, ret;
4529 CValue cval;
4530 struct macro_level ml;
4531
4532 /* first scan for '##' operator handling */
4533 ptr = macro_str;
4534 macro_str1 = macro_twosharps(ptr);
4535 if (macro_str1)
4536 ptr = macro_str1;
4537 while (1) {
4538 /* NOTE: ptr == NULL can only happen if tokens are read from
4539 file stream due to a macro function call */
4540 if (ptr == NULL)
4541 break;
4542 TOK_GET(t, ptr, cval);
4543 if (t == 0)
4544 break;
4545 s = define_find(t);
4546 if (s != NULL) {
4547 /* if nested substitution, do nothing */
4548 if (sym_find2(*nested_list, t))
4549 goto no_subst;
4550 ml.p = macro_ptr;
4551 if (can_read_stream)
4552 ml.prev = *can_read_stream, *can_read_stream = &ml;
4553 macro_ptr = (int *)ptr;
4554 tok = t;
4555 ret = macro_subst_tok(tok_str, nested_list, s, can_read_stream);
4556 ptr = (int *)macro_ptr;
4557 macro_ptr = ml.p;
4558 if (can_read_stream && *can_read_stream == &ml)
4559 *can_read_stream = ml.prev;
4560 if (ret != 0)
4561 goto no_subst;
4562 } else {
4563 no_subst:
4564 tok_str_add2(tok_str, t, &cval);
4565 }
4566 }
4567 if (macro_str1)
4568 tok_str_free(macro_str1);
4569 }
4570
4571 /* return next token with macro substitution */
4572 static void next(void)
4573 {
4574 Sym *nested_list, *s;
4575 TokenString str;
4576 struct macro_level *ml;
4577
4578 redo:
4579 next_nomacro();
4580 if (!macro_ptr) {
4581 /* if not reading from macro substituted string, then try
4582 to substitute macros */
4583 if (tok >= TOK_IDENT &&
4584 (parse_flags & PARSE_FLAG_PREPROCESS)) {
4585 s = define_find(tok);
4586 if (s) {
4587 /* we have a macro: we try to substitute */
4588 tok_str_new(&str);
4589 nested_list = NULL;
4590 ml = NULL;
4591 if (macro_subst_tok(&str, &nested_list, s, &ml) == 0) {
4592 /* substitution done, NOTE: maybe empty */
4593 tok_str_add(&str, 0);
4594 macro_ptr = str.str;
4595 macro_ptr_allocated = str.str;
4596 goto redo;
4597 }
4598 }
4599 }
4600 } else {
4601 if (tok == 0) {
4602 /* end of macro or end of unget buffer */
4603 if (unget_buffer_enabled) {
4604 macro_ptr = unget_saved_macro_ptr;
4605 unget_buffer_enabled = 0;
4606 } else {
4607 /* end of macro string: free it */
4608 tok_str_free(macro_ptr_allocated);
4609 macro_ptr = NULL;
4610 }
4611 goto redo;
4612 }
4613 }
4614
4615 /* convert preprocessor tokens into C tokens */
4616 if (tok == TOK_PPNUM &&
4617 (parse_flags & PARSE_FLAG_TOK_NUM)) {
4618 parse_number((char *)tokc.cstr->data);
4619 }
4620 }
4621
4622 /* push back current token and set current token to 'last_tok'. Only
4623 identifier case handled for labels. */
4624 static inline void unget_tok(int last_tok)
4625 {
4626 int i, n;
4627 int *q;
4628 unget_saved_macro_ptr = macro_ptr;
4629 unget_buffer_enabled = 1;
4630 q = unget_saved_buffer;
4631 macro_ptr = q;
4632 *q++ = tok;
4633 n = tok_ext_size(tok) - 1;
4634 for(i=0;i<n;i++)
4635 *q++ = tokc.tab[i];
4636 *q = 0; /* end of token string */
4637 tok = last_tok;
4638 }
4639
4640
4641 void swap(int *p, int *q)
4642 {
4643 int t;
4644 t = *p;
4645 *p = *q;
4646 *q = t;
4647 }
4648
4649 void vsetc(CType *type, int r, CValue *vc)
4650 {
4651 int v;
4652
4653 if (vtop >= vstack + (VSTACK_SIZE - 1))
4654 error("memory full");
4655 /* cannot let cpu flags if other instruction are generated. Also
4656 avoid leaving VT_JMP anywhere except on the top of the stack
4657 because it would complicate the code generator. */
4658 if (vtop >= vstack) {
4659 v = vtop->r & VT_VALMASK;
4660 if (v == VT_CMP || (v & ~1) == VT_JMP)
4661 gv(RC_INT);
4662 }
4663 vtop++;
4664 vtop->type = *type;
4665 vtop->r = r;
4666 vtop->r2 = VT_CONST;
4667 vtop->c = *vc;
4668 }
4669
4670 /* push integer constant */
4671 void vpushi(int v)
4672 {
4673 CValue cval;
4674 cval.i = v;
4675 vsetc(&int_type, VT_CONST, &cval);
4676 }
4677
4678 /* push long long constant */
4679 void vpushll(long long v)
4680 {
4681 CValue cval;
4682 CType ctype;
4683 ctype.t = VT_LLONG;
4684 cval.ull = v;
4685 vsetc(&ctype, VT_CONST, &cval);
4686 }
4687
4688 /* Return a static symbol pointing to a section */
4689 static Sym *get_sym_ref(CType *type, Section *sec,
4690 unsigned long offset, unsigned long size)
4691 {
4692 int v;
4693 Sym *sym;
4694
4695 v = anon_sym++;
4696 sym = global_identifier_push(v, type->t | VT_STATIC, 0);
4697 sym->type.ref = type->ref;
4698 sym->r = VT_CONST | VT_SYM;
4699 put_extern_sym(sym, sec, offset, size);
4700 return sym;
4701 }
4702
4703 /* push a reference to a section offset by adding a dummy symbol */
4704 static void vpush_ref(CType *type, Section *sec, unsigned long offset, unsigned long size)
4705 {
4706 CValue cval;
4707
4708 cval.ul = 0;
4709 vsetc(type, VT_CONST | VT_SYM, &cval);
4710 vtop->sym = get_sym_ref(type, sec, offset, size);
4711 }
4712
4713 /* define a new external reference to a symbol 'v' of type 'u' */
4714 static Sym *external_global_sym(int v, CType *type, int r)
4715 {
4716 Sym *s;
4717
4718 s = sym_find(v);
4719 if (!s) {
4720 /* push forward reference */
4721 s = global_identifier_push(v, type->t | VT_EXTERN, 0);
4722 s->type.ref = type->ref;
4723 s->r = r | VT_CONST | VT_SYM;
4724 }
4725 return s;
4726 }
4727
4728 /* define a new external reference to a symbol 'v' of type 'u' */
4729 static Sym *external_sym(int v, CType *type, int r)
4730 {
4731 Sym *s;
4732
4733 s = sym_find(v);
4734 if (!s) {
4735 /* push forward reference */
4736 s = sym_push(v, type, r | VT_CONST | VT_SYM, 0);
4737 s->type.t |= VT_EXTERN;
4738 } else {
4739 if (!is_compatible_types(&s->type, type))
4740 error("incompatible types for redefinition of '%s'",
4741 get_tok_str(v, NULL));
4742 }
4743 return s;
4744 }
4745
4746 /* push a reference to global symbol v */
4747 static void vpush_global_sym(CType *type, int v)
4748 {
4749 Sym *sym;
4750 CValue cval;
4751
4752 sym = external_global_sym(v, type, 0);
4753 cval.ul = 0;
4754 vsetc(type, VT_CONST | VT_SYM, &cval);
4755 vtop->sym = sym;
4756 }
4757
4758 void vset(CType *type, int r, int v)
4759 {
4760 CValue cval;
4761
4762 cval.i = v;
4763 vsetc(type, r, &cval);
4764 }
4765
4766 void vseti(int r, int v)
4767 {
4768 CType type;
4769 type.t = VT_INT;
4770 vset(&type, r, v);
4771 }
4772
4773 void vswap(void)
4774 {
4775 SValue tmp;
4776
4777 tmp = vtop[0];
4778 vtop[0] = vtop[-1];
4779 vtop[-1] = tmp;
4780 }
4781
4782 void vpushv(SValue *v)
4783 {
4784 if (vtop >= vstack + (VSTACK_SIZE - 1))
4785 error("memory full");
4786 vtop++;
4787 *vtop = *v;
4788 }
4789
4790 void vdup(void)
4791 {
4792 vpushv(vtop);
4793 }
4794
4795 /* save r to the memory stack, and mark it as being free */
4796 void save_reg(int r)
4797 {
4798 int l, saved, size, align;
4799 SValue *p, sv;
4800 CType *type;
4801
4802 /* modify all stack values */
4803 saved = 0;
4804 l = 0;
4805 for(p=vstack;p<=vtop;p++) {
4806 if ((p->r & VT_VALMASK) == r ||
4807 ((p->type.t & VT_BTYPE) == VT_LLONG && (p->r2 & VT_VALMASK) == r)) {
4808 /* must save value on stack if not already done */
4809 if (!saved) {
4810 /* NOTE: must reload 'r' because r might be equal to r2 */
4811 r = p->r & VT_VALMASK;
4812 /* store register in the stack */
4813 type = &p->type;
4814 if ((p->r & VT_LVAL) ||
4815 (!is_float(type->t) && (type->t & VT_BTYPE) != VT_LLONG))
4816 #ifdef TCC_TARGET_X86_64
4817 type = &char_pointer_type;
4818 #else
4819 type = &int_type;
4820 #endif
4821 size = type_size(type, &align);
4822 loc = (loc - size) & -align;
4823 sv.type.t = type->t;
4824 sv.r = VT_LOCAL | VT_LVAL;
4825 sv.c.ul = loc;
4826 store(r, &sv);
4827 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
4828 /* x86 specific: need to pop fp register ST0 if saved */
4829 if (r == TREG_ST0) {
4830 o(0xd9dd); /* fstp %st(1) */
4831 }
4832 #endif
4833 #ifndef TCC_TARGET_X86_64
4834 /* special long long case */
4835 if ((type->t & VT_BTYPE) == VT_LLONG) {
4836 sv.c.ul += 4;
4837 store(p->r2, &sv);
4838 }
4839 #endif
4840 l = loc;
4841 saved = 1;
4842 }
4843 /* mark that stack entry as being saved on the stack */
4844 if (p->r & VT_LVAL) {
4845 /* also clear the bounded flag because the
4846 relocation address of the function was stored in
4847 p->c.ul */
4848 p->r = (p->r & ~(VT_VALMASK | VT_BOUNDED)) | VT_LLOCAL;
4849 } else {
4850 p->r = lvalue_type(p->type.t) | VT_LOCAL;
4851 }
4852 p->r2 = VT_CONST;
4853 p->c.ul = l;
4854 }
4855 }
4856 }
4857
4858 /* find a register of class 'rc2' with at most one reference on stack.
4859 * If none, call get_reg(rc) */
4860 int get_reg_ex(int rc, int rc2)
4861 {
4862 int r;
4863 SValue *p;
4864
4865 for(r=0;r<NB_REGS;r++) {
4866 if (reg_classes[r] & rc2) {
4867 int n;
4868 n=0;
4869 for(p = vstack; p <= vtop; p++) {
4870 if ((p->r & VT_VALMASK) == r ||
4871 (p->r2 & VT_VALMASK) == r)
4872 n++;
4873 }
4874 if (n <= 1)
4875 return r;
4876 }
4877 }
4878 return get_reg(rc);
4879 }
4880
4881 /* find a free register of class 'rc'. If none, save one register */
4882 int get_reg(int rc)
4883 {
4884 int r;
4885 SValue *p;
4886
4887 /* find a free register */
4888 for(r=0;r<NB_REGS;r++) {
4889 if (reg_classes[r] & rc) {
4890 for(p=vstack;p<=vtop;p++) {
4891 if ((p->r & VT_VALMASK) == r ||
4892 (p->r2 & VT_VALMASK) == r)
4893 goto notfound;
4894 }
4895 return r;
4896 }
4897 notfound: ;
4898 }
4899
4900 /* no register left : free the first one on the stack (VERY
4901 IMPORTANT to start from the bottom to ensure that we don't
4902 spill registers used in gen_opi()) */
4903 for(p=vstack;p<=vtop;p++) {
4904 r = p->r & VT_VALMASK;
4905 if (r < VT_CONST && (reg_classes[r] & rc))
4906 goto save_found;
4907 /* also look at second register (if long long) */
4908 r = p->r2 & VT_VALMASK;
4909 if (r < VT_CONST && (reg_classes[r] & rc)) {
4910 save_found:
4911 save_reg(r);
4912 return r;
4913 }
4914 }
4915 /* Should never comes here */
4916 return -1;
4917 }
4918
4919 /* save registers up to (vtop - n) stack entry */
4920 void save_regs(int n)
4921 {
4922 int r;
4923 SValue *p, *p1;
4924 p1 = vtop - n;
4925 for(p = vstack;p <= p1; p++) {
4926 r = p->r & VT_VALMASK;
4927 if (r < VT_CONST) {
4928 save_reg(r);
4929 }
4930 }
4931 }
4932
4933 /* move register 's' to 'r', and flush previous value of r to memory
4934 if needed */
4935 void move_reg(int r, int s)
4936 {
4937 SValue sv;
4938
4939 if (r != s) {
4940 save_reg(r);
4941 sv.type.t = VT_INT;
4942 sv.r = s;
4943 sv.c.ul = 0;
4944 load(r, &sv);
4945 }
4946 }
4947
4948 /* get address of vtop (vtop MUST BE an lvalue) */
4949 void gaddrof(void)
4950 {
4951 vtop->r &= ~VT_LVAL;
4952 /* tricky: if saved lvalue, then we can go back to lvalue */
4953 if ((vtop->r & VT_VALMASK) == VT_LLOCAL)
4954 vtop->r = (vtop->r & ~(VT_VALMASK | VT_LVAL_TYPE)) | VT_LOCAL | VT_LVAL;
4955 }
4956
4957 #ifdef CONFIG_TCC_BCHECK
4958 /* generate lvalue bound code */
4959 void gbound(void)
4960 {
4961 int lval_type;
4962 CType type1;
4963
4964 vtop->r &= ~VT_MUSTBOUND;
4965 /* if lvalue, then use checking code before dereferencing */
4966 if (vtop->r & VT_LVAL) {
4967 /* if not VT_BOUNDED value, then make one */
4968 if (!(vtop->r & VT_BOUNDED)) {
4969 lval_type = vtop->r & (VT_LVAL_TYPE | VT_LVAL);
4970 /* must save type because we must set it to int to get pointer */
4971 type1 = vtop->type;
4972 vtop->type.t = VT_INT;
4973 gaddrof();
4974 vpushi(0);
4975 gen_bounded_ptr_add();
4976 vtop->r |= lval_type;
4977 vtop->type = type1;
4978 }
4979 /* then check for dereferencing */
4980 gen_bounded_ptr_deref();
4981 }
4982 }
4983 #endif
4984
4985 /* store vtop a register belonging to class 'rc'. lvalues are
4986 converted to values. Cannot be used if cannot be converted to
4987 register value (such as structures). */
4988 int gv(int rc)
4989 {
4990 int r, rc2, bit_pos, bit_size, size, align, i;
4991
4992 /* NOTE: get_reg can modify vstack[] */
4993 if (vtop->type.t & VT_BITFIELD) {
4994 CType type;
4995 int bits = 32;
4996 bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f;
4997 bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
4998 /* remove bit field info to avoid loops */
4999 vtop->type.t &= ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT));
5000 /* cast to int to propagate signedness in following ops */
5001 if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
5002 type.t = VT_LLONG;
5003 bits = 64;
5004 } else
5005 type.t = VT_INT;
5006 if((vtop->type.t & VT_UNSIGNED) ||
5007 (vtop->type.t & VT_BTYPE) == VT_BOOL)
5008 type.t |= VT_UNSIGNED;
5009 gen_cast(&type);
5010 /* generate shifts */
5011 vpushi(bits - (bit_pos + bit_size));
5012 gen_op(TOK_SHL);
5013 vpushi(bits - bit_size);
5014 /* NOTE: transformed to SHR if unsigned */
5015 gen_op(TOK_SAR);
5016 r = gv(rc);
5017 } else {
5018 if (is_float(vtop->type.t) &&
5019 (vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
5020 Sym *sym;
5021 int *ptr;
5022 unsigned long offset;
5023 #if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
5024 CValue check;
5025 #endif
5026
5027 /* XXX: unify with initializers handling ? */
5028 /* CPUs usually cannot use float constants, so we store them
5029 generically in data segment */
5030 size = type_size(&vtop->type, &align);
5031 offset = (data_section->data_offset + align - 1) & -align;
5032 data_section->data_offset = offset;
5033 /* XXX: not portable yet */
5034 #if defined(__i386__) || defined(__x86_64__)
5035 /* Zero pad x87 tenbyte long doubles */
5036 if (size == LDOUBLE_SIZE)
5037 vtop->c.tab[2] &= 0xffff;
5038 #endif
5039 ptr = section_ptr_add(data_section, size);
5040 size = size >> 2;
5041 #if defined(TCC_TARGET_ARM) && !defined(TCC_ARM_VFP)
5042 check.d = 1;
5043 if(check.tab[0])
5044 for(i=0;i<size;i++)
5045 ptr[i] = vtop->c.tab[size-1-i];
5046 else
5047 #endif
5048 for(i=0;i<size;i++)
5049 ptr[i] = vtop->c.tab[i];
5050 sym = get_sym_ref(&vtop->type, data_section, offset, size << 2);
5051 vtop->r |= VT_LVAL | VT_SYM;
5052 vtop->sym = sym;
5053 vtop->c.ul = 0;
5054 }
5055 #ifdef CONFIG_TCC_BCHECK
5056 if (vtop->r & VT_MUSTBOUND)
5057 gbound();
5058 #endif
5059
5060 r = vtop->r & VT_VALMASK;
5061 rc2 = RC_INT;
5062 if (rc == RC_IRET)
5063 rc2 = RC_LRET;
5064 /* need to reload if:
5065 - constant
5066 - lvalue (need to dereference pointer)
5067 - already a register, but not in the right class */
5068 if (r >= VT_CONST ||
5069 (vtop->r & VT_LVAL) ||
5070 !(reg_classes[r] & rc) ||
5071 ((vtop->type.t & VT_BTYPE) == VT_LLONG &&
5072 !(reg_classes[vtop->r2] & rc2))) {
5073 r = get_reg(rc);
5074 #ifndef TCC_TARGET_X86_64
5075 if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
5076 int r2;
5077 unsigned long long ll;
5078 /* two register type load : expand to two words
5079 temporarily */
5080 if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
5081 /* load constant */
5082 ll = vtop->c.ull;
5083 vtop->c.ui = ll; /* first word */
5084 load(r, vtop);
5085 vtop->r = r; /* save register value */
5086 vpushi(ll >> 32); /* second word */
5087 } else if (r >= VT_CONST || /* XXX: test to VT_CONST incorrect ? */
5088 (vtop->r & VT_LVAL)) {
5089 /* We do not want to modifier the long long
5090 pointer here, so the safest (and less
5091 efficient) is to save all the other registers
5092 in the stack. XXX: totally inefficient. */
5093 save_regs(1);
5094 /* load from memory */
5095 load(r, vtop);
5096 vdup();
5097 vtop[-1].r = r; /* save register value */
5098 /* increment pointer to get second word */
5099 vtop->type.t = VT_INT;
5100 gaddrof();
5101 vpushi(4);
5102 gen_op('+');
5103 vtop->r |= VT_LVAL;
5104 } else {
5105 /* move registers */
5106 load(r, vtop);
5107 vdup();
5108 vtop[-1].r = r; /* save register value */
5109 vtop->r = vtop[-1].r2;
5110 }
5111 /* allocate second register */
5112 r2 = get_reg(rc2);
5113 load(r2, vtop);
5114 vpop();
5115 /* write second register */
5116 vtop->r2 = r2;
5117 } else
5118 #endif
5119 if ((vtop->r & VT_LVAL) && !is_float(vtop->type.t)) {
5120 int t1, t;
5121 /* lvalue of scalar type : need to use lvalue type
5122 because of possible cast */
5123 t = vtop->type.t;
5124 t1 = t;
5125 /* compute memory access type */
5126 if (vtop->r & VT_LVAL_BYTE)
5127 t = VT_BYTE;
5128 else if (vtop->r & VT_LVAL_SHORT)
5129 t = VT_SHORT;
5130 if (vtop->r & VT_LVAL_UNSIGNED)
5131 t |= VT_UNSIGNED;
5132 vtop->type.t = t;
5133 load(r, vtop);
5134 /* restore wanted type */
5135 vtop->type.t = t1;
5136 } else {
5137 /* one register type load */
5138 load(r, vtop);
5139 }
5140 }
5141 vtop->r = r;
5142 #ifdef TCC_TARGET_C67
5143 /* uses register pairs for doubles */
5144 if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
5145 vtop->r2 = r+1;
5146 #endif
5147 }
5148 return r;
5149 }
5150
5151 /* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
5152 void gv2(int rc1, int rc2)
5153 {
5154 int v;
5155
5156 /* generate more generic register first. But VT_JMP or VT_CMP
5157 values must be generated first in all cases to avoid possible
5158 reload errors */
5159 v = vtop[0].r & VT_VALMASK;
5160 if (v != VT_CMP && (v & ~1) != VT_JMP && rc1 <= rc2) {
5161 vswap();
5162 gv(rc1);
5163 vswap();
5164 gv(rc2);
5165 /* test if reload is needed for first register */
5166 if ((vtop[-1].r & VT_VALMASK) >= VT_CONST) {
5167 vswap();
5168 gv(rc1);
5169 vswap();
5170 }
5171 } else {
5172 gv(rc2);
5173 vswap();
5174 gv(rc1);
5175 vswap();
5176 /* test if reload is needed for first register */
5177 if ((vtop[0].r & VT_VALMASK) >= VT_CONST) {
5178 gv(rc2);
5179 }
5180 }
5181 }
5182
5183 /* expand long long on stack in two int registers */
5184 void lexpand(void)
5185 {
5186 int u;
5187
5188 u = vtop->type.t & VT_UNSIGNED;
5189 gv(RC_INT);
5190 vdup();
5191 vtop[0].r = vtop[-1].r2;
5192 vtop[0].r2 = VT_CONST;
5193 vtop[-1].r2 = VT_CONST;
5194 vtop[0].type.t = VT_INT | u;
5195 vtop[-1].type.t = VT_INT | u;
5196 }
5197
5198 #ifdef TCC_TARGET_ARM
5199 /* expand long long on stack */
5200 void lexpand_nr(void)
5201 {
5202 int u,v;
5203
5204 u = vtop->type.t & VT_UNSIGNED;
5205 vdup();
5206 vtop->r2 = VT_CONST;
5207 vtop->type.t = VT_INT | u;
5208 v=vtop[-1].r & (VT_VALMASK | VT_LVAL);
5209 if (v == VT_CONST) {
5210 vtop[-1].c.ui = vtop->c.ull;
5211 vtop->c.ui = vtop->c.ull >> 32;
5212 vtop->r = VT_CONST;
5213 } else if (v == (VT_LVAL|VT_CONST) || v == (VT_LVAL|VT_LOCAL)) {
5214 vtop->c.ui += 4;
5215 vtop->r = vtop[-1].r;
5216 } else if (v > VT_CONST) {
5217 vtop--;
5218 lexpand();
5219 } else
5220 vtop->r = vtop[-1].r2;
5221 vtop[-1].r2 = VT_CONST;
5222 vtop[-1].type.t = VT_INT | u;
5223 }
5224 #endif
5225
5226 /* build a long long from two ints */
5227 void lbuild(int t)
5228 {
5229 gv2(RC_INT, RC_INT);
5230 vtop[-1].r2 = vtop[0].r;
5231 vtop[-1].type.t = t;
5232 vpop();
5233 }
5234
5235 /* rotate n first stack elements to the bottom
5236 I1 ... In -> I2 ... In I1 [top is right]
5237 */
5238 void vrotb(int n)
5239 {
5240 int i;
5241 SValue tmp;
5242
5243 tmp = vtop[-n + 1];
5244 for(i=-n+1;i!=0;i++)
5245 vtop[i] = vtop[i+1];
5246 vtop[0] = tmp;
5247 }
5248
5249 /* rotate n first stack elements to the top
5250 I1 ... In -> In I1 ... I(n-1) [top is right]
5251 */
5252 void vrott(int n)
5253 {
5254 int i;
5255 SValue tmp;
5256
5257 tmp = vtop[0];
5258 for(i = 0;i < n - 1; i++)
5259 vtop[-i] = vtop[-i - 1];
5260 vtop[-n + 1] = tmp;
5261 }
5262
5263 #ifdef TCC_TARGET_ARM
5264 /* like vrott but in other direction
5265 In ... I1 -> I(n-1) ... I1 In [top is right]
5266 */
5267 void vnrott(int n)
5268 {
5269 int i;
5270 SValue tmp;
5271
5272 tmp = vtop[-n + 1];
5273 for(i = n - 1; i > 0; i--)
5274 vtop[-i] = vtop[-i + 1];
5275 vtop[0] = tmp;
5276 }
5277 #endif
5278
5279 /* pop stack value */
5280 void vpop(void)
5281 {
5282 int v;
5283 v = vtop->r & VT_VALMASK;
5284 #if defined(TCC_TARGET_I386) || defined(TCC_TARGET_X86_64)
5285 /* for x86, we need to pop the FP stack */
5286 if (v == TREG_ST0 && !nocode_wanted) {
5287 o(0xd9dd); /* fstp %st(1) */
5288 } else
5289 #endif
5290 if (v == VT_JMP || v == VT_JMPI) {
5291 /* need to put correct jump if && or || without test */
5292 gsym(vtop->c.ul);
5293 }
5294 vtop--;
5295 }
5296
5297 /* convert stack entry to register and duplicate its value in another
5298 register */
5299 void gv_dup(void)
5300 {
5301 int rc, t, r, r1;
5302 SValue sv;
5303
5304 t = vtop->type.t;
5305 if ((t & VT_BTYPE) == VT_LLONG) {
5306 lexpand();
5307 gv_dup();
5308 vswap();
5309 vrotb(3);
5310 gv_dup();
5311 vrotb(4);
5312 /* stack: H L L1 H1 */
5313 lbuild(t);
5314 vrotb(3);
5315 vrotb(3);
5316 vswap();
5317 lbuild(t);
5318 vswap();
5319 } else {
5320 /* duplicate value */
5321 rc = RC_INT;
5322 sv.type.t = VT_INT;
5323 if (is_float(t)) {
5324 rc = RC_FLOAT;
5325 #ifdef TCC_TARGET_X86_64
5326 if ((t & VT_BTYPE) == VT_LDOUBLE) {
5327 rc = RC_ST0;
5328 }
5329 #endif
5330 sv.type.t = t;
5331 }
5332 r = gv(rc);
5333 r1 = get_reg(rc);
5334 sv.r = r;
5335 sv.c.ul = 0;
5336 load(r1, &sv); /* move r to r1 */
5337 vdup();
5338 /* duplicates value */
5339 vtop->r = r1;
5340 }
5341 }
5342
5343 #ifndef TCC_TARGET_X86_64
5344 /* generate CPU independent (unsigned) long long operations */
5345 void gen_opl(int op)
5346 {
5347 int t, a, b, op1, c, i;
5348 int func;
5349 unsigned short reg_iret = REG_IRET;
5350 unsigned short reg_lret = REG_LRET;
5351 SValue tmp;
5352
5353 switch(op) {
5354 case '/':
5355 case TOK_PDIV:
5356 func = TOK___divdi3;
5357 goto gen_func;
5358 case TOK_UDIV:
5359 func = TOK___udivdi3;
5360 goto gen_func;
5361 case '%':
5362 func = TOK___moddi3;
5363 goto gen_mod_func;
5364 case TOK_UMOD:
5365 func = TOK___umoddi3;
5366 gen_mod_func:
5367 #ifdef TCC_ARM_EABI
5368 reg_iret = TREG_R2;
5369 reg_lret = TREG_R3;
5370 #endif
5371 gen_func:
5372 /* call generic long long function */
5373 vpush_global_sym(&func_old_type, func);
5374 vrott(3);
5375 gfunc_call(2);
5376 vpushi(0);
5377 vtop->r = reg_iret;
5378 vtop->r2 = reg_lret;
5379 break;
5380 case '^':
5381 case '&':
5382 case '|':
5383 case '*':
5384 case '+':
5385 case '-':
5386 t = vtop->type.t;
5387 vswap();
5388 lexpand();
5389 vrotb(3);
5390 lexpand();
5391 /* stack: L1 H1 L2 H2 */
5392 tmp = vtop[0];
5393 vtop[0] = vtop[-3];
5394 vtop[-3] = tmp;
5395 tmp = vtop[-2];
5396 vtop[-2] = vtop[-3];
5397 vtop[-3] = tmp;
5398 vswap();
5399 /* stack: H1 H2 L1 L2 */
5400 if (op == '*') {
5401 vpushv(vtop - 1);
5402 vpushv(vtop - 1);
5403 gen_op(TOK_UMULL);
5404 lexpand();
5405 /* stack: H1 H2 L1 L2 ML MH */
5406 for(i=0;i<4;i++)
5407 vrotb(6);
5408 /* stack: ML MH H1 H2 L1 L2 */
5409 tmp = vtop[0];
5410 vtop[0] = vtop[-2];
5411 vtop[-2] = tmp;
5412 /* stack: ML MH H1 L2 H2 L1 */
5413 gen_op('*');
5414 vrotb(3);
5415 vrotb(3);
5416 gen_op('*');
5417 /* stack: ML MH M1 M2 */
5418 gen_op('+');
5419 gen_op('+');
5420 } else if (op == '+' || op == '-') {
5421 /* XXX: add non carry method too (for MIPS or alpha) */
5422 if (op == '+')
5423 op1 = TOK_ADDC1;
5424 else
5425 op1 = TOK_SUBC1;
5426 gen_op(op1);
5427 /* stack: H1 H2 (L1 op L2) */
5428 vrotb(3);
5429 vrotb(3);
5430 gen_op(op1 + 1); /* TOK_xxxC2 */
5431 } else {
5432 gen_op(op);
5433 /* stack: H1 H2 (L1 op L2) */
5434 vrotb(3);
5435 vrotb(3);
5436 /* stack: (L1 op L2) H1 H2 */
5437 gen_op(op);
5438 /* stack: (L1 op L2) (H1 op H2) */
5439 }
5440 /* stack: L H */
5441 lbuild(t);
5442 break;
5443 case TOK_SAR:
5444 case TOK_SHR:
5445 case TOK_SHL:
5446 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
5447 t = vtop[-1].type.t;
5448 vswap();
5449 lexpand();
5450 vrotb(3);
5451 /* stack: L H shift */
5452 c = (int)vtop->c.i;
5453 /* constant: simpler */
5454 /* NOTE: all comments are for SHL. the other cases are
5455 done by swaping words */
5456 vpop();
5457 if (op != TOK_SHL)
5458 vswap();
5459 if (c >= 32) {
5460 /* stack: L H */
5461 vpop();
5462 if (c > 32) {
5463 vpushi(c - 32);
5464 gen_op(op);
5465 }
5466 if (op != TOK_SAR) {
5467 vpushi(0);
5468 } else {
5469 gv_dup();
5470 vpushi(31);
5471 gen_op(TOK_SAR);
5472 }
5473 vswap();
5474 } else {
5475 vswap();
5476 gv_dup();
5477 /* stack: H L L */
5478 vpushi(c);
5479 gen_op(op);
5480 vswap();
5481 vpushi(32 - c);
5482 if (op == TOK_SHL)
5483 gen_op(TOK_SHR);
5484 else
5485 gen_op(TOK_SHL);
5486 vrotb(3);
5487 /* stack: L L H */
5488 vpushi(c);
5489 if (op == TOK_SHL)
5490 gen_op(TOK_SHL);
5491 else
5492 gen_op(TOK_SHR);
5493 gen_op('|');
5494 }
5495 if (op != TOK_SHL)
5496 vswap();
5497 lbuild(t);
5498 } else {
5499 /* XXX: should provide a faster fallback on x86 ? */
5500 switch(op) {
5501 case TOK_SAR:
5502 func = TOK___ashrdi3;
5503 goto gen_func;
5504 case TOK_SHR:
5505 func = TOK___lshrdi3;
5506 goto gen_func;
5507 case TOK_SHL:
5508 func = TOK___ashldi3;
5509 goto gen_func;
5510 }
5511 }
5512 break;
5513 default:
5514 /* compare operations */
5515 t = vtop->type.t;
5516 vswap();
5517 lexpand();
5518 vrotb(3);
5519 lexpand();
5520 /* stack: L1 H1 L2 H2 */
5521 tmp = vtop[-1];
5522 vtop[-1] = vtop[-2];
5523 vtop[-2] = tmp;
5524 /* stack: L1 L2 H1 H2 */
5525 /* compare high */
5526 op1 = op;
5527 /* when values are equal, we need to compare low words. since
5528 the jump is inverted, we invert the test too. */
5529 if (op1 == TOK_LT)
5530 op1 = TOK_LE;
5531 else if (op1 == TOK_GT)
5532 op1 = TOK_GE;
5533 else if (op1 == TOK_ULT)
5534 op1 = TOK_ULE;
5535 else if (op1 == TOK_UGT)
5536 op1 = TOK_UGE;
5537 a = 0;
5538 b = 0;
5539 gen_op(op1);
5540 if (op1 != TOK_NE) {
5541 a = gtst(1, 0);
5542 }
5543 if (op != TOK_EQ) {
5544 /* generate non equal test */
5545 /* XXX: NOT PORTABLE yet */
5546 if (a == 0) {
5547 b = gtst(0, 0);
5548 } else {
5549 #if defined(TCC_TARGET_I386)
5550 b = psym(0x850f, 0);
5551 #elif defined(TCC_TARGET_ARM)
5552 b = ind;
5553 o(0x1A000000 | encbranch(ind, 0, 1));
5554 #elif defined(TCC_TARGET_C67)
5555 error("not implemented");
5556 #else
5557 #error not supported
5558 #endif
5559 }
5560 }
5561 /* compare low. Always unsigned */
5562 op1 = op;
5563 if (op1 == TOK_LT)
5564 op1 = TOK_ULT;
5565 else if (op1 == TOK_LE)
5566 op1 = TOK_ULE;
5567 else if (op1 == TOK_GT)
5568 op1 = TOK_UGT;
5569 else if (op1 == TOK_GE)
5570 op1 = TOK_UGE;
5571 gen_op(op1);
5572 a = gtst(1, a);
5573 gsym(b);
5574 vseti(VT_JMPI, a);
5575 break;
5576 }
5577 }
5578 #endif
5579
5580 /* handle integer constant optimizations and various machine
5581 independent opt */
5582 void gen_opic(int op)
5583 {
5584 int c1, c2, t1, t2, n;
5585 SValue *v1, *v2;
5586 long long l1, l2;
5587 typedef unsigned long long U;
5588
5589 v1 = vtop - 1;
5590 v2 = vtop;
5591 t1 = v1->type.t & VT_BTYPE;
5592 t2 = v2->type.t & VT_BTYPE;
5593
5594 if (t1 == VT_LLONG)
5595 l1 = v1->c.ll;
5596 else if (v1->type.t & VT_UNSIGNED)
5597 l1 = v1->c.ui;
5598 else
5599 l1 = v1->c.i;
5600
5601 if (t2 == VT_LLONG)
5602 l2 = v2->c.ll;
5603 else if (v2->type.t & VT_UNSIGNED)
5604 l2 = v2->c.ui;
5605 else
5606 l2 = v2->c.i;
5607
5608 /* currently, we cannot do computations with forward symbols */
5609 c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
5610 c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
5611 if (c1 && c2) {
5612 switch(op) {
5613 case '+': l1 += l2; break;
5614 case '-': l1 -= l2; break;
5615 case '&': l1 &= l2; break;
5616 case '^': l1 ^= l2; break;
5617 case '|': l1 |= l2; break;
5618 case '*': l1 *= l2; break;
5619
5620 case TOK_PDIV:
5621 case '/':
5622 case '%':
5623 case TOK_UDIV:
5624 case TOK_UMOD:
5625 /* if division by zero, generate explicit division */
5626 if (l2 == 0) {
5627 if (const_wanted)
5628 error("division by zero in constant");
5629 goto general_case;
5630 }
5631 switch(op) {
5632 default: l1 /= l2; break;
5633 case '%': l1 %= l2; break;
5634 case TOK_UDIV: l1 = (U)l1 / l2; break;
5635 case TOK_UMOD: l1 = (U)l1 % l2; break;
5636 }
5637 break;
5638 case TOK_SHL: l1 <<= l2; break;
5639 case TOK_SHR: l1 = (U)l1 >> l2; break;
5640 case TOK_SAR: l1 >>= l2; break;
5641 /* tests */
5642 case TOK_ULT: l1 = (U)l1 < (U)l2; break;
5643 case TOK_UGE: l1 = (U)l1 >= (U)l2; break;
5644 case TOK_EQ: l1 = l1 == l2; break;
5645 case TOK_NE: l1 = l1 != l2; break;
5646 case TOK_ULE: l1 = (U)l1 <= (U)l2; break;
5647 case TOK_UGT: l1 = (U)l1 > (U)l2; break;
5648 case TOK_LT: l1 = l1 < l2; break;
5649 case TOK_GE: l1 = l1 >= l2; break;
5650 case TOK_LE: l1 = l1 <= l2; break;
5651 case TOK_GT: l1 = l1 > l2; break;
5652 /* logical */
5653 case TOK_LAND: l1 = l1 && l2; break;
5654 case TOK_LOR: l1 = l1 || l2; break;
5655 default:
5656 goto general_case;
5657 }
5658 v1->c.ll = l1;
5659 vtop--;
5660 } else {
5661 /* if commutative ops, put c2 as constant */
5662 if (c1 && (op == '+' || op == '&' || op == '^' ||
5663 op == '|' || op == '*')) {
5664 vswap();
5665 c2 = c1; //c = c1, c1 = c2, c2 = c;
5666 l2 = l1; //l = l1, l1 = l2, l2 = l;
5667 }
5668 /* Filter out NOP operations like x*1, x-0, x&-1... */
5669 if (c2 && (((op == '*' || op == '/' || op == TOK_UDIV ||
5670 op == TOK_PDIV) &&
5671 l2 == 1) ||
5672 ((op == '+' || op == '-' || op == '|' || op == '^' ||
5673 op == TOK_SHL || op == TOK_SHR || op == TOK_SAR) &&
5674 l2 == 0) ||
5675 (op == '&' &&
5676 l2 == -1))) {
5677 /* nothing to do */
5678 vtop--;
5679 } else if (c2 && (op == '*' || op == TOK_PDIV || op == TOK_UDIV)) {
5680 /* try to use shifts instead of muls or divs */
5681 if (l2 > 0 && (l2 & (l2 - 1)) == 0) {
5682 n = -1;
5683 while (l2) {
5684 l2 >>= 1;
5685 n++;
5686 }
5687 vtop->c.ll = n;
5688 if (op == '*')
5689 op = TOK_SHL;
5690 else if (op == TOK_PDIV)
5691 op = TOK_SAR;
5692 else
5693 op = TOK_SHR;
5694 }
5695 goto general_case;
5696 } else if (c2 && (op == '+' || op == '-') &&
5697 ((vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM)) ==
5698 (VT_CONST | VT_SYM) ||
5699 (vtop[-1].r & (VT_VALMASK | VT_LVAL)) == VT_LOCAL)) {
5700 /* symbol + constant case */
5701 if (op == '-')
5702 l2 = -l2;
5703 vtop--;
5704 vtop->c.ll += l2;
5705 } else {
5706 general_case:
5707 if (!nocode_wanted) {
5708 /* call low level op generator */
5709 if (t1 == VT_LLONG || t2 == VT_LLONG)
5710 gen_opl(op);
5711 else
5712 gen_opi(op);
5713 } else {
5714 vtop--;
5715 }
5716 }
5717 }
5718 }
5719
5720 /* generate a floating point operation with constant propagation */
5721 void gen_opif(int op)
5722 {
5723 int c1, c2;
5724 SValue *v1, *v2;
5725 long double f1, f2;
5726
5727 v1 = vtop - 1;
5728 v2 = vtop;
5729 /* currently, we cannot do computations with forward symbols */
5730 c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
5731 c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
5732 if (c1 && c2) {
5733 if (v1->type.t == VT_FLOAT) {
5734 f1 = v1->c.f;
5735 f2 = v2->c.f;
5736 } else if (v1->type.t == VT_DOUBLE) {
5737 f1 = v1->c.d;
5738 f2 = v2->c.d;
5739 } else {
5740 f1 = v1->c.ld;
5741 f2 = v2->c.ld;
5742 }
5743
5744 /* NOTE: we only do constant propagation if finite number (not
5745 NaN or infinity) (ANSI spec) */
5746 if (!ieee_finite(f1) || !ieee_finite(f2))
5747 goto general_case;
5748
5749 switch(op) {
5750 case '+': f1 += f2; break;
5751 case '-': f1 -= f2; break;
5752 case '*': f1 *= f2; break;
5753 case '/':
5754 if (f2 == 0.0) {
5755 if (const_wanted)
5756 error("division by zero in constant");
5757 goto general_case;
5758 }
5759 f1 /= f2;
5760 break;
5761 /* XXX: also handles tests ? */
5762 default:
5763 goto general_case;
5764 }
5765 /* XXX: overflow test ? */
5766 if (v1->type.t == VT_FLOAT) {
5767 v1->c.f = f1;
5768 } else if (v1->type.t == VT_DOUBLE) {
5769 v1->c.d = f1;
5770 } else {
5771 v1->c.ld = f1;
5772 }
5773 vtop--;
5774 } else {
5775 general_case:
5776 if (!nocode_wanted) {
5777 gen_opf(op);
5778 } else {
5779 vtop--;
5780 }
5781 }
5782 }
5783
5784 static int pointed_size(CType *type)
5785 {
5786 int align;
5787 return type_size(pointed_type(type), &align);
5788 }
5789
5790 static inline int is_null_pointer(SValue *p)
5791 {
5792 if ((p->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
5793 return 0;
5794 return ((p->type.t & VT_BTYPE) == VT_INT && p->c.i == 0) ||
5795 ((p->type.t & VT_BTYPE) == VT_LLONG && p->c.ll == 0);
5796 }
5797
5798 static inline int is_integer_btype(int bt)
5799 {
5800 return (bt == VT_BYTE || bt == VT_SHORT ||
5801 bt == VT_INT || bt == VT_LLONG);
5802 }
5803
5804 /* check types for comparison or substraction of pointers */
5805 static void check_comparison_pointer_types(SValue *p1, SValue *p2, int op)
5806 {
5807 CType *type1, *type2, tmp_type1, tmp_type2;
5808 int bt1, bt2;
5809
5810 /* null pointers are accepted for all comparisons as gcc */
5811 if (is_null_pointer(p1) || is_null_pointer(p2))
5812 return;
5813 type1 = &p1->type;
5814 type2 = &p2->type;
5815 bt1 = type1->t & VT_BTYPE;
5816 bt2 = type2->t & VT_BTYPE;
5817 /* accept comparison between pointer and integer with a warning */
5818 if ((is_integer_btype(bt1) || is_integer_btype(bt2)) && op != '-') {
5819 if (op != TOK_LOR && op != TOK_LAND )
5820 warning("comparison between pointer and integer");
5821 return;
5822 }
5823
5824 /* both must be pointers or implicit function pointers */
5825 if (bt1 == VT_PTR) {
5826 type1 = pointed_type(type1);
5827 } else if (bt1 != VT_FUNC)
5828 goto invalid_operands;
5829
5830 if (bt2 == VT_PTR) {
5831 type2 = pointed_type(type2);
5832 } else if (bt2 != VT_FUNC) {
5833 invalid_operands:
5834 error("invalid operands to binary %s", get_tok_str(op, NULL));
5835 }
5836 if ((type1->t & VT_BTYPE) == VT_VOID ||
5837 (type2->t & VT_BTYPE) == VT_VOID)
5838 return;
5839 tmp_type1 = *type1;
5840 tmp_type2 = *type2;
5841 tmp_type1.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
5842 tmp_type2.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
5843 if (!is_compatible_types(&tmp_type1, &tmp_type2)) {
5844 /* gcc-like error if '-' is used */
5845 if (op == '-')
5846 goto invalid_operands;
5847 else
5848 warning("comparison of distinct pointer types lacks a cast");
5849 }
5850 }
5851
5852 /* generic gen_op: handles types problems */
5853 void gen_op(int op)
5854 {
5855 int u, t1, t2, bt1, bt2, t;
5856 CType type1;
5857
5858 t1 = vtop[-1].type.t;
5859 t2 = vtop[0].type.t;
5860 bt1 = t1 & VT_BTYPE;
5861 bt2 = t2 & VT_BTYPE;
5862
5863 if (bt1 == VT_PTR || bt2 == VT_PTR) {
5864 /* at least one operand is a pointer */
5865 /* relationnal op: must be both pointers */
5866 if (op >= TOK_ULT && op <= TOK_LOR) {
5867 check_comparison_pointer_types(vtop - 1, vtop, op);
5868 /* pointers are handled are unsigned */
5869 #ifdef TCC_TARGET_X86_64
5870 t = VT_LLONG | VT_UNSIGNED;
5871 #else
5872 t = VT_INT | VT_UNSIGNED;
5873 #endif
5874 goto std_op;
5875 }
5876 /* if both pointers, then it must be the '-' op */
5877 if (bt1 == VT_PTR && bt2 == VT_PTR) {
5878 if (op != '-')
5879 error("cannot use pointers here");
5880 check_comparison_pointer_types(vtop - 1, vtop, op);
5881 /* XXX: check that types are compatible */
5882 u = pointed_size(&vtop[-1].type);
5883 gen_opic(op);
5884 /* set to integer type */
5885 #ifdef TCC_TARGET_X86_64
5886 vtop->type.t = VT_LLONG;
5887 #else
5888 vtop->type.t = VT_INT;
5889 #endif
5890 vpushi(u);
5891 gen_op(TOK_PDIV);
5892 } else {
5893 /* exactly one pointer : must be '+' or '-'. */
5894 if (op != '-' && op != '+')
5895 error("cannot use pointers here");
5896 /* Put pointer as first operand */
5897 if (bt2 == VT_PTR) {
5898 vswap();
5899 swap(&t1, &t2);
5900 }
5901 type1 = vtop[-1].type;
5902 #ifdef TCC_TARGET_X86_64
5903 vpushll(pointed_size(&vtop[-1].type));
5904 #else
5905 /* XXX: cast to int ? (long long case) */
5906 vpushi(pointed_size(&vtop[-1].type));
5907 #endif
5908 gen_op('*');
5909 #ifdef CONFIG_TCC_BCHECK
5910 /* if evaluating constant expression, no code should be
5911 generated, so no bound check */
5912 if (do_bounds_check && !const_wanted) {
5913 /* if bounded pointers, we generate a special code to
5914 test bounds */
5915 if (op == '-') {
5916 vpushi(0);
5917 vswap();
5918 gen_op('-');
5919 }
5920 gen_bounded_ptr_add();
5921 } else
5922 #endif
5923 {
5924 gen_opic(op);
5925 }
5926 /* put again type if gen_opic() swaped operands */
5927 vtop->type = type1;
5928 }
5929 } else if (is_float(bt1) || is_float(bt2)) {
5930 /* compute bigger type and do implicit casts */
5931 if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) {
5932 t = VT_LDOUBLE;
5933 } else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) {
5934 t = VT_DOUBLE;
5935 } else {
5936 t = VT_FLOAT;
5937 }
5938 /* floats can only be used for a few operations */
5939 if (op != '+' && op != '-' && op != '*' && op != '/' &&
5940 (op < TOK_ULT || op > TOK_GT))
5941 error("invalid operands for binary operation");
5942 goto std_op;
5943 } else if (bt1 == VT_LLONG || bt2 == VT_LLONG) {
5944 /* cast to biggest op */
5945 t = VT_LLONG;
5946 /* convert to unsigned if it does not fit in a long long */
5947 if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED) ||
5948 (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED))
5949 t |= VT_UNSIGNED;
5950 goto std_op;
5951 } else {
5952 /* integer operations */
5953 t = VT_INT;
5954 /* convert to unsigned if it does not fit in an integer */
5955 if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED) ||
5956 (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED))
5957 t |= VT_UNSIGNED;
5958 std_op:
5959 /* XXX: currently, some unsigned operations are explicit, so
5960 we modify them here */
5961 if (t & VT_UNSIGNED) {
5962 if (op == TOK_SAR)
5963 op = TOK_SHR;
5964 else if (op == '/')
5965 op = TOK_UDIV;
5966 else if (op == '%')
5967 op = TOK_UMOD;
5968 else if (op == TOK_LT)
5969 op = TOK_ULT;
5970 else if (op == TOK_GT)
5971 op = TOK_UGT;
5972 else if (op == TOK_LE)
5973 op = TOK_ULE;
5974 else if (op == TOK_GE)
5975 op = TOK_UGE;
5976 }
5977 vswap();
5978 type1.t = t;
5979 gen_cast(&type1);
5980 vswap();
5981 /* special case for shifts and long long: we keep the shift as
5982 an integer */
5983 if (op == TOK_SHR || op == TOK_SAR || op == TOK_SHL)
5984 type1.t = VT_INT;
5985 gen_cast(&type1);
5986 if (is_float(t))
5987 gen_opif(op);
5988 else
5989 gen_opic(op);
5990 if (op >= TOK_ULT && op <= TOK_GT) {
5991 /* relationnal op: the result is an int */
5992 vtop->type.t = VT_INT;
5993 } else {
5994 vtop->type.t = t;
5995 }
5996 }
5997 }
5998
5999 #ifndef TCC_TARGET_ARM
6000 /* generic itof for unsigned long long case */
6001 void gen_cvt_itof1(int t)
6002 {
6003 if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) ==
6004 (VT_LLONG | VT_UNSIGNED)) {
6005
6006 if (t == VT_FLOAT)
6007 vpush_global_sym(&func_old_type, TOK___floatundisf);
6008 #if LDOUBLE_SIZE != 8
6009 else if (t == VT_LDOUBLE)
6010 vpush_global_sym(&func_old_type, TOK___floatundixf);
6011 #endif
6012 else
6013 vpush_global_sym(&func_old_type, TOK___floatundidf);
6014 vrott(2);
6015 gfunc_call(1);
6016 vpushi(0);
6017 vtop->r = REG_FRET;
6018 } else {
6019 gen_cvt_itof(t);
6020 }
6021 }
6022 #endif
6023
6024 /* generic ftoi for unsigned long long case */
6025 void gen_cvt_ftoi1(int t)
6026 {
6027 int st;
6028
6029 if (t == (VT_LLONG | VT_UNSIGNED)) {
6030 /* not handled natively */
6031 st = vtop->type.t & VT_BTYPE;
6032 if (st == VT_FLOAT)
6033 vpush_global_sym(&func_old_type, TOK___fixunssfdi);
6034 #if LDOUBLE_SIZE != 8
6035 else if (st == VT_LDOUBLE)
6036 vpush_global_sym(&func_old_type, TOK___fixunsxfdi);
6037 #endif
6038 else
6039 vpush_global_sym(&func_old_type, TOK___fixunsdfdi);
6040 vrott(2);
6041 gfunc_call(1);
6042 vpushi(0);
6043 vtop->r = REG_IRET;
6044 vtop->r2 = REG_LRET;
6045 } else {
6046 gen_cvt_ftoi(t);
6047 }
6048 }
6049
6050 /* force char or short cast */
6051 void force_charshort_cast(int t)
6052 {
6053 int bits, dbt;
6054 dbt = t & VT_BTYPE;
6055 /* XXX: add optimization if lvalue : just change type and offset */
6056 if (dbt == VT_BYTE)
6057 bits = 8;
6058 else
6059 bits = 16;
6060 if (t & VT_UNSIGNED) {
6061 vpushi((1 << bits) - 1);
6062 gen_op('&');
6063 } else {
6064 bits = 32 - bits;
6065 vpushi(bits);
6066 gen_op(TOK_SHL);
6067 /* result must be signed or the SAR is converted to an SHL
6068 This was not the case when "t" was a signed short
6069 and the last value on the stack was an unsigned int */
6070 vtop->type.t &= ~VT_UNSIGNED;
6071 vpushi(bits);
6072 gen_op(TOK_SAR);
6073 }
6074 }
6075
6076 /* cast 'vtop' to 'type'. Casting to bitfields is forbidden. */
6077 static void gen_cast(CType *type)
6078 {
6079 int sbt, dbt, sf, df, c, p;
6080
6081 /* special delayed cast for char/short */
6082 /* XXX: in some cases (multiple cascaded casts), it may still
6083 be incorrect */
6084 if (vtop->r & VT_MUSTCAST) {
6085 vtop->r &= ~VT_MUSTCAST;
6086 force_charshort_cast(vtop->type.t);
6087 }
6088
6089 /* bitfields first get cast to ints */
6090 if (vtop->type.t & VT_BITFIELD) {
6091 gv(RC_INT);
6092 }
6093
6094 dbt = type->t & (VT_BTYPE | VT_UNSIGNED);
6095 sbt = vtop->type.t & (VT_BTYPE | VT_UNSIGNED);
6096
6097 if (sbt != dbt) {
6098 sf = is_float(sbt);
6099 df = is_float(dbt);
6100 c = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
6101 p = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == (VT_CONST | VT_SYM);
6102 if (c) {
6103 /* constant case: we can do it now */
6104 /* XXX: in ISOC, cannot do it if error in convert */
6105 if (sbt == VT_FLOAT)
6106 vtop->c.ld = vtop->c.f;
6107 else if (sbt == VT_DOUBLE)
6108 vtop->c.ld = vtop->c.d;
6109
6110 if (df) {
6111 if ((sbt & VT_BTYPE) == VT_LLONG) {
6112 if (sbt & VT_UNSIGNED)
6113 vtop->c.ld = vtop->c.ull;
6114 else
6115 vtop->c.ld = vtop->c.ll;
6116 } else if(!sf) {
6117 if (sbt & VT_UNSIGNED)
6118 vtop->c.ld = vtop->c.ui;
6119 else
6120 vtop->c.ld = vtop->c.i;
6121 }
6122
6123 if (dbt == VT_FLOAT)
6124 vtop->c.f = (float)vtop->c.ld;
6125 else if (dbt == VT_DOUBLE)
6126 vtop->c.d = (double)vtop->c.ld;
6127 } else if (sf && dbt == (VT_LLONG|VT_UNSIGNED)) {
6128 vtop->c.ull = (unsigned long long)vtop->c.ld;
6129 } else if (sf && dbt == VT_BOOL) {
6130 vtop->c.i = (vtop->c.ld != 0);
6131 } else {
6132 if(sf)
6133 vtop->c.ll = (long long)vtop->c.ld;
6134 else if (sbt == (VT_LLONG|VT_UNSIGNED))
6135 vtop->c.ll = vtop->c.ull;
6136 else if (sbt & VT_UNSIGNED)
6137 vtop->c.ll = vtop->c.ui;
6138 else if (sbt != VT_LLONG)
6139 vtop->c.ll = vtop->c.i;
6140
6141 if (dbt == (VT_LLONG|VT_UNSIGNED))
6142 vtop->c.ull = vtop->c.ll;
6143 else if (dbt == VT_BOOL)
6144 vtop->c.i = (vtop->c.ll != 0);
6145 else if (dbt != VT_LLONG) {
6146 int s = 0;
6147 if ((dbt & VT_BTYPE) == VT_BYTE)
6148 s = 24;
6149 else if ((dbt & VT_BTYPE) == VT_SHORT)
6150 s = 16;
6151
6152 if(dbt & VT_UNSIGNED)
6153 vtop->c.ui = ((unsigned int)vtop->c.ll << s) >> s;
6154 else
6155 vtop->c.i = ((int)vtop->c.ll << s) >> s;
6156 }
6157 }
6158 } else if (p && dbt == VT_BOOL) {
6159 vtop->r = VT_CONST;
6160 vtop->c.i = 1;
6161 } else if (!nocode_wanted) {
6162 /* non constant case: generate code */
6163 if (sf && df) {
6164 /* convert from fp to fp */
6165 gen_cvt_ftof(dbt);
6166 } else if (df) {
6167 /* convert int to fp */
6168 gen_cvt_itof1(dbt);
6169 } else if (sf) {
6170 /* convert fp to int */
6171 if (dbt == VT_BOOL) {
6172 vpushi(0);
6173 gen_op(TOK_NE);
6174 } else {
6175 /* we handle char/short/etc... with generic code */
6176 if (dbt != (VT_INT | VT_UNSIGNED) &&
6177 dbt != (VT_LLONG | VT_UNSIGNED) &&
6178 dbt != VT_LLONG)
6179 dbt = VT_INT;
6180 gen_cvt_ftoi1(dbt);
6181 if (dbt == VT_INT && (type->t & (VT_BTYPE | VT_UNSIGNED)) != dbt) {
6182 /* additional cast for char/short... */
6183 vtop->type.t = dbt;
6184 gen_cast(type);
6185 }
6186 }
6187 } else if ((dbt & VT_BTYPE) == VT_LLONG) {
6188 if ((sbt & VT_BTYPE) != VT_LLONG) {
6189 /* scalar to long long */
6190 #ifndef TCC_TARGET_X86_64
6191 /* machine independent conversion */
6192 gv(RC_INT);
6193 /* generate high word */
6194 if (sbt == (VT_INT | VT_UNSIGNED)) {
6195 vpushi(0);
6196 gv(RC_INT);
6197 } else {
6198 gv_dup();
6199 vpushi(31);
6200 gen_op(TOK_SAR);
6201 }
6202 /* patch second register */
6203 vtop[-1].r2 = vtop->r;
6204 vpop();
6205 #else
6206 int r = gv(RC_INT);
6207 if (sbt != (VT_INT | VT_UNSIGNED)) {
6208 /* x86_64 specific: movslq */
6209 o(0x6348);
6210 o(0xc0 + (REG_VALUE(r) << 3) + REG_VALUE(r));
6211 }
6212 #endif
6213 }
6214 } else if (dbt == VT_BOOL) {
6215 /* scalar to bool */
6216 vpushi(0);
6217 gen_op(TOK_NE);
6218 } else if ((dbt & VT_BTYPE) == VT_BYTE ||
6219 (dbt & VT_BTYPE) == VT_SHORT) {
6220 if (sbt == VT_PTR) {
6221 vtop->type.t = VT_INT;
6222 warning("nonportable conversion from pointer to char/short");
6223 }
6224 force_charshort_cast(dbt);
6225 } else if ((dbt & VT_BTYPE) == VT_INT) {
6226 /* scalar to int */
6227 if (sbt == VT_LLONG) {
6228 /* from long long: just take low order word */
6229 lexpand();
6230 vpop();
6231 }
6232 /* if lvalue and single word type, nothing to do because
6233 the lvalue already contains the real type size (see
6234 VT_LVAL_xxx constants) */
6235 }
6236 }
6237 } else if ((dbt & VT_BTYPE) == VT_PTR && !(vtop->r & VT_LVAL)) {
6238 /* if we are casting between pointer types,
6239 we must update the VT_LVAL_xxx size */
6240 vtop->r = (vtop->r & ~VT_LVAL_TYPE)
6241 | (lvalue_type(type->ref->type.t) & VT_LVAL_TYPE);
6242 }
6243 vtop->type = *type;
6244 }
6245
6246 /* return type size. Put alignment at 'a' */
6247 static int type_size(CType *type, int *a)
6248 {
6249 Sym *s;
6250 int bt;
6251
6252 bt = type->t & VT_BTYPE;
6253 if (bt == VT_STRUCT) {
6254 /* struct/union */
6255 s = type->ref;
6256 *a = s->r;
6257 return s->c;
6258 } else if (bt == VT_PTR) {
6259 if (type->t & VT_ARRAY) {
6260 int ts;
6261
6262 s = type->ref;
6263 ts = type_size(&s->type, a);
6264
6265 if (ts < 0 && s->c < 0)
6266 ts = -ts;
6267
6268 return ts * s->c;
6269 } else {
6270 *a = PTR_SIZE;
6271 return PTR_SIZE;
6272 }
6273 } else if (bt == VT_LDOUBLE) {
6274 *a = LDOUBLE_ALIGN;
6275 return LDOUBLE_SIZE;
6276 } else if (bt == VT_DOUBLE || bt == VT_LLONG) {
6277 #ifdef TCC_TARGET_I386
6278 #ifdef TCC_TARGET_PE
6279 *a = 8;
6280 #else
6281 *a = 4;
6282 #endif
6283 #elif defined(TCC_TARGET_ARM)
6284 #ifdef TCC_ARM_EABI
6285 *a = 8;
6286 #else
6287 *a = 4;
6288 #endif
6289 #else
6290 *a = 8;
6291 #endif
6292 return 8;
6293 } else if (bt == VT_INT || bt == VT_ENUM || bt == VT_FLOAT) {
6294 *a = 4;
6295 return 4;
6296 } else if (bt == VT_SHORT) {
6297 *a = 2;
6298 return 2;
6299 } else {
6300 /* char, void, function, _Bool */
6301 *a = 1;
6302 return 1;
6303 }
6304 }
6305
6306 /* return the pointed type of t */
6307 static inline CType *pointed_type(CType *type)
6308 {
6309 return &type->ref->type;
6310 }
6311
6312 /* modify type so that its it is a pointer to type. */
6313 static void mk_pointer(CType *type)
6314 {
6315 Sym *s;
6316 s = sym_push(SYM_FIELD, type, 0, -1);
6317 type->t = VT_PTR | (type->t & ~VT_TYPE);
6318 type->ref = s;
6319 }
6320
6321 /* compare function types. OLD functions match any new functions */
6322 static int is_compatible_func(CType *type1, CType *type2)
6323 {
6324 Sym *s1, *s2;
6325
6326 s1 = type1->ref;
6327 s2 = type2->ref;
6328 if (!is_compatible_types(&s1->type, &s2->type))
6329 return 0;
6330 /* check func_call */
6331 if (FUNC_CALL(s1->r) != FUNC_CALL(s2->r))
6332 return 0;
6333 /* XXX: not complete */
6334 if (s1->c == FUNC_OLD || s2->c == FUNC_OLD)
6335 return 1;
6336 if (s1->c != s2->c)
6337 return 0;
6338 while (s1 != NULL) {
6339 if (s2 == NULL)
6340 return 0;
6341 if (!is_compatible_parameter_types(&s1->type, &s2->type))
6342 return 0;
6343 s1 = s1->next;
6344 s2 = s2->next;
6345 }
6346 if (s2)
6347 return 0;
6348 return 1;
6349 }
6350
6351 /* return true if type1 and type2 are the same. If unqualified is
6352 true, qualifiers on the types are ignored.
6353
6354 - enums are not checked as gcc __builtin_types_compatible_p ()
6355 */
6356 static int compare_types(CType *type1, CType *type2, int unqualified)
6357 {
6358 int bt1, t1, t2;
6359
6360 t1 = type1->t & VT_TYPE;
6361 t2 = type2->t & VT_TYPE;
6362 if (unqualified) {
6363 /* strip qualifiers before comparing */
6364 t1 &= ~(VT_CONSTANT | VT_VOLATILE);
6365 t2 &= ~(VT_CONSTANT | VT_VOLATILE);
6366 }
6367 /* XXX: bitfields ? */
6368 if (t1 != t2)
6369 return 0;
6370 /* test more complicated cases */
6371 bt1 = t1 & VT_BTYPE;
6372 if (bt1 == VT_PTR) {
6373 type1 = pointed_type(type1);
6374 type2 = pointed_type(type2);
6375 return is_compatible_types(type1, type2);
6376 } else if (bt1 == VT_STRUCT) {
6377 return (type1->ref == type2->ref);
6378 } else if (bt1 == VT_FUNC) {
6379 return is_compatible_func(type1, type2);
6380 } else {
6381 return 1;
6382 }
6383 }
6384
6385 /* return true if type1 and type2 are exactly the same (including
6386 qualifiers).
6387 */
6388 static int is_compatible_types(CType *type1, CType *type2)
6389 {
6390 return compare_types(type1,type2,0);
6391 }
6392
6393 /* return true if type1 and type2 are the same (ignoring qualifiers).
6394 */
6395 static int is_compatible_parameter_types(CType *type1, CType *type2)
6396 {
6397 return compare_types(type1,type2,1);
6398 }
6399
6400 /* print a type. If 'varstr' is not NULL, then the variable is also
6401 printed in the type */
6402 /* XXX: union */
6403 /* XXX: add array and function pointers */
6404 void type_to_str(char *buf, int buf_size,
6405 CType *type, const char *varstr)
6406 {
6407 int bt, v, t;
6408 Sym *s, *sa;
6409 char buf1[256];
6410 const char *tstr;
6411
6412 t = type->t & VT_TYPE;
6413 bt = t & VT_BTYPE;
6414 buf[0] = '\0';
6415 if (t & VT_CONSTANT)
6416 pstrcat(buf, buf_size, "const ");
6417 if (t & VT_VOLATILE)
6418 pstrcat(buf, buf_size, "volatile ");
6419 if (t & VT_UNSIGNED)
6420 pstrcat(buf, buf_size, "unsigned ");
6421 switch(bt) {
6422 case VT_VOID:
6423 tstr = "void";
6424 goto add_tstr;
6425 case VT_BOOL:
6426 tstr = "_Bool";
6427 goto add_tstr;
6428 case VT_BYTE:
6429 tstr = "char";
6430 goto add_tstr;
6431 case VT_SHORT:
6432 tstr = "short";
6433 goto add_tstr;
6434 case VT_INT:
6435 tstr = "int";
6436 goto add_tstr;
6437 case VT_LONG:
6438 tstr = "long";
6439 goto add_tstr;
6440 case VT_LLONG:
6441 tstr = "long long";
6442 goto add_tstr;
6443 case VT_FLOAT:
6444 tstr = "float";
6445 goto add_tstr;
6446 case VT_DOUBLE:
6447 tstr = "double";
6448 goto add_tstr;
6449 case VT_LDOUBLE:
6450 tstr = "long double";
6451 add_tstr:
6452 pstrcat(buf, buf_size, tstr);
6453 break;
6454 case VT_ENUM:
6455 case VT_STRUCT:
6456 if (bt == VT_STRUCT)
6457 tstr = "struct ";
6458 else
6459 tstr = "enum ";
6460 pstrcat(buf, buf_size, tstr);
6461 v = type->ref->v & ~SYM_STRUCT;
6462 if (v >= SYM_FIRST_ANOM)
6463 pstrcat(buf, buf_size, "<anonymous>");
6464 else
6465 pstrcat(buf, buf_size, get_tok_str(v, NULL));
6466 break;
6467 case VT_FUNC:
6468 s = type->ref;
6469 type_to_str(buf, buf_size, &s->type, varstr);
6470 pstrcat(buf, buf_size, "(");
6471 sa = s->next;
6472 while (sa != NULL) {
6473 type_to_str(buf1, sizeof(buf1), &sa->type, NULL);
6474 pstrcat(buf, buf_size, buf1);
6475 sa = sa->next;
6476 if (sa)
6477 pstrcat(buf, buf_size, ", ");
6478 }
6479 pstrcat(buf, buf_size, ")");
6480 goto no_var;
6481 case VT_PTR:
6482 s = type->ref;
6483 pstrcpy(buf1, sizeof(buf1), "*");
6484 if (varstr)
6485 pstrcat(buf1, sizeof(buf1), varstr);
6486 type_to_str(buf, buf_size, &s->type, buf1);
6487 goto no_var;
6488 }
6489 if (varstr) {
6490 pstrcat(buf, buf_size, " ");
6491 pstrcat(buf, buf_size, varstr);
6492 }
6493 no_var: ;
6494 }
6495
6496 /* verify type compatibility to store vtop in 'dt' type, and generate
6497 casts if needed. */
6498 static void gen_assign_cast(CType *dt)
6499 {
6500 CType *st, *type1, *type2, tmp_type1, tmp_type2;
6501 char buf1[256], buf2[256];
6502 int dbt, sbt;
6503
6504 st = &vtop->type; /* source type */
6505 dbt = dt->t & VT_BTYPE;
6506 sbt = st->t & VT_BTYPE;
6507 if (dt->t & VT_CONSTANT)
6508 warning("assignment of read-only location");
6509 switch(dbt) {
6510 case VT_PTR:
6511 /* special cases for pointers */
6512 /* '0' can also be a pointer */
6513 if (is_null_pointer(vtop))
6514 goto type_ok;
6515 /* accept implicit pointer to integer cast with warning */
6516 if (is_integer_btype(sbt)) {
6517 warning("assignment makes pointer from integer without a cast");
6518 goto type_ok;
6519 }
6520 type1 = pointed_type(dt);
6521 /* a function is implicitely a function pointer */
6522 if (sbt == VT_FUNC) {
6523 if ((type1->t & VT_BTYPE) != VT_VOID &&
6524 !is_compatible_types(pointed_type(dt), st))
6525 goto error;
6526 else
6527 goto type_ok;
6528 }
6529 if (sbt != VT_PTR)
6530 goto error;
6531 type2 = pointed_type(st);
6532 if ((type1->t & VT_BTYPE) == VT_VOID ||
6533 (type2->t & VT_BTYPE) == VT_VOID) {
6534 /* void * can match anything */
6535 } else {
6536 /* exact type match, except for unsigned */
6537 tmp_type1 = *type1;
6538 tmp_type2 = *type2;
6539 tmp_type1.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
6540 tmp_type2.t &= ~(VT_UNSIGNED | VT_CONSTANT | VT_VOLATILE);
6541 if (!is_compatible_types(&tmp_type1, &tmp_type2))
6542 warning("assignment from incompatible pointer type");
6543 }
6544 /* check const and volatile */
6545 if ((!(type1->t & VT_CONSTANT) && (type2->t & VT_CONSTANT)) ||
6546 (!(type1->t & VT_VOLATILE) && (type2->t & VT_VOLATILE)))
6547 warning("assignment discards qualifiers from pointer target type");
6548 break;
6549 case VT_BYTE:
6550 case VT_SHORT:
6551 case VT_INT:
6552 case VT_LLONG:
6553 if (sbt == VT_PTR || sbt == VT_FUNC) {
6554 warning("assignment makes integer from pointer without a cast");
6555 }
6556 /* XXX: more tests */
6557 break;
6558 case VT_STRUCT:
6559 tmp_type1 = *dt;
6560 tmp_type2 = *st;
6561 tmp_type1.t &= ~(VT_CONSTANT | VT_VOLATILE);
6562 tmp_type2.t &= ~(VT_CONSTANT | VT_VOLATILE);
6563 if (!is_compatible_types(&tmp_type1, &tmp_type2)) {
6564 error:
6565 type_to_str(buf1, sizeof(buf1), st, NULL);
6566 type_to_str(buf2, sizeof(buf2), dt, NULL);
6567 error("cannot cast '%s' to '%s'", buf1, buf2);
6568 }
6569 break;
6570 }
6571 type_ok:
6572 gen_cast(dt);
6573 }
6574
6575 /* store vtop in lvalue pushed on stack */
6576 void vstore(void)
6577 {
6578 int sbt, dbt, ft, r, t, size, align, bit_size, bit_pos, rc, delayed_cast;
6579
6580 ft = vtop[-1].type.t;
6581 sbt = vtop->type.t & VT_BTYPE;
6582 dbt = ft & VT_BTYPE;
6583 if (((sbt == VT_INT || sbt == VT_SHORT) && dbt == VT_BYTE) ||
6584 (sbt == VT_INT && dbt == VT_SHORT)) {
6585 /* optimize char/short casts */
6586 delayed_cast = VT_MUSTCAST;
6587 vtop->type.t = ft & (VT_TYPE & ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT)));
6588 /* XXX: factorize */
6589 if (ft & VT_CONSTANT)
6590 warning("assignment of read-only location");
6591 } else {
6592 delayed_cast = 0;
6593 if (!(ft & VT_BITFIELD))
6594 gen_assign_cast(&vtop[-1].type);
6595 }
6596
6597 if (sbt == VT_STRUCT) {
6598 /* if structure, only generate pointer */
6599 /* structure assignment : generate memcpy */
6600 /* XXX: optimize if small size */
6601 if (!nocode_wanted) {
6602 size = type_size(&vtop->type, &align);
6603
6604 #ifdef TCC_ARM_EABI
6605 if(!(align & 7))
6606 vpush_global_sym(&func_old_type, TOK_memcpy8);
6607 else if(!(align & 3))
6608 vpush_global_sym(&func_old_type, TOK_memcpy4);
6609 else
6610 #endif
6611 vpush_global_sym(&func_old_type, TOK_memcpy);
6612
6613 /* destination */
6614 vpushv(vtop - 2);
6615 vtop->type.t = VT_INT;
6616 gaddrof();
6617 /* source */
6618 vpushv(vtop - 2);
6619 vtop->type.t = VT_INT;
6620 gaddrof();
6621 /* type size */
6622 vpushi(size);
6623 gfunc_call(3);
6624
6625 vswap();
6626 vpop();
6627 } else {
6628 vswap();
6629 vpop();
6630 }
6631 /* leave source on stack */
6632 } else if (ft & VT_BITFIELD) {
6633 /* bitfield store handling */
6634 bit_pos = (ft >> VT_STRUCT_SHIFT) & 0x3f;
6635 bit_size = (ft >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
6636 /* remove bit field info to avoid loops */
6637 vtop[-1].type.t = ft & ~(VT_BITFIELD | (-1 << VT_STRUCT_SHIFT));
6638
6639 /* duplicate source into other register */
6640 gv_dup();
6641 vswap();
6642 vrott(3);
6643
6644 if((ft & VT_BTYPE) == VT_BOOL) {
6645 gen_cast(&vtop[-1].type);
6646 vtop[-1].type.t = (vtop[-1].type.t & ~VT_BTYPE) | (VT_BYTE | VT_UNSIGNED);
6647 }
6648
6649 /* duplicate destination */
6650 vdup();
6651 vtop[-1] = vtop[-2];
6652
6653 /* mask and shift source */
6654 if((ft & VT_BTYPE) != VT_BOOL) {
6655 if((ft & VT_BTYPE) == VT_LLONG) {
6656 vpushll((1ULL << bit_size) - 1ULL);
6657 } else {
6658 vpushi((1 << bit_size) - 1);
6659 }
6660 gen_op('&');
6661 }
6662 vpushi(bit_pos);
6663 gen_op(TOK_SHL);
6664 /* load destination, mask and or with source */
6665 vswap();
6666 if((ft & VT_BTYPE) == VT_LLONG) {
6667 vpushll(~(((1ULL << bit_size) - 1ULL) << bit_pos));
6668 } else {
6669 vpushi(~(((1 << bit_size) - 1) << bit_pos));
6670 }
6671 gen_op('&');
6672 gen_op('|');
6673 /* store result */
6674 vstore();
6675
6676 /* pop off shifted source from "duplicate source..." above */
6677 vpop();
6678
6679 } else {
6680 #ifdef CONFIG_TCC_BCHECK
6681 /* bound check case */
6682 if (vtop[-1].r & VT_MUSTBOUND) {
6683 vswap();
6684 gbound();
6685 vswap();
6686 }
6687 #endif
6688 if (!nocode_wanted) {
6689 rc = RC_INT;
6690 if (is_float(ft)) {
6691 rc = RC_FLOAT;
6692 #ifdef TCC_TARGET_X86_64
6693 if ((ft & VT_BTYPE) == VT_LDOUBLE) {
6694 rc = RC_ST0;
6695 }
6696 #endif
6697 }
6698 r = gv(rc); /* generate value */
6699 /* if lvalue was saved on stack, must read it */
6700 if ((vtop[-1].r & VT_VALMASK) == VT_LLOCAL) {
6701 SValue sv;
6702 t = get_reg(RC_INT);
6703 #ifdef TCC_TARGET_X86_64
6704 sv.type.t = VT_PTR;
6705 #else
6706 sv.type.t = VT_INT;
6707 #endif
6708 sv.r = VT_LOCAL | VT_LVAL;
6709 sv.c.ul = vtop[-1].c.ul;
6710 load(t, &sv);
6711 vtop[-1].r = t | VT_LVAL;
6712 }
6713 store(r, vtop - 1);
6714 #ifndef TCC_TARGET_X86_64
6715 /* two word case handling : store second register at word + 4 */
6716 if ((ft & VT_BTYPE) == VT_LLONG) {
6717 vswap();
6718 /* convert to int to increment easily */
6719 vtop->type.t = VT_INT;
6720 gaddrof();
6721 vpushi(4);
6722 gen_op('+');
6723 vtop->r |= VT_LVAL;
6724 vswap();
6725 /* XXX: it works because r2 is spilled last ! */
6726 store(vtop->r2, vtop - 1);
6727 }
6728 #endif
6729 }
6730 vswap();
6731 vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
6732 vtop->r |= delayed_cast;
6733 }
6734 }
6735
6736 /* post defines POST/PRE add. c is the token ++ or -- */
6737 void inc(int post, int c)
6738 {
6739 test_lvalue();
6740 vdup(); /* save lvalue */
6741 if (post) {
6742 gv_dup(); /* duplicate value */
6743 vrotb(3);
6744 vrotb(3);
6745 }
6746 /* add constant */
6747 vpushi(c - TOK_MID);
6748 gen_op('+');
6749 vstore(); /* store value */
6750 if (post)
6751 vpop(); /* if post op, return saved value */
6752 }
6753
6754 /* Parse GNUC __attribute__ extension. Currently, the following
6755 extensions are recognized:
6756 - aligned(n) : set data/function alignment.
6757 - packed : force data alignment to 1
6758 - section(x) : generate data/code in this section.
6759 - unused : currently ignored, but may be used someday.
6760 - regparm(n) : pass function parameters in registers (i386 only)
6761 */
6762 static void parse_attribute(AttributeDef *ad)
6763 {
6764 int t, n;
6765
6766 while (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2) {
6767 next();
6768 skip('(');
6769 skip('(');
6770 while (tok != ')') {
6771 if (tok < TOK_IDENT)
6772 expect("attribute name");
6773 t = tok;
6774 next();
6775 switch(t) {
6776 case TOK_SECTION1:
6777 case TOK_SECTION2:
6778 skip('(');
6779 if (tok != TOK_STR)
6780 expect("section name");
6781 ad->section = find_section(tcc_state, (char *)tokc.cstr->data);
6782 next();
6783 skip(')');
6784 break;
6785 case TOK_ALIGNED1:
6786 case TOK_ALIGNED2:
6787 if (tok == '(') {
6788 next();
6789 n = expr_const();
6790 if (n <= 0 || (n & (n - 1)) != 0)
6791 error("alignment must be a positive power of two");
6792 skip(')');
6793 } else {
6794 n = MAX_ALIGN;
6795 }
6796 ad->aligned = n;
6797 break;
6798 case TOK_PACKED1:
6799 case TOK_PACKED2:
6800 ad->packed = 1;
6801 break;
6802 case TOK_UNUSED1:
6803 case TOK_UNUSED2:
6804 /* currently, no need to handle it because tcc does not
6805 track unused objects */
6806 break;
6807 case TOK_NORETURN1:
6808 case TOK_NORETURN2:
6809 /* currently, no need to handle it because tcc does not
6810 track unused objects */
6811 break;
6812 case TOK_CDECL1:
6813 case TOK_CDECL2:
6814 case TOK_CDECL3:
6815 FUNC_CALL(ad->func_attr) = FUNC_CDECL;
6816 break;
6817 case TOK_STDCALL1:
6818 case TOK_STDCALL2:
6819 case TOK_STDCALL3:
6820 FUNC_CALL(ad->func_attr) = FUNC_STDCALL;
6821 break;
6822 #ifdef TCC_TARGET_I386
6823 case TOK_REGPARM1:
6824 case TOK_REGPARM2:
6825 skip('(');
6826 n = expr_const();
6827 if (n > 3)
6828 n = 3;
6829 else if (n < 0)
6830 n = 0;
6831 if (n > 0)
6832 FUNC_CALL(ad->func_attr) = FUNC_FASTCALL1 + n - 1;
6833 skip(')');
6834 break;
6835 case TOK_FASTCALL1:
6836 case TOK_FASTCALL2:
6837 case TOK_FASTCALL3:
6838 FUNC_CALL(ad->func_attr) = FUNC_FASTCALLW;
6839 break;
6840 #endif
6841 case TOK_DLLEXPORT:
6842 FUNC_EXPORT(ad->func_attr) = 1;
6843 break;
6844 default:
6845 if (tcc_state->warn_unsupported)
6846 warning("'%s' attribute ignored", get_tok_str(t, NULL));
6847 /* skip parameters */
6848 if (tok == '(') {
6849 int parenthesis = 0;
6850 do {
6851 if (tok == '(')
6852 parenthesis++;
6853 else if (tok == ')')
6854 parenthesis--;
6855 next();
6856 } while (parenthesis && tok != -1);
6857 }
6858 break;
6859 }
6860 if (tok != ',')
6861 break;
6862 next();
6863 }
6864 skip(')');
6865 skip(')');
6866 }
6867 }
6868
6869 /* enum/struct/union declaration. u is either VT_ENUM or VT_STRUCT */
6870 static void struct_decl(CType *type, int u)
6871 {
6872 int a, v, size, align, maxalign, c, offset;
6873 int bit_size, bit_pos, bsize, bt, lbit_pos, prevbt;
6874 Sym *s, *ss, *ass, **ps;
6875 AttributeDef ad;
6876 CType type1, btype;
6877
6878 a = tok; /* save decl type */
6879 next();
6880 if (tok != '{') {
6881 v = tok;
6882 next();
6883 /* struct already defined ? return it */
6884 if (v < TOK_IDENT)
6885 expect("struct/union/enum name");
6886 s = struct_find(v);
6887 if (s) {
6888 if (s->type.t != a)
6889 error("invalid type");
6890 goto do_decl;
6891 }
6892 } else {
6893 v = anon_sym++;
6894 }
6895 type1.t = a;
6896 /* we put an undefined size for struct/union */
6897 s = sym_push(v | SYM_STRUCT, &type1, 0, -1);
6898 s->r = 0; /* default alignment is zero as gcc */
6899 /* put struct/union/enum name in type */
6900 do_decl:
6901 type->t = u;
6902 type->ref = s;
6903
6904 if (tok == '{') {
6905 next();
6906 if (s->c != -1)
6907 error("struct/union/enum already defined");
6908 /* cannot be empty */
6909 c = 0;
6910 /* non empty enums are not allowed */
6911 if (a == TOK_ENUM) {
6912 for(;;) {
6913 v = tok;
6914 if (v < TOK_UIDENT)
6915 expect("identifier");
6916 next();
6917 if (tok == '=') {
6918 next();
6919 c = expr_const();
6920 }
6921 /* enum symbols have static storage */
6922 ss = sym_push(v, &int_type, VT_CONST, c);
6923 ss->type.t |= VT_STATIC;
6924 if (tok != ',')
6925 break;
6926 next();
6927 c++;
6928 /* NOTE: we accept a trailing comma */
6929 if (tok == '}')
6930 break;
6931 }
6932 skip('}');
6933 } else {
6934 maxalign = 1;
6935 ps = &s->next;
6936 prevbt = VT_INT;
6937 bit_pos = 0;
6938 offset = 0;
6939 while (tok != '}') {
6940 parse_btype(&btype, &ad);
6941 while (1) {
6942 bit_size = -1;
6943 v = 0;
6944 type1 = btype;
6945 if (tok != ':') {
6946 type_decl(&type1, &ad, &v, TYPE_DIRECT | TYPE_ABSTRACT);
6947 if (v == 0 && (type1.t & VT_BTYPE) != VT_STRUCT)
6948 expect("identifier");
6949 if ((type1.t & VT_BTYPE) == VT_FUNC ||
6950 (type1.t & (VT_TYPEDEF | VT_STATIC | VT_EXTERN | VT_INLINE)))
6951 error("invalid type for '%s'",
6952 get_tok_str(v, NULL));
6953 }
6954 if (tok == ':') {
6955 next();
6956 bit_size = expr_const();
6957 /* XXX: handle v = 0 case for messages */
6958 if (bit_size < 0)
6959 error("negative width in bit-field '%s'",
6960 get_tok_str(v, NULL));
6961 if (v && bit_size == 0)
6962 error("zero width for bit-field '%s'",
6963 get_tok_str(v, NULL));
6964 }
6965 size = type_size(&type1, &align);
6966 if (ad.aligned) {
6967 if (align < ad.aligned)
6968 align = ad.aligned;
6969 } else if (ad.packed) {
6970 align = 1;
6971 } else if (*tcc_state->pack_stack_ptr) {
6972 if (align > *tcc_state->pack_stack_ptr)
6973 align = *tcc_state->pack_stack_ptr;
6974 }
6975 lbit_pos = 0;
6976 if (bit_size >= 0) {
6977 bt = type1.t & VT_BTYPE;
6978 if (bt != VT_INT &&
6979 bt != VT_BYTE &&
6980 bt != VT_SHORT &&
6981 bt != VT_BOOL &&
6982 bt != VT_ENUM &&
6983 bt != VT_LLONG)
6984 error("bitfields must have scalar type");
6985 bsize = size * 8;
6986 if (bit_size > bsize) {
6987 error("width of '%s' exceeds its type",
6988 get_tok_str(v, NULL));
6989 } else if (bit_size == bsize) {
6990 /* no need for bit fields */
6991 bit_pos = 0;
6992 } else if (bit_size == 0) {
6993 /* XXX: what to do if only padding in a
6994 structure ? */
6995 /* zero size: means to pad */
6996 bit_pos = 0;
6997 } else {
6998 /* we do not have enough room ?
6999 did the type change?
7000 is it a union? */
7001 if ((bit_pos + bit_size) > bsize ||
7002 bt != prevbt || a == TOK_UNION)
7003 bit_pos = 0;
7004 lbit_pos = bit_pos;
7005 /* XXX: handle LSB first */
7006 type1.t |= VT_BITFIELD |
7007 (bit_pos << VT_STRUCT_SHIFT) |
7008 (bit_size << (VT_STRUCT_SHIFT + 6));
7009 bit_pos += bit_size;
7010 }
7011 prevbt = bt;
7012 } else {
7013 bit_pos = 0;
7014 }
7015 if (v != 0 || (type1.t & VT_BTYPE) == VT_STRUCT) {
7016 /* add new memory data only if starting
7017 bit field */
7018 if (lbit_pos == 0) {
7019 if (a == TOK_STRUCT) {
7020 c = (c + align - 1) & -align;
7021 offset = c;
7022 if (size > 0)
7023 c += size;
7024 } else {
7025 offset = 0;
7026 if (size > c)
7027 c = size;
7028 }
7029 if (align > maxalign)
7030 maxalign = align;
7031 }
7032 #if 0
7033 printf("add field %s offset=%d",
7034 get_tok_str(v, NULL), offset);
7035 if (type1.t & VT_BITFIELD) {
7036 printf(" pos=%d size=%d",
7037 (type1.t >> VT_STRUCT_SHIFT) & 0x3f,
7038 (type1.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f);
7039 }
7040 printf("\n");
7041 #endif
7042 }
7043 if (v == 0 && (type1.t & VT_BTYPE) == VT_STRUCT) {
7044 ass = type1.ref;
7045 while ((ass = ass->next) != NULL) {
7046 ss = sym_push(ass->v, &ass->type, 0, offset + ass->c);
7047 *ps = ss;
7048 ps = &ss->next;
7049 }
7050 } else if (v) {
7051 ss = sym_push(v | SYM_FIELD, &type1, 0, offset);
7052 *ps = ss;
7053 ps = &ss->next;
7054 }
7055 if (tok == ';' || tok == TOK_EOF)
7056 break;
7057 skip(',');
7058 }
7059 skip(';');
7060 }
7061 skip('}');
7062 /* store size and alignment */
7063 s->c = (c + maxalign - 1) & -maxalign;
7064 s->r = maxalign;
7065 }
7066 }
7067 }
7068
7069 /* return 0 if no type declaration. otherwise, return the basic type
7070 and skip it.
7071 */
7072 static int parse_btype(CType *type, AttributeDef *ad)
7073 {
7074 int t, u, type_found, typespec_found, typedef_found;
7075 Sym *s;
7076 CType type1;
7077
7078 memset(ad, 0, sizeof(AttributeDef));
7079 type_found = 0;
7080 typespec_found = 0;
7081 typedef_found = 0;
7082 t = 0;
7083 while(1) {
7084 switch(tok) {
7085 case TOK_EXTENSION:
7086 /* currently, we really ignore extension */
7087 next();
7088 continue;
7089
7090 /* basic types */
7091 case TOK_CHAR:
7092 u = VT_BYTE;
7093 basic_type:
7094 next();
7095 basic_type1:
7096 if ((t & VT_BTYPE) != 0)
7097 error("too many basic types");
7098 t |= u;
7099 typespec_found = 1;
7100 break;
7101 case TOK_VOID:
7102 u = VT_VOID;
7103 goto basic_type;
7104 case TOK_SHORT:
7105 u = VT_SHORT;
7106 goto basic_type;
7107 case TOK_INT:
7108 next();
7109 typespec_found = 1;
7110 break;
7111 case TOK_LONG:
7112 next();
7113 if ((t & VT_BTYPE) == VT_DOUBLE) {
7114 t = (t & ~VT_BTYPE) | VT_LDOUBLE;
7115 } else if ((t & VT_BTYPE) == VT_LONG) {
7116 t = (t & ~VT_BTYPE) | VT_LLONG;
7117 } else {
7118 u = VT_LONG;
7119 goto basic_type1;
7120 }
7121 break;
7122 case TOK_BOOL:
7123 u = VT_BOOL;
7124 goto basic_type;
7125 case TOK_FLOAT:
7126 u = VT_FLOAT;
7127 goto basic_type;
7128 case TOK_DOUBLE:
7129 next();
7130 if ((t & VT_BTYPE) == VT_LONG) {
7131 t = (t & ~VT_BTYPE) | VT_LDOUBLE;
7132 } else {
7133 u = VT_DOUBLE;
7134 goto basic_type1;
7135 }
7136 break;
7137 case TOK_ENUM:
7138 struct_decl(&type1, VT_ENUM);
7139 basic_type2:
7140 u = type1.t;
7141 type->ref = type1.ref;
7142 goto basic_type1;
7143 case TOK_STRUCT:
7144 case TOK_UNION:
7145 struct_decl(&type1, VT_STRUCT);
7146 goto basic_type2;
7147
7148 /* type modifiers */
7149 case TOK_CONST1:
7150 case TOK_CONST2:
7151 case TOK_CONST3:
7152 t |= VT_CONSTANT;
7153 next();
7154 break;
7155 case TOK_VOLATILE1:
7156 case TOK_VOLATILE2:
7157 case TOK_VOLATILE3:
7158 t |= VT_VOLATILE;
7159 next();
7160 break;
7161 case TOK_SIGNED1:
7162 case TOK_SIGNED2:
7163 case TOK_SIGNED3:
7164 typespec_found = 1;
7165 t |= VT_SIGNED;
7166 next();
7167 break;
7168 case TOK_REGISTER:
7169 case TOK_AUTO:
7170 case TOK_RESTRICT1:
7171 case TOK_RESTRICT2:
7172 case TOK_RESTRICT3:
7173 next();
7174 break;
7175 case TOK_UNSIGNED:
7176 t |= VT_UNSIGNED;
7177 next();
7178 typespec_found = 1;
7179 break;
7180
7181 /* storage */
7182 case TOK_EXTERN:
7183 t |= VT_EXTERN;
7184 next();
7185 break;
7186 case TOK_STATIC:
7187 t |= VT_STATIC;
7188 next();
7189 break;
7190 case TOK_TYPEDEF:
7191 t |= VT_TYPEDEF;
7192 next();
7193 break;
7194 case TOK_INLINE1:
7195 case TOK_INLINE2:
7196 case TOK_INLINE3:
7197 t |= VT_INLINE;
7198 next();
7199 break;
7200
7201 /* GNUC attribute */
7202 case TOK_ATTRIBUTE1:
7203 case TOK_ATTRIBUTE2:
7204 parse_attribute(ad);
7205 break;
7206 /* GNUC typeof */
7207 case TOK_TYPEOF1:
7208 case TOK_TYPEOF2:
7209 case TOK_TYPEOF3:
7210 next();
7211 parse_expr_type(&type1);
7212 goto basic_type2;
7213 default:
7214 if (typespec_found || typedef_found)
7215 goto the_end;
7216 s = sym_find(tok);
7217 if (!s || !(s->type.t & VT_TYPEDEF))
7218 goto the_end;
7219 typedef_found = 1;
7220 t |= (s->type.t & ~VT_TYPEDEF);
7221 type->ref = s->type.ref;
7222 next();
7223 typespec_found = 1;
7224 break;
7225 }
7226 type_found = 1;
7227 }
7228 the_end:
7229 if ((t & (VT_SIGNED|VT_UNSIGNED)) == (VT_SIGNED|VT_UNSIGNED))
7230 error("signed and unsigned modifier");
7231 if (tcc_state->char_is_unsigned) {
7232 if ((t & (VT_SIGNED|VT_UNSIGNED|VT_BTYPE)) == VT_BYTE)
7233 t |= VT_UNSIGNED;
7234 }
7235 t &= ~VT_SIGNED;
7236
7237 /* long is never used as type */
7238 if ((t & VT_BTYPE) == VT_LONG)
7239 #ifndef TCC_TARGET_X86_64
7240 t = (t & ~VT_BTYPE) | VT_INT;
7241 #else
7242 t = (t & ~VT_BTYPE) | VT_LLONG;
7243 #endif
7244 type->t = t;
7245 return type_found;
7246 }
7247
7248 /* convert a function parameter type (array to pointer and function to
7249 function pointer) */
7250 static inline void convert_parameter_type(CType *pt)
7251 {
7252 /* remove const and volatile qualifiers (XXX: const could be used
7253 to indicate a const function parameter */
7254 pt->t &= ~(VT_CONSTANT | VT_VOLATILE);
7255 /* array must be transformed to pointer according to ANSI C */
7256 pt->t &= ~VT_ARRAY;
7257 if ((pt->t & VT_BTYPE) == VT_FUNC) {
7258 mk_pointer(pt);
7259 }
7260 }
7261
7262 static void post_type(CType *type, AttributeDef *ad)
7263 {
7264 int n, l, t1, arg_size, align;
7265 Sym **plast, *s, *first;
7266 AttributeDef ad1;
7267 CType pt;
7268
7269 if (tok == '(') {
7270 /* function declaration */
7271 next();
7272 l = 0;
7273 first = NULL;
7274 plast = &first;
7275 arg_size = 0;
7276 if (tok != ')') {
7277 for(;;) {
7278 /* read param name and compute offset */
7279 if (l != FUNC_OLD) {
7280 if (!parse_btype(&pt, &ad1)) {
7281 if (l) {
7282 error("invalid type");
7283 } else {
7284 l = FUNC_OLD;
7285 goto old_proto;
7286 }
7287 }
7288 l = FUNC_NEW;
7289 if ((pt.t & VT_BTYPE) == VT_VOID && tok == ')')
7290 break;
7291 type_decl(&pt, &ad1, &n, TYPE_DIRECT | TYPE_ABSTRACT);
7292 if ((pt.t & VT_BTYPE) == VT_VOID)
7293 error("parameter declared as void");
7294 arg_size += (type_size(&pt, &align) + 3) & ~3;
7295 } else {
7296 old_proto:
7297 n = tok;
7298 if (n < TOK_UIDENT)
7299 expect("identifier");
7300 pt.t = VT_INT;
7301 next();
7302 }
7303 convert_parameter_type(&pt);
7304 s = sym_push(n | SYM_FIELD, &pt, 0, 0);
7305 *plast = s;
7306 plast = &s->next;
7307 if (tok == ')')
7308 break;
7309 skip(',');
7310 if (l == FUNC_NEW && tok == TOK_DOTS) {
7311 l = FUNC_ELLIPSIS;
7312 next();
7313 break;
7314 }
7315 }
7316 }
7317 /* if no parameters, then old type prototype */
7318 if (l == 0)
7319 l = FUNC_OLD;
7320 skip(')');
7321 t1 = type->t & VT_STORAGE;
7322 /* NOTE: const is ignored in returned type as it has a special
7323 meaning in gcc / C++ */
7324 type->t &= ~(VT_STORAGE | VT_CONSTANT);
7325 post_type(type, ad);
7326 /* we push a anonymous symbol which will contain the function prototype */
7327 FUNC_ARGS(ad->func_attr) = arg_size;
7328 s = sym_push(SYM_FIELD, type, ad->func_attr, l);
7329 s->next = first;
7330 type->t = t1 | VT_FUNC;
7331 type->ref = s;
7332 } else if (tok == '[') {
7333 /* array definition */
7334 next();
7335 if (tok == TOK_RESTRICT1)
7336 next();
7337 n = -1;
7338 if (tok != ']') {
7339 n = expr_const();
7340 if (n < 0)
7341 error("invalid array size");
7342 }
7343 skip(']');
7344 /* parse next post type */
7345 t1 = type->t & VT_STORAGE;
7346 type->t &= ~VT_STORAGE;
7347 post_type(type, ad);
7348
7349 /* we push a anonymous symbol which will contain the array
7350 element type */
7351 s = sym_push(SYM_FIELD, type, 0, n);
7352 type->t = t1 | VT_ARRAY | VT_PTR;
7353 type->ref = s;
7354 }
7355 }
7356
7357 /* Parse a type declaration (except basic type), and return the type
7358 in 'type'. 'td' is a bitmask indicating which kind of type decl is
7359 expected. 'type' should contain the basic type. 'ad' is the
7360 attribute definition of the basic type. It can be modified by
7361 type_decl().
7362 */
7363 static void type_decl(CType *type, AttributeDef *ad, int *v, int td)
7364 {
7365 Sym *s;
7366 CType type1, *type2;
7367 int qualifiers;
7368
7369 while (tok == '*') {
7370 qualifiers = 0;
7371 redo:
7372 next();
7373 switch(tok) {
7374 case TOK_CONST1:
7375 case TOK_CONST2:
7376 case TOK_CONST3:
7377 qualifiers |= VT_CONSTANT;
7378 goto redo;
7379 case TOK_VOLATILE1:
7380 case TOK_VOLATILE2:
7381 case TOK_VOLATILE3:
7382 qualifiers |= VT_VOLATILE;
7383 goto redo;
7384 case TOK_RESTRICT1:
7385 case TOK_RESTRICT2:
7386 case TOK_RESTRICT3:
7387 goto redo;
7388 }
7389 mk_pointer(type);
7390 type->t |= qualifiers;
7391 }
7392
7393 /* XXX: clarify attribute handling */
7394 if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2)
7395 parse_attribute(ad);
7396
7397 /* recursive type */
7398 /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
7399 type1.t = 0; /* XXX: same as int */
7400 if (tok == '(') {
7401 next();
7402 /* XXX: this is not correct to modify 'ad' at this point, but
7403 the syntax is not clear */
7404 if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2)
7405 parse_attribute(ad);
7406 type_decl(&type1, ad, v, td);
7407 skip(')');
7408 } else {
7409 /* type identifier */
7410 if (tok >= TOK_IDENT && (td & TYPE_DIRECT)) {
7411 *v = tok;
7412 next();
7413 } else {
7414 if (!(td & TYPE_ABSTRACT))
7415 expect("identifier");
7416 *v = 0;
7417 }
7418 }
7419 post_type(type, ad);
7420 if (tok == TOK_ATTRIBUTE1 || tok == TOK_ATTRIBUTE2)
7421 parse_attribute(ad);
7422 if (!type1.t)
7423 return;
7424 /* append type at the end of type1 */
7425 type2 = &type1;
7426 for(;;) {
7427 s = type2->ref;
7428 type2 = &s->type;
7429 if (!type2->t) {
7430 *type2 = *type;
7431 break;
7432 }
7433 }
7434 *type = type1;
7435 }
7436
7437 /* compute the lvalue VT_LVAL_xxx needed to match type t. */
7438 static int lvalue_type(int t)
7439 {
7440 int bt, r;
7441 r = VT_LVAL;
7442 bt = t & VT_BTYPE;
7443 if (bt == VT_BYTE || bt == VT_BOOL)
7444 r |= VT_LVAL_BYTE;
7445 else if (bt == VT_SHORT)
7446 r |= VT_LVAL_SHORT;
7447 else
7448 return r;
7449 if (t & VT_UNSIGNED)
7450 r |= VT_LVAL_UNSIGNED;
7451 return r;
7452 }
7453
7454 /* indirection with full error checking and bound check */
7455 static void indir(void)
7456 {
7457 if ((vtop->type.t & VT_BTYPE) != VT_PTR) {
7458 if ((vtop->type.t & VT_BTYPE) == VT_FUNC)
7459 return;
7460 expect("pointer");
7461 }
7462 if ((vtop->r & VT_LVAL) && !nocode_wanted)
7463 gv(RC_INT);
7464 vtop->type = *pointed_type(&vtop->type);
7465 /* Arrays and functions are never lvalues */
7466 if (!(vtop->type.t & VT_ARRAY)
7467 && (vtop->type.t & VT_BTYPE) != VT_FUNC) {
7468 vtop->r |= lvalue_type(vtop->type.t);
7469 /* if bound checking, the referenced pointer must be checked */
7470 if (do_bounds_check)
7471 vtop->r |= VT_MUSTBOUND;
7472 }
7473 }
7474
7475 /* pass a parameter to a function and do type checking and casting */
7476 static void gfunc_param_typed(Sym *func, Sym *arg)
7477 {
7478 int func_type;
7479 CType type;
7480
7481 func_type = func->c;
7482 if (func_type == FUNC_OLD ||
7483 (func_type == FUNC_ELLIPSIS && arg == NULL)) {
7484 /* default casting : only need to convert float to double */
7485 if ((vtop->type.t & VT_BTYPE) == VT_FLOAT) {
7486 type.t = VT_DOUBLE;
7487 gen_cast(&type);
7488 }
7489 } else if (arg == NULL) {
7490 error("too many arguments to function");
7491 } else {
7492 type = arg->type;
7493 type.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */
7494 gen_assign_cast(&type);
7495 }
7496 }
7497
7498 /* parse an expression of the form '(type)' or '(expr)' and return its
7499 type */
7500 static void parse_expr_type(CType *type)
7501 {
7502 int n;
7503 AttributeDef ad;
7504
7505 skip('(');
7506 if (parse_btype(type, &ad)) {
7507 type_decl(type, &ad, &n, TYPE_ABSTRACT);
7508 } else {
7509 expr_type(type);
7510 }
7511 skip(')');
7512 }
7513
7514 static void parse_type(CType *type)
7515 {
7516 AttributeDef ad;
7517 int n;
7518
7519 if (!parse_btype(type, &ad)) {
7520 expect("type");
7521 }
7522 type_decl(type, &ad, &n, TYPE_ABSTRACT);
7523 }
7524
7525 static void vpush_tokc(int t)
7526 {
7527 CType type;
7528 type.t = t;
7529 vsetc(&type, VT_CONST, &tokc);
7530 }
7531
7532 static void unary(void)
7533 {
7534 int n, t, align, size, r;
7535 CType type;
7536 Sym *s;
7537 AttributeDef ad;
7538
7539 /* XXX: GCC 2.95.3 does not generate a table although it should be
7540 better here */
7541 tok_next:
7542 switch(tok) {
7543 case TOK_EXTENSION:
7544 next();
7545 goto tok_next;
7546 case TOK_CINT:
7547 case TOK_CCHAR:
7548 case TOK_LCHAR:
7549 vpushi(tokc.i);
7550 next();
7551 break;
7552 case TOK_CUINT:
7553 vpush_tokc(VT_INT | VT_UNSIGNED);
7554 next();
7555 break;
7556 case TOK_CLLONG:
7557 vpush_tokc(VT_LLONG);
7558 next();
7559 break;
7560 case TOK_CULLONG:
7561 vpush_tokc(VT_LLONG | VT_UNSIGNED);
7562 next();
7563 break;
7564 case TOK_CFLOAT:
7565 vpush_tokc(VT_FLOAT);
7566 next();
7567 break;
7568 case TOK_CDOUBLE:
7569 vpush_tokc(VT_DOUBLE);
7570 next();
7571 break;
7572 case TOK_CLDOUBLE:
7573 vpush_tokc(VT_LDOUBLE);
7574 next();
7575 break;
7576 case TOK___FUNCTION__:
7577 if (!gnu_ext)
7578 goto tok_identifier;
7579 /* fall thru */
7580 case TOK___FUNC__:
7581 {
7582 void *ptr;
7583 int len;
7584 /* special function name identifier */
7585 len = strlen(funcname) + 1;
7586 /* generate char[len] type */
7587 type.t = VT_BYTE;
7588 mk_pointer(&type);
7589 type.t |= VT_ARRAY;
7590 type.ref->c = len;
7591 vpush_ref(&type, data_section, data_section->data_offset, len);
7592 ptr = section_ptr_add(data_section, len);
7593 memcpy(ptr, funcname, len);
7594 next();
7595 }
7596 break;
7597 case TOK_LSTR:
7598 #ifdef TCC_TARGET_PE
7599 t = VT_SHORT | VT_UNSIGNED;
7600 #else
7601 t = VT_INT;
7602 #endif
7603 goto str_init;
7604 case TOK_STR:
7605 /* string parsing */
7606 t = VT_BYTE;
7607 str_init:
7608 if (tcc_state->warn_write_strings)
7609 t |= VT_CONSTANT;
7610 type.t = t;
7611 mk_pointer(&type);
7612 type.t |= VT_ARRAY;
7613 memset(&ad, 0, sizeof(AttributeDef));
7614 decl_initializer_alloc(&type, &ad, VT_CONST, 2, 0, 0);
7615 break;
7616 case '(':
7617 next();
7618 /* cast ? */
7619 if (parse_btype(&type, &ad)) {
7620 type_decl(&type, &ad, &n, TYPE_ABSTRACT);
7621 skip(')');
7622 /* check ISOC99 compound literal */
7623 if (tok == '{') {
7624 /* data is allocated locally by default */
7625 if (global_expr)
7626 r = VT_CONST;
7627 else
7628 r = VT_LOCAL;
7629 /* all except arrays are lvalues */
7630 if (!(type.t & VT_ARRAY))
7631 r |= lvalue_type(type.t);
7632 memset(&ad, 0, sizeof(AttributeDef));
7633 decl_initializer_alloc(&type, &ad, r, 1, 0, 0);
7634 } else {
7635 unary();
7636 gen_cast(&type);
7637 }
7638 } else if (tok == '{') {
7639 /* save all registers */
7640 save_regs(0);
7641 /* statement expression : we do not accept break/continue
7642 inside as GCC does */
7643 block(NULL, NULL, NULL, NULL, 0, 1);
7644 skip(')');
7645 } else {
7646 gexpr();
7647 skip(')');
7648 }
7649 break;
7650 case '*':
7651 next();
7652 unary();
7653 indir();
7654 break;
7655 case '&':
7656 next();
7657 unary();
7658 /* functions names must be treated as function pointers,
7659 except for unary '&' and sizeof. Since we consider that
7660 functions are not lvalues, we only have to handle it
7661 there and in function calls. */
7662 /* arrays can also be used although they are not lvalues */
7663 if ((vtop->type.t & VT_BTYPE) != VT_FUNC &&
7664 !(vtop->type.t & VT_ARRAY) && !(vtop->type.t & VT_LLOCAL))
7665 test_lvalue();
7666 mk_pointer(&vtop->type);
7667 gaddrof();
7668 break;
7669 case '!':
7670 next();
7671 unary();
7672 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
7673 CType boolean;
7674 boolean.t = VT_BOOL;
7675 gen_cast(&boolean);
7676 vtop->c.i = !vtop->c.i;
7677 } else if ((vtop->r & VT_VALMASK) == VT_CMP)
7678 vtop->c.i = vtop->c.i ^ 1;
7679 else {
7680 save_regs(1);
7681 vseti(VT_JMP, gtst(1, 0));
7682 }
7683 break;
7684 case '~':
7685 next();
7686 unary();
7687 vpushi(-1);
7688 gen_op('^');
7689 break;
7690 case '+':
7691 next();
7692 /* in order to force cast, we add zero */
7693 unary();
7694 if ((vtop->type.t & VT_BTYPE) == VT_PTR)
7695 error("pointer not accepted for unary plus");
7696 vpushi(0);
7697 gen_op('+');
7698 break;
7699 case TOK_SIZEOF:
7700 case TOK_ALIGNOF1:
7701 case TOK_ALIGNOF2:
7702 t = tok;
7703 next();
7704 if (tok == '(') {
7705 parse_expr_type(&type);
7706 } else {
7707 unary_type(&type);
7708 }
7709 size = type_size(&type, &align);
7710 if (t == TOK_SIZEOF) {
7711 if (size < 0)
7712 error("sizeof applied to an incomplete type");
7713 vpushi(size);
7714 } else {
7715 vpushi(align);
7716 }
7717 vtop->type.t |= VT_UNSIGNED;
7718 break;
7719
7720 case TOK_builtin_types_compatible_p:
7721 {
7722 CType type1, type2;
7723 next();
7724 skip('(');
7725 parse_type(&type1);
7726 skip(',');
7727 parse_type(&type2);
7728 skip(')');
7729 type1.t &= ~(VT_CONSTANT | VT_VOLATILE);
7730 type2.t &= ~(VT_CONSTANT | VT_VOLATILE);
7731 vpushi(is_compatible_types(&type1, &type2));
7732 }
7733 break;
7734 case TOK_builtin_constant_p:
7735 {
7736 int saved_nocode_wanted, res;
7737 next();
7738 skip('(');
7739 saved_nocode_wanted = nocode_wanted;
7740 nocode_wanted = 1;
7741 gexpr();
7742 res = (vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
7743 vpop();
7744 nocode_wanted = saved_nocode_wanted;
7745 skip(')');
7746 vpushi(res);
7747 }
7748 break;
7749 case TOK_builtin_frame_address:
7750 {
7751 CType type;
7752 next();
7753 skip('(');
7754 if (tok != TOK_CINT) {
7755 error("__builtin_frame_address only takes integers");
7756 }
7757 if (tokc.i != 0) {
7758 error("TCC only supports __builtin_frame_address(0)");
7759 }
7760 next();
7761 skip(')');
7762 type.t = VT_VOID;
7763 mk_pointer(&type);
7764 vset(&type, VT_LOCAL, 0);
7765 }
7766 break;
7767 #ifdef TCC_TARGET_X86_64
7768 case TOK_builtin_malloc:
7769 {
7770 char *p = file->buf_ptr;
7771 file->buf_ptr = "malloc";
7772 next_nomacro1();
7773 file->buf_ptr = p;
7774 goto tok_identifier;
7775 }
7776 case TOK_builtin_free:
7777 {
7778 char *p = file->buf_ptr;
7779 file->buf_ptr = "free";
7780 next_nomacro1();
7781 file->buf_ptr = p;
7782 goto tok_identifier;
7783 }
7784 #endif
7785 case TOK_INC:
7786 case TOK_DEC:
7787 t = tok;
7788 next();
7789 unary();
7790 inc(0, t);
7791 break;
7792 case '-':
7793 next();
7794 vpushi(0);
7795 unary();
7796 gen_op('-');
7797 break;
7798 case TOK_LAND:
7799 if (!gnu_ext)
7800 goto tok_identifier;
7801 next();
7802 /* allow to take the address of a label */
7803 if (tok < TOK_UIDENT)
7804 expect("label identifier");
7805 s = label_find(tok);
7806 if (!s) {
7807 s = label_push(&global_label_stack, tok, LABEL_FORWARD);
7808 } else {
7809 if (s->r == LABEL_DECLARED)
7810 s->r = LABEL_FORWARD;
7811 }
7812 if (!s->type.t) {
7813 s->type.t = VT_VOID;
7814 mk_pointer(&s->type);
7815 s->type.t |= VT_STATIC;
7816 }
7817 vset(&s->type, VT_CONST | VT_SYM, 0);
7818 vtop->sym = s;
7819 next();
7820 break;
7821 default:
7822 tok_identifier:
7823 t = tok;
7824 next();
7825 if (t < TOK_UIDENT)
7826 expect("identifier");
7827 s = sym_find(t);
7828 if (!s) {
7829 if (tok != '(')
7830 error("'%s' undeclared", get_tok_str(t, NULL));
7831 /* for simple function calls, we tolerate undeclared
7832 external reference to int() function */
7833 if (tcc_state->warn_implicit_function_declaration)
7834 warning("implicit declaration of function '%s'",
7835 get_tok_str(t, NULL));
7836 s = external_global_sym(t, &func_old_type, 0);
7837 }
7838 if ((s->type.t & (VT_STATIC | VT_INLINE | VT_BTYPE)) ==
7839 (VT_STATIC | VT_INLINE | VT_FUNC)) {
7840 /* if referencing an inline function, then we generate a
7841 symbol to it if not already done. It will have the
7842 effect to generate code for it at the end of the
7843 compilation unit. Inline function as always
7844 generated in the text section. */
7845 if (!s->c)
7846 put_extern_sym(s, text_section, 0, 0);
7847 r = VT_SYM | VT_CONST;
7848 } else {
7849 r = s->r;
7850 }
7851 vset(&s->type, r, s->c);
7852 /* if forward reference, we must point to s */
7853 if (vtop->r & VT_SYM) {
7854 vtop->sym = s;
7855 vtop->c.ul = 0;
7856 }
7857 break;
7858 }
7859
7860 /* post operations */
7861 while (1) {
7862 if (tok == TOK_INC || tok == TOK_DEC) {
7863 inc(1, tok);
7864 next();
7865 } else if (tok == '.' || tok == TOK_ARROW) {
7866 /* field */
7867 if (tok == TOK_ARROW)
7868 indir();
7869 test_lvalue();
7870 gaddrof();
7871 next();
7872 /* expect pointer on structure */
7873 if ((vtop->type.t & VT_BTYPE) != VT_STRUCT)
7874 expect("struct or union");
7875 s = vtop->type.ref;
7876 /* find field */
7877 tok |= SYM_FIELD;
7878 while ((s = s->next) != NULL) {
7879 if (s->v == tok)
7880 break;
7881 }
7882 if (!s)
7883 error("field not found: %s", get_tok_str(tok & ~SYM_FIELD, NULL));
7884 /* add field offset to pointer */
7885 vtop->type = char_pointer_type; /* change type to 'char *' */
7886 vpushi(s->c);
7887 gen_op('+');
7888 /* change type to field type, and set to lvalue */
7889 vtop->type = s->type;
7890 /* an array is never an lvalue */
7891 if (!(vtop->type.t & VT_ARRAY)) {
7892 vtop->r |= lvalue_type(vtop->type.t);
7893 /* if bound checking, the referenced pointer must be checked */
7894 if (do_bounds_check)
7895 vtop->r |= VT_MUSTBOUND;
7896 }
7897 next();
7898 } else if (tok == '[') {
7899 next();
7900 gexpr();
7901 gen_op('+');
7902 indir();
7903 skip(']');
7904 } else if (tok == '(') {
7905 SValue ret;
7906 Sym *sa;
7907 int nb_args;
7908
7909 /* function call */
7910 if ((vtop->type.t & VT_BTYPE) != VT_FUNC) {
7911 /* pointer test (no array accepted) */
7912 if ((vtop->type.t & (VT_BTYPE | VT_ARRAY)) == VT_PTR) {
7913 vtop->type = *pointed_type(&vtop->type);
7914 if ((vtop->type.t & VT_BTYPE) != VT_FUNC)
7915 goto error_func;
7916 } else {
7917 error_func:
7918 expect("function pointer");
7919 }
7920 } else {
7921 vtop->r &= ~VT_LVAL; /* no lvalue */
7922 }
7923 /* get return type */
7924 s = vtop->type.ref;
7925 next();
7926 sa = s->next; /* first parameter */
7927 nb_args = 0;
7928 ret.r2 = VT_CONST;
7929 /* compute first implicit argument if a structure is returned */
7930 if ((s->type.t & VT_BTYPE) == VT_STRUCT) {
7931 /* get some space for the returned structure */
7932 size = type_size(&s->type, &align);
7933 loc = (loc - size) & -align;
7934 ret.type = s->type;
7935 ret.r = VT_LOCAL | VT_LVAL;
7936 /* pass it as 'int' to avoid structure arg passing
7937 problems */
7938 vseti(VT_LOCAL, loc);
7939 ret.c = vtop->c;
7940 nb_args++;
7941 } else {
7942 ret.type = s->type;
7943 /* return in register */
7944 if (is_float(ret.type.t)) {
7945 ret.r = REG_FRET;
7946 } else {
7947 if ((ret.type.t & VT_BTYPE) == VT_LLONG)
7948 ret.r2 = REG_LRET;
7949 ret.r = REG_IRET;
7950 }
7951 ret.c.i = 0;
7952 }
7953 if (tok != ')') {
7954 for(;;) {
7955 expr_eq();
7956 gfunc_param_typed(s, sa);
7957 nb_args++;
7958 if (sa)
7959 sa = sa->next;
7960 if (tok == ')')
7961 break;
7962 skip(',');
7963 }
7964 }
7965 if (sa)
7966 error("too few arguments to function");
7967 skip(')');
7968 if (!nocode_wanted) {
7969 gfunc_call(nb_args);
7970 } else {
7971 vtop -= (nb_args + 1);
7972 }
7973 /* return value */
7974 vsetc(&ret.type, ret.r, &ret.c);
7975 vtop->r2 = ret.r2;
7976 } else {
7977 break;
7978 }
7979 }
7980 }
7981
7982 static void uneq(void)
7983 {
7984 int t;
7985
7986 unary();
7987 if (tok == '=' ||
7988 (tok >= TOK_A_MOD && tok <= TOK_A_DIV) ||
7989 tok == TOK_A_XOR || tok == TOK_A_OR ||
7990 tok == TOK_A_SHL || tok == TOK_A_SAR) {
7991 test_lvalue();
7992 t = tok;
7993 next();
7994 if (t == '=') {
7995 expr_eq();
7996 } else {
7997 vdup();
7998 expr_eq();
7999 gen_op(t & 0x7f);
8000 }
8001 vstore();
8002 }
8003 }
8004
8005 static void expr_prod(void)
8006 {
8007 int t;
8008
8009 uneq();
8010 while (tok == '*' || tok == '/' || tok == '%') {
8011 t = tok;
8012 next();
8013 uneq();
8014 gen_op(t);
8015 }
8016 }
8017
8018 static void expr_sum(void)
8019 {
8020 int t;
8021
8022 expr_prod();
8023 while (tok == '+' || tok == '-') {
8024 t = tok;
8025 next();
8026 expr_prod();
8027 gen_op(t);
8028 }
8029 }
8030
8031 static void expr_shift(void)
8032 {
8033 int t;
8034
8035 expr_sum();
8036 while (tok == TOK_SHL || tok == TOK_SAR) {
8037 t = tok;
8038 next();
8039 expr_sum();
8040 gen_op(t);
8041 }
8042 }
8043
8044 static void expr_cmp(void)
8045 {
8046 int t;
8047
8048 expr_shift();
8049 while ((tok >= TOK_ULE && tok <= TOK_GT) ||
8050 tok == TOK_ULT || tok == TOK_UGE) {
8051 t = tok;
8052 next();
8053 expr_shift();
8054 gen_op(t);
8055 }
8056 }
8057
8058 static void expr_cmpeq(void)
8059 {
8060 int t;
8061
8062 expr_cmp();
8063 while (tok == TOK_EQ || tok == TOK_NE) {
8064 t = tok;
8065 next();
8066 expr_cmp();
8067 gen_op(t);
8068 }
8069 }
8070
8071 static void expr_and(void)
8072 {
8073 expr_cmpeq();
8074 while (tok == '&') {
8075 next();
8076 expr_cmpeq();
8077 gen_op('&');
8078 }
8079 }
8080
8081 static void expr_xor(void)
8082 {
8083 expr_and();
8084 while (tok == '^') {
8085 next();
8086 expr_and();
8087 gen_op('^');
8088 }
8089 }
8090
8091 static void expr_or(void)
8092 {
8093 expr_xor();
8094 while (tok == '|') {
8095 next();
8096 expr_xor();
8097 gen_op('|');
8098 }
8099 }
8100
8101 /* XXX: fix this mess */
8102 static void expr_land_const(void)
8103 {
8104 expr_or();
8105 while (tok == TOK_LAND) {
8106 next();
8107 expr_or();
8108 gen_op(TOK_LAND);
8109 }
8110 }
8111
8112 /* XXX: fix this mess */
8113 static void expr_lor_const(void)
8114 {
8115 expr_land_const();
8116 while (tok == TOK_LOR) {
8117 next();
8118 expr_land_const();
8119 gen_op(TOK_LOR);
8120 }
8121 }
8122
8123 /* only used if non constant */
8124 static void expr_land(void)
8125 {
8126 int t;
8127
8128 expr_or();
8129 if (tok == TOK_LAND) {
8130 t = 0;
8131 save_regs(1);
8132 for(;;) {
8133 t = gtst(1, t);
8134 if (tok != TOK_LAND) {
8135 vseti(VT_JMPI, t);
8136 break;
8137 }
8138 next();
8139 expr_or();
8140 }
8141 }
8142 }
8143
8144 static void expr_lor(void)
8145 {
8146 int t;
8147
8148 expr_land();
8149 if (tok == TOK_LOR) {
8150 t = 0;
8151 save_regs(1);
8152 for(;;) {
8153 t = gtst(0, t);
8154 if (tok != TOK_LOR) {
8155 vseti(VT_JMP, t);
8156 break;
8157 }
8158 next();
8159 expr_land();
8160 }
8161 }
8162 }
8163
8164 /* XXX: better constant handling */
8165 static void expr_eq(void)
8166 {
8167 int tt, u, r1, r2, rc, t1, t2, bt1, bt2;
8168 SValue sv;
8169 CType type, type1, type2;
8170
8171 if (const_wanted) {
8172 expr_lor_const();
8173 if (tok == '?') {
8174 CType boolean;
8175 int c;
8176 boolean.t = VT_BOOL;
8177 vdup();
8178 gen_cast(&boolean);
8179 c = vtop->c.i;
8180 vpop();
8181 next();
8182 if (tok != ':' || !gnu_ext) {
8183 vpop();
8184 gexpr();
8185 }
8186 if (!c)
8187 vpop();
8188 skip(':');
8189 expr_eq();
8190 if (c)
8191 vpop();
8192 }
8193 } else {
8194 expr_lor();
8195 if (tok == '?') {
8196 next();
8197 if (vtop != vstack) {
8198 /* needed to avoid having different registers saved in
8199 each branch */
8200 if (is_float(vtop->type.t)) {
8201 rc = RC_FLOAT;
8202 #ifdef TCC_TARGET_X86_64
8203 if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE) {
8204 rc = RC_ST0;
8205 }
8206 #endif
8207 }
8208 else
8209 rc = RC_INT;
8210 gv(rc);
8211 save_regs(1);
8212 }
8213 if (tok == ':' && gnu_ext) {
8214 gv_dup();
8215 tt = gtst(1, 0);
8216 } else {
8217 tt = gtst(1, 0);
8218 gexpr();
8219 }
8220 type1 = vtop->type;
8221 sv = *vtop; /* save value to handle it later */
8222 vtop--; /* no vpop so that FP stack is not flushed */
8223 skip(':');
8224 u = gjmp(0);
8225 gsym(tt);
8226 expr_eq();
8227 type2 = vtop->type;
8228
8229 t1 = type1.t;
8230 bt1 = t1 & VT_BTYPE;
8231 t2 = type2.t;
8232 bt2 = t2 & VT_BTYPE;
8233 /* cast operands to correct type according to ISOC rules */
8234 if (is_float(bt1) || is_float(bt2)) {
8235 if (bt1 == VT_LDOUBLE || bt2 == VT_LDOUBLE) {
8236 type.t = VT_LDOUBLE;
8237 } else if (bt1 == VT_DOUBLE || bt2 == VT_DOUBLE) {
8238 type.t = VT_DOUBLE;
8239 } else {
8240 type.t = VT_FLOAT;
8241 }
8242 } else if (bt1 == VT_LLONG || bt2 == VT_LLONG) {
8243 /* cast to biggest op */
8244 type.t = VT_LLONG;
8245 /* convert to unsigned if it does not fit in a long long */
8246 if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED) ||
8247 (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_LLONG | VT_UNSIGNED))
8248 type.t |= VT_UNSIGNED;
8249 } else if (bt1 == VT_PTR || bt2 == VT_PTR) {
8250 /* XXX: test pointer compatibility */
8251 type = type1;
8252 } else if (bt1 == VT_FUNC || bt2 == VT_FUNC) {
8253 /* XXX: test function pointer compatibility */
8254 type = type1;
8255 } else if (bt1 == VT_STRUCT || bt2 == VT_STRUCT) {
8256 /* XXX: test structure compatibility */
8257 type = type1;
8258 } else if (bt1 == VT_VOID || bt2 == VT_VOID) {
8259 /* NOTE: as an extension, we accept void on only one side */
8260 type.t = VT_VOID;
8261 } else {
8262 /* integer operations */
8263 type.t = VT_INT;
8264 /* convert to unsigned if it does not fit in an integer */
8265 if ((t1 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED) ||
8266 (t2 & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED))
8267 type.t |= VT_UNSIGNED;
8268 }
8269
8270 /* now we convert second operand */
8271 gen_cast(&type);
8272 if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
8273 gaddrof();
8274 rc = RC_INT;
8275 if (is_float(type.t)) {
8276 rc = RC_FLOAT;
8277 #ifdef TCC_TARGET_X86_64
8278 if ((type.t & VT_BTYPE) == VT_LDOUBLE) {
8279 rc = RC_ST0;
8280 }
8281 #endif
8282 } else if ((type.t & VT_BTYPE) == VT_LLONG) {
8283 /* for long longs, we use fixed registers to avoid having
8284 to handle a complicated move */
8285 rc = RC_IRET;
8286 }
8287
8288 r2 = gv(rc);
8289 /* this is horrible, but we must also convert first
8290 operand */
8291 tt = gjmp(0);
8292 gsym(u);
8293 /* put again first value and cast it */
8294 *vtop = sv;
8295 gen_cast(&type);
8296 if (VT_STRUCT == (vtop->type.t & VT_BTYPE))
8297 gaddrof();
8298 r1 = gv(rc);
8299 move_reg(r2, r1);
8300 vtop->r = r2;
8301 gsym(tt);
8302 }
8303 }
8304 }
8305
8306 static void gexpr(void)
8307 {
8308 while (1) {
8309 expr_eq();
8310 if (tok != ',')
8311 break;
8312 vpop();
8313 next();
8314 }
8315 }
8316
8317 /* parse an expression and return its type without any side effect. */
8318 static void expr_type(CType *type)
8319 {
8320 int saved_nocode_wanted;
8321
8322 saved_nocode_wanted = nocode_wanted;
8323 nocode_wanted = 1;
8324 gexpr();
8325 *type = vtop->type;
8326 vpop();
8327 nocode_wanted = saved_nocode_wanted;
8328 }
8329
8330 /* parse a unary expression and return its type without any side
8331 effect. */
8332 static void unary_type(CType *type)
8333 {
8334 int a;
8335
8336 a = nocode_wanted;
8337 nocode_wanted = 1;
8338 unary();
8339 *type = vtop->type;
8340 vpop();
8341 nocode_wanted = a;
8342 }
8343
8344 /* parse a constant expression and return value in vtop. */
8345 static void expr_const1(void)
8346 {
8347 int a;
8348 a = const_wanted;
8349 const_wanted = 1;
8350 expr_eq();
8351 const_wanted = a;
8352 }
8353
8354 /* parse an integer constant and return its value. */
8355 static int expr_const(void)
8356 {
8357 int c;
8358 expr_const1();
8359 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
8360 expect("constant expression");
8361 c = vtop->c.i;
8362 vpop();
8363 return c;
8364 }
8365
8366 /* return the label token if current token is a label, otherwise
8367 return zero */
8368 static int is_label(void)
8369 {
8370 int last_tok;
8371
8372 /* fast test first */
8373 if (tok < TOK_UIDENT)
8374 return 0;
8375 /* no need to save tokc because tok is an identifier */
8376 last_tok = tok;
8377 next();
8378 if (tok == ':') {
8379 next();
8380 return last_tok;
8381 } else {
8382 unget_tok(last_tok);
8383 return 0;
8384 }
8385 }
8386
8387 static void block(int *bsym, int *csym, int *case_sym, int *def_sym,
8388 int case_reg, int is_expr)
8389 {
8390 int a, b, c, d;
8391 Sym *s;
8392
8393 /* generate line number info */
8394 if (do_debug &&
8395 (last_line_num != file->line_num || last_ind != ind)) {
8396 put_stabn(N_SLINE, 0, file->line_num, ind - func_ind);
8397 last_ind = ind;
8398 last_line_num = file->line_num;
8399 }
8400
8401 if (is_expr) {
8402 /* default return value is (void) */
8403 vpushi(0);
8404 vtop->type.t = VT_VOID;
8405 }
8406
8407 if (tok == TOK_IF) {
8408 /* if test */
8409 next();
8410 skip('(');
8411 gexpr();
8412 skip(')');
8413 a = gtst(1, 0);
8414 block(bsym, csym, case_sym, def_sym, case_reg, 0);
8415 c = tok;
8416 if (c == TOK_ELSE) {
8417 next();
8418 d = gjmp(0);
8419 gsym(a);
8420 block(bsym, csym, case_sym, def_sym, case_reg, 0);
8421 gsym(d); /* patch else jmp */
8422 } else
8423 gsym(a);
8424 } else if (tok == TOK_WHILE) {
8425 next();
8426 d = ind;
8427 skip('(');
8428 gexpr();
8429 skip(')');
8430 a = gtst(1, 0);
8431 b = 0;
8432 block(&a, &b, case_sym, def_sym, case_reg, 0);
8433 gjmp_addr(d);
8434 gsym(a);
8435 gsym_addr(b, d);
8436 } else if (tok == '{') {
8437 Sym *llabel;
8438
8439 next();
8440 /* record local declaration stack position */
8441 s = local_stack;
8442 llabel = local_label_stack;
8443 /* handle local labels declarations */
8444 if (tok == TOK_LABEL) {
8445 next();
8446 for(;;) {
8447 if (tok < TOK_UIDENT)
8448 expect("label identifier");
8449 label_push(&local_label_stack, tok, LABEL_DECLARED);
8450 next();
8451 if (tok == ',') {
8452 next();
8453 } else {
8454 skip(';');
8455 break;
8456 }
8457 }
8458 }
8459 while (tok != '}') {
8460 decl(VT_LOCAL);
8461 if (tok != '}') {
8462 if (is_expr)
8463 vpop();
8464 block(bsym, csym, case_sym, def_sym, case_reg, is_expr);
8465 }
8466 }
8467 /* pop locally defined labels */
8468 label_pop(&local_label_stack, llabel);
8469 /* pop locally defined symbols */
8470 if(is_expr) {
8471 /* XXX: this solution makes only valgrind happy...
8472 triggered by gcc.c-torture/execute/20000917-1.c */
8473 Sym *p;
8474 switch(vtop->type.t & VT_BTYPE) {
8475 case VT_PTR:
8476 case VT_STRUCT:
8477 case VT_ENUM:
8478 case VT_FUNC:
8479 for(p=vtop->type.ref;p;p=p->prev)
8480 if(p->prev==s)
8481 error("unsupported expression type");
8482 }
8483 }
8484 sym_pop(&local_stack, s);
8485 next();
8486 } else if (tok == TOK_RETURN) {
8487 next();
8488 if (tok != ';') {
8489 gexpr();
8490 gen_assign_cast(&func_vt);
8491 if ((func_vt.t & VT_BTYPE) == VT_STRUCT) {
8492 CType type;
8493 /* if returning structure, must copy it to implicit
8494 first pointer arg location */
8495 #ifdef TCC_ARM_EABI
8496 int align, size;
8497 size = type_size(&func_vt,&align);
8498 if(size <= 4)
8499 {
8500 if((vtop->r != (VT_LOCAL | VT_LVAL) || (vtop->c.i & 3))
8501 && (align & 3))
8502 {
8503 int addr;
8504 loc = (loc - size) & -4;
8505 addr = loc;
8506 type = func_vt;
8507 vset(&type, VT_LOCAL | VT_LVAL, addr);
8508 vswap();
8509 vstore();
8510 vset(&int_type, VT_LOCAL | VT_LVAL, addr);
8511 }
8512 vtop->type = int_type;
8513 gv(RC_IRET);
8514 } else {
8515 #endif
8516 type = func_vt;
8517 mk_pointer(&type);
8518 vset(&type, VT_LOCAL | VT_LVAL, func_vc);
8519 indir();
8520 vswap();
8521 /* copy structure value to pointer */
8522 vstore();
8523 #ifdef TCC_ARM_EABI
8524 }
8525 #endif
8526 } else if (is_float(func_vt.t)) {
8527 gv(RC_FRET);
8528 } else {
8529 gv(RC_IRET);
8530 }
8531 vtop--; /* NOT vpop() because on x86 it would flush the fp stack */
8532 }
8533 skip(';');
8534 rsym = gjmp(rsym); /* jmp */
8535 } else if (tok == TOK_BREAK) {
8536 /* compute jump */
8537 if (!bsym)
8538 error("cannot break");
8539 *bsym = gjmp(*bsym);
8540 next();
8541 skip(';');
8542 } else if (tok == TOK_CONTINUE) {
8543 /* compute jump */
8544 if (!csym)
8545 error("cannot continue");
8546 *csym = gjmp(*csym);
8547 next();
8548 skip(';');
8549 } else if (tok == TOK_FOR) {
8550 int e;
8551 next();
8552 skip('(');
8553 if (tok != ';') {
8554 gexpr();
8555 vpop();
8556 }
8557 skip(';');
8558 d = ind;
8559 c = ind;
8560 a = 0;
8561 b = 0;
8562 if (tok != ';') {
8563 gexpr();
8564 a = gtst(1, 0);
8565 }
8566 skip(';');
8567 if (tok != ')') {
8568 e = gjmp(0);
8569 c = ind;
8570 gexpr();
8571 vpop();
8572 gjmp_addr(d);
8573 gsym(e);
8574 }
8575 skip(')');
8576 block(&a, &b, case_sym, def_sym, case_reg, 0);
8577 gjmp_addr(c);
8578 gsym(a);
8579 gsym_addr(b, c);
8580 } else
8581 if (tok == TOK_DO) {
8582 next();
8583 a = 0;
8584 b = 0;
8585 d = ind;
8586 block(&a, &b, case_sym, def_sym, case_reg, 0);
8587 skip(TOK_WHILE);
8588 skip('(');
8589 gsym(b);
8590 gexpr();
8591 c = gtst(0, 0);
8592 gsym_addr(c, d);
8593 skip(')');
8594 gsym(a);
8595 skip(';');
8596 } else
8597 if (tok == TOK_SWITCH) {
8598 next();
8599 skip('(');
8600 gexpr();
8601 /* XXX: other types than integer */
8602 case_reg = gv(RC_INT);
8603 vpop();
8604 skip(')');
8605 a = 0;
8606 b = gjmp(0); /* jump to first case */
8607 c = 0;
8608 block(&a, csym, &b, &c, case_reg, 0);
8609 /* if no default, jmp after switch */
8610 if (c == 0)
8611 c = ind;
8612 /* default label */
8613 gsym_addr(b, c);
8614 /* break label */
8615 gsym(a);
8616 } else
8617 if (tok == TOK_CASE) {
8618 int v1, v2;
8619 if (!case_sym)
8620 expect("switch");
8621 next();
8622 v1 = expr_const();
8623 v2 = v1;
8624 if (gnu_ext && tok == TOK_DOTS) {
8625 next();
8626 v2 = expr_const();
8627 if (v2 < v1)
8628 warning("empty case range");
8629 }
8630 /* since a case is like a label, we must skip it with a jmp */
8631 b = gjmp(0);
8632 gsym(*case_sym);
8633 vseti(case_reg, 0);
8634 vpushi(v1);
8635 if (v1 == v2) {
8636 gen_op(TOK_EQ);
8637 *case_sym = gtst(1, 0);
8638 } else {
8639 gen_op(TOK_GE);
8640 *case_sym = gtst(1, 0);
8641 vseti(case_reg, 0);
8642 vpushi(v2);
8643 gen_op(TOK_LE);
8644 *case_sym = gtst(1, *case_sym);
8645 }
8646 gsym(b);
8647 skip(':');
8648 is_expr = 0;
8649 goto block_after_label;
8650 } else
8651 if (tok == TOK_DEFAULT) {
8652 next();
8653 skip(':');
8654 if (!def_sym)
8655 expect("switch");
8656 if (*def_sym)
8657 error("too many 'default'");
8658 *def_sym = ind;
8659 is_expr = 0;
8660 goto block_after_label;
8661 } else
8662 if (tok == TOK_GOTO) {
8663 next();
8664 if (tok == '*' && gnu_ext) {
8665 /* computed goto */
8666 next();
8667 gexpr();
8668 if ((vtop->type.t & VT_BTYPE) != VT_PTR)
8669 expect("pointer");
8670 ggoto();
8671 } else if (tok >= TOK_UIDENT) {
8672 s = label_find(tok);
8673 /* put forward definition if needed */
8674 if (!s) {
8675 s = label_push(&global_label_stack, tok, LABEL_FORWARD);
8676 } else {
8677 if (s->r == LABEL_DECLARED)
8678 s->r = LABEL_FORWARD;
8679 }
8680 /* label already defined */
8681 if (s->r & LABEL_FORWARD)
8682 s->next = (void *)gjmp((long)s->next);
8683 else
8684 gjmp_addr((long)s->next);
8685 next();
8686 } else {
8687 expect("label identifier");
8688 }
8689 skip(';');
8690 } else if (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3) {
8691 asm_instr();
8692 } else {
8693 b = is_label();
8694 if (b) {
8695 /* label case */
8696 s = label_find(b);
8697 if (s) {
8698 if (s->r == LABEL_DEFINED)
8699 error("duplicate label '%s'", get_tok_str(s->v, NULL));
8700 gsym((long)s->next);
8701 s->r = LABEL_DEFINED;
8702 } else {
8703 s = label_push(&global_label_stack, b, LABEL_DEFINED);
8704 }
8705 s->next = (void *)ind;
8706 /* we accept this, but it is a mistake */
8707 block_after_label:
8708 if (tok == '}') {
8709 warning("deprecated use of label at end of compound statement");
8710 } else {
8711 if (is_expr)
8712 vpop();
8713 block(bsym, csym, case_sym, def_sym, case_reg, is_expr);
8714 }
8715 } else {
8716 /* expression case */
8717 if (tok != ';') {
8718 if (is_expr) {
8719 vpop();
8720 gexpr();
8721 } else {
8722 gexpr();
8723 vpop();
8724 }
8725 }
8726 skip(';');
8727 }
8728 }
8729 }
8730
8731 /* t is the array or struct type. c is the array or struct
8732 address. cur_index/cur_field is the pointer to the current
8733 value. 'size_only' is true if only size info is needed (only used
8734 in arrays) */
8735 static void decl_designator(CType *type, Section *sec, unsigned long c,
8736 int *cur_index, Sym **cur_field,
8737 int size_only)
8738 {
8739 Sym *s, *f;
8740 int notfirst, index, index_last, align, l, nb_elems, elem_size;
8741 CType type1;
8742
8743 notfirst = 0;
8744 elem_size = 0;
8745 nb_elems = 1;
8746 if (gnu_ext && (l = is_label()) != 0)
8747 goto struct_field;
8748 while (tok == '[' || tok == '.') {
8749 if (tok == '[') {
8750 if (!(type->t & VT_ARRAY))
8751 expect("array type");
8752 s = type->ref;
8753 next();
8754 index = expr_const();
8755 if (index < 0 || (s->c >= 0 && index >= s->c))
8756 expect("invalid index");
8757 if (tok == TOK_DOTS && gnu_ext) {
8758 next();
8759 index_last = expr_const();
8760 if (index_last < 0 ||
8761 (s->c >= 0 && index_last >= s->c) ||
8762 index_last < index)
8763 expect("invalid index");
8764 } else {
8765 index_last = index;
8766 }
8767 skip(']');
8768 if (!notfirst)
8769 *cur_index = index_last;
8770 type = pointed_type(type);
8771 elem_size = type_size(type, &align);
8772 c += index * elem_size;
8773 /* NOTE: we only support ranges for last designator */
8774 nb_elems = index_last - index + 1;
8775 if (nb_elems != 1) {
8776 notfirst = 1;
8777 break;
8778 }
8779 } else {
8780 next();
8781 l = tok;
8782 next();
8783 struct_field:
8784 if ((type->t & VT_BTYPE) != VT_STRUCT)
8785 expect("struct/union type");
8786 s = type->ref;
8787 l |= SYM_FIELD;
8788 f = s->next;
8789 while (f) {
8790 if (f->v == l)
8791 break;
8792 f = f->next;
8793 }
8794 if (!f)
8795 expect("field");
8796 if (!notfirst)
8797 *cur_field = f;
8798 /* XXX: fix this mess by using explicit storage field */
8799 type1 = f->type;
8800 type1.t |= (type->t & ~VT_TYPE);
8801 type = &type1;
8802 c += f->c;
8803 }
8804 notfirst = 1;
8805 }
8806 if (notfirst) {
8807 if (tok == '=') {
8808 next();
8809 } else {
8810 if (!gnu_ext)
8811 expect("=");
8812 }
8813 } else {
8814 if (type->t & VT_ARRAY) {
8815 index = *cur_index;
8816 type = pointed_type(type);
8817 c += index * type_size(type, &align);
8818 } else {
8819 f = *cur_field;
8820 if (!f)
8821 error("too many field init");
8822 /* XXX: fix this mess by using explicit storage field */
8823 type1 = f->type;
8824 type1.t |= (type->t & ~VT_TYPE);
8825 type = &type1;
8826 c += f->c;
8827 }
8828 }
8829 decl_initializer(type, sec, c, 0, size_only);
8830
8831 /* XXX: make it more general */
8832 if (!size_only && nb_elems > 1) {
8833 unsigned long c_end;
8834 uint8_t *src, *dst;
8835 int i;
8836
8837 if (!sec)
8838 error("range init not supported yet for dynamic storage");
8839 c_end = c + nb_elems * elem_size;
8840 if (c_end > sec->data_allocated)
8841 section_realloc(sec, c_end);
8842 src = sec->data + c;
8843 dst = src;
8844 for(i = 1; i < nb_elems; i++) {
8845 dst += elem_size;
8846 memcpy(dst, src, elem_size);
8847 }
8848 }
8849 }
8850
8851 #define EXPR_VAL 0
8852 #define EXPR_CONST 1
8853 #define EXPR_ANY 2
8854
8855 /* store a value or an expression directly in global data or in local array */
8856 static void init_putv(CType *type, Section *sec, unsigned long c,
8857 int v, int expr_type)
8858 {
8859 int saved_global_expr, bt, bit_pos, bit_size;
8860 void *ptr;
8861 unsigned long long bit_mask;
8862 CType dtype;
8863
8864 switch(expr_type) {
8865 case EXPR_VAL:
8866 vpushi(v);
8867 break;
8868 case EXPR_CONST:
8869 /* compound literals must be allocated globally in this case */
8870 saved_global_expr = global_expr;
8871 global_expr = 1;
8872 expr_const1();
8873 global_expr = saved_global_expr;
8874 /* NOTE: symbols are accepted */
8875 if ((vtop->r & (VT_VALMASK | VT_LVAL)) != VT_CONST)
8876 error("initializer element is not constant");
8877 break;
8878 case EXPR_ANY:
8879 expr_eq();
8880 break;
8881 }
8882
8883 dtype = *type;
8884 dtype.t &= ~VT_CONSTANT; /* need to do that to avoid false warning */
8885
8886 if (sec) {
8887 /* XXX: not portable */
8888 /* XXX: generate error if incorrect relocation */
8889 gen_assign_cast(&dtype);
8890 bt = type->t & VT_BTYPE;
8891 /* we'll write at most 12 bytes */
8892 if (c + 12 > sec->data_allocated) {
8893 section_realloc(sec, c + 12);
8894 }
8895 ptr = sec->data + c;
8896 /* XXX: make code faster ? */
8897 if (!(type->t & VT_BITFIELD)) {
8898 bit_pos = 0;
8899 bit_size = 32;
8900 bit_mask = -1LL;
8901 } else {
8902 bit_pos = (vtop->type.t >> VT_STRUCT_SHIFT) & 0x3f;
8903 bit_size = (vtop->type.t >> (VT_STRUCT_SHIFT + 6)) & 0x3f;
8904 bit_mask = (1LL << bit_size) - 1;
8905 }
8906 if ((vtop->r & VT_SYM) &&
8907 (bt == VT_BYTE ||
8908 bt == VT_SHORT ||
8909 bt == VT_DOUBLE ||
8910 bt == VT_LDOUBLE ||
8911 bt == VT_LLONG ||
8912 (bt == VT_INT && bit_size != 32)))
8913 error("initializer element is not computable at load time");
8914 switch(bt) {
8915 case VT_BOOL:
8916 vtop->c.i = (vtop->c.i != 0);
8917 case VT_BYTE:
8918 *(char *)ptr |= (vtop->c.i & bit_mask) << bit_pos;
8919 break;
8920 case VT_SHORT:
8921 *(short *)ptr |= (vtop->c.i & bit_mask) << bit_pos;
8922 break;
8923 case VT_DOUBLE:
8924 *(double *)ptr = vtop->c.d;
8925 break;
8926 case VT_LDOUBLE:
8927 *(long double *)ptr = vtop->c.ld;
8928 break;
8929 case VT_LLONG:
8930 *(long long *)ptr |= (vtop->c.ll & bit_mask) << bit_pos;
8931 break;
8932 default:
8933 if (vtop->r & VT_SYM) {
8934 greloc(sec, vtop->sym, c, R_DATA_32);
8935 }
8936 *(int *)ptr |= (vtop->c.i & bit_mask) << bit_pos;
8937 break;
8938 }
8939 vtop--;
8940 } else {
8941 vset(&dtype, VT_LOCAL|VT_LVAL, c);
8942 vswap();
8943 vstore();
8944 vpop();
8945 }
8946 }
8947
8948 /* put zeros for variable based init */
8949 static void init_putz(CType *t, Section *sec, unsigned long c, int size)
8950 {
8951 if (sec) {
8952 /* nothing to do because globals are already set to zero */
8953 } else {
8954 vpush_global_sym(&func_old_type, TOK_memset);
8955 vseti(VT_LOCAL, c);
8956 vpushi(0);
8957 vpushi(size);
8958 gfunc_call(3);
8959 }
8960 }
8961
8962 /* 't' contains the type and storage info. 'c' is the offset of the
8963 object in section 'sec'. If 'sec' is NULL, it means stack based
8964 allocation. 'first' is true if array '{' must be read (multi
8965 dimension implicit array init handling). 'size_only' is true if
8966 size only evaluation is wanted (only for arrays). */
8967 static void decl_initializer(CType *type, Section *sec, unsigned long c,
8968 int first, int size_only)
8969 {
8970 int index, array_length, n, no_oblock, nb, parlevel, i;
8971 int size1, align1, expr_type;
8972 Sym *s, *f;
8973 CType *t1;
8974
8975 if (type->t & VT_ARRAY) {
8976 s = type->ref;
8977 n = s->c;
8978 array_length = 0;
8979 t1 = pointed_type(type);
8980 size1 = type_size(t1, &align1);
8981
8982 no_oblock = 1;
8983 if ((first && tok != TOK_LSTR && tok != TOK_STR) ||
8984 tok == '{') {
8985 skip('{');
8986 no_oblock = 0;
8987 }
8988
8989 /* only parse strings here if correct type (otherwise: handle
8990 them as ((w)char *) expressions */
8991 if ((tok == TOK_LSTR &&
8992 #ifdef TCC_TARGET_PE
8993 (t1->t & VT_BTYPE) == VT_SHORT && (t1->t & VT_UNSIGNED)
8994 #else
8995 (t1->t & VT_BTYPE) == VT_INT
8996 #endif
8997 ) || (tok == TOK_STR && (t1->t & VT_BTYPE) == VT_BYTE)) {
8998 while (tok == TOK_STR || tok == TOK_LSTR) {
8999 int cstr_len, ch;
9000 CString *cstr;
9001
9002 cstr = tokc.cstr;
9003 /* compute maximum number of chars wanted */
9004 if (tok == TOK_STR)
9005 cstr_len = cstr->size;
9006 else
9007 cstr_len = cstr->size / sizeof(nwchar_t);
9008 cstr_len--;
9009 nb = cstr_len;
9010 if (n >= 0 && nb > (n - array_length))
9011 nb = n - array_length;
9012 if (!size_only) {
9013 if (cstr_len > nb)
9014 warning("initializer-string for array is too long");
9015 /* in order to go faster for common case (char
9016 string in global variable, we handle it
9017 specifically */
9018 if (sec && tok == TOK_STR && size1 == 1) {
9019 memcpy(sec->data + c + array_length, cstr->data, nb);
9020 } else {
9021 for(i=0;i<nb;i++) {
9022 if (tok == TOK_STR)
9023 ch = ((unsigned char *)cstr->data)[i];
9024 else
9025 ch = ((nwchar_t *)cstr->data)[i];
9026 init_putv(t1, sec, c + (array_length + i) * size1,
9027 ch, EXPR_VAL);
9028 }
9029 }
9030 }
9031 array_length += nb;
9032 next();
9033 }
9034 /* only add trailing zero if enough storage (no
9035 warning in this case since it is standard) */
9036 if (n < 0 || array_length < n) {
9037 if (!size_only) {
9038 init_putv(t1, sec, c + (array_length * size1), 0, EXPR_VAL);
9039 }
9040 array_length++;
9041 }
9042 } else {
9043 index = 0;
9044 while (tok != '}') {
9045 decl_designator(type, sec, c, &index, NULL, size_only);
9046 if (n >= 0 && index >= n)
9047 error("index too large");
9048 /* must put zero in holes (note that doing it that way
9049 ensures that it even works with designators) */
9050 if (!size_only && array_length < index) {
9051 init_putz(t1, sec, c + array_length * size1,
9052 (index - array_length) * size1);
9053 }
9054 index++;
9055 if (index > array_length)
9056 array_length = index;
9057 /* special test for multi dimensional arrays (may not
9058 be strictly correct if designators are used at the
9059 same time) */
9060 if (index >= n && no_oblock)
9061 break;
9062 if (tok == '}')
9063 break;
9064 skip(',');
9065 }
9066 }
9067 if (!no_oblock)
9068 skip('}');
9069 /* put zeros at the end */
9070 if (!size_only && n >= 0 && array_length < n) {
9071 init_putz(t1, sec, c + array_length * size1,
9072 (n - array_length) * size1);
9073 }
9074 /* patch type size if needed */
9075 if (n < 0)
9076 s->c = array_length;
9077 } else if ((type->t & VT_BTYPE) == VT_STRUCT &&
9078 (sec || !first || tok == '{')) {
9079 int par_count;
9080
9081 /* NOTE: the previous test is a specific case for automatic
9082 struct/union init */
9083 /* XXX: union needs only one init */
9084
9085 /* XXX: this test is incorrect for local initializers
9086 beginning with ( without {. It would be much more difficult
9087 to do it correctly (ideally, the expression parser should
9088 be used in all cases) */
9089 par_count = 0;
9090 if (tok == '(') {
9091 AttributeDef ad1;
9092 CType type1;
9093 next();
9094 while (tok == '(') {
9095 par_count++;
9096 next();
9097 }
9098 if (!parse_btype(&type1, &ad1))
9099 expect("cast");
9100 type_decl(&type1, &ad1, &n, TYPE_ABSTRACT);
9101 #if 0
9102 if (!is_assignable_types(type, &type1))
9103 error("invalid type for cast");
9104 #endif
9105 skip(')');
9106 }
9107 no_oblock = 1;
9108 if (first || tok == '{') {
9109 skip('{');
9110 no_oblock = 0;
9111 }
9112 s = type->ref;
9113 f = s->next;
9114 array_length = 0;
9115 index = 0;
9116 n = s->c;
9117 while (tok != '}') {
9118 decl_designator(type, sec, c, NULL, &f, size_only);
9119 index = f->c;
9120 if (!size_only && array_length < index) {
9121 init_putz(type, sec, c + array_length,
9122 index - array_length);
9123 }
9124 index = index + type_size(&f->type, &align1);
9125 if (index > array_length)
9126 array_length = index;
9127 f = f->next;
9128 if (no_oblock && f == NULL)
9129 break;
9130 if (tok == '}')
9131 break;
9132 skip(',');
9133 }
9134 /* put zeros at the end */
9135 if (!size_only && array_length < n) {
9136 init_putz(type, sec, c + array_length,
9137 n - array_length);
9138 }
9139 if (!no_oblock)
9140 skip('}');
9141 while (par_count) {
9142 skip(')');
9143 par_count--;
9144 }
9145 } else if (tok == '{') {
9146 next();
9147 decl_initializer(type, sec, c, first, size_only);
9148 skip('}');
9149 } else if (size_only) {
9150 /* just skip expression */
9151 parlevel = 0;
9152 while ((parlevel > 0 || (tok != '}' && tok != ',')) &&
9153 tok != -1) {
9154 if (tok == '(')
9155 parlevel++;
9156 else if (tok == ')')
9157 parlevel--;
9158 next();
9159 }
9160 } else {
9161 /* currently, we always use constant expression for globals
9162 (may change for scripting case) */
9163 expr_type = EXPR_CONST;
9164 if (!sec)
9165 expr_type = EXPR_ANY;
9166 init_putv(type, sec, c, 0, expr_type);
9167 }
9168 }
9169
9170 /* parse an initializer for type 't' if 'has_init' is non zero, and
9171 allocate space in local or global data space ('r' is either
9172 VT_LOCAL or VT_CONST). If 'v' is non zero, then an associated
9173 variable 'v' of scope 'scope' is declared before initializers are
9174 parsed. If 'v' is zero, then a reference to the new object is put
9175 in the value stack. If 'has_init' is 2, a special parsing is done
9176 to handle string constants. */
9177 static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r,
9178 int has_init, int v, int scope)
9179 {
9180 int size, align, addr, data_offset;
9181 int level;
9182 ParseState saved_parse_state;
9183 TokenString init_str;
9184 Section *sec;
9185
9186 size = type_size(type, &align);
9187 /* If unknown size, we must evaluate it before
9188 evaluating initializers because
9189 initializers can generate global data too
9190 (e.g. string pointers or ISOC99 compound
9191 literals). It also simplifies local
9192 initializers handling */
9193 tok_str_new(&init_str);
9194 if (size < 0) {
9195 if (!has_init)
9196 error("unknown type size");
9197 /* get all init string */
9198 if (has_init == 2) {
9199 /* only get strings */
9200 while (tok == TOK_STR || tok == TOK_LSTR) {
9201 tok_str_add_tok(&init_str);
9202 next();
9203 }
9204 } else {
9205 level = 0;
9206 while (level > 0 || (tok != ',' && tok != ';')) {
9207 if (tok < 0)
9208 error("unexpected end of file in initializer");
9209 tok_str_add_tok(&init_str);
9210 if (tok == '{')
9211 level++;
9212 else if (tok == '}') {
9213 level--;
9214 if (level <= 0) {
9215 next();
9216 break;
9217 }
9218 }
9219 next();
9220 }
9221 }
9222 tok_str_add(&init_str, -1);
9223 tok_str_add(&init_str, 0);
9224
9225 /* compute size */
9226 save_parse_state(&saved_parse_state);
9227
9228 macro_ptr = init_str.str;
9229 next();
9230 decl_initializer(type, NULL, 0, 1, 1);
9231 /* prepare second initializer parsing */
9232 macro_ptr = init_str.str;
9233 next();
9234
9235 /* if still unknown size, error */
9236 size = type_size(type, &align);
9237 if (size < 0)
9238 error("unknown type size");
9239 }
9240 /* take into account specified alignment if bigger */
9241 if (ad->aligned) {
9242 if (ad->aligned > align)
9243 align = ad->aligned;
9244 } else if (ad->packed) {
9245 align = 1;
9246 }
9247 if ((r & VT_VALMASK) == VT_LOCAL) {
9248 sec = NULL;
9249 if (do_bounds_check && (type->t & VT_ARRAY))
9250 loc--;
9251 loc = (loc - size) & -align;
9252 addr = loc;
9253 /* handles bounds */
9254 /* XXX: currently, since we do only one pass, we cannot track
9255 '&' operators, so we add only arrays */
9256 if (do_bounds_check && (type->t & VT_ARRAY)) {
9257 unsigned long *bounds_ptr;
9258 /* add padding between regions */
9259 loc--;
9260 /* then add local bound info */
9261 bounds_ptr = section_ptr_add(lbounds_section, 2 * sizeof(unsigned long));
9262 bounds_ptr[0] = addr;
9263 bounds_ptr[1] = size;
9264 }
9265 if (v) {
9266 /* local variable */
9267 sym_push(v, type, r, addr);
9268 } else {
9269 /* push local reference */
9270 vset(type, r, addr);
9271 }
9272 } else {
9273 Sym *sym;
9274
9275 sym = NULL;
9276 if (v && scope == VT_CONST) {
9277 /* see if the symbol was already defined */
9278 sym = sym_find(v);
9279 if (sym) {
9280 if (!is_compatible_types(&sym->type, type))
9281 error("incompatible types for redefinition of '%s'",
9282 get_tok_str(v, NULL));
9283 if (sym->type.t & VT_EXTERN) {
9284 /* if the variable is extern, it was not allocated */
9285 sym->type.t &= ~VT_EXTERN;
9286 /* set array size if it was ommited in extern
9287 declaration */
9288 if ((sym->type.t & VT_ARRAY) &&
9289 sym->type.ref->c < 0 &&
9290 type->ref->c >= 0)
9291 sym->type.ref->c = type->ref->c;
9292 } else {
9293 /* we accept several definitions of the same
9294 global variable. this is tricky, because we
9295 must play with the SHN_COMMON type of the symbol */
9296 /* XXX: should check if the variable was already
9297 initialized. It is incorrect to initialized it
9298 twice */
9299 /* no init data, we won't add more to the symbol */
9300 if (!has_init)
9301 goto no_alloc;
9302 }
9303 }
9304 }
9305
9306 /* allocate symbol in corresponding section */
9307 sec = ad->section;
9308 if (!sec) {
9309 if (has_init)
9310 sec = data_section;
9311 else if (tcc_state->nocommon)
9312 sec = bss_section;
9313 }
9314 if (sec) {
9315 data_offset = sec->data_offset;
9316 data_offset = (data_offset + align - 1) & -align;
9317 addr = data_offset;
9318 /* very important to increment global pointer at this time
9319 because initializers themselves can create new initializers */
9320 data_offset += size;
9321 /* add padding if bound check */
9322 if (do_bounds_check)
9323 data_offset++;
9324 sec->data_offset = data_offset;
9325 /* allocate section space to put the data */
9326 if (sec->sh_type != SHT_NOBITS &&
9327 data_offset > sec->data_allocated)
9328 section_realloc(sec, data_offset);
9329 /* align section if needed */
9330 if (align > sec->sh_addralign)
9331 sec->sh_addralign = align;
9332 } else {
9333 addr = 0; /* avoid warning */
9334 }
9335
9336 if (v) {
9337 if (scope != VT_CONST || !sym) {
9338 sym = sym_push(v, type, r | VT_SYM, 0);
9339 }
9340 /* update symbol definition */
9341 if (sec) {
9342 put_extern_sym(sym, sec, addr, size);
9343 } else {
9344 ElfW(Sym) *esym;
9345 /* put a common area */
9346 put_extern_sym(sym, NULL, align, size);
9347 /* XXX: find a nicer way */
9348 esym = &((ElfW(Sym) *)symtab_section->data)[sym->c];
9349 esym->st_shndx = SHN_COMMON;
9350 }
9351 } else {
9352 CValue cval;
9353
9354 /* push global reference */
9355 sym = get_sym_ref(type, sec, addr, size);
9356 cval.ul = 0;
9357 vsetc(type, VT_CONST | VT_SYM, &cval);
9358 vtop->sym = sym;
9359 }
9360
9361 /* handles bounds now because the symbol must be defined
9362 before for the relocation */
9363 if (do_bounds_check) {
9364 unsigned long *bounds_ptr;
9365
9366 greloc(bounds_section, sym, bounds_section->data_offset, R_DATA_32);
9367 /* then add global bound info */
9368 bounds_ptr = section_ptr_add(bounds_section, 2 * sizeof(long));
9369 bounds_ptr[0] = 0; /* relocated */
9370 bounds_ptr[1] = size;
9371 }
9372 }
9373 if (has_init) {
9374 decl_initializer(type, sec, addr, 1, 0);
9375 /* restore parse state if needed */
9376 if (init_str.str) {
9377 tok_str_free(init_str.str);
9378 restore_parse_state(&saved_parse_state);
9379 }
9380 }
9381 no_alloc: ;
9382 }
9383
9384 void put_func_debug(Sym *sym)
9385 {
9386 char buf[512];
9387
9388 /* stabs info */
9389 /* XXX: we put here a dummy type */
9390 snprintf(buf, sizeof(buf), "%s:%c1",
9391 funcname, sym->type.t & VT_STATIC ? 'f' : 'F');
9392 put_stabs_r(buf, N_FUN, 0, file->line_num, 0,
9393 cur_text_section, sym->c);
9394 /* //gr gdb wants a line at the function */
9395 put_stabn(N_SLINE, 0, file->line_num, 0);
9396 last_ind = 0;
9397 last_line_num = 0;
9398 }
9399
9400 /* parse an old style function declaration list */
9401 /* XXX: check multiple parameter */
9402 static void func_decl_list(Sym *func_sym)
9403 {
9404 AttributeDef ad;
9405 int v;
9406 Sym *s;
9407 CType btype, type;
9408
9409 /* parse each declaration */
9410 while (tok != '{' && tok != ';' && tok != ',' && tok != TOK_EOF) {
9411 if (!parse_btype(&btype, &ad))
9412 expect("declaration list");
9413 if (((btype.t & VT_BTYPE) == VT_ENUM ||
9414 (btype.t & VT_BTYPE) == VT_STRUCT) &&
9415 tok == ';') {
9416 /* we accept no variable after */
9417 } else {
9418 for(;;) {
9419 type = btype;
9420 type_decl(&type, &ad, &v, TYPE_DIRECT);
9421 /* find parameter in function parameter list */
9422 s = func_sym->next;
9423 while (s != NULL) {
9424 if ((s->v & ~SYM_FIELD) == v)
9425 goto found;
9426 s = s->next;
9427 }
9428 error("declaration for parameter '%s' but no such parameter",
9429 get_tok_str(v, NULL));
9430 found:
9431 /* check that no storage specifier except 'register' was given */
9432 if (type.t & VT_STORAGE)
9433 error("storage class specified for '%s'", get_tok_str(v, NULL));
9434 convert_parameter_type(&type);
9435 /* we can add the type (NOTE: it could be local to the function) */
9436 s->type = type;
9437 /* accept other parameters */
9438 if (tok == ',')
9439 next();
9440 else
9441 break;
9442 }
9443 }
9444 skip(';');
9445 }
9446 }
9447
9448 /* parse a function defined by symbol 'sym' and generate its code in
9449 'cur_text_section' */
9450 static void gen_function(Sym *sym)
9451 {
9452 int saved_nocode_wanted = nocode_wanted;
9453 nocode_wanted = 0;
9454 ind = cur_text_section->data_offset;
9455 /* NOTE: we patch the symbol size later */
9456 put_extern_sym(sym, cur_text_section, ind, 0);
9457 funcname = get_tok_str(sym->v, NULL);
9458 func_ind = ind;
9459 /* put debug symbol */
9460 if (do_debug)
9461 put_func_debug(sym);
9462 /* push a dummy symbol to enable local sym storage */
9463 sym_push2(&local_stack, SYM_FIELD, 0, 0);
9464 gfunc_prolog(&sym->type);
9465 rsym = 0;
9466 block(NULL, NULL, NULL, NULL, 0, 0);
9467 gsym(rsym);
9468 gfunc_epilog();
9469 cur_text_section->data_offset = ind;
9470 label_pop(&global_label_stack, NULL);
9471 sym_pop(&local_stack, NULL); /* reset local stack */
9472 /* end of function */
9473 /* patch symbol size */
9474 ((ElfW(Sym) *)symtab_section->data)[sym->c].st_size =
9475 ind - func_ind;
9476 if (do_debug) {
9477 put_stabn(N_FUN, 0, 0, ind - func_ind);
9478 }
9479 /* It's better to crash than to generate wrong code */
9480 cur_text_section = NULL;
9481 funcname = ""; /* for safety */
9482 func_vt.t = VT_VOID; /* for safety */
9483 ind = 0; /* for safety */
9484 nocode_wanted = saved_nocode_wanted;
9485 }
9486
9487 static void gen_inline_functions(void)
9488 {
9489 Sym *sym;
9490 CType *type;
9491 int *str, inline_generated;
9492
9493 /* iterate while inline function are referenced */
9494 for(;;) {
9495 inline_generated = 0;
9496 for(sym = global_stack; sym != NULL; sym = sym->prev) {
9497 type = &sym->type;
9498 if (((type->t & VT_BTYPE) == VT_FUNC) &&
9499 (type->t & (VT_STATIC | VT_INLINE)) ==
9500 (VT_STATIC | VT_INLINE) &&
9501 sym->c != 0) {
9502 /* the function was used: generate its code and
9503 convert it to a normal function */
9504 str = INLINE_DEF(sym->r);
9505 sym->r = VT_SYM | VT_CONST;
9506 sym->type.t &= ~VT_INLINE;
9507
9508 macro_ptr = str;
9509 next();
9510 cur_text_section = text_section;
9511 gen_function(sym);
9512 macro_ptr = NULL; /* fail safe */
9513
9514 tok_str_free(str);
9515 inline_generated = 1;
9516 }
9517 }
9518 if (!inline_generated)
9519 break;
9520 }
9521
9522 /* free all remaining inline function tokens */
9523 for(sym = global_stack; sym != NULL; sym = sym->prev) {
9524 type = &sym->type;
9525 if (((type->t & VT_BTYPE) == VT_FUNC) &&
9526 (type->t & (VT_STATIC | VT_INLINE)) ==
9527 (VT_STATIC | VT_INLINE)) {
9528 //gr printf("sym %d %s\n", sym->r, get_tok_str(sym->v, NULL));
9529 if (sym->r == (VT_SYM | VT_CONST)) //gr beware!
9530 continue;
9531 str = INLINE_DEF(sym->r);
9532 tok_str_free(str);
9533 sym->r = 0; /* fail safe */
9534 }
9535 }
9536 }
9537
9538 /* 'l' is VT_LOCAL or VT_CONST to define default storage type */
9539 static void decl(int l)
9540 {
9541 int v, has_init, r;
9542 CType type, btype;
9543 Sym *sym;
9544 AttributeDef ad;
9545
9546 while (1) {
9547 if (!parse_btype(&btype, &ad)) {
9548 /* skip redundant ';' */
9549 /* XXX: find more elegant solution */
9550 if (tok == ';') {
9551 next();
9552 continue;
9553 }
9554 if (l == VT_CONST &&
9555 (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3)) {
9556 /* global asm block */
9557 asm_global_instr();
9558 continue;
9559 }
9560 /* special test for old K&R protos without explicit int
9561 type. Only accepted when defining global data */
9562 if (l == VT_LOCAL || tok < TOK_DEFINE)
9563 break;
9564 btype.t = VT_INT;
9565 }
9566 if (((btype.t & VT_BTYPE) == VT_ENUM ||
9567 (btype.t & VT_BTYPE) == VT_STRUCT) &&
9568 tok == ';') {
9569 /* we accept no variable after */
9570 next();
9571 continue;
9572 }
9573 while (1) { /* iterate thru each declaration */
9574 type = btype;
9575 type_decl(&type, &ad, &v, TYPE_DIRECT);
9576 #if 0
9577 {
9578 char buf[500];
9579 type_to_str(buf, sizeof(buf), t, get_tok_str(v, NULL));
9580 printf("type = '%s'\n", buf);
9581 }
9582 #endif
9583 if ((type.t & VT_BTYPE) == VT_FUNC) {
9584 /* if old style function prototype, we accept a
9585 declaration list */
9586 sym = type.ref;
9587 if (sym->c == FUNC_OLD)
9588 func_decl_list(sym);
9589 }
9590
9591 if (tok == '{') {
9592 if (l == VT_LOCAL)
9593 error("cannot use local functions");
9594 if ((type.t & VT_BTYPE) != VT_FUNC)
9595 expect("function definition");
9596
9597 /* reject abstract declarators in function definition */
9598 sym = type.ref;
9599 while ((sym = sym->next) != NULL)
9600 if (!(sym->v & ~SYM_FIELD))
9601 expect("identifier");
9602
9603 /* XXX: cannot do better now: convert extern line to static inline */
9604 if ((type.t & (VT_EXTERN | VT_INLINE)) == (VT_EXTERN | VT_INLINE))
9605 type.t = (type.t & ~VT_EXTERN) | VT_STATIC;
9606
9607 sym = sym_find(v);
9608 if (sym) {
9609 if ((sym->type.t & VT_BTYPE) != VT_FUNC)
9610 goto func_error1;
9611 /* specific case: if not func_call defined, we put
9612 the one of the prototype */
9613 /* XXX: should have default value */
9614 r = sym->type.ref->r;
9615 if (FUNC_CALL(r) != FUNC_CDECL
9616 && FUNC_CALL(type.ref->r) == FUNC_CDECL)
9617 FUNC_CALL(type.ref->r) = FUNC_CALL(r);
9618 if (FUNC_EXPORT(r))
9619 FUNC_EXPORT(type.ref->r) = 1;
9620
9621 if (!is_compatible_types(&sym->type, &type)) {
9622 func_error1:
9623 error("incompatible types for redefinition of '%s'",
9624 get_tok_str(v, NULL));
9625 }
9626 /* if symbol is already defined, then put complete type */
9627 sym->type = type;
9628 } else {
9629 /* put function symbol */
9630 sym = global_identifier_push(v, type.t, 0);
9631 sym->type.ref = type.ref;
9632 }
9633
9634 /* static inline functions are just recorded as a kind
9635 of macro. Their code will be emitted at the end of
9636 the compilation unit only if they are used */
9637 if ((type.t & (VT_INLINE | VT_STATIC)) ==
9638 (VT_INLINE | VT_STATIC)) {
9639 TokenString func_str;
9640 int block_level;
9641
9642 tok_str_new(&func_str);
9643
9644 block_level = 0;
9645 for(;;) {
9646 int t;
9647 if (tok == TOK_EOF)
9648 error("unexpected end of file");
9649 tok_str_add_tok(&func_str);
9650 t = tok;
9651 next();
9652 if (t == '{') {
9653 block_level++;
9654 } else if (t == '}') {
9655 block_level--;
9656 if (block_level == 0)
9657 break;
9658 }
9659 }
9660 tok_str_add(&func_str, -1);
9661 tok_str_add(&func_str, 0);
9662 INLINE_DEF(sym->r) = func_str.str;
9663 } else {
9664 /* compute text section */
9665 cur_text_section = ad.section;
9666 if (!cur_text_section)
9667 cur_text_section = text_section;
9668 sym->r = VT_SYM | VT_CONST;
9669 gen_function(sym);
9670 }
9671 break;
9672 } else {
9673 if (btype.t & VT_TYPEDEF) {
9674 /* save typedefed type */
9675 /* XXX: test storage specifiers ? */
9676 sym = sym_push(v, &type, 0, 0);
9677 sym->type.t |= VT_TYPEDEF;
9678 } else if ((type.t & VT_BTYPE) == VT_FUNC) {
9679 /* external function definition */
9680 /* specific case for func_call attribute */
9681 if (ad.func_attr)
9682 type.ref->r = ad.func_attr;
9683 external_sym(v, &type, 0);
9684 } else {
9685 /* not lvalue if array */
9686 r = 0;
9687 if (!(type.t & VT_ARRAY))
9688 r |= lvalue_type(type.t);
9689 has_init = (tok == '=');
9690 if ((btype.t & VT_EXTERN) ||
9691 ((type.t & VT_ARRAY) && (type.t & VT_STATIC) &&
9692 !has_init && l == VT_CONST && type.ref->c < 0)) {
9693 /* external variable */
9694 /* NOTE: as GCC, uninitialized global static
9695 arrays of null size are considered as
9696 extern */
9697 external_sym(v, &type, r);
9698 } else {
9699 type.t |= (btype.t & VT_STATIC); /* Retain "static". */
9700 if (type.t & VT_STATIC)
9701 r |= VT_CONST;
9702 else
9703 r |= l;
9704 if (has_init)
9705 next();
9706 decl_initializer_alloc(&type, &ad, r,
9707 has_init, v, l);
9708 }
9709 }
9710 if (tok != ',') {
9711 skip(';');
9712 break;
9713 }
9714 next();
9715 }
9716 }
9717 }
9718 }
9719
9720 /* better than nothing, but needs extension to handle '-E' option
9721 correctly too */
9722 static void preprocess_init(TCCState *s1)
9723 {
9724 s1->include_stack_ptr = s1->include_stack;
9725 /* XXX: move that before to avoid having to initialize
9726 file->ifdef_stack_ptr ? */
9727 s1->ifdef_stack_ptr = s1->ifdef_stack;
9728 file->ifdef_stack_ptr = s1->ifdef_stack_ptr;
9729
9730 /* XXX: not ANSI compliant: bound checking says error */
9731 vtop = vstack - 1;
9732 s1->pack_stack[0] = 0;
9733 s1->pack_stack_ptr = s1->pack_stack;
9734 }
9735
9736 /* compile the C file opened in 'file'. Return non zero if errors. */
9737 static int tcc_compile(TCCState *s1)
9738 {
9739 Sym *define_start;
9740 char buf[512];
9741 volatile int section_sym;
9742
9743 #ifdef INC_DEBUG
9744 printf("%s: **** new file\n", file->filename);
9745 #endif
9746 preprocess_init(s1);
9747
9748 cur_text_section = NULL;
9749 funcname = "";
9750 anon_sym = SYM_FIRST_ANOM;
9751
9752 /* file info: full path + filename */
9753 section_sym = 0; /* avoid warning */
9754 if (do_debug) {
9755 section_sym = put_elf_sym(symtab_section, 0, 0,
9756 ELFW(ST_INFO)(STB_LOCAL, STT_SECTION), 0,
9757 text_section->sh_num, NULL);
9758 getcwd(buf, sizeof(buf));
9759 #ifdef _WIN32
9760 normalize_slashes(buf);
9761 #endif
9762 pstrcat(buf, sizeof(buf), "/");
9763 put_stabs_r(buf, N_SO, 0, 0,
9764 text_section->data_offset, text_section, section_sym);
9765 put_stabs_r(file->filename, N_SO, 0, 0,
9766 text_section->data_offset, text_section, section_sym);
9767 }
9768 /* an elf symbol of type STT_FILE must be put so that STB_LOCAL
9769 symbols can be safely used */
9770 put_elf_sym(symtab_section, 0, 0,
9771 ELFW(ST_INFO)(STB_LOCAL, STT_FILE), 0,
9772 SHN_ABS, file->filename);
9773
9774 /* define some often used types */
9775 int_type.t = VT_INT;
9776
9777 char_pointer_type.t = VT_BYTE;
9778 mk_pointer(&char_pointer_type);
9779
9780 func_old_type.t = VT_FUNC;
9781 func_old_type.ref = sym_push(SYM_FIELD, &int_type, FUNC_CDECL, FUNC_OLD);
9782
9783 #if defined(TCC_ARM_EABI) && defined(TCC_ARM_VFP)
9784 float_type.t = VT_FLOAT;
9785 double_type.t = VT_DOUBLE;
9786
9787 func_float_type.t = VT_FUNC;
9788 func_float_type.ref = sym_push(SYM_FIELD, &float_type, FUNC_CDECL, FUNC_OLD);
9789 func_double_type.t = VT_FUNC;
9790 func_double_type.ref = sym_push(SYM_FIELD, &double_type, FUNC_CDECL, FUNC_OLD);
9791 #endif
9792
9793 #if 0
9794 /* define 'void *alloca(unsigned int)' builtin function */
9795 {
9796 Sym *s1;
9797
9798 p = anon_sym++;
9799 sym = sym_push(p, mk_pointer(VT_VOID), FUNC_CDECL, FUNC_NEW);
9800 s1 = sym_push(SYM_FIELD, VT_UNSIGNED | VT_INT, 0, 0);
9801 s1->next = NULL;
9802 sym->next = s1;
9803 sym_push(TOK_alloca, VT_FUNC | (p << VT_STRUCT_SHIFT), VT_CONST, 0);
9804 }
9805 #endif
9806
9807 define_start = define_stack;
9808 nocode_wanted = 1;
9809
9810 if (setjmp(s1->error_jmp_buf) == 0) {
9811 s1->nb_errors = 0;
9812 s1->error_set_jmp_enabled = 1;
9813
9814 ch = file->buf_ptr[0];
9815 tok_flags = TOK_FLAG_BOL | TOK_FLAG_BOF;
9816 parse_flags = PARSE_FLAG_PREPROCESS | PARSE_FLAG_TOK_NUM;
9817 next();
9818 decl(VT_CONST);
9819 if (tok != TOK_EOF)
9820 expect("declaration");
9821
9822 /* end of translation unit info */
9823 if (do_debug) {
9824 put_stabs_r(NULL, N_SO, 0, 0,
9825 text_section->data_offset, text_section, section_sym);
9826 }
9827 }
9828 s1->error_set_jmp_enabled = 0;
9829
9830 /* reset define stack, but leave -Dsymbols (may be incorrect if
9831 they are undefined) */
9832 free_defines(define_start);
9833
9834 gen_inline_functions();
9835
9836 sym_pop(&global_stack, NULL);
9837 sym_pop(&local_stack, NULL);
9838
9839 return s1->nb_errors != 0 ? -1 : 0;
9840 }
9841
9842 /* Preprocess the current file */
9843 /* XXX: add line and file infos,
9844 * XXX: add options to preserve spaces (partly done, only spaces in macro are
9845 * not preserved)
9846 */
9847 static int tcc_preprocess(TCCState *s1)
9848 {
9849 Sym *define_start;
9850 BufferedFile *file_ref;
9851 int token_seen, line_ref;
9852
9853 preprocess_init(s1);
9854 define_start = define_stack;
9855 ch = file->buf_ptr[0];
9856
9857 tok_flags = TOK_FLAG_BOL | TOK_FLAG_BOF;
9858 parse_flags = PARSE_FLAG_ASM_COMMENTS | PARSE_FLAG_PREPROCESS |
9859 PARSE_FLAG_LINEFEED;
9860
9861 token_seen = 0;
9862 line_ref = 0;
9863 file_ref = NULL;
9864
9865 for (;;) {
9866 next();
9867 if (tok == TOK_EOF) {
9868 break;
9869 } else if (tok == TOK_LINEFEED) {
9870 if (!token_seen)
9871 continue;
9872 ++line_ref;
9873 token_seen = 0;
9874 } else if (token_seen) {
9875 fwrite(tok_spaces.data, tok_spaces.size, 1, s1->outfile);
9876 } else {
9877 int d = file->line_num - line_ref;
9878 if (file != file_ref || d < 0 || d >= 8)
9879 fprintf(s1->outfile, "# %d \"%s\"\n", file->line_num, file->filename);
9880 else
9881 while (d)
9882 fputs("\n", s1->outfile), --d;
9883 line_ref = (file_ref = file)->line_num;
9884 token_seen = 1;
9885 }
9886 fputs(get_tok_str(tok, &tokc), s1->outfile);
9887 }
9888 free_defines(define_start);
9889 return 0;
9890 }
9891
9892 #ifdef LIBTCC
9893 int tcc_compile_string(TCCState *s, const char *str)
9894 {
9895 BufferedFile bf1, *bf = &bf1;
9896 int ret, len;
9897 char *buf;
9898
9899 /* init file structure */
9900 bf->fd = -1;
9901 /* XXX: avoid copying */
9902 len = strlen(str);
9903 buf = tcc_malloc(len + 1);
9904 if (!buf)
9905 return -1;
9906 memcpy(buf, str, len);
9907 buf[len] = CH_EOB;
9908 bf->buf_ptr = buf;
9909 bf->buf_end = buf + len;
9910 pstrcpy(bf->filename, sizeof(bf->filename), "<string>");
9911 bf->line_num = 1;
9912 file = bf;
9913 ret = tcc_compile(s);
9914 file = NULL;
9915 tcc_free(buf);
9916
9917 /* currently, no need to close */
9918 return ret;
9919 }
9920 #endif
9921
9922 /* define a preprocessor symbol. A value can also be provided with the '=' operator */
9923 void tcc_define_symbol(TCCState *s1, const char *sym, const char *value)
9924 {
9925 BufferedFile bf1, *bf = &bf1;
9926
9927 pstrcpy(bf->buffer, IO_BUF_SIZE, sym);
9928 pstrcat(bf->buffer, IO_BUF_SIZE, " ");
9929 /* default value */
9930 if (!value)
9931 value = "1";
9932 pstrcat(bf->buffer, IO_BUF_SIZE, value);
9933
9934 /* init file structure */
9935 bf->fd = -1;
9936 bf->buf_ptr = bf->buffer;
9937 bf->buf_end = bf->buffer + strlen(bf->buffer);
9938 *bf->buf_end = CH_EOB;
9939 bf->filename[0] = '\0';
9940 bf->line_num = 1;
9941 file = bf;
9942
9943 s1->include_stack_ptr = s1->include_stack;
9944
9945 /* parse with define parser */
9946 ch = file->buf_ptr[0];
9947 next_nomacro();
9948 parse_define();
9949 file = NULL;
9950 }
9951
9952 /* undefine a preprocessor symbol */
9953 void tcc_undefine_symbol(TCCState *s1, const char *sym)
9954 {
9955 TokenSym *ts;
9956 Sym *s;
9957 ts = tok_alloc(sym, strlen(sym));
9958 s = define_find(ts->tok);
9959 /* undefine symbol by putting an invalid name */
9960 if (s)
9961 define_undef(s);
9962 }
9963
9964 #ifdef CONFIG_TCC_ASM
9965
9966 #ifdef TCC_TARGET_I386
9967 #include "i386-asm.c"
9968 #endif
9969 #include "tccasm.c"
9970
9971 #else
9972 static void asm_instr(void)
9973 {
9974 error("inline asm() not supported");
9975 }
9976 static void asm_global_instr(void)
9977 {
9978 error("inline asm() not supported");
9979 }
9980 #endif
9981
9982 #include "tccelf.c"
9983
9984 #ifdef TCC_TARGET_COFF
9985 #include "tcccoff.c"
9986 #endif
9987
9988 #ifdef TCC_TARGET_PE
9989 #include "tccpe.c"
9990 #endif
9991
9992 /* print the position in the source file of PC value 'pc' by reading
9993 the stabs debug information */
9994 static void rt_printline(unsigned long wanted_pc)
9995 {
9996 Stab_Sym *sym, *sym_end;
9997 char func_name[128], last_func_name[128];
9998 unsigned long func_addr, last_pc, pc;
9999 const char *incl_files[INCLUDE_STACK_SIZE];
10000 int incl_index, len, last_line_num, i;
10001 const char *str, *p;
10002
10003 fprintf(stderr, "0x%08lx:", wanted_pc);
10004
10005 func_name[0] = '\0';
10006 func_addr = 0;
10007 incl_index = 0;
10008 last_func_name[0] = '\0';
10009 last_pc = 0xffffffff;
10010 last_line_num = 1;
10011 sym = (Stab_Sym *)stab_section->data + 1;
10012 sym_end = (Stab_Sym *)(stab_section->data + stab_section->data_offset);
10013 while (sym < sym_end) {
10014 switch(sym->n_type) {
10015 /* function start or end */
10016 case N_FUN:
10017 if (sym->n_strx == 0) {
10018 /* we test if between last line and end of function */
10019 pc = sym->n_value + func_addr;
10020 if (wanted_pc >= last_pc && wanted_pc < pc)
10021 goto found;
10022 func_name[0] = '\0';
10023 func_addr = 0;
10024 } else {
10025 str = stabstr_section->data + sym->n_strx;
10026 p = strchr(str, ':');
10027 if (!p) {
10028 pstrcpy(func_name, sizeof(func_name), str);
10029 } else {
10030 len = p - str;
10031 if (len > sizeof(func_name) - 1)
10032 len = sizeof(func_name) - 1;
10033 memcpy(func_name, str, len);
10034 func_name[len] = '\0';
10035 }
10036 func_addr = sym->n_value;
10037 }
10038 break;
10039 /* line number info */
10040 case N_SLINE:
10041 pc = sym->n_value + func_addr;
10042 if (wanted_pc >= last_pc && wanted_pc < pc)
10043 goto found;
10044 last_pc = pc;
10045 last_line_num = sym->n_desc;
10046 /* XXX: slow! */
10047 strcpy(last_func_name, func_name);
10048 break;
10049 /* include files */
10050 case N_BINCL:
10051 str = stabstr_section->data + sym->n_strx;
10052 add_incl:
10053 if (incl_index < INCLUDE_STACK_SIZE) {
10054 incl_files[incl_index++] = str;
10055 }
10056 break;
10057 case N_EINCL:
10058 if (incl_index > 1)
10059 incl_index--;
10060 break;
10061 case N_SO:
10062 if (sym->n_strx == 0) {
10063 incl_index = 0; /* end of translation unit */
10064 } else {
10065 str = stabstr_section->data + sym->n_strx;
10066 /* do not add path */
10067 len = strlen(str);
10068 if (len > 0 && str[len - 1] != '/')
10069 goto add_incl;
10070 }
10071 break;
10072 }
10073 sym++;
10074 }
10075
10076 /* second pass: we try symtab symbols (no line number info) */
10077 incl_index = 0;
10078 {
10079 ElfW(Sym) *sym, *sym_end;
10080 int type;
10081
10082 sym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
10083 for(sym = (ElfW(Sym) *)symtab_section->data + 1;
10084 sym < sym_end;
10085 sym++) {
10086 type = ELFW(ST_TYPE)(sym->st_info);
10087 if (type == STT_FUNC) {
10088 if (wanted_pc >= sym->st_value &&
10089 wanted_pc < sym->st_value + sym->st_size) {
10090 pstrcpy(last_func_name, sizeof(last_func_name),
10091 strtab_section->data + sym->st_name);
10092 goto found;
10093 }
10094 }
10095 }
10096 }
10097 /* did not find any info: */
10098 fprintf(stderr, " ???\n");
10099 return;
10100 found:
10101 if (last_func_name[0] != '\0') {
10102 fprintf(stderr, " %s()", last_func_name);
10103 }
10104 if (incl_index > 0) {
10105 fprintf(stderr, " (%s:%d",
10106 incl_files[incl_index - 1], last_line_num);
10107 for(i = incl_index - 2; i >= 0; i--)
10108 fprintf(stderr, ", included from %s", incl_files[i]);
10109 fprintf(stderr, ")");
10110 }
10111 fprintf(stderr, "\n");
10112 }
10113
10114 #if !defined(_WIN32) && !defined(CONFIG_TCCBOOT)
10115
10116 #ifdef __i386__
10117
10118 /* fix for glibc 2.1 */
10119 #ifndef REG_EIP
10120 #define REG_EIP EIP
10121 #define REG_EBP EBP
10122 #endif
10123
10124 /* return the PC at frame level 'level'. Return non zero if not found */
10125 static int rt_get_caller_pc(unsigned long *paddr,
10126 ucontext_t *uc, int level)
10127 {
10128 unsigned long fp;
10129 int i;
10130
10131 if (level == 0) {
10132 #if defined(__FreeBSD__)
10133 *paddr = uc->uc_mcontext.mc_eip;
10134 #elif defined(__dietlibc__)
10135 *paddr = uc->uc_mcontext.eip;
10136 #else
10137 *paddr = uc->uc_mcontext.gregs[REG_EIP];
10138 #endif
10139 return 0;
10140 } else {
10141 #if defined(__FreeBSD__)
10142 fp = uc->uc_mcontext.mc_ebp;
10143 #elif defined(__dietlibc__)
10144 fp = uc->uc_mcontext.ebp;
10145 #else
10146 fp = uc->uc_mcontext.gregs[REG_EBP];
10147 #endif
10148 for(i=1;i<level;i++) {
10149 /* XXX: check address validity with program info */
10150 if (fp <= 0x1000 || fp >= 0xc0000000)
10151 return -1;
10152 fp = ((unsigned long *)fp)[0];
10153 }
10154 *paddr = ((unsigned long *)fp)[1];
10155 return 0;
10156 }
10157 }
10158 #elif defined(__x86_64__)
10159 /* return the PC at frame level 'level'. Return non zero if not found */
10160 static int rt_get_caller_pc(unsigned long *paddr,
10161 ucontext_t *uc, int level)
10162 {
10163 unsigned long fp;
10164 int i;
10165
10166 if (level == 0) {
10167 /* XXX: only support linux */
10168 *paddr = uc->uc_mcontext.gregs[REG_RIP];
10169 return 0;
10170 } else {
10171 fp = uc->uc_mcontext.gregs[REG_RBP];
10172 for(i=1;i<level;i++) {
10173 /* XXX: check address validity with program info */
10174 if (fp <= 0x1000 || fp >= 0xc0000000)
10175 return -1;
10176 fp = ((unsigned long *)fp)[0];
10177 }
10178 *paddr = ((unsigned long *)fp)[1];
10179 return 0;
10180 }
10181 }
10182 #else
10183
10184 #warning add arch specific rt_get_caller_pc()
10185
10186 static int rt_get_caller_pc(unsigned long *paddr,
10187 ucontext_t *uc, int level)
10188 {
10189 return -1;
10190 }
10191 #endif
10192
10193 /* emit a run time error at position 'pc' */
10194 void rt_error(ucontext_t *uc, const char *fmt, ...)
10195 {
10196 va_list ap;
10197 unsigned long pc;
10198 int i;
10199
10200 va_start(ap, fmt);
10201 fprintf(stderr, "Runtime error: ");
10202 vfprintf(stderr, fmt, ap);
10203 fprintf(stderr, "\n");
10204 for(i=0;i<num_callers;i++) {
10205 if (rt_get_caller_pc(&pc, uc, i) < 0)
10206 break;
10207 if (i == 0)
10208 fprintf(stderr, "at ");
10209 else
10210 fprintf(stderr, "by ");
10211 rt_printline(pc);
10212 }
10213 exit(255);
10214 va_end(ap);
10215 }
10216
10217 /* signal handler for fatal errors */
10218 static void sig_error(int signum, siginfo_t *siginf, void *puc)
10219 {
10220 ucontext_t *uc = puc;
10221
10222 switch(signum) {
10223 case SIGFPE:
10224 switch(siginf->si_code) {
10225 case FPE_INTDIV:
10226 case FPE_FLTDIV:
10227 rt_error(uc, "division by zero");
10228 break;
10229 default:
10230 rt_error(uc, "floating point exception");
10231 break;
10232 }
10233 break;
10234 case SIGBUS:
10235 case SIGSEGV:
10236 if (rt_bound_error_msg && *rt_bound_error_msg)
10237 rt_error(uc, *rt_bound_error_msg);
10238 else
10239 rt_error(uc, "dereferencing invalid pointer");
10240 break;
10241 case SIGILL:
10242 rt_error(uc, "illegal instruction");
10243 break;
10244 case SIGABRT:
10245 rt_error(uc, "abort() called");
10246 break;
10247 default:
10248 rt_error(uc, "caught signal %d", signum);
10249 break;
10250 }
10251 exit(255);
10252 }
10253 #endif
10254
10255 /* do all relocations (needed before using tcc_get_symbol()) */
10256 int tcc_relocate(TCCState *s1)
10257 {
10258 Section *s;
10259 int i;
10260
10261 s1->nb_errors = 0;
10262
10263 #ifdef TCC_TARGET_PE
10264 pe_add_runtime(s1);
10265 #else
10266 tcc_add_runtime(s1);
10267 #endif
10268
10269 relocate_common_syms();
10270
10271 tcc_add_linker_symbols(s1);
10272 #ifndef TCC_TARGET_PE
10273 build_got_entries(s1);
10274 #endif
10275
10276 #ifdef TCC_TARGET_X86_64
10277 {
10278 /* If the distance of two sections are longer than 32bit, our
10279 program will crash. Let's combine all sections which are
10280 necessary to run the program into a single buffer in the
10281 text section */
10282 unsigned char *p;
10283 int size;
10284 /* calculate the size of buffers we need */
10285 size = 0;
10286 for(i = 1; i < s1->nb_sections; i++) {
10287 s = s1->sections[i];
10288 if (s->sh_flags & SHF_ALLOC) {
10289 size += s->data_offset;
10290 }
10291 }
10292 /* double the size of the buffer for got and plt entries
10293 XXX: calculate exact size for them? */
10294 section_realloc(text_section, size * 2);
10295 p = text_section->data + text_section->data_offset;
10296 /* we will put got and plt after this offset */
10297 text_section->data_offset = size;
10298
10299 for(i = 1; i < s1->nb_sections; i++) {
10300 s = s1->sections[i];
10301 if (s->sh_flags & SHF_ALLOC) {
10302 if (s != text_section && s->data_offset) {
10303 if (s->sh_type == SHT_NOBITS) {
10304 /* for bss section */
10305 memset(p, 0, s->data_offset);
10306 } else {
10307 memcpy(p, s->data, s->data_offset);
10308 tcc_free(s->data);
10309 }
10310 s->data = p;
10311 /* we won't free s->data for this section */
10312 s->data_allocated = 0;
10313 p += s->data_offset;
10314 }
10315 s->sh_addr = (unsigned long)s->data;
10316 }
10317 }
10318 }
10319 #else
10320 /* compute relocation address : section are relocated in place. We
10321 also alloc the bss space */
10322 for(i = 1; i < s1->nb_sections; i++) {
10323 s = s1->sections[i];
10324 if (s->sh_flags & SHF_ALLOC) {
10325 if (s->sh_type == SHT_NOBITS)
10326 s->data = tcc_mallocz(s->data_offset);
10327 s->sh_addr = (unsigned long)s->data;
10328 }
10329 }
10330 #endif
10331
10332 relocate_syms(s1, 1);
10333
10334 if (s1->nb_errors != 0)
10335 return -1;
10336
10337 /* relocate each section */
10338 for(i = 1; i < s1->nb_sections; i++) {
10339 s = s1->sections[i];
10340 if (s->reloc)
10341 relocate_section(s1, s);
10342 }
10343
10344 /* mark executable sections as executable in memory */
10345 for(i = 1; i < s1->nb_sections; i++) {
10346 s = s1->sections[i];
10347 if ((s->sh_flags & (SHF_ALLOC | SHF_EXECINSTR)) ==
10348 (SHF_ALLOC | SHF_EXECINSTR))
10349 set_pages_executable(s->data, s->data_offset);
10350 }
10351 return 0;
10352 }
10353
10354 /* launch the compiled program with the given arguments */
10355 int tcc_run(TCCState *s1, int argc, char **argv)
10356 {
10357 int (*prog_main)(int, char **);
10358
10359 if (tcc_relocate(s1) < 0)
10360 return -1;
10361
10362 prog_main = tcc_get_symbol_err(s1, "main");
10363
10364 if (do_debug) {
10365 #if defined(_WIN32) || defined(CONFIG_TCCBOOT)
10366 error("debug mode currently not available for Windows");
10367 #else
10368 struct sigaction sigact;
10369 /* install TCC signal handlers to print debug info on fatal
10370 runtime errors */
10371 sigact.sa_flags = SA_SIGINFO | SA_RESETHAND;
10372 sigact.sa_sigaction = sig_error;
10373 sigemptyset(&sigact.sa_mask);
10374 sigaction(SIGFPE, &sigact, NULL);
10375 sigaction(SIGILL, &sigact, NULL);
10376 sigaction(SIGSEGV, &sigact, NULL);
10377 sigaction(SIGBUS, &sigact, NULL);
10378 sigaction(SIGABRT, &sigact, NULL);
10379 #endif
10380 }
10381
10382 #ifdef CONFIG_TCC_BCHECK
10383 if (do_bounds_check) {
10384 void (*bound_init)(void);
10385
10386 /* set error function */
10387 rt_bound_error_msg = (void *)tcc_get_symbol_err(s1,
10388 "__bound_error_msg");
10389
10390 /* XXX: use .init section so that it also work in binary ? */
10391 bound_init = (void *)tcc_get_symbol_err(s1, "__bound_init");
10392 bound_init();
10393 }
10394 #endif
10395 return (*prog_main)(argc, argv);
10396 }
10397
10398 void tcc_memstats(void)
10399 {
10400 #ifdef MEM_DEBUG
10401 printf("memory in use: %d\n", mem_cur_size);
10402 #endif
10403 }
10404
10405 static void tcc_cleanup(void)
10406 {
10407 int i, n;
10408
10409 if (NULL == tcc_state)
10410 return;
10411 tcc_state = NULL;
10412
10413 /* free -D defines */
10414 free_defines(NULL);
10415
10416 /* free tokens */
10417 n = tok_ident - TOK_IDENT;
10418 for(i = 0; i < n; i++)
10419 tcc_free(table_ident[i]);
10420 tcc_free(table_ident);
10421
10422 /* free sym_pools */
10423 dynarray_reset(&sym_pools, &nb_sym_pools);
10424 /* string buffer */
10425 cstr_free(&tokcstr);
10426 /* reset symbol stack */
10427 sym_free_first = NULL;
10428 /* cleanup from error/setjmp */
10429 macro_ptr = NULL;
10430 }
10431
10432 TCCState *tcc_new(void)
10433 {
10434 const char *p, *r;
10435 TCCState *s;
10436 TokenSym *ts;
10437 int i, c;
10438
10439 tcc_cleanup();
10440
10441 s = tcc_mallocz(sizeof(TCCState));
10442 if (!s)
10443 return NULL;
10444 tcc_state = s;
10445 s->output_type = TCC_OUTPUT_MEMORY;
10446
10447 /* init isid table */
10448 for(i=CH_EOF;i<256;i++)
10449 isidnum_table[i-CH_EOF] = isid(i) || isnum(i);
10450
10451 /* add all tokens */
10452 table_ident = NULL;
10453 memset(hash_ident, 0, TOK_HASH_SIZE * sizeof(TokenSym *));
10454
10455 tok_ident = TOK_IDENT;
10456 p = tcc_keywords;
10457 while (*p) {
10458 r = p;
10459 for(;;) {
10460 c = *r++;
10461 if (c == '\0')
10462 break;
10463 }
10464 ts = tok_alloc(p, r - p - 1);
10465 p = r;
10466 }
10467
10468 /* we add dummy defines for some special macros to speed up tests
10469 and to have working defined() */
10470 define_push(TOK___LINE__, MACRO_OBJ, NULL, NULL);
10471 define_push(TOK___FILE__, MACRO_OBJ, NULL, NULL);
10472 define_push(TOK___DATE__, MACRO_OBJ, NULL, NULL);
10473 define_push(TOK___TIME__, MACRO_OBJ, NULL, NULL);
10474
10475 /* standard defines */
10476 tcc_define_symbol(s, "__STDC__", NULL);
10477 tcc_define_symbol(s, "__STDC_VERSION__", "199901L");
10478 #if defined(TCC_TARGET_I386)
10479 tcc_define_symbol(s, "__i386__", NULL);
10480 #endif
10481 #if defined(TCC_TARGET_X86_64)
10482 tcc_define_symbol(s, "__x86_64__", NULL);
10483 #endif
10484 #if defined(TCC_TARGET_ARM)
10485 tcc_define_symbol(s, "__ARM_ARCH_4__", NULL);
10486 tcc_define_symbol(s, "__arm_elf__", NULL);
10487 tcc_define_symbol(s, "__arm_elf", NULL);
10488 tcc_define_symbol(s, "arm_elf", NULL);
10489 tcc_define_symbol(s, "__arm__", NULL);
10490 tcc_define_symbol(s, "__arm", NULL);
10491 tcc_define_symbol(s, "arm", NULL);
10492 tcc_define_symbol(s, "__APCS_32__", NULL);
10493 #endif
10494 #ifdef TCC_TARGET_PE
10495 tcc_define_symbol(s, "_WIN32", NULL);
10496 #else
10497 tcc_define_symbol(s, "__unix__", NULL);
10498 tcc_define_symbol(s, "__unix", NULL);
10499 #if defined(__linux)
10500 tcc_define_symbol(s, "__linux__", NULL);
10501 tcc_define_symbol(s, "__linux", NULL);
10502 #endif
10503 #endif
10504 /* tiny C specific defines */
10505 tcc_define_symbol(s, "__TINYC__", NULL);
10506
10507 /* tiny C & gcc defines */
10508 tcc_define_symbol(s, "__SIZE_TYPE__", "unsigned int");
10509 tcc_define_symbol(s, "__PTRDIFF_TYPE__", "int");
10510 #ifdef TCC_TARGET_PE
10511 tcc_define_symbol(s, "__WCHAR_TYPE__", "unsigned short");
10512 #else
10513 tcc_define_symbol(s, "__WCHAR_TYPE__", "int");
10514 #endif
10515
10516 #ifndef TCC_TARGET_PE
10517 /* default library paths */
10518 tcc_add_library_path(s, CONFIG_SYSROOT "/usr/local/lib");
10519 tcc_add_library_path(s, CONFIG_SYSROOT "/usr/lib");
10520 tcc_add_library_path(s, CONFIG_SYSROOT "/lib");
10521 #endif
10522
10523 /* no section zero */
10524 dynarray_add((void ***)&s->sections, &s->nb_sections, NULL);
10525
10526 /* create standard sections */
10527 text_section = new_section(s, ".text", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR);
10528 data_section = new_section(s, ".data", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
10529 bss_section = new_section(s, ".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
10530
10531 /* symbols are always generated for linking stage */
10532 symtab_section = new_symtab(s, ".symtab", SHT_SYMTAB, 0,
10533 ".strtab",
10534 ".hashtab", SHF_PRIVATE);
10535 strtab_section = symtab_section->link;
10536
10537 /* private symbol table for dynamic symbols */
10538 s->dynsymtab_section = new_symtab(s, ".dynsymtab", SHT_SYMTAB, SHF_PRIVATE,
10539 ".dynstrtab",
10540 ".dynhashtab", SHF_PRIVATE);
10541 s->alacarte_link = 1;
10542
10543 #ifdef CHAR_IS_UNSIGNED
10544 s->char_is_unsigned = 1;
10545 #endif
10546 #if defined(TCC_TARGET_PE) && 0
10547 /* XXX: currently the PE linker is not ready to support that */
10548 s->leading_underscore = 1;
10549 #endif
10550 return s;
10551 }
10552
10553 void tcc_delete(TCCState *s1)
10554 {
10555 int i;
10556
10557 tcc_cleanup();
10558
10559 /* free all sections */
10560 for(i = 1; i < s1->nb_sections; i++)
10561 free_section(s1->sections[i]);
10562 dynarray_reset(&s1->sections, &s1->nb_sections);
10563
10564 for(i = 0; i < s1->nb_priv_sections; i++)
10565 free_section(s1->priv_sections[i]);
10566 dynarray_reset(&s1->priv_sections, &s1->nb_priv_sections);
10567
10568 /* free any loaded DLLs */
10569 for ( i = 0; i < s1->nb_loaded_dlls; i++) {
10570 DLLReference *ref = s1->loaded_dlls[i];
10571 if ( ref->handle )
10572 dlclose(ref->handle);
10573 }
10574
10575 /* free loaded dlls array */
10576 dynarray_reset(&s1->loaded_dlls, &s1->nb_loaded_dlls);
10577
10578 /* free library paths */
10579 dynarray_reset(&s1->library_paths, &s1->nb_library_paths);
10580
10581 /* free include paths */
10582 dynarray_reset(&s1->cached_includes, &s1->nb_cached_includes);
10583 dynarray_reset(&s1->include_paths, &s1->nb_include_paths);
10584 dynarray_reset(&s1->sysinclude_paths, &s1->nb_sysinclude_paths);
10585
10586 tcc_free(s1);
10587 }
10588
10589 int tcc_add_include_path(TCCState *s1, const char *pathname)
10590 {
10591 char *pathname1;
10592
10593 pathname1 = tcc_strdup(pathname);
10594 dynarray_add((void ***)&s1->include_paths, &s1->nb_include_paths, pathname1);
10595 return 0;
10596 }
10597
10598 int tcc_add_sysinclude_path(TCCState *s1, const char *pathname)
10599 {
10600 char *pathname1;
10601
10602 pathname1 = tcc_strdup(pathname);
10603 dynarray_add((void ***)&s1->sysinclude_paths, &s1->nb_sysinclude_paths, pathname1);
10604 return 0;
10605 }
10606
10607 static int tcc_add_file_internal(TCCState *s1, const char *filename, int flags)
10608 {
10609 const char *ext;
10610 ElfW(Ehdr) ehdr;
10611 int fd, ret;
10612 BufferedFile *saved_file;
10613
10614 /* find source file type with extension */
10615 ext = tcc_fileextension(filename);
10616 if (ext[0])
10617 ext++;
10618
10619 /* open the file */
10620 saved_file = file;
10621 file = tcc_open(s1, filename);
10622 if (!file) {
10623 if (flags & AFF_PRINT_ERROR) {
10624 error_noabort("file '%s' not found", filename);
10625 }
10626 ret = -1;
10627 goto fail1;
10628 }
10629
10630 if (flags & AFF_PREPROCESS) {
10631 ret = tcc_preprocess(s1);
10632 } else if (!ext[0] || !strcmp(ext, "c")) {
10633 /* C file assumed */
10634 ret = tcc_compile(s1);
10635 } else
10636 #ifdef CONFIG_TCC_ASM
10637 if (!strcmp(ext, "S")) {
10638 /* preprocessed assembler */
10639 ret = tcc_assemble(s1, 1);
10640 } else if (!strcmp(ext, "s")) {
10641 /* non preprocessed assembler */
10642 ret = tcc_assemble(s1, 0);
10643 } else
10644 #endif
10645 #ifdef TCC_TARGET_PE
10646 if (!strcmp(ext, "def")) {
10647 ret = pe_load_def_file(s1, file->fd);
10648 } else
10649 #endif
10650 {
10651 fd = file->fd;
10652 /* assume executable format: auto guess file type */
10653 ret = read(fd, &ehdr, sizeof(ehdr));
10654 lseek(fd, 0, SEEK_SET);
10655 if (ret <= 0) {
10656 error_noabort("could not read header");
10657 goto fail;
10658 } else if (ret != sizeof(ehdr)) {
10659 goto try_load_script;
10660 }
10661
10662 if (ehdr.e_ident[0] == ELFMAG0 &&
10663 ehdr.e_ident[1] == ELFMAG1 &&
10664 ehdr.e_ident[2] == ELFMAG2 &&
10665 ehdr.e_ident[3] == ELFMAG3) {
10666 file->line_num = 0; /* do not display line number if error */
10667 if (ehdr.e_type == ET_REL) {
10668 ret = tcc_load_object_file(s1, fd, 0);
10669 } else if (ehdr.e_type == ET_DYN) {
10670 if (s1->output_type == TCC_OUTPUT_MEMORY) {
10671 #ifdef TCC_TARGET_PE
10672 ret = -1;
10673 #else
10674 void *h;
10675 h = dlopen(filename, RTLD_GLOBAL | RTLD_LAZY);
10676 if (h)
10677 ret = 0;
10678 else
10679 ret = -1;
10680 #endif
10681 } else {
10682 ret = tcc_load_dll(s1, fd, filename,
10683 (flags & AFF_REFERENCED_DLL) != 0);
10684 }
10685 } else {
10686 error_noabort("unrecognized ELF file");
10687 goto fail;
10688 }
10689 } else if (memcmp((char *)&ehdr, ARMAG, 8) == 0) {
10690 file->line_num = 0; /* do not display line number if error */
10691 ret = tcc_load_archive(s1, fd);
10692 } else
10693 #ifdef TCC_TARGET_COFF
10694 if (*(uint16_t *)(&ehdr) == COFF_C67_MAGIC) {
10695 ret = tcc_load_coff(s1, fd);
10696 } else
10697 #endif
10698 #ifdef TCC_TARGET_PE
10699 if (pe_test_res_file(&ehdr, ret)) {
10700 ret = pe_load_res_file(s1, fd);
10701 } else
10702 #endif
10703 {
10704 /* as GNU ld, consider it is an ld script if not recognized */
10705 try_load_script:
10706 ret = tcc_load_ldscript(s1);
10707 if (ret < 0) {
10708 error_noabort("unrecognized file type");
10709 goto fail;
10710 }
10711 }
10712 }
10713 the_end:
10714 tcc_close(file);
10715 fail1:
10716 file = saved_file;
10717 return ret;
10718 fail:
10719 ret = -1;
10720 goto the_end;
10721 }
10722
10723 int tcc_add_file(TCCState *s, const char *filename)
10724 {
10725 return tcc_add_file_internal(s, filename, AFF_PRINT_ERROR);
10726 }
10727
10728 int tcc_add_library_path(TCCState *s, const char *pathname)
10729 {
10730 char *pathname1;
10731
10732 pathname1 = tcc_strdup(pathname);
10733 dynarray_add((void ***)&s->library_paths, &s->nb_library_paths, pathname1);
10734 return 0;
10735 }
10736
10737 /* find and load a dll. Return non zero if not found */
10738 /* XXX: add '-rpath' option support ? */
10739 static int tcc_add_dll(TCCState *s, const char *filename, int flags)
10740 {
10741 char buf[1024];
10742 int i;
10743
10744 for(i = 0; i < s->nb_library_paths; i++) {
10745 snprintf(buf, sizeof(buf), "%s/%s",
10746 s->library_paths[i], filename);
10747 if (tcc_add_file_internal(s, buf, flags) == 0)
10748 return 0;
10749 }
10750 return -1;
10751 }
10752
10753 /* the library name is the same as the argument of the '-l' option */
10754 int tcc_add_library(TCCState *s, const char *libraryname)
10755 {
10756 char buf[1024];
10757 int i;
10758
10759 /* first we look for the dynamic library if not static linking */
10760 if (!s->static_link) {
10761 #ifdef TCC_TARGET_PE
10762 snprintf(buf, sizeof(buf), "%s.def", libraryname);
10763 #else
10764 snprintf(buf, sizeof(buf), "lib%s.so", libraryname);
10765 #endif
10766 if (tcc_add_dll(s, buf, 0) == 0)
10767 return 0;
10768 }
10769
10770 /* then we look for the static library */
10771 for(i = 0; i < s->nb_library_paths; i++) {
10772 snprintf(buf, sizeof(buf), "%s/lib%s.a",
10773 s->library_paths[i], libraryname);
10774 if (tcc_add_file_internal(s, buf, 0) == 0)
10775 return 0;
10776 }
10777 return -1;
10778 }
10779
10780 int tcc_add_symbol(TCCState *s, const char *name, unsigned long val)
10781 {
10782 add_elf_sym(symtab_section, val, 0,
10783 ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
10784 SHN_ABS, name);
10785 return 0;
10786 }
10787
10788 int tcc_set_output_type(TCCState *s, int output_type)
10789 {
10790 char buf[1024];
10791
10792 s->output_type = output_type;
10793
10794 if (!s->nostdinc) {
10795 /* default include paths */
10796 /* XXX: reverse order needed if -isystem support */
10797 #ifndef TCC_TARGET_PE
10798 tcc_add_sysinclude_path(s, CONFIG_SYSROOT "/usr/local/include");
10799 tcc_add_sysinclude_path(s, CONFIG_SYSROOT "/usr/include");
10800 #endif
10801 snprintf(buf, sizeof(buf), "%s/include", tcc_lib_path);
10802 tcc_add_sysinclude_path(s, buf);
10803 #ifdef TCC_TARGET_PE
10804 snprintf(buf, sizeof(buf), "%s/include/winapi", tcc_lib_path);
10805 tcc_add_sysinclude_path(s, buf);
10806 #endif
10807 }
10808
10809 /* if bound checking, then add corresponding sections */
10810 #ifdef CONFIG_TCC_BCHECK
10811 if (do_bounds_check) {
10812 /* define symbol */
10813 tcc_define_symbol(s, "__BOUNDS_CHECKING_ON", NULL);
10814 /* create bounds sections */
10815 bounds_section = new_section(s, ".bounds",
10816 SHT_PROGBITS, SHF_ALLOC);
10817 lbounds_section = new_section(s, ".lbounds",
10818 SHT_PROGBITS, SHF_ALLOC);
10819 }
10820 #endif
10821
10822 if (s->char_is_unsigned) {
10823 tcc_define_symbol(s, "__CHAR_UNSIGNED__", NULL);
10824 }
10825
10826 /* add debug sections */
10827 if (do_debug) {
10828 /* stab symbols */
10829 stab_section = new_section(s, ".stab", SHT_PROGBITS, 0);
10830 stab_section->sh_entsize = sizeof(Stab_Sym);
10831 stabstr_section = new_section(s, ".stabstr", SHT_STRTAB, 0);
10832 put_elf_str(stabstr_section, "");
10833 stab_section->link = stabstr_section;
10834 /* put first entry */
10835 put_stabs("", 0, 0, 0, 0);
10836 }
10837
10838 /* add libc crt1/crti objects */
10839 #ifndef TCC_TARGET_PE
10840 if ((output_type == TCC_OUTPUT_EXE || output_type == TCC_OUTPUT_DLL) &&
10841 !s->nostdlib) {
10842 if (output_type != TCC_OUTPUT_DLL)
10843 tcc_add_file(s, CONFIG_TCC_CRT_PREFIX "/crt1.o");
10844 tcc_add_file(s, CONFIG_TCC_CRT_PREFIX "/crti.o");
10845 }
10846 #endif
10847
10848 #ifdef TCC_TARGET_PE
10849 snprintf(buf, sizeof(buf), "%s/lib", tcc_lib_path);
10850 tcc_add_library_path(s, buf);
10851 #endif
10852
10853 return 0;
10854 }
10855
10856 #define WD_ALL 0x0001 /* warning is activated when using -Wall */
10857 #define FD_INVERT 0x0002 /* invert value before storing */
10858
10859 typedef struct FlagDef {
10860 uint16_t offset;
10861 uint16_t flags;
10862 const char *name;
10863 } FlagDef;
10864
10865 static const FlagDef warning_defs[] = {
10866 { offsetof(TCCState, warn_unsupported), 0, "unsupported" },
10867 { offsetof(TCCState, warn_write_strings), 0, "write-strings" },
10868 { offsetof(TCCState, warn_error), 0, "error" },
10869 { offsetof(TCCState, warn_implicit_function_declaration), WD_ALL,
10870 "implicit-function-declaration" },
10871 };
10872
10873 static int set_flag(TCCState *s, const FlagDef *flags, int nb_flags,
10874 const char *name, int value)
10875 {
10876 int i;
10877 const FlagDef *p;
10878 const char *r;
10879
10880 r = name;
10881 if (r[0] == 'n' && r[1] == 'o' && r[2] == '-') {
10882 r += 3;
10883 value = !value;
10884 }
10885 for(i = 0, p = flags; i < nb_flags; i++, p++) {
10886 if (!strcmp(r, p->name))
10887 goto found;
10888 }
10889 return -1;
10890 found:
10891 if (p->flags & FD_INVERT)
10892 value = !value;
10893 *(int *)((uint8_t *)s + p->offset) = value;
10894 return 0;
10895 }
10896
10897
10898 /* set/reset a warning */
10899 int tcc_set_warning(TCCState *s, const char *warning_name, int value)
10900 {
10901 int i;
10902 const FlagDef *p;
10903
10904 if (!strcmp(warning_name, "all")) {
10905 for(i = 0, p = warning_defs; i < countof(warning_defs); i++, p++) {
10906 if (p->flags & WD_ALL)
10907 *(int *)((uint8_t *)s + p->offset) = 1;
10908 }
10909 return 0;
10910 } else {
10911 return set_flag(s, warning_defs, countof(warning_defs),
10912 warning_name, value);
10913 }
10914 }
10915
10916 static const FlagDef flag_defs[] = {
10917 { offsetof(TCCState, char_is_unsigned), 0, "unsigned-char" },
10918 { offsetof(TCCState, char_is_unsigned), FD_INVERT, "signed-char" },
10919 { offsetof(TCCState, nocommon), FD_INVERT, "common" },
10920 { offsetof(TCCState, leading_underscore), 0, "leading-underscore" },
10921 };
10922
10923 /* set/reset a flag */
10924 int tcc_set_flag(TCCState *s, const char *flag_name, int value)
10925 {
10926 return set_flag(s, flag_defs, countof(flag_defs),
10927 flag_name, value);
10928 }
10929
10930 #if !defined(LIBTCC)
10931
10932 static int64_t getclock_us(void)
10933 {
10934 #ifdef _WIN32
10935 struct _timeb tb;
10936 _ftime(&tb);
10937 return (tb.time * 1000LL + tb.millitm) * 1000LL;
10938 #else
10939 struct timeval tv;
10940 gettimeofday(&tv, NULL);
10941 return tv.tv_sec * 1000000LL + tv.tv_usec;
10942 #endif
10943 }
10944
10945 void help(void)
10946 {
10947 printf("tcc version " TCC_VERSION " - Tiny C Compiler - Copyright (C) 2001-2006 Fabrice Bellard\n"
10948 "usage: tcc [-v] [-c] [-o outfile] [-Bdir] [-bench] [-Idir] [-Dsym[=val]] [-Usym]\n"
10949 " [-Wwarn] [-g] [-b] [-bt N] [-Ldir] [-llib] [-shared] [-soname name]\n"
10950 " [-static] [infile1 infile2...] [-run infile args...]\n"
10951 "\n"
10952 "General options:\n"
10953 " -v display current version, increase verbosity\n"
10954 " -c compile only - generate an object file\n"
10955 " -o outfile set output filename\n"
10956 " -Bdir set tcc internal library path\n"
10957 " -bench output compilation statistics\n"
10958 " -run run compiled source\n"
10959 " -fflag set or reset (with 'no-' prefix) 'flag' (see man page)\n"
10960 " -Wwarning set or reset (with 'no-' prefix) 'warning' (see man page)\n"
10961 " -w disable all warnings\n"
10962 "Preprocessor options:\n"
10963 " -E preprocess only\n"
10964 " -Idir add include path 'dir'\n"
10965 " -Dsym[=val] define 'sym' with value 'val'\n"
10966 " -Usym undefine 'sym'\n"
10967 "Linker options:\n"
10968 " -Ldir add library path 'dir'\n"
10969 " -llib link with dynamic or static library 'lib'\n"
10970 " -shared generate a shared library\n"
10971 " -soname set name for shared library to be used at runtime\n"
10972 " -static static linking\n"
10973 " -rdynamic export all global symbols to dynamic linker\n"
10974 " -r generate (relocatable) object file\n"
10975 "Debugger options:\n"
10976 " -g generate runtime debug info\n"
10977 #ifdef CONFIG_TCC_BCHECK
10978 " -b compile with built-in memory and bounds checker (implies -g)\n"
10979 #endif
10980 " -bt N show N callers in stack traces\n"
10981 );
10982 }
10983
10984 #define TCC_OPTION_HAS_ARG 0x0001
10985 #define TCC_OPTION_NOSEP 0x0002 /* cannot have space before option and arg */
10986
10987 typedef struct TCCOption {
10988 const char *name;
10989 uint16_t index;
10990 uint16_t flags;
10991 } TCCOption;
10992
10993 enum {
10994 TCC_OPTION_HELP,
10995 TCC_OPTION_I,
10996 TCC_OPTION_D,
10997 TCC_OPTION_U,
10998 TCC_OPTION_L,
10999 TCC_OPTION_B,
11000 TCC_OPTION_l,
11001 TCC_OPTION_bench,
11002 TCC_OPTION_bt,
11003 TCC_OPTION_b,
11004 TCC_OPTION_g,
11005 TCC_OPTION_c,
11006 TCC_OPTION_static,
11007 TCC_OPTION_shared,
11008 TCC_OPTION_soname,
11009 TCC_OPTION_o,
11010 TCC_OPTION_r,
11011 TCC_OPTION_Wl,
11012 TCC_OPTION_W,
11013 TCC_OPTION_O,
11014 TCC_OPTION_m,
11015 TCC_OPTION_f,
11016 TCC_OPTION_nostdinc,
11017 TCC_OPTION_nostdlib,
11018 TCC_OPTION_print_search_dirs,
11019 TCC_OPTION_rdynamic,
11020 TCC_OPTION_run,
11021 TCC_OPTION_v,
11022 TCC_OPTION_w,
11023 TCC_OPTION_pipe,
11024 TCC_OPTION_E,
11025 };
11026
11027 static const TCCOption tcc_options[] = {
11028 { "h", TCC_OPTION_HELP, 0 },
11029 { "?", TCC_OPTION_HELP, 0 },
11030 { "I", TCC_OPTION_I, TCC_OPTION_HAS_ARG },
11031 { "D", TCC_OPTION_D, TCC_OPTION_HAS_ARG },
11032 { "U", TCC_OPTION_U, TCC_OPTION_HAS_ARG },
11033 { "L", TCC_OPTION_L, TCC_OPTION_HAS_ARG },
11034 { "B", TCC_OPTION_B, TCC_OPTION_HAS_ARG },
11035 { "l", TCC_OPTION_l, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
11036 { "bench", TCC_OPTION_bench, 0 },
11037 { "bt", TCC_OPTION_bt, TCC_OPTION_HAS_ARG },
11038 #ifdef CONFIG_TCC_BCHECK
11039 { "b", TCC_OPTION_b, 0 },
11040 #endif
11041 { "g", TCC_OPTION_g, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
11042 { "c", TCC_OPTION_c, 0 },
11043 { "static", TCC_OPTION_static, 0 },
11044 { "shared", TCC_OPTION_shared, 0 },
11045 { "soname", TCC_OPTION_soname, TCC_OPTION_HAS_ARG },
11046 { "o", TCC_OPTION_o, TCC_OPTION_HAS_ARG },
11047 { "run", TCC_OPTION_run, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
11048 { "rdynamic", TCC_OPTION_rdynamic, 0 },
11049 { "r", TCC_OPTION_r, 0 },
11050 { "Wl,", TCC_OPTION_Wl, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
11051 { "W", TCC_OPTION_W, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
11052 { "O", TCC_OPTION_O, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
11053 { "m", TCC_OPTION_m, TCC_OPTION_HAS_ARG },
11054 { "f", TCC_OPTION_f, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
11055 { "nostdinc", TCC_OPTION_nostdinc, 0 },
11056 { "nostdlib", TCC_OPTION_nostdlib, 0 },
11057 { "print-search-dirs", TCC_OPTION_print_search_dirs, 0 },
11058 { "v", TCC_OPTION_v, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
11059 { "w", TCC_OPTION_w, 0 },
11060 { "pipe", TCC_OPTION_pipe, 0},
11061 { "E", TCC_OPTION_E, 0},
11062 { NULL },
11063 };
11064
11065 /* convert 'str' into an array of space separated strings */
11066 static int expand_args(char ***pargv, const char *str)
11067 {
11068 const char *s1;
11069 char **argv, *arg;
11070 int argc, len;
11071
11072 argc = 0;
11073 argv = NULL;
11074 for(;;) {
11075 while (is_space(*str))
11076 str++;
11077 if (*str == '\0')
11078 break;
11079 s1 = str;
11080 while (*str != '\0' && !is_space(*str))
11081 str++;
11082 len = str - s1;
11083 arg = tcc_malloc(len + 1);
11084 memcpy(arg, s1, len);
11085 arg[len] = '\0';
11086 dynarray_add((void ***)&argv, &argc, arg);
11087 }
11088 *pargv = argv;
11089 return argc;
11090 }
11091
11092 static char **files;
11093 static int nb_files, nb_libraries;
11094 static int multiple_files;
11095 static int print_search_dirs;
11096 static int output_type;
11097 static int reloc_output;
11098 static const char *outfile;
11099
11100 int parse_args(TCCState *s, int argc, char **argv)
11101 {
11102 int optind;
11103 const TCCOption *popt;
11104 const char *optarg, *p1, *r1;
11105 char *r;
11106
11107 optind = 0;
11108 while (optind < argc) {
11109
11110 r = argv[optind++];
11111 if (r[0] != '-' || r[1] == '\0') {
11112 /* add a new file */
11113 dynarray_add((void ***)&files, &nb_files, r);
11114 if (!multiple_files) {
11115 optind--;
11116 /* argv[0] will be this file */
11117 break;
11118 }
11119 } else {
11120 /* find option in table (match only the first chars */
11121 popt = tcc_options;
11122 for(;;) {
11123 p1 = popt->name;
11124 if (p1 == NULL)
11125 error("invalid option -- '%s'", r);
11126 r1 = r + 1;
11127 for(;;) {
11128 if (*p1 == '\0')
11129 goto option_found;
11130 if (*r1 != *p1)
11131 break;
11132 p1++;
11133 r1++;
11134 }
11135 popt++;
11136 }
11137 option_found:
11138 if (popt->flags & TCC_OPTION_HAS_ARG) {
11139 if (*r1 != '\0' || (popt->flags & TCC_OPTION_NOSEP)) {
11140 optarg = r1;
11141 } else {
11142 if (optind >= argc)
11143 error("argument to '%s' is missing", r);
11144 optarg = argv[optind++];
11145 }
11146 } else {
11147 if (*r1 != '\0')
11148 return 0;
11149 optarg = NULL;
11150 }
11151
11152 switch(popt->index) {
11153 case TCC_OPTION_HELP:
11154 return 0;
11155
11156 case TCC_OPTION_I:
11157 if (tcc_add_include_path(s, optarg) < 0)
11158 error("too many include paths");
11159 break;
11160 case TCC_OPTION_D:
11161 {
11162 char *sym, *value;
11163 sym = (char *)optarg;
11164 value = strchr(sym, '=');
11165 if (value) {
11166 *value = '\0';
11167 value++;
11168 }
11169 tcc_define_symbol(s, sym, value);
11170 }
11171 break;
11172 case TCC_OPTION_U:
11173 tcc_undefine_symbol(s, optarg);
11174 break;
11175 case TCC_OPTION_L:
11176 tcc_add_library_path(s, optarg);
11177 break;
11178 case TCC_OPTION_B:
11179 /* set tcc utilities path (mainly for tcc development) */
11180 tcc_lib_path = optarg;
11181 break;
11182 case TCC_OPTION_l:
11183 dynarray_add((void ***)&files, &nb_files, r);
11184 nb_libraries++;
11185 break;
11186 case TCC_OPTION_bench:
11187 do_bench = 1;
11188 break;
11189 case TCC_OPTION_bt:
11190 num_callers = atoi(optarg);
11191 break;
11192 #ifdef CONFIG_TCC_BCHECK
11193 case TCC_OPTION_b:
11194 do_bounds_check = 1;
11195 do_debug = 1;
11196 break;
11197 #endif
11198 case TCC_OPTION_g:
11199 do_debug = 1;
11200 break;
11201 case TCC_OPTION_c:
11202 multiple_files = 1;
11203 output_type = TCC_OUTPUT_OBJ;
11204 break;
11205 case TCC_OPTION_static:
11206 s->static_link = 1;
11207 break;
11208 case TCC_OPTION_shared:
11209 output_type = TCC_OUTPUT_DLL;
11210 break;
11211 case TCC_OPTION_soname:
11212 s->soname = optarg;
11213 break;
11214 case TCC_OPTION_o:
11215 multiple_files = 1;
11216 outfile = optarg;
11217 break;
11218 case TCC_OPTION_r:
11219 /* generate a .o merging several output files */
11220 reloc_output = 1;
11221 output_type = TCC_OUTPUT_OBJ;
11222 break;
11223 case TCC_OPTION_nostdinc:
11224 s->nostdinc = 1;
11225 break;
11226 case TCC_OPTION_nostdlib:
11227 s->nostdlib = 1;
11228 break;
11229 case TCC_OPTION_print_search_dirs:
11230 print_search_dirs = 1;
11231 break;
11232 case TCC_OPTION_run:
11233 {
11234 int argc1;
11235 char **argv1;
11236 argc1 = expand_args(&argv1, optarg);
11237 if (argc1 > 0) {
11238 parse_args(s, argc1, argv1);
11239 }
11240 multiple_files = 0;
11241 output_type = TCC_OUTPUT_MEMORY;
11242 }
11243 break;
11244 case TCC_OPTION_v:
11245 do {
11246 if (0 == verbose++)
11247 printf("tcc version %s\n", TCC_VERSION);
11248 } while (*optarg++ == 'v');
11249 break;
11250 case TCC_OPTION_f:
11251 if (tcc_set_flag(s, optarg, 1) < 0 && s->warn_unsupported)
11252 goto unsupported_option;
11253 break;
11254 case TCC_OPTION_W:
11255 if (tcc_set_warning(s, optarg, 1) < 0 &&
11256 s->warn_unsupported)
11257 goto unsupported_option;
11258 break;
11259 case TCC_OPTION_w:
11260 s->warn_none = 1;
11261 break;
11262 case TCC_OPTION_rdynamic:
11263 s->rdynamic = 1;
11264 break;
11265 case TCC_OPTION_Wl:
11266 {
11267 const char *p;
11268 if (strstart(optarg, "-Ttext,", &p)) {
11269 s->text_addr = strtoul(p, NULL, 16);
11270 s->has_text_addr = 1;
11271 } else if (strstart(optarg, "--oformat,", &p)) {
11272 if (strstart(p, "elf32-", NULL)) {
11273 s->output_format = TCC_OUTPUT_FORMAT_ELF;
11274 } else if (!strcmp(p, "binary")) {
11275 s->output_format = TCC_OUTPUT_FORMAT_BINARY;
11276 } else
11277 #ifdef TCC_TARGET_COFF
11278 if (!strcmp(p, "coff")) {
11279 s->output_format = TCC_OUTPUT_FORMAT_COFF;
11280 } else
11281 #endif
11282 {
11283 error("target %s not found", p);
11284 }
11285 } else {
11286 error("unsupported linker option '%s'", optarg);
11287 }
11288 }
11289 break;
11290 case TCC_OPTION_E:
11291 output_type = TCC_OUTPUT_PREPROCESS;
11292 break;
11293 default:
11294 if (s->warn_unsupported) {
11295 unsupported_option:
11296 warning("unsupported option '%s'", r);
11297 }
11298 break;
11299 }
11300 }
11301 }
11302 return optind + 1;
11303 }
11304
11305 int main(int argc, char **argv)
11306 {
11307 int i;
11308 TCCState *s;
11309 int nb_objfiles, ret, optind;
11310 char objfilename[1024];
11311 int64_t start_time = 0;
11312
11313 #ifdef _WIN32
11314 tcc_lib_path = w32_tcc_lib_path();
11315 #endif
11316
11317 s = tcc_new();
11318 output_type = TCC_OUTPUT_EXE;
11319 outfile = NULL;
11320 multiple_files = 1;
11321 files = NULL;
11322 nb_files = 0;
11323 nb_libraries = 0;
11324 reloc_output = 0;
11325 print_search_dirs = 0;
11326 ret = 0;
11327
11328 optind = parse_args(s, argc - 1, argv + 1);
11329 if (print_search_dirs) {
11330 /* enough for Linux kernel */
11331 printf("install: %s/\n", tcc_lib_path);
11332 return 0;
11333 }
11334 if (optind == 0 || nb_files == 0) {
11335 if (optind && verbose)
11336 return 0;
11337 help();
11338 return 1;
11339 }
11340
11341 nb_objfiles = nb_files - nb_libraries;
11342
11343 /* if outfile provided without other options, we output an
11344 executable */
11345 if (outfile && output_type == TCC_OUTPUT_MEMORY)
11346 output_type = TCC_OUTPUT_EXE;
11347
11348 /* check -c consistency : only single file handled. XXX: checks file type */
11349 if (output_type == TCC_OUTPUT_OBJ && !reloc_output) {
11350 /* accepts only a single input file */
11351 if (nb_objfiles != 1)
11352 error("cannot specify multiple files with -c");
11353 if (nb_libraries != 0)
11354 error("cannot specify libraries with -c");
11355 }
11356
11357
11358 if (output_type == TCC_OUTPUT_PREPROCESS) {
11359 if (!outfile) {
11360 s->outfile = stdout;
11361 } else {
11362 s->outfile = fopen(outfile, "w");
11363 if (!s->outfile)
11364 error("could not open '%s", outfile);
11365 }
11366 } else if (output_type != TCC_OUTPUT_MEMORY) {
11367 if (!outfile) {
11368 /* compute default outfile name */
11369 char *ext;
11370 const char *name =
11371 strcmp(files[0], "-") == 0 ? "a" : tcc_basename(files[0]);
11372 pstrcpy(objfilename, sizeof(objfilename), name);
11373 ext = tcc_fileextension(objfilename);
11374 #ifdef TCC_TARGET_PE
11375 if (output_type == TCC_OUTPUT_DLL)
11376 strcpy(ext, ".dll");
11377 else
11378 if (output_type == TCC_OUTPUT_EXE)
11379 strcpy(ext, ".exe");
11380 else
11381 #endif
11382 if (output_type == TCC_OUTPUT_OBJ && !reloc_output && *ext)
11383 strcpy(ext, ".o");
11384 else
11385 pstrcpy(objfilename, sizeof(objfilename), "a.out");
11386 outfile = objfilename;
11387 }
11388 }
11389
11390 if (do_bench) {
11391 start_time = getclock_us();
11392 }
11393
11394 tcc_set_output_type(s, output_type);
11395
11396 /* compile or add each files or library */
11397 for(i = 0; i < nb_files && ret == 0; i++) {
11398 const char *filename;
11399
11400 filename = files[i];
11401 if (output_type == TCC_OUTPUT_PREPROCESS) {
11402 if (tcc_add_file_internal(s, filename,
11403 AFF_PRINT_ERROR | AFF_PREPROCESS) < 0)
11404 ret = 1;
11405 } else if (filename[0] == '-' && filename[1]) {
11406 if (tcc_add_library(s, filename + 2) < 0)
11407 error("cannot find %s", filename);
11408 } else {
11409 if (1 == verbose)
11410 printf("-> %s\n", filename);
11411 if (tcc_add_file(s, filename) < 0)
11412 ret = 1;
11413 }
11414 }
11415
11416 /* free all files */
11417 tcc_free(files);
11418
11419 if (ret)
11420 goto the_end;
11421
11422 if (do_bench) {
11423 double total_time;
11424 total_time = (double)(getclock_us() - start_time) / 1000000.0;
11425 if (total_time < 0.001)
11426 total_time = 0.001;
11427 if (total_bytes < 1)
11428 total_bytes = 1;
11429 printf("%d idents, %d lines, %d bytes, %0.3f s, %d lines/s, %0.1f MB/s\n",
11430 tok_ident - TOK_IDENT, total_lines, total_bytes,
11431 total_time, (int)(total_lines / total_time),
11432 total_bytes / total_time / 1000000.0);
11433 }
11434
11435 if (s->output_type == TCC_OUTPUT_PREPROCESS) {
11436 if (outfile)
11437 fclose(s->outfile);
11438 } else if (s->output_type == TCC_OUTPUT_MEMORY) {
11439 ret = tcc_run(s, argc - optind, argv + optind);
11440 } else
11441 ret = tcc_output_file(s, outfile) ? 1 : 0;
11442 the_end:
11443 /* XXX: cannot do it with bound checking because of the malloc hooks */
11444 if (!do_bounds_check)
11445 tcc_delete(s);
11446
11447 #ifdef MEM_DEBUG
11448 if (do_bench) {
11449 printf("memory: %d bytes, max = %d bytes\n", mem_cur_size, mem_max_size);
11450 }
11451 #endif
11452 return ret;
11453 }
11454
11455 #endif
kirr's tinycc tree