Skip to content

Commit 267b859

Browse files
AmrDeveloperAmrDeveloper
authored
[CIR] Implement folder for VecCmpOp (#143322)
This change adds a folder for the VecCmpOp Issue #136487
1 parent 90d62e0 commit 267b859

File tree

4 files changed

+328
-1
lines changed

4 files changed

+328
-1
lines changed

‎clang/include/clang/CIR/Dialect/IR/CIROps.td

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2155,6 +2155,8 @@ def VecCmpOp : CIR_Op<"vec.cmp", [Pure, SameTypeOperands]> {
21552155
`(` $kind `,` $lhs `,` $rhs `)` `:` qualified(type($lhs)) `,`
21562156
qualified(type($result)) attr-dict
21572157
}];
2158+
2159+
let hasFolder = 1;
21582160
}
21592161

21602162
//===----------------------------------------------------------------------===//

‎clang/lib/CIR/Dialect/IR/CIRDialect.cpp

Lines changed: 98 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1589,6 +1589,104 @@ OpFoldResult cir::VecExtractOp::fold(FoldAdaptor adaptor) {
15891589
return elements[index];
15901590
}
15911591

1592+
//===----------------------------------------------------------------------===//
1593+
// VecCmpOp
1594+
//===----------------------------------------------------------------------===//
1595+
1596+
OpFoldResult cir::VecCmpOp::fold(FoldAdaptor adaptor) {
1597+
auto lhsVecAttr =
1598+
mlir::dyn_cast_if_present<cir::ConstVectorAttr>(adaptor.getLhs());
1599+
auto rhsVecAttr =
1600+
mlir::dyn_cast_if_present<cir::ConstVectorAttr>(adaptor.getRhs());
1601+
if (!lhsVecAttr || !rhsVecAttr)
1602+
return {};
1603+
1604+
mlir::Type inputElemTy =
1605+
mlir::cast<cir::VectorType>(lhsVecAttr.getType()).getElementType();
1606+
if (!isAnyIntegerOrFloatingPointType(inputElemTy))
1607+
return {};
1608+
1609+
cir::CmpOpKind opKind = adaptor.getKind();
1610+
mlir::ArrayAttr lhsVecElhs = lhsVecAttr.getElts();
1611+
mlir::ArrayAttr rhsVecElhs = rhsVecAttr.getElts();
1612+
uint64_t vecSize = lhsVecElhs.size();
1613+
1614+
SmallVector<mlir::Attribute, 16> elements(vecSize);
1615+
bool isIntAttr = vecSize && mlir::isa<cir::IntAttr>(lhsVecElhs[0]);
1616+
for (uint64_t i = 0; i < vecSize; i++) {
1617+
mlir::Attribute lhsAttr = lhsVecElhs[i];
1618+
mlir::Attribute rhsAttr = rhsVecElhs[i];
1619+
int cmpResult = 0;
1620+
switch (opKind) {
1621+
case cir::CmpOpKind::lt: {
1622+
if (isIntAttr) {
1623+
cmpResult = mlir::cast<cir::IntAttr>(lhsAttr).getSInt() <
1624+
mlir::cast<cir::IntAttr>(rhsAttr).getSInt();
1625+
} else {
1626+
cmpResult = mlir::cast<cir::FPAttr>(lhsAttr).getValue() <
1627+
mlir::cast<cir::FPAttr>(rhsAttr).getValue();
1628+
}
1629+
break;
1630+
}
1631+
case cir::CmpOpKind::le: {
1632+
if (isIntAttr) {
1633+
cmpResult = mlir::cast<cir::IntAttr>(lhsAttr).getSInt() <=
1634+
mlir::cast<cir::IntAttr>(rhsAttr).getSInt();
1635+
} else {
1636+
cmpResult = mlir::cast<cir::FPAttr>(lhsAttr).getValue() <=
1637+
mlir::cast<cir::FPAttr>(rhsAttr).getValue();
1638+
}
1639+
break;
1640+
}
1641+
case cir::CmpOpKind::gt: {
1642+
if (isIntAttr) {
1643+
cmpResult = mlir::cast<cir::IntAttr>(lhsAttr).getSInt() >
1644+
mlir::cast<cir::IntAttr>(rhsAttr).getSInt();
1645+
} else {
1646+
cmpResult = mlir::cast<cir::FPAttr>(lhsAttr).getValue() >
1647+
mlir::cast<cir::FPAttr>(rhsAttr).getValue();
1648+
}
1649+
break;
1650+
}
1651+
case cir::CmpOpKind::ge: {
1652+
if (isIntAttr) {
1653+
cmpResult = mlir::cast<cir::IntAttr>(lhsAttr).getSInt() >=
1654+
mlir::cast<cir::IntAttr>(rhsAttr).getSInt();
1655+
} else {
1656+
cmpResult = mlir::cast<cir::FPAttr>(lhsAttr).getValue() >=
1657+
mlir::cast<cir::FPAttr>(rhsAttr).getValue();
1658+
}
1659+
break;
1660+
}
1661+
case cir::CmpOpKind::eq: {
1662+
if (isIntAttr) {
1663+
cmpResult = mlir::cast<cir::IntAttr>(lhsAttr).getSInt() ==
1664+
mlir::cast<cir::IntAttr>(rhsAttr).getSInt();
1665+
} else {
1666+
cmpResult = mlir::cast<cir::FPAttr>(lhsAttr).getValue() ==
1667+
mlir::cast<cir::FPAttr>(rhsAttr).getValue();
1668+
}
1669+
break;
1670+
}
1671+
case cir::CmpOpKind::ne: {
1672+
if (isIntAttr) {
1673+
cmpResult = mlir::cast<cir::IntAttr>(lhsAttr).getSInt() !=
1674+
mlir::cast<cir::IntAttr>(rhsAttr).getSInt();
1675+
} else {
1676+
cmpResult = mlir::cast<cir::FPAttr>(lhsAttr).getValue() !=
1677+
mlir::cast<cir::FPAttr>(rhsAttr).getValue();
1678+
}
1679+
break;
1680+
}
1681+
}
1682+
1683+
elements[i] = cir::IntAttr::get(getType().getElementType(), cmpResult);
1684+
}
1685+
1686+
return cir::ConstVectorAttr::get(
1687+
getType(), mlir::ArrayAttr::get(getContext(), elements));
1688+
}
1689+
15921690
//===----------------------------------------------------------------------===//
15931691
// VecShuffleOp
15941692
//===----------------------------------------------------------------------===//

‎clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -141,7 +141,7 @@ void CIRCanonicalizePass::runOnOperation() {
141141
// Many operations are here to perform a manual `fold` in
142142
// applyOpPatternsGreedily.
143143
if (isa<BrOp, BrCondOp, CastOp, ScopeOp, SwitchOp, SelectOp, UnaryOp,
144-
ComplexCreateOp, VecCreateOp, VecExtractOp, VecShuffleOp,
144+
ComplexCreateOp, VecCmpOp, VecCreateOp, VecExtractOp, VecShuffleOp,
145145
VecShuffleDynamicOp, VecTernaryOp>(op))
146146
ops.push_back(op);
147147
});

‎clang/test/CIR/Transforms/vector-cmp-fold.cir

Lines changed: 227 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,227 @@
1+
// RUN: cir-opt %s -cir-canonicalize -o - -split-input-file | FileCheck %s
2+
3+
!s32i = !cir.int<s, 32>
4+
5+
module {
6+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
7+
%vec_1 = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
8+
%vec_2 = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
9+
%new_vec = cir.vec.cmp(eq, %vec_1, %vec_2) : !cir.vector<4 x !s32i>, !cir.vector<4 x !s32i>
10+
cir.return %new_vec : !cir.vector<4 x !s32i>
11+
}
12+
13+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
14+
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<0> : !s32i, #cir.int<0> : !s32i,
15+
// CHECK-SAME: #cir.int<0> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
16+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
17+
}
18+
19+
// -----
20+
21+
!s32i = !cir.int<s, 32>
22+
23+
module {
24+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
25+
%vec_1 = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
26+
%vec_2 = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
27+
%new_vec = cir.vec.cmp(ne, %vec_1, %vec_2) : !cir.vector<4 x !s32i>, !cir.vector<4 x !s32i>
28+
cir.return %new_vec : !cir.vector<4 x !s32i>
29+
}
30+
31+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
32+
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<1> : !s32i,
33+
// CHECK-SAME: #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.vector<4 x !s32i>
34+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
35+
}
36+
37+
// -----
38+
39+
!s32i = !cir.int<s, 32>
40+
41+
module {
42+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
43+
%vec_1 = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
44+
%vec_2 = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
45+
%new_vec = cir.vec.cmp(lt, %vec_1, %vec_2) : !cir.vector<4 x !s32i>, !cir.vector<4 x !s32i>
46+
cir.return %new_vec : !cir.vector<4 x !s32i>
47+
}
48+
49+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
50+
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<1> : !s32i,
51+
// CHECK-SAME: #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.vector<4 x !s32i>
52+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
53+
}
54+
55+
// -----
56+
57+
!s32i = !cir.int<s, 32>
58+
59+
module {
60+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
61+
%vec_1 = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
62+
%vec_2 = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
63+
%new_vec = cir.vec.cmp(le, %vec_1, %vec_2) : !cir.vector<4 x !s32i>, !cir.vector<4 x !s32i>
64+
cir.return %new_vec : !cir.vector<4 x !s32i>
65+
}
66+
67+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
68+
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<1> : !s32i,
69+
// CHECK-SAME: #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.vector<4 x !s32i>
70+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
71+
}
72+
73+
// -----
74+
75+
!s32i = !cir.int<s, 32>
76+
77+
module {
78+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
79+
%vec_1 = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
80+
%vec_2 = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
81+
%new_vec = cir.vec.cmp(gt, %vec_1, %vec_2) : !cir.vector<4 x !s32i>, !cir.vector<4 x !s32i>
82+
cir.return %new_vec : !cir.vector<4 x !s32i>
83+
}
84+
85+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
86+
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<0> : !s32i, #cir.int<0> : !s32i,
87+
// CHECK-SAME: #cir.int<0> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
88+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
89+
}
90+
91+
// -----
92+
93+
!s32i = !cir.int<s, 32>
94+
95+
module {
96+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
97+
%vec_1 = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<3> : !s32i, #cir.int<5> : !s32i, #cir.int<7> : !s32i]> : !cir.vector<4 x !s32i>
98+
%vec_2 = cir.const #cir.const_vector<[#cir.int<2> : !s32i, #cir.int<4> : !s32i, #cir.int<6> : !s32i, #cir.int<8> : !s32i]> : !cir.vector<4 x !s32i>
99+
%new_vec = cir.vec.cmp(gt, %vec_1, %vec_2) : !cir.vector<4 x !s32i>, !cir.vector<4 x !s32i>
100+
cir.return %new_vec : !cir.vector<4 x !s32i>
101+
}
102+
103+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
104+
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<0> : !s32i, #cir.int<0> : !s32i,
105+
// CHECK-SAME: #cir.int<0> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
106+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
107+
}
108+
109+
// -----
110+
111+
!s32i = !cir.int<s, 32>
112+
113+
module {
114+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
115+
%vec_1 = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00>
116+
: !cir.float, #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
117+
%vec_2 = cir.const #cir.const_vector<[#cir.fp<5.000000e+00> : !cir.float, #cir.fp<6.000000e+00>
118+
: !cir.float, #cir.fp<7.000000e+00> : !cir.float, #cir.fp<8.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
119+
%new_vec = cir.vec.cmp(eq, %vec_1, %vec_2) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
120+
cir.return %new_vec : !cir.vector<4 x !s32i>
121+
}
122+
123+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
124+
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<0> : !s32i, #cir.int<0> : !s32i,
125+
// CHECK-SAME: #cir.int<0> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
126+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
127+
}
128+
129+
// -----
130+
131+
!s32i = !cir.int<s, 32>
132+
133+
module {
134+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
135+
%vec_1 = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00>
136+
: !cir.float, #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
137+
%vec_2 = cir.const #cir.const_vector<[#cir.fp<5.000000e+00> : !cir.float, #cir.fp<6.000000e+00>
138+
: !cir.float, #cir.fp<7.000000e+00> : !cir.float, #cir.fp<8.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
139+
%new_vec = cir.vec.cmp(ne, %vec_1, %vec_2) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
140+
cir.return %new_vec : !cir.vector<4 x !s32i>
141+
}
142+
143+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
144+
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<1> : !s32i,
145+
// CHECK-SAME: #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.vector<4 x !s32i>
146+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
147+
}
148+
149+
// -----
150+
151+
!s32i = !cir.int<s, 32>
152+
153+
module {
154+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
155+
%vec_1 = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00>
156+
: !cir.float, #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
157+
%vec_2 = cir.const #cir.const_vector<[#cir.fp<5.000000e+00> : !cir.float, #cir.fp<6.000000e+00>
158+
: !cir.float, #cir.fp<7.000000e+00> : !cir.float, #cir.fp<8.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
159+
%new_vec = cir.vec.cmp(lt, %vec_1, %vec_2) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
160+
cir.return %new_vec : !cir.vector<4 x !s32i>
161+
}
162+
163+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
164+
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<1> : !s32i,
165+
// CHECK-SAME: #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.vector<4 x !s32i>
166+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
167+
}
168+
169+
// -----
170+
171+
!s32i = !cir.int<s, 32>
172+
173+
module {
174+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
175+
%vec_1 = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00>
176+
: !cir.float, #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
177+
%vec_2 = cir.const #cir.const_vector<[#cir.fp<5.000000e+00> : !cir.float, #cir.fp<6.000000e+00>
178+
: !cir.float, #cir.fp<7.000000e+00> : !cir.float, #cir.fp<8.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
179+
%new_vec = cir.vec.cmp(le, %vec_1, %vec_2) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
180+
cir.return %new_vec : !cir.vector<4 x !s32i>
181+
}
182+
183+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
184+
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<1> : !s32i, #cir.int<1> : !s32i,
185+
// CHECK-SAME: #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.vector<4 x !s32i>
186+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
187+
}
188+
189+
// -----
190+
191+
!s32i = !cir.int<s, 32>
192+
193+
module {
194+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
195+
%vec_1 = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00>
196+
: !cir.float, #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
197+
%vec_2 = cir.const #cir.const_vector<[#cir.fp<5.000000e+00> : !cir.float, #cir.fp<6.000000e+00>
198+
: !cir.float, #cir.fp<7.000000e+00> : !cir.float, #cir.fp<8.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
199+
%new_vec = cir.vec.cmp(gt, %vec_1, %vec_2) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
200+
cir.return %new_vec : !cir.vector<4 x !s32i>
201+
}
202+
203+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
204+
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<0> : !s32i, #cir.int<0> : !s32i,
205+
// CHECK-SAME: #cir.int<0> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
206+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
207+
}
208+
209+
// -----
210+
211+
!s32i = !cir.int<s, 32>
212+
213+
module {
214+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
215+
%vec_1 = cir.const #cir.const_vector<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00>
216+
: !cir.float, #cir.fp<3.000000e+00> : !cir.float, #cir.fp<4.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
217+
%vec_2 = cir.const #cir.const_vector<[#cir.fp<5.000000e+00> : !cir.float, #cir.fp<6.000000e+00>
218+
: !cir.float, #cir.fp<7.000000e+00> : !cir.float, #cir.fp<8.000000e+00> : !cir.float]> : !cir.vector<4 x !cir.float>
219+
%new_vec = cir.vec.cmp(ge, %vec_1, %vec_2) : !cir.vector<4 x !cir.float>, !cir.vector<4 x !s32i>
220+
cir.return %new_vec : !cir.vector<4 x !s32i>
221+
}
222+
223+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<4 x !s32i> {
224+
// CHECK-NEXT: %[[RES:.*]] = cir.const #cir.const_vector<[#cir.int<0> : !s32i, #cir.int<0> : !s32i,
225+
// CHECK-SAME: #cir.int<0> : !s32i, #cir.int<0> : !s32i]> : !cir.vector<4 x !s32i>
226+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<4 x !s32i>
227+
}

0 commit comments

Comments
 (0)