Add option to print when an AllocId gets created

README.md

@@ -180,6 +180,8 @@ Several `-Z` flags are relevant for Miri:
   is popped from a borrow stack (which is where the tag becomes invalid and any
   future use of it will error).  This helps you in finding out why UB is
   happening and where in your code would be a good place to look for it.
+* `-Zmiri-track-alloc-id=<id>` shows a backtrace when the given allocation is
+  being allocated.  This helps in debugging memory leaks.
 
 Moreover, Miri recognizes some environment variables:
 

benches/helpers/miri_helper.rs

@@ -29,16 +29,7 @@ impl rustc_driver::Callbacks for MiriCompilerCalls<'_> {
                 tcx.entry_fn(LOCAL_CRATE).expect("no main or start function found");
 
             self.bencher.iter(|| {
-                let config = miri::MiriConfig {
-                    validate: true,
-                    stacked_borrows: true,
-                    communicate: false,
-                    ignore_leaks: false,
-                    excluded_env_vars: vec![],
-                    args: vec![],
-                    seed: None,
-                    tracked_pointer_tag: None,
-                };
+                let config = miri::MiriConfig::default();
                 eval_main(tcx, entry_def_id, config);
             });
         });

src/bin/miri-rustc-tests.rs

@@ -46,16 +46,7 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
                                 .iter()
                                 .any(|attr| attr.check_name(rustc_span::symbol::sym::test))
                             {
-                                let config = MiriConfig {
-                                    validate: true,
-                                    stacked_borrows: true,
-                                    communicate: false,
-                                    ignore_leaks: false,
-                                    excluded_env_vars: vec![],
-                                    args: vec![],
-                                    seed: None,
-                                    tracked_pointer_tag: None,
-                                };
+                                let config = MiriConfig::default();
                                 let did = self.0.hir().body_owner_def_id(body_id);
                                 println!("running test: {}", self.0.def_path_debug_str(did));
                                 miri::eval_main(self.0, did, config);
@@ -68,16 +59,7 @@ impl rustc_driver::Callbacks for MiriCompilerCalls {
                 }
                 tcx.hir().krate().visit_all_item_likes(&mut Visitor(tcx));
             } else if let Some((entry_def_id, _)) = tcx.entry_fn(LOCAL_CRATE) {
-                let config = MiriConfig {
-                    validate: true,
-                    stacked_borrows: true,
-                    communicate: false,
-                    ignore_leaks: false,
-                    excluded_env_vars: vec![],
-                    args: vec![],
-                    seed: None,
-                    tracked_pointer_tag: None,
-                };
+                let config = MiriConfig::default();
                 miri::eval_main(tcx, entry_def_id, config);
 
                 compiler.session().abort_if_errors();

src/bin/miri.rs

@@ -135,6 +135,7 @@ fn main() {
     let mut ignore_leaks = false;
     let mut seed: Option<u64> = None;
     let mut tracked_pointer_tag: Option<miri::PtrId> = None;
+    let mut tracked_alloc_id: Option<miri::AllocId> = None;
     let mut rustc_args = vec![];
     let mut miri_args = vec![];
     let mut after_dashdash = false;
@@ -206,6 +207,17 @@ fn main() {
                         panic!("-Zmiri-track-pointer-tag must be a nonzero id");
                     }
                 }
+                arg if arg.starts_with("-Zmiri-track-alloc-id=") => {
+                    let id: u64 = match arg.trim_start_matches("-Zmiri-track-alloc-id=").parse()
+                    {
+                        Ok(id) => id,
+                        Err(err) => panic!(
+                            "-Zmiri-track-alloc-id requires a valid `u64` as the argument: {}",
+                            err
+                        ),
+                    };
+                    tracked_alloc_id = Some(miri::AllocId(id));
+                }
                 _ => {
                     rustc_args.push(arg);
                 }
@@ -240,6 +252,7 @@ fn main() {
         seed,
         args: miri_args,
         tracked_pointer_tag,
+        tracked_alloc_id,
     };
     rustc_driver::install_ice_hook();
     let result = rustc_driver::catch_fatal_errors(move || {

src/diagnostics.rs

@@ -6,6 +6,7 @@ use crate::*;
 /// Miri specific diagnostics
 pub enum NonHaltingDiagnostic {
     PoppedTrackedPointerTag(Item),
+    CreatedAlloc(AllocId),
 }
 
 /// Emit a custom diagnostic without going through the miri-engine machinery
@@ -97,9 +98,12 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         let this = self.eval_context_ref();
         DIAGNOSTICS.with(|diagnostics| {
             for e in diagnostics.borrow_mut().drain(..) {
+                use NonHaltingDiagnostic::*;
                 let msg = match e {
-                    NonHaltingDiagnostic::PoppedTrackedPointerTag(item) =>
+                    PoppedTrackedPointerTag(item) =>
                         format!("popped tracked tag for item {:?}", item),
+                    CreatedAlloc(AllocId(id)) =>
+                        format!("created allocation with id {}", id),
                 };
                 report_msg(this, msg, false);
             }

src/eval.rs

@@ -30,6 +30,24 @@ pub struct MiriConfig {
     pub seed: Option<u64>,
     /// The stacked borrow id to report about
     pub tracked_pointer_tag: Option<PtrId>,
+    /// The allocation id to report about.
+    pub tracked_alloc_id: Option<AllocId>,
+}
+
+impl Default for MiriConfig {
+    fn default() -> MiriConfig {
+        MiriConfig {
+            validate: true,
+            stacked_borrows: true,
+            communicate: false,
+            ignore_leaks: false,
+            excluded_env_vars: vec![],
+            args: vec![],
+            seed: None,
+            tracked_pointer_tag: None,
+            tracked_alloc_id: None,
+        }
+    }
 }
 
 /// Details of premature program termination.
@@ -55,6 +73,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
             StdRng::seed_from_u64(config.seed.unwrap_or(0)),
             config.stacked_borrows,
             config.tracked_pointer_tag,
+            config.tracked_alloc_id,
         ),
     );
     // Complete initialization.

src/machine.rs

@@ -75,15 +75,19 @@ pub struct MemoryExtra {
     pub intptrcast: intptrcast::MemoryExtra,
 
     /// Mapping extern static names to their canonical allocation.
-    pub(crate) extern_statics: FxHashMap<Symbol, AllocId>,
+    extern_statics: FxHashMap<Symbol, AllocId>,
 
     /// The random number generator used for resolving non-determinism.
     /// Needs to be queried by ptr_to_int, hence needs interior mutability.
     pub(crate) rng: RefCell<StdRng>,
+
+    /// An allocation ID to report when it is being allocated
+    /// (helps for debugging memory leaks).
+    tracked_alloc_id: Option<AllocId>,
 }
 
 impl MemoryExtra {
-    pub fn new(rng: StdRng, stacked_borrows: bool, tracked_pointer_tag: Option<PtrId>) -> Self {
+    pub fn new(rng: StdRng, stacked_borrows: bool, tracked_pointer_tag: Option<PtrId>, tracked_alloc_id: Option<AllocId>) -> Self {
         let stacked_borrows = if stacked_borrows {
             Some(Rc::new(RefCell::new(stacked_borrows::GlobalState::new(tracked_pointer_tag))))
         } else {
@@ -94,6 +98,7 @@ impl MemoryExtra {
             intptrcast: Default::default(),
             extern_statics: FxHashMap::default(),
             rng: RefCell::new(rng),
+            tracked_alloc_id,
         }
     }
 
@@ -329,6 +334,10 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
         alloc: Cow<'b, Allocation>,
         kind: Option<MemoryKind<Self::MemoryKinds>>,
     ) -> (Cow<'b, Allocation<Self::PointerTag, Self::AllocExtra>>, Self::PointerTag) {
+        if Some(id) == memory_extra.tracked_alloc_id {
+            register_diagnostic(NonHaltingDiagnostic::CreatedAlloc(id));
+        }
+
         let kind = kind.expect("we set our STATIC_KIND so this cannot be None");
         let alloc = alloc.into_owned();
         let (stacks, base_tag) =