Lines Matching defs:expr
33 MLIRContext *AffineExpr::getContext() const { return expr->context; }
35 AffineExprKind AffineExpr::getKind() const { return expr->kind; }
50 WalkRetTy visitAffineBinaryOpExpr(AffineBinaryOpExpr expr) {
51 return callback(expr);
53 WalkRetTy visitConstantExpr(AffineConstantExpr expr) {
54 return callback(expr);
56 WalkRetTy visitDimExpr(AffineDimExpr expr) { return callback(expr); }
57 WalkRetTy visitSymbolExpr(AffineSymbolExpr expr) { return callback(expr); }
181 AffineExpr AffineExpr::replace(AffineExpr expr, AffineExpr replacement) const {
183 map.insert(std::make_pair(expr, replacement));
202 auto expr = llvm::cast<AffineBinaryOpExpr>(*this);
203 return expr.getLHS().isSymbolicOrConstant() &&
204 expr.getRHS().isSymbolicOrConstant();
320 if (auto expr = llvm::dyn_cast<AffineBinaryOpExpr>(*this)) {
321 return expr.getLHS().isFunctionOfDim(position) ||
322 expr.getRHS().isFunctionOfDim(position);
331 if (auto expr = llvm::dyn_cast<AffineBinaryOpExpr>(*this)) {
332 return expr.getLHS().isFunctionOfSymbol(position) ||
333 expr.getRHS().isFunctionOfSymbol(position);
341 return static_cast<ImplType *>(expr)->lhs;
344 return static_cast<ImplType *>(expr)->rhs;
349 return static_cast<ImplType *>(expr)->position;
356 ///`exprKind` is floordiv and `expr` is also a binary expression of a floordiv
359 static bool canSimplifyDivisionBySymbol(AffineExpr expr, unsigned symbolPos,
366 switch (expr.getKind()) {
368 return cast<AffineConstantExpr>(expr).getValue() == 0;
372 return (cast<AffineSymbolExpr>(expr).getPosition() == symbolPos);
375 AffineBinaryOpExpr binaryExpr = cast<AffineBinaryOpExpr>(expr);
386 AffineBinaryOpExpr binaryExpr = cast<AffineBinaryOpExpr>(expr);
394 AffineBinaryOpExpr binaryExpr = cast<AffineBinaryOpExpr>(expr);
401 // operand is divisible, and the affine expression kind of the argument expr
412 AffineBinaryOpExpr binaryExpr = cast<AffineBinaryOpExpr>(expr);
413 if (opKind != expr.getKind())
418 expr.getKind());
427 static AffineExpr symbolicDivide(AffineExpr expr, unsigned symbolPos,
433 switch (expr.getKind()) {
435 if (cast<AffineConstantExpr>(expr).getValue() != 0)
437 return getAffineConstantExpr(0, expr.getContext());
441 return getAffineConstantExpr(1, expr.getContext());
444 AffineBinaryOpExpr binaryExpr = cast<AffineBinaryOpExpr>(expr);
446 expr.getKind(), symbolicDivide(binaryExpr.getLHS(), symbolPos, opKind),
451 AffineBinaryOpExpr binaryExpr = cast<AffineBinaryOpExpr>(expr);
453 expr.getKind(),
454 symbolicDivide(binaryExpr.getLHS(), symbolPos, expr.getKind()),
455 symbolicDivide(binaryExpr.getRHS(), symbolPos, expr.getKind()));
459 AffineBinaryOpExpr binaryExpr = cast<AffineBinaryOpExpr>(expr);
469 AffineBinaryOpExpr binaryExpr = cast<AffineBinaryOpExpr>(expr);
471 expr.getKind(),
472 symbolicDivide(binaryExpr.getLHS(), symbolPos, expr.getKind()),
483 static void getSummandExprs(AffineExpr expr, SmallVector<AffineExpr> &result) {
484 auto addExpr = dyn_cast<AffineBinaryOpExpr>(expr);
486 result.push_back(expr);
493 /// Return "true" if `candidate` is a negated expression, i.e., Mul(-1, expr).
494 /// If so, also return the non-negated expression via `expr`.
495 static bool isNegatedAffineExpr(AffineExpr candidate, AffineExpr &expr) {
501 expr = mulExpr.getRHS();
507 expr = mulExpr.getLHS();
560 static AffineExpr simplifySemiAffine(AffineExpr expr, unsigned numDims,
562 switch (expr.getKind()) {
566 return expr;
569 AffineBinaryOpExpr binaryExpr = cast<AffineBinaryOpExpr>(expr);
571 expr.getKind(),
583 AffineBinaryOpExpr binaryExpr = cast<AffineBinaryOpExpr>(expr);
589 return getAffineConstantExpr(0, expr.getContext());
593 return getAffineBinaryOpExpr(expr.getKind(), sLHS, sRHS);
596 expr.getKind()))
597 return getAffineBinaryOpExpr(expr.getKind(), sLHS, sRHS);
598 if (expr.getKind() == AffineExprKind::Mod)
599 return getAffineConstantExpr(0, expr.getContext());
600 return symbolicDivide(sLHS, symbolPos, expr.getKind());
624 return static_cast<ImplType *>(expr)->position;
634 return static_cast<ImplType *>(expr)->constant;
692 // Detect "c1 * expr + c_2 * expr" as "(c1 + c2) * expr".
732 // Detect and transform "expr - q * (expr floordiv q)" to "expr mod q", where
737 // Process '(expr floordiv c) * (-c)'.
746 // Check if lrhsBinOpExpr is of the form (expr floordiv q) * q, where q is a
753 // Check llrhs = expr floordiv q.
764 // Process lrhs, which is 'expr floordiv c'.
765 // expr + (expr // c * -c) = expr % c
891 // Simplify `(expr * lrhs) floordiv rhsConst` when `lrhs` is known to be a
950 // Simplify `(expr * lrhs) ceildiv rhsConst` when `lrhs` is known to be a
1038 raw_ostream &mlir::operator<<(raw_ostream &os, AffineExpr expr) {
1039 expr.print(os);
1057 auto expr = getAffineConstantExpr(0, context);
1064 expr = expr + id * flatExprs[j];
1073 expr = expr + term;
1079 expr = expr + constTerm;
1080 return expr;
1102 AffineExpr expr = getAffineConstantExpr(0, context);
1133 AffineExpr expr) {
1140 indexToExprMap.insert({index, expr});
1173 AffineExpr expr = it.value();
1176 AffineExpr lhs = cast<AffineBinaryOpExpr>(expr).getLHS();
1177 AffineExpr rhs = cast<AffineBinaryOpExpr>(expr).getRHS();
1192 expr);
1198 expr);
1209 addEntry(indexEntry, flatExprs[numDims + numSymbols + it.index()], expr);
1219 addEntry(indexEntry, flatExprs[numDims + numSymbols + it.index()], expr);
1242 expr = expr + indexToExprMap.lookup(index) * coefficients.lookup(index);
1253 expr = expr + term;
1259 expr = expr + constTerm;
1260 return expr;
1269 // In pure affine t = expr * c, we multiply each coefficient of lhs with c.
1271 // In case of semi affine multiplication expressions, t = expr * symbolic_expr,
1272 // introduce a local variable p (= expr * symbolic_expr), and the affine
1273 // expression expr * symbolic_expr is added to `localExprs`.
1274 LogicalResult SimpleAffineExprFlattener::visitMulExpr(AffineBinaryOpExpr expr) {
1283 if (!isa<AffineConstantExpr>(expr.getRHS())) {
1285 MLIRContext *context = expr.getContext();
1301 LogicalResult SimpleAffineExprFlattener::visitAddExpr(AffineBinaryOpExpr expr) {
1316 // t = expr mod c <=> t = expr - c*q and c*q <= expr <= c*q + c - 1
1318 // A mod expression "expr mod c" is thus flattened by introducing a new local
1319 // variable q (= expr floordiv c), such that expr mod c is replaced with
1320 // 'expr - c * q' and c * q <= expr <= c * q + c - 1 are added to localVarCst.
1322 // In case of semi-affine modulo expressions, t = expr mod symbolic_expr,
1323 // introduce a local variable m (= expr mod symbolic_expr), and the affine
1324 // expression expr mod symbolic_expr is added to `localExprs`.
1325 LogicalResult SimpleAffineExprFlattener::visitModExpr(AffineBinaryOpExpr expr) {
1331 MLIRContext *context = expr.getContext();
1336 if (!isa<AffineConstantExpr>(expr.getRHS())) {
1361 // Add a local variable for the quotient, i.e., expr % c is replaced by
1362 // (expr - q * c) where q = expr floordiv c. Do this while canceling out
1363 // the GCD of expr and c.
1394 SimpleAffineExprFlattener::visitCeilDivExpr(AffineBinaryOpExpr expr) {
1395 return visitDivExpr(expr, /*isCeil=*/true);
1398 SimpleAffineExprFlattener::visitFloorDivExpr(AffineBinaryOpExpr expr) {
1399 return visitDivExpr(expr, /*isCeil=*/false);
1402 LogicalResult SimpleAffineExprFlattener::visitDimExpr(AffineDimExpr expr) {
1405 assert(expr.getPosition() < numDims && "Inconsistent number of dims");
1406 eq[getDimStartIndex() + expr.getPosition()] = 1;
1411 SimpleAffineExprFlattener::visitSymbolExpr(AffineSymbolExpr expr) {
1414 assert(expr.getPosition() < numSymbols && "inconsistent number of symbols");
1415 eq[getSymbolStartIndex() + expr.getPosition()] = 1;
1420 SimpleAffineExprFlattener::visitConstantExpr(AffineConstantExpr expr) {
1423 eq[getConstantIndex()] = expr.getValue();
1445 // t = expr floordiv c <=> t = q, c * q <= expr <= c * q + c - 1
1448 // c * q <= expr <= c * q + c - 1 to localVarCst (done by
1452 // t = expr ceildiv c <=> t = (expr + c - 1) floordiv c
1454 // In case of semi affine division expressions, t = expr floordiv symbolic_expr
1455 // or t = expr ceildiv symbolic_expr, introduce a local variable q (= expr
1458 LogicalResult SimpleAffineExprFlattener::visitDivExpr(AffineBinaryOpExpr expr,
1462 MLIRContext *context = expr.getContext();
1470 if (!isa<AffineConstantExpr>(expr.getRHS())) {
1480 // This is a pure affine expr; the RHS is a positive constant.
1502 // the ceil/floor expr (simplified up until here). Add an existential
1532 // Add a local identifier (needed to flatten a mod, floordiv, ceildiv expr).
1566 AffineExpr mlir::simplifyAffineExpr(AffineExpr expr, unsigned numDims,
1569 if (!expr.isPureAffine())
1570 expr = simplifySemiAffine(expr, numDims, numSymbols);
1574 if (failed(flattener.walkPostOrder(expr)))
1575 return expr;
1577 if (!expr.isPureAffine() &&
1578 expr == getAffineExprFromFlatForm(flattenedExpr, numDims, numSymbols,
1580 expr.getContext()))
1581 return expr;
1583 expr.isPureAffine()
1585 flattener.localExprs, expr.getContext())
1588 expr.getContext());
1596 AffineExpr expr, unsigned numDims, unsigned numSymbols,
1600 if (auto binOpExpr = dyn_cast<AffineBinaryOpExpr>(expr)) {
1649 auto simpleResult = flattener.walkPostOrder(expr);
1655 // get bound on the local expr recursively.