rustc_target: stow an AbiMap and expose through accessor

Author: workingjubilee

compiler/rustc_target/src/spec/abi_map.rs

@@ -6,7 +6,7 @@ use crate::spec::Target;
 ///
 /// A maybe-transitional structure circa 2025 for hosting future experiments in
 /// encapsulating arch-specific ABI lowering details to make them more testable.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct AbiMap {
     arch: Arch,
     os: OsKind,
@@ -47,10 +47,15 @@ impl AbiMap {
     /// create an AbiMap according to arbitrary fields on the [Target]
     pub fn from_target(target: &Target) -> Self {
         // the purpose of this little exercise is to force listing what affects these mappings
-        let arch = match &*target.arch {
+        AbiMap::from_args(&target.arch, &target.llvm_target, target.is_like_windows)
+    }
+
+    /// implementation detail of `AbiMap::from_target`, may replace it entirely soon?
+    pub(super) fn from_args(arch: &str, llvm_target: &str, is_like_windows: bool) -> Self {
+        let arch = match arch {
             "aarch64" => Arch::Aarch64,
             "amdgpu" => Arch::Amdgpu,
-            "arm" if target.llvm_target.starts_with("thumbv8m") => Arch::Arm(ArmVer::ThumbV8M),
+            "arm" if llvm_target.starts_with("thumbv8m") => Arch::Arm(ArmVer::ThumbV8M),
             "arm" => Arch::Arm(ArmVer::Other),
             "avr" => Arch::Avr,
             "msp430" => Arch::Msp430,
@@ -60,7 +65,7 @@ impl AbiMap {
             "x86_64" => Arch::X86_64,
             _ => Arch::Other,
         };
-        let os = if target.is_like_windows { OsKind::Windows } else { OsKind::Other };
+        let os = if is_like_windows { OsKind::Windows } else { OsKind::Other };
         AbiMap { arch, os }
     }
 

compiler/rustc_target/src/spec/json.rs

@@ -675,14 +675,15 @@ impl Target {
         key!(entry_name);
         key!(supports_xray, bool);
 
-        // we're going to run `update_from_cli`, but that won't change the target's AbiMap
-        // FIXME: better factor the Target definition so we enforce this on a type level
-        let abi_map = AbiMap::from_target(&base);
+        // This API is exposed almost entirely for this
+        base.abi_map = AbiMap::from_args(&base.arch, &base.llvm_target, base.is_like_windows);
 
         if let Some(abi_str) = obj.remove("entry-abi") {
             if let Json::String(abi_str) = abi_str {
                 match abi_str.parse::<ExternAbi>() {
-                    Ok(abi) => base.options.entry_abi = abi_map.canonize_abi(abi, false).unwrap(),
+                    Ok(abi) => {
+                        base.options.entry_abi = base.abi_map.canonize_abi(abi, false).unwrap()
+                    }
                     Err(_) => return Err(format!("{abi_str} is not a valid ExternAbi")),
                 }
             } else {

compiler/rustc_target/src/spec/mod.rs

@@ -2259,6 +2259,8 @@ type StaticCow<T> = Cow<'static, T>;
 /// through `Deref` impls.
 #[derive(PartialEq, Clone, Debug)]
 pub struct TargetOptions {
+    /// How to translate ABIs for this target
+    abi_map: AbiMap,
     /// Used as the `target_endian` `cfg` variable. Defaults to little endian.
     pub endian: Endian,
     /// Width of c_int type. Defaults to "32".
@@ -2758,6 +2760,10 @@ impl Default for TargetOptions {
     /// incomplete, and if used for compilation, will certainly not work.
     fn default() -> TargetOptions {
         TargetOptions {
+            // FIXME(jubilee): We shouldn't do this, and this code indicates a backwards ontology.
+            // There is no "default target" so we shouldn't let this type be incrementally built.
+            // Rather, we should validate the construction in a builder's `.build()`.
+            abi_map: AbiMap::from_args("", "", false),
             endian: Endian::Little,
             c_int_width: 32,
             os: "none".into(),
@@ -2904,6 +2910,11 @@ impl Target {
         abi_map.canonize_abi(abi, false).is_mapped()
     }
 
+    /// how the target translates ABI strings to "real" ABIs
+    pub fn abi_map(&self) -> &AbiMap {
+        &self.abi_map
+    }
+
     /// Minimum integer size in bits that this target can perform atomic
     /// operations on.
     pub fn min_atomic_width(&self) -> u64 {