Type Alias rustc_middle::query::queries::mir_shims::Key

pub type Key<'tcx> = InstanceDef<'tcx>;

Aliased Type

enum Key<'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,
    },
    CoroutineKindShim {
        coroutine_def_id: DefId,
    },
    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" or "platform-intrinsic" ABI).

Alongside Virtual, this is the only InstanceDef 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 InstanceDef::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 InstanceDef 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

CoroutineKindShim

<[coroutine] as Future>::poll, but for coroutines produced when AsyncFnOnce is called on a coroutine-closure whose closure kind greater than FnOnce, or similarly for AsyncFnMut.

This will select the body that is produced by the ByMoveBody transform, and thus take and use all of its upvars by-move rather than by-ref.

Fields

coroutine_def_id: DefId

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 bytes
• Intrinsic: 11 bytes
• VTableShim: 11 bytes
• ReifyShim: 11 bytes
• FnPtrShim: 23 bytes
• Virtual: 23 bytes
• ClosureOnceShim: 11 bytes
• ConstructCoroutineInClosureShim: 11 bytes
• CoroutineKindShim: 11 bytes
• ThreadLocalShim: 11 bytes
• DropGlue: 23 bytes
• CloneShim: 23 bytes
• FnPtrAddrShim: 23 bytes
• AsyncDropGlueCtorShim: 23 bytes