make entry_abi a lowering of the ABI string

this allows removing CanonAbi::try_from_extern_abi and its FromStr

Author: workingjubilee

compiler/rustc_abi/src/canon_abi.rs

@@ -1,12 +1,11 @@
 use std::cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
 use std::fmt;
 use std::hash::{Hash, Hasher};
-use std::str::FromStr;
 
 #[cfg(feature = "nightly")]
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableOrd};
 
-use crate::{AbiConvErr, ExternAbi};
+use crate::ExternAbi;
 
 /// Calling convention to determine codegen
 ///
@@ -134,69 +133,6 @@ impl CanonAbi {
             },
         }
     }
-
-    /// convert an ExternAbi to a CanonAbi if it maps directly
-    ///
-    /// A target-insensitive mapping of ExternAbi to CanonAbi. This is a partial function,
-    /// and mostly serves as a way to reuse ExternAbi's code.
-    const fn try_from_extern_abi(extern_abi: ExternAbi) -> Result<Self, AbiConvErr> {
-        match extern_abi {
-            ExternAbi::C { unwind: false } => Ok(Self::C),
-            ExternAbi::Rust => Ok(Self::Rust),
-            ExternAbi::RustCold => Ok(Self::RustCold),
-
-            // arm
-            ExternAbi::Aapcs { unwind: false } => Ok(Self::Arm(ArmCall::Aapcs)),
-            ExternAbi::CCmseNonSecureCall => Ok(Self::Arm(ArmCall::CCmseNonSecureCall)),
-            ExternAbi::CCmseNonSecureEntry => Ok(Self::Arm(ArmCall::CCmseNonSecureEntry)),
-            // gpu
-            ExternAbi::GpuKernel => Ok(Self::GpuKernel),
-            // interrupt
-            ExternAbi::AvrInterrupt => Ok(Self::Interrupt(InterruptKind::Avr)),
-            ExternAbi::AvrNonBlockingInterrupt => {
-                Ok(Self::Interrupt(InterruptKind::AvrNonBlocking))
-            }
-            ExternAbi::Msp430Interrupt => Ok(Self::Interrupt(InterruptKind::Msp430)),
-            ExternAbi::RiscvInterruptM => Ok(Self::Interrupt(InterruptKind::RiscvMachine)),
-            ExternAbi::RiscvInterruptS => Ok(Self::Interrupt(InterruptKind::RiscvSupervisor)),
-            ExternAbi::X86Interrupt => Ok(Self::Interrupt(InterruptKind::X86)),
-
-            // x86
-            ExternAbi::Stdcall { unwind: false } => Ok(Self::X86(X86Call::Stdcall)),
-            ExternAbi::Fastcall { unwind: false } => Ok(Self::X86(X86Call::Fastcall)),
-            ExternAbi::Vectorcall { unwind: false } => Ok(Self::X86(X86Call::Vectorcall)),
-            ExternAbi::Thiscall { unwind: false } => Ok(Self::X86(X86Call::Thiscall)),
-            ExternAbi::Win64 { unwind: false } => Ok(Self::X86(X86Call::Win64)),
-            ExternAbi::SysV64 { unwind: false } => Ok(Self::X86(X86Call::SysV64)),
-
-            // fanon
-            ExternAbi::Cdecl { unwind: _ }
-            | ExternAbi::EfiApi
-            | ExternAbi::PtxKernel
-            | ExternAbi::RustCall
-            | ExternAbi::System { unwind: _ }
-            | ExternAbi::Unadjusted => Err(AbiConvErr::Unknown),
-            // unwind where it should not unwind
-            ExternAbi::Aapcs { unwind: true }
-            | ExternAbi::C { unwind: true }
-            | ExternAbi::Stdcall { unwind: true }
-            | ExternAbi::Fastcall { unwind: true }
-            | ExternAbi::Vectorcall { unwind: true }
-            | ExternAbi::Thiscall { unwind: true }
-            | ExternAbi::Win64 { unwind: true }
-            | ExternAbi::SysV64 { unwind: true } => Err(AbiConvErr::UnwindInvalid),
-        }
-    }
-}
-
-impl FromStr for CanonAbi {
-    type Err = AbiConvErr;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        // parse as ExternAbi and propagate out errors, as CanonAbi uses the same errors
-        let extern_abi = s.parse()?;
-        CanonAbi::try_from_extern_abi(extern_abi)
-    }
 }
 
 /// Callee codegen for interrupts

compiler/rustc_target/src/spec/json.rs

@@ -2,10 +2,12 @@ use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::str::FromStr;
 
+use rustc_abi::ExternAbi;
 use serde_json::Value;
 
 use super::{Target, TargetKind, TargetOptions, TargetWarnings};
 use crate::json::{Json, ToJson};
+use crate::spec::AbiMap;
 
 impl Target {
     /// Loads a target descriptor from a JSON object.
@@ -535,17 +537,6 @@ impl Target {
             }
         }
 
-        if let Some(abi_str) = obj.remove("entry-abi") {
-            if let Json::String(abi_str) = abi_str {
-                match abi_str.parse() {
-                    Ok(canon_abi) => base.options.entry_abi = canon_abi,
-                    Err(_) => return Err(format!("{abi_str} is not a valid CanonAbi")),
-                }
-            } else {
-                incorrect_type.push("entry-abi".to_owned())
-            }
-        }
-
         key!(c_int_width = "target-c-int-width");
         key!(c_enum_min_bits, Option<u64>); // if None, matches c_int_width
         key!(os);
@@ -661,6 +652,21 @@ 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);
+
+        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(),
+                    Err(_) => return Err(format!("{abi_str} is not a valid ExternAbi")),
+                }
+            } else {
+                incorrect_type.push("entry-abi".to_owned())
+            }
+        }
+
         base.update_from_cli();
         base.check_consistency(TargetKind::Json)?;