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