pub type Key<'tcx> = InstanceKind<'tcx>;
Aliased Type§
enum Key<'tcx> {
Show 13 variants
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.
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.
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
.
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 bytesIntrinsic
: 11 bytesVTableShim
: 11 bytesReifyShim
: 11 bytesFnPtrShim
: 23 bytesVirtual
: 23 bytesClosureOnceShim
: 11 bytesConstructCoroutineInClosureShim
: 11 bytesThreadLocalShim
: 11 bytesDropGlue
: 23 bytesCloneShim
: 23 bytesFnPtrAddrShim
: 23 bytesAsyncDropGlueCtorShim
: 23 bytes