Skip to content

Commit e45e40f

Browse files
AmrDeveloperAmrDeveloper
committed
[CIR] Implement folder for VecCmpOp
1 parent 6baaa0a commit e45e40f

File tree

4 files changed

+333
-1
lines changed

4 files changed

+333
-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
@@ -2154,6 +2154,8 @@ def VecCmpOp : CIR_Op<"vec.cmp", [Pure, SameTypeOperands]> {
21542154
`(` $kind `,` $lhs `,` $rhs `)` `:` qualified(type($lhs)) `,`
21552155
qualified(type($result)) attr-dict
21562156
}];
2157+
2158+
let hasFolder = 1;
21572159
}
21582160

21592161
//===----------------------------------------------------------------------===//

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

Lines changed: 103 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1579,6 +1579,109 @@ OpFoldResult cir::VecExtractOp::fold(FoldAdaptor adaptor) {
15791579
return elements[index];
15801580
}
15811581

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

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

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

‎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)