Added support for multiple tracked pointers

- Changed arg parsing to handle comma seperated list of `u64`.
- Changed type and field names of config and global state to hold a set
  of tracked ids.
- Adjusted Readme

Author: BennoLossin

README.md

@@ -320,7 +320,7 @@ environment variable:
 * `-Zmiri-track-call-id=<id>` shows a backtrace when the given call id is
   assigned to a stack frame.  This helps in debugging UB related to Stacked
   Borrows "protectors".
-* `-Zmiri-track-pointer-tag=<tag>` shows a backtrace when the given pointer tag
+* `-Zmiri-track-pointer-tag=<tag-list>` shows a backtrace when a given pointer tag
   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.

src/bin/miri.rs

@@ -397,19 +397,20 @@ fn main() {
                         .push(arg.strip_prefix("-Zmiri-env-forward=").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
-                                ),
-                        };
-                    if let Some(id) = miri::PtrId::new(id) {
-                        miri_config.tracked_pointer_tag = Some(id);
-                    } else {
-                        panic!("-Zmiri-track-pointer-tag requires a nonzero argument");
+                    let ids: Vec<u64> = match arg.strip_prefix("-Zmiri-track-pointer-tag=").unwrap().split(',').map(|id| id.parse::<u64>()).collect() {
+                        Ok(ids) => ids,
+                        Err(err) =>
+                            panic!(
+                                "-Zmiri-track-pointer-tag requires a comma seperated list of valid `u64` arguments: {}",
+                                err
+                            ),
+                    };
+                    for id in ids.into_iter().map(miri::PtrId::new) {
+                        if let Some(id) = id {
+                            miri_config.tracked_pointer_tags.insert(id);
+                        } else {
+                            panic!("-Zmiri-track-pointer-tag requires nonzero arguments");
+                        }
                     }
                 }
                 arg if arg.starts_with("-Zmiri-track-call-id=") => {

src/eval.rs

@@ -15,6 +15,8 @@ use rustc_target::spec::abi::Abi;
 
 use rustc_session::config::EntryFnType;
 
+use std::collections::HashSet;
+
 use crate::*;
 
 #[derive(Copy, Clone, Debug, PartialEq)]
@@ -91,8 +93,8 @@ pub struct MiriConfig {
     pub args: Vec<String>,
     /// The seed to use when non-determinism or randomness are required (e.g. ptr-to-int cast, `getrandom()`).
     pub seed: Option<u64>,
-    /// The stacked borrows pointer id to report about
-    pub tracked_pointer_tag: Option<PtrId>,
+    /// 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.
@@ -130,7 +132,7 @@ impl Default for MiriConfig {
             forwarded_env_vars: vec![],
             args: vec![],
             seed: None,
-            tracked_pointer_tag: None,
+            tracked_pointer_tags: Default::default(),
             tracked_call_id: None,
             tracked_alloc_id: None,
             tag_raw: false,

src/machine.rs

@@ -303,7 +303,7 @@ impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
         let rng = StdRng::seed_from_u64(config.seed.unwrap_or(0));
         let stacked_borrows = if config.stacked_borrows {
             Some(RefCell::new(stacked_borrows::GlobalStateInner::new(
-                config.tracked_pointer_tag,
+                config.tracked_pointer_tags.clone(),
                 config.tracked_call_id,
                 config.tag_raw,
             )))

src/stacked_borrows.rs

@@ -15,6 +15,7 @@ use rustc_middle::ty::{
 };
 use rustc_span::DUMMY_SP;
 use rustc_target::abi::Size;
+use std::collections::HashSet;
 
 use crate::*;
 
@@ -104,8 +105,8 @@ pub struct GlobalStateInner {
     next_call_id: CallId,
     /// Those call IDs corresponding to functions that are still running.
     active_calls: FxHashSet<CallId>,
-    /// The pointer id to trace
-    tracked_pointer_tag: Option<PtrId>,
+    /// The pointer ids to trace
+    tracked_pointer_tags: HashSet<PtrId>,
     /// The call id to trace
     tracked_call_id: Option<CallId>,
     /// Whether to track raw pointers.
@@ -158,7 +159,7 @@ impl fmt::Display for RefKind {
 /// Utilities for initialization and ID generation
 impl GlobalStateInner {
     pub fn new(
-        tracked_pointer_tag: Option<PtrId>,
+        tracked_pointer_tags: HashSet<PtrId>,
         tracked_call_id: Option<CallId>,
         tag_raw: bool,
     ) -> Self {
@@ -167,15 +168,15 @@ impl GlobalStateInner {
             base_ptr_ids: FxHashMap::default(),
             next_call_id: NonZeroU64::new(1).unwrap(),
             active_calls: FxHashSet::default(),
-            tracked_pointer_tag,
+            tracked_pointer_tags,
             tracked_call_id,
             tag_raw,
         }
     }
 
     fn new_ptr(&mut self) -> PtrId {
         let id = self.next_ptr_id;
-        if Some(id) == self.tracked_pointer_tag {
+        if self.tracked_pointer_tags.contains(&id) {
             register_diagnostic(NonHaltingDiagnostic::CreatedPointerTag(id));
         }
         self.next_ptr_id = NonZeroU64::new(id.get() + 1).unwrap();
@@ -311,7 +312,7 @@ impl<'tcx> Stack {
         global: &GlobalStateInner,
     ) -> InterpResult<'tcx> {
         if let SbTag::Tagged(id) = item.tag {
-            if Some(id) == global.tracked_pointer_tag {
+            if global.tracked_pointer_tags.contains(&id) {
                 register_diagnostic(NonHaltingDiagnostic::PoppedPointerTag(
                     item.clone(),
                     provoking_access,