src/liballoc_system/lib.rs

   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.
   4 //
   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.
  10
  11 #![crate_name = "alloc_system"]
  12 #![crate_type = "rlib"]
  13 #![no_std]
  14 #![allocator]
  15 #![unstable(feature = "alloc_system",
  16             reason = "this library is unlikely to be stabilized in its current \
  17                       form or name",
  18             issue = "27783")]
  19 #![feature(allocator)]
  20 #![feature(libc)]
  21 #![feature(staged_api)]
  22
  23 extern crate libc;
  24
  25 // The minimum alignment guaranteed by the architecture. This value is used to
  26 // add fast paths for low alignment values. In practice, the alignment is a
  27 // constant at the call site and the branch will be optimized out.
  28 #[cfg(all(any(target_arch = "x86",
  29               target_arch = "arm",
  30               target_arch = "mips",
  31               target_arch = "mipsel",
  32               target_arch = "powerpc",
  33               target_arch = "powerpc64",
  34               target_arch = "powerpc64le")))]
  35 const MIN_ALIGN: usize = 8;
  36 #[cfg(all(any(target_arch = "x86_64",
  37               target_arch = "aarch64")))]
  38 const MIN_ALIGN: usize = 16;
  39
  40 #[no_mangle]
  41 pub extern "C" fn __rust_allocate(size: usize, align: usize) -> *mut u8 {
  42     unsafe { imp::allocate(size, align) }
  43 }
  44
  45 #[no_mangle]
  46 pub extern "C" fn __rust_deallocate(ptr: *mut u8, old_size: usize, align: usize) {
  47     unsafe { imp::deallocate(ptr, old_size, align) }
  48 }
  49
  50 #[no_mangle]
  51 pub extern "C" fn __rust_reallocate(ptr: *mut u8,
  52                                     old_size: usize,
  53                                     size: usize,
  54                                     align: usize)
  55                                     -> *mut u8 {
  56     unsafe { imp::reallocate(ptr, old_size, size, align) }
  57 }
  58
  59 #[no_mangle]
  60 pub extern "C" fn __rust_reallocate_inplace(ptr: *mut u8,
  61                                             old_size: usize,
  62                                             size: usize,
  63                                             align: usize)
  64                                             -> usize {
  65     unsafe { imp::reallocate_inplace(ptr, old_size, size, align) }
  66 }
  67
  68 #[no_mangle]
  69 pub extern "C" fn __rust_usable_size(size: usize, align: usize) -> usize {
  70     imp::usable_size(size, align)
  71 }
  72
  73 #[cfg(unix)]
  74 mod imp {
  75     use core::cmp;
  76     use core::ptr;
  77     use libc;
  78     use MIN_ALIGN;
  79
  80     pub unsafe fn allocate(size: usize, align: usize) -> *mut u8 {
  81         if align <= MIN_ALIGN {
  82             libc::malloc(size as libc::size_t) as *mut u8
  83         } else {
  84             let mut out = ptr::null_mut();
  85             let ret = libc::posix_memalign(&mut out, align as libc::size_t, size as libc::size_t);
  86             if ret != 0 {
  87                 ptr::null_mut()
  88             } else {
  89                 out as *mut u8
  90             }
  91         }
  92     }
  93
  94     pub unsafe fn reallocate(ptr: *mut u8, old_size: usize, size: usize, align: usize) -> *mut u8 {
  95         if align <= MIN_ALIGN {
  96             libc::realloc(ptr as *mut libc::c_void, size as libc::size_t) as *mut u8
  97         } else {
  98             let new_ptr = allocate(size, align);
  99             ptr::copy(ptr, new_ptr, cmp::min(size, old_size));
 100             deallocate(ptr, old_size, align);
 101             new_ptr
 102         }
 103     }
 104
 105     pub unsafe fn reallocate_inplace(_ptr: *mut u8,
 106                                      old_size: usize,
 107                                      _size: usize,
 108                                      _align: usize)
 109                                      -> usize {
 110         old_size
 111     }
 112
 113     pub unsafe fn deallocate(ptr: *mut u8, _old_size: usize, _align: usize) {
 114         libc::free(ptr as *mut libc::c_void)
 115     }
 116
 117     pub fn usable_size(size: usize, _align: usize) -> usize {
 118         size
 119     }
 120 }
 121
 122 #[cfg(windows)]
 123 #[allow(bad_style)]
 124 mod imp {
 125     use MIN_ALIGN;
 126
 127     type LPVOID = *mut u8;
 128     type HANDLE = LPVOID;
 129     type SIZE_T = usize;
 130     type DWORD = u32;
 131     type BOOL = i32;
 132
 133     extern "system" {
 134         fn GetProcessHeap() -> HANDLE;
 135         fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) -> LPVOID;
 136         fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T) -> LPVOID;
 137         fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID) -> BOOL;
 138     }
 139
 140     #[repr(C)]
 141     struct Header(*mut u8);
 142
 143     const HEAP_REALLOC_IN_PLACE_ONLY: DWORD = 0x00000010;
 144
 145     unsafe fn get_header<'a>(ptr: *mut u8) -> &'a mut Header {
 146         &mut *(ptr as *mut Header).offset(-1)
 147     }
 148
 149     unsafe fn align_ptr(ptr: *mut u8, align: usize) -> *mut u8 {
 150         let aligned = ptr.offset((align - (ptr as usize & (align - 1))) as isize);
 151         *get_header(aligned) = Header(ptr);
 152         aligned
 153     }
 154
 155     pub unsafe fn allocate(size: usize, align: usize) -> *mut u8 {
 156         if align <= MIN_ALIGN {
 157             HeapAlloc(GetProcessHeap(), 0, size as SIZE_T) as *mut u8
 158         } else {
 159             let ptr = HeapAlloc(GetProcessHeap(), 0, (size + align) as SIZE_T) as *mut u8;
 160             if ptr.is_null() {
 161                 return ptr;
 162             }
 163             align_ptr(ptr, align)
 164         }
 165     }
 166
 167     pub unsafe fn reallocate(ptr: *mut u8, _old_size: usize, size: usize, align: usize) -> *mut u8 {
 168         if align <= MIN_ALIGN {
 169             HeapReAlloc(GetProcessHeap(), 0, ptr as LPVOID, size as SIZE_T) as *mut u8
 170         } else {
 171             let header = get_header(ptr);
 172             let new = HeapReAlloc(GetProcessHeap(),
 173                                   0,
 174                                   header.0 as LPVOID,
 175                                   (size + align) as SIZE_T) as *mut u8;
 176             if new.is_null() {
 177                 return new;
 178             }
 179             align_ptr(new, align)
 180         }
 181     }
 182
 183     pub unsafe fn reallocate_inplace(ptr: *mut u8,
 184                                      old_size: usize,
 185                                      size: usize,
 186                                      align: usize)
 187                                      -> usize {
 188         if align <= MIN_ALIGN {
 189             let new = HeapReAlloc(GetProcessHeap(),
 190                                   HEAP_REALLOC_IN_PLACE_ONLY,
 191                                   ptr as LPVOID,
 192                                   size as SIZE_T) as *mut u8;
 193             if new.is_null() {
 194                 old_size
 195             } else {
 196                 size
 197             }
 198         } else {
 199             old_size
 200         }
 201     }
 202
 203     pub unsafe fn deallocate(ptr: *mut u8, _old_size: usize, align: usize) {
 204         if align <= MIN_ALIGN {
 205             let err = HeapFree(GetProcessHeap(), 0, ptr as LPVOID);
 206             debug_assert!(err != 0);
 207         } else {
 208             let header = get_header(ptr);
 209             let err = HeapFree(GetProcessHeap(), 0, header.0 as LPVOID);
 210             debug_assert!(err != 0);
 211         }
 212     }
 213
 214     pub fn usable_size(size: usize, _align: usize) -> usize {
 215         size
 216     }
 217 }