[Support/Hash functions] Change the `final()` and `result()` of the hashing functions to return an array of bytes

[akyrtzi]

Summary

Returning std::array<uint8_t, N> is better ergonomics for the hashing functions usage, instead of a StringRef:

• When returning StringRef, client code is "jumping through hoops" to do string manipulations instead of dealing with array of bytes directly, which is more natural
• Returning std::array<uint8_t, N> avoids the need for the hasher classes to keep a field just for the purpose of wrapping it and returning it as a StringRef

As part of this patch also change the BLAKE3 class API to match HashBuilder's generic hash API.

[akyrtzi]

Adjust ASTFileSignature to accept only the array hash bytes and directly from the final() call.

[dexonsmith]

llvm/include/llvm/Support/BLAKE3.h

38

The visual noise of BLAKE3<> everywhere is a bit unfortunate.

Another option:

// Hardcoded to 32B. OR same implementation as before, with optional template
// parameters to choose a size when accessing the hash.
class BLAKE3 { /* ... */ };

// Wrap final(), result(), and hash() to truncate the hash.
template <size_t TruncatedNumBytes> class TruncatedBLAKE3 : public BLAKE3 { ... };

WDYT?

llvm/include/llvm/Support/MD5.h

82

Should this (and result() below) be MD5Result? It has an implicit cast to std::array<uint8_t, 16>. Maybe it's better as you have it... not sure...

llvm/lib/Support/SHA1.cpp

289

Should this be HASH_LENGTH instead of 20?

[akyrtzi]

• Move BLAKE3 back to templated sizes for final() and result() and add TruncatedBLAKE3 that has the size parameter on the class.
• Make MD5Result inherit from std::array<uint8_t, 16> which both simplifies its API and makes it a better fit for replacing StringRef.
• Use HASH_LENGTH in implementations of SHA1::final() and SHA256::final()

llvm/include/llvm/Support/BLAKE3.h

38

Good idea! I moved BLAKE3 back to templated sizes for final() and result() and added TruncatedBLAKE3 that has the size parameter on the class.
TruncatedBLAKE3 is useful for using BLAKE3 as the hasher type for HashBuilder with non-default hash sizes, otherwise one can use BLAKE3 for all other uses.

llvm/include/llvm/Support/MD5.h

82

I avoided MD5Result due to not being as good as std::array for a "drop-in replacement" for StringRef due to lack of data() and size().
But it occurred to me that MD5Result could just inherit from std::array<uint8_t, 16> which would make it better fit to replace StringRef and improves & simplifies its API, see updated patch.

llvm/lib/Support/SHA1.cpp

289

Updated 👍

[akyrtzi]

Also revert the README changes to the previous version of BLAKE3 class.

[Amir]

bolt/lib/Core/DebugData.cpp

823–824

I think it would be more in line with LLVM coding standards to expand auto in this case (and others) – see https://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable.
My understanding is that auto is fine where the type is obvious from the context (is explicitly available on the same line e.g. with casts), is abstract (T::iterator types), or doesn't matter (e.g. lambdas).

[jhenderson]

bolt/lib/Core/DebugData.cpp

823–824

+1 (also relevant in other places in this patch)

[akyrtzi]

Expand type instead of using auto

[akyrtzi]

bolt/lib/Core/DebugData.cpp

823–824

Updated 👍

[Amir]

BOLT changes LGTM

[dexonsmith]

LGTM!

bolt/lib/Core/DebugData.cpp

void DebugAbbrevWriter::addUnitAbbreviations(DWARFUnit &Unit) {
   UnitData.Stream = std::make_unique<raw_svector_ostream>(*UnitData.Buffer);
 
   raw_svector_ostream &OS = *UnitData.Stream.get();
 
   // Returns true if AbbrevData is re-used, false otherwise.
   auto hashAndAddAbbrev = [&](StringRef AbbrevData) -> bool {
     llvm::SHA1 Hasher;
     Hasher.update(AbbrevData);
-    StringRef Key = Hasher.final();
+    auto Hash = Hasher.final();
+    StringRef Key((const char *)Hash.data(), Hash.size());
     auto Iter = AbbrevDataCache.find(Key);
     if (Iter != AbbrevDataCache.end()) {
       UnitsAbbrevData[&Unit] = Iter->second.get();
       return true;
     }
     AbbrevDataCache[Key] = std::move(UnitDataPtr);
     UnitsAbbrevData[&Unit] = &UnitData;
     return false;

clang/include/clang/Basic/Module.h

struct ASTFileSignature : std::array<uint8_t, 20> {
   uint64_t truncatedValue() const {
     uint64_t Value = 0;
     static_assert(sizeof(*this) >= sizeof(uint64_t), "No need to truncate.");
     for (unsigned I = 0; I < sizeof(uint64_t); ++I)
       Value |= static_cast<uint64_t>((*this)[I]) << (I * 8);
     return Value;
   }
 
+  static ASTFileSignature create(std::array<uint8_t, 20> Bytes) {
+    return ASTFileSignature(std::move(Bytes));
+  }
+
   static ASTFileSignature create(StringRef Bytes) {
     return create(Bytes.bytes_begin(), Bytes.bytes_end());
   }
 
   static ASTFileSignature createDISentinel() {
     ASTFileSignature Sentinel;
     Sentinel.fill(0xFF);
     return Sentinel;

clang/lib/Serialization/ASTWriter.cpp

adjustFilenameForRelocatableAST(const char *Filename, StringRef BaseDir) {
   return Filename + Pos;
 }
 
 std::pair<ASTFileSignature, ASTFileSignature>
 ASTWriter::createSignature(StringRef AllBytes, StringRef ASTBlockBytes) {
   llvm::SHA1 Hasher;
   Hasher.update(ASTBlockBytes);
   auto Hash = Hasher.result();
-  ASTFileSignature ASTBlockHash = ASTFileSignature::create(Hash);
+  ASTFileSignature ASTBlockHash = ASTFileSignature::create(std::move(Hash));
 
   // Add the remaining bytes (i.e. bytes before the unhashed control block that
   // are not part of the AST block).
   Hasher.update(
       AllBytes.take_front(ASTBlockBytes.bytes_end() - AllBytes.bytes_begin()));
   Hasher.update(
       AllBytes.take_back(AllBytes.bytes_end() - ASTBlockBytes.bytes_end()));
   Hash = Hasher.result();
-  ASTFileSignature Signature = ASTFileSignature::create(Hash);
+  ASTFileSignature Signature = ASTFileSignature::create(std::move(Hash));
 
   return std::make_pair(ASTBlockHash, Signature);
 }
 
 ASTFileSignature ASTWriter::writeUnhashedControlBlock(Preprocessor &PP,
                                                       ASTContext &Context) {
   using namespace llvm;
 

lld/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::writeBuildId() {
   switch (config->buildId) {
   case BuildIdKind::Fast:
     computeHash(output, input, [](uint8_t *dest, ArrayRef<uint8_t> arr) {
       write64le(dest, xxHash64(arr));
     });
     break;
   case BuildIdKind::Md5:
     computeHash(output, input, [&](uint8_t *dest, ArrayRef<uint8_t> arr) {
-      memcpy(dest, BLAKE3::hash<16>(arr).data(), hashSize);
+      memcpy(dest, BLAKE3<16>::hash(arr).data(), hashSize);
     });
     break;
   case BuildIdKind::Sha1:
     computeHash(output, input, [&](uint8_t *dest, ArrayRef<uint8_t> arr) {
-      memcpy(dest, BLAKE3::hash<20>(arr).data(), hashSize);
+      memcpy(dest, BLAKE3<20>::hash(arr).data(), hashSize);
     });
     break;
   case BuildIdKind::Uuid:
     if (auto ec = llvm::getRandomBytes(buildId.get(), hashSize))
       error("entropy source failure: " + ec.message());
     break;
   default:
     llvm_unreachable("unknown BuildIdKind");

lld/MachO/SyntheticSections.cpp

void CodeSignatureSection::writeHashes(uint8_t *buf) const {
   uint8_t *code = buf;
   uint8_t *codeEnd = buf + fileOff;
   uint8_t *hashes = codeEnd + allHeadersSize;
   while (code < codeEnd) {
     StringRef block(reinterpret_cast<char *>(code),
                     std::min(codeEnd - code, static_cast<ssize_t>(blockSize)));
     SHA256 hasher;
     hasher.update(block);
-    StringRef hash = hasher.final();
+    auto hash = hasher.final();
     assert(hash.size() == hashSize);
     memcpy(hashes, hash.data(), hashSize);
     code += blockSize;
     hashes += hashSize;
   }
 #if defined(__APPLE__)
   // This is macOS-specific work-around and makes no sense for any
   // other host OS. See https://openradar.appspot.com/FB8914231

llvm/include/llvm/Support/BLAKE3.h

 /// additional security.
 ///
 /// Shorter BLAKE3 outputs are prefixes of longer ones. Explicitly
 /// requesting a short output is equivalent to truncating the default-length
 /// output.
 template <size_t NumBytes = LLVM_BLAKE3_OUT_LEN>
 using BLAKE3Result = std::array<uint8_t, NumBytes>;
 
-/// A class that wrap the BLAKE3 algorithm.
-class BLAKE3 {
+/// A class that wraps the BLAKE3 algorithm.
+template <size_t NumBytes = LLVM_BLAKE3_OUT_LEN> class BLAKE3 {
 public:
   BLAKE3() { init(); }
 
   /// Reinitialize the internal state
   void init() { llvm_blake3_hasher_init(&Hasher); }
 
   /// Digest more data.
   void update(ArrayRef<uint8_t> Data) {
     llvm_blake3_hasher_update(&Hasher, Data.data(), Data.size());
   }
 
   /// Digest more data.
   void update(StringRef Str) {
     llvm_blake3_hasher_update(&Hasher, Str.data(), Str.size());
   }
 
   /// Finalize the hasher and put the result in \p Result.
   /// This doesn't modify the hasher itself, and it's possible to finalize again
   /// after adding more input.
-  template <size_t NumBytes = LLVM_BLAKE3_OUT_LEN>
   void final(BLAKE3Result<NumBytes> &Result) {
     llvm_blake3_hasher_finalize(&Hasher, Result.data(), Result.size());
   }
 
   /// Finalize the hasher and return an output of any length, given in bytes.
   /// This doesn't modify the hasher itself, and it's possible to finalize again
   /// after adding more input.
-  template <size_t NumBytes = LLVM_BLAKE3_OUT_LEN>
   BLAKE3Result<NumBytes> final() {
     BLAKE3Result<NumBytes> Result;
     llvm_blake3_hasher_finalize(&Hasher, Result.data(), Result.size());
     return Result;
   }
 
+  /// Return the current output for the digested data since the last call to
+  /// init().
+  ///
+  /// Other hash functions distinguish between \p result() and \p final(), with
+  /// \p result() allowing more calls into \p update(), but there's no
+  // difference for the BLAKE3 function.
+  BLAKE3Result<NumBytes> result() { return final(); }
+
   /// Returns a BLAKE3 hash for the given data.
-  template <size_t NumBytes = LLVM_BLAKE3_OUT_LEN>
   static BLAKE3Result<NumBytes> hash(ArrayRef<uint8_t> Data) {
-    BLAKE3 Hasher;
+    BLAKE3<NumBytes> Hasher;
     Hasher.update(Data);
-    return Hasher.final<NumBytes>();
+    return Hasher.final();
   }
 
 private:
   llvm_blake3_hasher Hasher;
 };
 
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/HashBuilder.h

 struct IsHashableData
     : std::integral_constant<bool, is_integral_or_enum<U>::value> {};
 
 } // namespace hashbuilder_detail
 
 /// Declares the hasher member, and functions forwarding directly to the hasher.
 template <typename HasherT> class HashBuilderBase {
 public:
+  template <typename HasherT_ = HasherT>
+  using HashResultTy = decltype(std::declval<HasherT_ &>().final());
+
   HasherT &getHasher() { return Hasher; }
 
   /// Forward to `HasherT::update(ArrayRef<uint8_t>)`.
   ///
   /// This may not take the size of `Data` into account.
   /// Users of this function should pay attention to respect endianness
   /// contraints.
   void update(ArrayRef<uint8_t> Data) { this->getHasher().update(Data); }
 
   /// Forward to `HasherT::update(ArrayRef<uint8_t>)`.
   ///
   /// This may not take the size of `Data` into account.
   /// Users of this function should pay attention to respect endianness
   /// contraints.
   void update(StringRef Data) {
     update(makeArrayRef(reinterpret_cast<const uint8_t *>(Data.data()),
                         Data.size()));
   }
 
   /// Forward to `HasherT::final()` if available.
-  template <typename HasherT_ = HasherT> StringRef final() {
+  template <typename HasherT_ = HasherT> HashResultTy<HasherT_> final() {
     return this->getHasher().final();
   }
 
   /// Forward to `HasherT::result()` if available.
-  template <typename HasherT_ = HasherT> StringRef result() {
+  template <typename HasherT_ = HasherT> HashResultTy<HasherT_> result() {
     return this->getHasher().result();
   }
 
 protected:
   explicit HashBuilderBase(HasherT &Hasher) : Hasher(Hasher) {}
 
   template <typename... ArgTypes>
   explicit HashBuilderBase(ArgTypes &&...Args)

llvm/include/llvm/Support/MD5.h

public:
   void update(ArrayRef<uint8_t> Data);
 
   /// Updates the hash for the StringRef provided.
   void update(StringRef Str);
 
   /// Finishes off the hash and puts the result in result.
   void final(MD5Result &Result);
 
-  /// Finishes off the hash, and returns a reference to the 16-byte hash data.
-  StringRef final();
+  /// Finishes off the hash, and returns the 16-byte hash data.
+  std::array<uint8_t, 16> final();
 
-  /// Finishes off the hash, and returns a reference to the 16-byte hash data.
+  /// Finishes off the hash, and returns the 16-byte hash data.
   /// This is suitable for getting the MD5 at any time without invalidating the
   /// internal state, so that more calls can be made into `update`.
-  StringRef result();
+  std::array<uint8_t, 16> result();
 
   /// Translates the bytes in \p Res to a hex string that is
   /// deposited into \p Str. The result will be of length 32.
   static void stringifyResult(MD5Result &Result, SmallVectorImpl<char> &Str);
 
   /// Computes the hash for a given bytes.
   static std::array<uint8_t, 16> hash(ArrayRef<uint8_t> Data);
 
 private:
   // Any 32-bit or wider unsigned integer data type will do.
   typedef uint32_t MD5_u32plus;
 
   // Internal State
   struct {
     MD5_u32plus a = 0x67452301;
     MD5_u32plus b = 0xefcdab89;
     MD5_u32plus c = 0x98badcfe;
     MD5_u32plus d = 0x10325476;
     MD5_u32plus hi = 0;
     MD5_u32plus lo = 0;
     uint8_t buffer[64];
     MD5_u32plus block[16];
   } InternalState;
 
-  MD5Result Result;
-
   const uint8_t *body(ArrayRef<uint8_t> Data);
 };
 
 inline bool operator==(const MD5::MD5Result &LHS, const MD5::MD5Result &RHS) {
   return LHS.Bytes == RHS.Bytes;
 }
 
 /// Helper to compute and return lower 64 bits of the given string's MD5 hash.

llvm/include/llvm/Support/SHA1.h

public:
   void init();
 
   /// Digest more data.
   void update(ArrayRef<uint8_t> Data);
 
   /// Digest more data.
   void update(StringRef Str);
 
-  /// Return a reference to the current raw 160-bits SHA1 for the digested data
+  /// Return the current raw 160-bits SHA1 for the digested data
   /// since the last call to init(). This call will add data to the internal
   /// state and as such is not suited for getting an intermediate result
   /// (see result()).
-  StringRef final();
+  std::array<uint8_t, 20> final();
 
-  /// Return a reference to the current raw 160-bits SHA1 for the digested data
+  /// Return the current raw 160-bits SHA1 for the digested data
   /// since the last call to init(). This is suitable for getting the SHA1 at
   /// any time without invalidating the internal state so that more calls can be
   /// made into update.
-  StringRef result();
+  std::array<uint8_t, 20> result();
 
   /// Returns a raw 160-bit SHA1 hash for the given data.
   static std::array<uint8_t, 20> hash(ArrayRef<uint8_t> Data);
 
 private:
   /// Define some constants.
   /// "static constexpr" would be cleaner but MSVC does not support it yet.
   enum { BLOCK_LENGTH = 64 };
   enum { HASH_LENGTH = 20 };
 
   // Internal State
   struct {
     union {
       uint8_t C[BLOCK_LENGTH];
       uint32_t L[BLOCK_LENGTH / 4];
     } Buffer;
     uint32_t State[HASH_LENGTH / 4];
     uint32_t ByteCount;
     uint8_t BufferOffset;
   } InternalState;
 
-  // Internal copy of the hash, populated and accessed on calls to result()
-  uint32_t HashResult[HASH_LENGTH / 4];
-
   // Helper
   void writebyte(uint8_t data);
   void hashBlock();
   void addUncounted(uint8_t data);
   void pad();
+
+  void final(std::array<uint32_t, HASH_LENGTH / 4> &HashResult);
 };
 
 } // end llvm namespace
 
 #endif

llvm/include/llvm/Support/SHA256.h

public:
   void init();
 
   /// Digest more data.
   void update(ArrayRef<uint8_t> Data);
 
   /// Digest more data.
   void update(StringRef Str);
 
-  /// Return a reference to the current raw 256-bits SHA256 for the digested
+  /// Return the current raw 256-bits SHA256 for the digested
   /// data since the last call to init(). This call will add data to the
   /// internal state and as such is not suited for getting an intermediate
   /// result (see result()).
-  StringRef final();
+  std::array<uint8_t, 32> final();
 
-  /// Return a reference to the current raw 256-bits SHA256 for the digested
+  /// Return the current raw 256-bits SHA256 for the digested
   /// data since the last call to init(). This is suitable for getting the
   /// SHA256 at any time without invalidating the internal state so that more
   /// calls can be made into update.
-  StringRef result();
+  std::array<uint8_t, 32> result();
 
   /// Returns a raw 256-bit SHA256 hash for the given data.
   static std::array<uint8_t, 32> hash(ArrayRef<uint8_t> Data);
 
 private:
   /// Define some constants.
   /// "static constexpr" would be cleaner but MSVC does not support it yet.
   enum { BLOCK_LENGTH = 64 };
   enum { HASH_LENGTH = 32 };
 
   // Internal State
   struct {
     union {
       uint8_t C[BLOCK_LENGTH];
       uint32_t L[BLOCK_LENGTH / 4];
     } Buffer;
     uint32_t State[HASH_LENGTH / 4];
     uint32_t ByteCount;
     uint8_t BufferOffset;
   } InternalState;
 
-  // Internal copy of the hash, populated and accessed on calls to result()
-  uint32_t HashResult[HASH_LENGTH / 4];
-
   // Helper
   void writebyte(uint8_t data);
   void hashBlock();
   void addUncounted(uint8_t data);
   void pad();
+
+  void final(std::array<uint32_t, HASH_LENGTH / 4> &HashResult);
 };
 
 } // namespace llvm
 
 #endif // LLVM_SUPPORT_SHA256_H

llvm/include/llvm/Support/raw_sha1_ostream.h

class raw_sha1_ostream : public raw_ostream {
 
   /// See raw_ostream::write_impl.
   void write_impl(const char *Ptr, size_t Size) override {
     State.update(ArrayRef<uint8_t>((const uint8_t *)Ptr, Size));
   }
 
 public:
   /// Return the current SHA1 hash for the content of the stream
-  StringRef sha1() {
+  std::array<uint8_t, 20> sha1() {
     flush();
     return State.result();
   }
 
   /// Reset the internal state to start over from scratch.
   void resetHash() { State.init(); }
 
   uint64_t current_pos() const override { return 0; }
 };
 
 } // end llvm namespace
 
 #endif

llvm/lib/Bitcode/Reader/BitcodeAnalyzer.cpp

if (DumpRecords) {
       // If we found a module hash, let's verify that it matches!
       if (BlockID == bitc::MODULE_BLOCK_ID && Code == bitc::MODULE_CODE_HASH &&
           CheckHash.hasValue()) {
         if (Record.size() != 5)
           O->OS << " (invalid)";
         else {
           // Recompute the hash and compare it to the one in the bitcode
           SHA1 Hasher;
-          StringRef Hash;
+          std::array<uint8_t, 20> Hash;
           Hasher.update(*CheckHash);
           {
             int BlockSize = (CurrentRecordPos / 8) - BlockEntryPos;
             auto Ptr = Stream.getPointerToByte(BlockEntryPos, BlockSize);
             Hasher.update(ArrayRef<uint8_t>(Ptr, BlockSize));
             Hash = Hasher.result();
           }
-          std::array<char, 20> RecordedHash;
+          std::array<uint8_t, 20> RecordedHash;
           int Pos = 0;
           for (auto &Val : Record) {
             assert(!(Val >> 32) && "Unexpected high bits set");
             support::endian::write32be(&RecordedHash[Pos], Val);
             Pos += 4;
           }
-          if (Hash == StringRef(RecordedHash.data(), RecordedHash.size()))
+          if (Hash == RecordedHash)
             O->OS << " (match)";
           else
             O->OS << " (!mismatch!)";
         }
       }
 
       O->OS << "/>";
 

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

 
 void ModuleBitcodeWriter::writeModuleHash(size_t BlockStartPos) {
   // Emit the module's hash.
   // MODULE_CODE_HASH: [5*i32]
   if (GenerateHash) {
     uint32_t Vals[5];
     Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&(Buffer)[BlockStartPos],
                                     Buffer.size() - BlockStartPos));
-    StringRef Hash = Hasher.result();
+    auto Hash = Hasher.result();
     for (int Pos = 0; Pos < 20; Pos += 4) {
       Vals[Pos / 4] = support::endian::read32be(Hash.data() + Pos);
     }
 
     // Emit the finished record.
     Stream.EmitRecord(bitc::MODULE_CODE_HASH, Vals);
 
     if (ModHash)

llvm/lib/DebugInfo/CodeView/TypeHashing.cpp

for (const auto &Ref : Refs) {
 
     Off = Ref.Offset + Ref.Count * sizeof(TypeIndex);
   }
 
   // Don't forget to add in any trailing bytes.
   auto TrailingBytes = RecordData.drop_front(Off);
   S.update(TrailingBytes);
 
-  return {S.final().take_back(8)};
+  auto Hash = S.final();
+  return {ArrayRef<uint8_t>(Hash).take_back(8)};
 }

llvm/lib/ObjCopy/MachO/MachOWriter.cpp

void MachOWriter::writeCodeSignatureData() {
   uint8_t *CurrHashReadPosition = HashReadStart;
   uint8_t *CurrHashWritePosition = HashWriteStart;
   while (CurrHashReadPosition < HashReadEnd) {
     StringRef Block(reinterpret_cast<char *>(CurrHashReadPosition),
                     std::min(HashReadEnd - CurrHashReadPosition,
                              static_cast<ssize_t>(CodeSignature.BlockSize)));
     SHA256 Hasher;
     Hasher.update(Block);
-    StringRef Hash = Hasher.final();
+    auto Hash = Hasher.final();
     assert(Hash.size() == CodeSignature.HashSize);
     memcpy(CurrHashWritePosition, Hash.data(), CodeSignature.HashSize);
     CurrHashReadPosition += CodeSignature.BlockSize;
     CurrHashWritePosition += CodeSignature.HashSize;
   }
 #if defined(__APPLE__)
   // This is macOS-specific work-around and makes no sense for any
   // other host OS. See https://openradar.appspot.com/FB8914231

llvm/lib/Support/BLAKE3/README.md

 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 int main() {
   // Initialize the hasher.
-  llvm::BLAKE3 hasher;
+  llvm::BLAKE3<> hasher;
 
   // Read input bytes from stdin.
   char buf[65536];
   while (1) {
     ssize_t n = read(STDIN_FILENO, buf, sizeof(buf));
     if (n > 0) {
       hasher.update(llvm::StringRef(buf, n));
     } else if (n == 0) {

 }
 ```
 
 # API
 
 ## The Class/Struct
 
 ```c++
+template <size_t NumBytes = LLVM_BLAKE3_OUT_LEN>
 class BLAKE3 {
   // API
 private:
   llvm_blake3_hasher Hasher;
 };
 ```
 ```c
 typedef struct {

 
 ---
 
 ```c++
 template <size_t NumBytes = LLVM_BLAKE3_OUT_LEN>
 using BLAKE3Result = std::array<uint8_t, NumBytes>;
 
 template <size_t NumBytes = LLVM_BLAKE3_OUT_LEN>
-void BLAKE3::final(BLAKE3Result<NumBytes> &Result);
+void BLAKE3<NumBytes>::final(BLAKE3Result<NumBytes> &Result);
 
 template <size_t NumBytes = LLVM_BLAKE3_OUT_LEN>
-BLAKE3Result<NumBytes> final();
+BLAKE3Result<NumBytes> BLAKE3<NumBytes>::final();
 ```
 ```c
 void llvm_blake3_hasher_finalize(
   const llvm_blake3_hasher *self,
   uint8_t *out,
   size_t out_len);
 ```
 

llvm/lib/Support/MD5.cpp

void MD5::final(MD5Result &Result) {
   body(makeArrayRef(InternalState.buffer, 64));
 
   support::endian::write32le(&Result[0], InternalState.a);
   support::endian::write32le(&Result[4], InternalState.b);
   support::endian::write32le(&Result[8], InternalState.c);
   support::endian::write32le(&Result[12], InternalState.d);
 }
 
-StringRef MD5::final() {
+std::array<uint8_t, 16> MD5::final() {
+  MD5Result Result;
   final(Result);
-  return StringRef(reinterpret_cast<char *>(Result.Bytes.data()),
-                   Result.Bytes.size());
+  return Result.Bytes;
 }
 
-StringRef MD5::result() {
+std::array<uint8_t, 16> MD5::result() {
   auto StateToRestore = InternalState;
 
   auto Hash = final();
 
   // Restore the state
   InternalState = StateToRestore;
 
   return Hash;

llvm/lib/Support/SHA1.cpp

void SHA1::pad() {
   addUncounted(InternalState.ByteCount >> 29); // Shifting to multiply by 8
   addUncounted(InternalState.ByteCount >>
                21); // as SHA-1 supports bitstreams as well as
   addUncounted(InternalState.ByteCount >> 13); // byte.
   addUncounted(InternalState.ByteCount >> 5);
   addUncounted(InternalState.ByteCount << 3);
 }
 
-StringRef SHA1::final() {
+void SHA1::final(std::array<uint32_t, HASH_LENGTH / 4> &HashResult) {
   // Pad to complete the last block
   pad();
 
 #ifdef SHA_BIG_ENDIAN
   // Just copy the current state
   for (int i = 0; i < 5; i++) {
     HashResult[i] = InternalState.State[i];
   }
 #else
   // Swap byte order back
   for (int i = 0; i < 5; i++) {
     HashResult[i] = (((InternalState.State[i]) << 24) & 0xff000000) |
                     (((InternalState.State[i]) << 8) & 0x00ff0000) |
                     (((InternalState.State[i]) >> 8) & 0x0000ff00) |
                     (((InternalState.State[i]) >> 24) & 0x000000ff);
   }
 #endif
+}
 
-  // Return pointer to hash (20 characters)
-  return StringRef((char *)HashResult, HASH_LENGTH);
+std::array<uint8_t, 20> SHA1::final() {
+  union {
+    std::array<uint32_t, HASH_LENGTH / 4> HashResult;
+    std::array<uint8_t, 20> ReturnResult;
+  };
+  static_assert(sizeof(HashResult) == sizeof(ReturnResult), "");
+  final(HashResult);
+  return ReturnResult;
 }
 
-StringRef SHA1::result() {
+std::array<uint8_t, 20> SHA1::result() {
   auto StateToRestore = InternalState;
 
   auto Hash = final();
 
   // Restore the state
   InternalState = StateToRestore;
 
   // Return pointer to hash (20 characters)
   return Hash;
 }
 
 std::array<uint8_t, 20> SHA1::hash(ArrayRef<uint8_t> Data) {
   SHA1 Hash;
   Hash.update(Data);
-  StringRef S = Hash.final();
-
-  std::array<uint8_t, 20> Arr;
-  memcpy(Arr.data(), S.data(), S.size());
-  return Arr;
+  return Hash.final();
 }

llvm/lib/Support/SHA256.cpp

void SHA256::pad() {
   addUncounted(len >> 40);
   addUncounted(len >> 32);
   addUncounted(len >> 24);
   addUncounted(len >> 16);
   addUncounted(len >> 8);
   addUncounted(len);
 }
 
-StringRef SHA256::final() {
+void SHA256::final(std::array<uint32_t, HASH_LENGTH / 4> &HashResult) {
   // Pad to complete the last block
   pad();
 
 #ifdef SHA_BIG_ENDIAN
   // Just copy the current state
   for (int i = 0; i < 8; i++) {
     HashResult[i] = InternalState.State[i];
   }
 #else
   // Swap byte order back
   for (int i = 0; i < 8; i++) {
     HashResult[i] = (((InternalState.State[i]) << 24) & 0xff000000) |
                     (((InternalState.State[i]) << 8) & 0x00ff0000) |
                     (((InternalState.State[i]) >> 8) & 0x0000ff00) |
                     (((InternalState.State[i]) >> 24) & 0x000000ff);
   }
 #endif
+}
 
-  // Return pointer to hash (32 characters)
-  return StringRef((char *)HashResult, HASH_LENGTH);
+std::array<uint8_t, 32> SHA256::final() {
+  union {
+    std::array<uint32_t, HASH_LENGTH / 4> HashResult;
+    std::array<uint8_t, 32> ReturnResult;
+  };
+  static_assert(sizeof(HashResult) == sizeof(ReturnResult), "");
+  final(HashResult);
+  return ReturnResult;
 }
 
-StringRef SHA256::result() {
+std::array<uint8_t, 32> SHA256::result() {
   auto StateToRestore = InternalState;
 
   auto Hash = final();
 
   // Restore the state
   InternalState = StateToRestore;
 
   // Return pointer to hash (32 characters)
   return Hash;
 }
 
 std::array<uint8_t, 32> SHA256::hash(ArrayRef<uint8_t> Data) {
   SHA256 Hash;
   Hash.update(Data);
-  StringRef S = Hash.final();
-
-  std::array<uint8_t, 32> Arr;
-  memcpy(Arr.data(), S.data(), S.size());
-  return Arr;
+  return Hash.final();
 }
 
 } // namespace llvm

llvm/unittests/Support/BLAKE3Test.cpp

 //===- llvm/unittest/Support/BLAKE3Test.cpp - BLAKE3 tests ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements unit tests for the BLAKE3 functions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/BLAKE3.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/HashBuilder.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 /// Tests an arbitrary set of bytes passed as \p Input.
 void TestBLAKE3Sum(ArrayRef<uint8_t> Input, StringRef Final) {
-  BLAKE3 Hash;
+  BLAKE3<> Hash;
   Hash.update(Input);
   auto hash = Hash.final();
   auto hashStr = toHex(hash);
   EXPECT_EQ(hashStr, Final);
 }
 
 using KV = std::pair<const char *, const char *>;
 
TEST(BLAKE3Test, BLAKE3) {
   for (auto input_expected : testvectors) {
     auto str = std::get<0>(input_expected);
     auto expected = std::get<1>(input_expected);
     TestBLAKE3Sum({reinterpret_cast<const uint8_t *>(str), strlen(str)},
                   expected);
   }
 
   std::string rep(1000, 'a');
-  BLAKE3 Hash;
+  BLAKE3<> Hash;
   for (int i = 0; i < 1000; ++i) {
     Hash.update({reinterpret_cast<const uint8_t *>(rep.data()), rep.size()});
   }
   auto hash = Hash.final();
   auto hashStr = toHex(hash);
   EXPECT_EQ(hashStr,
             "616F575A1B58D4C9797D4217B9730AE5E6EB319D76EDEF6549B46F4EFE31FF8B");
 }
 
 TEST(BLAKE3Test, SmallerHashSize) {
   const char *InputStr = "abc";
   ArrayRef<uint8_t> Input(reinterpret_cast<const uint8_t *>(InputStr),
                           strlen(InputStr));
-  BLAKE3 Hash;
+  BLAKE3<16> Hash;
   Hash.update(Input);
-  auto hash1 = Hash.final<16>();
-  auto hash2 = BLAKE3::hash<16>(Input);
+  auto hash1 = Hash.final();
+  auto hash2 = BLAKE3<16>::hash(Input);
   auto hashStr1 = toHex(hash1);
   auto hashStr2 = toHex(hash2);
   EXPECT_EQ(hashStr1, hashStr2);
   EXPECT_EQ(hashStr1, "6437B3AC38465133FFB63B75273A8DB5");
+
+  // Using generic HashBuilder
+  HashBuilder<BLAKE3<16>, support::endianness::native> HashBuilder;
+  HashBuilder.update(Input);
+  auto hash3 = HashBuilder.final();
+  auto hash4 = HashBuilder.result();
+  EXPECT_EQ(hashStr1, toHex(hash3));
+  EXPECT_EQ(hashStr1, toHex(hash4));
 }
 
 } // namespace

llvm/unittests/Support/HashBuilderTest.cpp

 template <typename HasherT> class HashBuilderTest : public testing::Test {};
 TYPED_TEST_SUITE(HashBuilderTest, HasherTAndEndiannessToTest, );
 
 template <typename HasherTAndEndianness>
 using HashBuilder = llvm::HashBuilder<typename HasherTAndEndianness::HasherT,
                                       HasherTAndEndianness::Endianness>;
 
 template <typename HasherTAndEndianness, typename... Ts>
-static std::string hashWithBuilder(const Ts &...Args) {
-  return HashBuilder<HasherTAndEndianness>().add(Args...).final().str();
+static typename HashBuilder<HasherTAndEndianness>::template HashResultTy<>
+hashWithBuilder(const Ts &...Args) {
+  return HashBuilder<HasherTAndEndianness>().add(Args...).final();
 }
 
 template <typename HasherTAndEndianness, typename... Ts>
-static std::string hashRangeWithBuilder(const Ts &...Args) {
-  return HashBuilder<HasherTAndEndianness>().addRange(Args...).final().str();
+static typename HashBuilder<HasherTAndEndianness>::template HashResultTy<>
+hashRangeWithBuilder(const Ts &...Args) {
+  return HashBuilder<HasherTAndEndianness>().addRange(Args...).final();
 }
 
 // All the test infrastructure relies on the variadic helpers. Test them first.
 TYPED_TEST(HashBuilderTest, VariadicHelpers) {
   {
     HashBuilder<TypeParam> HBuilder;
 
     HBuilder.add(100);
TYPED_TEST(HashBuilderTest, AddHashableData) {
 
   auto ByteSwapAndHashWithHasher = [](auto Data) {
     using H = typename HE::HasherT;
     constexpr auto E = HE::Endianness;
     H Hasher;
     auto SwappedData = llvm::support::endian::byte_swap(Data, E);
     Hasher.update(llvm::makeArrayRef(
         reinterpret_cast<const uint8_t *>(&SwappedData), sizeof(Data)));
-    return static_cast<std::string>(Hasher.final());
+    return Hasher.final();
   };
 
   char C = 'c';
   int32_t I = 0x12345678;
   uint64_t UI64 = static_cast<uint64_t>(1) << 50;
   enum TestEnumeration : uint16_t { TE_One = 1, TE_Two = 2 };
   TestEnumeration Enum = TE_Two;
 

llvm/unittests/Support/MD5Test.cpp

TEST(MD5Test, FinalAndResultHelpers) {
 
   Hash.update("abcd");
 
   {
     MD5 ReferenceHash;
     ReferenceHash.update("abcd");
     MD5::MD5Result ReferenceResult;
     ReferenceHash.final(ReferenceResult);
-    StringRef ExpectedResult =
-        StringRef(reinterpret_cast<char *>(ReferenceResult.Bytes.data()),
-                  ReferenceResult.Bytes.size());
-    EXPECT_EQ(Hash.result(), ExpectedResult);
+    EXPECT_EQ(Hash.result(), ReferenceResult.Bytes);
   }
 
   Hash.update("xyz");
 
   {
     MD5 ReferenceHash;
     ReferenceHash.update("abcd");
     ReferenceHash.update("xyz");
     MD5::MD5Result ReferenceResult;
     ReferenceHash.final(ReferenceResult);
-    StringRef ExpectedResult =
-        StringRef(reinterpret_cast<char *>(ReferenceResult.Bytes.data()),
-                  ReferenceResult.Bytes.size());
-    EXPECT_EQ(Hash.final(), ExpectedResult);
+    EXPECT_EQ(Hash.final(), ReferenceResult.Bytes);
   }
 }
 } // namespace

llvm/unittests/Support/SHA256.cpp

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
-static std::string toHex(StringRef Input) {
+static std::string toHex(ArrayRef<uint8_t> Input) {
   static const char *const LUT = "0123456789abcdef";
   size_t Length = Input.size();
 
   std::string Output;
   Output.reserve(2 * Length);
   for (size_t i = 0; i < Length; ++i) {
     const unsigned char c = Input[i];
     Output.push_back(LUT[c >> 4]);

llvm/unittests/Support/raw_sha1_ostream_test.cpp

 //===- llvm/unittest/Support/raw_ostream_test.cpp - raw_ostream tests -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_sha1_ostream.h"
 #include "gtest/gtest.h"
 
 #include <string>
 
 using namespace llvm;
 
-static std::string toHex(StringRef Input) {
+static std::string toHex(ArrayRef<uint8_t> Input) {
   static const char *const LUT = "0123456789ABCDEF";
   size_t Length = Input.size();
 
   std::string Output;
   Output.reserve(2 * Length);
   for (size_t i = 0; i < Length; ++i) {
     const unsigned char c = Input[i];
     Output.push_back(LUT[c >> 4]);
     Output.push_back(LUT[c & 15]);
   }
   return Output;
 }
 
 TEST(raw_sha1_ostreamTest, Basic) {
   llvm::raw_sha1_ostream Sha1Stream;
   Sha1Stream << "Hello World!";
   auto Hash = toHex(Sha1Stream.sha1());
 
   ASSERT_EQ("2EF7BDE608CE5404E97D5F042F95F89F1C232871", Hash);
 }
 
 TEST(sha1_hash_test, Basic) {
   ArrayRef<uint8_t> Input((const uint8_t *)"Hello World!", 12);
   std::array<uint8_t, 20> Vec = SHA1::hash(Input);
-  std::string Hash = toHex({(const char *)Vec.data(), 20});
+  std::string Hash = toHex(Vec);
   ASSERT_EQ("2EF7BDE608CE5404E97D5F042F95F89F1C232871", Hash);
 }
 
 TEST(sha1_hash_test, Update) {
   SHA1 sha1;
   std::string Input = "123456789012345678901234567890";
   ASSERT_EQ(Input.size(), 30UL);
   // 3 short updates.

mlir/lib/Pass/IRPrinting.cpp

public:
   }
 
 private:
   template <typename T> void addDataToHash(llvm::SHA1 &hasher, const T &data) {
     hasher.update(
         ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(&data), sizeof(T)));
   }
 
-  SmallString<20> hash;
+  std::array<uint8_t, 20> hash;
 };
 
 //===----------------------------------------------------------------------===//
 // IRPrinter
 //===----------------------------------------------------------------------===//
 
 class IRPrinterInstrumentation : public PassInstrumentation {
 public: