Expand description
An interpreter for MIR used in CTFE and by miri
Macros
- A lot of the flexibility above is just needed for
Miri
, but all “compile-time” machines (CTFE and ConstProp) use the same instance. Here, we share that code.
Structs
- The information that makes up a memory access: offset and size.
- A reference to some allocation that was already bounds-checked for the given region and had the on-access machine hooks run.
- A reference to some allocation that was already bounds-checked for the given region and had the on-access machine hooks run.
- This type represents an Allocation in the Miri/CTFE core engine.
- Details of an access to uninitialized bytes / bad pointer bytes where it is not allowed.
- Interned types generally have an
Outer
type and anInner
type, whereOuter
is a newtype aroundInterned<Inner>
, and all the operations are done onOuter
, because all occurrences are interned. E.g.Ty
is an outer type andTyKind
is its inner type. - A stack frame.
- What we store about a frame in an interpreter backtrace.
- Uniquely identifies one of the following:
- Yields
InitChunk
s. SeeInitMask::range_as_init_chunks
. - Packages the kind of error we got from the const code interpreter up with a Rust-level backtrace of where the error occurred. These should always be constructed by calling
.into()
on anInterpError
. Inrustc_mir::interpret
, we havethrow_err_*
macros for this. - Input argument for
tcx.lit_to_const
. - A MemPlace with its layout. Constructing it is only possible in this module.
- Represents a pointer in the Miri engine.
- State for tracking recursive validation of references
- Information about a size mismatch.
Enums
- We have our own error type that does not know about the
AllocId
; that information is added when converting toInterpError
. - The return value of
get_alloc_info
indicates the “kind” of the allocation. - Details of why a pointer had to be in-bounds.
- Extra things to check for during validation of CTFE results.
- An argment passed to a function.
- The value of a function pointer.
- An allocation in the global (tcx-managed) memory can be either a function pointer, a static, or a “real” allocation with some data in it.
- An
Immediate
represents a single immediate self-contained Rust value. - A contiguous chunk of initialized or uninitialized memory.
- How a constant value should be interned.
- Error information for when the program we executed turned out not to actually be a valid program. This cannot happen in stand-alone Miri, but it can happen during CTFE/ConstProp where we work on generic code or execution does not have all information available.
- Error type for
tcx.lit_to_const
. - Information required for the sound usage of a
MemPlace
. - Error information for when the program exhausted the resources granted to it by the interpreter.
- A
Scalar
represents an immediate, primitive value existing outside of amemory::Allocation
. It is in many ways like a small chunk of anAllocation
, up to 16 bytes in size. Like a range of bytes in anAllocation
, aScalar
can either represent the raw bytes of a simple value or a pointer into anotherAllocation
- Data returned by Machine::stack_pop, to provide further control over the popping of the stack frame
- Error information for when the program caused Undefined Behavior.
- Error information for when the program did something that might (or might not) be correct to do according to the Rust spec, but due to limitations in the interpreter, the operation could not be carried out. These limitations can differ between CTFE and the Miri engine, e.g., CTFE does not support dereferencing pointers at integral addresses.
Traits
- Functionality required for the bytes of an
Allocation
. - The functionality needed by memory to manage its allocations
- Methods of this trait signifies a point where CTFE evaluation would fail and some use case dependent behaviour can instead be applied.
- A trait for machine-specific errors (or other “machine stop” conditions).
- Whether this kind of memory is allowed to leak
- A thing that we can project into, and that has a layout.
- This trait abstracts over the kind of provenance that is associated with a
Pointer
. It is mostly opaque; theMachine
trait extends it with some more operations that also have access to some global state. TheDebug
rendering is used to display bare provenance, and for the default impl offmt
. - The
Readable
trait describes interpreter values that one can read from. - How to traverse a value and what to do when we are at the leaves.
- The
Weiteable
trait describes interpreter values that can be written to.
Functions
- Free-starting constructor for less syntactic overhead.
- Intern
ret
and everything it references.
Type Aliases
Ok(None)
indicates the constant was fine, but the valtree couldn’t be constructed. This is needed inthir::pattern::lower_inline_const
.