Improve SIMD binary op lowering and add vector tests

Author: darmie

crates/compiler/src/cranelift_backend.rs

@@ -6709,15 +6709,20 @@ impl CraneliftBackend {
 impl HirType {
     #[allow(dead_code)]
     fn is_float(&self) -> bool {
-        matches!(self, HirType::F32 | HirType::F64)
+        match self {
+            HirType::F32 | HirType::F64 => true,
+            HirType::Vector(elem_ty, _) => elem_ty.is_float(),
+            _ => false,
+        }
     }
 
     #[allow(dead_code)]
     fn is_signed(&self) -> bool {
-        matches!(
-            self,
-            HirType::I8 | HirType::I16 | HirType::I32 | HirType::I64 | HirType::I128
-        )
+        match self {
+            HirType::I8 | HirType::I16 | HirType::I32 | HirType::I64 | HirType::I128 => true,
+            HirType::Vector(elem_ty, _) => elem_ty.is_signed(),
+            _ => false,
+        }
     }
 }
 

crates/compiler/src/ssa.rs

@@ -1883,7 +1883,7 @@ impl SsaBuilder {
                 let right_val = self.translate_expression(block_id, right)?;
                 let result_type = self.convert_type(&expr.ty);
 
-                let hir_op = self.convert_binary_op(op);
+                let hir_op = self.convert_binary_op(op, &left_with_type.ty);
 
                 // For comparisons, use the operand type (not Bool result type) for the instruction
                 let inst_type = match hir_op {
@@ -4350,28 +4350,102 @@ impl SsaBuilder {
     fn convert_binary_op(
         &self,
         op: &zyntax_typed_ast::typed_ast::BinaryOp,
+        operand_ty: &Type,
     ) -> crate::hir::BinaryOp {
         use crate::hir::BinaryOp as HirOp;
         use zyntax_typed_ast::typed_ast::BinaryOp as FrontendOp;
 
+        let operand_hir_ty = self.convert_type(operand_ty);
+        let is_float_like = match &operand_hir_ty {
+            HirType::F32 | HirType::F64 => true,
+            HirType::Vector(elem_ty, _) => matches!(&**elem_ty, HirType::F32 | HirType::F64),
+            _ => false,
+        };
+
         match op {
-            FrontendOp::Add => HirOp::Add,
-            FrontendOp::Sub => HirOp::Sub,
-            FrontendOp::Mul => HirOp::Mul,
+            FrontendOp::Add => {
+                if is_float_like {
+                    HirOp::FAdd
+                } else {
+                    HirOp::Add
+                }
+            }
+            FrontendOp::Sub => {
+                if is_float_like {
+                    HirOp::FSub
+                } else {
+                    HirOp::Sub
+                }
+            }
+            FrontendOp::Mul => {
+                if is_float_like {
+                    HirOp::FMul
+                } else {
+                    HirOp::Mul
+                }
+            }
             FrontendOp::MatMul => HirOp::Mul,
-            FrontendOp::Div => HirOp::Div,
-            FrontendOp::Rem => HirOp::Rem,
+            FrontendOp::Div => {
+                if is_float_like {
+                    HirOp::FDiv
+                } else {
+                    HirOp::Div
+                }
+            }
+            FrontendOp::Rem => {
+                if is_float_like {
+                    HirOp::FRem
+                } else {
+                    HirOp::Rem
+                }
+            }
             FrontendOp::BitAnd => HirOp::And,
             FrontendOp::BitOr => HirOp::Or,
             FrontendOp::BitXor => HirOp::Xor,
             FrontendOp::Shl => HirOp::Shl,
             FrontendOp::Shr => HirOp::Shr,
-            FrontendOp::Eq => HirOp::Eq,
-            FrontendOp::Ne => HirOp::Ne,
-            FrontendOp::Lt => HirOp::Lt,
-            FrontendOp::Le => HirOp::Le,
-            FrontendOp::Gt => HirOp::Gt,
-            FrontendOp::Ge => HirOp::Ge,
+            FrontendOp::Eq => {
+                if is_float_like {
+                    HirOp::FEq
+                } else {
+                    HirOp::Eq
+                }
+            }
+            FrontendOp::Ne => {
+                if is_float_like {
+                    HirOp::FNe
+                } else {
+                    HirOp::Ne
+                }
+            }
+            FrontendOp::Lt => {
+                if is_float_like {
+                    HirOp::FLt
+                } else {
+                    HirOp::Lt
+                }
+            }
+            FrontendOp::Le => {
+                if is_float_like {
+                    HirOp::FLe
+                } else {
+                    HirOp::Le
+                }
+            }
+            FrontendOp::Gt => {
+                if is_float_like {
+                    HirOp::FGt
+                } else {
+                    HirOp::Gt
+                }
+            }
+            FrontendOp::Ge => {
+                if is_float_like {
+                    HirOp::FGe
+                } else {
+                    HirOp::Ge
+                }
+            }
             _ => HirOp::Add, // Default
         }
     }
@@ -6493,7 +6567,7 @@ impl SsaBuilder {
                     ));
                 }
 
-                let hir_op = self.convert_binary_op(&bin.op);
+                let hir_op = self.convert_binary_op(&bin.op, &bin.left.ty);
                 let result_id = HirId::new();
                 func.values.insert(
                     result_id,

crates/compiler/tests/cranelift_backend_tests.rs

@@ -206,6 +206,26 @@ fn test_arithmetic_operations() {
         .expect("Failed to compile division function");
 }
 
+/// Test SIMD vector arithmetic compilation (integer lanes)
+#[test]
+fn test_vector_i32x4_add_compilation() {
+    let mut backend = CraneliftBackend::new().expect("Failed to create backend");
+    let func = create_vector_arithmetic_function("vec_i32x4_add", BinaryOp::Add, HirType::I32, 4);
+    backend
+        .compile_function(func.id, &func)
+        .expect("Failed to compile i32x4 add function");
+}
+
+/// Test SIMD vector arithmetic compilation (floating lanes)
+#[test]
+fn test_vector_f32x4_add_compilation() {
+    let mut backend = CraneliftBackend::new().expect("Failed to create backend");
+    let func = create_vector_arithmetic_function("vec_f32x4_add", BinaryOp::FAdd, HirType::F32, 4);
+    backend
+        .compile_function(func.id, &func)
+        .expect("Failed to compile f32x4 add function");
+}
+
 /// Test comparison operations
 #[test]
 fn test_comparison_operations() {
@@ -359,6 +379,65 @@ fn create_comparison_function(name: &str, op: BinaryOp) -> HirFunction {
     func
 }
 
+/// Helper function to create vector arithmetic operations
+fn create_vector_arithmetic_function(
+    name: &str,
+    op: BinaryOp,
+    elem_ty: HirType,
+    lanes: u32,
+) -> HirFunction {
+    let name = create_test_string(name);
+    let vec_ty = HirType::Vector(Box::new(elem_ty), lanes);
+
+    let sig = HirFunctionSignature {
+        params: vec![
+            HirParam {
+                id: HirId::new(),
+                name: create_test_string("a"),
+                ty: vec_ty.clone(),
+                attributes: ParamAttributes::default(),
+            },
+            HirParam {
+                id: HirId::new(),
+                name: create_test_string("b"),
+                ty: vec_ty.clone(),
+                attributes: ParamAttributes::default(),
+            },
+        ],
+        returns: vec![vec_ty.clone()],
+        type_params: vec![],
+        const_params: vec![],
+        lifetime_params: vec![],
+        is_variadic: false,
+        is_async: false,
+        effects: vec![],
+        is_pure: false,
+    };
+
+    let mut func = HirFunction::new(name, sig);
+
+    let entry_block_id = func.entry_block;
+    let param_a = func.create_value(vec_ty.clone(), HirValueKind::Parameter(0));
+    let param_b = func.create_value(vec_ty.clone(), HirValueKind::Parameter(1));
+
+    let result = func.create_value(vec_ty.clone(), HirValueKind::Instruction);
+    let inst = HirInstruction::Binary {
+        op,
+        result,
+        ty: vec_ty,
+        left: param_a,
+        right: param_b,
+    };
+
+    let block = func.blocks.get_mut(&entry_block_id).unwrap();
+    block.add_instruction(inst);
+    block.set_terminator(HirTerminator::Return {
+        values: vec![result],
+    });
+
+    func
+}
+
 /// Create a function with control flow (if-else)
 fn create_control_flow_function() -> HirFunction {
     let name = create_test_string("abs");