tcc - Tiny C Compiler

       Fabrice Bellard

0.9.27                                             2024-08-10                                         TCC-DOC(1)

       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-runa.c"
           Compile a.c and execute it directly

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

       "tcca.c-runb.carg1"
           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-omyproga.cb.c"
           Compile a.c and b.c, link them and generate the executable myprog.

       "tcc-omyproga.ob.o"
           link a.o and b.o together and generate the executable myprog.

       "tcc-ca.c"
           Compile a.c and generate object file a.o.

       "tcc-casmfile.S"
           Preprocess with C preprocess and assemble asmfile.S and generate object file asmfile.o.

       "tcc-casmfile.s"
           Assemble (but not preprocess) asmfile.s and generate object file asmfile.o.

       "tcc-r-oab.oa.cb.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 standardinput when - is used in place of infile. Example:

               echo 'main(){puts("hello");}' | tcc -run -

       Environment variables that affect how tcc operates.

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

       tcc - Tiny C Compiler

-c  Generate an object file.

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

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

       -v  Display TCC version.

       -vv Show included files.  As sole argument, print search dirs.  -vvv shows tries too.

       -bench
           Display compilation statistics.

       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.

       -E  Preprocess only, to stdout or file (with -o).

       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.

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

       -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,--export-all-symbols-Wl,--export-dynamic
           Export global symbols to the dynamic linker. It is useful when a library opened with  dlopen()  needs
           to access executable symbols.

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

       -Wl,-(no-)whole-archive
           Turn on/off linking of all objects in archives.

       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.   The  bound  checking  code  is  not
           included in shared libraries. The main executable should always be compiled with the -b.

           There are five environment variables that can be used:

           TCC_BOUNDS_WARN_POINTER_ADD
               Print warning when pointer add creates an illegal pointer.

           TCC_BOUNDS_PRINT_CALLS
               Print bound checking calls. Can be used for debugging.

           TCC_BOUNDS_PRINT_HEAP
               Print heap objects that are not freed at exit of program.

           TCC_BOUNDS_PRINT_STATISTIC
               Print statistic information at exit of program.

           TCC_BOUNDS_NEVER_FATAL
               Try to continue in case of a bound checking error.

           Note:  -b  is  only available on i386 (linux and windows), x86_64 (linux and windows), arm, arm64 and
           riscv64 for the moment.

       -bt[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 tcc_backtrace(const char *fmt, ...); " is provided to trigger a stack trace with a
           message on demand.

       Misc options:

       -MD Generate makefile fragment with dependencies.

       -MFdepfile
           Use depfile as output for -MD.

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

       -dumpversion
           Print version.

       Target specific options:

       -mms-bitfields
           Use an algorithm for bitfield alignment consistent with MSVC. Default is gcc's algorithm.

       -mfloat-abi(ARMonly)
           Select the float ABI. Possible values: "softfp" and "hard"

       -mno-sse
           Do not use sse registers on x86_64

       -m32,-m64
           Pass command line to the i386/x86_64 cross compiler.

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

cpp(1), gcc(1)

       usage: tcc [options] [infile1infile2...] [-runinfileargs...]