⚙️ Compiler Pipeline

Three-address code (TAC) is an intermediate representation where each instruction has at most one operator and three operands (two sources and one destination): e.g. t1 = a * b; t2 = t1 + c. This simple, uniform structure makes dataflow analysis easy — each temporary is defined once, facilitating static single assignment (SSA) form. Most modern compilers (GCC, LLVM) use a form of TAC internally before lowering to assembly; LLVM's IR is a well-known, human-readable example.

Constant folding is an optimisation that evaluates constant sub-expressions at compile time rather than emitting code to compute them at runtime. For example, 2 * 3 + 1 becomes 7 with zero runtime cost. Modern compilers also propagate constants through variable assignments (constant propagation), enable further simplifications like dead-code elimination, and even evaluate pure function calls whose arguments are all constants. The combined effect can dramatically reduce instruction count in code with many literal calculations.

A compiler translates source code into a target representation ahead of time (AOT), producing an artefact — a binary, bytecode, or IR — that can run independently of the compiler. An interpreter reads source (or bytecode) and executes it directly, statement by statement, at runtime. Many modern systems combine both: Python compiles to bytecode (.pyc) which the CPython interpreter then executes, and JavaScript engines compile to machine code using just-in-time (JIT) compilation for frequently executed code paths.

A formal grammar is a set of production rules that define which strings of tokens are valid in a language. Context-free grammars (CFGs), described in Backus-Naur Form (BNF) or Extended BNF, are used for most programming languages. A parser checks that the input conforms to the grammar and builds the AST. The famous Chomsky hierarchy ranks grammars by expressive power; context-free grammars are powerful enough to describe nested structures like balanced parentheses, which regular expressions cannot.

Semantic analysis checks constraints that the grammar cannot express: type checking (is an integer being added to a string?), scope resolution (is this variable declared before use?), and use-before-initialisation detection. In statically typed languages, this phase constructs a symbol table mapping identifiers to their types and builds type annotations into the AST. Errors here produce the familiar "type mismatch" or "undeclared variable" messages that appear after successful parsing.

Modern compilers apply dozens of optimisation passes: dead code elimination removes instructions whose results are never used; loop unrolling reduces branch overhead; inlining substitutes function call sites with the function body to eliminate call overhead; common subexpression elimination (CSE) avoids recomputing identical expressions; and auto-vectorisation rewrites scalar loops to use SIMD (Single Instruction, Multiple Data) CPU instructions. LLVM's optimisation pipeline applies around 60 passes at -O2, and the speedups achieved routinely range from 2x to 10x over unoptimised code.

A JIT compiler compiles code at runtime, typically after it has been observed running frequently ("hot paths"). The V8 engine (used in Chrome and Node.js) starts by interpreting JavaScript bytecode, profiles which functions are called most, then compiles those to optimised native machine code. If a previously made assumption (such as a variable always holding an integer) is later violated, V8 "deoptimises" and falls back to interpreted execution. JIT-compiled JavaScript can run within 2-3x the speed of equivalent C code for many workloads.