Size -> Range in RangeMap's iterators

Author: Vanille-N

src/borrow_tracker/stacked_borrows/mod.rs

@@ -459,7 +459,7 @@ impl<'tcx> Stack {
 impl Stacks {
     pub fn remove_unreachable_tags(&mut self, live_tags: &FxHashSet<BorTag>) {
         if self.modified_since_last_gc {
-            for stack in self.stacks.iter_mut_all() {
+            for (_, stack) in self.stacks.iter_mut_all() {
                 if stack.len() > 64 {
                     stack.retain(live_tags);
                 }
@@ -512,7 +512,7 @@ impl<'tcx> Stacks {
     ) -> InterpResult<'tcx> {
         self.modified_since_last_gc = true;
         for (offset, stack) in self.stacks.iter_mut(range.start, range.size) {
-            let mut dcx = dcx_builder.build(&mut self.history, offset);
+            let mut dcx = dcx_builder.build(&mut self.history, Size::from_bytes(offset.start));
             f(stack, &mut dcx, &mut self.exposed_tags)?;
             dcx_builder = dcx.unbuild();
         }

src/borrow_tracker/tree_borrows/diagnostics.rs

@@ -3,7 +3,6 @@ use std::ops::Range;
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_span::{Span, SpanData};
-use rustc_target::abi::Size;
 
 use crate::borrow_tracker::tree_borrows::{
     perms::{PermTransition, Permission},
@@ -25,7 +24,7 @@ pub struct Event {
     pub access_kind: AccessKind,
     pub is_foreign: bool,
     pub access_range: AllocRange,
-    pub offset: Size,
+    pub offset: Range<u64>,
     pub span: Span,
 }
 
@@ -243,7 +242,7 @@ pub(super) struct TbError<'node> {
     /// What failure occurred.
     pub error_kind: TransitionError,
     /// The byte at which the conflict occured.
-    pub error_offset: Size,
+    pub error_offset: u64,
     /// The tag on which the error was triggered.
     /// On protector violations, this is the tag that was protected.
     /// On accesses rejected due to insufficient permissions, this is the

src/borrow_tracker/tree_borrows/tree.rs

@@ -368,7 +368,7 @@ impl<'tcx> Tree {
                         TbError {
                             conflicting_info,
                             access_kind: AccessKind::Write,
-                            error_offset: offset,
+                            error_offset: offset.start,
                             error_kind,
                             accessed_info,
                         }
@@ -458,7 +458,7 @@ impl<'tcx> Tree {
                                 access_kind,
                                 access_range: range,
                                 is_foreign: rel_pos.is_foreign(),
-                                offset,
+                                offset: offset.clone(),
                                 span,
                             });
                             old_state.permission =
@@ -472,7 +472,7 @@ impl<'tcx> Tree {
                         TbError {
                             conflicting_info,
                             access_kind,
-                            error_offset: offset,
+                            error_offset: offset.start,
                             error_kind,
                             accessed_info,
                         }
@@ -530,7 +530,7 @@ impl Tree {
             // the tag from the mapping.
             let tag = node.tag;
             self.nodes.remove(idx);
-            for perms in self.rperms.iter_mut_all() {
+            for (_, perms) in self.rperms.iter_mut_all() {
                 perms.remove(idx);
             }
             self.tag_mapping.remove(&tag);

src/concurrency/data_race.rs

@@ -869,7 +869,7 @@ impl VClockAlloc {
                         range,
                         "Read",
                         false,
-                        Pointer::new(alloc_id, offset),
+                        Pointer::new(alloc_id, Size::from_bytes(offset.start)),
                     );
                 }
             }
@@ -903,7 +903,7 @@ impl VClockAlloc {
                         range,
                         write_type.get_descriptor(),
                         false,
-                        Pointer::new(alloc_id, offset),
+                        Pointer::new(alloc_id, Size::from_bytes(offset.start)),
                     );
                 }
             }
@@ -1137,7 +1137,7 @@ trait EvalContextPrivExt<'mir, 'tcx: 'mir>: MiriInterpCxExt<'mir, 'tcx> {
                                     range,
                                     description,
                                     true,
-                                    Pointer::new(alloc_id, offset),
+                                    Pointer::new(alloc_id, Size::from_bytes(offset.start)),
                                 )
                                 .map(|_| true);
                             }

src/range_map.rs

@@ -63,7 +63,7 @@ impl<T> RangeMap<T> {
     /// through interior mutability.
     ///
     /// The iterator also provides the offset of the given element.
-    pub fn iter(&self, offset: Size, len: Size) -> impl Iterator<Item = (Size, &T)> {
+    pub fn iter(&self, offset: Size, len: Size) -> impl Iterator<Item = (ops::Range<u64>, &T)> {
         let offset = offset.bytes();
         let len = len.bytes();
         // Compute a slice starting with the elements we care about.
@@ -84,11 +84,11 @@ impl<T> RangeMap<T> {
         slice
             .iter()
             .take_while(move |elem| elem.range.start < end)
-            .map(|elem| (Size::from_bytes(elem.range.start), &elem.data))
+            .map(|elem| (elem.range.clone(), &elem.data))
     }
 
-    pub fn iter_mut_all(&mut self) -> impl Iterator<Item = &mut T> {
-        self.v.iter_mut().map(|elem| &mut elem.data)
+    pub fn iter_mut_all(&mut self) -> impl Iterator<Item = (ops::Range<u64>, &mut T)> {
+        self.v.iter_mut().map(|elem| (elem.range.clone(), &mut elem.data))
     }
 
     pub fn iter_all(&self) -> impl Iterator<Item = (ops::Range<u64>, &T)> {
@@ -127,7 +127,11 @@ impl<T> RangeMap<T> {
     /// Moreover, this will opportunistically merge neighbouring equal blocks.
     ///
     /// The iterator also provides the offset of the given element.
-    pub fn iter_mut(&mut self, offset: Size, len: Size) -> impl Iterator<Item = (Size, &mut T)>
+    pub fn iter_mut(
+        &mut self,
+        offset: Size,
+        len: Size,
+    ) -> impl Iterator<Item = (ops::Range<u64>, &mut T)>
     where
         T: Clone + PartialEq,
     {
@@ -208,7 +212,7 @@ impl<T> RangeMap<T> {
             // Now we yield the slice. `end` is inclusive.
             &mut self.v[first_idx..=end_idx]
         };
-        slice.iter_mut().map(|elem| (Size::from_bytes(elem.range.start), &mut elem.data))
+        slice.iter_mut().map(|elem| (elem.range.clone(), &mut elem.data))
     }
 }