33dfd0fb16
We've gotten requests to move our Android support as far back as API level 9 where unfortunately the `posix_memalign` API wasn't implemented yet. Thankfully, however, the `memalign` API was and it appears to be usable with `free` on the Android platform (see comments included in commit). This should help fix some of the last few test failures when compiling against API level 9.
246 lines
8.5 KiB
Rust
246 lines
8.5 KiB
Rust
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
#![crate_name = "alloc_system"]
|
|
#![crate_type = "rlib"]
|
|
#![no_std]
|
|
#![allocator]
|
|
#![cfg_attr(not(stage0), deny(warnings))]
|
|
#![unstable(feature = "alloc_system",
|
|
reason = "this library is unlikely to be stabilized in its current \
|
|
form or name",
|
|
issue = "27783")]
|
|
#![feature(allocator)]
|
|
#![feature(staged_api)]
|
|
#![cfg_attr(unix, feature(libc))]
|
|
|
|
// The minimum alignment guaranteed by the architecture. This value is used to
|
|
// add fast paths for low alignment values. In practice, the alignment is a
|
|
// constant at the call site and the branch will be optimized out.
|
|
#[cfg(all(any(target_arch = "x86",
|
|
target_arch = "arm",
|
|
target_arch = "mips",
|
|
target_arch = "powerpc",
|
|
target_arch = "powerpc64",
|
|
target_arch = "asmjs")))]
|
|
const MIN_ALIGN: usize = 8;
|
|
#[cfg(all(any(target_arch = "x86_64",
|
|
target_arch = "aarch64")))]
|
|
const MIN_ALIGN: usize = 16;
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn __rust_allocate(size: usize, align: usize) -> *mut u8 {
|
|
unsafe { imp::allocate(size, align) }
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn __rust_deallocate(ptr: *mut u8, old_size: usize, align: usize) {
|
|
unsafe { imp::deallocate(ptr, old_size, align) }
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn __rust_reallocate(ptr: *mut u8,
|
|
old_size: usize,
|
|
size: usize,
|
|
align: usize)
|
|
-> *mut u8 {
|
|
unsafe { imp::reallocate(ptr, old_size, size, align) }
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn __rust_reallocate_inplace(ptr: *mut u8,
|
|
old_size: usize,
|
|
size: usize,
|
|
align: usize)
|
|
-> usize {
|
|
unsafe { imp::reallocate_inplace(ptr, old_size, size, align) }
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub extern "C" fn __rust_usable_size(size: usize, align: usize) -> usize {
|
|
imp::usable_size(size, align)
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
mod imp {
|
|
extern crate libc;
|
|
|
|
use core::cmp;
|
|
use core::ptr;
|
|
use MIN_ALIGN;
|
|
|
|
pub unsafe fn allocate(size: usize, align: usize) -> *mut u8 {
|
|
if align <= MIN_ALIGN {
|
|
libc::malloc(size as libc::size_t) as *mut u8
|
|
} else {
|
|
aligned_malloc(size, align)
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "android")]
|
|
unsafe fn aligned_malloc(size: usize, align: usize) -> *mut u8 {
|
|
// On android we currently target API level 9 which unfortunately
|
|
// doesn't have the `posix_memalign` API used below. Instead we use
|
|
// `memalign`, but this unfortunately has the property on some systems
|
|
// where the memory returned cannot be deallocated by `free`!
|
|
//
|
|
// Upon closer inspection, however, this appears to work just fine with
|
|
// Android, so for this platform we should be fine to call `memalign`
|
|
// (which is present in API level 9). Some helpful references could
|
|
// possibly be chromium using memalign [1], attempts at documenting that
|
|
// memalign + free is ok [2] [3], or the current source of chromium
|
|
// which still uses memalign on android [4].
|
|
//
|
|
// [1]: https://codereview.chromium.org/10796020/
|
|
// [2]: https://code.google.com/p/android/issues/detail?id=35391
|
|
// [3]: https://bugs.chromium.org/p/chromium/issues/detail?id=138579
|
|
// [4]: https://chromium.googlesource.com/chromium/src/base/+/master/
|
|
// /memory/aligned_memory.cc
|
|
libc::memalign(align as libc::size_t, size as libc::size_t) as *mut u8
|
|
}
|
|
|
|
#[cfg(not(target_os = "android"))]
|
|
unsafe fn aligned_malloc(size: usize, align: usize) -> *mut u8 {
|
|
let mut out = ptr::null_mut();
|
|
let ret = libc::posix_memalign(&mut out, align as libc::size_t, size as libc::size_t);
|
|
if ret != 0 {
|
|
ptr::null_mut()
|
|
} else {
|
|
out as *mut u8
|
|
}
|
|
}
|
|
|
|
pub unsafe fn reallocate(ptr: *mut u8, old_size: usize, size: usize, align: usize) -> *mut u8 {
|
|
if align <= MIN_ALIGN {
|
|
libc::realloc(ptr as *mut libc::c_void, size as libc::size_t) as *mut u8
|
|
} else {
|
|
let new_ptr = allocate(size, align);
|
|
if !new_ptr.is_null() {
|
|
ptr::copy(ptr, new_ptr, cmp::min(size, old_size));
|
|
deallocate(ptr, old_size, align);
|
|
}
|
|
new_ptr
|
|
}
|
|
}
|
|
|
|
pub unsafe fn reallocate_inplace(_ptr: *mut u8,
|
|
old_size: usize,
|
|
_size: usize,
|
|
_align: usize)
|
|
-> usize {
|
|
old_size
|
|
}
|
|
|
|
pub unsafe fn deallocate(ptr: *mut u8, _old_size: usize, _align: usize) {
|
|
libc::free(ptr as *mut libc::c_void)
|
|
}
|
|
|
|
pub fn usable_size(size: usize, _align: usize) -> usize {
|
|
size
|
|
}
|
|
}
|
|
|
|
#[cfg(windows)]
|
|
#[allow(bad_style)]
|
|
mod imp {
|
|
use MIN_ALIGN;
|
|
|
|
type LPVOID = *mut u8;
|
|
type HANDLE = LPVOID;
|
|
type SIZE_T = usize;
|
|
type DWORD = u32;
|
|
type BOOL = i32;
|
|
|
|
extern "system" {
|
|
fn GetProcessHeap() -> HANDLE;
|
|
fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) -> LPVOID;
|
|
fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T) -> LPVOID;
|
|
fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID) -> BOOL;
|
|
}
|
|
|
|
#[repr(C)]
|
|
struct Header(*mut u8);
|
|
|
|
const HEAP_REALLOC_IN_PLACE_ONLY: DWORD = 0x00000010;
|
|
|
|
unsafe fn get_header<'a>(ptr: *mut u8) -> &'a mut Header {
|
|
&mut *(ptr as *mut Header).offset(-1)
|
|
}
|
|
|
|
unsafe fn align_ptr(ptr: *mut u8, align: usize) -> *mut u8 {
|
|
let aligned = ptr.offset((align - (ptr as usize & (align - 1))) as isize);
|
|
*get_header(aligned) = Header(ptr);
|
|
aligned
|
|
}
|
|
|
|
pub unsafe fn allocate(size: usize, align: usize) -> *mut u8 {
|
|
if align <= MIN_ALIGN {
|
|
HeapAlloc(GetProcessHeap(), 0, size as SIZE_T) as *mut u8
|
|
} else {
|
|
let ptr = HeapAlloc(GetProcessHeap(), 0, (size + align) as SIZE_T) as *mut u8;
|
|
if ptr.is_null() {
|
|
return ptr;
|
|
}
|
|
align_ptr(ptr, align)
|
|
}
|
|
}
|
|
|
|
pub unsafe fn reallocate(ptr: *mut u8, _old_size: usize, size: usize, align: usize) -> *mut u8 {
|
|
if align <= MIN_ALIGN {
|
|
HeapReAlloc(GetProcessHeap(), 0, ptr as LPVOID, size as SIZE_T) as *mut u8
|
|
} else {
|
|
let header = get_header(ptr);
|
|
let new = HeapReAlloc(GetProcessHeap(),
|
|
0,
|
|
header.0 as LPVOID,
|
|
(size + align) as SIZE_T) as *mut u8;
|
|
if new.is_null() {
|
|
return new;
|
|
}
|
|
align_ptr(new, align)
|
|
}
|
|
}
|
|
|
|
pub unsafe fn reallocate_inplace(ptr: *mut u8,
|
|
old_size: usize,
|
|
size: usize,
|
|
align: usize)
|
|
-> usize {
|
|
if align <= MIN_ALIGN {
|
|
let new = HeapReAlloc(GetProcessHeap(),
|
|
HEAP_REALLOC_IN_PLACE_ONLY,
|
|
ptr as LPVOID,
|
|
size as SIZE_T) as *mut u8;
|
|
if new.is_null() {
|
|
old_size
|
|
} else {
|
|
size
|
|
}
|
|
} else {
|
|
old_size
|
|
}
|
|
}
|
|
|
|
pub unsafe fn deallocate(ptr: *mut u8, _old_size: usize, align: usize) {
|
|
if align <= MIN_ALIGN {
|
|
let err = HeapFree(GetProcessHeap(), 0, ptr as LPVOID);
|
|
debug_assert!(err != 0);
|
|
} else {
|
|
let header = get_header(ptr);
|
|
let err = HeapFree(GetProcessHeap(), 0, header.0 as LPVOID);
|
|
debug_assert!(err != 0);
|
|
}
|
|
}
|
|
|
|
pub fn usable_size(size: usize, _align: usize) -> usize {
|
|
size
|
|
}
|
|
}
|