Added some sanity checks to function call compilation. This will catch *some* cases of ABI mismatch.

Author: FractalFir

src/builder.rs

@@ -270,18 +270,11 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
                             actual_val.dereference(self.location).to_rvalue()
                         }
                     } else {
-                        // FIXME: this condition seems wrong: it will pass when both types are not
-                        // a vector.
+                        // Check that the types are not "known to mismatch" or are vectors
                         assert!(
-                            (!expected_ty.is_vector() || actual_ty.is_vector())
-                                && (expected_ty.is_vector() || !actual_ty.is_vector()),
-                            "{:?} (is vector: {}) -> {:?} (is vector: {}), Function: {:?}[{}]",
-                            actual_ty,
-                            actual_ty.is_vector(),
-                            expected_ty,
-                            expected_ty.is_vector(),
-                            func_ptr,
-                            index
+                            expected_ty.known_eq(&actual_ty, self.cx).unwrap_or(true)
+                                || expected_ty.is_vector() && actual_ty.is_vector(),
+                            "{actual_ty:?} -> {expected_ty:?}, Function: {func_ptr:?}[{index}]"
                         );
                         // TODO(antoyo): perhaps use __builtin_convertvector for vector casting.
                         // TODO: remove bitcast now that vector types can be compared?

src/common.rs

@@ -425,6 +425,10 @@ pub trait TypeReflection<'gcc, 'tcx> {
     fn is_u128(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
 
     fn is_vector(&self) -> bool;
+    /// Checks if 2 types are "known to be equal". Returns Some(true) if types are equal(e.g. bool and bool),
+    /// Some(false) if they can't possibly be equal(e.g. a struct and a float), and None if there is no way
+    /// to check for their equality(struct and struct)
+    fn known_eq(&self, rhs: &Self, cx: &CodegenCx<'gcc, 'tcx>) -> Option<bool>;
 }
 
 impl<'gcc, 'tcx> TypeReflection<'gcc, 'tcx> for Type<'gcc> {
@@ -524,4 +528,43 @@ impl<'gcc, 'tcx> TypeReflection<'gcc, 'tcx> for Type<'gcc> {
 
         false
     }
+    fn known_eq(&self, other: &Self, cx: &CodegenCx<'gcc, 'tcx>) -> Option<bool> {
+        // "Happy" path: types represented using the same pointer
+        if self == other {
+            return Some(true);
+        }
+        if self.is_bool() {
+            return Some(other.is_bool());
+        } else if self.is_integral() {
+            if !other.is_integral() {
+                return Some(false);
+            }
+            return Some(
+                (self.get_size() == other.get_size())
+                    && (self.is_signed(cx) == other.is_signed(cx)),
+            );
+        } else if self.is_floating_point() {
+            if !other.is_floating_point() {
+                return Some(false);
+            }
+            return Some(self.get_size() == other.get_size());
+        } else if self.is_vector() {
+            if !other.is_vector() {
+                return Some(false);
+            }
+            return None;
+        } else if self.is_struct().is_some() {
+            if other.is_struct().is_none() {
+                return Some(false);
+            }
+            return None;
+        } else if let Some(s_ptr) = self.get_pointee() {
+            let Some(other_ptr) = other.get_pointee() else {
+                return Some(false);
+            };
+            return s_ptr.known_eq(&other_ptr, cx);
+        }
+        // Unknown type...
+        None
+    }
 }