Improve integer divisibilty inference for util.assume.int with 0 cases (

iree-org#19254)

If one of the possible values for a util.assume.int is a constant 0,
don't bail out of the GCD computation even if that constant doesn't have
a `udiv` term.

This is because 0 is divisible by any integer.

compiler/src/iree/compiler/Dialect/Util/IR/UtilOps.cpp

@@ -1184,14 +1184,26 @@ AssumeIntOp::getUnionedUnsignedRange(unsigned operandIndex) {
       umaxCount == assumptions.size() ? umaxUnion : std::nullopt);
 }
 
+static bool isConstantZero(IntAssumptionAttr assumption) {
+  std::optional<uint64_t> umin = assumption.getUmin();
+  std::optional<uint64_t> umax = assumption.getUmax();
+  if (!umin || !umax)
+    return false;
+  return *umin == 0 && *umax == 0;
+}
+
 std::optional<uint64_t>
 AssumeIntOp::getUnionedUnsignedDivisor(unsigned operandIndex) {
   auto assumptions = getOperandAssumptions(operandIndex);
   std::optional<uint64_t> divisorUnion;
   for (auto assumption : assumptions) {
     auto divisor = assumption.getUdiv();
-    if (!divisor)
+    if (!divisor) {
+      // Constant zero is divisible by anything
+      if (isConstantZero(assumption))
+        continue;
       return std::nullopt;
+    }
     if (divisorUnion)
       divisorUnion = std::gcd(*divisor, *divisorUnion);
     else

compiler/src/iree/compiler/Dialect/Util/Transforms/test/integer_divisibility.mlir

@@ -100,3 +100,15 @@ util.func @divui_divisibility(%arg0 : index) -> (index, index) {
 //       CHECK:   %[[V:.+]] = arith.divui
 //       CHECK:   %[[REM:.+]] = arith.remui %[[V]], %[[C32]]
 //       CHECK:   return %[[C0]], %[[REM]]
+
+// -----
+
+util.func @everything_divides_zero(%arg0 : index) -> index {
+  %c32 = arith.constant 32 : index
+  %0 = util.assume.int %arg0[<umin = 0, umax = 0>, <umin = 64, umax = 64, udiv = 64>] : index
+  %1 = arith.remui %0, %c32 : index
+  util.return %1 : index
+}
+// CHECK-LABEL: @everything_divides_zero
+//   CHECK-DAG:   %[[C0:.+]] = arith.constant 0 : index
+//       CHECK:   return %[[C0]]