tcc(1)

NAME
tcc - User interface to the TDF system

SYNOPSIS
tcc [ options ] files

DESCRIPTION
tcc is the user interface to the TDF system. It is more fully documented in the tcc User's Guide.

tcc accepts several types of arguments as files:

-   Arguments whose names end in .c are understood to be C source files.

-   Arguments whose names end in .i are understood to be preprocessed C source files.

-   Arguments whose names end in .C are understood to be C++ source files (only if -Yc++ is specified).

-   Arguments whose names end in .I are understood to be preprocessed C++ source files (only if -Yc++ is specified).

-   Arguments whose names end in .j are understood to be target independent TDF capsules.

-   Arguments whose names end in .ta are understood to be archives of target independent TDF capsules.

-   Arguments whose names end in .t are understood to be target dependent TDF capsules.

-   Arguments whose names end in .s are understood to be assembly source files.

-   Arguments whose names end in .d are understood to be TenDRA dump files.

-   Arguments whose names end in .K are understood to be C++ spec files (only if -Yc++ is specified).

-   Arguments whose names end in .p are understood to be TDF notation source files (only if -Ytnc is specified).

-   Arguments whose names end in .pl are understood to be PL_TDF source files (only if -Ypl_tdf is specified).

-   All other arguments (but particularly those whose names end in .o and .a) are understood to be binary object files.

The compilation process is as follows. Depending on the options given, it may halt at any stage:

1.  TDF archives are split into their constituent target independent capsules.

2.  C source files (including preprocessed C) are compiled into target independent TDF capsules using tdfc(1). (tcpplus(1) does the same for C++ source files when -Yc++ is specified.)

3.  Target independent TDF capsules are linked, using tld(1), with the TDF libraries to produce target dependent TDF capsules.

4.  Target dependent TDF capsules are translated into assembly source files using one of mipstrans(1) (q.v. - things are not quite so simple in this case), trans386(1) etc.

5.  Assembly source files are compiled into binary object files using as(1).

6.  Binary object files are linked with the precompiled libraries, using ld(1), to produce a final executable.

With the exception of binary object files, intermediate files are not preserved unless explicitly instructed.

The standard file suffixes c, i, C, I, j, t, s, o, d, k, and K, together with p (pretty-printed TDF capsule) and pl (PL_TDF source file), are used to indicate file types in some options. Also the various compilation phases are identified by letters in some options. These are:

c   C to TDF producer

p   C preprocessor

x   C++ to TDF producer (only if -Yc++ is specified)

g   C++ preprocessor (only if -Yc++ is specified)

L   TDF linker (or builder)

t   TDF translator

a   System assembler

l   System linker

S   C++ spec linker

e   Compact-output error reporter (only if -Ycompact is specified)

u   TenDRA dump file linker

d   TDF pretty-printer

OPTIONS
The following options are supported by tcc. All options are scanned before input files are dealt with. The system variable TCCOPTS may be used to specify a list of options which are processed before the first command-line option.

-Astring
    Asserts the predicate string.

-Bstring
    Passed to the system linker. The valid values of string are target dependent.

-C  Not implemented and provided for cc(1) compatibility only. It is meant to preserve comments when preprocessing.

-Dstring
    Where string is of the form macro or macro=defn, is equivalent to inserting the preprocessor directives "#define macro 1" or "#define macro defn" at the start of each C source file. This is implemented by tcc writing this directive into a start-up file.

-E  Invokes the C preprocessor only, putting the result into a file with a .i suffix if other options indicate that preprocessed C files are to be preserved, or onto the standard output otherwise. Similarly, C++ source files are preprocessed and put into files with .I suffixes.

-Eletter:file
    Causes file to be invoked as the executable for the compilation stage given by letter.

-Fletter
    Tells tcc to stop after producing the files indicated by letter, and to preserve these files. letter is a single character corresponding to the suffix of the files to be preserved.

-G  Provided for cc compatibility.

-H  Causes the names of files included by a '#include' directive to be printed.

-Istring
    Tells the producers and preprocessors to search the directory string for included files. The directories are searched in the order given, followed by the system default directories.

-Jstring
    Tells the TDF linker to search the directory string for TDF libraries. The linker searches the directories in the order given, followed by the system default directories.

-Kstring,...
    Provided for cc compatibility. Specifies various installer options.

-Lstring
    Tells the system linker to search the directory string for libraries. It searches the directories in the order given, followed by the system default directories.

-M  Specifies that the TDF linker should link all the given target independent TDF capsules into one. This is done between stages 2 and 3 above. The default name for the produced capsule is a.j.

-MA Specifies that the TDF linker should link all the given target independent TDF capsules into one and also hide all the defined tag and token names from the resultant TDF (except the tag "main"). This should only be used to compile complete programs. The default name for the resulting capsule is a.j.

-Nidentifier:string
    As -Istring except that the identifier identifier is associated with the directory string in the producer.

-Ostring
    This flag has no effect other than to cancel any previous diagnostics flag and is included only for compatibility with other compilers. All TDF optimisations are on by default. All optimisations are believed to be correct, any bug which occurs in the fully-optimised state is a genuine bug.

-P  Invokes the C preprocessor only, putting the result into a file with a .i suffix. The C++ preprocessor is similarly invoked for C++ source files, putting the result into a file with a .I suffix.

-Pletter...
    Tells tcc to preserve those files indicated by letter. Each letter is a single character corresponding to the suffix of the files to be preserved. The tcc startup-file can be preserved as tcc_startup.h using -Ph. All intermediate files can be preserved using -Pa.

-S  Tells tcc to stop after producing an assembly source file. This is equivalent to -Fs.

-Sletter,string,...
    The specifies that the list of input files string all have type letter, where letter is a single character giving the normal suffix of the file type. This gives an alternative method of passing input files to tcc, one which does not depend on it having to recognise suffixes to find the type of a file.

-Sletter:string
    Similar to the option above, but specifies a single input file, string (which may contain a comma).

-Ustring
    Is equivalent to inserting the preprocessor directive "#undef string" at the start of each C source file. This is implemented by tcc writing this directive into a start-up file. The only macros built into the C to TDF producer are __LINE__ , __FILE__ , __DATE__ , __TIME__ , __STDC__ , __ANDF__ and __TenDRA__ .

-V  Causes all tools invoked by tcc to print their version numbers.

-Wletter,string,...
    This passes the list of options string to the compilation phase indicated by letter.

-Wletter:string
    Similar to the option above, but specifies a single option string (which may contain a comma).

-Xstring
    Specifies a compilation mode. string can be a for "lenient ANSI", c for "strict ANSI" (this is default), p for "strict ANSI with some extra checks", s for "strict ANSI with many extra checks" or t for "traditional".

-X:string
    Specifies an individual compilation option. See the tcc User's Guide for details.

-Yfile
    Specifies the environment to use. An environment is a file telling tcc to modify its defaults. If the full pathname of env is not given, the file is searched for along the tcc environments path which is a list of directories separated by colons. This search path can be printed using -show_env. There are certain standard environments, for example, ansi, representing the ANSI API (this is the default API environment), posix represents the POSIX API, xpg3 the XPG3 API, and so on. The system environment allows tcc to behave like cc(1), using the system header files etc. See the tcc User's Guide and tccenv(5) manual page for more details about environments.

-Zstring
    Provided for cc(1) compatibility. Specifies various installer options.

-api_check
    Causes tchk to create an API usage analysis file, with default name a.api.

-api_check_out string
    If an API usage analysis file is produced, call it string.

-b  Stops the library libc.a being used by the linker by default.

-c  Tells tcc to stop after producing the binary object files. This is equivalent to -Fo.

-cc Causes tcc to invoke cc(1) for its code production, using the C to TDF producer as a checking front-end to cc. This allows the checking capabilities of the front-end of the TDF compiler to be exploited on machines where no TDF back-end is available.

-cc_only
    Causes tcc to invoke cc(1) only.

-ch Causes tcc to emulate the stand-alone static checker, tchk(1). Intermodular checks are enabled in this mode.

-d  Halts the compilation after the creation of the dump files. This is equivalent to -Fd.

-disp
    Runs the TDF pretty-printer on all files at stage 2 or 3 and then terminates. The results are put into files with .p suffixes.

-disp_t
    Runs the pretty-printer on all files at stage 3 and then terminates. This differs from the previous option in that it displays the TDF after linking with the target-dependent TDF libraries rather than before. The output is put into a file with a .p suffix.

-dn or -dy
    Passed to the system linker.

-doletter string
    Sets the name of the default output file of type letter to string. For example, -doh can be used to set the name of the preserved start-up file.

-dry
    Makes tcc print information on what system commands it would execute with the given files and options (as in verbose mode) but not actually perform them.

-dump
    Causes tcc to dump its current status. This option is only used during the actual compilation of tcc.

-estring
    Is equivalent to inserting the preprocessor directive "#include "string"" at the end of each C source file.

-fstring
    Is equivalent to inserting the preprocessor directive "#include "string"" at the start of each C source file.

-g  Tells tcc to produce diagnostic information compatible with the system debugger.

-hstring
    Passed to the system linker.

-i  Tells tcc to stop after producing the target independent TDF capsules. This is equivalent to -Fj.

-im Enables intermodular checks.

-im0
    Disables intermodular checks.

-info
    Causes tcc to print information on the current API.

-jstring
    Tells the TDF linker to use the TDF library string.tl.

-k  In intermodular checking mode, halts the compilation after the creation of the C++ spec files. This is equivalent to -FK.

-keep_errors
    By default, if an error occurs during the production of a file, tcc will remove it. This option will preserve such files.

-lstring
    Tells the system linker to use the library libstring.a.

-make_up_names
    Causes tcc to make up names for all intermediate files rather than forming them from the basenames of the input files.

-message string
    Causes tcc to print the message string.

-nepc
    Tells the C to TDF producer to allow certain non-portable constructs through.

-not_ansi
    Tells the C to TDF producer to allow certain non-ANSI features through.

-no_startup_options
    Ensures that no start-up or end-up options are passed to the C to TDF producer (unlikely to be useful).

-o string
    If a final executable is produced, call it string (the default is a.out). Otherwise, if only one file is preserved, call it string.

-p  Produces profiling data for use with prof(1) on those machines for which this command is available.

-prod
    Specifies that tcc should stop after producing the target independent TDF capsules and combine them into a TDF archive. The default archive name is a.ta.

-q or -quiet
    Specifies that tcc should work silently. This is the default.

-query
    Causes tcc to print a list of all the options it recognises, together with a brief description of each. Since this list is automatically generated it is likely to be more accurate than this manual page.

-s  Passed to the system linker.

-sletter:suffix
    Specifies that files with suffix suffix are interpreted as having type indicated by letter.

-show_env
    Prints the tcc environments path. This is a list of directories separated by colons. The first element of the list is always the system default environments directory and the last element is always the current working directory. The other elements may be specified by the user by means of the TCCENV system variable.

-show_errors
    Makes tcc report on the command it was executing when an error occurred.

-special string
    Allows various internal options to be specified.

-startup string
    Causes string to be printed to the tcc built-in start-up file.

-sym
    Enables dump-linking.

-sym: string\fR
    Enables dump-linking (with mode specified by options in string).

-target string
    No effect (allowed for compatibility with cc(1) on some systems).

-temp dir
    Specifies that tcc should use dir as its temporary directory.

-tidy
    Causes tcc to remove its intermediate files when they are no longer required rather than waiting to the end of the compilation.

-time
    Makes tcc print information on what system commands it is executing (as with verbose mode) followed by the time taken for each.

-ustring
    Passed to the system linker.

-v or -verbose
    Specifies that tcc should work in verbose mode, sending information on what system commands it is executing to the standard output.

-vb Causes the name of each input file to be printed as it is processed.

-version
    Makes tcc report its version number.

-w  Suppresses all tcc warning messages.

-work string
    Specifies that all preserved intermediate files are placed in the directory string rather than where they are placed by default, in the current working directory.

-wsl
    Tells the TDF translator to make all string literals writable.

-zstring
    Passed to the system linker.

FILES

file.c
    C source file

file.i
    Preprocessed C source file

file.C
    C++ source file (only if -Yc++ is specified)

file.I
    Preprocessed C++ source file (only if -Yc++ is specified)

file.j
    Target independent TDF capsule

file.t
    Target dependent TDF capsule

file.s
    Assembly source file

file.o
    Binary object file

file.d
    TenDRA dump file

file.K
    C++ spec file (only if -Yc++ is specified)

file.p
    Pretty-printed TDF capsule

file.pl
    PL_TDF source file (only if -Ypl_tdf is specified)

file.ta
    TDF archive

file.G
    Binasm source file (Mips and Alpha only)

file.T
    Assembler symbol table (Mips and Alpha only)

a.out
    Default executable name

a.ta
    Default TDF archive name

a.d Default dump file name

a.api
    Default API usage analysis file name

a.j Default output file for merge-TDF-capsules option

tcc_startup.h
    Name of preserved tcc start-up file

/tmp/tcc*
    Temporary directory (this may be changed using the TMPDIR system variable, see tempnam(3)).

SEE ALSO
as(1), cc(1), disp(1), ld(1), prof(1), tchk(1), tdfc(1), tcpplus(1), tot_o(1), tld(1), trans386(1), alphatrans(1), hppatrans(1), mipstrans(1), sparctrans(1), tccenv(5).