llvm-reduce: Use DenseSet

[arsenm]

89b739163226b78b638fd82fb099ffc2dd7c683b

llvm/tools/llvm-reduce/deltas/Delta.h

void print() const {
     errs() << "]";
   }
 
   /// Operator when populating CurrentChunks in Generic Delta Pass
   friend bool operator!=(const Chunk &C1, const Chunk &C2) {
     return C1.Begin != C2.Begin || C1.End != C2.End;
   }
 
+  friend bool operator==(const Chunk &C1, const Chunk &C2) {
+    return C1.Begin == C2.Begin && C1.End == C2.End;
+  }
+
   /// Operator used for sets
   friend bool operator<(const Chunk &C1, const Chunk &C2) {
     return std::tie(C1.Begin, C1.End) < std::tie(C2.Begin, C2.End);
   }
 };
 
+template<>
+struct DenseMapInfo<Chunk> {
+  static inline Chunk getEmptyKey() {
+    return {DenseMapInfo<int>::getEmptyKey(),
+            DenseMapInfo<int>::getEmptyKey()};
+  }
+
+  static inline Chunk getTombstoneKey() {
+    return {DenseMapInfo<int>::getTombstoneKey(),
+            DenseMapInfo<int>::getTombstoneKey()};
+  }
+
+  static unsigned getHashValue(const Chunk Val) {
+    std::pair<int, int> PairVal = std::make_pair(Val.Begin, Val.End);
+    return DenseMapInfo<std::pair<int, int>>::getHashValue(PairVal);
+  }
+
+  static bool isEqual(const Chunk LHS, const Chunk RHS) {
+    return LHS == RHS;
+  }
+};
+
+
 /// Provides opaque interface for querying into ChunksToKeep without having to
 /// actually understand what is going on.
 class Oracle {
   /// Out of all the features that we promised to be,
   /// how many have we already processed?
   int Index = 0;
 
   /// The actual workhorse, contains the knowledge whether or not

llvm/tools/llvm-reduce/deltas/Delta.cpp

 }
 
 // Check if \p ChunkToCheckForUninterestingness is interesting. Returns the
 // modified module if the chunk resulted in a reduction.
 static std::unique_ptr<ReducerWorkItem>
 CheckChunk(Chunk &ChunkToCheckForUninterestingness,
            std::unique_ptr<ReducerWorkItem> Clone, TestRunner &Test,
            ReductionFunc ExtractChunksFromModule,
-           std::set<Chunk> &UninterestingChunks,
+           DenseSet<Chunk> &UninterestingChunks,
            std::vector<Chunk> &ChunksStillConsideredInteresting) {
   // Take all of ChunksStillConsideredInteresting chunks, except those we've
   // already deemed uninteresting (UninterestingChunks) but didn't remove
   // from ChunksStillConsideredInteresting yet, and additionally ignore
   // ChunkToCheckForUninterestingness chunk.
   std::vector<Chunk> CurrentChunks;
   CurrentChunks.reserve(ChunksStillConsideredInteresting.size() -
                         UninterestingChunks.size() - 1);
if (Verbose)
       errs() << "\n";
     return nullptr;
   }
   return Clone;
 }
 
 static SmallString<0> ProcessChunkFromSerializedBitcode(
     Chunk &ChunkToCheckForUninterestingness, TestRunner &Test,
-    ReductionFunc ExtractChunksFromModule, std::set<Chunk> &UninterestingChunks,
+    ReductionFunc ExtractChunksFromModule, DenseSet<Chunk> &UninterestingChunks,
     std::vector<Chunk> &ChunksStillConsideredInteresting,
     SmallString<0> &OriginalBC, std::atomic<bool> &AnyReduced) {
   LLVMContext Ctx;
   auto CloneMMM = std::make_unique<ReducerWorkItem>();
   auto Data = MemoryBufferRef(StringRef(OriginalBC.data(), OriginalBC.size()),
                               "<bc file>");
   readBitcode(*CloneMMM, Data, Ctx, Test.getToolName());
 
#endif
   if (NumJobs > 1)
     ChunkThreadPoolPtr =
         std::make_unique<ThreadPool>(hardware_concurrency(NumJobs));
 
   bool FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity;
   do {
     FoundAtLeastOneNewUninterestingChunkWithCurrentGranularity = false;
 
-    std::set<Chunk> UninterestingChunks;
+    DenseSet<Chunk> UninterestingChunks;
 
     // When running with more than one thread, serialize the original bitcode
     // to OriginalBC.
     SmallString<0> OriginalBC;
     if (NumJobs > 1) {
       raw_svector_ostream BCOS(OriginalBC);
       writeBitcode(Test.getProgram(), BCOS);
     }