Tiny C Compiler

From Wikipedia, the free encyclopedia

Tiny C Compiler

Developer:	Fabrice Bellard
Latest release:	0.9.23 / June 17, 2005
OS:	Linux, Unix, Microsoft Windows
Use:	C compiler
License:	GNU Lesser General Public License
Website:	http://tinycc.org

The Tiny C Compiler (aka TCC, tcc, or TinyCC) is an x86 C language compiler created by Fabrice Bellard. It is designed to work for slow computers with little disk space (e.g. on rescue disks). The newest version (0.9.23, 17 Jun 2005) can be used on MS Windows operating systems too. TCC is distributed under the GNU Lesser General Public License (LGPL).

TCC supports much of ANSI C, much of the new ISO C99 standard and many GNUC extensions including inline assembly. However, it does make some compromises, and improving TCC to achieve compliance might significantly slow it down. Examples of unsupported areas are trigraph handling, proper type and expression checking, and incorrect nested macro expansion.

1 Features
2 Compiled program performance
3 Uses
4 History
5 Current Status
6 References
7 External links

[edit] Features

TCC has the following features:

Small - can compile and execute C code everywhere, for example on rescue disks (about 100KB for x86 TCC executable, including C preprocessor, C compiler, assembler and linker).
Fast - tcc generates optimized x86 code. No byte code overhead. It compiles, assembles and links about 9 times faster than GCC.
Any C dynamic library can be used directly. TCC is heading towards full ISOC99 compliance. TCC can of course compile itself.
Includes an optional memory and bound checker. Bound checked code can be mixed freely with standard code.
Compile and execute C source directly. No linking or assembly necessary. Full C preprocessor and GNU-like assembler included.
C script is supported: just add '#!/usr/local/bin/tcc -run' at the first line of your C source, and execute it directly from the command line.
With libtcc, you can use TCC as a backend for dynamic code generation.
Few dependencies. It includes its own hand-written lexer, and it is implemented using a recursive descent parser. Thus, building TCC requires few other libraries.

Its LGPL license permits anyone to use, modify, and/or redistribute the software, and it can be used to develop either open source or proprietary software.

[edit] Compiled program performance

Although the TCC compiler itself is exceptionally fast and produces very small executables, there is an inherent trade off between this size of the compiler and the performance of the code that TCC produces.

TCC does perform a few optimizations, such as constant propagation for all operations, multiplications and divisions are optimized to shifts when appropriate, and comparison operators are specially optimized (by maintaining a special cache for the processor flags). It also does some simple register allocation, which prevents many extraneous save/load pairs inside a single statement.

But in general, TCC's implementation emphasizes smallness instead of optimally-performing results. TCC generates code in a single pass, and does not perform most of the optimizations performed by other compilers such as gcc. TCC compiles every statement on its own, and at the end of each statement register values are written back to the stack and must be re-read even if the next line uses the values in registers (creating extraneous save/load pairs between statements). TCC only uses some of the available registers (e.g., on x86 it never uses ebx, esi, or edi because they need to be preserved across function calls).^[1]

Here are two benchmark examples:

Rough benchmarks of a recursive Fibonacci algorithm on a 1.8Ghz Intel Centrino laptop with 512MB RAM yields a noticeable difference in results between Microsoft Visual C++ compiler 13.10.3052 and TCC. To calculate the 49th Fibonacci number, it took a TCC-compiled program approximately 110 seconds whereas the same program compiled by VC++ took approximately 93 seconds. Here, TCC takes 18% longer.
With a tcc modified to compile gcc, running cc1 (the gcc C compiler) on itself required 518 seconds when compiled using GCC 3.4.2 (-O1), 558 seconds using GCC 2.95.3 (-O1), 545 using Microsoft C compiler, and 1145 seconds using tcc. ^[2] In this case TCC generates code that runs about 100% longer (double the time) of the speed of the other compilers when they are mildly optimizing (-O1).

[edit] Uses

Well-known uses of tcc include:

TCCBOOT, an impressive hack where TCC loads and boots a Linux kernel from source in about 10 seconds. That is to say, it is a "boot loader" which reads Linux kernel source code from disk, writes executable instructions to memory, and begins running it. This did require changes to the Linux build process.
TCC was used to demonstrate a defense against the trusting trust attack^[3]
TCC has been used to compile gcc, though various patches were required to make this work [1]
Cinpy is a Python library that allows you to implement functions with C in Python modules. The functions are compiled with tcc (Tiny C Compiler) in runtime. The results are made callable in Python through the ctypes library.
Rob Landley's Firmware Linux is to eventually use tcc.

[edit] History

TCC has its origins in the Obfuscated Tiny C Compiler (OTCC), a program Bellard wrote to win the International Obfuscated C Code Contest (IOCCC) in 2002. Since that time, Bellard expanded and un-obfuscated the program to produce tcc.^[4]

[edit] Current Status

The original developer, Fabrice Bellard, has been busy on other projects, leaving official tcc development slowed. Various others have distributed patches or download sites of various improved versions of tcc, such as Landley's Mercurial branch, Dave Dodge's collection of unofficial tcc patches, Debian and kfreebsd downstream patches, and grischka's gcc patches^[2].

TCC 0.9.23 is the subject of vulnerability number CVE-2006-0635, which is also Open Source Vulnerability Database vulnerability 22956. The report is that TCC "contains a flaw that may have security implications on programs compiled with it. The compiler fails to return unsigned values for the sizeof operator, resulting in potential integer overflows in the objects it compiles." At this time the official released version of TCC still has this vulnerability.

TCC does have an active mailing list, and Bellard's current version is available through CVS.