Method new

src/debug_utils/generic_function/arbitrary.rs:161–215

Initializes the `FunctionBuilder`.

(u: &'a mut Unstructured<'b>, reginfo: &'a R, config: ArbitraryFunctionConfig)

impl<'a, 'b, R: RegInfo> FunctionBuilder<'a, 'b, R> {
    /// Initializes the `FunctionBuilder`.
    fn new(u: &'a mut Unstructured<'b>, reginfo: &'a R, config: ArbitraryFunctionConfig) -> Self {
        let func = GenericFunction {
            entry_points: vec![],
            blocks: PrimaryMap::new(),
            insts: PrimaryMap::new(),
            values: PrimaryMap::new(),
            value_groups: PrimaryMap::new(),
        };

        let mut class_per_bank: SecondaryMap<RegBank, Vec<RegClass>> =
            SecondaryMap::with_max_index(reginfo.num_banks());
        let mut remat_class_per_bank: SecondaryMap<RegBank, Vec<RegClass>> =
            SecondaryMap::with_max_index(reginfo.num_banks());
        let mut reg_per_bank: SecondaryMap<RegBank, Vec<PhysReg>> =
            SecondaryMap::with_max_index(reginfo.num_banks());
        let mut non_allocatable_regs = vec![];
        for class in reginfo.classes() {
            class_per_bank[reginfo.bank_for_class(class)].push(class);
            if reginfo.class_group_size(class) == 1
                && !reginfo.allocation_order(class).is_empty()
                && (reginfo.class_includes_spillslots(class)
                    || reginfo
                        .class_members(class)
                        .into_iter()
                        .all(|reg| !reginfo.is_memory(reg)))
            {
                remat_class_per_bank[reginfo.bank_for_class(class)].push(class);
            }
        }
        for reg in reginfo.regs() {
            if let Some(bank) = reginfo.bank_for_reg(reg) {
                reg_per_bank[bank].push(reg);
            } else {
                non_allocatable_regs.push(reg);
            }
        }

        Self {
            u,
            reginfo,
            func,
            config,
            domtree: DominatorTree::new(),
            block_insts: SecondaryMap::new(),
            class_per_bank,
            remat_class_per_bank,
            reg_per_bank,
            non_allocatable_regs,
            defs_by_blocks: SecondaryMap::new(),
            use_candidates: vec![],
            early_fixed: RegUnitSet::new(),
            late_fixed: RegUnitSet::new(),
            reuse_operands: vec![],
        }
    }

    /// Generates a reasonable block frequency.
    fn block_frequency(&mut self) -> Result<f32> {