Feat: started the skeleton for x86 module, added XML intrinsic parsing capabilities

Author: madhav-madhusoodanan

crates/intrinsic-test/Cargo.toml

@@ -22,3 +22,5 @@ pretty_env_logger = "0.5.0"
 rayon = "1.5.0"
 diff = "0.1.12"
 itertools = "0.14.0"
+quick-xml = { version = "0.37.5", features = ["serialize", "overlapped-lists"] }
+serde-xml-rs = "0.8.0"

crates/intrinsic-test/src/main.rs

@@ -3,10 +3,12 @@ extern crate log;
 
 mod arm;
 mod common;
+mod x86;
 
 use arm::ArmArchitectureTest;
 use common::SupportedArchitectureTest;
 use common::cli::{Cli, ProcessedCli};
+use x86::X86ArchitectureTest;
 
 fn main() {
     pretty_env_logger::init();
@@ -21,6 +23,8 @@ fn main() {
                 Some(ArmArchitectureTest::create(processed_cli_options))
             }
 
+            "x86_64-unknown-linux-gnu" => Some(X86ArchitectureTest::create(processed_cli_options)),
+
             _ => None,
         };
 

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

@@ -0,0 +1,37 @@
+use crate::common::argument::ArgumentList;
+use crate::common::indentation::Indentation;
+use crate::common::intrinsic::{Intrinsic, IntrinsicDefinition};
+use crate::common::intrinsic_helpers::IntrinsicType;
+use std::ops::Deref;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct X86IntrinsicType(pub IntrinsicType);
+
+impl Deref for X86IntrinsicType {
+    type Target = IntrinsicType;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl IntrinsicDefinition<X86IntrinsicType> for Intrinsic<X86IntrinsicType> {
+    fn arguments(&self) -> ArgumentList<X86IntrinsicType> {
+        self.arguments.clone()
+    }
+
+    fn results(&self) -> X86IntrinsicType {
+        self.results.clone()
+    }
+
+    fn name(&self) -> String {
+        self.name.clone()
+    }
+
+    /// Generates a std::cout for the intrinsics results that will match the
+    /// rust debug output format for the return type. The generated line assumes
+    /// there is an int i in scope which is the current pass number.
+    fn print_result_c(&self, _indentation: Indentation, _additional: &str) -> String {
+        todo!("print_result_c in Intrinsic<X86IntrinsicType> needs to be implemented!");
+    }
+}

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

@@ -0,0 +1,38 @@
+mod intrinsic;
+mod types;
+mod xml_parser;
+
+use crate::common::SupportedArchitectureTest;
+use crate::common::cli::ProcessedCli;
+use crate::common::intrinsic::Intrinsic;
+use intrinsic::X86IntrinsicType;
+use xml_parser::get_xml_intrinsics;
+
+pub struct X86ArchitectureTest {
+    intrinsics: Vec<Intrinsic<X86IntrinsicType>>,
+    cli_options: ProcessedCli,
+}
+
+impl SupportedArchitectureTest for X86ArchitectureTest {
+    fn create(cli_options: ProcessedCli) -> Box<Self> {
+        let intrinsics = get_xml_intrinsics(&cli_options.filename, &cli_options.target)
+            .expect("Error parsing input file");
+
+        Box::new(Self {
+            intrinsics: intrinsics,
+            cli_options: cli_options,
+        })
+    }
+
+    fn build_c_file(&self) -> bool {
+        todo!("build_c_file in X86ArchitectureTest is not implemented")
+    }
+
+    fn build_rust_file(&self) -> bool {
+        todo!("build_rust_file in X86ArchitectureTest is not implemented")
+    }
+
+    fn compare_outputs(&self) -> bool {
+        todo!("compare_outputs in X86ArchitectureTest is not implemented")
+    }
+}

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

@@ -0,0 +1,32 @@
+use super::intrinsic::X86IntrinsicType;
+use crate::common::cli::Language;
+use crate::common::intrinsic_helpers::IntrinsicTypeDefinition;
+
+impl IntrinsicTypeDefinition for X86IntrinsicType {
+    /// Gets a string containing the typename for this type in C format.
+    fn c_type(&self) -> String {
+        todo!("c_type for X86IntrinsicType needs to be implemented!");
+    }
+
+    fn c_single_vector_type(&self) -> String {
+        todo!("c_single_vector_type for X86IntrinsicType needs to be implemented!");
+    }
+
+    fn rust_type(&self) -> String {
+        todo!("rust_type for X86IntrinsicType needs to be implemented!");
+    }
+
+    /// Determines the load function for this type.
+    fn get_load_function(&self, language: Language) -> String {
+        todo!("get_load_function for X86IntrinsicType needs to be implemented!");
+    }
+
+    /// Determines the get lane function for this type.
+    fn get_lane_function(&self) -> String {
+        todo!("get_lane_function for X86IntrinsicType needs to be implemented!");
+    }
+
+    fn from_c(s: &str, target: &String) -> Result<Self, String> {
+        todo!("from_c for X86IntrinsicType needs to be implemented!");
+    }
+}

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

@@ -0,0 +1,104 @@
+use crate::common::{
+    argument::Argument, intrinsic::Intrinsic, intrinsic_helpers::IntrinsicTypeDefinition,
+};
+use serde::{Deserialize, Deserializer};
+use std::path::Path;
+
+use super::intrinsic::X86IntrinsicType;
+
+// Custom deserializer function to convert "TRUE"/"FALSE" strings to boolean
+fn string_to_bool<'de, D>(deserializer: D) -> Result<bool, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let s = String::deserialize(deserializer)?;
+    match s.as_str() {
+        "TRUE" => Ok(true),
+        "FALSE" => Ok(false),
+        _ => Ok(false), // Default to false for any other value
+    }
+}
+
+#[derive(Deserialize)]
+struct Data {
+    #[serde(rename = "intrinsic", default)]
+    intrinsics: Vec<XMLIntrinsic>,
+}
+
+#[derive(Deserialize)]
+struct XMLIntrinsic {
+    #[serde(rename = "return")]
+    return_data: Return,
+    #[serde(rename = "@name")]
+    name: String,
+    #[serde(rename = "@tech")]
+    tech: String,
+    #[serde(rename = "CPUID", default)]
+    cpuid: Vec<String>,
+    #[serde(rename = "parameter", default)]
+    parameters: Vec<Parameter>,
+    #[serde(rename = "@sequence", default, deserialize_with = "string_to_bool")]
+    generates_sequence: bool,
+    #[serde(default)]
+    instruction: Vec<Instruction>,
+}
+
+#[derive(Deserialize)]
+struct Parameter {
+    #[serde(rename = "@type")]
+    type_data: String,
+    #[serde(rename = "@etype", default)]
+    etype: String,
+}
+
+#[derive(Deserialize)]
+struct Return {
+    #[serde(rename = "@type", default)]
+    type_data: String,
+}
+
+#[derive(Deserialize, Debug)]
+struct Instruction {
+    #[serde(rename = "@name")]
+    name: String,
+}
+
+pub fn get_xml_intrinsics(
+    filename: &Path,
+    target: &String,
+) -> 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");
+
+    // println!("{} intrinsics found", data.intrinsics.len());
+    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!"))
+        })
+        .collect();
+
+    Ok(parsed_intrinsics)
+}
+
+pub fn xml_to_intrinsic(
+    mut intr: XMLIntrinsic,
+    target: &String,
+) -> Result<Intrinsic<X86IntrinsicType>, Box<dyn std::error::Error>> {
+    let name = intr.name;
+    let results = X86IntrinsicType::from_c(&intr.return_data.type_data, target)?;
+
+    let arguments: Vec<_> = intr
+        .parameters
+        .into_iter()
+        .enumerate()
+        .map(|(i, arg)| {
+            // let arg_name = Argument::<X86IntrinsicType>::type_and_name_from_c(&arg).1;
+        })
+        .collect();
+
+    todo!("xml_to_intrinsic needs to collect the arguments properly!");
+}