Method gen_block_insts

src/debug_utils/generic_function/arbitrary.rs:371–435

Generate the contents of a basic block. This should be called in CFG post-order so that uses come before definitions.

(&mut self, block: Block)

    /// This should be called in CFG post-order so that uses come before
    /// definitions.
    fn gen_block_insts(&mut self, block: Block) -> Result<()> {
        // We generate instructions in reverse, starting with the terminator.
        // This allows us to know exactly what values need to be defined later.
        let mut num_insts = self.u.int_in_range(self.config.insts_per_block.clone())?;

        // Set up outgoing blockparams if we have a single successor that itself
        // has multiple predecessors.
        if let [succ] = self.func.blocks[block].succs[..] {
            if self.func.blocks[succ].preds.len() > 1 {
                for idx in 0..self.func.blocks[succ].block_params_in.len() {
                    let bank = self.func.values[self.func.blocks[succ].block_params_in[idx]].bank;
                    // It's fine if this adds defs to the current block, we will
                    // increase num_insts below to ensure these have a defining
                    // instruction.
                    let value = self.get_value_for_use(bank, block, false)?;
                    self.func.blocks[block].block_params_out.push(value);
                }

                // Our terminator cannot have operands. Create an empty
                // terminator now before adding any instructions.
                self.block_insts[block].push(InstData {
                    operands: vec![],
                    clobbers: vec![],
                    block,
                    terminator_kind: Some(TerminatorKind::Jump),
                    is_pure: false,
                });

                // If there are values that need to be defined in this block for
                // outgoing blockparams, make sure it has at least one
                // instruction.
                if num_insts == 0 && !self.defs_by_blocks[block].is_empty() {
                    num_insts = 1;
                }
            }
        }

        // We need a terminator instruction if an empty one wasn't created
        // above. This one is allowed to have operands like a normal
        // instruction.
        if self.block_insts[block].is_empty() {
            let is_ret = self.func.blocks[block].succs.is_empty();
            let mut terminator = self.gen_inst(block, num_insts == 0, is_ret)?;
            terminator.is_pure = false;
            terminator.terminator_kind = Some(if is_ret {
                TerminatorKind::Ret
            } else {
                TerminatorKind::Branch
            });
            self.block_insts[block].push(terminator);
        }

        // Generate a sequence of instructions in the block.
        for idx in 0..num_insts {
            // If this is the last instruction we generate (i.e. the first one
            // in the block) then we need to ensure all definitions assigned to
            // this block are actually processed.
            let inst = self.gen_inst(block, idx == num_insts - 1, false)?;