Remove changes to Base64 implementation and use existing implementation

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

Author: asudarsa

llvm/include/llvm/Support/Base64.h

@@ -56,32 +56,6 @@ template <class InputBytes> std::string encodeBase64(InputBytes const &Bytes) {
 
 llvm::Error decodeBase64(llvm::StringRef Input, std::vector<char> &Output);
 
-// General-purpose Base64 encoder/decoder class wrapper.
-class Base64 {
-public:
-  using byte = std::byte;
-
-  // Get the size of the encoded byte sequence of given size.
-  static size_t getEncodedSize(size_t SrcSize);
-
-  // Encode a byte sequence of given size into an output stream.
-  // Returns the number of bytes in the encoded result.
-  static size_t encode(const byte *Src, raw_ostream &Out, size_t SrcSize);
-
-  // Get the size of the encoded byte sequence of given size.
-  static size_t getDecodedSize(size_t SrcSize);
-
-  // Decode a sequence of given size into a pre-allocated memory.
-  // Returns the number of bytes in the decoded result or 0 in case of error.
-  static Expected<size_t> decode(const char *Src, byte *Dst, size_t SrcSize);
-
-  // Allocate minimum required amount of memory and decode a sequence of given
-  // size into it.
-  // Returns the decoded result. The size can be obtained via getDecodedSize.
-  static Expected<std::unique_ptr<byte[]>> decode(const char *Src,
-                                                  size_t SrcSize);
-};
-
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Support/PropertySetIO.h

@@ -52,7 +52,6 @@ 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 = std::byte;
 
   // Defines supported property types
   enum Type { first = 0, NONE = first, UINT32, BYTE_ARRAY, last = BYTE_ARRAY };
@@ -67,24 +66,19 @@ class PropertyValue {
     return static_cast<Type>(T);
   }
 
-  ~PropertyValue() {
-    if (std::holds_alternative<byte *>(Val)) {
-      byte *ByteArrayVal = std::get<byte *>(Val);
-      delete ByteArrayVal;
-    }
-  }
+  ~PropertyValue() {}
 
   PropertyValue() = default;
   PropertyValue(Type T) : Ty(T) {}
 
   PropertyValue(uint32_t Val) : Ty(UINT32), Val({Val}) {}
-  PropertyValue(const byte *Data, SizeTy DataBitSize);
+  PropertyValue(const std::byte *Data, SizeTy DataBitSize);
   template <typename C, typename T = typename C::value_type>
   PropertyValue(const C &Data)
-      : PropertyValue(reinterpret_cast<const byte *>(Data.data()),
+      : PropertyValue(reinterpret_cast<const std::byte *>(Data.data()),
                       Data.size() * sizeof(T) * CHAR_BIT) {}
   PropertyValue(const llvm::StringRef &Str)
-      : PropertyValue(reinterpret_cast<const byte *>(Str.data()),
+      : PropertyValue(reinterpret_cast<const std::byte *>(Str.data()),
                       Str.size() * sizeof(char) * /* bits in one byte */ 8) {}
   PropertyValue(const PropertyValue &P);
   PropertyValue(PropertyValue &&P);
@@ -107,7 +101,7 @@ class PropertyValue {
     SizeTy Res = 0;
 
     for (size_t I = 0; I < sizeof(SizeTy); ++I) {
-      auto ByteArrayVal = std::get<byte *>(Val);
+      auto ByteArrayVal = std::get<std::byte *>(Val);
       Res |= (SizeTy)ByteArrayVal[I] << (8 * I);
     }
     return Res;
@@ -127,31 +121,51 @@ class PropertyValue {
   }
 
   // Get byte array data including the leading bytes encoding the size.
-  const byte *asRawByteArray() const {
+  const std::byte *asRawByteArray() const {
     if (Ty != BYTE_ARRAY)
       llvm_unreachable("must be BYTE_ARRAY value");
-    auto *ByteArrayVal = std::get<byte *>(Val);
+    auto *ByteArrayVal = std::get<std::byte *>(Val);
     return ByteArrayVal;
   }
 
   // Get byte array data excluding the leading bytes encoding the size.
-  const byte *asByteArray() const {
+  const std::byte *asByteArray() const {
     if (Ty != BYTE_ARRAY)
       llvm_unreachable("must be BYTE_ARRAY value");
 
-    auto ByteArrayVal = std::get<byte *>(Val);
+    auto ByteArrayVal = std::get<std::byte *>(Val);
     return ByteArrayVal + sizeof(SizeTy);
   }
 
   bool isValid() const { return getType() != NONE; }
 
   // Set property value; the 'T' type must be convertible to a property type tag
-  template <typename T> void set(T V) {
-    if (getTypeTag<T>() != Ty)
+  void set(uint32_t V) {
+    if (Ty != UINT32)
       llvm_unreachable("invalid type tag for this operation");
     Val = V;
   }
 
+  // Set property value; the 'T' type must be convertible to a property type tag
+  void set(std::byte *V, int DataSize) {
+    if (Ty != BYTE_ARRAY)
+      llvm_unreachable("invalid type tag for this operation");
+    size_t DataBitSize = DataSize * CHAR_BIT;
+    constexpr size_t SizeFieldSize = sizeof(SizeTy);
+    // Allocate space for size and data.
+    Val = new std::byte[SizeFieldSize + DataSize];
+
+    // Write the size into first bytes.
+    for (size_t I = 0; I < SizeFieldSize; ++I) {
+      auto ByteArrayVal = std::get<std::byte *>(Val);
+      ByteArrayVal[I] = (std::byte)DataBitSize;
+      DataBitSize >>= CHAR_BIT;
+    }
+    // Append data.
+    auto ByteArrayVal = std::get<std::byte *>(Val);
+    std::memcpy(ByteArrayVal + SizeFieldSize, V, DataSize);
+  }
+
   Type getType() const { return Ty; }
 
   SizeTy size() const {
@@ -169,7 +183,7 @@ class PropertyValue {
   void copy(const PropertyValue &P);
 
   Type Ty = NONE;
-  std::variant<uint32_t, byte *> Val;
+  std::variant<uint32_t, std::byte *> Val;
 };
 
 /// Structure for specialization of DenseMap in PropertySetRegistry.

llvm/lib/Support/Base64.cpp

@@ -90,180 +90,3 @@ llvm::Error llvm::decodeBase64(llvm::StringRef Input,
   }
   return Error::success();
 }
-
-using namespace llvm;
-
-namespace {
-
-using byte = std::byte;
-
-::llvm::Error makeError(const Twine &Msg) {
-  return createStringError(std::error_code{}, Msg);
-}
-
-class Base64Impl {
-private:
-  static constexpr char EncodingTable[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                          "abcdefghijklmnopqrstuvwxyz"
-                                          "0123456789+/";
-
-  static_assert(sizeof(EncodingTable) == 65, "");
-
-  // Compose an index into the encoder table from two bytes and the number of
-  // significant bits in the lower byte until the byte boundary.
-  static inline int composeInd(byte ByteLo, byte ByteHi, int BitsLo) {
-    int Res = (int)((ByteHi << BitsLo) | (ByteLo >> (8 - BitsLo))) & 0x3F;
-    return Res;
-  }
-
-  // Decode a single character.
-  static inline int decode(char Ch) {
-    if (Ch >= 'A' && Ch <= 'Z') // 0..25
-      return Ch - 'A';
-    if (Ch >= 'a' && Ch <= 'z') // 26..51
-      return Ch - 'a' + 26;
-    if (Ch >= '0' && Ch <= '9') // 52..61
-      return Ch - '0' + 52;
-    if (Ch == '+') // 62
-      return 62;
-    if (Ch == '/') // 63
-      return 63;
-    return -1;
-  }
-
-  // Decode a quadruple of characters.
-  static inline Expected<bool> decode4(const char *Src, byte *Dst) {
-    int BadCh = -1;
-
-    for (auto I = 0; I < 4; ++I) {
-      char Ch = Src[I];
-      int Byte = decode(Ch);
-
-      if (Byte < 0) {
-        BadCh = Ch;
-        break;
-      }
-      Dst[I] = (byte)Byte;
-    }
-    if (BadCh == -1)
-      return true;
-    return makeError("invalid char in Base64Impl encoding: 0x" + Twine(BadCh));
-  }
-
-public:
-  static size_t getEncodedSize(size_t SrcSize) {
-    constexpr int ByteSizeInBits = 8;
-    constexpr int EncBitsPerChar = 6;
-    return (SrcSize * ByteSizeInBits + (EncBitsPerChar - 1)) / EncBitsPerChar;
-  }
-
-  static size_t encode(const byte *Src, raw_ostream &Out, size_t SrcSize) {
-    size_t Off = 0;
-
-    // Encode full byte triples
-    for (size_t TriB = 0; TriB < SrcSize / 3; ++TriB) {
-      Off = TriB * 3;
-      byte Byte0 = Src[Off++];
-      byte Byte1 = Src[Off++];
-      byte Byte2 = Src[Off++];
-
-      Out << EncodingTable[(int)Byte0 & 0x3F];
-      Out << EncodingTable[composeInd(Byte0, Byte1, 2)];
-      Out << EncodingTable[composeInd(Byte1, Byte2, 4)];
-      Out << EncodingTable[(int)(Byte2 >> 2) & 0x3F];
-    }
-    // Encode the remainder
-    int RemBytes = SrcSize - Off;
-
-    if (RemBytes > 0) {
-      byte Byte0 = Src[Off + 0];
-      Out << EncodingTable[(int)Byte0 & 0x3F];
-
-      if (RemBytes > 1) {
-        byte Byte1 = Src[Off + 1];
-        Out << EncodingTable[composeInd(Byte0, Byte1, 2)];
-        Out << EncodingTable[(int)(Byte1 >> 4) & 0x3F];
-      } else {
-        Out << EncodingTable[(int)(Byte0 >> 6) & 0x3F];
-      }
-    }
-    return getEncodedSize(SrcSize);
-  }
-
-  static size_t getDecodedSize(size_t SrcSize) { return (SrcSize * 3 + 3) / 4; }
-
-  static Expected<size_t> decode(const char *Src, byte *Dst, size_t SrcSize) {
-    size_t SrcOff = 0;
-    size_t DstOff = 0;
-
-    // Decode full quads.
-    for (size_t Qch = 0; Qch < SrcSize / 4; ++Qch, SrcOff += 4, DstOff += 3) {
-      byte Ch[4];
-      Expected<bool> TrRes = decode4(Src + SrcOff, Ch);
-
-      if (!TrRes)
-        return TrRes.takeError();
-      // Each quad of chars produces three bytes of output.
-      Dst[DstOff + 0] = Ch[0] | (Ch[1] << 6);
-      Dst[DstOff + 1] = (Ch[1] >> 2) | (Ch[2] << 4);
-      Dst[DstOff + 2] = (Ch[2] >> 4) | (Ch[3] << 2);
-    }
-    auto RemChars = SrcSize - SrcOff;
-
-    if (RemChars == 0)
-      return DstOff;
-    // Decode the remainder; variants:
-    // 2 chars remain - produces single byte
-    // 3 chars remain - produces two bytes
-
-    if (RemChars != 2 && RemChars != 3)
-      return makeError("invalid encoded sequence length");
-
-    int Ch0 = decode(Src[SrcOff++]);
-    int Ch1 = decode(Src[SrcOff++]);
-    int Ch2 = RemChars == 3 ? decode(Src[SrcOff]) : 0;
-
-    if (Ch0 < 0 || Ch1 < 0 || Ch2 < 0)
-      return makeError("invalid characters in the encoded sequence remainder");
-    Dst[DstOff++] = (byte)Ch0 | (byte)((Ch1 << 6));
-
-    if (RemChars == 3)
-      Dst[DstOff++] = (byte)(Ch1 >> 2) | (byte)(Ch2 << 4);
-    return DstOff;
-  }
-
-  static Expected<std::unique_ptr<byte[]>> decode(const char *Src,
-                                                  size_t SrcSize) {
-    size_t DstSize = getDecodedSize(SrcSize);
-    std::unique_ptr<byte[]> Dst(new byte[DstSize]);
-    Expected<size_t> Res = decode(Src, Dst.get(), SrcSize);
-    if (!Res)
-      return Res.takeError();
-    return Expected<std::unique_ptr<byte[]>>(std::move(Dst));
-  }
-};
-
-constexpr char Base64Impl::EncodingTable[];
-
-} // anonymous namespace
-
-size_t Base64::getEncodedSize(size_t SrcSize) {
-  return Base64Impl::getEncodedSize(SrcSize);
-}
-
-size_t Base64::encode(const byte *Src, raw_ostream &Out, size_t SrcSize) {
-  return Base64Impl::encode(Src, Out, SrcSize);
-}
-
-size_t Base64::getDecodedSize(size_t SrcSize) {
-  return Base64Impl::getDecodedSize(SrcSize);
-}
-
-Expected<size_t> Base64::decode(const char *Src, byte *Dst, size_t SrcSize) {
-  return Base64Impl::decode(Src, Dst, SrcSize);
-}
-
-Expected<std::unique_ptr<byte[]>> Base64::decode(const char *Src,
-                                                 size_t SrcSize) {
-  return Base64Impl::decode(Src, SrcSize);
-}