Trait EvalContextExt

pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
    // Provided methods
    fn lazy_sync_init<'a, T: 'static>(
        &'a mut self,
        primitive: &MPlaceTy<'tcx>,
        init_offset: Size,
        data: T,
    ) -> InterpResult<'tcx, &'a T>
       where 'tcx: 'a { ... }
    fn lazy_sync_get_data<'a, T: 'static>(
        &'a mut self,
        primitive: &MPlaceTy<'tcx>,
        init_offset: Size,
        missing_data: impl FnOnce() -> InterpResult<'tcx, T>,
        new_data: impl FnOnce(&mut MiriInterpCx<'tcx>) -> InterpResult<'tcx, T>,
    ) -> InterpResult<'tcx, &'a T>
       where 'tcx: 'a { ... }
    fn get_sync_or_init<'a, T: 'static>(
        &'a mut self,
        ptr: Pointer,
        new: impl FnOnce(&'a mut MiriMachine<'tcx>) -> T,
    ) -> Option<&'a T>
       where 'tcx: 'a { ... }
    fn mutex_get_owner(&self, mutex_ref: &MutexRef) -> ThreadId { ... }
    fn mutex_is_locked(&self, mutex_ref: &MutexRef) -> bool { ... }
    fn mutex_lock(&mut self, mutex_ref: &MutexRef) { ... }
    fn mutex_unlock(
        &mut self,
        mutex_ref: &MutexRef,
    ) -> InterpResult<'tcx, Option<usize>> { ... }
    fn mutex_enqueue_and_block(
        &mut self,
        mutex_ref: &MutexRef,
        retval_dest: Option<(Scalar, MPlaceTy<'tcx>)>,
    ) { ... }
    fn rwlock_is_locked(&self, id: RwLockId) -> bool { ... }
    fn rwlock_is_write_locked(&self, id: RwLockId) -> bool { ... }
    fn rwlock_reader_lock(&mut self, id: RwLockId) { ... }
    fn rwlock_reader_unlock(&mut self, id: RwLockId) -> InterpResult<'tcx, bool> { ... }
    fn rwlock_enqueue_and_block_reader(
        &mut self,
        id: RwLockId,
        retval: Scalar,
        dest: MPlaceTy<'tcx>,
    ) { ... }
    fn rwlock_writer_lock(&mut self, id: RwLockId) { ... }
    fn rwlock_writer_unlock(&mut self, id: RwLockId) -> InterpResult<'tcx, bool> { ... }
    fn rwlock_enqueue_and_block_writer(
        &mut self,
        id: RwLockId,
        retval: Scalar,
        dest: MPlaceTy<'tcx>,
    ) { ... }
    fn condvar_is_awaited(&mut self, id: CondvarId) -> bool { ... }
    fn condvar_wait(
        &mut self,
        condvar: CondvarId,
        mutex_ref: MutexRef,
        timeout: Option<(TimeoutClock, TimeoutAnchor, Duration)>,
        retval_succ: Scalar,
        retval_timeout: Scalar,
        dest: MPlaceTy<'tcx>,
    ) -> InterpResult<'tcx> { ... }
    fn condvar_signal(&mut self, id: CondvarId) -> InterpResult<'tcx, bool> { ... }
    fn futex_wait(
        &mut self,
        futex_ref: FutexRef,
        bitset: u32,
        timeout: Option<(TimeoutClock, TimeoutAnchor, Duration)>,
        retval_succ: Scalar,
        retval_timeout: Scalar,
        dest: MPlaceTy<'tcx>,
        errno_timeout: IoError,
    ) { ... }
    fn futex_wake(
        &mut self,
        futex_ref: &FutexRef,
        bitset: u32,
    ) -> InterpResult<'tcx, bool> { ... }
}

Provided Methods

fn lazy_sync_init<'a, T: 'static>( &'a mut self, primitive: &MPlaceTy<'tcx>, init_offset: Size, data: T, ) -> InterpResult<'tcx, &'a T>

where 'tcx: 'a,

Helper for lazily initialized alloc_extra.sync data: this forces an immediate init. Return a reference to the data in the machine state.

fn lazy_sync_get_data<'a, T: 'static>( &'a mut self, primitive: &MPlaceTy<'tcx>, init_offset: Size, missing_data: impl FnOnce() -> InterpResult<'tcx, T>, new_data: impl FnOnce(&mut MiriInterpCx<'tcx>) -> InterpResult<'tcx, T>, ) -> InterpResult<'tcx, &'a T>

where 'tcx: 'a,

Helper for lazily initialized alloc_extra.sync data: Checks if the primitive is initialized:

• If yes, fetches the data from alloc_extra.sync, or calls missing_data if that fails and stores that in alloc_extra.sync.
• Otherwise, calls new_data to initialize the primitive.

Return a reference to the data in the machine state.

fn get_sync_or_init<'a, T: 'static>( &'a mut self, ptr: Pointer, new: impl FnOnce(&'a mut MiriMachine<'tcx>) -> T, ) -> Option<&'a T>

where 'tcx: 'a,

Get the synchronization primitive associated with the given pointer, or initialize a new one.

Return None if this pointer does not point to at least 1 byte of mutable memory.

fn mutex_get_owner(&self, mutex_ref: &MutexRef) -> ThreadId

Get the id of the thread that currently owns this lock.

fn mutex_is_locked(&self, mutex_ref: &MutexRef) -> bool

Check if locked.

fn mutex_lock(&mut self, mutex_ref: &MutexRef)

Lock by setting the mutex owner and increasing the lock count.

fn mutex_unlock( &mut self, mutex_ref: &MutexRef, ) -> InterpResult<'tcx, Option<usize>>

Try unlocking by decreasing the lock count and returning the old lock count. If the lock count reaches 0, release the lock and potentially give to a new owner. If the lock was not locked by the current thread, return None.

fn mutex_enqueue_and_block( &mut self, mutex_ref: &MutexRef, retval_dest: Option<(Scalar, MPlaceTy<'tcx>)>, )

Put the thread into the queue waiting for the mutex.

Once the Mutex becomes available and if it exists, retval_dest.0 will be written to retval_dest.1.

fn rwlock_is_locked(&self, id: RwLockId) -> bool

Check if locked.

fn rwlock_is_write_locked(&self, id: RwLockId) -> bool

Check if write locked.

fn rwlock_reader_lock(&mut self, id: RwLockId)

Read-lock the lock by adding the reader the list of threads that own this lock.

fn rwlock_reader_unlock(&mut self, id: RwLockId) -> InterpResult<'tcx, bool>

Try read-unlock the lock for the current threads and potentially give the lock to a new owner. Returns true if succeeded, false if this reader did not hold the lock.

fn rwlock_enqueue_and_block_reader( &mut self, id: RwLockId, retval: Scalar, dest: MPlaceTy<'tcx>, )

Put the reader in the queue waiting for the lock and block it. Once the lock becomes available, retval will be written to dest.

fn rwlock_writer_lock(&mut self, id: RwLockId)

Lock by setting the writer that owns the lock.

fn rwlock_writer_unlock(&mut self, id: RwLockId) -> InterpResult<'tcx, bool>

Try to unlock an rwlock held by the current thread. Return false if it is held by another thread.

fn rwlock_enqueue_and_block_writer( &mut self, id: RwLockId, retval: Scalar, dest: MPlaceTy<'tcx>, )

Put the writer in the queue waiting for the lock. Once the lock becomes available, retval will be written to dest.

fn condvar_is_awaited(&mut self, id: CondvarId) -> bool

Is the conditional variable awaited?

fn condvar_wait( &mut self, condvar: CondvarId, mutex_ref: MutexRef, timeout: Option<(TimeoutClock, TimeoutAnchor, Duration)>, retval_succ: Scalar, retval_timeout: Scalar, dest: MPlaceTy<'tcx>, ) -> InterpResult<'tcx>

Release the mutex and let the current thread wait on the given condition variable. Once it is signaled, the mutex will be acquired and retval_succ will be written to dest. If the timeout happens first, retval_timeout will be written to dest.

fn condvar_signal(&mut self, id: CondvarId) -> InterpResult<'tcx, bool>

Wake up some thread (if there is any) sleeping on the conditional variable. Returns true iff any thread was woken up.

fn futex_wait( &mut self, futex_ref: FutexRef, bitset: u32, timeout: Option<(TimeoutClock, TimeoutAnchor, Duration)>, retval_succ: Scalar, retval_timeout: Scalar, dest: MPlaceTy<'tcx>, errno_timeout: IoError, )

Wait for the futex to be signaled, or a timeout. On a signal, retval_succ is written to dest. On a timeout, retval_timeout is written to dest and errno_timeout is set as the last error.

fn futex_wake( &mut self, futex_ref: &FutexRef, bitset: u32, ) -> InterpResult<'tcx, bool>

Wake up the first thread in the queue that matches any of the bits in the bitset. Returns whether anything was woken.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'tcx> EvalContextExt<'tcx> for MiriInterpCx<'tcx>