TCC(1) General Commands Manual TCC(1)

tcc — Tiny C Compiler

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

is a lightweight and fast C compiler. Unlike other C compilers, it is meant to be self-relying; you do not need an external assembler or linker, because tcc does that for you.

tcc can run programs from memory without generating executable files, almost like scripting languages!

tcc runs on Linux, Windows, macOS, FreeBSD, NetBSD and OpenBSD operating systems. tcc can compile C code for i386, x86_64, arm, arm64 and riscv64 architectures.

Generate an object file.
outfile
Put object file, executable, or dll into output file outfile.
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
Display TCC version.
Show included files. As sole argument, print search dirs. -vvv shows too.
Display compilation statistics.

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

sym[=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
sym
Undefine preprocessor symbol sym.
Preprocess only, to stdout or file (with -o).

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

Let the char type be unsigned.
Let the char type be signed.
Do not generate common symbols for uninitialized data.
Add a leading underscore at the beginning of each C symbol.
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.
Allow dollar signs in identifiers.

Disable all warnings.

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

Warn about implicit function declaration.
Warn about unsupported GCC features that are ignored by TCC.
Make string constants be of type const char * instead of char *.
Abort compilation if warnings are issued.
Activate all warnings, except -Werror, -Wunusupported and -Wwrite-strings.

dir
Specify an additional static library path for the -l option. The default library paths are /usr/local/lib, /usr/lib and /lib.
name
Link your program with dynamic library libname.so or static library libname.a. The library is searched in the paths specified by the -L option and LIBRARY_PATH variable.
dir
Set the path where the tcc internal libraries (and include files) can be found (default is PREFIX/lib/tcc).
Generate a shared library instead of an executable.
name
set name for shared library to be used at runtime.
Generate a statically linked executable (default is a shared linked executable).
Export global symbols to the dynamic linker. It is useful when a library opened with dlopen(3) needs to access executable symbols.
Generate an object file combining all input files.
,-rpath=path
Put custom search path for dynamic libraries into executable.
,--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.
,--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 target)
,--export-all-symbols
 
,--export-dynamic
Export global symbols to the dynamic linker. It is useful when a library opened with dlopen(3) needs to access executable symbols.
,-subsystem=console/gui/wince/...
Set type for PE (Windows) executables.
,-T[text=# | section-alignment=# | file-alignment=# | image-base=# | stack=#]

Modify executable layout.

,-Bsymbolic
Set DT_SYMBOLIC tag.
,-[no-]whole-archive
Turn on/off linking of all objects in archives.

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.
Generate additional support code to check memory allocations and array/pointer bounds. -g is implied.
[N]
Display N callers in stack traces. This is useful with -g or -b.

With executables, additional support for stack traces is included.

A function int (const char *fmt, ...) is provided to trigger a stack trace with a message on demand.

Generate makefile fragment with dependencies.
depfile
Use depfile as output for -MD.
Print the configured installation directory and a list of library and include directories tcc will search.
Print version.

Use an algorithm for bitfield alignment consistent with MSVC. Default is gcc(1)'s algorithm.
(ARM only)
Select the float ABI. Possible values: and .
Do not use sse registers on x86_64
, -m64
Pass command line to the i386/x86_64 cross compiler.

Note: gcc(1) options -Ox, -fx and -mx are ignored.

Environment variables that affect how tcc operates.

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

Compile a.c and execute it directly:

tcc -run a.c

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

tcc -run a.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 a.c -run b.c arg1

Compile a.c and b.c, link them and generate the executable myprog.

tcc -o myprog a.c b.c

Link a.o and b.o together and generate the executable myprog.

tcc -o myprog a.o b.o

Compile a.c and generate object file a.o.

tcc -c a.c

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 -c asmfile.s

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

tcc -r -o ab.o a.c b.c

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. Use - in the place of input file names. For example:
echo 'main(){puts("hello");}' | tcc -run -

The tcc utility exits 0 on success, and >0 if an error occurs.

cc(1), cpp(1), dlopen(3), elf(5), gcc(1), ld(1).

Fabrice Bellard

December 25, 2020 OpenBSD 6.8