[MLIR] Add result status for normalizeAffineFor

[bondhugula]

Summary

Add result status for normalizeAffineFor utility.

[dcaballe]

Thanks, Uday. LGTM!

[ayzhuang]

Looks great, thanks!

mlir/include/mlir/Dialect/Affine/Utils.h

 /// Normalize a affine.parallel op so that lower bounds are 0 and steps are 1.
 /// As currently implemented, this transformation cannot fail and will return
 /// early if the op is already in a normalized form.
 void normalizeAffineParallel(AffineParallelOp op);
 
 /// Normalize an affine.for op. If the affine.for op has only a single iteration
 /// only then it is simply promoted, else it is normalized in the traditional
 /// way, by converting the lower bound to zero and loop step to one. The upper
-/// bound is set to the trip count of the loop. For now, original loops must
-/// have lower bound with a single result only. There is no such restriction on
-/// upper bounds.
-void normalizeAffineFor(AffineForOp op);
+/// bound is set to the trip count of the loop. Original loops must have a
+/// lower bound with only a single result. There is no such restriction on upper
+/// bounds. Returns success if the loop has been normalized (or is already in
+/// the normal form).
+LogicalResult normalizeAffineFor(AffineForOp op);
 
 /// Traverse `e` and return an AffineExpr where all occurrences of `dim` have
 /// been replaced by either:
 ///  - `min` if `positivePath` is true when we reach an occurrence of `dim`
 ///  - `max` if `positivePath` is true when we reach an occurrence of `dim`
 /// `positivePath` is negated each time we hit a multiplicative or divisive
 /// binary op with a constant negative coefficient.
 AffineExpr substWithMin(AffineExpr e, AffineExpr dim, AffineExpr min,

mlir/lib/Dialect/Affine/Transforms/AffineLoopNormalize.cpp

 struct AffineLoopNormalizePass
     : public AffineLoopNormalizeBase<AffineLoopNormalizePass> {
 
   void runOnOperation() override {
     getOperation().walk([](Operation *op) {
       if (auto affineParallel = dyn_cast<AffineParallelOp>(op))
         normalizeAffineParallel(affineParallel);
       else if (auto affineFor = dyn_cast<AffineForOp>(op))
-        normalizeAffineFor(affineFor);
+        (void)normalizeAffineFor(affineFor);
     });
   }
 };
 
 } // namespace
 
 std::unique_ptr<OperationPass<FuncOp>> mlir::createAffineLoopNormalizePass() {
   return std::make_unique<AffineLoopNormalizePass>();
 }

mlir/lib/Dialect/Affine/Utils/Utils.cpp

 }
 
 /// Normalizes affine.for ops. If the affine.for op has only a single iteration
 /// only then it is simply promoted, else it is normalized in the traditional
 /// way, by converting the lower bound to zero and loop step to one. The upper
 /// bound is set to the trip count of the loop. For now, original loops must
 /// have lower bound with a single result only. There is no such restriction on
 /// upper bounds.
-void mlir::normalizeAffineFor(AffineForOp op) {
+LogicalResult mlir::normalizeAffineFor(AffineForOp op) {
   if (succeeded(promoteIfSingleIteration(op)))
-    return;
+    return success();
 
   // Check if the forop is already normalized.
   if (op.hasConstantLowerBound() && (op.getConstantLowerBound() == 0) &&
       (op.getStep() == 1))
-    return;
+    return success();
 
   // Check if the lower bound has a single result only. Loops with a max lower
   // bound can't be normalized without additional support like
   // affine.execute_region's. If the lower bound does not have a single result
   // then skip this op.
   if (op.getLowerBoundMap().getNumResults() != 1)
-    return;
+    return failure();
 
   Location loc = op.getLoc();
   OpBuilder opBuilder(op);
   int64_t origLoopStep = op.getStep();
 
   // Calculate upperBound for normalized loop.
   SmallVector<Value, 4> ubOperands;
   AffineBound lb = op.getLowerBound();
for (unsigned j = 0, e = origLbMap.getNumSymbols(); j < e; ++j)
     lbOperands.push_back(lb.getOperand(origLbMap.getNumDims() + j));
 
   AffineExpr origIVExpr = opBuilder.getAffineDimExpr(lb.getMap().getNumDims());
   AffineExpr newIVExpr = origIVExpr * origLoopStep + origLbMap.getResult(0);
   AffineMap ivMap = AffineMap::get(origLbMap.getNumDims() + 1,
                                    origLbMap.getNumSymbols(), newIVExpr);
   Operation *newIV = opBuilder.create<AffineApplyOp>(loc, ivMap, lbOperands);
   op.getInductionVar().replaceAllUsesExcept(newIV->getResult(0), newIV);
+  return success();
 }
 
 /// Ensure that all operations that could be executed after `start`
 /// (noninclusive) and prior to `memOp` (e.g. on a control flow/op path
 /// between the operations) do not have the potential memory effect
 /// `EffectType` on `memOp`. `memOp`  is an operation that reads or writes to
 /// a memref. For example, if `EffectType` is MemoryEffects::Write, this method
 /// will check if there is no write to the memory between `start` and `memOp`