cow! targets - part 1

Author: Urgau

compiler/rustc_target/src/spec/mod.rs

@@ -1714,7 +1714,7 @@ macro_rules! cvs {
 }
 
 /// Cow-Str: Cow<'static, str>
-macro_rules! cs {
+macro_rules! cow {
     () => {
         ::std::borrow::Cow::Borrowed()
     };
@@ -1723,7 +1723,7 @@ macro_rules! cs {
     };
 }
 
-pub(crate) use cs;
+pub(crate) use cow;
 pub(crate) use cvs;
 
 /// Warnings encountered when parsing the target `json`.
@@ -2295,13 +2295,13 @@ impl TargetOptions {
         TargetOptions {
             is_builtin: false,
             endian: Endian::Little,
-            c_int_width: cs!("32"),
-            os: cs!("none"),
-            env: cs!(""),
-            abi: cs!(""),
-            vendor: cs!("unknown"),
+            c_int_width: cow!("32"),
+            os: cow!("none"),
+            env: cow!(""),
+            abi: cow!(""),
+            vendor: cow!("unknown"),
             linker: if let Some(s) = option_env!("CFG_DEFAULT_LINKER") {
-                Some(cs!(s))
+                Some(cow!(s))
             } else {
                 None
             },
@@ -2311,8 +2311,8 @@ impl TargetOptions {
             linker_is_gnu_json: true,
             link_script: None,
             asm_args: cvs![],
-            cpu: cs!("generic"),
-            features: cs!(""),
+            cpu: cow!("generic"),
+            features: cow!(""),
             direct_access_external_data: None,
             dynamic_linking: false,
             dll_tls_export: true,
@@ -2324,11 +2324,11 @@ impl TargetOptions {
             disable_redzone: false,
             frame_pointer: FramePointer::MayOmit,
             function_sections: true,
-            dll_prefix: cs!("lib"),
-            dll_suffix: cs!(".so"),
-            exe_suffix: cs!(""),
-            staticlib_prefix: cs!("lib"),
-            staticlib_suffix: cs!(".a"),
+            dll_prefix: cow!("lib"),
+            dll_suffix: cow!(".so"),
+            exe_suffix: cow!(""),
+            staticlib_prefix: cow!("lib"),
+            staticlib_suffix: cow!(".a"),
             families: cvs![],
             abi_return_struct_as_int: false,
             is_like_aix: false,
@@ -2363,13 +2363,13 @@ impl TargetOptions {
             post_link_args_json: LinkArgsCli::new(),
             link_env: cvs![],
             link_env_remove: cvs![],
-            archive_format: cs!("gnu"),
+            archive_format: cow!("gnu"),
             main_needs_argc_argv: true,
             allow_asm: true,
             has_thread_local: false,
             obj_is_bitcode: false,
             forces_embed_bitcode: false,
-            bitcode_llvm_cmdline: cs!(""),
+            bitcode_llvm_cmdline: cow!(""),
             min_atomic_width: None,
             max_atomic_width: None,
             atomic_cas: true,
@@ -2392,9 +2392,9 @@ impl TargetOptions {
             limit_rdylib_exports: true,
             override_export_symbols: None,
             merge_functions: MergeFunctions::Aliases,
-            mcount: cs!("mcount"),
+            mcount: cow!("mcount"),
             llvm_mcount_intrinsic: None,
-            llvm_abiname: cs!(""),
+            llvm_abiname: cow!(""),
             relax_elf_relocations: false,
             llvm_args: cvs![],
             use_ctors_section: false,
@@ -2409,7 +2409,7 @@ impl TargetOptions {
             c_enum_min_bits: None,
             generate_arange_section: true,
             supports_stack_protector: true,
-            entry_name: cs!("main"),
+            entry_name: cow!("main"),
             entry_abi: Conv::C,
             supports_xray: false,
         }

compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs

@@ -1,3 +1,4 @@
+use crate::spec::cow;
 use std::sync::LazyLock;
 
 use crate::spec::base::apple::{macos_llvm_target, opts, pre_link_args, Arch};
@@ -8,7 +9,7 @@ pub fn target() -> Target {
     const OS: &'static str = "macos";
 
     let mut base = opts(OS, ARCH);
-    base.cpu = "apple-m1".into();
+    base.cpu = cow!("apple-m1");
     base.max_atomic_width = Some(128);
 
     // FIXME: The leak sanitizer currently fails the tests, see #88132.
@@ -22,10 +23,10 @@ pub fn target() -> Target {
         // correctly, we do too.
         llvm_target: macos_llvm_target(ARCH).into(),
         pointer_width: 64,
-        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
+        data_layout: cow!("e-m:o-i64:64-i128:128-n32:64-S128"),
         arch: ARCH.target_arch(),
         options: TargetOptions {
-            mcount: "\u{1}mcount".into(),
+            mcount: cow!("\u{1}mcount"),
             frame_pointer: FramePointer::NonLeaf,
             ..base
         },

compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs

@@ -1,4 +1,6 @@
 use crate::spec::base::apple::{ios_llvm_target, opts, Arch};
+use crate::spec::cow;
+
 use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions};
 
 pub fn target() -> Target {
@@ -13,10 +15,10 @@ pub fn target() -> Target {
         // MACH-O commands, so we do too.
         llvm_target: ios_llvm_target(arch).into(),
         pointer_width: 64,
-        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
+        data_layout: cow!("e-m:o-i64:64-i128:128-n32:64-S128"),
         arch: arch.target_arch(),
         options: TargetOptions {
-            features: "+neon,+fp-armv8,+apple-a7".into(),
+            features: cow!("+neon,+fp-armv8,+apple-a7"),
             max_atomic_width: Some(128),
             frame_pointer: FramePointer::NonLeaf,
             ..base

compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs

@@ -1,4 +1,6 @@
 use crate::spec::base::apple::{mac_catalyst_llvm_target, opts, Arch};
+use crate::spec::cow;
+
 use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions};
 
 pub fn target() -> Target {
@@ -9,10 +11,10 @@ pub fn target() -> Target {
     Target {
         llvm_target: mac_catalyst_llvm_target(arch).into(),
         pointer_width: 64,
-        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
+        data_layout: cow!("e-m:o-i64:64-i128:128-n32:64-S128"),
         arch: arch.target_arch(),
         options: TargetOptions {
-            features: "+neon,+fp-armv8,+apple-a12".into(),
+            features: cow!("+neon,+fp-armv8,+apple-a12"),
             max_atomic_width: Some(128),
             frame_pointer: FramePointer::NonLeaf,
             ..base

compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs

@@ -1,4 +1,6 @@
 use crate::spec::base::apple::{ios_sim_llvm_target, opts, Arch};
+use crate::spec::cow;
+
 use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions};
 
 pub fn target() -> Target {
@@ -13,10 +15,10 @@ pub fn target() -> Target {
         // MACH-O commands, so we do too.
         llvm_target: ios_sim_llvm_target(arch).into(),
         pointer_width: 64,
-        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
+        data_layout: cow!("e-m:o-i64:64-i128:128-n32:64-S128"),
         arch: arch.target_arch(),
         options: TargetOptions {
-            features: "+neon,+fp-armv8,+apple-a7".into(),
+            features: cow!("+neon,+fp-armv8,+apple-a7"),
             max_atomic_width: Some(128),
             frame_pointer: FramePointer::NonLeaf,
             ..base

compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs

@@ -1,15 +1,17 @@
 use crate::spec::base::apple::{opts, tvos_llvm_target, Arch};
+use crate::spec::cow;
+
 use crate::spec::{FramePointer, Target, TargetOptions};
 
 pub fn target() -> Target {
     let arch = Arch::Arm64;
     Target {
         llvm_target: tvos_llvm_target(arch).into(),
         pointer_width: 64,
-        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
+        data_layout: cow!("e-m:o-i64:64-i128:128-n32:64-S128"),
         arch: arch.target_arch(),
         options: TargetOptions {
-            features: "+neon,+fp-armv8,+apple-a7".into(),
+            features: cow!("+neon,+fp-armv8,+apple-a7"),
             max_atomic_width: Some(128),
             frame_pointer: FramePointer::NonLeaf,
             ..opts("tvos", arch)

compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs

@@ -1,15 +1,17 @@
 use crate::spec::base::apple::{opts, tvos_sim_llvm_target, Arch};
+use crate::spec::cow;
+
 use crate::spec::{FramePointer, Target, TargetOptions};
 
 pub fn target() -> Target {
     let arch = Arch::Arm64_sim;
     Target {
         llvm_target: tvos_sim_llvm_target(arch).into(),
         pointer_width: 64,
-        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
+        data_layout: cow!("e-m:o-i64:64-i128:128-n32:64-S128"),
         arch: arch.target_arch(),
         options: TargetOptions {
-            features: "+neon,+fp-armv8,+apple-a7".into(),
+            features: cow!("+neon,+fp-armv8,+apple-a7"),
             max_atomic_width: Some(128),
             frame_pointer: FramePointer::NonLeaf,
             ..opts("tvos", arch)

compiler/rustc_target/src/spec/targets/aarch64_apple_watchos.rs

@@ -1,15 +1,17 @@
 use crate::spec::base::apple::{opts, Arch};
+use crate::spec::cow;
+
 use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     let base = opts("watchos", Arch::Arm64);
     Target {
-        llvm_target: "aarch64-apple-watchos".into(),
+        llvm_target: cow!("aarch64-apple-watchos"),
         pointer_width: 64,
-        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".into(),
+        data_layout: cow!("e-m:o-i64:64-i128:128-n32:64-S128"),
+        arch: cow!("aarch64"),
         options: TargetOptions {
-            features: "+v8a,+neon,+fp-armv8,+apple-a7".into(),
+            features: cow!("+v8a,+neon,+fp-armv8,+apple-a7"),
             max_atomic_width: Some(128),
             dynamic_linking: false,
             position_independent_executables: true,

compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs

@@ -1,4 +1,6 @@
 use crate::spec::base::apple::{opts, watchos_sim_llvm_target, Arch};
+use crate::spec::cow;
+
 use crate::spec::{FramePointer, Target, TargetOptions};
 
 pub fn target() -> Target {
@@ -10,10 +12,10 @@ pub fn target() -> Target {
         // MACH-O commands, so we do too.
         llvm_target: watchos_sim_llvm_target(arch).into(),
         pointer_width: 64,
-        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
+        data_layout: cow!("e-m:o-i64:64-i128:128-n32:64-S128"),
         arch: arch.target_arch(),
         options: TargetOptions {
-            features: "+neon,+fp-armv8,+apple-a7".into(),
+            features: cow!("+neon,+fp-armv8,+apple-a7"),
             max_atomic_width: Some(128),
             frame_pointer: FramePointer::NonLeaf,
             ..opts("watchos", arch)

compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu.rs

@@ -1,17 +1,19 @@
 use crate::abi::Endian;
+use crate::spec::cow;
+
 use crate::spec::{base, StackProbeType, Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "aarch64_be-unknown-linux-gnu".into(),
+        llvm_target: cow!("aarch64_be-unknown-linux-gnu"),
         pointer_width: 64,
-        data_layout: "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".into(),
+        data_layout: cow!("E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"),
+        arch: cow!("aarch64"),
         options: TargetOptions {
-            features: "+v8a,+outline-atomics".into(),
+            features: cow!("+v8a,+outline-atomics"),
             max_atomic_width: Some(128),
             stack_probes: StackProbeType::Inline,
-            mcount: "\u{1}_mcount".into(),
+            mcount: cow!("\u{1}_mcount"),
             endian: Endian::Big,
             ..base::linux_gnu::opts()
         },

compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu_ilp32.rs

@@ -1,20 +1,22 @@
 use crate::abi::Endian;
+use crate::spec::cow;
+
 use crate::spec::{base, StackProbeType, Target, TargetOptions};
 
 pub fn target() -> Target {
     let mut base = base::linux_gnu::opts();
     base.max_atomic_width = Some(128);
 
     Target {
-        llvm_target: "aarch64_be-unknown-linux-gnu_ilp32".into(),
+        llvm_target: cow!("aarch64_be-unknown-linux-gnu_ilp32"),
         pointer_width: 32,
-        data_layout: "E-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".into(),
+        data_layout: cow!("E-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"),
+        arch: cow!("aarch64"),
         options: TargetOptions {
-            abi: "ilp32".into(),
-            features: "+v8a,+outline-atomics".into(),
+            abi: cow!("ilp32"),
+            features: cow!("+v8a,+outline-atomics"),
             stack_probes: StackProbeType::Inline,
-            mcount: "\u{1}_mcount".into(),
+            mcount: cow!("\u{1}_mcount"),
             endian: Endian::Big,
             ..base
         },

compiler/rustc_target/src/spec/targets/aarch64_be_unknown_netbsd.rs

@@ -1,14 +1,16 @@
 use crate::abi::Endian;
+use crate::spec::cow;
+
 use crate::spec::{base, StackProbeType, Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "aarch64_be-unknown-netbsd".into(),
+        llvm_target: cow!("aarch64_be-unknown-netbsd"),
         pointer_width: 64,
-        data_layout: "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".into(),
+        data_layout: cow!("E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"),
+        arch: cow!("aarch64"),
         options: TargetOptions {
-            mcount: "__mcount".into(),
+            mcount: cow!("__mcount"),
             max_atomic_width: Some(128),
             stack_probes: StackProbeType::Inline,
             endian: Endian::Big,

compiler/rustc_target/src/spec/targets/aarch64_kmc_solid_asp3.rs

@@ -1,15 +1,16 @@
+use crate::spec::cow;
 use crate::spec::{base, RelocModel, StackProbeType, Target, TargetOptions};
 
 pub fn target() -> Target {
     let base = base::solid::opts("asp3");
     Target {
-        llvm_target: "aarch64-unknown-none".into(),
+        llvm_target: cow!("aarch64-unknown-none"),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".into(),
+        data_layout: cow!("e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"),
+        arch: cow!("aarch64"),
         options: TargetOptions {
-            linker: Some("aarch64-kmc-elf-gcc".into()),
-            features: "+v8a,+neon,+fp-armv8".into(),
+            linker: Some(cow!("aarch64-kmc-elf-gcc")),
+            features: cow!("+v8a,+neon,+fp-armv8"),
             relocation_model: RelocModel::Static,
             disable_redzone: true,
             max_atomic_width: Some(128),

compiler/rustc_target/src/spec/targets/aarch64_linux_android.rs

@@ -1,19 +1,20 @@
+use crate::spec::cow;
 use crate::spec::{base, SanitizerSet, StackProbeType, Target, TargetOptions};
 
 // See https://developer.android.com/ndk/guides/abis.html#arm64-v8a
 // for target ABI requirements.
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "aarch64-linux-android".into(),
+        llvm_target: cow!("aarch64-linux-android"),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".into(),
+        data_layout: cow!("e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"),
+        arch: cow!("aarch64"),
         options: TargetOptions {
             max_atomic_width: Some(128),
             // As documented in https://developer.android.com/ndk/guides/cpu-features.html
             // the neon (ASIMD) and FP must exist on all android aarch64 targets.
-            features: "+v8a,+neon,+fp-armv8".into(),
+            features: cow!("+v8a,+neon,+fp-armv8"),
             stack_probes: StackProbeType::Inline,
             supported_sanitizers: SanitizerSet::CFI
                 | SanitizerSet::HWADDRESS