# Struct rustc_mir_transform::dataflow_const_prop::DummyMachine

source ·

    pub(crate) struct DummyMachine;

## Trait Implementations§

source§

### impl HasStaticRootDefId for DummyMachine

source§

#### fn static_def_id(&self) -> Option<LocalDefId>

Returns the `DefId` of the static item that is currently being evaluated. Used for interning to be able to handle nested allocations.
source§

### impl<'mir, 'tcx: 'mir> Machine<'mir, 'tcx> for DummyMachine

§

#### type Provenance = CtfeProvenance

Pointers are “tagged” with provenance information; typically the `AllocId` they belong to.
§

#### type ProvenanceExtra = bool

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.
§

#### 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.
§

#### type MemoryMap = IndexMap<AllocId, (MemoryKind<!>, Allocation), BuildHasherDefault<FxHasher>>

Memory’s allocation map
source§

#### 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.
§

#### type AllocExtra = ()

Extra data stored in every allocation.
§

#### type FrameExtra = ()

Extra data stored in every call frame.
§

#### type Bytes = Box<[u8]>

Type for the bytes of the allocation.
source§

#### fn ignore_optional_overflow_checks(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool

Whether Assert(OverflowNeg) and Assert(Overflow) MIR terminators should actually check for overflow.
source§

#### fn unwind_terminate( _ecx: &mut InterpCx<'mir, 'tcx, Self>, _reason: UnwindTerminateReason ) -> InterpResult<'tcx>

Called when unwinding reached a state where execution should be terminated.
source§

#### fn call_extra_fn( _ecx: &mut InterpCx<'mir, 'tcx, Self>, fn_val: !, _abi: CallAbi, _args: &[FnArg<'tcx>], _destination: &MPlaceTy<'tcx, Self::Provenance>, _target: Option<BasicBlock>, _unwind: UnwindAction ) -> InterpResult<'tcx>

Execute `fn_val`. It is the hook’s responsibility to advance the instruction pointer as appropriate.
source§

#### 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>

Return the root pointer for the given `extern static`.
source§

#### fn adjust_alloc_base_pointer( _ecx: &InterpCx<'mir, 'tcx, Self>, ptr: Pointer<CtfeProvenance> ) -> InterpResult<'tcx, Pointer<CtfeProvenance>>

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<CtfeProvenance>>>

“Int-to-pointer cast”
source§

#### fn ptr_get_alloc( _ecx: &InterpCx<'mir, 'tcx, Self>, ptr: Pointer<CtfeProvenance> ) -> Option<(AllocId, Size, Self::ProvenanceExtra)>

Convert a pointer with provenance into an allocation-offset pair and extra provenance info. Read more
§

#### type MemoryKind = !

Additional memory kinds a machine wishes to distinguish from the builtin ones
source§

#### const PANIC_ON_ALLOC_FAIL: bool = true

Should the machine panic on allocation failures?
source§

#### fn enforce_alignment(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool

Whether memory accesses should be alignment-checked.
source§

#### fn enforce_validity( _ecx: &InterpCx<'mir, 'tcx, Self>, _layout: TyAndLayout<'tcx> ) -> bool

Whether to enforce the validity invariant for a specific layout.
source§

#### fn before_access_global( _tcx: TyCtxtAt<'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.
source§

#### fn find_mir_or_eval_fn( _ecx: &mut InterpCx<'mir, 'tcx, Self>, _instance: Instance<'tcx>, _abi: Abi, _args: &[FnArg<'tcx, Self::Provenance>], _destination: &MPlaceTy<'tcx, Self::Provenance>, _target: Option<BasicBlock>, _unwind: UnwindAction ) -> InterpResult<'tcx, Option<(&'mir Body<'tcx>, Instance<'tcx>)>>

Entry point to all function calls. Read more
source§

#### fn panic_nounwind( _ecx: &mut InterpCx<'mir, 'tcx, Self>, _msg: &str ) -> InterpResult<'tcx>

Called to trigger a non-unwinding panic.
source§

#### fn call_intrinsic( _ecx: &mut InterpCx<'mir, 'tcx, Self>, _instance: Instance<'tcx>, _args: &[OpTy<'tcx, Self::Provenance>], _destination: &MPlaceTy<'tcx, Self::Provenance>, _target: Option<BasicBlock>, _unwind: UnwindAction ) -> InterpResult<'tcx>

Directly process an intrinsic without pushing a stack frame. It is the hook’s responsibility to advance the instruction pointer as appropriate.
source§

#### fn assert_panic( _ecx: &mut InterpCx<'mir, 'tcx, Self>, _msg: &AssertMessage<'tcx>, _unwind: UnwindAction ) -> 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, Self::Provenance>, right: &ImmTy<'tcx, Self::Provenance> ) -> InterpResult<'tcx, (ImmTy<'tcx, Self::Provenance>, bool)>

Called for all binary operations where the LHS has pointer type. Read more
source§

#### fn expose_ptr( _ecx: &mut InterpCx<'mir, 'tcx, Self>, _ptr: Pointer<Self::Provenance> ) -> InterpResult<'tcx>

Marks a pointer as exposed, allowing it’s provenance to be recovered. “Pointer-to-int cast”
source§

#### fn init_frame_extra( _ecx: &mut InterpCx<'mir, 'tcx, Self>, _frame: Frame<'mir, 'tcx, Self::Provenance> ) -> InterpResult<'tcx, Frame<'mir, 'tcx, Self::Provenance, Self::FrameExtra>>

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>]

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>>

Mutably borrow the current thread’s stack.
source§

#### const POST_MONO_CHECKS: bool = true

Should post-monomorphization checks be run when a stack frame is pushed?
source§

#### fn alignment_check( _ecx: &InterpCx<'mir, 'tcx, Self>, _alloc_id: AllocId, _alloc_align: Align, _alloc_kind: AllocKind, _offset: Size, _align: Align ) -> Option<Misalignment>

Gives the machine a chance to detect more misalignment than the built-in checks would catch.
source§

#### fn enforce_abi(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool

Whether function calls should be ABI-checked.
source§

#### fn load_mir( ecx: &InterpCx<'mir, 'tcx, Self>, instance: InstanceDef<'tcx> ) -> Result<&'tcx Body<'tcx>, InterpErrorInfo<'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, …
source§

#### fn generate_nan<F1, F2>(_ecx: &InterpCx<'mir, 'tcx, Self>, _inputs: &[F1]) -> F2
where F1: Float + FloatConvert<F2>, F2: Float,

Generate the NaN returned by a float operation, given the list of inputs. (This is all inputs, not just NaN inputs!)
source§

#### fn before_terminator( _ecx: &mut InterpCx<'mir, 'tcx, Self> ) -> Result<(), InterpErrorInfo<'tcx>>

Called before a basic block terminator is executed.
source§

#### fn increment_const_eval_counter( _ecx: &mut InterpCx<'mir, 'tcx, Self> ) -> Result<(), InterpErrorInfo<'tcx>>

Called when the interpreter encounters a `StatementKind::ConstEvalCounter` instruction. You can use this to detect long or endlessly running programs.
source§

#### 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.
source§

#### fn eval_inline_asm( _ecx: &mut InterpCx<'mir, 'tcx, Self>, _template: &'tcx [InlineAsmTemplatePiece], _operands: &[InlineAsmOperand<'tcx>], _options: InlineAsmOptions, _targets: &[BasicBlock] ) -> Result<(), InterpErrorInfo<'tcx>>

Evaluate the inline assembly. Read more
source§

#### fn before_memory_read( _tcx: TyCtxtAt<'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
source§

#### fn before_alloc_read( _ecx: &InterpCx<'mir, 'tcx, Self>, _alloc_id: AllocId ) -> Result<(), InterpErrorInfo<'tcx>>

Hook for performing extra checks on any memory read access, that involves an allocation, even ZST reads. Read more
source§

#### fn before_memory_write( _tcx: TyCtxtAt<'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. This is not invoked for ZST accesses, as no write actually happens.
source§

#### fn before_memory_deallocation( _tcx: TyCtxtAt<'tcx>, _machine: &mut Self, _alloc_extra: &mut Self::AllocExtra, _prov: (AllocId, Self::ProvenanceExtra), _size: Size, _align: Align ) -> Result<(), InterpErrorInfo<'tcx>>

Hook for performing extra operations on a memory deallocation.
source§

#### 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.
source§

#### 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.
source§

#### fn protect_in_place_function_argument( ecx: &mut InterpCx<'mir, 'tcx, Self>, mplace: &MPlaceTy<'tcx, Self::Provenance> ) -> Result<(), InterpErrorInfo<'tcx>>

Called on places used for in-place function argument and return value handling. Read more
source§

#### 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.
source§

#### fn before_stack_pop( _ecx: &InterpCx<'mir, 'tcx, Self>, _frame: &Frame<'mir, 'tcx, Self::Provenance, Self::FrameExtra> ) -> Result<(), InterpErrorInfo<'tcx>>

Called just before the return value is copied to the caller-provided return place.
source§

#### 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!
source§

#### fn after_local_allocated( _ecx: &mut InterpCx<'mir, 'tcx, Self>, _local: Local, _mplace: &MPlaceTy<'tcx, Self::Provenance> ) -> Result<(), InterpErrorInfo<'tcx>>

Called immediately after actual memory was allocated for a local but before the local’s stack frame is updated to point to that memory.
source§

#### fn eval_mir_constant<F>( ecx: &InterpCx<'mir, 'tcx, Self>, val: Const<'tcx>, span: Span, layout: Option<TyAndLayout<'tcx, Ty<'tcx>>>, eval: F ) -> Result<OpTy<'tcx, Self::Provenance>, InterpErrorInfo<'tcx>>
where F: Fn(&InterpCx<'mir, 'tcx, Self>, Const<'tcx>, Span, Option<TyAndLayout<'tcx, Ty<'tcx>>>) -> Result<OpTy<'tcx, Self::Provenance>, InterpErrorInfo<'tcx>>,

Evaluate the given constant. The `eval` function will do all the required evaluation, but this hook has the chance to do some pre/postprocessing.

## Auto Trait Implementations§

§

### impl DynSend for DummyMachine

§

### impl DynSync for DummyMachine

§

### impl Freeze for DummyMachine

§

### impl RefUnwindSafe for DummyMachine

§

### impl Send for DummyMachine

§

### impl Sync for DummyMachine

§

### impl Unpin for DummyMachine

§

### impl UnwindSafe for DummyMachine

## Blanket Implementations§

source§

### impl<T> Aligned for T

source§

#### const ALIGN: Alignment = _

Alignment of `Self`.
source§

### impl<T> Any for T
where T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for T
where T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T, R> CollectAndApply<T, R> for T

source§

#### fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to `f(&iter.collect::<Vec<_>>())`.

§

#### type Output = R

§

### impl<T> Filterable for T

§

#### fn filterable( self, filter_name: &'static str ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>

Creates a filterable data provider with the given name for debugging. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T> Instrument for T

source§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
source§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
source§

### impl<T, U> Into<U> for T
where U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<P> IntoQueryParam<P> for P

source§

#### fn into_query_param(self) -> P

source§

### impl<T> MaybeResult<T> for T

§

#### type Error = !

source§

#### fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

source§

#### fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

§

### impl<T> Pointable for T

§

#### const ALIGN: usize = _

The alignment of pointer.
§

#### type Init = T

The type for initializers.
§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

### impl<T> Same for T

§

#### type Output = T

Should always be `Self`
source§

### impl<'tcx, T> ToPredicate<'tcx, T> for T

source§

#### fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> T

source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

### impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

#### fn vzip(self) -> V

source§

### impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

source§

#### default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed ) -> T

source§

### impl<T> WithSubscriber for T

source§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
source§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
source§

### impl<'a, T> Captures<'a> for T
where T: ?Sized,

source§

### impl<'a, T> Captures<'a> for T
where T: ?Sized,

§

### impl<T> ErasedDestructor for T
where T: 'static,

§

### impl<T> MaybeSendSync for T
where T: Send + Sync,

## 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: 0 bytes