rust-lang/miri

Features

• Provenance-Tracking Allocators - Defines allocation semantics with provenance tracking to enforce that pointers only access their originating allocation.
• Type Validity Enforcers - Enforces that all data must be valid for its type, enabling niche-based enum layout optimizations.
• Abstract Machine Models - Implements Rust's abstract machine semantics by modeling memory as a byte array with provenance tracking.
• Abstract Byte Representations - Models memory bytes with initialization and provenance tracking to detect undefined behavior at runtime.
• Intermediate Representation Interpreters - Interprets Rust's Mid-level Intermediate Representation (MIR) directly to simulate program execution.
• Stacked Borrows Models - Enforces the Stacked Borrows aliasing model to detect violations of Rust's reference and borrow rules at runtime.
• Tree Borrows Models - An alternative aliasing discipline using a tree structure to track permission states for each memory location.
• Layout Definitions - Defines how Rust types are laid out in memory, including size, alignment, and field offsets.
• Memory Model Enforcers - Validates pointer provenance, aliasing rules, and allocation semantics according to Rust's abstract machine.
• MIR Interpreters - Executes Rust's mid-level intermediate representation to detect undefined behavior and memory safety violations.
• Safe Code Verifiers - Verifies that safe code cannot trigger undefined behavior through library APIs using static and dynamic analysis.
• Undefined Behavior Detection - Detects operations that violate Rust's language specification, such as invalid memory access or data races.
• Isolated Execution Sandboxes - Provides an isolated execution sandbox that restricts interpreted programs from accessing real system resources.
• Interior Mutability Patterns - Supports interior mutability patterns like Cell and RefCell by allowing mutation through shared references.
• Aliasing Detectors - Detects when pointers overlap memory regions to enforce Rust's aliasing rules and prevent undefined behavior.
• Provenance Trackers - Tracks each pointer's originating allocation to ensure dereferences only access correct memory regions.
• Data Race Detectors - Ships a data race detector that uses vector clocks on every memory access to identify concurrent conflicts.
• Soundness Verifiers - Checks that safe code cannot trigger undefined behavior through a library's public API.
• Abstract Machine Enforcers - Enforces Rust's abstract machine rules including pointer provenance, aliasing, and validity invariants during execution.
• Safety Invariant Distinctions - Separates safety invariants from validity invariants, enabling unsafe code to temporarily violate safety guarantees.
• Cross-Platform Rust Testers - Emulates arbitrary target architectures to verify Rust programs behave correctly across different platforms.
• Library Soundness Verifiers - Verifies that safe code cannot cause undefined behavior when using a library's public API.
• Cross-Platform Test Execution - Runs Rust binaries and test suites for arbitrary target architectures to verify platform-independent correctness.
• Type ABI Compatibility Definitions - Specifies when two types can be passed by-value across function boundaries interchangeably.
• Padding Byte Semantics - Defines padding byte handling between struct fields and enum variants to satisfy alignment requirements.
• Place and Value Semantics - Separates memory locations from ephemeral computed values in the language's semantic model.
• Non-Determinism Explorers - Explores multiple execution paths by treating allocation addresses and scheduling as symbolic values with random seeding.
• Host Resource Isolation Configurations - Controls access to host resources like environment variables, files, and randomness for interpreted programs.
• Random Seed Replayers - Replays programs with multiple random seeds to uncover bugs dependent on thread scheduling or allocation addresses.
• Niche Bit-Pattern Identifiers - Identifies invalid bit patterns in types to enable niche-based layout optimizations like enum discriminant elision.
• Non-Deterministic Bug Hunters - Replays programs with multiple random seeds to uncover bugs that depend on thread scheduling or allocation addresses.
• Parallel Test Execution - Launches each test as a separate interpreter process to restore parallelism lost by the single-threaded interpreter.

Star-Verlauf