| //===- APFloatWrappers.cpp - Software Implementation of FP Arithmetics --- ===// |
| // |
| // 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 exposes the APFloat infrastructure to MLIR programs as a runtime |
| // library. APFloat is a software implementation of floating point arithmetics. |
| // |
| // On the MLIR side, floating-point values must be bitcasted to 64-bit integers |
| // before calling a runtime function. If a floating-point type has less than |
| // 64 bits, it must be zero-extended to 64 bits after bitcasting it to an |
| // integer. |
| // |
| // Runtime functions receive the floating-point operands of the arithmeic |
| // operation in the form of 64-bit integers, along with the APFloat semantics |
| // in the form of a 32-bit integer, which will be interpreted as an |
| // APFloatBase::Semantics enum value. |
| // |
| #include "llvm/ADT/APFloat.h" |
| #include "llvm/ADT/APSInt.h" |
| #include "llvm/Support/Debug.h" |
| |
| #ifdef _WIN32 |
| #ifndef MLIR_APFLOAT_WRAPPERS_EXPORT |
| #ifdef mlir_apfloat_wrappers_EXPORTS |
| // We are building this library |
| #define MLIR_APFLOAT_WRAPPERS_EXPORT __declspec(dllexport) |
| #else |
| // We are using this library |
| #define MLIR_APFLOAT_WRAPPERS_EXPORT __declspec(dllimport) |
| #endif // mlir_apfloat_wrappers_EXPORTS |
| #endif // MLIR_APFLOAT_WRAPPERS_EXPORT |
| #else |
| // Non-windows: use visibility attributes. |
| #define MLIR_APFLOAT_WRAPPERS_EXPORT __attribute__((visibility("default"))) |
| #endif // _WIN32 |
| |
| /// Binary operations without rounding mode. |
| #define APFLOAT_BINARY_OP(OP) \ |
| MLIR_APFLOAT_WRAPPERS_EXPORT int64_t _mlir_apfloat_##OP( \ |
| int32_t semantics, uint64_t a, uint64_t b) { \ |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( \ |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); \ |
| unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); \ |
| llvm::APFloat lhs(sem, llvm::APInt(bitWidth, a)); \ |
| llvm::APFloat rhs(sem, llvm::APInt(bitWidth, b)); \ |
| lhs.OP(rhs); \ |
| return lhs.bitcastToAPInt().getZExtValue(); \ |
| } |
| |
| /// Binary operations with rounding mode. |
| #define APFLOAT_BINARY_OP_ROUNDING_MODE(OP, ROUNDING_MODE) \ |
| MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t _mlir_apfloat_##OP( \ |
| int32_t semantics, uint64_t a, uint64_t b) { \ |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( \ |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); \ |
| unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); \ |
| llvm::APFloat lhs(sem, llvm::APInt(bitWidth, a)); \ |
| llvm::APFloat rhs(sem, llvm::APInt(bitWidth, b)); \ |
| lhs.OP(rhs, ROUNDING_MODE); \ |
| return lhs.bitcastToAPInt().getZExtValue(); \ |
| } |
| |
| extern "C" { |
| |
| #define BIN_OPS_WITH_ROUNDING(X) \ |
| X(add, llvm::RoundingMode::NearestTiesToEven) \ |
| X(subtract, llvm::RoundingMode::NearestTiesToEven) \ |
| X(multiply, llvm::RoundingMode::NearestTiesToEven) \ |
| X(divide, llvm::RoundingMode::NearestTiesToEven) |
| |
| BIN_OPS_WITH_ROUNDING(APFLOAT_BINARY_OP_ROUNDING_MODE) |
| #undef BIN_OPS_WITH_ROUNDING |
| #undef APFLOAT_BINARY_OP_ROUNDING_MODE |
| |
| APFLOAT_BINARY_OP(remainder) |
| |
| #undef APFLOAT_BINARY_OP |
| |
| MLIR_APFLOAT_WRAPPERS_EXPORT void printApFloat(int32_t semantics, uint64_t a) { |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| double d = x.convertToDouble(); |
| fprintf(stdout, "%lg", d); |
| } |
| |
| MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t |
| _mlir_apfloat_convert(int32_t inSemantics, int32_t outSemantics, uint64_t a) { |
| const llvm::fltSemantics &inSem = llvm::APFloatBase::EnumToSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(inSemantics)); |
| const llvm::fltSemantics &outSem = llvm::APFloatBase::EnumToSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(outSemantics)); |
| unsigned bitWidthIn = llvm::APFloatBase::semanticsSizeInBits(inSem); |
| llvm::APFloat val(inSem, llvm::APInt(bitWidthIn, a)); |
| // TODO: Custom rounding modes are not supported yet. |
| bool losesInfo; |
| val.convert(outSem, llvm::RoundingMode::NearestTiesToEven, &losesInfo); |
| llvm::APInt result = val.bitcastToAPInt(); |
| return result.getZExtValue(); |
| } |
| |
| MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t _mlir_apfloat_convert_to_int( |
| int32_t semantics, int32_t resultWidth, bool isUnsigned, uint64_t a) { |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| unsigned inputWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| llvm::APFloat val(sem, llvm::APInt(inputWidth, a)); |
| llvm::APSInt result(resultWidth, isUnsigned); |
| bool isExact; |
| // TODO: Custom rounding modes are not supported yet. |
| val.convertToInteger(result, llvm::RoundingMode::NearestTiesToEven, &isExact); |
| // This function always returns uint64_t, regardless of the desired result |
| // width. It does not matter whether we zero-extend or sign-extend the APSInt |
| // to 64 bits because the generated IR in arith-to-apfloat will truncate the |
| // result to the desired result width. |
| return result.getZExtValue(); |
| } |
| |
| MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t _mlir_apfloat_convert_from_int( |
| int32_t semantics, int32_t inputWidth, bool isUnsigned, uint64_t a) { |
| llvm::APInt val(inputWidth, a, /*isSigned=*/!isUnsigned); |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| llvm::APFloat result(sem); |
| // TODO: Custom rounding modes are not supported yet. |
| result.convertFromAPInt(val, /*IsSigned=*/!isUnsigned, |
| llvm::RoundingMode::NearestTiesToEven); |
| return result.bitcastToAPInt().getZExtValue(); |
| } |
| |
| MLIR_APFLOAT_WRAPPERS_EXPORT int8_t _mlir_apfloat_compare(int32_t semantics, |
| uint64_t a, |
| uint64_t b) { |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| llvm::APFloat y(sem, llvm::APInt(bitWidth, b)); |
| return static_cast<int8_t>(x.compare(y)); |
| } |
| |
| MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t _mlir_apfloat_neg(int32_t semantics, |
| uint64_t a) { |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| x.changeSign(); |
| return x.bitcastToAPInt().getZExtValue(); |
| } |
| |
| MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t _mlir_apfloat_abs(int32_t semantics, |
| uint64_t a) { |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| return abs(x).bitcastToAPInt().getZExtValue(); |
| } |
| |
| MLIR_APFLOAT_WRAPPERS_EXPORT bool _mlir_apfloat_isfinite(int32_t semantics, |
| uint64_t a) { |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| return x.isFinite(); |
| } |
| |
| MLIR_APFLOAT_WRAPPERS_EXPORT bool _mlir_apfloat_isinfinite(int32_t semantics, |
| uint64_t a) { |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| return x.isInfinity(); |
| } |
| |
| MLIR_APFLOAT_WRAPPERS_EXPORT bool _mlir_apfloat_isnormal(int32_t semantics, |
| uint64_t a) { |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| return x.isNormal(); |
| } |
| |
| MLIR_APFLOAT_WRAPPERS_EXPORT bool _mlir_apfloat_isnan(int32_t semantics, |
| uint64_t a) { |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| return x.isNaN(); |
| } |
| |
| MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t |
| _mlir_apfloat_fused_multiply_add(int32_t semantics, uint64_t operand, |
| uint64_t multiplicand, uint64_t addend) { |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| llvm::APFloat operand_(sem, llvm::APInt(bitWidth, operand)); |
| llvm::APFloat multiplicand_(sem, llvm::APInt(bitWidth, multiplicand)); |
| llvm::APFloat addend_(sem, llvm::APInt(bitWidth, addend)); |
| llvm::detail::opStatus stat = operand_.fusedMultiplyAdd( |
| multiplicand_, addend_, llvm::RoundingMode::NearestTiesToEven); |
| assert(stat == llvm::APFloatBase::opOK && |
| "expected fusedMultiplyAdd status to be OK"); |
| (void)stat; |
| return operand_.bitcastToAPInt().getZExtValue(); |
| } |
| |
| /// Min/max operations. |
| #define APFLOAT_MIN_MAX_OP(OP) \ |
| MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t _mlir_apfloat_##OP( \ |
| int32_t semantics, uint64_t a, uint64_t b) { \ |
| const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( \ |
| static_cast<llvm::APFloatBase::Semantics>(semantics)); \ |
| unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); \ |
| llvm::APFloat lhs(sem, llvm::APInt(bitWidth, a)); \ |
| llvm::APFloat rhs(sem, llvm::APInt(bitWidth, b)); \ |
| llvm::APFloat result = llvm::OP(lhs, rhs); \ |
| return result.bitcastToAPInt().getZExtValue(); \ |
| } |
| |
| APFLOAT_MIN_MAX_OP(minimum) |
| APFLOAT_MIN_MAX_OP(maximum) |
| APFLOAT_MIN_MAX_OP(minnum) |
| APFLOAT_MIN_MAX_OP(maxnum) |
| |
| #undef APFLOAT_MIN_MAX_OP |
| } |
