Revert "[ELF] Make Partition/InStruct members unique_ptr and remove associate make<XXX>"

This reverts commit e48b1c8a27. This reverts commit d019de23a1. The changes caused memory leaks (non-final classes cannot use unique_ptr).
2026-01-20 10:58:11 +08:00 · 2021-12-22 23:55:11 -08:00
parent d39d2acfdd
commit ad26b0b233
7 changed files with 118 additions and 131 deletions
--- a/lld/ELF/Driver.cpp
+++ b/lld/ELF/Driver.cpp
@@ -99,8 +99,7 @@ bool elf::link(ArrayRef<const char *> args, bool canExitEarly,
    tar = nullptr;
    memset(&in, 0, sizeof(in));

-    partitions.clear();
-    partitions.emplace_back();
+    partitions = {Partition()};

    SharedFile::vernauxNum = 0;
  };
@@ -117,8 +116,7 @@ bool elf::link(ArrayRef<const char *> args, bool canExitEarly,
  script = std::make_unique<LinkerScript>();
  symtab = std::make_unique<SymbolTable>();

-  partitions.clear();
-  partitions.emplace_back();
+  partitions = {Partition()};

  config->progName = args[0];

--- a/lld/ELF/InputFiles.cpp
+++ b/lld/ELF/InputFiles.cpp
@@ -878,8 +878,8 @@ InputSectionBase *ObjFile<ELFT>::createInputSection(uint32_t idx,
      // to work. In a full implementation we would merge all attribute
      // sections.
      if (in.attributes == nullptr) {
-        in.attributes = std::make_unique<InputSection>(*this, sec, name);
-        return in.attributes.get();
+        in.attributes = make<InputSection>(*this, sec, name);
+        return in.attributes;
      }
      return &InputSection::discarded;
    }
@@ -900,8 +900,8 @@ InputSectionBase *ObjFile<ELFT>::createInputSection(uint32_t idx,
      // standard extensions to enable. In a full implementation we would merge
      // all attribute sections.
      if (in.attributes == nullptr) {
-        in.attributes = std::make_unique<InputSection>(*this, sec, name);
-        return in.attributes.get();
+        in.attributes = make<InputSection>(*this, sec, name);
+        return in.attributes;
      }
      return &InputSection::discarded;
    }
--- a/lld/ELF/LinkerScript.cpp
+++ b/lld/ELF/LinkerScript.cpp
@@ -561,15 +561,15 @@ LinkerScript::computeInputSections(const InputSectionDescription *cmd,
 }

 void LinkerScript::discard(InputSectionBase &s) {
-  if (&s == in.shStrTab.get() || &s == mainPart->relrDyn.get())
+  if (&s == in.shStrTab || &s == mainPart->relrDyn)
    error("discarding " + s.name + " section is not allowed");

  // You can discard .hash and .gnu.hash sections by linker scripts. Since
  // they are synthesized sections, we need to handle them differently than
  // other regular sections.
-  if (&s == mainPart->gnuHashTab.get())
+  if (&s == mainPart->gnuHashTab)
    mainPart->gnuHashTab = nullptr;
-  if (&s == mainPart->hashTab.get())
+  if (&s == mainPart->hashTab)
    mainPart->hashTab = nullptr;

  s.markDead();
--- a/lld/ELF/Relocations.cpp
+++ b/lld/ELF/Relocations.cpp
@@ -870,7 +870,7 @@ static void addGotEntry(Symbol &sym) {

  // If preemptible, emit a GLOB_DAT relocation.
  if (sym.isPreemptible) {
-    mainPart->relaDyn->addReloc({target->gotRel, in.got.get(), off,
+    mainPart->relaDyn->addReloc({target->gotRel, in.got, off,
                                 DynamicReloc::AgainstSymbol, sym, 0, R_ABS});
    return;
  }
@@ -1205,8 +1205,8 @@ handleTlsRelocation(RelType type, Symbol &sym, InputSectionBase &c,
        in.got->relocations.push_back(
            {R_ADDEND, target->symbolicRel, in.got->getTlsIndexOff(), 1, &sym});
      else
-        mainPart->relaDyn->addReloc({target->tlsModuleIndexRel, in.got.get(),
-                                     in.got->getTlsIndexOff()});
+        mainPart->relaDyn->addReloc(
+            {target->tlsModuleIndexRel, in.got, in.got->getTlsIndexOff()});
    }
    c.relocations.push_back({expr, type, offset, addend, &sym});
    return 1;
@@ -1592,7 +1592,7 @@ static bool handleNonPreemptibleIfunc(Symbol &sym) {
  if (sym.hasDirectReloc) {
    // Change the value to the IPLT and redirect all references to it.
    auto &d = cast<Defined>(sym);
-    d.section = in.iplt.get();
+    d.section = in.iplt;
    d.value = sym.pltIndex * target->ipltEntrySize;
    d.size = 0;
    // It's important to set the symbol type here so that dynamic loaders
--- a/lld/ELF/SyntheticSections.cpp
+++ b/lld/ELF/SyntheticSections.cpp
@@ -1265,11 +1265,11 @@ DynamicSection<ELFT>::DynamicSection()
 //   .rela.dyn
 //
 // DT_RELASZ is the total size of the included sections.
-static uint64_t addRelaSz(const RelocationBaseSection &relaDyn) {
-  size_t size = relaDyn.getSize();
-  if (in.relaIplt->getParent() == relaDyn.getParent())
+static uint64_t addRelaSz(RelocationBaseSection *relaDyn) {
+  size_t size = relaDyn->getSize();
+  if (in.relaIplt->getParent() == relaDyn->getParent())
    size += in.relaIplt->getSize();
-  if (in.relaPlt->getParent() == relaDyn.getParent())
+  if (in.relaPlt->getParent() == relaDyn->getParent())
    size += in.relaPlt->getSize();
  return size;
 }
@@ -1375,8 +1375,7 @@ DynamicSection<ELFT>::computeContents() {
      (in.relaIplt->isNeeded() &&
       part.relaDyn->getParent() == in.relaIplt->getParent())) {
    addInSec(part.relaDyn->dynamicTag, *part.relaDyn);
-    entries.emplace_back(part.relaDyn->sizeDynamicTag,
-                         addRelaSz(*part.relaDyn));
+    entries.emplace_back(part.relaDyn->sizeDynamicTag, addRelaSz(part.relaDyn));

    bool isRela = config->isRela;
    addInt(isRela ? DT_RELAENT : DT_RELENT,
@@ -1627,7 +1626,7 @@ void RelocationBaseSection::addReloc(const DynamicReloc &reloc) {
 }

 void RelocationBaseSection::finalizeContents() {
-  SymbolTableBaseSection *symTab = getPartition().dynSymTab.get();
+  SymbolTableBaseSection *symTab = getPartition().dynSymTab;

  // When linking glibc statically, .rel{,a}.plt contains R_*_IRELATIVE
  // relocations due to IFUNC (e.g. strcpy). sh_link will be set to 0 in that
@@ -1637,11 +1636,11 @@ void RelocationBaseSection::finalizeContents() {
  else
    getParent()->link = 0;

-  if (in.relaPlt.get() == this && in.gotPlt->getParent()) {
+  if (in.relaPlt == this && in.gotPlt->getParent()) {
    getParent()->flags |= ELF::SHF_INFO_LINK;
    getParent()->info = in.gotPlt->getParent()->sectionIndex;
  }
-  if (in.relaIplt.get() == this && in.igotPlt->getParent()) {
+  if (in.relaIplt == this && in.igotPlt->getParent()) {
    getParent()->flags |= ELF::SHF_INFO_LINK;
    getParent()->info = in.igotPlt->getParent()->sectionIndex;
  }
@@ -1678,7 +1677,7 @@ RelocationSection<ELFT>::RelocationSection(StringRef name, bool sort)
 }

 template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *buf) {
-  SymbolTableBaseSection *symTab = getPartition().dynSymTab.get();
+  SymbolTableBaseSection *symTab = getPartition().dynSymTab;

  parallelForEach(relocs,
                  [symTab](DynamicReloc &rel) { rel.computeRaw(symTab); });
@@ -1773,8 +1772,8 @@ bool AndroidPackedRelocationSection<ELFT>::updateAllocSize() {
  for (const DynamicReloc &rel : relocs) {
    Elf_Rela r;
    r.r_offset = rel.getOffset();
-    r.setSymbolAndType(rel.getSymIndex(getPartition().dynSymTab.get()),
-                       rel.type, false);
+    r.setSymbolAndType(rel.getSymIndex(getPartition().dynSymTab), rel.type,
+                       false);
    if (config->isRela)
      r.r_addend = rel.computeAddend();

@@ -2100,7 +2099,7 @@ void SymbolTableBaseSection::finalizeContents() {

  // Only the main partition's dynsym indexes are stored in the symbols
  // themselves. All other partitions use a lookup table.
-  if (this == mainPart->dynSymTab.get()) {
+  if (this == mainPart->dynSymTab) {
    size_t i = 0;
    for (const SymbolTableEntry &s : symbols)
      s.sym->dynsymIndex = ++i;
@@ -2147,7 +2146,7 @@ void SymbolTableBaseSection::addSymbol(Symbol *b) {
 }

 size_t SymbolTableBaseSection::getSymbolIndex(Symbol *sym) {
-  if (this == mainPart->dynSymTab.get())
+  if (this == mainPart->dynSymTab)
    return sym->dynsymIndex;

  // Initializes symbol lookup tables lazily. This is used only for -r,
@@ -2482,7 +2481,7 @@ HashTableSection::HashTableSection()
 }

 void HashTableSection::finalizeContents() {
-  SymbolTableBaseSection *symTab = getPartition().dynSymTab.get();
+  SymbolTableBaseSection *symTab = getPartition().dynSymTab;

  if (OutputSection *sec = symTab->getParent())
    getParent()->link = sec->sectionIndex;
@@ -2496,7 +2495,7 @@ void HashTableSection::finalizeContents() {
 }

 void HashTableSection::writeTo(uint8_t *buf) {
-  SymbolTableBaseSection *symTab = getPartition().dynSymTab.get();
+  SymbolTableBaseSection *symTab = getPartition().dynSymTab;

  // See comment in GnuHashTableSection::writeTo.
  memset(buf, 0, size);
@@ -3802,9 +3801,8 @@ void PartitionIndexSection::writeTo(uint8_t *buf) {
    write32(buf, mainPart->dynStrTab->getVA() + partitions[i].nameStrTab - va);
    write32(buf + 4, partitions[i].elfHeader->getVA() - (va + 4));

-    SyntheticSection *next = i == partitions.size() - 1
-                                 ? in.partEnd.get()
-                                 : partitions[i + 1].elfHeader.get();
+    SyntheticSection *next =
+        i == partitions.size() - 1 ? in.partEnd : partitions[i + 1].elfHeader;
    write32(buf + 8, next->getVA() - partitions[i].elfHeader->getVA());

    va += 12;
--- a/lld/ELF/SyntheticSections.h
+++ b/lld/ELF/SyntheticSections.h
@@ -1203,24 +1203,24 @@ struct Partition {
  StringRef name;
  uint64_t nameStrTab;

-  std::unique_ptr<SyntheticSection> elfHeader;
-  std::unique_ptr<SyntheticSection> programHeaders;
+  SyntheticSection *elfHeader;
+  SyntheticSection *programHeaders;
  std::vector<PhdrEntry *> phdrs;

-  std::unique_ptr<ARMExidxSyntheticSection> armExidx;
-  std::unique_ptr<BuildIdSection> buildId;
-  std::unique_ptr<SyntheticSection> dynamic;
-  std::unique_ptr<StringTableSection> dynStrTab;
-  std::unique_ptr<SymbolTableBaseSection> dynSymTab;
-  std::unique_ptr<EhFrameHeader> ehFrameHdr;
-  std::unique_ptr<EhFrameSection> ehFrame;
-  std::unique_ptr<GnuHashTableSection> gnuHashTab;
-  std::unique_ptr<HashTableSection> hashTab;
-  std::unique_ptr<RelocationBaseSection> relaDyn;
-  std::unique_ptr<RelrBaseSection> relrDyn;
-  std::unique_ptr<VersionDefinitionSection> verDef;
-  std::unique_ptr<SyntheticSection> verNeed;
-  std::unique_ptr<VersionTableSection> verSym;
+  ARMExidxSyntheticSection *armExidx;
+  BuildIdSection *buildId;
+  SyntheticSection *dynamic;
+  StringTableSection *dynStrTab;
+  SymbolTableBaseSection *dynSymTab;
+  EhFrameHeader *ehFrameHdr;
+  EhFrameSection *ehFrame;
+  GnuHashTableSection *gnuHashTab;
+  HashTableSection *hashTab;
+  RelocationBaseSection *relaDyn;
+  RelrBaseSection *relrDyn;
+  VersionDefinitionSection *verDef;
+  SyntheticSection *verNeed;
+  VersionTableSection *verSym;

  unsigned getNumber() const { return this - &partitions[0] + 1; }
 };
@@ -1235,27 +1235,27 @@ inline Partition &SectionBase::getPartition() const {
 // Linker generated sections which can be used as inputs and are not specific to
 // a partition.
 struct InStruct {
-  std::unique_ptr<InputSection> attributes;
-  std::unique_ptr<BssSection> bss;
-  std::unique_ptr<BssSection> bssRelRo;
-  std::unique_ptr<GotSection> got;
-  std::unique_ptr<GotPltSection> gotPlt;
-  std::unique_ptr<IgotPltSection> igotPlt;
-  std::unique_ptr<PPC64LongBranchTargetSection> ppc64LongBranchTarget;
-  std::unique_ptr<MipsGotSection> mipsGot;
-  std::unique_ptr<MipsRldMapSection> mipsRldMap;
-  std::unique_ptr<SyntheticSection> partEnd;
-  std::unique_ptr<SyntheticSection> partIndex;
-  std::unique_ptr<PltSection> plt;
-  std::unique_ptr<IpltSection> iplt;
-  std::unique_ptr<PPC32Got2Section> ppc32Got2;
-  std::unique_ptr<IBTPltSection> ibtPlt;
-  std::unique_ptr<RelocationBaseSection> relaPlt;
-  std::unique_ptr<RelocationBaseSection> relaIplt;
-  std::unique_ptr<StringTableSection> shStrTab;
-  std::unique_ptr<StringTableSection> strTab;
-  std::unique_ptr<SymbolTableBaseSection> symTab;
-  std::unique_ptr<SymtabShndxSection> symTabShndx;
+  InputSection *attributes;
+  BssSection *bss;
+  BssSection *bssRelRo;
+  GotSection *got;
+  GotPltSection *gotPlt;
+  IgotPltSection *igotPlt;
+  PPC64LongBranchTargetSection *ppc64LongBranchTarget;
+  MipsGotSection *mipsGot;
+  MipsRldMapSection *mipsRldMap;
+  SyntheticSection *partEnd;
+  SyntheticSection *partIndex;
+  PltSection *plt;
+  IpltSection *iplt;
+  PPC32Got2Section *ppc32Got2;
+  IBTPltSection *ibtPlt;
+  RelocationBaseSection *relaPlt;
+  RelocationBaseSection *relaIplt;
+  StringTableSection *shStrTab;
+  StringTableSection *strTab;
+  SymbolTableBaseSection *symTab;
+  SymtabShndxSection *symTabShndx;
 };

 extern InStruct in;
--- a/lld/ELF/Writer.cpp
+++ b/lld/ELF/Writer.cpp
@@ -299,18 +299,18 @@ template <class ELFT> void elf::createSyntheticSections() {

  auto add = [](SyntheticSection &sec) { inputSections.push_back(&sec); };

-  in.shStrTab = std::make_unique<StringTableSection>(".shstrtab", false);
+  in.shStrTab = make<StringTableSection>(".shstrtab", false);

  Out::programHeaders = make<OutputSection>("", 0, SHF_ALLOC);
  Out::programHeaders->alignment = config->wordsize;

  if (config->strip != StripPolicy::All) {
-    in.strTab = std::make_unique<StringTableSection>(".strtab", false);
-    in.symTab = std::make_unique<SymbolTableSection<ELFT>>(*in.strTab);
-    in.symTabShndx = std::make_unique<SymtabShndxSection>();
+    in.strTab = make<StringTableSection>(".strtab", false);
+    in.symTab = make<SymbolTableSection<ELFT>>(*in.strTab);
+    in.symTabShndx = make<SymtabShndxSection>();
  }

-  in.bss = std::make_unique<BssSection>(".bss", 0, 1);
+  in.bss = make<BssSection>(".bss", 0, 1);
  add(*in.bss);

  // If there is a SECTIONS command and a .data.rel.ro section name use name
@@ -318,14 +318,14 @@ template <class ELFT> void elf::createSyntheticSections() {
  // This makes sure our relro is contiguous.
  bool hasDataRelRo =
      script->hasSectionsCommand && findSection(".data.rel.ro", 0);
-  in.bssRelRo = std::make_unique<BssSection>(
-      hasDataRelRo ? ".data.rel.ro.bss" : ".bss.rel.ro", 0, 1);
+  in.bssRelRo =
+      make<BssSection>(hasDataRelRo ? ".data.rel.ro.bss" : ".bss.rel.ro", 0, 1);
  add(*in.bssRelRo);

  // Add MIPS-specific sections.
  if (config->emachine == EM_MIPS) {
    if (!config->shared && config->hasDynSymTab) {
-      in.mipsRldMap = std::make_unique<MipsRldMapSection>();
+      in.mipsRldMap = make<MipsRldMapSection>();
      add(*in.mipsRldMap);
    }
    if (auto *sec = MipsAbiFlagsSection<ELFT>::create())
@@ -345,52 +345,49 @@ template <class ELFT> void elf::createSyntheticSections() {
    };

    if (!part.name.empty()) {
-      part.elfHeader = std::make_unique<PartitionElfHeaderSection<ELFT>>();
+      part.elfHeader = make<PartitionElfHeaderSection<ELFT>>();
      part.elfHeader->name = part.name;
      add(*part.elfHeader);

-      part.programHeaders =
-          std::make_unique<PartitionProgramHeadersSection<ELFT>>();
+      part.programHeaders = make<PartitionProgramHeadersSection<ELFT>>();
      add(*part.programHeaders);
    }

    if (config->buildId != BuildIdKind::None) {
-      part.buildId = std::make_unique<BuildIdSection>();
+      part.buildId = make<BuildIdSection>();
      add(*part.buildId);
    }

-    part.dynStrTab = std::make_unique<StringTableSection>(".dynstr", true);
-    part.dynSymTab =
-        std::make_unique<SymbolTableSection<ELFT>>(*part.dynStrTab);
-    part.dynamic = std::make_unique<DynamicSection<ELFT>>();
+    part.dynStrTab = make<StringTableSection>(".dynstr", true);
+    part.dynSymTab = make<SymbolTableSection<ELFT>>(*part.dynStrTab);
+    part.dynamic = make<DynamicSection<ELFT>>();
    if (config->androidPackDynRelocs)
-      part.relaDyn =
-          std::make_unique<AndroidPackedRelocationSection<ELFT>>(relaDynName);
+      part.relaDyn = make<AndroidPackedRelocationSection<ELFT>>(relaDynName);
    else
-      part.relaDyn = std::make_unique<RelocationSection<ELFT>>(
-          relaDynName, config->zCombreloc);
+      part.relaDyn =
+          make<RelocationSection<ELFT>>(relaDynName, config->zCombreloc);

    if (config->hasDynSymTab) {
      add(*part.dynSymTab);

-      part.verSym = std::make_unique<VersionTableSection>();
+      part.verSym = make<VersionTableSection>();
      add(*part.verSym);

      if (!namedVersionDefs().empty()) {
-        part.verDef = std::make_unique<VersionDefinitionSection>();
+        part.verDef = make<VersionDefinitionSection>();
        add(*part.verDef);
      }

-      part.verNeed = std::make_unique<VersionNeedSection<ELFT>>();
+      part.verNeed = make<VersionNeedSection<ELFT>>();
      add(*part.verNeed);

      if (config->gnuHash) {
-        part.gnuHashTab = std::make_unique<GnuHashTableSection>();
+        part.gnuHashTab = make<GnuHashTableSection>();
        add(*part.gnuHashTab);
      }

      if (config->sysvHash) {
-        part.hashTab = std::make_unique<HashTableSection>();
+        part.hashTab = make<HashTableSection>();
        add(*part.hashTab);
      }

@@ -400,23 +397,23 @@ template <class ELFT> void elf::createSyntheticSections() {
    }

    if (config->relrPackDynRelocs) {
-      part.relrDyn = std::make_unique<RelrSection<ELFT>>();
+      part.relrDyn = make<RelrSection<ELFT>>();
      add(*part.relrDyn);
    }

    if (!config->relocatable) {
      if (config->ehFrameHdr) {
-        part.ehFrameHdr = std::make_unique<EhFrameHeader>();
+        part.ehFrameHdr = make<EhFrameHeader>();
        add(*part.ehFrameHdr);
      }
-      part.ehFrame = std::make_unique<EhFrameSection>();
+      part.ehFrame = make<EhFrameSection>();
      add(*part.ehFrame);
    }

    if (config->emachine == EM_ARM && !config->relocatable) {
      // The ARMExidxsyntheticsection replaces all the individual .ARM.exidx
      // InputSections.
-      part.armExidx = std::make_unique<ARMExidxSyntheticSection>();
+      part.armExidx = make<ARMExidxSyntheticSection>();
      add(*part.armExidx);
    }
  }
@@ -425,14 +422,13 @@ template <class ELFT> void elf::createSyntheticSections() {
    // Create the partition end marker. This needs to be in partition number 255
    // so that it is sorted after all other partitions. It also has other
    // special handling (see createPhdrs() and combineEhSections()).
-    in.partEnd =
-        std::make_unique<BssSection>(".part.end", config->maxPageSize, 1);
+    in.partEnd = make<BssSection>(".part.end", config->maxPageSize, 1);
    in.partEnd->partition = 255;
    add(*in.partEnd);

-    in.partIndex = std::make_unique<PartitionIndexSection>();
-    addOptionalRegular("__part_index_begin", in.partIndex.get(), 0);
-    addOptionalRegular("__part_index_end", in.partIndex.get(),
+    in.partIndex = make<PartitionIndexSection>();
+    addOptionalRegular("__part_index_begin", in.partIndex, 0);
+    addOptionalRegular("__part_index_end", in.partIndex,
                       in.partIndex->getSize());
    add(*in.partIndex);
  }
@@ -440,26 +436,26 @@ template <class ELFT> void elf::createSyntheticSections() {
  // Add .got. MIPS' .got is so different from the other archs,
  // it has its own class.
  if (config->emachine == EM_MIPS) {
-    in.mipsGot = std::make_unique<MipsGotSection>();
+    in.mipsGot = make<MipsGotSection>();
    add(*in.mipsGot);
  } else {
-    in.got = std::make_unique<GotSection>();
+    in.got = make<GotSection>();
    add(*in.got);
  }

  if (config->emachine == EM_PPC) {
-    in.ppc32Got2 = std::make_unique<PPC32Got2Section>();
+    in.ppc32Got2 = make<PPC32Got2Section>();
    add(*in.ppc32Got2);
  }

  if (config->emachine == EM_PPC64) {
-    in.ppc64LongBranchTarget = std::make_unique<PPC64LongBranchTargetSection>();
+    in.ppc64LongBranchTarget = make<PPC64LongBranchTargetSection>();
    add(*in.ppc64LongBranchTarget);
  }

-  in.gotPlt = std::make_unique<GotPltSection>();
+  in.gotPlt = make<GotPltSection>();
  add(*in.gotPlt);
-  in.igotPlt = std::make_unique<IgotPltSection>();
+  in.igotPlt = make<IgotPltSection>();
  add(*in.igotPlt);

  // _GLOBAL_OFFSET_TABLE_ is defined relative to either .got.plt or .got. Treat
@@ -476,7 +472,7 @@ template <class ELFT> void elf::createSyntheticSections() {

  // We always need to add rel[a].plt to output if it has entries.
  // Even for static linking it can contain R_[*]_IRELATIVE relocations.
-  in.relaPlt = std::make_unique<RelocationSection<ELFT>>(
+  in.relaPlt = make<RelocationSection<ELFT>>(
      config->isRela ? ".rela.plt" : ".rel.plt", /*sort=*/false);
  add(*in.relaPlt);

@@ -486,23 +482,21 @@ template <class ELFT> void elf::createSyntheticSections() {
  // that would cause a section type mismatch. However, because the Android
  // dynamic loader reads .rel.plt after .rel.dyn, we can get the desired
  // behaviour by placing the iplt section in .rel.plt.
-  in.relaIplt = std::make_unique<RelocationSection<ELFT>>(
+  in.relaIplt = make<RelocationSection<ELFT>>(
      config->androidPackDynRelocs ? in.relaPlt->name : relaDynName,
      /*sort=*/false);
  add(*in.relaIplt);

  if ((config->emachine == EM_386 || config->emachine == EM_X86_64) &&
      (config->andFeatures & GNU_PROPERTY_X86_FEATURE_1_IBT)) {
-    in.ibtPlt = std::make_unique<IBTPltSection>();
+    in.ibtPlt = make<IBTPltSection>();
    add(*in.ibtPlt);
  }

-  if (config->emachine == EM_PPC)
-    in.plt = std::make_unique<PPC32GlinkSection>();
-  else
-    in.plt = std::make_unique<PltSection>();
+  in.plt = config->emachine == EM_PPC ? make<PPC32GlinkSection>()
+                                      : make<PltSection>();
  add(*in.plt);
-  in.iplt = std::make_unique<IpltSection>();
+  in.iplt = make<IpltSection>();
  add(*in.iplt);

  if (config->andFeatures)
@@ -1072,17 +1066,17 @@ template <class ELFT> void Writer<ELFT>::setReservedSymbolSections() {
  if (ElfSym::globalOffsetTable) {
    // The _GLOBAL_OFFSET_TABLE_ symbol is defined by target convention usually
    // to the start of the .got or .got.plt section.
-    InputSection *sec = in.gotPlt.get();
+    InputSection *gotSection = in.gotPlt;
    if (!target->gotBaseSymInGotPlt)
-      sec = in.mipsGot.get() ? cast<InputSection>(in.mipsGot.get())
-                             : cast<InputSection>(in.got.get());
-    ElfSym::globalOffsetTable->section = sec;
+      gotSection = in.mipsGot ? cast<InputSection>(in.mipsGot)
+                              : cast<InputSection>(in.got);
+    ElfSym::globalOffsetTable->section = gotSection;
  }

  // .rela_iplt_{start,end} mark the start and the end of in.relaIplt.
  if (ElfSym::relaIpltStart && in.relaIplt->isNeeded()) {
-    ElfSym::relaIpltStart->section = in.relaIplt.get();
-    ElfSym::relaIpltEnd->section = in.relaIplt.get();
+    ElfSym::relaIpltStart->section = in.relaIplt;
+    ElfSym::relaIpltEnd->section = in.relaIplt;
    ElfSym::relaIpltEnd->value = in.relaIplt->getSize();
  }

@@ -1650,9 +1644,6 @@ static void finalizeSynthetic(SyntheticSection *sec) {
    sec->finalizeContents();
  }
 }
-template <typename T> static void finalizeSynthetic(std::unique_ptr<T> &sec) {
-  finalizeSynthetic(sec.get());
-}

 // We need to generate and finalize the content that depends on the address of
 // InputSections. As the generation of the content may also alter InputSection
@@ -1889,9 +1880,9 @@ template <class ELFT> void Writer<ELFT>::finalizeSections() {
  // Even the author of gold doesn't remember why gold behaves that way.
  // https://sourceware.org/ml/binutils/2002-03/msg00360.html
  if (mainPart->dynamic->parent)
-    symtab->addSymbol(
-        Defined{/*file=*/nullptr, "_DYNAMIC", STB_WEAK, STV_HIDDEN, STT_NOTYPE,
-                /*value=*/0, /*size=*/0, mainPart->dynamic.get()});
+    symtab->addSymbol(Defined{/*file=*/nullptr, "_DYNAMIC", STB_WEAK,
+                              STV_HIDDEN, STT_NOTYPE,
+                              /*value=*/0, /*size=*/0, mainPart->dynamic});

  // Define __rel[a]_iplt_{start,end} symbols if needed.
  addRelIpltSymbols();