1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 #![crate_name = "alloc_system"]
12 #![crate_type = "rlib"]
16 #![unstable(feature = "alloc_system",
17 reason
= "this library is unlikely to be stabilized in its current \
20 #![feature(allocator)]
21 #![feature(staged_api)]
22 #![cfg_attr(any(unix, target_os = "redox"), feature(libc))]
24 // The minimum alignment guaranteed by the architecture. This value is used to
25 // add fast paths for low alignment values. In practice, the alignment is a
26 // constant at the call site and the branch will be optimized out.
27 #[cfg(all(any(target_arch = "x86",
30 target_arch
= "powerpc",
31 target_arch
= "powerpc64",
32 target_arch
= "asmjs",
33 target_arch
= "wasm32")))]
34 const MIN_ALIGN
: usize = 8;
35 #[cfg(all(any(target_arch = "x86_64",
36 target_arch
= "aarch64",
37 target_arch
= "mips64",
38 target_arch
= "s390x",
39 target_arch
= "sparc64")))]
40 const MIN_ALIGN
: usize = 16;
43 pub extern "C" fn __rust_allocate(size
: usize, align
: usize) -> *mut u8 {
44 unsafe { imp::allocate(size, align) }
48 pub extern "C" fn __rust_allocate_zeroed(size
: usize, align
: usize) -> *mut u8 {
49 unsafe { imp::allocate_zeroed(size, align) }
53 pub extern "C" fn __rust_deallocate(ptr
: *mut u8, old_size
: usize, align
: usize) {
54 unsafe { imp::deallocate(ptr, old_size, align) }
58 pub extern "C" fn __rust_reallocate(ptr
: *mut u8,
63 unsafe { imp::reallocate(ptr, old_size, size, align) }
67 pub extern "C" fn __rust_reallocate_inplace(ptr
: *mut u8,
72 unsafe { imp::reallocate_inplace(ptr, old_size, size, align) }
76 pub extern "C" fn __rust_usable_size(size
: usize, align
: usize) -> usize {
77 imp
::usable_size(size
, align
)
80 #[cfg(any(unix, target_os = "redox"))]
88 pub unsafe fn allocate(size
: usize, align
: usize) -> *mut u8 {
89 if align
<= MIN_ALIGN
{
90 libc
::malloc(size
as libc
::size_t
) as *mut u8
92 aligned_malloc(size
, align
)
96 #[cfg(any(target_os = "android", target_os = "redox"))]
97 unsafe fn aligned_malloc(size
: usize, align
: usize) -> *mut u8 {
98 // On android we currently target API level 9 which unfortunately
99 // doesn't have the `posix_memalign` API used below. Instead we use
100 // `memalign`, but this unfortunately has the property on some systems
101 // where the memory returned cannot be deallocated by `free`!
103 // Upon closer inspection, however, this appears to work just fine with
104 // Android, so for this platform we should be fine to call `memalign`
105 // (which is present in API level 9). Some helpful references could
106 // possibly be chromium using memalign [1], attempts at documenting that
107 // memalign + free is ok [2] [3], or the current source of chromium
108 // which still uses memalign on android [4].
110 // [1]: https://codereview.chromium.org/10796020/
111 // [2]: https://code.google.com/p/android/issues/detail?id=35391
112 // [3]: https://bugs.chromium.org/p/chromium/issues/detail?id=138579
113 // [4]: https://chromium.googlesource.com/chromium/src/base/+/master/
114 // /memory/aligned_memory.cc
115 libc
::memalign(align
as libc
::size_t
, size
as libc
::size_t
) as *mut u8
118 #[cfg(not(any(target_os = "android", target_os = "redox")))]
119 unsafe fn aligned_malloc(size
: usize, align
: usize) -> *mut u8 {
120 let mut out
= ptr
::null_mut();
121 let ret
= libc
::posix_memalign(&mut out
, align
as libc
::size_t
, size
as libc
::size_t
);
129 pub unsafe fn allocate_zeroed(size
: usize, align
: usize) -> *mut u8 {
130 if align
<= MIN_ALIGN
{
131 libc
::calloc(size
as libc
::size_t
, 1) as *mut u8
133 let ptr
= aligned_malloc(size
, align
);
135 ptr
::write_bytes(ptr
, 0, size
);
141 pub unsafe fn reallocate(ptr
: *mut u8, old_size
: usize, size
: usize, align
: usize) -> *mut u8 {
142 if align
<= MIN_ALIGN
{
143 libc
::realloc(ptr
as *mut libc
::c_void
, size
as libc
::size_t
) as *mut u8
145 let new_ptr
= allocate(size
, align
);
146 if !new_ptr
.is_null() {
147 ptr
::copy(ptr
, new_ptr
, cmp
::min(size
, old_size
));
148 deallocate(ptr
, old_size
, align
);
154 pub unsafe fn reallocate_inplace(_ptr
: *mut u8,
162 pub unsafe fn deallocate(ptr
: *mut u8, _old_size
: usize, _align
: usize) {
163 libc
::free(ptr
as *mut libc
::c_void
)
166 pub fn usable_size(size
: usize, _align
: usize) -> usize {
176 type LPVOID
= *mut u8;
177 type HANDLE
= LPVOID
;
183 fn GetProcessHeap() -> HANDLE
;
184 fn HeapAlloc(hHeap
: HANDLE
, dwFlags
: DWORD
, dwBytes
: SIZE_T
) -> LPVOID
;
185 fn HeapReAlloc(hHeap
: HANDLE
, dwFlags
: DWORD
, lpMem
: LPVOID
, dwBytes
: SIZE_T
) -> LPVOID
;
186 fn HeapFree(hHeap
: HANDLE
, dwFlags
: DWORD
, lpMem
: LPVOID
) -> BOOL
;
187 fn GetLastError() -> DWORD
;
191 struct Header(*mut u8);
194 const HEAP_ZERO_MEMORY
: DWORD
= 0x00000008;
195 const HEAP_REALLOC_IN_PLACE_ONLY
: DWORD
= 0x00000010;
197 unsafe fn get_header
<'a
>(ptr
: *mut u8) -> &'a
mut Header
{
198 &mut *(ptr
as *mut Header
).offset(-1)
201 unsafe fn align_ptr(ptr
: *mut u8, align
: usize) -> *mut u8 {
202 let aligned
= ptr
.offset((align
- (ptr
as usize & (align
- 1))) as isize);
203 *get_header(aligned
) = Header(ptr
);
208 unsafe fn allocate_with_flags(size
: usize, align
: usize, flags
: DWORD
) -> *mut u8 {
209 if align
<= MIN_ALIGN
{
210 HeapAlloc(GetProcessHeap(), flags
, size
as SIZE_T
) as *mut u8
212 let ptr
= HeapAlloc(GetProcessHeap(), flags
, (size
+ align
) as SIZE_T
) as *mut u8;
216 align_ptr(ptr
, align
)
220 pub unsafe fn allocate(size
: usize, align
: usize) -> *mut u8 {
221 allocate_with_flags(size
, align
, 0)
224 pub unsafe fn allocate_zeroed(size
: usize, align
: usize) -> *mut u8 {
225 allocate_with_flags(size
, align
, HEAP_ZERO_MEMORY
)
228 pub unsafe fn reallocate(ptr
: *mut u8, _old_size
: usize, size
: usize, align
: usize) -> *mut u8 {
229 if align
<= MIN_ALIGN
{
230 HeapReAlloc(GetProcessHeap(), 0, ptr
as LPVOID
, size
as SIZE_T
) as *mut u8
232 let header
= get_header(ptr
);
233 let new
= HeapReAlloc(GetProcessHeap(),
236 (size
+ align
) as SIZE_T
) as *mut u8;
240 align_ptr(new
, align
)
244 pub unsafe fn reallocate_inplace(ptr
: *mut u8,
249 if align
<= MIN_ALIGN
{
250 let new
= HeapReAlloc(GetProcessHeap(),
251 HEAP_REALLOC_IN_PLACE_ONLY
,
253 size
as SIZE_T
) as *mut u8;
254 if new
.is_null() { old_size }
else { size }
260 pub unsafe fn deallocate(ptr
: *mut u8, _old_size
: usize, align
: usize) {
261 if align
<= MIN_ALIGN
{
262 let err
= HeapFree(GetProcessHeap(), 0, ptr
as LPVOID
);
263 debug_assert
!(err
!= 0, "Failed to free heap memory: {}", GetLastError());
265 let header
= get_header(ptr
);
266 let err
= HeapFree(GetProcessHeap(), 0, header
.0 as LPVOID
);
267 debug_assert
!(err
!= 0, "Failed to free heap memory: {}", GetLastError());
271 pub fn usable_size(size
: usize, _align
: usize) -> usize {