Module rustc_const_eval::interpret

An interpreter for MIR used in CTFE and by miri

Re-exports

• pub use rustc_middle::mir::interpret::*;

Modules

• call 🔒
  Manages calling a concrete function (with known MIR body) with argument passing, and returning the return value to the caller.
• cast 🔒
• discriminant 🔒
  Functions for reading and writing discriminants of multi-variant layouts (enums and coroutines).
• eval_context 🔒
• intern 🔒
  This module specifies the type based interner for constants.
• intrinsics 🔒
  Intrinsics and other functions that the interpreter executes without looking at their MIR. Intrinsics/functions supported here are shared by CTFE and miri.
• machine 🔒
  This module contains everything needed to instantiate an interpreter. This separation exists to ensure that no fancy miri features like interpreting common C functions leak into CTFE.
• memory 🔒
  The memory subsystem.
• operand 🔒
  Functions concerning immediate values and operands, and reading from operands. All high-level functions to read from memory work on operands as sources.
• operator 🔒
• place 🔒
  Computations on places – field projections, going from mir::Place, and writing into a place. All high-level functions to write to memory work on places as destinations.
• projection 🔒
  This file implements “place projections”; basically a symmetric API for 3 types: MPlaceTy, OpTy, PlaceTy.
• stack 🔒
  Manages the low-level pushing and popping of stack frames and the (de)allocation of local variables. For hadling of argument passing and return values, see the call module.
• step 🔒
  This module contains the InterpCx methods for executing a single step of the interpreter.
• traits 🔒
• util 🔒
• validity 🔒
  Check the validity invariant of a given value, and tell the user where in the value it got violated. In const context, this goes even further and tries to approximate const safety. That’s useful because it means other passes (e.g. promotion) can rely on consts to be const-safe.
• visitor 🔒
  Visitor for a run-time value with a given layout: Traverse enums, structs and other compound types until we arrive at the leaves, with custom handling for primitive types.

Macros

• compile_time_machine
  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

• AllocRef
  A reference to some allocation that was already bounds-checked for the given region and had the on-access machine hooks run.
• AllocRefMut
  A reference to some allocation that was already bounds-checked for the given region and had the on-access machine hooks run.
• Frame
  A stack frame.
• FrameInfo
  What we store about a frame in an interpreter backtrace.
• ImmTy
• InterpCx
• LocalState
  State of a local variable including a memoized layout
• MPlaceTy
  A MemPlace with its layout. Constructing it is only possible in this module.
• Memory
• OpTy
• PlaceTy
  An evaluated place, together with its type.
• RefTracking
  State for tracking recursive validation of references
• StackPopInfo
  Return type of InterpCx::pop_stack_frame_raw.

Enums

• AllocKind
  The return value of get_alloc_info indicates the “kind” of the allocation.
• CtfeValidationMode
  Extra things to check for during validation of CTFE results.
• FnArg
  An argment passed to a function.
• FnVal
  The value of a function pointer.
• Immediate
  An Immediate represents a single immediate self-contained Rust value.
• InternKind
  How a constant value should be interned.
• InternResult
• MemPlaceMeta
  Information required for the sound usage of a MemPlace.
• MemoryKind
• OffsetMode
  Describes the constraints placed on offset-projections.
• ReturnAction
  Data returned by Machine::after_stack_pop, and consumed by InterpCx::return_from_current_stack_frame to determine what actions should be done when returning from a stack frame.
• StackPopCleanup

Traits

• AllocMap
  The functionality needed by memory to manage its allocations
• HasStaticRootDefId
• Machine
  Methods of this trait signifies a point where CTFE evaluation would fail and some use case dependent behaviour can instead be applied.
• MayLeak
  Whether this kind of memory is allowed to leak
• Projectable
  A thing that we can project into, and that has a layout.
• Readable
  The Readable trait describes interpreter values that one can read from.
• ValueVisitor
  How to traverse a value and what to do when we are at the leaves.
• Writeable
  The Weiteable trait describes interpreter values that can be written to.

Functions

• format_interp_error
  Turn the given error into a human-readable string. Expects the string to be printed, so if RUSTC_CTFE_BACKTRACE is set this will show a backtrace of the rustc internals that triggered the error.
• intern_const_alloc_for_constprop
  Intern ret. This function assumes that ret references no other allocation.
• intern_const_alloc_recursive
  Intern ret and everything it references.