Add AbiMapping for encoding permissive mappings

Author: workingjubilee

compiler/rustc_target/src/spec/abi_map.rs

@@ -6,12 +6,38 @@ 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)]
+#[derive(Clone, Debug)]
 pub struct AbiMap {
     arch: Arch,
     os: OsKind,
 }
 
+#[derive(Copy, Clone, Debug)]
+pub enum AbiMapping {
+    /// this ABI is exactly mapped for this platform
+    Direct(CanonAbi),
+    /// a "permissive" ABI mapping generalized from other platforms
+    Permissive(CanonAbi),
+    Invalid,
+}
+
+impl AbiMapping {
+    pub fn into_option(self) -> Option<CanonAbi> {
+        match self {
+            Self::Direct(abi) | Self::Permissive(abi) => Some(abi),
+            Self::Invalid => None,
+        }
+    }
+
+    pub fn unwrap(self) -> CanonAbi {
+        self.into_option().unwrap()
+    }
+
+    pub fn is_mapped(self) -> bool {
+        self.into_option().is_some()
+    }
+}
+
 impl AbiMap {
     pub fn from_target(target: &Target) -> Self {
         // the purpose of this little exercise is to force listing what affects these mappings
@@ -32,7 +58,7 @@ impl AbiMap {
         AbiMap { arch, os }
     }
 
-    pub fn canonize_abi(&self, extern_abi: ExternAbi, has_c_varargs: bool) -> Option<CanonAbi> {
+    pub fn canonize_abi(&self, extern_abi: ExternAbi, has_c_varargs: bool) -> AbiMapping {
         let AbiMap { os, arch } = *self;
 
         let canon_abi = match (extern_abi, arch) {
@@ -53,43 +79,45 @@ impl AbiMap {
             (ExternAbi::EfiApi, Arch::Arm(..)) => CanonAbi::Arm(ArmCall::Aapcs),
             (ExternAbi::EfiApi, Arch::X86_64) => CanonAbi::X86(X86Call::Win64),
             (ExternAbi::EfiApi, Arch::Aarch64 | Arch::Riscv | Arch::X86) => CanonAbi::C,
-            (ExternAbi::EfiApi, _) => return None,
+            (ExternAbi::EfiApi, _) => return AbiMapping::Invalid,
 
             (ExternAbi::Aapcs { .. }, Arch::Arm(..)) => CanonAbi::Arm(ArmCall::Aapcs),
-            (ExternAbi::Aapcs { .. }, _) => return None,
+            (ExternAbi::Aapcs { .. }, _) => return AbiMapping::Invalid,
 
             (ExternAbi::CCmseNonSecureCall, Arch::Arm(ArmVer::ThumbV8M)) => {
                 CanonAbi::Arm(ArmCall::CCmseNonSecureCall)
             }
             (ExternAbi::CCmseNonSecureEntry, Arch::Arm(ArmVer::ThumbV8M)) => {
                 CanonAbi::Arm(ArmCall::CCmseNonSecureEntry)
             }
-            (ExternAbi::CCmseNonSecureCall | ExternAbi::CCmseNonSecureEntry, ..) => return None,
+            (ExternAbi::CCmseNonSecureCall | ExternAbi::CCmseNonSecureEntry, ..) => {
+                return AbiMapping::Invalid;
+            }
 
             (ExternAbi::Fastcall { .. }, Arch::X86) => CanonAbi::X86(X86Call::Fastcall),
             (ExternAbi::Fastcall { .. }, _) if os == OsKind::Windows => CanonAbi::C,
-            (ExternAbi::Fastcall { .. }, _) => return None,
+            (ExternAbi::Fastcall { .. }, _) => return AbiMapping::Invalid,
 
             (ExternAbi::Stdcall { .. }, Arch::X86) => CanonAbi::X86(X86Call::Stdcall),
             (ExternAbi::Stdcall { .. }, _) if os == OsKind::Windows => CanonAbi::C,
-            (ExternAbi::Stdcall { .. }, _) => return None,
+            (ExternAbi::Stdcall { .. }, _) => return AbiMapping::Invalid,
 
             (ExternAbi::Thiscall { .. }, Arch::X86) => CanonAbi::X86(X86Call::Thiscall),
-            (ExternAbi::Thiscall { .. }, _) => return None,
+            (ExternAbi::Thiscall { .. }, _) => return AbiMapping::Invalid,
 
             (ExternAbi::Vectorcall { .. }, Arch::X86 | Arch::X86_64) => {
                 CanonAbi::X86(X86Call::Vectorcall)
             }
             (ExternAbi::Vectorcall { .. }, _) if os == OsKind::Windows => CanonAbi::C,
-            (ExternAbi::Vectorcall { .. }, _) => return None,
+            (ExternAbi::Vectorcall { .. }, _) => return AbiMapping::Invalid,
 
             (ExternAbi::SysV64 { .. }, Arch::X86_64) => CanonAbi::X86(X86Call::SysV64),
             (ExternAbi::Win64 { .. }, Arch::X86_64) => CanonAbi::X86(X86Call::Win64),
-            (ExternAbi::SysV64 { .. } | ExternAbi::Win64 { .. }, _) => return None,
+            (ExternAbi::SysV64 { .. } | ExternAbi::Win64 { .. }, _) => return AbiMapping::Invalid,
 
             (ExternAbi::PtxKernel, Arch::Nvptx) => CanonAbi::GpuKernel,
             (ExternAbi::GpuKernel, Arch::Amdgpu | Arch::Nvptx) => CanonAbi::GpuKernel,
-            (ExternAbi::PtxKernel | ExternAbi::GpuKernel, _) => return None,
+            (ExternAbi::PtxKernel | ExternAbi::GpuKernel, _) => return AbiMapping::Invalid,
 
             (ExternAbi::AvrInterrupt, Arch::Avr) => CanonAbi::Interrupt(InterruptKind::Avr),
             (ExternAbi::AvrNonBlockingInterrupt, Arch::Avr) => {
@@ -115,10 +143,10 @@ impl AbiMap {
                 | ExternAbi::RiscvInterruptS
                 | ExternAbi::X86Interrupt,
                 _,
-            ) => return None,
+            ) => return AbiMapping::Invalid,
         };
 
-        Some(canon_abi)
+        AbiMapping::Direct(canon_abi)
     }
 }
 

compiler/rustc_target/src/spec/mod.rs

@@ -2917,7 +2917,7 @@ impl DerefMut for Target {
 impl Target {
     pub fn is_abi_supported(&self, abi: ExternAbi) -> bool {
         let abi_map = AbiMap::from_target(self);
-        abi_map.canonize_abi(abi, false).is_some()
+        abi_map.canonize_abi(abi, false).is_mapped()
     }
 
     /// Minimum integer size in bits that this target can perform atomic