diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs index 40ecd91e5cfc1..3d9633c388b60 100644 --- a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs +++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs @@ -4,7 +4,7 @@ use rustc_hir::attrs::*; use rustc_session::Session; use rustc_session::parse::feature_err; use rustc_span::kw; -use rustc_target::spec::BinaryFormat; +use rustc_target::spec::{Architecture, BinaryFormat}; use super::prelude::*; use super::util::parse_single_integer; @@ -439,7 +439,7 @@ impl LinkParser { cx.expected_name_value(item.span(), Some(sym::import_name_type)); return true; }; - if cx.sess().target.arch != "x86" { + if cx.sess().target.arch != Architecture::X86 { cx.emit_err(ImportNameTypeX86 { span: item.span() }); return true; } diff --git a/compiler/rustc_codegen_cranelift/src/abi/mod.rs b/compiler/rustc_codegen_cranelift/src/abi/mod.rs index 29ee46194de19..028237a8cfba3 100644 --- a/compiler/rustc_codegen_cranelift/src/abi/mod.rs +++ b/compiler/rustc_codegen_cranelift/src/abi/mod.rs @@ -20,6 +20,7 @@ use rustc_middle::ty::print::with_no_trimmed_paths; use rustc_session::Session; use rustc_span::source_map::Spanned; use rustc_target::callconv::{FnAbi, PassMode}; +use rustc_target::spec::Architecture; use smallvec::SmallVec; use self::pass_mode::*; @@ -155,7 +156,7 @@ impl<'tcx> FunctionCx<'_, '_, 'tcx> { let ret = self.lib_call_unadjusted(name, params, returns, &args)[0]; Cow::Owned(vec![codegen_bitcast(self, types::I128, ret)]) - } else if ret_single_i128 && self.tcx.sess.target.arch == "s390x" { + } else if ret_single_i128 && self.tcx.sess.target.arch == Architecture::S390x { // Return i128 using a return area pointer on s390x. let mut params = params; let mut args = args.to_vec(); @@ -641,7 +642,7 @@ pub(crate) fn codegen_terminator_call<'tcx>( .flat_map(|arg_abi| arg_abi.get_abi_param(fx.tcx).into_iter()), ); - if fx.tcx.sess.target.is_like_darwin && fx.tcx.sess.target.arch == "aarch64" { + if fx.tcx.sess.target.is_like_darwin && fx.tcx.sess.target.arch == Architecture::AArch64 { // Add any padding arguments needed for Apple AArch64. // There's no need to pad the argument list unless variadic arguments are actually being // passed. @@ -787,25 +788,25 @@ pub(crate) fn codegen_drop<'tcx>( pub(crate) fn lib_call_arg_param(tcx: TyCtxt<'_>, ty: Type, is_signed: bool) -> AbiParam { let param = AbiParam::new(ty); if ty.is_int() && u64::from(ty.bits()) < tcx.data_layout.pointer_size().bits() { - match (&*tcx.sess.target.arch, &*tcx.sess.target.vendor) { - ("x86_64", _) | ("aarch64", "apple") => match (ty, is_signed) { + match (tcx.sess.target.arch, tcx.sess.target.vendor.as_ref()) { + (Architecture::X86_64, _) | (Architecture::AArch64, "apple") => match (ty, is_signed) { (types::I8 | types::I16, true) => param.sext(), (types::I8 | types::I16, false) => param.uext(), _ => param, }, - ("aarch64", _) => param, - ("riscv64", _) => match (ty, is_signed) { + (Architecture::AArch64, _) => param, + (Architecture::RiscV64, _) => match (ty, is_signed) { (types::I32, _) | (_, true) => param.sext(), _ => param.uext(), }, - ("s390x", _) => { + (Architecture::S390x, _) => { if is_signed { param.sext() } else { param.uext() } } - _ => unimplemented!("{:?}", tcx.sess.target.arch), + (arch, _) => unimplemented!("{arch:?}"), } } else { param diff --git a/compiler/rustc_codegen_cranelift/src/codegen_f16_f128.rs b/compiler/rustc_codegen_cranelift/src/codegen_f16_f128.rs index 1e202be1f1855..b237ca9a00ede 100644 --- a/compiler/rustc_codegen_cranelift/src/codegen_f16_f128.rs +++ b/compiler/rustc_codegen_cranelift/src/codegen_f16_f128.rs @@ -1,15 +1,18 @@ +use rustc_target::spec::Architecture; + use crate::prelude::*; pub(crate) fn f16_to_f32(fx: &mut FunctionCx<'_, '_, '_>, value: Value) -> Value { - let (value, arg_ty) = - if fx.tcx.sess.target.vendor == "apple" && fx.tcx.sess.target.arch == "x86_64" { - ( - fx.bcx.ins().bitcast(types::I16, MemFlags::new(), value), - lib_call_arg_param(fx.tcx, types::I16, false), - ) - } else { - (value, AbiParam::new(types::F16)) - }; + let (value, arg_ty) = if fx.tcx.sess.target.vendor == "apple" + && fx.tcx.sess.target.arch == Architecture::X86_64 + { + ( + fx.bcx.ins().bitcast(types::I16, MemFlags::new(), value), + lib_call_arg_param(fx.tcx, types::I16, false), + ) + } else { + (value, AbiParam::new(types::F16)) + }; fx.lib_call("__extendhfsf2", vec![arg_ty], vec![AbiParam::new(types::F32)], &[value])[0] } @@ -19,7 +22,9 @@ fn f16_to_f64(fx: &mut FunctionCx<'_, '_, '_>, value: Value) -> Value { } pub(crate) fn f32_to_f16(fx: &mut FunctionCx<'_, '_, '_>, value: Value) -> Value { - let ret_ty = if fx.tcx.sess.target.vendor == "apple" && fx.tcx.sess.target.arch == "x86_64" { + let ret_ty = if fx.tcx.sess.target.vendor == "apple" + && fx.tcx.sess.target.arch == Architecture::X86_64 + { types::I16 } else { types::F16 @@ -34,7 +39,9 @@ pub(crate) fn f32_to_f16(fx: &mut FunctionCx<'_, '_, '_>, value: Value) -> Value } fn f64_to_f16(fx: &mut FunctionCx<'_, '_, '_>, value: Value) -> Value { - let ret_ty = if fx.tcx.sess.target.vendor == "apple" && fx.tcx.sess.target.arch == "x86_64" { + let ret_ty = if fx.tcx.sess.target.vendor == "apple" + && fx.tcx.sess.target.arch == Architecture::X86_64 + { types::I16 } else { types::F16 diff --git a/compiler/rustc_codegen_cranelift/src/common.rs b/compiler/rustc_codegen_cranelift/src/common.rs index 81b1814605a12..61bdffc085761 100644 --- a/compiler/rustc_codegen_cranelift/src/common.rs +++ b/compiler/rustc_codegen_cranelift/src/common.rs @@ -8,7 +8,7 @@ use rustc_middle::ty::layout::{ }; use rustc_span::source_map::Spanned; use rustc_target::callconv::FnAbi; -use rustc_target::spec::{HasTargetSpec, Target}; +use rustc_target::spec::{Architecture, HasTargetSpec, Target}; use crate::constant::ConstantCx; use crate::debuginfo::FunctionDebugContext; @@ -373,7 +373,7 @@ impl<'tcx> FunctionCx<'_, '_, 'tcx> { "size must be a multiple of alignment (size={size}, align={align})" ); - let abi_align = if self.tcx.sess.target.arch == "s390x" { 8 } else { 16 }; + let abi_align = if self.tcx.sess.target.arch == Architecture::S390x { 8 } else { 16 }; if align <= abi_align { let stack_slot = self.bcx.create_sized_stack_slot(StackSlotData { kind: StackSlotKind::ExplicitSlot, diff --git a/compiler/rustc_codegen_cranelift/src/lib.rs b/compiler/rustc_codegen_cranelift/src/lib.rs index 5fd7c4d4f41bb..0ccdb1737569a 100644 --- a/compiler/rustc_codegen_cranelift/src/lib.rs +++ b/compiler/rustc_codegen_cranelift/src/lib.rs @@ -50,6 +50,7 @@ use rustc_middle::dep_graph::{WorkProduct, WorkProductId}; use rustc_session::Session; use rustc_session::config::OutputFilenames; use rustc_span::{Symbol, sym}; +use rustc_target::spec::Architecture; pub use crate::config::*; use crate::prelude::*; @@ -186,20 +187,20 @@ impl CodegenBackend for CraneliftCodegenBackend { fn target_config(&self, sess: &Session) -> TargetConfig { // FIXME return the actually used target features. this is necessary for #[cfg(target_feature)] - let target_features = if sess.target.arch == "x86_64" && sess.target.os != "none" { - // x86_64 mandates SSE2 support and rustc requires the x87 feature to be enabled - vec![sym::fxsr, sym::sse, sym::sse2, Symbol::intern("x87")] - } else if sess.target.arch == "aarch64" { - match &*sess.target.os { + let target_features = match sess.target.arch { + Architecture::X86_64 if sess.target.os != "none" => { + // x86_64 mandates SSE2 support and rustc requires the x87 feature to be enabled + vec![sym::fxsr, sym::sse, sym::sse2, Symbol::intern("x87")] + } + Architecture::AArch64 => match &*sess.target.os { "none" => vec![], // On macOS the aes, sha2 and sha3 features are enabled by default and ring // fails to compile on macOS when they are not present. "macos" => vec![sym::neon, sym::aes, sym::sha2, sym::sha3], // AArch64 mandates Neon support _ => vec![sym::neon], - } - } else { - vec![] + }, + _ => vec![], }; // FIXME do `unstable_target_features` properly let unstable_target_features = target_features.clone(); @@ -208,14 +209,14 @@ impl CodegenBackend for CraneliftCodegenBackend { // Windows, whereas LLVM 21+ and Cranelift pass it indirectly. This means that `f128` won't // work when linking against a LLVM-built sysroot. let has_reliable_f128 = !sess.target.is_like_windows; - let has_reliable_f16 = match &*sess.target.arch { + let has_reliable_f16 = match sess.target.arch { // FIXME(f16_f128): LLVM 20 does not support `f16` on s390x, meaning the required // builtins are not available in `compiler-builtins`. - "s390x" => false, + Architecture::S390x => false, // FIXME(f16_f128): `rustc_codegen_llvm` currently disables support on Windows GNU // targets due to GCC using a different ABI than LLVM. Therefore `f16` won't be // available when using a LLVM-built sysroot. - "x86_64" + Architecture::X86_64 if sess.target.os == "windows" && sess.target.env == "gnu" && sess.target.abi != "llvm" => diff --git a/compiler/rustc_codegen_gcc/src/abi.rs b/compiler/rustc_codegen_gcc/src/abi.rs index 0b359f1c5c81b..aaa134d7b3152 100644 --- a/compiler/rustc_codegen_gcc/src/abi.rs +++ b/compiler/rustc_codegen_gcc/src/abi.rs @@ -12,6 +12,8 @@ use rustc_middle::ty::layout::LayoutOf; #[cfg(feature = "master")] use rustc_session::config; use rustc_target::callconv::{ArgAttributes, CastTarget, FnAbi, PassMode}; +#[cfg(feature = "master")] +use rustc_target::spec::Architecture; use crate::builder::Builder; use crate::context::CodegenCx; @@ -233,12 +235,12 @@ impl<'gcc, 'tcx> FnAbiGccExt<'gcc, 'tcx> for FnAbi<'tcx, Ty<'tcx>> { #[cfg(feature = "master")] fn gcc_cconv(&self, cx: &CodegenCx<'gcc, 'tcx>) -> Option> { - conv_to_fn_attribute(self.conv, &cx.tcx.sess.target.arch) + conv_to_fn_attribute(self.conv, cx.tcx.sess.target.arch) } } #[cfg(feature = "master")] -pub fn conv_to_fn_attribute<'gcc>(conv: CanonAbi, arch: &str) -> Option> { +pub fn conv_to_fn_attribute<'gcc>(conv: CanonAbi, arch: Architecture) -> Option> { let attribute = match conv { CanonAbi::C | CanonAbi::Rust => return None, CanonAbi::RustCold => FnAttribute::Cold, @@ -251,15 +253,11 @@ pub fn conv_to_fn_attribute<'gcc>(conv: CanonAbi, arch: &str) -> Option FnAttribute::ArmCmseNonsecureEntry, ArmCall::Aapcs => FnAttribute::ArmPcs("aapcs"), }, - CanonAbi::GpuKernel => { - if arch == "amdgpu" { - FnAttribute::GcnAmdGpuHsaKernel - } else if arch == "nvptx64" { - FnAttribute::NvptxKernel - } else { - panic!("Architecture {} does not support GpuKernel calling convention", arch); - } - } + CanonAbi::GpuKernel => match arch { + Architecture::AmdGpu => FnAttribute::GcnAmdGpuHsaKernel, + Architecture::Nvptx64 => FnAttribute::NvptxKernel, + arch => panic!("Architecture {arch} does not support GpuKernel calling convention"), + }, // TODO(antoyo): check if those AVR attributes are mapped correctly. CanonAbi::Interrupt(interrupt_kind) => match interrupt_kind { InterruptKind::Avr => FnAttribute::AvrSignal, diff --git a/compiler/rustc_codegen_gcc/src/attributes.rs b/compiler/rustc_codegen_gcc/src/attributes.rs index 04b43bb8bb7c4..2a23fedf4e1e6 100644 --- a/compiler/rustc_codegen_gcc/src/attributes.rs +++ b/compiler/rustc_codegen_gcc/src/attributes.rs @@ -9,6 +9,8 @@ use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags; #[cfg(feature = "master")] use rustc_middle::mir::TerminatorKind; use rustc_middle::ty; +#[cfg(feature = "master")] +use rustc_target::spec::Architecture; use crate::context::CodegenCx; use crate::gcc_util::to_gcc_features; @@ -70,7 +72,7 @@ fn inline_attr<'gcc, 'tcx>( InlineAttr::Hint => Some(FnAttribute::Inline), InlineAttr::Force { .. } => Some(FnAttribute::AlwaysInline), InlineAttr::Never => { - if cx.sess().target.arch != "amdgpu" { + if cx.sess().target.arch != Architecture::AmdGpu { Some(FnAttribute::NoInline) } else { None @@ -153,8 +155,8 @@ pub fn from_fn_attrs<'gcc, 'tcx>( .join(","); if !target_features.is_empty() { #[cfg(feature = "master")] - match cx.sess().target.arch.as_ref() { - "x86" | "x86_64" | "powerpc" => { + match cx.sess().target.arch { + Architecture::X86 | Architecture::X86_64 | Architecture::PowerPC => { func.add_attribute(FnAttribute::Target(&target_features)) } // The target attribute is not supported on other targets in GCC. diff --git a/compiler/rustc_codegen_gcc/src/base.rs b/compiler/rustc_codegen_gcc/src/base.rs index e8672f49580b6..0598656b156f1 100644 --- a/compiler/rustc_codegen_gcc/src/base.rs +++ b/compiler/rustc_codegen_gcc/src/base.rs @@ -15,9 +15,9 @@ use rustc_middle::mir::mono::Visibility; use rustc_middle::ty::TyCtxt; use rustc_session::config::DebugInfo; use rustc_span::Symbol; -use rustc_target::spec::RelocModel; #[cfg(feature = "master")] use rustc_target::spec::SymbolVisibility; +use rustc_target::spec::{Architecture, RelocModel}; use crate::builder::Builder; use crate::context::CodegenCx; @@ -116,7 +116,7 @@ pub fn compile_codegen_unit( .map(|string| &string[1..]) .collect(); - if !disabled_features.contains("avx") && tcx.sess.target.arch == "x86_64" { + if !disabled_features.contains("avx") && tcx.sess.target.arch == Architecture::X86_64 { // NOTE: we always enable AVX because the equivalent of llvm.x86.sse2.cmp.pd in GCC for // SSE2 is multiple builtins, so we use the AVX __builtin_ia32_cmppd instead. // FIXME(antoyo): use the proper builtins for llvm.x86.sse2.cmp.pd and similar. diff --git a/compiler/rustc_codegen_gcc/src/context.rs b/compiler/rustc_codegen_gcc/src/context.rs index c9ae96777de44..6084b4fc07fac 100644 --- a/compiler/rustc_codegen_gcc/src/context.rs +++ b/compiler/rustc_codegen_gcc/src/context.rs @@ -487,7 +487,7 @@ impl<'gcc, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> { let entry_name = self.sess().target.entry_name.as_ref(); if !self.functions.borrow().contains_key(entry_name) { #[cfg(feature = "master")] - let conv = conv_to_fn_attribute(self.sess().target.entry_abi, &self.sess().target.arch); + let conv = conv_to_fn_attribute(self.sess().target.entry_abi, self.sess().target.arch); #[cfg(not(feature = "master"))] let conv = None; Some(self.declare_entry_fn(entry_name, fn_type, conv)) diff --git a/compiler/rustc_codegen_gcc/src/gcc_util.rs b/compiler/rustc_codegen_gcc/src/gcc_util.rs index 42ba40692b75c..fae95527e1ed3 100644 --- a/compiler/rustc_codegen_gcc/src/gcc_util.rs +++ b/compiler/rustc_codegen_gcc/src/gcc_util.rs @@ -2,6 +2,7 @@ use gccjit::Context; use rustc_codegen_ssa::target_features; use rustc_session::Session; +use rustc_target::spec::Architecture; use smallvec::{SmallVec, smallvec}; fn gcc_features_by_flags(sess: &Session, features: &mut Vec) { @@ -65,44 +66,47 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec(sess: &Session, s: &'a str) -> SmallVec<[&'a str; 2]> { - let arch = if sess.target.arch == "x86_64" { "x86" } else { &*sess.target.arch }; // cSpell:disable - match (arch, s) { + match (sess.target.arch, s) { // FIXME: seems like x87 does not exist? - ("x86", "x87") => smallvec![], - ("x86", "sse4.2") => smallvec!["sse4.2", "crc32"], - ("x86", "pclmulqdq") => smallvec!["pclmul"], - ("x86", "rdrand") => smallvec!["rdrnd"], - ("x86", "bmi1") => smallvec!["bmi"], - ("x86", "cmpxchg16b") => smallvec!["cx16"], - ("x86", "avx512vaes") => smallvec!["vaes"], - ("x86", "avx512gfni") => smallvec!["gfni"], - ("x86", "avx512vpclmulqdq") => smallvec!["vpclmulqdq"], + (Architecture::X86 | Architecture::X86_64, "x87") => smallvec![], + (Architecture::X86 | Architecture::X86_64, "sse4.2") => smallvec!["sse4.2", "crc32"], + (Architecture::X86 | Architecture::X86_64, "pclmulqdq") => smallvec!["pclmul"], + (Architecture::X86 | Architecture::X86_64, "rdrand") => smallvec!["rdrnd"], + (Architecture::X86 | Architecture::X86_64, "bmi1") => smallvec!["bmi"], + (Architecture::X86 | Architecture::X86_64, "cmpxchg16b") => smallvec!["cx16"], + (Architecture::X86 | Architecture::X86_64, "avx512vaes") => smallvec!["vaes"], + (Architecture::X86 | Architecture::X86_64, "avx512gfni") => smallvec!["gfni"], + (Architecture::X86 | Architecture::X86_64, "avx512vpclmulqdq") => smallvec!["vpclmulqdq"], // NOTE: seems like GCC requires 'avx512bw' for 'avx512vbmi2'. - ("x86", "avx512vbmi2") => smallvec!["avx512vbmi2", "avx512bw"], + (Architecture::X86 | Architecture::X86_64, "avx512vbmi2") => { + smallvec!["avx512vbmi2", "avx512bw"] + } // NOTE: seems like GCC requires 'avx512bw' for 'avx512bitalg'. - ("x86", "avx512bitalg") => smallvec!["avx512bitalg", "avx512bw"], - ("aarch64", "rcpc2") => smallvec!["rcpc-immo"], - ("aarch64", "dpb") => smallvec!["ccpp"], - ("aarch64", "dpb2") => smallvec!["ccdp"], - ("aarch64", "frintts") => smallvec!["fptoint"], - ("aarch64", "fcma") => smallvec!["complxnum"], - ("aarch64", "pmuv3") => smallvec!["perfmon"], - ("aarch64", "paca") => smallvec!["pauth"], - ("aarch64", "pacg") => smallvec!["pauth"], + (Architecture::X86 | Architecture::X86_64, "avx512bitalg") => { + smallvec!["avx512bitalg", "avx512bw"] + } + (Architecture::AArch64, "rcpc2") => smallvec!["rcpc-immo"], + (Architecture::AArch64, "dpb") => smallvec!["ccpp"], + (Architecture::AArch64, "dpb2") => smallvec!["ccdp"], + (Architecture::AArch64, "frintts") => smallvec!["fptoint"], + (Architecture::AArch64, "fcma") => smallvec!["complxnum"], + (Architecture::AArch64, "pmuv3") => smallvec!["perfmon"], + (Architecture::AArch64, "paca") => smallvec!["pauth"], + (Architecture::AArch64, "pacg") => smallvec!["pauth"], // Rust ties fp and neon together. In GCC neon implicitly enables fp, // but we manually enable neon when a feature only implicitly enables fp - ("aarch64", "f32mm") => smallvec!["f32mm", "neon"], - ("aarch64", "f64mm") => smallvec!["f64mm", "neon"], - ("aarch64", "fhm") => smallvec!["fp16fml", "neon"], - ("aarch64", "fp16") => smallvec!["fullfp16", "neon"], - ("aarch64", "jsconv") => smallvec!["jsconv", "neon"], - ("aarch64", "sve") => smallvec!["sve", "neon"], - ("aarch64", "sve2") => smallvec!["sve2", "neon"], - ("aarch64", "sve2-aes") => smallvec!["sve2-aes", "neon"], - ("aarch64", "sve2-sm4") => smallvec!["sve2-sm4", "neon"], - ("aarch64", "sve2-sha3") => smallvec!["sve2-sha3", "neon"], - ("aarch64", "sve2-bitperm") => smallvec!["sve2-bitperm", "neon"], + (Architecture::AArch64, "f32mm") => smallvec!["f32mm", "neon"], + (Architecture::AArch64, "f64mm") => smallvec!["f64mm", "neon"], + (Architecture::AArch64, "fhm") => smallvec!["fp16fml", "neon"], + (Architecture::AArch64, "fp16") => smallvec!["fullfp16", "neon"], + (Architecture::AArch64, "jsconv") => smallvec!["jsconv", "neon"], + (Architecture::AArch64, "sve") => smallvec!["sve", "neon"], + (Architecture::AArch64, "sve2") => smallvec!["sve2", "neon"], + (Architecture::AArch64, "sve2-aes") => smallvec!["sve2-aes", "neon"], + (Architecture::AArch64, "sve2-sm4") => smallvec!["sve2-sm4", "neon"], + (Architecture::AArch64, "sve2-sha3") => smallvec!["sve2-sha3", "neon"], + (Architecture::AArch64, "sve2-bitperm") => smallvec!["sve2-bitperm", "neon"], (_, s) => smallvec![s], } // cSpell:enable diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs index ec7eab8489ab8..ecbeb58cf0b22 100644 --- a/compiler/rustc_codegen_gcc/src/lib.rs +++ b/compiler/rustc_codegen_gcc/src/lib.rs @@ -110,7 +110,7 @@ use rustc_middle::util::Providers; use rustc_session::Session; use rustc_session::config::{OptLevel, OutputFilenames}; use rustc_span::Symbol; -use rustc_target::spec::RelocModel; +use rustc_target::spec::{Architecture, RelocModel}; use tempfile::TempDir; use crate::back::lto::ModuleBuffer; @@ -256,7 +256,7 @@ impl CodegenBackend for GccCodegenBackend { fn new_context<'gcc, 'tcx>(tcx: TyCtxt<'tcx>) -> Context<'gcc> { let context = Context::default(); - if tcx.sess.target.arch == "x86" || tcx.sess.target.arch == "x86_64" { + if matches!(tcx.sess.target.arch, Architecture::X86 | Architecture::X86_64) { context.add_command_line_option("-masm=intel"); } #[cfg(feature = "master")] diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs index 680ad98593e7e..694efd7eb8174 100644 --- a/compiler/rustc_codegen_llvm/src/abi.rs +++ b/compiler/rustc_codegen_llvm/src/abi.rs @@ -16,7 +16,7 @@ use rustc_session::{Session, config}; use rustc_target::callconv::{ ArgAbi, ArgAttribute, ArgAttributes, ArgExtension, CastTarget, FnAbi, PassMode, }; -use rustc_target::spec::SanitizerSet; +use rustc_target::spec::{Architecture, SanitizerSet}; use smallvec::SmallVec; use crate::attributes::{self, llfn_attrs_from_instance}; @@ -670,16 +670,11 @@ pub(crate) fn to_llvm_calling_convention(sess: &Session, abi: CanonAbi) -> llvm: // possible to declare an `extern "custom"` block, so the backend still needs a calling // convention for declaring foreign functions. CanonAbi::Custom => llvm::CCallConv, - CanonAbi::GpuKernel => { - let arch = sess.target.arch.as_ref(); - if arch == "amdgpu" { - llvm::AmdgpuKernel - } else if arch == "nvptx64" { - llvm::PtxKernel - } else { - panic!("Architecture {arch} does not support GpuKernel calling convention"); - } - } + CanonAbi::GpuKernel => match sess.target.arch { + Architecture::AmdGpu => llvm::AmdgpuKernel, + Architecture::Nvptx64 => llvm::PtxKernel, + arch => panic!("Architecture {arch} does not support GpuKernel calling convention"), + }, CanonAbi::Interrupt(interrupt_kind) => match interrupt_kind { InterruptKind::Avr => llvm::AvrInterrupt, InterruptKind::AvrNonBlocking => llvm::AvrNonBlockingInterrupt, diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs index 209b8efa2c3b3..1a4cdf0796fc9 100644 --- a/compiler/rustc_codegen_llvm/src/attributes.rs +++ b/compiler/rustc_codegen_llvm/src/attributes.rs @@ -7,7 +7,9 @@ use rustc_middle::middle::codegen_fn_attrs::{ use rustc_middle::ty::{self, TyCtxt}; use rustc_session::config::{BranchProtection, FunctionReturn, OptLevel, PAuthKey, PacRet}; use rustc_symbol_mangling::mangle_internal_symbol; -use rustc_target::spec::{FramePointer, SanitizerSet, StackProbeType, StackProtector}; +use rustc_target::spec::{ + Architecture, FramePointer, SanitizerSet, StackProbeType, StackProtector, +}; use smallvec::SmallVec; use crate::context::SimpleCx; @@ -54,7 +56,7 @@ pub(crate) fn inline_attr<'ll, 'tcx>( Some(AttributeKind::AlwaysInline.create_attr(cx.llcx)) } InlineAttr::Never => { - if tcx.sess.target.arch != "amdgpu" { + if tcx.sess.target.arch != Architecture::AmdGpu { Some(AttributeKind::NoInline.create_attr(cx.llcx)) } else { None @@ -287,7 +289,7 @@ fn stackprotector_attr<'ll>(cx: &SimpleCx<'ll>, sess: &Session) -> Option<&'ll A } fn backchain_attr<'ll>(cx: &SimpleCx<'ll>, sess: &Session) -> Option<&'ll Attribute> { - if sess.target.arch != "s390x" { + if sess.target.arch != Architecture::S390x { return None; } @@ -423,7 +425,7 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>( if let Some(BranchProtection { bti, pac_ret, gcs }) = sess.opts.unstable_opts.branch_protection { - assert!(sess.target.arch == "aarch64"); + assert!(sess.target.arch == Architecture::AArch64); if bti { to_add.push(llvm::CreateAttrString(cx.llcx, "branch-target-enforcement")); } diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs index 6ce1cbe072c06..cde2cf69d1a16 100644 --- a/compiler/rustc_codegen_llvm/src/back/write.rs +++ b/compiler/rustc_codegen_llvm/src/back/write.rs @@ -28,7 +28,9 @@ use rustc_session::config::{ self, Lto, OutputType, Passes, RemapPathScopeComponents, SplitDwarfKind, SwitchWithOptPath, }; use rustc_span::{BytePos, InnerSpan, Pos, SpanData, SyntaxContext, sym}; -use rustc_target::spec::{CodeModel, FloatAbi, RelocModel, SanitizerSet, SplitDebuginfo, TlsModel}; +use rustc_target::spec::{ + Architecture, CodeModel, FloatAbi, RelocModel, SanitizerSet, SplitDebuginfo, TlsModel, +}; use tracing::{debug, trace}; use crate::back::command_line_args::quote_command_line_args; @@ -210,7 +212,7 @@ pub(crate) fn target_machine_factory( let reloc_model = to_llvm_relocation_model(sess.relocation_model()); let (opt_level, _) = to_llvm_opt_settings(optlvl); - let float_abi = if sess.target.arch == "arm" && sess.opts.cg.soft_float { + let float_abi = if sess.target.arch == Architecture::Arm && sess.opts.cg.soft_float { llvm::FloatAbi::Soft } else { // `validate_commandline_args_with_session_available` has already warned about this being diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs index c082a82306848..94ed400b03a2c 100644 --- a/compiler/rustc_codegen_llvm/src/builder.rs +++ b/compiler/rustc_codegen_llvm/src/builder.rs @@ -27,7 +27,7 @@ use rustc_sanitizers::{cfi, kcfi}; use rustc_session::config::OptLevel; use rustc_span::Span; use rustc_target::callconv::{FnAbi, PassMode}; -use rustc_target::spec::{HasTargetSpec, SanitizerSet, Target}; +use rustc_target::spec::{Architecture, HasTargetSpec, SanitizerSet, Target}; use smallvec::SmallVec; use tracing::{debug, instrument}; @@ -840,11 +840,13 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> { // operation. But it's not clear how to do that with LLVM.) // For more context, see and // . - const WELL_BEHAVED_NONTEMPORAL_ARCHS: &[&str] = - &["aarch64", "arm", "riscv32", "riscv64"]; - - let use_nontemporal = - WELL_BEHAVED_NONTEMPORAL_ARCHS.contains(&&*self.cx.tcx.sess.target.arch); + let use_nontemporal = matches!( + self.cx.tcx.sess.target.arch, + Architecture::AArch64 + | Architecture::Arm + | Architecture::RiscV32 + | Architecture::RiscV64 + ); if use_nontemporal { // According to LLVM [1] building a nontemporal store must // *always* point to a metadata value of the integer 1. diff --git a/compiler/rustc_codegen_llvm/src/callee.rs b/compiler/rustc_codegen_llvm/src/callee.rs index b86b32b92df04..7203b0f1a02f9 100644 --- a/compiler/rustc_codegen_llvm/src/callee.rs +++ b/compiler/rustc_codegen_llvm/src/callee.rs @@ -7,6 +7,7 @@ use rustc_codegen_ssa::common; use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, HasTypingEnv}; use rustc_middle::ty::{self, Instance, TypeVisitableExt}; +use rustc_target::spec::Architecture; use tracing::debug; use crate::context::CodegenCx; @@ -35,7 +36,7 @@ pub(crate) fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'t llfn } else { let instance_def_id = instance.def_id(); - let llfn = if tcx.sess.target.arch == "x86" + let llfn = if tcx.sess.target.arch == Architecture::X86 && let Some(dllimport) = crate::common::get_dllimport(tcx, instance_def_id, sym) { // When calling functions in generated import libraries, MSVC needs diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs index 9844c9444b3d0..8dc6859446e38 100644 --- a/compiler/rustc_codegen_llvm/src/consts.rs +++ b/compiler/rustc_codegen_llvm/src/consts.rs @@ -17,6 +17,7 @@ use rustc_middle::ty::layout::{HasTypingEnv, LayoutOf}; use rustc_middle::ty::{self, Instance}; use rustc_middle::{bug, span_bug}; use rustc_span::Symbol; +use rustc_target::spec::Architecture; use tracing::{debug, instrument, trace}; use crate::common::CodegenCx; @@ -203,7 +204,7 @@ fn check_and_apply_linkage<'ll, 'tcx>( llvm::set_linkage(g2, llvm::Linkage::InternalLinkage); llvm::set_initializer(g2, g1); g2 - } else if cx.tcx.sess.target.arch == "x86" + } else if cx.tcx.sess.target.arch == Architecture::X86 && common::is_mingw_gnu_toolchain(&cx.tcx.sess.target) && let Some(dllimport) = crate::common::get_dllimport(cx.tcx, def_id, sym) { diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs index 808aaceab4d20..3074dd4fe436e 100644 --- a/compiler/rustc_codegen_llvm/src/context.rs +++ b/compiler/rustc_codegen_llvm/src/context.rs @@ -28,7 +28,9 @@ use rustc_session::config::{ use rustc_span::source_map::Spanned; use rustc_span::{DUMMY_SP, Span, Symbol}; use rustc_symbol_mangling::mangle_internal_symbol; -use rustc_target::spec::{HasTargetSpec, RelocModel, SmallDataThresholdSupport, Target, TlsModel}; +use rustc_target::spec::{ + Architecture, HasTargetSpec, RelocModel, SmallDataThresholdSupport, Target, TlsModel, +}; use smallvec::SmallVec; use crate::abi::to_llvm_calling_convention; @@ -181,22 +183,22 @@ pub(crate) unsafe fn create_module<'ll>( let llvm_version = llvm_util::get_version(); if llvm_version < (21, 0, 0) { - if sess.target.arch == "nvptx64" { + if sess.target.arch == Architecture::Nvptx64 { // LLVM 21 updated the default layout on nvptx: https://github.com/llvm/llvm-project/pull/124961 target_data_layout = target_data_layout.replace("e-p6:32:32-i64", "e-i64"); } - if sess.target.arch == "amdgpu" { + if sess.target.arch == Architecture::AmdGpu { // LLVM 21 adds the address width for address space 8. // See https://github.com/llvm/llvm-project/pull/139419 target_data_layout = target_data_layout.replace("p8:128:128:128:48", "p8:128:128") } } if llvm_version < (22, 0, 0) { - if sess.target.arch == "avr" { + if sess.target.arch == Architecture::Avr { // LLVM 22.0 updated the default layout on avr: https://github.com/llvm/llvm-project/pull/153010 target_data_layout = target_data_layout.replace("n8:16", "n8") } - if sess.target.arch == "nvptx64" { + if sess.target.arch == Architecture::Nvptx64 { // LLVM 22 updated the NVPTX layout to indicate 256-bit vector load/store: https://github.com/llvm/llvm-project/pull/155198 target_data_layout = target_data_layout.replace("-i256:256", ""); } @@ -371,7 +373,7 @@ pub(crate) unsafe fn create_module<'ll>( if let Some(BranchProtection { bti, pac_ret, gcs }) = sess.opts.unstable_opts.branch_protection { - if sess.target.arch == "aarch64" { + if sess.target.arch == Architecture::AArch64 { llvm::add_module_flag_u32( llmod, llvm::ModuleFlagMergeBehavior::Min, @@ -502,7 +504,9 @@ pub(crate) unsafe fn create_module<'ll>( // FIXME: https://github.com/llvm/llvm-project/issues/50591 // If llvm_abiname is empty, emit nothing. let llvm_abiname = &sess.target.options.llvm_abiname; - if matches!(sess.target.arch.as_ref(), "riscv32" | "riscv64") && !llvm_abiname.is_empty() { + if matches!(sess.target.arch, Architecture::RiscV32 | Architecture::RiscV64) + && !llvm_abiname.is_empty() + { llvm::add_module_flag_str( llmod, llvm::ModuleFlagMergeBehavior::Error, @@ -667,7 +671,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> { /// This corresponds to the `-fobjc-abi-version=` flag in Clang / GCC. pub(crate) fn objc_abi_version(&self) -> u32 { assert!(self.tcx.sess.target.is_like_darwin); - if self.tcx.sess.target.arch == "x86" && self.tcx.sess.target.os == "macos" { + if self.tcx.sess.target.arch == Architecture::X86 && self.tcx.sess.target.os == "macos" { // 32-bit x86 macOS uses ABI version 1 (a.k.a. the "fragile ABI"). 1 } else { diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs index 3b920168e06dc..96b7f72d0dcf4 100644 --- a/compiler/rustc_codegen_llvm/src/llvm_util.rs +++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs @@ -15,7 +15,7 @@ use rustc_fs_util::path_to_c_string; use rustc_middle::bug; use rustc_session::Session; use rustc_session::config::{PrintKind, PrintRequest}; -use rustc_target::spec::{MergeFunctions, PanicStrategy, SmallDataThresholdSupport}; +use rustc_target::spec::{Architecture, MergeFunctions, PanicStrategy, SmallDataThresholdSupport}; use smallvec::{SmallVec, smallvec}; use crate::back::write::create_informational_target_machine; @@ -217,70 +217,85 @@ impl<'a> IntoIterator for LLVMFeature<'a> { /// Rust can also be build with an external precompiled version of LLVM which might lead to failures /// if the oldest tested / supported LLVM version doesn't yet support the relevant intrinsics. pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option> { - let raw_arch = &*sess.target.arch; - let arch = match raw_arch { - "x86_64" => "x86", - "arm64ec" => "aarch64", - "sparc64" => "sparc", - "powerpc64" => "powerpc", - _ => raw_arch, - }; let (major, _, _) = get_version(); - match (arch, s) { - ("aarch64", "rcpc2") => Some(LLVMFeature::new("rcpc-immo")), - ("aarch64", "dpb") => Some(LLVMFeature::new("ccpp")), - ("aarch64", "dpb2") => Some(LLVMFeature::new("ccdp")), - ("aarch64", "frintts") => Some(LLVMFeature::new("fptoint")), - ("aarch64", "fcma") => Some(LLVMFeature::new("complxnum")), - ("aarch64", "pmuv3") => Some(LLVMFeature::new("perfmon")), - ("aarch64", "paca") => Some(LLVMFeature::new("pauth")), - ("aarch64", "pacg") => Some(LLVMFeature::new("pauth")), - ("aarch64", "flagm2") => Some(LLVMFeature::new("altnzcv")), - // Rust ties fp and neon together. - ("aarch64", "neon") => Some(LLVMFeature::with_dependencies( - "neon", - smallvec![TargetFeatureFoldStrength::Both("fp-armv8")], - )), - // In LLVM neon implicitly enables fp, but we manually enable - // neon when a feature only implicitly enables fp - ("aarch64", "fhm") => Some(LLVMFeature::new("fp16fml")), - ("aarch64", "fp16") => Some(LLVMFeature::new("fullfp16")), - // Filter out features that are not supported by the current LLVM version - ("aarch64", "fpmr") => None, // only existed in 18 - ("arm", "fp16") => Some(LLVMFeature::new("fullfp16")), + match sess.target.arch { + Architecture::AArch64 | Architecture::Arm64EC => { + match s { + "rcpc2" => Some(LLVMFeature::new("rcpc-immo")), + "dpb" => Some(LLVMFeature::new("ccpp")), + "dpb2" => Some(LLVMFeature::new("ccdp")), + "frintts" => Some(LLVMFeature::new("fptoint")), + "fcma" => Some(LLVMFeature::new("complxnum")), + "pmuv3" => Some(LLVMFeature::new("perfmon")), + "paca" => Some(LLVMFeature::new("pauth")), + "pacg" => Some(LLVMFeature::new("pauth")), + "flagm2" => Some(LLVMFeature::new("altnzcv")), + // Rust ties fp and neon together. + "neon" => Some(LLVMFeature::with_dependencies( + "neon", + smallvec![TargetFeatureFoldStrength::Both("fp-armv8")], + )), + // In LLVM neon implicitly enables fp, but we manually enable + // neon when a feature only implicitly enables fp + "fhm" => Some(LLVMFeature::new("fp16fml")), + "fp16" => Some(LLVMFeature::new("fullfp16")), + // Filter out features that are not supported by the current LLVM version + "fpmr" => None, // only existed in 18 + s => Some(LLVMFeature::new(s)), + } + } + Architecture::Arm => match s { + "fp16" => Some(LLVMFeature::new("fullfp16")), + s => Some(LLVMFeature::new(s)), + }, + // Filter out features that are not supported by the current LLVM version - ("loongarch32" | "loongarch64", "32s") if major < 21 => None, - ("powerpc", "power8-crypto") => Some(LLVMFeature::new("crypto")), - ("sparc", "leoncasa") => Some(LLVMFeature::new("hasleoncasa")), - ("x86", "sse4.2") => Some(LLVMFeature::with_dependencies( - "sse4.2", - smallvec![TargetFeatureFoldStrength::EnableOnly("crc32")], - )), - ("x86", "pclmulqdq") => Some(LLVMFeature::new("pclmul")), - ("x86", "rdrand") => Some(LLVMFeature::new("rdrnd")), - ("x86", "bmi1") => Some(LLVMFeature::new("bmi")), - ("x86", "cmpxchg16b") => Some(LLVMFeature::new("cx16")), - ("x86", "lahfsahf") => Some(LLVMFeature::new("sahf")), - // Enable the evex512 target feature if an avx512 target feature is enabled. - ("x86", s) if s.starts_with("avx512") => Some(LLVMFeature::with_dependencies( - s, - smallvec![TargetFeatureFoldStrength::EnableOnly("evex512")], - )), - ("x86", "avx10.1") => Some(LLVMFeature::new("avx10.1-512")), - ("x86", "avx10.2") => Some(LLVMFeature::new("avx10.2-512")), - ("x86", "apxf") => Some(LLVMFeature::with_dependencies( - "egpr", - smallvec![ - TargetFeatureFoldStrength::Both("push2pop2"), - TargetFeatureFoldStrength::Both("ppx"), - TargetFeatureFoldStrength::Both("ndd"), - TargetFeatureFoldStrength::Both("ccmp"), - TargetFeatureFoldStrength::Both("cf"), - TargetFeatureFoldStrength::Both("nf"), - TargetFeatureFoldStrength::Both("zu"), - ], - )), - (_, s) => Some(LLVMFeature::new(s)), + Architecture::LoongArch32 | Architecture::LoongArch64 => match s { + "32s" if major < 21 => None, + s => Some(LLVMFeature::new(s)), + }, + Architecture::PowerPC | Architecture::PowerPC64 => match s { + "power8-crypto" => Some(LLVMFeature::new("crypto")), + s => Some(LLVMFeature::new(s)), + }, + Architecture::Sparc | Architecture::Sparc64 => match s { + "leoncasa" => Some(LLVMFeature::new("hasleoncasa")), + s => Some(LLVMFeature::new(s)), + }, + Architecture::X86 | Architecture::X86_64 => { + match s { + "sse4.2" => Some(LLVMFeature::with_dependencies( + "sse4.2", + smallvec![TargetFeatureFoldStrength::EnableOnly("crc32")], + )), + "pclmulqdq" => Some(LLVMFeature::new("pclmul")), + "rdrand" => Some(LLVMFeature::new("rdrnd")), + "bmi1" => Some(LLVMFeature::new("bmi")), + "cmpxchg16b" => Some(LLVMFeature::new("cx16")), + "lahfsahf" => Some(LLVMFeature::new("sahf")), + // Enable the evex512 target feature if an avx512 target feature is enabled. + s if s.starts_with("avx512") => Some(LLVMFeature::with_dependencies( + s, + smallvec![TargetFeatureFoldStrength::EnableOnly("evex512")], + )), + "avx10.1" => Some(LLVMFeature::new("avx10.1-512")), + "avx10.2" => Some(LLVMFeature::new("avx10.2-512")), + "apxf" => Some(LLVMFeature::with_dependencies( + "egpr", + smallvec![ + TargetFeatureFoldStrength::Both("push2pop2"), + TargetFeatureFoldStrength::Both("ppx"), + TargetFeatureFoldStrength::Both("ndd"), + TargetFeatureFoldStrength::Both("ccmp"), + TargetFeatureFoldStrength::Both("cf"), + TargetFeatureFoldStrength::Both("nf"), + TargetFeatureFoldStrength::Both("zu"), + ], + )), + s => Some(LLVMFeature::new(s)), + } + } + _ => Some(LLVMFeature::new(s)), } } @@ -327,7 +342,7 @@ pub(crate) fn target_config(sess: &Session) -> TargetConfig { /// Determine whether or not experimental float types are reliable based on known bugs. fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) { - let target_arch = sess.target.arch.as_ref(); + let target_arch = sess.target.arch; let target_os = sess.target.options.os.as_ref(); let target_env = sess.target.options.env.as_ref(); let target_abi = sess.target.options.abi.as_ref(); @@ -338,23 +353,23 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) { cfg.has_reliable_f16 = match (target_arch, target_os) { // LLVM crash without neon (fixed in llvm20) - ("aarch64", _) + (Architecture::AArch64, _) if !cfg.target_features.iter().any(|f| f.as_str() == "neon") && lt_20_1_1 => { false } // Unsupported - ("arm64ec", _) => false, + (Architecture::Arm64EC, _) => false, // Selection failure (fixed in llvm21) - ("s390x", _) if lt_21_0_0 => false, + (Architecture::S390x, _) if lt_21_0_0 => false, // MinGW ABI bugs - ("x86_64", "windows") if target_env == "gnu" && target_abi != "llvm" => false, + (Architecture::X86_64, "windows") if target_env == "gnu" && target_abi != "llvm" => false, // Infinite recursion - ("csky", _) => false, - ("hexagon", _) if lt_21_0_0 => false, // (fixed in llvm21) - ("powerpc" | "powerpc64", _) => false, - ("sparc" | "sparc64", _) => false, - ("wasm32" | "wasm64", _) => false, + (Architecture::CSKY, _) => false, + (Architecture::Hexagon, _) if lt_21_0_0 => false, // (fixed in llvm21) + (Architecture::PowerPC | Architecture::PowerPC64, _) => false, + (Architecture::Sparc | Architecture::Sparc64, _) => false, + (Architecture::Wasm32 | Architecture::Wasm64, _) => false, // `f16` support only requires that symbols converting to and from `f32` are available. We // provide these in `compiler-builtins`, so `f16` should be available on all platforms that // do not have other ABI issues or LLVM crashes. @@ -363,24 +378,24 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) { cfg.has_reliable_f128 = match (target_arch, target_os) { // Unsupported - ("arm64ec", _) => false, + (Architecture::Arm64EC, _) => false, // Selection bug (fixed in llvm20) - ("mips64" | "mips64r6", _) if lt_20_1_1 => false, + (Architecture::Mips64 | Architecture::Mips64r6, _) if lt_20_1_1 => false, // Selection bug . This issue is closed // but basic math still does not work. - ("nvptx64", _) => false, + (Architecture::Nvptx64, _) => false, // Unsupported https://github.com/llvm/llvm-project/issues/121122 - ("amdgpu", _) => false, + (Architecture::AmdGpu, _) => false, // ABI bugs et al. (full // list at ) - ("powerpc" | "powerpc64", _) => false, + (Architecture::PowerPC | Architecture::PowerPC64, _) => false, // ABI unsupported - ("sparc", _) => false, + (Architecture::Sparc, _) => false, // Stack alignment bug . NB: tests may // not fail if our compiler-builtins is linked. (fixed in llvm21) - ("x86", _) if lt_21_0_0 => false, + (Architecture::X86, _) if lt_21_0_0 => false, // MinGW ABI bugs - ("x86_64", "windows") if target_env == "gnu" && target_abi != "llvm" => false, + (Architecture::X86_64, "windows") if target_env == "gnu" && target_abi != "llvm" => false, // There are no known problems on other platforms, so the only requirement is that symbols // are available. `compiler-builtins` provides all symbols required for core `f128` // support, so this should work for everything else. @@ -402,7 +417,7 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) { // // musl does not implement the symbols required for f128 math at all. _ if target_env == "musl" => false, - ("x86_64", _) => false, + (Architecture::X86_64, _) => false, (_, "linux") if target_pointer_width == 64 => true, _ => false, } && cfg.has_reliable_f128; @@ -605,8 +620,8 @@ fn llvm_features_by_flags(sess: &Session, features: &mut Vec) { // -Zfixed-x18 if sess.opts.unstable_opts.fixed_x18 { - if sess.target.arch != "aarch64" { - sess.dcx().emit_fatal(errors::FixedX18InvalidArch { arch: &sess.target.arch }); + if sess.target.arch != Architecture::AArch64 { + sess.dcx().emit_fatal(errors::FixedX18InvalidArch { arch: sess.target.arch.desc() }); } else { features.push("+reserve-x18".into()); } diff --git a/compiler/rustc_codegen_llvm/src/mono_item.rs b/compiler/rustc_codegen_llvm/src/mono_item.rs index 52eefe2d4d243..27c5b8460b240 100644 --- a/compiler/rustc_codegen_llvm/src/mono_item.rs +++ b/compiler/rustc_codegen_llvm/src/mono_item.rs @@ -7,7 +7,7 @@ use rustc_middle::mir::mono::Visibility; use rustc_middle::ty::layout::{FnAbiOf, HasTypingEnv, LayoutOf}; use rustc_middle::ty::{self, Instance, TypeVisitableExt}; use rustc_session::config::CrateType; -use rustc_target::spec::RelocModel; +use rustc_target::spec::{Architecture, RelocModel}; use tracing::debug; use crate::context::CodegenCx; @@ -116,7 +116,8 @@ impl CodegenCx<'_, '_> { } // PowerPC64 prefers TOC indirection to avoid copy relocations. - if matches!(&*self.tcx.sess.target.arch, "powerpc64" | "powerpc64le") { + if matches!(self.tcx.sess.target.arch, Architecture::PowerPC64 | Architecture::PowerPC64LE) + { return false; } diff --git a/compiler/rustc_codegen_llvm/src/va_arg.rs b/compiler/rustc_codegen_llvm/src/va_arg.rs index 2d9abb412d4f1..5594c4c9a28a0 100644 --- a/compiler/rustc_codegen_llvm/src/va_arg.rs +++ b/compiler/rustc_codegen_llvm/src/va_arg.rs @@ -7,6 +7,7 @@ use rustc_codegen_ssa::traits::{ }; use rustc_middle::ty::Ty; use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf}; +use rustc_target::spec::Architecture; use crate::builder::Builder; use crate::llvm::{Type, Value}; @@ -886,8 +887,8 @@ pub(super) fn emit_va_arg<'ll, 'tcx>( // is lacking in some instances, so we should only use it as a fallback. let target = &bx.cx.tcx.sess.target; - match &*target.arch { - "x86" => emit_ptr_va_arg( + match target.arch { + Architecture::X86 => emit_ptr_va_arg( bx, addr, target_ty, @@ -896,7 +897,9 @@ pub(super) fn emit_va_arg<'ll, 'tcx>( if target.is_like_windows { AllowHigherAlign::No } else { AllowHigherAlign::Yes }, ForceRightAdjust::No, ), - "aarch64" | "arm64ec" if target.is_like_windows || target.is_like_darwin => { + Architecture::AArch64 | Architecture::Arm64EC + if target.is_like_windows || target.is_like_darwin => + { emit_ptr_va_arg( bx, addr, @@ -907,8 +910,8 @@ pub(super) fn emit_va_arg<'ll, 'tcx>( ForceRightAdjust::No, ) } - "aarch64" => emit_aapcs_va_arg(bx, addr, target_ty), - "arm" => { + Architecture::AArch64 => emit_aapcs_va_arg(bx, addr, target_ty), + Architecture::Arm => { // Types wider than 16 bytes are not currently supported. Clang has special logic for // such types, but `VaArgSafe` is not implemented for any type that is this large. assert!(bx.cx.size_of(target_ty).bytes() <= 16); @@ -923,22 +926,28 @@ pub(super) fn emit_va_arg<'ll, 'tcx>( ForceRightAdjust::No, ) } - "s390x" => emit_s390x_va_arg(bx, addr, target_ty), - "powerpc" => emit_powerpc_va_arg(bx, addr, target_ty), - "powerpc64" | "powerpc64le" => emit_ptr_va_arg( + Architecture::S390x => emit_s390x_va_arg(bx, addr, target_ty), + Architecture::PowerPC => emit_powerpc_va_arg(bx, addr, target_ty), + Architecture::PowerPC64 => emit_ptr_va_arg( bx, addr, target_ty, PassMode::Direct, SlotSize::Bytes8, AllowHigherAlign::Yes, - match &*target.arch { - "powerpc64" => ForceRightAdjust::Yes, - _ => ForceRightAdjust::No, - }, + ForceRightAdjust::Yes, + ), + Architecture::PowerPC64LE => emit_ptr_va_arg( + bx, + addr, + target_ty, + PassMode::Direct, + SlotSize::Bytes8, + AllowHigherAlign::Yes, + ForceRightAdjust::No, ), // Windows x86_64 - "x86_64" if target.is_like_windows => { + Architecture::X86_64 if target.is_like_windows => { let target_ty_size = bx.cx.size_of(target_ty).bytes(); emit_ptr_va_arg( bx, @@ -955,8 +964,8 @@ pub(super) fn emit_va_arg<'ll, 'tcx>( ) } // This includes `target.is_like_darwin`, which on x86_64 targets is like sysv64. - "x86_64" => emit_x86_64_sysv64_va_arg(bx, addr, target_ty), - "xtensa" => emit_xtensa_va_arg(bx, addr, target_ty), + Architecture::X86_64 => emit_x86_64_sysv64_va_arg(bx, addr, target_ty), + Architecture::Xtensa => emit_xtensa_va_arg(bx, addr, target_ty), // For all other architecture/OS combinations fall back to using // the LLVM va_arg instruction. // https://llvm.org/docs/LangRef.html#va-arg-instruction diff --git a/compiler/rustc_codegen_ssa/src/back/apple.rs b/compiler/rustc_codegen_ssa/src/back/apple.rs index b1d646d9265ff..db3ac530caef3 100644 --- a/compiler/rustc_codegen_ssa/src/back/apple.rs +++ b/compiler/rustc_codegen_ssa/src/back/apple.rs @@ -5,8 +5,8 @@ use std::process::Command; use itertools::Itertools; use rustc_middle::middle::exported_symbols::SymbolExportKind; use rustc_session::Session; -use rustc_target::spec::Target; pub(super) use rustc_target::spec::apple::OSVersion; +use rustc_target::spec::{Architecture, Target}; use tracing::debug; use crate::errors::{XcrunError, XcrunSdkPathWarning}; @@ -95,7 +95,7 @@ pub(super) fn add_data_and_relocation( pointer_width => unimplemented!("unsupported Apple pointer width {pointer_width:?}"), }; - if target.arch == "x86_64" { + if target.arch == Architecture::X86_64 { // Force alignment for the entire section to be 16 on x86_64. file.section_mut(section).append_data(&[], 16); } else { @@ -111,7 +111,7 @@ pub(super) fn add_data_and_relocation( r_pcrel: false, r_length: 3, } - } else if target.arch == "arm" { + } else if target.arch == Architecture::Arm { // FIXME(madsmtm): Remove once `object` supports 32-bit ARM relocations: // https://github.com/gimli-rs/object/pull/757 object::write::RelocationFlags::MachO { diff --git a/compiler/rustc_codegen_ssa/src/back/archive.rs b/compiler/rustc_codegen_ssa/src/back/archive.rs index cfd8ceac3a604..b553e80fb733f 100644 --- a/compiler/rustc_codegen_ssa/src/back/archive.rs +++ b/compiler/rustc_codegen_ssa/src/back/archive.rs @@ -17,6 +17,7 @@ use rustc_fs_util::TempDirBuilder; use rustc_metadata::EncodedMetadata; use rustc_session::Session; use rustc_span::Symbol; +use rustc_target::spec::Architecture; use tracing::trace; use super::metadata::{create_compressed_metadata_file, search_for_section}; @@ -42,7 +43,7 @@ pub struct ImportLibraryItem { impl ImportLibraryItem { fn into_coff_short_export(self, sess: &Session) -> COFFShortExport { - let import_name = (sess.target.arch == "arm64ec").then(|| self.name.clone()); + let import_name = (sess.target.arch == Architecture::Arm64EC).then(|| self.name.clone()); COFFShortExport { name: self.name, ext_name: None, @@ -117,12 +118,12 @@ pub trait ArchiveBuilderBuilder { let exports = items.into_iter().map(|item| item.into_coff_short_export(sess)).collect::>(); - let machine = match &*sess.target.arch { - "x86_64" => MachineTypes::AMD64, - "x86" => MachineTypes::I386, - "aarch64" => MachineTypes::ARM64, - "arm64ec" => MachineTypes::ARM64EC, - "arm" => MachineTypes::ARMNT, + let machine = match sess.target.arch { + Architecture::X86_64 => MachineTypes::AMD64, + Architecture::X86 => MachineTypes::I386, + Architecture::AArch64 => MachineTypes::ARM64, + Architecture::Arm64EC => MachineTypes::ARM64EC, + Architecture::Arm => MachineTypes::ARMNT, cpu => panic!("unsupported cpu type {cpu}"), }; @@ -223,12 +224,12 @@ fn create_mingw_dll_import_lib( }; // dlltool target architecture args from: // https://github.com/llvm/llvm-project-release-prs/blob/llvmorg-15.0.6/llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp#L69 - let (dlltool_target_arch, dlltool_target_bitness) = match sess.target.arch.as_ref() { - "x86_64" => ("i386:x86-64", "--64"), - "x86" => ("i386", "--32"), - "aarch64" => ("arm64", "--64"), - "arm" => ("arm", "--32"), - _ => panic!("unsupported arch {}", sess.target.arch), + let (dlltool_target_arch, dlltool_target_bitness) = match sess.target.arch { + Architecture::X86_64 => ("i386:x86-64", "--64"), + Architecture::X86 => ("i386", "--32"), + Architecture::AArch64 => ("arm64", "--64"), + Architecture::Arm => ("arm", "--32"), + arch => panic!("unsupported arch {arch}"), }; let mut dlltool_cmd = std::process::Command::new(&dlltool); dlltool_cmd @@ -281,10 +282,10 @@ fn find_binutils_dlltool(sess: &Session) -> OsString { "dlltool.exe" } else { // On other platforms, use the architecture-specific name. - match sess.target.arch.as_ref() { - "x86_64" => "x86_64-w64-mingw32-dlltool", - "x86" => "i686-w64-mingw32-dlltool", - "aarch64" => "aarch64-w64-mingw32-dlltool", + match sess.target.arch { + Architecture::X86_64 => "x86_64-w64-mingw32-dlltool", + Architecture::X86 => "i686-w64-mingw32-dlltool", + Architecture::AArch64 => "aarch64-w64-mingw32-dlltool", // For non-standard architectures (e.g., aarch32) fallback to "dlltool". _ => "dlltool", @@ -378,9 +379,9 @@ pub fn try_extract_macho_fat_archive( archive_path: &Path, ) -> io::Result> { let archive_map = unsafe { Mmap::map(File::open(&archive_path)?)? }; - let target_arch = match sess.target.arch.as_ref() { - "aarch64" => object::Architecture::Aarch64, - "x86_64" => object::Architecture::X86_64, + let target_arch = match sess.target.arch { + Architecture::AArch64 => object::Architecture::Aarch64, + Architecture::X86_64 => object::Architecture::X86_64, _ => return Ok(None), }; @@ -531,7 +532,7 @@ impl<'a> ArArchiveBuilder<'a> { &entries, archive_kind, false, - /* is_ec = */ Some(self.sess.target.arch == "arm64ec"), + /* is_ec = */ Some(self.sess.target.arch == Architecture::Arm64EC), )?; archive_tmpfile.flush()?; drop(archive_tmpfile); diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs index ea538d3d46981..1124b0ac1aee5 100644 --- a/compiler/rustc_codegen_ssa/src/back/link.rs +++ b/compiler/rustc_codegen_ssa/src/back/link.rs @@ -883,7 +883,8 @@ fn link_natively( if is_msvc_link_exe && (code < 1000 || code > 9999) { let is_vs_installed = find_msvc_tools::find_vs_version().is_ok(); let has_linker = - find_msvc_tools::find_tool(&sess.target.arch, "link.exe").is_some(); + find_msvc_tools::find_tool(sess.target.arch.desc(), "link.exe") + .is_some(); sess.dcx().emit_note(errors::LinkExeUnexpectedError); diff --git a/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs b/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs index 7321bc1da391a..a152f0993348b 100644 --- a/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs +++ b/compiler/rustc_codegen_ssa/src/back/link/raw_dylib.rs @@ -11,6 +11,7 @@ use rustc_hir::attrs::NativeLibKind; use rustc_session::Session; use rustc_session::cstore::DllImport; use rustc_span::Symbol; +use rustc_target::spec::Architecture; use crate::back::archive::ImportLibraryItem; use crate::back::link::ArchiveBuilderBuilder; @@ -77,7 +78,7 @@ pub(super) fn create_raw_dylib_dll_import_libs<'a>( let items: Vec = raw_dylib_imports .iter() .map(|import: &DllImport| { - if sess.target.arch == "x86" { + if sess.target.arch == Architecture::X86 { ImportLibraryItem { name: common::i686_decorated_name( import, diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs index ac12314373828..270eb859be420 100644 --- a/compiler/rustc_codegen_ssa/src/back/linker.rs +++ b/compiler/rustc_codegen_ssa/src/back/linker.rs @@ -17,7 +17,7 @@ use rustc_middle::middle::exported_symbols::{ use rustc_middle::ty::TyCtxt; use rustc_session::Session; use rustc_session::config::{self, CrateType, DebugInfo, LinkerPluginLto, Lto, OptLevel, Strip}; -use rustc_target::spec::{Cc, LinkOutputKind, LinkerFlavor, Lld}; +use rustc_target::spec::{Architecture, Cc, LinkOutputKind, LinkerFlavor, Lld}; use tracing::{debug, warn}; use super::command::Command; @@ -53,7 +53,7 @@ pub(crate) fn get_linker<'a>( target_cpu: &'a str, codegen_backend: &'static str, ) -> Box { - let msvc_tool = find_msvc_tools::find_tool(&sess.target.arch, "link.exe"); + let msvc_tool = find_msvc_tools::find_tool(sess.target.arch.desc(), "link.exe"); // If our linker looks like a batch script on Windows then to execute this // we'll need to spawn `cmd` explicitly. This is primarily done to handle @@ -87,11 +87,11 @@ pub(crate) fn get_linker<'a>( if let Some(ref tool) = msvc_tool { let original_path = tool.path(); if let Some(root_lib_path) = original_path.ancestors().nth(4) { - let arch = match t.arch.as_ref() { - "x86_64" => Some("x64"), - "x86" => Some("x86"), - "aarch64" => Some("arm64"), - "arm" => Some("arm"), + let arch = match t.arch { + Architecture::X86_64 => Some("x64"), + Architecture::X86 => Some("x86"), + Architecture::AArch64 => Some("arm64"), + Architecture::Arm => Some("arm"), _ => None, }; if let Some(ref a) = arch { @@ -589,7 +589,7 @@ impl<'a> Linker for GccLinker<'a> { // // Currently this makes sense only when using avr-gcc as a linker, since // it brings a couple of hand-written important intrinsics from libgcc. - if self.sess.target.arch == "avr" && !self.uses_lld { + if self.sess.target.arch == Architecture::Avr && !self.uses_lld { self.verbatim_arg(format!("-mmcu={}", self.target_cpu)); } } diff --git a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs index b49e67217fb01..6a02bb438bc0d 100644 --- a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs +++ b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs @@ -15,7 +15,7 @@ use rustc_middle::ty::{self, GenericArgKind, GenericArgsRef, Instance, SymbolNam use rustc_middle::util::Providers; use rustc_session::config::{CrateType, OomStrategy}; use rustc_symbol_mangling::mangle_internal_symbol; -use rustc_target::spec::TlsModel; +use rustc_target::spec::{Architecture, TlsModel}; use tracing::debug; use crate::back::symbol_export; @@ -665,11 +665,11 @@ pub(crate) fn linking_symbol_name_for_instance_in_crate<'tcx>( return undecorated; } - let prefix = match &target.arch[..] { - "x86" => Some('_'), - "x86_64" => None, + let prefix = match target.arch { + Architecture::X86 => Some('_'), + Architecture::X86_64 => None, // Only functions are decorated for arm64ec. - "arm64ec" if export_kind == SymbolExportKind::Text => Some('#'), + Architecture::Arm64EC if export_kind == SymbolExportKind::Text => Some('#'), // Only x86/64 and arm64ec use symbol decorations. _ => return undecorated, }; diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs index ac3bcb1ea269f..3f4d1469616c6 100644 --- a/compiler/rustc_codegen_ssa/src/base.rs +++ b/compiler/rustc_codegen_ssa/src/base.rs @@ -31,6 +31,7 @@ use rustc_session::Session; use rustc_session::config::{self, CrateType, EntryFnType}; use rustc_span::{DUMMY_SP, Symbol, sym}; use rustc_symbol_mangling::mangle_internal_symbol; +use rustc_target::spec::Architecture; use rustc_trait_selection::infer::{BoundRegionConversionTime, TyCtxtInferExt}; use rustc_trait_selection::traits::{ObligationCause, ObligationCtxt}; use tracing::{debug, info}; @@ -975,9 +976,9 @@ impl CrateInfo { // by the compiler, but that's ok because all this stuff is unstable anyway. let target = &tcx.sess.target; if !are_upstream_rust_objects_already_included(tcx.sess) { - let add_prefix = match (target.is_like_windows, target.arch.as_ref()) { - (true, "x86") => |name: String, _: SymbolExportKind| format!("_{name}"), - (true, "arm64ec") => { + let add_prefix = match (target.is_like_windows, target.arch) { + (true, Architecture::X86) => |name: String, _: SymbolExportKind| format!("_{name}"), + (true, Architecture::Arm64EC) => { // Only functions are decorated for arm64ec. |name: String, export_kind: SymbolExportKind| match export_kind { SymbolExportKind::Text => format!("#{name}"), diff --git a/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs b/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs index befa00c6861ed..0a4a5c30e4b3b 100644 --- a/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs +++ b/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs @@ -4,6 +4,7 @@ use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_middle::{bug, span_bug}; use rustc_session::config::OptLevel; use rustc_span::sym; +use rustc_target::spec::Architecture; use super::FunctionCx; use super::operand::OperandRef; @@ -79,7 +80,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { // reinterpretation of values as (chunkable) byte arrays, and the loop in the // block optimization in `ptr::swap_nonoverlapping` is hard to rewrite back // into the (unoptimized) direct swapping implementation, so we disable it. - || bx.sess().target.arch == "spirv" + || bx.sess().target.arch == Architecture::SpirV { let align = pointee_layout.align.abi; let x_place = args[0].val.deref(align); diff --git a/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs b/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs index e7239ebfecf63..7672a060451c4 100644 --- a/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs +++ b/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs @@ -7,7 +7,7 @@ use rustc_middle::ty::{Instance, Ty, TyCtxt, TypeVisitableExt}; use rustc_middle::{bug, ty}; use rustc_span::sym; use rustc_target::callconv::{ArgAbi, FnAbi, PassMode}; -use rustc_target::spec::BinaryFormat; +use rustc_target::spec::{Architecture, BinaryFormat}; use crate::common; use crate::mir::AsmCodegenMethods; @@ -125,7 +125,7 @@ fn prefix_and_suffix<'tcx>( let asm_binary_format = &tcx.sess.target.binary_format; - let is_arm = tcx.sess.target.arch == "arm"; + let is_arm = tcx.sess.target.arch == Architecture::Arm; let is_thumb = tcx.sess.unstable_target_features.contains(&sym::thumb_mode); let attrs = tcx.codegen_instance_attrs(instance.def); diff --git a/compiler/rustc_codegen_ssa/src/target_features.rs b/compiler/rustc_codegen_ssa/src/target_features.rs index 54584999d61b6..5ce5f6bd6bb55 100644 --- a/compiler/rustc_codegen_ssa/src/target_features.rs +++ b/compiler/rustc_codegen_ssa/src/target_features.rs @@ -10,6 +10,7 @@ use rustc_session::Session; use rustc_session::lint::builtin::AARCH64_SOFTFLOAT_NEON; use rustc_session::parse::feature_err; use rustc_span::{Span, Symbol, sym}; +use rustc_target::spec::Architecture; use rustc_target::target_features::{RUSTC_SPECIFIC_FEATURES, Stability}; use smallvec::SmallVec; @@ -73,7 +74,8 @@ pub(crate) fn from_target_feature_attr( if abi_feature_constraints.incompatible.contains(&name.as_str()) { // For "neon" specifically, we emit an FCW instead of a hard error. // See . - if tcx.sess.target.arch == "aarch64" && name.as_str() == "neon" { + if tcx.sess.target.arch == Architecture::AArch64 && name.as_str() == "neon" + { tcx.emit_node_span_lint( AARCH64_SOFTFLOAT_NEON, tcx.local_def_id_to_hir_id(did), diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs index 15572063d45a6..8f85824591353 100644 --- a/compiler/rustc_metadata/src/native_libs.rs +++ b/compiler/rustc_metadata/src/native_libs.rs @@ -15,7 +15,7 @@ use rustc_session::cstore::{DllCallingConvention, DllImport, ForeignModule, Nati use rustc_session::search_paths::PathKind; use rustc_span::Symbol; use rustc_span::def_id::{DefId, LOCAL_CRATE}; -use rustc_target::spec::{BinaryFormat, LinkSelfContainedComponents}; +use rustc_target::spec::{Architecture, BinaryFormat, LinkSelfContainedComponents}; use crate::errors; @@ -393,7 +393,7 @@ impl<'tcx> Collector<'tcx> { // This logic is similar to `AbiMap::canonize_abi` (in rustc_target/src/spec/abi_map.rs) but // we need more detail than those adjustments, and we can't support all ABIs that are // generally supported. - let calling_convention = if self.tcx.sess.target.arch == "x86" { + let calling_convention = if self.tcx.sess.target.arch == Architecture::X86 { match abi { ExternAbi::C { .. } | ExternAbi::Cdecl { .. } => DllCallingConvention::C, ExternAbi::Stdcall { .. } => { diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs index 3c5c21a7a89c2..6e44434035b88 100644 --- a/compiler/rustc_middle/src/ty/context.rs +++ b/compiler/rustc_middle/src/ty/context.rs @@ -52,6 +52,7 @@ use rustc_session::cstore::{CrateStoreDyn, Untracked}; use rustc_session::lint::Lint; use rustc_span::def_id::{CRATE_DEF_ID, DefPathHash, StableCrateId}; use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym}; +use rustc_target::spec::Architecture; use rustc_type_ir::TyKind::*; use rustc_type_ir::lang_items::{SolverAdtLangItem, SolverLangItem, SolverTraitLangItem}; pub use rustc_type_ir::lift::Lift; @@ -2382,7 +2383,7 @@ impl<'tcx> TyCtxt<'tcx> { /// Determines whether identifiers in the assembly have strict naming rules. /// Currently, only NVPTX* targets need it. pub fn has_strict_asm_symbol_naming(self) -> bool { - self.sess.target.arch.contains("nvptx") + matches!(self.sess.target.arch, Architecture::Nvptx64) } /// Returns `&'static core::panic::Location<'static>`. diff --git a/compiler/rustc_session/src/config/cfg.rs b/compiler/rustc_session/src/config/cfg.rs index a72f6201dcea2..4654527490245 100644 --- a/compiler/rustc_session/src/config/cfg.rs +++ b/compiler/rustc_session/src/config/cfg.rs @@ -240,7 +240,7 @@ pub(crate) fn default_configuration(sess: &Session) -> Cfg { } ins_str!(sym::target_abi, &sess.target.abi); - ins_str!(sym::target_arch, &sess.target.arch); + ins_sym!(sym::target_arch, sess.target.arch.desc_symbol()); ins_str!(sym::target_endian, sess.target.endian.as_str()); ins_str!(sym::target_env, &sess.target.env); @@ -448,7 +448,7 @@ impl CheckCfg { for target in Target::builtins().chain(iter::once(current_target.clone())) { values_target_abi.insert(Symbol::intern(&target.options.abi)); - values_target_arch.insert(Symbol::intern(&target.arch)); + values_target_arch.insert(target.arch.desc_symbol()); values_target_endian.insert(Symbol::intern(target.options.endian.as_str())); values_target_env.insert(Symbol::intern(&target.options.env)); values_target_family.extend( diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs index 172672a80fbd7..5d50a5fe747ea 100644 --- a/compiler/rustc_session/src/session.rs +++ b/compiler/rustc_session/src/session.rs @@ -32,7 +32,7 @@ use rustc_span::source_map::{FilePathMapping, SourceMap}; use rustc_span::{FileNameDisplayPreference, RealFileName, Span, Symbol}; use rustc_target::asm::InlineAsmArch; use rustc_target::spec::{ - CodeModel, DebuginfoKind, PanicStrategy, RelocModel, RelroLevel, SanitizerSet, + Architecture, CodeModel, DebuginfoKind, PanicStrategy, RelocModel, RelroLevel, SanitizerSet, SmallDataThresholdSupport, SplitDebuginfo, StackProtector, SymbolVisibility, Target, TargetTuple, TlsModel, apple, }; @@ -1101,7 +1101,7 @@ pub fn build_session( _ => CtfeBacktrace::Disabled, }); - let asm_arch = if target.allow_asm { InlineAsmArch::from_str(&target.arch).ok() } else { None }; + let asm_arch = if target.allow_asm { InlineAsmArch::from_arch(target.arch) } else { None }; let target_filesearch = filesearch::FileSearch::new(&sopts.search_paths, &target_tlib_path, &target); let host_filesearch = filesearch::FileSearch::new(&sopts.search_paths, &host_tlib_path, &host); @@ -1192,7 +1192,7 @@ fn validate_commandline_args_with_session_available(sess: &Session) { let mut unsupported_sanitizers = sess.opts.unstable_opts.sanitizer - supported_sanitizers; // Niche: if `fixed-x18`, or effectively switching on `reserved-x18` flag, is enabled // we should allow Shadow Call Stack sanitizer. - if sess.opts.unstable_opts.fixed_x18 && sess.target.arch == "aarch64" { + if sess.opts.unstable_opts.fixed_x18 && sess.target.arch == Architecture::AArch64 { unsupported_sanitizers -= SanitizerSet::SHADOWCALLSTACK; } match unsupported_sanitizers.into_iter().count() { @@ -1303,7 +1303,9 @@ fn validate_commandline_args_with_session_available(sess: &Session) { } } - if sess.opts.unstable_opts.branch_protection.is_some() && sess.target.arch != "aarch64" { + if sess.opts.unstable_opts.branch_protection.is_some() + && sess.target.arch != Architecture::AArch64 + { sess.dcx().emit_err(errors::BranchProtectionRequiresAArch64); } @@ -1347,13 +1349,13 @@ fn validate_commandline_args_with_session_available(sess: &Session) { } if sess.opts.unstable_opts.function_return != FunctionReturn::default() { - if sess.target.arch != "x86" && sess.target.arch != "x86_64" { + if !matches!(sess.target.arch, Architecture::X86 | Architecture::X86_64) { sess.dcx().emit_err(errors::FunctionReturnRequiresX86OrX8664); } } if sess.opts.unstable_opts.indirect_branch_cs_prefix { - if sess.target.arch != "x86" && sess.target.arch != "x86_64" { + if !matches!(sess.target.arch, Architecture::X86 | Architecture::X86_64) { sess.dcx().emit_err(errors::IndirectBranchCsPrefixRequiresX86OrX8664); } } @@ -1362,12 +1364,12 @@ fn validate_commandline_args_with_session_available(sess: &Session) { if regparm > 3 { sess.dcx().emit_err(errors::UnsupportedRegparm { regparm }); } - if sess.target.arch != "x86" { + if sess.target.arch != Architecture::X86 { sess.dcx().emit_err(errors::UnsupportedRegparmArch); } } if sess.opts.unstable_opts.reg_struct_return { - if sess.target.arch != "x86" { + if sess.target.arch != Architecture::X86 { sess.dcx().emit_err(errors::UnsupportedRegStructReturnArch); } } @@ -1389,7 +1391,7 @@ fn validate_commandline_args_with_session_available(sess: &Session) { } if sess.opts.cg.soft_float { - if sess.target.arch == "arm" { + if sess.target.arch == Architecture::Arm { sess.dcx().emit_warn(errors::SoftFloatDeprecated); } else { // All `use_softfp` does is the equivalent of `-mfloat-abi` in GCC/clang, which only exists on ARM targets. diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index 4f21189f9a7d5..3e4afe7435727 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -400,6 +400,7 @@ symbols! { _t, _task_context, a32, + aarch64, aarch64_target_feature, aarch64_unstable_target_feature, aarch64_ver_target_feature, @@ -449,6 +450,7 @@ symbols! { altivec, alu32, always, + amdgpu, analysis, and, and_then, @@ -466,6 +468,7 @@ symbols! { args, arith_offset, arm, + arm64ec, arm_target_feature, array, as_dash_needed: "as-needed", @@ -554,6 +557,7 @@ symbols! { autodiff_reverse, automatically_derived, available_externally, + avr, avx, avx10_target_feature, avx512_target_feature, @@ -586,6 +590,7 @@ symbols! { box_patterns, box_syntax, boxed_slice, + bpf, bpf_target_feature, braced_empty_structs, branch, @@ -790,6 +795,7 @@ symbols! { crate_type, crate_visibility_modifier, crt_dash_static: "crt-static", + csky, csky_target_feature, cstr_type, cstring_as_c_str, @@ -1156,6 +1162,7 @@ symbols! { hashset_drain_ty, hashset_iter, hashset_iter_ty, + hexagon, hexagon_target_feature, hidden, hide, @@ -1342,11 +1349,14 @@ symbols! { logf32, logf64, logf128, + loongarch32, + loongarch64, loongarch_target_feature, loop_break_value, loop_match, lr, lt, + m68k, m68k_target_feature, macro_at_most_once_rep, macro_attr, @@ -1420,6 +1430,10 @@ symbols! { minnumf32, minnumf64, minnumf128, + mips, + mips32r6, + mips64, + mips64r6, mips_target_feature, mir_assume, mir_basic_block, @@ -1468,6 +1482,7 @@ symbols! { move_ref_pattern, move_size_limit, movrs_target_feature, + msp430, mul, mul_assign, mul_with_overflow, @@ -1554,6 +1569,7 @@ symbols! { not, notable_trait, note, + nvptx64, nvptx_target_feature, object_safe_for_dispatch, of, @@ -1678,6 +1694,9 @@ symbols! { post_cleanup: "post-cleanup", post_dash_lto: "post-lto", postfix_match, + powerpc, + powerpc64, + powerpc64le, powerpc_target_feature, powf16, powf32, @@ -1825,6 +1844,8 @@ symbols! { resume, return_position_impl_trait_in_trait, return_type_notation, + riscv32, + riscv64, riscv_target_feature, rlib, ropi, @@ -1971,6 +1992,7 @@ symbols! { rvalue_static_promotion, rwpi, s, + s390x, s390x_target_feature, safety, sanitize, @@ -2099,9 +2121,12 @@ symbols! { slice_patterns, slicing_syntax, soft, + sparc, + sparc64, sparc_target_feature, specialization, speed, + spirv, spotlight, sqrtf16, sqrtf32, @@ -2415,6 +2440,8 @@ symbols! { vtable_size, warn, wasip2, + wasm32, + wasm64, wasm_abi, wasm_import_module, wasm_target_feature, @@ -2441,12 +2468,15 @@ symbols! { write_str, write_via_move, writeln_macro, + x86, + x86_64, x86_amx_intrinsics, x87_reg, x87_target_feature, xer, xmm_reg, xop_target_feature, + xtensa, yeet_desugar_details, yeet_expr, yes, diff --git a/compiler/rustc_target/src/asm/mod.rs b/compiler/rustc_target/src/asm/mod.rs index 0601613567ead..045ef72f79625 100644 --- a/compiler/rustc_target/src/asm/mod.rs +++ b/compiler/rustc_target/src/asm/mod.rs @@ -1,12 +1,11 @@ use std::fmt; -use std::str::FromStr; use rustc_abi::Size; use rustc_data_structures::fx::{FxHashMap, FxIndexSet}; use rustc_macros::{Decodable, Encodable, HashStable_Generic}; use rustc_span::Symbol; -use crate::spec::{RelocModel, Target}; +use crate::spec::{Architecture, RelocModel, Target}; pub struct ModifierInfo { pub modifier: char, @@ -245,38 +244,36 @@ pub enum InlineAsmArch { CSKY, } -impl FromStr for InlineAsmArch { - type Err = (); - - fn from_str(s: &str) -> Result { - match s { - "x86" => Ok(Self::X86), - "x86_64" => Ok(Self::X86_64), - "arm" => Ok(Self::Arm), - "aarch64" => Ok(Self::AArch64), - "arm64ec" => Ok(Self::Arm64EC), - "riscv32" => Ok(Self::RiscV32), - "riscv64" => Ok(Self::RiscV64), - "nvptx64" => Ok(Self::Nvptx64), - "powerpc" => Ok(Self::PowerPC), - "powerpc64" => Ok(Self::PowerPC64), - "hexagon" => Ok(Self::Hexagon), - "loongarch32" => Ok(Self::LoongArch32), - "loongarch64" => Ok(Self::LoongArch64), - "mips" | "mips32r6" => Ok(Self::Mips), - "mips64" | "mips64r6" => Ok(Self::Mips64), - "s390x" => Ok(Self::S390x), - "sparc" => Ok(Self::Sparc), - "sparc64" => Ok(Self::Sparc64), - "spirv" => Ok(Self::SpirV), - "wasm32" => Ok(Self::Wasm32), - "wasm64" => Ok(Self::Wasm64), - "bpf" => Ok(Self::Bpf), - "avr" => Ok(Self::Avr), - "msp430" => Ok(Self::Msp430), - "m68k" => Ok(Self::M68k), - "csky" => Ok(Self::CSKY), - _ => Err(()), +impl InlineAsmArch { + pub fn from_arch(arch: Architecture) -> Option { + match arch { + Architecture::X86 => Some(Self::X86), + Architecture::X86_64 => Some(Self::X86_64), + Architecture::Arm => Some(Self::Arm), + Architecture::Arm64EC => Some(Self::Arm64EC), + Architecture::AArch64 => Some(Self::AArch64), + Architecture::RiscV32 => Some(Self::RiscV32), + Architecture::RiscV64 => Some(Self::RiscV64), + Architecture::Nvptx64 => Some(Self::Nvptx64), + Architecture::Hexagon => Some(Self::Hexagon), + Architecture::LoongArch32 => Some(Self::LoongArch32), + Architecture::LoongArch64 => Some(Self::LoongArch64), + Architecture::Mips | Architecture::Mips32r6 => Some(Self::Mips), + Architecture::Mips64 | Architecture::Mips64r6 => Some(Self::Mips64), + Architecture::PowerPC => Some(Self::PowerPC), + Architecture::PowerPC64 | Architecture::PowerPC64LE => Some(Self::PowerPC64), + Architecture::S390x => Some(Self::S390x), + Architecture::Sparc => Some(Self::Sparc), + Architecture::Sparc64 => Some(Self::Sparc64), + Architecture::SpirV => Some(Self::SpirV), + Architecture::Wasm32 => Some(Self::Wasm32), + Architecture::Wasm64 => Some(Self::Wasm64), + Architecture::Bpf => Some(Self::Bpf), + Architecture::Avr => Some(Self::Avr), + Architecture::Msp430 => Some(Self::Msp430), + Architecture::M68k => Some(Self::M68k), + Architecture::CSKY => Some(Self::CSKY), + Architecture::AmdGpu | Architecture::Xtensa => None, } } } diff --git a/compiler/rustc_target/src/callconv/mod.rs b/compiler/rustc_target/src/callconv/mod.rs index c59af581a1fe4..0101db8447c76 100644 --- a/compiler/rustc_target/src/callconv/mod.rs +++ b/compiler/rustc_target/src/callconv/mod.rs @@ -7,7 +7,7 @@ use rustc_abi::{ use rustc_macros::HashStable_Generic; pub use crate::spec::AbiMap; -use crate::spec::{HasTargetSpec, HasX86AbiOpt}; +use crate::spec::{Architecture, HasTargetSpec, HasX86AbiOpt}; mod aarch64; mod amdgpu; @@ -632,8 +632,8 @@ impl<'a, Ty> FnAbi<'a, Ty> { } let spec = cx.target_spec(); - match &spec.arch[..] { - "x86" => { + match spec.arch { + Architecture::X86 => { let (flavor, regparm) = match abi { ExternAbi::Fastcall { .. } | ExternAbi::Vectorcall { .. } => { (x86::Flavor::FastcallOrVectorcall, None) @@ -651,7 +651,7 @@ impl<'a, Ty> FnAbi<'a, Ty> { x86::compute_abi_info(cx, self, opts); } } - "x86_64" => match abi { + Architecture::X86_64 => match abi { ExternAbi::SysV64 { .. } => x86_64::compute_abi_info(cx, self), ExternAbi::Win64 { .. } | ExternAbi::Vectorcall { .. } => { x86_win64::compute_abi_info(cx, self) @@ -664,7 +664,7 @@ impl<'a, Ty> FnAbi<'a, Ty> { } } }, - "aarch64" | "arm64ec" => { + Architecture::AArch64 | Architecture::Arm64EC => { let kind = if cx.target_spec().is_like_darwin { aarch64::AbiKind::DarwinPCS } else if cx.target_spec().is_like_windows { @@ -674,33 +674,37 @@ impl<'a, Ty> FnAbi<'a, Ty> { }; aarch64::compute_abi_info(cx, self, kind) } - "amdgpu" => amdgpu::compute_abi_info(cx, self), - "arm" => arm::compute_abi_info(cx, self), - "avr" => avr::compute_abi_info(self), - "loongarch32" | "loongarch64" => loongarch::compute_abi_info(cx, self), - "m68k" => m68k::compute_abi_info(self), - "csky" => csky::compute_abi_info(self), - "mips" | "mips32r6" => mips::compute_abi_info(cx, self), - "mips64" | "mips64r6" => mips64::compute_abi_info(cx, self), - "powerpc" => powerpc::compute_abi_info(cx, self), - "powerpc64" => powerpc64::compute_abi_info(cx, self), - "s390x" => s390x::compute_abi_info(cx, self), - "msp430" => msp430::compute_abi_info(self), - "sparc" => sparc::compute_abi_info(cx, self), - "sparc64" => sparc64::compute_abi_info(cx, self), - "nvptx64" => { + Architecture::AmdGpu => amdgpu::compute_abi_info(cx, self), + Architecture::Arm => arm::compute_abi_info(cx, self), + Architecture::Avr => avr::compute_abi_info(self), + Architecture::LoongArch32 | Architecture::LoongArch64 => { + loongarch::compute_abi_info(cx, self) + } + Architecture::M68k => m68k::compute_abi_info(self), + Architecture::CSKY => csky::compute_abi_info(self), + Architecture::Mips | Architecture::Mips32r6 => mips::compute_abi_info(cx, self), + Architecture::Mips64 | Architecture::Mips64r6 => mips64::compute_abi_info(cx, self), + Architecture::PowerPC => powerpc::compute_abi_info(cx, self), + Architecture::PowerPC64 => powerpc64::compute_abi_info(cx, self), + Architecture::S390x => s390x::compute_abi_info(cx, self), + Architecture::Msp430 => msp430::compute_abi_info(self), + Architecture::Sparc => sparc::compute_abi_info(cx, self), + Architecture::Sparc64 => sparc64::compute_abi_info(cx, self), + Architecture::Nvptx64 => { if abi == ExternAbi::PtxKernel || abi == ExternAbi::GpuKernel { nvptx64::compute_ptx_kernel_abi_info(cx, self) } else { nvptx64::compute_abi_info(self) } } - "hexagon" => hexagon::compute_abi_info(self), - "xtensa" => xtensa::compute_abi_info(cx, self), - "riscv32" | "riscv64" => riscv::compute_abi_info(cx, self), - "wasm32" | "wasm64" => wasm::compute_abi_info(cx, self), - "bpf" => bpf::compute_abi_info(self), - arch => panic!("no lowering implemented for {arch}"), + Architecture::Hexagon => hexagon::compute_abi_info(self), + Architecture::Xtensa => xtensa::compute_abi_info(cx, self), + Architecture::RiscV32 | Architecture::RiscV64 => riscv::compute_abi_info(cx, self), + Architecture::Wasm32 | Architecture::Wasm64 => wasm::compute_abi_info(cx, self), + Architecture::Bpf => bpf::compute_abi_info(self), + arch @ (Architecture::PowerPC64LE | Architecture::SpirV) => { + panic!("no lowering implemented for {arch}") + } } } @@ -710,11 +714,13 @@ impl<'a, Ty> FnAbi<'a, Ty> { C: HasDataLayout + HasTargetSpec, { let spec = cx.target_spec(); - match &*spec.arch { - "x86" => x86::compute_rust_abi_info(cx, self), - "riscv32" | "riscv64" => riscv::compute_rust_abi_info(cx, self), - "loongarch32" | "loongarch64" => loongarch::compute_rust_abi_info(cx, self), - "aarch64" => aarch64::compute_rust_abi_info(cx, self), + match spec.arch { + Architecture::X86 => x86::compute_rust_abi_info(cx, self), + Architecture::RiscV32 | Architecture::RiscV64 => riscv::compute_rust_abi_info(cx, self), + Architecture::LoongArch32 | Architecture::LoongArch64 => { + loongarch::compute_rust_abi_info(cx, self) + } + Architecture::AArch64 => aarch64::compute_rust_abi_info(cx, self), _ => {} }; diff --git a/compiler/rustc_target/src/spec/abi_map.rs b/compiler/rustc_target/src/spec/abi_map.rs index 23e74539ddc07..5342e3034fea3 100644 --- a/compiler/rustc_target/src/spec/abi_map.rs +++ b/compiler/rustc_target/src/spec/abi_map.rs @@ -1,6 +1,6 @@ use rustc_abi::{ArmCall, CanonAbi, ExternAbi, InterruptKind, X86Call}; -use crate::spec::Target; +use crate::spec::{Architecture, Target}; /// Mapping for ExternAbi to CanonAbi according to a Target /// @@ -47,17 +47,20 @@ impl AbiMap { /// create an AbiMap according to arbitrary fields on the [Target] pub fn from_target(target: &Target) -> Self { // the purpose of this little exercise is to force listing what affects these mappings - let arch = match &*target.arch { - "aarch64" => Arch::Aarch64, - "amdgpu" => Arch::Amdgpu, - "arm" if target.llvm_target.starts_with("thumbv8m") => Arch::Arm(ArmVer::ThumbV8M), - "arm" => Arch::Arm(ArmVer::Other), - "avr" => Arch::Avr, - "msp430" => Arch::Msp430, - "nvptx64" => Arch::Nvptx, - "riscv32" | "riscv64" => Arch::Riscv, - "x86" => Arch::X86, - "x86_64" => Arch::X86_64, + let arch = match target.arch { + Architecture::AArch64 => Arch::Aarch64, + Architecture::AmdGpu => Arch::Amdgpu, + Architecture::Arm => Arch::Arm(if target.llvm_target.starts_with("thumbv8m") { + ArmVer::ThumbV8M + } else { + ArmVer::Other + }), + Architecture::Avr => Arch::Avr, + Architecture::Msp430 => Arch::Msp430, + Architecture::Nvptx64 => Arch::Nvptx, + Architecture::RiscV32 | Architecture::RiscV64 => Arch::Riscv, + Architecture::X86 => Arch::X86, + Architecture::X86_64 => Arch::X86_64, _ => Arch::Other, }; diff --git a/compiler/rustc_target/src/spec/base/apple/mod.rs b/compiler/rustc_target/src/spec/base/apple/mod.rs index c32e333eb8b02..15844df7ddc0a 100644 --- a/compiler/rustc_target/src/spec/base/apple/mod.rs +++ b/compiler/rustc_target/src/spec/base/apple/mod.rs @@ -4,8 +4,8 @@ use std::num::ParseIntError; use std::str::FromStr; use crate::spec::{ - BinaryFormat, Cc, DebuginfoKind, FloatAbi, FramePointer, LinkerFlavor, Lld, RustcAbi, - SplitDebuginfo, StackProbeType, StaticCow, Target, TargetOptions, cvs, + Architecture, BinaryFormat, Cc, DebuginfoKind, FloatAbi, FramePointer, LinkerFlavor, Lld, + RustcAbi, SplitDebuginfo, StackProbeType, StaticCow, Target, TargetOptions, cvs, }; #[cfg(test)] @@ -41,13 +41,13 @@ impl Arch { } } - pub(crate) fn target_arch(self) -> Cow<'static, str> { - Cow::Borrowed(match self { - Armv7k | Armv7s => "arm", - Arm64 | Arm64e | Arm64_32 => "aarch64", - I386 | I686 => "x86", - X86_64 | X86_64h => "x86_64", - }) + pub(crate) fn target_arch(self) -> Architecture { + match self { + Armv7k | Armv7s => Architecture::Arm, + Arm64 | Arm64e | Arm64_32 => Architecture::AArch64, + I386 | I686 => Architecture::X86, + X86_64 | X86_64h => Architecture::X86_64, + } } fn target_cpu(self, env: TargetEnv) -> &'static str { @@ -104,7 +104,7 @@ pub(crate) fn base( os: &'static str, arch: Arch, env: TargetEnv, -) -> (TargetOptions, StaticCow, StaticCow) { +) -> (TargetOptions, StaticCow, Architecture) { let mut opts = TargetOptions { llvm_floatabi: Some(FloatAbi::Hard), os: os.into(), @@ -306,18 +306,22 @@ impl OSVersion { /// This matches what LLVM does, see in part: /// pub fn minimum_deployment_target(target: &Target) -> Self { - let (major, minor, patch) = match (&*target.os, &*target.arch, &*target.env) { - ("macos", "aarch64", _) => (11, 0, 0), - ("ios", "aarch64", "macabi") => (14, 0, 0), - ("ios", "aarch64", "sim") => (14, 0, 0), + let (major, minor, patch) = match (&*target.os, target.arch, &*target.env) { + ("macos", Architecture::AArch64, _) => (11, 0, 0), + ("ios", Architecture::AArch64, "macabi") => (14, 0, 0), + ("ios", Architecture::AArch64, "sim") => (14, 0, 0), ("ios", _, _) if target.llvm_target.starts_with("arm64e") => (14, 0, 0), // Mac Catalyst defaults to 13.1 in Clang. ("ios", _, "macabi") => (13, 1, 0), - ("tvos", "aarch64", "sim") => (14, 0, 0), - ("watchos", "aarch64", "sim") => (7, 0, 0), + ("tvos", Architecture::AArch64, "sim") => (14, 0, 0), + ("watchos", Architecture::AArch64, "sim") => (7, 0, 0), // True Aarch64 on watchOS (instead of their Aarch64 Ilp32 called `arm64_32`) has been // available since Xcode 14, but it's only actually used more recently in watchOS 26. - ("watchos", "aarch64", "") if !target.llvm_target.starts_with("arm64_32") => (26, 0, 0), + ("watchos", Architecture::AArch64, "") + if !target.llvm_target.starts_with("arm64_32") => + { + (26, 0, 0) + } (os, _, _) => return Self::os_minimum_deployment_target(os), }; Self { major, minor, patch } diff --git a/compiler/rustc_target/src/spec/base/nto_qnx.rs b/compiler/rustc_target/src/spec/base/nto_qnx.rs index 3f35b8b801ab9..ad9437cf591e9 100644 --- a/compiler/rustc_target/src/spec/base/nto_qnx.rs +++ b/compiler/rustc_target/src/spec/base/nto_qnx.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkArgs, LinkerFlavor, Lld, RelroLevel, Target, TargetMetadata, TargetOptions, cvs, + Architecture, Cc, LinkArgs, LinkerFlavor, Lld, RelroLevel, Target, TargetMetadata, + TargetOptions, cvs, }; pub(crate) fn opts() -> TargetOptions { @@ -38,7 +39,7 @@ pub(crate) fn aarch64() -> Target { // n32:64 = 32 and 64 are native integer widths; Elements of this set are considered to support most general arithmetic operations efficiently. // S128 = 128 bits are the natural alignment of the stack in bits. data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { features: "+v8a".into(), max_atomic_width: Some(128), @@ -54,7 +55,7 @@ pub(crate) fn x86_64() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: TargetOptions { cpu: "x86-64".into(), plt_by_default: false, diff --git a/compiler/rustc_target/src/spec/json.rs b/compiler/rustc_target/src/spec/json.rs index f236be92b3b60..e2002625be72a 100644 --- a/compiler/rustc_target/src/spec/json.rs +++ b/compiler/rustc_target/src/spec/json.rs @@ -5,7 +5,7 @@ use rustc_abi::{Align, AlignFromBytesError}; use super::crt_objects::CrtObjects; use super::{ - BinaryFormat, CodeModel, DebuginfoKind, FloatAbi, FramePointer, LinkArgsCli, + Architecture, BinaryFormat, CodeModel, DebuginfoKind, FloatAbi, FramePointer, LinkArgsCli, LinkSelfContainedComponents, LinkSelfContainedDefault, LinkerFlavorCli, LldFlavor, MergeFunctions, PanicStrategy, RelocModel, RelroLevel, RustcAbi, SanitizerSet, SmallDataThresholdSupport, SplitDebuginfo, StackProbeType, StaticCow, SymbolVisibility, Target, @@ -486,7 +486,7 @@ struct TargetSpecJson { llvm_target: StaticCow, target_pointer_width: u16, data_layout: StaticCow, - arch: StaticCow, + arch: Architecture, metadata: Option, diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs index 1638c87c9ca9a..b640101790207 100644 --- a/compiler/rustc_target/src/spec/mod.rs +++ b/compiler/rustc_target/src/spec/mod.rs @@ -1840,6 +1840,82 @@ enum TargetKind { Builtin, } +crate::target_spec_enum! { + pub enum Architecture { + AArch64 = "aarch64", + AmdGpu = "amdgpu", + Arm = "arm", + Arm64EC = "arm64ec", + Avr = "avr", + Bpf = "bpf", + CSKY = "csky", + Hexagon = "hexagon", + LoongArch32 = "loongarch32", + LoongArch64 = "loongarch64", + M68k = "m68k", + Mips = "mips", + Mips32r6 = "mips32r6", + Mips64 = "mips64", + Mips64r6 = "mips64r6", + Msp430 = "msp430", + Nvptx64 = "nvptx64", + PowerPC = "powerpc", + PowerPC64 = "powerpc64", + PowerPC64LE = "powerpc64le", + RiscV32 = "riscv32", + RiscV64 = "riscv64", + S390x = "s390x", + Sparc = "sparc", + Sparc64 = "sparc64", + SpirV = "spirv", + Wasm32 = "wasm32", + Wasm64 = "wasm64", + X86 = "x86", + X86_64 = "x86_64", + Xtensa = "xtensa", + } + + parse_error_type = "architecture"; +} + +impl Architecture { + pub const fn desc_symbol(&self) -> Symbol { + match self { + Self::AArch64 => sym::aarch64, + Self::AmdGpu => sym::amdgpu, + Self::Arm => sym::arm, + Self::Arm64EC => sym::arm64ec, + Self::Avr => sym::avr, + Self::Bpf => sym::bpf, + Self::CSKY => sym::csky, + Self::Hexagon => sym::hexagon, + Self::LoongArch32 => sym::loongarch32, + Self::LoongArch64 => sym::loongarch64, + Self::M68k => sym::m68k, + Self::Mips => sym::mips, + Self::Mips32r6 => sym::mips32r6, + Self::Mips64 => sym::mips64, + Self::Mips64r6 => sym::mips64r6, + Self::Msp430 => sym::msp430, + Self::Nvptx64 => sym::nvptx64, + Self::PowerPC => sym::powerpc, + Self::PowerPC64 => sym::powerpc64, + Self::PowerPC64LE => sym::powerpc64le, + Self::RiscV32 => sym::riscv32, + Self::RiscV64 => sym::riscv64, + Self::S390x => sym::s390x, + Self::Sparc => sym::sparc, + Self::Sparc64 => sym::sparc64, + Self::SpirV => sym::spirv, + Self::Wasm32 => sym::wasm32, + Self::Wasm64 => sym::wasm64, + Self::X86 => sym::x86, + Self::X86_64 => sym::x86_64, + Self::Xtensa => sym::xtensa, + } + } +} + /// Everything `rustc` knows about how to compile for a specific target. /// /// Every field here must be specified, and has no default value. @@ -1859,7 +1935,7 @@ pub struct Target { pub pointer_width: u16, /// Architecture to use for ABI considerations. Valid options include: "x86", /// "x86_64", "arm", "aarch64", "mips", "powerpc", "powerpc64", and others. - pub arch: StaticCow, + pub arch: Architecture, /// [Data layout](https://llvm.org/docs/LangRef.html#data-layout) to pass to LLVM. pub data_layout: StaticCow, /// Optional settings with defaults. @@ -2665,7 +2741,7 @@ impl Target { ); check_eq!( self.is_like_wasm, - self.arch == "wasm32" || self.arch == "wasm64", + matches!(self.arch, Architecture::Wasm32 | Architecture::Wasm64), "`is_like_wasm` must be set if and only if `arch` is `wasm32` or `wasm64`" ); if self.is_like_msvc { @@ -2697,12 +2773,12 @@ impl Target { "`linker_flavor` must be `em-cc` if and only if `os` is `emscripten`" ); check_eq!( - self.arch == "bpf", + matches!(self.arch, Architecture::Bpf), matches!(self.linker_flavor, LinkerFlavor::Bpf), "`linker_flavor` must be `bpf` if and only if `arch` is `bpf`" ); check_eq!( - self.arch == "nvptx64", + matches!(self.arch, Architecture::Nvptx64), matches!(self.linker_flavor, LinkerFlavor::Ptx), "`linker_flavor` must be `ptc` if and only if `arch` is `nvptx64`" ); @@ -2716,7 +2792,7 @@ impl Target { ] { for (&flavor, flavor_args) in args { check!( - !flavor_args.is_empty() || self.arch == "avr", + !flavor_args.is_empty() || matches!(self.arch, Architecture::Avr), "linker flavor args must not be empty" ); // Check that flavors mentioned in link args are compatible with the default flavor. @@ -2839,10 +2915,13 @@ impl Target { // hexagon: when targeting QuRT, that OS can load dynamic libraries. // wasm{32,64}: dynamic linking is inherent in the definition of the VM. if self.os == "none" - && (self.arch != "bpf" - && self.arch != "hexagon" - && self.arch != "wasm32" - && self.arch != "wasm64") + && !matches!( + self.arch, + Architecture::Bpf + | Architecture::Hexagon + | Architecture::Wasm32 + | Architecture::Wasm64 + ) { check!( !self.dynamic_linking, @@ -2905,8 +2984,8 @@ impl Target { // Check that RISC-V targets always specify which ABI they use, // and that ARM targets specify their float ABI. - match &*self.arch { - "riscv32" => { + match self.arch { + Architecture::RiscV32 => { check_matches!( &*self.llvm_abiname, "ilp32" | "ilp32f" | "ilp32d" | "ilp32e", @@ -2914,7 +2993,7 @@ impl Target { self.llvm_abiname, ); } - "riscv64" => { + Architecture::RiscV64 => { // Note that the `lp64e` is still unstable as it's not (yet) part of the ELF psABI. check_matches!( &*self.llvm_abiname, @@ -2923,7 +3002,7 @@ impl Target { self.llvm_abiname, ); } - "arm" => { + Architecture::Arm => { check!( self.llvm_floatabi.is_some(), "ARM targets must set `llvm-floatabi` to `hard` or `soft`", @@ -2936,13 +3015,13 @@ impl Target { if let Some(rust_abi) = self.rustc_abi { match rust_abi { RustcAbi::X86Sse2 => check_matches!( - &*self.arch, - "x86", + self.arch, + Architecture::X86, "`x86-sse2` ABI is only valid for x86-32 targets" ), RustcAbi::X86Softfloat => check_matches!( - &*self.arch, - "x86" | "x86_64", + self.arch, + Architecture::X86 | Architecture::X86_64, "`x86-softfloat` ABI is only valid for x86 targets" ), } @@ -3109,15 +3188,17 @@ impl Target { // Avoid having to duplicate the small data support in every // target file by supporting a default value for each // architecture. - SmallDataThresholdSupport::DefaultForArch => match self.arch.as_ref() { - "mips" | "mips64" | "mips32r6" => { + SmallDataThresholdSupport::DefaultForArch => match self.arch { + Architecture::Mips | Architecture::Mips64 | Architecture::Mips32r6 => { SmallDataThresholdSupport::LlvmArg("mips-ssection-threshold".into()) } - "hexagon" => { + Architecture::Hexagon => { SmallDataThresholdSupport::LlvmArg("hexagon-small-data-threshold".into()) } - "m68k" => SmallDataThresholdSupport::LlvmArg("m68k-ssection-threshold".into()), - "riscv32" | "riscv64" => { + Architecture::M68k => { + SmallDataThresholdSupport::LlvmArg("m68k-ssection-threshold".into()) + } + Architecture::RiscV32 | Architecture::RiscV64 => { SmallDataThresholdSupport::LlvmModuleFlag("SmallDataLimit".into()) } _ => SmallDataThresholdSupport::None, @@ -3130,67 +3211,72 @@ impl Target { &self, unstable_target_features: &FxIndexSet, ) -> Option<(object::Architecture, Option)> { - use object::Architecture; - Some(match self.arch.as_ref() { - "arm" => (Architecture::Arm, None), - "aarch64" => ( + Some(match self.arch { + Architecture::Arm => (object::Architecture::Arm, None), + Architecture::AArch64 => ( if self.pointer_width == 32 { - Architecture::Aarch64_Ilp32 + object::Architecture::Aarch64_Ilp32 } else { - Architecture::Aarch64 + object::Architecture::Aarch64 }, None, ), - "x86" => (Architecture::I386, None), - "s390x" => (Architecture::S390x, None), - "m68k" => (Architecture::M68k, None), - "mips" | "mips32r6" => (Architecture::Mips, None), - "mips64" | "mips64r6" => ( + Architecture::X86 => (object::Architecture::I386, None), + Architecture::S390x => (object::Architecture::S390x, None), + Architecture::M68k => (object::Architecture::M68k, None), + Architecture::Mips | Architecture::Mips32r6 => (object::Architecture::Mips, None), + Architecture::Mips64 | Architecture::Mips64r6 => ( // While there are currently no builtin targets // using the N32 ABI, it is possible to specify // it using a custom target specification. N32 // is an ILP32 ABI like the Aarch64_Ilp32 // and X86_64_X32 cases above and below this one. if self.options.llvm_abiname.as_ref() == "n32" { - Architecture::Mips64_N32 + object::Architecture::Mips64_N32 } else { - Architecture::Mips64 + object::Architecture::Mips64 }, None, ), - "x86_64" => ( + Architecture::X86_64 => ( if self.pointer_width == 32 { - Architecture::X86_64_X32 + object::Architecture::X86_64_X32 } else { - Architecture::X86_64 + object::Architecture::X86_64 }, None, ), - "powerpc" => (Architecture::PowerPc, None), - "powerpc64" => (Architecture::PowerPc64, None), - "riscv32" => (Architecture::Riscv32, None), - "riscv64" => (Architecture::Riscv64, None), - "sparc" => { + Architecture::PowerPC => (object::Architecture::PowerPc, None), + Architecture::PowerPC64 => (object::Architecture::PowerPc64, None), + Architecture::RiscV32 => (object::Architecture::Riscv32, None), + Architecture::RiscV64 => (object::Architecture::Riscv64, None), + Architecture::Sparc => { if unstable_target_features.contains(&sym::v8plus) { // Target uses V8+, aka EM_SPARC32PLUS, aka 64-bit V9 but in 32-bit mode - (Architecture::Sparc32Plus, None) + (object::Architecture::Sparc32Plus, None) } else { // Target uses V7 or V8, aka EM_SPARC - (Architecture::Sparc, None) + (object::Architecture::Sparc, None) } } - "sparc64" => (Architecture::Sparc64, None), - "avr" => (Architecture::Avr, None), - "msp430" => (Architecture::Msp430, None), - "hexagon" => (Architecture::Hexagon, None), - "xtensa" => (Architecture::Xtensa, None), - "bpf" => (Architecture::Bpf, None), - "loongarch32" => (Architecture::LoongArch32, None), - "loongarch64" => (Architecture::LoongArch64, None), - "csky" => (Architecture::Csky, None), - "arm64ec" => (Architecture::Aarch64, Some(object::SubArchitecture::Arm64EC)), - // Unsupported architecture. - _ => return None, + Architecture::Sparc64 => (object::Architecture::Sparc64, None), + Architecture::Avr => (object::Architecture::Avr, None), + Architecture::Msp430 => (object::Architecture::Msp430, None), + Architecture::Hexagon => (object::Architecture::Hexagon, None), + Architecture::Xtensa => (object::Architecture::Xtensa, None), + Architecture::Bpf => (object::Architecture::Bpf, None), + Architecture::LoongArch32 => (object::Architecture::LoongArch32, None), + Architecture::LoongArch64 => (object::Architecture::LoongArch64, None), + Architecture::CSKY => (object::Architecture::Csky, None), + Architecture::Arm64EC => { + (object::Architecture::Aarch64, Some(object::SubArchitecture::Arm64EC)) + } + Architecture::AmdGpu + | Architecture::Nvptx64 + | Architecture::PowerPC64LE + | Architecture::SpirV + | Architecture::Wasm32 + | Architecture::Wasm64 => return None, }) } @@ -3206,7 +3292,7 @@ impl Target { // FIXME(#112480) MSVC on x86-32 is unsound and fails to properly align many types with // more-than-4-byte-alignment on the stack. This makes alignments larger than 4 generally // unreliable on 32bit Windows. - if self.is_like_windows && self.arch == "x86" { + if self.is_like_windows && matches!(self.arch, Architecture::X86) { Align::from_bytes(4).unwrap() } else { Align::MAX diff --git a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_hermit.rs b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_hermit.rs index cad57abc2b1e0..ffa61a362ff7a 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_hermit.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_hermit.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, StackProbeType, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -12,7 +12,7 @@ pub(crate) fn target() -> Target { std: Some(true), }, pointer_width: 64, - arch: "aarch64".into(), + arch: Architecture::AArch64, data_layout: "E-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), options: TargetOptions { features: "+v8a,+strict-align,+neon,+fp-armv8".into(), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu.rs index 4b75a6e5dbf61..72919f15ae33c 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu.rs @@ -1,6 +1,8 @@ use rustc_abi::Endian; -use crate::spec::{FramePointer, StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, FramePointer, StackProbeType, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -13,7 +15,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { features: "+v8a,+outline-atomics".into(), // the AAPCS64 expects use of non-leaf frame pointers per diff --git a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu_ilp32.rs b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu_ilp32.rs index 2a16d1de3b51f..ae79336b04e31 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu_ilp32.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_gnu_ilp32.rs @@ -1,6 +1,8 @@ use rustc_abi::Endian; -use crate::spec::{FramePointer, StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, FramePointer, StackProbeType, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { let mut base = base::linux_gnu::opts(); @@ -16,7 +18,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { abi: "ilp32".into(), features: "+v8a,+outline-atomics".into(), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_musl.rs index be5ac4a843baf..e8d80678ae1b9 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_linux_musl.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - FramePointer, SanitizerSet, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, FramePointer, SanitizerSet, StackProbeType, Target, TargetMetadata, + TargetOptions, base, }; pub(crate) fn target() -> Target { @@ -26,7 +27,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { // the AAPCS64 expects use of non-leaf frame pointers per // https://github.com/ARM-software/abi-aa/blob/4492d1570eb70c8fd146623e0db65b2d241f12e7/aapcs64/aapcs64.rst#the-frame-pointer diff --git a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_netbsd.rs index 97742403c78ff..1fd3c79002279 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_netbsd.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, StackProbeType, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { mcount: "__mcount".into(), max_atomic_width: Some(128), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_none_softfloat.rs index 7f918e8508094..b1f8d44458e35 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_none_softfloat.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_be_unknown_none_softfloat.rs @@ -8,8 +8,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, Target, - TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, + Target, TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -37,7 +37,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: opts, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_kmc_solid_asp3.rs b/compiler/rustc_target/src/spec/targets/aarch64_kmc_solid_asp3.rs index f58aa1ac043ca..017116cfa5bed 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_kmc_solid_asp3.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_kmc_solid_asp3.rs @@ -1,4 +1,6 @@ -use crate::spec::{RelocModel, StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, RelocModel, StackProbeType, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { let base = base::solid::opts("asp3"); @@ -12,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { linker: Some("aarch64-kmc-elf-gcc".into()), features: "+v8a,+neon,+fp-armv8".into(), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_linux_android.rs b/compiler/rustc_target/src/spec/targets/aarch64_linux_android.rs index d8651f305fe94..7b59704882be2 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_linux_android.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_linux_android.rs @@ -1,5 +1,6 @@ use crate::spec::{ - FramePointer, SanitizerSet, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, FramePointer, SanitizerSet, StackProbeType, Target, TargetMetadata, + TargetOptions, base, }; // See https://developer.android.com/ndk/guides/abis.html#arm64-v8a @@ -16,7 +17,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { max_atomic_width: Some(128), // As documented in https://developer.android.com/ndk/guides/cpu-features.html diff --git a/compiler/rustc_target/src/spec/targets/aarch64_nintendo_switch_freestanding.rs b/compiler/rustc_target/src/spec/targets/aarch64_nintendo_switch_freestanding.rs index 61e4cad3fa202..814194e4b4bdd 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_nintendo_switch_freestanding.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_nintendo_switch_freestanding.rs @@ -1,6 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelroLevel, StackProbeType, Target, TargetMetadata, - TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelroLevel, StackProbeType, Target, + TargetMetadata, TargetOptions, }; const LINKER_SCRIPT: &str = include_str!("./aarch64_nintendo_switch_freestanding_linker_script.ld"); @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { features: "+v8a,+neon,+crypto,+crc".into(), linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_gnullvm.rs b/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_gnullvm.rs index eee668cc67edb..a9935d004f1ab 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_gnullvm.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_gnullvm.rs @@ -1,4 +1,4 @@ -use crate::spec::{FramePointer, Target, TargetMetadata, base}; +use crate::spec::{Architecture, FramePointer, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::windows_gnullvm::opts(); @@ -24,7 +24,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-p:64:64-i32:32-i64:64-i128:128-n32:64-S128-Fn32" .into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_msvc.rs index cd55576ef8167..cce6b0f05f116 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_pc_windows_msvc.rs @@ -1,4 +1,4 @@ -use crate::spec::{FramePointer, Target, TargetMetadata, base}; +use crate::spec::{Architecture, FramePointer, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::windows_msvc::opts(); @@ -23,7 +23,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-p:64:64-i32:32-i64:64-i128:128-n32:64-S128-Fn32" .into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_freebsd.rs index 7306a75aa2274..cdcda89fd2f05 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_freebsd.rs @@ -1,4 +1,6 @@ -use crate::spec::{SanitizerSet, StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, SanitizerSet, StackProbeType, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -11,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { features: "+v8a".into(), max_atomic_width: Some(128), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_fuchsia.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_fuchsia.rs index 8366b6d9bd824..f040b63fb0c36 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_fuchsia.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_fuchsia.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, base, + Architecture, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, base, }; pub(crate) fn target() -> Target { @@ -33,7 +33,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_hermit.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_hermit.rs index 580a36cb2e927..1fd1ad844389d 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_hermit.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_hermit.rs @@ -1,4 +1,4 @@ -use crate::spec::{StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, StackProbeType, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -10,7 +10,7 @@ pub(crate) fn target() -> Target { std: Some(true), }, pointer_width: 64, - arch: "aarch64".into(), + arch: Architecture::AArch64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), options: TargetOptions { features: "+v8a,+strict-align,+neon,+fp-armv8".into(), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_illumos.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_illumos.rs index 1ed4fdb465d38..f3cd597ef8f98 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_illumos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_illumos.rs @@ -1,4 +1,4 @@ -use crate::spec::{Cc, LinkerFlavor, SanitizerSet, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, SanitizerSet, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::illumos::opts(); @@ -19,7 +19,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu.rs index 4220d74dfc890..cde4505c60c57 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu.rs @@ -1,5 +1,6 @@ use crate::spec::{ - FramePointer, SanitizerSet, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, FramePointer, SanitizerSet, StackProbeType, Target, TargetMetadata, + TargetOptions, base, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { features: "+v8a,+outline-atomics".into(), // the AAPCS64 expects use of non-leaf frame pointers per diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu_ilp32.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu_ilp32.rs index a22c128967736..5c87dadd7d802 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu_ilp32.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu_ilp32.rs @@ -1,4 +1,6 @@ -use crate::spec::{FramePointer, StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, FramePointer, StackProbeType, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -11,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { abi: "ilp32".into(), features: "+v8a,+outline-atomics".into(), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_musl.rs index 478726fbef699..c48efa6ffe8bb 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_musl.rs @@ -1,5 +1,6 @@ use crate::spec::{ - FramePointer, SanitizerSet, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, FramePointer, SanitizerSet, StackProbeType, Target, TargetMetadata, + TargetOptions, base, }; pub(crate) fn target() -> Target { @@ -27,7 +28,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { // the AAPCS64 expects use of non-leaf frame pointers per // https://github.com/ARM-software/abi-aa/blob/4492d1570eb70c8fd146623e0db65b2d241f12e7/aapcs64/aapcs64.rst#the-frame-pointer diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_ohos.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_ohos.rs index 51cdebf22db21..d7d8939cc57ef 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_ohos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_ohos.rs @@ -1,5 +1,6 @@ use crate::spec::{ - FramePointer, SanitizerSet, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, FramePointer, SanitizerSet, StackProbeType, Target, TargetMetadata, + TargetOptions, base, }; pub(crate) fn target() -> Target { @@ -16,7 +17,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { // the AAPCS64 expects use of non-leaf frame pointers per // https://github.com/ARM-software/abi-aa/blob/4492d1570eb70c8fd146623e0db65b2d241f12e7/aapcs64/aapcs64.rst#the-frame-pointer diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_managarm_mlibc.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_managarm_mlibc.rs index 1fa9d7131c508..c49d04f8ea844 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_managarm_mlibc.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_managarm_mlibc.rs @@ -1,4 +1,4 @@ -use crate::spec::{StackProbeType, Target, base}; +use crate::spec::{Architecture, StackProbeType, Target, base}; pub(crate) fn target() -> Target { let mut base = base::managarm_mlibc::opts(); @@ -16,7 +16,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: base } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_netbsd.rs index 461730457aa4a..671b3922a9ba5 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_netbsd.rs @@ -1,4 +1,4 @@ -use crate::spec::{StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, StackProbeType, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { features: "+v8a".into(), mcount: "__mcount".into(), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs index 6c14f5df4660a..c6be3d575ffcb 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none.rs @@ -7,8 +7,8 @@ // For example, `-C target-cpu=cortex-a53`. use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, Target, - TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, + Target, TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -39,7 +39,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: opts, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs index 35a4dd72b8628..048ebdb2937ab 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs @@ -7,8 +7,8 @@ // For example, `-C target-cpu=cortex-a53`. use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, Target, - TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, + Target, TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -35,7 +35,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: opts, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_nuttx.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_nuttx.rs index 243d84a12ecee..cae2bb7f55de6 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_nuttx.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_nuttx.rs @@ -7,8 +7,8 @@ // For example, `-C target-cpu=cortex-a53`. use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, Target, - TargetMetadata, TargetOptions, cvs, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, + Target, TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -41,7 +41,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: opts, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_openbsd.rs index c23006adad6d8..2dd73a6ff1b68 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_openbsd.rs @@ -1,4 +1,4 @@ -use crate::spec::{StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, StackProbeType, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { features: "+v8a".into(), max_atomic_width: Some(128), diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_redox.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_redox.rs index 39fe71528d381..64caf074fd0ae 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_redox.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_redox.rs @@ -1,4 +1,4 @@ -use crate::spec::{StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{Architecture, StackProbeType, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::redox::opts(); @@ -16,7 +16,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_teeos.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_teeos.rs index 799ff1a806eef..5d67b68faa16c 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_teeos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_teeos.rs @@ -1,4 +1,4 @@ -use crate::spec::{StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{Architecture, StackProbeType, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::teeos::opts(); @@ -16,7 +16,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs index 05783fde1adf8..80c151fcee686 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs @@ -1,7 +1,8 @@ // Trusty OS target for AArch64. use crate::spec::{ - LinkSelfContainedDefault, PanicStrategy, RelroLevel, Target, TargetMetadata, TargetOptions, + Architecture, LinkSelfContainedDefault, PanicStrategy, RelroLevel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -15,7 +16,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { features: "+neon,+fp-armv8,+reserve-x18".into(), executables: true, diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_uefi.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_uefi.rs index 327b52389b934..b013b73f12074 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_uefi.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_uefi.rs @@ -1,7 +1,7 @@ // This defines the aarch64 target for UEFI systems as described in the UEFI specification. See the // uefi-base module for generic UEFI options. -use crate::spec::{LinkerFlavor, Lld, Target, TargetMetadata, base}; +use crate::spec::{Architecture, LinkerFlavor, Lld, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::uefi_msvc::opts(); @@ -22,7 +22,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-p:64:64-i32:32-i64:64-i128:128-n32:64-S128-Fn32" .into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_uwp_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/aarch64_uwp_windows_msvc.rs index a40c8c3a3f26f..17f299e5d099f 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_uwp_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_uwp_windows_msvc.rs @@ -1,4 +1,4 @@ -use crate::spec::{Target, TargetMetadata, base}; +use crate::spec::{Architecture, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::windows_uwp_msvc::opts(); @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-p:64:64-i32:32-i64:64-i128:128-n32:64-S128-Fn32" .into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/aarch64_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/aarch64_wrs_vxworks.rs index b68267601838f..bc7549367c7f1 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_wrs_vxworks.rs @@ -1,4 +1,4 @@ -use crate::spec::{StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, StackProbeType, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(), - arch: "aarch64".into(), + arch: Architecture::AArch64, options: TargetOptions { features: "+v8a,+reserve-x18".into(), max_atomic_width: Some(128), diff --git a/compiler/rustc_target/src/spec/targets/amdgcn_amd_amdhsa.rs b/compiler/rustc_target/src/spec/targets/amdgcn_amd_amdhsa.rs index 0d6c6194e2694..353e4dcfafcbe 100644 --- a/compiler/rustc_target/src/spec/targets/amdgcn_amd_amdhsa.rs +++ b/compiler/rustc_target/src/spec/targets/amdgcn_amd_amdhsa.rs @@ -1,8 +1,10 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, PanicStrategy, Target, TargetMetadata, TargetOptions}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, Target, TargetMetadata, TargetOptions, +}; pub(crate) fn target() -> Target { Target { - arch: "amdgpu".into(), + arch: Architecture::AmdGpu, data_layout: "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9".into(), llvm_target: "amdgcn-amd-amdhsa".into(), metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs index 7292412a18d86..4946b1ea59803 100644 --- a/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/arm64ec_pc_windows_msvc.rs @@ -1,4 +1,6 @@ -use crate::spec::{FramePointer, LinkerFlavor, Lld, Target, TargetMetadata, add_link_args, base}; +use crate::spec::{ + Architecture, FramePointer, LinkerFlavor, Lld, Target, TargetMetadata, add_link_args, base, +}; pub(crate) fn target() -> Target { let mut base = base::windows_msvc::opts(); @@ -28,7 +30,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-p:64:64-i32:32-i64:64-i128:128-n32:64-S128-Fn32" .into(), - arch: "arm64ec".into(), + arch: Architecture::Arm64EC, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/arm_linux_androideabi.rs b/compiler/rustc_target/src/spec/targets/arm_linux_androideabi.rs index d74468899f56a..cd42140f60dce 100644 --- a/compiler/rustc_target/src/spec/targets/arm_linux_androideabi.rs +++ b/compiler/rustc_target/src/spec/targets/arm_linux_androideabi.rs @@ -1,4 +1,6 @@ -use crate::spec::{FloatAbi, SanitizerSet, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, FloatAbi, SanitizerSet, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -11,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabi.rs b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabi.rs index 3b6c97167cf45..39ba8007bef58 100644 --- a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabi.rs +++ b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabi.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabihf.rs b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabihf.rs index 0c711d5e71ab4..3a2a99e478724 100644 --- a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabihf.rs +++ b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_gnueabihf.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), llvm_floatabi: Some(FloatAbi::Hard), diff --git a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabi.rs b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabi.rs index 3919a5e0771b7..704e7baf9a5cd 100644 --- a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabi.rs +++ b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabi.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabihf.rs b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabihf.rs index ca52e5b3ca6c7..4fe689d4ac744 100644 --- a/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabihf.rs +++ b/compiler/rustc_target/src/spec/targets/arm_unknown_linux_musleabihf.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), llvm_floatabi: Some(FloatAbi::Hard), diff --git a/compiler/rustc_target/src/spec/targets/armeb_unknown_linux_gnueabi.rs b/compiler/rustc_target/src/spec/targets/armeb_unknown_linux_gnueabi.rs index afb17fd82032b..7918d955beceb 100644 --- a/compiler/rustc_target/src/spec/targets/armeb_unknown_linux_gnueabi.rs +++ b/compiler/rustc_target/src/spec/targets/armeb_unknown_linux_gnueabi.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/armebv7r_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armebv7r_none_eabi.rs index 0ae7cd7a3773d..e2e37c07657b4 100644 --- a/compiler/rustc_target/src/spec/targets/armebv7r_none_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/armebv7r_none_eabi.rs @@ -3,8 +3,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/armebv7r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armebv7r_none_eabihf.rs index 71ffd8baed57b..a6fe6cbd3fc96 100644 --- a/compiler/rustc_target/src/spec/targets/armebv7r_none_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armebv7r_none_eabihf.rs @@ -3,8 +3,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), llvm_floatabi: Some(FloatAbi::Hard), diff --git a/compiler/rustc_target/src/spec/targets/armv4t_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armv4t_none_eabi.rs index 9571821656c8c..8e87e49cd345b 100644 --- a/compiler/rustc_target/src/spec/targets/armv4t_none_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv4t_none_eabi.rs @@ -10,8 +10,8 @@ //! `-Clink-arg=-Tmy_script.ld` to override that with a correct linker script. use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, cvs, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -24,7 +24,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "arm".into(), + arch: Architecture::Arm, /* Data layout args are '-' separated: * little endian * stack is 64-bit aligned (EABI) diff --git a/compiler/rustc_target/src/spec/targets/armv4t_unknown_linux_gnueabi.rs b/compiler/rustc_target/src/spec/targets/armv4t_unknown_linux_gnueabi.rs index beaec71093cb4..2174d5eab7383 100644 --- a/compiler/rustc_target/src/spec/targets/armv4t_unknown_linux_gnueabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv4t_unknown_linux_gnueabi.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/armv5te_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armv5te_none_eabi.rs index 75ab941c5cf29..b62814345ef59 100644 --- a/compiler/rustc_target/src/spec/targets/armv5te_none_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv5te_none_eabi.rs @@ -1,6 +1,8 @@ //! Targets the ARMv5TE, with code as `a32` code by default. -use crate::spec::{FloatAbi, FramePointer, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{ + Architecture, FloatAbi, FramePointer, Target, TargetMetadata, TargetOptions, base, cvs, +}; pub(crate) fn target() -> Target { Target { @@ -12,7 +14,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "arm".into(), + arch: Architecture::Arm, /* Data layout args are '-' separated: * little endian * stack is 64-bit aligned (EABI) diff --git a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_gnueabi.rs b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_gnueabi.rs index 7b93672dbe0fa..6e85ac127ef24 100644 --- a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_gnueabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_gnueabi.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_musleabi.rs b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_musleabi.rs index e675739629b59..f7bd775c02666 100644 --- a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_musleabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_musleabi.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_uclibceabi.rs b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_uclibceabi.rs index 860629b08e19b..1879efda59c97 100644 --- a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_uclibceabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_uclibceabi.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/armv6_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/armv6_unknown_freebsd.rs index 1625a6b84bbc3..be829a1f688e6 100644 --- a/compiler/rustc_target/src/spec/targets/armv6_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/armv6_unknown_freebsd.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), llvm_floatabi: Some(FloatAbi::Hard), diff --git a/compiler/rustc_target/src/spec/targets/armv6_unknown_netbsd_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv6_unknown_netbsd_eabihf.rs index af9a43595651a..a14883caad23d 100644 --- a/compiler/rustc_target/src/spec/targets/armv6_unknown_netbsd_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv6_unknown_netbsd_eabihf.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), llvm_floatabi: Some(FloatAbi::Hard), diff --git a/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs b/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs index 4c32a5e621616..a619c932b7972 100644 --- a/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs +++ b/compiler/rustc_target/src/spec/targets/armv6k_nintendo_3ds.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, RelocModel, Target, TargetMetadata, TargetOptions, cvs, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, RelocModel, Target, TargetMetadata, + TargetOptions, cvs, }; /// A base target for Nintendo 3DS devices using the devkitARM toolchain. @@ -22,7 +23,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { os: "horizon".into(), diff --git a/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs b/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs index 706fb12a524a7..987537fa9baa7 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_linux_androideabi.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, SanitizerSet, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, SanitizerSet, Target, TargetMetadata, + TargetOptions, base, }; // This target if is for the baseline of the Android v7a ABI @@ -23,7 +24,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/armv7_rtems_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_rtems_eabihf.rs index c17db36ee6114..7d43a4a92a499 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_rtems_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_rtems_eabihf.rs @@ -1,6 +1,6 @@ use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, cvs, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -14,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { os: "rtems".into(), diff --git a/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs index 4902dc37d13cc..883b769e39275 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_sony_vita_newlibeabihf.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, RelocModel, Target, TargetMetadata, TargetOptions, cvs, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, RelocModel, Target, TargetMetadata, + TargetOptions, cvs, }; /// A base target for PlayStation Vita devices using the VITASDK toolchain (using newlib). @@ -26,7 +27,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { os: "vita".into(), diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_freebsd.rs index 56f2e090e0713..5204009240831 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_freebsd.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), llvm_floatabi: Some(FloatAbi::Hard), diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabi.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabi.rs index 603afe2c48bb9..ebf13f8769b41 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabi.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; // This target is for glibc Linux on ARMv7 without thumb-mode, NEON or // hardfloat. @@ -14,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabihf.rs index a3b35d658e9da..7cce83c1046c5 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_gnueabihf.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; // This target is for glibc Linux on ARMv7 without NEON or // thumb-mode. See the thumbv7neon variant for enabling both. @@ -14,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), llvm_floatabi: Some(FloatAbi::Hard), diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabi.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabi.rs index 42fbf6f486197..3e771d73f0ebc 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabi.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; // This target is for musl Linux on ARMv7 without thumb-mode, NEON or // hardfloat. @@ -16,7 +16,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabihf.rs index a3ac0223c84bf..b43da029a4ba5 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_musleabihf.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; // This target is for musl Linux on ARMv7 without thumb-mode or NEON. @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, // Most of these settings are copied from the armv7_unknown_linux_gnueabihf // target. diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_ohos.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_ohos.rs index f31dedb04e6ca..fbfba4ebeea20 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_ohos.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_ohos.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; // This target is for OpenHarmony on ARMv7 Linux with thumb-mode, but no NEON or // hardfloat. @@ -16,7 +16,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabi.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabi.rs index a9e9f4651bb28..3650afcae7ed4 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabi.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; // This target is for uclibc Linux on ARMv7 without NEON, // thumb-mode or hardfloat. @@ -15,7 +15,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabihf.rs index a95f12d0230d6..7c78ae7931378 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_linux_uclibceabihf.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; // This target is for uclibc Linux on ARMv7 without NEON or // thumb-mode. See the thumbv7neon variant for enabling both. @@ -15,7 +15,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { // Info about features at https://wiki.debian.org/ArmHardFloatPort diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_netbsd_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_netbsd_eabihf.rs index d155dc58e5113..2ae6cb29809ab 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_unknown_netbsd_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_netbsd_eabihf.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), llvm_floatabi: Some(FloatAbi::Hard), diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs index 2b0b0e1d1170d..81d384315cd95 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs @@ -1,6 +1,6 @@ use crate::spec::{ - FloatAbi, LinkSelfContainedDefault, PanicStrategy, RelroLevel, Target, TargetMetadata, - TargetOptions, + Architecture, FloatAbi, LinkSelfContainedDefault, PanicStrategy, RelroLevel, Target, + TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/armv7_wrs_vxworks_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7_wrs_vxworks_eabihf.rs index 05be389b57c37..ead17d0a86e5a 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_wrs_vxworks_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_wrs_vxworks_eabihf.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), llvm_floatabi: Some(FloatAbi::Hard), diff --git a/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabi.rs b/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabi.rs index 26c2513998919..03e62cd5ba28c 100644 --- a/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabi.rs @@ -1,4 +1,6 @@ -use crate::spec::{FloatAbi, RelocModel, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, FloatAbi, RelocModel, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { let base = base::solid::opts("asp3"); @@ -12,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabihf.rs index 7032444bea4ca..175362de2525a 100644 --- a/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7a_kmc_solid_asp3_eabihf.rs @@ -1,4 +1,6 @@ -use crate::spec::{FloatAbi, RelocModel, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, FloatAbi, RelocModel, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { let base = base::solid::opts("asp3"); @@ -12,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), llvm_floatabi: Some(FloatAbi::Hard), diff --git a/compiler/rustc_target/src/spec/targets/armv7a_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armv7a_none_eabi.rs index fb1d7d6c39d73..6e2ae4d9ca605 100644 --- a/compiler/rustc_target/src/spec/targets/armv7a_none_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv7a_none_eabi.rs @@ -15,8 +15,8 @@ // linking. rationale: matches `thumb` targets use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -44,7 +44,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: opts, } } diff --git a/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs index 217a79d4571e9..00e2b98a08334 100644 --- a/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7a_none_eabihf.rs @@ -6,8 +6,8 @@ // `thumb` & `aarch64` targets. use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -36,7 +36,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: opts, } } diff --git a/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabi.rs index 052285b98dc8a..12c9b235bf996 100644 --- a/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabi.rs @@ -5,8 +5,8 @@ // configuration without hardware floating point support. use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, cvs, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -36,7 +36,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: opts, } } diff --git a/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabihf.rs index 85543e95616b9..55ab6e50b343b 100644 --- a/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7a_nuttx_eabihf.rs @@ -5,8 +5,8 @@ // configuration with hardware floating point support. use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, cvs, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -36,7 +36,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: opts, } } diff --git a/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs b/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs index 06dd26297758f..74dee46797c81 100644 --- a/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs +++ b/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs @@ -1,6 +1,6 @@ use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, }; const LINKER_SCRIPT: &str = include_str!("./armv7a_vex_v5_linker_script.ld"); @@ -38,7 +38,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: opts, } } diff --git a/compiler/rustc_target/src/spec/targets/armv7r_none_eabi.rs b/compiler/rustc_target/src/spec/targets/armv7r_none_eabi.rs index 334be483daa0f..20728a5cdd252 100644 --- a/compiler/rustc_target/src/spec/targets/armv7r_none_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/armv7r_none_eabi.rs @@ -1,8 +1,8 @@ // Targets the Little-endian Cortex-R4/R5 processor (ARMv7-R) use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -16,7 +16,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), diff --git a/compiler/rustc_target/src/spec/targets/armv7r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv7r_none_eabihf.rs index 2bb3e70483ae0..fce7d57e29a7a 100644 --- a/compiler/rustc_target/src/spec/targets/armv7r_none_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7r_none_eabihf.rs @@ -1,8 +1,8 @@ // Targets the Little-endian Cortex-R4F/R5F processor (ARMv7-R) use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -16,7 +16,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), diff --git a/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs index d6e3a03bbba8b..5e62277df9cff 100644 --- a/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv8r_none_eabihf.rs @@ -1,8 +1,8 @@ // Targets the Little-endian Cortex-R52 processor (ARMv8-R) use crate::spec::{ - Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -16,7 +16,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), diff --git a/compiler/rustc_target/src/spec/targets/avr_none.rs b/compiler/rustc_target/src/spec/targets/avr_none.rs index 65a171e4515af..f02fda820557c 100644 --- a/compiler/rustc_target/src/spec/targets/avr_none.rs +++ b/compiler/rustc_target/src/spec/targets/avr_none.rs @@ -1,8 +1,8 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, RelocModel, Target, TargetOptions}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Lld, RelocModel, Target, TargetOptions}; pub(crate) fn target() -> Target { Target { - arch: "avr".into(), + arch: Architecture::Avr, metadata: crate::spec::TargetMetadata { description: None, tier: Some(3), diff --git a/compiler/rustc_target/src/spec/targets/bpfeb_unknown_none.rs b/compiler/rustc_target/src/spec/targets/bpfeb_unknown_none.rs index 3d39cd26c6502..4b97d49b04e47 100644 --- a/compiler/rustc_target/src/spec/targets/bpfeb_unknown_none.rs +++ b/compiler/rustc_target/src/spec/targets/bpfeb_unknown_none.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{Target, TargetMetadata, base}; +use crate::spec::{Architecture, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, data_layout: "E-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), pointer_width: 64, - arch: "bpf".into(), + arch: Architecture::Bpf, options: base::bpf::opts(Endian::Big), } } diff --git a/compiler/rustc_target/src/spec/targets/bpfel_unknown_none.rs b/compiler/rustc_target/src/spec/targets/bpfel_unknown_none.rs index 51f45b0124494..030a0b91aac7e 100644 --- a/compiler/rustc_target/src/spec/targets/bpfel_unknown_none.rs +++ b/compiler/rustc_target/src/spec/targets/bpfel_unknown_none.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{Target, TargetMetadata, base}; +use crate::spec::{Architecture, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), pointer_width: 64, - arch: "bpf".into(), + arch: Architecture::Bpf, options: base::bpf::opts(Endian::Little), } } diff --git a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs index 6142c1541f0b9..a08e93fe3aced 100644 --- a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs +++ b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base, +}; // This target is for glibc Linux on Csky @@ -14,7 +16,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-S32-p:32:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:32-v128:32:32-a:0:32-Fi32-n32".into(), - arch: "csky".into(), + arch: Architecture::CSKY, options: TargetOptions { abi: "abiv2".into(), features: "+2e3,+3e7,+7e10,+cache,+dsp1e2,+dspe60,+e1,+e2,+edsp,+elrw,+hard-tp,+high-registers,+hwdiv,+mp,+mp1e2,+nvic,+trust".into(), diff --git a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs index c233ec3ada731..48f173be84b7e 100644 --- a/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs +++ b/compiler/rustc_target/src/spec/targets/csky_unknown_linux_gnuabiv2hf.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base, +}; // This target is for glibc Linux on Csky @@ -14,7 +16,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-S32-p:32:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:32-v128:32:32-a:0:32-Fi32-n32".into(), - arch: "csky".into(), + arch: Architecture::CSKY, options: TargetOptions { abi: "abiv2hf".into(), cpu: "ck860fv".into(), diff --git a/compiler/rustc_target/src/spec/targets/hexagon_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/hexagon_unknown_linux_musl.rs index 1abf0537cda77..be419bb0dfa70 100644 --- a/compiler/rustc_target/src/spec/targets/hexagon_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/hexagon_unknown_linux_musl.rs @@ -1,4 +1,4 @@ -use crate::spec::{Cc, LinkerFlavor, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::linux_musl::opts(); @@ -28,7 +28,7 @@ pub(crate) fn target() -> Target { ":2048:2048" ) .into(), - arch: "hexagon".into(), + arch: Architecture::Hexagon, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/hexagon_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/hexagon_unknown_none_elf.rs index e5a927d0953a7..446393e3811da 100644 --- a/compiler/rustc_target/src/spec/targets/hexagon_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/hexagon_unknown_none_elf.rs @@ -1,4 +1,4 @@ -use crate::spec::{PanicStrategy, Target, TargetMetadata, TargetOptions}; +use crate::spec::{Architecture, PanicStrategy, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { Target { @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { ":2048:2048" ) .into(), - arch: "hexagon".into(), + arch: Architecture::Hexagon, options: TargetOptions { cpu: "hexagonv60".into(), diff --git a/compiler/rustc_target/src/spec/targets/i586_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/i586_unknown_netbsd.rs index 39a71cf178126..a3a5e968e3501 100644 --- a/compiler/rustc_target/src/spec/targets/i586_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/i586_unknown_netbsd.rs @@ -1,4 +1,4 @@ -use crate::spec::{StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, StackProbeType, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { let mut base = base::netbsd::opts(); @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i128:128-f64:32:64-f80:32-n8:16:32-S128" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: TargetOptions { mcount: "__mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/i586_unknown_redox.rs b/compiler/rustc_target/src/spec/targets/i586_unknown_redox.rs index 08281eda42e0c..f6781c857cc5e 100644 --- a/compiler/rustc_target/src/spec/targets/i586_unknown_redox.rs +++ b/compiler/rustc_target/src/spec/targets/i586_unknown_redox.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::redox::opts(); @@ -16,7 +18,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i128:128-f64:32:64-f80:32-n8:16:32-S128" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_linux_android.rs b/compiler/rustc_target/src/spec/targets/i686_linux_android.rs index f2d7ec6644392..44afbcf918242 100644 --- a/compiler/rustc_target/src/spec/targets/i686_linux_android.rs +++ b/compiler/rustc_target/src/spec/targets/i686_linux_android.rs @@ -1,5 +1,6 @@ use crate::spec::{ - RustcAbi, SanitizerSet, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, RustcAbi, SanitizerSet, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; // See https://developer.android.com/ndk/guides/abis.html#x86 @@ -28,7 +29,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i128:128-f64:32:64-f80:32-n8:16:32-S128" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: TargetOptions { supported_sanitizers: SanitizerSet::ADDRESS, ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_pc_nto_qnx700.rs b/compiler/rustc_target/src/spec/targets/i686_pc_nto_qnx700.rs index 6a98a763b364d..a5e9b94e02c6b 100644 --- a/compiler/rustc_target/src/spec/targets/i686_pc_nto_qnx700.rs +++ b/compiler/rustc_target/src/spec/targets/i686_pc_nto_qnx700.rs @@ -1,5 +1,5 @@ use crate::spec::base::nto_qnx; -use crate::spec::{RustcAbi, StackProbeType, Target, TargetOptions, base}; +use crate::spec::{Architecture, RustcAbi, StackProbeType, Target, TargetOptions, base}; pub(crate) fn target() -> Target { let mut meta = nto_qnx::meta(); @@ -12,7 +12,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i128:128-f64:32:64-f80:32-n8:16:32-S128" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: TargetOptions { rustc_abi: Some(RustcAbi::X86Sse2), cpu: "pentium4".into(), diff --git a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs index a0d403bd05e69..50e3709fbad89 100644 --- a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnu.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, FramePointer, LinkerFlavor, Lld, RustcAbi, Target, TargetMetadata, base, crt_objects, + Architecture, Cc, FramePointer, LinkerFlavor, Lld, RustcAbi, Target, TargetMetadata, base, + crt_objects, }; pub(crate) fn target() -> Target { @@ -34,7 +35,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i64:64-i128:128-f80:32-n8:16:32-a:0:32-S32" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnullvm.rs b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnullvm.rs index 2e2ea8f81be0f..4039ea5ffb556 100644 --- a/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnullvm.rs +++ b/compiler/rustc_target/src/spec/targets/i686_pc_windows_gnullvm.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, FramePointer, LinkerFlavor, Lld, RustcAbi, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, FramePointer, LinkerFlavor, Lld, RustcAbi, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::windows_gnullvm::opts(); @@ -27,7 +29,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i64:64-i128:128-f80:32-n8:16:32-a:0:32-S32" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/i686_pc_windows_msvc.rs index 6a95afa1d0d3c..a996596b53b09 100644 --- a/compiler/rustc_target/src/spec/targets/i686_pc_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/i686_pc_windows_msvc.rs @@ -1,4 +1,6 @@ -use crate::spec::{LinkerFlavor, Lld, RustcAbi, SanitizerSet, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, LinkerFlavor, Lld, RustcAbi, SanitizerSet, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::windows_msvc::opts(); @@ -32,7 +34,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i64:64-i128:128-f80:128-n8:16:32-a:0:32-S32" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_freebsd.rs index 1dfea64ebed62..569ef24a9ebf0 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_freebsd.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, RustcAbi, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, RustcAbi, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::freebsd::opts(); @@ -20,7 +22,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i128:128-f64:32:64-f80:32-n8:16:32-S128" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_haiku.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_haiku.rs index ab329170a4f3b..078ef92cf87da 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_haiku.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_haiku.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, RustcAbi, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, RustcAbi, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::haiku::opts(); @@ -20,7 +22,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i128:128-f64:32:64-f80:32-n8:16:32-S128" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_hurd_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_hurd_gnu.rs index b01f93f74042c..6c8fed5554ad1 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_hurd_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_hurd_gnu.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::hurd_gnu::opts(); @@ -19,7 +21,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i128:128-f64:32:64-f80:32-n8:16:32-S128" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_linux_gnu.rs index c70c026f9f71e..3521e15356729 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_linux_gnu.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, RustcAbi, SanitizerSet, StackProbeType, Target, TargetMetadata, base, + Architecture, Cc, LinkerFlavor, Lld, RustcAbi, SanitizerSet, StackProbeType, Target, + TargetMetadata, base, }; pub(crate) fn target() -> Target { @@ -34,7 +35,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i128:128-f64:32:64-f80:32-n8:16:32-S128" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_linux_musl.rs index 47a7eb3d597b4..1cf5b6fb39866 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_linux_musl.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, FramePointer, LinkerFlavor, Lld, RustcAbi, StackProbeType, Target, TargetMetadata, base, + Architecture, Cc, FramePointer, LinkerFlavor, Lld, RustcAbi, StackProbeType, Target, + TargetMetadata, base, }; pub(crate) fn target() -> Target { @@ -40,7 +41,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i128:128-f64:32:64-f80:32-n8:16:32-S128" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_netbsd.rs index cbd61cadb3603..f214242790210 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_netbsd.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, RustcAbi, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, RustcAbi, StackProbeType, Target, TargetMetadata, + TargetOptions, base, }; pub(crate) fn target() -> Target { @@ -22,7 +23,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i128:128-f64:32:64-f80:32-n8:16:32-S128" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: TargetOptions { mcount: "__mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_openbsd.rs index 48f7be7dc2b53..5c5e1172a72fa 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_openbsd.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, RustcAbi, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, RustcAbi, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::openbsd::opts(); @@ -20,7 +22,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i128:128-f64:32:64-f80:32-n8:16:32-S128" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_unknown_uefi.rs b/compiler/rustc_target/src/spec/targets/i686_unknown_uefi.rs index 1a7923ca89bd2..f18c248549479 100644 --- a/compiler/rustc_target/src/spec/targets/i686_unknown_uefi.rs +++ b/compiler/rustc_target/src/spec/targets/i686_unknown_uefi.rs @@ -5,7 +5,9 @@ // The cdecl ABI is used. It differs from the stdcall or fastcall ABI. // "i686-unknown-windows" is used to get the minimal subset of windows-specific features. -use crate::spec::{LinkerFlavor, Lld, RustcAbi, Target, TargetMetadata, add_link_args, base}; +use crate::spec::{ + Architecture, LinkerFlavor, Lld, RustcAbi, Target, TargetMetadata, add_link_args, base, +}; pub(crate) fn target() -> Target { let mut base = base::uefi_msvc::opts(); @@ -96,7 +98,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i64:64-i128:128-f80:32-n8:16:32-a:0:32-S32" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } diff --git a/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs index d95f779774f13..c54be5f778d15 100644 --- a/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_uwp_windows_gnu.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, FramePointer, LinkerFlavor, Lld, RustcAbi, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, FramePointer, LinkerFlavor, Lld, RustcAbi, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::windows_uwp_gnu::opts(); @@ -27,7 +29,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i64:64-i128:128-f80:32-n8:16:32-a:0:32-S32" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_uwp_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/i686_uwp_windows_msvc.rs index fa7a103df797f..93178d059ea32 100644 --- a/compiler/rustc_target/src/spec/targets/i686_uwp_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/i686_uwp_windows_msvc.rs @@ -1,4 +1,4 @@ -use crate::spec::{RustcAbi, Target, TargetMetadata, base}; +use crate::spec::{Architecture, RustcAbi, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::windows_uwp_msvc::opts(); @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i64:64-i128:128-f80:128-n8:16:32-a:0:32-S32" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_win7_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/i686_win7_windows_gnu.rs index f364c2cb03276..0159a1ec794cb 100644 --- a/compiler/rustc_target/src/spec/targets/i686_win7_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/i686_win7_windows_gnu.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, FramePointer, LinkerFlavor, Lld, RustcAbi, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, FramePointer, LinkerFlavor, Lld, RustcAbi, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::windows_gnu::opts(); @@ -29,7 +31,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i64:64-i128:128-f80:32-n8:16:32-a:0:32-S32" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs index 91ab311109787..b8575df3190fe 100644 --- a/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/i686_win7_windows_msvc.rs @@ -1,4 +1,6 @@ -use crate::spec::{LinkerFlavor, Lld, RustcAbi, SanitizerSet, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, LinkerFlavor, Lld, RustcAbi, SanitizerSet, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::windows_msvc::opts(); @@ -39,7 +41,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:x-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i64:64-i128:128-f80:128-n8:16:32-a:0:32-S32" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/i686_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/i686_wrs_vxworks.rs index 63ede7b4ab897..38b185ab273a4 100644 --- a/compiler/rustc_target/src/spec/targets/i686_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/i686_wrs_vxworks.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, RustcAbi, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, RustcAbi, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::vxworks::opts(); @@ -20,7 +22,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i128:128-f64:32:64-f80:32-n8:16:32-S128" .into(), - arch: "x86".into(), + arch: Architecture::X86, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none.rs b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none.rs index fb4963b88b0f4..a76118075cac5 100644 --- a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none.rs +++ b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-i64:64-n32-S128".into(), - arch: "loongarch32".into(), + arch: Architecture::LoongArch32, options: TargetOptions { cpu: "generic".into(), features: "+f,+d".into(), diff --git a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs index 0e65f83a71cff..ac4929469da91 100644 --- a/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs +++ b/compiler/rustc_target/src/spec/targets/loongarch32_unknown_none_softfloat.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-i64:64-n32-S128".into(), - arch: "loongarch32".into(), + arch: Architecture::LoongArch32, options: TargetOptions { cpu: "generic".into(), features: "-f,-d".into(), diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs index 9e743a355296c..734dab45a015d 100644 --- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_gnu.rs @@ -1,4 +1,6 @@ -use crate::spec::{CodeModel, SanitizerSet, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, CodeModel, SanitizerSet, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -11,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "loongarch64".into(), + arch: Architecture::LoongArch64, options: TargetOptions { code_model: Some(CodeModel::Medium), cpu: "generic".into(), diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs index d9010b1e4eebc..472aa5f98808a 100644 --- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_musl.rs @@ -1,4 +1,6 @@ -use crate::spec::{CodeModel, SanitizerSet, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, CodeModel, SanitizerSet, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -11,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "loongarch64".into(), + arch: Architecture::LoongArch64, options: TargetOptions { code_model: Some(CodeModel::Medium), cpu: "generic".into(), diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs index c1c859ef25c81..de1ae1e2a77c5 100644 --- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs +++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_linux_ohos.rs @@ -1,4 +1,6 @@ -use crate::spec::{CodeModel, SanitizerSet, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, CodeModel, SanitizerSet, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -11,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "loongarch64".into(), + arch: Architecture::LoongArch64, options: TargetOptions { code_model: Some(CodeModel::Medium), cpu: "generic".into(), diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs index b6a08958284fa..656a2af60acda 100644 --- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs +++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none.rs @@ -1,6 +1,6 @@ use crate::spec::{ - Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, + Architecture, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -14,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "loongarch64".into(), + arch: Architecture::LoongArch64, options: TargetOptions { cpu: "generic".into(), features: "+f,+d,-lsx".into(), diff --git a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs index 24983900683e3..12d110fc246e5 100644 --- a/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs +++ b/compiler/rustc_target/src/spec/targets/loongarch64_unknown_none_softfloat.rs @@ -1,6 +1,6 @@ use crate::spec::{ - Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, + Architecture, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -14,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "loongarch64".into(), + arch: Architecture::LoongArch64, options: TargetOptions { cpu: "generic".into(), features: "-f,-d".into(), diff --git a/compiler/rustc_target/src/spec/targets/m68k_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/m68k_unknown_linux_gnu.rs index 9bd02e842c243..23371246b093f 100644 --- a/compiler/rustc_target/src/spec/targets/m68k_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/m68k_unknown_linux_gnu.rs @@ -1,6 +1,8 @@ use rustc_abi::Endian; -use crate::spec::{LinkSelfContainedDefault, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, LinkSelfContainedDefault, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { let mut base = base::linux_gnu::opts(); @@ -17,7 +19,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:16:32-i8:8:8-i16:16:16-i32:16:32-n8:16:32-a:0:16-S16".into(), - arch: "m68k".into(), + arch: Architecture::M68k, options: TargetOptions { endian: Endian::Big, mcount: "_mcount".into(), diff --git a/compiler/rustc_target/src/spec/targets/m68k_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/m68k_unknown_none_elf.rs index 6b66052692a4a..fe428ca0305ab 100644 --- a/compiler/rustc_target/src/spec/targets/m68k_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/m68k_unknown_none_elf.rs @@ -1,6 +1,8 @@ use rustc_abi::Endian; -use crate::spec::{CodeModel, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions}; +use crate::spec::{ + Architecture, CodeModel, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, +}; pub(crate) fn target() -> Target { let options = TargetOptions { @@ -28,7 +30,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:16:32-i8:8:8-i16:16:16-i32:16:32-n8:16:32-a:0:16-S16".into(), - arch: "m68k".into(), + arch: Architecture::M68k, options, } } diff --git a/compiler/rustc_target/src/spec/targets/mips64_openwrt_linux_musl.rs b/compiler/rustc_target/src/spec/targets/mips64_openwrt_linux_musl.rs index 508abc0101841..bb9728514973d 100644 --- a/compiler/rustc_target/src/spec/targets/mips64_openwrt_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/mips64_openwrt_linux_musl.rs @@ -2,7 +2,7 @@ use rustc_abi::Endian; -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { let mut base = base::linux_musl::opts(); @@ -21,7 +21,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(), - arch: "mips64".into(), + arch: Architecture::Mips64, options: TargetOptions { vendor: "openwrt".into(), abi: "abi64".into(), diff --git a/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_gnuabi64.rs b/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_gnuabi64.rs index a26350ff22509..ba38194233436 100644 --- a/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_gnuabi64.rs +++ b/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_gnuabi64.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(), - arch: "mips64".into(), + arch: Architecture::Mips64, options: TargetOptions { abi: "abi64".into(), endian: Endian::Big, diff --git a/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_muslabi64.rs b/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_muslabi64.rs index 94ecd3590a93a..9bb339ced448c 100644 --- a/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_muslabi64.rs +++ b/compiler/rustc_target/src/spec/targets/mips64_unknown_linux_muslabi64.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { let mut base = base::linux_musl::opts(); @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(), - arch: "mips64".into(), + arch: Architecture::Mips64, options: TargetOptions { abi: "abi64".into(), endian: Endian::Big, diff --git a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_gnuabi64.rs b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_gnuabi64.rs index 19bceadc62232..0a89e35980a0b 100644 --- a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_gnuabi64.rs +++ b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_gnuabi64.rs @@ -1,4 +1,4 @@ -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(), - arch: "mips64".into(), + arch: Architecture::Mips64, options: TargetOptions { abi: "abi64".into(), // NOTE(mips64r2) matches C toolchain diff --git a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs index 38c3c7dfaa1bb..160d34fe30809 100644 --- a/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs +++ b/compiler/rustc_target/src/spec/targets/mips64el_unknown_linux_muslabi64.rs @@ -1,4 +1,4 @@ -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { let mut base = base::linux_musl::opts(); @@ -16,7 +16,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(), - arch: "mips64".into(), + arch: Architecture::Mips64, options: TargetOptions { abi: "abi64".into(), mcount: "_mcount".into(), diff --git a/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs b/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs index def12122416a9..5bec07414bb57 100644 --- a/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/mips_mti_none_elf.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -15,7 +16,7 @@ pub(crate) fn target() -> Target { std: None, // ? }, pointer_width: 32, - arch: "mips".into(), + arch: Architecture::Mips, options: TargetOptions { vendor: "mti".into(), diff --git a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_gnu.rs index 29a451b31a659..d6b1d9caec237 100644 --- a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_gnu.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(), - arch: "mips".into(), + arch: Architecture::Mips, options: TargetOptions { endian: Endian::Big, cpu: "mips32r2".into(), diff --git a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_musl.rs index 82f2fda7fff0a..22b3dcb7cee58 100644 --- a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_musl.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { let mut base = base::linux_musl::opts(); @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(), - arch: "mips".into(), + arch: Architecture::Mips, options: TargetOptions { endian: Endian::Big, mcount: "_mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs index c14bfbf46d21d..c558535962e07 100644 --- a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs +++ b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(), - arch: "mips".into(), + arch: Architecture::Mips, options: TargetOptions { endian: Endian::Big, cpu: "mips32r2".into(), diff --git a/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs b/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs index cc9c19e4a0b5e..b7520af6fd35c 100644 --- a/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/mipsel_mti_none_elf.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -15,7 +16,7 @@ pub(crate) fn target() -> Target { std: None, // ? }, pointer_width: 32, - arch: "mips".into(), + arch: Architecture::Mips, options: TargetOptions { vendor: "mti".into(), diff --git a/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs b/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs index 37ebb3d174b34..960b60f02dec0 100644 --- a/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs +++ b/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, RelocModel, Target, TargetMetadata, TargetOptions, cvs}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, RelocModel, Target, TargetMetadata, TargetOptions, cvs, +}; // The PSP has custom linker requirements. const LINKER_SCRIPT: &str = include_str!("./mipsel_sony_psp_linker_script.ld"); @@ -19,7 +21,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(), - arch: "mips".into(), + arch: Architecture::Mips, options: TargetOptions { os: "psp".into(), diff --git a/compiler/rustc_target/src/spec/targets/mipsel_sony_psx.rs b/compiler/rustc_target/src/spec/targets/mipsel_sony_psx.rs index 8475a43ea6332..ab8dcfbbb06e3 100644 --- a/compiler/rustc_target/src/spec/targets/mipsel_sony_psx.rs +++ b/compiler/rustc_target/src/spec/targets/mipsel_sony_psx.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(), - arch: "mips".into(), + arch: Architecture::Mips, options: TargetOptions { // The Playstation 1 is mostly bare-metal, but the BIOS does provide some a slight bit diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_gnu.rs index 6c7ea5c56889a..8fc054f56b8c6 100644 --- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(), - arch: "mips".into(), + arch: Architecture::Mips, options: TargetOptions { cpu: "mips32r2".into(), diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_musl.rs index d008bb55189be..3842687652b7d 100644 --- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_musl.rs @@ -1,4 +1,4 @@ -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { let mut base = base::linux_musl::opts(); @@ -15,7 +15,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(), - arch: "mips".into(), + arch: Architecture::Mips, options: TargetOptions { mcount: "_mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs index f0056799d66f6..32592097067d2 100644 --- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs +++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs @@ -1,4 +1,4 @@ -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(), - arch: "mips".into(), + arch: Architecture::Mips, options: TargetOptions { cpu: "mips32r2".into(), diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_netbsd.rs index 502d7382b3cfd..674d5c7ad570f 100644 --- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_netbsd.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { let mut base = base::netbsd::opts(); @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(), - arch: "mips".into(), + arch: Architecture::Mips, options: TargetOptions { features: "+soft-float".into(), mcount: "__mcount".into(), diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_none.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_none.rs index 6a201c56475ee..e098047914a20 100644 --- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_none.rs +++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_none.rs @@ -3,7 +3,8 @@ //! Can be used for MIPS M4K core (e.g. on PIC32MX devices) use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -17,7 +18,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(), - arch: "mips".into(), + arch: Architecture::Mips, options: TargetOptions { linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), diff --git a/compiler/rustc_target/src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs index 0716f2e483b41..64693279672dc 100644 --- a/compiler/rustc_target/src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/mipsisa32r6_unknown_linux_gnu.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(), - arch: "mips32r6".into(), + arch: Architecture::Mips32r6, options: TargetOptions { endian: Endian::Big, cpu: "mips32r6".into(), diff --git a/compiler/rustc_target/src/spec/targets/mipsisa32r6el_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/mipsisa32r6el_unknown_linux_gnu.rs index 81f2424e4dea0..cff216ee7bd2b 100644 --- a/compiler/rustc_target/src/spec/targets/mipsisa32r6el_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/mipsisa32r6el_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".into(), - arch: "mips32r6".into(), + arch: Architecture::Mips32r6, options: TargetOptions { cpu: "mips32r6".into(), diff --git a/compiler/rustc_target/src/spec/targets/mipsisa64r6_unknown_linux_gnuabi64.rs b/compiler/rustc_target/src/spec/targets/mipsisa64r6_unknown_linux_gnuabi64.rs index cdd5f6b84365a..48e39ee9df97d 100644 --- a/compiler/rustc_target/src/spec/targets/mipsisa64r6_unknown_linux_gnuabi64.rs +++ b/compiler/rustc_target/src/spec/targets/mipsisa64r6_unknown_linux_gnuabi64.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(), - arch: "mips64r6".into(), + arch: Architecture::Mips64r6, options: TargetOptions { abi: "abi64".into(), endian: Endian::Big, diff --git a/compiler/rustc_target/src/spec/targets/mipsisa64r6el_unknown_linux_gnuabi64.rs b/compiler/rustc_target/src/spec/targets/mipsisa64r6el_unknown_linux_gnuabi64.rs index 88879a25818b7..0045db0f67ffe 100644 --- a/compiler/rustc_target/src/spec/targets/mipsisa64r6el_unknown_linux_gnuabi64.rs +++ b/compiler/rustc_target/src/spec/targets/mipsisa64r6el_unknown_linux_gnuabi64.rs @@ -1,4 +1,4 @@ -use crate::spec::{Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128".into(), - arch: "mips64r6".into(), + arch: Architecture::Mips64r6, options: TargetOptions { abi: "abi64".into(), // NOTE(mips64r6) matches C toolchain diff --git a/compiler/rustc_target/src/spec/targets/msp430_none_elf.rs b/compiler/rustc_target/src/spec/targets/msp430_none_elf.rs index caf77bb8669d7..da5e3ee444a32 100644 --- a/compiler/rustc_target/src/spec/targets/msp430_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/msp430_none_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, + Architecture, Cc, LinkerFlavor, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 16, data_layout: "e-m:e-p:16:16-i32:16-i64:16-f32:16-f64:16-a:8-n8:16-S16".into(), - arch: "msp430".into(), + arch: Architecture::Msp430, options: TargetOptions { c_int_width: 16, diff --git a/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs b/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs index cada0dd640a49..48cd06afcb3db 100644 --- a/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs +++ b/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs @@ -1,11 +1,11 @@ use crate::spec::{ - LinkSelfContainedDefault, LinkerFlavor, MergeFunctions, PanicStrategy, Target, TargetMetadata, - TargetOptions, + Architecture, LinkSelfContainedDefault, LinkerFlavor, MergeFunctions, PanicStrategy, Target, + TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { Target { - arch: "nvptx64".into(), + arch: Architecture::Nvptx64, data_layout: "e-p6:32:32-i64:64-i128:128-i256:256-v16:16-v32:32-n16:32:64".into(), llvm_target: "nvptx64-nvidia-cuda".into(), metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs b/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs index a140518899970..1793782949885 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_ibm_aix.rs @@ -1,4 +1,4 @@ -use crate::spec::{Cc, LinkerFlavor, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::aix::opts(); @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:a-Fi64-i64:64-i128:128-n32:64-S128-v256:256:256-v512:512:512".into(), - arch: "powerpc64".into(), + arch: Architecture::PowerPC64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs index b01ca989282ef..1e6a820a49e92 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_freebsd.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -23,7 +24,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-Fn32-i64:64-i128:128-n32:64".into(), - arch: "powerpc64".into(), + arch: Architecture::PowerPC64, options: TargetOptions { endian: Endian::Big, mcount: "_mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs index bc7e445f3f8ae..e770a14a78e24 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_gnu.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -23,7 +24,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-Fi64-i64:64-i128:128-n32:64-S128-v256:256:256-v512:512:512".into(), - arch: "powerpc64".into(), + arch: Architecture::PowerPC64, options: TargetOptions { endian: Endian::Big, mcount: "_mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs index 482b6790dadcd..baff042057394 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_linux_musl.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -23,7 +24,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-Fn32-i64:64-i128:128-n32:64-S128-v256:256:256-v512:512:512".into(), - arch: "powerpc64".into(), + arch: Architecture::PowerPC64, options: TargetOptions { endian: Endian::Big, mcount: "_mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs index 9dc44aa05cc0a..68daab145f90b 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_unknown_openbsd.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -23,7 +24,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-Fn32-i64:64-i128:128-n32:64".into(), - arch: "powerpc64".into(), + arch: Architecture::PowerPC64, options: TargetOptions { endian: Endian::Big, mcount: "_mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs index 10072f8092deb..f81571c07025f 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64_wrs_vxworks.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -23,7 +24,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-Fi64-i64:64-i128:128-n32:64-S128-v256:256:256-v512:512:512".into(), - arch: "powerpc64".into(), + arch: Architecture::PowerPC64, options: TargetOptions { endian: Endian::Big, ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs index a7f4e0eabb0a2..826a98bfd14c1 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_freebsd.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -21,7 +22,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-Fn32-i64:64-i128:128-n32:64".into(), - arch: "powerpc64".into(), + arch: Architecture::PowerPC64, options: TargetOptions { mcount: "_mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs index af5704b51ba33..7f3631b57903f 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -21,7 +22,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-Fn32-i64:64-i128:128-n32:64-S128-v256:256:256-v512:512:512".into(), - arch: "powerpc64".into(), + arch: Architecture::PowerPC64, options: TargetOptions { mcount: "_mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs index 26ee6a68c6a8b..7bbe32652c813 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_musl.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -23,7 +24,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-Fn32-i64:64-i128:128-n32:64-S128-v256:256:256-v512:512:512".into(), - arch: "powerpc64".into(), + arch: Architecture::PowerPC64, options: TargetOptions { mcount: "_mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_freebsd.rs index 5e1161e2f7d6c..9f47c367a54fa 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_freebsd.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -24,7 +25,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(), - arch: "powerpc".into(), + arch: Architecture::PowerPC, options: TargetOptions { endian: Endian::Big, features: "+secure-plt".into(), diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnu.rs index 6cde4bd98ac10..5c71a6928fee9 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnu.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -20,7 +21,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(), - arch: "powerpc".into(), + arch: Architecture::PowerPC, options: TargetOptions { endian: Endian::Big, features: "+secure-plt".into(), diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs index 3c1d18e077719..c219e4daeb928 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_gnuspe.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -20,7 +21,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(), - arch: "powerpc".into(), + arch: Architecture::PowerPC, options: TargetOptions { abi: "spe".into(), endian: Endian::Big, diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_musl.rs index f39142d01018b..981c4dd2fd302 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_musl.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -20,7 +21,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(), - arch: "powerpc".into(), + arch: Architecture::PowerPC, options: TargetOptions { endian: Endian::Big, mcount: "_mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_muslspe.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_muslspe.rs index 8ddb45483b3b9..11c469303cc92 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_muslspe.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_muslspe.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -20,7 +21,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(), - arch: "powerpc".into(), + arch: Architecture::PowerPC, options: TargetOptions { abi: "spe".into(), endian: Endian::Big, diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_netbsd.rs index 47a61a1aff244..8ea82dc447755 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_netbsd.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -20,7 +21,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(), - arch: "powerpc".into(), + arch: Architecture::PowerPC, options: TargetOptions { endian: Endian::Big, mcount: "__mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_openbsd.rs index bc5a50a053997..b480ba527e261 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_openbsd.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{Architecture, StackProbeType, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::openbsd::opts(); @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(), - arch: "powerpc".into(), + arch: Architecture::PowerPC, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks.rs index ca78be2b2b239..01105007ee739 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -20,7 +21,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(), - arch: "powerpc".into(), + arch: Architecture::PowerPC, options: TargetOptions { endian: Endian::Big, features: "+secure-plt".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs index e6345629f0397..0fe6f82156569 100644 --- a/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs +++ b/compiler/rustc_target/src/spec/targets/powerpc_wrs_vxworks_spe.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -20,7 +21,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(), - arch: "powerpc".into(), + arch: Architecture::PowerPC, options: TargetOptions { abi: "spe".into(), endian: Endian::Big, diff --git a/compiler/rustc_target/src/spec/targets/riscv32_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/riscv32_wrs_vxworks.rs index efc17d8d083b7..2c5e58287574a 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32_wrs_vxworks.rs @@ -1,4 +1,4 @@ -use crate::spec::{StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, StackProbeType, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-i64:64-n32-S128".into(), - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { cpu: "generic-rv32".into(), llvm_abiname: "ilp32d".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv32e_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32e_unknown_none_elf.rs index 00e8532d23846..ab67989f41908 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32e_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32e_unknown_none_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -16,7 +17,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { abi: abi.into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv32em_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32em_unknown_none_elf.rs index f814201601fc1..8d5ef226a7247 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32em_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32em_unknown_none_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -16,7 +17,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { abi: abi.into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv32emc_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32emc_unknown_none_elf.rs index 33df429db725b..0f125fb5dc15c 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32emc_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32emc_unknown_none_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -16,7 +17,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { abi: abi.into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_gnu.rs index 5b7feef70d099..7745ec51db4a5 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_gnu.rs @@ -1,6 +1,8 @@ use std::borrow::Cow; -use crate::spec::{CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -13,7 +15,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-i64:64-n32-S128".into(), - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { code_model: Some(CodeModel::Medium), cpu: "generic-rv32".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_musl.rs index eb592cca1c81d..501ec0bcdab96 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32gc_unknown_linux_musl.rs @@ -1,6 +1,8 @@ use std::borrow::Cow; -use crate::spec::{CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -15,7 +17,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-i64:64-n32-S128".into(), - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { code_model: Some(CodeModel::Medium), cpu: "generic-rv32".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv32i_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32i_unknown_none_elf.rs index f9a3b2172205b..5461da2c97d0e 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32i_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32i_unknown_none_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), diff --git a/compiler/rustc_target/src/spec/targets/riscv32im_risc0_zkvm_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32im_risc0_zkvm_elf.rs index 162f21c42ba27..0fe1492d8c10e 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32im_risc0_zkvm_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32im_risc0_zkvm_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { std: None, // ? }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { os: "zkvm".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv32im_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32im_unknown_none_elf.rs index 47b408a12d171..dd30146d1eb83 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32im_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32im_unknown_none_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), diff --git a/compiler/rustc_target/src/spec/targets/riscv32ima_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32ima_unknown_none_elf.rs index a173fb00b329e..25f12cc2d190c 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32ima_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32ima_unknown_none_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), diff --git a/compiler/rustc_target/src/spec/targets/riscv32imac_esp_espidf.rs b/compiler/rustc_target/src/spec/targets/riscv32imac_esp_espidf.rs index 48db9f44eacd3..41c74e54f3a4c 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32imac_esp_espidf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32imac_esp_espidf.rs @@ -1,4 +1,6 @@ -use crate::spec::{PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs}; +use crate::spec::{ + Architecture, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, +}; pub(crate) fn target() -> Target { Target { @@ -11,7 +13,7 @@ pub(crate) fn target() -> Target { std: Some(true), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_none_elf.rs index 1608f051ea821..12dcfb271fb00 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_none_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), diff --git a/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_nuttx_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_nuttx_elf.rs index 4ee02c6b2956f..fecfc723c6829 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_nuttx_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_nuttx_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { std: Some(true), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_xous_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_xous_elf.rs index 0893bd5ad6dca..a560df5321bb3 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_xous_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32imac_unknown_xous_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { std: None, // ? }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { os: "xous".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv32imafc_esp_espidf.rs b/compiler/rustc_target/src/spec/targets/riscv32imafc_esp_espidf.rs index 0929af7bb75ff..51e40667fdb1b 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32imafc_esp_espidf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32imafc_esp_espidf.rs @@ -1,4 +1,6 @@ -use crate::spec::{PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs}; +use crate::spec::{ + Architecture, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, +}; pub(crate) fn target() -> Target { Target { @@ -11,7 +13,7 @@ pub(crate) fn target() -> Target { std: Some(true), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_none_elf.rs index 44a84d9082cdf..b88a2ad97c265 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_none_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), diff --git a/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_nuttx_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_nuttx_elf.rs index 8908c0c53d9fe..54ad3ebd8e9e9 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_nuttx_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32imafc_unknown_nuttx_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { std: Some(true), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/riscv32imc_esp_espidf.rs b/compiler/rustc_target/src/spec/targets/riscv32imc_esp_espidf.rs index 82a4d58a3986f..2c3a86b2e50e2 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32imc_esp_espidf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32imc_esp_espidf.rs @@ -1,4 +1,6 @@ -use crate::spec::{PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs}; +use crate::spec::{ + Architecture, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, +}; pub(crate) fn target() -> Target { Target { @@ -11,7 +13,7 @@ pub(crate) fn target() -> Target { std: Some(true), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_none_elf.rs index 755ffc6154a18..04bdf40e28713 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_none_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), diff --git a/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_nuttx_elf.rs b/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_nuttx_elf.rs index 8da0b0e3e6b27..5275611914831 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_nuttx_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32imc_unknown_nuttx_elf.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -13,7 +14,7 @@ pub(crate) fn target() -> Target { std: Some(true), }, pointer_width: 32, - arch: "riscv32".into(), + arch: Architecture::RiscV32, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/riscv64_linux_android.rs b/compiler/rustc_target/src/spec/targets/riscv64_linux_android.rs index b9176c939f805..ff86f96f0790c 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64_linux_android.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64_linux_android.rs @@ -1,7 +1,8 @@ use std::borrow::Cow; use crate::spec::{ - CodeModel, SanitizerSet, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base, + Architecture, CodeModel, SanitizerSet, SplitDebuginfo, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -15,7 +16,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: TargetOptions { code_model: Some(CodeModel::Medium), cpu: "generic-rv64".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv64_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/riscv64_wrs_vxworks.rs index 8d8c21952de5f..254542b62592a 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64_wrs_vxworks.rs @@ -1,4 +1,4 @@ -use crate::spec::{StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, StackProbeType, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: TargetOptions { cpu: "generic-rv64".into(), llvm_abiname: "lp64d".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv64a23_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/riscv64a23_unknown_linux_gnu.rs index 60f2e7da042cc..668bab28533ed 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64a23_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64a23_unknown_linux_gnu.rs @@ -1,6 +1,8 @@ use std::borrow::Cow; -use crate::spec::{CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -13,7 +15,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: TargetOptions { code_model: Some(CodeModel::Medium), cpu: "generic-rv64".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_freebsd.rs index e628095b88a6d..07588e8f62cea 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_freebsd.rs @@ -1,4 +1,4 @@ -use crate::spec::{CodeModel, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, CodeModel, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: TargetOptions { code_model: Some(CodeModel::Medium), cpu: "generic-rv64".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_fuchsia.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_fuchsia.rs index c4466e13d1439..f1ca29f2c8bc8 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_fuchsia.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_fuchsia.rs @@ -1,4 +1,6 @@ -use crate::spec::{CodeModel, SanitizerSet, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, CodeModel, SanitizerSet, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::fuchsia::opts(); @@ -21,7 +23,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_hermit.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_hermit.rs index 5c15bdd9f6454..2c66dc1f4c848 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_hermit.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_hermit.rs @@ -1,4 +1,6 @@ -use crate::spec::{CodeModel, RelocModel, Target, TargetMetadata, TargetOptions, TlsModel, base}; +use crate::spec::{ + Architecture, CodeModel, RelocModel, Target, TargetMetadata, TargetOptions, TlsModel, base, +}; pub(crate) fn target() -> Target { Target { @@ -10,7 +12,7 @@ pub(crate) fn target() -> Target { std: Some(true), }, pointer_width: 64, - arch: "riscv64".into(), + arch: Architecture::RiscV64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), options: TargetOptions { cpu: "generic-rv64".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_gnu.rs index af2f42fa00a2f..d911c42a096da 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_gnu.rs @@ -1,6 +1,8 @@ use std::borrow::Cow; -use crate::spec::{CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -13,7 +15,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: TargetOptions { code_model: Some(CodeModel::Medium), cpu: "generic-rv64".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_musl.rs index 70c19952af063..02c674ef6e06a 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_linux_musl.rs @@ -1,6 +1,8 @@ use std::borrow::Cow; -use crate::spec::{CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, CodeModel, SplitDebuginfo, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -13,7 +15,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: TargetOptions { code_model: Some(CodeModel::Medium), cpu: "generic-rv64".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_managarm_mlibc.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_managarm_mlibc.rs index abf28310634ae..19b1173856577 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_managarm_mlibc.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_managarm_mlibc.rs @@ -1,4 +1,4 @@ -use crate::spec::{CodeModel, Target, TargetOptions, base}; +use crate::spec::{Architecture, CodeModel, Target, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: TargetOptions { code_model: Some(CodeModel::Medium), cpu: "generic-rv64".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_netbsd.rs index 1f359d1e7fe6d..b03440ca6258f 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_netbsd.rs @@ -1,4 +1,4 @@ -use crate::spec::{CodeModel, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, CodeModel, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: TargetOptions { code_model: Some(CodeModel::Medium), cpu: "generic-rv64".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_none_elf.rs index 5a5aad93efba1..2965509e8089a 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_none_elf.rs @@ -1,6 +1,6 @@ use crate::spec::{ - Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, Target, - TargetMetadata, TargetOptions, + Architecture, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, + Target, TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -14,7 +14,7 @@ pub(crate) fn target() -> Target { }, llvm_target: "riscv64".into(), pointer_width: 64, - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: TargetOptions { linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_nuttx_elf.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_nuttx_elf.rs index e8abc926dd0ed..2416aca4dd844 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_nuttx_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_nuttx_elf.rs @@ -1,6 +1,6 @@ use crate::spec::{ - Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, Target, - TargetMetadata, TargetOptions, cvs, + Architecture, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, + Target, TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -14,7 +14,7 @@ pub(crate) fn target() -> Target { }, llvm_target: "riscv64".into(), pointer_width: 64, - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_openbsd.rs index 85d7dfe7865ed..bdb0af01799f7 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64gc_unknown_openbsd.rs @@ -1,4 +1,4 @@ -use crate::spec::{CodeModel, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, CodeModel, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -11,7 +11,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".into(), - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: TargetOptions { code_model: Some(CodeModel::Medium), cpu: "generic-rv64".into(), diff --git a/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_none_elf.rs index 5c5d4aa32a2c4..d223cc8913792 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_none_elf.rs @@ -1,6 +1,6 @@ use crate::spec::{ - Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, Target, - TargetMetadata, TargetOptions, + Architecture, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, + Target, TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -14,7 +14,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 64, - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: TargetOptions { linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), diff --git a/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_nuttx_elf.rs b/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_nuttx_elf.rs index 0928250dba64d..8d61e7a7a480a 100644 --- a/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_nuttx_elf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv64imac_unknown_nuttx_elf.rs @@ -1,6 +1,6 @@ use crate::spec::{ - Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, Target, - TargetMetadata, TargetOptions, cvs, + Architecture, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, + Target, TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -14,7 +14,7 @@ pub(crate) fn target() -> Target { }, llvm_target: "riscv64".into(), pointer_width: 64, - arch: "riscv64".into(), + arch: Architecture::RiscV64, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_gnu.rs index cdcf7d62a3e2b..1a49a5931aa93 100644 --- a/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_gnu.rs @@ -1,6 +1,6 @@ use rustc_abi::{Align, Endian}; -use crate::spec::{SanitizerSet, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{Architecture, SanitizerSet, StackProbeType, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::linux_gnu::opts(); @@ -23,7 +23,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64".into(), - arch: "s390x".into(), + arch: Architecture::S390x, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_musl.rs index 0cdbb626739d0..53a47694f187a 100644 --- a/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_musl.rs @@ -1,6 +1,6 @@ use rustc_abi::{Align, Endian}; -use crate::spec::{SanitizerSet, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{Architecture, SanitizerSet, StackProbeType, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::linux_musl::opts(); @@ -24,7 +24,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64".into(), - arch: "s390x".into(), + arch: Architecture::S390x, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/sparc64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/sparc64_unknown_linux_gnu.rs index a52dadba5a51d..832c096ee668e 100644 --- a/compiler/rustc_target/src/spec/targets/sparc64_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/sparc64_unknown_linux_gnu.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{Target, TargetMetadata, base}; +use crate::spec::{Architecture, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::linux_gnu::opts(); @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-i64:64-i128:128-n32:64-S128".into(), - arch: "sparc64".into(), + arch: Architecture::Sparc64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/sparc64_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/sparc64_unknown_netbsd.rs index 21eedc5b6bc0a..2ce41e0609bd1 100644 --- a/compiler/rustc_target/src/spec/targets/sparc64_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/sparc64_unknown_netbsd.rs @@ -1,6 +1,8 @@ use rustc_abi::Endian; -use crate::spec::{Cc, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { let mut base = base::netbsd::opts(); @@ -18,7 +20,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-i64:64-i128:128-n32:64-S128".into(), - arch: "sparc64".into(), + arch: Architecture::Sparc64, options: TargetOptions { endian: Endian::Big, mcount: "__mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/sparc64_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/sparc64_unknown_openbsd.rs index b573bdf80a96a..b5e264d13ca9a 100644 --- a/compiler/rustc_target/src/spec/targets/sparc64_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/sparc64_unknown_openbsd.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{Cc, LinkerFlavor, Lld, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Lld, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::openbsd::opts(); @@ -19,7 +19,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "E-m:e-i64:64-i128:128-n32:64-S128".into(), - arch: "sparc64".into(), + arch: Architecture::Sparc64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/sparc_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/sparc_unknown_linux_gnu.rs index ffef696791256..41a5c0ac60639 100644 --- a/compiler/rustc_target/src/spec/targets/sparc_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/sparc_unknown_linux_gnu.rs @@ -1,6 +1,8 @@ use rustc_abi::Endian; -use crate::spec::{Cc, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -13,7 +15,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "E-m:e-p:32:32-i64:64-i128:128-f128:64-n32-S64".into(), - arch: "sparc".into(), + arch: Architecture::Sparc, options: TargetOptions { features: "+v8plus".into(), cpu: "v9".into(), diff --git a/compiler/rustc_target/src/spec/targets/sparc_unknown_none_elf.rs b/compiler/rustc_target/src/spec/targets/sparc_unknown_none_elf.rs index c2f64998dddb9..d5e56815e1366 100644 --- a/compiler/rustc_target/src/spec/targets/sparc_unknown_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/sparc_unknown_none_elf.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -29,7 +30,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "sparc".into(), + arch: Architecture::Sparc, options, } } diff --git a/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs b/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs index 1c53e15837cff..7a76ca611b836 100644 --- a/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs +++ b/compiler/rustc_target/src/spec/targets/sparcv9_sun_solaris.rs @@ -1,6 +1,6 @@ use rustc_abi::Endian; -use crate::spec::{Cc, LinkerFlavor, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::solaris::opts(); @@ -25,7 +25,7 @@ pub(crate) fn target() -> Target { // used widely in the source base. If we ever needed ABI // differentiation from the sparc64, we could, but that would probably // just be confusing. - arch: "sparc64".into(), + arch: Architecture::Sparc64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/thumbv4t_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv4t_none_eabi.rs index 7221bd8d4aef3..e30d27d165fdd 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv4t_none_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv4t_none_eabi.rs @@ -10,8 +10,8 @@ //! `-Clink-arg=-Tmy_script.ld` to override that with a correct linker script. use crate::spec::{ - FloatAbi, FramePointer, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, base, - cvs, + Architecture, FloatAbi, FramePointer, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, base, cvs, }; pub(crate) fn target() -> Target { @@ -24,7 +24,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "arm".into(), + arch: Architecture::Arm, /* Data layout args are '-' separated: * little endian * stack is 64-bit aligned (EABI) diff --git a/compiler/rustc_target/src/spec/targets/thumbv5te_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv5te_none_eabi.rs index 155e25211c1f9..4cfd2d82e9bcb 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv5te_none_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv5te_none_eabi.rs @@ -1,6 +1,8 @@ //! Targets the ARMv5TE, with code as `t32` code by default. -use crate::spec::{FloatAbi, FramePointer, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{ + Architecture, FloatAbi, FramePointer, Target, TargetMetadata, TargetOptions, base, cvs, +}; pub(crate) fn target() -> Target { Target { @@ -12,7 +14,7 @@ pub(crate) fn target() -> Target { std: Some(false), }, pointer_width: 32, - arch: "arm".into(), + arch: Architecture::Arm, /* Data layout args are '-' separated: * little endian * stack is 64-bit aligned (EABI) diff --git a/compiler/rustc_target/src/spec/targets/thumbv6m_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv6m_none_eabi.rs index 3b4b94da0577e..14b476dba06f3 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv6m_none_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv6m_none_eabi.rs @@ -1,6 +1,6 @@ // Targets the Cortex-M0, Cortex-M0+ and Cortex-M1 processors (ARMv6-M architecture) -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), diff --git a/compiler/rustc_target/src/spec/targets/thumbv6m_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv6m_nuttx_eabi.rs index 3c6133dc7ceb0..c872b70f7a612 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv6m_nuttx_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv6m_nuttx_eabi.rs @@ -1,6 +1,6 @@ // Targets the Cortex-M0, Cortex-M0+ and Cortex-M1 processors (ARMv6-M architecture) -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabi.rs index 5660f97c8b57b..2102633986ad9 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabi.rs @@ -4,7 +4,7 @@ // and will use software floating point operations. This matches the NuttX EABI // configuration without hardware floating point support. -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabihf.rs index d79970b0a0dd7..7ab881166afdf 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7a_nuttx_eabihf.rs @@ -7,7 +7,7 @@ // This target uses the "hard" floating convention (ABI) where floating point values // are passed to/from subroutines via FPU registers (S0, S1, D0, D1, etc.). -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -20,7 +20,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/thumbv7a_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/thumbv7a_pc_windows_msvc.rs index 33da885cc1a53..36792bf5706e4 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7a_pc_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7a_pc_windows_msvc.rs @@ -1,5 +1,6 @@ use crate::spec::{ - FloatAbi, LinkerFlavor, Lld, PanicStrategy, Target, TargetMetadata, TargetOptions, base, + Architecture, FloatAbi, LinkerFlavor, Lld, PanicStrategy, Target, TargetMetadata, + TargetOptions, base, }; pub(crate) fn target() -> Target { @@ -23,7 +24,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:w-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { llvm_floatabi: Some(FloatAbi::Hard), features: "+vfp3,+neon".into(), diff --git a/compiler/rustc_target/src/spec/targets/thumbv7a_uwp_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/thumbv7a_uwp_windows_msvc.rs index b4cc960939e9d..e6bd4def19a2d 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7a_uwp_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7a_uwp_windows_msvc.rs @@ -1,4 +1,6 @@ -use crate::spec::{FloatAbi, PanicStrategy, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, FloatAbi, PanicStrategy, Target, TargetMetadata, TargetOptions, base, +}; pub(crate) fn target() -> Target { Target { @@ -11,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:w-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { llvm_floatabi: Some(FloatAbi::Hard), features: "+vfp3,+neon".into(), diff --git a/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabi.rs index c747d721b671f..a264547ad0031 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabi.rs @@ -9,7 +9,7 @@ // To opt-in to hardware accelerated floating point operations, you can use, for example, // `-C target-feature=+vfp4` or `-C target-cpu=cortex-m4`. -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -22,7 +22,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), diff --git a/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabihf.rs index 309d32042a036..666ef0302b9f6 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7em_none_eabihf.rs @@ -8,7 +8,7 @@ // // To opt into double precision hardware support, use the `-C target-feature=+fp64` flag. -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -21,7 +21,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), diff --git a/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabi.rs index 57ef4e75e6408..588ea267df407 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabi.rs @@ -9,7 +9,7 @@ // To opt-in to hardware accelerated floating point operations, you can use, for example, // `-C target-feature=+vfp4` or `-C target-cpu=cortex-m4`. -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -22,7 +22,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabihf.rs index 0518872dd62d2..df4b6102cbd97 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7em_nuttx_eabihf.rs @@ -8,7 +8,7 @@ // // To opt into double precision hardware support, use the `-C target-feature=+fp64` flag. -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -21,7 +21,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/thumbv7m_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7m_none_eabi.rs index f261009d854e8..72a9d20dc0737 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7m_none_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7m_none_eabi.rs @@ -1,6 +1,6 @@ // Targets the Cortex-M3 processor (ARMv7-M) -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), diff --git a/compiler/rustc_target/src/spec/targets/thumbv7m_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7m_nuttx_eabi.rs index 611795e58f1f9..a1587f6d16f67 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7m_nuttx_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7m_nuttx_eabi.rs @@ -1,6 +1,6 @@ // Targets the Cortex-M3 processor (ARMv7-M) -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs b/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs index d3a25163c53fd..22cc351c67bf1 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7neon_linux_androideabi.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, FloatAbi, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{ + Architecture, Cc, FloatAbi, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, base, +}; // This target if is for the Android v7a ABI in thumb mode with // NEON unconditionally enabled and, therefore, with 32 FPU registers @@ -21,7 +23,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), llvm_floatabi: Some(FloatAbi::Soft), diff --git a/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_gnueabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_gnueabihf.rs index cce49f274aca7..d4c616a38e210 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_gnueabihf.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_gnueabihf.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; // This target is for glibc Linux on ARMv7 with thumb mode enabled // (for consistency with Android and Debian-based distributions) @@ -19,7 +19,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), llvm_floatabi: Some(FloatAbi::Hard), diff --git a/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_musleabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_musleabihf.rs index e026595439f48..267e340d40628 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_musleabihf.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv7neon_unknown_linux_musleabihf.rs @@ -1,4 +1,4 @@ -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; // This target is for musl Linux on ARMv7 with thumb mode enabled // (for consistency with Android and Debian-based distributions) @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, // Most of these settings are copied from the thumbv7neon_unknown_linux_gnueabihf // target. diff --git a/compiler/rustc_target/src/spec/targets/thumbv8m_base_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv8m_base_none_eabi.rs index b35f7bac93b4a..e08b3e14ac045 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv8m_base_none_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv8m_base_none_eabi.rs @@ -1,6 +1,6 @@ // Targets the Cortex-M23 processor (Baseline ARMv8-M) -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), diff --git a/compiler/rustc_target/src/spec/targets/thumbv8m_base_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv8m_base_nuttx_eabi.rs index 4e5f6898651af..477db441f2750 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv8m_base_nuttx_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv8m_base_nuttx_eabi.rs @@ -1,6 +1,6 @@ // Targets the Cortex-M23 processor (Baseline ARMv8-M) -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -13,7 +13,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabi.rs index 38143904efd14..b0a3a91ad44d3 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabi.rs @@ -1,7 +1,7 @@ // Targets the Cortex-M33 processor (Armv8-M Mainline architecture profile), // without the Floating Point extension. -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -14,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabi".into(), diff --git a/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabihf.rs index 55b7561da84c7..e323d2b5bc2f1 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv8m_main_none_eabihf.rs @@ -1,7 +1,7 @@ // Targets the Cortex-M33 processor (Armv8-M Mainline architecture profile), // with the Floating Point extension. -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -14,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { abi: "eabihf".into(), diff --git a/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabi.rs b/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabi.rs index 56aca0a882977..e202b2db07e57 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabi.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabi.rs @@ -1,7 +1,7 @@ // Targets the Cortex-M33 processor (Armv8-M Mainline architecture profile), // without the Floating Point extension. -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -14,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabihf.rs b/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabihf.rs index 47525e704daf6..146bfe99f569e 100644 --- a/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/thumbv8m_main_nuttx_eabihf.rs @@ -1,7 +1,7 @@ // Targets the Cortex-M33 processor (Armv8-M Mainline architecture profile), // with the Floating Point extension. -use crate::spec::{FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Architecture, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -14,7 +14,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(), - arch: "arm".into(), + arch: Architecture::Arm, options: TargetOptions { families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs b/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs index 4624c0fd5cba9..00d4bce4ee737 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_unknown_emscripten.rs @@ -1,6 +1,6 @@ use crate::spec::{ - LinkArgs, LinkerFlavor, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, base, - cvs, + Architecture, LinkArgs, LinkerFlavor, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, base, cvs, }; pub(crate) fn target() -> Target { @@ -35,7 +35,7 @@ pub(crate) fn target() -> Target { pointer_width: 32, data_layout: "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-f128:64-n32:64-S128-ni:1:10:20" .into(), - arch: "wasm32".into(), + arch: Architecture::Wasm32, options: opts, } } diff --git a/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs b/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs index b5792731a900d..2e7fc061fbc74 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs @@ -10,7 +10,7 @@ //! This target is more or less managed by the Rust and WebAssembly Working //! Group nowadays at . -use crate::spec::{Cc, LinkerFlavor, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut options = base::wasm::options(); @@ -44,7 +44,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20".into(), - arch: "wasm32".into(), + arch: Architecture::Wasm32, options, } } diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wali_linux_musl.rs b/compiler/rustc_target/src/spec/targets/wasm32_wali_linux_musl.rs index 06e5cfaed92da..8d02df7e84260 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_wali_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_wali_linux_musl.rs @@ -1,7 +1,7 @@ //! The `wasm32-wali-linux-musl` target is a wasm32 target compliant with the //! [WebAssembly Linux Interface](https://github.com/arjunr2/WALI). -use crate::spec::{Cc, LinkerFlavor, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut options = base::linux_wasm::opts(); @@ -30,7 +30,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20".into(), - arch: "wasm32".into(), + arch: Architecture::Wasm32, options, } } diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs index 26add451ed253..a742f29ab6eec 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs @@ -11,7 +11,8 @@ //! introduced. use crate::spec::{ - Cc, LinkSelfContainedDefault, LinkerFlavor, Target, TargetMetadata, base, crt_objects, + Architecture, Cc, LinkSelfContainedDefault, LinkerFlavor, Target, TargetMetadata, base, + crt_objects, }; pub(crate) fn target() -> Target { @@ -58,7 +59,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20".into(), - arch: "wasm32".into(), + arch: Architecture::Wasm32, options, } } diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs index c735c72cb1cb1..35aee7bc0e15c 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs @@ -8,7 +8,8 @@ //! Historically this target was known as `wasm32-wasi-preview1-threads`. use crate::spec::{ - Cc, LinkSelfContainedDefault, LinkerFlavor, Target, TargetMetadata, base, crt_objects, + Architecture, Cc, LinkSelfContainedDefault, LinkerFlavor, Target, TargetMetadata, base, + crt_objects, }; pub(crate) fn target() -> Target { @@ -72,7 +73,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20".into(), - arch: "wasm32".into(), + arch: Architecture::Wasm32, options, } } diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip2.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip2.rs index 7ad675dc3cf13..42ec0c79321f5 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_wasip2.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip2.rs @@ -17,7 +17,7 @@ //! . use crate::spec::{ - LinkSelfContainedDefault, RelocModel, Target, TargetMetadata, base, crt_objects, + Architecture, LinkSelfContainedDefault, RelocModel, Target, TargetMetadata, base, crt_objects, }; pub(crate) fn target() -> Target { @@ -69,7 +69,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20".into(), - arch: "wasm32".into(), + arch: Architecture::Wasm32, options, } } diff --git a/compiler/rustc_target/src/spec/targets/wasm32v1_none.rs b/compiler/rustc_target/src/spec/targets/wasm32v1_none.rs index e554e2ac07680..4c02e861ecc96 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32v1_none.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32v1_none.rs @@ -12,7 +12,7 @@ //! nightly Rust feature `-Zbuild-std`. This target is for people who want to //! use stable Rust, and target a stable set pf WebAssembly features. -use crate::spec::{Cc, LinkerFlavor, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut options = base::wasm::options(); @@ -51,7 +51,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 32, data_layout: "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20".into(), - arch: "wasm32".into(), + arch: Architecture::Wasm32, options, } } diff --git a/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs b/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs index e8ac93a87ca47..cd853c41051f3 100644 --- a/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs +++ b/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs @@ -7,7 +7,7 @@ //! the standard library is available, most of it returns an error immediately //! (e.g. trying to create a TCP stream or something like that). -use crate::spec::{Cc, LinkerFlavor, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut options = base::wasm::options(); @@ -47,7 +47,7 @@ pub(crate) fn target() -> Target { }, pointer_width: 64, data_layout: "e-m:e-p:64:64-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20".into(), - arch: "wasm64".into(), + arch: Architecture::Wasm64, options, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs b/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs index bbaee6c1f6d9b..490676ab4375b 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_fortanix_unknown_sgx.rs @@ -1,6 +1,8 @@ use std::borrow::Cow; -use crate::spec::{Cc, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, cvs}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, cvs, +}; pub(crate) fn target() -> Target { let pre_link_args = TargetOptions::link_args( @@ -83,7 +85,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: opts, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_linux_android.rs b/compiler/rustc_target/src/spec/targets/x86_64_linux_android.rs index 3a0acaa028cbe..17675768855ae 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_linux_android.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_linux_android.rs @@ -1,6 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, TargetOptions, - base, + Architecture, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, + TargetOptions, base, }; pub(crate) fn target() -> Target { @@ -25,7 +25,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: TargetOptions { supported_sanitizers: SanitizerSet::ADDRESS, ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_lynx_lynxos178.rs b/compiler/rustc_target/src/spec/targets/x86_64_lynx_lynxos178.rs index 654ae7c9c5bea..c59d62eeb7bcc 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_lynx_lynxos178.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_lynx_lynxos178.rs @@ -1,4 +1,4 @@ -use crate::spec::{SanitizerSet, StackProbeType, Target, base}; +use crate::spec::{Architecture, SanitizerSet, StackProbeType, Target, base}; pub(crate) fn target() -> Target { let mut base = base::lynxos178::opts(); @@ -28,7 +28,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_cygwin.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_cygwin.rs index eac4caf41c8bc..11290ec290fe3 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_cygwin.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_cygwin.rs @@ -1,4 +1,4 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, Target, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Lld, Target, base}; pub(crate) fn target() -> Target { let mut base = base::cygwin::opts(); @@ -12,7 +12,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, metadata: crate::spec::TargetMetadata { description: Some("64-bit x86 Cygwin".into()), diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs index 662bbc4a31c4a..dd7780651088d 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_solaris.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, SanitizerSet, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, SanitizerSet, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::solaris::opts(); @@ -21,7 +23,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs index 16bdd3ee6684d..f1ed12afd7687 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnu.rs @@ -1,4 +1,4 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Lld, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::windows_gnu::opts(); @@ -25,7 +25,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs index 1a03390c2b89a..344a6d00d7215 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_gnullvm.rs @@ -1,4 +1,4 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Lld, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::windows_gnullvm::opts(); @@ -20,7 +20,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_msvc.rs index d88aabaa6d336..164f0f2e02dae 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_msvc.rs @@ -1,4 +1,4 @@ -use crate::spec::{SanitizerSet, Target, TargetMetadata, base}; +use crate::spec::{Architecture, SanitizerSet, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::windows_msvc::opts(); @@ -19,7 +19,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unikraft_linux_musl.rs b/compiler/rustc_target/src/spec/targets/x86_64_unikraft_linux_musl.rs index a5723341fe64c..32088a8e0a41c 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unikraft_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unikraft_linux_musl.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, base, + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, TargetOptions, + base, }; pub(crate) fn target() -> Target { @@ -12,7 +13,7 @@ pub(crate) fn target() -> Target { std: Some(true), }, pointer_width: 64, - arch: "x86_64".into(), + arch: Architecture::X86_64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), options: TargetOptions { diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_dragonfly.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_dragonfly.rs index 715c0db632b16..71d5a0d356dc3 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_dragonfly.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_dragonfly.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::dragonfly::opts(); @@ -19,7 +21,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_freebsd.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_freebsd.rs index 4a074539aab75..1c863e5863a06 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_freebsd.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_freebsd.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, base, + Architecture, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, base, }; pub(crate) fn target() -> Target { @@ -24,7 +24,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_fuchsia.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_fuchsia.rs index d7253da7e8d66..5077fa19e1a80 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_fuchsia.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_fuchsia.rs @@ -1,4 +1,4 @@ -use crate::spec::{SanitizerSet, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{Architecture, SanitizerSet, StackProbeType, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::fuchsia::opts(); @@ -23,7 +23,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_haiku.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_haiku.rs index ecb9fc80351e1..eeb99e0ddd44a 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_haiku.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_haiku.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::haiku::opts(); @@ -21,7 +23,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_hermit.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_hermit.rs index 7abde77179816..1048e71e2363d 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_hermit.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_hermit.rs @@ -1,4 +1,4 @@ -use crate::spec::{StackProbeType, Target, TargetMetadata, TargetOptions, base}; +use crate::spec::{Architecture, StackProbeType, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { Target { @@ -10,7 +10,7 @@ pub(crate) fn target() -> Target { std: Some(true), }, pointer_width: 64, - arch: "x86_64".into(), + arch: Architecture::X86_64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), options: TargetOptions { diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_hurd_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_hurd_gnu.rs index 57ce67af36d68..c51c96316b3c6 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_hurd_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_hurd_gnu.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::hurd_gnu::opts(); @@ -20,7 +22,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_illumos.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_illumos.rs index 17f90db0c9066..aa386312e8ab1 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_illumos.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_illumos.rs @@ -1,4 +1,4 @@ -use crate::spec::{Cc, LinkerFlavor, SanitizerSet, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, SanitizerSet, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::illumos::opts(); @@ -21,7 +21,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_l4re_uclibc.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_l4re_uclibc.rs index 4107249dcf1e3..0d9516bb468b6 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_l4re_uclibc.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_l4re_uclibc.rs @@ -1,4 +1,4 @@ -use crate::spec::{PanicStrategy, Target, TargetMetadata, base}; +use crate::spec::{Architecture, PanicStrategy, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::l4re::opts(); @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs index 59bb7f5962101..67a1607d908cb 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, base, + Architecture, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, base, }; pub(crate) fn target() -> Target { @@ -31,7 +31,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs index c5d556e5cc650..07a2b43b79c9e 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnux32.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::linux_gnu::opts(); @@ -24,7 +26,7 @@ pub(crate) fn target() -> Target { data_layout: "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-\ i64:64-i128:128-f80:128-n8:16:32:64-S128" .into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs index cc5f88862400e..473b6044178f4 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_musl.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, base, + Architecture, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, base, }; pub(crate) fn target() -> Target { @@ -30,7 +30,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_none.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_none.rs index 896e8a78f863a..d716d0dc52c02 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_none.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_none.rs @@ -1,5 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, PanicStrategy, StackProbeType, Target, TargetMetadata, base, + Architecture, Cc, LinkerFlavor, Lld, PanicStrategy, StackProbeType, Target, TargetMetadata, + base, }; pub(crate) fn target() -> Target { @@ -22,7 +23,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_ohos.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_ohos.rs index de9027ba9622b..886c3a09f9695 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_ohos.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_ohos.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, base, + Architecture, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, base, }; pub(crate) fn target() -> Target { @@ -27,7 +27,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_managarm_mlibc.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_managarm_mlibc.rs index 359e38cb80079..654803368b15e 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_managarm_mlibc.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_managarm_mlibc.rs @@ -1,4 +1,4 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, StackProbeType, Target, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, base}; pub(crate) fn target() -> Target { let mut base = base::managarm_mlibc::opts(); @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_motor.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_motor.rs index 0fd43357a7664..d01b483f61ab6 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_motor.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_motor.rs @@ -1,5 +1,6 @@ use crate::spec::{ - CodeModel, LinkSelfContainedDefault, LldFlavor, RelocModel, RelroLevel, Target, base, + Architecture, CodeModel, LinkSelfContainedDefault, LldFlavor, RelocModel, RelroLevel, Target, + base, }; pub(crate) fn target() -> Target { @@ -32,7 +33,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_netbsd.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_netbsd.rs index 0403c220982dc..817a3e3eac529 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_netbsd.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_netbsd.rs @@ -1,6 +1,6 @@ use crate::spec::{ - Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, TargetOptions, - base, + Architecture, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, + TargetOptions, base, }; pub(crate) fn target() -> Target { @@ -28,7 +28,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: TargetOptions { mcount: "__mcount".into(), ..base }, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_none.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_none.rs index 1a6343595f545..0745d11dc3b13 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_none.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_none.rs @@ -5,8 +5,8 @@ // features. use crate::spec::{ - Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelroLevel, RustcAbi, SanitizerSet, - StackProbeType, Target, TargetMetadata, TargetOptions, + Architecture, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelroLevel, RustcAbi, + SanitizerSet, StackProbeType, Target, TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -39,7 +39,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: opts, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_openbsd.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_openbsd.rs index 2eb09b8cbada6..2711c36b41367 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_openbsd.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_openbsd.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::openbsd::opts(); @@ -20,7 +22,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_redox.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_redox.rs index 65b8e2543a410..0a189ef1ad2db 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_redox.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_redox.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::redox::opts(); @@ -19,7 +21,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_trusty.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_trusty.rs index dbcb5fd4e11e2..2493a84a1b05a 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_trusty.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_trusty.rs @@ -1,8 +1,8 @@ // Trusty OS target for X86_64. use crate::spec::{ - LinkSelfContainedDefault, PanicStrategy, RelroLevel, StackProbeType, Target, TargetMetadata, - TargetOptions, + Architecture, LinkSelfContainedDefault, PanicStrategy, RelroLevel, StackProbeType, Target, + TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: TargetOptions { executables: true, max_atomic_width: Some(64), diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_uefi.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_uefi.rs index 0cf6a87946219..8e376563597f0 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_uefi.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_uefi.rs @@ -7,7 +7,7 @@ use rustc_abi::{CanonAbi, X86Call}; -use crate::spec::{RustcAbi, Target, TargetMetadata, base}; +use crate::spec::{Architecture, RustcAbi, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::uefi_msvc::opts(); @@ -40,7 +40,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs index bf6179cb6c384..fcf7221266481 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_gnu.rs @@ -1,4 +1,4 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Lld, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::windows_uwp_gnu::opts(); @@ -24,7 +24,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_msvc.rs index 50b0578da3572..46b938c4a5d55 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_uwp_windows_msvc.rs @@ -1,4 +1,4 @@ -use crate::spec::{Target, TargetMetadata, base}; +use crate::spec::{Architecture, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::windows_uwp_msvc::opts(); @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_win7_windows_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_win7_windows_gnu.rs index df1fe8e7853cc..a4cb28c8ed358 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_win7_windows_gnu.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_win7_windows_gnu.rs @@ -1,4 +1,4 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, Target, TargetMetadata, base}; +use crate::spec::{Architecture, Cc, LinkerFlavor, Lld, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::windows_gnu::opts(); @@ -25,7 +25,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_win7_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/x86_64_win7_windows_msvc.rs index 876ac01187923..96c85759ba24f 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_win7_windows_msvc.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_win7_windows_msvc.rs @@ -1,4 +1,4 @@ -use crate::spec::{SanitizerSet, Target, TargetMetadata, base}; +use crate::spec::{Architecture, SanitizerSet, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut base = base::windows_msvc::opts(); @@ -19,7 +19,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/x86_64_wrs_vxworks.rs b/compiler/rustc_target/src/spec/targets/x86_64_wrs_vxworks.rs index 9ab62b3530fab..702fd36bd7e28 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_wrs_vxworks.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_wrs_vxworks.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base}; +use crate::spec::{ + Architecture, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetMetadata, base, +}; pub(crate) fn target() -> Target { let mut base = base::vxworks::opts(); @@ -20,7 +22,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, data_layout: "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(), - arch: "x86_64".into(), + arch: Architecture::X86_64, options: base, } } diff --git a/compiler/rustc_target/src/spec/targets/xtensa_esp32_espidf.rs b/compiler/rustc_target/src/spec/targets/xtensa_esp32_espidf.rs index 8a6773811e882..08d90f80fb9c6 100644 --- a/compiler/rustc_target/src/spec/targets/xtensa_esp32_espidf.rs +++ b/compiler/rustc_target/src/spec/targets/xtensa_esp32_espidf.rs @@ -1,14 +1,14 @@ use rustc_abi::Endian; use crate::spec::base::xtensa; -use crate::spec::{Target, TargetMetadata, TargetOptions, cvs}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, cvs}; pub(crate) fn target() -> Target { Target { llvm_target: "xtensa-none-elf".into(), pointer_width: 32, data_layout: "e-m:e-p:32:32-v1:8:8-i64:64-i128:128-n32".into(), - arch: "xtensa".into(), + arch: Architecture::Xtensa, metadata: TargetMetadata { description: None, tier: None, host_tools: None, std: None }, options: TargetOptions { diff --git a/compiler/rustc_target/src/spec/targets/xtensa_esp32_none_elf.rs b/compiler/rustc_target/src/spec/targets/xtensa_esp32_none_elf.rs index d8638e8ac8050..337b49b69d253 100644 --- a/compiler/rustc_target/src/spec/targets/xtensa_esp32_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/xtensa_esp32_none_elf.rs @@ -1,12 +1,12 @@ use crate::spec::base::xtensa; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { Target { llvm_target: "xtensa-none-elf".into(), pointer_width: 32, data_layout: "e-m:e-p:32:32-v1:8:8-i64:64-i128:128-n32".into(), - arch: "xtensa".into(), + arch: Architecture::Xtensa, metadata: TargetMetadata { description: Some("Xtensa ESP32".into()), tier: Some(3), diff --git a/compiler/rustc_target/src/spec/targets/xtensa_esp32s2_espidf.rs b/compiler/rustc_target/src/spec/targets/xtensa_esp32s2_espidf.rs index f38d771f2579a..81557489caf10 100644 --- a/compiler/rustc_target/src/spec/targets/xtensa_esp32s2_espidf.rs +++ b/compiler/rustc_target/src/spec/targets/xtensa_esp32s2_espidf.rs @@ -1,14 +1,14 @@ use rustc_abi::Endian; use crate::spec::base::xtensa; -use crate::spec::{Target, TargetMetadata, TargetOptions, cvs}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, cvs}; pub(crate) fn target() -> Target { Target { llvm_target: "xtensa-none-elf".into(), pointer_width: 32, data_layout: "e-m:e-p:32:32-v1:8:8-i64:64-i128:128-n32".into(), - arch: "xtensa".into(), + arch: Architecture::Xtensa, metadata: TargetMetadata { description: None, tier: None, host_tools: None, std: None }, options: TargetOptions { diff --git a/compiler/rustc_target/src/spec/targets/xtensa_esp32s2_none_elf.rs b/compiler/rustc_target/src/spec/targets/xtensa_esp32s2_none_elf.rs index 7bf5834ab0aa0..0f48a909389ca 100644 --- a/compiler/rustc_target/src/spec/targets/xtensa_esp32s2_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/xtensa_esp32s2_none_elf.rs @@ -1,12 +1,12 @@ use crate::spec::base::xtensa; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { Target { llvm_target: "xtensa-none-elf".into(), pointer_width: 32, data_layout: "e-m:e-p:32:32-v1:8:8-i64:64-i128:128-n32".into(), - arch: "xtensa".into(), + arch: Architecture::Xtensa, metadata: TargetMetadata { description: Some("Xtensa ESP32-S2".into()), tier: Some(3), diff --git a/compiler/rustc_target/src/spec/targets/xtensa_esp32s3_espidf.rs b/compiler/rustc_target/src/spec/targets/xtensa_esp32s3_espidf.rs index 4ec6e319fd4f2..c0fef00f2bb1f 100644 --- a/compiler/rustc_target/src/spec/targets/xtensa_esp32s3_espidf.rs +++ b/compiler/rustc_target/src/spec/targets/xtensa_esp32s3_espidf.rs @@ -1,14 +1,14 @@ use rustc_abi::Endian; use crate::spec::base::xtensa; -use crate::spec::{Target, TargetMetadata, TargetOptions, cvs}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions, cvs}; pub(crate) fn target() -> Target { Target { llvm_target: "xtensa-none-elf".into(), pointer_width: 32, data_layout: "e-m:e-p:32:32-v1:8:8-i64:64-i128:128-n32".into(), - arch: "xtensa".into(), + arch: Architecture::Xtensa, metadata: TargetMetadata { description: None, tier: None, host_tools: None, std: None }, options: TargetOptions { diff --git a/compiler/rustc_target/src/spec/targets/xtensa_esp32s3_none_elf.rs b/compiler/rustc_target/src/spec/targets/xtensa_esp32s3_none_elf.rs index d506888d8ee04..ede2fe26f4de5 100644 --- a/compiler/rustc_target/src/spec/targets/xtensa_esp32s3_none_elf.rs +++ b/compiler/rustc_target/src/spec/targets/xtensa_esp32s3_none_elf.rs @@ -1,12 +1,12 @@ use crate::spec::base::xtensa; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Architecture, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { Target { llvm_target: "xtensa-none-elf".into(), pointer_width: 32, data_layout: "e-m:e-p:32:32-v1:8:8-i64:64-i128:128-n32".into(), - arch: "xtensa".into(), + arch: Architecture::Xtensa, metadata: TargetMetadata { description: Some("Xtensa ESP32-S3".into()), tier: Some(3), diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs index dc70089c385fe..9213c0ebb6499 100644 --- a/compiler/rustc_target/src/target_features.rs +++ b/compiler/rustc_target/src/target_features.rs @@ -5,7 +5,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_span::{Symbol, sym}; -use crate::spec::{FloatAbi, RustcAbi, Target}; +use crate::spec::{Architecture, FloatAbi, RustcAbi, Target}; /// Features that control behaviour of rustc, rather than the codegen. /// These exist globally and are not in the target-specific lists below. @@ -956,50 +956,72 @@ pub struct FeatureConstraints { impl Target { pub fn rust_target_features(&self) -> &'static [(&'static str, Stability, ImpliedFeatures)] { - match &*self.arch { - "arm" => ARM_FEATURES, - "aarch64" | "arm64ec" => AARCH64_FEATURES, - "x86" | "x86_64" => X86_FEATURES, - "hexagon" => HEXAGON_FEATURES, - "mips" | "mips32r6" | "mips64" | "mips64r6" => MIPS_FEATURES, - "nvptx64" => NVPTX_FEATURES, - "powerpc" | "powerpc64" => POWERPC_FEATURES, - "riscv32" | "riscv64" => RISCV_FEATURES, - "wasm32" | "wasm64" => WASM_FEATURES, - "bpf" => BPF_FEATURES, - "csky" => CSKY_FEATURES, - "loongarch32" | "loongarch64" => LOONGARCH_FEATURES, - "s390x" => IBMZ_FEATURES, - "sparc" | "sparc64" => SPARC_FEATURES, - "m68k" => M68K_FEATURES, - _ => &[], + match self.arch { + Architecture::Arm => ARM_FEATURES, + Architecture::AArch64 | Architecture::Arm64EC => AARCH64_FEATURES, + Architecture::X86 | Architecture::X86_64 => X86_FEATURES, + Architecture::Hexagon => HEXAGON_FEATURES, + Architecture::Mips + | Architecture::Mips32r6 + | Architecture::Mips64 + | Architecture::Mips64r6 => MIPS_FEATURES, + Architecture::Nvptx64 => NVPTX_FEATURES, + Architecture::PowerPC | Architecture::PowerPC64 => POWERPC_FEATURES, + Architecture::RiscV32 | Architecture::RiscV64 => RISCV_FEATURES, + Architecture::Wasm32 | Architecture::Wasm64 => WASM_FEATURES, + Architecture::Bpf => BPF_FEATURES, + Architecture::CSKY => CSKY_FEATURES, + Architecture::LoongArch32 | Architecture::LoongArch64 => LOONGARCH_FEATURES, + Architecture::S390x => IBMZ_FEATURES, + Architecture::Sparc | Architecture::Sparc64 => SPARC_FEATURES, + Architecture::M68k => M68K_FEATURES, + Architecture::AmdGpu + | Architecture::Avr + | Architecture::Msp430 + | Architecture::PowerPC64LE + | Architecture::SpirV + | Architecture::Xtensa => &[], } } pub fn features_for_correct_vector_abi(&self) -> &'static [(u64, &'static str)] { - match &*self.arch { - "x86" | "x86_64" => X86_FEATURES_FOR_CORRECT_VECTOR_ABI, - "aarch64" | "arm64ec" => AARCH64_FEATURES_FOR_CORRECT_VECTOR_ABI, - "arm" => ARM_FEATURES_FOR_CORRECT_VECTOR_ABI, - "powerpc" | "powerpc64" => POWERPC_FEATURES_FOR_CORRECT_VECTOR_ABI, - "loongarch32" | "loongarch64" => LOONGARCH_FEATURES_FOR_CORRECT_VECTOR_ABI, - "riscv32" | "riscv64" => RISCV_FEATURES_FOR_CORRECT_VECTOR_ABI, - "wasm32" | "wasm64" => WASM_FEATURES_FOR_CORRECT_VECTOR_ABI, - "s390x" => S390X_FEATURES_FOR_CORRECT_VECTOR_ABI, - "sparc" | "sparc64" => SPARC_FEATURES_FOR_CORRECT_VECTOR_ABI, - "hexagon" => HEXAGON_FEATURES_FOR_CORRECT_VECTOR_ABI, - "mips" | "mips32r6" | "mips64" | "mips64r6" => MIPS_FEATURES_FOR_CORRECT_VECTOR_ABI, - "nvptx64" | "bpf" | "m68k" => &[], // no vector ABI - "csky" => CSKY_FEATURES_FOR_CORRECT_VECTOR_ABI, + match self.arch { + Architecture::X86 | Architecture::X86_64 => X86_FEATURES_FOR_CORRECT_VECTOR_ABI, + Architecture::AArch64 | Architecture::Arm64EC => { + AARCH64_FEATURES_FOR_CORRECT_VECTOR_ABI + } + Architecture::Arm => ARM_FEATURES_FOR_CORRECT_VECTOR_ABI, + Architecture::PowerPC | Architecture::PowerPC64 => { + POWERPC_FEATURES_FOR_CORRECT_VECTOR_ABI + } + Architecture::LoongArch32 | Architecture::LoongArch64 => { + LOONGARCH_FEATURES_FOR_CORRECT_VECTOR_ABI + } + Architecture::RiscV32 | Architecture::RiscV64 => RISCV_FEATURES_FOR_CORRECT_VECTOR_ABI, + Architecture::Wasm32 | Architecture::Wasm64 => WASM_FEATURES_FOR_CORRECT_VECTOR_ABI, + Architecture::S390x => S390X_FEATURES_FOR_CORRECT_VECTOR_ABI, + Architecture::Sparc | Architecture::Sparc64 => SPARC_FEATURES_FOR_CORRECT_VECTOR_ABI, + Architecture::Hexagon => HEXAGON_FEATURES_FOR_CORRECT_VECTOR_ABI, + Architecture::Mips + | Architecture::Mips32r6 + | Architecture::Mips64 + | Architecture::Mips64r6 => MIPS_FEATURES_FOR_CORRECT_VECTOR_ABI, + Architecture::Nvptx64 | Architecture::Bpf | Architecture::M68k => &[], // no vector ABI + Architecture::CSKY => CSKY_FEATURES_FOR_CORRECT_VECTOR_ABI, // FIXME: for some tier3 targets, we are overly cautious and always give warnings // when passing args in vector registers. - _ => &[], + Architecture::AmdGpu + | Architecture::Avr + | Architecture::Msp430 + | Architecture::PowerPC64LE + | Architecture::SpirV + | Architecture::Xtensa => &[], } } pub fn tied_target_features(&self) -> &'static [&'static [&'static str]] { - match &*self.arch { - "aarch64" | "arm64ec" => AARCH64_TIED_FEATURES, + match self.arch { + Architecture::AArch64 | Architecture::Arm64EC => AARCH64_TIED_FEATURES, _ => &[], } } @@ -1039,8 +1061,8 @@ impl Target { // defined by target features. When that is the case, those target features must be // "forbidden" in the list above to ensure that there is a consistent answer to the // questions "which ABI is used". - match &*self.arch { - "x86" => { + match self.arch { + Architecture::X86 => { // We use our own ABI indicator here; LLVM does not have anything native. // Every case should require or forbid `soft-float`! match self.rustc_abi { @@ -1065,7 +1087,7 @@ impl Target { } } } - "x86_64" => { + Architecture::X86_64 => { // We use our own ABI indicator here; LLVM does not have anything native. // Every case should require or forbid `soft-float`! match self.rustc_abi { @@ -1086,7 +1108,7 @@ impl Target { Some(r) => panic!("invalid Rust ABI for x86_64: {r:?}"), } } - "arm" => { + Architecture::Arm => { // On ARM, ABI handling is reasonably sane; we use `llvm_floatabi` to indicate // to LLVM which ABI we are going for. match self.llvm_floatabi.unwrap() { @@ -1103,7 +1125,7 @@ impl Target { } } } - "aarch64" | "arm64ec" => { + Architecture::AArch64 | Architecture::Arm64EC => { // Aarch64 has no sane ABI specifier, and LLVM doesn't even have a way to force // the use of soft-float, so all we can do here is some crude hacks. match &*self.abi { @@ -1122,7 +1144,7 @@ impl Target { } } } - "riscv32" | "riscv64" => { + Architecture::RiscV32 | Architecture::RiscV64 => { // RISC-V handles ABI in a very sane way, being fully explicit via `llvm_abiname` // about what the intended ABI is. match &*self.llvm_abiname { @@ -1156,7 +1178,7 @@ impl Target { _ => unreachable!(), } } - "loongarch32" | "loongarch64" => { + Architecture::LoongArch32 | Architecture::LoongArch64 => { // LoongArch handles ABI in a very sane way, being fully explicit via `llvm_abiname` // about what the intended ABI is. match &*self.llvm_abiname { @@ -1178,7 +1200,7 @@ impl Target { _ => unreachable!(), } } - "s390x" => { + Architecture::S390x => { // We don't currently support a softfloat target on this architecture. // As usual, we have to reject swapping the `soft-float` target feature. // The "vector" target feature does not affect the ABI for floats diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs index 412640a112c09..468869ec5f764 100644 --- a/src/tools/miri/src/machine.rs +++ b/src/tools/miri/src/machine.rs @@ -27,6 +27,7 @@ use rustc_session::config::InliningThreshold; use rustc_span::def_id::{CrateNum, DefId}; use rustc_span::{Span, SpanData, Symbol}; use rustc_target::callconv::FnAbi; +use rustc_target::spec::Architecture; use crate::alloc_addresses::EvalContextExt; use crate::concurrency::cpu_affinity::{self, CpuAffinityMask}; @@ -716,9 +717,9 @@ impl<'tcx> MiriMachine<'tcx> { page_size } else { let target = &tcx.sess.target; - match target.arch.as_ref() { - "wasm32" | "wasm64" => 64 * 1024, // https://webassembly.github.io/spec/core/exec/runtime.html#memory-instances - "aarch64" => { + match target.arch { + Architecture::Wasm32 | Architecture::Wasm64 => 64 * 1024, // https://webassembly.github.io/spec/core/exec/runtime.html#memory-instances + Architecture::AArch64 => { if target.options.vendor.as_ref() == "apple" { // No "definitive" source, but see: // https://www.wwdcnotes.com/notes/wwdc20/10214/ diff --git a/src/tools/miri/src/shims/alloc.rs b/src/tools/miri/src/shims/alloc.rs index f05c5fbbe1d4f..6e3d79b95cc94 100644 --- a/src/tools/miri/src/shims/alloc.rs +++ b/src/tools/miri/src/shims/alloc.rs @@ -1,5 +1,6 @@ use rustc_abi::{Align, Size}; use rustc_ast::expand::allocator::AllocatorKind; +use rustc_target::spec::Architecture; use crate::*; @@ -16,14 +17,40 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> { // `library/std/src/sys/alloc/mod.rs` (where this is called `MIN_ALIGN`) and should // be kept in sync. let os = this.tcx.sess.target.os.as_ref(); - let max_fundamental_align = match this.tcx.sess.target.arch.as_ref() { - "riscv32" if matches!(os, "espidf" | "zkvm") => 4, - "xtensa" if matches!(os, "espidf") => 4, - "x86" | "arm" | "m68k" | "csky" | "loongarch32" | "mips" | "mips32r6" | "powerpc" - | "powerpc64" | "sparc" | "wasm32" | "hexagon" | "riscv32" | "xtensa" => 8, - "x86_64" | "aarch64" | "arm64ec" | "loongarch64" | "mips64" | "mips64r6" | "s390x" - | "sparc64" | "riscv64" | "wasm64" => 16, - arch => bug!("unsupported target architecture for malloc: `{}`", arch), + let max_fundamental_align = match this.tcx.sess.target.arch { + Architecture::RiscV32 if matches!(os, "espidf" | "zkvm") => 4, + Architecture::Xtensa if matches!(os, "espidf") => 4, + Architecture::X86 + | Architecture::Arm + | Architecture::M68k + | Architecture::CSKY + | Architecture::LoongArch32 + | Architecture::Mips + | Architecture::Mips32r6 + | Architecture::PowerPC + | Architecture::PowerPC64 + | Architecture::Sparc + | Architecture::Wasm32 + | Architecture::Hexagon + | Architecture::RiscV32 + | Architecture::Xtensa => 8, + Architecture::X86_64 + | Architecture::AArch64 + | Architecture::Arm64EC + | Architecture::LoongArch64 + | Architecture::Mips64 + | Architecture::Mips64r6 + | Architecture::S390x + | Architecture::Sparc64 + | Architecture::RiscV64 + | Architecture::Wasm64 => 16, + arch @ (Architecture::AmdGpu + | Architecture::Avr + | Architecture::Bpf + | Architecture::Msp430 + | Architecture::Nvptx64 + | Architecture::PowerPC64LE + | Architecture::SpirV) => bug!("unsupported target architecture for malloc: `{arch}`"), }; // The C standard only requires sufficient alignment for any *type* with size less than or // equal to the size requested. Types one can define in standard C seem to never have an alignment diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs index eca8cccf5efc4..2e47f3746fa4f 100644 --- a/src/tools/miri/src/shims/foreign_items.rs +++ b/src/tools/miri/src/shims/foreign_items.rs @@ -13,6 +13,7 @@ use rustc_middle::ty::{Instance, Ty}; use rustc_middle::{mir, ty}; use rustc_span::Symbol; use rustc_target::callconv::FnAbi; +use rustc_target::spec::Architecture; use super::alloc::EvalContextExt as _; use super::backtrace::EvalContextExt as _; @@ -868,20 +869,24 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> { // Target-specific shims name if name.starts_with("llvm.x86.") - && (this.tcx.sess.target.arch == "x86" - || this.tcx.sess.target.arch == "x86_64") => + && matches!( + this.tcx.sess.target.arch, + Architecture::X86 | Architecture::X86_64 + ) => { return shims::x86::EvalContextExt::emulate_x86_intrinsic( this, link_name, abi, args, dest, ); } - name if name.starts_with("llvm.aarch64.") && this.tcx.sess.target.arch == "aarch64" => { + name if name.starts_with("llvm.aarch64.") + && this.tcx.sess.target.arch == Architecture::AArch64 => + { return shims::aarch64::EvalContextExt::emulate_aarch64_intrinsic( this, link_name, abi, args, dest, ); } // FIXME: Move this to an `arm` submodule. - "llvm.arm.hint" if this.tcx.sess.target.arch == "arm" => { + "llvm.arm.hint" if this.tcx.sess.target.arch == Architecture::Arm => { let [arg] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?; let arg = this.read_scalar(arg)?.to_i32()?; // Note that different arguments might have different target feature requirements. diff --git a/src/tools/miri/src/shims/windows/foreign_items.rs b/src/tools/miri/src/shims/windows/foreign_items.rs index c3ca01bbf3403..5666b691763f8 100644 --- a/src/tools/miri/src/shims/windows/foreign_items.rs +++ b/src/tools/miri/src/shims/windows/foreign_items.rs @@ -6,6 +6,7 @@ use rustc_abi::{Align, CanonAbi, Size, X86Call}; use rustc_middle::ty::Ty; use rustc_span::Symbol; use rustc_target::callconv::FnAbi; +use rustc_target::spec::Architecture; use self::shims::windows::handle::{Handle, PseudoHandle}; use crate::shims::os_str::bytes_to_os_str; @@ -140,7 +141,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> { // https://github.com/rust-lang/rust/blob/fb00adbdb69266f10df95a4527b767b0ad35ea48/compiler/rustc_target/src/spec/mod.rs#L2766-L2768, // x86-32 Windows uses a different calling convention than other Windows targets // for the "system" ABI. - let sys_conv = if this.tcx.sess.target.arch == "x86" { + let sys_conv = if this.tcx.sess.target.arch == Architecture::X86 { CanonAbi::X86(X86Call::Stdcall) } else { CanonAbi::C diff --git a/src/tools/miri/src/shims/x86/bmi.rs b/src/tools/miri/src/shims/x86/bmi.rs index 140e31cc51333..8202351b8d104 100644 --- a/src/tools/miri/src/shims/x86/bmi.rs +++ b/src/tools/miri/src/shims/x86/bmi.rs @@ -2,6 +2,7 @@ use rustc_abi::CanonAbi; use rustc_middle::ty::Ty; use rustc_span::Symbol; use rustc_target::callconv::FnAbi; +use rustc_target::spec::Architecture; use crate::*; @@ -31,7 +32,7 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> { let target_feature = if unprefixed_name == "bextr" { "bmi1" } else { "bmi2" }; this.expect_target_feature_for_intrinsic(link_name, target_feature)?; - if is_64_bit && this.tcx.sess.target.arch != "x86_64" { + if is_64_bit && this.tcx.sess.target.arch != Architecture::X86_64 { return interp_ok(EmulateItemResult::NotSupported); } diff --git a/src/tools/miri/src/shims/x86/mod.rs b/src/tools/miri/src/shims/x86/mod.rs index 3324b7b024ace..b37962a945753 100644 --- a/src/tools/miri/src/shims/x86/mod.rs +++ b/src/tools/miri/src/shims/x86/mod.rs @@ -5,6 +5,7 @@ use rustc_middle::ty::Ty; use rustc_middle::{mir, ty}; use rustc_span::Symbol; use rustc_target::callconv::FnAbi; +use rustc_target::spec::Architecture; use self::helpers::bool_to_simd_element; use crate::*; @@ -41,7 +42,9 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> { // https://www.intel.com/content/www/us/en/docs/cpp-compiler/developer-guide-reference/2021-8/addcarry-u32-addcarry-u64.html // https://www.intel.com/content/www/us/en/docs/cpp-compiler/developer-guide-reference/2021-8/subborrow-u32-subborrow-u64.html "addcarry.32" | "addcarry.64" | "subborrow.32" | "subborrow.64" => { - if unprefixed_name.ends_with("64") && this.tcx.sess.target.arch != "x86_64" { + if unprefixed_name.ends_with("64") + && this.tcx.sess.target.arch != Architecture::X86_64 + { return interp_ok(EmulateItemResult::NotSupported); } @@ -65,7 +68,7 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> { this.expect_target_feature_for_intrinsic(link_name, "adx")?; let is_u64 = unprefixed_name.ends_with("64"); - if is_u64 && this.tcx.sess.target.arch != "x86_64" { + if is_u64 && this.tcx.sess.target.arch != Architecture::X86_64 { return interp_ok(EmulateItemResult::NotSupported); } let [c_in, a, b, out] = diff --git a/src/tools/miri/src/shims/x86/sse42.rs b/src/tools/miri/src/shims/x86/sse42.rs index 72c5039a12d3c..72010584a042e 100644 --- a/src/tools/miri/src/shims/x86/sse42.rs +++ b/src/tools/miri/src/shims/x86/sse42.rs @@ -3,6 +3,7 @@ use rustc_middle::mir; use rustc_middle::ty::Ty; use rustc_span::Symbol; use rustc_target::callconv::FnAbi; +use rustc_target::spec::Architecture; use crate::*; @@ -431,7 +432,7 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> { _ => unreachable!(), }; - if bit_size == 64 && this.tcx.sess.target.arch != "x86_64" { + if bit_size == 64 && this.tcx.sess.target.arch != Architecture::X86_64 { return interp_ok(EmulateItemResult::NotSupported); }