Enum InstanceKind

pub enum InstanceKind<'tcx> {
    Item(DefId),
    Intrinsic(DefId),
    VTableShim(DefId),
    ReifyShim(DefId, Option<ReifyReason>),
    FnPtrShim(DefId, Ty<'tcx>),
    Virtual(DefId, usize),
    ClosureOnceShim {
        call_once: DefId,
        track_caller: bool,
    },
    ConstructCoroutineInClosureShim {
        coroutine_closure_def_id: DefId,
        receiver_by_ref: bool,
    },
    ThreadLocalShim(DefId),
    DropGlue(DefId, Option<Ty<'tcx>>),
    CloneShim(DefId, Ty<'tcx>),
    FnPtrAddrShim(DefId, Ty<'tcx>),
    AsyncDropGlueCtorShim(DefId, Option<Ty<'tcx>>),
}

Variants

Item(DefId)

A user-defined callable item.

This includes:

• fn items
• closures
• coroutines

Intrinsic(DefId)

An intrinsic fn item (with "rust-intrinsic" ABI).

Alongside Virtual, this is the only InstanceKind that does not have its own callable MIR. Instead, codegen and const eval “magically” evaluate calls to intrinsics purely in the caller.

VTableShim(DefId)

<T as Trait>::method where method receives unsizeable self: Self (part of the unsized_locals feature).

The generated shim will take Self via *mut Self - conceptually this is &owned Self - and dereference the argument to call the original function.

ReifyShim(DefId, Option<ReifyReason>)

fn() pointer where the function itself cannot be turned into a pointer.

One example is <dyn Trait as Trait>::fn, where the shim contains a virtual call, which codegen supports only via a direct call to the <dyn Trait as Trait>::fn instance (an InstanceKind::Virtual).

Another example is functions annotated with #[track_caller], which must have their implicit caller location argument populated for a call. Because this is a required part of the function’s ABI but can’t be tracked as a property of the function pointer, we use a single “caller location” (the definition of the function itself).

The second field encodes why this shim was created. This allows distinguishing between a ReifyShim that appears in a vtable vs one that appears as a function pointer.

This field will only be populated if we are compiling in a mode that needs these shims to be separable, currently only when KCFI is enabled.

FnPtrShim(DefId, Ty<'tcx>)

<fn() as FnTrait>::call_* (generated FnTrait implementation for fn() pointers).

DefId is FnTrait::call_*.

Virtual(DefId, usize)

Dynamic dispatch to <dyn Trait as Trait>::fn.

This InstanceKind does not have callable MIR. Calls to Virtual instances must be codegen’d as virtual calls through the vtable.

If this is reified to a fn pointer, a ReifyShim is used (see ReifyShim above for more details on that).

ClosureOnceShim

<[FnMut/Fn closure] as FnOnce>::call_once.

The DefId is the ID of the call_once method in FnOnce.

This generates a body that will just borrow the (owned) self type, and dispatch to the FnMut::call_mut instance for the closure.

Fields

call_once: DefId

track_caller: bool

ConstructCoroutineInClosureShim

<[FnMut/Fn coroutine-closure] as FnOnce>::call_once

The body generated here differs significantly from the ClosureOnceShim, since we need to generate a distinct coroutine type that will move the closure’s upvars out of the closure.

Fields

coroutine_closure_def_id: DefId

receiver_by_ref: bool

ThreadLocalShim(DefId)

Compiler-generated accessor for thread locals which returns a reference to the thread local the DefId defines. This is used to export thread locals from dylibs on platforms lacking native support.

DropGlue(DefId, Option<Ty<'tcx>>)

core::ptr::drop_in_place::<T>.

The DefId is for core::ptr::drop_in_place. The Option<Ty<'tcx>> is either Some(T), or None for empty drop glue.

CloneShim(DefId, Ty<'tcx>)

Compiler-generated <T as Clone>::clone implementation.

For all types that automatically implement Copy, a trivial Clone impl is provided too. Additionally, arrays, tuples, and closures get a Clone shim even if they aren’t Copy.

The DefId is for Clone::clone, the Ty is the type T with the builtin Clone impl.

FnPtrAddrShim(DefId, Ty<'tcx>)

Compiler-generated <T as FnPtr>::addr implementation.

Automatically generated for all potentially higher-ranked fn(I) -> R types.

The DefId is for FnPtr::addr, the Ty is the type T.

AsyncDropGlueCtorShim(DefId, Option<Ty<'tcx>>)

core::future::async_drop::async_drop_in_place::<'_, T>.

The DefId is for core::future::async_drop::async_drop_in_place, the Ty is the type T.

Implementations

impl<'tcx> InstanceKind<'tcx>

pub fn def_id(self) -> DefId

pub fn def_id_if_not_guaranteed_local_codegen(self) -> Option<DefId>

Returns the DefId of instances which might not require codegen locally.

pub fn get_attrs( &self, tcx: TyCtxt<'tcx>, attr: Symbol, ) -> impl Iterator<Item = &'tcx Attribute>

pub fn requires_inline(&self, tcx: TyCtxt<'tcx>) -> bool

Returns true if the LLVM version of this instance is unconditionally marked with inline. This implies that a copy of this instance is generated in every codegen unit. Note that this is only a hint. See the documentation for generates_cgu_internal_copy for more information.

pub fn generates_cgu_internal_copy(&self, tcx: TyCtxt<'tcx>) -> bool

Returns true if the machine code for this instance is instantiated in each codegen unit that references it. Note that this is only a hint! The compiler can globally decide to not do this in order to speed up compilation. CGU-internal copies are only exist to enable inlining. If inlining is not performed (e.g. at -Copt-level=0) then the time for generating them is wasted and it’s better to create a single copy with external linkage.

pub fn requires_caller_location(&self, tcx: TyCtxt<'_>) -> bool

pub fn has_polymorphic_mir_body(&self) -> bool

Returns true when the MIR body associated with this instance should be monomorphized by its users (e.g. codegen or miri) by instantiating the args from Instance (see Instance::args_for_mir_body).

Otherwise, returns false only for some kinds of shims where the construction of the MIR body should perform necessary instantiations.

Trait Implementations

impl<'tcx> AsLocalKey for InstanceKind<'tcx>

type LocalKey = InstanceKind<'tcx>

fn as_local_key(&self) -> Option<Self::LocalKey>

Given an instance of this key, what crate is it referring to? This is used to find the provider.

impl<'tcx> Clone for InstanceKind<'tcx>

fn clone(&self) -> InstanceKind<'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for InstanceKind<'tcx>

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

Formats the value using the given formatter.

impl<'tcx, __D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<__D> for InstanceKind<'tcx>

fn decode(__decoder: &mut __D) -> Self

impl<'tcx, __E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<__E> for InstanceKind<'tcx>

fn encode(&self, __encoder: &mut __E)

impl<'tcx> EraseType for InstanceKind<'tcx>

type Result = [u8; 24]

impl<'tcx> Hash for InstanceKind<'tcx>

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<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for InstanceKind<'tcx>

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher, )

impl<'tcx> Key for InstanceKind<'tcx>

type Cache<V> = DefaultCache<InstanceKind<'tcx>, V>

fn default_span(&self, tcx: TyCtxt<'_>) -> Span

In the event that a cycle occurs, if no explicit span has been given for a query with key self, what span should we use?

fn key_as_def_id(&self) -> Option<DefId>

If the key is a DefId or DefId–equivalent, return that DefId. Otherwise, return None.

fn ty_def_id(&self) -> Option<DefId>

impl<'tcx, '__lifted> Lift<TyCtxt<'__lifted>> for InstanceKind<'tcx>

type Lifted = InstanceKind<'__lifted>

fn lift_to_interner( self, __tcx: TyCtxt<'__lifted>, ) -> Option<InstanceKind<'__lifted>>

impl<'tcx> PartialEq for InstanceKind<'tcx>

fn eq(&self, other: &InstanceKind<'tcx>) -> 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<'tcx> TypeFoldable<TyCtxt<'tcx>> for InstanceKind<'tcx>

fn try_fold_with<__F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, __folder: &mut __F, ) -> Result<Self, __F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Self

where F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for InstanceKind<'tcx>

fn visit_with<__V: TypeVisitor<TyCtxt<'tcx>>>( &self, __visitor: &mut __V, ) -> __V::Result

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'tcx> Copy for InstanceKind<'tcx>

impl<'tcx> Eq for InstanceKind<'tcx>

impl<'tcx> StructuralPartialEq for InstanceKind<'tcx>

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

Size for each variant:

• Item: 11 bytes
• Intrinsic: 11 bytes
• VTableShim: 11 bytes
• ReifyShim: 11 bytes
• FnPtrShim: 23 bytes
• Virtual: 23 bytes
• ClosureOnceShim: 11 bytes
• ConstructCoroutineInClosureShim: 11 bytes
• ThreadLocalShim: 11 bytes
• DropGlue: 23 bytes
• CloneShim: 23 bytes
• FnPtrAddrShim: 23 bytes
• AsyncDropGlueCtorShim: 23 bytes