feat: added the skeleton structure of the x86 module

Author: madhav-madhusoodanan

crates/intrinsic-test/Cargo.toml

@@ -19,3 +19,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();
@@ -20,6 +22,8 @@ fn main() {
             | "aarch64_be-unknown-linux-gnu" => {
                 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,43 @@
+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, DerefMut};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct X86IntrinsicType(pub IntrinsicType);
+
+impl Deref for X86IntrinsicType {
+    type Target = IntrinsicType;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for X86IntrinsicType {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut 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,31 @@
+mod intrinsic;
+mod types;
+mod xml_parser;
+
+use crate::common::SupportedArchitectureTest;
+use crate::common::cli::ProcessedCli;
+use crate::common::intrinsic::Intrinsic;
+use intrinsic::X86IntrinsicType;
+
+pub struct X86ArchitectureTest {
+    intrinsics: Vec<Intrinsic<X86IntrinsicType>>,
+    cli_options: ProcessedCli,
+}
+
+impl SupportedArchitectureTest for X86ArchitectureTest {
+    fn create(cli_options: ProcessedCli) -> Box<Self> {
+        todo!("create in X86ArchitectureTest is not implemented")
+    }
+
+    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,37 @@
+use super::intrinsic::X86IntrinsicType;
+use crate::common::cli::Language;
+use crate::common::intrinsic_helpers::IntrinsicTypeDefinition;
+use crate::x86::xml_parser::Parameter;
+
+impl IntrinsicTypeDefinition for X86IntrinsicType {
+    /// Gets a string containing the type in C format.
+    /// This function assumes that this value is present in the metadata hashmap.
+    fn c_type(&self) -> String {
+        todo!("c_type from IntrinsicTypeDefinition is not defined!")
+    }
+
+    fn c_single_vector_type(&self) -> String {
+        // matches __m128, __m256 and similar types
+        todo!("c_type from IntrinsicTypeDefinition is not defined!")
+    }
+
+    /// Determines the load function for this type.
+    fn get_load_function(&self, _language: Language) -> String {
+        todo!("get_load_function from IntrinsicTypeDefinition is not defined!")
+    }
+
+    /// 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: &str) -> Result<Self, String> {
+        todo!("from_c from IntrinsicTypeDefinition is not defined!")
+    }
+}
+
+impl X86IntrinsicType {
+    pub fn from_param(param: &Parameter) -> Result<Self, String> {
+        todo!("from_param from X86IntrinsicType is not defined!")
+    }
+}

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

@@ -0,0 +1,45 @@
+use serde::{Deserialize, Deserializer};
+
+
+// Custom deserializer function to convert strings to u32
+fn string_to_u32<'de, D>(deserializer: D) -> Result<u32, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let s = String::deserialize(deserializer)?;
+    return s.as_str().parse::<u32>().or(Ok(0u32));
+}
+
+#[derive(Deserialize)]
+struct Data {
+    #[serde(rename = "intrinsic", default)]
+    intrinsics: Vec<XMLIntrinsic>,
+}
+
+#[derive(Deserialize)]
+struct XMLIntrinsic {
+    #[serde(rename = "return")]
+    return_data: Parameter,
+    #[serde(rename = "@name")]
+    name: String,
+    // #[serde(rename = "@tech")]
+    // tech: String,
+    #[serde(rename = "CPUID", default)]
+    cpuid: Vec<String>,
+    #[serde(rename = "parameter", default)]
+    parameters: Vec<Parameter>,
+}
+
+#[derive(Deserialize)]
+pub struct Parameter {
+    #[serde(rename = "@varname")]
+    pub var_name: String,
+    #[serde(rename = "@type")]
+    pub type_data: String,
+    #[serde(rename = "@etype", default)]
+    pub etype: String,
+    #[serde(rename = "@memwidth", default, deserialize_with = "string_to_u32")]
+    pub memwidth: u32,
+    #[serde(rename = "@immtype", default)]
+    pub imm_type: String,
+}