Tiny C Compiler Reference Documentation

Introduction

TCC compiles so fast that even for big projects Makefiles may not be necessary.

TCC not only supports ANSI C, but also most of the new ISO C99 standard and many GNUC extensions.

TCC can also be used to make C scripts, i.e. pieces of C source that you run as a Perl or Python script. Compilation is so fast that your script will be as fast as if it was an executable.

TCC can also automatically generate memory and bound checks while allowing all C pointers operations. TCC can do these checks even if non patched libraries are used.

Full ANSI C support

• The preprocessor tokens are the same as C. It means that in some rare cases, preprocessed numbers are not handled exactly as in ANSI C. This approach has the advantage of being simpler and FAST!

ISOC99 extensions

• 64 bit 'long long' types are fully supported.
• The boolean type '_Bool' is supported.
• '__func__' is a string variable containing the current function name.
• Variadic macros: __VA_ARGS__ can be used for function-like macros:

      #define dprintf(level, __VA_ARGS__) printf(__VA_ARGS__)
  

  dprintf can then be used with a variable number of parameters.
• Declarations can appear anywhere in a block (as in C++).
• Array and struct/union elements can be initialized in any order by using designators:

      struct { int x, y; } st[10] = { [0].x = 1, [0].y = 2 };
  
      int tab[10] = { 1, 2, [5] = 5, [9] = 9};
  

• Compound initializers are supported:

      int *p = (int []){ 1, 2, 3 };
  

  to initialize a pointer pointing to an initialized array. The same works for structures and strings.
• Hexadecimal floating point constants are supported:

            double d = 0x1234p10;
  

  is the same as writing

            double d = 4771840.0;
  

• 'inline' keyword is ignored.
• 'restrict' keyword is ignored.

GNU C extensions

• array designators can be used without '=':

      int a[10] = { [0] 1, [5] 2, 3, 4 };
  

• Structure field designators can be a label:

      struct { int x, y; } st = { x: 1, y: 1};
  

  instead of

      struct { int x, y; } st = { .x = 1, .y = 1};
  

• '\e' is ASCII character 27.
• case ranges : ranges can be used in cases:

      switch(a) {
      case 1 ... 9:
            printf("range 1 to 9\n");
            break;
      default:
            printf("unexpected\n");
            break;
      }
  

• The keyword __attribute__ is handled to specify variable or function attributes. The following attributes are supported:
  • aligned(n): align data to n bytes (must be a power of two).
  • section(name): generate function or data in assembly section name (name is a string containing the section name) instead of the default section.
  • unused: specify that the variable or the function is unused.
  • cdecl: use standard C calling convention.
  • stdcall: use Pascal-like calling convention.
  
  Here are some examples:

      int a __attribute__ ((aligned(8), section(".mysection")));
  

  
  align variable 'a' to 8 bytes and put it in section .mysection.

      int my_add(int a, int b) __attribute__ ((section(".mycodesection"))) 
      {
          return a + b;
      }
  

  
  generate function 'my_add' in section .mycodesection.

TinyCC extensions

• __TINYC__ is a predefined macro to '1' to indicate that you use TCC.
• '#!' at the start of a line is ignored to allow scripting.
• Binary digits can be entered ('0b101' instead of '5').
• __BOUNDS_CHECKING_ON is defined if bound checking is activated.

TinyCC Memory and Bound checks

Note that pointer size is unchanged and that code generated with bound checks is fully compatible with unchecked code. When a pointer comes from unchecked code, it is assumed to be valid. Even very obscure C code with casts should work correctly.

To have more information about the ideas behind this method, check here.

Here are some examples of catched errors:

{
    char tab[10];
    memset(tab, 0, 11);
}

{
    int tab[10];
    for(i=0;i<11;i++) {
        sum += tab[i];
    }
}

{
    int *tab;
    tab = malloc(20 * sizeof(int));
    for(i=0;i<21;i++) {
        sum += tab4[i];
    }
    free(tab);
}

{
    int *tab;
    tab = malloc(20 * sizeof(int));
    free(tab);
    for(i=0;i<20;i++) {
        sum += tab4[i];
    }
}

{
    int *tab;
    tab = malloc(20 * sizeof(int));
    free(tab);
    free(tab);
}

Command line invocation

usage: tcc [-Idir] [-Dsym[=val]] [-Usym] [-llib] [-g] [-b]
           [-i infile] infile [infile_args...]