Class: Kumi::IR::Loop::Passes::CopyCleanup

Inherits:
Passes::Base show all
Defined in:
lib/kumi/ir/loop/passes/copy_cleanup.rb

Overview

Two classic, syntax-preserving cleanups on the final LoopIR, so both the Ruby and JS emitters get shorter output from one place:

1. Copy propagation. `ref` and `acc_load` emit a bare `x = y` copy
   (see the emitters). Since every LoopIR result is assigned once,
   rewriting every use of `x` to `y` and dropping the copy is always
   safe — it is pure renaming. This collapses chains like
   `t15 = t22; t10 = t15 - t23`  =>  `t10 = t22 - t23`, and lets a
   function `return` its accumulator directly instead of via a temp.

2. Dead-code elimination. After propagation, an instruction whose
   result is read nowhere and which has no side effect (a pure
   compute: constant/load/kernel_call/select/make_object/index_read/
   array_len/ref/acc_load) is removed. Loop control, pushes, and
   accumulator steps are kept — they act through effects, not a read.

Neither transform changes evaluation order or which registers are live across loop boundaries, so the scope-aware Loop::Validator still holds.

Constant Summary collapse

PURE_OPS =

Opcodes that are pure: their only observable effect is the value they produce, so an unused result means the whole instruction is dead.

%i[
  constant load_input load_field kernel_call select make_object
  ref acc_load array_len index_read shift_read shift_in_bounds
].freeze
COPY_OPS =

Opcodes that are a bare copy of their single input.

%i[ref acc_load].freeze

Instance Method Summary collapse

Instance Method Details

#run(graph:, context: {}) ⇒ Object

rubocop:disable Lint/UnusedMethodArgument



36
37
38
39
 
# File 'lib/kumi/ir/loop/passes/copy_cleanup.rb', line 36

def run(graph:, context: {}) # rubocop:disable Lint/UnusedMethodArgument
  functions = graph.functions.values.map { |fn| process_function(fn) }
  Loop::Module.new(name: graph.name, functions: functions)
end