feat: 新增 IR 层常量传播与折叠 pass

crates/oxide_fold/src/propagate.rs

@@ -0,0 +1,171 @@
+//! 单向前扫常量传播：per-register known 表 + 汇合点清空 + 就地改写。
+//!
+//! pass 形态：对单个函数逐条前扫，维护 `known: Vec<Option<Constant>>`（按 vreg
+//! 号索引）记录各寄存器的已知常量值。命中改写表即就地改写指令（改 op 与操作数
+//! 槽，指令位置不动），不删除任何指令、不重映射 `label_pos`。
+//!
+//! 汇合点健全性：`label_pos` 指向的指令下标（控制流汇合点）整体清空 known 表——
+//! 单向前扫状态只在前一条路径上有效，跨汇合的陈旧知识会误折。
+//!
+//! 改写后失去消费者的 `LOAD_CONST` 与死 `MOV` 由下游 DCE 清理（保守 DCE 的 use
+//! 计数迭代删纯指令、精确 DCE 删死 MOV），本 pass 不产生残留。
+
+use oxide_bytecode::module::Constant;
+use oxide_bytecode::opcode::OpCode;
+use oxide_ir::inst::Inst;
+use oxide_ir::operand::Operand;
+use oxide_ir::IRFunction;
+
+use crate::fold_table;
+
+/// 常量传播与折叠：单函数单向前扫，就地改写。
+///
+/// 返回是否发生改写（仅调试日志用）。不删指令、不重映射 label；改写只改变指令
+/// 的 op 与操作数，不改变跳转结构，CFG 的块划分与边集不变，由下游 DCE 在折叠后
+/// 的指令流上重建 CFG 吸收。
+pub fn fold_function(f: &mut IRFunction) -> bool {
+    let insts = &mut f.insts;
+    let constants = &mut f.constants;
+    let label_pos = &f.label_pos;
+
+    // 预计算 label 目标位图（控制流汇合点）。
+    let mut label_targets = vec![false; insts.len()];
+    for &pos in label_pos.iter().flatten() {
+        if pos < insts.len() {
+            label_targets[pos] = true;
+        }
+    }
+
+    // known 表上界 = 函数内 def/use 寄存器号最大值加一。
+    let max_reg = insts.iter().fold(0u32, |m, inst| {
+        let mut mx = m;
+        if let Some(r) = inst.def_reg() {
+            mx = mx.max(r);
+        }
+        for r in inst.use_regs() {
+            mx = mx.max(r);
+        }
+        mx
+    });
+
+    let mut known: Vec<Option<Constant>> = vec![None; (max_reg + 1) as usize];
+    let mut changed = false;
+
+    for (i, inst) in insts.iter_mut().enumerate() {
+        // 汇合点：label 目标整体清空 known（单向前扫状态只在前一条路径上有效）。
+        if label_targets[i] {
+            known.fill(None);
+        }
+
+        match inst.op {
+            // LOAD_CONST 是常量值来源：known[rd] = constants[idx]。
+            OpCode::LOAD_CONST => {
+                if let Some(rd) = inst.def_reg() {
+                    known[rd as usize] = match inst.a {
+                        Operand::Const(idx) => constants.get(idx as usize).cloned(),
+                        _ => None,
+                    };
+                }
+                continue;
+            }
+            // MOV 是纯拷贝：known[rd] = known[src]。
+            OpCode::MOV => {
+                if let Some(rd) = inst.def_reg() {
+                    known[rd as usize] = match inst.a {
+                        Operand::Reg(src) => known.get(src as usize).and_then(|c| c.clone()),
+                        _ => None,
+                    };
+                }
+                continue;
+            }
+            _ => {}
+        }
+
+        // A 组：常量折叠（操作数均已知）→ 改写为 LOAD_CONST。
+        let folded = match inst.op {
+            // VOID 无操作数，恒折 Undefined。
+            OpCode::VOID => Some(Constant::Undefined),
+            // 其余一元：操作数须为已知寄存器。
+            OpCode::NOT | OpCode::TYPEOF | OpCode::NEG | OpCode::UNARY_PLUS | OpCode::BIT_NOT => {
+                match inst.a {
+                    Operand::Reg(x) => known
+                        .get(x as usize)
+                        .and_then(|c| c.as_ref())
+                        .and_then(|c| fold_table::fold_unary(inst.op, c)),
+                    _ => None,
+                }
+            }
+            // 二元算术：两操作数须为已知寄存器。
+            OpCode::ADD | OpCode::SUB | OpCode::MUL | OpCode::DIV | OpCode::MOD | OpCode::EXP => {
+                match (inst.a, inst.b) {
+                    (Operand::Reg(x), Operand::Reg(y)) => match (
+                        known.get(x as usize).and_then(|c| c.as_ref()),
+                        known.get(y as usize).and_then(|c| c.as_ref()),
+                    ) {
+                        (Some(l), Some(r)) => fold_table::fold_binary(inst.op, l, r),
+                        _ => None,
+                    },
+                    _ => None,
+                }
+            }
+            _ => None,
+        };
+
+        if let Some(value) = folded {
+            // 新常量入池（去重加溢出守卫）；池满时 A 组失效，跳过改写。
+            if let Some(idx) = intern(constants, &value) {
+                *inst = Inst::load_const(inst.rd, idx);
+                changed = true;
+                if let Some(rd) = inst.def_reg() {
+                    known[rd as usize] = Some(value);
+                }
+            }
+        } else {
+            // B 组：逻辑短路（左操作数已知）→ 改写为 MOV。
+            let select_left = match (inst.op, inst.a) {
+                (OpCode::AND | OpCode::OR | OpCode::NULLISH, Operand::Reg(x)) => known
+                    .get(x as usize)
+                    .and_then(|c| c.as_ref())
+                    .and_then(|c| fold_table::short_circuit(inst.op, c)),
+                _ => None,
+            };
+            if let Some(select_left) = select_left {
+                let src = if select_left { inst.a } else { inst.b };
+                *inst = Inst::inst_mov(inst.rd, src);
+                changed = true;
+                if let (Some(rd), Operand::Reg(s)) = (inst.def_reg(), src) {
+                    known[rd as usize] = known.get(s as usize).and_then(|c| c.clone());
+                }
+            } else {
+                // 不可折：def 寄存器为不定值。
+                if let Some(rd) = inst.def_reg() {
+                    known[rd as usize] = None;
+                }
+            }
+        }
+    }
+
+    changed
+}
+
+/// 常量池判等：`Number` 臂按位模式比较（区分 `-0.0` 与 `+0.0`，与 emit 层
+/// `ConstantKey` 的 `to_bits` 口径一致），其余臂用派生 `PartialEq`。
+fn const_eq(a: &Constant, b: &Constant) -> bool {
+    match (a, b) {
+        (Constant::Number(x), Constant::Number(y)) => x.to_bits() == y.to_bits(),
+        _ => a == b,
+    }
+}
+
+/// 新常量入池：线性扫描判等（命中复用既有下标）；未命中推尾取新下标；池满
+/// （`u16::MAX`）时返回 `None` 禁用 A 组改写（B 组 MOV 不新增常量，不受影响）。
+fn intern(constants: &mut Vec<Constant>, c: &Constant) -> Option<u16> {
+    if let Some(idx) = constants.iter().position(|x| const_eq(x, c)) {
+        return Some(idx as u16);
+    }
+    if constants.len() >= u16::MAX as usize {
+        return None;
+    }
+    constants.push(c.clone());
+    Some((constants.len() - 1) as u16)
+}