Enum rustc_mir::interpret::Scalar

pub enum Scalar<Tag = ()> {
    Raw {
        data: u128,
        size: u8,
    },
    Ptr(Pointer<Tag>),
}

A Scalar represents an immediate, primitive value existing outside of a memory::Allocation. It is in many ways like a small chunk of a Allocation, up to 8 bytes in size. Like a range of bytes in an Allocation, a Scalar can either represent the raw bytes of a simple value or a pointer into another Allocation

Variants

Raw

The raw bytes of a simple value.

Fields of Raw

data: u128

The first size bytes of data are the value. Do not try to read less or more bytes than that. The remaining bytes must be 0.

size: u8

Ptr(Pointer<Tag>)

A pointer into an Allocation. An Allocation in the memory module has a list of relocations, but a Scalar is only large enough to contain one, so we just represent the relocation and its associated offset together as a Pointer here.

Implementations

impl Scalar<()>

pub fn with_tag<Tag>(self, new_tag: Tag) -> Scalar<Tag>

Tag this scalar with new_tag if it is a pointer, leave it unchanged otherwise.

Used by MemPlace::replace_tag.

impl<'tcx, Tag> Scalar<Tag>

pub fn erase_tag(self) -> Scalar<()>

Erase the tag from the scalar, if any.

Used by error reporting code to avoid having the error type depend on Tag.

pub fn null_ptr(cx: &impl HasDataLayout) -> Scalar<Tag>

pub fn zst() -> Scalar<Tag>

pub fn ptr_offset(
    self,
    i: Size,
    cx: &impl HasDataLayout
) -> Result<Scalar<Tag>, InterpErrorInfo<'tcx>>

pub fn ptr_wrapping_offset(
    self,
    i: Size,
    cx: &impl HasDataLayout
) -> Scalar<Tag>

pub fn ptr_signed_offset(
    self,
    i: i64,
    cx: &impl HasDataLayout
) -> Result<Scalar<Tag>, InterpErrorInfo<'tcx>>

pub fn ptr_wrapping_signed_offset(
    self,
    i: i64,
    cx: &impl HasDataLayout
) -> Scalar<Tag>

pub fn from_bool(b: bool) -> Scalar<Tag>

pub fn from_char(c: char) -> Scalar<Tag>

pub fn try_from_uint(i: impl Into<u128>, size: Size) -> Option<Scalar<Tag>>

pub fn from_uint(i: impl Into<u128>, size: Size) -> Scalar<Tag>

pub fn from_u8(i: u8) -> Scalar<Tag>

pub fn from_u16(i: u16) -> Scalar<Tag>

pub fn from_u32(i: u32) -> Scalar<Tag>

pub fn from_u64(i: u64) -> Scalar<Tag>

pub fn from_machine_usize(i: u64, cx: &impl HasDataLayout) -> Scalar<Tag>

pub fn try_from_int(i: impl Into<i128>, size: Size) -> Option<Scalar<Tag>>

pub fn from_int(i: impl Into<i128>, size: Size) -> Scalar<Tag>

pub fn from_i8(i: i8) -> Scalar<Tag>

pub fn from_i16(i: i16) -> Scalar<Tag>

pub fn from_i32(i: i32) -> Scalar<Tag>

pub fn from_i64(i: i64) -> Scalar<Tag>

pub fn from_machine_isize(i: i64, cx: &impl HasDataLayout) -> Scalar<Tag>

pub fn from_f32(f: IeeeFloat<SingleS>) -> Scalar<Tag>

pub fn from_f64(f: IeeeFloat<DoubleS>) -> Scalar<Tag>

pub fn to_bits_or_ptr(
    self,
    target_size: Size,
    cx: &impl HasDataLayout
) -> Result<u128, Pointer<Tag>>

This is very rarely the method you want! You should dispatch on the type and use force_bits/assert_bits/force_ptr/assert_ptr. This method only exists for the benefit of low-level memory operations as well as the implementation of the force_* methods.

pub fn assert_bits(self, target_size: Size) -> u128

pub fn assert_ptr(self) -> Pointer<Tag>

pub fn is_bits(self) -> bool

Do not call this method! Dispatch based on the type instead.

pub fn is_ptr(self) -> bool

Do not call this method! Dispatch based on the type instead.

pub fn to_bool(self) -> Result<bool, InterpErrorInfo<'tcx>>

pub fn to_char(self) -> Result<char, InterpErrorInfo<'tcx>>

pub fn to_u8(self) -> Result<u8, InterpErrorInfo<'static>>

Converts the scalar to produce an u8. Fails if the scalar is a pointer.

pub fn to_u16(self) -> Result<u16, InterpErrorInfo<'static>>

Converts the scalar to produce an u16. Fails if the scalar is a pointer.

pub fn to_u32(self) -> Result<u32, InterpErrorInfo<'static>>

Converts the scalar to produce an u32. Fails if the scalar is a pointer.

pub fn to_u64(self) -> Result<u64, InterpErrorInfo<'static>>

Converts the scalar to produce an u64. Fails if the scalar is a pointer.

pub fn to_machine_usize(
    self,
    cx: &impl HasDataLayout
) -> Result<u64, InterpErrorInfo<'static>>

pub fn to_i8(self) -> Result<i8, InterpErrorInfo<'static>>

Converts the scalar to produce an i8. Fails if the scalar is a pointer.

pub fn to_i16(self) -> Result<i16, InterpErrorInfo<'static>>

Converts the scalar to produce an i16. Fails if the scalar is a pointer.

pub fn to_i32(self) -> Result<i32, InterpErrorInfo<'static>>

Converts the scalar to produce an i32. Fails if the scalar is a pointer.

pub fn to_i64(self) -> Result<i64, InterpErrorInfo<'static>>

Converts the scalar to produce an i64. Fails if the scalar is a pointer.

pub fn to_machine_isize(
    self,
    cx: &impl HasDataLayout
) -> Result<i64, InterpErrorInfo<'static>>

pub fn to_f32(self) -> Result<IeeeFloat<SingleS>, InterpErrorInfo<'static>>

pub fn to_f64(self) -> Result<IeeeFloat<DoubleS>, InterpErrorInfo<'static>>

Trait Implementations

impl<Tag> Clone for Scalar<Tag> where
    Tag: Clone, 

fn clone(&self) -> Scalar<Tag>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Tag> Copy for Scalar<Tag> where
    Tag: Copy, 

impl<Tag> Debug for Scalar<Tag> where
    Tag: Debug, 

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

Formats the value using the given formatter.

impl<Tag> Display for Scalar<Tag> where
    Tag: Debug, 

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

Formats the value using the given formatter.

impl<Tag> Eq for Scalar<Tag> where
    Tag: Eq, 

impl<Tag> From<IeeeFloat<DoubleS>> for Scalar<Tag>

fn from(f: IeeeFloat<DoubleS>) -> Scalar<Tag>

Performs the conversion.

impl<Tag> From<IeeeFloat<SingleS>> for Scalar<Tag>

fn from(f: IeeeFloat<SingleS>) -> Scalar<Tag>

Performs the conversion.

impl<Tag> From<Pointer<Tag>> for Scalar<Tag>

fn from(ptr: Pointer<Tag>) -> Scalar<Tag>

Performs the conversion.

impl<Tag> From<Scalar<Tag>> for ScalarMaybeUninit<Tag>

fn from(s: Scalar<Tag>) -> ScalarMaybeUninit<Tag>

Performs the conversion.

impl<Tag> From<Scalar<Tag>> for Immediate<Tag>

fn from(val: Scalar<Tag>) -> Self

Performs the conversion.

impl<Tag> Hash for Scalar<Tag> where
    Tag: Hash, 

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<Tag> Ord for Scalar<Tag> where
    Tag: Ord, 

fn cmp(&self, other: &Scalar<Tag>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<Tag> PartialEq<Scalar<Tag>> for Scalar<Tag> where
    Tag: PartialEq<Tag>, 

fn eq(&self, other: &Scalar<Tag>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Scalar<Tag>) -> bool

This method tests for !=.

impl<Tag> PartialOrd<Scalar<Tag>> for Scalar<Tag> where
    Tag: PartialOrd<Tag>, 

fn partial_cmp(&self, other: &Scalar<Tag>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Scalar<Tag>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Scalar<Tag>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Scalar<Tag>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Scalar<Tag>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.