feat: added a skeletal structure for loongarch in intrinsic-test

Author: madhav-madhusoodanan

crates/intrinsic-test/Cargo.toml

@@ -19,3 +19,4 @@ pretty_env_logger = "0.5.0"
 rayon = "1.5.0"
 diff = "0.1.12"
 itertools = "0.14.0"
+regex = "1.11.1"

crates/intrinsic-test/src/loongarch/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, IntrinsicTypeDefinition, Sign, TypeKind};
+use std::ops::{Deref, DerefMut};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct LoongArchIntrinsicType(pub IntrinsicType);
+
+impl Deref for LoongArchIntrinsicType {
+    type Target = IntrinsicType;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for LoongArchIntrinsicType {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl IntrinsicDefinition<LoongArchIntrinsicType> for Intrinsic<LoongArchIntrinsicType> {
+    fn arguments(&self) -> ArgumentList<LoongArchIntrinsicType> {
+        self.arguments.clone()
+    }
+
+    fn results(&self) -> LoongArchIntrinsicType {
+        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 {
+        unimplemented!("print_result_c of IntrinsicDefinition<LoongArchIntrinsicType> is not defined!")
+    }
+}

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

@@ -0,0 +1,50 @@
+mod intrinsic;
+mod types;
+
+use std::fs::{self, File};
+
+use rayon::prelude::*;
+
+use crate::common::SupportedArchitectureTest;
+use crate::common::cli::ProcessedCli;
+use crate::common::compare::compare_outputs;
+
+use crate::common::intrinsic::Intrinsic;
+use intrinsic::LoongArchIntrinsicType;
+
+pub struct LoongArchArchitectureTest {
+    intrinsics: Vec<Intrinsic<LoongArchIntrinsicType>>,
+    cli_options: ProcessedCli,
+}
+
+impl SupportedArchitectureTest for LoongArchArchitectureTest {
+    fn create(cli_options: ProcessedCli) -> Box<Self> {
+        unimplemented!("create of LoongArchIntrinsicType is not defined!")
+    }
+
+    fn build_c_file(&self) -> bool {
+        unimplemented!("build_c_file of LoongArchIntrinsicType is not defined!")
+    }
+
+    fn build_rust_file(&self) -> bool {
+        unimplemented!("build_rust_file of LoongArchIntrinsicType is not defined!")
+    }
+
+    fn compare_outputs(&self) -> bool {
+        if self.cli_options.toolchain.is_some() {
+            let intrinsics_name_list = self
+                .intrinsics
+                .iter()
+                .map(|i| i.name.clone())
+                .collect::<Vec<_>>();
+
+            compare_outputs(
+                &intrinsics_name_list,
+                &self.cli_options.runner,
+                &self.cli_options.target,
+            )
+        } else {
+            true
+        }
+    }
+}

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

@@ -0,0 +1,93 @@
+use super::intrinsic::LoongArchIntrinsicType;
+use crate::common::cli::Language;
+use crate::common::intrinsic_helpers::IntrinsicTypeDefinition;
+
+impl IntrinsicTypeDefinition for LoongArchIntrinsicType {
+    /// 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 {
+        unimplemented!("c_type for LoongArchIntrinsicType is not implemented!")
+    }
+
+    fn c_single_vector_type(&self) -> String {
+        unimplemented!("c_single_vector_type for LoongArchIntrinsicType is not implemented!")
+    }
+
+    // fn rust_type(&self) -> String {
+    //     // handling edge cases first
+    //     // the general handling is implemented below
+    //     if let Some(val) = self.metadata.get("type") {
+    //         match val.as_str() {
+    //             "__m128 const *" => {
+    //                 return "&__m128".to_string();
+    //             }
+    //             "__m128d const *" => {
+    //                 return "&__m128d".to_string();
+    //             }
+    //             "const void*" => {
+    //                 return "&__m128d".to_string();
+    //             }
+    //             _ => {}
+    //         }
+    //     }
+
+    //     if self.kind() == TypeKind::Void && self.ptr {
+    //         // this has been handled by default settings in
+    //         // the from_param function of X86IntrinsicType
+    //         unreachable!()
+    //     }
+
+    //     // general handling cases
+    //     let core_part = if self.kind() == TypeKind::Mask {
+    //         // all types of __mmask<int> are handled here
+    //         format!("__mask{}", self.bit_len.unwrap())
+    //     } else if self.simd_len.is_some() {
+    //         // all types of __m<int> vector types are handled here
+    //         let re = Regex::new(r"\__m\d+[a-z]*").unwrap();
+    //         let rust_type = self
+    //             .metadata
+    //             .get("type")
+    //             .map(|val| re.find(val).unwrap().as_str());
+    //         rust_type.unwrap().to_string()
+    //     } else {
+    //         format!(
+    //             "{}{}",
+    //             self.kind.rust_prefix().to_string(),
+    //             self.bit_len.unwrap()
+    //         )
+    //     };
+
+    //     // extracting "memsize" so that even vector types can be involved
+    //     let memwidth = self
+    //         .metadata
+    //         .get("memwidth")
+    //         .map(|n| str::parse::<u32>(n).unwrap());
+    //     let prefix_part = if self.ptr && self.constant && self.bit_len.eq(&memwidth) {
+    //         "&"
+    //     } else if self.ptr && self.bit_len.eq(&memwidth) {
+    //         "&mut "
+    //     } else if self.ptr && self.constant {
+    //         "*const "
+    //     } else if self.ptr {
+    //         "*mut "
+    //     } else {
+    //         ""
+    //     };
+
+    //     return prefix_part.to_string() + core_part.as_str();
+    // }
+
+    /// Determines the load function for this type.
+    fn get_load_function(&self, _language: Language) -> String {
+        unimplemented!("get_load_function for LoongArchIntrinsicType is not implemented!")
+    }
+
+    /// Determines the get lane function for this type.
+    fn get_lane_function(&self) -> String {
+        todo!("get_lane_function for LoongArchIntrinsicType needs to be implemented!");
+    }
+
+    fn from_c(s: &str, target: &str) -> Result<Self, String> {
+        todo!("from_c for LoongArchIntrinsicType needs to be implemented!");
+    }
+}

crates/intrinsic-test/src/main.rs

@@ -3,8 +3,11 @@ extern crate log;
 
 mod arm;
 mod common;
+mod loongarch;
 
 use arm::ArmArchitectureTest;
+use loongarch::LoongArchArchitectureTest;
+
 use common::SupportedArchitectureTest;
 use common::cli::{Cli, ProcessedCli};
 
@@ -21,6 +24,7 @@ fn main() {
                 Some(ArmArchitectureTest::create(processed_cli_options))
             }
 
+            "loongarch64-unknown-linux-gnu" => Some(LoongArchArchitectureTest::create(processed_cli_options)),
             _ => None,
         };