/// Conditional edges preserve capacity checks for each comparison and layout.

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

    for op in [il::CmpOp::Eq, il::CmpOp::Ne, il::CmpOp::Slt, il::CmpOp::Ult] {

        for typ in [il::Type::W8, il::Type::W16, il::Type::W32, il::Type::W64] {

            for layout in 0..2 {

                for argumentSide in 0..3 {

                    try checkBranchCapacity(op, typ, layout, argumentSide);

                }

            }

        }

    }

}

/// Build a branch with no arguments or arguments on exactly one edge.

unsafe fn checkBranchCapacity(op: il::CmpOp, typ: il::Type, layout: u32, argumentSide: u32)

    throws (testing::TestError)

{

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

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

    let params = [

        il::Param { value: il::Reg { n: 0 }, type: il::Type::W64 },

        il::Param { value: il::Reg { n: 1 }, type: il::Type::W64 },

    ];

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

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

    let thenCount: u32 = 1 if argumentSide == 1 else 0;

    let elseCount: u32 = 1 if argumentSide == 2 else 0;

    let mut thenArgs = [b];

    let mut elseArgs = [a];

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

        op, typ, a, b: il::Val::Imm(0) if argumentSide == 1 else b,

        thenTarget: 1 if layout == 0 else 2, thenArgs: &mut thenArgs[..thenCount],

        elseTarget: 2 if layout == 0 else 1, elseArgs: &mut elseArgs[..elseCount],

    }];

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

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

    }];

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

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

    }];

    let thenBlock = il::Block {

        label: "then", params: &thenParams[..thenCount], instrs: &mut thenBody[..],

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

    };

    let elseBlock = il::Block {

        label: "else", params: &elseParams[..elseCount], instrs: &mut elseBody[..],

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

    };

    let blocks = [

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

        thenBlock if layout == 0 else elseBlock,

        elseBlock if layout == 0 else thenBlock,

    ];

    let func = il::Fn {

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

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

    };

    try checkFunctionCapacity(&func, nil);

}

    try checkFunctionCapacity(&func, expectedError);

}

/// Verify function output capacity and failure propagation with guard words.

unsafe fn checkFunctionCapacity(func: &il::Fn, expectedError: ?super::Error) throws (testing::TestError) {

    super::generateFunction(&mut gen, func, &mut scratch);

        super::generateFunction(&mut gen, func, &mut scratch);

        case il::Instr::Br { thenTarget, thenArgs, elseTarget, elseArgs, .. } => {

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

                if thenArgs.len > 0 and elseArgs.len == 0

                else func.blocks[elseTarget].params if elseArgs.len > 0 and thenArgs.len == 0

                else &[];

            selectBranch(s, blockIdx, instr, params, thenArgs, elseArgs);

/// Select a conditional branch with parameters for its argument-bearing edge.

fn selectBranch 'scratch 'selection (

    s: &mut Selector 'scratch 'selection,

    blockIdx: u32,

    instr: &il::Instr,

    params: &[il::Param],

    thenArgs: &[il::Val],

    elseArgs: &[il::Val]

) where 'scratch: 'selection {

    let case il::Instr::Br { op, typ, a, b, thenTarget, elseTarget, .. } = *instr

        else panic "selectBranch: expected conditional branch";

    // Use zero register directly for immediate `0` operands.

    let aIsZero = isZeroImm(a);

    let bIsZero = isZeroImm(b);

    let rs1 = super::ZERO if aIsZero else resolveVal(s, super::SCRATCH1, a);

    let rs2 = super::ZERO if bIsZero else resolveVal(s, super::SCRATCH2, b);

    // Normalize sub-word operands so that both registers have the same

    // canonical representation. Without this, eg. `-1 : i8 ` loaded as

    // `0xFFFFFFFFFFFFFFFF` and `255 : i8` loaded as `0xFF` would compare

    // unequal even though they are the same 8-bit pattern.

    //

    // For SLT: sign-extension needed (signed comparison).

    // For ULT: zero-extension needed (unsigned magnitude comparison).

    // For EQ/NE with W32: sign-extension is cheaper.

    // For EQ/NE with W8/W16: keep zero-extension.

    // Skip extension for zero register.

    let mut signed = false;

    if let case il::CmpOp::Slt = op {

        set signed = true;

    }

    let useSext = cmpUsesSext(typ, signed);

    if not aIsZero and not isExtendedImm(a, typ, useSext) {

        emitCmpExt(s.e, rs1, rs1, typ, useSext);

    }

    if not bIsZero and not isExtendedImm(b, typ, useSext) {

        emitCmpExt(s.e, rs2, rs2, typ, useSext);

    }

    // Block-argument moves must only execute on the taken path.

    // When `thenArgs` is non-empty, invert the branch so that the

    // then-moves land on the fall-through (taken) side.

    //

    // When one target is the next block in layout order, we can

    // eliminate the trailing unconditional jump by arranging the

    // conditional branch to skip to the *other* target and letting

    // execution fall through.

    if thenArgs.len > 0 and elseArgs.len > 0 {

        panic "selectBranch: both `then` and `else` have block arguments";

    } else if thenArgs.len > 0 {

        emit::recordBranch(s.e, elseTarget, emit::BranchKind::InvertedCond { op, rs1, rs2 });

        emitBlockArgs(s, params, thenArgs);

        // Skip trailing jump if then is the next block (fallthrough).

        if thenTarget <> blockIdx + 1 {

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

        }

    } else if thenTarget == blockIdx + 1 and elseArgs.len == 0 {

        // Then is the next block and no else args: invert the

        // condition to branch to else and fall through to then.

        emit::recordBranch(s.e, elseTarget, emit::BranchKind::InvertedCond { op, rs1, rs2 });

    } else {

        emit::recordBranch(s.e, thenTarget, emit::BranchKind::Cond { op, rs1, rs2 });

        emitBlockArgs(s, params, elseArgs);

        // Skip trailing jump if else is the next block (fallthrough).

        if elseTarget <> blockIdx + 1 {

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

        }

    }

}