Struct rustc_data_structures::tagged_ptr::CopyTaggedPtr

pub struct CopyTaggedPtr<P, T, const COMPARE_PACKED: bool>where
    P: Pointer,
    T: Tag,{
    packed: NonNull<P::Target>,
    tag_ghost: PhantomData<T>,
}

A Copy tagged pointer.

This is essentially { pointer: P, tag: T } packed in a single pointer.

You should use this instead of the TaggedPtr type in all cases where P implements Copy.

If COMPARE_PACKED is true, then the pointers will be compared and hashed without unpacking. Otherwise we don’t implement PartialEq, Eq and Hash; if you want that, wrap the CopyTaggedPtr.

Fields

packed: NonNull<P::Target>

This is semantically a pair of pointer: P and tag: T fields, however we pack them in a single pointer, to save space.

We pack the tag into the most-significant bits of the pointer to ease retrieval of the value. A left shift is a multiplication and those are embeddable in instruction encoding, for example:

// (<https://godbolt.org/z/jqcYPWEr3>)
example::shift_read3:
    mov     eax, dword ptr [8*rdi]
    ret

example::mask_read3:
    and     rdi, -8
    mov     eax, dword ptr [rdi]
    ret

This is ASM outputted by rustc for reads of values behind tagged pointers for different approaches of tagging:

• shift_read3 uses << 3 (the tag is in the most-significant bits)
• mask_read3 uses & !0b111 (the tag is in the least-significant bits)

The shift approach thus produces less instructions and is likely faster (see https://godbolt.org/z/Y913sMdWb).

Encoding diagram:

[ packed.addr                     ]
[ tag ] [ pointer.addr >> T::BITS ] <-- usize::BITS - T::BITS bits
   ^
   |
T::BITS bits

The tag can be retrieved by packed.addr() >> T::BITS and the pointer can be retrieved by packed.map_addr(|addr| addr << T::BITS).

tag_ghost: PhantomData<T>

Implementations

impl<P, T, const CP: bool> CopyTaggedPtr<P, T, CP>where P: Pointer, T: Tag,

pub fn new(pointer: P, tag: T) -> Self

Tags pointer with tag.

Note that this leaks pointer: it won’t be dropped when CopyTaggedPtr is dropped. If you have a pointer with a significant drop, use TaggedPtr instead.

pub fn pointer(self) -> Pwhere P: Copy,

Retrieves the pointer.

pub fn tag(&self) -> T

Retrieves the tag.

pub fn set_tag(&mut self, tag: T)

Sets the tag to a new value.

const TAG_BIT_SHIFT: u32 = _

const ASSERTION: () = _

fn pack(ptr: NonNull<P::Target>, tag: T) -> NonNull<P::Target>

Pack pointer ptr that comes from P::into_ptr with a tag, according to self.packed encoding scheme.

pub(super) fn pointer_raw(&self) -> NonNull<P::Target>

Retrieves the original raw pointer from self.packed.

pub(super) fn with_pointer_ref<R>(&self, f: impl FnOnce(&P) -> R) -> R

This provides a reference to the P pointer itself, rather than the Deref::Target. It is used for cases where we want to call methods that may be implement differently for the Pointer than the Pointee (e.g., Rc::clone vs cloning the inner value).

Trait Implementations

impl<P, T, const CP: bool> Clone for CopyTaggedPtr<P, T, CP>where P: Pointer + Copy, T: Tag,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P, T, const CP: bool> Debug for CopyTaggedPtr<P, T, CP>where P: Pointer + Debug, T: Tag + Debug,

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

Formats the value using the given formatter.

impl<P, T, const CP: bool> Deref for CopyTaggedPtr<P, T, CP>where P: Pointer, T: Tag,

type Target = <P as Deref>::Target

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<P, T, const CP: bool> DerefMut for CopyTaggedPtr<P, T, CP>where P: Pointer + DerefMut, T: Tag,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<P, T> Hash for CopyTaggedPtr<P, T, true>where P: Pointer, T: Tag,

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<P, T, HCX, const CP: bool> HashStable<HCX> for CopyTaggedPtr<P, T, CP>where P: Pointer + HashStable<HCX>, T: Tag + HashStable<HCX>,

fn hash_stable(&self, hcx: &mut HCX, hasher: &mut StableHasher)

impl<P, T> PartialEq<CopyTaggedPtr<P, T, true>> for CopyTaggedPtr<P, T, true>where P: Pointer, T: Tag,

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

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

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

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

impl<P, T, const CP: bool> Copy for CopyTaggedPtr<P, T, CP>where P: Pointer + Copy, T: Tag,

impl<P, T> Eq for CopyTaggedPtr<P, T, true>where P: Pointer, T: Tag,

impl<P, T, const CP: bool> Send for CopyTaggedPtr<P, T, CP>where P: Send + Pointer, T: Send + Tag,

impl<P, T, const CP: bool> Sync for CopyTaggedPtr<P, T, CP>where P: Sync + Pointer, T: Sync + Tag,

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.