Add convenient functions to compute hashes of byte vectors.

[ruiu]

Summary

In many sitautions, you just want to compute a hash for one chunk
of data. This patch adds convenient functions for that purpose.

[davide]

The code looks correct, but, out of curiosity, where do you plan to use it?

[mehdi_amini]

That looks fine, but maybe having one of the unittests using the new API would be nice as well?

[ruiu]

I'm planning to use that in LLD, but it should be useful for other purposes.

[ruiu]

• Changed the type from std::vector<uint8_t> to SmallVector<uint8_t, 16 or 20>.
• Added tests.

[mehdi_amini]

LGTM.

[mehdi_amini]

I was wondering if instead of returning SmallVector<uint8_t, 20> we could use std::array<uint8_t, 20>?

[ruiu]

I chose that because of my familiarity with SmallVector compared to std::array. But I agree that probably std::array is better.

[ruiu]

• use std::array instead of SmallVector since the size will never change

[mehdi_amini]

Great, thanks!
(Still LGTM of course).

llvm/trunk/include/llvm/Support/MD5.h

  */
 
 #ifndef LLVM_SUPPORT_MD5_H
 #define LLVM_SUPPORT_MD5_H
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Endian.h"
+#include <array>
 
 namespace llvm {
 template <typename T> class ArrayRef;
 
 class MD5 {
   // Any 32-bit or wider unsigned integer data type will do.
   typedef uint32_t MD5_u32plus;
 
public:
 
   /// \brief Finishes off the hash and puts the result in result.
   void final(MD5Result &Result);
 
   /// \brief 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);
 
+  /// \brief Computes the hash for a given bytes.
+  static std::array<uint8_t, 16> hash(ArrayRef<uint8_t> Data);
+
 private:
   const uint8_t *body(ArrayRef<uint8_t> Data);
 };
 
 /// Helper to compute and return lower 64 bits of the given string's MD5 hash.
 inline uint64_t MD5Hash(StringRef Str) {
   MD5 Hash;
   Hash.update(Str);

llvm/trunk/include/llvm/Support/SHA1.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_SHA1_H
 #define LLVM_SUPPORT_SHA1_H
 
 #include "llvm/ADT/ArrayRef.h"
 
+#include <array>
 #include <cstdint>
 
 namespace llvm {
 template <typename T> class ArrayRef;
 class StringRef;
 
 /// A class that wrap the SHA1 algorithm.
 class SHA1 {
public:
   StringRef final();
 
   /// Return a reference to 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();
 
+  /// 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 {

llvm/trunk/lib/Support/MD5.cpp

 }
 
 void MD5::stringifyResult(MD5Result &Result, SmallString<32> &Str) {
   raw_svector_ostream Res(Str);
   for (int i = 0; i < 16; ++i)
     Res << format("%.2x", Result[i]);
 }
 
+std::array<uint8_t, 16> MD5::hash(ArrayRef<uint8_t> Data) {
+  MD5 Hash;
+  Hash.update(Data);
+  MD5::MD5Result Res;
+  Hash.final(Res);
+
+  std::array<uint8_t, 16> Arr;
+  memcpy(Arr.data(), Res, sizeof(Res));
+  return Arr;
+}
 }

llvm/trunk/lib/Support/SHA1.cpp

StringRef SHA1::result() {
   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().data();
+
+  std::array<uint8_t, 20> Arr;
+  memcpy(Arr.data(), S.data(), S.size());
+  return Arr;
+}

llvm/trunk/unittests/Support/MD5Test.cpp

TestMD5Sum(makeArrayRef((const uint8_t *)"\0", (size_t) 1),
              "93b885adfe0da089cdf634904fd59f71");
   TestMD5Sum(makeArrayRef((const uint8_t *)"a\0", (size_t) 2),
              "4144e195f46de78a3623da7364d04f11");
   TestMD5Sum(makeArrayRef((const uint8_t *)"abcdefghijklmnopqrstuvwxyz\0",
                           (size_t) 27),
              "81948d1f1554f58cd1a56ebb01f808cb");
   TestMD5Sum("abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b");
 }
+
+TEST(MD5HashTest, MD5) {
+  ArrayRef<uint8_t> Input((const uint8_t *)"abcdefghijklmnopqrstuvwxyz", 26);
+  std::array<uint8_t, 16> Vec = MD5::hash(Input);
+  MD5::MD5Result MD5Res;
+  SmallString<32> Res;
+  memcpy(MD5Res, Vec.data(), Vec.size());
+  MD5::stringifyResult(MD5Res, Res);
+  EXPECT_EQ(Res, "c3fcd3d76192e4007dfb496cca67e13b");
+}
 }

llvm/trunk/unittests/Support/raw_sha1_ostream_test.cpp

 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});
+  ASSERT_EQ("2EF7BDE608CE5404E97D5F042F95F89F1C232871", Hash);
+}
+
 // Check that getting the intermediate hash in the middle of the stream does
 // not invalidate the final result.
 TEST(raw_sha1_ostreamTest, Intermediate) {
   llvm::raw_sha1_ostream Sha1Stream;
   Sha1Stream << "Hello";
   auto Hash = toHex(Sha1Stream.sha1());
 
   ASSERT_EQ("F7FF9E8B7BB2E09B70935A5D785E0CC5D9D0ABF0", Hash);