try checkSelectionCapacity(instr, nil);

/// Direct and indirect calls check argument and output capacities.

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

    let a = il::Val::Reg(il::Reg { n: 0 });

    let b = il::Val::Reg(il::Reg { n: 1 });

    let args = [b, a, b, a, il::Val::Imm(7), a, b, a, a];

    for callee in [il::Val::FnAddr("p::callee"), a] {

        for dst in [nil as ?il::Reg, il::Reg { n: 3 }] {

            for count in [0 as u32, 8, 9] {

                let instr = il::Instr::Call {

                    retTy: il::Type::W64, dst, func: callee, args: &args[..count],

                };

                let expected: ?super::Error = super::Error::Capacity if count == 9 else nil;

                try checkSelectionCapacity(instr, expected);

            }

        }

    }

}

/// Verify instruction errors, exact-fit output, and shorter-buffer canaries.

unsafe fn checkSelectionCapacity(instr: il::Instr, expectedError: ?super::Error) throws (testing::TestError) {

    assert gen.e.error == expectedError;

    if expectedError <> nil {

        let count = gen.e.codeLen;

        emit::emit(&mut gen.e, encode::nop());

        assert gen.e.codeLen == count;

        return;

    }

        case il::Instr::Call { dst, func, args, .. } => selectCall(s, &func, args, dst),

        else => selectFixedInstr(s, blockIdx, instr, frame),

    }

}

/// Select a call from its target, borrowed arguments, and optional result.

fn selectCall 'scratch 'selection (

    s: &mut Selector 'scratch 'selection,

    func: &il::Val,

    args: &[il::Val],

    dst: ?il::Reg

) where 'scratch: 'selection {

    // For indirect calls, save target to scratch register before arg

    // setup can clobber it.

    if let case il::Val::Reg(r) = *func {

        let target = getSrcReg(s, r, super::SCRATCH2);

        emitMv(s, super::SCRATCH2, target);

    }

    // Move arguments to A0-A7 using parallel move resolution.

    if args.len > super::ARG_REGS.len {

        set s.e.error = super::Error::Capacity;

        return;

    }

    emitParallelMoves(s, &super::ARG_REGS[..], args);

    // Emit call.

    match *func {

        case il::Val::FnAddr(name) => {

            emit::recordCall(s.e, name);

        case il::Val::Reg(_) => {

            emit::emit(s.e, encode::jalr(super::RA, super::SCRATCH2, 0));

        },

        else => {

            panic "selectCall: invalid call target";

        }

    }

    // Move result from A0.

    if let d = dst {

        let rd = getDstReg(s, d, super::SCRATCH1);

        emitMv(s, rd, super::A0);

//! returns: 0

//! Full-arity calls preserve argument order and live values.

/// Encode eight arguments in distinct decimal positions.

fn digits(a: u64, b: u64, c: u64, d: u64, e: u64, f: u64, g: u64, h: u64) -> u64 {

    return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h;

}

/// Retain argument values and the target across two indirect calls.

fn invoke(callback: fn(u64, u64, u64, u64, u64, u64, u64, u64) -> u64, values: &[u64]) -> u64 {

    let a = values[0];

    let b = values[1];

    let c = values[2];

    let d = values[3];

    let e = values[4];

    let f = values[5];

    let g = values[6];

    let h = values[7];

    let reversed = callback(h, g, f, e, d, c, b, a);

    let ordered = callback(a, b, c, d, e, f, g, h);

    return reversed + ordered + a + b + c + d + e + f + g + h;

}

/// Check direct argument placement and repeated indirect calls.

@default fn main() -> u32 {

    let values: [u64; 8] = [1, 2, 3, 4, 5, 6, 7, 8];

    assert digits(1, 2, 3, 4, 5, 6, 7, 8) == 87654321;

    assert invoke(digits, &values[..]) == 100000035;

    return 0;

}