From 89d9ce4ec3c134ab62e9eea18a9620face8f88b7 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 15 Oct 2017 21:39:16 +0300 Subject: [PATCH] Don't use target's linker when linking build scripts --- src/bootstrap/bin/rustc.rs | 17 +++++++++------- src/bootstrap/bin/rustdoc.rs | 2 +- src/bootstrap/builder.rs | 12 ++++++----- src/bootstrap/check.rs | 13 ++++++------ src/bootstrap/lib.rs | 30 +++++++++------------------- src/tools/compiletest/src/runtest.rs | 3 +++ 6 files changed, 36 insertions(+), 41 deletions(-) diff --git a/src/bootstrap/bin/rustc.rs b/src/bootstrap/bin/rustc.rs index e496ce27f501a..aeeda85e924ef 100644 --- a/src/bootstrap/bin/rustc.rs +++ b/src/bootstrap/bin/rustc.rs @@ -120,6 +120,11 @@ fn main() { cmd.arg("-L").arg(&root); } + // Override linker if necessary. + if let Ok(target_linker) = env::var("RUSTC_TARGET_LINKER") { + cmd.arg(format!("-Clinker={}", target_linker)); + } + // Pass down incremental directory, if any. if let Ok(dir) = env::var("RUSTC_INCREMENTAL") { cmd.arg(format!("-Zincremental={}", dir)); @@ -246,13 +251,11 @@ fn main() { if env::var_os("RUSTC_FORCE_UNSTABLE").is_some() { cmd.arg("-Z").arg("force-unstable-if-unmarked"); } - } - - // Pass down extra flags, commonly used to configure `-Clinker`. - // Linker options should be set for build scripts as well, - // can't link a build script executable without a linker! - if let Ok(s) = env::var("RUSTC_FLAGS") { - cmd.args(&s.split(" ").filter(|s| !s.is_empty()).collect::>()); + } else { + // Override linker if necessary. + if let Ok(host_linker) = env::var("RUSTC_HOST_LINKER") { + cmd.arg(format!("-Clinker={}", host_linker)); + } } let color = match env::var("RUSTC_COLOR") { diff --git a/src/bootstrap/bin/rustdoc.rs b/src/bootstrap/bin/rustdoc.rs index 2105797a83037..4e975adc9721c 100644 --- a/src/bootstrap/bin/rustdoc.rs +++ b/src/bootstrap/bin/rustdoc.rs @@ -47,7 +47,7 @@ fn main() { if env::var_os("RUSTC_FORCE_UNSTABLE").is_some() { cmd.arg("-Z").arg("force-unstable-if-unmarked"); } - if let Some(linker) = env::var_os("RUSTDOC_LINKER") { + if let Some(linker) = env::var_os("RUSTC_TARGET_LINKER") { cmd.arg("--linker").arg(linker).arg("-Z").arg("unstable-options"); } diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs index ef4f8f78b0d0a..6480b5a619c03 100644 --- a/src/bootstrap/builder.rs +++ b/src/bootstrap/builder.rs @@ -420,7 +420,7 @@ impl<'a> Builder<'a> { .env("RUSTDOC_REAL", self.rustdoc(host)) .env("RUSTDOC_CRATE_VERSION", self.build.rust_version()); if let Some(linker) = self.build.linker(host) { - cmd.env("RUSTDOC_LINKER", linker); + cmd.env("RUSTC_TARGET_LINKER", linker); } cmd } @@ -484,11 +484,13 @@ impl<'a> Builder<'a> { } else { PathBuf::from("/path/to/nowhere/rustdoc/not/required") }) - .env("TEST_MIRI", self.config.test_miri.to_string()) - .env("RUSTC_FLAGS", self.rustc_flags(target).join(" ")); + .env("TEST_MIRI", self.config.test_miri.to_string()); - if let Some(linker) = self.build.linker(target) { - cargo.env("RUSTDOC_LINKER", linker); + if let Some(host_linker) = self.build.linker(compiler.host) { + cargo.env("RUSTC_HOST_LINKER", host_linker); + } + if let Some(target_linker) = self.build.linker(target) { + cargo.env("RUSTC_TARGET_LINKER", target_linker); } if mode != Mode::Tool { diff --git a/src/bootstrap/check.rs b/src/bootstrap/check.rs index d9b0ff4c7a445..d9ee63eef8cdd 100644 --- a/src/bootstrap/check.rs +++ b/src/bootstrap/check.rs @@ -725,9 +725,6 @@ impl Step for Compiletest { // Avoid depending on rustdoc when we don't need it. if mode == "rustdoc" || mode == "run-make" { cmd.arg("--rustdoc-path").arg(builder.rustdoc(compiler.host)); - if let Some(linker) = build.linker(target) { - cmd.arg("--linker").arg(linker); - } } cmd.arg("--src-base").arg(build.src.join("src/test").join(suite)); @@ -750,12 +747,14 @@ impl Step for Compiletest { flags.push("-g".to_string()); } - let mut hostflags = build.rustc_flags(compiler.host); - hostflags.extend(flags.clone()); + if let Some(linker) = build.linker(target) { + cmd.arg("--linker").arg(linker); + } + + let hostflags = flags.clone(); cmd.arg("--host-rustcflags").arg(hostflags.join(" ")); - let mut targetflags = build.rustc_flags(target); - targetflags.extend(flags); + let mut targetflags = flags.clone(); targetflags.push(format!("-Lnative={}", build.test_helpers_out(target).display())); cmd.arg("--target-rustcflags").arg(targetflags.join(" ")); diff --git a/src/bootstrap/lib.rs b/src/bootstrap/lib.rs index 7c599f91838bf..63dc17910f08a 100644 --- a/src/bootstrap/lib.rs +++ b/src/bootstrap/lib.rs @@ -649,10 +649,6 @@ impl Build { self.ar.get(&target).map(|p| &**p) } - fn linker(&self, target: Interned) -> Option<&Path> { - self.config.target_config.get(&target).and_then(|c| c.linker.as_ref().map(|p| &**p)) - } - /// Returns the path to the C++ compiler for the target specified. fn cxx(&self, target: Interned) -> Result<&Path, String> { match self.cxx.get(&target) { @@ -663,24 +659,16 @@ impl Build { } } - /// Returns flags to pass to the compiler to generate code for `target`. - fn rustc_flags(&self, target: Interned) -> Vec { - // New flags should be added here with great caution! - // - // It's quite unfortunate to **require** flags to generate code for a - // target, so it should only be passed here if absolutely necessary! - // Most default configuration should be done through target specs rather - // than an entry here. - - let mut base = Vec::new(); - if let Some(linker) = self.linker(target) { - // If linker was explictly provided, force it on all the compiled Rust code. - base.push(format!("-Clinker={}", linker.display())); - } else if target != self.config.build && !target.contains("msvc") && - !target.contains("emscripten") { - base.push(format!("-Clinker={}", self.cc(target).display())); + /// Returns the path to the linker for the given target if it needs to be overriden. + fn linker(&self, target: Interned) -> Option<&Path> { + if let Some(config) = self.config.target_config.get(&target) { + config.linker.as_ref().map(|p| &**p) + } else if target != self.config.build && + !target.contains("msvc") && !target.contains("emscripten") { + Some(self.cc(target)) + } else { + None } - base } /// Returns if this target should statically link the C runtime, if specified diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs index 6d53c70bff6c1..d61077643f1fe 100644 --- a/src/tools/compiletest/src/runtest.rs +++ b/src/tools/compiletest/src/runtest.rs @@ -1444,6 +1444,9 @@ actual:\n\ } else { rustc.args(self.split_maybe_args(&self.config.target_rustcflags)); } + if let Some(ref linker) = self.config.linker { + rustc.arg(format!("-Clinker={}", linker)); + } rustc.args(&self.props.compile_flags);