NAME

SYNOPSIS

DESCRIPTION

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
    

-dumpversion

Print only the compiler version and nothing else.

-v

Display TCC version.

-vv

Show included files. As sole argument, print search dirs (as below).

-bench

Display compilation statistics.

-print-search-dirs

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

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).

-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.

Compilation flags:

Note: each of the following warning 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.

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.

-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 warnings are issued.

-Wall

Activate all warnings, except -Werror, -Wunusupported and -Wwrite-strings.

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.

-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.

-Wl,-rpath=path

Put custom seatch path for dynamic libraries into executable.

-Wl,--oformat=fmt

Use fmt as output format. The supported output formats are:

-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.

Debugger options:

-g

Generate run time 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".

-b

Generate additional support code to check memory allocations and array/pointer bounds. -g is implied. Note that the generated code is slower and bigger in this case.

Note: -b is only available on i386 for the moment.

-bt N

Display N callers in stack traces. This is useful with -g or -b.

Misc options:

-MD

Generate makefile fragment with dependencies.

-MF depfile

Use depfile as output for -MD.

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

SEE ALSO

AUTHOR