blob: e1e1c97c3f02414c81670df60a8ab5d34fd8d5d3 [file] [log] [blame]
//===-- lib/Evaluate/intrinsics-library.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
//
//===----------------------------------------------------------------------===//
// This file defines host runtime functions that can be used for folding
// intrinsic functions.
// The default host runtime folders are built with <cmath> and
// <complex> functions that are guaranteed to exist from the C++ standard.
#include "flang/Evaluate/intrinsics-library.h"
#include "fold-implementation.h"
#include "host.h"
#include "flang/Common/static-multimap-view.h"
#include "flang/Evaluate/expression.h"
#include <cmath>
#include <complex>
#include <functional>
#include <type_traits>
namespace Fortran::evaluate {
// Define a vector like class that can hold an arbitrary number of
// Dynamic type and be built at compile time. This is like a
// std::vector<DynamicType>, but constexpr only.
template <typename... FortranType> struct TypeVectorStorage {
static constexpr DynamicType values[]{FortranType{}.GetType()...};
static constexpr const DynamicType *start{&values[0]};
static constexpr const DynamicType *end{start + sizeof...(FortranType)};
};
template <> struct TypeVectorStorage<> {
static constexpr const DynamicType *start{nullptr}, *end{nullptr};
};
struct TypeVector {
template <typename... FortranType> static constexpr TypeVector Create() {
using storage = TypeVectorStorage<FortranType...>;
return TypeVector{storage::start, storage::end, sizeof...(FortranType)};
}
constexpr size_t size() const { return size_; };
using const_iterator = const DynamicType *;
constexpr const_iterator begin() const { return startPtr; }
constexpr const_iterator end() const { return endPtr; }
const DynamicType &operator[](size_t i) const { return *(startPtr + i); }
const DynamicType *startPtr{nullptr};
const DynamicType *endPtr{nullptr};
const size_t size_;
};
inline bool operator==(
const TypeVector &lhs, const std::vector<DynamicType> &rhs) {
if (lhs.size() != rhs.size()) {
return false;
}
for (size_t i{0}; i < lhs.size(); ++i) {
if (lhs[i] != rhs[i]) {
return false;
}
}
return true;
}
// HostRuntimeFunction holds a pointer to a Folder function that can fold
// a Fortran scalar intrinsic using host runtime functions (e.g libm).
// The folder take care of all conversions between Fortran types and the related
// host types as well as setting and cleaning-up the floating point environment.
// HostRuntimeFunction are intended to be built at compile time (members are all
// constexpr constructible) so that they can be stored in a compile time static
// map.
struct HostRuntimeFunction {
using Folder = Expr<SomeType> (*)(
FoldingContext &, std::vector<Expr<SomeType>> &&);
using Key = std::string_view;
// Needed for implicit compare with keys.
constexpr operator Key() const { return key; }
// Name of the related Fortran intrinsic.
Key key;
// DynamicType of the Expr<SomeType> returns by folder.
DynamicType resultType;
// DynamicTypes expected for the Expr<SomeType> arguments of the folder.
// The folder will crash if provided arguments of different types.
TypeVector argumentTypes;
// Folder to be called to fold the intrinsic with host runtime. The provided
// Expr<SomeType> arguments must wrap scalar constants of the type described
// in argumentTypes, otherwise folder will crash. Any floating point issue
// raised while executing the host runtime will be reported in FoldingContext
// messages.
Folder folder;
};
// Translate a host function type signature (template arguments) into a
// constexpr data representation based on Fortran DynamicType that can be
// stored.
template <typename TR, typename... TA> using FuncPointer = TR (*)(TA...);
template <typename T> struct FuncTypeAnalyzer {};
template <typename HostTR, typename... HostTA>
struct FuncTypeAnalyzer<FuncPointer<HostTR, HostTA...>> {
static constexpr DynamicType result{host::FortranType<HostTR>{}.GetType()};
static constexpr TypeVector arguments{
TypeVector::Create<host::FortranType<HostTA>...>()};
};
// Define helpers to deal with host floating environment.
template <typename TR>
static void CheckFloatingPointIssues(
host::HostFloatingPointEnvironment &hostFPE, const Scalar<TR> &x) {
if constexpr (TR::category == TypeCategory::Complex ||
TR::category == TypeCategory::Real) {
if (x.IsNotANumber()) {
hostFPE.SetFlag(RealFlag::InvalidArgument);
} else if (x.IsInfinite()) {
hostFPE.SetFlag(RealFlag::Overflow);
}
}
}
// Software Subnormal Flushing helper.
// Only flush floating-points. Forward other scalars untouched.
// Software flushing is only performed if hardware flushing is not available
// because it may not result in the same behavior as hardware flushing.
// Some runtime implementations are "working around" subnormal flushing to
// return results that they deem better than returning the result they would
// with a null argument. An example is logf that should return -inf if arguments
// are flushed to zero, but some implementations return -1.03972076416015625e2_4
// for all subnormal values instead. It is impossible to reproduce this with the
// simple software flushing below.
template <typename T>
static constexpr inline const Scalar<T> FlushSubnormals(Scalar<T> &&x) {
if constexpr (T::category == TypeCategory::Real ||
T::category == TypeCategory::Complex) {
return x.FlushSubnormalToZero();
}
return x;
}
// This is the kernel called by all HostRuntimeFunction folders, it convert the
// Fortran Expr<SomeType> to the host runtime function argument types, calls
// the runtime function, and wrap back the result into an Expr<SomeType>.
// It deals with host floating point environment set-up and clean-up.
template <typename FuncType, typename TR, typename... TA, size_t... I>
static Expr<SomeType> ApplyHostFunctionHelper(FuncType func,
FoldingContext &context, std::vector<Expr<SomeType>> &&args,
std::index_sequence<I...>) {
host::HostFloatingPointEnvironment hostFPE;
hostFPE.SetUpHostFloatingPointEnvironment(context);
host::HostType<TR> hostResult{};
Scalar<TR> result{};
std::tuple<Scalar<TA>...> scalarArgs{
GetScalarConstantValue<TA>(args[I]).value()...};
if (context.flushSubnormalsToZero() &&
!hostFPE.hasSubnormalFlushingHardwareControl()) {
hostResult = func(host::CastFortranToHost<TA>(
FlushSubnormals<TA>(std::move(std::get<I>(scalarArgs))))...);
result = FlushSubnormals<TR>(host::CastHostToFortran<TR>(hostResult));
} else {
hostResult = func(host::CastFortranToHost<TA>(std::get<I>(scalarArgs))...);
result = host::CastHostToFortran<TR>(hostResult);
}
if (!hostFPE.hardwareFlagsAreReliable()) {
CheckFloatingPointIssues<TR>(hostFPE, result);
}
hostFPE.CheckAndRestoreFloatingPointEnvironment(context);
return AsGenericExpr(Constant<TR>(std::move(result)));
}
template <typename HostTR, typename... HostTA>
Expr<SomeType> ApplyHostFunction(FuncPointer<HostTR, HostTA...> func,
FoldingContext &context, std::vector<Expr<SomeType>> &&args) {
return ApplyHostFunctionHelper<decltype(func), host::FortranType<HostTR>,
host::FortranType<HostTA>...>(
func, context, std::move(args), std::index_sequence_for<HostTA...>{});
}
// FolderFactory builds a HostRuntimeFunction for the host runtime function
// passed as a template argument.
// Its static member function "fold" is the resulting folder. It captures the
// host runtime function pointer and pass it to the host runtime function folder
// kernel.
template <typename HostFuncType, HostFuncType func> class FolderFactory {
public:
static constexpr HostRuntimeFunction Create(const std::string_view &name) {
return HostRuntimeFunction{name, FuncTypeAnalyzer<HostFuncType>::result,
FuncTypeAnalyzer<HostFuncType>::arguments, &Fold};
}
private:
static Expr<SomeType> Fold(
FoldingContext &context, std::vector<Expr<SomeType>> &&args) {
return ApplyHostFunction(func, context, std::move(args));
}
};
// Define host runtime libraries that can be used for folding and
// fill their description if they are available.
enum class LibraryVersion { Libm, PgmathFast, PgmathRelaxed, PgmathPrecise };
template <typename HostT, LibraryVersion> struct HostRuntimeLibrary {
// When specialized, this class holds a static constexpr table containing
// all the HostRuntimeLibrary for functions of library LibraryVersion
// that returns a value of type HostT.
};
using HostRuntimeMap = common::StaticMultimapView<HostRuntimeFunction>;
// Map numerical intrinsic to <cmath>/<complex> functions
template <typename HostT>
struct HostRuntimeLibrary<HostT, LibraryVersion::Libm> {
using F = FuncPointer<HostT, HostT>;
using F2 = FuncPointer<HostT, HostT, HostT>;
using ComplexToRealF = FuncPointer<HostT, const std::complex<HostT> &>;
static constexpr HostRuntimeFunction table[]{
FolderFactory<ComplexToRealF, ComplexToRealF{std::abs}>::Create("abs"),
FolderFactory<F, F{std::acos}>::Create("acos"),
FolderFactory<F, F{std::acosh}>::Create("acosh"),
FolderFactory<F, F{std::asin}>::Create("asin"),
FolderFactory<F, F{std::asinh}>::Create("asinh"),
FolderFactory<F, F{std::atan}>::Create("atan"),
FolderFactory<F2, F2{std::atan2}>::Create("atan2"),
FolderFactory<F, F{std::atanh}>::Create("atanh"),
FolderFactory<F, F{std::cos}>::Create("cos"),
FolderFactory<F, F{std::cosh}>::Create("cosh"),
FolderFactory<F, F{std::erf}>::Create("erf"),
FolderFactory<F, F{std::erfc}>::Create("erfc"),
FolderFactory<F, F{std::exp}>::Create("exp"),
FolderFactory<F, F{std::tgamma}>::Create("gamma"),
FolderFactory<F, F{std::log}>::Create("log"),
FolderFactory<F, F{std::log10}>::Create("log10"),
FolderFactory<F, F{std::lgamma}>::Create("log_gamma"),
FolderFactory<F2, F2{std::fmod}>::Create("mod"),
FolderFactory<F2, F2{std::pow}>::Create("pow"),
FolderFactory<F, F{std::sin}>::Create("sin"),
FolderFactory<F, F{std::sinh}>::Create("sinh"),
FolderFactory<F, F{std::tan}>::Create("tan"),
FolderFactory<F, F{std::tanh}>::Create("tanh"),
};
// Note: cmath does not have modulo and erfc_scaled equivalent
// Note regarding lack of bessel function support:
// C++17 defined standard Bessel math functions std::cyl_bessel_j
// and std::cyl_neumann that can be used for Fortran j and y
// bessel functions. However, they are not yet implemented in
// clang libc++ (ok in GNU libstdc++). C maths functions j0...
// are not C standard but a GNU extension so they are not used
// to avoid introducing incompatibilities.
// Use libpgmath to get bessel function folding support.
// TODO: Add Bessel functions when possible.
static constexpr HostRuntimeMap map{table};
static_assert(map.Verify(), "map must be sorted");
};
template <typename HostT>
struct HostRuntimeLibrary<std::complex<HostT>, LibraryVersion::Libm> {
using F = FuncPointer<std::complex<HostT>, const std::complex<HostT> &>;
using F2 = FuncPointer<std::complex<HostT>, const std::complex<HostT> &,
const std::complex<HostT> &>;
using F2A = FuncPointer<std::complex<HostT>, const HostT &,
const std::complex<HostT> &>;
using F2B = FuncPointer<std::complex<HostT>, const std::complex<HostT> &,
const HostT &>;
static constexpr HostRuntimeFunction table[]{
FolderFactory<F, F{std::acos}>::Create("acos"),
FolderFactory<F, F{std::acosh}>::Create("acosh"),
FolderFactory<F, F{std::asin}>::Create("asin"),
FolderFactory<F, F{std::asinh}>::Create("asinh"),
FolderFactory<F, F{std::atan}>::Create("atan"),
FolderFactory<F, F{std::atanh}>::Create("atanh"),
FolderFactory<F, F{std::cos}>::Create("cos"),
FolderFactory<F, F{std::cosh}>::Create("cosh"),
FolderFactory<F, F{std::exp}>::Create("exp"),
FolderFactory<F, F{std::log}>::Create("log"),
FolderFactory<F2, F2{std::pow}>::Create("pow"),
FolderFactory<F2A, F2A{std::pow}>::Create("pow"),
FolderFactory<F2B, F2B{std::pow}>::Create("pow"),
FolderFactory<F, F{std::sin}>::Create("sin"),
FolderFactory<F, F{std::sinh}>::Create("sinh"),
FolderFactory<F, F{std::sqrt}>::Create("sqrt"),
FolderFactory<F, F{std::tan}>::Create("tan"),
FolderFactory<F, F{std::tanh}>::Create("tanh"),
};
static constexpr HostRuntimeMap map{table};
static_assert(map.Verify(), "map must be sorted");
};
/// Define pgmath description
#if LINK_WITH_LIBPGMATH
// Only use libpgmath for folding if it is available.
// First declare all libpgmaths functions
#define PGMATH_LINKING
#define PGMATH_DECLARE
#include "flang/Evaluate/pgmath.h.inc"
#define REAL_FOLDER(name, func) \
FolderFactory<decltype(&func), &func>::Create(#name)
template <> struct HostRuntimeLibrary<float, LibraryVersion::PgmathFast> {
static constexpr HostRuntimeFunction table[]{
#define PGMATH_FAST
#define PGMATH_USE_S(name, func) REAL_FOLDER(name, func),
#include "flang/Evaluate/pgmath.h.inc"
};
static constexpr HostRuntimeMap map{table};
static_assert(map.Verify(), "map must be sorted");
};
template <> struct HostRuntimeLibrary<double, LibraryVersion::PgmathFast> {
static constexpr HostRuntimeFunction table[]{
#define PGMATH_FAST
#define PGMATH_USE_D(name, func) REAL_FOLDER(name, func),
#include "flang/Evaluate/pgmath.h.inc"
};
static constexpr HostRuntimeMap map{table};
static_assert(map.Verify(), "map must be sorted");
};
template <> struct HostRuntimeLibrary<float, LibraryVersion::PgmathRelaxed> {
static constexpr HostRuntimeFunction table[]{
#define PGMATH_RELAXED
#define PGMATH_USE_S(name, func) REAL_FOLDER(name, func),
#include "flang/Evaluate/pgmath.h.inc"
};
static constexpr HostRuntimeMap map{table};
static_assert(map.Verify(), "map must be sorted");
};
template <> struct HostRuntimeLibrary<double, LibraryVersion::PgmathRelaxed> {
static constexpr HostRuntimeFunction table[]{
#define PGMATH_RELAXED
#define PGMATH_USE_D(name, func) REAL_FOLDER(name, func),
#include "flang/Evaluate/pgmath.h.inc"
};
static constexpr HostRuntimeMap map{table};
static_assert(map.Verify(), "map must be sorted");
};
template <> struct HostRuntimeLibrary<float, LibraryVersion::PgmathPrecise> {
static constexpr HostRuntimeFunction table[]{
#define PGMATH_PRECISE
#define PGMATH_USE_S(name, func) REAL_FOLDER(name, func),
#include "flang/Evaluate/pgmath.h.inc"
};
static constexpr HostRuntimeMap map{table};
static_assert(map.Verify(), "map must be sorted");
};
template <> struct HostRuntimeLibrary<double, LibraryVersion::PgmathPrecise> {
static constexpr HostRuntimeFunction table[]{
#define PGMATH_PRECISE
#define PGMATH_USE_D(name, func) REAL_FOLDER(name, func),
#include "flang/Evaluate/pgmath.h.inc"
};
static constexpr HostRuntimeMap map{table};
static_assert(map.Verify(), "map must be sorted");
};
// TODO: double _Complex/float _Complex have been removed from llvm flang
// pgmath.h.inc because they caused warnings, they need to be added back
// so that the complex pgmath versions can be used when requested.
#endif /* LINK_WITH_LIBPGMATH */
// Helper to check if a HostRuntimeLibrary specialization exists
template <typename T, typename = void> struct IsAvailable : std::false_type {};
template <typename T>
struct IsAvailable<T, decltype((void)T::table, void())> : std::true_type {};
// Define helpers to find host runtime library map according to desired version
// and type.
template <typename HostT, LibraryVersion version>
static const HostRuntimeMap *GetHostRuntimeMapHelper(
[[maybe_unused]] DynamicType resultType) {
// A library must only be instantiated if LibraryVersion is
// available on the host and if HostT maps to a Fortran type.
// For instance, whenever long double and double are both 64-bits, double
// is mapped to Fortran 64bits real type, and long double will be left
// unmapped.
if constexpr (host::FortranTypeExists<HostT>()) {
using Lib = HostRuntimeLibrary<HostT, version>;
if constexpr (IsAvailable<Lib>::value) {
if (host::FortranType<HostT>{}.GetType() == resultType) {
return &Lib::map;
}
}
}
return nullptr;
}
template <LibraryVersion version>
static const HostRuntimeMap *GetHostRuntimeMapVersion(DynamicType resultType) {
if (resultType.category() == TypeCategory::Real) {
if (const auto *map{GetHostRuntimeMapHelper<float, version>(resultType)}) {
return map;
}
if (const auto *map{GetHostRuntimeMapHelper<double, version>(resultType)}) {
return map;
}
if (const auto *map{
GetHostRuntimeMapHelper<long double, version>(resultType)}) {
return map;
}
}
if (resultType.category() == TypeCategory::Complex) {
if (const auto *map{GetHostRuntimeMapHelper<std::complex<float>, version>(
resultType)}) {
return map;
}
if (const auto *map{GetHostRuntimeMapHelper<std::complex<double>, version>(
resultType)}) {
return map;
}
if (const auto *map{
GetHostRuntimeMapHelper<std::complex<long double>, version>(
resultType)}) {
return map;
}
}
return nullptr;
}
static const HostRuntimeMap *GetHostRuntimeMap(
LibraryVersion version, DynamicType resultType) {
switch (version) {
case LibraryVersion::Libm:
return GetHostRuntimeMapVersion<LibraryVersion::Libm>(resultType);
case LibraryVersion::PgmathPrecise:
return GetHostRuntimeMapVersion<LibraryVersion::PgmathPrecise>(resultType);
case LibraryVersion::PgmathRelaxed:
return GetHostRuntimeMapVersion<LibraryVersion::PgmathRelaxed>(resultType);
case LibraryVersion::PgmathFast:
return GetHostRuntimeMapVersion<LibraryVersion::PgmathFast>(resultType);
}
return nullptr;
}
static const HostRuntimeFunction *SearchInHostRuntimeMap(
const HostRuntimeMap &map, const std::string &name, DynamicType resultType,
const std::vector<DynamicType> &argTypes) {
auto sameNameRange{map.equal_range(name)};
for (const auto *iter{sameNameRange.first}; iter != sameNameRange.second;
++iter) {
if (iter->resultType == resultType && iter->argumentTypes == argTypes) {
return &*iter;
}
}
return nullptr;
}
// Search host runtime libraries for an exact type match.
static const HostRuntimeFunction *SearchHostRuntime(const std::string &name,
DynamicType resultType, const std::vector<DynamicType> &argTypes) {
// TODO: When command line options regarding targeted numerical library is
// available, this needs to be revisited to take it into account. So far,
// default to libpgmath if F18 is built with it.
#if LINK_WITH_LIBPGMATH
if (const auto *map{
GetHostRuntimeMap(LibraryVersion::PgmathPrecise, resultType)}) {
if (const auto *hostFunction{
SearchInHostRuntimeMap(*map, name, resultType, argTypes)}) {
return hostFunction;
}
}
// Default to libm if functions or types are not available in pgmath.
#endif
if (const auto *map{GetHostRuntimeMap(LibraryVersion::Libm, resultType)}) {
if (const auto *hostFunction{
SearchInHostRuntimeMap(*map, name, resultType, argTypes)}) {
return hostFunction;
}
}
return nullptr;
}
// Return a DynamicType that can hold all values of a given type.
// This is used to allow 16bit float to be folded with 32bits and
// x87 float to be folded with IEEE 128bits.
static DynamicType BiggerType(DynamicType type) {
if (type.category() == TypeCategory::Real ||
type.category() == TypeCategory::Complex) {
// 16 bits floats to IEEE 32 bits float
if (type.kind() == common::RealKindForPrecision(11) ||
type.kind() == common::RealKindForPrecision(8)) {
return {type.category(), common::RealKindForPrecision(24)};
}
// x87 float to IEEE 128 bits float
if (type.kind() == common::RealKindForPrecision(64)) {
return {type.category(), common::RealKindForPrecision(113)};
}
}
return type;
}
std::optional<HostRuntimeWrapper> GetHostRuntimeWrapper(const std::string &name,
DynamicType resultType, const std::vector<DynamicType> &argTypes) {
if (const auto *hostFunction{SearchHostRuntime(name, resultType, argTypes)}) {
return hostFunction->folder;
}
// If no exact match, search with "bigger" types and insert type
// conversions around the folder.
std::vector<evaluate::DynamicType> biggerArgTypes;
evaluate::DynamicType biggerResultType{BiggerType(resultType)};
for (auto type : argTypes) {
biggerArgTypes.emplace_back(BiggerType(type));
}
if (const auto *hostFunction{
SearchHostRuntime(name, biggerResultType, biggerArgTypes)}) {
return [hostFunction, resultType](
FoldingContext &context, std::vector<Expr<SomeType>> &&args) {
auto nArgs{args.size()};
for (size_t i{0}; i < nArgs; ++i) {
args[i] = Fold(context,
ConvertToType(hostFunction->argumentTypes[i], std::move(args[i]))
.value());
}
return Fold(context,
ConvertToType(
resultType, hostFunction->folder(context, std::move(args)))
.value());
};
}
return std::nullopt;
}
} // namespace Fortran::evaluate