//! These tests verify that instruction encodings match the RISC-V specification

//! by comparing against known-good values.

use std::testing;

use std::lang::alloc;

use std::collections::dict;

use super::encode;

use super::asm;

    try testing::expect(encode::isJumpImm(1048574));    // Max positive even

    try testing::expect(encode::isJumpImm(-1048576));   // Min negative

    try testing::expectNot(encode::isJumpImm(1));       // Must be even

    try testing::expectNot(encode::isJumpImm(1048576)); // Out of range

}

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

                set maxReg = maxRegNum(dst.n, maxReg);

            }

        }

    }

    // Allocate per-block bitsets.

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

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

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

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

    set *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;

}

        while i > 0 {

            set i -= 1;

            let instr = block.instrs[i];

            // Limit register pressure before processing this instruction.

            // Enforce cross-call pressure at call sites.

            if il::isCall(instr) {

                    &mut scratch, &mut spilled, costs,

                    &mut calleeClass, numCalleeSaved, il::instrDst(instr)

                );

            }

            // Remove definition from live set.

            }

            // Add uses to live set.

            il::forEachReg(instr, addRegToSetCallback, &mut scratch as &mut opaque);

        }

        // Also limit pressure at block entry.

    }

    // Phase 3: Enforce global callee-class limit.

    // The per-call-site limit may leave the callee-class set larger than

    // `numCalleeSaved` when different call sites keep different subsets.

        bitset::clear(source, c.entries[i].reg);

    }

}

/// Collect all values from a bitset into a candidates buffer with their costs.

    let mut c = Candidates { entries: undefined, n: 0 };

    let mut it = bitset::iter(bs);

    while let reg = bitset::iterNext(&mut it) {

        if reg < costs.len {

            set c.entries[c.n] = CostEntry { reg, cost: costs[reg].defs + costs[reg].uses };

            set c.n += 1;

        }

    }

unsafe fn limitPressure(

    live: &mut bitset::Bitset,

    spilled: &mut bitset::Bitset,

    costs: *unsafe [SpillCost],

    numRegs: u32

    let liveCount = bitset::count(live);

    if liveCount <= numRegs {

        return;

    }

    spillCheapest(&mut c, liveCount - numRegs, live, spilled);

}

/// Check whether an SSA register is the destination of a call instruction.

fn isCallDst(callDst: ?il::Reg, n: u32) -> bool {

    spilled: &mut bitset::Bitset,

    costs: *unsafe [SpillCost],

    calleeClass: &mut bitset::Bitset,

    numCalleeSaved: u32,

    callDst: ?il::Reg

    // Collect crossing candidates: live values excluding the call destination.

    let mut candidates: [CostEntry; 256] = undefined;

    let mut numCandidates: u32 = 0;

    let mut it = bitset::iter(live);

    while let n = bitset::iterNext(&mut it) {

        if not isCallDst(callDst, n) and n < costs.len {

            set candidates[numCandidates] = CostEntry {

                reg: n,

                cost: costs[n].defs + costs[n].uses,

            };

            set numCandidates += 1;