[CodeGen] Unify scalar low-level types

1 files changed, 42 insertions, 82 deletions

diff --git a/backend/lib/CodeGen/LowLevelType.cpp b/backend/lib/CodeGen/LowLevelType.cpp
index b50ea6b..50ee0e6 100644
--- a/backend/lib/CodeGen/LowLevelType.cpp
+++ b/backend/lib/CodeGen/LowLevelType.cpp
@@ -8,130 +8,99 @@
 namespace rcc {
 namespace {
 
-[[nodiscard]] LLT::Kind getVectorKind(LLT ElementType) noexcept {
+[[nodiscard]] LowLevelType::Kind getVectorKind(LowLevelType ElementType) noexcept {
   switch (ElementType.kind()) {
-  case LLT::Kind::AnyScalar:
-    return LLT::Kind::VectorAny;
-  case LLT::Kind::Integer:
-    return LLT::Kind::VectorInteger;
-  case LLT::Kind::Float:
-    return LLT::Kind::VectorFloat;
-  case LLT::Kind::Pointer:
-    return LLT::Kind::VectorPointer;
-  case LLT::Kind::Invalid:
-  case LLT::Kind::Token:
-  case LLT::Kind::VectorAny:
-  case LLT::Kind::VectorInteger:
-  case LLT::Kind::VectorFloat:
-  case LLT::Kind::VectorPointer:
-    return LLT::Kind::Invalid;
+  case LowLevelType::Kind::CategoryNeutralScalar:
+    return LowLevelType::Kind::Vector;
+  case LowLevelType::Kind::Pointer:
+    return LowLevelType::Kind::VectorPointer;
+  case LowLevelType::Kind::Invalid:
+  case LowLevelType::Kind::Token:
+  case LowLevelType::Kind::Vector:
+  case LowLevelType::Kind::VectorPointer:
+    return LowLevelType::Kind::Invalid;
   }
 
-  return LLT::Kind::Invalid;
+  return LowLevelType::Kind::Invalid;
 }
 
 } // namespace
 
-Expected<LLT> LLT::makeScalar(Kind TypeKind, std::uint64_t BitWidth) {
+Expected<LowLevelType> LowLevelType::makeCategoryNeutralScalar(std::uint64_t BitWidth) {
   if (BitWidth == 0 || BitWidth > MaxBitWidth) {
     return makeUnexpected(ErrorCode::InvalidArgument,
-                          "LLT bit width must be in the range [1, 65535]");
+                          "LowLevelType bit width must be in the range [1, 65535]");
   }
 
-  return LLT(encode(TypeKind, static_cast<std::uint32_t>(BitWidth), 0, 0, false));
+  return LowLevelType(
+      encode(Kind::CategoryNeutralScalar, static_cast<std::uint32_t>(BitWidth), 0, 0, false));
 }
 
-Expected<LLT> LLT::makeAnyScalar(std::uint64_t BitWidth) {
-  return makeScalar(Kind::AnyScalar, BitWidth);
-}
-
-Expected<LLT> LLT::makeInteger(std::uint64_t BitWidth) {
-  return makeScalar(Kind::Integer, BitWidth);
-}
-
-Expected<LLT> LLT::makeFloat(FloatSemantics Semantics) {
-  const auto BitWidth = getFloatSemanticsBitWidth(Semantics);
-  if (!BitWidth) {
-    return makeUnexpected(ErrorCode::InvalidArgument, "unknown floating-point semantics");
-  }
-
-  return LLT(encode(Kind::Float, *BitWidth, 0, static_cast<std::uint32_t>(Semantics), false));
-}
-
-Expected<LLT> LLT::makePointer(std::uint64_t AddressSpace, std::uint64_t BitWidth) {
+Expected<LowLevelType> LowLevelType::makePointer(std::uint64_t AddressSpace,
+                                                 std::uint64_t BitWidth) {
   if (BitWidth == 0 || BitWidth > MaxBitWidth) {
     return makeUnexpected(ErrorCode::InvalidArgument,
-                          "LLT pointer bit width must be in the range [1, 65535]");
+                          "LowLevelType pointer bit width must be in the range [1, 65535]");
   }
   if (AddressSpace > MaxAddressSpace) {
-    return makeUnexpected(ErrorCode::InvalidArgument, "LLT address space must fit in 24 bits");
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "LowLevelType address space must fit in 24 bits");
   }
 
-  return LLT(encode(Kind::Pointer, static_cast<std::uint32_t>(BitWidth), 0,
-                    static_cast<std::uint32_t>(AddressSpace), false));
+  return LowLevelType(encode(Kind::Pointer, static_cast<std::uint32_t>(BitWidth), 0,
+                             static_cast<std::uint32_t>(AddressSpace), false));
 }
 
-Expected<LLT> LLT::makeFixedVector(std::uint64_t ElementCount, LLT ElementType) {
+Expected<LowLevelType> LowLevelType::makeFixedVector(std::uint64_t ElementCount,
+                                                     LowLevelType ElementType) {
   return makeVector(ElementCount, false, ElementType);
 }
 
-Expected<LLT> LLT::makeScalableVector(std::uint64_t MinimumElementCount, LLT ElementType) {
+Expected<LowLevelType> LowLevelType::makeScalableVector(std::uint64_t MinimumElementCount,
+                                                        LowLevelType ElementType) {
   return makeVector(MinimumElementCount, true, ElementType);
 }
 
-Expected<LLT> LLT::makeVector(std::uint64_t ElementCount, bool IsScalable, LLT ElementType) {
+Expected<LowLevelType> LowLevelType::makeVector(std::uint64_t ElementCount, bool IsScalable,
+                                                LowLevelType ElementType) {
   if (ElementCount == 0 || ElementCount > MaxElementCount) {
     return makeUnexpected(ErrorCode::InvalidArgument,
-                          "LLT vector element count must be in the range [1, 65535]");
+                          "LowLevelType vector element count must be in the range [1, 65535]");
   }
   if (!IsScalable && ElementCount == 1) {
     return makeUnexpected(ErrorCode::InvalidArgument,
-                          "a fixed LLT vector must contain at least two elements");
+                          "a fixed LowLevelType vector must contain at least two elements");
   }
 
   const Kind VectorKind = getVectorKind(ElementType);
   if (VectorKind == Kind::Invalid) {
     return makeUnexpected(ErrorCode::InvalidArgument,
-                          "LLT vector elements must be non-vector value types");
+                          "LowLevelType vector elements must be non-vector value types");
   }
 
   std::uint32_t Auxiliary = 0;
   if (ElementType.isPointer())
     Auxiliary = *ElementType.addressSpace();
-  else if (ElementType.isFloat())
-    Auxiliary = static_cast<std::uint32_t>(*ElementType.floatSemantics());
 
-  return LLT(encode(VectorKind, ElementType.scalarBitWidth(),
-                    static_cast<std::uint32_t>(ElementCount), Auxiliary, IsScalable));
+  return LowLevelType(encode(VectorKind, ElementType.scalarBitWidth(),
+                             static_cast<std::uint32_t>(ElementCount), Auxiliary, IsScalable));
 }
 
-std::optional<std::uint32_t> LLT::addressSpace() const noexcept {
+std::optional<std::uint32_t> LowLevelType::addressSpace() const noexcept {
   if (!isPointerOrPointerVector())
     return std::nullopt;
   return auxiliaryValue();
 }
 
-std::optional<FloatSemantics> LLT::floatSemantics() const noexcept {
-  if (!isFloatOrFloatVector())
-    return std::nullopt;
-  return static_cast<FloatSemantics>(auxiliaryValue());
-}
-
-std::optional<LLT> LLT::scalarElementType() const noexcept {
+std::optional<LowLevelType> LowLevelType::scalarElementType() const noexcept {
   switch (kind()) {
-  case Kind::VectorAny:
-    return LLT(encode(Kind::AnyScalar, scalarBitWidth(), 0, 0, false));
-  case Kind::VectorInteger:
-    return LLT(encode(Kind::Integer, scalarBitWidth(), 0, 0, false));
-  case Kind::VectorFloat:
-    return LLT(encode(Kind::Float, scalarBitWidth(), 0, auxiliaryValue(), false));
+  case Kind::Vector:
+    return LowLevelType(encode(Kind::CategoryNeutralScalar, scalarBitWidth(), 0, 0, false));
   case Kind::VectorPointer:
-    return LLT(encode(Kind::Pointer, scalarBitWidth(), 0, auxiliaryValue(), false));
+    return LowLevelType(encode(Kind::Pointer, scalarBitWidth(), 0, auxiliaryValue(), false));
   case Kind::Invalid:
   case Kind::Token:
-  case Kind::AnyScalar:
-  case Kind::Integer:
-  case Kind::Float:
+  case Kind::CategoryNeutralScalar:
   case Kind::Pointer:
     return std::nullopt;
   }
@@ -139,7 +108,7 @@ std::optional<LLT> LLT::scalarElementType() const noexcept {
   return std::nullopt;
 }
 
-std::string LLT::toString() const {
+std::string LowLevelType::toString() const {
   if (!isValid())
     return "LLT_invalid";
   if (isToken())
@@ -147,19 +116,10 @@ std::string LLT::toString() const {
 
   std::string ScalarSpelling;
   switch (kind()) {
-  case Kind::AnyScalar:
-  case Kind::VectorAny:
+  case Kind::CategoryNeutralScalar:
+  case Kind::Vector:
     ScalarSpelling = "s" + std::to_string(scalarBitWidth());
     break;
-  case Kind::Integer:
-  case Kind::VectorInteger:
-    ScalarSpelling = "i" + std::to_string(scalarBitWidth());
-    break;
-  case Kind::Float:
-  case Kind::VectorFloat:
-    ScalarSpelling =
-        std::string(getFloatSemanticsSpelling(static_cast<FloatSemantics>(auxiliaryValue())));
-    break;
   case Kind::Pointer:
   case Kind::VectorPointer:
     ScalarSpelling =