Further reduce the number of allocators

[• espindola]

Summary

This uses the same allocators for sections.

It ranges from a tiny slowdown to a quite noticeable speedup.

In a followup patch I will try to further reduce the number of allocators and simplify the code by using a global variable.

[• rafael]

The perf numbers I got:

firefox

master 7.177125163
patch  7.182606942 1.00076378479x slower

firefox-gc

master 7.374067189
patch  7.381466572 1.00100343309x slower

chromium

master 5.120661949
patch  4.981522129 1.02793118577x faster

chromium fast

master 1.963941995
patch  1.85967246 1.05606876331x faster

the gold plugin

master 0.347964045
patch  0.340951595 1.02056728903x faster

clang

master 0.589530331
patch  0.578198657 1.01959823646x faster

llvm-as

master 0.034089395
patch  0.03350961 1.01730205156x faster

the gold plugin fsds

master 0.376985041
patch  0.370091689 1.01862606539x faster

clang fsds

master 0.671836293
patch  0.662105439 1.01469683441x faster

llvm-as fsds

master 0.031508503
patch  0.031008237 1.01613332612x faster

scylla

master 3.220639954
patch  3.22094804 1.00009565987x slower

[ruiu]

With your change to call _exit, you can't see any difference in performance, no? Because this change is a bit complicated, I'd want to not have this one if it doesn't improve performance in normal use cases.

[ruiu]

I wonder if we add a virtual dtor to InputSection. Do you think it's too expensive?

[ruiu]

I don't think I fully understand why this can make things faster. This patch replaces

llvm::SpecificBumpPtrAllocator<[derived class of InputSection]>

with

std::unique_ptr<InputSection>,

so the number of allocations and the number of deallocation (which should be zero if _exit is called) don't change, IIUC.

ELF/Driver.cpp

bool elf::link(ArrayRef<const char *> Args, bool CanExitEarly,
   Configuration C;
   LinkerDriver D;
   ScriptConfiguration SC;
   Config = &C;
   Driver = &D;
   ScriptConfig = &SC;
 
   Driver->main(Args, CanExitEarly);
-  InputFile::freePool();
   return !HasError;
 }
 
 // Parses a linker -m option.
 static std::pair<ELFKind, uint16_t> parseEmulation(StringRef Emul) {
   StringRef S = Emul;
   if (S.endswith("_fbsd"))
     S = S.drop_back(5);
template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   if (Config->GcSections)
     markLive<ELFT>();
   if (Config->ICF)
     doIcf<ELFT>();
 
   // MergeInputSection::splitIntoPieces needs to be called before
   // any call of MergeInputSection::getOffset. Do that.
   for (elf::ObjectFile<ELFT> *F : Symtab.getObjectFiles()) {
-    for (InputSectionBase<ELFT> *S : F->getSections()) {
+    for (const auto &Iter : F->getSections()) {
+      InputSectionBase<ELFT> *S = Iter.get();
       if (!S || S == &InputSection<ELFT>::Discarded || !S->Live)
         continue;
       if (S->Compressed)
         S->uncompress();
       if (auto *MS = dyn_cast<MergeInputSection<ELFT>>(S))
         MS->splitIntoPieces();
     }
   }
 
   // Write the result to the file.
   writeResult<ELFT>();
+  InputFile::freePool();
 }

ELF/ICF.cpp

template <class ELFT> bool ICF<ELFT>::isEligible(InputSectionBase<ELFT> *Sec) {
 
   return (S->Flags & SHF_ALLOC) && !(S->Flags & SHF_WRITE);
 }
 
 template <class ELFT>
 std::vector<InputSection<ELFT> *> ICF<ELFT>::getSections() {
   std::vector<InputSection<ELFT> *> V;
   for (ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles())
-    for (InputSectionBase<ELFT> *S : F->getSections())
+    for (const auto &Iter : F->getSections()) {
+      InputSectionBase<ELFT> *S = Iter.get();
       if (isEligible(S))
         V.push_back(cast<InputSection<ELFT>>(S));
+    }
   return V;
 }
 
 // All sections between Begin and End must have the same group ID before
 // you call this function. This function compare sections between Begin
 // and End using Eq and assign new group IDs for new groups.
 template <class ELFT>
 void ICF<ELFT>::segregate(InputSection<ELFT> **Begin, InputSection<ELFT> **End,

ELF/InputFiles.h

template <class ELFT> class ObjectFile : public ELFFileBase<ELFT> {
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::SymRange Elf_Sym_Range;
   typedef typename ELFT::Word Elf_Word;
   typedef typename ELFT::uint uintX_t;
 
   StringRef getShtGroupSignature(const Elf_Shdr &Sec);
   ArrayRef<Elf_Word> getShtGroupEntries(const Elf_Shdr &Sec);
 
+  struct Deleter {
+    void operator()(InputSectionBase<ELFT> *P);
+  };
+  typedef std::unique_ptr<InputSectionBase<ELFT>, Deleter> SecPtr;
+  static_assert(sizeof(SecPtr) == sizeof(InputSectionBase<ELFT> *),
+                "Should have no overhead");
+
 public:
   static bool classof(const InputFile *F) {
     return F->kind() == Base::ObjectKind;
   }
 
   ArrayRef<SymbolBody *> getSymbols();
   ArrayRef<SymbolBody *> getLocalSymbols();
   ArrayRef<SymbolBody *> getNonLocalSymbols();
 
   explicit ObjectFile(llvm::BumpPtrAllocator &Alloc, MemoryBufferRef M);
   void parse(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
 
-  ArrayRef<InputSectionBase<ELFT> *> getSections() const { return Sections; }
+  ArrayRef<SecPtr> getSections() const { return Sections; }
   InputSectionBase<ELFT> *getSection(const Elf_Sym &Sym) const;
 
   SymbolBody &getSymbolBody(uint32_t SymbolIndex) const {
     if (SymbolIndex >= SymbolBodies.size())
       fatal(getFilename(this) + ": invalid symbol index");
     return *SymbolBodies[SymbolIndex];
   }
 
private:
   void initializeReverseDependencies();
   InputSectionBase<ELFT> *getRelocTarget(const Elf_Shdr &Sec);
   InputSectionBase<ELFT> *createInputSection(const Elf_Shdr &Sec);
 
   bool shouldMerge(const Elf_Shdr &Sec);
   SymbolBody *createSymbolBody(const Elf_Sym *Sym);
 
   // List of all sections defined by this file.
-  std::vector<InputSectionBase<ELFT> *> Sections;
+  std::vector<SecPtr> Sections;
 
   // List of all symbols referenced or defined by this file.
   std::vector<SymbolBody *> SymbolBodies;
 
   // MIPS .reginfo section defined by this file.
-  std::unique_ptr<MipsReginfoInputSection<ELFT>> MipsReginfo;
+  MipsReginfoInputSection<ELFT> *MipsReginfo = nullptr;
   // MIPS .MIPS.options section defined by this file.
-  std::unique_ptr<MipsOptionsInputSection<ELFT>> MipsOptions;
+  MipsOptionsInputSection<ELFT> *MipsOptions = nullptr;
   // MIPS .MIPS.abiflags section defined by this file.
-  std::unique_ptr<MipsAbiFlagsInputSection<ELFT>> MipsAbiFlags;
+  MipsAbiFlagsInputSection<ELFT> *MipsAbiFlags = nullptr;
 
-  llvm::SpecificBumpPtrAllocator<InputSection<ELFT>> IAlloc;
-  llvm::SpecificBumpPtrAllocator<MergeInputSection<ELFT>> MAlloc;
-  llvm::SpecificBumpPtrAllocator<EhInputSection<ELFT>> EHAlloc;
   std::unique_ptr<DIHelper<ELFT>> DIH;
 };
 
 // LazyObjectFile is analogous to ArchiveFile in the sense that
 // the file contains lazy symbols. The difference is that
 // LazyObjectFile wraps a single file instead of multiple files.
 //
 // This class is used for --start-lib and --end-lib options which

ELF/InputFiles.cpp

 }
 
 template <class ELFT> void ELFFileBase<ELFT>::initStringTable() {
   if (!Symtab)
     return;
   StringTable = check(ELFObj.getStringTableForSymtab(*Symtab));
 }
 
+template <typename T> static void destruct(T *P) { P->~T(); }
+
+template <class ELFT>
+void elf::ObjectFile<ELFT>::Deleter::operator()(InputSectionBase<ELFT> *P) {
+  if (!P || P == &InputSection<ELFT>::Discarded)
+    return;
+  switch (P->kind()) {
+  case InputSectionData::Regular:
+    destruct(cast<InputSection<ELFT>>(P));
+    return;
+  case InputSectionData::EHFrame:
+    destruct(cast<EhInputSection<ELFT>>(P));
+    return;
+  case InputSectionData::Merge:
+    destruct(cast<MergeInputSection<ELFT>>(P));
+    return;
+  case InputSectionData::MipsReginfo:
+    destruct(cast<MipsReginfoInputSection<ELFT>>(P));
+    return;
+  case InputSectionData::MipsOptions:
+    destruct(cast<MipsOptionsInputSection<ELFT>>(P));
+    return;
+  case InputSectionData::MipsAbiFlags:
+    destruct(cast<MipsAbiFlagsInputSection<ELFT>>(P));
+    return;
+  };
+}
+
 template <class ELFT>
 elf::ObjectFile<ELFT>::ObjectFile(BumpPtrAllocator &Alloc, MemoryBufferRef M)
     : ELFFileBase<ELFT>(Base::ObjectKind, M), Alloc(Alloc) {}
 
 template <class ELFT>
 ArrayRef<SymbolBody *> elf::ObjectFile<ELFT>::getNonLocalSymbols() {
   if (!this->Symtab)
     return this->SymbolBodies;

 void elf::ObjectFile<ELFT>::initializeSections(
     DenseSet<CachedHashStringRef> &ComdatGroups) {
   uint64_t Size = this->ELFObj.getNumSections();
   Sections.resize(Size);
   unsigned I = -1;
   const ELFFile<ELFT> &Obj = this->ELFObj;
   for (const Elf_Shdr &Sec : Obj.sections()) {
     ++I;
-    if (Sections[I] == &InputSection<ELFT>::Discarded)
+    if (Sections[I].get() == &InputSection<ELFT>::Discarded)
       continue;
 
     // SHF_EXCLUDE'ed sections are discarded by the linker. However,
     // if -r is given, we'll let the final link discard such sections.
     // This is compatible with GNU.
     if ((Sec.sh_flags & SHF_EXCLUDE) && !Config->Relocatable) {
-      Sections[I] = &InputSection<ELFT>::Discarded;
+      Sections[I].reset(&InputSection<ELFT>::Discarded);
       continue;
     }
 
     switch (Sec.sh_type) {
     case SHT_GROUP:
-      Sections[I] = &InputSection<ELFT>::Discarded;
+      Sections[I].reset(&InputSection<ELFT>::Discarded);
       if (ComdatGroups.insert(CachedHashStringRef(getShtGroupSignature(Sec)))
               .second)
         continue;
       for (uint32_t SecIndex : getShtGroupEntries(Sec)) {
         if (SecIndex >= Size)
           fatal(getFilename(this) + ": invalid section index in group: " +
                 Twine(SecIndex));
-        Sections[SecIndex] = &InputSection<ELFT>::Discarded;
+        Sections[SecIndex].reset(&InputSection<ELFT>::Discarded);
       }
       break;
     case SHT_SYMTAB:
       this->Symtab = &Sec;
       break;
     case SHT_SYMTAB_SHNDX:
       this->SymtabSHNDX = check(Obj.getSHNDXTable(Sec));
       break;
     case SHT_STRTAB:
     case SHT_NULL:
       break;
     default:
-      Sections[I] = createInputSection(Sec);
+      Sections[I].reset(createInputSection(Sec));
     }
   }
 }
 
 // .ARM.exidx sections have a reverse dependency on the InputSection they
 // have a SHF_LINK_ORDER dependency, this is identified by the sh_link.
 template <class ELFT>
 void elf::ObjectFile<ELFT>::initializeReverseDependencies() {
   unsigned I = -1;
   for (const Elf_Shdr &Sec : this->ELFObj.sections()) {
     ++I;
-    if ((Sections[I] == &InputSection<ELFT>::Discarded) ||
+    InputSectionBase<ELFT> *CurSec = Sections[I].get();
+    if ((CurSec == &InputSection<ELFT>::Discarded) ||
         !(Sec.sh_flags & SHF_LINK_ORDER))
       continue;
     if (Sec.sh_link >= Sections.size())
       fatal(getFilename(this) + ": invalid sh_link index: " +
             Twine(Sec.sh_link));
-    auto *IS = cast<InputSection<ELFT>>(Sections[Sec.sh_link]);
-    IS->DependentSection = Sections[I];
+    auto &IS = cast<InputSection<ELFT>>(*Sections[Sec.sh_link]);
+    IS.DependentSection = CurSec;
   }
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *
 elf::ObjectFile<ELFT>::getRelocTarget(const Elf_Shdr &Sec) {
   uint32_t Idx = Sec.sh_info;
   if (Idx >= Sections.size())
     fatal(getFilename(this) + ": invalid relocated section index: " +
           Twine(Idx));
-  InputSectionBase<ELFT> *Target = Sections[Idx];
+  InputSectionBase<ELFT> *Target = Sections[Idx].get();
 
   // Strictly speaking, a relocation section must be included in the
   // group of the section it relocates. However, LLVM 3.3 and earlier
   // would fail to do so, so we gracefully handle that case.
   if (Target == &InputSection<ELFT>::Discarded)
     return nullptr;
 
   if (!Target)
elf::ObjectFile<ELFT>::createInputSection(const Elf_Shdr &Sec) {
   case SHT_ARM_ATTRIBUTES:
     // FIXME: ARM meta-data section. At present attributes are ignored,
     // they can be used to reason about object compatibility.
     return &InputSection<ELFT>::Discarded;
   case SHT_MIPS_REGINFO:
     if (MipsReginfo)
       fatal(getFilename(this) +
             ": multiple SHT_MIPS_REGINFO sections are not allowed");
-    MipsReginfo.reset(new MipsReginfoInputSection<ELFT>(this, &Sec, Name));
-    return MipsReginfo.get();
+    MipsReginfo = new (Alloc) MipsReginfoInputSection<ELFT>(this, &Sec, Name);
+    return MipsReginfo;
   case SHT_MIPS_OPTIONS:
     if (MipsOptions)
       fatal(getFilename(this) +
             ": multiple SHT_MIPS_OPTIONS sections are not allowed");
-    MipsOptions.reset(new MipsOptionsInputSection<ELFT>(this, &Sec, Name));
-    return MipsOptions.get();
+    MipsOptions = new (Alloc) MipsOptionsInputSection<ELFT>(this, &Sec, Name);
+    return MipsOptions;
   case SHT_MIPS_ABIFLAGS:
     if (MipsAbiFlags)
       fatal(getFilename(this) +
             ": multiple SHT_MIPS_ABIFLAGS sections are not allowed");
-    MipsAbiFlags.reset(new MipsAbiFlagsInputSection<ELFT>(this, &Sec, Name));
-    return MipsAbiFlags.get();
+    MipsAbiFlags = new (Alloc) MipsAbiFlagsInputSection<ELFT>(this, &Sec, Name);
+    return MipsAbiFlags;
   case SHT_RELA:
   case SHT_REL: {
     // This section contains relocation information.
     // If -r is given, we do not interpret or apply relocation
     // but just copy relocation sections to output.
     if (Config->Relocatable)
-      return new (IAlloc.Allocate()) InputSection<ELFT>(this, &Sec, Name);
+      return new (Alloc) InputSection<ELFT>(this, &Sec, Name);
 
     // Find the relocation target section and associate this
     // section with it.
     InputSectionBase<ELFT> *Target = getRelocTarget(Sec);
     if (!Target)
       return nullptr;
     if (auto *S = dyn_cast<InputSection<ELFT>>(Target)) {
       S->RelocSections.push_back(&Sec);
elf::ObjectFile<ELFT>::createInputSection(const Elf_Shdr &Sec) {
 
   if (Config->Strip != StripPolicy::None && Name.startswith(".debug"))
     return &InputSection<ELFT>::Discarded;
 
   // The linker merges EH (exception handling) frames and creates a
   // .eh_frame_hdr section for runtime. So we handle them with a special
   // class. For relocatable outputs, they are just passed through.
   if (Name == ".eh_frame" && !Config->Relocatable)
-    return new (EHAlloc.Allocate()) EhInputSection<ELFT>(this, &Sec, Name);
+    return new (Alloc) EhInputSection<ELFT>(this, &Sec, Name);
 
   if (shouldMerge(Sec))
-    return new (MAlloc.Allocate()) MergeInputSection<ELFT>(this, &Sec, Name);
-  return new (IAlloc.Allocate()) InputSection<ELFT>(this, &Sec, Name);
+    return new (Alloc) MergeInputSection<ELFT>(this, &Sec, Name);
+  return new (Alloc) InputSection<ELFT>(this, &Sec, Name);
 }
 
 template <class ELFT> void elf::ObjectFile<ELFT>::initializeSymbols() {
   this->initStringTable();
   Elf_Sym_Range Syms = this->getElfSymbols(false);
   uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
   SymbolBodies.reserve(NumSymbols);
   for (const Elf_Sym &Sym : Syms)
     SymbolBodies.push_back(createSymbolBody(&Sym));
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *
 elf::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
   uint32_t Index = this->getSectionIndex(Sym);
   if (Index >= Sections.size())
     fatal(getFilename(this) + ": invalid section index: " + Twine(Index));
-  InputSectionBase<ELFT> *S = Sections[Index];
+  InputSectionBase<ELFT> *S = Sections[Index].get();
 
   // We found that GNU assembler 2.17.50 [FreeBSD] 2007-07-03
   // could generate broken objects. STT_SECTION symbols can be
   // associated with SHT_REL[A]/SHT_SYMTAB/SHT_STRTAB sections.
   // In this case it is fine for section to be null here as we
   // do not allocate sections of these types.
   if (!S) {
     if (Index == 0 || Sym.getType() == STT_SECTION)

ELF/InputSection.cpp

 typename ELFT::uint
 InputSectionBase<ELFT>::getOffset(const DefinedRegular<ELFT> &Sym) const {
   return getOffset(Sym.Value);
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *InputSectionBase<ELFT>::getLinkOrderDep() const {
   if ((Flags & SHF_LINK_ORDER) && Link != 0)
-    return getFile()->getSections()[Link];
+    return getFile()->getSections()[Link].get();
   return nullptr;
 }
 
 template <class ELFT>
 InputSection<ELFT>::InputSection(uintX_t Flags, uint32_t Type,
                                  uintX_t Addralign, ArrayRef<uint8_t> Data)
     : InputSectionBase<ELFT>(nullptr, Flags, Type,
                              /*Entsize*/ 0, /*Link*/ 0, /*Info*/ 0, Addralign,
                              Data, "", Base::Regular) {}
 
 template <class ELFT>
 InputSection<ELFT>::InputSection(elf::ObjectFile<ELFT> *F,
                                  const Elf_Shdr *Header, StringRef Name)
     : InputSectionBase<ELFT>(F, Header, Name, Base::Regular) {}
 
 template <class ELFT>
 bool InputSection<ELFT>::classof(const InputSectionData *S) {
   return S->kind() == Base::Regular;
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *InputSection<ELFT>::getRelocatedSection() {
   assert(this->Type == SHT_RELA || this->Type == SHT_REL);
-  ArrayRef<InputSectionBase<ELFT> *> Sections = this->File->getSections();
-  return Sections[this->Info];
+  return this->File->getSections()[this->Info].get();
 }
 
 template <class ELFT> void InputSection<ELFT>::addThunk(const Thunk<ELFT> *T) {
   Thunks.push_back(T);
 }
 
 template <class ELFT> uint64_t InputSection<ELFT>::getThunkOff() const {
   return this->Data.size();

ELF/LinkerScript.cpp

void LinkerScript<ELFT>::computeInputSections(InputSectionDescription *I) {
   // and attach them to I.
   for (SectionPattern &Pat : I->SectionPatterns) {
     size_t SizeBefore = I->Sections.size();
     for (ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles()) {
       StringRef Filename = sys::path::filename(F->getName());
       if (!I->FileRe.match(Filename) || Pat.ExcludedFileRe.match(Filename))
         continue;
 
-      for (InputSectionBase<ELFT> *S : F->getSections())
+      for (const auto &Iter : F->getSections()) {
+        InputSectionBase<ELFT> *S = Iter.get();
         if (!isDiscarded(S) && !S->OutSec && Pat.SectionRe.match(S->Name))
           I->Sections.push_back(S);
+      }
       if (Pat.SectionRe.match("COMMON"))
         I->Sections.push_back(InputSection<ELFT>::CommonInputSection);
     }
 
     // Sort sections as instructed by SORT-family commands and --sort-section
     // option. Because SORT-family commands can be nested at most two depth
     // (e.g. SORT_BY_NAME(SORT_BY_ALIGNMENT(.text.*))) and because the command
     // line option is respected even if a SORT command is given, the exact
void LinkerScript<ELFT>::processCommands(OutputSectionFactory<ELFT> &Factory) {
   }
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::createSections(OutputSectionFactory<ELFT> &Factory) {
   processCommands(Factory);
   // Add orphan sections.
   for (ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles())
-    for (InputSectionBase<ELFT> *S : F->getSections())
+    for (const auto &Iter : F->getSections()) {
+      InputSectionBase<ELFT> *S = Iter.get();
       if (!isDiscarded(S) && !S->OutSec)
         addSection(Factory, S, getOutputSectionName(S->Name, Opt.Alloc));
     }
+}
 
 // Sets value of a section-defined symbol. Two kinds of
 // symbols are processed: synthetic symbols, whose value
 // is an offset from beginning of section and regular
 // symbols whose value is absolute.
 template <class ELFT>
 static void assignSectionSymbol(SymbolAssignment *Cmd,
                                 OutputSectionBase<ELFT> *Sec,

ELF/MarkLive.cpp

template <class ELFT> void elf::markLive() {
   // file can interrupt other ELF file's symbols at runtime.
   for (const Symbol *S : Symtab<ELFT>::X->getSymbols())
     if (S->includeInDynsym())
       MarkSymbol(S->body());
 
   // Preserve special sections and those which are specified in linker
   // script KEEP command.
   for (ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles()) {
-    for (InputSectionBase<ELFT> *Sec : F->getSections()) {
+    for (const auto &Iter : F->getSections()) {
+      InputSectionBase<ELFT> *Sec = Iter.get();
       if (!Sec || Sec == &InputSection<ELFT>::Discarded)
         continue;
       // .eh_frame is always marked as live now, but also it can reference to
       // sections that contain personality. We preserve all non-text sections
       // referred by .eh_frame here.
       if (auto *EH = dyn_cast_or_null<EhInputSection<ELFT>>(Sec))
         scanEhFrameSection<ELFT>(*EH, Enqueue);
       if (isReserved(Sec) || Script<ELFT>::X->shouldKeep(Sec))

ELF/Writer.cpp

if (S)
     reinterpret_cast<OutputSection<ELFT> *>(S)->sortCtorsDtors();
 }
 
 template <class ELFT>
 void Writer<ELFT>::forEachRelSec(
     std::function<void(InputSectionBase<ELFT> &, const typename ELFT::Shdr &)>
         Fn) {
   for (elf::ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles()) {
-    for (InputSectionBase<ELFT> *IS : F->getSections()) {
+    for (const auto &Iter : F->getSections()) {
+      InputSectionBase<ELFT> *IS = Iter.get();
       if (isDiscarded(IS))
         continue;
       // Scan all relocations. Each relocation goes through a series
       // of tests to determine if it needs special treatment, such as
       // creating GOT, PLT, copy relocations, etc.
       // Note that relocations for non-alloc sections are directly
       // processed by InputSection::relocateNonAlloc.
       if (!(IS->Flags & SHF_ALLOC))
         continue;
       if (auto *S = dyn_cast<InputSection<ELFT>>(IS)) {
         for (const Elf_Shdr *RelSec : S->RelocSections)
           Fn(*S, *RelSec);
         continue;
       }
       if (auto *S = dyn_cast<EhInputSection<ELFT>>(IS))
         if (S->RelocSection)
           Fn(*S, *S->RelocSection);
     }
   }
 }
 
 template <class ELFT> void Writer<ELFT>::createSections() {
   for (elf::ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles()) {
-    for (InputSectionBase<ELFT> *IS : F->getSections()) {
+    for (const auto &Iter : F->getSections()) {
+      InputSectionBase<ELFT> *IS = Iter.get();
       if (isDiscarded(IS)) {
         reportDiscarded(IS);
         continue;
       }
       OutputSectionBase<ELFT> *Sec;
       bool IsNew;
       StringRef OutsecName = getOutputSectionName(IS->Name, Alloc);
       std::tie(Sec, IsNew) = Factory.create(IS, OutsecName);