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"
|
2016-01-15 21:34:52 +08:00
|
|
|
#include "llvm/Support/Dwarf.h"
|
2015-10-22 16:21:35 +08:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2016-01-15 21:34:52 +08:00
|
|
|
#include <map>
|
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>
|
2016-01-08 02:33:11 +08:00
|
|
|
OutputSectionBase<ELFT>::OutputSectionBase(StringRef Name, uint32_t Type,
|
|
|
|
uintX_t 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));
|
2016-01-08 02:33:11 +08:00
|
|
|
Header.sh_type = Type;
|
|
|
|
Header.sh_flags = Flags;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-10-20 16:54:27 +08:00
|
|
|
template <class ELFT>
|
|
|
|
GotPltSection<ELFT>::GotPltSection()
|
2016-01-07 06:53:58 +08:00
|
|
|
: OutputSectionBase<ELFT>(".got.plt", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE) {
|
2015-10-20 16:54:27 +08:00
|
|
|
this->Header.sh_addralign = sizeof(uintX_t);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void GotPltSection<ELFT>::addEntry(SymbolBody *Sym) {
|
2016-01-29 09:49:32 +08:00
|
|
|
Sym->GotPltIndex = Target->GotPltHeaderEntriesNum + Entries.size();
|
2015-10-20 16:54:27 +08:00
|
|
|
Entries.push_back(Sym);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> bool GotPltSection<ELFT>::empty() const {
|
2015-11-17 01:44:08 +08:00
|
|
|
return Entries.empty();
|
2015-10-20 16:54:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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() {
|
2015-11-17 01:44:08 +08:00
|
|
|
this->Header.sh_size =
|
2016-01-29 09:49:32 +08:00
|
|
|
(Target->GotPltHeaderEntriesNum + Entries.size()) * sizeof(uintX_t);
|
2015-10-20 16:54:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void GotPltSection<ELFT>::writeTo(uint8_t *Buf) {
|
2016-01-29 10:33:45 +08:00
|
|
|
Target->writeGotPltHeader(Buf);
|
2016-01-29 09:49:32 +08:00
|
|
|
Buf += Target->GotPltHeaderEntriesNum * sizeof(uintX_t);
|
2015-10-20 16:54:27 +08:00
|
|
|
for (const SymbolBody *B : Entries) {
|
2016-01-29 10:33:45 +08:00
|
|
|
Target->writeGotPlt(Buf, Out<ELFT>::Plt->getEntryAddr(*B));
|
2015-10-20 16:54:27 +08:00
|
|
|
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()
|
2016-01-07 06:53:58 +08:00
|
|
|
: OutputSectionBase<ELFT>(".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE) {
|
2015-11-06 15:43:03 +08:00
|
|
|
if (Config->EMachine == EM_MIPS)
|
2016-01-07 06:53:58 +08:00
|
|
|
this->Header.sh_flags |= 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) {
|
2016-01-21 13:33:23 +08:00
|
|
|
Sym->GotIndex = Entries.size();
|
2015-09-22 05:38:08 +08:00
|
|
|
Entries.push_back(Sym);
|
2015-11-14 00:28:53 +08:00
|
|
|
}
|
|
|
|
|
2016-01-21 13:33:23 +08:00
|
|
|
template <class ELFT> void GotSection<ELFT>::addMipsLocalEntry() {
|
|
|
|
++MipsLocalEntries;
|
|
|
|
}
|
|
|
|
|
2015-12-02 03:20:26 +08:00
|
|
|
template <class ELFT> bool GotSection<ELFT>::addDynTlsEntry(SymbolBody *Sym) {
|
|
|
|
if (Sym->hasGlobalDynIndex())
|
|
|
|
return false;
|
2016-01-29 09:49:32 +08:00
|
|
|
Sym->GlobalDynIndex = Target->GotHeaderEntriesNum + Entries.size();
|
2015-11-13 08:28:34 +08:00
|
|
|
// Global Dynamic TLS entries take two GOT slots.
|
2015-11-14 00:28:53 +08:00
|
|
|
Entries.push_back(Sym);
|
|
|
|
Entries.push_back(nullptr);
|
2015-12-02 03:20:26 +08:00
|
|
|
return true;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-12-07 16:02:20 +08:00
|
|
|
template <class ELFT> bool GotSection<ELFT>::addCurrentModuleTlsIndex() {
|
2015-12-02 02:24:07 +08:00
|
|
|
if (LocalTlsIndexOff != uint32_t(-1))
|
|
|
|
return false;
|
2015-11-11 09:00:24 +08:00
|
|
|
Entries.push_back(nullptr);
|
|
|
|
Entries.push_back(nullptr);
|
2015-12-02 02:24:07 +08:00
|
|
|
LocalTlsIndexOff = (Entries.size() - 2) * sizeof(uintX_t);
|
|
|
|
return true;
|
2015-11-11 09:00:24 +08:00
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT>
|
|
|
|
typename GotSection<ELFT>::uintX_t
|
|
|
|
GotSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
|
2016-01-21 13:33:23 +08:00
|
|
|
return this->getVA() +
|
2016-01-29 09:49:32 +08:00
|
|
|
(Target->GotHeaderEntriesNum + MipsLocalEntries + B.GotIndex) *
|
2016-01-21 13:33:23 +08:00
|
|
|
sizeof(uintX_t);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
typename GotSection<ELFT>::uintX_t
|
|
|
|
GotSection<ELFT>::getMipsLocalFullAddr(const SymbolBody &B) {
|
|
|
|
return getMipsLocalEntryAddr(getSymVA<ELFT>(B));
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
typename GotSection<ELFT>::uintX_t
|
|
|
|
GotSection<ELFT>::getMipsLocalPageAddr(uintX_t EntryValue) {
|
|
|
|
// Initialize the entry by the %hi(EntryValue) expression
|
|
|
|
// but without right-shifting.
|
|
|
|
return getMipsLocalEntryAddr((EntryValue + 0x8000) & ~0xffff);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
typename GotSection<ELFT>::uintX_t
|
|
|
|
GotSection<ELFT>::getMipsLocalEntryAddr(uintX_t EntryValue) {
|
2016-01-29 09:49:32 +08:00
|
|
|
size_t NewIndex = Target->GotHeaderEntriesNum + MipsLocalGotPos.size();
|
2016-01-21 13:33:23 +08:00
|
|
|
auto P = MipsLocalGotPos.insert(std::make_pair(EntryValue, NewIndex));
|
|
|
|
assert(!P.second || MipsLocalGotPos.size() <= MipsLocalEntries);
|
|
|
|
return this->getVA() + P.first->second * sizeof(uintX_t);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-12-02 03:20:26 +08:00
|
|
|
template <class ELFT>
|
|
|
|
typename GotSection<ELFT>::uintX_t
|
|
|
|
GotSection<ELFT>::getGlobalDynAddr(const SymbolBody &B) const {
|
|
|
|
return this->getVA() + B.GlobalDynIndex * sizeof(uintX_t);
|
|
|
|
}
|
|
|
|
|
2015-11-12 12:39:49 +08:00
|
|
|
template <class ELFT>
|
|
|
|
const SymbolBody *GotSection<ELFT>::getMipsFirstGlobalEntry() const {
|
|
|
|
return Entries.empty() ? nullptr : Entries.front();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
unsigned GotSection<ELFT>::getMipsLocalEntriesNum() const {
|
2016-01-29 09:49:32 +08:00
|
|
|
return Target->GotHeaderEntriesNum + MipsLocalEntries;
|
2015-11-12 12:39:49 +08:00
|
|
|
}
|
|
|
|
|
2015-11-06 15:43:03 +08:00
|
|
|
template <class ELFT> void GotSection<ELFT>::finalize() {
|
|
|
|
this->Header.sh_size =
|
2016-01-29 09:49:32 +08:00
|
|
|
(Target->GotHeaderEntriesNum + MipsLocalEntries + Entries.size()) *
|
2016-01-21 13:33:23 +08:00
|
|
|
sizeof(uintX_t);
|
2015-11-06 15:43:03 +08:00
|
|
|
}
|
|
|
|
|
2015-10-07 07:56:53 +08:00
|
|
|
template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
|
2016-01-29 10:33:45 +08:00
|
|
|
Target->writeGotHeader(Buf);
|
2016-01-21 13:33:23 +08:00
|
|
|
for (const auto &L : MipsLocalGotPos) {
|
|
|
|
uint8_t *Entry = Buf + L.second * sizeof(uintX_t);
|
|
|
|
write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Entry, L.first);
|
|
|
|
}
|
2016-01-29 09:49:32 +08:00
|
|
|
Buf += Target->GotHeaderEntriesNum * sizeof(uintX_t);
|
2016-01-21 13:33:23 +08:00
|
|
|
Buf += MipsLocalEntries * 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()
|
2016-01-07 06:53:58 +08:00
|
|
|
: OutputSectionBase<ELFT>(".plt", SHT_PROGBITS, SHF_ALLOC | 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;
|
2016-01-29 12:15:02 +08:00
|
|
|
if (Target->UseLazyBinding) {
|
2015-10-20 16:54:27 +08:00
|
|
|
// First write PLT[0] entry which is special.
|
2016-01-29 11:51:49 +08:00
|
|
|
Target->writePltZero(Buf);
|
2016-01-29 11:00:32 +08:00
|
|
|
Off += Target->PltZeroSize;
|
2015-10-20 16:54:27 +08:00
|
|
|
}
|
2015-11-27 03:58:51 +08:00
|
|
|
for (auto &I : Entries) {
|
2016-01-29 12:15:02 +08:00
|
|
|
const SymbolBody *B = I.first;
|
2015-11-26 06:15:01 +08:00
|
|
|
unsigned RelOff = I.second;
|
2016-01-29 12:15:02 +08:00
|
|
|
uint64_t Got = Target->UseLazyBinding ? Out<ELFT>::GotPlt->getEntryAddr(*B)
|
|
|
|
: Out<ELFT>::Got->getEntryAddr(*B);
|
2015-10-13 02:56:36 +08:00
|
|
|
uint64_t Plt = this->getVA() + Off;
|
2016-01-29 12:15:02 +08:00
|
|
|
Target->writePlt(Buf + Off, Got, Plt, B->PltIndex, RelOff);
|
2016-01-29 09:49:32 +08:00
|
|
|
Off += Target->PltEntrySize;
|
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();
|
2016-01-29 09:49:32 +08:00
|
|
|
unsigned RelOff = Target->UseLazyBinding
|
2015-11-26 06:15:01 +08:00
|
|
|
? Out<ELFT>::RelaPlt->getRelocOffset()
|
|
|
|
: Out<ELFT>::RelaDyn->getRelocOffset();
|
|
|
|
Entries.push_back(std::make_pair(Sym, RelOff));
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
typename PltSection<ELFT>::uintX_t
|
|
|
|
PltSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
|
2016-01-29 11:00:32 +08:00
|
|
|
return this->getVA() + Target->PltZeroSize +
|
2016-01-29 09:49:32 +08:00
|
|
|
B.PltIndex * Target->PltEntrySize;
|
2015-10-09 05:51:31 +08:00
|
|
|
}
|
|
|
|
|
2015-10-20 16:54:27 +08:00
|
|
|
template <class ELFT> void PltSection<ELFT>::finalize() {
|
2016-01-29 09:49:32 +08:00
|
|
|
this->Header.sh_size =
|
2016-01-29 11:00:32 +08:00
|
|
|
Target->PltZeroSize + Entries.size() * Target->PltEntrySize;
|
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)
|
2016-01-07 06:53:58 +08:00
|
|
|
: OutputSectionBase<ELFT>(Name, IsRela ? SHT_RELA : SHT_REL, 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-12-01 01:49:19 +08:00
|
|
|
// Applies corresponding symbol and type for dynamic tls relocation.
|
|
|
|
// Returns true if relocation was handled.
|
|
|
|
template <class ELFT>
|
|
|
|
bool RelocationSection<ELFT>::applyTlsDynamicReloc(SymbolBody *Body,
|
|
|
|
uint32_t Type, Elf_Rel *P,
|
|
|
|
Elf_Rel *N) {
|
2016-01-29 10:33:45 +08:00
|
|
|
if (Target->isTlsLocalDynamicRel(Type)) {
|
2016-01-29 09:49:32 +08:00
|
|
|
P->setSymbolAndType(0, Target->TlsModuleIndexRel, Config->Mips64EL);
|
2015-12-02 02:24:07 +08:00
|
|
|
P->r_offset = Out<ELFT>::Got->getLocalTlsIndexVA();
|
2015-12-01 01:49:19 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-01-29 10:33:45 +08:00
|
|
|
if (!Body || !Target->isTlsGlobalDynamicRel(Type))
|
2015-12-04 19:20:13 +08:00
|
|
|
return false;
|
|
|
|
|
2016-01-29 08:20:12 +08:00
|
|
|
if (Target->canRelaxTls(Type, Body)) {
|
2016-01-29 09:49:33 +08:00
|
|
|
P->setSymbolAndType(Body->DynsymIndex, Target->getTlsGotRel(),
|
2016-01-29 09:49:32 +08:00
|
|
|
Config->Mips64EL);
|
2015-12-04 19:20:13 +08:00
|
|
|
P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
|
2015-12-01 01:49:19 +08:00
|
|
|
return true;
|
|
|
|
}
|
2015-12-04 19:20:13 +08:00
|
|
|
|
2016-01-29 09:49:33 +08:00
|
|
|
P->setSymbolAndType(Body->DynsymIndex, Target->TlsModuleIndexRel,
|
2016-01-29 09:49:32 +08:00
|
|
|
Config->Mips64EL);
|
2015-12-04 19:20:13 +08:00
|
|
|
P->r_offset = Out<ELFT>::Got->getGlobalDynAddr(*Body);
|
2016-01-29 09:49:33 +08:00
|
|
|
N->setSymbolAndType(Body->DynsymIndex, Target->TlsOffsetRel,
|
2016-01-29 09:49:32 +08:00
|
|
|
Config->Mips64EL);
|
2015-12-04 19:20:13 +08:00
|
|
|
N->r_offset = Out<ELFT>::Got->getGlobalDynAddr(*Body) + sizeof(uintX_t);
|
|
|
|
return true;
|
2015-12-01 01:49:19 +08:00
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
for (const DynamicReloc<ELFT> &Rel : Relocs) {
|
2015-09-23 01:49:38 +08:00
|
|
|
auto *P = reinterpret_cast<Elf_Rel *>(Buf);
|
2016-01-06 00:35:48 +08:00
|
|
|
Buf += IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
|
2015-09-23 01:49:38 +08:00
|
|
|
|
2015-11-13 08:28:34 +08:00
|
|
|
// Skip placeholder for global dynamic TLS relocation pair. It was already
|
|
|
|
// handled by the previous relocation.
|
2016-01-06 00:35:48 +08:00
|
|
|
if (!Rel.C)
|
2015-11-13 08:28:34 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
InputSectionBase<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-12-01 01:49:19 +08:00
|
|
|
if (applyTlsDynamicReloc(Body, Type, P, reinterpret_cast<Elf_Rel *>(Buf)))
|
2015-11-11 09:00:24 +08:00
|
|
|
continue;
|
2016-01-22 04:59:22 +08:00
|
|
|
|
2016-01-26 09:03:21 +08:00
|
|
|
// Writer::scanRelocs creates a RELATIVE reloc for some type of TLS reloc.
|
|
|
|
// We want to write it down as is.
|
2016-01-29 09:49:32 +08:00
|
|
|
if (Type == Target->RelativeRel) {
|
2016-01-26 09:03:21 +08:00
|
|
|
P->setSymbolAndType(0, Type, Config->Mips64EL);
|
|
|
|
P->r_offset = C.getOffset(RI.r_offset) + C.OutSec->getVA();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2016-01-22 04:59:22 +08:00
|
|
|
// Emit a copy relocation.
|
|
|
|
auto *SS = dyn_cast_or_null<SharedSymbol<ELFT>>(Body);
|
|
|
|
if (SS && SS->NeedsCopy) {
|
2016-01-29 09:49:33 +08:00
|
|
|
P->setSymbolAndType(Body->DynsymIndex, Target->CopyRel, Config->Mips64EL);
|
2016-01-22 04:59:22 +08:00
|
|
|
P->r_offset = Out<ELFT>::Bss->getVA() + SS->OffsetInBss;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2016-01-29 10:33:45 +08:00
|
|
|
bool NeedsGot = Body && Target->needsGot(Type, *Body);
|
2016-01-06 00:35:48 +08:00
|
|
|
bool CBP = canBePreempted(Body, NeedsGot);
|
2016-01-26 08:24:57 +08:00
|
|
|
|
|
|
|
// For a symbol with STT_GNU_IFUNC type, we always create a PLT and
|
|
|
|
// a GOT entry for the symbol, and emit an IRELATIVE reloc rather than
|
|
|
|
// the usual JUMP_SLOT reloc for the GOT entry. For the details, you
|
|
|
|
// want to read http://www.airs.com/blog/archives/403
|
|
|
|
if (!CBP && Body && isGnuIFunc<ELFT>(*Body)) {
|
2016-01-29 09:49:32 +08:00
|
|
|
P->setSymbolAndType(0, Target->IRelativeRel, Config->Mips64EL);
|
2016-01-26 08:24:57 +08:00
|
|
|
if (Out<ELFT>::GotPlt)
|
|
|
|
P->r_offset = Out<ELFT>::GotPlt->getEntryAddr(*Body);
|
|
|
|
else
|
|
|
|
P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2016-01-29 09:49:32 +08:00
|
|
|
bool LazyReloc =
|
2016-01-29 10:33:45 +08:00
|
|
|
Body && Target->UseLazyBinding && Target->needsPlt(Type, *Body);
|
2015-10-07 08:58:20 +08:00
|
|
|
|
2015-12-15 16:48:39 +08:00
|
|
|
unsigned Reloc;
|
2016-01-26 09:03:21 +08:00
|
|
|
if (!CBP)
|
2016-01-29 09:49:32 +08:00
|
|
|
Reloc = Target->RelativeRel;
|
2015-12-15 16:48:39 +08:00
|
|
|
else if (LazyReloc)
|
2016-01-29 09:49:32 +08:00
|
|
|
Reloc = Target->PltRel;
|
2015-12-15 16:48:39 +08:00
|
|
|
else if (NeedsGot)
|
2016-01-29 09:49:32 +08:00
|
|
|
Reloc = Body->isTls() ? Target->getTlsGotRel() : Target->GotRel;
|
2015-12-15 16:48:39 +08:00
|
|
|
else
|
2016-01-29 10:33:45 +08:00
|
|
|
Reloc = Target->getDynRel(Type);
|
2016-01-29 09:49:33 +08:00
|
|
|
P->setSymbolAndType(CBP ? Body->DynsymIndex : 0, Reloc, Config->Mips64EL);
|
2015-10-20 03:58:18 +08:00
|
|
|
|
2015-12-30 00:17:32 +08:00
|
|
|
if (LazyReloc)
|
|
|
|
P->r_offset = Out<ELFT>::GotPlt->getEntryAddr(*Body);
|
|
|
|
else if (NeedsGot)
|
|
|
|
P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
|
|
|
|
else
|
2015-11-12 03:54:14 +08:00
|
|
|
P->r_offset = C.getOffset(RI.r_offset) + C.OutSec->getVA();
|
2015-10-20 03:58:18 +08:00
|
|
|
|
2016-01-26 12:58:58 +08:00
|
|
|
if (!IsRela)
|
|
|
|
continue;
|
2015-10-20 03:58:18 +08:00
|
|
|
|
2016-01-26 12:58:58 +08:00
|
|
|
auto R = static_cast<const Elf_Rela &>(RI);
|
2016-01-26 15:17:27 +08:00
|
|
|
auto S = static_cast<Elf_Rela *>(P);
|
|
|
|
uintX_t A = NeedsGot ? 0 : R.r_addend;
|
2016-01-26 09:03:21 +08:00
|
|
|
if (CBP)
|
2016-01-26 15:17:27 +08:00
|
|
|
S->r_addend = A;
|
2015-10-20 04:31:49 +08:00
|
|
|
else if (Body)
|
2016-01-26 15:17:27 +08:00
|
|
|
S->r_addend = getSymVA<ELFT>(*Body) + A;
|
2015-10-20 04:31:49 +08:00
|
|
|
else
|
2016-01-26 15:17:27 +08:00
|
|
|
S->r_addend = getLocalRelTarget(File, R, A);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-26 06:15:01 +08:00
|
|
|
template <class ELFT> unsigned RelocationSection<ELFT>::getRelocOffset() {
|
|
|
|
const unsigned EntrySize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
|
|
|
|
return EntrySize * Relocs.size();
|
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT> void RelocationSection<ELFT>::finalize() {
|
2015-12-21 18:12:06 +08:00
|
|
|
this->Header.sh_link = Static ? Out<ELFT>::SymTab->SectionIndex
|
|
|
|
: 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()
|
2016-01-07 06:53:58 +08:00
|
|
|
: OutputSectionBase<ELFT>(".interp", SHT_PROGBITS, 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) {
|
|
|
|
*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()
|
2016-01-07 06:53:58 +08:00
|
|
|
: OutputSectionBase<ELFT>(".hash", SHT_HASH, 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;
|
|
|
|
|
2016-01-29 09:24:25 +08:00
|
|
|
for (const std::pair<SymbolBody *, unsigned> &P :
|
|
|
|
Out<ELFT>::DynSymTab->getSymbols()) {
|
|
|
|
SymbolBody *Body = P.first;
|
2015-10-21 05:47:58 +08:00
|
|
|
StringRef Name = Body->getName();
|
2016-01-29 09:49:33 +08:00
|
|
|
unsigned I = Body->DynsymIndex;
|
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()
|
2016-01-07 06:53:58 +08:00
|
|
|
: OutputSectionBase<ELFT>(".gnu.hash", SHT_GNU_HASH, SHF_ALLOC) {
|
2015-10-22 16:21:35 +08:00
|
|
|
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) {
|
2016-01-29 09:49:33 +08:00
|
|
|
Buckets[Bucket] = Item.Body->DynsymIndex;
|
2015-10-22 16:21:35 +08:00
|
|
|
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) {
|
2016-01-29 10:17:01 +08:00
|
|
|
// Assume that includeInDynsym() is already checked.
|
2015-11-02 22:33:11 +08:00
|
|
|
return !B->isUndefined();
|
|
|
|
}
|
|
|
|
|
2015-10-28 15:05:56 +08:00
|
|
|
template <class ELFT>
|
2016-01-29 09:24:25 +08:00
|
|
|
void GnuHashTableSection<ELFT>::addSymbols(
|
|
|
|
std::vector<std::pair<SymbolBody *, unsigned>> &Symbols) {
|
|
|
|
std::vector<std::pair<SymbolBody *, unsigned>> NotHashed;
|
2015-10-28 15:05:56 +08:00
|
|
|
NotHashed.reserve(Symbols.size());
|
|
|
|
HashedSymbols.reserve(Symbols.size());
|
2016-01-29 09:24:25 +08:00
|
|
|
for (const std::pair<SymbolBody *, unsigned> &P : Symbols) {
|
|
|
|
SymbolBody *B = P.first;
|
2015-10-28 15:05:56 +08:00
|
|
|
if (includeInGnuHashTable(B))
|
2016-01-29 09:24:25 +08:00
|
|
|
HashedSymbols.push_back(
|
|
|
|
HashedSymbolData{B, P.second, hashGnu(B->getName())});
|
2015-10-28 15:05:56 +08:00
|
|
|
else
|
2016-01-29 09:24:25 +08:00
|
|
|
NotHashed.push_back(P);
|
2015-10-28 15:05:56 +08:00
|
|
|
}
|
|
|
|
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)
|
2016-01-29 09:24:25 +08:00
|
|
|
Symbols.push_back(std::make_pair(Item.Body, Item.STName));
|
2015-10-28 15:05:56 +08:00
|
|
|
}
|
|
|
|
|
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)
|
2016-01-07 06:53:58 +08:00
|
|
|
: OutputSectionBase<ELFT>(".dynamic", SHT_DYNAMIC, SHF_ALLOC | 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-11-12 12:39:49 +08:00
|
|
|
|
|
|
|
// .dynamic section is not writable on MIPS.
|
|
|
|
// See "Special Section" in Chapter 4 in the following document:
|
|
|
|
// ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
|
|
|
|
if (Config->EMachine == EM_MIPS)
|
2016-01-07 06:53:58 +08:00
|
|
|
Header.sh_flags = SHF_ALLOC;
|
2015-09-26 01:19:10 +08:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2016-01-29 09:24:25 +08:00
|
|
|
auto Add = [=](Entry E) { Entries.push_back(E); };
|
|
|
|
|
|
|
|
// Add strings. We know that these are the last strings to be added to
|
2016-01-26 05:32:04 +08:00
|
|
|
// DynStrTab and doing this here allows this function to set DT_STRSZ.
|
|
|
|
if (!Config->RPath.empty())
|
2016-01-29 09:24:25 +08:00
|
|
|
Add({Config->EnableNewDtags ? DT_RUNPATH : DT_RPATH,
|
|
|
|
Out<ELFT>::DynStrTab->addString(Config->RPath)});
|
2016-01-26 05:32:04 +08:00
|
|
|
for (const std::unique_ptr<SharedFile<ELFT>> &F : SymTab.getSharedFiles())
|
|
|
|
if (F->isNeeded())
|
2016-01-29 09:24:25 +08:00
|
|
|
Add({DT_NEEDED, Out<ELFT>::DynStrTab->addString(F->getSoName())});
|
|
|
|
if (!Config->SoName.empty())
|
|
|
|
Add({DT_SONAME, Out<ELFT>::DynStrTab->addString(Config->SoName)});
|
|
|
|
|
2016-01-26 05:32:04 +08:00
|
|
|
Out<ELFT>::DynStrTab->finalize();
|
|
|
|
|
2016-01-26 07:38:34 +08:00
|
|
|
|
2015-10-08 03:18:16 +08:00
|
|
|
if (Out<ELFT>::RelaDyn->hasRelocs()) {
|
2016-01-26 05:32:04 +08:00
|
|
|
bool IsRela = Out<ELFT>::RelaDyn->isRela();
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({IsRela ? DT_RELA : DT_REL, Out<ELFT>::RelaDyn});
|
|
|
|
Add({IsRela ? DT_RELASZ : DT_RELSZ, Out<ELFT>::RelaDyn->getSize()});
|
|
|
|
Add({IsRela ? DT_RELAENT : DT_RELENT,
|
|
|
|
uintX_t(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()) {
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_JMPREL, Out<ELFT>::RelaPlt});
|
|
|
|
Add({DT_PLTRELSZ, Out<ELFT>::RelaPlt->getSize()});
|
|
|
|
Add({Config->EMachine == EM_MIPS ? DT_MIPS_PLTGOT : DT_PLTGOT,
|
|
|
|
Out<ELFT>::GotPlt});
|
2016-01-26 09:30:07 +08:00
|
|
|
Add({DT_PLTREL, uint64_t(Out<ELFT>::RelaPlt->isRela() ? DT_RELA : DT_REL)});
|
2015-10-20 16:54:27 +08:00
|
|
|
}
|
|
|
|
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_SYMTAB, Out<ELFT>::DynSymTab});
|
|
|
|
Add({DT_SYMENT, sizeof(Elf_Sym)});
|
|
|
|
Add({DT_STRTAB, Out<ELFT>::DynStrTab});
|
|
|
|
Add({DT_STRSZ, Out<ELFT>::DynStrTab->getSize()});
|
2015-10-22 16:21:35 +08:00
|
|
|
if (Out<ELFT>::GnuHashTab)
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_GNU_HASH, Out<ELFT>::GnuHashTab});
|
2015-10-22 16:21:35 +08:00
|
|
|
if (Out<ELFT>::HashTab)
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_HASH, Out<ELFT>::HashTab});
|
2015-10-02 03:36:04 +08:00
|
|
|
|
2016-01-26 05:32:04 +08:00
|
|
|
if (PreInitArraySec) {
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_PREINIT_ARRAY, PreInitArraySec});
|
|
|
|
Add({DT_PREINIT_ARRAYSZ, PreInitArraySec->getSize()});
|
2016-01-26 05:32:04 +08:00
|
|
|
}
|
|
|
|
if (InitArraySec) {
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_INIT_ARRAY, InitArraySec});
|
|
|
|
Add({DT_INIT_ARRAYSZ, (uintX_t)InitArraySec->getSize()});
|
2016-01-26 05:32:04 +08:00
|
|
|
}
|
|
|
|
if (FiniArraySec) {
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_FINI_ARRAY, FiniArraySec});
|
|
|
|
Add({DT_FINI_ARRAYSZ, (uintX_t)FiniArraySec->getSize()});
|
2015-10-10 04:32:54 +08:00
|
|
|
}
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2016-01-26 05:47:25 +08:00
|
|
|
if (SymbolBody *B = SymTab.find(Config->Init))
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_INIT, B});
|
2016-01-26 05:47:25 +08:00
|
|
|
if (SymbolBody *B = SymTab.find(Config->Fini))
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_FINI, B});
|
2015-10-22 01:47:10 +08:00
|
|
|
|
2016-01-26 05:32:04 +08:00
|
|
|
uint32_t DtFlags = 0;
|
|
|
|
uint32_t DtFlags1 = 0;
|
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)
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_FLAGS, DtFlags});
|
2015-10-22 01:47:10 +08:00
|
|
|
if (DtFlags1)
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_FLAGS_1, DtFlags1});
|
2015-11-12 12:39:49 +08:00
|
|
|
|
2016-01-06 23:52:27 +08:00
|
|
|
if (!Config->Entry.empty())
|
2016-01-26 09:30:07 +08:00
|
|
|
Add({DT_DEBUG, (uint64_t)0});
|
2016-01-06 23:52:27 +08:00
|
|
|
|
2015-11-12 12:39:49 +08:00
|
|
|
if (Config->EMachine == EM_MIPS) {
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_MIPS_RLD_VERSION, 1});
|
|
|
|
Add({DT_MIPS_FLAGS, RHF_NOTPOT});
|
|
|
|
Add({DT_MIPS_BASE_ADDRESS, (uintX_t)Target->getVAStart()});
|
|
|
|
Add({DT_MIPS_SYMTABNO, Out<ELFT>::DynSymTab->getNumSymbols()});
|
|
|
|
Add({DT_MIPS_LOCAL_GOTNO, Out<ELFT>::Got->getMipsLocalEntriesNum()});
|
2016-01-26 05:32:04 +08:00
|
|
|
if (const SymbolBody *B = Out<ELFT>::Got->getMipsFirstGlobalEntry())
|
2016-01-29 09:49:33 +08:00
|
|
|
Add({DT_MIPS_GOTSYM, B->DynsymIndex});
|
2016-01-26 05:32:04 +08:00
|
|
|
else
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_MIPS_GOTSYM, Out<ELFT>::DynSymTab->getNumSymbols()});
|
|
|
|
Add({DT_PLTGOT, Out<ELFT>::Got});
|
2015-11-12 12:39:49 +08:00
|
|
|
if (Out<ELFT>::MipsRldMap)
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_MIPS_RLD_MAP, Out<ELFT>::MipsRldMap});
|
2015-11-12 12:39:49 +08:00
|
|
|
}
|
|
|
|
|
2016-01-26 05:32:04 +08:00
|
|
|
// +1 for DT_NULL
|
|
|
|
Header.sh_size = (Entries.size() + 1) * Header.sh_entsize;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
auto *P = reinterpret_cast<Elf_Dyn *>(Buf);
|
|
|
|
|
2016-01-26 05:32:04 +08:00
|
|
|
for (const Entry &E : Entries) {
|
|
|
|
P->d_tag = E.Tag;
|
|
|
|
switch (E.Kind) {
|
|
|
|
case Entry::SecAddr:
|
|
|
|
P->d_un.d_ptr = E.OutSec->getVA();
|
|
|
|
break;
|
|
|
|
case Entry::SymAddr:
|
|
|
|
P->d_un.d_ptr = getSymVA<ELFT>(*E.Sym);
|
|
|
|
break;
|
|
|
|
case Entry::PlainInt:
|
|
|
|
P->d_un.d_val = E.Val;
|
|
|
|
break;
|
|
|
|
}
|
2015-09-22 05:38:08 +08:00
|
|
|
++P;
|
2015-11-12 12:39:49 +08:00
|
|
|
}
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2016-01-15 21:34:52 +08:00
|
|
|
template <class ELFT>
|
|
|
|
EhFrameHeader<ELFT>::EhFrameHeader()
|
|
|
|
: OutputSectionBase<ELFT>(".eh_frame_hdr", llvm::ELF::SHT_PROGBITS,
|
|
|
|
SHF_ALLOC) {
|
|
|
|
// It's a 4 bytes of header + pointer to the contents of the .eh_frame section
|
|
|
|
// + the number of FDE pointers in the table.
|
|
|
|
this->Header.sh_size = 12;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We have to get PC values of FDEs. They depend on relocations
|
|
|
|
// which are target specific, so we run this code after performing
|
|
|
|
// all relocations. We read the values from ouput buffer according to the
|
|
|
|
// encoding given for FDEs. Return value is an offset to the initial PC value
|
|
|
|
// for the FDE.
|
|
|
|
template <class ELFT>
|
|
|
|
typename EhFrameHeader<ELFT>::uintX_t
|
|
|
|
EhFrameHeader<ELFT>::getFdePc(uintX_t EhVA, const FdeData &F) {
|
|
|
|
const endianness E = ELFT::TargetEndianness;
|
|
|
|
assert((F.Enc & 0xF0) != dwarf::DW_EH_PE_datarel);
|
|
|
|
|
|
|
|
uintX_t FdeOff = EhVA + F.Off + 8;
|
|
|
|
switch (F.Enc & 0xF) {
|
|
|
|
case dwarf::DW_EH_PE_udata2:
|
|
|
|
case dwarf::DW_EH_PE_sdata2:
|
|
|
|
return FdeOff + read16<E>(F.PCRel);
|
|
|
|
case dwarf::DW_EH_PE_udata4:
|
|
|
|
case dwarf::DW_EH_PE_sdata4:
|
|
|
|
return FdeOff + read32<E>(F.PCRel);
|
|
|
|
case dwarf::DW_EH_PE_udata8:
|
|
|
|
case dwarf::DW_EH_PE_sdata8:
|
|
|
|
return FdeOff + read64<E>(F.PCRel);
|
|
|
|
case dwarf::DW_EH_PE_absptr:
|
|
|
|
if (sizeof(uintX_t) == 8)
|
|
|
|
return FdeOff + read64<E>(F.PCRel);
|
|
|
|
return FdeOff + read32<E>(F.PCRel);
|
|
|
|
}
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("unknown FDE size encoding");
|
2016-01-15 21:34:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void EhFrameHeader<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
const endianness E = ELFT::TargetEndianness;
|
|
|
|
|
|
|
|
const uint8_t Header[] = {1, dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4,
|
|
|
|
dwarf::DW_EH_PE_udata4,
|
|
|
|
dwarf::DW_EH_PE_datarel | dwarf::DW_EH_PE_sdata4};
|
|
|
|
memcpy(Buf, Header, sizeof(Header));
|
|
|
|
|
|
|
|
uintX_t EhVA = Sec->getVA();
|
|
|
|
uintX_t VA = this->getVA();
|
|
|
|
uintX_t EhOff = EhVA - VA - 4;
|
|
|
|
write32<E>(Buf + 4, EhOff);
|
|
|
|
write32<E>(Buf + 8, this->FdeList.size());
|
|
|
|
Buf += 12;
|
|
|
|
|
|
|
|
// InitialPC -> Offset in .eh_frame, sorted by InitialPC.
|
|
|
|
std::map<uintX_t, size_t> PcToOffset;
|
|
|
|
for (const FdeData &F : FdeList)
|
|
|
|
PcToOffset[getFdePc(EhVA, F)] = F.Off;
|
|
|
|
|
|
|
|
for (auto &I : PcToOffset) {
|
|
|
|
// The first four bytes are an offset to the initial PC value for the FDE.
|
|
|
|
write32<E>(Buf, I.first - VA);
|
|
|
|
// The last four bytes are an offset to the FDE data itself.
|
|
|
|
write32<E>(Buf + 4, EhVA + I.second - VA);
|
|
|
|
Buf += 8;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void EhFrameHeader<ELFT>::assignEhFrame(EHOutputSection<ELFT> *Sec) {
|
2016-01-26 03:27:50 +08:00
|
|
|
assert((!this->Sec || this->Sec == Sec) &&
|
|
|
|
"multiple .eh_frame sections not supported for .eh_frame_hdr");
|
2016-01-15 21:34:52 +08:00
|
|
|
Live = Config->EhFrameHdr;
|
|
|
|
this->Sec = Sec;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void EhFrameHeader<ELFT>::addFde(uint8_t Enc, size_t Off, uint8_t *PCRel) {
|
|
|
|
if (Live && (Enc & 0xF0) == dwarf::DW_EH_PE_datarel)
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("DW_EH_PE_datarel encoding unsupported for FDEs by .eh_frame_hdr");
|
2016-01-15 21:34:52 +08:00
|
|
|
FdeList.push_back(FdeData{Enc, Off, PCRel});
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void EhFrameHeader<ELFT>::reserveFde() {
|
|
|
|
// Each FDE entry is 8 bytes long:
|
|
|
|
// The first four bytes are an offset to the initial PC value for the FDE. The
|
|
|
|
// last four byte are an offset to the FDE data itself.
|
|
|
|
this->Header.sh_size += 8;
|
|
|
|
}
|
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
2016-01-08 02:33:11 +08:00
|
|
|
OutputSection<ELFT>::OutputSection(StringRef Name, uint32_t Type,
|
|
|
|
uintX_t Flags)
|
|
|
|
: OutputSectionBase<ELFT>(Name, Type, Flags) {}
|
2015-09-26 01:19:10 +08:00
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT>
|
2015-12-26 13:51:07 +08:00
|
|
|
void OutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
|
|
|
|
auto *S = cast<InputSection<ELFT>>(C);
|
|
|
|
Sections.push_back(S);
|
|
|
|
S->OutSec = this;
|
|
|
|
uint32_t Align = S->getAlign();
|
2016-01-30 04:31:05 +08:00
|
|
|
this->updateAlign(Align);
|
2015-09-22 05:38:08 +08:00
|
|
|
|
|
|
|
uintX_t Off = this->Header.sh_size;
|
2016-01-15 04:53:50 +08:00
|
|
|
Off = alignTo(Off, Align);
|
2015-12-26 13:51:07 +08:00
|
|
|
S->OutSecOff = Off;
|
|
|
|
Off += S->getSize();
|
2015-09-22 05:38:08 +08:00
|
|
|
this->Header.sh_size = Off;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
2016-01-07 04:11:55 +08:00
|
|
|
typename ELFFile<ELFT>::uintX_t 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);
|
2015-12-24 08:47:42 +08:00
|
|
|
return D.Section.getVA() + D.Value;
|
2015-10-06 22:33:58 +08:00
|
|
|
}
|
2015-09-26 02:19:03 +08:00
|
|
|
case SymbolBody::DefinedRegularKind: {
|
|
|
|
const auto &DR = cast<DefinedRegular<ELFT>>(S);
|
2015-12-24 22:22:24 +08:00
|
|
|
InputSectionBase<ELFT> *SC = DR.Section;
|
|
|
|
if (!SC)
|
|
|
|
return DR.Sym.st_value;
|
2016-01-07 11:59:08 +08:00
|
|
|
|
|
|
|
// Symbol offsets for AMDGPU need to be the offset in bytes of the symbol
|
|
|
|
// from the beginning of the section.
|
|
|
|
if (Config->EMachine == EM_AMDGPU)
|
|
|
|
return SC->getOffset(DR.Sym);
|
2015-11-04 06:39:09 +08:00
|
|
|
if (DR.Sym.getType() == STT_TLS)
|
2015-12-24 22:22:24 +08:00
|
|
|
return SC->OutSec->getVA() + SC->getOffset(DR.Sym) -
|
2015-11-07 06:14:44 +08:00
|
|
|
Out<ELFT>::TlsPhdr->p_vaddr;
|
2015-12-24 22:22:24 +08:00
|
|
|
return SC->OutSec->getVA() + SC->getOffset(DR.Sym);
|
2015-09-26 02:19:03 +08:00
|
|
|
}
|
|
|
|
case SymbolBody::DefinedCommonKind:
|
2016-01-06 00:35:43 +08:00
|
|
|
return Out<ELFT>::Bss->getVA() + cast<DefinedCommon>(S).OffsetInBss;
|
2015-10-29 00:48:58 +08:00
|
|
|
case SymbolBody::SharedKind: {
|
|
|
|
auto &SS = cast<SharedSymbol<ELFT>>(S);
|
2015-12-17 09:14:23 +08:00
|
|
|
if (SS.NeedsCopy)
|
2016-01-06 00:35:43 +08:00
|
|
|
return Out<ELFT>::Bss->getVA() + SS.OffsetInBss;
|
2015-10-29 00:48:58 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2015-12-23 07:00:50 +08:00
|
|
|
case SymbolBody::UndefinedElfKind:
|
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
|
2016-01-07 04:11:55 +08:00
|
|
|
elf2::getLocalRelTarget(const ObjectFile<ELFT> &File,
|
|
|
|
const Elf_Rel_Impl<ELFT, IsRela> &RI,
|
|
|
|
typename ELFFile<ELFT>::uintX_t Addend) {
|
2015-10-20 04:24:44 +08:00
|
|
|
typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
|
|
|
|
typedef typename ELFFile<ELFT>::uintX_t uintX_t;
|
|
|
|
|
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)
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("Unsupported relocation without symbol");
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-11-11 09:28:23 +08:00
|
|
|
InputSectionBase<ELFT> *Section = File.getSection(*Sym);
|
|
|
|
|
|
|
|
if (Sym->getType() == STT_TLS)
|
|
|
|
return (Section->OutSec->getVA() + Section->getOffset(*Sym) + Addend) -
|
2015-11-29 22:14:20 +08:00
|
|
|
Out<ELFT>::TlsPhdr->p_vaddr;
|
2015-11-11 09:28:23 +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-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
|
|
|
}
|
2015-12-25 09:00:41 +08:00
|
|
|
return VA + 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.
|
2016-01-07 04:11:55 +08:00
|
|
|
bool 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-11-12 03:54:14 +08:00
|
|
|
template <class ELFT>
|
2016-01-08 02:33:11 +08:00
|
|
|
EHOutputSection<ELFT>::EHOutputSection(StringRef Name, uint32_t Type,
|
|
|
|
uintX_t Flags)
|
2016-01-15 21:34:52 +08:00
|
|
|
: OutputSectionBase<ELFT>(Name, Type, Flags) {
|
|
|
|
Out<ELFT>::EhFrameHdr->assignEhFrame(this);
|
|
|
|
}
|
2015-11-12 03:54:14 +08:00
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
EHRegion<ELFT>::EHRegion(EHInputSection<ELFT> *S, unsigned Index)
|
|
|
|
: S(S), Index(Index) {}
|
|
|
|
|
|
|
|
template <class ELFT> StringRef EHRegion<ELFT>::data() const {
|
|
|
|
ArrayRef<uint8_t> SecData = S->getSectionData();
|
|
|
|
ArrayRef<std::pair<uintX_t, uintX_t>> Offsets = S->Offsets;
|
|
|
|
size_t Start = Offsets[Index].first;
|
|
|
|
size_t End =
|
|
|
|
Index == Offsets.size() - 1 ? SecData.size() : Offsets[Index + 1].first;
|
|
|
|
return StringRef((const char *)SecData.data() + Start, End - Start);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
Cie<ELFT>::Cie(EHInputSection<ELFT> *S, unsigned Index)
|
|
|
|
: EHRegion<ELFT>(S, Index) {}
|
|
|
|
|
2016-01-15 21:34:52 +08:00
|
|
|
// Read a byte and advance D by one byte.
|
|
|
|
static uint8_t readByte(ArrayRef<uint8_t> &D) {
|
|
|
|
if (D.empty())
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("corrupted or unsupported CIE information");
|
2016-01-15 21:34:52 +08:00
|
|
|
uint8_t B = D.front();
|
|
|
|
D = D.slice(1);
|
|
|
|
return B;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void skipLeb128(ArrayRef<uint8_t> &D) {
|
|
|
|
while (!D.empty()) {
|
|
|
|
uint8_t Val = D.front();
|
|
|
|
D = D.slice(1);
|
|
|
|
if ((Val & 0x80) == 0)
|
|
|
|
return;
|
|
|
|
}
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("corrupted or unsupported CIE information");
|
2016-01-15 21:34:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> static unsigned getSizeForEncoding(unsigned Enc) {
|
|
|
|
typedef typename ELFFile<ELFT>::uintX_t uintX_t;
|
|
|
|
switch (Enc & 0x0f) {
|
|
|
|
default:
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("unknown FDE encoding");
|
2016-01-15 21:34:52 +08:00
|
|
|
case dwarf::DW_EH_PE_absptr:
|
|
|
|
case dwarf::DW_EH_PE_signed:
|
|
|
|
return sizeof(uintX_t);
|
|
|
|
case dwarf::DW_EH_PE_udata2:
|
|
|
|
case dwarf::DW_EH_PE_sdata2:
|
|
|
|
return 2;
|
|
|
|
case dwarf::DW_EH_PE_udata4:
|
|
|
|
case dwarf::DW_EH_PE_sdata4:
|
|
|
|
return 4;
|
|
|
|
case dwarf::DW_EH_PE_udata8:
|
|
|
|
case dwarf::DW_EH_PE_sdata8:
|
|
|
|
return 8;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
uint8_t EHOutputSection<ELFT>::getFdeEncoding(ArrayRef<uint8_t> D) {
|
|
|
|
auto Check = [](bool C) {
|
|
|
|
if (!C)
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("corrupted or unsupported CIE information");
|
2016-01-15 21:34:52 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
Check(D.size() >= 8);
|
|
|
|
D = D.slice(8);
|
|
|
|
|
|
|
|
uint8_t Version = readByte(D);
|
|
|
|
if (Version != 1 && Version != 3)
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("FDE version 1 or 3 expected, but got " + Twine((unsigned)Version));
|
2016-01-15 21:34:52 +08:00
|
|
|
|
|
|
|
auto AugEnd = std::find(D.begin() + 1, D.end(), '\0');
|
|
|
|
Check(AugEnd != D.end());
|
|
|
|
ArrayRef<uint8_t> AugString(D.begin(), AugEnd - D.begin());
|
|
|
|
D = D.slice(AugString.size() + 1);
|
|
|
|
|
|
|
|
// Code alignment factor should always be 1 for .eh_frame.
|
|
|
|
if (readByte(D) != 1)
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("CIE code alignment must be 1");
|
2016-01-15 21:34:52 +08:00
|
|
|
// Skip data alignment factor
|
|
|
|
skipLeb128(D);
|
|
|
|
|
|
|
|
// Skip the return address register. In CIE version 1 this is a single
|
|
|
|
// byte. In CIE version 3 this is an unsigned LEB128.
|
|
|
|
if (Version == 1)
|
|
|
|
readByte(D);
|
|
|
|
else
|
|
|
|
skipLeb128(D);
|
|
|
|
|
|
|
|
while (!AugString.empty()) {
|
|
|
|
switch (readByte(AugString)) {
|
|
|
|
case 'z':
|
|
|
|
skipLeb128(D);
|
|
|
|
break;
|
|
|
|
case 'R':
|
|
|
|
return readByte(D);
|
|
|
|
case 'P': {
|
|
|
|
uint8_t Enc = readByte(D);
|
|
|
|
if ((Enc & 0xf0) == dwarf::DW_EH_PE_aligned)
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("DW_EH_PE_aligned encoding for address of a personality routine "
|
2016-01-15 21:34:52 +08:00
|
|
|
"handler not supported");
|
|
|
|
unsigned EncSize = getSizeForEncoding<ELFT>(Enc);
|
|
|
|
Check(D.size() >= EncSize);
|
|
|
|
D = D.slice(EncSize);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 'S':
|
|
|
|
case 'L':
|
|
|
|
// L: Language Specific Data Area (LSDA) encoding
|
|
|
|
// S: This CIE represents a stack frame for the invocation of a signal
|
|
|
|
// handler
|
|
|
|
break;
|
|
|
|
default:
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("unknown .eh_frame augmentation string value");
|
2016-01-15 21:34:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return dwarf::DW_EH_PE_absptr;
|
|
|
|
}
|
|
|
|
|
2015-11-12 03:54:14 +08:00
|
|
|
template <class ELFT>
|
|
|
|
template <bool IsRela>
|
|
|
|
void EHOutputSection<ELFT>::addSectionAux(
|
|
|
|
EHInputSection<ELFT> *S,
|
|
|
|
iterator_range<const Elf_Rel_Impl<ELFT, IsRela> *> Rels) {
|
|
|
|
const endianness E = ELFT::TargetEndianness;
|
|
|
|
|
|
|
|
S->OutSec = this;
|
2016-01-30 04:31:05 +08:00
|
|
|
this->updateAlign(S->getAlign());
|
2015-11-12 03:54:14 +08:00
|
|
|
Sections.push_back(S);
|
|
|
|
|
|
|
|
ArrayRef<uint8_t> SecData = S->getSectionData();
|
|
|
|
ArrayRef<uint8_t> D = SecData;
|
|
|
|
uintX_t Offset = 0;
|
|
|
|
auto RelI = Rels.begin();
|
|
|
|
auto RelE = Rels.end();
|
|
|
|
|
2016-01-03 00:55:01 +08:00
|
|
|
DenseMap<unsigned, unsigned> OffsetToIndex;
|
2015-11-12 03:54:14 +08:00
|
|
|
while (!D.empty()) {
|
|
|
|
unsigned Index = S->Offsets.size();
|
|
|
|
S->Offsets.push_back(std::make_pair(Offset, -1));
|
|
|
|
|
2015-12-17 17:23:40 +08:00
|
|
|
uintX_t Length = readEntryLength(D);
|
2016-01-15 21:34:52 +08:00
|
|
|
// If CIE/FDE data length is zero then Length is 4, this
|
|
|
|
// shall be considered a terminator and processing shall end.
|
|
|
|
if (Length == 4)
|
|
|
|
break;
|
2015-11-12 03:54:14 +08:00
|
|
|
StringRef Entry((const char *)D.data(), Length);
|
|
|
|
|
|
|
|
while (RelI != RelE && RelI->r_offset < Offset)
|
|
|
|
++RelI;
|
|
|
|
uintX_t NextOffset = Offset + Length;
|
|
|
|
bool HasReloc = RelI != RelE && RelI->r_offset < NextOffset;
|
|
|
|
|
|
|
|
uint32_t ID = read32<E>(D.data() + 4);
|
|
|
|
if (ID == 0) {
|
|
|
|
// CIE
|
|
|
|
Cie<ELFT> C(S, Index);
|
2016-01-15 21:34:52 +08:00
|
|
|
if (Config->EhFrameHdr)
|
|
|
|
C.FdeEncoding = getFdeEncoding(D);
|
2015-11-12 03:54:14 +08:00
|
|
|
|
|
|
|
StringRef Personality;
|
|
|
|
if (HasReloc) {
|
|
|
|
uint32_t SymIndex = RelI->getSymbol(Config->Mips64EL);
|
|
|
|
SymbolBody &Body = *S->getFile()->getSymbolBody(SymIndex)->repl();
|
|
|
|
Personality = Body.getName();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::pair<StringRef, StringRef> CieInfo(Entry, Personality);
|
|
|
|
auto P = CieMap.insert(std::make_pair(CieInfo, Cies.size()));
|
2016-01-03 00:55:01 +08:00
|
|
|
if (P.second) {
|
2015-11-12 03:54:14 +08:00
|
|
|
Cies.push_back(C);
|
2016-01-15 04:53:50 +08:00
|
|
|
this->Header.sh_size += alignTo(Length, sizeof(uintX_t));
|
2016-01-03 00:55:01 +08:00
|
|
|
}
|
|
|
|
OffsetToIndex[Offset] = P.first->second;
|
2015-11-12 03:54:14 +08:00
|
|
|
} else {
|
|
|
|
if (!HasReloc)
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("FDE doesn't reference another section");
|
2015-11-12 03:54:14 +08:00
|
|
|
InputSectionBase<ELFT> *Target = S->getRelocTarget(*RelI);
|
|
|
|
if (Target != &InputSection<ELFT>::Discarded && Target->isLive()) {
|
|
|
|
uint32_t CieOffset = Offset + 4 - ID;
|
2016-01-03 00:55:01 +08:00
|
|
|
auto I = OffsetToIndex.find(CieOffset);
|
|
|
|
if (I == OffsetToIndex.end())
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("Invalid CIE reference");
|
2016-01-03 00:55:01 +08:00
|
|
|
Cies[I->second].Fdes.push_back(EHRegion<ELFT>(S, Index));
|
2016-01-15 21:34:52 +08:00
|
|
|
Out<ELFT>::EhFrameHdr->reserveFde();
|
2016-01-15 04:53:50 +08:00
|
|
|
this->Header.sh_size += alignTo(Length, sizeof(uintX_t));
|
2015-11-12 03:54:14 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Offset = NextOffset;
|
|
|
|
D = D.slice(Length);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-17 17:23:40 +08:00
|
|
|
template <class ELFT>
|
|
|
|
typename EHOutputSection<ELFT>::uintX_t
|
|
|
|
EHOutputSection<ELFT>::readEntryLength(ArrayRef<uint8_t> D) {
|
|
|
|
const endianness E = ELFT::TargetEndianness;
|
|
|
|
|
|
|
|
if (D.size() < 4)
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("Truncated CIE/FDE length");
|
2015-12-17 17:23:40 +08:00
|
|
|
uint64_t Len = read32<E>(D.data());
|
|
|
|
if (Len < UINT32_MAX) {
|
|
|
|
if (Len > (UINT32_MAX - 4))
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("CIE/FIE size is too large");
|
2015-12-17 17:23:40 +08:00
|
|
|
if (Len + 4 > D.size())
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("CIE/FIE ends past the end of the section");
|
2015-12-17 17:23:40 +08:00
|
|
|
return Len + 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (D.size() < 12)
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("Truncated CIE/FDE length");
|
2015-12-17 17:23:40 +08:00
|
|
|
Len = read64<E>(D.data() + 4);
|
|
|
|
if (Len > (UINT64_MAX - 12))
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("CIE/FIE size is too large");
|
2015-12-17 17:23:40 +08:00
|
|
|
if (Len + 12 > D.size())
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("CIE/FIE ends past the end of the section");
|
2015-12-17 17:23:40 +08:00
|
|
|
return Len + 12;
|
|
|
|
}
|
|
|
|
|
2015-11-12 03:54:14 +08:00
|
|
|
template <class ELFT>
|
2015-12-26 13:51:07 +08:00
|
|
|
void EHOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
|
|
|
|
auto *S = cast<EHInputSection<ELFT>>(C);
|
2015-11-12 03:54:14 +08:00
|
|
|
const Elf_Shdr *RelSec = S->RelocSection;
|
2016-01-28 06:23:44 +08:00
|
|
|
if (!RelSec) {
|
|
|
|
addSectionAux(S, make_range<const Elf_Rela *>(nullptr, nullptr));
|
|
|
|
return;
|
|
|
|
}
|
2015-11-12 03:54:14 +08:00
|
|
|
ELFFile<ELFT> &Obj = S->getFile()->getObj();
|
|
|
|
if (RelSec->sh_type == SHT_RELA)
|
2016-01-28 06:23:44 +08:00
|
|
|
addSectionAux(S, Obj.relas(RelSec));
|
|
|
|
else
|
|
|
|
addSectionAux(S, Obj.rels(RelSec));
|
2015-11-12 03:54:14 +08:00
|
|
|
}
|
|
|
|
|
2015-12-25 04:44:06 +08:00
|
|
|
template <class ELFT>
|
|
|
|
static typename ELFFile<ELFT>::uintX_t writeAlignedCieOrFde(StringRef Data,
|
|
|
|
uint8_t *Buf) {
|
|
|
|
typedef typename ELFFile<ELFT>::uintX_t uintX_t;
|
|
|
|
const endianness E = ELFT::TargetEndianness;
|
2016-01-15 04:53:50 +08:00
|
|
|
uint64_t Len = alignTo(Data.size(), sizeof(uintX_t));
|
2015-12-25 04:44:06 +08:00
|
|
|
write32<E>(Buf, Len - 4);
|
|
|
|
memcpy(Buf + 4, Data.data() + 4, Data.size() - 4);
|
|
|
|
return Len;
|
|
|
|
}
|
|
|
|
|
2015-11-12 03:54:14 +08:00
|
|
|
template <class ELFT> void EHOutputSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
const endianness E = ELFT::TargetEndianness;
|
|
|
|
size_t Offset = 0;
|
|
|
|
for (const Cie<ELFT> &C : Cies) {
|
|
|
|
size_t CieOffset = Offset;
|
|
|
|
|
2015-12-25 04:44:06 +08:00
|
|
|
uintX_t CIELen = writeAlignedCieOrFde<ELFT>(C.data(), Buf + Offset);
|
2015-11-12 03:54:14 +08:00
|
|
|
C.S->Offsets[C.Index].second = Offset;
|
2015-12-25 04:44:06 +08:00
|
|
|
Offset += CIELen;
|
2015-11-12 03:54:14 +08:00
|
|
|
|
|
|
|
for (const EHRegion<ELFT> &F : C.Fdes) {
|
2015-12-25 04:44:06 +08:00
|
|
|
uintX_t Len = writeAlignedCieOrFde<ELFT>(F.data(), Buf + Offset);
|
2015-11-12 03:54:14 +08:00
|
|
|
write32<E>(Buf + Offset + 4, Offset + 4 - CieOffset); // Pointer
|
|
|
|
F.S->Offsets[F.Index].second = Offset;
|
2016-01-15 21:34:52 +08:00
|
|
|
Out<ELFT>::EhFrameHdr->addFde(C.FdeEncoding, Offset, Buf + Offset + 8);
|
2015-12-21 17:38:59 +08:00
|
|
|
Offset += Len;
|
2015-11-12 03:54:14 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (EHInputSection<ELFT> *S : Sections) {
|
|
|
|
const Elf_Shdr *RelSec = S->RelocSection;
|
|
|
|
if (!RelSec)
|
|
|
|
continue;
|
|
|
|
ELFFile<ELFT> &EObj = S->getFile()->getObj();
|
|
|
|
if (RelSec->sh_type == SHT_RELA)
|
|
|
|
S->relocate(Buf, nullptr, EObj.relas(RelSec));
|
|
|
|
else
|
2015-11-23 23:28:28 +08:00
|
|
|
S->relocate(Buf, nullptr, EObj.rels(RelSec));
|
2015-11-12 03:54:14 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-20 05:00:02 +08:00
|
|
|
template <class ELFT>
|
2016-01-08 02:33:11 +08:00
|
|
|
MergeOutputSection<ELFT>::MergeOutputSection(StringRef Name, uint32_t Type,
|
|
|
|
uintX_t Flags)
|
|
|
|
: OutputSectionBase<ELFT>(Name, Type, Flags) {}
|
2015-10-20 05:00:02 +08:00
|
|
|
|
|
|
|
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>
|
2015-12-26 13:51:07 +08:00
|
|
|
void MergeOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
|
|
|
|
auto *S = cast<MergeInputSection<ELFT>>(C);
|
2015-10-20 05:00:02 +08:00
|
|
|
S->OutSec = this;
|
2016-01-30 04:31:05 +08:00
|
|
|
this->updateAlign(S->getAlign());
|
2015-10-20 05:00:02 +08:00
|
|
|
|
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
|
|
|
|
2016-01-30 06:18:55 +08:00
|
|
|
// If this is of type string, the contents are null-terminated strings.
|
2015-10-25 06:51:01 +08:00
|
|
|
if (this->Header.sh_flags & SHF_STRINGS) {
|
2016-01-06 10:52:24 +08:00
|
|
|
uintX_t Offset = 0;
|
2015-10-25 06:51:01 +08:00
|
|
|
while (!Data.empty()) {
|
|
|
|
size_t End = findNull(Data, EntSize);
|
|
|
|
if (End == StringRef::npos)
|
ELF: Rename error -> fatal and redefine error as a non-noreturn function.
In many situations, we don't want to exit at the first error even in the
process model. For example, it is better to report all undefined symbols
rather than reporting the first one that the linker picked up randomly.
In order to handle such errors, we don't need to wrap everything with
ErrorOr (thanks for David Blaikie for pointing this out!) Instead, we
can set a flag to record the fact that we found an error and keep it
going until it reaches a reasonable checkpoint.
This idea should be applicable to other places. For example, we can
ignore broken relocations and check for errors after visiting all relocs.
In this patch, I rename error to fatal, and introduce another version of
error which doesn't call exit. That function instead sets HasError to true.
Once HasError becomes true, it stays true, so that we know that there
was an error if it is true.
I think introducing a non-noreturn error reporting function is by itself
a good idea, and it looks to me that this also provides a gradual path
towards lld-as-a-library (or at least embed-lld-to-your-program) without
sacrificing code readability with lots of ErrorOr's.
http://reviews.llvm.org/D16641
llvm-svn: 259069
2016-01-29 02:40:06 +08:00
|
|
|
fatal("String is not null terminated");
|
2015-10-25 06:51:01 +08:00
|
|
|
StringRef Entry = Data.substr(0, End + EntSize);
|
2015-11-13 21:44:59 +08:00
|
|
|
uintX_t OutputOffset = Builder.add(Entry);
|
2015-10-25 06:51:01 +08:00
|
|
|
if (shouldTailMerge())
|
|
|
|
OutputOffset = -1;
|
|
|
|
S->Offsets.push_back(std::make_pair(Offset, OutputOffset));
|
|
|
|
uintX_t Size = End + EntSize;
|
|
|
|
Data = Data.substr(Size);
|
|
|
|
Offset += Size;
|
|
|
|
}
|
2016-01-30 06:18:55 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this is not of type string, every entry has the same size.
|
|
|
|
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(I, OutputOffset));
|
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)
|
2016-01-08 04:53:30 +08:00
|
|
|
: OutputSectionBase<ELFT>(Name, SHT_STRTAB,
|
|
|
|
Dynamic ? (uintX_t)SHF_ALLOC : 0),
|
2015-09-26 01:19:10 +08:00
|
|
|
Dynamic(Dynamic) {
|
|
|
|
this->Header.sh_addralign = 1;
|
|
|
|
}
|
|
|
|
|
2016-01-29 09:24:25 +08:00
|
|
|
// Adds a string to the string table. If HashIt is true we hash and check for
|
|
|
|
// duplicates. It is optional because the name of global symbols are already
|
|
|
|
// uniqued and hashing them again has a big cost for a small value: uniquing
|
|
|
|
// them with some other string that happens to be the same.
|
|
|
|
template <class ELFT>
|
|
|
|
unsigned StringTableSection<ELFT>::addString(StringRef S, bool HashIt) {
|
|
|
|
if (HashIt) {
|
|
|
|
auto R = StringMap.insert(std::make_pair(S, Size));
|
|
|
|
if (!R.second)
|
|
|
|
return R.first->second;
|
|
|
|
}
|
|
|
|
unsigned Ret = Size;
|
|
|
|
Size += S.size() + 1;
|
2016-01-07 10:35:32 +08:00
|
|
|
Strings.push_back(S);
|
2016-01-29 09:24:25 +08:00
|
|
|
return Ret;
|
2016-01-07 10:35:32 +08:00
|
|
|
}
|
|
|
|
|
2015-10-16 06:27:29 +08:00
|
|
|
template <class ELFT> void StringTableSection<ELFT>::writeTo(uint8_t *Buf) {
|
2016-01-07 10:35:32 +08:00
|
|
|
// ELF string tables start with NUL byte, so advance the pointer by one.
|
|
|
|
++Buf;
|
|
|
|
for (StringRef S : Strings) {
|
|
|
|
memcpy(Buf, S.data(), S.size());
|
|
|
|
Buf += S.size() + 1;
|
|
|
|
}
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
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)
|
2016-01-07 06:53:58 +08:00
|
|
|
: OutputSectionBase<ELFT>(StrTabSec.isDynamic() ? ".dynsym" : ".symtab",
|
|
|
|
StrTabSec.isDynamic() ? SHT_DYNSYM : SHT_SYMTAB,
|
2016-01-08 04:53:30 +08:00
|
|
|
StrTabSec.isDynamic() ? (uintX_t)SHF_ALLOC : 0),
|
2016-01-29 09:24:25 +08:00
|
|
|
StrTabSec(StrTabSec), Table(Table) {
|
2016-01-08 02:20:02 +08:00
|
|
|
this->Header.sh_entsize = sizeof(Elf_Sym);
|
|
|
|
this->Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
|
2015-09-26 01:19:10 +08:00
|
|
|
}
|
|
|
|
|
2015-11-12 12:08:12 +08:00
|
|
|
// Orders symbols according to their positions in the GOT,
|
|
|
|
// in compliance with MIPS ABI rules.
|
|
|
|
// 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
|
2016-01-29 09:24:25 +08:00
|
|
|
static bool sortMipsSymbols(const std::pair<SymbolBody *, unsigned> &L,
|
|
|
|
const std::pair<SymbolBody *, unsigned> &R) {
|
|
|
|
if (!L.first->isInGot() || !R.first->isInGot())
|
|
|
|
return R.first->isInGot();
|
|
|
|
return L.first->GotIndex < R.first->GotIndex;
|
2015-11-12 12:08:12 +08:00
|
|
|
}
|
|
|
|
|
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(),
|
2016-01-29 09:24:25 +08:00
|
|
|
[](const std::pair<SymbolBody *, unsigned> &L,
|
|
|
|
const std::pair<SymbolBody *, unsigned> &R) {
|
|
|
|
return getSymbolBinding(L.first) == STB_LOCAL &&
|
|
|
|
getSymbolBinding(R.first) != 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-11-12 12:08:12 +08:00
|
|
|
else if (Config->EMachine == EM_MIPS)
|
|
|
|
std::stable_sort(Symbols.begin(), Symbols.end(), sortMipsSymbols);
|
2015-10-21 05:47:58 +08:00
|
|
|
size_t I = 0;
|
2016-01-29 09:24:25 +08:00
|
|
|
for (const std::pair<SymbolBody *, unsigned> &P : Symbols)
|
2016-01-29 09:49:33 +08:00
|
|
|
P.first->DynsymIndex = ++I;
|
2015-10-21 05:47:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void SymbolTableSection<ELFT>::addSymbol(SymbolBody *Body) {
|
2016-01-29 09:24:25 +08:00
|
|
|
Symbols.push_back(
|
|
|
|
std::make_pair(Body, StrTabSec.addString(Body->getName(), false)));
|
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()) {
|
2016-01-29 09:24:25 +08:00
|
|
|
for (const std::pair<const Elf_Sym *, unsigned> &P : File->KeptLocalSyms) {
|
|
|
|
const Elf_Sym *Sym = P.first;
|
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;
|
2016-01-28 02:04:26 +08:00
|
|
|
if (Sym->st_shndx == SHN_ABS) {
|
2015-09-30 08:32:10 +08:00
|
|
|
ESym->st_shndx = SHN_ABS;
|
2016-01-28 02:04:26 +08:00
|
|
|
VA = Sym->st_value;
|
2015-09-30 08:32:10 +08:00
|
|
|
} else {
|
2016-01-28 02:04:26 +08:00
|
|
|
InputSectionBase<ELFT> *Section = File->getSection(*Sym);
|
2015-10-20 05:00:02 +08:00
|
|
|
const OutputSectionBase<ELFT> *OutSec = Section->OutSec;
|
|
|
|
ESym->st_shndx = OutSec->SectionIndex;
|
2016-01-28 02:04:26 +08:00
|
|
|
VA = Section->getOffset(*Sym);
|
2016-01-07 11:59:08 +08:00
|
|
|
// Symbol offsets for AMDGPU need to be the offset in bytes of the
|
|
|
|
// symbol from the beginning of the section.
|
|
|
|
if (Config->EMachine != EM_AMDGPU)
|
|
|
|
VA += OutSec->getVA();
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
2016-01-29 09:24:25 +08:00
|
|
|
ESym->st_name = P.second;
|
2016-01-28 02:04:26 +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-12-23 07:00:50 +08:00
|
|
|
template <class ELFT>
|
|
|
|
static const typename llvm::object::ELFFile<ELFT>::Elf_Sym *
|
|
|
|
getElfSym(SymbolBody &Body) {
|
2015-12-24 08:47:42 +08:00
|
|
|
if (auto *EBody = dyn_cast<DefinedElf<ELFT>>(&Body))
|
2015-12-23 07:00:50 +08:00
|
|
|
return &EBody->Sym;
|
|
|
|
if (auto *EBody = dyn_cast<UndefinedElf<ELFT>>(&Body))
|
|
|
|
return &EBody->Sym;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
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);
|
2016-01-29 09:24:25 +08:00
|
|
|
for (const std::pair<SymbolBody *, unsigned> &P : Symbols) {
|
|
|
|
SymbolBody *Body = P.first;
|
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());
|
2015-12-24 22:22:24 +08:00
|
|
|
if (InputSectionBase<ELFT> *Sec = Sym->Section) {
|
|
|
|
if (!Sec->isLive())
|
|
|
|
continue;
|
|
|
|
OutSec = Sec->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-12-17 09:14:23 +08:00
|
|
|
if (cast<SharedSymbol<ELFT>>(Body)->NeedsCopy)
|
2015-10-29 00:48:58 +08:00
|
|
|
OutSec = Out<ELFT>::Bss;
|
|
|
|
break;
|
|
|
|
}
|
2015-12-23 07:00:50 +08:00
|
|
|
case SymbolBody::UndefinedElfKind:
|
2015-09-22 05:38:08 +08:00
|
|
|
case SymbolBody::UndefinedKind:
|
|
|
|
case SymbolBody::LazyKind:
|
2015-10-06 22:33:58 +08:00
|
|
|
break;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2016-01-29 09:24:25 +08:00
|
|
|
ESym->st_name = P.second;
|
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;
|
2015-12-23 07:00:50 +08:00
|
|
|
if (const Elf_Sym *InputSym = getElfSym<ELFT>(*Body)) {
|
|
|
|
Type = InputSym->getType();
|
|
|
|
Size = InputSym->st_size;
|
2015-12-25 00:23:37 +08:00
|
|
|
} else if (auto *C = dyn_cast<DefinedCommon>(Body)) {
|
|
|
|
Type = STT_OBJECT;
|
|
|
|
Size = C->Size;
|
2015-10-06 22:33:58 +08:00
|
|
|
}
|
|
|
|
|
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-12-24 22:22:24 +08:00
|
|
|
if (OutSec)
|
2015-10-16 04:55:22 +08:00
|
|
|
ESym->st_shndx = OutSec->SectionIndex;
|
2015-12-24 22:22:24 +08:00
|
|
|
else if (isa<DefinedRegular<ELFT>>(Body))
|
|
|
|
ESym->st_shndx = SHN_ABS;
|
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;
|
2015-12-23 07:00:50 +08:00
|
|
|
if (const Elf_Sym *ESym = getElfSym<ELFT>(*Body))
|
|
|
|
return ESym->getBinding();
|
2015-12-24 08:47:42 +08:00
|
|
|
if (isa<DefinedSynthetic<ELFT>>(Body))
|
|
|
|
return STB_LOCAL;
|
2015-10-21 04:52:14 +08:00
|
|
|
return Body->isWeak() ? STB_WEAK : STB_GLOBAL;
|
|
|
|
}
|
|
|
|
|
2015-12-20 18:57:34 +08:00
|
|
|
template <class ELFT>
|
|
|
|
MipsReginfoOutputSection<ELFT>::MipsReginfoOutputSection()
|
|
|
|
: OutputSectionBase<ELFT>(".reginfo", SHT_MIPS_REGINFO, SHF_ALLOC) {
|
|
|
|
this->Header.sh_addralign = 4;
|
|
|
|
this->Header.sh_entsize = sizeof(Elf_Mips_RegInfo);
|
|
|
|
this->Header.sh_size = sizeof(Elf_Mips_RegInfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void MipsReginfoOutputSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
auto *R = reinterpret_cast<Elf_Mips_RegInfo *>(Buf);
|
|
|
|
R->ri_gp_value = getMipsGpAddr<ELFT>();
|
2016-01-07 06:42:43 +08:00
|
|
|
R->ri_gprmask = GprMask;
|
2015-12-20 18:57:34 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
2015-12-26 13:51:07 +08:00
|
|
|
void MipsReginfoOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
|
2016-01-07 06:42:43 +08:00
|
|
|
// Copy input object file's .reginfo gprmask to output.
|
2015-12-26 13:51:07 +08:00
|
|
|
auto *S = cast<MipsReginfoInputSection<ELFT>>(C);
|
2016-01-07 06:42:43 +08:00
|
|
|
GprMask |= S->Reginfo->ri_gprmask;
|
2015-12-20 18:57:34 +08:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2016-01-15 21:34:52 +08:00
|
|
|
template class EhFrameHeader<ELF32LE>;
|
|
|
|
template class EhFrameHeader<ELF32BE>;
|
|
|
|
template class EhFrameHeader<ELF64LE>;
|
|
|
|
template class EhFrameHeader<ELF64BE>;
|
|
|
|
|
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-11-12 03:54:14 +08:00
|
|
|
template class EHOutputSection<ELF32LE>;
|
|
|
|
template class EHOutputSection<ELF32BE>;
|
|
|
|
template class EHOutputSection<ELF64LE>;
|
|
|
|
template class EHOutputSection<ELF64BE>;
|
|
|
|
|
2015-12-20 18:57:34 +08:00
|
|
|
template class MipsReginfoOutputSection<ELF32LE>;
|
|
|
|
template class MipsReginfoOutputSection<ELF32BE>;
|
|
|
|
template class MipsReginfoOutputSection<ELF64LE>;
|
|
|
|
template class MipsReginfoOutputSection<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
|
|
|
|
2016-01-26 09:32:00 +08:00
|
|
|
template uint32_t getLocalRelTarget(const ObjectFile<ELF32LE> &,
|
|
|
|
const ELFFile<ELF32LE>::Elf_Rel &,
|
|
|
|
uint32_t);
|
|
|
|
template uint32_t getLocalRelTarget(const ObjectFile<ELF32BE> &,
|
|
|
|
const ELFFile<ELF32BE>::Elf_Rel &,
|
|
|
|
uint32_t);
|
|
|
|
template uint64_t getLocalRelTarget(const ObjectFile<ELF64LE> &,
|
|
|
|
const ELFFile<ELF64LE>::Elf_Rel &,
|
|
|
|
uint64_t);
|
|
|
|
template uint64_t getLocalRelTarget(const ObjectFile<ELF64BE> &,
|
|
|
|
const ELFFile<ELF64BE>::Elf_Rel &,
|
|
|
|
uint64_t);
|
|
|
|
template uint32_t getLocalRelTarget(const ObjectFile<ELF32LE> &,
|
|
|
|
const ELFFile<ELF32LE>::Elf_Rela &,
|
|
|
|
uint32_t);
|
|
|
|
template uint32_t getLocalRelTarget(const ObjectFile<ELF32BE> &,
|
|
|
|
const ELFFile<ELF32BE>::Elf_Rela &,
|
|
|
|
uint32_t);
|
|
|
|
template uint64_t getLocalRelTarget(const ObjectFile<ELF64LE> &,
|
|
|
|
const ELFFile<ELF64LE>::Elf_Rela &,
|
|
|
|
uint64_t);
|
|
|
|
template uint64_t getLocalRelTarget(const ObjectFile<ELF64BE> &,
|
|
|
|
const ELFFile<ELF64BE>::Elf_Rela &,
|
|
|
|
uint64_t);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
}
|