Skip to content

Commit f00083b

Browse files
AmrDeveloperlanza
AmrDeveloper
authored and
lanza
committed
[CIR] Backport VecCmpOp folder (llvm#1709)
Backporting the VecCmpOp folder
1 parent 4ce2895 commit f00083b

File tree

4 files changed

+330
-2
lines changed

4 files changed

+330
-2
lines changed

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

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3220,6 +3220,8 @@ def VecCmpOp : CIR_Op<"vec.cmp", [Pure, SameTypeOperands]> {
32203220
`(` $kind `,` $lhs `,` $rhs `)` `:` qualified(type($lhs)) `,`
32213221
qualified(type($result)) attr-dict
32223222
}];
3223+
3224+
let hasFolder = 1;
32233225
}
32243226

32253227
//===----------------------------------------------------------------------===//

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

Lines changed: 98 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1203,6 +1203,104 @@ LogicalResult cir::VecShuffleDynamicOp::verify() {
12031203
return success();
12041204
}
12051205

1206+
//===----------------------------------------------------------------------===//
1207+
// VecCmpOp
1208+
//===----------------------------------------------------------------------===//
1209+
1210+
OpFoldResult cir::VecCmpOp::fold(FoldAdaptor adaptor) {
1211+
auto lhsVecAttr =
1212+
mlir::dyn_cast_if_present<cir::ConstVectorAttr>(adaptor.getLhs());
1213+
auto rhsVecAttr =
1214+
mlir::dyn_cast_if_present<cir::ConstVectorAttr>(adaptor.getRhs());
1215+
if (!lhsVecAttr || !rhsVecAttr)
1216+
return {};
1217+
1218+
mlir::Type inputElemTy =
1219+
mlir::cast<cir::VectorType>(lhsVecAttr.getType()).getElementType();
1220+
if (!isAnyIntegerOrFloatingPointType(inputElemTy))
1221+
return {};
1222+
1223+
cir::CmpOpKind opKind = adaptor.getKind();
1224+
mlir::ArrayAttr lhsVecElhs = lhsVecAttr.getElts();
1225+
mlir::ArrayAttr rhsVecElhs = rhsVecAttr.getElts();
1226+
uint64_t vecSize = lhsVecElhs.size();
1227+
1228+
SmallVector<mlir::Attribute, 16> elements(vecSize);
1229+
bool isIntAttr = vecSize && mlir::isa<cir::IntAttr>(lhsVecElhs[0]);
1230+
for (uint64_t i = 0; i < vecSize; i++) {
1231+
mlir::Attribute lhsAttr = lhsVecElhs[i];
1232+
mlir::Attribute rhsAttr = rhsVecElhs[i];
1233+
int cmpResult = 0;
1234+
switch (opKind) {
1235+
case cir::CmpOpKind::lt: {
1236+
if (isIntAttr) {
1237+
cmpResult = mlir::cast<cir::IntAttr>(lhsAttr).getSInt() <
1238+
mlir::cast<cir::IntAttr>(rhsAttr).getSInt();
1239+
} else {
1240+
cmpResult = mlir::cast<cir::FPAttr>(lhsAttr).getValue() <
1241+
mlir::cast<cir::FPAttr>(rhsAttr).getValue();
1242+
}
1243+
break;
1244+
}
1245+
case cir::CmpOpKind::le: {
1246+
if (isIntAttr) {
1247+
cmpResult = mlir::cast<cir::IntAttr>(lhsAttr).getSInt() <=
1248+
mlir::cast<cir::IntAttr>(rhsAttr).getSInt();
1249+
} else {
1250+
cmpResult = mlir::cast<cir::FPAttr>(lhsAttr).getValue() <=
1251+
mlir::cast<cir::FPAttr>(rhsAttr).getValue();
1252+
}
1253+
break;
1254+
}
1255+
case cir::CmpOpKind::gt: {
1256+
if (isIntAttr) {
1257+
cmpResult = mlir::cast<cir::IntAttr>(lhsAttr).getSInt() >
1258+
mlir::cast<cir::IntAttr>(rhsAttr).getSInt();
1259+
} else {
1260+
cmpResult = mlir::cast<cir::FPAttr>(lhsAttr).getValue() >
1261+
mlir::cast<cir::FPAttr>(rhsAttr).getValue();
1262+
}
1263+
break;
1264+
}
1265+
case cir::CmpOpKind::ge: {
1266+
if (isIntAttr) {
1267+
cmpResult = mlir::cast<cir::IntAttr>(lhsAttr).getSInt() >=
1268+
mlir::cast<cir::IntAttr>(rhsAttr).getSInt();
1269+
} else {
1270+
cmpResult = mlir::cast<cir::FPAttr>(lhsAttr).getValue() >=
1271+
mlir::cast<cir::FPAttr>(rhsAttr).getValue();
1272+
}
1273+
break;
1274+
}
1275+
case cir::CmpOpKind::eq: {
1276+
if (isIntAttr) {
1277+
cmpResult = mlir::cast<cir::IntAttr>(lhsAttr).getSInt() ==
1278+
mlir::cast<cir::IntAttr>(rhsAttr).getSInt();
1279+
} else {
1280+
cmpResult = mlir::cast<cir::FPAttr>(lhsAttr).getValue() ==
1281+
mlir::cast<cir::FPAttr>(rhsAttr).getValue();
1282+
}
1283+
break;
1284+
}
1285+
case cir::CmpOpKind::ne: {
1286+
if (isIntAttr) {
1287+
cmpResult = mlir::cast<cir::IntAttr>(lhsAttr).getSInt() !=
1288+
mlir::cast<cir::IntAttr>(rhsAttr).getSInt();
1289+
} else {
1290+
cmpResult = mlir::cast<cir::FPAttr>(lhsAttr).getValue() !=
1291+
mlir::cast<cir::FPAttr>(rhsAttr).getValue();
1292+
}
1293+
break;
1294+
}
1295+
}
1296+
1297+
elements[i] = cir::IntAttr::get(getType().getElementType(), cmpResult);
1298+
}
1299+
1300+
return cir::ConstVectorAttr::get(
1301+
getType(), mlir::ArrayAttr::get(getContext(), elements));
1302+
}
1303+
12061304
//===----------------------------------------------------------------------===//
12071305
// VecExtractOp
12081306
//===----------------------------------------------------------------------===//

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

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -179,8 +179,9 @@ void CIRCanonicalizePass::runOnOperation() {
179179
// CastOp, UnaryOp and VecExtractOp are here to perform a manual `fold` in
180180
// applyOpPatternsGreedily.
181181
if (isa<BrOp, BrCondOp, ScopeOp, SwitchOp, CastOp, TryOp, UnaryOp, SelectOp,
182-
ComplexCreateOp, ComplexRealOp, ComplexImagOp, CallOp, VecCreateOp,
183-
VecExtractOp, VecShuffleOp, VecShuffleDynamicOp, VecTernaryOp>(op))
182+
ComplexCreateOp, ComplexRealOp, ComplexImagOp, CallOp, VecCmpOp,
183+
VecCreateOp, VecExtractOp, VecShuffleOp, VecShuffleDynamicOp,
184+
VecTernaryOp>(op))
184185
ops.push_back(op);
185186
});
186187

‎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<!s32i x 4> {
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<!s32i x 4>
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<!s32i x 4>
9+
%new_vec = cir.vec.cmp(eq, %vec_1, %vec_2) : !cir.vector<!s32i x 4>, !cir.vector<!s32i x 4>
10+
cir.return %new_vec : !cir.vector<!s32i x 4>
11+
}
12+
13+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
16+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<!s32i x 4>
17+
}
18+
19+
// -----
20+
21+
!s32i = !cir.int<s, 32>
22+
23+
module {
24+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
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<!s32i x 4>
27+
%new_vec = cir.vec.cmp(ne, %vec_1, %vec_2) : !cir.vector<!s32i x 4>, !cir.vector<!s32i x 4>
28+
cir.return %new_vec : !cir.vector<!s32i x 4>
29+
}
30+
31+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
34+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<!s32i x 4>
35+
}
36+
37+
// -----
38+
39+
!s32i = !cir.int<s, 32>
40+
41+
module {
42+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
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<!s32i x 4>
45+
%new_vec = cir.vec.cmp(lt, %vec_1, %vec_2) : !cir.vector<!s32i x 4>, !cir.vector<!s32i x 4>
46+
cir.return %new_vec : !cir.vector<!s32i x 4>
47+
}
48+
49+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
52+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<!s32i x 4>
53+
}
54+
55+
// -----
56+
57+
!s32i = !cir.int<s, 32>
58+
59+
module {
60+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
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<!s32i x 4>
63+
%new_vec = cir.vec.cmp(le, %vec_1, %vec_2) : !cir.vector<!s32i x 4>, !cir.vector<!s32i x 4>
64+
cir.return %new_vec : !cir.vector<!s32i x 4>
65+
}
66+
67+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
70+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<!s32i x 4>
71+
}
72+
73+
// -----
74+
75+
!s32i = !cir.int<s, 32>
76+
77+
module {
78+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
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<!s32i x 4>
81+
%new_vec = cir.vec.cmp(gt, %vec_1, %vec_2) : !cir.vector<!s32i x 4>, !cir.vector<!s32i x 4>
82+
cir.return %new_vec : !cir.vector<!s32i x 4>
83+
}
84+
85+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
88+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<!s32i x 4>
89+
}
90+
91+
// -----
92+
93+
!s32i = !cir.int<s, 32>
94+
95+
module {
96+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
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<!s32i x 4>
99+
%new_vec = cir.vec.cmp(gt, %vec_1, %vec_2) : !cir.vector<!s32i x 4>, !cir.vector<!s32i x 4>
100+
cir.return %new_vec : !cir.vector<!s32i x 4>
101+
}
102+
103+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
106+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<!s32i x 4>
107+
}
108+
109+
// -----
110+
111+
!s32i = !cir.int<s, 32>
112+
113+
module {
114+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!cir.float x 4>
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<!cir.float x 4>
119+
%new_vec = cir.vec.cmp(eq, %vec_1, %vec_2) : !cir.vector<!cir.float x 4>, !cir.vector<!s32i x 4>
120+
cir.return %new_vec : !cir.vector<!s32i x 4>
121+
}
122+
123+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
126+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<!s32i x 4>
127+
}
128+
129+
// -----
130+
131+
!s32i = !cir.int<s, 32>
132+
133+
module {
134+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!cir.float x 4>
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<!cir.float x 4>
139+
%new_vec = cir.vec.cmp(ne, %vec_1, %vec_2) : !cir.vector<!cir.float x 4>, !cir.vector<!s32i x 4>
140+
cir.return %new_vec : !cir.vector<!s32i x 4>
141+
}
142+
143+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
146+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<!s32i x 4>
147+
}
148+
149+
// -----
150+
151+
!s32i = !cir.int<s, 32>
152+
153+
module {
154+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!cir.float x 4>
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<!cir.float x 4>
159+
%new_vec = cir.vec.cmp(lt, %vec_1, %vec_2) : !cir.vector<!cir.float x 4>, !cir.vector<!s32i x 4>
160+
cir.return %new_vec : !cir.vector<!s32i x 4>
161+
}
162+
163+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
166+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<!s32i x 4>
167+
}
168+
169+
// -----
170+
171+
!s32i = !cir.int<s, 32>
172+
173+
module {
174+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!cir.float x 4>
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<!cir.float x 4>
179+
%new_vec = cir.vec.cmp(le, %vec_1, %vec_2) : !cir.vector<!cir.float x 4>, !cir.vector<!s32i x 4>
180+
cir.return %new_vec : !cir.vector<!s32i x 4>
181+
}
182+
183+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
186+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<!s32i x 4>
187+
}
188+
189+
// -----
190+
191+
!s32i = !cir.int<s, 32>
192+
193+
module {
194+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!cir.float x 4>
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<!cir.float x 4>
199+
%new_vec = cir.vec.cmp(gt, %vec_1, %vec_2) : !cir.vector<!cir.float x 4>, !cir.vector<!s32i x 4>
200+
cir.return %new_vec : !cir.vector<!s32i x 4>
201+
}
202+
203+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
206+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<!s32i x 4>
207+
}
208+
209+
// -----
210+
211+
!s32i = !cir.int<s, 32>
212+
213+
module {
214+
cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!cir.float x 4>
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<!cir.float x 4>
219+
%new_vec = cir.vec.cmp(ge, %vec_1, %vec_2) : !cir.vector<!cir.float x 4>, !cir.vector<!s32i x 4>
220+
cir.return %new_vec : !cir.vector<!s32i x 4>
221+
}
222+
223+
// CHECK: cir.func @fold_cmp_vector_op_test() -> !cir.vector<!s32i x 4> {
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<!s32i x 4>
226+
// CHECK-NEXT: cir.return %[[RES]] : !cir.vector<!s32i x 4>
227+
}

0 commit comments

Comments
 (0)