Support for xrOS

Author: agg23

Cargo.lock

@@ -2162,8 +2162,6 @@ checksum = "db13adb97ab515a3691f56e4dbab09283d0b86cb45abd991d8634a9d6f501760"
 [[package]]
 name = "libc"
 version = "0.2.150"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89d92a4743f9a61002fae18374ed11e7973f530cb3a3255fb354818118b2203c"
 dependencies = [
  "rustc-std-workspace-core",
 ]

Cargo.toml

@@ -118,6 +118,7 @@ strip = true
 rustc-std-workspace-core = { path = 'library/rustc-std-workspace-core' }
 rustc-std-workspace-alloc = { path = 'library/rustc-std-workspace-alloc' }
 rustc-std-workspace-std = { path = 'library/rustc-std-workspace-std' }
+libc = { path = '../libc' }
 
 [patch."https://github.com/rust-lang/rust-clippy"]
 clippy_lints = { path = "src/tools/clippy/clippy_lints" }

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -902,6 +902,7 @@ fn target_is_apple(cgcx: &CodegenContext<LlvmCodegenBackend>) -> bool {
         || cgcx.opts.target_triple.triple().contains("-darwin")
         || cgcx.opts.target_triple.triple().contains("-tvos")
         || cgcx.opts.target_triple.triple().contains("-watchos")
+        || cgcx.opts.target_triple.triple().contains("-xros")
 }
 
 fn target_is_aix(cgcx: &CodegenContext<LlvmCodegenBackend>) -> bool {

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -2892,7 +2892,7 @@ fn add_apple_sdk(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavor) {
     let os = &sess.target.os;
     let llvm_target = &sess.target.llvm_target;
     if sess.target.vendor != "apple"
-        || !matches!(os.as_ref(), "ios" | "tvos" | "watchos" | "macos")
+        || !matches!(os.as_ref(), "ios" | "tvos" | "watchos" | "xros" | "macos")
         || !matches!(flavor, LinkerFlavor::Darwin(..))
     {
         return;
@@ -2917,6 +2917,8 @@ fn add_apple_sdk(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavor) {
         ("arm64_32", "watchos") => "watchos",
         ("aarch64", "watchos") if llvm_target.ends_with("-simulator") => "watchsimulator",
         ("aarch64", "watchos") => "watchos",
+        ("aarch64", "xros") if llvm_target.ends_with("-simulator") => "xrossimulator",
+        ("aarch64", "xros") => "xros",
         ("arm", "watchos") => "watchos",
         (_, "macos") => "macosx",
         _ => {
@@ -2973,6 +2975,9 @@ fn get_apple_sdk_root(sdk_name: &str) -> Result<String, errors::AppleSdkRootErro
                     || sdkroot.contains("MacOSX.platform") => {}
             "watchsimulator"
                 if sdkroot.contains("WatchOS.platform") || sdkroot.contains("MacOSX.platform") => {}
+            "xros" if sdkroot.contains("XROS.platform") || sdkroot.contains("MacOSX.platform") => {}
+            "xrossimulator"
+                if sdkroot.contains("XROS.platform") || sdkroot.contains("MacOSX.platform") => {}
             // Ignore `SDKROOT` if it's not a valid path.
             _ if !p.is_absolute() || p == Path::new("/") || !p.exists() => {}
             _ => return Ok(sdkroot),

compiler/rustc_target/src/spec/base/apple/mod.rs

@@ -102,6 +102,7 @@ fn pre_link_args(os: &'static str, arch: Arch, abi: &'static str) -> LinkArgs {
         "ios" => ios_lld_platform_version(arch),
         "tvos" => tvos_lld_platform_version(),
         "watchos" => watchos_lld_platform_version(),
+        "xros" => xros_lld_platform_version(),
         "macos" => macos_lld_platform_version(arch),
         _ => unreachable!(),
     }
@@ -192,6 +193,7 @@ pub fn sdk_version(platform: u32) -> Option<(u32, u32)> {
         | object::macho::PLATFORM_TVOSSIMULATOR
         | object::macho::PLATFORM_MACCATALYST => Some((16, 2)),
         object::macho::PLATFORM_WATCHOS | object::macho::PLATFORM_WATCHOSSIMULATOR => Some((9, 1)),
+        object::macho::PLATFORM_XROS | object::macho::PLATFORM_XROSSIMULATOR => Some((1, 0)),
         _ => None,
     }
 }
@@ -206,6 +208,8 @@ pub fn platform(target: &Target) -> Option<u32> {
         ("watchos", _) => object::macho::PLATFORM_WATCHOS,
         ("tvos", "sim") => object::macho::PLATFORM_TVOSSIMULATOR,
         ("tvos", _) => object::macho::PLATFORM_TVOS,
+        ("xros", "sim") => object::macho::PLATFORM_XROSSIMULATOR,
+        ("xros", _) => object::macho::PLATFORM_XROS,
         _ => return None,
     })
 }
@@ -233,6 +237,7 @@ pub fn deployment_target(target: &Target) -> Option<(u32, u32)> {
         },
         "watchos" => watchos_deployment_target(),
         "tvos" => tvos_deployment_target(),
+        "xros" => xros_deployment_target(),
         _ => return None,
     };
 
@@ -288,6 +293,7 @@ fn link_env_remove(arch: Arch, os: &'static str) -> StaticCow<[StaticCow<str>]>
                 || sdkroot.contains("AppleTVSimulator.platform")
                 || sdkroot.contains("WatchOS.platform")
                 || sdkroot.contains("WatchSimulator.platform")
+                || sdkroot.contains("XROS.platform")
             {
                 env_remove.push("SDKROOT".into())
             }
@@ -297,6 +303,7 @@ fn link_env_remove(arch: Arch, os: &'static str) -> StaticCow<[StaticCow<str>]>
         // although this is apparently ignored when using the linker at "/usr/bin/ld".
         env_remove.push("IPHONEOS_DEPLOYMENT_TARGET".into());
         env_remove.push("TVOS_DEPLOYMENT_TARGET".into());
+        env_remove.push("XROS_DEPLOYMENT_TARGET".into());
         env_remove.into()
     } else {
         // Otherwise if cross-compiling for a different OS/SDK, remove any part
@@ -377,3 +384,23 @@ pub fn watchos_sim_llvm_target(arch: Arch) -> String {
     let (major, minor) = watchos_deployment_target();
     format!("{}-apple-watchos{}.{}.0-simulator", arch.target_name(), major, minor)
 }
+
+fn xros_deployment_target() -> (u32, u32) {
+    // If you are looking for the default deployment target, prefer `rustc --print deployment-target`.
+    from_set_deployment_target("XROS_DEPLOYMENT_TARGET").unwrap_or((1, 0))
+}
+
+fn xros_lld_platform_version() -> String {
+    let (major, minor) = xros_deployment_target();
+    format!("{major}.{minor}")
+}
+
+pub fn xros_llvm_target(arch: Arch) -> String {
+    let (major, minor) = xros_deployment_target();
+    format!("{}-apple-xros{}.{}.0", arch.target_name(), major, minor)
+}
+
+pub fn xros_sim_llvm_target(arch: Arch) -> String {
+    let (major, minor) = xros_deployment_target();
+    format!("{}-apple-xros{}.{}.0-simulator", arch.target_name(), major, minor)
+}

compiler/rustc_target/src/spec/base/apple/tests.rs

@@ -1,6 +1,7 @@
 use crate::spec::targets::{
-    aarch64_apple_darwin, aarch64_apple_ios_sim, aarch64_apple_watchos_sim, i686_apple_darwin,
-    x86_64_apple_darwin, x86_64_apple_ios, x86_64_apple_tvos, x86_64_apple_watchos_sim,
+    aarch64_apple_darwin, aarch64_apple_ios_sim, aarch64_apple_watchos_sim, aarch64_apple_xros_sim,
+    i686_apple_darwin, x86_64_apple_darwin, x86_64_apple_ios, x86_64_apple_tvos,
+    x86_64_apple_watchos_sim,
 };
 
 #[test]
@@ -12,6 +13,7 @@ fn simulator_targets_set_abi() {
         aarch64_apple_ios_sim::target(),
         // Note: There is currently no ARM64 tvOS simulator target
         aarch64_apple_watchos_sim::target(),
+        aarch64_apple_xros_sim::target(),
     ];
 
     for target in all_sim_targets {

compiler/rustc_target/src/spec/mod.rs

@@ -1539,6 +1539,9 @@ supported_targets! {
     ("aarch64-apple-watchos", aarch64_apple_watchos),
     ("aarch64-apple-watchos-sim", aarch64_apple_watchos_sim),
 
+    ("aarch64-apple-xros", aarch64_apple_xros),
+    ("aarch64-apple-xros-sim", aarch64_apple_xros_sim),
+
     ("armebv7r-none-eabi", armebv7r_none_eabi),
     ("armebv7r-none-eabihf", armebv7r_none_eabihf),
     ("armv7r-none-eabi", armv7r_none_eabi),

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

@@ -0,0 +1,21 @@
+use crate::spec::base::apple::{opts, xros_llvm_target, Arch};
+use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions};
+
+pub fn target() -> Target {
+    let arch = Arch::Arm64;
+    let mut base = opts("xros", arch);
+    base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD;
+
+    Target {
+        llvm_target: xros_llvm_target(arch).into(),
+        pointer_width: 64,
+        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
+        arch: arch.target_arch(),
+        options: TargetOptions {
+            features: "+neon,+fp-armv8,+apple-a7".into(),
+            max_atomic_width: Some(128),
+            frame_pointer: FramePointer::NonLeaf,
+            ..base
+        },
+    }
+}

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

@@ -0,0 +1,21 @@
+use crate::spec::base::apple::{opts, xros_sim_llvm_target, Arch};
+use crate::spec::{FramePointer, SanitizerSet, Target, TargetOptions};
+
+pub fn target() -> Target {
+    let arch = Arch::Arm64_sim;
+    let mut base = opts("xros", arch);
+    base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::THREAD;
+
+    Target {
+        llvm_target: xros_sim_llvm_target(arch).into(),
+        pointer_width: 64,
+        data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".into(),
+        arch: arch.target_arch(),
+        options: TargetOptions {
+            features: "+neon,+fp-armv8,+apple-a7".into(),
+            max_atomic_width: Some(128),
+            frame_pointer: FramePointer::NonLeaf,
+            ..base
+        },
+    }
+}

library/std/build.rs

@@ -14,6 +14,7 @@ fn main() {
         || target.contains("apple-ios")
         || target.contains("apple-tvos")
         || target.contains("apple-watchos")
+        || target.contains("apple-xros")
         || target.contains("uwp")
         || target.contains("windows")
         || target.contains("fuchsia")