Also added multi arg support for allocs and calls

- Changed parsing to handle comma separated lists
- Changed types in config evaluator and global to use HashSet
- Adjusted Readme

Author: BennoLossin

README.md

@@ -314,10 +314,10 @@ environment variable:
   ensure alignment.  (The standard library `align_to` method works fine in both
   modes; under symbolic alignment it only fills the middle slice when the
   allocation guarantees sufficient alignment.)
-* `-Zmiri-track-alloc-id=<id>` shows a backtrace when the given allocation is
+* `-Zmiri-track-alloc-id=<id-list>` shows a backtrace when the given allocations are
   being allocated or freed.  This helps in debugging memory leaks and
   use after free bugs.
-* `-Zmiri-track-call-id=<id>` shows a backtrace when the given call id is
+* `-Zmiri-track-call-id=<id-list>` shows a backtrace when the given call ids are
   assigned to a stack frame.  This helps in debugging UB related to Stacked
   Borrows "protectors".
 * `-Zmiri-track-pointer-tag=<tag-list>` shows a backtrace when a given pointer tag

src/bin/miri.rs

@@ -397,11 +397,16 @@ fn main() {
                         .push(arg.strip_prefix("-Zmiri-env-forward=").unwrap().to_owned());
                 }
                 arg if arg.starts_with("-Zmiri-track-pointer-tag=") => {
-                    let ids: Vec<u64> = match arg.strip_prefix("-Zmiri-track-pointer-tag=").unwrap().split(',').map(|id| id.parse::<u64>()).collect() {
+                    let ids: Vec<u64> = match arg
+                        .strip_prefix("-Zmiri-track-pointer-tag=")
+                        .unwrap()
+                        .split(',')
+                        .map(str::parse::<u64>).collect()
+                    {
                         Ok(ids) => ids,
                         Err(err) =>
                             panic!(
-                                "-Zmiri-track-pointer-tag requires a comma seperated list of valid `u64` arguments: {}",
+                                "-Zmiri-track-pointer-tag requires a comma separated list of valid `u64` arguments: {}",
                                 err
                             ),
                     };
@@ -414,30 +419,39 @@ 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,
+                    let ids: Vec<u64> = match arg
+                        .strip_prefix("-Zmiri-track-call-id=")
+                        .unwrap()
+                        .split(',')
+                        .map(str::parse::<u64>)
+                        .collect()
+                    {
+                        Ok(ids) => ids,
                         Err(err) =>
-                            panic!("-Zmiri-track-call-id requires a valid `u64` argument: {}", err),
+                            panic!("-Zmiri-track-call-id requires a comma separated list of valid `u64` arguments: {}", err),
                     };
-                    if let Some(id) = miri::CallId::new(id) {
-                        miri_config.tracked_call_id = Some(id);
-                    } else {
-                        panic!("-Zmiri-track-call-id requires a nonzero argument");
+                    for id in ids.into_iter().map(miri::CallId::new) {
+                        if let Some(id) = id {
+                            miri_config.tracked_call_ids.insert(id);
+                        } else {
+                            panic!("-Zmiri-track-call-id requires a nonzero argument");
+                        }
                     }
                 }
                 arg if arg.starts_with("-Zmiri-track-alloc-id=") => {
-                    let id = match arg
+                    let ids: Vec<miri::AllocId> = match arg
                         .strip_prefix("-Zmiri-track-alloc-id=")
                         .unwrap()
-                        .parse()
-                        .ok()
-                        .and_then(NonZeroU64::new)
+                        .split(',')
+                        .map(str::parse::<u64>)
+                        .map(|id| id.ok().and_then(NonZeroU64::new).map(miri::AllocId))
+                        .collect()
                     {
-                        Some(id) => id,
+                        Some(ids) => ids,
                         None =>
-                            panic!("-Zmiri-track-alloc-id requires a valid non-zero `u64` argument"),
+                            panic!("-Zmiri-track-alloc-id requires a comma separated list of valid non-zero `u64` arguments"),
                     };
-                    miri_config.tracked_alloc_id = Some(miri::AllocId(id));
+                    miri_config.tracked_alloc_ids.extend(ids);
                 }
                 arg if arg.starts_with("-Zmiri-compare-exchange-weak-failure-rate=") => {
                     let rate = match arg

src/eval.rs

@@ -95,10 +95,10 @@ pub struct MiriConfig {
     pub seed: Option<u64>,
     /// The stacked borrows pointer ids to report about
     pub tracked_pointer_tags: HashSet<PtrId>,
-    /// The stacked borrows call ID to report about
-    pub tracked_call_id: Option<CallId>,
-    /// The allocation id to report about.
-    pub tracked_alloc_id: Option<AllocId>,
+    /// The stacked borrows call IDs to report about
+    pub tracked_call_ids: HashSet<CallId>,
+    /// The allocation ids to report about.
+    pub tracked_alloc_ids: HashSet<AllocId>,
     /// Whether to track raw pointers in stacked borrows.
     pub tag_raw: bool,
     /// Determine if data race detection should be enabled
@@ -133,8 +133,8 @@ impl Default for MiriConfig {
             args: vec![],
             seed: None,
             tracked_pointer_tags: Default::default(),
-            tracked_call_id: None,
-            tracked_alloc_id: None,
+            tracked_call_ids: Default::default(),
+            tracked_alloc_ids: Default::default(),
             tag_raw: false,
             data_race_detector: true,
             cmpxchg_weak_failure_rate: 0.8,

src/machine.rs

@@ -6,6 +6,7 @@ use std::cell::RefCell;
 use std::fmt;
 use std::num::NonZeroU64;
 use std::time::Instant;
+use std::collections::HashSet;
 
 use rand::rngs::StdRng;
 use rand::SeedableRng;
@@ -281,9 +282,9 @@ pub struct Evaluator<'mir, 'tcx> {
     /// 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
+    /// The allocation IDs to report when they are being allocated
     /// (helps for debugging memory leaks and use after free bugs).
-    tracked_alloc_id: Option<AllocId>,
+    tracked_alloc_ids: HashSet<AllocId>,
 
     /// Controls whether alignment of memory accesses is being checked.
     pub(crate) check_alignment: AlignmentCheck,
@@ -304,7 +305,7 @@ impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
         let stacked_borrows = if config.stacked_borrows {
             Some(RefCell::new(stacked_borrows::GlobalStateInner::new(
                 config.tracked_pointer_tags.clone(),
-                config.tracked_call_id,
+                config.tracked_call_ids.clone(),
                 config.tag_raw,
             )))
         } else {
@@ -340,7 +341,7 @@ impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
             local_crates,
             extern_statics: FxHashMap::default(),
             rng: RefCell::new(rng),
-            tracked_alloc_id: config.tracked_alloc_id,
+            tracked_alloc_ids: config.tracked_alloc_ids.clone(),
             check_alignment: config.check_alignment,
             cmpxchg_weak_failure_rate: config.cmpxchg_weak_failure_rate,
         }
@@ -557,7 +558,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
         alloc: Cow<'b, Allocation>,
         kind: Option<MemoryKind<Self::MemoryKind>>,
     ) -> Cow<'b, Allocation<Self::PointerTag, Self::AllocExtra>> {
-        if Some(id) == ecx.machine.tracked_alloc_id {
+        if ecx.machine.tracked_alloc_ids.contains(&id) {
             register_diagnostic(NonHaltingDiagnostic::CreatedAlloc(id));
         }
 
@@ -666,7 +667,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
         tag: Tag,
         range: AllocRange,
     ) -> InterpResult<'tcx> {
-        if Some(tag.alloc_id) == machine.tracked_alloc_id {
+        if machine.tracked_alloc_ids.contains(&tag.alloc_id) {
             register_diagnostic(NonHaltingDiagnostic::FreedAlloc(tag.alloc_id));
         }
         if let Some(data_race) = &mut alloc_extra.data_race {

src/stacked_borrows.rs

@@ -107,8 +107,8 @@ pub struct GlobalStateInner {
     active_calls: FxHashSet<CallId>,
     /// The pointer ids to trace
     tracked_pointer_tags: HashSet<PtrId>,
-    /// The call id to trace
-    tracked_call_id: Option<CallId>,
+    /// The call ids to trace
+    tracked_call_ids: HashSet<CallId>,
     /// Whether to track raw pointers.
     tag_raw: bool,
 }
@@ -160,7 +160,7 @@ impl fmt::Display for RefKind {
 impl GlobalStateInner {
     pub fn new(
         tracked_pointer_tags: HashSet<PtrId>,
-        tracked_call_id: Option<CallId>,
+        tracked_call_ids: HashSet<CallId>,
         tag_raw: bool,
     ) -> Self {
         GlobalStateInner {
@@ -169,7 +169,7 @@ impl GlobalStateInner {
             next_call_id: NonZeroU64::new(1).unwrap(),
             active_calls: FxHashSet::default(),
             tracked_pointer_tags,
-            tracked_call_id,
+            tracked_call_ids,
             tag_raw,
         }
     }
@@ -186,7 +186,7 @@ impl GlobalStateInner {
     pub fn new_call(&mut self) -> CallId {
         let id = self.next_call_id;
         trace!("new_call: Assigning ID {}", id);
-        if Some(id) == self.tracked_call_id {
+        if self.tracked_call_ids.contains(&id) {
             register_diagnostic(NonHaltingDiagnostic::CreatedCallId(id));
         }
         assert!(self.active_calls.insert(id));