1 files changed, 92 insertions, 0 deletions
diff --git a/src/tools/miri/tests/pass/ptr_offset.rs b/src/tools/miri/tests/pass/ptr_offset.rs
new file mode 100644
index 00000000000..95eac8522fb
--- /dev/null
+++ b/src/tools/miri/tests/pass/ptr_offset.rs
@@ -0,0 +1,92 @@
+//@compile-flags: -Zmiri-permissive-provenance
+#![feature(ptr_sub_ptr)]
+use std::{mem, ptr};
+
+fn main() {
+    smoke();
+    test_offset_from();
+    test_vec_into_iter();
+    ptr_arith_offset();
+    ptr_arith_offset_overflow();
+    ptr_offset();
+}
+
+fn smoke() {
+    // Smoke-test various offsetting operations.
+    let ptr = &5;
+    let ptr = ptr as *const i32;
+    let _val = ptr.wrapping_offset(0);
+    let _val = unsafe { ptr.offset(0) };
+    let _val = ptr.wrapping_add(0);
+    let _val = unsafe { ptr.add(0) };
+    let _val = ptr.wrapping_sub(0);
+    let _val = unsafe { ptr.sub(0) };
+    let _val = unsafe { ptr.offset_from(ptr) };
+    let _val = unsafe { ptr.sub_ptr(ptr) };
+}
+
+fn test_offset_from() {
+    unsafe {
+        let buf = [0u32; 4];
+
+        let x = buf.as_ptr() as *const u8;
+        let y = x.offset(12);
+
+        assert_eq!(y.offset_from(x), 12);
+        assert_eq!(y.sub_ptr(x), 12);
+        assert_eq!(x.offset_from(y), -12);
+        assert_eq!((y as *const u32).offset_from(x as *const u32), 12 / 4);
+        assert_eq!((x as *const u32).offset_from(y as *const u32), -12 / 4);
+
+        let x = (((x as usize) * 2) / 2) as *const u8;
+        assert_eq!(y.offset_from(x), 12);
+        assert_eq!(y.sub_ptr(x), 12);
+        assert_eq!(x.offset_from(y), -12);
+    }
+}
+
+// This also internally uses offset_from.
+fn test_vec_into_iter() {
+    let v = Vec::<i32>::new();
+    let i = v.into_iter();
+    i.size_hint();
+}
+
+fn ptr_arith_offset() {
+    let v = [1i16, 2];
+    let x = &v as *const [i16] as *const i16;
+    let x = x.wrapping_offset(1);
+    assert_eq!(unsafe { *x }, 2);
+}
+
+fn ptr_arith_offset_overflow() {
+    let v = [1i16, 2];
+    let x = &mut ptr::null(); // going through memory as there are more sanity checks along that path
+    *x = v.as_ptr().wrapping_offset(1); // ptr to the 2nd element
+    // Adding 2*isize::max and then 1 is like substracting 1
+    *x = x.wrapping_offset(isize::MAX);
+    *x = x.wrapping_offset(isize::MAX);
+    *x = x.wrapping_offset(1);
+    assert_eq!(unsafe { **x }, 1);
+}
+
+fn ptr_offset() {
+    fn f() -> i32 {
+        42
+    }
+
+    let v = [1i16, 2];
+    let x = &v as *const [i16; 2] as *const i16;
+    let x = unsafe { x.offset(1) };
+    assert_eq!(unsafe { *x }, 2);
+
+    // fn ptr offset
+    unsafe {
+        let p = f as fn() -> i32 as usize;
+        let x = (p as *mut u32).offset(0) as usize;
+        // *cast* to ptr, then transmute to fn ptr.
+        // (transmuting int to [fn]ptr causes trouble.)
+        let f: fn() -> i32 = mem::transmute(x as *const ());
+        assert_eq!(f(), 42);
+    }
+}