using namespace mlir;
namespace {
-// Visit affine expressions recursively and build the sequence of operations
-// that correspond to it. Visitation functions return an Value of the
-// expression subtree they visited or `nullptr` on error.
+/// Visit affine expressions recursively and build the sequence of operations
+/// that correspond to it. Visitation functions return an Value of the
+/// expression subtree they visited or `nullptr` on error.
class AffineApplyExpander
: public AffineExprVisitor<AffineApplyExpander, Value> {
public:
- // This internal class expects arguments to be non-null, checks must be
- // performed at the call site.
+ /// This internal class expects arguments to be non-null, checks must be
+ /// performed at the call site.
AffineApplyExpander(OpBuilder &builder, ArrayRef<Value> dimValues,
ArrayRef<Value> symbolValues, Location loc)
: builder(builder), dimValues(dimValues), symbolValues(symbolValues),
return buildBinaryExpr<MulIOp>(expr);
}
- // Euclidean modulo operation: negative RHS is not allowed.
- // Remainder of the euclidean integer division is always non-negative.
- //
- // Implemented as
- //
- // a mod b =
- // let remainder = srem a, b;
- // negative = a < 0 in
- // select negative, remainder + b, remainder.
+ /// Euclidean modulo operation: negative RHS is not allowed.
+ /// Remainder of the euclidean integer division is always non-negative.
+ ///
+ /// Implemented as
+ ///
+ /// a mod b =
+ /// let remainder = srem a, b;
+ /// negative = a < 0 in
+ /// select negative, remainder + b, remainder.
Value visitModExpr(AffineBinaryOpExpr expr) {
auto rhsConst = expr.getRHS().dyn_cast<AffineConstantExpr>();
if (!rhsConst) {
return result;
}
- // Floor division operation (rounds towards negative infinity).
- //
- // For positive divisors, it can be implemented without branching and with a
- // single division operation as
- //
- // a floordiv b =
- // let negative = a < 0 in
- // let absolute = negative ? -a - 1 : a in
- // let quotient = absolute / b in
- // negative ? -quotient - 1 : quotient
+ /// Floor division operation (rounds towards negative infinity).
+ ///
+ /// For positive divisors, it can be implemented without branching and with a
+ /// single division operation as
+ ///
+ /// a floordiv b =
+ /// let negative = a < 0 in
+ /// let absolute = negative ? -a - 1 : a in
+ /// let quotient = absolute / b in
+ /// negative ? -quotient - 1 : quotient
Value visitFloorDivExpr(AffineBinaryOpExpr expr) {
auto rhsConst = expr.getRHS().dyn_cast<AffineConstantExpr>();
if (!rhsConst) {
return result;
}
- // Ceiling division operation (rounds towards positive infinity).
- //
- // For positive divisors, it can be implemented without branching and with a
- // single division operation as
- //
- // a ceildiv b =
- // let negative = a <= 0 in
- // let absolute = negative ? -a : a - 1 in
- // let quotient = absolute / b in
- // negative ? -quotient : quotient + 1
+ /// Ceiling division operation (rounds towards positive infinity).
+ ///
+ /// For positive divisors, it can be implemented without branching and with a
+ /// single division operation as
+ ///
+ /// a ceildiv b =
+ /// let negative = a <= 0 in
+ /// let absolute = negative ? -a : a - 1 in
+ /// let quotient = absolute / b in
+ /// negative ? -quotient : quotient + 1
Value visitCeilDivExpr(AffineBinaryOpExpr expr) {
auto rhsConst = expr.getRHS().dyn_cast<AffineConstantExpr>();
if (!rhsConst) {
};
} // namespace
-// Create a sequence of operations that implement the `expr` applied to the
-// given dimension and symbol values.
+/// Create a sequence of operations that implement the `expr` applied to the
+/// given dimension and symbol values.
mlir::Value mlir::expandAffineExpr(OpBuilder &builder, Location loc,
AffineExpr expr, ArrayRef<Value> dimValues,
ArrayRef<Value> symbolValues) {
return AffineApplyExpander(builder, dimValues, symbolValues, loc).visit(expr);
}
-// Create a sequence of operations that implement the `affineMap` applied to
-// the given `operands` (as it it were an AffineApplyOp).
+/// Create a sequence of operations that implement the `affineMap` applied to
+/// the given `operands` (as it it were an AffineApplyOp).
Optional<SmallVector<Value, 8>> static expandAffineMap(
OpBuilder &builder, Location loc, AffineMap affineMap,
ArrayRef<Value> operands) {
return None;
}
-// Given a range of values, emit the code that reduces them with "min" or "max"
-// depending on the provided comparison predicate. The predicate defines which
-// comparison to perform, "lt" for "min", "gt" for "max" and is used for the
-// `cmpi` operation followed by the `select` operation:
-//
-// %cond = cmpi "predicate" %v0, %v1
-// %result = select %cond, %v0, %v1
-//
-// Multiple values are scanned in a linear sequence. This creates a data
-// dependences that wouldn't exist in a tree reduction, but is easier to
-// recognize as a reduction by the subsequent passes.
+/// Given a range of values, emit the code that reduces them with "min" or "max"
+/// depending on the provided comparison predicate. The predicate defines which
+/// comparison to perform, "lt" for "min", "gt" for "max" and is used for the
+/// `cmpi` operation followed by the `select` operation:
+///
+/// %cond = cmpi "predicate" %v0, %v1
+/// %result = select %cond, %v0, %v1
+///
+/// Multiple values are scanned in a linear sequence. This creates a data
+/// dependences that wouldn't exist in a tree reduction, but is easier to
+/// recognize as a reduction by the subsequent passes.
static Value buildMinMaxReductionSeq(Location loc, CmpIPredicate predicate,
ArrayRef<Value> values,
OpBuilder &builder) {
return value;
}
-// Emit instructions that correspond to the affine map in the lower bound
-// applied to the respective operands, and compute the maximum value across
-// the results.
+/// Emit instructions that correspond to the affine map in the lower bound
+/// applied to the respective operands, and compute the maximum value across
+/// the results.
Value mlir::lowerAffineLowerBound(AffineForOp op, OpBuilder &builder) {
SmallVector<Value, 8> boundOperands(op.getLowerBoundOperands());
auto lbValues = expandAffineMap(builder, op.getLoc(), op.getLowerBoundMap(),
builder);
}
-// Emit instructions that correspond to computing the minimum value amoung the
-// values of a (potentially) multi-output affine map applied to `operands`.
+/// Emit instructions that correspond to computing the minimum value amoung the
+/// values of a (potentially) multi-output affine map applied to `operands`.
static Value lowerAffineMapMin(OpBuilder &builder, Location loc, AffineMap map,
ValueRange operands) {
if (auto values =
return nullptr;
}
-// Emit instructions that correspond to the affine map in the upper bound
-// applied to the respective operands, and compute the minimum value across
-// the results.
+/// Emit instructions that correspond to the affine map in the upper bound
+/// applied to the respective operands, and compute the minimum value across
+/// the results.
Value mlir::lowerAffineUpperBound(AffineForOp op, OpBuilder &builder) {
return lowerAffineMapMin(builder, op.getLoc(), op.getUpperBoundMap(),
op.getUpperBoundOperands());
}
};
-// Affine terminators are removed.
+/// Affine terminators are removed.
class AffineTerminatorLowering : public OpRewritePattern<AffineTerminatorOp> {
public:
using OpRewritePattern<AffineTerminatorOp>::OpRewritePattern;
}
};
-// Convert an "affine.apply" operation into a sequence of arithmetic
-// operations using the StandardOps dialect.
+/// Convert an "affine.apply" operation into a sequence of arithmetic
+/// operations using the StandardOps dialect.
class AffineApplyLowering : public OpRewritePattern<AffineApplyOp> {
public:
using OpRewritePattern<AffineApplyOp>::OpRewritePattern;
}
};
-// Apply the affine map from an 'affine.load' operation to its operands, and
-// feed the results to a newly created 'std.load' operation (which replaces the
-// original 'affine.load').
+/// Apply the affine map from an 'affine.load' operation to its operands, and
+/// feed the results to a newly created 'std.load' operation (which replaces the
+/// original 'affine.load').
class AffineLoadLowering : public OpRewritePattern<AffineLoadOp> {
public:
using OpRewritePattern<AffineLoadOp>::OpRewritePattern;
}
};
-// Apply the affine map from an 'affine.prefetch' operation to its operands, and
-// feed the results to a newly created 'std.prefetch' operation (which replaces
-// the original 'affine.prefetch').
+/// Apply the affine map from an 'affine.prefetch' operation to its operands,
+/// and feed the results to a newly created 'std.prefetch' operation (which
+/// replaces the original 'affine.prefetch').
class AffinePrefetchLowering : public OpRewritePattern<AffinePrefetchOp> {
public:
using OpRewritePattern<AffinePrefetchOp>::OpRewritePattern;
}
};
-// Apply the affine map from an 'affine.store' operation to its operands, and
-// feed the results to a newly created 'std.store' operation (which replaces the
-// original 'affine.store').
+/// Apply the affine map from an 'affine.store' operation to its operands, and
+/// feed the results to a newly created 'std.store' operation (which replaces
+/// the original 'affine.store').
class AffineStoreLowering : public OpRewritePattern<AffineStoreOp> {
public:
using OpRewritePattern<AffineStoreOp>::OpRewritePattern;
}
};
-// Apply the affine maps from an 'affine.dma_start' operation to each of their
-// respective map operands, and feed the results to a newly created
-// 'std.dma_start' operation (which replaces the original 'affine.dma_start').
+/// Apply the affine maps from an 'affine.dma_start' operation to each of their
+/// respective map operands, and feed the results to a newly created
+/// 'std.dma_start' operation (which replaces the original 'affine.dma_start').
class AffineDmaStartLowering : public OpRewritePattern<AffineDmaStartOp> {
public:
using OpRewritePattern<AffineDmaStartOp>::OpRewritePattern;
}
};
-// Apply the affine map from an 'affine.dma_wait' operation tag memref,
-// and feed the results to a newly created 'std.dma_wait' operation (which
-// replaces the original 'affine.dma_wait').
+/// Apply the affine map from an 'affine.dma_wait' operation tag memref,
+/// and feed the results to a newly created 'std.dma_wait' operation (which
+/// replaces the original 'affine.dma_wait').
class AffineDmaWaitLowering : public OpRewritePattern<AffineDmaWaitOp> {
public:
using OpRewritePattern<AffineDmaWaitOp>::OpRewritePattern;
projects / platform / upstream / llvm.git / commitdiff