pub type Layout = LayoutData<RustcFieldIdx, RustcEnumVariantIdx>;Aliased Type§
struct Layout {
pub fields: FieldsShape<RustcFieldIdx>,
pub variants: Variants<RustcFieldIdx, RustcEnumVariantIdx>,
pub backend_repr: BackendRepr,
pub largest_niche: Option<Niche>,
pub uninhabited: bool,
pub align: AbiAndPrefAlign,
pub size: Size,
pub max_repr_align: Option<Align>,
pub unadjusted_abi_align: Align,
pub randomization_seed: Hash64,
}Fields§
§fields: FieldsShape<RustcFieldIdx>Says where the fields are located within the layout.
variants: Variants<RustcFieldIdx, RustcEnumVariantIdx>Encodes information about multi-variant layouts.
Even with Multiple variants, a layout still has its own fields! Those are then
shared between all variants. One of them will be the discriminant,
but e.g. coroutines can have more.
To access all fields of this layout, both fields and the fields of the active variant
must be taken into account.
backend_repr: BackendReprThe backend_repr defines how this data will be represented to the codegen backend,
and encodes value restrictions via valid_range.
Note that this is entirely orthogonal to the recursive structure defined by
variants and fields; for example, ManuallyDrop<Result<isize, isize>> has
IrForm::ScalarPair! So, even with non-Memory backend_repr, fields and variants
have to be taken into account to find all fields of this layout.
largest_niche: Option<Niche>The leaf scalar with the largest number of invalid values
(i.e. outside of its valid_range), if it exists.
uninhabited: boolIs this type known to be uninhabted?
This is separate from BackendRepr because uninhabited return types can affect ABI, especially in the case of by-pointer struct returns, which allocate stack even when unused.
align: AbiAndPrefAlign§size: Size§max_repr_align: Option<Align>The largest alignment explicitly requested with repr(align) on this type or any field.
Only used on i686-windows, where the argument passing ABI is different when alignment is
requested, even if the requested alignment is equal to the natural alignment.
unadjusted_abi_align: AlignThe alignment the type would have, ignoring any repr(align) but including repr(packed).
Only used on aarch64-linux, where the argument passing ABI ignores the requested alignment
in some cases.
randomization_seed: Hash64The randomization seed based on this type’s own repr and its fields.
Since randomization is toggled on a per-crate basis even crates that do not have randomization enabled should still calculate a seed so that downstream uses can use it to distinguish different types.
For every T and U for which we do not guarantee that a repr(Rust) Foo<T> can be coerced or
transmuted to Foo<U> we aim to create probalistically distinct seeds so that Foo can choose
to reorder its fields based on that information. The current implementation is a conservative
approximation of this goal.
Implementations
§impl<FieldIdx, VariantIdx> LayoutData<FieldIdx, VariantIdx>where
FieldIdx: Idx,
VariantIdx: Idx,
impl<FieldIdx, VariantIdx> LayoutData<FieldIdx, VariantIdx>where
FieldIdx: Idx,
VariantIdx: Idx,
pub fn is_aggregate(&self) -> bool
pub fn is_aggregate(&self) -> bool
Returns true if this is an aggregate type (including a ScalarPair!)
pub fn is_uninhabited(&self) -> bool
pub fn is_uninhabited(&self) -> bool
Returns true if this is an uninhabited type
§impl<FieldIdx, VariantIdx> LayoutData<FieldIdx, VariantIdx>where
FieldIdx: Idx,
VariantIdx: Idx,
impl<FieldIdx, VariantIdx> LayoutData<FieldIdx, VariantIdx>where
FieldIdx: Idx,
VariantIdx: Idx,
pub fn is_unsized(&self) -> bool
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_1zst(&self) -> bool
pub fn is_1zst(&self) -> bool
Returns true if the type is sized and a 1-ZST (meaning it has size 0 and alignment 1).
pub fn is_zst(&self) -> bool
pub fn is_zst(&self) -> bool
Returns true if the type is a ZST and not unsized.
Note that this does not imply that the type is irrelevant for layout! It can still have
non-trivial alignment constraints. You probably want to use is_1zst instead.
pub fn eq_abi(&self, other: &LayoutData<FieldIdx, VariantIdx>) -> bool
pub fn eq_abi(&self, other: &LayoutData<FieldIdx, VariantIdx>) -> bool
Checks if these two Layout are equal enough to be considered “the same for all function
call ABIs”. Note however that real ABIs depend on more details that are not reflected in the
Layout; the PassMode need to be compared as well. Also note that we assume
aggregates are passed via PassMode::Indirect or PassMode::Cast; more strict
checks would otherwise be required.
§impl<FieldIdx, VariantIdx> LayoutData<FieldIdx, VariantIdx>where
FieldIdx: Idx,
VariantIdx: Idx,
“Simple” layout constructors that cannot fail.
impl<FieldIdx, VariantIdx> LayoutData<FieldIdx, VariantIdx>where
FieldIdx: Idx,
VariantIdx: Idx,
“Simple” layout constructors that cannot fail.
pub fn unit<C>(cx: &C, sized: bool) -> LayoutData<FieldIdx, VariantIdx>where
C: HasDataLayout,
pub fn never_type<C>(cx: &C) -> LayoutData<FieldIdx, VariantIdx>where
C: HasDataLayout,
pub fn scalar<C>(cx: &C, scalar: Scalar) -> LayoutData<FieldIdx, VariantIdx>where
C: HasDataLayout,
pub fn scalar_pair<C>(
cx: &C,
a: Scalar,
b: Scalar,
) -> LayoutData<FieldIdx, VariantIdx>where
C: HasDataLayout,
pub fn uninhabited_variant<C>(
cx: &C,
index: VariantIdx,
fields: usize,
) -> LayoutData<FieldIdx, VariantIdx>where
C: HasDataLayout,
pub fn uninhabited_variant<C>(
cx: &C,
index: VariantIdx,
fields: usize,
) -> LayoutData<FieldIdx, VariantIdx>where
C: HasDataLayout,
Returns a dummy layout for an uninhabited variant.
Uninhabited variants get pruned as part of the layout calculation, so this can be used after the fact to reconstitute a layout.