path = src/llvm
url = https://github.com/rust-lang/llvm.git
branch = master
-[submodule "src/jemalloc"]
- path = src/jemalloc
- url = https://github.com/rust-lang/jemalloc.git
[submodule "src/rust-installer"]
path = src/tools/rust-installer
url = https://github.com/rust-lang/rust-installer.git
path = src/tools/clang
url = https://github.com/rust-lang-nursery/clang.git
branch = rust-release-80-v1
-
\ No newline at end of file
+
# Adding debuginfo makes them several times larger.
#debuginfo-tools = false
-# Whether or not jemalloc is built and enabled
-#use-jemalloc = true
-
-# Whether or not jemalloc is built with its debug option set
-#debug-jemalloc = false
-
# Whether or not `panic!`s generate backtraces (RUST_BACKTRACE)
#backtrace = true
# not, you can specify an explicit file name for it.
#llvm-filecheck = "/path/to/FileCheck"
-# Path to the custom jemalloc static library to link into the standard library
-# by default. This is only used if jemalloc is still enabled above
-#jemalloc = "/path/to/jemalloc/libjemalloc_pic.a"
-
# If this target is for Android, this option will be required to specify where
# the NDK for the target lives. This is used to find the C compiler to link and
# build native code.
backends = self.get_toml('codegen-backends')
if backends is None or not 'emscripten' in backends:
continue
- if module.endswith("jemalloc"):
- if self.get_toml('use-jemalloc') == 'false':
- continue
- if self.get_toml('jemalloc'):
- continue
if module.endswith("lld"):
config = self.get_toml('lld')
if config is None or config == 'false':
.arg("--manifest-path")
.arg(builder.src.join("src/rustc/compiler_builtins_shim/Cargo.toml"));
} else {
- let mut features = builder.std_features();
-
- // When doing a local rebuild we tell cargo that we're stage1 rather than
- // stage0. This works fine if the local rust and being-built rust have the
- // same view of what the default allocator is, but fails otherwise. Since
- // we don't have a way to express an allocator preference yet, work
- // around the issue in the case of a local rebuild with jemalloc disabled.
- if compiler.stage == 0 && builder.local_rebuild && !builder.config.use_jemalloc {
- features.push_str(" force_alloc_system");
- }
+ let features = builder.std_features();
if compiler.stage != 0 && builder.config.sanitizers {
// This variable is used by the sanitizer runtime crates, e.g.
.arg("--manifest-path")
.arg(builder.src.join("src/libstd/Cargo.toml"));
- if let Some(target) = builder.config.target_config.get(&target) {
- if let Some(ref jemalloc) = target.jemalloc {
- cargo.env("JEMALLOC_OVERRIDE", jemalloc);
- }
- }
if target.contains("musl") {
if let Some(p) = builder.musl_root(target) {
cargo.env("MUSL_ROOT", p);
pub dist_gpg_password_file: Option<PathBuf>,
// libstd features
- pub debug_jemalloc: bool,
- pub use_jemalloc: bool,
pub backtrace: bool, // support for RUST_BACKTRACE
pub wasm_syscall: bool,
pub llvm_config: Option<PathBuf>,
/// Some(path to FileCheck) if one was specified.
pub llvm_filecheck: Option<PathBuf>,
- pub jemalloc: Option<PathBuf>,
pub cc: Option<PathBuf>,
pub cxx: Option<PathBuf>,
pub ar: Option<PathBuf>,
debuginfo_only_std: Option<bool>,
debuginfo_tools: Option<bool>,
experimental_parallel_queries: Option<bool>,
- debug_jemalloc: Option<bool>,
- use_jemalloc: Option<bool>,
backtrace: Option<bool>,
default_linker: Option<String>,
channel: Option<String>,
struct TomlTarget {
llvm_config: Option<String>,
llvm_filecheck: Option<String>,
- jemalloc: Option<String>,
cc: Option<String>,
cxx: Option<String>,
ar: Option<String>,
config.llvm_enabled = true;
config.llvm_optimize = true;
config.llvm_version_check = true;
- config.use_jemalloc = true;
config.backtrace = true;
config.rust_optimize = true;
config.rust_optimize_tests = true;
let mut debuginfo_only_std = None;
let mut debuginfo_tools = None;
let mut debug = None;
- let mut debug_jemalloc = None;
let mut debuginfo = None;
let mut debug_assertions = None;
let mut optimize = None;
debuginfo_tools = rust.debuginfo_tools;
optimize = rust.optimize;
ignore_git = rust.ignore_git;
- debug_jemalloc = rust.debug_jemalloc;
set(&mut config.rust_optimize_tests, rust.optimize_tests);
set(&mut config.rust_debuginfo_tests, rust.debuginfo_tests);
set(&mut config.codegen_tests, rust.codegen_tests);
set(&mut config.rust_rpath, rust.rpath);
- set(&mut config.use_jemalloc, rust.use_jemalloc);
set(&mut config.backtrace, rust.backtrace);
set(&mut config.channel, rust.channel.clone());
set(&mut config.rust_dist_src, rust.dist_src);
if let Some(ref s) = cfg.llvm_filecheck {
target.llvm_filecheck = Some(config.src.join(s));
}
- if let Some(ref s) = cfg.jemalloc {
- target.jemalloc = Some(config.src.join(s));
- }
if let Some(ref s) = cfg.android_ndk {
target.ndk = Some(config.src.join(s));
}
config.rust_debuginfo_tools = debuginfo_tools.unwrap_or(false);
let default = debug == Some(true);
- config.debug_jemalloc = debug_jemalloc.unwrap_or(default);
config.rust_debuginfo = debuginfo.unwrap_or(default);
config.rust_debug_assertions = debug_assertions.unwrap_or(default);
o("debuginfo-lines", "rust.debuginfo-lines", "build with line number debugger metadata")
o("debuginfo-only-std", "rust.debuginfo-only-std", "build only libstd with debugging information")
o("debuginfo-tools", "rust.debuginfo-tools", "build extended tools with debugging information")
-o("debug-jemalloc", "rust.debug-jemalloc", "build jemalloc with --enable-debug --enable-fill")
v("save-toolstates", "rust.save-toolstates", "save build and test status of external tools into this file")
v("prefix", "install.prefix", "set installation prefix")
v("llvm-config", None, "set path to llvm-config")
v("llvm-filecheck", None, "set path to LLVM's FileCheck utility")
v("python", "build.python", "set path to python")
-v("jemalloc-root", None, "set directory where libjemalloc_pic.a is located")
v("android-cross-path", "target.arm-linux-androideabi.android-ndk",
"Android NDK standalone path (deprecated)")
v("i686-linux-android-ndk", "target.i686-linux-android.android-ndk",
# Many of these are saved below during the "writing configuration" step
# (others are conditionally saved).
o("manage-submodules", "build.submodules", "let the build manage the git submodules")
-o("jemalloc", "rust.use-jemalloc", "build liballoc with jemalloc")
o("full-bootstrap", "build.full-bootstrap", "build three compilers instead of two")
o("extended", "build.extended", "build an extended rust tool set")
set('target.{}.llvm-config'.format(build()), value)
elif option.name == 'llvm-filecheck':
set('target.{}.llvm-filecheck'.format(build()), value)
- elif option.name == 'jemalloc-root':
- set('target.{}.jemalloc'.format(build()), value + '/libjemalloc_pic.a')
elif option.name == 'tools':
set('build.tools', value.split(','))
elif option.name == 'host':
"src/build_helper",
"src/dlmalloc",
"src/liballoc",
- "src/liballoc_jemalloc",
"src/liballoc_system",
"src/libbacktrace",
"src/libcompiler_builtins",
"src/rustc/dlmalloc_shim",
"src/libtest",
"src/libterm",
- "src/jemalloc",
"src/libprofiler_builtins",
"src/stdsimd",
"src/libproc_macro",
];
let std_src_dirs_exclude = [
"src/libcompiler_builtins/compiler-rt/test",
- "src/jemalloc/test/unit",
];
copy_src_dirs(builder, &std_src_dirs[..], &std_src_dirs_exclude[..], &dst_src);
fn std_features(&self) -> String {
let mut features = "panic-unwind".to_string();
- if self.config.debug_jemalloc {
- features.push_str(" debug-jemalloc");
- }
- if self.config.use_jemalloc {
- features.push_str(" jemalloc");
- }
if self.config.backtrace {
features.push_str(" backtrace");
}
/// Get the space-separated set of activated features for the compiler.
fn rustc_features(&self) -> String {
- let mut features = String::new();
- if self.config.use_jemalloc {
- features.push_str(" jemalloc");
- }
- features
+ String::new()
}
/// Component directory that Cargo will produce output into (e.g.
// If we're compiling on macOS then we add a few unconditional flags
// indicating that we want libc++ (more filled out than libstdc++) and
// we want to compile for 10.7. This way we can ensure that
- // LLVM/jemalloc/etc are all properly compiled.
+ // LLVM/etc are all properly compiled.
if target.contains("apple-darwin") {
base.push("-stdlib=libc++".into());
}
if !build.config.dry_run {
cmd_finder.must_have(build.cxx(*host).unwrap());
}
-
- // The msvc hosts don't use jemalloc, turn it off globally to
- // avoid packaging the dummy liballoc_jemalloc on that platform.
- if host.contains("msvc") {
- build.config.use_jemalloc = false;
- }
}
// Externally configured LLVM requires FileCheck to exist
type Output = ();
fn should_run(run: ShouldRun) -> ShouldRun {
- run.path("src/liballoc_jemalloc")
- .path("src/librustc_asan")
+ run.path("src/librustc_asan")
.path("src/librustc_lsan")
.path("src/librustc_msan")
.path("src/librustc_tsan")
target: run.target,
test_kind,
krate: match run.path {
- _ if run.path.ends_with("src/liballoc_jemalloc") => "alloc_jemalloc",
_ if run.path.ends_with("src/librustc_asan") => "rustc_asan",
_ if run.path.ends_with("src/librustc_lsan") => "rustc_lsan",
_ if run.path.ends_with("src/librustc_msan") => "rustc_msan",
run = run.krate("test");
for krate in run.builder.in_tree_crates("std") {
if krate.is_local(&run.builder)
- && !krate.name.contains("jemalloc")
&& !(krate.name.starts_with("rustc_") && krate.name.ends_with("san"))
&& krate.name != "dlmalloc"
{
+++ /dev/null
-Subproject commit 1f5a28755e301ac581e2048011e4e0ff3da482ef
use std::alloc::{Global, Alloc, Layout};
/// https://github.com/rust-lang/rust/issues/45955
-///
-/// Note that `#[global_allocator]` is not used,
-/// so `liballoc_jemalloc` is linked (on some platforms).
#[test]
fn alloc_system_overaligned_request() {
check_overalign_requests(System)
+++ /dev/null
-[package]
-authors = ["The Rust Project Developers"]
-name = "alloc_jemalloc"
-version = "0.0.0"
-build = "build.rs"
-links = "jemalloc"
-
-[lib]
-name = "alloc_jemalloc"
-path = "lib.rs"
-test = false
-doc = false
-
-[dependencies]
-core = { path = "../libcore" }
-libc = { path = "../rustc/libc_shim" }
-compiler_builtins = { path = "../rustc/compiler_builtins_shim" }
-
-[build-dependencies]
-build_helper = { path = "../build_helper" }
-cc = "1.0.1"
-
-[features]
-debug = []
+++ /dev/null
-// 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.
-
-#![deny(warnings)]
-
-extern crate build_helper;
-extern crate cc;
-
-use std::env;
-use std::path::PathBuf;
-use std::process::Command;
-use build_helper::{run, native_lib_boilerplate};
-
-fn main() {
- // FIXME: This is a hack to support building targets that don't
- // support jemalloc alongside hosts that do. The jemalloc build is
- // controlled by a feature of the std crate, and if that feature
- // changes between targets, it invalidates the fingerprint of
- // std's build script (this is a cargo bug); so we must ensure
- // that the feature set used by std is the same across all
- // targets, which means we have to build the alloc_jemalloc crate
- // for targets like emscripten, even if we don't use it.
- let target = env::var("TARGET").expect("TARGET was not set");
- let host = env::var("HOST").expect("HOST was not set");
- if target.contains("bitrig") || target.contains("emscripten") || target.contains("fuchsia") ||
- target.contains("msvc") || target.contains("openbsd") || target.contains("redox") ||
- target.contains("rumprun") || target.contains("wasm32") {
- println!("cargo:rustc-cfg=dummy_jemalloc");
- return;
- }
-
- // CloudABI ships with a copy of jemalloc that has been patched to
- // work well with sandboxing. Don't attempt to build our own copy,
- // as it won't build.
- if target.contains("cloudabi") {
- return;
- }
-
- if target.contains("android") {
- println!("cargo:rustc-link-lib=gcc");
- } else if !target.contains("windows") && !target.contains("musl") {
- println!("cargo:rustc-link-lib=pthread");
- }
-
- if let Some(jemalloc) = env::var_os("JEMALLOC_OVERRIDE") {
- let jemalloc = PathBuf::from(jemalloc);
- println!("cargo:rustc-link-search=native={}",
- jemalloc.parent().unwrap().display());
- let stem = jemalloc.file_stem().unwrap().to_str().unwrap();
- let name = jemalloc.file_name().unwrap().to_str().unwrap();
- let kind = if name.ends_with(".a") {
- "static"
- } else {
- "dylib"
- };
- println!("cargo:rustc-link-lib={}={}", kind, &stem[3..]);
- return;
- }
-
- let link_name = if target.contains("windows") { "jemalloc" } else { "jemalloc_pic" };
- let native = match native_lib_boilerplate("jemalloc", "jemalloc", link_name, "lib") {
- Ok(native) => native,
- _ => return,
- };
-
- let mut cmd = Command::new("sh");
- cmd.arg(native.src_dir.join("configure")
- .to_str()
- .unwrap()
- .replace("C:\\", "/c/")
- .replace("\\", "/"))
- .current_dir(&native.out_dir)
- // jemalloc generates Makefile deps using GCC's "-MM" flag. This means
- // that GCC will run the preprocessor, and only the preprocessor, over
- // jemalloc's source files. If we don't specify CPPFLAGS, then at least
- // on ARM that step fails with a "Missing implementation for 32-bit
- // atomic operations" error. This is because no "-march" flag will be
- // passed to GCC, and then GCC won't define the
- // "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4" macro that jemalloc needs to
- // select an atomic operation implementation.
- .env("CPPFLAGS", env::var_os("CFLAGS").unwrap_or_default());
-
- if target.contains("ios") {
- cmd.arg("--disable-tls");
- } else if target.contains("android") {
- // We force android to have prefixed symbols because apparently
- // replacement of the libc allocator doesn't quite work. When this was
- // tested (unprefixed symbols), it was found that the `realpath`
- // function in libc would allocate with libc malloc (not jemalloc
- // malloc), and then the standard library would free with jemalloc free,
- // causing a segfault.
- //
- // If the test suite passes, however, without symbol prefixes then we
- // should be good to go!
- cmd.arg("--with-jemalloc-prefix=je_");
- cmd.arg("--disable-tls");
- } else if target.contains("dragonfly") || target.contains("musl") {
- cmd.arg("--with-jemalloc-prefix=je_");
- }
-
- if cfg!(feature = "debug") {
- // Enable jemalloc assertions.
- cmd.arg("--enable-debug");
- }
-
- cmd.arg(format!("--host={}", build_helper::gnu_target(&target)));
- cmd.arg(format!("--build={}", build_helper::gnu_target(&host)));
-
- // for some reason, jemalloc configure doesn't detect this value
- // automatically for this target
- if target == "sparc64-unknown-linux-gnu" {
- cmd.arg("--with-lg-quantum=4");
- }
-
- run(&mut cmd);
-
- let mut make = Command::new(build_helper::make(&host));
- make.current_dir(&native.out_dir)
- .arg("build_lib_static");
-
- // These are intended for mingw32-make which we don't use
- if cfg!(windows) {
- make.env_remove("MAKEFLAGS").env_remove("MFLAGS");
- }
-
- // mingw make seems... buggy? unclear...
- if !host.contains("windows") {
- make.arg("-j")
- .arg(env::var("NUM_JOBS").expect("NUM_JOBS was not set"));
- }
-
- run(&mut make);
-
- // The pthread_atfork symbols is used by jemalloc on android but the really
- // old android we're building on doesn't have them defined, so just make
- // sure the symbols are available.
- if target.contains("androideabi") {
- println!("cargo:rerun-if-changed=pthread_atfork_dummy.c");
- cc::Build::new()
- .flag("-fvisibility=hidden")
- .file("pthread_atfork_dummy.c")
- .compile("pthread_atfork_dummy");
- }
-}
+++ /dev/null
-// 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.
-
-#![no_std]
-#![allow(unused_attributes)]
-#![unstable(feature = "alloc_jemalloc",
- reason = "implementation detail of std, does not provide any public API",
- issue = "0")]
-#![feature(core_intrinsics)]
-#![feature(libc)]
-#![feature(linkage)]
-#![feature(nll)]
-#![feature(staged_api)]
-#![feature(rustc_attrs)]
-#![cfg_attr(dummy_jemalloc, allow(dead_code, unused_extern_crates))]
-#![cfg_attr(not(dummy_jemalloc), feature(allocator_api))]
-#![rustc_alloc_kind = "exe"]
-
-extern crate libc;
-
-#[cfg(not(dummy_jemalloc))]
-pub use contents::*;
-#[cfg(not(dummy_jemalloc))]
-mod contents {
- use libc::{c_int, c_void, size_t};
-
- // Note that the symbols here are prefixed by default on macOS and Windows (we
- // don't explicitly request it), and on Android and DragonFly we explicitly
- // request it as unprefixing cause segfaults (mismatches in allocators).
- extern "C" {
- #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
- target_os = "dragonfly", target_os = "windows", target_env = "musl"),
- link_name = "je_mallocx")]
- fn mallocx(size: size_t, flags: c_int) -> *mut c_void;
- #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
- target_os = "dragonfly", target_os = "windows", target_env = "musl"),
- link_name = "je_calloc")]
- fn calloc(size: size_t, flags: c_int) -> *mut c_void;
- #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
- target_os = "dragonfly", target_os = "windows", target_env = "musl"),
- link_name = "je_rallocx")]
- fn rallocx(ptr: *mut c_void, size: size_t, flags: c_int) -> *mut c_void;
- #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios",
- target_os = "dragonfly", target_os = "windows", target_env = "musl"),
- link_name = "je_sdallocx")]
- fn sdallocx(ptr: *mut c_void, size: size_t, flags: c_int);
- }
-
- const MALLOCX_ZERO: c_int = 0x40;
-
- // The minimum alignment guaranteed by the architecture. This value is used to
- // add fast paths for low alignment values.
- #[cfg(all(any(target_arch = "arm",
- target_arch = "mips",
- target_arch = "powerpc")))]
- const MIN_ALIGN: usize = 8;
- #[cfg(all(any(target_arch = "x86",
- target_arch = "x86_64",
- target_arch = "aarch64",
- target_arch = "powerpc64",
- target_arch = "mips64",
- target_arch = "s390x",
- target_arch = "sparc64")))]
- const MIN_ALIGN: usize = 16;
-
- // MALLOCX_ALIGN(a) macro
- fn mallocx_align(a: usize) -> c_int {
- a.trailing_zeros() as c_int
- }
-
- fn align_to_flags(align: usize, size: usize) -> c_int {
- if align <= MIN_ALIGN && align <= size {
- 0
- } else {
- mallocx_align(align)
- }
- }
-
- // for symbol names src/librustc/middle/allocator.rs
- // for signatures src/librustc_allocator/lib.rs
-
- // linkage directives are provided as part of the current compiler allocator
- // ABI
-
- #[rustc_std_internal_symbol]
- pub unsafe extern fn __rde_alloc(size: usize, align: usize) -> *mut u8 {
- let flags = align_to_flags(align, size);
- let ptr = mallocx(size as size_t, flags) as *mut u8;
- ptr
- }
-
- #[rustc_std_internal_symbol]
- pub unsafe extern fn __rde_dealloc(ptr: *mut u8,
- size: usize,
- align: usize) {
- let flags = align_to_flags(align, size);
- sdallocx(ptr as *mut c_void, size, flags);
- }
-
- #[rustc_std_internal_symbol]
- pub unsafe extern fn __rde_realloc(ptr: *mut u8,
- _old_size: usize,
- align: usize,
- new_size: usize) -> *mut u8 {
- let flags = align_to_flags(align, new_size);
- let ptr = rallocx(ptr as *mut c_void, new_size, flags) as *mut u8;
- ptr
- }
-
- #[rustc_std_internal_symbol]
- pub unsafe extern fn __rde_alloc_zeroed(size: usize, align: usize) -> *mut u8 {
- let ptr = if align <= MIN_ALIGN && align <= size {
- calloc(size as size_t, 1) as *mut u8
- } else {
- let flags = align_to_flags(align, size) | MALLOCX_ZERO;
- mallocx(size as size_t, flags) as *mut u8
- };
- ptr
- }
-}
+++ /dev/null
-// Copyright 2017 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.
-
-// See comments in build.rs for why this exists
-int pthread_atfork(void* prefork,
- void* postfork_parent,
- void* postfork_child) {
- return 0;
-}
log = "0.4"
rustc_cratesio_shim = { path = "../librustc_cratesio_shim" }
serialize = { path = "../libserialize" }
-
-[features]
-jemalloc = []
dll_suffix: ".dylib".to_string(),
archive_format: "bsd".to_string(),
pre_link_args: LinkArgs::new(),
- exe_allocation_crate: super::maybe_jemalloc(),
has_elf_tls: version >= (10, 7),
abi_return_struct_as_int: true,
emit_debug_gdb_scripts: false,
pre_link_args,
has_elf_tls: false,
eliminate_frame_pointer: false,
- // The following line is a workaround for jemalloc 4.5 being broken on
- // ios. jemalloc 5.0 is supposed to fix this.
- // see https://github.com/rust-lang/rust/issues/45262
- exe_allocation_crate: None,
.. super::apple_base::opts()
})
}
// dynamic linking.
tls_model: "local-exec".to_string(),
relro_level: RelroLevel::Full,
- exe_allocation_crate: super::maybe_jemalloc(),
.. Default::default()
}
}
pre_link_args: args,
position_independent_executables: true,
relro_level: RelroLevel::Full,
- exe_allocation_crate: super::maybe_jemalloc(),
.. Default::default()
}
}
position_independent_executables: true,
eliminate_frame_pointer: false, // FIXME 43575
relro_level: RelroLevel::Full,
- exe_allocation_crate: super::maybe_jemalloc(),
abi_return_struct_as_int: true,
.. Default::default()
}
pre_link_args: args,
position_independent_executables: true,
relro_level: RelroLevel::Full,
- exe_allocation_crate: super::maybe_jemalloc(),
has_elf_tls: true,
.. Default::default()
}
}
}
-fn maybe_jemalloc() -> Option<String> {
- if cfg!(feature = "jemalloc") {
- Some("alloc_jemalloc".to_string())
- } else {
- None
- }
-}
-
/// Either a target triple string or a path to a JSON file.
#[derive(PartialEq, Clone, Debug, Hash, RustcEncodable, RustcDecodable)]
pub enum TargetTriple {
has_rpath: true,
target_family: Some("unix".to_string()),
is_like_solaris: true,
- exe_allocation_crate: super::maybe_jemalloc(),
.. Default::default()
}
[dependencies]
alloc = { path = "../liballoc" }
-alloc_jemalloc = { path = "../liballoc_jemalloc", optional = true }
alloc_system = { path = "../liballoc_system" }
panic_unwind = { path = "../libpanic_unwind", optional = true }
panic_abort = { path = "../libpanic_abort" }
[features]
backtrace = []
-debug-jemalloc = ["alloc_jemalloc/debug"]
-jemalloc = ["alloc_jemalloc"]
-force_alloc_system = []
panic-unwind = ["panic_unwind"]
profiler = ["profiler_builtins"]
//! In a given program, the standard library has one “global” memory allocator
//! that is used for example by `Box<T>` and `Vec<T>`.
//!
-//! Currently the default global allocator is unspecified.
-//! The compiler may link to a version of [jemalloc] on some platforms,
-//! but this is not guaranteed.
-//! Libraries, however, like `cdylib`s and `staticlib`s are guaranteed
-//! to use the [`System`] by default.
+//! Currently the default global allocator is unspecified. Libraries, however,
+//! like `cdylib`s and `staticlib`s are guaranteed to use the [`System`] by
+//! default.
//!
-//! [jemalloc]: https://github.com/jemalloc/jemalloc
//! [`System`]: struct.System.html
//!
//! # The `#[global_allocator]` attribute
#![default_lib_allocator]
-// Always use alloc_system during stage0 since we don't know if the alloc_*
-// crate the stage0 compiler will pick by default is enabled (e.g.
-// if the user has disabled jemalloc in `./configure`).
-// `force_alloc_system` is *only* intended as a workaround for local rebuilds
-// with a rustc without jemalloc.
-// FIXME(#44236) shouldn't need MSVC logic
-#[cfg(all(not(target_env = "msvc"),
- any(all(stage0, not(test)), feature = "force_alloc_system")))]
+#[cfg(stage0)]
#[global_allocator]
static ALLOC: alloc_system::System = alloc_system::System;
[dependencies]
rustc_target = { path = "../librustc_target" }
rustc_driver = { path = "../librustc_driver" }
-
-[features]
-jemalloc = ["rustc_target/jemalloc"]
// This is intentional, this dependency just makes the crate available
// for others later on. Cover cases
- let whitelisted = krate == "alloc_jemalloc";
let whitelisted = whitelisted || krate.starts_with("panic");
if toml.contains("name = \"std\"") && whitelisted {
continue
fn filter_dirs(path: &Path) -> bool {
let skip = [
"src/dlmalloc",
- "src/jemalloc",
"src/llvm",
"src/llvm-emscripten",
"src/libbacktrace",
//! - core may not have platform-specific code
//! - libcompiler_builtins may have platform-specific code
//! - liballoc_system may have platform-specific code
-//! - liballoc_jemalloc may have platform-specific code
//! - libpanic_abort may have platform-specific code
//! - libpanic_unwind may have platform-specific code
//! - libunwind may have platform-specific code
// Paths that may contain platform-specific code
const EXCEPTION_PATHS: &[&str] = &[
// std crates
- "src/liballoc_jemalloc",
"src/liballoc_system",
"src/libcompiler_builtins",
"src/liblibc",
projects / rust.git / commitdiff