[mlir][Interfaces] Better error handling for `addBound`

[springerm]

Summary

Do not assert if a bound could not be added. This may or may not cause an error. We have the appropriate error handling in computeBound (which returns a LogicalResult).

Depends On: D146306

mlir/lib/Interfaces/ValueBoundsOpInterface.cpp

 //===- ValueBoundsOpInterface.cpp - Value Bounds  -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Interfaces/ValueBoundsOpInterface.h"
 
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Matchers.h"
 #include "llvm/ADT/APSInt.h"
+#include "llvm/Support/Debug.h"
+
+#define DEBUG_TYPE "value-bounds-op-interface"
 
 using namespace mlir;
 using presburger::BoundType;
 using presburger::VarKind;
 
 namespace mlir {
 #include "mlir/Interfaces/ValueBoundsOpInterface.cpp.inc"
 } // namespace mlir

 }
 #endif // NDEBUG
 
 void ValueBoundsConstraintSet::addBound(BoundType type, int64_t pos,
                                         AffineExpr expr) {
   LogicalResult status = cstr.addBound(
       type, pos,
       AffineMap::get(cstr.getNumDimVars(), cstr.getNumSymbolVars(), expr));
-  (void)status;
-  assert(succeeded(status) && "failed to add bound to constraint system");
+  if (failed(status)) {
+    // Non-pure (e.g., semi-affine) expressions are not yet supported by
+    // FlatLinearConstraints. However, we can just ignore such failures here.
+    // Even without this bound, there may be enough information in the
+    // constraint system to compute the requested bound. In case this bound is
+    // actually needed, `computeBound` will return `failure`.
+    LLVM_DEBUG(llvm::dbgs() << "Failed to add bound: " << expr << "\n");
+  }
 }
 
 AffineExpr ValueBoundsConstraintSet::getExpr(Value value,
                                              std::optional<int64_t> dim) {
 #ifndef NDEBUG
   assertValidValueDim(value, dim);
 #endif // NDEBUG
 

mlir/test/Dialect/Arith/value-bounds-op-interface-impl.mlir

 // RUN: mlir-opt %s -test-affine-reify-value-bounds -verify-diagnostics \
-// RUN:     -split-input-file | FileCheck %s
+// RUN:     -verify-diagnostics -split-input-file | FileCheck %s
 
 // CHECK: #[[$map:.*]] = affine_map<()[s0] -> (s0 + 5)>
 // CHECK-LABEL: func @arith_addi(
 //  CHECK-SAME:     %[[a:.*]]: index
 //       CHECK:   %[[apply:.*]] = affine.apply #[[$map]]()[%[[a]]]
 //       CHECK:   return %[[apply]]
 func.func @arith_addi(%a: index) -> index {
   %0 = arith.constant 5 : index
func.func @arith_muli(%a: index) -> index {
   %0 = arith.constant 5 : index
   %1 = arith.muli %0, %a : index
   %2 = "test.reify_bound"(%1) : (index) -> (index)
   return %2 : index
 }
 
 // -----
 
+func.func @arith_muli_non_pure(%a: index, %b: index) -> index {
+  %0 = arith.muli %a, %b : index
+  // Semi-affine expressions (such as "symbol * symbol") are not supported.
+  // expected-error @below{{could not reify bound}}
+  %1 = "test.reify_bound"(%0) : (index) -> (index)
+  return %1 : index
+}
+
+// -----
+
 // CHECK-LABEL: func @arith_const()
 //       CHECK:   %[[c5:.*]] = arith.constant 5 : index
 //       CHECK:   %[[c5:.*]] = arith.constant 5 : index
 //       CHECK:   return %[[c5]]
 func.func @arith_const() -> index {
   %c5 = arith.constant 5 : index
   %0 = "test.reify_bound"(%c5) : (index) -> (index)
   return %0 : index
 }