SyntheticSections.cpp

//===- SyntheticSections.cpp ----------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file contains linker-synthesized sections. Currently,
// synthetic sections are created either output sections or input sections,
// but we are rewriting code so that all synthetic sections are created as
// input sections.
//
//===----------------------------------------------------------------------===//

#include"SyntheticSections.h"
#include"Config.h"
#include"DWARF.h"
#include"EhFrame.h"
#include"InputFiles.h"
#include"LinkerScript.h"
#include"OutputSections.h"
#include"SymbolTable.h"
#include"Symbols.h"
#include"Target.h"
#include"Thunks.h"
#include"Writer.h"
#include"lld/Common/CommonLinkerContext.h"
#include"lld/Common/DWARF.h"
#include"lld/Common/Strings.h"
#include"lld/Common/Version.h"
#include"llvm/ADT/STLExtras.h"
#include"llvm/ADT/Sequence.h"
#include"llvm/ADT/SetOperations.h"
#include"llvm/ADT/StringExtras.h"
#include"llvm/BinaryFormat/Dwarf.h"
#include"llvm/BinaryFormat/ELF.h"
#include"llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
#include"llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
#include"llvm/Support/DJB.h"
#include"llvm/Support/Endian.h"
#include"llvm/Support/LEB128.h"
#include"llvm/Support/Parallel.h"
#include"llvm/Support/TimeProfiler.h"
#include<cinttypes>
#include<cstdlib>

usingnamespacellvm;
usingnamespacellvm::dwarf;
usingnamespacellvm::ELF;
usingnamespacellvm::object;
usingnamespacellvm::support;
usingnamespacelld;
usingnamespacelld::elf;

using llvm::support::endian::read32le;
using llvm::support::endian::write32le;
using llvm::support::endian::write64le;

constexprsize_t MergeNoTailSection::numShards;

staticuint64_treadUint(Ctx &ctx, uint8_t *buf) {
return ctx.arg.is64 ? read64(ctx, buf) : read32(ctx, buf);
}

staticvoidwriteUint(Ctx &ctx, uint8_t *buf, uint64_t val) {
if (ctx.arg.is64)
write64(ctx, buf, val);
else
write32(ctx, buf, val);
}

// Returns an LLD version string.
static ArrayRef<uint8_t> getVersion(Ctx &ctx) {
// Check LLD_VERSION first for ease of testing.
// You can get consistent output by using the environment variable.
// This is only for testing.
 StringRef s = getenv("LLD_VERSION");
if (s.empty())
 s = ctx.saver.save(Twine("Linker: ") + getLLDVersion());

// +1 to include the terminating '\0'.
return {(constuint8_t *)s.data(), s.size() + 1};
}

// Creates a .comment section containing LLD version info.
// With this feature, you can identify LLD-generated binaries easily
// by "readelf --string-dump .comment <file>".
// The returned object is a mergeable string section.
MergeInputSection *elf::createCommentSection(Ctx &ctx) {
auto *sec =
 make<MergeInputSection>(ctx, ".comment", SHT_PROGBITS,
 SHF_MERGE | SHF_STRINGS, 1, getVersion(ctx));
 sec->splitIntoPieces();
return sec;
}

// .MIPS.abiflags section.
template <classELFT>
MipsAbiFlagsSection<ELFT>::MipsAbiFlagsSection(Ctx &ctx,
 Elf_Mips_ABIFlags flags)
 : SyntheticSection(ctx, ".MIPS.abiflags", SHT_MIPS_ABIFLAGS, SHF_ALLOC, 8),
flags(flags) {
this->entsize = sizeof(Elf_Mips_ABIFlags);
}

template <classELFT> void MipsAbiFlagsSection<ELFT>::writeTo(uint8_t *buf) {
memcpy(buf, &flags, sizeof(flags));
}

template <classELFT>
std::unique_ptr<MipsAbiFlagsSection<ELFT>>
MipsAbiFlagsSection<ELFT>::create(Ctx &ctx) {
 Elf_Mips_ABIFlags flags = {};
bool create = false;

for (InputSectionBase *sec : ctx.inputSections) {
if (sec->type != SHT_MIPS_ABIFLAGS)
continue;
 sec->markDead();
 create = true;

constsize_t size = sec->content().size();
// Older version of BFD (such as the default FreeBSD linker) concatenate
// .MIPS.abiflags instead of merging. To allow for this case (or potential
// zero padding) we ignore everything after the first Elf_Mips_ABIFlags
if (size < sizeof(Elf_Mips_ABIFlags)) {
Err(ctx) << sec->file << ": invalid size of .MIPS.abiflags section: got "
 << size << " instead of " << sizeof(Elf_Mips_ABIFlags);
returnnullptr;
 }
auto *s =
reinterpret_cast<const Elf_Mips_ABIFlags *>(sec->content().data());
if (s->version != 0) {
Err(ctx) << sec->file << ": unexpected .MIPS.abiflags version "
 << s->version;
returnnullptr;
 }

// LLD checks ISA compatibility in calcMipsEFlags(). Here we just
// select the highest number of ISA/Rev/Ext.
 flags.isa_level = std::max(flags.isa_level, s->isa_level);
 flags.isa_rev = std::max(flags.isa_rev, s->isa_rev);
 flags.isa_ext = std::max(flags.isa_ext, s->isa_ext);
 flags.gpr_size = std::max(flags.gpr_size, s->gpr_size);
 flags.cpr1_size = std::max(flags.cpr1_size, s->cpr1_size);
 flags.cpr2_size = std::max(flags.cpr2_size, s->cpr2_size);
 flags.ases |= s->ases;
 flags.flags1 |= s->flags1;
 flags.flags2 |= s->flags2;
 flags.fp_abi =
elf::getMipsFpAbiFlag(ctx, sec->file, flags.fp_abi, s->fp_abi);
 };

if (create)
return std::make_unique<MipsAbiFlagsSection<ELFT>>(ctx, flags);
returnnullptr;
}

// .MIPS.options section.
template <classELFT>
MipsOptionsSection<ELFT>::MipsOptionsSection(Ctx &ctx, Elf_Mips_RegInfo reginfo)
 : SyntheticSection(ctx, ".MIPS.options", SHT_MIPS_OPTIONS, SHF_ALLOC, 8),
reginfo(reginfo) {
this->entsize = sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo);
}

template <classELFT> void MipsOptionsSection<ELFT>::writeTo(uint8_t *buf) {
auto *options = reinterpret_cast<Elf_Mips_Options *>(buf);
 options->kind = ODK_REGINFO;
 options->size = getSize();

if (!ctx.arg.relocatable)
 reginfo.ri_gp_value = ctx.in.mipsGot->getGp();
memcpy(buf + sizeof(Elf_Mips_Options), &reginfo, sizeof(reginfo));
}

template <classELFT>
std::unique_ptr<MipsOptionsSection<ELFT>>
MipsOptionsSection<ELFT>::create(Ctx &ctx) {
// N64 ABI only.
if (!ELFT::Is64Bits)
returnnullptr;

 SmallVector<InputSectionBase *, 0> sections;
for (InputSectionBase *sec : ctx.inputSections)
if (sec->type == SHT_MIPS_OPTIONS)
 sections.push_back(sec);

if (sections.empty())
returnnullptr;

 Elf_Mips_RegInfo reginfo = {};
for (InputSectionBase *sec : sections) {
 sec->markDead();

 ArrayRef<uint8_t> d = sec->content();
while (!d.empty()) {
if (d.size() < sizeof(Elf_Mips_Options)) {
Err(ctx) << sec->file << ": invalid size of .MIPS.options section";
break;
 }

auto *opt = reinterpret_cast<const Elf_Mips_Options *>(d.data());
if (opt->kind == ODK_REGINFO) {
 reginfo.ri_gprmask |= opt->getRegInfo().ri_gprmask;
 sec->getFile<ELFT>()->mipsGp0 = opt->getRegInfo().ri_gp_value;
break;
 }

if (!opt->size) {
Err(ctx) << sec->file << ": zero option descriptor size";
break;
 }
 d = d.slice(opt->size);
 }
 };

return std::make_unique<MipsOptionsSection<ELFT>>(ctx, reginfo);
}

// MIPS .reginfo section.
template <classELFT>
MipsReginfoSection<ELFT>::MipsReginfoSection(Ctx &ctx, Elf_Mips_RegInfo reginfo)
 : SyntheticSection(ctx, ".reginfo", SHT_MIPS_REGINFO, SHF_ALLOC, 4),
reginfo(reginfo) {
this->entsize = sizeof(Elf_Mips_RegInfo);
}

template <classELFT> void MipsReginfoSection<ELFT>::writeTo(uint8_t *buf) {
if (!ctx.arg.relocatable)
 reginfo.ri_gp_value = ctx.in.mipsGot->getGp();
memcpy(buf, &reginfo, sizeof(reginfo));
}

template <classELFT>
std::unique_ptr<MipsReginfoSection<ELFT>>
MipsReginfoSection<ELFT>::create(Ctx &ctx) {
// Section should be alive for O32 and N32 ABIs only.
if (ELFT::Is64Bits)
returnnullptr;

 SmallVector<InputSectionBase *, 0> sections;
for (InputSectionBase *sec : ctx.inputSections)
if (sec->type == SHT_MIPS_REGINFO)
 sections.push_back(sec);

if (sections.empty())
returnnullptr;

 Elf_Mips_RegInfo reginfo = {};
for (InputSectionBase *sec : sections) {
 sec->markDead();

if (sec->content().size() != sizeof(Elf_Mips_RegInfo)) {
Err(ctx) << sec->file << ": invalid size of .reginfo section";
returnnullptr;
 }

auto *r = reinterpret_cast<const Elf_Mips_RegInfo *>(sec->content().data());
 reginfo.ri_gprmask |= r->ri_gprmask;
 sec->getFile<ELFT>()->mipsGp0 = r->ri_gp_value;
 };

return std::make_unique<MipsReginfoSection<ELFT>>(ctx, reginfo);
}

InputSection *elf::createInterpSection(Ctx &ctx) {
// StringSaver guarantees that the returned string ends with '\0'.
 StringRef s = ctx.saver.save(ctx.arg.dynamicLinker);
 ArrayRef<uint8_t> contents = {(constuint8_t *)s.data(), s.size() + 1};

return make<InputSection>(ctx.internalFile, ".interp", SHT_PROGBITS,
 SHF_ALLOC,
/*addralign=*/1, /*entsize=*/0, contents);
}

Defined *elf::addSyntheticLocal(Ctx &ctx, StringRef name, uint8_t type,
uint64_t value, uint64_t size,
 InputSectionBase &section) {
 Defined *s = makeDefined(ctx, section.file, name, STB_LOCAL, STV_DEFAULT,
 type, value, size, &section);
if (ctx.in.symTab)
 ctx.in.symTab->addSymbol(s);

if (ctx.arg.emachine == EM_ARM && !ctx.arg.isLE && ctx.arg.armBe8 &&
 (section.flags & SHF_EXECINSTR))
// Adding Linker generated mapping symbols to the arm specific mapping
// symbols list.
addArmSyntheticSectionMappingSymbol(s);

return s;
}

staticsize_tgetHashSize(Ctx &ctx) {
switch (ctx.arg.buildId) {
case BuildIdKind::Fast:
return8;
case BuildIdKind::Md5:
case BuildIdKind::Uuid:
return16;
case BuildIdKind::Sha1:
return20;
case BuildIdKind::Hexstring:
return ctx.arg.buildIdVector.size();
default:
llvm_unreachable("unknown BuildIdKind");
 }
}

// This class represents a linker-synthesized .note.gnu.property section.
//
// In x86 and AArch64, object files may contain feature flags indicating the
// features that they have used. The flags are stored in a .note.gnu.property
// section.
//
// lld reads the sections from input files and merges them by computing AND of
// the flags. The result is written as a new .note.gnu.property section.
//
// If the flag is zero (which indicates that the intersection of the feature
// sets is empty, or some input files didn't have .note.gnu.property sections),
// we don't create this section.
GnuPropertySection::GnuPropertySection(Ctx &ctx)
 : SyntheticSection(ctx, ".note.gnu.property", SHT_NOTE, SHF_ALLOC,
 ctx.arg.wordsize) {}

voidGnuPropertySection::writeTo(uint8_t *buf) {
write32(ctx, buf, 4); // Name size
write32(ctx, buf + 4, getSize() - 16); // Content size
write32(ctx, buf + 8, NT_GNU_PROPERTY_TYPE_0); // Type
memcpy(buf + 12, "GNU", 4); // Name string

uint32_t featureAndType = ctx.arg.emachine == EM_AARCH64
 ? GNU_PROPERTY_AARCH64_FEATURE_1_AND
 : GNU_PROPERTY_X86_FEATURE_1_AND;

unsigned offset = 16;
if (ctx.arg.andFeatures != 0) {
write32(ctx, buf + offset + 0, featureAndType); // Feature type
write32(ctx, buf + offset + 4, 4); // Feature size
write32(ctx, buf + offset + 8, ctx.arg.andFeatures); // Feature flags
if (ctx.arg.is64)
write32(ctx, buf + offset + 12, 0); // Padding
 offset += 16;
 }

if (!ctx.aarch64PauthAbiCoreInfo.empty()) {
write32(ctx, buf + offset + 0, GNU_PROPERTY_AARCH64_FEATURE_PAUTH);
write32(ctx, buf + offset + 4, ctx.aarch64PauthAbiCoreInfo.size());
memcpy(buf + offset + 8, ctx.aarch64PauthAbiCoreInfo.data(),
 ctx.aarch64PauthAbiCoreInfo.size());
 }
}

size_tGnuPropertySection::getSize() const {
uint32_t contentSize = 0;
if (ctx.arg.andFeatures != 0)
 contentSize += ctx.arg.is64 ? 16 : 12;
if (!ctx.aarch64PauthAbiCoreInfo.empty())
 contentSize += 4 + 4 + ctx.aarch64PauthAbiCoreInfo.size();
assert(contentSize != 0);
return contentSize + 16;
}

BuildIdSection::BuildIdSection(Ctx &ctx)
 : SyntheticSection(ctx, ".note.gnu.build-id", SHT_NOTE, SHF_ALLOC, 4),
 hashSize(getHashSize(ctx)) {}

voidBuildIdSection::writeTo(uint8_t *buf) {
write32(ctx, buf, 4); // Name size
write32(ctx, buf + 4, hashSize); // Content size
write32(ctx, buf + 8, NT_GNU_BUILD_ID); // Type
memcpy(buf + 12, "GNU", 4); // Name string
 hashBuf = buf + 16;
}

voidBuildIdSection::writeBuildId(ArrayRef<uint8_t> buf) {
assert(buf.size() == hashSize);
memcpy(hashBuf, buf.data(), hashSize);
}

BssSection::BssSection(Ctx &ctx, StringRef name, uint64_t size,
uint32_t alignment)
 : SyntheticSection(ctx, name, SHT_NOBITS, SHF_ALLOC | SHF_WRITE,
 alignment) {
this->bss = true;
this->size = size;
}

EhFrameSection::EhFrameSection(Ctx &ctx)
 : SyntheticSection(ctx, ".eh_frame", SHT_PROGBITS, SHF_ALLOC, 1) {}

// Search for an existing CIE record or create a new one.
// CIE records from input object files are uniquified by their contents
// and where their relocations point to.
template <classELFT, classRelTy>
CieRecord *EhFrameSection::addCie(EhSectionPiece &cie, ArrayRef<RelTy> rels) {
 Symbol *personality = nullptr;
unsigned firstRelI = cie.firstRelocation;
if (firstRelI != (unsigned)-1)
 personality = &cie.sec->file->getRelocTargetSym(rels[firstRelI]);

// Search for an existing CIE by CIE contents/relocation target pair.
 CieRecord *&rec = cieMap[{cie.data(), personality}];

// If not found, create a new one.
if (!rec) {
 rec = make<CieRecord>();
 rec->cie = &cie;
 cieRecords.push_back(rec);
 }
return rec;
}

// There is one FDE per function. Returns a non-null pointer to the function
// symbol if the given FDE points to a live function.
template <classELFT, classRelTy>
Defined *EhFrameSection::isFdeLive(EhSectionPiece &fde, ArrayRef<RelTy> rels) {
auto *sec = cast<EhInputSection>(fde.sec);
unsigned firstRelI = fde.firstRelocation;

// An FDE should point to some function because FDEs are to describe
// functions. That's however not always the case due to an issue of
// ld.gold with -r. ld.gold may discard only functions and leave their
// corresponding FDEs, which results in creating bad .eh_frame sections.
// To deal with that, we ignore such FDEs.
if (firstRelI == (unsigned)-1)
returnnullptr;

const RelTy &rel = rels[firstRelI];
 Symbol &b = sec->file->getRelocTargetSym(rel);

// FDEs for garbage-collected or merged-by-ICF sections, or sections in
// another partition, are dead.
if (auto *d = dyn_cast<Defined>(&b))
if (!d->folded && d->section && d->section->partition == partition)
return d;
returnnullptr;
}

// .eh_frame is a sequence of CIE or FDE records. In general, there
// is one CIE record per input object file which is followed by
// a list of FDEs. This function searches an existing CIE or create a new
// one and associates FDEs to the CIE.
template <classELFT, classRelTy>
voidEhFrameSection::addRecords(EhInputSection *sec, ArrayRef<RelTy> rels) {
 offsetToCie.clear();
for (EhSectionPiece &cie : sec->cies)
 offsetToCie[cie.inputOff] = addCie<ELFT>(cie, rels);
for (EhSectionPiece &fde : sec->fdes) {
uint32_t id = endian::read32<ELFT::Endianness>(fde.data().data() + 4);
 CieRecord *rec = offsetToCie[fde.inputOff + 4 - id];
if (!rec)
Fatal(ctx) << sec << ": invalid CIE reference";

if (!isFdeLive<ELFT>(fde, rels))
continue;
 rec->fdes.push_back(&fde);
 numFdes++;
 }
}

template <classELFT>
voidEhFrameSection::addSectionAux(EhInputSection *sec) {
if (!sec->isLive())
return;
const RelsOrRelas<ELFT> rels =
 sec->templaterelsOrRelas<ELFT>(/*supportsCrel=*/false);
if (rels.areRelocsRel())
 addRecords<ELFT>(sec, rels.rels);
else
 addRecords<ELFT>(sec, rels.relas);
}

// Used by ICF<ELFT>::handleLSDA(). This function is very similar to
// EhFrameSection::addRecords().
template <classELFT, classRelTy>
voidEhFrameSection::iterateFDEWithLSDAAux(
 EhInputSection &sec, ArrayRef<RelTy> rels, DenseSet<size_t> &ciesWithLSDA,
 llvm::function_ref<void(InputSection &)> fn) {
for (EhSectionPiece &cie : sec.cies)
if (hasLSDA(cie))
 ciesWithLSDA.insert(cie.inputOff);
for (EhSectionPiece &fde : sec.fdes) {
uint32_t id = endian::read32<ELFT::Endianness>(fde.data().data() + 4);
if (!ciesWithLSDA.contains(fde.inputOff + 4 - id))
continue;

// The CIE has a LSDA argument. Call fn with d's section.
if (Defined *d = isFdeLive<ELFT>(fde, rels))
if (auto *s = dyn_cast_or_null<InputSection>(d->section))
fn(*s);
 }
}

template <classELFT>
voidEhFrameSection::iterateFDEWithLSDA(
 llvm::function_ref<void(InputSection &)> fn) {
 DenseSet<size_t> ciesWithLSDA;
for (EhInputSection *sec : sections) {
 ciesWithLSDA.clear();
const RelsOrRelas<ELFT> rels =
 sec->templaterelsOrRelas<ELFT>(/*supportsCrel=*/false);
if (rels.areRelocsRel())
 iterateFDEWithLSDAAux<ELFT>(*sec, rels.rels, ciesWithLSDA, fn);
else
 iterateFDEWithLSDAAux<ELFT>(*sec, rels.relas, ciesWithLSDA, fn);
 }
}

staticvoidwriteCieFde(Ctx &ctx, uint8_t *buf, ArrayRef<uint8_t> d) {
memcpy(buf, d.data(), d.size());
// Fix the size field. -4 since size does not include the size field itself.
write32(ctx, buf, d.size() - 4);
}

voidEhFrameSection::finalizeContents() {
assert(!this->size); // Not finalized.

switch (ctx.arg.ekind) {
case ELFNoneKind:
llvm_unreachable("invalid ekind");
case ELF32LEKind:
for (EhInputSection *sec : sections)
 addSectionAux<ELF32LE>(sec);
break;
case ELF32BEKind:
for (EhInputSection *sec : sections)
 addSectionAux<ELF32BE>(sec);
break;
case ELF64LEKind:
for (EhInputSection *sec : sections)
 addSectionAux<ELF64LE>(sec);
break;
case ELF64BEKind:
for (EhInputSection *sec : sections)
 addSectionAux<ELF64BE>(sec);
break;
 }

size_t off = 0;
for (CieRecord *rec : cieRecords) {
 rec->cie->outputOff = off;
 off += rec->cie->size;

for (EhSectionPiece *fde : rec->fdes) {
 fde->outputOff = off;
 off += fde->size;
 }
 }

// The LSB standard does not allow a .eh_frame section with zero
// Call Frame Information records. glibc unwind-dw2-fde.c
// classify_object_over_fdes expects there is a CIE record length 0 as a
// terminator. Thus we add one unconditionally.
 off += 4;

this->size = off;
}

// Returns data for .eh_frame_hdr. .eh_frame_hdr is a binary search table
// to get an FDE from an address to which FDE is applied. This function
// returns a list of such pairs.
SmallVector<EhFrameSection::FdeData, 0> EhFrameSection::getFdeData() const {
uint8_t *buf = ctx.bufferStart + getParent()->offset + outSecOff;
 SmallVector<FdeData, 0> ret;

uint64_t va = getPartition(ctx).ehFrameHdr->getVA();
for (CieRecord *rec : cieRecords) {
uint8_t enc = getFdeEncoding(rec->cie);
for (EhSectionPiece *fde : rec->fdes) {
uint64_t pc = getFdePc(buf, fde->outputOff, enc);
uint64_t fdeVA = getParent()->addr + fde->outputOff;
if (!isInt<32>(pc - va)) {
Err(ctx) << fde->sec << ": PC offset is too large: 0x"
 << Twine::utohexstr(pc - va);
continue;
 }
 ret.push_back({uint32_t(pc - va), uint32_t(fdeVA - va)});
 }
 }

// Sort the FDE list by their PC and uniqueify. Usually there is only
// one FDE for a PC (i.e. function), but if ICF merges two functions
// into one, there can be more than one FDEs pointing to the address.
auto less = [](const FdeData &a, const FdeData &b) {
return a.pcRel < b.pcRel;
 };
llvm::stable_sort(ret, less);
auto eq = [](const FdeData &a, const FdeData &b) {
return a.pcRel == b.pcRel;
 };
 ret.erase(llvm::unique(ret, eq), ret.end());

return ret;
}

staticuint64_treadFdeAddr(Ctx &ctx, uint8_t *buf, int size) {
switch (size) {
case DW_EH_PE_udata2:
returnread16(ctx, buf);
case DW_EH_PE_sdata2:
return (int16_t)read16(ctx, buf);
case DW_EH_PE_udata4:
returnread32(ctx, buf);
case DW_EH_PE_sdata4:
return (int32_t)read32(ctx, buf);
case DW_EH_PE_udata8:
case DW_EH_PE_sdata8:
returnread64(ctx, buf);
case DW_EH_PE_absptr:
returnreadUint(ctx, buf);
 }
Err(ctx) << "unknown FDE size encoding";
return0;
}

// Returns the VA to which a given FDE (on a mmap'ed buffer) is applied to.
// We need it to create .eh_frame_hdr section.
uint64_tEhFrameSection::getFdePc(uint8_t *buf, size_t fdeOff,
uint8_t enc) const {
// The starting address to which this FDE applies is
// stored at FDE + 8 byte. And this offset is within
// the .eh_frame section.
size_t off = fdeOff + 8;
uint64_t addr = readFdeAddr(ctx, buf + off, enc & 0xf);
if ((enc & 0x70) == DW_EH_PE_absptr)
return ctx.arg.is64 ? addr : uint32_t(addr);
if ((enc & 0x70) == DW_EH_PE_pcrel)
return addr + getParent()->addr + off + outSecOff;
Err(ctx) << "unknown FDE size relative encoding";
return0;
}

voidEhFrameSection::writeTo(uint8_t *buf) {
// Write CIE and FDE records.
for (CieRecord *rec : cieRecords) {
size_t cieOffset = rec->cie->outputOff;
writeCieFde(ctx, buf + cieOffset, rec->cie->data());

for (EhSectionPiece *fde : rec->fdes) {
size_t off = fde->outputOff;
writeCieFde(ctx, buf + off, fde->data());

// FDE's second word should have the offset to an associated CIE.
// Write it.
write32(ctx, buf + off + 4, off + 4 - cieOffset);
 }
 }

// Apply relocations. .eh_frame section contents are not contiguous
// in the output buffer, but relocateAlloc() still works because
// getOffset() takes care of discontiguous section pieces.
for (EhInputSection *s : sections)
 ctx.target->relocateAlloc(*s, buf);

if (getPartition(ctx).ehFrameHdr && getPartition(ctx).ehFrameHdr->getParent())
getPartition(ctx).ehFrameHdr->write();
}

GotSection::GotSection(Ctx &ctx)
 : SyntheticSection(ctx, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE,
 ctx.target->gotEntrySize) {
 numEntries = ctx.target->gotHeaderEntriesNum;
}

voidGotSection::addConstant(const Relocation &r) { relocations.push_back(r); }
voidGotSection::addEntry(const Symbol &sym) {
assert(sym.auxIdx == ctx.symAux.size() - 1);
 ctx.symAux.back().gotIdx = numEntries++;
}

voidGotSection::addAuthEntry(const Symbol &sym) {
 authEntries.push_back({(numEntries - 1) * ctx.arg.wordsize, sym.isFunc()});
}

boolGotSection::addTlsDescEntry(const Symbol &sym) {
assert(sym.auxIdx == ctx.symAux.size() - 1);
 ctx.symAux.back().tlsDescIdx = numEntries;
 numEntries += 2;
returntrue;
}

voidGotSection::addTlsDescAuthEntry() {
 authEntries.push_back({(numEntries - 2) * ctx.arg.wordsize, true});
 authEntries.push_back({(numEntries - 1) * ctx.arg.wordsize, false});
}

boolGotSection::addDynTlsEntry(const Symbol &sym) {
assert(sym.auxIdx == ctx.symAux.size() - 1);
 ctx.symAux.back().tlsGdIdx = numEntries;
// Global Dynamic TLS entries take two GOT slots.
 numEntries += 2;
returntrue;
}

// Reserves TLS entries for a TLS module ID and a TLS block offset.
// In total it takes two GOT slots.
boolGotSection::addTlsIndex() {
if (tlsIndexOff != uint32_t(-1))
returnfalse;
 tlsIndexOff = numEntries * ctx.arg.wordsize;
 numEntries += 2;
returntrue;
}

uint32_tGotSection::getTlsDescOffset(const Symbol &sym) const {
return sym.getTlsDescIdx(ctx) * ctx.arg.wordsize;
}

uint64_tGotSection::getTlsDescAddr(const Symbol &sym) const {
returngetVA() + getTlsDescOffset(sym);
}

uint64_tGotSection::getGlobalDynAddr(const Symbol &b) const {
returnthis->getVA() + b.getTlsGdIdx(ctx) * ctx.arg.wordsize;
}

uint64_tGotSection::getGlobalDynOffset(const Symbol &b) const {
return b.getTlsGdIdx(ctx) * ctx.arg.wordsize;
}

voidGotSection::finalizeContents() {
if (ctx.arg.emachine == EM_PPC64 &&
 numEntries <= ctx.target->gotHeaderEntriesNum &&
 !ctx.sym.globalOffsetTable)
 size = 0;
else
 size = numEntries * ctx.arg.wordsize;
}

boolGotSection::isNeeded() const {
// Needed if the GOT symbol is used or the number of entries is more than just
// the header. A GOT with just the header may not be needed.
return hasGotOffRel || numEntries > ctx.target->gotHeaderEntriesNum;
}

voidGotSection::writeTo(uint8_t *buf) {
// On PPC64 .got may be needed but empty. Skip the write.
if (size == 0)
return;
 ctx.target->writeGotHeader(buf);
 ctx.target->relocateAlloc(*this, buf);
for (const AuthEntryInfo &authEntry : authEntries) {
// https://github.com/ARM-software/abi-aa/blob/2024Q3/pauthabielf64/pauthabielf64.rst#default-signing-schema
// Signed GOT entries use the IA key for symbols of type STT_FUNC and the
// DA key for all other symbol types, with the address of the GOT entry as
// the modifier. The static linker must encode the signing schema into the
// GOT slot.
//
// https://github.com/ARM-software/abi-aa/blob/2024Q3/pauthabielf64/pauthabielf64.rst#encoding-the-signing-schema
// If address diversity is set and the discriminator
// is 0 then modifier = Place
uint8_t *dest = buf + authEntry.offset;
uint64_t key = authEntry.isSymbolFunc ? /*IA=*/0b00 : /*DA=*/0b10;
uint64_t addrDiversity = 1;
write64(ctx, dest, (addrDiversity << 63) | (key << 60));
 }
}

staticuint64_tgetMipsPageAddr(uint64_t addr) {
return (addr + 0x8000) & ~0xffff;
}

staticuint64_tgetMipsPageCount(uint64_t size) {
return (size + 0xfffe) / 0xffff + 1;
}

MipsGotSection::MipsGotSection(Ctx &ctx)
 : SyntheticSection(ctx, ".got", SHT_PROGBITS,
 SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL, 16) {}

voidMipsGotSection::addEntry(InputFile &file, Symbol &sym, int64_t addend,
 RelExpr expr) {
 FileGot &g = getGot(file);
if (expr == RE_MIPS_GOT_LOCAL_PAGE) {
if (const OutputSection *os = sym.getOutputSection())
 g.pagesMap.insert({os, {}});
else
 g.local16.insert({{nullptr, getMipsPageAddr(sym.getVA(ctx, addend))}, 0});
 } elseif (sym.isTls())
 g.tls.insert({&sym, 0});
elseif (sym.isPreemptible && expr == R_ABS)
 g.relocs.insert({&sym, 0});
elseif (sym.isPreemptible)
 g.global.insert({&sym, 0});
elseif (expr == RE_MIPS_GOT_OFF32)
 g.local32.insert({{&sym, addend}, 0});
else
 g.local16.insert({{&sym, addend}, 0});
}

voidMipsGotSection::addDynTlsEntry(InputFile &file, Symbol &sym) {
getGot(file).dynTlsSymbols.insert({&sym, 0});
}

voidMipsGotSection::addTlsIndex(InputFile &file) {
getGot(file).dynTlsSymbols.insert({nullptr, 0});
}

size_tMipsGotSection::FileGot::getEntriesNum() const {
returngetPageEntriesNum() + local16.size() + global.size() + relocs.size() +
 tls.size() + dynTlsSymbols.size() * 2;
}

size_tMipsGotSection::FileGot::getPageEntriesNum() const {
size_t num = 0;
for (const std::pair<const OutputSection *, FileGot::PageBlock> &p : pagesMap)
 num += p.second.count;
return num;
}

size_tMipsGotSection::FileGot::getIndexedEntriesNum() const {
size_t count = getPageEntriesNum() + local16.size() + global.size();
// If there are relocation-only entries in the GOT, TLS entries
// are allocated after them. TLS entries should be addressable
// by 16-bit index so count both reloc-only and TLS entries.
if (!tls.empty() || !dynTlsSymbols.empty())
 count += relocs.size() + tls.size() + dynTlsSymbols.size() * 2;
return count;
}

MipsGotSection::FileGot &MipsGotSection::getGot(InputFile &f) {
if (f.mipsGotIndex == uint32_t(-1)) {
 gots.emplace_back();
 gots.back().file = &f;
 f.mipsGotIndex = gots.size() - 1;
 }
return gots[f.mipsGotIndex];
}

uint64_tMipsGotSection::getPageEntryOffset(const InputFile *f,
const Symbol &sym,
int64_t addend) const {
const FileGot &g = gots[f->mipsGotIndex];
uint64_tindex = 0;
if (const OutputSection *outSec = sym.getOutputSection()) {
uint64_t secAddr = getMipsPageAddr(outSec->addr);
uint64_t symAddr = getMipsPageAddr(sym.getVA(ctx, addend));
index = g.pagesMap.lookup(outSec).firstIndex + (symAddr - secAddr) / 0xffff;
 } else {
index =
 g.local16.lookup({nullptr, getMipsPageAddr(sym.getVA(ctx, addend))});
 }
returnindex * ctx.arg.wordsize;
}

uint64_tMipsGotSection::getSymEntryOffset(const InputFile *f, const Symbol &s,
int64_t addend) const {
const FileGot &g = gots[f->mipsGotIndex];
 Symbol *sym = const_cast<Symbol *>(&s);
if (sym->isTls())
return g.tls.lookup(sym) * ctx.arg.wordsize;
if (sym->isPreemptible)
return g.global.lookup(sym) * ctx.arg.wordsize;
return g.local16.lookup({sym, addend}) * ctx.arg.wordsize;
}

uint64_tMipsGotSection::getTlsIndexOffset(const InputFile *f) const {
const FileGot &g = gots[f->mipsGotIndex];
return g.dynTlsSymbols.lookup(nullptr) * ctx.arg.wordsize;
}

uint64_tMipsGotSection::getGlobalDynOffset(const InputFile *f,
const Symbol &s) const {
const FileGot &g = gots[f->mipsGotIndex];
 Symbol *sym = const_cast<Symbol *>(&s);
return g.dynTlsSymbols.lookup(sym) * ctx.arg.wordsize;
}

const Symbol *MipsGotSection::getFirstGlobalEntry() const {
if (gots.empty())
returnnullptr;
const FileGot &primGot = gots.front();
if (!primGot.global.empty())
return primGot.global.front().first;
if (!primGot.relocs.empty())
return primGot.relocs.front().first;
returnnullptr;
}

unsignedMipsGotSection::getLocalEntriesNum() const {
if (gots.empty())
return headerEntriesNum;
return headerEntriesNum + gots.front().getPageEntriesNum() +
 gots.front().local16.size();
}

boolMipsGotSection::tryMergeGots(FileGot &dst, FileGot &src, bool isPrimary) {
 FileGot tmp = dst;
set_union(tmp.pagesMap, src.pagesMap);
set_union(tmp.local16, src.local16);
set_union(tmp.global, src.global);
set_union(tmp.relocs, src.relocs);
set_union(tmp.tls, src.tls);
set_union(tmp.dynTlsSymbols, src.dynTlsSymbols);

size_t count = isPrimary ? headerEntriesNum : 0;
 count += tmp.getIndexedEntriesNum();

if (count * ctx.arg.wordsize > ctx.arg.mipsGotSize)
returnfalse;

std::swap(tmp, dst);
returntrue;
}

voidMipsGotSection::finalizeContents() { updateAllocSize(ctx); }

boolMipsGotSection::updateAllocSize(Ctx &ctx) {
 size = headerEntriesNum * ctx.arg.wordsize;
for (const FileGot &g : gots)
 size += g.getEntriesNum() * ctx.arg.wordsize;
returnfalse;
}

voidMipsGotSection::build() {
if (gots.empty())
return;

 std::vector<FileGot> mergedGots(1);

// For each GOT move non-preemptible symbols from the `Global`
// to `Local16` list. Preemptible symbol might become non-preemptible
// one if, for example, it gets a related copy relocation.
for (FileGot &got : gots) {
for (auto &p: got.global)
if (!p.first->isPreemptible)
 got.local16.insert({{p.first, 0}, 0});
 got.global.remove_if([&](const std::pair<Symbol *, size_t> &p) {
return !p.first->isPreemptible;
 });
 }

// For each GOT remove "reloc-only" entry if there is "global"
// entry for the same symbol. And add local entries which indexed
// using 32-bit value at the end of 16-bit entries.
for (FileGot &got : gots) {
 got.relocs.remove_if([&](const std::pair<Symbol *, size_t> &p) {
return got.global.count(p.first);
 });
set_union(got.local16, got.local32);
 got.local32.clear();
 }

// Evaluate number of "reloc-only" entries in the resulting GOT.
// To do that put all unique "reloc-only" and "global" entries
// from all GOTs to the future primary GOT.
 FileGot *primGot = &mergedGots.front();
for (FileGot &got : gots) {
set_union(primGot->relocs, got.global);
set_union(primGot->relocs, got.relocs);
 got.relocs.clear();
 }

// Evaluate number of "page" entries in each GOT.
for (FileGot &got : gots) {
for (std::pair<const OutputSection *, FileGot::PageBlock> &p :
 got.pagesMap) {
const OutputSection *os = p.first;
uint64_t secSize = 0;
for (SectionCommand *cmd : os->commands) {
if (auto *isd = dyn_cast<InputSectionDescription>(cmd))
for (InputSection *isec : isd->sections) {
uint64_t off = alignToPowerOf2(secSize, isec->addralign);
 secSize = off + isec->getSize();
 }
 }
 p.second.count = getMipsPageCount(secSize);
 }
 }

// Merge GOTs. Try to join as much as possible GOTs but do not exceed
// maximum GOT size. At first, try to fill the primary GOT because
// the primary GOT can be accessed in the most effective way. If it
// is not possible, try to fill the last GOT in the list, and finally
// create a new GOT if both attempts failed.
for (FileGot &srcGot : gots) {
 InputFile *file = srcGot.file;
if (tryMergeGots(mergedGots.front(), srcGot, true)) {
 file->mipsGotIndex = 0;
 } else {
// If this is the first time we failed to merge with the primary GOT,
// MergedGots.back() will also be the primary GOT. We must make sure not
// to try to merge again with isPrimary=false, as otherwise, if the
// inputs are just right, we could allow the primary GOT to become 1 or 2
// words bigger due to ignoring the header size.
if (mergedGots.size() == 1 ||
 !tryMergeGots(mergedGots.back(), srcGot, false)) {
 mergedGots.emplace_back();
std::swap(mergedGots.back(), srcGot);
 }
 file->mipsGotIndex = mergedGots.size() - 1;
 }
 }
std::swap(gots, mergedGots);

// Reduce number of "reloc-only" entries in the primary GOT
// by subtracting "global" entries in the primary GOT.
 primGot = &gots.front();