Use pointers for the C definitions to resolve ABI inconsistencies

Author: sayantn

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

@@ -89,17 +89,21 @@ where
     pub fn as_non_imm_arglist_c(&self) -> String {
         self.iter()
             .filter(|arg| !arg.has_constraint())
-            .format_with(", ", |arg, fmt| {
-                fmt(&format_args!("{} {}", arg.to_c_type(), arg.name))
+            .format_with("", |arg, fmt| {
+                fmt(&format_args!(", const {}* {}", arg.to_c_type(), arg.name))
             })
             .to_string()
     }
 
     pub fn as_non_imm_arglist_rust(&self) -> String {
         self.iter()
             .filter(|arg| !arg.has_constraint())
-            .format_with(", ", |arg, fmt| {
-                fmt(&format_args!("{}: {}", arg.name, arg.ty.rust_type()))
+            .format_with("", |arg, fmt| {
+                fmt(&format_args!(
+                    ", {}: *const {}",
+                    arg.name,
+                    arg.ty.rust_type()
+                ))
             })
             .to_string()
     }
@@ -111,6 +115,7 @@ where
                 if arg.has_constraint() {
                     fmt(&imm_args.next().unwrap())
                 } else {
+                    fmt(&"*")?;
                     fmt(&arg.name)
                 }
             })
@@ -126,6 +131,13 @@ where
             .join(", ")
     }
 
+    pub fn as_c_call_param_rust(&self) -> String {
+        self.iter()
+            .filter(|a| !a.has_constraint())
+            .map(|arg| format!(", &raw const {} as _", arg.generate_name()))
+            .join("")
+    }
+
     /// Creates a line for each argument that initializes an array for Rust from which `loads` argument
     /// values can be loaded as a sliding window, e.g `const A_VALS: [u32; 20]  = [...];`
     pub fn gen_arglists_rust(

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

@@ -24,8 +24,8 @@ pub fn write_wrapper_c<T: IntrinsicTypeDefinition>(
             writeln!(
                 w,
                 "
-{return_ty} {name}_wrapper{imm_arglist}({arglist}) {{
-    return {name}({params});
+void {name}_wrapper{imm_arglist}({return_ty}* dst{arglist}) {{
+    *dst = {name}({params});
 }}",
                 return_ty = intrinsic.results.c_type(),
                 name = intrinsic.name,

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

@@ -130,10 +130,13 @@ fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
 
     // Each function (and each specialization) has its own type. Erase that type with a cast.
     let mut coerce = String::from("fn(");
+    let mut c_coerce = String::from("fn(_, ");
     for _ in intrinsic.arguments.iter().filter(|a| !a.has_constraint()) {
         coerce += "_, ";
+        c_coerce += "_, ";
     }
     coerce += ") -> _";
+    c_coerce += ")";
 
     if intrinsic
         .arguments
@@ -152,7 +155,7 @@ fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
         intrinsic.iter_specializations(|imm_values| {
             writeln!(
                 w,
-                "        (\"{const_args}\", {intrinsic_name}::<{const_args}> as unsafe {coerce}, {intrinsic_name}_wrapper_{c_const_args} as unsafe extern \"C\" {coerce}),",
+                "        (\"{const_args}\", {intrinsic_name}::<{const_args}> as unsafe {coerce}, {intrinsic_name}_wrapper_{c_const_args} as unsafe extern \"C\" {c_coerce}),",
                 const_args = imm_values.iter().join(","),
                 c_const_args = imm_values.iter().join("_"),
             )
@@ -191,17 +194,19 @@ fn generate_rust_test_loop<T: IntrinsicTypeDefinition>(
             "        for i in 0..{passes} {{",
             "            unsafe {{",
             "{loaded_args}",
-            "                let __rust_return_value = rust({args});",
-            "                let __c_return_value = c({args});",
-            "                assert_eq!({cast_prefix}__rust_return_value{cast_suffix}, {cast_prefix}__c_return_value{cast_suffix}, \"{{id}}\");",
+            "                let __rust_return_value = rust({rust_args});",
+            "                let mut __c_return_value = std::mem::MaybeUninit::uninit();",
+            "                c(__c_return_value.as_mut_ptr(){c_args});",
+            "                assert_eq!({cast_prefix}__rust_return_value{cast_suffix}, {cast_prefix}__c_return_value.assume_init(){cast_suffix}, \"{{id}}\");",
             "            }}",
             "        }}",
             "    }}",
         ),
         loaded_args = intrinsic
             .arguments
             .load_values_rust(Indentation::default().nest_by(4)),
-        args = intrinsic.arguments.as_call_param_rust(),
+        rust_args = intrinsic.arguments.as_call_param_rust(),
+        c_args = intrinsic.arguments.as_c_call_param_rust(),
         passes = passes,
         cast_prefix = cast_prefix,
         cast_suffix = cast_suffix,
@@ -250,7 +255,7 @@ pub fn write_bindings_rust<T: IntrinsicTypeDefinition>(
         intrinsic.iter_specializations(|imm_values| {
             writeln!(
                 w,
-                "    fn {name}_wrapper{imm_arglist}({arglist}) -> {return_ty};",
+                "    fn {name}_wrapper{imm_arglist}(dst: *mut {return_ty}{arglist});",
                 return_ty = intrinsic.results.rust_type(),
                 name = intrinsic.name,
                 imm_arglist = imm_values