[−][src]Struct rustc_mir::interpret::eval_context::InterpCx
Fields
machine: M
Stores the Machine
instance.
Note: the stack is provided by the machine.
tcx: TyCtxtAt<'tcx>
The results of the type checker, from rustc. The span in this is the "root" of the evaluation, i.e., the const we are evaluating (if this is CTFE).
param_env: ParamEnv<'tcx>
Bounds in scope for polymorphic evaluations.
memory: Memory<'mir, 'tcx, M>
The virtual memory system.
vtables: FxHashMap<(Ty<'tcx>, Option<PolyExistentialTraitRef<'tcx>>), Pointer<M::PointerTag>>
A cache for deduplicating vtables
Implementations
impl<'mir, 'tcx> InterpCx<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>>
[src]
fn hook_panic_fn(
&mut self,
instance: Instance<'tcx>,
args: &[OpTy<'tcx>]
) -> InterpResult<'tcx>
[src]
&mut self,
instance: Instance<'tcx>,
args: &[OpTy<'tcx>]
) -> InterpResult<'tcx>
"Intercept" a function call to a panic-related function
because we have something special to do for it.
If this returns successfully (Ok
), the function should just be evaluated normally.
impl<'mir, 'tcx: 'mir> InterpCx<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>>
[src]
fn guaranteed_eq(&mut self, a: Scalar, b: Scalar) -> bool
[src]
fn guaranteed_ne(&mut self, a: Scalar, b: Scalar) -> bool
[src]
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M>
[src]
pub fn cast(
&mut self,
src: OpTy<'tcx, M::PointerTag>,
cast_kind: CastKind,
cast_ty: Ty<'tcx>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
src: OpTy<'tcx, M::PointerTag>,
cast_kind: CastKind,
cast_ty: Ty<'tcx>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
fn misc_cast(
&self,
src: ImmTy<'tcx, M::PointerTag>,
cast_ty: Ty<'tcx>
) -> InterpResult<'tcx, Immediate<M::PointerTag>>
[src]
&self,
src: ImmTy<'tcx, M::PointerTag>,
cast_ty: Ty<'tcx>
) -> InterpResult<'tcx, Immediate<M::PointerTag>>
pub(super) fn cast_from_scalar(
&self,
v: u128,
src_layout: TyAndLayout<'tcx>,
cast_ty: Ty<'tcx>
) -> Scalar<M::PointerTag>
[src]
&self,
v: u128,
src_layout: TyAndLayout<'tcx>,
cast_ty: Ty<'tcx>
) -> Scalar<M::PointerTag>
fn cast_from_float<F>(&self, f: F, dest_ty: Ty<'tcx>) -> Scalar<M::PointerTag> where
F: Float + Into<Scalar<M::PointerTag>> + FloatConvert<Single> + FloatConvert<Double>,
[src]
F: Float + Into<Scalar<M::PointerTag>> + FloatConvert<Single> + FloatConvert<Double>,
fn unsize_into_ptr(
&mut self,
src: OpTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>,
source_ty: Ty<'tcx>,
cast_ty: Ty<'tcx>
) -> InterpResult<'tcx>
[src]
&mut self,
src: OpTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>,
source_ty: Ty<'tcx>,
cast_ty: Ty<'tcx>
) -> InterpResult<'tcx>
fn unsize_into(
&mut self,
src: OpTy<'tcx, M::PointerTag>,
cast_ty: TyAndLayout<'tcx>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
src: OpTy<'tcx, M::PointerTag>,
cast_ty: TyAndLayout<'tcx>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M>
[src]
pub fn new(
tcx: TyCtxt<'tcx>,
root_span: Span,
param_env: ParamEnv<'tcx>,
machine: M,
memory_extra: M::MemoryExtra
) -> Self
[src]
tcx: TyCtxt<'tcx>,
root_span: Span,
param_env: ParamEnv<'tcx>,
machine: M,
memory_extra: M::MemoryExtra
) -> Self
pub fn cur_span(&self) -> Span
[src]
pub fn force_ptr(
&self,
scalar: Scalar<M::PointerTag>
) -> InterpResult<'tcx, Pointer<M::PointerTag>>
[src]
&self,
scalar: Scalar<M::PointerTag>
) -> InterpResult<'tcx, Pointer<M::PointerTag>>
pub fn force_bits(
&self,
scalar: Scalar<M::PointerTag>,
size: Size
) -> InterpResult<'tcx, u128>
[src]
&self,
scalar: Scalar<M::PointerTag>,
size: Size
) -> InterpResult<'tcx, u128>
pub fn global_base_pointer(
&self,
ptr: Pointer
) -> InterpResult<'tcx, Pointer<M::PointerTag>>
[src]
&self,
ptr: Pointer
) -> InterpResult<'tcx, Pointer<M::PointerTag>>
Call this to turn untagged "global" pointers (obtained via tcx
) into
the machine pointer to the allocation. Must never be used
for any other pointers, nor for TLS statics.
Using the resulting pointer represents a direct access to that memory
(e.g. by directly using a static
),
as opposed to access through a pointer that was created by the program.
This function can fail only if ptr
points to an extern static
.
pub(crate) fn stack(&self) -> &[Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>]
[src]
pub(crate) fn stack_mut(
&mut self
) -> &mut Vec<Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>>
[src]
&mut self
) -> &mut Vec<Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>>
pub fn frame_idx(&self) -> usize
[src]
pub fn frame(&self) -> &Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>
[src]
pub fn frame_mut(
&mut self
) -> &mut Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>
[src]
&mut self
) -> &mut Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>
pub(super) fn body(&self) -> &'mir Body<'tcx>
[src]
pub fn sign_extend(&self, value: u128, ty: TyAndLayout<'_>) -> u128
[src]
pub fn truncate(&self, value: u128, ty: TyAndLayout<'_>) -> u128
[src]
pub fn type_is_sized(&self, ty: Ty<'tcx>) -> bool
[src]
pub fn type_is_freeze(&self, ty: Ty<'tcx>) -> bool
[src]
pub fn load_mir(
&self,
instance: InstanceDef<'tcx>,
promoted: Option<Promoted>
) -> InterpResult<'tcx, &'tcx Body<'tcx>>
[src]
&self,
instance: InstanceDef<'tcx>,
promoted: Option<Promoted>
) -> InterpResult<'tcx, &'tcx Body<'tcx>>
pub(super) fn subst_from_current_frame_and_normalize_erasing_regions<T: TypeFoldable<'tcx>>(
&self,
value: T
) -> T
[src]
&self,
value: T
) -> T
Call this on things you got out of the MIR (so it is as generic as the current stack frame), to bring it into the proper environment for this interpreter.
pub(super) fn subst_from_frame_and_normalize_erasing_regions<T: TypeFoldable<'tcx>>(
&self,
frame: &Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>,
value: T
) -> T
[src]
&self,
frame: &Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>,
value: T
) -> T
Call this on things you got out of the MIR (so it is as generic as the provided stack frame), to bring it into the proper environment for this interpreter.
pub(super) fn resolve(
&self,
def: WithOptConstParam<DefId>,
substs: SubstsRef<'tcx>
) -> InterpResult<'tcx, Instance<'tcx>>
[src]
&self,
def: WithOptConstParam<DefId>,
substs: SubstsRef<'tcx>
) -> InterpResult<'tcx, Instance<'tcx>>
The substs
are assumed to already be in our interpreter "universe" (param_env).
pub fn layout_of_local(
&self,
frame: &Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>,
local: Local,
layout: Option<TyAndLayout<'tcx>>
) -> InterpResult<'tcx, TyAndLayout<'tcx>>
[src]
&self,
frame: &Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>,
local: Local,
layout: Option<TyAndLayout<'tcx>>
) -> InterpResult<'tcx, TyAndLayout<'tcx>>
pub(super) fn size_and_align_of(
&self,
metadata: MemPlaceMeta<M::PointerTag>,
layout: TyAndLayout<'tcx>
) -> InterpResult<'tcx, Option<(Size, Align)>>
[src]
&self,
metadata: MemPlaceMeta<M::PointerTag>,
layout: TyAndLayout<'tcx>
) -> InterpResult<'tcx, Option<(Size, Align)>>
Returns the actual dynamic size and alignment of the place at the given type. Only the "meta" (metadata) part of the place matters. This can fail to provide an answer for extern types.
pub fn size_and_align_of_mplace(
&self,
mplace: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, Option<(Size, Align)>>
[src]
&self,
mplace: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, Option<(Size, Align)>>
pub fn push_stack_frame(
&mut self,
instance: Instance<'tcx>,
body: &'mir Body<'tcx>,
return_place: Option<PlaceTy<'tcx, M::PointerTag>>,
return_to_block: StackPopCleanup
) -> InterpResult<'tcx>
[src]
&mut self,
instance: Instance<'tcx>,
body: &'mir Body<'tcx>,
return_place: Option<PlaceTy<'tcx, M::PointerTag>>,
return_to_block: StackPopCleanup
) -> InterpResult<'tcx>
pub fn go_to_block(&mut self, target: BasicBlock)
[src]
Jump to the given block.
pub fn return_to_block(
&mut self,
target: Option<BasicBlock>
) -> InterpResult<'tcx>
[src]
&mut self,
target: Option<BasicBlock>
) -> InterpResult<'tcx>
Return to the given target
basic block.
Do not use for unwinding! Use unwind_to_block
instead.
If target
is None
, that indicates the function cannot return, so we raise UB.
pub fn unwind_to_block(&mut self, target: Option<BasicBlock>)
[src]
Unwind to the given target
basic block.
Do not use for returning! Use return_to_block
instead.
If target
is None
, that indicates the function does not need cleanup during
unwinding, and we will just keep propagating that upwards.
pub(super) fn pop_stack_frame(&mut self, unwinding: bool) -> InterpResult<'tcx>
[src]
Pops the current frame from the stack, deallocating the memory for allocated locals.
If unwinding
is false
, then we are performing a normal return
from a function. In this case, we jump back into the frame of the caller,
and continue execution as normal.
If unwinding
is true
, then we are in the middle of a panic,
and need to unwind this frame. In this case, we jump to the
cleanup
block for the function, which is responsible for running
Drop
impls for any locals that have been initialized at this point.
The cleanup block ends with a special Resume
terminator, which will
cause us to continue unwinding.
pub fn storage_live(&mut self, local: Local) -> InterpResult<'tcx>
[src]
Mark a storage as live, killing the previous content.
pub fn storage_dead(&mut self, local: Local) -> InterpResult<'tcx>
[src]
fn deallocate_local(
&mut self,
local: LocalValue<M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
local: LocalValue<M::PointerTag>
) -> InterpResult<'tcx>
pub fn eval_to_allocation(
&self,
gid: GlobalId<'tcx>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
[src]
&self,
gid: GlobalId<'tcx>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
#[must_use]pub fn dump_place<'a>(
&'a self,
place: Place<M::PointerTag>
) -> PlacePrinter<'a, 'mir, 'tcx, M>
[src]
&'a self,
place: Place<M::PointerTag>
) -> PlacePrinter<'a, 'mir, 'tcx, M>
#[must_use]pub fn generate_stacktrace(&self) -> Vec<FrameInfo<'tcx>>
[src]
impl<'mir, 'tcx: 'mir, M: CompileTimeMachine<'mir, 'tcx, !>> InterpCx<'mir, 'tcx, M>
[src]
pub(crate) fn intern_with_temp_alloc(
&mut self,
layout: TyAndLayout<'tcx>,
f: impl FnOnce(&mut InterpCx<'mir, 'tcx, M>, MPlaceTy<'tcx, M::PointerTag>) -> InterpResult<'tcx, ()>
) -> InterpResult<'tcx, &'tcx Allocation>
[src]
&mut self,
layout: TyAndLayout<'tcx>,
f: impl FnOnce(&mut InterpCx<'mir, 'tcx, M>, MPlaceTy<'tcx, M::PointerTag>) -> InterpResult<'tcx, ()>
) -> InterpResult<'tcx, &'tcx Allocation>
A helper function that allocates memory for the layout given and gives you access to mutate
it. Once your own mutation code is done, the backing Allocation
is removed from the
current Memory
and returned.
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M>
[src]
pub(crate) fn find_closest_untracked_caller_location(&self) -> Span
[src]
Walks up the callstack from the intrinsic's callsite, searching for the first callsite in a
frame which is not #[track_caller]
.
pub(crate) fn alloc_caller_location(
&mut self,
filename: Symbol,
line: u32,
col: u32
) -> MPlaceTy<'tcx, M::PointerTag>
[src]
&mut self,
filename: Symbol,
line: u32,
col: u32
) -> MPlaceTy<'tcx, M::PointerTag>
Allocate a const core::panic::Location
with the provided filename and line/column numbers.
pub(crate) fn location_triple_for_span(&self, span: Span) -> (Symbol, u32, u32)
[src]
pub fn alloc_caller_location_for_span(
&mut self,
span: Span
) -> MPlaceTy<'tcx, M::PointerTag>
[src]
&mut self,
span: Span
) -> MPlaceTy<'tcx, M::PointerTag>
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M>
[src]
pub fn emulate_intrinsic(
&mut self,
instance: Instance<'tcx>,
args: &[OpTy<'tcx, M::PointerTag>],
ret: Option<(PlaceTy<'tcx, M::PointerTag>, BasicBlock)>
) -> InterpResult<'tcx, bool>
[src]
&mut self,
instance: Instance<'tcx>,
args: &[OpTy<'tcx, M::PointerTag>],
ret: Option<(PlaceTy<'tcx, M::PointerTag>, BasicBlock)>
) -> InterpResult<'tcx, bool>
Returns true
if emulation happened.
Here we implement the intrinsics that are common to all Miri instances; individual machines can add their own
intrinsic handling.
pub fn exact_div(
&mut self,
a: ImmTy<'tcx, M::PointerTag>,
b: ImmTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
a: ImmTy<'tcx, M::PointerTag>,
b: ImmTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
pub fn ptr_offset_inbounds(
&self,
ptr: Scalar<M::PointerTag>,
pointee_ty: Ty<'tcx>,
offset_count: i64
) -> InterpResult<'tcx, Scalar<M::PointerTag>>
[src]
&self,
ptr: Scalar<M::PointerTag>,
pointee_ty: Ty<'tcx>,
offset_count: i64
) -> InterpResult<'tcx, Scalar<M::PointerTag>>
Offsets a pointer by some multiple of its type, returning an error if the pointer leaves its allocation. For integer pointers, we consider each of them their own tiny allocation of size 0, so offset-by-0 (and only 0) is okay -- except that NULL cannot be offset by any value.
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M>
[src]
pub fn force_op_ptr(
&self,
op: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
[src]
&self,
op: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
Normalice place.ptr
to a Pointer
if this is a place and not a ZST.
Can be helpful to avoid lots of force_ptr
calls later, if this place is used a lot.
fn try_read_immediate_from_mplace(
&self,
mplace: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, Option<ImmTy<'tcx, M::PointerTag>>>
[src]
&self,
mplace: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, Option<ImmTy<'tcx, M::PointerTag>>>
Try reading an immediate in memory; this is interesting particularly for ScalarPair
.
Returns None
if the layout does not permit loading this as a value.
pub(crate) fn try_read_immediate(
&self,
src: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, Result<ImmTy<'tcx, M::PointerTag>, MPlaceTy<'tcx, M::PointerTag>>>
[src]
&self,
src: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, Result<ImmTy<'tcx, M::PointerTag>, MPlaceTy<'tcx, M::PointerTag>>>
Try returning an immediate for the operand.
If the layout does not permit loading this as an immediate, return where in memory
we can find the data.
Note that for a given layout, this operation will either always fail or always
succeed! Whether it succeeds depends on whether the layout can be represented
in a Immediate
, not on which data is stored there currently.
pub fn read_immediate(
&self,
op: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, ImmTy<'tcx, M::PointerTag>>
[src]
&self,
op: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, ImmTy<'tcx, M::PointerTag>>
Read an immediate from a place, asserting that that is possible with the given layout.
pub fn read_scalar(
&self,
op: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, ScalarMaybeUninit<M::PointerTag>>
[src]
&self,
op: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, ScalarMaybeUninit<M::PointerTag>>
Read a scalar from a place
pub fn read_str(
&self,
mplace: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, &str>
[src]
&self,
mplace: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, &str>
pub fn operand_field(
&self,
op: OpTy<'tcx, M::PointerTag>,
field: usize
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
[src]
&self,
op: OpTy<'tcx, M::PointerTag>,
field: usize
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
Projection functions
pub fn operand_index(
&self,
op: OpTy<'tcx, M::PointerTag>,
index: u64
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
[src]
&self,
op: OpTy<'tcx, M::PointerTag>,
index: u64
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
pub fn operand_downcast(
&self,
op: OpTy<'tcx, M::PointerTag>,
variant: VariantIdx
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
[src]
&self,
op: OpTy<'tcx, M::PointerTag>,
variant: VariantIdx
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
pub fn operand_projection(
&self,
base: OpTy<'tcx, M::PointerTag>,
proj_elem: PlaceElem<'tcx>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
[src]
&self,
base: OpTy<'tcx, M::PointerTag>,
proj_elem: PlaceElem<'tcx>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
pub fn access_local(
&self,
frame: &Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>,
local: Local,
layout: Option<TyAndLayout<'tcx>>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
[src]
&self,
frame: &Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>,
local: Local,
layout: Option<TyAndLayout<'tcx>>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
Read from a local. Will not actually access the local if reading from a ZST.
Will not access memory, instead an indirect Operand
is returned.
This is public because it is used by priroda to get an OpTy from a local
pub fn place_to_op(
&self,
place: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
[src]
&self,
place: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
Every place can be read from, so we can turn them into an operand.
This will definitely return Indirect
if the place is a Ptr
, i.e., this
will never actually read from memory.
pub fn eval_place_to_op(
&self,
place: Place<'tcx>,
layout: Option<TyAndLayout<'tcx>>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
[src]
&self,
place: Place<'tcx>,
layout: Option<TyAndLayout<'tcx>>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
pub fn eval_operand(
&self,
mir_op: &Operand<'tcx>,
layout: Option<TyAndLayout<'tcx>>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
[src]
&self,
mir_op: &Operand<'tcx>,
layout: Option<TyAndLayout<'tcx>>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
Evaluate the operand, returning a place where you can then find the data. If you already know the layout, you can save two table lookups by passing it in here.
pub(super) fn eval_operands(
&self,
ops: &[Operand<'tcx>]
) -> InterpResult<'tcx, Vec<OpTy<'tcx, M::PointerTag>>>
[src]
&self,
ops: &[Operand<'tcx>]
) -> InterpResult<'tcx, Vec<OpTy<'tcx, M::PointerTag>>>
Evaluate a bunch of operands at once
pub(crate) fn const_to_op(
&self,
val: &Const<'tcx>,
layout: Option<TyAndLayout<'tcx>>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
[src]
&self,
val: &Const<'tcx>,
layout: Option<TyAndLayout<'tcx>>
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>>
The val
and layout
are assumed to already be in our interpreter
"universe" (param_env).
pub fn read_discriminant(
&self,
op: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, (Scalar<M::PointerTag>, VariantIdx)>
[src]
&self,
op: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, (Scalar<M::PointerTag>, VariantIdx)>
Read discriminant, return the runtime value as well as the variant index.
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M>
[src]
pub fn binop_with_overflow(
&mut self,
op: BinOp,
left: ImmTy<'tcx, M::PointerTag>,
right: ImmTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
op: BinOp,
left: ImmTy<'tcx, M::PointerTag>,
right: ImmTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
Applies the binary operation op
to the two operands and writes a tuple of the result
and a boolean signifying the potential overflow to the destination.
pub fn binop_ignore_overflow(
&mut self,
op: BinOp,
left: ImmTy<'tcx, M::PointerTag>,
right: ImmTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
op: BinOp,
left: ImmTy<'tcx, M::PointerTag>,
right: ImmTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
Applies the binary operation op
to the arguments and writes the result to the
destination.
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M>
[src]
fn binary_char_op(
&self,
bin_op: BinOp,
l: char,
r: char
) -> (Scalar<M::PointerTag>, bool, Ty<'tcx>)
[src]
&self,
bin_op: BinOp,
l: char,
r: char
) -> (Scalar<M::PointerTag>, bool, Ty<'tcx>)
fn binary_bool_op(
&self,
bin_op: BinOp,
l: bool,
r: bool
) -> (Scalar<M::PointerTag>, bool, Ty<'tcx>)
[src]
&self,
bin_op: BinOp,
l: bool,
r: bool
) -> (Scalar<M::PointerTag>, bool, Ty<'tcx>)
fn binary_float_op<F: Float + Into<Scalar<M::PointerTag>>>(
&self,
bin_op: BinOp,
ty: Ty<'tcx>,
l: F,
r: F
) -> (Scalar<M::PointerTag>, bool, Ty<'tcx>)
[src]
&self,
bin_op: BinOp,
ty: Ty<'tcx>,
l: F,
r: F
) -> (Scalar<M::PointerTag>, bool, Ty<'tcx>)
fn binary_int_op(
&self,
bin_op: BinOp,
l: u128,
left_layout: TyAndLayout<'tcx>,
r: u128,
right_layout: TyAndLayout<'tcx>
) -> InterpResult<'tcx, (Scalar<M::PointerTag>, bool, Ty<'tcx>)>
[src]
&self,
bin_op: BinOp,
l: u128,
left_layout: TyAndLayout<'tcx>,
r: u128,
right_layout: TyAndLayout<'tcx>
) -> InterpResult<'tcx, (Scalar<M::PointerTag>, bool, Ty<'tcx>)>
pub fn overflowing_binary_op(
&self,
bin_op: BinOp,
left: ImmTy<'tcx, M::PointerTag>,
right: ImmTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, (Scalar<M::PointerTag>, bool, Ty<'tcx>)>
[src]
&self,
bin_op: BinOp,
left: ImmTy<'tcx, M::PointerTag>,
right: ImmTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, (Scalar<M::PointerTag>, bool, Ty<'tcx>)>
Returns the result of the specified operation, whether it overflowed, and the result type.
pub fn binary_op(
&self,
bin_op: BinOp,
left: ImmTy<'tcx, M::PointerTag>,
right: ImmTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, ImmTy<'tcx, M::PointerTag>>
[src]
&self,
bin_op: BinOp,
left: ImmTy<'tcx, M::PointerTag>,
right: ImmTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, ImmTy<'tcx, M::PointerTag>>
Typed version of overflowing_binary_op
, returning an ImmTy
. Also ignores overflows.
pub fn overflowing_unary_op(
&self,
un_op: UnOp,
val: ImmTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, (Scalar<M::PointerTag>, bool, Ty<'tcx>)>
[src]
&self,
un_op: UnOp,
val: ImmTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, (Scalar<M::PointerTag>, bool, Ty<'tcx>)>
Returns the result of the specified operation, whether it overflowed, and the result type.
pub fn unary_op(
&self,
un_op: UnOp,
val: ImmTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, ImmTy<'tcx, M::PointerTag>>
[src]
&self,
un_op: UnOp,
val: ImmTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, ImmTy<'tcx, M::PointerTag>>
impl<'mir, 'tcx: 'mir, Tag, M> InterpCx<'mir, 'tcx, M> where
Tag: Debug + Copy + Eq + Hash + 'static,
M: Machine<'mir, 'tcx, PointerTag = Tag>,
M::MemoryMap: AllocMap<AllocId, (MemoryKind<M::MemoryKind>, Allocation<Tag, M::AllocExtra>)>,
M::AllocExtra: AllocationExtra<Tag>,
[src]
Tag: Debug + Copy + Eq + Hash + 'static,
M: Machine<'mir, 'tcx, PointerTag = Tag>,
M::MemoryMap: AllocMap<AllocId, (MemoryKind<M::MemoryKind>, Allocation<Tag, M::AllocExtra>)>,
M::AllocExtra: AllocationExtra<Tag>,
pub fn ref_to_mplace(
&self,
val: ImmTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
[src]
&self,
val: ImmTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
Take a value, which represents a (thin or wide) reference, and make it a place.
Alignment is just based on the type. This is the inverse of MemPlace::to_ref()
.
Only call this if you are sure the place is "valid" (aligned and inbounds), or do not
want to ever use the place for memory access!
Generally prefer deref_operand
.
pub fn deref_operand(
&self,
src: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
[src]
&self,
src: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
Take an operand, representing a pointer, and dereference it to a place -- that
will always be a MemPlace. Lives in place.rs
because it creates a place.
pub(super) fn check_mplace_access(
&self,
place: MPlaceTy<'tcx, M::PointerTag>,
size: Option<Size>
) -> InterpResult<'tcx, Option<Pointer<M::PointerTag>>>
[src]
&self,
place: MPlaceTy<'tcx, M::PointerTag>,
size: Option<Size>
) -> InterpResult<'tcx, Option<Pointer<M::PointerTag>>>
Check if the given place is good for memory access with the given
size, falling back to the layout's size if None
(in the latter case,
this must be a statically sized type).
On success, returns None
for zero-sized accesses (where nothing else is
left to do) and a Pointer
to use for the actual access otherwise.
pub fn mplace_access_checked(
&self,
mut place: MPlaceTy<'tcx, M::PointerTag>,
force_align: Option<Align>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
[src]
&self,
mut place: MPlaceTy<'tcx, M::PointerTag>,
force_align: Option<Align>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
Return the "access-checked" version of this MPlace
, where for non-ZST
this is definitely a Pointer
.
force_align
must only be used when correct alignment does not matter,
like in Stacked Borrows.
pub(super) fn force_mplace_ptr(
&self,
mut place: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
[src]
&self,
mut place: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
Force place.ptr
to a Pointer
.
Can be helpful to avoid lots of force_ptr
calls later, if this place is used a lot.
pub fn mplace_field(
&self,
base: MPlaceTy<'tcx, M::PointerTag>,
field: usize
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
[src]
&self,
base: MPlaceTy<'tcx, M::PointerTag>,
field: usize
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
Offset a pointer to project to a field of a struct/union. Unlike place_field
, this is
always possible without allocating, so it can take &self
. Also return the field's layout.
This supports both struct and array fields.
This also works for arrays, but then the usize
index type is restricting.
For indexing into arrays, use mplace_index
.
pub fn mplace_index(
&self,
base: MPlaceTy<'tcx, M::PointerTag>,
index: u64
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
[src]
&self,
base: MPlaceTy<'tcx, M::PointerTag>,
index: u64
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
Index into an array.
pub(super) fn mplace_array_fields(
&self,
base: MPlaceTy<'tcx, Tag>
) -> InterpResult<'tcx, impl Iterator<Item = InterpResult<'tcx, MPlaceTy<'tcx, Tag>>> + 'tcx>
[src]
&self,
base: MPlaceTy<'tcx, Tag>
) -> InterpResult<'tcx, impl Iterator<Item = InterpResult<'tcx, MPlaceTy<'tcx, Tag>>> + 'tcx>
fn mplace_subslice(
&self,
base: MPlaceTy<'tcx, M::PointerTag>,
from: u64,
to: u64,
from_end: bool
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
[src]
&self,
base: MPlaceTy<'tcx, M::PointerTag>,
from: u64,
to: u64,
from_end: bool
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
pub(super) fn mplace_downcast(
&self,
base: MPlaceTy<'tcx, M::PointerTag>,
variant: VariantIdx
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
[src]
&self,
base: MPlaceTy<'tcx, M::PointerTag>,
variant: VariantIdx
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
pub(super) fn mplace_projection(
&self,
base: MPlaceTy<'tcx, M::PointerTag>,
proj_elem: PlaceElem<'tcx>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
[src]
&self,
base: MPlaceTy<'tcx, M::PointerTag>,
proj_elem: PlaceElem<'tcx>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
Project into an mplace
pub fn place_field(
&mut self,
base: PlaceTy<'tcx, M::PointerTag>,
field: usize
) -> InterpResult<'tcx, PlaceTy<'tcx, M::PointerTag>>
[src]
&mut self,
base: PlaceTy<'tcx, M::PointerTag>,
field: usize
) -> InterpResult<'tcx, PlaceTy<'tcx, M::PointerTag>>
Gets the place of a field inside the place, and also the field's type.
Just a convenience function, but used quite a bit.
This is the only projection that might have a side-effect: We cannot project
into the field of a local ScalarPair
, we have to first allocate it.
pub fn place_index(
&mut self,
base: PlaceTy<'tcx, M::PointerTag>,
index: u64
) -> InterpResult<'tcx, PlaceTy<'tcx, M::PointerTag>>
[src]
&mut self,
base: PlaceTy<'tcx, M::PointerTag>,
index: u64
) -> InterpResult<'tcx, PlaceTy<'tcx, M::PointerTag>>
pub fn place_downcast(
&self,
base: PlaceTy<'tcx, M::PointerTag>,
variant: VariantIdx
) -> InterpResult<'tcx, PlaceTy<'tcx, M::PointerTag>>
[src]
&self,
base: PlaceTy<'tcx, M::PointerTag>,
variant: VariantIdx
) -> InterpResult<'tcx, PlaceTy<'tcx, M::PointerTag>>
pub fn place_projection(
&mut self,
base: PlaceTy<'tcx, M::PointerTag>,
&proj_elem: &ProjectionElem<Local, Ty<'tcx>>
) -> InterpResult<'tcx, PlaceTy<'tcx, M::PointerTag>>
[src]
&mut self,
base: PlaceTy<'tcx, M::PointerTag>,
&proj_elem: &ProjectionElem<Local, Ty<'tcx>>
) -> InterpResult<'tcx, PlaceTy<'tcx, M::PointerTag>>
Projects into a place.
pub fn eval_place(
&mut self,
place: Place<'tcx>
) -> InterpResult<'tcx, PlaceTy<'tcx, M::PointerTag>>
[src]
&mut self,
place: Place<'tcx>
) -> InterpResult<'tcx, PlaceTy<'tcx, M::PointerTag>>
Computes a place. You should only use this if you intend to write into this
place; for reading, a more efficient alternative is eval_place_for_read
.
pub fn write_scalar(
&mut self,
val: impl Into<ScalarMaybeUninit<M::PointerTag>>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
val: impl Into<ScalarMaybeUninit<M::PointerTag>>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
Write a scalar to a place
pub fn write_immediate(
&mut self,
src: Immediate<M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
src: Immediate<M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
Write an immediate to a place
pub fn write_immediate_to_mplace(
&mut self,
src: Immediate<M::PointerTag>,
dest: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
src: Immediate<M::PointerTag>,
dest: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
Write an Immediate
to memory.
fn write_immediate_no_validate(
&mut self,
src: Immediate<M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
src: Immediate<M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
Write an immediate to a place. If you use this you are responsible for validating that things got copied at the right type.
fn write_immediate_to_mplace_no_validate(
&mut self,
value: Immediate<M::PointerTag>,
dest: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
value: Immediate<M::PointerTag>,
dest: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
Write an immediate to memory. If you use this you are responsible for validating that things got copied at the right type.
pub fn copy_op(
&mut self,
src: OpTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
src: OpTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
Copies the data from an operand to a place. This does not support transmuting!
Use copy_op_transmute
if the layouts could disagree.
fn copy_op_no_validate(
&mut self,
src: OpTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
src: OpTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
Copies the data from an operand to a place. This does not support transmuting!
Use copy_op_transmute
if the layouts could disagree.
Also, if you use this you are responsible for validating that things get copied at the
right type.
pub fn copy_op_transmute(
&mut self,
src: OpTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
src: OpTy<'tcx, M::PointerTag>,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
Copies the data from an operand to a place. The layouts may disagree, but they must have the same size.
pub fn force_allocation_maybe_sized(
&mut self,
place: PlaceTy<'tcx, M::PointerTag>,
meta: MemPlaceMeta<M::PointerTag>
) -> InterpResult<'tcx, (MPlaceTy<'tcx, M::PointerTag>, Option<Size>)>
[src]
&mut self,
place: PlaceTy<'tcx, M::PointerTag>,
meta: MemPlaceMeta<M::PointerTag>
) -> InterpResult<'tcx, (MPlaceTy<'tcx, M::PointerTag>, Option<Size>)>
Ensures that a place is in memory, and returns where it is.
If the place currently refers to a local that doesn't yet have a matching allocation,
create such an allocation.
This is essentially force_to_memplace
.
This supports unsized types and returns the computed size to avoid some
redundant computation when copying; use force_allocation
for a simpler, sized-only
version.
pub fn force_allocation(
&mut self,
place: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
[src]
&mut self,
place: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
pub fn allocate(
&mut self,
layout: TyAndLayout<'tcx>,
kind: MemoryKind<M::MemoryKind>
) -> MPlaceTy<'tcx, M::PointerTag>
[src]
&mut self,
layout: TyAndLayout<'tcx>,
kind: MemoryKind<M::MemoryKind>
) -> MPlaceTy<'tcx, M::PointerTag>
pub fn allocate_str(
&mut self,
str: &str,
kind: MemoryKind<M::MemoryKind>
) -> MPlaceTy<'tcx, M::PointerTag>
[src]
&mut self,
str: &str,
kind: MemoryKind<M::MemoryKind>
) -> MPlaceTy<'tcx, M::PointerTag>
Returns a wide MPlace.
pub fn write_discriminant(
&mut self,
variant_index: VariantIdx,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
variant_index: VariantIdx,
dest: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
Writes the discriminant of the given variant.
pub fn raw_const_to_mplace(
&self,
raw: ConstAlloc<'tcx>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
[src]
&self,
raw: ConstAlloc<'tcx>
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>>
pub(super) fn unpack_dyn_trait(
&self,
mplace: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, (Instance<'tcx>, MPlaceTy<'tcx, M::PointerTag>)>
[src]
&self,
mplace: MPlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx, (Instance<'tcx>, MPlaceTy<'tcx, M::PointerTag>)>
Turn a place with a dyn Trait
type into a place with the actual dynamic type.
Also return some more information so drop doesn't have to run the same code twice.
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M>
[src]
pub fn run(&mut self) -> InterpResult<'tcx>
[src]
pub fn step(&mut self) -> InterpResult<'tcx, bool>
[src]
Returns true
as long as there are more things to do.
This is used by priroda
This is marked #inline(always)
to work around adverserial codegen when opt-level = 3
pub(crate) fn statement(&mut self, stmt: &Statement<'tcx>) -> InterpResult<'tcx>
[src]
Runs the interpretation logic for the given mir::Statement
at the current frame and
statement counter. This also moves the statement counter forward.
pub fn eval_rvalue_into_place(
&mut self,
rvalue: &Rvalue<'tcx>,
place: Place<'tcx>
) -> InterpResult<'tcx>
[src]
&mut self,
rvalue: &Rvalue<'tcx>,
place: Place<'tcx>
) -> InterpResult<'tcx>
Evaluate an assignment statement.
There is no separate eval_rvalue
function. Instead, the code for handling each rvalue
type writes its results directly into the memory specified by the place.
fn terminator(&mut self, terminator: &Terminator<'tcx>) -> InterpResult<'tcx>
[src]
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M>
[src]
pub(super) fn eval_terminator(
&mut self,
terminator: &Terminator<'tcx>
) -> InterpResult<'tcx>
[src]
&mut self,
terminator: &Terminator<'tcx>
) -> InterpResult<'tcx>
fn check_argument_compat(
rust_abi: bool,
caller: TyAndLayout<'tcx>,
callee: TyAndLayout<'tcx>
) -> bool
[src]
rust_abi: bool,
caller: TyAndLayout<'tcx>,
callee: TyAndLayout<'tcx>
) -> bool
fn pass_argument(
&mut self,
rust_abi: bool,
caller_arg: &mut impl Iterator<Item = OpTy<'tcx, M::PointerTag>>,
callee_arg: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&mut self,
rust_abi: bool,
caller_arg: &mut impl Iterator<Item = OpTy<'tcx, M::PointerTag>>,
callee_arg: PlaceTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
Pass a single argument, checking the types for compatibility.
fn eval_fn_call(
&mut self,
fn_val: FnVal<'tcx, M::ExtraFnVal>,
caller_abi: Abi,
args: &[OpTy<'tcx, M::PointerTag>],
ret: Option<(PlaceTy<'tcx, M::PointerTag>, BasicBlock)>,
unwind: Option<BasicBlock>
) -> InterpResult<'tcx>
[src]
&mut self,
fn_val: FnVal<'tcx, M::ExtraFnVal>,
caller_abi: Abi,
args: &[OpTy<'tcx, M::PointerTag>],
ret: Option<(PlaceTy<'tcx, M::PointerTag>, BasicBlock)>,
unwind: Option<BasicBlock>
) -> InterpResult<'tcx>
Call this function -- pushing the stack frame and initializing the arguments.
fn drop_in_place(
&mut self,
place: PlaceTy<'tcx, M::PointerTag>,
instance: Instance<'tcx>,
target: BasicBlock,
unwind: Option<BasicBlock>
) -> InterpResult<'tcx>
[src]
&mut self,
place: PlaceTy<'tcx, M::PointerTag>,
instance: Instance<'tcx>,
target: BasicBlock,
unwind: Option<BasicBlock>
) -> InterpResult<'tcx>
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M>
[src]
pub fn get_vtable(
&mut self,
ty: Ty<'tcx>,
poly_trait_ref: Option<PolyExistentialTraitRef<'tcx>>
) -> InterpResult<'tcx, Pointer<M::PointerTag>>
[src]
&mut self,
ty: Ty<'tcx>,
poly_trait_ref: Option<PolyExistentialTraitRef<'tcx>>
) -> InterpResult<'tcx, Pointer<M::PointerTag>>
Creates a dynamic vtable for the given type and vtable origin. This is used only for objects.
The trait_ref
encodes the erased self type. Hence, if we are
making an object Foo<Trait>
from a value of type Foo<T>
, then
trait_ref
would map T: Trait
.
pub fn get_vtable_slot(
&self,
vtable: Scalar<M::PointerTag>,
idx: u64
) -> InterpResult<'tcx, FnVal<'tcx, M::ExtraFnVal>>
[src]
&self,
vtable: Scalar<M::PointerTag>,
idx: u64
) -> InterpResult<'tcx, FnVal<'tcx, M::ExtraFnVal>>
Resolves the function at the specified slot in the provided vtable. An index of '0' corresponds to the first method declared in the trait of the provided vtable.
pub fn read_drop_type_from_vtable(
&self,
vtable: Scalar<M::PointerTag>
) -> InterpResult<'tcx, (Instance<'tcx>, Ty<'tcx>)>
[src]
&self,
vtable: Scalar<M::PointerTag>
) -> InterpResult<'tcx, (Instance<'tcx>, Ty<'tcx>)>
Returns the drop fn instance as well as the actual dynamic type.
pub fn read_size_and_align_from_vtable(
&self,
vtable: Scalar<M::PointerTag>
) -> InterpResult<'tcx, (Size, Align)>
[src]
&self,
vtable: Scalar<M::PointerTag>
) -> InterpResult<'tcx, (Size, Align)>
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M>
[src]
fn validate_operand_internal(
&self,
op: OpTy<'tcx, M::PointerTag>,
path: Vec<PathElem>,
ref_tracking: Option<&mut RefTracking<MPlaceTy<'tcx, M::PointerTag>, Vec<PathElem>>>,
ctfe_mode: Option<CtfeValidationMode>
) -> InterpResult<'tcx>
[src]
&self,
op: OpTy<'tcx, M::PointerTag>,
path: Vec<PathElem>,
ref_tracking: Option<&mut RefTracking<MPlaceTy<'tcx, M::PointerTag>, Vec<PathElem>>>,
ctfe_mode: Option<CtfeValidationMode>
) -> InterpResult<'tcx>
pub fn const_validate_operand(
&self,
op: OpTy<'tcx, M::PointerTag>,
path: Vec<PathElem>,
ref_tracking: &mut RefTracking<MPlaceTy<'tcx, M::PointerTag>, Vec<PathElem>>,
ctfe_mode: CtfeValidationMode
) -> InterpResult<'tcx>
[src]
&self,
op: OpTy<'tcx, M::PointerTag>,
path: Vec<PathElem>,
ref_tracking: &mut RefTracking<MPlaceTy<'tcx, M::PointerTag>, Vec<PathElem>>,
ctfe_mode: CtfeValidationMode
) -> InterpResult<'tcx>
This function checks the data at op
to be const-valid.
op
is assumed to cover valid memory if it is an indirect operand.
It will error if the bits at the destination do not match the ones described by the layout.
ref_tracking
is used to record references that we encounter so that they
can be checked recursively by an outside driving loop.
constant
controls whether this must satisfy the rules for constants:
- no pointers to statics.
- no
UnsafeCell
or non-ZST&mut
.
pub fn validate_operand(
&self,
op: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
[src]
&self,
op: OpTy<'tcx, M::PointerTag>
) -> InterpResult<'tcx>
This function checks the data at op
to be runtime-valid.
op
is assumed to cover valid memory if it is an indirect operand.
It will error if the bits at the destination do not match the ones described by the layout.
Trait Implementations
impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> HasDataLayout for InterpCx<'mir, 'tcx, M>
[src]
pub fn data_layout(&self) -> &TargetDataLayout
[src]
impl<'mir, 'tcx, M> HasParamEnv<'tcx> for InterpCx<'mir, 'tcx, M> where
M: Machine<'mir, 'tcx>,
[src]
M: Machine<'mir, 'tcx>,
impl<'mir, 'tcx, M> HasTyCtxt<'tcx> for InterpCx<'mir, 'tcx, M> where
M: Machine<'mir, 'tcx>,
[src]
M: Machine<'mir, 'tcx>,
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> LayoutOf for InterpCx<'mir, 'tcx, M>
[src]
type Ty = Ty<'tcx>
type TyAndLayout = InterpResult<'tcx, TyAndLayout<'tcx>>
pub fn layout_of(&self, ty: Ty<'tcx>) -> Self::TyAndLayout
[src]
pub fn spanned_layout_of(&self, ty: Self::Ty, _span: Span) -> Self::TyAndLayout
[src]
Auto Trait Implementations
impl<'mir, 'tcx, M> !RefUnwindSafe for InterpCx<'mir, 'tcx, M>
[src]
impl<'mir, 'tcx, M> !Send for InterpCx<'mir, 'tcx, M>
[src]
impl<'mir, 'tcx, M> !Sync for InterpCx<'mir, 'tcx, M>
[src]
impl<'mir, 'tcx, M> Unpin for InterpCx<'mir, 'tcx, M> where
M: Unpin,
<M as Machine<'mir, 'tcx>>::ExtraFnVal: Unpin,
<M as Machine<'mir, 'tcx>>::MemoryExtra: Unpin,
<M as Machine<'mir, 'tcx>>::MemoryMap: Unpin,
<M as Machine<'mir, 'tcx>>::PointerTag: Unpin,
[src]
M: Unpin,
<M as Machine<'mir, 'tcx>>::ExtraFnVal: Unpin,
<M as Machine<'mir, 'tcx>>::MemoryExtra: Unpin,
<M as Machine<'mir, 'tcx>>::MemoryMap: Unpin,
<M as Machine<'mir, 'tcx>>::PointerTag: Unpin,
impl<'mir, 'tcx, M> !UnwindSafe for InterpCx<'mir, 'tcx, M>
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> PointerArithmetic for T where
T: HasDataLayout,
[src]
T: HasDataLayout,
pub fn pointer_size(&self) -> Size
[src]
pub fn machine_usize_max(&self) -> u64
[src]
pub fn machine_isize_min(&self) -> i64
[src]
pub fn machine_isize_max(&self) -> i64
[src]
pub fn truncate_to_ptr(&self, (u64, bool)) -> (u64, bool)
[src]
pub fn overflowing_offset(&self, val: u64, i: u64) -> (u64, bool)
[src]
pub fn overflowing_signed_offset(&self, val: u64, i: i64) -> (u64, bool)
[src]
pub fn offset<'tcx>(
&self,
val: u64,
i: u64
) -> Result<u64, InterpErrorInfo<'tcx>>
[src]
&self,
val: u64,
i: u64
) -> Result<u64, InterpErrorInfo<'tcx>>
pub fn signed_offset<'tcx>(
&self,
val: u64,
i: i64
) -> Result<u64, InterpErrorInfo<'tcx>>
[src]
&self,
val: u64,
i: i64
) -> Result<u64, InterpErrorInfo<'tcx>>
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.