2015-09-22 05:38:08 +08:00
|
|
|
//===- OutputSections.cpp -------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Linker
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "OutputSections.h"
|
|
|
|
#include "Config.h"
|
|
|
|
#include "SymbolTable.h"
|
2015-09-23 02:19:46 +08:00
|
|
|
#include "Target.h"
|
2015-10-22 16:21:35 +08:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2015-09-22 05:38:08 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
using namespace llvm::object;
|
2015-10-07 07:56:53 +08:00
|
|
|
using namespace llvm::support::endian;
|
2015-09-22 05:38:08 +08:00
|
|
|
using namespace llvm::ELF;
|
|
|
|
|
|
|
|
using namespace lld;
|
|
|
|
using namespace lld::elf2;
|
|
|
|
|
2015-10-16 06:27:29 +08:00
|
|
|
template <class ELFT>
|
|
|
|
OutputSectionBase<ELFT>::OutputSectionBase(StringRef Name, uint32_t sh_type,
|
|
|
|
uintX_t sh_flags)
|
2015-09-22 05:38:08 +08:00
|
|
|
: Name(Name) {
|
2015-10-16 06:27:29 +08:00
|
|
|
memset(&Header, 0, sizeof(Elf_Shdr));
|
2015-09-22 05:38:08 +08:00
|
|
|
Header.sh_type = sh_type;
|
|
|
|
Header.sh_flags = sh_flags;
|
|
|
|
}
|
|
|
|
|
2015-10-20 16:54:27 +08:00
|
|
|
template <class ELFT>
|
|
|
|
GotPltSection<ELFT>::GotPltSection()
|
|
|
|
: OutputSectionBase<ELFT>(".got.plt", llvm::ELF::SHT_PROGBITS,
|
|
|
|
llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE) {
|
|
|
|
this->Header.sh_addralign = sizeof(uintX_t);
|
|
|
|
// .got.plt has 3 reserved entry
|
|
|
|
Entries.resize(3);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void GotPltSection<ELFT>::addEntry(SymbolBody *Sym) {
|
|
|
|
Sym->GotPltIndex = Entries.size();
|
|
|
|
Entries.push_back(Sym);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> bool GotPltSection<ELFT>::empty() const {
|
|
|
|
return Entries.size() == 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
typename GotPltSection<ELFT>::uintX_t
|
|
|
|
GotPltSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
|
|
|
|
return this->getVA() + B.GotPltIndex * sizeof(uintX_t);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void GotPltSection<ELFT>::finalize() {
|
|
|
|
this->Header.sh_size = Entries.size() * sizeof(uintX_t);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void GotPltSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(
|
|
|
|
Buf, Out<ELFT>::Dynamic->getVA());
|
|
|
|
for (const SymbolBody *B : Entries) {
|
|
|
|
if (B)
|
|
|
|
Target->writeGotPltEntry(Buf, Out<ELFT>::Plt->getEntryAddr(*B));
|
|
|
|
Buf += sizeof(uintX_t);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
2015-10-08 03:18:16 +08:00
|
|
|
GotSection<ELFT>::GotSection()
|
2015-10-16 06:27:29 +08:00
|
|
|
: OutputSectionBase<ELFT>(".got", llvm::ELF::SHT_PROGBITS,
|
|
|
|
llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE) {
|
2015-11-06 15:43:03 +08:00
|
|
|
if (Config->EMachine == EM_MIPS)
|
|
|
|
this->Header.sh_flags |= llvm::ELF::SHF_MIPS_GPREL;
|
2015-10-14 22:02:06 +08:00
|
|
|
this->Header.sh_addralign = sizeof(uintX_t);
|
2015-09-26 01:19:10 +08:00
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody *Sym) {
|
2015-11-06 15:43:03 +08:00
|
|
|
Sym->GotIndex = Target->getGotHeaderEntriesNum() + Entries.size();
|
2015-09-22 05:38:08 +08:00
|
|
|
Entries.push_back(Sym);
|
|
|
|
}
|
|
|
|
|
2015-11-11 09:00:24 +08:00
|
|
|
template <class ELFT> uint32_t GotSection<ELFT>::addLocalModuleTlsIndex() {
|
|
|
|
Entries.push_back(nullptr);
|
|
|
|
Entries.push_back(nullptr);
|
|
|
|
return (Entries.size() - 2) * sizeof(uintX_t);
|
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT>
|
|
|
|
typename GotSection<ELFT>::uintX_t
|
|
|
|
GotSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
|
2015-10-14 22:02:06 +08:00
|
|
|
return this->getVA() + B.GotIndex * sizeof(uintX_t);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-11-06 15:43:03 +08:00
|
|
|
template <class ELFT> void GotSection<ELFT>::finalize() {
|
|
|
|
this->Header.sh_size =
|
|
|
|
(Target->getGotHeaderEntriesNum() + Entries.size()) * sizeof(uintX_t);
|
|
|
|
}
|
|
|
|
|
2015-10-07 07:56:53 +08:00
|
|
|
template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
|
2015-11-06 15:43:03 +08:00
|
|
|
Target->writeGotHeaderEntries(Buf);
|
|
|
|
Buf += Target->getGotHeaderEntriesNum() * sizeof(uintX_t);
|
2015-10-07 07:56:53 +08:00
|
|
|
for (const SymbolBody *B : Entries) {
|
2015-10-07 11:56:05 +08:00
|
|
|
uint8_t *Entry = Buf;
|
|
|
|
Buf += sizeof(uintX_t);
|
2015-11-11 09:00:24 +08:00
|
|
|
if (!B)
|
|
|
|
continue;
|
2015-11-06 15:43:03 +08:00
|
|
|
// MIPS has special rules to fill up GOT entries.
|
|
|
|
// See "Global Offset Table" in Chapter 5 in the following document
|
|
|
|
// for detailed description:
|
|
|
|
// ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
|
|
|
|
// As the first approach, we can just store addresses for all symbols.
|
|
|
|
if (Config->EMachine != EM_MIPS && canBePreempted(B, false))
|
2015-10-07 07:56:53 +08:00
|
|
|
continue; // The dynamic linker will take care of it.
|
2015-10-08 03:18:16 +08:00
|
|
|
uintX_t VA = getSymVA<ELFT>(*B);
|
2015-10-07 11:56:05 +08:00
|
|
|
write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Entry, VA);
|
2015-10-07 07:56:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
2015-10-08 03:18:16 +08:00
|
|
|
PltSection<ELFT>::PltSection()
|
2015-10-16 06:27:29 +08:00
|
|
|
: OutputSectionBase<ELFT>(".plt", llvm::ELF::SHT_PROGBITS,
|
|
|
|
llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_EXECINSTR) {
|
2015-09-26 01:19:10 +08:00
|
|
|
this->Header.sh_addralign = 16;
|
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT> void PltSection<ELFT>::writeTo(uint8_t *Buf) {
|
2015-10-13 02:56:36 +08:00
|
|
|
size_t Off = 0;
|
2015-10-20 16:54:27 +08:00
|
|
|
bool LazyReloc = Target->supportsLazyRelocations();
|
|
|
|
if (LazyReloc) {
|
|
|
|
// First write PLT[0] entry which is special.
|
|
|
|
Target->writePltZeroEntry(Buf, Out<ELFT>::GotPlt->getVA(), this->getVA());
|
|
|
|
Off += Target->getPltZeroEntrySize();
|
|
|
|
}
|
2015-09-22 05:38:08 +08:00
|
|
|
for (const SymbolBody *E : Entries) {
|
2015-10-20 16:54:27 +08:00
|
|
|
uint64_t Got = LazyReloc ? Out<ELFT>::GotPlt->getEntryAddr(*E)
|
|
|
|
: Out<ELFT>::Got->getEntryAddr(*E);
|
2015-10-13 02:56:36 +08:00
|
|
|
uint64_t Plt = this->getVA() + Off;
|
2015-10-20 16:54:27 +08:00
|
|
|
Target->writePltEntry(Buf + Off, Got, Plt, E->PltIndex);
|
2015-10-13 02:56:36 +08:00
|
|
|
Off += Target->getPltEntrySize();
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void PltSection<ELFT>::addEntry(SymbolBody *Sym) {
|
2015-10-09 08:42:06 +08:00
|
|
|
Sym->PltIndex = Entries.size();
|
2015-09-22 05:38:08 +08:00
|
|
|
Entries.push_back(Sym);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
typename PltSection<ELFT>::uintX_t
|
|
|
|
PltSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
|
2015-10-20 16:54:27 +08:00
|
|
|
return this->getVA() + Target->getPltZeroEntrySize() +
|
|
|
|
B.PltIndex * Target->getPltEntrySize();
|
2015-10-09 05:51:31 +08:00
|
|
|
}
|
|
|
|
|
2015-10-20 16:54:27 +08:00
|
|
|
template <class ELFT> void PltSection<ELFT>::finalize() {
|
|
|
|
this->Header.sh_size = Target->getPltZeroEntrySize() +
|
|
|
|
Entries.size() * Target->getPltEntrySize();
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
2015-10-20 16:54:27 +08:00
|
|
|
RelocationSection<ELFT>::RelocationSection(StringRef Name, bool IsRela)
|
|
|
|
: OutputSectionBase<ELFT>(Name,
|
2015-10-16 06:27:29 +08:00
|
|
|
IsRela ? llvm::ELF::SHT_RELA : llvm::ELF::SHT_REL,
|
|
|
|
llvm::ELF::SHF_ALLOC),
|
2015-10-08 03:18:16 +08:00
|
|
|
IsRela(IsRela) {
|
2015-09-26 01:19:10 +08:00
|
|
|
this->Header.sh_entsize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
|
|
|
|
this->Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
|
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
|
2015-09-23 01:49:38 +08:00
|
|
|
const unsigned EntrySize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
|
2015-09-22 05:38:08 +08:00
|
|
|
for (const DynamicReloc<ELFT> &Rel : Relocs) {
|
2015-09-23 01:49:38 +08:00
|
|
|
auto *P = reinterpret_cast<Elf_Rel *>(Buf);
|
|
|
|
Buf += EntrySize;
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
const InputSection<ELFT> &C = Rel.C;
|
|
|
|
const Elf_Rel &RI = Rel.RI;
|
2015-10-17 06:51:43 +08:00
|
|
|
uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
|
2015-10-06 06:49:16 +08:00
|
|
|
const ObjectFile<ELFT> &File = *C.getFile();
|
2015-10-12 04:59:12 +08:00
|
|
|
SymbolBody *Body = File.getSymbolBody(SymIndex);
|
|
|
|
if (Body)
|
|
|
|
Body = Body->repl();
|
2015-10-06 06:49:16 +08:00
|
|
|
|
2015-10-17 06:51:43 +08:00
|
|
|
uint32_t Type = RI.getType(Config->Mips64EL);
|
2015-11-11 09:00:24 +08:00
|
|
|
|
|
|
|
if (Type == Target->getTlsLocalDynamicReloc()) {
|
|
|
|
P->setSymbolAndType(0, Target->getTlsModuleIndexReloc(),
|
|
|
|
Config->Mips64EL);
|
|
|
|
P->r_offset =
|
|
|
|
Out<ELFT>::Got->getVA() + Out<ELFT>::LocalModuleTlsIndexOffset;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-10-29 00:48:58 +08:00
|
|
|
bool NeedsCopy = Body && Target->relocNeedsCopy(Type, *Body);
|
2015-10-15 02:42:16 +08:00
|
|
|
bool NeedsGot = Body && Target->relocNeedsGot(Type, *Body);
|
|
|
|
bool CanBePreempted = canBePreempted(Body, NeedsGot);
|
2015-10-20 16:54:27 +08:00
|
|
|
bool LazyReloc = Body && Target->supportsLazyRelocations() &&
|
|
|
|
Target->relocNeedsPlt(Type, *Body);
|
2015-10-07 08:58:20 +08:00
|
|
|
|
2015-10-20 03:58:18 +08:00
|
|
|
if (CanBePreempted) {
|
|
|
|
if (NeedsGot)
|
2015-10-07 08:58:20 +08:00
|
|
|
P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
|
2015-10-20 16:54:27 +08:00
|
|
|
LazyReloc ? Target->getPltReloc()
|
|
|
|
: Target->getGotReloc(),
|
|
|
|
Config->Mips64EL);
|
2015-10-20 03:58:18 +08:00
|
|
|
else
|
2015-10-29 00:48:58 +08:00
|
|
|
P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
|
|
|
|
NeedsCopy ? Target->getCopyReloc() : Type,
|
2015-10-17 06:51:43 +08:00
|
|
|
Config->Mips64EL);
|
2015-10-20 03:58:18 +08:00
|
|
|
} else {
|
|
|
|
P->setSymbolAndType(0, Target->getRelativeReloc(), Config->Mips64EL);
|
|
|
|
}
|
|
|
|
|
2015-10-20 16:54:27 +08:00
|
|
|
if (NeedsGot) {
|
|
|
|
if (LazyReloc)
|
|
|
|
P->r_offset = Out<ELFT>::GotPlt->getEntryAddr(*Body);
|
|
|
|
else
|
|
|
|
P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
|
2015-10-29 00:48:58 +08:00
|
|
|
} else if (NeedsCopy) {
|
|
|
|
P->r_offset = Out<ELFT>::Bss->getVA() +
|
|
|
|
dyn_cast<SharedSymbol<ELFT>>(Body)->OffsetInBSS;
|
2015-10-20 16:54:27 +08:00
|
|
|
} else {
|
2015-10-20 03:58:18 +08:00
|
|
|
P->r_offset = RI.r_offset + C.OutSec->getVA() + C.OutSecOff;
|
2015-10-20 16:54:27 +08:00
|
|
|
}
|
2015-10-20 03:58:18 +08:00
|
|
|
|
2015-10-20 04:24:44 +08:00
|
|
|
uintX_t OrigAddend = 0;
|
2015-10-20 03:58:18 +08:00
|
|
|
if (IsRela && !NeedsGot)
|
2015-10-20 04:24:44 +08:00
|
|
|
OrigAddend = static_cast<const Elf_Rela &>(RI).r_addend;
|
2015-10-20 03:58:18 +08:00
|
|
|
|
2015-10-20 04:24:44 +08:00
|
|
|
uintX_t Addend;
|
2015-10-29 00:48:58 +08:00
|
|
|
if (NeedsCopy)
|
|
|
|
Addend = 0;
|
|
|
|
else if (CanBePreempted)
|
2015-10-20 04:24:44 +08:00
|
|
|
Addend = OrigAddend;
|
2015-10-20 04:31:49 +08:00
|
|
|
else if (Body)
|
|
|
|
Addend = getSymVA<ELFT>(cast<ELFSymbolBody<ELFT>>(*Body)) + OrigAddend;
|
|
|
|
else if (IsRela)
|
|
|
|
Addend = getLocalRelTarget(File, static_cast<const Elf_Rela &>(RI));
|
|
|
|
else
|
|
|
|
Addend = getLocalRelTarget(File, RI);
|
2015-10-07 08:58:20 +08:00
|
|
|
|
|
|
|
if (IsRela)
|
|
|
|
static_cast<Elf_Rela *>(P)->r_addend = Addend;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void RelocationSection<ELFT>::finalize() {
|
2015-10-16 04:55:22 +08:00
|
|
|
this->Header.sh_link = Out<ELFT>::DynSymTab->SectionIndex;
|
2015-09-22 05:38:08 +08:00
|
|
|
this->Header.sh_size = Relocs.size() * this->Header.sh_entsize;
|
|
|
|
}
|
|
|
|
|
2015-10-16 06:27:29 +08:00
|
|
|
template <class ELFT>
|
|
|
|
InterpSection<ELFT>::InterpSection()
|
|
|
|
: OutputSectionBase<ELFT>(".interp", llvm::ELF::SHT_PROGBITS,
|
|
|
|
llvm::ELF::SHF_ALLOC) {
|
2015-09-22 05:38:08 +08:00
|
|
|
this->Header.sh_size = Config->DynamicLinker.size() + 1;
|
|
|
|
this->Header.sh_addralign = 1;
|
|
|
|
}
|
|
|
|
|
2015-10-16 06:27:29 +08:00
|
|
|
template <class ELFT>
|
|
|
|
void OutputSectionBase<ELFT>::writeHeaderTo(Elf_Shdr *SHdr) {
|
2015-10-25 01:57:39 +08:00
|
|
|
Header.sh_name = Out<ELFT>::ShStrTab->getOffset(Name);
|
2015-10-16 06:27:29 +08:00
|
|
|
*SHdr = Header;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-10-16 06:27:29 +08:00
|
|
|
template <class ELFT> void InterpSection<ELFT>::writeTo(uint8_t *Buf) {
|
2015-09-22 05:38:08 +08:00
|
|
|
memcpy(Buf, Config->DynamicLinker.data(), Config->DynamicLinker.size());
|
|
|
|
}
|
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
2015-10-08 03:18:16 +08:00
|
|
|
HashTableSection<ELFT>::HashTableSection()
|
2015-10-16 06:27:29 +08:00
|
|
|
: OutputSectionBase<ELFT>(".hash", llvm::ELF::SHT_HASH,
|
|
|
|
llvm::ELF::SHF_ALLOC) {
|
2015-09-26 01:19:10 +08:00
|
|
|
this->Header.sh_entsize = sizeof(Elf_Word);
|
|
|
|
this->Header.sh_addralign = sizeof(Elf_Word);
|
|
|
|
}
|
|
|
|
|
2015-10-22 16:21:35 +08:00
|
|
|
static uint32_t hashSysv(StringRef Name) {
|
2015-10-16 05:27:17 +08:00
|
|
|
uint32_t H = 0;
|
|
|
|
for (char C : Name) {
|
|
|
|
H = (H << 4) + C;
|
|
|
|
uint32_t G = H & 0xf0000000;
|
|
|
|
if (G)
|
|
|
|
H ^= G >> 24;
|
|
|
|
H &= ~G;
|
|
|
|
}
|
|
|
|
return H;
|
|
|
|
}
|
|
|
|
|
2015-10-08 00:58:54 +08:00
|
|
|
template <class ELFT> void HashTableSection<ELFT>::finalize() {
|
2015-10-16 04:55:22 +08:00
|
|
|
this->Header.sh_link = Out<ELFT>::DynSymTab->SectionIndex;
|
2015-10-08 00:58:54 +08:00
|
|
|
|
|
|
|
unsigned NumEntries = 2; // nbucket and nchain.
|
2015-10-08 03:18:16 +08:00
|
|
|
NumEntries += Out<ELFT>::DynSymTab->getNumSymbols(); // The chain entries.
|
2015-10-08 00:58:54 +08:00
|
|
|
|
|
|
|
// Create as many buckets as there are symbols.
|
|
|
|
// FIXME: This is simplistic. We can try to optimize it, but implementing
|
|
|
|
// support for SHT_GNU_HASH is probably even more profitable.
|
2015-10-08 03:18:16 +08:00
|
|
|
NumEntries += Out<ELFT>::DynSymTab->getNumSymbols();
|
2015-10-08 00:58:54 +08:00
|
|
|
this->Header.sh_size = NumEntries * sizeof(Elf_Word);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void HashTableSection<ELFT>::writeTo(uint8_t *Buf) {
|
2015-10-08 03:18:16 +08:00
|
|
|
unsigned NumSymbols = Out<ELFT>::DynSymTab->getNumSymbols();
|
2015-10-08 00:58:54 +08:00
|
|
|
auto *P = reinterpret_cast<Elf_Word *>(Buf);
|
|
|
|
*P++ = NumSymbols; // nbucket
|
|
|
|
*P++ = NumSymbols; // nchain
|
|
|
|
|
|
|
|
Elf_Word *Buckets = P;
|
|
|
|
Elf_Word *Chains = P + NumSymbols;
|
|
|
|
|
2015-10-28 15:05:56 +08:00
|
|
|
for (SymbolBody *Body : Out<ELFT>::DynSymTab->getSymbols()) {
|
2015-10-21 05:47:58 +08:00
|
|
|
StringRef Name = Body->getName();
|
|
|
|
unsigned I = Body->getDynamicSymbolTableIndex();
|
2015-10-22 16:21:35 +08:00
|
|
|
uint32_t Hash = hashSysv(Name) % NumSymbols;
|
2015-10-08 00:58:54 +08:00
|
|
|
Chains[I] = Buckets[Hash];
|
|
|
|
Buckets[Hash] = I;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-22 16:21:35 +08:00
|
|
|
static uint32_t hashGnu(StringRef Name) {
|
|
|
|
uint32_t H = 5381;
|
|
|
|
for (uint8_t C : Name)
|
|
|
|
H = (H << 5) + H + C;
|
|
|
|
return H;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
GnuHashTableSection<ELFT>::GnuHashTableSection()
|
|
|
|
: OutputSectionBase<ELFT>(".gnu.hash", llvm::ELF::SHT_GNU_HASH,
|
|
|
|
llvm::ELF::SHF_ALLOC) {
|
|
|
|
this->Header.sh_entsize = ELFT::Is64Bits ? 0 : 4;
|
|
|
|
this->Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
unsigned GnuHashTableSection<ELFT>::calcNBuckets(unsigned NumHashed) {
|
|
|
|
if (!NumHashed)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
// These values are prime numbers which are not greater than 2^(N-1) + 1.
|
|
|
|
// In result, for any particular NumHashed we return a prime number
|
|
|
|
// which is not greater than NumHashed.
|
|
|
|
static const unsigned Primes[] = {
|
|
|
|
1, 1, 3, 3, 7, 13, 31, 61, 127, 251,
|
|
|
|
509, 1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071};
|
|
|
|
|
|
|
|
return Primes[std::min<unsigned>(Log2_32_Ceil(NumHashed),
|
|
|
|
array_lengthof(Primes) - 1)];
|
|
|
|
}
|
|
|
|
|
|
|
|
// Bloom filter estimation: at least 8 bits for each hashed symbol.
|
|
|
|
// GNU Hash table requirement: it should be a power of 2,
|
|
|
|
// the minimum value is 1, even for an empty table.
|
|
|
|
// Expected results for a 32-bit target:
|
|
|
|
// calcMaskWords(0..4) = 1
|
|
|
|
// calcMaskWords(5..8) = 2
|
|
|
|
// calcMaskWords(9..16) = 4
|
|
|
|
// For a 64-bit target:
|
|
|
|
// calcMaskWords(0..8) = 1
|
|
|
|
// calcMaskWords(9..16) = 2
|
|
|
|
// calcMaskWords(17..32) = 4
|
|
|
|
template <class ELFT>
|
|
|
|
unsigned GnuHashTableSection<ELFT>::calcMaskWords(unsigned NumHashed) {
|
|
|
|
if (!NumHashed)
|
|
|
|
return 1;
|
|
|
|
return NextPowerOf2((NumHashed - 1) / sizeof(Elf_Off));
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void GnuHashTableSection<ELFT>::finalize() {
|
2015-11-02 18:46:14 +08:00
|
|
|
unsigned NumHashed = HashedSymbols.size();
|
2015-10-22 16:21:35 +08:00
|
|
|
NBuckets = calcNBuckets(NumHashed);
|
|
|
|
MaskWords = calcMaskWords(NumHashed);
|
|
|
|
// Second hash shift estimation: just predefined values.
|
|
|
|
Shift2 = ELFT::Is64Bits ? 6 : 5;
|
|
|
|
|
|
|
|
this->Header.sh_link = Out<ELFT>::DynSymTab->SectionIndex;
|
|
|
|
this->Header.sh_size = sizeof(Elf_Word) * 4 // Header
|
|
|
|
+ sizeof(Elf_Off) * MaskWords // Bloom Filter
|
|
|
|
+ sizeof(Elf_Word) * NBuckets // Hash Buckets
|
|
|
|
+ sizeof(Elf_Word) * NumHashed; // Hash Values
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void GnuHashTableSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
writeHeader(Buf);
|
2015-10-28 15:05:56 +08:00
|
|
|
if (HashedSymbols.empty())
|
2015-10-22 16:21:35 +08:00
|
|
|
return;
|
|
|
|
writeBloomFilter(Buf);
|
|
|
|
writeHashTable(Buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void GnuHashTableSection<ELFT>::writeHeader(uint8_t *&Buf) {
|
|
|
|
auto *P = reinterpret_cast<Elf_Word *>(Buf);
|
|
|
|
*P++ = NBuckets;
|
2015-10-28 15:05:56 +08:00
|
|
|
*P++ = Out<ELFT>::DynSymTab->getNumSymbols() - HashedSymbols.size();
|
2015-10-22 16:21:35 +08:00
|
|
|
*P++ = MaskWords;
|
|
|
|
*P++ = Shift2;
|
|
|
|
Buf = reinterpret_cast<uint8_t *>(P);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void GnuHashTableSection<ELFT>::writeBloomFilter(uint8_t *&Buf) {
|
|
|
|
unsigned C = sizeof(Elf_Off) * 8;
|
|
|
|
|
|
|
|
auto *Masks = reinterpret_cast<Elf_Off *>(Buf);
|
2015-10-28 15:05:56 +08:00
|
|
|
for (const HashedSymbolData &Item : HashedSymbols) {
|
|
|
|
size_t Pos = (Item.Hash / C) & (MaskWords - 1);
|
|
|
|
uintX_t V = (uintX_t(1) << (Item.Hash % C)) |
|
|
|
|
(uintX_t(1) << ((Item.Hash >> Shift2) % C));
|
2015-10-22 16:21:35 +08:00
|
|
|
Masks[Pos] |= V;
|
|
|
|
}
|
|
|
|
Buf += sizeof(Elf_Off) * MaskWords;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void GnuHashTableSection<ELFT>::writeHashTable(uint8_t *Buf) {
|
|
|
|
Elf_Word *Buckets = reinterpret_cast<Elf_Word *>(Buf);
|
|
|
|
Elf_Word *Values = Buckets + NBuckets;
|
|
|
|
|
|
|
|
int PrevBucket = -1;
|
|
|
|
int I = 0;
|
2015-10-28 15:05:56 +08:00
|
|
|
for (const HashedSymbolData &Item : HashedSymbols) {
|
|
|
|
int Bucket = Item.Hash % NBuckets;
|
2015-10-22 16:21:35 +08:00
|
|
|
assert(PrevBucket <= Bucket);
|
|
|
|
if (Bucket != PrevBucket) {
|
|
|
|
Buckets[Bucket] = Item.Body->getDynamicSymbolTableIndex();
|
|
|
|
PrevBucket = Bucket;
|
|
|
|
if (I > 0)
|
|
|
|
Values[I - 1] |= 1;
|
|
|
|
}
|
2015-10-28 15:05:56 +08:00
|
|
|
Values[I] = Item.Hash & ~1;
|
2015-10-22 16:21:35 +08:00
|
|
|
++I;
|
|
|
|
}
|
|
|
|
if (I > 0)
|
|
|
|
Values[I - 1] |= 1;
|
|
|
|
}
|
|
|
|
|
2015-11-02 22:33:11 +08:00
|
|
|
static bool includeInGnuHashTable(SymbolBody *B) {
|
|
|
|
// Assume that includeInDynamicSymtab() is already checked.
|
|
|
|
return !B->isUndefined();
|
|
|
|
}
|
|
|
|
|
2015-10-28 15:05:56 +08:00
|
|
|
template <class ELFT>
|
|
|
|
void GnuHashTableSection<ELFT>::addSymbols(std::vector<SymbolBody *> &Symbols) {
|
|
|
|
std::vector<SymbolBody *> NotHashed;
|
|
|
|
NotHashed.reserve(Symbols.size());
|
|
|
|
HashedSymbols.reserve(Symbols.size());
|
|
|
|
for (SymbolBody *B : Symbols) {
|
|
|
|
if (includeInGnuHashTable(B))
|
|
|
|
HashedSymbols.push_back(HashedSymbolData{B, hashGnu(B->getName())});
|
|
|
|
else
|
|
|
|
NotHashed.push_back(B);
|
|
|
|
}
|
|
|
|
if (HashedSymbols.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
unsigned NBuckets = calcNBuckets(HashedSymbols.size());
|
|
|
|
std::stable_sort(HashedSymbols.begin(), HashedSymbols.end(),
|
|
|
|
[&](const HashedSymbolData &L, const HashedSymbolData &R) {
|
|
|
|
return L.Hash % NBuckets < R.Hash % NBuckets;
|
|
|
|
});
|
|
|
|
|
|
|
|
Symbols = std::move(NotHashed);
|
|
|
|
for (const HashedSymbolData &Item : HashedSymbols)
|
|
|
|
Symbols.push_back(Item.Body);
|
|
|
|
}
|
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
2015-10-10 05:07:25 +08:00
|
|
|
DynamicSection<ELFT>::DynamicSection(SymbolTable<ELFT> &SymTab)
|
2015-10-16 06:27:29 +08:00
|
|
|
: OutputSectionBase<ELFT>(".dynamic", llvm::ELF::SHT_DYNAMIC,
|
|
|
|
llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE),
|
2015-10-08 03:18:16 +08:00
|
|
|
SymTab(SymTab) {
|
2015-10-16 06:27:29 +08:00
|
|
|
Elf_Shdr &Header = this->Header;
|
2015-09-26 01:19:10 +08:00
|
|
|
Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
|
|
|
|
Header.sh_entsize = ELFT::Is64Bits ? 16 : 8;
|
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT> void DynamicSection<ELFT>::finalize() {
|
2015-10-02 05:15:02 +08:00
|
|
|
if (this->Header.sh_size)
|
|
|
|
return; // Already finalized.
|
|
|
|
|
2015-10-16 06:27:29 +08:00
|
|
|
Elf_Shdr &Header = this->Header;
|
2015-10-16 04:55:22 +08:00
|
|
|
Header.sh_link = Out<ELFT>::DynStrTab->SectionIndex;
|
2015-09-22 05:38:08 +08:00
|
|
|
|
|
|
|
unsigned NumEntries = 0;
|
2015-10-08 03:18:16 +08:00
|
|
|
if (Out<ELFT>::RelaDyn->hasRelocs()) {
|
2015-09-22 05:38:08 +08:00
|
|
|
++NumEntries; // DT_RELA / DT_REL
|
2015-10-01 05:57:53 +08:00
|
|
|
++NumEntries; // DT_RELASZ / DT_RELSZ
|
|
|
|
++NumEntries; // DT_RELAENT / DT_RELENT
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
2015-10-20 16:54:27 +08:00
|
|
|
if (Out<ELFT>::RelaPlt && Out<ELFT>::RelaPlt->hasRelocs()) {
|
|
|
|
++NumEntries; // DT_JMPREL
|
|
|
|
++NumEntries; // DT_PLTRELSZ
|
|
|
|
++NumEntries; // DT_PLTGOT
|
|
|
|
++NumEntries; // DT_PLTREL
|
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
++NumEntries; // DT_SYMTAB
|
2015-10-01 05:57:53 +08:00
|
|
|
++NumEntries; // DT_SYMENT
|
2015-09-22 05:38:08 +08:00
|
|
|
++NumEntries; // DT_STRTAB
|
|
|
|
++NumEntries; // DT_STRSZ
|
2015-10-22 16:21:35 +08:00
|
|
|
if (Out<ELFT>::GnuHashTab)
|
|
|
|
++NumEntries; // DT_GNU_HASH
|
|
|
|
if (Out<ELFT>::HashTab)
|
|
|
|
++NumEntries; // DT_HASH
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-10-02 03:36:04 +08:00
|
|
|
if (!Config->RPath.empty()) {
|
2015-10-07 00:20:00 +08:00
|
|
|
++NumEntries; // DT_RUNPATH / DT_RPATH
|
2015-10-08 03:18:16 +08:00
|
|
|
Out<ELFT>::DynStrTab->add(Config->RPath);
|
2015-10-02 03:36:04 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!Config->SoName.empty()) {
|
|
|
|
++NumEntries; // DT_SONAME
|
2015-10-08 03:18:16 +08:00
|
|
|
Out<ELFT>::DynStrTab->add(Config->SoName);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-10-03 03:37:55 +08:00
|
|
|
if (PreInitArraySec)
|
|
|
|
NumEntries += 2;
|
|
|
|
if (InitArraySec)
|
|
|
|
NumEntries += 2;
|
|
|
|
if (FiniArraySec)
|
|
|
|
NumEntries += 2;
|
|
|
|
|
2015-10-10 05:07:25 +08:00
|
|
|
for (const std::unique_ptr<SharedFile<ELFT>> &F : SymTab.getSharedFiles()) {
|
2015-10-12 04:59:12 +08:00
|
|
|
if (!F->isNeeded())
|
|
|
|
continue;
|
2015-10-10 04:32:54 +08:00
|
|
|
Out<ELFT>::DynStrTab->add(F->getSoName());
|
|
|
|
++NumEntries;
|
|
|
|
}
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-10-05 18:29:46 +08:00
|
|
|
if (Symbol *S = SymTab.getSymbols().lookup(Config->Init))
|
|
|
|
InitSym = dyn_cast<ELFSymbolBody<ELFT>>(S->Body);
|
|
|
|
if (Symbol *S = SymTab.getSymbols().lookup(Config->Fini))
|
|
|
|
FiniSym = dyn_cast<ELFSymbolBody<ELFT>>(S->Body);
|
|
|
|
if (InitSym)
|
|
|
|
++NumEntries; // DT_INIT
|
|
|
|
if (FiniSym)
|
|
|
|
++NumEntries; // DT_FINI
|
2015-10-22 01:47:10 +08:00
|
|
|
|
|
|
|
if (Config->Bsymbolic)
|
|
|
|
DtFlags |= DF_SYMBOLIC;
|
|
|
|
if (Config->ZNodelete)
|
|
|
|
DtFlags1 |= DF_1_NODELETE;
|
|
|
|
if (Config->ZNow) {
|
|
|
|
DtFlags |= DF_BIND_NOW;
|
|
|
|
DtFlags1 |= DF_1_NOW;
|
|
|
|
}
|
|
|
|
if (Config->ZOrigin) {
|
|
|
|
DtFlags |= DF_ORIGIN;
|
|
|
|
DtFlags1 |= DF_1_ORIGIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (DtFlags)
|
2015-10-20 07:32:16 +08:00
|
|
|
++NumEntries; // DT_FLAGS
|
2015-10-22 01:47:10 +08:00
|
|
|
if (DtFlags1)
|
2015-10-07 23:00:21 +08:00
|
|
|
++NumEntries; // DT_FLAGS_1
|
2015-09-22 05:38:08 +08:00
|
|
|
++NumEntries; // DT_NULL
|
|
|
|
|
|
|
|
Header.sh_size = NumEntries * Header.sh_entsize;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
auto *P = reinterpret_cast<Elf_Dyn *>(Buf);
|
|
|
|
|
2015-10-02 09:33:31 +08:00
|
|
|
auto WritePtr = [&](int32_t Tag, uint64_t Val) {
|
|
|
|
P->d_tag = Tag;
|
|
|
|
P->d_un.d_ptr = Val;
|
2015-09-22 05:38:08 +08:00
|
|
|
++P;
|
2015-10-02 09:33:31 +08:00
|
|
|
};
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-10-02 09:33:31 +08:00
|
|
|
auto WriteVal = [&](int32_t Tag, uint32_t Val) {
|
|
|
|
P->d_tag = Tag;
|
|
|
|
P->d_un.d_val = Val;
|
2015-09-22 05:38:08 +08:00
|
|
|
++P;
|
2015-10-02 09:33:31 +08:00
|
|
|
};
|
2015-10-01 05:57:53 +08:00
|
|
|
|
2015-10-08 03:18:16 +08:00
|
|
|
if (Out<ELFT>::RelaDyn->hasRelocs()) {
|
|
|
|
bool IsRela = Out<ELFT>::RelaDyn->isRela();
|
|
|
|
WritePtr(IsRela ? DT_RELA : DT_REL, Out<ELFT>::RelaDyn->getVA());
|
|
|
|
WriteVal(IsRela ? DT_RELASZ : DT_RELSZ, Out<ELFT>::RelaDyn->getSize());
|
2015-10-02 09:33:31 +08:00
|
|
|
WriteVal(IsRela ? DT_RELAENT : DT_RELENT,
|
|
|
|
IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel));
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
2015-10-20 16:54:27 +08:00
|
|
|
if (Out<ELFT>::RelaPlt && Out<ELFT>::RelaPlt->hasRelocs()) {
|
|
|
|
WritePtr(DT_JMPREL, Out<ELFT>::RelaPlt->getVA());
|
|
|
|
WriteVal(DT_PLTRELSZ, Out<ELFT>::RelaPlt->getSize());
|
|
|
|
WritePtr(DT_PLTGOT, Out<ELFT>::GotPlt->getVA());
|
|
|
|
WriteVal(DT_PLTREL, Out<ELFT>::RelaPlt->isRela() ? DT_RELA : DT_REL);
|
|
|
|
}
|
2015-10-14 00:59:30 +08:00
|
|
|
|
2015-10-08 03:18:16 +08:00
|
|
|
WritePtr(DT_SYMTAB, Out<ELFT>::DynSymTab->getVA());
|
2015-10-02 09:33:31 +08:00
|
|
|
WritePtr(DT_SYMENT, sizeof(Elf_Sym));
|
2015-10-08 03:18:16 +08:00
|
|
|
WritePtr(DT_STRTAB, Out<ELFT>::DynStrTab->getVA());
|
|
|
|
WriteVal(DT_STRSZ, Out<ELFT>::DynStrTab->data().size());
|
2015-10-22 16:21:35 +08:00
|
|
|
if (Out<ELFT>::GnuHashTab)
|
|
|
|
WritePtr(DT_GNU_HASH, Out<ELFT>::GnuHashTab->getVA());
|
|
|
|
if (Out<ELFT>::HashTab)
|
|
|
|
WritePtr(DT_HASH, Out<ELFT>::HashTab->getVA());
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-10-02 09:33:31 +08:00
|
|
|
if (!Config->RPath.empty())
|
2015-10-07 00:20:00 +08:00
|
|
|
|
|
|
|
// If --enable-new-dtags is set lld emits DT_RUNPATH
|
|
|
|
// instead of DT_RPATH. The two tags are functionally
|
|
|
|
// equivalent except for the following:
|
|
|
|
// - DT_RUNPATH is searched after LD_LIBRARY_PATH, while
|
|
|
|
// DT_RPATH is searched before.
|
|
|
|
// - DT_RUNPATH is used only to search for direct
|
|
|
|
// dependencies of the object it's contained in, while
|
|
|
|
// DT_RPATH is used for indirect dependencies as well.
|
|
|
|
WriteVal(Config->EnableNewDtags ? DT_RUNPATH : DT_RPATH,
|
2015-10-25 01:44:52 +08:00
|
|
|
Out<ELFT>::DynStrTab->getOffset(Config->RPath));
|
2015-10-02 03:36:04 +08:00
|
|
|
|
2015-10-02 09:33:31 +08:00
|
|
|
if (!Config->SoName.empty())
|
2015-10-25 01:44:52 +08:00
|
|
|
WriteVal(DT_SONAME, Out<ELFT>::DynStrTab->getOffset(Config->SoName));
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-10-03 03:37:55 +08:00
|
|
|
auto WriteArray = [&](int32_t T1, int32_t T2,
|
2015-10-16 06:27:29 +08:00
|
|
|
const OutputSectionBase<ELFT> *Sec) {
|
2015-10-03 03:37:55 +08:00
|
|
|
if (!Sec)
|
|
|
|
return;
|
|
|
|
WritePtr(T1, Sec->getVA());
|
|
|
|
WriteVal(T2, Sec->getSize());
|
|
|
|
};
|
|
|
|
WriteArray(DT_PREINIT_ARRAY, DT_PREINIT_ARRAYSZ, PreInitArraySec);
|
|
|
|
WriteArray(DT_INIT_ARRAY, DT_INIT_ARRAYSZ, InitArraySec);
|
|
|
|
WriteArray(DT_FINI_ARRAY, DT_FINI_ARRAYSZ, FiniArraySec);
|
|
|
|
|
2015-10-10 05:07:25 +08:00
|
|
|
for (const std::unique_ptr<SharedFile<ELFT>> &F : SymTab.getSharedFiles())
|
2015-10-12 04:59:12 +08:00
|
|
|
if (F->isNeeded())
|
2015-10-25 01:44:52 +08:00
|
|
|
WriteVal(DT_NEEDED, Out<ELFT>::DynStrTab->getOffset(F->getSoName()));
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-10-05 18:29:46 +08:00
|
|
|
if (InitSym)
|
2015-10-08 03:18:16 +08:00
|
|
|
WritePtr(DT_INIT, getSymVA<ELFT>(*InitSym));
|
2015-10-05 18:29:46 +08:00
|
|
|
if (FiniSym)
|
2015-10-08 03:18:16 +08:00
|
|
|
WritePtr(DT_FINI, getSymVA<ELFT>(*FiniSym));
|
2015-10-22 01:47:10 +08:00
|
|
|
if (DtFlags)
|
|
|
|
WriteVal(DT_FLAGS, DtFlags);
|
|
|
|
if (DtFlags1)
|
|
|
|
WriteVal(DT_FLAGS_1, DtFlags1);
|
2015-10-02 09:33:31 +08:00
|
|
|
WriteVal(DT_NULL, 0);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
2015-10-08 03:18:16 +08:00
|
|
|
OutputSection<ELFT>::OutputSection(StringRef Name, uint32_t sh_type,
|
2015-09-26 01:19:10 +08:00
|
|
|
uintX_t sh_flags)
|
2015-10-16 06:27:29 +08:00
|
|
|
: OutputSectionBase<ELFT>(Name, sh_type, sh_flags) {}
|
2015-09-26 01:19:10 +08:00
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT>
|
2015-09-22 08:16:19 +08:00
|
|
|
void OutputSection<ELFT>::addSection(InputSection<ELFT> *C) {
|
|
|
|
Sections.push_back(C);
|
2015-10-15 09:58:40 +08:00
|
|
|
C->OutSec = this;
|
2015-09-22 05:38:08 +08:00
|
|
|
uint32_t Align = C->getAlign();
|
|
|
|
if (Align > this->Header.sh_addralign)
|
|
|
|
this->Header.sh_addralign = Align;
|
|
|
|
|
|
|
|
uintX_t Off = this->Header.sh_size;
|
|
|
|
Off = RoundUpToAlignment(Off, Align);
|
2015-10-15 09:58:40 +08:00
|
|
|
C->OutSecOff = Off;
|
2015-09-22 05:38:08 +08:00
|
|
|
Off += C->getSize();
|
|
|
|
this->Header.sh_size = Off;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
2015-10-08 03:18:16 +08:00
|
|
|
typename ELFFile<ELFT>::uintX_t lld::elf2::getSymVA(const SymbolBody &S) {
|
2015-09-26 02:19:03 +08:00
|
|
|
switch (S.kind()) {
|
2015-10-06 22:33:58 +08:00
|
|
|
case SymbolBody::DefinedSyntheticKind: {
|
|
|
|
auto &D = cast<DefinedSynthetic<ELFT>>(S);
|
|
|
|
return D.Section.getVA() + D.Sym.st_value;
|
|
|
|
}
|
2015-09-26 02:19:03 +08:00
|
|
|
case SymbolBody::DefinedAbsoluteKind:
|
2015-10-06 22:33:58 +08:00
|
|
|
return cast<DefinedAbsolute<ELFT>>(S).Sym.st_value;
|
2015-09-26 02:19:03 +08:00
|
|
|
case SymbolBody::DefinedRegularKind: {
|
|
|
|
const auto &DR = cast<DefinedRegular<ELFT>>(S);
|
2015-10-24 03:55:11 +08:00
|
|
|
InputSectionBase<ELFT> &SC = DR.Section;
|
2015-11-04 06:39:09 +08:00
|
|
|
if (DR.Sym.getType() == STT_TLS)
|
|
|
|
return SC.OutSec->getVA() + SC.getOffset(DR.Sym) -
|
2015-11-07 06:14:44 +08:00
|
|
|
Out<ELFT>::TlsPhdr->p_vaddr;
|
2015-10-20 05:00:02 +08:00
|
|
|
return SC.OutSec->getVA() + SC.getOffset(DR.Sym);
|
2015-09-26 02:19:03 +08:00
|
|
|
}
|
|
|
|
case SymbolBody::DefinedCommonKind:
|
2015-10-08 03:18:16 +08:00
|
|
|
return Out<ELFT>::Bss->getVA() + cast<DefinedCommon<ELFT>>(S).OffsetInBSS;
|
2015-10-29 00:48:58 +08:00
|
|
|
case SymbolBody::SharedKind: {
|
|
|
|
auto &SS = cast<SharedSymbol<ELFT>>(S);
|
2015-11-03 22:34:11 +08:00
|
|
|
if (SS.needsCopy())
|
2015-10-29 00:48:58 +08:00
|
|
|
return Out<ELFT>::Bss->getVA() + SS.OffsetInBSS;
|
|
|
|
return 0;
|
|
|
|
}
|
2015-09-26 02:19:03 +08:00
|
|
|
case SymbolBody::UndefinedKind:
|
|
|
|
return 0;
|
|
|
|
case SymbolBody::LazyKind:
|
2015-10-06 22:33:58 +08:00
|
|
|
assert(S.isUsedInRegularObj() && "Lazy symbol reached writer");
|
|
|
|
return 0;
|
2015-09-26 02:19:03 +08:00
|
|
|
}
|
2015-10-07 16:21:34 +08:00
|
|
|
llvm_unreachable("Invalid symbol kind");
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-10-14 03:51:57 +08:00
|
|
|
// Returns a VA which a relocatin RI refers to. Used only for local symbols.
|
|
|
|
// For non-local symbols, use getSymVA instead.
|
2015-10-20 04:24:44 +08:00
|
|
|
template <class ELFT, bool IsRela>
|
2015-09-22 05:38:08 +08:00
|
|
|
typename ELFFile<ELFT>::uintX_t
|
2015-10-13 04:28:22 +08:00
|
|
|
lld::elf2::getLocalRelTarget(const ObjectFile<ELFT> &File,
|
2015-10-20 04:24:44 +08:00
|
|
|
const Elf_Rel_Impl<ELFT, IsRela> &RI) {
|
|
|
|
typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
|
|
|
|
typedef typename ELFFile<ELFT>::uintX_t uintX_t;
|
|
|
|
|
|
|
|
uintX_t Addend = getAddend<ELFT>(RI);
|
|
|
|
|
2015-10-17 05:55:40 +08:00
|
|
|
// PPC64 has a special relocation representing the TOC base pointer
|
|
|
|
// that does not have a corresponding symbol.
|
2015-10-17 06:37:32 +08:00
|
|
|
if (Config->EMachine == EM_PPC64 && RI.getType(false) == R_PPC64_TOC)
|
2015-10-20 04:24:44 +08:00
|
|
|
return getPPC64TocBase() + Addend;
|
2015-10-17 05:55:40 +08:00
|
|
|
|
2015-10-13 04:28:22 +08:00
|
|
|
const Elf_Sym *Sym =
|
|
|
|
File.getObj().getRelocationSymbol(&RI, File.getSymbolTable());
|
|
|
|
|
|
|
|
if (!Sym)
|
2015-10-17 05:55:40 +08:00
|
|
|
error("Unsupported relocation without symbol");
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-10-10 03:25:07 +08:00
|
|
|
// According to the ELF spec reference to a local symbol from outside
|
|
|
|
// the group are not allowed. Unfortunately .eh_frame breaks that rule
|
|
|
|
// and must be treated specially. For now we just replace the symbol with
|
|
|
|
// 0.
|
2015-10-20 05:00:02 +08:00
|
|
|
InputSectionBase<ELFT> *Section = File.getSection(*Sym);
|
2015-11-10 01:44:10 +08:00
|
|
|
if (Section == &InputSection<ELFT>::Discarded || !Section->isLive())
|
2015-10-20 04:24:44 +08:00
|
|
|
return Addend;
|
2015-10-10 03:25:07 +08:00
|
|
|
|
2015-10-20 05:00:02 +08:00
|
|
|
uintX_t VA = Section->OutSec->getVA();
|
|
|
|
if (isa<InputSection<ELFT>>(Section))
|
|
|
|
return VA + Section->getOffset(*Sym) + Addend;
|
|
|
|
|
|
|
|
uintX_t Offset = Sym->st_value;
|
|
|
|
if (Sym->getType() == STT_SECTION) {
|
|
|
|
Offset += Addend;
|
2015-10-21 06:08:49 +08:00
|
|
|
Addend = 0;
|
2015-10-20 05:00:02 +08:00
|
|
|
}
|
|
|
|
return VA + cast<MergeInputSection<ELFT>>(Section)->getOffset(Offset) +
|
|
|
|
Addend;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-10-14 03:51:57 +08:00
|
|
|
// Returns true if a symbol can be replaced at load-time by a symbol
|
|
|
|
// with the same name defined in other ELF executable or DSO.
|
2015-10-15 02:42:16 +08:00
|
|
|
bool lld::elf2::canBePreempted(const SymbolBody *Body, bool NeedsGot) {
|
2015-10-07 07:56:53 +08:00
|
|
|
if (!Body)
|
2015-10-14 03:51:57 +08:00
|
|
|
return false; // Body is a local symbol.
|
2015-10-07 12:22:55 +08:00
|
|
|
if (Body->isShared())
|
|
|
|
return true;
|
2015-10-15 02:42:16 +08:00
|
|
|
|
|
|
|
if (Body->isUndefined()) {
|
|
|
|
if (!Body->isWeak())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// This is an horrible corner case. Ideally we would like to say that any
|
|
|
|
// undefined symbol can be preempted so that the dynamic linker has a
|
|
|
|
// chance of finding it at runtime.
|
|
|
|
//
|
|
|
|
// The problem is that the code sequence used to test for weak undef
|
|
|
|
// functions looks like
|
|
|
|
// if (func) func()
|
|
|
|
// If the code is -fPIC the first reference is a load from the got and
|
|
|
|
// everything works.
|
|
|
|
// If the code is not -fPIC there is no reasonable way to solve it:
|
|
|
|
// * A relocation writing to the text segment will fail (it is ro).
|
|
|
|
// * A copy relocation doesn't work for functions.
|
|
|
|
// * The trick of using a plt entry as the address would fail here since
|
|
|
|
// the plt entry would have a non zero address.
|
|
|
|
// Since we cannot do anything better, we just resolve the symbol to 0 and
|
|
|
|
// don't produce a dynamic relocation.
|
2015-10-17 06:11:05 +08:00
|
|
|
//
|
|
|
|
// As an extra hack, assume that if we are producing a shared library the
|
|
|
|
// user knows what he or she is doing and can handle a dynamic relocation.
|
|
|
|
return Config->Shared || NeedsGot;
|
2015-10-15 02:42:16 +08:00
|
|
|
}
|
2015-10-07 07:56:53 +08:00
|
|
|
if (!Config->Shared)
|
|
|
|
return false;
|
2015-10-22 02:13:47 +08:00
|
|
|
return Body->getVisibility() == STV_DEFAULT;
|
2015-10-07 07:56:53 +08:00
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
|
2015-09-22 08:16:19 +08:00
|
|
|
for (InputSection<ELFT> *C : Sections)
|
2015-10-08 03:18:16 +08:00
|
|
|
C->writeTo(Buf);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-10-20 05:00:02 +08:00
|
|
|
template <class ELFT>
|
|
|
|
MergeOutputSection<ELFT>::MergeOutputSection(StringRef Name, uint32_t sh_type,
|
|
|
|
uintX_t sh_flags)
|
|
|
|
: OutputSectionBase<ELFT>(Name, sh_type, sh_flags) {}
|
|
|
|
|
|
|
|
template <class ELFT> void MergeOutputSection<ELFT>::writeTo(uint8_t *Buf) {
|
2015-10-25 06:51:01 +08:00
|
|
|
if (shouldTailMerge()) {
|
|
|
|
StringRef Data = Builder.data();
|
2015-10-20 05:00:02 +08:00
|
|
|
memcpy(Buf, Data.data(), Data.size());
|
2015-10-25 06:51:01 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (const std::pair<StringRef, size_t> &P : Builder.getMap()) {
|
|
|
|
StringRef Data = P.first;
|
|
|
|
memcpy(Buf + P.second, Data.data(), Data.size());
|
2015-10-20 05:00:02 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-25 06:51:01 +08:00
|
|
|
static size_t findNull(StringRef S, size_t EntSize) {
|
|
|
|
// Optimize the common case.
|
|
|
|
if (EntSize == 1)
|
|
|
|
return S.find(0);
|
|
|
|
|
|
|
|
for (unsigned I = 0, N = S.size(); I != N; I += EntSize) {
|
|
|
|
const char *B = S.begin() + I;
|
|
|
|
if (std::all_of(B, B + EntSize, [](char C) { return C == 0; }))
|
|
|
|
return I;
|
|
|
|
}
|
|
|
|
return StringRef::npos;
|
|
|
|
}
|
|
|
|
|
2015-10-20 05:00:02 +08:00
|
|
|
template <class ELFT>
|
|
|
|
void MergeOutputSection<ELFT>::addSection(MergeInputSection<ELFT> *S) {
|
|
|
|
S->OutSec = this;
|
|
|
|
uint32_t Align = S->getAlign();
|
|
|
|
if (Align > this->Header.sh_addralign)
|
|
|
|
this->Header.sh_addralign = Align;
|
|
|
|
|
2015-10-25 06:51:01 +08:00
|
|
|
ArrayRef<uint8_t> D = S->getSectionData();
|
2015-10-26 04:14:07 +08:00
|
|
|
StringRef Data((const char *)D.data(), D.size());
|
2015-10-20 05:00:02 +08:00
|
|
|
uintX_t EntSize = S->getSectionHdr()->sh_entsize;
|
2015-10-25 06:51:01 +08:00
|
|
|
uintX_t Offset = 0;
|
|
|
|
|
|
|
|
if (this->Header.sh_flags & SHF_STRINGS) {
|
|
|
|
while (!Data.empty()) {
|
|
|
|
size_t End = findNull(Data, EntSize);
|
|
|
|
if (End == StringRef::npos)
|
|
|
|
error("String is not null terminated");
|
|
|
|
StringRef Entry = Data.substr(0, End + EntSize);
|
|
|
|
size_t OutputOffset = Builder.add(Entry);
|
|
|
|
if (shouldTailMerge())
|
|
|
|
OutputOffset = -1;
|
|
|
|
S->Offsets.push_back(std::make_pair(Offset, OutputOffset));
|
|
|
|
uintX_t Size = End + EntSize;
|
|
|
|
Data = Data.substr(Size);
|
|
|
|
Offset += Size;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (unsigned I = 0, N = Data.size(); I != N; I += EntSize) {
|
|
|
|
StringRef Entry = Data.substr(I, EntSize);
|
|
|
|
size_t OutputOffset = Builder.add(Entry);
|
|
|
|
S->Offsets.push_back(std::make_pair(Offset, OutputOffset));
|
|
|
|
Offset += EntSize;
|
|
|
|
}
|
2015-10-20 05:00:02 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
2015-10-25 06:51:01 +08:00
|
|
|
unsigned MergeOutputSection<ELFT>::getOffset(StringRef Val) {
|
|
|
|
return Builder.getOffset(Val);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> bool MergeOutputSection<ELFT>::shouldTailMerge() const {
|
|
|
|
return Config->Optimize >= 2 && this->Header.sh_flags & SHF_STRINGS;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void MergeOutputSection<ELFT>::finalize() {
|
|
|
|
if (shouldTailMerge())
|
|
|
|
Builder.finalize();
|
|
|
|
this->Header.sh_size = Builder.getSize();
|
2015-10-20 05:00:02 +08:00
|
|
|
}
|
|
|
|
|
2015-10-16 06:27:29 +08:00
|
|
|
template <class ELFT>
|
2015-10-21 01:21:35 +08:00
|
|
|
StringTableSection<ELFT>::StringTableSection(StringRef Name, bool Dynamic)
|
|
|
|
: OutputSectionBase<ELFT>(Name, llvm::ELF::SHT_STRTAB,
|
2015-10-16 06:27:29 +08:00
|
|
|
Dynamic ? (uintX_t)llvm::ELF::SHF_ALLOC : 0),
|
2015-09-26 01:19:10 +08:00
|
|
|
Dynamic(Dynamic) {
|
|
|
|
this->Header.sh_addralign = 1;
|
|
|
|
}
|
|
|
|
|
2015-10-16 06:27:29 +08:00
|
|
|
template <class ELFT> void StringTableSection<ELFT>::writeTo(uint8_t *Buf) {
|
2015-09-22 05:38:08 +08:00
|
|
|
StringRef Data = StrTabBuilder.data();
|
|
|
|
memcpy(Buf, Data.data(), Data.size());
|
|
|
|
}
|
|
|
|
|
2015-10-05 23:24:04 +08:00
|
|
|
template <class ELFT> bool lld::elf2::includeInSymtab(const SymbolBody &B) {
|
2015-09-22 05:38:08 +08:00
|
|
|
if (!B.isUsedInRegularObj())
|
|
|
|
return false;
|
2015-10-05 23:24:04 +08:00
|
|
|
|
|
|
|
// Don't include synthetic symbols like __init_array_start in every output.
|
|
|
|
if (auto *U = dyn_cast<DefinedAbsolute<ELFT>>(&B))
|
|
|
|
if (&U->Sym == &DefinedAbsolute<ELFT>::IgnoreUndef)
|
|
|
|
return false;
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-09-23 07:38:23 +08:00
|
|
|
bool lld::elf2::includeInDynamicSymtab(const SymbolBody &B) {
|
2015-10-22 02:13:47 +08:00
|
|
|
uint8_t V = B.getVisibility();
|
2015-10-05 23:24:04 +08:00
|
|
|
if (V != STV_DEFAULT && V != STV_PROTECTED)
|
|
|
|
return false;
|
|
|
|
|
2015-09-23 07:38:23 +08:00
|
|
|
if (Config->ExportDynamic || Config->Shared)
|
|
|
|
return true;
|
|
|
|
return B.isUsedInDynamicReloc();
|
|
|
|
}
|
|
|
|
|
2015-10-06 00:25:43 +08:00
|
|
|
template <class ELFT>
|
2015-10-10 03:25:07 +08:00
|
|
|
bool lld::elf2::shouldKeepInSymtab(const ObjectFile<ELFT> &File,
|
|
|
|
StringRef SymName,
|
2015-10-06 00:25:43 +08:00
|
|
|
const typename ELFFile<ELFT>::Elf_Sym &Sym) {
|
|
|
|
if (Sym.getType() == STT_SECTION)
|
|
|
|
return false;
|
|
|
|
|
2015-10-10 03:25:07 +08:00
|
|
|
// If sym references a section in a discarded group, don't keep it.
|
2015-10-16 23:29:48 +08:00
|
|
|
if (File.getSection(Sym) == &InputSection<ELFT>::Discarded)
|
|
|
|
return false;
|
2015-10-10 03:25:07 +08:00
|
|
|
|
2015-09-26 08:47:56 +08:00
|
|
|
if (Config->DiscardNone)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// ELF defines dynamic locals as symbols which name starts with ".L".
|
|
|
|
return !(Config->DiscardLocals && SymName.startswith(".L"));
|
|
|
|
}
|
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
|
|
|
SymbolTableSection<ELFT>::SymbolTableSection(
|
2015-10-16 06:27:29 +08:00
|
|
|
SymbolTable<ELFT> &Table, StringTableSection<ELFT> &StrTabSec)
|
|
|
|
: OutputSectionBase<ELFT>(
|
2015-09-26 01:19:10 +08:00
|
|
|
StrTabSec.isDynamic() ? ".dynsym" : ".symtab",
|
|
|
|
StrTabSec.isDynamic() ? llvm::ELF::SHT_DYNSYM : llvm::ELF::SHT_SYMTAB,
|
|
|
|
StrTabSec.isDynamic() ? (uintX_t)llvm::ELF::SHF_ALLOC : 0),
|
2015-10-08 03:18:16 +08:00
|
|
|
Table(Table), StrTabSec(StrTabSec) {
|
2015-10-16 06:27:29 +08:00
|
|
|
typedef OutputSectionBase<ELFT> Base;
|
|
|
|
typename Base::Elf_Shdr &Header = this->Header;
|
2015-09-26 01:19:10 +08:00
|
|
|
|
|
|
|
Header.sh_entsize = sizeof(Elf_Sym);
|
|
|
|
Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
|
|
|
|
}
|
|
|
|
|
2015-10-08 00:58:54 +08:00
|
|
|
template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
|
2015-11-02 18:46:14 +08:00
|
|
|
if (this->Header.sh_size)
|
|
|
|
return; // Already finalized.
|
|
|
|
|
2015-10-08 00:58:54 +08:00
|
|
|
this->Header.sh_size = getNumSymbols() * sizeof(Elf_Sym);
|
2015-10-16 04:55:22 +08:00
|
|
|
this->Header.sh_link = StrTabSec.SectionIndex;
|
2015-10-08 00:58:54 +08:00
|
|
|
this->Header.sh_info = NumLocals + 1;
|
2015-10-21 05:47:58 +08:00
|
|
|
|
|
|
|
if (!StrTabSec.isDynamic()) {
|
|
|
|
std::stable_sort(Symbols.begin(), Symbols.end(),
|
2015-10-28 15:05:56 +08:00
|
|
|
[](SymbolBody *L, SymbolBody *R) {
|
|
|
|
return getSymbolBinding(L) == STB_LOCAL &&
|
|
|
|
getSymbolBinding(R) != STB_LOCAL;
|
2015-10-21 05:47:58 +08:00
|
|
|
});
|
|
|
|
return;
|
|
|
|
}
|
2015-10-28 15:05:56 +08:00
|
|
|
if (Out<ELFT>::GnuHashTab)
|
|
|
|
// NB: It also sorts Symbols to meet the GNU hash table requirements.
|
|
|
|
Out<ELFT>::GnuHashTab->addSymbols(Symbols);
|
2015-10-21 05:47:58 +08:00
|
|
|
size_t I = 0;
|
2015-10-28 15:05:56 +08:00
|
|
|
for (SymbolBody *B : Symbols)
|
|
|
|
B->setDynamicSymbolTableIndex(++I);
|
2015-10-08 00:58:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
2015-10-21 05:47:58 +08:00
|
|
|
void SymbolTableSection<ELFT>::addLocalSymbol(StringRef Name) {
|
2015-10-08 00:58:54 +08:00
|
|
|
StrTabSec.add(Name);
|
|
|
|
++NumVisible;
|
2015-10-21 05:47:58 +08:00
|
|
|
++NumLocals;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void SymbolTableSection<ELFT>::addSymbol(SymbolBody *Body) {
|
|
|
|
StrTabSec.add(Body->getName());
|
2015-10-28 15:05:56 +08:00
|
|
|
Symbols.push_back(Body);
|
2015-10-21 05:47:58 +08:00
|
|
|
++NumVisible;
|
2015-10-08 00:58:54 +08:00
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
Buf += sizeof(Elf_Sym);
|
|
|
|
|
|
|
|
// All symbols with STB_LOCAL binding precede the weak and global symbols.
|
|
|
|
// .dynsym only contains global symbols.
|
2015-09-30 08:32:10 +08:00
|
|
|
if (!Config->DiscardAll && !StrTabSec.isDynamic())
|
|
|
|
writeLocalSymbols(Buf);
|
|
|
|
|
|
|
|
writeGlobalSymbols(Buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void SymbolTableSection<ELFT>::writeLocalSymbols(uint8_t *&Buf) {
|
|
|
|
// Iterate over all input object files to copy their local symbols
|
|
|
|
// to the output symbol table pointed by Buf.
|
2015-10-10 05:07:25 +08:00
|
|
|
for (const std::unique_ptr<ObjectFile<ELFT>> &File : Table.getObjectFiles()) {
|
|
|
|
Elf_Sym_Range Syms = File->getLocalSymbols();
|
2015-09-30 08:32:10 +08:00
|
|
|
for (const Elf_Sym &Sym : Syms) {
|
2015-10-10 05:07:25 +08:00
|
|
|
ErrorOr<StringRef> SymNameOrErr = Sym.getName(File->getStringTable());
|
2015-10-10 00:15:57 +08:00
|
|
|
error(SymNameOrErr);
|
|
|
|
StringRef SymName = *SymNameOrErr;
|
2015-10-10 05:07:25 +08:00
|
|
|
if (!shouldKeepInSymtab<ELFT>(*File, SymName, Sym))
|
2015-09-30 08:32:10 +08:00
|
|
|
continue;
|
2015-10-10 03:25:07 +08:00
|
|
|
|
2015-09-30 08:54:29 +08:00
|
|
|
auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
|
2015-10-20 05:00:02 +08:00
|
|
|
uintX_t VA = 0;
|
2015-10-16 23:29:48 +08:00
|
|
|
if (Sym.st_shndx == SHN_ABS) {
|
2015-09-30 08:32:10 +08:00
|
|
|
ESym->st_shndx = SHN_ABS;
|
2015-10-20 05:00:02 +08:00
|
|
|
VA = Sym.st_value;
|
2015-09-30 08:32:10 +08:00
|
|
|
} else {
|
2015-10-24 03:55:11 +08:00
|
|
|
InputSectionBase<ELFT> *Section = File->getSection(Sym);
|
ELF2: Implement --gc-sections.
Section garbage collection is a feature to remove unused sections
from outputs. Unused sections are sections that cannot be reachable
from known GC-root symbols or sections. Naturally the feature is
implemented as a mark-sweep garbage collector.
In this patch, I added Live bit to InputSectionBase. If and only
if Live bit is on, the section will be written to the output.
Starting from GC-root symbols or sections, a new function, markLive(),
visits all reachable sections and sets their Live bits. Writer then
ignores sections whose Live bit is off, so that such sections are
excluded from the output.
This change has small negative impact on performance if you use
the feature because making sections means more work. The time to
link Clang changes from 0.356s to 0.386s, or +8%.
It reduces Clang size from 57,764,984 bytes to 55,296,600 bytes.
That is 4.3% reduction.
http://reviews.llvm.org/D13950
llvm-svn: 251043
2015-10-23 02:49:53 +08:00
|
|
|
if (!Section->isLive())
|
|
|
|
continue;
|
2015-10-20 05:00:02 +08:00
|
|
|
const OutputSectionBase<ELFT> *OutSec = Section->OutSec;
|
|
|
|
ESym->st_shndx = OutSec->SectionIndex;
|
|
|
|
VA += OutSec->getVA() + Section->getOffset(Sym);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
2015-10-25 01:44:52 +08:00
|
|
|
ESym->st_name = StrTabSec.getOffset(SymName);
|
ELF2: Implement --gc-sections.
Section garbage collection is a feature to remove unused sections
from outputs. Unused sections are sections that cannot be reachable
from known GC-root symbols or sections. Naturally the feature is
implemented as a mark-sweep garbage collector.
In this patch, I added Live bit to InputSectionBase. If and only
if Live bit is on, the section will be written to the output.
Starting from GC-root symbols or sections, a new function, markLive(),
visits all reachable sections and sets their Live bits. Writer then
ignores sections whose Live bit is off, so that such sections are
excluded from the output.
This change has small negative impact on performance if you use
the feature because making sections means more work. The time to
link Clang changes from 0.356s to 0.386s, or +8%.
It reduces Clang size from 57,764,984 bytes to 55,296,600 bytes.
That is 4.3% reduction.
http://reviews.llvm.org/D13950
llvm-svn: 251043
2015-10-23 02:49:53 +08:00
|
|
|
ESym->st_size = Sym.st_size;
|
|
|
|
ESym->setBindingAndType(Sym.getBinding(), Sym.getType());
|
2015-09-30 08:32:10 +08:00
|
|
|
ESym->st_value = VA;
|
ELF2: Implement --gc-sections.
Section garbage collection is a feature to remove unused sections
from outputs. Unused sections are sections that cannot be reachable
from known GC-root symbols or sections. Naturally the feature is
implemented as a mark-sweep garbage collector.
In this patch, I added Live bit to InputSectionBase. If and only
if Live bit is on, the section will be written to the output.
Starting from GC-root symbols or sections, a new function, markLive(),
visits all reachable sections and sets their Live bits. Writer then
ignores sections whose Live bit is off, so that such sections are
excluded from the output.
This change has small negative impact on performance if you use
the feature because making sections means more work. The time to
link Clang changes from 0.356s to 0.386s, or +8%.
It reduces Clang size from 57,764,984 bytes to 55,296,600 bytes.
That is 4.3% reduction.
http://reviews.llvm.org/D13950
llvm-svn: 251043
2015-10-23 02:49:53 +08:00
|
|
|
Buf += sizeof(*ESym);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
}
|
2015-09-30 08:32:10 +08:00
|
|
|
}
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-09-30 08:32:10 +08:00
|
|
|
template <class ELFT>
|
2015-10-19 16:01:51 +08:00
|
|
|
void SymbolTableSection<ELFT>::writeGlobalSymbols(uint8_t *Buf) {
|
2015-09-30 08:32:10 +08:00
|
|
|
// Write the internal symbol table contents to the output symbol table
|
|
|
|
// pointed by Buf.
|
2015-10-21 05:47:58 +08:00
|
|
|
auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
|
2015-10-28 15:05:56 +08:00
|
|
|
for (SymbolBody *Body : Symbols) {
|
2015-10-16 06:27:29 +08:00
|
|
|
const OutputSectionBase<ELFT> *OutSec = nullptr;
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-10-06 22:33:58 +08:00
|
|
|
switch (Body->kind()) {
|
2015-09-26 02:56:53 +08:00
|
|
|
case SymbolBody::DefinedSyntheticKind:
|
2015-10-08 01:04:18 +08:00
|
|
|
OutSec = &cast<DefinedSynthetic<ELFT>>(Body)->Section;
|
2015-09-26 02:56:53 +08:00
|
|
|
break;
|
ELF2: Implement --gc-sections.
Section garbage collection is a feature to remove unused sections
from outputs. Unused sections are sections that cannot be reachable
from known GC-root symbols or sections. Naturally the feature is
implemented as a mark-sweep garbage collector.
In this patch, I added Live bit to InputSectionBase. If and only
if Live bit is on, the section will be written to the output.
Starting from GC-root symbols or sections, a new function, markLive(),
visits all reachable sections and sets their Live bits. Writer then
ignores sections whose Live bit is off, so that such sections are
excluded from the output.
This change has small negative impact on performance if you use
the feature because making sections means more work. The time to
link Clang changes from 0.356s to 0.386s, or +8%.
It reduces Clang size from 57,764,984 bytes to 55,296,600 bytes.
That is 4.3% reduction.
http://reviews.llvm.org/D13950
llvm-svn: 251043
2015-10-23 02:49:53 +08:00
|
|
|
case SymbolBody::DefinedRegularKind: {
|
|
|
|
auto *Sym = cast<DefinedRegular<ELFT>>(Body->repl());
|
|
|
|
if (!Sym->Section.isLive())
|
|
|
|
continue;
|
|
|
|
OutSec = Sym->Section.OutSec;
|
2015-09-22 05:38:08 +08:00
|
|
|
break;
|
ELF2: Implement --gc-sections.
Section garbage collection is a feature to remove unused sections
from outputs. Unused sections are sections that cannot be reachable
from known GC-root symbols or sections. Naturally the feature is
implemented as a mark-sweep garbage collector.
In this patch, I added Live bit to InputSectionBase. If and only
if Live bit is on, the section will be written to the output.
Starting from GC-root symbols or sections, a new function, markLive(),
visits all reachable sections and sets their Live bits. Writer then
ignores sections whose Live bit is off, so that such sections are
excluded from the output.
This change has small negative impact on performance if you use
the feature because making sections means more work. The time to
link Clang changes from 0.356s to 0.386s, or +8%.
It reduces Clang size from 57,764,984 bytes to 55,296,600 bytes.
That is 4.3% reduction.
http://reviews.llvm.org/D13950
llvm-svn: 251043
2015-10-23 02:49:53 +08:00
|
|
|
}
|
2015-09-22 05:38:08 +08:00
|
|
|
case SymbolBody::DefinedCommonKind:
|
2015-10-08 03:18:16 +08:00
|
|
|
OutSec = Out<ELFT>::Bss;
|
2015-09-22 05:38:08 +08:00
|
|
|
break;
|
2015-10-29 00:48:58 +08:00
|
|
|
case SymbolBody::SharedKind: {
|
2015-11-03 22:34:11 +08:00
|
|
|
if (cast<SharedSymbol<ELFT>>(Body)->needsCopy())
|
2015-10-29 00:48:58 +08:00
|
|
|
OutSec = Out<ELFT>::Bss;
|
|
|
|
break;
|
|
|
|
}
|
2015-09-22 05:38:08 +08:00
|
|
|
case SymbolBody::UndefinedKind:
|
|
|
|
case SymbolBody::DefinedAbsoluteKind:
|
|
|
|
case SymbolBody::LazyKind:
|
2015-10-06 22:33:58 +08:00
|
|
|
break;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
ELF2: Implement --gc-sections.
Section garbage collection is a feature to remove unused sections
from outputs. Unused sections are sections that cannot be reachable
from known GC-root symbols or sections. Naturally the feature is
implemented as a mark-sweep garbage collector.
In this patch, I added Live bit to InputSectionBase. If and only
if Live bit is on, the section will be written to the output.
Starting from GC-root symbols or sections, a new function, markLive(),
visits all reachable sections and sets their Live bits. Writer then
ignores sections whose Live bit is off, so that such sections are
excluded from the output.
This change has small negative impact on performance if you use
the feature because making sections means more work. The time to
link Clang changes from 0.356s to 0.386s, or +8%.
It reduces Clang size from 57,764,984 bytes to 55,296,600 bytes.
That is 4.3% reduction.
http://reviews.llvm.org/D13950
llvm-svn: 251043
2015-10-23 02:49:53 +08:00
|
|
|
StringRef Name = Body->getName();
|
2015-10-25 01:44:52 +08:00
|
|
|
ESym->st_name = StrTabSec.getOffset(Name);
|
ELF2: Implement --gc-sections.
Section garbage collection is a feature to remove unused sections
from outputs. Unused sections are sections that cannot be reachable
from known GC-root symbols or sections. Naturally the feature is
implemented as a mark-sweep garbage collector.
In this patch, I added Live bit to InputSectionBase. If and only
if Live bit is on, the section will be written to the output.
Starting from GC-root symbols or sections, a new function, markLive(),
visits all reachable sections and sets their Live bits. Writer then
ignores sections whose Live bit is off, so that such sections are
excluded from the output.
This change has small negative impact on performance if you use
the feature because making sections means more work. The time to
link Clang changes from 0.356s to 0.386s, or +8%.
It reduces Clang size from 57,764,984 bytes to 55,296,600 bytes.
That is 4.3% reduction.
http://reviews.llvm.org/D13950
llvm-svn: 251043
2015-10-23 02:49:53 +08:00
|
|
|
|
2015-10-06 22:33:58 +08:00
|
|
|
unsigned char Type = STT_NOTYPE;
|
|
|
|
uintX_t Size = 0;
|
|
|
|
if (const auto *EBody = dyn_cast<ELFSymbolBody<ELFT>>(Body)) {
|
|
|
|
const Elf_Sym &InputSym = EBody->Sym;
|
|
|
|
Type = InputSym.getType();
|
|
|
|
Size = InputSym.st_size;
|
|
|
|
}
|
|
|
|
|
2015-10-21 04:52:14 +08:00
|
|
|
ESym->setBindingAndType(getSymbolBinding(Body), Type);
|
2015-10-06 22:33:58 +08:00
|
|
|
ESym->st_size = Size;
|
2015-10-22 02:13:47 +08:00
|
|
|
ESym->setVisibility(Body->getVisibility());
|
2015-10-08 03:18:16 +08:00
|
|
|
ESym->st_value = getSymVA<ELFT>(*Body);
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-10-06 22:33:58 +08:00
|
|
|
if (isa<DefinedAbsolute<ELFT>>(Body))
|
2015-10-06 22:17:53 +08:00
|
|
|
ESym->st_shndx = SHN_ABS;
|
2015-10-08 01:04:18 +08:00
|
|
|
else if (OutSec)
|
2015-10-16 04:55:22 +08:00
|
|
|
ESym->st_shndx = OutSec->SectionIndex;
|
2015-10-21 05:47:58 +08:00
|
|
|
|
|
|
|
++ESym;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-21 04:52:14 +08:00
|
|
|
template <class ELFT>
|
|
|
|
uint8_t SymbolTableSection<ELFT>::getSymbolBinding(SymbolBody *Body) {
|
2015-10-22 02:13:47 +08:00
|
|
|
uint8_t Visibility = Body->getVisibility();
|
2015-10-21 04:52:14 +08:00
|
|
|
if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
|
|
|
|
return STB_LOCAL;
|
|
|
|
if (const auto *EBody = dyn_cast<ELFSymbolBody<ELFT>>(Body))
|
|
|
|
return EBody->Sym.getBinding();
|
|
|
|
return Body->isWeak() ? STB_WEAK : STB_GLOBAL;
|
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
namespace lld {
|
|
|
|
namespace elf2 {
|
2015-10-16 06:27:29 +08:00
|
|
|
template class OutputSectionBase<ELF32LE>;
|
|
|
|
template class OutputSectionBase<ELF32BE>;
|
|
|
|
template class OutputSectionBase<ELF64LE>;
|
|
|
|
template class OutputSectionBase<ELF64BE>;
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-10-20 16:54:27 +08:00
|
|
|
template class GotPltSection<ELF32LE>;
|
|
|
|
template class GotPltSection<ELF32BE>;
|
|
|
|
template class GotPltSection<ELF64LE>;
|
|
|
|
template class GotPltSection<ELF64BE>;
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template class GotSection<ELF32LE>;
|
|
|
|
template class GotSection<ELF32BE>;
|
|
|
|
template class GotSection<ELF64LE>;
|
|
|
|
template class GotSection<ELF64BE>;
|
|
|
|
|
|
|
|
template class PltSection<ELF32LE>;
|
|
|
|
template class PltSection<ELF32BE>;
|
|
|
|
template class PltSection<ELF64LE>;
|
|
|
|
template class PltSection<ELF64BE>;
|
|
|
|
|
|
|
|
template class RelocationSection<ELF32LE>;
|
|
|
|
template class RelocationSection<ELF32BE>;
|
|
|
|
template class RelocationSection<ELF64LE>;
|
|
|
|
template class RelocationSection<ELF64BE>;
|
|
|
|
|
2015-10-16 06:27:29 +08:00
|
|
|
template class InterpSection<ELF32LE>;
|
|
|
|
template class InterpSection<ELF32BE>;
|
|
|
|
template class InterpSection<ELF64LE>;
|
|
|
|
template class InterpSection<ELF64BE>;
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-10-22 16:21:35 +08:00
|
|
|
template class GnuHashTableSection<ELF32LE>;
|
|
|
|
template class GnuHashTableSection<ELF32BE>;
|
|
|
|
template class GnuHashTableSection<ELF64LE>;
|
|
|
|
template class GnuHashTableSection<ELF64BE>;
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template class HashTableSection<ELF32LE>;
|
|
|
|
template class HashTableSection<ELF32BE>;
|
|
|
|
template class HashTableSection<ELF64LE>;
|
|
|
|
template class HashTableSection<ELF64BE>;
|
|
|
|
|
|
|
|
template class DynamicSection<ELF32LE>;
|
|
|
|
template class DynamicSection<ELF32BE>;
|
|
|
|
template class DynamicSection<ELF64LE>;
|
|
|
|
template class DynamicSection<ELF64BE>;
|
|
|
|
|
|
|
|
template class OutputSection<ELF32LE>;
|
|
|
|
template class OutputSection<ELF32BE>;
|
|
|
|
template class OutputSection<ELF64LE>;
|
|
|
|
template class OutputSection<ELF64BE>;
|
|
|
|
|
2015-10-20 05:00:02 +08:00
|
|
|
template class MergeOutputSection<ELF32LE>;
|
|
|
|
template class MergeOutputSection<ELF32BE>;
|
|
|
|
template class MergeOutputSection<ELF64LE>;
|
|
|
|
template class MergeOutputSection<ELF64BE>;
|
|
|
|
|
2015-10-16 06:27:29 +08:00
|
|
|
template class StringTableSection<ELF32LE>;
|
|
|
|
template class StringTableSection<ELF32BE>;
|
|
|
|
template class StringTableSection<ELF64LE>;
|
|
|
|
template class StringTableSection<ELF64BE>;
|
2015-09-22 05:38:08 +08:00
|
|
|
|
|
|
|
template class SymbolTableSection<ELF32LE>;
|
|
|
|
template class SymbolTableSection<ELF32BE>;
|
|
|
|
template class SymbolTableSection<ELF64LE>;
|
|
|
|
template class SymbolTableSection<ELF64BE>;
|
|
|
|
|
2015-10-08 03:18:16 +08:00
|
|
|
template ELFFile<ELF32LE>::uintX_t getSymVA<ELF32LE>(const SymbolBody &);
|
|
|
|
template ELFFile<ELF32BE>::uintX_t getSymVA<ELF32BE>(const SymbolBody &);
|
|
|
|
template ELFFile<ELF64LE>::uintX_t getSymVA<ELF64LE>(const SymbolBody &);
|
|
|
|
template ELFFile<ELF64BE>::uintX_t getSymVA<ELF64BE>(const SymbolBody &);
|
2015-09-22 06:01:00 +08:00
|
|
|
|
2015-09-22 06:48:12 +08:00
|
|
|
template ELFFile<ELF32LE>::uintX_t
|
2015-10-13 04:28:22 +08:00
|
|
|
getLocalRelTarget(const ObjectFile<ELF32LE> &,
|
2015-10-17 06:37:32 +08:00
|
|
|
const ELFFile<ELF32LE>::Elf_Rel &);
|
2015-09-22 06:48:12 +08:00
|
|
|
template ELFFile<ELF32BE>::uintX_t
|
2015-10-13 04:28:22 +08:00
|
|
|
getLocalRelTarget(const ObjectFile<ELF32BE> &,
|
2015-10-17 06:37:32 +08:00
|
|
|
const ELFFile<ELF32BE>::Elf_Rel &);
|
2015-09-22 06:48:12 +08:00
|
|
|
template ELFFile<ELF64LE>::uintX_t
|
2015-10-13 04:28:22 +08:00
|
|
|
getLocalRelTarget(const ObjectFile<ELF64LE> &,
|
2015-10-17 06:37:32 +08:00
|
|
|
const ELFFile<ELF64LE>::Elf_Rel &);
|
2015-09-22 06:48:12 +08:00
|
|
|
template ELFFile<ELF64BE>::uintX_t
|
2015-10-13 04:28:22 +08:00
|
|
|
getLocalRelTarget(const ObjectFile<ELF64BE> &,
|
2015-10-17 06:37:32 +08:00
|
|
|
const ELFFile<ELF64BE>::Elf_Rel &);
|
2015-10-05 23:24:04 +08:00
|
|
|
|
2015-10-20 05:00:02 +08:00
|
|
|
template ELFFile<ELF32LE>::uintX_t
|
|
|
|
getLocalRelTarget(const ObjectFile<ELF32LE> &,
|
|
|
|
const ELFFile<ELF32LE>::Elf_Rela &);
|
|
|
|
template ELFFile<ELF32BE>::uintX_t
|
|
|
|
getLocalRelTarget(const ObjectFile<ELF32BE> &,
|
|
|
|
const ELFFile<ELF32BE>::Elf_Rela &);
|
|
|
|
template ELFFile<ELF64LE>::uintX_t
|
|
|
|
getLocalRelTarget(const ObjectFile<ELF64LE> &,
|
|
|
|
const ELFFile<ELF64LE>::Elf_Rela &);
|
|
|
|
template ELFFile<ELF64BE>::uintX_t
|
|
|
|
getLocalRelTarget(const ObjectFile<ELF64BE> &,
|
|
|
|
const ELFFile<ELF64BE>::Elf_Rela &);
|
|
|
|
|
2015-10-05 23:24:04 +08:00
|
|
|
template bool includeInSymtab<ELF32LE>(const SymbolBody &);
|
|
|
|
template bool includeInSymtab<ELF32BE>(const SymbolBody &);
|
|
|
|
template bool includeInSymtab<ELF64LE>(const SymbolBody &);
|
|
|
|
template bool includeInSymtab<ELF64BE>(const SymbolBody &);
|
2015-10-06 00:25:43 +08:00
|
|
|
|
2015-10-10 03:25:07 +08:00
|
|
|
template bool shouldKeepInSymtab<ELF32LE>(const ObjectFile<ELF32LE> &,
|
|
|
|
StringRef,
|
2015-10-06 00:25:43 +08:00
|
|
|
const ELFFile<ELF32LE>::Elf_Sym &);
|
2015-10-10 03:25:07 +08:00
|
|
|
template bool shouldKeepInSymtab<ELF32BE>(const ObjectFile<ELF32BE> &,
|
|
|
|
StringRef,
|
2015-10-06 00:25:43 +08:00
|
|
|
const ELFFile<ELF32BE>::Elf_Sym &);
|
2015-10-10 03:25:07 +08:00
|
|
|
template bool shouldKeepInSymtab<ELF64LE>(const ObjectFile<ELF64LE> &,
|
|
|
|
StringRef,
|
2015-10-06 00:25:43 +08:00
|
|
|
const ELFFile<ELF64LE>::Elf_Sym &);
|
2015-10-10 03:25:07 +08:00
|
|
|
template bool shouldKeepInSymtab<ELF64BE>(const ObjectFile<ELF64BE> &,
|
|
|
|
StringRef,
|
2015-10-06 00:25:43 +08:00
|
|
|
const ELFFile<ELF64BE>::Elf_Sym &);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
}
|