Enum BackendRepr 

pub enum BackendRepr {
    Scalar(Scalar),
    ScalarPair {
        a: Scalar,
        b: Scalar,
        b_offset: Size,
    },
    SimdScalableVector {
        element: Scalar,
        count: u64,
        number_of_vectors: NumScalableVectors,
    },
    SimdVector {
        element: Scalar,
        count: u64,
    },
    Memory {
        sized: bool,
    },
}

The way we represent values to the backend

Previously this was conflated with the “ABI” a type is given, as in the platform-specific ABI. In reality, this implies little about that, but is mostly used to describe the syntactic form emitted for the backend, as most backends handle SSA values and blobs of memory differently. The psABI may need consideration in doing so, but this enum does not constitute a promise for how the value will be lowered to the calling convention, in itself.

Generally, a codegen backend will prefer to handle smaller values as a scalar or short vector, and larger values will usually prefer to be represented as memory.

Variants

Scalar(Scalar)

ScalarPair

The data contained in this type can be entirely represented by two scalars. The two scalars are listed in memory order, so a is at offset zero and b is at non-zero offset b_offset. These need not be FieldIdx(0) and FieldIdx(1).

As of June 2026 the b_offset is always the size of the a scalar rounded up to the platform alignment of the b scalar. That may soon change, however; see MCP#1007.

Fields

a: Scalar

b: Scalar

b_offset: Size

SimdScalableVector

Fields

element: Scalar

count: u64

number_of_vectors: NumScalableVectors

SimdVector

Fields

element: Scalar

count: u64

Memory

Fields

sized: bool

If true, the size is exact, otherwise it’s only a lower bound.

Implementations

impl BackendRepr

pub fn is_unsized(&self) -> bool

Returns true if the layout corresponds to an unsized type.

pub fn is_sized(&self) -> bool

pub fn is_signed(&self) -> bool

Returns true if this is a single signed integer scalar. Sanity check: panics if this is not a scalar type (see PR #70189).

pub fn is_scalar(&self) -> bool

Returns true if this is specifically a Self::Scalar type.

This excludes SIMD types.

pub fn is_scalar_or_simd(&self) -> bool

Returns true if this is a scalar type or SIMD type.

pub fn is_bool(&self) -> bool

Returns true if this is a bool

pub fn scalar_platform_align<C: HasDataLayout>(&self, cx: &C) -> Option<Align>

The psABI alignment for a Scalar or ScalarPair

None for other variants.

It’s unclear whether this is a meaningful operation, and MCP#1007 proposes changes. You should generally be using the alignment of the place or the type, not calculating something from the Scalars.

pub fn scalar_size<C: HasDataLayout>(&self, cx: &C) -> Option<Size>

The psABI size for a Scalar or ScalarPair

None for other variants

pub fn to_union(&self) -> Self

Discard validity range information and allow undef.

pub fn eq_up_to_validity(&self, other: &Self) -> bool

Trait Implementations

impl Clone for BackendRepr

fn clone(&self) -> BackendRepr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for BackendRepr

impl Debug for BackendRepr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for BackendRepr

impl Hash for BackendRepr

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BackendRepr

fn eq(&self, other: &BackendRepr) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StableHash for BackendRepr

fn stable_hash<__Hcx: StableHashCtxt>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher, )

impl StructuralPartialEq for BackendRepr

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 112 bytes

Size for each variant:

• Scalar: 64 bytes
• ScalarPair: 112 bytes
• SimdScalableVector: 80 bytes
• SimdVector: 80 bytes
• Memory: 5 bytes