//! 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;

static ASSEMBLY_ARENA_STORAGE: [u8; 16777216] = [0; 16777216];

static ASSEMBLY_TEXT_STORAGE: [u32; 2] = [0; 2];

/// Helper to check encoding equals expected value.

fn expectEncoding(actual: u32, expected: u32) throws (testing::TestError) {

    try testing::expect(actual == expected);

}

    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

}

            maxReg: 0,

        };

    }

    // Find max register number.

    for p in func.params {

    }

    for b in 0..blockCount {

        let block = &func.blocks[b];

        for p in block.params {

        }

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

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

            }

        }

    }

    // 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];

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

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

    }

}

}

    }

}

/// Add successor live-in sets to the block's live-out set.

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

    if block.instrs.len == 0 {

        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;