[MLIR][Affine] Fix affine.parallel op domain add

[bondhugula]

Summary

Fix obvious bug in addAffineParallelOpDomain that would lead to
incorrect domain constraints for any affine.parallel op with
dimensionality greater than one.

mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp

FlatAffineValueConstraints::addAffineForOpDomain(AffineForOp forOp) {
   // Non-constant upper bound case.
   return addBound(BoundType::UB, pos, forOp.getUpperBoundMap(),
                   forOp.getUpperBoundOperands());
 }
 
 LogicalResult FlatAffineValueConstraints::addAffineParallelOpDomain(
     AffineParallelOp parallelOp) {
   size_t ivPos = 0;
-  for (auto iv : parallelOp.getIVs()) {
+  for (Value iv : parallelOp.getIVs()) {
     unsigned pos;
     if (!findVar(iv, &pos)) {
       assert(false && "variable expected for the IV value");
       return failure();
     }
 
     AffineMap lowerBound = parallelOp.getLowerBoundMap(ivPos);
     if (lowerBound.isConstant())
       addBound(BoundType::LB, pos, lowerBound.getSingleConstantResult());
     else if (failed(addBound(BoundType::LB, pos, lowerBound,
                              parallelOp.getLowerBoundsOperands())))
       return failure();
 
     auto upperBound = parallelOp.getUpperBoundMap(ivPos);
     if (upperBound.isConstant())
       addBound(BoundType::UB, pos, upperBound.getSingleConstantResult());
     else if (failed(addBound(BoundType::UB, pos, upperBound,
                              parallelOp.getUpperBoundsOperands())))
       return failure();
+    ++ivPos;
   }
   return success();
 }
 
 LogicalResult
 FlatAffineValueConstraints::addDomainFromSliceMaps(ArrayRef<AffineMap> lbMaps,
                                                    ArrayRef<AffineMap> ubMaps,
                                                    ArrayRef<Value> operands) {

mlir/test/Transforms/memref-dependence-check.mlir

func.func @affine_if_no_dependence() {
   // This set is empty.
   affine.if affine_set<(d0, d1, d2, d3) : ((d0 + 1) mod 8 >= 0, d0 * -8 >= 0)>(%c1, %c1, %c1, %c1){
     %265 = affine.load %alloc[%c1] : memref<15xi1>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   }
   return
 }
+
+// -----
+
+// CHECK-LABEL: func @affine_parallel_dep_check
+func.func @affine_parallel_dep_check() {
+  %memref_23 = memref.alloc() : memref<1x130xf32>
+  %memref_25 = memref.alloc() : memref<1x130x130xf32>
+  %cst = arith.constant 0.0 : f32
+  affine.parallel (%arg4, %arg5) = (0, 0) to (1, 130) {
+    affine.store %cst, %memref_25[%arg4, %arg5, 129] : memref<1x130x130xf32>
+    // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}
+    // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}
+  }
+  %memref_27 = memref.alloc() : memref<1x128x128xf32>
+  affine.parallel (%arg4) = (0) to (130) {
+    affine.parallel (%arg5, %arg6) = (0, 0) to (1, 130) {
+      affine.load %memref_25[0, %arg4 + %arg5, %arg6] : memref<1x130x130xf32>
+      // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
+      // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
+      // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}
+      // expected-remark@above {{dependence from 1 to 1 at depth 4 = false}}
+      // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
+    }
+  }
+  return
+}