[Support] Update `MD5` to follow other hashes.

[arames]

Summary

Introduce StringRef final() and StringRef result().

[dexonsmith]

Sorry I missed this before -- I have a few suggestions below to align this better with SHA1 and SHA256.

llvm/include/llvm/Support/MD5.h

93–95

I'm not seeing finalWords() in the other hashers. I suggest not adding it.

97

The other hashers return a StringRef. MD5 should align with that, and also return the raw bytes as they do (instead of a hex string).

Looking at SHA1 and SHA256, they have two methods, result() and final(), the former of which can be called at any time. Here is the implementation of result():

StringRef SHA1::result() {
  auto StateToRestore = InternalState;

  auto Hash = final();

  // Restore the state
  InternalState = StateToRestore;

  // Return pointer to hash (20 characters)
  return Hash;
}

I think if we're adding one we should add both, for consistency.

• Seems we'd need a prep NFC patch that moved its members into an InternalState member.
• MD5::final() can add an MD5Result member, calling final(MD5Result&) on it and returning a StringRef referencing MD5Result::bytes, and then MD5::result() can be implemented exactly as in SHA1.

llvm/lib/Support/MD5.cpp

276

The other hashers do not return a digest, but the raw bytes. MD5 should align with that.

llvm/unittests/Support/MD5Test.cpp

77

I think this should avoid a magic number, and just confirm that the final() return is equal to MD5Result::bytes when calling final(MD5Result&).

[arames]

Address review comments.

[dexonsmith]

LGTM, thanks!

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 the hash, and returns the result as a pair of words.
+  std::pair<uint64_t, uint64_t> finalWords();
+
+  /// Finishes the hash, and returns the result as a hex string of length 32.
+  SmallString<32> final();
+
   /// 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, SmallString<32> &Str);
 
   /// Computes the hash for a given bytes.
   static std::array<uint8_t, 16> hash(ArrayRef<uint8_t> Data);
 
 private:

llvm/lib/Support/MD5.cpp

void MD5::final(MD5Result &Result) {
   body(makeArrayRef(buffer, 64));
 
   support::endian::write32le(&Result[0], a);
   support::endian::write32le(&Result[4], b);
   support::endian::write32le(&Result[8], c);
   support::endian::write32le(&Result[12], d);
 }
 
+/// Finish and return the hash as a pair of words.
+std::pair<uint64_t, uint64_t> MD5::finalWords() {
+  MD5Result Result;
+  final(Result);
+  return Result.words();
+}
+
+/// Finish and return the hash as a hex string of length 32.
+SmallString<32> MD5::final() {
+  MD5Result Result;
+  final(Result);
+  return Result.digest();
+}
+
 SmallString<32> MD5::MD5Result::digest() const {
   SmallString<32> Str;
   raw_svector_ostream Res(Str);
   for (int i = 0; i < 16; ++i)
     Res << format("%.2x", Bytes[i]);
   return Str;
 }
 

llvm/unittests/Support/MD5Test.cpp

TEST(MD5HashTest, MD5) {
   MD5::MD5Result MD5Res;
   SmallString<32> Res;
   memcpy(MD5Res.Bytes.data(), Vec.data(), Vec.size());
   MD5::stringifyResult(MD5Res, Res);
   EXPECT_EQ(Res, "c3fcd3d76192e4007dfb496cca67e13b");
   EXPECT_EQ(0x3be167ca6c49fb7dULL, MD5Res.high());
   EXPECT_EQ(0x00e49261d7d3fcc3ULL, MD5Res.low());
 }
+
+TEST(MD5Test, FinalHelpers) {
+  {
+    MD5 Hash;
+    Hash.update("abcd");
+    SmallString<32> Result = Hash.final();
+    const char *Expected = "e2fc714c4727ee9395f324cd2e7f331f";
+    EXPECT_EQ(Result, Expected);
+  }
+  {
+    MD5 Hash;
+    Hash.update("abcd");
+    std::pair<uint64_t, uint64_t> Result = Hash.finalWords();
+    auto Expected = std::make_pair<uint64_t, uint64_t>(2248280477974983573ULL,
+                                                       10659500555211242722ULL);
+    EXPECT_EQ(Result, Expected);
+  }
 }
+} // namespace