Replace every String in Target(Options) with Cow<'static, str>

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -116,7 +116,7 @@ fn instrument_function_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribu
 
         // The function name varies on platforms.
         // See test/CodeGen/mcount.c in clang.
-        let mcount_name = cx.sess().target.mcount.as_str();
+        let mcount_name = cx.sess().target.mcount.as_ref();
 
         Some(llvm::CreateAttrStringValue(
             cx.llcx,

compiler/rustc_codegen_llvm/src/builder.rs

@@ -1452,7 +1452,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
     }
 
     fn fptoint_sat_broken_in_llvm(&self) -> bool {
-        match self.tcx.sess.target.arch.as_str() {
+        match self.tcx.sess.target.arch.as_ref() {
             // FIXME - https://bugs.llvm.org/show_bug.cgi?id=50083
             "riscv64" => llvm_util::get_version() < (13, 0, 0),
             _ => false,

compiler/rustc_codegen_llvm/src/context.rs

@@ -134,7 +134,7 @@ pub unsafe fn create_module<'ll>(
     let mod_name = SmallCStr::new(mod_name);
     let llmod = llvm::LLVMModuleCreateWithNameInContext(mod_name.as_ptr(), llcx);
 
-    let mut target_data_layout = sess.target.data_layout.clone();
+    let mut target_data_layout = sess.target.data_layout.to_string();
     let llvm_version = llvm_util::get_version();
     if llvm_version < (13, 0, 0) {
         if sess.target.arch == "powerpc64" {
@@ -859,7 +859,7 @@ impl<'ll> CodegenCx<'ll, '_> {
 
         // This isn't an "LLVM intrinsic", but LLVM's optimization passes
         // recognize it like one and we assume it exists in `core::slice::cmp`
-        match self.sess().target.arch.as_str() {
+        match self.sess().target.arch.as_ref() {
             "avr" | "msp430" => ifn!("memcmp", fn(i8p, i8p, t_isize) -> t_i16),
             _ => ifn!("memcmp", fn(i8p, i8p, t_isize) -> t_i32),
         }

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -329,7 +329,7 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                     let b_ptr = self.bitcast(b, i8p_ty);
                     let n = self.const_usize(layout.size().bytes());
                     let cmp = self.call_intrinsic("memcmp", &[a_ptr, b_ptr, n]);
-                    match self.cx.sess().target.arch.as_str() {
+                    match self.cx.sess().target.arch.as_ref() {
                         "avr" | "msp430" => self.icmp(IntPredicate::IntEQ, cmp, self.const_i16(0)),
                         _ => self.icmp(IntPredicate::IntEQ, cmp, self.const_i32(0)),
                     }

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -61,8 +61,8 @@ unsafe fn configure_llvm(sess: &Session) {
         full_arg.trim().split(|c: char| c == '=' || c.is_whitespace()).next().unwrap_or("")
     }
 
-    let cg_opts = sess.opts.cg.llvm_args.iter();
+    let cg_opts = sess.opts.cg.llvm_args.iter().map(AsRef::as_ref);
-    let tg_opts = sess.target.llvm_args.iter();
+    let tg_opts = sess.target.llvm_args.iter().map(AsRef::as_ref);
     let sess_args = cg_opts.chain(tg_opts);
 
     let user_specified_args: FxHashSet<_> =
@@ -375,8 +375,10 @@ fn handle_native(name: &str) -> &str {
 }
 
 pub fn target_cpu(sess: &Session) -> &str {
-    let name = sess.opts.cg.target_cpu.as_ref().unwrap_or(&sess.target.cpu);
+    match sess.opts.cg.target_cpu {
-    handle_native(name)
+        Some(ref name) => handle_native(name),
+        None => handle_native(sess.target.cpu.as_ref()),
+    }
 }
 
 /// The list of LLVM features computed from CLI flags (`-Ctarget-cpu`, `-Ctarget-feature`,

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -675,10 +675,10 @@ fn link_natively<'a, B: ArchiveBuilder<'a>>(
     linker::disable_localization(&mut cmd);
 
     for &(ref k, ref v) in &sess.target.link_env {
-        cmd.env(k, v);
+        cmd.env(k.as_ref(), v.as_ref());
     }
     for k in &sess.target.link_env_remove {
-        cmd.env_remove(k);
+        cmd.env_remove(k.as_ref());
     }
 
     if sess.opts.prints.contains(&PrintRequest::LinkArgs) {
@@ -1216,7 +1216,7 @@ pub fn linker_and_flavor(sess: &Session) -> (PathBuf, LinkerFlavor) {
 
     if let Some(ret) = infer_from(
         sess,
-        sess.target.linker.clone().map(PathBuf::from),
+        sess.target.linker.as_ref().map(|l| PathBuf::from(l.as_ref())),
         Some(sess.target.linker_flavor),
     ) {
         return ret;
@@ -1602,7 +1602,7 @@ fn add_link_script(cmd: &mut dyn Linker, sess: &Session, tmpdir: &Path, crate_ty
             let file_name = ["rustc", &sess.target.llvm_target, "linkfile.ld"].join("-");
 
             let path = tmpdir.join(file_name);
-            if let Err(e) = fs::write(&path, script) {
+            if let Err(e) = fs::write(&path, script.as_ref()) {
                 sess.fatal(&format!("failed to write link script to {}: {}", path.display(), e));
             }
 
@@ -1960,8 +1960,8 @@ fn add_order_independent_options(
         cmd.arg(&codegen_results.crate_info.target_cpu);
         cmd.arg("--cpu-features");
         cmd.arg(match &sess.opts.cg.target_feature {
-            feat if !feat.is_empty() => feat,
+            feat if !feat.is_empty() => feat.as_ref(),
-            _ => &sess.target.options.features,
+            _ => sess.target.options.features.as_ref(),
         });
     }
 
@@ -2478,12 +2478,12 @@ fn add_apple_sdk(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavor) {
     let os = &sess.target.os;
     let llvm_target = &sess.target.llvm_target;
     if sess.target.vendor != "apple"
-        || !matches!(os.as_str(), "ios" | "tvos")
+        || !matches!(os.as_ref(), "ios" | "tvos")
         || flavor != LinkerFlavor::Gcc
     {
         return;
     }
-    let sdk_name = match (arch.as_str(), os.as_str()) {
+    let sdk_name = match (arch.as_ref(), os.as_ref()) {
         ("aarch64", "tvos") => "appletvos",
         ("x86_64", "tvos") => "appletvsimulator",
         ("arm", "ios") => "iphoneos",

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -75,7 +75,7 @@ pub fn get_linker<'a>(
         if let Some(ref tool) = msvc_tool {
             let original_path = tool.path();
             if let Some(ref root_lib_path) = original_path.ancestors().nth(4) {
-                let arch = match t.arch.as_str() {
+                let arch = match t.arch.as_ref() {
                     "x86_64" => Some("x64"),
                     "x86" => Some("x86"),
                     "aarch64" => Some("arm64"),
@@ -1520,7 +1520,7 @@ impl<'a> L4Bender<'a> {
 
 pub(crate) fn exported_symbols(tcx: TyCtxt<'_>, crate_type: CrateType) -> Vec<String> {
     if let Some(ref exports) = tcx.sess.target.override_export_symbols {
-        return exports.clone();
+        return exports.iter().map(ToString::to_string).collect();
     }
 
     let mut symbols = Vec::new();

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -218,7 +218,7 @@ impl ModuleConfig {
                 false
             ),
             emit_obj,
-            bc_cmdline: sess.target.bitcode_llvm_cmdline.clone(),
+            bc_cmdline: sess.target.bitcode_llvm_cmdline.to_string(),
 
             verify_llvm_ir: sess.verify_llvm_ir(),
             no_prepopulate_passes: sess.opts.cg.no_prepopulate_passes,
@@ -1061,7 +1061,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
         is_pe_coff: tcx.sess.target.is_like_windows,
         target_can_use_split_dwarf: tcx.sess.target_can_use_split_dwarf(),
         target_pointer_width: tcx.sess.target.pointer_width,
-        target_arch: tcx.sess.target.arch.clone(),
+        target_arch: tcx.sess.target.arch.to_string(),
         debuginfo: tcx.sess.opts.debuginfo,
         split_debuginfo: tcx.sess.split_debuginfo(),
         split_dwarf_kind: tcx.sess.opts.debugging_opts.split_dwarf_kind,

compiler/rustc_metadata/src/locator.rs

@@ -416,10 +416,10 @@ impl<'a> CrateLocator<'a> {
                     (&f[rlib_prefix.len()..(f.len() - rlib_suffix.len())], CrateFlavor::Rlib)
                 } else if f.starts_with(rmeta_prefix) && f.ends_with(rmeta_suffix) {
                     (&f[rmeta_prefix.len()..(f.len() - rmeta_suffix.len())], CrateFlavor::Rmeta)
-                } else if f.starts_with(dylib_prefix) && f.ends_with(dylib_suffix) {
+                } else if f.starts_with(dylib_prefix) && f.ends_with(dylib_suffix.as_ref()) {
                     (&f[dylib_prefix.len()..(f.len() - dylib_suffix.len())], CrateFlavor::Dylib)
                 } else {
-                    if f.starts_with(staticlib_prefix) && f.ends_with(staticlib_suffix) {
+                    if f.starts_with(staticlib_prefix) && f.ends_with(staticlib_suffix.as_ref()) {
                         self.crate_rejections.via_kind.push(CrateMismatch {
                             path: spf.path.clone(),
                             got: "static".to_string(),
@@ -698,8 +698,8 @@ impl<'a> CrateLocator<'a> {
             };
 
             if file.starts_with("lib") && (file.ends_with(".rlib") || file.ends_with(".rmeta"))
-                || file.starts_with(&self.target.dll_prefix)
+                || file.starts_with(self.target.dll_prefix.as_ref())
-                    && file.ends_with(&self.target.dll_suffix)
+                    && file.ends_with(self.target.dll_suffix.as_ref())
             {
                 // Make sure there's at most one rlib and at most one dylib.
                 // Note to take care and match against the non-canonicalized name:
@@ -733,8 +733,8 @@ impl<'a> CrateLocator<'a> {
             crate_name: self.crate_name,
             root,
             triple: self.triple,
-            dll_prefix: self.target.dll_prefix.clone(),
+            dll_prefix: self.target.dll_prefix.to_string(),
-            dll_suffix: self.target.dll_suffix.clone(),
+            dll_suffix: self.target.dll_suffix.to_string(),
             crate_rejections: self.crate_rejections,
         })
     }

compiler/rustc_serialize/src/json.rs

@@ -170,6 +170,7 @@ use self::JsonEvent::*;
 use self::ParserError::*;
 use self::ParserState::*;
 
+use std::borrow::Cow;
 use std::collections::{BTreeMap, HashMap};
 use std::mem::swap;
 use std::num::FpCategory as Fp;
@@ -2196,6 +2197,12 @@ impl ToJson for string::String {
     }
 }
 
+impl<'a> ToJson for Cow<'a, str> {
+    fn to_json(&self) -> Json {
+        Json::String(self.to_string())
+    }
+}
+
 macro_rules! tuple_impl {
     // use variables to indicate the arity of the tuple
     ($($tyvar:ident),* ) => {

compiler/rustc_target/src/spec/aarch64_apple_darwin.rs

@@ -2,13 +2,13 @@ use crate::spec::{FramePointer, LinkerFlavor, SanitizerSet, Target, TargetOption
 
 pub fn target() -> Target {
     let mut base = super::apple_base::opts("macos");
-    base.cpu = "apple-a14".to_string();
+    base.cpu = "apple-a14".into();
     base.max_atomic_width = Some(128);
 
     // FIXME: The leak sanitizer currently fails the tests, see #88132.
     base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::CFI | SanitizerSet::THREAD;
 
-    base.pre_link_args.insert(LinkerFlavor::Gcc, vec!["-arch".to_string(), "arm64".to_string()]);
+    base.pre_link_args.insert(LinkerFlavor::Gcc, vec!["-arch".into(), "arm64".into()]);
     base.link_env_remove.extend(super::apple_base::macos_link_env_remove());
 
     // Clang automatically chooses a more specific target based on
@@ -17,12 +17,12 @@ pub fn target() -> Target {
     let llvm_target = super::apple_base::macos_llvm_target("arm64");
 
     Target {
-        llvm_target,
+        llvm_target: llvm_target.into(),
         pointer_width: 64,
-        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions {
-            mcount: "\u{1}mcount".to_string(),
+            mcount: "\u{1}mcount".into(),
             frame_pointer: FramePointer::NonLeaf,
             ..base
         },

compiler/rustc_target/src/spec/aarch64_apple_ios.rs

@@ -10,12 +10,12 @@ pub fn target() -> Target {
     let llvm_target = super::apple_base::ios_llvm_target(arch);
 
     Target {
-        llvm_target,
+        llvm_target: llvm_target.into(),
         pointer_width: 64,
-        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions {
-            features: "+neon,+fp-armv8,+apple-a7".to_string(),
+            features: "+neon,+fp-armv8,+apple-a7".into(),
             max_atomic_width: Some(128),
             forces_embed_bitcode: true,
             frame_pointer: FramePointer::NonLeaf,
@@ -29,7 +29,7 @@ pub fn target() -> Target {
                 -target-abi\0\
                 darwinpcs\0\
                 -Os\0"
-                .to_string(),
+                .into(),
             ..opts("ios", Arch::Arm64)
         },
     }

compiler/rustc_target/src/spec/aarch64_apple_ios_macabi.rs

@@ -3,12 +3,12 @@ use crate::spec::{FramePointer, Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "arm64-apple-ios14.0-macabi".to_string(),
+        llvm_target: "arm64-apple-ios14.0-macabi".into(),
         pointer_width: 64,
-        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions {
-            features: "+neon,+fp-armv8,+apple-a12".to_string(),
+            features: "+neon,+fp-armv8,+apple-a12".into(),
             max_atomic_width: Some(128),
             forces_embed_bitcode: true,
             frame_pointer: FramePointer::NonLeaf,
@@ -20,7 +20,7 @@ pub fn target() -> Target {
                 -emit-obj\0\
                 -disable-llvm-passes\0\
                 -Os\0"
-                .to_string(),
+                .into(),
             ..opts("ios", Arch::Arm64_macabi)
         },
     }

compiler/rustc_target/src/spec/aarch64_apple_ios_sim.rs

@@ -12,12 +12,12 @@ pub fn target() -> Target {
     let llvm_target = super::apple_base::ios_sim_llvm_target(arch);
 
     Target {
-        llvm_target: llvm_target,
+        llvm_target: llvm_target.into(),
         pointer_width: 64,
-        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions {
-            features: "+neon,+fp-armv8,+apple-a7".to_string(),
+            features: "+neon,+fp-armv8,+apple-a7".into(),
             max_atomic_width: Some(128),
             forces_embed_bitcode: true,
             frame_pointer: FramePointer::NonLeaf,
@@ -31,7 +31,7 @@ pub fn target() -> Target {
                 -target-abi\0\
                 darwinpcs\0\
                 -Os\0"
-                .to_string(),
+                .into(),
             ..base
         },
     }

compiler/rustc_target/src/spec/aarch64_apple_tvos.rs

@@ -3,12 +3,12 @@ use crate::spec::{FramePointer, Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "arm64-apple-tvos".to_string(),
+        llvm_target: "arm64-apple-tvos".into(),
         pointer_width: 64,
-        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions {
-            features: "+neon,+fp-armv8,+apple-a7".to_string(),
+            features: "+neon,+fp-armv8,+apple-a7".into(),
             max_atomic_width: Some(128),
             forces_embed_bitcode: true,
             frame_pointer: FramePointer::NonLeaf,

compiler/rustc_target/src/spec/aarch64_be_unknown_linux_gnu.rs

@@ -3,14 +3,14 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "aarch64_be-unknown-linux-gnu".to_string(),
+        llvm_target: "aarch64_be-unknown-linux-gnu".into(),
         pointer_width: 64,
-        data_layout: "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions {
-            features: "+outline-atomics".to_string(),
+            features: "+outline-atomics".into(),
             max_atomic_width: Some(128),
-            mcount: "\u{1}_mcount".to_string(),
+            mcount: "\u{1}_mcount".into(),
             endian: Endian::Big,
             ..super::linux_gnu_base::opts()
         },

compiler/rustc_target/src/spec/aarch64_be_unknown_linux_gnu_ilp32.rs

@@ -6,14 +6,14 @@ pub fn target() -> Target {
     base.max_atomic_width = Some(128);
 
     Target {
-        llvm_target: "aarch64_be-unknown-linux-gnu_ilp32".to_string(),
+        llvm_target: "aarch64_be-unknown-linux-gnu_ilp32".into(),
         pointer_width: 32,
-        data_layout: "E-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "E-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions {
-            abi: "ilp32".to_string(),
+            abi: "ilp32".into(),
-            features: "+outline-atomics".to_string(),
+            features: "+outline-atomics".into(),
-            mcount: "\u{1}_mcount".to_string(),
+            mcount: "\u{1}_mcount".into(),
             endian: Endian::Big,
             ..base
         },

compiler/rustc_target/src/spec/aarch64_fuchsia.rs

@@ -2,10 +2,10 @@ use crate::spec::{SanitizerSet, Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "aarch64-fuchsia".to_string(),
+        llvm_target: "aarch64-fuchsia".into(),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions {
             max_atomic_width: Some(128),
             supported_sanitizers: SanitizerSet::ADDRESS | SanitizerSet::CFI,

compiler/rustc_target/src/spec/aarch64_kmc_solid_asp3.rs

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

compiler/rustc_target/src/spec/aarch64_linux_android.rs

@@ -5,15 +5,15 @@ use crate::spec::{SanitizerSet, Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "aarch64-linux-android".to_string(),
+        llvm_target: "aarch64-linux-android".into(),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         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: "+neon,+fp-armv8".to_string(),
+            features: "+neon,+fp-armv8".into(),
             supported_sanitizers: SanitizerSet::CFI
                 | SanitizerSet::HWADDRESS
                 | SanitizerSet::MEMTAG

compiler/rustc_target/src/spec/aarch64_pc_windows_msvc.rs

@@ -3,13 +3,13 @@ use crate::spec::Target;
 pub fn target() -> Target {
     let mut base = super::windows_msvc_base::opts();
     base.max_atomic_width = Some(64);
-    base.features = "+neon,+fp-armv8".to_string();
+    base.features = "+neon,+fp-armv8".into();
 
     Target {
-        llvm_target: "aarch64-pc-windows-msvc".to_string(),
+        llvm_target: "aarch64-pc-windows-msvc".into(),
         pointer_width: 64,
-        data_layout: "e-m:w-p:64:64-i32:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:w-p:64:64-i32:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/aarch64_unknown_freebsd.rs

@@ -2,10 +2,10 @@ use crate::spec::{SanitizerSet, Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "aarch64-unknown-freebsd".to_string(),
+        llvm_target: "aarch64-unknown-freebsd".into(),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions {
             max_atomic_width: Some(128),
             supported_sanitizers: SanitizerSet::ADDRESS

compiler/rustc_target/src/spec/aarch64_unknown_hermit.rs

@@ -3,13 +3,13 @@ use crate::spec::Target;
 pub fn target() -> Target {
     let mut base = super::hermit_base::opts();
     base.max_atomic_width = Some(128);
-    base.features = "+strict-align,+neon,+fp-armv8".to_string();
+    base.features = "+strict-align,+neon,+fp-armv8".into();
 
     Target {
-        llvm_target: "aarch64-unknown-hermit".to_string(),
+        llvm_target: "aarch64-unknown-hermit".into(),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/aarch64_unknown_linux_gnu.rs

@@ -2,13 +2,13 @@ use crate::spec::{SanitizerSet, Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "aarch64-unknown-linux-gnu".to_string(),
+        llvm_target: "aarch64-unknown-linux-gnu".into(),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions {
-            features: "+outline-atomics".to_string(),
+            features: "+outline-atomics".into(),
-            mcount: "\u{1}_mcount".to_string(),
+            mcount: "\u{1}_mcount".into(),
             max_atomic_width: Some(128),
             supported_sanitizers: SanitizerSet::ADDRESS
                 | SanitizerSet::CFI

compiler/rustc_target/src/spec/aarch64_unknown_linux_gnu_ilp32.rs

@@ -2,15 +2,15 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "aarch64-unknown-linux-gnu_ilp32".to_string(),
+        llvm_target: "aarch64-unknown-linux-gnu_ilp32".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions {
-            abi: "ilp32".to_string(),
+            abi: "ilp32".into(),
-            features: "+outline-atomics".to_string(),
+            features: "+outline-atomics".into(),
             max_atomic_width: Some(128),
-            mcount: "\u{1}_mcount".to_string(),
+            mcount: "\u{1}_mcount".into(),
             ..super::linux_gnu_base::opts()
         },
     }

compiler/rustc_target/src/spec/aarch64_unknown_linux_musl.rs

@@ -5,10 +5,10 @@ pub fn target() -> Target {
     base.max_atomic_width = Some(128);
 
     Target {
-        llvm_target: "aarch64-unknown-linux-musl".to_string(),
+        llvm_target: "aarch64-unknown-linux-musl".into(),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
-        options: TargetOptions { mcount: "\u{1}_mcount".to_string(), ..base },
+        options: TargetOptions { mcount: "\u{1}_mcount".into(), ..base },
     }
 }

compiler/rustc_target/src/spec/aarch64_unknown_netbsd.rs

@@ -2,12 +2,12 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "aarch64-unknown-netbsd".to_string(),
+        llvm_target: "aarch64-unknown-netbsd".into(),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions {
-            mcount: "__mcount".to_string(),
+            mcount: "__mcount".into(),
             max_atomic_width: Some(128),
             ..super::netbsd_base::opts()
         },

compiler/rustc_target/src/spec/aarch64_unknown_none.rs

@@ -11,8 +11,8 @@ use super::{LinkerFlavor, LldFlavor, PanicStrategy, RelocModel, Target, TargetOp
 pub fn target() -> Target {
     let opts = TargetOptions {
         linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
-        linker: Some("rust-lld".to_owned()),
+        linker: Some("rust-lld".into()),
-        features: "+strict-align,+neon,+fp-armv8".to_string(),
+        features: "+strict-align,+neon,+fp-armv8".into(),
         executables: true,
         relocation_model: RelocModel::Static,
         disable_redzone: true,
@@ -21,10 +21,10 @@ pub fn target() -> Target {
         ..Default::default()
     };
     Target {
-        llvm_target: "aarch64-unknown-none".to_string(),
+        llvm_target: "aarch64-unknown-none".into(),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: opts,
     }
 }

compiler/rustc_target/src/spec/aarch64_unknown_none_softfloat.rs

@@ -10,10 +10,10 @@ use super::{LinkerFlavor, LldFlavor, PanicStrategy, RelocModel, Target, TargetOp
 
 pub fn target() -> Target {
     let opts = TargetOptions {
-        abi: "softfloat".to_string(),
+        abi: "softfloat".into(),
         linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
-        linker: Some("rust-lld".to_owned()),
+        linker: Some("rust-lld".into()),
-        features: "+strict-align,-neon,-fp-armv8".to_string(),
+        features: "+strict-align,-neon,-fp-armv8".into(),
         executables: true,
         relocation_model: RelocModel::Static,
         disable_redzone: true,
@@ -22,10 +22,10 @@ pub fn target() -> Target {
         ..Default::default()
     };
     Target {
-        llvm_target: "aarch64-unknown-none".to_string(),
+        llvm_target: "aarch64-unknown-none".into(),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: opts,
     }
 }

compiler/rustc_target/src/spec/aarch64_unknown_openbsd.rs

@@ -2,10 +2,10 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "aarch64-unknown-openbsd".to_string(),
+        llvm_target: "aarch64-unknown-openbsd".into(),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions { max_atomic_width: Some(128), ..super::openbsd_base::opts() },
     }
 }

compiler/rustc_target/src/spec/aarch64_unknown_redox.rs

@@ -5,10 +5,10 @@ pub fn target() -> Target {
     base.max_atomic_width = Some(128);
 
     Target {
-        llvm_target: "aarch64-unknown-redox".to_string(),
+        llvm_target: "aarch64-unknown-redox".into(),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/aarch64_unknown_uefi.rs

@@ -9,7 +9,7 @@ pub fn target() -> Target {
 
     base.max_atomic_width = Some(64);
 
-    let pre_link_args_msvc = vec!["/machine:arm64".to_string()];
+    let pre_link_args_msvc = vec!["/machine:arm64".into()];
 
     base.pre_link_args.get_mut(&LinkerFlavor::Msvc).unwrap().extend(pre_link_args_msvc.clone());
     base.pre_link_args
@@ -18,10 +18,10 @@ pub fn target() -> Target {
         .extend(pre_link_args_msvc);
 
     Target {
-        llvm_target: "aarch64-unknown-windows".to_string(),
+        llvm_target: "aarch64-unknown-windows".into(),
         pointer_width: 64,
-        data_layout: "e-m:w-p:64:64-i32:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:w-p:64:64-i32:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/aarch64_uwp_windows_msvc.rs

@@ -5,10 +5,10 @@ pub fn target() -> Target {
     base.max_atomic_width = Some(64);
 
     Target {
-        llvm_target: "aarch64-pc-windows-msvc".to_string(),
+        llvm_target: "aarch64-pc-windows-msvc".into(),
         pointer_width: 64,
-        data_layout: "e-m:w-p:64:64-i32:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:w-p:64:64-i32:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/aarch64_wrs_vxworks.rs

@@ -2,10 +2,10 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "aarch64-unknown-linux-gnu".to_string(),
+        llvm_target: "aarch64-unknown-linux-gnu".into(),
         pointer_width: 64,
-        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(),
-        arch: "aarch64".to_string(),
+        arch: "aarch64".into(),
         options: TargetOptions { max_atomic_width: Some(128), ..super::vxworks_base::opts() },
     }
 }

compiler/rustc_target/src/spec/android_base.rs

@@ -2,7 +2,7 @@ use crate::spec::TargetOptions;
 
 pub fn opts() -> TargetOptions {
     let mut base = super::linux_base::opts();
-    base.os = "android".to_string();
+    base.os = "android".into();
     base.dwarf_version = Some(2);
     base.position_independent_executables = true;
     base.has_thread_local = false;

compiler/rustc_target/src/spec/apple_base.rs

@@ -1,8 +1,8 @@
-use std::env;
+use std::{borrow::Cow, env};
 
 use crate::spec::{FramePointer, LldFlavor, SplitDebuginfo, TargetOptions};
 
-pub fn opts(os: &str) -> TargetOptions {
+pub fn opts(os: &'static str) -> TargetOptions {
     // ELF TLS is only available in macOS 10.7+. If you try to compile for 10.6
     // either the linker will complain if it is used or the binary will end up
     // segfaulting at runtime when run on 10.6. Rust by default supports macOS
@@ -19,20 +19,20 @@ pub fn opts(os: &str) -> TargetOptions {
     let has_thread_local = macos_deployment_target("x86_64") >= (10, 7);
 
     TargetOptions {
-        os: os.to_string(),
+        os: os.into(),
-        vendor: "apple".to_string(),
+        vendor: "apple".into(),
         // macOS has -dead_strip, which doesn't rely on function_sections
         function_sections: false,
         dynamic_linking: true,
         linker_is_gnu: false,
         executables: true,
-        families: vec!["unix".to_string()],
+        families: vec!["unix".into()],
         is_like_osx: true,
         dwarf_version: Some(2),
         frame_pointer: FramePointer::Always,
         has_rpath: true,
-        dll_suffix: ".dylib".to_string(),
+        dll_suffix: ".dylib".into(),
-        archive_format: "darwin".to_string(),
+        archive_format: "darwin".into(),
         has_thread_local,
         abi_return_struct_as_int: true,
         emit_debug_gdb_scripts: false,
@@ -51,7 +51,7 @@ pub fn opts(os: &str) -> TargetOptions {
         // this environment variable too in recent versions.
         //
         // For some more info see the commentary on #47086
-        link_env: vec![("ZERO_AR_DATE".to_string(), "1".to_string())],
+        link_env: vec![("ZERO_AR_DATE".into(), "1".into())],
 
         ..Default::default()
     }
@@ -79,19 +79,19 @@ pub fn macos_llvm_target(arch: &str) -> String {
     format!("{}-apple-macosx{}.{}.0", arch, major, minor)
 }
 
-pub fn macos_link_env_remove() -> Vec<String> {
+pub fn macos_link_env_remove() -> Vec<Cow<'static, str>> {
     let mut env_remove = Vec::with_capacity(2);
     // Remove the `SDKROOT` environment variable if it's clearly set for the wrong platform, which
     // may occur when we're linking a custom build script while targeting iOS for example.
     if let Ok(sdkroot) = env::var("SDKROOT") {
         if sdkroot.contains("iPhoneOS.platform") || sdkroot.contains("iPhoneSimulator.platform") {
-            env_remove.push("SDKROOT".to_string())
+            env_remove.push("SDKROOT".into())
         }
     }
     // Additionally, `IPHONEOS_DEPLOYMENT_TARGET` must not be set when using the Xcode linker at
     // "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/ld",
     // although this is apparently ignored when using the linker at "/usr/bin/ld".
-    env_remove.push("IPHONEOS_DEPLOYMENT_TARGET".to_string());
+    env_remove.push("IPHONEOS_DEPLOYMENT_TARGET".into());
     env_remove
 }
 

compiler/rustc_target/src/spec/apple_sdk_base.rs

@@ -1,4 +1,5 @@
 use crate::spec::TargetOptions;
+use std::borrow::Cow;
 
 use Arch::*;
 #[allow(non_camel_case_types)]
@@ -14,16 +15,15 @@ pub enum Arch {
     Arm64_sim,
 }
 
-fn target_abi(arch: Arch) -> String {
+fn target_abi(arch: Arch) -> &'static str {
     match arch {
         Armv7 | Armv7s | Arm64 | I386 | X86_64 => "",
         X86_64_macabi | Arm64_macabi => "macabi",
         Arm64_sim => "sim",
     }
-    .to_string()
 }
 
-fn target_cpu(arch: Arch) -> String {
+fn target_cpu(arch: Arch) -> &'static str {
     match arch {
         Armv7 => "cortex-a8", // iOS7 is supported on iPhone 4 and higher
         Armv7s => "cortex-a9",
@@ -34,22 +34,21 @@ fn target_cpu(arch: Arch) -> String {
         Arm64_macabi => "apple-a12",
         Arm64_sim => "apple-a12",
     }
-    .to_string()
 }
 
-fn link_env_remove(arch: Arch) -> Vec<String> {
+fn link_env_remove(arch: Arch) -> Vec<Cow<'static, str>> {
     match arch {
         Armv7 | Armv7s | Arm64 | I386 | X86_64 | Arm64_sim => {
-            vec!["MACOSX_DEPLOYMENT_TARGET".to_string()]
+            vec!["MACOSX_DEPLOYMENT_TARGET".into()]
         }
-        X86_64_macabi | Arm64_macabi => vec!["IPHONEOS_DEPLOYMENT_TARGET".to_string()],
+        X86_64_macabi | Arm64_macabi => vec!["IPHONEOS_DEPLOYMENT_TARGET".into()],
     }
 }
 
-pub fn opts(os: &str, arch: Arch) -> TargetOptions {
+pub fn opts(os: &'static str, arch: Arch) -> TargetOptions {
     TargetOptions {
-        abi: target_abi(arch),
+        abi: target_abi(arch).into(),
-        cpu: target_cpu(arch),
+        cpu: target_cpu(arch).into(),
         dynamic_linking: false,
         executables: true,
         link_env_remove: link_env_remove(arch),

compiler/rustc_target/src/spec/arm_linux_androideabi.rs

@@ -2,14 +2,14 @@ use crate::spec::{SanitizerSet, Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "arm-linux-androideabi".to_string(),
+        llvm_target: "arm-linux-androideabi".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabi".to_string(),
+            abi: "eabi".into(),
             // https://developer.android.com/ndk/guides/abis.html#armeabi
-            features: "+strict-align,+v5te".to_string(),
+            features: "+strict-align,+v5te".into(),
             supported_sanitizers: SanitizerSet::ADDRESS,
             max_atomic_width: Some(32),
             ..super::android_base::opts()

compiler/rustc_target/src/spec/arm_unknown_linux_gnueabi.rs

@@ -2,15 +2,15 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "arm-unknown-linux-gnueabi".to_string(),
+        llvm_target: "arm-unknown-linux-gnueabi".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabi".to_string(),
+            abi: "eabi".into(),
-            features: "+strict-align,+v6".to_string(),
+            features: "+strict-align,+v6".into(),
             max_atomic_width: Some(64),
-            mcount: "\u{1}__gnu_mcount_nc".to_string(),
+            mcount: "\u{1}__gnu_mcount_nc".into(),
             ..super::linux_gnu_base::opts()
         },
     }

compiler/rustc_target/src/spec/arm_unknown_linux_gnueabihf.rs

@@ -2,15 +2,15 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "arm-unknown-linux-gnueabihf".to_string(),
+        llvm_target: "arm-unknown-linux-gnueabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabihf".to_string(),
+            abi: "eabihf".into(),
-            features: "+strict-align,+v6,+vfp2,-d32".to_string(),
+            features: "+strict-align,+v6,+vfp2,-d32".into(),
             max_atomic_width: Some(64),
-            mcount: "\u{1}__gnu_mcount_nc".to_string(),
+            mcount: "\u{1}__gnu_mcount_nc".into(),
             ..super::linux_gnu_base::opts()
         },
     }

compiler/rustc_target/src/spec/arm_unknown_linux_musleabi.rs

@@ -5,17 +5,17 @@ pub fn target() -> Target {
         // It's important we use "gnueabi" and not "musleabi" here. LLVM uses it
         // to determine the calling convention and float ABI, and it doesn't
         // support the "musleabi" value.
-        llvm_target: "arm-unknown-linux-gnueabi".to_string(),
+        llvm_target: "arm-unknown-linux-gnueabi".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabi".to_string(),
+            abi: "eabi".into(),
             // Most of these settings are copied from the arm_unknown_linux_gnueabi
             // target.
-            features: "+strict-align,+v6".to_string(),
+            features: "+strict-align,+v6".into(),
             max_atomic_width: Some(64),
-            mcount: "\u{1}mcount".to_string(),
+            mcount: "\u{1}mcount".into(),
             ..super::linux_musl_base::opts()
         },
     }

compiler/rustc_target/src/spec/arm_unknown_linux_musleabihf.rs

@@ -5,17 +5,17 @@ pub fn target() -> Target {
         // It's important we use "gnueabihf" and not "musleabihf" here. LLVM
         // uses it to determine the calling convention and float ABI, and it
         // doesn't support the "musleabihf" value.
-        llvm_target: "arm-unknown-linux-gnueabihf".to_string(),
+        llvm_target: "arm-unknown-linux-gnueabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabihf".to_string(),
+            abi: "eabihf".into(),
             // Most of these settings are copied from the arm_unknown_linux_gnueabihf
             // target.
-            features: "+strict-align,+v6,+vfp2,-d32".to_string(),
+            features: "+strict-align,+v6,+vfp2,-d32".into(),
             max_atomic_width: Some(64),
-            mcount: "\u{1}mcount".to_string(),
+            mcount: "\u{1}mcount".into(),
             ..super::linux_musl_base::opts()
         },
     }

compiler/rustc_target/src/spec/armebv7r_none_eabi.rs

@@ -6,16 +6,16 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armebv7r-unknown-none-eabi".to_string(),
+        llvm_target: "armebv7r-unknown-none-eabi".into(),
         pointer_width: 32,
-        data_layout: "E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabi".to_string(),
+            abi: "eabi".into(),
             endian: Endian::Big,
             linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
             executables: true,
-            linker: Some("rust-lld".to_owned()),
+            linker: Some("rust-lld".into()),
             relocation_model: RelocModel::Static,
             panic_strategy: PanicStrategy::Abort,
             max_atomic_width: Some(32),

compiler/rustc_target/src/spec/armebv7r_none_eabihf.rs

@@ -6,19 +6,19 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armebv7r-unknown-none-eabihf".to_string(),
+        llvm_target: "armebv7r-unknown-none-eabihf".into(),
         pointer_width: 32,
-        data_layout: "E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabihf".to_string(),
+            abi: "eabihf".into(),
             endian: Endian::Big,
             linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
             executables: true,
-            linker: Some("rust-lld".to_owned()),
+            linker: Some("rust-lld".into()),
             relocation_model: RelocModel::Static,
             panic_strategy: PanicStrategy::Abort,
-            features: "+vfp3,-d32,-fp16".to_string(),
+            features: "+vfp3,-d32,-fp16".into(),
             max_atomic_width: Some(32),
             emit_debug_gdb_scripts: false,
             // GCC and Clang default to 8 for arm-none here

compiler/rustc_target/src/spec/armv4t_unknown_linux_gnueabi.rs

@@ -2,16 +2,16 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armv4t-unknown-linux-gnueabi".to_string(),
+        llvm_target: "armv4t-unknown-linux-gnueabi".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabi".to_string(),
+            abi: "eabi".into(),
-            features: "+soft-float,+strict-align".to_string(),
+            features: "+soft-float,+strict-align".into(),
             // Atomic operations provided by compiler-builtins
             max_atomic_width: Some(32),
-            mcount: "\u{1}__gnu_mcount_nc".to_string(),
+            mcount: "\u{1}__gnu_mcount_nc".into(),
             has_thumb_interworking: true,
             ..super::linux_gnu_base::opts()
         },

compiler/rustc_target/src/spec/armv5te_unknown_linux_gnueabi.rs

@@ -2,16 +2,16 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armv5te-unknown-linux-gnueabi".to_string(),
+        llvm_target: "armv5te-unknown-linux-gnueabi".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabi".to_string(),
+            abi: "eabi".into(),
-            features: "+soft-float,+strict-align".to_string(),
+            features: "+soft-float,+strict-align".into(),
             // Atomic operations provided by compiler-builtins
             max_atomic_width: Some(32),
-            mcount: "\u{1}__gnu_mcount_nc".to_string(),
+            mcount: "\u{1}__gnu_mcount_nc".into(),
             has_thumb_interworking: true,
             ..super::linux_gnu_base::opts()
         },

compiler/rustc_target/src/spec/armv5te_unknown_linux_musleabi.rs

@@ -6,16 +6,16 @@ pub fn target() -> Target {
         // It's important we use "gnueabihf" and not "musleabihf" here. LLVM
         // uses it to determine the calling convention and float ABI, and LLVM
         // doesn't support the "musleabihf" value.
-        llvm_target: "armv5te-unknown-linux-gnueabi".to_string(),
+        llvm_target: "armv5te-unknown-linux-gnueabi".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabi".to_string(),
+            abi: "eabi".into(),
-            features: "+soft-float,+strict-align".to_string(),
+            features: "+soft-float,+strict-align".into(),
             // Atomic operations provided by compiler-builtins
             max_atomic_width: Some(32),
-            mcount: "\u{1}mcount".to_string(),
+            mcount: "\u{1}mcount".into(),
             has_thumb_interworking: true,
             ..super::linux_musl_base::opts()
         },

compiler/rustc_target/src/spec/armv5te_unknown_linux_uclibceabi.rs

@@ -2,16 +2,16 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armv5te-unknown-linux-uclibcgnueabi".to_string(),
+        llvm_target: "armv5te-unknown-linux-uclibcgnueabi".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabi".to_string(),
+            abi: "eabi".into(),
-            features: "+soft-float,+strict-align".to_string(),
+            features: "+soft-float,+strict-align".into(),
             // Atomic operations provided by compiler-builtins
             max_atomic_width: Some(32),
-            mcount: "\u{1}__gnu_mcount_nc".to_string(),
+            mcount: "\u{1}__gnu_mcount_nc".into(),
             has_thumb_interworking: true,
             ..super::linux_uclibc_base::opts()
         },

compiler/rustc_target/src/spec/armv6_unknown_freebsd.rs

@@ -2,17 +2,17 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armv6-unknown-freebsd-gnueabihf".to_string(),
+        llvm_target: "armv6-unknown-freebsd-gnueabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabihf".to_string(),
+            abi: "eabihf".into(),
             // FIXME: change env to "gnu" when cfg_target_abi becomes stable
-            env: "gnueabihf".to_string(),
+            env: "gnueabihf".into(),
-            features: "+v6,+vfp2,-d32".to_string(),
+            features: "+v6,+vfp2,-d32".into(),
             max_atomic_width: Some(64),
-            mcount: "\u{1}__gnu_mcount_nc".to_string(),
+            mcount: "\u{1}__gnu_mcount_nc".into(),
             ..super::freebsd_base::opts()
         },
     }

compiler/rustc_target/src/spec/armv6_unknown_netbsd_eabihf.rs

@@ -2,17 +2,17 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armv6-unknown-netbsdelf-eabihf".to_string(),
+        llvm_target: "armv6-unknown-netbsdelf-eabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabihf".to_string(),
+            abi: "eabihf".into(),
             // FIXME: remove env when cfg_target_abi becomes stable
-            env: "eabihf".to_string(),
+            env: "eabihf".into(),
-            features: "+v6,+vfp2,-d32".to_string(),
+            features: "+v6,+vfp2,-d32".into(),
             max_atomic_width: Some(64),
-            mcount: "__mcount".to_string(),
+            mcount: "__mcount".into(),
             ..super::netbsd_base::opts()
         },
     }

compiler/rustc_target/src/spec/armv6k_nintendo_3ds.rs

@@ -9,33 +9,33 @@ pub fn target() -> Target {
     pre_link_args.insert(
         LinkerFlavor::Gcc,
         vec![
-            "-specs=3dsx.specs".to_string(),
+            "-specs=3dsx.specs".into(),
-            "-mtune=mpcore".to_string(),
+            "-mtune=mpcore".into(),
-            "-mfloat-abi=hard".to_string(),
+            "-mfloat-abi=hard".into(),
-            "-mtp=soft".to_string(),
+            "-mtp=soft".into(),
         ],
     );
 
     Target {
-        llvm_target: "armv6k-none-eabihf".to_string(),
+        llvm_target: "armv6k-none-eabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
 
         options: TargetOptions {
-            os: "horizon".to_string(),
+            os: "horizon".into(),
-            env: "newlib".to_string(),
+            env: "newlib".into(),
-            vendor: "nintendo".to_string(),
+            vendor: "nintendo".into(),
-            abi: "eabihf".to_string(),
+            abi: "eabihf".into(),
             linker_flavor: LinkerFlavor::Gcc,
-            cpu: "mpcore".to_string(),
+            cpu: "mpcore".into(),
             executables: true,
-            families: vec!["unix".to_string()],
+            families: vec!["unix".into()],
-            linker: Some("arm-none-eabi-gcc".to_string()),
+            linker: Some("arm-none-eabi-gcc".into()),
             relocation_model: RelocModel::Static,
-            features: "+vfp2".to_string(),
+            features: "+vfp2".into(),
             pre_link_args,
-            exe_suffix: ".elf".to_string(),
+            exe_suffix: ".elf".into(),
             no_default_libraries: false,
             has_thread_local: true,
             ..Default::default()

compiler/rustc_target/src/spec/armv7_apple_ios.rs

@@ -2,13 +2,15 @@ use super::apple_sdk_base::{opts, Arch};
 use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
+    let llvm_target = super::apple_base::ios_llvm_target("armv7");
+
     Target {
-        llvm_target: super::apple_base::ios_llvm_target("armv7"),
+        llvm_target: llvm_target.into(),
         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".to_string(),
+        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: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            features: "+v7,+vfp3,+neon".to_string(),
+            features: "+v7,+vfp3,+neon".into(),
             max_atomic_width: Some(64),
             ..opts("ios", Arch::Armv7)
         },

compiler/rustc_target/src/spec/armv7_linux_androideabi.rs

@@ -10,15 +10,15 @@ use crate::spec::{LinkerFlavor, SanitizerSet, Target, TargetOptions};
 
 pub fn target() -> Target {
     let mut base = super::android_base::opts();
-    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-march=armv7-a".to_string());
+    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-march=armv7-a".into());
     Target {
-        llvm_target: "armv7-none-linux-android".to_string(),
+        llvm_target: "armv7-none-linux-android".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabi".to_string(),
+            abi: "eabi".into(),
-            features: "+v7,+thumb-mode,+thumb2,+vfp3,-d32,-neon".to_string(),
+            features: "+v7,+thumb-mode,+thumb2,+vfp3,-d32,-neon".into(),
             supported_sanitizers: SanitizerSet::ADDRESS,
             max_atomic_width: Some(64),
             ..base

compiler/rustc_target/src/spec/armv7_unknown_freebsd.rs

@@ -2,17 +2,17 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armv7-unknown-freebsd-gnueabihf".to_string(),
+        llvm_target: "armv7-unknown-freebsd-gnueabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabihf".to_string(),
+            abi: "eabihf".into(),
             // FIXME: change env to "gnu" when cfg_target_abi becomes stable
-            env: "gnueabihf".to_string(),
+            env: "gnueabihf".into(),
-            features: "+v7,+vfp3,-d32,+thumb2,-neon".to_string(),
+            features: "+v7,+vfp3,-d32,+thumb2,-neon".into(),
             max_atomic_width: Some(64),
-            mcount: "\u{1}__gnu_mcount_nc".to_string(),
+            mcount: "\u{1}__gnu_mcount_nc".into(),
             ..super::freebsd_base::opts()
         },
     }

compiler/rustc_target/src/spec/armv7_unknown_linux_gnueabi.rs

@@ -5,15 +5,15 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armv7-unknown-linux-gnueabi".to_string(),
+        llvm_target: "armv7-unknown-linux-gnueabi".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabi".to_string(),
+            abi: "eabi".into(),
-            features: "+v7,+thumb2,+soft-float,-neon".to_string(),
+            features: "+v7,+thumb2,+soft-float,-neon".into(),
             max_atomic_width: Some(64),
-            mcount: "\u{1}__gnu_mcount_nc".to_string(),
+            mcount: "\u{1}__gnu_mcount_nc".into(),
             ..super::linux_gnu_base::opts()
         },
     }

compiler/rustc_target/src/spec/armv7_unknown_linux_gnueabihf.rs

@@ -5,16 +5,16 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armv7-unknown-linux-gnueabihf".to_string(),
+        llvm_target: "armv7-unknown-linux-gnueabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabihf".to_string(),
+            abi: "eabihf".into(),
             // Info about features at https://wiki.debian.org/ArmHardFloatPort
-            features: "+v7,+vfp3,-d32,+thumb2,-neon".to_string(),
+            features: "+v7,+vfp3,-d32,+thumb2,-neon".into(),
             max_atomic_width: Some(64),
-            mcount: "\u{1}__gnu_mcount_nc".to_string(),
+            mcount: "\u{1}__gnu_mcount_nc".into(),
             ..super::linux_gnu_base::opts()
         },
     }

compiler/rustc_target/src/spec/armv7_unknown_linux_musleabi.rs

@@ -10,16 +10,16 @@ pub fn target() -> Target {
         // It's important we use "gnueabi" and not "musleabi" here. LLVM uses it
         // to determine the calling convention and float ABI, and it doesn't
         // support the "musleabi" value.
-        llvm_target: "armv7-unknown-linux-gnueabi".to_string(),
+        llvm_target: "armv7-unknown-linux-gnueabi".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
 
         options: TargetOptions {
-            abi: "eabi".to_string(),
+            abi: "eabi".into(),
-            features: "+v7,+thumb2,+soft-float,-neon".to_string(),
+            features: "+v7,+thumb2,+soft-float,-neon".into(),
             max_atomic_width: Some(64),
-            mcount: "\u{1}mcount".to_string(),
+            mcount: "\u{1}mcount".into(),
             ..super::linux_musl_base::opts()
         },
     }

compiler/rustc_target/src/spec/armv7_unknown_linux_musleabihf.rs

@@ -7,18 +7,18 @@ pub fn target() -> Target {
         // It's important we use "gnueabihf" and not "musleabihf" here. LLVM
         // uses it to determine the calling convention and float ABI, and LLVM
         // doesn't support the "musleabihf" value.
-        llvm_target: "armv7-unknown-linux-gnueabihf".to_string(),
+        llvm_target: "armv7-unknown-linux-gnueabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
 
         // Most of these settings are copied from the armv7_unknown_linux_gnueabihf
         // target.
         options: TargetOptions {
-            abi: "eabihf".to_string(),
+            abi: "eabihf".into(),
-            features: "+v7,+vfp3,-d32,+thumb2,-neon".to_string(),
+            features: "+v7,+vfp3,-d32,+thumb2,-neon".into(),
             max_atomic_width: Some(64),
-            mcount: "\u{1}mcount".to_string(),
+            mcount: "\u{1}mcount".into(),
             ..super::linux_musl_base::opts()
         },
     }

compiler/rustc_target/src/spec/armv7_unknown_linux_uclibceabi.rs

@@ -6,17 +6,17 @@ use crate::spec::{Target, TargetOptions};
 pub fn target() -> Target {
     let base = super::linux_uclibc_base::opts();
     Target {
-        llvm_target: "armv7-unknown-linux-gnueabi".to_string(),
+        llvm_target: "armv7-unknown-linux-gnueabi".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
 
         options: TargetOptions {
-            features: "+v7,+thumb2,+soft-float,-neon".to_string(),
+            features: "+v7,+thumb2,+soft-float,-neon".into(),
-            cpu: "generic".to_string(),
+            cpu: "generic".into(),
             max_atomic_width: Some(64),
-            mcount: "_mcount".to_string(),
+            mcount: "_mcount".into(),
-            abi: "eabi".to_string(),
+            abi: "eabi".into(),
             ..base
         },
     }

compiler/rustc_target/src/spec/armv7_unknown_linux_uclibceabihf.rs

@@ -6,18 +6,18 @@ use crate::spec::{Target, TargetOptions};
 pub fn target() -> Target {
     let base = super::linux_uclibc_base::opts();
     Target {
-        llvm_target: "armv7-unknown-linux-gnueabihf".to_string(),
+        llvm_target: "armv7-unknown-linux-gnueabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
 
         options: TargetOptions {
             // Info about features at https://wiki.debian.org/ArmHardFloatPort
-            features: "+v7,+vfp3,-d32,+thumb2,-neon".to_string(),
+            features: "+v7,+vfp3,-d32,+thumb2,-neon".into(),
-            cpu: "generic".to_string(),
+            cpu: "generic".into(),
             max_atomic_width: Some(64),
-            mcount: "_mcount".to_string(),
+            mcount: "_mcount".into(),
-            abi: "eabihf".to_string(),
+            abi: "eabihf".into(),
             ..base
         },
     }

compiler/rustc_target/src/spec/armv7_unknown_netbsd_eabihf.rs

@@ -2,17 +2,17 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armv7-unknown-netbsdelf-eabihf".to_string(),
+        llvm_target: "armv7-unknown-netbsdelf-eabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabihf".to_string(),
+            abi: "eabihf".into(),
             // FIXME: remove env when cfg_target_abi becomes stable
-            env: "eabihf".to_string(),
+            env: "eabihf".into(),
-            features: "+v7,+vfp3,-d32,+thumb2,-neon".to_string(),
+            features: "+v7,+vfp3,-d32,+thumb2,-neon".into(),
             max_atomic_width: Some(64),
-            mcount: "__mcount".to_string(),
+            mcount: "__mcount".into(),
             ..super::netbsd_base::opts()
         },
     }

compiler/rustc_target/src/spec/armv7_wrs_vxworks_eabihf.rs

@@ -2,14 +2,14 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armv7-unknown-linux-gnueabihf".to_string(),
+        llvm_target: "armv7-unknown-linux-gnueabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            abi: "eabihf".to_string(),
+            abi: "eabihf".into(),
             // Info about features at https://wiki.debian.org/ArmHardFloatPort
-            features: "+v7,+vfp3,-d32,+thumb2,-neon".to_string(),
+            features: "+v7,+vfp3,-d32,+thumb2,-neon".into(),
             max_atomic_width: Some(64),
             ..super::vxworks_base::opts()
         },

compiler/rustc_target/src/spec/armv7a_kmc_solid_asp3_eabi.rs

@@ -3,13 +3,13 @@ use super::{RelocModel, Target, TargetOptions};
 pub fn target() -> Target {
     let base = super::solid_base::opts("asp3");
     Target {
-        llvm_target: "armv7a-none-eabi".to_string(),
+        llvm_target: "armv7a-none-eabi".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            linker: Some("arm-kmc-eabi-gcc".to_owned()),
+            linker: Some("arm-kmc-eabi-gcc".into()),
-            features: "+v7,+soft-float,+thumb2,-neon".to_string(),
+            features: "+v7,+soft-float,+thumb2,-neon".into(),
             relocation_model: RelocModel::Static,
             disable_redzone: true,
             max_atomic_width: Some(64),

compiler/rustc_target/src/spec/armv7a_kmc_solid_asp3_eabihf.rs

@@ -3,13 +3,13 @@ use super::{RelocModel, Target, TargetOptions};
 pub fn target() -> Target {
     let base = super::solid_base::opts("asp3");
     Target {
-        llvm_target: "armv7a-none-eabihf".to_string(),
+        llvm_target: "armv7a-none-eabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            linker: Some("arm-kmc-eabi-gcc".to_owned()),
+            linker: Some("arm-kmc-eabi-gcc".into()),
-            features: "+v7,+vfp3,-d32,+thumb2,-neon".to_string(),
+            features: "+v7,+vfp3,-d32,+thumb2,-neon".into(),
             relocation_model: RelocModel::Static,
             disable_redzone: true,
             max_atomic_width: Some(64),

compiler/rustc_target/src/spec/armv7a_none_eabi.rs

@@ -18,10 +18,10 @@ use super::{LinkerFlavor, LldFlavor, PanicStrategy, RelocModel, Target, TargetOp
 
 pub fn target() -> Target {
     let opts = TargetOptions {
-        abi: "eabi".to_string(),
+        abi: "eabi".into(),
         linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
-        linker: Some("rust-lld".to_owned()),
+        linker: Some("rust-lld".into()),
-        features: "+v7,+thumb2,+soft-float,-neon,+strict-align".to_string(),
+        features: "+v7,+thumb2,+soft-float,-neon,+strict-align".into(),
         executables: true,
         relocation_model: RelocModel::Static,
         disable_redzone: true,
@@ -32,10 +32,10 @@ pub fn target() -> Target {
         ..Default::default()
     };
     Target {
-        llvm_target: "armv7a-none-eabi".to_string(),
+        llvm_target: "armv7a-none-eabi".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: opts,
     }
 }

compiler/rustc_target/src/spec/armv7a_none_eabihf.rs

@@ -9,10 +9,10 @@ use super::{LinkerFlavor, LldFlavor, PanicStrategy, RelocModel, Target, TargetOp
 
 pub fn target() -> Target {
     let opts = TargetOptions {
-        abi: "eabihf".to_string(),
+        abi: "eabihf".into(),
         linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
-        linker: Some("rust-lld".to_owned()),
+        linker: Some("rust-lld".into()),
-        features: "+v7,+vfp3,-d32,+thumb2,-neon,+strict-align".to_string(),
+        features: "+v7,+vfp3,-d32,+thumb2,-neon,+strict-align".into(),
         executables: true,
         relocation_model: RelocModel::Static,
         disable_redzone: true,
@@ -24,10 +24,10 @@ pub fn target() -> Target {
         ..Default::default()
     };
     Target {
-        llvm_target: "armv7a-none-eabihf".to_string(),
+        llvm_target: "armv7a-none-eabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
         options: opts,
     }
 }

compiler/rustc_target/src/spec/armv7r_none_eabi.rs

@@ -5,16 +5,16 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armv7r-unknown-none-eabi".to_string(),
+        llvm_target: "armv7r-unknown-none-eabi".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
 
         options: TargetOptions {
-            abi: "eabi".to_string(),
+            abi: "eabi".into(),
             linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
             executables: true,
-            linker: Some("rust-lld".to_owned()),
+            linker: Some("rust-lld".into()),
             relocation_model: RelocModel::Static,
             panic_strategy: PanicStrategy::Abort,
             max_atomic_width: Some(32),

compiler/rustc_target/src/spec/armv7r_none_eabihf.rs

@@ -5,19 +5,19 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armv7r-unknown-none-eabihf".to_string(),
+        llvm_target: "armv7r-unknown-none-eabihf".into(),
         pointer_width: 32,
-        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".to_string(),
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
-        arch: "arm".to_string(),
+        arch: "arm".into(),
 
         options: TargetOptions {
-            abi: "eabihf".to_string(),
+            abi: "eabihf".into(),
             linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
             executables: true,
-            linker: Some("rust-lld".to_owned()),
+            linker: Some("rust-lld".into()),
             relocation_model: RelocModel::Static,
             panic_strategy: PanicStrategy::Abort,
-            features: "+vfp3,-d32,-fp16".to_string(),
+            features: "+vfp3,-d32,-fp16".into(),
             max_atomic_width: Some(32),
             emit_debug_gdb_scripts: false,
             // GCC and Clang default to 8 for arm-none here

compiler/rustc_target/src/spec/armv7s_apple_ios.rs

@@ -3,12 +3,12 @@ use crate::spec::{Target, TargetOptions};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "armv7s-apple-ios".to_string(),
+        llvm_target: "armv7s-apple-ios".into(),
         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".to_string(),
+        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: "arm".to_string(),
+        arch: "arm".into(),
         options: TargetOptions {
-            features: "+v7,+vfp4,+neon".to_string(),
+            features: "+v7,+vfp4,+neon".into(),
             max_atomic_width: Some(64),
             ..opts("ios", Arch::Armv7s)
         },

compiler/rustc_target/src/spec/asmjs_unknown_emscripten.rs

@@ -6,6 +6,6 @@ pub fn target() -> Target {
         .post_link_args
         .entry(LinkerFlavor::Em)
         .or_default()
-        .extend(vec!["-s".to_string(), "WASM=0".to_string()]);
+        .extend(vec!["-s".into(), "WASM=0".into()]);
     target
 }

compiler/rustc_target/src/spec/avr_gnu_base.rs

@@ -3,24 +3,24 @@ use crate::spec::{LinkerFlavor, Target, TargetOptions};
 /// A base target for AVR devices using the GNU toolchain.
 ///
 /// Requires GNU avr-gcc and avr-binutils on the host system.
-pub fn target(target_cpu: String) -> Target {
+pub fn target(target_cpu: &'static str) -> Target {
     Target {
-        arch: "avr".to_string(),
+        arch: "avr".into(),
-        data_layout: "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8".to_string(),
+        data_layout: "e-P1-p:16:8-i8:8-i16:8-i32:8-i64:8-f32:8-f64:8-n8-a:8".into(),
-        llvm_target: "avr-unknown-unknown".to_string(),
+        llvm_target: "avr-unknown-unknown".into(),
         pointer_width: 16,
         options: TargetOptions {
-            c_int_width: "16".to_string(),
+            c_int_width: "16".into(),
-            cpu: target_cpu.clone(),
+            cpu: target_cpu.into(),
-            exe_suffix: ".elf".to_string(),
+            exe_suffix: ".elf".into(),
 
-            linker: Some("avr-gcc".to_owned()),
+            linker: Some("avr-gcc".into()),
             executables: true,
             eh_frame_header: false,
             pre_link_args: [(LinkerFlavor::Gcc, vec![format!("-mmcu={}", target_cpu)])]
                 .into_iter()
                 .collect(),
-            late_link_args: [(LinkerFlavor::Gcc, vec!["-lgcc".to_owned()])].into_iter().collect(),
+            late_link_args: [(LinkerFlavor::Gcc, vec!["-lgcc".into()])].into_iter().collect(),
             max_atomic_width: Some(0),
             atomic_cas: false,
             ..TargetOptions::default()

compiler/rustc_target/src/spec/avr_unknown_gnu_atmega328.rs

@@ -1,5 +1,5 @@
 use crate::spec::Target;
 
 pub fn target() -> Target {
-    super::avr_gnu_base::target("atmega328".to_owned())
+    super::avr_gnu_base::target("atmega328")
 }

compiler/rustc_target/src/spec/bpfeb_unknown_none.rs

@@ -3,10 +3,10 @@ use crate::{abi::Endian, spec::bpf_base};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "bpfeb".to_string(),
+        llvm_target: "bpfeb".into(),
-        data_layout: "E-m:e-p:64:64-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "E-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(),
         pointer_width: 64,
-        arch: "bpf".to_string(),
+        arch: "bpf".into(),
         options: bpf_base::opts(Endian::Big),
     }
 }

compiler/rustc_target/src/spec/bpfel_unknown_none.rs

@@ -3,10 +3,10 @@ use crate::{abi::Endian, spec::bpf_base};
 
 pub fn target() -> Target {
     Target {
-        llvm_target: "bpfel".to_string(),
+        llvm_target: "bpfel".into(),
-        data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".to_string(),
+        data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(),
         pointer_width: 64,
-        arch: "bpf".to_string(),
+        arch: "bpf".into(),
         options: bpf_base::opts(Endian::Little),
     }
 }

compiler/rustc_target/src/spec/crt_objects.rs

@@ -42,16 +42,17 @@
 
 use crate::spec::LinkOutputKind;
 use rustc_serialize::json::{Json, ToJson};
+use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::str::FromStr;
 
-pub type CrtObjects = BTreeMap<LinkOutputKind, Vec<String>>;
+pub type CrtObjects = BTreeMap<LinkOutputKind, Vec<Cow<'static, str>>>;
 
-pub(super) fn new(obj_table: &[(LinkOutputKind, &[&str])]) -> CrtObjects {
+pub(super) fn new(obj_table: &[(LinkOutputKind, &[&'static str])]) -> CrtObjects {
-    obj_table.iter().map(|(z, k)| (*z, k.iter().map(|b| b.to_string()).collect())).collect()
+    obj_table.iter().map(|(z, k)| (*z, k.iter().map(|b| (*b).into()).collect())).collect()
 }
 
-pub(super) fn all(obj: &str) -> CrtObjects {
+pub(super) fn all(obj: &'static str) -> CrtObjects {
     new(&[
         (LinkOutputKind::DynamicNoPicExe, &[obj]),
         (LinkOutputKind::DynamicPicExe, &[obj]),

compiler/rustc_target/src/spec/dragonfly_base.rs

@@ -2,10 +2,10 @@ use crate::spec::{RelroLevel, TargetOptions};
 
 pub fn opts() -> TargetOptions {
     TargetOptions {
-        os: "dragonfly".to_string(),
+        os: "dragonfly".into(),
         dynamic_linking: true,
         executables: true,
-        families: vec!["unix".to_string()],
+        families: vec!["unix".into()],
         has_rpath: true,
         position_independent_executables: true,
         relro_level: RelroLevel::Full,

compiler/rustc_target/src/spec/freebsd_base.rs

@@ -2,10 +2,10 @@ use crate::spec::{RelroLevel, TargetOptions};
 
 pub fn opts() -> TargetOptions {
     TargetOptions {
-        os: "freebsd".to_string(),
+        os: "freebsd".into(),
         dynamic_linking: true,
         executables: true,
-        families: vec!["unix".to_string()],
+        families: vec!["unix".into()],
         has_rpath: true,
         position_independent_executables: true,
         relro_level: RelroLevel::Full,

compiler/rustc_target/src/spec/fuchsia_base.rs

@@ -5,27 +5,27 @@ pub fn opts() -> TargetOptions {
     pre_link_args.insert(
         LinkerFlavor::Lld(LldFlavor::Ld),
         vec![
-            "--build-id".to_string(),
+            "--build-id".into(),
-            "--hash-style=gnu".to_string(),
+            "--hash-style=gnu".into(),
-            "-z".to_string(),
+            "-z".into(),
-            "max-page-size=4096".to_string(),
+            "max-page-size=4096".into(),
-            "-z".to_string(),
+            "-z".into(),
-            "now".to_string(),
+            "now".into(),
-            "-z".to_string(),
+            "-z".into(),
-            "rodynamic".to_string(),
+            "rodynamic".into(),
-            "-z".to_string(),
+            "-z".into(),
-            "separate-loadable-segments".to_string(),
+            "separate-loadable-segments".into(),
-            "--pack-dyn-relocs=relr".to_string(),
+            "--pack-dyn-relocs=relr".into(),
         ],
     );
 
     TargetOptions {
-        os: "fuchsia".to_string(),
+        os: "fuchsia".into(),
         linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
-        linker: Some("rust-lld".to_owned()),
+        linker: Some("rust-lld".into()),
         dynamic_linking: true,
         executables: true,
-        families: vec!["unix".to_string()],
+        families: vec!["unix".into()],
         is_like_fuchsia: true,
         pre_link_args,
         pre_link_objects: crt_objects::new(&[

compiler/rustc_target/src/spec/haiku_base.rs

@@ -2,10 +2,10 @@ use crate::spec::{RelroLevel, TargetOptions};
 
 pub fn opts() -> TargetOptions {
     TargetOptions {
-        os: "haiku".to_string(),
+        os: "haiku".into(),
         dynamic_linking: true,
         executables: true,
-        families: vec!["unix".to_string()],
+        families: vec!["unix".into()],
         relro_level: RelroLevel::Full,
         ..Default::default()
     }

compiler/rustc_target/src/spec/hermit_base.rs

@@ -4,13 +4,13 @@ pub fn opts() -> TargetOptions {
     let mut pre_link_args = LinkArgs::new();
     pre_link_args.insert(
         LinkerFlavor::Lld(LldFlavor::Ld),
-        vec!["--build-id".to_string(), "--hash-style=gnu".to_string(), "--Bstatic".to_string()],
+        vec!["--build-id".into(), "--hash-style=gnu".into(), "--Bstatic".into()],
     );
 
     TargetOptions {
-        os: "hermit".to_string(),
+        os: "hermit".into(),
         linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
-        linker: Some("rust-lld".to_owned()),
+        linker: Some("rust-lld".into()),
         executables: true,
         has_thread_local: true,
         pre_link_args,

compiler/rustc_target/src/spec/hexagon_unknown_linux_musl.rs

@@ -2,10 +2,10 @@ use crate::spec::Target;
 
 pub fn target() -> Target {
     let mut base = super::linux_musl_base::opts();
-    base.cpu = "hexagonv60".to_string();
+    base.cpu = "hexagonv60".into();
     base.max_atomic_width = Some(32);
     // FIXME: HVX length defaults are per-CPU
-    base.features = "-small-data,+hvx-length128b".to_string();
+    base.features = "-small-data,+hvx-length128b".into();
 
     base.crt_static_default = false;
     base.has_rpath = true;
@@ -16,7 +16,7 @@ pub fn target() -> Target {
     base.c_enum_min_bits = 8;
 
     Target {
-        llvm_target: "hexagon-unknown-linux-musl".to_string(),
+        llvm_target: "hexagon-unknown-linux-musl".into(),
         pointer_width: 32,
         data_layout: concat!(
             "e-m:e-p:32:32:32-a:0-n16:32-i64:64:64-i32:32",
@@ -24,8 +24,8 @@ pub fn target() -> Target {
             ":32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048",
             ":2048:2048"
         )
-        .to_string(),
+        .into(),
-        arch: "hexagon".to_string(),
+        arch: "hexagon".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/i386_apple_ios.rs

@@ -3,13 +3,15 @@ use crate::spec::{StackProbeType, Target, TargetOptions};
 
 pub fn target() -> Target {
     let base = opts("ios", Arch::I386);
+    let llvm_target = super::apple_base::ios_sim_llvm_target("i386");
+
     Target {
-        llvm_target: super::apple_base::ios_sim_llvm_target("i386"),
+        llvm_target: llvm_target.into(),
         pointer_width: 32,
         data_layout: "e-m:o-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             f64:32:64-f80:128-n8:16:32-S128"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
         options: TargetOptions {
             max_atomic_width: Some(64),
             // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved

compiler/rustc_target/src/spec/i386_unknown_linux_gnu.rs

@@ -2,7 +2,7 @@ use crate::spec::Target;
 
 pub fn target() -> Target {
     let mut base = super::i686_unknown_linux_gnu::target();
-    base.cpu = "i386".to_string();
+    base.cpu = "i386".into();
-    base.llvm_target = "i386-unknown-linux-gnu".to_string();
+    base.llvm_target = "i386-unknown-linux-gnu".into();
     base
 }

compiler/rustc_target/src/spec/i486_unknown_linux_gnu.rs

@@ -2,7 +2,7 @@ use crate::spec::Target;
 
 pub fn target() -> Target {
     let mut base = super::i686_unknown_linux_gnu::target();
-    base.cpu = "i486".to_string();
+    base.cpu = "i486".into();
-    base.llvm_target = "i486-unknown-linux-gnu".to_string();
+    base.llvm_target = "i486-unknown-linux-gnu".into();
     base
 }

compiler/rustc_target/src/spec/i586_pc_windows_msvc.rs

@@ -2,7 +2,7 @@ use crate::spec::Target;
 
 pub fn target() -> Target {
     let mut base = super::i686_pc_windows_msvc::target();
-    base.cpu = "pentium".to_string();
+    base.cpu = "pentium".into();
-    base.llvm_target = "i586-pc-windows-msvc".to_string();
+    base.llvm_target = "i586-pc-windows-msvc".into();
     base
 }

compiler/rustc_target/src/spec/i586_unknown_linux_gnu.rs

@@ -2,7 +2,7 @@ use crate::spec::Target;
 
 pub fn target() -> Target {
     let mut base = super::i686_unknown_linux_gnu::target();
-    base.cpu = "pentium".to_string();
+    base.cpu = "pentium".into();
-    base.llvm_target = "i586-unknown-linux-gnu".to_string();
+    base.llvm_target = "i586-unknown-linux-gnu".into();
     base
 }

compiler/rustc_target/src/spec/i586_unknown_linux_musl.rs

@@ -2,7 +2,7 @@ use crate::spec::Target;
 
 pub fn target() -> Target {
     let mut base = super::i686_unknown_linux_musl::target();
-    base.cpu = "pentium".to_string();
+    base.cpu = "pentium".into();
-    base.llvm_target = "i586-unknown-linux-musl".to_string();
+    base.llvm_target = "i586-unknown-linux-musl".into();
     base
 }

compiler/rustc_target/src/spec/i686_apple_darwin.rs

@@ -2,9 +2,9 @@ use crate::spec::{FramePointer, LinkerFlavor, StackProbeType, Target, TargetOpti
 
 pub fn target() -> Target {
     let mut base = super::apple_base::opts("macos");
-    base.cpu = "yonah".to_string();
+    base.cpu = "yonah".into();
     base.max_atomic_width = Some(64);
-    base.pre_link_args.insert(LinkerFlavor::Gcc, vec!["-m32".to_string()]);
+    base.pre_link_args.insert(LinkerFlavor::Gcc, vec!["-m32".into()]);
     base.link_env_remove.extend(super::apple_base::macos_link_env_remove());
     // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
     base.stack_probes = StackProbeType::Call;
@@ -17,12 +17,12 @@ pub fn target() -> Target {
     let llvm_target = super::apple_base::macos_llvm_target(&arch);
 
     Target {
-        llvm_target,
+        llvm_target: llvm_target.into(),
         pointer_width: 32,
         data_layout: "e-m:o-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             f64:32:64-f80:128-n8:16:32-S128"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
-        options: TargetOptions { mcount: "\u{1}mcount".to_string(), ..base },
+        options: TargetOptions { mcount: "\u{1}mcount".into(), ..base },
     }
 }

compiler/rustc_target/src/spec/i686_linux_android.rs

@@ -9,18 +9,18 @@ pub fn target() -> Target {
     base.max_atomic_width = Some(64);
 
     // https://developer.android.com/ndk/guides/abis.html#x86
-    base.cpu = "pentiumpro".to_string();
+    base.cpu = "pentiumpro".into();
-    base.features = "+mmx,+sse,+sse2,+sse3,+ssse3".to_string();
+    base.features = "+mmx,+sse,+sse2,+sse3,+ssse3".into();
     // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
     base.stack_probes = StackProbeType::Call;
 
     Target {
-        llvm_target: "i686-linux-android".to_string(),
+        llvm_target: "i686-linux-android".into(),
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             f64:32:64-f80:32-n8:16:32-S128"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
         options: TargetOptions { supported_sanitizers: SanitizerSet::ADDRESS, ..base },
     }
 }

compiler/rustc_target/src/spec/i686_pc_windows_gnu.rs

@@ -2,27 +2,26 @@ use crate::spec::{FramePointer, LinkerFlavor, LldFlavor, Target};
 
 pub fn target() -> Target {
     let mut base = super::windows_gnu_base::opts();
-    base.cpu = "pentium4".to_string();
+    base.cpu = "pentium4".into();
-    base.pre_link_args
+    base.pre_link_args.insert(LinkerFlavor::Lld(LldFlavor::Ld), vec!["-m".into(), "i386pe".into()]);
-        .insert(LinkerFlavor::Lld(LldFlavor::Ld), vec!["-m".to_string(), "i386pe".to_string()]);
     base.max_atomic_width = Some(64);
     base.frame_pointer = FramePointer::Always; // Required for backtraces
-    base.linker = Some("i686-w64-mingw32-gcc".to_string());
+    base.linker = Some("i686-w64-mingw32-gcc".into());
 
     // 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
         .entry(LinkerFlavor::Gcc)
         .or_default()
-        .push("-Wl,--large-address-aware".to_string());
+        .push("-Wl,--large-address-aware".into());
 
     Target {
-        llvm_target: "i686-pc-windows-gnu".to_string(),
+        llvm_target: "i686-pc-windows-gnu".into(),
         pointer_width: 32,
         data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             i64:64-f80:32-n8:16:32-a:0:32-S32"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/i686_pc_windows_msvc.rs

@@ -2,17 +2,17 @@ use crate::spec::{LinkerFlavor, LldFlavor, Target};
 
 pub fn target() -> Target {
     let mut base = super::windows_msvc_base::opts();
-    base.cpu = "pentium4".to_string();
+    base.cpu = "pentium4".into();
     base.max_atomic_width = Some(64);
 
     let pre_link_args_msvc = vec![
         // Mark all dynamic libraries and executables as compatible with the larger 4GiB address
         // space available to x86 Windows binaries on x86_64.
-        "/LARGEADDRESSAWARE".to_string(),
+        "/LARGEADDRESSAWARE".into(),
         // 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".to_string(),
+        "/SAFESEH".into(),
     ];
     base.pre_link_args.entry(LinkerFlavor::Msvc).or_default().extend(pre_link_args_msvc.clone());
     base.pre_link_args
@@ -23,12 +23,12 @@ pub fn target() -> Target {
     base.has_thread_local = false;
 
     Target {
-        llvm_target: "i686-pc-windows-msvc".to_string(),
+        llvm_target: "i686-pc-windows-msvc".into(),
         pointer_width: 32,
         data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             i64:64-f80:128-n8:16:32-a:0:32-S32"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/i686_unknown_freebsd.rs

@@ -2,21 +2,21 @@ use crate::spec::{LinkerFlavor, StackProbeType, Target};
 
 pub fn target() -> Target {
     let mut base = super::freebsd_base::opts();
-    base.cpu = "pentium4".to_string();
+    base.cpu = "pentium4".into();
     base.max_atomic_width = Some(64);
     let pre_link_args = base.pre_link_args.entry(LinkerFlavor::Gcc).or_default();
-    pre_link_args.push("-m32".to_string());
+    pre_link_args.push("-m32".into());
-    pre_link_args.push("-Wl,-znotext".to_string());
+    pre_link_args.push("-Wl,-znotext".into());
     // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
     base.stack_probes = StackProbeType::Call;
 
     Target {
-        llvm_target: "i686-unknown-freebsd".to_string(),
+        llvm_target: "i686-unknown-freebsd".into(),
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             f64:32:64-f80:32-n8:16:32-S128"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/i686_unknown_haiku.rs

@@ -2,19 +2,19 @@ use crate::spec::{LinkerFlavor, StackProbeType, Target};
 
 pub fn target() -> Target {
     let mut base = super::haiku_base::opts();
-    base.cpu = "pentium4".to_string();
+    base.cpu = "pentium4".into();
     base.max_atomic_width = Some(64);
-    base.pre_link_args.insert(LinkerFlavor::Gcc, vec!["-m32".to_string()]);
+    base.pre_link_args.insert(LinkerFlavor::Gcc, vec!["-m32".into()]);
     // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
     base.stack_probes = StackProbeType::Call;
 
     Target {
-        llvm_target: "i686-unknown-haiku".to_string(),
+        llvm_target: "i686-unknown-haiku".into(),
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             f64:32:64-f80:32-n8:16:32-S128"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/i686_unknown_linux_gnu.rs

@@ -2,19 +2,19 @@ use crate::spec::{LinkerFlavor, StackProbeType, Target};
 
 pub fn target() -> Target {
     let mut base = super::linux_gnu_base::opts();
-    base.cpu = "pentium4".to_string();
+    base.cpu = "pentium4".into();
     base.max_atomic_width = Some(64);
-    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".to_string());
+    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".into());
     // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
     base.stack_probes = StackProbeType::Call;
 
     Target {
-        llvm_target: "i686-unknown-linux-gnu".to_string(),
+        llvm_target: "i686-unknown-linux-gnu".into(),
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             f64:32:64-f80:32-n8:16:32-S128"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/i686_unknown_linux_musl.rs

@@ -2,10 +2,10 @@ use crate::spec::{FramePointer, LinkerFlavor, StackProbeType, Target};
 
 pub fn target() -> Target {
     let mut base = super::linux_musl_base::opts();
-    base.cpu = "pentium4".to_string();
+    base.cpu = "pentium4".into();
     base.max_atomic_width = Some(64);
-    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".to_string());
+    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".into());
-    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-Wl,-melf_i386".to_string());
+    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-Wl,-melf_i386".into());
     // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
     base.stack_probes = StackProbeType::Call;
 
@@ -24,12 +24,12 @@ pub fn target() -> Target {
     base.frame_pointer = FramePointer::Always;
 
     Target {
-        llvm_target: "i686-unknown-linux-musl".to_string(),
+        llvm_target: "i686-unknown-linux-musl".into(),
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             f64:32:64-f80:32-n8:16:32-S128"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/i686_unknown_netbsd.rs

@@ -2,19 +2,19 @@ use crate::spec::{LinkerFlavor, StackProbeType, Target, TargetOptions};
 
 pub fn target() -> Target {
     let mut base = super::netbsd_base::opts();
-    base.cpu = "pentium4".to_string();
+    base.cpu = "pentium4".into();
     base.max_atomic_width = Some(64);
-    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".to_string());
+    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".into());
     // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
     base.stack_probes = StackProbeType::Call;
 
     Target {
-        llvm_target: "i686-unknown-netbsdelf".to_string(),
+        llvm_target: "i686-unknown-netbsdelf".into(),
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             f64:32:64-f80:32-n8:16:32-S128"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
-        options: TargetOptions { mcount: "__mcount".to_string(), ..base },
+        options: TargetOptions { mcount: "__mcount".into(), ..base },
     }
 }

compiler/rustc_target/src/spec/i686_unknown_openbsd.rs

@@ -2,20 +2,20 @@ use crate::spec::{LinkerFlavor, StackProbeType, Target};
 
 pub fn target() -> Target {
     let mut base = super::openbsd_base::opts();
-    base.cpu = "pentium4".to_string();
+    base.cpu = "pentium4".into();
     base.max_atomic_width = Some(64);
-    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".to_string());
+    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".into());
-    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-fuse-ld=lld".to_string());
+    base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-fuse-ld=lld".into());
     // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
     base.stack_probes = StackProbeType::Call;
 
     Target {
-        llvm_target: "i686-unknown-openbsd".to_string(),
+        llvm_target: "i686-unknown-openbsd".into(),
         pointer_width: 32,
         data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             f64:32:64-f80:32-n8:16:32-S128"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/i686_unknown_uefi.rs

@@ -9,7 +9,7 @@ use crate::spec::Target;
 
 pub fn target() -> Target {
     let mut base = super::uefi_msvc_base::opts();
-    base.cpu = "pentium4".to_string();
+    base.cpu = "pentium4".into();
     base.max_atomic_width = Some(64);
 
     // We disable MMX and SSE for now, even though UEFI allows using them. Problem is, you have to
@@ -21,7 +21,7 @@ pub fn target() -> Target {
     // far.
     // If you initialize FP units yourself, you can override these flags with custom linker
     // arguments, thus giving you access to full MMX/SSE acceleration.
-    base.features = "-mmx,-sse,+soft-float".to_string();
+    base.features = "-mmx,-sse,+soft-float".into();
 
     // Use -GNU here, because of the reason below:
     // Background and Problem:
@@ -77,12 +77,12 @@ pub fn target() -> Target {
     // compiler-builtins. After compiler-builtins implements all required intrinsics, we may
     // remove -gnu and use the default one.
     Target {
-        llvm_target: "i686-unknown-windows-gnu".to_string(),
+        llvm_target: "i686-unknown-windows-gnu".into(),
         pointer_width: 32,
         data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             i64:64-f80:32-n8:16:32-a:0:32-S32"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
 
         options: base,
     }

compiler/rustc_target/src/spec/i686_uwp_windows_gnu.rs

@@ -2,9 +2,8 @@ use crate::spec::{FramePointer, LinkerFlavor, LldFlavor, Target};
 
 pub fn target() -> Target {
     let mut base = super::windows_uwp_gnu_base::opts();
-    base.cpu = "pentium4".to_string();
+    base.cpu = "pentium4".into();
-    base.pre_link_args
+    base.pre_link_args.insert(LinkerFlavor::Lld(LldFlavor::Ld), vec!["-m".into(), "i386pe".into()]);
-        .insert(LinkerFlavor::Lld(LldFlavor::Ld), vec!["-m".to_string(), "i386pe".to_string()]);
     base.max_atomic_width = Some(64);
     base.frame_pointer = FramePointer::Always; // Required for backtraces
 
@@ -13,15 +12,15 @@ pub fn target() -> Target {
     base.pre_link_args
         .entry(LinkerFlavor::Gcc)
         .or_default()
-        .push("-Wl,--large-address-aware".to_string());
+        .push("-Wl,--large-address-aware".into());
 
     Target {
-        llvm_target: "i686-pc-windows-gnu".to_string(),
+        llvm_target: "i686-pc-windows-gnu".into(),
         pointer_width: 32,
         data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             i64:64-f80:32-n8:16:32-a:0:32-S32"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
         options: base,
     }
 }

compiler/rustc_target/src/spec/i686_uwp_windows_msvc.rs

@@ -2,16 +2,16 @@ use crate::spec::Target;
 
 pub fn target() -> Target {
     let mut base = super::windows_uwp_msvc_base::opts();
-    base.cpu = "pentium4".to_string();
+    base.cpu = "pentium4".into();
     base.max_atomic_width = Some(64);
 
     Target {
-        llvm_target: "i686-pc-windows-msvc".to_string(),
+        llvm_target: "i686-pc-windows-msvc".into(),
         pointer_width: 32,
         data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\
             i64:64-f80:128-n8:16:32-a:0:32-S32"
-            .to_string(),
+            .into(),
-        arch: "x86".to_string(),
+        arch: "x86".into(),
         options: base,
     }
 }