use serde_json;
use crate::dist;
+use crate::builder::Cargo;
use crate::util::{exe, is_dylib};
use crate::{Compiler, Mode, GitRepo};
use crate::native;
return;
}
- builder.ensure(StartupObjects { compiler, target });
+ let mut target_deps = builder.ensure(StartupObjects { compiler, target });
let compiler_to_use = builder.compiler_for(compiler.stage, compiler.host, target);
if compiler_to_use != compiler {
return;
}
- copy_third_party_objects(builder, &compiler, target);
+ target_deps.extend(copy_third_party_objects(builder, &compiler, target).into_iter());
let mut cargo = builder.cargo(compiler, Mode::Std, target, "build");
std_cargo(builder, &compiler, target, &mut cargo);
builder.info(&format!("Building stage{} std artifacts ({} -> {})", compiler.stage,
&compiler.host, target));
run_cargo(builder,
- &mut cargo,
+ cargo,
vec![],
&libstd_stamp(builder, compiler, target),
+ target_deps,
false);
builder.ensure(StdLink {
}
/// Copies third pary objects needed by various targets.
-fn copy_third_party_objects(builder: &Builder<'_>, compiler: &Compiler, target: Interned<String>) {
+fn copy_third_party_objects(builder: &Builder<'_>, compiler: &Compiler, target: Interned<String>)
+ -> Vec<PathBuf>
+{
let libdir = builder.sysroot_libdir(*compiler, target);
+ let mut target_deps = vec![];
+
+ let mut copy_and_stamp = |sourcedir: &Path, name: &str| {
+ let target = libdir.join(name);
+ builder.copy(
+ &sourcedir.join(name),
+ &target,
+ );
+ target_deps.push(target);
+ };
+
// Copies the crt(1,i,n).o startup objects
//
// Since musl supports fully static linking, we can cross link for it even
// files. As those shipped with glibc won't work, copy the ones provided by
// musl so we have them on linux-gnu hosts.
if target.contains("musl") {
+ let srcdir = builder.musl_root(target).unwrap().join("lib");
for &obj in &["crt1.o", "crti.o", "crtn.o"] {
- builder.copy(
- &builder.musl_root(target).unwrap().join("lib").join(obj),
- &libdir.join(obj),
- );
+ copy_and_stamp(&srcdir, obj);
}
} else if target.ends_with("-wasi") {
- for &obj in &["crt1.o"] {
- builder.copy(
- &builder.wasi_root(target).unwrap().join("lib/wasm32-wasi").join(obj),
- &libdir.join(obj),
- );
- }
+ let srcdir = builder.wasi_root(target).unwrap().join("lib/wasm32-wasi");
+ copy_and_stamp(&srcdir, "crt1.o");
}
// Copies libunwind.a compiled to be linked wit x86_64-fortanix-unknown-sgx.
// which is provided by std for this target.
if target == "x86_64-fortanix-unknown-sgx" {
let src_path_env = "X86_FORTANIX_SGX_LIBS";
- let obj = "libunwind.a";
let src = env::var(src_path_env).expect(&format!("{} not found in env", src_path_env));
- let src = Path::new(&src).join(obj);
- builder.copy(&src, &libdir.join(obj));
+ copy_and_stamp(Path::new(&src), "libunwind.a");
}
+
+ target_deps
}
/// Configure cargo to compile the standard library, adding appropriate env vars
pub fn std_cargo(builder: &Builder<'_>,
compiler: &Compiler,
target: Interned<String>,
- cargo: &mut Command) {
+ cargo: &mut Cargo) {
if let Some(target) = env::var_os("MACOSX_STD_DEPLOYMENT_TARGET") {
cargo.env("MACOSX_DEPLOYMENT_TARGET", target);
}
.arg("--manifest-path")
.arg(builder.src.join("src/libtest/Cargo.toml"));
+ // Help the libc crate compile by assisting it in finding various
+ // sysroot native libraries.
if target.contains("musl") {
if let Some(p) = builder.musl_root(target) {
- cargo.env("MUSL_ROOT", p);
+ let root = format!("native={}/lib", p.to_str().unwrap());
+ cargo.rustflag("-L").rustflag(&root);
}
}
if target.ends_with("-wasi") {
if let Some(p) = builder.wasi_root(target) {
- cargo.env("WASI_ROOT", p);
+ let root = format!("native={}/lib/wasm32-wasi", p.to_str().unwrap());
+ cargo.rustflag("-L").rustflag(&root);
}
}
}
}
impl Step for StartupObjects {
- type Output = ();
+ type Output = Vec<PathBuf>;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
run.path("src/rtstartup")
/// They don't require any library support as they're just plain old object
/// files, so we just use the nightly snapshot compiler to always build them (as
/// no other compilers are guaranteed to be available).
- fn run(self, builder: &Builder<'_>) {
+ fn run(self, builder: &Builder<'_>) -> Vec<PathBuf> {
let for_compiler = self.compiler;
let target = self.target;
if !target.contains("windows-gnu") {
- return
+ return vec![]
}
+ let mut target_deps = vec![];
+
let src_dir = &builder.src.join("src/rtstartup");
let dst_dir = &builder.native_dir(target).join("rtstartup");
let sysroot_dir = &builder.sysroot_libdir(for_compiler, target);
.arg(src_file));
}
- builder.copy(dst_file, &sysroot_dir.join(file.to_string() + ".o"));
+ let target = sysroot_dir.join(file.to_string() + ".o");
+ builder.copy(dst_file, &target);
+ target_deps.push(target);
}
for obj in ["crt2.o", "dllcrt2.o"].iter() {
builder.cc(target),
target,
obj);
- builder.copy(&src, &sysroot_dir.join(obj));
+ let target = sysroot_dir.join(obj);
+ builder.copy(&src, &target);
+ target_deps.push(target);
}
+
+ target_deps
}
}
builder.info(&format!("Building stage{} compiler artifacts ({} -> {})",
compiler.stage, &compiler.host, target));
run_cargo(builder,
- &mut cargo,
+ cargo,
vec![],
&librustc_stamp(builder, compiler, target),
+ vec![],
false);
builder.ensure(RustcLink {
}
}
-pub fn rustc_cargo(builder: &Builder<'_>, cargo: &mut Command) {
+pub fn rustc_cargo(builder: &Builder<'_>, cargo: &mut Cargo) {
cargo.arg("--features").arg(builder.rustc_features())
.arg("--manifest-path")
.arg(builder.src.join("src/rustc/Cargo.toml"));
rustc_cargo_env(builder, cargo);
}
-pub fn rustc_cargo_env(builder: &Builder<'_>, cargo: &mut Command) {
+pub fn rustc_cargo_env(builder: &Builder<'_>, cargo: &mut Cargo) {
// Set some configuration variables picked up by build scripts and
// the compiler alike
cargo.env("CFG_RELEASE", builder.rust_release())
cargo.env("CFG_DEFAULT_LINKER", s);
}
if builder.config.rustc_parallel {
- cargo.env("RUSTC_PARALLEL_COMPILER", "1");
+ cargo.rustflag("--cfg=parallel_compiler");
}
if builder.config.rust_verify_llvm_ir {
cargo.env("RUSTC_VERIFY_LLVM_IR", "1");
rustc_cargo_env(builder, &mut cargo);
let features = build_codegen_backend(&builder, &mut cargo, &compiler, target, backend);
+ cargo.arg("--features").arg(features);
let tmp_stamp = out_dir.join(".tmp.stamp");
- let files = run_cargo(builder,
- cargo.arg("--features").arg(features),
- vec![],
- &tmp_stamp,
- false);
+ let files = run_cargo(builder, cargo, vec![], &tmp_stamp, vec![], false);
if builder.config.dry_run {
return;
}
}
pub fn build_codegen_backend(builder: &Builder<'_>,
- cargo: &mut Command,
+ cargo: &mut Cargo,
compiler: &Compiler,
target: Interned<String>,
backend: Interned<String>) -> String {
}
pub fn run_cargo(builder: &Builder<'_>,
- cargo: &mut Command,
+ cargo: Cargo,
tail_args: Vec<String>,
stamp: &Path,
+ additional_target_deps: Vec<PathBuf>,
is_check: bool)
-> Vec<PathBuf>
{
deps.push((path_to_add.into(), false));
}
+ deps.extend(additional_target_deps.into_iter().map(|d| (d, false)));
deps.sort();
let mut new_contents = Vec::new();
for (dep, proc_macro) in deps.iter() {
pub fn stream_cargo(
builder: &Builder<'_>,
- cargo: &mut Command,
+ cargo: Cargo,
tail_args: Vec<String>,
cb: &mut dyn FnMut(CargoMessage<'_>),
) -> bool {
+ let mut cargo = Command::from(cargo);
if builder.config.dry_run {
return true;
}
projects / rust.git / blobdiff