wasmer_types::lib::std::ptr

Struct Alignment

pub struct Alignment(/* private fields */);

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

Available on crate feature std only.

Expand description

A type storing a usize which is a power of two, and thus represents a possible alignment in the Rust abstract machine.

Note that particularly large alignments, while representable in this type, are likely not to be supported by actual allocators and linkers.

Implementations§

Source §

impl Alignment

Source

pub const MIN: Alignment

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

The smallest possible alignment, 1.

All addresses are always aligned at least this much.

§Examples

#![feature(ptr_alignment_type)]
use std::ptr::Alignment;

assert_eq!(Alignment::MIN.as_usize(), 1);

Source

pub const fn of<T>() -> Alignment

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

Returns the alignment for a type.

This provides the same numerical value as align_of, but in an Alignment instead of a usize.

Source

pub const fn of_val<T>(val: &T) -> Alignment
where T: ?Sized,

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

Returns the ABI-required minimum alignment of the type of the value that val points to.

Every reference to a value of the type T must be a multiple of this number.

§Examples

#![feature(ptr_alignment_type)]
use std::ptr::Alignment;

assert_eq!(Alignment::of_val(&5i32).as_usize(), 4);

Source

pub const unsafe fn of_val_raw<T>(val: *const T) -> Alignment
where T: ?Sized,

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

Returns the ABI-required minimum alignment of the type of the value that val points to.

Every reference to a value of the type T must be a multiple of this number.

§Safety

This function is only safe to call if the following conditions hold:

If T is Sized, this function is always safe to call.
If the unsized tail of T is:
- a slice, then the length of the slice tail must be an initialized integer, and the size of the entire value (dynamic tail length + statically sized prefix) must fit in isize. For the special case where the dynamic tail length is 0, this function is safe to call.
- a trait object, then the vtable part of the pointer must point to a valid vtable acquired by an unsizing coercion, and the size of the entire value (dynamic tail length + statically sized prefix) must fit in isize.
- an (unstable) extern type, then this function is always safe to call, but may panic or otherwise return the wrong value, as the extern type’s layout is not known. This is the same behavior as Alignment::of_val on a reference to a type with an extern type tail.
- otherwise, it is conservatively not allowed to call this function.

§Examples

#![feature(ptr_alignment_type)]
#![feature(layout_for_ptr)]
use std::ptr::Alignment;

assert_eq!(unsafe { Alignment::of_val_raw(&5i32) }.as_usize(), 4);

Source

pub const fn new(align: usize) -> Option<Alignment>

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

Creates an Alignment from a usize, or returns None if it’s not a power of two.

Note that 0 is not a power of two, nor a valid alignment.

Source

pub const unsafe fn new_unchecked(align: usize) -> Alignment

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

Creates an Alignment from a power-of-two usize.

§Safety

align must be a power of two.

Equivalently, it must be 1 << exp for some exp in 0..usize::BITS. It must not be zero.

Source

pub const fn as_usize(self) -> usize

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

Returns the alignment as a usize.

Source

pub const fn as_nonzero(self) -> NonZero<usize>

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

Returns the alignment as a NonZero<usize>.

Source

pub const fn log2(self) -> u32

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

Returns the base-2 logarithm of the alignment.

This is always exact, as self represents a power of two.

§Examples

#![feature(ptr_alignment_type)]
use std::ptr::Alignment;

assert_eq!(Alignment::of::<u8>().log2(), 0);
assert_eq!(Alignment::new(1024).unwrap().log2(), 10);

Source

pub const fn mask(self) -> usize

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

Returns a bit mask that can be used to match this alignment.

This is equivalent to !(self.as_usize() - 1).

§Examples

#![feature(ptr_alignment_type)]
#![feature(ptr_mask)]
use std::ptr::{Alignment, NonNull};

#[repr(align(1))] struct Align1(u8);
#[repr(align(2))] struct Align2(u16);
#[repr(align(4))] struct Align4(u32);
let one = <NonNull<Align1>>::dangling().as_ptr();
let two = <NonNull<Align2>>::dangling().as_ptr();
let four = <NonNull<Align4>>::dangling().as_ptr();

assert_eq!(four.mask(Alignment::of::<Align1>().mask()), four);
assert_eq!(four.mask(Alignment::of::<Align2>().mask()), four);
assert_eq!(four.mask(Alignment::of::<Align4>().mask()), four);
assert_ne!(one.mask(Alignment::of::<Align4>().mask()), one);