chore: add better error handling when writing and compiling mod_{i}.cpp, neatly organize C++ headers

Author: madhav-madhusoodanan

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

@@ -31,15 +31,7 @@ impl SupportedArchitectureTest for ArmArchitectureTest {
 
     const NOTICE: &str = config::NOTICE;
 
-    const PLATFORM_C_HEADERS: &[&str] = &[
-        "iostream",
-        "cstring",
-        "iomanip",
-        "sstream",
-        "arm_neon.h",
-        "arm_acle.h",
-        "arm_fp16.h",
-    ];
+    const PLATFORM_C_HEADERS: &[&str] = &["arm_neon.h", "arm_acle.h", "arm_fp16.h"];
     const PLATFORM_C_DEFINITIONS: &str = config::POLY128_OSTREAM_DEF;
     const PLATFORM_C_FORWARD_DECLARATIONS: &str = config::POLY128_OSTREAM_DECL;
 

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

@@ -133,20 +133,15 @@ pub fn write_main_cpp<'a>(
     arch_specific_headers: &[&str],
     intrinsics: impl Iterator<Item = &'a str> + Clone,
 ) -> std::io::Result<()> {
-    writeln!(w, "#include <iostream>")?;
-    writeln!(w, "#include <string>")?;
+    const COMMON_HEADERS: [&str; 5] = ["iostream", "string", "cstring", "iomanip", "sstream"];
 
-    for header in arch_specific_headers {
+    for header in COMMON_HEADERS.iter().chain(arch_specific_headers.iter()) {
         writeln!(w, "#include <{header}>")?;
     }
 
     writeln!(
         w,
         r#"
-#include <cstring>
-#include <iomanip>
-#include <sstream>
-
 std::ostream& operator<<(std::ostream& os, float16_t value) {{
     uint16_t temp = 0;
     memcpy(&temp, &value, sizeof(float16_t));

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

@@ -60,28 +60,34 @@ pub trait SupportedArchitectureTest {
             .map(|(i, chunk)| {
                 let c_filename = format!("c_programs/mod_{i}.cpp");
                 let mut file = File::create(&c_filename).unwrap();
-                write_mod_cpp(
+                let mod_file_write_result = write_mod_cpp(
                     &mut file,
                     Self::NOTICE,
                     Self::PLATFORM_C_HEADERS,
                     Self::PLATFORM_C_FORWARD_DECLARATIONS,
                     chunk,
-                )
-                .unwrap();
+                );
+
+                if let Err(error) = mod_file_write_result {
+                    return Err(format!("Error writing to mod_{i}.cpp: {error:?}"));
+                }
 
                 // compile this cpp file into a .o file.
                 //
                 // This is done because `cpp_compiler_wrapped` is None when
                 // the --generate-only flag is passed
                 if let Some(cpp_compiler) = cpp_compiler_wrapped.as_ref() {
-                    let output = cpp_compiler
-                        .compile_object_file(&format!("mod_{i}.cpp"), &format!("mod_{i}.o"))?;
-                    assert!(output.status.success(), "{output:?}");
+                    let compile_output = cpp_compiler
+                        .compile_object_file(&format!("mod_{i}.cpp"), &format!("mod_{i}.o"));
+
+                    if let Err(compile_error) = compile_output {
+                        return Err(format!("Error compiling mod_{i}.cpp: {compile_error:?}"));
+                    }
                 }
 
                 Ok(())
             })
-            .collect::<Result<(), std::io::Error>>()
+            .collect::<Result<(), String>>()
             .unwrap();
 
         let mut file = File::create("c_programs/main.cpp").unwrap();

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

@@ -35,15 +35,7 @@ impl SupportedArchitectureTest for X86ArchitectureTest {
 
     const NOTICE: &str = config::NOTICE;
 
-    const PLATFORM_C_HEADERS: &[&str] = &[
-        "immintrin.h",
-        "iostream",
-        "cstring",
-        "iomanip",
-        "sstream",
-        "cstddef",
-        "cstdint",
-    ];
+    const PLATFORM_C_HEADERS: &[&str] = &["immintrin.h", "cstddef", "cstdint"];
     const PLATFORM_C_DEFINITIONS: &str = config::LANE_FUNCTION_HELPERS;
     const PLATFORM_C_FORWARD_DECLARATIONS: &str = config::LANE_FUNCTION_HELPERS;