[Support] Split APInt and APFloat ownership

5 files changed, 23 insertions, 118 deletions

diff --git a/backend/include/rcc/CodeGen/GenericConstant.h b/backend/include/rcc/CodeGen/GenericConstant.h
index 92a8f13..4219c24 100644
--- a/backend/include/rcc/CodeGen/GenericConstant.h
+++ b/backend/include/rcc/CodeGen/GenericConstant.h
@@ -3,8 +3,9 @@
 #ifndef RCC_CODEGEN_GENERICCONSTANT_H
 #define RCC_CODEGEN_GENERICCONSTANT_H
 
+#include "rcc/ADT/APFloat.h"
+#include "rcc/ADT/APInt.h"
 #include "rcc/CodeGen/LowLevelType.h"
-#include "rcc/CodeGen/MachineOperand.h"
 #include "rcc/Support/Error.h"
 
 #include <cstddef>
@@ -144,8 +145,8 @@ private:
 struct GenericConstantData final {
   GenericConstantType Type;
   GenericConstantKind Kind = GenericConstantKind::Invalid;
-  std::optional<IntegerImmediate> IntegerValue;
-  std::optional<FloatingPointBits> FloatingValue;
+  std::optional<APInt> IntegerValue;
+  std::optional<APFloat> FloatingValue;
   std::vector<std::byte> ByteValue;
   std::vector<GenericConstantData> Elements;
   std::string Symbol;
@@ -155,11 +156,11 @@ struct GenericConstantData final {
   GenericConstantExpressionOpcode ExpressionOpcode = GenericConstantExpressionOpcode::Invalid;
   GenericConstantExpressionFlags ExpressionFlags;
   std::optional<GenericConstantType> SourceElementType;
-  std::optional<IntegerImmediate> InRangeStart;
-  std::optional<IntegerImmediate> InRangeEnd;
+  std::optional<APInt> InRangeStart;
+  std::optional<APInt> InRangeEnd;
 
-  [[nodiscard]] static Expected<GenericConstantData> integer(IntegerImmediate Value);
-  [[nodiscard]] static Expected<GenericConstantData> floating(FloatingPointBits Value);
+  [[nodiscard]] static Expected<GenericConstantData> integer(APInt Value);
+  [[nodiscard]] static Expected<GenericConstantData> floating(APFloat Value);
   [[nodiscard]] static Expected<GenericConstantData> byteString(GenericConstantType Type,
                                                                 std::vector<std::byte> Bytes);
 
diff --git a/backend/include/rcc/CodeGen/GlobalObject.h b/backend/include/rcc/CodeGen/GlobalObject.h
index 49f1f42..798dcd8 100644
--- a/backend/include/rcc/CodeGen/GlobalObject.h
+++ b/backend/include/rcc/CodeGen/GlobalObject.h
@@ -82,8 +82,8 @@ public:
   GlobalInitializer &operator=(GlobalInitializer &&) noexcept = default;
   ~GlobalInitializer() = default;
 
-  [[nodiscard]] static GlobalInitializer integer(IntegerImmediate Value);
-  [[nodiscard]] static GlobalInitializer floating(FloatingPointBits Value);
+  [[nodiscard]] static GlobalInitializer integer(APInt Value);
+  [[nodiscard]] static GlobalInitializer floating(APFloat Value);
   [[nodiscard]] static Expected<GlobalInitializer> bytes(std::vector<std::byte> Value);
   [[nodiscard]] static Expected<GlobalInitializer> zeroFill(std::uint64_t Size);
   [[nodiscard]] static Expected<GlobalInitializer> repeated(std::uint64_t Count,
@@ -108,10 +108,10 @@ public:
 
 private:
   using StorageT =
-      std::variant<std::monostate, IntegerImmediate, FloatingPointBits, std::vector<std::byte>,
-                   GlobalZeroFill, GlobalRepeatedInitializer, GlobalAggregateInitializer,
-                   GlobalSymbolAddress, GlobalSymbolDifference, TargetConstant,
-                   GlobalAlignmentPadding, GlobalUndefinedStorage>;
+      std::variant<std::monostate, APInt, APFloat, std::vector<std::byte>, GlobalZeroFill,
+                   GlobalRepeatedInitializer, GlobalAggregateInitializer, GlobalSymbolAddress,
+                   GlobalSymbolDifference, TargetConstant, GlobalAlignmentPadding,
+                   GlobalUndefinedStorage>;
 
   explicit GlobalInitializer(StorageT Storage) : Storage(std::move(Storage)) {}
 
diff --git a/backend/include/rcc/CodeGen/LowLevelType.h b/backend/include/rcc/CodeGen/LowLevelType.h
index 116ffd5..e6ff174 100644
--- a/backend/include/rcc/CodeGen/LowLevelType.h
+++ b/backend/include/rcc/CodeGen/LowLevelType.h
@@ -3,6 +3,7 @@
 #ifndef RCC_CODEGEN_LOWLEVELTYPE_H
 #define RCC_CODEGEN_LOWLEVELTYPE_H
 
+#include "rcc/ADT/APFloat.h"
 #include "rcc/Support/Error.h"
 
 #include <cstddef>
@@ -15,35 +16,6 @@
 
 namespace rcc {
 
-enum class FloatSemantics : std::uint8_t {
-  IEEEHalf,
-  BFloat,
-  IEEESingle,
-  IEEEDouble,
-  IEEEQuad,
-  PPCDoubleDouble,
-  Float8E5M2,
-  Float8E5M2FNUZ,
-  Float8E4M3,
-  Float8E4M3FN,
-  Float8E4M3FNUZ,
-  Float8E4M3B11FNUZ,
-  Float8E3M4,
-  FloatTF32,
-  Float8E8M0FNU,
-  Float6E3M2FN,
-  Float6E2M3FN,
-  Float4E2M1FN,
-  X87DoubleExtended,
-  Count,
-};
-
-[[nodiscard]] bool isKnownFloatSemantics(FloatSemantics Semantics) noexcept;
-[[nodiscard]] std::optional<std::uint32_t>
-getFloatSemanticsBitWidth(FloatSemantics Semantics) noexcept;
-[[nodiscard]] std::string_view getFloatSemanticsName(FloatSemantics Semantics) noexcept;
-[[nodiscard]] std::string_view getFloatSemanticsSpelling(FloatSemantics Semantics) noexcept;
-
 class LLT final {
 public:
   enum class Kind : std::uint8_t {
diff --git a/backend/include/rcc/CodeGen/MachineIRBuilder.h b/backend/include/rcc/CodeGen/MachineIRBuilder.h
index 2524c7a..b8ff248 100644
--- a/backend/include/rcc/CodeGen/MachineIRBuilder.h
+++ b/backend/include/rcc/CodeGen/MachineIRBuilder.h
@@ -52,10 +52,8 @@ public:
                                               std::uint32_t TargetFlags = 0);
 
   [[nodiscard]] Expected<void> addImmediate(std::int64_t Value, std::uint32_t TargetFlags = 0);
-  [[nodiscard]] Expected<void> addIntegerImmediate(IntegerImmediate Value,
-                                                   std::uint32_t TargetFlags = 0);
-  [[nodiscard]] Expected<void> addFloatingImmediate(FloatingPointBits Bits,
-                                                    std::uint32_t TargetFlags = 0);
+  [[nodiscard]] Expected<void> addIntegerImmediate(APInt Value, std::uint32_t TargetFlags = 0);
+  [[nodiscard]] Expected<void> addFloatingImmediate(APFloat Bits, std::uint32_t TargetFlags = 0);
   [[nodiscard]] Expected<void> addBasicBlock(MachineBasicBlock &Block,
                                              std::uint32_t TargetFlags = 0);
   [[nodiscard]] Expected<void> addFrameIndex(FrameIndex Index, std::int64_t Offset = 0,
diff --git a/backend/include/rcc/CodeGen/MachineOperand.h b/backend/include/rcc/CodeGen/MachineOperand.h
index a7feafa..ef14638 100644
--- a/backend/include/rcc/CodeGen/MachineOperand.h
+++ b/backend/include/rcc/CodeGen/MachineOperand.h
@@ -3,6 +3,8 @@
 #ifndef RCC_CODEGEN_MACHINEOPERAND_H
 #define RCC_CODEGEN_MACHINEOPERAND_H
 
+#include "rcc/ADT/APFloat.h"
+#include "rcc/ADT/APInt.h"
 #include "rcc/CodeGen/LowLevelType.h"
 #include "rcc/CodeGen/MachineDebugInfo.h"
 #include "rcc/CodeGen/MachineIRTypes.h"
@@ -10,7 +12,6 @@
 #include "rcc/CodeGen/RegisterMask.h"
 #include "rcc/Support/Error.h"
 
-#include <array>
 #include <cstddef>
 #include <cstdint>
 #include <initializer_list>
@@ -30,72 +31,6 @@ class MachineInstr;
 class MachineRegisterInfo;
 class RegOperandIterator;
 
-class FloatingPointBits final {
-public:
-  [[nodiscard]] static Expected<FloatingPointBits> create(FloatSemantics Semantics,
-                                                          std::span<const std::uint64_t> Words);
-
-  [[nodiscard]] FloatSemantics semantics() const noexcept {
-    return Semantics;
-  }
-
-  [[nodiscard]] std::uint32_t bitWidth() const noexcept {
-    return getFloatSemanticsBitWidth(Semantics).value_or(0);
-  }
-
-  [[nodiscard]] std::span<const std::uint64_t> words() const noexcept {
-    return std::span(Words).first(WordCount);
-  }
-
-  friend bool operator==(const FloatingPointBits &Left, const FloatingPointBits &Right) = default;
-
-private:
-  FloatingPointBits(FloatSemantics Semantics, std::array<std::uint64_t, 2> Words,
-                    std::uint8_t WordCount) noexcept
-      : Semantics(Semantics), Words(Words), WordCount(WordCount) {}
-
-  FloatSemantics Semantics;
-  std::array<std::uint64_t, 2> Words;
-  std::uint8_t WordCount;
-};
-
-class IntegerImmediate final {
-public:
-  static constexpr std::uint32_t MaxBitWidth = std::uint32_t{1} << 23U;
-
-  [[nodiscard]] static Expected<IntegerImmediate> create(std::uint32_t BitWidth,
-                                                         std::span<const std::uint64_t> Words);
-  [[nodiscard]] static Expected<IntegerImmediate> fromUnsigned(std::uint32_t BitWidth,
-                                                               std::uint64_t Value);
-  [[nodiscard]] static Expected<IntegerImmediate> fromSigned(std::uint32_t BitWidth,
-                                                             std::int64_t Value);
-  [[nodiscard]] static Expected<IntegerImmediate> parseDecimal(std::uint32_t BitWidth,
-                                                               std::string_view Text);
-
-  [[nodiscard]] std::uint32_t bitWidth() const noexcept {
-    return BitWidth;
-  }
-
-  [[nodiscard]] std::span<const std::uint64_t> words() const noexcept {
-    return Words;
-  }
-
-  [[nodiscard]] bool isZero() const noexcept;
-  [[nodiscard]] bool isNegative() const noexcept;
-  [[nodiscard]] std::string toUnsignedDecimal() const;
-  [[nodiscard]] std::string toSignedDecimal() const;
-  [[nodiscard]] Expected<void> verify() const;
-
-  friend bool operator==(const IntegerImmediate &Left, const IntegerImmediate &Right) = default;
-
-private:
-  IntegerImmediate(std::uint32_t BitWidth, std::vector<std::uint64_t> Words)
-      : BitWidth(BitWidth), Words(std::move(Words)) {}
-
-  std::uint32_t BitWidth;
-  std::vector<std::uint64_t> Words;
-};
-
 enum class RegisterOperandFlag : std::uint8_t {
   Define,
   Use,
@@ -147,14 +82,14 @@ private:
 };
 
 struct FloatingImmediateOperand final {
-  FloatingPointBits Bits;
+  APFloat Bits;
 
   friend bool operator==(const FloatingImmediateOperand &Left,
                          const FloatingImmediateOperand &Right) = default;
 };
 
 struct IntegerImmediateOperand final {
-  IntegerImmediate Value;
+  APInt Value;
 
   friend bool operator==(const IntegerImmediateOperand &Left,
                          const IntegerImmediateOperand &Right) = default;
@@ -382,9 +317,8 @@ public:
                                                                 SubRegIndex SubReg = {},
                                                                 std::uint32_t TargetFlags = 0);
   [[nodiscard]] static MachineOperand immediate(std::int64_t Value, std::uint32_t TargetFlags = 0);
-  [[nodiscard]] static MachineOperand integerImmediate(IntegerImmediate Value,
-                                                       std::uint32_t TargetFlags = 0);
-  [[nodiscard]] static MachineOperand floatingImmediate(FloatingPointBits Bits,
+  [[nodiscard]] static MachineOperand integerImmediate(APInt Value, std::uint32_t TargetFlags = 0);
+  [[nodiscard]] static MachineOperand floatingImmediate(APFloat Bits,
                                                         std::uint32_t TargetFlags = 0);
   [[nodiscard]] static MachineOperand basicBlock(MachineBasicBlock &Block,
                                                  std::uint32_t TargetFlags = 0);