[clang] [CIR] Use `cir.vec.fcmp` op for logical comparisons (PR #239706)

Mariya Podchishchaeva via cfe-commits cfe-commits at lists.llvm.org
Fri Nov 6 09:53:32 PST 2026


https://github.com/Fznamznon created https://github.com/llvm/llvm-project/pull/239706

None

>From bd225b498b1d2b9a006dc87cc8aad2ff9afa7f9a Mon Sep 17 00:00:00 2001
From: Mariya Podchishchaeva <Mariya.Podchishchaeva at amd.com>
Date: Fri, 6 Nov 2026 11:37:12 -0600
Subject: [PATCH] [CIR] Use `cir.vec.fcmp` op for logical comparisons

---
 clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp    | 32 +++++++++++++++----
 clang/test/CIR/CodeGen/vector-ext.cpp         |  8 ++---
 .../CodeGen/vector-logical-long-double.cpp    | 12 +++----
 clang/test/CIR/CodeGen/vector-strict-fp.cpp   | 10 +++---
 clang/test/CIR/CodeGen/vector.cpp             | 10 +++---
 5 files changed, 46 insertions(+), 26 deletions(-)

diff --git a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
index f0c1714ba3cc18..e3f7f50f30a344 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
@@ -1430,11 +1430,18 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
       mlir::Value lhs = Visit(e->getLHS());
       mlir::Value rhs = Visit(e->getRHS());
 
-      auto cmpOpKind = cir::CmpOpKind::ne;
       auto resultTy =
           mlir::cast<cir::VectorType>(cgf.convertType(e->getType()));
-      lhs = builder.createVecCompare(loc, resultTy, cmpOpKind, lhs, zeroVec);
-      rhs = builder.createVecCompare(loc, resultTy, cmpOpKind, rhs, zeroVec);
+      if (cir::isFPOrVectorOfFPType(lhs.getType())) {
+        CIRGenFunction::CIRGenFPOptionsRAII FPOptsRAII(cgf, e);
+        auto cmpOpKind = cir::FCmpOpKind::une;
+        lhs = builder.createVecFCompare(loc, resultTy, cmpOpKind, lhs, zeroVec);
+        rhs = builder.createVecFCompare(loc, resultTy, cmpOpKind, rhs, zeroVec);
+      } else {
+        auto cmpOpKind = cir::CmpOpKind::ne;
+        lhs = builder.createVecCompare(loc, resultTy, cmpOpKind, lhs, zeroVec);
+        rhs = builder.createVecCompare(loc, resultTy, cmpOpKind, rhs, zeroVec);
+      }
       return builder.createAnd(loc, lhs, rhs);
     }
 
@@ -1478,11 +1485,18 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
       mlir::Value lhs = Visit(e->getLHS());
       mlir::Value rhs = Visit(e->getRHS());
 
-      auto cmpOpKind = cir::CmpOpKind::ne;
       auto resultTy =
           mlir::cast<cir::VectorType>(cgf.convertType(e->getType()));
-      lhs = builder.createVecCompare(loc, resultTy, cmpOpKind, lhs, zeroVec);
-      rhs = builder.createVecCompare(loc, resultTy, cmpOpKind, rhs, zeroVec);
+      if (cir::isFPOrVectorOfFPType(lhs.getType())) {
+        CIRGenFunction::CIRGenFPOptionsRAII FPOptsRAII(cgf, e);
+        auto cmpOpKind = cir::FCmpOpKind::une;
+        lhs = builder.createVecFCompare(loc, resultTy, cmpOpKind, lhs, zeroVec);
+        rhs = builder.createVecFCompare(loc, resultTy, cmpOpKind, rhs, zeroVec);
+      } else {
+        auto cmpOpKind = cir::CmpOpKind::ne;
+        lhs = builder.createVecCompare(loc, resultTy, cmpOpKind, lhs, zeroVec);
+        rhs = builder.createVecCompare(loc, resultTy, cmpOpKind, rhs, zeroVec);
+      }
       return builder.createOr(loc, lhs, rhs);
     }
 
@@ -3133,6 +3147,12 @@ mlir::Value ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *e) {
     auto operVecTy = mlir::cast<cir::VectorType>(oper.getType());
     mlir::Value zeroVec = builder.getNullValue(operVecTy, loc);
     auto resultTy = mlir::cast<cir::VectorType>(cgf.convertType(e->getType()));
+    if (cir::isFPOrVectorOfFPType(oper.getType())) {
+      CIRGenFunction::CIRGenFPOptionsRAII FPOptsRAII(cgf, e);
+      return builder.createVecFCompare(loc, resultTy, cir::FCmpOpKind::oeq,
+                                       oper, zeroVec);
+    }
+
     return builder.createVecCompare(loc, resultTy, cir::CmpOpKind::eq, oper,
                                     zeroVec);
   }
diff --git a/clang/test/CIR/CodeGen/vector-ext.cpp b/clang/test/CIR/CodeGen/vector-ext.cpp
index e352aead72b5f2..561f666c8d569d 100644
--- a/clang/test/CIR/CodeGen/vector-ext.cpp
+++ b/clang/test/CIR/CodeGen/vector-ext.cpp
@@ -1229,8 +1229,8 @@ void logical_or_vf4() {
 // CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
 // CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
 // CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
-// CIR: %[[NE_A_ZERO:.*]] = cir.vec.cmp(ne, %4, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
-// CIR: %[[NE_B_ZERO:.*]] = cir.vec.cmp(ne, %5, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
+// CIR: %[[NE_A_ZERO:.*]] = cir.vec.fcmp(une, %4, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
+// CIR: %[[NE_B_ZERO:.*]] = cir.vec.fcmp(une, %5, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
 // CIR: %[[RESULT:.*]] = cir.or %[[NE_A_ZERO]], %[[NE_B_ZERO]] : !cir.vector<4 x !s32i>
 // CIR: cir.store {{.*}} %[[RESULT]], %[[C_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
 
@@ -1348,8 +1348,8 @@ void logical_and_vf4() {
 // CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
 // CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
 // CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
-// CIR: %[[NE_A_ZERO:.*]] = cir.vec.cmp(ne, %4, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
-// CIR: %[[NE_B_ZERO:.*]] = cir.vec.cmp(ne, %5, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
+// CIR: %[[NE_A_ZERO:.*]] = cir.vec.fcmp(une, %4, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
+// CIR: %[[NE_B_ZERO:.*]] = cir.vec.fcmp(une, %5, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
 // CIR: %[[RESULT:.*]] = cir.and %[[NE_A_ZERO]], %[[NE_B_ZERO]] : !cir.vector<4 x !s32i>
 // CIR: cir.store {{.*}} %[[RESULT]], %[[C_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
 
diff --git a/clang/test/CIR/CodeGen/vector-logical-long-double.cpp b/clang/test/CIR/CodeGen/vector-logical-long-double.cpp
index ac580a1fd76402..2378195dae0245 100644
--- a/clang/test/CIR/CodeGen/vector-logical-long-double.cpp
+++ b/clang/test/CIR/CodeGen/vector-logical-long-double.cpp
@@ -14,7 +14,7 @@ typedef __int128 m2 __attribute__((vector_size(32)));
 void lnot(m1 *r, ld1 *v) { *r = !*v; }
 
 // CIR-LABEL: cir.func{{.*}} @_Z4lnotPDv1_nPDv1_e(
-// CIR: cir.vec.cmp(eq, %{{.+}}, %{{.+}}) : !cir.vector<1 x !cir.long_double<!cir.f80>>, !cir.vector<1 x !s128i>
+// CIR: cir.vec.fcmp(oeq, %{{.+}}, %{{.+}}) : !cir.vector<1 x !cir.long_double<!cir.f80>>, !cir.vector<1 x !s128i>
 
 // LLVM-LABEL: define dso_local void @_Z4lnotPDv1_nPDv1_e(ptr noundef %{{[^,)]+}}, ptr noundef %{{[^,)]+}})
 // LLVM: %[[CMP:.+]] = fcmp oeq <1 x x86_fp80> %{{.+}}, zeroinitializer
@@ -24,7 +24,7 @@ void lnot(m1 *r, ld1 *v) { *r = !*v; }
 void lnot2(m2 *r, ld2 *v) { *r = !*v; }
 
 // CIR-LABEL: cir.func{{.*}} @_Z5lnot2PDv2_nPDv2_e(
-// CIR: cir.vec.cmp(eq, %{{.+}}, %{{.+}}) : !cir.vector<2 x !cir.long_double<!cir.f80>>, !cir.vector<2 x !s128i>
+// CIR: cir.vec.fcmp(oeq, %{{.+}}, %{{.+}}) : !cir.vector<2 x !cir.long_double<!cir.f80>>, !cir.vector<2 x !s128i>
 
 // LLVM-LABEL: define dso_local void @_Z5lnot2PDv2_nPDv2_e(ptr noundef %{{[^,)]+}}, ptr noundef %{{[^,)]+}})
 // LLVM: %[[CMP:.+]] = fcmp oeq <2 x x86_fp80> %{{.+}}, zeroinitializer
@@ -34,8 +34,8 @@ void lnot2(m2 *r, ld2 *v) { *r = !*v; }
 void land(m1 *r, ld1 *a, ld1 *b) { *r = *a && *b; }
 
 // CIR-LABEL: cir.func{{.*}} @_Z4landPDv1_nPDv1_eS2_(
-// CIR: %[[A:.+]] = cir.vec.cmp(ne, %{{.+}}, %{{.+}}) : !cir.vector<1 x !cir.long_double<!cir.f80>>, !cir.vector<1 x !s128i>
-// CIR: %[[B:.+]] = cir.vec.cmp(ne, %{{.+}}, %{{.+}}) : !cir.vector<1 x !cir.long_double<!cir.f80>>, !cir.vector<1 x !s128i>
+// CIR: %[[A:.+]] = cir.vec.fcmp(une, %{{.+}}, %{{.+}}) : !cir.vector<1 x !cir.long_double<!cir.f80>>, !cir.vector<1 x !s128i>
+// CIR: %[[B:.+]] = cir.vec.fcmp(une, %{{.+}}, %{{.+}}) : !cir.vector<1 x !cir.long_double<!cir.f80>>, !cir.vector<1 x !s128i>
 // CIR: cir.and %[[A]], %[[B]] : !cir.vector<1 x !s128i>
 
 // LLVM-LABEL: define dso_local void @_Z4landPDv1_nPDv1_eS2_(ptr noundef %{{[^,)]+}}, ptr noundef %{{[^,)]+}}, ptr noundef %{{[^,)]+}})
@@ -51,8 +51,8 @@ void land(m1 *r, ld1 *a, ld1 *b) { *r = *a && *b; }
 void lor(m1 *r, ld1 *a, ld1 *b) { *r = *a || *b; }
 
 // CIR-LABEL: cir.func{{.*}} @_Z3lorPDv1_nPDv1_eS2_(
-// CIR: %[[A:.+]] = cir.vec.cmp(ne, %{{.+}}, %{{.+}}) : !cir.vector<1 x !cir.long_double<!cir.f80>>, !cir.vector<1 x !s128i>
-// CIR: %[[B:.+]] = cir.vec.cmp(ne, %{{.+}}, %{{.+}}) : !cir.vector<1 x !cir.long_double<!cir.f80>>, !cir.vector<1 x !s128i>
+// CIR: %[[A:.+]] = cir.vec.fcmp(une, %{{.+}}, %{{.+}}) : !cir.vector<1 x !cir.long_double<!cir.f80>>, !cir.vector<1 x !s128i>
+// CIR: %[[B:.+]] = cir.vec.fcmp(une, %{{.+}}, %{{.+}}) : !cir.vector<1 x !cir.long_double<!cir.f80>>, !cir.vector<1 x !s128i>
 // CIR: cir.or %[[A]], %[[B]] : !cir.vector<1 x !s128i>
 
 // LLVM-LABEL: define dso_local void @_Z3lorPDv1_nPDv1_eS2_(ptr noundef %{{[^,)]+}}, ptr noundef %{{[^,)]+}}, ptr noundef %{{[^,)]+}})
diff --git a/clang/test/CIR/CodeGen/vector-strict-fp.cpp b/clang/test/CIR/CodeGen/vector-strict-fp.cpp
index 7e7f75879bb515..9e5225c492a430 100644
--- a/clang/test/CIR/CodeGen/vector-strict-fp.cpp
+++ b/clang/test/CIR/CodeGen/vector-strict-fp.cpp
@@ -17,7 +17,7 @@ void vec_logical_not() {
 // CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
 // CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
 // CIR: %[[CONST_ZERO:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
-// CIR: %[[RESULT:.*]] = cir.vec.cmp(eq, %[[TMP_A]], %[[CONST_ZERO]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i> fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true>
+// CIR: %[[RESULT:.*]] = cir.vec.fcmp(oeq, %[[TMP_A]], %[[CONST_ZERO]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i> fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true>
 // CIR: cir.store {{.*}} %[[RESULT]], %[[B_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
 
 // SHARED: %[[A_ADDR:.*]] = alloca <4 x float>, align 16
@@ -39,8 +39,8 @@ void vec_logical_or() {
 // CIR: %[[CONST_ZERO:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
 // CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
 // CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
-// CIR: %[[A_NE_ZERO:.*]] = cir.vec.cmp(ne, %[[TMP_A]], %[[CONST_ZERO]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i> fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true>
-// CIR: %[[B_NE_ZERO:.*]] = cir.vec.cmp(ne, %[[TMP_B]], %[[CONST_ZERO]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i> fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true>
+// CIR: %[[A_NE_ZERO:.*]] = cir.vec.fcmp(une, %[[TMP_A]], %[[CONST_ZERO]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i> fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true>
+// CIR: %[[B_NE_ZERO:.*]] = cir.vec.fcmp(une, %[[TMP_B]], %[[CONST_ZERO]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i> fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true>
 // CIR: %[[RESULT:.*]] = cir.or %[[A_NE_ZERO]], %[[B_NE_ZERO]] : !cir.vector<4 x !s32i>
 // CIR: cir.store {{.*}} %[[RESULT]], %[[R_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
 
@@ -79,8 +79,8 @@ void vec_logical_and() {
 // CIR: %[[CONST_ZERO:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
 // CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
 // CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
-// CIR: %[[A_NE_ZERO:.*]] = cir.vec.cmp(ne, %[[TMP_A]], %[[CONST_ZERO]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i> fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true>
-// CIR: %[[B_NE_ZERO:.*]] = cir.vec.cmp(ne, %[[TMP_B]], %[[CONST_ZERO]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i> fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true>
+// CIR: %[[A_NE_ZERO:.*]] = cir.vec.fcmp(une, %[[TMP_A]], %[[CONST_ZERO]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i> fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true>
+// CIR: %[[B_NE_ZERO:.*]] = cir.vec.fcmp(une, %[[TMP_B]], %[[CONST_ZERO]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i> fenv<dynamic_rounding_mode = tonearest, except_mode = unknown, strict_except = true>
 // CIR: %[[RESULT:.*]] = cir.and %[[A_NE_ZERO]], %[[B_NE_ZERO]] : !cir.vector<4 x !s32i>
 // CIR: cir.store {{.*}} %[[RESULT]], %[[R_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
 
diff --git a/clang/test/CIR/CodeGen/vector.cpp b/clang/test/CIR/CodeGen/vector.cpp
index a9690e392ce967..b521665681da55 100644
--- a/clang/test/CIR/CodeGen/vector.cpp
+++ b/clang/test/CIR/CodeGen/vector.cpp
@@ -1271,8 +1271,8 @@ void logical_or_vf4() {
 // CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
 // CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
 // CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
-// CIR: %[[NE_A_ZERO:.*]] = cir.vec.cmp(ne, %4, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
-// CIR: %[[NE_B_ZERO:.*]] = cir.vec.cmp(ne, %5, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
+// CIR: %[[NE_A_ZERO:.*]] = cir.vec.fcmp(une, %4, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
+// CIR: %[[NE_B_ZERO:.*]] = cir.vec.fcmp(une, %5, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
 // CIR: %[[RESULT:.*]] = cir.or %[[NE_A_ZERO]], %[[NE_B_ZERO]] : !cir.vector<4 x !s32i>
 // CIR: cir.store {{.*}} %[[RESULT]], %[[C_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
 
@@ -1390,8 +1390,8 @@ void logical_and_vf4() {
 // CIR: %[[ZERO_VEC:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
 // CIR: %[[TMP_A:.*]] = cir.load {{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
 // CIR: %[[TMP_B:.*]] = cir.load {{.*}} %[[B_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
-// CIR: %[[NE_A_ZERO:.*]] = cir.vec.cmp(ne, %4, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
-// CIR: %[[NE_B_ZERO:.*]] = cir.vec.cmp(ne, %5, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
+// CIR: %[[NE_A_ZERO:.*]] = cir.vec.fcmp(une, %4, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
+// CIR: %[[NE_B_ZERO:.*]] = cir.vec.fcmp(une, %5, %[[ZERO_VEC]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
 // CIR: %[[RESULT:.*]] = cir.and %[[NE_A_ZERO]], %[[NE_B_ZERO]] : !cir.vector<4 x !s32i>
 // CIR: cir.store {{.*}} %[[RESULT]], %[[C_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
 
@@ -1453,7 +1453,7 @@ void logical_not_float() {
 // CIR: %[[B_ADDR:.*]] = cir.alloca "b" {{.*}} init : !cir.ptr<!cir.vector<4 x !s32i>>
 // CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.vector<4 x !cir.float>>, !cir.vector<4 x !cir.float>
 // CIR: %[[CONST_V0:.*]] = cir.const #cir.zero : !cir.vector<4 x !cir.float>
-// CIR: %[[RESULT:.*]] = cir.vec.cmp(eq, %[[TMP_A]], %[[CONST_V0]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
+// CIR: %[[RESULT:.*]] = cir.vec.fcmp(oeq, %[[TMP_A]], %[[CONST_V0]]) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
 // CIR: cir.store{{.*}} %[[RESULT]], %[[B_ADDR]] : !cir.vector<4 x !s32i>, !cir.ptr<!cir.vector<4 x !s32i>>
 
 // LLVM: %[[A_ADDR:.*]] = alloca <4 x float>, align 16



More information about the cfe-commits mailing list