Method fold_unary_negative

crates/codegen/src/ir.rs:653–705

Fold LOAD_CONST/LOAD_SMALL_INT + UNARY_NEGATIVE → LOAD_CONST (negative value)

(&mut self)

    /// Fold LOAD_CONST/LOAD_SMALL_INT + UNARY_NEGATIVE → LOAD_CONST (negative value)
    fn fold_unary_negative(&mut self) {
        for block in &mut self.blocks {
            let mut i = 0;
            while i + 1 < block.instructions.len() {
                let next = &block.instructions[i + 1];
                let Some(Instruction::UnaryNegative) = next.instr.real() else {
                    i += 1;
                    continue;
                };
                let curr = &block.instructions[i];
                let value = match curr.instr.real() {
                    Some(Instruction::LoadConst { .. }) => {
                        let idx = u32::from(curr.arg) as usize;
                        match self.metadata.consts.get_index(idx) {
                            Some(ConstantData::Integer { value }) => {
                                Some(ConstantData::Integer { value: -value })
                            }
                            Some(ConstantData::Float { value }) => {
                                Some(ConstantData::Float { value: -value })
                            }
                            _ => None,
                        }
                    }
                    Some(Instruction::LoadSmallInt { .. }) => {
                        let v = u32::from(curr.arg) as i32;
                        Some(ConstantData::Integer {
                            value: BigInt::from(-v),
                        })
                    }
                    _ => None,
                };
                if let Some(neg_const) = value {
                    let (const_idx, _) = self.metadata.consts.insert_full(neg_const);
                    // Replace LOAD_CONST/LOAD_SMALL_INT with new LOAD_CONST
                    let load_location = block.instructions[i].location;
                    block.instructions[i].instr = Instruction::LoadConst {
                        consti: Arg::marker(),
                    }
                    .into();
                    block.instructions[i].arg = OpArg::new(const_idx as u32);
                    // Replace UNARY_NEGATIVE with NOP, inheriting the LOAD_CONST
                    // location so that remove_nops can clean it up
                    block.instructions[i + 1].instr = Instruction::Nop.into();
                    block.instructions[i + 1].location = load_location;
                    block.instructions[i + 1].end_location = block.instructions[i].end_location;
                    // Skip the NOP, don't re-check
                    i += 2;
                } else {
                    i += 1;
                }
            }
        }
    }

    /// Constant folding: fold LOAD_CONST/LOAD_SMALL_INT + LOAD_CONST/LOAD_SMALL_INT + BINARY_OP
    /// into a single LOAD_CONST when the result is computable at compile time.