nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-26 16:54:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #83587 - petrochenkov:asneeded, r=nagisa

Browse Source 
linker: Use `--as-needed` by default when linker supports it

Do it in a centralized way in `link.rs` instead of individual target specs.
Majority of relevant target specs were already passing it.
This commit is contained in:
bors 2021-03-28 01:00:25 +00:00
commit 3bfc85149e
21 changed files with 30 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
compiler/rustc_codegen_ssa/src/back/link.rs
View File

@ -1651,6 +1651,12 @@ fn linker_with_args<'a, B: ArchiveBuilder<'a>>(
cmd.add_eh_frame_header();
}
// NO-OPT-OUT, OBJECT-FILES-NO
// Avoid linking to dynamic libraries unless they satisfy some undefined symbols
// at the point at which they are specified on the command line.
// Must be passed before any dynamic libraries.
cmd.add_as_needed();
// NO-OPT-OUT, OBJECT-FILES-NO
if crt_objects_fallback {
cmd.no_crt_objects();

7
compiler/rustc_codegen_ssa/src/back/linker.rs
View File

@ -130,6 +130,7 @@ pub trait Linker {
fn group_end(&mut self);
fn linker_plugin_lto(&mut self);
fn add_eh_frame_header(&mut self) {}
fn add_as_needed(&mut self) {}
fn finalize(&mut self);
}
@ -641,6 +642,12 @@ impl<'a> Linker for GccLinker<'a> {
fn add_eh_frame_header(&mut self) {
self.linker_arg("--eh-frame-hdr");
}
fn add_as_needed(&mut self) {
if self.sess.target.linker_is_gnu {
self.linker_arg("--as-needed");
}
}
}
pub struct MsvcLinker<'a> {

19
compiler/rustc_target/src/spec/avr_gnu_base.rs
View File

@ -21,22 +21,9 @@ pub fn target(target_cpu: String) -> Target {
has_rpath: false,
position_independent_executables: false,
eh_frame_header: false,
pre_link_args: vec![(
LinkerFlavor::Gcc,
vec![
format!("-mmcu={}", target_cpu),
// We want to be able to strip as much executable code as possible
// from the linker command line, and this flag indicates to the
// linker that it can avoid linking in dynamic libraries that don't
// actually satisfy any symbols up to that point (as with many other
// resolutions the linker does). This option only applies to all
// following libraries so we're sure to pass it as one of the first
// arguments.
"-Wl,--as-needed".to_string(),
],
)]
.into_iter()
.collect(),
pre_link_args: vec![(LinkerFlavor::Gcc, vec![format!("-mmcu={}", target_cpu)])]
.into_iter()
.collect(),
late_link_args: vec![(LinkerFlavor::Gcc, vec!["-lgcc".to_owned()])]
.into_iter()
.collect(),

5
compiler/rustc_target/src/spec/dragonfly_base.rs
View File

@ -5,11 +5,6 @@ pub fn opts() -> TargetOptions {
args.insert(
LinkerFlavor::Gcc,
vec![
// GNU-style linkers will use this to omit linking to libraries
// which don't actually fulfill any relocations, but only for
// libraries which follow this flag. Thus, use it before
// specifying libraries to link to.
"-Wl,--as-needed".to_string(),
// Always enable NX protection when it is available
"-Wl,-z,noexecstack".to_string(),
],

5
compiler/rustc_target/src/spec/freebsd_base.rs
View File

@ -5,11 +5,6 @@ pub fn opts() -> TargetOptions {
args.insert(
LinkerFlavor::Gcc,
vec![
// GNU-style linkers will use this to omit linking to libraries
// which don't actually fulfill any relocations, but only for
// libraries which follow this flag. Thus, use it before
// specifying libraries to link to.
"-Wl,--as-needed".to_string(),
// Always enable NX protection when it is available
"-Wl,-z,noexecstack".to_string(),
],

2
compiler/rustc_target/src/spec/i686_unknown_netbsd.rs
View File

@ -4,7 +4,7 @@ pub fn target() -> Target {
let mut base = super::netbsd_base::opts();
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m32".to_string());
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".to_string());
base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
Target {

2
compiler/rustc_target/src/spec/i686_wrs_vxworks.rs
View File

@ -4,7 +4,7 @@ pub fn target() -> Target {
let mut base = super::vxworks_base::opts();
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m32".to_string());
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".to_string());
base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
Target {

8
compiler/rustc_target/src/spec/linux_base.rs
View File

@ -5,14 +5,6 @@ pub fn opts() -> TargetOptions {
args.insert(
LinkerFlavor::Gcc,
vec![
// We want to be able to strip as much executable code as possible
// from the linker command line, and this flag indicates to the
// linker that it can avoid linking in dynamic libraries that don't
// actually satisfy any symbols up to that point (as with many other
// resolutions the linker does). This option only applies to all
// following libraries so we're sure to pass it as one of the first
// arguments.
"-Wl,--as-needed".to_string(),
// Always enable NX protection when it is available
"-Wl,-z,noexecstack".to_string(),
],

5
compiler/rustc_target/src/spec/linux_kernel_base.rs
View File

@ -4,10 +4,7 @@ use crate::spec::{
pub fn opts() -> TargetOptions {
let mut pre_link_args = LinkArgs::new();
pre_link_args.insert(
LinkerFlavor::Gcc,
vec!["-Wl,--as-needed".to_string(), "-Wl,-z,noexecstack".to_string()],
);
pre_link_args.insert(LinkerFlavor::Gcc, vec!["-Wl,-z,noexecstack".to_string()]);
TargetOptions {
env: "gnu".to_string(),

15
compiler/rustc_target/src/spec/netbsd_base.rs
View File

@ -1,18 +1,6 @@
use crate::spec::{LinkArgs, LinkerFlavor, RelroLevel, TargetOptions};
use crate::spec::{RelroLevel, TargetOptions};
pub fn opts() -> TargetOptions {
let mut args = LinkArgs::new();
args.insert(
LinkerFlavor::Gcc,
vec![
// GNU-style linkers will use this to omit linking to libraries
// which don't actually fulfill any relocations, but only for
// libraries which follow this flag. Thus, use it before
// specifying libraries to link to.
"-Wl,--as-needed".to_string(),
],
);
TargetOptions {
os: "netbsd".to_string(),
dynamic_linking: true,
@ -21,7 +9,6 @@ pub fn opts() -> TargetOptions {
linker_is_gnu: true,
no_default_libraries: false,
has_rpath: true,
pre_link_args: args,
position_independent_executables: true,
relro_level: RelroLevel::Full,
use_ctors_section: true,

5
compiler/rustc_target/src/spec/openbsd_base.rs
View File

@ -5,11 +5,6 @@ pub fn opts() -> TargetOptions {
args.insert(
LinkerFlavor::Gcc,
vec![
// GNU-style linkers will use this to omit linking to libraries
// which don't actually fulfill any relocations, but only for
// libraries which follow this flag. Thus, use it before
// specifying libraries to link to.
"-Wl,--as-needed".to_string(),
// Always enable NX protection when it is available
"-Wl,-z,noexecstack".to_string(),
],

2
compiler/rustc_target/src/spec/powerpc64_wrs_vxworks.rs
View File

@ -4,7 +4,7 @@ use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> Target {
let mut base = super::vxworks_base::opts();
base.cpu = "ppc64".to_string();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string());
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m64".to_string());
base.max_atomic_width = Some(64);
Target {

2
compiler/rustc_target/src/spec/powerpc_unknown_netbsd.rs
View File

@ -3,7 +3,7 @@ use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> Target {
let mut base = super::netbsd_base::opts();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m32".to_string());
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".to_string());
base.max_atomic_width = Some(32);
Target {

4
compiler/rustc_target/src/spec/powerpc_wrs_vxworks.rs
View File

@ -3,8 +3,8 @@ use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> Target {
let mut base = super::vxworks_base::opts();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m32".to_string());
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("--secure-plt".to_string());
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".to_string());
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("--secure-plt".to_string());
base.max_atomic_width = Some(32);
Target {

4
compiler/rustc_target/src/spec/powerpc_wrs_vxworks_spe.rs
View File

@ -3,8 +3,8 @@ use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> Target {
let mut base = super::vxworks_base::opts();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-mspe".to_string());
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("--secure-plt".to_string());
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-mspe".to_string());
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("--secure-plt".to_string());
base.max_atomic_width = Some(32);
Target {

8
compiler/rustc_target/src/spec/redox_base.rs
View File

@ -5,14 +5,6 @@ pub fn opts() -> TargetOptions {
args.insert(
LinkerFlavor::Gcc,
vec![
// We want to be able to strip as much executable code as possible
// from the linker command line, and this flag indicates to the
// linker that it can avoid linking in dynamic libraries that don't
// actually satisfy any symbols up to that point (as with many other
// resolutions the linker does). This option only applies to all
// following libraries so we're sure to pass it as one of the first
// arguments.
"-Wl,--as-needed".to_string(),
// Always enable NX protection when it is available
"-Wl,-z,noexecstack".to_string(),
],

2
compiler/rustc_target/src/spec/sparc64_unknown_netbsd.rs
View File

@ -4,7 +4,7 @@ use crate::spec::{LinkerFlavor, Target, TargetOptions};
pub fn target() -> Target {
let mut base = super::netbsd_base::opts();
base.cpu = "v9".to_string();
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string());
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m64".to_string());
base.max_atomic_width = Some(64);
Target {

18
compiler/rustc_target/src/spec/vxworks_base.rs
View File

@ -1,21 +1,6 @@
use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions};
use crate::spec::TargetOptions;
pub fn opts() -> TargetOptions {
let mut args = LinkArgs::new();
args.insert(
LinkerFlavor::Gcc,
vec![
// We want to be able to strip as much executable code as possible
// from the linker command line, and this flag indicates to the
// linker that it can avoid linking in dynamic libraries that don't
// actually satisfy any symbols up to that point (as with many other
// resolutions the linker does). This option only applies to all
// following libraries so we're sure to pass it as one of the first
// arguments.
"-Wl,--as-needed".to_string(),
],
);
TargetOptions {
os: "vxworks".to_string(),
env: "gnu".to_string(),
@ -27,7 +12,6 @@ pub fn opts() -> TargetOptions {
os_family: Some("unix".to_string()),
linker_is_gnu: true,
has_rpath: true,
pre_link_args: args,
position_independent_executables: false,
has_elf_tls: true,
crt_static_default: true,

1
compiler/rustc_target/src/spec/x86_64_fortanix_unknown_sgx.rs
View File

@ -4,7 +4,6 @@ use super::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions};
pub fn target() -> Target {
const PRE_LINK_ARGS: &[&str] = &[
"--as-needed",
"-z",
"noexecstack",
"-e",

2
compiler/rustc_target/src/spec/x86_64_unknown_netbsd.rs
View File

@ -4,7 +4,7 @@ pub fn target() -> Target {
let mut base = super::netbsd_base::opts();
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string());
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m64".to_string());
base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
Target {

2
compiler/rustc_target/src/spec/x86_64_wrs_vxworks.rs
View File

@ -4,7 +4,7 @@ pub fn target() -> Target {
let mut base = super::vxworks_base::opts();
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string());
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m64".to_string());
base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
base.disable_redzone = true;