/// Cross-call pressure excludes the result and spills equal-cost values in order.

@test unsafe fn testCrossCallPressure() throws (testing::TestError) {

    let first = il::Reg { n: 0 };

    let second = il::Reg { n: 33 };

    let result = il::Reg { n: 66 };

    let sum = il::Reg { n: 67 };

    let total = il::Reg { n: 68 };

    let params = [il::Param { value: first, type: il::Type::W64 },

        il::Param { value: second, type: il::Type::W64 }];

    let args = [il::Val::Reg(first), il::Val::Reg(second)];

    let mut instructions = [

        il::Instr::Call { retTy: il::Type::W64, dst: result,

            func: il::Val::FnAddr("callee"), args: &args[..] },

        il::Instr::BinOp { op: il::BinOp::Add, typ: il::Type::W64, dst: sum,

            a: il::Val::Reg(first), b: il::Val::Reg(second) },

        il::Instr::BinOp { op: il::BinOp::Add, typ: il::Type::W64, dst: total,

            a: il::Val::Reg(sum), b: il::Val::Reg(result) },

        il::Instr::Ret { val: il::Val::Reg(total) },

    ];

    let blocks = [block("entry", &mut instructions[..]), block("empty", &mut [])];

    let function = il::Fn { name: "crossing", params: &params[..], returnType: il::Type::W64,

        isExtern: false, isLeaf: false, blocks: &blocks[..] };

    for capacity in [0 as u32, 1, 2] {

        static DATA: [u8; 8192] = [0; 8192];

        let mut arena = alloc::new(&mut DATA[..]);

        use arena as analysis in {

            let live = try! super::analyze(&function, &analysis);

            let info = try! spill::analyze(&function, &live, 8, capacity, 8, &analysis);

            assert spill::isSpilled(&info, first) == (capacity < 2);

            assert spill::isSpilled(&info, second) == (capacity == 0);

            assert not spill::isSpilled(&info, result);

            assert not spill::isSpilled(&info, sum);

            assert not spill::isSpilled(&info, total);

            assert bitset::contains(info.calleeClass, first.n) == (capacity == 2);

            assert bitset::contains(info.calleeClass, second.n) == (capacity > 0);

            assert not bitset::contains(info.calleeClass, result.n);

            assert info.frameSize == ((2 - capacity) * 8) as i32;

        }

    }

}

        try limitBlockPressure(block.instrs, scratch, spilled, costs, calleeClass, numRegs, numCalleeSaved);

    }

    let frameSize = try finishSpills(slots, spilled, calleeClass, numCalleeSaved, slotSize);

    return SpillInfo 'scratch { slots: &slots[..], frameSize, calleeClass: &calleeClass[..], maxReg };

}

/// Limit register pressure from the block's live-out set to its entry.

fn limitBlockPressure(

    instructions: &[il::Instr],

    live: &mut [u32],

    spilled: &mut [u32],

    costs: &[SpillCost],

    calleeClass: &mut [u32],

    numRegs: u32,

    numCalleeSaved: u32,

) throws (alloc::AllocError) {

    // Walk instructions backwards.

    let mut i = instructions.len;

    while i > 0 {

        set i -= 1;

        let instr = &instructions[i];

        // Limit register pressure before processing this instruction.

        try limitPressure(live, spilled, costs, numRegs);

        // Enforce cross-call pressure at call sites.

        if il::isCall(*instr) {

            try limitCrossCallPressure(

                live, spilled, costs,

                calleeClass, numCalleeSaved, il::instrDst(*instr)

            );

        }

        // Remove definition from live set.

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

            bitset::clear(live, dst.n);

        }

        // Add uses to live set.

        let mut registers = il::registers(instr);

        // Argument groups contain raw views into the function's IL storage.

        unsafe {

            while let reg = il::nextReg(&mut registers, instr) {

                bitset::put(live, reg.n);

    // Also limit pressure at block entry.

    try limitPressure(live, spilled, costs, numRegs);