[COFF] Avoid allocating temporary vectors during ICF

[rnk]

Summary

Heap profiling with ETW shows that LLD allocates 4,053,721 bytes of heap
memory over its lifetime, and ~800,000 of them come from assocEquals.
These vectors are created just to do a comparison, so fuse the
comparison into the loop and avoid the allocation.

ICF is overall a small portion of the time spent linking, and I did not
measure overall throughput improvements from this change above the noise
threshold. However, these show up in the heap profiler, and the work is
done, so we might as well land it if the code is clear enough.

[hans]

Looks great to me!

[rnk]

Heap profiling with ETW shows that LLD allocates 4,053,721 bytes of heap
memory over its lifetime, and ~800,000 of them come from assocEquals.

I misspoke here, I didn't understand the WPA heap profiler API. These numbers are for individual allocations.

I wasn't able to measure much speed improvement, but it makes LLD faster under the heap profiler. :) Fewer heap allocation stack traces for it to process.

lld/COFF/Chunks.h

public:
   // Single linked list iterator for associated comdat children.
   class AssociatedIterator
       : public llvm::iterator_facade_base<
             AssociatedIterator, std::forward_iterator_tag, SectionChunk> {
   public:
     AssociatedIterator() = default;
     AssociatedIterator(SectionChunk *head) : cur(head) {}
     bool operator==(const AssociatedIterator &r) const { return cur == r.cur; }
-    const SectionChunk &operator*() const { return *cur; }
+    // FIXME: Wrong const-ness, but it makes filter ranges work.
+    SectionChunk &operator*() const { return *cur; }
     SectionChunk &operator*() { return *cur; }
     AssociatedIterator &operator++() {
       cur = cur->assocChildren;
       return *this;
     }
 
   private:
     SectionChunk *cur = nullptr;

lld/COFF/ICF.cpp

if (mid != end)
       repeat = true;
 
     begin = mid;
   }
 }
 
 // Returns true if two sections' associative children are equal.
 bool ICF::assocEquals(const SectionChunk *a, const SectionChunk *b) {
-  auto childClasses = [&](const SectionChunk *sc) {
-    std::vector<uint32_t> classes;
-    for (const SectionChunk &c : sc->children())
-      if (!c.getSectionName().startswith(".debug") &&
-          c.getSectionName() != ".gfids$y" && c.getSectionName() != ".gljmp$y")
-        classes.push_back(c.eqClass[cnt % 2]);
-    return classes;
+  // Ignore associated metadata sections that don't participate in ICF, such as
+  // debug info and CFGuard metadata.
+  auto considerForICF = [](const SectionChunk &assoc) {
+    StringRef Name = assoc.getSectionName();
+    return !(Name.startswith(".debug") || Name == ".gfids$y" ||
+             Name == ".gljmp$y");
   };
-  return childClasses(a) == childClasses(b);
+  auto ra = make_filter_range(a->children(), considerForICF);
+  auto rb = make_filter_range(b->children(), considerForICF);
+  return std::equal(ra.begin(), ra.end(), rb.begin(), rb.end(),
+                    [&](const SectionChunk &ia, const SectionChunk &ib) {
+                      return ia.eqClass[cnt % 2] == ib.eqClass[cnt % 2];
+                    });
 }
 
 // Compare "non-moving" part of two sections, namely everything
 // except relocation targets.
 bool ICF::equalsConstant(const SectionChunk *a, const SectionChunk *b) {
   if (a->relocsSize != b->relocsSize)
     return false;