include/mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h

//===- AffineCanonicalizationUtils.h ----------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This header file defines utility functions to canonicalize affine ops
// within SCF op regions.
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_DIALECT_SCF_UTILS_AFFINECANONICALIZATIONUTILS_H_
#define MLIR_DIALECT_SCF_UTILS_AFFINECANONICALIZATIONUTILS_H_

#include "mlir/Support/LLVM.h"
#include "mlir/Support/LogicalResult.h"

namespace mlir {
class AffineMap;
struct LogicalResult;
class Operation;
class OpFoldResult;
class RewriterBase;
class Value;
class ValueRange;

namespace affine {
class FlatAffineValueConstraints;
} // namespace affine

namespace scf {
class IfOp;

/// Match "for loop"-like operations: If the first parameter is an iteration
/// variable, return lower/upper bounds via the second/third parameter and the
/// step size via the last parameter. The function should return `success` in
/// that case. If the first parameter is not an iteration variable, return
/// `failure`.
using LoopMatcherFn = function_ref<LogicalResult(
    Value, OpFoldResult &, OpFoldResult &, OpFoldResult &)>;

/// Match "for loop"-like operations from the SCF dialect.
LogicalResult matchForLikeLoop(Value iv, OpFoldResult &lb, OpFoldResult &ub,
                               OpFoldResult &step);

/// Populate the given constraint set with induction variable constraints of a
/// "for" loop with the given range and step.
LogicalResult addLoopRangeConstraints(affine::FlatAffineValueConstraints &cstr,
                                      Value iv, OpFoldResult lb,
                                      OpFoldResult ub, OpFoldResult step);

/// Try to canonicalize the given affine.min/max operation in the context of
/// for `loops` with a known range.
///
/// `loopMatcher` is used to retrieve loop bounds and the step size for a given
/// iteration variable.
///
/// Note: `loopMatcher` allows this function to be used with any "for loop"-like
/// operation (scf.for, scf.parallel and even ops defined in other dialects).
LogicalResult canonicalizeMinMaxOpInLoop(RewriterBase &rewriter, Operation *op,
                                         LoopMatcherFn loopMatcher);

/// Try to simplify the given affine.min/max operation `op` after loop peeling.
/// This function can simplify min/max operations such as (ub is the previous
/// upper bound of the unpeeled loop):
/// ```
/// #map = affine_map<(d0)[s0, s1] -> (s0, -d0 + s1)>
/// %r = affine.min #map(%iv)[%step, %ub]
/// ```
/// and rewrites them into (in the case the peeled loop):
/// ```
/// %r = %step
/// ```
/// min/max operations inside the partial iteration are rewritten in a similar
/// way.
LogicalResult rewritePeeledMinMaxOp(RewriterBase &rewriter, Operation *op,
                                    Value iv, Value ub, Value step,
                                    bool insideLoop);

} // namespace scf
} // namespace mlir

#endif // MLIR_DIALECT_SCF_UTILS_AFFINECANONICALIZATIONUTILS_H_