TCC-DOC(1)

NAME
tcc - Tiny C Compiler

SYNOPSIS
usage: tcc [options] [infile1 infile2...] [-run infile args...]

DESCRIPTION
TCC options are very much like gcc options. The main difference is that TCC can also execute directly the resulting program and give it runtime arguments.

Here are some examples to understand the logic:

"tcc -run a.c"
    Compile a.c and execute it directly

"tcc -run a.c arg1"
    Compile a.c and execute it directly. arg1 is given as first argument to the main() of a.c.

"tcc a.c -run b.c arg1"
    Compile a.c and b.c, link them together and execute them. arg1 is given as first argument to the main() of the resulting program.

"tcc -o myprog a.c b.c"
    Compile a.c and b.c, link them and generate the executable myprog.

"tcc -o myprog a.o b.o"
    link a.o and b.o together and generate the executable myprog.

"tcc -c a.c"
    Compile a.c and generate object file a.o.

"tcc -c asmfile.S"
    Preprocess with C preprocess and assemble asmfile.S and generate object file asmfile.o.

"tcc -c asmfile.s"
    Assemble (but not preprocess) asmfile.s and generate object file asmfile.o.

"tcc -r -o ab.o a.c b.c"
    Compile a.c and b.c, link them together and generate the object file ab.o.

Scripting:

TCC can be invoked from scripts, just as shell scripts. You just need to add "#!/usr/local/bin/tcc -run" at the start of your C source:

        #!/usr/local/bin/tcc -run
        #include <stdio.h>

        int main()
        {
            printf("Hello World\n");
            return 0;
        }

TCC can read C source code from standard input when - is used in place of infile. Example:

        echo 'main(){puts("hello");}' | tcc -run -

OPTIONS

-c  Generate an object file.

-o outfile
    Put object file, executable, or dll into output file outfile.

-run source [args...]
    Compile file source and run it with the command line arguments args. In order to be able to give more than one argument to a script, several TCC options can be given after the -run option, separated by spaces:

            tcc "-run -L/usr/X11R6/lib -lX11" ex4.c

    In a script, it gives the following header:

            #!/usr/local/bin/tcc -run -L/usr/X11R6/lib -lX11

-v  Display TCC version.

-vv Show included files. As sole argument, print search dirs. -vvv shows tries too.

-bench
    Display compilation statistics.

Preprocessor options:

-Idir
    Specify an additional include path. Include paths are searched in the order they are specified.

    System include paths are always searched after. The default system include paths are: /usr/local/include, /usr/include and PREFIX/lib/tcc/include. (PREFIX is usually /usr or /usr/local).

-isystem dir
    Specify a system include path to be added to the defaults.

-nostdinc
    Do not search the default system include paths; only search include paths provided on the command line.

-include file
    Include file above each input file.

-Dsym[=val]
    Define preprocessor symbol sym to val. If val is not present, its value is 1. Function-like macros can also be defined: -DF(a)=a+1

-Usym
    Undefine preprocessor symbol sym.

-E  Preprocess only, to stdout or file (with -o).

-P  Do not output "#line" directives.

-P1 Output alternative "#line" directives.

-dD, -dM
    Output "#define" directives.

-Wp,-opt
    Same as -opt.

Compilation flags:

Note: each of the following options has a negative form beginning with -fno-.

-funsigned-char
    Let the "char" type be unsigned.

-fsigned-char
    Let the "char" type be signed.

-fno-common
    Do not generate common symbols for uninitialized data.

-fleading-underscore
    Add a leading underscore at the beginning of each C symbol.

-fms-extensions
    Allow a MS C compiler extensions to the language. Currently this assumes a nested named structure declaration without an identifier behaves like an unnamed one.

-fdollars-in-identifiers
    Allow dollar signs in identifiers

-freverse-funcargs
    Evaluate function arguments right to left.

-fgnu89-inline
    "extern inline" is like "static inline".

-fasynchronous-unwind-tables
    Create eh_frame section [on]

-ftest-coverage
    Create code coverage code. After running the resulting code an executable.tcov or sofile.tcov file is generated with code coverage.

Warning options:

-w  Disable all warnings.

Note: each of the following warning options has a negative form beginning with -Wno-.

-Wimplicit-function-declaration
    Warn about implicit function declaration (missing prototype).

-Wdiscarded-qualifiers
    Warn when const is dropped.

-Wunsupported
    Warn about unsupported GCC features that are ignored by TCC.

-Wwrite-strings
    Make string constants be of type "const char *" instead of "char *".

-Werror
    Abort compilation if a warning is issued. Can be given an option to enable the specified warning and turn it into an error, for example -Werror=unsupported.

-Wall
    Activate some useful warnings (-Wimplicit-function-declaration, -Wdiscard-qualifiers).

Linker options:

-Ldir
    Specify an additional static library path for the -l option. The default library paths are /usr/local/lib, /usr/lib and /lib.

-lxxx
    Link your program with dynamic library libxxx.so or static library libxxx.a. The library is searched in the paths specified by the -L option and LIBRARY_PATH variable.

-Bdir
    Set the path where the tcc internal libraries (and include files) can be found (default is PREFIX/lib/tcc).

-shared
    Generate a shared library instead of an executable.

-soname name
    set name for shared library to be used at runtime

-static
    Generate a statically linked executable (default is a shared linked executable).

-rdynamic
    Export global symbols to the dynamic linker. It is useful when a library opened with dlopen() needs to access executable symbols.

-r  Generate an object file combining all input files.

-nostdlib
    Don't implicitly link with libc, the C runtime files, and libtcc1.

-Wl,-nostdlib
    Don't search the default paths for libraries (/usr/local/lib, /usr/lib and /lib). Only the paths specified with -L and LIBRARY_PATH are searched.

-Wl,-rpath=path
    Put custom search path for dynamic libraries into executable.

-Wl,-Ipath
-Wl,--dynamic-linker=path
    Set the ELF interpreter (dynamic linker). This defaults to the value of the environment variable LD_SO if set, or a compiled-in default.

-Wl,--enable-new-dtags
    When putting a custom search path for dynamic libraries into the executable, create the new ELF dynamic tag DT_RUNPATH instead of the old legacy DT_RPATH.

-Wl,--oformat=fmt
    Use fmt as output format. The supported output formats are:

    "elf32-i386"
        ELF output format (default)

    "binary"
        Binary image (only for executable output)

    "coff"
        COFF output format (only for executable output for TMS320C67xx target)

-Wl,--export-all-symbols
-Wl,--export-dynamic
    Export global symbols to the dynamic linker. It is useful when a library opened with dlopen() needs to access executable symbols.

-Wl,-subsystem=console/gui/wince/...
    Set type for PE (Windows) executables.

-Wl,-[Ttext=# | section-alignment=# | file-alignment=# | image-base=# | stack=#]
    Modify executable layout.

-Wl,-Bsymbolic
    Set DT_SYMBOLIC tag.

-Wl,-(no-)whole-archive
    Turn on/off linking of all objects in archives.

Debugger options:

-g  Generate run time stab debug information so that you get clear run time error messages: " test.c:68: in function 'test5()': dereferencing invalid pointer" instead of the laconic "Segmentation fault".

-gdwarf[-x]
    Generate run time dwarf debug information instead of stab debug information.

-b  Generate additional support code to check memory allocations and array/pointer bounds. -g is implied.

-bt[N]
    Display N callers in stack traces. This is useful with -g or -b. When activated, "__TCC_BACKTRACE__" is defined.

    With executables, additional support for stack traces is included. A function
        " int tcc_backtrace(const char *fmt, ...); " is provided to trigger a stack trace with a message on demand.

Misc options:

-std=version
    Define "__STDC_VERSION__": 201112 if version is c11 or gnu11; 199901 otherwise.

-x[c|a|b|n]
    Specify content of next input file: respectively C, assembly, binary, or none.

-O[n]
    Same as -D__OPTIMIZE__ except for -O0.

-pthread
    Preprocess with -D_REENTRANT, link with -lpthread.

-M  Just output makefile fragment with dependencies

-MM Like -M except mention only user header files, not system header files.

-MD Generate makefile fragment with dependencies.

-MMD
    Like -MD except mention only user header files, not system header files.

-MF depfile
    Use depfile as output for -MD.

-MP Mention all dependencies as targets too.

-print-search-dirs
    Print the configured installation directory and a list of library and include directories tcc will search.

-dumpversion
    Print version.

-dt With -run/-E: auto-define 'test_...' macros

Target specific options:

-mms-bitfields
    Use an algorithm for bitfield alignment consistent with MSVC. Default is gcc's algorithm.

-mfloat-abi (ARM only)
    Select the float ABI. Possible values: "softfp" and "hard"

-mno-sse
    Do not use sse registers on x86_64

-m32, -m64
    Pass command line to the i386/x86_64 cross compiler.

Note: GCC options -fx and -mx are ignored.

ENVIRONMENT
Environment variables that affect how tcc operates.

CPATH
C_INCLUDE_PATH
    A colon-separated list of directories searched for include files, directories given with -I are searched first.

LIBRARY_PATH
    A colon-separated list of directories searched for libraries for the -l option, directories given with -L are searched first.

SEE ALSO
cpp(1), gcc(1)

AUTHOR
Fabrice Bellard