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