rust_compiler/libs/optimizer/OPTIMIZATION_IDEAS.md

@@ -1,212 +0,0 @@
-# Additional Optimization Opportunities for Slang IL Optimizer
-
-## Currently Implemented ✓
-
-1. Constant Propagation - Folds math operations with known values
-2. Register Forwarding - Eliminates intermediate moves
-3. Function Call Optimization - Removes unnecessary push/pop around calls
-4. Leaf Function Optimization - Removes RA save/restore for non-calling functions
-5. Redundant Move Elimination - Removes `move rx rx`
-6. Dead Code Elimination - Removes unreachable code after jumps
-
-## Proposed Additional Optimizations
-
-### 1. **Algebraic Simplification** 🔥 HIGH IMPACT
-
-Simplify mathematical identities:
-
-- `x + 0` → `x` (move)
-- `x - 0` → `x` (move)
-- `x * 1` → `x` (move)
-- `x * 0` → `0` (move to constant)
-- `x / 1` → `x` (move)
-- `x - x` → `0` (move to constant)
-- `x % 1` → `0` (move to constant)
-
-**Example:**
-
-```
-add r1 r2 0     →    move r1 r2
-mul r3 r4 1     →    move r3 r4
-mul r5 r6 0     →    move r5 0
-```
-
-### 2. **Strength Reduction** 🔥 HIGH IMPACT
-
-Replace expensive operations with cheaper ones:
-
-- `x * 2` → `add x x x` (addition is cheaper than multiplication)
-- `x * power_of_2` → bit shifts (if IC10 supports)
-- `x / 2` → bit shifts (if IC10 supports)
-
-**Example:**
-
-```
-mul r1 r2 2     →    add r1 r2 r2
-```
-
-### 3. **Peephole Optimization - Instruction Sequences** 🔥 MEDIUM-HIGH IMPACT
-
-Recognize and optimize common instruction patterns:
-
-#### Pattern: Conditional Branch Simplification
-
-```
-seq r1 ra rb     →    beq ra rb label
-beqz r1 label         (remove the seq entirely)
-
-sne r1 ra rb     →    bne ra rb label
-beqz r1 label         (remove the sne entirely)
-```
-
-#### Pattern: Double Move Elimination
-
-```
-move r1 r2      →    move r1 r3
-move r1 r3          (remove first move if r1 not used between)
-```
-
-#### Pattern: Redundant Load Elimination
-
-If a register's value is already loaded and hasn't been clobbered:
-
-```
-l r1 d0 Temperature
-... (no writes to r1)
-l r1 d0 Temperature   →  (remove second load)
-```
-
-### 4. **Copy Propagation Enhancement** 🔥 MEDIUM IMPACT
-
-Current register forwarding is good, but we can extend it:
-
-- Track `move` chains: if `r1 = r2` and `r2 = 5`, propagate the `5` directly
-- Eliminate the intermediate register if possible
-
-### 5. **Dead Store Elimination** 🔥 MEDIUM IMPACT
-
-Remove writes to registers that are never read before being overwritten:
-
-```
-move r1 5
-move r1 10      →    move r1 10
-                     (first write is dead)
-```
-
-### 6. **Common Subexpression Elimination (CSE)** 🔥 MEDIUM-HIGH IMPACT
-
-Recognize when the same computation is done multiple times:
-
-```
-add r1 r8 r9
-add r2 r8 r9    →    add r1 r8 r9
-                     move r2 r1
-```
-
-This is especially valuable for expensive operations like:
-
-- Device loads (`l`)
-- Math functions (sqrt, sin, cos, etc.)
-
-### 7. **Jump Threading** 🔥 LOW-MEDIUM IMPACT
-
-Optimize jump-to-jump sequences:
-
-```
-j label1
-...
-label1:
-j label2        →    j label2 (rewrite first jump)
-```
-
-### 8. **Branch Folding** 🔥 LOW-MEDIUM IMPACT
-
-Merge consecutive branches to the same target:
-
-```
-bgt r1 r2 label
-bgt r3 r4 label  →   Could potentially be optimized based on conditions
-```
-
-### 9. **Loop Invariant Code Motion** 🔥 MEDIUM-HIGH IMPACT
-
-Move calculations out of loops if they don't change:
-
-```
-loop:
-  mul r2 5 10      →   mul r2 5 10      (hoisted before loop)
-  add r1 r1 r2         loop:
-  ...                    add r1 r1 r2
-  j loop                 ...
-                        j loop
-```
-
-### 10. **Select Instruction Optimization** 🔥 LOW-MEDIUM IMPACT
-
-The `select` instruction can sometimes replace branch patterns:
-
-```
-beq r1 r2 else
-move r3 r4
-j end
-else:
-move r3 r5        →   seq r6 r1 r2
-end:                   select r3 r6 r5 r4
-```
-
-### 11. **Stack Access Pattern Optimization** 🔥 LOW IMPACT
-
-If we see repeated `sub r0 sp N` + `get`, we might be able to optimize by:
-
-- Caching the stack address in a register if used multiple times
-- Combining sequential gets from adjacent stack slots
-
-### 12. **Inline Small Functions** 🔥 HIGH IMPACT (Complex to implement)
-
-For very small leaf functions (1-2 instructions), inline them at the call site:
-
-```
-calculateSum:
-  add r15 r8 r9
-  j ra
-
-main:
-  push 5           →   main:
-  push 10                add r15 5 10
-  jal calculateSum
-```
-
-### 13. **Branch Prediction Hints** 🔥 LOW IMPACT
-
-Reorganize code to put likely branches inline (fall-through) and unlikely branches as jumps.
-
-### 14. **Register Coalescing** 🔥 MEDIUM IMPACT
-
-Reduce register pressure by reusing registers that have non-overlapping lifetimes.
-
-## Priority Implementation Order
-
-### Phase 1 (Quick Wins):
-
-1. Algebraic Simplification (easy, high impact)
-2. Strength Reduction (easy, high impact)
-3. Dead Store Elimination (medium complexity, good impact)
-
-### Phase 2 (Medium Effort):
-
-4. Peephole Optimizations - seq/beq pattern (medium, high impact)
-5. Common Subexpression Elimination (medium, high impact)
-6. Copy Propagation Enhancement (medium, medium impact)
-
-### Phase 3 (Advanced):
-
-7. Loop Invariant Code Motion (complex, high impact for loop-heavy code)
-8. Function Inlining (complex, high impact)
-9. Register Coalescing (complex, medium impact)
-
-## Testing Strategy
-
-- Add test cases for each optimization
-- Ensure optimization preserves semantics (run existing tests after each)
-- Measure code size reduction
-- Consider adding benchmarks to measure game performance impact