Move from union to variant

Signed-off-by: Arvind Sudarsanam <[email protected]>

Author: asudarsa

llvm/include/llvm/Support/Base64.h

@@ -59,7 +59,7 @@ llvm::Error decodeBase64(llvm::StringRef Input, std::vector<char> &Output);
 // General-purpose Base64 encoder/decoder class wrapper.
 class Base64 {
 public:
-  using byte = uint8_t;
+  using byte = std::byte;
 
   // Get the size of the encoded byte sequence of given size.
   static size_t getEncodedSize(size_t SrcSize);

llvm/include/llvm/Support/PropertySetIO.h

@@ -40,6 +40,7 @@
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/xxhash.h"
+#include <variant>
 
 namespace llvm {
 namespace util {
@@ -52,7 +53,7 @@ class PropertyValue {
   // value data in some cases for later reading at runtime, so size_t is not
   // suitable as its size varies.
   using SizeTy = uint64_t;
-  using byte = uint8_t;
+  using byte = std::byte;
 
   // Defines supported property types
   enum Type { first = 0, NONE = first, UINT32, BYTE_ARRAY, last = BYTE_ARRAY };
@@ -68,8 +69,10 @@ class PropertyValue {
   }
 
   ~PropertyValue() {
-    if ((getType() == BYTE_ARRAY) && Val.ByteArrayVal)
-      delete[] Val.ByteArrayVal;
+    if (std::holds_alternative<byte *>(Val)) {
+      byte *ByteArrayVal = std::get<byte *>(Val);
+      delete ByteArrayVal;
+    }
   }
 
   PropertyValue() = default;
@@ -95,7 +98,7 @@ class PropertyValue {
   uint32_t asUint32() const {
     if (Ty != UINT32)
       llvm_unreachable("must be UINT32 value");
-    return Val.UInt32Val;
+    return std::get<uint32_t>(Val);
   }
 
   // Get raw data size in bits.
@@ -104,8 +107,10 @@ class PropertyValue {
       llvm_unreachable("must be BYTE_ARRAY value");
     SizeTy Res = 0;
 
-    for (size_t I = 0; I < sizeof(SizeTy); ++I)
-      Res |= (SizeTy)Val.ByteArrayVal[I] << (8 * I);
+    for (size_t I = 0; I < sizeof(SizeTy); ++I) {
+      auto ByteArrayVal = std::get<byte *>(Val);
+      Res |= (SizeTy)ByteArrayVal[I] << (8 * I);
+    }
     return Res;
   }
 
@@ -126,14 +131,17 @@ class PropertyValue {
   const byte *asRawByteArray() const {
     if (Ty != BYTE_ARRAY)
       llvm_unreachable("must be BYTE_ARRAY value");
-    return Val.ByteArrayVal;
+    auto &ByteArrayVal = std::get<byte *>(Val);
+    return ByteArrayVal;
   }
 
   // Get byte array data excluding the leading bytes encoding the size.
   const byte *asByteArray() const {
     if (Ty != BYTE_ARRAY)
       llvm_unreachable("must be BYTE_ARRAY value");
-    return Val.ByteArrayVal + sizeof(SizeTy);
+
+    auto ByteArrayVal = std::get<byte *>(Val);
+    return ByteArrayVal + sizeof(SizeTy);
   }
 
   bool isValid() const { return getType() != NONE; }
@@ -150,7 +158,7 @@ class PropertyValue {
   SizeTy size() const {
     switch (Ty) {
     case UINT32:
-      return sizeof(Val.UInt32Val);
+      return sizeof(std::get<uint32_t>(Val));
     case BYTE_ARRAY:
       return getRawByteArraySize();
     default:
@@ -163,12 +171,7 @@ class PropertyValue {
   void copy(const PropertyValue &P);
 
   Type Ty = NONE;
-  // TODO: replace this union with std::variant when uplifting to C++17
-  union {
-    uint32_t UInt32Val;
-    // Holds first sizeof(size_t) bytes of size followed by actual raw data.
-    byte *ByteArrayVal;
-  } Val;
+  std::variant<uint32_t, byte *> Val;
 };
 
 /// Structure for specialization of DenseMap in PropertySetRegistry.

llvm/lib/Support/PropertySetIO.cpp

@@ -22,7 +22,7 @@ using namespace llvm;
 
 namespace {
 
-using byte = Base64::byte;
+using byte = std::byte;
 
 ::llvm::Error makeError(const Twine &Msg) {
   return createStringError(std::error_code{}, Msg);
@@ -135,11 +135,12 @@ namespace llvm {
 namespace util {
 
 template <> uint32_t &PropertyValue::getValueRef<uint32_t>() {
-  return Val.UInt32Val;
+  return std::get<uint32_t>(Val);
 }
 
 template <> byte *&PropertyValue::getValueRef<byte *>() {
-  return Val.ByteArrayVal;
+  auto &ByteArrayVal = std::get<byte *>(Val);
+  return ByteArrayVal;
 }
 
 template <> PropertyValue::Type PropertyValue::getTypeTag<uint32_t>() {
@@ -157,15 +158,17 @@ PropertyValue::PropertyValue(const byte *Data, SizeTy DataBitSize) {
   constexpr size_t SizeFieldSize = sizeof(SizeTy);
 
   // Allocate space for size and data.
-  Val.ByteArrayVal = new byte[SizeFieldSize + DataSize];
+  Val = new byte[SizeFieldSize + DataSize];
 
   // Write the size into first bytes.
   for (size_t I = 0; I < SizeFieldSize; ++I) {
-    Val.ByteArrayVal[I] = (byte)DataBitSize;
+    auto ByteArrayVal = std::get<byte *>(Val);
+    ByteArrayVal[I] = (byte)DataBitSize;
     DataBitSize >>= ByteSizeInBits;
   }
   // Append data.
-  std::memcpy(Val.ByteArrayVal + SizeFieldSize, Data, DataSize);
+  auto ByteArrayVal = std::get<byte *>(Val);
+  std::memcpy(ByteArrayVal + SizeFieldSize, Data, DataSize);
 }
 
 PropertyValue::PropertyValue(const PropertyValue &P) { *this = P; }
@@ -175,8 +178,10 @@ PropertyValue::PropertyValue(PropertyValue &&P) { *this = std::move(P); }
 PropertyValue &PropertyValue::operator=(PropertyValue &&P) {
   copy(P);
 
-  if (P.getType() == BYTE_ARRAY)
-    P.Val.ByteArrayVal = nullptr;
+  if (P.getType() == BYTE_ARRAY) {
+    auto &ByteArrayVal = std::get<byte *>(P.Val);
+    ByteArrayVal = nullptr;
+  }
   P.Ty = NONE;
   return *this;
 }