tcc.c

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