pub(crate) enum CallEffect {
Show 44 variants
ReturnAliasArg {
arg: usize,
},
ReturnArgValue {
arg: usize,
},
ReturnOpaque,
ReturnFloatToIntUnchecked,
ReturnSizeOfVal {
arg: usize,
},
ReturnRawEq {
left_arg: usize,
right_arg: usize,
},
ReturnExactDiv {
lhs_arg: usize,
rhs_arg: usize,
},
SelectUnpredictable,
ReturnWrappingPointerOffset {
base_arg: usize,
offset_arg: usize,
},
ReturnPtrOffsetFrom {
ptr_arg: usize,
base_arg: usize,
},
ReturnConst {
value: u64,
},
ReallocateVec {
arg: usize,
},
CopyMemory {
source_arg: usize,
destination_arg: usize,
count_arg: usize,
},
SwapMemory {
left_arg: usize,
right_arg: usize,
},
FillBytes {
pointer_arg: usize,
byte_arg: usize,
count_arg: usize,
},
ReturnNullableAllocation {
size_arg: usize,
align_arg: usize,
zeroed: bool,
},
ReturnMin {
lhs_arg: usize,
rhs_arg: usize,
},
ReturnMax {
lhs_arg: usize,
rhs_arg: usize,
},
ReturnAdd {
lhs_arg: usize,
rhs_arg: usize,
},
ReturnMul {
lhs_arg: usize,
rhs_arg: usize,
},
ReturnBoundedArithmetic {
lhs_arg: usize,
rhs_arg: usize,
op: BoundedArithmeticOp,
},
ReturnWithOverflow {
lhs_arg: usize,
rhs_arg: usize,
op: OverflowOp,
},
ReturnNonZeroIff {
arg: usize,
},
ReturnLeadingZeros {
arg: usize,
},
ReturnTrailingZeros {
arg: usize,
},
ReturnAlignOfVal {
arg: usize,
},
ReturnCompareBytes {
left_arg: usize,
right_arg: usize,
count_arg: usize,
},
ReturnMaskedPointer {
pointer_arg: usize,
mask_arg: usize,
},
LoadMemory {
pointer_arg: usize,
},
StoreMemory {
pointer_arg: usize,
value_arg: usize,
},
AtomicRmw {
pointer_arg: usize,
},
SimdCompare {
lhs_arg: usize,
rhs_arg: usize,
op: SimdCmpOp,
},
SimdArithmetic {
lhs_arg: usize,
rhs_arg: usize,
op: SimdArithOp,
},
SimdOpaque,
SimdSplat {
arg: usize,
},
SimdExtract {
vector_arg: usize,
index_arg: usize,
},
SimdInsert {
vector_arg: usize,
index_arg: usize,
value_arg: usize,
},
SimdHavocMemory {
pointer_arg: usize,
mask_arg: usize,
},
SimdMaskedFallback {
mask_arg: usize,
fallback_arg: usize,
},
SimdBitmask {
arg: usize,
},
ReturnVecFromSlice,
ReturnAlignOffset {
ptr_arg: usize,
align_arg: usize,
},
ReturnTransparentDeref {
arg: usize,
peel: usize,
},
ReturnLayoutSymbolic {
is_size: bool,
},
}Expand description
Path-local effect produced by a retained call.
Variants§
ReturnAliasArg
The return value aliases or is a direct value flow from an argument.
ReturnArgValue
The return value is a transparent copy of an argument’s value
(MaybeUninit::assume_init, ManuallyDrop::into_inner): same term and
facts, retyped to the destination — no pointer non_null forcing.
ReturnOpaque
ReturnFloatToIntUnchecked
Fold a constant unchecked float-to-int conversion; other inputs remain opaque.
ReturnSizeOfVal
ReturnRawEq
ReturnExactDiv
SelectUnpredictable
select_unpredictable(cond, x, y) returns either x or y: the result
is one of the two candidate values (args[1]/args[2]), non-deterministic
since the boolean selector (args[0]) is unpredictable.
ReturnWrappingPointerOffset
The return value is a pointer extracted from an aggregate/reference arg.
ReturnPtrOffsetFrom
ReturnConst
The return value is a concrete layout/numeric constant.
ReallocateVec
CopyMemory
SwapMemory
FillBytes
ReturnNullableAllocation
ReturnMin
The return value is min(lhs_arg, rhs_arg), satisfying
return <= lhs_arg and return <= rhs_arg.
ReturnMax
The return value is max(lhs_arg, rhs_arg).
ReturnAdd
The return value is lhs_arg + rhs_arg.
ReturnMul
The return value is lhs_arg * rhs_arg.
ReturnBoundedArithmetic
ReturnWithOverflow
ReturnNonZeroIff
The return value is non-zero iff arg is non-zero (models bit-manipulating
intrinsics like bswap/bitreverse/ctpop/rotate_*, which map 0 to
0 and non-zero to non-zero).
ReturnLeadingZeros
ReturnTrailingZeros
ReturnAlignOfVal
ReturnCompareBytes
ReturnMaskedPointer
LoadMemory
StoreMemory
AtomicRmw
SimdCompare
SimdArithmetic
SimdOpaque
SimdSplat
SimdExtract
SimdInsert
SimdHavocMemory
SimdMaskedFallback
SimdBitmask
ReturnVecFromSlice
The slice-to-Vec conversion creates a new allocation with the source length.
ReturnAlignOffset
ptr.align_offset(align) returns an offset such that
(ptr + offset) % align == 0 and 0 <= offset < align (or usize::MAX
when no such offset exists). Models *const T::align_offset /
*mut T::align_offset by recording the alignment path-condition so
downstream ptr.add(offset) dereferences can discharge Align.
ReturnTransparentDeref
<ManuallyDrop<T> as Deref>::deref / MaybeDangling::as_ref return a
reference to the inner value at the same address (transparent
wrappers). The return aliases arg (a &T pointing at arg’s
pointee) and its pointee field values are the argument’s field values
with the leading peel transparent field-0 hops stripped.
ReturnLayoutSymbolic
size_of::<T>() / align_of::<T>() for a generic T (no concrete
layout): the result is the shared symbolic sizeof_T / align_T, bound
at apply time from func’s type argument.
Implementations§
Source§impl CallEffect
impl CallEffect
pub(super) fn written_args(&self) -> Vec<usize>
pub(super) fn write_inputs(&self) -> Vec<usize>
Trait Implementations§
Source§impl Clone for CallEffect
impl Clone for CallEffect
Auto Trait Implementations§
impl DynSend for CallEffect
impl DynSync for CallEffect
impl Forget for CallEffect
impl Freeze for CallEffect
impl Move for CallEffect
impl RefUnwindSafe for CallEffect
impl Send for CallEffect
impl Sync for CallEffect
impl Unpin for CallEffect
impl UnsafeUnpin for CallEffect
impl UnwindSafe for CallEffect
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more