54eee1e947
Reapply https://github.com/llvm/llvm-project/pull/171221 - Fix builder by linking `MLIRTransformUtils`. Also move headers to `mlir/Conversion/ArithAndMathToAPFloat`.
624 lines
27 KiB
C++
624 lines
27 KiB
C++
//===- ArithToAPFloat.cpp - Arithmetic to APFloat Conversion --------------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "Utils.h"
|
|
|
|
#include "mlir/Conversion/ArithAndMathToAPFloat/ArithToAPFloat.h"
|
|
#include "mlir/Dialect/Arith/IR/Arith.h"
|
|
#include "mlir/Dialect/Arith/Transforms/Passes.h"
|
|
#include "mlir/Dialect/Func/IR/FuncOps.h"
|
|
#include "mlir/Dialect/Func/Utils/Utils.h"
|
|
#include "mlir/Dialect/Vector/IR/VectorOps.h"
|
|
#include "mlir/IR/PatternMatch.h"
|
|
#include "mlir/IR/Verifier.h"
|
|
#include "mlir/Transforms/WalkPatternRewriteDriver.h"
|
|
|
|
namespace mlir {
|
|
#define GEN_PASS_DEF_ARITHTOAPFLOATCONVERSIONPASS
|
|
#include "mlir/Conversion/Passes.h.inc"
|
|
} // namespace mlir
|
|
|
|
using namespace mlir;
|
|
using namespace mlir::func;
|
|
|
|
/// Helper function to look up or create the symbol for a runtime library
|
|
/// function for a binary arithmetic operation.
|
|
///
|
|
/// Parameter 1: APFloat semantics
|
|
/// Parameter 2: Left-hand side operand
|
|
/// Parameter 3: Right-hand side operand
|
|
///
|
|
/// This function will return a failure if the function is found but has an
|
|
/// unexpected signature.
|
|
///
|
|
static FailureOr<FuncOp>
|
|
lookupOrCreateBinaryFn(OpBuilder &b, SymbolOpInterface symTable, StringRef name,
|
|
SymbolTableCollection *symbolTables = nullptr) {
|
|
auto i32Type = IntegerType::get(symTable->getContext(), 32);
|
|
auto i64Type = IntegerType::get(symTable->getContext(), 64);
|
|
std::string funcName = (llvm::Twine("_mlir_apfloat_") + name).str();
|
|
return lookupOrCreateFnDecl(b, symTable, funcName,
|
|
{i32Type, i64Type, i64Type}, symbolTables);
|
|
}
|
|
|
|
/// Given two operands of vector type and vector result type (with the same
|
|
/// shape), call the given function for each pair of scalar operands and
|
|
/// package the result into a vector. If the given operands and result type are
|
|
/// not vectors, call the function directly. The second operand is optional.
|
|
template <typename Fn, typename... Values>
|
|
static Value forEachScalarValue(RewriterBase &rewriter, Location loc,
|
|
Value operand1, Value operand2, Type resultType,
|
|
Fn fn) {
|
|
auto vecTy1 = dyn_cast<VectorType>(operand1.getType());
|
|
if (operand2) {
|
|
// Sanity check: Operand types must match.
|
|
assert(vecTy1 == dyn_cast<VectorType>(operand2.getType()) &&
|
|
"expected same vector types");
|
|
}
|
|
if (!vecTy1) {
|
|
// Not a vector. Call the function directly.
|
|
return fn(operand1, operand2, resultType);
|
|
}
|
|
|
|
// Prepare scalar operands.
|
|
ResultRange sclars1 =
|
|
vector::ToElementsOp::create(rewriter, loc, operand1)->getResults();
|
|
SmallVector<Value> scalars2;
|
|
if (!operand2) {
|
|
// No second operand. Create a vector of empty values.
|
|
scalars2.assign(vecTy1.getNumElements(), Value());
|
|
} else {
|
|
llvm::append_range(
|
|
scalars2,
|
|
vector::ToElementsOp::create(rewriter, loc, operand2)->getResults());
|
|
}
|
|
|
|
// Call the function for each pair of scalar operands.
|
|
auto resultVecType = cast<VectorType>(resultType);
|
|
SmallVector<Value> results;
|
|
for (auto [scalar1, scalar2] : llvm::zip_equal(sclars1, scalars2)) {
|
|
Value result = fn(scalar1, scalar2, resultVecType.getElementType());
|
|
results.push_back(result);
|
|
}
|
|
|
|
// Package the results into a vector.
|
|
return vector::FromElementsOp::create(
|
|
rewriter, loc,
|
|
vecTy1.cloneWith(/*shape=*/std::nullopt, results.front().getType()),
|
|
results);
|
|
}
|
|
|
|
/// Check preconditions for the conversion:
|
|
/// 1. All operands / results must be integers or floats (or vectors thereof).
|
|
/// 2. The bitwidth of the operands / results must be <= 64.
|
|
static LogicalResult checkPreconditions(RewriterBase &rewriter, Operation *op) {
|
|
for (Value value : llvm::concat<Value>(op->getOperands(), op->getResults())) {
|
|
Type type = value.getType();
|
|
if (auto vecTy = dyn_cast<VectorType>(type)) {
|
|
type = vecTy.getElementType();
|
|
}
|
|
if (!type.isIntOrFloat()) {
|
|
return rewriter.notifyMatchFailure(
|
|
op, "only integers and floats (or vectors thereof) are supported");
|
|
}
|
|
if (type.getIntOrFloatBitWidth() > 64)
|
|
return rewriter.notifyMatchFailure(op,
|
|
"bitwidth > 64 bits is not supported");
|
|
}
|
|
return success();
|
|
}
|
|
|
|
/// Rewrite a binary arithmetic operation to an APFloat function call.
|
|
template <typename OpTy>
|
|
struct BinaryArithOpToAPFloatConversion final : OpRewritePattern<OpTy> {
|
|
BinaryArithOpToAPFloatConversion(MLIRContext *context,
|
|
const char *APFloatName,
|
|
SymbolOpInterface symTable,
|
|
PatternBenefit benefit = 1)
|
|
: OpRewritePattern<OpTy>(context, benefit), symTable(symTable),
|
|
APFloatName(APFloatName) {};
|
|
|
|
LogicalResult matchAndRewrite(OpTy op,
|
|
PatternRewriter &rewriter) const override {
|
|
if (failed(checkPreconditions(rewriter, op)))
|
|
return failure();
|
|
|
|
// Get APFloat function from runtime library.
|
|
FailureOr<FuncOp> fn =
|
|
lookupOrCreateBinaryFn(rewriter, symTable, APFloatName);
|
|
if (failed(fn))
|
|
return fn;
|
|
|
|
// Scalarize and convert to APFloat runtime calls.
|
|
Location loc = op.getLoc();
|
|
rewriter.setInsertionPoint(op);
|
|
Value repl = forEachScalarValue(
|
|
rewriter, loc, op.getLhs(), op.getRhs(), op.getType(),
|
|
[&](Value lhs, Value rhs, Type resultType) {
|
|
// Cast operands to 64-bit integers.
|
|
auto floatTy = cast<FloatType>(resultType);
|
|
auto intWType = rewriter.getIntegerType(floatTy.getWidth());
|
|
auto int64Type = rewriter.getI64Type();
|
|
Value lhsBits = arith::ExtUIOp::create(
|
|
rewriter, loc, int64Type,
|
|
arith::BitcastOp::create(rewriter, loc, intWType, lhs));
|
|
Value rhsBits = arith::ExtUIOp::create(
|
|
rewriter, loc, int64Type,
|
|
arith::BitcastOp::create(rewriter, loc, intWType, rhs));
|
|
|
|
// Call APFloat function.
|
|
Value semValue = getAPFloatSemanticsValue(rewriter, loc, floatTy);
|
|
SmallVector<Value> params = {semValue, lhsBits, rhsBits};
|
|
auto resultOp = func::CallOp::create(rewriter, loc,
|
|
TypeRange(rewriter.getI64Type()),
|
|
SymbolRefAttr::get(*fn), params);
|
|
|
|
// Truncate result to the original width.
|
|
Value truncatedBits = arith::TruncIOp::create(rewriter, loc, intWType,
|
|
resultOp->getResult(0));
|
|
return arith::BitcastOp::create(rewriter, loc, floatTy,
|
|
truncatedBits);
|
|
});
|
|
rewriter.replaceOp(op, repl);
|
|
return success();
|
|
}
|
|
|
|
SymbolOpInterface symTable;
|
|
const char *APFloatName;
|
|
};
|
|
|
|
template <typename OpTy>
|
|
struct FpToFpConversion final : OpRewritePattern<OpTy> {
|
|
FpToFpConversion(MLIRContext *context, SymbolOpInterface symTable,
|
|
PatternBenefit benefit = 1)
|
|
: OpRewritePattern<OpTy>(context, benefit), symTable(symTable) {}
|
|
|
|
LogicalResult matchAndRewrite(OpTy op,
|
|
PatternRewriter &rewriter) const override {
|
|
if (failed(checkPreconditions(rewriter, op)))
|
|
return failure();
|
|
|
|
// Get APFloat function from runtime library.
|
|
auto i32Type = IntegerType::get(symTable->getContext(), 32);
|
|
auto i64Type = IntegerType::get(symTable->getContext(), 64);
|
|
FailureOr<FuncOp> fn =
|
|
lookupOrCreateFnDecl(rewriter, symTable, "_mlir_apfloat_convert",
|
|
{i32Type, i32Type, i64Type});
|
|
if (failed(fn))
|
|
return fn;
|
|
|
|
// Scalarize and convert to APFloat runtime calls.
|
|
Location loc = op.getLoc();
|
|
rewriter.setInsertionPoint(op);
|
|
Value repl = forEachScalarValue(
|
|
rewriter, loc, op.getOperand(), /*operand2=*/Value(), op.getType(),
|
|
[&](Value operand1, Value operand2, Type resultType) {
|
|
// Cast operands to 64-bit integers.
|
|
auto inFloatTy = cast<FloatType>(operand1.getType());
|
|
auto inIntWType = rewriter.getIntegerType(inFloatTy.getWidth());
|
|
Value operandBits = arith::ExtUIOp::create(
|
|
rewriter, loc, i64Type,
|
|
arith::BitcastOp::create(rewriter, loc, inIntWType, operand1));
|
|
|
|
// Call APFloat function.
|
|
Value inSemValue = getAPFloatSemanticsValue(rewriter, loc, inFloatTy);
|
|
auto outFloatTy = cast<FloatType>(resultType);
|
|
Value outSemValue =
|
|
getAPFloatSemanticsValue(rewriter, loc, outFloatTy);
|
|
std::array<Value, 3> params = {inSemValue, outSemValue, operandBits};
|
|
auto resultOp = func::CallOp::create(rewriter, loc,
|
|
TypeRange(rewriter.getI64Type()),
|
|
SymbolRefAttr::get(*fn), params);
|
|
|
|
// Truncate result to the original width.
|
|
auto outIntWType = rewriter.getIntegerType(outFloatTy.getWidth());
|
|
Value truncatedBits = arith::TruncIOp::create(
|
|
rewriter, loc, outIntWType, resultOp->getResult(0));
|
|
return arith::BitcastOp::create(rewriter, loc, outFloatTy,
|
|
truncatedBits);
|
|
});
|
|
rewriter.replaceOp(op, repl);
|
|
return success();
|
|
}
|
|
|
|
SymbolOpInterface symTable;
|
|
};
|
|
|
|
template <typename OpTy>
|
|
struct FpToIntConversion final : OpRewritePattern<OpTy> {
|
|
FpToIntConversion(MLIRContext *context, SymbolOpInterface symTable,
|
|
bool isUnsigned, PatternBenefit benefit = 1)
|
|
: OpRewritePattern<OpTy>(context, benefit), symTable(symTable),
|
|
isUnsigned(isUnsigned) {}
|
|
|
|
LogicalResult matchAndRewrite(OpTy op,
|
|
PatternRewriter &rewriter) const override {
|
|
if (failed(checkPreconditions(rewriter, op)))
|
|
return failure();
|
|
|
|
// Get APFloat function from runtime library.
|
|
auto i1Type = IntegerType::get(symTable->getContext(), 1);
|
|
auto i32Type = IntegerType::get(symTable->getContext(), 32);
|
|
auto i64Type = IntegerType::get(symTable->getContext(), 64);
|
|
FailureOr<FuncOp> fn =
|
|
lookupOrCreateFnDecl(rewriter, symTable, "_mlir_apfloat_convert_to_int",
|
|
{i32Type, i32Type, i1Type, i64Type});
|
|
if (failed(fn))
|
|
return fn;
|
|
|
|
// Scalarize and convert to APFloat runtime calls.
|
|
Location loc = op.getLoc();
|
|
rewriter.setInsertionPoint(op);
|
|
Value repl = forEachScalarValue(
|
|
rewriter, loc, op.getOperand(), /*operand2=*/Value(), op.getType(),
|
|
[&](Value operand1, Value operand2, Type resultType) {
|
|
// Cast operands to 64-bit integers.
|
|
auto inFloatTy = cast<FloatType>(operand1.getType());
|
|
auto inIntWType = rewriter.getIntegerType(inFloatTy.getWidth());
|
|
Value operandBits = arith::ExtUIOp::create(
|
|
rewriter, loc, i64Type,
|
|
arith::BitcastOp::create(rewriter, loc, inIntWType, operand1));
|
|
|
|
// Call APFloat function.
|
|
Value inSemValue = getAPFloatSemanticsValue(rewriter, loc, inFloatTy);
|
|
auto outIntTy = cast<IntegerType>(resultType);
|
|
Value outWidthValue = arith::ConstantOp::create(
|
|
rewriter, loc, i32Type,
|
|
rewriter.getIntegerAttr(i32Type, outIntTy.getWidth()));
|
|
Value isUnsignedValue = arith::ConstantOp::create(
|
|
rewriter, loc, i1Type,
|
|
rewriter.getIntegerAttr(i1Type, isUnsigned));
|
|
SmallVector<Value> params = {inSemValue, outWidthValue,
|
|
isUnsignedValue, operandBits};
|
|
auto resultOp = func::CallOp::create(rewriter, loc,
|
|
TypeRange(rewriter.getI64Type()),
|
|
SymbolRefAttr::get(*fn), params);
|
|
|
|
// Truncate result to the original width.
|
|
return arith::TruncIOp::create(rewriter, loc, outIntTy,
|
|
resultOp->getResult(0));
|
|
});
|
|
rewriter.replaceOp(op, repl);
|
|
return success();
|
|
}
|
|
|
|
SymbolOpInterface symTable;
|
|
bool isUnsigned;
|
|
};
|
|
|
|
template <typename OpTy>
|
|
struct IntToFpConversion final : OpRewritePattern<OpTy> {
|
|
IntToFpConversion(MLIRContext *context, SymbolOpInterface symTable,
|
|
bool isUnsigned, PatternBenefit benefit = 1)
|
|
: OpRewritePattern<OpTy>(context, benefit), symTable(symTable),
|
|
isUnsigned(isUnsigned) {}
|
|
|
|
LogicalResult matchAndRewrite(OpTy op,
|
|
PatternRewriter &rewriter) const override {
|
|
if (failed(checkPreconditions(rewriter, op)))
|
|
return failure();
|
|
|
|
// Get APFloat function from runtime library.
|
|
auto i1Type = IntegerType::get(symTable->getContext(), 1);
|
|
auto i32Type = IntegerType::get(symTable->getContext(), 32);
|
|
auto i64Type = IntegerType::get(symTable->getContext(), 64);
|
|
FailureOr<FuncOp> fn = lookupOrCreateFnDecl(
|
|
rewriter, symTable, "_mlir_apfloat_convert_from_int",
|
|
{i32Type, i32Type, i1Type, i64Type});
|
|
if (failed(fn))
|
|
return fn;
|
|
|
|
// Scalarize and convert to APFloat runtime calls.
|
|
Location loc = op.getLoc();
|
|
rewriter.setInsertionPoint(op);
|
|
Value repl = forEachScalarValue(
|
|
rewriter, loc, op.getOperand(), /*operand2=*/Value(), op.getType(),
|
|
[&](Value operand1, Value operand2, Type resultType) {
|
|
// Cast operands to 64-bit integers.
|
|
auto inIntTy = cast<IntegerType>(operand1.getType());
|
|
Value operandBits = operand1;
|
|
if (operandBits.getType().getIntOrFloatBitWidth() < 64) {
|
|
if (isUnsigned) {
|
|
operandBits =
|
|
arith::ExtUIOp::create(rewriter, loc, i64Type, operandBits);
|
|
} else {
|
|
operandBits =
|
|
arith::ExtSIOp::create(rewriter, loc, i64Type, operandBits);
|
|
}
|
|
}
|
|
|
|
// Call APFloat function.
|
|
auto outFloatTy = cast<FloatType>(resultType);
|
|
Value outSemValue =
|
|
getAPFloatSemanticsValue(rewriter, loc, outFloatTy);
|
|
Value inWidthValue = arith::ConstantOp::create(
|
|
rewriter, loc, i32Type,
|
|
rewriter.getIntegerAttr(i32Type, inIntTy.getWidth()));
|
|
Value isUnsignedValue = arith::ConstantOp::create(
|
|
rewriter, loc, i1Type,
|
|
rewriter.getIntegerAttr(i1Type, isUnsigned));
|
|
SmallVector<Value> params = {outSemValue, inWidthValue,
|
|
isUnsignedValue, operandBits};
|
|
auto resultOp = func::CallOp::create(rewriter, loc,
|
|
TypeRange(rewriter.getI64Type()),
|
|
SymbolRefAttr::get(*fn), params);
|
|
|
|
// Truncate result to the original width.
|
|
auto outIntWType = rewriter.getIntegerType(outFloatTy.getWidth());
|
|
Value truncatedBits = arith::TruncIOp::create(
|
|
rewriter, loc, outIntWType, resultOp->getResult(0));
|
|
return arith::BitcastOp::create(rewriter, loc, outFloatTy,
|
|
truncatedBits);
|
|
});
|
|
rewriter.replaceOp(op, repl);
|
|
return success();
|
|
}
|
|
|
|
SymbolOpInterface symTable;
|
|
bool isUnsigned;
|
|
};
|
|
|
|
struct CmpFOpToAPFloatConversion final : OpRewritePattern<arith::CmpFOp> {
|
|
CmpFOpToAPFloatConversion(MLIRContext *context, SymbolOpInterface symTable,
|
|
PatternBenefit benefit = 1)
|
|
: OpRewritePattern<arith::CmpFOp>(context, benefit), symTable(symTable) {}
|
|
|
|
LogicalResult matchAndRewrite(arith::CmpFOp op,
|
|
PatternRewriter &rewriter) const override {
|
|
if (failed(checkPreconditions(rewriter, op)))
|
|
return failure();
|
|
|
|
// Get APFloat function from runtime library.
|
|
auto i1Type = IntegerType::get(symTable->getContext(), 1);
|
|
auto i8Type = IntegerType::get(symTable->getContext(), 8);
|
|
auto i32Type = IntegerType::get(symTable->getContext(), 32);
|
|
auto i64Type = IntegerType::get(symTable->getContext(), 64);
|
|
FailureOr<FuncOp> fn =
|
|
lookupOrCreateFnDecl(rewriter, symTable, "_mlir_apfloat_compare",
|
|
{i32Type, i64Type, i64Type}, nullptr, i8Type);
|
|
if (failed(fn))
|
|
return fn;
|
|
|
|
// Scalarize and convert to APFloat runtime calls.
|
|
Location loc = op.getLoc();
|
|
rewriter.setInsertionPoint(op);
|
|
Value repl = forEachScalarValue(
|
|
rewriter, loc, op.getLhs(), op.getRhs(), op.getType(),
|
|
[&](Value lhs, Value rhs, Type resultType) {
|
|
// Cast operands to 64-bit integers.
|
|
auto floatTy = cast<FloatType>(lhs.getType());
|
|
auto intWType = rewriter.getIntegerType(floatTy.getWidth());
|
|
Value lhsBits = arith::ExtUIOp::create(
|
|
rewriter, loc, i64Type,
|
|
arith::BitcastOp::create(rewriter, loc, intWType, lhs));
|
|
Value rhsBits = arith::ExtUIOp::create(
|
|
rewriter, loc, i64Type,
|
|
arith::BitcastOp::create(rewriter, loc, intWType, rhs));
|
|
|
|
// Call APFloat function.
|
|
Value semValue = getAPFloatSemanticsValue(rewriter, loc, floatTy);
|
|
SmallVector<Value> params = {semValue, lhsBits, rhsBits};
|
|
Value comparisonResult =
|
|
func::CallOp::create(rewriter, loc, TypeRange(i8Type),
|
|
SymbolRefAttr::get(*fn), params)
|
|
->getResult(0);
|
|
|
|
// Generate an i1 SSA value that is "true" if the comparison result
|
|
// matches the given `val`.
|
|
auto checkResult = [&](llvm::APFloat::cmpResult val) {
|
|
return arith::CmpIOp::create(
|
|
rewriter, loc, arith::CmpIPredicate::eq, comparisonResult,
|
|
arith::ConstantOp::create(
|
|
rewriter, loc, i8Type,
|
|
rewriter.getIntegerAttr(i8Type, static_cast<int8_t>(val)))
|
|
.getResult());
|
|
};
|
|
// Generate an i1 SSA value that is "true" if the comparison result
|
|
// matches any of the given `vals`.
|
|
std::function<Value(ArrayRef<llvm::APFloat::cmpResult>)>
|
|
checkResults = [&](ArrayRef<llvm::APFloat::cmpResult> vals) {
|
|
Value first = checkResult(vals.front());
|
|
if (vals.size() == 1)
|
|
return first;
|
|
Value rest = checkResults(vals.drop_front());
|
|
return arith::OrIOp::create(rewriter, loc, first, rest)
|
|
.getResult();
|
|
};
|
|
|
|
// This switch-case statement was taken from arith::applyCmpPredicate.
|
|
Value result;
|
|
switch (op.getPredicate()) {
|
|
case arith::CmpFPredicate::AlwaysFalse:
|
|
result =
|
|
arith::ConstantOp::create(rewriter, loc, i1Type,
|
|
rewriter.getIntegerAttr(i1Type, 0))
|
|
.getResult();
|
|
break;
|
|
case arith::CmpFPredicate::OEQ:
|
|
result = checkResult(llvm::APFloat::cmpEqual);
|
|
break;
|
|
case arith::CmpFPredicate::OGT:
|
|
result = checkResult(llvm::APFloat::cmpGreaterThan);
|
|
break;
|
|
case arith::CmpFPredicate::OGE:
|
|
result = checkResults(
|
|
{llvm::APFloat::cmpGreaterThan, llvm::APFloat::cmpEqual});
|
|
break;
|
|
case arith::CmpFPredicate::OLT:
|
|
result = checkResult(llvm::APFloat::cmpLessThan);
|
|
break;
|
|
case arith::CmpFPredicate::OLE:
|
|
result = checkResults(
|
|
{llvm::APFloat::cmpLessThan, llvm::APFloat::cmpEqual});
|
|
break;
|
|
case arith::CmpFPredicate::ONE:
|
|
// Not cmpUnordered and not cmpUnordered.
|
|
result = checkResults(
|
|
{llvm::APFloat::cmpLessThan, llvm::APFloat::cmpGreaterThan});
|
|
break;
|
|
case arith::CmpFPredicate::ORD:
|
|
// Not cmpUnordered.
|
|
result = checkResults({llvm::APFloat::cmpLessThan,
|
|
llvm::APFloat::cmpGreaterThan,
|
|
llvm::APFloat::cmpEqual});
|
|
break;
|
|
case arith::CmpFPredicate::UEQ:
|
|
result = checkResults(
|
|
{llvm::APFloat::cmpUnordered, llvm::APFloat::cmpEqual});
|
|
break;
|
|
case arith::CmpFPredicate::UGT:
|
|
result = checkResults(
|
|
{llvm::APFloat::cmpUnordered, llvm::APFloat::cmpGreaterThan});
|
|
break;
|
|
case arith::CmpFPredicate::UGE:
|
|
result = checkResults({llvm::APFloat::cmpUnordered,
|
|
llvm::APFloat::cmpGreaterThan,
|
|
llvm::APFloat::cmpEqual});
|
|
break;
|
|
case arith::CmpFPredicate::ULT:
|
|
result = checkResults(
|
|
{llvm::APFloat::cmpUnordered, llvm::APFloat::cmpLessThan});
|
|
break;
|
|
case arith::CmpFPredicate::ULE:
|
|
result = checkResults({llvm::APFloat::cmpUnordered,
|
|
llvm::APFloat::cmpLessThan,
|
|
llvm::APFloat::cmpEqual});
|
|
break;
|
|
case arith::CmpFPredicate::UNE:
|
|
// Not cmpEqual.
|
|
result = checkResults({llvm::APFloat::cmpLessThan,
|
|
llvm::APFloat::cmpGreaterThan,
|
|
llvm::APFloat::cmpUnordered});
|
|
break;
|
|
case arith::CmpFPredicate::UNO:
|
|
result = checkResult(llvm::APFloat::cmpUnordered);
|
|
break;
|
|
case arith::CmpFPredicate::AlwaysTrue:
|
|
result =
|
|
arith::ConstantOp::create(rewriter, loc, i1Type,
|
|
rewriter.getIntegerAttr(i1Type, 1))
|
|
.getResult();
|
|
break;
|
|
}
|
|
return result;
|
|
});
|
|
rewriter.replaceOp(op, repl);
|
|
return success();
|
|
}
|
|
|
|
SymbolOpInterface symTable;
|
|
};
|
|
|
|
struct NegFOpToAPFloatConversion final : OpRewritePattern<arith::NegFOp> {
|
|
NegFOpToAPFloatConversion(MLIRContext *context, SymbolOpInterface symTable,
|
|
PatternBenefit benefit = 1)
|
|
: OpRewritePattern<arith::NegFOp>(context, benefit), symTable(symTable) {}
|
|
|
|
LogicalResult matchAndRewrite(arith::NegFOp op,
|
|
PatternRewriter &rewriter) const override {
|
|
if (failed(checkPreconditions(rewriter, op)))
|
|
return failure();
|
|
|
|
// Get APFloat function from runtime library.
|
|
auto i32Type = IntegerType::get(symTable->getContext(), 32);
|
|
auto i64Type = IntegerType::get(symTable->getContext(), 64);
|
|
FailureOr<FuncOp> fn = lookupOrCreateFnDecl(
|
|
rewriter, symTable, "_mlir_apfloat_neg", {i32Type, i64Type});
|
|
if (failed(fn))
|
|
return fn;
|
|
|
|
// Scalarize and convert to APFloat runtime calls.
|
|
Location loc = op.getLoc();
|
|
rewriter.setInsertionPoint(op);
|
|
Value repl = forEachScalarValue(
|
|
rewriter, loc, op.getOperand(), /*operand2=*/Value(), op.getType(),
|
|
[&](Value operand1, Value operand2, Type resultType) {
|
|
// Cast operands to 64-bit integers.
|
|
auto floatTy = cast<FloatType>(operand1.getType());
|
|
auto intWType = rewriter.getIntegerType(floatTy.getWidth());
|
|
Value operandBits = arith::ExtUIOp::create(
|
|
rewriter, loc, i64Type,
|
|
arith::BitcastOp::create(rewriter, loc, intWType, operand1));
|
|
|
|
// Call APFloat function.
|
|
Value semValue = getAPFloatSemanticsValue(rewriter, loc, floatTy);
|
|
SmallVector<Value> params = {semValue, operandBits};
|
|
Value negatedBits =
|
|
func::CallOp::create(rewriter, loc, TypeRange(i64Type),
|
|
SymbolRefAttr::get(*fn), params)
|
|
->getResult(0);
|
|
|
|
// Truncate result to the original width.
|
|
Value truncatedBits =
|
|
arith::TruncIOp::create(rewriter, loc, intWType, negatedBits);
|
|
return arith::BitcastOp::create(rewriter, loc, floatTy,
|
|
truncatedBits);
|
|
});
|
|
rewriter.replaceOp(op, repl);
|
|
return success();
|
|
}
|
|
|
|
SymbolOpInterface symTable;
|
|
};
|
|
|
|
namespace {
|
|
struct ArithToAPFloatConversionPass final
|
|
: impl::ArithToAPFloatConversionPassBase<ArithToAPFloatConversionPass> {
|
|
using Base::Base;
|
|
|
|
void runOnOperation() override;
|
|
};
|
|
|
|
void ArithToAPFloatConversionPass::runOnOperation() {
|
|
MLIRContext *context = &getContext();
|
|
RewritePatternSet patterns(context);
|
|
patterns.add<BinaryArithOpToAPFloatConversion<arith::AddFOp>>(context, "add",
|
|
getOperation());
|
|
patterns.add<BinaryArithOpToAPFloatConversion<arith::SubFOp>>(
|
|
context, "subtract", getOperation());
|
|
patterns.add<BinaryArithOpToAPFloatConversion<arith::MulFOp>>(
|
|
context, "multiply", getOperation());
|
|
patterns.add<BinaryArithOpToAPFloatConversion<arith::DivFOp>>(
|
|
context, "divide", getOperation());
|
|
patterns.add<BinaryArithOpToAPFloatConversion<arith::RemFOp>>(
|
|
context, "remainder", getOperation());
|
|
patterns.add<BinaryArithOpToAPFloatConversion<arith::MinNumFOp>>(
|
|
context, "minnum", getOperation());
|
|
patterns.add<BinaryArithOpToAPFloatConversion<arith::MaxNumFOp>>(
|
|
context, "maxnum", getOperation());
|
|
patterns.add<BinaryArithOpToAPFloatConversion<arith::MinimumFOp>>(
|
|
context, "minimum", getOperation());
|
|
patterns.add<BinaryArithOpToAPFloatConversion<arith::MaximumFOp>>(
|
|
context, "maximum", getOperation());
|
|
patterns
|
|
.add<FpToFpConversion<arith::ExtFOp>, FpToFpConversion<arith::TruncFOp>,
|
|
CmpFOpToAPFloatConversion, NegFOpToAPFloatConversion>(
|
|
context, getOperation());
|
|
patterns.add<FpToIntConversion<arith::FPToSIOp>>(context, getOperation(),
|
|
/*isUnsigned=*/false);
|
|
patterns.add<FpToIntConversion<arith::FPToUIOp>>(context, getOperation(),
|
|
/*isUnsigned=*/true);
|
|
patterns.add<IntToFpConversion<arith::SIToFPOp>>(context, getOperation(),
|
|
/*isUnsigned=*/false);
|
|
patterns.add<IntToFpConversion<arith::UIToFPOp>>(context, getOperation(),
|
|
/*isUnsigned=*/true);
|
|
LogicalResult result = success();
|
|
ScopedDiagnosticHandler scopedHandler(context, [&result](Diagnostic &diag) {
|
|
if (diag.getSeverity() == DiagnosticSeverity::Error) {
|
|
result = failure();
|
|
}
|
|
// NB: if you don't return failure, no other diag handlers will fire (see
|
|
// mlir/lib/IR/Diagnostics.cpp:DiagnosticEngineImpl::emit).
|
|
return failure();
|
|
});
|
|
walkAndApplyPatterns(getOperation(), std::move(patterns));
|
|
if (failed(result))
|
|
return signalPassFailure();
|
|
}
|
|
} // namespace
|