Auto merge of #141569 - workingjubilee:canonicalize-abi, r=<try>

Replace ad-hoc ABI "adjustments" with an `AbiMap` to `CanonAbi`

I am having second thoughts about some of my design choices, here, but I think it's useless to _internally_ debate them further.

r? `@ghost`

try-job: test-various
try-job: aarch64-apple
try-job: aarch64-gnu
try-job: armhf-gnu
try-job: x86_64-msvc-1
try-job: x86_64-msvc-2
try-job: x86_64-mingw-1
try-job: x86_64-mingw-2
try-job: i686-msvc-1
try-job: i686-msvc-2

Author: bors

Cargo.lock

@@ -3251,6 +3251,7 @@ dependencies = [
  "rustc_macros",
  "rustc_serialize",
  "rustc_span",
+ "serde_json",
  "tracing",
 ]
 

compiler/rustc_abi/Cargo.toml

@@ -14,6 +14,7 @@ rustc_index = { path = "../rustc_index", default-features = false }
 rustc_macros = { path = "../rustc_macros", optional = true }
 rustc_serialize = { path = "../rustc_serialize", optional = true }
 rustc_span = { path = "../rustc_span", optional = true }
+serde_json = "1"
 tracing = "0.1"
 # tidy-alphabetical-end
 

compiler/rustc_abi/src/canon_abi.rs

@@ -0,0 +1,236 @@
+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::{AbiFromStrErr, ExternAbi};
+
+/// Calling convention to determine codegen
+///
+/// CanonAbi erases certain distinctions ExternAbi preserves, but remains target-dependent.
+/// There are still both target-specific variants and aliasing variants, though much fewer.
+/// The reason for this step is the frontend may wish to show an ExternAbi but implement that ABI
+/// using a different ABI than the string per se, or describe irrelevant differences, e.g.
+/// - extern "system"
+/// - extern "cdecl"
+/// - extern "C-unwind"
+/// In that sense, this erases mere syntactic distinctions to create a canonical *directive*,
+/// rather than picking the "actual" ABI.
+#[derive(Copy, Clone, Debug)]
+pub enum CanonAbi {
+    // NOTE: the use of nested variants for some ABIs is for many targets they don't matter,
+    // and this pushes the complexity of their reasoning to target-specific code,
+    // allowing a `match` to easily exhaustively ignore these subcategories of variants.
+    // Otherwise it is very tempting to avoid matching exhaustively!
+    C,
+    Rust,
+    RustCold,
+
+    /// ABIs relevant to 32-bit Arm targets
+    Arm(ArmCall),
+    /// ABI relevant to GPUs: the entry point for a GPU kernel
+    GpuKernel,
+
+    /// ABIs relevant to bare-metal interrupt targets
+    // FIXME(workingjubilee): a particular reason for this nesting is we might not need these?
+    // interrupt ABIs should have the same properties:
+    // - uncallable by Rust calls, as LLVM rejects it in most cases
+    // - uses a preserve-all-registers *callee* convention
+    // - should always return `-> !` (effectively... it can't use normal `ret`)
+    // what differs between targets is
+    // - allowed arguments: x86 differs slightly, having 2-3 arguments which are handled magically
+    // - may need special prologues/epilogues for some interrupts, without affecting "call ABI"
+    Interrupt(InterruptKind),
+
+    /// ABIs relevant to Windows or x86 targets
+    X86(X86Call),
+}
+
+// For most "utility" impls, just forward CanonAbi to ExternAbi as it is notionally a subset
+impl Ord for CanonAbi {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.to_erased_extern_abi().cmp(&other.to_erased_extern_abi())
+    }
+}
+
+impl PartialOrd for CanonAbi {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(&other))
+    }
+}
+
+impl PartialEq for CanonAbi {
+    fn eq(&self, other: &Self) -> bool {
+        self.cmp(&other) == Ordering::Equal
+    }
+}
+
+impl Eq for CanonAbi {}
+
+impl Hash for CanonAbi {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.to_erased_extern_abi().hash(state)
+    }
+}
+
+// because we forward hashing to ExternAbi, also forward this:
+#[cfg(feature = "nightly")]
+impl<C> HashStable<C> for CanonAbi {
+    #[inline]
+    fn hash_stable(&self, _: &mut C, hasher: &mut StableHasher) {
+        Hash::hash(self, hasher);
+    }
+}
+
+#[cfg(feature = "nightly")]
+impl StableOrd for CanonAbi {
+    const CAN_USE_UNSTABLE_SORT: bool = true;
+
+    // because each ABI is hashed like a string, there is no possible instability
+    const THIS_IMPLEMENTATION_HAS_BEEN_TRIPLE_CHECKED: () = ();
+}
+
+impl fmt::Display for CanonAbi {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.to_erased_extern_abi().as_str().fmt(f)
+    }
+}
+
+impl CanonAbi {
+    /// convert to the ExternAbi that *shares a string* with this CanonAbi
+    ///
+    /// NOT correct to use if you want to map CanonAbi to an ABI it may have been lowered from,
+    /// but it is convenient for various "forwarding" implementations. Avoid exposing publicly!
+    const fn to_erased_extern_abi(self) -> ExternAbi {
+        match self {
+            CanonAbi::C => ExternAbi::C { unwind: false },
+            CanonAbi::Rust => ExternAbi::Rust,
+            CanonAbi::RustCold => ExternAbi::RustCold,
+            CanonAbi::Arm(arm_call) => match arm_call {
+                ArmCall::Aapcs => ExternAbi::Aapcs { unwind: false },
+                ArmCall::CCmseNonSecureCall => ExternAbi::CCmseNonSecureCall,
+                ArmCall::CCmseNonSecureEntry => ExternAbi::CCmseNonSecureEntry,
+            },
+            CanonAbi::GpuKernel => ExternAbi::GpuKernel,
+            CanonAbi::Interrupt(interrupt_kind) => match interrupt_kind {
+                InterruptKind::Avr => ExternAbi::AvrInterrupt,
+                InterruptKind::AvrNonBlocking => ExternAbi::AvrNonBlockingInterrupt,
+                InterruptKind::Msp430 => ExternAbi::Msp430Interrupt,
+                InterruptKind::RiscvMachine => ExternAbi::RiscvInterruptM,
+                InterruptKind::RiscvSupervisor => ExternAbi::RiscvInterruptS,
+                InterruptKind::X86 => ExternAbi::X86Interrupt,
+            },
+            CanonAbi::X86(x86_call) => match x86_call {
+                X86Call::Fastcall => ExternAbi::Fastcall { unwind: false },
+                X86Call::Stdcall => ExternAbi::Stdcall { unwind: false },
+                X86Call::SysV64 => ExternAbi::SysV64 { unwind: false },
+                X86Call::Thiscall => ExternAbi::Thiscall { unwind: false },
+                X86Call::Vectorcall => ExternAbi::Vectorcall { unwind: false },
+                X86Call::Win64 => ExternAbi::Win64 { unwind: false },
+            },
+        }
+    }
+
+    /// convert an ExternAbi to a CanonAbi if it maps directly
+    ///
+    /// Pretty incorrect to publicly expose!
+    const fn try_from_extern_abi(extern_abi: ExternAbi) -> Result<Self, AbiFromStrErr> {
+        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(AbiFromStrErr::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(AbiFromStrErr::NoUnwind),
+        }
+    }
+}
+
+impl FromStr for CanonAbi {
+    type Err = AbiFromStrErr;
+
+    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
+///
+/// This is named differently from the "Call" enums because it is different:
+/// these "ABI" differences are not relevant to callers, since there is "no caller".
+/// These only affect callee codegen. making their categorization as distinct ABIs a bit peculiar.
+#[derive(Copy, Clone, Debug)]
+pub enum InterruptKind {
+    Avr,
+    AvrNonBlocking,
+    Msp430,
+    RiscvMachine,
+    RiscvSupervisor,
+    X86,
+}
+
+/// ABIs defined for x86-{32,64}
+///
+/// One of SysV64 or Win64 may alias the C ABI, and arguably Win64 is cross-platform now?
+#[derive(Clone, Copy, Debug)]
+pub enum X86Call {
+    /// "fastcall" has both GNU and Windows variants
+    Fastcall,
+    /// "stdcall" has both GNU and Windows variants
+    Stdcall,
+    SysV64,
+    Thiscall,
+    Vectorcall,
+    Win64,
+}
+
+/// ABIs defined for 32-bit Arm
+#[derive(Copy, Clone, Debug)]
+pub enum ArmCall {
+    Aapcs,
+    CCmseNonSecureCall,
+    CCmseNonSecureEntry,
+}

compiler/rustc_abi/src/extern_abi.rs

@@ -7,6 +7,8 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableOrd};
 #[cfg(feature = "nightly")]
 use rustc_macros::{Decodable, Encodable};
 
+use crate::AbiFromStrErr;
+
 #[cfg(test)]
 mod tests;
 
@@ -99,11 +101,6 @@ macro_rules! abi_impls {
     }
 }
 
-#[derive(Debug)]
-pub enum AbiFromStrErr {
-    Unknown,
-}
-
 abi_impls! {
     ExternAbi = {
             C { unwind: false } =><= "C",

compiler/rustc_abi/src/lib.rs

@@ -55,17 +55,20 @@ use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_Generic};
 
 mod callconv;
+mod canon_abi;
+mod extern_abi;
 mod layout;
+mod map;
 #[cfg(test)]
 mod tests;
 
-mod extern_abi;
-
 pub use callconv::{Heterogeneous, HomogeneousAggregate, Reg, RegKind};
+pub use canon_abi::{ArmCall, CanonAbi, InterruptKind, X86Call};
 pub use extern_abi::{ExternAbi, all_names};
 #[cfg(feature = "nightly")]
 pub use layout::{FIRST_VARIANT, FieldIdx, Layout, TyAbiInterface, TyAndLayout, VariantIdx};
 pub use layout::{LayoutCalculator, LayoutCalculatorError};
+pub use map::{AbiMap, AbiNotNormal};
 
 /// Requirements for a `StableHashingContext` to be used in this crate.
 /// This is a hack to allow using the `HashStable_Generic` derive macro
@@ -1895,3 +1898,18 @@ pub enum StructKind {
     /// A univariant, but with a prefix of an arbitrary size & alignment (e.g., enum tag).
     Prefixed(Size, Align),
 }
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum AbiFromStrErr {
+    /// not a known ABI
+    Unknown,
+    /// no "-unwind" variant
+    NoUnwind,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum AbiFromJsonErr {
+    InvalidType,
+    UnusedKey,
+    Parse { kind: AbiFromStrErr, value: String },
+}