Auto merge of rust-lang#122703 - Urgau:lazy-targets, r=<try>

Lazify more work in builtins targets

This PR make some fields in `Target` and `TargetOptions` lazifyable.

This is done in order to reduce the impact of check-cfg which needs to load all the built-ins targets but doesn't need all the fields.

In paticular this PR introduce a `MaybeLazy<T>` struct to support a borrowed, owned and lazy state.

The fields that are changed are:
 - `LinkArgs` fields (access to env + allocate): ~54 023 236 ins[^1] -> ~53 478 072 ins
 - `CrtObjects` fields (allocate): ~53 478 072 ins -> ~53 127 832 ins
 - `llvm_name` field (access to env + allocate): ~53 127 832 ins -> ~53 057 110 ins

This brings around -1 000 000 ins*tructions* and -0.2/0.3ms of less wall-time (with some measurement even having the same minimum wall-time with or without check-cfg) 🎉.

*This PR is also a step further to completely `static`-fying all the build-in targets, if we one day we decide to do it, but that's a separate conversion.*

[^1]: This is the total number of instructions as measured with `cachegrind` for the entire `rustc` invocation on a cargo --lib hello world, variance was really low (<15 000 ins).
In the scale of the check-cfg feature, last time I measured `CheckCfg::fill_well_known` was around ~2.8 millions ins.

r? `@petrochenkov`

Author: bors

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -1832,7 +1832,7 @@ fn add_pre_link_objects(
     // FIXME: we are currently missing some infra here (per-linker-flavor CRT objects),
     // so Fuchsia has to be special-cased.
     let opts = &sess.target;
-    let empty = Default::default();
+    let empty = CrtObjects::default();
     let objects = if self_contained {
         &opts.pre_link_objects_self_contained
     } else if !(sess.target.os == "fuchsia" && matches!(flavor, LinkerFlavor::Gnu(Cc::Yes, _))) {

compiler/rustc_target/src/lib.rs

@@ -14,6 +14,7 @@
 #![feature(assert_matches)]
 #![feature(iter_intersperse)]
 #![feature(let_chains)]
+#![feature(lazy_cell)]
 #![feature(rustc_attrs)]
 #![feature(step_trait)]
 #![allow(internal_features)]

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()
     }

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};
 
@@ -90,7 +90,9 @@ impl Arch {
     }
 }
 
-fn pre_link_args(os: &'static str, arch: Arch, abi: &'static str) -> LinkArgs {
+pub fn pre_link_args(os: &'static str, arch: Arch) -> LinkArgs {
+    let abi = arch.target_abi();
+
     let platform_name: StaticCow<str> = match abi {
         "sim" => format!("{os}-simulator").into(),
         "macabi" => "mac-catalyst".into(),
@@ -136,7 +138,7 @@ fn pre_link_args(os: &'static str, arch: Arch, abi: &'static str) -> LinkArgs {
     args
 }
 
-pub fn opts(os: &'static str, arch: Arch) -> TargetOptions {
+pub fn opts(os: &'static str, arch: Arch, pre_link_args: MaybeLazy<LinkArgs>) -> TargetOptions {
     let abi = arch.target_abi();
 
     TargetOptions {
@@ -149,7 +151,7 @@ pub fn opts(os: &'static str, arch: Arch) -> 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

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,

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(),
@@ -32,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,

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(),

compiler/rustc_target/src/spec/base/linux_musl.rs

@@ -1,12 +1,12 @@
 use crate::spec::crt_objects;
-use crate::spec::{base, LinkSelfContainedDefault, TargetOptions};
+use crate::spec::{base, LinkSelfContainedDefault, MaybeLazy, TargetOptions};
 
 pub fn opts() -> TargetOptions {
     let mut base = base::linux::opts();
 
     base.env = "musl".into();
-    base.pre_link_objects_self_contained = crt_objects::pre_musl_self_contained();
-    base.post_link_objects_self_contained = crt_objects::post_musl_self_contained();
+    base.pre_link_objects_self_contained = MaybeLazy::lazy(crt_objects::pre_musl_self_contained);
+    base.post_link_objects_self_contained = MaybeLazy::lazy(crt_objects::post_musl_self_contained);
     base.link_self_contained = LinkSelfContainedDefault::InferredForMusl;
 
     // These targets statically link libc by default

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),

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(),

compiler/rustc_target/src/spec/base/uefi_msvc.rs

@@ -9,30 +9,34 @@
 // 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, 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(),

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,