format much of Miri

Author: RalfJung

benches/helpers/miri_helper.rs

@@ -2,8 +2,8 @@ extern crate rustc_driver;
 extern crate rustc_hir;
 extern crate rustc_interface;
 
-use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_driver::Compilation;
+use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_interface::{interface, Queries};
 
 use crate::test::Bencher;

src/bin/miri.rs

@@ -1,11 +1,11 @@
 #![feature(rustc_private)]
 
-extern crate rustc_middle;
 extern crate rustc_driver;
+extern crate rustc_errors;
 extern crate rustc_hir;
 extern crate rustc_interface;
+extern crate rustc_middle;
 extern crate rustc_session;
-extern crate rustc_errors;
 
 use std::convert::TryFrom;
 use std::env;
@@ -14,11 +14,11 @@ use std::str::FromStr;
 use hex::FromHexError;
 use log::debug;
 
-use rustc_session::{CtfeBacktrace, config::ErrorOutputType};
-use rustc_errors::emitter::{HumanReadableErrorType, ColorConfig};
 use rustc_driver::Compilation;
+use rustc_errors::emitter::{ColorConfig, HumanReadableErrorType};
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_middle::ty::TyCtxt;
+use rustc_session::{config::ErrorOutputType, CtfeBacktrace};
 
 struct MiriCompilerCalls {
     miri_config: miri::MiriConfig,
@@ -37,8 +37,13 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
             let (entry_def_id, _) = if let Some((entry_def, x)) = tcx.entry_fn(LOCAL_CRATE) {
                 (entry_def, x)
             } else {
-                let output_ty = ErrorOutputType::HumanReadable(HumanReadableErrorType::Default(ColorConfig::Auto));
-                rustc_session::early_error(output_ty, "miri can only run programs that have a main function");
+                let output_ty = ErrorOutputType::HumanReadable(HumanReadableErrorType::Default(
+                    ColorConfig::Auto,
+                ));
+                rustc_session::early_error(
+                    output_ty,
+                    "miri can only run programs that have a main function",
+                );
             };
             let mut config = self.miri_config.clone();
 
@@ -249,28 +254,27 @@ fn main() {
                             err => panic!("unknown error decoding -Zmiri-seed as hex: {:?}", err),
                         });
                     if seed_raw.len() > 8 {
-                        panic!(
-                            "-Zmiri-seed must be at most 8 bytes, was {}",
-                            seed_raw.len()
-                        );
+                        panic!("-Zmiri-seed must be at most 8 bytes, was {}", seed_raw.len());
                     }
 
                     let mut bytes = [0; 8];
                     bytes[..seed_raw.len()].copy_from_slice(&seed_raw);
                     miri_config.seed = Some(u64::from_be_bytes(bytes));
                 }
                 arg if arg.starts_with("-Zmiri-env-exclude=") => {
-                    miri_config.excluded_env_vars
+                    miri_config
+                        .excluded_env_vars
                         .push(arg.strip_prefix("-Zmiri-env-exclude=").unwrap().to_owned());
                 }
                 arg if arg.starts_with("-Zmiri-track-pointer-tag=") => {
-                    let id: u64 = match arg.strip_prefix("-Zmiri-track-pointer-tag=").unwrap().parse() {
-                        Ok(id) => id,
-                        Err(err) => panic!(
-                            "-Zmiri-track-pointer-tag requires a valid `u64` argument: {}",
-                            err
-                        ),
-                    };
+                    let id: u64 =
+                        match arg.strip_prefix("-Zmiri-track-pointer-tag=").unwrap().parse() {
+                            Ok(id) => id,
+                            Err(err) => panic!(
+                                "-Zmiri-track-pointer-tag requires a valid `u64` argument: {}",
+                                err
+                            ),
+                        };
                     if let Some(id) = miri::PtrId::new(id) {
                         miri_config.tracked_pointer_tag = Some(id);
                     } else {
@@ -280,10 +284,8 @@ fn main() {
                 arg if arg.starts_with("-Zmiri-track-call-id=") => {
                     let id: u64 = match arg.strip_prefix("-Zmiri-track-call-id=").unwrap().parse() {
                         Ok(id) => id,
-                        Err(err) => panic!(
-                            "-Zmiri-track-call-id requires a valid `u64` argument: {}",
-                            err
-                        ),
+                        Err(err) =>
+                            panic!("-Zmiri-track-call-id requires a valid `u64` argument: {}", err),
                     };
                     if let Some(id) = miri::CallId::new(id) {
                         miri_config.tracked_call_id = Some(id);
@@ -292,20 +294,28 @@ fn main() {
                     }
                 }
                 arg if arg.starts_with("-Zmiri-track-alloc-id=") => {
-                    let id: u64 = match arg.strip_prefix("-Zmiri-track-alloc-id=").unwrap().parse() {
+                    let id: u64 = match arg.strip_prefix("-Zmiri-track-alloc-id=").unwrap().parse()
+                    {
                         Ok(id) => id,
-                        Err(err) => panic!(
-                            "-Zmiri-track-alloc-id requires a valid `u64` argument: {}",
-                            err
-                        ),
+                        Err(err) =>
+                            panic!("-Zmiri-track-alloc-id requires a valid `u64` argument: {}", err),
                     };
                     miri_config.tracked_alloc_id = Some(miri::AllocId(id));
                 }
                 arg if arg.starts_with("-Zmiri-compare-exchange-weak-failure-rate=") => {
-                    let rate = match arg.strip_prefix("-Zmiri-compare-exchange-weak-failure-rate=").unwrap().parse::<f64>() {
+                    let rate = match arg
+                        .strip_prefix("-Zmiri-compare-exchange-weak-failure-rate=")
+                        .unwrap()
+                        .parse::<f64>()
+                    {
                         Ok(rate) if rate >= 0.0 && rate <= 1.0 => rate,
-                        Ok(_) => panic!("-Zmiri-compare-exchange-weak-failure-rate must be between `0.0` and `1.0`"),
-                        Err(err) => panic!("-Zmiri-compare-exchange-weak-failure-rate requires a `f64` between `0.0` and `1.0`: {}", err),
+                        Ok(_) => panic!(
+                            "-Zmiri-compare-exchange-weak-failure-rate must be between `0.0` and `1.0`"
+                        ),
+                        Err(err) => panic!(
+                            "-Zmiri-compare-exchange-weak-failure-rate requires a `f64` between `0.0` and `1.0`: {}",
+                            err
+                        ),
                     };
                     miri_config.cmpxchg_weak_failure_rate = rate;
                 }
@@ -319,5 +329,9 @@ fn main() {
 
     debug!("rustc arguments: {:?}", rustc_args);
     debug!("crate arguments: {:?}", miri_config.args);
-    run_compiler(rustc_args, &mut MiriCompilerCalls { miri_config }, /* insert_default_args: */ true)
+    run_compiler(
+        rustc_args,
+        &mut MiriCompilerCalls { miri_config },
+        /* insert_default_args: */ true,
+    )
 }

src/eval.rs

@@ -135,8 +135,9 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
             argvs.push(arg_place.ptr);
         }
         // Make an array with all these pointers, in the Miri memory.
-        let argvs_layout =
-            ecx.layout_of(tcx.mk_array(tcx.mk_imm_ptr(tcx.types.u8), u64::try_from(argvs.len()).unwrap()))?;
+        let argvs_layout = ecx.layout_of(
+            tcx.mk_array(tcx.mk_imm_ptr(tcx.types.u8), u64::try_from(argvs.len()).unwrap()),
+        )?;
         let argvs_place = ecx.allocate(argvs_layout, MiriMemoryKind::Machine.into());
         for (idx, arg) in argvs.into_iter().enumerate() {
             let place = ecx.mplace_field(&argvs_place, idx)?;
@@ -224,9 +225,11 @@ pub fn eval_main<'tcx>(tcx: TyCtxt<'tcx>, main_id: DefId, config: MiriConfig) ->
                     assert!(ecx.step()?, "a terminated thread was scheduled for execution");
                 }
                 SchedulingAction::ExecuteTimeoutCallback => {
-                    assert!(ecx.machine.communicate,
+                    assert!(
+                        ecx.machine.communicate,
                         "scheduler callbacks require disabled isolation, but the code \
-                        that created the callback did not check it");
+                        that created the callback did not check it"
+                    );
                     ecx.run_timeout_callback()?;
                 }
                 SchedulingAction::ExecuteDtors => {
@@ -241,7 +244,8 @@ pub fn eval_main<'tcx>(tcx: TyCtxt<'tcx>, main_id: DefId, config: MiriConfig) ->
             }
             ecx.process_diagnostics(info);
         }
-        let return_code = ecx.read_scalar(&ret_place.into())?.check_init()?.to_machine_isize(&ecx)?;
+        let return_code =
+            ecx.read_scalar(&ret_place.into())?.check_init()?.to_machine_isize(&ecx)?;
         Ok(return_code)
     })();
 

src/helpers.rs

@@ -5,10 +5,10 @@ use std::time::Duration;
 
 use log::trace;
 
-use rustc_middle::mir;
-use rustc_middle::ty::{self, List, TyCtxt, layout::TyAndLayout};
 use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX};
-use rustc_target::abi::{LayoutOf, Size, FieldsShape, Variants};
+use rustc_middle::mir;
+use rustc_middle::ty::{self, layout::TyAndLayout, List, TyCtxt};
+use rustc_target::abi::{FieldsShape, LayoutOf, Size, Variants};
 use rustc_target::spec::abi::Abi;
 
 use rand::RngCore;
@@ -19,10 +19,8 @@ impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mi
 
 /// Gets an instance for a path.
 fn try_resolve_did<'mir, 'tcx>(tcx: TyCtxt<'tcx>, path: &[&str]) -> Option<DefId> {
-    tcx.crates()
-        .iter()
-        .find(|&&krate| tcx.original_crate_name(krate).as_str() == path[0])
-        .and_then(|krate| {
+    tcx.crates().iter().find(|&&krate| tcx.original_crate_name(krate).as_str() == path[0]).and_then(
+        |krate| {
             let krate = DefId { krate: *krate, index: CRATE_DEF_INDEX };
             let mut items = tcx.item_children(krate);
             let mut path_it = path.iter().skip(1).peekable();
@@ -40,7 +38,8 @@ fn try_resolve_did<'mir, 'tcx>(tcx: TyCtxt<'tcx>, path: &[&str]) -> Option<DefId
                 }
             }
             None
-        })
+        },
+    )
 }
 
 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
@@ -53,10 +52,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
     /// Evaluates the scalar at the specified path. Returns Some(val)
     /// if the path could be resolved, and None otherwise
-    fn eval_path_scalar(
-        &mut self,
-        path: &[&str],
-    ) -> InterpResult<'tcx, ScalarMaybeUninit<Tag>> {
+    fn eval_path_scalar(&mut self, path: &[&str]) -> InterpResult<'tcx, ScalarMaybeUninit<Tag>> {
         let this = self.eval_context_mut();
         let instance = this.resolve_path(path);
         let cid = GlobalId { instance, promoted: None };
@@ -67,9 +63,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
     /// Helper function to get a `libc` constant as a `Scalar`.
     fn eval_libc(&mut self, name: &str) -> InterpResult<'tcx, Scalar<Tag>> {
-        self.eval_context_mut()
-            .eval_path_scalar(&["libc", name])?
-            .check_init()
+        self.eval_context_mut().eval_path_scalar(&["libc", name])?.check_init()
     }
 
     /// Helper function to get a `libc` constant as an `i32`.
@@ -101,7 +95,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     /// Helper function to get the `TyAndLayout` of a `windows` type
     fn windows_ty_layout(&mut self, name: &str) -> InterpResult<'tcx, TyAndLayout<'tcx>> {
         let this = self.eval_context_mut();
-        let ty = this.resolve_path(&["std", "sys", "windows", "c", name]).ty(*this.tcx, ty::ParamEnv::reveal_all());
+        let ty = this
+            .resolve_path(&["std", "sys", "windows", "c", name])
+            .ty(*this.tcx, ty::ParamEnv::reveal_all());
         this.layout_of(ty)
     }
 
@@ -170,7 +166,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         let param_env = ty::ParamEnv::reveal_all(); // in Miri this is always the param_env we use... and this.param_env is private.
         let callee_abi = f.ty(*this.tcx, param_env).fn_sig(*this.tcx).abi();
         if callee_abi != caller_abi {
-            throw_ub_format!("calling a function with ABI {} using caller ABI {}", callee_abi.name(), caller_abi.name())
+            throw_ub_format!(
+                "calling a function with ABI {} using caller ABI {}",
+                callee_abi.name(),
+                caller_abi.name()
+            )
         }
 
         // Push frame.
@@ -181,9 +181,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         let mut callee_args = this.frame().body.args_iter();
         for arg in args {
             let callee_arg = this.local_place(
-                callee_args.next().ok_or_else(||
-                    err_ub_format!("callee has fewer arguments than expected")
-                )?
+                callee_args
+                    .next()
+                    .ok_or_else(|| err_ub_format!("callee has fewer arguments than expected"))?,
             )?;
             this.write_immediate(*arg, &callee_arg)?;
         }
@@ -356,7 +356,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 }
             }
 
-            fn visit_union(&mut self, _v: &MPlaceTy<'tcx, Tag>, _fields: NonZeroUsize) -> InterpResult<'tcx> {
+            fn visit_union(
+                &mut self,
+                _v: &MPlaceTy<'tcx, Tag>,
+                _fields: NonZeroUsize,
+            ) -> InterpResult<'tcx> {
                 bug!("we should have already handled unions in `visit_value`")
             }
         }
@@ -465,12 +469,21 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             })?
         } else if target.families.contains(&"windows".to_owned()) {
             // FIXME: we have to finish implementing the Windows equivalent of this.
-            this.eval_windows("c", match e.kind() {
-                NotFound => "ERROR_FILE_NOT_FOUND",
-                _ => throw_unsup_format!("io error {} cannot be transformed into a raw os error", e)
-            })?
+            this.eval_windows(
+                "c",
+                match e.kind() {
+                    NotFound => "ERROR_FILE_NOT_FOUND",
+                    _ => throw_unsup_format!(
+                        "io error {} cannot be transformed into a raw os error",
+                        e
+                    ),
+                },
+            )?
         } else {
-            throw_unsup_format!("setting the last OS error from an io::Error is unsupported for {}.", target_os)
+            throw_unsup_format!(
+                "setting the last OS error from an io::Error is unsupported for {}.",
+                target_os
+            )
         };
         this.set_last_error(last_error)
     }
@@ -556,8 +569,12 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 }
 
 /// Check that the number of args is what we expect.
-pub fn check_arg_count<'a, 'tcx, const N: usize>(args: &'a [OpTy<'tcx, Tag>]) -> InterpResult<'tcx, &'a [OpTy<'tcx, Tag>; N]>
-    where &'a [OpTy<'tcx, Tag>; N]: TryFrom<&'a [OpTy<'tcx, Tag>]> {
+pub fn check_arg_count<'a, 'tcx, const N: usize>(
+    args: &'a [OpTy<'tcx, Tag>],
+) -> InterpResult<'tcx, &'a [OpTy<'tcx, Tag>; N]>
+where
+    &'a [OpTy<'tcx, Tag>; N]: TryFrom<&'a [OpTy<'tcx, Tag>]>,
+{
     if let Ok(ops) = args.try_into() {
         return Ok(ops);
     }
@@ -569,7 +586,11 @@ pub fn check_abi<'a>(abi: Abi, exp_abi: Abi) -> InterpResult<'a, ()> {
     if abi == exp_abi {
         Ok(())
     } else {
-        throw_ub_format!("calling a function with ABI {} using caller ABI {}", exp_abi.name(), abi.name())
+        throw_ub_format!(
+            "calling a function with ABI {} using caller ABI {}",
+            exp_abi.name(),
+            abi.name()
+        )
     }
 }
 

src/intptrcast.rs

@@ -6,7 +6,7 @@ use log::trace;
 use rand::Rng;
 
 use rustc_data_structures::fx::FxHashMap;
-use rustc_target::abi::{Size, HasDataLayout};
+use rustc_target::abi::{HasDataLayout, Size};
 
 use crate::*;