1 use core::cell::RefCell;
6 use std::fmt::{Debug, Display};
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);
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);
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);
31 assert_eq!(*iptr, 30);
32 assert_eq!(p.fst, 30);
34 *pptr = Pair { fst: 50, snd: 60 };
35 assert_eq!(*iptr, 50);
36 assert_eq!(p.fst, 50);
37 assert_eq!(p.snd, 60);
39 let v0 = vec![32000u16, 32001u16, 32002u16];
40 let mut v1 = vec![0u16, 0u16, 0u16];
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));
53 let p: *const isize = null();
56 let q = p.wrapping_offset(1);
57 assert!(!q.is_null());
59 let mp: *mut isize = null_mut();
60 assert!(mp.is_null());
62 let mq = mp.wrapping_offset(1);
63 assert!(!mq.is_null());
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());
70 let ms: *mut [u8] = s;
71 assert!(!ms.is_null());
73 let cz: *const [u8] = &[];
74 assert!(!cz.is_null());
76 let mz: *mut [u8] = &mut [];
77 assert!(!mz.is_null());
79 let ncs: *const [u8] = null::<[u8; 3]>();
80 assert!(ncs.is_null());
82 let nms: *mut [u8] = null_mut::<[u8; 3]>();
83 assert!(nms.is_null());
85 // Pointers to unsized types -- trait objects
86 let ci: *const dyn ToString = &3;
87 assert!(!ci.is_null());
89 let mi: *mut dyn ToString = &mut 3;
90 assert!(!mi.is_null());
92 let nci: *const dyn ToString = null::<isize>();
93 assert!(nci.is_null());
95 let nmi: *mut dyn ToString = null_mut::<isize>();
96 assert!(nmi.is_null());
102 let p: *const isize = null();
103 assert_eq!(p.as_ref(), None);
105 let q: *const isize = &2;
106 assert_eq!(q.as_ref().unwrap(), &2);
108 let p: *mut isize = null_mut();
109 assert_eq!(p.as_ref(), None);
111 let q: *mut isize = &mut 2;
112 assert_eq!(q.as_ref().unwrap(), &2);
114 // Lifetime inference
117 let p = &u as *const isize;
118 assert_eq!(p.as_ref().unwrap(), &2);
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));
126 let ms: *mut [u8] = s;
127 assert_eq!(ms.as_ref(), Some(&*s));
129 let cz: *const [u8] = &[];
130 assert_eq!(cz.as_ref(), Some(&[][..]));
132 let mz: *mut [u8] = &mut [];
133 assert_eq!(mz.as_ref(), Some(&[][..]));
135 let ncs: *const [u8] = null::<[u8; 3]>();
136 assert_eq!(ncs.as_ref(), None);
138 let nms: *mut [u8] = null_mut::<[u8; 3]>();
139 assert_eq!(nms.as_ref(), None);
141 // Pointers to unsized types -- trait objects
142 let ci: *const dyn ToString = &3;
143 assert!(ci.as_ref().is_some());
145 let mi: *mut dyn ToString = &mut 3;
146 assert!(mi.as_ref().is_some());
148 let nci: *const dyn ToString = null::<isize>();
149 assert!(nci.as_ref().is_none());
151 let nmi: *mut dyn ToString = null_mut::<isize>();
152 assert!(nmi.as_ref().is_none());
159 let p: *mut isize = null_mut();
160 assert!(p.as_mut() == None);
162 let q: *mut isize = &mut 2;
163 assert!(q.as_mut().unwrap() == &mut 2);
165 // Lifetime inference
168 let p = &mut u as *mut isize;
169 assert!(p.as_mut().unwrap() == &mut 2);
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][..]));
177 let mz: *mut [u8] = &mut [];
178 assert_eq!(mz.as_mut(), Some(&mut [][..]));
180 let nms: *mut [u8] = null_mut::<[u8; 3]>();
181 assert_eq!(nms.as_mut(), None);
183 // Pointers to unsized types -- trait objects
184 let mi: *mut dyn ToString = &mut 3;
185 assert!(mi.as_mut().is_some());
187 let nmi: *mut dyn ToString = null_mut::<isize>();
188 assert!(nmi.as_mut().is_none());
193 fn test_ptr_addition() {
195 let xs = vec![5; 16];
196 let mut ptr = xs.as_ptr();
197 let end = ptr.offset(16);
205 let mut m_ptr = xs_mut.as_mut_ptr();
206 let m_end = m_ptr.offset(16);
208 while m_ptr < m_end {
210 m_ptr = m_ptr.offset(1);
213 assert!(xs_mut == vec![10; 16]);
218 fn test_ptr_subtraction() {
220 let xs = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
222 let ptr = xs.as_ptr();
225 assert_eq!(*(ptr.offset(idx as isize)), idx as isize);
230 let m_start = xs_mut.as_mut_ptr();
231 let mut m_ptr = m_start.offset(9);
235 if m_ptr == m_start {
238 m_ptr = m_ptr.offset(-1);
241 assert_eq!(xs_mut, [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]);
246 fn test_set_memory() {
247 let mut xs = [0u8; 20];
248 let ptr = xs.as_mut_ptr();
250 write_bytes(ptr, 5u8, xs.len());
252 assert!(xs == [5u8; 20]);
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];
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.
269 pub fn test_variadic_fnptr() {
270 use core::hash::{Hash, SipHasher};
272 fn test_variadic_fnptr(_: u64, ...) -> f64;
274 let p: unsafe extern "C" fn(u64, ...) -> f64 = test_variadic_fnptr;
278 let mut s = SipHasher::new();
279 assert_eq!(p.hash(&mut s), q.hash(&mut s));
283 fn write_unaligned_drop() {
285 static DROPS: RefCell<Vec<u32>> = RefCell::new(Vec::new());
290 impl Drop for Dropper {
292 DROPS.with(|d| d.borrow_mut().push(self.0));
298 let mut t = Dropper(1);
300 write_unaligned(&mut t, c);
303 DROPS.with(|d| assert_eq!(*d.borrow(), [0]));
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.
312 assert_eq!((p as *const ()).align_offset(p), 0);
314 assert_eq!(((p + 1) as *const ()).align_offset(p), !0);
316 p = (p + 1).next_power_of_two();
321 fn align_offset_stride1() {
322 // For pointers of stride = 1, the pointer can always be aligned. The offset is equal to
326 for ptr in 1..2 * align {
327 let expected = ptr % align;
328 let offset = if expected == 0 { 0 } else { align - expected };
330 (ptr as *const u8).align_offset(align),
332 "ptr = {}, align = {}, size = 1",
337 align = (align + 1).next_power_of_two();
342 fn align_offset_weird_strides() {
351 struct A7(u32, u16, u8);
355 struct A9(u32, u32, u8);
357 struct A10(u32, u32, u16);
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>.
364 if (numptr + el * ::std::mem::size_of::<T>()) % align == 0 {
369 let got = ptr.align_offset(align);
372 "aligning {:p} (with stride of {}) to {}, expected {}, got {}",
374 ::std::mem::size_of::<T>(),
384 // For pointers of stride != 1, we verify the algorithm against the naivest possible
389 let limit = if cfg!(miri) { 32 } else { 1024 };
390 while align < limit {
391 for ptr in 1usize..4 * align {
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);
403 align = (align + 1).next_power_of_two();
411 let ptr1: *mut i32 = &mut a[1];
412 let ptr2: *mut i32 = &mut a[3];
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);
422 #[cfg(not(bootstrap))]
425 struct Pair<A, B: ?Sized>(A, B);
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);
442 assert_eq!(metadata("foo"), 3_usize);
443 assert_eq!(metadata(&[4, 7][..]), 2_usize);
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);
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);
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>);
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);
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
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>();
495 // For this reason, let’s check here that bounds are satisfied:
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>;
504 fn static_assert_expected_bounds_for_metadata<Meta>()
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,
513 #[cfg(not(bootstrap))]
517 struct Something([u8; 47]);
519 let value = Something([0; 47]);
520 let trait_object: &dyn Debug = &value;
521 let meta = metadata(trait_object);
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>());
529 assert!(format!("{:?}", meta).starts_with("DynMetadata(0x"));
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);
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);
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[..]);
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);
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);
560 #[cfg(not(bootstrap))]
562 let foo = ThinBox::<dyn Display>::new(4);
563 assert_eq!(foo.to_string(), "4");
565 let bar = ThinBox::<dyn Display>::new(7);
566 assert_eq!(bar.to_string(), "7");
568 // A slightly more interesting library that could be built on top of metadata APIs.
570 // * It could be generalized to any `T: ?Sized` (not just trait object)
571 // if `{size,align}_of_for_meta<T: ?Sized>(T::Metadata)` are added.
572 // * Constructing a `ThinBox` without consuming and deallocating a `Box`
573 // requires either the unstable `Unsize` marker trait,
574 // or the unstable `unsized_locals` language feature,
575 // or taking `&dyn T` and restricting to `T: Copy`.
578 use std::marker::PhantomData;
582 T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
584 ptr: NonNull<DynMetadata<T>>,
585 phantom: PhantomData<T>,
590 T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
592 pub fn new<Value: std::marker::Unsize<T>>(value: Value) -> Self {
593 let unsized_: &T = &value;
594 let meta = metadata(unsized_);
595 let meta_layout = Layout::for_value(&meta);
596 let value_layout = Layout::for_value(&value);
597 let (layout, offset) = meta_layout.extend(value_layout).unwrap();
598 // `DynMetadata` is pointer-sized:
599 assert!(layout.size() > 0);
600 // If `ThinBox<T>` is generalized to any `T: ?Sized`,
601 // handle ZSTs with a dangling pointer without going through `alloc()`,
602 // like `Box<T>` does.
604 let ptr = NonNull::new(alloc(layout))
605 .unwrap_or_else(|| handle_alloc_error(layout))
606 .cast::<DynMetadata<T>>();
607 ptr.as_ptr().write(meta);
608 ptr.cast::<u8>().as_ptr().add(offset).cast::<Value>().write(value);
609 Self { ptr, phantom: PhantomData }
613 fn meta(&self) -> DynMetadata<T> {
614 unsafe { *self.ptr.as_ref() }
617 fn layout(&self) -> (Layout, usize) {
618 let meta = self.meta();
619 Layout::for_value(&meta).extend(meta.layout()).unwrap()
622 fn value_ptr(&self) -> *const T {
623 let (_, offset) = self.layout();
624 let data_ptr = unsafe { self.ptr.cast::<u8>().as_ptr().add(offset) };
625 ptr::from_raw_parts(data_ptr.cast(), self.meta())
628 fn value_mut_ptr(&mut self) -> *mut T {
629 let (_, offset) = self.layout();
630 // FIXME: can this line be shared with the same in `value_ptr()`
631 // without upsetting Stacked Borrows?
632 let data_ptr = unsafe { self.ptr.cast::<u8>().as_ptr().add(offset) };
633 from_raw_parts_mut(data_ptr.cast(), self.meta())
637 impl<T> std::ops::Deref for ThinBox<T>
639 T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
643 fn deref(&self) -> &T {
644 unsafe { &*self.value_ptr() }
648 impl<T> std::ops::DerefMut for ThinBox<T>
650 T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
652 fn deref_mut(&mut self) -> &mut T {
653 unsafe { &mut *self.value_mut_ptr() }
657 impl<T> std::ops::Drop for ThinBox<T>
659 T: ?Sized + Pointee<Metadata = DynMetadata<T>>,
662 let (layout, _) = self.layout();
664 drop_in_place::<T>(&mut **self);
665 dealloc(self.ptr.cast().as_ptr(), layout);