library/core/tests/ptr.rs

   1 use core::cell::RefCell;
   2 #[cfg(not(bootstrap))]
   3 use core::ptr;
   4 use core::ptr::*;
   5 #[cfg(not(bootstrap))]
   6 use std::fmt::{Debug, Display};
   7
   8 #[test]
   9 fn test_const_from_raw_parts() {
  10     const SLICE: &[u8] = &[1, 2, 3, 4];
  11     const FROM_RAW: &[u8] = unsafe { &*slice_from_raw_parts(SLICE.as_ptr(), SLICE.len()) };
  12     assert_eq!(SLICE, FROM_RAW);
  13
  14     let slice = &[1, 2, 3, 4, 5];
  15     let from_raw = unsafe { &*slice_from_raw_parts(slice.as_ptr(), 2) };
  16     assert_eq!(&slice[..2], from_raw);
  17 }
  18
  19 #[test]
  20 fn test() {
  21     unsafe {
  22         struct Pair {
  23             fst: isize,
  24             snd: isize,
  25         }
  26         let mut p = Pair { fst: 10, snd: 20 };
  27         let pptr: *mut Pair = &mut p;
  28         let iptr: *mut isize = pptr as *mut isize;
  29         assert_eq!(*iptr, 10);
  30         *iptr = 30;
  31         assert_eq!(*iptr, 30);
  32         assert_eq!(p.fst, 30);
  33
  34         *pptr = Pair { fst: 50, snd: 60 };
  35         assert_eq!(*iptr, 50);
  36         assert_eq!(p.fst, 50);
  37         assert_eq!(p.snd, 60);
  38
  39         let v0 = vec![32000u16, 32001u16, 32002u16];
  40         let mut v1 = vec![0u16, 0u16, 0u16];
  41
  42         copy(v0.as_ptr().offset(1), v1.as_mut_ptr().offset(1), 1);
  43         assert!((v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16));
  44         copy(v0.as_ptr().offset(2), v1.as_mut_ptr(), 1);
  45         assert!((v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 0u16));
  46         copy(v0.as_ptr(), v1.as_mut_ptr().offset(2), 1);
  47         assert!((v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 32000u16));
  48     }
  49 }
  50
  51 #[test]
  52 fn test_is_null() {
  53     let p: *const isize = null();
  54     assert!(p.is_null());
  55
  56     let q = p.wrapping_offset(1);
  57     assert!(!q.is_null());
  58
  59     let mp: *mut isize = null_mut();
  60     assert!(mp.is_null());
  61
  62     let mq = mp.wrapping_offset(1);
  63     assert!(!mq.is_null());
  64
  65     // Pointers to unsized types -- slices
  66     let s: &mut [u8] = &mut [1, 2, 3];
  67     let cs: *const [u8] = s;
  68     assert!(!cs.is_null());
  69
  70     let ms: *mut [u8] = s;
  71     assert!(!ms.is_null());
  72
  73     let cz: *const [u8] = &[];
  74     assert!(!cz.is_null());
  75
  76     let mz: *mut [u8] = &mut [];
  77     assert!(!mz.is_null());
  78
  79     let ncs: *const [u8] = null::<[u8; 3]>();
  80     assert!(ncs.is_null());
  81
  82     let nms: *mut [u8] = null_mut::<[u8; 3]>();
  83     assert!(nms.is_null());
  84
  85     // Pointers to unsized types -- trait objects
  86     let ci: *const dyn ToString = &3;
  87     assert!(!ci.is_null());
  88
  89     let mi: *mut dyn ToString = &mut 3;
  90     assert!(!mi.is_null());
  91
  92     let nci: *const dyn ToString = null::<isize>();
  93     assert!(nci.is_null());
  94
  95     let nmi: *mut dyn ToString = null_mut::<isize>();
  96     assert!(nmi.is_null());
  97 }
  98
  99 #[test]
 100 fn test_as_ref() {
 101     unsafe {
 102         let p: *const isize = null();
 103         assert_eq!(p.as_ref(), None);
 104
 105         let q: *const isize = &2;
 106         assert_eq!(q.as_ref().unwrap(), &2);
 107
 108         let p: *mut isize = null_mut();
 109         assert_eq!(p.as_ref(), None);
 110
 111         let q: *mut isize = &mut 2;
 112         assert_eq!(q.as_ref().unwrap(), &2);
 113
 114         // Lifetime inference
 115         let u = 2isize;
 116         {
 117             let p = &u as *const isize;
 118             assert_eq!(p.as_ref().unwrap(), &2);
 119         }
 120
 121         // Pointers to unsized types -- slices
 122         let s: &mut [u8] = &mut [1, 2, 3];
 123         let cs: *const [u8] = s;
 124         assert_eq!(cs.as_ref(), Some(&*s));
 125
 126         let ms: *mut [u8] = s;
 127         assert_eq!(ms.as_ref(), Some(&*s));
 128
 129         let cz: *const [u8] = &[];
 130         assert_eq!(cz.as_ref(), Some(&[][..]));
 131
 132         let mz: *mut [u8] = &mut [];
 133         assert_eq!(mz.as_ref(), Some(&[][..]));
 134
 135         let ncs: *const [u8] = null::<[u8; 3]>();
 136         assert_eq!(ncs.as_ref(), None);
 137
 138         let nms: *mut [u8] = null_mut::<[u8; 3]>();
 139         assert_eq!(nms.as_ref(), None);
 140
 141         // Pointers to unsized types -- trait objects
 142         let ci: *const dyn ToString = &3;
 143         assert!(ci.as_ref().is_some());
 144
 145         let mi: *mut dyn ToString = &mut 3;
 146         assert!(mi.as_ref().is_some());
 147
 148         let nci: *const dyn ToString = null::<isize>();
 149         assert!(nci.as_ref().is_none());
 150
 151         let nmi: *mut dyn ToString = null_mut::<isize>();
 152         assert!(nmi.as_ref().is_none());
 153     }
 154 }
 155
 156 #[test]
 157 fn test_as_mut() {
 158     unsafe {
 159         let p: *mut isize = null_mut();
 160         assert!(p.as_mut() == None);
 161
 162         let q: *mut isize = &mut 2;
 163         assert!(q.as_mut().unwrap() == &mut 2);
 164
 165         // Lifetime inference
 166         let mut u = 2isize;
 167         {
 168             let p = &mut u as *mut isize;
 169             assert!(p.as_mut().unwrap() == &mut 2);
 170         }
 171
 172         // Pointers to unsized types -- slices
 173         let s: &mut [u8] = &mut [1, 2, 3];
 174         let ms: *mut [u8] = s;
 175         assert_eq!(ms.as_mut(), Some(&mut [1, 2, 3][..]));
 176
 177         let mz: *mut [u8] = &mut [];
 178         assert_eq!(mz.as_mut(), Some(&mut [][..]));
 179
 180         let nms: *mut [u8] = null_mut::<[u8; 3]>();
 181         assert_eq!(nms.as_mut(), None);
 182
 183         // Pointers to unsized types -- trait objects
 184         let mi: *mut dyn ToString = &mut 3;
 185         assert!(mi.as_mut().is_some());
 186
 187         let nmi: *mut dyn ToString = null_mut::<isize>();
 188         assert!(nmi.as_mut().is_none());
 189     }
 190 }
 191
 192 #[test]
 193 fn test_ptr_addition() {
 194     unsafe {
 195         let xs = vec![5; 16];
 196         let mut ptr = xs.as_ptr();
 197         let end = ptr.offset(16);
 198
 199         while ptr < end {
 200             assert_eq!(*ptr, 5);
 201             ptr = ptr.offset(1);
 202         }
 203
 204         let mut xs_mut = xs;
 205         let mut m_ptr = xs_mut.as_mut_ptr();
 206         let m_end = m_ptr.offset(16);
 207
 208         while m_ptr < m_end {
 209             *m_ptr += 5;
 210             m_ptr = m_ptr.offset(1);
 211         }
 212
 213         assert!(xs_mut == vec![10; 16]);
 214     }
 215 }
 216
 217 #[test]
 218 fn test_ptr_subtraction() {
 219     unsafe {
 220         let xs = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 221         let mut idx = 9;
 222         let ptr = xs.as_ptr();
 223
 224         while idx >= 0 {
 225             assert_eq!(*(ptr.offset(idx as isize)), idx as isize);
 226             idx = idx - 1;
 227         }
 228
 229         let mut xs_mut = xs;
 230         let m_start = xs_mut.as_mut_ptr();
 231         let mut m_ptr = m_start.offset(9);
 232
 233         loop {
 234             *m_ptr += *m_ptr;
 235             if m_ptr == m_start {
 236                 break;
 237             }
 238             m_ptr = m_ptr.offset(-1);
 239         }
 240
 241         assert_eq!(xs_mut, [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]);
 242     }
 243 }
 244
 245 #[test]
 246 fn test_set_memory() {
 247     let mut xs = [0u8; 20];
 248     let ptr = xs.as_mut_ptr();
 249     unsafe {
 250         write_bytes(ptr, 5u8, xs.len());
 251     }
 252     assert!(xs == [5u8; 20]);
 253 }
 254
 255 #[test]
 256 fn test_unsized_nonnull() {
 257     let xs: &[i32] = &[1, 2, 3];
 258     let ptr = unsafe { NonNull::new_unchecked(xs as *const [i32] as *mut [i32]) };
 259     let ys = unsafe { ptr.as_ref() };
 260     let zs: &[i32] = &[1, 2, 3];
 261     assert!(ys == zs);
 262 }
 263
 264 #[test]
 265 #[allow(warnings)]
 266 // Have a symbol for the test below. It doesn’t need to be an actual variadic function, match the
 267 // ABI, or even point to an actual executable code, because the function itself is never invoked.
 268 #[no_mangle]
 269 pub fn test_variadic_fnptr() {
 270     use core::hash::{Hash, SipHasher};
 271     extern "C" {
 272         fn test_variadic_fnptr(_: u64, ...) -> f64;
 273     }
 274     let p: unsafe extern "C" fn(u64, ...) -> f64 = test_variadic_fnptr;
 275     let q = p.clone();
 276     assert_eq!(p, q);
 277     assert!(!(p < q));
 278     let mut s = SipHasher::new();
 279     assert_eq!(p.hash(&mut s), q.hash(&mut s));
 280 }
 281
 282 #[test]
 283 fn write_unaligned_drop() {
 284     thread_local! {
 285         static DROPS: RefCell<Vec<u32>> = RefCell::new(Vec::new());
 286     }
 287
 288     struct Dropper(u32);
 289
 290     impl Drop for Dropper {
 291         fn drop(&mut self) {
 292             DROPS.with(|d| d.borrow_mut().push(self.0));
 293         }
 294     }
 295
 296     {
 297         let c = Dropper(0);
 298         let mut t = Dropper(1);
 299         unsafe {
 300             write_unaligned(&mut t, c);
 301         }
 302     }
 303     DROPS.with(|d| assert_eq!(*d.borrow(), [0]));
 304 }
 305
 306 #[test]
 307 fn align_offset_zst() {
 308     // For pointers of stride = 0, the pointer is already aligned or it cannot be aligned at
 309     // all, because no amount of elements will align the pointer.
 310     let mut p = 1;
 311     while p < 1024 {
 312         assert_eq!((p as *const ()).align_offset(p), 0);
 313         if p != 1 {
 314             assert_eq!(((p + 1) as *const ()).align_offset(p), !0);
 315         }
 316         p = (p + 1).next_power_of_two();
 317     }
 318 }
 319
 320 #[test]
 321 fn align_offset_stride1() {
 322     // For pointers of stride = 1, the pointer can always be aligned. The offset is equal to
 323     // number of bytes.
 324     let mut align = 1;
 325     while align < 1024 {
 326         for ptr in 1..2 * align {
 327             let expected = ptr % align;
 328             let offset = if expected == 0 { 0 } else { align - expected };
 329             assert_eq!(
 330                 (ptr as *const u8).align_offset(align),
 331                 offset,
 332                 "ptr = {}, align = {}, size = 1",
 333                 ptr,
 334                 align
 335             );
 336         }
 337         align = (align + 1).next_power_of_two();
 338     }
 339 }
 340
 341 #[test]
 342 fn align_offset_weird_strides() {
 343     #[repr(packed)]
 344     struct A3(u16, u8);
 345     struct A4(u32);
 346     #[repr(packed)]
 347     struct A5(u32, u8);
 348     #[repr(packed)]
 349     struct A6(u32, u16);
 350     #[repr(packed)]
 351     struct A7(u32, u16, u8);
 352     #[repr(packed)]
 353     struct A8(u32, u32);
 354     #[repr(packed)]
 355     struct A9(u32, u32, u8);
 356     #[repr(packed)]
 357     struct A10(u32, u32, u16);
 358
 359     unsafe fn test_weird_stride<T>(ptr: *const T, align: usize) -> bool {
 360         let numptr = ptr as usize;
 361         let mut expected = usize::MAX;
 362         // Naive but definitely correct way to find the *first* aligned element of stride::<T>.
 363         for el in 0..align {
 364             if (numptr + el * ::std::mem::size_of::<T>()) % align == 0 {
 365                 expected = el;
 366                 break;
 367             }
 368         }
 369         let got = ptr.align_offset(align);
 370         if got != expected {
 371             eprintln!(
 372                 "aligning {:p} (with stride of {}) to {}, expected {}, got {}",
 373                 ptr,
 374                 ::std::mem::size_of::<T>(),
 375                 align,
 376                 expected,
 377                 got
 378             );
 379             return true;
 380         }
 381         return false;
 382     }
 383
 384     // For pointers of stride != 1, we verify the algorithm against the naivest possible
 385     // implementation
 386     let mut align = 1;
 387     let mut x = false;
 388     // Miri is too slow
 389     let limit = if cfg!(miri) { 32 } else { 1024 };
 390     while align < limit {
 391         for ptr in 1usize..4 * align {
 392             unsafe {
 393                 x |= test_weird_stride::<A3>(ptr as *const A3, align);
 394                 x |= test_weird_stride::<A4>(ptr as *const A4, align);
 395                 x |= test_weird_stride::<A5>(ptr as *const A5, align);
 396                 x |= test_weird_stride::<A6>(ptr as *const A6, align);
 397                 x |= test_weird_stride::<A7>(ptr as *const A7, align);
 398                 x |= test_weird_stride::<A8>(ptr as *const A8, align);
 399                 x |= test_weird_stride::<A9>(ptr as *const A9, align);
 400                 x |= test_weird_stride::<A10>(ptr as *const A10, align);
 401             }
 402         }
 403         align = (align + 1).next_power_of_two();
 404     }
 405     assert!(!x);
 406 }
 407
 408 #[test]
 409 fn offset_from() {
 410     let mut a = [0; 5];
 411     let ptr1: *mut i32 = &mut a[1];
 412     let ptr2: *mut i32 = &mut a[3];
 413     unsafe {
 414         assert_eq!(ptr2.offset_from(ptr1), 2);
 415         assert_eq!(ptr1.offset_from(ptr2), -2);
 416         assert_eq!(ptr1.offset(2), ptr2);
 417         assert_eq!(ptr2.offset(-2), ptr1);
 418     }
 419 }
 420
 421 #[test]
 422 #[cfg(not(bootstrap))]
 423 fn ptr_metadata() {
 424     struct Unit;
 425     struct Pair<A, B: ?Sized>(A, B);
 426     extern "C" {
 427         type Extern;
 428     }
 429     let () = metadata(&());
 430     let () = metadata(&Unit);
 431     let () = metadata(&4_u32);
 432     let () = metadata(&String::new());
 433     let () = metadata(&Some(4_u32));
 434     let () = metadata(&ptr_metadata);
 435     let () = metadata(&|| {});
 436     let () = metadata(&[4, 7]);
 437     let () = metadata(&(4, String::new()));
 438     let () = metadata(&Pair(4, String::new()));
 439     let () = metadata(0 as *const Extern);
 440     let () = metadata(0 as *const <&u32 as std::ops::Deref>::Target);
 441
 442     assert_eq!(metadata("foo"), 3_usize);
 443     assert_eq!(metadata(&[4, 7][..]), 2_usize);
 444
 445     let dst_tuple: &(bool, [u8]) = &(true, [0x66, 0x6F, 0x6F]);
 446     let dst_struct: &Pair<bool, [u8]> = &Pair(true, [0x66, 0x6F, 0x6F]);
 447     assert_eq!(metadata(dst_tuple), 3_usize);
 448     assert_eq!(metadata(dst_struct), 3_usize);
 449     unsafe {
 450         let dst_tuple: &(bool, str) = std::mem::transmute(dst_tuple);
 451         let dst_struct: &Pair<bool, str> = std::mem::transmute(dst_struct);
 452         assert_eq!(&dst_tuple.1, "foo");
 453         assert_eq!(&dst_struct.1, "foo");
 454         assert_eq!(metadata(dst_tuple), 3_usize);
 455         assert_eq!(metadata(dst_struct), 3_usize);
 456     }
 457
 458     let vtable_1: DynMetadata<dyn Debug> = metadata(&4_u16 as &dyn Debug);
 459     let vtable_2: DynMetadata<dyn Display> = metadata(&4_u16 as &dyn Display);
 460     let vtable_3: DynMetadata<dyn Display> = metadata(&4_u32 as &dyn Display);
 461     let vtable_4: DynMetadata<dyn Display> = metadata(&(true, 7_u32) as &(bool, dyn Display));
 462     let vtable_5: DynMetadata<dyn Display> =
 463         metadata(&Pair(true, 7_u32) as &Pair<bool, dyn Display>);
 464     unsafe {
 465         let address_1: usize = std::mem::transmute(vtable_1);
 466         let address_2: usize = std::mem::transmute(vtable_2);
 467         let address_3: usize = std::mem::transmute(vtable_3);
 468         let address_4: usize = std::mem::transmute(vtable_4);
 469         let address_5: usize = std::mem::transmute(vtable_5);
 470         // Different trait => different vtable pointer
 471         assert_ne!(address_1, address_2);
 472         // Different erased type => different vtable pointer
 473         assert_ne!(address_2, address_3);
 474         // Same erased type and same trait => same vtable pointer
 475         assert_eq!(address_3, address_4);
 476         assert_eq!(address_3, address_5);
 477     }
 478 }
 479
 480 #[test]
 481 #[cfg(not(bootstrap))]
 482 fn ptr_metadata_bounds() {
 483     fn metadata_eq_method_address<T: ?Sized>() -> usize {
 484         // The `Metadata` associated type has an `Ord` bound, so this is valid:
 485         <<T as Pointee>::Metadata as PartialEq>::eq as usize
 486     }
 487     // "Synthetic" trait impls generated by the compiler like those of `Pointee`
 488     // are not checked for bounds of associated type.
 489     // So with a buggy libcore we could have both:
 490     // * `<dyn Display as Pointee>::Metadata == DynMetadata`
 491     // * `DynMetadata: !PartialEq`
 492     // … and cause an ICE here:
 493     metadata_eq_method_address::<dyn Display>();
 494
 495     // For this reason, let’s check here that bounds are satisfied:
 496
 497     let _ = static_assert_expected_bounds_for_metadata::<()>;
 498     let _ = static_assert_expected_bounds_for_metadata::<usize>;
 499     let _ = static_assert_expected_bounds_for_metadata::<DynMetadata<dyn Display>>;
 500     fn _static_assert_associated_type<T: ?Sized>() {
 501         let _ = static_assert_expected_bounds_for_metadata::<<T as Pointee>::Metadata>;
 502     }
 503
 504     fn static_assert_expected_bounds_for_metadata<Meta>()
 505     where
 506         // Keep this in sync with the associated type in `library/core/src/ptr/metadata.rs`
 507         Meta: Copy + Send + Sync + Ord + std::hash::Hash + Unpin,
 508     {
 509     }
 510 }
 511
 512 #[test]
 513 #[cfg(not(bootstrap))]
 514 fn dyn_metadata() {
 515     #[derive(Debug)]
 516     #[repr(align(32))]
 517     struct Something([u8; 47]);
 518
 519     let value = Something([0; 47]);
 520     let trait_object: &dyn Debug = &value;
 521     let meta = metadata(trait_object);
 522
 523     assert_eq!(meta.size_of(), 64);
 524     assert_eq!(meta.size_of(), std::mem::size_of::<Something>());
 525     assert_eq!(meta.align_of(), 32);
 526     assert_eq!(meta.align_of(), std::mem::align_of::<Something>());
 527     assert_eq!(meta.layout(), std::alloc::Layout::new::<Something>());
 528
 529     assert!(format!("{:?}", meta).starts_with("DynMetadata(0x"));
 530 }
 531
 532 #[test]
 533 #[cfg(not(bootstrap))]
 534 fn from_raw_parts() {
 535     let mut value = 5_u32;
 536     let address = &mut value as *mut _ as *mut ();
 537     let trait_object: &dyn Display = &mut value;
 538     let vtable = metadata(trait_object);
 539     let trait_object = NonNull::from(trait_object);
 540
 541     assert_eq!(ptr::from_raw_parts(address, vtable), trait_object.as_ptr());
 542     assert_eq!(ptr::from_raw_parts_mut(address, vtable), trait_object.as_ptr());
 543     assert_eq!(NonNull::from_raw_parts(NonNull::new(address).unwrap(), vtable), trait_object);
 544
 545     let mut array = [5_u32, 5, 5, 5, 5];
 546     let address = &mut array as *mut _ as *mut ();
 547     let array_ptr = NonNull::from(&mut array);
 548     let slice_ptr = NonNull::from(&mut array[..]);
 549
 550     assert_eq!(ptr::from_raw_parts(address, ()), array_ptr.as_ptr());
 551     assert_eq!(ptr::from_raw_parts_mut(address, ()), array_ptr.as_ptr());
 552     assert_eq!(NonNull::from_raw_parts(NonNull::new(address).unwrap(), ()), array_ptr);
 553
 554     assert_eq!(ptr::from_raw_parts(address, 5), slice_ptr.as_ptr());
 555     assert_eq!(ptr::from_raw_parts_mut(address, 5), slice_ptr.as_ptr());
 556     assert_eq!(NonNull::from_raw_parts(NonNull::new(address).unwrap(), 5), slice_ptr);
 557 }