Enum RetagPlan 

enum RetagPlan<V> {
    EmitRetag(RetagInfo<V>),
    Recurse {
        field_plans: FxIndexMap<FieldIdx, RetagPlan<V>>,
        variant_plans: FxIndexMap<VariantIdx, RetagPlan<V>>,
    },
}

A description of the pointers within a type that need to be retagged.

Variants

EmitRetag(RetagInfo<V>)

Indicates that a pointer should be retagged.

Recurse

Indicates that one or more fields or variants of this type contain pointers that need to be retagged.

Fields

field_plans: FxIndexMap<FieldIdx, RetagPlan<V>>

variant_plans: FxIndexMap<VariantIdx, RetagPlan<V>>

Implementations

impl<V> RetagPlan<V>

fn for_field(self, ix: FieldIdx) -> Self

A helper function to move a RetagPlan into a particular field.

impl<'a, 'tcx, V> RetagPlan<V>

fn build<Bx: BuilderMethods<'a, 'tcx>>( bx: &mut Bx, layout: TyAndLayout<'tcx>, is_fn_entry: bool, ) -> Option<RetagPlan<Bx::Value>>

Attempts to create a RetagPlan for a place or operand with the given layout.

fn walk_value<Bx: BuilderMethods<'a, 'tcx>>( bx: &mut Bx, layout: TyAndLayout<'tcx>, is_fn_entry: bool, ) -> Option<RetagPlan<Bx::Value>>

Recurses through the fields and variants of a value in memory order to create a RetagPlan.

fn visit_box<Bx: BuilderMethods<'a, 'tcx>>( bx: &mut Bx, layout: TyAndLayout<'tcx>, is_fn_entry: bool, ) -> Option<RetagPlan<Bx::Value>>

Emits a retag for a Box.

fn emit_retag<Bx: BuilderMethods<'a, 'tcx>>( _bx: &mut Bx, _pointee_layout: TyAndLayout<'tcx>, _ptr_kind: Option<Mutability>, _is_fn_entry: bool, ) -> Option<RetagPlan<Bx::Value>>

Determines if a pointer needs to be retagged, when it points to a type with the given layout. Returns None for mutable pointers to types that are entirely covered by UnsafePinned, for which retags are a no-op.

Trait Implementations

impl<V: Debug> Debug for RetagPlan<V>

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

Formats the value using the given formatter.

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.