[Support] Split APInt and APFloat ownership

7 files changed, 22 insertions, 296 deletions

diff --git a/backend/lib/CodeGen/GenericConstant.cpp b/backend/lib/CodeGen/GenericConstant.cpp
index d9d9233..afcdd44 100644
--- a/backend/lib/CodeGen/GenericConstant.cpp
+++ b/backend/lib/CodeGen/GenericConstant.cpp
@@ -203,8 +203,7 @@ nonPointerFixedBitWidth(const GenericConstantType &Type) noexcept {
   return false;
 }
 
-[[nodiscard]] bool signedIntegerLess(const IntegerImmediate &Left,
-                                     const IntegerImmediate &Right) noexcept {
+[[nodiscard]] bool signedIntegerLess(const APInt &Left, const APInt &Right) noexcept {
   if (Left.bitWidth() != Right.bitWidth())
     return false;
   if (Left.isNegative() != Right.isNegative())
@@ -249,7 +248,7 @@ nonPointerFixedBitWidth(const GenericConstantType &Type) noexcept {
   case GenericConstantTypeKind::Metadata:
     return RequireNoElements();
   case GenericConstantTypeKind::Integer:
-    if (Type.BitWidth == 0 || Type.BitWidth > IntegerImmediate::MaxBitWidth) {
+    if (Type.BitWidth == 0 || Type.BitWidth > APInt::MaxBitWidth) {
       return makeUnexpected(ErrorCode::VerificationError,
                             "generic integer type has an invalid bit width");
     }
@@ -257,7 +256,7 @@ nonPointerFixedBitWidth(const GenericConstantType &Type) noexcept {
   case GenericConstantTypeKind::Byte:
     return RequireNoElements();
   case GenericConstantTypeKind::Floating:
-    if (!isKnownFloatSemantics(Type.Semantics)) {
+    if (!getFloatSemanticsBitWidth(Type.Semantics)) {
       return makeUnexpected(ErrorCode::VerificationError,
                             "generic floating type has unknown semantics");
     }
@@ -702,7 +701,7 @@ nonPointerFixedBitWidth(const GenericConstantType &Type) noexcept {
 } // namespace
 
 Expected<GenericConstantType> GenericConstantType::integer(std::uint32_t Width) {
-  if (Width == 0 || Width > IntegerImmediate::MaxBitWidth)
+  if (Width == 0 || Width > APInt::MaxBitWidth)
     return makeUnexpected(ErrorCode::InvalidArgument, "generic integer type width is invalid");
   GenericConstantType Type;
   Type.Kind = GenericConstantTypeKind::Integer;
@@ -724,7 +723,7 @@ GenericConstantType GenericConstantType::byte() noexcept {
 }
 
 Expected<GenericConstantType> GenericConstantType::floating(FloatSemantics ValueSemantics) {
-  if (!isKnownFloatSemantics(ValueSemantics))
+  if (!getFloatSemanticsBitWidth(ValueSemantics))
     return makeUnexpected(ErrorCode::InvalidArgument, "generic floating semantics is unknown");
   GenericConstantType Type;
   Type.Kind = GenericConstantTypeKind::Floating;
@@ -810,7 +809,7 @@ Expected<void> GenericConstantType::verify() const {
   return verifyType(*this, 0, Nodes);
 }
 
-Expected<GenericConstantData> GenericConstantData::integer(IntegerImmediate Value) {
+Expected<GenericConstantData> GenericConstantData::integer(APInt Value) {
   auto Type = GenericConstantType::integer(Value.bitWidth());
   if (!Type)
     return std::unexpected(Type.error());
@@ -821,7 +820,7 @@ Expected<GenericConstantData> GenericConstantData::integer(IntegerImmediate Valu
   return Result;
 }
 
-Expected<GenericConstantData> GenericConstantData::floating(FloatingPointBits Value) {
+Expected<GenericConstantData> GenericConstantData::floating(APFloat Value) {
   auto Type = GenericConstantType::floating(Value.semantics());
   if (!Type)
     return std::unexpected(Type.error());
diff --git a/backend/lib/CodeGen/GlobalObject.cpp b/backend/lib/CodeGen/GlobalObject.cpp
index cda28bd..aa8fd15 100644
--- a/backend/lib/CodeGen/GlobalObject.cpp
+++ b/backend/lib/CodeGen/GlobalObject.cpp
@@ -45,7 +45,7 @@ namespace {
   case GlobalInitializer::Kind::Invalid:
     return makeUnexpected(ErrorCode::VerificationError, "global initializer is invalid");
   case GlobalInitializer::Kind::Integer: {
-    const auto *Value = Initializer.getIf<IntegerImmediate>();
+    const auto *Value = Initializer.getIf<APInt>();
     if (Value == nullptr)
       return makeUnexpected(ErrorCode::InternalError, "integer initializer storage is invalid");
     auto Verified = Value->verify();
@@ -54,7 +54,7 @@ namespace {
     return (static_cast<std::uint64_t>(Value->bitWidth()) + 7U) / 8U;
   }
   case GlobalInitializer::Kind::Floating: {
-    const auto *Value = Initializer.getIf<FloatingPointBits>();
+    const auto *Value = Initializer.getIf<APFloat>();
     if (Value == nullptr)
       return makeUnexpected(ErrorCode::InternalError, "floating initializer storage is invalid");
     return (static_cast<std::uint64_t>(Value->bitWidth()) + 7U) / 8U;
@@ -141,11 +141,11 @@ namespace {
 
 } // namespace
 
-GlobalInitializer GlobalInitializer::integer(IntegerImmediate Value) {
+GlobalInitializer GlobalInitializer::integer(APInt Value) {
   return GlobalInitializer(std::move(Value));
 }
 
-GlobalInitializer GlobalInitializer::floating(FloatingPointBits Value) {
+GlobalInitializer GlobalInitializer::floating(APFloat Value) {
   return GlobalInitializer(Value);
 }
 
diff --git a/backend/lib/CodeGen/LowLevelType.cpp b/backend/lib/CodeGen/LowLevelType.cpp
index b124765..b50ea6b 100644
--- a/backend/lib/CodeGen/LowLevelType.cpp
+++ b/backend/lib/CodeGen/LowLevelType.cpp
@@ -8,43 +8,6 @@
 namespace rcc {
 namespace {
 
-struct FloatSemanticsInfo final {
-  std::uint32_t BitWidth;
-  std::string_view Name;
-  std::string_view Spelling;
-};
-
-constexpr std::array FloatSemanticsTable{
-    FloatSemanticsInfo{16, "IEEE half", "f16"},
-    FloatSemanticsInfo{16, "bfloat", "bf16"},
-    FloatSemanticsInfo{32, "IEEE single", "f32"},
-    FloatSemanticsInfo{64, "IEEE double", "f64"},
-    FloatSemanticsInfo{128, "IEEE quad", "f128"},
-    FloatSemanticsInfo{128, "PPC double-double", "ppcf128"},
-    FloatSemanticsInfo{8, "float8 E5M2", "f8e5m2"},
-    FloatSemanticsInfo{8, "float8 E5M2 FNUZ", "f8e5m2fnuz"},
-    FloatSemanticsInfo{8, "float8 E4M3", "f8e4m3"},
-    FloatSemanticsInfo{8, "float8 E4M3 FN", "f8e4m3fn"},
-    FloatSemanticsInfo{8, "float8 E4M3 FNUZ", "f8e4m3fnuz"},
-    FloatSemanticsInfo{8, "float8 E4M3 B11 FNUZ", "f8e4m3b11fnuz"},
-    FloatSemanticsInfo{8, "float8 E3M4", "f8e3m4"},
-    FloatSemanticsInfo{19, "TensorFloat-32", "tf32"},
-    FloatSemanticsInfo{8, "float8 E8M0 FNU", "f8e8m0fnu"},
-    FloatSemanticsInfo{6, "float6 E3M2 FN", "f6e3m2fn"},
-    FloatSemanticsInfo{6, "float6 E2M3 FN", "f6e2m3fn"},
-    FloatSemanticsInfo{4, "float4 E2M1 FN", "f4e2m1fn"},
-    FloatSemanticsInfo{80, "x87 double-extended", "x86fp80"},
-};
-
-static_assert(FloatSemanticsTable.size() == static_cast<std::size_t>(FloatSemantics::Count));
-
-[[nodiscard]] const FloatSemanticsInfo *getFloatSemanticsInfo(FloatSemantics Semantics) noexcept {
-  const auto Index = static_cast<std::size_t>(Semantics);
-  if (Index >= FloatSemanticsTable.size())
-    return nullptr;
-  return &FloatSemanticsTable[Index];
-}
-
 [[nodiscard]] LLT::Kind getVectorKind(LLT ElementType) noexcept {
   switch (ElementType.kind()) {
   case LLT::Kind::AnyScalar:
@@ -69,31 +32,6 @@ static_assert(FloatSemanticsTable.size() == static_cast<std::size_t>(FloatSemant
 
 } // namespace
 
-bool isKnownFloatSemantics(FloatSemantics Semantics) noexcept {
-  return getFloatSemanticsInfo(Semantics) != nullptr;
-}
-
-std::optional<std::uint32_t> getFloatSemanticsBitWidth(FloatSemantics Semantics) noexcept {
-  const auto *Info = getFloatSemanticsInfo(Semantics);
-  if (Info == nullptr)
-    return std::nullopt;
-  return Info->BitWidth;
-}
-
-std::string_view getFloatSemanticsName(FloatSemantics Semantics) noexcept {
-  const auto *Info = getFloatSemanticsInfo(Semantics);
-  if (Info == nullptr)
-    return "unknown";
-  return Info->Name;
-}
-
-std::string_view getFloatSemanticsSpelling(FloatSemantics Semantics) noexcept {
-  const auto *Info = getFloatSemanticsInfo(Semantics);
-  if (Info == nullptr)
-    return "invalid-float";
-  return Info->Spelling;
-}
-
 Expected<LLT> LLT::makeScalar(Kind TypeKind, std::uint64_t BitWidth) {
   if (BitWidth == 0 || BitWidth > MaxBitWidth) {
     return makeUnexpected(ErrorCode::InvalidArgument,
diff --git a/backend/lib/CodeGen/MIRParser/MIParser.cpp b/backend/lib/CodeGen/MIRParser/MIParser.cpp
index e38b9f1..183e6b3 100644
--- a/backend/lib/CodeGen/MIRParser/MIParser.cpp
+++ b/backend/lib/CodeGen/MIRParser/MIParser.cpp
@@ -116,9 +116,9 @@ namespace {
          Token.isKeyword("llvm_vector_register_mask");
 }
 
-[[nodiscard]] Expected<IntegerImmediate> parseIntegerImmediateValue(std::uint32_t BitWidth,
-                                                                    std::string_view Spelling) {
-  if (BitWidth == 0 || BitWidth > IntegerImmediate::MaxBitWidth)
+[[nodiscard]] Expected<APInt> parseIntegerImmediateValue(std::uint32_t BitWidth,
+                                                         std::string_view Spelling) {
+  if (BitWidth == 0 || BitWidth > APInt::MaxBitWidth)
     return makeUnexpected(ErrorCode::ParseError, "typed integer width is out of range");
 
   const bool Negative = Spelling.starts_with('-');
@@ -155,7 +155,7 @@ namespace {
     if (BitWidth % 64U != 0)
       Words.back() &= (std::uint64_t{1} << (BitWidth % 64U)) - 1U;
   }
-  return IntegerImmediate::create(BitWidth, Words);
+  return APInt::create(BitWidth, Words);
 }
 
 [[nodiscard]] std::optional<std::uint64_t> minimumTypeSizeInBits(LLT Type) noexcept {
@@ -1244,7 +1244,7 @@ bool MIParser::Impl::parseTypedIntegerOperand(ParsedOperand &Result) {
     return fail(Begin, "typed integer operand must use an 'iN' type");
   std::uint64_t WideBitWidth = 0;
   if (!parseUnsignedDigits(TypeSpelling.substr(1), WideBitWidth) ||
-      WideBitWidth > IntegerImmediate::MaxBitWidth) {
+      WideBitWidth > APInt::MaxBitWidth) {
     return fail(Begin, "typed integer operand has an invalid bit width");
   }
   const auto BitWidth = static_cast<std::uint32_t>(WideBitWidth);
diff --git a/backend/lib/CodeGen/MIRPrinter.cpp b/backend/lib/CodeGen/MIRPrinter.cpp
index d510c83..ea201b9 100644
--- a/backend/lib/CodeGen/MIRPrinter.cpp
+++ b/backend/lib/CodeGen/MIRPrinter.cpp
@@ -2249,7 +2249,7 @@ Expected<void> BodyPrinter::printOperand(const MachineOperand &Operand, bool IsE
     Output.append(std::to_string(*Operand.getIf<std::int64_t>()));
     return {};
   case MachineOperand::Kind::IntegerImmediate: {
-    const IntegerImmediate &Value = Operand.getIf<IntegerImmediateOperand>()->Value;
+    const APInt &Value = Operand.getIf<IntegerImmediateOperand>()->Value;
     Output.push_back('i');
     Output.append(std::to_string(Value.bitWidth()));
     Output.push_back(' ');
@@ -2260,7 +2260,7 @@ Expected<void> BodyPrinter::printOperand(const MachineOperand &Operand, bool IsE
     return {};
   }
   case MachineOperand::Kind::FloatingImmediate: {
-    const FloatingPointBits &Bits = Operand.getIf<FloatingImmediateOperand>()->Bits;
+    const APFloat &Bits = Operand.getIf<FloatingImmediateOperand>()->Bits;
     auto Constant = GenericConstantData::floating(Bits);
     if (!Constant)
       return std::unexpected(Constant.error());
diff --git a/backend/lib/CodeGen/MachineIRBuilder.cpp b/backend/lib/CodeGen/MachineIRBuilder.cpp
index 6887804..e59f613 100644
--- a/backend/lib/CodeGen/MachineIRBuilder.cpp
+++ b/backend/lib/CodeGen/MachineIRBuilder.cpp
@@ -162,13 +162,11 @@ Expected<void> MachineInstrBuilder::addImmediate(std::int64_t Value, std::uint32
   return addOperand(MachineOperand::immediate(Value, TargetFlags));
 }
 
-Expected<void> MachineInstrBuilder::addIntegerImmediate(IntegerImmediate Value,
-                                                        std::uint32_t TargetFlags) {
+Expected<void> MachineInstrBuilder::addIntegerImmediate(APInt Value, std::uint32_t TargetFlags) {
   return addOperand(MachineOperand::integerImmediate(std::move(Value), TargetFlags));
 }
 
-Expected<void> MachineInstrBuilder::addFloatingImmediate(FloatingPointBits Bits,
-                                                         std::uint32_t TargetFlags) {
+Expected<void> MachineInstrBuilder::addFloatingImmediate(APFloat Bits, std::uint32_t TargetFlags) {
   return addOperand(MachineOperand::floatingImmediate(Bits, TargetFlags));
 }
 
diff --git a/backend/lib/CodeGen/MachineOperand.cpp b/backend/lib/CodeGen/MachineOperand.cpp
index c81a7c3..44ad8b6 100644
--- a/backend/lib/CodeGen/MachineOperand.cpp
+++ b/backend/lib/CodeGen/MachineOperand.cpp
@@ -8,222 +8,14 @@
 #include "rcc/CodeGen/MachineRegisterInfo.h"
 
 #include <algorithm>
-#include <array>
 #include <cstdint>
 #include <limits>
 #include <memory>
-#include <span>
 #include <string>
-#include <string_view>
 #include <utility>
 #include <vector>
 
 namespace rcc {
-namespace {
-
-[[nodiscard]] constexpr std::size_t integerWordCount(std::uint32_t BitWidth) noexcept {
-  return (static_cast<std::size_t>(BitWidth) + 63U) / 64U;
-}
-
-[[nodiscard]] constexpr std::uint64_t integerHighWordMask(std::uint32_t BitWidth) noexcept {
-  const std::uint32_t UsedBits = BitWidth % 64U;
-  if (UsedBits == 0)
-    return std::numeric_limits<std::uint64_t>::max();
-  return (std::uint64_t{1} << UsedBits) - 1U;
-}
-
-[[nodiscard]] Expected<void> verifyIntegerImmediate(std::uint32_t BitWidth,
-                                                    std::span<const std::uint64_t> Words,
-                                                    ErrorCode Code) {
-  if (BitWidth == 0 || BitWidth > IntegerImmediate::MaxBitWidth) {
-    return makeUnexpected(Code, "integer immediate bit width is outside the supported range");
-  }
-  if (Words.size() != integerWordCount(BitWidth)) {
-    return makeUnexpected(Code, "integer immediate bit pattern has the wrong word count");
-  }
-  if ((Words.back() & ~integerHighWordMask(BitWidth)) != 0) {
-    return makeUnexpected(Code, "integer immediate has nonzero bits above its declared width");
-  }
-  return {};
-}
-
-} // namespace
-
-Expected<IntegerImmediate> IntegerImmediate::create(std::uint32_t BitWidth,
-                                                    std::span<const std::uint64_t> Words) {
-  auto Verification = verifyIntegerImmediate(BitWidth, Words, ErrorCode::InvalidArgument);
-  if (!Verification)
-    return std::unexpected(Verification.error());
-  return IntegerImmediate(BitWidth, std::vector<std::uint64_t>(Words.begin(), Words.end()));
-}
-
-Expected<IntegerImmediate> IntegerImmediate::fromUnsigned(std::uint32_t BitWidth,
-                                                          std::uint64_t Value) {
-  if (BitWidth == 0 || BitWidth > MaxBitWidth) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "integer immediate bit width is outside the supported range");
-  }
-  if (BitWidth < 64U && (Value >> BitWidth) != 0) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "unsigned value does not fit the integer immediate bit width");
-  }
-
-  std::vector<std::uint64_t> Words(integerWordCount(BitWidth), 0);
-  Words.front() = Value;
-  return create(BitWidth, Words);
-}
-
-Expected<IntegerImmediate> IntegerImmediate::fromSigned(std::uint32_t BitWidth,
-                                                        std::int64_t Value) {
-  if (BitWidth == 0 || BitWidth > MaxBitWidth) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "integer immediate bit width is outside the supported range");
-  }
-  if (BitWidth < 64U) {
-    const std::uint32_t MagnitudeBits = BitWidth - 1U;
-    const std::int64_t Minimum = -(std::int64_t{1} << MagnitudeBits);
-    const std::int64_t Maximum = (std::int64_t{1} << MagnitudeBits) - 1;
-    if (Value < Minimum || Value > Maximum) {
-      return makeUnexpected(ErrorCode::InvalidArgument,
-                            "signed value does not fit the integer immediate bit width");
-    }
-  }
-
-  const std::uint64_t Fill =
-      Value < 0 ? std::numeric_limits<std::uint64_t>::max() : std::uint64_t{0};
-  std::vector<std::uint64_t> Words(integerWordCount(BitWidth), Fill);
-  Words.front() = static_cast<std::uint64_t>(Value);
-  Words.back() &= integerHighWordMask(BitWidth);
-  return create(BitWidth, Words);
-}
-
-Expected<IntegerImmediate> IntegerImmediate::parseDecimal(std::uint32_t BitWidth,
-                                                          std::string_view Text) {
-  if (BitWidth == 0 || BitWidth > MaxBitWidth) {
-    return makeUnexpected(ErrorCode::ParseError,
-                          "integer immediate bit width is outside the supported range");
-  }
-  const bool Negative = Text.starts_with('-');
-  if (Negative)
-    Text.remove_prefix(1);
-  if (Text.empty())
-    return makeUnexpected(ErrorCode::ParseError, "integer immediate has no decimal digits");
-
-  std::vector<std::uint64_t> Words(integerWordCount(BitWidth), 0);
-  for (const char Character : Text) {
-    if (Character < '0' || Character > '9') {
-      return makeUnexpected(ErrorCode::ParseError,
-                            "integer immediate contains a non-decimal digit");
-    }
-    std::uint64_t Carry = static_cast<unsigned>(Character - '0');
-    for (std::uint64_t &Word : Words) {
-      const unsigned __int128 Product = static_cast<unsigned __int128>(Word) * 10U + Carry;
-      Word = static_cast<std::uint64_t>(Product);
-      Carry = static_cast<std::uint64_t>(Product >> 64U);
-    }
-  }
-
-  // LLVM integer literals are arbitrary precision and are extended or
-  // truncated to the declared bit width before becoming a constant.
-  Words.back() &= integerHighWordMask(BitWidth);
-  if (Negative) {
-    for (std::uint64_t &Word : Words)
-      Word = ~Word;
-    std::uint64_t Carry = 1;
-    for (std::uint64_t &Word : Words) {
-      const std::uint64_t Previous = Word;
-      Word += Carry;
-      Carry = Carry != 0 && Word < Previous ? 1 : 0;
-    }
-    Words.back() &= integerHighWordMask(BitWidth);
-  }
-  return create(BitWidth, Words);
-}
-
-bool IntegerImmediate::isZero() const noexcept {
-  return std::ranges::all_of(Words, [](std::uint64_t Word) { return Word == 0; });
-}
-
-bool IntegerImmediate::isNegative() const noexcept {
-  const std::uint32_t SignBit = BitWidth - 1U;
-  return (Words[SignBit / 64U] & (std::uint64_t{1} << (SignBit % 64U))) != 0;
-}
-
-std::string IntegerImmediate::toUnsignedDecimal() const {
-  if (isZero())
-    return "0";
-  std::vector<std::uint64_t> Remaining = Words;
-  std::string Digits;
-  while (!std::ranges::all_of(Remaining, [](std::uint64_t Word) { return Word == 0; })) {
-    unsigned __int128 Remainder = 0;
-    for (auto Iterator = Remaining.rbegin(); Iterator != Remaining.rend(); ++Iterator) {
-      const unsigned __int128 Dividend = (Remainder << 64U) | *Iterator;
-      *Iterator = static_cast<std::uint64_t>(Dividend / 10U);
-      Remainder = Dividend % 10U;
-    }
-    Digits.push_back(static_cast<char>('0' + static_cast<unsigned>(Remainder)));
-  }
-  std::ranges::reverse(Digits);
-  return Digits;
-}
-
-std::string IntegerImmediate::toSignedDecimal() const {
-  if (!isNegative())
-    return toUnsignedDecimal();
-
-  std::vector<std::uint64_t> Magnitude = Words;
-  for (std::uint64_t &Word : Magnitude)
-    Word = ~Word;
-  std::uint64_t Carry = 1;
-  for (std::uint64_t &Word : Magnitude) {
-    const std::uint64_t Previous = Word;
-    Word += Carry;
-    Carry = Carry != 0 && Word < Previous ? 1 : 0;
-  }
-  Magnitude.back() &= integerHighWordMask(BitWidth);
-
-  std::string Digits;
-  while (!std::ranges::all_of(Magnitude, [](std::uint64_t Word) { return Word == 0; })) {
-    unsigned __int128 Remainder = 0;
-    for (auto Iterator = Magnitude.rbegin(); Iterator != Magnitude.rend(); ++Iterator) {
-      const unsigned __int128 Dividend = (Remainder << 64U) | *Iterator;
-      *Iterator = static_cast<std::uint64_t>(Dividend / 10U);
-      Remainder = Dividend % 10U;
-    }
-    Digits.push_back(static_cast<char>('0' + static_cast<unsigned>(Remainder)));
-  }
-  std::ranges::reverse(Digits);
-  Digits.insert(Digits.begin(), '-');
-  return Digits;
-}
-
-Expected<void> IntegerImmediate::verify() const {
-  return verifyIntegerImmediate(BitWidth, Words, ErrorCode::VerificationError);
-}
-
-Expected<FloatingPointBits> FloatingPointBits::create(FloatSemantics Semantics,
-                                                      std::span<const std::uint64_t> Words) {
-  const auto BitWidth = getFloatSemanticsBitWidth(Semantics);
-  if (!BitWidth) {
-    return makeUnexpected(ErrorCode::InvalidArgument, "floating immediate has unknown semantics");
-  }
-
-  const std::size_t RequiredWords = (*BitWidth + 63U) / 64U;
-  if (RequiredWords > 2 || Words.size() != RequiredWords) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "floating immediate bit pattern has the wrong word count");
-  }
-
-  const std::uint32_t UsedBitsInLastWord = *BitWidth % 64U;
-  if (UsedBitsInLastWord != 0 && (Words.back() >> UsedBitsInLastWord) != 0) {
-    return makeUnexpected(ErrorCode::InvalidArgument,
-                          "floating immediate has nonzero bits above its semantics width");
-  }
-
-  std::array<std::uint64_t, 2> StoredWords{};
-  std::ranges::copy(Words, StoredWords.begin());
-  return FloatingPointBits(Semantics, StoredWords, static_cast<std::uint8_t>(RequiredWords));
-}
 
 RegisterOperandFlags::RegisterOperandFlags(
     std::initializer_list<RegisterOperandFlag> Flags) noexcept {
@@ -296,13 +88,12 @@ MachineOperand MachineOperand::immediate(std::int64_t Value, std::uint32_t Targe
   return MachineOperand(Kind::Immediate, Value, TargetFlags);
 }
 
-MachineOperand MachineOperand::integerImmediate(IntegerImmediate Value, std::uint32_t TargetFlags) {
+MachineOperand MachineOperand::integerImmediate(APInt Value, std::uint32_t TargetFlags) {
   return MachineOperand(Kind::IntegerImmediate, IntegerImmediateOperand{std::move(Value)},
                         TargetFlags);
 }
 
-MachineOperand MachineOperand::floatingImmediate(FloatingPointBits Bits,
-                                                 std::uint32_t TargetFlags) {
+MachineOperand MachineOperand::floatingImmediate(APFloat Bits, std::uint32_t TargetFlags) {
   return MachineOperand(Kind::FloatingImmediate, FloatingImmediateOperand{Bits}, TargetFlags);
 }