Enum OperandKind

src/function.rs:219–275

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum OperandKind {
    /// A write of a `Value`.
    ///
    /// The SSA property requires that each `Value` only be defined in a single
    /// place in the entire function.
    Def(Value),

    /// A read of a `Value`.
    Use(Value),

    /// An "early" write of a `Value`.
    ///
    /// Normally, the same `PhysReg` may be assigned to a `Use` and a `Def`
    /// operand because these are assumed to have non-overlapping live ranges.
    /// To avoid this, an `EarlyDef` operand can be used. It is identical to a
    /// `Def` except that it is guaranteed not to conflict with any input
    /// operand.
    ///
    /// `EarlyDef` is primarily useful for pseudo-instructions that expand to
    /// multiple instruction after register allocation. In such sequences, an
    /// output or scratch register may need to be written to before all input
    /// registers have been read.
    EarlyDef(Value),

    /// A write of a group of `Value`s.
    ///
    /// This is analogous to [`OperandKind::Def`] but requires that the
    /// corresponding constraint use an [`OperandConstraint::Class`] with a
    /// register class that has same group size as the [`ValueGroup`].
    DefGroup(ValueGroup),

    /// A read of a group of `Value`s.
    ///
    /// This is analogous to [`OperandKind::Use`] but requires that the
    /// corresponding constraint use an [`OperandConstraint::Class`] with a
    /// register class that has same group size as the [`ValueGroup`].
    UseGroup(ValueGroup),

    /// An "early" write of a group of `Value`s.
    ///
    /// This is analogous to [`OperandKind::EarlyDef`] but requires that the
    /// corresponding constraint use an [`OperandConstraint::Class`] with a
    /// register class that has same group size as the [`ValueGroup`].
    EarlyDefGroup(ValueGroup),

    /// Use of a fixed non-allocatable register.
    ///
    /// This must be used with `OperandConstraint::Fixed`. The given `PhysReg`
    /// is directly assigned to the operand without tracking its live range for
    /// checking interferences.
    ///
    /// This is intended for use with reserved registers that are manually
    /// managed by the client such as the stack pointer or a hardware zero
    /// register. It must not be used with a `PhysReg` that is part of an
    /// allocatable register class.
    NonAllocatable,
}