src/liballoc_jemalloc/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_jemalloc"]
  12 #![crate_type = "rlib"]
  13 #![no_std]
  14 #![allocator]
  15 #![unstable(feature = "alloc_jemalloc",
  16             reason = "this library is unlikely to be stabilized in its current \
  17                       form or name",
  18             issue = "27783")]
  19 #![cfg_attr(not(stage0), deny(warnings))]
  20 #![feature(allocator)]
  21 #![feature(libc)]
  22 #![feature(staged_api)]
  23
  24 extern crate libc;
  25
  26 pub use imp::*;
  27
  28 // See comments in build.rs for why we sometimes build a crate that does nothing
  29 #[cfg(not(dummy_jemalloc))]
  30 mod imp {
  31     use libc::{c_int, c_void, size_t};
  32
  33     // Linkage directives to pull in jemalloc and its dependencies.
  34     //
  35     // On some platforms we need to be sure to link in `pthread` which jemalloc
  36     // depends on, and specifically on android we need to also link to libgcc.
  37     // Currently jemalloc is compiled with gcc which will generate calls to
  38     // intrinsics that are libgcc specific (e.g. those intrinsics aren't present in
  39     // libcompiler-rt), so link that in to get that support.
  40     #[link(name = "jemalloc", kind = "static")]
  41     #[cfg_attr(target_os = "android", link(name = "gcc"))]
  42     #[cfg_attr(all(not(windows),
  43                    not(target_os = "android"),
  44                    not(target_env = "musl")),
  45                link(name = "pthread"))]
  46     #[cfg(not(cargobuild))]
  47     extern "C" {}
  48
  49     // Note that the symbols here are prefixed by default on OSX and Windows (we
  50     // don't explicitly request it), and on Android and DragonFly we explicitly
  51     // request it as unprefixing cause segfaults (mismatches in allocators).
  52     extern "C" {
  53         #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
  54                        target_os = "dragonfly", target_os = "windows"),
  55                    link_name = "je_mallocx")]
  56         fn mallocx(size: size_t, flags: c_int) -> *mut c_void;
  57         #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
  58                        target_os = "dragonfly", target_os = "windows"),
  59                    link_name = "je_rallocx")]
  60         fn rallocx(ptr: *mut c_void, size: size_t, flags: c_int) -> *mut c_void;
  61         #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
  62                        target_os = "dragonfly", target_os = "windows"),
  63                    link_name = "je_xallocx")]
  64         fn xallocx(ptr: *mut c_void, size: size_t, extra: size_t, flags: c_int) -> size_t;
  65         #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
  66                        target_os = "dragonfly", target_os = "windows"),
  67                    link_name = "je_sdallocx")]
  68         fn sdallocx(ptr: *mut c_void, size: size_t, flags: c_int);
  69         #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
  70                        target_os = "dragonfly", target_os = "windows"),
  71                    link_name = "je_nallocx")]
  72         fn nallocx(size: size_t, flags: c_int) -> size_t;
  73     }
  74
  75     // The minimum alignment guaranteed by the architecture. This value is used to
  76     // add fast paths for low alignment values. In practice, the alignment is a
  77     // constant at the call site and the branch will be optimized out.
  78     #[cfg(all(any(target_arch = "arm",
  79                   target_arch = "mips",
  80                   target_arch = "powerpc")))]
  81     const MIN_ALIGN: usize = 8;
  82     #[cfg(all(any(target_arch = "x86",
  83                   target_arch = "x86_64",
  84                   target_arch = "aarch64",
  85                   target_arch = "powerpc64",
  86                   target_arch = "mips64",
  87                   target_arch = "s390x")))]
  88     const MIN_ALIGN: usize = 16;
  89
  90     // MALLOCX_ALIGN(a) macro
  91     fn mallocx_align(a: usize) -> c_int {
  92         a.trailing_zeros() as c_int
  93     }
  94
  95     fn align_to_flags(align: usize) -> c_int {
  96         if align <= MIN_ALIGN {
  97             0
  98         } else {
  99             mallocx_align(align)
 100         }
 101     }
 102
 103     #[no_mangle]
 104     pub extern "C" fn __rust_allocate(size: usize, align: usize) -> *mut u8 {
 105         let flags = align_to_flags(align);
 106         unsafe { mallocx(size as size_t, flags) as *mut u8 }
 107     }
 108
 109     #[no_mangle]
 110     pub extern "C" fn __rust_reallocate(ptr: *mut u8,
 111                                         _old_size: usize,
 112                                         size: usize,
 113                                         align: usize)
 114                                         -> *mut u8 {
 115         let flags = align_to_flags(align);
 116         unsafe { rallocx(ptr as *mut c_void, size as size_t, flags) as *mut u8 }
 117     }
 118
 119     #[no_mangle]
 120     pub extern "C" fn __rust_reallocate_inplace(ptr: *mut u8,
 121                                                 _old_size: usize,
 122                                                 size: usize,
 123                                                 align: usize)
 124                                                 -> usize {
 125         let flags = align_to_flags(align);
 126         unsafe { xallocx(ptr as *mut c_void, size as size_t, 0, flags) as usize }
 127     }
 128
 129     #[no_mangle]
 130     pub extern "C" fn __rust_deallocate(ptr: *mut u8, old_size: usize, align: usize) {
 131         let flags = align_to_flags(align);
 132         unsafe { sdallocx(ptr as *mut c_void, old_size as size_t, flags) }
 133     }
 134
 135     #[no_mangle]
 136     pub extern "C" fn __rust_usable_size(size: usize, align: usize) -> usize {
 137         let flags = align_to_flags(align);
 138         unsafe { nallocx(size as size_t, flags) as usize }
 139     }
 140
 141     // These symbols are used by jemalloc on android but the really old android
 142     // we're building on doesn't have them defined, so just make sure the symbols
 143     // are available.
 144     #[no_mangle]
 145     #[cfg(target_os = "android")]
 146     pub extern "C" fn pthread_atfork(_prefork: *mut u8,
 147                                      _postfork_parent: *mut u8,
 148                                      _postfork_child: *mut u8)
 149                                      -> i32 {
 150         0
 151     }
 152 }
 153
 154 #[cfg(dummy_jemalloc)]
 155 mod imp {
 156     fn bogus() -> ! {
 157         panic!("jemalloc is not implemented for this platform");
 158     }
 159
 160     #[no_mangle]
 161     pub extern "C" fn __rust_allocate(_size: usize, _align: usize) -> *mut u8 {
 162         bogus()
 163     }
 164
 165     #[no_mangle]
 166     pub extern "C" fn __rust_reallocate(_ptr: *mut u8,
 167                                         _old_size: usize,
 168                                         _size: usize,
 169                                         _align: usize)
 170                                         -> *mut u8 {
 171         bogus()
 172     }
 173
 174     #[no_mangle]
 175     pub extern "C" fn __rust_reallocate_inplace(_ptr: *mut u8,
 176                                                 _old_size: usize,
 177                                                 _size: usize,
 178                                                 _align: usize)
 179                                                 -> usize {
 180         bogus()
 181     }
 182
 183     #[no_mangle]
 184     pub extern "C" fn __rust_deallocate(_ptr: *mut u8, _old_size: usize, _align: usize) {
 185         bogus()
 186     }
 187
 188     #[no_mangle]
 189     pub extern "C" fn __rust_usable_size(_size: usize, _align: usize) -> usize {
 190         bogus()
 191     }
 192 }