Struct move_stackless_bytecode_interpreter::concrete::local_state::LocalState

pub struct LocalState { /* private fields */ }

Implementations

impl LocalState

pub fn new(slots: Vec<LocalSlot>, skip_specs: bool) -> Self

pub fn num_slots(&self) -> usize

Get the number of slots available in this state

pub fn get_type(&self, index: TempIndex) -> &Type

Get the type of the local slot at index

pub fn has_value(&self, index: TempIndex) -> bool

Check whether the local slot at index holds a value

pub fn get_value(&self, index: TempIndex) -> TypedValue

Get the value held in local slot index. Panics if the slot does not hold a value

pub fn put_value_override(&mut self, index: TempIndex, val: TypedValue)

Put the value held in local slot index. Override if the slot already holds a value

pub fn put_value(&mut self, index: TempIndex, val: TypedValue)

Put the value held in local slot index. Panics if the slot already holds a value

pub fn del_value(&mut self, index: TempIndex) -> TypedValue

Delete the value held in local slot index. Panics if the slot does not hold a value

pub fn save_destroyed_arg(&mut self, index: TempIndex, val: TypedValue)

Save a mutable argument that is destroyed

pub fn load_destroyed_arg(&mut self, index: TempIndex) -> TypedValue

Load a mutable argument that is destroyed

pub fn mark_uninit(&mut self, index: TempIndex)

Mark a mutable reference is uninitialized explicitly

pub fn unset_uninit(&mut self, index: TempIndex) -> bool

Unset the mark that the mutable reference is uninitialized, return True if unset

pub fn get_pc(&self) -> CodeOffset

Get the current PC location (i.e., which bytecode to be executed)

pub fn set_pc(&mut self, pc: CodeOffset)

Set the PC location to jump to on next execution

pub fn ready_pc_for_next_instruction(&mut self)

Decide the PC location for next bytecode instruction

pub fn collect_pointers(&self) -> BTreeMap<TempIndex, &Pointer>

Collect the pointers of the underlying values in the local slots

pub fn transit_to_post_abort(&mut self, info: AbortInfo)

Mark that an abort is raised and we will be executing the abort action next

pub fn is_terminated(&self) -> bool

Check whether execution of the current function is finished or not

pub fn is_post_abort(&self) -> bool

Check whether we are executing in a post-abort status

pub fn terminate_with_abort(&mut self, abort_info: AbortInfo)

Mark that the current function terminated with an abort

pub fn terminate_with_return(&mut self, ret_vals: Vec<TypedValue>)

Mark that the current function terminated with return values

pub fn into_termination_status(self) -> TerminationStatus

Consume and reduce the state into termination status

pub fn skip_specs(&mut self)

Mark the spec checking disabled for the rest of the function

pub fn is_spec_skipped(&self) -> bool

Check whether we are skipping the specs