Add a command line flag to avoid printing to stdout and stderr

Author: oli-obk

src/bin/miri.rs

@@ -374,6 +374,9 @@ fn main() {
                     miri_config.tag_raw = true;
                     miri_config.check_number_validity = true;
                 }
+                "-Zmiri-drop-stdout-stderr" => {
+                    miri_config.drop_stdout_stderr = true;
+                }
                 "-Zmiri-track-raw-pointers" => {
                     eprintln!(
                         "WARNING: -Zmiri-track-raw-pointers has been renamed to -Zmiri-tag-raw-pointers, the old name is deprecated."

src/eval.rs

@@ -116,6 +116,9 @@ pub struct MiriConfig {
     /// Whether to enforce "strict provenance" rules. Enabling this means int2ptr casts return
     /// pointers with an invalid provenance, i.e., not valid for any memory access.
     pub strict_provenance: bool,
+    /// Whether to ignore any output by the program. This is helpful when debugging miri
+    /// as its messages don't get intermingled with the program messages.
+    pub drop_stdout_stderr: bool,
 }
 
 impl Default for MiriConfig {
@@ -142,6 +145,7 @@ impl Default for MiriConfig {
             panic_on_unsupported: false,
             backtrace_style: BacktraceStyle::Short,
             strict_provenance: false,
+            drop_stdout_stderr: false,
         }
     }
 }

src/machine.rs

@@ -28,7 +28,7 @@ use rustc_span::symbol::{sym, Symbol};
 use rustc_target::abi::Size;
 use rustc_target::spec::abi::Abi;
 
-use crate::*;
+use crate::{*, shims::posix::FileHandler};
 
 // Some global facts about the emulated machine.
 pub const PAGE_SIZE: u64 = 4 * 1024; // FIXME: adjust to target architecture
@@ -327,7 +327,7 @@ impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
             validate: config.validate,
             enforce_number_validity: config.check_number_validity,
             enforce_abi: config.check_abi,
-            file_handler: Default::default(),
+            file_handler: FileHandler::new(config.drop_stdout_stderr),
             dir_handler: Default::default(),
             time_anchor: Instant::now(),
             layouts,

src/shims/posix/fs.rs

@@ -251,22 +251,70 @@ impl FileDescriptor for io::Stderr {
     }
 }
 
+#[derive(Debug)]
+struct DevNull;
+
+impl FileDescriptor for DevNull {
+    fn as_file_handle<'tcx>(&self) -> InterpResult<'tcx, &FileHandle> {
+        throw_unsup_format!("/dev/null cannot be used as FileHandle");
+    }
+
+    fn read<'tcx>(
+        &mut self,
+        _communicate_allowed: bool,
+        _bytes: &mut [u8],
+    ) -> InterpResult<'tcx, io::Result<usize>> {
+        throw_unsup_format!("cannot read from /dev/null");
+    }
+
+    fn write<'tcx>(
+        &self,
+        _communicate_allowed: bool,
+        bytes: &[u8],
+    ) -> InterpResult<'tcx, io::Result<usize>> {
+        // We just don't write anything
+        Ok(Ok(bytes.len()))
+    }
+
+    fn seek<'tcx>(
+        &mut self,
+        _communicate_allowed: bool,
+        _offset: SeekFrom,
+    ) -> InterpResult<'tcx, io::Result<u64>> {
+        throw_unsup_format!("cannot seek on /dev/null");
+    }
+
+    fn close<'tcx>(
+        self: Box<Self>,
+        _communicate_allowed: bool,
+    ) -> InterpResult<'tcx, io::Result<i32>> {
+        throw_unsup_format!("/dev/null cannot be closed");
+    }
+
+    fn dup<'tcx>(&mut self) -> io::Result<Box<dyn FileDescriptor>> {
+        Ok(Box::new(DevNull))
+    }
+}
+
 #[derive(Debug)]
 pub struct FileHandler {
     handles: BTreeMap<i32, Box<dyn FileDescriptor>>,
 }
 
-impl<'tcx> Default for FileHandler {
-    fn default() -> Self {
+impl<'tcx> FileHandler {
+    pub(crate) fn new(drop_stdout_stderr: bool) -> FileHandler {
         let mut handles: BTreeMap<_, Box<dyn FileDescriptor>> = BTreeMap::new();
-        handles.insert(0i32, Box::new(io::stdin()));
-        handles.insert(1i32, Box::new(io::stdout()));
+        if drop_stdout_stderr {
+            handles.insert(0i32, Box::new(DevNull));
+            handles.insert(1i32, Box::new(DevNull));
+        } else {
+            handles.insert(0i32, Box::new(io::stdin()));
+            handles.insert(1i32, Box::new(io::stdout()));
+        }
         handles.insert(2i32, Box::new(io::stderr()));
         FileHandler { handles }
     }
-}
 
-impl<'tcx> FileHandler {
     fn insert_fd(&mut self, file_handle: Box<dyn FileDescriptor>) -> i32 {
         self.insert_fd_with_min_fd(file_handle, 0)
     }

tests/run-pass/hide_stdout.rs

@@ -0,0 +1,5 @@
+// compile-flags: -Zmiri-drop-stdout-stderr
+
+fn main() {
+    println!("cake");
+}