chibicc C Compiler

chibicc prioritizes simplicity and readability over performance and memory efficiency. Key design choices include:

• Simplicity over Abstraction: Uses straightforward, sometimes duplicative code (like in the recursive descent parser) to remain readable for first-time readers.
• Memory Management: Uses calloc for all heap allocations to ensure memory is zeroed. Notably, it never calls free; memory is only released when the process exits. This is a deliberate choice for short-lived programs like compilers.
• Data Structures: Uses simple structures like linked lists for sets and a single large Node struct for all AST nodes to avoid the complexity of unions and premature optimization.

chibicc is a multi-pass compiler that operates through the following stages:

1. Tokenize: Converts an input string into a list of tokens.
2. Preprocess: Takes tokens and produces a new list of macro-expanded tokens by interpreting preprocessor directives.
3. Parse: A recursive descent parser that constructs Abstract Syntax Trees (AST) from the preprocessed tokens and assigns types to each AST node.
4. Codegen: A code generator that emits assembly text from the AST nodes.

The project follows an unusual contribution model to maintain the integrity of the book's incremental learning path:

• No Pull Requests: The maintainer does not accept direct pull requests. Instead, bugs are fixed by rewriting the commit history to incorporate the fix at the original point of introduction.
• History Rewriting: The maintainer may occasionally force-push to the repository to rewrite history. If you have local commits based on the repository, you will need to rebase them manually after a force-push.

Chibicc acts as a driver that orchestrates several stages of the C compilation process by invoking subprocesses (like as for assembly or ld for linking) or running its internal cc1 logic.

The Pipeline Stages

1. Preprocessing: Handles macros (-D, -U), includes (-I, -include), and header expansion. If -E is specified, the process stops here.
2. Compilation (cc1): Converts C code into assembly. If -S is specified, the process stops here.
3. Assembly (as): Converts assembly code into object files (.o). If -c is specified, the process stops here.
4. Linking (ld): Combines object files, libraries (-l), and startup files (like crt1.o) into a final executable or shared library. This is the default behavior if no other flags are provided.

Chibicc supports dependency generation similar to GCC, which is useful for automating builds with make.

• -M: Writes a list of input files to stdout in a format make can read.
• -MD: Writes dependencies to a file named <output_file>.d (or <output_file> if -o is used).
• -MMD: Similar to -MD, but skips dependencies found in standard system include paths.
• -MP: Adds extra rules to the dependency file to prevent issues if a header file is deleted.
• -MF <file>: Specifies a custom filename for the dependency output.
• -MT <target>: Specifies the target name used in the dependency file.
• -MQ <file>: Used with -MT to generate dependency rules for a specific target.

chibicc supports almost all mandatory and most optional features of C11, along with some GCC extensions.

Supported features include:

• Preprocessor
• Floating point types: float, double, and long double (x87 80-bit)
• Bit-fields
• alloca()
• Variable-length arrays
• Compound literals
• Thread-local variables
• Atomic variables
• Common symbols
• Designated initializers
• String literals: L, u, U, and u8
• Functions taking/returning structs (per x86-64 SystemV ABI)

Unsupported features:

• Complex numbers
• K&R-style function prototypes
• GCC-style inline assembly
• Digraphs and trigraphs