Struct TargetDataLayout 

pub struct TargetDataLayout {

    pub endian: Endian,
    pub i1_align: Align,
    pub i8_align: Align,
    pub i16_align: Align,
    pub i32_align: Align,
    pub i64_align: Align,
    pub i128_align: Align,
    pub f16_align: Align,
    pub f32_align: Align,
    pub f64_align: Align,
    pub f128_align: Align,
    pub aggregate_align: Align,
    pub vector_align: Vec<(Size, Align)>,
    pub default_address_space: AddressSpace,
    pub default_address_space_pointer_spec: PointerSpec,
    pub(crate) address_space_info: Vec<(AddressSpace, PointerSpec)>,
    pub instruction_address_space: AddressSpace,
    pub c_enum_min_size: Integer,
}

Parsed Data layout for a target, which contains everything needed to compute layouts.

Fields

endian: Endian

i1_align: Align

i8_align: Align

i16_align: Align

i32_align: Align

i64_align: Align

i128_align: Align

f16_align: Align

f32_align: Align

f64_align: Align

f128_align: Align

aggregate_align: Align

vector_align: Vec<(Size, Align)>

Alignments for vector types.

default_address_space: AddressSpace

default_address_space_pointer_spec: PointerSpec

address_space_info: Vec<(AddressSpace, PointerSpec)>

Address space information of all known address spaces.

Note

This vector does not contain the PointerSpec relative to the default address space, which instead lives in Self::default_address_space_pointer_spec.

instruction_address_space: AddressSpace

c_enum_min_size: Integer

Minimum size of #[repr(C)] enums (default c_int::BITS, usually 32) Note: This isn’t in LLVM’s data layout string, it is short_enum so the only valid spec for LLVM is c_int::BITS or 8

Implementations

impl TargetDataLayout

pub fn parse_from_llvm_datalayout_string<'a>( input: &'a str, default_address_space: AddressSpace, ) -> Result<TargetDataLayout, TargetDataLayoutErrors<'a>>

Parse data layout from an llvm data layout string

This function doesn’t fill c_enum_min_size and it will always be I32 since it can not be determined from llvm string.

pub fn obj_size_bound(&self) -> u64

Returns exclusive upper bound on object size in bytes, in the default data address space.

The theoretical maximum object size is defined as the maximum positive isize value. This ensures that the offset semantics remain well-defined by allowing it to correctly index every address within an object along with one byte past the end, along with allowing isize to store the difference between any two pointers into an object.

LLVM uses a 64-bit integer to represent object size in bits, but we care only for bytes, so we adopt such a more-constrained size bound due to its technical limitations.

pub fn obj_size_bound_in(&self, address_space: AddressSpace) -> u64

Returns exclusive upper bound on object size in bytes.

The theoretical maximum object size is defined as the maximum positive isize value. This ensures that the offset semantics remain well-defined by allowing it to correctly index every address within an object along with one byte past the end, along with allowing isize to store the difference between any two pointers into an object.

LLVM uses a 64-bit integer to represent object size in bits, but we care only for bytes, so we adopt such a more-constrained size bound due to its technical limitations.

pub fn ptr_sized_integer(&self) -> Integer

pub fn ptr_sized_integer_in(&self, address_space: AddressSpace) -> Integer

pub(crate) fn cabi_vector_align(&self, vec_size: Size) -> Option<Align>

psABI-mandated alignment for a vector type, if any

pub fn llvmlike_vector_align(&self, vec_size: Size) -> Align

an alignment resembling the one LLVM would pick for a vector

pub fn pointer_size(&self) -> Size

Get the pointer size in the default data address space.

pub fn pointer_size_in(&self, c: AddressSpace) -> Size

Get the pointer size in a specific address space.

pub fn pointer_offset(&self) -> Size

Get the pointer index in the default data address space.

pub fn pointer_offset_in(&self, c: AddressSpace) -> Size

Get the pointer index in a specific address space.

pub fn pointer_align(&self) -> AbiAlign

Get the pointer alignment in the default data address space.

pub fn pointer_align_in(&self, c: AddressSpace) -> AbiAlign

Get the pointer alignment in a specific address space.

Trait Implementations

impl Debug for TargetDataLayout

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

Formats the value using the given formatter.

impl Default for TargetDataLayout

fn default() -> TargetDataLayout

Creates an instance of TargetDataLayout.

impl HasDataLayout for &TargetDataLayout

fn data_layout(&self) -> &TargetDataLayout

impl HasDataLayout for TargetDataLayout

fn data_layout(&self) -> &TargetDataLayout

impl PartialEq for TargetDataLayout

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for TargetDataLayout

impl StructuralPartialEq for TargetDataLayout

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: 96 bytes