rucc_codegen/

wide.rs

//! The integer that is wider than a register, as the two registers it is held in.
//!
//! `__int128` is the one integer a C program on this machine writes that no register holds.
//! Everything else the front end produces is a width the machine has, or is a width
//! [`crate::widths`] rounds up into one, and neither of those is true here: there is nothing to
//! round up into above sixty four bits. What there is, is two registers, and the convention already
//! says so. System V classifies a `__int128` as two eightbytes of class INTEGER, so it travels in a
//! pair of general purpose registers, comes back in the pair a return comes back in, and sits in
//! memory as two words with the low one first. That is what this pass writes down.
//!
//! Every value a hundred and twenty eight bits wide becomes two values of sixty four, a low half
//! and a high half, and every instruction over such a value becomes instructions over the halves.
//! After it there is no value of that width left anywhere in the function, which is what lets the
//! rest of the back end stay written about widths the machine has. Nothing below this knows the
//! type existed.
//!
//! # Why a pass and not a rule
//!
//! A rule matches a term and rewrites it into instructions of the machine, and the selector works a
//! value at a time. There is no register a value this wide can be selected into, so there is
//! nothing for a rule to produce, and a rule that produced a pair would have to say which register
//! each half landed in, which is the allocator's answer and not a rule's. So the splitting happens
//! before selection, in the IR, where a value is still something a pass may make two of. That is
//! the same reasoning [`crate::widths`] follows from the other end, and the two are the two halves
//! of one sentence: nothing reaching the selector is at a width the machine has no register for.
//!
//! # What crosses the boundary
//!
//! A parameter and a return value are agreed with something this compilation is not looking at, so
//! splitting one is a claim about where the two halves are. The claim is true when both halves land
//! in registers, because the convention hands out argument registers in order and two halves in a
//! row take the two registers the whole value would have taken. It is not true when they do not: a
//! value the convention could not fit in registers travels in the argument area as sixteen bytes
//! aligned to sixteen and leaves the register it could not use to whatever comes after it, and two
//! independent words in a row would put the first one in that register and the second a word up
//! from wherever the area had got to.
//!
//! So a signature with such a parameter is laid out again rather than split in place. Where every
//! parameter is meant to be is worked out first, and then the split signature is put in the order
//! that makes the ordinary walk over it arrive at the same places: the ones in registers first,
//! then the ones in the argument area by how far up it they are, with a filler that carries nothing
//! wherever the convention leaves a register or a word empty. Both ends of a call are built from the
//! same layout, a function's own parameters and every call it makes, so nothing below this has to
//! know a parameter was ever in any other order, and the IR needs no form of parameter it did not
//! have.
//!
//! A call to a variadic function is laid out the same way over everything it passes, the arguments
//! past the `...` included, because System V puts each of those where it would have gone had it
//! been named. What the ABI asks of each of them moves onto the parameter it becomes, so the call
//! names all its arguments afterwards and still says the callee is variadic, which is what sets the
//! count of vector registers the callee is told about. A variadic function's own signature with a
//! wide named parameter that goes in memory is still refused, because its named parameters are what
//! `va_start` counts from, and so is any of this on a convention that counts the two register files
//! as one run, where a float past the `...` travels in both. The `va_arg` of one is read in
//! `rucc-lower` as a pair of words, which is the walk [`crate::varargs`] already has for a small
//! structure.
//!
//! # Dividing and converting are calls into the runtime
//!
//! Every other operation at this width is the same operation over the halves with whatever crossed
//! between them put back. A quotient is not. The halves of a quotient are not a function of the
//! halves of its operands taken apart, at this width or at any other, which is why every compiler's
//! runtime has a division routine in it and none of them has an addition one. So a divide and a
//! remainder become a call to the routines `runtime/builtins/div.c` defines, which are libgcc's four
//! names and libgcc's signatures, and `spec/12-abi-and-runtime.md` section 12.8 is what they are.
//!
//! A conversion to or from a floating point value is the other one, for a plainer reason: the
//! machine's own conversion reaches sixty four bits and no further, so there is no instruction to
//! split into. Those are the eight names `runtime/builtins/convert.c` defines, one for each of a
//! signed and an unsigned integer against a `float` and a `double` in each direction, and the four
//! `runtime/builtins/quad.c` defines for a `_Float128`, which has no instruction of its own at any
//! width and so is a call here for both reasons at once. An eighty bit float is not among them,
//! because this machine has no register that holds one and the back end says so, which is
//! tamnd/rucc#326, so a function converting at that width is left alone here and refused below the
//! way every function of this width used to be.
//!
//! The call is asked for with the halves already in it, four parameters of sixty four bits for the
//! two operands of a divide and two results for the answer, or two parameters and a float, or a
//! float and two results, which is the shape this pass gives a call it found in the program anyway.
//! Both ends agree because the convention puts a `__int128` argument in two registers in a row and
//! hands out argument registers in order, which is the same sentence the section below about
//! crossing the boundary is.
//!
//! That is the shape on every convention that has registers for a value this wide and it is not the
//! shape on Windows x64, where such a value travels as the address of a copy the caller made and an
//! integer this wide comes back whole in a vector register. The one place the two are told apart is
//! where the call is built, by asking the ABI the same question a call in the program is asked, so
//! everything above it goes on describing the call in halves and nothing above it names a target.

use std::collections::{HashMap, HashSet};

use rucc_base::Interner;
use rucc_ir::{
    Abi, Block, BlockCall, CallInfo, Def, Extra, Flags, Float, Func, Imm, Inst, InstData, IntPred,
    MemInfo, MemOrder, Opcode, Param, Restrict, Signature, Type, Value,
};
use rucc_target::{AbiDescription, CallRegs, Convention, Places, Variadic, Where};

use crate::capability;
use crate::expand;

/// The width this pass is about, which is the one width a C program writes that no register holds.
const WIDE: u32 = 128;

/// What the capability table calls that width, which is how the rule language spells one.
const MODE: &str = "i128";

/// The width each half is, which is a register on every target this pass runs for.
const HALF: u32 = 64;

/// How many bytes one half takes in memory, which is how far the high one sits above the low one.
const STEP: u64 = 8;

/// Whether a type is the width this pass splits.
fn is_wide(ty: Type) -> bool {
    ty.is_int() && ty.is_scalar() && ty.bits() == WIDE
}

/// The type each half has.
fn half() -> Type {
    Type::int(HALF)
}

/// Splits every integer the machine holds in two registers into the two halves it holds it in.
///
/// Gives back whether it changed anything, which is what a test asks and what tells a reader of a
/// dump that the function the selector saw is not the one the middle end produced.
///
/// The function is left exactly as it was when there is nothing at that width, when something at
/// that width is reached by an instruction this does not understand, and when a half would cross
/// the function's boundary somewhere the convention has no register for it. All three leave the
/// refusal to the passes below, which name the construct they could not lower, rather than
/// rewriting into something that guessed.
pub fn halves(func: &mut Func, names: &mut Interner, conv: &CallRegs) -> bool {
    if !func.values().any(|value| is_wide(func[value].ty)) {
        return false;
    }
    let insts: Vec<Inst> =
        walk(func).into_iter().flat_map(|block| func.insts(block).collect::<Vec<_>>()).collect();
    let order: HashMap<Inst, usize> =
        insts.iter().enumerate().map(|(at, &inst)| (inst, at)).collect();
    if !insts.iter().enumerate().all(|(at, &inst)| can_split(func, conv, &order, at, inst)) {
        return false;
    }
    let Some(arriving) = plan(func.signature(), conv) else { return false };
    if !func.signatures().all(|signature| plan(signature, conv).is_some()) {
        return false;
    }

    let mut halves: Halves = HashMap::new();
    let mut forward: HashMap<Value, Value> = HashMap::new();
    let entry = func.entry();
    for block in func.blocks().collect::<Vec<_>>() {
        if Some(block) == entry {
            arrive(func, block, &arriving, &mut halves, &mut forward);
        } else {
            params(func, block, &mut halves, &mut forward);
        }
    }
    for &inst in &insts {
        rewrite(func, names, conv, &mut halves, &mut forward, inst);
    }
    substitute(func, &forward);
    let signature = planned(func.signature(), &arriving);
    func.set_signature(signature);
    true
}

/// Every block, in an order where a block comes after everything that dominates it.
///
/// Reverse postorder from the entry, then whatever the walk did not reach, in the order the
/// function holds them. The order is what the rule below about a use and its definition is read
/// against, and the two together are the whole of why this is not simply the order the function
/// holds the blocks in: a value is defined in a block that dominates every block reading it, a
/// dominator is on every path from the entry, so a depth first walk finishes it last and reverse
/// postorder puts it first. The order the function holds blocks in says nothing of the kind. It is
/// the order they were made in, and every pass in the optimizer that makes a block, which is every
/// pass that gives a loop a preheader or copies a header in front of one, puts a block that runs
/// early at the end of that list. So the same program compiled at `-O0` and at `-O1` gave two
/// different answers to whether this pass understood it, and above `-O0` the answer was often no.
/// tamnd/rucc#1054.
///
/// A block nothing reaches cannot be walked to and is put at the end rather than dropped, because
/// deciding a block is unreachable is not this pass's business. Two of them in the wrong order
/// refuse the function the way they always did.
fn walk(func: &Func) -> Vec<Block> {
    let Some(entry) = func.entry() else { return func.blocks().collect() };
    let mut seen: HashSet<Block> = HashSet::new();
    let mut order: Vec<Block> = Vec::new();
    // A postorder without recursion: the second time a block comes off the stack every block below
    // it has been finished, so that is where it belongs in the postorder.
    let mut stack: Vec<(Block, bool)> = vec![(entry, false)];
    seen.insert(entry);
    while let Some((block, done)) = stack.pop() {
        if done {
            order.push(block);
            continue;
        }
        stack.push((block, true));
        let Some(term) = func.terminator(block) else { continue };
        for call in func.successors(term) {
            if seen.insert(call.block) {
                stack.push((call.block, false));
            }
        }
    }
    order.reverse();
    order.extend(func.blocks().filter(|block| !seen.contains(block)));
    order
}

/// The two halves each wide value became, low first.
type Halves = HashMap<Value, (Value, Value)>;

/// The opcodes this pass knows how to split.
///
/// An instruction that touches a value of this width and is not one of these is why the whole
/// function is left alone, so this list is the pass's own statement of what it has thought about.
/// Adding to it is adding an arm to [`rewrite`] as well.
///
/// The four divisions and the four conversions to and from a floating point value are here, and they
/// are the entries that become a call rather than arithmetic over the halves. Which float formats
/// those conversions are understood at is a separate question, asked in [`can_split`], because it is
/// about the type rather than about the opcode.
fn understood(opcode: Opcode) -> bool {
    matches!(
        opcode,
        Opcode::IConst
            | Opcode::Load
            | Opcode::Store
            | Opcode::Add
            | Opcode::Sub
            | Opcode::Mul
            | Opcode::UDiv
            | Opcode::SDiv
            | Opcode::URem
            | Opcode::SRem
            | Opcode::Shl
            | Opcode::LShr
            | Opcode::AShr
            | Opcode::And
            | Opcode::Or
            | Opcode::Xor
            | Opcode::ICmp
            | Opcode::Select
            | Opcode::SIToFP
            | Opcode::UIToFP
            | Opcode::FPToSI
            | Opcode::FPToUI
            | Opcode::Trunc
            | Opcode::SExt
            | Opcode::ZExt
            | Opcode::Call
            | Opcode::CallIndirect
            | Opcode::Return
            | Opcode::Jump
            | Opcode::BrIf
    )
}

/// Whether one instruction is one this pass can split, given where it is in the walk.
///
/// Asked of every instruction, and answered yes at once for the ones that never see a value this
/// wide, which in a function that has one at all is still most of them.
fn can_split(
    func: &Func,
    conv: &CallRegs,
    order: &HashMap<Inst, usize>,
    at: usize,
    inst: Inst,
) -> bool {
    let data = func[inst];
    let reads = operands(func, inst);
    let wide = |&value: &Value| is_wide(func[value].ty);
    if !reads.iter().any(wide) && !data.results().any(|value| is_wide(func[value].ty)) {
        return true;
    }
    if !understood(data.opcode) {
        return false;
    }
    // Memory SSA threads a version of memory through each access, and splitting one access into two
    // makes a version this pass would have to name. Nothing hands this crate a function carrying it
    // today, and leaving one alone costs less than being wrong about it later.
    if func.carries_mem(inst) {
        return false;
    }
    // The machine sign extends from a byte and no narrower, so a truth value widened into the high
    // half would become an instruction with no rule behind it. Zero extending one is fine, which is
    // why only the signed side is asked about.
    if data.opcode == Opcode::SExt && reads.iter().any(|&value| func[value].ty.bits() < 8) {
        return false;
    }
    // The runtime has a conversion for a `float`, for a `double` and for a `_Float128`, and for
    // nothing else, so every other format is refused here rather than turned into a call to a name
    // nothing defines. An eighty bit float is the one a program reaches without asking for it, since
    // `long double` is that type on this target, and it is tamnd/rucc#326 rather than an oversight.
    if matches!(data.opcode, Opcode::SIToFP | Opcode::UIToFP | Opcode::FPToSI | Opcode::FPToUI)
        && converted(func, inst).is_none()
    {
        return false;
    }
    // Splitting an argument makes two of them, and which parameter an argument stands for is how a
    // variadic call knows what the ABI asks of the ones its signature does not name. So a variadic
    // call is laid out as a whole, with the arguments past the `...` named as parameters, and that
    // is only right where naming them changes nothing. On a convention that counts the two files as
    // one run it does, because a float past the `...` goes in both files and one before it does
    // not, and on Apple's AArch64 it does too, because everything past the `...` goes in memory.
    if matches!(data.opcode, Opcode::Call | Opcode::CallIndirect) {
        let Some((site, variadic)) = site(func, inst) else { return false };
        let Some(conv) = conv.under(site.convention) else { return false };
        let in_memory = conv.abi.variadic == Variadic::AlwaysMemory;
        if variadic && (conv.shared_positions || in_memory || plan(&site, conv).is_none()) {
            return false;
        }
    }
    // The halves of a value are written where the value was, so a use this pass reaches before the
    // definition is a use whose halves do not exist yet. A value arriving as a block parameter is
    // always ready, since every block's parameters are split before any instruction is.
    reads.iter().filter(|value| wide(value)).all(|&value| match func[value].def {
        Def::Result { inst, .. } => order.get(&inst).is_some_and(|&def| def < at),
        Def::Param { .. } => true,
    })
}

/// The format of the floating point side of a conversion, when the runtime has a routine for it.
///
/// One float type is in such an instruction, the result of a conversion going up and the operand of
/// one coming down, so both ends are looked at and the one is found. `None` means the function is
/// left alone, and it covers a format with no routine, no float at all, and a float on both ends,
/// which are three shapes that have nothing to be turned into rather than one.
fn converted(func: &Func, inst: Inst) -> Option<Float> {
    let data = func[inst];
    let mut floats = func[data.args]
        .iter()
        .copied()
        .chain(data.results())
        .map(|value| func[value].ty)
        .filter(|ty| ty.is_float());
    let only = floats.next()?;
    if floats.next().is_some() {
        return None;
    }
    match only.format() {
        Some(format @ (Float::F32 | Float::F64 | Float::F128)) => Some(format),
        _ => None,
    }
}

/// Everything an instruction reads: its own operands, and the arguments it passes along its edges.
///
/// The arguments of a `jump` and of a `br_if` hang on the block call rather than on the
/// instruction, so an instruction whose own operands are all narrow may still be handing a wide one
/// to the block it branches to.
fn operands(func: &Func, inst: Inst) -> Vec<Value> {
    let mut reads = func[func[inst].args].to_vec();
    for call in func.successors(inst).collect::<Vec<_>>() {
        reads.extend_from_slice(&func[call.args]);
    }
    reads
}

/// What one parameter of a split signature is.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Slot {
    /// The parameter at that index of the whole signature, which is not wide, as it was.
    Whole(usize),
    /// The low half of the wide parameter at that index.
    Low(usize),
    /// The high half of it.
    High(usize),
    /// A value of that type that carries nothing and is there to take a place nothing else takes.
    Filler(Type),
}

/// The parameters of one signature once every wide one is two halves, in the order that puts each
/// of them where the convention puts the whole signature.
///
/// The walk is the one [`crate::abi::entry`] and [`crate::abi::call`] make, because the answer has
/// to be the one that walk will give: it hands out places in the order the signature holds the
/// parameters. When both halves of every wide parameter land in registers, two halves in a row in
/// the place of the whole take the two registers the whole value would have taken, and the order
/// is the order the signature had.
///
/// When one does not, System V puts the whole value in the argument area as sixteen bytes aligned
/// to sixteen and leaves the registers it did not take to the parameters after it. Two words in a
/// row go somewhere else: the first takes whatever register is left, and a word only has to be
/// aligned to eight. So the order is built from where everything is meant to be rather than from
/// the signature. The ones in general purpose registers come first in register order, then the
/// ones in vector registers, then the ones in the argument area by how far up it they are. A filler
/// takes a register a wide value skipped, since a word of the argument area is only handed out once
/// the registers of its kind have run out, and a filler takes each word the alignment of a wide
/// value leaves empty. The walk is made again over what was built, and anything that did not land
/// where it was meant to is `None`, as is a variadic signature, whose named parameters have to stay
/// in front of the rest, and a convention that counts the two register files as one run, which
/// passes a value this wide some other way.
///
/// A return value is not asked about. What comes back comes back in the registers a return uses,
/// which is a sequence of its own with two in it on this convention, and a signature wanting more
/// than it has is refused by name in [`crate::lower`] already.
///
/// `conv` is the convention of the function being split, and the signature is laid out under the
/// convention it names itself, found through it: a function of one convention calls functions of
/// the other, and each call is laid out the way its callee reads it. A convention the platform
/// does not have is no layout at all, and the function is left alone.
fn plan(signature: &Signature, conv: &CallRegs) -> Option<Vec<Slot>> {
    let conv = conv.under(signature.convention)?;
    let word = Param::new(half());
    let mut places = Places::new(conv);
    let mut meant: Vec<(Slot, Param, Where)> = Vec::new();
    let mut moved = false;
    for (index, &param) in signature.params.iter().enumerate() {
        if !is_wide(param.ty) {
            meant.push((Slot::Whole(index), param, place(&mut places, param, conv)));
            continue;
        }
        let mut ahead = places.clone();
        if let (low @ Where::Reg(_), high @ Where::Reg(_)) =
            (ahead.integer(HALF / 8), ahead.integer(HALF / 8))
        {
            places = ahead;
            meant.push((Slot::Low(index), word, low));
            meant.push((Slot::High(index), word, high));
            continue;
        }
        let Where::Stack(at) = places.on_stack(WIDE / 8, WIDE / 8) else { return None };
        meant.push((Slot::Low(index), word, Where::Stack(at)));
        meant.push((Slot::High(index), word, Where::Stack(at + HALF / 8)));
        moved = true;
    }
    if !moved {
        return Some(meant.into_iter().map(|(slot, _, _)| slot).collect());
    }
    if signature.variadic || conv.shared_positions {
        return None;
    }

    let in_reg = |at: &Where| matches!(at, Where::Reg(_));
    let mut stacked: Vec<&(Slot, Param, Where)> =
        meant.iter().filter(|(_, _, at)| !in_reg(at)).collect();
    stacked.sort_by_key(|(_, _, at)| match at {
        Where::Stack(up) => *up,
        Where::Reg(_) => 0,
    });
    let mut order: Vec<(Slot, Param, Option<Where>)> = Vec::new();
    for float in [false, true] {
        let kind = |param: &Param| scalar(*param) && param.ty.is_float() == float;
        order.extend(
            meant
                .iter()
                .filter(|(_, param, at)| kind(param) && in_reg(at))
                .map(|&(slot, param, at)| (slot, param, Some(at))),
        );
        let (count, filler) = match float {
            false => (conv.int_args.len(), word),
            true => (conv.sse_args.len(), Param::new(Type::float(Float::F64))),
        };
        if stacked.iter().any(|(_, param, _)| kind(param)) {
            let took = order.iter().filter(|(_, param, _)| kind(param)).count();
            let padding = count.saturating_sub(took);
            order.extend((0..padding).map(|_| (Slot::Filler(filler.ty), filler, None)));
        }
    }

    let mut places = Places::new(conv);
    let mut slots = Vec::with_capacity(order.len() + stacked.len());
    for (slot, param, meant) in order {
        let at = place(&mut places, param, conv);
        if !in_reg(&at) || meant.is_some_and(|meant| meant != at) {
            return None;
        }
        slots.push(slot);
    }
    for &&(slot, param, meant) in &stacked {
        let Where::Stack(up) = meant else { return None };
        while places.size() < up {
            if in_reg(&place(&mut places, word, conv)) {
                return None;
            }
            slots.push(Slot::Filler(word.ty));
        }
        if place(&mut places, param, conv) != meant {
            return None;
        }
        slots.push(slot);
    }
    Some(slots)
}

/// Where the next parameter goes, asked the way [`crate::abi::entry`] asks.
fn place(places: &mut Places<'_>, param: Param, conv: &CallRegs) -> Where {
    // A structure the classification put in the argument area, which is the one parameter whose
    // place is bytes rather than a register. Everything else is a value, the pointer an `sret`
    // hands over included, and a value takes the next register of its own kind.
    if let Abi::ByVal { size, align, drains } = param.abi {
        let at = places.object(u32::try_from(size).unwrap_or(u32::MAX), align);
        crate::abi::drain(places, drains);
        at
    } else if crate::abi::on_the_stack(param.ty) {
        let (size, align) = crate::abi::X87_AREA;
        places.on_stack(size, align)
    } else if param.ty.is_float() {
        places.float(crate::abi::float_bytes(param.ty))
    } else {
        places.integer(crate::abi::int_bytes(param.ty, conv))
    }
}

/// Whether a parameter is a value that takes a register of its kind while there is one left.
fn scalar(param: Param) -> bool {
    !matches!(param.abi, Abi::ByVal { .. }) && !crate::abi::on_the_stack(param.ty)
}

/// A signature laid out the way [`plan`] said, with every wide return value as two halves.
fn planned(signature: &Signature, slots: &[Slot]) -> Signature {
    let params = slots
        .iter()
        .map(|&slot| match slot {
            Slot::Whole(index) => signature.params[index],
            Slot::Low(_) | Slot::High(_) => Param::new(half()),
            Slot::Filler(ty) => Param::new(ty),
        })
        .collect();
    Signature { params, ..split_signature(signature) }
}

/// One block's parameters, with each wide one replaced by its two halves in the same position.
///
/// Every parameter of such a block is made again rather than only the wide ones, because a
/// parameter's position is its identity to the branches that feed it and appending is the only way
/// to add one. The narrow ones are made again as themselves and pointed at the copy, which costs
/// nothing once the substitution below has run.
fn params(func: &mut Func, block: Block, halves: &mut Halves, forward: &mut HashMap<Value, Value>) {
    let old: Vec<Value> = func[block].params.clone();
    if !old.iter().any(|&value| is_wide(func[value].ty)) {
        return;
    }
    for &value in &old {
        if is_wide(func[value].ty) {
            let low = func.append_param(block, half());
            let high = func.append_param(block, half());
            halves.insert(value, (low, high));
        } else {
            let again = func.append_param(block, func[value].ty);
            forward.insert(value, again);
        }
    }
    func.retain_params(block, |value| !old.contains(&value));
}

/// The entry block's parameters, laid out the way [`plan`] said the function's own are.
fn arrive(
    func: &mut Func,
    block: Block,
    slots: &[Slot],
    halves: &mut Halves,
    forward: &mut HashMap<Value, Value>,
) {
    let old: Vec<Value> = func[block].params.clone();
    if !old.iter().any(|&value| is_wide(func[value].ty)) {
        return;
    }
    let mut lows = HashMap::new();
    for &slot in slots {
        match slot {
            Slot::Whole(index) => {
                let again = func.append_param(block, func[old[index]].ty);
                forward.insert(old[index], again);
            }
            Slot::Low(index) => {
                lows.insert(index, func.append_param(block, half()));
            }
            Slot::High(index) => {
                let high = func.append_param(block, half());
                halves.insert(old[index], (lows[&index], high));
            }
            Slot::Filler(ty) => {
                func.append_param(block, ty);
            }
        }
    }
    func.retain_params(block, |value| !old.contains(&value));
}

/// One instruction, as instructions over halves.
fn rewrite(
    func: &mut Func,
    names: &mut Interner,
    conv: &CallRegs,
    halves: &mut Halves,
    forward: &mut HashMap<Value, Value>,
    inst: Inst,
) {
    // The runtime's routines are ordinary functions of the platform, whatever convention the
    // function calling them was written in, so a call to one is shaped by the platform's own.
    let abi = conv.under(Convention::Target).unwrap_or(conv).abi;
    let data = func[inst];
    let produces = data.results().any(|value| is_wide(func[value].ty));
    let takes = func[data.args].iter().any(|&value| is_wide(func[value].ty));
    match data.opcode {
        Opcode::IConst if produces => constant(func, halves, inst),
        Opcode::Load if produces => load(func, halves, inst),
        Opcode::Store if takes => store(func, halves, inst),
        Opcode::Add | Opcode::Sub if produces => carried(func, halves, inst, data.opcode),
        Opcode::Mul if produces => multiply(func, halves, inst),
        Opcode::UDiv | Opcode::SDiv | Opcode::URem | Opcode::SRem if produces => {
            divide(func, names, abi, halves, inst, data.opcode);
        }
        Opcode::Shl | Opcode::LShr | Opcode::AShr if produces => {
            shifted(func, halves, inst, data.opcode);
        }
        Opcode::And | Opcode::Or | Opcode::Xor if produces => {
            bitwise(func, halves, inst, data.opcode);
        }
        Opcode::SIToFP | Opcode::UIToFP if takes => {
            to_float(func, names, abi, halves, forward, inst, data.opcode == Opcode::SIToFP);
        }
        Opcode::FPToSI | Opcode::FPToUI if produces => {
            from_float(func, names, abi, halves, inst, data.opcode == Opcode::FPToSI);
        }
        Opcode::ICmp if takes => compare(func, halves, forward, inst),
        Opcode::Select if produces => choose(func, halves, inst),
        Opcode::Trunc if takes => truncate(func, halves, forward, inst),
        Opcode::SExt | Opcode::ZExt if produces => {
            extend(func, halves, inst, data.opcode == Opcode::SExt);
        }
        Opcode::Call | Opcode::CallIndirect if produces || takes => {
            call(func, conv, halves, forward, inst);
        }
        Opcode::Return if takes => flatten(func, halves, inst),
        Opcode::Jump | Opcode::BrIf => edges(func, halves, inst),
        _ => {}
    }
}

/// A constant, as the two halves of its bits with the low one first.
fn constant(func: &mut Func, halves: &mut Halves, inst: Inst) {
    let Extra::Imm(imm) = func[inst].extra else { return };
    let bits = func[imm].unsigned();
    #[expect(clippy::cast_possible_truncation, reason = "the halves are what this is taking")]
    let (low, high) = (bits as u64, (bits >> HALF) as u64);
    let low = ahead_const(func, inst, i128::from(low));
    let high = ahead_const(func, inst, i128::from(high));
    replace(func, halves, inst, low, high);
}

/// A read, as the two words of it with the low one first.
///
/// Little endian is the order, which is what every target this back end has is. The high word knows
/// less about its alignment than the low one when the low one knew more than a word, since a
/// sixteen byte object aligned to sixteen has its high word aligned to eight.
fn load(func: &mut Func, halves: &mut Halves, inst: Inst) {
    let data = func[inst];
    let Extra::Mem(mem) = data.extra else { return };
    let info = func[mem];
    let Some(&from) = func[data.args].first() else { return };
    let low = read(func, inst, from, word(info, 0), data.flags);
    let up = stepped(func, inst, from);
    let high = read(func, inst, up, word(info, STEP), data.flags);
    replace(func, halves, inst, low, high);
}

/// A write, as the two words of it.
fn store(func: &mut Func, halves: &mut Halves, inst: Inst) {
    let data = func[inst];
    let Extra::Mem(mem) = data.extra else { return };
    let info = func[mem];
    let args = func[data.args].to_vec();
    let [value, into] = args[..] else { return };
    let Some(&(low, high)) = halves.get(&value) else { return };
    write(func, inst, low, into, word(info, 0), data.flags);
    let up = stepped(func, inst, into);
    write(func, inst, high, up, word(info, STEP), data.flags);
    func.remove_inst(inst);
}

/// An add or a subtract, as the same over the low halves and the same again over the high ones with
/// what the low halves carried between them.
///
/// The carry is a comparison and not a flag. An unsigned sum comes out below either operand exactly
/// when it wrapped, and an unsigned difference wrapped exactly when the left operand was below the
/// right, which are the two tests [`crate::expand`] writes for the overflow builtins and are what
/// the machine's own carry flag stands for. Whether the pair is put back together into an `adc` and
/// an `sbb` is a question for what reads flags rather than for this, and the answer here is correct
/// either way.
fn carried(func: &mut Func, halves: &mut Halves, inst: Inst, opcode: Opcode) {
    let args = func[func[inst].args].to_vec();
    let [a, b] = args[..] else { return };
    let (Some(&(a_low, a_high)), Some(&(b_low, b_high))) = (halves.get(&a), halves.get(&b)) else {
        return;
    };
    let low = ahead(func, inst, opcode, &[a_low, b_low]);
    let carried = if opcode == Opcode::Add {
        compared(func, inst, IntPred::Ult, low, a_low)
    } else {
        compared(func, inst, IntPred::Ult, a_low, b_low)
    };
    let carry = ahead(func, inst, Opcode::ZExt, &[carried]);
    let high = ahead(func, inst, opcode, &[a_high, b_high]);
    let high = ahead(func, inst, opcode, &[high, carry]);
    replace(func, halves, inst, low, high);
}

/// A multiply, which is long multiplication in base two to the sixty fourth with everything that
/// lands above the width thrown away.
///
/// The low half of the answer is the low halves multiplied together. The high half is what that
/// multiply carried out of its own top, plus the two cross products, each of which starts at bit
/// sixty four. The fourth partial product is the two high halves against each other and it starts
/// at bit one hundred and twenty eight, so the whole of it is above the width and it is never
/// worked out, which is why a wide multiply is three multiplies and not four.
///
/// Nothing here asks whether the operands are signed, because the low hundred and twenty eight bits
/// of a product are the same bits either way. The sign only matters to the bits that are being
/// thrown away.
///
/// The carry out of the low halves is the high half of a sixty four bit product, which this machine
/// has an instruction for and this compiler has no way to ask for. [`crate::expand`] already writes
/// that out as long multiplication one level further down, for the overflow builtins, so this calls
/// it rather than keeping a second copy of the same arithmetic. It is the expensive part of a wide
/// multiply by a long way, and `tamnd/rucc#309` is the rule that would make it one instruction for
/// both callers at once.
fn multiply(func: &mut Func, halves: &mut Halves, inst: Inst) {
    let args = func[func[inst].args].to_vec();
    let [a, b] = args[..] else { return };
    let (Some(&(a_low, a_high)), Some(&(b_low, b_high))) = (halves.get(&a), halves.get(&b)) else {
        return;
    };
    let low = ahead(func, inst, Opcode::Mul, &[a_low, b_low]);
    let carried = expand::high_half(func, inst, a_low, b_low, false, half());
    let cross = ahead(func, inst, Opcode::Mul, &[a_low, b_high]);
    let other = ahead(func, inst, Opcode::Mul, &[a_high, b_low]);
    let high = ahead(func, inst, Opcode::Add, &[carried, cross]);
    let high = ahead(func, inst, Opcode::Add, &[high, other]);
    replace(func, halves, inst, low, high);
}

/// A divide or a remainder, as a call to the routine in the compiler runtime that works it out.
///
/// The four names are libgcc's, and the archive `runtime/builtins/div.c` builds into defines them for
/// a target that has no libgcc, which is every target this compiler links without gcc's driver. What
/// picks one of the four is the opcode and nothing else: the sign is in the name because it is in the
/// answer, since a quotient rounds towards zero and a remainder takes the sign of the dividend, and
/// neither is the unsigned answer with bits reinterpreted the way a sum is.
///
/// The call is created with the halves in it rather than with the wide values, which would then be
/// split by [`call`] on the next instruction of the walk. Four parameters and two results, in the
/// order the operands were in and low half first, because that is where the convention puts the two
/// eightbytes of a value this wide and [`split_signature`] is what the routine's own definition went
/// through on the way in.
///
/// Nothing here is conditional on the divisor. Dividing by zero is undefined in C, the machine traps
/// on it at every width it has, and a test written in front of the call would be this pass deciding
/// what an undefined program does.
fn divide(
    func: &mut Func,
    names: &mut Interner,
    abi: &'static AbiDescription,
    halves: &mut Halves,
    inst: Inst,
    opcode: Opcode,
) {
    let args = func[func[inst].args].to_vec();
    let [a, b] = args[..] else { return };
    let (Some(&(a_low, a_high)), Some(&(b_low, b_high))) = (halves.get(&a), halves.get(&b)) else {
        return;
    };
    // The four that need the whole value at once, which is why they are calls rather than a pair
    // of half width instructions like everything else in this pass. Which call each one is, is in
    // the capability table, since a routine name is a fact about what this target cannot do.
    let Some(routine) = capability::libcall(opcode, MODE) else { return };
    let args = [Operand::Split(a_low, a_high), Operand::Split(b_low, b_high)];
    let made = runtime(func, names, abi, inst, routine, &args, &[half(), half()]);
    let [low, high] = made[..] else { return };
    replace(func, halves, inst, low, high);
}

/// A conversion from one of these to a float, as a call to the routine that works it out.
///
/// Two parameters of sixty four bits and one float result. The answer is not a wide value, so the
/// instruction's own result is pointed at the call's rather than halved, which is what [`compare`]
/// and [`truncate`] do with a narrow answer as well.
///
/// The sign is in the name because it is in the answer: the same hundred and twenty eight bits are
/// two different numbers depending on it, and unlike a sum the float they become is two different
/// floats.
fn to_float(
    func: &mut Func,
    names: &mut Interner,
    abi: &'static AbiDescription,
    halves: &Halves,
    forward: &mut HashMap<Value, Value>,
    inst: Inst,
    signed: bool,
) {
    let Some(&arg) = func[func[inst].args].first() else { return };
    let Some(&(low, high)) = halves.get(&arg) else { return };
    let (Some(result), Some(format)) = (func[inst].first_result, converted(func, inst)) else {
        return;
    };
    let routine = going_up(signed, format);
    let args = [Operand::Split(low, high)];
    let made = runtime(func, names, abi, inst, routine, &args, &[func[result].ty]);
    if let [answer] = made[..] {
        forward.insert(result, answer);
    }
    func.remove_inst(inst);
}

/// A conversion from a float to one of these, as a call to the routine that works it out.
///
/// One float parameter and two results of sixty four bits, which is the divide's shape with the
/// operands and the answer the other way round. The operand is a float and so was never split, and
/// it is passed along as it is.
///
/// A value the integer cannot hold, an infinity and a not a number are all undefined in C, and
/// nothing is written in front of the call about any of them, for the reason [`divide`] writes
/// nothing in front of itself about a zero divisor.
fn from_float(
    func: &mut Func,
    names: &mut Interner,
    abi: &'static AbiDescription,
    halves: &mut Halves,
    inst: Inst,
    signed: bool,
) {
    let Some(&arg) = func[func[inst].args].first() else { return };
    let Some(format) = converted(func, inst) else { return };
    let routine = coming_down(signed, format);
    let args = [Operand::Whole(arg)];
    let made = runtime(func, names, abi, inst, routine, &args, &[half(), half()]);
    let [low, high] = made[..] else { return };
    replace(func, halves, inst, low, high);
}

/// The routine that turns an integer this wide into a float of that format.
///
/// Three formats, since [`converted`] answers with no others, and the quad is the last arm rather
/// than a named one so that a format added to that list arrives here as a routine that does not
/// exist rather than as a name that is wrong.
fn going_up(signed: bool, format: Float) -> &'static str {
    let mode = match format {
        Float::F32 => "i128.f32",
        Float::F64 => "i128.f64",
        _ => "i128.f128",
    };
    routine(if signed { Opcode::SIToFP } else { Opcode::UIToFP }, mode)
}

/// The routine that turns a float of that format into an integer this wide.
fn coming_down(signed: bool, format: Float) -> &'static str {
    let mode = match format {
        Float::F32 => "f32.i128",
        Float::F64 => "f64.i128",
        _ => "f128.i128",
    };
    routine(if signed { Opcode::FPToSI } else { Opcode::FPToUI }, mode)
}

/// The routine the capability table names for this operation at this width.
///
/// Every mode this pass asks about is one this machine has no register wide enough for, so the
/// table always has an answer and a missing one is the table and this pass having gone out of step.
fn routine(opcode: Opcode, mode: &str) -> &'static str {
    capability::libcall(opcode, mode)
        .unwrap_or_else(|| panic!("no routine for `{}` at `{mode}`", opcode.name()))
}

/// One operand of a call to a runtime routine, as this pass has it in hand.
///
/// A wide integer is two halves here because two halves is what this pass has turned every one of
/// them into, and whether the routine is handed the two of them or the address of the one value
/// they are is the convention's answer rather than this pass's.
#[derive(Clone, Copy)]
enum Operand {
    /// A value of a type the machine holds, given as itself.
    Whole(Value),
    /// A wide integer, given as the low half and the high half it became.
    Split(Value, Value),
}

/// A call to a routine in the compiler runtime, written in front of an instruction, with the values
/// it answers.
///
/// Where the convention hands everything over in registers the signature is made out of the types
/// of the values being handed over, because the values are already the halves at this point and the
/// routine's own definition went through [`split_signature`] on the way in, so the two descriptions
/// are the same one arrived at from the two ends.
///
/// Windows x64 does not hand a value of this width over in registers. A scalar of a size no register
/// holds travels as the address of a copy the caller made, which is the rule `tamnd/rucc#1331` put
/// in the ABI description, and it applies to a call this pass writes exactly as it applies to a call
/// the program wrote: libgcc's `__floattitf` on that target reads its `__int128` out of the address
/// in `rdx` and writes its answer through the address in `rcx`. So an operand the convention passes
/// by address becomes a frame slot with a copy of the value in it, a slot per operand because a
/// routine may write through an address it was handed, and a single answer that comes back by
/// address becomes a slot passed as the leading `sret` argument with the load out of it standing for
/// the call's result.
///
/// An answer at this width is the third shape and the one that reads strangely. mingw brings a
/// sixteen byte integer back in `xmm0` rather than through an address, which is gcc's answer to a
/// convention that has no integer that size in it, so the call is written as returning one value at
/// the quad float format and the two halves are read back out of a slot it is stored into. The
/// format is a name for sixteen bytes in a vector register and says nothing about what is in them,
/// which is the same thing the routine's own `movaps` says.
fn runtime(
    func: &mut Func,
    names: &mut Interner,
    abi: &'static AbiDescription,
    inst: Inst,
    routine: &str,
    args: &[Operand],
    results: &[Type],
) -> Vec<Value> {
    let mut params: Vec<Param> = Vec::new();
    let mut values: Vec<Value> = Vec::new();
    let mut answer = Answer::Registers;
    // The answer first, because an address it comes back through is the first argument.
    match *results {
        [ty] if abi.scalar_is_by_reference(bytes(ty)) => {
            let size = bytes(ty);
            let align = align(size);
            let slot = room(func, inst, size, align);
            params.push(Param::with_abi(Type::PTR, Abi::Sret { size, align }));
            values.push(slot);
            answer = Answer::Slot(slot, ty);
        }
        [low, high] if low == half() && high == half() => {
            if let Some(format) = packed(abi) {
                answer = Answer::Packed(format);
            }
        }
        _ => {}
    }
    for &arg in args {
        handed(func, abi, inst, arg, &mut params, &mut values);
    }
    let answers = match answer {
        Answer::Registers => results.to_vec(),
        Answer::Slot(..) => Vec::new(),
        Answer::Packed(format) => vec![Type::float(format)],
    };
    let returns = answers.iter().map(|&ty| Param::new(ty)).collect();
    // The platform's own convention, as the routine is an ordinary function of the platform.
    let signature = func.add_signature(Signature { params, returns, ..Signature::new() });
    let callee = Some(names.intern(routine));
    let varargs = func.push_abis(&[]);
    let extra = Extra::Call(func.add_call(CallInfo { callee, signature, varargs }));
    let pushed = func.push_values(&values);
    let span = func.span(inst);
    let data = InstData { args: pushed, extra, ..InstData::new(Opcode::Call) };
    let made = func.create_inst(data, &answers, span);
    func.insert_before(made, inst);
    match answer {
        Answer::Registers => func[made].results().collect(),
        Answer::Slot(slot, ty) => {
            let size = bytes(ty);
            let info = whole(size, align(size));
            let extra = Extra::Mem(func.add_mem(info));
            let args = func.push_values(&[slot]);
            let data = InstData { args, extra, ..InstData::new(Opcode::Load) };
            vec![written(func, inst, data, ty)]
        }
        Answer::Packed(format) => unpacked(func, inst, made, format),
    }
}

/// Where the answer of such a call is, once the convention has been asked about it.
#[derive(Clone, Copy)]
enum Answer {
    /// In the registers the signature's own result types name, which is every convention that has
    /// registers for a value of the width being asked about.
    Registers,
    /// In a frame slot whose address went over as the leading `sret` argument, with the type the
    /// call was meant to answer with.
    Slot(Value, Type),
    /// Whole in a vector register, at a format that is this many bytes and is not what is in them.
    Packed(Float),
}

/// The format a wide integer answer comes back in on this convention, where it comes back in a
/// register at all, as the IR spells a format.
///
/// [`None`] everywhere but Windows x64. The question is asked of the ABI rather than of the target
/// name for the reason the rest of this pass asks it there: a second list of which targets do this
/// is a list that can disagree with the one the classifier reads.
fn packed(abi: &'static AbiDescription) -> Option<Float> {
    let format = abi.wide_integer_returns_in(u64::from(WIDE / 8))?;
    Float::from_bits(format.width())
}

/// The two halves of an answer that came back whole in a register, read out of a slot it is stored
/// into.
///
/// A store and two loads rather than anything cleverer because the value in hand is at a float
/// format and the halves wanted are integers, and the frame is the only place this compiler moves
/// bits between the two files without saying something about them. It is what gcc writes for the
/// same call.
fn unpacked(func: &mut Func, inst: Inst, call: Inst, format: Float) -> Vec<Value> {
    let Some(value) = func[call].first_result else { return Vec::new() };
    let size = bytes(Type::float(format));
    let align = align(size);
    let slot = room(func, inst, size, align);
    let info = whole(size, align);
    write(func, inst, value, slot, info, Flags::NONE);
    let low = read(func, inst, slot, word(info, 0), Flags::NONE);
    let up = stepped(func, inst, slot);
    let high = read(func, inst, up, word(info, STEP), Flags::NONE);
    vec![low, high]
}

/// One operand of such a call, in the form the convention hands it over in.
fn handed(
    func: &mut Func,
    abi: &'static AbiDescription,
    inst: Inst,
    arg: Operand,
    params: &mut Vec<Param>,
    values: &mut Vec<Value>,
) {
    match arg {
        Operand::Whole(value) => {
            let ty = func[value].ty;
            let size = bytes(ty);
            if !abi.scalar_is_by_reference(size) {
                params.push(Param::new(ty));
                values.push(value);
                return;
            }
            let align = align(size);
            let slot = room(func, inst, size, align);
            write(func, inst, value, slot, whole(size, align), Flags::NONE);
            params.push(Param::new(Type::PTR));
            values.push(slot);
        }
        Operand::Split(low, high) => {
            let size = u64::from(WIDE / 8);
            if !abi.scalar_is_by_reference(size) {
                params.push(Param::new(half()));
                values.push(low);
                params.push(Param::new(half()));
                values.push(high);
                return;
            }
            let align = align(size);
            let slot = room(func, inst, size, align);
            let info = whole(size, align);
            write(func, inst, low, slot, word(info, 0), Flags::NONE);
            let up = stepped(func, inst, slot);
            write(func, inst, high, up, word(info, STEP), Flags::NONE);
            params.push(Param::new(Type::PTR));
            values.push(slot);
        }
    }
}

/// How many bytes a value of this type takes.
fn bytes(ty: Type) -> u64 {
    u64::from(ty.bits().div_ceil(8))
}

/// How far a value of that size is aligned, which at these sizes is the size itself.
fn align(size: u64) -> u32 {
    u32::try_from(size).unwrap_or(u32::MAX)
}

/// An ordinary access of the whole of one value of that size.
fn whole(size: u64, align: u32) -> MemInfo {
    MemInfo {
        size,
        align,
        order: MemOrder::NotAtomic,
        tbaa: None,
        owns: 0,
        restrict: Restrict::NONE,
    }
}

/// A frame slot of that size, written in front of an instruction.
fn room(func: &mut Func, inst: Inst, size: u64, align: u32) -> Value {
    let extra = Extra::Mem(func.add_mem(whole(size, align)));
    written(func, inst, InstData { extra, ..InstData::new(Opcode::Alloca) }, Type::PTR)
}

/// A shift, as each half shifted by the count with the bits that crossed between them put back, and
/// a second answer for a count that reached a whole half.
///
/// A count below sixty four moves each half by the count, and the bits that left one half are the
/// ones that arrive in the other. A count of sixty four or more empties one half completely, and
/// what lands in the other is the first half moved by the count less sixty four. Taking the sixty
/// four bit off a count in range is the same as subtracting sixty four from it, so both cases shift
/// by the same number of places and differ only in which value ends up where, which means one shift
/// each and a choice rather than two of everything. The choice is a `select` and not a branch, for
/// the reason [`choose`] gives.
///
/// The bits that cross move the other way by sixty four less the count. That is a shift of sixty
/// four places when the count is zero, which is not a distance this width has. Moving one place and
/// then sixty three less the count is the same distance for every count from one to sixty three,
/// and for a count of zero it shifts a value whose top bit is already gone all the way down to
/// nothing, which is the right answer: a half that did not move carries nothing into the other one.
///
/// A count of a hundred and twenty eight or more is undefined in C and nothing here goes out of its
/// way about it, the same as at every other width.
fn shifted(func: &mut Func, halves: &mut Halves, inst: Inst, opcode: Opcode) {
    let args = func[func[inst].args].to_vec();
    let [a, b] = args[..] else { return };
    let (Some(&(a_low, a_high)), Some(&(count, _))) = (halves.get(&a), halves.get(&b)) else {
        return;
    };
    let top = ahead_const(func, inst, i128::from(HALF - 1));
    let places = ahead(func, inst, Opcode::And, &[count, top]);
    let back = ahead(func, inst, Opcode::Sub, &[top, places]);
    let one = ahead_const(func, inst, 1);
    let zero = ahead_const(func, inst, 0);
    let bit = ahead_const(func, inst, i128::from(HALF));
    let reach = ahead(func, inst, Opcode::And, &[count, bit]);
    let whole = compared(func, inst, IntPred::Ne, reach, zero);

    let (low, high) = if opcode == Opcode::Shl {
        let moved = ahead(func, inst, Opcode::Shl, &[a_low, places]);
        let edge = ahead(func, inst, Opcode::LShr, &[a_low, one]);
        let across = ahead(func, inst, Opcode::LShr, &[edge, back]);
        let above = ahead(func, inst, Opcode::Shl, &[a_high, places]);
        let joined = ahead(func, inst, Opcode::Or, &[above, across]);
        let low = ahead(func, inst, Opcode::Select, &[whole, zero, moved]);
        let high = ahead(func, inst, Opcode::Select, &[whole, moved, joined]);
        (low, high)
    } else {
        let moved = ahead(func, inst, opcode, &[a_high, places]);
        let edge = ahead(func, inst, Opcode::Shl, &[a_high, one]);
        let across = ahead(func, inst, Opcode::Shl, &[edge, back]);
        let below = ahead(func, inst, Opcode::LShr, &[a_low, places]);
        let joined = ahead(func, inst, Opcode::Or, &[below, across]);
        // What is left behind when the whole low half is gone: zeroes for a logical shift, and for
        // an arithmetic one the sign bit spread over the half it came from.
        let spent = if opcode == Opcode::AShr {
            ahead(func, inst, Opcode::AShr, &[a_high, top])
        } else {
            zero
        };
        let low = ahead(func, inst, Opcode::Select, &[whole, moved, joined]);
        let high = ahead(func, inst, Opcode::Select, &[whole, spent, moved]);
        (low, high)
    };
    replace(func, halves, inst, low, high);
}

/// An `and`, an `or` or an `xor`, which is the same operation on each half and nothing between
/// them.
fn bitwise(func: &mut Func, halves: &mut Halves, inst: Inst, opcode: Opcode) {
    let args = func[func[inst].args].to_vec();
    let [a, b] = args[..] else { return };
    let (Some(&(a_low, a_high)), Some(&(b_low, b_high))) = (halves.get(&a), halves.get(&b)) else {
        return;
    };
    let low = ahead(func, inst, opcode, &[a_low, b_low]);
    let high = ahead(func, inst, opcode, &[a_high, b_high]);
    replace(func, halves, inst, low, high);
}

/// A comparison, which produces one bit and so is pointed at its answer rather than halved.
///
/// An equality is the two halves differing in neither place, which is one `or` over two `xor`s
/// against zero and is shorter than comparing twice and combining. An ordering is the high halves
/// settling it outright, or the low halves settling it when the high halves are equal, and the low
/// halves are compared without a sign because the low half of a signed number is unsigned whatever
/// the number is.
///
/// The high halves are asked a strict question even when the predicate is not strict. A predicate
/// that lets the two be equal is true of two equal high halves whatever the low halves say, and
/// what decides it there is the low halves, so `a >= b` is `a.hi > b.hi` or the high halves being
/// equal and `a.lo >= b.lo` unsigned. Asking `a.hi >= b.hi` instead makes every value with a high
/// half of its own greater than or equal to every other, which is the shape of this that a
/// differential run against GCC caught.
fn compare(func: &mut Func, halves: &Halves, forward: &mut HashMap<Value, Value>, inst: Inst) {
    let Extra::IntPred(pred) = func[inst].extra else { return };
    let args = func[func[inst].args].to_vec();
    let [a, b] = args[..] else { return };
    let (Some(&(a_low, a_high)), Some(&(b_low, b_high))) = (halves.get(&a), halves.get(&b)) else {
        return;
    };
    let answer = if matches!(pred, IntPred::Eq | IntPred::Ne) {
        let low = ahead(func, inst, Opcode::Xor, &[a_low, b_low]);
        let high = ahead(func, inst, Opcode::Xor, &[a_high, b_high]);
        let both = ahead(func, inst, Opcode::Or, &[low, high]);
        let zero = ahead_const(func, inst, 0);
        compared(func, inst, pred, both, zero)
    } else {
        let above = compared(func, inst, strict(pred), a_high, b_high);
        let below = compared(func, inst, unsigned(pred), a_low, b_low);
        let same = compared(func, inst, IntPred::Eq, a_high, b_high);
        let tail = bit(func, inst, Opcode::And, same, below);
        bit(func, inst, Opcode::Or, above, tail)
    };
    if let Some(result) = func[inst].first_result {
        forward.insert(result, answer);
    }
    func.remove_inst(inst);
}

/// The same ordering with the equal case taken out of it, which is what the high halves are asked.
fn strict(pred: IntPred) -> IntPred {
    match pred {
        IntPred::Sle => IntPred::Slt,
        IntPred::Sge => IntPred::Sgt,
        IntPred::Ule => IntPred::Ult,
        IntPred::Uge => IntPred::Ugt,
        other => other,
    }
}

/// The same ordering with no sign in it, which is how the low halves of two signed numbers compare.
fn unsigned(pred: IntPred) -> IntPred {
    match pred {
        IntPred::Slt => IntPred::Ult,
        IntPred::Sle => IntPred::Ule,
        IntPred::Sgt => IntPred::Ugt,
        IntPred::Sge => IntPred::Uge,
        other => other,
    }
}

/// A choice between two wide values, which is the same choice made on each half.
///
/// Two of them rather than one, with the condition read twice. What that costs is one more
/// conditional move, and what the alternative costs is a branch, which is the more expensive of the
/// two on anything that predicts.
fn choose(func: &mut Func, halves: &mut Halves, inst: Inst) {
    let args = func[func[inst].args].to_vec();
    let [cond, then, other] = args[..] else { return };
    let (Some(&(then_low, then_high)), Some(&(other_low, other_high))) =
        (halves.get(&then), halves.get(&other))
    else {
        return;
    };
    let low = ahead(func, inst, Opcode::Select, &[cond, then_low, other_low]);
    let high = ahead(func, inst, Opcode::Select, &[cond, then_high, other_high]);
    replace(func, halves, inst, low, high);
}

/// Keeping the low bits of a wide value, which is the low half and then whatever is left to do.
///
/// Down to sixty four there is nothing left to do and the low half is the answer, so the truncation
/// goes and its readers read the half. Down to anything narrower the machine's own truncation still
/// happens, out of the half rather than out of the value that is no longer there.
fn truncate(func: &mut Func, halves: &Halves, forward: &mut HashMap<Value, Value>, inst: Inst) {
    let Some(&arg) = func[func[inst].args].first() else { return };
    let Some(&(low, _)) = halves.get(&arg) else { return };
    let Some(result) = func[inst].first_result else { return };
    if func[result].ty.bits() == HALF {
        forward.insert(result, low);
        func.remove_inst(inst);
        return;
    }
    becomes(func, inst, Opcode::Trunc, &[low]);
}

/// Widening into a wide value, which is the value in the low half and its own sign or zero above.
fn extend(func: &mut Func, halves: &mut Halves, inst: Inst, signed: bool) {
    let Some(&arg) = func[func[inst].args].first() else { return };
    let low = if func[arg].ty.bits() == HALF {
        arg
    } else {
        let opcode = if signed { Opcode::SExt } else { Opcode::ZExt };
        ahead(func, inst, opcode, &[arg])
    };
    let high = if signed {
        let top = ahead_const(func, inst, i128::from(HALF - 1));
        ahead(func, inst, Opcode::AShr, &[low, top])
    } else {
        ahead_const(func, inst, 0)
    };
    replace(func, halves, inst, low, high);
}

/// A call, as a call passing and receiving halves.
///
/// The instruction is made again rather than edited, because how many values a call gives back is
/// settled when it is created and a wide return value is two where it was one. Its signature is
/// made again for the same reason, since the signature is what each end of the call lays itself out
/// against and both ends are split the same way.
fn call(
    func: &mut Func,
    conv: &CallRegs,
    halves: &mut Halves,
    forward: &mut HashMap<Value, Value>,
    inst: Inst,
) {
    let data = func[inst];
    let Extra::Call(info) = data.extra else { return };
    let info = func[info];
    let Some((whole, variadic)) = site(func, inst) else { return };
    let old = func[data.args].to_vec();
    // An indirect call's first operand is the address it calls, and the arguments come after it.
    let skip = usize::from(data.opcode == Opcode::CallIndirect);
    let Some(slots) = plan(&whole, conv) else { return };
    let mut args = spread(&old[..skip], halves);
    for slot in slots.iter().copied() {
        let value = match slot {
            Slot::Whole(index) => old[skip + index],
            Slot::Low(index) => halves[&old[skip + index]].0,
            Slot::High(index) => halves[&old[skip + index]].1,
            Slot::Filler(ty) if ty.is_float() => {
                let extra = Extra::Imm(func.add_imm(Imm::from_bits(0)));
                written(func, inst, InstData { extra, ..InstData::new(Opcode::FConst) }, ty)
            }
            Slot::Filler(_) => ahead_const(func, inst, 0),
        };
        args.push(value);
    }
    let results: Vec<Type> = data
        .results()
        .map(|value| func[value].ty)
        .flat_map(|ty| if is_wide(ty) { vec![half(), half()] } else { vec![ty] })
        .collect();
    let signature = func.add_signature(planned(&Signature { variadic, ..whole }, &slots));
    // What the ABI asks of each argument past the `...` is on the parameter it became now, so the
    // call names none of them any more and the list it kept that in is empty.
    let varargs = if variadic { func.push_abis(&[]) } else { info.varargs };
    let extra = Extra::Call(func.add_call(CallInfo { signature, varargs, ..info }));
    let args = func.push_values(&args);
    let span = func.span(inst);
    let made = func.create_inst(InstData { args, extra, ..data }, &results, span);
    func.insert_before(made, inst);
    let mut fresh = func[made].results();
    for old in data.results() {
        if is_wide(func[old].ty) {
            let (Some(low), Some(high)) = (fresh.next(), fresh.next()) else { return };
            halves.insert(old, (low, high));
        } else if let Some(again) = fresh.next() {
            forward.insert(old, again);
        }
    }
    func.remove_inst(inst);
}

/// Everything one call passes as the one list of parameters it is laid out as, and whether the
/// callee is variadic.
///
/// A variadic callee's signature names the parameters in front of the `...` and nothing else, and
/// what the ABI asks of each argument behind it is on the call. Here those become parameters too,
/// each with what the call said about it, which is the list the convention lays out anyway: on
/// System V an argument past the `...` goes where it would have gone had it been named, and the
/// one thing the callee is told is how many vector registers were used, which is a count over all
/// of them. The list comes back not variadic so [`plan`] lays it out as a whole, and the flag is
/// handed back beside it for the signature the call is made against.
fn site(func: &Func, inst: Inst) -> Option<(Signature, bool)> {
    let data = func[inst];
    let Extra::Call(info) = data.extra else { return None };
    let info = func[info];
    let mut whole = func[info.signature].clone();
    let skip = usize::from(data.opcode == Opcode::CallIndirect);
    let args = &func[data.args];
    let named = skip + whole.params.len();
    if args.len() < named {
        return None;
    }
    let beyond = &func[info.varargs];
    for (index, &value) in args[named..].iter().enumerate() {
        let abi = beyond.get(index).copied().unwrap_or_default();
        whole.params.push(Param { ty: func[value].ty, abi });
    }
    let variadic = whole.variadic;
    whole.variadic = false;
    Some((whole, variadic))
}

/// A `return`, whose operands are the values the signature says and so are halves now.
fn flatten(func: &mut Func, halves: &Halves, inst: Inst) {
    let args = spread(&func[func[inst].args], halves);
    func[inst].args = func.push_values(&args);
}

/// A branch, whose arguments hang on the edge rather than on the instruction.
fn edges(func: &mut Func, halves: &Halves, inst: Inst) {
    for at in func.target_list(inst).iter() {
        let call = func[at];
        let args = func[call.args].to_vec();
        if !args.iter().any(|value| halves.contains_key(value)) {
            continue;
        }
        let args = func.push_values(&spread(&args, halves));
        func.set_block_call(at, BlockCall { args, ..call });
    }
}

/// A list of values with each wide one replaced by its two halves in the same position.
fn spread(args: &[Value], halves: &Halves) -> Vec<Value> {
    args.iter()
        .flat_map(|value| match halves.get(value) {
            Some(&(low, high)) => vec![low, high],
            None => vec![*value],
        })
        .collect()
}

/// One signature with every wide parameter and return value as two halves in its place.
///
/// Each half is plain. What the ABI asks beyond a type is about the bits above a narrow value and
/// about an object whose address travels, and a half is neither: it is exactly a register wide and
/// it is the value itself.
fn split_signature(signature: &Signature) -> Signature {
    let split = |params: &[Param]| -> Vec<Param> {
        params
            .iter()
            .flat_map(|param| {
                if is_wide(param.ty) {
                    vec![Param::new(half()), Param::new(half())]
                } else {
                    vec![*param]
                }
            })
            .collect()
    };
    Signature {
        params: split(&signature.params),
        returns: split(&signature.returns),
        variadic: signature.variadic,
        convention: signature.convention,
    }
}

/// Records the two halves an instruction became and takes the instruction out.
fn replace(func: &mut Func, halves: &mut Halves, inst: Inst, low: Value, high: Value) {
    if let Some(result) = func[inst].first_result {
        halves.insert(result, (low, high));
    }
    func.remove_inst(inst);
}

/// Points every reader of a value this pass replaced at what replaced it.
///
/// The arguments of each instruction and the arguments of the blocks it branches to, which between
/// them are everywhere a value can be read. Nothing chases, because every value this map answers
/// with is one made here and so is never itself a key.
fn substitute(func: &mut Func, forward: &HashMap<Value, Value>) {
    if forward.is_empty() {
        return;
    }
    let with = |value: Value| forward.get(&value).copied().unwrap_or(value);
    for block in func.blocks().collect::<Vec<_>>() {
        for inst in func.insts(block).collect::<Vec<Inst>>() {
            let args = func[inst].args;
            func.rewrite(args, with);
            for call in func.successors(inst).collect::<Vec<_>>() {
                func.rewrite(call.args, with);
            }
        }
    }
}

/// The access one word of a wide access is, that many bytes into it.
fn word(info: MemInfo, at: u64) -> MemInfo {
    let align = if at == 0 { info.align } else { info.align.min(8) };
    MemInfo { size: STEP, align, ..info }
}

/// The address one word past another, written in front of an instruction.
fn stepped(func: &mut Func, inst: Inst, from: Value) -> Value {
    let step = ahead_const(func, inst, i128::from(STEP));
    let args = func.push_values(&[from, step]);
    written(func, inst, InstData { args, ..InstData::new(Opcode::PtrAdd) }, Type::PTR)
}

/// A load put in front of an instruction, and the half it reads.
fn read(func: &mut Func, inst: Inst, from: Value, info: MemInfo, flags: Flags) -> Value {
    let extra = Extra::Mem(func.add_mem(info));
    let args = func.push_values(&[from]);
    let data = InstData { args, flags, extra, ..InstData::new(Opcode::Load) };
    written(func, inst, data, half())
}

/// A store put in front of an instruction, which produces nothing and is only its effect.
fn write(func: &mut Func, inst: Inst, value: Value, into: Value, info: MemInfo, flags: Flags) {
    let span = func.span(inst);
    let extra = Extra::Mem(func.add_mem(info));
    let args = func.push_values(&[value, into]);
    let data = InstData { args, flags, extra, ..InstData::new(Opcode::Store) };
    let made = func.create_inst(data, &[], span);
    func.insert_before(made, inst);
}

/// A comparison written in front of an instruction, which carries its predicate where everything
/// else carries nothing.
fn compared(func: &mut Func, inst: Inst, pred: IntPred, lhs: Value, rhs: Value) -> Value {
    let args = func.push_values(&[lhs, rhs]);
    let extra = Extra::IntPred(pred);
    written(func, inst, InstData { args, extra, ..InstData::new(Opcode::ICmp) }, Type::I1)
}

/// An `and` or an `or` over two truth values, which is the same instruction at the width of one.
fn bit(func: &mut Func, inst: Inst, opcode: Opcode, lhs: Value, rhs: Value) -> Value {
    let args = func.push_values(&[lhs, rhs]);
    written(func, inst, InstData { args, ..InstData::new(opcode) }, Type::I1)
}

/// An instruction over these operands put in front of another one, producing a half.
fn ahead(func: &mut Func, inst: Inst, opcode: Opcode, args: &[Value]) -> Value {
    let args = func.push_values(args);
    written(func, inst, InstData { args, ..InstData::new(opcode) }, half())
}

/// A constant half put in front of an instruction.
fn ahead_const(func: &mut Func, inst: Inst, value: i128) -> Value {
    let extra = Extra::Imm(func.add_imm(Imm::int(value, half())));
    written(func, inst, InstData { extra, ..InstData::new(Opcode::IConst) }, half())
}

/// Creates the instruction, puts it in front of another, and reads its value back out.
fn written(func: &mut Func, inst: Inst, data: InstData, ty: Type) -> Value {
    let span = func.span(inst);
    let made = func.create_inst(data, &[ty], span);
    func.insert_before(made, inst);
    func[made].first_result.expect("an instruction created with one result has one")
}

/// Turns an instruction into a different one over different operands, in place.
fn becomes(func: &mut Func, inst: Inst, opcode: Opcode, args: &[Value]) {
    let args = func.push_values(args);
    let data = &mut func[inst];
    data.opcode = opcode;
    data.args = args;
    data.extra = Extra::None;
    data.flags = data.flags.intersection(Flags::legal_on(opcode));
}

#[cfg(test)]
mod tests {
    use rucc_base::Interner;
    use rucc_ir::{
        Abi, Block, Builder, Flags, Float, Func, MemOrder, Module, Restrict, Signature, Type, Value,
    };
    use rucc_target::x86_64::{MINGW64, SYSV};
    use rucc_target::{Arch, Env, Os, TargetInfo, Triple};

    use super::{Def, Extra, HALF, IntPred, MemInfo, Opcode, halves};

    /// The width the pass is about, as a type, which is what every test builds with.
    fn wide() -> Type {
        Type::int(super::WIDE)
    }

    fn target() -> TargetInfo {
        TargetInfo::new(Triple::new(Arch::X86_64, Os::Linux, Env::Gnu))
    }

    fn printed(func: &Func, names: &mut Interner) -> String {
        let module = Module::new(names.intern("w.c"), &target());
        rucc_ir::print_func(&module, func, names)
    }

    /// A function of those parameters returning that, with its entry block and its parameters.
    fn shell(names: &mut Interner, params: &[Type], returns: &[Type]) -> (Func, Block, Vec<Value>) {
        let signature = Signature::new().with_params(params).with_returns(returns);
        let mut func = Func::new(names.intern("f"), signature);
        let entry = func.create_block();
        let values = params.iter().map(|&ty| func.append_param(entry, ty)).collect();
        (func, entry, values)
    }

    /// An ordinary access of that many bytes, aligned that far.
    fn info(size: u64, align: u32) -> MemInfo {
        MemInfo {
            size,
            align,
            order: MemOrder::NotAtomic,
            tbaa: None,
            owns: 0,
            restrict: Restrict::NONE,
        }
    }

    #[test]
    fn an_add_carries_from_the_low_half_into_the_high_one() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let sum = build.binary(Opcode::Add, params[0], params[1], Flags::NONE);
        build.ret(&[sum]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(!text.contains("i128"), "nothing that wide is left: {text}");
        // Two adds for the halves, one more for the carry, and the carry itself is the unsigned
        // comparison that says the low half wrapped.
        assert_eq!(text.matches(" = add ").count(), 3, "three adds: {text}");
        assert_eq!(text.matches("icmp ult").count(), 1, "one carry: {text}");
        assert_eq!(text.matches(" = zext.i64 ").count(), 1, "the carry as a number: {text}");
    }

    #[test]
    fn a_subtract_borrows_the_other_way_round() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let difference = build.binary(Opcode::Sub, params[0], params[1], Flags::NONE);
        build.ret(&[difference]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert_eq!(text.matches(" = sub ").count(), 3, "three subtracts: {text}");
        // The borrow is the operands compared, not the answer, which is what tells a reader the
        // two directions were thought about separately.
        assert!(text.contains("icmp ult %0, %2"), "the operands are compared: {text}");
    }

    #[test]
    fn the_signature_and_the_entry_block_say_the_same_thing() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[Type::int(32), wide()], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        build.ret(&[params[1]]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        assert_eq!(
            func.signature().param_types().collect::<Vec<_>>(),
            [Type::int(32), Type::int(HALF), Type::int(HALF)],
            "the wide parameter became two where it stood"
        );
        assert_eq!(
            func.signature().return_types().collect::<Vec<_>>(),
            [Type::int(HALF), Type::int(HALF)],
            "and so did what comes back"
        );
        let text = printed(&func, &mut names);
        assert!(text.contains("block0(%0: i32, %1: i64, %2: i64)"), "the block agrees: {text}");
        assert!(text.contains("return %1, %2"), "both halves go back: {text}");
        let _ = entry;
    }

    #[test]
    fn a_read_takes_the_high_word_a_word_above_the_low_one() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[Type::PTR], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let value = build.load(wide(), params[0], info(16, 16), Flags::NONE);
        build.ret(&[value]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert_eq!(text.matches(" = load.i64 ").count(), 2, "two reads: {text}");
        assert!(text.contains("ptr_add"), "the high word is a word up: {text}");
        // The object is aligned to sixteen and its high word is not, which is the one thing
        // splitting an access can get wrong quietly.
        assert!(text.contains("align 16"), "the low word keeps what the object had: {text}");
        assert!(text.contains("align 8"), "the high word knows less: {text}");
    }

    #[test]
    fn an_equality_asks_once_about_both_halves() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[Type::int(32)]);
        let mut build = Builder::new(&mut func, entry);
        let same = build.icmp(IntPred::Eq, params[0], params[1]);
        let answer = build.unary(Opcode::ZExt, same, Type::int(32));
        build.ret(&[answer]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert_eq!(text.matches("icmp").count(), 1, "one comparison: {text}");
        assert_eq!(text.matches(" = xor ").count(), 2, "the halves differ or they do not: {text}");
    }

    #[test]
    fn an_ordering_reads_the_low_halves_without_a_sign() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[Type::int(32)]);
        let mut build = Builder::new(&mut func, entry);
        let below = build.icmp(IntPred::Slt, params[0], params[1]);
        let answer = build.unary(Opcode::ZExt, below, Type::int(32));
        build.ret(&[answer]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(text.contains("icmp slt"), "the high halves keep the sign: {text}");
        assert!(text.contains("icmp ult"), "the low halves have none: {text}");
        assert!(
            text.contains("icmp eq"),
            "and the low halves only matter when the high tie: {text}"
        );
    }

    /// An ordering that allows the two to be equal still asks the high halves a strict question.
    ///
    /// Two values whose high halves are equal are ordered by their low halves alone, and a high
    /// half that is greater than or equal to the other says nothing about that. Asking the high
    /// halves the predicate as it stands makes every ordering that is not strict answer yes on a
    /// tie, which is the mistake a run against GCC caught.
    #[test]
    fn an_ordering_that_allows_equality_asks_the_high_halves_a_strict_question() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[Type::int(32)]);
        let mut build = Builder::new(&mut func, entry);
        let at_least = build.icmp(IntPred::Sge, params[0], params[1]);
        let answer = build.unary(Opcode::ZExt, at_least, Type::int(32));
        build.ret(&[answer]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(text.contains("icmp sgt"), "the high halves settle it outright: {text}");
        assert!(!text.contains("icmp sge"), "a tie in the high halves settles nothing: {text}");
        assert!(text.contains("icmp uge"), "the low halves are the ones allowed to tie: {text}");
    }

    #[test]
    fn a_widening_puts_the_sign_of_the_value_in_the_high_half() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[Type::int(32)], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let value = build.unary(Opcode::SExt, params[0], wide());
        build.ret(&[value]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(text.contains("sext.i64"), "the value fills the low half: {text}");
        assert!(text.contains("ashr"), "and its sign fills the high one: {text}");
    }

    #[test]
    fn a_block_parameter_becomes_two_and_every_branch_passes_two() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), Type::int(32)], &[wide()]);
        let tail = func.create_block();
        let carried = func.append_param(tail, wide());
        let mut build = Builder::new(&mut func, entry);
        let zero = build.iconst(Type::int(32), 0);
        let taken = build.icmp(IntPred::Ne, params[1], zero);
        let other = build.iconst(wide(), 7);
        build.br_if(taken, tail, &[params[0]], tail, &[other]);
        let mut build = Builder::new(&mut func, tail);
        build.ret(&[carried]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(!text.contains("i128"), "nothing that wide is left: {text}");
        assert!(text.contains("block1(%7: i64, %8: i64)"), "the block takes two: {text}");
        assert_eq!(text.matches("block1(").count(), 3, "and both edges pass two: {text}");
    }

    /// A multiply is the low halves, the two cross products, and nothing for the fourth corner.
    ///
    /// Three at the top, and four more inside the carry out of the low halves, which is a product
    /// at half the width again worked out the same way. What the count is really saying is that the
    /// two high halves are never multiplied together, because the whole of that partial product
    /// lands above the width.
    #[test]
    fn a_multiply_is_three_multiplies_and_the_carry_out_of_the_low_ones() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let product = build.binary(Opcode::Mul, params[0], params[1], Flags::NONE);
        build.ret(&[product]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(!text.contains("i128"), "nothing that wide is left: {text}");
        assert_eq!(text.matches(" = mul ").count(), 7, "three and the carry's four: {text}");
    }

    /// Each of the four divisions becomes a call to the routine of that name in the runtime.
    ///
    /// The sign is in the name because it is in the answer. A quotient rounds towards zero and a
    /// remainder takes the sign of the dividend, so the signed routine and the unsigned one work out
    /// two different numbers, where a wide add is one computation that two signednesses read the
    /// same bits of.
    #[test]
    fn each_of_the_four_divisions_calls_the_routine_of_that_name() {
        for (opcode, routine) in [
            (Opcode::UDiv, "__udivti3"),
            (Opcode::SDiv, "__divti3"),
            (Opcode::URem, "__umodti3"),
            (Opcode::SRem, "__modti3"),
        ] {
            let mut names = Interner::new();
            let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[wide()]);
            let mut build = Builder::new(&mut func, entry);
            let answer = build.binary(opcode, params[0], params[1], Flags::NONE);
            build.ret(&[answer]);

            assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
            let text = printed(&func, &mut names);
            assert!(!text.contains("i128"), "nothing that wide is left: {text}");
            assert!(text.contains(&format!("call @{routine}")), "{routine} is called: {text}");
        }
    }

    /// The call hands over four halves and takes two back, which is the shape of the routine.
    ///
    /// Low half first and the dividend first, which is what the definition of the routine was split
    /// into by the same code on the way in. The operands here are the entry block's parameters, so
    /// the four values the call passes are the four the block now takes, in order.
    #[test]
    fn a_divide_hands_over_four_halves_and_takes_two_back() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let quotient = build.binary(Opcode::UDiv, params[0], params[1], Flags::NONE);
        build.ret(&[quotient]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(text.contains("@__udivti3(%0, %1, %2, %3)"), "four halves go over: {text}");
        assert!(text.contains("return %4, %5"), "and two come back: {text}");
    }

    /// A divide whose operands were worked out in the function calls with the halves of those.
    ///
    /// The other direction of the same rule the walk is for: the call is built where the divide was,
    /// so the halves of a sum computed above it exist by then, and what reaches the routine is the
    /// two values the sum became rather than anything at the old width.
    #[test]
    fn a_divide_of_something_computed_calls_with_the_halves_of_it() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let sum = build.binary(Opcode::Add, params[0], params[1], Flags::NONE);
        let quotient = build.binary(Opcode::SDiv, sum, params[1], Flags::NONE);
        build.ret(&[quotient]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(!text.contains("i128"), "nothing that wide is left: {text}");
        assert_eq!(text.matches(" = add ").count(), 3, "the sum is still a sum: {text}");
        assert_eq!(text.matches("call @__divti3").count(), 1, "one call: {text}");
    }

    /// Each conversion between this width and a float becomes a call to the routine of that name.
    ///
    /// Twelve of them, which is a signed and an unsigned integer against a `float`, a `double` and a
    /// `_Float128` in each direction, and the table is here rather than in a comment because the
    /// names are the whole of what this has to get right.
    #[test]
    fn each_conversion_between_this_width_and_a_float_calls_the_routine_of_that_name() {
        let double = Type::float(Float::F64);
        let single = Type::float(Float::F32);
        let quad = Type::float(Float::F128);
        for (opcode, float, routine) in [
            (Opcode::SIToFP, double, "__floattidf"),
            (Opcode::SIToFP, single, "__floattisf"),
            (Opcode::UIToFP, double, "__floatuntidf"),
            (Opcode::UIToFP, single, "__floatuntisf"),
            (Opcode::SIToFP, quad, "__floattitf"),
            (Opcode::UIToFP, quad, "__floatuntitf"),
        ] {
            let mut names = Interner::new();
            let (mut func, entry, params) = shell(&mut names, &[wide()], &[float]);
            let mut build = Builder::new(&mut func, entry);
            let answer = build.unary(opcode, params[0], float);
            build.ret(&[answer]);

            assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
            let text = printed(&func, &mut names);
            assert!(!text.contains("i128"), "nothing that wide is left: {text}");
            assert!(text.contains(&format!("call @{routine}")), "{routine} is called: {text}");
        }
        for (opcode, float, routine) in [
            (Opcode::FPToSI, double, "__fixdfti"),
            (Opcode::FPToSI, single, "__fixsfti"),
            (Opcode::FPToUI, double, "__fixunsdfti"),
            (Opcode::FPToUI, single, "__fixunssfti"),
            (Opcode::FPToSI, quad, "__fixtfti"),
            (Opcode::FPToUI, quad, "__fixunstfti"),
        ] {
            let mut names = Interner::new();
            let (mut func, entry, params) = shell(&mut names, &[float], &[wide()]);
            let mut build = Builder::new(&mut func, entry);
            let answer = build.unary(opcode, params[0], wide());
            build.ret(&[answer]);

            assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
            let text = printed(&func, &mut names);
            assert!(!text.contains("i128"), "nothing that wide is left: {text}");
            assert!(text.contains(&format!("call @{routine}")), "{routine} is called: {text}");
        }
    }

    /// A conversion up hands over two halves and takes one float back, and one coming down is the
    /// same call the other way round.
    ///
    /// The answer going up is not a wide value, so it is one result and the readers of the
    /// conversion read it, the way they read the answer of a comparison.
    #[test]
    fn a_conversion_hands_over_halves_one_way_and_takes_them_back_the_other() {
        let double = Type::float(Float::F64);
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide()], &[double]);
        let mut build = Builder::new(&mut func, entry);
        let answer = build.unary(Opcode::SIToFP, params[0], double);
        build.ret(&[answer]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(text.contains("@__floattidf(%0, %1)"), "two halves go over: {text}");
        assert!(text.contains("return %2"), "and one float comes back: {text}");

        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[double], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let answer = build.unary(Opcode::FPToSI, params[0], wide());
        build.ret(&[answer]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(text.contains("@__fixdfti(%0)"), "the float goes over as it is: {text}");
        assert!(text.contains("return %1, %2"), "and two halves come back: {text}");
    }

    /// A conversion against a quad is that same shape, with the quad crossing whole.
    ///
    /// Worth its own test because the two sides of it are wide for different reasons. The integer is
    /// a pair here because no register holds a hundred and twenty eight bits of integer, and the
    /// quad is one value because a vector register holds all of it, so the call this pass writes has
    /// two operands and one result going up and one operand and two results coming down.
    #[test]
    fn a_conversion_against_a_quad_hands_over_the_pair_and_the_quad_whole() {
        let quad = Type::float(Float::F128);
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide()], &[quad]);
        let mut build = Builder::new(&mut func, entry);
        let answer = build.unary(Opcode::UIToFP, params[0], quad);
        build.ret(&[answer]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(text.contains("@__floatuntitf(%0, %1)"), "two halves go over: {text}");
        assert!(text.contains("return %2"), "and one quad comes back: {text}");

        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[quad], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let answer = build.unary(Opcode::FPToSI, params[0], wide());
        build.ret(&[answer]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(text.contains("@__fixtfti(%0)"), "the quad goes over as it is: {text}");
        assert!(text.contains("return %1, %2"), "and two halves come back: {text}");
    }

    /// A conversion at a float width the runtime has no routine for leaves the function alone.
    ///
    /// `long double` is the eighty bit float on this target and the runtime has no conversion for
    /// it, because the back end has no register that holds one, which is tamnd/rucc#326. So the
    /// function keeps its wide values and is refused below by name, rather than being turned into a
    /// call to a routine nothing defines.
    #[test]
    fn a_conversion_at_a_width_the_runtime_has_no_routine_for_is_left_alone() {
        let long = Type::float(Float::F80);
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide()], &[long]);
        let mut build = Builder::new(&mut func, entry);
        let answer = build.unary(Opcode::SIToFP, params[0], long);
        build.ret(&[answer]);

        assert!(!halves(&mut func, &mut names, &SYSV), "the pass does not understand this one");
        let text = printed(&func, &mut names);
        assert!(text.contains("i128"), "the width is still there: {text}");
    }

    /// A shift left moves each half and chooses between the count having crossed a half and not.
    ///
    /// Two shifts left, one per half, and the low one does for both cases: a count that reached a
    /// whole half puts exactly that value in the high half and nothing in the low one, so the only
    /// thing the far case needs is the shift the near case already did. Two right shifts carry the
    /// crossing bits, two selects pick a half each, and there is no branch anywhere.
    #[test]
    fn a_shift_left_chooses_between_a_count_that_crossed_a_half_and_one_that_did_not() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let moved = build.binary(Opcode::Shl, params[0], params[1], Flags::NONE);
        build.ret(&[moved]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(!text.contains("i128"), "nothing that wide is left: {text}");
        assert_eq!(
            text.matches(" = shl ").count(),
            2,
            "one per half, and the far case reuses one: {text}"
        );
        assert_eq!(text.matches(" = select.i64 ").count(), 2, "one choice per half: {text}");
        assert_eq!(text.matches(" = lshr ").count(), 2, "the crossing bits, in two steps: {text}");
    }

    /// The bits that cross move one place and then the rest, so a count of zero carries nothing.
    ///
    /// Sixty four less a count of zero is sixty four, which is not a distance a sixty four bit shift
    /// has. One place first and sixty three less the count after is the same distance everywhere the
    /// question is asked, and for a count of zero it moves a value whose top bit has already gone
    /// all the way out, which leaves the zero a half that did not move should carry.
    #[test]
    fn the_bits_that_cross_move_one_place_and_then_the_rest_of_the_way() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let moved = build.binary(Opcode::LShr, params[0], params[1], Flags::NONE);
        build.ret(&[moved]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(text.contains("iconst.i64 63"), "sixty three is the distance left: {text}");
        assert!(text.contains("iconst.i64 1"), "after the one place that comes first: {text}");
        assert!(text.contains(" = sub "), "the rest of the way is worked out: {text}");
        assert!(
            !text.contains("iconst.i64 127"),
            "and the count is not masked to the width: {text}"
        );
    }

    /// An arithmetic shift right leaves the sign bit behind where a logical one leaves zeroes.
    ///
    /// What the two differ in is only the half the count moved out of entirely. A logical shift puts
    /// zeroes there, which is a constant already in hand, and an arithmetic one puts the sign bit
    /// spread across the half it came from, which is one more shift.
    #[test]
    fn an_arithmetic_shift_right_leaves_the_sign_bit_where_a_logical_one_leaves_zeroes() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let moved = build.binary(Opcode::AShr, params[0], params[1], Flags::NONE);
        build.ret(&[moved]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(!text.contains("i128"), "nothing that wide is left: {text}");
        // The high half by the count, and the high half by sixty three for the half left empty.
        assert_eq!(text.matches(" = ashr ").count(), 2, "the count and the sign: {text}");
        assert_eq!(text.matches(" = lshr ").count(), 1, "the low half is not signed: {text}");
        assert_eq!(text.matches(" = select.i64 ").count(), 2, "one choice per half: {text}");
    }

    /// A wide parameter that gets no register pair, as the function's own parameter.
    ///
    /// The whole value goes in the argument area and the register it could not use stays empty,
    /// so the split signature has a filler where that register is and the two halves after it.
    /// What the function reads from the low half is the parameter the filler is followed by.
    fn arrived(params: &[Type], wide_at: usize) -> (Signature, usize) {
        let mut names = Interner::new();
        let word = Type::int(HALF);
        let (mut func, entry, values) = shell(&mut names, params, &[word]);
        let mut build = Builder::new(&mut func, entry);
        let low = build.unary(Opcode::Trunc, values[wide_at], word);
        build.ret(&[low]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let ret = func.insts(entry).last().expect("the block ends in a return");
        let read = func[func[ret].args][0];
        let at = func[entry].params.iter().position(|&value| value == read);
        (func.signature().clone(), at.expect("the low half is a parameter"))
    }

    fn types(signature: &Signature) -> Vec<Type> {
        signature.params.iter().map(|param| param.ty).collect()
    }

    #[test]
    fn a_parameter_with_one_register_left_goes_in_memory_and_the_register_stays_empty() {
        let word = Type::int(HALF);
        let (signature, low) = arrived(&[word, word, word, word, word, wide()], 5);
        assert_eq!(types(&signature), vec![word; 8], "five, a filler and two halves");
        assert_eq!(low, 6, "the halves come after the register the value skipped");
    }

    #[test]
    fn the_register_a_wide_parameter_skipped_goes_to_the_parameter_after_it() {
        let word = Type::int(HALF);
        let (signature, low) = arrived(&[word, word, word, word, word, wide(), word], 5);
        assert_eq!(types(&signature), vec![word; 8], "six registers and two words, no filler");
        assert_eq!(low, 6, "the word after the wide value took the sixth register");
    }

    #[test]
    fn a_wide_parameter_in_memory_starts_on_a_sixteen_byte_boundary() {
        let word = Type::int(HALF);
        let params = [word, word, word, word, word, word, word, wide()];
        let (signature, low) = arrived(&params, 7);
        assert_eq!(types(&signature), vec![word; 10], "the seventh word, a filler, the halves");
        assert_eq!(low, 8, "the filler takes the word the alignment leaves empty");
    }

    /// The same layout on the calling side, with a constant in the place of the filler.
    #[test]
    fn a_call_passes_a_wide_argument_in_memory_the_way_the_callee_reads_it() {
        let mut names = Interner::new();
        let word = Type::int(HALF);
        let (mut func, entry, _) = shell(&mut names, &[], &[]);
        let callee = names.intern("g");
        let params = [word, word, word, word, word, wide()];
        let signature = func.add_signature(Signature::new().with_params(&params));
        let mut build = Builder::new(&mut func, entry);
        let one = build.iconst(word, 1);
        let big = build.iconst(wide(), 4);
        build.call(callee, signature, &[one, one, one, one, one, big]);
        build.ret(&[]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let call = func.insts(entry).find(|&inst| func[inst].opcode == Opcode::Call);
        let call = call.expect("the call is still there");
        let Extra::Call(info) = func[call].extra else { unreachable!("a call has call info") };
        let passed = func[func[call].args].to_vec();
        assert_eq!(types(&func[func[info].signature]), vec![word; 8], "as the callee has it");
        assert_eq!(passed.len(), 8, "one argument for each parameter");
        assert_eq!(passed[..5], [one; 5], "the words keep their registers");
        let constant = |value: Value| {
            let Def::Result { inst, .. } = func[value].def else { return None };
            let Extra::Imm(imm) = func[inst].extra else { return None };
            Some(func[imm].unsigned())
        };
        assert_eq!(constant(passed[6]), Some(4), "the low half is the first word in memory");
        assert_eq!(constant(passed[7]), Some(0), "and the high half the second");
    }

    /// A variadic callee's named parameters have to stay in front of the rest, so a wide one that
    /// would go in memory is still refused there, by leaving the function as it was.
    #[test]
    fn a_variadic_call_with_a_wide_argument_in_memory_leaves_the_function_alone() {
        let mut names = Interner::new();
        let word = Type::int(HALF);
        let (mut func, entry, _) = shell(&mut names, &[], &[]);
        let callee = names.intern("g");
        let params = [word, word, word, word, word, wide()];
        let signature = Signature { variadic: true, ..Signature::new().with_params(&params) };
        let signature = func.add_signature(signature);
        let mut build = Builder::new(&mut func, entry);
        let one = build.iconst(word, 1);
        let big = build.iconst(wide(), 4);
        build.call(callee, signature, &[one, one, one, one, one, big]);
        build.ret(&[]);
        let before = printed(&func, &mut names);

        assert!(!halves(&mut func, &mut names, &SYSV), "the named parameters cannot move");
        assert_eq!(printed(&func, &mut names), before, "so nothing moved");
    }

    /// A wide argument past the `...` is laid out as if it had been named, which is what System V
    /// does with it, and the call names every argument afterwards so the list of what the ABI asks
    /// of the unnamed ones is empty.
    #[test]
    fn a_wide_argument_past_the_dots_goes_where_a_named_one_would() {
        let mut names = Interner::new();
        let word = Type::int(HALF);
        let (mut func, entry, _) = shell(&mut names, &[], &[]);
        let callee = names.intern("g");
        let params = [word, word, word, word, word];
        let signature = Signature { variadic: true, ..Signature::new().with_params(&params) };
        let signature = func.add_signature(signature);
        let mut build = Builder::new(&mut func, entry);
        let one = build.iconst(word, 1);
        let big = build.iconst(wide(), 4);
        build.call_varargs(callee, signature, &[one, one, one, one, one, big], &[Abi::Plain]);
        build.ret(&[]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let call = func.insts(entry).find(|&inst| func[inst].opcode == Opcode::Call);
        let call = call.expect("the call is still there");
        let Extra::Call(info) = func[call].extra else { unreachable!("a call has call info") };
        let made = &func[func[info].signature];
        assert!(made.variadic, "the callee is still variadic");
        assert_eq!(types(made), vec![word; 8], "five words, a filler and the two halves");
        assert!(func[func[info].varargs].is_empty(), "every argument is named now");
        assert_eq!(func[func[call].args].len(), 8, "one argument for each parameter");
    }

    /// The same call on a convention that counts both files as one run is left alone, because
    /// naming a float past the `...` there changes which registers it goes in.
    #[test]
    fn a_wide_argument_past_the_dots_on_windows_leaves_the_function_alone() {
        let mut names = Interner::new();
        let word = Type::int(HALF);
        let (mut func, entry, _) = shell(&mut names, &[], &[]);
        let callee = names.intern("g");
        let signature = Signature { variadic: true, ..Signature::new().with_params(&[word]) };
        let signature = func.add_signature(signature);
        let mut build = Builder::new(&mut func, entry);
        let one = build.iconst(word, 1);
        let big = build.iconst(wide(), 4);
        build.call_varargs(callee, signature, &[one, big], &[Abi::Plain]);
        build.ret(&[]);

        assert!(!halves(&mut func, &mut names, &MINGW64), "the call is left for a refusal");
    }

    /// The order the function holds its blocks in is not the order they run in.
    ///
    /// This is what the optimizer produced and `-O0` did not. A block that runs early is made late
    /// by whichever pass needed it, so the list the function keeps had a use of a wide value in it
    /// before the instruction defining that value, and the walk that asks whether every definition
    /// comes first said no and left the whole function alone. Then the selector met an instruction
    /// at a width it has no register for and refused the program. The blocks here are made in the
    /// order that produces, which is the tail before the middle. tamnd/rucc#1054.
    #[test]
    fn a_block_made_after_the_one_it_runs_before_is_still_split() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide()], &[wide()]);
        let tail = func.create_block();
        let middle = func.create_block();
        let mut build = Builder::new(&mut func, entry);
        build.jump(middle, &[]);
        let mut build = Builder::new(&mut func, middle);
        let doubled = build.binary(Opcode::Add, params[0], params[0], Flags::NONE);
        build.jump(tail, &[]);
        let mut build = Builder::new(&mut func, tail);
        let again = build.binary(Opcode::Add, doubled, doubled, Flags::NONE);
        build.ret(&[again]);

        assert!(
            halves(&mut func, &mut names, &SYSV),
            "the definition runs before the use whatever the list says"
        );
        let text = printed(&func, &mut names);
        assert!(!text.contains("i128"), "nothing that wide is left: {text}");
    }

    #[test]
    fn a_function_with_nothing_that_wide_is_not_touched() {
        let mut names = Interner::new();
        let word = Type::int(HALF);
        let (mut func, entry, params) = shell(&mut names, &[word, word], &[word]);
        let mut build = Builder::new(&mut func, entry);
        let sum = build.binary(Opcode::Add, params[0], params[1], Flags::NONE);
        build.ret(&[sum]);

        assert!(!halves(&mut func, &mut names, &SYSV), "there is nothing to split");
    }

    /// The operands of a runtime call go over the way the target's convention passes them.
    ///
    /// Windows x64 passes a scalar of a size no register holds as the address of a copy the caller
    /// made, so libgcc's `__floattitf` there reads its integer out of the address in `rdx` and
    /// writes its answer through the address in `rcx`. Handing it two halves in registers instead is
    /// not a worse encoding of the same call, it is a routine reading registers nothing was put in.
    #[test]
    fn on_windows_a_wide_operand_goes_over_as_the_address_of_a_copy() {
        let mut names = Interner::new();
        let quad = Type::float(Float::F64);
        let (mut func, entry, params) = shell(&mut names, &[wide()], &[quad]);
        let mut build = Builder::new(&mut func, entry);
        let answer = build.unary(Opcode::SIToFP, params[0], quad);
        build.ret(&[answer]);

        assert!(halves(&mut func, &mut names, &MINGW64), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(text.contains("call @__floattidf"), "{text}");
        // One slot with the two halves written into it, and the address of it is the argument.
        assert_eq!(text.matches("alloca").count(), 1, "one slot: {text}");
        assert_eq!(text.matches("store").count(), 2, "a half at a time: {text}");
        assert_eq!(text.matches("ptr_add").count(), 1, "the high half eight bytes up: {text}");
        assert!(!text.contains("__floattidf(%0, %1)"), "not the two halves: {text}");
    }

    /// An answer the convention brings back through an address is the leading argument.
    #[test]
    fn on_windows_a_wide_answer_at_this_format_comes_back_through_a_slot() {
        let mut names = Interner::new();
        let quad = Type::float(Float::F128);
        let (mut func, entry, params) = shell(&mut names, &[wide()], &[quad]);
        let mut build = Builder::new(&mut func, entry);
        let answer = build.unary(Opcode::SIToFP, params[0], quad);
        build.ret(&[answer]);

        assert!(halves(&mut func, &mut names, &MINGW64), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(text.contains("call @__floattitf"), "{text}");
        // The slot for the answer and the slot for the operand.
        assert_eq!(text.matches("alloca").count(), 2, "two slots: {text}");
        assert_eq!(text.matches(" = call").count(), 0, "the call answers nothing: {text}");
        assert_eq!(text.matches(" = load").count(), 1, "the answer is the load after it: {text}");
    }

    /// The convention that hands the halves over in registers is left exactly as it was.
    #[test]
    fn the_convention_with_registers_for_both_halves_puts_nothing_on_the_frame() {
        let mut names = Interner::new();
        let double = Type::float(Float::F64);
        let (mut func, entry, params) = shell(&mut names, &[wide()], &[double]);
        let mut build = Builder::new(&mut func, entry);
        let answer = build.unary(Opcode::SIToFP, params[0], double);
        build.ret(&[answer]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(text.contains("@__floattidf(%0, %1)"), "both halves in registers: {text}");
        assert!(!text.contains("alloca"), "nothing goes through the frame: {text}");
    }

    /// An answer at this width on Windows, which comes back whole in a vector register and is taken
    /// apart through a slot rather than read out of two of them.
    #[test]
    fn on_windows_a_wide_answer_comes_back_in_one_register_and_is_split_on_the_frame() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let answer = build.binary(Opcode::SDiv, params[0], params[1], Flags::NONE);
        build.ret(&[answer]);

        assert!(halves(&mut func, &mut names, &MINGW64), "there is a width to split");
        let text = printed(&func, &mut names);
        // The call answers one value and it is at the quad format, which is the name this compiler
        // has for sixteen bytes in a vector register.
        assert!(text.contains("call @__divti3(%4, %7) : (ptr, ptr) -> f128"), "{text}");
        assert_eq!(text.matches(" = call").count(), 1, "one answer: {text}");
        // Two slots for the two operands and one more to take the answer apart in.
        assert_eq!(text.matches("alloca").count(), 3, "three slots: {text}");
        assert_eq!(text.matches(" = load").count(), 2, "the two halves: {text}");
    }

    /// The same division where the convention has a pair of registers for the answer.
    #[test]
    fn the_convention_with_registers_for_the_answer_reads_both_halves_out_of_them() {
        let mut names = Interner::new();
        let (mut func, entry, params) = shell(&mut names, &[wide(), wide()], &[wide()]);
        let mut build = Builder::new(&mut func, entry);
        let answer = build.binary(Opcode::SDiv, params[0], params[1], Flags::NONE);
        build.ret(&[answer]);

        assert!(halves(&mut func, &mut names, &SYSV), "there is a width to split");
        let text = printed(&func, &mut names);
        assert!(text.contains("@__divti3(%0, %1, %2, %3)"), "four halves over: {text}");
        assert!(!text.contains("alloca"), "nothing goes through the frame: {text}");
    }
}