module insel

import v3.mir
import v3.ssa

// OperandKind lists operand kind values used by insel.
pub enum OperandKind {
    value
    block
}

// Operand represents operand data used by insel.
pub struct Operand {
pub:
    kind OperandKind
    id   int
}

// Instruction represents instruction data used by insel.
pub struct Instruction {
pub:
    op       ssa.OpCode
    operands []Operand
    typ      ssa.TypeID
}

// BasicBlock represents basic block data used by insel.
pub struct BasicBlock {
pub:
    id     int
    name   string
    instrs []Instruction
}

// Function represents function data used by insel.
pub struct Function {
pub:
    id     int
    name   string
    abi    mir.FunctionAbi
    blocks []BasicBlock
}

// Module represents module data used by insel.
pub struct Module {
pub:
    target mir.Target
    funcs  []Function
}

// select_ selects MIR instructions into a target-specific machine module shell.
pub fn select_(mut m mir.Module) Module {
    mut funcs := []Function{}
    for f in m.funcs {
        if f.is_c_extern {
            continue
        }
        mut blocks := []BasicBlock{}
        for block_id in f.blocks {
            if block_id < 0 || block_id >= m.blocks.len {
                continue
            }
            blk := m.blocks[block_id]
            mut instrs := []Instruction{}
            for val_id in blk.instrs {
                if val_id <= 0 || val_id >= m.values.len {
                    continue
                }
                val := m.values[val_id]
                if val.kind != .instruction {
                    continue
                }
                instr := m.instrs[val.index]
                instrs << Instruction{
                    op:       instr.op
                    operands: select_operands(instr)
                    typ:      instr.typ
                }
            }
            blocks << BasicBlock{
                id:     blk.id
                name:   blk.name
                instrs: instrs
            }
        }
        funcs << Function{
            id:     f.id
            name:   f.name
            abi:    f.abi
            blocks: blocks
        }
    }
    return Module{
        target: m.target
        funcs:  funcs
    }
}

// select_operands resolves select operands information for insel.
fn select_operands(instr mir.Instruction) []Operand {
    mut operands := []Operand{}
    for i, operand in instr.operands {
        kind := if instr.op == .br && i > 0 {
            OperandKind.block
        } else if instr.op == .phi && i % 2 == 1 {
            OperandKind.block
        } else if instr.op == .jmp {
            OperandKind.block
        } else {
            OperandKind.value
        }
        operands << Operand{
            kind: kind
            id:   operand
        }
    }
    return operands
}