Auto merge of #1106 - RalfJung:memleak-ignore, r=RalfJung

add flag to ignore memory leaks

Author: bors

README.md

@@ -159,6 +159,7 @@ Several `-Z` flags are relevant for Miri:
 * `-Zmiri-disable-isolation` disables host host isolation.  As a consequence,
   the program has access to host resources such as environment variables and
   randomness (and, eventually, file systems and more).
+* `-Zmiri-ignore-leaks` disables the memory leak checker.
 * `-Zmiri-env-exclude=<var>` keeps the `var` environment variable isolated from 
   the host. Can be used multiple times to exclude several variables. The `TERM`
   environment variable is excluded by default.

benches/helpers/miri_helper.rs

@@ -28,6 +28,7 @@ impl rustc_driver::Callbacks for MiriCompilerCalls<'_> {
                 let config = miri::MiriConfig {
                     validate: true,
                     communicate: false,
+                    ignore_leaks: false,
                     excluded_env_vars: vec![],
                     args: vec![],
                     seed: None,

src/bin/miri-rustc-tests.rs

@@ -41,6 +41,7 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
                                 let config = MiriConfig {
                                     validate: true,
                                     communicate: false,
+                                    ignore_leaks: false,
                                     excluded_env_vars: vec![],
                                     args: vec![],
                                     seed: None,
@@ -60,6 +61,7 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
                 let config = MiriConfig {
                     validate: true,
                     communicate: false,
+                    ignore_leaks: false,
                     excluded_env_vars: vec![],
                     args: vec![],
                     seed: None

src/bin/miri.rs

@@ -124,6 +124,7 @@ fn main() {
     // Parse our arguments and split them across `rustc` and `miri`.
     let mut validate = true;
     let mut communicate = false;
+    let mut ignore_leaks = false;
     let mut seed: Option<u64> = None;
     let mut rustc_args = vec![];
     let mut miri_args = vec![];
@@ -145,6 +146,9 @@ fn main() {
                 "-Zmiri-disable-isolation" => {
                     communicate = true;
                 },
+                "-Zmiri-ignore-leaks" => {
+                    ignore_leaks = true;
+                },
                 "--" => {
                     after_dashdash = true;
                 }
@@ -200,6 +204,7 @@ fn main() {
     let miri_config = miri::MiriConfig {
         validate,
         communicate,
+        ignore_leaks,
         excluded_env_vars,
         seed,
         args: miri_args,

src/eval.rs

@@ -18,6 +18,8 @@ pub struct MiriConfig {
     pub validate: bool,
     /// Determines if communication with the host environment is enabled.
     pub communicate: bool,
+    /// Determines if memory leaks should be ignored.
+    pub ignore_leaks: bool,
     /// Environment variables that should always be isolated from the host.
     pub excluded_env_vars: Vec<String>,
     /// Command-line arguments passed to the interpreted program.
@@ -169,6 +171,11 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
 /// Returns `Some(return_code)` if program executed completed.
 /// Returns `None` if an evaluation error occured.
 pub fn eval_main<'tcx>(tcx: TyCtxt<'tcx>, main_id: DefId, config: MiriConfig) -> Option<i64> {
+    // FIXME: We always ignore leaks on some platforms where we do not
+    // correctly implement TLS destructors.
+    let target_os = tcx.sess.target.target.target_os.to_lowercase();
+    let ignore_leaks = config.ignore_leaks || target_os == "windows" || target_os == "macos";
+
     let (mut ecx, ret_place) = match create_ecx(tcx, main_id, config) {
         Ok(v) => v,
         Err(mut err) => {
@@ -190,10 +197,6 @@ pub fn eval_main<'tcx>(tcx: TyCtxt<'tcx>, main_id: DefId, config: MiriConfig) ->
     // Process the result.
     match res {
         Ok(return_code) => {
-            // Disable the leak test on some platforms where we do not
-            // correctly implement TLS destructors.
-            let target_os = ecx.tcx.tcx.sess.target.target.target_os.to_lowercase();
-            let ignore_leaks = target_os == "windows" || target_os == "macos";
             if !ignore_leaks {
                 let leaks = ecx.memory.leak_report();
                 if leaks != 0 {

tests/run-pass/memleak_ignored.rs

@@ -0,0 +1,5 @@
+// compile-flags: -Zmiri-ignore-leaks
+
+fn main() {
+    std::mem::forget(Box::new(42));
+}