[llvm-branch-commits] [llvm] cbc2f2f - Revert "[APFloat] Support user defined bit conversions (#240920)"
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Nov 13 02:27:57 PST 2026
Author: Simon Pilgrim
Date: 2026-11-13T10:27:53Z
New Revision: cbc2f2f7471a11cbfec79b87183d65110fcfe37b
URL: https://github.com/llvm/llvm-project/commit/cbc2f2f7471a11cbfec79b87183d65110fcfe37b
DIFF: https://github.com/llvm/llvm-project/commit/cbc2f2f7471a11cbfec79b87183d65110fcfe37b.diff
LOG: Revert "[APFloat] Support user defined bit conversions (#240920)"
This reverts commit 2be50053ae1b2e4d1a90683e93e451b065f56155.
Added:
Modified:
llvm/include/llvm/ADT/APFloat.h
llvm/lib/Support/APFloat.cpp
llvm/unittests/ADT/APFloatTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/ADT/APFloat.h b/llvm/include/llvm/ADT/APFloat.h
index 87d1f6f533bd1..6655720bee27a 100644
--- a/llvm/include/llvm/ADT/APFloat.h
+++ b/llvm/include/llvm/ADT/APFloat.h
@@ -39,7 +39,6 @@ struct fltSemantics;
class APSInt;
class StringRef;
class APFloat;
-class FloatRepr;
class raw_ostream;
template <typename T> class Expected;
@@ -300,55 +299,37 @@ class APFloatBase {
friend class APFloat;
public:
- static constexpr const fltSemantics &IEEEhalf() { return semIEEEhalf; }
- static constexpr const fltSemantics &BFloat() { return semBFloat; }
- static constexpr const fltSemantics &IEEEsingle() { return semIEEEsingle; }
- static constexpr const fltSemantics &IEEEdouble() { return semIEEEdouble; }
- static constexpr const fltSemantics &IEEEquad() { return semIEEEquad; }
- static constexpr const fltSemantics &x87DoubleExtended() {
+ static const fltSemantics &IEEEhalf() { return semIEEEhalf; }
+ static const fltSemantics &BFloat() { return semBFloat; }
+ static const fltSemantics &IEEEsingle() { return semIEEEsingle; }
+ static const fltSemantics &IEEEdouble() { return semIEEEdouble; }
+ static const fltSemantics &IEEEquad() { return semIEEEquad; }
+ static const fltSemantics &x87DoubleExtended() {
return semX87DoubleExtended;
}
- static constexpr const fltSemantics &PPCDoubleDouble() {
- return semPPCDoubleDouble;
- }
- static constexpr const fltSemantics &PPCDoubleDoubleLegacy() {
+ static const fltSemantics &PPCDoubleDouble() { return semPPCDoubleDouble; }
+ static const fltSemantics &PPCDoubleDoubleLegacy() {
return semPPCDoubleDoubleLegacy;
}
- static constexpr const fltSemantics &Float8E5M2() { return semFloat8E5M2; }
- static constexpr const fltSemantics &Float8E5M2FNUZ() {
- return semFloat8E5M2FNUZ;
- }
- static constexpr const fltSemantics &Float8E4M3() { return semFloat8E4M3; }
- static constexpr const fltSemantics &Float8E4M3FN() {
- return semFloat8E4M3FN;
- }
- static constexpr const fltSemantics &Float8E4M3FNUZ() {
- return semFloat8E4M3FNUZ;
- }
- static constexpr const fltSemantics &Float8E4M3B11FNUZ() {
+ static const fltSemantics &Float8E5M2() { return semFloat8E5M2; }
+ static const fltSemantics &Float8E5M2FNUZ() { return semFloat8E5M2FNUZ; }
+ static const fltSemantics &Float8E4M3() { return semFloat8E4M3; }
+ static const fltSemantics &Float8E4M3FN() { return semFloat8E4M3FN; }
+ static const fltSemantics &Float8E4M3FNUZ() { return semFloat8E4M3FNUZ; }
+ static const fltSemantics &Float8E4M3B11FNUZ() {
return semFloat8E4M3B11FNUZ;
}
- static constexpr const fltSemantics &Float8E3M4() { return semFloat8E3M4; }
- static constexpr const fltSemantics &FloatTF32() { return semFloatTF32; }
- static constexpr const fltSemantics &Float8E8M0FNU() {
- return semFloat8E8M0FNU;
- }
- static constexpr const fltSemantics &Float8E5M3FNU() {
- return semFloat8E5M3FNU;
- }
- static constexpr const fltSemantics &Float6E3M2FN() {
- return semFloat6E3M2FN;
- }
- static constexpr const fltSemantics &Float6E2M3FN() {
- return semFloat6E2M3FN;
- }
- static constexpr const fltSemantics &Float4E2M1FN() {
- return semFloat4E2M1FN;
- }
+ static const fltSemantics &Float8E3M4() { return semFloat8E3M4; }
+ static const fltSemantics &FloatTF32() { return semFloatTF32; }
+ static const fltSemantics &Float8E8M0FNU() { return semFloat8E8M0FNU; }
+ static const fltSemantics &Float8E5M3FNU() { return semFloat8E5M3FNU; }
+ static const fltSemantics &Float6E3M2FN() { return semFloat6E3M2FN; }
+ static const fltSemantics &Float6E2M3FN() { return semFloat6E2M3FN; }
+ static const fltSemantics &Float4E2M1FN() { return semFloat4E2M1FN; }
/// A Pseudo fltsemantic used to construct APFloats that cannot conflict with
/// anything real.
- static constexpr const fltSemantics &Bogus() { return semBogus; }
+ static const fltSemantics &Bogus() { return semBogus; }
// Returns true if any number described by this semantics can be precisely
// represented by the specified semantics. Does not take into account
@@ -728,7 +709,6 @@ class IEEEFloat final {
integerPart *significandParts();
const integerPart *significandParts() const;
LLVM_ABI unsigned int partCount() const;
- static unsigned int partCountForSemantic(APFloatBase::Semantics E);
/// @}
@@ -797,18 +777,49 @@ class IEEEFloat final {
/// @}
- static IEEEFloat &fromRepr(const FloatRepr &R);
-
- template <APFloatBase::Semantics S>
- friend APInt bitcastForSemantics(const FloatRepr &R);
-
template <const fltSemantics &S> APInt convertIEEEFloatToAPInt() const;
-
- template <APFloatBase::Semantics S>
- friend void initFromAPIntForSemantics(FloatRepr &, const APInt &);
-
+ APInt convertHalfAPFloatToAPInt() const;
+ APInt convertBFloatAPFloatToAPInt() const;
+ APInt convertFloatAPFloatToAPInt() const;
+ APInt convertDoubleAPFloatToAPInt() const;
+ APInt convertQuadrupleAPFloatToAPInt() const;
+ APInt convertF80LongDoubleAPFloatToAPInt() const;
+ APInt convertPPCDoubleDoubleLegacyAPFloatToAPInt() const;
+ APInt convertFloat8E5M2APFloatToAPInt() const;
+ APInt convertFloat8E5M2FNUZAPFloatToAPInt() const;
+ APInt convertFloat8E4M3APFloatToAPInt() const;
+ APInt convertFloat8E4M3FNAPFloatToAPInt() const;
+ APInt convertFloat8E4M3FNUZAPFloatToAPInt() const;
+ APInt convertFloat8E4M3B11FNUZAPFloatToAPInt() const;
+ APInt convertFloat8E3M4APFloatToAPInt() const;
+ APInt convertFloatTF32APFloatToAPInt() const;
+ APInt convertFloat8E8M0FNUAPFloatToAPInt() const;
+ APInt convertFloat8E5M3FNUAPFloatToAPInt() const;
+ APInt convertFloat6E3M2FNAPFloatToAPInt() const;
+ APInt convertFloat6E2M3FNAPFloatToAPInt() const;
+ APInt convertFloat4E2M1FNAPFloatToAPInt() const;
void initFromAPInt(const fltSemantics *Sem, const APInt &api);
template <const fltSemantics &S> void initFromIEEEAPInt(const APInt &api);
+ void initFromHalfAPInt(const APInt &api);
+ void initFromBFloatAPInt(const APInt &api);
+ void initFromFloatAPInt(const APInt &api);
+ void initFromDoubleAPInt(const APInt &api);
+ void initFromQuadrupleAPInt(const APInt &api);
+ void initFromF80LongDoubleAPInt(const APInt &api);
+ void initFromPPCDoubleDoubleLegacyAPInt(const APInt &api);
+ void initFromFloat8E5M2APInt(const APInt &api);
+ void initFromFloat8E5M2FNUZAPInt(const APInt &api);
+ void initFromFloat8E4M3APInt(const APInt &api);
+ void initFromFloat8E4M3FNAPInt(const APInt &api);
+ void initFromFloat8E4M3FNUZAPInt(const APInt &api);
+ void initFromFloat8E4M3B11FNUZAPInt(const APInt &api);
+ void initFromFloat8E3M4APInt(const APInt &api);
+ void initFromFloatTF32APInt(const APInt &api);
+ void initFromFloat8E8M0FNUAPInt(const APInt &api);
+ void initFromFloat8E5M3FNUAPInt(const APInt &api);
+ void initFromFloat6E3M2FNAPInt(const APInt &api);
+ void initFromFloat6E2M3FNAPInt(const APInt &api);
+ void initFromFloat4E2M1FNAPInt(const APInt &api);
void assign(const IEEEFloat &);
void copySignificand(const IEEEFloat &);
@@ -839,7 +850,6 @@ class IEEEFloat final {
unsigned int sign : 1;
friend class IEEEFloatUnitTestHelper;
- friend class llvm::FloatRepr;
};
LLVM_ABI hash_code hash_value(const IEEEFloat &Arg);
@@ -1009,42 +1019,6 @@ enum class fltNanEncoding {
NegativeZero,
};
-/// Interface for fltSemantics callbacks to access the internal data of
-/// APFloat/IEEEFloat.
-///
-/// Used to let user provided callback functions in fltSemantics access the
-/// internals of APFloat without making them public and to hide the concrete
-/// class used in APFloat
-class FloatRepr {
- detail::IEEEFloat *Repr;
-
- friend class detail::IEEEFloat;
- explicit FloatRepr(detail::IEEEFloat &F) : Repr(&F) {}
-
-public:
- /// Set the semantics and allocate storage for the significand. Must be
- /// called exactly once before any setter when initializing from bits.
- LLVM_ABI void initialize(const fltSemantics &Sem);
-
- LLVM_ABI const fltSemantics &getSemantics() const;
-
- LLVM_ABI APFloatBase::fltCategory getCategory() const;
- /// Exponent and significand are only meaningful for fcNormal and fcNaN.
- LLVM_ABI void setCategory(APFloatBase::fltCategory Category);
-
- LLVM_ABI bool isNegative() const;
- LLVM_ABI void setNegative(bool Negative);
-
- LLVM_ABI APFloatBase::ExponentType getExponent() const;
- /// - The exponent is unbiased. Denormals use the semantics' minExponent and
- /// have the integer bit cleared.
- LLVM_ABI void setExponent(APFloatBase::ExponentType Exponent);
-
- LLVM_ABI APInt getSignificand() const;
- /// The significand is precision bits wide and includes the integer bit.
- LLVM_ABI void setSignificand(const APInt &Significand);
-};
-
/* Represents floating point arithmetic semantics. */
struct fltSemantics {
/* The largest E such that 2^E is representable; this matches the
@@ -1093,9 +1067,6 @@ struct fltSemantics {
- exponent = 0, integer bit 1 ("pseudodenormal")
The first three are treated as NaNs, the last one as Normal */
bool hasExplicitIntegerBit = false;
-
- void (*initFromAPInt)(FloatRepr &, const APInt &) = nullptr;
- APInt (*bitcastToAPInt)(const FloatRepr &) = nullptr;
};
// This is a interface class that is currently forwarding functionalities from
diff --git a/llvm/lib/Support/APFloat.cpp b/llvm/lib/Support/APFloat.cpp
index 0475685567035..a2848fc46d90d 100644
--- a/llvm/lib/Support/APFloat.cpp
+++ b/llvm/lib/Support/APFloat.cpp
@@ -70,107 +70,11 @@ static_assert(APFloatBase::integerPartWidth % 4 == 0, "Part width must be divisi
namespace llvm {
-namespace detail {
-constexpr const llvm::fltSemantics &EnumToSemanticsCE(APFloatBase::Semantics S);
-
-unsigned int IEEEFloat::partCountForSemantic(APFloatBase::Semantics S) {
- switch (S) {
- case APFloatBase::S_IEEEquad:
- return 2;
- case APFloatBase::S_x87DoubleExtended:
- return 2;
- case APFloatBase::S_PPCDoubleDoubleLegacy:
- return 2;
- case APFloatBase::S_PPCDoubleDouble:
- assert(false);
- default:
- return 1;
- }
-}
-
-template <APFloatBase::Semantics S>
-APInt bitcastForSemantics(const FloatRepr &R) {
- const IEEEFloat &f{IEEEFloat::fromRepr(R)};
- assert(f.partCount() == IEEEFloat::partCountForSemantic(S));
- return f.convertIEEEFloatToAPInt<EnumToSemanticsCE(S)>();
-}
-
-template <APFloatBase::Semantics S>
-void initFromAPIntForSemantics(FloatRepr &R, const APInt &api) {
- IEEEFloat::fromRepr(R).initFromIEEEAPInt<EnumToSemanticsCE(S)>(api);
-}
-} // namespace detail
-
-constexpr fltSemantics APFloatBase::semIEEEhalf = {
- 15,
- -14,
- 11,
- 16,
- fltNonfiniteBehavior::IEEE754,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<S_IEEEhalf>,
- &detail::bitcastForSemantics<S_IEEEhalf>};
-constexpr fltSemantics APFloatBase::semBFloat = {
- 127,
- -126,
- 8,
- 16,
- fltNonfiniteBehavior::IEEE754,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_BFloat>,
- &detail::bitcastForSemantics<APFloatBase::S_BFloat>};
-constexpr fltSemantics APFloatBase::semIEEEsingle = {
- 127,
- -126,
- 24,
- 32,
- fltNonfiniteBehavior::IEEE754,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_IEEEsingle>,
- &detail::bitcastForSemantics<APFloatBase::S_IEEEsingle>};
-constexpr fltSemantics APFloatBase::semIEEEdouble = {
- 1023,
- -1022,
- 53,
- 64,
- fltNonfiniteBehavior::IEEE754,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_IEEEdouble>,
- &detail::bitcastForSemantics<APFloatBase::S_IEEEdouble>};
-constexpr fltSemantics APFloatBase::semIEEEquad = {
- 16383,
- -16382,
- 113,
- 128,
- fltNonfiniteBehavior::IEEE754,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_IEEEquad>,
- &detail::bitcastForSemantics<APFloatBase::S_IEEEquad>};
+constexpr fltSemantics APFloatBase::semIEEEhalf = {15, -14, 11, 16};
+constexpr fltSemantics APFloatBase::semBFloat = {127, -126, 8, 16};
+constexpr fltSemantics APFloatBase::semIEEEsingle = {127, -126, 24, 32};
+constexpr fltSemantics APFloatBase::semIEEEdouble = {1023, -1022, 53, 64};
+constexpr fltSemantics APFloatBase::semIEEEquad = {16383, -16382, 113, 128};
constexpr fltSemantics APFloatBase::semX87DoubleExtended = {
16383,
-16382,
@@ -182,149 +86,22 @@ constexpr fltSemantics APFloatBase::semX87DoubleExtended = {
true,
true,
true,
- true,
- &detail::initFromAPIntForSemantics<APFloatBase::S_x87DoubleExtended>,
- &detail::bitcastForSemantics<APFloatBase::S_x87DoubleExtended>};
-constexpr fltSemantics APFloatBase::semPPCDoubleDouble = {
- -1,
- 0,
- 0,
- 128,
- fltNonfiniteBehavior::IEEE754,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- nullptr,
- nullptr};
+ true};
+constexpr fltSemantics APFloatBase::semPPCDoubleDouble = {-1, 0, 0, 128};
constexpr fltSemantics APFloatBase::semPPCDoubleDoubleLegacy = {
- 1023,
- -1022 + 53,
- 53 + 53,
- 128,
- fltNonfiniteBehavior::IEEE754,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_PPCDoubleDoubleLegacy>,
- &detail::bitcastForSemantics<APFloatBase::S_PPCDoubleDoubleLegacy>};
-constexpr fltSemantics APFloatBase::semFloat8E5M2 = {
- 15,
- -14,
- 3,
- 8,
- fltNonfiniteBehavior::IEEE754,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_Float8E5M2>,
- &detail::bitcastForSemantics<APFloatBase::S_Float8E5M2>};
+ 1023, -1022 + 53, 53 + 53, 128};
+constexpr fltSemantics APFloatBase::semFloat8E5M2 = {15, -14, 3, 8};
constexpr fltSemantics APFloatBase::semFloat8E5M2FNUZ = {
- 15,
- -15,
- 3,
- 8,
- fltNonfiniteBehavior::NanOnly,
- fltNanEncoding::NegativeZero,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_Float8E5M2FNUZ>,
- &detail::bitcastForSemantics<APFloatBase::S_Float8E5M2FNUZ>};
-constexpr fltSemantics APFloatBase::semFloat8E4M3 = {
- 7,
- -6,
- 4,
- 8,
- fltNonfiniteBehavior::IEEE754,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_Float8E4M3>,
- &detail::bitcastForSemantics<APFloatBase::S_Float8E4M3>};
+ 15, -15, 3, 8, fltNonfiniteBehavior::NanOnly, fltNanEncoding::NegativeZero};
+constexpr fltSemantics APFloatBase::semFloat8E4M3 = {7, -6, 4, 8};
constexpr fltSemantics APFloatBase::semFloat8E4M3FN = {
- 8,
- -6,
- 4,
- 8,
- fltNonfiniteBehavior::NanOnly,
- fltNanEncoding::AllOnes,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_Float8E4M3FN>,
- &detail::bitcastForSemantics<APFloatBase::S_Float8E4M3FN>};
+ 8, -6, 4, 8, fltNonfiniteBehavior::NanOnly, fltNanEncoding::AllOnes};
constexpr fltSemantics APFloatBase::semFloat8E4M3FNUZ = {
- 7,
- -7,
- 4,
- 8,
- fltNonfiniteBehavior::NanOnly,
- fltNanEncoding::NegativeZero,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_Float8E4M3FNUZ>,
- &detail::bitcastForSemantics<APFloatBase::S_Float8E4M3FNUZ>};
+ 7, -7, 4, 8, fltNonfiniteBehavior::NanOnly, fltNanEncoding::NegativeZero};
constexpr fltSemantics APFloatBase::semFloat8E4M3B11FNUZ = {
- 4,
- -10,
- 4,
- 8,
- fltNonfiniteBehavior::NanOnly,
- fltNanEncoding::NegativeZero,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_Float8E4M3B11FNUZ>,
- &detail::bitcastForSemantics<APFloatBase::S_Float8E4M3B11FNUZ>};
-constexpr fltSemantics APFloatBase::semFloat8E3M4 = {
- 3,
- -2,
- 5,
- 8,
- fltNonfiniteBehavior::IEEE754,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_Float8E3M4>,
- &detail::bitcastForSemantics<APFloatBase::S_Float8E3M4>};
-constexpr fltSemantics APFloatBase::semFloatTF32 = {
- 127,
- -126,
- 11,
- 19,
- fltNonfiniteBehavior::IEEE754,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_FloatTF32>,
- &detail::bitcastForSemantics<APFloatBase::S_FloatTF32>};
+ 4, -10, 4, 8, fltNonfiniteBehavior::NanOnly, fltNanEncoding::NegativeZero};
+constexpr fltSemantics APFloatBase::semFloat8E3M4 = {3, -2, 5, 8};
+constexpr fltSemantics APFloatBase::semFloatTF32 = {127, -126, 11, 19};
constexpr fltSemantics APFloatBase::semFloat8E8M0FNU = {
127,
-127,
@@ -335,10 +112,7 @@ constexpr fltSemantics APFloatBase::semFloat8E8M0FNU = {
false,
false,
false,
- false,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_Float8E8M0FNU>,
- &detail::bitcastForSemantics<APFloatBase::S_Float8E8M0FNU>};
+ false};
constexpr fltSemantics APFloatBase::semFloat8E5M3FNU = {
16,
@@ -349,110 +123,62 @@ constexpr fltSemantics APFloatBase::semFloat8E5M3FNU = {
fltNanEncoding::AllOnes,
true,
false,
- false,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_Float8E5M3FNU>,
- &detail::bitcastForSemantics<APFloatBase::S_Float8E5M3FNU>};
+ false};
constexpr fltSemantics APFloatBase::semFloat6E3M2FN = {
- 4,
- -2,
- 3,
- 6,
- fltNonfiniteBehavior::FiniteOnly,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_Float6E3M2FN>,
- &detail::bitcastForSemantics<APFloatBase::S_Float6E3M2FN>};
+ 4, -2, 3, 6, fltNonfiniteBehavior::FiniteOnly};
constexpr fltSemantics APFloatBase::semFloat6E2M3FN = {
- 2,
- 0,
- 4,
- 6,
- fltNonfiniteBehavior::FiniteOnly,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_Float6E2M3FN>,
- &detail::bitcastForSemantics<APFloatBase::S_Float6E2M3FN>};
+ 2, 0, 4, 6, fltNonfiniteBehavior::FiniteOnly};
constexpr fltSemantics APFloatBase::semFloat4E2M1FN = {
- 2,
- 0,
- 2,
- 4,
- fltNonfiniteBehavior::FiniteOnly,
- fltNanEncoding::IEEE,
- true,
- true,
- true,
- true,
- false,
- &detail::initFromAPIntForSemantics<APFloatBase::S_Float4E2M1FN>,
- &detail::bitcastForSemantics<APFloatBase::S_Float4E2M1FN>};
+ 2, 0, 2, 4, fltNonfiniteBehavior::FiniteOnly};
constexpr fltSemantics APFloatBase::semBogus = {0, 0, 0, 0};
-constexpr const llvm::fltSemantics &
-detail::EnumToSemanticsCE(APFloatBase::Semantics S) {
- switch (S) {
- case APFloatBase::S_IEEEhalf:
- return APFloatBase::IEEEhalf();
- case APFloatBase::S_BFloat:
- return APFloatBase::BFloat();
- case APFloatBase::S_IEEEsingle:
- return APFloatBase::IEEEsingle();
- case APFloatBase::S_IEEEdouble:
- return APFloatBase::IEEEdouble();
- case APFloatBase::S_IEEEquad:
- return APFloatBase::IEEEquad();
- case APFloatBase::S_x87DoubleExtended:
- return APFloatBase::x87DoubleExtended();
- case APFloatBase::S_PPCDoubleDouble:
- return APFloatBase::PPCDoubleDouble();
- case APFloatBase::S_PPCDoubleDoubleLegacy:
- return APFloatBase::PPCDoubleDoubleLegacy();
- case APFloatBase::S_Float8E5M2:
- return APFloatBase::Float8E5M2();
- case APFloatBase::S_Float8E5M2FNUZ:
- return APFloatBase::Float8E5M2FNUZ();
- case APFloatBase::S_Float8E4M3:
- return APFloatBase::Float8E4M3();
- case APFloatBase::S_Float8E4M3FN:
- return APFloatBase::Float8E4M3FN();
- case APFloatBase::S_Float8E4M3FNUZ:
- return APFloatBase::Float8E4M3FNUZ();
- case APFloatBase::S_Float8E4M3B11FNUZ:
- return APFloatBase::Float8E4M3B11FNUZ();
- case APFloatBase::S_Float8E3M4:
- return APFloatBase::Float8E3M4();
- case APFloatBase::S_FloatTF32:
- return APFloatBase::FloatTF32();
- case APFloatBase::S_Float8E8M0FNU:
- return APFloatBase::Float8E8M0FNU();
- case APFloatBase::S_Float8E5M3FNU:
- return APFloatBase::Float8E5M3FNU();
- case APFloatBase::S_Float6E3M2FN:
- return APFloatBase::Float6E3M2FN();
- case APFloatBase::S_Float6E2M3FN:
- return APFloatBase::Float6E2M3FN();
- case APFloatBase::S_Float4E2M1FN:
- return APFloatBase::Float4E2M1FN();
- }
- return APFloatBase::Bogus();
-}
-
const llvm::fltSemantics &APFloatBase::EnumToSemantics(Semantics S) {
- // Wrapper to avoid moving EnumToSemanticsCE into the header
- const fltSemantics &Sem = detail::EnumToSemanticsCE(S);
- assert(&Sem != &semBogus);
- return Sem;
+ switch (S) {
+ case S_IEEEhalf:
+ return IEEEhalf();
+ case S_BFloat:
+ return BFloat();
+ case S_IEEEsingle:
+ return IEEEsingle();
+ case S_IEEEdouble:
+ return IEEEdouble();
+ case S_IEEEquad:
+ return IEEEquad();
+ case S_x87DoubleExtended:
+ return x87DoubleExtended();
+ case S_PPCDoubleDouble:
+ return PPCDoubleDouble();
+ case S_PPCDoubleDoubleLegacy:
+ return PPCDoubleDoubleLegacy();
+ case S_Float8E5M2:
+ return Float8E5M2();
+ case S_Float8E5M2FNUZ:
+ return Float8E5M2FNUZ();
+ case S_Float8E4M3:
+ return Float8E4M3();
+ case S_Float8E4M3FN:
+ return Float8E4M3FN();
+ case S_Float8E4M3FNUZ:
+ return Float8E4M3FNUZ();
+ case S_Float8E4M3B11FNUZ:
+ return Float8E4M3B11FNUZ();
+ case S_Float8E3M4:
+ return Float8E3M4();
+ case S_FloatTF32:
+ return FloatTF32();
+ case S_Float8E8M0FNU:
+ return Float8E8M0FNU();
+ case S_Float8E5M3FNU:
+ return Float8E5M3FNU();
+ case S_Float6E3M2FN:
+ return Float6E3M2FN();
+ case S_Float6E2M3FN:
+ return Float6E2M3FN();
+ case S_Float4E2M1FN:
+ return Float4E2M1FN();
+ }
+ llvm_unreachable("Unrecognised floating semantics");
}
APFloatBase::Semantics
@@ -3760,9 +3486,12 @@ hash_code hash_value(const IEEEFloat &Arg) {
// Denormals have exponent minExponent in APFloat, but minExponent-1 in
// the actual IEEE respresentations. We compensate for that here.
-template <>
-APInt IEEEFloat::convertIEEEFloatToAPInt<
- APFloatBase::semPPCDoubleDoubleLegacy>() const {
+APInt IEEEFloat::convertF80LongDoubleAPFloatToAPInt() const {
+ assert(partCount() == 2);
+ return convertIEEEFloatToAPInt<APFloatBase::semX87DoubleExtended>();
+}
+
+APInt IEEEFloat::convertPPCDoubleDoubleLegacyAPFloatToAPInt() const {
assert(semantics ==
(const llvm::fltSemantics *)&APFloatBase::semPPCDoubleDoubleLegacy);
assert(partCount()==2);
@@ -3786,8 +3515,7 @@ APInt IEEEFloat::convertIEEEFloatToAPInt<
IEEEFloat u(extended);
fs = u.convert(APFloatBase::semIEEEdouble, rmNearestTiesToEven, &losesInfo);
assert(fs == opOK || fs == opInexact);
- words[0] = *bitcastForSemantics<APFloatBase::S_IEEEdouble>(FloatRepr(u))
- .getRawData();
+ words[0] = *u.convertDoubleAPFloatToAPInt().getRawData();
// If conversion was exact or resulted in a special case, we're done;
// just set the second double to zero. Otherwise, re-convert back to
@@ -3801,8 +3529,7 @@ APInt IEEEFloat::convertIEEEFloatToAPInt<
v.subtract(u, rmNearestTiesToEven);
fs = v.convert(APFloatBase::semIEEEdouble, rmNearestTiesToEven, &losesInfo);
assert(fs == opOK && !losesInfo);
- words[1] = *bitcastForSemantics<APFloatBase::S_IEEEdouble>(FloatRepr(v))
- .getRawData();
+ words[1] = *v.convertDoubleAPFloatToAPInt().getRawData();
} else {
words[1] = 0;
}
@@ -3884,15 +3611,165 @@ APInt IEEEFloat::convertIEEEFloatToAPInt() const {
return APInt(S.sizeInBits, words);
}
+APInt IEEEFloat::convertQuadrupleAPFloatToAPInt() const {
+ assert(partCount() == 2);
+ return convertIEEEFloatToAPInt<APFloatBase::semIEEEquad>();
+}
+
+APInt IEEEFloat::convertDoubleAPFloatToAPInt() const {
+ assert(partCount()==1);
+ return convertIEEEFloatToAPInt<APFloatBase::semIEEEdouble>();
+}
+
+APInt IEEEFloat::convertFloatAPFloatToAPInt() const {
+ assert(partCount()==1);
+ return convertIEEEFloatToAPInt<APFloatBase::semIEEEsingle>();
+}
+
+APInt IEEEFloat::convertBFloatAPFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semBFloat>();
+}
+
+APInt IEEEFloat::convertHalfAPFloatToAPInt() const {
+ assert(partCount()==1);
+ return convertIEEEFloatToAPInt<APFloatBase::APFloatBase::semIEEEhalf>();
+}
+
+APInt IEEEFloat::convertFloat8E5M2APFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semFloat8E5M2>();
+}
+
+APInt IEEEFloat::convertFloat8E5M2FNUZAPFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semFloat8E5M2FNUZ>();
+}
+
+APInt IEEEFloat::convertFloat8E4M3APFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semFloat8E4M3>();
+}
+
+APInt IEEEFloat::convertFloat8E4M3FNAPFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semFloat8E4M3FN>();
+}
+
+APInt IEEEFloat::convertFloat8E4M3FNUZAPFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semFloat8E4M3FNUZ>();
+}
+
+APInt IEEEFloat::convertFloat8E4M3B11FNUZAPFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semFloat8E4M3B11FNUZ>();
+}
+
+APInt IEEEFloat::convertFloat8E3M4APFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semFloat8E3M4>();
+}
+
+APInt IEEEFloat::convertFloatTF32APFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semFloatTF32>();
+}
+
+APInt IEEEFloat::convertFloat8E8M0FNUAPFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semFloat8E8M0FNU>();
+}
+
+APInt IEEEFloat::convertFloat8E5M3FNUAPFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semFloat8E5M3FNU>();
+}
+
+APInt IEEEFloat::convertFloat6E3M2FNAPFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semFloat6E3M2FN>();
+}
+
+APInt IEEEFloat::convertFloat6E2M3FNAPFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semFloat6E2M3FN>();
+}
+
+APInt IEEEFloat::convertFloat4E2M1FNAPFloatToAPInt() const {
+ assert(partCount() == 1);
+ return convertIEEEFloatToAPInt<APFloatBase::semFloat4E2M1FN>();
+}
+
// This function creates an APInt that is just a bit map of the floating
// point constant as it would appear in memory. It is not a conversion,
// and treating the result as a normal integer is unlikely to be useful.
APInt IEEEFloat::bitcastToAPInt() const {
- assert(semantics->bitcastToAPInt != nullptr &&
- "semantics must have bitcastToAPInt defined");
- const FloatRepr R(const_cast<IEEEFloat &>(*this));
- return semantics->bitcastToAPInt(R);
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semIEEEhalf)
+ return convertHalfAPFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semBFloat)
+ return convertBFloatAPFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semIEEEsingle)
+ return convertFloatAPFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semIEEEdouble)
+ return convertDoubleAPFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semIEEEquad)
+ return convertQuadrupleAPFloatToAPInt();
+
+ if (semantics ==
+ (const llvm::fltSemantics *)&APFloatBase::semX87DoubleExtended)
+ return convertF80LongDoubleAPFloatToAPInt();
+
+ if (semantics ==
+ (const llvm::fltSemantics *)&APFloatBase::semPPCDoubleDoubleLegacy)
+ return convertPPCDoubleDoubleLegacyAPFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semFloat8E5M2)
+ return convertFloat8E5M2APFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semFloat8E5M2FNUZ)
+ return convertFloat8E5M2FNUZAPFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semFloat8E4M3)
+ return convertFloat8E4M3APFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semFloat8E4M3FN)
+ return convertFloat8E4M3FNAPFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semFloat8E4M3FNUZ)
+ return convertFloat8E4M3FNUZAPFloatToAPInt();
+
+ if (semantics ==
+ (const llvm::fltSemantics *)&APFloatBase::semFloat8E4M3B11FNUZ)
+ return convertFloat8E4M3B11FNUZAPFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semFloat8E3M4)
+ return convertFloat8E3M4APFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semFloatTF32)
+ return convertFloatTF32APFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semFloat8E8M0FNU)
+ return convertFloat8E8M0FNUAPFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semFloat8E5M3FNU)
+ return convertFloat8E5M3FNUAPFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semFloat6E3M2FN)
+ return convertFloat6E3M2FNAPFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semFloat6E2M3FN)
+ return convertFloat6E2M3FNAPFloatToAPInt();
+
+ if (semantics == (const llvm::fltSemantics *)&APFloatBase::semFloat4E2M1FN)
+ return convertFloat4E2M1FNAPFloatToAPInt();
+
+ llvm_unreachable("unknown format!");
}
float IEEEFloat::convertToFloat() const {
@@ -3918,15 +3795,17 @@ float128 IEEEFloat::convertToQuad() const {
}
#endif
-template <>
-void IEEEFloat::initFromIEEEAPInt<APFloatBase::semPPCDoubleDoubleLegacy>(
- const APInt &api) {
+void IEEEFloat::initFromF80LongDoubleAPInt(const APInt &api) {
+ return initFromIEEEAPInt<APFloatBase::semX87DoubleExtended>(api);
+}
+
+void IEEEFloat::initFromPPCDoubleDoubleLegacyAPInt(const APInt &api) {
uint64_t i1 = api.getRawData()[0];
uint64_t i2 = api.getRawData()[1];
bool losesInfo;
// Get the first double and convert to our format.
- initFromIEEEAPInt<APFloatBase::semIEEEdouble>(APInt(64, i1));
+ initFromDoubleAPInt(APInt(64, i1));
[[maybe_unused]] opStatus fs = convert(APFloatBase::semPPCDoubleDoubleLegacy,
rmNearestTiesToEven, &losesInfo);
// (convert may return opInvalidOp if i1 is an sNaN).
@@ -3947,6 +3826,19 @@ void IEEEFloat::initFromIEEEAPInt<APFloatBase::semPPCDoubleDoubleLegacy>(
}
}
+// The E8M0 format has the following characteristics:
+// It is an 8-bit unsigned format with only exponents (no actual significand).
+// No encodings for {zero, infinities or denorms}.
+// NaN is represented by all 1's.
+// Bias is 127.
+void IEEEFloat::initFromFloat8E8M0FNUAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semFloat8E8M0FNU>(api);
+}
+
+void IEEEFloat::initFromFloat8E5M3FNUAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semFloat8E5M3FNU>(api);
+}
+
template <const fltSemantics &S>
void IEEEFloat::initFromIEEEAPInt(const APInt &api) {
assert(api.getBitWidth() == S.sizeInBits);
@@ -4085,13 +3977,115 @@ void IEEEFloat::initFromIEEEAPInt(const APInt &api) {
}
}
+void IEEEFloat::initFromQuadrupleAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semIEEEquad>(api);
+}
+
+void IEEEFloat::initFromDoubleAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semIEEEdouble>(api);
+}
+
+void IEEEFloat::initFromFloatAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semIEEEsingle>(api);
+}
+
+void IEEEFloat::initFromBFloatAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semBFloat>(api);
+}
+
+void IEEEFloat::initFromHalfAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semIEEEhalf>(api);
+}
+
+void IEEEFloat::initFromFloat8E5M2APInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semFloat8E5M2>(api);
+}
+
+void IEEEFloat::initFromFloat8E5M2FNUZAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semFloat8E5M2FNUZ>(api);
+}
+
+void IEEEFloat::initFromFloat8E4M3APInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semFloat8E4M3>(api);
+}
+
+void IEEEFloat::initFromFloat8E4M3FNAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semFloat8E4M3FN>(api);
+}
+
+void IEEEFloat::initFromFloat8E4M3FNUZAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semFloat8E4M3FNUZ>(api);
+}
+
+void IEEEFloat::initFromFloat8E4M3B11FNUZAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semFloat8E4M3B11FNUZ>(api);
+}
+
+void IEEEFloat::initFromFloat8E3M4APInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semFloat8E3M4>(api);
+}
+
+void IEEEFloat::initFromFloatTF32APInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semFloatTF32>(api);
+}
+
+void IEEEFloat::initFromFloat6E3M2FNAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semFloat6E3M2FN>(api);
+}
+
+void IEEEFloat::initFromFloat6E2M3FNAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semFloat6E2M3FN>(api);
+}
+
+void IEEEFloat::initFromFloat4E2M1FNAPInt(const APInt &api) {
+ initFromIEEEAPInt<APFloatBase::semFloat4E2M1FN>(api);
+}
+
/// Treat api as containing the bits of a floating point number.
void IEEEFloat::initFromAPInt(const fltSemantics *Sem, const APInt &api) {
assert(api.getBitWidth() == Sem->sizeInBits);
- assert(Sem->initFromAPInt != nullptr &&
- "semantics must have initFromAPInt defined");
- FloatRepr R(*this);
- Sem->initFromAPInt(R, api);
+ if (Sem == &APFloatBase::semIEEEhalf)
+ return initFromHalfAPInt(api);
+ if (Sem == &APFloatBase::semBFloat)
+ return initFromBFloatAPInt(api);
+ if (Sem == &APFloatBase::semIEEEsingle)
+ return initFromFloatAPInt(api);
+ if (Sem == &APFloatBase::semIEEEdouble)
+ return initFromDoubleAPInt(api);
+ if (Sem == &APFloatBase::semIEEEquad)
+ return initFromQuadrupleAPInt(api);
+ if (Sem == &APFloatBase::semX87DoubleExtended)
+ return initFromF80LongDoubleAPInt(api);
+ if (Sem == &APFloatBase::semPPCDoubleDoubleLegacy)
+ return initFromPPCDoubleDoubleLegacyAPInt(api);
+ if (Sem == &APFloatBase::semFloat8E5M2)
+ return initFromFloat8E5M2APInt(api);
+ if (Sem == &APFloatBase::semFloat8E5M2FNUZ)
+ return initFromFloat8E5M2FNUZAPInt(api);
+ if (Sem == &APFloatBase::semFloat8E4M3)
+ return initFromFloat8E4M3APInt(api);
+ if (Sem == &APFloatBase::semFloat8E4M3FN)
+ return initFromFloat8E4M3FNAPInt(api);
+ if (Sem == &APFloatBase::semFloat8E4M3FNUZ)
+ return initFromFloat8E4M3FNUZAPInt(api);
+ if (Sem == &APFloatBase::semFloat8E4M3B11FNUZ)
+ return initFromFloat8E4M3B11FNUZAPInt(api);
+ if (Sem == &APFloatBase::semFloat8E3M4)
+ return initFromFloat8E3M4APInt(api);
+ if (Sem == &APFloatBase::semFloatTF32)
+ return initFromFloatTF32APInt(api);
+ if (Sem == &APFloatBase::semFloat8E8M0FNU)
+ return initFromFloat8E8M0FNUAPInt(api);
+ if (Sem == &APFloatBase::semFloat8E5M3FNU)
+ return initFromFloat8E5M3FNUAPInt(api);
+ if (Sem == &APFloatBase::semFloat6E3M2FN)
+ return initFromFloat6E3M2FNAPInt(api);
+ if (Sem == &APFloatBase::semFloat6E2M3FN)
+ return initFromFloat6E2M3FNAPInt(api);
+ if (Sem == &APFloatBase::semFloat4E2M1FN)
+ return initFromFloat4E2M1FNAPInt(api);
+
+ llvm_unreachable("unsupported semantics");
}
/// Make this number the largest magnitude normal number in the given
@@ -5943,53 +5937,6 @@ DoubleAPFloat frexp(const DoubleAPFloat &Arg, int &Exp,
APInt DoubleAPFloat::getNaNPayload() const { return Floats[0].getNaNPayload(); }
} // namespace detail
-detail::IEEEFloat &detail::IEEEFloat::fromRepr(const FloatRepr &R) {
- return *R.Repr;
-}
-
-void FloatRepr::initialize(const fltSemantics &Sem) { Repr->initialize(&Sem); }
-
-const fltSemantics &FloatRepr::getSemantics() const { return *Repr->semantics; }
-
-APFloatBase::fltCategory FloatRepr::getCategory() const {
- return Repr->category;
-}
-
-bool FloatRepr::isNegative() const { return Repr->sign; }
-
-APFloatBase::ExponentType FloatRepr::getExponent() const {
- return Repr->exponent;
-}
-
-APInt FloatRepr::getSignificand() const {
- return APInt(Repr->semantics->precision,
- ArrayRef(Repr->significandParts(), Repr->partCount()));
-}
-
-void FloatRepr::setCategory(APFloatBase::fltCategory Category) {
- Repr->category = Category;
-}
-
-void FloatRepr::setNegative(bool Negative) {
- assert((!Negative || Repr->semantics->hasSignedRepr) &&
- "This floating point format does not support signed values");
- Repr->sign = Negative;
-}
-
-void FloatRepr::setExponent(APFloatBase::ExponentType Exponent) {
- Repr->exponent = Exponent;
-}
-
-void FloatRepr::setSignificand(const APInt &Significand) {
- assert(Significand.getBitWidth() == Repr->semantics->precision &&
- "significand must be precision bits wide");
- APFloatBase::integerPart *Parts = Repr->significandParts();
- unsigned PartCount = Repr->partCount();
- APInt::tcSet(Parts, 0, PartCount);
- std::copy_n(Significand.getRawData(),
- std::min(PartCount, Significand.getNumWords()), Parts);
-}
-
APFloat::Storage::Storage(IEEEFloat F, const fltSemantics &Semantics) {
if (usesLayout<IEEEFloat>(Semantics)) {
new (&IEEE) IEEEFloat(std::move(F));
diff --git a/llvm/unittests/ADT/APFloatTest.cpp b/llvm/unittests/ADT/APFloatTest.cpp
index 54486650e9e0f..06d23bed4edaa 100644
--- a/llvm/unittests/ADT/APFloatTest.cpp
+++ b/llvm/unittests/ADT/APFloatTest.cpp
@@ -2900,8 +2900,6 @@ TEST(APFloatTest, getLargest) {
EXPECT_EQ(7.5,
APFloat::getLargest(APFloat::Float6E2M3FN()).convertToDouble());
EXPECT_EQ(6, APFloat::getLargest(APFloat::Float4E2M1FN()).convertToDouble());
- EXPECT_EQ(APInt(128, "7ffeffffffffffffffffffffffffffff", 16),
- APFloat::getLargest(APFloat::IEEEquad()).bitcastToAPInt());
}
TEST(APFloatTest, getSmallest) {
@@ -8052,7 +8050,7 @@ TEST(APFloatTest, x87Bits) {
}
// Test pseudoinfinity: exp=0x7fff, int_bit=0, significand=0
- // Is treated as NaN in APFloat, see fltSemantics::hasExplicitIntegerBit
+ // Is treated as NaN in APFloat, see IEEEFloat::initFromF80LongDoubleAPInt
{
APFloat pseudoInf(S, APInt(80, {0x0000000000000000ull, 0x7fffull}));
EXPECT_TRUE(pseudoInf.isNaN());
@@ -8061,7 +8059,7 @@ TEST(APFloatTest, x87Bits) {
}
// Test pseudoNaN: exp=0x7fff, int_bit=0, significand!=0
- // Is treated as NaN in APFloat, see fltSemantics::hasExplicitIntegerBit
+ // Is treated as NaN in APFloat, see IEEEFloat::initFromF80LongDoubleAPInt
{
APFloat pseudoNan(S, APInt(80, {0x4000000000000000ull, 0x7fffull}));
EXPECT_TRUE(pseudoNan.isNaN());
@@ -8069,7 +8067,7 @@ TEST(APFloatTest, x87Bits) {
}
// Test unnormal: exp!=0 and !=0x7fff, int_bit=0
- // Is treated as NaN in APFloat, see fltSemantics::hasExplicitIntegerBit
+ // Is treated as NaN in APFloat, see IEEEFloat::initFromF80LongDoubleAPInt
{
APFloat unnormal(S, APInt(80, {0x4000000000000000ull, 0x4000ull}));
EXPECT_TRUE(unnormal.isNaN());
@@ -11502,342 +11500,4 @@ TEST(APFloatTest, exp_exceptions) {
EXPECT_FALSE(llvm::exp(APFloat::getZero(APFloat::IEEEhalf())).has_value());
}
-namespace {
-static void initFloat16E6M9(FloatRepr &R, const APInt &api);
-static APInt bitcastFloat16E6M9(const FloatRepr &R);
-
-static const fltSemantics semFloat16E6M9 = {
- 31, // maxExponent (bias = 31)
- -30, // minExponent (1 - bias = 1 - 31 = -30)
- 10, // precision (9 mantissa + 1 implicit integer bit)
- 16, // sizeInBits
- fltNonfiniteBehavior::IEEE754,
- fltNanEncoding::IEEE,
- true, // hasZero
- true, // hasSignedRepr
- true, // hasSignBitInMSB
- true, // hasDenormals
- false, // hasExplicitIntegerBit
- initFloat16E6M9,
- bitcastFloat16E6M9,
-};
-
-static void initFloat16E6M9(FloatRepr &R, const APInt &api) {
- const fltSemantics &Sem = semFloat16E6M9;
- uint16_t bits = api.getZExtValue();
-
- // Extract fields
- unsigned sign = (bits >> 15) & 1;
- unsigned biasedExp = (bits >> 9) & 0x3F; // 6 bits
- uint64_t mantissa = bits & 0x1FF; // 9 bits
-
- // Initialize the representation with our semantics
- R.initialize(Sem);
- R.setNegative(sign);
-
- if (biasedExp == 0 && mantissa == 0) {
- // Zero
- R.setCategory(APFloat::fcZero);
- R.setExponent(Sem.minExponent - 1);
- R.setSignificand(APInt(Sem.precision, 0));
- } else if (biasedExp == 0x3F) {
- // Infinity or NaN
- if (mantissa == 0) {
- R.setCategory(APFloat::fcInfinity);
- R.setExponent(Sem.maxExponent + 1);
- R.setSignificand(APInt(Sem.precision, 0));
- } else {
- R.setCategory(APFloat::fcNaN);
- R.setExponent(Sem.maxExponent + 1); // exponentNaN
- // Set significand with the integer bit
- R.setSignificand(APInt(Sem.precision, (1ULL << 9) | mantissa));
- }
- } else if (biasedExp == 0) {
- // Denormal
- R.setCategory(APFloat::fcNormal);
- R.setExponent(Sem.minExponent);
- R.setSignificand(APInt(Sem.precision, mantissa));
- } else {
- // Normal
- R.setCategory(APFloat::fcNormal);
- R.setExponent(biasedExp - 31); // unbias
- // Set significand with the integer bit (bit 9)
- R.setSignificand(APInt(Sem.precision, (1ULL << 9) | mantissa));
- }
-}
-
-static APInt bitcastFloat16E6M9(const FloatRepr &R) {
- uint16_t bits = 0;
- const fltSemantics &Sem = semFloat16E6M9;
- EXPECT_EQ(&R.getSemantics(), &Sem);
-
- // Get sign
- if (R.isNegative())
- bits |= (1 << 15);
-
- APFloat::fltCategory cat = R.getCategory();
-
- if (cat == APFloat::fcZero) {
- // Zero: exp=0, mantissa=0
- return APInt(16, bits);
- }
-
- if (cat == APFloat::fcInfinity) {
- // Infinity: exp=all 1s, mantissa=0
- bits |= (0x3F << 9);
- return APInt(16, bits);
- }
-
- if (cat == APFloat::fcNaN) {
- // NaN: exp=all 1s, mantissa!=0
- bits |= (0x3F << 9);
- uint64_t sig = R.getSignificand().getZExtValue() & 0x1FF;
- if (sig == 0)
- sig = 1; // Ensure at least one bit set
- bits |= sig;
- return APInt(16, bits);
- }
-
- // Normal or denormal
- APFloat::ExponentType exp = R.getExponent();
- uint64_t sig = R.getSignificand().getZExtValue();
-
- if (exp == Sem.minExponent && (sig & (1ULL << 9)) == 0) {
- // Denormal: biasedExp = 0, store raw mantissa
- bits |= (sig & 0x1FF);
- } else {
- // Normal
- int biasedExp = exp + 31; // add bias
- bits |= ((biasedExp & 0x3F) << 9);
- bits |= (sig & 0x1FF); // mask off integer bit
- }
-
- return APInt(16, bits);
-}
-} // anonymous namespace
-
-TEST(APFloatTest, UserDefinedSemanticsConversion) {
- const fltSemantics &Sem = semFloat16E6M9;
-
- // Positive zero: 0x0000
- APFloat PosZero(Sem, APInt(16, 0x0000));
- EXPECT_TRUE(PosZero.isZero());
- EXPECT_FALSE(PosZero.isNegative());
- EXPECT_EQ(PosZero.bitcastToAPInt(), APInt(16, 0x0000));
-
- // Negative zero: 0x8000
- APFloat NegZero(Sem, APInt(16, 0x8000));
- EXPECT_TRUE(NegZero.isZero());
- EXPECT_TRUE(NegZero.isNegative());
- EXPECT_EQ(NegZero.bitcastToAPInt(), APInt(16, 0x8000));
-
- // Positive infinity: exp=0x3F (all 1s), mantissa=0 -> 0x7E00
- APFloat PosInf(Sem, APInt(16, 0x7E00));
- EXPECT_TRUE(PosInf.isInfinity());
- EXPECT_FALSE(PosInf.isNegative());
- EXPECT_EQ(PosInf.bitcastToAPInt(), APInt(16, 0x7E00));
-
- // Negative infinity: 0xFE00
- APFloat NegInf(Sem, APInt(16, 0xFE00));
- EXPECT_TRUE(NegInf.isInfinity());
- EXPECT_TRUE(NegInf.isNegative());
- EXPECT_EQ(NegInf.bitcastToAPInt(), APInt(16, 0xFE00));
-
- APFloat Nan(Sem, APInt(16, 0x7E01));
- EXPECT_TRUE(Nan.isNaN());
-
- APFloat One(Sem, APInt(16, 0x3E00));
- EXPECT_TRUE(One.isFiniteNonZero());
- EXPECT_FALSE(One.isNegative());
- bool losesInfo;
- APFloat OneCopy(One);
- OneCopy.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
- &losesInfo);
- EXPECT_NEAR(OneCopy.convertToDouble(), 1.0, 1e-6);
-
- APFloat Two(Sem, APInt(16, 0x4000));
- EXPECT_TRUE(Two.isFiniteNonZero());
-
- APFloat TwoCopy(Two);
- TwoCopy.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
- &losesInfo);
- EXPECT_NEAR(TwoCopy.convertToDouble(), 2.0, 1e-6);
-}
-
-TEST(APFloatTest, UserDefinedSemanticsBitcastRoundtrip) {
- const fltSemantics &Sem = semFloat16E6M9;
-
- // Test various bit patterns for roundtrip
- uint16_t testPatterns[] = {
- 0x0000, // +0
- 0x8000, // -0
- 0x3E00, // 1.0
- 0xBE00, // -1.0
- 0x4000, // 2.0
- 0x7E00, // +inf
- 0xFE00, // -inf
- };
-
- for (uint16_t pattern : testPatterns) {
- APFloat F(Sem, APInt(16, pattern));
- APInt result = F.bitcastToAPInt();
- EXPECT_EQ(result, APInt(16, pattern))
- << "Roundtrip failed for pattern 0x" << std::hex << pattern;
- }
-}
-
-namespace {
-static void initFloat0NaN(FloatRepr &R, const APInt &API);
-static APInt bitcastFloat0NaN(const FloatRepr &R);
-
-// A type without any bits. Its only value is a quiet NaN.
-static const fltSemantics semFloat0NaN = {
- 0, // maxExponent
- 0, // minExponent
- 1, // precision
- 0, // sizeInBits
- fltNonfiniteBehavior::NanOnly,
- fltNanEncoding::AllOnes,
- false, // hasZero
- false, // hasSignedRepr
- false, // hasSignBitInMSB
- false, // hasDenormals
- false, // hasExplicitIntegerBit
- initFloat0NaN,
- bitcastFloat0NaN,
-};
-
-static void initFloat0NaN(FloatRepr &R, const APInt &API) {
- const fltSemantics &Sem = semFloat0NaN;
- R.initialize(Sem);
- R.setNegative(false);
- R.setCategory(APFloat::fcNaN);
- R.setExponent(Sem.maxExponent + 1);
- R.setSignificand(APInt(Sem.precision, 1));
-}
-
-static APInt bitcastFloat0NaN(const FloatRepr &R) {
- EXPECT_EQ(&R.getSemantics(), &semFloat0NaN);
- EXPECT_EQ(R.getCategory(), APFloat::fcNaN);
- return APInt::getZero(0);
-}
-} // anonymous namespace
-
-TEST(APFloatTest, UserDefinedSemanticsZeroBits) {
- const fltSemantics &Sem = semFloat0NaN;
- const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
-
- APFloat FromBits(Sem, APInt::getZero(0));
- APFloat NaN = APFloat::getNaN(Sem);
-
- auto ExpectQNaN = [](const APFloat &F) {
- EXPECT_TRUE(F.isNaN());
- EXPECT_FALSE(F.isSignaling());
- EXPECT_FALSE(F.isNegative());
- EXPECT_EQ(F.bitcastToAPInt(), APInt::getZero(0));
- };
-
- ExpectQNaN(FromBits);
- ExpectQNaN(NaN);
-
- APFloat Sum = FromBits;
- EXPECT_EQ(Sum.add(NaN, RM), APFloat::opOK);
- ExpectQNaN(Sum);
-
- APFloat Diff = FromBits;
- EXPECT_EQ(Diff.subtract(NaN, RM), APFloat::opOK);
- ExpectQNaN(Diff);
-
- APFloat Prod = FromBits;
- EXPECT_EQ(Prod.multiply(NaN, RM), APFloat::opOK);
- ExpectQNaN(Prod);
-
- APFloat Quot = FromBits;
- EXPECT_EQ(Quot.divide(NaN, RM), APFloat::opOK);
- ExpectQNaN(Quot);
-}
-
-namespace {
-static void initFloat1Inf(FloatRepr &R, const APInt &API);
-static APInt bitcastFloat1Inf(const FloatRepr &R);
-
-// A type with only a sign bit. Its only values are +inf and -inf.
-static const fltSemantics semFloat1Inf = {
- 0, // maxExponent
- 0, // minExponent
- 1, // precision
- 1, // sizeInBits
- fltNonfiniteBehavior::IEEE754,
- fltNanEncoding::IEEE,
- false, // hasZero
- true, // hasSignedRepr
- true, // hasSignBitInMSB
- false, // hasDenormals
- false, // hasExplicitIntegerBit
- initFloat1Inf,
- bitcastFloat1Inf,
-};
-
-static void initFloat1Inf(FloatRepr &R, const APInt &API) {
- const fltSemantics &Sem = semFloat1Inf;
- R.initialize(Sem);
- R.setNegative(API[0]);
- R.setCategory(APFloat::fcInfinity);
- R.setExponent(Sem.maxExponent + 1);
- R.setSignificand(APInt::getZero(Sem.precision));
-}
-
-static APInt bitcastFloat1Inf(const FloatRepr &R) {
- EXPECT_EQ(&R.getSemantics(), &semFloat1Inf);
- EXPECT_EQ(R.getCategory(), APFloat::fcInfinity);
- return APInt(1, R.isNegative());
-}
-} // anonymous namespace
-
-TEST(APFloatTest, UserDefinedSemanticsOneBit) {
- const fltSemantics &Sem = semFloat1Inf;
- const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
-
- APFloat PInf(Sem, APInt(1, 0));
- APFloat MInf(Sem, APInt(1, 1));
- EXPECT_TRUE(PInf.bitwiseIsEqual(APFloat::getInf(Sem, false)));
- EXPECT_TRUE(MInf.bitwiseIsEqual(APFloat::getInf(Sem, true)));
-
- auto ExpectInf = [](const APFloat &F, bool Negative) {
- EXPECT_TRUE(F.isInfinity());
- EXPECT_EQ(F.isNegative(), Negative);
- EXPECT_EQ(F.bitcastToAPInt(), APInt(1, Negative));
- };
-
- ExpectInf(PInf, false);
- ExpectInf(MInf, true);
-
- APFloat Sum = PInf;
- EXPECT_EQ(Sum.add(PInf, RM), APFloat::opOK);
- ExpectInf(Sum, false);
-
- Sum = MInf;
- EXPECT_EQ(Sum.add(MInf, RM), APFloat::opOK);
- ExpectInf(Sum, true);
-
- APFloat Diff = PInf;
- EXPECT_EQ(Diff.subtract(MInf, RM), APFloat::opOK);
- ExpectInf(Diff, false);
-
- Diff = MInf;
- EXPECT_EQ(Diff.subtract(PInf, RM), APFloat::opOK);
- ExpectInf(Diff, true);
-
- APFloat Prod = PInf;
- EXPECT_EQ(Prod.multiply(PInf, RM), APFloat::opOK);
- ExpectInf(Prod, false);
-
- Prod = PInf;
- EXPECT_EQ(Prod.multiply(MInf, RM), APFloat::opOK);
- ExpectInf(Prod, true);
-
- Prod = MInf;
- EXPECT_EQ(Prod.multiply(MInf, RM), APFloat::opOK);
- ExpectInf(Prod, false);
-}
} // namespace
More information about the llvm-branch-commits
mailing list