Subversion Repositories Kolibri OS

/*

 *  TCC - Tiny C Compiler

 *

 *  Copyright (c) 2001-2004 Fabrice Bellard

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#ifndef _TCC_H

#define _TCC_H

#define _GNU_SOURCE

#include "config.h"

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include           /* stat() */

#ifdef CONFIG_TCCASSERT

#include 

#define TCC_ASSERT(ex) assert(ex)

#else

#define TCC_ASSERT(ex)

#endif

#ifdef TCC_TARGET_KX

#ifndef TCC_TARGET_MEOS

#define TCC_TARGET_MEOS

#endif

#endif

#ifndef _WIN32

# include 

# include 

# ifndef TCC_TARGET_MEOS

# include 

# include 

# endif

# ifndef CONFIG_TCC_STATIC

#  include 

# endif

/* XXX: need to define this to use them in non ISOC99 context */

 extern float strtof (const char *__nptr, char **__endptr);

 extern long double strtold (const char *__nptr, char **__endptr);

#else /* on _WIN32: */

# include 

# include 

# include  /* open, close etc. */

# include  /* getcwd */

# ifdef __GNUC__

#  include 

# endif

# define inline __inline

# define inp next_inp

# define snprintf _snprintf

# define vsnprintf _vsnprintf

# ifndef __GNUC__

#  define strtold (long double)strtod

#  define strtof (float)strtod

#  define strtoll _strtoi64

#  define strtoull _strtoui64

# endif

# ifdef LIBTCC_AS_DLL

#  define LIBTCCAPI __declspec(dllexport)

#  define PUB_FUNC LIBTCCAPI

# endif

# ifdef _MSC_VER

#  pragma warning (disable : 4244)  // conversion from 'uint64_t' to 'int', possible loss of data

#  pragma warning (disable : 4267)  // conversion from 'size_t' to 'int', possible loss of data

#  pragma warning (disable : 4996)  // The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conformant name

#  pragma warning (disable : 4018)  // signed/unsigned mismatch

#  pragma warning (disable : 4146)  // unary minus operator applied to unsigned type, result still unsigned

# endif

#endif

#ifndef O_BINARY

# define O_BINARY 0

#endif

#ifdef __GNUC__

# define NORETURN __attribute__ ((noreturn))

#elif defined _MSC_VER

# define NORETURN __declspec(noreturn)

#else

# define NORETURN

#endif

#ifdef _WIN32

# define IS_DIRSEP(c) (c == '/' || c == '\\')

# define IS_ABSPATH(p) (IS_DIRSEP(p[0]) || (p[0] && p[1] == ':' && IS_DIRSEP(p[2])))

# define PATHCMP stricmp

# define PATH_NOCASE

#else

# define IS_DIRSEP(c) (c == '/')

# define IS_ABSPATH(p) IS_DIRSEP(p[0])

# define PATHCMP strcmp

#endif

#if defined(TCC_TARGET_PE)||defined(TCC_TARGET_MEOS)

#define PATHSEP ';'

#else

#define PATHSEP ':'

#endif

#include "elf.h"

#if defined(TCC_TARGET_ARM64) || defined(TCC_TARGET_X86_64)

# define ELFCLASSW ELFCLASS64

# define ElfW(type) Elf##64##_##type

# define ELFW(type) ELF##64##_##type

# define ElfW_Rel ElfW(Rela)

# define SHT_RELX SHT_RELA

# define REL_SECTION_FMT ".rela%s"

/* XXX: DLL with PLT would only work with x86-64 for now */

# define TCC_OUTPUT_DLL_WITH_PLT

#else

# define ELFCLASSW ELFCLASS32

# define ElfW(type) Elf##32##_##type

# define ELFW(type) ELF##32##_##type

# define ElfW_Rel ElfW(Rel)

# define SHT_RELX SHT_REL

# define REL_SECTION_FMT ".rel%s"

#endif

/* target address type */

#define addr_t ElfW(Addr)

#include "stab.h"

#include "libtcc.h"

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 (p[0] | (uint32_t)p[1] << 8 |

          (uint32_t)p[2] << 16 | (uint32_t)p[3] << 24);

}

static inline void write32le(unsigned char *p, uint32_t x)

{

    p[0] = x & 255;

    p[1] = x >> 8 & 255;

    p[2] = x >> 16 & 255;

    p[3] = x >> 24 & 255;

}

static inline uint64_t read64le(unsigned char *p)

{

  return (p[0] | (uint64_t)p[1] << 8 |

          (uint64_t)p[2] << 16 | (uint64_t)p[3] << 24 |

          (uint64_t)p[4] << 32 | (uint64_t)p[5] << 40 |

          (uint64_t)p[6] << 48 | (uint64_t)p[7] << 56);

}

static inline void write64le(unsigned char *p, uint64_t x)

{

    p[0] = x & 255;

    p[1] = x >> 8 & 255;

    p[2] = x >> 16 & 255;

    p[3] = x >> 24 & 255;

    p[4] = x >> 32 & 255;

    p[5] = x >> 40 & 255;

    p[6] = x >> 48 & 255;

    p[7] = x >> 56 & 255;

}

/* parser debug */

/* #define PARSE_DEBUG */

/* preprocessor debug */

/* #define PP_DEBUG */

/* include file debug */

/* #define INC_DEBUG */

/* memory leak debug */

/* #define MEM_DEBUG */

/* assembler debug */

/* #define ASM_DEBUG */

/* target selection */

/* #define TCC_TARGET_I386   *//* i386 code generator */

/* #define TCC_TARGET_ARM    *//* ARMv4 code generator */

/* #define TCC_TARGET_ARM64  *//* ARMv8 code generator */

/* #define TCC_TARGET_C67    *//* TMS320C67xx code generator */

/* #define TCC_TARGET_X86_64 *//* x86-64 code generator */

/* default target is I386 */

#if !defined(TCC_TARGET_I386) && !defined(TCC_TARGET_ARM) && \

    !defined(TCC_TARGET_ARM64) && !defined(TCC_TARGET_C67) && \

    !defined(TCC_TARGET_X86_64)

#define TCC_TARGET_I386

#endif

#if !defined(TCC_UCLIBC) && !defined(TCC_TARGET_ARM) && \

    !defined(TCC_TARGET_ARM64) && !defined(TCC_TARGET_C67) && \

    !defined(CONFIG_USE_LIBGCC)

#define CONFIG_TCC_BCHECK /* enable bound checking code */

#endif

/* define it to include assembler support */

#if !defined(TCC_TARGET_ARM) && !defined(TCC_TARGET_ARM64) && \

    !defined(TCC_TARGET_C67)

#define CONFIG_TCC_ASM

#endif

/* object format selection */

#if defined(TCC_TARGET_C67)

#define TCC_TARGET_COFF

#endif

/* only native compiler supports -run */

#if defined _WIN32 && defined TCC_TARGET_PE

# if (defined __i386__ || defined _X86_) && defined TCC_TARGET_I386

#  define TCC_IS_NATIVE

# elif (defined __x86_64__ || defined _AMD64_) && defined TCC_TARGET_X86_64

#  define TCC_IS_NATIVE

# elif defined __arm__ && defined TCC_TARGET_ARM

#  define TCC_IS_NATIVE

# elif defined __aarch64__ && defined TCC_TARGET_ARM64

#  define TCC_IS_NATIVE

# endif

#endif

#if defined TCC_IS_NATIVE && !defined CONFIG_TCCBOOT

# define CONFIG_TCC_BACKTRACE

#endif

/* ------------ path configuration ------------ */

#ifndef CONFIG_SYSROOT

# define CONFIG_SYSROOT ""

#endif

#ifndef CONFIG_TCCDIR

# define CONFIG_TCCDIR "."

#endif

#ifndef CONFIG_LDDIR

# ifdef TCC_TARGET_X86_64

#   define CONFIG_LDDIR "lib64"

# else

#   define CONFIG_LDDIR "lib"

# endif

#endif

#ifdef CONFIG_MULTIARCHDIR

# define USE_MUADIR(s) s "/" CONFIG_MULTIARCHDIR

# define ALSO_MUADIR(s) s "/" CONFIG_MULTIARCHDIR ":" s

#else

# define USE_MUADIR(s) s

# define ALSO_MUADIR(s) s

#endif

/* path to find crt1.o, crti.o and crtn.o */

#ifndef CONFIG_TCC_CRTPREFIX

# if defined (TCC_TARGET_MEOS)

#   define CONFIG_TCC_CRTPREFIX "{B}/lib"

# else

#   define CONFIG_TCC_CRTPREFIX USE_MUADIR(CONFIG_SYSROOT "/usr/" CONFIG_LDDIR)

# endif

#endif

/* Below: {B} is substituted by CONFIG_TCCDIR (rsp. -B option) */

/* system include paths */

#ifndef CONFIG_TCC_SYSINCLUDEPATHS

# ifdef TCC_TARGET_PE

#  define CONFIG_TCC_SYSINCLUDEPATHS "{B}/include;{B}/include/winapi"

# elif defined(TCC_TARGET_MEOS)

#  define CONFIG_TCC_SYSINCLUDEPATHS "{B}/include"

# else

#  define CONFIG_TCC_SYSINCLUDEPATHS \

        "{B}/include" \

    ":" ALSO_MUADIR(CONFIG_SYSROOT "/usr/local/include") \

    ":" ALSO_MUADIR(CONFIG_SYSROOT "/usr/include")

# endif

#endif

/* library search paths */

#ifndef CONFIG_TCC_LIBPATHS

# if defined (TCC_TARGET_PE) || defined (TCC_TARGET_MEOS)

#  define CONFIG_TCC_LIBPATHS "{B}/lib"

# else

#  define CONFIG_TCC_LIBPATHS \

        ALSO_MUADIR(CONFIG_SYSROOT "/usr/" CONFIG_LDDIR) \

    ":" ALSO_MUADIR(CONFIG_SYSROOT "/" CONFIG_LDDIR) \

    ":" ALSO_MUADIR(CONFIG_SYSROOT "/usr/local/" CONFIG_LDDIR)

# endif

#endif

/* name of ELF interpreter */

#ifndef CONFIG_TCC_ELFINTERP

# if defined __FreeBSD__

#  define CONFIG_TCC_ELFINTERP "/libexec/ld-elf.so.1"

# elif defined __FreeBSD_kernel__

#  if defined(TCC_TARGET_X86_64)

#   define CONFIG_TCC_ELFINTERP "/lib/ld-kfreebsd-x86-64.so.1"

#  else

#   define CONFIG_TCC_ELFINTERP "/lib/ld.so.1"

#  endif

# elif defined __DragonFly__

#  define CONFIG_TCC_ELFINTERP "/usr/libexec/ld-elf.so.2"

# elif defined __NetBSD__

#  define CONFIG_TCC_ELFINTERP "/usr/libexec/ld.elf_so"

# elif defined __GNU__

#  define CONFIG_TCC_ELFINTERP "/lib/ld.so"

# elif defined(TCC_TARGET_PE)

#  define CONFIG_TCC_ELFINTERP "-"

# elif defined(TCC_UCLIBC)

#  define CONFIG_TCC_ELFINTERP "/lib/ld-uClibc.so.0" /* is there a uClibc for x86_64 ? */

# elif defined TCC_TARGET_ARM64

#  define CONFIG_TCC_ELFINTERP "/lib/ld-linux-aarch64.so.1"

# elif defined(TCC_TARGET_X86_64)

#  define CONFIG_TCC_ELFINTERP "/lib64/ld-linux-x86-64.so.2"

# elif !defined(TCC_ARM_EABI)

#  define CONFIG_TCC_ELFINTERP "/lib/ld-linux.so.2"

# endif

#endif

/* var elf_interp dans *-gen.c */

#ifdef CONFIG_TCC_ELFINTERP

# define DEFAULT_ELFINTERP(s) CONFIG_TCC_ELFINTERP

#else

# define DEFAULT_ELFINTERP(s) default_elfinterp(s)

#endif

/* library to use with CONFIG_USE_LIBGCC instead of libtcc1.a */

#define TCC_LIBGCC USE_MUADIR(CONFIG_SYSROOT "/" CONFIG_LDDIR) "/libgcc_s.so.1"

/* -------------------------------------------- */

/* include the target specific definitions */

#ifdef TCC_TARGET_COFF

# include "coff.h"

#endif

#define TARGET_DEFS_ONLY

#ifdef TCC_TARGET_I386

# include "i386-gen.c"

#endif

#ifdef TCC_TARGET_X86_64

# include "x86_64-gen.c"

#endif

#ifdef TCC_TARGET_ARM

# include "arm-gen.c"

#endif

#ifdef TCC_TARGET_ARM64

# include "arm64-gen.c"

#endif

#ifdef TCC_TARGET_C67

# include "c67-gen.c"

#endif

#undef TARGET_DEFS_ONLY

/* -------------------------------------------- */

#define INCLUDE_STACK_SIZE  32

#define IFDEF_STACK_SIZE    64

#define VSTACK_SIZE         256

#define STRING_MAX_SIZE     1024

#define TOKSTR_MAX_SIZE     256

#define PACK_STACK_SIZE     8

#define TOK_HASH_SIZE       16384 /* must be a power of two */

#define TOK_ALLOC_INCR      512  /* must be a power of two */

#define TOK_MAX_SIZE        4 /* token max size in int unit when stored in string */

#define TOKSYM_TAL_SIZE     (768 * 1024) /* allocator for tiny TokenSym in table_ident */

#define TOKSTR_TAL_SIZE     (768 * 1024) /* allocator for tiny TokenString instances */

#define CSTR_TAL_SIZE       (256 * 1024) /* allocator for tiny CString instances */

#define TOKSYM_TAL_LIMIT    256 /* prefer unique limits to distinguish allocators debug msgs */

#define TOKSTR_TAL_LIMIT    128 /* 32 * sizeof(int) */

#define CSTR_TAL_LIMIT      1024

/* token symbol management */

typedef struct TokenSym {

    struct TokenSym *hash_next;

    struct Sym *sym_define; /* direct pointer to define */

    struct Sym *sym_label; /* direct pointer to label */

    struct Sym *sym_struct; /* direct pointer to structure */

    struct Sym *sym_identifier; /* direct pointer to identifier */

    int tok; /* token number */

    int len;

    char str[1];

} TokenSym;

#ifdef TCC_TARGET_PE

typedef unsigned short nwchar_t;

#else

typedef int nwchar_t;

#endif

typedef struct CString {

    int size; /* size in bytes */

    void *data; /* either 'char *' or 'nwchar_t *' */

    int size_allocated;

    void *data_allocated; /* if non NULL, data has been malloced */

} CString;

/* type definition */

typedef struct CType {

    int t;

    struct Sym *ref;

} CType;

/* constant value */

typedef union CValue {

    long double ld;

    double d;

    float f;

    uint64_t i;

    struct {

        int size;

        const void *data;

        void *data_allocated;

    } str;

    int tab[LDOUBLE_SIZE/4];

} CValue;

/* value on stack */

typedef struct SValue {

    CType type;      /* type */

    unsigned short r;      /* register + flags */

    unsigned short r2;     /* second register, used for 'long long'

                              type. If not used, set to VT_CONST */

    CValue c;              /* constant, if VT_CONST */

    struct Sym *sym;       /* symbol, if (VT_SYM | VT_CONST) */

} SValue;

struct Attribute {

    unsigned

        func_call     : 3, /* calling convention (0..5), see below */

        aligned       : 5, /* alignement (0..16) */

        packed        : 1,

        func_export   : 1,

        func_import   : 1,

        func_args     : 5,

        func_proto    : 1,

        mode          : 4,

        weak          : 1,

        visibility    : 2,

        fill          : 8; // 8 bits left to fit well in union below

};

/* GNUC attribute definition */

typedef struct AttributeDef {

    struct Attribute a;

    struct Section *section;

    int alias_target;    /* token */

    int asm_label;    /* associated asm label */

} AttributeDef;

/* symbol management */

typedef struct Sym {

    int v;    /* symbol token */

    int asm_label;    /* associated asm label */

    union {

        long r;    /* associated register */

        struct Attribute a;

    };

    union {

        long c;    /* associated number */

        int *d;   /* define token stream */

    };

    CType type;    /* associated type */

    union {

        struct Sym *next; /* next related symbol */

        long jnext; /* next jump label */

    };

    struct Sym *prev; /* prev symbol in stack */

    struct Sym *prev_tok; /* previous symbol for this token */

} Sym;

/* section definition */

/* XXX: use directly ELF structure for parameters ? */

/* special flag to indicate that the section should not be linked to

   the other ones */

#define SHF_PRIVATE 0x80000000

/* special flag, too */

#define SECTION_ABS ((void *)1)

typedef struct Section {

    unsigned long data_offset; /* current data offset */

    unsigned char *data;       /* section data */

    unsigned long data_allocated; /* used for realloc() handling */

    int sh_name;             /* elf section name (only used during output) */

    int sh_num;              /* elf section number */

    int sh_type;             /* elf section type */

    int sh_flags;            /* elf section flags */

    int sh_info;             /* elf section info */

    int sh_addralign;        /* elf section alignment */

    int sh_entsize;          /* elf entry size */

    unsigned long sh_size;   /* section size (only used during output) */

    addr_t sh_addr;          /* address at which the section is relocated */

    unsigned long sh_offset; /* file offset */

    int nb_hashed_syms;      /* used to resize the hash table */

    struct Section *link;    /* link to another section */

    struct Section *reloc;   /* corresponding section for relocation, if any */

    struct Section *hash;     /* hash table for symbols */

    struct Section *next;

    char name[1];           /* section name */

} Section;

typedef struct DLLReference {

    int level;

    void *handle;

    char name[1];

} DLLReference;

/* -------------------------------------------------- */

#define SYM_STRUCT     0x40000000 /* struct/union/enum symbol space */

#define SYM_FIELD      0x20000000 /* struct/union field symbol space */

#define SYM_FIRST_ANOM 0x10000000 /* first anonymous sym */

/* stored in 'Sym.c' field */

#define FUNC_NEW       1 /* ansi function prototype */

#define FUNC_OLD       2 /* old function prototype */

#define FUNC_ELLIPSIS  3 /* ansi function prototype with ... */

/* stored in 'Sym.r' field */

#define FUNC_CDECL     0 /* standard c call */

#define FUNC_STDCALL   1 /* pascal c call */

#define FUNC_FASTCALL1 2 /* first param in %eax */

#define FUNC_FASTCALL2 3 /* first parameters in %eax, %edx */

#define FUNC_FASTCALL3 4 /* first parameter in %eax, %edx, %ecx */

#define FUNC_FASTCALLW 5 /* first parameter in %ecx, %edx */

/* field 'Sym.t' for macros */

#define MACRO_OBJ      0 /* object like macro */

#define MACRO_FUNC     1 /* function like macro */

/* field 'Sym.r' for C labels */

#define LABEL_DEFINED  0 /* label is defined */

#define LABEL_FORWARD  1 /* label is forward defined */

#define LABEL_DECLARED 2 /* label is declared but never used */

/* type_decl() types */

#define TYPE_ABSTRACT  1 /* type without variable */

#define TYPE_DIRECT    2 /* type with variable */

#define IO_BUF_SIZE 8192

typedef struct BufferedFile {

    uint8_t *buf_ptr;

    uint8_t *buf_end;

    int fd;

    struct BufferedFile *prev;

    int line_num;    /* current line number - here to simplify code */

    int line_ref;    /* tcc -E: last printed line */

    int ifndef_macro;  /* #ifndef macro / #endif search */

    int ifndef_macro_saved; /* saved ifndef_macro */

    int *ifdef_stack_ptr; /* ifdef_stack value at the start of the file */

    int include_next_index; /* next search path */

    char filename[1024];    /* filename */

    unsigned char unget[4];

    unsigned char buffer[1]; /* extra size for CH_EOB char */

} BufferedFile;

#define CH_EOB   '\\'       /* end of buffer or '\0' char in file */

#define CH_EOF   (-1)   /* end of file */

/* parsing state (used to save parser state to reparse part of the

   source several times) */

typedef struct ParseState {

    const int *macro_ptr;

    int line_num;

    int tok;

    CValue tokc;

} ParseState;

/* used to record tokens */

typedef struct TokenString {

    int *str;

    int len;

    int allocated_len;

    int last_line_num;

    /* used to chain token-strings with begin/end_macro() */

    struct TokenString *prev;

    const int *prev_ptr;

    char alloc;

} TokenString;

/* inline functions */

typedef struct InlineFunc {

    TokenString func_str;

    Sym *sym;

    char filename[1];

} InlineFunc;

/* include file cache, used to find files faster and also to eliminate

   inclusion if the include file is protected by #ifndef ... #endif */

typedef struct CachedInclude {

    int ifndef_macro;

    int hash_next; /* -1 if none */

    char filename[1]; /* path specified in #include */

} CachedInclude;

#define CACHED_INCLUDES_HASH_SIZE 512

#ifdef CONFIG_TCC_ASM

typedef struct ExprValue {

    uint32_t v;

    Sym *sym;

} ExprValue;

#define MAX_ASM_OPERANDS 30

typedef struct ASMOperand {

    int id; /* GCC 3 optionnal identifier (0 if number only supported */

    char *constraint;

    char asm_str[16]; /* computed asm string for operand */

    SValue *vt; /* C value of the expression */

    int ref_index; /* if >= 0, gives reference to a output constraint */

    int input_index; /* if >= 0, gives reference to an input constraint */

    int priority; /* priority, used to assign registers */

    int reg; /* if >= 0, register number used for this operand */

    int is_llong; /* true if double register value */

    int is_memory; /* true if memory operand */

    int is_rw;     /* for '+' modifier */

} ASMOperand;

#endif

struct sym_attr {

    unsigned long got_offset;

    unsigned long plt_offset;

#ifdef TCC_TARGET_ARM

    unsigned char plt_thumb_stub:1;

#endif

};

typedef struct ParseArgsState

{

    int run;

    int pthread;

    int filetype;

    CString linker_arg; /* collect -Wl options for input such as "-Wl,-rpath -Wl," */

} ParseArgsState;

#if !defined(MEM_DEBUG)

#define tal_free(al, p) tal_free_impl(al, p)

#define tal_realloc(al, p, size) tal_realloc_impl(&al, p, size)

#define TAL_DEBUG_PARAMS

#else

#define TAL_DEBUG 1

#define tal_free(al, p) tal_free_impl(al, p, __FILE__, __LINE__)

#define tal_realloc(al, p, size) tal_realloc_impl(&al, p, size, __FILE__, __LINE__)

#define TAL_DEBUG_PARAMS , const char *file, int line

#define TAL_DEBUG_FILE_LEN 15

#endif

//#define TAL_INFO 1 /* collect and dump allocators stats */

typedef struct TinyAlloc {

    size_t  limit;

    size_t  size;

    uint8_t *buffer;

    uint8_t *p;

    size_t  nb_allocs;

    struct TinyAlloc *next, *top;

#ifdef TAL_INFO

    size_t  nb_peak;

    size_t  nb_total;

    size_t  nb_missed;

    uint8_t *peak_p;

#endif

} TinyAlloc;

typedef struct tal_header_t {

    size_t  size;

#ifdef TAL_DEBUG

    int     line_num; /* negative line_num used for double free check */

    char    file_name[TAL_DEBUG_FILE_LEN + 1];

#endif

} tal_header_t;

struct TCCState {

    int verbose; /* if true, display some information during compilation */

    int nostdinc; /* if true, no standard headers are added */

    int nostdlib; /* if true, no standard libraries are added */

    int nocommon; /* if true, do not use common symbols for .bss data */

    int static_link; /* if true, static linking is performed */

    int rdynamic; /* if true, all symbols are exported */

    int symbolic; /* if true, resolve symbols in the current module first */

    int alacarte_link; /* if true, only link in referenced objects from archive */

    char *tcc_lib_path; /* CONFIG_TCCDIR or -B option */

    char *soname; /* as specified on the command line (-soname) */

    char *rpath; /* as specified on the command line (-Wl,-rpath=) */

    /* output type, see TCC_OUTPUT_XXX */

    int output_type;

    /* output format, see TCC_OUTPUT_FORMAT_xxx */

    int output_format;

    /* C language options */

    int char_is_unsigned;

    int leading_underscore;

    int ms_extensions;		/* allow nested named struct w/o identifier behave like unnamed */

    int old_struct_init_code;	/* use old algorithm to init array in struct when there is no '{' used.

				   Liuux 2.4.26 can't find initrd when compiled with a new algorithm */

    int dollars_in_identifiers;	/* allows '$' char in indentifiers */

    int normalize_inc_dirs;	/* remove non-existent or duplicate directories from include paths */

    /* warning switches */

    int warn_write_strings;

    int warn_unsupported;

    int warn_error;

    int warn_none;

    int warn_implicit_function_declaration;

    /* compile with debug symbol (and use them if error during execution) */

    int do_debug;

    int do_strip;

#ifdef CONFIG_TCC_BCHECK

    /* compile with built-in memory and bounds checker */

    int do_bounds_check;

#endif

#ifdef TCC_TARGET_ARM

    enum float_abi float_abi; /* float ABI of the generated code*/

#endif

    addr_t text_addr; /* address of text section */

    int has_text_addr;

    unsigned long section_align; /* section alignment */

    char *init_symbol; /* symbols to call at load-time (not used currently) */

    char *fini_symbol; /* symbols to call at unload-time (not used currently) */

#ifdef TCC_TARGET_I386

    int seg_size; /* 32. Can be 16 with i386 assembler (.code16) */

#endif

    /* array of all loaded dlls (including those referenced by loaded dlls) */

    DLLReference **loaded_dlls;

    int nb_loaded_dlls;

    /* include paths */

    char **include_paths;

    int nb_include_paths;

    char **sysinclude_paths;

    int nb_sysinclude_paths;

    /* library paths */

    char **library_paths;

    int nb_library_paths;

    /* crt?.o object path */

    char **crt_paths;

    int nb_crt_paths;

    /* error handling */

    void *error_opaque;

    void (*error_func)(void *opaque, const char *msg);

    int error_set_jmp_enabled;

    jmp_buf error_jmp_buf;

    int nb_errors;

    /* output file for preprocessing (-E) */

    FILE *ppfp;

    enum {

	LINE_MACRO_OUTPUT_FORMAT_GCC,

	LINE_MACRO_OUTPUT_FORMAT_NONE,

	LINE_MACRO_OUTPUT_FORMAT_STD

    } Pflag; /* -P switch */

    char dflag; /* -dX value */

    FILE *dffp;

    /* for -MD/-MF: collected dependencies for this compilation */

    char **target_deps;

    int nb_target_deps;

    /* compilation */

    BufferedFile *include_stack[INCLUDE_STACK_SIZE];

    BufferedFile **include_stack_ptr;

    int ifdef_stack[IFDEF_STACK_SIZE];

    int *ifdef_stack_ptr;

    /* included files enclosed with #ifndef MACRO */

    int cached_includes_hash[CACHED_INCLUDES_HASH_SIZE];

    CachedInclude **cached_includes;

    int nb_cached_includes;

    /* #pragma pack stack */

    int pack_stack[PACK_STACK_SIZE];

    int *pack_stack_ptr;

    char **pragma_libs;

    int nb_pragma_libs;

    /* inline functions are stored as token lists and compiled last

       only if referenced */

    struct InlineFunc **inline_fns;

    int nb_inline_fns;

    /* sections */

    Section **sections;

    int nb_sections; /* number of sections, including first dummy section */

    Section **priv_sections;

    int nb_priv_sections; /* number of private sections */

    /* got & plt handling */

    Section *got;

    Section *plt;

    struct sym_attr *sym_attrs;

    int nb_sym_attrs;

    /* give the correspondance from symtab indexes to dynsym indexes */

    int *symtab_to_dynsym;

    /* temporary dynamic symbol sections (for dll loading) */

    Section *dynsymtab_section;

    /* exported dynamic symbol section */

    Section *dynsym;

    /* copy of the gobal symtab_section variable */

    Section *symtab;

    /* tiny assembler state */

    Sym *asm_labels;

#if defined (TCC_TARGET_PE) || defined (TCC_TARGET_MEOS)

    /* PE info */

    int pe_subsystem;

    unsigned pe_file_align;

    unsigned pe_stack_size;

# ifdef TCC_TARGET_X86_64

    Section *uw_pdata;

    int uw_sym;

    unsigned uw_offs;

# endif

#endif

#ifdef TCC_IS_NATIVE

    const char *runtime_main;

    /* for tcc_relocate */

    void *runtime_mem;

# ifdef HAVE_SELINUX

    void *write_mem;

    unsigned long mem_size;

# endif

#endif

    /* used by main and tcc_parse_args only */

    char **files; /* files seen on command line */

    int nb_files; /* number thereof */

    int nb_libraries; /* number of libs thereof */

    char *outfile; /* output filename */

    char *option_m; /* only -m32/-m64 handled */

    int print_search_dirs; /* option */

    int option_r; /* option -r */

    int option_C; /* option -C, keep comments when -E */

    int do_bench; /* option -bench */

    int gen_deps; /* option -MD  */

    char *deps_outfile; /* option -MF */

#if defined(TCC_TARGET_MEOS) && !defined (TCC_TARGET_KX)

    int nobss; /* option -nobss, omit BSS section (KolibriOS-only) */

#endif

    ParseArgsState *parse_args_state;

};

/* The current value can be: */

#define VT_VALMASK   0x003f  /* mask for value location, register or: */

#define VT_CONST     0x0030  /* constant in vc (must be first non register value) */

#define VT_LLOCAL    0x0031  /* lvalue, offset on stack */

#define VT_LOCAL     0x0032  /* offset on stack */

#define VT_CMP       0x0033  /* the value is stored in processor flags (in vc) */

#define VT_JMP       0x0034  /* value is the consequence of jmp true (even) */

#define VT_JMPI      0x0035  /* value is the consequence of jmp false (odd) */

#define VT_REF       0x0040  /* value is pointer to structure rather than address */

#define VT_LVAL      0x0100  /* var is an lvalue */

#define VT_SYM       0x0200  /* a symbol value is added */

#define VT_MUSTCAST  0x0400  /* value must be casted to be correct (used for

                                char/short stored in integer registers) */

#define VT_MUSTBOUND 0x0800  /* bound checking must be done before

                                dereferencing value */

#define VT_BOUNDED   0x8000  /* value is bounded. The address of the

                                bounding function call point is in vc */

#define VT_LVAL_BYTE     0x1000  /* lvalue is a byte */

#define VT_LVAL_SHORT    0x2000  /* lvalue is a short */

#define VT_LVAL_UNSIGNED 0x4000  /* lvalue is unsigned */

#define VT_LVAL_TYPE     (VT_LVAL_BYTE | VT_LVAL_SHORT | VT_LVAL_UNSIGNED)

/* types */

#define VT_BTYPE       0x000f  /* mask for basic type */

#define VT_INT              0  /* integer type */

#define VT_BYTE             1  /* signed byte type */

#define VT_SHORT            2  /* short type */

#define VT_VOID             3  /* void type */

#define VT_PTR              4  /* pointer */

#define VT_ENUM             5  /* enum definition */

#define VT_FUNC             6  /* function type */

#define VT_STRUCT           7  /* struct/union definition */

#define VT_FLOAT            8  /* IEEE float */

#define VT_DOUBLE           9  /* IEEE double */

#define VT_LDOUBLE         10  /* IEEE long double */

#define VT_BOOL            11  /* ISOC99 boolean type */

#define VT_LLONG           12  /* 64 bit integer */

#define VT_LONG            13  /* long integer (NEVER USED as type, only

                                  during parsing) */

#define VT_QLONG           14  /* 128-bit integer. Only used for x86-64 ABI */

#define VT_QFLOAT          15  /* 128-bit float. Only used for x86-64 ABI */

#define VT_UNSIGNED    0x0010  /* unsigned type */

#define VT_ARRAY       0x0020  /* array type (also has VT_PTR) */

#define VT_BITFIELD    0x0040  /* bitfield modifier */

#define VT_CONSTANT    0x0800  /* const modifier */

#define VT_VOLATILE    0x1000  /* volatile modifier */

#define VT_DEFSIGN     0x2000  /* signed type */

#define VT_VLA     0x00020000  /* VLA type (also has VT_PTR and VT_ARRAY) */

/* storage */

#define VT_EXTERN  0x00000080  /* extern definition */

#define VT_STATIC  0x00000100  /* static variable */

#define VT_TYPEDEF 0x00000200  /* typedef definition */

#define VT_INLINE  0x00000400  /* inline definition */

#define VT_IMPORT  0x00004000  /* win32: extern data imported from dll */

#define VT_EXPORT  0x00008000  /* win32: data exported from dll */

#define VT_WEAK    0x00010000  /* weak symbol */

#define VT_TLS     0x00040000  /* thread-local storage */

#define VT_VIS_SHIFT    19     /* shift for symbol visibility, overlapping

				  bitfield values, because bitfields never

				  have linkage and hence never have

				  visibility.  */

#define VT_VIS_SIZE      2     /* We have four visibilities.  */

#define VT_VIS_MASK (((1 << VT_VIS_SIZE)-1) << VT_VIS_SHIFT)

#define VT_STRUCT_SHIFT 19     /* shift for bitfield shift values (max: 32 - 2*6) */

/* type mask (except storage) */

#define VT_STORAGE (VT_EXTERN | VT_STATIC | VT_TYPEDEF | VT_INLINE | VT_IMPORT | VT_EXPORT | VT_WEAK | VT_VIS_MASK)

#define VT_TYPE (~(VT_STORAGE))

/* token values */

/* warning: the following compare tokens depend on i386 asm code */

#define TOK_ULT 0x92

#define TOK_UGE 0x93

#define TOK_EQ  0x94

#define TOK_NE  0x95

#define TOK_ULE 0x96

#define TOK_UGT 0x97

#define TOK_Nset 0x98

#define TOK_Nclear 0x99

#define TOK_LT  0x9c

#define TOK_GE  0x9d

#define TOK_LE  0x9e

#define TOK_GT  0x9f

#define TOK_LAND  0xa0

#define TOK_LOR   0xa1

#define TOK_DEC   0xa2

#define TOK_MID   0xa3 /* inc/dec, to void constant */

#define TOK_INC   0xa4

#define TOK_UDIV  0xb0 /* unsigned division */

#define TOK_UMOD  0xb1 /* unsigned modulo */

#define TOK_PDIV  0xb2 /* fast division with undefined rounding for pointers */

/* tokens that carry values (in additional token string space / tokc) --> */

#define TOK_CCHAR   0xb3 /* char constant in tokc */

#define TOK_LCHAR   0xb4

#define TOK_CINT    0xb5 /* number in tokc */

#define TOK_CUINT   0xb6 /* unsigned int constant */

#define TOK_CLLONG  0xb7 /* long long constant */

#define TOK_CULLONG 0xb8 /* unsigned long long constant */

#define TOK_STR     0xb9 /* pointer to string in tokc */

#define TOK_LSTR    0xba

#define TOK_CFLOAT  0xbb /* float constant */

#define TOK_CDOUBLE 0xbc /* double constant */

#define TOK_CLDOUBLE 0xbd /* long double constant */

#define TOK_PPNUM   0xbe /* preprocessor number */

#define TOK_PPSTR   0xbf /* preprocessor string */

#define TOK_LINENUM 0xc0 /* line number info */

/* <-- */

#define TOK_UMULL    0xc2 /* unsigned 32x32 -> 64 mul */

#define TOK_ADDC1    0xc3 /* add with carry generation */

#define TOK_ADDC2    0xc4 /* add with carry use */

#define TOK_SUBC1    0xc5 /* add with carry generation */

#define TOK_SUBC2    0xc6 /* add with carry use */

#define TOK_ARROW    0xc7

#define TOK_DOTS     0xc8 /* three dots */

#define TOK_SHR      0xc9 /* unsigned shift right */

#define TOK_TWOSHARPS 0xca /* ## preprocessing token */

#define TOK_PLCHLDR  0xcb /* placeholder token as defined in C99 */

#define TOK_NOSUBST  0xcc /* means following token has already been pp'd */

#define TOK_SHL   0x01 /* shift left */

#define TOK_SAR   0x02 /* signed shift right */

/* assignement operators : normal operator or 0x80 */

#define TOK_A_MOD 0xa5

#define TOK_A_AND 0xa6

#define TOK_A_MUL 0xaa

#define TOK_A_ADD 0xab

#define TOK_A_SUB 0xad

#define TOK_A_DIV 0xaf

#define TOK_A_XOR 0xde

#define TOK_A_OR  0xfc

#define TOK_A_SHL 0x81

#define TOK_A_SAR 0x82

#ifndef offsetof

#define offsetof(type, field) ((size_t) &((type *)0)->field)

#endif

#ifndef countof

#define countof(tab) (sizeof(tab) / sizeof((tab)[0]))

#endif

#define TOK_EOF       (-1)  /* end of file */

#define TOK_LINEFEED  10    /* line feed */

/* all identificators and strings have token above that */

#define TOK_IDENT 256

#define DEF_ASM(x) DEF(TOK_ASM_ ## x, #x)

#define TOK_ASM_int TOK_INT

#define DEF_ASMDIR(x) DEF(TOK_ASMDIR_ ## x, "." #x)

#define TOK_ASMDIR_FIRST TOK_ASMDIR_byte

#define TOK_ASMDIR_LAST TOK_ASMDIR_section

#if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64

/* only used for i386 asm opcodes definitions */

#define DEF_BWL(x) \

 DEF(TOK_ASM_ ## x ## b, #x "b") \

 DEF(TOK_ASM_ ## x ## w, #x "w") \

 DEF(TOK_ASM_ ## x ## l, #x "l") \

 DEF(TOK_ASM_ ## x, #x)

#define DEF_WL(x) \

 DEF(TOK_ASM_ ## x ## w, #x "w") \

 DEF(TOK_ASM_ ## x ## l, #x "l") \

 DEF(TOK_ASM_ ## x, #x)

#ifdef TCC_TARGET_X86_64

# define DEF_BWLQ(x) \

 DEF(TOK_ASM_ ## x ## b, #x "b") \

 DEF(TOK_ASM_ ## x ## w, #x "w") \

 DEF(TOK_ASM_ ## x ## l, #x "l") \

 DEF(TOK_ASM_ ## x ## q, #x "q") \

 DEF(TOK_ASM_ ## x, #x)

# define DEF_WLQ(x) \

 DEF(TOK_ASM_ ## x ## w, #x "w") \

 DEF(TOK_ASM_ ## x ## l, #x "l") \

 DEF(TOK_ASM_ ## x ## q, #x "q") \

 DEF(TOK_ASM_ ## x, #x)

# define DEF_BWLX DEF_BWLQ

# define DEF_WLX DEF_WLQ

/* number of sizes + 1 */

# define NBWLX 5

#else

# define DEF_BWLX DEF_BWL

# define DEF_WLX DEF_WL

/* number of sizes + 1 */

# define NBWLX 4

#endif

#define DEF_FP1(x) \

 DEF(TOK_ASM_ ## f ## x ## s, "f" #x "s") \

 DEF(TOK_ASM_ ## fi ## x ## l, "fi" #x "l") \

 DEF(TOK_ASM_ ## f ## x ## l, "f" #x "l") \

 DEF(TOK_ASM_ ## fi ## x ## s, "fi" #x "s")

#define DEF_FP(x) \

 DEF(TOK_ASM_ ## f ## x, "f" #x ) \

 DEF(TOK_ASM_ ## f ## x ## p, "f" #x "p") \

 DEF_FP1(x)

#define DEF_ASMTEST(x,suffix) \

 DEF_ASM(x ## o ## suffix) \

 DEF_ASM(x ## no ## suffix) \

 DEF_ASM(x ## b ## suffix) \

 DEF_ASM(x ## c ## suffix) \

 DEF_ASM(x ## nae ## suffix) \

 DEF_ASM(x ## nb ## suffix) \

 DEF_ASM(x ## nc ## suffix) \

 DEF_ASM(x ## ae ## suffix) \

 DEF_ASM(x ## e ## suffix) \

 DEF_ASM(x ## z ## suffix) \

 DEF_ASM(x ## ne ## suffix) \

 DEF_ASM(x ## nz ## suffix) \

 DEF_ASM(x ## be ## suffix) \

 DEF_ASM(x ## na ## suffix) \

 DEF_ASM(x ## nbe ## suffix) \

 DEF_ASM(x ## a ## suffix) \

 DEF_ASM(x ## s ## suffix) \

 DEF_ASM(x ## ns ## suffix) \

 DEF_ASM(x ## p ## suffix) \

 DEF_ASM(x ## pe ## suffix) \

 DEF_ASM(x ## np ## suffix) \

 DEF_ASM(x ## po ## suffix) \

 DEF_ASM(x ## l ## suffix) \

 DEF_ASM(x ## nge ## suffix) \

 DEF_ASM(x ## nl ## suffix) \

 DEF_ASM(x ## ge ## suffix) \

 DEF_ASM(x ## le ## suffix) \

 DEF_ASM(x ## ng ## suffix) \

 DEF_ASM(x ## nle ## suffix) \

 DEF_ASM(x ## g ## suffix)

#endif /* defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64 */