//===- 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/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>

using namespace llvm;

using namespace llvm::dwarf;

using namespace llvm::ELF;

using namespace llvm::object;

using namespace llvm::support;

using namespace lld;

using namespace lld::elf;

using llvm::support::endian::read32le;

using llvm::support::endian::write32le;

using llvm::support::endian::write64le;

static uint64_t readUint(Ctx &ctx, uint8_t *buf) {

return ctx.arg.is64 ? read64(ctx, buf) : read32(ctx, buf);

}

static void writeUint(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 {(const uint8_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;

}

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 = {(const uint8_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;

}

static size_t getHashSize(Ctx &ctx) {

switch (ctx.arg.buildId) {

case BuildIdKind::Fast:

return 8;

case BuildIdKind::Md5:

case BuildIdKind::Uuid:

return 16;

case BuildIdKind::Sha1:

return 20;

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) {}

void GnuPropertySection::writeTo(uint8_t *buf) {

uint32_t featureAndType;

switch (ctx.arg.emachine) {

case EM_386:

case EM_X86_64:

featureAndType = GNU_PROPERTY_X86_FEATURE_1_AND;

break;

case EM_AARCH64:

featureAndType = GNU_PROPERTY_AARCH64_FEATURE_1_AND;

break;

case EM_RISCV:

featureAndType = GNU_PROPERTY_RISCV_FEATURE_1_AND;

break;

default:

llvm_unreachable(

"target machine does not support .note.gnu.property section");

}

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

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) {

write32(ctx, buf + offset + 0, GNU_PROPERTY_AARCH64_FEATURE_PAUTH);

write32(ctx, buf + offset + 4, AArch64PauthAbiCoreInfo::size());

write64(ctx, buf + offset + 8, ctx.aarch64PauthAbiCoreInfo->platform);

write64(ctx, buf + offset + 16, ctx.aarch64PauthAbiCoreInfo->version);

}

}

size_t GnuPropertySection::getSize() const {

uint32_t contentSize = 0;

if (ctx.arg.andFeatures != 0)

contentSize += ctx.arg.is64 ? 16 : 12;

if (ctx.aarch64PauthAbiCoreInfo)

contentSize += 4 + 4 + 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)) {}

void BuildIdSection::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;

}

void BuildIdSection::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.

CieRecord *EhFrameSection::addCie(EhSectionPiece &cie,

ArrayRef<Relocation> rels) {

Symbol *personality = nullptr;

unsigned firstRelI = cie.firstRelocation;

if (firstRelI != (unsigned)-1)

personality = rels[firstRelI].sym;

// 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.

Defined *EhFrameSection::isFdeLive(EhSectionPiece &fde,

ArrayRef<Relocation> rels) {

// 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.

unsigned firstRelI = fde.firstRelocation;

if (firstRelI == (unsigned)-1)

return nullptr;

// FDEs for garbage-collected or merged-by-ICF sections, or sections in

// another partition, are dead.

if (auto *d = dyn_cast<Defined>(rels[firstRelI].sym))

if (!d->folded && d->section && d->section->partition == partition)

return d;

return nullptr;

}

// .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 <endianness e> void EhFrameSection::addRecords(EhInputSection *sec) {

auto rels = sec->rels;

offsetToCie.clear();

for (EhSectionPiece &cie : sec->cies)

offsetToCie[cie.inputOff] = addCie(cie, rels);

for (EhSectionPiece &fde : sec->fdes) {

uint32_t id = endian::read32<e>(fde.data().data() + 4);

CieRecord *rec = offsetToCie[fde.inputOff + 4 - id];

if (!rec)

Fatal(ctx) << sec << ": invalid CIE reference";

if (!isFdeLive(fde, rels))

continue;

rec->fdes.push_back(&fde);

numFdes++;

}

}

// Used by ICF<ELFT>::handleLSDA(). This function is very similar to

// EhFrameSection::addRecords().

template <class ELFT>

void EhFrameSection::iterateFDEWithLSDAAux(

EhInputSection &sec, 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(fde, sec.rels))

if (auto *s = dyn_cast_or_null<InputSection>(d->section))

fn(*s);

}

}

template <class ELFT>

void EhFrameSection::iterateFDEWithLSDA(

llvm::function_ref<void(InputSection &)> fn) {

DenseSet<size_t> ciesWithLSDA;

for (EhInputSection *sec : sections) {

ciesWithLSDA.clear();

iterateFDEWithLSDAAux<ELFT>(*sec, ciesWithLSDA, fn);

}

}

static void writeCieFde(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);

}

void EhFrameSection::finalizeContents() {

assert(!this->size); // Not finalized.

switch (ctx.arg.ekind) {

case ELFNoneKind:

llvm_unreachable("invalid ekind");

case ELF32LEKind:

case ELF64LEKind:

for (EhInputSection *sec : sections)

if (sec->isLive())

addRecords<endianness::little>(sec);

break;

case ELF32BEKind:

case ELF64BEKind:

for (EhInputSection *sec : sections)

if (sec->isLive())

addRecords<endianness::big>(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;

}

void EhFrameSection::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 to .eh_frame entries. This includes CIE personality

// pointers, FDE initial_location fields, and LSDA pointers.

for (EhInputSection *s : sections)

ctx.target->relocateEh(*s, buf);

EhFrameHeader *hdr = getPartition(ctx).ehFrameHdr.get();

if (!hdr || !hdr->getParent())

return;

// Write the .eh_frame_hdr section using cached FDE data from updateAllocSize.

bool large = hdr->large;

int64_t ehFramePtr = getParent()->addr - hdr->getVA() - 4;

auto writeField = [&](uint8_t *buf, uint64_t val) {

large ? write64(ctx, buf, val) : write32(ctx, buf, val);

};

uint8_t *hdrBuf = ctx.bufferStart + hdr->getParent()->offset + hdr->outSecOff;

// version

hdrBuf[0] = 1;

// eh_frame_ptr_enc

hdrBuf[1] = DW_EH_PE_pcrel | (large ? DW_EH_PE_sdata8 : DW_EH_PE_sdata4);

// fde_count_enc

hdrBuf[2] = DW_EH_PE_udata4;

// table_enc

hdrBuf[3] = DW_EH_PE_datarel | (large ? DW_EH_PE_sdata8 : DW_EH_PE_sdata4);

hdrBuf += 4;

writeField(hdrBuf, ehFramePtr);

hdrBuf += large ? 8 : 4;

write32(ctx, hdrBuf, hdr->fdes.size());

hdrBuf += 4;

for (const FdeData &fde : hdr->fdes) {

writeField(hdrBuf, fde.pcRel);

writeField(hdrBuf + (large ? 8 : 4), fde.fdeVARel);

hdrBuf += large ? 16 : 8;

}

}

EhFrameHeader::EhFrameHeader(Ctx &ctx)

: SyntheticSection(ctx, ".eh_frame_hdr", SHT_PROGBITS, SHF_ALLOC, 4) {}

void EhFrameHeader::writeTo(uint8_t *buf) {

// The section content is written during EhFrameSection::writeTo.

}

bool EhFrameHeader::isNeeded() const {

return isLive() && getPartition(ctx).ehFrame->isNeeded();

}

void EhFrameHeader::finalizeContents() {

// Compute size: 4-byte header + eh_frame_ptr + fde_count + FDE table.

// Initially `large` is false; updateAllocSize may set it to true if addresses

// exceed the 32-bit range, then call finalizeContents again.

auto numFdes = getPartition(ctx).ehFrame->numFdes;

size = 4 + (large ? 8 : 4) + 4 + numFdes * (large ? 16 : 8);

}

bool EhFrameHeader::updateAllocSize(Ctx &ctx) {

// This is called after `finalizeSynthetic`, so in the typical case without

// .relr.dyn, this function will not change the size and assignAddresses

// will not need another iteration.

EhFrameSection *ehFrame = getPartition(ctx).ehFrame.get();

uint64_t hdrVA = getVA();

int64_t ehFramePtr = ehFrame->getParent()->addr - hdrVA - 4;

// Determine if 64-bit encodings are needed.

bool newLarge = !isInt<32>(ehFramePtr);

// Collect FDE entries. For each FDE, compute pcRel and fdeVARel relative to

// .eh_frame_hdr's VA.

fdes.clear();

for (CieRecord *rec : ehFrame->getCieRecords()) {

uint8_t enc = getFdeEncoding(rec->cie);

if ((enc & 0x70) != DW_EH_PE_absptr && (enc & 0x70) != DW_EH_PE_pcrel) {

Err(ctx) << "unknown FDE size encoding";

continue;

}

for (EhSectionPiece *fde : rec->fdes) {

// The FDE has passed `isFdeLive`, so the first relocation's symbol is a

// live Defined.

auto *isec = cast<EhInputSection>(fde->sec);

auto &reloc = isec->rels[fde->firstRelocation];

assert(isa<Defined>(reloc.sym) && "isFdeLive should have checked this");

int64_t pcRel = reloc.sym->getVA(ctx) + reloc.addend - hdrVA;

int64_t fdeVARel = ehFrame->getParent()->addr + fde->outputOff - hdrVA;

fdes.push_back({pcRel, fdeVARel});

newLarge |= !isInt<32>(pcRel) || !isInt<32>(fdeVARel);

}

}

// Sort the FDE list by their PC and uniquify. Usually there is only one FDE

// at an address, but there can be more than one FDEs pointing to the address.

llvm::stable_sort(

fdes, [](const EhFrameSection::FdeData &a,

const EhFrameSection::FdeData &b) { return a.pcRel < b.pcRel; });

fdes.erase(llvm::unique(fdes,

[](const EhFrameSection::FdeData &a,

const EhFrameSection::FdeData &b) {

return a.pcRel == b.pcRel;

}),

fdes.end());

ehFrame->numFdes = fdes.size();

large = newLarge;

// Compute size.

size_t oldSize = size;

finalizeContents();

return size != oldSize;

}

GotSection::GotSection(Ctx &ctx)

: SyntheticSection(ctx, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE,

ctx.target->gotEntrySize) {

numEntries = ctx.target->gotHeaderEntriesNum;

}

void GotSection::addEntry(const Symbol &sym) {

assert(sym.auxIdx == ctx.symAux.size() - 1);

ctx.symAux.back().gotIdx = numEntries++;

}

void GotSection::addAuthEntry(const Symbol &sym) {

authEntries.push_back(

{(numEntries - 1) * ctx.target->gotEntrySize, sym.isFunc()});

}

bool GotSection::addTlsDescEntry(const Symbol &sym) {

assert(sym.auxIdx == ctx.symAux.size() - 1);

ctx.symAux.back().tlsDescIdx = numEntries;

numEntries += 2;

return true;

}

void GotSection::addTlsDescAuthEntry() {

authEntries.push_back({(numEntries - 2) * ctx.target->gotEntrySize, true});

authEntries.push_back({(numEntries - 1) * ctx.target->gotEntrySize, false});

}

bool GotSection::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;

return true;

}

// Reserves TLS entries for a TLS module ID and a TLS block offset.

// In total it takes two GOT slots.

bool GotSection::addTlsIndex() {

if (tlsIndexOff != uint32_t(-1))

return false;

tlsIndexOff = numEntries * ctx.target->gotEntrySize;

numEntries += 2;

return true;

}

uint32_t GotSection::getTlsDescOffset(const Symbol &sym) const {

return sym.getTlsDescIdx(ctx) * ctx.target->gotEntrySize;

}

uint64_t GotSection::getTlsDescAddr(const Symbol &sym) const {

return getVA() + getTlsDescOffset(sym);

}

uint64_t GotSection::getGlobalDynAddr(const Symbol &b) const {

return this->getVA() + b.getTlsGdIdx(ctx) * ctx.target->gotEntrySize;

}

uint64_t GotSection::getGlobalDynOffset(const Symbol &b) const {

return b.getTlsGdIdx(ctx) * ctx.target->gotEntrySize;

}

void GotSection::finalizeContents() {

if (ctx.arg.emachine == EM_PPC64 &&

numEntries <= ctx.target->gotHeaderEntriesNum &&

!ctx.sym.globalOffsetTable)

size = 0;

else

size = numEntries * ctx.target->gotEntrySize;

}

bool GotSection::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;

}

void GotSection::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));

}

}

static uint64_t getMipsPageCount(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) {}

void MipsGotSection::addConstant(const Relocation &r) {

relocations.push_back(r);

}

void MipsGotSection::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, {&sym}});

else

g.local16.insert({{nullptr, getMipsPageAddr(sym.getVA(ctx, addend))}, 0});

} else if (sym.isTls())

g.tls.insert({&sym, 0});

else if (sym.isPreemptible && expr == R_ABS)

g.relocs.insert({&sym, 0});

else if (sym.isPreemptible)

g.global.insert({&sym, 0});

else if (expr == RE_MIPS_GOT_OFF32)

g.local32.insert({{&sym, addend}, 0});

else

g.local16.insert({{&sym, addend}, 0});

}

void MipsGotSection::addDynTlsEntry(InputFile &file, Symbol &sym) {

getGot(file).dynTlsSymbols.insert({&sym, 0});

}

void MipsGotSection::addTlsIndex(InputFile &file) {

getGot(file).dynTlsSymbols.insert({nullptr, 0});

}

size_t MipsGotSection::FileGot::getEntriesNum() const {

return getPageEntriesNum() + local16.size() + global.size() + relocs.size() +

tls.size() + dynTlsSymbols.size() * 2;

}

size_t MipsGotSection::FileGot::getPageEntriesNum() const {

size_t num = 0;

for (const std::pair<const OutputSection *, FileGot::PageBlock> &p : pagesMap)

num += p.second.count;

return num;

}

size_t MipsGotSection::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_t MipsGotSection::getPageEntryOffset(const InputFile *f,

const Symbol &sym,

int64_t addend) const {

const FileGot &g = gots[f->mipsGotIndex];

uint64_t index = 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))});

}

return index * ctx.arg.wordsize;

}

uint64_t MipsGotSection::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_t MipsGotSection::getTlsIndexOffset(const InputFile *f) const {

const FileGot &g = gots[f->mipsGotIndex];

return g.dynTlsSymbols.lookup(nullptr) * ctx.arg.wordsize;

}

uint64_t MipsGotSection::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())

return nullptr;

const FileGot &primGot = gots.front();

if (!primGot.global.empty())

return primGot.global.front().first;

if (!primGot.relocs.empty())

return primGot.relocs.front().first;

return nullptr;

}

unsigned MipsGotSection::getLocalEntriesNum() const {

if (gots.empty())

return headerEntriesNum;

return headerEntriesNum + gots.front().getPageEntriesNum() +

gots.front().local16.size();

}

bool MipsGotSection::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)

return false;

std::swap(tmp, dst);

return true;

}

void MipsGotSection::finalizeContents() { updateAllocSize(ctx); }

bool MipsGotSection::updateAllocSize(Ctx &ctx) {

size = headerEntriesNum * ctx.arg.wordsize;

for (const FileGot &g : gots)

size += g.getEntriesNum() * ctx.arg.wordsize;

return false;

}

void MipsGotSection::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.contains(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();

primGot->relocs.remove_if([&](const std::pair<Symbol *, size_t> &p) {

return primGot->global.contains(p.first);

});

// Calculate indexes for each GOT entry.

size_t index = headerEntriesNum;

for (FileGot &got : gots) {

got.startIndex = &got == primGot ? 0 : index;

for (std::pair<const OutputSection *, FileGot::PageBlock> &p :

got.pagesMap) {

// For each output section referenced by GOT page relocations calculate

// and save into pagesMap an upper bound of MIPS GOT entries required

// to store page addresses of local symbols. We assume the worst case -

// each 64kb page of the output section has at least one GOT relocation

// against it. And take in account the case when the section intersects

// page boundaries.

p.second.firstIndex = index;

index += p.second.count;

}

for (auto &p: got.local16)

p.second = index++;

for (auto &p: got.global)

p.second = index++;

for (auto &p: got.relocs)

p.second = index++;

for (auto &p: got.tls)

p.second = index++;

for (auto &p: got.dynTlsSymbols) {

p.second = index;

index += 2;

}

}

// Update SymbolAux::gotIdx field to use this

// value later in the `sortMipsSymbols` function.

for (auto &p : primGot->global) {

if (p.first->auxIdx == 0)

p.first->allocateAux(ctx);

ctx.symAux.back().gotIdx = p.second;

}

for (auto &p : primGot->relocs) {

if (p.first->auxIdx == 0)

p.first->allocateAux(ctx);

ctx.symAux.back().gotIdx = p.second;

}

// Create relocations.

//

// Note the primary GOT's local and global relocations are implicit, and the

// MIPS ABI requires the VA be written even for the global entries, so we

// treat both as constants here.

for (FileGot &got : gots) {

// Create relocations for TLS entries.

for (std::pair<Symbol *, size_t> &p : got.tls) {

Symbol *s = p.first;

uint64_t offset = p.second * ctx.arg.wordsize;

// When building a shared library we still need a dynamic relocation

// for the TP-relative offset as we don't know how much other data will

// be allocated before us in the static TLS block.

if (!s->isPreemptible && !ctx.arg.shared)

addConstant({R_TPREL, ctx.target->symbolicRel, offset, 0, s});

else

ctx.mainPart->relaDyn->addAddendOnlyRelocIfNonPreemptible(

ctx.target->tlsGotRel, *this, offset, *s, ctx.target->symbolicRel);

}

for (std::pair<Symbol *, size_t> &p : got.dynTlsSymbols) {

Symbol *s = p.first;

uint64_t offset = p.second * ctx.arg.wordsize;

if (s == nullptr) {

if (ctx.arg.shared)

ctx.mainPart->relaDyn->addReloc(

{ctx.target->tlsModuleIndexRel, this, offset});

else

addConstant(

{R_ADDEND, ctx.target->symbolicRel, offset, 1, ctx.dummySym});

} else {

// When building a shared library we still need a dynamic relocation

// for the module index. Therefore only checking for

// S->isPreemptible is not sufficient (this happens e.g. for

// thread-locals that have been marked as local through a linker script)

if (!s->isPreemptible && !ctx.arg.shared)

// Write one to the GOT slot.

addConstant({R_ADDEND, ctx.target->symbolicRel, offset, 1, s});

else

ctx.mainPart->relaDyn->addSymbolReloc(ctx.target->tlsModuleIndexRel,

*this, offset, *s);

offset += ctx.arg.wordsize;

// However, we can skip writing the TLS offset reloc for non-preemptible

// symbols since it is known even in shared libraries

if (s->isPreemptible)

ctx.mainPart->relaDyn->addSymbolReloc(ctx.target->tlsOffsetRel, *this,

offset, *s);

else

addConstant({R_ABS, ctx.target->tlsOffsetRel, offset, 0, s});

}

}

// Relocations for "global" entries.

for (const std::pair<Symbol *, size_t> &p : got.global) {

uint64_t offset = p.second * ctx.arg.wordsize;

if (&got == primGot)

addConstant({R_ABS, ctx.target->relativeRel, offset, 0, p.first});

else

ctx.mainPart->relaDyn->addSymbolReloc(ctx.target->relativeRel, *this,

offset, *p.first);

}

// Relocation-only entries exist as dummy entries for dynamic symbols that

// aren't otherwise in the primary GOT, as the ABI requires an entry for

// each dynamic symbol. Secondary GOTs have no need for them.

assert((got.relocs.empty() || &got == primGot) &&

"Relocation-only entries should only be in the primary GOT");

for (const std::pair<Symbol *, size_t> &p : got.relocs) {

uint64_t offset = p.second * ctx.arg.wordsize;

addConstant({R_ABS, ctx.target->relativeRel, offset, 0, p.first});

}

// Relocations for "local" entries

for (const std::pair<const OutputSection *, FileGot::PageBlock> &l :

got.pagesMap) {

size_t pageCount = l.second.count;

for (size_t pi = 0; pi < pageCount; ++pi) {

uint64_t offset = (l.second.firstIndex + pi) * ctx.arg.wordsize;

int64_t addend = int64_t(pi * 0x10000);

if (!ctx.arg.isPic || &got == primGot)

addConstant({RE_MIPS_OSEC_LOCAL_PAGE, ctx.target->relativeRel, offset,

addend, l.second.repSym});

else

ctx.mainPart->relaDyn->addRelativeReloc(

ctx.target->relativeRel, *this, offset, *l.second.repSym, addend,

ctx.target->relativeRel, RE_MIPS_OSEC_LOCAL_PAGE);

}

}

for (const std::pair<GotEntry, size_t> &p : got.local16) {

uint64_t offset = p.second * ctx.arg.wordsize;

if (p.first.first == nullptr)

addConstant({R_ADDEND, ctx.target->relativeRel, offset, p.first.second,

ctx.dummySym});

else if (!ctx.arg.isPic || &got == primGot)

addConstant({R_ABS, ctx.target->relativeRel, offset, p.first.second,

p.first.first});

else

ctx.mainPart->relaDyn->addRelativeReloc(

ctx.target->relativeRel, *this, offset, *p.first.first,

p.first.second, ctx.target->relativeRel, R_ABS);

}

}

}

bool MipsGotSection::isNeeded() const {

// We add the .got section to the result for dynamic MIPS target because

// its address and properties are mentioned in the .dynamic section.

return !ctx.arg.relocatable;

}

uint64_t MipsGotSection::getGp(const InputFile *f) const {

// For files without related GOT or files refer a primary GOT

// returns "common" _gp value. For secondary GOTs calculate

// individual _gp values.

if (!f || f->mipsGotIndex == uint32_t(-1) || f->mipsGotIndex == 0)

return ctx.sym.mipsGp->getVA(ctx, 0);

return getVA() + gots[f->mipsGotIndex].startIndex * ctx.arg.wordsize + 0x7ff0;

}