From fcf6809b053747873013c6ca54e234f63c08ba9c Mon Sep 17 00:00:00 2001 From: Tamir Duberstein Date: Wed, 5 Nov 2025 16:32:20 -0500 Subject: [PATCH] rustc_target: introduce Os Improve type safety by using an enum rather than strings. --- compiler/rustc_codegen_cranelift/src/lib.rs | 12 +-- compiler/rustc_codegen_llvm/src/context.rs | 8 +- compiler/rustc_codegen_llvm/src/intrinsic.rs | 3 +- compiler/rustc_codegen_llvm/src/llvm_util.rs | 12 +-- compiler/rustc_codegen_ssa/src/back/apple.rs | 46 +++++----- compiler/rustc_codegen_ssa/src/back/link.rs | 24 ++--- compiler/rustc_codegen_ssa/src/back/linker.rs | 12 +-- .../rustc_codegen_ssa/src/back/metadata.rs | 10 +-- .../src/back/symbol_export.rs | 4 +- compiler/rustc_codegen_ssa/src/base.rs | 10 +-- .../rustc_codegen_ssa/src/codegen_attrs.rs | 3 +- compiler/rustc_codegen_ssa/src/common.rs | 4 +- .../rustc_lint/src/types/improper_ctypes.rs | 5 +- compiler/rustc_metadata/src/native_libs.rs | 6 +- compiler/rustc_passes/src/weak_lang_items.rs | 3 +- compiler/rustc_session/src/config/cfg.rs | 4 +- compiler/rustc_session/src/session.rs | 4 +- compiler/rustc_target/src/asm/aarch64.rs | 6 +- compiler/rustc_target/src/callconv/powerpc.rs | 4 +- .../rustc_target/src/callconv/powerpc64.rs | 6 +- compiler/rustc_target/src/callconv/s390x.rs | 4 +- compiler/rustc_target/src/callconv/sparc64.rs | 4 +- compiler/rustc_target/src/spec/base/aix.rs | 5 +- .../rustc_target/src/spec/base/android.rs | 4 +- .../rustc_target/src/spec/base/apple/mod.rs | 78 ++++++++-------- compiler/rustc_target/src/spec/base/cygwin.rs | 6 +- .../rustc_target/src/spec/base/dragonfly.rs | 4 +- .../rustc_target/src/spec/base/freebsd.rs | 4 +- .../rustc_target/src/spec/base/fuchsia.rs | 4 +- compiler/rustc_target/src/spec/base/haiku.rs | 4 +- .../rustc_target/src/spec/base/helenos.rs | 4 +- compiler/rustc_target/src/spec/base/hermit.rs | 4 +- compiler/rustc_target/src/spec/base/hurd.rs | 4 +- .../rustc_target/src/spec/base/illumos.rs | 4 +- compiler/rustc_target/src/spec/base/l4re.rs | 4 +- compiler/rustc_target/src/spec/base/linux.rs | 4 +- .../rustc_target/src/spec/base/linux_wasm.rs | 4 +- .../rustc_target/src/spec/base/lynxos178.rs | 4 +- .../src/spec/base/managarm_mlibc.rs | 4 +- compiler/rustc_target/src/spec/base/motor.rs | 4 +- compiler/rustc_target/src/spec/base/netbsd.rs | 4 +- .../rustc_target/src/spec/base/nto_qnx.rs | 4 +- .../rustc_target/src/spec/base/openbsd.rs | 4 +- compiler/rustc_target/src/spec/base/redox.rs | 4 +- .../rustc_target/src/spec/base/solaris.rs | 4 +- compiler/rustc_target/src/spec/base/solid.rs | 6 +- compiler/rustc_target/src/spec/base/teeos.rs | 7 +- .../rustc_target/src/spec/base/uefi_msvc.rs | 4 +- .../src/spec/base/unikraft_linux_musl.rs | 4 +- .../rustc_target/src/spec/base/vxworks.rs | 4 +- .../rustc_target/src/spec/base/windows_gnu.rs | 4 +- .../src/spec/base/windows_gnullvm.rs | 6 +- .../src/spec/base/windows_msvc.rs | 4 +- compiler/rustc_target/src/spec/base/xtensa.rs | 4 +- compiler/rustc_target/src/spec/json.rs | 4 +- compiler/rustc_target/src/spec/mod.rs | 90 ++++++++++++++++--- .../src/spec/targets/aarch64_apple_darwin.rs | 4 +- .../src/spec/targets/aarch64_apple_ios.rs | 4 +- .../spec/targets/aarch64_apple_ios_macabi.rs | 4 +- .../src/spec/targets/aarch64_apple_ios_sim.rs | 4 +- .../src/spec/targets/aarch64_apple_tvos.rs | 4 +- .../spec/targets/aarch64_apple_tvos_sim.rs | 4 +- .../spec/targets/aarch64_apple_visionos.rs | 4 +- .../targets/aarch64_apple_visionos_sim.rs | 4 +- .../src/spec/targets/aarch64_apple_watchos.rs | 4 +- .../spec/targets/aarch64_apple_watchos_sim.rs | 4 +- .../spec/targets/aarch64_kmc_solid_asp3.rs | 2 +- .../aarch64_nintendo_switch_freestanding.rs | 6 +- .../src/spec/targets/aarch64_unknown_nuttx.rs | 6 +- .../spec/targets/aarch64_unknown_trusty.rs | 4 +- .../src/spec/targets/amdgcn_amd_amdhsa.rs | 4 +- .../spec/targets/arm64_32_apple_watchos.rs | 4 +- .../src/spec/targets/arm64e_apple_darwin.rs | 4 +- .../src/spec/targets/arm64e_apple_ios.rs | 4 +- .../src/spec/targets/arm64e_apple_tvos.rs | 4 +- .../src/spec/targets/armv6k_nintendo_3ds.rs | 4 +- .../src/spec/targets/armv7_rtems_eabihf.rs | 4 +- .../targets/armv7_sony_vita_newlibeabihf.rs | 4 +- .../src/spec/targets/armv7_unknown_trusty.rs | 4 +- .../targets/armv7a_kmc_solid_asp3_eabi.rs | 2 +- .../targets/armv7a_kmc_solid_asp3_eabihf.rs | 2 +- .../src/spec/targets/armv7a_nuttx_eabi.rs | 6 +- .../src/spec/targets/armv7a_nuttx_eabihf.rs | 6 +- .../src/spec/targets/armv7a_vex_v5.rs | 4 +- .../src/spec/targets/armv7k_apple_watchos.rs | 4 +- .../src/spec/targets/armv7s_apple_ios.rs | 4 +- .../src/spec/targets/i386_apple_ios.rs | 4 +- .../src/spec/targets/i686_apple_darwin.rs | 4 +- .../src/spec/targets/mipsel_sony_psp.rs | 4 +- .../src/spec/targets/mipsel_sony_psx.rs | 6 +- .../src/spec/targets/nvptx64_nvidia_cuda.rs | 4 +- .../spec/targets/riscv32im_risc0_zkvm_elf.rs | 5 +- .../spec/targets/riscv32imac_esp_espidf.rs | 4 +- .../targets/riscv32imac_unknown_nuttx_elf.rs | 6 +- .../targets/riscv32imac_unknown_xous_elf.rs | 5 +- .../spec/targets/riscv32imafc_esp_espidf.rs | 4 +- .../targets/riscv32imafc_unknown_nuttx_elf.rs | 6 +- .../src/spec/targets/riscv32imc_esp_espidf.rs | 4 +- .../targets/riscv32imc_unknown_nuttx_elf.rs | 6 +- .../targets/riscv64gc_unknown_nuttx_elf.rs | 4 +- .../targets/riscv64imac_unknown_nuttx_elf.rs | 4 +- .../src/spec/targets/thumbv6m_nuttx_eabi.rs | 4 +- .../src/spec/targets/thumbv7a_nuttx_eabi.rs | 4 +- .../src/spec/targets/thumbv7a_nuttx_eabihf.rs | 4 +- .../src/spec/targets/thumbv7em_nuttx_eabi.rs | 4 +- .../spec/targets/thumbv7em_nuttx_eabihf.rs | 4 +- .../src/spec/targets/thumbv7m_nuttx_eabi.rs | 4 +- .../spec/targets/thumbv8m_base_nuttx_eabi.rs | 4 +- .../spec/targets/thumbv8m_main_nuttx_eabi.rs | 4 +- .../targets/thumbv8m_main_nuttx_eabihf.rs | 4 +- .../spec/targets/wasm32_unknown_emscripten.rs | 6 +- .../spec/targets/wasm32_unknown_unknown.rs | 4 +- .../src/spec/targets/wasm32_wasip1.rs | 4 +- .../src/spec/targets/wasm32_wasip1_threads.rs | 4 +- .../src/spec/targets/wasm32_wasip2.rs | 4 +- .../src/spec/targets/wasm32v1_none.rs | 4 +- .../spec/targets/wasm64_unknown_unknown.rs | 4 +- .../src/spec/targets/x86_64_apple_darwin.rs | 4 +- .../src/spec/targets/x86_64_apple_ios.rs | 4 +- .../spec/targets/x86_64_apple_ios_macabi.rs | 4 +- .../src/spec/targets/x86_64_apple_tvos.rs | 4 +- .../spec/targets/x86_64_apple_watchos_sim.rs | 4 +- .../targets/x86_64_fortanix_unknown_sgx.rs | 4 +- .../src/spec/targets/x86_64_unknown_trusty.rs | 4 +- .../src/spec/targets/x86_64h_apple_darwin.rs | 4 +- .../src/spec/targets/xtensa_esp32_espidf.rs | 4 +- .../src/spec/targets/xtensa_esp32s2_espidf.rs | 4 +- .../src/spec/targets/xtensa_esp32s3_espidf.rs | 4 +- src/tools/miri/src/concurrency/thread.rs | 3 +- src/tools/miri/src/eval.rs | 3 +- src/tools/miri/src/helpers.rs | 15 ++-- src/tools/miri/src/machine.rs | 4 +- src/tools/miri/src/shims/alloc.rs | 8 +- src/tools/miri/src/shims/env.rs | 5 +- src/tools/miri/src/shims/extern_static.rs | 14 +-- src/tools/miri/src/shims/foreign_items.rs | 10 +-- src/tools/miri/src/shims/os_str.rs | 5 +- src/tools/miri/src/shims/time.rs | 21 ++--- src/tools/miri/src/shims/tls.rs | 7 +- src/tools/miri/src/shims/unix/env.rs | 3 +- src/tools/miri/src/shims/unix/fd.rs | 3 +- .../miri/src/shims/unix/foreign_items.rs | 52 +++++------ src/tools/miri/src/shims/unix/fs.rs | 29 +++--- src/tools/miri/src/shims/unix/mem.rs | 3 +- .../src/shims/unix/solarish/foreign_items.rs | 9 +- src/tools/miri/src/shims/unix/sync.rs | 43 ++++----- .../miri/src/shims/unix/unnamed_socket.rs | 4 +- src/tools/miri/src/shims/windows/env.rs | 17 ++-- src/tools/miri/src/shims/windows/fs.rs | 7 +- 149 files changed, 580 insertions(+), 487 deletions(-) diff --git a/compiler/rustc_codegen_cranelift/src/lib.rs b/compiler/rustc_codegen_cranelift/src/lib.rs index 2175869085a3..5fdecd014ac0 100644 --- a/compiler/rustc_codegen_cranelift/src/lib.rs +++ b/compiler/rustc_codegen_cranelift/src/lib.rs @@ -49,7 +49,7 @@ use rustc_session::Session; use rustc_session::config::OutputFilenames; use rustc_span::{Symbol, sym}; -use rustc_target::spec::{Abi, Arch, Env}; +use rustc_target::spec::{Abi, Arch, Env, Os}; pub use crate::config::*; use crate::prelude::*; @@ -163,15 +163,15 @@ fn init(&self, sess: &Session) { fn target_config(&self, sess: &Session) -> TargetConfig { // FIXME return the actually used target features. this is necessary for #[cfg(target_feature)] let target_features = match sess.target.arch { - Arch::X86_64 if sess.target.os != "none" => { + Arch::X86_64 if sess.target.os != 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")] } - Arch::AArch64 => match &*sess.target.os { - "none" => vec![], + Arch::AArch64 => match &sess.target.os { + 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], + Os::MacOs => vec![sym::neon, sym::aes, sym::sha2, sym::sha3], // AArch64 mandates Neon support _ => vec![sym::neon], }, @@ -184,7 +184,7 @@ fn target_config(&self, sess: &Session) -> TargetConfig { // targets due to GCC using a different ABI than LLVM. Therefore `f16` and `f128` // won't be available when using a LLVM-built sysroot. let has_reliable_f16_f128 = !(sess.target.arch == Arch::X86_64 - && sess.target.os == "windows" + && sess.target.os == Os::Windows && sess.target.env == Env::Gnu && sess.target.abi != Abi::Llvm); diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs index ff29c18c56bb..b60c8a7d3719 100644 --- a/compiler/rustc_codegen_llvm/src/context.rs +++ b/compiler/rustc_codegen_llvm/src/context.rs @@ -29,7 +29,7 @@ use rustc_span::{DUMMY_SP, Span, Symbol}; use rustc_symbol_mangling::mangle_internal_symbol; use rustc_target::spec::{ - Abi, Arch, Env, HasTargetSpec, RelocModel, SmallDataThresholdSupport, Target, TlsModel, + Abi, Arch, Env, HasTargetSpec, Os, RelocModel, SmallDataThresholdSupport, Target, TlsModel, }; use smallvec::SmallVec; @@ -335,7 +335,7 @@ pub(crate) unsafe fn create_module<'ll>( // Control Flow Guard is currently only supported by MSVC and LLVM on Windows. if sess.target.is_like_msvc - || (sess.target.options.os == "windows" + || (sess.target.options.os == Os::Windows && sess.target.options.env == Env::Gnu && sess.target.options.abi == Abi::Llvm) { @@ -669,7 +669,7 @@ pub(crate) fn create_used_variable_impl(&self, name: &'static CStr, values: &[&' /// 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 == Arch::X86 && self.tcx.sess.target.os == "macos" { + if self.tcx.sess.target.arch == Arch::X86 && self.tcx.sess.target.os == Os::MacOs { // 32-bit x86 macOS uses ABI version 1 (a.k.a. the "fragile ABI"). 1 } else { @@ -963,7 +963,7 @@ pub(crate) fn eh_catch_typeinfo(&self) -> &'ll Value { return eh_catch_typeinfo; } let tcx = self.tcx; - assert!(self.sess().target.os == "emscripten"); + assert!(self.sess().target.os == Os::Emscripten); let eh_catch_typeinfo = match tcx.lang_items().eh_catch_typeinfo() { Some(def_id) => self.get_static(def_id), _ => { diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs index 0626cb3f2f16..739b33f34962 100644 --- a/compiler/rustc_codegen_llvm/src/intrinsic.rs +++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs @@ -18,6 +18,7 @@ use rustc_span::{Span, Symbol, sym}; use rustc_symbol_mangling::{mangle_internal_symbol, symbol_name_for_instance_in_crate}; use rustc_target::callconv::PassMode; +use rustc_target::spec::Os; use tracing::debug; use crate::abi::FnAbiLlvmExt; @@ -681,7 +682,7 @@ fn catch_unwind_intrinsic<'ll, 'tcx>( codegen_msvc_try(bx, try_func, data, catch_func, dest); } else if wants_wasm_eh(bx.sess()) { codegen_wasm_try(bx, try_func, data, catch_func, dest); - } else if bx.sess().target.os == "emscripten" { + } else if bx.sess().target.os == Os::Emscripten { codegen_emcc_try(bx, try_func, data, catch_func, dest); } else { codegen_gnu_try(bx, try_func, data, catch_func, dest); diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs index ea0106ce83c7..b498448417f5 100644 --- a/compiler/rustc_codegen_llvm/src/llvm_util.rs +++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs @@ -16,7 +16,7 @@ use rustc_session::Session; use rustc_session::config::{PrintKind, PrintRequest}; use rustc_target::spec::{ - Abi, Arch, Env, MergeFunctions, PanicStrategy, SmallDataThresholdSupport, + Abi, Arch, Env, MergeFunctions, Os, PanicStrategy, SmallDataThresholdSupport, }; use smallvec::{SmallVec, smallvec}; @@ -106,7 +106,7 @@ fn llvm_arg_to_arg_name(full_arg: &str) -> &str { add("-wasm-enable-eh", false); } - if sess.target.os == "emscripten" + if sess.target.os == Os::Emscripten && !sess.opts.unstable_opts.emscripten_wasm_eh && sess.panic_strategy().unwinds() { @@ -353,7 +353,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; - let target_os = sess.target.options.os.as_ref(); + let target_os = &sess.target.options.os; let target_env = &sess.target.options.env; let target_abi = &sess.target.options.abi; let target_pointer_width = sess.target.pointer_width; @@ -373,7 +373,7 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) { // Selection failure (fixed in llvm21) (Arch::S390x, _) if lt_21_0_0 => false, // MinGW ABI bugs - (Arch::X86_64, "windows") if *target_env == Env::Gnu && *target_abi != Abi::Llvm => false, + (Arch::X86_64, Os::Windows) if *target_env == Env::Gnu && *target_abi != Abi::Llvm => false, // Infinite recursion (Arch::CSky, _) => false, (Arch::Hexagon, _) if lt_21_0_0 => false, // (fixed in llvm21) @@ -405,7 +405,7 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) { // not fail if our compiler-builtins is linked. (fixed in llvm21) (Arch::X86, _) if lt_21_0_0 => false, // MinGW ABI bugs - (Arch::X86_64, "windows") if *target_env == Env::Gnu && *target_abi != Abi::Llvm => false, + (Arch::X86_64, Os::Windows) if *target_env == Env::Gnu && *target_abi != 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. @@ -428,7 +428,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 == Env::Musl => false, (Arch::X86_64, _) => false, - (_, "linux") if target_pointer_width == 64 => true, + (_, Os::Linux) if target_pointer_width == 64 => true, _ => false, } && cfg.has_reliable_f128; } diff --git a/compiler/rustc_codegen_ssa/src/back/apple.rs b/compiler/rustc_codegen_ssa/src/back/apple.rs index 09dd9170f756..23808ade6c85 100644 --- a/compiler/rustc_codegen_ssa/src/back/apple.rs +++ b/compiler/rustc_codegen_ssa/src/back/apple.rs @@ -6,7 +6,7 @@ use rustc_middle::middle::exported_symbols::SymbolExportKind; use rustc_session::Session; pub(super) use rustc_target::spec::apple::OSVersion; -use rustc_target::spec::{Arch, Env, Target}; +use rustc_target::spec::{Arch, Env, Os, Target}; use tracing::debug; use crate::errors::{XcrunError, XcrunSdkPathWarning}; @@ -17,34 +17,34 @@ /// The canonical name of the desired SDK for a given target. pub(super) fn sdk_name(target: &Target) -> &'static str { - match (&*target.os, &target.env) { - ("macos", Env::Unspecified) => "MacOSX", - ("ios", Env::Unspecified) => "iPhoneOS", - ("ios", Env::Sim) => "iPhoneSimulator", + match (&target.os, &target.env) { + (Os::MacOs, Env::Unspecified) => "MacOSX", + (Os::IOs, Env::Unspecified) => "iPhoneOS", + (Os::IOs, Env::Sim) => "iPhoneSimulator", // Mac Catalyst uses the macOS SDK - ("ios", Env::MacAbi) => "MacOSX", - ("tvos", Env::Unspecified) => "AppleTVOS", - ("tvos", Env::Sim) => "AppleTVSimulator", - ("visionos", Env::Unspecified) => "XROS", - ("visionos", Env::Sim) => "XRSimulator", - ("watchos", Env::Unspecified) => "WatchOS", - ("watchos", Env::Sim) => "WatchSimulator", + (Os::IOs, Env::MacAbi) => "MacOSX", + (Os::TvOs, Env::Unspecified) => "AppleTVOS", + (Os::TvOs, Env::Sim) => "AppleTVSimulator", + (Os::VisionOs, Env::Unspecified) => "XROS", + (Os::VisionOs, Env::Sim) => "XRSimulator", + (Os::WatchOs, Env::Unspecified) => "WatchOS", + (Os::WatchOs, Env::Sim) => "WatchSimulator", (os, abi) => unreachable!("invalid os '{os}' / abi '{abi}' combination for Apple target"), } } pub(super) fn macho_platform(target: &Target) -> u32 { - match (&*target.os, &target.env) { - ("macos", _) => object::macho::PLATFORM_MACOS, - ("ios", Env::MacAbi) => object::macho::PLATFORM_MACCATALYST, - ("ios", Env::Sim) => object::macho::PLATFORM_IOSSIMULATOR, - ("ios", _) => object::macho::PLATFORM_IOS, - ("watchos", Env::Sim) => object::macho::PLATFORM_WATCHOSSIMULATOR, - ("watchos", _) => object::macho::PLATFORM_WATCHOS, - ("tvos", Env::Sim) => object::macho::PLATFORM_TVOSSIMULATOR, - ("tvos", _) => object::macho::PLATFORM_TVOS, - ("visionos", Env::Sim) => object::macho::PLATFORM_XROSSIMULATOR, - ("visionos", _) => object::macho::PLATFORM_XROS, + match (&target.os, &target.env) { + (Os::MacOs, _) => object::macho::PLATFORM_MACOS, + (Os::IOs, Env::MacAbi) => object::macho::PLATFORM_MACCATALYST, + (Os::IOs, Env::Sim) => object::macho::PLATFORM_IOSSIMULATOR, + (Os::IOs, _) => object::macho::PLATFORM_IOS, + (Os::WatchOs, Env::Sim) => object::macho::PLATFORM_WATCHOSSIMULATOR, + (Os::WatchOs, _) => object::macho::PLATFORM_WATCHOS, + (Os::TvOs, Env::Sim) => object::macho::PLATFORM_TVOSSIMULATOR, + (Os::TvOs, _) => object::macho::PLATFORM_TVOS, + (Os::VisionOs, Env::Sim) => object::macho::PLATFORM_XROSSIMULATOR, + (Os::VisionOs, _) => object::macho::PLATFORM_XROS, (os, env) => unreachable!("invalid os '{os}' / env '{env}' combination for Apple target"), } } diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs index d01bcfe97118..ec3021b4e14e 100644 --- a/compiler/rustc_codegen_ssa/src/back/link.rs +++ b/compiler/rustc_codegen_ssa/src/back/link.rs @@ -47,7 +47,7 @@ use rustc_target::spec::crt_objects::CrtObjects; use rustc_target::spec::{ Abi, BinaryFormat, Cc, Env, LinkOutputKind, LinkSelfContainedComponents, - LinkSelfContainedDefault, LinkerFeatures, LinkerFlavor, LinkerFlavorCli, Lld, RelocModel, + LinkSelfContainedDefault, LinkerFeatures, LinkerFlavor, LinkerFlavorCli, Lld, Os, RelocModel, RelroLevel, SanitizerSet, SplitDebuginfo, }; use tracing::{debug, info, warn}; @@ -1845,7 +1845,7 @@ fn add_pre_link_objects( let empty = Default::default(); let objects = if self_contained { &opts.pre_link_objects_self_contained - } else if !(sess.target.os == "fuchsia" && matches!(flavor, LinkerFlavor::Gnu(Cc::Yes, _))) { + } else if !(sess.target.os == Os::Fuchsia && matches!(flavor, LinkerFlavor::Gnu(Cc::Yes, _))) { &opts.pre_link_objects } else { &empty @@ -2496,7 +2496,7 @@ fn add_order_independent_options( let apple_sdk_root = add_apple_sdk(cmd, sess, flavor); - if sess.target.os == "fuchsia" + if sess.target.os == Os::Fuchsia && crate_type == CrateType::Executable && !matches!(flavor, LinkerFlavor::Gnu(Cc::Yes, _)) { @@ -2515,7 +2515,7 @@ fn add_order_independent_options( cmd.no_crt_objects(); } - if sess.target.os == "emscripten" { + if sess.target.os == Os::Emscripten { cmd.cc_arg(if sess.opts.unstable_opts.emscripten_wasm_eh { "-fwasm-exceptions" } else if sess.panic_strategy().unwinds() { @@ -3070,7 +3070,7 @@ fn add_apple_link_args(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavo // `sess.target.arch` (`target_arch`) is not detailed enough. let llvm_arch = sess.target.llvm_target.split_once('-').expect("LLVM target must have arch").0; - let target_os = &*sess.target.os; + let target_os = &sess.target.os; let target_env = &sess.target.env; // The architecture name to forward to the linker. @@ -3123,12 +3123,12 @@ fn add_apple_link_args(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavo // > - xros-simulator // > - driverkit let platform_name = match (target_os, target_env) { - (os, Env::Unspecified) => os, - ("ios", Env::MacAbi) => "mac-catalyst", - ("ios", Env::Sim) => "ios-simulator", - ("tvos", Env::Sim) => "tvos-simulator", - ("watchos", Env::Sim) => "watchos-simulator", - ("visionos", Env::Sim) => "visionos-simulator", + (os, Env::Unspecified) => os.desc(), + (Os::IOs, Env::MacAbi) => "mac-catalyst", + (Os::IOs, Env::Sim) => "ios-simulator", + (Os::TvOs, Env::Sim) => "tvos-simulator", + (Os::WatchOs, Env::Sim) => "watchos-simulator", + (Os::VisionOs, Env::Sim) => "visionos-simulator", _ => bug!("invalid OS/env combination for Apple target: {target_os}, {target_env}"), }; @@ -3192,7 +3192,7 @@ fn add_apple_link_args(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavo // fairly safely use `-target`. See also the following, where it is // made explicit that the recommendation by LLVM developers is to use // `-target`: - if target_os == "macos" { + if *target_os == Os::MacOs { // `-arch` communicates the architecture. // // CC forwards the `-arch` to the linker, so we use the same value diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs index 4ee78ab3f29f..f4225b2d764b 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::ty::TyCtxt; use rustc_session::Session; use rustc_session::config::{self, CrateType, DebugInfo, LinkerPluginLto, Lto, OptLevel, Strip}; -use rustc_target::spec::{Abi, Arch, Cc, LinkOutputKind, LinkerFlavor, Lld}; +use rustc_target::spec::{Abi, Arch, Cc, LinkOutputKind, LinkerFlavor, Lld, Os}; use tracing::{debug, warn}; use super::command::Command; @@ -136,10 +136,10 @@ pub(crate) fn get_linker<'a>( // to the linker args construction. assert!(cmd.get_args().is_empty() || sess.target.abi == Abi::Uwp); match flavor { - LinkerFlavor::Unix(Cc::No) if sess.target.os == "l4re" => { + LinkerFlavor::Unix(Cc::No) if sess.target.os == Os::L4Re => { Box::new(L4Bender::new(cmd, sess)) as Box } - LinkerFlavor::Unix(Cc::No) if sess.target.os == "aix" => { + LinkerFlavor::Unix(Cc::No) if sess.target.os == Os::Aix => { Box::new(AixLinker::new(cmd, sess)) as Box } LinkerFlavor::WasmLld(Cc::No) => Box::new(WasmLd::new(cmd, sess)) as Box, @@ -573,7 +573,7 @@ fn set_output_kind( // any `#[link]` attributes in the `libc` crate, see #72782 for details. // FIXME: Switch to using `#[link]` attributes in the `libc` crate // similarly to other targets. - if self.sess.target.os == "vxworks" + if self.sess.target.os == Os::VxWorks && matches!( output_kind, LinkOutputKind::StaticNoPicExe @@ -595,7 +595,7 @@ fn set_output_kind( } fn link_dylib_by_name(&mut self, name: &str, verbatim: bool, as_needed: bool) { - if self.sess.target.os == "illumos" && name == "c" { + if self.sess.target.os == Os::Illumos && name == "c" { // libc will be added via late_link_args on illumos so that it will // appear last in the library search order. // FIXME: This should be replaced by a more complete and generic @@ -1439,7 +1439,7 @@ fn export_symbols( // symbols explicitly passed via the `--export` flags above and hides all // others. Various bits and pieces of wasm32-unknown-unknown tooling use // this, so be sure these symbols make their way out of the linker as well. - if self.sess.target.os == "unknown" || self.sess.target.os == "none" { + if matches!(self.sess.target.os, Os::Unknown | Os::None) { self.link_args(&["--export=__heap_base", "--export=__data_end"]); } } diff --git a/compiler/rustc_codegen_ssa/src/back/metadata.rs b/compiler/rustc_codegen_ssa/src/back/metadata.rs index e8a1869acc2c..6dff79374f20 100644 --- a/compiler/rustc_codegen_ssa/src/back/metadata.rs +++ b/compiler/rustc_codegen_ssa/src/back/metadata.rs @@ -20,7 +20,7 @@ use rustc_middle::bug; use rustc_session::Session; use rustc_span::sym; -use rustc_target::spec::{Abi, RelocModel, Target, ef_avr_arch}; +use rustc_target::spec::{Abi, Os, RelocModel, Target, ef_avr_arch}; use tracing::debug; use super::apple; @@ -260,10 +260,10 @@ pub(crate) fn create_object_file(sess: &Session) -> Option u8 { - match sess.target.options.os.as_ref() { - "hermit" => elf::ELFOSABI_STANDALONE, - "freebsd" => elf::ELFOSABI_FREEBSD, - "solaris" => elf::ELFOSABI_SOLARIS, + match sess.target.options.os { + Os::Hermit => elf::ELFOSABI_STANDALONE, + Os::FreeBsd => elf::ELFOSABI_FREEBSD, + Os::Solaris => elf::ELFOSABI_SOLARIS, _ => elf::ELFOSABI_NONE, } } diff --git a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs index 6fa8725a7871..a80976fad02a 100644 --- a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs +++ b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs @@ -17,7 +17,7 @@ use rustc_middle::util::Providers; use rustc_session::config::{CrateType, OomStrategy}; use rustc_symbol_mangling::mangle_internal_symbol; -use rustc_target::spec::{Arch, TlsModel}; +use rustc_target::spec::{Arch, Os, TlsModel}; use tracing::debug; use crate::back::symbol_export; @@ -711,7 +711,7 @@ pub(crate) fn extend_exported_symbols<'tcx>( ) { let (callconv, _) = calling_convention_for_symbol(tcx, symbol); - if callconv != CanonAbi::GpuKernel || tcx.sess.target.os != "amdhsa" { + if callconv != CanonAbi::GpuKernel || tcx.sess.target.os != Os::AmdHsa { return; } diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs index ed2815b06c18..414e9ce1c821 100644 --- a/compiler/rustc_codegen_ssa/src/base.rs +++ b/compiler/rustc_codegen_ssa/src/base.rs @@ -33,7 +33,7 @@ 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::Arch; +use rustc_target::spec::{Arch, Os}; use rustc_trait_selection::infer::{BoundRegionConversionTime, TyCtxtInferExt}; use rustc_trait_selection::traits::{ObligationCause, ObligationCtxt}; use tracing::{debug, info}; @@ -366,7 +366,7 @@ pub(crate) fn build_shift_expr_rhs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>( // us pub fn wants_wasm_eh(sess: &Session) -> bool { sess.target.is_like_wasm - && (sess.target.os != "emscripten" || sess.opts.unstable_opts.emscripten_wasm_eh) + && (sess.target.os != Os::Emscripten || sess.opts.unstable_opts.emscripten_wasm_eh) } /// Returns `true` if this session's target will use SEH-based unwinding. @@ -500,7 +500,7 @@ fn create_entry_fn<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>( ) -> Bx::Function { // The entry function is either `int main(void)` or `int main(int argc, char **argv)`, or // `usize efi_main(void *handle, void *system_table)` depending on the target. - let llfty = if cx.sess().target.os.contains("uefi") { + let llfty = if cx.sess().target.os == Os::Uefi { cx.type_func(&[cx.type_ptr(), cx.type_ptr()], cx.type_isize()) } else if cx.sess().target.main_needs_argc_argv { cx.type_func(&[cx.type_int(), cx.type_ptr()], cx.type_int()) @@ -562,7 +562,7 @@ fn create_entry_fn<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>( }; let result = bx.call(start_ty, None, None, start_fn, &args, None, instance); - if cx.sess().target.os.contains("uefi") { + if cx.sess().target.os == Os::Uefi { bx.ret(result); } else { let cast = bx.intcast(result, cx.type_int(), true); @@ -576,7 +576,7 @@ fn create_entry_fn<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>( /// Obtain the `argc` and `argv` values to pass to the rust start function /// (i.e., the "start" lang item). fn get_argc_argv<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(bx: &mut Bx) -> (Bx::Value, Bx::Value) { - if bx.cx().sess().target.os.contains("uefi") { + if bx.cx().sess().target.os == Os::Uefi { // Params for UEFI let param_handle = bx.get_param(0); let param_system_table = bx.get_param(1); diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs index 720f8061c4e6..c59e04c07b21 100644 --- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs +++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs @@ -16,6 +16,7 @@ use rustc_session::lint; use rustc_session::parse::feature_err; use rustc_span::{Ident, Span, sym}; +use rustc_target::spec::Os; use crate::errors; use crate::target_features::{ @@ -258,7 +259,7 @@ fn process_builtin_attrs( UsedBy::Compiler => codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED_COMPILER, UsedBy::Linker => codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED_LINKER, UsedBy::Default => { - let used_form = if tcx.sess.target.os == "illumos" { + let used_form = if tcx.sess.target.os == Os::Illumos { // illumos' `ld` doesn't support a section header that would represent // `#[used(linker)]`, see // https://github.com/rust-lang/rust/issues/146169. For that target, diff --git a/compiler/rustc_codegen_ssa/src/common.rs b/compiler/rustc_codegen_ssa/src/common.rs index b9d23e281169..89a3f8061a8c 100644 --- a/compiler/rustc_codegen_ssa/src/common.rs +++ b/compiler/rustc_codegen_ssa/src/common.rs @@ -7,7 +7,7 @@ use rustc_middle::{bug, mir, span_bug}; use rustc_session::cstore::{DllCallingConvention, DllImport}; use rustc_span::Span; -use rustc_target::spec::{Abi, Env, Target}; +use rustc_target::spec::{Abi, Env, Os, Target}; use crate::traits::*; @@ -171,7 +171,7 @@ pub fn asm_const_to_str<'tcx>( } pub fn is_mingw_gnu_toolchain(target: &Target) -> bool { - target.os == "windows" && target.env == Env::Gnu && target.abi == Abi::Unspecified + target.os == Os::Windows && target.env == Env::Gnu && target.abi == Abi::Unspecified } pub fn i686_decorated_name( diff --git a/compiler/rustc_lint/src/types/improper_ctypes.rs b/compiler/rustc_lint/src/types/improper_ctypes.rs index 2c8839708669..9e38ea6b685b 100644 --- a/compiler/rustc_lint/src/types/improper_ctypes.rs +++ b/compiler/rustc_lint/src/types/improper_ctypes.rs @@ -16,6 +16,7 @@ use rustc_session::{declare_lint, declare_lint_pass}; use rustc_span::def_id::LocalDefId; use rustc_span::{Span, sym}; +use rustc_target::spec::Os; use tracing::debug; use super::repr_nullable_ptr; @@ -177,7 +178,7 @@ fn variant_has_complex_ctor(variant: &ty::VariantDef) -> bool { /// the Power alignment Rule (see the `check_struct_for_power_alignment` function). fn check_arg_for_power_alignment<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool { let tcx = cx.tcx; - assert!(tcx.sess.target.os == "aix"); + assert!(tcx.sess.target.os == Os::Aix); // Structs (under repr(C)) follow the power alignment rule if: // - the first field of the struct is a floating-point type that // is greater than 4-bytes, or @@ -222,7 +223,7 @@ fn check_struct_for_power_alignment<'tcx>( let tcx = cx.tcx; // Only consider structs (not enums or unions) on AIX. - if tcx.sess.target.os != "aix" || !adt_def.is_struct() { + if tcx.sess.target.os != Os::Aix || !adt_def.is_struct() { return; } diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs index f7cbcf43a7e7..250657bc6806 100644 --- a/compiler/rustc_metadata/src/native_libs.rs +++ b/compiler/rustc_metadata/src/native_libs.rs @@ -15,7 +15,7 @@ use rustc_session::search_paths::PathKind; use rustc_span::Symbol; use rustc_span::def_id::{DefId, LOCAL_CRATE}; -use rustc_target::spec::{Abi, Arch, BinaryFormat, Env, LinkSelfContainedComponents}; +use rustc_target::spec::{Abi, Arch, BinaryFormat, Env, LinkSelfContainedComponents, Os}; use crate::errors; @@ -68,8 +68,8 @@ pub fn walk_native_lib_search_dirs( // non-empty, which is needed or the linker may decide to record the LIBPATH env, if // defined, as the search path instead of appending the default search paths. if sess.target.abi == Abi::Fortanix - || sess.target.os == "linux" - || sess.target.os == "fuchsia" + || sess.target.os == Os::Linux + || sess.target.os == Os::Fuchsia || sess.target.is_like_aix || sess.target.is_like_darwin && !sess.sanitizers().is_empty() { diff --git a/compiler/rustc_passes/src/weak_lang_items.rs b/compiler/rustc_passes/src/weak_lang_items.rs index 93d164e7d01f..26cd9e7f44ff 100644 --- a/compiler/rustc_passes/src/weak_lang_items.rs +++ b/compiler/rustc_passes/src/weak_lang_items.rs @@ -8,6 +8,7 @@ use rustc_middle::middle::lang_items::required; use rustc_middle::ty::TyCtxt; use rustc_session::config::CrateType; +use rustc_target::spec::Os; use crate::errors::{ MissingLangItem, MissingPanicHandler, PanicUnwindWithoutStd, UnknownExternLangItem, @@ -26,7 +27,7 @@ pub(crate) fn check_crate( if items.eh_personality().is_none() { items.missing.push(LangItem::EhPersonality); } - if tcx.sess.target.os == "emscripten" + if tcx.sess.target.os == Os::Emscripten && items.eh_catch_typeinfo().is_none() && !tcx.sess.opts.unstable_opts.emscripten_wasm_eh { diff --git a/compiler/rustc_session/src/config/cfg.rs b/compiler/rustc_session/src/config/cfg.rs index a73508c78a24..cd0556de5c22 100644 --- a/compiler/rustc_session/src/config/cfg.rs +++ b/compiler/rustc_session/src/config/cfg.rs @@ -291,7 +291,7 @@ macro_rules! ins_sym { } } - ins_str!(sym::target_os, &sess.target.os); + ins_sym!(sym::target_os, sess.target.os.desc_symbol()); ins_sym!(sym::target_pointer_width, sym::integer(sess.target.pointer_width)); if sess.opts.unstable_opts.has_thread_local.unwrap_or(sess.target.has_thread_local) { @@ -454,7 +454,7 @@ macro_rules! ins { values_target_family.extend( target.options.families.iter().map(|family| Symbol::intern(family)), ); - values_target_os.insert(Symbol::intern(&target.options.os)); + values_target_os.insert(target.options.os.desc_symbol()); values_target_pointer_width.insert(sym::integer(target.pointer_width)); values_target_vendor.insert(target.vendor_symbol()); } diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs index 9fb3c35d5ef7..f27b32de565d 100644 --- a/compiler/rustc_session/src/session.rs +++ b/compiler/rustc_session/src/session.rs @@ -32,7 +32,7 @@ use rustc_span::{FileNameDisplayPreference, RealFileName, Span, Symbol}; use rustc_target::asm::InlineAsmArch; use rustc_target::spec::{ - Arch, CodeModel, DebuginfoKind, PanicStrategy, RelocModel, RelroLevel, SanitizerSet, + Arch, CodeModel, DebuginfoKind, Os, PanicStrategy, RelocModel, RelroLevel, SanitizerSet, SmallDataThresholdSupport, SplitDebuginfo, StackProtector, SymbolVisibility, Target, TargetTuple, TlsModel, apple, }; @@ -382,7 +382,7 @@ pub fn crt_static(&self, crate_type: Option) -> bool { } pub fn is_wasi_reactor(&self) -> bool { - self.target.options.os == "wasi" + self.target.options.os == Os::Wasi && matches!( self.opts.unstable_opts.wasi_exec_model, Some(config::WasiExecModel::Reactor) diff --git a/compiler/rustc_target/src/asm/aarch64.rs b/compiler/rustc_target/src/asm/aarch64.rs index 0dcf5c74e63b..2db8a7ff3020 100644 --- a/compiler/rustc_target/src/asm/aarch64.rs +++ b/compiler/rustc_target/src/asm/aarch64.rs @@ -4,7 +4,7 @@ use rustc_span::{Symbol, sym}; use super::{InlineAsmArch, InlineAsmType, ModifierInfo}; -use crate::spec::{Env, RelocModel, Target}; +use crate::spec::{Env, Os, RelocModel, Target}; def_reg_class! { AArch64 AArch64InlineAsmRegClass { @@ -75,8 +75,8 @@ pub(crate) fn target_reserves_x18(target: &Target, target_features: &FxIndexSet< // See isX18ReservedByDefault in LLVM for targets reserve x18 by default: // https://github.com/llvm/llvm-project/blob/llvmorg-19.1.0/llvm/lib/TargetParser/AArch64TargetParser.cpp#L102-L105 // Note that +reserve-x18 is currently not set for the above targets. - target.os == "android" - || target.os == "fuchsia" + target.os == Os::Android + || target.os == Os::Fuchsia || target.env == Env::Ohos || target.is_like_darwin || target.is_like_windows diff --git a/compiler/rustc_target/src/callconv/powerpc.rs b/compiler/rustc_target/src/callconv/powerpc.rs index 34711d2843c5..2b6a104e1221 100644 --- a/compiler/rustc_target/src/callconv/powerpc.rs +++ b/compiler/rustc_target/src/callconv/powerpc.rs @@ -1,7 +1,7 @@ use rustc_abi::TyAbiInterface; use crate::callconv::{ArgAbi, FnAbi}; -use crate::spec::{Env, HasTargetSpec}; +use crate::spec::{Env, HasTargetSpec, Os}; fn classify_ret(ret: &mut ArgAbi<'_, Ty>) { if ret.layout.is_aggregate() { @@ -17,7 +17,7 @@ fn classify_arg<'a, Ty, C: HasTargetSpec>(cx: &C, arg: &mut ArgAbi<'a, Ty>) { if arg.is_ignore() { // powerpc-unknown-linux-{gnu,musl,uclibc} doesn't ignore ZSTs. - if cx.target_spec().os == "linux" + if cx.target_spec().os == Os::Linux && matches!(cx.target_spec().env, Env::Gnu | Env::Musl | Env::Uclibc) && arg.layout.is_zst() { diff --git a/compiler/rustc_target/src/callconv/powerpc64.rs b/compiler/rustc_target/src/callconv/powerpc64.rs index 536af1d9b9cd..a77724a572dc 100644 --- a/compiler/rustc_target/src/callconv/powerpc64.rs +++ b/compiler/rustc_target/src/callconv/powerpc64.rs @@ -5,7 +5,7 @@ use rustc_abi::{Endian, HasDataLayout, TyAbiInterface}; use crate::callconv::{Align, ArgAbi, FnAbi, Reg, RegKind, Uniform}; -use crate::spec::{Env, HasTargetSpec}; +use crate::spec::{Env, HasTargetSpec, Os}; #[derive(Debug, Clone, Copy, PartialEq)] enum ABI { @@ -106,9 +106,9 @@ pub(crate) fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>) Ty: TyAbiInterface<'a, C> + Copy, C: HasDataLayout + HasTargetSpec, { - let abi = if cx.target_spec().env == Env::Musl || cx.target_spec().os == "freebsd" { + let abi = if cx.target_spec().env == Env::Musl || cx.target_spec().os == Os::FreeBsd { ELFv2 - } else if cx.target_spec().os == "aix" { + } else if cx.target_spec().os == Os::Aix { AIX } else { match cx.data_layout().endian { diff --git a/compiler/rustc_target/src/callconv/s390x.rs b/compiler/rustc_target/src/callconv/s390x.rs index a9ebd60b56f2..a2ff6f5a3a03 100644 --- a/compiler/rustc_target/src/callconv/s390x.rs +++ b/compiler/rustc_target/src/callconv/s390x.rs @@ -4,7 +4,7 @@ use rustc_abi::{BackendRepr, HasDataLayout, TyAbiInterface}; use crate::callconv::{ArgAbi, FnAbi, Reg, RegKind}; -use crate::spec::{Env, HasTargetSpec}; +use crate::spec::{Env, HasTargetSpec, Os}; fn classify_ret(ret: &mut ArgAbi<'_, Ty>) { let size = ret.layout.size; @@ -29,7 +29,7 @@ fn classify_arg<'a, Ty, C>(cx: &C, arg: &mut ArgAbi<'a, Ty>) } if arg.is_ignore() { // s390x-unknown-linux-{gnu,musl,uclibc} doesn't ignore ZSTs. - if cx.target_spec().os == "linux" + if cx.target_spec().os == Os::Linux && matches!(cx.target_spec().env, Env::Gnu | Env::Musl | Env::Uclibc) && arg.layout.is_zst() { diff --git a/compiler/rustc_target/src/callconv/sparc64.rs b/compiler/rustc_target/src/callconv/sparc64.rs index d4e8b8a086f6..73e9a46ed5b2 100644 --- a/compiler/rustc_target/src/callconv/sparc64.rs +++ b/compiler/rustc_target/src/callconv/sparc64.rs @@ -6,7 +6,7 @@ }; use crate::callconv::{ArgAbi, ArgAttribute, CastTarget, FnAbi, Uniform}; -use crate::spec::{Env, HasTargetSpec}; +use crate::spec::{Env, HasTargetSpec, Os}; #[derive(Clone, Debug)] struct Sdata { @@ -223,7 +223,7 @@ pub(crate) fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>) for arg in fn_abi.args.iter_mut() { if arg.is_ignore() { // sparc64-unknown-linux-{gnu,musl,uclibc} doesn't ignore ZSTs. - if cx.target_spec().os == "linux" + if cx.target_spec().os == Os::Linux && matches!(cx.target_spec().env, Env::Gnu | Env::Musl | Env::Uclibc) && arg.layout.is_zst() { diff --git a/compiler/rustc_target/src/spec/base/aix.rs b/compiler/rustc_target/src/spec/base/aix.rs index 34522aa37722..76e8fb763e58 100644 --- a/compiler/rustc_target/src/spec/base/aix.rs +++ b/compiler/rustc_target/src/spec/base/aix.rs @@ -1,7 +1,8 @@ use rustc_abi::Endian; use crate::spec::{ - Abi, BinaryFormat, Cc, CodeModel, LinkOutputKind, LinkerFlavor, TargetOptions, crt_objects, cvs, + Abi, BinaryFormat, Cc, CodeModel, LinkOutputKind, LinkerFlavor, Os, TargetOptions, crt_objects, + cvs, }; pub(crate) fn opts() -> TargetOptions { @@ -9,7 +10,7 @@ pub(crate) fn opts() -> TargetOptions { abi: Abi::VecExtAbi, code_model: Some(CodeModel::Large), cpu: "pwr7".into(), - os: "aix".into(), + os: Os::Aix, vendor: "ibm".into(), dynamic_linking: true, endian: Endian::Big, diff --git a/compiler/rustc_target/src/spec/base/android.rs b/compiler/rustc_target/src/spec/base/android.rs index df2757aaabf6..c7f5d863bf67 100644 --- a/compiler/rustc_target/src/spec/base/android.rs +++ b/compiler/rustc_target/src/spec/base/android.rs @@ -1,8 +1,8 @@ -use crate::spec::{SanitizerSet, TargetOptions, TlsModel, base}; +use crate::spec::{Os, SanitizerSet, TargetOptions, TlsModel, base}; pub(crate) fn opts() -> TargetOptions { let mut base = base::linux::opts(); - base.os = "android".into(); + base.os = Os::Android; base.is_like_android = true; base.default_dwarf_version = 2; base.tls_model = TlsModel::Emulated; diff --git a/compiler/rustc_target/src/spec/base/apple/mod.rs b/compiler/rustc_target/src/spec/base/apple/mod.rs index 45ac54c68f8a..87e7dca24dbc 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::str::FromStr; use crate::spec::{ - Abi, BinaryFormat, Cc, DebuginfoKind, Env, FloatAbi, FramePointer, LinkerFlavor, Lld, RustcAbi, - SplitDebuginfo, StackProbeType, StaticCow, Target, TargetOptions, cvs, + Abi, BinaryFormat, Cc, DebuginfoKind, Env, FloatAbi, FramePointer, LinkerFlavor, Lld, Os, + RustcAbi, SplitDebuginfo, StackProbeType, StaticCow, Target, TargetOptions, cvs, }; #[cfg(test)] @@ -114,13 +114,15 @@ fn target_abi(self) -> Abi { /// Get the base target options, unversioned LLVM target and `target_arch` from the three /// things that uniquely identify Rust's Apple targets: The OS, the architecture, and the ABI. pub(crate) fn base( - os: &'static str, + os: Os, arch: Arch, env: TargetEnv, ) -> (TargetOptions, StaticCow, crate::spec::Arch) { + let link_env_remove = link_env_remove(&os); + let unversioned_llvm_target = unversioned_llvm_target(&os, arch, env); let mut opts = TargetOptions { llvm_floatabi: Some(FloatAbi::Hard), - os: os.into(), + os, env: env.target_env(), // NOTE: We originally set `cfg(target_abi = "macabi")` / `cfg(target_abi = "sim")`, // before it was discovered that those are actually environments: @@ -130,7 +132,7 @@ pub(crate) fn base( // FIXME(madsmtm): Warn about using these in the future. abi: env.target_abi(), cpu: arch.target_cpu(env).into(), - link_env_remove: link_env_remove(os), + link_env_remove, vendor: "apple".into(), linker_flavor: LinkerFlavor::Darwin(Cc::Yes, Lld::No), // macOS has -dead_strip, which doesn't rely on function_sections @@ -197,23 +199,23 @@ pub(crate) fn base( // All Apple x86-32 targets have SSE2. opts.rustc_abi = Some(RustcAbi::X86Sse2); } - (opts, unversioned_llvm_target(os, arch, env), arch.target_arch()) + (opts, unversioned_llvm_target, arch.target_arch()) } /// Generate part of the LLVM target triple. /// /// See `rustc_codegen_ssa::back::versioned_llvm_target` for the full triple passed to LLVM and /// Clang. -fn unversioned_llvm_target(os: &str, arch: Arch, env: TargetEnv) -> StaticCow { +fn unversioned_llvm_target(os: &Os, arch: Arch, env: TargetEnv) -> StaticCow { let arch = arch.target_name(); // Convert to the "canonical" OS name used by LLVM: // https://github.com/llvm/llvm-project/blob/llvmorg-18.1.8/llvm/lib/TargetParser/Triple.cpp#L236-L282 let os = match os { - "macos" => "macosx", - "ios" => "ios", - "watchos" => "watchos", - "tvos" => "tvos", - "visionos" => "xros", + Os::MacOs => "macosx", + Os::IOs => "ios", + Os::WatchOs => "watchos", + Os::TvOs => "tvos", + Os::VisionOs => "xros", _ => unreachable!("tried to get LLVM target OS for non-Apple platform"), }; let environment = match env { @@ -224,13 +226,13 @@ fn unversioned_llvm_target(os: &str, arch: Arch, env: TargetEnv) -> StaticCow StaticCow<[StaticCow]> { +fn link_env_remove(os: &Os) -> StaticCow<[StaticCow]> { // Apple platforms only officially support macOS as a host for any compilation. // // If building for macOS, we go ahead and remove any erroneous environment state // that's only applicable to cross-OS compilation. Always leave anything for the // host OS alone though. - if os == "macos" { + if *os == Os::MacOs { // `IPHONEOS_DEPLOYMENT_TARGET` must not be set when using the Xcode linker at // "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/ld", // although this is apparently ignored when using the linker at "/usr/bin/ld". @@ -292,7 +294,7 @@ pub fn fmt_full(self) -> impl Display { } /// Minimum operating system versions currently supported by `rustc`. - pub fn os_minimum_deployment_target(os: &str) -> Self { + pub fn os_minimum_deployment_target(os: &Os) -> Self { // When bumping a version in here, remember to update the platform-support docs too. // // NOTE: The defaults may change in future `rustc` versions, so if you are looking for the @@ -301,12 +303,14 @@ pub fn os_minimum_deployment_target(os: &str) -> Self { // $ rustc --print deployment-target // ``` let (major, minor, patch) = match os { - "macos" => (10, 12, 0), - "ios" => (10, 0, 0), - "tvos" => (10, 0, 0), - "watchos" => (5, 0, 0), - "visionos" => (1, 0, 0), - _ => unreachable!("tried to get deployment target for non-Apple platform"), + Os::MacOs => (10, 12, 0), + Os::IOs => (10, 0, 0), + Os::TvOs => (10, 0, 0), + Os::WatchOs => (5, 0, 0), + Os::VisionOs => (1, 0, 0), + other => { + unreachable!("tried to get deployment target for non-Apple platform: {:?}", other) + } }; Self { major, minor, patch } } @@ -319,36 +323,36 @@ pub fn os_minimum_deployment_target(os: &str) -> Self { /// 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", crate::spec::Arch::AArch64, _) => (11, 0, 0), - ("ios", crate::spec::Arch::AArch64, Env::MacAbi) => (14, 0, 0), - ("ios", crate::spec::Arch::AArch64, Env::Sim) => (14, 0, 0), - ("ios", _, _) if target.llvm_target.starts_with("arm64e") => (14, 0, 0), + let (major, minor, patch) = match (&target.os, &target.arch, &target.env) { + (Os::MacOs, crate::spec::Arch::AArch64, _) => (11, 0, 0), + (Os::IOs, crate::spec::Arch::AArch64, Env::MacAbi) => (14, 0, 0), + (Os::IOs, crate::spec::Arch::AArch64, Env::Sim) => (14, 0, 0), + (Os::IOs, _, _) if target.llvm_target.starts_with("arm64e") => (14, 0, 0), // Mac Catalyst defaults to 13.1 in Clang. - ("ios", _, Env::MacAbi) => (13, 1, 0), - ("tvos", crate::spec::Arch::AArch64, Env::Sim) => (14, 0, 0), - ("watchos", crate::spec::Arch::AArch64, Env::Sim) => (7, 0, 0), + (Os::IOs, _, Env::MacAbi) => (13, 1, 0), + (Os::TvOs, crate::spec::Arch::AArch64, Env::Sim) => (14, 0, 0), + (Os::WatchOs, crate::spec::Arch::AArch64, Env::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", crate::spec::Arch::AArch64, Env::Unspecified) + (Os::WatchOs, crate::spec::Arch::AArch64, Env::Unspecified) if !target.llvm_target.starts_with("arm64_32") => { (26, 0, 0) } - (os, _, _) => return Self::os_minimum_deployment_target(os), + _ => return Self::os_minimum_deployment_target(&target.os), }; Self { major, minor, patch } } } /// Name of the environment variable used to fetch the deployment target on the given OS. -pub fn deployment_target_env_var(os: &str) -> &'static str { +pub fn deployment_target_env_var(os: &Os) -> &'static str { match os { - "macos" => "MACOSX_DEPLOYMENT_TARGET", - "ios" => "IPHONEOS_DEPLOYMENT_TARGET", - "watchos" => "WATCHOS_DEPLOYMENT_TARGET", - "tvos" => "TVOS_DEPLOYMENT_TARGET", - "visionos" => "XROS_DEPLOYMENT_TARGET", + Os::MacOs => "MACOSX_DEPLOYMENT_TARGET", + Os::IOs => "IPHONEOS_DEPLOYMENT_TARGET", + Os::WatchOs => "WATCHOS_DEPLOYMENT_TARGET", + Os::TvOs => "TVOS_DEPLOYMENT_TARGET", + Os::VisionOs => "XROS_DEPLOYMENT_TARGET", _ => unreachable!("tried to get deployment target env var for non-Apple platform"), } } diff --git a/compiler/rustc_target/src/spec/base/cygwin.rs b/compiler/rustc_target/src/spec/base/cygwin.rs index d6ae0a905bf6..fcc2a732c18d 100644 --- a/compiler/rustc_target/src/spec/base/cygwin.rs +++ b/compiler/rustc_target/src/spec/base/cygwin.rs @@ -1,8 +1,8 @@ use std::borrow::Cow; use crate::spec::{ - BinaryFormat, Cc, DebuginfoKind, LinkerFlavor, Lld, SplitDebuginfo, TargetOptions, TlsModel, - cvs, + BinaryFormat, Cc, DebuginfoKind, LinkerFlavor, Lld, Os, SplitDebuginfo, TargetOptions, + TlsModel, cvs, }; pub(crate) fn opts() -> TargetOptions { @@ -24,7 +24,7 @@ pub(crate) fn opts() -> TargetOptions { cygwin_libs, ); TargetOptions { - os: "cygwin".into(), + os: Os::Cygwin, vendor: "pc".into(), // FIXME(#13846) this should be enabled for cygwin function_sections: false, diff --git a/compiler/rustc_target/src/spec/base/dragonfly.rs b/compiler/rustc_target/src/spec/base/dragonfly.rs index 36c9489fb705..af8fd9a03689 100644 --- a/compiler/rustc_target/src/spec/base/dragonfly.rs +++ b/compiler/rustc_target/src/spec/base/dragonfly.rs @@ -1,8 +1,8 @@ -use crate::spec::{RelroLevel, TargetOptions, cvs}; +use crate::spec::{Os, RelroLevel, TargetOptions, cvs}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "dragonfly".into(), + os: Os::Dragonfly, dynamic_linking: true, families: cvs!["unix"], has_rpath: true, diff --git a/compiler/rustc_target/src/spec/base/freebsd.rs b/compiler/rustc_target/src/spec/base/freebsd.rs index 360232933027..6bbb84a653fb 100644 --- a/compiler/rustc_target/src/spec/base/freebsd.rs +++ b/compiler/rustc_target/src/spec/base/freebsd.rs @@ -1,8 +1,8 @@ -use crate::spec::{RelroLevel, TargetOptions, cvs}; +use crate::spec::{Os, RelroLevel, TargetOptions, cvs}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "freebsd".into(), + os: Os::FreeBsd, dynamic_linking: true, families: cvs!["unix"], has_rpath: true, diff --git a/compiler/rustc_target/src/spec/base/fuchsia.rs b/compiler/rustc_target/src/spec/base/fuchsia.rs index 92cb0299ddb2..a43c3e2bab55 100644 --- a/compiler/rustc_target/src/spec/base/fuchsia.rs +++ b/compiler/rustc_target/src/spec/base/fuchsia.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Cc, FramePointer, LinkOutputKind, LinkerFlavor, Lld, TargetOptions, crt_objects, cvs, + Cc, FramePointer, LinkOutputKind, LinkerFlavor, Lld, Os, TargetOptions, crt_objects, cvs, }; pub(crate) fn opts() -> TargetOptions { @@ -30,7 +30,7 @@ pub(crate) fn opts() -> TargetOptions { ); TargetOptions { - os: "fuchsia".into(), + os: Os::Fuchsia, linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), linker: Some("rust-lld".into()), dynamic_linking: true, diff --git a/compiler/rustc_target/src/spec/base/haiku.rs b/compiler/rustc_target/src/spec/base/haiku.rs index 35e4cd2962ee..d4e6545a9f58 100644 --- a/compiler/rustc_target/src/spec/base/haiku.rs +++ b/compiler/rustc_target/src/spec/base/haiku.rs @@ -1,8 +1,8 @@ -use crate::spec::{RelroLevel, TargetOptions, cvs}; +use crate::spec::{Os, RelroLevel, TargetOptions, cvs}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "haiku".into(), + os: Os::Haiku, dynamic_linking: true, families: cvs!["unix"], relro_level: RelroLevel::Full, diff --git a/compiler/rustc_target/src/spec/base/helenos.rs b/compiler/rustc_target/src/spec/base/helenos.rs index 8d6f406e41f7..e26633121b82 100644 --- a/compiler/rustc_target/src/spec/base/helenos.rs +++ b/compiler/rustc_target/src/spec/base/helenos.rs @@ -1,8 +1,8 @@ -use crate::spec::{PanicStrategy, RelroLevel, StackProbeType, TargetOptions}; +use crate::spec::{Os, PanicStrategy, RelroLevel, StackProbeType, TargetOptions}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "helenos".into(), + os: Os::HelenOs, dynamic_linking: true, // we need the linker to keep libgcc and friends diff --git a/compiler/rustc_target/src/spec/base/hermit.rs b/compiler/rustc_target/src/spec/base/hermit.rs index 971abef80d9b..1fa50c25439c 100644 --- a/compiler/rustc_target/src/spec/base/hermit.rs +++ b/compiler/rustc_target/src/spec/base/hermit.rs @@ -1,8 +1,8 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, PanicStrategy, TargetOptions, TlsModel}; +use crate::spec::{Cc, LinkerFlavor, Lld, Os, PanicStrategy, TargetOptions, TlsModel}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "hermit".into(), + os: Os::Hermit, linker: Some("rust-lld".into()), linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), tls_model: TlsModel::InitialExec, diff --git a/compiler/rustc_target/src/spec/base/hurd.rs b/compiler/rustc_target/src/spec/base/hurd.rs index dcb346ddecca..c814fe934291 100644 --- a/compiler/rustc_target/src/spec/base/hurd.rs +++ b/compiler/rustc_target/src/spec/base/hurd.rs @@ -1,8 +1,8 @@ -use crate::spec::{RelroLevel, TargetOptions, cvs}; +use crate::spec::{Os, RelroLevel, TargetOptions, cvs}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "hurd".into(), + os: Os::Hurd, dynamic_linking: true, families: cvs!["unix"], has_rpath: true, diff --git a/compiler/rustc_target/src/spec/base/illumos.rs b/compiler/rustc_target/src/spec/base/illumos.rs index 2391b229e5ba..50ff14bbf0a2 100644 --- a/compiler/rustc_target/src/spec/base/illumos.rs +++ b/compiler/rustc_target/src/spec/base/illumos.rs @@ -1,4 +1,4 @@ -use crate::spec::{Cc, FramePointer, LinkerFlavor, TargetOptions, cvs}; +use crate::spec::{Cc, FramePointer, LinkerFlavor, Os, TargetOptions, cvs}; pub(crate) fn opts() -> TargetOptions { let late_link_args = TargetOptions::link_args( @@ -25,7 +25,7 @@ pub(crate) fn opts() -> TargetOptions { ); TargetOptions { - os: "illumos".into(), + os: Os::Illumos, dynamic_linking: true, has_rpath: true, families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/base/l4re.rs b/compiler/rustc_target/src/spec/base/l4re.rs index 126865549ea6..8722c8a71e23 100644 --- a/compiler/rustc_target/src/spec/base/l4re.rs +++ b/compiler/rustc_target/src/spec/base/l4re.rs @@ -1,8 +1,8 @@ -use crate::spec::{Cc, Env, LinkerFlavor, PanicStrategy, RelocModel, TargetOptions, cvs}; +use crate::spec::{Cc, Env, LinkerFlavor, Os, PanicStrategy, RelocModel, TargetOptions, cvs}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "l4re".into(), + os: Os::L4Re, env: Env::Uclibc, linker_flavor: LinkerFlavor::Unix(Cc::No), panic_strategy: PanicStrategy::Abort, diff --git a/compiler/rustc_target/src/spec/base/linux.rs b/compiler/rustc_target/src/spec/base/linux.rs index 26e4590cf5e6..e7757fd4726c 100644 --- a/compiler/rustc_target/src/spec/base/linux.rs +++ b/compiler/rustc_target/src/spec/base/linux.rs @@ -1,10 +1,10 @@ use std::borrow::Cow; -use crate::spec::{RelroLevel, SplitDebuginfo, TargetOptions, cvs}; +use crate::spec::{Os, RelroLevel, SplitDebuginfo, TargetOptions, cvs}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "linux".into(), + os: Os::Linux, dynamic_linking: true, families: cvs!["unix"], has_rpath: true, diff --git a/compiler/rustc_target/src/spec/base/linux_wasm.rs b/compiler/rustc_target/src/spec/base/linux_wasm.rs index c13b130b3691..994299e5c025 100644 --- a/compiler/rustc_target/src/spec/base/linux_wasm.rs +++ b/compiler/rustc_target/src/spec/base/linux_wasm.rs @@ -2,7 +2,7 @@ //! aspects from their respective base targets use crate::spec::{ - Cc, Env, LinkSelfContainedDefault, LinkerFlavor, PanicStrategy, RelocModel, TargetOptions, + Cc, Env, LinkSelfContainedDefault, LinkerFlavor, Os, PanicStrategy, RelocModel, TargetOptions, TlsModel, add_link_args, crt_objects, cvs, }; @@ -57,7 +57,7 @@ macro_rules! args { TargetOptions { is_like_wasm: true, families: cvs!["wasm", "unix"], - os: "linux".into(), + os: Os::Linux, env: Env::Musl, // we allow dynamic linking, but only cdylibs. Basically we allow a diff --git a/compiler/rustc_target/src/spec/base/lynxos178.rs b/compiler/rustc_target/src/spec/base/lynxos178.rs index b9434ff5faaf..3ce53d59949c 100644 --- a/compiler/rustc_target/src/spec/base/lynxos178.rs +++ b/compiler/rustc_target/src/spec/base/lynxos178.rs @@ -1,12 +1,12 @@ use std::borrow::Cow; use crate::spec::{ - PanicStrategy, RelocModel, RelroLevel, SplitDebuginfo, StackProbeType, TargetOptions, cvs, + Os, PanicStrategy, RelocModel, RelroLevel, SplitDebuginfo, StackProbeType, TargetOptions, cvs, }; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "lynxos178".into(), + os: Os::LynxOs178, dynamic_linking: false, families: cvs!["unix"], position_independent_executables: false, diff --git a/compiler/rustc_target/src/spec/base/managarm_mlibc.rs b/compiler/rustc_target/src/spec/base/managarm_mlibc.rs index 3eea65550399..2384fc37d84a 100644 --- a/compiler/rustc_target/src/spec/base/managarm_mlibc.rs +++ b/compiler/rustc_target/src/spec/base/managarm_mlibc.rs @@ -1,8 +1,8 @@ -use crate::spec::{Env, RelroLevel, TargetOptions, cvs}; +use crate::spec::{Env, Os, RelroLevel, TargetOptions, cvs}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "managarm".into(), + os: Os::Managarm, env: Env::Mlibc, dynamic_linking: true, executables: true, diff --git a/compiler/rustc_target/src/spec/base/motor.rs b/compiler/rustc_target/src/spec/base/motor.rs index 18485b2cef2f..7b75c9bf253a 100644 --- a/compiler/rustc_target/src/spec/base/motor.rs +++ b/compiler/rustc_target/src/spec/base/motor.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Cc, FramePointer, LinkerFlavor, Lld, PanicStrategy, StackProbeType, TargetOptions, + Cc, FramePointer, LinkerFlavor, Lld, Os, PanicStrategy, StackProbeType, TargetOptions, }; pub(crate) fn opts() -> TargetOptions { @@ -16,7 +16,7 @@ pub(crate) fn opts() -> TargetOptions { ], ); TargetOptions { - os: "motor".into(), + os: Os::Motor, executables: true, // TLS is false below because if true, the compiler assumes // we handle TLS at the ELF loading level, which we don't. diff --git a/compiler/rustc_target/src/spec/base/netbsd.rs b/compiler/rustc_target/src/spec/base/netbsd.rs index b92d8933a27a..566cebdf744c 100644 --- a/compiler/rustc_target/src/spec/base/netbsd.rs +++ b/compiler/rustc_target/src/spec/base/netbsd.rs @@ -1,8 +1,8 @@ -use crate::spec::{RelroLevel, TargetOptions, cvs}; +use crate::spec::{Os, RelroLevel, TargetOptions, cvs}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "netbsd".into(), + os: Os::NetBsd, dynamic_linking: true, families: cvs!["unix"], no_default_libraries: false, diff --git a/compiler/rustc_target/src/spec/base/nto_qnx.rs b/compiler/rustc_target/src/spec/base/nto_qnx.rs index 119c5ec98f95..417ac0bc0189 100644 --- a/compiler/rustc_target/src/spec/base/nto_qnx.rs +++ b/compiler/rustc_target/src/spec/base/nto_qnx.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Cc, LinkArgs, LinkerFlavor, Lld, RelroLevel, Target, TargetMetadata, TargetOptions, cvs, + Cc, LinkArgs, LinkerFlavor, Lld, Os, RelroLevel, Target, TargetMetadata, TargetOptions, cvs, }; pub(crate) fn opts() -> TargetOptions { @@ -11,7 +11,7 @@ pub(crate) fn opts() -> TargetOptions { has_rpath: true, has_thread_local: false, linker: Some("qcc".into()), - os: "nto".into(), + os: Os::Nto, // We want backtraces to work by default and they rely on unwind tables // (regardless of `-C panic` strategy). default_uwtable: true, diff --git a/compiler/rustc_target/src/spec/base/openbsd.rs b/compiler/rustc_target/src/spec/base/openbsd.rs index 481fbdf0b08e..84395a407895 100644 --- a/compiler/rustc_target/src/spec/base/openbsd.rs +++ b/compiler/rustc_target/src/spec/base/openbsd.rs @@ -1,8 +1,8 @@ -use crate::spec::{FramePointer, RelroLevel, TargetOptions, TlsModel, cvs}; +use crate::spec::{FramePointer, Os, RelroLevel, TargetOptions, TlsModel, cvs}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "openbsd".into(), + os: Os::OpenBsd, dynamic_linking: true, families: cvs!["unix"], has_rpath: true, diff --git a/compiler/rustc_target/src/spec/base/redox.rs b/compiler/rustc_target/src/spec/base/redox.rs index 8a394df2dff8..fc12cbb7b2b4 100644 --- a/compiler/rustc_target/src/spec/base/redox.rs +++ b/compiler/rustc_target/src/spec/base/redox.rs @@ -1,8 +1,8 @@ -use crate::spec::{Cc, Env, LinkerFlavor, Lld, RelroLevel, TargetOptions, cvs}; +use crate::spec::{Cc, Env, LinkerFlavor, Lld, Os, RelroLevel, TargetOptions, cvs}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "redox".into(), + os: Os::Redox, env: Env::Relibc, dynamic_linking: true, families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/base/solaris.rs b/compiler/rustc_target/src/spec/base/solaris.rs index 22288b86e2ec..be43e44557b7 100644 --- a/compiler/rustc_target/src/spec/base/solaris.rs +++ b/compiler/rustc_target/src/spec/base/solaris.rs @@ -1,8 +1,8 @@ -use crate::spec::{Cc, LinkerFlavor, TargetOptions, cvs}; +use crate::spec::{Cc, LinkerFlavor, Os, TargetOptions, cvs}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "solaris".into(), + os: Os::Solaris, dynamic_linking: true, has_rpath: true, families: cvs!["unix"], diff --git a/compiler/rustc_target/src/spec/base/solid.rs b/compiler/rustc_target/src/spec/base/solid.rs index fd55e1d15014..042942a5a196 100644 --- a/compiler/rustc_target/src/spec/base/solid.rs +++ b/compiler/rustc_target/src/spec/base/solid.rs @@ -1,8 +1,8 @@ -use crate::spec::{FramePointer, TargetOptions}; +use crate::spec::{FramePointer, Os, TargetOptions}; -pub(crate) fn opts(kernel: &str) -> TargetOptions { +pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: format!("solid_{kernel}").into(), + os: Os::SolidAsp3, vendor: "kmc".into(), executables: false, frame_pointer: FramePointer::NonLeaf, diff --git a/compiler/rustc_target/src/spec/base/teeos.rs b/compiler/rustc_target/src/spec/base/teeos.rs index ecd9752c213e..f78ea035b221 100644 --- a/compiler/rustc_target/src/spec/base/teeos.rs +++ b/compiler/rustc_target/src/spec/base/teeos.rs @@ -1,4 +1,6 @@ -use crate::spec::{Cc, LinkerFlavor, Lld, PanicStrategy, RelroLevel, TargetOptions, add_link_args}; +use crate::spec::{ + Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelroLevel, TargetOptions, add_link_args, +}; pub(crate) fn opts() -> TargetOptions { let lld_args = &["-zmax-page-size=4096", "-znow", "-ztext", "--execute-only"]; @@ -8,8 +10,7 @@ pub(crate) fn opts() -> TargetOptions { add_link_args(&mut pre_link_args, LinkerFlavor::Gnu(Cc::Yes, Lld::No), cc_args); TargetOptions { - os: "teeos".into(), - vendor: "unknown".into(), + os: Os::TeeOs, dynamic_linking: true, linker_flavor: LinkerFlavor::Gnu(Cc::Yes, Lld::No), // rpath hardcodes -Wl, so it can't be used together with ld.lld. diff --git a/compiler/rustc_target/src/spec/base/uefi_msvc.rs b/compiler/rustc_target/src/spec/base/uefi_msvc.rs index 4766eab7fd7c..99005715018a 100644 --- a/compiler/rustc_target/src/spec/base/uefi_msvc.rs +++ b/compiler/rustc_target/src/spec/base/uefi_msvc.rs @@ -9,7 +9,7 @@ // the timer-interrupt. Device-drivers are required to use polling-based models. Furthermore, all // code runs in the same environment, no process separation is supported. -use crate::spec::{LinkerFlavor, Lld, PanicStrategy, StackProbeType, TargetOptions, base}; +use crate::spec::{LinkerFlavor, Lld, Os, PanicStrategy, StackProbeType, TargetOptions, base}; pub(crate) fn opts() -> TargetOptions { let mut base = base::msvc::opts(); @@ -35,7 +35,7 @@ pub(crate) fn opts() -> TargetOptions { ); TargetOptions { - os: "uefi".into(), + os: Os::Uefi, linker_flavor: LinkerFlavor::Msvc(Lld::Yes), disable_redzone: true, exe_suffix: ".efi".into(), diff --git a/compiler/rustc_target/src/spec/base/unikraft_linux_musl.rs b/compiler/rustc_target/src/spec/base/unikraft_linux_musl.rs index 154633090d7b..4efcc4b03a95 100644 --- a/compiler/rustc_target/src/spec/base/unikraft_linux_musl.rs +++ b/compiler/rustc_target/src/spec/base/unikraft_linux_musl.rs @@ -1,8 +1,8 @@ -use crate::spec::{Env, PanicStrategy, RelocModel, TargetOptions, cvs}; +use crate::spec::{Env, Os, PanicStrategy, RelocModel, TargetOptions, cvs}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "linux".into(), + os: Os::Linux, env: Env::Musl, vendor: "unikraft".into(), linker: Some("kraftld".into()), diff --git a/compiler/rustc_target/src/spec/base/vxworks.rs b/compiler/rustc_target/src/spec/base/vxworks.rs index 04e1d4b9a826..129554b5aae4 100644 --- a/compiler/rustc_target/src/spec/base/vxworks.rs +++ b/compiler/rustc_target/src/spec/base/vxworks.rs @@ -1,8 +1,8 @@ -use crate::spec::{Env, TargetOptions, cvs}; +use crate::spec::{Env, Os, TargetOptions, cvs}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "vxworks".into(), + os: Os::VxWorks, env: Env::Gnu, vendor: "wrs".into(), linker: Some("wr-c++".into()), diff --git a/compiler/rustc_target/src/spec/base/windows_gnu.rs b/compiler/rustc_target/src/spec/base/windows_gnu.rs index d8e660c7cda2..d2fe42b90306 100644 --- a/compiler/rustc_target/src/spec/base/windows_gnu.rs +++ b/compiler/rustc_target/src/spec/base/windows_gnu.rs @@ -1,7 +1,7 @@ use std::borrow::Cow; use crate::spec::{ - BinaryFormat, Cc, DebuginfoKind, Env, LinkSelfContainedDefault, LinkerFlavor, Lld, + BinaryFormat, Cc, DebuginfoKind, Env, LinkSelfContainedDefault, LinkerFlavor, Lld, Os, SplitDebuginfo, TargetOptions, add_link_args, crt_objects, cvs, }; @@ -77,7 +77,7 @@ pub(crate) fn opts() -> TargetOptions { ); TargetOptions { - os: "windows".into(), + os: Os::Windows, env: Env::Gnu, vendor: "pc".into(), // FIXME(#13846) this should be enabled for windows diff --git a/compiler/rustc_target/src/spec/base/windows_gnullvm.rs b/compiler/rustc_target/src/spec/base/windows_gnullvm.rs index 41b8a0122fb0..58aff198a660 100644 --- a/compiler/rustc_target/src/spec/base/windows_gnullvm.rs +++ b/compiler/rustc_target/src/spec/base/windows_gnullvm.rs @@ -1,8 +1,8 @@ use std::borrow::Cow; use crate::spec::{ - Abi, BinaryFormat, Cc, DebuginfoKind, Env, LinkerFlavor, Lld, SplitDebuginfo, TargetOptions, - cvs, + Abi, BinaryFormat, Cc, DebuginfoKind, Env, LinkerFlavor, Lld, Os, SplitDebuginfo, + TargetOptions, cvs, }; pub(crate) fn opts() -> TargetOptions { @@ -21,7 +21,7 @@ pub(crate) fn opts() -> TargetOptions { ); TargetOptions { - os: "windows".into(), + os: Os::Windows, env: Env::Gnu, vendor: "pc".into(), abi: Abi::Llvm, diff --git a/compiler/rustc_target/src/spec/base/windows_msvc.rs b/compiler/rustc_target/src/spec/base/windows_msvc.rs index d2c143613891..963253c3162b 100644 --- a/compiler/rustc_target/src/spec/base/windows_msvc.rs +++ b/compiler/rustc_target/src/spec/base/windows_msvc.rs @@ -1,10 +1,10 @@ -use crate::spec::{Env, TargetOptions, base, cvs}; +use crate::spec::{Env, Os, TargetOptions, base, cvs}; pub(crate) fn opts() -> TargetOptions { let base = base::msvc::opts(); TargetOptions { - os: "windows".into(), + os: Os::Windows, env: Env::Msvc, vendor: "pc".into(), dynamic_linking: true, diff --git a/compiler/rustc_target/src/spec/base/xtensa.rs b/compiler/rustc_target/src/spec/base/xtensa.rs index a7cc748973c4..d1b803d51a2b 100644 --- a/compiler/rustc_target/src/spec/base/xtensa.rs +++ b/compiler/rustc_target/src/spec/base/xtensa.rs @@ -1,10 +1,10 @@ use rustc_abi::Endian; -use crate::spec::{Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, TargetOptions}; +use crate::spec::{Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, TargetOptions}; pub(crate) fn opts() -> TargetOptions { TargetOptions { - os: "none".into(), + os: Os::None, endian: Endian::Little, c_int_width: 32, linker_flavor: LinkerFlavor::Gnu(Cc::Yes, Lld::No), diff --git a/compiler/rustc_target/src/spec/json.rs b/compiler/rustc_target/src/spec/json.rs index 7924460b78f2..a972299deeac 100644 --- a/compiler/rustc_target/src/spec/json.rs +++ b/compiler/rustc_target/src/spec/json.rs @@ -7,7 +7,7 @@ use super::{ Abi, Arch, BinaryFormat, CodeModel, DebuginfoKind, Env, FloatAbi, FramePointer, LinkArgsCli, LinkSelfContainedComponents, LinkSelfContainedDefault, LinkerFlavorCli, LldFlavor, - MergeFunctions, PanicStrategy, RelocModel, RelroLevel, RustcAbi, SanitizerSet, + MergeFunctions, Os, PanicStrategy, RelocModel, RelroLevel, RustcAbi, SanitizerSet, SmallDataThresholdSupport, SplitDebuginfo, StackProbeType, StaticCow, SymbolVisibility, Target, TargetKind, TargetOptions, TargetWarnings, TlsModel, }; @@ -505,7 +505,7 @@ struct TargetSpecJson { #[serde(rename = "target-c-int-width")] c_int_width: Option, c_enum_min_bits: Option, - os: Option>, + os: Option, env: Option, abi: Option, vendor: Option>, diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs index d72ce7e14b05..7bcffabfe976 100644 --- a/compiler/rustc_target/src/spec/mod.rs +++ b/compiler/rustc_target/src/spec/mod.rs @@ -1926,6 +1926,66 @@ pub fn desc_symbol(&self) -> Symbol { } } +crate::target_spec_enum! { + pub enum Os { + Aix = "aix", + AmdHsa = "amdhsa", + Android = "android", + Cuda = "cuda", + Cygwin = "cygwin", + Dragonfly = "dragonfly", + Emscripten = "emscripten", + EspIdf = "espidf", + FreeBsd = "freebsd", + Fuchsia = "fuchsia", + Haiku = "haiku", + HelenOs = "helenos", + Hermit = "hermit", + Horizon = "horizon", + Hurd = "hurd", + Illumos = "illumos", + IOs = "ios", + L4Re = "l4re", + Linux = "linux", + LynxOs178 = "lynxos178", + MacOs = "macos", + Managarm = "managarm", + Motor = "motor", + NetBsd = "netbsd", + None = "none", + Nto = "nto", + NuttX = "nuttx", + OpenBsd = "openbsd", + Psp = "psp", + Psx = "psx", + Redox = "redox", + Rtems = "rtems", + Solaris = "solaris", + SolidAsp3 = "solid_asp3", + TeeOs = "teeos", + Trusty = "trusty", + TvOs = "tvos", + Uefi = "uefi", + VexOs = "vexos", + VisionOs = "visionos", + Vita = "vita", + VxWorks = "vxworks", + Wasi = "wasi", + WatchOs = "watchos", + Windows = "windows", + Xous = "xous", + Zkvm = "zkvm", + Unknown = "unknown", + } + other_variant = Other; +} + +impl Os { + pub fn desc_symbol(&self) -> Symbol { + Symbol::intern(self.desc()) + } +} + crate::target_spec_enum! { pub enum Env { Gnu = "gnu", @@ -2108,11 +2168,11 @@ pub struct TargetOptions { pub endian: Endian, /// Width of c_int type. Defaults to "32". pub c_int_width: u16, - /// OS name to use for conditional compilation (`target_os`). Defaults to "none". - /// "none" implies a bare metal target without `std` library. - /// A couple of targets having `std` also use "unknown" as an `os` value, + /// OS name to use for conditional compilation (`target_os`). Defaults to [`Os::None`]. + /// [`Os::None`] implies a bare metal target without `std` library. + /// A couple of targets having `std` also use [`Os::Unknown`] as their `os` value, /// but they are exceptions. - pub os: StaticCow, + pub os: Os, /// Environment name to use for conditional compilation (`target_env`). Defaults to [`Env::Unspecified`]. pub env: Env, /// ABI name to distinguish multiple ABIs on the same OS and architecture. For instance, `"eabi"` @@ -2622,7 +2682,7 @@ fn default() -> TargetOptions { TargetOptions { endian: Endian::Little, c_int_width: 32, - os: "none".into(), + os: Os::None, env: Env::Unspecified, abi: Abi::Unspecified, vendor: "unknown".into(), @@ -2820,7 +2880,7 @@ macro_rules! check_matches { ); check_eq!( self.is_like_solaris, - self.os == "solaris" || self.os == "illumos", + matches!(self.os, Os::Solaris | Os::Illumos), "`is_like_solaris` must be set if and only if `os` is `solaris` or `illumos`" ); check_eq!( @@ -2830,7 +2890,7 @@ macro_rules! check_matches { ); check_eq!( self.is_like_windows, - self.os == "windows" || self.os == "uefi" || self.os == "cygwin", + matches!(self.os, Os::Windows | Os::Uefi | Os::Cygwin), "`is_like_windows` must be set if and only if `os` is `windows`, `uefi` or `cygwin`" ); check_eq!( @@ -2841,7 +2901,7 @@ macro_rules! check_matches { if self.is_like_msvc { check!(self.is_like_windows, "if `is_like_msvc` is set, `is_like_windows` must be set"); } - if self.os == "emscripten" { + if self.os == Os::Emscripten { check!(self.is_like_wasm, "the `emcscripten` os only makes sense on wasm-like targets"); } @@ -2857,12 +2917,12 @@ macro_rules! check_matches { "`linker_flavor` must be `msvc` if and only if `is_like_msvc` is set" ); check_eq!( - self.is_like_wasm && self.os != "emscripten", + self.is_like_wasm && self.os != Os::Emscripten, matches!(self.linker_flavor, LinkerFlavor::WasmLld(..)), "`linker_flavor` must be `wasm-lld` if and only if `is_like_wasm` is set and the `os` is not `emscripten`", ); check_eq!( - self.os == "emscripten", + self.os == Os::Emscripten, matches!(self.linker_flavor, LinkerFlavor::EmCc), "`linker_flavor` must be `em-cc` if and only if `os` is `emscripten`" ); @@ -2989,12 +3049,14 @@ macro_rules! check_matches { // except it and document the reasons. // Keep the default "unknown" vendor instead. check_ne!(self.vendor, "", "`vendor` cannot be empty"); - check_ne!(self.os, "", "`os` cannot be empty"); + if let Os::Other(s) = &self.os { + check!(!s.is_empty(), "`os` cannot be empty"); + } if !self.can_use_os_unknown() { // Keep the default "none" for bare metal targets instead. check_ne!( self.os, - "unknown", + Os::Unknown, "`unknown` os can only be used on particular targets; use `none` for bare-metal targets" ); } @@ -3008,7 +3070,7 @@ macro_rules! check_matches { // BPF: when targeting user space vms (like rbpf), those can load dynamic libraries. // 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" + if self.os == Os::None && !matches!(self.arch, Arch::Bpf | Arch::Hexagon | Arch::Wasm32 | Arch::Wasm64) { check!( @@ -3041,7 +3103,7 @@ macro_rules! check_matches { ); } // The UEFI targets do not support dynamic linking but still require PIC (#101377). - if self.relocation_model == RelocModel::Pic && (self.os != "uefi") { + if self.relocation_model == RelocModel::Pic && self.os != Os::Uefi { check!( self.dynamic_linking || self.position_independent_executables, "when the relocation model is `pic`, the target must support dynamic linking or use position-independent executables. \ diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs index ecfd6ebba863..da3d7c7d99db 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{SanitizerSet, Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, SanitizerSet, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("macos", Arch::Arm64, TargetEnv::Normal); + let (opts, llvm_target, arch) = base(Os::MacOs, Arch::Arm64, TargetEnv::Normal); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs index 85b4a0614a85..e6c64add9ecb 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{SanitizerSet, Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, SanitizerSet, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("ios", Arch::Arm64, TargetEnv::Normal); + let (opts, llvm_target, arch) = base(Os::IOs, Arch::Arm64, TargetEnv::Normal); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs index 4d6a3103ee30..28d22e022c4e 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{SanitizerSet, Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, SanitizerSet, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("ios", Arch::Arm64, TargetEnv::MacCatalyst); + let (opts, llvm_target, arch) = base(Os::IOs, Arch::Arm64, TargetEnv::MacCatalyst); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs index 2924ba5ebb10..3b6a075588a8 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_sim.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{SanitizerSet, Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, SanitizerSet, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("ios", Arch::Arm64, TargetEnv::Simulator); + let (opts, llvm_target, arch) = base(Os::IOs, Arch::Arm64, TargetEnv::Simulator); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs index 7aef6f96e1c5..b4e60f769b3b 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("tvos", Arch::Arm64, TargetEnv::Normal); + let (opts, llvm_target, arch) = base(Os::TvOs, Arch::Arm64, TargetEnv::Normal); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs index f0d17db873bf..0f2f73c50d0b 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_tvos_sim.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("tvos", Arch::Arm64, TargetEnv::Simulator); + let (opts, llvm_target, arch) = base(Os::TvOs, Arch::Arm64, TargetEnv::Simulator); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs index 22ce52e637f3..b7ddd58fbb32 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{SanitizerSet, Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, SanitizerSet, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("visionos", Arch::Arm64, TargetEnv::Normal); + let (opts, llvm_target, arch) = base(Os::VisionOs, Arch::Arm64, TargetEnv::Normal); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs index 21739ba9fdb7..9ad313f14922 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_visionos_sim.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{SanitizerSet, Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, SanitizerSet, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("visionos", Arch::Arm64, TargetEnv::Simulator); + let (opts, llvm_target, arch) = base(Os::VisionOs, Arch::Arm64, TargetEnv::Simulator); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos.rs index 2e88f95f1dd8..f0a5a616a6d2 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("watchos", Arch::Arm64, TargetEnv::Normal); + let (opts, llvm_target, arch) = base(Os::WatchOs, Arch::Arm64, TargetEnv::Normal); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs index 272dc682dc0e..db73687a715f 100644 --- a/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_watchos_sim.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("watchos", Arch::Arm64, TargetEnv::Simulator); + let (opts, llvm_target, arch) = base(Os::WatchOs, Arch::Arm64, TargetEnv::Simulator); Target { llvm_target, metadata: TargetMetadata { 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 d6b0e0919512..77ed9a6b82c1 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,7 +1,7 @@ use crate::spec::{Arch, RelocModel, StackProbeType, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { - let base = base::solid::opts("asp3"); + let base = base::solid::opts(); Target { llvm_target: "aarch64-unknown-none".into(), metadata: TargetMetadata { 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 eb8144dd44e2..32bdf1d97042 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::{ - Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelroLevel, StackProbeType, Target, TargetMetadata, - TargetOptions, + Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelroLevel, StackProbeType, Target, + TargetMetadata, TargetOptions, }; const LINKER_SCRIPT: &str = include_str!("./aarch64_nintendo_switch_freestanding_linker_script.ld"); @@ -23,7 +23,7 @@ pub(crate) fn target() -> Target { linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), linker: Some("rust-lld".into()), link_script: Some(LINKER_SCRIPT.into()), - os: "horizon".into(), + os: Os::Horizon, vendor: "nintendo".into(), max_atomic_width: Some(128), stack_probes: StackProbeType::Inline, 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 8bcc3e0ae16d..b8618050074d 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::{ - Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, Target, - TargetMetadata, TargetOptions, cvs, + Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, SanitizerSet, StackProbeType, + Target, TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -28,7 +28,7 @@ pub(crate) fn target() -> Target { stack_probes: StackProbeType::Inline, panic_strategy: PanicStrategy::Abort, families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, ..Default::default() }; Target { 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 3d0560eb7963..7dfa29787c86 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,7 @@ // Trusty OS target for AArch64. use crate::spec::{ - Arch, LinkSelfContainedDefault, PanicStrategy, RelroLevel, Target, TargetMetadata, + Arch, LinkSelfContainedDefault, Os, PanicStrategy, RelroLevel, Target, TargetMetadata, TargetOptions, }; @@ -22,7 +22,7 @@ pub(crate) fn target() -> Target { executables: true, max_atomic_width: Some(128), panic_strategy: PanicStrategy::Abort, - os: "trusty".into(), + os: Os::Trusty, position_independent_executables: true, static_position_independent_executables: true, crt_static_default: true, 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 d80a3ffd0c7f..828d853ac65e 100644 --- a/compiler/rustc_target/src/spec/targets/amdgcn_amd_amdhsa.rs +++ b/compiler/rustc_target/src/spec/targets/amdgcn_amd_amdhsa.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Arch, Cc, LinkerFlavor, Lld, PanicStrategy, Target, TargetMetadata, TargetOptions, + Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, Target, TargetMetadata, TargetOptions, }; pub(crate) fn target() -> Target { @@ -16,7 +16,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, options: TargetOptions { - os: "amdhsa".into(), + os: Os::AmdHsa, vendor: "amd".into(), linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), linker: Some("rust-lld".into()), diff --git a/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs b/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs index 564ac2cd7081..dab8cd157d2b 100644 --- a/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs +++ b/compiler/rustc_target/src/spec/targets/arm64_32_apple_watchos.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("watchos", Arch::Arm64_32, TargetEnv::Normal); + let (opts, llvm_target, arch) = base(Os::WatchOs, Arch::Arm64_32, TargetEnv::Normal); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs index 86e178a95728..ab8f369f1bee 100644 --- a/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/arm64e_apple_darwin.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{SanitizerSet, Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, SanitizerSet, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("macos", Arch::Arm64e, TargetEnv::Normal); + let (opts, llvm_target, arch) = base(Os::MacOs, Arch::Arm64e, TargetEnv::Normal); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs b/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs index dae3f77d7ae3..4ee4a16ab747 100644 --- a/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/arm64e_apple_ios.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{SanitizerSet, Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, SanitizerSet, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("ios", Arch::Arm64e, TargetEnv::Normal); + let (opts, llvm_target, arch) = base(Os::IOs, Arch::Arm64e, TargetEnv::Normal); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/arm64e_apple_tvos.rs b/compiler/rustc_target/src/spec/targets/arm64e_apple_tvos.rs index a99fc5dc68c9..c09591be95f9 100644 --- a/compiler/rustc_target/src/spec/targets/arm64e_apple_tvos.rs +++ b/compiler/rustc_target/src/spec/targets/arm64e_apple_tvos.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("tvos", Arch::Arm64e, TargetEnv::Normal); + let (opts, llvm_target, arch) = base(Os::TvOs, Arch::Arm64e, TargetEnv::Normal); Target { llvm_target, metadata: TargetMetadata { 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 78d4fe94acec..ed2ab47c0e24 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,5 @@ use crate::spec::{ - Abi, Arch, Cc, Env, FloatAbi, LinkerFlavor, Lld, RelocModel, Target, TargetMetadata, + Abi, Arch, Cc, Env, FloatAbi, LinkerFlavor, Lld, Os, RelocModel, Target, TargetMetadata, TargetOptions, cvs, }; @@ -25,7 +25,7 @@ pub(crate) fn target() -> Target { arch: Arch::Arm, options: TargetOptions { - os: "horizon".into(), + os: Os::Horizon, env: Env::Newlib, vendor: "nintendo".into(), cpu: "mpcore".into(), 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 73195b18499f..382658a87b54 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_rtems_eabihf.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_rtems_eabihf.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Abi, Arch, Cc, Env, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + Abi, Arch, Cc, Env, FloatAbi, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, }; @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { arch: Arch::Arm, options: TargetOptions { - os: "rtems".into(), + os: Os::Rtems, families: cvs!["unix"], abi: Abi::EabiHf, llvm_floatabi: Some(FloatAbi::Hard), 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 481ab5ff644f..20e5c0acca96 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,7 @@ use rustc_abi::Endian; use crate::spec::{ - Abi, Arch, Cc, Env, FloatAbi, LinkerFlavor, Lld, RelocModel, Target, TargetMetadata, + Abi, Arch, Cc, Env, FloatAbi, LinkerFlavor, Lld, Os, RelocModel, Target, TargetMetadata, TargetOptions, cvs, }; @@ -29,7 +29,7 @@ pub(crate) fn target() -> Target { arch: Arch::Arm, options: TargetOptions { - os: "vita".into(), + os: Os::Vita, endian: Endian::Little, c_int_width: 32, env: Env::Newlib, 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 e270ed03ebe9..fb3954abb286 100644 --- a/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs +++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Abi, Arch, FloatAbi, LinkSelfContainedDefault, PanicStrategy, RelroLevel, Target, + Abi, Arch, FloatAbi, LinkSelfContainedDefault, Os, PanicStrategy, RelroLevel, Target, TargetMetadata, TargetOptions, }; @@ -24,7 +24,7 @@ pub(crate) fn target() -> Target { features: "+v7,+thumb2,+soft-float,-neon".into(), max_atomic_width: Some(64), mcount: "\u{1}mcount".into(), - os: "trusty".into(), + os: Os::Trusty, link_self_contained: LinkSelfContainedDefault::InferredForMusl, dynamic_linking: false, executables: true, 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 ef530ec7d063..bd18d6d8ae90 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,7 +1,7 @@ use crate::spec::{Abi, Arch, FloatAbi, RelocModel, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { - let base = base::solid::opts("asp3"); + let base = base::solid::opts(); Target { llvm_target: "armv7a-none-eabi".into(), metadata: TargetMetadata { 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 0d1531dd4884..9433cbd46627 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,7 +1,7 @@ use crate::spec::{Abi, Arch, FloatAbi, RelocModel, Target, TargetMetadata, TargetOptions, base}; pub(crate) fn target() -> Target { - let base = base::solid::opts("asp3"); + let base = base::solid::opts(); Target { llvm_target: "armv7a-none-eabihf".into(), metadata: TargetMetadata { 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 57b19431924f..5ab74e0533ba 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::{ - Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, cvs, + Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -23,7 +23,7 @@ pub(crate) fn target() -> Target { emit_debug_gdb_scripts: false, c_enum_min_bits: Some(8), families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, ..Default::default() }; Target { 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 f6e40e2a7252..4ac07e24a48b 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::{ - Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, - TargetOptions, cvs, + Abi, Arch, Cc, FloatAbi, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, + TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -23,7 +23,7 @@ pub(crate) fn target() -> Target { emit_debug_gdb_scripts: false, c_enum_min_bits: Some(8), families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, ..Default::default() }; Target { 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 c1fbbc33b878..b83d7b090689 100644 --- a/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs +++ b/compiler/rustc_target/src/spec/targets/armv7a_vex_v5.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Abi, Arch, Cc, Env, FloatAbi, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, + Abi, Arch, Cc, Env, FloatAbi, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, }; @@ -9,7 +9,7 @@ pub(crate) fn target() -> Target { let opts = TargetOptions { vendor: "vex".into(), env: Env::V5, - os: "vexos".into(), + os: Os::VexOs, cpu: "cortex-a9".into(), abi: Abi::EabiHf, is_like_vexos: true, diff --git a/compiler/rustc_target/src/spec/targets/armv7k_apple_watchos.rs b/compiler/rustc_target/src/spec/targets/armv7k_apple_watchos.rs index df58559848a0..2547cf19004b 100644 --- a/compiler/rustc_target/src/spec/targets/armv7k_apple_watchos.rs +++ b/compiler/rustc_target/src/spec/targets/armv7k_apple_watchos.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("watchos", Arch::Armv7k, TargetEnv::Normal); + let (opts, llvm_target, arch) = base(Os::WatchOs, Arch::Armv7k, TargetEnv::Normal); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs b/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs index 63259043b73d..cd9da114acfb 100644 --- a/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/armv7s_apple_ios.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("ios", Arch::Armv7s, TargetEnv::Normal); + let (opts, llvm_target, arch) = base(Os::IOs, Arch::Armv7s, TargetEnv::Normal); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs b/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs index a919be765a27..3992e7aa9dbc 100644 --- a/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/i386_apple_ios.rs @@ -1,10 +1,10 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { // i386-apple-ios is a simulator target, even though it isn't declared // that way in the target name like the other ones... - let (opts, llvm_target, arch) = base("ios", Arch::I386, TargetEnv::Simulator); + let (opts, llvm_target, arch) = base(Os::IOs, Arch::I386, TargetEnv::Simulator); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs index 96c477d52367..1c3481928a85 100644 --- a/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/i686_apple_darwin.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("macos", Arch::I686, TargetEnv::Normal); + let (opts, llvm_target, arch) = base(Os::MacOs, Arch::I686, TargetEnv::Normal); Target { llvm_target, metadata: TargetMetadata { 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 200735f4e0fb..370e585f65ad 100644 --- a/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs +++ b/compiler/rustc_target/src/spec/targets/mipsel_sony_psp.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Arch, Cc, LinkerFlavor, Lld, RelocModel, Target, TargetMetadata, TargetOptions, cvs, + Arch, Cc, LinkerFlavor, Lld, Os, RelocModel, Target, TargetMetadata, TargetOptions, cvs, }; // The PSP has custom linker requirements. @@ -24,7 +24,7 @@ pub(crate) fn target() -> Target { arch: Arch::Mips, options: TargetOptions { - os: "psp".into(), + os: Os::Psp, vendor: "sony".into(), linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), cpu: "mips2".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 b6d30be589ea..06631fdefb4a 100644 --- a/compiler/rustc_target/src/spec/targets/mipsel_sony_psx.rs +++ b/compiler/rustc_target/src/spec/targets/mipsel_sony_psx.rs @@ -1,6 +1,6 @@ use crate::spec::{ - Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, - cvs, + Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -21,7 +21,7 @@ pub(crate) fn target() -> Target { // of functionality post load, so we still declare it as `cfg!(target_os = "psx")`. // // See for details. - os: "psx".into(), + os: Os::Psx, vendor: "sony".into(), linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), cpu: "mips1".into(), 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 5bbf40b5fadd..35003c4d4dd6 100644 --- a/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs +++ b/compiler/rustc_target/src/spec/targets/nvptx64_nvidia_cuda.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Arch, LinkSelfContainedDefault, LinkerFlavor, MergeFunctions, PanicStrategy, Target, + Arch, LinkSelfContainedDefault, LinkerFlavor, MergeFunctions, Os, PanicStrategy, Target, TargetMetadata, TargetOptions, }; @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { pointer_width: 64, options: TargetOptions { - os: "cuda".into(), + os: Os::Cuda, vendor: "nvidia".into(), linker_flavor: LinkerFlavor::Ptx, // The linker can be installed from `crates.io`. 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 c0372035cd7e..af25334a2e53 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::{ - Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -16,7 +17,7 @@ pub(crate) fn target() -> Target { arch: Arch::RiscV32, options: TargetOptions { - os: "zkvm".into(), + os: Os::Zkvm, vendor: "risc0".into(), linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), linker: Some("rust-lld".into()), 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 81bd2a64632b..11a5626c5641 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32imac_esp_espidf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32imac_esp_espidf.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Arch, Env, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, + Arch, Env, Os, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "espidf".into(), + os: Os::EspIdf, env: Env::Newlib, vendor: "espressif".into(), linker: Some("riscv32-esp-elf-gcc".into()), 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 70eb7cb78d65..7205fb61de74 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,6 +1,6 @@ use crate::spec::{ - Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, - cvs, + Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), linker: Some("rust-lld".into()), cpu: "generic-rv32".into(), 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 e50de1cc9371..363e465e2ef4 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::{ - Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, + Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, }; pub(crate) fn target() -> Target { @@ -16,7 +17,7 @@ pub(crate) fn target() -> Target { arch: Arch::RiscV32, options: TargetOptions { - os: "xous".into(), + os: Os::Xous, linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), linker: Some("rust-lld".into()), cpu: "generic-rv32".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 198afeb20533..b3a3ab9b7543 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32imafc_esp_espidf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32imafc_esp_espidf.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Arch, Env, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, + Arch, Env, Os, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "espidf".into(), + os: Os::EspIdf, env: Env::Newlib, vendor: "espressif".into(), linker: Some("riscv32-esp-elf-gcc".into()), 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 f7b8bd49e527..0bba2e47dc85 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,6 +1,6 @@ use crate::spec::{ - Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, - cvs, + Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), linker: Some("rust-lld".into()), cpu: "generic-rv32".into(), 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 8534bb6093bd..f903bbdb04bf 100644 --- a/compiler/rustc_target/src/spec/targets/riscv32imc_esp_espidf.rs +++ b/compiler/rustc_target/src/spec/targets/riscv32imc_esp_espidf.rs @@ -1,5 +1,5 @@ use crate::spec::{ - Arch, Env, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, + Arch, Env, Os, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "espidf".into(), + os: Os::EspIdf, env: Env::Newlib, vendor: "espressif".into(), linker: Some("riscv32-esp-elf-gcc".into()), 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 a10ddb2d0569..d1d73842703e 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,6 +1,6 @@ use crate::spec::{ - Arch, Cc, LinkerFlavor, Lld, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, - cvs, + Arch, Cc, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), linker: Some("rust-lld".into()), cpu: "generic-rv32".into(), 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 93dd6dc7ed1c..7850cc8105d9 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,5 +1,5 @@ use crate::spec::{ - Arch, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, Target, + Arch, Cc, CodeModel, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, SanitizerSet, Target, TargetMetadata, TargetOptions, cvs, }; @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), linker: Some("rust-lld".into()), llvm_abiname: "lp64d".into(), 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 25e3e72f9de9..b1a1817bbe1f 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,5 +1,5 @@ use crate::spec::{ - Arch, Cc, CodeModel, LinkerFlavor, Lld, PanicStrategy, RelocModel, SanitizerSet, Target, + Arch, Cc, CodeModel, LinkerFlavor, Lld, Os, PanicStrategy, RelocModel, SanitizerSet, Target, TargetMetadata, TargetOptions, cvs, }; @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), linker: Some("rust-lld".into()), cpu: "generic-rv64".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 fb4cc9556725..fa0154d65d68 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::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, abi: Abi::Eabi, llvm_floatabi: Some(FloatAbi::Soft), // The ARMv6-M architecture doesn't support unaligned loads/stores so we disable them 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 0c7d7feb0a5f..7c1adc932626 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::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -21,7 +21,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, abi: Abi::Eabi, llvm_floatabi: Some(FloatAbi::Soft), // Cortex-A7/A8/A9 with software floating point 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 c469665edb12..0e6d5b1f2ea9 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::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -24,7 +24,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, abi: Abi::EabiHf, llvm_floatabi: Some(FloatAbi::Hard), // Cortex-A7/A8/A9 support VFPv3-D32/VFPv4-D32 with optional double-precision 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 0648febdb3e3..796206d4ffee 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::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -26,7 +26,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, abi: Abi::Eabi, llvm_floatabi: Some(FloatAbi::Soft), max_atomic_width: Some(32), 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 fee5805d1925..f85aef1ab5a6 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::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -25,7 +25,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, abi: Abi::EabiHf, llvm_floatabi: Some(FloatAbi::Hard), // vfp4 is the lowest common denominator between the Cortex-M4F (vfp4) and the 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 389fea54ce56..3d3d48748a9c 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::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, abi: Abi::Eabi, llvm_floatabi: Some(FloatAbi::Soft), max_atomic_width: Some(32), 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 562e494075e5..18bafc72553d 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::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -17,7 +17,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, abi: Abi::Eabi, llvm_floatabi: Some(FloatAbi::Soft), // ARMv8-M baseline doesn't support unaligned loads/stores so we disable them 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 f8e4a7d0e5ef..f5039f13bc09 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::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, abi: Abi::Eabi, llvm_floatabi: Some(FloatAbi::Soft), max_atomic_width: Some(32), 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 1c5dd845cf7f..77d23a255278 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::{Abi, Arch, FloatAbi, Target, TargetMetadata, TargetOptions, base, cvs}; +use crate::spec::{Abi, Arch, FloatAbi, Os, Target, TargetMetadata, TargetOptions, base, cvs}; pub(crate) fn target() -> Target { Target { @@ -18,7 +18,7 @@ pub(crate) fn target() -> Target { options: TargetOptions { families: cvs!["unix"], - os: "nuttx".into(), + os: Os::NuttX, abi: Abi::EabiHf, llvm_floatabi: Some(FloatAbi::Hard), // If the Floating Point extension is implemented in the Cortex-M33 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 aa4a1be99291..47623c34dce3 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::{ - Arch, LinkArgs, LinkerFlavor, PanicStrategy, RelocModel, Target, TargetMetadata, TargetOptions, - base, cvs, + Arch, LinkArgs, LinkerFlavor, Os, PanicStrategy, RelocModel, Target, TargetMetadata, + TargetOptions, base, cvs, }; pub(crate) fn target() -> Target { @@ -10,7 +10,7 @@ pub(crate) fn target() -> Target { TargetOptions::link_args(LinkerFlavor::EmCc, &["-sABORTING_MALLOC=0", "-sWASM_BIGINT"]); let opts = TargetOptions { - os: "emscripten".into(), + os: Os::Emscripten, linker_flavor: LinkerFlavor::EmCc, // emcc emits two files - a .js file to instantiate the wasm and supply platform // functionality, and a .wasm file. 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 3050f17d5efb..cff336c04190 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_unknown_unknown.rs @@ -10,11 +10,11 @@ //! This target is more or less managed by the Rust and WebAssembly Working //! Group nowadays at . -use crate::spec::{Arch, Cc, LinkerFlavor, Target, TargetMetadata, base}; +use crate::spec::{Arch, Cc, LinkerFlavor, Os, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut options = base::wasm::options(); - options.os = "unknown".into(); + options.os = Os::Unknown; options.add_pre_link_args( LinkerFlavor::WasmLld(Cc::No), diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs index 65ca593730ea..2d3dd0862d64 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs @@ -11,14 +11,14 @@ //! introduced. use crate::spec::{ - Arch, Cc, Env, LinkSelfContainedDefault, LinkerFlavor, Target, TargetMetadata, base, + Arch, Cc, Env, LinkSelfContainedDefault, LinkerFlavor, Os, Target, TargetMetadata, base, crt_objects, }; pub(crate) fn target() -> Target { let mut options = base::wasm::options(); - options.os = "wasi".into(); + options.os = Os::Wasi; options.env = Env::P1; options.add_pre_link_args(LinkerFlavor::WasmLld(Cc::Yes), &["--target=wasm32-wasip1"]); 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 f1b91be4f155..645f7ad40bb6 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip1_threads.rs @@ -8,14 +8,14 @@ //! Historically this target was known as `wasm32-wasi-preview1-threads`. use crate::spec::{ - Arch, Cc, Env, LinkSelfContainedDefault, LinkerFlavor, Target, TargetMetadata, base, + Arch, Cc, Env, LinkSelfContainedDefault, LinkerFlavor, Os, Target, TargetMetadata, base, crt_objects, }; pub(crate) fn target() -> Target { let mut options = base::wasm::options(); - options.os = "wasi".into(); + options.os = Os::Wasi; options.env = Env::P1; options.add_pre_link_args( diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip2.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip2.rs index 67a12c032b6d..e594d187e42b 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32_wasip2.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip2.rs @@ -17,13 +17,13 @@ //! . use crate::spec::{ - Arch, Env, LinkSelfContainedDefault, RelocModel, Target, TargetMetadata, base, crt_objects, + Arch, Env, LinkSelfContainedDefault, Os, RelocModel, Target, TargetMetadata, base, crt_objects, }; pub(crate) fn target() -> Target { let mut options = base::wasm::options(); - options.os = "wasi".into(); + options.os = Os::Wasi; options.env = Env::P2; options.linker = Some("wasm-component-ld".into()); diff --git a/compiler/rustc_target/src/spec/targets/wasm32v1_none.rs b/compiler/rustc_target/src/spec/targets/wasm32v1_none.rs index 41267f0e5708..8c5a253b0e2f 100644 --- a/compiler/rustc_target/src/spec/targets/wasm32v1_none.rs +++ b/compiler/rustc_target/src/spec/targets/wasm32v1_none.rs @@ -12,11 +12,11 @@ //! 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::{Arch, Cc, LinkerFlavor, Target, TargetMetadata, base}; +use crate::spec::{Arch, Cc, LinkerFlavor, Os, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut options = base::wasm::options(); - options.os = "none".into(); + options.os = Os::None; // WebAssembly 1.0 shipped in 2019 and included exactly one proposal // after the initial "MVP" feature set: "mutable-globals". 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 850e85591661..7f9341b3ef91 100644 --- a/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs +++ b/compiler/rustc_target/src/spec/targets/wasm64_unknown_unknown.rs @@ -7,11 +7,11 @@ //! 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::{Arch, Cc, LinkerFlavor, Target, TargetMetadata, base}; +use crate::spec::{Arch, Cc, LinkerFlavor, Os, Target, TargetMetadata, base}; pub(crate) fn target() -> Target { let mut options = base::wasm::options(); - options.os = "unknown".into(); + options.os = Os::Unknown; options.add_pre_link_args( LinkerFlavor::WasmLld(Cc::No), diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs index cb517b2a357a..8d0febc362d4 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{SanitizerSet, Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, SanitizerSet, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("macos", Arch::X86_64, TargetEnv::Normal); + let (opts, llvm_target, arch) = base(Os::MacOs, Arch::X86_64, TargetEnv::Normal); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs index d74a688fa0f7..349460331e56 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios.rs @@ -1,10 +1,10 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{SanitizerSet, Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, SanitizerSet, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { // x86_64-apple-ios is a simulator target, even though it isn't declared // that way in the target name like the other ones... - let (opts, llvm_target, arch) = base("ios", Arch::X86_64, TargetEnv::Simulator); + let (opts, llvm_target, arch) = base(Os::IOs, Arch::X86_64, TargetEnv::Simulator); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs index 193e26f94c98..2b8d552bf854 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{SanitizerSet, Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, SanitizerSet, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("ios", Arch::X86_64, TargetEnv::MacCatalyst); + let (opts, llvm_target, arch) = base(Os::IOs, Arch::X86_64, TargetEnv::MacCatalyst); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs index e69bd17a0496..273cf31b7631 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_tvos.rs @@ -1,10 +1,10 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { // x86_64-apple-tvos is a simulator target, even though it isn't declared // that way in the target name like the other ones... - let (opts, llvm_target, arch) = base("tvos", Arch::X86_64, TargetEnv::Simulator); + let (opts, llvm_target, arch) = base(Os::TvOs, Arch::X86_64, TargetEnv::Simulator); Target { llvm_target, metadata: TargetMetadata { diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs index 9490ca6aa36c..395f4fe5db4a 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_watchos_sim.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (opts, llvm_target, arch) = base("watchos", Arch::X86_64, TargetEnv::Simulator); + let (opts, llvm_target, arch) = base(Os::WatchOs, Arch::X86_64, TargetEnv::Simulator); Target { llvm_target, metadata: TargetMetadata { 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 85c5e0a5f5ee..290087d8cef6 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,7 +1,7 @@ use std::borrow::Cow; use crate::spec::{ - Abi, Arch, Cc, Env, LinkerFlavor, Lld, Target, TargetMetadata, TargetOptions, cvs, + Abi, Arch, Cc, Env, LinkerFlavor, Lld, Os, Target, TargetMetadata, TargetOptions, cvs, }; pub(crate) fn target() -> Target { @@ -57,7 +57,7 @@ pub(crate) fn target() -> Target { "TEXT_SIZE", ]; let opts = TargetOptions { - os: "unknown".into(), + os: Os::Unknown, env: Env::Sgx, vendor: "fortanix".into(), abi: Abi::Fortanix, 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 88c66ff6db9f..af9d653dbd2d 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,7 +1,7 @@ // Trusty OS target for X86_64. use crate::spec::{ - Arch, LinkSelfContainedDefault, PanicStrategy, RelroLevel, StackProbeType, Target, + Arch, LinkSelfContainedDefault, Os, PanicStrategy, RelroLevel, StackProbeType, Target, TargetMetadata, TargetOptions, }; @@ -22,7 +22,7 @@ pub(crate) fn target() -> Target { executables: true, max_atomic_width: Some(64), panic_strategy: PanicStrategy::Abort, - os: "trusty".into(), + os: Os::Trusty, link_self_contained: LinkSelfContainedDefault::InferredForMusl, position_independent_executables: true, static_position_independent_executables: true, diff --git a/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs index 67b5a160a89a..adc87378fc7e 100644 --- a/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs +++ b/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs @@ -1,8 +1,8 @@ use crate::spec::base::apple::{Arch, TargetEnv, base}; -use crate::spec::{SanitizerSet, Target, TargetMetadata, TargetOptions}; +use crate::spec::{Os, SanitizerSet, Target, TargetMetadata, TargetOptions}; pub(crate) fn target() -> Target { - let (mut opts, llvm_target, arch) = base("macos", Arch::X86_64h, TargetEnv::Normal); + let (mut opts, llvm_target, arch) = base(Os::MacOs, Arch::X86_64h, TargetEnv::Normal); opts.max_atomic_width = Some(128); opts.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::CFI | SanitizerSet::LEAK | SanitizerSet::THREAD; 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 4199c410dc7e..83835705f3da 100644 --- a/compiler/rustc_target/src/spec/targets/xtensa_esp32_espidf.rs +++ b/compiler/rustc_target/src/spec/targets/xtensa_esp32_espidf.rs @@ -1,7 +1,7 @@ use rustc_abi::Endian; use crate::spec::base::xtensa; -use crate::spec::{Arch, Env, Target, TargetMetadata, TargetOptions, cvs}; +use crate::spec::{Arch, Env, Os, Target, TargetMetadata, TargetOptions, cvs}; pub(crate) fn target() -> Target { Target { @@ -15,7 +15,7 @@ pub(crate) fn target() -> Target { endian: Endian::Little, c_int_width: 32, families: cvs!["unix"], - os: "espidf".into(), + os: Os::EspIdf, env: Env::Newlib, vendor: "espressif".into(), 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 cca6a124ec63..42e4c7bf8bec 100644 --- a/compiler/rustc_target/src/spec/targets/xtensa_esp32s2_espidf.rs +++ b/compiler/rustc_target/src/spec/targets/xtensa_esp32s2_espidf.rs @@ -1,7 +1,7 @@ use rustc_abi::Endian; use crate::spec::base::xtensa; -use crate::spec::{Arch, Env, Target, TargetMetadata, TargetOptions, cvs}; +use crate::spec::{Arch, Env, Os, Target, TargetMetadata, TargetOptions, cvs}; pub(crate) fn target() -> Target { Target { @@ -15,7 +15,7 @@ pub(crate) fn target() -> Target { endian: Endian::Little, c_int_width: 32, families: cvs!["unix"], - os: "espidf".into(), + os: Os::EspIdf, env: Env::Newlib, vendor: "espressif".into(), 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 7038222b9571..498daf4e6063 100644 --- a/compiler/rustc_target/src/spec/targets/xtensa_esp32s3_espidf.rs +++ b/compiler/rustc_target/src/spec/targets/xtensa_esp32s3_espidf.rs @@ -1,7 +1,7 @@ use rustc_abi::Endian; use crate::spec::base::xtensa; -use crate::spec::{Arch, Env, Target, TargetMetadata, TargetOptions, cvs}; +use crate::spec::{Arch, Env, Os, Target, TargetMetadata, TargetOptions, cvs}; pub(crate) fn target() -> Target { Target { @@ -15,7 +15,7 @@ pub(crate) fn target() -> Target { endian: Endian::Little, c_int_width: 32, families: cvs!["unix"], - os: "espidf".into(), + os: Os::EspIdf, env: Env::Newlib, vendor: "espressif".into(), diff --git a/src/tools/miri/src/concurrency/thread.rs b/src/tools/miri/src/concurrency/thread.rs index 6178f87d7849..7838bd214302 100644 --- a/src/tools/miri/src/concurrency/thread.rs +++ b/src/tools/miri/src/concurrency/thread.rs @@ -15,6 +15,7 @@ use rustc_middle::mir::Mutability; use rustc_middle::ty::layout::TyAndLayout; use rustc_span::Span; +use rustc_target::spec::Os; use crate::concurrency::GlobalDataRaceHandler; use crate::shims::tls; @@ -471,7 +472,7 @@ pub(crate) fn init( ) { ecx.machine.threads.threads[ThreadId::MAIN_THREAD].on_stack_empty = Some(on_main_stack_empty); - if ecx.tcx.sess.target.os.as_ref() != "windows" { + if ecx.tcx.sess.target.os != Os::Windows { // The main thread can *not* be joined on except on windows. ecx.machine.threads.threads[ThreadId::MAIN_THREAD].join_status = ThreadJoinStatus::Detached; diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs index 20b506bad91e..6daee0ba6969 100644 --- a/src/tools/miri/src/eval.rs +++ b/src/tools/miri/src/eval.rs @@ -14,6 +14,7 @@ use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutCx}; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_session::config::EntryFnType; +use rustc_target::spec::Os; use crate::concurrency::GenmcCtx; use crate::concurrency::thread::TlsAllocAction; @@ -341,7 +342,7 @@ pub fn create_ecx<'tcx>( ecx.machine.argv = Some(argv_place.ptr()); } // Store command line as UTF-16 for Windows `GetCommandLineW`. - if tcx.sess.target.os == "windows" { + if tcx.sess.target.os == Os::Windows { // Construct a command string with all the arguments. let cmd_utf16: Vec = args_to_utf16_command_string(config.args.iter()); diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs index 18e16ddf1a5d..383a4e2ea4b0 100644 --- a/src/tools/miri/src/helpers.rs +++ b/src/tools/miri/src/helpers.rs @@ -19,6 +19,7 @@ use rustc_session::config::CrateType; use rustc_span::{Span, Symbol}; use rustc_symbol_mangling::mangle_internal_symbol; +use rustc_target::spec::Os; use crate::*; @@ -234,7 +235,7 @@ fn eval_path_scalar(&self, path: &[&str]) -> Scalar { /// Helper function to get a `libc` constant as a `Scalar`. fn eval_libc(&self, name: &str) -> Scalar { - if self.eval_context_ref().tcx.sess.target.os == "windows" { + if self.eval_context_ref().tcx.sess.target.os == Os::Windows { panic!( "`libc` crate is not reliably available on Windows targets; Miri should not use it there" ); @@ -290,7 +291,7 @@ fn eval_windows_u64(&self, module: &str, name: &str) -> u64 { /// Helper function to get the `TyAndLayout` of a `libc` type fn libc_ty_layout(&self, name: &str) -> TyAndLayout<'tcx> { let this = self.eval_context_ref(); - if this.tcx.sess.target.os == "windows" { + if this.tcx.sess.target.os == Os::Windows { panic!( "`libc` crate is not reliably available on Windows targets; Miri should not use it there" ); @@ -669,7 +670,7 @@ fn reject_in_isolation(&self, op_name: &str, reject_with: RejectOpWith) -> Inter /// Helper function used inside the shims of foreign functions to assert that the target OS /// is `target_os`. It panics showing a message with the `name` of the foreign function /// if this is not the case. - fn assert_target_os(&self, target_os: &str, name: &str) { + fn assert_target_os(&self, target_os: Os, name: &str) { assert_eq!( self.eval_context_ref().tcx.sess.target.os, target_os, @@ -680,9 +681,9 @@ fn assert_target_os(&self, target_os: &str, name: &str) { /// Helper function used inside shims of foreign functions to check that the target OS /// is one of `target_oses`. It returns an error containing the `name` of the foreign function /// in a message if this is not the case. - fn check_target_os(&self, target_oses: &[&str], name: Symbol) -> InterpResult<'tcx> { - let target_os = self.eval_context_ref().tcx.sess.target.os.as_ref(); - if !target_oses.contains(&target_os) { + fn check_target_os(&self, target_oses: &[Os], name: Symbol) -> InterpResult<'tcx> { + let target_os = &self.eval_context_ref().tcx.sess.target.os; + if !target_oses.contains(target_os) { throw_unsup_format!("`{name}` is not supported on {target_os}"); } interp_ok(()) @@ -918,7 +919,7 @@ fn write_wide_str( /// Always returns a `Vec` no matter the size of `wchar_t`. fn read_wchar_t_str(&self, ptr: Pointer) -> InterpResult<'tcx, Vec> { let this = self.eval_context_ref(); - let wchar_t = if this.tcx.sess.target.os == "windows" { + let wchar_t = if this.tcx.sess.target.os == Os::Windows { // We don't have libc on Windows so we have to hard-code the type ourselves. this.machine.layouts.u16 } else { diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs index a4f8e9ccaab9..4ffee208f4e0 100644 --- a/src/tools/miri/src/machine.rs +++ b/src/tools/miri/src/machine.rs @@ -31,7 +31,7 @@ use rustc_span::{Span, SpanData, Symbol}; use rustc_symbol_mangling::mangle_internal_symbol; use rustc_target::callconv::FnAbi; -use rustc_target::spec::Arch; +use rustc_target::spec::{Arch, Os}; use crate::alloc_addresses::EvalContextExt; use crate::concurrency::cpu_affinity::{self, CpuAffinityMask}; @@ -739,7 +739,7 @@ pub(crate) fn new( ); let threads = ThreadManager::new(config); let mut thread_cpu_affinity = FxHashMap::default(); - if matches!(&*tcx.sess.target.os, "linux" | "freebsd" | "android") { + if matches!(&tcx.sess.target.os, Os::Linux | Os::FreeBsd | Os::Android) { thread_cpu_affinity .insert(threads.active_thread(), CpuAffinityMask::new(&layout_cx, config.num_cpus)); } diff --git a/src/tools/miri/src/shims/alloc.rs b/src/tools/miri/src/shims/alloc.rs index 7163d96d9331..94649dde4736 100644 --- a/src/tools/miri/src/shims/alloc.rs +++ b/src/tools/miri/src/shims/alloc.rs @@ -3,7 +3,7 @@ use rustc_middle::ty::Ty; use rustc_span::Symbol; use rustc_target::callconv::FnAbi; -use rustc_target::spec::Arch; +use rustc_target::spec::{Arch, Os}; use crate::*; @@ -19,10 +19,10 @@ fn malloc_align(&self, size: u64) -> Align { // This is given by `alignof(max_align_t)`. The following list is taken from // `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 os = &this.tcx.sess.target.os; let max_fundamental_align = match &this.tcx.sess.target.arch { - Arch::RiscV32 if matches!(os, "espidf" | "zkvm") => 4, - Arch::Xtensa if matches!(os, "espidf") => 4, + Arch::RiscV32 if matches!(os, Os::EspIdf | Os::Zkvm) => 4, + Arch::Xtensa if matches!(os, Os::EspIdf) => 4, Arch::X86 | Arch::Arm | Arch::M68k diff --git a/src/tools/miri/src/shims/env.rs b/src/tools/miri/src/shims/env.rs index b9fb9192df4a..6915924f2a48 100644 --- a/src/tools/miri/src/shims/env.rs +++ b/src/tools/miri/src/shims/env.rs @@ -1,6 +1,7 @@ use std::ffi::{OsStr, OsString}; use rustc_data_structures::fx::FxHashMap; +use rustc_target::spec::Os; use self::shims::unix::UnixEnvVars; use self::shims::windows::WindowsEnvVars; @@ -48,7 +49,7 @@ pub(crate) fn init( let env_vars = if ecx.target_os_is_unix() { EnvVars::Unix(UnixEnvVars::new(ecx, env_vars)?) - } else if ecx.tcx.sess.target.os == "windows" { + } else if ecx.tcx.sess.target.os == Os::Windows { EnvVars::Windows(WindowsEnvVars::new(ecx, env_vars)?) } else { // For "none" targets (i.e., without an OS). @@ -118,7 +119,7 @@ fn get_tid(&self, thread: ThreadId) -> u32 { let this = self.eval_context_ref(); let index = thread.to_u32(); let target_os = &this.tcx.sess.target.os; - if target_os == "linux" || target_os == "netbsd" { + if matches!(target_os, Os::Linux | Os::NetBsd) { // On Linux, the main thread has PID == TID so we uphold this. NetBSD also appears // to exhibit the same behavior, though I can't find a citation. this.get_pid().strict_add(index) diff --git a/src/tools/miri/src/shims/extern_static.rs b/src/tools/miri/src/shims/extern_static.rs index c2527bf8e25d..fc9971641088 100644 --- a/src/tools/miri/src/shims/extern_static.rs +++ b/src/tools/miri/src/shims/extern_static.rs @@ -1,5 +1,7 @@ //! Provides the `extern static` that this platform expects. +use rustc_target::spec::Os; + use crate::*; impl<'tcx> MiriMachine<'tcx> { @@ -49,28 +51,28 @@ pub fn init_extern_statics(ecx: &mut MiriInterpCx<'tcx>) -> InterpResult<'tcx> { Self::add_extern_static(ecx, "environ", environ); } - match ecx.tcx.sess.target.os.as_ref() { - "linux" => { + match &ecx.tcx.sess.target.os { + Os::Linux => { Self::null_ptr_extern_statics( ecx, &["__cxa_thread_atexit_impl", "__clock_gettime64"], )?; Self::weak_symbol_extern_statics(ecx, &["getrandom", "gettid", "statx"])?; } - "freebsd" => { + Os::FreeBsd => { Self::null_ptr_extern_statics(ecx, &["__cxa_thread_atexit_impl"])?; } - "android" => { + Os::Android => { Self::null_ptr_extern_statics(ecx, &["bsd_signal"])?; Self::weak_symbol_extern_statics(ecx, &["signal", "getrandom", "gettid"])?; } - "windows" => { + Os::Windows => { // "_tls_used" // This is some obscure hack that is part of the Windows TLS story. It's a `u8`. let val = ImmTy::from_int(0, ecx.machine.layouts.u8); Self::alloc_extern_static(ecx, "_tls_used", val)?; } - "illumos" | "solaris" => { + Os::Illumos | Os::Solaris => { Self::weak_symbol_extern_statics(ecx, &["pthread_setname_np"])?; } _ => {} // No "extern statics" supported on this target diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs index bffe633f7797..69a028e48507 100644 --- a/src/tools/miri/src/shims/foreign_items.rs +++ b/src/tools/miri/src/shims/foreign_items.rs @@ -15,7 +15,7 @@ use rustc_session::config::OomStrategy; use rustc_span::Symbol; use rustc_target::callconv::FnAbi; -use rustc_target::spec::Arch; +use rustc_target::spec::{Os, Arch}; use super::alloc::EvalContextExt as _; use super::backtrace::EvalContextExt as _; @@ -101,9 +101,9 @@ fn emulate_foreign_item( fn is_dyn_sym(&self, name: &str) -> bool { let this = self.eval_context_ref(); - match this.tcx.sess.target.os.as_ref() { + match &this.tcx.sess.target.os { os if this.target_os_is_unix() => shims::unix::foreign_items::is_dyn_sym(name, os), - "windows" => shims::windows::foreign_items::is_dyn_sym(name), + Os::Windows => shims::windows::foreign_items::is_dyn_sym(name), _ => false, } } @@ -842,12 +842,12 @@ fn emulate_foreign_item_inner( } // Platform-specific shims - return match this.tcx.sess.target.os.as_ref() { + return match &this.tcx.sess.target.os { _ if this.target_os_is_unix() => shims::unix::foreign_items::EvalContextExt::emulate_foreign_item_inner( this, link_name, abi, args, dest, ), - "windows" => + Os::Windows => shims::windows::foreign_items::EvalContextExt::emulate_foreign_item_inner( this, link_name, abi, args, dest, ), diff --git a/src/tools/miri/src/shims/os_str.rs b/src/tools/miri/src/shims/os_str.rs index b9391a0ffe07..28b03ffb88c6 100644 --- a/src/tools/miri/src/shims/os_str.rs +++ b/src/tools/miri/src/shims/os_str.rs @@ -7,6 +7,7 @@ use std::path::{Path, PathBuf}; use rustc_middle::ty::Ty; +use rustc_target::spec::Os; use crate::*; @@ -329,7 +330,7 @@ fn unix_to_windows(path: &mut Vec) // Below we assume that everything non-Windows works like Unix, at least // when it comes to file system path conventions. #[cfg(windows)] - return if target_os == "windows" { + return if *target_os == Os::Windows { // Windows-on-Windows, all fine. os_str } else { @@ -346,7 +347,7 @@ fn unix_to_windows(path: &mut Vec) Cow::Owned(OsString::from_wide(&path)) }; #[cfg(unix)] - return if target_os == "windows" { + return if *target_os == Os::Windows { // Windows target, Unix host. let mut path: Vec = os_str.into_owned().into_encoded_bytes(); match direction { diff --git a/src/tools/miri/src/shims/time.rs b/src/tools/miri/src/shims/time.rs index 6e56fdfe35ae..614cc75c6d58 100644 --- a/src/tools/miri/src/shims/time.rs +++ b/src/tools/miri/src/shims/time.rs @@ -5,6 +5,7 @@ use chrono::{DateTime, Datelike, Offset, Timelike, Utc}; use chrono_tz::Tz; +use rustc_target::spec::Os; use crate::*; @@ -31,8 +32,8 @@ fn parse_clockid(&self, clk_id: Scalar) -> Option { } // Some further platform-specific names we support. - match this.tcx.sess.target.os.as_ref() { - "linux" | "freebsd" | "android" => { + match &this.tcx.sess.target.os { + Os::Linux | Os::FreeBsd | Os::Android => { // Linux further distinguishes regular and "coarse" clocks, but the "coarse" version // is just specified to be "faster and less precise", so we treat it like normal // clocks. @@ -42,7 +43,7 @@ fn parse_clockid(&self, clk_id: Scalar) -> Option { return Some(TimeoutClock::Monotonic); } } - "macos" => { + Os::MacOs => { // `CLOCK_UPTIME_RAW` supposed to not increment while the system is asleep... but // that's not really something a program running inside Miri can tell, anyway. // We need to support it because std uses it. @@ -176,7 +177,7 @@ fn localtime_r( // solaris/illumos system tm struct does not have // the additional tm_zone/tm_gmtoff fields. // https://docs.oracle.com/cd/E36784_01/html/E36874/localtime-r-3c.html - if !matches!(&*this.tcx.sess.target.os, "solaris" | "illumos") { + if !matches!(&this.tcx.sess.target.os, Os::Solaris | Os::Illumos) { // tm_zone represents the timezone value in the form of: +0730, +08, -0730 or -08. // This may not be consistent with libc::localtime_r's result. @@ -215,7 +216,7 @@ fn GetSystemTimeAsFileTime( ) -> InterpResult<'tcx> { let this = self.eval_context_mut(); - this.assert_target_os("windows", shim_name); + this.assert_target_os(Os::Windows, shim_name); this.check_no_isolation(shim_name)?; let filetime = this.deref_pointer_as(LPFILETIME_op, this.windows_ty_layout("FILETIME"))?; @@ -237,7 +238,7 @@ fn QueryPerformanceCounter( ) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - this.assert_target_os("windows", "QueryPerformanceCounter"); + this.assert_target_os(Os::Windows, "QueryPerformanceCounter"); // QueryPerformanceCounter uses a hardware counter as its basis. // Miri will emulate a counter with a resolution of 1 nanosecond. @@ -260,7 +261,7 @@ fn QueryPerformanceFrequency( ) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - this.assert_target_os("windows", "QueryPerformanceFrequency"); + this.assert_target_os(Os::Windows, "QueryPerformanceFrequency"); // Retrieves the frequency of the hardware performance counter. // The frequency of the performance counter is fixed at system boot and @@ -301,7 +302,7 @@ fn windows_ticks_for(&self, duration: Duration) -> InterpResult<'tcx, u64> { fn mach_absolute_time(&self) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_ref(); - this.assert_target_os("macos", "mach_absolute_time"); + this.assert_target_os(Os::MacOs, "mach_absolute_time"); // This returns a u64, with time units determined dynamically by `mach_timebase_info`. // We return plain nanoseconds. @@ -316,7 +317,7 @@ fn mach_absolute_time(&self) -> InterpResult<'tcx, Scalar> { fn mach_timebase_info(&mut self, info_op: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - this.assert_target_os("macos", "mach_timebase_info"); + this.assert_target_os(Os::MacOs, "mach_timebase_info"); let info = this.deref_pointer_as(info_op, this.libc_ty_layout("mach_timebase_info"))?; @@ -418,7 +419,7 @@ fn clock_nanosleep( fn Sleep(&mut self, timeout: &OpTy<'tcx>) -> InterpResult<'tcx> { let this = self.eval_context_mut(); - this.assert_target_os("windows", "Sleep"); + this.assert_target_os(Os::Windows, "Sleep"); let timeout_ms = this.read_scalar(timeout)?.to_u32()?; diff --git a/src/tools/miri/src/shims/tls.rs b/src/tools/miri/src/shims/tls.rs index 9dc829d7a1ee..2159c41ab16c 100644 --- a/src/tools/miri/src/shims/tls.rs +++ b/src/tools/miri/src/shims/tls.rs @@ -6,6 +6,7 @@ use rustc_abi::{ExternAbi, HasDataLayout, Size}; use rustc_middle::ty; +use rustc_target::spec::Os; use crate::*; @@ -234,8 +235,8 @@ pub fn on_stack_empty( let new_state = 'new_state: { match &mut self.0 { Init => { - match this.tcx.sess.target.os.as_ref() { - "macos" => { + match this.tcx.sess.target.os { + Os::MacOs => { // macOS has a _tlv_atexit function that allows // registering destructors without associated keys. // These are run first. @@ -245,7 +246,7 @@ pub fn on_stack_empty( // All other Unixes directly jump to running the pthread dtors. break 'new_state PthreadDtors(Default::default()); } - "windows" => { + Os::Windows => { // Determine which destructors to run. let dtors = this.lookup_windows_tls_dtors()?; // And move to the next state, that runs them. diff --git a/src/tools/miri/src/shims/unix/env.rs b/src/tools/miri/src/shims/unix/env.rs index eb4365e20042..41bf70c34634 100644 --- a/src/tools/miri/src/shims/unix/env.rs +++ b/src/tools/miri/src/shims/unix/env.rs @@ -6,6 +6,7 @@ use rustc_data_structures::fx::FxHashMap; use rustc_index::IndexVec; use rustc_middle::ty::Ty; +use rustc_target::spec::Os; use crate::*; @@ -281,7 +282,7 @@ fn apple_pthread_threadip_np( tid_op: &OpTy<'tcx>, ) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - this.assert_target_os("macos", "pthread_threadip_np"); + this.assert_target_os(Os::MacOs, "pthread_threadip_np"); let tid_dest = this.read_pointer(tid_op)?; if this.ptr_is_null(tid_dest)? { diff --git a/src/tools/miri/src/shims/unix/fd.rs b/src/tools/miri/src/shims/unix/fd.rs index 95e26ef5d5d8..4f1d88b79954 100644 --- a/src/tools/miri/src/shims/unix/fd.rs +++ b/src/tools/miri/src/shims/unix/fd.rs @@ -6,6 +6,7 @@ use rand::Rng; use rustc_abi::Size; +use rustc_target::spec::Os; use crate::shims::files::FileDescription; use crate::shims::sig::check_min_vararg_count; @@ -197,7 +198,7 @@ fn fcntl( fd.set_flags(flag, this) } - cmd if this.tcx.sess.target.os == "macos" + cmd if this.tcx.sess.target.os == Os::MacOs && cmd == this.eval_libc_i32("F_FULLFSYNC") => { // Reject if isolation is enabled. diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs index 1f8e60484eda..e2d27e570215 100644 --- a/src/tools/miri/src/shims/unix/foreign_items.rs +++ b/src/tools/miri/src/shims/unix/foreign_items.rs @@ -5,6 +5,7 @@ use rustc_middle::ty::Ty; use rustc_span::Symbol; use rustc_target::callconv::FnAbi; +use rustc_target::spec::Os; use self::shims::unix::android::foreign_items as android; use self::shims::unix::freebsd::foreign_items as freebsd; @@ -16,7 +17,7 @@ use crate::shims::unix::*; use crate::{shim_sig, *}; -pub fn is_dyn_sym(name: &str, target_os: &str) -> bool { +pub fn is_dyn_sym(name: &str, target_os: &Os) -> bool { match name { // Used for tests. "isatty" => true, @@ -26,15 +27,14 @@ pub fn is_dyn_sym(name: &str, target_os: &str) -> bool { // needed at least on macOS to avoid file-based fallback in getrandom "getentropy" | "getrandom" => true, // Give specific OSes a chance to allow their symbols. - _ => - match target_os { - "android" => android::is_dyn_sym(name), - "freebsd" => freebsd::is_dyn_sym(name), - "linux" => linux::is_dyn_sym(name), - "macos" => macos::is_dyn_sym(name), - "solaris" | "illumos" => solarish::is_dyn_sym(name), - _ => false, - }, + _ => match *target_os { + Os::Android => android::is_dyn_sym(name), + Os::FreeBsd => freebsd::is_dyn_sym(name), + Os::Linux => linux::is_dyn_sym(name), + Os::MacOs => macos::is_dyn_sym(name), + Os::Solaris | Os::Illumos => solarish::is_dyn_sym(name), + _ => false, + }, } } @@ -302,7 +302,7 @@ fn emulate_foreign_item_inner( } "flock" => { // Currently this function does not exist on all Unixes, e.g. on Solaris. - this.check_target_os(&["linux", "freebsd", "macos", "illumos"], link_name)?; + this.check_target_os(&[Os::Linux, Os::FreeBsd, Os::MacOs, Os::Illumos], link_name)?; let [fd, op] = this.check_shim_sig( shim_sig!(extern "C" fn(i32, i32) -> i32), link_name, @@ -530,7 +530,7 @@ fn emulate_foreign_item_inner( } "pipe2" => { // Currently this function does not exist on all Unixes, e.g. on macOS. - this.check_target_os(&["linux", "freebsd", "solaris", "illumos"], link_name)?; + this.check_target_os(&[Os::Linux, Os::FreeBsd, Os::Solaris, Os::Illumos], link_name)?; let [pipefd, flags] = this.check_shim_sig( shim_sig!(extern "C" fn(*mut _, i32) -> i32), link_name, @@ -596,7 +596,7 @@ fn emulate_foreign_item_inner( "reallocarray" => { // Currently this function does not exist on all Unixes, e.g. on macOS. - this.check_target_os(&["linux", "freebsd", "android"], link_name)?; + this.check_target_os(&[Os::Linux, Os::FreeBsd, Os::Android], link_name)?; let [ptr, nmemb, size] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?; let ptr = this.read_pointer(ptr)?; @@ -861,7 +861,7 @@ fn emulate_foreign_item_inner( "clock_nanosleep" => { // Currently this function does not exist on all Unixes, e.g. on macOS. this.check_target_os( - &["freebsd", "linux", "android", "solaris", "illumos"], + &[Os::FreeBsd, Os::Linux, Os::Android, Os::Solaris, Os::Illumos], link_name, )?; let [clock_id, flags, req, rem] = @@ -871,7 +871,7 @@ fn emulate_foreign_item_inner( } "sched_getaffinity" => { // Currently this function does not exist on all Unixes, e.g. on macOS. - this.check_target_os(&["linux", "freebsd", "android"], link_name)?; + this.check_target_os(&[Os::Linux, Os::FreeBsd, Os::Android], link_name)?; let [pid, cpusetsize, mask] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?; let pid = this.read_scalar(pid)?.to_u32()?; @@ -909,7 +909,7 @@ fn emulate_foreign_item_inner( } "sched_setaffinity" => { // Currently this function does not exist on all Unixes, e.g. on macOS. - this.check_target_os(&["linux", "freebsd", "android"], link_name)?; + this.check_target_os(&[Os::Linux, Os::FreeBsd, Os::Android], link_name)?; let [pid, cpusetsize, mask] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?; let pid = this.read_scalar(pid)?.to_u32()?; @@ -968,7 +968,7 @@ fn emulate_foreign_item_inner( // This function is non-standard but exists with the same signature and behavior on // Linux, macOS, FreeBSD and Solaris/Illumos. this.check_target_os( - &["linux", "macos", "freebsd", "illumos", "solaris", "android"], + &[Os::Linux, Os::MacOs, Os::FreeBsd, Os::Illumos, Os::Solaris, Os::Android], link_name, )?; let [buf, bufsize] = @@ -1000,7 +1000,7 @@ fn emulate_foreign_item_inner( // This function is non-standard but exists with the same signature and behavior on // Linux, FreeBSD and Solaris/Illumos. this.check_target_os( - &["linux", "freebsd", "illumos", "solaris", "android"], + &[Os::Linux, Os::FreeBsd, Os::Illumos, Os::Solaris, Os::Android], link_name, )?; let [ptr, len, flags] = @@ -1015,7 +1015,7 @@ fn emulate_foreign_item_inner( "arc4random_buf" => { // This function is non-standard but exists with the same signature and // same behavior (eg never fails) on FreeBSD and Solaris/Illumos. - this.check_target_os(&["freebsd", "illumos", "solaris"], link_name)?; + this.check_target_os(&[Os::FreeBsd, Os::Illumos, Os::Solaris], link_name)?; let [ptr, len] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?; let ptr = this.read_pointer(ptr)?; let len = this.read_target_usize(len)?; @@ -1036,7 +1036,7 @@ fn emulate_foreign_item_inner( // `_Unwind_RaiseException` impl in miri should work: // https://github.com/ARM-software/abi-aa/blob/main/ehabi32/ehabi32.rst this.check_target_os( - &["linux", "freebsd", "illumos", "solaris", "android", "macos"], + &[Os::Linux, Os::FreeBsd, Os::Illumos, Os::Solaris, Os::Android, Os::MacOs], link_name, )?; // This function looks and behaves excatly like miri_start_unwind. @@ -1146,25 +1146,25 @@ fn emulate_foreign_item_inner( // Platform-specific shims _ => { - let target_os = &*this.tcx.sess.target.os; + let target_os = &this.tcx.sess.target.os; return match target_os { - "android" => + Os::Android => android::EvalContextExt::emulate_foreign_item_inner( this, link_name, abi, args, dest, ), - "freebsd" => + Os::FreeBsd => freebsd::EvalContextExt::emulate_foreign_item_inner( this, link_name, abi, args, dest, ), - "linux" => + Os::Linux => linux::EvalContextExt::emulate_foreign_item_inner( this, link_name, abi, args, dest, ), - "macos" => + Os::MacOs => macos::EvalContextExt::emulate_foreign_item_inner( this, link_name, abi, args, dest, ), - "solaris" | "illumos" => + Os::Solaris | Os::Illumos => solarish::EvalContextExt::emulate_foreign_item_inner( this, link_name, abi, args, dest, ), diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs index 22bec9bd8394..076012591760 100644 --- a/src/tools/miri/src/shims/unix/fs.rs +++ b/src/tools/miri/src/shims/unix/fs.rs @@ -11,6 +11,7 @@ use rustc_abi::Size; use rustc_data_structures::fx::FxHashMap; +use rustc_target::spec::Os; use self::shims::time::system_time_to_duration; use crate::shims::files::FileHandle; @@ -149,7 +150,7 @@ fn macos_fbsd_solarish_write_stat_buf( &buf, )?; - if matches!(&*this.tcx.sess.target.os, "macos" | "freebsd") { + if matches!(&this.tcx.sess.target.os, Os::MacOs | Os::FreeBsd) { this.write_int_fields_named( &[ ("st_atime_nsec", access_nsec.into()), @@ -164,7 +165,7 @@ fn macos_fbsd_solarish_write_stat_buf( )?; } - if matches!(&*this.tcx.sess.target.os, "solaris" | "illumos") { + if matches!(&this.tcx.sess.target.os, Os::Solaris | Os::Illumos) { let st_fstype = this.project_field_named(&buf, "st_fstype")?; // This is an array; write 0 into first element so that it encodes the empty string. this.write_int(0, &this.project_index(&st_fstype, 0)?)?; @@ -390,7 +391,7 @@ fn open( // (Technically we do not support *not* setting this flag, but we ignore that.) mirror |= o_cloexec; } - if this.tcx.sess.target.os == "linux" { + if this.tcx.sess.target.os == Os::Linux { let o_tmpfile = this.eval_libc_i32("O_TMPFILE"); if flag & o_tmpfile == o_tmpfile { // if the flag contains `O_TMPFILE` then we return a graceful error @@ -529,7 +530,7 @@ fn macos_fbsd_solarish_stat( ) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - if !matches!(&*this.tcx.sess.target.os, "macos" | "freebsd" | "solaris" | "illumos") { + if !matches!(&this.tcx.sess.target.os, Os::MacOs | Os::FreeBsd | Os::Solaris | Os::Illumos) { panic!("`macos_fbsd_solaris_stat` should not be called on {}", this.tcx.sess.target.os); } @@ -559,7 +560,7 @@ fn macos_fbsd_solarish_lstat( ) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - if !matches!(&*this.tcx.sess.target.os, "macos" | "freebsd" | "solaris" | "illumos") { + if !matches!(&this.tcx.sess.target.os, Os::MacOs | Os::FreeBsd | Os::Solaris | Os::Illumos) { panic!( "`macos_fbsd_solaris_lstat` should not be called on {}", this.tcx.sess.target.os @@ -590,7 +591,7 @@ fn macos_fbsd_solarish_fstat( ) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - if !matches!(&*this.tcx.sess.target.os, "macos" | "freebsd" | "solaris" | "illumos") { + if !matches!(&this.tcx.sess.target.os, Os::MacOs | Os::FreeBsd | Os::Solaris | Os::Illumos) { panic!( "`macos_fbsd_solaris_fstat` should not be called on {}", this.tcx.sess.target.os @@ -623,7 +624,7 @@ fn linux_statx( ) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - this.assert_target_os("linux", "statx"); + this.assert_target_os(Os::Linux, "statx"); let dirfd = this.read_scalar(dirfd_op)?.to_i32()?; let pathname_ptr = this.read_pointer(pathname_op)?; @@ -824,7 +825,7 @@ fn mkdir(&mut self, path_op: &OpTy<'tcx>, mode_op: &OpTy<'tcx>) -> InterpResult< let this = self.eval_context_mut(); #[cfg_attr(not(unix), allow(unused_variables))] - let mode = if matches!(&*this.tcx.sess.target.os, "macos" | "freebsd") { + let mode = if matches!(&this.tcx.sess.target.os, Os::MacOs | Os::FreeBsd) { u32::from(this.read_scalar(mode_op)?.to_u16()?) } else { this.read_scalar(mode_op)?.to_u32()? @@ -903,7 +904,7 @@ fn opendir(&mut self, name_op: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> { fn readdir64(&mut self, dirent_type: &str, dirp_op: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - if !matches!(&*this.tcx.sess.target.os, "linux" | "solaris" | "illumos" | "freebsd") { + if !matches!(&this.tcx.sess.target.os, Os::Linux | Os::Solaris | Os::Illumos | Os::FreeBsd) { panic!("`linux_solaris_readdir64` should not be called on {}", this.tcx.sess.target.os); } @@ -981,7 +982,7 @@ fn readdir64(&mut self, dirent_type: &str, dirp_op: &OpTy<'tcx>) -> InterpResult // Write common fields let ino_name = - if this.tcx.sess.target.os == "freebsd" { "d_fileno" } else { "d_ino" }; + if this.tcx.sess.target.os == Os::FreeBsd { "d_fileno" } else { "d_ino" }; this.write_int_fields_named( &[(ino_name, ino.into()), ("d_reclen", size.into())], &entry, @@ -1034,7 +1035,7 @@ fn macos_fbsd_readdir_r( ) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - if !matches!(&*this.tcx.sess.target.os, "macos" | "freebsd") { + if !matches!(&this.tcx.sess.target.os, Os::MacOs | Os::FreeBsd) { panic!("`macos_fbsd_readdir_r` should not be called on {}", this.tcx.sess.target.os); } @@ -1102,8 +1103,8 @@ fn macos_fbsd_readdir_r( &entry_place, )?; // Special fields. - match &*this.tcx.sess.target.os { - "macos" => { + match this.tcx.sess.target.os { + Os::MacOs => { #[rustfmt::skip] this.write_int_fields_named( &[ @@ -1113,7 +1114,7 @@ fn macos_fbsd_readdir_r( &entry_place, )?; } - "freebsd" => { + Os::FreeBsd => { #[rustfmt::skip] this.write_int_fields_named( &[ diff --git a/src/tools/miri/src/shims/unix/mem.rs b/src/tools/miri/src/shims/unix/mem.rs index 1738de4dd4fe..01aa5afafcc3 100644 --- a/src/tools/miri/src/shims/unix/mem.rs +++ b/src/tools/miri/src/shims/unix/mem.rs @@ -15,6 +15,7 @@ //! report UB. use rustc_abi::Size; +use rustc_target::spec::Os; use crate::*; @@ -46,7 +47,7 @@ fn mmap( // This is a horrible hack, but on MacOS and Solarish the guard page mechanism uses mmap // in a way we do not support. We just give it the return value it expects. if this.frame_in_std() - && matches!(&*this.tcx.sess.target.os, "macos" | "solaris" | "illumos") + && matches!(&this.tcx.sess.target.os, Os::MacOs | Os::Solaris | Os::Illumos) && (flags & map_fixed) != 0 { return interp_ok(Scalar::from_maybe_pointer(Pointer::without_provenance(addr), this)); diff --git a/src/tools/miri/src/shims/unix/solarish/foreign_items.rs b/src/tools/miri/src/shims/unix/solarish/foreign_items.rs index 31269bf00c94..6335e6bc9662 100644 --- a/src/tools/miri/src/shims/unix/solarish/foreign_items.rs +++ b/src/tools/miri/src/shims/unix/solarish/foreign_items.rs @@ -2,6 +2,7 @@ use rustc_middle::ty::Ty; use rustc_span::Symbol; use rustc_target::callconv::FnAbi; +use rustc_target::spec::Os; use crate::shims::unix::foreign_items::EvalContextExt as _; use crate::shims::unix::linux_like::epoll::EvalContextExt as _; @@ -26,26 +27,26 @@ fn emulate_foreign_item_inner( match link_name.as_str() { // epoll, eventfd (NOT available on Solaris!) "epoll_create1" => { - this.assert_target_os("illumos", "epoll_create1"); + this.assert_target_os(Os::Illumos, "epoll_create1"); let [flag] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?; let result = this.epoll_create1(flag)?; this.write_scalar(result, dest)?; } "epoll_ctl" => { - this.assert_target_os("illumos", "epoll_ctl"); + this.assert_target_os(Os::Illumos, "epoll_ctl"); let [epfd, op, fd, event] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?; let result = this.epoll_ctl(epfd, op, fd, event)?; this.write_scalar(result, dest)?; } "epoll_wait" => { - this.assert_target_os("illumos", "epoll_wait"); + this.assert_target_os(Os::Illumos, "epoll_wait"); let [epfd, events, maxevents, timeout] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?; this.epoll_wait(epfd, events, maxevents, timeout, dest)?; } "eventfd" => { - this.assert_target_os("illumos", "eventfd"); + this.assert_target_os(Os::Illumos, "eventfd"); let [val, flag] = this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?; let result = this.eventfd(val, flag)?; this.write_scalar(result, dest)?; diff --git a/src/tools/miri/src/shims/unix/sync.rs b/src/tools/miri/src/shims/unix/sync.rs index 57dbe2cd333b..39014f34c897 100644 --- a/src/tools/miri/src/shims/unix/sync.rs +++ b/src/tools/miri/src/shims/unix/sync.rs @@ -1,4 +1,5 @@ use rustc_abi::Size; +use rustc_target::spec::Os; use crate::concurrency::sync::{AccessKind, SyncObj}; use crate::*; @@ -29,8 +30,8 @@ fn bytewise_equal<'tcx>( #[inline] fn mutexattr_kind_offset<'tcx>(ecx: &MiriInterpCx<'tcx>) -> InterpResult<'tcx, u64> { - interp_ok(match &*ecx.tcx.sess.target.os { - "linux" | "illumos" | "solaris" | "macos" | "freebsd" | "android" => 0, + interp_ok(match &ecx.tcx.sess.target.os { + Os::Linux | Os::Illumos | Os::Solaris | Os::MacOs | Os::FreeBsd | Os::Android => 0, os => throw_unsup_format!("`pthread_mutexattr` is not supported on {os}"), }) } @@ -128,10 +129,10 @@ fn delete_on_write(&self) -> bool { /// a statically initialized mutex that is used the first time, we pick some offset within /// `pthread_mutex_t` and use it as an "initialized" flag. fn mutex_init_offset<'tcx>(ecx: &MiriInterpCx<'tcx>) -> InterpResult<'tcx, Size> { - let offset = match &*ecx.tcx.sess.target.os { - "linux" | "illumos" | "solaris" | "freebsd" | "android" => 0, + let offset = match &ecx.tcx.sess.target.os { + Os::Linux | Os::Illumos | Os::Solaris | Os::FreeBsd | Os::Android => 0, // macOS stores a signature in the first bytes, so we move to offset 4. - "macos" => 4, + Os::MacOs => 4, os => throw_unsup_format!("`pthread_mutex` is not supported on {os}"), }; let offset = Size::from_bytes(offset); @@ -152,13 +153,13 @@ fn mutex_init_offset<'tcx>(ecx: &MiriInterpCx<'tcx>) -> InterpResult<'tcx, Size> check_static_initializer("PTHREAD_MUTEX_INITIALIZER"); // Check non-standard initializers. - match &*ecx.tcx.sess.target.os { - "linux" => { + match &ecx.tcx.sess.target.os { + Os::Linux => { check_static_initializer("PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP"); check_static_initializer("PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP"); check_static_initializer("PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP"); } - "illumos" | "solaris" | "macos" | "freebsd" | "android" => { + Os::Illumos | Os::Solaris | Os::MacOs | Os::FreeBsd | Os::Android => { // No non-standard initializers. } os => throw_unsup_format!("`pthread_mutex` is not supported on {os}"), @@ -215,8 +216,8 @@ fn mutex_kind_from_static_initializer<'tcx>( return interp_ok(MutexKind::Default); } // Support additional platform-specific initializers. - match &*ecx.tcx.sess.target.os { - "linux" => + match &ecx.tcx.sess.target.os { + Os::Linux => if is_initializer("PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP")? { return interp_ok(MutexKind::Recursive); } else if is_initializer("PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP")? { @@ -254,10 +255,10 @@ fn delete_on_write(&self) -> bool { } fn rwlock_init_offset<'tcx>(ecx: &MiriInterpCx<'tcx>) -> InterpResult<'tcx, Size> { - let offset = match &*ecx.tcx.sess.target.os { - "linux" | "illumos" | "solaris" | "freebsd" | "android" => 0, + let offset = match &ecx.tcx.sess.target.os { + Os::Linux | Os::Illumos | Os::Solaris | Os::FreeBsd | Os::Android => 0, // macOS stores a signature in the first bytes, so we move to offset 4. - "macos" => 4, + Os::MacOs => 4, os => throw_unsup_format!("`pthread_rwlock` is not supported on {os}"), }; let offset = Size::from_bytes(offset); @@ -311,8 +312,8 @@ fn rwlock_get_data<'tcx, 'a>( #[inline] fn condattr_clock_offset<'tcx>(ecx: &MiriInterpCx<'tcx>) -> InterpResult<'tcx, u64> { - interp_ok(match &*ecx.tcx.sess.target.os { - "linux" | "illumos" | "solaris" | "freebsd" | "android" => 0, + interp_ok(match &ecx.tcx.sess.target.os { + Os::Linux | Os::Illumos | Os::Solaris | Os::FreeBsd | Os::Android => 0, // macOS does not have a clock attribute. os => throw_unsup_format!("`pthread_condattr` clock field is not supported on {os}"), }) @@ -349,10 +350,10 @@ fn condattr_set_clock_id<'tcx>( // - init: u8 fn cond_init_offset<'tcx>(ecx: &MiriInterpCx<'tcx>) -> InterpResult<'tcx, Size> { - let offset = match &*ecx.tcx.sess.target.os { - "linux" | "illumos" | "solaris" | "freebsd" | "android" => 0, + let offset = match &ecx.tcx.sess.target.os { + Os::Linux | Os::Illumos | Os::Solaris | Os::FreeBsd | Os::Android => 0, // macOS stores a signature in the first bytes, so we move to offset 4. - "macos" => 4, + Os::MacOs => 4, os => throw_unsup_format!("`pthread_cond` is not supported on {os}"), }; let offset = Size::from_bytes(offset); @@ -748,7 +749,7 @@ fn pthread_condattr_init(&mut self, attr_op: &OpTy<'tcx>) -> InterpResult<'tcx, let this = self.eval_context_mut(); // no clock attribute on macOS - if this.tcx.sess.target.os != "macos" { + if this.tcx.sess.target.os != Os::MacOs { // The default value of the clock attribute shall refer to the system // clock. // https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_condattr_setclock.html @@ -798,7 +799,7 @@ fn pthread_condattr_destroy(&mut self, attr_op: &OpTy<'tcx>) -> InterpResult<'tc // Destroying an uninit pthread_condattr is UB, so check to make sure it's not uninit. // There's no clock attribute on macOS. - if this.tcx.sess.target.os != "macos" { + if this.tcx.sess.target.os != Os::MacOs { condattr_get_clock_id(this, attr_op)?; } @@ -820,7 +821,7 @@ fn pthread_cond_init( let attr = this.read_pointer(attr_op)?; // Default clock if `attr` is null, and on macOS where there is no clock attribute. - let clock_id = if this.ptr_is_null(attr)? || this.tcx.sess.target.os == "macos" { + let clock_id = if this.ptr_is_null(attr)? || this.tcx.sess.target.os == Os::MacOs { this.eval_libc("CLOCK_REALTIME") } else { condattr_get_clock_id(this, attr_op)? diff --git a/src/tools/miri/src/shims/unix/unnamed_socket.rs b/src/tools/miri/src/shims/unix/unnamed_socket.rs index 81703d6e176b..4f4ec7183c69 100644 --- a/src/tools/miri/src/shims/unix/unnamed_socket.rs +++ b/src/tools/miri/src/shims/unix/unnamed_socket.rs @@ -7,6 +7,8 @@ use std::io; use std::io::ErrorKind; +use rustc_target::spec::Os; + use crate::concurrency::VClock; use crate::shims::files::{ EvalContextExt as _, FileDescription, FileDescriptionRef, WeakFileDescriptionRef, @@ -448,7 +450,7 @@ fn socketpair( // Interpret the flag. Every flag we recognize is "subtracted" from `flags`, so // if there is anything left at the end, that's an unsupported flag. - if this.tcx.sess.target.os == "linux" { + if this.tcx.sess.target.os == Os::Linux { // SOCK_NONBLOCK only exists on Linux. let sock_nonblock = this.eval_libc_i32("SOCK_NONBLOCK"); let sock_cloexec = this.eval_libc_i32("SOCK_CLOEXEC"); diff --git a/src/tools/miri/src/shims/windows/env.rs b/src/tools/miri/src/shims/windows/env.rs index a7c26d601e50..aabace4b7cd3 100644 --- a/src/tools/miri/src/shims/windows/env.rs +++ b/src/tools/miri/src/shims/windows/env.rs @@ -3,6 +3,7 @@ use std::io::ErrorKind; use rustc_data_structures::fx::FxHashMap; +use rustc_target::spec::Os; use self::helpers::windows_check_buffer_size; use crate::*; @@ -45,7 +46,7 @@ fn GetEnvironmentVariableW( // ^ Returns DWORD (u32 on Windows) let this = self.eval_context_mut(); - this.assert_target_os("windows", "GetEnvironmentVariableW"); + this.assert_target_os(Os::Windows, "GetEnvironmentVariableW"); let name_ptr = this.read_pointer(name_op)?; let buf_ptr = this.read_pointer(buf_op)?; @@ -73,7 +74,7 @@ fn GetEnvironmentVariableW( #[allow(non_snake_case)] fn GetEnvironmentStringsW(&mut self) -> InterpResult<'tcx, Pointer> { let this = self.eval_context_mut(); - this.assert_target_os("windows", "GetEnvironmentStringsW"); + this.assert_target_os(Os::Windows, "GetEnvironmentStringsW"); // Info on layout of environment blocks in Windows: // https://docs.microsoft.com/en-us/windows/win32/procthread/environment-variables @@ -95,7 +96,7 @@ fn GetEnvironmentStringsW(&mut self) -> InterpResult<'tcx, Pointer> { #[allow(non_snake_case)] fn FreeEnvironmentStringsW(&mut self, env_block_op: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - this.assert_target_os("windows", "FreeEnvironmentStringsW"); + this.assert_target_os(Os::Windows, "FreeEnvironmentStringsW"); let env_block_ptr = this.read_pointer(env_block_op)?; this.deallocate_ptr(env_block_ptr, None, MiriMemoryKind::Runtime.into())?; @@ -110,7 +111,7 @@ fn SetEnvironmentVariableW( value_op: &OpTy<'tcx>, // LPCWSTR ) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - this.assert_target_os("windows", "SetEnvironmentVariableW"); + this.assert_target_os(Os::Windows, "SetEnvironmentVariableW"); let name_ptr = this.read_pointer(name_op)?; let value_ptr = this.read_pointer(value_op)?; @@ -143,7 +144,7 @@ fn GetCurrentDirectoryW( buf_op: &OpTy<'tcx>, // LPTSTR ) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - this.assert_target_os("windows", "GetCurrentDirectoryW"); + this.assert_target_os(Os::Windows, "GetCurrentDirectoryW"); let size = u64::from(this.read_scalar(size_op)?.to_u32()?); let buf = this.read_pointer(buf_op)?; @@ -176,7 +177,7 @@ fn SetCurrentDirectoryW( // ^ Returns BOOL (i32 on Windows) let this = self.eval_context_mut(); - this.assert_target_os("windows", "SetCurrentDirectoryW"); + this.assert_target_os(Os::Windows, "SetCurrentDirectoryW"); let path = this.read_path_from_wide_str(this.read_pointer(path_op)?)?; @@ -199,7 +200,7 @@ fn SetCurrentDirectoryW( #[allow(non_snake_case)] fn GetCurrentProcessId(&mut self) -> InterpResult<'tcx, Scalar> { let this = self.eval_context_mut(); - this.assert_target_os("windows", "GetCurrentProcessId"); + this.assert_target_os(Os::Windows, "GetCurrentProcessId"); interp_ok(Scalar::from_u32(this.get_pid())) } @@ -213,7 +214,7 @@ fn GetUserProfileDirectoryW( ) -> InterpResult<'tcx, Scalar> // returns BOOL { let this = self.eval_context_mut(); - this.assert_target_os("windows", "GetUserProfileDirectoryW"); + this.assert_target_os(Os::Windows, "GetUserProfileDirectoryW"); this.check_no_isolation("`GetUserProfileDirectoryW`")?; let token = this.read_target_isize(token)?; diff --git a/src/tools/miri/src/shims/windows/fs.rs b/src/tools/miri/src/shims/windows/fs.rs index e4ec1b0130c9..e36ed7bd707f 100644 --- a/src/tools/miri/src/shims/windows/fs.rs +++ b/src/tools/miri/src/shims/windows/fs.rs @@ -5,6 +5,7 @@ use std::time::SystemTime; use bitflags::bitflags; +use rustc_target::spec::Os; use crate::shims::files::{FileDescription, FileHandle}; use crate::shims::windows::handle::{EvalContextExt as _, Handle}; @@ -164,7 +165,7 @@ fn CreateFileW( use CreationDisposition::*; let this = self.eval_context_mut(); - this.assert_target_os("windows", "CreateFileW"); + this.assert_target_os(Os::Windows, "CreateFileW"); this.check_no_isolation("`CreateFileW`")?; // This function appears to always set the error to 0. This is important for some flag @@ -309,7 +310,7 @@ fn GetFileInformationByHandle( ) -> InterpResult<'tcx, Scalar> { // ^ Returns BOOL (i32 on Windows) let this = self.eval_context_mut(); - this.assert_target_os("windows", "GetFileInformationByHandle"); + this.assert_target_os(Os::Windows, "GetFileInformationByHandle"); this.check_no_isolation("`GetFileInformationByHandle`")?; let file = this.read_handle(file, "GetFileInformationByHandle")?; @@ -379,7 +380,7 @@ fn DeleteFileW( ) -> InterpResult<'tcx, Scalar> { // ^ Returns BOOL (i32 on Windows) let this = self.eval_context_mut(); - this.assert_target_os("windows", "DeleteFileW"); + this.assert_target_os(Os::Windows, "DeleteFileW"); this.check_no_isolation("`DeleteFileW`")?; let file_name = this.read_path_from_wide_str(this.read_pointer(file_name)?)?;