tcc - Tiny C Compiler

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

TCC options are a 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: Compile a.c and execute it directly Compile a.c and execute it directly. arg1 is given as first argument to the CWmain() of a.c. Compile a.c and b.c, link them together and execute them. arg1 is given as first argument to the CWmain() of the resulting program. Because multiple C files are specified, -- are necessary to clearly separate the program arguments from the TCC options. Compile a.c and b.c, link them and generate the executable myprog. link a.o and b.o together and generate the executable myprog. Compile a.c and generate object file a.o. Preprocess with C preprocess and assemble asmfile.S and generate object file asmfile.o. Assemble (but not preprocess) asmfile.s and generate object file asmfile.o. 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 CW#!/usr/bin/tcc -run at the start of your C source:

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

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

-v

Display current TCC version.

-c

Generate an object file (-o option must also be given).

-o outfile

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

-Bdir

Set the path where the tcc internal libraries can be found (default is PREFIX/lib/tcc).

-bench

Output compilation statistics.

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

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

In a script, it gives the following header:

        #!/usr/bin/tcc -run -L/usr/X11R6/lib -lX11
        #include <stdlib.h>
        int main(int argc, char **argv)
        {
            ...
        }

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 CWchar type be unsigned.

-fsigned-char

Let the CWchar 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 CWconst char * instead of CWchar *.

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

-shared

Generate a shared library instead of an executable (-o option must also be given).

-static

Generate a statically linked executable (default is a shared linked executable) (-o option must also be given).

-rdynamic

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

-r

Generate an object file combining all input files (-o option must also be given).

-Wl,-Ttext,address

Set the start of the .text section to address.

-Wl,--oformat,fmt

Use fmt as output format. The supported output formats are: ELF output format (default) Binary image (only for executable output) COFF output format (only for executable output for TMS320C67xx target)

Debugger options:

-g

Generate run time debug information so that you get clear run time error messages: CW test.c:68: in function 'test5()': dereferencing invalid pointer instead of the laconic CWSegmentation 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.

-bt N

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

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

gcc(1)

Fabrice Bellard