| 1 | //===- APFloatWrappers.cpp - Software Implementation of FP Arithmetics --- ===// |
| 2 | // |
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 | // See https://llvm.org/LICENSE.txt for license information. |
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | // |
| 9 | // This file exposes the APFloat infrastructure to MLIR programs as a runtime |
| 10 | // library. APFloat is a software implementation of floating point arithmetics. |
| 11 | // |
| 12 | // On the MLIR side, floating-point values must be bitcasted to 64-bit integers |
| 13 | // before calling a runtime function. If a floating-point type has less than |
| 14 | // 64 bits, it must be zero-extended to 64 bits after bitcasting it to an |
| 15 | // integer. |
| 16 | // |
| 17 | // Runtime functions receive the floating-point operands of the arithmeic |
| 18 | // operation in the form of 64-bit integers, along with the APFloat semantics |
| 19 | // in the form of a 32-bit integer, which will be interpreted as an |
| 20 | // APFloatBase::Semantics enum value. |
| 21 | // |
| 22 | #include "llvm/ADT/APFloat.h" |
| 23 | #include "llvm/ADT/APSInt.h" |
| 24 | #include "llvm/Support/Debug.h" |
| 25 | |
| 26 | #ifdef _WIN32 |
| 27 | #ifndef MLIR_APFLOAT_WRAPPERS_EXPORT |
| 28 | #ifdef mlir_apfloat_wrappers_EXPORTS |
| 29 | // We are building this library |
| 30 | #define MLIR_APFLOAT_WRAPPERS_EXPORT __declspec(dllexport) |
| 31 | #else |
| 32 | // We are using this library |
| 33 | #define MLIR_APFLOAT_WRAPPERS_EXPORT __declspec(dllimport) |
| 34 | #endif // mlir_apfloat_wrappers_EXPORTS |
| 35 | #endif // MLIR_APFLOAT_WRAPPERS_EXPORT |
| 36 | #else |
| 37 | // Non-windows: use visibility attributes. |
| 38 | #define MLIR_APFLOAT_WRAPPERS_EXPORT __attribute__((visibility("default"))) |
| 39 | #endif // _WIN32 |
| 40 | |
| 41 | /// Binary operations without rounding mode. |
| 42 | #define APFLOAT_BINARY_OP(OP) \ |
| 43 | MLIR_APFLOAT_WRAPPERS_EXPORT int64_t _mlir_apfloat_##OP( \ |
| 44 | int32_t semantics, uint64_t a, uint64_t b) { \ |
| 45 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( \ |
| 46 | static_cast<llvm::APFloatBase::Semantics>(semantics)); \ |
| 47 | unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); \ |
| 48 | llvm::APFloat lhs(sem, llvm::APInt(bitWidth, a)); \ |
| 49 | llvm::APFloat rhs(sem, llvm::APInt(bitWidth, b)); \ |
| 50 | lhs.OP(rhs); \ |
| 51 | return lhs.bitcastToAPInt().getZExtValue(); \ |
| 52 | } |
| 53 | |
| 54 | /// Binary operations with rounding mode. |
| 55 | #define APFLOAT_BINARY_OP_ROUNDING_MODE(OP, ROUNDING_MODE) \ |
| 56 | MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t _mlir_apfloat_##OP( \ |
| 57 | int32_t semantics, uint64_t a, uint64_t b) { \ |
| 58 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( \ |
| 59 | static_cast<llvm::APFloatBase::Semantics>(semantics)); \ |
| 60 | unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); \ |
| 61 | llvm::APFloat lhs(sem, llvm::APInt(bitWidth, a)); \ |
| 62 | llvm::APFloat rhs(sem, llvm::APInt(bitWidth, b)); \ |
| 63 | lhs.OP(rhs, ROUNDING_MODE); \ |
| 64 | return lhs.bitcastToAPInt().getZExtValue(); \ |
| 65 | } |
| 66 | |
| 67 | extern "C" { |
| 68 | |
| 69 | #define BIN_OPS_WITH_ROUNDING(X) \ |
| 70 | X(add, llvm::RoundingMode::NearestTiesToEven) \ |
| 71 | X(subtract, llvm::RoundingMode::NearestTiesToEven) \ |
| 72 | X(multiply, llvm::RoundingMode::NearestTiesToEven) \ |
| 73 | X(divide, llvm::RoundingMode::NearestTiesToEven) |
| 74 | |
| 75 | BIN_OPS_WITH_ROUNDING(APFLOAT_BINARY_OP_ROUNDING_MODE) |
| 76 | #undef BIN_OPS_WITH_ROUNDING |
| 77 | #undef APFLOAT_BINARY_OP_ROUNDING_MODE |
| 78 | |
| 79 | APFLOAT_BINARY_OP(remainder) |
| 80 | |
| 81 | #undef APFLOAT_BINARY_OP |
| 82 | |
| 83 | MLIR_APFLOAT_WRAPPERS_EXPORT void printApFloat(int32_t semantics, uint64_t a) { |
| 84 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| 85 | S: static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| 86 | unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| 87 | llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| 88 | double d = x.convertToDouble(); |
| 89 | fprintf(stdout, format: "%lg" , d); |
| 90 | } |
| 91 | |
| 92 | MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t |
| 93 | _mlir_apfloat_convert(int32_t inSemantics, int32_t outSemantics, uint64_t a) { |
| 94 | const llvm::fltSemantics &inSem = llvm::APFloatBase::EnumToSemantics( |
| 95 | S: static_cast<llvm::APFloatBase::Semantics>(inSemantics)); |
| 96 | const llvm::fltSemantics &outSem = llvm::APFloatBase::EnumToSemantics( |
| 97 | S: static_cast<llvm::APFloatBase::Semantics>(outSemantics)); |
| 98 | unsigned bitWidthIn = llvm::APFloatBase::semanticsSizeInBits(inSem); |
| 99 | llvm::APFloat val(inSem, llvm::APInt(bitWidthIn, a)); |
| 100 | // TODO: Custom rounding modes are not supported yet. |
| 101 | bool losesInfo; |
| 102 | val.convert(ToSemantics: outSem, RM: llvm::RoundingMode::NearestTiesToEven, losesInfo: &losesInfo); |
| 103 | llvm::APInt result = val.bitcastToAPInt(); |
| 104 | return result.getZExtValue(); |
| 105 | } |
| 106 | |
| 107 | MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t _mlir_apfloat_convert_to_int( |
| 108 | int32_t semantics, int32_t resultWidth, bool isUnsigned, uint64_t a) { |
| 109 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| 110 | S: static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| 111 | unsigned inputWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| 112 | llvm::APFloat val(sem, llvm::APInt(inputWidth, a)); |
| 113 | llvm::APSInt result(resultWidth, isUnsigned); |
| 114 | bool isExact; |
| 115 | // TODO: Custom rounding modes are not supported yet. |
| 116 | val.convertToInteger(Result&: result, RM: llvm::RoundingMode::NearestTiesToEven, IsExact: &isExact); |
| 117 | // This function always returns uint64_t, regardless of the desired result |
| 118 | // width. It does not matter whether we zero-extend or sign-extend the APSInt |
| 119 | // to 64 bits because the generated IR in arith-to-apfloat will truncate the |
| 120 | // result to the desired result width. |
| 121 | return result.getZExtValue(); |
| 122 | } |
| 123 | |
| 124 | MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t _mlir_apfloat_convert_from_int( |
| 125 | int32_t semantics, int32_t inputWidth, bool isUnsigned, uint64_t a) { |
| 126 | llvm::APInt val(inputWidth, a, /*isSigned=*/!isUnsigned); |
| 127 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| 128 | S: static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| 129 | llvm::APFloat result(sem); |
| 130 | // TODO: Custom rounding modes are not supported yet. |
| 131 | result.convertFromAPInt(Input: val, /*IsSigned=*/!isUnsigned, |
| 132 | RM: llvm::RoundingMode::NearestTiesToEven); |
| 133 | return result.bitcastToAPInt().getZExtValue(); |
| 134 | } |
| 135 | |
| 136 | MLIR_APFLOAT_WRAPPERS_EXPORT int8_t _mlir_apfloat_compare(int32_t semantics, |
| 137 | uint64_t a, |
| 138 | uint64_t b) { |
| 139 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| 140 | S: static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| 141 | unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| 142 | llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| 143 | llvm::APFloat y(sem, llvm::APInt(bitWidth, b)); |
| 144 | return static_cast<int8_t>(x.compare(RHS: y)); |
| 145 | } |
| 146 | |
| 147 | MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t _mlir_apfloat_neg(int32_t semantics, |
| 148 | uint64_t a) { |
| 149 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| 150 | S: static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| 151 | unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| 152 | llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| 153 | x.changeSign(); |
| 154 | return x.bitcastToAPInt().getZExtValue(); |
| 155 | } |
| 156 | |
| 157 | MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t _mlir_apfloat_abs(int32_t semantics, |
| 158 | uint64_t a) { |
| 159 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| 160 | S: static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| 161 | unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| 162 | llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| 163 | return abs(X: x).bitcastToAPInt().getZExtValue(); |
| 164 | } |
| 165 | |
| 166 | MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t |
| 167 | _mlir_apfloat_flush_denormals(int32_t semantics, uint64_t a) { |
| 168 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| 169 | S: static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| 170 | unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| 171 | llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| 172 | if (x.isDenormal()) |
| 173 | x = llvm::APFloat::getZero(Sem: sem, Negative: x.isNegative()); |
| 174 | return x.bitcastToAPInt().getZExtValue(); |
| 175 | } |
| 176 | |
| 177 | MLIR_APFLOAT_WRAPPERS_EXPORT bool _mlir_apfloat_isfinite(int32_t semantics, |
| 178 | uint64_t a) { |
| 179 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| 180 | S: static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| 181 | unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| 182 | llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| 183 | return x.isFinite(); |
| 184 | } |
| 185 | |
| 186 | MLIR_APFLOAT_WRAPPERS_EXPORT bool _mlir_apfloat_isinfinite(int32_t semantics, |
| 187 | uint64_t a) { |
| 188 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| 189 | S: static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| 190 | unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| 191 | llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| 192 | return x.isInfinity(); |
| 193 | } |
| 194 | |
| 195 | MLIR_APFLOAT_WRAPPERS_EXPORT bool _mlir_apfloat_isnormal(int32_t semantics, |
| 196 | uint64_t a) { |
| 197 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| 198 | S: static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| 199 | unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| 200 | llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| 201 | return x.isNormal(); |
| 202 | } |
| 203 | |
| 204 | MLIR_APFLOAT_WRAPPERS_EXPORT bool _mlir_apfloat_isnan(int32_t semantics, |
| 205 | uint64_t a) { |
| 206 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| 207 | S: static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| 208 | unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| 209 | llvm::APFloat x(sem, llvm::APInt(bitWidth, a)); |
| 210 | return x.isNaN(); |
| 211 | } |
| 212 | |
| 213 | MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t |
| 214 | _mlir_apfloat_fused_multiply_add(int32_t semantics, uint64_t operand, |
| 215 | uint64_t multiplicand, uint64_t addend) { |
| 216 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( |
| 217 | S: static_cast<llvm::APFloatBase::Semantics>(semantics)); |
| 218 | unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); |
| 219 | llvm::APFloat operand_(sem, llvm::APInt(bitWidth, operand)); |
| 220 | llvm::APFloat multiplicand_(sem, llvm::APInt(bitWidth, multiplicand)); |
| 221 | llvm::APFloat addend_(sem, llvm::APInt(bitWidth, addend)); |
| 222 | llvm::detail::opStatus stat = operand_.fusedMultiplyAdd( |
| 223 | Multiplicand: multiplicand_, Addend: addend_, RM: llvm::RoundingMode::NearestTiesToEven); |
| 224 | assert(stat == llvm::APFloatBase::opOK && |
| 225 | "expected fusedMultiplyAdd status to be OK" ); |
| 226 | (void)stat; |
| 227 | return operand_.bitcastToAPInt().getZExtValue(); |
| 228 | } |
| 229 | |
| 230 | /// Min/max operations. |
| 231 | #define APFLOAT_MIN_MAX_OP(OP) \ |
| 232 | MLIR_APFLOAT_WRAPPERS_EXPORT uint64_t _mlir_apfloat_##OP( \ |
| 233 | int32_t semantics, uint64_t a, uint64_t b) { \ |
| 234 | const llvm::fltSemantics &sem = llvm::APFloatBase::EnumToSemantics( \ |
| 235 | static_cast<llvm::APFloatBase::Semantics>(semantics)); \ |
| 236 | unsigned bitWidth = llvm::APFloatBase::semanticsSizeInBits(sem); \ |
| 237 | llvm::APFloat lhs(sem, llvm::APInt(bitWidth, a)); \ |
| 238 | llvm::APFloat rhs(sem, llvm::APInt(bitWidth, b)); \ |
| 239 | llvm::APFloat result = llvm::OP(lhs, rhs); \ |
| 240 | return result.bitcastToAPInt().getZExtValue(); \ |
| 241 | } |
| 242 | |
| 243 | APFLOAT_MIN_MAX_OP(minimum) |
| 244 | APFLOAT_MIN_MAX_OP(maximum) |
| 245 | APFLOAT_MIN_MAX_OP(minnum) |
| 246 | APFLOAT_MIN_MAX_OP(maxnum) |
| 247 | |
| 248 | #undef APFLOAT_MIN_MAX_OP |
| 249 | } |
| 250 | |