Struct Thread

pub struct Thread<'tcx> {
    state: ThreadState<'tcx>,
    thread_name: Option<Vec<u8>>,
    stack: Vec<Frame<'tcx, Provenance, FrameExtra<'tcx>>>,
    pub(crate) on_stack_empty: Option<StackEmptyCallback<'tcx>>,
    top_user_relevant_frame: Option<usize>,
    join_status: ThreadJoinStatus,
    pub(crate) panic_payloads: Vec<ImmTy<'tcx>>,
    pub(crate) last_error: Option<MPlaceTy<'tcx>>,
}

A thread.

Fields

state: ThreadState<'tcx>

thread_name: Option<Vec<u8>>

Name of the thread.

stack: Vec<Frame<'tcx, Provenance, FrameExtra<'tcx>>>

The virtual call stack.

on_stack_empty: Option<StackEmptyCallback<'tcx>>

The function to call when the stack ran empty, to figure out what to do next. Conceptually, this is the interpreter implementation of the things that happen ‘after’ the Rust language entry point for this thread returns (usually implemented by the C or OS runtime). (None is an error, it means the callback has not been set up yet or is actively running.)

top_user_relevant_frame: Option<usize>

The index of the topmost user-relevant frame in stack. This field must contain the value produced by get_top_user_relevant_frame. The None state here represents This field is a cache to reduce how often we call that method. The cache is manually maintained inside MiriMachine::after_stack_push and MiriMachine::after_stack_pop.

join_status: ThreadJoinStatus

The join status.

panic_payloads: Vec<ImmTy<'tcx>>

Stack of active panic payloads for the current thread. Used for storing the argument of the call to miri_start_unwind (the panic payload) when unwinding. This is pointer-sized, and matches the Payload type in src/libpanic_unwind/miri.rs.

In real unwinding, the payload gets passed as an argument to the landing pad, which then forwards it to ‘Resume’. However this argument is implicit in MIR, so we have to store it out-of-band. When there are multiple active unwinds, the innermost one is always caught first, so we can store them as a stack.

last_error: Option<MPlaceTy<'tcx>>

Last OS error location in memory. It is a 32-bit integer.

Implementations

impl<'tcx> Thread<'tcx>

fn thread_name(&self) -> Option<&[u8]>

Get the name of the current thread if it was set.

fn thread_display_name(&self, id: ThreadId) -> String

Get the name of the current thread for display purposes; will include thread ID if not set.

fn compute_top_user_relevant_frame(&self) -> Option<usize>

Return the top user-relevant frame, if there is one. Note that the choice to return None here when there is no user-relevant frame is part of justifying the optimization that only pushes of user-relevant frames require updating the top_user_relevant_frame field.

pub fn recompute_top_user_relevant_frame(&mut self)

Re-compute the top user-relevant frame from scratch.

pub fn set_top_user_relevant_frame(&mut self, frame_idx: usize)

Set the top user-relevant frame to the given value. Must be equal to what get_top_user_relevant_frame would return!

pub fn top_user_relevant_frame(&self) -> Option<usize>

Returns the topmost frame that is considered user-relevant, or the top of the stack if there is no such frame, or None if the stack is empty.

pub fn current_span(&self) -> Span

impl<'tcx> Thread<'tcx>

fn new( name: Option<&str>, on_stack_empty: Option<StackEmptyCallback<'tcx>>, ) -> Self

Trait Implementations

impl<'tcx> Debug for Thread<'tcx>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl VisitProvenance for Thread<'_>

fn visit_provenance(&self, visit: &mut VisitWith<'_>)

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: 272 bytes