shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity
llvm-project/flang/lib/Lower/IntrinsicCall.cpp
River Riddle 1b97cdf885 [mlir][IR][NFC] Move context/location parameters of builtin Type::get methods to the start of the parameter list 
This better matches the rest of the infrastructure, is much simpler, and makes it easier to move these types to being declaratively specified.

Differential Revision: https://reviews.llvm.org/D93432
2020-12-17 13:01:36 -08:00

1309 lines
54 KiB
C++
Raw Blame History

//===-- IntrinsicCall.cpp -------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Helper routines for constructing the FIR dialect of MLIR. As FIR is a
// dialect of MLIR, it makes extensive use of MLIR interfaces and MLIR's coding
// style (https://mlir.llvm.org/getting_started/DeveloperGuide/) is used in this
// module.
//
//===----------------------------------------------------------------------===//
#include "flang/Lower/IntrinsicCall.h"
#include "RTBuilder.h"
#include "flang/Common/static-multimap-view.h"
#include "flang/Lower/CharacterExpr.h"
#include "flang/Lower/ComplexExpr.h"
#include "flang/Lower/ConvertType.h"
#include "flang/Lower/FIRBuilder.h"
#include "flang/Lower/Mangler.h"
#include "flang/Lower/Runtime.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ErrorHandling.h"
#include <algorithm>
#include <string_view>
#include <utility>
#define PGMATH_DECLARE
#include "../runtime/pgmath.h.inc"
/// This file implements lowering of Fortran intrinsic procedures.
/// Intrinsics are lowered to a mix of FIR and MLIR operations as
/// well as call to runtime functions or LLVM intrinsics.
/// Lowering of intrinsic procedure calls is based on a map that associates
/// Fortran intrinsic generic names to FIR generator functions.
/// All generator functions are member functions of the IntrinsicLibrary class
/// and have the same interface.
/// If no generator is given for an intrinsic name, a math runtime library
/// is searched for an implementation and, if a runtime function is found,
/// a call is generated for it. LLVM intrinsics are handled as a math
/// runtime library here.
/// Enums used to templatize and share lowering of MIN and MAX.
enum class Extremum { Min, Max };
// There are different ways to deal with NaNs in MIN and MAX.
// Known existing behaviors are listed below and can be selected for
// f18 MIN/MAX implementation.
enum class ExtremumBehavior {
// Note: the Signaling/quiet aspect of NaNs in the behaviors below are
// not described because there is no way to control/observe such aspect in
// MLIR/LLVM yet. The IEEE behaviors come with requirements regarding this
// aspect that are therefore currently not enforced. In the descriptions
// below, NaNs can be signaling or quite. Returned NaNs may be signaling
// if one of the input NaN was signaling but it cannot be guaranteed either.
// Existing compilers using an IEEE behavior (gfortran) also do not fulfill
// signaling/quiet requirements.
IeeeMinMaximumNumber,
// IEEE minimumNumber/maximumNumber behavior (754-2019, section 9.6):
// If one of the argument is and number and the other is NaN, return the
// number. If both arguements are NaN, return NaN.
// Compilers: gfortran.
IeeeMinMaximum,
// IEEE minimum/maximum behavior (754-2019, section 9.6):
// If one of the argument is NaN, return NaN.
MinMaxss,
// x86 minss/maxss behavior:
// If the second argument is a number and the other is NaN, return the number.
// In all other cases where at least one operand is NaN, return NaN.
// Compilers: xlf (only for MAX), ifort, pgfortran -nollvm, and nagfor.
PgfortranLlvm,
// "Opposite of" x86 minss/maxss behavior:
// If the first argument is a number and the other is NaN, return the
// number.
// In all other cases where at least one operand is NaN, return NaN.
// Compilers: xlf (only for MIN), and pgfortran (with llvm).
IeeeMinMaxNum
// IEEE minNum/maxNum behavior (754-2008, section 5.3.1):
// TODO: Not implemented.
// It is the only behavior where the signaling/quiet aspect of a NaN argument
// impacts if the result should be NaN or the argument that is a number.
// LLVM/MLIR do not provide ways to observe this aspect, so it is not
// possible to implement it without some target dependent runtime.
};
// TODO error handling -> return a code or directly emit messages ?
struct IntrinsicLibrary {
// Constructors.
explicit IntrinsicLibrary(Fortran::lower::FirOpBuilder &builder,
mlir::Location loc)
: builder{builder}, loc{loc} {}
IntrinsicLibrary() = delete;
IntrinsicLibrary(const IntrinsicLibrary &) = delete;
/// Generate FIR for call to Fortran intrinsic \p name with arguments \p arg
/// and expected result type \p resultType.
fir::ExtendedValue genIntrinsicCall(llvm::StringRef name,
mlir::Type resultType,
llvm::ArrayRef<fir::ExtendedValue> arg);
/// Search a runtime function that is associated to the generic intrinsic name
/// and whose signature matches the intrinsic arguments and result types.
/// If no such runtime function is found but a runtime function associated
/// with the Fortran generic exists and has the same number of arguments,
/// conversions will be inserted before and/or after the call. This is to
/// mainly to allow 16 bits float support even-though little or no math
/// runtime is currently available for it.
mlir::Value genRuntimeCall(llvm::StringRef name, mlir::Type,
llvm::ArrayRef<mlir::Value>);
using RuntimeCallGenerator =
std::function<mlir::Value(Fortran::lower::FirOpBuilder &, mlir::Location,
llvm::ArrayRef<mlir::Value>)>;
RuntimeCallGenerator
getRuntimeCallGenerator(llvm::StringRef name,
mlir::FunctionType soughtFuncType);
mlir::Value genAbs(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genAimag(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genAint(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genAnint(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genCeiling(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genConjg(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genDim(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genDprod(mlir::Type, llvm::ArrayRef<mlir::Value>);
template <Extremum, ExtremumBehavior>
mlir::Value genExtremum(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genFloor(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genIAnd(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genIchar(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genIEOr(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genIOr(mlir::Type, llvm::ArrayRef<mlir::Value>);
fir::ExtendedValue genLen(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
fir::ExtendedValue genLenTrim(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
mlir::Value genMerge(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genMod(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genNint(mlir::Type, llvm::ArrayRef<mlir::Value>);
mlir::Value genSign(mlir::Type, llvm::ArrayRef<mlir::Value>);
/// Implement all conversion functions like DBLE, the first argument is
/// the value to convert. There may be an additional KIND arguments that
/// is ignored because this is already reflected in the result type.
mlir::Value genConversion(mlir::Type, llvm::ArrayRef<mlir::Value>);
/// Define the different FIR generators that can be mapped to intrinsic to
/// generate the related code.
using ElementalGenerator = decltype(&IntrinsicLibrary::genAbs);
using ExtendedGenerator = decltype(&IntrinsicLibrary::genLenTrim);
using Generator = std::variant<ElementalGenerator, ExtendedGenerator>;
/// All generators can be outlined. This will build a function named
/// "fir."+ <generic name> + "." + <result type code> and generate the
/// intrinsic implementation inside instead of at the intrinsic call sites.
/// This can be used to keep the FIR more readable. Only one function will
/// be generated for all the similar calls in a program.
/// If the Generator is nullptr, the wrapper uses genRuntimeCall.
template <typename GeneratorType>
mlir::Value outlineInWrapper(GeneratorType, llvm::StringRef name,
mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args);
fir::ExtendedValue outlineInWrapper(ExtendedGenerator, llvm::StringRef name,
mlir::Type resultType,
llvm::ArrayRef<fir::ExtendedValue> args);
template <typename GeneratorType>
mlir::FuncOp getWrapper(GeneratorType, llvm::StringRef name,
mlir::FunctionType, bool loadRefArguments = false);
/// Generate calls to ElementalGenerator, handling the elemental aspects
template <typename GeneratorType>
fir::ExtendedValue
genElementalCall(GeneratorType, llvm::StringRef name, mlir::Type resultType,
llvm::ArrayRef<fir::ExtendedValue> args, bool outline);
/// Helper to invoke code generator for the intrinsics given arguments.
mlir::Value invokeGenerator(ElementalGenerator generator,
mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args);
mlir::Value invokeGenerator(RuntimeCallGenerator generator,
mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args);
mlir::Value invokeGenerator(ExtendedGenerator generator,
mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args);
/// Get pointer to unrestricted intrinsic. Generate the related unrestricted
/// intrinsic if it is not defined yet.
mlir::SymbolRefAttr
getUnrestrictedIntrinsicSymbolRefAttr(llvm::StringRef name,
mlir::FunctionType signature);
Fortran::lower::FirOpBuilder &builder;
mlir::Location loc;
};
/// Table that drives the fir generation depending on the intrinsic.
/// one to one mapping with Fortran arguments. If no mapping is
/// defined here for a generic intrinsic, genRuntimeCall will be called
/// to look for a match in the runtime a emit a call.
struct IntrinsicHandler {
const char *name;
IntrinsicLibrary::Generator generator;
bool isElemental = true;
/// Code heavy intrinsic can be outlined to make FIR
/// more readable.
bool outline = false;
};
using I = IntrinsicLibrary;
static constexpr IntrinsicHandler handlers[]{
{"abs", &I::genAbs},
{"achar", &I::genConversion},
{"aimag", &I::genAimag},
{"aint", &I::genAint},
{"anint", &I::genAnint},
{"ceiling", &I::genCeiling},
{"char", &I::genConversion},
{"conjg", &I::genConjg},
{"dim", &I::genDim},
{"dble", &I::genConversion},
{"dprod", &I::genDprod},
{"floor", &I::genFloor},
{"iand", &I::genIAnd},
{"ichar", &I::genIchar},
{"ieor", &I::genIEOr},
{"ior", &I::genIOr},
{"len", &I::genLen},
{"len_trim", &I::genLenTrim},
{"max", &I::genExtremum<Extremum::Max, ExtremumBehavior::MinMaxss>},
{"min", &I::genExtremum<Extremum::Min, ExtremumBehavior::MinMaxss>},
{"merge", &I::genMerge},
{"mod", &I::genMod},
{"nint", &I::genNint},
{"sign", &I::genSign},
};
/// To make fir output more readable for debug, one can outline all intrinsic
/// implementation in wrappers (overrides the IntrinsicHandler::outline flag).
static llvm::cl::opt<bool> outlineAllIntrinsics(
"outline-intrinsics",
llvm::cl::desc(
"Lower all intrinsic procedure implementation in their own functions"),
llvm::cl::init(false));
//===----------------------------------------------------------------------===//
// Math runtime description and matching utility
//===----------------------------------------------------------------------===//
/// Command line option to modify math runtime version used to implement
/// intrinsics.
enum MathRuntimeVersion {
fastVersion,
relaxedVersion,
preciseVersion,
llvmOnly
};
llvm::cl::opt<MathRuntimeVersion> mathRuntimeVersion(
"math-runtime", llvm::cl::desc("Select math runtime version:"),
llvm::cl::values(
clEnumValN(fastVersion, "fast", "use pgmath fast runtime"),
clEnumValN(relaxedVersion, "relaxed", "use pgmath relaxed runtime"),
clEnumValN(preciseVersion, "precise", "use pgmath precise runtime"),
clEnumValN(llvmOnly, "llvm",
"only use LLVM intrinsics (may be incomplete)")),
llvm::cl::init(fastVersion));
struct RuntimeFunction {
// llvm::StringRef comparison operator are not constexpr, so use string_view.
using Key = std::string_view;
// Needed for implicit compare with keys.
constexpr operator Key() const { return key; }
Key key; // intrinsic name
llvm::StringRef symbol;
Fortran::lower::FuncTypeBuilderFunc typeGenerator;
};
#define RUNTIME_STATIC_DESCRIPTION(name, func) \
{#name, #func, \
Fortran::lower::RuntimeTableKey<decltype(func)>::getTypeModel()},
static constexpr RuntimeFunction pgmathFast[] = {
#define PGMATH_FAST
#define PGMATH_USE_ALL_TYPES(name, func) RUNTIME_STATIC_DESCRIPTION(name, func)
#include "../runtime/pgmath.h.inc"
};
static constexpr RuntimeFunction pgmathRelaxed[] = {
#define PGMATH_RELAXED
#define PGMATH_USE_ALL_TYPES(name, func) RUNTIME_STATIC_DESCRIPTION(name, func)
#include "../runtime/pgmath.h.inc"
};
static constexpr RuntimeFunction pgmathPrecise[] = {
#define PGMATH_PRECISE
#define PGMATH_USE_ALL_TYPES(name, func) RUNTIME_STATIC_DESCRIPTION(name, func)
#include "../runtime/pgmath.h.inc"
};
static mlir::FunctionType genF32F32FuncType(mlir::MLIRContext *context) {
auto t = mlir::FloatType::getF32(context);
return mlir::FunctionType::get(context, {t}, {t});
}
static mlir::FunctionType genF64F64FuncType(mlir::MLIRContext *context) {
auto t = mlir::FloatType::getF64(context);
return mlir::FunctionType::get(context, {t}, {t});
}
template <int Bits>
static mlir::FunctionType genIntF64FuncType(mlir::MLIRContext *context) {
auto t = mlir::FloatType::getF64(context);
auto r = mlir::IntegerType::get(context, Bits);
return mlir::FunctionType::get(context, {t}, {r});
}
template <int Bits>
static mlir::FunctionType genIntF32FuncType(mlir::MLIRContext *context) {
auto t = mlir::FloatType::getF32(context);
auto r = mlir::IntegerType::get(context, Bits);
return mlir::FunctionType::get(context, {t}, {r});
}
// TODO : Fill-up this table with more intrinsic.
// Note: These are also defined as operations in LLVM dialect. See if this
// can be use and has advantages.
static constexpr RuntimeFunction llvmIntrinsics[] = {
{"abs", "llvm.fabs.f32", genF32F32FuncType},
{"abs", "llvm.fabs.f64", genF64F64FuncType},
{"aint", "llvm.trunc.f32", genF32F32FuncType},
{"aint", "llvm.trunc.f64", genF64F64FuncType},
{"anint", "llvm.round.f32", genF32F32FuncType},
{"anint", "llvm.round.f64", genF64F64FuncType},
// ceil is used for CEILING but is different, it returns a real.
{"ceil", "llvm.ceil.f32", genF32F32FuncType},
{"ceil", "llvm.ceil.f64", genF64F64FuncType},
{"cos", "llvm.cos.f32", genF32F32FuncType},
{"cos", "llvm.cos.f64", genF64F64FuncType},
// llvm.floor is used for FLOOR, but returns real.
{"floor", "llvm.floor.f32", genF32F32FuncType},
{"floor", "llvm.floor.f64", genF64F64FuncType},
{"log", "llvm.log.f32", genF32F32FuncType},
{"log", "llvm.log.f64", genF64F64FuncType},
{"log10", "llvm.log10.f32", genF32F32FuncType},
{"log10", "llvm.log10.f64", genF64F64FuncType},
{"nint", "llvm.lround.i64.f64", genIntF64FuncType<64>},
{"nint", "llvm.lround.i64.f32", genIntF32FuncType<64>},
{"nint", "llvm.lround.i32.f64", genIntF64FuncType<32>},
{"nint", "llvm.lround.i32.f32", genIntF32FuncType<32>},
{"sin", "llvm.sin.f32", genF32F32FuncType},
{"sin", "llvm.sin.f64", genF64F64FuncType},
{"sqrt", "llvm.sqrt.f32", genF32F32FuncType},
{"sqrt", "llvm.sqrt.f64", genF64F64FuncType},
};
// This helper class computes a "distance" between two function types.
// The distance measures how many narrowing conversions of actual arguments
// and result of "from" must be made in order to use "to" instead of "from".
// For instance, the distance between ACOS(REAL(10)) and ACOS(REAL(8)) is
// greater than the one between ACOS(REAL(10)) and ACOS(REAL(16)). This means
// if no implementation of ACOS(REAL(10)) is available, it is better to use
// ACOS(REAL(16)) with casts rather than ACOS(REAL(8)).
// Note that this is not a symmetric distance and the order of "from" and "to"
// arguments matters, d(foo, bar) may not be the same as d(bar, foo) because it
// may be safe to replace foo by bar, but not the opposite.
class FunctionDistance {
public:
FunctionDistance() : infinite{true} {}
FunctionDistance(mlir::FunctionType from, mlir::FunctionType to) {
auto nInputs = from.getNumInputs();
auto nResults = from.getNumResults();
if (nResults != to.getNumResults() || nInputs != to.getNumInputs()) {
infinite = true;
} else {
for (decltype(nInputs) i{0}; i < nInputs && !infinite; ++i)
addArgumentDistance(from.getInput(i), to.getInput(i));
for (decltype(nResults) i{0}; i < nResults && !infinite; ++i)
addResultDistance(to.getResult(i), from.getResult(i));
}
}
/// Beware both d1.isSmallerThan(d2) *and* d2.isSmallerThan(d1) may be
/// false if both d1 and d2 are infinite. This implies that
/// d1.isSmallerThan(d2) is not equivalent to !d2.isSmallerThan(d1)
bool isSmallerThan(const FunctionDistance &d) const {
return !infinite &&
(d.infinite || std::lexicographical_compare(
conversions.begin(), conversions.end(),
d.conversions.begin(), d.conversions.end()));
}
bool isLosingPrecision() const {
return conversions[narrowingArg] != 0 || conversions[extendingResult] != 0;
}
bool isInfinite() const { return infinite; }
private:
enum class Conversion { Forbidden, None, Narrow, Extend };
void addArgumentDistance(mlir::Type from, mlir::Type to) {
switch (conversionBetweenTypes(from, to)) {
case Conversion::Forbidden:
infinite = true;
break;
case Conversion::None:
break;
case Conversion::Narrow:
conversions[narrowingArg]++;
break;
case Conversion::Extend:
conversions[nonNarrowingArg]++;
break;
}
}
void addResultDistance(mlir::Type from, mlir::Type to) {
switch (conversionBetweenTypes(from, to)) {
case Conversion::Forbidden:
infinite = true;
break;
case Conversion::None:
break;
case Conversion::Narrow:
conversions[nonExtendingResult]++;
break;
case Conversion::Extend:
conversions[extendingResult]++;
break;
}
}
// Floating point can be mlir::FloatType or fir::real
static unsigned getFloatingPointWidth(mlir::Type t) {
if (auto f{t.dyn_cast<mlir::FloatType>()})
return f.getWidth();
// FIXME: Get width another way for fir.real/complex
// - use fir/KindMapping.h and llvm::Type
// - or use evaluate/type.h
if (auto r{t.dyn_cast<fir::RealType>()})
return r.getFKind() * 4;
if (auto cplx{t.dyn_cast<fir::CplxType>()})
return cplx.getFKind() * 4;
llvm_unreachable("not a floating-point type");
}
static Conversion conversionBetweenTypes(mlir::Type from, mlir::Type to) {
if (from == to) {
return Conversion::None;
}
if (auto fromIntTy{from.dyn_cast<mlir::IntegerType>()}) {
if (auto toIntTy{to.dyn_cast<mlir::IntegerType>()}) {
return fromIntTy.getWidth() > toIntTy.getWidth() ? Conversion::Narrow
: Conversion::Extend;
}
}
if (fir::isa_real(from) && fir::isa_real(to)) {
return getFloatingPointWidth(from) > getFloatingPointWidth(to)
? Conversion::Narrow
: Conversion::Extend;
}
if (auto fromCplxTy{from.dyn_cast<fir::CplxType>()}) {
if (auto toCplxTy{to.dyn_cast<fir::CplxType>()}) {
return getFloatingPointWidth(fromCplxTy) >
getFloatingPointWidth(toCplxTy)
? Conversion::Narrow
: Conversion::Extend;
}
}
// Notes:
// - No conversion between character types, specialization of runtime
// functions should be made instead.
// - It is not clear there is a use case for automatic conversions
// around Logical and it may damage hidden information in the physical
// storage so do not do it.
return Conversion::Forbidden;
}
// Below are indexes to access data in conversions.
// The order in data does matter for lexicographical_compare
enum {
narrowingArg = 0, // usually bad
extendingResult, // usually bad
nonExtendingResult, // usually ok
nonNarrowingArg, // usually ok
dataSize
};
std::array<int, dataSize> conversions{/* zero init*/};
bool infinite{false}; // When forbidden conversion or wrong argument number
};
/// Build mlir::FuncOp from runtime symbol description and add
/// fir.runtime attribute.
static mlir::FuncOp getFuncOp(mlir::Location loc,
Fortran::lower::FirOpBuilder &builder,
const RuntimeFunction &runtime) {
auto function = builder.addNamedFunction(
loc, runtime.symbol, runtime.typeGenerator(builder.getContext()));
function->setAttr("fir.runtime", builder.getUnitAttr());
return function;
}
/// Select runtime function that has the smallest distance to the intrinsic
/// function type and that will not imply narrowing arguments or extending the
/// result.
/// If nothing is found, the mlir::FuncOp will contain a nullptr.
mlir::FuncOp searchFunctionInLibrary(
mlir::Location loc, Fortran::lower::FirOpBuilder &builder,
const Fortran::common::StaticMultimapView<RuntimeFunction> &lib,
llvm::StringRef name, mlir::FunctionType funcType,
const RuntimeFunction **bestNearMatch,
FunctionDistance &bestMatchDistance) {
auto range = lib.equal_range(name);
for (auto iter{range.first}; iter != range.second && iter; ++iter) {
const auto &impl = *iter;
auto implType = impl.typeGenerator(builder.getContext());
if (funcType == implType) {
return getFuncOp(loc, builder, impl); // exact match
} else {
FunctionDistance distance(funcType, implType);
if (distance.isSmallerThan(bestMatchDistance)) {
*bestNearMatch = &impl;
bestMatchDistance = std::move(distance);
}
}
}
return {};
}
/// Search runtime for the best runtime function given an intrinsic name
/// and interface. The interface may not be a perfect match in which case
/// the caller is responsible to insert argument and return value conversions.
/// If nothing is found, the mlir::FuncOp will contain a nullptr.
static mlir::FuncOp getRuntimeFunction(mlir::Location loc,
Fortran::lower::FirOpBuilder &builder,
llvm::StringRef name,
mlir::FunctionType funcType) {
const RuntimeFunction *bestNearMatch = nullptr;
FunctionDistance bestMatchDistance{};
mlir::FuncOp match;
using RtMap = Fortran::common::StaticMultimapView<RuntimeFunction>;
static constexpr RtMap pgmathF(pgmathFast);
static_assert(pgmathF.Verify() && "map must be sorted");
static constexpr RtMap pgmathR(pgmathRelaxed);
static_assert(pgmathR.Verify() && "map must be sorted");
static constexpr RtMap pgmathP(pgmathPrecise);
static_assert(pgmathP.Verify() && "map must be sorted");
if (mathRuntimeVersion == fastVersion) {
match = searchFunctionInLibrary(loc, builder, pgmathF, name, funcType,
&bestNearMatch, bestMatchDistance);
} else if (mathRuntimeVersion == relaxedVersion) {
match = searchFunctionInLibrary(loc, builder, pgmathR, name, funcType,
&bestNearMatch, bestMatchDistance);
} else if (mathRuntimeVersion == preciseVersion) {
match = searchFunctionInLibrary(loc, builder, pgmathP, name, funcType,
&bestNearMatch, bestMatchDistance);
} else {
assert(mathRuntimeVersion == llvmOnly && "unknown math runtime");
}
if (match)
return match;
// Go through llvm intrinsics if not exact match in libpgmath or if
// mathRuntimeVersion == llvmOnly
static constexpr RtMap llvmIntr(llvmIntrinsics);
static_assert(llvmIntr.Verify() && "map must be sorted");
if (auto exactMatch =
searchFunctionInLibrary(loc, builder, llvmIntr, name, funcType,
&bestNearMatch, bestMatchDistance))
return exactMatch;
if (bestNearMatch != nullptr) {
assert(!bestMatchDistance.isLosingPrecision() &&
"runtime selection loses precision");
return getFuncOp(loc, builder, *bestNearMatch);
}
return {};
}
/// Helpers to get function type from arguments and result type.
static mlir::FunctionType
getFunctionType(mlir::Type resultType, llvm::ArrayRef<mlir::Value> arguments,
Fortran::lower::FirOpBuilder &builder) {
llvm::SmallVector<mlir::Type, 2> argumentTypes;
for (auto &arg : arguments)
argumentTypes.push_back(arg.getType());
return mlir::FunctionType::get(builder.getModule().getContext(),
argumentTypes, resultType);
}
/// fir::ExtendedValue to mlir::Value translation layer
fir::ExtendedValue toExtendedValue(mlir::Value val,
Fortran::lower::FirOpBuilder &builder,
mlir::Location loc) {
assert(val && "optional unhandled here");
auto type = val.getType();
auto base = val;
auto indexType = builder.getIndexType();
llvm::SmallVector<mlir::Value, 2> extents;
Fortran::lower::CharacterExprHelper charHelper{builder, loc};
if (charHelper.isCharacter(type))
return charHelper.toExtendedValue(val);
if (auto refType = type.dyn_cast<fir::ReferenceType>())
type = refType.getEleTy();
if (auto arrayType = type.dyn_cast<fir::SequenceType>()) {
type = arrayType.getEleTy();
for (auto extent : arrayType.getShape()) {
if (extent == fir::SequenceType::getUnknownExtent())
break;
extents.emplace_back(
builder.createIntegerConstant(loc, indexType, extent));
}
// Last extent might be missing in case of assumed-size. If more extents
// could not be deduced from type, that's an error (a fir.box should
// have been used in the interface).
if (extents.size() + 1 < arrayType.getShape().size())
mlir::emitError(loc, "cannot retrieve array extents from type");
} else if (type.isa<fir::BoxType>() || type.isa<fir::RecordType>()) {
mlir::emitError(loc, "descriptor or derived type not yet handled");
}
if (!extents.empty())
return fir::ArrayBoxValue{base, extents};
return base;
}
mlir::Value toValue(const fir::ExtendedValue &val,
Fortran::lower::FirOpBuilder &builder, mlir::Location loc) {
if (auto charBox = val.getCharBox()) {
auto buffer = charBox->getBuffer();
if (buffer.getType().isa<fir::BoxCharType>())
return buffer;
return Fortran::lower::CharacterExprHelper{builder, loc}.createEmboxChar(
buffer, charBox->getLen());
}
// FIXME: need to access other ExtendedValue variants and handle them
// properly.
return fir::getBase(val);
}
//===----------------------------------------------------------------------===//
// IntrinsicLibrary
//===----------------------------------------------------------------------===//
template <typename GeneratorType>
fir::ExtendedValue IntrinsicLibrary::genElementalCall(
GeneratorType generator, llvm::StringRef name, mlir::Type resultType,
llvm::ArrayRef<fir::ExtendedValue> args, bool outline) {
llvm::SmallVector<mlir::Value, 2> scalarArgs;
for (const auto &arg : args) {
if (arg.getUnboxed() || arg.getCharBox()) {
scalarArgs.emplace_back(fir::getBase(arg));
} else {
// TODO: get the result shape and create the loop...
mlir::emitError(loc, "array or descriptor not yet handled in elemental "
"intrinsic lowering");
exit(1);
}
}
if (outline)
return outlineInWrapper(generator, name, resultType, scalarArgs);
return invokeGenerator(generator, resultType, scalarArgs);
}
/// Some ExtendedGenerator operating on characters are also elemental
/// (e.g LEN_TRIM).
template <>
fir::ExtendedValue
IntrinsicLibrary::genElementalCall<IntrinsicLibrary::ExtendedGenerator>(
ExtendedGenerator generator, llvm::StringRef name, mlir::Type resultType,
llvm::ArrayRef<fir::ExtendedValue> args, bool outline) {
for (const auto &arg : args)
if (!arg.getUnboxed() && !arg.getCharBox()) {
// TODO: get the result shape and create the loop...
mlir::emitError(loc, "array or descriptor not yet handled in elemental "
"intrinsic lowering");
exit(1);
}
if (outline)
return outlineInWrapper(generator, name, resultType, args);
return std::invoke(generator, *this, resultType, args);
}
fir::ExtendedValue
IntrinsicLibrary::genIntrinsicCall(llvm::StringRef name, mlir::Type resultType,
llvm::ArrayRef<fir::ExtendedValue> args) {
for (auto &handler : handlers)
if (name == handler.name) {
bool outline = handler.outline || outlineAllIntrinsics;
if (const auto *elementalGenerator =
std::get_if<ElementalGenerator>(&handler.generator))
return genElementalCall(*elementalGenerator, name, resultType, args,
outline);
const auto &generator = std::get<ExtendedGenerator>(handler.generator);
if (handler.isElemental)
return genElementalCall(generator, name, resultType, args, outline);
if (outline)
return outlineInWrapper(generator, name, resultType, args);
return std::invoke(generator, *this, resultType, args);
}
// Try the runtime if no special handler was defined for the
// intrinsic being called. Maths runtime only has numerical elemental.
// No optional arguments are expected at this point, the code will
// crash if it gets absent optional.
// FIXME: using toValue to get the type won't work with array arguments.
llvm::SmallVector<mlir::Value, 2> mlirArgs;
for (const auto &extendedVal : args) {
auto val = toValue(extendedVal, builder, loc);
if (!val) {
// If an absent optional gets there, most likely its handler has just
// not yet been defined.
mlir::emitError(loc,
"TODO: missing intrinsic lowering: " + llvm::Twine(name));
exit(1);
}
mlirArgs.emplace_back(val);
}
mlir::FunctionType soughtFuncType =
getFunctionType(resultType, mlirArgs, builder);
auto runtimeCallGenerator = getRuntimeCallGenerator(name, soughtFuncType);
return genElementalCall(runtimeCallGenerator, name, resultType, args,
/* outline */ true);
}
mlir::Value
IntrinsicLibrary::invokeGenerator(ElementalGenerator generator,
mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
return std::invoke(generator, *this, resultType, args);
}
mlir::Value
IntrinsicLibrary::invokeGenerator(RuntimeCallGenerator generator,
mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
return generator(builder, loc, args);
}
mlir::Value
IntrinsicLibrary::invokeGenerator(ExtendedGenerator generator,
mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
llvm::SmallVector<fir::ExtendedValue, 2> extendedArgs;
for (auto arg : args)
extendedArgs.emplace_back(toExtendedValue(arg, builder, loc));
auto extendedResult = std::invoke(generator, *this, resultType, extendedArgs);
return toValue(extendedResult, builder, loc);
}
template <typename GeneratorType>
mlir::FuncOp IntrinsicLibrary::getWrapper(GeneratorType generator,
llvm::StringRef name,
mlir::FunctionType funcType,
bool loadRefArguments) {
assert(funcType.getNumResults() == 1 &&
"expect one result for intrinsic functions");
auto resultType = funcType.getResult(0);
std::string wrapperName = fir::mangleIntrinsicProcedure(name, funcType);
auto function = builder.getNamedFunction(wrapperName);
if (!function) {
// First time this wrapper is needed, build it.
function = builder.createFunction(loc, wrapperName, funcType);
function->setAttr("fir.intrinsic", builder.getUnitAttr());
function.addEntryBlock();
// Create local context to emit code into the newly created function
// This new function is not linked to a source file location, only
// its calls will be.
auto localBuilder = std::make_unique<Fortran::lower::FirOpBuilder>(
function, builder.getKindMap());
localBuilder->setInsertionPointToStart(&function.front());
// Location of code inside wrapper of the wrapper is independent from
// the location of the intrinsic call.
auto localLoc = localBuilder->getUnknownLoc();
llvm::SmallVector<mlir::Value, 2> localArguments;
for (mlir::BlockArgument bArg : function.front().getArguments()) {
auto refType = bArg.getType().dyn_cast<fir::ReferenceType>();
if (loadRefArguments && refType) {
auto loaded = localBuilder->create<fir::LoadOp>(localLoc, bArg);
localArguments.push_back(loaded);
} else {
localArguments.push_back(bArg);
}
}
IntrinsicLibrary localLib{*localBuilder, localLoc};
auto result =
localLib.invokeGenerator(generator, resultType, localArguments);
localBuilder->create<mlir::ReturnOp>(localLoc, result);
} else {
// Wrapper was already built, ensure it has the sought type
assert(function.getType() == funcType &&
"conflict between intrinsic wrapper types");
}
return function;
}
/// Helpers to detect absent optional (not yet supported in outlining).
bool static hasAbsentOptional(llvm::ArrayRef<mlir::Value> args) {
for (const auto &arg : args)
if (!arg)
return true;
return false;
}
bool static hasAbsentOptional(llvm::ArrayRef<fir::ExtendedValue> args) {
for (const auto &arg : args)
if (!fir::getBase(arg))
return true;
return false;
}
template <typename GeneratorType>
mlir::Value
IntrinsicLibrary::outlineInWrapper(GeneratorType generator,
llvm::StringRef name, mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
if (hasAbsentOptional(args)) {
// TODO: absent optional in outlining is an issue: we cannot just ignore
// them. Needs a better interface here. The issue is that we cannot easily
// tell that a value is optional or not here if it is presents. And if it is
// absent, we cannot tell what it type should be.
mlir::emitError(loc, "todo: cannot outline call to intrinsic " +
llvm::Twine(name) +
" with absent optional argument");
exit(1);
}
auto funcType = getFunctionType(resultType, args, builder);
auto wrapper = getWrapper(generator, name, funcType);
return builder.create<mlir::CallOp>(loc, wrapper, args).getResult(0);
}
fir::ExtendedValue
IntrinsicLibrary::outlineInWrapper(ExtendedGenerator generator,
llvm::StringRef name, mlir::Type resultType,
llvm::ArrayRef<fir::ExtendedValue> args) {
if (hasAbsentOptional(args)) {
// TODO
mlir::emitError(loc, "todo: cannot outline call to intrinsic " +
llvm::Twine(name) +
" with absent optional argument");
exit(1);
}
llvm::SmallVector<mlir::Value, 2> mlirArgs;
for (const auto &extendedVal : args)
mlirArgs.emplace_back(toValue(extendedVal, builder, loc));
auto funcType = getFunctionType(resultType, mlirArgs, builder);
auto wrapper = getWrapper(generator, name, funcType);
auto mlirResult =
builder.create<mlir::CallOp>(loc, wrapper, mlirArgs).getResult(0);
return toExtendedValue(mlirResult, builder, loc);
}
IntrinsicLibrary::RuntimeCallGenerator
IntrinsicLibrary::getRuntimeCallGenerator(llvm::StringRef name,
mlir::FunctionType soughtFuncType) {
auto funcOp = getRuntimeFunction(loc, builder, name, soughtFuncType);
if (!funcOp) {
mlir::emitError(loc,
"TODO: missing intrinsic lowering: " + llvm::Twine(name));
llvm::errs() << "requested type was: " << soughtFuncType << "\n";
exit(1);
}
mlir::FunctionType actualFuncType = funcOp.getType();
assert(actualFuncType.getNumResults() == soughtFuncType.getNumResults() &&
actualFuncType.getNumInputs() == soughtFuncType.getNumInputs() &&
actualFuncType.getNumResults() == 1 && "Bad intrinsic match");
return [funcOp, actualFuncType, soughtFuncType](
Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
llvm::ArrayRef<mlir::Value> args) {
llvm::SmallVector<mlir::Value, 2> convertedArguments;
for (const auto &pair : llvm::zip(actualFuncType.getInputs(), args))
convertedArguments.push_back(
builder.createConvert(loc, std::get<0>(pair), std::get<1>(pair)));
auto call = builder.create<mlir::CallOp>(loc, funcOp, convertedArguments);
mlir::Type soughtType = soughtFuncType.getResult(0);
return builder.createConvert(loc, soughtType, call.getResult(0));
};
}
mlir::SymbolRefAttr IntrinsicLibrary::getUnrestrictedIntrinsicSymbolRefAttr(
llvm::StringRef name, mlir::FunctionType signature) {
// Unrestricted intrinsics signature follows implicit rules: argument
// are passed by references. But the runtime versions expect values.
// So instead of duplicating the runtime, just have the wrappers loading
// this before calling the code generators.
bool loadRefArguments = true;
mlir::FuncOp funcOp;
for (auto &handler : handlers)
if (name == handler.name)
funcOp = std::visit(
[&](auto generator) {
return getWrapper(generator, name, signature, loadRefArguments);
},
handler.generator);
if (!funcOp) {
llvm::SmallVector<mlir::Type, 2> argTypes;
for (auto type : signature.getInputs()) {
if (auto refType = type.dyn_cast<fir::ReferenceType>())
argTypes.push_back(refType.getEleTy());
else
argTypes.push_back(type);
}
auto soughtFuncType =
builder.getFunctionType(signature.getResults(), argTypes);
auto rtCallGenerator = getRuntimeCallGenerator(name, soughtFuncType);
funcOp = getWrapper(rtCallGenerator, name, signature, loadRefArguments);
}
return builder.getSymbolRefAttr(funcOp.getName());
}
//===----------------------------------------------------------------------===//
// Code generators for the intrinsic
//===----------------------------------------------------------------------===//
mlir::Value IntrinsicLibrary::genRuntimeCall(llvm::StringRef name,
mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
mlir::FunctionType soughtFuncType =
getFunctionType(resultType, args, builder);
return getRuntimeCallGenerator(name, soughtFuncType)(builder, loc, args);
}
mlir::Value IntrinsicLibrary::genConversion(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
// There can be an optional kind in second argument.
assert(args.size() >= 1);
return builder.convertWithSemantics(loc, resultType, args[0]);
}
// ABS
mlir::Value IntrinsicLibrary::genAbs(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() == 1);
auto arg = args[0];
auto type = arg.getType();
if (fir::isa_real(type)) {
// Runtime call to fp abs. An alternative would be to use mlir AbsFOp
// but it does not support all fir floating point types.
return genRuntimeCall("abs", resultType, args);
}
if (auto intType = type.dyn_cast<mlir::IntegerType>()) {
// At the time of this implementation there is no abs op in mlir.
// So, implement abs here without branching.
auto shift =
builder.createIntegerConstant(loc, intType, intType.getWidth() - 1);
auto mask = builder.create<mlir::SignedShiftRightOp>(loc, arg, shift);
auto xored = builder.create<mlir::XOrOp>(loc, arg, mask);
return builder.create<mlir::SubIOp>(loc, xored, mask);
}
if (fir::isa_complex(type)) {
// Use HYPOT to fulfill the no underflow/overflow requirement.
auto parts =
Fortran::lower::ComplexExprHelper{builder, loc}.extractParts(arg);
llvm::SmallVector<mlir::Value, 2> args = {parts.first, parts.second};
return genRuntimeCall("hypot", resultType, args);
}
llvm_unreachable("unexpected type in ABS argument");
}
// AIMAG
mlir::Value IntrinsicLibrary::genAimag(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() == 1);
return Fortran::lower::ComplexExprHelper{builder, loc}.extractComplexPart(
args[0], true /* isImagPart */);
}
// ANINT
mlir::Value IntrinsicLibrary::genAnint(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() >= 1);
// Skip optional kind argument to search the runtime; it is already reflected
// in result type.
return genRuntimeCall("anint", resultType, {args[0]});
}
// AINT
mlir::Value IntrinsicLibrary::genAint(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() >= 1);
// Skip optional kind argument to search the runtime; it is already reflected
// in result type.
return genRuntimeCall("aint", resultType, {args[0]});
}
// CEILING
mlir::Value IntrinsicLibrary::genCeiling(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
// Optional KIND argument.
assert(args.size() >= 1);
auto arg = args[0];
// Use ceil that is not an actual Fortran intrinsic but that is
// an llvm intrinsic that does the same, but return a floating
// point.
auto ceil = genRuntimeCall("ceil", arg.getType(), {arg});
return builder.createConvert(loc, resultType, ceil);
}
// CONJG
mlir::Value IntrinsicLibrary::genConjg(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() == 1);
if (resultType != args[0].getType())
llvm_unreachable("argument type mismatch");
mlir::Value cplx = args[0];
auto imag =
Fortran::lower::ComplexExprHelper{builder, loc}.extractComplexPart(
cplx, /*isImagPart=*/true);
auto negImag = builder.create<fir::NegfOp>(loc, imag);
return Fortran::lower::ComplexExprHelper{builder, loc}.insertComplexPart(
cplx, negImag, /*isImagPart=*/true);
}
// DIM
mlir::Value IntrinsicLibrary::genDim(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() == 2);
if (resultType.isa<mlir::IntegerType>()) {
auto zero = builder.createIntegerConstant(loc, resultType, 0);
auto diff = builder.create<mlir::SubIOp>(loc, args[0], args[1]);
auto cmp =
builder.create<mlir::CmpIOp>(loc, mlir::CmpIPredicate::sgt, diff, zero);
return builder.create<mlir::SelectOp>(loc, cmp, diff, zero);
}
assert(fir::isa_real(resultType) && "Only expects real and integer in DIM");
auto zero = builder.createRealZeroConstant(loc, resultType);
auto diff = builder.create<fir::SubfOp>(loc, args[0], args[1]);
auto cmp =
builder.create<fir::CmpfOp>(loc, mlir::CmpFPredicate::OGT, diff, zero);
return builder.create<mlir::SelectOp>(loc, cmp, diff, zero);
}
// DPROD
mlir::Value IntrinsicLibrary::genDprod(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() == 2);
assert(fir::isa_real(resultType) &&
"Result must be double precision in DPROD");
auto a = builder.createConvert(loc, resultType, args[0]);
auto b = builder.createConvert(loc, resultType, args[1]);
return builder.create<fir::MulfOp>(loc, a, b);
}
// FLOOR
mlir::Value IntrinsicLibrary::genFloor(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
// Optional KIND argument.
assert(args.size() >= 1);
auto arg = args[0];
// Use LLVM floor that returns real.
auto floor = genRuntimeCall("floor", arg.getType(), {arg});
return builder.createConvert(loc, resultType, floor);
}
// IAND
mlir::Value IntrinsicLibrary::genIAnd(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() == 2);
return builder.create<mlir::AndOp>(loc, args[0], args[1]);
}
// ICHAR
mlir::Value IntrinsicLibrary::genIchar(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
// There can be an optional kind in second argument.
assert(args.size() >= 1);
auto arg = args[0];
Fortran::lower::CharacterExprHelper helper{builder, loc};
auto dataAndLen = helper.createUnboxChar(arg);
auto charType = fir::CharacterType::get(
builder.getContext(), helper.getCharacterKind(arg.getType()));
auto refType = builder.getRefType(charType);
auto charAddr = builder.createConvert(loc, refType, dataAndLen.first);
auto charVal = builder.create<fir::LoadOp>(loc, charType, charAddr);
return builder.createConvert(loc, resultType, charVal);
}
// IEOR
mlir::Value IntrinsicLibrary::genIEOr(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() == 2);
return builder.create<mlir::XOrOp>(loc, args[0], args[1]);
}
// IOR
mlir::Value IntrinsicLibrary::genIOr(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() == 2);
return builder.create<mlir::OrOp>(loc, args[0], args[1]);
}
// LEN
// Note that this is only used for unrestricted intrinsic.
// Usage of LEN are otherwise rewritten as descriptor inquiries by the
// front-end.
fir::ExtendedValue
IntrinsicLibrary::genLen(mlir::Type resultType,
llvm::ArrayRef<fir::ExtendedValue> args) {
// Optional KIND argument reflected in result type.
assert(args.size() >= 1);
mlir::Value len;
if (const auto *charBox = args[0].getCharBox()) {
len = charBox->getLen();
} else if (const auto *charBoxArray = args[0].getCharBox()) {
len = charBoxArray->getLen();
} else {
Fortran::lower::CharacterExprHelper helper{builder, loc};
len = helper.createUnboxChar(fir::getBase(args[0])).second;
}
return builder.createConvert(loc, resultType, len);
}
// LEN_TRIM
fir::ExtendedValue
IntrinsicLibrary::genLenTrim(mlir::Type resultType,
llvm::ArrayRef<fir::ExtendedValue> args) {
// Optional KIND argument reflected in result type.
assert(args.size() >= 1);
Fortran::lower::CharacterExprHelper helper{builder, loc};
auto len = helper.createLenTrim(fir::getBase(args[0]));
return builder.createConvert(loc, resultType, len);
}
// MERGE
mlir::Value IntrinsicLibrary::genMerge(mlir::Type,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() == 3);
auto i1Type = mlir::IntegerType::get(builder.getContext(), 1);
auto mask = builder.createConvert(loc, i1Type, args[2]);
return builder.create<mlir::SelectOp>(loc, mask, args[0], args[1]);
}
// MOD
mlir::Value IntrinsicLibrary::genMod(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() == 2);
if (resultType.isa<mlir::IntegerType>())
return builder.create<mlir::SignedRemIOp>(loc, args[0], args[1]);
// Use runtime. Note that mlir::RemFOp implements floating point
// remainder, but it does not work with fir::Real type.
// TODO: consider using mlir::RemFOp when possible, that may help folding
// and optimizations.
return genRuntimeCall("mod", resultType, args);
}
// NINT
mlir::Value IntrinsicLibrary::genNint(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() >= 1);
// Skip optional kind argument to search the runtime; it is already reflected
// in result type.
return genRuntimeCall("nint", resultType, {args[0]});
}
// SIGN
mlir::Value IntrinsicLibrary::genSign(mlir::Type resultType,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() == 2);
auto abs = genAbs(resultType, {args[0]});
if (resultType.isa<mlir::IntegerType>()) {
auto zero = builder.createIntegerConstant(loc, resultType, 0);
auto neg = builder.create<mlir::SubIOp>(loc, zero, abs);
auto cmp = builder.create<mlir::CmpIOp>(loc, mlir::CmpIPredicate::slt,
args[1], zero);
return builder.create<mlir::SelectOp>(loc, cmp, neg, abs);
}
// TODO: Requirements when second argument is +0./0.
auto zeroAttr = builder.getZeroAttr(resultType);
auto zero = builder.create<mlir::ConstantOp>(loc, resultType, zeroAttr);
auto neg = builder.create<fir::NegfOp>(loc, abs);
auto cmp =
builder.create<fir::CmpfOp>(loc, mlir::CmpFPredicate::OLT, args[1], zero);
return builder.create<mlir::SelectOp>(loc, cmp, neg, abs);
}
// Compare two FIR values and return boolean result as i1.
template <Extremum extremum, ExtremumBehavior behavior>
static mlir::Value createExtremumCompare(mlir::Location loc,
Fortran::lower::FirOpBuilder &builder,
mlir::Value left, mlir::Value right) {
static constexpr auto integerPredicate = extremum == Extremum::Max
? mlir::CmpIPredicate::sgt
: mlir::CmpIPredicate::slt;
static constexpr auto orderedCmp = extremum == Extremum::Max
? mlir::CmpFPredicate::OGT
: mlir::CmpFPredicate::OLT;
auto type = left.getType();
mlir::Value result;
if (fir::isa_real(type)) {
// Note: the signaling/quit aspect of the result required by IEEE
// cannot currently be obtained with LLVM without ad-hoc runtime.
if constexpr (behavior == ExtremumBehavior::IeeeMinMaximumNumber) {
// Return the number if one of the inputs is NaN and the other is
// a number.
auto leftIsResult =
builder.create<fir::CmpfOp>(loc, orderedCmp, left, right);
auto rightIsNan = builder.create<fir::CmpfOp>(
loc, mlir::CmpFPredicate::UNE, right, right);
result = builder.create<mlir::OrOp>(loc, leftIsResult, rightIsNan);
} else if constexpr (behavior == ExtremumBehavior::IeeeMinMaximum) {
// Always return NaNs if one the input is NaNs
auto leftIsResult =
builder.create<fir::CmpfOp>(loc, orderedCmp, left, right);
auto leftIsNan = builder.create<fir::CmpfOp>(
loc, mlir::CmpFPredicate::UNE, left, left);
result = builder.create<mlir::OrOp>(loc, leftIsResult, leftIsNan);
} else if constexpr (behavior == ExtremumBehavior::MinMaxss) {
// If the left is a NaN, return the right whatever it is.
result = builder.create<fir::CmpfOp>(loc, orderedCmp, left, right);
} else if constexpr (behavior == ExtremumBehavior::PgfortranLlvm) {
// If one of the operand is a NaN, return left whatever it is.
static constexpr auto unorderedCmp = extremum == Extremum::Max
? mlir::CmpFPredicate::UGT
: mlir::CmpFPredicate::ULT;
result = builder.create<fir::CmpfOp>(loc, unorderedCmp, left, right);
} else {
// TODO: ieeeMinNum/ieeeMaxNum
static_assert(behavior == ExtremumBehavior::IeeeMinMaxNum,
"ieeeMinNum/ieeeMaxNum behavior not implemented");
}
} else if (fir::isa_integer(type)) {
result = builder.create<mlir::CmpIOp>(loc, integerPredicate, left, right);
} else if (type.isa<fir::CharacterType>()) {
// TODO: ! character min and max is tricky because the result
// length is the length of the longest argument!
// So we may need a temp.
}
assert(result);
return result;
}
// MIN and MAX
template <Extremum extremum, ExtremumBehavior behavior>
mlir::Value IntrinsicLibrary::genExtremum(mlir::Type,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() >= 1);
mlir::Value result = args[0];
for (auto arg : args.drop_front()) {
auto mask =
createExtremumCompare<extremum, behavior>(loc, builder, result, arg);
result = builder.create<mlir::SelectOp>(loc, mask, result, arg);
}
return result;
}
//===----------------------------------------------------------------------===//
// Public intrinsic call helpers
//===----------------------------------------------------------------------===//
fir::ExtendedValue
Fortran::lower::genIntrinsicCall(Fortran::lower::FirOpBuilder &builder,
mlir::Location loc, llvm::StringRef name,
mlir::Type resultType,
llvm::ArrayRef<fir::ExtendedValue> args) {
return IntrinsicLibrary{builder, loc}.genIntrinsicCall(name, resultType,
args);
}
mlir::Value Fortran::lower::genMax(Fortran::lower::FirOpBuilder &builder,
mlir::Location loc,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() > 0 && "max requires at least one argument");
return IntrinsicLibrary{builder, loc}
.genExtremum<Extremum::Max, ExtremumBehavior::MinMaxss>(args[0].getType(),
args);
}
mlir::Value Fortran::lower::genMin(Fortran::lower::FirOpBuilder &builder,
mlir::Location loc,
llvm::ArrayRef<mlir::Value> args) {
assert(args.size() > 0 && "min requires at least one argument");
return IntrinsicLibrary{builder, loc}
.genExtremum<Extremum::Min, ExtremumBehavior::MinMaxss>(args[0].getType(),
args);
}
mlir::Value Fortran::lower::genPow(Fortran::lower::FirOpBuilder &builder,
mlir::Location loc, mlir::Type type,
mlir::Value x, mlir::Value y) {
return IntrinsicLibrary{builder, loc}.genRuntimeCall("pow", type, {x, y});
}
mlir::SymbolRefAttr Fortran::lower::getUnrestrictedIntrinsicSymbolRefAttr(
Fortran::lower::FirOpBuilder &builder, mlir::Location loc,
llvm::StringRef name, mlir::FunctionType signature) {
return IntrinsicLibrary{builder, loc}.getUnrestrictedIntrinsicSymbolRefAttr(
name, signature);
}
Reference in New Issue View Git Blame Copy Permalink