From 91a2aec1d46d0265fb19906cd26a738f1c05a41e Mon Sep 17 00:00:00 2001 From: Urgau Date: Sun, 17 Mar 2024 17:50:21 +0100 Subject: [PATCH 01/13] Introduce `MaybeLazy`(Cow) for 3-way lazy-less --- compiler/rustc_target/src/spec/maybe_lazy.rs | 125 +++++++++++++++++++ compiler/rustc_target/src/spec/mod.rs | 3 + 2 files changed, 128 insertions(+) create mode 100644 compiler/rustc_target/src/spec/maybe_lazy.rs diff --git a/compiler/rustc_target/src/spec/maybe_lazy.rs b/compiler/rustc_target/src/spec/maybe_lazy.rs new file mode 100644 index 0000000000000..201db71d636f0 --- /dev/null +++ b/compiler/rustc_target/src/spec/maybe_lazy.rs @@ -0,0 +1,125 @@ +//! A custom LazyLock+Cow suitable for holding borrowed, owned or lazy data. + +use std::borrow::{Borrow, Cow}; +use std::fmt::{Debug, Display}; +use std::ops::Deref; +use std::sync::LazyLock; + +enum MaybeLazyInner { + Lazy(LazyLock), + Cow(Cow<'static, T>), +} + +/// A custom LazyLock+Cow suitable for holding borrowed, owned or lazy data. +/// +/// Technically this structure has 3 states: borrowed, owned and lazy +/// They can all be constructed from the [`MaybeLazy::borrowed`], [`MaybeLazy::owned`] and +/// [`MaybeLazy::lazy`] methods. +#[repr(transparent)] +pub struct MaybeLazy { + // Inner state. + // + // Not to be inlined since we may want in the future to + // make this struct usable to statics and we might need to + // workaround const-eval limitation (particulary around drop). + inner: MaybeLazyInner, +} + +impl MaybeLazy { + /// Create a [`MaybeLazy`] from an borrowed `T`. + #[inline] + pub const fn borrowed(a: &'static T) -> Self { + MaybeLazy { inner: MaybeLazyInner::Cow(Cow::Borrowed(a)) } + } + + /// Create a [`MaybeLazy`] from an borrowed `T`. + #[inline] + pub const fn owned(a: T::Owned) -> Self { + MaybeLazy { inner: MaybeLazyInner::Cow(Cow::Owned(a)) } + } + + /// Create a [`MaybeLazy`] that is lazy by taking a function pointer. + /// + /// This function pointer cannot *ever* take a closure. User can potentially + /// workaround that by using closure-to-fnptr or `const` items. + #[inline] + pub const fn lazy(a: fn() -> T::Owned) -> Self { + MaybeLazy { inner: MaybeLazyInner::Lazy(LazyLock::new(a)) } + } +} + +impl> Clone for MaybeLazy { + #[inline] + fn clone(&self) -> Self { + MaybeLazy { + inner: MaybeLazyInner::Cow(match &self.inner { + MaybeLazyInner::Lazy(f) => Cow::Owned((*f).to_owned()), + MaybeLazyInner::Cow(c) => c.clone(), + }), + } + } +} + +impl> Default for MaybeLazy { + #[inline] + fn default() -> MaybeLazy { + MaybeLazy::lazy(T::Owned::default) + } +} + +// `Debug`, `Display` and other traits below are implemented in terms of this `Deref` +impl>> Deref for MaybeLazy { + type Target = T; + + #[inline] + fn deref(&self) -> &T { + match &self.inner { + MaybeLazyInner::Lazy(f) => (&**f).borrow(), + MaybeLazyInner::Cow(c) => &*c, + } + } +} + +impl + Debug> Debug for MaybeLazy { + #[inline] + fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + Debug::fmt(&**self, fmt) + } +} + +impl + Display> Display for MaybeLazy { + #[inline] + fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + Display::fmt(&**self, fmt) + } +} + +impl AsRef for MaybeLazy { + #[inline] + fn as_ref(&self) -> &T { + &**self + } +} + +impl + ToOwned, C: ?Sized + ToOwned> PartialEq> + for MaybeLazy +{ + #[inline] + fn eq(&self, other: &MaybeLazy) -> bool { + PartialEq::eq(&**self, &**other) + } +} + +impl PartialEq<&str> for MaybeLazy { + #[inline] + fn eq(&self, other: &&str) -> bool { + &**self == *other + } +} + +impl From<&'static str> for MaybeLazy { + #[inline] + fn from(s: &'static str) -> MaybeLazy { + MaybeLazy::borrowed(s) + } +} diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs index 42860b1059ed7..96aa73cfaf1a3 100644 --- a/compiler/rustc_target/src/spec/mod.rs +++ b/compiler/rustc_target/src/spec/mod.rs @@ -55,6 +55,7 @@ use tracing::debug; pub mod abi; pub mod crt_objects; +pub mod maybe_lazy; mod base; pub use base::apple::deployment_target as current_apple_deployment_target; @@ -62,6 +63,8 @@ pub use base::apple::platform as current_apple_platform; pub use base::apple::sdk_version as current_apple_sdk_version; pub use base::avr_gnu::ef_avr_arch; +use maybe_lazy::MaybeLazy; + /// Linker is called through a C/C++ compiler. #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)] pub enum Cc { From 02942312e02710871194a06004d88bef74581f7f Mon Sep 17 00:00:00 2001 From: Urgau Date: Sun, 17 Mar 2024 20:43:01 +0100 Subject: [PATCH 02/13] Move `TargetOptions::link_args` to `MaybeLazy` - part 1 Replace all the `pre_link_args: TargetOptions::link_args` to `MaybeLazy::lazy(|| TargetOptions::link_args(...))` --- .../rustc_target/src/spec/base/apple/mod.rs | 13 +- .../rustc_target/src/spec/base/avr_gnu.rs | 16 +-- .../rustc_target/src/spec/base/fuchsia.rs | 36 ++--- .../rustc_target/src/spec/base/illumos.rs | 48 ++++--- compiler/rustc_target/src/spec/base/msvc.rs | 5 +- compiler/rustc_target/src/spec/base/teeos.rs | 17 ++- compiler/rustc_target/src/spec/base/wasm.rs | 11 +- .../rustc_target/src/spec/base/windows_gnu.rs | 134 ++++++++++-------- .../src/spec/base/windows_gnullvm.rs | 24 ++-- .../src/spec/base/windows_uwp_gnu.rs | 39 ++--- compiler/rustc_target/src/spec/mod.rs | 27 ++-- .../src/spec/targets/aarch64_apple_darwin.rs | 15 +- .../src/spec/targets/aarch64_apple_ios.rs | 15 +- .../spec/targets/aarch64_apple_ios_macabi.rs | 15 +- .../src/spec/targets/aarch64_apple_ios_sim.rs | 15 +- .../src/spec/targets/aarch64_apple_tvos.rs | 15 +- .../spec/targets/aarch64_apple_tvos_sim.rs | 15 +- .../spec/targets/aarch64_apple_visionos.rs | 14 +- .../targets/aarch64_apple_visionos_sim.rs | 15 +- .../src/spec/targets/aarch64_apple_watchos.rs | 10 +- .../spec/targets/aarch64_apple_watchos_sim.rs | 15 +- .../src/spec/targets/aarch64_unknown_none.rs | 14 +- .../targets/aarch64_unknown_nto_qnx710.rs | 12 +- .../spec/targets/arm64_32_apple_watchos.rs | 14 +- .../src/spec/targets/arm64e_apple_darwin.rs | 15 +- .../src/spec/targets/arm64e_apple_ios.rs | 15 +- .../spec/targets/arm64ec_pc_windows_msvc.rs | 13 +- .../src/spec/targets/armv6k_nintendo_3ds.rs | 12 +- .../targets/armv7_sony_vita_newlibeabihf.rs | 12 +- .../src/spec/targets/armv7k_apple_watchos.rs | 13 +- .../src/spec/targets/armv7s_apple_ios.rs | 15 +- .../spec/targets/avr_unknown_gnu_atmega328.rs | 2 +- .../targets/csky_unknown_linux_gnuabiv2.rs | 4 +- .../targets/csky_unknown_linux_gnuabiv2hf.rs | 4 +- .../src/spec/targets/i386_apple_ios.rs | 19 ++- .../src/spec/targets/i586_pc_nto_qnx700.rs | 9 +- .../src/spec/targets/i686_apple_darwin.rs | 13 +- .../src/spec/targets/mipsel_sony_psp.rs | 9 +- .../spec/targets/wasm32_unknown_emscripten.rs | 7 +- .../src/spec/targets/x86_64_apple_darwin.rs | 15 +- .../src/spec/targets/x86_64_apple_ios.rs | 15 +- .../spec/targets/x86_64_apple_ios_macabi.rs | 15 +- .../src/spec/targets/x86_64_apple_tvos.rs | 20 ++- .../spec/targets/x86_64_apple_watchos_sim.rs | 15 +- .../targets/x86_64_fortanix_unknown_sgx.rs | 72 +++++----- .../src/spec/targets/x86_64_pc_nto_qnx710.rs | 12 +- .../targets/x86_64_unikraft_linux_musl.rs | 6 +- .../src/spec/targets/x86_64h_apple_darwin.rs | 15 +- 48 files changed, 516 insertions(+), 385 deletions(-) diff --git a/compiler/rustc_target/src/spec/base/apple/mod.rs b/compiler/rustc_target/src/spec/base/apple/mod.rs index 055420090835d..317a7fffb7325 100644 --- a/compiler/rustc_target/src/spec/base/apple/mod.rs +++ b/compiler/rustc_target/src/spec/base/apple/mod.rs @@ -1,6 +1,6 @@ use std::{borrow::Cow, env}; -use crate::spec::{add_link_args, add_link_args_iter}; +use crate::spec::{add_link_args, add_link_args_iter, MaybeLazy}; use crate::spec::{cvs, Cc, DebuginfoKind, FramePointer, LinkArgs, LinkerFlavor, Lld}; use crate::spec::{SplitDebuginfo, StackProbeType, StaticCow, Target, TargetOptions}; @@ -94,7 +94,7 @@ impl TargetAbi { } } -fn pre_link_args(os: &'static str, arch: Arch, abi: TargetAbi) -> LinkArgs { +pub fn pre_link_args(os: &'static str, arch: Arch, abi: TargetAbi) -> LinkArgs { let platform_name: StaticCow = match abi { TargetAbi::Normal => os.into(), TargetAbi::Simulator => format!("{os}-simulator").into(), @@ -140,7 +140,12 @@ fn pre_link_args(os: &'static str, arch: Arch, abi: TargetAbi) -> LinkArgs { args } -pub fn opts(os: &'static str, arch: Arch, abi: TargetAbi) -> TargetOptions { +pub fn opts( + os: &'static str, + arch: Arch, + abi: TargetAbi, + pre_link_args: MaybeLazy, +) -> TargetOptions { TargetOptions { abi: abi.target_abi().into(), os: os.into(), @@ -151,7 +156,7 @@ pub fn opts(os: &'static str, arch: Arch, abi: TargetAbi) -> TargetOptions { // macOS has -dead_strip, which doesn't rely on function_sections function_sections: false, dynamic_linking: true, - pre_link_args: pre_link_args(os, arch, abi), + pre_link_args, families: cvs!["unix"], is_like_osx: true, // LLVM notes that macOS 10.11+ and iOS 9+ default diff --git a/compiler/rustc_target/src/spec/base/avr_gnu.rs b/compiler/rustc_target/src/spec/base/avr_gnu.rs index 211d52f5b07ed..1307b43aa889e 100644 --- a/compiler/rustc_target/src/spec/base/avr_gnu.rs +++ b/compiler/rustc_target/src/spec/base/avr_gnu.rs @@ -1,11 +1,10 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, RelocModel, Target, TargetOptions}; +use crate::spec::{Cc, LinkerFlavor, Lld, MaybeLazy, RelocModel, Target, TargetOptions}; use object::elf; /// A base target for AVR devices using the GNU toolchain. /// /// Requires GNU avr-gcc and avr-binutils on the host system. -/// FIXME: Remove the second parameter when const string concatenation is possible. -pub fn target(target_cpu: &'static str, mmcu: &'static str) -> Target { +pub fn target(target_cpu: &'static str) -> Target { Target { arch: "avr".into(), metadata: crate::spec::TargetMetadata { @@ -24,11 +23,12 @@ pub fn target(target_cpu: &'static str, mmcu: &'static str) -> Target { linker: Some("avr-gcc".into()), eh_frame_header: false, - pre_link_args: TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &[mmcu]), - late_link_args: TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-lgcc"], - ), + pre_link_args: MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mmcu=atmega328"]) + }), + late_link_args: MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-lgcc"]) + }), max_atomic_width: Some(16), atomic_cas: false, relocation_model: RelocModel::Static, diff --git a/compiler/rustc_target/src/spec/base/fuchsia.rs b/compiler/rustc_target/src/spec/base/fuchsia.rs index d1ac22f3a098c..3fbd38223187c 100644 --- a/compiler/rustc_target/src/spec/base/fuchsia.rs +++ b/compiler/rustc_target/src/spec/base/fuchsia.rs @@ -1,5 +1,5 @@ use crate::spec::{ - crt_objects, cvs, Cc, FramePointer, LinkOutputKind, LinkerFlavor, Lld, TargetOptions, + crt_objects, cvs, Cc, FramePointer, LinkOutputKind, LinkerFlavor, Lld, MaybeLazy, TargetOptions, }; pub fn opts() -> TargetOptions { @@ -8,22 +8,24 @@ pub fn opts() -> TargetOptions { // so we only list them for ld/lld. // // https://github.com/llvm/llvm-project/blob/db9322b2066c55254e7691efeab863f43bfcc084/clang/lib/Driver/ToolChains/Fuchsia.cpp#L31 - let pre_link_args = TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &[ - "--build-id", - "--hash-style=gnu", - "-z", - "max-page-size=4096", - "-z", - "now", - "-z", - "rodynamic", - "-z", - "separate-loadable-segments", - "--pack-dyn-relocs=relr", - ], - ); + let pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &[ + "--build-id", + "--hash-style=gnu", + "-z", + "max-page-size=4096", + "-z", + "now", + "-z", + "rodynamic", + "-z", + "separate-loadable-segments", + "--pack-dyn-relocs=relr", + ], + ) + }); TargetOptions { os: "fuchsia".into(), diff --git a/compiler/rustc_target/src/spec/base/illumos.rs b/compiler/rustc_target/src/spec/base/illumos.rs index f0a648b93ad04..41f501b30c0b7 100644 --- a/compiler/rustc_target/src/spec/base/illumos.rs +++ b/compiler/rustc_target/src/spec/base/illumos.rs @@ -1,28 +1,30 @@ -use crate::spec::{cvs, Cc, FramePointer, LinkerFlavor, TargetOptions}; +use crate::spec::{cvs, Cc, FramePointer, LinkerFlavor, MaybeLazy, TargetOptions}; pub fn opts() -> TargetOptions { - let late_link_args = TargetOptions::link_args( - LinkerFlavor::Unix(Cc::Yes), - &[ - // The illumos libc contains a stack unwinding implementation, as - // does libgcc_s. The latter implementation includes several - // additional symbols that are not always in base libc. To force - // the consistent use of just one unwinder, we ensure libc appears - // after libgcc_s in the NEEDED list for the resultant binary by - // ignoring any attempts to add it as a dynamic dependency until the - // very end. - // FIXME: This should be replaced by a more complete and generic - // mechanism for controlling the order of library arguments passed - // to the linker. - "-lc", - // LLVM will insert calls to the stack protector functions - // "__stack_chk_fail" and "__stack_chk_guard" into code in native - // object files. Some platforms include these symbols directly in - // libc, but at least historically these have been provided in - // libssp.so on illumos and Solaris systems. - "-lssp", - ], - ); + let late_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Unix(Cc::Yes), + &[ + // The illumos libc contains a stack unwinding implementation, as + // does libgcc_s. The latter implementation includes several + // additional symbols that are not always in base libc. To force + // the consistent use of just one unwinder, we ensure libc appears + // after libgcc_s in the NEEDED list for the resultant binary by + // ignoring any attempts to add it as a dynamic dependency until the + // very end. + // FIXME: This should be replaced by a more complete and generic + // mechanism for controlling the order of library arguments passed + // to the linker. + "-lc", + // LLVM will insert calls to the stack protector functions + // "__stack_chk_fail" and "__stack_chk_guard" into code in native + // object files. Some platforms include these symbols directly in + // libc, but at least historically these have been provided in + // libssp.so on illumos and Solaris systems. + "-lssp", + ], + ) + }); TargetOptions { os: "illumos".into(), diff --git a/compiler/rustc_target/src/spec/base/msvc.rs b/compiler/rustc_target/src/spec/base/msvc.rs index 44fc376fea084..0a55aa3b5d4e2 100644 --- a/compiler/rustc_target/src/spec/base/msvc.rs +++ b/compiler/rustc_target/src/spec/base/msvc.rs @@ -1,10 +1,11 @@ -use crate::spec::{DebuginfoKind, LinkerFlavor, Lld, SplitDebuginfo, TargetOptions}; +use crate::spec::{DebuginfoKind, LinkerFlavor, Lld, MaybeLazy, SplitDebuginfo, TargetOptions}; use std::borrow::Cow; pub fn opts() -> TargetOptions { // Suppress the verbose logo and authorship debugging output, which would needlessly // clog any log files. - let pre_link_args = TargetOptions::link_args(LinkerFlavor::Msvc(Lld::No), &["/NOLOGO"]); + let pre_link_args = + MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Msvc(Lld::No), &["/NOLOGO"])); TargetOptions { linker_flavor: LinkerFlavor::Msvc(Lld::No), diff --git a/compiler/rustc_target/src/spec/base/teeos.rs b/compiler/rustc_target/src/spec/base/teeos.rs index 38d0a6d73140a..8ef8f767fdb80 100644 --- a/compiler/rustc_target/src/spec/base/teeos.rs +++ b/compiler/rustc_target/src/spec/base/teeos.rs @@ -1,11 +1,16 @@ -use crate::spec::{add_link_args, Cc, LinkerFlavor, Lld, PanicStrategy, RelroLevel, TargetOptions}; +use crate::spec::{ + add_link_args, Cc, LinkerFlavor, Lld, MaybeLazy, PanicStrategy, RelroLevel, TargetOptions, +}; pub fn opts() -> TargetOptions { - let lld_args = &["-zmax-page-size=4096", "-znow", "-ztext", "--execute-only"]; - let cc_args = &["-Wl,-zmax-page-size=4096", "-Wl,-znow", "-Wl,-ztext", "-mexecute-only"]; - - let mut pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), lld_args); - add_link_args(&mut pre_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), cc_args); + let pre_link_args = MaybeLazy::lazy(|| { + let lld_args = &["-zmax-page-size=4096", "-znow", "-ztext", "--execute-only"]; + let cc_args = &["-Wl,-zmax-page-size=4096", "-Wl,-znow", "-Wl,-ztext", "-mexecute-only"]; + let mut pre_link_args = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), lld_args); + add_link_args(&mut pre_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), cc_args); + pre_link_args + }); TargetOptions { os: "teeos".into(), diff --git a/compiler/rustc_target/src/spec/base/wasm.rs b/compiler/rustc_target/src/spec/base/wasm.rs index f237391016e77..e01454d89545a 100644 --- a/compiler/rustc_target/src/spec/base/wasm.rs +++ b/compiler/rustc_target/src/spec/base/wasm.rs @@ -1,6 +1,6 @@ use crate::spec::{ - add_link_args, cvs, Cc, LinkSelfContainedDefault, LinkerFlavor, PanicStrategy, RelocModel, - TargetOptions, TlsModel, + add_link_args, cvs, Cc, LinkSelfContainedDefault, LinkerFlavor, MaybeLazy, PanicStrategy, + RelocModel, TargetOptions, TlsModel, }; pub fn options() -> TargetOptions { @@ -48,8 +48,11 @@ pub fn options() -> TargetOptions { }; } - let mut pre_link_args = TargetOptions::link_args(LinkerFlavor::WasmLld(Cc::No), args!("")); - add_link_args(&mut pre_link_args, LinkerFlavor::WasmLld(Cc::Yes), args!("-Wl,")); + let pre_link_args = MaybeLazy::lazy(|| { + let mut pre_link_args = TargetOptions::link_args(LinkerFlavor::WasmLld(Cc::No), args!("")); + add_link_args(&mut pre_link_args, LinkerFlavor::WasmLld(Cc::Yes), args!("-Wl,")); + pre_link_args + }); TargetOptions { is_like_wasm: true, diff --git a/compiler/rustc_target/src/spec/base/windows_gnu.rs b/compiler/rustc_target/src/spec/base/windows_gnu.rs index 1357de2dad126..79af79fa1b47a 100644 --- a/compiler/rustc_target/src/spec/base/windows_gnu.rs +++ b/compiler/rustc_target/src/spec/base/windows_gnu.rs @@ -1,78 +1,90 @@ -use crate::spec::LinkSelfContainedDefault; use crate::spec::{add_link_args, crt_objects}; use crate::spec::{cvs, Cc, DebuginfoKind, LinkerFlavor, Lld, SplitDebuginfo, TargetOptions}; +use crate::spec::{LinkSelfContainedDefault, MaybeLazy}; use std::borrow::Cow; pub fn opts() -> TargetOptions { - let mut pre_link_args = TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &[ - // Enable ASLR - "--dynamicbase", - // ASLR will rebase it anyway so leaving that option enabled only leads to confusion - "--disable-auto-image-base", - ], - ); - add_link_args( - &mut pre_link_args, - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &[ - // Tell GCC to avoid linker plugins, because we are not bundling - // them with Windows installer, and Rust does its own LTO anyways. - "-fno-use-linker-plugin", - "-Wl,--dynamicbase", - "-Wl,--disable-auto-image-base", - ], - ); + let pre_link_args = MaybeLazy::lazy(|| { + let mut pre_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &[ + // Enable ASLR + "--dynamicbase", + // ASLR will rebase it anyway so leaving that option enabled only leads to confusion + "--disable-auto-image-base", + ], + ); + add_link_args( + &mut pre_link_args, + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &[ + // Tell GCC to avoid linker plugins, because we are not bundling + // them with Windows installer, and Rust does its own LTO anyways. + "-fno-use-linker-plugin", + "-Wl,--dynamicbase", + "-Wl,--disable-auto-image-base", + ], + ); + pre_link_args + }); - // Order of `late_link_args*` was found through trial and error to work with various - // mingw-w64 versions (not tested on the CI). It's expected to change from time to time. - let mingw_libs = &[ - "-lmsvcrt", - "-lmingwex", - "-lmingw32", - "-lgcc", // alas, mingw* libraries above depend on libgcc - // mingw's msvcrt is a weird hybrid import library and static library. - // And it seems that the linker fails to use import symbols from msvcrt - // that are required from functions in msvcrt in certain cases. For example - // `_fmode` that is used by an implementation of `__p__fmode` in x86_64. - // The library is purposely listed twice to fix that. - // - // See https://github.com/rust-lang/rust/pull/47483 for some more details. - "-lmsvcrt", - // Math functions missing in MSVCRT (they are present in UCRT) require - // this dependency cycle: `libmingwex.a` -> `libmsvcrt.a` -> `libmingwex.a`. - "-lmingwex", - "-luser32", - "-lkernel32", - ]; - let mut late_link_args = - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), mingw_libs); - add_link_args(&mut late_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), mingw_libs); + let late_link_args = MaybeLazy::lazy(|| { + // Order of `late_link_args*` was found through trial and error to work with various + // mingw-w64 versions (not tested on the CI). It's expected to change from time to time. + let mingw_libs = &[ + "-lmsvcrt", + "-lmingwex", + "-lmingw32", + "-lgcc", // alas, mingw* libraries above depend on libgcc + // mingw's msvcrt is a weird hybrid import library and static library. + // And it seems that the linker fails to use import symbols from msvcrt + // that are required from functions in msvcrt in certain cases. For example + // `_fmode` that is used by an implementation of `__p__fmode` in x86_64. + // The library is purposely listed twice to fix that. + // + // See https://github.com/rust-lang/rust/pull/47483 for some more details. + "-lmsvcrt", + // Math functions missing in MSVCRT (they are present in UCRT) require + // this dependency cycle: `libmingwex.a` -> `libmsvcrt.a` -> `libmingwex.a`. + "-lmingwex", + "-luser32", + "-lkernel32", + ]; + let mut late_link_args = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), mingw_libs); + add_link_args(&mut late_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), mingw_libs); + late_link_args + }); // If any of our crates are dynamically linked then we need to use // the shared libgcc_s-dw2-1.dll. This is required to support // unwinding across DLL boundaries. - let dynamic_unwind_libs = &["-lgcc_s"]; - let mut late_link_args_dynamic = - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), dynamic_unwind_libs); - add_link_args( - &mut late_link_args_dynamic, - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - dynamic_unwind_libs, - ); + let late_link_args_dynamic = MaybeLazy::lazy(|| { + let dynamic_unwind_libs = &["-lgcc_s"]; + let mut late_link_args_dynamic = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), dynamic_unwind_libs); + add_link_args( + &mut late_link_args_dynamic, + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + dynamic_unwind_libs, + ); + late_link_args_dynamic + }); // If all of our crates are statically linked then we can get away // with statically linking the libgcc unwinding code. This allows // binaries to be redistributed without the libgcc_s-dw2-1.dll // dependency, but unfortunately break unwinding across DLL // boundaries when unwinding across FFI boundaries. - let static_unwind_libs = &["-lgcc_eh", "-l:libpthread.a"]; - let mut late_link_args_static = - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), static_unwind_libs); - add_link_args( - &mut late_link_args_static, - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - static_unwind_libs, - ); + let late_link_args_static = MaybeLazy::lazy(|| { + let static_unwind_libs = &["-lgcc_eh", "-l:libpthread.a"]; + let mut late_link_args_static = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), static_unwind_libs); + add_link_args( + &mut late_link_args_static, + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + static_unwind_libs, + ); + late_link_args_static + }); TargetOptions { os: "windows".into(), diff --git a/compiler/rustc_target/src/spec/base/windows_gnullvm.rs b/compiler/rustc_target/src/spec/base/windows_gnullvm.rs index b1d8e2be5a61f..6755592358342 100644 --- a/compiler/rustc_target/src/spec/base/windows_gnullvm.rs +++ b/compiler/rustc_target/src/spec/base/windows_gnullvm.rs @@ -1,4 +1,6 @@ -use crate::spec::{cvs, Cc, DebuginfoKind, LinkerFlavor, Lld, SplitDebuginfo, TargetOptions}; +use crate::spec::{ + cvs, Cc, DebuginfoKind, LinkerFlavor, Lld, MaybeLazy, SplitDebuginfo, TargetOptions, +}; use std::borrow::Cow; pub fn opts() -> TargetOptions { @@ -6,15 +8,19 @@ pub fn opts() -> TargetOptions { // as a path since it's not added to linker search path by the default. // There were attempts to make it behave like libgcc (so one can just use -l) // but LLVM maintainers rejected it: https://reviews.llvm.org/D51440 - let pre_link_args = TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-nolibc", "--unwindlib=none"], - ); + let pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-nolibc", "--unwindlib=none"], + ) + }); // Order of `late_link_args*` does not matter with LLD. - let late_link_args = TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-lmingw32", "-lmingwex", "-lmsvcrt", "-lkernel32", "-luser32"], - ); + let late_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-lmingw32", "-lmingwex", "-lmsvcrt", "-lkernel32", "-luser32"], + ) + }); TargetOptions { os: "windows".into(), diff --git a/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs b/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs index 17256e18e24e3..00d7d99650bbf 100644 --- a/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs +++ b/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs @@ -1,26 +1,29 @@ -use crate::spec::{add_link_args, base, Cc, LinkArgs, LinkerFlavor, Lld, TargetOptions}; +use crate::spec::{add_link_args, base, Cc, LinkArgs, LinkerFlavor, Lld, MaybeLazy, TargetOptions}; pub fn opts() -> TargetOptions { let base = base::windows_gnu::opts(); - // FIXME: This should be updated for the exception machinery changes from #67502 - // and inherit from `windows_gnu_base`, at least partially. - let mingw_libs = &[ - "-lwinstorecompat", - "-lruntimeobject", - "-lsynchronization", - "-lvcruntime140_app", - "-lucrt", - "-lwindowsapp", - "-lmingwex", - "-lmingw32", - ]; - let mut late_link_args = - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), mingw_libs); - add_link_args(&mut late_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), mingw_libs); + let late_link_args = MaybeLazy::lazy(|| { + // FIXME: This should be updated for the exception machinery changes from #67502 + // and inherit from `windows_gnu_base`, at least partially. + let mingw_libs = &[ + "-lwinstorecompat", + "-lruntimeobject", + "-lsynchronization", + "-lvcruntime140_app", + "-lucrt", + "-lwindowsapp", + "-lmingwex", + "-lmingw32", + ]; + let mut late_link_args = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), mingw_libs); + add_link_args(&mut late_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), mingw_libs); + late_link_args + }); // Reset the flags back to empty until the FIXME above is addressed. - let late_link_args_dynamic = LinkArgs::new(); - let late_link_args_static = LinkArgs::new(); + let late_link_args_dynamic = MaybeLazy::lazy(LinkArgs::new); + let late_link_args_static = MaybeLazy::lazy(LinkArgs::new); TargetOptions { abi: "uwp".into(), diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs index 96aa73cfaf1a3..7a9568a198251 100644 --- a/compiler/rustc_target/src/spec/mod.rs +++ b/compiler/rustc_target/src/spec/mod.rs @@ -2027,24 +2027,24 @@ pub struct TargetOptions { pub link_self_contained: LinkSelfContainedDefault, /// Linker arguments that are passed *before* any user-defined libraries. - pub pre_link_args: LinkArgs, + pub pre_link_args: MaybeLazy, pre_link_args_json: LinkArgsCli, /// Linker arguments that are unconditionally passed after any /// user-defined but before post-link objects. Standard platform /// libraries that should be always be linked to, usually go here. - pub late_link_args: LinkArgs, + pub late_link_args: MaybeLazy, late_link_args_json: LinkArgsCli, /// Linker arguments used in addition to `late_link_args` if at least one /// Rust dependency is dynamically linked. - pub late_link_args_dynamic: LinkArgs, + pub late_link_args_dynamic: MaybeLazy, late_link_args_dynamic_json: LinkArgsCli, /// Linker arguments used in addition to `late_link_args` if all Rust /// dependencies are statically linked. - pub late_link_args_static: LinkArgs, + pub late_link_args_static: MaybeLazy, late_link_args_static_json: LinkArgsCli, /// Linker arguments that are unconditionally passed *after* any /// user-defined libraries. - pub post_link_args: LinkArgs, + pub post_link_args: MaybeLazy, post_link_args_json: LinkArgsCli, /// Optional link script applied to `dylib` and `executable` crate types. @@ -2407,14 +2407,14 @@ impl TargetOptions { self.lld_flavor_json, self.linker_is_gnu_json, ); - for (args, args_json) in [ + for (real_args, args_json) in [ (&mut self.pre_link_args, &self.pre_link_args_json), (&mut self.late_link_args, &self.late_link_args_json), (&mut self.late_link_args_dynamic, &self.late_link_args_dynamic_json), (&mut self.late_link_args_static, &self.late_link_args_static_json), (&mut self.post_link_args, &self.post_link_args_json), ] { - args.clear(); + let mut args = LinkArgs::new(); for (flavor, args_json) in args_json { let linker_flavor = self.linker_flavor.with_cli_hints(*flavor); // Normalize to no lld to avoid asserts. @@ -2425,9 +2425,10 @@ impl TargetOptions { _ => linker_flavor, }; if !args.contains_key(&linker_flavor) { - add_link_args_iter(args, linker_flavor, args_json.iter().cloned()); + add_link_args_iter(&mut args, linker_flavor, args_json.iter().cloned()); } } + *real_args = MaybeLazy::owned(args); } } @@ -2509,15 +2510,15 @@ impl Default for TargetOptions { pre_link_objects_self_contained: Default::default(), post_link_objects_self_contained: Default::default(), link_self_contained: LinkSelfContainedDefault::False, - pre_link_args: LinkArgs::new(), + pre_link_args: MaybeLazy::lazy(LinkArgs::new), pre_link_args_json: LinkArgsCli::new(), - late_link_args: LinkArgs::new(), + late_link_args: MaybeLazy::lazy(LinkArgs::new), late_link_args_json: LinkArgsCli::new(), - late_link_args_dynamic: LinkArgs::new(), + late_link_args_dynamic: MaybeLazy::lazy(LinkArgs::new), late_link_args_dynamic_json: LinkArgsCli::new(), - late_link_args_static: LinkArgs::new(), + late_link_args_static: MaybeLazy::lazy(LinkArgs::new), late_link_args_static_json: LinkArgsCli::new(), - post_link_args: LinkArgs::new(), + post_link_args: MaybeLazy::lazy(LinkArgs::new), post_link_args_json: LinkArgsCli::new(), link_env: cvs![], link_env_remove: cvs![], diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs index 4e2964174f925..4563df9f40244 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs @@ -1,9 +1,12 @@ -use crate::spec::base::apple::{macos_llvm_target, opts, Arch, TargetAbi}; -use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions}; +use crate::spec::base::apple::{macos_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Arm64; - let mut base = opts("macos", arch, TargetAbi::Normal); + const ARCH: Arch = Arch::Arm64; + const OS: &'static str = "macos"; + const ABI: TargetAbi = TargetAbi::Normal; + + let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.cpu = "apple-m1".into(); base.max_atomic_width = Some(128); @@ -14,7 +17,7 @@ pub fn target() -> Target { // Clang automatically chooses a more specific target based on // MACOSX_DEPLOYMENT_TARGET. To enable cross-language LTO to work // correctly, we do too. - llvm_target: macos_llvm_target(arch).into(), + llvm_target: macos_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -23,7 +26,7 @@ pub fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:o-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { mcount: "\u{1}mcount".into(), frame_pointer: FramePointer::NonLeaf, diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs index 20655689772d8..14182d582df87 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs @@ -1,9 +1,12 @@ -use crate::spec::base::apple::{ios_llvm_target, opts, Arch, TargetAbi}; -use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions}; +use crate::spec::base::apple::{ios_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Arm64; - let mut base = opts("ios", arch, TargetAbi::Normal); + const ARCH: Arch = Arch::Arm64; + const OS: &'static str = "ios"; + const ABI: TargetAbi = TargetAbi::Normal; + + let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { @@ -11,7 +14,7 @@ pub fn target() -> Target { // IPHONEOS_DEPLOYMENT_TARGET. // This is required for the target to pick the right // MACH-O commands, so we do too. - llvm_target: ios_llvm_target(arch).into(), + llvm_target: ios_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -20,7 +23,7 @@ pub fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:o-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { features: "+neon,+fp-armv8,+apple-a7".into(), max_atomic_width: Some(128), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs index 4c008f7985e6f..a607130d465c2 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs @@ -1,13 +1,16 @@ -use crate::spec::base::apple::{mac_catalyst_llvm_target, opts, Arch, TargetAbi}; -use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions}; +use crate::spec::base::apple::{mac_catalyst_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Arm64; - let mut base = opts("ios", arch, TargetAbi::MacCatalyst); + const ARCH: Arch = Arch::Arm64; + const OS: &'static str = "ios"; + const ABI: TargetAbi = TargetAbi::MacCatalyst; + + let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::LEAK | SanitizerSet::THREAD; Target { - llvm_target: mac_catalyst_llvm_target(arch).into(), + llvm_target: mac_catalyst_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -16,7 +19,7 @@ pub fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:o-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { features: "+neon,+fp-armv8,+apple-a12".into(), max_atomic_width: Some(128), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs index 4a63abdf5419f..48f6f1b4cbffc 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs @@ -1,9 +1,12 @@ -use crate::spec::base::apple::{ios_sim_llvm_target, opts, Arch, TargetAbi}; -use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions}; +use crate::spec::base::apple::{ios_sim_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Arm64; - let mut base = opts("ios", arch, TargetAbi::Simulator); + const ARCH: Arch = Arch::Arm64; + const OS: &'static str = "ios"; + const ABI: TargetAbi = TargetAbi::Simulator; + + let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { @@ -11,7 +14,7 @@ pub fn target() -> Target { // IPHONEOS_DEPLOYMENT_TARGET. // This is required for the simulator target to pick the right // MACH-O commands, so we do too. - llvm_target: ios_sim_llvm_target(arch).into(), + llvm_target: ios_sim_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -20,7 +23,7 @@ pub fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:o-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { features: "+neon,+fp-armv8,+apple-a7".into(), max_atomic_width: Some(128), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs index 3310e6c9e8a41..96d8dee0ac55d 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs @@ -1,10 +1,13 @@ -use crate::spec::base::apple::{opts, tvos_llvm_target, Arch, TargetAbi}; -use crate::spec::{FramePointer, Target, TargetOptions}; +use crate::spec::base::apple::{opts, pre_link_args, tvos_llvm_target, Arch, TargetAbi}; +use crate::spec::{FramePointer, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Arm64; + const ARCH: Arch = Arch::Arm64; + const OS: &'static str = "tvos"; + const ABI: TargetAbi = TargetAbi::Normal; + Target { - llvm_target: tvos_llvm_target(arch).into(), + llvm_target: tvos_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -13,12 +16,12 @@ pub fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:o-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { features: "+neon,+fp-armv8,+apple-a7".into(), max_atomic_width: Some(128), frame_pointer: FramePointer::NonLeaf, - ..opts("tvos", arch, TargetAbi::Normal) + ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) }, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs index b901c663afaef..66b0689cc065e 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs @@ -1,10 +1,13 @@ -use crate::spec::base::apple::{opts, tvos_sim_llvm_target, Arch, TargetAbi}; -use crate::spec::{FramePointer, Target, TargetOptions}; +use crate::spec::base::apple::{opts, pre_link_args, tvos_sim_llvm_target, Arch, TargetAbi}; +use crate::spec::{FramePointer, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Arm64; + const ARCH: Arch = Arch::Arm64; + const OS: &'static str = "tvos"; + const ABI: TargetAbi = TargetAbi::Normal; + Target { - llvm_target: tvos_sim_llvm_target(arch).into(), + llvm_target: tvos_sim_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -13,12 +16,12 @@ pub fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:o-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { features: "+neon,+fp-armv8,+apple-a7".into(), max_atomic_width: Some(128), frame_pointer: FramePointer::NonLeaf, - ..opts("tvos", arch, TargetAbi::Simulator) + ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) }, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs index b0798e5e4f580..30913513d22a7 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs @@ -1,13 +1,17 @@ -use crate::spec::base::apple::{opts, visionos_llvm_target, Arch, TargetAbi}; +use crate::spec::base::apple::{opts, pre_link_args, visionos_llvm_target, Arch, TargetAbi}; +use crate::spec::maybe_lazy::MaybeLazy; use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Arm64; - let mut base = opts("visionos", arch, TargetAbi::Normal); + const OS: &str = "visionos"; + const ABI: TargetAbi = TargetAbi::Normal; + const ARCH: Arch = Arch::Arm64; + + let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { - llvm_target: visionos_llvm_target(arch).into(), + llvm_target: visionos_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: Some("ARM64 Apple visionOS".into()), tier: Some(3), @@ -16,7 +20,7 @@ pub fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:o-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { features: "+neon,+fp-armv8,+apple-a16".into(), max_atomic_width: Some(128), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs index 7b2d2b6a8e442..b1c8a3d9efa14 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs @@ -1,13 +1,16 @@ -use crate::spec::base::apple::{opts, visionos_sim_llvm_target, Arch, TargetAbi}; -use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions}; +use crate::spec::base::apple::{opts, pre_link_args, visionos_sim_llvm_target, Arch, TargetAbi}; +use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Arm64; - let mut base = opts("visionos", arch, TargetAbi::Simulator); + const OS: &str = "visionos"; + const ABI: TargetAbi = TargetAbi::Simulator; + const ARCH: Arch = Arch::Arm64; + + let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { - llvm_target: visionos_sim_llvm_target(arch).into(), + llvm_target: visionos_sim_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: Some("ARM64 Apple visionOS simulator".into()), tier: Some(3), @@ -16,7 +19,7 @@ pub fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:o-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { features: "+neon,+fp-armv8,+apple-a16".into(), max_atomic_width: Some(128), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos.rs index a00a97a133f60..6ed7d25aa9040 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos.rs @@ -1,8 +1,12 @@ -use crate::spec::base::apple::{opts, Arch, TargetAbi}; -use crate::spec::{Target, TargetOptions}; +use crate::spec::base::apple::{opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { - let base = opts("watchos", Arch::Arm64, TargetAbi::Normal); + const ARCH: Arch = Arch::Arm64; + const OS: &'static str = "watchos"; + const ABI: TargetAbi = TargetAbi::Normal; + + let base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); Target { llvm_target: "aarch64-apple-watchos".into(), metadata: crate::spec::TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs index e2f80b7b7a888..0dbe7f2724605 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs @@ -1,14 +1,17 @@ -use crate::spec::base::apple::{opts, watchos_sim_llvm_target, Arch, TargetAbi}; -use crate::spec::{FramePointer, Target, TargetOptions}; +use crate::spec::base::apple::{opts, pre_link_args, watchos_sim_llvm_target, Arch, TargetAbi}; +use crate::spec::{FramePointer, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Arm64; + const ARCH: Arch = Arch::Arm64; + const OS: &'static str = "watchos"; + const ABI: TargetAbi = TargetAbi::Simulator; + Target { // Clang automatically chooses a more specific target based on // WATCHOS_DEPLOYMENT_TARGET. // This is required for the simulator target to pick the right // MACH-O commands, so we do too. - llvm_target: watchos_sim_llvm_target(arch).into(), + llvm_target: watchos_sim_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -17,12 +20,12 @@ pub fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:o-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { features: "+neon,+fp-armv8,+apple-a7".into(), max_atomic_width: Some(128), frame_pointer: FramePointer::NonLeaf, - ..opts("watchos", arch, TargetAbi::Simulator) + ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) }, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs index 21706aa0b5d85..e7814d6b11f76 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs @@ -7,8 +7,8 @@ // For example, `-C target-cpu=cortex-a53`. use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, Target, - TargetOptions, + Cc, LinkerFlavor, Lld, MaybeLazy, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, + Target, TargetOptions, }; pub fn target() -> Target { @@ -16,10 +16,12 @@ pub fn target() -> Target { linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), linker: Some("rust-lld".into()), // Enable the Cortex-A53 errata 843419 mitigation by default - pre_link_args: TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &["--fix-cortex-a53-843419"], - ), + pre_link_args: MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &["--fix-cortex-a53-843419"], + ) + }), features: "+v8a,+strict-align,+neon,+fp-armv8".into(), supported_sanitizers: SanitizerSet::KCFI | SanitizerSet::KERNELADDRESS, relocation_model: RelocModel::Static, diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_nto_qnx710.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_nto_qnx710.rs index 8e448a2fa9a7a..b3f4539b9195e 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_nto_qnx710.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_nto_qnx710.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { Target { @@ -24,10 +24,12 @@ pub fn target() -> Target { options: TargetOptions { features: "+v8a".into(), max_atomic_width: Some(128), - pre_link_args: TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-Vgcc_ntoaarch64le_cxx"], - ), + pre_link_args: MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-Vgcc_ntoaarch64le_cxx"], + ) + }), env: "nto71".into(), ..base::nto_qnx::opts() }, diff --git a/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs b/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs index 3ca8c9969c2d5..f0d1ac989fec9 100644 --- a/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs +++ b/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs @@ -1,11 +1,15 @@ -use crate::spec::base::apple::{opts, watchos_llvm_target, Arch, TargetAbi}; -use crate::spec::{Target, TargetOptions}; +use crate::spec::base::apple::{opts, pre_link_args, watchos_llvm_target, Arch, TargetAbi}; +use crate::spec::{MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Arm64_32; - let base = opts("watchos", arch, TargetAbi::Normal); + const OS: &str = "watchos"; + const ARCH: Arch = Arch::Arm64_32; + const ABI: TargetAbi = TargetAbi::Normal; + + let base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + Target { - llvm_target: watchos_llvm_target(arch).into(), + llvm_target: watchos_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs index 90be518638e93..9ba6c74ee0a91 100644 --- a/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs @@ -1,9 +1,12 @@ -use crate::spec::base::apple::{macos_llvm_target, opts, Arch, TargetAbi}; -use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions}; +use crate::spec::base::apple::{macos_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Arm64e; - let mut base = opts("macos", arch, TargetAbi::Normal); + const ARCH: Arch = Arch::Arm64e; + const OS: &'static str = "macos"; + const ABI: TargetAbi = TargetAbi::Normal; + + let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.cpu = "apple-m1".into(); base.max_atomic_width = Some(128); @@ -14,7 +17,7 @@ pub fn target() -> Target { // Clang automatically chooses a more specific target based on // MACOSX_DEPLOYMENT_TARGET. To enable cross-language LTO to work // correctly, we do too. - llvm_target: macos_llvm_target(arch).into(), + llvm_target: macos_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -23,7 +26,7 @@ pub fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:o-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { mcount: "\u{1}mcount".into(), frame_pointer: FramePointer::NonLeaf, diff --git a/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs b/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs index 56470d29eae00..05a88f811e427 100644 --- a/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs @@ -1,9 +1,12 @@ -use crate::spec::base::apple::{ios_llvm_target, opts, Arch, TargetAbi}; -use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions}; +use crate::spec::base::apple::{ios_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Arm64e; - let mut base = opts("ios", arch, TargetAbi::Normal); + const ARCH: Arch = Arch::Arm64e; + const OS: &'static str = "ios"; + const ABI: TargetAbi = TargetAbi::Normal; + + let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { @@ -11,7 +14,7 @@ pub fn target() -> Target { // IPHONEOS_DEPLOYMENT_TARGET. // This is required for the target to pick the right // MACH-O commands, so we do too. - llvm_target: ios_llvm_target(arch).into(), + llvm_target: ios_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -20,7 +23,7 @@ pub fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:o-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { features: "+neon,+fp-armv8,+apple-a12,+v8.3a,+pauth".into(), max_atomic_width: Some(128), diff --git a/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs index aedfb88102462..011f38209a6cc 100644 --- a/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs @@ -1,14 +1,15 @@ -use crate::spec::{add_link_args, base, LinkerFlavor, Lld, Target}; +use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_msvc::opts(); base.max_atomic_width = Some(128); base.features = "+v8a,+neon,+fp-armv8".into(); - add_link_args( - &mut base.late_link_args, - LinkerFlavor::Msvc(Lld::No), - &["/machine:arm64ec", "softintrin.lib"], - ); + base.late_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Msvc(Lld::No), + &["/machine:arm64ec", "softintrin.lib"], + ) + }); Target { llvm_target: "arm64ec-pc-windows-msvc".into(), diff --git a/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs b/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs index 9a88277b06364..f8900f68595e4 100644 --- a/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs +++ b/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs @@ -1,14 +1,16 @@ -use crate::spec::{cvs, Cc, LinkerFlavor, Lld, RelocModel, Target, TargetOptions}; +use crate::spec::{cvs, Cc, LinkerFlavor, Lld, MaybeLazy, RelocModel, Target, TargetOptions}; /// A base target for Nintendo 3DS devices using the devkitARM toolchain. /// /// Requires the devkitARM toolchain for 3DS targets on the host system. pub fn target() -> Target { - let pre_link_args = TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-specs=3dsx.specs", "-mtune=mpcore", "-mfloat-abi=hard", "-mtp=soft"], - ); + let pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-specs=3dsx.specs", "-mtune=mpcore", "-mfloat-abi=hard", "-mtp=soft"], + ) + }); Target { llvm_target: "armv6k-none-eabihf".into(), diff --git a/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs index 0730a423f724a..9aa7f6f7c2f18 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs @@ -1,15 +1,17 @@ use crate::abi::Endian; -use crate::spec::{cvs, Cc, LinkerFlavor, Lld, RelocModel, Target, TargetOptions}; +use crate::spec::{cvs, Cc, LinkerFlavor, Lld, MaybeLazy, RelocModel, Target, TargetOptions}; /// A base target for PlayStation Vita devices using the VITASDK toolchain (using newlib). /// /// Requires the VITASDK toolchain on the host system. pub fn target() -> Target { - let pre_link_args = TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-Wl,-q", "-Wl,--pic-veneer"], - ); + let pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-Wl,-q", "-Wl,--pic-veneer"], + ) + }); Target { llvm_target: "thumbv7a-vita-eabihf".into(), diff --git a/compiler/rustc_target/src/spec/targets/armv7k_apple_watchos.rs b/compiler/rustc_target/src/spec/targets/armv7k_apple_watchos.rs index 5c675c22ef511..f802f53729e72 100644 --- a/compiler/rustc_target/src/spec/targets/armv7k_apple_watchos.rs +++ b/compiler/rustc_target/src/spec/targets/armv7k_apple_watchos.rs @@ -1,8 +1,11 @@ -use crate::spec::base::apple::{opts, Arch, TargetAbi}; -use crate::spec::{Target, TargetOptions}; +use crate::spec::base::apple::{opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Armv7k; + const ARCH: Arch = Arch::Armv7k; + const OS: &'static str = "watchos"; + const ABI: TargetAbi = TargetAbi::Normal; + Target { llvm_target: "armv7k-apple-watchos".into(), metadata: crate::spec::TargetMetadata { @@ -13,13 +16,13 @@ pub fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:o-p:32:32-Fi8-i64:64-a:0:32-n32-S128".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { features: "+v7,+vfp4,+neon".into(), max_atomic_width: Some(64), dynamic_linking: false, position_independent_executables: true, - ..opts("watchos", arch, TargetAbi::Normal) + ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) }, } } diff --git a/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs b/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs index 4dd475e3a82da..a00d131d96986 100644 --- a/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs @@ -1,10 +1,13 @@ -use crate::spec::base::apple::{ios_llvm_target, opts, Arch, TargetAbi}; -use crate::spec::{Target, TargetOptions}; +use crate::spec::base::apple::{ios_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::Armv7s; + const ARCH: Arch = Arch::Armv7s; + const OS: &'static str = "ios"; + const ABI: TargetAbi = TargetAbi::Normal; + Target { - llvm_target: ios_llvm_target(arch).into(), + llvm_target: ios_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -13,11 +16,11 @@ pub fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:o-p:32:32-Fi8-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { features: "+v7,+vfp4,+neon".into(), max_atomic_width: Some(64), - ..opts("ios", arch, TargetAbi::Normal) + ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) }, } } diff --git a/compiler/rustc_target/src/spec/targets/avr_unknown_gnu_atmega328.rs b/compiler/rustc_target/src/spec/targets/avr_unknown_gnu_atmega328.rs index bf01413a80adf..2afe598c9f08a 100644 --- a/compiler/rustc_target/src/spec/targets/avr_unknown_gnu_atmega328.rs +++ b/compiler/rustc_target/src/spec/targets/avr_unknown_gnu_atmega328.rs @@ -1,5 +1,5 @@ use crate::spec::{base, Target}; pub fn target() -> Target { - base::avr_gnu::target("atmega328", "-mmcu=atmega328") + base::avr_gnu::target("atmega328") } diff --git a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs index 120c75f528ad9..1baeebbe65b26 100644 --- a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs +++ b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; // This target is for glibc Linux on Csky @@ -13,7 +13,7 @@ pub fn target() -> Target { options: TargetOptions { abi: "abiv2".into(), features: "+2e3,+3e7,+7e10,+cache,+dsp1e2,+dspe60,+e1,+e2,+edsp,+elrw,+hard-tp,+high-registers,+hwdiv,+mp,+mp1e2,+nvic,+trust".into(), - late_link_args: TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-l:libatomic.a"]), + late_link_args: MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-l:libatomic.a"])), max_atomic_width: Some(32), ..base::linux_gnu::opts() }, diff --git a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs index 2856e94ea4a98..ab56c5080163b 100644 --- a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs +++ b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; // This target is for glibc Linux on Csky @@ -14,7 +14,7 @@ pub fn target() -> Target { abi: "abiv2hf".into(), cpu: "ck860fv".into(), features: "+hard-float,+hard-float-abi,+2e3,+3e7,+7e10,+cache,+dsp1e2,+dspe60,+e1,+e2,+edsp,+elrw,+hard-tp,+high-registers,+hwdiv,+mp,+mp1e2,+nvic,+trust".into(), - late_link_args: TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-l:libatomic.a", "-mhard-float"]), + late_link_args: MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-l:libatomic.a", "-mhard-float"])), max_atomic_width: Some(32), ..base::linux_gnu::opts() }, diff --git a/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs b/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs index c03a0974bc1cb..da6d813911902 100644 --- a/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs @@ -1,17 +1,19 @@ -use crate::spec::base::apple::{ios_sim_llvm_target, opts, Arch, TargetAbi}; -use crate::spec::{Target, TargetOptions}; +use crate::spec::base::apple::{ios_sim_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::I386; + const ARCH: Arch = Arch::I386; + const OS: &'static str = "ios"; // i386-apple-ios is a simulator target, even though it isn't declared // that way in the target name like the other ones... - let abi = TargetAbi::Simulator; + const ABI: TargetAbi = TargetAbi::Simulator; + Target { // Clang automatically chooses a more specific target based on // IPHONEOS_DEPLOYMENT_TARGET. // This is required for the target to pick the right // MACH-O commands, so we do too. - llvm_target: ios_sim_llvm_target(arch).into(), + llvm_target: ios_sim_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -22,7 +24,10 @@ pub fn target() -> Target { data_layout: "e-m:o-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i128:128-f64:32:64-f80:128-n8:16:32-S128" .into(), - arch: arch.target_arch(), - options: TargetOptions { max_atomic_width: Some(64), ..opts("ios", arch, abi) }, + arch: ARCH.target_arch(), + options: TargetOptions { + max_atomic_width: Some(64), + ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) + }, } } diff --git a/compiler/rustc_target/src/spec/targets/i586_pc_nto_qnx700.rs b/compiler/rustc_target/src/spec/targets/i586_pc_nto_qnx700.rs index 290ed81ad45d8..8b24977caf1c6 100644 --- a/compiler/rustc_target/src/spec/targets/i586_pc_nto_qnx700.rs +++ b/compiler/rustc_target/src/spec/targets/i586_pc_nto_qnx700.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { Target { @@ -17,10 +17,9 @@ pub fn target() -> Target { options: TargetOptions { cpu: "pentium4".into(), max_atomic_width: Some(64), - pre_link_args: TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-Vgcc_ntox86_cxx"], - ), + pre_link_args: MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-Vgcc_ntox86_cxx"]) + }), env: "nto70".into(), stack_probes: StackProbeType::Inline, ..base::nto_qnx::opts() diff --git a/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs index aea6a1ac4ecea..b9fc916ef0009 100644 --- a/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs @@ -1,10 +1,13 @@ -use crate::spec::base::apple::{macos_llvm_target, opts, Arch, TargetAbi}; -use crate::spec::{Cc, FramePointer, LinkerFlavor, Lld, Target, TargetOptions}; +use crate::spec::base::apple::{macos_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{Cc, FramePointer, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { // ld64 only understands i386 and not i686 - let arch = Arch::I386; - let mut base = opts("macos", arch, TargetAbi::Normal); + const ARCH: Arch = Arch::I386; + const OS: &'static str = "macos"; + const ABI: TargetAbi = TargetAbi::Normal; + + let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.max_atomic_width = Some(64); base.add_pre_link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m32"]); base.frame_pointer = FramePointer::Always; @@ -26,7 +29,7 @@ pub fn target() -> Target { data_layout: "e-m:o-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i128:128-f64:32:64-f80:128-n8:16:32-S128" .into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { mcount: "\u{1}mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs b/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs index fafe14935383d..6dff93778fef3 100644 --- a/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs +++ b/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs @@ -1,13 +1,12 @@ -use crate::spec::{cvs, Cc, LinkerFlavor, Lld, RelocModel, Target, TargetOptions}; +use crate::spec::{cvs, Cc, LinkerFlavor, Lld, MaybeLazy, RelocModel, Target, TargetOptions}; // The PSP has custom linker requirements. const LINKER_SCRIPT: &str = include_str!("./mipsel_sony_psp_linker_script.ld"); pub fn target() -> Target { - let pre_link_args = TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &["--emit-relocs", "--nmagic"], - ); + let pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), &["--emit-relocs", "--nmagic"]) + }); Target { llvm_target: "mipsel-sony-psp".into(), diff --git a/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs b/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs index 195ff46cf9d25..0ff38c420bcb7 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs @@ -1,11 +1,12 @@ use crate::spec::{ - base, cvs, LinkArgs, LinkerFlavor, PanicStrategy, RelocModel, Target, TargetOptions, + base, cvs, LinkArgs, LinkerFlavor, MaybeLazy, PanicStrategy, RelocModel, Target, TargetOptions, }; pub fn target() -> Target { // Reset flags for non-Em flavors back to empty to satisfy sanity checking tests. - let pre_link_args = LinkArgs::new(); - let post_link_args = TargetOptions::link_args(LinkerFlavor::EmCc, &["-sABORTING_MALLOC=0"]); + let pre_link_args = MaybeLazy::lazy(|| LinkArgs::new()); + let post_link_args = + MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::EmCc, &["-sABORTING_MALLOC=0"])); let opts = TargetOptions { os: "emscripten".into(), diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs index 21acd750df2dc..bd1c0f669ec3c 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs @@ -1,10 +1,13 @@ -use crate::spec::base::apple::{macos_llvm_target, opts, Arch, TargetAbi}; -use crate::spec::{Cc, FramePointer, LinkerFlavor, Lld, SanitizerSet}; +use crate::spec::base::apple::{macos_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{Cc, FramePointer, LinkerFlavor, Lld, MaybeLazy, SanitizerSet}; use crate::spec::{Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::X86_64; - let mut base = opts("macos", arch, TargetAbi::Normal); + const ARCH: Arch = Arch::X86_64; + const OS: &'static str = "macos"; + const ABI: TargetAbi = TargetAbi::Normal; + + let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.max_atomic_width = Some(128); // penryn+ supports cmpxchg16b base.frame_pointer = FramePointer::Always; base.add_pre_link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m64"]); @@ -15,7 +18,7 @@ pub fn target() -> Target { // Clang automatically chooses a more specific target based on // MACOSX_DEPLOYMENT_TARGET. To enable cross-language LTO to work // correctly, we do too. - llvm_target: macos_llvm_target(arch).into(), + llvm_target: macos_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -25,7 +28,7 @@ pub fn target() -> Target { pointer_width: 64, data_layout: "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { mcount: "\u{1}mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs index ec61b7967646e..11f22170256df 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs @@ -1,15 +1,18 @@ -use crate::spec::base::apple::{ios_sim_llvm_target, opts, Arch, TargetAbi}; -use crate::spec::{SanitizerSet, Target, TargetOptions}; +use crate::spec::base::apple::{ios_sim_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::X86_64; + const ARCH: Arch = Arch::X86_64; + const OS: &'static str = "ios"; + const ABI: TargetAbi = TargetAbi::Simulator; + // x86_64-apple-ios is a simulator target, even though it isn't declared // that way in the target name like the other ones... - let mut base = opts("ios", arch, TargetAbi::Simulator); + let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { - llvm_target: ios_sim_llvm_target(arch).into(), + llvm_target: ios_sim_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -19,7 +22,7 @@ pub fn target() -> Target { pointer_width: 64, data_layout: "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { max_atomic_width: Some(128), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs index bd967ee972b32..9a71697c5d932 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs @@ -1,13 +1,16 @@ -use crate::spec::base::apple::{mac_catalyst_llvm_target, opts, Arch, TargetAbi}; -use crate::spec::{SanitizerSet, Target, TargetOptions}; +use crate::spec::base::apple::{mac_catalyst_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::X86_64; - let mut base = opts("ios", arch, TargetAbi::MacCatalyst); + const ARCH: Arch = Arch::X86_64; + const OS: &'static str = "ios"; + const ABI: TargetAbi = TargetAbi::MacCatalyst; + + let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::LEAK | SanitizerSet::THREAD; Target { - llvm_target: mac_catalyst_llvm_target(arch).into(), + llvm_target: mac_catalyst_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -17,7 +20,7 @@ pub fn target() -> Target { pointer_width: 64, data_layout: "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { max_atomic_width: Some(128), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs index 55b2e1afcd392..c112f2cd3448a 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs @@ -1,13 +1,16 @@ -use crate::spec::base::apple::{opts, tvos_sim_llvm_target, Arch, TargetAbi}; -use crate::spec::{Target, TargetOptions}; +use crate::spec::base::apple::{opts, pre_link_args, tvos_sim_llvm_target, Arch, TargetAbi}; +use crate::spec::{MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::X86_64; // x86_64-apple-tvos is a simulator target, even though it isn't declared // that way in the target name like the other ones... - let abi = TargetAbi::Simulator; + + const ARCH: Arch = Arch::X86_64; + const OS: &'static str = "tvos"; + const ABI: TargetAbi = TargetAbi::Simulator; + Target { - llvm_target: tvos_sim_llvm_target(arch).into(), + llvm_target: tvos_sim_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -17,7 +20,10 @@ pub fn target() -> Target { pointer_width: 64, data_layout: "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: arch.target_arch(), - options: TargetOptions { max_atomic_width: Some(128), ..opts("tvos", arch, abi) }, + arch: ARCH.target_arch(), + options: TargetOptions { + max_atomic_width: Some(128), + ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) + }, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs index a783eff15b261..91711cf33d6bb 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs @@ -1,10 +1,13 @@ -use crate::spec::base::apple::{opts, watchos_sim_llvm_target, Arch, TargetAbi}; -use crate::spec::{Target, TargetOptions}; +use crate::spec::base::apple::{opts, pre_link_args, watchos_sim_llvm_target, Arch, TargetAbi}; +use crate::spec::{MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::X86_64; + const ARCH: Arch = Arch::X86_64; + const OS: &'static str = "watchos"; + const ABI: TargetAbi = TargetAbi::Simulator; + Target { - llvm_target: watchos_sim_llvm_target(arch).into(), + llvm_target: watchos_sim_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -14,10 +17,10 @@ pub fn target() -> Target { pointer_width: 64, data_layout: "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { max_atomic_width: Some(128), - ..opts("watchos", arch, TargetAbi::Simulator) + ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) }, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs b/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs index 012450e307e7c..67e52d4b966a9 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs @@ -1,42 +1,44 @@ use std::borrow::Cow; -use crate::spec::{cvs, Cc, LinkerFlavor, Lld, Target, TargetOptions}; +use crate::spec::{cvs, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { - let pre_link_args = TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &[ - "-e", - "elf_entry", - "-Bstatic", - "--gc-sections", - "-z", - "text", - "-z", - "norelro", - "--no-undefined", - "--error-unresolved-symbols", - "--no-undefined-version", - "-Bsymbolic", - "--export-dynamic", - // The following symbols are needed by libunwind, which is linked after - // libstd. Make sure they're included in the link. - "-u", - "__rust_abort", - "-u", - "__rust_c_alloc", - "-u", - "__rust_c_dealloc", - "-u", - "__rust_print_err", - "-u", - "__rust_rwlock_rdlock", - "-u", - "__rust_rwlock_unlock", - "-u", - "__rust_rwlock_wrlock", - ], - ); + let pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &[ + "-e", + "elf_entry", + "-Bstatic", + "--gc-sections", + "-z", + "text", + "-z", + "norelro", + "--no-undefined", + "--error-unresolved-symbols", + "--no-undefined-version", + "-Bsymbolic", + "--export-dynamic", + // The following symbols are needed by libunwind, which is linked after + // libstd. Make sure they're included in the link. + "-u", + "__rust_abort", + "-u", + "__rust_c_alloc", + "-u", + "__rust_c_dealloc", + "-u", + "__rust_print_err", + "-u", + "__rust_rwlock_rdlock", + "-u", + "__rust_rwlock_unlock", + "-u", + "__rust_rwlock_wrlock", + ], + ) + }); const EXPORT_SYMBOLS: &[&str] = &[ "sgx_entry", diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_nto_qnx710.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_nto_qnx710.rs index c7169c3d62d54..dceb97b2a7e5c 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_nto_qnx710.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_nto_qnx710.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { Target { @@ -17,10 +17,12 @@ pub fn target() -> Target { cpu: "x86-64".into(), plt_by_default: false, max_atomic_width: Some(64), - pre_link_args: TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-Vgcc_ntox86_64_cxx"], - ), + pre_link_args: MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-Vgcc_ntox86_64_cxx"], + ) + }), env: "nto71".into(), ..base::nto_qnx::opts() }, diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unikraft_linux_musl.rs b/compiler/rustc_target/src/spec/targets/x86_64_unikraft_linux_musl.rs index 8752ba81066e1..dde680a919c85 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unikraft_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unikraft_linux_musl.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { Target { @@ -16,7 +16,9 @@ pub fn target() -> Target { options: TargetOptions { cpu: "x86-64".into(), plt_by_default: false, - pre_link_args: TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]), + pre_link_args: MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }), max_atomic_width: Some(64), stack_probes: StackProbeType::Inline, ..base::unikraft_linux_musl::opts() diff --git a/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs index fe6cbca32c748..bd7c19ff3c6cf 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs @@ -1,10 +1,13 @@ -use crate::spec::base::apple::{macos_llvm_target, opts, Arch, TargetAbi}; -use crate::spec::{Cc, FramePointer, LinkerFlavor, Lld, SanitizerSet}; +use crate::spec::base::apple::{macos_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::{Cc, FramePointer, LinkerFlavor, Lld, MaybeLazy, SanitizerSet}; use crate::spec::{Target, TargetOptions}; pub fn target() -> Target { - let arch = Arch::X86_64h; - let mut base = opts("macos", arch, TargetAbi::Normal); + const ARCH: Arch = Arch::X86_64h; + const OS: &'static str = "macos"; + const ABI: TargetAbi = TargetAbi::Normal; + + let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.max_atomic_width = Some(128); base.frame_pointer = FramePointer::Always; base.add_pre_link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m64"]); @@ -33,7 +36,7 @@ pub fn target() -> Target { // Clang automatically chooses a more specific target based on // MACOSX_DEPLOYMENT_TARGET. To enable cross-language LTO to work // correctly, we do too. - llvm_target: macos_llvm_target(arch).into(), + llvm_target: macos_llvm_target(ARCH).into(), metadata: crate::spec::TargetMetadata { description: None, tier: None, @@ -43,7 +46,7 @@ pub fn target() -> Target { pointer_width: 64, data_layout: "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: arch.target_arch(), + arch: ARCH.target_arch(), options: TargetOptions { mcount: "\u{1}mcount".into(), ..base }, } } From a8ff91b792b44afcf4454ce2c70168df4749a33d Mon Sep 17 00:00:00 2001 From: Urgau Date: Mon, 18 Mar 2024 00:21:07 +0100 Subject: [PATCH 03/13] Move `TargetOptions::link_args` to `MaybeLazy` - part 2 Remove add_pre_link_args and replace it with explicit call to MaybeLazy::lazy(|| TargetOptions::link_args(...)) --- .../rustc_target/src/spec/base/uefi_msvc.rs | 43 ++++++++++--------- .../src/spec/base/windows_uwp_msvc.rs | 6 ++- compiler/rustc_target/src/spec/mod.rs | 4 -- .../spec/targets/aarch64_unknown_illumos.rs | 5 ++- .../src/spec/targets/aarch64_unknown_uefi.rs | 6 ++- .../spec/targets/armv7_linux_androideabi.rs | 6 ++- .../src/spec/targets/i686_apple_darwin.rs | 4 +- .../src/spec/targets/i686_pc_windows_gnu.rs | 20 ++++++--- .../spec/targets/i686_pc_windows_gnullvm.rs | 12 +++--- .../src/spec/targets/i686_pc_windows_msvc.rs | 28 ++++++------ .../src/spec/targets/i686_unknown_freebsd.rs | 6 ++- .../src/spec/targets/i686_unknown_haiku.rs | 6 ++- .../src/spec/targets/i686_unknown_hurd_gnu.rs | 6 ++- .../spec/targets/i686_unknown_linux_gnu.rs | 7 ++- .../spec/targets/i686_unknown_linux_musl.rs | 8 +++- .../src/spec/targets/i686_unknown_netbsd.rs | 6 ++- .../src/spec/targets/i686_unknown_openbsd.rs | 6 ++- .../src/spec/targets/i686_uwp_windows_gnu.rs | 20 ++++++--- .../spec/targets/i686_win7_windows_msvc.rs | 2 +- .../src/spec/targets/i686_wrs_vxworks.rs | 6 ++- .../src/spec/targets/powerpc64_ibm_aix.rs | 12 +++--- .../spec/targets/powerpc64_unknown_freebsd.rs | 6 ++- .../targets/powerpc64_unknown_linux_gnu.rs | 6 ++- .../targets/powerpc64_unknown_linux_musl.rs | 6 ++- .../spec/targets/powerpc64_unknown_openbsd.rs | 6 ++- .../src/spec/targets/powerpc64_wrs_vxworks.rs | 6 ++- .../targets/powerpc64le_unknown_freebsd.rs | 6 ++- .../targets/powerpc64le_unknown_linux_gnu.rs | 6 ++- .../targets/powerpc64le_unknown_linux_musl.rs | 6 ++- .../spec/targets/powerpc_unknown_freebsd.rs | 12 +++--- .../spec/targets/powerpc_unknown_linux_gnu.rs | 6 ++- .../targets/powerpc_unknown_linux_gnuspe.rs | 6 ++- .../targets/powerpc_unknown_linux_musl.rs | 6 ++- .../spec/targets/powerpc_unknown_netbsd.rs | 6 ++- .../src/spec/targets/powerpc_wrs_vxworks.rs | 6 ++- .../spec/targets/powerpc_wrs_vxworks_spe.rs | 6 ++- .../spec/targets/sparc64_unknown_netbsd.rs | 6 ++- .../spec/targets/sparc64_unknown_openbsd.rs | 6 ++- .../spec/targets/sparc_unknown_linux_gnu.rs | 6 ++- .../src/spec/targets/sparcv9_sun_solaris.rs | 5 ++- .../spec/targets/thumbv7a_pc_windows_msvc.rs | 5 ++- .../targets/thumbv7neon_linux_androideabi.rs | 6 ++- .../spec/targets/wasm32_unknown_unknown.rs | 40 +++++++++-------- .../src/spec/targets/wasm32_wasip1.rs | 6 ++- .../src/spec/targets/wasm32_wasip1_threads.rs | 35 +++++++++------ .../spec/targets/wasm64_unknown_unknown.rs | 42 ++++++++++-------- .../src/spec/targets/x86_64_apple_darwin.rs | 4 +- .../src/spec/targets/x86_64_linux_android.rs | 6 ++- .../src/spec/targets/x86_64_pc_solaris.rs | 7 ++- .../src/spec/targets/x86_64_pc_windows_gnu.rs | 19 +++++--- .../spec/targets/x86_64_pc_windows_gnullvm.rs | 6 ++- .../spec/targets/x86_64_unknown_dragonfly.rs | 6 ++- .../spec/targets/x86_64_unknown_freebsd.rs | 8 +++- .../src/spec/targets/x86_64_unknown_haiku.rs | 6 ++- .../spec/targets/x86_64_unknown_illumos.rs | 6 ++- .../spec/targets/x86_64_unknown_linux_gnu.rs | 8 +++- .../targets/x86_64_unknown_linux_gnux32.rs | 6 ++- .../spec/targets/x86_64_unknown_linux_musl.rs | 8 +++- .../spec/targets/x86_64_unknown_linux_ohos.rs | 8 +++- .../src/spec/targets/x86_64_unknown_netbsd.rs | 6 ++- .../spec/targets/x86_64_unknown_openbsd.rs | 6 ++- .../src/spec/targets/x86_64_unknown_redox.rs | 6 ++- .../spec/targets/x86_64_uwp_windows_gnu.rs | 19 +++++--- .../src/spec/targets/x86_64_wrs_vxworks.rs | 6 ++- .../src/spec/targets/x86_64h_apple_darwin.rs | 4 +- 65 files changed, 391 insertions(+), 226 deletions(-) diff --git a/compiler/rustc_target/src/spec/base/uefi_msvc.rs b/compiler/rustc_target/src/spec/base/uefi_msvc.rs index e8acd6078e2ad..432ec2b4b0d16 100644 --- a/compiler/rustc_target/src/spec/base/uefi_msvc.rs +++ b/compiler/rustc_target/src/spec/base/uefi_msvc.rs @@ -9,30 +9,33 @@ // the timer-interrupt. Device-drivers are required to use polling-based models. Furthermore, all // code runs in the same environment, no process separation is supported. -use crate::spec::{base, LinkerFlavor, Lld, PanicStrategy, StackProbeType, TargetOptions}; +use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy}; +use crate::spec::{PanicStrategy, StackProbeType, TargetOptions}; pub fn opts() -> TargetOptions { let mut base = base::msvc::opts(); - base.add_pre_link_args( - LinkerFlavor::Msvc(Lld::No), - &[ - // Non-standard subsystems have no default entry-point in PE+ files. We have to define - // one. "efi_main" seems to be a common choice amongst other implementations and the - // spec. - "/entry:efi_main", - // COFF images have a "Subsystem" field in their header, which defines what kind of - // program it is. UEFI has 3 fields reserved, which are EFI_APPLICATION, - // EFI_BOOT_SERVICE_DRIVER, and EFI_RUNTIME_DRIVER. We default to EFI_APPLICATION, - // which is very likely the most common option. Individual projects can override this - // with custom linker flags. - // The subsystem-type only has minor effects on the application. It defines the memory - // regions the application is loaded into (runtime-drivers need to be put into - // reserved areas), as well as whether a return from the entry-point is treated as - // exit (default for applications). - "/subsystem:efi_application", - ], - ); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Msvc(Lld::No), + &[ + // Non-standard subsystems have no default entry-point in PE+ files. We have to define + // one. "efi_main" seems to be a common choice amongst other implementations and the + // spec. + "/entry:efi_main", + // COFF images have a "Subsystem" field in their header, which defines what kind of + // program it is. UEFI has 3 fields reserved, which are EFI_APPLICATION, + // EFI_BOOT_SERVICE_DRIVER, and EFI_RUNTIME_DRIVER. We default to EFI_APPLICATION, + // which is very likely the most common option. Individual projects can override this + // with custom linker flags. + // The subsystem-type only has minor effects on the application. It defines the memory + // regions the application is loaded into (runtime-drivers need to be put into + // reserved areas), as well as whether a return from the entry-point is treated as + // exit (default for applications). + "/subsystem:efi_application", + ], + ) + }); TargetOptions { os: "uefi".into(), diff --git a/compiler/rustc_target/src/spec/base/windows_uwp_msvc.rs b/compiler/rustc_target/src/spec/base/windows_uwp_msvc.rs index 59a7616712541..d99775b31b6aa 100644 --- a/compiler/rustc_target/src/spec/base/windows_uwp_msvc.rs +++ b/compiler/rustc_target/src/spec/base/windows_uwp_msvc.rs @@ -1,11 +1,13 @@ -use crate::spec::{base, LinkerFlavor, Lld, TargetOptions}; +use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy, TargetOptions}; pub fn opts() -> TargetOptions { let mut opts = base::windows_msvc::opts(); opts.abi = "uwp".into(); opts.vendor = "uwp".into(); - opts.add_pre_link_args(LinkerFlavor::Msvc(Lld::No), &["/APPCONTAINER", "mincore.lib"]); + opts.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Msvc(Lld::No), &["/APPCONTAINER", "mincore.lib"]) + }); opts } diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs index 7a9568a198251..ffc8764eaee93 100644 --- a/compiler/rustc_target/src/spec/mod.rs +++ b/compiler/rustc_target/src/spec/mod.rs @@ -2397,10 +2397,6 @@ impl TargetOptions { link_args } - fn add_pre_link_args(&mut self, flavor: LinkerFlavor, args: &[&'static str]) { - add_link_args(&mut self.pre_link_args, flavor, args); - } - fn update_from_cli(&mut self) { self.linker_flavor = LinkerFlavor::from_cli_json( self.linker_flavor_json, diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_illumos.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_illumos.rs index 6f253c2a22393..7218b62d02b74 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_illumos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_illumos.rs @@ -1,8 +1,9 @@ -use crate::spec::{base, Cc, LinkerFlavor, SanitizerSet, Target}; +use crate::spec::{base, Cc, LinkerFlavor, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::illumos::opts(); - base.add_pre_link_args(LinkerFlavor::Unix(Cc::Yes), &["-std=c99"]); + base.pre_link_args = + MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Unix(Cc::Yes), &["-std=c99"])); base.max_atomic_width = Some(128); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::CFI; base.features = "+v8a".into(); diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_uefi.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_uefi.rs index de4a56ae03da3..989c27da93a06 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_uefi.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_uefi.rs @@ -1,13 +1,15 @@ // This defines the aarch64 target for UEFI systems as described in the UEFI specification. See the // uefi-base module for generic UEFI options. -use crate::spec::{base, LinkerFlavor, Lld, Target}; +use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::uefi_msvc::opts(); base.max_atomic_width = Some(128); - base.add_pre_link_args(LinkerFlavor::Msvc(Lld::No), &["/machine:arm64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Msvc(Lld::No), &["/machine:arm64"]) + }); base.features = "+v8a".into(); Target { diff --git a/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs b/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs index e798ef4735436..b99fb02493d6f 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, SanitizerSet, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, Target, TargetOptions}; // This target if is for the baseline of the Android v7a ABI // in thumb mode. It's named armv7-* instead of thumbv7-* @@ -10,7 +10,9 @@ use crate::spec::{base, Cc, LinkerFlavor, Lld, SanitizerSet, Target, TargetOptio pub fn target() -> Target { let mut base = base::android::opts(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-march=armv7-a"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-march=armv7-a"]) + }); Target { llvm_target: "armv7-none-linux-android".into(), metadata: crate::spec::TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs index b9fc916ef0009..1c1c877a87d59 100644 --- a/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs @@ -9,7 +9,9 @@ pub fn target() -> Target { let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m32"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m32"]) + }); base.frame_pointer = FramePointer::Always; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs index 66e09416dde90..e481edeed2497 100644 --- a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs @@ -1,4 +1,5 @@ -use crate::spec::{base, Cc, FramePointer, LinkerFlavor, Lld, Target}; +use crate::spec::{add_link_args, base, Cc, FramePointer}; +use crate::spec::{LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_gnu::opts(); @@ -9,11 +10,18 @@ pub fn target() -> Target { // Mark all dynamic libraries and executables as compatible with the larger 4GiB address // space available to x86 Windows binaries on x86_64. - base.add_pre_link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &["-m", "i386pe", "--large-address-aware"], - ); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-Wl,--large-address-aware"]); + base.pre_link_args = MaybeLazy::lazy(|| { + let mut pre_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &["-m", "i386pe", "--large-address-aware"], + ); + add_link_args( + &mut pre_link_args, + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-Wl,--large-address-aware"], + ); + pre_link_args + }); Target { llvm_target: "i686-pc-windows-gnu".into(), diff --git a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnullvm.rs b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnullvm.rs index 7a2d28aec9c08..849d540e678fa 100644 --- a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnullvm.rs +++ b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnullvm.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, FramePointer, LinkerFlavor, Lld, Target}; +use crate::spec::{base, Cc, FramePointer, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_gnullvm::opts(); @@ -9,10 +9,12 @@ pub fn target() -> Target { // Mark all dynamic libraries and executables as compatible with the larger 4GiB address // space available to x86 Windows binaries on x86_64. - base.add_pre_link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &["-m", "i386pe", "--large-address-aware"], - ); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &["-m", "i386pe", "--large-address-aware"], + ) + }); Target { llvm_target: "i686-pc-windows-gnu".into(), diff --git a/compiler/rustc_target/src/spec/targets/i686_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/i686_pc_windows_msvc.rs index 970b43ad109ba..3595244e060f4 100644 --- a/compiler/rustc_target/src/spec/targets/i686_pc_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/i686_pc_windows_msvc.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, LinkerFlavor, Lld, SanitizerSet, Target}; +use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_msvc::opts(); @@ -6,18 +6,20 @@ pub fn target() -> Target { base.max_atomic_width = Some(64); base.supported_sanitizers = SanitizerSet::ADDRESS; - base.add_pre_link_args( - LinkerFlavor::Msvc(Lld::No), - &[ - // Mark all dynamic libraries and executables as compatible with the larger 4GiB address - // space available to x86 Windows binaries on x86_64. - "/LARGEADDRESSAWARE", - // Ensure the linker will only produce an image if it can also produce a table of - // the image's safe exception handlers. - // https://docs.microsoft.com/en-us/cpp/build/reference/safeseh-image-has-safe-exception-handlers - "/SAFESEH", - ], - ); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Msvc(Lld::No), + &[ + // Mark all dynamic libraries and executables as compatible with the larger 4GiB address + // space available to x86 Windows binaries on x86_64. + "/LARGEADDRESSAWARE", + // Ensure the linker will only produce an image if it can also produce a table of + // the image's safe exception handlers. + // https://docs.microsoft.com/en-us/cpp/build/reference/safeseh-image-has-safe-exception-handlers + "/SAFESEH", + ], + ) + }); Target { llvm_target: "i686-pc-windows-msvc".into(), diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_freebsd.rs index 5826906e9d8ed..e4663397d4e25 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_freebsd.rs @@ -1,10 +1,12 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::freebsd::opts(); base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "-Wl,-znotext"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "-Wl,-znotext"]) + }); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_haiku.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_haiku.rs index 5f66911b39a14..51f70d78cb4a9 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_haiku.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_haiku.rs @@ -1,10 +1,12 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::haiku::opts(); base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) + }); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_hurd_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_hurd_gnu.rs index a67105f24ca2e..ac7946673a02c 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_hurd_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_hurd_gnu.rs @@ -1,10 +1,12 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::hurd_gnu::opts(); base.cpu = "pentiumpro".into(); base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) + }); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_linux_gnu.rs index 1d4916cabfdf3..670c5f160379e 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_linux_gnu.rs @@ -1,11 +1,14 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy}; +use crate::spec::{SanitizerSet, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); base.supported_sanitizers = SanitizerSet::ADDRESS; - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) + }); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_linux_musl.rs index c3b9b71802b18..d9e0c4ec70f8a 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_linux_musl.rs @@ -1,10 +1,14 @@ -use crate::spec::{base, Cc, FramePointer, LinkerFlavor, Lld, StackProbeType, Target}; +use crate::spec::{ + base, Cc, FramePointer, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions, +}; pub fn target() -> Target { let mut base = base::linux_musl::opts(); base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "-Wl,-melf_i386"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "-Wl,-melf_i386"]) + }); base.stack_probes = StackProbeType::Inline; // The unwinder used by i686-unknown-linux-musl, the LLVM libunwind diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_netbsd.rs index 87eba1fb856f0..cbc8c77f43c7b 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_netbsd.rs @@ -1,10 +1,12 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::netbsd::opts(); base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) + }); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_openbsd.rs index 0436f39f5b11c..e0cfbaef3c43a 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_openbsd.rs @@ -1,10 +1,12 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::openbsd::opts(); base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "-fuse-ld=lld"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "-fuse-ld=lld"]) + }); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs index 77dcd645728f1..e1de02770e515 100644 --- a/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs @@ -1,4 +1,5 @@ -use crate::spec::{base, Cc, FramePointer, LinkerFlavor, Lld, Target}; +use crate::spec::{add_link_args, base, Cc, FramePointer}; +use crate::spec::{LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_uwp_gnu::opts(); @@ -8,11 +9,18 @@ pub fn target() -> Target { // Mark all dynamic libraries and executables as compatible with the larger 4GiB address // space available to x86 Windows binaries on x86_64. - base.add_pre_link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &["-m", "i386pe", "--large-address-aware"], - ); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-Wl,--large-address-aware"]); + base.pre_link_args = MaybeLazy::lazy(|| { + let mut pre_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &["-m", "i386pe", "--large-address-aware"], + ); + add_link_args( + &mut pre_link_args, + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-Wl,--large-address-aware"], + ); + pre_link_args + }); Target { llvm_target: "i686-pc-windows-gnu".into(), diff --git a/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs index ae1a44e44a85a..35705e01ab41e 100644 --- a/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, LinkerFlavor, Lld, Target}; +use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_msvc::opts(); diff --git a/compiler/rustc_target/src/spec/targets/i686_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/i686_wrs_vxworks.rs index e4d0b674cc4c3..c16652063dcd0 100644 --- a/compiler/rustc_target/src/spec/targets/i686_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/i686_wrs_vxworks.rs @@ -1,10 +1,12 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::vxworks::opts(); base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) + }); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs b/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs index 481df71c1a65a..f2c0a8f49db26 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs @@ -1,12 +1,14 @@ -use crate::spec::{base, Cc, LinkerFlavor, Target}; +use crate::spec::{base, Cc, LinkerFlavor, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::aix::opts(); base.max_atomic_width = Some(64); - base.add_pre_link_args( - LinkerFlavor::Unix(Cc::No), - &["-b64", "-bpT:0x100000000", "-bpD:0x110000000", "-bcdtors:all:0:s"], - ); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Unix(Cc::No), + &["-b64", "-bpT:0x100000000", "-bpD:0x110000000", "-bcdtors:all:0:s"], + ) + }); Target { llvm_target: "powerpc64-ibm-aix".into(), diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs index b1b981823b89d..ff87cc719e53a 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs @@ -1,10 +1,12 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::freebsd::opts(); base.cpu = "ppc64".into(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs index ac10630d94404..683e7bfb50e49 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs @@ -1,10 +1,12 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); base.cpu = "ppc64".into(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs index 663f06cf0c67b..2488909638fb3 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs @@ -1,10 +1,12 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_musl::opts(); base.cpu = "ppc64".into(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs index 5611352c951c7..1cd215d5509e5 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs @@ -1,10 +1,12 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::openbsd::opts(); base.cpu = "ppc64".into(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs index 22b45042aa667..61749d9ff457b 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs @@ -1,10 +1,12 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::vxworks::opts(); base.cpu = "ppc64".into(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs index 812b5928966f6..7df62b27e9e01 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs @@ -1,9 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::freebsd::opts(); base.cpu = "ppc64le".into(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs index e3c4b3b585c2a..98776dab96878 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs @@ -1,9 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); base.cpu = "ppc64le".into(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs index 497a40ade81e8..70dd0e2006a03 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs @@ -1,9 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_musl::opts(); base.cpu = "ppc64le".into(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_freebsd.rs index 194bb0566f18f..7737400e58965 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_freebsd.rs @@ -1,13 +1,15 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::freebsd::opts(); // Extra hint to linker that we are generating secure-PLT code. - base.add_pre_link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-m32", "--target=powerpc-unknown-freebsd13.0"], - ); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-m32", "--target=powerpc-unknown-freebsd13.0"], + ) + }); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnu.rs index b88b2fbf80948..834861efbe68c 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnu.rs @@ -1,9 +1,11 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) + }); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs index b09c4cd21e046..b54ebe4c4edef 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs @@ -1,9 +1,11 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mspe"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mspe"]) + }); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_musl.rs index 67b19e9048916..deee308613a5e 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_musl.rs @@ -1,9 +1,11 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_musl::opts(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) + }); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_netbsd.rs index c592cd3f6fd2d..caca549426f89 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_netbsd.rs @@ -1,9 +1,11 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::netbsd::opts(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) + }); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks.rs index 91925ce151dfd..e8e1c942dd4e4 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks.rs @@ -1,9 +1,11 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::vxworks::opts(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "--secure-plt"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "--secure-plt"]) + }); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs index 7640feb28e3c9..be55defce7678 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs @@ -1,9 +1,11 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::vxworks::opts(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mspe", "--secure-plt"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mspe", "--secure-plt"]) + }); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/sparc64_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/sparc64_unknown_netbsd.rs index 42944367cf666..4e584f9a26866 100644 --- a/compiler/rustc_target/src/spec/targets/sparc64_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/sparc64_unknown_netbsd.rs @@ -1,10 +1,12 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::netbsd::opts(); base.cpu = "v9".into(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.max_atomic_width = Some(64); Target { diff --git a/compiler/rustc_target/src/spec/targets/sparc64_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/sparc64_unknown_openbsd.rs index f0bf55d33e684..11e72321afafa 100644 --- a/compiler/rustc_target/src/spec/targets/sparc64_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/sparc64_unknown_openbsd.rs @@ -1,11 +1,13 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::openbsd::opts(); base.endian = Endian::Big; base.cpu = "v9".into(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.max_atomic_width = Some(64); Target { diff --git a/compiler/rustc_target/src/spec/targets/sparc_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/sparc_unknown_linux_gnu.rs index c10f9d82d4636..5df71355b526b 100644 --- a/compiler/rustc_target/src/spec/targets/sparc_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/sparc_unknown_linux_gnu.rs @@ -1,12 +1,14 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); base.endian = Endian::Big; base.cpu = "v9".into(); base.max_atomic_width = Some(32); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mv8plus"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mv8plus"]) + }); Target { llvm_target: "sparc-unknown-linux-gnu".into(), diff --git a/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs b/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs index a42243f59dc4d..4e8e02108185d 100644 --- a/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs +++ b/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs @@ -1,10 +1,11 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Target}; +use crate::spec::{base, Cc, LinkerFlavor, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::solaris::opts(); base.endian = Endian::Big; - base.add_pre_link_args(LinkerFlavor::Unix(Cc::Yes), &["-m64"]); + base.pre_link_args = + MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Unix(Cc::Yes), &["-m64"])); // llvm calls this "v9" base.cpu = "v9".into(); base.vendor = "sun".into(); diff --git a/compiler/rustc_target/src/spec/targets/thumbv7a_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/thumbv7a_pc_windows_msvc.rs index 13e1e349b0402..008af9a5cd206 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7a_pc_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7a_pc_windows_msvc.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, LinkerFlavor, Lld, PanicStrategy, Target, TargetOptions}; +use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy, PanicStrategy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_msvc::opts(); @@ -9,7 +9,8 @@ pub fn target() -> Target { // should be smart enough to insert branch islands only // where necessary, but this is not the observed behavior. // Disabling the LBR optimization works around the issue. - base.add_pre_link_args(LinkerFlavor::Msvc(Lld::No), &["/OPT:NOLBR"]); + base.pre_link_args = + MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Msvc(Lld::No), &["/OPT:NOLBR"])); Target { llvm_target: "thumbv7a-pc-windows-msvc".into(), diff --git a/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs index d50e63b92175d..feda3a4516181 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; // This target if is for the Android v7a ABI in thumb mode with // NEON unconditionally enabled and, therefore, with 32 FPU registers @@ -10,7 +10,9 @@ use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::android::opts(); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-march=armv7-a"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-march=armv7-a"]) + }); Target { llvm_target: "armv7-none-linux-android".into(), metadata: crate::spec::TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs b/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs index 23f4772c39cb5..42bce0aba62b8 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs @@ -10,29 +10,33 @@ //! This target is more or less managed by the Rust and WebAssembly Working //! Group nowadays at . -use crate::spec::{base, Cc, LinkerFlavor, Target}; +use crate::spec::{base, Cc, LinkerFlavor, MaybeLazy, Target}; pub fn target() -> Target { let mut options = base::wasm::options(); options.os = "unknown".into(); - options.add_pre_link_args( - LinkerFlavor::WasmLld(Cc::No), - &[ - // For now this target just never has an entry symbol no matter the output - // type, so unconditionally pass this. - "--no-entry", - ], - ); - options.add_pre_link_args( - LinkerFlavor::WasmLld(Cc::Yes), - &[ - // Make sure clang uses LLD as its linker and is configured appropriately - // otherwise - "--target=wasm32-unknown-unknown", - "-Wl,--no-entry", - ], - ); + options.pre_link_args = MaybeLazy::lazy(|| { + let mut pre_link_args = TargetOptions::link_args( + LinkerFlavor::WasmLld(Cc::No), + &[ + // For now this target just never has an entry symbol no matter the output + // type, so unconditionally pass this. + "--no-entry", + ], + ); + add_link_args( + &mut pre_link_args, + LinkerFlavor::WasmLld(Cc::Yes), + &[ + // Make sure clang uses LLD as its linker and is configured appropriately + // otherwise + "--target=wasm32-unknown-unknown", + "-Wl,--no-entry", + ], + ); + pre_link_args + }); Target { llvm_target: "wasm32-unknown-unknown".into(), diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs index 4c2d222b590e4..53c1fe7b1ef10 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs @@ -12,6 +12,8 @@ use crate::spec::crt_objects; use crate::spec::LinkSelfContainedDefault; +use crate::spec::MaybeLazy; +use crate::spec::TargetOptions; use crate::spec::{base, Cc, LinkerFlavor, Target}; pub fn target() -> Target { @@ -19,7 +21,9 @@ pub fn target() -> Target { options.os = "wasi".into(); options.env = "p1".into(); - options.add_pre_link_args(LinkerFlavor::WasmLld(Cc::Yes), &["--target=wasm32-wasi"]); + options.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::WasmLld(Cc::Yes), &["--target=wasm32-wasi"]) + }); options.pre_link_objects_self_contained = crt_objects::pre_wasi_self_contained(); options.post_link_objects_self_contained = crt_objects::post_wasi_self_contained(); diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs index 38af48ab2665a..ebb74ab508562 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs @@ -7,7 +7,10 @@ //! //! Historically this target was known as `wasm32-wasi-preview1-threads`. -use crate::spec::{base, crt_objects, Cc, LinkSelfContainedDefault, LinkerFlavor, Target}; +use crate::spec::{ + add_link_args, base, crt_objects, Cc, LinkSelfContainedDefault, LinkerFlavor, MaybeLazy, + Target, TargetOptions, +}; pub fn target() -> Target { let mut options = base::wasm::options(); @@ -15,19 +18,23 @@ pub fn target() -> Target { options.os = "wasi".into(); options.env = "p1".into(); - options.add_pre_link_args( - LinkerFlavor::WasmLld(Cc::No), - &["--import-memory", "--export-memory", "--shared-memory"], - ); - options.add_pre_link_args( - LinkerFlavor::WasmLld(Cc::Yes), - &[ - "--target=wasm32-wasip1-threads", - "-Wl,--import-memory", - "-Wl,--export-memory,", - "-Wl,--shared-memory", - ], - ); + options.pre_link_args = MaybeLazy::lazy(|| { + let mut pre_link_args = TargetOptions::link_args( + LinkerFlavor::WasmLld(Cc::No), + &["--import-memory", "--export-memory", "--shared-memory"], + ); + add_link_args( + &mut pre_link_args, + LinkerFlavor::WasmLld(Cc::Yes), + &[ + "--target=wasm32-wasip1-threads", + "-Wl,--import-memory", + "-Wl,--export-memory,", + "-Wl,--shared-memory", + ], + ); + pre_link_args + }); options.pre_link_objects_self_contained = crt_objects::pre_wasi_self_contained(); options.post_link_objects_self_contained = crt_objects::post_wasi_self_contained(); diff --git a/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs b/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs index 8edde36dac623..6289c0a0c4a9d 100644 --- a/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs +++ b/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs @@ -7,30 +7,34 @@ //! the standard library is available, most of it returns an error immediately //! (e.g. trying to create a TCP stream or something like that). -use crate::spec::{base, Cc, LinkerFlavor, Target}; +use crate::spec::{add_link_args, base, Cc, LinkerFlavor, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut options = base::wasm::options(); options.os = "unknown".into(); - options.add_pre_link_args( - LinkerFlavor::WasmLld(Cc::No), - &[ - // For now this target just never has an entry symbol no matter the output - // type, so unconditionally pass this. - "--no-entry", - "-mwasm64", - ], - ); - options.add_pre_link_args( - LinkerFlavor::WasmLld(Cc::Yes), - &[ - // Make sure clang uses LLD as its linker and is configured appropriately - // otherwise - "--target=wasm64-unknown-unknown", - "-Wl,--no-entry", - ], - ); + options.pre_link_args = MaybeLazy::lazy(|| { + let mut pre_link_args = TargetOptions::link_args( + LinkerFlavor::WasmLld(Cc::No), + &[ + // For now this target just never has an entry symbol no matter the output + // type, so unconditionally pass this. + "--no-entry", + "-mwasm64", + ], + ); + add_link_args( + &mut pre_link_args, + LinkerFlavor::WasmLld(Cc::Yes), + &[ + // Make sure clang uses LLD as its linker and is configured appropriately + // otherwise + "--target=wasm64-unknown-unknown", + "-Wl,--no-entry", + ], + ); + pre_link_args + }); // Any engine that implements wasm64 will surely implement the rest of these // features since they were all merged into the official spec by the time diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs index bd1c0f669ec3c..2c3ab6a3d4ce7 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs @@ -10,7 +10,9 @@ pub fn target() -> Target { let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.max_atomic_width = Some(128); // penryn+ supports cmpxchg16b base.frame_pointer = FramePointer::Always; - base.add_pre_link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m64"]) + }); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::CFI | SanitizerSet::LEAK | SanitizerSet::THREAD; diff --git a/compiler/rustc_target/src/spec/targets/x86_64_linux_android.rs b/compiler/rustc_target/src/spec/targets/x86_64_linux_android.rs index 92711bbe246b7..e60595912bbfd 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_linux_android.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_linux_android.rs @@ -1,5 +1,5 @@ use crate::spec::{ - base, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetOptions, + base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, }; pub fn target() -> Target { @@ -9,7 +9,9 @@ pub fn target() -> Target { // https://developer.android.com/ndk/guides/abis.html#86-64 base.features = "+mmx,+sse,+sse2,+sse3,+ssse3,+sse4.1,+sse4.2,+popcnt".into(); base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.stack_probes = StackProbeType::Inline; base.supports_xray = true; diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs index 4dbe049a4b782..08b345063ae64 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs @@ -1,8 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, SanitizerSet, StackProbeType, Target}; +use crate::spec::{ + base, Cc, LinkerFlavor, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, +}; pub fn target() -> Target { let mut base = base::solaris::opts(); - base.add_pre_link_args(LinkerFlavor::Unix(Cc::Yes), &["-m64"]); + base.pre_link_args = + MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Unix(Cc::Yes), &["-m64"])); base.cpu = "x86-64".into(); base.plt_by_default = false; base.vendor = "pc".into(); diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs index de0f17246c3dc..1b91ef6b4e718 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, Target}; +use crate::spec::{add_link_args, base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_gnu::opts(); @@ -6,11 +6,18 @@ pub fn target() -> Target { base.features = "+cx16,+sse3,+sahf".into(); base.plt_by_default = false; // Use high-entropy 64 bit address space for ASLR - base.add_pre_link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &["-m", "i386pep", "--high-entropy-va"], - ); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64", "-Wl,--high-entropy-va"]); + base.pre_link_args = MaybeLazy::lazy(|| { + let mut pre_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &["-m", "i386pep", "--high-entropy-va"], + ); + add_link_args( + &mut pre_link_args, + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-m64", "-Wl,--high-entropy-va"], + ); + pre_link_args + }); base.max_atomic_width = Some(128); base.linker = Some("x86_64-w64-mingw32-gcc".into()); diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs index b485970bb416d..a77d73be336b4 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs @@ -1,11 +1,13 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_gnullvm::opts(); base.cpu = "x86-64".into(); base.features = "+cx16,+sse3,+sahf".into(); base.plt_by_default = false; - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.max_atomic_width = Some(128); base.linker = Some("x86_64-w64-mingw32-clang".into()); diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_dragonfly.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_dragonfly.rs index aef95e373cbfa..09eb1594da0dc 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_dragonfly.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_dragonfly.rs @@ -1,11 +1,13 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::dragonfly::opts(); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_freebsd.rs index 15146a5ef7299..340998e3c33a5 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_freebsd.rs @@ -1,11 +1,15 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target}; +use crate::spec::{ + base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, +}; pub fn target() -> Target { let mut base = base::freebsd::opts(); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.stack_probes = StackProbeType::Inline; base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::CFI | SanitizerSet::MEMORY | SanitizerSet::THREAD; diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_haiku.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_haiku.rs index 9f62eb1fa270d..2beec9cf577d8 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_haiku.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_haiku.rs @@ -1,11 +1,13 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::haiku::opts(); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.stack_probes = StackProbeType::Inline; // This option is required to build executables on Haiku x86_64 base.position_independent_executables = true; diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_illumos.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_illumos.rs index c52cdf466abe7..cb7033fc303e0 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_illumos.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_illumos.rs @@ -1,8 +1,10 @@ -use crate::spec::{base, Cc, LinkerFlavor, SanitizerSet, Target}; +use crate::spec::{base, Cc, LinkerFlavor, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::illumos::opts(); - base.add_pre_link_args(LinkerFlavor::Unix(Cc::Yes), &["-m64", "-std=c99"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Unix(Cc::Yes), &["-m64", "-std=c99"]) + }); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs index bd12d4d8af0e0..c24ae4b1b5b57 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs @@ -1,11 +1,15 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target}; +use crate::spec::{ + base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, +}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.stack_probes = StackProbeType::Inline; base.static_position_independent_executables = true; base.supported_sanitizers = SanitizerSet::ADDRESS diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs index f6e0b051e8f54..fdfa78a4b65cf 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs @@ -1,11 +1,13 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); base.cpu = "x86-64".into(); base.abi = "x32".into(); base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mx32"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mx32"]) + }); base.stack_probes = StackProbeType::Inline; base.has_thread_local = false; // BUG(GabrielMajeri): disabling the PLT on x86_64 Linux with x32 ABI diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs index 66237f071028d..aba2684ff9a3d 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs @@ -1,11 +1,15 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target}; +use crate::spec::{ + base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, +}; pub fn target() -> Target { let mut base = base::linux_musl::opts(); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.stack_probes = StackProbeType::Inline; base.static_position_independent_executables = true; base.supported_sanitizers = SanitizerSet::ADDRESS diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_ohos.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_ohos.rs index db8db1d253824..0bad1fec70945 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_ohos.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_ohos.rs @@ -1,10 +1,14 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target}; +use crate::spec::{ + base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, +}; pub fn target() -> Target { let mut base = base::linux_ohos::opts(); base.cpu = "x86-64".into(); base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.stack_probes = StackProbeType::Inline; base.static_position_independent_executables = true; base.supported_sanitizers = SanitizerSet::ADDRESS diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_netbsd.rs index 38ae3a4fe4248..0dd66812b3af4 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_netbsd.rs @@ -1,5 +1,5 @@ use crate::spec::{ - base, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetOptions, + base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, }; pub fn target() -> Target { @@ -7,7 +7,9 @@ pub fn target() -> Target { base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.stack_probes = StackProbeType::Inline; base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::CFI diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_openbsd.rs index 4d7eba2421394..058808c6f8b1d 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_openbsd.rs @@ -1,11 +1,13 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::openbsd::opts(); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.stack_probes = StackProbeType::Inline; base.supports_xray = true; diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_redox.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_redox.rs index 99f5d9dc41d29..f1f57cf7dd9ca 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_redox.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_redox.rs @@ -1,11 +1,13 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::redox::opts(); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs index aef6fd1a7814e..fe40b313ea95c 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, Target}; +use crate::spec::{add_link_args, base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_uwp_gnu::opts(); @@ -6,11 +6,18 @@ pub fn target() -> Target { base.features = "+cx16,+sse3,+sahf".into(); base.plt_by_default = false; // Use high-entropy 64 bit address space for ASLR - base.add_pre_link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &["-m", "i386pep", "--high-entropy-va"], - ); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64", "-Wl,--high-entropy-va"]); + base.pre_link_args = MaybeLazy::lazy(|| { + let mut pre_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &["-m", "i386pep", "--high-entropy-va"], + ); + add_link_args( + &mut pre_link_args, + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-m64", "-Wl,--high-entropy-va"], + ); + pre_link_args + }); base.max_atomic_width = Some(128); Target { diff --git a/compiler/rustc_target/src/spec/targets/x86_64_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/x86_64_wrs_vxworks.rs index b956d228c17fe..04dc9e4ea7070 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_wrs_vxworks.rs @@ -1,11 +1,13 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::vxworks::opts(); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) + }); base.stack_probes = StackProbeType::Inline; base.disable_redzone = true; diff --git a/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs index bd7c19ff3c6cf..2e65eea60ef41 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs @@ -10,7 +10,9 @@ pub fn target() -> Target { let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.max_atomic_width = Some(128); base.frame_pointer = FramePointer::Always; - base.add_pre_link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m64"]); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m64"]) + }); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::CFI | SanitizerSet::LEAK | SanitizerSet::THREAD; From 723e040d59a078ccb470c1d483b511a2b202dcba Mon Sep 17 00:00:00 2001 From: Urgau Date: Sun, 12 May 2024 16:24:36 +0200 Subject: [PATCH 04/13] Move `TargetOptions` CRT objects to `MaybeLazy` --- compiler/rustc_target/src/spec/base/aix.rs | 13 ++- .../rustc_target/src/spec/base/fuchsia.rs | 14 +-- compiler/rustc_target/src/spec/crt_objects.rs | 97 ++++++++++--------- compiler/rustc_target/src/spec/mod.rs | 12 +-- .../spec/targets/i686_win7_windows_msvc.rs | 26 ++--- .../spec/targets/wasm32_unknown_unknown.rs | 3 +- 6 files changed, 91 insertions(+), 74 deletions(-) diff --git a/compiler/rustc_target/src/spec/base/aix.rs b/compiler/rustc_target/src/spec/base/aix.rs index c71c4ba2cc902..fb131dff31dd2 100644 --- a/compiler/rustc_target/src/spec/base/aix.rs +++ b/compiler/rustc_target/src/spec/base/aix.rs @@ -1,5 +1,6 @@ use crate::abi::Endian; -use crate::spec::{crt_objects, cvs, Cc, CodeModel, LinkOutputKind, LinkerFlavor, TargetOptions}; +use crate::spec::{crt_objects, cvs, Cc, CodeModel, LinkOutputKind, LinkerFlavor}; +use crate::spec::{MaybeLazy, TargetOptions}; pub fn opts() -> TargetOptions { TargetOptions { @@ -22,10 +23,12 @@ pub fn opts() -> TargetOptions { is_like_aix: true, default_dwarf_version: 3, function_sections: true, - pre_link_objects: crt_objects::new(&[ - (LinkOutputKind::DynamicNoPicExe, &["/usr/lib/crt0_64.o", "/usr/lib/crti_64.o"]), - (LinkOutputKind::DynamicPicExe, &["/usr/lib/crt0_64.o", "/usr/lib/crti_64.o"]), - ]), + pre_link_objects: MaybeLazy::lazy(|| { + crt_objects::new(&[ + (LinkOutputKind::DynamicNoPicExe, &["/usr/lib/crt0_64.o", "/usr/lib/crti_64.o"]), + (LinkOutputKind::DynamicPicExe, &["/usr/lib/crt0_64.o", "/usr/lib/crti_64.o"]), + ]) + }), dll_suffix: ".a".into(), ..Default::default() } diff --git a/compiler/rustc_target/src/spec/base/fuchsia.rs b/compiler/rustc_target/src/spec/base/fuchsia.rs index 3fbd38223187c..f8652a08f87d0 100644 --- a/compiler/rustc_target/src/spec/base/fuchsia.rs +++ b/compiler/rustc_target/src/spec/base/fuchsia.rs @@ -34,12 +34,14 @@ pub fn opts() -> TargetOptions { dynamic_linking: true, families: cvs!["unix"], pre_link_args, - pre_link_objects: crt_objects::new(&[ - (LinkOutputKind::DynamicNoPicExe, &["Scrt1.o"]), - (LinkOutputKind::DynamicPicExe, &["Scrt1.o"]), - (LinkOutputKind::StaticNoPicExe, &["Scrt1.o"]), - (LinkOutputKind::StaticPicExe, &["Scrt1.o"]), - ]), + pre_link_objects: MaybeLazy::lazy(|| { + crt_objects::new(&[ + (LinkOutputKind::DynamicNoPicExe, &["Scrt1.o"]), + (LinkOutputKind::DynamicPicExe, &["Scrt1.o"]), + (LinkOutputKind::StaticNoPicExe, &["Scrt1.o"]), + (LinkOutputKind::StaticPicExe, &["Scrt1.o"]), + ]) + }), position_independent_executables: true, has_thread_local: true, frame_pointer: FramePointer::NonLeaf, diff --git a/compiler/rustc_target/src/spec/crt_objects.rs b/compiler/rustc_target/src/spec/crt_objects.rs index 53f710b8f9e14..5f9736617e745 100644 --- a/compiler/rustc_target/src/spec/crt_objects.rs +++ b/compiler/rustc_target/src/spec/crt_objects.rs @@ -40,11 +40,12 @@ //! but not gcc's. As a result rustc cannot link with C++ static libraries (#36710) //! when linking in self-contained mode. -use crate::spec::LinkOutputKind; +use crate::spec::{LinkOutputKind, MaybeLazy}; use std::borrow::Cow; use std::collections::BTreeMap; pub type CrtObjects = BTreeMap>>; +pub type LazyCrtObjects = MaybeLazy; pub(super) fn new(obj_table: &[(LinkOutputKind, &[&'static str])]) -> CrtObjects { obj_table.iter().map(|(z, k)| (*z, k.iter().map(|b| (*b).into()).collect())).collect() @@ -61,63 +62,71 @@ pub(super) fn all(obj: &'static str) -> CrtObjects { ]) } -pub(super) fn pre_musl_self_contained() -> CrtObjects { - new(&[ - (LinkOutputKind::DynamicNoPicExe, &["crt1.o", "crti.o", "crtbegin.o"]), - (LinkOutputKind::DynamicPicExe, &["Scrt1.o", "crti.o", "crtbeginS.o"]), - (LinkOutputKind::StaticNoPicExe, &["crt1.o", "crti.o", "crtbegin.o"]), - (LinkOutputKind::StaticPicExe, &["rcrt1.o", "crti.o", "crtbeginS.o"]), - (LinkOutputKind::DynamicDylib, &["crti.o", "crtbeginS.o"]), - (LinkOutputKind::StaticDylib, &["crti.o", "crtbeginS.o"]), - ]) +pub(super) fn pre_musl_self_contained() -> LazyCrtObjects { + MaybeLazy::lazy(|| { + new(&[ + (LinkOutputKind::DynamicNoPicExe, &["crt1.o", "crti.o", "crtbegin.o"]), + (LinkOutputKind::DynamicPicExe, &["Scrt1.o", "crti.o", "crtbeginS.o"]), + (LinkOutputKind::StaticNoPicExe, &["crt1.o", "crti.o", "crtbegin.o"]), + (LinkOutputKind::StaticPicExe, &["rcrt1.o", "crti.o", "crtbeginS.o"]), + (LinkOutputKind::DynamicDylib, &["crti.o", "crtbeginS.o"]), + (LinkOutputKind::StaticDylib, &["crti.o", "crtbeginS.o"]), + ]) + }) } -pub(super) fn post_musl_self_contained() -> CrtObjects { - new(&[ - (LinkOutputKind::DynamicNoPicExe, &["crtend.o", "crtn.o"]), - (LinkOutputKind::DynamicPicExe, &["crtendS.o", "crtn.o"]), - (LinkOutputKind::StaticNoPicExe, &["crtend.o", "crtn.o"]), - (LinkOutputKind::StaticPicExe, &["crtendS.o", "crtn.o"]), - (LinkOutputKind::DynamicDylib, &["crtendS.o", "crtn.o"]), - (LinkOutputKind::StaticDylib, &["crtendS.o", "crtn.o"]), - ]) +pub(super) fn post_musl_self_contained() -> LazyCrtObjects { + MaybeLazy::lazy(|| { + new(&[ + (LinkOutputKind::DynamicNoPicExe, &["crtend.o", "crtn.o"]), + (LinkOutputKind::DynamicPicExe, &["crtendS.o", "crtn.o"]), + (LinkOutputKind::StaticNoPicExe, &["crtend.o", "crtn.o"]), + (LinkOutputKind::StaticPicExe, &["crtendS.o", "crtn.o"]), + (LinkOutputKind::DynamicDylib, &["crtendS.o", "crtn.o"]), + (LinkOutputKind::StaticDylib, &["crtendS.o", "crtn.o"]), + ]) + }) } -pub(super) fn pre_mingw_self_contained() -> CrtObjects { - new(&[ - (LinkOutputKind::DynamicNoPicExe, &["crt2.o", "rsbegin.o"]), - (LinkOutputKind::DynamicPicExe, &["crt2.o", "rsbegin.o"]), - (LinkOutputKind::StaticNoPicExe, &["crt2.o", "rsbegin.o"]), - (LinkOutputKind::StaticPicExe, &["crt2.o", "rsbegin.o"]), - (LinkOutputKind::DynamicDylib, &["dllcrt2.o", "rsbegin.o"]), - (LinkOutputKind::StaticDylib, &["dllcrt2.o", "rsbegin.o"]), - ]) +pub(super) fn pre_mingw_self_contained() -> LazyCrtObjects { + MaybeLazy::lazy(|| { + new(&[ + (LinkOutputKind::DynamicNoPicExe, &["crt2.o", "rsbegin.o"]), + (LinkOutputKind::DynamicPicExe, &["crt2.o", "rsbegin.o"]), + (LinkOutputKind::StaticNoPicExe, &["crt2.o", "rsbegin.o"]), + (LinkOutputKind::StaticPicExe, &["crt2.o", "rsbegin.o"]), + (LinkOutputKind::DynamicDylib, &["dllcrt2.o", "rsbegin.o"]), + (LinkOutputKind::StaticDylib, &["dllcrt2.o", "rsbegin.o"]), + ]) + }) } -pub(super) fn post_mingw_self_contained() -> CrtObjects { - all("rsend.o") +pub(super) fn post_mingw_self_contained() -> LazyCrtObjects { + MaybeLazy::lazy(|| all("rsend.o")) } -pub(super) fn pre_mingw() -> CrtObjects { - all("rsbegin.o") +pub(super) fn pre_mingw() -> LazyCrtObjects { + MaybeLazy::lazy(|| all("rsbegin.o")) } -pub(super) fn post_mingw() -> CrtObjects { - all("rsend.o") +pub(super) fn post_mingw() -> LazyCrtObjects { + MaybeLazy::lazy(|| all("rsend.o")) } -pub(super) fn pre_wasi_self_contained() -> CrtObjects { +pub(super) fn pre_wasi_self_contained() -> LazyCrtObjects { // Use crt1-command.o instead of crt1.o to enable support for new-style // commands. See https://reviews.llvm.org/D81689 for more info. - new(&[ - (LinkOutputKind::DynamicNoPicExe, &["crt1-command.o"]), - (LinkOutputKind::DynamicPicExe, &["crt1-command.o"]), - (LinkOutputKind::StaticNoPicExe, &["crt1-command.o"]), - (LinkOutputKind::StaticPicExe, &["crt1-command.o"]), - (LinkOutputKind::WasiReactorExe, &["crt1-reactor.o"]), - ]) + MaybeLazy::lazy(|| { + new(&[ + (LinkOutputKind::DynamicNoPicExe, &["crt1-command.o"]), + (LinkOutputKind::DynamicPicExe, &["crt1-command.o"]), + (LinkOutputKind::StaticNoPicExe, &["crt1-command.o"]), + (LinkOutputKind::StaticPicExe, &["crt1-command.o"]), + (LinkOutputKind::WasiReactorExe, &["crt1-reactor.o"]), + ]) + }) } -pub(super) fn post_wasi_self_contained() -> CrtObjects { - new(&[]) +pub(super) fn post_wasi_self_contained() -> LazyCrtObjects { + MaybeLazy::lazy(|| new(&[])) } diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs index ffc8764eaee93..400f43103315e 100644 --- a/compiler/rustc_target/src/spec/mod.rs +++ b/compiler/rustc_target/src/spec/mod.rs @@ -38,7 +38,7 @@ use crate::abi::call::Conv; use crate::abi::{Endian, Integer, Size, TargetDataLayout, TargetDataLayoutErrors}; use crate::json::{Json, ToJson}; use crate::spec::abi::Abi; -use crate::spec::crt_objects::CrtObjects; +use crate::spec::crt_objects::{CrtObjects, LazyCrtObjects}; use rustc_fs_util::try_canonicalize; use rustc_macros::{Decodable, Encodable, HashStable_Generic}; use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; @@ -2017,11 +2017,11 @@ pub struct TargetOptions { linker_is_gnu_json: bool, /// Objects to link before and after all other object code. - pub pre_link_objects: CrtObjects, - pub post_link_objects: CrtObjects, + pub pre_link_objects: LazyCrtObjects, + pub post_link_objects: LazyCrtObjects, /// Same as `(pre|post)_link_objects`, but when self-contained linking mode is enabled. - pub pre_link_objects_self_contained: CrtObjects, - pub post_link_objects_self_contained: CrtObjects, + pub pre_link_objects_self_contained: LazyCrtObjects, + pub post_link_objects_self_contained: LazyCrtObjects, /// Behavior for the self-contained linking mode: inferred for some targets, or explicitly /// enabled (in bulk, or with individual components). pub link_self_contained: LinkSelfContainedDefault, @@ -3095,7 +3095,7 @@ impl Target { args.insert(kind, v); } - base.$key_name = args; + base.$key_name = MaybeLazy::owned(args); } } ); ($key_name:ident = $json_name:expr, link_args) => ( { diff --git a/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs index 35705e01ab41e..4d63564c19368 100644 --- a/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs @@ -6,18 +6,20 @@ pub fn target() -> Target { base.max_atomic_width = Some(64); base.vendor = "win7".into(); - base.add_pre_link_args( - LinkerFlavor::Msvc(Lld::No), - &[ - // Mark all dynamic libraries and executables as compatible with the larger 4GiB address - // space available to x86 Windows binaries on x86_64. - "/LARGEADDRESSAWARE", - // Ensure the linker will only produce an image if it can also produce a table of - // the image's safe exception handlers. - // https://docs.microsoft.com/en-us/cpp/build/reference/safeseh-image-has-safe-exception-handlers - "/SAFESEH", - ], - ); + base.pre_link_args = MaybeLazy::lazy(|| { + TargetOptions::link_args( + LinkerFlavor::Msvc(Lld::No), + &[ + // Mark all dynamic libraries and executables as compatible with the larger 4GiB address + // space available to x86 Windows binaries on x86_64. + "/LARGEADDRESSAWARE", + // Ensure the linker will only produce an image if it can also produce a table of + // the image's safe exception handlers. + // https://docs.microsoft.com/en-us/cpp/build/reference/safeseh-image-has-safe-exception-handlers + "/SAFESEH", + ], + ) + }); Target { llvm_target: "i686-pc-windows-msvc".into(), diff --git a/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs b/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs index 42bce0aba62b8..f7a50f9fa93a7 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs @@ -10,7 +10,8 @@ //! This target is more or less managed by the Rust and WebAssembly Working //! Group nowadays at . -use crate::spec::{base, Cc, LinkerFlavor, MaybeLazy, Target}; +use crate::spec::add_link_args; +use crate::spec::{base, Cc, LinkerFlavor, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { let mut options = base::wasm::options(); From 859815b0905e53d706bde8ba113e0dc322298ead Mon Sep 17 00:00:00 2001 From: Urgau Date: Sun, 12 May 2024 16:24:57 +0200 Subject: [PATCH 05/13] Move `Target::llvm_target` to `MaybeLazy` --- compiler/rustc_target/src/spec/mod.rs | 4 ++-- .../rustc_target/src/spec/targets/aarch64_apple_darwin.rs | 2 +- compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs | 2 +- .../rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs | 2 +- .../rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs | 2 +- compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs | 2 +- .../rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs | 2 +- .../rustc_target/src/spec/targets/aarch64_apple_visionos.rs | 2 +- .../src/spec/targets/aarch64_apple_visionos_sim.rs | 2 +- .../src/spec/targets/aarch64_apple_watchos_sim.rs | 2 +- .../rustc_target/src/spec/targets/arm64_32_apple_watchos.rs | 2 +- compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs | 2 +- compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs | 2 +- compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs | 2 +- compiler/rustc_target/src/spec/targets/i386_apple_ios.rs | 2 +- compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs | 2 +- compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs | 2 +- compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs | 2 +- .../rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs | 2 +- compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs | 2 +- .../rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs | 2 +- .../rustc_target/src/spec/targets/x86_64h_apple_darwin.rs | 2 +- 22 files changed, 23 insertions(+), 23 deletions(-) diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs index 400f43103315e..3e05e72006e13 100644 --- a/compiler/rustc_target/src/spec/mod.rs +++ b/compiler/rustc_target/src/spec/mod.rs @@ -1882,7 +1882,7 @@ impl TargetWarnings { #[derive(PartialEq, Clone, Debug)] pub struct Target { /// Target triple to pass to LLVM. - pub llvm_target: StaticCow, + pub llvm_target: MaybeLazy, /// Metadata about a target, for example the description or tier. /// Used for generating target documentation. pub metadata: TargetMetadata, @@ -2734,7 +2734,7 @@ impl Target { }; let mut base = Target { - llvm_target: get_req_field("llvm-target")?.into(), + llvm_target: MaybeLazy::owned(get_req_field("llvm-target")?), metadata: Default::default(), pointer_width: get_req_field("target-pointer-width")? .parse::() diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs index 4563df9f40244..cf88dd2f1917d 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs @@ -17,7 +17,7 @@ pub fn target() -> Target { // Clang automatically chooses a more specific target based on // MACOSX_DEPLOYMENT_TARGET. To enable cross-language LTO to work // correctly, we do too. - llvm_target: macos_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| macos_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs index 14182d582df87..6abb8d172a427 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs @@ -14,7 +14,7 @@ pub fn target() -> Target { // IPHONEOS_DEPLOYMENT_TARGET. // This is required for the target to pick the right // MACH-O commands, so we do too. - llvm_target: ios_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| ios_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs index a607130d465c2..875241fb01b7c 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs @@ -10,7 +10,7 @@ pub fn target() -> Target { base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::LEAK | SanitizerSet::THREAD; Target { - llvm_target: mac_catalyst_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| mac_catalyst_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs index 48f6f1b4cbffc..f9921a2f3867e 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs @@ -14,7 +14,7 @@ pub fn target() -> Target { // IPHONEOS_DEPLOYMENT_TARGET. // This is required for the simulator target to pick the right // MACH-O commands, so we do too. - llvm_target: ios_sim_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| ios_sim_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs index 96d8dee0ac55d..3a35503e64aec 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs @@ -7,7 +7,7 @@ pub fn target() -> Target { const ABI: TargetAbi = TargetAbi::Normal; Target { - llvm_target: tvos_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| tvos_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs index 66b0689cc065e..65143f2474834 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs @@ -7,7 +7,7 @@ pub fn target() -> Target { const ABI: TargetAbi = TargetAbi::Normal; Target { - llvm_target: tvos_sim_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| tvos_sim_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs index 30913513d22a7..ab5bbe79c8d6c 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs @@ -11,7 +11,7 @@ pub fn target() -> Target { base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { - llvm_target: visionos_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| visionos_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: Some("ARM64 Apple visionOS".into()), tier: Some(3), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs index b1c8a3d9efa14..f724e70c9db13 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs @@ -10,7 +10,7 @@ pub fn target() -> Target { base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { - llvm_target: visionos_sim_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| visionos_sim_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: Some("ARM64 Apple visionOS simulator".into()), tier: Some(3), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs index 0dbe7f2724605..c8f78b344864d 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs @@ -11,7 +11,7 @@ pub fn target() -> Target { // WATCHOS_DEPLOYMENT_TARGET. // This is required for the simulator target to pick the right // MACH-O commands, so we do too. - llvm_target: watchos_sim_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| watchos_sim_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs b/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs index f0d1ac989fec9..737f896fa1c61 100644 --- a/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs +++ b/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs @@ -9,7 +9,7 @@ pub fn target() -> Target { let base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); Target { - llvm_target: watchos_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| watchos_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs index 9ba6c74ee0a91..178da0b4bafa0 100644 --- a/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs @@ -17,7 +17,7 @@ pub fn target() -> Target { // Clang automatically chooses a more specific target based on // MACOSX_DEPLOYMENT_TARGET. To enable cross-language LTO to work // correctly, we do too. - llvm_target: macos_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| macos_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs b/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs index 05a88f811e427..6234ae0ec9d18 100644 --- a/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs @@ -14,7 +14,7 @@ pub fn target() -> Target { // IPHONEOS_DEPLOYMENT_TARGET. // This is required for the target to pick the right // MACH-O commands, so we do too. - llvm_target: ios_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| ios_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs b/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs index a00d131d96986..6285e357f4aff 100644 --- a/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs @@ -7,7 +7,7 @@ pub fn target() -> Target { const ABI: TargetAbi = TargetAbi::Normal; Target { - llvm_target: ios_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| ios_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs b/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs index da6d813911902..3c1d9c044bda8 100644 --- a/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs @@ -13,7 +13,7 @@ pub fn target() -> Target { // IPHONEOS_DEPLOYMENT_TARGET. // This is required for the target to pick the right // MACH-O commands, so we do too. - llvm_target: ios_sim_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| ios_sim_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs index 1c1c877a87d59..2a371d324fc57 100644 --- a/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs @@ -20,7 +20,7 @@ pub fn target() -> Target { // correctly, we do too. // // While ld64 doesn't understand i686, LLVM does. - llvm_target: macos_llvm_target(Arch::I686).into(), + llvm_target: MaybeLazy::lazy(|| macos_llvm_target(Arch::I686)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs index 2c3ab6a3d4ce7..7d5a5810213f1 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs @@ -20,7 +20,7 @@ pub fn target() -> Target { // Clang automatically chooses a more specific target based on // MACOSX_DEPLOYMENT_TARGET. To enable cross-language LTO to work // correctly, we do too. - llvm_target: macos_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| macos_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs index 11f22170256df..043ef133186ed 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs @@ -12,7 +12,7 @@ pub fn target() -> Target { base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { - llvm_target: ios_sim_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| ios_sim_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs index 9a71697c5d932..c95e3df08a972 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs @@ -10,7 +10,7 @@ pub fn target() -> Target { base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::LEAK | SanitizerSet::THREAD; Target { - llvm_target: mac_catalyst_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| mac_catalyst_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs index c112f2cd3448a..f86e26bec7ebf 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs @@ -10,7 +10,7 @@ pub fn target() -> Target { const ABI: TargetAbi = TargetAbi::Simulator; Target { - llvm_target: tvos_sim_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| tvos_sim_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs index 91711cf33d6bb..95a67c895e1e1 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs @@ -7,7 +7,7 @@ pub fn target() -> Target { const ABI: TargetAbi = TargetAbi::Simulator; Target { - llvm_target: watchos_sim_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| watchos_sim_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, diff --git a/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs index 2e65eea60ef41..c1633d792b646 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs @@ -38,7 +38,7 @@ pub fn target() -> Target { // Clang automatically chooses a more specific target based on // MACOSX_DEPLOYMENT_TARGET. To enable cross-language LTO to work // correctly, we do too. - llvm_target: macos_llvm_target(ARCH).into(), + llvm_target: MaybeLazy::lazy(|| macos_llvm_target(ARCH)), metadata: crate::spec::TargetMetadata { description: None, tier: None, From 124f9fbf21c5dd4f4cdc0e777972a9f037234921 Mon Sep 17 00:00:00 2001 From: Urgau Date: Mon, 18 Mar 2024 19:56:19 +0100 Subject: [PATCH 06/13] Fix rustc_target tests --- compiler/rustc_target/src/spec/tests/tests_impl.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/rustc_target/src/spec/tests/tests_impl.rs b/compiler/rustc_target/src/spec/tests/tests_impl.rs index 3be18ef3127d5..e84aa598c20ed 100644 --- a/compiler/rustc_target/src/spec/tests/tests_impl.rs +++ b/compiler/rustc_target/src/spec/tests/tests_impl.rs @@ -37,7 +37,7 @@ impl Target { &self.late_link_args_static, &self.post_link_args, ] { - for (&flavor, flavor_args) in args { + for (&flavor, flavor_args) in &**args { assert!(!flavor_args.is_empty()); // Check that flavors mentioned in link args are compatible with the default flavor. match self.linker_flavor { From 7c3b6c9150a77bea243f9dc18bb12efe055f18bc Mon Sep 17 00:00:00 2001 From: Urgau Date: Sat, 15 Jun 2024 17:02:19 +0200 Subject: [PATCH 07/13] MaybeLazy: Permit non function-pointer as lazy input --- compiler/rustc_target/src/spec/maybe_lazy.rs | 65 +++++++++++++------- 1 file changed, 42 insertions(+), 23 deletions(-) diff --git a/compiler/rustc_target/src/spec/maybe_lazy.rs b/compiler/rustc_target/src/spec/maybe_lazy.rs index 201db71d636f0..f1a8e658853aa 100644 --- a/compiler/rustc_target/src/spec/maybe_lazy.rs +++ b/compiler/rustc_target/src/spec/maybe_lazy.rs @@ -5,8 +5,8 @@ use std::fmt::{Debug, Display}; use std::ops::Deref; use std::sync::LazyLock; -enum MaybeLazyInner { - Lazy(LazyLock), +enum MaybeLazyInner { + Lazy(LazyLock), Cow(Cow<'static, T>), } @@ -16,16 +16,16 @@ enum MaybeLazyInner { /// They can all be constructed from the [`MaybeLazy::borrowed`], [`MaybeLazy::owned`] and /// [`MaybeLazy::lazy`] methods. #[repr(transparent)] -pub struct MaybeLazy { +pub struct MaybeLazy ::Owned> { // Inner state. // // Not to be inlined since we may want in the future to // make this struct usable to statics and we might need to // workaround const-eval limitation (particulary around drop). - inner: MaybeLazyInner, + inner: MaybeLazyInner, } -impl MaybeLazy { +impl T::Owned> MaybeLazy { /// Create a [`MaybeLazy`] from an borrowed `T`. #[inline] pub const fn borrowed(a: &'static T) -> Self { @@ -38,17 +38,24 @@ impl MaybeLazy { MaybeLazy { inner: MaybeLazyInner::Cow(Cow::Owned(a)) } } - /// Create a [`MaybeLazy`] that is lazy by taking a function pointer. - /// - /// This function pointer cannot *ever* take a closure. User can potentially - /// workaround that by using closure-to-fnptr or `const` items. + /// Create a [`MaybeLazy`] from a function-able `F`. + #[inline] + pub const fn lazied(f: F) -> Self { + MaybeLazy { inner: MaybeLazyInner::Lazy(LazyLock::new(f)) } + } +} + +impl MaybeLazy { + /// Create a [`MaybeLazy`] from a function pointer. #[inline] pub const fn lazy(a: fn() -> T::Owned) -> Self { MaybeLazy { inner: MaybeLazyInner::Lazy(LazyLock::new(a)) } } } -impl> Clone for MaybeLazy { +impl, F: FnOnce() -> T::Owned> Clone + for MaybeLazy +{ #[inline] fn clone(&self) -> Self { MaybeLazy { @@ -60,15 +67,19 @@ impl> Clone for MaybeLazy { } } -impl> Default for MaybeLazy { +impl, F: FnOnce() -> T::Owned> Default + for MaybeLazy +{ #[inline] - fn default() -> MaybeLazy { - MaybeLazy::lazy(T::Owned::default) + fn default() -> MaybeLazy { + MaybeLazy::owned(T::Owned::default()) } } // `Debug`, `Display` and other traits below are implemented in terms of this `Deref` -impl>> Deref for MaybeLazy { +impl>, F: FnOnce() -> T::Owned> Deref + for MaybeLazy +{ type Target = T; #[inline] @@ -80,46 +91,54 @@ impl>> Deref for MaybeLazy { } } -impl + Debug> Debug for MaybeLazy { +impl + Debug, F: FnOnce() -> T::Owned> Debug + for MaybeLazy +{ #[inline] fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { Debug::fmt(&**self, fmt) } } -impl + Display> Display for MaybeLazy { +impl + Display, F: FnOnce() -> T::Owned> Display + for MaybeLazy +{ #[inline] fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { Display::fmt(&**self, fmt) } } -impl AsRef for MaybeLazy { +impl T::Owned> AsRef for MaybeLazy { #[inline] fn as_ref(&self) -> &T { &**self } } -impl + ToOwned, C: ?Sized + ToOwned> PartialEq> - for MaybeLazy +impl< + B: ?Sized + PartialEq + ToOwned, + C: ?Sized + ToOwned, + F1: FnOnce() -> B::Owned, + F2: FnOnce() -> C::Owned, +> PartialEq> for MaybeLazy { #[inline] - fn eq(&self, other: &MaybeLazy) -> bool { + fn eq(&self, other: &MaybeLazy) -> bool { PartialEq::eq(&**self, &**other) } } -impl PartialEq<&str> for MaybeLazy { +impl String> PartialEq<&str> for MaybeLazy { #[inline] fn eq(&self, other: &&str) -> bool { &**self == *other } } -impl From<&'static str> for MaybeLazy { +impl String> From<&'static str> for MaybeLazy { #[inline] - fn from(s: &'static str) -> MaybeLazy { + fn from(s: &'static str) -> MaybeLazy { MaybeLazy::borrowed(s) } } From 47b71972b9ca27376bfd9b2475d8fc66348d5500 Mon Sep 17 00:00:00 2001 From: Urgau Date: Sat, 15 Jun 2024 17:03:37 +0200 Subject: [PATCH 08/13] Move CRT Objects to stateful `MaybeLazy` --- compiler/rustc_target/src/lib.rs | 2 + compiler/rustc_target/src/spec/base/aix.rs | 12 +- .../rustc_target/src/spec/base/fuchsia.rs | 14 +-- compiler/rustc_target/src/spec/crt_objects.rs | 114 +++++++++--------- 4 files changed, 72 insertions(+), 70 deletions(-) diff --git a/compiler/rustc_target/src/lib.rs b/compiler/rustc_target/src/lib.rs index ecc91ab9a310e..2962b0ab61e7f 100644 --- a/compiler/rustc_target/src/lib.rs +++ b/compiler/rustc_target/src/lib.rs @@ -12,11 +12,13 @@ #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")] #![doc(rust_logo)] #![feature(assert_matches)] +#![feature(fn_traits)] #![feature(iter_intersperse)] #![feature(let_chains)] #![feature(min_exhaustive_patterns)] #![feature(rustc_attrs)] #![feature(rustdoc_internals)] +#![feature(unboxed_closures)] // tidy-alphabetical-end use std::path::{Path, PathBuf}; diff --git a/compiler/rustc_target/src/spec/base/aix.rs b/compiler/rustc_target/src/spec/base/aix.rs index fb131dff31dd2..62325457b626d 100644 --- a/compiler/rustc_target/src/spec/base/aix.rs +++ b/compiler/rustc_target/src/spec/base/aix.rs @@ -1,6 +1,6 @@ use crate::abi::Endian; +use crate::spec::TargetOptions; use crate::spec::{crt_objects, cvs, Cc, CodeModel, LinkOutputKind, LinkerFlavor}; -use crate::spec::{MaybeLazy, TargetOptions}; pub fn opts() -> TargetOptions { TargetOptions { @@ -23,12 +23,10 @@ pub fn opts() -> TargetOptions { is_like_aix: true, default_dwarf_version: 3, function_sections: true, - pre_link_objects: MaybeLazy::lazy(|| { - crt_objects::new(&[ - (LinkOutputKind::DynamicNoPicExe, &["/usr/lib/crt0_64.o", "/usr/lib/crti_64.o"]), - (LinkOutputKind::DynamicPicExe, &["/usr/lib/crt0_64.o", "/usr/lib/crti_64.o"]), - ]) - }), + pre_link_objects: crt_objects::new(&[ + (LinkOutputKind::DynamicNoPicExe, &["/usr/lib/crt0_64.o", "/usr/lib/crti_64.o"]), + (LinkOutputKind::DynamicPicExe, &["/usr/lib/crt0_64.o", "/usr/lib/crti_64.o"]), + ]), dll_suffix: ".a".into(), ..Default::default() } diff --git a/compiler/rustc_target/src/spec/base/fuchsia.rs b/compiler/rustc_target/src/spec/base/fuchsia.rs index f8652a08f87d0..3fbd38223187c 100644 --- a/compiler/rustc_target/src/spec/base/fuchsia.rs +++ b/compiler/rustc_target/src/spec/base/fuchsia.rs @@ -34,14 +34,12 @@ pub fn opts() -> TargetOptions { dynamic_linking: true, families: cvs!["unix"], pre_link_args, - pre_link_objects: MaybeLazy::lazy(|| { - crt_objects::new(&[ - (LinkOutputKind::DynamicNoPicExe, &["Scrt1.o"]), - (LinkOutputKind::DynamicPicExe, &["Scrt1.o"]), - (LinkOutputKind::StaticNoPicExe, &["Scrt1.o"]), - (LinkOutputKind::StaticPicExe, &["Scrt1.o"]), - ]) - }), + pre_link_objects: crt_objects::new(&[ + (LinkOutputKind::DynamicNoPicExe, &["Scrt1.o"]), + (LinkOutputKind::DynamicPicExe, &["Scrt1.o"]), + (LinkOutputKind::StaticNoPicExe, &["Scrt1.o"]), + (LinkOutputKind::StaticPicExe, &["Scrt1.o"]), + ]), position_independent_executables: true, has_thread_local: true, frame_pointer: FramePointer::NonLeaf, diff --git a/compiler/rustc_target/src/spec/crt_objects.rs b/compiler/rustc_target/src/spec/crt_objects.rs index 5f9736617e745..b34c7deabf556 100644 --- a/compiler/rustc_target/src/spec/crt_objects.rs +++ b/compiler/rustc_target/src/spec/crt_objects.rs @@ -44,89 +44,93 @@ use crate::spec::{LinkOutputKind, MaybeLazy}; use std::borrow::Cow; use std::collections::BTreeMap; -pub type CrtObjects = BTreeMap>>; -pub type LazyCrtObjects = MaybeLazy; +type Tralala = &'static [(LinkOutputKind, &'static [&'static str])]; +pub struct Trulala(Tralala); -pub(super) fn new(obj_table: &[(LinkOutputKind, &[&'static str])]) -> CrtObjects { - obj_table.iter().map(|(z, k)| (*z, k.iter().map(|b| (*b).into()).collect())).collect() +impl FnOnce<()> for Trulala { + type Output = CrtObjects; + extern "rust-call" fn call_once(self, _args: ()) -> Self::Output { + self.0.iter().map(|(z, k)| (*z, k.iter().map(|b| (*b).into()).collect())).collect() + } } -pub(super) fn all(obj: &'static str) -> CrtObjects { - new(&[ - (LinkOutputKind::DynamicNoPicExe, &[obj]), - (LinkOutputKind::DynamicPicExe, &[obj]), - (LinkOutputKind::StaticNoPicExe, &[obj]), - (LinkOutputKind::StaticPicExe, &[obj]), - (LinkOutputKind::DynamicDylib, &[obj]), - (LinkOutputKind::StaticDylib, &[obj]), - ]) +pub type CrtObjects = BTreeMap>>; +pub type LazyCrtObjects = MaybeLazy; + +pub(super) fn new(obj_table: Tralala) -> LazyCrtObjects { + MaybeLazy::lazied(Trulala(obj_table)) } -pub(super) fn pre_musl_self_contained() -> LazyCrtObjects { - MaybeLazy::lazy(|| { +macro_rules! all { + ($obj: literal) => { new(&[ - (LinkOutputKind::DynamicNoPicExe, &["crt1.o", "crti.o", "crtbegin.o"]), - (LinkOutputKind::DynamicPicExe, &["Scrt1.o", "crti.o", "crtbeginS.o"]), - (LinkOutputKind::StaticNoPicExe, &["crt1.o", "crti.o", "crtbegin.o"]), - (LinkOutputKind::StaticPicExe, &["rcrt1.o", "crti.o", "crtbeginS.o"]), - (LinkOutputKind::DynamicDylib, &["crti.o", "crtbeginS.o"]), - (LinkOutputKind::StaticDylib, &["crti.o", "crtbeginS.o"]), + (LinkOutputKind::DynamicNoPicExe, &[$obj]), + (LinkOutputKind::DynamicPicExe, &[$obj]), + (LinkOutputKind::StaticNoPicExe, &[$obj]), + (LinkOutputKind::StaticPicExe, &[$obj]), + (LinkOutputKind::DynamicDylib, &[$obj]), + (LinkOutputKind::StaticDylib, &[$obj]), ]) - }) + }; +} + +pub(super) fn pre_musl_self_contained() -> LazyCrtObjects { + new(&[ + (LinkOutputKind::DynamicNoPicExe, &["crt1.o", "crti.o", "crtbegin.o"]), + (LinkOutputKind::DynamicPicExe, &["Scrt1.o", "crti.o", "crtbeginS.o"]), + (LinkOutputKind::StaticNoPicExe, &["crt1.o", "crti.o", "crtbegin.o"]), + (LinkOutputKind::StaticPicExe, &["rcrt1.o", "crti.o", "crtbeginS.o"]), + (LinkOutputKind::DynamicDylib, &["crti.o", "crtbeginS.o"]), + (LinkOutputKind::StaticDylib, &["crti.o", "crtbeginS.o"]), + ]) } pub(super) fn post_musl_self_contained() -> LazyCrtObjects { - MaybeLazy::lazy(|| { - new(&[ - (LinkOutputKind::DynamicNoPicExe, &["crtend.o", "crtn.o"]), - (LinkOutputKind::DynamicPicExe, &["crtendS.o", "crtn.o"]), - (LinkOutputKind::StaticNoPicExe, &["crtend.o", "crtn.o"]), - (LinkOutputKind::StaticPicExe, &["crtendS.o", "crtn.o"]), - (LinkOutputKind::DynamicDylib, &["crtendS.o", "crtn.o"]), - (LinkOutputKind::StaticDylib, &["crtendS.o", "crtn.o"]), - ]) - }) + new(&[ + (LinkOutputKind::DynamicNoPicExe, &["crtend.o", "crtn.o"]), + (LinkOutputKind::DynamicPicExe, &["crtendS.o", "crtn.o"]), + (LinkOutputKind::StaticNoPicExe, &["crtend.o", "crtn.o"]), + (LinkOutputKind::StaticPicExe, &["crtendS.o", "crtn.o"]), + (LinkOutputKind::DynamicDylib, &["crtendS.o", "crtn.o"]), + (LinkOutputKind::StaticDylib, &["crtendS.o", "crtn.o"]), + ]) } pub(super) fn pre_mingw_self_contained() -> LazyCrtObjects { - MaybeLazy::lazy(|| { - new(&[ - (LinkOutputKind::DynamicNoPicExe, &["crt2.o", "rsbegin.o"]), - (LinkOutputKind::DynamicPicExe, &["crt2.o", "rsbegin.o"]), - (LinkOutputKind::StaticNoPicExe, &["crt2.o", "rsbegin.o"]), - (LinkOutputKind::StaticPicExe, &["crt2.o", "rsbegin.o"]), - (LinkOutputKind::DynamicDylib, &["dllcrt2.o", "rsbegin.o"]), - (LinkOutputKind::StaticDylib, &["dllcrt2.o", "rsbegin.o"]), - ]) - }) + new(&[ + (LinkOutputKind::DynamicNoPicExe, &["crt2.o", "rsbegin.o"]), + (LinkOutputKind::DynamicPicExe, &["crt2.o", "rsbegin.o"]), + (LinkOutputKind::StaticNoPicExe, &["crt2.o", "rsbegin.o"]), + (LinkOutputKind::StaticPicExe, &["crt2.o", "rsbegin.o"]), + (LinkOutputKind::DynamicDylib, &["dllcrt2.o", "rsbegin.o"]), + (LinkOutputKind::StaticDylib, &["dllcrt2.o", "rsbegin.o"]), + ]) } pub(super) fn post_mingw_self_contained() -> LazyCrtObjects { - MaybeLazy::lazy(|| all("rsend.o")) + all!("rsend.o") } pub(super) fn pre_mingw() -> LazyCrtObjects { - MaybeLazy::lazy(|| all("rsbegin.o")) + all!("rsbegin.o") } pub(super) fn post_mingw() -> LazyCrtObjects { - MaybeLazy::lazy(|| all("rsend.o")) + all!("rsend.o") } pub(super) fn pre_wasi_self_contained() -> LazyCrtObjects { // Use crt1-command.o instead of crt1.o to enable support for new-style // commands. See https://reviews.llvm.org/D81689 for more info. - MaybeLazy::lazy(|| { - new(&[ - (LinkOutputKind::DynamicNoPicExe, &["crt1-command.o"]), - (LinkOutputKind::DynamicPicExe, &["crt1-command.o"]), - (LinkOutputKind::StaticNoPicExe, &["crt1-command.o"]), - (LinkOutputKind::StaticPicExe, &["crt1-command.o"]), - (LinkOutputKind::WasiReactorExe, &["crt1-reactor.o"]), - ]) - }) + new(&[ + (LinkOutputKind::DynamicNoPicExe, &["crt1-command.o"]), + (LinkOutputKind::DynamicPicExe, &["crt1-command.o"]), + (LinkOutputKind::StaticNoPicExe, &["crt1-command.o"]), + (LinkOutputKind::StaticPicExe, &["crt1-command.o"]), + (LinkOutputKind::WasiReactorExe, &["crt1-reactor.o"]), + ]) } pub(super) fn post_wasi_self_contained() -> LazyCrtObjects { - MaybeLazy::lazy(|| new(&[])) + new(&[]) } From 5f567164a96fa3a33ea72a39c715208346428dd8 Mon Sep 17 00:00:00 2001 From: Urgau Date: Sat, 15 Jun 2024 18:18:14 +0200 Subject: [PATCH 09/13] Make `TargetOptions::link_args` stateful lazy - part 1 --- .../rustc_target/src/spec/base/apple/mod.rs | 4 +- .../rustc_target/src/spec/base/avr_gnu.rs | 16 +++-- .../rustc_target/src/spec/base/fuchsia.rs | 34 +++++---- .../rustc_target/src/spec/base/illumos.rs | 48 ++++++------- compiler/rustc_target/src/spec/base/msvc.rs | 5 +- compiler/rustc_target/src/spec/base/teeos.rs | 2 +- .../rustc_target/src/spec/base/uefi_msvc.rs | 42 ++++++----- compiler/rustc_target/src/spec/base/wasm.rs | 3 +- .../rustc_target/src/spec/base/windows_gnu.rs | 8 +-- .../src/spec/base/windows_gnullvm.rs | 24 +++---- .../src/spec/base/windows_uwp_gnu.rs | 2 +- .../src/spec/base/windows_uwp_msvc.rs | 7 +- compiler/rustc_target/src/spec/link_args.rs | 26 +++++++ compiler/rustc_target/src/spec/mod.rs | 31 ++++---- .../spec/targets/aarch64_unknown_illumos.rs | 5 +- .../src/spec/targets/aarch64_unknown_none.rs | 14 ++-- .../targets/aarch64_unknown_nto_qnx710.rs | 12 ++-- .../src/spec/targets/aarch64_unknown_uefi.rs | 6 +- .../spec/targets/arm64ec_pc_windows_msvc.rs | 12 ++-- .../src/spec/targets/armv6k_nintendo_3ds.rs | 12 ++-- .../spec/targets/armv7_linux_androideabi.rs | 7 +- .../targets/armv7_sony_vita_newlibeabihf.rs | 12 ++-- .../targets/csky_unknown_linux_gnuabiv2.rs | 4 +- .../targets/csky_unknown_linux_gnuabiv2hf.rs | 4 +- .../src/spec/targets/i586_pc_nto_qnx700.rs | 9 +-- .../src/spec/targets/i686_apple_darwin.rs | 5 +- .../src/spec/targets/i686_pc_windows_gnu.rs | 2 +- .../spec/targets/i686_pc_windows_gnullvm.rs | 12 ++-- .../src/spec/targets/i686_pc_windows_msvc.rs | 28 ++++---- .../src/spec/targets/i686_unknown_freebsd.rs | 7 +- .../src/spec/targets/i686_unknown_haiku.rs | 6 +- .../src/spec/targets/i686_unknown_hurd_gnu.rs | 6 +- .../spec/targets/i686_unknown_linux_gnu.rs | 6 +- .../spec/targets/i686_unknown_linux_musl.rs | 7 +- .../src/spec/targets/i686_unknown_netbsd.rs | 6 +- .../src/spec/targets/i686_unknown_openbsd.rs | 7 +- .../src/spec/targets/i686_unknown_redox.rs | 4 +- .../src/spec/targets/i686_uwp_windows_gnu.rs | 2 +- .../spec/targets/i686_win7_windows_msvc.rs | 28 ++++---- .../src/spec/targets/i686_wrs_vxworks.rs | 6 +- .../src/spec/targets/mipsel_sony_psp.rs | 9 +-- .../src/spec/targets/powerpc64_ibm_aix.rs | 12 ++-- .../spec/targets/powerpc64_unknown_freebsd.rs | 6 +- .../targets/powerpc64_unknown_linux_gnu.rs | 6 +- .../targets/powerpc64_unknown_linux_musl.rs | 6 +- .../spec/targets/powerpc64_unknown_openbsd.rs | 6 +- .../src/spec/targets/powerpc64_wrs_vxworks.rs | 6 +- .../targets/powerpc64le_unknown_freebsd.rs | 6 +- .../targets/powerpc64le_unknown_linux_gnu.rs | 6 +- .../targets/powerpc64le_unknown_linux_musl.rs | 6 +- .../spec/targets/powerpc_unknown_freebsd.rs | 12 ++-- .../spec/targets/powerpc_unknown_linux_gnu.rs | 6 +- .../targets/powerpc_unknown_linux_gnuspe.rs | 6 +- .../targets/powerpc_unknown_linux_musl.rs | 6 +- .../spec/targets/powerpc_unknown_netbsd.rs | 6 +- .../src/spec/targets/powerpc_wrs_vxworks.rs | 7 +- .../spec/targets/powerpc_wrs_vxworks_spe.rs | 7 +- .../spec/targets/sparc64_unknown_netbsd.rs | 6 +- .../spec/targets/sparc64_unknown_openbsd.rs | 6 +- .../spec/targets/sparc_unknown_linux_gnu.rs | 7 +- .../src/spec/targets/sparcv9_sun_solaris.rs | 5 +- .../spec/targets/thumbv7a_pc_windows_msvc.rs | 5 +- .../targets/thumbv7neon_linux_androideabi.rs | 7 +- .../spec/targets/wasm32_unknown_emscripten.rs | 5 +- .../spec/targets/wasm32_unknown_unknown.rs | 2 +- .../src/spec/targets/wasm32_wasip1.rs | 6 +- .../src/spec/targets/wasm32_wasip1_threads.rs | 2 +- .../spec/targets/wasm64_unknown_unknown.rs | 2 +- .../src/spec/targets/x86_64_apple_darwin.rs | 5 +- .../targets/x86_64_fortanix_unknown_sgx.rs | 72 +++++++++---------- .../src/spec/targets/x86_64_linux_android.rs | 6 +- .../src/spec/targets/x86_64_pc_nto_qnx710.rs | 12 ++-- .../src/spec/targets/x86_64_pc_solaris.rs | 7 +- .../src/spec/targets/x86_64_pc_windows_gnu.rs | 2 +- .../spec/targets/x86_64_pc_windows_gnullvm.rs | 6 +- .../targets/x86_64_unikraft_linux_musl.rs | 6 +- .../spec/targets/x86_64_unknown_dragonfly.rs | 6 +- .../spec/targets/x86_64_unknown_freebsd.rs | 6 +- .../src/spec/targets/x86_64_unknown_haiku.rs | 6 +- .../spec/targets/x86_64_unknown_illumos.rs | 7 +- .../spec/targets/x86_64_unknown_linux_gnu.rs | 6 +- .../targets/x86_64_unknown_linux_gnux32.rs | 6 +- .../spec/targets/x86_64_unknown_linux_musl.rs | 6 +- .../spec/targets/x86_64_unknown_linux_ohos.rs | 6 +- .../src/spec/targets/x86_64_unknown_netbsd.rs | 6 +- .../spec/targets/x86_64_unknown_openbsd.rs | 6 +- .../src/spec/targets/x86_64_unknown_redox.rs | 6 +- .../spec/targets/x86_64_uwp_windows_gnu.rs | 2 +- .../src/spec/targets/x86_64_wrs_vxworks.rs | 6 +- .../src/spec/targets/x86_64h_apple_darwin.rs | 5 +- 90 files changed, 378 insertions(+), 471 deletions(-) create mode 100644 compiler/rustc_target/src/spec/link_args.rs diff --git a/compiler/rustc_target/src/spec/base/apple/mod.rs b/compiler/rustc_target/src/spec/base/apple/mod.rs index 317a7fffb7325..23b1dbeb22a65 100644 --- a/compiler/rustc_target/src/spec/base/apple/mod.rs +++ b/compiler/rustc_target/src/spec/base/apple/mod.rs @@ -114,7 +114,7 @@ pub fn pre_link_args(os: &'static str, arch: Arch, abi: TargetAbi) -> LinkArgs { }; let sdk_version = min_version.clone(); - let mut args = TargetOptions::link_args( + let mut args = TargetOptions::link_args_base( LinkerFlavor::Darwin(Cc::No, Lld::No), &["-arch", arch.target_name(), "-platform_version"], ); @@ -144,7 +144,7 @@ pub fn opts( os: &'static str, arch: Arch, abi: TargetAbi, - pre_link_args: MaybeLazy, + pre_link_args: MaybeLazy, ) -> TargetOptions { TargetOptions { abi: abi.target_abi().into(), diff --git a/compiler/rustc_target/src/spec/base/avr_gnu.rs b/compiler/rustc_target/src/spec/base/avr_gnu.rs index 1307b43aa889e..27bc5a1c9ea8a 100644 --- a/compiler/rustc_target/src/spec/base/avr_gnu.rs +++ b/compiler/rustc_target/src/spec/base/avr_gnu.rs @@ -1,4 +1,4 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, MaybeLazy, RelocModel, Target, TargetOptions}; +use crate::spec::{Cc, LinkerFlavor, Lld, RelocModel, Target, TargetOptions}; use object::elf; /// A base target for AVR devices using the GNU toolchain. @@ -23,12 +23,14 @@ pub fn target(target_cpu: &'static str) -> Target { linker: Some("avr-gcc".into()), eh_frame_header: false, - pre_link_args: MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mmcu=atmega328"]) - }), - late_link_args: MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-lgcc"]) - }), + pre_link_args: TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-mmcu=atmega328"], + ), + late_link_args: TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-lgcc"], + ), max_atomic_width: Some(16), atomic_cas: false, relocation_model: RelocModel::Static, diff --git a/compiler/rustc_target/src/spec/base/fuchsia.rs b/compiler/rustc_target/src/spec/base/fuchsia.rs index 3fbd38223187c..cfcedbef7aff7 100644 --- a/compiler/rustc_target/src/spec/base/fuchsia.rs +++ b/compiler/rustc_target/src/spec/base/fuchsia.rs @@ -8,24 +8,22 @@ pub fn opts() -> TargetOptions { // so we only list them for ld/lld. // // https://github.com/llvm/llvm-project/blob/db9322b2066c55254e7691efeab863f43bfcc084/clang/lib/Driver/ToolChains/Fuchsia.cpp#L31 - let pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &[ - "--build-id", - "--hash-style=gnu", - "-z", - "max-page-size=4096", - "-z", - "now", - "-z", - "rodynamic", - "-z", - "separate-loadable-segments", - "--pack-dyn-relocs=relr", - ], - ) - }); + let pre_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &[ + "--build-id", + "--hash-style=gnu", + "-z", + "max-page-size=4096", + "-z", + "now", + "-z", + "rodynamic", + "-z", + "separate-loadable-segments", + "--pack-dyn-relocs=relr", + ], + ); TargetOptions { os: "fuchsia".into(), diff --git a/compiler/rustc_target/src/spec/base/illumos.rs b/compiler/rustc_target/src/spec/base/illumos.rs index 41f501b30c0b7..f0a648b93ad04 100644 --- a/compiler/rustc_target/src/spec/base/illumos.rs +++ b/compiler/rustc_target/src/spec/base/illumos.rs @@ -1,30 +1,28 @@ -use crate::spec::{cvs, Cc, FramePointer, LinkerFlavor, MaybeLazy, TargetOptions}; +use crate::spec::{cvs, Cc, FramePointer, LinkerFlavor, TargetOptions}; pub fn opts() -> TargetOptions { - let late_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Unix(Cc::Yes), - &[ - // The illumos libc contains a stack unwinding implementation, as - // does libgcc_s. The latter implementation includes several - // additional symbols that are not always in base libc. To force - // the consistent use of just one unwinder, we ensure libc appears - // after libgcc_s in the NEEDED list for the resultant binary by - // ignoring any attempts to add it as a dynamic dependency until the - // very end. - // FIXME: This should be replaced by a more complete and generic - // mechanism for controlling the order of library arguments passed - // to the linker. - "-lc", - // LLVM will insert calls to the stack protector functions - // "__stack_chk_fail" and "__stack_chk_guard" into code in native - // object files. Some platforms include these symbols directly in - // libc, but at least historically these have been provided in - // libssp.so on illumos and Solaris systems. - "-lssp", - ], - ) - }); + let late_link_args = TargetOptions::link_args( + LinkerFlavor::Unix(Cc::Yes), + &[ + // The illumos libc contains a stack unwinding implementation, as + // does libgcc_s. The latter implementation includes several + // additional symbols that are not always in base libc. To force + // the consistent use of just one unwinder, we ensure libc appears + // after libgcc_s in the NEEDED list for the resultant binary by + // ignoring any attempts to add it as a dynamic dependency until the + // very end. + // FIXME: This should be replaced by a more complete and generic + // mechanism for controlling the order of library arguments passed + // to the linker. + "-lc", + // LLVM will insert calls to the stack protector functions + // "__stack_chk_fail" and "__stack_chk_guard" into code in native + // object files. Some platforms include these symbols directly in + // libc, but at least historically these have been provided in + // libssp.so on illumos and Solaris systems. + "-lssp", + ], + ); TargetOptions { os: "illumos".into(), diff --git a/compiler/rustc_target/src/spec/base/msvc.rs b/compiler/rustc_target/src/spec/base/msvc.rs index 0a55aa3b5d4e2..44fc376fea084 100644 --- a/compiler/rustc_target/src/spec/base/msvc.rs +++ b/compiler/rustc_target/src/spec/base/msvc.rs @@ -1,11 +1,10 @@ -use crate::spec::{DebuginfoKind, LinkerFlavor, Lld, MaybeLazy, SplitDebuginfo, TargetOptions}; +use crate::spec::{DebuginfoKind, LinkerFlavor, Lld, SplitDebuginfo, TargetOptions}; use std::borrow::Cow; pub fn opts() -> TargetOptions { // Suppress the verbose logo and authorship debugging output, which would needlessly // clog any log files. - let pre_link_args = - MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Msvc(Lld::No), &["/NOLOGO"])); + let pre_link_args = TargetOptions::link_args(LinkerFlavor::Msvc(Lld::No), &["/NOLOGO"]); TargetOptions { linker_flavor: LinkerFlavor::Msvc(Lld::No), diff --git a/compiler/rustc_target/src/spec/base/teeos.rs b/compiler/rustc_target/src/spec/base/teeos.rs index 8ef8f767fdb80..53bc5c580b4f9 100644 --- a/compiler/rustc_target/src/spec/base/teeos.rs +++ b/compiler/rustc_target/src/spec/base/teeos.rs @@ -7,7 +7,7 @@ pub fn opts() -> TargetOptions { let lld_args = &["-zmax-page-size=4096", "-znow", "-ztext", "--execute-only"]; let cc_args = &["-Wl,-zmax-page-size=4096", "-Wl,-znow", "-Wl,-ztext", "-mexecute-only"]; let mut pre_link_args = - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), lld_args); + TargetOptions::link_args_base(LinkerFlavor::Gnu(Cc::No, Lld::No), lld_args); add_link_args(&mut pre_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), cc_args); pre_link_args }); diff --git a/compiler/rustc_target/src/spec/base/uefi_msvc.rs b/compiler/rustc_target/src/spec/base/uefi_msvc.rs index 432ec2b4b0d16..8d908144d58c2 100644 --- a/compiler/rustc_target/src/spec/base/uefi_msvc.rs +++ b/compiler/rustc_target/src/spec/base/uefi_msvc.rs @@ -9,33 +9,31 @@ // the timer-interrupt. Device-drivers are required to use polling-based models. Furthermore, all // code runs in the same environment, no process separation is supported. -use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy}; +use crate::spec::{base, LinkerFlavor, Lld}; use crate::spec::{PanicStrategy, StackProbeType, TargetOptions}; pub fn opts() -> TargetOptions { let mut base = base::msvc::opts(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Msvc(Lld::No), - &[ - // Non-standard subsystems have no default entry-point in PE+ files. We have to define - // one. "efi_main" seems to be a common choice amongst other implementations and the - // spec. - "/entry:efi_main", - // COFF images have a "Subsystem" field in their header, which defines what kind of - // program it is. UEFI has 3 fields reserved, which are EFI_APPLICATION, - // EFI_BOOT_SERVICE_DRIVER, and EFI_RUNTIME_DRIVER. We default to EFI_APPLICATION, - // which is very likely the most common option. Individual projects can override this - // with custom linker flags. - // The subsystem-type only has minor effects on the application. It defines the memory - // regions the application is loaded into (runtime-drivers need to be put into - // reserved areas), as well as whether a return from the entry-point is treated as - // exit (default for applications). - "/subsystem:efi_application", - ], - ) - }); + base.pre_link_args = TargetOptions::link_args( + LinkerFlavor::Msvc(Lld::No), + &[ + // Non-standard subsystems have no default entry-point in PE+ files. We have to define + // one. "efi_main" seems to be a common choice amongst other implementations and the + // spec. + "/entry:efi_main", + // COFF images have a "Subsystem" field in their header, which defines what kind of + // program it is. UEFI has 3 fields reserved, which are EFI_APPLICATION, + // EFI_BOOT_SERVICE_DRIVER, and EFI_RUNTIME_DRIVER. We default to EFI_APPLICATION, + // which is very likely the most common option. Individual projects can override this + // with custom linker flags. + // The subsystem-type only has minor effects on the application. It defines the memory + // regions the application is loaded into (runtime-drivers need to be put into + // reserved areas), as well as whether a return from the entry-point is treated as + // exit (default for applications). + "/subsystem:efi_application", + ], + ); TargetOptions { os: "uefi".into(), diff --git a/compiler/rustc_target/src/spec/base/wasm.rs b/compiler/rustc_target/src/spec/base/wasm.rs index e01454d89545a..e73ca46248a30 100644 --- a/compiler/rustc_target/src/spec/base/wasm.rs +++ b/compiler/rustc_target/src/spec/base/wasm.rs @@ -49,7 +49,8 @@ pub fn options() -> TargetOptions { } let pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args(LinkerFlavor::WasmLld(Cc::No), args!("")); + let mut pre_link_args = + TargetOptions::link_args_base(LinkerFlavor::WasmLld(Cc::No), args!("")); add_link_args(&mut pre_link_args, LinkerFlavor::WasmLld(Cc::Yes), args!("-Wl,")); pre_link_args }); diff --git a/compiler/rustc_target/src/spec/base/windows_gnu.rs b/compiler/rustc_target/src/spec/base/windows_gnu.rs index 79af79fa1b47a..253c497b48ee2 100644 --- a/compiler/rustc_target/src/spec/base/windows_gnu.rs +++ b/compiler/rustc_target/src/spec/base/windows_gnu.rs @@ -5,7 +5,7 @@ use std::borrow::Cow; pub fn opts() -> TargetOptions { let pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args( + let mut pre_link_args = TargetOptions::link_args_base( LinkerFlavor::Gnu(Cc::No, Lld::No), &[ // Enable ASLR @@ -51,7 +51,7 @@ pub fn opts() -> TargetOptions { "-lkernel32", ]; let mut late_link_args = - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), mingw_libs); + TargetOptions::link_args_base(LinkerFlavor::Gnu(Cc::No, Lld::No), mingw_libs); add_link_args(&mut late_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), mingw_libs); late_link_args }); @@ -61,7 +61,7 @@ pub fn opts() -> TargetOptions { let late_link_args_dynamic = MaybeLazy::lazy(|| { let dynamic_unwind_libs = &["-lgcc_s"]; let mut late_link_args_dynamic = - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), dynamic_unwind_libs); + TargetOptions::link_args_base(LinkerFlavor::Gnu(Cc::No, Lld::No), dynamic_unwind_libs); add_link_args( &mut late_link_args_dynamic, LinkerFlavor::Gnu(Cc::Yes, Lld::No), @@ -77,7 +77,7 @@ pub fn opts() -> TargetOptions { let late_link_args_static = MaybeLazy::lazy(|| { let static_unwind_libs = &["-lgcc_eh", "-l:libpthread.a"]; let mut late_link_args_static = - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), static_unwind_libs); + TargetOptions::link_args_base(LinkerFlavor::Gnu(Cc::No, Lld::No), static_unwind_libs); add_link_args( &mut late_link_args_static, LinkerFlavor::Gnu(Cc::Yes, Lld::No), diff --git a/compiler/rustc_target/src/spec/base/windows_gnullvm.rs b/compiler/rustc_target/src/spec/base/windows_gnullvm.rs index 6755592358342..b1d8e2be5a61f 100644 --- a/compiler/rustc_target/src/spec/base/windows_gnullvm.rs +++ b/compiler/rustc_target/src/spec/base/windows_gnullvm.rs @@ -1,6 +1,4 @@ -use crate::spec::{ - cvs, Cc, DebuginfoKind, LinkerFlavor, Lld, MaybeLazy, SplitDebuginfo, TargetOptions, -}; +use crate::spec::{cvs, Cc, DebuginfoKind, LinkerFlavor, Lld, SplitDebuginfo, TargetOptions}; use std::borrow::Cow; pub fn opts() -> TargetOptions { @@ -8,19 +6,15 @@ pub fn opts() -> TargetOptions { // as a path since it's not added to linker search path by the default. // There were attempts to make it behave like libgcc (so one can just use -l) // but LLVM maintainers rejected it: https://reviews.llvm.org/D51440 - let pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-nolibc", "--unwindlib=none"], - ) - }); + let pre_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-nolibc", "--unwindlib=none"], + ); // Order of `late_link_args*` does not matter with LLD. - let late_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-lmingw32", "-lmingwex", "-lmsvcrt", "-lkernel32", "-luser32"], - ) - }); + let late_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-lmingw32", "-lmingwex", "-lmsvcrt", "-lkernel32", "-luser32"], + ); TargetOptions { os: "windows".into(), diff --git a/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs b/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs index 00d7d99650bbf..db036365ebd7c 100644 --- a/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs +++ b/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs @@ -17,7 +17,7 @@ pub fn opts() -> TargetOptions { "-lmingw32", ]; let mut late_link_args = - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), mingw_libs); + TargetOptions::link_args_base(LinkerFlavor::Gnu(Cc::No, Lld::No), mingw_libs); add_link_args(&mut late_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), mingw_libs); late_link_args }); diff --git a/compiler/rustc_target/src/spec/base/windows_uwp_msvc.rs b/compiler/rustc_target/src/spec/base/windows_uwp_msvc.rs index d99775b31b6aa..a4140f4ea4fe7 100644 --- a/compiler/rustc_target/src/spec/base/windows_uwp_msvc.rs +++ b/compiler/rustc_target/src/spec/base/windows_uwp_msvc.rs @@ -1,13 +1,12 @@ -use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy, TargetOptions}; +use crate::spec::{base, LinkerFlavor, Lld, TargetOptions}; pub fn opts() -> TargetOptions { let mut opts = base::windows_msvc::opts(); opts.abi = "uwp".into(); opts.vendor = "uwp".into(); - opts.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Msvc(Lld::No), &["/APPCONTAINER", "mincore.lib"]) - }); + opts.pre_link_args = + TargetOptions::link_args(LinkerFlavor::Msvc(Lld::No), &["/APPCONTAINER", "mincore.lib"]); opts } diff --git a/compiler/rustc_target/src/spec/link_args.rs b/compiler/rustc_target/src/spec/link_args.rs new file mode 100644 index 0000000000000..5e7704a7f83f2 --- /dev/null +++ b/compiler/rustc_target/src/spec/link_args.rs @@ -0,0 +1,26 @@ +//! Linker arguments + +use crate::spec::{LinkerFlavor, LinkerFlavorCli}; +use crate::spec::{MaybeLazy, TargetOptions}; +use crate::spec::StaticCow; + +use std::collections::BTreeMap; + +pub type LinkArgs = BTreeMap>>; +pub type LinkArgsCli = BTreeMap>>; + +pub type LazyLinkArgs = MaybeLazy; + +pub(super) enum LazyLinkArgsState { + Simple(LinkerFlavor, &'static [&'static str]) +} + +impl FnOnce<()> for LazyLinkArgsState { + type Output = LinkArgs; + extern "rust-call" fn call_once(self, _args: ()) -> Self::Output { + match self { + LazyLinkArgsState::Simple(flavor, args) => + TargetOptions::link_args_base(flavor, args), + } + } +} diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs index 3e05e72006e13..dc2e91765f846 100644 --- a/compiler/rustc_target/src/spec/mod.rs +++ b/compiler/rustc_target/src/spec/mod.rs @@ -39,6 +39,7 @@ use crate::abi::{Endian, Integer, Size, TargetDataLayout, TargetDataLayoutErrors use crate::json::{Json, ToJson}; use crate::spec::abi::Abi; use crate::spec::crt_objects::{CrtObjects, LazyCrtObjects}; +use crate::spec::link_args::{LazyLinkArgs, LinkArgs, LinkArgsCli}; use rustc_fs_util::try_canonicalize; use rustc_macros::{Decodable, Encodable, HashStable_Generic}; use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; @@ -55,6 +56,7 @@ use tracing::debug; pub mod abi; pub mod crt_objects; +pub mod link_args; pub mod maybe_lazy; mod base; @@ -1105,9 +1107,6 @@ impl fmt::Display for LinkOutputKind { } } -pub type LinkArgs = BTreeMap>>; -pub type LinkArgsCli = BTreeMap>>; - /// Which kind of debuginfo does the target use? /// /// Useful in determining whether a target supports Split DWARF (a target with @@ -2027,24 +2026,24 @@ pub struct TargetOptions { pub link_self_contained: LinkSelfContainedDefault, /// Linker arguments that are passed *before* any user-defined libraries. - pub pre_link_args: MaybeLazy, + pub pre_link_args: LazyLinkArgs, pre_link_args_json: LinkArgsCli, /// Linker arguments that are unconditionally passed after any /// user-defined but before post-link objects. Standard platform /// libraries that should be always be linked to, usually go here. - pub late_link_args: MaybeLazy, + pub late_link_args: LazyLinkArgs, late_link_args_json: LinkArgsCli, /// Linker arguments used in addition to `late_link_args` if at least one /// Rust dependency is dynamically linked. - pub late_link_args_dynamic: MaybeLazy, + pub late_link_args_dynamic: LazyLinkArgs, late_link_args_dynamic_json: LinkArgsCli, /// Linker arguments used in addition to `late_link_args` if all Rust /// dependencies are statically linked. - pub late_link_args_static: MaybeLazy, + pub late_link_args_static: LazyLinkArgs, late_link_args_static_json: LinkArgsCli, /// Linker arguments that are unconditionally passed *after* any /// user-defined libraries. - pub post_link_args: MaybeLazy, + pub post_link_args: LazyLinkArgs, post_link_args_json: LinkArgsCli, /// Optional link script applied to `dylib` and `executable` crate types. @@ -2391,7 +2390,11 @@ fn add_link_args(link_args: &mut LinkArgs, flavor: LinkerFlavor, args: &[&'stati } impl TargetOptions { - fn link_args(flavor: LinkerFlavor, args: &[&'static str]) -> LinkArgs { + fn link_args(flavor: LinkerFlavor, args: &'static [&'static str]) -> LazyLinkArgs { + MaybeLazy::lazied(link_args::LazyLinkArgsState::Simple(flavor, args)) + } + + fn link_args_base(flavor: LinkerFlavor, args: &[&'static str]) -> LinkArgs { let mut link_args = LinkArgs::new(); add_link_args(&mut link_args, flavor, args); link_args @@ -2506,15 +2509,15 @@ impl Default for TargetOptions { pre_link_objects_self_contained: Default::default(), post_link_objects_self_contained: Default::default(), link_self_contained: LinkSelfContainedDefault::False, - pre_link_args: MaybeLazy::lazy(LinkArgs::new), + pre_link_args: Default::default(), pre_link_args_json: LinkArgsCli::new(), - late_link_args: MaybeLazy::lazy(LinkArgs::new), + late_link_args: Default::default(), late_link_args_json: LinkArgsCli::new(), - late_link_args_dynamic: MaybeLazy::lazy(LinkArgs::new), + late_link_args_dynamic: Default::default(), late_link_args_dynamic_json: LinkArgsCli::new(), - late_link_args_static: MaybeLazy::lazy(LinkArgs::new), + late_link_args_static: Default::default(), late_link_args_static_json: LinkArgsCli::new(), - post_link_args: MaybeLazy::lazy(LinkArgs::new), + post_link_args: Default::default(), post_link_args_json: LinkArgsCli::new(), link_env: cvs![], link_env_remove: cvs![], diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_illumos.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_illumos.rs index 7218b62d02b74..14337f4d8e83c 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_illumos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_illumos.rs @@ -1,9 +1,8 @@ -use crate::spec::{base, Cc, LinkerFlavor, MaybeLazy, SanitizerSet, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::illumos::opts(); - base.pre_link_args = - MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Unix(Cc::Yes), &["-std=c99"])); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Unix(Cc::Yes), &["-std=c99"]); base.max_atomic_width = Some(128); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::CFI; base.features = "+v8a".into(); diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs index e7814d6b11f76..21706aa0b5d85 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs @@ -7,8 +7,8 @@ // For example, `-C target-cpu=cortex-a53`. use crate::spec::{ - Cc, LinkerFlavor, Lld, MaybeLazy, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, - Target, TargetOptions, + Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, Target, + TargetOptions, }; pub fn target() -> Target { @@ -16,12 +16,10 @@ pub fn target() -> Target { linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), linker: Some("rust-lld".into()), // Enable the Cortex-A53 errata 843419 mitigation by default - pre_link_args: MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &["--fix-cortex-a53-843419"], - ) - }), + pre_link_args: TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &["--fix-cortex-a53-843419"], + ), features: "+v8a,+strict-align,+neon,+fp-armv8".into(), supported_sanitizers: SanitizerSet::KCFI | SanitizerSet::KERNELADDRESS, relocation_model: RelocModel::Static, diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_nto_qnx710.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_nto_qnx710.rs index b3f4539b9195e..8e448a2fa9a7a 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_nto_qnx710.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_nto_qnx710.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { Target { @@ -24,12 +24,10 @@ pub fn target() -> Target { options: TargetOptions { features: "+v8a".into(), max_atomic_width: Some(128), - pre_link_args: MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-Vgcc_ntoaarch64le_cxx"], - ) - }), + pre_link_args: TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-Vgcc_ntoaarch64le_cxx"], + ), env: "nto71".into(), ..base::nto_qnx::opts() }, diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_uefi.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_uefi.rs index 989c27da93a06..2f35a3e6ec92c 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_uefi.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_uefi.rs @@ -1,15 +1,13 @@ // This defines the aarch64 target for UEFI systems as described in the UEFI specification. See the // uefi-base module for generic UEFI options. -use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::uefi_msvc::opts(); base.max_atomic_width = Some(128); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Msvc(Lld::No), &["/machine:arm64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Msvc(Lld::No), &["/machine:arm64"]); base.features = "+v8a".into(); Target { diff --git a/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs index 011f38209a6cc..cd329bd2c68d1 100644 --- a/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs @@ -1,15 +1,13 @@ -use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_msvc::opts(); base.max_atomic_width = Some(128); base.features = "+v8a,+neon,+fp-armv8".into(); - base.late_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Msvc(Lld::No), - &["/machine:arm64ec", "softintrin.lib"], - ) - }); + base.late_link_args = TargetOptions::link_args( + LinkerFlavor::Msvc(Lld::No), + &["/machine:arm64ec", "softintrin.lib"], + ); Target { llvm_target: "arm64ec-pc-windows-msvc".into(), diff --git a/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs b/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs index f8900f68595e4..9a88277b06364 100644 --- a/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs +++ b/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs @@ -1,16 +1,14 @@ -use crate::spec::{cvs, Cc, LinkerFlavor, Lld, MaybeLazy, RelocModel, Target, TargetOptions}; +use crate::spec::{cvs, Cc, LinkerFlavor, Lld, RelocModel, Target, TargetOptions}; /// A base target for Nintendo 3DS devices using the devkitARM toolchain. /// /// Requires the devkitARM toolchain for 3DS targets on the host system. pub fn target() -> Target { - let pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-specs=3dsx.specs", "-mtune=mpcore", "-mfloat-abi=hard", "-mtp=soft"], - ) - }); + let pre_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-specs=3dsx.specs", "-mtune=mpcore", "-mfloat-abi=hard", "-mtp=soft"], + ); Target { llvm_target: "armv6k-none-eabihf".into(), diff --git a/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs b/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs index b99fb02493d6f..6a1194c3ece7d 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, SanitizerSet, Target, TargetOptions}; // This target if is for the baseline of the Android v7a ABI // in thumb mode. It's named armv7-* instead of thumbv7-* @@ -10,9 +10,8 @@ use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, Target, pub fn target() -> Target { let mut base = base::android::opts(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-march=armv7-a"]) - }); + base.pre_link_args = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-march=armv7-a"]); Target { llvm_target: "armv7-none-linux-android".into(), metadata: crate::spec::TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs index 9aa7f6f7c2f18..0730a423f724a 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs @@ -1,17 +1,15 @@ use crate::abi::Endian; -use crate::spec::{cvs, Cc, LinkerFlavor, Lld, MaybeLazy, RelocModel, Target, TargetOptions}; +use crate::spec::{cvs, Cc, LinkerFlavor, Lld, RelocModel, Target, TargetOptions}; /// A base target for PlayStation Vita devices using the VITASDK toolchain (using newlib). /// /// Requires the VITASDK toolchain on the host system. pub fn target() -> Target { - let pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-Wl,-q", "-Wl,--pic-veneer"], - ) - }); + let pre_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-Wl,-q", "-Wl,--pic-veneer"], + ); Target { llvm_target: "thumbv7a-vita-eabihf".into(), diff --git a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs index 1baeebbe65b26..120c75f528ad9 100644 --- a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs +++ b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; // This target is for glibc Linux on Csky @@ -13,7 +13,7 @@ pub fn target() -> Target { options: TargetOptions { abi: "abiv2".into(), features: "+2e3,+3e7,+7e10,+cache,+dsp1e2,+dspe60,+e1,+e2,+edsp,+elrw,+hard-tp,+high-registers,+hwdiv,+mp,+mp1e2,+nvic,+trust".into(), - late_link_args: MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-l:libatomic.a"])), + late_link_args: TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-l:libatomic.a"]), max_atomic_width: Some(32), ..base::linux_gnu::opts() }, diff --git a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs index ab56c5080163b..2856e94ea4a98 100644 --- a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs +++ b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; // This target is for glibc Linux on Csky @@ -14,7 +14,7 @@ pub fn target() -> Target { abi: "abiv2hf".into(), cpu: "ck860fv".into(), features: "+hard-float,+hard-float-abi,+2e3,+3e7,+7e10,+cache,+dsp1e2,+dspe60,+e1,+e2,+edsp,+elrw,+hard-tp,+high-registers,+hwdiv,+mp,+mp1e2,+nvic,+trust".into(), - late_link_args: MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-l:libatomic.a", "-mhard-float"])), + late_link_args: TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-l:libatomic.a", "-mhard-float"]), max_atomic_width: Some(32), ..base::linux_gnu::opts() }, diff --git a/compiler/rustc_target/src/spec/targets/i586_pc_nto_qnx700.rs b/compiler/rustc_target/src/spec/targets/i586_pc_nto_qnx700.rs index 8b24977caf1c6..290ed81ad45d8 100644 --- a/compiler/rustc_target/src/spec/targets/i586_pc_nto_qnx700.rs +++ b/compiler/rustc_target/src/spec/targets/i586_pc_nto_qnx700.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { Target { @@ -17,9 +17,10 @@ pub fn target() -> Target { options: TargetOptions { cpu: "pentium4".into(), max_atomic_width: Some(64), - pre_link_args: MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-Vgcc_ntox86_cxx"]) - }), + pre_link_args: TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-Vgcc_ntox86_cxx"], + ), env: "nto70".into(), stack_probes: StackProbeType::Inline, ..base::nto_qnx::opts() diff --git a/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs index 2a371d324fc57..65bcf98cbbb2d 100644 --- a/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs @@ -9,9 +9,8 @@ pub fn target() -> Target { let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m32"]) - }); + base.pre_link_args = + TargetOptions::link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m32"]); base.frame_pointer = FramePointer::Always; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs index e481edeed2497..63e5f31d6ffa1 100644 --- a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs @@ -11,7 +11,7 @@ pub fn target() -> Target { // Mark all dynamic libraries and executables as compatible with the larger 4GiB address // space available to x86 Windows binaries on x86_64. base.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args( + let mut pre_link_args = TargetOptions::link_args_base( LinkerFlavor::Gnu(Cc::No, Lld::No), &["-m", "i386pe", "--large-address-aware"], ); diff --git a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnullvm.rs b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnullvm.rs index 849d540e678fa..ba9a20251577d 100644 --- a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnullvm.rs +++ b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnullvm.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, FramePointer, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, FramePointer, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_gnullvm::opts(); @@ -9,12 +9,10 @@ pub fn target() -> Target { // Mark all dynamic libraries and executables as compatible with the larger 4GiB address // space available to x86 Windows binaries on x86_64. - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &["-m", "i386pe", "--large-address-aware"], - ) - }); + base.pre_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &["-m", "i386pe", "--large-address-aware"], + ); Target { llvm_target: "i686-pc-windows-gnu".into(), diff --git a/compiler/rustc_target/src/spec/targets/i686_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/i686_pc_windows_msvc.rs index 3595244e060f4..b27c7dd09ab8b 100644 --- a/compiler/rustc_target/src/spec/targets/i686_pc_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/i686_pc_windows_msvc.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, Target, TargetOptions}; +use crate::spec::{base, LinkerFlavor, Lld, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_msvc::opts(); @@ -6,20 +6,18 @@ pub fn target() -> Target { base.max_atomic_width = Some(64); base.supported_sanitizers = SanitizerSet::ADDRESS; - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Msvc(Lld::No), - &[ - // Mark all dynamic libraries and executables as compatible with the larger 4GiB address - // space available to x86 Windows binaries on x86_64. - "/LARGEADDRESSAWARE", - // Ensure the linker will only produce an image if it can also produce a table of - // the image's safe exception handlers. - // https://docs.microsoft.com/en-us/cpp/build/reference/safeseh-image-has-safe-exception-handlers - "/SAFESEH", - ], - ) - }); + base.pre_link_args = TargetOptions::link_args( + LinkerFlavor::Msvc(Lld::No), + &[ + // Mark all dynamic libraries and executables as compatible with the larger 4GiB address + // space available to x86 Windows binaries on x86_64. + "/LARGEADDRESSAWARE", + // Ensure the linker will only produce an image if it can also produce a table of + // the image's safe exception handlers. + // https://docs.microsoft.com/en-us/cpp/build/reference/safeseh-image-has-safe-exception-handlers + "/SAFESEH", + ], + ); Target { llvm_target: "i686-pc-windows-msvc".into(), diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_freebsd.rs index e4663397d4e25..97454046b2f21 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_freebsd.rs @@ -1,12 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::freebsd::opts(); base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "-Wl,-znotext"]) - }); + base.pre_link_args = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "-Wl,-znotext"]); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_haiku.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_haiku.rs index 51f70d78cb4a9..35960eb7f082d 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_haiku.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_haiku.rs @@ -1,12 +1,10 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::haiku::opts(); base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_hurd_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_hurd_gnu.rs index ac7946673a02c..83136d600ba2b 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_hurd_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_hurd_gnu.rs @@ -1,12 +1,10 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::hurd_gnu::opts(); base.cpu = "pentiumpro".into(); base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_linux_gnu.rs index 670c5f160379e..a908994845729 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy}; +use crate::spec::{base, Cc, LinkerFlavor, Lld}; use crate::spec::{SanitizerSet, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { @@ -6,9 +6,7 @@ pub fn target() -> Target { base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); base.supported_sanitizers = SanitizerSet::ADDRESS; - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_linux_musl.rs index d9e0c4ec70f8a..f39eba801cca5 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_linux_musl.rs @@ -1,14 +1,13 @@ use crate::spec::{ - base, Cc, FramePointer, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions, + base, Cc, FramePointer, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions, }; pub fn target() -> Target { let mut base = base::linux_musl::opts(); base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "-Wl,-melf_i386"]) - }); + base.pre_link_args = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "-Wl,-melf_i386"]); base.stack_probes = StackProbeType::Inline; // The unwinder used by i686-unknown-linux-musl, the LLVM libunwind diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_netbsd.rs index cbc8c77f43c7b..ac7ea5ff15d62 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_netbsd.rs @@ -1,12 +1,10 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::netbsd::opts(); base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_openbsd.rs index e0cfbaef3c43a..02b87aa919ccc 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_openbsd.rs @@ -1,12 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::openbsd::opts(); base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "-fuse-ld=lld"]) - }); + base.pre_link_args = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "-fuse-ld=lld"]); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_redox.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_redox.rs index 83252fadb78ea..0f6307ea35d61 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_redox.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_redox.rs @@ -1,11 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::redox::opts(); base.cpu = "pentiumpro".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved base.stack_probes = StackProbeType::Call; diff --git a/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs index e1de02770e515..8b3a155bbf480 100644 --- a/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs @@ -10,7 +10,7 @@ pub fn target() -> Target { // Mark all dynamic libraries and executables as compatible with the larger 4GiB address // space available to x86 Windows binaries on x86_64. base.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args( + let mut pre_link_args = TargetOptions::link_args_base( LinkerFlavor::Gnu(Cc::No, Lld::No), &["-m", "i386pe", "--large-address-aware"], ); diff --git a/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs index 4d63564c19368..d97900b4ab929 100644 --- a/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_msvc::opts(); @@ -6,20 +6,18 @@ pub fn target() -> Target { base.max_atomic_width = Some(64); base.vendor = "win7".into(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Msvc(Lld::No), - &[ - // Mark all dynamic libraries and executables as compatible with the larger 4GiB address - // space available to x86 Windows binaries on x86_64. - "/LARGEADDRESSAWARE", - // Ensure the linker will only produce an image if it can also produce a table of - // the image's safe exception handlers. - // https://docs.microsoft.com/en-us/cpp/build/reference/safeseh-image-has-safe-exception-handlers - "/SAFESEH", - ], - ) - }); + base.pre_link_args = TargetOptions::link_args( + LinkerFlavor::Msvc(Lld::No), + &[ + // Mark all dynamic libraries and executables as compatible with the larger 4GiB address + // space available to x86 Windows binaries on x86_64. + "/LARGEADDRESSAWARE", + // Ensure the linker will only produce an image if it can also produce a table of + // the image's safe exception handlers. + // https://docs.microsoft.com/en-us/cpp/build/reference/safeseh-image-has-safe-exception-handlers + "/SAFESEH", + ], + ); Target { llvm_target: "i686-pc-windows-msvc".into(), diff --git a/compiler/rustc_target/src/spec/targets/i686_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/i686_wrs_vxworks.rs index c16652063dcd0..9e23ce188ad4c 100644 --- a/compiler/rustc_target/src/spec/targets/i686_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/i686_wrs_vxworks.rs @@ -1,12 +1,10 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::vxworks::opts(); base.cpu = "pentium4".into(); base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs b/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs index 6dff93778fef3..fafe14935383d 100644 --- a/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs +++ b/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs @@ -1,12 +1,13 @@ -use crate::spec::{cvs, Cc, LinkerFlavor, Lld, MaybeLazy, RelocModel, Target, TargetOptions}; +use crate::spec::{cvs, Cc, LinkerFlavor, Lld, RelocModel, Target, TargetOptions}; // The PSP has custom linker requirements. const LINKER_SCRIPT: &str = include_str!("./mipsel_sony_psp_linker_script.ld"); pub fn target() -> Target { - let pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::No, Lld::No), &["--emit-relocs", "--nmagic"]) - }); + let pre_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &["--emit-relocs", "--nmagic"], + ); Target { llvm_target: "mipsel-sony-psp".into(), diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs b/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs index f2c0a8f49db26..1cab3395a8f0a 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs @@ -1,14 +1,12 @@ -use crate::spec::{base, Cc, LinkerFlavor, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::aix::opts(); base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Unix(Cc::No), - &["-b64", "-bpT:0x100000000", "-bpD:0x110000000", "-bcdtors:all:0:s"], - ) - }); + base.pre_link_args = TargetOptions::link_args( + LinkerFlavor::Unix(Cc::No), + &["-b64", "-bpT:0x100000000", "-bpD:0x110000000", "-bcdtors:all:0:s"], + ); Target { llvm_target: "powerpc64-ibm-aix".into(), diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs index ff87cc719e53a..12c2c9e247dfd 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs @@ -1,12 +1,10 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::freebsd::opts(); base.cpu = "ppc64".into(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs index 683e7bfb50e49..b44ba19b2b2df 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs @@ -1,12 +1,10 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); base.cpu = "ppc64".into(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs index 2488909638fb3..b250315213fb4 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs @@ -1,12 +1,10 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_musl::opts(); base.cpu = "ppc64".into(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs index 1cd215d5509e5..ccd829f53ec43 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs @@ -1,12 +1,10 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::openbsd::opts(); base.cpu = "ppc64".into(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs index 61749d9ff457b..2dfe1b90d04ad 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs @@ -1,12 +1,10 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::vxworks::opts(); base.cpu = "ppc64".into(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs index 7df62b27e9e01..7deb248aa9fc7 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs @@ -1,11 +1,9 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::freebsd::opts(); base.cpu = "ppc64le".into(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs index 98776dab96878..2515f011f24f8 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs @@ -1,11 +1,9 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); base.cpu = "ppc64le".into(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs index 70dd0e2006a03..7d25e1359afba 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs @@ -1,11 +1,9 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_musl::opts(); base.cpu = "ppc64le".into(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.max_atomic_width = Some(64); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_freebsd.rs index 7737400e58965..7b2acb20ec51d 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_freebsd.rs @@ -1,15 +1,13 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::freebsd::opts(); // Extra hint to linker that we are generating secure-PLT code. - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-m32", "--target=powerpc-unknown-freebsd13.0"], - ) - }); + base.pre_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-m32", "--target=powerpc-unknown-freebsd13.0"], + ); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnu.rs index 834861efbe68c..fd2a367a85844 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnu.rs @@ -1,11 +1,9 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs index b54ebe4c4edef..fe8c7aad73079 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs @@ -1,11 +1,9 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mspe"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mspe"]); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_musl.rs index deee308613a5e..5fa90e242ad48 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_musl.rs @@ -1,11 +1,9 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_musl::opts(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_netbsd.rs index caca549426f89..a13a1fbd8c0bb 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_netbsd.rs @@ -1,11 +1,9 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::netbsd::opts(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32"]); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks.rs index e8e1c942dd4e4..a89ea8f5fda4c 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks.rs @@ -1,11 +1,10 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::vxworks::opts(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "--secure-plt"]) - }); + base.pre_link_args = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m32", "--secure-plt"]); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs index be55defce7678..2affe53a05c33 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs @@ -1,11 +1,10 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::vxworks::opts(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mspe", "--secure-plt"]) - }); + base.pre_link_args = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mspe", "--secure-plt"]); base.max_atomic_width = Some(32); base.stack_probes = StackProbeType::Inline; diff --git a/compiler/rustc_target/src/spec/targets/sparc64_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/sparc64_unknown_netbsd.rs index 4e584f9a26866..3e4bbf538af5e 100644 --- a/compiler/rustc_target/src/spec/targets/sparc64_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/sparc64_unknown_netbsd.rs @@ -1,12 +1,10 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::netbsd::opts(); base.cpu = "v9".into(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.max_atomic_width = Some(64); Target { diff --git a/compiler/rustc_target/src/spec/targets/sparc64_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/sparc64_unknown_openbsd.rs index 11e72321afafa..d9c3e63da1a65 100644 --- a/compiler/rustc_target/src/spec/targets/sparc64_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/sparc64_unknown_openbsd.rs @@ -1,13 +1,11 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::openbsd::opts(); base.endian = Endian::Big; base.cpu = "v9".into(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.max_atomic_width = Some(64); Target { diff --git a/compiler/rustc_target/src/spec/targets/sparc_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/sparc_unknown_linux_gnu.rs index 5df71355b526b..eff9d4deea9b8 100644 --- a/compiler/rustc_target/src/spec/targets/sparc_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/sparc_unknown_linux_gnu.rs @@ -1,14 +1,13 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); base.endian = Endian::Big; base.cpu = "v9".into(); base.max_atomic_width = Some(32); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mv8plus"]) - }); + base.pre_link_args = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mv8plus"]); Target { llvm_target: "sparc-unknown-linux-gnu".into(), diff --git a/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs b/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs index 4e8e02108185d..99a163af92709 100644 --- a/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs +++ b/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs @@ -1,11 +1,10 @@ use crate::abi::Endian; -use crate::spec::{base, Cc, LinkerFlavor, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::solaris::opts(); base.endian = Endian::Big; - base.pre_link_args = - MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Unix(Cc::Yes), &["-m64"])); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Unix(Cc::Yes), &["-m64"]); // llvm calls this "v9" base.cpu = "v9".into(); base.vendor = "sun".into(); diff --git a/compiler/rustc_target/src/spec/targets/thumbv7a_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/thumbv7a_pc_windows_msvc.rs index 008af9a5cd206..836740144e67e 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7a_pc_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7a_pc_windows_msvc.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, LinkerFlavor, Lld, MaybeLazy, PanicStrategy, Target, TargetOptions}; +use crate::spec::{base, LinkerFlavor, Lld, PanicStrategy, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_msvc::opts(); @@ -9,8 +9,7 @@ pub fn target() -> Target { // should be smart enough to insert branch islands only // where necessary, but this is not the observed behavior. // Disabling the LBR optimization works around the issue. - base.pre_link_args = - MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Msvc(Lld::No), &["/OPT:NOLBR"])); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Msvc(Lld::No), &["/OPT:NOLBR"]); Target { llvm_target: "thumbv7a-pc-windows-msvc".into(), diff --git a/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs index feda3a4516181..8f07873826ba6 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; // This target if is for the Android v7a ABI in thumb mode with // NEON unconditionally enabled and, therefore, with 32 FPU registers @@ -10,9 +10,8 @@ use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions} pub fn target() -> Target { let mut base = base::android::opts(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-march=armv7-a"]) - }); + base.pre_link_args = + TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-march=armv7-a"]); Target { llvm_target: "armv7-none-linux-android".into(), metadata: crate::spec::TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs b/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs index 0ff38c420bcb7..4d0a5b9aef321 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs @@ -4,9 +4,8 @@ use crate::spec::{ pub fn target() -> Target { // Reset flags for non-Em flavors back to empty to satisfy sanity checking tests. - let pre_link_args = MaybeLazy::lazy(|| LinkArgs::new()); - let post_link_args = - MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::EmCc, &["-sABORTING_MALLOC=0"])); + let pre_link_args = MaybeLazy::lazy(LinkArgs::new); + let post_link_args = TargetOptions::link_args(LinkerFlavor::EmCc, &["-sABORTING_MALLOC=0"]); let opts = TargetOptions { os: "emscripten".into(), diff --git a/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs b/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs index f7a50f9fa93a7..d9ae5e24ab26d 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs @@ -18,7 +18,7 @@ pub fn target() -> Target { options.os = "unknown".into(); options.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args( + let mut pre_link_args = TargetOptions::link_args_base( LinkerFlavor::WasmLld(Cc::No), &[ // For now this target just never has an entry symbol no matter the output diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs index 53c1fe7b1ef10..2fe82cb571540 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs @@ -12,7 +12,6 @@ use crate::spec::crt_objects; use crate::spec::LinkSelfContainedDefault; -use crate::spec::MaybeLazy; use crate::spec::TargetOptions; use crate::spec::{base, Cc, LinkerFlavor, Target}; @@ -21,9 +20,8 @@ pub fn target() -> Target { options.os = "wasi".into(); options.env = "p1".into(); - options.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::WasmLld(Cc::Yes), &["--target=wasm32-wasi"]) - }); + options.pre_link_args = + TargetOptions::link_args(LinkerFlavor::WasmLld(Cc::Yes), &["--target=wasm32-wasi"]); options.pre_link_objects_self_contained = crt_objects::pre_wasi_self_contained(); options.post_link_objects_self_contained = crt_objects::post_wasi_self_contained(); diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs index ebb74ab508562..f4d9badd3a184 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs @@ -19,7 +19,7 @@ pub fn target() -> Target { options.env = "p1".into(); options.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args( + let mut pre_link_args = TargetOptions::link_args_base( LinkerFlavor::WasmLld(Cc::No), &["--import-memory", "--export-memory", "--shared-memory"], ); diff --git a/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs b/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs index 6289c0a0c4a9d..e24180ba41411 100644 --- a/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs +++ b/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs @@ -14,7 +14,7 @@ pub fn target() -> Target { options.os = "unknown".into(); options.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args( + let mut pre_link_args = TargetOptions::link_args_base( LinkerFlavor::WasmLld(Cc::No), &[ // For now this target just never has an entry symbol no matter the output diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs index 7d5a5810213f1..bc843c1211d77 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs @@ -10,9 +10,8 @@ pub fn target() -> Target { let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.max_atomic_width = Some(128); // penryn+ supports cmpxchg16b base.frame_pointer = FramePointer::Always; - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = + TargetOptions::link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m64"]); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::CFI | SanitizerSet::LEAK | SanitizerSet::THREAD; diff --git a/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs b/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs index 67e52d4b966a9..012450e307e7c 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs @@ -1,44 +1,42 @@ use std::borrow::Cow; -use crate::spec::{cvs, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{cvs, Cc, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { - let pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &[ - "-e", - "elf_entry", - "-Bstatic", - "--gc-sections", - "-z", - "text", - "-z", - "norelro", - "--no-undefined", - "--error-unresolved-symbols", - "--no-undefined-version", - "-Bsymbolic", - "--export-dynamic", - // The following symbols are needed by libunwind, which is linked after - // libstd. Make sure they're included in the link. - "-u", - "__rust_abort", - "-u", - "__rust_c_alloc", - "-u", - "__rust_c_dealloc", - "-u", - "__rust_print_err", - "-u", - "__rust_rwlock_rdlock", - "-u", - "__rust_rwlock_unlock", - "-u", - "__rust_rwlock_wrlock", - ], - ) - }); + let pre_link_args = TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::No, Lld::No), + &[ + "-e", + "elf_entry", + "-Bstatic", + "--gc-sections", + "-z", + "text", + "-z", + "norelro", + "--no-undefined", + "--error-unresolved-symbols", + "--no-undefined-version", + "-Bsymbolic", + "--export-dynamic", + // The following symbols are needed by libunwind, which is linked after + // libstd. Make sure they're included in the link. + "-u", + "__rust_abort", + "-u", + "__rust_c_alloc", + "-u", + "__rust_c_dealloc", + "-u", + "__rust_print_err", + "-u", + "__rust_rwlock_rdlock", + "-u", + "__rust_rwlock_unlock", + "-u", + "__rust_rwlock_wrlock", + ], + ); const EXPORT_SYMBOLS: &[&str] = &[ "sgx_entry", diff --git a/compiler/rustc_target/src/spec/targets/x86_64_linux_android.rs b/compiler/rustc_target/src/spec/targets/x86_64_linux_android.rs index e60595912bbfd..7fa499c29657b 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_linux_android.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_linux_android.rs @@ -1,5 +1,5 @@ use crate::spec::{ - base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, + base, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetOptions, }; pub fn target() -> Target { @@ -9,9 +9,7 @@ pub fn target() -> Target { // https://developer.android.com/ndk/guides/abis.html#86-64 base.features = "+mmx,+sse,+sse2,+sse3,+ssse3,+sse4.1,+sse4.2,+popcnt".into(); base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.stack_probes = StackProbeType::Inline; base.supports_xray = true; diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_nto_qnx710.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_nto_qnx710.rs index dceb97b2a7e5c..c7169c3d62d54 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_nto_qnx710.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_nto_qnx710.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { Target { @@ -17,12 +17,10 @@ pub fn target() -> Target { cpu: "x86-64".into(), plt_by_default: false, max_atomic_width: Some(64), - pre_link_args: MaybeLazy::lazy(|| { - TargetOptions::link_args( - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-Vgcc_ntox86_64_cxx"], - ) - }), + pre_link_args: TargetOptions::link_args( + LinkerFlavor::Gnu(Cc::Yes, Lld::No), + &["-Vgcc_ntox86_64_cxx"], + ), env: "nto71".into(), ..base::nto_qnx::opts() }, diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs index 08b345063ae64..df7b124f81008 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs @@ -1,11 +1,8 @@ -use crate::spec::{ - base, Cc, LinkerFlavor, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, -}; +use crate::spec::{base, Cc, LinkerFlavor, SanitizerSet, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::solaris::opts(); - base.pre_link_args = - MaybeLazy::lazy(|| TargetOptions::link_args(LinkerFlavor::Unix(Cc::Yes), &["-m64"])); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Unix(Cc::Yes), &["-m64"]); base.cpu = "x86-64".into(); base.plt_by_default = false; base.vendor = "pc".into(); diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs index 1b91ef6b4e718..61935bd4dd3c3 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs @@ -7,7 +7,7 @@ pub fn target() -> Target { base.plt_by_default = false; // Use high-entropy 64 bit address space for ASLR base.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args( + let mut pre_link_args = TargetOptions::link_args_base( LinkerFlavor::Gnu(Cc::No, Lld::No), &["-m", "i386pep", "--high-entropy-va"], ); diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs index a77d73be336b4..a19e53ce93dc1 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs @@ -1,13 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_gnullvm::opts(); base.cpu = "x86-64".into(); base.features = "+cx16,+sse3,+sahf".into(); base.plt_by_default = false; - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.max_atomic_width = Some(128); base.linker = Some("x86_64-w64-mingw32-clang".into()); diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unikraft_linux_musl.rs b/compiler/rustc_target/src/spec/targets/x86_64_unikraft_linux_musl.rs index dde680a919c85..8752ba81066e1 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unikraft_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unikraft_linux_musl.rs @@ -1,4 +1,4 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { Target { @@ -16,9 +16,7 @@ pub fn target() -> Target { options: TargetOptions { cpu: "x86-64".into(), plt_by_default: false, - pre_link_args: MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }), + pre_link_args: TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]), max_atomic_width: Some(64), stack_probes: StackProbeType::Inline, ..base::unikraft_linux_musl::opts() diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_dragonfly.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_dragonfly.rs index 09eb1594da0dc..38d0eb6bbb5f4 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_dragonfly.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_dragonfly.rs @@ -1,13 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::dragonfly::opts(); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_freebsd.rs index 340998e3c33a5..2cbf9d91f2717 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_freebsd.rs @@ -1,5 +1,5 @@ use crate::spec::{ - base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, + base, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetOptions, }; pub fn target() -> Target { @@ -7,9 +7,7 @@ pub fn target() -> Target { base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.stack_probes = StackProbeType::Inline; base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::CFI | SanitizerSet::MEMORY | SanitizerSet::THREAD; diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_haiku.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_haiku.rs index 2beec9cf577d8..6956fc788e12d 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_haiku.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_haiku.rs @@ -1,13 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::haiku::opts(); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.stack_probes = StackProbeType::Inline; // This option is required to build executables on Haiku x86_64 base.position_independent_executables = true; diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_illumos.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_illumos.rs index cb7033fc303e0..d861b6e81d392 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_illumos.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_illumos.rs @@ -1,10 +1,9 @@ -use crate::spec::{base, Cc, LinkerFlavor, MaybeLazy, SanitizerSet, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::illumos::opts(); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Unix(Cc::Yes), &["-m64", "-std=c99"]) - }); + base.pre_link_args = + TargetOptions::link_args(LinkerFlavor::Unix(Cc::Yes), &["-m64", "-std=c99"]); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs index c24ae4b1b5b57..55eb001b4995f 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs @@ -1,5 +1,5 @@ use crate::spec::{ - base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, + base, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetOptions, }; pub fn target() -> Target { @@ -7,9 +7,7 @@ pub fn target() -> Target { base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.stack_probes = StackProbeType::Inline; base.static_position_independent_executables = true; base.supported_sanitizers = SanitizerSet::ADDRESS diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs index fdfa78a4b65cf..2853b78fe6615 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs @@ -1,13 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::linux_gnu::opts(); base.cpu = "x86-64".into(); base.abi = "x32".into(); base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mx32"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mx32"]); base.stack_probes = StackProbeType::Inline; base.has_thread_local = false; // BUG(GabrielMajeri): disabling the PLT on x86_64 Linux with x32 ABI diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs index aba2684ff9a3d..669de753c01e6 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs @@ -1,5 +1,5 @@ use crate::spec::{ - base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, + base, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetOptions, }; pub fn target() -> Target { @@ -7,9 +7,7 @@ pub fn target() -> Target { base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.stack_probes = StackProbeType::Inline; base.static_position_independent_executables = true; base.supported_sanitizers = SanitizerSet::ADDRESS diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_ohos.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_ohos.rs index 0bad1fec70945..dbe6433d543bb 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_ohos.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_ohos.rs @@ -1,14 +1,12 @@ use crate::spec::{ - base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, + base, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetOptions, }; pub fn target() -> Target { let mut base = base::linux_ohos::opts(); base.cpu = "x86-64".into(); base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.stack_probes = StackProbeType::Inline; base.static_position_independent_executables = true; base.supported_sanitizers = SanitizerSet::ADDRESS diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_netbsd.rs index 0dd66812b3af4..222f90bc147e6 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_netbsd.rs @@ -1,5 +1,5 @@ use crate::spec::{ - base, Cc, LinkerFlavor, Lld, MaybeLazy, SanitizerSet, StackProbeType, Target, TargetOptions, + base, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetOptions, }; pub fn target() -> Target { @@ -7,9 +7,7 @@ pub fn target() -> Target { base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.stack_probes = StackProbeType::Inline; base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::CFI diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_openbsd.rs index 058808c6f8b1d..cd076fc15d931 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_openbsd.rs @@ -1,13 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::openbsd::opts(); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.stack_probes = StackProbeType::Inline; base.supports_xray = true; diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_redox.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_redox.rs index f1f57cf7dd9ca..7b85a05f53ecd 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_redox.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_redox.rs @@ -1,13 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::redox::opts(); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.stack_probes = StackProbeType::Inline; Target { diff --git a/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs index fe40b313ea95c..2002b22cab943 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs @@ -7,7 +7,7 @@ pub fn target() -> Target { base.plt_by_default = false; // Use high-entropy 64 bit address space for ASLR base.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args( + let mut pre_link_args = TargetOptions::link_args_base( LinkerFlavor::Gnu(Cc::No, Lld::No), &["-m", "i386pep", "--high-entropy-va"], ); diff --git a/compiler/rustc_target/src/spec/targets/x86_64_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/x86_64_wrs_vxworks.rs index 04dc9e4ea7070..adb23c8c3ab91 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_wrs_vxworks.rs @@ -1,13 +1,11 @@ -use crate::spec::{base, Cc, LinkerFlavor, Lld, MaybeLazy, StackProbeType, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::vxworks::opts(); base.cpu = "x86-64".into(); base.plt_by_default = false; base.max_atomic_width = Some(64); - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); base.stack_probes = StackProbeType::Inline; base.disable_redzone = true; diff --git a/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs index c1633d792b646..dc7e46465bc2f 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs @@ -10,9 +10,8 @@ pub fn target() -> Target { let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); base.max_atomic_width = Some(128); base.frame_pointer = FramePointer::Always; - base.pre_link_args = MaybeLazy::lazy(|| { - TargetOptions::link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m64"]) - }); + base.pre_link_args = + TargetOptions::link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m64"]); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::CFI | SanitizerSet::LEAK | SanitizerSet::THREAD; From 463c8c81016ab54c148f534cf69ddcbc4f424130 Mon Sep 17 00:00:00 2001 From: Urgau Date: Sun, 16 Jun 2024 12:53:12 +0200 Subject: [PATCH 10/13] Make `TargetOptions::link_args` stateful lazy - part 2 by adding `TargetOptions::link_args_list` to handle multi link args --- .../rustc_target/src/spec/base/fuchsia.rs | 2 +- compiler/rustc_target/src/spec/base/teeos.rs | 21 +++--- compiler/rustc_target/src/spec/base/wasm.rs | 16 ++--- .../rustc_target/src/spec/base/windows_gnu.rs | 68 ++++++++----------- .../src/spec/base/windows_uwp_gnu.rs | 20 +++--- compiler/rustc_target/src/spec/link_args.rs | 21 ++++-- compiler/rustc_target/src/spec/mod.rs | 6 +- .../src/spec/targets/i686_pc_windows_gnu.rs | 20 ++---- .../src/spec/targets/i686_uwp_windows_gnu.rs | 20 ++---- .../spec/targets/wasm32_unknown_emscripten.rs | 7 +- .../spec/targets/wasm32_unknown_unknown.rs | 18 ++--- .../src/spec/targets/wasm32_wasip1_threads.rs | 18 ++--- .../spec/targets/wasm64_unknown_unknown.rs | 16 ++--- .../src/spec/targets/x86_64_pc_windows_gnu.rs | 18 ++--- .../spec/targets/x86_64_uwp_windows_gnu.rs | 18 ++--- 15 files changed, 119 insertions(+), 170 deletions(-) diff --git a/compiler/rustc_target/src/spec/base/fuchsia.rs b/compiler/rustc_target/src/spec/base/fuchsia.rs index cfcedbef7aff7..d1ac22f3a098c 100644 --- a/compiler/rustc_target/src/spec/base/fuchsia.rs +++ b/compiler/rustc_target/src/spec/base/fuchsia.rs @@ -1,5 +1,5 @@ use crate::spec::{ - crt_objects, cvs, Cc, FramePointer, LinkOutputKind, LinkerFlavor, Lld, MaybeLazy, TargetOptions, + crt_objects, cvs, Cc, FramePointer, LinkOutputKind, LinkerFlavor, Lld, TargetOptions, }; pub fn opts() -> TargetOptions { diff --git a/compiler/rustc_target/src/spec/base/teeos.rs b/compiler/rustc_target/src/spec/base/teeos.rs index 53bc5c580b4f9..d50cf9c0db419 100644 --- a/compiler/rustc_target/src/spec/base/teeos.rs +++ b/compiler/rustc_target/src/spec/base/teeos.rs @@ -1,16 +1,15 @@ -use crate::spec::{ - add_link_args, Cc, LinkerFlavor, Lld, MaybeLazy, PanicStrategy, RelroLevel, TargetOptions, -}; +use crate::spec::{Cc, LinkerFlavor, Lld, PanicStrategy, RelroLevel, TargetOptions}; pub fn opts() -> TargetOptions { - let pre_link_args = MaybeLazy::lazy(|| { - let lld_args = &["-zmax-page-size=4096", "-znow", "-ztext", "--execute-only"]; - let cc_args = &["-Wl,-zmax-page-size=4096", "-Wl,-znow", "-Wl,-ztext", "-mexecute-only"]; - let mut pre_link_args = - TargetOptions::link_args_base(LinkerFlavor::Gnu(Cc::No, Lld::No), lld_args); - add_link_args(&mut pre_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), cc_args); - pre_link_args - }); + let pre_link_args = { + const LLD_ARGS: &[&str] = &["-zmax-page-size=4096", "-znow", "-ztext", "--execute-only"]; + const CC_ARGS: &[&str] = + &["-Wl,-zmax-page-size=4096", "-Wl,-znow", "-Wl,-ztext", "-mexecute-only"]; + TargetOptions::link_args_list(&[ + (LinkerFlavor::Gnu(Cc::No, Lld::No), LLD_ARGS), + (LinkerFlavor::Gnu(Cc::Yes, Lld::No), CC_ARGS), + ]) + }; TargetOptions { os: "teeos".into(), diff --git a/compiler/rustc_target/src/spec/base/wasm.rs b/compiler/rustc_target/src/spec/base/wasm.rs index e73ca46248a30..26d795834fb0b 100644 --- a/compiler/rustc_target/src/spec/base/wasm.rs +++ b/compiler/rustc_target/src/spec/base/wasm.rs @@ -1,7 +1,5 @@ -use crate::spec::{ - add_link_args, cvs, Cc, LinkSelfContainedDefault, LinkerFlavor, MaybeLazy, PanicStrategy, - RelocModel, TargetOptions, TlsModel, -}; +use crate::spec::{cvs, Cc, LinkSelfContainedDefault, LinkerFlavor, PanicStrategy}; +use crate::spec::{RelocModel, TargetOptions, TlsModel}; pub fn options() -> TargetOptions { macro_rules! args { @@ -48,12 +46,10 @@ pub fn options() -> TargetOptions { }; } - let pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = - TargetOptions::link_args_base(LinkerFlavor::WasmLld(Cc::No), args!("")); - add_link_args(&mut pre_link_args, LinkerFlavor::WasmLld(Cc::Yes), args!("-Wl,")); - pre_link_args - }); + let pre_link_args = TargetOptions::link_args_list(&[ + (LinkerFlavor::WasmLld(Cc::No), args!("")), + (LinkerFlavor::WasmLld(Cc::Yes), args!("-Wl,")), + ]); TargetOptions { is_like_wasm: true, diff --git a/compiler/rustc_target/src/spec/base/windows_gnu.rs b/compiler/rustc_target/src/spec/base/windows_gnu.rs index 253c497b48ee2..4d8e2c361db59 100644 --- a/compiler/rustc_target/src/spec/base/windows_gnu.rs +++ b/compiler/rustc_target/src/spec/base/windows_gnu.rs @@ -1,11 +1,11 @@ -use crate::spec::{add_link_args, crt_objects}; +use crate::spec::crt_objects; +use crate::spec::LinkSelfContainedDefault; use crate::spec::{cvs, Cc, DebuginfoKind, LinkerFlavor, Lld, SplitDebuginfo, TargetOptions}; -use crate::spec::{LinkSelfContainedDefault, MaybeLazy}; use std::borrow::Cow; pub fn opts() -> TargetOptions { - let pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args_base( + let pre_link_args = TargetOptions::link_args_list(&[ + ( LinkerFlavor::Gnu(Cc::No, Lld::No), &[ // Enable ASLR @@ -13,9 +13,8 @@ pub fn opts() -> TargetOptions { // ASLR will rebase it anyway so leaving that option enabled only leads to confusion "--disable-auto-image-base", ], - ); - add_link_args( - &mut pre_link_args, + ), + ( LinkerFlavor::Gnu(Cc::Yes, Lld::No), &[ // Tell GCC to avoid linker plugins, because we are not bundling @@ -24,14 +23,13 @@ pub fn opts() -> TargetOptions { "-Wl,--dynamicbase", "-Wl,--disable-auto-image-base", ], - ); - pre_link_args - }); + ), + ]); - let late_link_args = MaybeLazy::lazy(|| { + let late_link_args = { // Order of `late_link_args*` was found through trial and error to work with various // mingw-w64 versions (not tested on the CI). It's expected to change from time to time. - let mingw_libs = &[ + const MINGW_LIBS: &[&str] = &[ "-lmsvcrt", "-lmingwex", "-lmingw32", @@ -50,41 +48,33 @@ pub fn opts() -> TargetOptions { "-luser32", "-lkernel32", ]; - let mut late_link_args = - TargetOptions::link_args_base(LinkerFlavor::Gnu(Cc::No, Lld::No), mingw_libs); - add_link_args(&mut late_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), mingw_libs); - late_link_args - }); + TargetOptions::link_args_list(&[ + (LinkerFlavor::Gnu(Cc::No, Lld::No), MINGW_LIBS), + (LinkerFlavor::Gnu(Cc::Yes, Lld::No), MINGW_LIBS), + ]) + }; // If any of our crates are dynamically linked then we need to use // the shared libgcc_s-dw2-1.dll. This is required to support // unwinding across DLL boundaries. - let late_link_args_dynamic = MaybeLazy::lazy(|| { - let dynamic_unwind_libs = &["-lgcc_s"]; - let mut late_link_args_dynamic = - TargetOptions::link_args_base(LinkerFlavor::Gnu(Cc::No, Lld::No), dynamic_unwind_libs); - add_link_args( - &mut late_link_args_dynamic, - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - dynamic_unwind_libs, - ); - late_link_args_dynamic - }); + let late_link_args_dynamic = { + const DYNAMIC_UNWIND_LIBS: &[&str] = &["-lgcc_s"]; + TargetOptions::link_args_list(&[ + (LinkerFlavor::Gnu(Cc::No, Lld::No), DYNAMIC_UNWIND_LIBS), + (LinkerFlavor::Gnu(Cc::Yes, Lld::No), DYNAMIC_UNWIND_LIBS), + ]) + }; // If all of our crates are statically linked then we can get away // with statically linking the libgcc unwinding code. This allows // binaries to be redistributed without the libgcc_s-dw2-1.dll // dependency, but unfortunately break unwinding across DLL // boundaries when unwinding across FFI boundaries. - let late_link_args_static = MaybeLazy::lazy(|| { - let static_unwind_libs = &["-lgcc_eh", "-l:libpthread.a"]; - let mut late_link_args_static = - TargetOptions::link_args_base(LinkerFlavor::Gnu(Cc::No, Lld::No), static_unwind_libs); - add_link_args( - &mut late_link_args_static, - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - static_unwind_libs, - ); - late_link_args_static - }); + let late_link_args_static = { + const STATIC_UNWIND_LIBS: &[&str] = &["-lgcc_eh", "-l:libpthread.a"]; + TargetOptions::link_args_list(&[ + (LinkerFlavor::Gnu(Cc::No, Lld::No), STATIC_UNWIND_LIBS), + (LinkerFlavor::Gnu(Cc::Yes, Lld::No), STATIC_UNWIND_LIBS), + ]) + }; TargetOptions { os: "windows".into(), diff --git a/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs b/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs index db036365ebd7c..a6bd247cf606f 100644 --- a/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs +++ b/compiler/rustc_target/src/spec/base/windows_uwp_gnu.rs @@ -1,12 +1,12 @@ -use crate::spec::{add_link_args, base, Cc, LinkArgs, LinkerFlavor, Lld, MaybeLazy, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, TargetOptions}; pub fn opts() -> TargetOptions { let base = base::windows_gnu::opts(); - let late_link_args = MaybeLazy::lazy(|| { + let late_link_args = { // FIXME: This should be updated for the exception machinery changes from #67502 // and inherit from `windows_gnu_base`, at least partially. - let mingw_libs = &[ + const MINGW_LIBS: &[&str] = &[ "-lwinstorecompat", "-lruntimeobject", "-lsynchronization", @@ -16,14 +16,14 @@ pub fn opts() -> TargetOptions { "-lmingwex", "-lmingw32", ]; - let mut late_link_args = - TargetOptions::link_args_base(LinkerFlavor::Gnu(Cc::No, Lld::No), mingw_libs); - add_link_args(&mut late_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), mingw_libs); - late_link_args - }); + TargetOptions::link_args_list(&[ + (LinkerFlavor::Gnu(Cc::No, Lld::No), MINGW_LIBS), + (LinkerFlavor::Gnu(Cc::Yes, Lld::No), MINGW_LIBS), + ]) + }; // Reset the flags back to empty until the FIXME above is addressed. - let late_link_args_dynamic = MaybeLazy::lazy(LinkArgs::new); - let late_link_args_static = MaybeLazy::lazy(LinkArgs::new); + let late_link_args_dynamic = Default::default(); + let late_link_args_static = Default::default(); TargetOptions { abi: "uwp".into(), diff --git a/compiler/rustc_target/src/spec/link_args.rs b/compiler/rustc_target/src/spec/link_args.rs index 5e7704a7f83f2..3db67f7973a08 100644 --- a/compiler/rustc_target/src/spec/link_args.rs +++ b/compiler/rustc_target/src/spec/link_args.rs @@ -1,8 +1,8 @@ //! Linker arguments +use crate::spec::add_link_args; use crate::spec::{LinkerFlavor, LinkerFlavorCli}; -use crate::spec::{MaybeLazy, TargetOptions}; -use crate::spec::StaticCow; +use crate::spec::{MaybeLazy, StaticCow}; use std::collections::BTreeMap; @@ -12,15 +12,26 @@ pub type LinkArgsCli = BTreeMap>>; pub type LazyLinkArgs = MaybeLazy; pub(super) enum LazyLinkArgsState { - Simple(LinkerFlavor, &'static [&'static str]) + Simple(LinkerFlavor, &'static [&'static str]), + List(&'static [(LinkerFlavor, &'static [&'static str])]), } impl FnOnce<()> for LazyLinkArgsState { type Output = LinkArgs; extern "rust-call" fn call_once(self, _args: ()) -> Self::Output { match self { - LazyLinkArgsState::Simple(flavor, args) => - TargetOptions::link_args_base(flavor, args), + LazyLinkArgsState::Simple(flavor, args) => { + let mut link_args = LinkArgs::new(); + add_link_args(&mut link_args, flavor, args); + link_args + } + LazyLinkArgsState::List(l) => { + let mut link_args = LinkArgs::new(); + for (flavor, args) in l { + add_link_args(&mut link_args, *flavor, args) + } + link_args + } } } } diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs index dc2e91765f846..4d4509c3540fc 100644 --- a/compiler/rustc_target/src/spec/mod.rs +++ b/compiler/rustc_target/src/spec/mod.rs @@ -2394,10 +2394,8 @@ impl TargetOptions { MaybeLazy::lazied(link_args::LazyLinkArgsState::Simple(flavor, args)) } - fn link_args_base(flavor: LinkerFlavor, args: &[&'static str]) -> LinkArgs { - let mut link_args = LinkArgs::new(); - add_link_args(&mut link_args, flavor, args); - link_args + fn link_args_list(list: &'static [(LinkerFlavor, &'static [&'static str])]) -> LazyLinkArgs { + MaybeLazy::lazied(link_args::LazyLinkArgsState::List(list)) } fn update_from_cli(&mut self) { diff --git a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs index 63e5f31d6ffa1..ae298fc9a4c41 100644 --- a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs @@ -1,5 +1,5 @@ -use crate::spec::{add_link_args, base, Cc, FramePointer}; -use crate::spec::{LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, FramePointer}; +use crate::spec::{LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_gnu::opts(); @@ -10,18 +10,10 @@ pub fn target() -> Target { // Mark all dynamic libraries and executables as compatible with the larger 4GiB address // space available to x86 Windows binaries on x86_64. - base.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args_base( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &["-m", "i386pe", "--large-address-aware"], - ); - add_link_args( - &mut pre_link_args, - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-Wl,--large-address-aware"], - ); - pre_link_args - }); + base.pre_link_args = TargetOptions::link_args_list(&[ + (LinkerFlavor::Gnu(Cc::No, Lld::No), &["-m", "i386pe", "--large-address-aware"]), + (LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-Wl,--large-address-aware"]), + ]); Target { llvm_target: "i686-pc-windows-gnu".into(), diff --git a/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs index 8b3a155bbf480..c88433537bb6f 100644 --- a/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs @@ -1,5 +1,5 @@ -use crate::spec::{add_link_args, base, Cc, FramePointer}; -use crate::spec::{LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, FramePointer}; +use crate::spec::{LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_uwp_gnu::opts(); @@ -9,18 +9,10 @@ pub fn target() -> Target { // Mark all dynamic libraries and executables as compatible with the larger 4GiB address // space available to x86 Windows binaries on x86_64. - base.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args_base( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &["-m", "i386pe", "--large-address-aware"], - ); - add_link_args( - &mut pre_link_args, - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-Wl,--large-address-aware"], - ); - pre_link_args - }); + base.pre_link_args = TargetOptions::link_args_list(&[ + (LinkerFlavor::Gnu(Cc::No, Lld::No), &["-m", "i386pe", "--large-address-aware"]), + (LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-Wl,--large-address-aware"]), + ]); Target { llvm_target: "i686-pc-windows-gnu".into(), diff --git a/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs b/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs index 4d0a5b9aef321..d61ce747aca1a 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs @@ -1,10 +1,9 @@ -use crate::spec::{ - base, cvs, LinkArgs, LinkerFlavor, MaybeLazy, PanicStrategy, RelocModel, Target, TargetOptions, -}; +use crate::spec::{base, cvs, LinkerFlavor, PanicStrategy}; +use crate::spec::{RelocModel, Target, TargetOptions}; pub fn target() -> Target { // Reset flags for non-Em flavors back to empty to satisfy sanity checking tests. - let pre_link_args = MaybeLazy::lazy(LinkArgs::new); + let pre_link_args = Default::default(); let post_link_args = TargetOptions::link_args(LinkerFlavor::EmCc, &["-sABORTING_MALLOC=0"]); let opts = TargetOptions { diff --git a/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs b/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs index d9ae5e24ab26d..62a8794212d60 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs @@ -9,25 +9,22 @@ //! //! This target is more or less managed by the Rust and WebAssembly Working //! Group nowadays at . - -use crate::spec::add_link_args; -use crate::spec::{base, Cc, LinkerFlavor, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Target, TargetOptions}; pub fn target() -> Target { let mut options = base::wasm::options(); options.os = "unknown".into(); - options.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args_base( + options.pre_link_args = TargetOptions::link_args_list(&[ + ( LinkerFlavor::WasmLld(Cc::No), &[ // For now this target just never has an entry symbol no matter the output // type, so unconditionally pass this. "--no-entry", ], - ); - add_link_args( - &mut pre_link_args, + ), + ( LinkerFlavor::WasmLld(Cc::Yes), &[ // Make sure clang uses LLD as its linker and is configured appropriately @@ -35,9 +32,8 @@ pub fn target() -> Target { "--target=wasm32-unknown-unknown", "-Wl,--no-entry", ], - ); - pre_link_args - }); + ), + ]); Target { llvm_target: "wasm32-unknown-unknown".into(), diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs index f4d9badd3a184..72e4e03bac707 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs @@ -8,8 +8,7 @@ //! Historically this target was known as `wasm32-wasi-preview1-threads`. use crate::spec::{ - add_link_args, base, crt_objects, Cc, LinkSelfContainedDefault, LinkerFlavor, MaybeLazy, - Target, TargetOptions, + base, crt_objects, Cc, LinkSelfContainedDefault, LinkerFlavor, Target, TargetOptions, }; pub fn target() -> Target { @@ -18,13 +17,9 @@ pub fn target() -> Target { options.os = "wasi".into(); options.env = "p1".into(); - options.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args_base( - LinkerFlavor::WasmLld(Cc::No), - &["--import-memory", "--export-memory", "--shared-memory"], - ); - add_link_args( - &mut pre_link_args, + options.pre_link_args = TargetOptions::link_args_list(&[ + (LinkerFlavor::WasmLld(Cc::No), &["--import-memory", "--export-memory", "--shared-memory"]), + ( LinkerFlavor::WasmLld(Cc::Yes), &[ "--target=wasm32-wasip1-threads", @@ -32,9 +27,8 @@ pub fn target() -> Target { "-Wl,--export-memory,", "-Wl,--shared-memory", ], - ); - pre_link_args - }); + ), + ]); options.pre_link_objects_self_contained = crt_objects::pre_wasi_self_contained(); options.post_link_objects_self_contained = crt_objects::post_wasi_self_contained(); diff --git a/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs b/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs index e24180ba41411..28883ee3c77a7 100644 --- a/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs +++ b/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs @@ -7,14 +7,14 @@ //! the standard library is available, most of it returns an error immediately //! (e.g. trying to create a TCP stream or something like that). -use crate::spec::{add_link_args, base, Cc, LinkerFlavor, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Target, TargetOptions}; pub fn target() -> Target { let mut options = base::wasm::options(); options.os = "unknown".into(); - options.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args_base( + options.pre_link_args = TargetOptions::link_args_list(&[ + ( LinkerFlavor::WasmLld(Cc::No), &[ // For now this target just never has an entry symbol no matter the output @@ -22,9 +22,8 @@ pub fn target() -> Target { "--no-entry", "-mwasm64", ], - ); - add_link_args( - &mut pre_link_args, + ), + ( LinkerFlavor::WasmLld(Cc::Yes), &[ // Make sure clang uses LLD as its linker and is configured appropriately @@ -32,9 +31,8 @@ pub fn target() -> Target { "--target=wasm64-unknown-unknown", "-Wl,--no-entry", ], - ); - pre_link_args - }); + ), + ]); // Any engine that implements wasm64 will surely implement the rest of these // features since they were all merged into the official spec by the time diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs index 61935bd4dd3c3..cfc158eadf284 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs @@ -1,4 +1,4 @@ -use crate::spec::{add_link_args, base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_gnu::opts(); @@ -6,18 +6,10 @@ pub fn target() -> Target { base.features = "+cx16,+sse3,+sahf".into(); base.plt_by_default = false; // Use high-entropy 64 bit address space for ASLR - base.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args_base( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &["-m", "i386pep", "--high-entropy-va"], - ); - add_link_args( - &mut pre_link_args, - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-m64", "-Wl,--high-entropy-va"], - ); - pre_link_args - }); + base.pre_link_args = TargetOptions::link_args_list(&[ + (LinkerFlavor::Gnu(Cc::No, Lld::No), &["-m", "i386pep", "--high-entropy-va"]), + (LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64", "-Wl,--high-entropy-va"]), + ]); base.max_atomic_width = Some(128); base.linker = Some("x86_64-w64-mingw32-gcc".into()); diff --git a/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs index 2002b22cab943..2b9ea5a295728 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs @@ -1,4 +1,4 @@ -use crate::spec::{add_link_args, base, Cc, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; +use crate::spec::{base, Cc, LinkerFlavor, Lld, Target, TargetOptions}; pub fn target() -> Target { let mut base = base::windows_uwp_gnu::opts(); @@ -6,18 +6,10 @@ pub fn target() -> Target { base.features = "+cx16,+sse3,+sahf".into(); base.plt_by_default = false; // Use high-entropy 64 bit address space for ASLR - base.pre_link_args = MaybeLazy::lazy(|| { - let mut pre_link_args = TargetOptions::link_args_base( - LinkerFlavor::Gnu(Cc::No, Lld::No), - &["-m", "i386pep", "--high-entropy-va"], - ); - add_link_args( - &mut pre_link_args, - LinkerFlavor::Gnu(Cc::Yes, Lld::No), - &["-m64", "-Wl,--high-entropy-va"], - ); - pre_link_args - }); + base.pre_link_args = TargetOptions::link_args_list(&[ + (LinkerFlavor::Gnu(Cc::No, Lld::No), &["-m", "i386pep", "--high-entropy-va"]), + (LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64", "-Wl,--high-entropy-va"]), + ]); base.max_atomic_width = Some(128); Target { From 0f4784d04ab0540a01c970c9ed5ad7ec4e5db751 Mon Sep 17 00:00:00 2001 From: Urgau Date: Sun, 16 Jun 2024 15:02:40 +0200 Subject: [PATCH 11/13] Make `TargetOptions::link_args` stateful lazy - part 3 Handle Apple targets --- .../rustc_target/src/spec/base/apple/mod.rs | 19 ++++++++++--------- compiler/rustc_target/src/spec/link_args.rs | 4 +++- .../src/spec/targets/aarch64_apple_darwin.rs | 4 ++-- .../src/spec/targets/aarch64_apple_ios.rs | 4 ++-- .../spec/targets/aarch64_apple_ios_macabi.rs | 4 ++-- .../src/spec/targets/aarch64_apple_ios_sim.rs | 4 ++-- .../src/spec/targets/aarch64_apple_tvos.rs | 4 ++-- .../spec/targets/aarch64_apple_tvos_sim.rs | 4 ++-- .../spec/targets/aarch64_apple_visionos.rs | 7 +++---- .../targets/aarch64_apple_visionos_sim.rs | 4 ++-- .../src/spec/targets/aarch64_apple_watchos.rs | 6 +++--- .../spec/targets/aarch64_apple_watchos_sim.rs | 4 ++-- .../spec/targets/arm64_32_apple_watchos.rs | 4 ++-- .../src/spec/targets/arm64e_apple_darwin.rs | 4 ++-- .../src/spec/targets/arm64e_apple_ios.rs | 4 ++-- .../src/spec/targets/armv7k_apple_watchos.rs | 6 +++--- .../src/spec/targets/armv7s_apple_ios.rs | 4 ++-- .../src/spec/targets/i386_apple_ios.rs | 7 ++----- .../src/spec/targets/i686_apple_darwin.rs | 4 ++-- .../src/spec/targets/x86_64_apple_darwin.rs | 4 ++-- .../src/spec/targets/x86_64_apple_ios.rs | 4 ++-- .../spec/targets/x86_64_apple_ios_macabi.rs | 4 ++-- .../src/spec/targets/x86_64_apple_tvos.rs | 7 ++----- .../spec/targets/x86_64_apple_watchos_sim.rs | 7 ++----- .../src/spec/targets/x86_64h_apple_darwin.rs | 4 ++-- 25 files changed, 62 insertions(+), 69 deletions(-) diff --git a/compiler/rustc_target/src/spec/base/apple/mod.rs b/compiler/rustc_target/src/spec/base/apple/mod.rs index 23b1dbeb22a65..391ec6078c27b 100644 --- a/compiler/rustc_target/src/spec/base/apple/mod.rs +++ b/compiler/rustc_target/src/spec/base/apple/mod.rs @@ -1,5 +1,6 @@ use std::{borrow::Cow, env}; +use crate::spec::link_args::LazyLinkArgsState; use crate::spec::{add_link_args, add_link_args_iter, MaybeLazy}; use crate::spec::{cvs, Cc, DebuginfoKind, FramePointer, LinkArgs, LinkerFlavor, Lld}; use crate::spec::{SplitDebuginfo, StackProbeType, StaticCow, Target, TargetOptions}; @@ -94,7 +95,10 @@ impl TargetAbi { } } -pub fn pre_link_args(os: &'static str, arch: Arch, abi: TargetAbi) -> LinkArgs { +pub(crate) type ApplePreLinkArgs = + (/*os:*/ &'static str, /*arch:*/ Arch, /*abi:*/ TargetAbi); + +pub(crate) fn pre_link_args((os, arch, abi): ApplePreLinkArgs) -> LinkArgs { let platform_name: StaticCow = match abi { TargetAbi::Normal => os.into(), TargetAbi::Simulator => format!("{os}-simulator").into(), @@ -114,7 +118,9 @@ pub fn pre_link_args(os: &'static str, arch: Arch, abi: TargetAbi) -> LinkArgs { }; let sdk_version = min_version.clone(); - let mut args = TargetOptions::link_args_base( + let mut args = LinkArgs::new(); + add_link_args( + &mut args, LinkerFlavor::Darwin(Cc::No, Lld::No), &["-arch", arch.target_name(), "-platform_version"], ); @@ -140,12 +146,7 @@ pub fn pre_link_args(os: &'static str, arch: Arch, abi: TargetAbi) -> LinkArgs { args } -pub fn opts( - os: &'static str, - arch: Arch, - abi: TargetAbi, - pre_link_args: MaybeLazy, -) -> TargetOptions { +pub fn opts(os: &'static str, arch: Arch, abi: TargetAbi) -> TargetOptions { TargetOptions { abi: abi.target_abi().into(), os: os.into(), @@ -156,7 +157,7 @@ pub fn opts( // macOS has -dead_strip, which doesn't rely on function_sections function_sections: false, dynamic_linking: true, - pre_link_args, + pre_link_args: MaybeLazy::lazied(LazyLinkArgsState::Apple((os, arch, abi))), families: cvs!["unix"], is_like_osx: true, // LLVM notes that macOS 10.11+ and iOS 9+ default diff --git a/compiler/rustc_target/src/spec/link_args.rs b/compiler/rustc_target/src/spec/link_args.rs index 3db67f7973a08..0a5fc29f17295 100644 --- a/compiler/rustc_target/src/spec/link_args.rs +++ b/compiler/rustc_target/src/spec/link_args.rs @@ -11,9 +11,10 @@ pub type LinkArgsCli = BTreeMap>>; pub type LazyLinkArgs = MaybeLazy; -pub(super) enum LazyLinkArgsState { +pub enum LazyLinkArgsState { Simple(LinkerFlavor, &'static [&'static str]), List(&'static [(LinkerFlavor, &'static [&'static str])]), + Apple(super::base::apple::ApplePreLinkArgs), } impl FnOnce<()> for LazyLinkArgsState { @@ -32,6 +33,7 @@ impl FnOnce<()> for LazyLinkArgsState { } link_args } + LazyLinkArgsState::Apple(args) => super::base::apple::pre_link_args(args), } } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs index cf88dd2f1917d..4dd4592478010 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{macos_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::base::apple::{macos_llvm_target, opts, Arch, TargetAbi}; use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { @@ -6,7 +6,7 @@ pub fn target() -> Target { const OS: &'static str = "macos"; const ABI: TargetAbi = TargetAbi::Normal; - let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let mut base = opts(OS, ARCH, ABI); base.cpu = "apple-m1".into(); base.max_atomic_width = Some(128); diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs index 6abb8d172a427..ebf28292551d1 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{ios_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::base::apple::{ios_llvm_target, opts, Arch, TargetAbi}; use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { @@ -6,7 +6,7 @@ pub fn target() -> Target { const OS: &'static str = "ios"; const ABI: TargetAbi = TargetAbi::Normal; - let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let mut base = opts(OS, ARCH, ABI); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs index 875241fb01b7c..b2c5b1c4527b8 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{mac_catalyst_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::base::apple::{mac_catalyst_llvm_target, opts, Arch, TargetAbi}; use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { @@ -6,7 +6,7 @@ pub fn target() -> Target { const OS: &'static str = "ios"; const ABI: TargetAbi = TargetAbi::MacCatalyst; - let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let mut base = opts(OS, ARCH, ABI); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::LEAK | SanitizerSet::THREAD; Target { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs index f9921a2f3867e..a444993553d12 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{ios_sim_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::base::apple::{ios_sim_llvm_target, opts, Arch, TargetAbi}; use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { @@ -6,7 +6,7 @@ pub fn target() -> Target { const OS: &'static str = "ios"; const ABI: TargetAbi = TargetAbi::Simulator; - let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let mut base = opts(OS, ARCH, ABI); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs index 3a35503e64aec..3434789425727 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{opts, pre_link_args, tvos_llvm_target, Arch, TargetAbi}; +use crate::spec::base::apple::{opts, tvos_llvm_target, Arch, TargetAbi}; use crate::spec::{FramePointer, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { @@ -21,7 +21,7 @@ pub fn target() -> Target { features: "+neon,+fp-armv8,+apple-a7".into(), max_atomic_width: Some(128), frame_pointer: FramePointer::NonLeaf, - ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) + ..opts(OS, ARCH, ABI) }, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs index 65143f2474834..3d71d01785b07 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{opts, pre_link_args, tvos_sim_llvm_target, Arch, TargetAbi}; +use crate::spec::base::apple::{opts, tvos_sim_llvm_target, Arch, TargetAbi}; use crate::spec::{FramePointer, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { @@ -21,7 +21,7 @@ pub fn target() -> Target { features: "+neon,+fp-armv8,+apple-a7".into(), max_atomic_width: Some(128), frame_pointer: FramePointer::NonLeaf, - ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) + ..opts(OS, ARCH, ABI) }, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs index ab5bbe79c8d6c..0e6590ea4c445 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs @@ -1,13 +1,12 @@ -use crate::spec::base::apple::{opts, pre_link_args, visionos_llvm_target, Arch, TargetAbi}; -use crate::spec::maybe_lazy::MaybeLazy; -use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions}; +use crate::spec::base::apple::{opts, visionos_llvm_target, Arch, TargetAbi}; +use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { const OS: &str = "visionos"; const ABI: TargetAbi = TargetAbi::Normal; const ARCH: Arch = Arch::Arm64; - let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let mut base = opts(OS, ARCH, ABI); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs index f724e70c9db13..152a2487cec04 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{opts, pre_link_args, visionos_sim_llvm_target, Arch, TargetAbi}; +use crate::spec::base::apple::{opts, visionos_sim_llvm_target, Arch, TargetAbi}; use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { @@ -6,7 +6,7 @@ pub fn target() -> Target { const ABI: TargetAbi = TargetAbi::Simulator; const ARCH: Arch = Arch::Arm64; - let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let mut base = opts(OS, ARCH, ABI); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos.rs index 6ed7d25aa9040..ae5920b0ea819 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos.rs @@ -1,12 +1,12 @@ -use crate::spec::base::apple::{opts, pre_link_args, Arch, TargetAbi}; -use crate::spec::{MaybeLazy, Target, TargetOptions}; +use crate::spec::base::apple::{opts, Arch, TargetAbi}; +use crate::spec::{Target, TargetOptions}; pub fn target() -> Target { const ARCH: Arch = Arch::Arm64; const OS: &'static str = "watchos"; const ABI: TargetAbi = TargetAbi::Normal; - let base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let base = opts(OS, ARCH, ABI); Target { llvm_target: "aarch64-apple-watchos".into(), metadata: crate::spec::TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs index c8f78b344864d..17e0ea966feb9 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{opts, pre_link_args, watchos_sim_llvm_target, Arch, TargetAbi}; +use crate::spec::base::apple::{opts, watchos_sim_llvm_target, Arch, TargetAbi}; use crate::spec::{FramePointer, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { @@ -25,7 +25,7 @@ pub fn target() -> Target { features: "+neon,+fp-armv8,+apple-a7".into(), max_atomic_width: Some(128), frame_pointer: FramePointer::NonLeaf, - ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) + ..opts(OS, ARCH, ABI) }, } } diff --git a/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs b/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs index 737f896fa1c61..682ddc5c2c67d 100644 --- a/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs +++ b/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{opts, pre_link_args, watchos_llvm_target, Arch, TargetAbi}; +use crate::spec::base::apple::{opts, watchos_llvm_target, Arch, TargetAbi}; use crate::spec::{MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { @@ -6,7 +6,7 @@ pub fn target() -> Target { const ARCH: Arch = Arch::Arm64_32; const ABI: TargetAbi = TargetAbi::Normal; - let base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let base = opts(OS, ARCH, ABI); Target { llvm_target: MaybeLazy::lazy(|| watchos_llvm_target(ARCH)), diff --git a/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs index 178da0b4bafa0..c0795dcba6be6 100644 --- a/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{macos_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::base::apple::{macos_llvm_target, opts, Arch, TargetAbi}; use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { @@ -6,7 +6,7 @@ pub fn target() -> Target { const OS: &'static str = "macos"; const ABI: TargetAbi = TargetAbi::Normal; - let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let mut base = opts(OS, ARCH, ABI); base.cpu = "apple-m1".into(); base.max_atomic_width = Some(128); diff --git a/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs b/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs index 6234ae0ec9d18..42f74d53c305d 100644 --- a/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{ios_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::base::apple::{ios_llvm_target, opts, Arch, TargetAbi}; use crate::spec::{FramePointer, MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { @@ -6,7 +6,7 @@ pub fn target() -> Target { const OS: &'static str = "ios"; const ABI: TargetAbi = TargetAbi::Normal; - let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let mut base = opts(OS, ARCH, ABI); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { diff --git a/compiler/rustc_target/src/spec/targets/armv7k_apple_watchos.rs b/compiler/rustc_target/src/spec/targets/armv7k_apple_watchos.rs index f802f53729e72..0dbd06e587a9a 100644 --- a/compiler/rustc_target/src/spec/targets/armv7k_apple_watchos.rs +++ b/compiler/rustc_target/src/spec/targets/armv7k_apple_watchos.rs @@ -1,5 +1,5 @@ -use crate::spec::base::apple::{opts, pre_link_args, Arch, TargetAbi}; -use crate::spec::{MaybeLazy, Target, TargetOptions}; +use crate::spec::base::apple::{opts, Arch, TargetAbi}; +use crate::spec::{Target, TargetOptions}; pub fn target() -> Target { const ARCH: Arch = Arch::Armv7k; @@ -22,7 +22,7 @@ pub fn target() -> Target { max_atomic_width: Some(64), dynamic_linking: false, position_independent_executables: true, - ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) + ..opts(OS, ARCH, ABI) }, } } diff --git a/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs b/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs index 6285e357f4aff..f5693647040ca 100644 --- a/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{ios_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::base::apple::{ios_llvm_target, opts, Arch, TargetAbi}; use crate::spec::{MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { @@ -20,7 +20,7 @@ pub fn target() -> Target { options: TargetOptions { features: "+v7,+vfp4,+neon".into(), max_atomic_width: Some(64), - ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) + ..opts(OS, ARCH, ABI) }, } } diff --git a/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs b/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs index 3c1d9c044bda8..747c881524621 100644 --- a/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{ios_sim_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::base::apple::{ios_sim_llvm_target, opts, Arch, TargetAbi}; use crate::spec::{MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { @@ -25,9 +25,6 @@ pub fn target() -> Target { i128:128-f64:32:64-f80:128-n8:16:32-S128" .into(), arch: ARCH.target_arch(), - options: TargetOptions { - max_atomic_width: Some(64), - ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) - }, + options: TargetOptions { max_atomic_width: Some(64), ..opts(OS, ARCH, ABI) }, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs index 65bcf98cbbb2d..adface04134a3 100644 --- a/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{macos_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::base::apple::{macos_llvm_target, opts, Arch, TargetAbi}; use crate::spec::{Cc, FramePointer, LinkerFlavor, Lld, MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { @@ -7,7 +7,7 @@ pub fn target() -> Target { const OS: &'static str = "macos"; const ABI: TargetAbi = TargetAbi::Normal; - let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let mut base = opts(OS, ARCH, ABI); base.max_atomic_width = Some(64); base.pre_link_args = TargetOptions::link_args(LinkerFlavor::Darwin(Cc::Yes, Lld::No), &["-m32"]); diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs index bc843c1211d77..bd59dc3f813bd 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{macos_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::base::apple::{macos_llvm_target, opts, Arch, TargetAbi}; use crate::spec::{Cc, FramePointer, LinkerFlavor, Lld, MaybeLazy, SanitizerSet}; use crate::spec::{Target, TargetOptions}; @@ -7,7 +7,7 @@ pub fn target() -> Target { const OS: &'static str = "macos"; const ABI: TargetAbi = TargetAbi::Normal; - let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let mut base = opts(OS, ARCH, ABI); base.max_atomic_width = Some(128); // penryn+ supports cmpxchg16b base.frame_pointer = FramePointer::Always; base.pre_link_args = diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs index 043ef133186ed..e59dbe0c6c761 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{ios_sim_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::base::apple::{ios_sim_llvm_target, opts, Arch, TargetAbi}; use crate::spec::{MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { @@ -8,7 +8,7 @@ pub fn target() -> Target { // x86_64-apple-ios is a simulator target, even though it isn't declared // that way in the target name like the other ones... - let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let mut base = opts(OS, ARCH, ABI); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD; Target { diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs index c95e3df08a972..04d0bc7775200 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{mac_catalyst_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::base::apple::{mac_catalyst_llvm_target, opts, Arch, TargetAbi}; use crate::spec::{MaybeLazy, SanitizerSet, Target, TargetOptions}; pub fn target() -> Target { @@ -6,7 +6,7 @@ pub fn target() -> Target { const OS: &'static str = "ios"; const ABI: TargetAbi = TargetAbi::MacCatalyst; - let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let mut base = opts(OS, ARCH, ABI); base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::LEAK | SanitizerSet::THREAD; Target { diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs index f86e26bec7ebf..d6495f83c8ff9 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{opts, pre_link_args, tvos_sim_llvm_target, Arch, TargetAbi}; +use crate::spec::base::apple::{opts, tvos_sim_llvm_target, Arch, TargetAbi}; use crate::spec::{MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { @@ -21,9 +21,6 @@ pub fn target() -> Target { data_layout: "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), arch: ARCH.target_arch(), - options: TargetOptions { - max_atomic_width: Some(128), - ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) - }, + options: TargetOptions { max_atomic_width: Some(128), ..opts(OS, ARCH, ABI) }, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs index 95a67c895e1e1..a00e94a1a713c 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{opts, pre_link_args, watchos_sim_llvm_target, Arch, TargetAbi}; +use crate::spec::base::apple::{opts, watchos_sim_llvm_target, Arch, TargetAbi}; use crate::spec::{MaybeLazy, Target, TargetOptions}; pub fn target() -> Target { @@ -18,9 +18,6 @@ pub fn target() -> Target { data_layout: "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), arch: ARCH.target_arch(), - options: TargetOptions { - max_atomic_width: Some(128), - ..opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))) - }, + options: TargetOptions { max_atomic_width: Some(128), ..opts(OS, ARCH, ABI) }, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs index dc7e46465bc2f..1be5856b4ca32 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs @@ -1,4 +1,4 @@ -use crate::spec::base::apple::{macos_llvm_target, opts, pre_link_args, Arch, TargetAbi}; +use crate::spec::base::apple::{macos_llvm_target, opts, Arch, TargetAbi}; use crate::spec::{Cc, FramePointer, LinkerFlavor, Lld, MaybeLazy, SanitizerSet}; use crate::spec::{Target, TargetOptions}; @@ -7,7 +7,7 @@ pub fn target() -> Target { const OS: &'static str = "macos"; const ABI: TargetAbi = TargetAbi::Normal; - let mut base = opts(OS, ARCH, ABI, MaybeLazy::lazy(|| pre_link_args(OS, ARCH, ABI))); + let mut base = opts(OS, ARCH, ABI); base.max_atomic_width = Some(128); base.frame_pointer = FramePointer::Always; base.pre_link_args = From 99879cd1adf2454ec6dc458d29205b535097dcaf Mon Sep 17 00:00:00 2001 From: Urgau Date: Mon, 17 Jun 2024 12:50:01 +0200 Subject: [PATCH 12/13] Add missing `#[inline]` to `TargetOptions::link_args` --- compiler/rustc_target/src/spec/link_args.rs | 2 ++ compiler/rustc_target/src/spec/mod.rs | 2 ++ 2 files changed, 4 insertions(+) diff --git a/compiler/rustc_target/src/spec/link_args.rs b/compiler/rustc_target/src/spec/link_args.rs index 0a5fc29f17295..53233ebfa593d 100644 --- a/compiler/rustc_target/src/spec/link_args.rs +++ b/compiler/rustc_target/src/spec/link_args.rs @@ -19,6 +19,8 @@ pub enum LazyLinkArgsState { impl FnOnce<()> for LazyLinkArgsState { type Output = LinkArgs; + + #[inline] extern "rust-call" fn call_once(self, _args: ()) -> Self::Output { match self { LazyLinkArgsState::Simple(flavor, args) => { diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs index 4d4509c3540fc..19b58d4c7f726 100644 --- a/compiler/rustc_target/src/spec/mod.rs +++ b/compiler/rustc_target/src/spec/mod.rs @@ -2390,10 +2390,12 @@ fn add_link_args(link_args: &mut LinkArgs, flavor: LinkerFlavor, args: &[&'stati } impl TargetOptions { + #[inline] fn link_args(flavor: LinkerFlavor, args: &'static [&'static str]) -> LazyLinkArgs { MaybeLazy::lazied(link_args::LazyLinkArgsState::Simple(flavor, args)) } + #[inline] fn link_args_list(list: &'static [(LinkerFlavor, &'static [&'static str])]) -> LazyLinkArgs { MaybeLazy::lazied(link_args::LazyLinkArgsState::List(list)) } From d7ef5e6dae5d4ae3f76580f74a808645cfbbcb32 Mon Sep 17 00:00:00 2001 From: Urgau Date: Tue, 18 Jun 2024 16:04:58 +0200 Subject: [PATCH 13/13] Re-make `MaybeLazy::default` lazy --- compiler/rustc_target/src/spec/maybe_lazy.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/compiler/rustc_target/src/spec/maybe_lazy.rs b/compiler/rustc_target/src/spec/maybe_lazy.rs index f1a8e658853aa..312e97ccab707 100644 --- a/compiler/rustc_target/src/spec/maybe_lazy.rs +++ b/compiler/rustc_target/src/spec/maybe_lazy.rs @@ -6,6 +6,7 @@ use std::ops::Deref; use std::sync::LazyLock; enum MaybeLazyInner { + LazyStaticFn(LazyLock), Lazy(LazyLock), Cow(Cow<'static, T>), } @@ -60,6 +61,7 @@ impl, F: FnOnce() -> T::Owned> Clone fn clone(&self) -> Self { MaybeLazy { inner: MaybeLazyInner::Cow(match &self.inner { + MaybeLazyInner::LazyStaticFn(f) => Cow::Owned((*f).to_owned()), MaybeLazyInner::Lazy(f) => Cow::Owned((*f).to_owned()), MaybeLazyInner::Cow(c) => c.clone(), }), @@ -72,7 +74,7 @@ impl, F: FnOnce() -> T::Owned> Def { #[inline] fn default() -> MaybeLazy { - MaybeLazy::owned(T::Owned::default()) + MaybeLazy { inner: MaybeLazyInner::LazyStaticFn(LazyLock::new(T::Owned::default)) } } } @@ -85,6 +87,7 @@ impl>, F: FnOnce() -> T::Owned> D #[inline] fn deref(&self) -> &T { match &self.inner { + MaybeLazyInner::LazyStaticFn(f) => (&**f).borrow(), MaybeLazyInner::Lazy(f) => (&**f).borrow(), MaybeLazyInner::Cow(c) => &*c, }