add AbiMap

Author: workingjubilee

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/lib.rs

@@ -58,6 +58,7 @@ mod callconv;
 mod canon_abi;
 mod extern_abi;
 mod layout;
+mod map;
 #[cfg(test)]
 mod tests;
 
@@ -67,6 +68,7 @@ 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
@@ -1904,3 +1906,10 @@ pub enum AbiFromStrErr {
     /// no "-unwind" variant
     NoUnwind,
 }
+
+#[derive(Clone, Debug)]
+pub enum AbiFromJsonErr {
+    InvalidType,
+    UnusedKey,
+    Parse(AbiFromStrErr),
+}

compiler/rustc_abi/src/map.rs

@@ -0,0 +1,336 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use serde_json::Value as JsonValue;
+
+use crate::{AbiFromJsonErr, ArmCall, CanonAbi, ExternAbi, InterruptKind};
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct AbiMap {
+    /// a target may support ABIs that are "proper names" for the C ABI, otherwise this is "C"
+    pub c_proper: CanonAbi,
+
+    // required ABIs
+    pub system: CanonAbi,
+    pub system_varargs: CanonAbi,
+    /// ABI used for `extern "rust-cold"`
+    pub rust_cold: CanonAbi,
+
+    // optional abstract ABIs
+    pub efiapi: Option<CanonAbi>,
+    pub stdcall: Option<CanonAbi>,
+    pub fastcall: Option<CanonAbi>,
+    pub thiscall: Option<CanonAbi>,
+    pub vectorcall: Option<CanonAbi>,
+    pub win64: Option<CanonAbi>,
+    pub sysv64: Option<CanonAbi>,
+
+    // optional concrete ABIs
+    // arm
+    pub aapcs: bool,
+    pub cmse_nonsecure_entry: bool,
+    // gpu
+    pub gpu_kernel: bool,
+    pub ptx_kernel: bool,
+    // interrupt
+    pub avr_interrupt: bool,
+    pub msp430_interrupt: bool,
+    pub riscv_interrupt: bool,
+    pub x86_interrupt: bool,
+}
+
+// usually the reasonable default, but pay attention to system
+impl Default for AbiMap {
+    fn default() -> AbiMap {
+        let c = CanonAbi::C;
+        let rust_cold = CanonAbi::RustCold;
+        AbiMap {
+            c_proper: c,
+            system: c,
+            system_varargs: c,
+            rust_cold,
+
+            // some mercifully either map or don't
+            // arm
+            aapcs: false,
+            cmse_nonsecure_entry: false,
+            // gpu
+            gpu_kernel: false,
+            ptx_kernel: false,
+            // interrupt
+            avr_interrupt: false,
+            msp430_interrupt: false,
+            riscv_interrupt: false,
+            x86_interrupt: false,
+
+            // x86ish ones lack a mapping by default, but have many
+            efiapi: None,
+            fastcall: None,
+            stdcall: None,
+            sysv64: None,
+            thiscall: None,
+            vectorcall: None,
+            win64: None,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum AbiNotNormal {
+    CannotVarargs,
+    NotSupported,
+}
+
+impl AbiMap {
+    /// transform an ExternAbi to a CanonAbi, depending on its vararg usage
+    pub fn normalize_abi(
+        &self,
+        abi: ExternAbi,
+        has_c_varargs: bool,
+    ) -> Result<CanonAbi, AbiNotNormal> {
+        // because of feature(extern_system_varargs)
+        if has_c_varargs && !abi.supports_varargs() && !matches!(abi, ExternAbi::System { .. }) {
+            return Err(AbiNotNormal::CannotVarargs);
+        };
+        let option = match abi {
+            // An ExternAbi is either
+            // - "universal" or "optional" in their platform support
+            // - "invariant" or "varying" in normalization to CanonAbi
+
+            // universal, invariant
+            ExternAbi::C { unwind: _ } | ExternAbi::Cdecl { unwind: _ } => Some(CanonAbi::C),
+            ExternAbi::Rust => Some(CanonAbi::Rust),
+            ExternAbi::RustCall => Some(CanonAbi::Rust),
+            ExternAbi::Unadjusted => Some(CanonAbi::C),
+
+            // universal, varying
+            ExternAbi::RustCold => Some(self.rust_cold),
+            ExternAbi::System { unwind: _ } => {
+                Some(if has_c_varargs { self.system_varargs } else { self.system })
+            }
+
+            // optional, varying
+            ExternAbi::EfiApi => self.efiapi,
+            ExternAbi::Stdcall { unwind: _ } => self.stdcall,
+            ExternAbi::Fastcall { unwind: _ } => self.fastcall,
+            ExternAbi::Vectorcall { unwind: _ } => self.vectorcall,
+            ExternAbi::Thiscall { unwind: _ } => self.thiscall,
+            ExternAbi::Win64 { unwind: _ } => self.win64,
+            ExternAbi::SysV64 { unwind: _ } => self.sysv64,
+
+            // optional, invariant
+            // arm (aarch32)
+            ExternAbi::Aapcs { unwind: _ } => self.aapcs.then_some(CanonAbi::Arm(ArmCall::Aapcs)),
+            ExternAbi::CCmseNonSecureCall => {
+                self.cmse_nonsecure_entry.then_some(CanonAbi::Arm(ArmCall::CCmseNonSecureCall))
+            }
+            ExternAbi::CCmseNonSecureEntry => {
+                self.cmse_nonsecure_entry.then_some(CanonAbi::Arm(ArmCall::CCmseNonSecureEntry))
+            }
+
+            // gpu
+            ExternAbi::PtxKernel => self.ptx_kernel.then_some(CanonAbi::GpuKernel),
+            ExternAbi::GpuKernel => self.gpu_kernel.then_some(CanonAbi::GpuKernel),
+
+            // interrupt
+            ExternAbi::AvrInterrupt => {
+                self.avr_interrupt.then_some(CanonAbi::Interrupt(InterruptKind::Avr))
+            }
+            ExternAbi::AvrNonBlockingInterrupt => {
+                self.avr_interrupt.then_some(CanonAbi::Interrupt(InterruptKind::AvrNonBlocking))
+            }
+            ExternAbi::Msp430Interrupt => {
+                self.msp430_interrupt.then_some(CanonAbi::Interrupt(InterruptKind::Msp430))
+            }
+            ExternAbi::RiscvInterruptM => {
+                self.riscv_interrupt.then_some(CanonAbi::Interrupt(InterruptKind::RiscvMachine))
+            }
+            ExternAbi::RiscvInterruptS => {
+                self.riscv_interrupt.then_some(CanonAbi::Interrupt(InterruptKind::RiscvSupervisor))
+            }
+            ExternAbi::X86Interrupt => {
+                self.x86_interrupt.then_some(CanonAbi::Interrupt(InterruptKind::X86))
+            }
+        };
+        option.ok_or_else(|| AbiNotNormal::NotSupported)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct AbiKey {
+    abi: ExternAbi,
+    has_c_varargs: bool,
+}
+
+impl AbiMap {
+    /// map of ExternAbi + has_c_varargs to CanonAbi
+    // "why not use this as the internal representation of AbiMap?"
+    // see those ABIs that are only a bool to determine how they lower from ExternAbi?
+    // yeah, let's not give up that property for no reason.
+    // it is, however, admittedly easier to work with this
+    fn to_btree_map(&self) -> BTreeMap<AbiKey, CanonAbi> {
+        ExternAbi::ALL_VARIANTS
+            .iter()
+            .flat_map(|&abi| {
+                [AbiKey { abi, has_c_varargs: false }, AbiKey { abi, has_c_varargs: true }]
+            })
+            .filter_map(|AbiKey { abi, has_c_varargs }| {
+                let normalized_abi = self.normalize_abi(abi, has_c_varargs).ok()?;
+                Some((AbiKey { abi, has_c_varargs }, normalized_abi))
+            })
+            .collect()
+    }
+
+    /// map of CanonAbi to all codegen-equivalent ExternAbi
+    pub fn to_denormalizing_map(&self) -> BTreeMap<CanonAbi, BTreeSet<AbiKey>> {
+        let extern_to_canon = self.to_btree_map();
+        let mut canon_to_extern = BTreeMap::new();
+        for (extern_abi_with_varargs, canon_abi) in extern_to_canon {
+            canon_to_extern
+                .entry(canon_abi)
+                .or_insert(BTreeSet::new())
+                .insert(extern_abi_with_varargs);
+        }
+        let all_c: BTreeSet<_> = canon_to_extern[&self.c_proper]
+            .union(&canon_to_extern[&CanonAbi::C])
+            .cloned()
+            .collect();
+        if let Some(abi_set) = canon_to_extern.get_mut(&self.c_proper) {
+            abi_set.extend(all_c.clone())
+        };
+        if let Some(abi_set) = canon_to_extern.get_mut(&CanonAbi::C) {
+            abi_set.extend(all_c.clone())
+        };
+        canon_to_extern
+    }
+}
+
+// deserialization
+
+type JsonObject = serde_json::Map<String, JsonValue>;
+
+fn extract_abi_str(
+    json: &mut JsonObject,
+    s: &str,
+) -> Result<Option<CanonAbi>, (String, AbiFromJsonErr)> {
+    json.remove_entry(s)
+        .map(|(key_string, abi_str)| {
+            if let JsonValue::String(abi_str) = abi_str {
+                abi_str.parse().map_err(|err| (key_string, AbiFromJsonErr::Parse(err)))
+            } else {
+                Err((key_string, AbiFromJsonErr::InvalidType))
+            }
+        })
+        .transpose()
+}
+
+fn extract_bool_abi(
+    json: &mut JsonObject,
+    s: &str,
+) -> Result<Option<bool>, (String, AbiFromJsonErr)> {
+    json.remove_entry(s)
+        .map(|(key_string, boolean)| {
+            if let JsonValue::Bool(boolean) = boolean {
+                Ok(boolean)
+            } else {
+                Err((key_string, AbiFromJsonErr::InvalidType))
+            }
+        })
+        .transpose()
+}
+
+impl AbiMap {
+    pub fn from_json_object(
+        mut json: JsonObject,
+    ) -> Result<Self, BTreeMap<String, AbiFromJsonErr>> {
+        // extract all keys we are interested in
+        let required_c_abis =
+            ["C", "system", "system-varargs"].map(|abi_str| extract_abi_str(&mut json, abi_str));
+        let rust_cold = extract_abi_str(&mut json, "rust-cold");
+        let bool_abis = [
+            // arm...
+            "aapcs",
+            "cmse-nonsecure-entry",
+            // ...gpu...
+            "gpu-kernel",
+            "ptx-kernel",
+            // ...interrupt
+            "avr-interrupt",
+            "msp430-interrupt",
+            "riscv-interrupt",
+            "x86-interrupt",
+        ]
+        .map(|abi_str| extract_bool_abi(&mut json, abi_str));
+        // x86ish
+        let optional_abis =
+            ["efiapi", "stdcall", "fastcall", "thiscall", "vectorcall", "win64", "sysv64"]
+                .map(|abi_str| extract_abi_str(&mut json, abi_str));
+
+        // accumulate errors
+        // create an iterator of invalid types and bad parses
+        let errs = required_c_abis
+            .iter()
+            .filter_map(|result| result.as_ref().err())
+            .chain(rust_cold.as_ref().err())
+            .chain(bool_abis.iter().filter_map(|result| result.as_ref().err()))
+            .chain(optional_abis.iter().filter_map(|result| result.as_ref().err()));
+        // consume the JSON object...
+        let error_map = json
+            .into_iter()
+            // ...because any remaining keys are unused
+            .map(|(key_string, _value)| (key_string, AbiFromJsonErr::UnusedKey))
+            .chain(errs.cloned())
+            .collect::<BTreeMap<_, _>>();
+
+        if error_map.len() > 0 {
+            Err(error_map)
+        } else {
+            // oh? success? merry giftmas! time to unwrap your presents
+            // these have default ABIs to select
+            let [c_proper, system, system_varargs] =
+                required_c_abis.map(|result| result.unwrap().unwrap_or(CanonAbi::C));
+            let rust_cold = rust_cold.unwrap().unwrap_or(CanonAbi::RustCold);
+
+            // these stay options, but shell the Result
+            let [efiapi, stdcall, fastcall, thiscall, vectorcall, win64, sysv64] =
+                optional_abis.map(|result| result.unwrap());
+
+            // these simplify to booleans
+            let bool_abis = bool_abis.map(|result| result.unwrap().unwrap_or(false));
+            // repeat the mantra: arm...
+            let [aapcs, cmse_nonsecure_entry, bool_abis @ ..] = bool_abis;
+            // ...gpu...
+            let [gpu_kernel, ptx_kernel, bool_abis @ ..] = bool_abis;
+            // ...interrupt
+            let [avr_interrupt, msp430_interrupt, riscv_interrupt, x86_interrupt] = bool_abis;
+            Ok(AbiMap {
+                c_proper,
+                system,
+                system_varargs,
+                rust_cold,
+
+                // arm...
+                aapcs,
+                cmse_nonsecure_entry,
+
+                // ...gpu...
+                gpu_kernel,
+                ptx_kernel,
+
+                // ...interrupt
+                avr_interrupt,
+                msp430_interrupt,
+                riscv_interrupt,
+                x86_interrupt,
+
+                // x86-ish
+                efiapi,
+                stdcall,
+                fastcall,
+                thiscall,
+                vectorcall,
+                win64,
+                sysv64,
+            })
+        }
+    }
+}