mirror of
https://github.com/rust-lang/rust.git
synced 2025-05-12 09:57:43 +00:00
093b075d32
This is the first (known) step towards starting to use `unix_sigpipe` in the wild. Eventually, `rustc_driver::set_sigpipe_handler` can be removed and all clients can use `unix_sigpipe` instead. For now we just start using `unix_sigpipe` in once place: `rustc` itself. It is easy to manually verify this change. If you remove `#[unix_sigpipe = "sig_dfl"]` and run `./x.py build` you will get an ICE when you do `./build/x86_64-unknown-linux-gnu/stage1/bin/rustc --help | false`. Add back `#[unix_sigpipe = "sig_dfl"]` and the ICE disappears again.
66 lines
2.9 KiB
Rust
66 lines
2.9 KiB
Rust
#![feature(unix_sigpipe)]
|
|
|
|
// A note about jemalloc: rustc uses jemalloc when built for CI and
|
|
// distribution. The obvious way to do this is with the `#[global_allocator]`
|
|
// mechanism. However, for complicated reasons (see
|
|
// https://github.com/rust-lang/rust/pull/81782#issuecomment-784438001 for some
|
|
// details) that mechanism doesn't work here. Also, we must use a consistent
|
|
// allocator across the rustc <-> llvm boundary, and `#[global_allocator]`
|
|
// wouldn't provide that.
|
|
//
|
|
// Instead, we use a lower-level mechanism. rustc is linked with jemalloc in a
|
|
// way such that jemalloc's implementation of `malloc`, `free`, etc., override
|
|
// the libc allocator's implementation. This means that Rust's `System`
|
|
// allocator, which calls `libc::malloc()` et al., is actually calling into
|
|
// jemalloc.
|
|
//
|
|
// A consequence of not using `GlobalAlloc` (and the `tikv-jemallocator` crate
|
|
// provides an impl of that trait, which is called `Jemalloc`) is that we
|
|
// cannot use the sized deallocation APIs (`sdallocx`) that jemalloc provides.
|
|
// It's unclear how much performance is lost because of this.
|
|
//
|
|
// As for the symbol overrides in `main` below: we're pulling in a static copy
|
|
// of jemalloc. We need to actually reference its symbols for it to get linked.
|
|
// The two crates we link to here, `std` and `rustc_driver`, are both dynamic
|
|
// libraries. So we must reference jemalloc symbols one way or another, because
|
|
// this file is the only object code in the rustc executable.
|
|
|
|
#[unix_sigpipe = "sig_dfl"]
|
|
fn main() {
|
|
// See the comment at the top of this file for an explanation of this.
|
|
#[cfg(feature = "jemalloc-sys")]
|
|
{
|
|
use std::os::raw::{c_int, c_void};
|
|
|
|
#[used]
|
|
static _F1: unsafe extern "C" fn(usize, usize) -> *mut c_void = jemalloc_sys::calloc;
|
|
#[used]
|
|
static _F2: unsafe extern "C" fn(*mut *mut c_void, usize, usize) -> c_int =
|
|
jemalloc_sys::posix_memalign;
|
|
#[used]
|
|
static _F3: unsafe extern "C" fn(usize, usize) -> *mut c_void = jemalloc_sys::aligned_alloc;
|
|
#[used]
|
|
static _F4: unsafe extern "C" fn(usize) -> *mut c_void = jemalloc_sys::malloc;
|
|
#[used]
|
|
static _F5: unsafe extern "C" fn(*mut c_void, usize) -> *mut c_void = jemalloc_sys::realloc;
|
|
#[used]
|
|
static _F6: unsafe extern "C" fn(*mut c_void) = jemalloc_sys::free;
|
|
|
|
// On OSX, jemalloc doesn't directly override malloc/free, but instead
|
|
// registers itself with the allocator's zone APIs in a ctor. However,
|
|
// the linker doesn't seem to consider ctors as "used" when statically
|
|
// linking, so we need to explicitly depend on the function.
|
|
#[cfg(target_os = "macos")]
|
|
{
|
|
extern "C" {
|
|
fn _rjem_je_zone_register();
|
|
}
|
|
|
|
#[used]
|
|
static _F7: unsafe extern "C" fn() = _rjem_je_zone_register;
|
|
}
|
|
}
|
|
|
|
rustc_driver::main()
|
|
}
|