pub struct LayoutS<FieldIdx: Idx, VariantIdx: Idx> {
pub fields: FieldsShape<FieldIdx>,
pub variants: Variants<FieldIdx, VariantIdx>,
pub abi: Abi,
pub largest_niche: Option<Niche>,
pub align: AbiAndPrefAlign,
pub size: Size,
pub max_repr_align: Option<Align>,
pub unadjusted_abi_align: Align,
}
Fields§
§fields: FieldsShape<FieldIdx>
Says where the fields are located within the layout.
variants: Variants<FieldIdx, VariantIdx>
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.
abi: Abi
The abi
defines how this data is passed between functions, and it defines
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
Abi::ScalarPair
! So, even with non-Aggregate
abi
, 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.
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: Align
The 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.
Implementations§
source§impl<FieldIdx: Idx, VariantIdx: Idx> LayoutS<FieldIdx, VariantIdx>
impl<FieldIdx: Idx, VariantIdx: Idx> LayoutS<FieldIdx, VariantIdx>
pub fn scalar<C: HasDataLayout>(cx: &C, scalar: Scalar) -> Self
source§impl<FieldIdx: Idx, VariantIdx: Idx> LayoutS<FieldIdx, VariantIdx>
impl<FieldIdx: Idx, VariantIdx: Idx> LayoutS<FieldIdx, VariantIdx>
sourcepub 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
sourcepub 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).
sourcepub 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.
sourcepub fn eq_abi(&self, other: &Self) -> bool
pub fn eq_abi(&self, other: &Self) -> 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.
Trait Implementations§
source§impl<FieldIdx, VariantIdx, __CTX> HashStable<__CTX> for LayoutS<FieldIdx, VariantIdx>where
__CTX: HashStableContext,
FieldIdx: HashStable<__CTX> + Idx,
VariantIdx: HashStable<__CTX> + Idx,
impl<FieldIdx, VariantIdx, __CTX> HashStable<__CTX> for LayoutS<FieldIdx, VariantIdx>where
__CTX: HashStableContext,
FieldIdx: HashStable<__CTX> + Idx,
VariantIdx: HashStable<__CTX> + Idx,
fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)
source§impl<FieldIdx: PartialEq + Idx, VariantIdx: PartialEq + Idx> PartialEq for LayoutS<FieldIdx, VariantIdx>
impl<FieldIdx: PartialEq + Idx, VariantIdx: PartialEq + Idx> PartialEq for LayoutS<FieldIdx, VariantIdx>
impl<FieldIdx: Eq + Idx, VariantIdx: Eq + Idx> Eq for LayoutS<FieldIdx, VariantIdx>
impl<FieldIdx: Idx, VariantIdx: Idx> StructuralPartialEq for LayoutS<FieldIdx, VariantIdx>
Auto Trait Implementations§
impl<FieldIdx, VariantIdx> Freeze for LayoutS<FieldIdx, VariantIdx>where
VariantIdx: Freeze,
impl<FieldIdx, VariantIdx> RefUnwindSafe for LayoutS<FieldIdx, VariantIdx>where
VariantIdx: RefUnwindSafe,
impl<FieldIdx, VariantIdx> Send for LayoutS<FieldIdx, VariantIdx>where
VariantIdx: Send,
impl<FieldIdx, VariantIdx> Sync for LayoutS<FieldIdx, VariantIdx>where
VariantIdx: Sync,
impl<FieldIdx, VariantIdx> Unpin for LayoutS<FieldIdx, VariantIdx>where
VariantIdx: Unpin,
impl<FieldIdx, VariantIdx> UnwindSafe for LayoutS<FieldIdx, VariantIdx>where
VariantIdx: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
source§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
source§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
Layout§
Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.