Method alloc

cranelift/codegen/src/machinst/vcode.rs:1716–1751

Allocate a fresh ValueRegs.

(&mut self, ty: Type)

    /// Allocate a fresh ValueRegs.
    pub fn alloc(&mut self, ty: Type) -> CodegenResult<ValueRegs<Reg>> {
        if self.deferred_error.is_some() {
            return Err(CodegenError::CodeTooLarge);
        }
        let v = self.vreg_types.len();
        let (regclasses, tys) = I::rc_for_type(ty)?;

        // Check that new indices are in-bounds for regalloc2's
        // VReg/Operand representation.
        if v + regclasses.len() > VReg::MAX {
            return Err(CodegenError::CodeTooLarge);
        }

        // Check that new indices are in-bounds for our Reg
        // bit-packing on top of the RA2 types, which represents
        // spillslots as well.
        let check = |vreg: regalloc2::VReg| -> CodegenResult<Reg> {
            Reg::from_virtual_reg_checked(vreg).ok_or(CodegenError::CodeTooLarge)
        };

        let regs: ValueRegs<Reg> = match regclasses {
            &[rc0] => ValueRegs::one(check(VReg::new(v, rc0))?),
            &[rc0, rc1] => ValueRegs::two(check(VReg::new(v, rc0))?, check(VReg::new(v + 1, rc1))?),
            // We can extend this if/when we support 32-bit targets; e.g.,
            // an i128 on a 32-bit machine will need up to four machine regs
            // for a `Value`.
            _ => panic!("Value must reside in 1 or 2 registers"),
        };
        for (&reg_ty, &reg) in tys.iter().zip(regs.regs().iter()) {
            let vreg = reg.to_virtual_reg().unwrap();
            debug_assert_eq!(self.vreg_types.len(), vreg.index());
            self.vreg_types.push(reg_ty);
        }

        Ok(regs)
    }

    /// Allocate a fresh ValueRegs, deferring any out-of-vregs
    /// errors. This is useful in places where we cannot bubble a