tests/ui/realloc-16687.rs

   1 // run-pass
   2 // alloc::heap::reallocate test.
   3 //
   4 // Ideally this would be revised to use no_std, but for now it serves
   5 // well enough to reproduce (and illustrate) the bug from #16687.
   6
   7 #![feature(allocator_api)]
   8 #![feature(slice_ptr_get)]
   9
  10 use std::alloc::{handle_alloc_error, Allocator, Global, Layout};
  11 use std::ptr::{self, NonNull};
  12
  13 fn main() {
  14     unsafe {
  15         assert!(test_triangle());
  16     }
  17 }
  18
  19 unsafe fn test_triangle() -> bool {
  20     static COUNT: usize = 16;
  21     let mut ascend = vec![ptr::null_mut(); COUNT];
  22     let ascend = &mut *ascend;
  23     static ALIGN: usize = 1;
  24
  25     // Checks that `ascend` forms triangle of ascending size formed
  26     // from pairs of rows (where each pair of rows is equally sized),
  27     // and the elements of the triangle match their row-pair index.
  28     unsafe fn sanity_check(ascend: &[*mut u8]) {
  29         for i in 0..COUNT / 2 {
  30             let (p0, p1, size) = (ascend[2 * i], ascend[2 * i + 1], idx_to_size(i));
  31             for j in 0..size {
  32                 assert_eq!(*p0.add(j), i as u8);
  33                 assert_eq!(*p1.add(j), i as u8);
  34             }
  35         }
  36     }
  37
  38     static PRINT: bool = false;
  39
  40     unsafe fn allocate(layout: Layout) -> *mut u8 {
  41         if PRINT {
  42             println!("allocate({:?})", layout);
  43         }
  44
  45         let ptr = Global.allocate(layout).unwrap_or_else(|_| handle_alloc_error(layout));
  46
  47         if PRINT {
  48             println!("allocate({:?}) = {:?}", layout, ptr);
  49         }
  50
  51         ptr.as_mut_ptr()
  52     }
  53
  54     unsafe fn deallocate(ptr: *mut u8, layout: Layout) {
  55         if PRINT {
  56             println!("deallocate({:?}, {:?}", ptr, layout);
  57         }
  58
  59         Global.deallocate(NonNull::new_unchecked(ptr), layout);
  60     }
  61
  62     unsafe fn reallocate(ptr: *mut u8, old: Layout, new: Layout) -> *mut u8 {
  63         if PRINT {
  64             println!("reallocate({:?}, old={:?}, new={:?})", ptr, old, new);
  65         }
  66
  67         let memory = if new.size() > old.size() {
  68             Global.grow(NonNull::new_unchecked(ptr), old, new)
  69         } else {
  70             Global.shrink(NonNull::new_unchecked(ptr), old, new)
  71         };
  72
  73         let ptr = memory.unwrap_or_else(|_| handle_alloc_error(new));
  74
  75         if PRINT {
  76             println!("reallocate({:?}, old={:?}, new={:?}) = {:?}", ptr, old, new, ptr);
  77         }
  78         ptr.as_mut_ptr()
  79     }
  80
  81     fn idx_to_size(i: usize) -> usize {
  82         (i + 1) * 10
  83     }
  84
  85     // Allocate pairs of rows that form a triangle shape.  (Hope is
  86     // that at least two rows will be allocated near each other, so
  87     // that we trigger the bug (a buffer overrun) in an observable
  88     // way.)
  89     for i in 0..COUNT / 2 {
  90         let size = idx_to_size(i);
  91         ascend[2 * i] = allocate(Layout::from_size_align(size, ALIGN).unwrap());
  92         ascend[2 * i + 1] = allocate(Layout::from_size_align(size, ALIGN).unwrap());
  93     }
  94
  95     // Initialize each pair of rows to distinct value.
  96     for i in 0..COUNT / 2 {
  97         let (p0, p1, size) = (ascend[2 * i], ascend[2 * i + 1], idx_to_size(i));
  98         for j in 0..size {
  99             *p0.add(j) = i as u8;
 100             *p1.add(j) = i as u8;
 101         }
 102     }
 103
 104     sanity_check(&*ascend);
 105     test_1(ascend); // triangle -> square
 106     test_2(ascend); // square -> triangle
 107     test_3(ascend); // triangle -> square
 108     test_4(ascend); // square -> triangle
 109
 110     for i in 0..COUNT / 2 {
 111         let size = idx_to_size(i);
 112         deallocate(ascend[2 * i], Layout::from_size_align(size, ALIGN).unwrap());
 113         deallocate(ascend[2 * i + 1], Layout::from_size_align(size, ALIGN).unwrap());
 114     }
 115
 116     return true;
 117
 118     // Test 1: turn the triangle into a square (in terms of
 119     // allocation; initialized portion remains a triangle) by
 120     // realloc'ing each row from top to bottom, and checking all the
 121     // rows as we go.
 122     unsafe fn test_1(ascend: &mut [*mut u8]) {
 123         let new_size = idx_to_size(COUNT - 1);
 124         let new = Layout::from_size_align(new_size, ALIGN).unwrap();
 125         for i in 0..COUNT / 2 {
 126             let (p0, p1, old_size) = (ascend[2 * i], ascend[2 * i + 1], idx_to_size(i));
 127             assert!(old_size < new_size);
 128             let old = Layout::from_size_align(old_size, ALIGN).unwrap();
 129
 130             ascend[2 * i] = reallocate(p0, old.clone(), new.clone());
 131             sanity_check(&*ascend);
 132
 133             ascend[2 * i + 1] = reallocate(p1, old.clone(), new.clone());
 134             sanity_check(&*ascend);
 135         }
 136     }
 137
 138     // Test 2: turn the square back into a triangle, top to bottom.
 139     unsafe fn test_2(ascend: &mut [*mut u8]) {
 140         let old_size = idx_to_size(COUNT - 1);
 141         let old = Layout::from_size_align(old_size, ALIGN).unwrap();
 142         for i in 0..COUNT / 2 {
 143             let (p0, p1, new_size) = (ascend[2 * i], ascend[2 * i + 1], idx_to_size(i));
 144             assert!(new_size < old_size);
 145             let new = Layout::from_size_align(new_size, ALIGN).unwrap();
 146
 147             ascend[2 * i] = reallocate(p0, old.clone(), new.clone());
 148             sanity_check(&*ascend);
 149
 150             ascend[2 * i + 1] = reallocate(p1, old.clone(), new.clone());
 151             sanity_check(&*ascend);
 152         }
 153     }
 154
 155     // Test 3: turn triangle into a square, bottom to top.
 156     unsafe fn test_3(ascend: &mut [*mut u8]) {
 157         let new_size = idx_to_size(COUNT - 1);
 158         let new = Layout::from_size_align(new_size, ALIGN).unwrap();
 159         for i in (0..COUNT / 2).rev() {
 160             let (p0, p1, old_size) = (ascend[2 * i], ascend[2 * i + 1], idx_to_size(i));
 161             assert!(old_size < new_size);
 162             let old = Layout::from_size_align(old_size, ALIGN).unwrap();
 163
 164             ascend[2 * i + 1] = reallocate(p1, old.clone(), new.clone());
 165             sanity_check(&*ascend);
 166
 167             ascend[2 * i] = reallocate(p0, old.clone(), new.clone());
 168             sanity_check(&*ascend);
 169         }
 170     }
 171
 172     // Test 4: turn the square back into a triangle, bottom to top.
 173     unsafe fn test_4(ascend: &mut [*mut u8]) {
 174         let old_size = idx_to_size(COUNT - 1);
 175         let old = Layout::from_size_align(old_size, ALIGN).unwrap();
 176         for i in (0..COUNT / 2).rev() {
 177             let (p0, p1, new_size) = (ascend[2 * i], ascend[2 * i + 1], idx_to_size(i));
 178             assert!(new_size < old_size);
 179             let new = Layout::from_size_align(new_size, ALIGN).unwrap();
 180
 181             ascend[2 * i + 1] = reallocate(p1, old.clone(), new.clone());
 182             sanity_check(&*ascend);
 183
 184             ascend[2 * i] = reallocate(p0, old.clone(), new.clone());
 185             sanity_check(&*ascend);
 186         }
 187     }
 188 }