module optimize

import v3.ssa

// arr_contains reports whether arr contains applies in optimize.
fn arr_contains(arr []int, val int) bool {
    for v in arr {
        if v == val {
            return true
        }
    }
    return false
}

// build_cfg builds cfg data for optimize.
fn build_cfg(mut m ssa.Module) {
    n_blocks := m.blocks.len
    n_values := m.values.len

    for bi in 0 .. n_blocks {
        mut blk := m.blocks[bi]
        blk.succs = []
        blk.preds = []
        m.blocks[bi] = blk
    }

    for fi in 0 .. m.funcs.len {
        for blk_id in m.funcs[fi].blocks {
            blk := m.blocks[blk_id]
            if blk.instrs.len == 0 {
                continue
            }
            term_val_id := blk.instrs.last()
            if term_val_id < 0 || term_val_id >= n_values {
                continue
            }
            term_val := m.values[term_val_id]
            if term_val.kind != .instruction {
                continue
            }
            term := m.instrs[term_val.index]

            match term.op {
                .br {
                    if term.operands.len >= 3 {
                        for oi in 1 .. 3 {
                            s := int(term.operands[oi])
                            if s >= 0 && s < n_blocks && !arr_contains(m.blocks[blk_id].succs, s) {
                                mut b := m.blocks[blk_id]
                                b.succs << s
                                m.blocks[blk_id] = b
                            }
                        }
                    }
                }
                .jmp {
                    if term.operands.len >= 1 {
                        s := int(term.operands[0])
                        if s >= 0 && s < n_blocks {
                            mut b := m.blocks[blk_id]
                            b.succs << s
                            m.blocks[blk_id] = b
                        }
                    }
                }
                .switch_ {
                    // switch_ cond, default_blk, [case_val, blk]...
                    if term.operands.len >= 2 {
                        s := int(term.operands[1])
                        if s >= 0 && s < n_blocks && !arr_contains(m.blocks[blk_id].succs, s) {
                            mut b := m.blocks[blk_id]
                            b.succs << s
                            m.blocks[blk_id] = b
                        }
                        for oi := 3; oi < term.operands.len; oi += 2 {
                            cs := int(term.operands[oi])
                            if cs >= 0 && cs < n_blocks && !arr_contains(m.blocks[blk_id].succs, cs) {
                                mut b := m.blocks[blk_id]
                                b.succs << cs
                                m.blocks[blk_id] = b
                            }
                        }
                    }
                }
                else {}
            }

            for s in m.blocks[blk_id].succs {
                if s >= 0 && s < n_blocks && !arr_contains(m.blocks[s].preds, blk_id) {
                    mut b := m.blocks[s]
                    b.preds << blk_id
                    m.blocks[s] = b
                }
            }
        }
    }
}