Print more in SB error diagnostics

This tries to clarify exactly why an access is not valid by printing
what memory range the access was over, which in combination with
tag-tracking may help a user figure out the source of the problem.

Author: saethlin

src/stacked_borrows.rs

@@ -338,16 +338,20 @@ impl<'tcx> Stack {
         &mut self,
         access: AccessKind,
         tag: SbTag,
-        dbg_ptr: Pointer<AllocId>, // just for debug printing amd error messages
+        (alloc_id, range): (AllocId, AllocRange), // just for debug printing amd error messages
         global: &GlobalState,
     ) -> InterpResult<'tcx> {
         // Two main steps: Find granting item, remove incompatible items above.
 
         // Step 1: Find granting item.
         let granting_idx = self.find_granting(access, tag).ok_or_else(|| {
             err_sb_ub(format!(
-                "no item granting {} to tag {:?} at {:?} found in borrow stack.",
-                access, tag, dbg_ptr,
+                "no item granting {} to tag {:?} over {}[{:#x}..{:#x}] found in borrow stack.",
+                access,
+                tag,
+                alloc_id,
+                range.start.bytes(),
+                range.end().bytes(),
             ))
         })?;
 
@@ -416,19 +420,17 @@ impl<'tcx> Stack {
         &mut self,
         derived_from: SbTag,
         new: Item,
-        dbg_ptr: Pointer<AllocId>,
+        (alloc_id, alloc_range): (AllocId, AllocRange),
         global: &GlobalState,
     ) -> InterpResult<'tcx> {
         // Figure out which access `perm` corresponds to.
         let access =
             if new.perm.grants(AccessKind::Write) { AccessKind::Write } else { AccessKind::Read };
         // Now we figure out which item grants our parent (`derived_from`) this kind of access.
         // We use that to determine where to put the new item.
-        let granting_idx = self.find_granting(access, derived_from)
-            .ok_or_else(|| err_sb_ub(format!(
-                "trying to reborrow for {:?} at {:?}, but parent tag {:?} does not have an appropriate item in the borrow stack",
-                new.perm, dbg_ptr, derived_from,
-            )))?;
+        let granting_idx = self
+            .find_granting(access, derived_from)
+            .ok_or_else(|| self.grant_error(derived_from, new, alloc_id, alloc_range))?;
 
         // Compute where to put the new item.
         // Either way, we ensure that we insert the new item in a way such that between
@@ -447,7 +449,7 @@ impl<'tcx> Stack {
             // A "safe" reborrow for a pointer that actually expects some aliasing guarantees.
             // Here, creating a reference actually counts as an access.
             // This ensures F2b for `Unique`, by removing offending `SharedReadOnly`.
-            self.access(access, derived_from, dbg_ptr, global)?;
+            self.access(access, derived_from, (alloc_id, alloc_range), global)?;
 
             // We insert "as far up as possible": We know only compatible items are remaining
             // on top of `derived_from`, and we want the new item at the top so that we
@@ -467,6 +469,41 @@ impl<'tcx> Stack {
 
         Ok(())
     }
+
+    /// Report a descriptive error when `new` could not be granted from `derived_from`.
+    fn grant_error(
+        &self,
+        derived_from: SbTag,
+        new: Item,
+        alloc_id: AllocId,
+        alloc_range: AllocRange,
+    ) -> InterpError<'static> {
+        let action = format!(
+            "trying to reborrow for {:?} over {:?}[{:#x}..{:#x}]",
+            new.perm,
+            alloc_id,
+            alloc_range.start.bytes(),
+            alloc_range.end().bytes()
+        );
+        if derived_from == SbTag::Untagged {
+            err_sb_ub(format!(
+                "{}, but parent tag {:?} does not grant the required permission over memory range",
+                action, derived_from
+            ))
+        } else {
+            if let Some(parent) = self.borrows.iter().rev().find(|item| derived_from == item.tag) {
+                err_sb_ub(format!(
+                    "{}, but parent tag {:?} grants insufficient permission: {:?}",
+                    action, derived_from, parent.perm
+                ))
+            } else {
+                err_sb_ub(format!(
+                    "{}, but parent tag {:?} does not exist in the borrow stack for this memory range",
+                    action, derived_from
+                ))
+            }
+        }
+    }
 }
 // # Stacked Borrows Core End
 
@@ -565,8 +602,8 @@ impl Stacks {
             range.size.bytes()
         );
         let global = &*extra.borrow();
-        self.for_each(range, move |offset, stack| {
-            stack.access(AccessKind::Read, tag, Pointer::new(alloc_id, offset), global)
+        self.for_each(range, move |_offset, stack| {
+            stack.access(AccessKind::Read, tag, (alloc_id, range), global)
         })
     }
 
@@ -585,8 +622,8 @@ impl Stacks {
             range.size.bytes()
         );
         let global = extra.get_mut();
-        self.for_each_mut(range, move |offset, stack| {
-            stack.access(AccessKind::Write, tag, Pointer::new(alloc_id, offset), global)
+        self.for_each_mut(range, move |_offset, stack| {
+            stack.access(AccessKind::Write, tag, (alloc_id, range), global)
         })
     }
 
@@ -692,8 +729,8 @@ trait EvalContextPrivExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                         Permission::SharedReadWrite
                     };
                     let item = Item { perm, tag: new_tag, protector };
-                    stacked_borrows.for_each(range, |offset, stack| {
-                        stack.grant(orig_tag, item, Pointer::new(alloc_id, offset), &*global)
+                    stacked_borrows.for_each(range, |_offset, stack| {
+                        stack.grant(orig_tag, item, (alloc_id, range), &*global)
                     })
                 })?;
                 return Ok(());
@@ -707,8 +744,9 @@ trait EvalContextPrivExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             alloc_extra.stacked_borrows.as_mut().expect("we should have Stacked Borrows data");
         let global = memory_extra.stacked_borrows.as_mut().unwrap().get_mut();
         let item = Item { perm, tag: new_tag, protector };
-        stacked_borrows.for_each_mut(alloc_range(base_offset, size), |offset, stack| {
-            stack.grant(orig_tag, item, Pointer::new(alloc_id, offset), global)
+        let range = alloc_range(base_offset, size);
+        stacked_borrows.for_each_mut(alloc_range(base_offset, size), |_offset, stack| {
+            stack.grant(orig_tag, item, (alloc_id, range), global)
         })?;
         Ok(())
     }