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-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;
|
|
|
|
|
|
|
|
template <bool Is64Bits>
|
|
|
|
OutputSectionBase<Is64Bits>::OutputSectionBase(StringRef Name, uint32_t sh_type,
|
|
|
|
uintX_t sh_flags)
|
|
|
|
: Name(Name) {
|
|
|
|
memset(&Header, 0, sizeof(HeaderT));
|
|
|
|
Header.sh_type = sh_type;
|
|
|
|
Header.sh_flags = sh_flags;
|
|
|
|
}
|
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
2015-10-08 03:18:16 +08:00
|
|
|
GotSection<ELFT>::GotSection()
|
2015-09-26 01:19:10 +08:00
|
|
|
: OutputSectionBase<ELFT::Is64Bits>(".got", llvm::ELF::SHT_PROGBITS,
|
|
|
|
llvm::ELF::SHF_ALLOC |
|
2015-10-08 03:18:16 +08:00
|
|
|
llvm::ELF::SHF_WRITE) {
|
2015-09-26 01:19:10 +08:00
|
|
|
this->Header.sh_addralign = this->getAddrSize();
|
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody *Sym) {
|
2015-10-09 08:42:06 +08:00
|
|
|
Sym->GotIndex = Entries.size();
|
2015-09-22 05:38:08 +08:00
|
|
|
Entries.push_back(Sym);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
typename GotSection<ELFT>::uintX_t
|
|
|
|
GotSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
|
2015-10-09 08:42:06 +08:00
|
|
|
return this->getVA() + B.GotIndex * this->getAddrSize();
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-10-07 07:56:53 +08:00
|
|
|
template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
for (const SymbolBody *B : Entries) {
|
2015-10-07 11:56:05 +08:00
|
|
|
uint8_t *Entry = Buf;
|
|
|
|
Buf += sizeof(uintX_t);
|
2015-10-07 07:56:53 +08:00
|
|
|
if (canBePreempted(B))
|
|
|
|
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-09-26 01:19:10 +08:00
|
|
|
: OutputSectionBase<ELFT::Is64Bits>(".plt", llvm::ELF::SHT_PROGBITS,
|
|
|
|
llvm::ELF::SHF_ALLOC |
|
2015-10-08 03:18:16 +08:00
|
|
|
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-09-22 05:38:08 +08:00
|
|
|
for (const SymbolBody *E : Entries) {
|
2015-10-14 00:59:30 +08:00
|
|
|
uint64_t Got = Out<ELFT>::Got->getEntryAddr(*E);
|
2015-10-13 02:56:36 +08:00
|
|
|
uint64_t Plt = this->getVA() + Off;
|
2015-10-14 00:59:30 +08:00
|
|
|
Target->writePltEntry(Buf + Off, Got, Plt);
|
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-14 00:59:30 +08:00
|
|
|
return this->getVA() + B.PltIndex * Target->getPltEntrySize();
|
2015-10-09 05:51:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void PltSection<ELFT>::finalize() {
|
2015-10-14 00:59:30 +08:00
|
|
|
this->Header.sh_size = 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-14 00:59:30 +08:00
|
|
|
RelocationSection<ELFT>::RelocationSection(bool IsRela)
|
|
|
|
: OutputSectionBase<ELFT::Is64Bits>(IsRela ? ".rela.dyn" : ".rel.dyn",
|
|
|
|
IsRela ? llvm::ELF::SHT_RELA
|
|
|
|
: llvm::ELF::SHT_REL,
|
2015-09-26 01:19:10 +08:00
|
|
|
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-24 23:11:50 +08:00
|
|
|
bool IsMips64EL = Relocs[0].C.getFile()->getObj().isMips64EL();
|
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-08 01:04:18 +08:00
|
|
|
OutputSection<ELFT> *OutSec = C.getOutputSection();
|
2015-09-22 05:38:08 +08:00
|
|
|
uint32_t SymIndex = RI.getSymbol(IsMips64EL);
|
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-09-22 05:38:08 +08:00
|
|
|
uint32_t Type = RI.getType(IsMips64EL);
|
2015-10-07 08:58:20 +08:00
|
|
|
|
|
|
|
bool CanBePreempted = canBePreempted(Body);
|
|
|
|
uintX_t Addend = 0;
|
|
|
|
if (!CanBePreempted) {
|
|
|
|
if (IsRela) {
|
|
|
|
if (Body)
|
2015-10-08 03:18:16 +08:00
|
|
|
Addend += getSymVA<ELFT>(cast<ELFSymbolBody<ELFT>>(*Body));
|
2015-10-07 08:58:20 +08:00
|
|
|
else
|
2015-10-13 04:28:22 +08:00
|
|
|
Addend += getLocalRelTarget(File, RI);
|
2015-10-07 08:58:20 +08:00
|
|
|
}
|
|
|
|
P->setSymbolAndType(0, Target->getRelativeReloc(), IsMips64EL);
|
|
|
|
}
|
|
|
|
|
2015-10-06 03:30:12 +08:00
|
|
|
if (Body && Target->relocNeedsGot(Type, *Body)) {
|
2015-10-14 00:59:30 +08:00
|
|
|
P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
|
2015-10-07 08:58:20 +08:00
|
|
|
if (CanBePreempted)
|
|
|
|
P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
|
2015-10-14 00:59:30 +08:00
|
|
|
Target->getGotReloc(), IsMips64EL);
|
2015-09-22 05:38:08 +08:00
|
|
|
} else {
|
2015-10-06 05:09:37 +08:00
|
|
|
if (IsRela)
|
2015-10-07 08:58:20 +08:00
|
|
|
Addend += static_cast<const Elf_Rela &>(RI).r_addend;
|
2015-10-08 01:04:18 +08:00
|
|
|
P->r_offset = RI.r_offset + C.getOutputSectionOff() + OutSec->getVA();
|
2015-10-07 08:58:20 +08:00
|
|
|
if (CanBePreempted)
|
2015-10-06 03:30:12 +08:00
|
|
|
P->setSymbolAndType(Body->getDynamicSymbolTableIndex(), Type,
|
|
|
|
IsMips64EL);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
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-08 03:18:16 +08:00
|
|
|
this->Header.sh_link = Out<ELFT>::DynSymTab->getSectionIndex();
|
2015-09-22 05:38:08 +08:00
|
|
|
this->Header.sh_size = Relocs.size() * this->Header.sh_entsize;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <bool Is64Bits>
|
|
|
|
InterpSection<Is64Bits>::InterpSection()
|
|
|
|
: OutputSectionBase<Is64Bits>(".interp", llvm::ELF::SHT_PROGBITS,
|
|
|
|
llvm::ELF::SHF_ALLOC) {
|
|
|
|
this->Header.sh_size = Config->DynamicLinker.size() + 1;
|
|
|
|
this->Header.sh_addralign = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <bool Is64Bits>
|
|
|
|
template <endianness E>
|
|
|
|
void OutputSectionBase<Is64Bits>::writeHeaderTo(
|
|
|
|
typename ELFFile<ELFType<E, Is64Bits>>::Elf_Shdr *SHdr) {
|
|
|
|
SHdr->sh_name = Header.sh_name;
|
|
|
|
SHdr->sh_type = Header.sh_type;
|
|
|
|
SHdr->sh_flags = Header.sh_flags;
|
|
|
|
SHdr->sh_addr = Header.sh_addr;
|
|
|
|
SHdr->sh_offset = Header.sh_offset;
|
|
|
|
SHdr->sh_size = Header.sh_size;
|
|
|
|
SHdr->sh_link = Header.sh_link;
|
|
|
|
SHdr->sh_info = Header.sh_info;
|
|
|
|
SHdr->sh_addralign = Header.sh_addralign;
|
|
|
|
SHdr->sh_entsize = Header.sh_entsize;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <bool Is64Bits> void InterpSection<Is64Bits>::writeTo(uint8_t *Buf) {
|
|
|
|
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-09-26 01:19:10 +08:00
|
|
|
: OutputSectionBase<ELFT::Is64Bits>(".hash", llvm::ELF::SHT_HASH,
|
2015-10-08 03:18:16 +08:00
|
|
|
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-09-22 05:38:08 +08:00
|
|
|
template <class ELFT> void HashTableSection<ELFT>::addSymbol(SymbolBody *S) {
|
|
|
|
StringRef Name = S->getName();
|
2015-10-08 03:18:16 +08:00
|
|
|
Out<ELFT>::DynSymTab->addSymbol(Name);
|
2015-09-22 05:38:08 +08:00
|
|
|
Hashes.push_back(hash(Name));
|
|
|
|
S->setDynamicSymbolTableIndex(Hashes.size());
|
|
|
|
}
|
|
|
|
|
2015-10-08 00:58:54 +08:00
|
|
|
template <class ELFT> void HashTableSection<ELFT>::finalize() {
|
2015-10-08 03:18:16 +08:00
|
|
|
this->Header.sh_link = Out<ELFT>::DynSymTab->getSectionIndex();
|
2015-10-08 00:58:54 +08:00
|
|
|
|
2015-10-08 03:18:16 +08:00
|
|
|
assert(Out<ELFT>::DynSymTab->getNumSymbols() == Hashes.size() + 1);
|
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;
|
|
|
|
|
|
|
|
for (unsigned I = 1; I < NumSymbols; ++I) {
|
|
|
|
uint32_t Hash = Hashes[I - 1] % NumSymbols;
|
|
|
|
Chains[I] = Buckets[Hash];
|
|
|
|
Buckets[Hash] = I;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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-09-26 01:19:10 +08:00
|
|
|
: OutputSectionBase<ELFT::Is64Bits>(".dynamic", llvm::ELF::SHT_DYNAMIC,
|
|
|
|
llvm::ELF::SHF_ALLOC |
|
|
|
|
llvm::ELF::SHF_WRITE),
|
2015-10-08 03:18:16 +08:00
|
|
|
SymTab(SymTab) {
|
2015-09-26 01:19:10 +08:00
|
|
|
typename Base::HeaderT &Header = this->Header;
|
|
|
|
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-09-22 05:38:08 +08:00
|
|
|
typename Base::HeaderT &Header = this->Header;
|
2015-10-08 03:18:16 +08:00
|
|
|
Header.sh_link = Out<ELFT>::DynStrTab->getSectionIndex();
|
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
|
|
|
}
|
|
|
|
++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
|
|
|
|
++NumEntries; // DT_HASH
|
|
|
|
|
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-14 05:02:34 +08:00
|
|
|
if (Config->ZNow || Config->Bsymbolic)
|
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-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());
|
|
|
|
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-08 03:18:16 +08:00
|
|
|
Out<ELFT>::DynStrTab->getFileOff(Config->RPath));
|
2015-10-02 03:36:04 +08:00
|
|
|
|
2015-10-02 09:33:31 +08:00
|
|
|
if (!Config->SoName.empty())
|
2015-10-08 03:18:16 +08:00
|
|
|
WriteVal(DT_SONAME, Out<ELFT>::DynStrTab->getFileOff(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,
|
|
|
|
const OutputSection<ELFT> *Sec) {
|
|
|
|
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())
|
|
|
|
WriteVal(DT_NEEDED, Out<ELFT>::DynStrTab->getFileOff(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-05 18:29:46 +08:00
|
|
|
|
2015-10-14 05:02:34 +08:00
|
|
|
uint32_t Flags = 0;
|
|
|
|
if (Config->Bsymbolic)
|
|
|
|
Flags |= DF_SYMBOLIC;
|
2015-10-07 23:00:21 +08:00
|
|
|
if (Config->ZNow)
|
2015-10-14 05:02:34 +08:00
|
|
|
Flags |= DF_1_NOW;
|
|
|
|
if (Flags)
|
|
|
|
WriteVal(DT_FLAGS_1, Flags);
|
2015-10-07 23:00:21 +08:00
|
|
|
|
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-08 03:18:16 +08:00
|
|
|
: OutputSectionBase<ELFT::Is64Bits>(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-09-22 05:38:08 +08:00
|
|
|
C->setOutputSection(this);
|
|
|
|
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);
|
|
|
|
C->setOutputSectionOff(Off);
|
|
|
|
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);
|
|
|
|
const InputSection<ELFT> *SC = &DR.Section;
|
|
|
|
OutputSection<ELFT> *OS = SC->getOutputSection();
|
|
|
|
return OS->getVA() + SC->getOutputSectionOff() + DR.Sym.st_value;
|
|
|
|
}
|
|
|
|
case SymbolBody::DefinedCommonKind:
|
2015-10-08 03:18:16 +08:00
|
|
|
return Out<ELFT>::Bss->getVA() + cast<DefinedCommon<ELFT>>(S).OffsetInBSS;
|
2015-09-26 02:19:03 +08:00
|
|
|
case SymbolBody::SharedKind:
|
|
|
|
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-09-22 05:38:08 +08:00
|
|
|
template <class ELFT>
|
|
|
|
typename ELFFile<ELFT>::uintX_t
|
2015-10-13 04:28:22 +08:00
|
|
|
lld::elf2::getLocalRelTarget(const ObjectFile<ELFT> &File,
|
|
|
|
const typename ELFFile<ELFT>::Elf_Rel &RI) {
|
|
|
|
typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
|
|
|
|
const Elf_Sym *Sym =
|
|
|
|
File.getObj().getRelocationSymbol(&RI, File.getSymbolTable());
|
|
|
|
|
|
|
|
// For certain special relocations, such as R_PPC64_TOC, there's no
|
|
|
|
// corresponding symbol. Just return 0 in that case.
|
|
|
|
if (!Sym)
|
|
|
|
return 0;
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-10-13 04:28:22 +08:00
|
|
|
uint32_t SecIndex = Sym->st_shndx;
|
2015-09-22 05:38:08 +08:00
|
|
|
if (SecIndex == SHN_XINDEX)
|
2015-09-24 23:11:50 +08:00
|
|
|
SecIndex = File.getObj().getExtendedSymbolTableIndex(
|
2015-09-22 05:38:08 +08:00
|
|
|
Sym, File.getSymbolTable(), File.getSymbolTableShndx());
|
2015-09-22 08:16:19 +08:00
|
|
|
ArrayRef<InputSection<ELFT> *> Sections = File.getSections();
|
|
|
|
InputSection<ELFT> *Section = Sections[SecIndex];
|
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.
|
|
|
|
if (Section == &InputSection<ELFT>::Discarded)
|
|
|
|
return 0;
|
|
|
|
|
2015-10-08 01:04:18 +08:00
|
|
|
OutputSection<ELFT> *OutSec = Section->getOutputSection();
|
|
|
|
return OutSec->getVA() + Section->getOutputSectionOff() + Sym->st_value;
|
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-07 07:56:53 +08:00
|
|
|
bool lld::elf2::canBePreempted(const SymbolBody *Body) {
|
|
|
|
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;
|
|
|
|
if (Body->isUndefined() && !Body->isWeak())
|
2015-10-07 07:56:53 +08:00
|
|
|
return true;
|
|
|
|
if (!Config->Shared)
|
|
|
|
return false;
|
2015-10-07 08:58:20 +08:00
|
|
|
return Body->getMostConstrainingVisibility() == 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-09-26 01:19:10 +08:00
|
|
|
template <bool Is64Bits>
|
|
|
|
StringTableSection<Is64Bits>::StringTableSection(bool Dynamic)
|
|
|
|
: OutputSectionBase<Is64Bits>(Dynamic ? ".dynstr" : ".strtab",
|
|
|
|
llvm::ELF::SHT_STRTAB,
|
|
|
|
Dynamic ? (uintX_t)llvm::ELF::SHF_ALLOC : 0),
|
|
|
|
Dynamic(Dynamic) {
|
|
|
|
this->Header.sh_addralign = 1;
|
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <bool Is64Bits>
|
|
|
|
void StringTableSection<Is64Bits>::writeTo(uint8_t *Buf) {
|
|
|
|
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-05 23:24:04 +08:00
|
|
|
uint8_t V = B.getMostConstrainingVisibility();
|
|
|
|
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.
|
|
|
|
uint32_t SecIndex = Sym.st_shndx;
|
|
|
|
if (SecIndex != SHN_ABS) {
|
|
|
|
if (SecIndex == SHN_XINDEX)
|
|
|
|
SecIndex = File.getObj().getExtendedSymbolTableIndex(
|
|
|
|
&Sym, File.getSymbolTable(), File.getSymbolTableShndx());
|
|
|
|
ArrayRef<InputSection<ELFT> *> Sections = File.getSections();
|
|
|
|
const InputSection<ELFT> *Section = Sections[SecIndex];
|
|
|
|
if (Section == &InputSection<ELFT>::Discarded)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
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-10 05:07:25 +08:00
|
|
|
SymbolTable<ELFT> &Table, StringTableSection<ELFT::Is64Bits> &StrTabSec)
|
2015-09-26 01:19:10 +08:00
|
|
|
: OutputSectionBase<ELFT::Is64Bits>(
|
|
|
|
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-09-26 01:19:10 +08:00
|
|
|
typedef OutputSectionBase<ELFT::Is64Bits> Base;
|
|
|
|
typename Base::HeaderT &Header = this->Header;
|
|
|
|
|
|
|
|
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() {
|
|
|
|
this->Header.sh_size = getNumSymbols() * sizeof(Elf_Sym);
|
|
|
|
this->Header.sh_link = StrTabSec.getSectionIndex();
|
|
|
|
this->Header.sh_info = NumLocals + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void SymbolTableSection<ELFT>::addSymbol(StringRef Name, bool isLocal) {
|
|
|
|
StrTabSec.add(Name);
|
|
|
|
++NumVisible;
|
|
|
|
if (isLocal)
|
|
|
|
++NumLocals;
|
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
Buf += sizeof(*ESym);
|
2015-10-10 00:15:57 +08:00
|
|
|
ESym->st_name = StrTabSec.getFileOff(SymName);
|
2015-09-30 08:32:10 +08:00
|
|
|
ESym->st_size = Sym.st_size;
|
|
|
|
ESym->setBindingAndType(Sym.getBinding(), Sym.getType());
|
|
|
|
uint32_t SecIndex = Sym.st_shndx;
|
|
|
|
uintX_t VA = Sym.st_value;
|
|
|
|
if (SecIndex == SHN_ABS) {
|
|
|
|
ESym->st_shndx = SHN_ABS;
|
|
|
|
} else {
|
|
|
|
if (SecIndex == SHN_XINDEX)
|
2015-10-10 05:07:25 +08:00
|
|
|
SecIndex = File->getObj().getExtendedSymbolTableIndex(
|
|
|
|
&Sym, File->getSymbolTable(), File->getSymbolTableShndx());
|
|
|
|
ArrayRef<InputSection<ELFT> *> Sections = File->getSections();
|
2015-09-30 08:32:10 +08:00
|
|
|
const InputSection<ELFT> *Section = Sections[SecIndex];
|
2015-10-08 01:04:18 +08:00
|
|
|
const OutputSection<ELFT> *OutSec = Section->getOutputSection();
|
|
|
|
ESym->st_shndx = OutSec->getSectionIndex();
|
|
|
|
VA += OutSec->getVA() + Section->getOutputSectionOff();
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
2015-09-30 08:32:10 +08:00
|
|
|
ESym->st_value = VA;
|
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>
|
|
|
|
void SymbolTableSection<ELFT>::writeGlobalSymbols(uint8_t *&Buf) {
|
|
|
|
// Write the internal symbol table contents to the output symbol table
|
|
|
|
// pointed by Buf.
|
2015-10-05 23:24:04 +08:00
|
|
|
uint8_t *Start = Buf;
|
2015-09-30 08:32:10 +08:00
|
|
|
for (const std::pair<StringRef, Symbol *> &P : Table.getSymbols()) {
|
2015-09-22 05:38:08 +08:00
|
|
|
StringRef Name = P.first;
|
|
|
|
Symbol *Sym = P.second;
|
|
|
|
SymbolBody *Body = Sym->Body;
|
2015-10-05 23:24:04 +08:00
|
|
|
if (!includeInSymtab<ELFT>(*Body))
|
2015-09-22 05:38:08 +08:00
|
|
|
continue;
|
2015-09-23 07:38:23 +08:00
|
|
|
if (StrTabSec.isDynamic() && !includeInDynamicSymtab(*Body))
|
|
|
|
continue;
|
2015-09-22 05:38:08 +08:00
|
|
|
|
|
|
|
auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
|
2015-09-30 08:54:29 +08:00
|
|
|
Buf += sizeof(*ESym);
|
2015-10-06 22:33:58 +08:00
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
ESym->st_name = StrTabSec.getFileOff(Name);
|
|
|
|
|
2015-10-08 01:04:18 +08:00
|
|
|
const OutputSection<ELFT> *OutSec = nullptr;
|
2015-09-26 01:32:37 +08:00
|
|
|
const InputSection<ELFT> *Section = 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;
|
2015-09-22 05:38:08 +08:00
|
|
|
case SymbolBody::DefinedRegularKind:
|
2015-10-06 22:33:58 +08:00
|
|
|
Section = &cast<DefinedRegular<ELFT>>(Body)->Section;
|
2015-09-22 05:38:08 +08:00
|
|
|
break;
|
|
|
|
case SymbolBody::DefinedCommonKind:
|
2015-10-08 03:18:16 +08:00
|
|
|
OutSec = Out<ELFT>::Bss;
|
2015-09-22 05:38:08 +08:00
|
|
|
break;
|
|
|
|
case SymbolBody::UndefinedKind:
|
|
|
|
case SymbolBody::DefinedAbsoluteKind:
|
|
|
|
case SymbolBody::SharedKind:
|
|
|
|
case SymbolBody::LazyKind:
|
2015-10-06 22:33:58 +08:00
|
|
|
break;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-10-06 22:33:58 +08:00
|
|
|
unsigned char Binding = Body->isWeak() ? STB_WEAK : STB_GLOBAL;
|
|
|
|
unsigned char Type = STT_NOTYPE;
|
|
|
|
uintX_t Size = 0;
|
|
|
|
if (const auto *EBody = dyn_cast<ELFSymbolBody<ELFT>>(Body)) {
|
|
|
|
const Elf_Sym &InputSym = EBody->Sym;
|
|
|
|
Binding = InputSym.getBinding();
|
|
|
|
Type = InputSym.getType();
|
|
|
|
Size = InputSym.st_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned char Visibility = Body->getMostConstrainingVisibility();
|
2015-10-05 23:24:04 +08:00
|
|
|
if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
|
|
|
|
Binding = STB_LOCAL;
|
|
|
|
|
2015-10-06 22:33:58 +08:00
|
|
|
ESym->setBindingAndType(Binding, Type);
|
|
|
|
ESym->st_size = Size;
|
2015-10-05 23:24:04 +08:00
|
|
|
ESym->setVisibility(Visibility);
|
2015-10-08 03:18:16 +08:00
|
|
|
ESym->st_value = getSymVA<ELFT>(*Body);
|
2015-09-22 05:38:08 +08:00
|
|
|
|
|
|
|
if (Section)
|
2015-10-08 01:04:18 +08:00
|
|
|
OutSec = Section->getOutputSection();
|
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)
|
|
|
|
ESym->st_shndx = OutSec->getSectionIndex();
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
2015-10-05 23:24:04 +08:00
|
|
|
if (!StrTabSec.isDynamic())
|
|
|
|
std::stable_sort(
|
|
|
|
reinterpret_cast<Elf_Sym *>(Start), reinterpret_cast<Elf_Sym *>(Buf),
|
|
|
|
[](const Elf_Sym &A, const Elf_Sym &B) -> bool {
|
|
|
|
return A.getBinding() == STB_LOCAL && B.getBinding() != STB_LOCAL;
|
|
|
|
});
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
namespace lld {
|
|
|
|
namespace elf2 {
|
|
|
|
template class OutputSectionBase<false>;
|
|
|
|
template class OutputSectionBase<true>;
|
|
|
|
|
|
|
|
template void OutputSectionBase<false>::writeHeaderTo<support::little>(
|
2015-09-22 06:21:46 +08:00
|
|
|
ELFFile<ELFType<support::little, false>>::Elf_Shdr *SHdr);
|
2015-09-22 05:38:08 +08:00
|
|
|
template void OutputSectionBase<true>::writeHeaderTo<support::little>(
|
2015-09-22 06:21:46 +08:00
|
|
|
ELFFile<ELFType<support::little, true>>::Elf_Shdr *SHdr);
|
2015-09-22 05:38:08 +08:00
|
|
|
template void OutputSectionBase<false>::writeHeaderTo<support::big>(
|
2015-09-22 06:21:46 +08:00
|
|
|
ELFFile<ELFType<support::big, false>>::Elf_Shdr *SHdr);
|
2015-09-22 05:38:08 +08:00
|
|
|
template void OutputSectionBase<true>::writeHeaderTo<support::big>(
|
2015-09-22 06:21:46 +08:00
|
|
|
ELFFile<ELFType<support::big, true>>::Elf_Shdr *SHdr);
|
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>;
|
|
|
|
|
|
|
|
template class InterpSection<false>;
|
|
|
|
template class InterpSection<true>;
|
|
|
|
|
|
|
|
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>;
|
|
|
|
|
|
|
|
template class StringTableSection<false>;
|
|
|
|
template class StringTableSection<true>;
|
|
|
|
|
|
|
|
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> &,
|
|
|
|
const ELFFile<ELF32LE>::Elf_Rel &);
|
2015-09-22 06:01:00 +08:00
|
|
|
|
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> &,
|
|
|
|
const ELFFile<ELF32BE>::Elf_Rel &);
|
2015-09-22 06:01:00 +08:00
|
|
|
|
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> &,
|
|
|
|
const ELFFile<ELF64LE>::Elf_Rel &);
|
2015-09-22 06:01:00 +08:00
|
|
|
|
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> &,
|
|
|
|
const ELFFile<ELF64BE>::Elf_Rel &);
|
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
|
|
|
}
|
|
|
|
}
|