Struct rustc_mir_transform::const_prop::ConstPropMachine
source · pub struct ConstPropMachine<'mir, 'tcx> {
stack: Vec<Frame<'mir, 'tcx>>,
pub written_only_inside_own_block_locals: FxHashSet<Local>,
pub only_propagate_inside_block_locals: BitSet<Local>,
pub can_const_prop: IndexVec<Local, ConstPropMode>,
}
Fields§
§stack: Vec<Frame<'mir, 'tcx>>
The virtual call stack.
written_only_inside_own_block_locals: FxHashSet<Local>
OnlyInsideOwnBlock
locals that were written in the current block get erased at the end.
only_propagate_inside_block_locals: BitSet<Local>
Locals that need to be cleared after every block terminates.
can_const_prop: IndexVec<Local, ConstPropMode>
Implementations§
source§impl ConstPropMachine<'_, '_>
impl ConstPropMachine<'_, '_>
Trait Implementations§
source§impl<'mir, 'tcx> Machine<'mir, 'tcx> for ConstPropMachine<'mir, 'tcx>
impl<'mir, 'tcx> Machine<'mir, 'tcx> for ConstPropMachine<'mir, 'tcx>
§type Provenance = AllocId
type Provenance = AllocId
Pointers are “tagged” with provenance information; typically the
AllocId
they belong to.§type ProvenanceExtra = ()
type ProvenanceExtra = ()
When getting the AllocId of a pointer, some extra data is also obtained from the provenance
that is passed to memory access hooks so they can do things with it. Read more
§type ExtraFnVal = !
type ExtraFnVal = !
Machines can define extra (non-instance) things that represent values of function pointers.
For example, Miri uses this to return a function pointer from
dlsym
that can later be called to execute the right thing. Read more§type MemoryMap = IndexMap<AllocId, (MemoryKind<!>, Allocation<AllocId, ()>), BuildHasherDefault<FxHasher>>
type MemoryMap = IndexMap<AllocId, (MemoryKind<!>, Allocation<AllocId, ()>), BuildHasherDefault<FxHasher>>
Memory’s allocation map
source§const GLOBAL_KIND: Option<Self::MemoryKind> = None
const GLOBAL_KIND: Option<Self::MemoryKind> = None
The memory kind to use for copied global memory (held in
tcx
) –
or None if such memory should not be mutated and thus any such attempt will cause
a ModifiedStatic
error to be raised.
Statics are copied under two circumstances: When they are mutated, and when
adjust_allocation
(see below) returns an owned allocation
that is added to the memory so that the work is not done twice. Read more§type AllocExtra = ()
type AllocExtra = ()
Extra data stored in every allocation.
§type FrameExtra = ()
type FrameExtra = ()
Extra data stored in every call frame.
source§fn use_addr_for_alignment_check(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool
fn use_addr_for_alignment_check(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool
Whether, when checking alignment, we should look at the actual address and thus support
custom alignment logic based on whatever the integer address happens to be. Read more
source§fn checked_binop_checks_overflow(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool
fn checked_binop_checks_overflow(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool
Whether CheckedBinOp MIR statements should actually check for overflow.
source§fn call_extra_fn(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
fn_val: !,
_abi: CallAbi,
_args: &[OpTy<'tcx>],
_destination: &PlaceTy<'tcx, Self::Provenance>,
_target: Option<BasicBlock>,
_unwind: StackPopUnwind
) -> InterpResult<'tcx>
fn call_extra_fn(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
fn_val: !,
_abi: CallAbi,
_args: &[OpTy<'tcx>],
_destination: &PlaceTy<'tcx, Self::Provenance>,
_target: Option<BasicBlock>,
_unwind: StackPopUnwind
) -> InterpResult<'tcx>
Execute
fn_val
. It is the hook’s responsibility to advance the instruction
pointer as appropriate. Read moresource§fn adjust_allocation<'b>(
_ecx: &InterpCx<'mir, 'tcx, Self>,
_id: AllocId,
alloc: Cow<'b, Allocation>,
_kind: Option<MemoryKind<Self::MemoryKind>>
) -> InterpResult<'tcx, Cow<'b, Allocation<Self::Provenance>>>
fn adjust_allocation<'b>(
_ecx: &InterpCx<'mir, 'tcx, Self>,
_id: AllocId,
alloc: Cow<'b, Allocation>,
_kind: Option<MemoryKind<Self::MemoryKind>>
) -> InterpResult<'tcx, Cow<'b, Allocation<Self::Provenance>>>
Called to adjust allocations to the Provenance and AllocExtra of this machine. Read more
source§fn extern_static_base_pointer(
ecx: &InterpCx<'mir, 'tcx, Self>,
def_id: DefId
) -> InterpResult<'tcx, Pointer>
fn extern_static_base_pointer(
ecx: &InterpCx<'mir, 'tcx, Self>,
def_id: DefId
) -> InterpResult<'tcx, Pointer>
Return the root pointer for the given
extern static
.source§fn adjust_alloc_base_pointer(
_ecx: &InterpCx<'mir, 'tcx, Self>,
ptr: Pointer<AllocId>
) -> Pointer<AllocId>
fn adjust_alloc_base_pointer(
_ecx: &InterpCx<'mir, 'tcx, Self>,
ptr: Pointer<AllocId>
) -> Pointer<AllocId>
Return a “base” pointer for the given allocation: the one that is used for direct
accesses to this static/const/fn allocation, or the one returned from the heap allocator. Read more
source§fn ptr_from_addr_cast(
_ecx: &InterpCx<'mir, 'tcx, Self>,
addr: u64
) -> InterpResult<'tcx, Pointer<Option<AllocId>>>
fn ptr_from_addr_cast(
_ecx: &InterpCx<'mir, 'tcx, Self>,
addr: u64
) -> InterpResult<'tcx, Pointer<Option<AllocId>>>
“Int-to-pointer cast”
source§fn ptr_get_alloc(
_ecx: &InterpCx<'mir, 'tcx, Self>,
ptr: Pointer<AllocId>
) -> Option<(AllocId, Size, Self::ProvenanceExtra)>
fn ptr_get_alloc(
_ecx: &InterpCx<'mir, 'tcx, Self>,
ptr: Pointer<AllocId>
) -> Option<(AllocId, Size, Self::ProvenanceExtra)>
Convert a pointer with provenance into an allocation-offset pair
and extra provenance info. Read more
source§const PANIC_ON_ALLOC_FAIL: bool = true
const PANIC_ON_ALLOC_FAIL: bool = true
Should the machine panic on allocation failures?
§type MemoryKind = !
type MemoryKind = !
Additional memory kinds a machine wishes to distinguish from the builtin ones
source§fn enforce_alignment(_ecx: &InterpCx<'mir, 'tcx, Self>) -> CheckAlignment
fn enforce_alignment(_ecx: &InterpCx<'mir, 'tcx, Self>) -> CheckAlignment
Whether memory accesses should be alignment-checked.
source§fn enforce_validity(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool
fn enforce_validity(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool
Whether to enforce the validity invariant
fn alignment_check_failed(
ecx: &InterpCx<'mir, 'tcx, Self>,
_has: Align,
_required: Align,
_check: CheckAlignment
) -> InterpResult<'tcx, ()>
source§fn load_mir(
_ecx: &InterpCx<'mir, 'tcx, Self>,
_instance: InstanceDef<'tcx>
) -> InterpResult<'tcx, &'tcx Body<'tcx>>
fn load_mir(
_ecx: &InterpCx<'mir, 'tcx, Self>,
_instance: InstanceDef<'tcx>
) -> InterpResult<'tcx, &'tcx Body<'tcx>>
Entry point for obtaining the MIR of anything that should get evaluated.
So not just functions and shims, but also const/static initializers, anonymous
constants, … Read more
source§fn find_mir_or_eval_fn(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_instance: Instance<'tcx>,
_abi: CallAbi,
_args: &[OpTy<'tcx>],
_destination: &PlaceTy<'tcx>,
_target: Option<BasicBlock>,
_unwind: StackPopUnwind
) -> InterpResult<'tcx, Option<(&'mir Body<'tcx>, Instance<'tcx>)>>
fn find_mir_or_eval_fn(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_instance: Instance<'tcx>,
_abi: CallAbi,
_args: &[OpTy<'tcx>],
_destination: &PlaceTy<'tcx>,
_target: Option<BasicBlock>,
_unwind: StackPopUnwind
) -> InterpResult<'tcx, Option<(&'mir Body<'tcx>, Instance<'tcx>)>>
Entry point to all function calls. Read more
source§fn call_intrinsic(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_instance: Instance<'tcx>,
_args: &[OpTy<'tcx>],
_destination: &PlaceTy<'tcx>,
_target: Option<BasicBlock>,
_unwind: StackPopUnwind
) -> InterpResult<'tcx>
fn call_intrinsic(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_instance: Instance<'tcx>,
_args: &[OpTy<'tcx>],
_destination: &PlaceTy<'tcx>,
_target: Option<BasicBlock>,
_unwind: StackPopUnwind
) -> InterpResult<'tcx>
Directly process an intrinsic without pushing a stack frame. It is the hook’s
responsibility to advance the instruction pointer as appropriate. Read more
source§fn assert_panic(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_msg: &AssertMessage<'tcx>,
_unwind: Option<BasicBlock>
) -> InterpResult<'tcx>
fn assert_panic(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_msg: &AssertMessage<'tcx>,
_unwind: Option<BasicBlock>
) -> InterpResult<'tcx>
Called to evaluate
Assert
MIR terminators that trigger a panic.source§fn binary_ptr_op(
_ecx: &InterpCx<'mir, 'tcx, Self>,
_bin_op: BinOp,
_left: &ImmTy<'tcx>,
_right: &ImmTy<'tcx>
) -> InterpResult<'tcx, (Scalar, bool, Ty<'tcx>)>
fn binary_ptr_op(
_ecx: &InterpCx<'mir, 'tcx, Self>,
_bin_op: BinOp,
_left: &ImmTy<'tcx>,
_right: &ImmTy<'tcx>
) -> InterpResult<'tcx, (Scalar, bool, Ty<'tcx>)>
Called for all binary operations where the LHS has pointer type. Read more
source§fn access_local_mut<'a>(
ecx: &'a mut InterpCx<'mir, 'tcx, Self>,
frame: usize,
local: Local
) -> InterpResult<'tcx, &'a mut Operand<Self::Provenance>>
fn access_local_mut<'a>(
ecx: &'a mut InterpCx<'mir, 'tcx, Self>,
frame: usize,
local: Local
) -> InterpResult<'tcx, &'a mut Operand<Self::Provenance>>
Called to write the specified
local
from the frame
.
Since writing a ZST is not actually accessing memory or locals, this is never invoked
for ZST reads. Read moresource§fn before_access_global(
_tcx: TyCtxt<'tcx>,
_machine: &Self,
_alloc_id: AllocId,
alloc: ConstAllocation<'tcx>,
_static_def_id: Option<DefId>,
is_write: bool
) -> InterpResult<'tcx>
fn before_access_global(
_tcx: TyCtxt<'tcx>,
_machine: &Self,
_alloc_id: AllocId,
alloc: ConstAllocation<'tcx>,
_static_def_id: Option<DefId>,
is_write: bool
) -> InterpResult<'tcx>
Called before a global allocation is accessed.
def_id
is Some
if this is the “lazy” allocation of a static. Read moresource§fn expose_ptr(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_ptr: Pointer<AllocId>
) -> InterpResult<'tcx>
fn expose_ptr(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_ptr: Pointer<AllocId>
) -> InterpResult<'tcx>
Marks a pointer as exposed, allowing it’s provenance
to be recovered. “Pointer-to-int cast” Read more
source§fn init_frame_extra(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
frame: Frame<'mir, 'tcx>
) -> InterpResult<'tcx, Frame<'mir, 'tcx>>
fn init_frame_extra(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
frame: Frame<'mir, 'tcx>
) -> InterpResult<'tcx, Frame<'mir, 'tcx>>
Called immediately before a new stack frame gets pushed.
source§fn stack<'a>(
ecx: &'a InterpCx<'mir, 'tcx, Self>
) -> &'a [Frame<'mir, 'tcx, Self::Provenance, Self::FrameExtra>]
fn stack<'a>(
ecx: &'a InterpCx<'mir, 'tcx, Self>
) -> &'a [Frame<'mir, 'tcx, Self::Provenance, Self::FrameExtra>]
Borrow the current thread’s stack.
source§fn stack_mut<'a>(
ecx: &'a mut InterpCx<'mir, 'tcx, Self>
) -> &'a mut Vec<Frame<'mir, 'tcx, Self::Provenance, Self::FrameExtra>>
fn stack_mut<'a>(
ecx: &'a mut InterpCx<'mir, 'tcx, Self>
) -> &'a mut Vec<Frame<'mir, 'tcx, Self::Provenance, Self::FrameExtra>>
Mutably borrow the current thread’s stack.
§fn enforce_abi(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool
fn enforce_abi(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool
Whether function calls should be ABI-checked.
§fn abort(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_msg: String
) -> Result<!, InterpErrorInfo<'tcx>>
fn abort(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_msg: String
) -> Result<!, InterpErrorInfo<'tcx>>
Called to evaluate
Abort
MIR terminator.§fn before_terminator(
_ecx: &mut InterpCx<'mir, 'tcx, Self>
) -> Result<(), InterpErrorInfo<'tcx>>
fn before_terminator(
_ecx: &mut InterpCx<'mir, 'tcx, Self>
) -> Result<(), InterpErrorInfo<'tcx>>
Called before a basic block terminator is executed.
You can use this to detect endlessly running programs. Read more
§fn thread_local_static_base_pointer(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
def_id: DefId
) -> Result<Pointer<Self::Provenance>, InterpErrorInfo<'tcx>>
fn thread_local_static_base_pointer(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
def_id: DefId
) -> Result<Pointer<Self::Provenance>, InterpErrorInfo<'tcx>>
Return the
AllocId
for the given thread-local static in the current thread.fn eval_inline_asm(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_template: &'tcx [InlineAsmTemplatePiece],
_operands: &[InlineAsmOperand<'tcx>],
_options: InlineAsmOptions
) -> Result<(), InterpErrorInfo<'tcx>>
§fn before_memory_read(
_tcx: TyCtxt<'tcx>,
_machine: &Self,
_alloc_extra: &Self::AllocExtra,
_prov: (AllocId, Self::ProvenanceExtra),
_range: AllocRange
) -> Result<(), InterpErrorInfo<'tcx>>
fn before_memory_read(
_tcx: TyCtxt<'tcx>,
_machine: &Self,
_alloc_extra: &Self::AllocExtra,
_prov: (AllocId, Self::ProvenanceExtra),
_range: AllocRange
) -> Result<(), InterpErrorInfo<'tcx>>
Hook for performing extra checks on a memory read access. Read more
§fn before_memory_write(
_tcx: TyCtxt<'tcx>,
_machine: &mut Self,
_alloc_extra: &mut Self::AllocExtra,
_prov: (AllocId, Self::ProvenanceExtra),
_range: AllocRange
) -> Result<(), InterpErrorInfo<'tcx>>
fn before_memory_write(
_tcx: TyCtxt<'tcx>,
_machine: &mut Self,
_alloc_extra: &mut Self::AllocExtra,
_prov: (AllocId, Self::ProvenanceExtra),
_range: AllocRange
) -> Result<(), InterpErrorInfo<'tcx>>
Hook for performing extra checks on a memory write access.
§fn before_memory_deallocation(
_tcx: TyCtxt<'tcx>,
_machine: &mut Self,
_alloc_extra: &mut Self::AllocExtra,
_prov: (AllocId, Self::ProvenanceExtra),
_range: AllocRange
) -> Result<(), InterpErrorInfo<'tcx>>
fn before_memory_deallocation(
_tcx: TyCtxt<'tcx>,
_machine: &mut Self,
_alloc_extra: &mut Self::AllocExtra,
_prov: (AllocId, Self::ProvenanceExtra),
_range: AllocRange
) -> Result<(), InterpErrorInfo<'tcx>>
Hook for performing extra operations on a memory deallocation.
§fn retag_ptr_value(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_kind: RetagKind,
val: &ImmTy<'tcx, Self::Provenance>
) -> Result<ImmTy<'tcx, Self::Provenance>, InterpErrorInfo<'tcx>>
fn retag_ptr_value(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_kind: RetagKind,
val: &ImmTy<'tcx, Self::Provenance>
) -> Result<ImmTy<'tcx, Self::Provenance>, InterpErrorInfo<'tcx>>
Executes a retagging operation for a single pointer.
Returns the possibly adjusted pointer. Read more
§fn retag_place_contents(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_kind: RetagKind,
_place: &PlaceTy<'tcx, Self::Provenance>
) -> Result<(), InterpErrorInfo<'tcx>>
fn retag_place_contents(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_kind: RetagKind,
_place: &PlaceTy<'tcx, Self::Provenance>
) -> Result<(), InterpErrorInfo<'tcx>>
Executes a retagging operation on a compound value.
Replaces all pointers stored in the given place. Read more
§fn after_stack_push(
_ecx: &mut InterpCx<'mir, 'tcx, Self>
) -> Result<(), InterpErrorInfo<'tcx>>
fn after_stack_push(
_ecx: &mut InterpCx<'mir, 'tcx, Self>
) -> Result<(), InterpErrorInfo<'tcx>>
Called immediately after a stack frame got pushed and its locals got initialized.
§fn after_stack_pop(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_frame: Frame<'mir, 'tcx, Self::Provenance, Self::FrameExtra>,
unwinding: bool
) -> Result<StackPopJump, InterpErrorInfo<'tcx>>
fn after_stack_pop(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
_frame: Frame<'mir, 'tcx, Self::Provenance, Self::FrameExtra>,
unwinding: bool
) -> Result<StackPopJump, InterpErrorInfo<'tcx>>
Called immediately after a stack frame got popped, but before jumping back to the caller.
The
locals
have already been destroyed! Read moreAuto Trait Implementations§
impl<'mir, 'tcx> !RefUnwindSafe for ConstPropMachine<'mir, 'tcx>
impl<'mir, 'tcx> !Send for ConstPropMachine<'mir, 'tcx>
impl<'mir, 'tcx> !Sync for ConstPropMachine<'mir, 'tcx>
impl<'mir, 'tcx> Unpin for ConstPropMachine<'mir, 'tcx>where
'tcx: 'mir,
impl<'mir, 'tcx> !UnwindSafe for ConstPropMachine<'mir, 'tcx>
Blanket Implementations§
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: 112 bytes