1use crate::alloc::{GlobalAlloc, Layout, System};
2use crate::ptr;
3use crate::sys::common::alloc::{realloc_fallback, MIN_ALIGN};
4
5#[stable(feature = "alloc_system_type", since = "1.28.0")]
6unsafe impl GlobalAlloc for System {
7 #[inline]
8 unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
9 // jemalloc provides alignment less than MIN_ALIGN for small allocations.
10 // So only rely on MIN_ALIGN if size >= align.
11 // Also see <https://github.com/rust-lang/rust/issues/45955> and
12 // <https://github.com/rust-lang/rust/issues/62251#issuecomment-507580914>.
13 if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
14 libc::malloc(layout.size()) as *mut u8
15 } else {
16 #[cfg(target_os = "macos")]
17 {
18 if layout.align() > (1 << 31) {
19 return ptr::null_mut();
20 }
21 }
22 aligned_malloc(&layout)
23 }
24 }
25
26 #[inline]
27 unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
28 // See the comment above in `alloc` for why this check looks the way it does.
29 if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
30 libc::calloc(layout.size(), 1) as *mut u8
31 } else {
32 let ptr = self.alloc(layout);
33 if !ptr.is_null() {
34 ptr::write_bytes(ptr, 0, layout.size());
35 }
36 ptr
37 }
38 }
39
40 #[inline]
41 unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
42 libc::free(ptr as *mut libc::c_void)
43 }
44
45 #[inline]
46 unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
47 if layout.align() <= MIN_ALIGN && layout.align() <= new_size {
48 libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8
49 } else {
50 realloc_fallback(self, ptr, layout, new_size)
51 }
52 }
53}
54
55cfg_if::cfg_if! {
56 if #[cfg(any(
57 target_os = "android",
58 target_os = "illumos",
59 target_os = "redox",
60 target_os = "solaris",
61 target_os = "espidf",
62 target_os = "horizon",
63 target_os = "vita",
64 ))] {
65 #[inline]
66 unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 {
67 // On android we currently target API level 9 which unfortunately
68 // doesn't have the `posix_memalign` API used below. Instead we use
69 // `memalign`, but this unfortunately has the property on some systems
70 // where the memory returned cannot be deallocated by `free`!
71 //
72 // Upon closer inspection, however, this appears to work just fine with
73 // Android, so for this platform we should be fine to call `memalign`
74 // (which is present in API level 9). Some helpful references could
75 // possibly be chromium using memalign [1], attempts at documenting that
76 // memalign + free is ok [2] [3], or the current source of chromium
77 // which still uses memalign on android [4].
78 //
79 // [1]: https://codereview.chromium.org/10796020/
80 // [2]: https://code.google.com/p/android/issues/detail?id=35391
81 // [3]: https://bugs.chromium.org/p/chromium/issues/detail?id=138579
82 // [4]: https://chromium.googlesource.com/chromium/src/base/+/master/
83 // /memory/aligned_memory.cc
84 libc::memalign(layout.align(), layout.size()) as *mut u8
85 }
86 } else if #[cfg(target_os = "wasi")] {
87 #[inline]
88 unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 {
89 // C11 aligned_alloc requires that the size be a multiple of the alignment.
90 // Layout already checks that the size rounded up doesn't overflow isize::MAX.
91 let align = layout.align();
92 let size = layout.size().next_multiple_of(align);
93 libc::aligned_alloc(align, size) as *mut u8
94 }
95 } else {
96 #[inline]
97 unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 {
98 let mut out = ptr::null_mut();
99 // posix_memalign requires that the alignment be a multiple of `sizeof(void*)`.
100 // Since these are all powers of 2, we can just use max.
101 let align = layout.align().max(crate::mem::size_of::<usize>());
102 let ret = libc::posix_memalign(&mut out, align, layout.size());
103 if ret != 0 { ptr::null_mut() } else { out as *mut u8 }
104 }
105 }
106}
107