COFF: Make SectionChunk::Relocs field an ArrayRef. NFCI.

[ruiu]

LGTM

Nice!

COFF/Chunks.h

public:
   ObjFile *File;
 
   // The COMDAT leader symbol if this is a COMDAT chunk.
   DefinedRegular *Sym = nullptr;
 
 private:
   StringRef SectionName;
   std::vector<SectionChunk *> AssocChildren;
-  llvm::iterator_range<const coff_relocation *> Relocs;
-  size_t NumRelocs;
+  ArrayRef<coff_relocation> Relocs;
 
   // Used by the garbage collector.
   bool Live;
 
   // Used for ICF (Identical COMDAT Folding)
   void replace(SectionChunk *Other);
   uint32_t Class[2] = {0, 0};
 };

COFF/Chunks.cpp

 using namespace llvm::COFF;
 using llvm::support::ulittle32_t;
 
 namespace lld {
 namespace coff {
 
 SectionChunk::SectionChunk(ObjFile *F, const coff_section *H)
     : Chunk(SectionKind), Repl(this), Header(H), File(F),
-      Relocs(File->getCOFFObj()->getRelocations(Header)),
-      NumRelocs(std::distance(Relocs.begin(), Relocs.end())) {
+      Relocs(File->getCOFFObj()->getRelocations(Header)) {
   // Initialize SectionName.
   File->getCOFFObj()->getSectionName(Header, SectionName);
 
   Alignment = Header->getAlignment();
 
   // If linker GC is disabled, every chunk starts out alive.  If linker GC is
   // enabled, treat non-comdat sections as roots. Generally optimized object
   // files will be built with -ffunction-sections or /Gy, so most things worth

COFF/ICF.cpp

private:
 
   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->getPermissions(), C->SectionName, C->NumRelocs,
+  return hash_combine(C->getPermissions(), C->SectionName, C->Relocs.size(),
                       C->Alignment, 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
while (Begin < End) {
 
     Begin = Mid;
   }
 }
 
 // Compare "non-moving" part of two sections, namely everything
 // except relocation targets.
 bool ICF::equalsConstant(const SectionChunk *A, const SectionChunk *B) {
-  if (A->NumRelocs != B->NumRelocs)
+  if (A->Relocs.size() != B->Relocs.size())
     return false;
 
   // Compare relocations.
   auto Eq = [&](const coff_relocation &R1, const coff_relocation &R2) {
     if (R1.Type != R2.Type ||
         R1.VirtualAddress != R2.VirtualAddress) {
       return false;
     }