feat: casting the results of the lane function by preserving the bits

instead of letting C++ do it (and potentially change the bits)

Author: madhav-madhusoodanan

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

@@ -112,12 +112,10 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                         ty = self.c_single_vector_type(),
                         lanes = (0..self.num_lanes())
                             .map(move |idx| -> std::string::String {
+                                let lane_fn = self.get_lane_function();
+                                let final_cast = self.generate_final_type_cast();
                                 format!(
-                                    "{cast}{lane_fn}(__return_value.val[{vector}], {lane})",
-                                    cast = self.c_promotion(),
-                                    lane_fn = self.get_lane_function(),
-                                    lane = idx,
-                                    vector = vector,
+                                    "{final_cast}{lane_fn}(__return_value.val[{vector}], {idx})"
                                 )
                             })
                             .collect::<Vec<_>>()
@@ -129,12 +127,9 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
         } else if self.num_lanes() > 1 {
             (0..self.num_lanes())
                 .map(|idx| -> std::string::String {
-                    format!(
-                        "{cast}{lane_fn}(__return_value, {lane})",
-                        cast = self.c_promotion(),
-                        lane_fn = self.get_lane_function(),
-                        lane = idx
-                    )
+                    let lane_fn = self.get_lane_function();
+                    let final_cast = self.generate_final_type_cast();
+                    format!("{final_cast}{lane_fn}(__return_value, {idx})")
                 })
                 .collect::<Vec<_>>()
                 .join(r#" << ", " << "#)
@@ -150,7 +145,7 @@ impl IntrinsicTypeDefinition for ArmIntrinsicType {
                     TypeKind::Poly => format!("poly{}_t", self.inner_size()),
                     ty => todo!("print_result_c - Unknown type: {:#?}", ty),
                 },
-                promote = self.c_promotion(),
+                promote = self.generate_final_type_cast(),
             )
         };
 

crates/intrinsic-test/src/common/intrinsic_helpers.rs

@@ -173,9 +173,9 @@ impl IntrinsicType {
                 bit_len: Some(8),
                 ..
             } => match kind {
-                TypeKind::Int(Sign::Signed) => "(int)",
-                TypeKind::Int(Sign::Unsigned) => "(unsigned int)",
-                TypeKind::Poly => "(unsigned int)(uint8_t)",
+                TypeKind::Int(Sign::Signed) => "int",
+                TypeKind::Int(Sign::Unsigned) => "unsigned int",
+                TypeKind::Poly => "uint8_t",
                 _ => "",
             },
             IntrinsicType {
@@ -184,9 +184,9 @@ impl IntrinsicType {
                 ..
             } => match bit_len {
                 8 => unreachable!("handled above"),
-                16 => "(uint16_t)",
-                32 => "(uint32_t)",
-                64 => "(uint64_t)",
+                16 => "uint16_t",
+                32 => "uint32_t",
+                64 => "uint64_t",
                 128 => "",
                 _ => panic!("invalid bit_len"),
             },
@@ -195,16 +195,16 @@ impl IntrinsicType {
                 bit_len: Some(bit_len),
                 ..
             } => match bit_len {
-                16 => "(float16_t)",
-                32 => "(float)",
-                64 => "(double)",
+                16 => "float16_t",
+                32 => "float",
+                64 => "double",
                 128 => "",
                 _ => panic!("invalid bit_len"),
             },
             IntrinsicType {
                 kind: TypeKind::Char(_),
                 ..
-            } => "(char)",
+            } => "char",
             _ => "",
         }
     }
@@ -391,4 +391,13 @@ pub trait IntrinsicTypeDefinition: Deref<Target = IntrinsicType> {
             bits = self.inner_size()
         )
     }
+
+    fn generate_final_type_cast(&self) -> String {
+        let type_data = self.c_promotion();
+        if type_data.len() > 2 {
+            format!("({type_data})")
+        } else {
+            String::new()
+        }
+    }
 }

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

@@ -185,7 +185,7 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
                             .map(move |idx| -> std::string::String {
                                 format!(
                                     "{cast}{lane_fn}(__return_value.val[{vector}], {lane})",
-                                    cast = self.c_promotion(),
+                                    cast = self.generate_final_type_cast(),
                                     lane_fn = self.get_lane_function(),
                                     lane = idx,
                                     vector = vector,
@@ -200,12 +200,13 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
         } else if self.num_lanes() > 1 {
             (0..self.num_lanes())
                 .map(|idx| -> std::string::String {
-                    format!(
-                        "{cast}{lane_fn}(__return_value, {lane})",
-                        cast = self.c_promotion(),
-                        lane_fn = self.get_lane_function(),
-                        lane = idx
-                    )
+                    let cast_type = self.c_promotion();
+                    let lane_fn = self.get_lane_function();
+                    if cast_type.len() > 2 {
+                        format!("({cast_type})({lane_fn}(__return_value, {idx}))")
+                    } else {
+                        format!("{lane_fn}(__return_value, {idx})")
+                    }
                 })
                 .collect::<Vec<_>>()
                 .join(r#" << ", " << "#)
@@ -224,13 +225,6 @@ impl IntrinsicTypeDefinition for X86IntrinsicType {
                         "__m{}i",
                         self.bit_len.expect(format!("self: {:#?}", self).as_str())
                     ),
-                    // TypeKind::Float if self.results().inner_size() == 16 => "float16_t".to_string(),
-                    // TypeKind::Int(true) if self.results().inner_size() == 64 => "long".to_string(),
-                    // TypeKind::Int(false) if self.results().inner_size() == 64 => "unsigned long".to_string(),
-                    // TypeKind::Int(true) if self.results().inner_size() == 32 => "int".to_string(),
-                    // TypeKind::Int(false) if self.results().inner_size() == 32 => "unsigned int".to_string(),
-                    // TypeKind::Int(true) if self.results().inner_size() == 16 => "short".to_string(),
-                    // TypeKind::Int(false) if self.results().inner_size() == 16 => "unsigned short".to_string(),
                     _ => self.c_scalar_type(),
                 },
                 promote = self.c_promotion(),