Emit error message instead of asserting

[vimal-polymagelabs]

Summary

test-affine-parametric-tile pass was crashing on an incorrect input.
Instead it should emit an error message and exit.

Fixes: https://github.com/llvm/llvm-project/issues/61528

[vimal-polymagelabs]

Added the github issue link to the commit summary

[mehdi_amini]

Thanks for the fix

[bondhugula]

mlir/test/lib/Dialect/Affine/TestAffineLoopParametricTiling.cpp

45

Please remove commented out code.

[vimal-polymagelabs]

Removed commented out code

mlir/test/Dialect/Affine/loop-tiling-parametric.mlir

-// RUN: mlir-opt %s -split-input-file -test-affine-parametric-tile | FileCheck %s
+// RUN: mlir-opt %s -split-input-file -test-affine-parametric-tile -verify-diagnostics | FileCheck %s
 // Test cases to test the utility introduced to tile affine for loops using
 // SSA values as tiling parameters(tile sizes). The tile sizes are expected
 // to be passed as input arguments(before any other argument) to the function
 // enclosing the loop nest. Currently hyper-rectangular loop nests with constant
 // lower bounds are supported.
 
 // -----
 

 func.func @tile_with_upper_bounds_in_dimensions_and_symbols_non_unit_steps(%t12 : index, %t13 :index, %M: index, %N :  index, %K: index) {
   affine.for %i = 0 to affine_map<(d0)[s0] -> (d0 + s0 + 2)>(%M)[%K] step 2 {
     affine.for %j = 0 to affine_map<(d0)[s0] -> (d0 + s0 + 4)>(%N)[%K] step 4 {
       "test.foo" () : () -> ()
     }
   }
   return
 }
+
+// -----
+
+func.func @too_few_tile_size_params() {
+  // expected-error@+1 {{too few tile sizes provided in the argument list of the function which contains the current band}}
+  affine.for %i = 0 to 256 {
+    affine.for %j = 0 to 512 {
+      affine.for %k = 0 to 1024 {
+        "test.foo"(%i, %j, %k) : (index, index, index) -> ()
+      }
+    }
+  }
+  return
+}
+
+// -----
+
+func.func @invalid_type_for_tile_size_params(%arg0: f32, %arg1: f32, %arg2: f32) {
+  // expected-error@+1 {{expected tiling parameters to be of index type}}
+  affine.for %i = 0 to 256 {
+    affine.for %j = 0 to 512 {
+      affine.for %k = 0 to 1024 {
+        "test.foo"(%i, %j, %k) : (index, index, index) -> ()
+      }
+    }
+  }
+  return
+}

mlir/test/lib/Dialect/Affine/TestAffineLoopParametricTiling.cpp

struct TestAffineLoopParametricTiling
   }
   void runOnOperation() override;
 };
 } // namespace
 
 /// Checks if the function enclosing the loop nest has any arguments passed to
 /// it, which can be used as tiling parameters. Assumes that atleast 'n'
 /// arguments are passed, where 'n' is the number of loops in the loop nest.
-static void checkIfTilingParametersExist(ArrayRef<AffineForOp> band) {
+static LogicalResult checkIfTilingParametersExist(ArrayRef<AffineForOp> band) {
   assert(!band.empty() && "no loops in input band");
   AffineForOp topLoop = band[0];
 
   if (func::FuncOp funcOp = dyn_cast<func::FuncOp>(topLoop->getParentOp()))
-    assert(funcOp.getNumArguments() >= band.size() && "Too few tile sizes");
+    // assert(funcOp.getNumArguments() >= band.size() && "Too few tile sizes");
+    if (funcOp.getNumArguments() < band.size())
+      return topLoop->emitError(
+          "too few tile sizes provided in the argument list of the function "
+          "which contains the current band");
+  return success();
 }
 
 /// Captures tiling parameters, which are expected to be passed as arguments
 /// to the function enclosing the loop nest. Also checks if the required
 /// parameters are of index type. This approach is temporary for testing
 /// purposes.
-static void getTilingParameters(ArrayRef<AffineForOp> band,
-                                SmallVectorImpl<Value> &tilingParameters) {
+static LogicalResult
+getTilingParameters(ArrayRef<AffineForOp> band,
   AffineForOp topLoop = band[0];
   Region *funcOpRegion = topLoop->getParentRegion();
   unsigned nestDepth = band.size();
 
   for (BlockArgument blockArgument :
        funcOpRegion->getArguments().take_front(nestDepth)) {
     if (blockArgument.getArgNumber() < nestDepth) {
-      assert(blockArgument.getType().isIndex() &&
-             "expected tiling parameters to be of index type.");
+      if (!blockArgument.getType().isIndex())
+        return topLoop->emitError(
+            "expected tiling parameters to be of index type");
       tilingParameters.push_back(blockArgument);
     }
   }
+  return success();
 }
 
 void TestAffineLoopParametricTiling::runOnOperation() {
   // Bands of loops to tile.
   std::vector<SmallVector<AffineForOp, 6>> bands;
   getTileableBands(getOperation(), &bands);
 
   // Tile each band.
   for (MutableArrayRef<AffineForOp> band : bands) {
     // Capture the tiling parameters from the arguments to the function
     // enclosing this loop nest.
     SmallVector<AffineForOp, 6> tiledNest;
     SmallVector<Value, 6> tilingParameters;
     // Check if tiling parameters are present.
-    checkIfTilingParametersExist(band);
+    if (checkIfTilingParametersExist(band).failed())
+      return;
 
     // Get function arguments as tiling parameters.
-    getTilingParameters(band, tilingParameters);
+    if (getTilingParameters(band, tilingParameters).failed())
+      return;
 
     (void)tilePerfectlyNestedParametric(band, tilingParameters, &tiledNest);
   }
 }
 
 namespace mlir {
 namespace test {
 void registerTestAffineLoopParametricTilingPass() {
   PassRegistration<TestAffineLoopParametricTiling>();
 }
 } // namespace test
 } // namespace mlir