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. Because multiple C files are specified, -- are necessary to clearly separate the program arguments from the TCC options.

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;
        }

-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/local/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 "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.

-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 "dlopen()" 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:

elf32-i386

ELF output format (default)

binary

Binary image (only for executable output)

coff

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

-bt N

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

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