Make ICF output deterministic.

[ruiu]

Summary

This patch does the same thing as r338153 for COFF.

[pcc]

LGTM

I'd probably mention in the commit message that it's just the log output that's being made deterministic. As far as I know this shouldn't affect the contents of the output file.

lld/trunk/COFF/ICF.cpp

 #include "Chunks.h"
 #include "Symbols.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Timer.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/xxhash.h"
 #include <algorithm>
 #include <atomic>
 #include <vector>
 
 using namespace llvm;
 
 namespace lld {
 namespace coff {
private:
 
   void forEachClass(std::function<void(size_t, size_t)> Fn);
 
   std::vector<SectionChunk *> Chunks;
   int Cnt = 0;
   std::atomic<bool> Repeat = {false};
 };
 
-// Returns a hash value for S.
-uint32_t ICF::getHash(SectionChunk *C) {
-  return hash_combine(C->getOutputCharacteristics(), C->SectionName,
-                      C->Relocs.size(), uint32_t(C->Header->SizeOfRawData),
-                      C->Checksum, C->getContents());
-}
-
 // Returns true if section S is subject of ICF.
 //
 // Microsoft's documentation
 // (https://msdn.microsoft.com/en-us/library/bxwfs976.aspx; visited April
 // 2017) says that /opt:icf folds both functions and read-only data.
 // Despite that, the MSVC linker folds only functions. We found
 // a few instances of programs that are not safe for data merging.
 // Therefore, we merge only functions just like the MSVC tool. However, we also
void ICF::run(ArrayRef<Chunk *> Vec) {
   // tail merging.
   for (auto &P : MergeChunk::Instances)
     for (SectionChunk *SC : P.second->Sections)
       SC->Class[0] = NextId++;
 
   // Initially, we use hash values to partition sections.
   for_each(parallel::par, Chunks.begin(), Chunks.end(), [&](SectionChunk *SC) {
     // Set MSB to 1 to avoid collisions with non-hash classs.
-    SC->Class[0] = getHash(SC) | (1 << 31);
+    SC->Class[0] = xxHash64(SC->getContents()) | (1 << 31);
   });
 
   // From now on, sections in Chunks are ordered so that sections in
   // the same group are consecutive in the vector.
   std::stable_sort(Chunks.begin(), Chunks.end(),
                    [](SectionChunk *A, SectionChunk *B) {
                      return A->Class[0] < B->Class[0];
                    });

lld/trunk/ELF/ICF.cpp

template <class ELFT> void ICF<ELFT>::run() {
   for (InputSectionBase *Sec : InputSections)
     if (auto *S = dyn_cast<InputSection>(Sec))
       if (isEligible(S))
         Sections.push_back(S);
 
   // Initially, we use hash values to partition sections.
   parallelForEach(Sections, [&](InputSection *S) {
     // Set MSB to 1 to avoid collisions with non-hash IDs.
-    S->Class[0] = xxHash64(toStringRef(S->Data)) | (1U << 31);
+    S->Class[0] = xxHash64(S->Data) | (1U << 31);
   });
 
   // From now on, sections in Sections vector are ordered so that sections
   // in the same equivalence class are consecutive in the vector.
   std::stable_sort(Sections.begin(), Sections.end(),
                    [](InputSection *A, InputSection *B) {
                      return A->Class[0] < B->Class[0];
                    });

llvm/trunk/include/llvm/Support/xxhash.h

 */
 
 /* based on revision d2df04efcbef7d7f6886d345861e5dfda4edacc1 Removed
  * everything but a simple interface for computing XXh64. */
 
 #ifndef LLVM_SUPPORT_XXHASH_H
 #define LLVM_SUPPORT_XXHASH_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 uint64_t xxHash64(llvm::StringRef Data);
+uint64_t xxHash64(llvm::ArrayRef<uint8_t> Data);
 }
 
 #endif

llvm/trunk/lib/Support/xxhash.cpp

uint64_t llvm::xxHash64(StringRef Data) {
   H64 ^= H64 >> 33;
   H64 *= PRIME64_2;
   H64 ^= H64 >> 29;
   H64 *= PRIME64_3;
   H64 ^= H64 >> 32;
 
   return H64;
 }
+
+uint64_t llvm::xxHash64(ArrayRef<uint8_t> Data) {
+  return xxHash64({(const char *)Data.data(), Data.size()});
+}