1 \input texinfo @c -*- texinfo -*-
3 @setfilename tcc-doc.info
4 @settitle Tiny C Compiler Reference Documentation
13 @center @titlefont{Tiny C Compiler Reference Documentation}
21 @node Top, Introduction, (dir), (dir)
22 @top Tiny C Compiler Reference Documentation
24 This manual documents version @value{VERSION} of the Tiny C Compiler.
27 * Introduction:: Introduction to tcc.
28 * Invoke:: Invocation of tcc (command line, options).
29 * Clang:: ANSI C and extensions.
30 * asm:: Assembler syntax.
31 * linker:: Output file generation and supported targets.
32 * Bounds:: Automatic bounds-checking of C code.
33 * Libtcc:: The libtcc library.
34 * devel:: Guide for Developers.
41 TinyCC (aka TCC) is a small but hyper fast C compiler. Unlike other C
42 compilers, it is meant to be self-relying: you do not need an
43 external assembler or linker because TCC does that for you.
45 TCC compiles so @emph{fast} that even for big projects @code{Makefile}s may
48 TCC not only supports ANSI C, but also most of the new ISO C99
49 standard and many GNUC extensions including inline assembly.
51 TCC can also be used to make @emph{C scripts}, i.e. pieces of C source
52 that you run as a Perl or Python script. Compilation is so fast that
53 your script will be as fast as if it was an executable.
55 TCC can also automatically generate memory and bound checks
56 (@pxref{Bounds}) while allowing all C pointers operations. TCC can do
57 these checks even if non patched libraries are used.
59 With @code{libtcc}, you can use TCC as a backend for dynamic code
60 generation (@pxref{Libtcc}).
62 TCC mainly supports the i386 target on Linux and Windows. There are alpha
63 ports for the ARM (@code{arm-tcc}) and the TMS320C67xx targets
64 (@code{c67-tcc}). More information about the ARM port is available at
65 @url{http://lists.gnu.org/archive/html/tinycc-devel/2003-10/msg00044.html}.
67 For usage on Windows, see also tcc-win32.txt.
70 @chapter Command line invocation
76 usage: tcc [options] [@var{infile1} @var{infile2}@dots{}] [@option{-run} @var{infile} @var{args}@dots{}]
81 @c man begin DESCRIPTION
82 TCC options are a very much like gcc options. The main difference is that TCC
83 can also execute directly the resulting program and give it runtime
86 Here are some examples to understand the logic:
89 @item @samp{tcc -run a.c}
90 Compile @file{a.c} and execute it directly
92 @item @samp{tcc -run a.c arg1}
93 Compile a.c and execute it directly. arg1 is given as first argument to
94 the @code{main()} of a.c.
96 @item @samp{tcc a.c -run b.c arg1}
97 Compile @file{a.c} and @file{b.c}, link them together and execute them. arg1 is given
98 as first argument to the @code{main()} of the resulting program.
100 Because multiple C files are specified, @option{--} are necessary to clearly
101 separate the program arguments from the TCC options.
104 @item @samp{tcc -o myprog a.c b.c}
105 Compile @file{a.c} and @file{b.c}, link them and generate the executable @file{myprog}.
107 @item @samp{tcc -o myprog a.o b.o}
108 link @file{a.o} and @file{b.o} together and generate the executable @file{myprog}.
110 @item @samp{tcc -c a.c}
111 Compile @file{a.c} and generate object file @file{a.o}.
113 @item @samp{tcc -c asmfile.S}
114 Preprocess with C preprocess and assemble @file{asmfile.S} and generate
115 object file @file{asmfile.o}.
117 @item @samp{tcc -c asmfile.s}
118 Assemble (but not preprocess) @file{asmfile.s} and generate object file
121 @item @samp{tcc -r -o ab.o a.c b.c}
122 Compile @file{a.c} and @file{b.c}, link them together and generate the object file @file{ab.o}.
128 TCC can be invoked from @emph{scripts}, just as shell scripts. You just
129 need to add @code{#!/usr/local/bin/tcc -run} at the start of your C source:
132 #!/usr/local/bin/tcc -run
137 printf("Hello World\n");
142 TCC can read C source code from @emph{standard input} when @option{-} is used in
143 place of @option{infile}. Example:
146 echo 'main()@{puts("hello");@}' | tcc -run -
150 @section Option summary
157 Display current TCC version, increase verbosity.
159 @item -print-search-dirs
160 Print the name of the configured installation directory and a list
161 of program and library directories tcc will search.
164 Generate an object file (@option{-o} option must also be given).
167 Put object file, executable, or dll into output file @file{outfile}.
170 Set the path where the tcc internal libraries can be found (default is
171 @file{PREFIX/lib/tcc}).
174 Output compilation statistics.
176 @item -run source [args...]
177 Compile file @var{source} and run it with the command line arguments
178 @var{args}. In order to be able to give more than one argument to a
179 script, several TCC options can be given @emph{after} the
180 @option{-run} option, separated by spaces. Example:
183 tcc "-run -L/usr/X11R6/lib -lX11" ex4.c
186 In a script, it gives the following header:
189 #!/usr/local/bin/tcc -run -L/usr/X11R6/lib -lX11
191 int main(int argc, char **argv)
199 Preprocessor options:
203 Specify an additional include path. Include paths are searched in the
204 order they are specified.
206 System include paths are always searched after. The default system
207 include paths are: @file{/usr/local/include}, @file{/usr/include}
208 and @file{PREFIX/lib/tcc/include}. (@file{PREFIX} is usually
209 @file{/usr} or @file{/usr/local}).
212 Define preprocessor symbol @samp{sym} to
213 val. If val is not present, its value is @samp{1}. Function-like macros can
214 also be defined: @option{-DF(a)=a+1}
217 Undefine preprocessor symbol @samp{sym}.
222 Note: each of the following warning options has a negative form beginning with
226 @item -funsigned-char
227 Let the @code{char} type be unsigned.
230 Let the @code{char} type be signed.
233 Do not generate common symbols for uninitialized data.
235 @item -fleading-underscore
236 Add a leading underscore at the beginning of each C symbol.
244 Disable all warnings.
248 Note: each of the following warning options has a negative form beginning with
252 @item -Wimplicit-function-declaration
253 Warn about implicit function declaration.
256 Warn about unsupported GCC features that are ignored by TCC.
258 @item -Wwrite-strings
259 Make string constants be of type @code{const char *} instead of @code{char
263 Abort compilation if warnings are issued.
266 Activate all warnings, except @option{-Werror}, @option{-Wunusupported} and
267 @option{-Wwrite-strings}.
275 Specify an additional static library path for the @option{-l} option. The
276 default library paths are @file{/usr/local/lib}, @file{/usr/lib} and @file{/lib}.
279 Link your program with dynamic library libxxx.so or static library
280 libxxx.a. The library is searched in the paths specified by the
284 Generate a shared library instead of an executable (@option{-o} option
288 Generate a statically linked executable (default is a shared linked
289 executable) (@option{-o} option must also be given).
292 Export global symbols to the dynamic linker. It is useful when a library
293 opened with @code{dlopen()} needs to access executable symbols.
296 Generate an object file combining all input files (@option{-o} option must
299 @item -Wl,-Ttext,address
300 Set the start of the .text section to @var{address}.
302 @item -Wl,--oformat,fmt
303 Use @var{fmt} as output format. The supported output formats are:
306 ELF output format (default)
308 Binary image (only for executable output)
310 COFF output format (only for executable output for TMS320C67xx target)
319 Generate run time debug information so that you get clear run time
320 error messages: @code{ test.c:68: in function 'test5()': dereferencing
321 invalid pointer} instead of the laconic @code{Segmentation
325 Generate additional support code to check
326 memory allocations and array/pointer bounds. @option{-g} is implied. Note
327 that the generated code is slower and bigger in this case.
330 Display N callers in stack traces. This is useful with @option{-g} or
335 Note: GCC options @option{-Ox}, @option{-fx} and @option{-mx} are
342 @settitle Tiny C Compiler
355 @chapter C language support
359 TCC implements all the ANSI C standard, including structure bit fields
360 and floating point numbers (@code{long double}, @code{double}, and
361 @code{float} fully supported).
363 @section ISOC99 extensions
365 TCC implements many features of the new C standard: ISO C99. Currently
366 missing items are: complex and imaginary numbers and variable length
369 Currently implemented ISOC99 features:
373 @item 64 bit @code{long long} types are fully supported.
375 @item The boolean type @code{_Bool} is supported.
377 @item @code{__func__} is a string variable containing the current
380 @item Variadic macros: @code{__VA_ARGS__} can be used for
381 function-like macros:
383 #define dprintf(level, __VA_ARGS__) printf(__VA_ARGS__)
387 @code{dprintf} can then be used with a variable number of parameters.
389 @item Declarations can appear anywhere in a block (as in C++).
391 @item Array and struct/union elements can be initialized in any order by
394 struct @{ int x, y; @} st[10] = @{ [0].x = 1, [0].y = 2 @};
396 int tab[10] = @{ 1, 2, [5] = 5, [9] = 9@};
399 @item Compound initializers are supported:
401 int *p = (int [])@{ 1, 2, 3 @};
403 to initialize a pointer pointing to an initialized array. The same
404 works for structures and strings.
406 @item Hexadecimal floating point constants are supported:
408 double d = 0x1234p10;
412 is the same as writing
414 double d = 4771840.0;
417 @item @code{inline} keyword is ignored.
419 @item @code{restrict} keyword is ignored.
422 @section GNU C extensions
424 TCC implements some GNU C extensions:
428 @item array designators can be used without '=':
430 int a[10] = @{ [0] 1, [5] 2, 3, 4 @};
433 @item Structure field designators can be a label:
435 struct @{ int x, y; @} st = @{ x: 1, y: 1@};
439 struct @{ int x, y; @} st = @{ .x = 1, .y = 1@};
442 @item @code{\e} is ASCII character 27.
444 @item case ranges : ranges can be used in @code{case}s:
448 printf("range 1 to 9\n");
451 printf("unexpected\n");
456 @cindex aligned attribute
457 @cindex packed attribute
458 @cindex section attribute
459 @cindex unused attribute
460 @cindex cdecl attribute
461 @cindex stdcall attribute
462 @cindex regparm attribute
463 @cindex dllexport attribute
465 @item The keyword @code{__attribute__} is handled to specify variable or
466 function attributes. The following attributes are supported:
469 @item @code{aligned(n)}: align a variable or a structure field to n bytes
470 (must be a power of two).
472 @item @code{packed}: force alignment of a variable or a structure field to
475 @item @code{section(name)}: generate function or data in assembly section
476 name (name is a string containing the section name) instead of the default
479 @item @code{unused}: specify that the variable or the function is unused.
481 @item @code{cdecl}: use standard C calling convention (default).
483 @item @code{stdcall}: use Pascal-like calling convention.
485 @item @code{regparm(n)}: use fast i386 calling convention. @var{n} must be
486 between 1 and 3. The first @var{n} function parameters are respectively put in
487 registers @code{%eax}, @code{%edx} and @code{%ecx}.
489 @item @code{dllexport}: export function from dll/executable (win32 only)
493 Here are some examples:
495 int a __attribute__ ((aligned(8), section(".mysection")));
499 align variable @code{a} to 8 bytes and put it in section @code{.mysection}.
502 int my_add(int a, int b) __attribute__ ((section(".mycodesection")))
509 generate function @code{my_add} in section @code{.mycodesection}.
511 @item GNU style variadic macros:
513 #define dprintf(fmt, args@dots{}) printf(fmt, ## args)
516 dprintf("one arg %d\n", 1);
519 @item @code{__FUNCTION__} is interpreted as C99 @code{__func__}
520 (so it has not exactly the same semantics as string literal GNUC
521 where it is a string literal).
523 @item The @code{__alignof__} keyword can be used as @code{sizeof}
524 to get the alignment of a type or an expression.
526 @item The @code{typeof(x)} returns the type of @code{x}.
527 @code{x} is an expression or a type.
529 @item Computed gotos: @code{&&label} returns a pointer of type
530 @code{void *} on the goto label @code{label}. @code{goto *expr} can be
531 used to jump on the pointer resulting from @code{expr}.
533 @item Inline assembly with asm instruction:
534 @cindex inline assembly
535 @cindex assembly, inline
538 static inline void * my_memcpy(void * to, const void * from, size_t n)
541 __asm__ __volatile__(
546 "1:\ttestb $1,%b4\n\t"
550 : "=&c" (d0), "=&D" (d1), "=&S" (d2)
551 :"0" (n/4), "q" (n),"1" ((long) to),"2" ((long) from)
559 TCC includes its own x86 inline assembler with a @code{gas}-like (GNU
560 assembler) syntax. No intermediate files are generated. GCC 3.x named
561 operands are supported.
563 @item @code{__builtin_types_compatible_p()} and @code{__builtin_constant_p()}
566 @item @code{#pragma pack} is supported for win32 compatibility.
570 @section TinyCC extensions
574 @item @code{__TINYC__} is a predefined macro to @code{1} to
575 indicate that you use TCC.
577 @item @code{#!} at the start of a line is ignored to allow scripting.
579 @item Binary digits can be entered (@code{0b101} instead of
582 @item @code{__BOUNDS_CHECKING_ON} is defined if bound checking is activated.
587 @chapter TinyCC Assembler
589 Since version 0.9.16, TinyCC integrates its own assembler. TinyCC
590 assembler supports a gas-like syntax (GNU assembler). You can
591 desactivate assembler support if you want a smaller TinyCC executable
592 (the C compiler does not rely on the assembler).
594 TinyCC Assembler is used to handle files with @file{.S} (C
595 preprocessed assembler) and @file{.s} extensions. It is also used to
596 handle the GNU inline assembler with the @code{asm} keyword.
600 TinyCC Assembler supports most of the gas syntax. The tokens are the
605 @item C and C++ comments are supported.
607 @item Identifiers are the same as C, so you cannot use '.' or '$'.
609 @item Only 32 bit integer numbers are supported.
617 @item Integers in decimal, octal and hexa are supported.
619 @item Unary operators: +, -, ~.
621 @item Binary operators in decreasing priority order:
629 @item A value is either an absolute number or a label plus an offset.
630 All operators accept absolute values except '+' and '-'. '+' or '-' can be
631 used to add an offset to a label. '-' supports two labels only if they
632 are the same or if they are both defined and in the same section.
640 @item All labels are considered as local, except undefined ones.
642 @item Numeric labels can be used as local @code{gas}-like labels.
643 They can be defined several times in the same source. Use 'b'
644 (backward) or 'f' (forward) as suffix to reference them:
648 jmp 1b /* jump to '1' label before */
649 jmp 1f /* jump to '1' label after */
656 @cindex assembler directives
657 @cindex directives, assembler
658 @cindex align directive
659 @cindex skip directive
660 @cindex space directive
661 @cindex byte directive
662 @cindex word directive
663 @cindex short directive
664 @cindex int directive
665 @cindex long directive
666 @cindex quad directive
667 @cindex globl directive
668 @cindex global directive
669 @cindex section directive
670 @cindex text directive
671 @cindex data directive
672 @cindex bss directive
673 @cindex fill directive
674 @cindex org directive
675 @cindex previous directive
676 @cindex string directive
677 @cindex asciz directive
678 @cindex ascii directive
680 All directives are preceeded by a '.'. The following directives are
684 @item .align n[,value]
685 @item .skip n[,value]
686 @item .space n[,value]
687 @item .byte value1[,...]
688 @item .word value1[,...]
689 @item .short value1[,...]
690 @item .int value1[,...]
691 @item .long value1[,...]
692 @item .quad immediate_value1[,...]
695 @item .section section
699 @item .fill repeat[,size[,value]]
702 @item .string string[,...]
703 @item .asciz string[,...]
704 @item .ascii string[,...]
707 @section X86 Assembler
710 All X86 opcodes are supported. Only ATT syntax is supported (source
711 then destination operand order). If no size suffix is given, TinyCC
712 tries to guess it from the operand sizes.
714 Currently, MMX opcodes are supported but not SSE ones.
717 @chapter TinyCC Linker
720 @section ELF file generation
723 TCC can directly output relocatable ELF files (object files),
724 executable ELF files and dynamic ELF libraries without relying on an
727 Dynamic ELF libraries can be output but the C compiler does not generate
728 position independent code (PIC). It means that the dynamic library
729 code generated by TCC cannot be factorized among processes yet.
731 TCC linker eliminates unreferenced object code in libraries. A single pass is
732 done on the object and library list, so the order in which object files and
733 libraries are specified is important (same constraint as GNU ld). No grouping
734 options (@option{--start-group} and @option{--end-group}) are supported.
736 @section ELF file loader
738 TCC can load ELF object files, archives (.a files) and dynamic
741 @section PE-i386 file generation
744 TCC for Windows supports the native Win32 executable file format (PE-i386). It
745 generates EXE files (console and gui) and DLL files.
747 For usage on Windows, see also tcc-win32.txt.
749 @section GNU Linker Scripts
750 @cindex scripts, linker
751 @cindex linker scripts
752 @cindex GROUP, linker command
753 @cindex FILE, linker command
754 @cindex OUTPUT_FORMAT, linker command
755 @cindex TARGET, linker command
757 Because on many Linux systems some dynamic libraries (such as
758 @file{/usr/lib/libc.so}) are in fact GNU ld link scripts (horrible!),
759 the TCC linker also supports a subset of GNU ld scripts.
761 The @code{GROUP} and @code{FILE} commands are supported. @code{OUTPUT_FORMAT}
762 and @code{TARGET} are ignored.
764 Example from @file{/usr/lib/libc.so}:
767 Use the shared library, but some functions are only in
768 the static library, so try that secondarily. */
769 GROUP ( /lib/libc.so.6 /usr/lib/libc_nonshared.a )
773 @chapter TinyCC Memory and Bound checks
775 @cindex memory checks
777 This feature is activated with the @option{-b} (@pxref{Invoke}).
779 Note that pointer size is @emph{unchanged} and that code generated
780 with bound checks is @emph{fully compatible} with unchecked
781 code. When a pointer comes from unchecked code, it is assumed to be
782 valid. Even very obscure C code with casts should work correctly.
784 For more information about the ideas behind this method, see
785 @url{http://www.doc.ic.ac.uk/~phjk/BoundsChecking.html}.
787 Here are some examples of caught errors:
791 @item Invalid range with standard string function:
799 @item Out of bounds-error in global or local arrays:
809 @item Out of bounds-error in malloc'ed data:
813 tab = malloc(20 * sizeof(int));
821 @item Access of freed memory:
825 tab = malloc(20 * sizeof(int));
837 tab = malloc(20 * sizeof(int));
846 @chapter The @code{libtcc} library
848 The @code{libtcc} library enables you to use TCC as a backend for
849 dynamic code generation.
851 Read the @file{libtcc.h} to have an overview of the API. Read
852 @file{libtcc_test.c} to have a very simple example.
854 The idea consists in giving a C string containing the program you want
855 to compile directly to @code{libtcc}. Then you can access to any global
856 symbol (function or variable) defined.
859 @chapter Developer's guide
861 This chapter gives some hints to understand how TCC works. You can skip
862 it if you do not intend to modify the TCC code.
864 @section File reading
866 The @code{BufferedFile} structure contains the context needed to read a
867 file, including the current line number. @code{tcc_open()} opens a new
868 file and @code{tcc_close()} closes it. @code{inp()} returns the next
873 @code{next()} reads the next token in the current
874 file. @code{next_nomacro()} reads the next token without macro
877 @code{tok} contains the current token (see @code{TOK_xxx})
878 constants. Identifiers and keywords are also keywords. @code{tokc}
879 contains additional infos about the token (for example a constant value
880 if number or string token).
884 The parser is hardcoded (yacc is not necessary). It does only one pass,
889 @item For initialized arrays with unknown size, a first pass
890 is done to count the number of elements.
892 @item For architectures where arguments are evaluated in
893 reverse order, a first pass is done to reverse the argument order.
899 The types are stored in a single 'int' variable. It was choosen in the
900 first stages of development when tcc was much simpler. Now, it may not
901 be the best solution.
904 #define VT_INT 0 /* integer type */
905 #define VT_BYTE 1 /* signed byte type */
906 #define VT_SHORT 2 /* short type */
907 #define VT_VOID 3 /* void type */
908 #define VT_PTR 4 /* pointer */
909 #define VT_ENUM 5 /* enum definition */
910 #define VT_FUNC 6 /* function type */
911 #define VT_STRUCT 7 /* struct/union definition */
912 #define VT_FLOAT 8 /* IEEE float */
913 #define VT_DOUBLE 9 /* IEEE double */
914 #define VT_LDOUBLE 10 /* IEEE long double */
915 #define VT_BOOL 11 /* ISOC99 boolean type */
916 #define VT_LLONG 12 /* 64 bit integer */
917 #define VT_LONG 13 /* long integer (NEVER USED as type, only
919 #define VT_BTYPE 0x000f /* mask for basic type */
920 #define VT_UNSIGNED 0x0010 /* unsigned type */
921 #define VT_ARRAY 0x0020 /* array type (also has VT_PTR) */
922 #define VT_BITFIELD 0x0040 /* bitfield modifier */
924 #define VT_STRUCT_SHIFT 16 /* structure/enum name shift (16 bits left) */
927 When a reference to another type is needed (for pointers, functions and
928 structures), the @code{32 - VT_STRUCT_SHIFT} high order bits are used to
929 store an identifier reference.
931 The @code{VT_UNSIGNED} flag can be set for chars, shorts, ints and long
934 Arrays are considered as pointers @code{VT_PTR} with the flag
937 The @code{VT_BITFIELD} flag can be set for chars, shorts, ints and long
938 longs. If it is set, then the bitfield position is stored from bits
939 VT_STRUCT_SHIFT to VT_STRUCT_SHIFT + 5 and the bit field size is stored
940 from bits VT_STRUCT_SHIFT + 6 to VT_STRUCT_SHIFT + 11.
942 @code{VT_LONG} is never used except during parsing.
944 During parsing, the storage of an object is also stored in the type
948 #define VT_EXTERN 0x00000080 /* extern definition */
949 #define VT_STATIC 0x00000100 /* static variable */
950 #define VT_TYPEDEF 0x00000200 /* typedef definition */
955 All symbols are stored in hashed symbol stacks. Each symbol stack
956 contains @code{Sym} structures.
958 @code{Sym.v} contains the symbol name (remember
959 an idenfier is also a token, so a string is never necessary to store
960 it). @code{Sym.t} gives the type of the symbol. @code{Sym.r} is usually
961 the register in which the corresponding variable is stored. @code{Sym.c} is
962 usually a constant associated to the symbol.
964 Four main symbol stacks are defined:
969 for the macros (@code{#define}s).
972 for the global variables, functions and types.
975 for the local variables, functions and types.
977 @item global_label_stack
978 for the local labels (for @code{goto}).
981 for GCC block local labels (see the @code{__label__} keyword).
985 @code{sym_push()} is used to add a new symbol in the local symbol
986 stack. If no local symbol stack is active, it is added in the global
989 @code{sym_pop(st,b)} pops symbols from the symbol stack @var{st} until
990 the symbol @var{b} is on the top of stack. If @var{b} is NULL, the stack
993 @code{sym_find(v)} return the symbol associated to the identifier
994 @var{v}. The local stack is searched first from top to bottom, then the
999 The generated code and datas are written in sections. The structure
1000 @code{Section} contains all the necessary information for a given
1001 section. @code{new_section()} creates a new section. ELF file semantics
1002 is assumed for each section.
1004 The following sections are predefined:
1009 is the section containing the generated code. @var{ind} contains the
1010 current position in the code section.
1013 contains initialized data
1016 contains uninitialized data
1018 @item bounds_section
1019 @itemx lbounds_section
1020 are used when bound checking is activated
1023 @itemx stabstr_section
1024 are used when debugging is actived to store debug information
1026 @item symtab_section
1027 @itemx strtab_section
1028 contain the exported symbols (currently only used for debugging).
1032 @section Code generation
1033 @cindex code generation
1035 @subsection Introduction
1037 The TCC code generator directly generates linked binary code in one
1038 pass. It is rather unusual these days (see gcc for example which
1039 generates text assembly), but it can be very fast and surprisingly
1042 The TCC code generator is register based. Optimization is only done at
1043 the expression level. No intermediate representation of expression is
1044 kept except the current values stored in the @emph{value stack}.
1046 On x86, three temporary registers are used. When more registers are
1047 needed, one register is spilled into a new temporary variable on the stack.
1049 @subsection The value stack
1050 @cindex value stack, introduction
1052 When an expression is parsed, its value is pushed on the value stack
1053 (@var{vstack}). The top of the value stack is @var{vtop}. Each value
1054 stack entry is the structure @code{SValue}.
1056 @code{SValue.t} is the type. @code{SValue.r} indicates how the value is
1057 currently stored in the generated code. It is usually a CPU register
1058 index (@code{REG_xxx} constants), but additional values and flags are
1062 #define VT_CONST 0x00f0
1063 #define VT_LLOCAL 0x00f1
1064 #define VT_LOCAL 0x00f2
1065 #define VT_CMP 0x00f3
1066 #define VT_JMP 0x00f4
1067 #define VT_JMPI 0x00f5
1068 #define VT_LVAL 0x0100
1069 #define VT_SYM 0x0200
1070 #define VT_MUSTCAST 0x0400
1071 #define VT_MUSTBOUND 0x0800
1072 #define VT_BOUNDED 0x8000
1073 #define VT_LVAL_BYTE 0x1000
1074 #define VT_LVAL_SHORT 0x2000
1075 #define VT_LVAL_UNSIGNED 0x4000
1076 #define VT_LVAL_TYPE (VT_LVAL_BYTE | VT_LVAL_SHORT | VT_LVAL_UNSIGNED)
1082 indicates that the value is a constant. It is stored in the union
1083 @code{SValue.c}, depending on its type.
1086 indicates a local variable pointer at offset @code{SValue.c.i} in the
1090 indicates that the value is actually stored in the CPU flags (i.e. the
1091 value is the consequence of a test). The value is either 0 or 1. The
1092 actual CPU flags used is indicated in @code{SValue.c.i}.
1094 If any code is generated which destroys the CPU flags, this value MUST be
1095 put in a normal register.
1099 indicates that the value is the consequence of a conditional jump. For VT_JMP,
1100 it is 1 if the jump is taken, 0 otherwise. For VT_JMPI it is inverted.
1102 These values are used to compile the @code{||} and @code{&&} logical
1105 If any code is generated, this value MUST be put in a normal
1106 register. Otherwise, the generated code won't be executed if the jump is
1110 is a flag indicating that the value is actually an lvalue (left value of
1111 an assignment). It means that the value stored is actually a pointer to
1114 Understanding the use @code{VT_LVAL} is very important if you want to
1115 understand how TCC works.
1118 @itemx VT_LVAL_SHORT
1119 @itemx VT_LVAL_UNSIGNED
1120 if the lvalue has an integer type, then these flags give its real
1121 type. The type alone is not enough in case of cast optimisations.
1124 is a saved lvalue on the stack. @code{VT_LLOCAL} should be eliminated
1125 ASAP because its semantics are rather complicated.
1128 indicates that a cast to the value type must be performed if the value
1129 is used (lazy casting).
1132 indicates that the symbol @code{SValue.sym} must be added to the constant.
1136 are only used for optional bound checking.
1140 @subsection Manipulating the value stack
1143 @code{vsetc()} and @code{vset()} pushes a new value on the value
1144 stack. If the previous @var{vtop} was stored in a very unsafe place(for
1145 example in the CPU flags), then some code is generated to put the
1146 previous @var{vtop} in a safe storage.
1148 @code{vpop()} pops @var{vtop}. In some cases, it also generates cleanup
1149 code (for example if stacked floating point registers are used as on
1152 The @code{gv(rc)} function generates code to evaluate @var{vtop} (the
1153 top value of the stack) into registers. @var{rc} selects in which
1154 register class the value should be put. @code{gv()} is the @emph{most
1155 important function} of the code generator.
1157 @code{gv2()} is the same as @code{gv()} but for the top two stack
1160 @subsection CPU dependent code generation
1161 @cindex CPU dependent
1162 See the @file{i386-gen.c} file to have an example.
1167 must generate the code needed to load a stack value into a register.
1170 must generate the code needed to store a register into a stack value
1174 @itemx gfunc_param()
1176 should generate a function call
1178 @item gfunc_prolog()
1179 @itemx gfunc_epilog()
1180 should generate a function prolog/epilog.
1183 must generate the binary integer operation @var{op} on the two top
1184 entries of the stack which are guaranted to contain integer types.
1186 The result value should be put on the stack.
1189 same as @code{gen_opi()} for floating point operations. The two top
1190 entries of the stack are guaranted to contain floating point values of
1193 @item gen_cvt_itof()
1194 integer to floating point conversion.
1196 @item gen_cvt_ftoi()
1197 floating point to integer conversion.
1199 @item gen_cvt_ftof()
1200 floating point to floating point of different size conversion.
1202 @item gen_bounded_ptr_add()
1203 @item gen_bounded_ptr_deref()
1204 are only used for bounds checking.
1208 @section Optimizations done
1209 @cindex optimizations
1210 @cindex constant propagation
1211 @cindex strength reduction
1212 @cindex comparison operators
1213 @cindex caching processor flags
1214 @cindex flags, caching
1215 @cindex jump optimization
1216 Constant propagation is done for all operations. Multiplications and
1217 divisions are optimized to shifts when appropriate. Comparison
1218 operators are optimized by maintaining a special cache for the
1219 processor flags. &&, || and ! are optimized by maintaining a special
1220 'jump target' value. No other jump optimization is currently performed
1221 because it would require to store the code in a more abstract fashion.
1223 @unnumbered Concept Index
1230 @c texinfo-column-for-description: 32