tcc(1)



TCC(1)                          Tiny C Compiler                         TCC(1)

NAME
       tcc - Tiny C Compiler

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

DESCRIPTION
       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:

       "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

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

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

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

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

       -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,-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 when using libtcc 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.

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

0.9.27 (prerelease)               2016-12-18                            TCC(1)

Man(1) output converted with man2html
list of all man pages