Skip to content

Commit 8829868

Browse files
mingshi2333mingshi2333
authored
[CIR][CodeGen] Fix missing 'nsw' flag in add, sub, and mul in binop operator (#677)
This PR is to fix the missing **nsw** flag in issue #664 regarding add, mul arithmetic operations. there is also a problem with unary operations such as **Inc ,Dec,Plus,Minus and Not** . which should also have 'nsw' flag [example](https://godbolt.org/z/q3o3jsbe1). This part should need to be fixed through lowering.
1 parent e3f3124 commit 8829868

17 files changed

+178
-47
lines changed

‎clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h

+37-2
Original file line numberDiff line numberDiff line change
@@ -171,8 +171,21 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
171171
return createBinop(lhs, mlir::cir::BinOpKind::Or, rhs);
172172
}
173173

174-
mlir::Value createMul(mlir::Value lhs, mlir::Value rhs) {
175-
return createBinop(lhs, mlir::cir::BinOpKind::Mul, rhs);
174+
mlir::Value createMul(mlir::Value lhs, mlir::Value rhs, bool hasNUW = false,
175+
bool hasNSW = false) {
176+
auto op = create<mlir::cir::BinOp>(lhs.getLoc(), lhs.getType(),
177+
mlir::cir::BinOpKind::Mul, lhs, rhs);
178+
if (hasNUW)
179+
op.setNoUnsignedWrap(true);
180+
if (hasNSW)
181+
op.setNoSignedWrap(true);
182+
return op;
183+
}
184+
mlir::Value createNSWMul(mlir::Value lhs, mlir::Value rhs) {
185+
return createMul(lhs, rhs, false, true);
186+
}
187+
mlir::Value createNUWAMul(mlir::Value lhs, mlir::Value rhs) {
188+
return createMul(lhs, rhs, true, false);
176189
}
177190

178191
mlir::Value createMul(mlir::Value lhs, llvm::APInt rhs) {
@@ -235,6 +248,28 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
235248
return createSub(lhs, rhs, false, true);
236249
}
237250

251+
mlir::Value createNUWSub(mlir::Value lhs, mlir::Value rhs) {
252+
return createSub(lhs, rhs, true, false);
253+
}
254+
255+
mlir::Value createAdd(mlir::Value lhs, mlir::Value rhs, bool hasNUW = false,
256+
bool hasNSW = false) {
257+
auto op = create<mlir::cir::BinOp>(lhs.getLoc(), lhs.getType(),
258+
mlir::cir::BinOpKind::Add, lhs, rhs);
259+
if (hasNUW)
260+
op.setNoUnsignedWrap(true);
261+
if (hasNSW)
262+
op.setNoSignedWrap(true);
263+
return op;
264+
}
265+
266+
mlir::Value createNSWAdd(mlir::Value lhs, mlir::Value rhs) {
267+
return createAdd(lhs, rhs, false, true);
268+
}
269+
mlir::Value createNUWAdd(mlir::Value lhs, mlir::Value rhs) {
270+
return createAdd(lhs, rhs, true, false);
271+
}
272+
238273
struct BinOpOverflowResults {
239274
mlir::Value result;
240275
mlir::Value overflow;

‎clang/include/clang/CIR/Dialect/IR/CIRTypes.h

+1-1
Original file line numberDiff line numberDiff line change
@@ -177,7 +177,7 @@ class StructType
177177
};
178178

179179
bool isAnyFloatingPointType(mlir::Type t);
180-
180+
bool isFPOrFPVectorTy(mlir::Type);
181181
} // namespace cir
182182
} // namespace mlir
183183

‎clang/lib/CIR/CodeGen/CIRGenBuilder.h

+19
Original file line numberDiff line numberDiff line change
@@ -648,6 +648,25 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
648648
lhs, rhs);
649649
}
650650

651+
mlir::Value createFAdd(mlir::Value lhs, mlir::Value rhs) {
652+
assert(!MissingFeatures::metaDataNode());
653+
if (IsFPConstrained)
654+
llvm_unreachable("Constrained FP NYI");
655+
656+
assert(!MissingFeatures::foldBinOpFMF());
657+
return create<mlir::cir::BinOp>(lhs.getLoc(), mlir::cir::BinOpKind::Add,
658+
lhs, rhs);
659+
}
660+
mlir::Value createFMul(mlir::Value lhs, mlir::Value rhs) {
661+
assert(!MissingFeatures::metaDataNode());
662+
if (IsFPConstrained)
663+
llvm_unreachable("Constrained FP NYI");
664+
665+
assert(!MissingFeatures::foldBinOpFMF());
666+
return create<mlir::cir::BinOp>(lhs.getLoc(), mlir::cir::BinOpKind::Mul,
667+
lhs, rhs);
668+
}
669+
651670
mlir::Value createDynCast(mlir::Location loc, mlir::Value src,
652671
mlir::cir::PointerType destType, bool isRefCast,
653672
mlir::cir::DynamicCastInfoAttr info) {

‎clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

+66-1
Original file line numberDiff line numberDiff line change
@@ -1289,6 +1289,38 @@ static mlir::Value buildPointerArithmetic(CIRGenFunction &CGF,
12891289
}
12901290

12911291
mlir::Value ScalarExprEmitter::buildMul(const BinOpInfo &Ops) {
1292+
if (Ops.CompType->isSignedIntegerOrEnumerationType()) {
1293+
switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
1294+
case LangOptions::SOB_Defined:
1295+
if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
1296+
return Builder.createMul(Ops.LHS, Ops.RHS);
1297+
[[fallthrough]];
1298+
case LangOptions::SOB_Undefined:
1299+
if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
1300+
return Builder.createNSWMul(Ops.LHS, Ops.RHS);
1301+
[[fallthrough]];
1302+
case LangOptions::SOB_Trapping:
1303+
if (CanElideOverflowCheck(CGF.getContext(), Ops))
1304+
return Builder.createNSWMul(Ops.LHS, Ops.RHS);
1305+
llvm_unreachable("NYI");
1306+
}
1307+
}
1308+
if (Ops.FullType->isConstantMatrixType()) {
1309+
llvm_unreachable("NYI");
1310+
}
1311+
if (Ops.CompType->isUnsignedIntegerType() &&
1312+
CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
1313+
!CanElideOverflowCheck(CGF.getContext(), Ops))
1314+
llvm_unreachable("NYI");
1315+
1316+
if (mlir::cir::isFPOrFPVectorTy(Ops.LHS.getType())) {
1317+
CIRGenFunction::CIRGenFPOptionsRAII FPOptsRAII(CGF, Ops.FPFeatures);
1318+
return Builder.createFMul(Ops.LHS, Ops.RHS);
1319+
}
1320+
1321+
if (Ops.isFixedPointOp())
1322+
llvm_unreachable("NYI");
1323+
12921324
return Builder.create<mlir::cir::BinOp>(
12931325
CGF.getLoc(Ops.Loc), CGF.getCIRType(Ops.FullType),
12941326
mlir::cir::BinOpKind::Mul, Ops.LHS, Ops.RHS);
@@ -1308,6 +1340,39 @@ mlir::Value ScalarExprEmitter::buildAdd(const BinOpInfo &Ops) {
13081340
if (Ops.LHS.getType().isa<mlir::cir::PointerType>() ||
13091341
Ops.RHS.getType().isa<mlir::cir::PointerType>())
13101342
return buildPointerArithmetic(CGF, Ops, /*isSubtraction=*/false);
1343+
if (Ops.CompType->isSignedIntegerOrEnumerationType()) {
1344+
switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
1345+
case LangOptions::SOB_Defined:
1346+
if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
1347+
return Builder.createAdd(Ops.LHS, Ops.RHS);
1348+
[[fallthrough]];
1349+
case LangOptions::SOB_Undefined:
1350+
if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
1351+
return Builder.createNSWAdd(Ops.LHS, Ops.RHS);
1352+
[[fallthrough]];
1353+
case LangOptions::SOB_Trapping:
1354+
if (CanElideOverflowCheck(CGF.getContext(), Ops))
1355+
return Builder.createNSWAdd(Ops.LHS, Ops.RHS);
1356+
1357+
llvm_unreachable("NYI");
1358+
}
1359+
}
1360+
if (Ops.FullType->isConstantMatrixType()) {
1361+
llvm_unreachable("NYI");
1362+
}
1363+
1364+
if (Ops.CompType->isUnsignedIntegerType() &&
1365+
CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
1366+
!CanElideOverflowCheck(CGF.getContext(), Ops))
1367+
llvm_unreachable("NYI");
1368+
1369+
if (mlir::cir::isFPOrFPVectorTy(Ops.LHS.getType())) {
1370+
CIRGenFunction::CIRGenFPOptionsRAII FPOptsRAII(CGF, Ops.FPFeatures);
1371+
return Builder.createFAdd(Ops.LHS, Ops.RHS);
1372+
}
1373+
1374+
if (Ops.isFixedPointOp())
1375+
llvm_unreachable("NYI");
13111376

13121377
return Builder.create<mlir::cir::BinOp>(
13131378
CGF.getLoc(Ops.Loc), CGF.getCIRType(Ops.FullType),
@@ -1344,7 +1409,7 @@ mlir::Value ScalarExprEmitter::buildSub(const BinOpInfo &Ops) {
13441409
!CanElideOverflowCheck(CGF.getContext(), Ops))
13451410
llvm_unreachable("NYI");
13461411

1347-
if (Ops.CompType->isFloatingType()) {
1412+
if (mlir::cir::isFPOrFPVectorTy(Ops.LHS.getType())) {
13481413
CIRGenFunction::CIRGenFPOptionsRAII FPOptsRAII(CGF, Ops.FPFeatures);
13491414
return Builder.createFSub(Ops.LHS, Ops.RHS);
13501415
}

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

+13
Original file line numberDiff line numberDiff line change
@@ -803,6 +803,19 @@ bool mlir::cir::isAnyFloatingPointType(mlir::Type t) {
803803
mlir::cir::LongDoubleType, mlir::cir::FP80Type>(t);
804804
}
805805

806+
//===----------------------------------------------------------------------===//
807+
// Floating-point and Float-point Vecotr type helpers
808+
//===----------------------------------------------------------------------===//
809+
810+
bool mlir::cir::isFPOrFPVectorTy(mlir::Type t) {
811+
812+
if (isa<mlir::cir::VectorType>(t)) {
813+
return isAnyFloatingPointType(
814+
t.dyn_cast<mlir::cir::VectorType>().getEltType());
815+
}
816+
return isAnyFloatingPointType(t);
817+
}
818+
806819
//===----------------------------------------------------------------------===//
807820
// FuncType Definitions
808821
//===----------------------------------------------------------------------===//

‎clang/test/CIR/CodeGen/binop.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -14,10 +14,10 @@ void b0(int a, int b) {
1414
x = x | b;
1515
}
1616

17-
// CHECK: = cir.binop(mul, %3, %4) : !s32i
17+
// CHECK: = cir.binop(mul, %3, %4) nsw : !s32i
1818
// CHECK: = cir.binop(div, %6, %7) : !s32i
1919
// CHECK: = cir.binop(rem, %9, %10) : !s32i
20-
// CHECK: = cir.binop(add, %12, %13) : !s32i
20+
// CHECK: = cir.binop(add, %12, %13) nsw : !s32i
2121
// CHECK: = cir.binop(sub, %15, %16) nsw : !s32i
2222
// CHECK: = cir.shift( right, %18 : !s32i, %19 : !s32i) -> !s32i
2323
// CHECK: = cir.shift(left, %21 : !s32i, %22 : !s32i) -> !s32i

‎clang/test/CIR/CodeGen/bitint.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ i10 test_arith(i10 lhs, i10 rhs) {
4747
// CHECK: cir.func @_Z10test_arithDB10_S_(%arg0: !cir.int<s, 10> loc({{.+}}), %arg1: !cir.int<s, 10> loc({{.+}})) -> !cir.int<s, 10>
4848
// CHECK: %[[#LHS:]] = cir.load %{{.+}} : !cir.ptr<!cir.int<s, 10>>, !cir.int<s, 10>
4949
// CHECK-NEXT: %[[#RHS:]] = cir.load %{{.+}} : !cir.ptr<!cir.int<s, 10>>, !cir.int<s, 10>
50-
// CHECK-NEXT: %{{.+}} = cir.binop(add, %[[#LHS]], %[[#RHS]]) : !cir.int<s, 10>
50+
// CHECK-NEXT: %{{.+}} = cir.binop(add, %[[#LHS]], %[[#RHS]]) nsw : !cir.int<s, 10>
5151
// CHECK: }
5252

5353
void Size1ExtIntParam(unsigned _BitInt(1) A) {

‎clang/test/CIR/CodeGen/call.c

+2-2
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@ void d(void) {
2626
// CHECK: cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
2727
// CHECK: %3 = cir.load %0 : !cir.ptr<!s32i>, !s32i
2828
// CHECK: %4 = cir.load %1 : !cir.ptr<!s32i>, !s32i
29-
// CHECK: %5 = cir.binop(add, %3, %4) : !s32i
29+
// CHECK: %5 = cir.binop(add, %3, %4) nsw : !s32i
3030
// CHECK: cir.store %5, %2 : !s32i, !cir.ptr<!s32i>
3131
// CHECK: %6 = cir.load %2 : !cir.ptr<!s32i>, !s32i
3232
// CHECK: cir.return %6
@@ -64,7 +64,7 @@ void d(void) {
6464
// CXX-NEXT: cir.store %arg1, %1 : !s32i, !cir.ptr<!s32i>
6565
// CXX-NEXT: %3 = cir.load %0 : !cir.ptr<!s32i>, !s32i
6666
// CXX-NEXT: %4 = cir.load %1 : !cir.ptr<!s32i>, !s32i
67-
// CXX-NEXT: %5 = cir.binop(add, %3, %4) : !s32i
67+
// CXX-NEXT: %5 = cir.binop(add, %3, %4) nsw : !s32i
6868
// CXX-NEXT: cir.store %5, %2 : !s32i, !cir.ptr<!s32i>
6969
// CXX-NEXT: %6 = cir.load %2 : !cir.ptr<!s32i>, !s32i
7070
// CXX-NEXT: cir.return %6

‎clang/test/CIR/CodeGen/comma.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ int c0() {
1212
// CHECK: %[[#A:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init]
1313
// CHECK: %[[#B:]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init]
1414
// CHECK: %[[#LOADED_B:]] = cir.load %[[#B]] : !cir.ptr<!s32i>, !s32i
15-
// CHECK: %[[#]] = cir.binop(add, %[[#LOADED_B]], %[[#]]) : !s32i
15+
// CHECK: %[[#]] = cir.binop(add, %[[#LOADED_B]], %[[#]]) nsw : !s32i
1616
// CHECK: %[[#LOADED_A:]] = cir.load %[[#A]] : !cir.ptr<!s32i>, !s32i
1717
// CHECK: cir.store %[[#LOADED_A]], %[[#RET]] : !s32i, !cir.ptr<!s32i>
1818

‎clang/test/CIR/CodeGen/if-constexpr.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -66,7 +66,7 @@ void if0() {
6666
// CHECK-NEXT: cir.store %4, %2 : !s32i, !cir.ptr<!s32i> loc({{.*}})
6767
// CHECK-NEXT: %5 = cir.const #cir.int<3> : !s32i loc({{.*}})
6868
// CHECK-NEXT: %6 = cir.load %2 : !cir.ptr<!s32i>, !s32i loc({{.*}})
69-
// CHECK-NEXT: %7 = cir.binop(mul, %5, %6) : !s32i loc({{.*}})
69+
// CHECK-NEXT: %7 = cir.binop(mul, %5, %6) nsw : !s32i loc({{.*}})
7070
// CHECK-NEXT: cir.store %7, %3 : !s32i, !cir.ptr<!s32i> loc({{.*}})
7171
// CHECK-NEXT: } loc({{.*}})
7272
// CHECK-NEXT: cir.scope {
@@ -84,7 +84,7 @@ void if0() {
8484
// CHECK-NEXT: cir.store %4, %2 : !s32i, !cir.ptr<!s32i> loc({{.*}})
8585
// CHECK-NEXT: %5 = cir.const #cir.int<10> : !s32i loc({{.*}})
8686
// CHECK-NEXT: %6 = cir.load %2 : !cir.ptr<!s32i>, !s32i loc({{.*}})
87-
// CHECK-NEXT: %7 = cir.binop(mul, %5, %6) : !s32i loc({{.*}})
87+
// CHECK-NEXT: %7 = cir.binop(mul, %5, %6) nsw : !s32i loc({{.*}})
8888
// CHECK-NEXT: cir.store %7, %3 : !s32i, !cir.ptr<!s32i> loc({{.*}})
8989
// CHECK-NEXT: } loc({{.*}})
9090
// CHECK-NEXT: cir.scope {

‎clang/test/CIR/CodeGen/lambda.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ void l0() {
3030
// CHECK: %3 = cir.load %2 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
3131
// CHECK: %4 = cir.load %3 : !cir.ptr<!s32i>, !s32i
3232
// CHECK: %5 = cir.const #cir.int<1> : !s32i
33-
// CHECK: %6 = cir.binop(add, %4, %5) : !s32i
33+
// CHECK: %6 = cir.binop(add, %4, %5) nsw : !s32i
3434
// CHECK: %7 = cir.get_member %1[0] {name = "i"} : !cir.ptr<!ty_22anon2E422> -> !cir.ptr<!cir.ptr<!s32i>>
3535
// CHECK: %8 = cir.load %7 : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
3636
// CHECK: cir.store %6, %8 : !s32i, !cir.ptr<!s32i>

‎clang/test/CIR/CodeGen/loop.cpp

+9-9
Original file line numberDiff line numberDiff line change
@@ -27,13 +27,13 @@ void l1() {
2727
// CHECK-NEXT: } body {
2828
// CHECK-NEXT: %4 = cir.load %0 : !cir.ptr<!s32i>, !s32i
2929
// CHECK-NEXT: %5 = cir.const #cir.int<1> : !s32i
30-
// CHECK-NEXT: %6 = cir.binop(add, %4, %5) : !s32i
30+
// CHECK-NEXT: %6 = cir.binop(add, %4, %5) nsw : !s32i
3131
// CHECK-NEXT: cir.store %6, %0 : !s32i, !cir.ptr<!s32i>
3232
// CHECK-NEXT: cir.yield
3333
// CHECK-NEXT: } step {
3434
// CHECK-NEXT: %4 = cir.load %2 : !cir.ptr<!s32i>, !s32i
3535
// CHECK-NEXT: %5 = cir.const #cir.int<1> : !s32i
36-
// CHECK-NEXT: %6 = cir.binop(add, %4, %5) : !s32i
36+
// CHECK-NEXT: %6 = cir.binop(add, %4, %5) nsw : !s32i
3737
// CHECK-NEXT: cir.store %6, %2 : !s32i, !cir.ptr<!s32i>
3838
// CHECK-NEXT: cir.yield
3939
// CHECK-NEXT: }
@@ -59,7 +59,7 @@ void l2(bool cond) {
5959
// CHECK-NEXT: } do {
6060
// CHECK-NEXT: %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
6161
// CHECK-NEXT: %4 = cir.const #cir.int<1> : !s32i
62-
// CHECK-NEXT: %5 = cir.binop(add, %3, %4) : !s32i
62+
// CHECK-NEXT: %5 = cir.binop(add, %3, %4) nsw : !s32i
6363
// CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr<!s32i>
6464
// CHECK-NEXT: cir.yield
6565
// CHECK-NEXT: }
@@ -71,7 +71,7 @@ void l2(bool cond) {
7171
// CHECK-NEXT: } do {
7272
// CHECK-NEXT: %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
7373
// CHECK-NEXT: %4 = cir.const #cir.int<1> : !s32i
74-
// CHECK-NEXT: %5 = cir.binop(add, %3, %4) : !s32i
74+
// CHECK-NEXT: %5 = cir.binop(add, %3, %4) nsw : !s32i
7575
// CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr<!s32i>
7676
// CHECK-NEXT: cir.yield
7777
// CHECK-NEXT: }
@@ -84,7 +84,7 @@ void l2(bool cond) {
8484
// CHECK-NEXT: } do {
8585
// CHECK-NEXT: %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
8686
// CHECK-NEXT: %4 = cir.const #cir.int<1> : !s32i
87-
// CHECK-NEXT: %5 = cir.binop(add, %3, %4) : !s32i
87+
// CHECK-NEXT: %5 = cir.binop(add, %3, %4) nsw : !s32i
8888
// CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr<!s32i>
8989
// CHECK-NEXT: cir.yield
9090
// CHECK-NEXT: }
@@ -108,7 +108,7 @@ void l3(bool cond) {
108108
// CHECK-NEXT: cir.do {
109109
// CHECK-NEXT: %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
110110
// CHECK-NEXT: %4 = cir.const #cir.int<1> : !s32i
111-
// CHECK-NEXT: %5 = cir.binop(add, %3, %4) : !s32i
111+
// CHECK-NEXT: %5 = cir.binop(add, %3, %4) nsw : !s32i
112112
// CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr<!s32i>
113113
// CHECK-NEXT: cir.yield
114114
// CHECK-NEXT: } while {
@@ -120,7 +120,7 @@ void l3(bool cond) {
120120
// CHECK-NEXT: cir.do {
121121
// CHECK-NEXT: %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
122122
// CHECK-NEXT: %4 = cir.const #cir.int<1> : !s32i
123-
// CHECK-NEXT: %5 = cir.binop(add, %3, %4) : !s32i
123+
// CHECK-NEXT: %5 = cir.binop(add, %3, %4) nsw : !s32i
124124
// CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr<!s32i>
125125
// CHECK-NEXT: cir.yield
126126
// CHECK-NEXT: } while {
@@ -132,7 +132,7 @@ void l3(bool cond) {
132132
// CHECK-NEXT: cir.do {
133133
// CHECK-NEXT: %3 = cir.load %1 : !cir.ptr<!s32i>, !s32i
134134
// CHECK-NEXT: %4 = cir.const #cir.int<1> : !s32i
135-
// CHECK-NEXT: %5 = cir.binop(add, %3, %4) : !s32i
135+
// CHECK-NEXT: %5 = cir.binop(add, %3, %4) nsw : !s32i
136136
// CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr<!s32i>
137137
// CHECK-NEXT: cir.yield
138138
// CHECK-NEXT: } while {
@@ -159,7 +159,7 @@ void l4() {
159159
// CHECK-NEXT: } do {
160160
// CHECK-NEXT: %4 = cir.load %0 : !cir.ptr<!s32i>, !s32i
161161
// CHECK-NEXT: %5 = cir.const #cir.int<1> : !s32i
162-
// CHECK-NEXT: %6 = cir.binop(add, %4, %5) : !s32i
162+
// CHECK-NEXT: %6 = cir.binop(add, %4, %5) nsw : !s32i
163163
// CHECK-NEXT: cir.store %6, %0 : !s32i, !cir.ptr<!s32i>
164164
// CHECK-NEXT: cir.scope {
165165
// CHECK-NEXT: %10 = cir.load %0 : !cir.ptr<!s32i>, !s32i

0 commit comments

Comments
 (0)