Delete LLDB code for MD5'ing a file. Use LLVM instead

[sas]

So nice.

[labath]

cool

lldb/trunk/include/lldb/Host/FileSystem.h

public:
   static Error Hardlink(const FileSpec &src, const FileSpec &dst);
   static int GetHardlinkCount(const FileSpec &file_spec);
   static Error Symlink(const FileSpec &src, const FileSpec &dst);
   static Error Readlink(const FileSpec &src, FileSpec &dst);
   static Error Unlink(const FileSpec &file_spec);
 
   static Error ResolveSymbolicLink(const FileSpec &src, FileSpec &dst);
 
-  static bool CalculateMD5(const FileSpec &file_spec, uint64_t &low,
-                           uint64_t &high);
-  static bool CalculateMD5(const FileSpec &file_spec, uint64_t offset,
-                           uint64_t length, uint64_t &low, uint64_t &high);
-
-  static bool CalculateMD5AsString(const FileSpec &file_spec,
-                                   std::string &digest_str);
-  static bool CalculateMD5AsString(const FileSpec &file_spec, uint64_t offset,
-                                   uint64_t length, std::string &digest_str);
-
   /// Return \b true if \a spec is on a locally mounted file system, \b false
   /// otherwise.
   static bool IsLocal(const FileSpec &spec);
 
   /// Wraps ::fopen in a platform-independent way. Once opened, FILEs can be
   /// manipulated and closed with the normal ::fread, ::fclose, etc. functions.
   static FILE *Fopen(const char *path, const char *mode);
 
   /// Wraps ::stat in a platform-independent way.
   static int Stat(const char *path, struct stat *stats);
 
   static llvm::sys::TimePoint<> GetModificationTime(const FileSpec &file_spec);
 };
 }
 
 #endif

lldb/trunk/source/Host/common/FileSystem.cpp

 //===-- FileSystem.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/FileSystem.h"
 
 #include "llvm/Support/FileSystem.h"
-#include "llvm/Support/MD5.h"
 
 #include <algorithm>
 #include <fstream>
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 
-namespace {
-
-bool CalcMD5(const FileSpec &file_spec, uint64_t offset, uint64_t length,
-             llvm::MD5::MD5Result &md5_result) {
-  llvm::MD5 md5_hash;
-  std::ifstream file(file_spec.GetPath(), std::ios::binary);
-  if (!file.is_open())
-    return false;
-
-  if (offset > 0)
-    file.seekg(offset, file.beg);
-
-  std::vector<char> read_buf(4096);
-  uint64_t total_read_bytes = 0;
-  while (!file.eof()) {
-    const uint64_t to_read =
-        (length > 0) ? std::min(static_cast<uint64_t>(read_buf.size()),
-                                length - total_read_bytes)
-                     : read_buf.size();
-    if (to_read == 0)
-      break;
-
-    file.read(&read_buf[0], to_read);
-    const auto read_bytes = file.gcount();
-    if (read_bytes == 0)
-      break;
-
-    md5_hash.update(llvm::StringRef(&read_buf[0], read_bytes));
-    total_read_bytes += read_bytes;
-  }
-
-  md5_hash.final(md5_result);
-  return true;
-}
-
-} // namespace
-
-bool FileSystem::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
-                              uint64_t &high) {
-  return CalculateMD5(file_spec, 0, 0, low, high);
-}
-
-bool FileSystem::CalculateMD5(const FileSpec &file_spec, uint64_t offset,
-                              uint64_t length, uint64_t &low, uint64_t &high) {
-  llvm::MD5::MD5Result md5_result;
-  if (!CalcMD5(file_spec, offset, length, md5_result))
-    return false;
-
-  std::tie(high, low) = md5_result.words();
-
-  return true;
-}
-
-bool FileSystem::CalculateMD5AsString(const FileSpec &file_spec,
-                                      std::string &digest_str) {
-  return CalculateMD5AsString(file_spec, 0, 0, digest_str);
-}
-
-bool FileSystem::CalculateMD5AsString(const FileSpec &file_spec,
-                                      uint64_t offset, uint64_t length,
-                                      std::string &digest_str) {
-  llvm::MD5::MD5Result md5_result;
-  if (!CalcMD5(file_spec, offset, length, md5_result))
-    return false;
-
-  llvm::SmallString<32> result_str;
-  llvm::MD5::stringifyResult(md5_result, result_str);
-  digest_str = result_str.c_str();
-  return true;
-}
-
 llvm::sys::TimePoint<>
 FileSystem::GetModificationTime(const FileSpec &file_spec) {
   llvm::sys::fs::file_status status;
   std::error_code ec = llvm::sys::fs::status(file_spec.GetPath(), status);
   if (ec)
     return llvm::sys::TimePoint<>();
   return status.getLastModificationTime();
 }

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 #include "clang/Basic/VersionTuple.h"
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Timer.h"
-#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
if (!cache_path.empty()) {
         }
       }
 
       // try to find the module in the cache
       if (module_cache_spec.Exists()) {
         // get the local and remote MD5 and compare
         if (m_remote_platform_sp) {
           // when going over the *slow* GDB remote transfer mechanism we first
-          // check
-          // the hashes of the files - and only do the actual transfer if they
-          // differ
+          // check the hashes of the files - and only do the actual transfer if
+          // they differ
           uint64_t high_local, high_remote, low_local, low_remote;
-          FileSystem::CalculateMD5(module_cache_spec, low_local, high_local);
+          auto MD5 = llvm::sys::fs::md5_contents(module_cache_spec.GetPath());
+          if (!MD5)
+            return Error(MD5.getError());
+          std::tie(high_local, low_local) = MD5->words();
+
           m_remote_platform_sp->CalculateMD5(module_spec.GetFileSpec(),
                                              low_remote, high_remote);
           if (low_local != low_remote || high_local != high_remote) {
             // bring in the remote file
             Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
             if (log)
               log->Printf(
                   "[%s] module %s/%s needs to be replaced from remote copy",

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

 GDBRemoteCommunicationServerCommon::Handle_vFile_MD5(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:MD5:"));
   std::string path;
   packet.GetHexByteString(path);
   if (!path.empty()) {
     uint64_t a, b;
     StreamGDBRemote response;
-    if (!FileSystem::CalculateMD5(FileSpec(path, false), a, b)) {
+    auto Result = llvm::sys::fs::md5_contents(path);
+    if (!Result) {
       response.PutCString("F,");
       response.PutCString("x");
     } else {
       response.PutCString("F,");
-      response.PutHex64(a);
-      response.PutHex64(b);
+      response.PutHex64(Result->low());
+      response.PutHex64(Result->high());
     }
     return SendPacketNoLock(response.GetString());
   }
   return SendErrorResponse(25);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_qPlatform_mkdir(
GDBRemoteCommunicationServerCommon::Handle_qModuleInfo(
 
   const auto file_offset = matched_module_spec.GetObjectOffset();
   const auto file_size = matched_module_spec.GetObjectSize();
   const auto uuid_str = matched_module_spec.GetUUID().GetAsString("");
 
   StreamGDBRemote response;
 
   if (uuid_str.empty()) {
-    std::string md5_hash;
-    if (!FileSystem::CalculateMD5AsString(matched_module_spec.GetFileSpec(),
-                                          file_offset, file_size, md5_hash))
+    auto Result = llvm::sys::fs::md5_contents(matched_module_spec.GetFileSpec().GetPath());
+    if (!Result)
       return SendErrorResponse(5);
     response.PutCString("md5:");
-    response.PutCStringAsRawHex8(md5_hash.c_str());
+    response.PutCStringAsRawHex8(Result->digest().c_str());
   } else {
     response.PutCString("uuid:");
     response.PutCStringAsRawHex8(uuid_str.c_str());
   }
   response.PutChar(';');
 
   const auto &module_arch = matched_module_spec.GetArchitecture();
   response.PutCString("triple:");

lldb/trunk/source/Target/Platform.cpp

if (IsHost())
     return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr,
                                  command_output, timeout_sec);
   else
     return Error("unimplemented");
 }
 
 bool Platform::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
                             uint64_t &high) {
-  if (IsHost())
-    return FileSystem::CalculateMD5(file_spec, low, high);
-  else
+  if (!IsHost())
     return false;
+  auto Result = llvm::sys::fs::md5_contents(file_spec.GetPath());
+  if (!Result)
+    return false;
+  std::tie(high, low) = Result->words();
+  return true;
 }
 
 void Platform::SetLocalCacheDirectory(const char *local) {
   m_local_cache_directory.assign(local);
 }
 
 const char *Platform::GetLocalCacheDirectory() {
   return m_local_cache_directory.c_str();