or an invalid enum discriminant)
* **Experimental**: Violations of the [Stacked Borrows] rules governing aliasing
for reference types
-* **Experimental**: Data races (but no weak memory effects)
+* **Experimental**: Data races
+* **Experimental**: Emulation of weak memory effects (i.e., reads can return outdated values)
On top of that, Miri will also tell you about memory leaks: when there is memory
still allocated at the end of the execution, and that memory is not reachable
not support networking. System API support varies between targets; if you run
on Windows it is a good idea to use `--target x86_64-unknown-linux-gnu` to get
better support.
-* Threading support is not finished yet. E.g., weak memory effects are not
- emulated and spin loops (without syscalls) just loop forever. There is no
- threading support on Windows.
+* Threading support is not finished yet. E.g. spin loops (without syscalls) just
+ loop forever. There is no threading support on Windows.
+* Weak memory emulation may produce weak behaivours unobservable by compiled
+ programs running on real hardware when `SeqCst` fences are used, and it cannot
+ produce all behaviors possibly observable on real hardware.
[rust]: https://www.rust-lang.org/
[mir]: https://github.com/rust-lang/rfcs/blob/master/text/1211-mir.md
* `-Zmiri-compare-exchange-weak-failure-rate=<rate>` changes the failure rate of
`compare_exchange_weak` operations. The default is `0.8` (so 4 out of 5 weak ops will fail).
You can change it to any value between `0.0` and `1.0`, where `1.0` means it
- will always fail and `0.0` means it will never fail.
+ will always fail and `0.0` means it will never fail. Note than setting it to
+ `1.0` will likely cause hangs, since it means programs using
+ `compare_exchange_weak` cannot make progress.
* `-Zmiri-disable-isolation` disables host isolation. As a consequence,
the program has access to host resources such as environment variables, file
systems, and randomness.
`-Zmiri-disable-isolation` is set.
* `-Zmiri-ignore-leaks` disables the memory leak checker, and also allows some
remaining threads to exist when the main thread exits.
-* `-Zmiri-seed=<hex>` configures the seed of the RNG that Miri uses to resolve
- non-determinism. This RNG is used to pick base addresses for allocations. When
- isolation is enabled (the default), this is also used to emulate system
- entropy. The default seed is 0. You can increase test coverage by running Miri
- multiple times with different seeds.
- **NOTE**: This entropy is not good enough for cryptographic use! Do not
- generate secret keys in Miri or perform other kinds of cryptographic
- operations that rely on proper random numbers.
+* `-Zmiri-preemption-rate` configures the probability that at the end of a basic block, the active
+ thread will be preempted. The default is `0.01` (i.e., 1%). Setting this to `0` disables
+ preemption.
+* `-Zmiri-seed=<hex>` configures the seed of the RNG that Miri uses to resolve non-determinism. This
+ RNG is used to pick base addresses for allocations, to determine preemption and failure of
+ `compare_exchange_weak`, and to control store buffering for weak memory emulation. When isolation
+ is enabled (the default), this is also used to emulate system entropy. The default seed is 0. You
+ can increase test coverage by running Miri multiple times with different seeds. **NOTE**: This
+ entropy is not good enough for cryptographic use! Do not generate secret keys in Miri or perform
+ other kinds of cryptographic operations that rely on proper random numbers.
* `-Zmiri-strict-provenance` enables [strict
provenance](https://github.com/rust-lang/rust/issues/95228) checking in Miri. This means that
casting an integer to a pointer yields a result with 'invalid' provenance, i.e., with provenance
- that cannot be used for any memory access. Also implies `-Zmiri-tag-raw-pointers` and
- `-Zmiri-check-number-validity`.
+ that cannot be used for any memory access. Also implies `-Zmiri-tag-raw-pointers`.
The remaining flags are for advanced use only, and more likely to change or be removed.
Some of these are **unsound**, which means they can lead
* `-Zmiri-allow-uninit-numbers` disables the check to ensure that number types (integer and float
types) always hold initialized data. (They must still be initialized when any actual operation,
- such as arithmetic, is performed.) Using this flag is **unsound**. This has no effect when
+ such as arithmetic, is performed.) Using this flag is **unsound** and
+ [deprecated](https://github.com/rust-lang/miri/issues/2187). This has no effect when
`-Zmiri-disable-validation` is present.
* `-Zmiri-allow-ptr-int-transmute` makes Miri more accepting of transmutation between pointers and
integers via `mem::transmute` or union/pointer type punning. This has two effects: it disables the
check against integers storing a pointer (i.e., data with provenance), thus allowing
pointer-to-integer transmutation, and it treats integer-to-pointer transmutation as equivalent to
- a cast. Using this flag is **unsound**.
+ a cast. Using this flag is **unsound** and
+ [deprecated](https://github.com/rust-lang/miri/issues/2188).
* `-Zmiri-disable-abi-check` disables checking [function ABI]. Using this flag
is **unsound**.
* `-Zmiri-disable-alignment-check` disables checking pointer alignment, so you
can focus on other failures, but it means Miri can miss bugs in your program.
Using this flag is **unsound**.
* `-Zmiri-disable-data-race-detector` disables checking for data races. Using
- this flag is **unsound**.
+ this flag is **unsound**. This implies `-Zmiri-disable-weak-memory-emulation`.
* `-Zmiri-disable-stacked-borrows` disables checking the experimental
[Stacked Borrows] aliasing rules. This can make Miri run faster, but it also
means no aliasing violations will be detected. Using this flag is **unsound**
as out-of-bounds accesses) first. Setting this flag means Miri can miss bugs
in your program. However, this can also help to make Miri run faster. Using
this flag is **unsound**.
+* `-Zmiri-disable-weak-memory-emulation` disables the emulation of some C++11 weak
+ memory effects.
* `-Zmiri-measureme=<name>` enables `measureme` profiling for the interpreted program.
This can be used to find which parts of your program are executing slowly under Miri.
The profile is written out to a file with the prefix `<name>`, and can be processed