compiler: implement AbiMap errors

Author: workingjubilee

compiler/rustc_abi/src/lib.rs

@@ -1899,17 +1899,17 @@ pub enum StructKind {
     Prefixed(Size, Align),
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum AbiFromStrErr {
     /// not a known ABI
     Unknown,
     /// no "-unwind" variant
     NoUnwind,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum AbiFromJsonErr {
     InvalidType,
     UnusedKey,
-    Parse(AbiFromStrErr),
+    Parse { kind: AbiFromStrErr, value: String },
 }

compiler/rustc_abi/src/map.rs

@@ -215,7 +215,9 @@ fn extract_abi_str(
     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)))
+                abi_str.parse().map_err(|err| {
+                    (key_string, AbiFromJsonErr::Parse { kind: err, value: abi_str })
+                })
             } else {
                 Err((key_string, AbiFromJsonErr::InvalidType))
             }

compiler/rustc_target/src/spec/json.rs

@@ -2,6 +2,7 @@ use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::str::FromStr;
 
+use rustc_abi::{AbiFromJsonErr, AbiFromStrErr};
 use serde_json::Value;
 
 use super::{Target, TargetKind, TargetOptions, TargetWarnings};
@@ -56,6 +57,47 @@ impl Target {
         }
 
         let mut incorrect_type = vec![];
+        let mut unused_fields = vec![];
+        let mut bad_kv = vec![];
+
+        match obj.remove("abi-map") {
+            Some(Json::Object(object)) => match rustc_abi::AbiMap::from_json_object(object) {
+                Ok(abi_map) => base.options.abi_map = abi_map,
+                Err(error_map) => {
+                    for (key, error) in error_map {
+                        match error {
+                            AbiFromJsonErr::InvalidType => {
+                                incorrect_type.push(["abi-map", &key].join("."))
+                            }
+                            AbiFromJsonErr::UnusedKey => {
+                                unused_fields.push(["abi-map", &key].join("."))
+                            }
+                            AbiFromJsonErr::Parse { kind, value } => bad_kv.push((
+                                ["abi-map", &key].join("."),
+                                match kind {
+                                    AbiFromStrErr::Unknown => {
+                                        format!("{value} is not a valid CanonAbi")
+                                    }
+                                    AbiFromStrErr::NoUnwind => {
+                                        format!("{value} must not be -unwind")
+                                    }
+                                },
+                            )),
+                        }
+                    }
+                }
+            },
+            Some(_) => incorrect_type.push("abi-map".to_owned()),
+            None => (),
+        };
+
+        if bad_kv.len() > 0 {
+            let err = bad_kv
+                .into_iter()
+                .map(|(key, err)| format!("invalid {key}: {err}\n"))
+                .collect::<String>();
+            return Err(err);
+        }
 
         macro_rules! key {
             ($key_name:ident) => ( {
@@ -546,7 +588,6 @@ impl Target {
                 incorrect_type.push("frame-pointer".into())
             }
         }
-
         key!(c_int_width = "target-c-int-width");
         key!(c_enum_min_bits, Option<u64>); // if None, matches c_int_width
         key!(os);
@@ -667,11 +708,9 @@ impl Target {
         base.check_consistency(TargetKind::Json)?;
 
         // Each field should have been read using `Json::remove` so any keys remaining are unused.
-        let remaining_keys = obj.keys();
-        Ok((
-            base,
-            TargetWarnings { unused_fields: remaining_keys.cloned().collect(), incorrect_type },
-        ))
+        unused_fields.extend(obj.keys().cloned());
+
+        Ok((base, TargetWarnings { unused_fields, incorrect_type }))
     }
 }
 

compiler/rustc_target/src/spec/mod.rs

@@ -43,7 +43,7 @@ use std::str::FromStr;
 use std::{fmt, io};
 
 use rustc_abi::{
-    Align, Endian, ExternAbi, Integer, Size, TargetDataLayout, TargetDataLayoutErrors,
+    AbiMap, Align, Endian, ExternAbi, Integer, Size, TargetDataLayout, TargetDataLayoutErrors,
 };
 use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_fs_util::try_canonicalize;
@@ -2274,6 +2274,8 @@ type StaticCow<T> = Cow<'static, T>;
 /// through `Deref` impls.
 #[derive(PartialEq, Clone, Debug)]
 pub struct TargetOptions {
+    /// map of ABIs that are supported and mapped
+    pub 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".
@@ -2773,6 +2775,7 @@ impl Default for TargetOptions {
     /// incomplete, and if used for compilation, will certainly not work.
     fn default() -> TargetOptions {
         TargetOptions {
+            abi_map: AbiMap::default(),
             endian: Endian::Little,
             c_int_width: "32".into(),
             os: "none".into(),