library/core/tests/ptr.rs

   1 use core::cell::RefCell;
   2 use core::mem::{self, MaybeUninit};
   3 use core::num::NonZeroUsize;
   4 use core::ptr;
   5 use core::ptr::*;
   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         #[repr(C)]
  23         struct Pair {
  24             fst: isize,
  25             snd: isize,
  26         }
  27         let mut p = Pair { fst: 10, snd: 20 };
  28         let pptr: *mut Pair = &mut p;
  29         let iptr: *mut isize = pptr as *mut isize;
  30         assert_eq!(*iptr, 10);
  31         *iptr = 30;
  32         assert_eq!(*iptr, 30);
  33         assert_eq!(p.fst, 30);
  34
  35         *pptr = Pair { fst: 50, snd: 60 };
  36         assert_eq!(*iptr, 50);
  37         assert_eq!(p.fst, 50);
  38         assert_eq!(p.snd, 60);
  39
  40         let v0 = vec![32000u16, 32001u16, 32002u16];
  41         let mut v1 = vec![0u16, 0u16, 0u16];
  42
  43         copy(v0.as_ptr().offset(1), v1.as_mut_ptr().offset(1), 1);
  44         assert!((v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16));
  45         copy(v0.as_ptr().offset(2), v1.as_mut_ptr(), 1);
  46         assert!((v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 0u16));
  47         copy(v0.as_ptr(), v1.as_mut_ptr().offset(2), 1);
  48         assert!((v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 32000u16));
  49     }
  50 }
  51
  52 #[test]
  53 fn test_is_null() {
  54     let p: *const isize = null();
  55     assert!(p.is_null());
  56
  57     let q = p.wrapping_offset(1);
  58     assert!(!q.is_null());
  59
  60     let mp: *mut isize = null_mut();
  61     assert!(mp.is_null());
  62
  63     let mq = mp.wrapping_offset(1);
  64     assert!(!mq.is_null());
  65
  66     // Pointers to unsized types -- slices
  67     let s: &mut [u8] = &mut [1, 2, 3];
  68     let cs: *const [u8] = s;
  69     assert!(!cs.is_null());
  70
  71     let ms: *mut [u8] = s;
  72     assert!(!ms.is_null());
  73
  74     let cz: *const [u8] = &[];
  75     assert!(!cz.is_null());
  76
  77     let mz: *mut [u8] = &mut [];
  78     assert!(!mz.is_null());
  79
  80     let ncs: *const [u8] = null::<[u8; 3]>();
  81     assert!(ncs.is_null());
  82
  83     let nms: *mut [u8] = null_mut::<[u8; 3]>();
  84     assert!(nms.is_null());
  85
  86     // Pointers to unsized types -- trait objects
  87     let ci: *const dyn ToString = &3;
  88     assert!(!ci.is_null());
  89
  90     let mi: *mut dyn ToString = &mut 3;
  91     assert!(!mi.is_null());
  92
  93     let nci: *const dyn ToString = null::<isize>();
  94     assert!(nci.is_null());
  95
  96     let nmi: *mut dyn ToString = null_mut::<isize>();
  97     assert!(nmi.is_null());
  98
  99     #[cfg(not(bootstrap))]
 100     {
 101         extern "C" {
 102             type Extern;
 103         }
 104         let ec: *const Extern = null::<Extern>();
 105         assert!(ec.is_null());
 106
 107         let em: *mut Extern = null_mut::<Extern>();
 108         assert!(em.is_null());
 109     }
 110 }
 111
 112 #[test]
 113 fn test_as_ref() {
 114     unsafe {
 115         let p: *const isize = null();
 116         assert_eq!(p.as_ref(), None);
 117
 118         let q: *const isize = &2;
 119         assert_eq!(q.as_ref().unwrap(), &2);
 120
 121         let p: *mut isize = null_mut();
 122         assert_eq!(p.as_ref(), None);
 123
 124         let q: *mut isize = &mut 2;
 125         assert_eq!(q.as_ref().unwrap(), &2);
 126
 127         // Lifetime inference
 128         let u = 2isize;
 129         {
 130             let p = &u as *const isize;
 131             assert_eq!(p.as_ref().unwrap(), &2);
 132         }
 133
 134         // Pointers to unsized types -- slices
 135         let s: &mut [u8] = &mut [1, 2, 3];
 136         let cs: *const [u8] = s;
 137         assert_eq!(cs.as_ref(), Some(&*s));
 138
 139         let ms: *mut [u8] = s;
 140         assert_eq!(ms.as_ref(), Some(&*s));
 141
 142         let cz: *const [u8] = &[];
 143         assert_eq!(cz.as_ref(), Some(&[][..]));
 144
 145         let mz: *mut [u8] = &mut [];
 146         assert_eq!(mz.as_ref(), Some(&[][..]));
 147
 148         let ncs: *const [u8] = null::<[u8; 3]>();
 149         assert_eq!(ncs.as_ref(), None);
 150
 151         let nms: *mut [u8] = null_mut::<[u8; 3]>();
 152         assert_eq!(nms.as_ref(), None);
 153
 154         // Pointers to unsized types -- trait objects
 155         let ci: *const dyn ToString = &3;
 156         assert!(ci.as_ref().is_some());
 157
 158         let mi: *mut dyn ToString = &mut 3;
 159         assert!(mi.as_ref().is_some());
 160
 161         let nci: *const dyn ToString = null::<isize>();
 162         assert!(nci.as_ref().is_none());
 163
 164         let nmi: *mut dyn ToString = null_mut::<isize>();
 165         assert!(nmi.as_ref().is_none());
 166     }
 167 }
 168
 169 #[test]
 170 fn test_as_mut() {
 171     unsafe {
 172         let p: *mut isize = null_mut();
 173         assert!(p.as_mut() == None);
 174
 175         let q: *mut isize = &mut 2;
 176         assert!(q.as_mut().unwrap() == &mut 2);
 177
 178         // Lifetime inference
 179         let mut u = 2isize;
 180         {
 181             let p = &mut u as *mut isize;
 182             assert!(p.as_mut().unwrap() == &mut 2);
 183         }
 184
 185         // Pointers to unsized types -- slices
 186         let s: &mut [u8] = &mut [1, 2, 3];
 187         let ms: *mut [u8] = s;
 188         assert_eq!(ms.as_mut(), Some(&mut [1, 2, 3][..]));
 189
 190         let mz: *mut [u8] = &mut [];
 191         assert_eq!(mz.as_mut(), Some(&mut [][..]));
 192
 193         let nms: *mut [u8] = null_mut::<[u8; 3]>();
 194         assert_eq!(nms.as_mut(), None);
 195
 196         // Pointers to unsized types -- trait objects
 197         let mi: *mut dyn ToString = &mut 3;
 198         assert!(mi.as_mut().is_some());
 199
 200         let nmi: *mut dyn ToString = null_mut::<isize>();
 201         assert!(nmi.as_mut().is_none());
 202     }
 203 }
 204
 205 #[test]
 206 fn test_ptr_addition() {
 207     unsafe {
 208         let xs = vec![5; 16];
 209         let mut ptr = xs.as_ptr();
 210         let end = ptr.offset(16);
 211
 212         while ptr < end {
 213             assert_eq!(*ptr, 5);
 214             ptr = ptr.offset(1);
 215         }
 216
 217         let mut xs_mut = xs;
 218         let mut m_ptr = xs_mut.as_mut_ptr();
 219         let m_end = m_ptr.offset(16);
 220
 221         while m_ptr < m_end {
 222             *m_ptr += 5;
 223             m_ptr = m_ptr.offset(1);
 224         }
 225
 226         assert!(xs_mut == vec![10; 16]);
 227     }
 228 }
 229
 230 #[test]
 231 fn test_ptr_subtraction() {
 232     unsafe {
 233         let xs = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 234         let mut idx = 9;
 235         let ptr = xs.as_ptr();
 236
 237         while idx >= 0 {
 238             assert_eq!(*(ptr.offset(idx as isize)), idx as isize);
 239             idx = idx - 1;
 240         }
 241
 242         let mut xs_mut = xs;
 243         let m_start = xs_mut.as_mut_ptr();
 244         let mut m_ptr = m_start.offset(9);
 245
 246         loop {
 247             *m_ptr += *m_ptr;
 248             if m_ptr == m_start {
 249                 break;
 250             }
 251             m_ptr = m_ptr.offset(-1);
 252         }
 253
 254         assert_eq!(xs_mut, [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]);
 255     }
 256 }
 257
 258 #[test]
 259 fn test_set_memory() {
 260     let mut xs = [0u8; 20];
 261     let ptr = xs.as_mut_ptr();
 262     unsafe {
 263         write_bytes(ptr, 5u8, xs.len());
 264     }
 265     assert!(xs == [5u8; 20]);
 266 }
 267
 268 #[test]
 269 fn test_set_memory_const() {
 270     const XS: [u8; 20] = {
 271         let mut xs = [0u8; 20];
 272         let ptr = xs.as_mut_ptr();
 273         unsafe {
 274             ptr.write_bytes(5u8, xs.len());
 275         }
 276         xs
 277     };
 278
 279     assert!(XS == [5u8; 20]);
 280 }
 281
 282 #[test]
 283 fn test_unsized_nonnull() {
 284     let xs: &[i32] = &[1, 2, 3];
 285     let ptr = unsafe { NonNull::new_unchecked(xs as *const [i32] as *mut [i32]) };
 286     let ys = unsafe { ptr.as_ref() };
 287     let zs: &[i32] = &[1, 2, 3];
 288     assert!(ys == zs);
 289 }
 290
 291 #[test]
 292 fn test_const_nonnull_new() {
 293     const {
 294         assert!(NonNull::new(core::ptr::null_mut::<()>()).is_none());
 295
 296         let value = &mut 0u32;
 297         let mut ptr = NonNull::new(value).unwrap();
 298         unsafe { *ptr.as_mut() = 42 };
 299
 300         let reference = unsafe { &*ptr.as_ref() };
 301         assert!(*reference == *value);
 302         assert!(*reference == 42);
 303     };
 304 }
 305
 306 #[test]
 307 #[cfg(unix)] // printf may not be available on other platforms
 308 #[allow(deprecated)] // For SipHasher
 309 pub fn test_variadic_fnptr() {
 310     use core::ffi;
 311     use core::hash::{Hash, SipHasher};
 312     extern "C" {
 313         // This needs to use the correct function signature even though it isn't called as some
 314         // codegen backends make it UB to declare a function with multiple conflicting signatures
 315         // (like LLVM) while others straight up return an error (like Cranelift).
 316         fn printf(_: *const ffi::c_char, ...) -> ffi::c_int;
 317     }
 318     let p: unsafe extern "C" fn(*const ffi::c_char, ...) -> ffi::c_int = printf;
 319     let q = p.clone();
 320     assert_eq!(p, q);
 321     assert!(!(p < q));
 322     let mut s = SipHasher::new();
 323     assert_eq!(p.hash(&mut s), q.hash(&mut s));
 324 }
 325
 326 #[test]
 327 fn write_unaligned_drop() {
 328     thread_local! {
 329         static DROPS: RefCell<Vec<u32>> = RefCell::new(Vec::new());
 330     }
 331
 332     struct Dropper(u32);
 333
 334     impl Drop for Dropper {
 335         fn drop(&mut self) {
 336             DROPS.with(|d| d.borrow_mut().push(self.0));
 337         }
 338     }
 339
 340     {
 341         let c = Dropper(0);
 342         let mut t = Dropper(1);
 343         unsafe {
 344             write_unaligned(&mut t, c);
 345         }
 346     }
 347     DROPS.with(|d| assert_eq!(*d.borrow(), [0]));
 348 }
 349
 350 #[test]
 351 fn align_offset_zst() {
 352     // For pointers of stride = 0, the pointer is already aligned or it cannot be aligned at
 353     // all, because no amount of elements will align the pointer.
 354     let mut p = 1;
 355     while p < 1024 {
 356         assert_eq!((p as *const ()).align_offset(p), 0);
 357         if p != 1 {
 358             assert_eq!(((p + 1) as *const ()).align_offset(p), !0);
 359         }
 360         p = (p + 1).next_power_of_two();
 361     }
 362 }
 363
 364 #[test]
 365 fn align_offset_stride1() {
 366     // For pointers of stride = 1, the pointer can always be aligned. The offset is equal to
 367     // number of bytes.
 368     let mut align = 1;
 369     while align < 1024 {
 370         for ptr in 1..2 * align {
 371             let expected = ptr % align;
 372             let offset = if expected == 0 { 0 } else { align - expected };
 373             assert_eq!(
 374                 (ptr as *const u8).align_offset(align),
 375                 offset,
 376                 "ptr = {}, align = {}, size = 1",
 377                 ptr,
 378                 align
 379             );
 380         }
 381         align = (align + 1).next_power_of_two();
 382     }
 383 }
 384
 385 #[test]
 386 fn align_offset_weird_strides() {
 387     #[repr(packed)]
 388     struct A3(u16, u8);
 389     struct A4(u32);
 390     #[repr(packed)]
 391     struct A5(u32, u8);
 392     #[repr(packed)]
 393     struct A6(u32, u16);
 394     #[repr(packed)]
 395     struct A7(u32, u16, u8);
 396     #[repr(packed)]
 397     struct A8(u32, u32);
 398     #[repr(packed)]
 399     struct A9(u32, u32, u8);
 400     #[repr(packed)]
 401     struct A10(u32, u32, u16);
 402
 403     unsafe fn test_weird_stride<T>(ptr: *const T, align: usize) -> bool {
 404         let numptr = ptr as usize;
 405         let mut expected = usize::MAX;
 406         // Naive but definitely correct way to find the *first* aligned element of stride::<T>.
 407         for el in 0..align {
 408             if (numptr + el * ::std::mem::size_of::<T>()) % align == 0 {
 409                 expected = el;
 410                 break;
 411             }
 412         }
 413         let got = ptr.align_offset(align);
 414         if got != expected {
 415             eprintln!(
 416                 "aligning {:p} (with stride of {}) to {}, expected {}, got {}",
 417                 ptr,
 418                 ::std::mem::size_of::<T>(),
 419                 align,
 420                 expected,
 421                 got
 422             );
 423             return true;
 424         }
 425         return false;
 426     }
 427
 428     // For pointers of stride != 1, we verify the algorithm against the naivest possible
 429     // implementation
 430     let mut align = 1;
 431     let mut x = false;
 432     // Miri is too slow
 433     let limit = if cfg!(miri) { 32 } else { 1024 };
 434     while align < limit {
 435         for ptr in 1usize..4 * align {
 436             unsafe {
 437                 x |= test_weird_stride::<A3>(ptr as *const A3, align);
 438                 x |= test_weird_stride::<A4>(ptr as *const A4, align);
 439                 x |= test_weird_stride::<A5>(ptr as *const A5, align);
 440                 x |= test_weird_stride::<A6>(ptr as *const A6, align);
 441                 x |= test_weird_stride::<A7>(ptr as *const A7, align);
 442                 x |= test_weird_stride::<A8>(ptr as *const A8, align);
 443                 x |= test_weird_stride::<A9>(ptr as *const A9, align);
 444                 x |= test_weird_stride::<A10>(ptr as *const A10, align);
 445             }
 446         }
 447         align = (align + 1).next_power_of_two();
 448     }
 449     assert!(!x);
 450 }
 451
 452 #[test]
 453 fn offset_from() {
 454     let mut a = [0; 5];
 455     let ptr1: *mut i32 = &mut a[1];
 456     let ptr2: *mut i32 = &mut a[3];
 457     unsafe {
 458         assert_eq!(ptr2.offset_from(ptr1), 2);
 459         assert_eq!(ptr1.offset_from(ptr2), -2);
 460         assert_eq!(ptr1.offset(2), ptr2);
 461         assert_eq!(ptr2.offset(-2), ptr1);
 462     }
 463 }
 464
 465 #[test]
 466 fn ptr_metadata() {
 467     struct Unit;
 468     struct Pair<A, B: ?Sized>(A, B);
 469     extern "C" {
 470         type Extern;
 471     }
 472     let () = metadata(&());
 473     let () = metadata(&Unit);
 474     let () = metadata(&4_u32);
 475     let () = metadata(&String::new());
 476     let () = metadata(&Some(4_u32));
 477     let () = metadata(&ptr_metadata);
 478     let () = metadata(&|| {});
 479     let () = metadata(&[4, 7]);
 480     let () = metadata(&(4, String::new()));
 481     let () = metadata(&Pair(4, String::new()));
 482     let () = metadata(0 as *const Extern);
 483     let () = metadata(0 as *const <&u32 as std::ops::Deref>::Target);
 484
 485     assert_eq!(metadata("foo"), 3_usize);
 486     assert_eq!(metadata(&[4, 7][..]), 2_usize);
 487
 488     let dst_tuple: &(bool, [u8]) = &(true, [0x66, 0x6F, 0x6F]);
 489     let dst_struct: &Pair<bool, [u8]> = &Pair(true, [0x66, 0x6F, 0x6F]);
 490     assert_eq!(metadata(dst_tuple), 3_usize);
 491     assert_eq!(metadata(dst_struct), 3_usize);
 492     unsafe {
 493         let dst_tuple: &(bool, str) = std::mem::transmute(dst_tuple);
 494         let dst_struct: &Pair<bool, str> = std::mem::transmute(dst_struct);
 495         assert_eq!(&dst_tuple.1, "foo");
 496         assert_eq!(&dst_struct.1, "foo");
 497         assert_eq!(metadata(dst_tuple), 3_usize);
 498         assert_eq!(metadata(dst_struct), 3_usize);
 499     }
 500
 501     let vtable_1: DynMetadata<dyn Debug> = metadata(&4_u16 as &dyn Debug);
 502     let vtable_2: DynMetadata<dyn Display> = metadata(&4_u16 as &dyn Display);
 503     let vtable_3: DynMetadata<dyn Display> = metadata(&4_u32 as &dyn Display);
 504     let vtable_4: DynMetadata<dyn Display> = metadata(&(true, 7_u32) as &(bool, dyn Display));
 505     let vtable_5: DynMetadata<dyn Display> =
 506         metadata(&Pair(true, 7_u32) as &Pair<bool, dyn Display>);
 507     unsafe {
 508         let address_1: *const () = std::mem::transmute(vtable_1);
 509         let address_2: *const () = std::mem::transmute(vtable_2);
 510         let address_3: *const () = std::mem::transmute(vtable_3);
 511         let address_4: *const () = std::mem::transmute(vtable_4);
 512         let address_5: *const () = std::mem::transmute(vtable_5);
 513         // Different trait => different vtable pointer
 514         assert_ne!(address_1, address_2);
 515         // Different erased type => different vtable pointer
 516         assert_ne!(address_2, address_3);
 517         // Same erased type and same trait => same vtable pointer
 518         assert_eq!(address_3, address_4);
 519         assert_eq!(address_3, address_5);
 520     }
 521 }
 522
 523 #[test]
 524 fn ptr_metadata_bounds() {
 525     fn metadata_eq_method_address<T: ?Sized>() -> usize {
 526         // The `Metadata` associated type has an `Ord` bound, so this is valid:
 527         <<T as Pointee>::Metadata as PartialEq>::eq as usize
 528     }
 529     // "Synthetic" trait impls generated by the compiler like those of `Pointee`
 530     // are not checked for bounds of associated type.
 531     // So with a buggy libcore we could have both:
 532     // * `<dyn Display as Pointee>::Metadata == DynMetadata`
 533     // * `DynMetadata: !PartialEq`
 534     // … and cause an ICE here:
 535     metadata_eq_method_address::<dyn Display>();
 536
 537     // For this reason, let’s check here that bounds are satisfied:
 538
 539     let _ = static_assert_expected_bounds_for_metadata::<()>;
 540     let _ = static_assert_expected_bounds_for_metadata::<usize>;
 541     let _ = static_assert_expected_bounds_for_metadata::<DynMetadata<dyn Display>>;
 542     fn _static_assert_associated_type<T: ?Sized>() {
 543         let _ = static_assert_expected_bounds_for_metadata::<<T as Pointee>::Metadata>;
 544     }
 545
 546     fn static_assert_expected_bounds_for_metadata<Meta>()
 547     where
 548         // Keep this in sync with the associated type in `library/core/src/ptr/metadata.rs`
 549         Meta: Copy + Send + Sync + Ord + std::hash::Hash + Unpin,
 550     {
 551     }
 552 }
 553
 554 #[test]
 555 fn dyn_metadata() {
 556     #[derive(Debug)]
 557     #[repr(align(32))]
 558     struct Something([u8; 47]);
 559
 560     let value = Something([0; 47]);
 561     let trait_object: &dyn Debug = &value;
 562     let meta = metadata(trait_object);
 563
 564     assert_eq!(meta.size_of(), 64);
 565     assert_eq!(meta.size_of(), std::mem::size_of::<Something>());
 566     assert_eq!(meta.align_of(), 32);
 567     assert_eq!(meta.align_of(), std::mem::align_of::<Something>());
 568     assert_eq!(meta.layout(), std::alloc::Layout::new::<Something>());
 569
 570     assert!(format!("{meta:?}").starts_with("DynMetadata(0x"));
 571 }
 572
 573 #[test]
 574 fn from_raw_parts() {
 575     let mut value = 5_u32;
 576     let address = &mut value as *mut _ as *mut ();
 577     let trait_object: &dyn Display = &mut value;
 578     let vtable = metadata(trait_object);
 579     let trait_object = NonNull::from(trait_object);
 580
 581     assert_eq!(ptr::from_raw_parts(address, vtable), trait_object.as_ptr());
 582     assert_eq!(ptr::from_raw_parts_mut(address, vtable), trait_object.as_ptr());
 583     assert_eq!(NonNull::from_raw_parts(NonNull::new(address).unwrap(), vtable), trait_object);
 584
 585     let mut array = [5_u32, 5, 5, 5, 5];
 586     let address = &mut array as *mut _ as *mut ();
 587     let array_ptr = NonNull::from(&mut array);
 588     let slice_ptr = NonNull::from(&mut array[..]);
 589
 590     assert_eq!(ptr::from_raw_parts(address, ()), array_ptr.as_ptr());
 591     assert_eq!(ptr::from_raw_parts_mut(address, ()), array_ptr.as_ptr());
 592     assert_eq!(NonNull::from_raw_parts(NonNull::new(address).unwrap(), ()), array_ptr);
 593
 594     assert_eq!(ptr::from_raw_parts(address, 5), slice_ptr.as_ptr());
 595     assert_eq!(ptr::from_raw_parts_mut(address, 5), slice_ptr.as_ptr());
 596     assert_eq!(NonNull::from_raw_parts(NonNull::new(address).unwrap(), 5), slice_ptr);
 597 }
 598
 599 #[test]
 600 fn thin_box() {
 601     let foo = ThinBox::<dyn Display>::new(4);
 602     assert_eq!(foo.to_string(), "4");
 603     drop(foo);
 604     let bar = ThinBox::<dyn Display>::new(7);
 605     assert_eq!(bar.to_string(), "7");
 606
 607     // A slightly more interesting library that could be built on top of metadata APIs.
 608     //
 609     // * It could be generalized to any `T: ?Sized` (not just trait object)
 610     //   if `{size,align}_of_for_meta<T: ?Sized>(T::Metadata)` are added.
 611     // * Constructing a `ThinBox` without consuming and deallocating a `Box`
 612     //   requires either the unstable `Unsize` marker trait,
 613     //   or the unstable `unsized_locals` language feature,
 614     //   or taking `&dyn T` and restricting to `T: Copy`.
 615
 616     use std::alloc::*;
 617     use std::marker::PhantomData;
 618
 619     struct ThinBox<T>
 620     where
 621         T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
 622     {
 623         ptr: NonNull<DynMetadata<T>>,
 624         phantom: PhantomData<T>,
 625     }
 626
 627     impl<T> ThinBox<T>
 628     where
 629         T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
 630     {
 631         pub fn new<Value: std::marker::Unsize<T>>(value: Value) -> Self {
 632             let unsized_: &T = &value;
 633             let meta = metadata(unsized_);
 634             let meta_layout = Layout::for_value(&meta);
 635             let value_layout = Layout::for_value(&value);
 636             let (layout, offset) = meta_layout.extend(value_layout).unwrap();
 637             // `DynMetadata` is pointer-sized:
 638             assert!(layout.size() > 0);
 639             // If `ThinBox<T>` is generalized to any `T: ?Sized`,
 640             // handle ZSTs with a dangling pointer without going through `alloc()`,
 641             // like `Box<T>` does.
 642             unsafe {
 643                 let ptr = NonNull::new(alloc(layout))
 644                     .unwrap_or_else(|| handle_alloc_error(layout))
 645                     .cast::<DynMetadata<T>>();
 646                 ptr.as_ptr().write(meta);
 647                 ptr.cast::<u8>().as_ptr().add(offset).cast::<Value>().write(value);
 648                 Self { ptr, phantom: PhantomData }
 649             }
 650         }
 651
 652         fn meta(&self) -> DynMetadata<T> {
 653             unsafe { *self.ptr.as_ref() }
 654         }
 655
 656         fn layout(&self) -> (Layout, usize) {
 657             let meta = self.meta();
 658             Layout::for_value(&meta).extend(meta.layout()).unwrap()
 659         }
 660
 661         fn value_ptr(&self) -> *const T {
 662             let (_, offset) = self.layout();
 663             let data_ptr = unsafe { self.ptr.cast::<u8>().as_ptr().add(offset) };
 664             ptr::from_raw_parts(data_ptr.cast(), self.meta())
 665         }
 666
 667         fn value_mut_ptr(&mut self) -> *mut T {
 668             let (_, offset) = self.layout();
 669             // FIXME: can this line be shared with the same in `value_ptr()`
 670             // without upsetting Stacked Borrows?
 671             let data_ptr = unsafe { self.ptr.cast::<u8>().as_ptr().add(offset) };
 672             from_raw_parts_mut(data_ptr.cast(), self.meta())
 673         }
 674     }
 675
 676     impl<T> std::ops::Deref for ThinBox<T>
 677     where
 678         T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
 679     {
 680         type Target = T;
 681
 682         fn deref(&self) -> &T {
 683             unsafe { &*self.value_ptr() }
 684         }
 685     }
 686
 687     impl<T> std::ops::DerefMut for ThinBox<T>
 688     where
 689         T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
 690     {
 691         fn deref_mut(&mut self) -> &mut T {
 692             unsafe { &mut *self.value_mut_ptr() }
 693         }
 694     }
 695
 696     impl<T> std::ops::Drop for ThinBox<T>
 697     where
 698         T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
 699     {
 700         fn drop(&mut self) {
 701             let (layout, _) = self.layout();
 702             unsafe {
 703                 drop_in_place::<T>(&mut **self);
 704                 dealloc(self.ptr.cast().as_ptr(), layout);
 705             }
 706         }
 707     }
 708 }
 709
 710 #[test]
 711 fn nonnull_tagged_pointer_with_provenance() {
 712     let raw_pointer = Box::into_raw(Box::new(10));
 713
 714     let mut p = TaggedPointer::new(raw_pointer).unwrap();
 715     assert_eq!(p.tag(), 0);
 716
 717     p.set_tag(1);
 718     assert_eq!(p.tag(), 1);
 719     assert_eq!(unsafe { *p.pointer().as_ptr() }, 10);
 720
 721     p.set_tag(3);
 722     assert_eq!(p.tag(), 3);
 723     assert_eq!(unsafe { *p.pointer().as_ptr() }, 10);
 724
 725     unsafe { Box::from_raw(p.pointer().as_ptr()) };
 726
 727     /// A non-null pointer type which carries several bits of metadata and maintains provenance.
 728     #[repr(transparent)]
 729     pub struct TaggedPointer<T>(NonNull<T>);
 730
 731     impl<T> Clone for TaggedPointer<T> {
 732         fn clone(&self) -> Self {
 733             Self(self.0)
 734         }
 735     }
 736
 737     impl<T> Copy for TaggedPointer<T> {}
 738
 739     impl<T> TaggedPointer<T> {
 740         /// The ABI-required minimum alignment of the `P` type.
 741         pub const ALIGNMENT: usize = core::mem::align_of::<T>();
 742         /// A mask for data-carrying bits of the address.
 743         pub const DATA_MASK: usize = !Self::ADDRESS_MASK;
 744         /// Number of available bits of storage in the address.
 745         pub const NUM_BITS: u32 = Self::ALIGNMENT.trailing_zeros();
 746         /// A mask for the non-data-carrying bits of the address.
 747         pub const ADDRESS_MASK: usize = usize::MAX << Self::NUM_BITS;
 748
 749         /// Create a new tagged pointer from a possibly null pointer.
 750         pub fn new(pointer: *mut T) -> Option<TaggedPointer<T>> {
 751             Some(TaggedPointer(NonNull::new(pointer)?))
 752         }
 753
 754         /// Consume this tagged pointer and produce a raw mutable pointer to the
 755         /// memory location.
 756         pub fn pointer(self) -> NonNull<T> {
 757             // SAFETY: The `addr` guaranteed to have bits set in the Self::ADDRESS_MASK, so the result will be non-null.
 758             self.0.map_addr(|addr| unsafe {
 759                 NonZeroUsize::new_unchecked(addr.get() & Self::ADDRESS_MASK)
 760             })
 761         }
 762
 763         /// Consume this tagged pointer and produce the data it carries.
 764         pub fn tag(&self) -> usize {
 765             self.0.addr().get() & Self::DATA_MASK
 766         }
 767
 768         /// Update the data this tagged pointer carries to a new value.
 769         pub fn set_tag(&mut self, data: usize) {
 770             assert_eq!(
 771                 data & Self::ADDRESS_MASK,
 772                 0,
 773                 "cannot set more data beyond the lowest NUM_BITS"
 774             );
 775             let data = data & Self::DATA_MASK;
 776
 777             // SAFETY: This value will always be non-zero because the upper bits (from
 778             // ADDRESS_MASK) will always be non-zero. This a property of the type and its
 779             // construction.
 780             self.0 = self.0.map_addr(|addr| unsafe {
 781                 NonZeroUsize::new_unchecked((addr.get() & Self::ADDRESS_MASK) | data)
 782             })
 783         }
 784     }
 785 }
 786
 787 #[test]
 788 fn test_const_copy() {
 789     const {
 790         let ptr1 = &1;
 791         let mut ptr2 = &666;
 792
 793         // Copy ptr1 to ptr2, bytewise.
 794         unsafe {
 795             ptr::copy(
 796                 &ptr1 as *const _ as *const MaybeUninit<u8>,
 797                 &mut ptr2 as *mut _ as *mut MaybeUninit<u8>,
 798                 mem::size_of::<&i32>(),
 799             );
 800         }
 801
 802         // Make sure they still work.
 803         assert!(*ptr1 == 1);
 804         assert!(*ptr2 == 1);
 805     };
 806
 807     const {
 808         let ptr1 = &1;
 809         let mut ptr2 = &666;
 810
 811         // Copy ptr1 to ptr2, bytewise.
 812         unsafe {
 813             ptr::copy_nonoverlapping(
 814                 &ptr1 as *const _ as *const MaybeUninit<u8>,
 815                 &mut ptr2 as *mut _ as *mut MaybeUninit<u8>,
 816                 mem::size_of::<&i32>(),
 817             );
 818         }
 819
 820         // Make sure they still work.
 821         assert!(*ptr1 == 1);
 822         assert!(*ptr2 == 1);
 823     };
 824 }