feat: added the XML intrinsic parser for x86

Author: madhav-madhusoodanan

crates/intrinsic-test/src/x86/constraint.rs

@@ -0,0 +1,20 @@
+use crate::common::constraint::Constraint;
+
+pub fn map_constraints(imm_type: &String) -> Option<Constraint> {
+    match imm_type.as_str() {
+        "_MM_FROUND" => Some(Constraint::Range(0..4)),
+        "_MM_INDEX_SCALE" => Some(Constraint::Set(vec![1, 2, 4, 8])),
+        "_MM_CMPINT" => Some(Constraint::Range(0..8)),
+        "_MM_REDUCE" => Some(Constraint::Range(0..8)),
+        "_MM_FROUND_SAE" => Some(Constraint::Range(0..8)),
+        "_MM_MANTISSA_NORM" => Some(Constraint::Range(0..4)),
+        "_MM_MANTISSA_NORM_ENUM" => Some(Constraint::Range(0..4)),
+        "_MM_MANTISSA_SIGN" => Some(Constraint::Range(0..3)),
+        "_MM_PERM" => Some(Constraint::Range(0..256)),
+        "_MM_PERM_ENUM" => Some(Constraint::Range(0..256)),
+        "_MM_CMPINT_ENUM" => Some(Constraint::Range(0..8)),
+        "_MM_ROUND_MODE" => Some(Constraint::Set(vec![0, 0x2000, 0x4000, 0x6000])),
+        "_CMP_" => Some(Constraint::Range(0..32)),
+        _ => None,
+    }
+}

crates/intrinsic-test/src/x86/mod.rs

@@ -1,3 +1,4 @@
+mod constraint;
 mod intrinsic;
 mod types;
 mod xml_parser;

crates/intrinsic-test/src/x86/xml_parser.rs

@@ -1,5 +1,12 @@
+use crate::common::argument::{Argument, ArgumentList};
+use crate::common::intrinsic::Intrinsic;
+use crate::common::intrinsic_helpers::TypeKind;
+use crate::x86::constraint::map_constraints;
+
 use serde::{Deserialize, Deserializer};
+use std::path::Path;
 
+use super::intrinsic::X86IntrinsicType;
 
 // Custom deserializer function to convert strings to u32
 fn string_to_u32<'de, D>(deserializer: D) -> Result<u32, D::Error>
@@ -43,3 +50,66 @@ pub struct Parameter {
     #[serde(rename = "@immtype", default)]
     pub imm_type: String,
 }
+
+pub fn get_xml_intrinsics(
+    filename: &Path,
+) -> Result<Vec<Intrinsic<X86IntrinsicType>>, Box<dyn std::error::Error>> {
+    let file = std::fs::File::open(filename)?;
+    let reader = std::io::BufReader::new(file);
+    let data: Data =
+        quick_xml::de::from_reader(reader).expect("failed to deserialize the source XML file");
+
+    let parsed_intrinsics: Vec<Intrinsic<X86IntrinsicType>> = data
+        .intrinsics
+        .into_iter()
+        .filter_map(|intr| {
+            // Some(xml_to_intrinsic(intr, target).expect("Couldn't parse XML properly!"))
+            xml_to_intrinsic(intr).ok()
+        })
+        .collect();
+
+    Ok(parsed_intrinsics)
+}
+
+fn xml_to_intrinsic(
+    intr: XMLIntrinsic,
+) -> Result<Intrinsic<X86IntrinsicType>, Box<dyn std::error::Error>> {
+    let name = intr.name;
+    let result = X86IntrinsicType::from_param(&intr.return_data);
+    let args_check = intr.parameters.into_iter().enumerate().map(|(i, param)| {
+        let ty = X86IntrinsicType::from_param(&param);
+        if ty.is_err() {
+            None
+        } else {
+            let constraint = map_constraints(&param.imm_type);
+            let arg = Argument::<X86IntrinsicType>::new(
+                i,
+                param.var_name.clone(),
+                ty.unwrap(),
+                constraint,
+            );
+            Some(arg)
+        }
+    });
+
+    let args = args_check.collect::<Vec<_>>();
+    if args.iter().any(|elem| elem.is_none()) {
+        return Err(Box::from("intrinsic isn't fully supported in this test!"));
+    }
+    let args = args
+        .into_iter()
+        .map(|e| e.unwrap())
+        .filter(|arg| arg.ty.ptr || arg.ty.kind != TypeKind::Void)
+        .collect::<Vec<_>>();
+    let arguments = ArgumentList::<X86IntrinsicType> { args };
+
+    if let Err(message) = result {
+        return Err(Box::from(message));
+    }
+    Ok(Intrinsic {
+        name,
+        arguments,
+        results: result.unwrap(),
+        arch_tags: intr.cpuid,
+    })
+}