[Mlir-commits] [mlir] [mlir][Interfaces] Track and infer no-overflow flags in integer ranges (PR #191777)

[llvmlistbot at llvm.org]

github-actions[bot] wrote:

<!--LLVM CODE FORMAT COMMENT: {clang-format}-->


:warning: C/C++ code formatter, clang-format found issues in your code. :warning:

<details>
<summary>
You can test this locally with the following command:
</summary>

``````````bash
git-clang-format --diff origin/main HEAD --extensions cpp,h -- mlir/include/mlir/Interfaces/InferIntRangeInterface.h mlir/include/mlir/Interfaces/Utils/InferIntRangeCommon.h mlir/lib/Analysis/DataFlow/StridedMetadataRangeAnalysis.cpp mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp mlir/lib/Interfaces/InferIntRangeInterface.cpp mlir/unittests/Interfaces/InferIntRangeInterfaceTest.cpp --diff_from_common_commit
``````````

:warning:
The reproduction instructions above might return results for more than one PR
in a stack if you are using a stacked PR workflow. You can limit the results by
changing `origin/main` to the base branch/commit you want to compare against.
:warning:

</details>

<details>
<summary>
View the diff from clang-format here.
</summary>

``````````diff
diff --git a/mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp b/mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp
index db17d35b0..37b348df5 100644
--- a/mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp
+++ b/mlir/lib/Dialect/Arith/IR/InferIntRangeInterfaceImpls.cpp
@@ -153,11 +153,10 @@ void arith::ConstantOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
 
 void arith::AddIOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
                                       SetIntRangeFn setResultRange) {
-  ConstantIntRanges range = inferAdd(argRanges, convertArithOverflowFlags(
-                                                    getOverflowFlags()));
-  OverflowFlags noOverflowFlags =
-      proveNoOverflowForAdd(argRanges) |
-      convertArithOverflowFlags(getOverflowFlags());
+  ConstantIntRanges range =
+      inferAdd(argRanges, convertArithOverflowFlags(getOverflowFlags()));
+  OverflowFlags noOverflowFlags = proveNoOverflowForAdd(argRanges) |
+                                  convertArithOverflowFlags(getOverflowFlags());
   setResultRange(getResult(), range.withOverflowFlags(noOverflowFlags));
 }
 
@@ -167,11 +166,10 @@ void arith::AddIOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
 
 void arith::SubIOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
                                       SetIntRangeFn setResultRange) {
-  ConstantIntRanges range = inferSub(argRanges, convertArithOverflowFlags(
-                                                    getOverflowFlags()));
-  OverflowFlags noOverflowFlags =
-      proveNoOverflowForSub(argRanges) |
-      convertArithOverflowFlags(getOverflowFlags());
+  ConstantIntRanges range =
+      inferSub(argRanges, convertArithOverflowFlags(getOverflowFlags()));
+  OverflowFlags noOverflowFlags = proveNoOverflowForSub(argRanges) |
+                                  convertArithOverflowFlags(getOverflowFlags());
   setResultRange(getResult(), range.withOverflowFlags(noOverflowFlags));
 }
 
@@ -181,11 +179,10 @@ void arith::SubIOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
 
 void arith::MulIOp::inferResultRanges(ArrayRef<ConstantIntRanges> argRanges,
                                       SetIntRangeFn setResultRange) {
-  ConstantIntRanges range = inferMul(argRanges, convertArithOverflowFlags(
-                                                    getOverflowFlags()));
-  OverflowFlags noOverflowFlags =
-      proveNoOverflowForMul(argRanges) |
-      convertArithOverflowFlags(getOverflowFlags());
+  ConstantIntRanges range =
+      inferMul(argRanges, convertArithOverflowFlags(getOverflowFlags()));
+  OverflowFlags noOverflowFlags = proveNoOverflowForMul(argRanges) |
+                                  convertArithOverflowFlags(getOverflowFlags());
   setResultRange(getResult(), range.withOverflowFlags(noOverflowFlags));
 }
 
diff --git a/mlir/lib/Interfaces/InferIntRangeInterface.cpp b/mlir/lib/Interfaces/InferIntRangeInterface.cpp
index 327f3ed17..a7718e0db 100644
--- a/mlir/lib/Interfaces/InferIntRangeInterface.cpp
+++ b/mlir/lib/Interfaces/InferIntRangeInterface.cpp
@@ -95,8 +95,7 @@ ConstantIntRanges::rangeUnion(const ConstantIntRanges &other) const {
   const APInt &umaxUnion = umax().ugt(other.umax()) ? umax() : other.umax();
   const APInt &sminUnion = smin().slt(other.smin()) ? smin() : other.smin();
   const APInt &smaxUnion = smax().sgt(other.smax()) ? smax() : other.smax();
-  OverflowFlags noOverflowUnion =
-      getOverflowFlags() & other.getOverflowFlags();
+  OverflowFlags noOverflowUnion = getOverflowFlags() & other.getOverflowFlags();
 
   return {uminUnion, umaxUnion, sminUnion, smaxUnion, noOverflowUnion};
 }
diff --git a/mlir/unittests/Interfaces/InferIntRangeInterfaceTest.cpp b/mlir/unittests/Interfaces/InferIntRangeInterfaceTest.cpp
index 19890a2d9..c4a7c3e88 100644
--- a/mlir/unittests/Interfaces/InferIntRangeInterfaceTest.cpp
+++ b/mlir/unittests/Interfaces/InferIntRangeInterfaceTest.cpp
@@ -112,18 +112,15 @@ TEST(IntRangeAttrs, OverflowFlags) {
   EXPECT_EQ(nswOnly.getOverflowFlags() & OverflowFlags::Nuw,
             OverflowFlags::None);
 
-  ConstantIntRanges both = nswOnly.withOverflowFlags(OverflowFlags::Nsw |
-                                                       OverflowFlags::Nuw);
-  EXPECT_NE(both.getOverflowFlags() & OverflowFlags::Nsw,
-            OverflowFlags::None);
-  EXPECT_NE(both.getOverflowFlags() & OverflowFlags::Nuw,
-            OverflowFlags::None);
+  ConstantIntRanges both =
+      nswOnly.withOverflowFlags(OverflowFlags::Nsw | OverflowFlags::Nuw);
+  EXPECT_NE(both.getOverflowFlags() & OverflowFlags::Nsw, OverflowFlags::None);
+  EXPECT_NE(both.getOverflowFlags() & OverflowFlags::Nuw, OverflowFlags::None);
 
   // rangeUnion conservatively preserves only proofs present in both inputs.
   EXPECT_EQ(nswOnly.rangeUnion(nuwOnly).getOverflowFlags(),
             OverflowFlags::None);
-  EXPECT_EQ(both.rangeUnion(nswOnly).getOverflowFlags(),
-            OverflowFlags::Nsw);
+  EXPECT_EQ(both.rangeUnion(nswOnly).getOverflowFlags(), OverflowFlags::Nsw);
 
   // intersection preserves proofs from either input.
   EXPECT_EQ(nswOnly.intersection(nuwOnly).getOverflowFlags(),
@@ -131,8 +128,7 @@ TEST(IntRangeAttrs, OverflowFlags) {
   EXPECT_EQ(both.intersection(nswOnly).getOverflowFlags(),
             OverflowFlags::Nsw | OverflowFlags::Nuw);
   ConstantIntRanges none(zero, two, zero, two, OverflowFlags::None);
-  EXPECT_EQ(nswOnly.intersection(none).getOverflowFlags(),
-            OverflowFlags::Nsw);
+  EXPECT_EQ(nswOnly.intersection(none).getOverflowFlags(), OverflowFlags::Nsw);
 }
 
 TEST(IntRangeAttrs, OverflowFlagsPrinting) {
@@ -150,12 +146,10 @@ TEST(IntRangeAttrs, OverflowFlagsPrinting) {
   EXPECT_EQ(toString(noFlags), "unsigned : [0, 1] signed : [0, 1]");
 
   ConstantIntRanges nsw(zero, one, zero, one, OverflowFlags::Nsw);
-  EXPECT_EQ(toString(nsw),
-            "unsigned : [0, 1] signed : [0, 1] nooverflow<nsw>");
+  EXPECT_EQ(toString(nsw), "unsigned : [0, 1] signed : [0, 1] nooverflow<nsw>");
 
   ConstantIntRanges nuw(zero, one, zero, one, OverflowFlags::Nuw);
-  EXPECT_EQ(toString(nuw),
-            "unsigned : [0, 1] signed : [0, 1] nooverflow<nuw>");
+  EXPECT_EQ(toString(nuw), "unsigned : [0, 1] signed : [0, 1] nooverflow<nuw>");
 
   ConstantIntRanges both(zero, one, zero, one,
                          OverflowFlags::Nsw | OverflowFlags::Nuw);

``````````

</details>


https://github.com/llvm/llvm-project/pull/191777