[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