simplified

Pass Manager

Turn individual optimizations on and off and watch what each one does — including the two that refuse to fire, because firing would change what the program means.

simplifiedReal passes on real SSA

Every pass below is implemented in src/compilers/sim/optimize.ts and runs on the SSA form of the program you type. The pass manager iterates to a fixed point, because passes expose work for each other.

AtlasLang source

Examples

✓ No diagnostics. The program lexes, parses and type-checks.

Passes

Constant foldingfired ×1The operands are literals and the operation cannot trap. Evaluating it at compile time then produces exactly the value the program would have computed.Illegal when: The operation can fault on these operands — `1 / 0` — or the result depends on a runtime property the compiler cannot see, such as a floating-point rounding mode set at startup.Constant Folding →Strength reduction and algebraic identitiesfired ×1The rewritten form produces the identical value for every input the operand types admit. `x + 0` is `x` for every integer; `x * 2` becoming a shift is valid only where the target defines the shift to agree with multiplication on the full range.Illegal when: The identity does not hold across the whole domain. `x + 0.0` is NOT `x` in IEEE-754 floating point, because it turns negative zero into positive zero; `x / x` is not 1 when x is zero. AtlasLang has no floats, which is the only reason the additive identity is unconditional here.Strength Reduction and Algebraic Identities →Constant propagationfired ×1The value has exactly one definition and that definition is a literal. In SSA this is guaranteed by construction, which is most of why SSA exists.Illegal when: The variable is reassigned on another path and the two definitions reach the same use. Outside SSA that requires a reaching-definitions analysis to rule out; a phi node makes it explicit instead.Constant Propagation →Copy propagationno effect hereThe definition is a pure copy of another value that is still live and unmodified at every use. In SSA the source cannot have been modified, because nothing is ever modified.Illegal when: The source is reassigned between the copy and the use — the classic non-SSA hazard, and the reason this pass is dangerous to write by hand on three-address code.Copy Propagation →Branch simplificationfired ×1The branch condition folded to a literal. The untaken edge can then never be executed, so replacing the conditional branch with an unconditional jump removes no reachable behavior.Illegal when: The condition merely *usually* has that value. A profile is evidence, not a proof — using it requires a guard and a deoptimization path, which is what a JIT does and a static compiler must not.Phase Ordering →Unreachable block eliminationfired ×1No path from the entry block reaches the block. Nothing it contains can ever execute, so nothing it contains is observable.Illegal when: The block is reachable through an edge the analysis did not model — an exception edge, a computed jump, or a label whose address escaped. AtlasLang has none of those, which is the only reason this pass is this simple.Dead Code Elimination →Common subexpression eliminationno effect hereTwo instructions compute the same pure operation on the same operands, and the first dominates the second. Dominance is what guarantees the earlier value is available on every path that reaches the later one.Illegal when: The operation reads memory that may have been written between the two, or either operand may have changed. Establishing that requires alias analysis, which is why CSE over memory is far harder than CSE over registers.Common Subexpression Elimination →Dead code eliminationfired ×1The instruction has no side effect and its result is used by nothing. Deleting it therefore changes nothing observable.Illegal when: The instruction has an effect the compiler cannot see in its operands — it prints, calls, writes memory, or can trap. Removing an effectful instruction because its *value* is unused is a miscompilation, not an optimization.Dead Code Elimination →

✓ observable behavior unchanged

Unoptimized output ["6"] · optimized ["6"]. This is the property that makes an optimization an optimization, and it is asserted for every example in scripts/compilers-sim.test.ts.

7 → 3 instructions · 6 pass runs over 2 iterations

Before — SSA as constructed

fn main(): void {
b0: ; entry
  %0 = int 2 * 3
  %2 = int %0 + 0
  branch false ? b1 : b2
b1: ; if.then preds=b0
  print 999
  jump b2
b2: ; if.join preds=b0,b1
  print %2
  ret
}

After — the enabled passes, run to a fixed point

fn main(): void {
b0: ; entry
  jump b2
b2: ; if.join preds=b0
  print 6
  ret
}

Show all 6 pass runs in order

1. constant-folding — 1 change

fn main(): void {
b0: ; entry
  %0 = const 6
  %2 = int %0 + 0
  branch false ? b1 : b2
b1: ; if.then preds=b0
  print 999
  jump b2
b2: ; if.join preds=b0,b1
  print %2
  ret
}

2. strength-reduction — 1 change

fn main(): void {
b0: ; entry
  %0 = const 6
  branch false ? b1 : b2
b1: ; if.then preds=b0
  print 999
  jump b2
b2: ; if.join preds=b0,b1
  print %0
  ret
}

3. constant-propagation — 1 change

fn main(): void {
b0: ; entry
  %0 = const 6
  branch false ? b1 : b2
b1: ; if.then preds=b0
  print 999
  jump b2
b2: ; if.join preds=b0,b1
  print 6
  ret
}

4. branch-simplification — 1 change

fn main(): void {
b0: ; entry
  %0 = const 6
  jump b2
b1: ; if.then
  print 999
  jump b2
b2: ; if.join preds=b0,b1
  print 6
  ret
}

5. unreachable-block-elimination — 1 change

fn main(): void {
b0: ; entry
  %0 = const 6
  jump b2
b2: ; if.join preds=b0
  print 6
  ret
}

6. dead-code-elimination — 1 change

fn main(): void {
b0: ; entry
  jump b2
b2: ; if.join preds=b0
  print 6
  ret
}