2.3 從 RTL 到閘級：符號執行與結構雜湊#

// eda/src/netlist.rs
pub struct Builder {
    pub cells: Vec<Cell>,
    pub next_wire: u32,
    cache: HashMap<(&'static str, [Bit; 3]), Bit>,
    /// x <-> !x，因此雙重否定與 x & !x 會被折疊掉
    inv: HashMap<Bit, Bit>,
    /// 把多工器折疊進它選擇的兩個相同值之間
    /// （`s ? (t ? v : a) : a` = `(s & t) ? v : a`）：
    /// 巢狀條件下寫入陣列，每位元只花一個多工器，而不是每個條件一個
    pub fold_mux: bool,
    muxes: HashMap<Bit, [Bit; 3]>,
}

fn gate(&mut self, typ: &'static str, ins: &[(&'static str, Bit)]) -> Bit {
    let mut key = [Bit::C0; 3];
    for (k, (_, b)) in ins.iter().enumerate() { key[k] = *b; }
    if let Some(&y) = self.cache.get(&(typ, key)) { return y; }
    let y = self.wire();
    // ...
    self.cache.insert((typ, key), y);
    y
}

pub fn and(&mut self, a: Bit, b: Bit) -> Bit {
    match (a, b) {
        (Bit::C0, _) | (_, Bit::C0) => Bit::C0,
        (Bit::C1, x) | (x, Bit::C1) => x,
        _ if a == b => a,
        _ if self.is_inv(a, b) => Bit::C0,      // x & !x = 0
        _ => {
            let (x, y) = (a.min(b), a.max(b));   // 交換律正規化
            self.gate("$_AND_", &[("A", x), ("B", y)])
        }
    }
}

fn declare(&mut self, sc: &mut Scope, name: &str, ty: TypeInfo) -> Vec<Bit> {
    let total = ty.w * ty.arr.unwrap_or(1);
    let bits = self.b.wires(total);
    self.nets.push((sc.qual(name), bits.clone()));
    sc.sigs.insert(name.to_string(), SigInfo { bits: bits.clone(), ty });
    sc.order.push(name.to_string());
    bits
}

pub fn optimize(b: Builder, alias: &HashMap<u32, Bit>, ports: Vec<Port>,
                nets: Vec<(String, Vec<Bit>)], name: &str) -> R<Netlist>

// eda/src/netlist.rs
/// 重建網表：在拓樸順序上重跑常數折疊與結構雜湊，並偵測組合迴路

let mut stack: Vec<(u32, bool)> = vec![(rw, false)];
let mut onstack: HashSet<u32> = HashSet::new();
while let Some((w, expanded)) = stack.pop() {
    // ...
    if !onstack.insert(w) {
        return Err(format!("combinational loop through '{}'", net_name(w)));
    }
}

/// 優化：重建網表，然後把永遠無法離開初始 0 的正反器換成常數 0，重複直到沒有變化

let is_stuck = |c: &Cell| {
    let (q, d) = (c.out(), c.port("D"));
    let zero_reset = c.port("R").is_none() || c.typ.ends_with("0_");
    c.is_ff() && zero_reset && (d == Some(q) || d == Some(Bit::C0))
};

/// 找出那些雖然沒有局部折疊規則能看到、但其實是常數的組合節點……
/// 隨機模擬提出候選，再用對其輸入支援的窮舉模擬證明
fn const_nodes(nl: &Netlist) -> HashMap<u32, Bit> {
    const MAXSUP: usize = 16;

// 隨機模擬：4 × 64 位元樣本，xorshift PRNG
let mut seed = 0x9e3779b97f4a7c15u64;
let mut rnd = move || { seed ^= seed << 13; seed ^= seed >> 7; seed ^= seed << 17; seed };

let valid = if npat >= 64 { !0u64 } else { (1u64 << npat) - 1 };
if r.iter().all(|x| x & valid == 0) { out.insert(w, Bit::C0); }
else if r.iter().all(|x| x & valid == valid) { out.insert(w, Bit::C1); }

/// 移除輸出接不到任何輸出埠的單元（也包含死掉的正反器）
pub fn sweep(cells: &mut Vec<Cell>, roots: &[Bit]) {
    let mut live: HashSet<Bit> = roots.iter().copied().collect();
    // ... 從 roots 反向可達性分析 ...
}

// 仍然被讀取的記憶體，其寫入埠會留下（映射器可能把它變成 RAM）
for (n, bits) in &nets2 {
    let Some(rest) = n.strip_prefix("$mem:") else { continue; };
    let Some((q, port)) = rest.rsplit_once(':') else { continue; };
    if !port.starts_with("rd") || !bits.iter().any(|b| used.contains(b)) { continue; }
    for (m, b) in &nets2 {
        if [":clk", ":we", ":wa", ":wd"].iter().any(|s| *m == format!("$mem:{}{}", q, s)) {
            roots.extend(b.iter().copied());
        }
    }
}

let (mut env_n, mut env_r) = (Env::new(), Env::new());
// ...
self.ff = Some((self.ff_blocks, ck, pos));
let reset = if let Some(Stmt::IfReset { reset, arms, els }) = body.first() {
    self.exec(sc, reset, &mut env_r)?;                       // 重置路徑
    self.exec(sc, &[Stmt::If { arms, els }], &mut env_n)?;   // 正常路徑
    Some((rb, low, asynch))
} else {
    self.exec(sc, &body, &mut env_n)?;
    None
};

// $_DFF_P_ / $_DFF_PN0_ / $_SDFF_PP1_ ...
let f: Vec<char> = t.trim_start_matches("$_").trim_start_matches("S").trim_start_matches("DFF_").chars().collect();
let edge = if f[0] == 'P' { "posedge" } else { "negedge" };

// 分支條件互斥時：每個結果位元是 OR_i(hit_i & value_i) | (無命中 & 預設值)，
// 用平衡樹，而不是 exec_chain 的優先多工器鏈

fn exec_chain(&mut self, sc: &Scope, conds: &[(Bit, &[Stmt])], els: &[Stmt], env: &mut Env) -> R<()> {
    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 鏈
    let m = self.b.muxv(*c, &f, &t);   // c ? then : else
}

for i in idx {
    sc.consts.insert(var.clone(), Val::new(32, i));
    out.extend(self.lower_block(sc, &f.statement_block)?);
}

// return 之後的指派不應該生效
if let Some(d) = env.get("$done").map(|v| v[0]) {
    if d != Bit::C0 && name != "$done" { nv = self.b.muxv(d, &nv, &cur); }
}