Rollup merge of rust-lang#62296 - RalfJung:memalign, r=alexcrichton

request at least ptr-size alignment from posix_memalign

Fixes rust-lang#62251

src/liballoc/tests/heap.rs

@@ -1,6 +1,6 @@
 use std::alloc::{Global, Alloc, Layout, System};
 
-/// Issue #45955.
+/// Issue #45955 and #62251.
 #[test]
 fn alloc_system_overaligned_request() {
  check_overalign_requests(System)
@@ -12,21 +12,23 @@ fn std_heap_overaligned_request() {
 }
 
 fn check_overalign_requests<T: Alloc>(mut allocator: T) {
- let size = 8;
- let align = 16; // greater than size
- let iterations = 100;
- unsafe {
- let pointers: Vec<_> = (0..iterations).map(|_| {
- allocator.alloc(Layout::from_size_align(size, align).unwrap()).unwrap()
- }).collect();
- for &ptr in &pointers {
- assert_eq!((ptr.as_ptr() as usize) % align, 0,
- "Got a pointer less aligned than requested")
- }
+ for &align in &[4, 8, 16, 32] { // less than and bigger than `MIN_ALIGN`
+  for &size in &[align/2, align-1] { // size less than alignment
+  let iterations = 128;
+  unsafe {
+  let pointers: Vec<_> = (0..iterations).map(|_| {
+  allocator.alloc(Layout::from_size_align(size, align).unwrap()).unwrap()
+  }).collect();
+  for &ptr in &pointers {
+  assert_eq!((ptr.as_ptr() as usize) % align, 0,
+  "Got a pointer less aligned than requested")
+  }
 
- // Clean up
- for &ptr in &pointers {
- allocator.dealloc(ptr, Layout::from_size_align(size, align).unwrap())
+ // Clean up
+ for &ptr in &pointers {
+ allocator.dealloc(ptr, Layout::from_size_align(size, align).unwrap())
+ }
+ }
  }
  }
 }

src/libstd/sys/unix/alloc.rs

@@ -6,6 +6,10 @@ use crate::alloc::{GlobalAlloc, Layout, System};
 unsafe impl GlobalAlloc for System {
  #[inline]
  unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+ // jemalloc provides alignment less than MIN_ALIGN for small allocations.
+ // So only rely on MIN_ALIGN if size >= align.
+ // Also see <https://github.com/rust-lang/rust/issues/45955> and
+ // <https://github.com/rust-lang/rust/issues/62251#issuecomment-507580914>.
  if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
  libc::malloc(layout.size()) as *mut u8
  } else {
@@ -21,6 +25,7 @@ unsafe impl GlobalAlloc for System {
 
  #[inline]
  unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+ // See the comment above in `alloc` for why this check looks the way it does.
  if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
  libc::calloc(layout.size(), 1) as *mut u8
  } else {
@@ -80,7 +85,10 @@ unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 {
 #[inline]
 unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 {
  let mut out = ptr::null_mut();
- let ret = libc::posix_memalign(&mut out, layout.align(), layout.size());
+ // posix_memalign requires that the alignment be a multiple of `sizeof(void*)`.
+ // Since these are all powers of 2, we can just use max.
+ let align = layout.align().max(crate::mem::size_of::<usize>());
+ let ret = libc::posix_memalign(&mut out, align, layout.size());
  if ret != 0 {
  ptr::null_mut()
  } else {