shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity

[MLIR] Allow constFoldBinaryOp to fold (T1, T1) -> T2 (#151410)

Browse Source 
The `constFoldBinaryOp` helper function had limited support for
different input and output types, but the static type of the underlying
value (e.g. `APInt`) had to match between the inputs and the output.

This worked fine for int comparisons of the form `(intN, intN) -> int1`,
as the static type signature was `(APInt, APInt) -> APInt`. However,
float comparisons map `(floatN, floatN) -> int1`, with a static type
signature of `(APFloat, APFloat) -> APInt`. This use case wasn't
supported by `constFoldBinaryOp`.

`constFoldBinaryOp` now accepts an optional template argument overriding
the return type in case it differs from the input type. If the new
template argument isn't provided, the default behavior is unchanged
(i.e. the return type will be assumed to match the input type).

`constFoldUnaryOp` received similar changes in order to support folding
non-cast ops of the form `(T1) -> T2` (e.g. a `sign` op mapping
`(floatN) -> sint32`).
This commit is contained in:
Matthias Guenther 2025-08-07 08:52:03 -07:00 committed by GitHub
parent 6f272d1ecf
commit de2bac367f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
4 changed files with 237 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
mlir/include/mlir/Dialect/CommonFolders.h
View File

@ -15,10 +15,16 @@
#ifndef MLIR_DIALECT_COMMONFOLDERS_H
#define MLIR_DIALECT_COMMONFOLDERS_H
#include "mlir/IR/Attributes.h"
#include "mlir/IR/BuiltinAttributeInterfaces.h"
#include "mlir/IR/BuiltinAttributes.h"
#include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/BuiltinTypeInterfaces.h"
#include "mlir/IR/Types.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/STLExtras.h"
#include <cassert>
#include <cstddef>
#include <optional>
namespace mlir {
@ -30,11 +36,13 @@ class PoisonAttr;
/// Uses `resultType` for the type of the returned attribute.
/// Optional PoisonAttr template argument allows to specify 'poison' attribute
/// which will be directly propagated to result.
template <class AttrElementT,
template <class AttrElementT, //
class ElementValueT = typename AttrElementT::ValueType,
class PoisonAttr = ub::PoisonAttr,
class ResultAttrElementT = AttrElementT,
class ResultElementValueT = typename ResultAttrElementT::ValueType,
class CalculationT = function_ref<
std::optional<ElementValueT>(ElementValueT, ElementValueT)>>
std::optional<ResultElementValueT>(ElementValueT, ElementValueT)>>
Attribute constFoldBinaryOpConditional(ArrayRef<Attribute> operands,
Type resultType,
CalculationT &&calculate) {
@ -65,7 +73,7 @@ Attribute constFoldBinaryOpConditional(ArrayRef<Attribute> operands,
if (!calRes)
return {};
return AttrElementT::get(resultType, *calRes);
return ResultAttrElementT::get(resultType, *calRes);
}
if (isa<SplatElementsAttr>(operands[0]) &&
@ -99,7 +107,7 @@ Attribute constFoldBinaryOpConditional(ArrayRef<Attribute> operands,
return {};
auto lhsIt = *maybeLhsIt;
auto rhsIt = *maybeRhsIt;
SmallVector<ElementValueT, 4> elementResults;
SmallVector<ResultElementValueT, 4> elementResults;
elementResults.reserve(lhs.getNumElements());
for (size_t i = 0, e = lhs.getNumElements(); i < e; ++i, ++lhsIt, ++rhsIt) {
auto elementResult = calculate(*lhsIt, *rhsIt);
@ -119,11 +127,13 @@ Attribute constFoldBinaryOpConditional(ArrayRef<Attribute> operands,
/// attribute.
/// Optional PoisonAttr template argument allows to specify 'poison' attribute
/// which will be directly propagated to result.
template <class AttrElementT,
template <class AttrElementT, //
class ElementValueT = typename AttrElementT::ValueType,
class PoisonAttr = ub::PoisonAttr,
class ResultAttrElementT = AttrElementT,
class ResultElementValueT = typename ResultAttrElementT::ValueType,
class CalculationT = function_ref<
std::optional<ElementValueT>(ElementValueT, ElementValueT)>>
std::optional<ResultElementValueT>(ElementValueT, ElementValueT)>>
Attribute constFoldBinaryOpConditional(ArrayRef<Attribute> operands,
CalculationT &&calculate) {
assert(operands.size() == 2 && "binary op takes two operands");
@ -139,64 +149,73 @@ Attribute constFoldBinaryOpConditional(ArrayRef<Attribute> operands,
return operands[1];
}
auto getResultType = [](Attribute attr) -> Type {
auto getAttrType = [](Attribute attr) -> Type {
if (auto typed = dyn_cast_or_null<TypedAttr>(attr))
return typed.getType();
return {};
};
Type lhsType = getResultType(operands[0]);
Type rhsType = getResultType(operands[1]);
Type lhsType = getAttrType(operands[0]);
Type rhsType = getAttrType(operands[1]);
if (!lhsType || !rhsType)
return {};
if (lhsType != rhsType)
return {};
return constFoldBinaryOpConditional<AttrElementT, ElementValueT, PoisonAttr,
ResultAttrElementT, ResultElementValueT,
CalculationT>(
operands, lhsType, std::forward<CalculationT>(calculate));
}
template <class AttrElementT,
class ElementValueT = typename AttrElementT::ValueType,
class PoisonAttr = void,
class PoisonAttr = void, //
class ResultAttrElementT = AttrElementT,
class ResultElementValueT = typename ResultAttrElementT::ValueType,
class CalculationT =
function_ref<ElementValueT(ElementValueT, ElementValueT)>>
function_ref<ResultElementValueT(ElementValueT, ElementValueT)>>
Attribute constFoldBinaryOp(ArrayRef<Attribute> operands, Type resultType,
CalculationT &&calculate) {
return constFoldBinaryOpConditional<AttrElementT, ElementValueT, PoisonAttr>(
return constFoldBinaryOpConditional<AttrElementT, ElementValueT, PoisonAttr,
ResultAttrElementT>(
operands, resultType,
[&](ElementValueT a, ElementValueT b) -> std::optional<ElementValueT> {
return calculate(a, b);
});
[&](ElementValueT a, ElementValueT b)
-> std::optional<ResultElementValueT> { return calculate(a, b); });
}
template <class AttrElementT,
template <class AttrElementT, //
class ElementValueT = typename AttrElementT::ValueType,
class PoisonAttr = ub::PoisonAttr,
class ResultAttrElementT = AttrElementT,
class ResultElementValueT = typename ResultAttrElementT::ValueType,
class CalculationT =
function_ref<ElementValueT(ElementValueT, ElementValueT)>>
function_ref<ResultElementValueT(ElementValueT, ElementValueT)>>
Attribute constFoldBinaryOp(ArrayRef<Attribute> operands,
CalculationT &&calculate) {
return constFoldBinaryOpConditional<AttrElementT, ElementValueT, PoisonAttr>(
return constFoldBinaryOpConditional<AttrElementT, ElementValueT, PoisonAttr,
ResultAttrElementT>(
operands,
[&](ElementValueT a, ElementValueT b) -> std::optional<ElementValueT> {
return calculate(a, b);
});
[&](ElementValueT a, ElementValueT b)
-> std::optional<ResultElementValueT> { return calculate(a, b); });
}
/// Performs constant folding `calculate` with element-wise behavior on the one
/// attributes in `operands` and returns the result if possible.
/// Uses `resultType` for the type of the returned attribute.
/// Optional PoisonAttr template argument allows to specify 'poison' attribute
/// which will be directly propagated to result.
template <class AttrElementT,
template <class AttrElementT, //
class ElementValueT = typename AttrElementT::ValueType,
class PoisonAttr = ub::PoisonAttr,
class ResultAttrElementT = AttrElementT,
class ResultElementValueT = typename ResultAttrElementT::ValueType,
class CalculationT =
function_ref<std::optional<ElementValueT>(ElementValueT)>>
function_ref<std::optional<ResultElementValueT>(ElementValueT)>>
Attribute constFoldUnaryOpConditional(ArrayRef<Attribute> operands,
Type resultType,
CalculationT &&calculate) {
if (!llvm::getSingleElement(operands))
if (!resultType || !llvm::getSingleElement(operands))
return {};
static_assert(
@ -214,7 +233,7 @@ Attribute constFoldUnaryOpConditional(ArrayRef<Attribute> operands,
auto res = calculate(op.getValue());
if (!res)
return {};
return AttrElementT::get(op.getType(), *res);
return ResultAttrElementT::get(resultType, *res);
}
if (isa<SplatElementsAttr>(operands[0])) {
// Both operands are splats so we can avoid expanding the values out and
@ -224,7 +243,7 @@ Attribute constFoldUnaryOpConditional(ArrayRef<Attribute> operands,
auto elementResult = calculate(op.getSplatValue<ElementValueT>());
if (!elementResult)
return {};
return DenseElementsAttr::get(op.getType(), *elementResult);
return DenseElementsAttr::get(cast<ShapedType>(resultType), *elementResult);
} else if (isa<ElementsAttr>(operands[0])) {
// Operands are ElementsAttr-derived; perform an element-wise fold by
// expanding the values.
@ -234,7 +253,7 @@ Attribute constFoldUnaryOpConditional(ArrayRef<Attribute> operands,
if (!maybeOpIt)
return {};
auto opIt = *maybeOpIt;
SmallVector<ElementValueT> elementResults;
SmallVector<ResultElementValueT> elementResults;
elementResults.reserve(op.getNumElements());
for (size_t i = 0, e = op.getNumElements(); i < e; ++i, ++opIt) {
auto elementResult = calculate(*opIt);
@ -242,19 +261,81 @@ Attribute constFoldUnaryOpConditional(ArrayRef<Attribute> operands,
return {};
elementResults.push_back(*elementResult);
}
return DenseElementsAttr::get(op.getShapedType(), elementResults);
return DenseElementsAttr::get(cast<ShapedType>(resultType), elementResults);
}
return {};
}
template <class AttrElementT,
/// Performs constant folding `calculate` with element-wise behavior on the one
/// attributes in `operands` and returns the result if possible.
/// Uses the operand element type for the element type of the returned
/// attribute.
/// Optional PoisonAttr template argument allows to specify 'poison' attribute
/// which will be directly propagated to result.
template <class AttrElementT, //
class ElementValueT = typename AttrElementT::ValueType,
class PoisonAttr = ub::PoisonAttr,
class CalculationT = function_ref<ElementValueT(ElementValueT)>>
class ResultAttrElementT = AttrElementT,
class ResultElementValueT = typename ResultAttrElementT::ValueType,
class CalculationT =
function_ref<std::optional<ResultElementValueT>(ElementValueT)>>
Attribute constFoldUnaryOpConditional(ArrayRef<Attribute> operands,
CalculationT &&calculate) {
if (!llvm::getSingleElement(operands))
return {};
static_assert(
std::is_void_v<PoisonAttr> || !llvm::is_incomplete_v<PoisonAttr>,
"PoisonAttr is undefined, either add a dependency on UB dialect or pass "
"void as template argument to opt-out from poison semantics.");
if constexpr (!std::is_void_v<PoisonAttr>) {
if (isa<PoisonAttr>(operands[0]))
return operands[0];
}
auto getAttrType = [](Attribute attr) -> Type {
if (auto typed = dyn_cast_or_null<TypedAttr>(attr))
return typed.getType();
return {};
};
Type operandType = getAttrType(operands[0]);
if (!operandType)
return {};
return constFoldUnaryOpConditional<AttrElementT, ElementValueT, PoisonAttr,
ResultAttrElementT, ResultElementValueT,
CalculationT>(
operands, operandType, std::forward<CalculationT>(calculate));
}
template <class AttrElementT, //
class ElementValueT = typename AttrElementT::ValueType,
class PoisonAttr = ub::PoisonAttr,
class ResultAttrElementT = AttrElementT,
class ResultElementValueT = typename ResultAttrElementT::ValueType,
class CalculationT = function_ref<ResultElementValueT(ElementValueT)>>
Attribute constFoldUnaryOp(ArrayRef<Attribute> operands, Type resultType,
CalculationT &&calculate) {
return constFoldUnaryOpConditional<AttrElementT, ElementValueT, PoisonAttr,
ResultAttrElementT>(
operands, resultType,
[&](ElementValueT a) -> std::optional<ResultElementValueT> {
return calculate(a);
});
}
template <class AttrElementT, //
class ElementValueT = typename AttrElementT::ValueType,
class PoisonAttr = ub::PoisonAttr,
class ResultAttrElementT = AttrElementT,
class ResultElementValueT = typename ResultAttrElementT::ValueType,
class CalculationT = function_ref<ResultElementValueT(ElementValueT)>>
Attribute constFoldUnaryOp(ArrayRef<Attribute> operands,
CalculationT &&calculate) {
return constFoldUnaryOpConditional<AttrElementT, ElementValueT, PoisonAttr>(
operands, [&](ElementValueT a) -> std::optional<ElementValueT> {
return constFoldUnaryOpConditional<AttrElementT, ElementValueT, PoisonAttr,
ResultAttrElementT>(
operands, [&](ElementValueT a) -> std::optional<ResultElementValueT> {
return calculate(a);
});
}

22
mlir/test/Dialect/common_folders.mlir Normal file
View File

@ -0,0 +1,22 @@
// RUN: mlir-opt %s --test-fold-type-converting-op --split-input-file | FileCheck %s
// CHECK-LABEL: @test_fold_unary_op_f32_to_si32(
func.func @test_fold_unary_op_f32_to_si32() -> tensor<4x2xsi32> {
// CHECK-NEXT: %[[POSITIVE_ONE:.*]] = arith.constant dense<1> : tensor<4x2xsi32>
// CHECK-NEXT: return %[[POSITIVE_ONE]] : tensor<4x2xsi32>
%operand = arith.constant dense<5.1> : tensor<4x2xf32>
%sign = test.sign %operand : (tensor<4x2xf32>) -> tensor<4x2xsi32>
return %sign : tensor<4x2xsi32>
}
// -----
// CHECK-LABEL: @test_fold_binary_op_f32_to_i1(
func.func @test_fold_binary_op_f32_to_i1() -> tensor<8xi1> {
// CHECK-NEXT: %[[FALSE:.*]] = arith.constant dense<false> : tensor<8xi1>
// CHECK-NEXT: return %[[FALSE]] : tensor<8xi1>
%lhs = arith.constant dense<5.1> : tensor<8xf32>
%rhs = arith.constant dense<4.2> : tensor<8xf32>
%less_than = test.less_than %lhs, %rhs : (tensor<8xf32>, tensor<8xf32>) -> tensor<8xi1>
return %less_than : tensor<8xi1>
}

20
mlir/test/lib/Dialect/Test/TestOps.td
View File

@ -1169,6 +1169,26 @@ def OpP : TEST_Op<"op_p"> {
let results = (outs I32);
}
// Test constant-folding a pattern that maps `(F32) -> SI32`.
def SignOp : TEST_Op<"sign", [SameOperandsAndResultShape]> {
let arguments = (ins RankedTensorOf<[F32]>:$operand);
let results = (outs RankedTensorOf<[SI32]>:$result);
let assemblyFormat = [{
$operand attr-dict `:` functional-type(operands, results)
}];
}
// Test constant-folding a pattern that maps `(F32, F32) -> I1`.
def LessThanOp : TEST_Op<"less_than", [SameOperandsAndResultShape]> {
let arguments = (ins RankedTensorOf<[F32]>:$lhs, RankedTensorOf<[F32]>:$rhs);
let results = (outs RankedTensorOf<[I1]>:$result);
let assemblyFormat = [{
$lhs `,` $rhs attr-dict `:` functional-type(operands, results)
}];
}
// Test same operand name enforces equality condition check.
def TestEqualArgsPattern : Pat<(OpN $a, $a), (OpO $a)>;

81
mlir/test/lib/Dialect/Test/TestPatterns.cpp
View File

@ -10,6 +10,7 @@
#include "TestOps.h"
#include "TestTypes.h"
#include "mlir/Dialect/Arith/IR/Arith.h"
#include "mlir/Dialect/CommonFolders.h"
#include "mlir/Dialect/Func/IR/FuncOps.h"
#include "mlir/Dialect/Func/Transforms/FuncConversions.h"
#include "mlir/Dialect/Tensor/IR/Tensor.h"
@ -202,6 +203,66 @@ struct HoistEligibleOps : public OpRewritePattern<test::OneRegionOp> {
}
};
struct FoldSignOpF32ToSI32 : public OpRewritePattern<test::SignOp> {
using OpRewritePattern<test::SignOp>::OpRewritePattern;
LogicalResult matchAndRewrite(test::SignOp op,
PatternRewriter &rewriter) const override {
if (op->getNumOperands() != 1 || op->getNumResults() != 1)
return failure();
TypedAttr operandAttr;
matchPattern(op->getOperand(0), m_Constant(&operandAttr));
if (!operandAttr)
return failure();
TypedAttr res = cast_or_null<TypedAttr>(
constFoldUnaryOp<FloatAttr, FloatAttr::ValueType, void, IntegerAttr>(
operandAttr, op.getType(), [](APFloat operand) -> APSInt {
static const APFloat zero(0.0f);
int operandSign = 0;
if (operand != zero)
operandSign = (operand < zero) ? -1 : +1;
return APSInt(APInt(32, operandSign), false);
}));
if (!res)
return failure();
rewriter.replaceOpWithNewOp<arith::ConstantOp>(op, res);
return success();
}
};
struct FoldLessThanOpF32ToI1 : public OpRewritePattern<test::LessThanOp> {
using OpRewritePattern<test::LessThanOp>::OpRewritePattern;
LogicalResult matchAndRewrite(test::LessThanOp op,
PatternRewriter &rewriter) const override {
if (op->getNumOperands() != 2 || op->getNumResults() != 1)
return failure();
TypedAttr lhsAttr;
TypedAttr rhsAttr;
matchPattern(op->getOperand(0), m_Constant(&lhsAttr));
matchPattern(op->getOperand(1), m_Constant(&rhsAttr));
if (!lhsAttr || !rhsAttr)
return failure();
Attribute operandAttrs[2] = {lhsAttr, rhsAttr};
TypedAttr res = cast_or_null<TypedAttr>(
constFoldBinaryOp<FloatAttr, FloatAttr::ValueType, void, IntegerAttr>(
operandAttrs, op.getType(), [](APFloat lhs, APFloat rhs) -> APInt {
return APInt(1, lhs < rhs);
}));
if (!res)
return failure();
rewriter.replaceOpWithNewOp<arith::ConstantOp>(op, res);
return success();
}
};
/// This pattern moves "test.move_before_parent_op" before the parent op.
struct MoveBeforeParentOp : public RewritePattern {
MoveBeforeParentOp(MLIRContext *context)
@ -2226,6 +2287,24 @@ struct TestSelectiveReplacementPatternDriver
(void)applyPatternsGreedily(getOperation(), std::move(patterns));
}
};
struct TestFoldTypeConvertingOp
: public PassWrapper<TestFoldTypeConvertingOp, OperationPass<>> {
MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestFoldTypeConvertingOp)
StringRef getArgument() const final { return "test-fold-type-converting-op"; }
StringRef getDescription() const final {
return "Test helper functions for folding ops whose input and output types "
"differ, e.g. float comparisons of the form `(f32, f32) -> i1`.";
}
void runOnOperation() override {
MLIRContext *context = &getContext();
mlir::RewritePatternSet patterns(context);
patterns.add<FoldSignOpF32ToSI32, FoldLessThanOpF32ToI1>(context);
if (failed(applyPatternsGreedily(getOperation(), std::move(patterns))))
signalPassFailure();
}
};
} // namespace
//===----------------------------------------------------------------------===//
@ -2256,6 +2335,8 @@ void registerPatternsTestPass() {
PassRegistration<TestMergeBlocksPatternDriver>();
PassRegistration<TestSelectiveReplacementPatternDriver>();
PassRegistration<TestFoldTypeConvertingOp>();
}
} // namespace test
} // namespace mlir