/// Switch cases and default edges respect every shorter output capacity.

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

    for count in 0..3 {

        for argumentMask in 0..8 {

            try checkSwitchCapacity(count, argumentMask);

        }

    }

}

/// Build a switch with independently selected case and default arguments.

unsafe fn checkSwitchCapacity(count: u32, argumentMask: u32) throws (testing::TestError) {

    let params = [il::Param { value: il::Reg { n: 0 }, type: il::Type::W64 }];

    let firstParams = [il::Param { value: il::Reg { n: 1 }, type: il::Type::W64 }];

    let secondParams = [il::Param { value: il::Reg { n: 2 }, type: il::Type::W64 }];

    let defaultParams = [il::Param { value: il::Reg { n: 3 }, type: il::Type::W64 }];

    let firstCount: u32 = 1 if argumentMask & 1 <> 0 else 0;

    let secondCount: u32 = 1 if argumentMask & 2 <> 0 else 0;

    let defaultCount: u32 = 1 if argumentMask & 4 <> 0 else 0;

    let mut firstArgs = [il::Val::Imm(11)];

    let mut secondArgs = [il::Val::Imm(22)];

    let mut defaultArgs = [il::Val::Reg(il::Reg { n: 0 })];

    let mut cases = [

        il::SwitchCase { value: 0, target: 1, args: &mut firstArgs[..firstCount] },

        il::SwitchCase { value: 0x123456789abcdef, target: 2, args: &mut secondArgs[..secondCount] },

    ];

    let mut entry = [il::Instr::Switch {

        val: il::Val::Reg(il::Reg { n: 0 }), defaultTarget: 3,

        defaultArgs: &mut defaultArgs[..defaultCount], cases: &mut cases[..count],

    }];

    let mut first = [il::Instr::Ret {

        val: il::Val::Reg(il::Reg { n: 1 }) if firstCount > 0 else il::Val::Imm(11),

    }];

    let mut second = [il::Instr::Ret {

        val: il::Val::Reg(il::Reg { n: 2 }) if secondCount > 0 else il::Val::Imm(22),

    }];

    let mut fallback = [il::Instr::Ret {

        val: il::Val::Reg(il::Reg { n: 3 }) if defaultCount > 0 else il::Val::Imm(33),

    }];

    let predecessors = [0 as u32];

    let blocks = [

        il::Block { label: "entry", params: &[], instrs: &mut entry[..], locs: &[], preds: &[], loopDepth: 0 },

        il::Block {

            label: "first", params: &firstParams[..firstCount], instrs: &mut first[..],

            locs: &[], preds: &predecessors[..1 if count > 0 else 0], loopDepth: 0,

        },

        il::Block {

            label: "second", params: &secondParams[..secondCount], instrs: &mut second[..],

            locs: &[], preds: &predecessors[..1 if count > 1 else 0], loopDepth: 0,

        },

        il::Block {

            label: "default", params: &defaultParams[..defaultCount], instrs: &mut fallback[..],

            locs: &[], preds: &predecessors[..], loopDepth: 0,

        },

    ];

    let func = il::Fn {

        name: "p::switch", params: &params[..], returnType: il::Type::W64,

        isExtern: false, isLeaf: true, blocks: &blocks[..],

    };

    try checkFunctionCapacity(&func, nil);

}

                let params: *unsafe [il::Param] = func.blocks[c.target].params

                    if c.args.len > 0 else &[];

                selectSwitchCase(s, rs1, c.value, c.target, params, c.args);

/// Compare one switch case and emit its argument moves only on a match.

fn selectSwitchCase 'scratch 'selection (

    s: &mut Selector 'scratch 'selection,

    rs1: gen::Reg,

    value: i64,

    target: u32,

    params: &[il::Param],

    args: &[il::Val]

) where 'scratch: 'selection {

    emit::loadImm(s.e, super::SCRATCH2, value);

    // When a case has block args, invert the branch to skip past

    // the arg moves.

    if args.len > 0 {

        let skip = s.nextSynthBlock;

        set s.nextSynthBlock = skip + 1;

        emit::recordBranch(s.e, skip, emit::BranchKind::InvertedCond {

            op: il::CmpOp::Eq, rs1, rs2: super::SCRATCH2,

        });

        emitBlockArgs(s, params, args);

        emit::recordBranch(s.e, target, emit::BranchKind::Jump);

        emit::recordBlock(s.e, skip);

    } else {

        emit::recordBranch(s.e, target, emit::BranchKind::Cond {

            op: il::CmpOp::Eq, rs1, rs2: super::SCRATCH2,

        });

    }

}