Method arbitrary

fuzz/fuzz_targets/parallel_moves.rs:117–235

(u: &mut Unstructured)

impl Arbitrary<'_> for TestCase {
    fn arbitrary(u: &mut Unstructured) -> Result<Self> {
        // Ensure the logger is initialized.
        let _ = pretty_env_logger::try_init();

        let reginfo = reginfo(u)?;

        // Generate values for move sources.
        let mut src_used_mask = RegUnitSet::new();
        let mut spillslots = PrimaryMap::new();
        let mut values = PrimaryMap::new();
        let mut slots_per_bank: SecondaryMap<RegBank, Vec<SpillSlot>> =
            SecondaryMap::with_max_index(reginfo.num_banks());
        for _ in 0..u.int_in_range(1..=20)? {
            let mut gen_alloc = || {
                // Try to get a register if it doesn't overlap an existing one.
                if u.arbitrary()? {
                    let reg = PhysReg::new(u.choose_index(reginfo.num_regs())?);
                    if reginfo
                        .reg_units(reg)
                        .all(|unit| !src_used_mask.contains(unit))
                    {
                        reginfo
                            .reg_units(reg)
                            .for_each(|unit| src_used_mask.insert(unit));
                        let bank = reginfo.bank_for_reg(reg).unwrap();
                        return Ok((Some(Allocation::reg(reg)), bank));
                    }
                }

                // Otherwise get a spillslot or force a rematerialization.
                let bank = RegBank::new(u.choose_index(reginfo.num_banks())?);
                if u.arbitrary()? {
                    Ok((None, bank))
                } else {
                    let spillslot = spillslots.push(reginfo.spillslot_size(bank));
                    slots_per_bank[bank].push(spillslot);
                    Ok((Some(Allocation::spillslot(spillslot)), bank))
                }
            };

            let (alloc, bank) = gen_alloc()?;
            let remat = if alloc.is_none() || u.arbitrary()? {
                let cost = if u.arbitrary()? {
                    RematCost::CheaperThanMove
                } else {
                    RematCost::CheaperThanLoad
                };
                let remat_classes: Vec<_> = reginfo
                    .classes()
                    .filter(|&class| {
                        reginfo.bank_for_class(class) == bank
                            && reginfo.class_group_size(class) == 1
                            && (reginfo.class_includes_spillslots(class)
                                || reginfo
                                    .class_members(class)
                                    .into_iter()
                                    .all(|reg| !reginfo.is_memory(reg)))
                    })