Value in rustc_middle::queries::valtree_to_const_val - Rust
Description: API documentation for the Rust `Value` type in crate `rustc_middle`.

Skip to main content

## Value

# Type Alias Value

Source

    pub type Value<'tcx> = ConstValue;

## Aliased Type§

    pub enum Value<'tcx> {
        Scalar(Scalar),
        ZeroSized,
        Slice {
            alloc_id: AllocId,
            meta: u64,
        },
        Indirect {
            alloc_id: AllocId,
            offset: Size,
        },
    }

## Variants§

§

### Scalar(Scalar)

Used for types with `layout::abi::Scalar` ABI.

Not using the enum `Value` to encode that this must not be `Uninit`.

§

### ZeroSized

Only for ZSTs.

§

### Slice

Used for references to unsized types with slice tail.

This is worth an optimized representation since Rust has literals of type `&str` and `&[u8]`. Not having to indirect those through an `AllocId` (or two, if we used `Indirect`) has shown measurable performance improvements on stress tests. We then reuse this optimization for slice-tail types more generally during valtree-to-constval conversion.

#### Fields

§`alloc_id: AllocId`

The allocation storing the slice contents. This always points to the beginning of the allocation.

§`meta: u64`

The metadata field of the reference. This is a “target usize”, so we use `u64` as in the interpreter.

§

### Indirect

A value not representable by the other variants; needs to be stored in-memory.

Must not be used for scalars or ZST, but having `&str` or other slices in this variant is fine.

#### Fields

§`alloc_id: AllocId`

The backing memory of the value. May contain more memory than needed for just the value if this points into some other larger ConstValue.

We use an `AllocId` here instead of a `ConstAllocation<'tcx>` to make sure that when a raw constant (which is basically just an `AllocId`) is turned into a `ConstValue` and back, we can preserve the original `AllocId`.

§`offset: Size`

Offset into `alloc`

## 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: 24 bytes

Size for each variant:

- `Scalar`: 24 bytes
- `ZeroSized`: 0 bytes
- `Slice`: 24 bytes
- `Indirect`: 24 bytes