rustc_target: introduce OS

Improve type safety by using an enum rather than strings.

Author: tamird

compiler/rustc_codegen_cranelift/src/lib.rs

@@ -47,7 +47,7 @@ use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
 use rustc_session::Session;
 use rustc_session::config::OutputFilenames;
 use rustc_span::{Symbol, sym};
-use rustc_target::spec::{ABI, Arch, Env};
+use rustc_target::spec::{ABI, Arch, Env, OS};
 
 pub use crate::config::*;
 use crate::prelude::*;
@@ -185,15 +185,15 @@ impl CodegenBackend for CraneliftCodegenBackend {
     fn target_config(&self, sess: &Session) -> TargetConfig {
         // FIXME return the actually used target features. this is necessary for #[cfg(target_feature)]
         let target_features = 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],
             },
@@ -214,7 +214,7 @@ impl CodegenBackend for CraneliftCodegenBackend {
             // targets due to GCC using a different ABI than LLVM. Therefore `f16` won't be
             // available when using a LLVM-built sysroot.
             Arch::X86_64
-                if sess.target.os == "windows"
+                if sess.target.os == OS::Windows
                     && sess.target.env == Env::Gnu
                     && sess.target.abi != ABI::Llvm =>
             {

compiler/rustc_codegen_llvm/src/context.rs

@@ -29,7 +29,7 @@ use rustc_span::source_map::Spanned;
 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 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
     /// This corresponds to the `-fobjc-abi-version=` flag in Clang / GCC.
     pub(crate) fn objc_abi_version(&self) -> u32 {
         assert!(self.tcx.sess.target.is_like_darwin);
-        if self.tcx.sess.target.arch == 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 @@ impl<'ll> CodegenCx<'ll, '_> {
             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),
             _ => {

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -18,6 +18,7 @@ use rustc_middle::{bug, span_bug};
 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);

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -16,7 +16,7 @@ use rustc_middle::bug;
 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 @@ unsafe fn configure_llvm(sess: &Session) {
             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 <https://github.com/llvm/llvm-project/issues/50374> (fixed in llvm21)
         (Arch::S390x, _) if lt_21_0_0 => false,
         // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
-        (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 <https://github.com/llvm/llvm-project/issues/97981>
         (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 <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
-        (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;
 }

compiler/rustc_codegen_ssa/src/back/apple.rs

@@ -6,7 +6,7 @@ use itertools::Itertools;
 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 @@ mod tests;
 
 /// 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"),
     }
 }

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -47,7 +47,7 @@ use rustc_span::Symbol;
 use rustc_target::spec::crt_objects::CrtObjects;
 use rustc_target::spec::{
     BinaryFormat, Cc, Env, LinkOutputKind, LinkSelfContainedComponents, LinkSelfContainedDefault,
-    LinkerFeatures, LinkerFlavor, LinkerFlavorCli, Lld, RelocModel, RelroLevel, SanitizerSet,
+    LinkerFeatures, LinkerFlavor, LinkerFlavorCli, Lld, OS, RelocModel, RelroLevel, SanitizerSet,
     SplitDebuginfo, Vendor,
 };
 use tracing::{debug, info, warn};
@@ -1842,7 +1842,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
@@ -2493,7 +2493,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, _))
     {
@@ -2516,7 +2516,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() {
@@ -3071,7 +3071,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.
@@ -3124,12 +3124,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}"),
         };
 
@@ -3193,7 +3193,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`: <https://github.com/llvm/llvm-project/issues/88271>
-        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

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -17,7 +17,7 @@ use rustc_middle::middle::exported_symbols::{
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_session::config::{self, CrateType, DebugInfo, LinkerPluginLto, Lto, OptLevel, Strip};
-use rustc_target::spec::{Arch, Cc, LinkOutputKind, LinkerFlavor, Lld, Vendor};
+use rustc_target::spec::{Arch, Cc, LinkOutputKind, LinkerFlavor, Lld, OS, Vendor};
 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.vendor == Vendor::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<dyn Linker>
         }
-        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<dyn Linker>
         }
         LinkerFlavor::WasmLld(Cc::No) => Box::new(WasmLd::new(cmd, sess)) as Box<dyn Linker>,
@@ -573,7 +573,7 @@ impl<'a> Linker for GccLinker<'a> {
         // 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 @@ impl<'a> Linker for GccLinker<'a> {
     }
 
     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 @@ impl<'a> Linker for WasmLd<'a> {
         // 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"]);
         }
     }

compiler/rustc_codegen_ssa/src/back/metadata.rs

@@ -20,7 +20,7 @@ use rustc_metadata::fs::METADATA_FILENAME;
 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<write::Object<'static
 }
 
 pub(super) fn elf_os_abi(sess: &Session) -> 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,
     }
 }

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -17,7 +17,7 @@ use rustc_middle::ty::{self, GenericArgKind, GenericArgsRef, Instance, SymbolNam
 use rustc_middle::util::Providers;
 use rustc_session::config::{CrateType, OomStrategy};
 use rustc_symbol_mangling::mangle_internal_symbol;
-use rustc_target::spec::{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;
     }