3.3 控制流到資料流：mux 樹、one-hot 合併、展開與內嵌#

Stmt::If { arms, els } => {
    let mut conds = vec![];
    for (c, body) in arms {
        let v = self.eval(sc, env, c, 0)?;
        conds.push((self.b.reduce_or(&v), body.as_slice()));
    }
    self.exec_chain(sc, &conds, els, env)?;
}

fn exec_chain(&mut self, sc: &Scope, conds: &[(Bit, &[Stmt])], els: &[Stmt], env: &mut Env) -> R<()> {
    let Some(((c, body), rest)) = conds.split_first() else { return self.exec(sc, els, env) };
    match *c {
        Bit::C1 => return self.exec(sc, body, env),      // 條件常真：直落
        Bit::C0 => return self.exec_chain(sc, rest, els, env), // 條件常假：刪除
        _ => {}
    }
    let mut et = env.clone();
    self.exec(sc, body, &mut et)?;                       // then 分支在複本上
    let mut ef = env.clone();
    self.exec_chain(sc, rest, els, &mut ef)?;            // else 鏈在另一個複本上
    ...
    for k in keys {
        ...
        let base = self.cur(sc, env, &k)?;
        let t = t.cloned().unwrap_or_else(|| base.clone());
        let f = f.cloned().unwrap_or(base.clone());
        ...
        let m = self.b.muxv(*c, &f, &t);                 // 逐位 mux
        env.insert(k, m);
    }
}

// distinct constant labels are mutually exclusive: parallel one-hot merge
let mut labels: Vec<u128> = vec![];
let mut exclusive = true;
for (items, body) in arms {
    ...
    match it {
        CaseItem::V(e) => {
            let v = self.eval(sc, env, e, 0)?;
            match const_of(&v) {
                Some(k) if !labels.contains(&k) => labels.push(k),
                _ => exclusive = false,
            }
            self.b.eq(&sv, &v)
        }
        CaseItem::R(lo, hi, incl) => { ... exclusive = false; ... }  // 範圍標籤：不可證明互斥
    }
    ...
}
if exclusive { self.exec_onehot(sc, &conds, def, env)?; }
else         { self.exec_chain (sc, &conds, def, env)?; }

// arms with the same value share one select; a signal most arms leave alone
// (a register held in other states) becomes a 2-way mux: changed ? new : old
let mut groups: Vec<(Vec<Bit>, &Vec<Bit>)> = vec![];
for (h, v) in &arms {
    match groups.iter_mut().find(|g| g.1 == *v) { Some(g) => g.0.push(*h), None => groups.push((vec![*h], *v)) }
}
...
let hold = groups.iter().position(|g| *g.1 == base);
let sel: Vec<(Bit, &Vec<Bit>)> = groups.iter().enumerate()
    .filter(|(i, _)| Some(*i) != hold)
    .map(|(_, g)| (self.b.reduce_or(&g.0), g.1)).collect();
let changed = if hold.is_some() { Some(self.b.reduce_or(&sel.iter().map(|x| x.0).collect::<Vec<_>>())) } else { None };
...
let new = self.b.reduce_or(&terms);
out.push(match changed { Some(c) => self.b.mux(c, at(&base, i), new), None => new });

Statement::ForStatement(x) => {
    // loops are unrolled: the bounds must be constant
    let from = self.const_of(sc, &toks(|k| k.expression(&f.range.expression)))?.v.sat();
    let o = f.range.range_opt.as_ref().ok_or("for range needs `a..b`")?;
    let to = self.const_of(sc, &toks(|k| k.expression(&o.expression)))?.v.sat();
    ...
    for i in idx {
        sc.consts.insert(var.clone(), Val::new(32, i));
        out.extend(self.lower_block(sc, &f.statement_block)?);
    }
}

let mut env = Env::new();
for ((p, ty), v) in f.params.iter().zip(args) { env.insert(p.clone(), self.fit(&v, ty.w, ty.signed)); }
env.insert("$ret".into(), vec![Bit::C0; ret.w as usize]);
env.insert("$done".into(), vec![Bit::C0]);
...
self.exec(&fsc, &f.body, &mut env)?;
Ok(env.remove("$ret").unwrap())

self.write(sc, env, "$ret", &Sel::All, &v)?;
env.insert("$done".into(), vec![Bit::C1]);

// after a `return`, later assignments must not take effect
if let Some(d) = env.get("$done").map(|v| v[0]) {
    if d != Bit::C0 && name != "$done" { nv = self.b.muxv(d, &nv, &cur); }
}

always_comb {
    case state {
        IDLE:    out = 0;
        RUN:     out = cnt;
        default: out = 8'hFF;
    }
}