diff options
Diffstat (limited to 'utils/benchmark/inputs/tccgen.c.pp')
| -rw-r--r-- | utils/benchmark/inputs/tccgen.c.pp | 9993 |
1 files changed, 9993 insertions, 0 deletions
diff --git a/utils/benchmark/inputs/tccgen.c.pp b/utils/benchmark/inputs/tccgen.c.pp new file mode 100644 index 0000000..b007f19 --- /dev/null +++ b/utils/benchmark/inputs/tccgen.c.pp @@ -0,0 +1,9993 @@ +# 1 "tccgen.c" +# 1 "<built-in>" +# 1 "<command-line>" +# 1 "tccgen.c" +# 21 "tccgen.c" +# 1 "tcc.h" 1 +# 25 "tcc.h" +# 1 "config.h" 1 +# 26 "tcc.h" 2 + +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/stdlib.h" 1 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_defines.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/stdlib.h" 2 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_typedefs.h" 1 + + + +typedef int size_t; +typedef int __builtin_va_list; +typedef int __gnuc_va_list; +typedef int va_list; +typedef int __int8_t; +typedef int __uint8_t; +typedef int __int16_t; +typedef int __uint16_t; +typedef int __int_least16_t; +typedef int __uint_least16_t; +typedef int __int32_t; +typedef int __uint32_t; +typedef int __int64_t; +typedef int __uint64_t; +typedef int __int_least32_t; +typedef int __uint_least32_t; +typedef int __s8; +typedef int __u8; +typedef int __s16; +typedef int __u16; +typedef int __s32; +typedef int __u32; +typedef int __s64; +typedef int __u64; +typedef int _LOCK_T; +typedef int _LOCK_RECURSIVE_T; +typedef int _off_t; +typedef int __dev_t; +typedef int __uid_t; +typedef int __gid_t; +typedef int _off64_t; +typedef int _fpos_t; +typedef int _ssize_t; +typedef int wint_t; +typedef int _mbstate_t; +typedef int _flock_t; +typedef int _iconv_t; +typedef int __ULong; +typedef int __FILE; +typedef int ptrdiff_t; +typedef int wchar_t; +typedef int __off_t; +typedef int __pid_t; +typedef int __loff_t; +typedef int u_char; +typedef int u_short; +typedef int u_int; +typedef int u_long; +typedef int ushort; +typedef int uint; +typedef int clock_t; +typedef int time_t; +typedef int daddr_t; +typedef int caddr_t; +typedef int ino_t; +typedef int off_t; +typedef int dev_t; +typedef int uid_t; +typedef int gid_t; +typedef int pid_t; +typedef int key_t; +typedef int ssize_t; +typedef int mode_t; +typedef int nlink_t; +typedef int fd_mask; +typedef int _types_fd_set; +typedef int clockid_t; +typedef int timer_t; +typedef int useconds_t; +typedef int suseconds_t; +typedef int FILE; +typedef int fpos_t; +typedef int cookie_read_function_t; +typedef int cookie_write_function_t; +typedef int cookie_seek_function_t; +typedef int cookie_close_function_t; +typedef int cookie_io_functions_t; +typedef int div_t; +typedef int ldiv_t; +typedef int lldiv_t; +typedef int sigset_t; +typedef int __sigset_t; +typedef int _sig_func_ptr; +typedef int sig_atomic_t; +typedef int __tzrule_type; +typedef int __tzinfo_type; +typedef int mbstate_t; +typedef int sem_t; +typedef int pthread_t; +typedef int pthread_attr_t; +typedef int pthread_mutex_t; +typedef int pthread_mutexattr_t; +typedef int pthread_cond_t; +typedef int pthread_condattr_t; +typedef int pthread_key_t; +typedef int pthread_once_t; +typedef int pthread_rwlock_t; +typedef int pthread_rwlockattr_t; +typedef int pthread_spinlock_t; +typedef int pthread_barrier_t; +typedef int pthread_barrierattr_t; +typedef int jmp_buf; +typedef int rlim_t; +typedef int sa_family_t; +typedef int sigjmp_buf; +typedef int stack_t; +typedef int siginfo_t; +typedef int z_stream; + + +typedef int int8_t; +typedef int uint8_t; +typedef int int16_t; +typedef int uint16_t; +typedef int int32_t; +typedef int uint32_t; +typedef int int64_t; +typedef int uint64_t; + + +typedef int int_least8_t; +typedef int uint_least8_t; +typedef int int_least16_t; +typedef int uint_least16_t; +typedef int int_least32_t; +typedef int uint_least32_t; +typedef int int_least64_t; +typedef int uint_least64_t; + + +typedef int int_fast8_t; +typedef int uint_fast8_t; +typedef int int_fast16_t; +typedef int uint_fast16_t; +typedef int int_fast32_t; +typedef int uint_fast32_t; +typedef int int_fast64_t; +typedef int uint_fast64_t; + + +typedef int intptr_t; +typedef int uintptr_t; + + +typedef int intmax_t; +typedef int uintmax_t; + + +typedef _Bool bool; + + +typedef void* MirEGLNativeWindowType; +typedef void* MirEGLNativeDisplayType; +typedef struct MirConnection MirConnection; +typedef struct MirSurface MirSurface; +typedef struct MirSurfaceSpec MirSurfaceSpec; +typedef struct MirScreencast MirScreencast; +typedef struct MirPromptSession MirPromptSession; +typedef struct MirBufferStream MirBufferStream; +typedef struct MirPersistentId MirPersistentId; +typedef struct MirBlob MirBlob; +typedef struct MirDisplayConfig MirDisplayConfig; + + +typedef struct xcb_connection_t xcb_connection_t; +typedef uint32_t xcb_window_t; +typedef uint32_t xcb_visualid_t; +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/stdlib.h" 2 +# 28 "tcc.h" 2 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/stdio.h" 1 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_defines.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/stdio.h" 2 +# 29 "tcc.h" 2 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/stdarg.h" 1 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_defines.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/stdarg.h" 2 +# 30 "tcc.h" 2 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/string.h" 1 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_defines.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/string.h" 2 +# 31 "tcc.h" 2 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/errno.h" 1 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_defines.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/errno.h" 2 +# 32 "tcc.h" 2 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/math.h" 1 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_defines.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/math.h" 2 +# 33 "tcc.h" 2 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/fcntl.h" 1 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_defines.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/fcntl.h" 2 +# 34 "tcc.h" 2 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/setjmp.h" 1 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_defines.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/setjmp.h" 2 +# 35 "tcc.h" 2 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/time.h" 1 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_defines.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/time.h" 2 +# 36 "tcc.h" 2 + + +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/unistd.h" 1 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_defines.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/unistd.h" 2 +# 39 "tcc.h" 2 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/sys/time.h" 1 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_defines.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/sys/time.h" 2 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_typedefs.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/sys/time.h" 2 +# 40 "tcc.h" 2 + +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/dlfcn.h" 1 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_defines.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/dlfcn.h" 2 +# 42 "tcc.h" 2 + + +extern float strtof (const char *__nptr, char **__endptr); +extern long double strtold (const char *__nptr, char **__endptr); +# 283 "tcc.h" +# 1 "libtcc.h" 1 +# 12 "libtcc.h" +struct TCCState; + +typedef struct TCCState TCCState; + + + TCCState *tcc_new(void); + + + void tcc_delete(TCCState *s); + + + void tcc_set_lib_path(TCCState *s, const char *path); + + + void tcc_set_error_func(TCCState *s, void *error_opaque, + void (*error_func)(void *opaque, const char *msg)); + + + void tcc_set_options(TCCState *s, const char *str); + + + + + + int tcc_add_include_path(TCCState *s, const char *pathname); + + + int tcc_add_sysinclude_path(TCCState *s, const char *pathname); + + + void tcc_define_symbol(TCCState *s, const char *sym, const char *value); + + + void tcc_undefine_symbol(TCCState *s, const char *sym); + + + + + + int tcc_add_file(TCCState *s, const char *filename); + + + int tcc_compile_string(TCCState *s, const char *buf); + + + + + + int tcc_set_output_type(TCCState *s, int output_type); + + + + + + + + int tcc_add_library_path(TCCState *s, const char *pathname); + + + int tcc_add_library(TCCState *s, const char *libraryname); + + + int tcc_add_symbol(TCCState *s, const char *name, const void *val); + + + + int tcc_output_file(TCCState *s, const char *filename); + + + + int tcc_run(TCCState *s, int argc, char **argv); + + + int tcc_relocate(TCCState *s1, void *ptr); +# 94 "libtcc.h" + void *tcc_get_symbol(TCCState *s, const char *name); +# 284 "tcc.h" 2 +# 1 "elf.h" 1 +# 23 "elf.h" +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/inttypes.h" 1 +# 1 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/_fake_defines.h" 1 +# 2 "/usr/local/google/home/eliben/eli/pycparser/utils/fake_libc_include/inttypes.h" 2 +# 24 "elf.h" 2 +# 41 "elf.h" +typedef uint16_t Elf32_Half; +typedef uint16_t Elf64_Half; + + +typedef uint32_t Elf32_Word; +typedef int32_t Elf32_Sword; +typedef uint32_t Elf64_Word; +typedef int32_t Elf64_Sword; + + +typedef uint64_t Elf32_Xword; +typedef int64_t Elf32_Sxword; +typedef uint64_t Elf64_Xword; +typedef int64_t Elf64_Sxword; + + +typedef uint32_t Elf32_Addr; +typedef uint64_t Elf64_Addr; + + +typedef uint32_t Elf32_Off; +typedef uint64_t Elf64_Off; + + +typedef uint16_t Elf32_Section; +typedef uint16_t Elf64_Section; + + +typedef Elf32_Half Elf32_Versym; +typedef Elf64_Half Elf64_Versym; + + + + + + +typedef struct +{ + unsigned char e_ident[(16)]; + Elf32_Half e_type; + Elf32_Half e_machine; + Elf32_Word e_version; + Elf32_Addr e_entry; + Elf32_Off e_phoff; + Elf32_Off e_shoff; + Elf32_Word e_flags; + Elf32_Half e_ehsize; + Elf32_Half e_phentsize; + Elf32_Half e_phnum; + Elf32_Half e_shentsize; + Elf32_Half e_shnum; + Elf32_Half e_shstrndx; +} Elf32_Ehdr; + +typedef struct +{ + unsigned char e_ident[(16)]; + Elf64_Half e_type; + Elf64_Half e_machine; + Elf64_Word e_version; + Elf64_Addr e_entry; + Elf64_Off e_phoff; + Elf64_Off e_shoff; + Elf64_Word e_flags; + Elf64_Half e_ehsize; + Elf64_Half e_phentsize; + Elf64_Half e_phnum; + Elf64_Half e_shentsize; + Elf64_Half e_shnum; + Elf64_Half e_shstrndx; +} Elf64_Ehdr; +# 282 "elf.h" +typedef struct +{ + Elf32_Word sh_name; + Elf32_Word sh_type; + Elf32_Word sh_flags; + Elf32_Addr sh_addr; + Elf32_Off sh_offset; + Elf32_Word sh_size; + Elf32_Word sh_link; + Elf32_Word sh_info; + Elf32_Word sh_addralign; + Elf32_Word sh_entsize; +} Elf32_Shdr; + +typedef struct +{ + Elf64_Word sh_name; + Elf64_Word sh_type; + Elf64_Xword sh_flags; + Elf64_Addr sh_addr; + Elf64_Off sh_offset; + Elf64_Xword sh_size; + Elf64_Word sh_link; + Elf64_Word sh_info; + Elf64_Xword sh_addralign; + Elf64_Xword sh_entsize; +} Elf64_Shdr; +# 392 "elf.h" +typedef struct +{ + Elf32_Word st_name; + Elf32_Addr st_value; + Elf32_Word st_size; + unsigned char st_info; + unsigned char st_other; + Elf32_Section st_shndx; +} Elf32_Sym; + +typedef struct +{ + Elf64_Word st_name; + unsigned char st_info; + unsigned char st_other; + Elf64_Section st_shndx; + Elf64_Addr st_value; + Elf64_Xword st_size; +} Elf64_Sym; + + + + +typedef struct +{ + Elf32_Half si_boundto; + Elf32_Half si_flags; +} Elf32_Syminfo; + +typedef struct +{ + Elf64_Half si_boundto; + Elf64_Half si_flags; +} Elf64_Syminfo; +# 507 "elf.h" +typedef struct +{ + Elf32_Addr r_offset; + Elf32_Word r_info; +} Elf32_Rel; + + + + + + +typedef struct +{ + Elf64_Addr r_offset; + Elf64_Xword r_info; +} Elf64_Rel; + + + +typedef struct +{ + Elf32_Addr r_offset; + Elf32_Word r_info; + Elf32_Sword r_addend; +} Elf32_Rela; + +typedef struct +{ + Elf64_Addr r_offset; + Elf64_Xword r_info; + Elf64_Sxword r_addend; +} Elf64_Rela; +# 552 "elf.h" +typedef struct +{ + Elf32_Word p_type; + Elf32_Off p_offset; + Elf32_Addr p_vaddr; + Elf32_Addr p_paddr; + Elf32_Word p_filesz; + Elf32_Word p_memsz; + Elf32_Word p_flags; + Elf32_Word p_align; +} Elf32_Phdr; + +typedef struct +{ + Elf64_Word p_type; + Elf64_Word p_flags; + Elf64_Off p_offset; + Elf64_Addr p_vaddr; + Elf64_Addr p_paddr; + Elf64_Xword p_filesz; + Elf64_Xword p_memsz; + Elf64_Xword p_align; +} Elf64_Phdr; +# 658 "elf.h" +typedef struct +{ + Elf32_Sword d_tag; + union + { + Elf32_Word d_val; + Elf32_Addr d_ptr; + } d_un; +} Elf32_Dyn; + +typedef struct +{ + Elf64_Sxword d_tag; + union + { + Elf64_Xword d_val; + Elf64_Addr d_ptr; + } d_un; +} Elf64_Dyn; +# 834 "elf.h" +typedef struct +{ + Elf32_Half vd_version; + Elf32_Half vd_flags; + Elf32_Half vd_ndx; + Elf32_Half vd_cnt; + Elf32_Word vd_hash; + Elf32_Word vd_aux; + Elf32_Word vd_next; + +} Elf32_Verdef; + +typedef struct +{ + Elf64_Half vd_version; + Elf64_Half vd_flags; + Elf64_Half vd_ndx; + Elf64_Half vd_cnt; + Elf64_Word vd_hash; + Elf64_Word vd_aux; + Elf64_Word vd_next; + +} Elf64_Verdef; +# 876 "elf.h" +typedef struct +{ + Elf32_Word vda_name; + Elf32_Word vda_next; + +} Elf32_Verdaux; + +typedef struct +{ + Elf64_Word vda_name; + Elf64_Word vda_next; + +} Elf64_Verdaux; + + + + +typedef struct +{ + Elf32_Half vn_version; + Elf32_Half vn_cnt; + Elf32_Word vn_file; + + Elf32_Word vn_aux; + Elf32_Word vn_next; + +} Elf32_Verneed; + +typedef struct +{ + Elf64_Half vn_version; + Elf64_Half vn_cnt; + Elf64_Word vn_file; + + Elf64_Word vn_aux; + Elf64_Word vn_next; + +} Elf64_Verneed; +# 923 "elf.h" +typedef struct +{ + Elf32_Word vna_hash; + Elf32_Half vna_flags; + Elf32_Half vna_other; + Elf32_Word vna_name; + Elf32_Word vna_next; + +} Elf32_Vernaux; + +typedef struct +{ + Elf64_Word vna_hash; + Elf64_Half vna_flags; + Elf64_Half vna_other; + Elf64_Word vna_name; + Elf64_Word vna_next; + +} Elf64_Vernaux; +# 957 "elf.h" +typedef struct +{ + uint32_t a_type; + union + { + uint32_t a_val; + + + + } a_un; +} Elf32_auxv_t; + +typedef struct +{ + uint64_t a_type; + union + { + uint64_t a_val; + + + + } a_un; +} Elf64_auxv_t; +# 1041 "elf.h" +typedef struct +{ + Elf32_Word n_namesz; + Elf32_Word n_descsz; + Elf32_Word n_type; +} Elf32_Nhdr; + +typedef struct +{ + Elf64_Word n_namesz; + Elf64_Word n_descsz; + Elf64_Word n_type; +} Elf64_Nhdr; +# 1105 "elf.h" +typedef struct +{ + Elf32_Xword m_value; + Elf32_Word m_info; + Elf32_Word m_poffset; + Elf32_Half m_repeat; + Elf32_Half m_stride; +} Elf32_Move; + +typedef struct +{ + Elf64_Xword m_value; + Elf64_Xword m_info; + Elf64_Xword m_poffset; + Elf64_Half m_repeat; + Elf64_Half m_stride; +} Elf64_Move; +# 1489 "elf.h" +typedef union +{ + struct + { + Elf32_Word gt_current_g_value; + Elf32_Word gt_unused; + } gt_header; + struct + { + Elf32_Word gt_g_value; + Elf32_Word gt_bytes; + } gt_entry; +} Elf32_gptab; + + + +typedef struct +{ + Elf32_Word ri_gprmask; + Elf32_Word ri_cprmask[4]; + Elf32_Sword ri_gp_value; +} Elf32_RegInfo; + + + +typedef struct +{ + unsigned char kind; + + unsigned char size; + Elf32_Section section; + + Elf32_Word info; +} Elf_Options; +# 1565 "elf.h" +typedef struct +{ + Elf32_Word hwp_flags1; + Elf32_Word hwp_flags2; +} Elf_Options_Hw; +# 1726 "elf.h" +typedef struct +{ + Elf32_Word l_name; + Elf32_Word l_time_stamp; + Elf32_Word l_checksum; + Elf32_Word l_version; + Elf32_Word l_flags; +} Elf32_Lib; + +typedef struct +{ + Elf64_Word l_name; + Elf64_Word l_time_stamp; + Elf64_Word l_checksum; + Elf64_Word l_version; + Elf64_Word l_flags; +} Elf64_Lib; +# 1757 "elf.h" +typedef Elf32_Addr Elf32_Conflict; +# 285 "tcc.h" 2 +# 1 "stab.h" 1 +# 9 "stab.h" +enum __stab_debug_code +{ +# 1 "stab.def" 1 +# 24 "stab.def" +N_GSYM=0x20, + + + +N_FNAME=0x22, + + + + +N_FUN=0x24, + + + +N_STSYM=0x26, + + +N_LCSYM=0x28, + + + +N_MAIN=0x2a, + + + +N_PC=0x30, + + +N_NSYMS=0x32, + + +N_NOMAP=0x34, + + + +N_OBJ=0x38, + + + + +N_OPT=0x3c, + + +N_RSYM=0x40, + + +N_M2C=0x42, + + + +N_SLINE=0x44, + + +N_DSLINE=0x46, + + +N_BSLINE=0x48, + + + + +N_BROWS=0x48, + + + + + +N_DEFD=0x4a, + + + + +N_EHDECL=0x50, + +N_MOD2=0x50, + + + + + + +N_CATCH=0x54, + + +N_SSYM=0x60, + + + +N_SO=0x64, + + + +N_LSYM=0x80, + + + + +N_BINCL=0x82, + + + +N_SOL=0x84, + + + +N_PSYM=0xa0, + + + + + +N_EINCL=0xa2, + + +N_ENTRY=0xa4, + + + + + +N_LBRAC=0xc0, + + + + + +N_EXCL=0xc2, + + +N_SCOPE=0xc4, + + + +N_RBRAC=0xe0, + + +N_BCOMM=0xe2, + + + +N_ECOMM=0xe4, + + + +N_ECOML=0xe8, + + + + +N_NBTEXT=0xF0, +N_NBDATA=0xF2, +N_NBBSS=0xF4, +N_NBSTS=0xF6, +N_NBLCS=0xF8, + + + +N_LENG=0xfe, +# 12 "stab.h" 2 +LAST_UNUSED_STAB_CODE +}; +# 286 "tcc.h" 2 +# 320 "tcc.h" +# 1 "x86_64-gen.c" 1 +# 57 "x86_64-gen.c" +enum { + TREG_RAX = 0, + TREG_RCX = 1, + TREG_RDX = 2, + TREG_RSP = 4, + TREG_RSI = 6, + TREG_RDI = 7, + + TREG_R8 = 8, + TREG_R9 = 9, + TREG_R10 = 10, + TREG_R11 = 11, + + TREG_XMM0 = 16, + TREG_XMM1 = 17, + TREG_XMM2 = 18, + TREG_XMM3 = 19, + TREG_XMM4 = 20, + TREG_XMM5 = 21, + TREG_XMM6 = 22, + TREG_XMM7 = 23, + + TREG_ST0 = 24, + + TREG_MEM = 0x20 +}; +# 321 "tcc.h" 2 +# 1 "x86_64-link.c" 1 +# 322 "tcc.h" 2 +# 381 "tcc.h" +typedef struct TokenSym { + struct TokenSym *hash_next; + struct Sym *sym_define; + struct Sym *sym_label; + struct Sym *sym_struct; + struct Sym *sym_identifier; + int tok; + int len; + char str[1]; +} TokenSym; + + + + +typedef int nwchar_t; + + +typedef struct CString { + int size; + void *data; + int size_allocated; +} CString; + + +typedef struct CType { + int t; + struct Sym *ref; +} CType; + + +typedef union CValue { + long double ld; + double d; + float f; + uint64_t i; + struct { + int size; + const void *data; + } str; + int tab[16/4]; +} CValue; + + +typedef struct SValue { + CType type; + unsigned short r; + unsigned short r2; + + CValue c; + struct Sym *sym; + +} SValue; + + +struct SymAttr { + unsigned short + aligned : 5, + packed : 1, + weak : 1, + visibility : 2, + dllexport : 1, + dllimport : 1, + unused : 5; +}; + + +struct FuncAttr { + unsigned + func_call : 3, + func_type : 2, + func_args : 8; +}; + + +typedef struct AttributeDef { + struct SymAttr a; + struct FuncAttr f; + struct Section *section; + int alias_target; + int asm_label; + char attr_mode; +} AttributeDef; + + +typedef struct Sym { + int v; + unsigned short r; + struct SymAttr a; + union { + struct { + int c; + union { + int sym_scope; + int jnext; + struct FuncAttr f; + int auxtype; + }; + }; + long long enum_val; + int *d; + }; + CType type; + union { + struct Sym *next; + int asm_label; + }; + struct Sym *prev; + struct Sym *prev_tok; +} Sym; + + +typedef struct Section { + unsigned long data_offset; + unsigned char *data; + unsigned long data_allocated; + int sh_name; + int sh_num; + int sh_type; + int sh_flags; + int sh_info; + int sh_addralign; + int sh_entsize; + unsigned long sh_size; + Elf64_Addr sh_addr; + unsigned long sh_offset; + int nb_hashed_syms; + struct Section *link; + struct Section *reloc; + struct Section *hash; + struct Section *prev; + char name[1]; +} Section; + +typedef struct DLLReference { + int level; + void *handle; + char name[1]; +} DLLReference; +# 554 "tcc.h" +typedef struct BufferedFile { + uint8_t *buf_ptr; + uint8_t *buf_end; + int fd; + struct BufferedFile *prev; + int line_num; + int line_ref; + int ifndef_macro; + int ifndef_macro_saved; + int *ifdef_stack_ptr; + int include_next_index; + char filename[1024]; + char *true_filename; + unsigned char unget[4]; + unsigned char buffer[1]; +} BufferedFile; + + + + + +typedef struct TokenString { + int *str; + int len; + int lastlen; + int allocated_len; + int last_line_num; + int save_line_num; + + struct TokenString *prev; + const int *prev_ptr; + char alloc; +} TokenString; + + +typedef struct InlineFunc { + TokenString *func_str; + Sym *sym; + char filename[1]; +} InlineFunc; + + + +typedef struct CachedInclude { + int ifndef_macro; + int once; + int hash_next; + char filename[1]; +} CachedInclude; + + + + +typedef struct ExprValue { + uint64_t v; + Sym *sym; + int pcrel; +} ExprValue; + + +typedef struct ASMOperand { + int id; + char *constraint; + char asm_str[16]; + SValue *vt; + int ref_index; + int input_index; + int priority; + int reg; + int is_llong; + int is_memory; + int is_rw; +} ASMOperand; + + + +struct sym_attr { + unsigned got_offset; + unsigned plt_offset; + int plt_sym; + int dyn_index; + + + +}; + +struct TCCState { + + int verbose; + int nostdinc; + int nostdlib; + int nocommon; + int static_link; + int rdynamic; + int symbolic; + int alacarte_link; + + char *tcc_lib_path; + char *soname; + char *rpath; + int enable_new_dtags; + + + int output_type; + + int output_format; + + + int char_is_unsigned; + int leading_underscore; + int ms_extensions; + int dollars_in_identifiers; + int ms_bitfields; + + + int warn_write_strings; + int warn_unsupported; + int warn_error; + int warn_none; + int warn_implicit_function_declaration; + int warn_gcc_compat; + + + int do_debug; + + + int do_bounds_check; + + + + + int run_test; + + Elf64_Addr text_addr; + int has_text_addr; + + unsigned section_align; + + char *init_symbol; + char *fini_symbol; + + + + + + int nosse; + + + + DLLReference **loaded_dlls; + int nb_loaded_dlls; + + + char **include_paths; + int nb_include_paths; + + char **sysinclude_paths; + int nb_sysinclude_paths; + + + char **library_paths; + int nb_library_paths; + + + char **crt_paths; + int nb_crt_paths; + + + char **cmd_include_files; + int nb_cmd_include_files; + + + void *error_opaque; + void (*error_func)(void *opaque, const char *msg); + int error_set_jmp_enabled; + jmp_buf error_jmp_buf; + int nb_errors; + + + FILE *ppfp; + enum { + LINE_MACRO_OUTPUT_FORMAT_GCC, + LINE_MACRO_OUTPUT_FORMAT_NONE, + LINE_MACRO_OUTPUT_FORMAT_STD, + LINE_MACRO_OUTPUT_FORMAT_P10 = 11 + } Pflag; + char dflag; + + + char **target_deps; + int nb_target_deps; + + + BufferedFile *include_stack[32]; + BufferedFile **include_stack_ptr; + + int ifdef_stack[64]; + int *ifdef_stack_ptr; + + + int cached_includes_hash[32]; + CachedInclude **cached_includes; + int nb_cached_includes; + + + int pack_stack[8]; + int *pack_stack_ptr; + char **pragma_libs; + int nb_pragma_libs; + + + + struct InlineFunc **inline_fns; + int nb_inline_fns; + + + Section **sections; + int nb_sections; + + Section **priv_sections; + int nb_priv_sections; + + + Section *got; + Section *plt; + + + Section *dynsymtab_section; + + Section *dynsym; + + Section *symtab; + + struct sym_attr *sym_attrs; + int nb_sym_attrs; +# 805 "tcc.h" + const char *runtime_main; + void **runtime_mem; + int nb_runtime_mem; + + + + struct filespec **files; + int nb_files; + int nb_libraries; + int filetype; + char *outfile; + int option_r; + int do_bench; + int gen_deps; + char *deps_outfile; + int option_pthread; + int argc; + char **argv; +}; + +struct filespec { + char type; + char alacarte; + char name[1]; +}; +# 1070 "tcc.h" +enum tcc_token { + TOK_LAST = 256 - 1 + +# 1 "tcctok.h" 1 + + ,TOK_INT + ,TOK_VOID + ,TOK_CHAR + ,TOK_IF + ,TOK_ELSE + ,TOK_WHILE + ,TOK_BREAK + ,TOK_RETURN + ,TOK_FOR + ,TOK_EXTERN + ,TOK_STATIC + ,TOK_UNSIGNED + ,TOK_GOTO + ,TOK_DO + ,TOK_CONTINUE + ,TOK_SWITCH + ,TOK_CASE + + ,TOK_CONST1 + ,TOK_CONST2 + ,TOK_CONST3 + ,TOK_VOLATILE1 + ,TOK_VOLATILE2 + ,TOK_VOLATILE3 + ,TOK_LONG + ,TOK_REGISTER + ,TOK_SIGNED1 + ,TOK_SIGNED2 + ,TOK_SIGNED3 + ,TOK_AUTO + ,TOK_INLINE1 + ,TOK_INLINE2 + ,TOK_INLINE3 + ,TOK_RESTRICT1 + ,TOK_RESTRICT2 + ,TOK_RESTRICT3 + ,TOK_EXTENSION + + ,TOK_GENERIC + + ,TOK_FLOAT + ,TOK_DOUBLE + ,TOK_BOOL + ,TOK_SHORT + ,TOK_STRUCT + ,TOK_UNION + ,TOK_TYPEDEF + ,TOK_DEFAULT + ,TOK_ENUM + ,TOK_SIZEOF + ,TOK_ATTRIBUTE1 + ,TOK_ATTRIBUTE2 + ,TOK_ALIGNOF1 + ,TOK_ALIGNOF2 + ,TOK_TYPEOF1 + ,TOK_TYPEOF2 + ,TOK_TYPEOF3 + ,TOK_LABEL + ,TOK_ASM1 + ,TOK_ASM2 + ,TOK_ASM3 +# 71 "tcctok.h" + ,TOK_DEFINE + ,TOK_INCLUDE + ,TOK_INCLUDE_NEXT + ,TOK_IFDEF + ,TOK_IFNDEF + ,TOK_ELIF + ,TOK_ENDIF + ,TOK_DEFINED + ,TOK_UNDEF + ,TOK_ERROR + ,TOK_WARNING + ,TOK_LINE + ,TOK_PRAGMA + ,TOK___LINE__ + ,TOK___FILE__ + ,TOK___DATE__ + ,TOK___TIME__ + ,TOK___FUNCTION__ + ,TOK___VA_ARGS__ + ,TOK___COUNTER__ + + + ,TOK___FUNC__ + + + ,TOK___NAN__ + ,TOK___SNAN__ + ,TOK___INF__ + + + + ,TOK_SECTION1 + ,TOK_SECTION2 + ,TOK_ALIGNED1 + ,TOK_ALIGNED2 + ,TOK_PACKED1 + ,TOK_PACKED2 + ,TOK_WEAK1 + ,TOK_WEAK2 + ,TOK_ALIAS1 + ,TOK_ALIAS2 + ,TOK_UNUSED1 + ,TOK_UNUSED2 + ,TOK_CDECL1 + ,TOK_CDECL2 + ,TOK_CDECL3 + ,TOK_STDCALL1 + ,TOK_STDCALL2 + ,TOK_STDCALL3 + ,TOK_FASTCALL1 + ,TOK_FASTCALL2 + ,TOK_FASTCALL3 + ,TOK_REGPARM1 + ,TOK_REGPARM2 + + ,TOK_MODE + ,TOK_MODE_QI + ,TOK_MODE_DI + ,TOK_MODE_HI + ,TOK_MODE_SI + ,TOK_MODE_word + + ,TOK_DLLEXPORT + ,TOK_DLLIMPORT + ,TOK_NORETURN1 + ,TOK_NORETURN2 + ,TOK_VISIBILITY1 + ,TOK_VISIBILITY2 + + ,TOK_builtin_types_compatible_p + ,TOK_builtin_choose_expr + ,TOK_builtin_constant_p + ,TOK_builtin_frame_address + ,TOK_builtin_return_address + ,TOK_builtin_expect + + + + + ,TOK_builtin_va_arg_types + + + + + + + ,TOK_pack + + + + + + ,TOK_comment + ,TOK_lib + ,TOK_push_macro + ,TOK_pop_macro + ,TOK_once + ,TOK_option + + + + ,TOK_memcpy + ,TOK_memmove + ,TOK_memset + ,TOK___divdi3 + ,TOK___moddi3 + ,TOK___udivdi3 + ,TOK___umoddi3 + ,TOK___ashrdi3 + ,TOK___lshrdi3 + ,TOK___ashldi3 + ,TOK___floatundisf + ,TOK___floatundidf + + ,TOK___floatundixf + ,TOK___fixunsxfdi + + ,TOK___fixunssfdi + ,TOK___fixunsdfdi +# 251 "tcctok.h" + ,TOK_alloca +# 285 "tcctok.h" + ,TOK___bound_ptr_add + ,TOK___bound_ptr_indir1 + ,TOK___bound_ptr_indir2 + ,TOK___bound_ptr_indir4 + ,TOK___bound_ptr_indir8 + ,TOK___bound_ptr_indir12 + ,TOK___bound_ptr_indir16 + ,TOK___bound_main_arg + ,TOK___bound_local_new + ,TOK___bound_local_delete + + + + + + + + ,TOK_strlen + ,TOK_strcpy + + + + ,TOK_ASMDIR_byte + ,TOK_ASMDIR_word + ,TOK_ASMDIR_align + ,TOK_ASMDIR_balign + ,TOK_ASMDIR_p2align + ,TOK_ASMDIR_set + ,TOK_ASMDIR_skip + ,TOK_ASMDIR_space + ,TOK_ASMDIR_string + ,TOK_ASMDIR_asciz + ,TOK_ASMDIR_ascii + ,TOK_ASMDIR_file + ,TOK_ASMDIR_globl + ,TOK_ASMDIR_global + ,TOK_ASMDIR_weak + ,TOK_ASMDIR_hidden + ,TOK_ASMDIR_ident + ,TOK_ASMDIR_size + ,TOK_ASMDIR_type + ,TOK_ASMDIR_text + ,TOK_ASMDIR_data + ,TOK_ASMDIR_bss + ,TOK_ASMDIR_previous + ,TOK_ASMDIR_pushsection + ,TOK_ASMDIR_popsection + ,TOK_ASMDIR_fill + ,TOK_ASMDIR_rept + ,TOK_ASMDIR_endr + ,TOK_ASMDIR_org + ,TOK_ASMDIR_quad + + + + + ,TOK_ASMDIR_code64 + + ,TOK_ASMDIR_short + ,TOK_ASMDIR_long + ,TOK_ASMDIR_int + ,TOK_ASMDIR_section + + +# 1 "i386-tok.h" 1 + + + + + ,TOK_ASM_al + ,TOK_ASM_cl + ,TOK_ASM_dl + ,TOK_ASM_bl + ,TOK_ASM_ah + ,TOK_ASM_ch + ,TOK_ASM_dh + ,TOK_ASM_bh + ,TOK_ASM_ax + ,TOK_ASM_cx + ,TOK_ASM_dx + ,TOK_ASM_bx + ,TOK_ASM_sp + ,TOK_ASM_bp + ,TOK_ASM_si + ,TOK_ASM_di + ,TOK_ASM_eax + ,TOK_ASM_ecx + ,TOK_ASM_edx + ,TOK_ASM_ebx + ,TOK_ASM_esp + ,TOK_ASM_ebp + ,TOK_ASM_esi + ,TOK_ASM_edi + + ,TOK_ASM_rax + ,TOK_ASM_rcx + ,TOK_ASM_rdx + ,TOK_ASM_rbx + ,TOK_ASM_rsp + ,TOK_ASM_rbp + ,TOK_ASM_rsi + ,TOK_ASM_rdi + + ,TOK_ASM_mm0 + ,TOK_ASM_mm1 + ,TOK_ASM_mm2 + ,TOK_ASM_mm3 + ,TOK_ASM_mm4 + ,TOK_ASM_mm5 + ,TOK_ASM_mm6 + ,TOK_ASM_mm7 + ,TOK_ASM_xmm0 + ,TOK_ASM_xmm1 + ,TOK_ASM_xmm2 + ,TOK_ASM_xmm3 + ,TOK_ASM_xmm4 + ,TOK_ASM_xmm5 + ,TOK_ASM_xmm6 + ,TOK_ASM_xmm7 + ,TOK_ASM_cr0 + ,TOK_ASM_cr1 + ,TOK_ASM_cr2 + ,TOK_ASM_cr3 + ,TOK_ASM_cr4 + ,TOK_ASM_cr5 + ,TOK_ASM_cr6 + ,TOK_ASM_cr7 + ,TOK_ASM_tr0 + ,TOK_ASM_tr1 + ,TOK_ASM_tr2 + ,TOK_ASM_tr3 + ,TOK_ASM_tr4 + ,TOK_ASM_tr5 + ,TOK_ASM_tr6 + ,TOK_ASM_tr7 + ,TOK_ASM_db0 + ,TOK_ASM_db1 + ,TOK_ASM_db2 + ,TOK_ASM_db3 + ,TOK_ASM_db4 + ,TOK_ASM_db5 + ,TOK_ASM_db6 + ,TOK_ASM_db7 + ,TOK_ASM_dr0 + ,TOK_ASM_dr1 + ,TOK_ASM_dr2 + ,TOK_ASM_dr3 + ,TOK_ASM_dr4 + ,TOK_ASM_dr5 + ,TOK_ASM_dr6 + ,TOK_ASM_dr7 + ,TOK_ASM_es + ,TOK_ASM_cs + ,TOK_ASM_ss + ,TOK_ASM_ds + ,TOK_ASM_fs + ,TOK_ASM_gs + ,TOK_ASM_st + ,TOK_ASM_rip + + + + + ,TOK_ASM_spl + ,TOK_ASM_bpl + ,TOK_ASM_sil + ,TOK_ASM_dil + + + ,TOK_ASM_movb ,TOK_ASM_movw ,TOK_ASM_movl ,TOK_ASM_movq ,TOK_ASM_mov + + ,TOK_ASM_addb ,TOK_ASM_addw ,TOK_ASM_addl ,TOK_ASM_addq ,TOK_ASM_add + ,TOK_ASM_orb ,TOK_ASM_orw ,TOK_ASM_orl ,TOK_ASM_orq ,TOK_ASM_or + ,TOK_ASM_adcb ,TOK_ASM_adcw ,TOK_ASM_adcl ,TOK_ASM_adcq ,TOK_ASM_adc + ,TOK_ASM_sbbb ,TOK_ASM_sbbw ,TOK_ASM_sbbl ,TOK_ASM_sbbq ,TOK_ASM_sbb + ,TOK_ASM_andb ,TOK_ASM_andw ,TOK_ASM_andl ,TOK_ASM_andq ,TOK_ASM_and + ,TOK_ASM_subb ,TOK_ASM_subw ,TOK_ASM_subl ,TOK_ASM_subq ,TOK_ASM_sub + ,TOK_ASM_xorb ,TOK_ASM_xorw ,TOK_ASM_xorl ,TOK_ASM_xorq ,TOK_ASM_xor + ,TOK_ASM_cmpb ,TOK_ASM_cmpw ,TOK_ASM_cmpl ,TOK_ASM_cmpq ,TOK_ASM_cmp + + + ,TOK_ASM_incb ,TOK_ASM_incw ,TOK_ASM_incl ,TOK_ASM_incq ,TOK_ASM_inc + ,TOK_ASM_decb ,TOK_ASM_decw ,TOK_ASM_decl ,TOK_ASM_decq ,TOK_ASM_dec + ,TOK_ASM_notb ,TOK_ASM_notw ,TOK_ASM_notl ,TOK_ASM_notq ,TOK_ASM_not + ,TOK_ASM_negb ,TOK_ASM_negw ,TOK_ASM_negl ,TOK_ASM_negq ,TOK_ASM_neg + ,TOK_ASM_mulb ,TOK_ASM_mulw ,TOK_ASM_mull ,TOK_ASM_mulq ,TOK_ASM_mul + ,TOK_ASM_imulb ,TOK_ASM_imulw ,TOK_ASM_imull ,TOK_ASM_imulq ,TOK_ASM_imul + ,TOK_ASM_divb ,TOK_ASM_divw ,TOK_ASM_divl ,TOK_ASM_divq ,TOK_ASM_div + ,TOK_ASM_idivb ,TOK_ASM_idivw ,TOK_ASM_idivl ,TOK_ASM_idivq ,TOK_ASM_idiv + + ,TOK_ASM_xchgb ,TOK_ASM_xchgw ,TOK_ASM_xchgl ,TOK_ASM_xchgq ,TOK_ASM_xchg + ,TOK_ASM_testb ,TOK_ASM_testw ,TOK_ASM_testl ,TOK_ASM_testq ,TOK_ASM_test + + + ,TOK_ASM_rolb ,TOK_ASM_rolw ,TOK_ASM_roll ,TOK_ASM_rolq ,TOK_ASM_rol + ,TOK_ASM_rorb ,TOK_ASM_rorw ,TOK_ASM_rorl ,TOK_ASM_rorq ,TOK_ASM_ror + ,TOK_ASM_rclb ,TOK_ASM_rclw ,TOK_ASM_rcll ,TOK_ASM_rclq ,TOK_ASM_rcl + ,TOK_ASM_rcrb ,TOK_ASM_rcrw ,TOK_ASM_rcrl ,TOK_ASM_rcrq ,TOK_ASM_rcr + ,TOK_ASM_shlb ,TOK_ASM_shlw ,TOK_ASM_shll ,TOK_ASM_shlq ,TOK_ASM_shl + ,TOK_ASM_shrb ,TOK_ASM_shrw ,TOK_ASM_shrl ,TOK_ASM_shrq ,TOK_ASM_shr + ,TOK_ASM_sarb ,TOK_ASM_sarw ,TOK_ASM_sarl ,TOK_ASM_sarq ,TOK_ASM_sar + + ,TOK_ASM_shldw ,TOK_ASM_shldl ,TOK_ASM_shldq ,TOK_ASM_shld + ,TOK_ASM_shrdw ,TOK_ASM_shrdl ,TOK_ASM_shrdq ,TOK_ASM_shrd + + ,TOK_ASM_pushw + ,TOK_ASM_pushl + + ,TOK_ASM_pushq + + ,TOK_ASM_push + + ,TOK_ASM_popw + ,TOK_ASM_popl + + ,TOK_ASM_popq + + ,TOK_ASM_pop + + ,TOK_ASM_inb ,TOK_ASM_inw ,TOK_ASM_inl ,TOK_ASM_in + ,TOK_ASM_outb ,TOK_ASM_outw ,TOK_ASM_outl ,TOK_ASM_out + + ,TOK_ASM_movzbw ,TOK_ASM_movzbl ,TOK_ASM_movzbq ,TOK_ASM_movzb + ,TOK_ASM_movzwl + ,TOK_ASM_movsbw + ,TOK_ASM_movsbl + ,TOK_ASM_movswl + + ,TOK_ASM_movsbq + ,TOK_ASM_movswq + ,TOK_ASM_movzwq + ,TOK_ASM_movslq + + + ,TOK_ASM_leaw ,TOK_ASM_leal ,TOK_ASM_leaq ,TOK_ASM_lea + + ,TOK_ASM_les + ,TOK_ASM_lds + ,TOK_ASM_lss + ,TOK_ASM_lfs + ,TOK_ASM_lgs + + ,TOK_ASM_call + ,TOK_ASM_jmp + ,TOK_ASM_lcall + ,TOK_ASM_ljmp + + ,TOK_ASM_jo ,TOK_ASM_jno ,TOK_ASM_jb ,TOK_ASM_jc ,TOK_ASM_jnae ,TOK_ASM_jnb ,TOK_ASM_jnc ,TOK_ASM_jae ,TOK_ASM_je ,TOK_ASM_jz ,TOK_ASM_jne ,TOK_ASM_jnz ,TOK_ASM_jbe ,TOK_ASM_jna ,TOK_ASM_jnbe ,TOK_ASM_ja ,TOK_ASM_js ,TOK_ASM_jns ,TOK_ASM_jp ,TOK_ASM_jpe ,TOK_ASM_jnp ,TOK_ASM_jpo ,TOK_ASM_jl ,TOK_ASM_jnge ,TOK_ASM_jnl ,TOK_ASM_jge ,TOK_ASM_jle ,TOK_ASM_jng ,TOK_ASM_jnle ,TOK_ASM_jg + + ,TOK_ASM_seto ,TOK_ASM_setno ,TOK_ASM_setb ,TOK_ASM_setc ,TOK_ASM_setnae ,TOK_ASM_setnb ,TOK_ASM_setnc ,TOK_ASM_setae ,TOK_ASM_sete ,TOK_ASM_setz ,TOK_ASM_setne ,TOK_ASM_setnz ,TOK_ASM_setbe ,TOK_ASM_setna ,TOK_ASM_setnbe ,TOK_ASM_seta ,TOK_ASM_sets ,TOK_ASM_setns ,TOK_ASM_setp ,TOK_ASM_setpe ,TOK_ASM_setnp ,TOK_ASM_setpo ,TOK_ASM_setl ,TOK_ASM_setnge ,TOK_ASM_setnl ,TOK_ASM_setge ,TOK_ASM_setle ,TOK_ASM_setng ,TOK_ASM_setnle ,TOK_ASM_setg + ,TOK_ASM_setob ,TOK_ASM_setnob ,TOK_ASM_setbb ,TOK_ASM_setcb ,TOK_ASM_setnaeb ,TOK_ASM_setnbb ,TOK_ASM_setncb ,TOK_ASM_setaeb ,TOK_ASM_seteb ,TOK_ASM_setzb ,TOK_ASM_setneb ,TOK_ASM_setnzb ,TOK_ASM_setbeb ,TOK_ASM_setnab ,TOK_ASM_setnbeb ,TOK_ASM_setab ,TOK_ASM_setsb ,TOK_ASM_setnsb ,TOK_ASM_setpb ,TOK_ASM_setpeb ,TOK_ASM_setnpb ,TOK_ASM_setpob ,TOK_ASM_setlb ,TOK_ASM_setngeb ,TOK_ASM_setnlb ,TOK_ASM_setgeb ,TOK_ASM_setleb ,TOK_ASM_setngb ,TOK_ASM_setnleb ,TOK_ASM_setgb + ,TOK_ASM_cmovo ,TOK_ASM_cmovno ,TOK_ASM_cmovb ,TOK_ASM_cmovc ,TOK_ASM_cmovnae ,TOK_ASM_cmovnb ,TOK_ASM_cmovnc ,TOK_ASM_cmovae ,TOK_ASM_cmove ,TOK_ASM_cmovz ,TOK_ASM_cmovne ,TOK_ASM_cmovnz ,TOK_ASM_cmovbe ,TOK_ASM_cmovna ,TOK_ASM_cmovnbe ,TOK_ASM_cmova ,TOK_ASM_cmovs ,TOK_ASM_cmovns ,TOK_ASM_cmovp ,TOK_ASM_cmovpe ,TOK_ASM_cmovnp ,TOK_ASM_cmovpo ,TOK_ASM_cmovl ,TOK_ASM_cmovnge ,TOK_ASM_cmovnl ,TOK_ASM_cmovge ,TOK_ASM_cmovle ,TOK_ASM_cmovng ,TOK_ASM_cmovnle ,TOK_ASM_cmovg + + ,TOK_ASM_bsfw ,TOK_ASM_bsfl ,TOK_ASM_bsfq ,TOK_ASM_bsf + ,TOK_ASM_bsrw ,TOK_ASM_bsrl ,TOK_ASM_bsrq ,TOK_ASM_bsr + ,TOK_ASM_btw ,TOK_ASM_btl ,TOK_ASM_btq ,TOK_ASM_bt + ,TOK_ASM_btsw ,TOK_ASM_btsl ,TOK_ASM_btsq ,TOK_ASM_bts + ,TOK_ASM_btrw ,TOK_ASM_btrl ,TOK_ASM_btrq ,TOK_ASM_btr + ,TOK_ASM_btcw ,TOK_ASM_btcl ,TOK_ASM_btcq ,TOK_ASM_btc + + ,TOK_ASM_larw ,TOK_ASM_larl ,TOK_ASM_larq ,TOK_ASM_lar + ,TOK_ASM_lslw ,TOK_ASM_lsll ,TOK_ASM_lslq ,TOK_ASM_lsl + + + ,TOK_ASM_fadd ,TOK_ASM_faddp ,TOK_ASM_fadds ,TOK_ASM_fiaddl ,TOK_ASM_faddl ,TOK_ASM_fiadds + ,TOK_ASM_fmul ,TOK_ASM_fmulp ,TOK_ASM_fmuls ,TOK_ASM_fimull ,TOK_ASM_fmull ,TOK_ASM_fimuls + + ,TOK_ASM_fcom + ,TOK_ASM_fcom_1 + ,TOK_ASM_fcoms ,TOK_ASM_ficoml ,TOK_ASM_fcoml ,TOK_ASM_ficoms + + ,TOK_ASM_fcomp ,TOK_ASM_fcompp ,TOK_ASM_fcomps ,TOK_ASM_ficompl ,TOK_ASM_fcompl ,TOK_ASM_ficomps + ,TOK_ASM_fsub ,TOK_ASM_fsubp ,TOK_ASM_fsubs ,TOK_ASM_fisubl ,TOK_ASM_fsubl ,TOK_ASM_fisubs + ,TOK_ASM_fsubr ,TOK_ASM_fsubrp ,TOK_ASM_fsubrs ,TOK_ASM_fisubrl ,TOK_ASM_fsubrl ,TOK_ASM_fisubrs + ,TOK_ASM_fdiv ,TOK_ASM_fdivp ,TOK_ASM_fdivs ,TOK_ASM_fidivl ,TOK_ASM_fdivl ,TOK_ASM_fidivs + ,TOK_ASM_fdivr ,TOK_ASM_fdivrp ,TOK_ASM_fdivrs ,TOK_ASM_fidivrl ,TOK_ASM_fdivrl ,TOK_ASM_fidivrs + + ,TOK_ASM_xaddb ,TOK_ASM_xaddw ,TOK_ASM_xaddl ,TOK_ASM_xaddq ,TOK_ASM_xadd + ,TOK_ASM_cmpxchgb ,TOK_ASM_cmpxchgw ,TOK_ASM_cmpxchgl ,TOK_ASM_cmpxchgq ,TOK_ASM_cmpxchg + + + ,TOK_ASM_cmpsb ,TOK_ASM_cmpsw ,TOK_ASM_cmpsl ,TOK_ASM_cmpsq ,TOK_ASM_cmps + ,TOK_ASM_scmpb ,TOK_ASM_scmpw ,TOK_ASM_scmpl ,TOK_ASM_scmpq ,TOK_ASM_scmp + ,TOK_ASM_insb ,TOK_ASM_insw ,TOK_ASM_insl ,TOK_ASM_ins + ,TOK_ASM_outsb ,TOK_ASM_outsw ,TOK_ASM_outsl ,TOK_ASM_outs + ,TOK_ASM_lodsb ,TOK_ASM_lodsw ,TOK_ASM_lodsl ,TOK_ASM_lodsq ,TOK_ASM_lods + ,TOK_ASM_slodb ,TOK_ASM_slodw ,TOK_ASM_slodl ,TOK_ASM_slodq ,TOK_ASM_slod + ,TOK_ASM_movsb ,TOK_ASM_movsw ,TOK_ASM_movsl ,TOK_ASM_movsq ,TOK_ASM_movs + ,TOK_ASM_smovb ,TOK_ASM_smovw ,TOK_ASM_smovl ,TOK_ASM_smovq ,TOK_ASM_smov + ,TOK_ASM_scasb ,TOK_ASM_scasw ,TOK_ASM_scasl ,TOK_ASM_scasq ,TOK_ASM_scas + ,TOK_ASM_sscab ,TOK_ASM_sscaw ,TOK_ASM_sscal ,TOK_ASM_sscaq ,TOK_ASM_ssca + ,TOK_ASM_stosb ,TOK_ASM_stosw ,TOK_ASM_stosl ,TOK_ASM_stosq ,TOK_ASM_stos + ,TOK_ASM_sstob ,TOK_ASM_sstow ,TOK_ASM_sstol ,TOK_ASM_sstoq ,TOK_ASM_ssto +# 238 "i386-tok.h" +# 1 "x86_64-asm.h" 1 + ,TOK_ASM_clc + ,TOK_ASM_cld + ,TOK_ASM_cli + ,TOK_ASM_clts + ,TOK_ASM_cmc + ,TOK_ASM_lahf + ,TOK_ASM_sahf + ,TOK_ASM_pushfq + ,TOK_ASM_popfq + ,TOK_ASM_pushf + ,TOK_ASM_popf + ,TOK_ASM_stc + ,TOK_ASM_std + ,TOK_ASM_sti + ,TOK_ASM_aaa + ,TOK_ASM_aas + ,TOK_ASM_daa + ,TOK_ASM_das + ,TOK_ASM_aad + ,TOK_ASM_aam + ,TOK_ASM_cbw + ,TOK_ASM_cwd + ,TOK_ASM_cwde + ,TOK_ASM_cdq + ,TOK_ASM_cbtw + ,TOK_ASM_cwtl + ,TOK_ASM_cwtd + ,TOK_ASM_cltd + ,TOK_ASM_cqto + ,TOK_ASM_int3 + ,TOK_ASM_into + ,TOK_ASM_iret + ,TOK_ASM_rsm + ,TOK_ASM_hlt + ,TOK_ASM_wait + ,TOK_ASM_nop + ,TOK_ASM_pause + ,TOK_ASM_xlat + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ,TOK_ASM_lock + ,TOK_ASM_rep + ,TOK_ASM_repe + ,TOK_ASM_repz + ,TOK_ASM_repne + ,TOK_ASM_repnz + + ,TOK_ASM_invd + ,TOK_ASM_wbinvd + ,TOK_ASM_cpuid + ,TOK_ASM_wrmsr + ,TOK_ASM_rdtsc + ,TOK_ASM_rdmsr + ,TOK_ASM_rdpmc + + ,TOK_ASM_syscall + ,TOK_ASM_sysret + + ,TOK_ASM_ud2 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ,TOK_ASM_leave + ,TOK_ASM_ret + ,TOK_ASM_retq + + + ,TOK_ASM_lret + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ,TOK_ASM_fucompp + ,TOK_ASM_ftst + ,TOK_ASM_fxam + ,TOK_ASM_fld1 + ,TOK_ASM_fldl2t + ,TOK_ASM_fldl2e + ,TOK_ASM_fldpi + ,TOK_ASM_fldlg2 + ,TOK_ASM_fldln2 + ,TOK_ASM_fldz + + ,TOK_ASM_f2xm1 + ,TOK_ASM_fyl2x + ,TOK_ASM_fptan + ,TOK_ASM_fpatan + ,TOK_ASM_fxtract + ,TOK_ASM_fprem1 + ,TOK_ASM_fdecstp + ,TOK_ASM_fincstp + ,TOK_ASM_fprem + ,TOK_ASM_fyl2xp1 + ,TOK_ASM_fsqrt + ,TOK_ASM_fsincos + ,TOK_ASM_frndint + ,TOK_ASM_fscale + ,TOK_ASM_fsin + ,TOK_ASM_fcos + ,TOK_ASM_fchs + ,TOK_ASM_fabs + ,TOK_ASM_fninit + ,TOK_ASM_fnclex + ,TOK_ASM_fnop + ,TOK_ASM_fwait + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ,TOK_ASM_fxch + + + + + + + + + + + ,TOK_ASM_fnstsw + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ,TOK_ASM_emms + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +# 239 "i386-tok.h" 2 +# 250 "i386-tok.h" +# 1 "x86_64-asm.h" 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ,TOK_ASM_sysretq + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ,TOK_ASM_ljmpw + ,TOK_ASM_ljmpl + + + + + ,TOK_ASM_enter + + + + + + + + + + ,TOK_ASM_loopne + ,TOK_ASM_loopnz + ,TOK_ASM_loope + ,TOK_ASM_loopz + ,TOK_ASM_loop + ,TOK_ASM_jecxz + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ,TOK_ASM_fld + ,TOK_ASM_fldl + ,TOK_ASM_flds + + ,TOK_ASM_fildl + ,TOK_ASM_fildq + ,TOK_ASM_fildll + ,TOK_ASM_fldt + ,TOK_ASM_fbld + + + ,TOK_ASM_fst + ,TOK_ASM_fstl + ,TOK_ASM_fsts + ,TOK_ASM_fstps + + ,TOK_ASM_fstpl + ,TOK_ASM_fist + ,TOK_ASM_fistp + ,TOK_ASM_fistl + ,TOK_ASM_fistpl + + ,TOK_ASM_fstp + ,TOK_ASM_fistpq + ,TOK_ASM_fistpll + ,TOK_ASM_fstpt + ,TOK_ASM_fbstp + + + + + + + ,TOK_ASM_fucom + ,TOK_ASM_fucomp + + ,TOK_ASM_finit + ,TOK_ASM_fldcw + ,TOK_ASM_fnstcw + ,TOK_ASM_fstcw + + + + ,TOK_ASM_fstsw + + + ,TOK_ASM_fclex + ,TOK_ASM_fnstenv + ,TOK_ASM_fstenv + ,TOK_ASM_fldenv + ,TOK_ASM_fnsave + ,TOK_ASM_fsave + ,TOK_ASM_frstor + ,TOK_ASM_ffree + ,TOK_ASM_ffreep + ,TOK_ASM_fxsave + ,TOK_ASM_fxrstor + + + + + ,TOK_ASM_fxsaveq + ,TOK_ASM_fxrstorq + + + ,TOK_ASM_arpl + + ,TOK_ASM_lgdt + ,TOK_ASM_lgdtq + ,TOK_ASM_lidt + ,TOK_ASM_lidtq + ,TOK_ASM_lldt + ,TOK_ASM_lmsw + + ,TOK_ASM_ltr + ,TOK_ASM_sgdt + ,TOK_ASM_sgdtq + ,TOK_ASM_sidt + ,TOK_ASM_sidtq + ,TOK_ASM_sldt + ,TOK_ASM_smsw + ,TOK_ASM_str + + + ,TOK_ASM_verr + ,TOK_ASM_verw + ,TOK_ASM_swapgs + + + + ,TOK_ASM_bswap + ,TOK_ASM_bswapl + ,TOK_ASM_bswapq + + + + ,TOK_ASM_invlpg + + + ,TOK_ASM_cmpxchg8b + + + ,TOK_ASM_cmpxchg16b + + + + + ,TOK_ASM_fcmovb + ,TOK_ASM_fcmove + ,TOK_ASM_fcmovbe + ,TOK_ASM_fcmovu + ,TOK_ASM_fcmovnb + ,TOK_ASM_fcmovne + ,TOK_ASM_fcmovnbe + ,TOK_ASM_fcmovnu + + ,TOK_ASM_fucomi + ,TOK_ASM_fcomi + ,TOK_ASM_fucomip + ,TOK_ASM_fcomip + + + + ,TOK_ASM_movd + + + + + + + + + + + + + ,TOK_ASM_packssdw + ,TOK_ASM_packsswb + ,TOK_ASM_packuswb + ,TOK_ASM_paddb + ,TOK_ASM_paddw + ,TOK_ASM_paddd + ,TOK_ASM_paddsb + ,TOK_ASM_paddsw + ,TOK_ASM_paddusb + ,TOK_ASM_paddusw + ,TOK_ASM_pand + ,TOK_ASM_pandn + ,TOK_ASM_pcmpeqb + ,TOK_ASM_pcmpeqw + ,TOK_ASM_pcmpeqd + ,TOK_ASM_pcmpgtb + ,TOK_ASM_pcmpgtw + ,TOK_ASM_pcmpgtd + ,TOK_ASM_pmaddwd + ,TOK_ASM_pmulhw + ,TOK_ASM_pmullw + ,TOK_ASM_por + ,TOK_ASM_psllw + + ,TOK_ASM_pslld + + ,TOK_ASM_psllq + + ,TOK_ASM_psraw + + ,TOK_ASM_psrad + + ,TOK_ASM_psrlw + + ,TOK_ASM_psrld + + ,TOK_ASM_psrlq + + ,TOK_ASM_psubb + ,TOK_ASM_psubw + ,TOK_ASM_psubd + ,TOK_ASM_psubsb + ,TOK_ASM_psubsw + ,TOK_ASM_psubusb + ,TOK_ASM_psubusw + ,TOK_ASM_punpckhbw + ,TOK_ASM_punpckhwd + ,TOK_ASM_punpckhdq + ,TOK_ASM_punpcklbw + ,TOK_ASM_punpcklwd + ,TOK_ASM_punpckldq + ,TOK_ASM_pxor + + + ,TOK_ASM_movups + + ,TOK_ASM_movaps + + ,TOK_ASM_movhps + + ,TOK_ASM_addps + ,TOK_ASM_cvtpi2ps + ,TOK_ASM_cvtps2pi + ,TOK_ASM_cvttps2pi + ,TOK_ASM_divps + ,TOK_ASM_maxps + ,TOK_ASM_minps + ,TOK_ASM_mulps + ,TOK_ASM_pavgb + ,TOK_ASM_pavgw + ,TOK_ASM_pmaxsw + ,TOK_ASM_pmaxub + ,TOK_ASM_pminsw + ,TOK_ASM_pminub + ,TOK_ASM_rcpss + ,TOK_ASM_rsqrtps + ,TOK_ASM_sqrtps + ,TOK_ASM_subps + + ,TOK_ASM_prefetchnta + ,TOK_ASM_prefetcht0 + ,TOK_ASM_prefetcht1 + ,TOK_ASM_prefetcht2 + ,TOK_ASM_prefetchw + ,TOK_ASM_lfence + ,TOK_ASM_mfence + ,TOK_ASM_sfence + ,TOK_ASM_clflush +# 251 "i386-tok.h" 2 +# 350 "tcctok.h" 2 +# 1074 "tcc.h" 2 + +}; + + + + + + + +static int gnu_ext; + +static int tcc_ext; + +static struct TCCState *tcc_state; + + +static char *pstrcpy(char *buf, int buf_size, const char *s); +static char *pstrcat(char *buf, int buf_size, const char *s); +static char *pstrncpy(char *out, const char *in, size_t num); + char *tcc_basename(const char *name); + char *tcc_fileextension (const char *name); + + + void tcc_free(void *ptr); + void *tcc_malloc(unsigned long size); + void *tcc_mallocz(unsigned long size); + void *tcc_realloc(void *ptr, unsigned long size); + char *tcc_strdup(const char *str); +# 1120 "tcc.h" + void tcc_memcheck(void); + void tcc_error_noabort(const char *fmt, ...); + void tcc_error(const char *fmt, ...); + void tcc_warning(const char *fmt, ...); + + +static void dynarray_add(void *ptab, int *nb_ptr, void *data); +static void dynarray_reset(void *pp, int *n); +static inline void cstr_ccat(CString *cstr, int ch); +static void cstr_cat(CString *cstr, const char *str, int len); +static void cstr_wccat(CString *cstr, int ch); +static void cstr_new(CString *cstr); +static void cstr_free(CString *cstr); +static void cstr_reset(CString *cstr); + +static inline void sym_free(Sym *sym); +static Sym *sym_push2(Sym **ps, int v, int t, int c); +static Sym *sym_find2(Sym *s, int v); +static Sym *sym_push(int v, CType *type, int r, int c); +static void sym_pop(Sym **ptop, Sym *b, int keep); +static inline Sym *struct_find(int v); +static inline Sym *sym_find(int v); +static Sym *global_identifier_push(int v, int t, int c); + +static void tcc_open_bf(TCCState *s1, const char *filename, int initlen); +static int tcc_open(TCCState *s1, const char *filename); +static void tcc_close(void); + +static int tcc_add_file_internal(TCCState *s1, const char *filename, int flags); +# 1166 "tcc.h" +static int tcc_add_crt(TCCState *s, const char *filename); +static int tcc_add_dll(TCCState *s, const char *filename, int flags); +static void tcc_add_pragma_libs(TCCState *s1); + int tcc_add_library_err(TCCState *s, const char *f); + void tcc_print_stats(TCCState *s, unsigned total_time); + int tcc_parse_args(TCCState *s, int *argc, char ***argv, int optind); +# 1188 "tcc.h" +static struct BufferedFile *file; +static int ch, tok; +static CValue tokc; +static const int *macro_ptr; +static int parse_flags; +static int tok_flags; +static CString tokcstr; + + +static int total_lines; +static int total_bytes; +static int tok_ident; +static TokenSym **table_ident; +# 1222 "tcc.h" +static TokenSym *tok_alloc(const char *str, int len); +static const char *get_tok_str(int v, CValue *cv); +static void begin_macro(TokenString *str, int alloc); +static void end_macro(void); +static int set_idnum(int c, int val); +static inline void tok_str_new(TokenString *s); +static TokenString *tok_str_alloc(void); +static void tok_str_free(TokenString *s); +static void tok_str_free_str(int *str); +static void tok_str_add(TokenString *s, int t); +static void tok_str_add_tok(TokenString *s); +static inline void define_push(int v, int macro_type, int *str, Sym *first_arg); +static void define_undef(Sym *s); +static inline Sym *define_find(int v); +static void free_defines(Sym *b); +static Sym *label_find(int v); +static Sym *label_push(Sym **ptop, int v, int flags); +static void label_pop(Sym **ptop, Sym *slast, int keep); +static void parse_define(void); +static void preprocess(int is_bof); +static void next_nomacro(void); +static void next(void); +static inline void unget_tok(int last_tok); +static void preprocess_start(TCCState *s1, int is_asm); +static void preprocess_end(TCCState *s1); +static void tccpp_new(TCCState *s); +static void tccpp_delete(TCCState *s); +static int tcc_preprocess(TCCState *s1); +static void skip(int c); +static void expect(const char *msg); + + +static inline int is_space(int ch) { + return ch == ' ' || ch == '\t' || ch == '\v' || ch == '\f' || ch == '\r'; +} +static inline int isid(int c) { + return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_'; +} +static inline int isnum(int c) { + return c >= '0' && c <= '9'; +} +static inline int isoct(int c) { + return c >= '0' && c <= '7'; +} +static inline int toup(int c) { + return (c >= 'a' && c <= 'z') ? c - 'a' + 'A' : c; +} + + + + +static Sym *sym_free_first; +static void **sym_pools; +static int nb_sym_pools; + +static Sym *global_stack; +static Sym *local_stack; +static Sym *local_label_stack; +static Sym *global_label_stack; +static Sym *define_stack; +static CType char_pointer_type, func_old_type, int_type, size_type; +static SValue __vstack[1+ 256], *vtop, *pvtop; + +static int rsym, anon_sym, ind, loc; + +static int const_wanted; +static int nocode_wanted; +static int global_expr; +static CType func_vt; +static int func_var; +static int func_vc; +static int last_line_num, last_ind, func_ind; +static const char *funcname; +static int g_debug; + +static void tcc_debug_start(TCCState *s1); +static void tcc_debug_end(TCCState *s1); +static void tcc_debug_funcstart(TCCState *s1, Sym *sym); +static void tcc_debug_funcend(TCCState *s1, int size); +static void tcc_debug_line(TCCState *s1); + +static int tccgen_compile(TCCState *s1); +static void free_inline_functions(TCCState *s); +static void check_vstack(void); + +static inline int is_float(int t); +static int ieee_finite(double d); +static void test_lvalue(void); +static void vpushi(int v); +static Elf64_Sym *elfsym(Sym *); +static void update_storage(Sym *sym); +static Sym *external_global_sym(int v, CType *type, int r); +static void vset(CType *type, int r, int v); +static void vswap(void); +static void vpush_global_sym(CType *type, int v); +static void vrote(SValue *e, int n); +static void vrott(int n); +static void vrotb(int n); + + + + +static void vpushv(SValue *v); +static void save_reg(int r); +static void save_reg_upstack(int r, int n); +static int get_reg(int rc); +static void save_regs(int n); +static void gaddrof(void); +static int gv(int rc); +static void gv2(int rc1, int rc2); +static void vpop(void); +static void gen_op(int op); +static int type_size(CType *type, int *a); +static void mk_pointer(CType *type); +static void vstore(void); +static void inc(int post, int c); +static void parse_mult_str (CString *astr, const char *msg); +static void parse_asm_str(CString *astr); +static int lvalue_type(int t); +static void indir(void); +static void unary(void); +static void expr_prod(void); +static void expr_sum(void); +static void gexpr(void); +static int expr_const(void); + +static Sym *get_sym_ref(CType *type, Section *sec, unsigned long offset, unsigned long size); + + +static int classify_x86_64_va_arg(CType *ty); +# 1362 "tcc.h" +typedef struct { + unsigned int n_strx; + unsigned char n_type; + unsigned char n_other; + unsigned short n_desc; + unsigned int n_value; +} Stab_Sym; + +static Section *text_section, *data_section, *bss_section; +static Section *common_section; +static Section *cur_text_section; + +static Section *last_text_section; + + + +static Section *bounds_section; +static Section *lbounds_section; +static void tccelf_bounds_new(TCCState *s); + + +static Section *symtab_section; + +static Section *stab_section, *stabstr_section; + +static void tccelf_new(TCCState *s); +static void tccelf_delete(TCCState *s); +static void tccelf_stab_new(TCCState *s); +static void tccelf_begin_file(TCCState *s1); +static void tccelf_end_file(TCCState *s1); + +static Section *new_section(TCCState *s1, const char *name, int sh_type, int sh_flags); +static void section_realloc(Section *sec, unsigned long new_size); +static size_t section_add(Section *sec, Elf64_Addr size, int align); +static void *section_ptr_add(Section *sec, Elf64_Addr size); +static void section_reserve(Section *sec, unsigned long size); +static Section *find_section(TCCState *s1, const char *name); +static Section *new_symtab(TCCState *s1, const char *symtab_name, int sh_type, int sh_flags, const char *strtab_name, const char *hash_name, int hash_sh_flags); + +static void put_extern_sym2(Sym *sym, int sh_num, Elf64_Addr value, unsigned long size, int can_add_underscore); +static void put_extern_sym(Sym *sym, Section *section, Elf64_Addr value, unsigned long size); + + + +static void greloca(Section *s, Sym *sym, unsigned long offset, int type, Elf64_Addr addend); + +static int put_elf_str(Section *s, const char *sym); +static int put_elf_sym(Section *s, Elf64_Addr value, unsigned long size, int info, int other, int shndx, const char *name); +static int set_elf_sym(Section *s, Elf64_Addr value, unsigned long size, int info, int other, int shndx, const char *name); +static int find_elf_sym(Section *s, const char *name); +static void put_elf_reloc(Section *symtab, Section *s, unsigned long offset, int type, int symbol); +static void put_elf_reloca(Section *symtab, Section *s, unsigned long offset, int type, int symbol, Elf64_Addr addend); + +static void put_stabs(const char *str, int type, int other, int desc, unsigned long value); +static void put_stabs_r(const char *str, int type, int other, int desc, unsigned long value, Section *sec, int sym_index); +static void put_stabn(int type, int other, int desc, int value); +static void put_stabd(int type, int other, int desc); + +static void resolve_common_syms(TCCState *s1); +static void relocate_syms(TCCState *s1, Section *symtab, int do_resolve); +static void relocate_section(TCCState *s1, Section *s); + +static int tcc_object_type(int fd, Elf64_Ehdr *h); +static int tcc_load_object_file(TCCState *s1, int fd, unsigned long file_offset); +static int tcc_load_archive(TCCState *s1, int fd); +static void tcc_add_bcheck(TCCState *s1); +static void tcc_add_runtime(TCCState *s1); + +static void build_got_entries(TCCState *s1); +static struct sym_attr *get_sym_attr(TCCState *s1, int index, int alloc); +static void squeeze_multi_relocs(Section *sec, size_t oldrelocoffset); + +static Elf64_Addr get_elf_sym_addr(TCCState *s, const char *name, int err); + +static void *tcc_get_symbol_err(TCCState *s, const char *name); + + + +static int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level); +static int tcc_load_ldscript(TCCState *s1); +static uint8_t *parse_comment(uint8_t *p); +static void minp(void); +static inline void inp(void); +static int handle_eob(void); + + + + + + +enum gotplt_entry { + NO_GOTPLT_ENTRY, + BUILD_GOT_ONLY, + AUTO_GOTPLT_ENTRY, + ALWAYS_GOTPLT_ENTRY +}; + +static int code_reloc (int reloc_type); +static int gotplt_entry_type (int reloc_type); +static unsigned create_plt_entry(TCCState *s1, unsigned got_offset, struct sym_attr *attr); +static void relocate_init(Section *sr); +static void relocate(TCCState *s1, Elf64_Rela *rel, int type, unsigned char *ptr, Elf64_Addr addr, Elf64_Addr val); +static void relocate_plt(TCCState *s1); + + + +static const int reg_classes[25]; + +static void gsym_addr(int t, int a); +static void gsym(int t); +static void load(int r, SValue *sv); +static void store(int r, SValue *v); +static int gfunc_sret(CType *vt, int variadic, CType *ret, int *align, int *regsize); +static void gfunc_call(int nb_args); +static void gfunc_prolog(CType *func_type); +static void gfunc_epilog(void); +static int gjmp(int t); +static void gjmp_addr(int a); +static int gtst(int inv, int t); + +static void gtst_addr(int inv, int a); + + + +static void gen_opi(int op); +static void gen_opf(int op); +static void gen_cvt_ftoi(int t); +static void gen_cvt_ftof(int t); +static void ggoto(void); + +static void o(unsigned int c); + + +static void gen_cvt_itof(int t); + +static void gen_vla_sp_save(int addr); +static void gen_vla_sp_restore(int addr); +static void gen_vla_alloc(CType *type, int align); + +static inline uint16_t read16le(unsigned char *p) { + return p[0] | (uint16_t)p[1] << 8; +} +static inline void write16le(unsigned char *p, uint16_t x) { + p[0] = x & 255; p[1] = x >> 8 & 255; +} +static inline uint32_t read32le(unsigned char *p) { + return read16le(p) | (uint32_t)read16le(p + 2) << 16; +} +static inline void write32le(unsigned char *p, uint32_t x) { + write16le(p, x); write16le(p + 2, x >> 16); +} +static inline void add32le(unsigned char *p, int32_t x) { + write32le(p, read32le(p) + x); +} +static inline uint64_t read64le(unsigned char *p) { + return read32le(p) | (uint64_t)read32le(p + 4) << 32; +} +static inline void write64le(unsigned char *p, uint64_t x) { + write32le(p, x); write32le(p + 4, x >> 32); +} +static inline void add64le(unsigned char *p, int64_t x) { + write64le(p, read64le(p) + x); +} + + + +static void g(int c); +static void gen_le16(int c); +static void gen_le32(int c); +static void gen_addr32(int r, Sym *sym, int c); +static void gen_addrpc32(int r, Sym *sym, int c); + + + +static void gen_bounded_ptr_add(void); +static void gen_bounded_ptr_deref(void); + + + + +static void gen_addr64(int r, Sym *sym, int64_t c); +static void gen_opl(int op); +# 1580 "tcc.h" +static void asm_instr(void); +static void asm_global_instr(void); + +static int find_constraint(ASMOperand *operands, int nb_operands, const char *name, const char **pp); +static Sym* get_asm_sym(int name, Sym *csym); +static void asm_expr(TCCState *s1, ExprValue *pe); +static int asm_int_expr(TCCState *s1); +static int tcc_assemble(TCCState *s1, int do_preprocess); + +static void gen_expr32(ExprValue *pe); + +static void gen_expr64(ExprValue *pe); + +static void asm_opcode(TCCState *s1, int opcode); +static int asm_parse_regvar(int t); +static void asm_compute_constraints(ASMOperand *operands, int nb_operands, int nb_outputs, const uint8_t *clobber_regs, int *pout_reg); +static void subst_asm_operand(CString *add_str, SValue *sv, int modifier); +static void asm_gen_code(ASMOperand *operands, int nb_operands, int nb_outputs, int is_output, uint8_t *clobber_regs, int out_reg); +static void asm_clobber(uint8_t *clobber_regs, const char *str); +# 1634 "tcc.h" +static int rt_num_callers; +static const char **rt_bound_error_msg; +static void *rt_prog_main; +static void tcc_set_num_callers(int n); + +static void tcc_run_free(TCCState *s1); +# 22 "tccgen.c" 2 +# 31 "tccgen.c" +static int rsym, anon_sym, ind, loc; + +static Sym *sym_free_first; +static void **sym_pools; +static int nb_sym_pools; + +static Sym *global_stack; +static Sym *local_stack; +static Sym *define_stack; +static Sym *global_label_stack; +static Sym *local_label_stack; +static int local_scope; +static int in_sizeof; +static int section_sym; + +static int vlas_in_scope; +static int vla_sp_root_loc; +static int vla_sp_loc; + +static SValue __vstack[1+256], *vtop, *pvtop; + +static int const_wanted; +static int nocode_wanted; + + +static int global_expr; +static CType func_vt; +static int func_var; +static int func_vc; +static int last_line_num, last_ind, func_ind; +static const char *funcname; +static int g_debug; + +static CType char_pointer_type, func_old_type, int_type, size_type, ptrdiff_type; + +static struct switch_t { + struct case_t { + int64_t v1, v2; + int sym; + } **p; int n; + int def_sym; +} *cur_switch; + + + +static void gen_cast(CType *type); +static void gen_cast_s(int t); +static inline CType *pointed_type(CType *type); +static int is_compatible_types(CType *type1, CType *type2); +static int parse_btype(CType *type, AttributeDef *ad); +static CType *type_decl(CType *type, AttributeDef *ad, int *v, int td); +static void parse_expr_type(CType *type); +static void init_putv(CType *type, Section *sec, unsigned long c); +static void decl_initializer(CType *type, Section *sec, unsigned long c, int first, int size_only); +static void block(int *bsym, int *csym, int is_expr); +static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, int has_init, int v, int scope); +static void decl(int l); +static int decl0(int l, int is_for_loop_init, Sym *); +static void expr_eq(void); +static void vla_runtime_type_size(CType *type, int *a); +static void vla_sp_restore(void); +static void vla_sp_restore_root(void); +static int is_compatible_unqualified_types(CType *type1, CType *type2); +static inline int64_t expr_const64(void); +static void vpush64(int ty, unsigned long long v); +static void vpush(CType *type); +static int gvtst(int inv, int t); +static void gen_inline_functions(TCCState *s); +static void skip_or_save_block(TokenString **str); +static void gv_dup(void); + +static inline int is_float(int t) +{ + int bt; + bt = t & 0x000f; + return bt == 10 || bt == 9 || bt == 8 || bt == 14; +} + + + + +static int ieee_finite(double d) +{ + int p[4]; + memcpy(p, &d, sizeof(double)); + return ((unsigned)((p[1] | 0x800fffff) + 1)) >> 31; +} + + + + + + + +static void test_lvalue(void) +{ + if (!(vtop->r & 0x0100)) + expect("lvalue"); +} + +static void check_vstack(void) +{ + if (pvtop != vtop) + tcc_error("internal compiler error: vstack leak (%d)", vtop - pvtop); +} +# 154 "tccgen.c" +static void tcc_debug_start(TCCState *s1) +{ + if (s1->do_debug) { + char buf[512]; + + + section_sym = put_elf_sym(symtab_section, 0, 0, + ((((0)) << 4) + (((3)) & 0xf)), 0, + text_section->sh_num, 0); + getcwd(buf, sizeof(buf)); + + + + pstrcat(buf, sizeof(buf), "/"); + put_stabs_r(buf, N_SO, 0, 0, + text_section->data_offset, text_section, section_sym); + put_stabs_r(file->filename, N_SO, 0, 0, + text_section->data_offset, text_section, section_sym); + last_ind = 0; + last_line_num = 0; + } + + + + put_elf_sym(symtab_section, 0, 0, + ((((0)) << 4) + (((4)) & 0xf)), 0, + 0xfff1, file->filename); +} + + +static void tcc_debug_end(TCCState *s1) +{ + if (!s1->do_debug) + return; + put_stabs_r(0, N_SO, 0, 0, + text_section->data_offset, text_section, section_sym); + +} + + +static void tcc_debug_line(TCCState *s1) +{ + if (!s1->do_debug) + return; + if ((last_line_num != file->line_num || last_ind != ind)) { + put_stabn(N_SLINE, 0, file->line_num, ind - func_ind); + last_ind = ind; + last_line_num = file->line_num; + } +} + + +static void tcc_debug_funcstart(TCCState *s1, Sym *sym) +{ + char buf[512]; + + if (!s1->do_debug) + return; + + + + snprintf(buf, sizeof(buf), "%s:%c1", + funcname, sym->type.t & 0x00002000 ? 'f' : 'F'); + put_stabs_r(buf, N_FUN, 0, file->line_num, 0, + cur_text_section, sym->c); + + put_stabn(N_SLINE, 0, file->line_num, 0); + + last_ind = 0; + last_line_num = 0; +} + + +static void tcc_debug_funcend(TCCState *s1, int size) +{ + if (!s1->do_debug) + return; + put_stabn(N_FUN, 0, 0, size); +} + + +static int tccgen_compile(TCCState *s1) +{ + cur_text_section = 0; + funcname = ""; + anon_sym = 0x10000000; + section_sym = 0; + const_wanted = 0; + nocode_wanted = 0x80000000; + + + int_type.t = 3; + char_pointer_type.t = 1; + mk_pointer(&char_pointer_type); + + + + + + + + size_type.t = 0x0800 | 4 | 0x0010; + ptrdiff_type.t = 0x0800 | 4; + + func_old_type.t = 6; + func_old_type.ref = sym_push(0x20000000, &int_type, 0, 0); + func_old_type.ref->f.func_call = 0; + func_old_type.ref->f.func_type = 2; + + tcc_debug_start(s1); +# 273 "tccgen.c" + parse_flags = 0x0001 | 0x0002 | 0x0040; + next(); + decl(0x0030); + gen_inline_functions(s1); + check_vstack(); + + tcc_debug_end(s1); + return 0; +} + + +static Elf64_Sym *elfsym(Sym *s) +{ + if (!s || !s->c) + return 0; + return &((Elf64_Sym *)symtab_section->data)[s->c]; +} + + +static void update_storage(Sym *sym) +{ + Elf64_Sym *esym; + int sym_bind, old_sym_bind; + + esym = elfsym(sym); + if (!esym) + return; + + if (sym->a.visibility) + esym->st_other = (esym->st_other & ~((-1) & 0x03)) + | sym->a.visibility; + + if (sym->type.t & 0x00002000) + sym_bind = 0; + else if (sym->a.weak) + sym_bind = 2; + else + sym_bind = 1; + old_sym_bind = (((unsigned char) (esym->st_info)) >> 4); + if (sym_bind != old_sym_bind) { + esym->st_info = ((((sym_bind)) << 4) + (((((esym->st_info) & 0xf))) & 0xf)); + } +# 332 "tccgen.c" +} + + + + + +static void put_extern_sym2(Sym *sym, int sh_num, + Elf64_Addr value, unsigned long size, + int can_add_underscore) +{ + int sym_type, sym_bind, info, other, t; + Elf64_Sym *esym; + const char *name; + char buf1[256]; + + char buf[32]; + + + if (!sym->c) { + name = get_tok_str(sym->v, 0); + + if (tcc_state->do_bounds_check) { + + + + switch(sym->v) { +# 366 "tccgen.c" + case TOK_memcpy: + case TOK_memmove: + case TOK_memset: + case TOK_strlen: + case TOK_strcpy: + case TOK_alloca: + strcpy(buf, "__bound_"); + strcat(buf, name); + name = buf; + break; + } + } + + t = sym->type.t; + if ((t & 0x000f) == 6) { + sym_type = 2; + } else if ((t & 0x000f) == 0) { + sym_type = 0; + } else { + sym_type = 1; + } + if (t & 0x00002000) + sym_bind = 0; + else + sym_bind = 1; + other = 0; +# 403 "tccgen.c" + if (tcc_state->leading_underscore && can_add_underscore) { + buf1[0] = '_'; + pstrcpy(buf1 + 1, sizeof(buf1) - 1, name); + name = buf1; + } + if (sym->asm_label) + name = get_tok_str(sym->asm_label, 0); + info = ((((sym_bind)) << 4) + (((sym_type)) & 0xf)); + sym->c = put_elf_sym(symtab_section, value, size, info, other, sh_num, name); + } else { + esym = elfsym(sym); + esym->st_value = value; + esym->st_size = size; + esym->st_shndx = sh_num; + } + update_storage(sym); +} + +static void put_extern_sym(Sym *sym, Section *section, + Elf64_Addr value, unsigned long size) +{ + int sh_num = section ? section->sh_num : 0; + put_extern_sym2(sym, sh_num, value, size, 1); +} + + +static void greloca(Section *s, Sym *sym, unsigned long offset, int type, + Elf64_Addr addend) +{ + int c = 0; + + if (nocode_wanted && s == cur_text_section) + return; + + if (sym) { + if (0 == sym->c) + put_extern_sym(sym, 0, 0, 0); + c = sym->c; + } + + + put_elf_reloca(symtab_section, s, offset, type, c, addend); +} +# 456 "tccgen.c" +static Sym *__sym_malloc(void) +{ + Sym *sym_pool, *sym, *last_sym; + int i; + + sym_pool = tcc_malloc((8192 / sizeof(Sym)) * sizeof(Sym)); + dynarray_add(&sym_pools, &nb_sym_pools, sym_pool); + + last_sym = sym_free_first; + sym = sym_pool; + for(i = 0; i < (8192 / sizeof(Sym)); i++) { + sym->next = last_sym; + last_sym = sym; + sym++; + } + sym_free_first = last_sym; + return last_sym; +} + +static inline Sym *sym_malloc(void) +{ + Sym *sym; + + sym = sym_free_first; + if (!sym) + sym = __sym_malloc(); + sym_free_first = sym->next; + return sym; + + + + +} + +static inline void sym_free(Sym *sym) +{ + + sym->next = sym_free_first; + sym_free_first = sym; + + + +} + + +static Sym *sym_push2(Sym **ps, int v, int t, int c) +{ + Sym *s; + + s = sym_malloc(); + memset(s, 0, sizeof *s); + s->v = v; + s->type.t = t; + s->c = c; + + s->prev = *ps; + *ps = s; + return s; +} + + + +static Sym *sym_find2(Sym *s, int v) +{ + while (s) { + if (s->v == v) + return s; + else if (s->v == -1) + return 0; + s = s->prev; + } + return 0; +} + + +static inline Sym *struct_find(int v) +{ + v -= 256; + if ((unsigned)v >= (unsigned)(tok_ident - 256)) + return 0; + return table_ident[v]->sym_struct; +} + + +static inline Sym *sym_find(int v) +{ + v -= 256; + if ((unsigned)v >= (unsigned)(tok_ident - 256)) + return 0; + return table_ident[v]->sym_identifier; +} + + +static Sym *sym_push(int v, CType *type, int r, int c) +{ + Sym *s, **ps; + TokenSym *ts; + + if (local_stack) + ps = &local_stack; + else + ps = &global_stack; + s = sym_push2(ps, v, type->t, c); + s->type.ref = type->ref; + s->r = r; + + + if (!(v & 0x20000000) && (v & ~0x40000000) < 0x10000000) { + + ts = table_ident[(v & ~0x40000000) - 256]; + if (v & 0x40000000) + ps = &ts->sym_struct; + else + ps = &ts->sym_identifier; + s->prev_tok = *ps; + *ps = s; + s->sym_scope = local_scope; + if (s->prev_tok && s->prev_tok->sym_scope == s->sym_scope) + tcc_error("redeclaration of '%s'", + get_tok_str(v & ~0x40000000, 0)); + } + return s; +} + + +static Sym *global_identifier_push(int v, int t, int c) +{ + Sym *s, **ps; + s = sym_push2(&global_stack, v, t, c); + + if (v < 0x10000000) { + ps = &table_ident[v - 256]->sym_identifier; + + + while (*ps != 0 && (*ps)->sym_scope) + ps = &(*ps)->prev_tok; + s->prev_tok = *ps; + *ps = s; + } + return s; +} + + + +static void sym_pop(Sym **ptop, Sym *b, int keep) +{ + Sym *s, *ss, **ps; + TokenSym *ts; + int v; + + s = *ptop; + while(s != b) { + ss = s->prev; + v = s->v; + + + if (!(v & 0x20000000) && (v & ~0x40000000) < 0x10000000) { + ts = table_ident[(v & ~0x40000000) - 256]; + if (v & 0x40000000) + ps = &ts->sym_struct; + else + ps = &ts->sym_identifier; + *ps = s->prev_tok; + } + if (!keep) + sym_free(s); + s = ss; + } + if (!keep) + *ptop = b; +} + + + +static void vsetc(CType *type, int r, CValue *vc) +{ + int v; + + if (vtop >= (__vstack + 1) + (256 - 1)) + tcc_error("memory full (vstack)"); +# 649 "tccgen.c" + if (vtop >= (__vstack + 1) && !nocode_wanted) { + v = vtop->r & 0x003f; + if (v == 0x0033 || (v & ~1) == 0x0034) + gv(0x0001); + } + + vtop++; + vtop->type = *type; + vtop->r = r; + vtop->r2 = 0x0030; + vtop->c = *vc; + vtop->sym = 0; +} + +static void vswap(void) +{ + SValue tmp; + + if (vtop >= (__vstack + 1) && !nocode_wanted) { + int v = vtop->r & 0x003f; + if (v == 0x0033 || (v & ~1) == 0x0034) + gv(0x0001); + } + tmp = vtop[0]; + vtop[0] = vtop[-1]; + vtop[-1] = tmp; +} + + +static void vpop(void) +{ + int v; + v = vtop->r & 0x003f; + + + if (v == TREG_ST0) { + o(0xd8dd); + } else + + if (v == 0x0034 || v == 0x0035) { + + gsym(vtop->c.i); + } + vtop--; +} + + +static void vpush(CType *type) +{ + vset(type, 0x0030, 0); +} + + +static void vpushi(int v) +{ + CValue cval; + cval.i = v; + vsetc(&int_type, 0x0030, &cval); +} + + +static void vpushs(Elf64_Addr v) +{ + CValue cval; + cval.i = v; + vsetc(&size_type, 0x0030, &cval); +} + + +static void vpush64(int ty, unsigned long long v) +{ + CValue cval; + CType ctype; + ctype.t = ty; + ctype.ref = 0; + cval.i = v; + vsetc(&ctype, 0x0030, &cval); +} + + +static inline void vpushll(long long v) +{ + vpush64(4, v); +} + +static void vset(CType *type, int r, int v) +{ + CValue cval; + + cval.i = v; + vsetc(type, r, &cval); +} + +static void vseti(int r, int v) +{ + CType type; + type.t = 3; + type.ref = 0; + vset(&type, r, v); +} + +static void vpushv(SValue *v) +{ + if (vtop >= (__vstack + 1) + (256 - 1)) + tcc_error("memory full (vstack)"); + vtop++; + *vtop = *v; +} + +static void vdup(void) +{ + vpushv(vtop); +} + + + + +static void vrotb(int n) +{ + int i; + SValue tmp; + + tmp = vtop[-n + 1]; + for(i=-n+1;i!=0;i++) + vtop[i] = vtop[i+1]; + vtop[0] = tmp; +} + + + + +static void vrote(SValue *e, int n) +{ + int i; + SValue tmp; + + tmp = *e; + for(i = 0;i < n - 1; i++) + e[-i] = e[-i - 1]; + e[-n + 1] = tmp; +} + + + + +static void vrott(int n) +{ + vrote(vtop, n); +} + + +static inline void vpushsym(CType *type, Sym *sym) +{ + CValue cval; + cval.i = 0; + vsetc(type, 0x0030 | 0x0200, &cval); + vtop->sym = sym; +} + + +static Sym *get_sym_ref(CType *type, Section *sec, unsigned long offset, unsigned long size) +{ + int v; + Sym *sym; + + v = anon_sym++; + sym = global_identifier_push(v, type->t | 0x00002000, 0); + sym->type.ref = type->ref; + sym->r = 0x0030 | 0x0200; + put_extern_sym(sym, sec, offset, size); + return sym; +} + + +static void vpush_ref(CType *type, Section *sec, unsigned long offset, unsigned long size) +{ + vpushsym(type, get_sym_ref(type, sec, offset, size)); +} + + +static Sym *external_global_sym(int v, CType *type, int r) +{ + Sym *s; + + s = sym_find(v); + if (!s) { + + s = global_identifier_push(v, type->t | 0x00001000, 0); + s->type.ref = type->ref; + s->r = r | 0x0030 | 0x0200; + } else if ((((s)->type.t & (0x000f | (0 | 0x0010))) == (0 | 0x0010))) { + s->type.t = type->t | (s->type.t & 0x00001000); + s->type.ref = type->ref; + update_storage(s); + } + return s; +} + + +static void patch_type(Sym *sym, CType *type) +{ + if (!(type->t & 0x00001000)) { + if (!(sym->type.t & 0x00001000)) + tcc_error("redefinition of '%s'", get_tok_str(sym->v, 0)); + sym->type.t &= ~0x00001000; + } + + if ((((sym)->type.t & (0x000f | (0 | 0x0010))) == (0 | 0x0010))) { + + sym->type.t = type->t & (sym->type.t | ~0x00002000); + sym->type.ref = type->ref; + } + + if (!is_compatible_types(&sym->type, type)) { + tcc_error("incompatible types for redefinition of '%s'", + get_tok_str(sym->v, 0)); + + } else if ((sym->type.t & 0x000f) == 6) { + int static_proto = sym->type.t & 0x00002000; + + if ((type->t & 0x00002000) && !static_proto && !(type->t & 0x00008000)) + tcc_warning("static storage ignored for redefinition of '%s'", + get_tok_str(sym->v, 0)); + + if (0 == (type->t & 0x00001000)) { + + sym->type.t = (type->t & ~0x00002000) | static_proto; + if (type->t & 0x00008000) + sym->type.t = type->t; + sym->type.ref = type->ref; + } + + } else { + if ((sym->type.t & 0x0040) && type->ref->c >= 0) { + + if (sym->type.ref->c < 0) + sym->type.ref->c = type->ref->c; + else if (sym->type.ref->c != type->ref->c) + tcc_error("conflicting type for '%s'", get_tok_str(sym->v, 0)); + } + if ((type->t ^ sym->type.t) & 0x00002000) + tcc_warning("storage mismatch for redefinition of '%s'", + get_tok_str(sym->v, 0)); + } +} + + + +static void patch_storage(Sym *sym, AttributeDef *ad, CType *type) +{ + if (type) + patch_type(sym, type); + + + + + + + + sym->a.weak |= ad->a.weak; + if (ad->a.visibility) { + int vis = sym->a.visibility; + int vis2 = ad->a.visibility; + if (vis == 0) + vis = vis2; + else if (vis2 != 0) + vis = (vis < vis2) ? vis : vis2; + sym->a.visibility = vis; + } + if (ad->a.aligned) + sym->a.aligned = ad->a.aligned; + if (ad->asm_label) + sym->asm_label = ad->asm_label; + update_storage(sym); +} + + +static Sym *external_sym(int v, CType *type, int r, AttributeDef *ad) +{ + Sym *s; + s = sym_find(v); + if (!s) { + + s = sym_push(v, type, r | 0x0030 | 0x0200, 0); + s->type.t |= 0x00001000; + s->a = ad->a; + s->sym_scope = 0; + } else { + if (s->type.ref == func_old_type.ref) { + s->type.ref = type->ref; + s->r = r | 0x0030 | 0x0200; + s->type.t |= 0x00001000; + } + patch_storage(s, ad, type); + } + return s; +} + + +static void vpush_global_sym(CType *type, int v) +{ + vpushsym(type, external_global_sym(v, type, 0)); +} + + +static void save_regs(int n) +{ + SValue *p, *p1; + for(p = (__vstack + 1), p1 = vtop - n; p <= p1; p++) + save_reg(p->r); +} + + +static void save_reg(int r) +{ + save_reg_upstack(r, 0); +} + + + +static void save_reg_upstack(int r, int n) +{ + int l, saved, size, align; + SValue *p, *p1, sv; + CType *type; + + if ((r &= 0x003f) >= 0x0030) + return; + if (nocode_wanted) + return; + + + saved = 0; + l = 0; + for(p = (__vstack + 1), p1 = vtop - n; p <= p1; p++) { + if ((p->r & 0x003f) == r || + ((p->type.t & 0x000f) == 4 && (p->r2 & 0x003f) == r)) { + + if (!saved) { + + r = p->r & 0x003f; + + type = &p->type; + if ((p->r & 0x0100) || + (!is_float(type->t) && (type->t & 0x000f) != 4)) + + type = &char_pointer_type; + + + + size = type_size(type, &align); + loc = (loc - size) & -align; + sv.type.t = type->t; + sv.r = 0x0032 | 0x0100; + sv.c.i = loc; + store(r, &sv); + + + if (r == TREG_ST0) { + o(0xd8dd); + } +# 1018 "tccgen.c" + l = loc; + saved = 1; + } + + if (p->r & 0x0100) { + + + + p->r = (p->r & ~(0x003f | 0x8000)) | 0x0031; + } else { + p->r = lvalue_type(p->type.t) | 0x0032; + } + p->r2 = 0x0030; + p->c.i = l; + } + } +} +# 1062 "tccgen.c" +static int get_reg(int rc) +{ + int r; + SValue *p; + + + for(r=0;r<25;r++) { + if (reg_classes[r] & rc) { + if (nocode_wanted) + return r; + for(p=(__vstack + 1);p<=vtop;p++) { + if ((p->r & 0x003f) == r || + (p->r2 & 0x003f) == r) + goto notfound; + } + return r; + } + notfound: ; + } + + + + + for(p=(__vstack + 1);p<=vtop;p++) { + + r = p->r2 & 0x003f; + if (r < 0x0030 && (reg_classes[r] & rc)) + goto save_found; + r = p->r & 0x003f; + if (r < 0x0030 && (reg_classes[r] & rc)) { + save_found: + save_reg(r); + return r; + } + } + + return -1; +} + + + +static void move_reg(int r, int s, int t) +{ + SValue sv; + + if (r != s) { + save_reg(r); + sv.type.t = t; + sv.type.ref = 0; + sv.r = s; + sv.c.i = 0; + load(r, &sv); + } +} + + +static void gaddrof(void) +{ + vtop->r &= ~0x0100; + + if ((vtop->r & 0x003f) == 0x0031) + vtop->r = (vtop->r & ~(0x003f | (0x1000 | 0x2000 | 0x4000))) | 0x0032 | 0x0100; + + +} + + + +static void gbound(void) +{ + int lval_type; + CType type1; + + vtop->r &= ~0x0800; + + if (vtop->r & 0x0100) { + + if (!(vtop->r & 0x8000)) { + lval_type = vtop->r & ((0x1000 | 0x2000 | 0x4000) | 0x0100); + + type1 = vtop->type; + vtop->type.t = 5; + gaddrof(); + vpushi(0); + gen_bounded_ptr_add(); + vtop->r |= lval_type; + vtop->type = type1; + } + + gen_bounded_ptr_deref(); + } +} + + +static void incr_bf_adr(int o) +{ + vtop->type = char_pointer_type; + gaddrof(); + vpushi(o); + gen_op('+'); + vtop->type.t = (vtop->type.t & ~(0x000f|0x0020)) + | (1|0x0010); + vtop->r = (vtop->r & ~(0x1000 | 0x2000 | 0x4000)) + | (0x1000|0x4000|0x0100); +} + + +static void load_packed_bf(CType *type, int bit_pos, int bit_size) +{ + int n, o, bits; + save_reg_upstack(vtop->r, 1); + vpush64(type->t & 0x000f, 0); + bits = 0, o = bit_pos >> 3, bit_pos &= 7; + do { + vswap(); + incr_bf_adr(o); + vdup(); + n = 8 - bit_pos; + if (n > bit_size) + n = bit_size; + if (bit_pos) + vpushi(bit_pos), gen_op(0xc9), bit_pos = 0; + if (n < 8) + vpushi((1 << n) - 1), gen_op('&'); + gen_cast(type); + if (bits) + vpushi(bits), gen_op(0x01); + vrotb(3); + gen_op('|'); + bits += n, bit_size -= n, o = 1; + } while (bit_size); + vswap(), vpop(); + if (!(type->t & 0x0010)) { + n = ((type->t & 0x000f) == 4 ? 64 : 32) - bits; + vpushi(n), gen_op(0x01); + vpushi(n), gen_op(0x02); + } +} + + +static void store_packed_bf(int bit_pos, int bit_size) +{ + int bits, n, o, m, c; + + c = (vtop->r & (0x003f | 0x0100 | 0x0200)) == 0x0030; + vswap(); + save_reg_upstack(vtop->r, 1); + bits = 0, o = bit_pos >> 3, bit_pos &= 7; + do { + incr_bf_adr(o); + vswap(); + c ? vdup() : gv_dup(); + vrott(3); + if (bits) + vpushi(bits), gen_op(0xc9); + if (bit_pos) + vpushi(bit_pos), gen_op(0x01); + n = 8 - bit_pos; + if (n > bit_size) + n = bit_size; + if (n < 8) { + m = ((1 << n) - 1) << bit_pos; + vpushi(m), gen_op('&'); + vpushv(vtop-1); + vpushi(m & 0x80 ? ~m & 0x7f : ~m); + gen_op('&'); + gen_op('|'); + } + vdup(), vtop[-1] = vtop[-2]; + vstore(), vpop(); + bits += n, bit_size -= n, bit_pos = 0, o = 1; + } while (bit_size); + vpop(), vpop(); +} + +static int adjust_bf(SValue *sv, int bit_pos, int bit_size) +{ + int t; + if (0 == sv->type.ref) + return 0; + t = sv->type.ref->auxtype; + if (t != -1 && t != 7) { + sv->type.t = (sv->type.t & ~0x000f) | t; + sv->r = (sv->r & ~(0x1000 | 0x2000 | 0x4000)) | lvalue_type(sv->type.t); + } + return t; +} + + + + +static int gv(int rc) +{ + int r, bit_pos, bit_size, size, align, rc2; + + + if (vtop->type.t & 0x0080) { + CType type; + + bit_pos = (((vtop->type.t) >> 20) & 0x3f); + bit_size = (((vtop->type.t) >> (20 + 6)) & 0x3f); + + vtop->type.t &= ~(((1 << (6+6)) - 1) << 20 | 0x0080); + + type.ref = 0; + type.t = vtop->type.t & 0x0010; + if ((vtop->type.t & 0x000f) == 11) + type.t |= 0x0010; + + r = adjust_bf(vtop, bit_pos, bit_size); + + if ((vtop->type.t & 0x000f) == 4) + type.t |= 4; + else + type.t |= 3; + + if (r == 7) { + load_packed_bf(&type, bit_pos, bit_size); + } else { + int bits = (type.t & 0x000f) == 4 ? 64 : 32; + + gen_cast(&type); + + vpushi(bits - (bit_pos + bit_size)); + gen_op(0x01); + vpushi(bits - bit_size); + + gen_op(0x02); + } + r = gv(rc); + } else { + if (is_float(vtop->type.t) && + (vtop->r & (0x003f | 0x0100)) == 0x0030) { + unsigned long offset; + + + size = type_size(&vtop->type, &align); + if ((nocode_wanted > 0)) + size = 0, align = 1; + offset = section_add(data_section, size, align); + vpush_ref(&vtop->type, data_section, offset, size); + vswap(); + init_putv(&vtop->type, data_section, offset); + vtop->r |= 0x0100; + } + + if (vtop->r & 0x0800) + gbound(); + + + r = vtop->r & 0x003f; + rc2 = (rc & 0x0002) ? 0x0002 : 0x0001; + + if (rc == 0x0004) + rc2 = 0x0010; + + else if (rc == 0x1000) + rc2 = 0x2000; + + + + + + + if (r >= 0x0030 + || (vtop->r & 0x0100) + || !(reg_classes[r] & rc) + + || ((vtop->type.t & 0x000f) == 13 && !(reg_classes[vtop->r2] & rc2)) + || ((vtop->type.t & 0x000f) == 14 && !(reg_classes[vtop->r2] & rc2)) + + + + ) + { + r = get_reg(rc); + + if (((vtop->type.t & 0x000f) == 13) || ((vtop->type.t & 0x000f) == 14)) { + int addr_type = 4, load_size = 8, load_type = ((vtop->type.t & 0x000f) == 13) ? 4 : 9; + + + + + + int r2, original_type; + original_type = vtop->type.t; +# 1360 "tccgen.c" + if (vtop->r & 0x0100) { +# 1369 "tccgen.c" + save_reg_upstack(vtop->r, 1); + + + vtop->type.t = load_type; + load(r, vtop); + vdup(); + vtop[-1].r = r; + + vtop->type.t = addr_type; + gaddrof(); + vpushi(load_size); + gen_op('+'); + vtop->r |= 0x0100; + vtop->type.t = load_type; + } else { + + load(r, vtop); + vdup(); + vtop[-1].r = r; + vtop->r = vtop[-1].r2; + } + + + r2 = get_reg(rc2); + load(r2, vtop); + vpop(); + + vtop->r2 = r2; + vtop->type.t = original_type; + } else if ((vtop->r & 0x0100) && !is_float(vtop->type.t)) { + int t1, t; + + + t = vtop->type.t; + t1 = t; + + if (vtop->r & 0x1000) + t = 1; + else if (vtop->r & 0x2000) + t = 2; + if (vtop->r & 0x4000) + t |= 0x0010; + vtop->type.t = t; + load(r, vtop); + + vtop->type.t = t1; + } else { + + load(r, vtop); + } + } + vtop->r = r; + + + + + + } + return r; +} + + +static void gv2(int rc1, int rc2) +{ + int v; + + + + + v = vtop[0].r & 0x003f; + if (v != 0x0033 && (v & ~1) != 0x0034 && rc1 <= rc2) { + vswap(); + gv(rc1); + vswap(); + gv(rc2); + + if ((vtop[-1].r & 0x003f) >= 0x0030) { + vswap(); + gv(rc1); + vswap(); + } + } else { + gv(rc2); + vswap(); + gv(rc1); + vswap(); + + if ((vtop[0].r & 0x003f) >= 0x0030) { + gv(rc2); + } + } +} + + + +static int rc_fret(int t) +{ + + if (t == 10) { + return 0x0080; + } + + return 0x1000; +} + + + +static int reg_fret(int t) +{ + + if (t == 10) { + return TREG_ST0; + } + + return TREG_XMM0; +} +# 1550 "tccgen.c" +static void gv_dup(void) +{ + int rc, t, r, r1; + SValue sv; + + t = vtop->type.t; +# 1577 "tccgen.c" + { + + rc = 0x0001; + sv.type.t = 3; + if (is_float(t)) { + rc = 0x0002; + + if ((t & 0x000f) == 10) { + rc = 0x0080; + } + + sv.type.t = t; + } + r = gv(rc); + r1 = get_reg(rc); + sv.r = r; + sv.c.i = 0; + load(r1, &sv); + vdup(); + + if (r != r1) + vtop->r = r1; + } +} + + + + +static int gvtst(int inv, int t) +{ + int v = vtop->r & 0x003f; + if (v != 0x0033 && v != 0x0034 && v != 0x0035) { + vpushi(0); + gen_op(0x95); + } + if ((vtop->r & (0x003f | 0x0100 | 0x0200)) == 0x0030) { + + if ((vtop->c.i != 0) != inv) + t = gjmp(t); + vtop--; + return t; + } + return gtst(inv, t); +} +# 1851 "tccgen.c" +static uint64_t gen_opic_sdiv(uint64_t a, uint64_t b) +{ + uint64_t x = (a >> 63 ? -a : a) / (b >> 63 ? -b : b); + return (a ^ b) >> 63 ? -x : x; +} + +static int gen_opic_lt(uint64_t a, uint64_t b) +{ + return (a ^ (uint64_t)1 << 63) < (b ^ (uint64_t)1 << 63); +} + + + +static void gen_opic(int op) +{ + SValue *v1 = vtop - 1; + SValue *v2 = vtop; + int t1 = v1->type.t & 0x000f; + int t2 = v2->type.t & 0x000f; + int c1 = (v1->r & (0x003f | 0x0100 | 0x0200)) == 0x0030; + int c2 = (v2->r & (0x003f | 0x0100 | 0x0200)) == 0x0030; + uint64_t l1 = c1 ? v1->c.i : 0; + uint64_t l2 = c2 ? v2->c.i : 0; + int shm = (t1 == 4) ? 63 : 31; + + if (t1 != 4 && (8 != 8 || t1 != 5)) + l1 = ((uint32_t)l1 | + (v1->type.t & 0x0010 ? 0 : -(l1 & 0x80000000))); + if (t2 != 4 && (8 != 8 || t2 != 5)) + l2 = ((uint32_t)l2 | + (v2->type.t & 0x0010 ? 0 : -(l2 & 0x80000000))); + + if (c1 && c2) { + switch(op) { + case '+': l1 += l2; break; + case '-': l1 -= l2; break; + case '&': l1 &= l2; break; + case '^': l1 ^= l2; break; + case '|': l1 |= l2; break; + case '*': l1 *= l2; break; + + case 0xb2: + case '/': + case '%': + case 0xb0: + case 0xb1: + + if (l2 == 0) { + if (const_wanted) + tcc_error("division by zero in constant"); + goto general_case; + } + switch(op) { + default: l1 = gen_opic_sdiv(l1, l2); break; + case '%': l1 = l1 - l2 * gen_opic_sdiv(l1, l2); break; + case 0xb0: l1 = l1 / l2; break; + case 0xb1: l1 = l1 % l2; break; + } + break; + case 0x01: l1 <<= (l2 & shm); break; + case 0xc9: l1 >>= (l2 & shm); break; + case 0x02: + l1 = (l1 >> 63) ? ~(~l1 >> (l2 & shm)) : l1 >> (l2 & shm); + break; + + case 0x92: l1 = l1 < l2; break; + case 0x93: l1 = l1 >= l2; break; + case 0x94: l1 = l1 == l2; break; + case 0x95: l1 = l1 != l2; break; + case 0x96: l1 = l1 <= l2; break; + case 0x97: l1 = l1 > l2; break; + case 0x9c: l1 = gen_opic_lt(l1, l2); break; + case 0x9d: l1 = !gen_opic_lt(l1, l2); break; + case 0x9e: l1 = !gen_opic_lt(l2, l1); break; + case 0x9f: l1 = gen_opic_lt(l2, l1); break; + + case 0xa0: l1 = l1 && l2; break; + case 0xa1: l1 = l1 || l2; break; + default: + goto general_case; + } + if (t1 != 4 && (8 != 8 || t1 != 5)) + l1 = ((uint32_t)l1 | + (v1->type.t & 0x0010 ? 0 : -(l1 & 0x80000000))); + v1->c.i = l1; + vtop--; + } else { + + if (c1 && (op == '+' || op == '&' || op == '^' || + op == '|' || op == '*')) { + vswap(); + c2 = c1; + l2 = l1; + } + if (!const_wanted && + c1 && ((l1 == 0 && + (op == 0x01 || op == 0xc9 || op == 0x02)) || + (l1 == -1 && op == 0x02))) { + + vtop--; + } else if (!const_wanted && + c2 && ((l2 == 0 && (op == '&' || op == '*')) || + (op == '|' && + (l2 == -1 || (l2 == 0xFFFFFFFF && t2 != 4))) || + (l2 == 1 && (op == '%' || op == 0xb1)))) { + + if (l2 == 1) + vtop->c.i = 0; + vswap(); + vtop--; + } else if (c2 && (((op == '*' || op == '/' || op == 0xb0 || + op == 0xb2) && + l2 == 1) || + ((op == '+' || op == '-' || op == '|' || op == '^' || + op == 0x01 || op == 0xc9 || op == 0x02) && + l2 == 0) || + (op == '&' && + (l2 == -1 || (l2 == 0xFFFFFFFF && t2 != 4))))) { + + vtop--; + } else if (c2 && (op == '*' || op == 0xb2 || op == 0xb0)) { + + if (l2 > 0 && (l2 & (l2 - 1)) == 0) { + int n = -1; + while (l2) { + l2 >>= 1; + n++; + } + vtop->c.i = n; + if (op == '*') + op = 0x01; + else if (op == 0xb2) + op = 0x02; + else + op = 0xc9; + } + goto general_case; + } else if (c2 && (op == '+' || op == '-') && + (((vtop[-1].r & (0x003f | 0x0100 | 0x0200)) == (0x0030 | 0x0200)) + || (vtop[-1].r & (0x003f | 0x0100)) == 0x0032)) { + + if (op == '-') + l2 = -l2; + l2 += vtop[-1].c.i; + + + if ((int)l2 != l2) + goto general_case; + vtop--; + vtop->c.i = l2; + } else { + general_case: + + if (t1 == 4 || t2 == 4 || + (8 == 8 && (t1 == 5 || t2 == 5))) + gen_opl(op); + else + gen_opi(op); + } + } +} + + +static void gen_opif(int op) +{ + int c1, c2; + SValue *v1, *v2; + + + + + long double f1, f2; + + v1 = vtop - 1; + v2 = vtop; + + c1 = (v1->r & (0x003f | 0x0100 | 0x0200)) == 0x0030; + c2 = (v2->r & (0x003f | 0x0100 | 0x0200)) == 0x0030; + if (c1 && c2) { + if (v1->type.t == 8) { + f1 = v1->c.f; + f2 = v2->c.f; + } else if (v1->type.t == 9) { + f1 = v1->c.d; + f2 = v2->c.d; + } else { + f1 = v1->c.ld; + f2 = v2->c.ld; + } + + + + if (!ieee_finite(f1) || !ieee_finite(f2)) + goto general_case; + + switch(op) { + case '+': f1 += f2; break; + case '-': f1 -= f2; break; + case '*': f1 *= f2; break; + case '/': + if (f2 == 0.0) { + if (const_wanted) + tcc_error("division by zero in constant"); + goto general_case; + } + f1 /= f2; + break; + + default: + goto general_case; + } + + if (v1->type.t == 8) { + v1->c.f = f1; + } else if (v1->type.t == 9) { + v1->c.d = f1; + } else { + v1->c.ld = f1; + } + vtop--; + } else { + general_case: + gen_opf(op); + } +} + +static int pointed_size(CType *type) +{ + int align; + return type_size(pointed_type(type), &align); +} + +static void vla_runtime_pointed_size(CType *type) +{ + int align; + vla_runtime_type_size(pointed_type(type), &align); +} + +static inline int is_null_pointer(SValue *p) +{ + if ((p->r & (0x003f | 0x0100 | 0x0200)) != 0x0030) + return 0; + return ((p->type.t & 0x000f) == 3 && (uint32_t)p->c.i == 0) || + ((p->type.t & 0x000f) == 4 && p->c.i == 0) || + ((p->type.t & 0x000f) == 5 && + (8 == 4 ? (uint32_t)p->c.i == 0 : p->c.i == 0)); +} + +static inline int is_integer_btype(int bt) +{ + return (bt == 1 || bt == 2 || + bt == 3 || bt == 4); +} + + +static void check_comparison_pointer_types(SValue *p1, SValue *p2, int op) +{ + CType *type1, *type2, tmp_type1, tmp_type2; + int bt1, bt2; + + + if (is_null_pointer(p1) || is_null_pointer(p2)) + return; + type1 = &p1->type; + type2 = &p2->type; + bt1 = type1->t & 0x000f; + bt2 = type2->t & 0x000f; + + if ((is_integer_btype(bt1) || is_integer_btype(bt2)) && op != '-') { + if (op != 0xa1 && op != 0xa0 ) + tcc_warning("comparison between pointer and integer"); + return; + } + + + if (bt1 == 5) { + type1 = pointed_type(type1); + } else if (bt1 != 6) + goto invalid_operands; + + if (bt2 == 5) { + type2 = pointed_type(type2); + } else if (bt2 != 6) { + invalid_operands: + tcc_error("invalid operands to binary %s", get_tok_str(op, 0)); + } + if ((type1->t & 0x000f) == 0 || + (type2->t & 0x000f) == 0) + return; + tmp_type1 = *type1; + tmp_type2 = *type2; + tmp_type1.t &= ~(0x0020 | 0x0010 | 0x0100 | 0x0200); + tmp_type2.t &= ~(0x0020 | 0x0010 | 0x0100 | 0x0200); + if (!is_compatible_types(&tmp_type1, &tmp_type2)) { + + if (op == '-') + goto invalid_operands; + else + tcc_warning("comparison of distinct pointer types lacks a cast"); + } +} + + +static void gen_op(int op) +{ + int u, t1, t2, bt1, bt2, t; + CType type1; + +redo: + t1 = vtop[-1].type.t; + t2 = vtop[0].type.t; + bt1 = t1 & 0x000f; + bt2 = t2 & 0x000f; + + if (bt1 == 7 || bt2 == 7) { + tcc_error("operation on a struct"); + } else if (bt1 == 6 || bt2 == 6) { + if (bt2 == 6) { + mk_pointer(&vtop->type); + gaddrof(); + } + if (bt1 == 6) { + vswap(); + mk_pointer(&vtop->type); + gaddrof(); + vswap(); + } + goto redo; + } else if (bt1 == 5 || bt2 == 5) { + + + if (op >= 0x92 && op <= 0xa1) { + check_comparison_pointer_types(vtop - 1, vtop, op); + + + t = 4 | 0x0010; + + + + goto std_op; + } + + if (bt1 == 5 && bt2 == 5) { + if (op != '-') + tcc_error("cannot use pointers here"); + check_comparison_pointer_types(vtop - 1, vtop, op); + + if (vtop[-1].type.t & 0x0400) { + vla_runtime_pointed_size(&vtop[-1].type); + } else { + vpushi(pointed_size(&vtop[-1].type)); + } + vrott(3); + gen_opic(op); + vtop->type.t = ptrdiff_type.t; + vswap(); + gen_op(0xb2); + } else { + + if (op != '-' && op != '+') + tcc_error("cannot use pointers here"); + + if (bt2 == 5) { + vswap(); + t = t1, t1 = t2, t2 = t; + } + + + + + + type1 = vtop[-1].type; + type1.t &= ~0x0040; + if (vtop[-1].type.t & 0x0400) + vla_runtime_pointed_size(&vtop[-1].type); + else { + u = pointed_size(&vtop[-1].type); + if (u < 0) + tcc_error("unknown array element size"); + + vpushll(u); + + + + + } + gen_op('*'); +# 2267 "tccgen.c" + { + gen_opic(op); + } + + vtop->type = type1; + } + } else if (is_float(bt1) || is_float(bt2)) { + + if (bt1 == 10 || bt2 == 10) { + t = 10; + } else if (bt1 == 9 || bt2 == 9) { + t = 9; + } else { + t = 8; + } + + if (op != '+' && op != '-' && op != '*' && op != '/' && + (op < 0x92 || op > 0x9f)) + tcc_error("invalid operands for binary operation"); + goto std_op; + } else if (op == 0xc9 || op == 0x02 || op == 0x01) { + t = bt1 == 4 ? 4 : 3; + if ((t1 & (0x000f | 0x0010 | 0x0080)) == (t | 0x0010)) + t |= 0x0010; + t |= (0x0800 & t1); + goto std_op; + } else if (bt1 == 4 || bt2 == 4) { + + t = 4 | 0x0800; + if (bt1 == 4) + t &= t1; + if (bt2 == 4) + t &= t2; + + if ((t1 & (0x000f | 0x0010 | 0x0080)) == (4 | 0x0010) || + (t2 & (0x000f | 0x0010 | 0x0080)) == (4 | 0x0010)) + t |= 0x0010; + goto std_op; + } else { + + t = 3 | (0x0800 & (t1 | t2)); + + if ((t1 & (0x000f | 0x0010 | 0x0080)) == (3 | 0x0010) || + (t2 & (0x000f | 0x0010 | 0x0080)) == (3 | 0x0010)) + t |= 0x0010; + std_op: + + + if (t & 0x0010) { + if (op == 0x02) + op = 0xc9; + else if (op == '/') + op = 0xb0; + else if (op == '%') + op = 0xb1; + else if (op == 0x9c) + op = 0x92; + else if (op == 0x9f) + op = 0x97; + else if (op == 0x9e) + op = 0x96; + else if (op == 0x9d) + op = 0x93; + } + vswap(); + type1.t = t; + type1.ref = 0; + gen_cast(&type1); + vswap(); + + + if (op == 0xc9 || op == 0x02 || op == 0x01) + type1.t = 3; + gen_cast(&type1); + if (is_float(t)) + gen_opif(op); + else + gen_opic(op); + if (op >= 0x92 && op <= 0x9f) { + + vtop->type.t = 3; + } else { + vtop->type.t = t; + } + } + + if (vtop->r & 0x0100) + gv(is_float(vtop->type.t & 0x000f) ? 0x0002 : 0x0001); +} + + + +static void gen_cvt_itof1(int t) +{ + + + + if ((vtop->type.t & (0x000f | 0x0010)) == + (4 | 0x0010)) { + + if (t == 8) + vpush_global_sym(&func_old_type, TOK___floatundisf); + + else if (t == 10) + vpush_global_sym(&func_old_type, TOK___floatundixf); + + else + vpush_global_sym(&func_old_type, TOK___floatundidf); + vrott(2); + gfunc_call(1); + vpushi(0); + vtop->r = reg_fret(t); + } else { + gen_cvt_itof(t); + } + +} + + + +static void gen_cvt_ftoi1(int t) +{ + + + + int st; + + if (t == (4 | 0x0010)) { + + st = vtop->type.t & 0x000f; + if (st == 8) + vpush_global_sym(&func_old_type, TOK___fixunssfdi); + + else if (st == 10) + vpush_global_sym(&func_old_type, TOK___fixunsxfdi); + + else + vpush_global_sym(&func_old_type, TOK___fixunsdfdi); + vrott(2); + gfunc_call(1); + vpushi(0); + vtop->r = TREG_RAX; + vtop->r2 = TREG_RDX; + } else { + gen_cvt_ftoi(t); + } + +} + + +static void force_charshort_cast(int t) +{ + int bits, dbt; + + + if ((nocode_wanted & 0xC0000000)) + return; + + dbt = t & 0x000f; + + if (dbt == 1) + bits = 8; + else + bits = 16; + if (t & 0x0010) { + vpushi((1 << bits) - 1); + gen_op('&'); + } else { + if ((vtop->type.t & 0x000f) == 4) + bits = 64 - bits; + else + bits = 32 - bits; + vpushi(bits); + gen_op(0x01); + + + + vtop->type.t &= ~0x0010; + vpushi(bits); + gen_op(0x02); + } +} + + +static void gen_cast_s(int t) +{ + CType type; + type.t = t; + type.ref = 0; + gen_cast(&type); +} + +static void gen_cast(CType *type) +{ + int sbt, dbt, sf, df, c, p; + + + + + if (vtop->r & 0x0400) { + vtop->r &= ~0x0400; + force_charshort_cast(vtop->type.t); + } + + + if (vtop->type.t & 0x0080) { + gv(0x0001); + } + + dbt = type->t & (0x000f | 0x0010); + sbt = vtop->type.t & (0x000f | 0x0010); + + if (sbt != dbt) { + sf = is_float(sbt); + df = is_float(dbt); + c = (vtop->r & (0x003f | 0x0100 | 0x0200)) == 0x0030; + p = (vtop->r & (0x003f | 0x0100 | 0x0200)) == (0x0030 | 0x0200); + + + + if (c) { + + + if (sbt == 8) + vtop->c.ld = vtop->c.f; + else if (sbt == 9) + vtop->c.ld = vtop->c.d; + + if (df) { + if ((sbt & 0x000f) == 4) { + if ((sbt & 0x0010) || !(vtop->c.i >> 63)) + vtop->c.ld = vtop->c.i; + else + vtop->c.ld = -(long double)-vtop->c.i; + } else if(!sf) { + if ((sbt & 0x0010) || !(vtop->c.i >> 31)) + vtop->c.ld = (uint32_t)vtop->c.i; + else + vtop->c.ld = -(long double)-(uint32_t)vtop->c.i; + } + + if (dbt == 8) + vtop->c.f = (float)vtop->c.ld; + else if (dbt == 9) + vtop->c.d = (double)vtop->c.ld; + } else if (sf && dbt == (4|0x0010)) { + vtop->c.i = vtop->c.ld; + } else if (sf && dbt == 11) { + vtop->c.i = (vtop->c.ld != 0); + } else { + if(sf) + vtop->c.i = vtop->c.ld; + else if (sbt == (4|0x0010)) + ; + else if (sbt & 0x0010) + vtop->c.i = (uint32_t)vtop->c.i; + + else if (sbt == 5) + ; + + else if (sbt != 4) + vtop->c.i = ((uint32_t)vtop->c.i | + -(vtop->c.i & 0x80000000)); + + if (dbt == (4|0x0010)) + ; + else if (dbt == 11) + vtop->c.i = (vtop->c.i != 0); + + else if (dbt == 5) + ; + + else if (dbt != 4) { + uint32_t m = ((dbt & 0x000f) == 1 ? 0xff : + (dbt & 0x000f) == 2 ? 0xffff : + 0xffffffff); + vtop->c.i &= m; + if (!(dbt & 0x0010)) + vtop->c.i |= -(vtop->c.i & ((m >> 1) + 1)); + } + } + } else if (p && dbt == 11) { + vtop->r = 0x0030; + vtop->c.i = 1; + } else { + + if (sf && df) { + + gen_cvt_ftof(dbt); + } else if (df) { + + gen_cvt_itof1(dbt); + } else if (sf) { + + if (dbt == 11) { + vpushi(0); + gen_op(0x95); + } else { + + if (dbt != (3 | 0x0010) && + dbt != (4 | 0x0010) && + dbt != 4) + dbt = 3; + gen_cvt_ftoi1(dbt); + if (dbt == 3 && (type->t & (0x000f | 0x0010)) != dbt) { + + vtop->type.t = dbt; + gen_cast(type); + } + } +# 2602 "tccgen.c" + } else if ((dbt & 0x000f) == 4 || + (dbt & 0x000f) == 5 || + (dbt & 0x000f) == 6) { + if ((sbt & 0x000f) != 4 && + (sbt & 0x000f) != 5 && + (sbt & 0x000f) != 6) { + + gv(0x0001); + if (sbt != (3 | 0x0010)) { + + + + int r = gv(0x0001); + + o(0x6348); + o(0xc0 + (((r) & 7) << 3) + ((r) & 7)); + + + + } + } + + } else if (dbt == 11) { + + vpushi(0); + gen_op(0x95); + } else if ((dbt & 0x000f) == 1 || + (dbt & 0x000f) == 2) { + if (sbt == 5) { + vtop->type.t = 3; + tcc_warning("nonportable conversion from pointer to char/short"); + } + force_charshort_cast(dbt); +# 2647 "tccgen.c" + } + } + } else if ((dbt & 0x000f) == 5 && !(vtop->r & 0x0100)) { + + + vtop->r = (vtop->r & ~(0x1000 | 0x2000 | 0x4000)) + | (lvalue_type(type->ref->type.t) & (0x1000 | 0x2000 | 0x4000)); + } + vtop->type = *type; +} + + +static int type_size(CType *type, int *a) +{ + Sym *s; + int bt; + + bt = type->t & 0x000f; + if (bt == 7) { + + s = type->ref; + *a = s->r; + return s->c; + } else if (bt == 5) { + if (type->t & 0x0040) { + int ts; + + s = type->ref; + ts = type_size(&s->type, a); + + if (ts < 0 && s->c < 0) + ts = -ts; + + return ts * s->c; + } else { + *a = 8; + return 8; + } + } else if (((type->t & (((1 << (6+6)) - 1) << 20 | 0x0080)) == (2 << 20)) && type->ref->c == -1) { + return -1; + } else if (bt == 10) { + *a = 16; + return 16; + } else if (bt == 9 || bt == 4) { +# 2704 "tccgen.c" + *a = 8; + + return 8; + } else if (bt == 3 || bt == 8) { + *a = 4; + return 4; + } else if (bt == 2) { + *a = 2; + return 2; + } else if (bt == 13 || bt == 14) { + *a = 8; + return 16; + } else { + + *a = 1; + return 1; + } +} + + + +static void vla_runtime_type_size(CType *type, int *a) +{ + if (type->t & 0x0400) { + type_size(&type->ref->type, a); + vset(&int_type, 0x0032|0x0100, type->ref->c); + } else { + vpushi(type_size(type, a)); + } +} + +static void vla_sp_restore(void) { + if (vlas_in_scope) { + gen_vla_sp_restore(vla_sp_loc); + } +} + +static void vla_sp_restore_root(void) { + if (vlas_in_scope) { + gen_vla_sp_restore(vla_sp_root_loc); + } +} + + +static inline CType *pointed_type(CType *type) +{ + return &type->ref->type; +} + + +static void mk_pointer(CType *type) +{ + Sym *s; + s = sym_push(0x20000000, type, 0, -1); + type->t = 5 | (type->t & (0x00001000 | 0x00002000 | 0x00004000 | 0x00008000)); + type->ref = s; +} + + +static int is_compatible_func(CType *type1, CType *type2) +{ + Sym *s1, *s2; + + s1 = type1->ref; + s2 = type2->ref; + if (!is_compatible_types(&s1->type, &s2->type)) + return 0; + + if (s1->f.func_call != s2->f.func_call) + return 0; + + if (s1->f.func_type == 2 || s2->f.func_type == 2) + return 1; + if (s1->f.func_type != s2->f.func_type) + return 0; + while (s1 != 0) { + if (s2 == 0) + return 0; + if (!is_compatible_unqualified_types(&s1->type, &s2->type)) + return 0; + s1 = s1->next; + s2 = s2->next; + } + if (s2) + return 0; + return 1; +} + + + + + + +static int compare_types(CType *type1, CType *type2, int unqualified) +{ + int bt1, t1, t2; + + t1 = type1->t & (~((0x00001000 | 0x00002000 | 0x00004000 | 0x00008000)|(((1 << (6+6)) - 1) << 20 | 0x0080))); + t2 = type2->t & (~((0x00001000 | 0x00002000 | 0x00004000 | 0x00008000)|(((1 << (6+6)) - 1) << 20 | 0x0080))); + if (unqualified) { + + t1 &= ~(0x0100 | 0x0200); + t2 &= ~(0x0100 | 0x0200); + } + + + if ((t1 & 0x000f) != 1) { + t1 &= ~0x0020; + t2 &= ~0x0020; + } + + if (t1 != t2) + return 0; + + bt1 = t1 & 0x000f; + if (bt1 == 5) { + type1 = pointed_type(type1); + type2 = pointed_type(type2); + return is_compatible_types(type1, type2); + } else if (bt1 == 7) { + return (type1->ref == type2->ref); + } else if (bt1 == 6) { + return is_compatible_func(type1, type2); + } else { + return 1; + } +} + + + + +static int is_compatible_types(CType *type1, CType *type2) +{ + return compare_types(type1,type2,0); +} + + + +static int is_compatible_unqualified_types(CType *type1, CType *type2) +{ + return compare_types(type1,type2,1); +} + + + + + +static void type_to_str(char *buf, int buf_size, + CType *type, const char *varstr) +{ + int bt, v, t; + Sym *s, *sa; + char buf1[256]; + const char *tstr; + + t = type->t; + bt = t & 0x000f; + buf[0] = '\0'; + + if (t & 0x00001000) + pstrcat(buf, buf_size, "extern "); + if (t & 0x00002000) + pstrcat(buf, buf_size, "static "); + if (t & 0x00004000) + pstrcat(buf, buf_size, "typedef "); + if (t & 0x00008000) + pstrcat(buf, buf_size, "inline "); + if (t & 0x0200) + pstrcat(buf, buf_size, "volatile "); + if (t & 0x0100) + pstrcat(buf, buf_size, "const "); + + if (((t & 0x0020) && bt == 1) + || ((t & 0x0010) + && (bt == 2 || bt == 3 || bt == 4) + && !((t & (((1 << (6+6)) - 1) << 20 | 0x0080)) == (2 << 20)) + )) + pstrcat(buf, buf_size, (t & 0x0010) ? "unsigned " : "signed "); + + buf_size -= strlen(buf); + buf += strlen(buf); + + switch(bt) { + case 0: + tstr = "void"; + goto add_tstr; + case 11: + tstr = "_Bool"; + goto add_tstr; + case 1: + tstr = "char"; + goto add_tstr; + case 2: + tstr = "short"; + goto add_tstr; + case 3: + tstr = "int"; + goto maybe_long; + case 4: + tstr = "long long"; + maybe_long: + if (t & 0x0800) + tstr = "long"; + if (!((t & (((1 << (6+6)) - 1) << 20 | 0x0080)) == (2 << 20))) + goto add_tstr; + tstr = "enum "; + goto tstruct; + case 8: + tstr = "float"; + goto add_tstr; + case 9: + tstr = "double"; + goto add_tstr; + case 10: + tstr = "long double"; + add_tstr: + pstrcat(buf, buf_size, tstr); + break; + case 7: + tstr = "struct "; + if (((t & ((((1 << (6+6)) - 1) << 20 | 0x0080)|0x000f)) == (1 << 20 | 7))) + tstr = "union "; + tstruct: + pstrcat(buf, buf_size, tstr); + v = type->ref->v & ~0x40000000; + if (v >= 0x10000000) + pstrcat(buf, buf_size, "<anonymous>"); + else + pstrcat(buf, buf_size, get_tok_str(v, 0)); + break; + case 6: + s = type->ref; + type_to_str(buf, buf_size, &s->type, varstr); + pstrcat(buf, buf_size, "("); + sa = s->next; + while (sa != 0) { + type_to_str(buf1, sizeof(buf1), &sa->type, 0); + pstrcat(buf, buf_size, buf1); + sa = sa->next; + if (sa) + pstrcat(buf, buf_size, ", "); + } + pstrcat(buf, buf_size, ")"); + goto no_var; + case 5: + s = type->ref; + if (t & 0x0040) { + snprintf(buf1, sizeof(buf1), "%s[%d]", varstr ? varstr : "", s->c); + type_to_str(buf, buf_size, &s->type, buf1); + goto no_var; + } + pstrcpy(buf1, sizeof(buf1), "*"); + if (t & 0x0100) + pstrcat(buf1, buf_size, "const "); + if (t & 0x0200) + pstrcat(buf1, buf_size, "volatile "); + if (varstr) + pstrcat(buf1, sizeof(buf1), varstr); + type_to_str(buf, buf_size, &s->type, buf1); + goto no_var; + } + if (varstr) { + pstrcat(buf, buf_size, " "); + pstrcat(buf, buf_size, varstr); + } + no_var: ; +} + + + +static void gen_assign_cast(CType *dt) +{ + CType *st, *type1, *type2; + char buf1[256], buf2[256]; + int dbt, sbt; + + st = &vtop->type; + dbt = dt->t & 0x000f; + sbt = st->t & 0x000f; + if (sbt == 0 || dbt == 0) { + if (sbt == 0 && dbt == 0) + ; +# 2994 "tccgen.c" + else + tcc_error("cannot cast from/to void"); + } + if (dt->t & 0x0100) + tcc_warning("assignment of read-only location"); + switch(dbt) { + case 5: + + + if (is_null_pointer(vtop)) + goto type_ok; + + if (is_integer_btype(sbt)) { + tcc_warning("assignment makes pointer from integer without a cast"); + goto type_ok; + } + type1 = pointed_type(dt); + + if (sbt == 6) { + if ((type1->t & 0x000f) != 0 && + !is_compatible_types(pointed_type(dt), st)) + tcc_warning("assignment from incompatible pointer type"); + goto type_ok; + } + if (sbt != 5) + goto error; + type2 = pointed_type(st); + if ((type1->t & 0x000f) == 0 || + (type2->t & 0x000f) == 0) { + + } else { + + + if (!is_compatible_unqualified_types(type1, type2)) { + + + + + if ((type1->t & (0x000f|0x0800)) != (type2->t & (0x000f|0x0800)) + || ((type1->t & (((1 << (6+6)) - 1) << 20 | 0x0080)) == (2 << 20)) || ((type2->t & (((1 << (6+6)) - 1) << 20 | 0x0080)) == (2 << 20)) + ) + tcc_warning("assignment from incompatible pointer type"); + } + } + + if ((!(type1->t & 0x0100) && (type2->t & 0x0100)) || + (!(type1->t & 0x0200) && (type2->t & 0x0200))) + tcc_warning("assignment discards qualifiers from pointer target type"); + break; + case 1: + case 2: + case 3: + case 4: + if (sbt == 5 || sbt == 6) { + tcc_warning("assignment makes integer from pointer without a cast"); + } else if (sbt == 7) { + goto case_VT_STRUCT; + } + + break; + case 7: + case_VT_STRUCT: + if (!is_compatible_unqualified_types(dt, st)) { + error: + type_to_str(buf1, sizeof(buf1), st, 0); + type_to_str(buf2, sizeof(buf2), dt, 0); + tcc_error("cannot cast '%s' to '%s'", buf1, buf2); + } + break; + } + type_ok: + gen_cast(dt); +} + + +static void vstore(void) +{ + int sbt, dbt, ft, r, t, size, align, bit_size, bit_pos, rc, delayed_cast; + + ft = vtop[-1].type.t; + sbt = vtop->type.t & 0x000f; + dbt = ft & 0x000f; + if ((((sbt == 3 || sbt == 2) && dbt == 1) || + (sbt == 3 && dbt == 2)) + && !(vtop->type.t & 0x0080)) { + + delayed_cast = 0x0400; + vtop->type.t = ft & (~((0x00001000 | 0x00002000 | 0x00004000 | 0x00008000)|(((1 << (6+6)) - 1) << 20 | 0x0080))); + + if (ft & 0x0100) + tcc_warning("assignment of read-only location"); + } else { + delayed_cast = 0; + if (!(ft & 0x0080)) + gen_assign_cast(&vtop[-1].type); + } + + if (sbt == 7) { + + + + size = type_size(&vtop->type, &align); + + + vswap(); + vtop->type.t = 5; + gaddrof(); +# 3111 "tccgen.c" + vpush_global_sym(&func_old_type, TOK_memmove); + + vswap(); + + vpushv(vtop - 2); + vtop->type.t = 5; + gaddrof(); + + vpushi(size); + gfunc_call(3); + + + } else if (ft & 0x0080) { + + + + vdup(), vtop[-1] = vtop[-2]; + + bit_pos = (((ft) >> 20) & 0x3f); + bit_size = (((ft) >> (20 + 6)) & 0x3f); + + vtop[-1].type.t = ft & ~(((1 << (6+6)) - 1) << 20 | 0x0080); + + if ((ft & 0x000f) == 11) { + gen_cast(&vtop[-1].type); + vtop[-1].type.t = (vtop[-1].type.t & ~0x000f) | (1 | 0x0010); + } + + r = adjust_bf(vtop - 1, bit_pos, bit_size); + if (r == 7) { + gen_cast_s((ft & 0x000f) == 4 ? 4 : 3); + store_packed_bf(bit_pos, bit_size); + } else { + unsigned long long mask = (1ULL << bit_size) - 1; + if ((ft & 0x000f) != 11) { + + if ((vtop[-1].type.t & 0x000f) == 4) + vpushll(mask); + else + vpushi((unsigned)mask); + gen_op('&'); + } + + vpushi(bit_pos); + gen_op(0x01); + vswap(); + + vdup(); + vrott(3); + + if ((vtop->type.t & 0x000f) == 4) + vpushll(~(mask << bit_pos)); + else + vpushi(~((unsigned)mask << bit_pos)); + gen_op('&'); + gen_op('|'); + + vstore(); + + vpop(); + } + } else if (dbt == 0) { + --vtop; + } else { + + + if (vtop[-1].r & 0x0800) { + vswap(); + gbound(); + vswap(); + } + + rc = 0x0001; + if (is_float(ft)) { + rc = 0x0002; + + if ((ft & 0x000f) == 10) { + rc = 0x0080; + } else if ((ft & 0x000f) == 14) { + rc = 0x1000; + } + + } + r = gv(rc); + + if ((vtop[-1].r & 0x003f) == 0x0031) { + SValue sv; + t = get_reg(0x0001); + + sv.type.t = 5; + + + + sv.r = 0x0032 | 0x0100; + sv.c.i = vtop[-1].c.i; + load(t, &sv); + vtop[-1].r = t | 0x0100; + } + + + if (((ft & 0x000f) == 13) || ((ft & 0x000f) == 14)) { + int addr_type = 4, load_size = 8, load_type = ((vtop->type.t & 0x000f) == 13) ? 4 : 9; + + + + + vtop[-1].type.t = load_type; + store(r, vtop - 1); + vswap(); + + vtop->type.t = addr_type; + gaddrof(); + vpushi(load_size); + gen_op('+'); + vtop->r |= 0x0100; + vswap(); + vtop[-1].type.t = load_type; + + store(vtop->r2, vtop - 1); + } else { + store(r, vtop - 1); + } + + vswap(); + vtop--; + vtop->r |= delayed_cast; + } +} + + +static void inc(int post, int c) +{ + test_lvalue(); + vdup(); + if (post) { + gv_dup(); + vrotb(3); + vrotb(3); + } + + vpushi(c - 0xa3); + gen_op('+'); + vstore(); + if (post) + vpop(); +} + +static void parse_mult_str (CString *astr, const char *msg) +{ + + if (tok != 0xb9) + expect(msg); + cstr_new(astr); + while (tok == 0xb9) { + + cstr_cat(astr, tokc.str.data, -1); + next(); + } + cstr_ccat(astr, '\0'); +} + + + +static int exact_log2p1(int i) +{ + int ret; + if (!i) + return 0; + for (ret = 1; i >= 1 << 8; ret += 8) + i >>= 8; + if (i >= 1 << 4) + ret += 4, i >>= 4; + if (i >= 1 << 2) + ret += 2, i >>= 2; + if (i >= 1 << 1) + ret++; + return ret; +} + + +static void parse_attribute(AttributeDef *ad) +{ + int t, n; + CString astr; + +redo: + if (tok != TOK_ATTRIBUTE1 && tok != TOK_ATTRIBUTE2) + return; + next(); + skip('('); + skip('('); + while (tok != ')') { + if (tok < 256) + expect("attribute name"); + t = tok; + next(); + switch(t) { + case TOK_SECTION1: + case TOK_SECTION2: + skip('('); + parse_mult_str(&astr, "section name"); + ad->section = find_section(tcc_state, (char *)astr.data); + skip(')'); + cstr_free(&astr); + break; + case TOK_ALIAS1: + case TOK_ALIAS2: + skip('('); + parse_mult_str(&astr, "alias(\"target\")"); + ad->alias_target = + tok_alloc((char*)astr.data, astr.size-1)->tok; + skip(')'); + cstr_free(&astr); + break; + case TOK_VISIBILITY1: + case TOK_VISIBILITY2: + skip('('); + parse_mult_str(&astr, + "visibility(\"default|hidden|internal|protected\")"); + if (!strcmp (astr.data, "default")) + ad->a.visibility = 0; + else if (!strcmp (astr.data, "hidden")) + ad->a.visibility = 2; + else if (!strcmp (astr.data, "internal")) + ad->a.visibility = 1; + else if (!strcmp (astr.data, "protected")) + ad->a.visibility = 3; + else + expect("visibility(\"default|hidden|internal|protected\")"); + skip(')'); + cstr_free(&astr); + break; + case TOK_ALIGNED1: + case TOK_ALIGNED2: + if (tok == '(') { + next(); + n = expr_const(); + if (n <= 0 || (n & (n - 1)) != 0) + tcc_error("alignment must be a positive power of two"); + skip(')'); + } else { + n = 16; + } + ad->a.aligned = exact_log2p1(n); + if (n != 1 << (ad->a.aligned - 1)) + tcc_error("alignment of %d is larger than implemented", n); + break; + case TOK_PACKED1: + case TOK_PACKED2: + ad->a.packed = 1; + break; + case TOK_WEAK1: + case TOK_WEAK2: + ad->a.weak = 1; + break; + case TOK_UNUSED1: + case TOK_UNUSED2: + + + break; + case TOK_NORETURN1: + case TOK_NORETURN2: + + + break; + case TOK_CDECL1: + case TOK_CDECL2: + case TOK_CDECL3: + ad->f.func_call = 0; + break; + case TOK_STDCALL1: + case TOK_STDCALL2: + case TOK_STDCALL3: + ad->f.func_call = 1; + break; +# 3405 "tccgen.c" + case TOK_MODE: + skip('('); + switch(tok) { + case TOK_MODE_DI: + ad->attr_mode = 4 + 1; + break; + case TOK_MODE_QI: + ad->attr_mode = 1 + 1; + break; + case TOK_MODE_HI: + ad->attr_mode = 2 + 1; + break; + case TOK_MODE_SI: + case TOK_MODE_word: + ad->attr_mode = 3 + 1; + break; + default: + tcc_warning("__mode__(%s) not supported\n", get_tok_str(tok, 0)); + break; + } + next(); + skip(')'); + break; + case TOK_DLLEXPORT: + ad->a.dllexport = 1; + break; + case TOK_DLLIMPORT: + ad->a.dllimport = 1; + break; + default: + if (tcc_state->warn_unsupported) + tcc_warning("'%s' attribute ignored", get_tok_str(t, 0)); + + if (tok == '(') { + int parenthesis = 0; + do { + if (tok == '(') + parenthesis++; + else if (tok == ')') + parenthesis--; + next(); + } while (parenthesis && tok != -1); + } + break; + } + if (tok != ',') + break; + next(); + } + skip(')'); + skip(')'); + goto redo; +} + +static Sym * find_field (CType *type, int v) +{ + Sym *s = type->ref; + v |= 0x20000000; + while ((s = s->next) != 0) { + if ((s->v & 0x20000000) && + (s->type.t & 0x000f) == 7 && + (s->v & ~0x20000000) >= 0x10000000) { + Sym *ret = find_field (&s->type, v); + if (ret) + return ret; + } + if (s->v == v) + break; + } + return s; +} + +static void struct_add_offset (Sym *s, int offset) +{ + while ((s = s->next) != 0) { + if ((s->v & 0x20000000) && + (s->type.t & 0x000f) == 7 && + (s->v & ~0x20000000) >= 0x10000000) { + struct_add_offset(s->type.ref, offset); + } else + s->c += offset; + } +} + +static void struct_layout(CType *type, AttributeDef *ad) +{ + int size, align, maxalign, offset, c, bit_pos, bit_size; + int packed, a, bt, prevbt, prev_bit_size; + int pcc = !tcc_state->ms_bitfields; + int pragma_pack = *tcc_state->pack_stack_ptr; + Sym *f; + + maxalign = 1; + offset = 0; + c = 0; + bit_pos = 0; + prevbt = 7; + prev_bit_size = 0; + + + + for (f = type->ref->next; f; f = f->next) { + if (f->type.t & 0x0080) + bit_size = (((f->type.t) >> (20 + 6)) & 0x3f); + else + bit_size = -1; + size = type_size(&f->type, &align); + a = f->a.aligned ? 1 << (f->a.aligned - 1) : 0; + packed = 0; + + if (pcc && bit_size == 0) { + + + } else { + + if (pcc && (f->a.packed || ad->a.packed)) + align = packed = 1; + + + if (pragma_pack) { + packed = 1; + if (pragma_pack < align) + align = pragma_pack; + + if (pcc && pragma_pack < a) + a = 0; + } + } + + if (a) + align = a; + + if (type->ref->type.t == (1 << 20 | 7)) { + if (pcc && bit_size >= 0) + size = (bit_size + 7) >> 3; + offset = 0; + if (size > c) + c = size; + + } else if (bit_size < 0) { + if (pcc) + c += (bit_pos + 7) >> 3; + c = (c + align - 1) & -align; + offset = c; + if (size > 0) + c += size; + bit_pos = 0; + prevbt = 7; + prev_bit_size = 0; + + } else { + + + if (pcc) { + + + + + + + if (bit_size == 0) { + new_field: + c = (c + ((bit_pos + 7) >> 3) + align - 1) & -align; + bit_pos = 0; + } else if (f->a.aligned) { + goto new_field; + } else if (!packed) { + int a8 = align * 8; + int ofs = ((c * 8 + bit_pos) % a8 + bit_size + a8 - 1) / a8; + if (ofs > size / align) + goto new_field; + } + + + if (size == 8 && bit_size <= 32) + f->type.t = (f->type.t & ~0x000f) | 3, size = 4; + + while (bit_pos >= align * 8) + c += align, bit_pos -= align * 8; + offset = c; + + + + + if (f->v & 0x10000000 + + ) + align = 1; + + } else { + bt = f->type.t & 0x000f; + if ((bit_pos + bit_size > size * 8) + || (bit_size > 0) == (bt != prevbt) + ) { + c = (c + align - 1) & -align; + offset = c; + bit_pos = 0; + + + + + if (bit_size || prev_bit_size) + c += size; + } + + + + + if (bit_size == 0 && prevbt != bt) + align = 1; + prevbt = bt; + prev_bit_size = bit_size; + } + + f->type.t = (f->type.t & ~(0x3f << 20)) + | (bit_pos << 20); + bit_pos += bit_size; + } + if (align > maxalign) + maxalign = align; +# 3638 "tccgen.c" + if (f->v & 0x10000000 && (f->type.t & 0x000f) == 7) { + Sym *ass; + + + + + + + + int v2 = f->type.ref->v; + if (!(v2 & 0x20000000) && + (v2 & ~0x40000000) < 0x10000000) { + Sym **pps; + + + + + + ass = f->type.ref; + f->type.ref = sym_push(anon_sym++ | 0x20000000, + &f->type.ref->type, 0, + f->type.ref->c); + pps = &f->type.ref->next; + while ((ass = ass->next) != 0) { + *pps = sym_push(ass->v, &ass->type, 0, ass->c); + pps = &((*pps)->next); + } + *pps = 0; + } + struct_add_offset(f->type.ref, offset); + f->c = 0; + } else { + f->c = offset; + } + + f->r = 0; + } + + if (pcc) + c += (bit_pos + 7) >> 3; + + + a = bt = ad->a.aligned ? 1 << (ad->a.aligned - 1) : 1; + if (a < maxalign) + a = maxalign; + type->ref->r = a; + if (pragma_pack && pragma_pack < maxalign && 0 == pcc) { + + + a = pragma_pack; + if (a < bt) + a = bt; + } + c = (c + a - 1) & -a; + type->ref->c = c; + + + + + + + for (f = type->ref->next; f; f = f->next) { + int s, px, cx, c0; + CType t; + + if (0 == (f->type.t & 0x0080)) + continue; + f->type.ref = f; + f->auxtype = -1; + bit_size = (((f->type.t) >> (20 + 6)) & 0x3f); + if (bit_size == 0) + continue; + bit_pos = (((f->type.t) >> 20) & 0x3f); + size = type_size(&f->type, &align); + if (bit_pos + bit_size <= size * 8 && f->c + size <= c) + continue; + + + c0 = -1, s = align = 1; + for (;;) { + px = f->c * 8 + bit_pos; + cx = (px >> 3) & -align; + px = px - (cx << 3); + if (c0 == cx) + break; + s = (px + bit_size + 7) >> 3; + if (s > 4) { + t.t = 4; + } else if (s > 2) { + t.t = 3; + } else if (s > 1) { + t.t = 2; + } else { + t.t = 1; + } + s = type_size(&t, &align); + c0 = cx; + } + + if (px + bit_size <= s * 8 && cx + s <= c) { + + f->c = cx; + bit_pos = px; + f->type.t = (f->type.t & ~(0x3f << 20)) + | (bit_pos << 20); + if (s != size) + f->auxtype = t.t; + + + + + + + } else { + + f->auxtype = 7; + + + + + } + } +} + + +static void struct_decl(CType *type, int u) +{ + int v, c, size, align, flexible; + int bit_size, bsize, bt; + Sym *s, *ss, **ps; + AttributeDef ad, ad1; + CType type1, btype; + + memset(&ad, 0, sizeof ad); + next(); + parse_attribute(&ad); + if (tok != '{') { + v = tok; + next(); + + if (v < 256) + expect("struct/union/enum name"); + s = struct_find(v); + if (s && (s->sym_scope == local_scope || tok != '{')) { + if (u == s->type.t) + goto do_decl; + if (u == (2 << 20) && ((s->type.t & (((1 << (6+6)) - 1) << 20 | 0x0080)) == (2 << 20))) + goto do_decl; + tcc_error("redefinition of '%s'", get_tok_str(v, 0)); + } + } else { + v = anon_sym++; + } + + type1.t = u == (2 << 20) ? u | 3 | 0x0010 : u; + type1.ref = 0; + + s = sym_push(v | 0x40000000, &type1, 0, -1); + s->r = 0; +do_decl: + type->t = s->type.t; + type->ref = s; + + if (tok == '{') { + next(); + if (s->c != -1) + tcc_error("struct/union/enum already defined"); + + + ps = &s->next; + if (u == (2 << 20)) { + long long ll = 0, pl = 0, nl = 0; + CType t; + t.ref = s; + + t.t = 3|0x00002000|(3 << 20); + for(;;) { + v = tok; + if (v < TOK_DEFINE) + expect("identifier"); + ss = sym_find(v); + if (ss && !local_stack) + tcc_error("redefinition of enumerator '%s'", + get_tok_str(v, 0)); + next(); + if (tok == '=') { + next(); + ll = expr_const64(); + } + ss = sym_push(v, &t, 0x0030, 0); + ss->enum_val = ll; + *ps = ss, ps = &ss->next; + if (ll < nl) + nl = ll; + if (ll > pl) + pl = ll; + if (tok != ',') + break; + next(); + ll++; + + if (tok == '}') + break; + } + skip('}'); + + t.t = 3; + if (nl >= 0) { + if (pl != (unsigned)pl) + t.t = (8==8 ? 4|0x0800 : 4); + t.t |= 0x0010; + } else if (pl != (int)pl || nl != (int)nl) + t.t = (8==8 ? 4|0x0800 : 4); + s->type.t = type->t = t.t | (2 << 20); + s->c = 0; + + for (ss = s->next; ss; ss = ss->next) { + ll = ss->enum_val; + if (ll == (int)ll) + continue; + if (t.t & 0x0010) { + ss->type.t |= 0x0010; + if (ll == (unsigned)ll) + continue; + } + ss->type.t = (ss->type.t & ~0x000f) + | (8==8 ? 4|0x0800 : 4); + } + } else { + c = 0; + flexible = 0; + while (tok != '}') { + if (!parse_btype(&btype, &ad1)) { + skip(';'); + continue; + } + while (1) { + if (flexible) + tcc_error("flexible array member '%s' not at the end of struct", + get_tok_str(v, 0)); + bit_size = -1; + v = 0; + type1 = btype; + if (tok != ':') { + if (tok != ';') + type_decl(&type1, &ad1, &v, 2); + if (v == 0) { + if ((type1.t & 0x000f) != 7) + expect("identifier"); + else { + int v = btype.ref->v; + if (!(v & 0x20000000) && (v & ~0x40000000) < 0x10000000) { + if (tcc_state->ms_extensions == 0) + expect("identifier"); + } + } + } + if (type_size(&type1, &align) < 0) { + if ((u == 7) && (type1.t & 0x0040) && c) + flexible = 1; + else + tcc_error("field '%s' has incomplete type", + get_tok_str(v, 0)); + } + if ((type1.t & 0x000f) == 6 || + (type1.t & (0x00001000 | 0x00002000 | 0x00004000 | 0x00008000))) + tcc_error("invalid type for '%s'", + get_tok_str(v, 0)); + } + if (tok == ':') { + next(); + bit_size = expr_const(); + + if (bit_size < 0) + tcc_error("negative width in bit-field '%s'", + get_tok_str(v, 0)); + if (v && bit_size == 0) + tcc_error("zero width for bit-field '%s'", + get_tok_str(v, 0)); + parse_attribute(&ad1); + } + size = type_size(&type1, &align); + if (bit_size >= 0) { + bt = type1.t & 0x000f; + if (bt != 3 && + bt != 1 && + bt != 2 && + bt != 11 && + bt != 4) + tcc_error("bitfields must have scalar type"); + bsize = size * 8; + if (bit_size > bsize) { + tcc_error("width of '%s' exceeds its type", + get_tok_str(v, 0)); + } else if (bit_size == bsize + && !ad.a.packed && !ad1.a.packed) { + + ; + } else if (bit_size == 64) { + tcc_error("field width 64 not implemented"); + } else { + type1.t = (type1.t & ~(((1 << (6+6)) - 1) << 20 | 0x0080)) + | 0x0080 + | (bit_size << (20 + 6)); + } + } + if (v != 0 || (type1.t & 0x000f) == 7) { + + + c = 1; + } + + + if (v == 0 && + ((type1.t & 0x000f) == 7 || + bit_size >= 0)) { + v = anon_sym++; + } + if (v) { + ss = sym_push(v | 0x20000000, &type1, 0, 0); + ss->a = ad1.a; + *ps = ss; + ps = &ss->next; + } + if (tok == ';' || tok == (-1)) + break; + skip(','); + } + skip(';'); + } + skip('}'); + parse_attribute(&ad); + struct_layout(type, &ad); + } + } +} + +static void sym_to_attr(AttributeDef *ad, Sym *s) +{ + if (s->a.aligned && 0 == ad->a.aligned) + ad->a.aligned = s->a.aligned; + if (s->f.func_call && 0 == ad->f.func_call) + ad->f.func_call = s->f.func_call; + if (s->f.func_type && 0 == ad->f.func_type) + ad->f.func_type = s->f.func_type; + if (s->a.packed) + ad->a.packed = 1; +} + + + +static void parse_btype_qualify(CType *type, int qualifiers) +{ + while (type->t & 0x0040) { + type->ref = sym_push(0x20000000, &type->ref->type, 0, type->ref->c); + type = &type->ref->type; + } + type->t |= qualifiers; +} + + + + +static int parse_btype(CType *type, AttributeDef *ad) +{ + int t, u, bt, st, type_found, typespec_found, g; + Sym *s; + CType type1; + + memset(ad, 0, sizeof(AttributeDef)); + type_found = 0; + typespec_found = 0; + t = 3; + bt = st = -1; + type->ref = 0; + + while(1) { + switch(tok) { + case TOK_EXTENSION: + + next(); + continue; + + + case TOK_CHAR: + u = 1; + basic_type: + next(); + basic_type1: + if (u == 2 || u == 0x0800) { + if (st != -1 || (bt != -1 && bt != 3)) + tmbt: tcc_error("too many basic types"); + st = u; + } else { + if (bt != -1 || (st != -1 && u != 3)) + goto tmbt; + bt = u; + } + if (u != 3) + t = (t & ~(0x000f|0x0800)) | u; + typespec_found = 1; + break; + case TOK_VOID: + u = 0; + goto basic_type; + case TOK_SHORT: + u = 2; + goto basic_type; + case TOK_INT: + u = 3; + goto basic_type; + case TOK_LONG: + if ((t & 0x000f) == 9) { + t = (t & ~(0x000f|0x0800)) | 10; + } else if ((t & (0x000f|0x0800)) == 0x0800) { + t = (t & ~(0x000f|0x0800)) | 4; + } else { + u = 0x0800; + goto basic_type; + } + next(); + break; + + + + + + + + case TOK_BOOL: + u = 11; + goto basic_type; + case TOK_FLOAT: + u = 8; + goto basic_type; + case TOK_DOUBLE: + if ((t & (0x000f|0x0800)) == 0x0800) { + t = (t & ~(0x000f|0x0800)) | 10; + } else { + u = 9; + goto basic_type; + } + next(); + break; + case TOK_ENUM: + struct_decl(&type1, (2 << 20)); + basic_type2: + u = type1.t; + type->ref = type1.ref; + goto basic_type1; + case TOK_STRUCT: + struct_decl(&type1, 7); + goto basic_type2; + case TOK_UNION: + struct_decl(&type1, (1 << 20 | 7)); + goto basic_type2; + + + case TOK_CONST1: + case TOK_CONST2: + case TOK_CONST3: + type->t = t; + parse_btype_qualify(type, 0x0100); + t = type->t; + next(); + break; + case TOK_VOLATILE1: + case TOK_VOLATILE2: + case TOK_VOLATILE3: + type->t = t; + parse_btype_qualify(type, 0x0200); + t = type->t; + next(); + break; + case TOK_SIGNED1: + case TOK_SIGNED2: + case TOK_SIGNED3: + if ((t & (0x0020|0x0010)) == (0x0020|0x0010)) + tcc_error("signed and unsigned modifier"); + t |= 0x0020; + next(); + typespec_found = 1; + break; + case TOK_REGISTER: + case TOK_AUTO: + case TOK_RESTRICT1: + case TOK_RESTRICT2: + case TOK_RESTRICT3: + next(); + break; + case TOK_UNSIGNED: + if ((t & (0x0020|0x0010)) == 0x0020) + tcc_error("signed and unsigned modifier"); + t |= 0x0020 | 0x0010; + next(); + typespec_found = 1; + break; + + + case TOK_EXTERN: + g = 0x00001000; + goto storage; + case TOK_STATIC: + g = 0x00002000; + goto storage; + case TOK_TYPEDEF: + g = 0x00004000; + goto storage; + storage: + if (t & (0x00001000|0x00002000|0x00004000) & ~g) + tcc_error("multiple storage classes"); + t |= g; + next(); + break; + case TOK_INLINE1: + case TOK_INLINE2: + case TOK_INLINE3: + t |= 0x00008000; + next(); + break; + + + case TOK_ATTRIBUTE1: + case TOK_ATTRIBUTE2: + parse_attribute(ad); + if (ad->attr_mode) { + u = ad->attr_mode -1; + t = (t & ~(0x000f|0x0800)) | u; + } + break; + + case TOK_TYPEOF1: + case TOK_TYPEOF2: + case TOK_TYPEOF3: + next(); + parse_expr_type(&type1); + + type1.t &= ~((0x00001000 | 0x00002000 | 0x00004000 | 0x00008000)&~0x00004000); + if (type1.ref) + sym_to_attr(ad, type1.ref); + goto basic_type2; + default: + if (typespec_found) + goto the_end; + s = sym_find(tok); + if (!s || !(s->type.t & 0x00004000)) + goto the_end; + t &= ~(0x000f|0x0800); + u = t & ~(0x0100 | 0x0200), t ^= u; + type->t = (s->type.t & ~0x00004000) | u; + type->ref = s->type.ref; + if (t) + parse_btype_qualify(type, t); + t = type->t; + + sym_to_attr(ad, s); + next(); + typespec_found = 1; + st = bt = -2; + break; + } + type_found = 1; + } +the_end: + if (tcc_state->char_is_unsigned) { + if ((t & (0x0020|0x000f)) == 1) + t |= 0x0010; + } + + bt = t & (0x000f|0x0800); + if (bt == 0x0800) + t |= 8 == 8 ? 4 : 3; + + + + + type->t = t; + return type_found; +} + + + +static inline void convert_parameter_type(CType *pt) +{ + + + pt->t &= ~(0x0100 | 0x0200); + + pt->t &= ~0x0040; + if ((pt->t & 0x000f) == 6) { + mk_pointer(pt); + } +} + +static void parse_asm_str(CString *astr) +{ + skip('('); + parse_mult_str(astr, "string constant"); +} + + +static int asm_label_instr(void) +{ + int v; + CString astr; + + next(); + parse_asm_str(&astr); + skip(')'); + + + + v = tok_alloc(astr.data, astr.size - 1)->tok; + cstr_free(&astr); + return v; +} + +static int post_type(CType *type, AttributeDef *ad, int storage, int td) +{ + int n, l, t1, arg_size, align; + Sym **plast, *s, *first; + AttributeDef ad1; + CType pt; + + if (tok == '(') { + + next(); + if (td && !(td & 1)) + return 0; + if (tok == ')') + l = 0; + else if (parse_btype(&pt, &ad1)) + l = 1; + else if (td) + return 0; + else + l = 2; + first = 0; + plast = &first; + arg_size = 0; + if (l) { + for(;;) { + + if (l != 2) { + if ((pt.t & 0x000f) == 0 && tok == ')') + break; + type_decl(&pt, &ad1, &n, 2 | 1); + if ((pt.t & 0x000f) == 0) + tcc_error("parameter declared as void"); + arg_size += (type_size(&pt, &align) + 8 - 1) / 8; + } else { + n = tok; + if (n < TOK_DEFINE) + expect("identifier"); + pt.t = 0; + next(); + } + convert_parameter_type(&pt); + s = sym_push(n | 0x20000000, &pt, 0, 0); + *plast = s; + plast = &s->next; + if (tok == ')') + break; + skip(','); + if (l == 1 && tok == 0xc8) { + l = 3; + next(); + break; + } + if (l == 1 && !parse_btype(&pt, &ad1)) + tcc_error("invalid type"); + } + } else + + l = 2; + skip(')'); + + + type->t &= ~0x0100; + + + + if (tok == '[') { + next(); + skip(']'); + mk_pointer(type); + } + + ad->f.func_args = arg_size; + ad->f.func_type = l; + s = sym_push(0x20000000, type, 0, 0); + s->a = ad->a; + s->f = ad->f; + s->next = first; + type->t = 6; + type->ref = s; + } else if (tok == '[') { + int saved_nocode_wanted = nocode_wanted; + + next(); + if (tok == TOK_RESTRICT1) + next(); + n = -1; + t1 = 0; + if (tok != ']') { + if (!local_stack || (storage & 0x00002000)) + vpushi(expr_const()); + else { + + + + + nocode_wanted = 0; + gexpr(); + } + if ((vtop->r & (0x003f | 0x0100 | 0x0200)) == 0x0030) { + n = vtop->c.i; + if (n < 0) + tcc_error("invalid array size"); + } else { + if (!is_integer_btype(vtop->type.t & 0x000f)) + tcc_error("size of variable length array should be an integer"); + t1 = 0x0400; + } + } + skip(']'); + + post_type(type, ad, storage, 0); + if (type->t == 6) + tcc_error("declaration of an array of functions"); + t1 |= type->t & 0x0400; + + if (t1 & 0x0400) { + loc -= type_size(&int_type, &align); + loc &= -align; + n = loc; + + vla_runtime_type_size(type, &align); + gen_op('*'); + vset(&int_type, 0x0032|0x0100, n); + vswap(); + vstore(); + } + if (n != -1) + vpop(); + nocode_wanted = saved_nocode_wanted; + + + + s = sym_push(0x20000000, type, 0, n); + type->t = (t1 ? 0x0400 : 0x0040) | 5; + type->ref = s; + } + return 1; +} +# 4401 "tccgen.c" +static CType *type_decl(CType *type, AttributeDef *ad, int *v, int td) +{ + CType *post, *ret; + int qualifiers, storage; + + + storage = type->t & (0x00001000 | 0x00002000 | 0x00004000 | 0x00008000); + type->t &= ~(0x00001000 | 0x00002000 | 0x00004000 | 0x00008000); + post = ret = type; + + while (tok == '*') { + qualifiers = 0; + redo: + next(); + switch(tok) { + case TOK_CONST1: + case TOK_CONST2: + case TOK_CONST3: + qualifiers |= 0x0100; + goto redo; + case TOK_VOLATILE1: + case TOK_VOLATILE2: + case TOK_VOLATILE3: + qualifiers |= 0x0200; + goto redo; + case TOK_RESTRICT1: + case TOK_RESTRICT2: + case TOK_RESTRICT3: + goto redo; + + case TOK_ATTRIBUTE1: + case TOK_ATTRIBUTE2: + parse_attribute(ad); + break; + } + mk_pointer(type); + type->t |= qualifiers; + if (ret == type) + + ret = pointed_type(type); + } + + if (tok == '(') { + + + if (!post_type(type, ad, 0, td)) { + + + + + parse_attribute(ad); + post = type_decl(type, ad, v, td); + skip(')'); + } + } else if (tok >= 256 && (td & 2)) { + + *v = tok; + next(); + } else { + if (!(td & 1)) + expect("identifier"); + *v = 0; + } + post_type(post, ad, storage, 0); + parse_attribute(ad); + type->t |= storage; + return ret; +} + + +static int lvalue_type(int t) +{ + int bt, r; + r = 0x0100; + bt = t & 0x000f; + if (bt == 1 || bt == 11) + r |= 0x1000; + else if (bt == 2) + r |= 0x2000; + else + return r; + if (t & 0x0010) + r |= 0x4000; + return r; +} + + +static void indir(void) +{ + if ((vtop->type.t & 0x000f) != 5) { + if ((vtop->type.t & 0x000f) == 6) + return; + expect("pointer"); + } + if (vtop->r & 0x0100) + gv(0x0001); + vtop->type = *pointed_type(&vtop->type); + + if (!(vtop->type.t & 0x0040) && !(vtop->type.t & 0x0400) + && (vtop->type.t & 0x000f) != 6) { + vtop->r |= lvalue_type(vtop->type.t); + + + if (tcc_state->do_bounds_check) + vtop->r |= 0x0800; + + } +} + + +static void gfunc_param_typed(Sym *func, Sym *arg) +{ + int func_type; + CType type; + + func_type = func->f.func_type; + if (func_type == 2 || + (func_type == 3 && arg == 0)) { + + if ((vtop->type.t & 0x000f) == 8) { + gen_cast_s(9); + } else if (vtop->type.t & 0x0080) { + type.t = vtop->type.t & (0x000f | 0x0010); + type.ref = vtop->type.ref; + gen_cast(&type); + } + } else if (arg == 0) { + tcc_error("too many arguments to function"); + } else { + type = arg->type; + type.t &= ~0x0100; + gen_assign_cast(&type); + } +} + + +static void expr_type(CType *type, void (*expr_fn)(void)) +{ + nocode_wanted++; + expr_fn(); + *type = vtop->type; + vpop(); + nocode_wanted--; +} + + + +static void parse_expr_type(CType *type) +{ + int n; + AttributeDef ad; + + skip('('); + if (parse_btype(type, &ad)) { + type_decl(type, &ad, &n, 1); + } else { + expr_type(type, gexpr); + } + skip(')'); +} + +static void parse_type(CType *type) +{ + AttributeDef ad; + int n; + + if (!parse_btype(type, &ad)) { + expect("type"); + } + type_decl(type, &ad, &n, 1); +} + +static void parse_builtin_params(int nc, const char *args) +{ + char c, sep = '('; + CType t; + if (nc) + nocode_wanted++; + next(); + while ((c = *args++)) { + skip(sep); + sep = ','; + switch (c) { + case 'e': expr_eq(); continue; + case 't': parse_type(&t); vpush(&t); continue; + default: tcc_error("internal error"); break; + } + } + skip(')'); + if (nc) + nocode_wanted--; +} + +static void unary(void) +{ + int n, t, align, size, r, sizeof_caller; + CType type; + Sym *s; + AttributeDef ad; + + sizeof_caller = in_sizeof; + in_sizeof = 0; + type.ref = 0; + + + tok_next: + switch(tok) { + case TOK_EXTENSION: + next(); + goto tok_next; + case 0xb4: + + + + + case 0xb5: + case 0xb3: + t = 3; + push_tokc: + type.t = t; + vsetc(&type, 0x0030, &tokc); + next(); + break; + case 0xb6: + t = 3 | 0x0010; + goto push_tokc; + case 0xb7: + t = 4; + goto push_tokc; + case 0xb8: + t = 4 | 0x0010; + goto push_tokc; + case 0xbb: + t = 8; + goto push_tokc; + case 0xbc: + t = 9; + goto push_tokc; + case 0xbd: + t = 10; + goto push_tokc; + case 0xce: + t = (8 == 8 ? 4 : 3) | 0x0800; + goto push_tokc; + case 0xcf: + t = (8 == 8 ? 4 : 3) | 0x0800 | 0x0010; + goto push_tokc; + case TOK___FUNCTION__: + if (!gnu_ext) + goto tok_identifier; + + case TOK___FUNC__: + { + void *ptr; + int len; + + len = strlen(funcname) + 1; + + type.t = 1; + mk_pointer(&type); + type.t |= 0x0040; + type.ref->c = len; + vpush_ref(&type, data_section, data_section->data_offset, len); + if (!(nocode_wanted > 0)) { + ptr = section_ptr_add(data_section, len); + memcpy(ptr, funcname, len); + } + next(); + } + break; + case 0xba: + + + + t = 3; + + goto str_init; + case 0xb9: + + t = 1; + if (tcc_state->char_is_unsigned) + t = 1 | 0x0010; + str_init: + if (tcc_state->warn_write_strings) + t |= 0x0100; + type.t = t; + mk_pointer(&type); + type.t |= 0x0040; + memset(&ad, 0, sizeof(AttributeDef)); + decl_initializer_alloc(&type, &ad, 0x0030, 2, 0, 0); + break; + case '(': + next(); + + if (parse_btype(&type, &ad)) { + type_decl(&type, &ad, &n, 1); + skip(')'); + + if (tok == '{') { + + if (global_expr) + r = 0x0030; + else + r = 0x0032; + + if (!(type.t & 0x0040)) + r |= lvalue_type(type.t); + memset(&ad, 0, sizeof(AttributeDef)); + decl_initializer_alloc(&type, &ad, r, 1, 0, 0); + } else { + if (sizeof_caller) { + vpush(&type); + return; + } + unary(); + gen_cast(&type); + } + } else if (tok == '{') { + int saved_nocode_wanted = nocode_wanted; + if (const_wanted) + tcc_error("expected constant"); + + save_regs(0); + + + + + + block(0, 0, 1); + nocode_wanted = saved_nocode_wanted; + skip(')'); + } else { + gexpr(); + skip(')'); + } + break; + case '*': + next(); + unary(); + indir(); + break; + case '&': + next(); + unary(); + + + + + + if ((vtop->type.t & 0x000f) != 6 && + !(vtop->type.t & 0x0040)) + test_lvalue(); + mk_pointer(&vtop->type); + gaddrof(); + break; + case '!': + next(); + unary(); + if ((vtop->r & (0x003f | 0x0100 | 0x0200)) == 0x0030) { + gen_cast_s(11); + vtop->c.i = !vtop->c.i; + } else if ((vtop->r & 0x003f) == 0x0033) + vtop->c.i ^= 1; + else { + save_regs(1); + vseti(0x0034, gvtst(1, 0)); + } + break; + case '~': + next(); + unary(); + vpushi(-1); + gen_op('^'); + break; + case '+': + next(); + unary(); + if ((vtop->type.t & 0x000f) == 5) + tcc_error("pointer not accepted for unary plus"); + + + + if (!is_float(vtop->type.t)) { + vpushi(0); + gen_op('+'); + } + break; + case TOK_SIZEOF: + case TOK_ALIGNOF1: + case TOK_ALIGNOF2: + t = tok; + next(); + in_sizeof++; + expr_type(&type, unary); + s = vtop[1].sym; + size = type_size(&type, &align); + if (s && s->a.aligned) + align = 1 << (s->a.aligned - 1); + if (t == TOK_SIZEOF) { + if (!(type.t & 0x0400)) { + if (size < 0) + tcc_error("sizeof applied to an incomplete type"); + vpushs(size); + } else { + vla_runtime_type_size(&type, &align); + } + } else { + vpushs(align); + } + vtop->type.t |= 0x0010; + break; + + case TOK_builtin_expect: + + parse_builtin_params(0, "ee"); + vpop(); + break; + case TOK_builtin_types_compatible_p: + parse_builtin_params(0, "tt"); + vtop[-1].type.t &= ~(0x0100 | 0x0200); + vtop[0].type.t &= ~(0x0100 | 0x0200); + n = is_compatible_types(&vtop[-1].type, &vtop[0].type); + vtop -= 2; + vpushi(n); + break; + case TOK_builtin_choose_expr: + { + int64_t c; + next(); + skip('('); + c = expr_const64(); + skip(','); + if (!c) { + nocode_wanted++; + } + expr_eq(); + if (!c) { + vpop(); + nocode_wanted--; + } + skip(','); + if (c) { + nocode_wanted++; + } + expr_eq(); + if (c) { + vpop(); + nocode_wanted--; + } + skip(')'); + } + break; + case TOK_builtin_constant_p: + parse_builtin_params(1, "e"); + n = (vtop->r & (0x003f | 0x0100 | 0x0200)) == 0x0030; + vtop--; + vpushi(n); + break; + case TOK_builtin_frame_address: + case TOK_builtin_return_address: + { + int tok1 = tok; + int level; + next(); + skip('('); + if (tok != 0xb5) { + tcc_error("%s only takes positive integers", + tok1 == TOK_builtin_return_address ? + "__builtin_return_address" : + "__builtin_frame_address"); + } + level = (uint32_t)tokc.i; + next(); + skip(')'); + type.t = 0; + mk_pointer(&type); + vset(&type, 0x0032, 0); + while (level--) { + mk_pointer(&vtop->type); + indir(); + } + if (tok1 == TOK_builtin_return_address) { + + vpushi(8); + gen_op('+'); + mk_pointer(&vtop->type); + indir(); + } + } + break; +# 4906 "tccgen.c" + case TOK_builtin_va_arg_types: + parse_builtin_params(0, "t"); + vpushi(classify_x86_64_va_arg(&vtop->type)); + vswap(); + vpop(); + break; +# 4942 "tccgen.c" + case 0xa4: + case 0xa2: + t = tok; + next(); + unary(); + inc(0, t); + break; + case '-': + next(); + unary(); + t = vtop->type.t & 0x000f; + if (is_float(t)) { + + + vpush(&vtop->type); + if (t == 8) + vtop->c.f = -1.0 * 0.0; + else if (t == 9) + vtop->c.d = -1.0 * 0.0; + else + vtop->c.ld = -1.0 * 0.0; + } else + vpushi(0); + vswap(); + gen_op('-'); + break; + case 0xa0: + if (!gnu_ext) + goto tok_identifier; + next(); + + if (tok < TOK_DEFINE) + expect("label identifier"); + s = label_find(tok); + if (!s) { + s = label_push(&global_label_stack, tok, 1); + } else { + if (s->r == 2) + s->r = 1; + } + if (!s->type.t) { + s->type.t = 0; + mk_pointer(&s->type); + s->type.t |= 0x00002000; + } + vpushsym(&s->type, s); + next(); + break; + + case TOK_GENERIC: + { + CType controlling_type; + int has_default = 0; + int has_match = 0; + int learn = 0; + TokenString *str = 0; + + next(); + skip('('); + expr_type(&controlling_type, expr_eq); + controlling_type.t &= ~(0x0100 | 0x0200 | 0x0040); + for (;;) { + learn = 0; + skip(','); + if (tok == TOK_DEFAULT) { + if (has_default) + tcc_error("too many 'default'"); + has_default = 1; + if (!has_match) + learn = 1; + next(); + } else { + AttributeDef ad_tmp; + int itmp; + CType cur_type; + parse_btype(&cur_type, &ad_tmp); + type_decl(&cur_type, &ad_tmp, &itmp, 1); + if (compare_types(&controlling_type, &cur_type, 0)) { + if (has_match) { + tcc_error("type match twice"); + } + has_match = 1; + learn = 1; + } + } + skip(':'); + if (learn) { + if (str) + tok_str_free(str); + skip_or_save_block(&str); + } else { + skip_or_save_block(0); + } + if (tok == ')') + break; + } + if (!str) { + char buf[60]; + type_to_str(buf, sizeof buf, &controlling_type, 0); + tcc_error("type '%s' does not match any association", buf); + } + begin_macro(str, 1); + next(); + expr_eq(); + if (tok != (-1)) + expect(","); + end_macro(); + next(); + break; + } + + case TOK___NAN__: + vpush64(9, 0x7ff8000000000000ULL); + next(); + break; + case TOK___SNAN__: + vpush64(9, 0x7ff0000000000001ULL); + next(); + break; + case TOK___INF__: + vpush64(9, 0x7ff0000000000000ULL); + next(); + break; + + default: + tok_identifier: + t = tok; + next(); + if (t < TOK_DEFINE) + expect("identifier"); + s = sym_find(t); + if (!s || (((s)->type.t & (0x000f | (0 | 0x0010))) == (0 | 0x0010))) { + const char *name = get_tok_str(t, 0); + if (tok != '(') + tcc_error("'%s' undeclared", name); + + + if (tcc_state->warn_implicit_function_declaration + + + + + + ) + tcc_warning("implicit declaration of function '%s'", name); + s = external_global_sym(t, &func_old_type, 0); + } + + r = s->r; + + + if ((r & 0x003f) < 0x0030) + r = (r & ~0x003f) | 0x0032; + + vset(&s->type, r, s->c); + + + + vtop->sym = s; + + if (r & 0x0200) { + vtop->c.i = 0; + } else if (r == 0x0030 && ((s->type.t & (((1 << (6+6)) - 1) << 20 | 0x0080)) == (3 << 20))) { + vtop->c.i = s->enum_val; + } + break; + } + + + while (1) { + if (tok == 0xa4 || tok == 0xa2) { + inc(1, tok); + next(); + } else if (tok == '.' || tok == 0xc7 || tok == 0xbc) { + int qualifiers; + + if (tok == 0xc7) + indir(); + qualifiers = vtop->type.t & (0x0100 | 0x0200); + test_lvalue(); + gaddrof(); + + if ((vtop->type.t & 0x000f) != 7) + expect("struct or union"); + if (tok == 0xbc) + expect("field name"); + next(); + if (tok == 0xb5 || tok == 0xb6) + expect("field name"); + s = find_field(&vtop->type, tok); + if (!s) + tcc_error("field not found: %s", get_tok_str(tok & ~0x20000000, &tokc)); + + vtop->type = char_pointer_type; + vpushi(s->c); + gen_op('+'); + + vtop->type = s->type; + vtop->type.t |= qualifiers; + + if (!(vtop->type.t & 0x0040)) { + vtop->r |= lvalue_type(vtop->type.t); + + + if (tcc_state->do_bounds_check && (vtop->r & 0x003f) != 0x0032) + vtop->r |= 0x0800; + + } + next(); + } else if (tok == '[') { + next(); + gexpr(); + gen_op('+'); + indir(); + skip(']'); + } else if (tok == '(') { + SValue ret; + Sym *sa; + int nb_args, ret_nregs, ret_align, regsize, variadic; + + + if ((vtop->type.t & 0x000f) != 6) { + + if ((vtop->type.t & (0x000f | 0x0040)) == 5) { + vtop->type = *pointed_type(&vtop->type); + if ((vtop->type.t & 0x000f) != 6) + goto error_func; + } else { + error_func: + expect("function pointer"); + } + } else { + vtop->r &= ~0x0100; + } + + s = vtop->type.ref; + next(); + sa = s->next; + nb_args = regsize = 0; + ret.r2 = 0x0030; + + if ((s->type.t & 0x000f) == 7) { + variadic = (s->f.func_type == 3); + ret_nregs = gfunc_sret(&s->type, variadic, &ret.type, + &ret_align, ®size); + if (!ret_nregs) { + + size = type_size(&s->type, &align); +# 5199 "tccgen.c" + loc = (loc - size) & -align; + ret.type = s->type; + ret.r = 0x0032 | 0x0100; + + + vseti(0x0032, loc); + ret.c = vtop->c; + nb_args++; + } + } else { + ret_nregs = 1; + ret.type = s->type; + } + + if (ret_nregs) { + + if (is_float(ret.type.t)) { + ret.r = reg_fret(ret.type.t); + + if ((ret.type.t & 0x000f) == 14) + ret.r2 = TREG_XMM1; + + } else { + + + if ((ret.type.t & 0x000f) == 13) + + + + ret.r2 = TREG_RDX; + + ret.r = TREG_RAX; + } + ret.c.i = 0; + } + if (tok != ')') { + for(;;) { + expr_eq(); + gfunc_param_typed(s, sa); + nb_args++; + if (sa) + sa = sa->next; + if (tok == ')') + break; + skip(','); + } + } + if (sa) + tcc_error("too few arguments to function"); + skip(')'); + gfunc_call(nb_args); + + + for (r = ret.r + ret_nregs + !ret_nregs; r-- > ret.r;) { + vsetc(&ret.type, r, &ret.c); + vtop->r2 = ret.r2; + } + + + if (((s->type.t & 0x000f) == 7) && ret_nregs) { + int addr, offset; + + size = type_size(&s->type, &align); + + + if (regsize > align) + align = regsize; + loc = (loc - size) & -align; + addr = loc; + offset = 0; + for (;;) { + vset(&ret.type, 0x0032 | 0x0100, addr + offset); + vswap(); + vstore(); + vtop--; + if (--ret_nregs == 0) + break; + offset += regsize; + } + vset(&s->type, 0x0032 | 0x0100, addr); + } + } else { + break; + } + } +} + +static void expr_prod(void) +{ + int t; + + unary(); + while (tok == '*' || tok == '/' || tok == '%') { + t = tok; + next(); + unary(); + gen_op(t); + } +} + +static void expr_sum(void) +{ + int t; + + expr_prod(); + while (tok == '+' || tok == '-') { + t = tok; + next(); + expr_prod(); + gen_op(t); + } +} + +static void expr_shift(void) +{ + int t; + + expr_sum(); + while (tok == 0x01 || tok == 0x02) { + t = tok; + next(); + expr_sum(); + gen_op(t); + } +} + +static void expr_cmp(void) +{ + int t; + + expr_shift(); + while ((tok >= 0x96 && tok <= 0x9f) || + tok == 0x92 || tok == 0x93) { + t = tok; + next(); + expr_shift(); + gen_op(t); + } +} + +static void expr_cmpeq(void) +{ + int t; + + expr_cmp(); + while (tok == 0x94 || tok == 0x95) { + t = tok; + next(); + expr_cmp(); + gen_op(t); + } +} + +static void expr_and(void) +{ + expr_cmpeq(); + while (tok == '&') { + next(); + expr_cmpeq(); + gen_op('&'); + } +} + +static void expr_xor(void) +{ + expr_and(); + while (tok == '^') { + next(); + expr_and(); + gen_op('^'); + } +} + +static void expr_or(void) +{ + expr_xor(); + while (tok == '|') { + next(); + expr_xor(); + gen_op('|'); + } +} + +static void expr_land(void) +{ + expr_or(); + if (tok == 0xa0) { + int t = 0; + for(;;) { + if ((vtop->r & (0x003f | 0x0100 | 0x0200)) == 0x0030) { + gen_cast_s(11); + if (vtop->c.i) { + vpop(); + } else { + nocode_wanted++; + while (tok == 0xa0) { + next(); + expr_or(); + vpop(); + } + nocode_wanted--; + if (t) + gsym(t); + gen_cast_s(3); + break; + } + } else { + if (!t) + save_regs(1); + t = gvtst(1, t); + } + if (tok != 0xa0) { + if (t) + vseti(0x0035, t); + else + vpushi(1); + break; + } + next(); + expr_or(); + } + } +} + +static void expr_lor(void) +{ + expr_land(); + if (tok == 0xa1) { + int t = 0; + for(;;) { + if ((vtop->r & (0x003f | 0x0100 | 0x0200)) == 0x0030) { + gen_cast_s(11); + if (!vtop->c.i) { + vpop(); + } else { + nocode_wanted++; + while (tok == 0xa1) { + next(); + expr_land(); + vpop(); + } + nocode_wanted--; + if (t) + gsym(t); + gen_cast_s(3); + break; + } + } else { + if (!t) + save_regs(1); + t = gvtst(0, t); + } + if (tok != 0xa1) { + if (t) + vseti(0x0034, t); + else + vpushi(0); + break; + } + next(); + expr_land(); + } + } +} + + + + +static int condition_3way(void) +{ + int c = -1; + if ((vtop->r & (0x003f | 0x0100)) == 0x0030 && + (!(vtop->r & 0x0200) || !vtop->sym->a.weak)) { + vdup(); + gen_cast_s(11); + c = vtop->c.i; + vpop(); + } + return c; +} + +static void expr_cond(void) +{ + int tt, u, r1, r2, rc, t1, t2, bt1, bt2, islv, c, g; + SValue sv; + CType type, type1, type2; + + expr_lor(); + if (tok == '?') { + next(); + c = condition_3way(); + g = (tok == ':' && gnu_ext); + if (c < 0) { + + + if (is_float(vtop->type.t)) { + rc = 0x0002; + + if ((vtop->type.t & 0x000f) == 10) { + rc = 0x0080; + } + + } else + rc = 0x0001; + gv(rc); + save_regs(1); + if (g) + gv_dup(); + tt = gvtst(1, 0); + + } else { + if (!g) + vpop(); + tt = 0; + } + + if (1) { + if (c == 0) + nocode_wanted++; + if (!g) + gexpr(); + + type1 = vtop->type; + sv = *vtop; + vtop--; + skip(':'); + + u = 0; + if (c < 0) + u = gjmp(0); + gsym(tt); + + if (c == 0) + nocode_wanted--; + if (c == 1) + nocode_wanted++; + expr_cond(); + if (c == 1) + nocode_wanted--; + + type2 = vtop->type; + t1 = type1.t; + bt1 = t1 & 0x000f; + t2 = type2.t; + bt2 = t2 & 0x000f; + type.ref = 0; + + + if (is_float(bt1) || is_float(bt2)) { + if (bt1 == 10 || bt2 == 10) { + type.t = 10; + + } else if (bt1 == 9 || bt2 == 9) { + type.t = 9; + } else { + type.t = 8; + } + } else if (bt1 == 4 || bt2 == 4) { + + type.t = 4 | 0x0800; + if (bt1 == 4) + type.t &= t1; + if (bt2 == 4) + type.t &= t2; + + if ((t1 & (0x000f | 0x0010 | 0x0080)) == (4 | 0x0010) || + (t2 & (0x000f | 0x0010 | 0x0080)) == (4 | 0x0010)) + type.t |= 0x0010; + } else if (bt1 == 5 || bt2 == 5) { + + + if (is_null_pointer (vtop)) + type = type1; + else if (is_null_pointer (&sv)) + type = type2; + + + else + type = type1; + } else if (bt1 == 6 || bt2 == 6) { + + type = bt1 == 6 ? type1 : type2; + } else if (bt1 == 7 || bt2 == 7) { + + type = bt1 == 7 ? type1 : type2; + } else if (bt1 == 0 || bt2 == 0) { + + type.t = 0; + } else { + + type.t = 3 | (0x0800 & (t1 | t2)); + + if ((t1 & (0x000f | 0x0010 | 0x0080)) == (3 | 0x0010) || + (t2 & (0x000f | 0x0010 | 0x0080)) == (3 | 0x0010)) + type.t |= 0x0010; + } + + + islv = (vtop->r & 0x0100) && (sv.r & 0x0100) && 7 == (type.t & 0x000f); + islv &= c < 0; + + + if (c != 1) { + gen_cast(&type); + if (islv) { + mk_pointer(&vtop->type); + gaddrof(); + } else if (7 == (vtop->type.t & 0x000f)) + gaddrof(); + } + + rc = 0x0001; + if (is_float(type.t)) { + rc = 0x0002; + + if ((type.t & 0x000f) == 10) { + rc = 0x0080; + } + + } else if ((type.t & 0x000f) == 4) { + + + rc = 0x0004; + } + + tt = r2 = 0; + if (c < 0) { + r2 = gv(rc); + tt = gjmp(0); + } + gsym(u); + + + + if (c != 0) { + *vtop = sv; + gen_cast(&type); + if (islv) { + mk_pointer(&vtop->type); + gaddrof(); + } else if (7 == (vtop->type.t & 0x000f)) + gaddrof(); + } + + if (c < 0) { + r1 = gv(rc); + move_reg(r2, r1, type.t); + vtop->r = r2; + gsym(tt); + if (islv) + indir(); + } + } + } +} + +static void expr_eq(void) +{ + int t; + + expr_cond(); + if (tok == '=' || + (tok >= 0xa5 && tok <= 0xaf) || + tok == 0xde || tok == 0xfc || + tok == 0x81 || tok == 0x82) { + test_lvalue(); + t = tok; + next(); + if (t == '=') { + expr_eq(); + } else { + vdup(); + expr_eq(); + gen_op(t & 0x7f); + } + vstore(); + } +} + +static void gexpr(void) +{ + while (1) { + expr_eq(); + if (tok != ',') + break; + vpop(); + next(); + } +} + + +static void expr_const1(void) +{ + const_wanted++; + nocode_wanted++; + expr_cond(); + nocode_wanted--; + const_wanted--; +} + + +static inline int64_t expr_const64(void) +{ + int64_t c; + expr_const1(); + if ((vtop->r & (0x003f | 0x0100 | 0x0200)) != 0x0030) + expect("constant expression"); + c = vtop->c.i; + vpop(); + return c; +} + + + +static int expr_const(void) +{ + int c; + int64_t wc = expr_const64(); + c = wc; + if (c != wc && (unsigned)c != wc) + tcc_error("constant exceeds 32 bit"); + return c; +} + + + +static int is_label(void) +{ + int last_tok; + + + if (tok < TOK_DEFINE) + return 0; + + last_tok = tok; + next(); + if (tok == ':') { + return last_tok; + } else { + unget_tok(last_tok); + return 0; + } +} + + +static void gfunc_return(CType *func_type) +{ + if ((func_type->t & 0x000f) == 7) { + CType type, ret_type; + int ret_align, ret_nregs, regsize; + ret_nregs = gfunc_sret(func_type, func_var, &ret_type, + &ret_align, ®size); + if (0 == ret_nregs) { + + + type = *func_type; + mk_pointer(&type); + vset(&type, 0x0032 | 0x0100, func_vc); + indir(); + vswap(); + + vstore(); + } else { + + int r, size, addr, align; + size = type_size(func_type,&align); + if ((vtop->r != (0x0032 | 0x0100) || + (vtop->c.i & (ret_align-1))) + && (align & (ret_align-1))) { + loc = (loc - size) & -ret_align; + addr = loc; + type = *func_type; + vset(&type, 0x0032 | 0x0100, addr); + vswap(); + vstore(); + vpop(); + vset(&ret_type, 0x0032 | 0x0100, addr); + } + vtop->type = ret_type; + if (is_float(ret_type.t)) + r = rc_fret(ret_type.t); + else + r = 0x0004; + + if (ret_nregs == 1) + gv(r); + else { + for (;;) { + vdup(); + gv(r); + vpop(); + if (--ret_nregs == 0) + break; + + + + r <<= 1; + vtop->c.i += regsize; + } + } + } + } else if (is_float(func_type->t)) { + gv(rc_fret(func_type->t)); + } else { + gv(0x0004); + } + vtop--; +} + + +static int case_cmp(const void *pa, const void *pb) +{ + int64_t a = (*(struct case_t**) pa)->v1; + int64_t b = (*(struct case_t**) pb)->v1; + return a < b ? -1 : a > b; +} + +static void gcase(struct case_t **base, int len, int *bsym) +{ + struct case_t *p; + int e; + int ll = (vtop->type.t & 0x000f) == 4; + gv(0x0001); + while (len > 4) { + + p = base[len/2]; + vdup(); + if (ll) + vpushll(p->v2); + else + vpushi(p->v2); + gen_op(0x9e); + e = gtst(1, 0); + vdup(); + if (ll) + vpushll(p->v1); + else + vpushi(p->v1); + gen_op(0x9d); + gtst_addr(0, p->sym); + + gcase(base, len/2, bsym); + if (cur_switch->def_sym) + gjmp_addr(cur_switch->def_sym); + else + *bsym = gjmp(*bsym); + + gsym(e); + e = len/2 + 1; + base += e; len -= e; + } + + while (len--) { + p = *base++; + vdup(); + if (ll) + vpushll(p->v2); + else + vpushi(p->v2); + if (p->v1 == p->v2) { + gen_op(0x94); + gtst_addr(0, p->sym); + } else { + gen_op(0x9e); + e = gtst(1, 0); + vdup(); + if (ll) + vpushll(p->v1); + else + vpushi(p->v1); + gen_op(0x9d); + gtst_addr(0, p->sym); + gsym(e); + } + } +} + +static void block(int *bsym, int *csym, int is_expr) +{ + int a, b, c, d, cond; + Sym *s; + + + if (tcc_state->do_debug) + tcc_debug_line(tcc_state); + + if (is_expr) { + + vpushi(0); + vtop->type.t = 0; + } + + if (tok == TOK_IF) { + + int saved_nocode_wanted = nocode_wanted; + next(); + skip('('); + gexpr(); + skip(')'); + cond = condition_3way(); + if (cond == 1) + a = 0, vpop(); + else + a = gvtst(1, 0); + if (cond == 0) + nocode_wanted |= 0x20000000; + block(bsym, csym, 0); + if (cond != 1) + nocode_wanted = saved_nocode_wanted; + c = tok; + if (c == TOK_ELSE) { + next(); + d = gjmp(0); + gsym(a); + if (cond == 1) + nocode_wanted |= 0x20000000; + block(bsym, csym, 0); + gsym(d); + if (cond != 0) + nocode_wanted = saved_nocode_wanted; + } else + gsym(a); + } else if (tok == TOK_WHILE) { + int saved_nocode_wanted; + nocode_wanted &= ~0x20000000; + next(); + d = ind; + vla_sp_restore(); + skip('('); + gexpr(); + skip(')'); + a = gvtst(1, 0); + b = 0; + ++local_scope; + saved_nocode_wanted = nocode_wanted; + block(&a, &b, 0); + nocode_wanted = saved_nocode_wanted; + --local_scope; + gjmp_addr(d); + gsym(a); + gsym_addr(b, d); + } else if (tok == '{') { + Sym *llabel; + int block_vla_sp_loc = vla_sp_loc, saved_vlas_in_scope = vlas_in_scope; + + next(); + + s = local_stack; + llabel = local_label_stack; + ++local_scope; + + + if (tok == TOK_LABEL) { + next(); + for(;;) { + if (tok < TOK_DEFINE) + expect("label identifier"); + label_push(&local_label_stack, tok, 2); + next(); + if (tok == ',') { + next(); + } else { + skip(';'); + break; + } + } + } + while (tok != '}') { + if ((a = is_label())) + unget_tok(a); + else + decl(0x0032); + if (tok != '}') { + if (is_expr) + vpop(); + block(bsym, csym, is_expr); + } + } + + label_pop(&local_label_stack, llabel, is_expr); + + --local_scope; + + + + + + + + sym_pop(&local_stack, s, is_expr); + + + if (vlas_in_scope > saved_vlas_in_scope) { + vla_sp_loc = saved_vlas_in_scope ? block_vla_sp_loc : vla_sp_root_loc; + vla_sp_restore(); + } + vlas_in_scope = saved_vlas_in_scope; + + next(); + } else if (tok == TOK_RETURN) { + next(); + if (tok != ';') { + gexpr(); + gen_assign_cast(&func_vt); + if ((func_vt.t & 0x000f) == 0) + vtop--; + else + gfunc_return(&func_vt); + } + skip(';'); + + if (tok != '}' || local_scope != 1) + rsym = gjmp(rsym); + nocode_wanted |= 0x20000000; + } else if (tok == TOK_BREAK) { + + if (!bsym) + tcc_error("cannot break"); + *bsym = gjmp(*bsym); + next(); + skip(';'); + nocode_wanted |= 0x20000000; + } else if (tok == TOK_CONTINUE) { + + if (!csym) + tcc_error("cannot continue"); + vla_sp_restore_root(); + *csym = gjmp(*csym); + next(); + skip(';'); + } else if (tok == TOK_FOR) { + int e; + int saved_nocode_wanted; + nocode_wanted &= ~0x20000000; + next(); + skip('('); + s = local_stack; + ++local_scope; + if (tok != ';') { + + if (!decl0(0x0032, 1, 0)) { + + gexpr(); + vpop(); + } + } + skip(';'); + d = ind; + c = ind; + vla_sp_restore(); + a = 0; + b = 0; + if (tok != ';') { + gexpr(); + a = gvtst(1, 0); + } + skip(';'); + if (tok != ')') { + e = gjmp(0); + c = ind; + vla_sp_restore(); + gexpr(); + vpop(); + gjmp_addr(d); + gsym(e); + } + skip(')'); + saved_nocode_wanted = nocode_wanted; + block(&a, &b, 0); + nocode_wanted = saved_nocode_wanted; + gjmp_addr(c); + gsym(a); + gsym_addr(b, c); + --local_scope; + sym_pop(&local_stack, s, 0); + + } else + if (tok == TOK_DO) { + int saved_nocode_wanted; + nocode_wanted &= ~0x20000000; + next(); + a = 0; + b = 0; + d = ind; + vla_sp_restore(); + saved_nocode_wanted = nocode_wanted; + block(&a, &b, 0); + skip(TOK_WHILE); + skip('('); + gsym(b); + gexpr(); + c = gvtst(0, 0); + gsym_addr(c, d); + nocode_wanted = saved_nocode_wanted; + skip(')'); + gsym(a); + skip(';'); + } else + if (tok == TOK_SWITCH) { + struct switch_t *saved, sw; + int saved_nocode_wanted = nocode_wanted; + SValue switchval; + next(); + skip('('); + gexpr(); + skip(')'); + switchval = *vtop--; + a = 0; + b = gjmp(0); + sw.p = 0; sw.n = 0; sw.def_sym = 0; + saved = cur_switch; + cur_switch = &sw; + block(&a, csym, 0); + nocode_wanted = saved_nocode_wanted; + a = gjmp(a); + + gsym(b); + qsort(sw.p, sw.n, sizeof(void*), case_cmp); + for (b = 1; b < sw.n; b++) + if (sw.p[b - 1]->v2 >= sw.p[b]->v1) + tcc_error("duplicate case value"); + + + if ((switchval.type.t & 0x000f) == 4) + switchval.type.t &= ~0x0010; + vpushv(&switchval); + gcase(sw.p, sw.n, &a); + vpop(); + if (sw.def_sym) + gjmp_addr(sw.def_sym); + dynarray_reset(&sw.p, &sw.n); + cur_switch = saved; + + gsym(a); + } else + if (tok == TOK_CASE) { + struct case_t *cr = tcc_malloc(sizeof(struct case_t)); + if (!cur_switch) + expect("switch"); + nocode_wanted &= ~0x20000000; + next(); + cr->v1 = cr->v2 = expr_const64(); + if (gnu_ext && tok == 0xc8) { + next(); + cr->v2 = expr_const64(); + if (cr->v2 < cr->v1) + tcc_warning("empty case range"); + } + cr->sym = ind; + dynarray_add(&cur_switch->p, &cur_switch->n, cr); + skip(':'); + is_expr = 0; + goto block_after_label; + } else + if (tok == TOK_DEFAULT) { + next(); + skip(':'); + if (!cur_switch) + expect("switch"); + if (cur_switch->def_sym) + tcc_error("too many 'default'"); + cur_switch->def_sym = ind; + is_expr = 0; + goto block_after_label; + } else + if (tok == TOK_GOTO) { + next(); + if (tok == '*' && gnu_ext) { + + next(); + gexpr(); + if ((vtop->type.t & 0x000f) != 5) + expect("pointer"); + ggoto(); + } else if (tok >= TOK_DEFINE) { + s = label_find(tok); + + if (!s) { + s = label_push(&global_label_stack, tok, 1); + } else { + if (s->r == 2) + s->r = 1; + } + vla_sp_restore_root(); + if (s->r & 1) + s->jnext = gjmp(s->jnext); + else + gjmp_addr(s->jnext); + next(); + } else { + expect("label identifier"); + } + skip(';'); + } else if (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3) { + asm_instr(); + } else { + b = is_label(); + if (b) { + + next(); + s = label_find(b); + if (s) { + if (s->r == 0) + tcc_error("duplicate label '%s'", get_tok_str(s->v, 0)); + gsym(s->jnext); + s->r = 0; + } else { + s = label_push(&global_label_stack, b, 0); + } + s->jnext = ind; + vla_sp_restore(); + + block_after_label: + nocode_wanted &= ~0x20000000; + if (tok == '}') { + tcc_warning("deprecated use of label at end of compound statement"); + } else { + if (is_expr) + vpop(); + block(bsym, csym, is_expr); + } + } else { + + if (tok != ';') { + if (is_expr) { + vpop(); + gexpr(); + } else { + gexpr(); + vpop(); + } + } + skip(';'); + } + } +} + + + + + + +static void skip_or_save_block(TokenString **str) +{ + int braces = tok == '{'; + int level = 0; + if (str) + *str = tok_str_alloc(); + + while ((level > 0 || (tok != '}' && tok != ',' && tok != ';' && tok != ')'))) { + int t; + if (tok == (-1)) { + if (str || level > 0) + tcc_error("unexpected end of file"); + else + break; + } + if (str) + tok_str_add_tok(*str); + t = tok; + next(); + if (t == '{' || t == '(') { + level++; + } else if (t == '}' || t == ')') { + level--; + if (level == 0 && braces && t == '}') + break; + } + } + if (str) { + tok_str_add(*str, -1); + tok_str_add(*str, 0); + } +} + + + + +static void parse_init_elem(int expr_type) +{ + int saved_global_expr; + switch(expr_type) { + case 1: + + saved_global_expr = global_expr; + global_expr = 1; + expr_const1(); + global_expr = saved_global_expr; + + + if (((vtop->r & (0x003f | 0x0100)) != 0x0030 + && ((vtop->r & (0x0200|0x0100)) != (0x0200|0x0100) + || vtop->sym->v < 0x10000000)) + + + + ) + tcc_error("initializer element is not constant"); + break; + case 2: + expr_eq(); + break; + } +} + + +static void init_putz(Section *sec, unsigned long c, int size) +{ + if (sec) { + + } else { + vpush_global_sym(&func_old_type, TOK_memset); + vseti(0x0032, c); + + + + + vpushi(0); + vpushs(size); + + gfunc_call(3); + } +} + + + + + + + +static int decl_designator(CType *type, Section *sec, unsigned long c, + Sym **cur_field, int size_only, int al) +{ + Sym *s, *f; + int index, index_last, align, l, nb_elems, elem_size; + unsigned long corig = c; + + elem_size = 0; + nb_elems = 1; + if (gnu_ext && (l = is_label()) != 0) + goto struct_field; + + while (nb_elems == 1 && (tok == '[' || tok == '.')) { + if (tok == '[') { + if (!(type->t & 0x0040)) + expect("array type"); + next(); + index = index_last = expr_const(); + if (tok == 0xc8 && gnu_ext) { + next(); + index_last = expr_const(); + } + skip(']'); + s = type->ref; + if (index < 0 || (s->c >= 0 && index_last >= s->c) || + index_last < index) + tcc_error("invalid index"); + if (cur_field) + (*cur_field)->c = index_last; + type = pointed_type(type); + elem_size = type_size(type, &align); + c += index * elem_size; + nb_elems = index_last - index + 1; + } else { + next(); + l = tok; + struct_field: + next(); + if ((type->t & 0x000f) != 7) + expect("struct/union type"); + f = find_field(type, l); + if (!f) + expect("field"); + if (cur_field) + *cur_field = f; + type = &f->type; + c += f->c; + } + cur_field = 0; + } + if (!cur_field) { + if (tok == '=') { + next(); + } else if (!gnu_ext) { + expect("="); + } + } else { + if (type->t & 0x0040) { + index = (*cur_field)->c; + if (type->ref->c >= 0 && index >= type->ref->c) + tcc_error("index too large"); + type = pointed_type(type); + c += index * type_size(type, &align); + } else { + f = *cur_field; + while (f && (f->v & 0x10000000) && (f->type.t & 0x0080)) + *cur_field = f = f->next; + if (!f) + tcc_error("too many field init"); + type = &f->type; + c += f->c; + } + } + + + if (!size_only && c - corig > al) + init_putz(sec, corig + al, c - corig - al); + decl_initializer(type, sec, c, 0, size_only); + + + if (!size_only && nb_elems > 1) { + unsigned long c_end; + uint8_t *src, *dst; + int i; + + if (!sec) { + vset(type, 0x0032|0x0100, c); + for (i = 1; i < nb_elems; i++) { + vset(type, 0x0032|0x0100, c + elem_size * i); + vswap(); + vstore(); + } + vpop(); + } else if (!(nocode_wanted > 0)) { + c_end = c + nb_elems * elem_size; + if (c_end > sec->data_allocated) + section_realloc(sec, c_end); + src = sec->data + c; + dst = src; + for(i = 1; i < nb_elems; i++) { + dst += elem_size; + memcpy(dst, src, elem_size); + } + } + } + c += nb_elems * type_size(type, &align); + if (c - corig > al) + al = c - corig; + return al; +} + + +static void init_putv(CType *type, Section *sec, unsigned long c) +{ + int bt; + void *ptr; + CType dtype; + + dtype = *type; + dtype.t &= ~0x0100; + + if (sec) { + int size, align; + + + gen_assign_cast(&dtype); + bt = type->t & 0x000f; + + if ((vtop->r & 0x0200) + && bt != 5 + && bt != 6 + && (bt != (8 == 8 ? 4 : 3) + || (type->t & 0x0080)) + && !((vtop->r & 0x0030) && vtop->sym->v >= 0x10000000) + ) + tcc_error("initializer element is not computable at load time"); + + if ((nocode_wanted > 0)) { + vtop--; + return; + } + + size = type_size(type, &align); + section_reserve(sec, c + size); + ptr = sec->data + c; + + + if ((vtop->r & (0x0200|0x0030)) == (0x0200|0x0030) && + vtop->sym->v >= 0x10000000 && +# 6488 "tccgen.c" + (vtop->type.t & 0x000f) != 5) { + + Section *ssec; + Elf64_Sym *esym; + Elf64_Rela *rel; + esym = elfsym(vtop->sym); + ssec = tcc_state->sections[esym->st_shndx]; + memmove (ptr, ssec->data + esym->st_value, size); + if (ssec->reloc) { + + + + + int num_relocs = ssec->reloc->data_offset / sizeof(*rel); + rel = (Elf64_Rela*)(ssec->reloc->data + ssec->reloc->data_offset); + while (num_relocs--) { + rel--; + if (rel->r_offset >= esym->st_value + size) + continue; + if (rel->r_offset < esym->st_value) + break; + + + + + + + put_elf_reloca(symtab_section, sec, + c + rel->r_offset - esym->st_value, + ((rel->r_info) & 0xffffffff), + ((rel->r_info) >> 32), + + rel->r_addend + + + + ); + } + } + } else { + if (type->t & 0x0080) { + int bit_pos, bit_size, bits, n; + unsigned char *p, v, m; + bit_pos = (((vtop->type.t) >> 20) & 0x3f); + bit_size = (((vtop->type.t) >> (20 + 6)) & 0x3f); + p = (unsigned char*)ptr + (bit_pos >> 3); + bit_pos &= 7, bits = 0; + while (bit_size) { + n = 8 - bit_pos; + if (n > bit_size) + n = bit_size; + v = vtop->c.i >> bits << bit_pos; + m = ((1 << n) - 1) << bit_pos; + *p = (*p & ~m) | (v & m); + bits += n, bit_size -= n, bit_pos = 0, ++p; + } + } else + switch(bt) { + + + + case 11: + vtop->c.i = vtop->c.i != 0; + case 1: + *(char *)ptr |= vtop->c.i; + break; + case 2: + *(short *)ptr |= vtop->c.i; + break; + case 8: + *(float*)ptr = vtop->c.f; + break; + case 9: + *(double *)ptr = vtop->c.d; + break; + case 10: + + if (sizeof (long double) >= 10) + memcpy(ptr, &vtop->c.ld, 10); + + + + + else if (vtop->c.ld == 0.0) + ; + else + + if (sizeof(long double) == 16) + *(long double*)ptr = vtop->c.ld; + else if (sizeof(double) == 16) + *(double *)ptr = (double)vtop->c.ld; + else + tcc_error("can't cross compile long double constants"); + break; + + + + + + case 4: + + case 5: + { + Elf64_Addr val = vtop->c.i; + + if (vtop->r & 0x0200) + greloca(sec, vtop->sym, c, 1, val); + else + *(Elf64_Addr *)ptr |= val; + + + + + + break; + } + default: + { + int val = vtop->c.i; + + if (vtop->r & 0x0200) + greloca(sec, vtop->sym, c, 1, val); + else + *(int *)ptr |= val; + + + + + + break; + } + } + } + vtop--; + } else { + vset(&dtype, 0x0032|0x0100, c); + vswap(); + vstore(); + vpop(); + } +} + + + + + + +static void decl_initializer(CType *type, Section *sec, unsigned long c, + int first, int size_only) +{ + int len, n, no_oblock, nb, i; + int size1, align1; + int have_elem; + Sym *s, *f; + Sym indexsym; + CType *t1; + + + + have_elem = tok == '}' || tok == ','; + if (!have_elem && tok != '{' && + + + + tok != 0xba && tok != 0xb9 && + !size_only) { + parse_init_elem(!sec ? 2 : 1); + have_elem = 1; + } + + if (have_elem && + !(type->t & 0x0040) && + + + + is_compatible_unqualified_types(type, &vtop->type)) { + init_putv(type, sec, c); + } else if (type->t & 0x0040) { + s = type->ref; + n = s->c; + t1 = pointed_type(type); + size1 = type_size(t1, &align1); + + no_oblock = 1; + if ((first && tok != 0xba && tok != 0xb9) || + tok == '{') { + if (tok != '{') + tcc_error("character array initializer must be a literal," + " optionally enclosed in braces"); + skip('{'); + no_oblock = 0; + } + + + + if ((tok == 0xba && + + + + (t1->t & 0x000f) == 3 + + ) || (tok == 0xb9 && (t1->t & 0x000f) == 1)) { + len = 0; + while (tok == 0xb9 || tok == 0xba) { + int cstr_len, ch; + + + if (tok == 0xb9) + cstr_len = tokc.str.size; + else + cstr_len = tokc.str.size / sizeof(nwchar_t); + cstr_len--; + nb = cstr_len; + if (n >= 0 && nb > (n - len)) + nb = n - len; + if (!size_only) { + if (cstr_len > nb) + tcc_warning("initializer-string for array is too long"); + + + + if (sec && tok == 0xb9 && size1 == 1) { + if (!(nocode_wanted > 0)) + memcpy(sec->data + c + len, tokc.str.data, nb); + } else { + for(i=0;i<nb;i++) { + if (tok == 0xb9) + ch = ((unsigned char *)tokc.str.data)[i]; + else + ch = ((nwchar_t *)tokc.str.data)[i]; + vpushi(ch); + init_putv(t1, sec, c + (len + i) * size1); + } + } + } + len += nb; + next(); + } + + + if (n < 0 || len < n) { + if (!size_only) { + vpushi(0); + init_putv(t1, sec, c + (len * size1)); + } + len++; + } + len *= size1; + } else { + indexsym.c = 0; + f = &indexsym; + + do_init_list: + len = 0; + while (tok != '}' || have_elem) { + len = decl_designator(type, sec, c, &f, size_only, len); + have_elem = 0; + if (type->t & 0x0040) { + ++indexsym.c; + + + + if (no_oblock && len >= n*size1) + break; + } else { + if (s->type.t == (1 << 20 | 7)) + f = 0; + else + f = f->next; + if (no_oblock && f == 0) + break; + } + + if (tok == '}') + break; + skip(','); + } + } + + if (!size_only && len < n*size1) + init_putz(sec, c + len, n*size1 - len); + if (!no_oblock) + skip('}'); + + if (n < 0) + s->c = size1 == 1 ? len : ((len + size1 - 1)/size1); + } else if ((type->t & 0x000f) == 7) { + size1 = 1; + no_oblock = 1; + if (first || tok == '{') { + skip('{'); + no_oblock = 0; + } + s = type->ref; + f = s->next; + n = s->c; + goto do_init_list; + } else if (tok == '{') { + next(); + decl_initializer(type, sec, c, first, size_only); + skip('}'); + } else if (size_only) { + + + + + + + + skip_or_save_block(0); + } else { + if (!have_elem) { + + + + if (tok != 0xb9 && tok != 0xba) + expect("string constant"); + parse_init_elem(!sec ? 2 : 1); + } + init_putv(type, sec, c); + } +} +# 6818 "tccgen.c" +static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, + int has_init, int v, int scope) +{ + int size, align, addr; + TokenString *init_str = 0; + + Section *sec; + Sym *flexible_array; + Sym *sym = 0; + int saved_nocode_wanted = nocode_wanted; + + int bcheck = tcc_state->do_bounds_check && !(nocode_wanted > 0); + + + if (type->t & 0x00002000) + nocode_wanted |= (nocode_wanted > 0) ? 0x40000000 : 0x80000000; + + flexible_array = 0; + if ((type->t & 0x000f) == 7) { + Sym *field = type->ref->next; + if (field) { + while (field->next) + field = field->next; + if (field->type.t & 0x0040 && field->type.ref->c < 0) + flexible_array = field; + } + } + + size = type_size(type, &align); + + + + + + + if (size < 0 || (flexible_array && has_init)) { + if (!has_init) + tcc_error("unknown type size"); + + if (has_init == 2) { + init_str = tok_str_alloc(); + + while (tok == 0xb9 || tok == 0xba) { + tok_str_add_tok(init_str); + next(); + } + tok_str_add(init_str, -1); + tok_str_add(init_str, 0); + } else { + skip_or_save_block(&init_str); + } + unget_tok(0); + + + begin_macro(init_str, 1); + next(); + decl_initializer(type, 0, 0, 1, 1); + + macro_ptr = init_str->str; + next(); + + + size = type_size(type, &align); + if (size < 0) + tcc_error("unknown type size"); + } + + + if (flexible_array && + flexible_array->type.ref->c > 0) + size += flexible_array->type.ref->c + * pointed_size(&flexible_array->type); + + if (ad->a.aligned) { + int speca = 1 << (ad->a.aligned - 1); + if (speca > align) + align = speca; + } else if (ad->a.packed) { + align = 1; + } + + if ((nocode_wanted > 0)) + size = 0, align = 1; + + if ((r & 0x003f) == 0x0032) { + sec = 0; + + if (bcheck && (type->t & 0x0040)) { + loc--; + } + + loc = (loc - size) & -align; + addr = loc; + + + + + if (bcheck && (type->t & 0x0040)) { + Elf64_Addr *bounds_ptr; + + loc--; + + bounds_ptr = section_ptr_add(lbounds_section, 2 * sizeof(Elf64_Addr)); + bounds_ptr[0] = addr; + bounds_ptr[1] = size; + } + + if (v) { + + + if (ad->asm_label) { + int reg = asm_parse_regvar(ad->asm_label); + if (reg >= 0) + r = (r & ~0x003f) | reg; + } + + sym = sym_push(v, type, r, addr); + sym->a = ad->a; + } else { + + vset(type, r, addr); + } + } else { + if (v && scope == 0x0030) { + + sym = sym_find(v); + if (sym) { + patch_storage(sym, ad, type); + + if (!has_init && sym->c && elfsym(sym)->st_shndx != 0) + goto no_alloc; + } + } + + + sec = ad->section; + if (!sec) { + if (has_init) + sec = data_section; + else if (tcc_state->nocommon) + sec = bss_section; + } + + if (sec) { + addr = section_add(sec, size, align); + + + if (bcheck) + section_add(sec, 1, 1); + + } else { + addr = align; + sec = common_section; + } + + if (v) { + if (!sym) { + sym = sym_push(v, type, r | 0x0200, 0); + patch_storage(sym, ad, 0); + } + + + sym->sym_scope = 0; + + put_extern_sym(sym, sec, addr, size); + } else { + + sym = get_sym_ref(type, sec, addr, size); + vpushsym(type, sym); + vtop->r |= r; + } + + + + + if (bcheck) { + Elf64_Addr *bounds_ptr; + + greloca(bounds_section, sym, bounds_section->data_offset, 1, 0); + + bounds_ptr = section_ptr_add(bounds_section, 2 * sizeof(Elf64_Addr)); + bounds_ptr[0] = 0; + bounds_ptr[1] = size; + } + + } + + if (type->t & 0x0400) { + int a; + + if ((nocode_wanted > 0)) + goto no_alloc; + + + if (vlas_in_scope == 0) { + if (vla_sp_root_loc == -1) + vla_sp_root_loc = (loc -= 8); + gen_vla_sp_save(vla_sp_root_loc); + } + + vla_runtime_type_size(type, &a); + gen_vla_alloc(type, a); + + + + + + gen_vla_sp_save(addr); + vla_sp_loc = addr; + vlas_in_scope++; + + } else if (has_init) { + size_t oldreloc_offset = 0; + if (sec && sec->reloc) + oldreloc_offset = sec->reloc->data_offset; + decl_initializer(type, sec, addr, 1, 0); + if (sec && sec->reloc) + squeeze_multi_relocs(sec, oldreloc_offset); + + + if (flexible_array) + flexible_array->type.ref->c = -1; + } + + no_alloc: + + if (init_str) { + end_macro(); + next(); + } + + nocode_wanted = saved_nocode_wanted; +} + + + +static void gen_function(Sym *sym) +{ + nocode_wanted = 0; + ind = cur_text_section->data_offset; + + put_extern_sym(sym, cur_text_section, ind, 0); + funcname = get_tok_str(sym->v, 0); + func_ind = ind; + + vla_sp_loc = -1; + vla_sp_root_loc = -1; + + tcc_debug_funcstart(tcc_state, sym); + + sym_push2(&local_stack, 0x20000000, 0, 0); + local_scope = 1; + gfunc_prolog(&sym->type); + local_scope = 0; + rsym = 0; + block(0, 0, 0); + nocode_wanted = 0; + gsym(rsym); + gfunc_epilog(); + cur_text_section->data_offset = ind; + label_pop(&global_label_stack, 0, 0); + + local_scope = 0; + sym_pop(&local_stack, 0, 0); + + + elfsym(sym)->st_size = ind - func_ind; + tcc_debug_funcend(tcc_state, ind - func_ind); + + cur_text_section = 0; + funcname = ""; + func_vt.t = 0; + func_var = 0; + ind = 0; + nocode_wanted = 0x80000000; + check_vstack(); +} + +static void gen_inline_functions(TCCState *s) +{ + Sym *sym; + int inline_generated, i, ln; + struct InlineFunc *fn; + + ln = file->line_num; + + do { + inline_generated = 0; + for (i = 0; i < s->nb_inline_fns; ++i) { + fn = s->inline_fns[i]; + sym = fn->sym; + if (sym && sym->c) { + + + fn->sym = 0; + if (file) + pstrcpy(file->filename, sizeof file->filename, fn->filename); + sym->type.t &= ~0x00008000; + + begin_macro(fn->func_str, 1); + next(); + cur_text_section = text_section; + gen_function(sym); + end_macro(); + + inline_generated = 1; + } + } + } while (inline_generated); + file->line_num = ln; +} + +static void free_inline_functions(TCCState *s) +{ + int i; + + for (i = 0; i < s->nb_inline_fns; ++i) { + struct InlineFunc *fn = s->inline_fns[i]; + if (fn->sym) + tok_str_free(fn->func_str); + } + dynarray_reset(&s->inline_fns, &s->nb_inline_fns); +} + + + +static int decl0(int l, int is_for_loop_init, Sym *func_sym) +{ + int v, has_init, r; + CType type, btype; + Sym *sym; + AttributeDef ad; + + while (1) { + if (!parse_btype(&btype, &ad)) { + if (is_for_loop_init) + return 0; + + if (tok == ';' && l != 0x0033) { + next(); + continue; + } + if (l != 0x0030) + break; + if (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3) { + + asm_global_instr(); + continue; + } + if (tok >= TOK_DEFINE) { + + + btype.t = 3; + } else { + if (tok != (-1)) + expect("declaration"); + break; + } + } + if (tok == ';') { + if ((btype.t & 0x000f) == 7) { + int v = btype.ref->v; + if (!(v & 0x20000000) && (v & ~0x40000000) >= 0x10000000) + tcc_warning("unnamed struct/union that defines no instances"); + next(); + continue; + } + if (((btype.t & (((1 << (6+6)) - 1) << 20 | 0x0080)) == (2 << 20))) { + next(); + continue; + } + } + while (1) { + type = btype; + + + + + + if ((type.t & 0x0040) && type.ref->c < 0) { + type.ref = sym_push(0x20000000, &type.ref->type, 0, type.ref->c); + } + type_decl(&type, &ad, &v, 2); + + + + + + + + if ((type.t & 0x000f) == 6) { + if ((type.t & 0x00002000) && (l == 0x0032)) { + tcc_error("function without file scope cannot be static"); + } + + + sym = type.ref; + if (sym->f.func_type == 2 && l == 0x0030) + decl0(0x0033, 0, sym); + } + + if (gnu_ext && (tok == TOK_ASM1 || tok == TOK_ASM2 || tok == TOK_ASM3)) { + ad.asm_label = asm_label_instr(); + + parse_attribute(&ad); + if (tok == '{') + expect(";"); + } +# 7239 "tccgen.c" + if (tok == '{') { + if (l != 0x0030) + tcc_error("cannot use local functions"); + if ((type.t & 0x000f) != 6) + expect("function definition"); + + + + sym = type.ref; + while ((sym = sym->next) != 0) { + if (!(sym->v & ~0x20000000)) + expect("identifier"); + if (sym->type.t == 0) + sym->type = int_type; + } + + + if ((type.t & (0x00001000 | 0x00008000)) == (0x00001000 | 0x00008000)) + type.t = (type.t & ~0x00001000) | 0x00002000; + + + sym = external_global_sym(v, &type, 0); + type.t &= ~0x00001000; + patch_storage(sym, &ad, &type); + + + + + if ((type.t & (0x00008000 | 0x00002000)) == + (0x00008000 | 0x00002000)) { + struct InlineFunc *fn; + const char *filename; + + filename = file ? file->filename : ""; + fn = tcc_malloc(sizeof *fn + strlen(filename)); + strcpy(fn->filename, filename); + fn->sym = sym; + skip_or_save_block(&fn->func_str); + dynarray_add(&tcc_state->inline_fns, + &tcc_state->nb_inline_fns, fn); + } else { + + cur_text_section = ad.section; + if (!cur_text_section) + cur_text_section = text_section; + gen_function(sym); + } + break; + } else { + if (l == 0x0033) { + + for (sym = func_sym->next; sym; sym = sym->next) + if ((sym->v & ~0x20000000) == v) + goto found; + tcc_error("declaration for parameter '%s' but no such parameter", + get_tok_str(v, 0)); +found: + if (type.t & (0x00001000 | 0x00002000 | 0x00004000 | 0x00008000)) + tcc_error("storage class specified for '%s'", + get_tok_str(v, 0)); + if (sym->type.t != 0) + tcc_error("redefinition of parameter '%s'", + get_tok_str(v, 0)); + convert_parameter_type(&type); + sym->type = type; + } else if (type.t & 0x00004000) { + + + sym = sym_find(v); + if (sym && sym->sym_scope == local_scope) { + if (!is_compatible_types(&sym->type, &type) + || !(sym->type.t & 0x00004000)) + tcc_error("incompatible redefinition of '%s'", + get_tok_str(v, 0)); + sym->type = type; + } else { + sym = sym_push(v, &type, 0, 0); + } + sym->a = ad.a; + sym->f = ad.f; + } else { + r = 0; + if ((type.t & 0x000f) == 6) { + + + type.ref->f = ad.f; + } else if (!(type.t & 0x0040)) { + + r |= lvalue_type(type.t); + } + has_init = (tok == '='); + if (has_init && (type.t & 0x0400)) + tcc_error("variable length array cannot be initialized"); + if (((type.t & 0x00001000) && (!has_init || l != 0x0030)) || + ((type.t & 0x000f) == 6) || + ((type.t & 0x0040) && (type.t & 0x00002000) && + !has_init && l == 0x0030 && type.ref->c < 0)) { + + + + + type.t |= 0x00001000; + sym = external_sym(v, &type, r, &ad); + if (ad.alias_target) { + Elf64_Sym *esym; + Sym *alias_target; + alias_target = sym_find(ad.alias_target); + esym = elfsym(alias_target); + if (!esym) + tcc_error("unsupported forward __alias__ attribute"); + + + sym->sym_scope = 0; + put_extern_sym2(sym, esym->st_shndx, esym->st_value, esym->st_size, 0); + } + } else { + if (type.t & 0x00002000) + r |= 0x0030; + else + r |= l; + if (has_init) + next(); + else if (l == 0x0030) + + type.t |= 0x00001000; + decl_initializer_alloc(&type, &ad, r, has_init, v, l); + } + } + if (tok != ',') { + if (is_for_loop_init) + return 1; + skip(';'); + break; + } + next(); + } + ad.a.aligned = 0; + } + } + return 0; +} + +static void decl(int l) +{ + decl0(l, 0, 0); +} |