4.3 ECP5 映射：ecp5.rs#

use crate::ice40::{find_carries, lut_cover, truth, PAT};

// ecp5.rs — LUT 生成，覆蓋結果來自 ice40::lut_cover
let mut lut_order: Vec<u32> = used.iter().copied().collect();
lut_order.sort_by_key(|n| pos[n]);          // 閘序，輸出確定性
for n in lut_order {
    let leaves = &best[&n].leaves;
    let mut memo: HashMap<u32, u16> = HashMap::new();
    for (i, l) in leaves.iter().enumerate() { memo.insert(*l, PAT[i]); }
    let tt = truth(n, &gates, &pos, &mut memo);
    for (i, p) in ["A", "B", "C", "D"].iter().enumerate() {
        conns.push((p, leaves.get(i).map(|w| Bit::W(*w)).unwrap_or(Bit::C0)));
    }
    conns.push(("Z", Bit::W(n)));
    cells.push(Cell { typ: "LUT4".into(), conns,
        params: vec![("INIT", format!("{:016b}", tt))] });
}

/// CCU2C half that adds A + B + CIN (C = 0, D = 1: LUT4 = A ^ B, LUT2 = A)
pub const ADD_INIT: u16 = 0x96AA;
/// CCU2C half that only passes the carry on (LUT4 = 1: COUT = CIN)
pub const PASS_INIT: u16 = 0xFFFF;

let init1 = if let Some(j) = j {
    done.insert(j);
    let b1 = &bits[&j];
    conns.extend([("A1", b1.x), ("B1", b1.y), ("C1", Bit::C0),
                  ("D1", Bit::C1), ("COUT", Bit::W(j))]);
    if let Some(s) = b1.sum { conns.push(("S1", Bit::W(s))); }
    ADD_INIT                                     // 真的加第二位元
} else {
    conns.extend([("A1", Bit::C0), ("B1", Bit::C0), ("C1", Bit::C0),
                  ("D1", Bit::C0), ("COUT", Bit::W(i))]);
    PASS_INIT                                    // 只當進位導管
};

let j = next_of.get(&Bit::W(i)).copied()
    .filter(|j| !done.contains(j) && uses.get(&Bit::W(i)) == Some(&1));

// a carry chain does not branch: a COUT feeds at most one CIN directly,
// any other carry-in gets it through the fabric (a buffer LUT; nextpnr
// adds the feed-out / feed-in)
let couts: std::collections::HashSet<Bit> = cells.iter()
    .filter(|c| c.typ == "CCU2C").filter_map(|c| c.port("COUT")).collect();
let mut seen: std::collections::HashSet<Bit> = Default::default();
let mut bufs = vec![];
for c in cells.iter_mut().filter(|c| c.typ == "CCU2C") {
    let Some(k) = c.conns.iter().position(|x| x.0 == "CIN") else { continue };
    let ci = c.conns[k].1;
    if !couts.contains(&ci) || seen.insert(ci) { continue; }  // 首次使用免費
    let y = Bit::W(next_wire); next_wire += 1;
    bufs.push(Cell { typ: "LUT4".into(),
        conns: vec![("A", ci), ("B", Bit::C0), ("C", Bit::C0),
                    ("D", Bit::C0), ("Z", y)],
        params: vec![("INIT", format!("{:016b}", PAT[0]))] });
    c.conns[k].1 = y;
}
cells.extend(bufs);

// flip-flops: $_DFF_P_ / $_DFF_PN0_ / $_SDFF_NP1_ ...
// (clock and reset polarity are muxes in the slice)
for c in nl.cells.iter().filter(|c| c.is_ff()) {
    let t = c.typ.as_str();
    let f: Vec<char> = t.trim_start_matches("$_")
        .trim_start_matches('S').trim_start_matches("DFF_").chars().collect();
    let (q, d, ck) = (c.port("Q").unwrap(), c.port("D").unwrap(),
                      c.port("C").unwrap());
    let mut conns = vec![("CLK", ck), ("DI", d), ("Q", q)];
    let mut params = vec![
        ("GSR", "DISABLED".to_string()),
        ("CEMUX", "1".into()),
        ("CLKMUX", if f[0] == 'N' { "INV" } else { "CLK" }.into())];
    if let Some(r) = c.port("R") {
        conns.push(("LSR", r));
        params.push(("LSRMUX", if f[1] == 'N' { "INV" } else { "LSR" }.into()));
        params.push(("REGSET", if f[2] == '1' { "SET" } else { "RESET" }.into()));
        params.push(("SRMODE", if t.starts_with("$_SDFF") { "LSR_OVER_CE" }
                                         else { "ASYNC" }.into()));
    } else {
        params.push(("REGSET", "RESET".into()));
    }
    cells.push(Cell { typ: "TRELLIS_FF".into(), conns, params });
}

/// parameters that are strings, not bit vectors (yosys JSON marks a string
/// of 0 / 1 with a trailing space)
pub fn is_string_param(cell: &str, k: &str) -> bool {
    matches!(cell, "TRELLIS_FF" | "CCU2C") && !matches!(k, "INIT0" | "INIT1")
}

/// combinational cells in topological order
fn topo(cells: Vec<Cell>) -> Vec<Cell> {
    let mut driver: HashMap<u32, usize> = HashMap::new();
    for (i, c) in cells.iter().enumerate() {
        for (p, b) in &c.conns {
            if let (true, Bit::W(w)) = (is_out(p), b) { driver.insert(*w, i); }
        }
    }
    let mut state = vec![0u8; cells.len()];
    let mut order = vec![];
    for i in 0..cells.len() {
        // iterative depth-first post-order
        let mut stack = vec![(i, false)];
        while let Some((k, done)) = stack.pop() {
            if done { state[k] = 2; order.push(k); continue; }
            if state[k] != 0 { continue; }
            state[k] = 1;
            stack.push((k, true));
            for (p, b) in &cells[k].conns {
                if let (false, Bit::W(w)) = (is_out(p), b) {
                    if let Some(&d) = driver.get(w) {
                        if state[d] == 0 { stack.push((d, false)); }
                    }
                }
            }
        }
    }
    ...
}

pub fn ccu2c(c: &Cell, get: impl Fn(&str) -> bool) -> (bool, bool, bool) {
    let init = |k: &str| u16::from_str_radix(&p(k), 2).unwrap_or(0);
    let lut = |init: u16, a: bool, b: bool, cc: bool, d: bool|
        (init >> (a as u16 | (b as u16) << 1 | (cc as u16) << 2 | (d as u16) << 3)) & 1 == 1;
    let half = |init: u16, inject: bool, ins: [bool; 4], cin: bool| {
        let l4 = lut(init, ins[0], ins[1], ins[2], ins[3]);
        let l2 = (init >> (ins[0] as u16 | (ins[1] as u16) << 1)) & 1 == 1;
        let s = l4 ^ (!inject && cin);
        let co = (!l4 && !inject && l2) || (l4 && cin);
        (s, co)
    };
    let (s0, c0) = half(init("INIT0"), p("INJECT1_0") != "NO",
                        [get("A0"), get("B0"), get("C0"), get("D0")], get("CIN"));
    let (s1, c1) = half(init("INIT1"), p("INJECT1_1") != "NO",
                        [get("A1"), get("B1"), get("C1"), get("D1")], c0);
    (s0, s1, c1)
}