NFC: remove stray decl of toAffineExpr, rename for readability

[bondhugula]

Summary

• remove stray toAffineExpr decl in affine analysis (name duplicate of mlir::toAffineExpr)

• rename mlir::toAffineExpr for better readability

• related NFC changes

Signed-off-by: Uday Bondhugula <[e-mail]>

[bondhugula]

Commit summary update

[bondhugula]

Thanks, @andydavis1 Could you please commit this for me?

[rriddle]

Hey Uday, I tried to apply the patch but it fails for me. Can you try syncing to master and re-uploading?

[bondhugula]

Rebase.

[rriddle]

Thanks, should be landed now.

mlir/include/mlir/Analysis/AffineStructures.h

inline ArrayRef<int64_t> getEquality(unsigned idx) const {
     return ArrayRef<int64_t>(&equalities[idx * numReservedCols], getNumCols());
   }
 
   inline ArrayRef<int64_t> getInequality(unsigned idx) const {
     return ArrayRef<int64_t>(&inequalities[idx * numReservedCols],
                              getNumCols());
   }
 
-  AffineExpr toAffineExpr(unsigned idx, MLIRContext *context);
-
   /// Adds constraints (lower and upper bounds) for the specified 'affine.for'
   /// operation's Value using IR information stored in its bound maps. The
   /// right identifier is first looked up using forOp's Value. Asserts if the
   /// Value corresponding to the 'affine.for' operation isn't found in the
   /// constraint system. Returns failure for the yet unimplemented/unsupported
   /// cases.  Any new identifiers that are found in the bound operands of the
   /// 'affine.for' operation are added as trailing identifiers (either
   /// dimensional or symbolic depending on whether the operand is a valid

mlir/include/mlir/IR/AffineExpr.h

 AffineExpr getAffineBinaryOpExpr(AffineExprKind kind, AffineExpr lhs,
                                  AffineExpr rhs);
 
 /// Constructs an affine expression from a flat ArrayRef. If there are local
 /// identifiers (neither dimensional nor symbolic) that appear in the sum of
 /// products expression, 'localExprs' is expected to have the AffineExpr
 /// for it, and is substituted into. The ArrayRef 'eq' is expected to be in the
 /// format [dims, symbols, locals, constant term].
-AffineExpr toAffineExpr(ArrayRef<int64_t> eq, unsigned numDims,
-                        unsigned numSymbols, ArrayRef<AffineExpr> localExprs,
+AffineExpr getAffineExprFromFlatForm(ArrayRef<int64_t> flatExprs,
+                                     unsigned numDims, unsigned numSymbols,
+                                     ArrayRef<AffineExpr> localExprs,
                                      MLIRContext *context);
 
 raw_ostream &operator<<(raw_ostream &os, AffineExpr &expr);
 
 template <typename U> bool AffineExpr::isa() const {
   if (std::is_same<U, AffineBinaryOpExpr>::value)
     return getKind() <= AffineExprKind::LAST_AFFINE_BINARY_OP;
   if (std::is_same<U, AffineDimExpr>::value)
     return getKind() == AffineExprKind::DimId;

mlir/lib/Analysis/AffineStructures.cpp

std::pair<AffineMap, AffineMap> FlatAffineConstraints::getLowerAndUpperBound(
   // Lower bound expressions.
   for (auto idx : lbIndices) {
     auto ineq = getInequality(idx);
     // Extract the lower bound (in terms of other coeff's + const), i.e., if
     // i - j + 1 >= 0 is the constraint, 'pos' is for i the lower bound is j
     // - 1.
     addCoeffs(ineq, lb);
     std::transform(lb.begin(), lb.end(), lb.begin(), std::negate<int64_t>());
-    auto expr = mlir::toAffineExpr(lb, dimCount, symCount, localExprs, context);
+    auto expr =
+        getAffineExprFromFlatForm(lb, dimCount, symCount, localExprs, context);
     // expr ceildiv divisor is (expr + divisor - 1) floordiv divisor
     int64_t divisor = std::abs(ineq[pos + offset]);
     expr = (expr + divisor  - 1).floorDiv(divisor);
     lbExprs.push_back(expr);
   }
 
   SmallVector<AffineExpr, 4> ubExprs;
   ubExprs.reserve(ubIndices.size() + eqIndices.size());
   // Upper bound expressions.
   for (auto idx : ubIndices) {
     auto ineq = getInequality(idx);
     // Extract the upper bound (in terms of other coeff's + const).
     addCoeffs(ineq, ub);
-    auto expr = mlir::toAffineExpr(ub, dimCount, symCount, localExprs, context);
+    auto expr =
+        getAffineExprFromFlatForm(ub, dimCount, symCount, localExprs, context);
     expr = expr.floorDiv(std::abs(ineq[pos + offset]));
     // Upper bound is exclusive.
     ubExprs.push_back(expr + 1);
   }
 
   // Equalities. It's both a lower and a upper bound.
   SmallVector<int64_t, 4> b;
   for (auto idx : eqIndices) {
     auto eq = getEquality(idx);
     addCoeffs(eq, b);
     if (eq[pos + offset] > 0)
       std::transform(b.begin(), b.end(), b.begin(), std::negate<int64_t>());
 
     // Extract the upper bound (in terms of other coeff's + const).
-    auto expr = mlir::toAffineExpr(b, dimCount, symCount, localExprs, context);
+    auto expr =
+        getAffineExprFromFlatForm(b, dimCount, symCount, localExprs, context);
     expr = expr.floorDiv(std::abs(eq[pos + offset]));
     // Upper bound is exclusive.
     ubExprs.push_back(expr + 1);
     // Lower bound.
-    expr = mlir::toAffineExpr(b, dimCount, symCount, localExprs, context);
+    expr =
+        getAffineExprFromFlatForm(b, dimCount, symCount, localExprs, context);
     expr = expr.ceilDiv(std::abs(eq[pos + offset]));
     lbExprs.push_back(expr);
   }
 
   auto lbMap = lbExprs.empty() ? AffineMap()
                                : AffineMap::get(dimCount, symCount, lbExprs);
 
   auto ubMap = ubExprs.empty() ? AffineMap()

mlir/lib/IR/AffineExpr.cpp

 }
 raw_ostream &mlir::operator<<(raw_ostream &os, AffineExpr &expr) {
   expr.print(os);
   return os;
 }
 
 /// Constructs an affine expression from a flat ArrayRef. If there are local
 /// identifiers (neither dimensional nor symbolic) that appear in the sum of
-/// products expression, 'localExprs' is expected to have the AffineExpr
-/// for it, and is substituted into. The ArrayRef 'eq' is expected to be in the
-/// format [dims, symbols, locals, constant term].
-AffineExpr mlir::toAffineExpr(ArrayRef<int64_t> eq, unsigned numDims,
+/// products expression, `localExprs` is expected to have the AffineExpr
+/// for it, and is substituted into. The ArrayRef `flatExprs` is expected to be
+/// in the format [dims, symbols, locals, constant term].
+AffineExpr mlir::getAffineExprFromFlatForm(ArrayRef<int64_t> flatExprs,
+                                           unsigned numDims,
                                            unsigned numSymbols,
                                            ArrayRef<AffineExpr> localExprs,
                                            MLIRContext *context) {
-  // Assert expected numLocals = eq.size() - numDims - numSymbols - 1
-  assert(eq.size() - numDims - numSymbols - 1 == localExprs.size() &&
+  // Assert expected numLocals = flatExprs.size() - numDims - numSymbols - 1.
+  assert(flatExprs.size() - numDims - numSymbols - 1 == localExprs.size() &&
          "unexpected number of local expressions");
 
   auto expr = getAffineConstantExpr(0, context);
   // Dimensions and symbols.
   for (unsigned j = 0; j < numDims + numSymbols; j++) {
-    if (eq[j] == 0) {
+    if (flatExprs[j] == 0)
       continue;
-    }
     auto id = j < numDims ? getAffineDimExpr(j, context)
                           : getAffineSymbolExpr(j - numDims, context);
-    expr = expr + id * eq[j];
+    expr = expr + id * flatExprs[j];
   }
 
   // Local identifiers.
-  for (unsigned j = numDims + numSymbols, e = eq.size() - 1; j < e; j++) {
-    if (eq[j] == 0) {
+  for (unsigned j = numDims + numSymbols, e = flatExprs.size() - 1; j < e;
+       j++) {
+    if (flatExprs[j] == 0)
       continue;
-    }
-    auto term = localExprs[j - numDims - numSymbols] * eq[j];
+    auto term = localExprs[j - numDims - numSymbols] * flatExprs[j];
     expr = expr + term;
   }
 
   // Constant term.
-  int64_t constTerm = eq[eq.size() - 1];
+  int64_t constTerm = flatExprs[flatExprs.size() - 1];
   if (constTerm != 0)
     expr = expr + constTerm;
   return expr;
 }
 
 SimpleAffineExprFlattener::SimpleAffineExprFlattener(unsigned numDims,
                                                      unsigned numSymbols)
     : numDims(numDims), numSymbols(numSymbols), numLocals(0) {
void SimpleAffineExprFlattener::visitModExpr(AffineBinaryOpExpr expr) {
   if (gcd != 1) {
     for (unsigned i = 0, e = floorDividend.size(); i < e; i++)
       floorDividend[i] = floorDividend[i] / static_cast<int64_t>(gcd);
   }
   int64_t floorDivisor = rhsConst / static_cast<int64_t>(gcd);
 
   // Construct the AffineExpr form of the floordiv to store in localExprs.
   MLIRContext *context = expr.getContext();
-  auto dividendExpr =
-      toAffineExpr(floorDividend, numDims, numSymbols, localExprs, context);
+  auto dividendExpr = getAffineExprFromFlatForm(
+      floorDividend, numDims, numSymbols, localExprs, context);
   auto divisorExpr = getAffineConstantExpr(floorDivisor, context);
   auto floorDivExpr = dividendExpr.floorDiv(divisorExpr);
   int loc;
   if ((loc = findLocalId(floorDivExpr)) == -1) {
     addLocalFloorDivId(floorDividend, floorDivisor, floorDivExpr);
     // Set result at top of stack to "lhs - rhsConst * q".
     lhs[getLocalVarStartIndex() + numLocals - 1] = -rhsConst;
   } else {
void SimpleAffineExprFlattener::visitDivExpr(AffineBinaryOpExpr expr,
   if (divisor == 1)
     return;
 
   // If the divisor cannot be simplified to one, we will have to retain
   // the ceil/floor expr (simplified up until here). Add an existential
   // quantifier to express its result, i.e., expr1 div expr2 is replaced
   // by a new identifier, q.
   MLIRContext *context = expr.getContext();
-  auto a = toAffineExpr(lhs, numDims, numSymbols, localExprs, context);
+  auto a =
+      getAffineExprFromFlatForm(lhs, numDims, numSymbols, localExprs, context);
   auto b = getAffineConstantExpr(divisor, context);
 
   int loc;
   auto divExpr = isCeil ? a.ceilDiv(b) : a.floorDiv(b);
   if ((loc = findLocalId(divExpr)) == -1) {
     if (!isCeil) {
       SmallVector<int64_t, 8> dividend(lhs);
       addLocalFloorDivId(dividend, divisor, divExpr);
AffineExpr mlir::simplifyAffineExpr(AffineExpr expr, unsigned numDims,
   // TODO(bondhugula): only pure affine for now. The simplification here can
   // be extended to semi-affine maps in the future.
   if (!expr.isPureAffine())
     return expr;
 
   SimpleAffineExprFlattener flattener(numDims, numSymbols);
   flattener.walkPostOrder(expr);
   ArrayRef<int64_t> flattenedExpr = flattener.operandExprStack.back();
-  auto simplifiedExpr = toAffineExpr(flattenedExpr, numDims, numSymbols,
-                                     flattener.localExprs, expr.getContext());
+  auto simplifiedExpr =
+      getAffineExprFromFlatForm(flattenedExpr, numDims, numSymbols,
   flattener.operandExprStack.pop_back();
   assert(flattener.operandExprStack.empty());
 
   return simplifiedExpr;
 }
 
 // Flattens the expressions in map. Returns true on success or false
 // if 'expr' was unable to be flattened (i.e., semi-affine expressions not