Translation Pipeline

Compilation costs time, CPU and memory, and most methods run only a handful of times. Counting invocations and loop iterations finds the small hot fraction where optimisation will be repaid, and the interpreted phase supplies the profile the compiler then optimises against.

An abstract syntax tree keeps operators, operands and structure, and drops what only guided the parser: grouping parentheses, separators and terminators, layout, and single-child chain nodes from precedence rules. The tree's shape already encodes the grouping those tokens expressed.

Three-address code gives every intermediate value a name and every operation its own instruction in a fixed order. Evaluation order and the producer of each value become explicit data rather than facts implied by a tree walk.

It takes the longest prefix starting at that position that any rule accepts, not the first rule that matches. If two rules accept the same longest prefix, the rule declared earlier wins.

Constant folding evaluates an operation whose operands are all literals and replaces the expression with the result. Constant propagation replaces a use of a variable with the literal every reaching definition assigns it. Each creates work for the other, so pipelines iterate them.

The expression must be invariant — every operand defined outside the loop and unchanged by it — and moving it must not change behaviour. That means it is effect-free and safe to evaluate even when the loop body would have run zero times, or the hoist is guarded.

Name resolution keeps one symbol table per open scope, each linked to the table of the scope around it. An identifier binds to the first matching entry found walking that chain outward, so an inner declaration hides an outer one of the same name.

Early requests execute interpreted or lightly optimised code while counters climb, and compilation itself takes CPU away from request handling. Peak arrives only after the hot paths have been compiled, so an early measurement times warmup rather than the system that was shipped.

Because parsing only proves the text has a legal shape. The pass after it checks meaning against a symbol table — that every name resolves, that it is used as the kind of thing it was declared, and that operand types agree — and those depend on declarations arbitrarily far away.

Desugaring rewrites convenient surface forms into a small core the compiler already handles, so every later pass sees one shape instead of many. The cost is that diagnostics and debug output now describe code the programmer did not write.

Because every keyword also matches the identifier pattern. Matching the identifier once and looking the text up in a table keeps the recogniser small, makes the keyword set a data edit, and leaves room for words that are keywords only in some positions.

Because the two jobs need different machine power and different rules. Token shapes are regular, so a finite-state pass handles them in one linear sweep, which keeps whitespace, comments and longest-match logic out of every grammar rule.

Two things, both required: nothing later reads the result, and the computation has no observable effect. Liveness analysis settles the first; effect reasoning settles the second. A statement with an effect stays even when its result is unused.

So that forward references resolve. Collecting every declaration of a scope into its symbol table first means a reference can name something declared later in the same scope — mutually recursive definitions being the case a single left-to-right walk cannot handle at all.

The specialised code carries a guard that tests the assumption on every execution. When the guard fails, the runtime deoptimises: it reconstructs interpreter state for the running frame, resumes there, and later recompiles the method against the widened profile.

A phi node defines a new version of a value at a merge point, selecting among the versions that arrive on each incoming edge. It preserves the single-assignment rule where two branches would otherwise both assign the same name.

It lacks a counter. A finite-state pass has a fixed number of states, so it cannot track how many openings are still unclosed when the depth is unbounded. Scanners add a depth counter, and a stack of modes for constructs that nest.

It spills. The allocator picks a value by cost, rewrites it to live in the stack frame with a store after its definition and a load before each use, which breaks one long live range into several short ones, then rebuilds the graph and tries to colour again.

Let process lifetime and restart frequency decide. A two-second job never runs long enough for in-process profiling to repay itself, so compile ahead of time; a server that runs for days can afford warmup once to buy the peak that profile-driven speculation reaches.

Add a level only when a whole class of work is natural there and awkward at both neighbours — because each level costs another lowering step, printer, verifier and position mapping to keep correct forever. Start with two and split under pressure.

Order passes by what they enable: transforms that expose facts run before the passes that consume them, cheap cleanups run after every heavyweight transform, and lossy lowering runs last. Then cap the repetition with a compile-time budget, because searching for a per-program optimal order costs a full compile per candidate.

There are three defensible policies — permit silently, permit with a warning, or reject — and the choice trades authoring freedom against the reader's ability to predict what a name means. A common landing point is permit with a warning, and reject only where the collision is across kinds.

A tree-walking interpreter pays a node-kind test, an indirect call and several pointer loads for every node it visits, re-deciding the program's shape on each visit. A bytecode interpreter settles that shape once and then runs a flat instruction loop.

Because one machine instruction can implement several operations of the intermediate form at once. Selection covers the operation graph with patterns, each pattern standing for one instruction and carrying a cost, and looks for a cheap cover rather than a one-to-one translation.

Stack-based code leaves operands implicit on an operand stack: instructions are short and trivial to emit from a tree walk, but the stream is longer and data flow must be reconstructed. Register-based code names operands explicitly, costing wider instructions and a naming step.

Because the scanner carries state forward. One character can open a comment or a string, and every token after it is then classified under a different rule set, so the change propagates to the end of the buffer.

So that a name's meaning is fixed by where it is written, not by who is running. Recording the binding turns each access into a direct slot reference and makes shadowing and capture predictable; searching by name at run time makes the same text mean different things on different call paths.