//! Backward dataflow liveness analysis.

//!

//! Computes live-in and live-out sets for each basic block. A register is

//! "live" at a program point if its value may be used on some path from that

//! point to program exit.

//!

//! Uses iterative dataflow analysis:

//!

//!   REPEAT UNTIL changed == false

//!     changed = false

//!     FOR EACH BLOCK b IN POST-ORDER DO

//!       newOut = UNION(liveIn[succ] FOR EACH SUCCESSOR OF b)

//!       newIn = uses[b] | (newOut - defs[b])

//!       IF newIn != liveIn[b] OR newOut != liveOut[b] THEN

//!         changed = true

//!         liveIn[b] = newIn

//!         liveOut[b] = newOut

//!

//! Usage:

//!

//!   let live = liveness::analyze(func, ...);

//!   if liveness::isLastUse(&live, func, blockIdx, instrIdx, reg) {

//!       // `reg` last use is at this instruction.

//!   }

use std::mem;

use std::lang::il;

use std::lang::alloc;

use std::lang::gen::bitset;

/// Maximum number of SSA registers supported.

pub const MAX_SSA_REGS: u32 = 8192;

/// Liveness information for a function.

pub record LiveInfo {

    /// Per-block live-in sets (indexed by block index).

    liveIn: *mut [bitset::Bitset],

    /// Per-block live-out sets (indexed by block index).

    liveOut: *mut [bitset::Bitset],

    /// Per-block defs sets (registers defined in block).

    defs: *mut [bitset::Bitset],

    /// Per-block uses sets (registers used before defined in block).

    uses: *mut [bitset::Bitset],

    /// Number of blocks.

    blockCount: u32,

    /// Maximum register number used.

    maxReg: u32,

}

/// Context for collecting defs and uses during block analysis.

record DefsUses {

    defs: *bitset::Bitset,

    uses: *mut bitset::Bitset,

}

/// Context for searching for a specific register in an instruction.

record FindCtx {

    target: u32,

    found: bool,

}

/// Compute liveness information for a function.

pub fn analyze(func: *il::Fn, arena: *mut alloc::Arena) -> LiveInfo throws (alloc::AllocError) {

    let blockCount = func.blocks.len;

    if blockCount == 0 {

        return LiveInfo {

            liveIn: &mut [],

            liveOut: &mut [],

            defs: &mut [],

            uses: &mut [],

            blockCount: 0,

            maxReg: 0,

        };

    }

    // Find max register number.

    let mut maxReg: u32 = 0;

    for p in func.params {

        maxReg = maxRegNum(p.value.n, maxReg);

    }

    for b in 0..blockCount {

        let block = &func.blocks[b];

        for p in block.params {

            maxReg = maxRegNum(p.value.n, maxReg);

        }

        for i in 0..block.instrs.len {

            il::forEachReg(block.instrs[i], maxRegCallback, &mut maxReg as *mut opaque);

            if let dst = il::instrDst(block.instrs[i]) {

                maxReg = maxRegNum(dst.n, maxReg);

            }

        }

    }

    assert maxReg <= MAX_SSA_REGS, "analyze: maximum SSA registers exceeded";

    // Allocate per-block bitsets.

    let liveIn = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];

    let liveOut = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];

    let defs = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];

    let uses = try alloc::allocSlice(arena, @sizeOf(bitset::Bitset), @alignOf(bitset::Bitset), blockCount) as *mut [bitset::Bitset];

    for b in 0..blockCount {

        liveIn[b] = try bitset::allocate(arena, maxReg);

        liveOut[b] = try bitset::allocate(arena, maxReg);

        defs[b] = try bitset::allocate(arena, maxReg);

        uses[b] = try bitset::allocate(arena, maxReg);

    }

    // Compute local defs and uses for each block.

    for b in 0..blockCount {

        computeLocalDefsUses(&func.blocks[b], &mut defs[b], &mut uses[b]);

    }

    // Iterative dataflow analysis.

    let mut changed = true;

    let mut scratch = try bitset::allocate(arena, maxReg);

    while changed {

        changed = false;

        // Process blocks in reverse order (approximates post-order).

        let mut b = blockCount;

        while b > 0 {

            b -= 1;

            let block = &func.blocks[b];

            // Compute new `liveOut` as union of successor `liveIn` sets.

            bitset::clearAll(&mut scratch);

            addSuccessorLiveIn(func, block, liveIn, &mut scratch);

            if not bitset::eq(&liveOut[b], &scratch) {

                bitset::copy(&mut liveOut[b], &scratch);

                changed = true;

            }

            if computeAndUpdateLiveIn(&mut liveIn[b], &liveOut[b], &defs[b], &uses[b]) {

                changed = true;

            }

        }

    }

    return LiveInfo { liveIn, liveOut, defs, uses, blockCount, maxReg };

}

/// Compute `liveIn = uses | (liveOut - defs)` and update `dst`.

/// Returns `true` if `dst` changed. Combined loop avoids multiple passes.

fn computeAndUpdateLiveIn(

    dst: *mut bitset::Bitset,

    liveOut: *bitset::Bitset,

    defs: *bitset::Bitset,

    uses: *bitset::Bitset

) -> bool {

    let numWords = dst.bits.len;

    let mut changed = false;

    for i in 0..numWords {

        let newWord = uses.bits[i] | (liveOut.bits[i] & ~defs.bits[i]);

        if dst.bits[i] != newWord {

            dst.bits[i] = newWord;

            changed = true;

        }

    }

    return changed;

}

/// Compute local defs and uses for a single block.

fn computeLocalDefsUses(block: *il::Block, defs: *mut bitset::Bitset, uses: *mut bitset::Bitset) {

    for p in block.params {

        bitset::set(defs, p.value.n);

    }

    for i in 0..block.instrs.len {

        let instr = block.instrs[i];

        let mut ctx = DefsUses { defs, uses };

        il::forEachReg(instr, addUseCallback, &mut ctx as *mut opaque);

        if let dst = il::instrDst(instr) {

            bitset::set(defs, dst.n);

        }

    }

}

/// Callback for [`il::forEachReg`]: adds register to uses if not already defined.

fn addUseCallback(reg: il::Reg, ctx: *mut opaque) {

    let c = ctx as *mut DefsUses;

    if not bitset::contains(c.defs, reg.n) {

        bitset::set(c.uses, reg.n);

    }

}

/// Callback for [`il::forEachReg`]: updates max register number.

fn maxRegCallback(reg: il::Reg, ctx: *mut opaque) {

    let max = ctx as *mut u32;

    *max = maxRegNum(reg.n, *max);

}

/// Return the larger of n+1 and current.

fn maxRegNum(n: u32, current: u32) -> u32 {

    if n + 1 > current {

        return n + 1;

    }

    return current;

}

/// Add successor "live in" sets to the scratch bitset.

fn addSuccessorLiveIn(func: *il::Fn, block: *il::Block, liveIn: *[bitset::Bitset], scratch: *mut bitset::Bitset) {

    if block.instrs.len == 0 {

        return;

    }

    let term = block.instrs[block.instrs.len - 1];

    match term {

        case il::Instr::Jmp { target, .. } =>

            unionBlockLiveIn(target, liveIn, scratch),

        case il::Instr::Br { thenTarget, elseTarget, .. } => {

            unionBlockLiveIn(thenTarget, liveIn, scratch);

            unionBlockLiveIn(elseTarget, liveIn, scratch);

        },

        case il::Instr::Switch { defaultTarget, cases, .. } => {

            unionBlockLiveIn(defaultTarget, liveIn, scratch);

            for c in cases {

                unionBlockLiveIn(c.target, liveIn, scratch);

            }

        },

        else => {},

    }

}

/// Union a target block's "live in" set into scratch.

fn unionBlockLiveIn(target: u32, liveIn: *[bitset::Bitset], scratch: *mut bitset::Bitset) {

    bitset::union_(scratch, &liveIn[target]);

}

/// Check if this is the last use of a register at this instruction.

pub fn isLastUse(info: *LiveInfo, func: *il::Fn, blockIdx: u32, instrIdx: u32, reg: il::Reg) -> bool {

    let block = &func.blocks[blockIdx];

    let instr = block.instrs[instrIdx];

    if not instrUsesReg(instr, reg) {

        return false;

    }

    if bitset::contains(&info.liveOut[blockIdx], reg.n) {

        return false;

    }

    for i in (instrIdx + 1)..block.instrs.len {

        if instrUsesReg(block.instrs[i], reg) {

            return false;

        }

    }

    return true;

}

/// Check if an instruction uses a specific register.

fn instrUsesReg(instr: il::Instr, reg: il::Reg) -> bool {

    let mut ctx = FindCtx { target: reg.n, found: false };

    il::forEachReg(instr, findRegCallback, &mut ctx as *mut opaque);

    return ctx.found;

}

/// Callback for [`il::forEachReg`]: sets found if register matches target.

fn findRegCallback(reg: il::Reg, ctx: *mut opaque) {

    let c = ctx as *mut FindCtx;

    if reg.n == c.target {

        c.found = true;

    }

}