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"
|
2016-05-24 10:55:45 +08:00
|
|
|
#include "EhFrame.h"
|
2016-02-26 22:48:31 +08:00
|
|
|
#include "LinkerScript.h"
|
2016-06-29 17:08:02 +08:00
|
|
|
#include "Strings.h"
|
2015-09-22 05:38:08 +08:00
|
|
|
#include "SymbolTable.h"
|
2015-09-23 02:19:46 +08:00
|
|
|
#include "Target.h"
|
2016-03-11 12:23:12 +08:00
|
|
|
#include "lld/Core/Parallel.h"
|
2016-01-15 21:34:52 +08:00
|
|
|
#include "llvm/Support/Dwarf.h"
|
2016-04-08 06:49:21 +08:00
|
|
|
#include "llvm/Support/MD5.h"
|
2015-10-22 16:21:35 +08:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2016-04-08 07:51:56 +08:00
|
|
|
#include "llvm/Support/SHA1.h"
|
2016-08-26 17:55:37 +08:00
|
|
|
#include "llvm/Support/RandomNumberGenerator.h"
|
2015-09-22 05:38:08 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
2016-02-10 05:46:11 +08:00
|
|
|
using namespace llvm::dwarf;
|
2015-09-22 05:38:08 +08:00
|
|
|
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;
|
2016-02-28 08:25:54 +08:00
|
|
|
using namespace lld::elf;
|
2015-09-22 05:38:08 +08:00
|
|
|
|
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) {
|
2016-04-20 12:26:16 +08:00
|
|
|
memset(&Header, 0, sizeof(Elf_Shdr));
|
2016-01-08 02:33:11 +08:00
|
|
|
Header.sh_type = Type;
|
|
|
|
Header.sh_flags = Flags;
|
2016-07-14 13:46:24 +08:00
|
|
|
Header.sh_addralign = 1;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2016-07-27 22:10:56 +08:00
|
|
|
template <class ELFT> uint32_t OutputSectionBase<ELFT>::getPhdrFlags() const {
|
|
|
|
uintX_t Flags = getFlags();
|
|
|
|
uint32_t Ret = PF_R;
|
|
|
|
if (Flags & SHF_WRITE)
|
|
|
|
Ret |= PF_W;
|
|
|
|
if (Flags & SHF_EXECINSTR)
|
|
|
|
Ret |= PF_X;
|
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
|
2016-03-13 14:50:33 +08:00
|
|
|
template <class ELFT>
|
|
|
|
void OutputSectionBase<ELFT>::writeHeaderTo(Elf_Shdr *Shdr) {
|
|
|
|
*Shdr = Header;
|
|
|
|
}
|
|
|
|
|
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) {
|
2016-07-14 02:55:14 +08:00
|
|
|
this->Header.sh_addralign = Target->GotPltEntrySize;
|
2015-10-20 16:54:27 +08:00
|
|
|
}
|
|
|
|
|
2016-03-11 20:06:30 +08:00
|
|
|
template <class ELFT> void GotPltSection<ELFT>::addEntry(SymbolBody &Sym) {
|
|
|
|
Sym.GotPltIndex = Target->GotPltHeaderEntriesNum + Entries.size();
|
|
|
|
Entries.push_back(&Sym);
|
2015-10-20 16:54:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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> void GotPltSection<ELFT>::finalize() {
|
2016-07-14 02:55:14 +08:00
|
|
|
this->Header.sh_size = (Target->GotPltHeaderEntriesNum + Entries.size()) *
|
|
|
|
Target->GotPltEntrySize;
|
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-07-14 02:55:14 +08:00
|
|
|
Buf += Target->GotPltHeaderEntriesNum * Target->GotPltEntrySize;
|
2015-10-20 16:54:27 +08:00
|
|
|
for (const SymbolBody *B : Entries) {
|
2016-06-17 00:14:50 +08:00
|
|
|
Target->writeGotPlt(Buf, *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;
|
2016-07-14 02:55:14 +08:00
|
|
|
this->Header.sh_addralign = Target->GotEntrySize;
|
2015-09-26 01:19:10 +08:00
|
|
|
}
|
|
|
|
|
2016-06-20 05:39:37 +08:00
|
|
|
template <class ELFT>
|
|
|
|
void GotSection<ELFT>::addEntry(SymbolBody &Sym) {
|
2016-03-11 20:06:30 +08:00
|
|
|
Sym.GotIndex = Entries.size();
|
|
|
|
Entries.push_back(&Sym);
|
2015-11-14 00:28:53 +08:00
|
|
|
}
|
|
|
|
|
2016-06-20 05:39:37 +08:00
|
|
|
template <class ELFT>
|
|
|
|
void GotSection<ELFT>::addMipsEntry(SymbolBody &Sym, uintX_t Addend,
|
|
|
|
RelExpr Expr) {
|
|
|
|
// For "true" local symbols which can be referenced from the same module
|
|
|
|
// only compiler creates two instructions for address loading:
|
|
|
|
//
|
|
|
|
// lw $8, 0($gp) # R_MIPS_GOT16
|
|
|
|
// addi $8, $8, 0 # R_MIPS_LO16
|
|
|
|
//
|
|
|
|
// The first instruction loads high 16 bits of the symbol address while
|
|
|
|
// the second adds an offset. That allows to reduce number of required
|
|
|
|
// GOT entries because only one global offset table entry is necessary
|
|
|
|
// for every 64 KBytes of local data. So for local symbols we need to
|
|
|
|
// allocate number of GOT entries to hold all required "page" addresses.
|
|
|
|
//
|
|
|
|
// All global symbols (hidden and regular) considered by compiler uniformly.
|
|
|
|
// It always generates a single `lw` instruction and R_MIPS_GOT16 relocation
|
|
|
|
// to load address of the symbol. So for each such symbol we need to
|
|
|
|
// allocate dedicated GOT entry to store its address.
|
|
|
|
//
|
|
|
|
// If a symbol is preemptible we need help of dynamic linker to get its
|
|
|
|
// final address. The corresponding GOT entries are allocated in the
|
|
|
|
// "global" part of GOT. Entries for non preemptible global symbol allocated
|
|
|
|
// in the "local" part of GOT.
|
|
|
|
//
|
|
|
|
// See "Global Offset Table" in Chapter 5:
|
|
|
|
// ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
|
|
|
|
if (Expr == R_MIPS_GOT_LOCAL_PAGE) {
|
|
|
|
// At this point we do not know final symbol value so to reduce number
|
|
|
|
// of allocated GOT entries do the following trick. Save all output
|
|
|
|
// sections referenced by GOT relocations. Then later in the `finalize`
|
|
|
|
// method calculate number of "pages" required to cover all saved output
|
|
|
|
// section and allocate appropriate number of GOT entries.
|
|
|
|
auto *OutSec = cast<DefinedRegular<ELFT>>(&Sym)->Section->OutSec;
|
|
|
|
MipsOutSections.insert(OutSec);
|
|
|
|
return;
|
|
|
|
}
|
2016-06-23 23:26:31 +08:00
|
|
|
if (Sym.isTls()) {
|
|
|
|
// GOT entries created for MIPS TLS relocations behave like
|
|
|
|
// almost GOT entries from other ABIs. They go to the end
|
|
|
|
// of the global offset table.
|
|
|
|
Sym.GotIndex = Entries.size();
|
|
|
|
Entries.push_back(&Sym);
|
|
|
|
return;
|
|
|
|
}
|
2016-06-20 05:39:37 +08:00
|
|
|
auto AddEntry = [&](SymbolBody &S, uintX_t A, MipsGotEntries &Items) {
|
|
|
|
if (S.isInGot() && !A)
|
|
|
|
return;
|
|
|
|
size_t NewIndex = Items.size();
|
|
|
|
if (!MipsGotMap.insert({{&S, A}, NewIndex}).second)
|
|
|
|
return;
|
|
|
|
Items.emplace_back(&S, A);
|
|
|
|
if (!A)
|
|
|
|
S.GotIndex = NewIndex;
|
|
|
|
};
|
|
|
|
if (Sym.isPreemptible()) {
|
|
|
|
// Ignore addends for preemptible symbols. They got single GOT entry anyway.
|
|
|
|
AddEntry(Sym, 0, MipsGlobal);
|
|
|
|
Sym.IsInGlobalMipsGot = true;
|
|
|
|
} else
|
|
|
|
AddEntry(Sym, Addend, MipsLocal);
|
|
|
|
}
|
|
|
|
|
2016-03-11 20:06:30 +08:00
|
|
|
template <class ELFT> bool GotSection<ELFT>::addDynTlsEntry(SymbolBody &Sym) {
|
2016-06-06 03:03:28 +08:00
|
|
|
if (Sym.GlobalDynIndex != -1U)
|
2015-12-02 03:20:26 +08:00
|
|
|
return false;
|
2016-06-06 03:03:28 +08:00
|
|
|
Sym.GlobalDynIndex = 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(nullptr);
|
2016-06-09 05:31:59 +08:00
|
|
|
Entries.push_back(&Sym);
|
2015-12-02 03:20:26 +08:00
|
|
|
return true;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2016-02-05 08:10:02 +08:00
|
|
|
// Reserves TLS entries for a TLS module ID and a TLS block offset.
|
|
|
|
// In total it takes two GOT slots.
|
|
|
|
template <class ELFT> bool GotSection<ELFT>::addTlsIndex() {
|
|
|
|
if (TlsIndexOff != uint32_t(-1))
|
2015-12-02 02:24:07 +08:00
|
|
|
return false;
|
2016-02-05 08:10:02 +08:00
|
|
|
TlsIndexOff = Entries.size() * sizeof(uintX_t);
|
2015-11-11 09:00:24 +08:00
|
|
|
Entries.push_back(nullptr);
|
|
|
|
Entries.push_back(nullptr);
|
2015-12-02 02:24:07 +08:00
|
|
|
return true;
|
2015-11-11 09:00:24 +08:00
|
|
|
}
|
|
|
|
|
2016-01-21 13:33:23 +08:00
|
|
|
template <class ELFT>
|
|
|
|
typename GotSection<ELFT>::uintX_t
|
2016-04-20 06:46:03 +08:00
|
|
|
GotSection<ELFT>::getMipsLocalPageOffset(uintX_t EntryValue) {
|
2016-01-21 13:33:23 +08:00
|
|
|
// Initialize the entry by the %hi(EntryValue) expression
|
|
|
|
// but without right-shifting.
|
2016-06-20 05:39:37 +08:00
|
|
|
EntryValue = (EntryValue + 0x8000) & ~0xffff;
|
2016-04-26 04:25:05 +08:00
|
|
|
// Take into account MIPS GOT header.
|
|
|
|
// See comment in the GotSection::writeTo.
|
|
|
|
size_t NewIndex = MipsLocalGotPos.size() + 2;
|
2016-01-21 13:33:23 +08:00
|
|
|
auto P = MipsLocalGotPos.insert(std::make_pair(EntryValue, NewIndex));
|
2016-06-20 05:39:37 +08:00
|
|
|
assert(!P.second || MipsLocalGotPos.size() <= MipsPageEntries);
|
2016-05-11 17:41:15 +08:00
|
|
|
return (uintX_t)P.first->second * sizeof(uintX_t) - MipsGPOffset;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2016-06-20 05:39:37 +08:00
|
|
|
template <class ELFT>
|
|
|
|
typename GotSection<ELFT>::uintX_t
|
|
|
|
GotSection<ELFT>::getMipsGotOffset(const SymbolBody &B, uintX_t Addend) const {
|
|
|
|
uintX_t Off = MipsPageEntries;
|
2016-06-23 23:26:31 +08:00
|
|
|
if (B.isTls())
|
|
|
|
Off += MipsLocal.size() + MipsGlobal.size() + B.GotIndex;
|
|
|
|
else if (B.IsInGlobalMipsGot)
|
2016-06-20 05:39:37 +08:00
|
|
|
Off += MipsLocal.size() + B.GotIndex;
|
|
|
|
else if (B.isInGot())
|
|
|
|
Off += B.GotIndex;
|
|
|
|
else {
|
|
|
|
auto It = MipsGotMap.find({&B, Addend});
|
|
|
|
assert(It != MipsGotMap.end());
|
|
|
|
Off += It->second;
|
|
|
|
}
|
|
|
|
return Off * sizeof(uintX_t) - MipsGPOffset;
|
|
|
|
}
|
|
|
|
|
2016-06-23 23:26:31 +08:00
|
|
|
template <class ELFT>
|
|
|
|
typename GotSection<ELFT>::uintX_t GotSection<ELFT>::getMipsTlsOffset() {
|
|
|
|
return (MipsPageEntries + MipsLocal.size() + MipsGlobal.size()) *
|
|
|
|
sizeof(uintX_t);
|
|
|
|
}
|
|
|
|
|
2015-12-02 03:20:26 +08:00
|
|
|
template <class ELFT>
|
|
|
|
typename GotSection<ELFT>::uintX_t
|
|
|
|
GotSection<ELFT>::getGlobalDynAddr(const SymbolBody &B) const {
|
2016-06-06 03:03:28 +08:00
|
|
|
return this->getVA() + B.GlobalDynIndex * sizeof(uintX_t);
|
2015-12-02 03:20:26 +08:00
|
|
|
}
|
|
|
|
|
2016-04-07 23:20:56 +08:00
|
|
|
template <class ELFT>
|
|
|
|
typename GotSection<ELFT>::uintX_t
|
|
|
|
GotSection<ELFT>::getGlobalDynOffset(const SymbolBody &B) const {
|
2016-06-06 03:03:28 +08:00
|
|
|
return B.GlobalDynIndex * sizeof(uintX_t);
|
2016-04-07 23:20:56 +08:00
|
|
|
}
|
|
|
|
|
2015-11-12 12:39:49 +08:00
|
|
|
template <class ELFT>
|
|
|
|
const SymbolBody *GotSection<ELFT>::getMipsFirstGlobalEntry() const {
|
2016-06-20 05:39:37 +08:00
|
|
|
return MipsGlobal.empty() ? nullptr : MipsGlobal.front().first;
|
2015-11-12 12:39:49 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
unsigned GotSection<ELFT>::getMipsLocalEntriesNum() const {
|
2016-06-20 05:39:37 +08:00
|
|
|
return MipsPageEntries + MipsLocal.size();
|
2015-11-12 12:39:49 +08:00
|
|
|
}
|
|
|
|
|
2015-11-06 15:43:03 +08:00
|
|
|
template <class ELFT> void GotSection<ELFT>::finalize() {
|
2016-06-10 20:26:28 +08:00
|
|
|
size_t EntriesNum = Entries.size();
|
|
|
|
if (Config->EMachine == EM_MIPS) {
|
2016-04-26 04:25:05 +08:00
|
|
|
// Take into account MIPS GOT header.
|
|
|
|
// See comment in the GotSection::writeTo.
|
2016-06-20 05:39:37 +08:00
|
|
|
MipsPageEntries += 2;
|
2016-06-10 20:26:28 +08:00
|
|
|
for (const OutputSectionBase<ELFT> *OutSec : MipsOutSections) {
|
|
|
|
// Calculate an upper bound of MIPS GOT entries required to store page
|
|
|
|
// addresses of local symbols. We assume the worst case - each 64kb
|
|
|
|
// page of the output section has at least one GOT relocation against it.
|
|
|
|
// Add 0x8000 to the section's size because the page address stored
|
|
|
|
// in the GOT entry is calculated as (value + 0x8000) & ~0xffff.
|
2016-06-20 05:39:37 +08:00
|
|
|
MipsPageEntries += (OutSec->getSize() + 0x8000 + 0xfffe) / 0xffff;
|
2016-06-10 20:26:28 +08:00
|
|
|
}
|
2016-06-20 05:39:37 +08:00
|
|
|
EntriesNum += MipsPageEntries + MipsLocal.size() + MipsGlobal.size();
|
2016-03-29 22:07:22 +08:00
|
|
|
}
|
2016-06-10 20:26:28 +08:00
|
|
|
this->Header.sh_size = EntriesNum * sizeof(uintX_t);
|
2015-11-06 15:43:03 +08:00
|
|
|
}
|
|
|
|
|
2016-09-09 05:46:21 +08:00
|
|
|
template <class ELFT>
|
|
|
|
static void writeUint(uint8_t *Buf, typename ELFT::uint Val) {
|
|
|
|
typedef typename ELFT::uint uintX_t;
|
|
|
|
write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Buf, Val);
|
|
|
|
}
|
|
|
|
|
2016-09-08 17:07:19 +08:00
|
|
|
template <class ELFT> void GotSection<ELFT>::writeMipsGot(uint8_t *Buf) {
|
2016-06-20 05:39:37 +08:00
|
|
|
// Set the MSB of the second GOT slot. This is not required by any
|
|
|
|
// MIPS ABI documentation, though.
|
|
|
|
//
|
|
|
|
// There is a comment in glibc saying that "The MSB of got[1] of a
|
|
|
|
// gnu object is set to identify gnu objects," and in GNU gold it
|
|
|
|
// says "the second entry will be used by some runtime loaders".
|
|
|
|
// But how this field is being used is unclear.
|
|
|
|
//
|
|
|
|
// We are not really willing to mimic other linkers behaviors
|
|
|
|
// without understanding why they do that, but because all files
|
|
|
|
// generated by GNU tools have this special GOT value, and because
|
|
|
|
// we've been doing this for years, it is probably a safe bet to
|
|
|
|
// keep doing this for now. We really need to revisit this to see
|
|
|
|
// if we had to do this.
|
|
|
|
auto *P = reinterpret_cast<typename ELFT::Off *>(Buf);
|
|
|
|
P[1] = uintX_t(1) << (ELFT::Is64Bits ? 63 : 31);
|
|
|
|
// Write 'page address' entries to the local part of the GOT.
|
|
|
|
for (std::pair<uintX_t, size_t> &L : MipsLocalGotPos) {
|
|
|
|
uint8_t *Entry = Buf + L.second * sizeof(uintX_t);
|
2016-09-09 05:46:21 +08:00
|
|
|
writeUint<ELFT>(Entry, L.first);
|
2016-04-26 04:25:05 +08:00
|
|
|
}
|
2016-06-20 05:39:37 +08:00
|
|
|
Buf += MipsPageEntries * sizeof(uintX_t);
|
|
|
|
auto AddEntry = [&](const MipsGotEntry &SA) {
|
|
|
|
uint8_t *Entry = Buf;
|
|
|
|
Buf += sizeof(uintX_t);
|
2016-06-20 18:01:50 +08:00
|
|
|
const SymbolBody* Body = SA.first;
|
|
|
|
uintX_t VA = Body->template getVA<ELFT>(SA.second);
|
2016-09-09 05:46:21 +08:00
|
|
|
writeUint<ELFT>(Entry, VA);
|
2016-06-20 05:39:37 +08:00
|
|
|
};
|
|
|
|
std::for_each(std::begin(MipsLocal), std::end(MipsLocal), AddEntry);
|
|
|
|
std::for_each(std::begin(MipsGlobal), std::end(MipsGlobal), AddEntry);
|
2016-09-08 17:07:19 +08:00
|
|
|
// Initialize TLS-related GOT entries. If the entry has a corresponding
|
|
|
|
// dynamic relocations, leave it initialized by zero. Write down adjusted
|
|
|
|
// TLS symbol's values otherwise. To calculate the adjustments use offsets
|
|
|
|
// for thread-local storage.
|
|
|
|
// https://www.linux-mips.org/wiki/NPTL
|
|
|
|
if (TlsIndexOff != -1U && !Config->Pic)
|
2016-09-09 05:46:21 +08:00
|
|
|
writeUint<ELFT>(Buf + TlsIndexOff, 1);
|
2016-09-08 17:07:19 +08:00
|
|
|
for (const SymbolBody *B : Entries) {
|
|
|
|
if (!B || B->isPreemptible())
|
|
|
|
continue;
|
|
|
|
uintX_t VA = B->getVA<ELFT>();
|
|
|
|
if (B->GotIndex != -1U) {
|
|
|
|
uint8_t *Entry = Buf + B->GotIndex * sizeof(uintX_t);
|
2016-09-09 05:46:21 +08:00
|
|
|
writeUint<ELFT>(Entry, VA - 0x7000);
|
2016-09-08 17:07:19 +08:00
|
|
|
}
|
|
|
|
if (B->GlobalDynIndex != -1U) {
|
|
|
|
uint8_t *Entry = Buf + B->GlobalDynIndex * sizeof(uintX_t);
|
2016-09-09 05:46:21 +08:00
|
|
|
writeUint<ELFT>(Entry, 1);
|
2016-09-08 17:07:19 +08:00
|
|
|
Entry += sizeof(uintX_t);
|
2016-09-09 05:46:21 +08:00
|
|
|
writeUint<ELFT>(Entry, VA - 0x8000);
|
2016-09-08 17:07:19 +08:00
|
|
|
}
|
|
|
|
}
|
2016-06-20 05:39:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
|
2016-09-08 17:07:19 +08:00
|
|
|
if (Config->EMachine == EM_MIPS) {
|
2016-06-20 05:39:37 +08:00
|
|
|
writeMipsGot(Buf);
|
2016-09-08 17:07:19 +08:00
|
|
|
return;
|
|
|
|
}
|
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;
|
2016-06-20 05:39:37 +08:00
|
|
|
if (B->isPreemptible())
|
2015-10-07 07:56:53 +08:00
|
|
|
continue; // The dynamic linker will take care of it.
|
2016-02-02 05:00:35 +08:00
|
|
|
uintX_t VA = B->getVA<ELFT>();
|
2016-09-09 05:46:21 +08:00
|
|
|
writeUint<ELFT>(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) {
|
2016-05-19 05:03:36 +08:00
|
|
|
// At beginning of PLT, we have code to call the dynamic linker
|
|
|
|
// to resolve dynsyms at runtime. Write such code.
|
2016-06-17 00:28:50 +08:00
|
|
|
Target->writePltHeader(Buf);
|
|
|
|
size_t Off = Target->PltHeaderSize;
|
2016-05-21 05:39:07 +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-05-19 05:03:36 +08:00
|
|
|
uint64_t Got = B->getGotPltVA<ELFT>();
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-11 20:06:30 +08:00
|
|
|
template <class ELFT> void PltSection<ELFT>::addEntry(SymbolBody &Sym) {
|
|
|
|
Sym.PltIndex = Entries.size();
|
2016-05-19 05:03:36 +08:00
|
|
|
unsigned RelOff = Out<ELFT>::RelaPlt->getRelocOffset();
|
2016-03-11 20:06:30 +08:00
|
|
|
Entries.push_back(std::make_pair(&Sym, RelOff));
|
2015-09-22 05:38:08 +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-06-17 00:28:50 +08:00
|
|
|
Target->PltHeaderSize + Entries.size() * Target->PltEntrySize;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
2016-05-10 23:47:57 +08:00
|
|
|
RelocationSection<ELFT>::RelocationSection(StringRef Name, bool Sort)
|
2016-03-14 04:10:20 +08:00
|
|
|
: OutputSectionBase<ELFT>(Name, Config->Rela ? SHT_RELA : SHT_REL,
|
2016-05-10 23:47:57 +08:00
|
|
|
SHF_ALLOC),
|
|
|
|
Sort(Sort) {
|
2016-03-14 04:10:20 +08:00
|
|
|
this->Header.sh_entsize = Config->Rela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
|
2016-01-30 06:18:57 +08:00
|
|
|
this->Header.sh_addralign = sizeof(uintX_t);
|
2015-09-26 01:19:10 +08:00
|
|
|
}
|
|
|
|
|
2016-02-05 23:03:10 +08:00
|
|
|
template <class ELFT>
|
|
|
|
void RelocationSection<ELFT>::addReloc(const DynamicReloc<ELFT> &Reloc) {
|
2016-08-31 16:51:39 +08:00
|
|
|
if (Reloc.Type == Target->RelativeRel)
|
|
|
|
++NumRelativeRelocs;
|
2016-02-05 23:03:10 +08:00
|
|
|
Relocs.push_back(Reloc);
|
|
|
|
}
|
|
|
|
|
2016-05-10 23:47:57 +08:00
|
|
|
template <class ELFT, class RelTy>
|
|
|
|
static bool compRelocations(const RelTy &A, const RelTy &B) {
|
2016-08-31 16:51:39 +08:00
|
|
|
bool AIsRel = A.getType(Config->Mips64EL) == Target->RelativeRel;
|
|
|
|
bool BIsRel = B.getType(Config->Mips64EL) == Target->RelativeRel;
|
|
|
|
if (AIsRel != BIsRel)
|
|
|
|
return AIsRel;
|
|
|
|
|
2016-05-10 23:47:57 +08:00
|
|
|
return A.getSymbol(Config->Mips64EL) < B.getSymbol(Config->Mips64EL);
|
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
|
2016-05-10 23:47:57 +08:00
|
|
|
uint8_t *BufBegin = Buf;
|
2015-09-22 05:38:08 +08:00
|
|
|
for (const DynamicReloc<ELFT> &Rel : Relocs) {
|
2016-03-13 13:23:40 +08:00
|
|
|
auto *P = reinterpret_cast<Elf_Rela *>(Buf);
|
2016-03-14 04:10:20 +08:00
|
|
|
Buf += Config->Rela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
|
2016-01-26 08:24:57 +08:00
|
|
|
|
2016-03-14 04:10:20 +08:00
|
|
|
if (Config->Rela)
|
2016-06-23 12:33:42 +08:00
|
|
|
P->r_addend = Rel.getAddend();
|
|
|
|
P->r_offset = Rel.getOffset();
|
2016-06-23 23:26:31 +08:00
|
|
|
if (Config->EMachine == EM_MIPS && Rel.getOutputSec() == Out<ELFT>::Got)
|
|
|
|
// Dynamic relocation against MIPS GOT section make deal TLS entries
|
|
|
|
// allocated in the end of the GOT. We need to adjust the offset to take
|
|
|
|
// in account 'local' and 'global' GOT entries.
|
|
|
|
P->r_offset += Out<ELFT>::Got->getMipsTlsOffset();
|
2016-06-23 12:33:42 +08:00
|
|
|
P->setSymbolAndType(Rel.getSymIndex(), Rel.Type, Config->Mips64EL);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
2016-05-10 23:47:57 +08:00
|
|
|
|
|
|
|
if (Sort) {
|
|
|
|
if (Config->Rela)
|
|
|
|
std::stable_sort((Elf_Rela *)BufBegin,
|
|
|
|
(Elf_Rela *)BufBegin + Relocs.size(),
|
|
|
|
compRelocations<ELFT, Elf_Rela>);
|
|
|
|
else
|
|
|
|
std::stable_sort((Elf_Rel *)BufBegin, (Elf_Rel *)BufBegin + Relocs.size(),
|
|
|
|
compRelocations<ELFT, Elf_Rel>);
|
|
|
|
}
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-11-26 06:15:01 +08:00
|
|
|
template <class ELFT> unsigned RelocationSection<ELFT>::getRelocOffset() {
|
2016-02-06 03:13:18 +08:00
|
|
|
return this->Header.sh_entsize * Relocs.size();
|
2015-11-26 06:15:01 +08:00
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT> void RelocationSection<ELFT>::finalize() {
|
2016-08-09 12:42:01 +08:00
|
|
|
this->Header.sh_link = Out<ELFT>::DynSymTab
|
2016-08-09 12:31:21 +08:00
|
|
|
? Out<ELFT>::DynSymTab->SectionIndex
|
|
|
|
: Out<ELFT>::SymTab->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;
|
|
|
|
}
|
|
|
|
|
2015-10-16 06:27:29 +08:00
|
|
|
template <class ELFT> void InterpSection<ELFT>::writeTo(uint8_t *Buf) {
|
2016-03-13 14:50:34 +08:00
|
|
|
StringRef S = Config->DynamicLinker;
|
|
|
|
memcpy(Buf, S.data(), S.size());
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
2015-10-08 03:18:16 +08:00
|
|
|
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
|
|
|
|
2016-02-18 23:17:01 +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;
|
2016-01-30 06:18:57 +08:00
|
|
|
this->Header.sh_addralign = sizeof(uintX_t);
|
2015-10-22 16:21:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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() {
|
2016-02-17 13:40:01 +08:00
|
|
|
unsigned NumHashed = Symbols.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);
|
2016-02-17 13:40:01 +08:00
|
|
|
if (Symbols.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;
|
2016-02-17 13:40:01 +08:00
|
|
|
*P++ = Out<ELFT>::DynSymTab->getNumSymbols() - Symbols.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);
|
2016-02-17 13:40:03 +08:00
|
|
|
for (const SymbolData &Sym : Symbols) {
|
|
|
|
size_t Pos = (Sym.Hash / C) & (MaskWords - 1);
|
|
|
|
uintX_t V = (uintX_t(1) << (Sym.Hash % C)) |
|
|
|
|
(uintX_t(1) << ((Sym.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;
|
2016-02-17 13:40:03 +08:00
|
|
|
for (const SymbolData &Sym : Symbols) {
|
|
|
|
int Bucket = Sym.Hash % NBuckets;
|
2015-10-22 16:21:35 +08:00
|
|
|
assert(PrevBucket <= Bucket);
|
|
|
|
if (Bucket != PrevBucket) {
|
2016-02-17 13:40:03 +08:00
|
|
|
Buckets[Bucket] = Sym.Body->DynsymIndex;
|
2015-10-22 16:21:35 +08:00
|
|
|
PrevBucket = Bucket;
|
|
|
|
if (I > 0)
|
|
|
|
Values[I - 1] |= 1;
|
|
|
|
}
|
2016-02-17 13:40:03 +08:00
|
|
|
Values[I] = Sym.Hash & ~1;
|
2015-10-22 16:21:35 +08:00
|
|
|
++I;
|
|
|
|
}
|
|
|
|
if (I > 0)
|
|
|
|
Values[I - 1] |= 1;
|
|
|
|
}
|
|
|
|
|
2016-02-17 13:40:01 +08:00
|
|
|
// Add symbols to this symbol hash table. Note that this function
|
|
|
|
// destructively sort a given vector -- which is needed because
|
|
|
|
// GNU-style hash table places some sorting requirements.
|
2015-10-28 15:05:56 +08:00
|
|
|
template <class ELFT>
|
2016-01-29 09:24:25 +08:00
|
|
|
void GnuHashTableSection<ELFT>::addSymbols(
|
2016-02-17 13:40:01 +08:00
|
|
|
std::vector<std::pair<SymbolBody *, size_t>> &V) {
|
2016-07-05 03:49:55 +08:00
|
|
|
// Ideally this will just be 'auto' but GCC 6.1 is not able
|
|
|
|
// to deduce it correctly.
|
|
|
|
std::vector<std::pair<SymbolBody *, size_t>>::iterator Mid =
|
|
|
|
std::stable_partition(V.begin(), V.end(),
|
|
|
|
[](std::pair<SymbolBody *, size_t> &P) {
|
|
|
|
return P.first->isUndefined();
|
|
|
|
});
|
2016-02-17 13:40:01 +08:00
|
|
|
if (Mid == V.end())
|
2015-10-28 15:05:56 +08:00
|
|
|
return;
|
2016-07-07 01:41:55 +08:00
|
|
|
for (auto I = Mid, E = V.end(); I != E; ++I) {
|
2016-02-17 13:40:01 +08:00
|
|
|
SymbolBody *B = I->first;
|
|
|
|
size_t StrOff = I->second;
|
|
|
|
Symbols.push_back({B, StrOff, hashGnu(B->getName())});
|
|
|
|
}
|
2015-10-28 15:05:56 +08:00
|
|
|
|
2016-02-17 13:40:01 +08:00
|
|
|
unsigned NBuckets = calcNBuckets(Symbols.size());
|
|
|
|
std::stable_sort(Symbols.begin(), Symbols.end(),
|
2016-02-17 13:40:03 +08:00
|
|
|
[&](const SymbolData &L, const SymbolData &R) {
|
2015-10-28 15:05:56 +08:00
|
|
|
return L.Hash % NBuckets < R.Hash % NBuckets;
|
|
|
|
});
|
|
|
|
|
2016-02-17 13:40:01 +08:00
|
|
|
V.erase(Mid, V.end());
|
2016-02-17 13:40:03 +08:00
|
|
|
for (const SymbolData &Sym : Symbols)
|
|
|
|
V.push_back({Sym.Body, Sym.STName});
|
2015-10-28 15:05:56 +08:00
|
|
|
}
|
|
|
|
|
2016-06-20 19:55:12 +08:00
|
|
|
// Returns the number of version definition entries. Because the first entry
|
|
|
|
// is for the version definition itself, it is the number of versioned symbols
|
|
|
|
// plus one. Note that we don't support multiple versions yet.
|
2016-07-16 12:09:27 +08:00
|
|
|
static unsigned getVerDefNum() { return Config->VersionDefinitions.size() + 1; }
|
2016-06-20 19:55:12 +08:00
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
2016-05-24 12:25:47 +08:00
|
|
|
DynamicSection<ELFT>::DynamicSection()
|
|
|
|
: OutputSectionBase<ELFT>(".dynamic", SHT_DYNAMIC, SHF_ALLOC | SHF_WRITE) {
|
2015-10-16 06:27:29 +08:00
|
|
|
Elf_Shdr &Header = this->Header;
|
2016-01-30 06:18:57 +08:00
|
|
|
Header.sh_addralign = sizeof(uintX_t);
|
2015-09-26 01:19:10 +08:00
|
|
|
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.
|
2016-09-02 17:13:05 +08:00
|
|
|
for (StringRef S : Config->AuxiliaryList)
|
|
|
|
Add({DT_AUXILIARY, Out<ELFT>::DynStrTab->addString(S)});
|
2016-01-26 05:32:04 +08:00
|
|
|
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-05-24 12:25:47 +08:00
|
|
|
for (const std::unique_ptr<SharedFile<ELFT>> &F :
|
|
|
|
Symtab<ELFT>::X->getSharedFiles())
|
2016-01-26 05:32:04 +08:00
|
|
|
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();
|
|
|
|
|
2015-10-08 03:18:16 +08:00
|
|
|
if (Out<ELFT>::RelaDyn->hasRelocs()) {
|
2016-03-14 04:10:20 +08:00
|
|
|
bool IsRela = Config->Rela;
|
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))});
|
2016-08-31 16:51:39 +08:00
|
|
|
|
2016-09-05 01:40:12 +08:00
|
|
|
// MIPS dynamic loader does not support RELCOUNT tag.
|
|
|
|
// The problem is in the tight relation between dynamic
|
|
|
|
// relocations and GOT. So do not emit this tag on MIPS.
|
|
|
|
if (Config->EMachine != EM_MIPS) {
|
|
|
|
size_t NumRelativeRels = Out<ELFT>::RelaDyn->getRelativeRelocCount();
|
|
|
|
if (Config->ZCombreloc && NumRelativeRels)
|
|
|
|
Add({IsRela ? DT_RELACOUNT : DT_RELCOUNT, NumRelativeRels});
|
|
|
|
}
|
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-03-14 04:10:20 +08:00
|
|
|
Add({DT_PLTREL, uint64_t(Config->Rela ? 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-08-09 12:25:20 +08:00
|
|
|
if (Out<ELFT>::PreinitArray) {
|
|
|
|
Add({DT_PREINIT_ARRAY, Out<ELFT>::PreinitArray});
|
2016-08-19 23:23:39 +08:00
|
|
|
Add({DT_PREINIT_ARRAYSZ, Out<ELFT>::PreinitArray, Entry::SecSize});
|
2016-01-26 05:32:04 +08:00
|
|
|
}
|
2016-08-09 12:25:20 +08:00
|
|
|
if (Out<ELFT>::InitArray) {
|
|
|
|
Add({DT_INIT_ARRAY, Out<ELFT>::InitArray});
|
2016-08-19 23:23:39 +08:00
|
|
|
Add({DT_INIT_ARRAYSZ, Out<ELFT>::InitArray, Entry::SecSize});
|
2016-01-26 05:32:04 +08:00
|
|
|
}
|
2016-08-09 12:25:20 +08:00
|
|
|
if (Out<ELFT>::FiniArray) {
|
|
|
|
Add({DT_FINI_ARRAY, Out<ELFT>::FiniArray});
|
2016-08-19 23:23:39 +08:00
|
|
|
Add({DT_FINI_ARRAYSZ, Out<ELFT>::FiniArray, Entry::SecSize});
|
2015-10-10 04:32:54 +08:00
|
|
|
}
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2016-05-24 12:25:47 +08:00
|
|
|
if (SymbolBody *B = Symtab<ELFT>::X->find(Config->Init))
|
2016-01-26 07:38:34 +08:00
|
|
|
Add({DT_INIT, B});
|
2016-05-24 12:25:47 +08:00
|
|
|
if (SymbolBody *B = Symtab<ELFT>::X->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
|
|
|
|
2016-06-20 19:55:12 +08:00
|
|
|
bool HasVerNeed = Out<ELFT>::VerNeed->getNeedNum() != 0;
|
|
|
|
if (HasVerNeed || Out<ELFT>::VerDef)
|
2016-04-28 04:22:31 +08:00
|
|
|
Add({DT_VERSYM, Out<ELFT>::VerSym});
|
2016-06-20 19:55:12 +08:00
|
|
|
if (Out<ELFT>::VerDef) {
|
|
|
|
Add({DT_VERDEF, Out<ELFT>::VerDef});
|
|
|
|
Add({DT_VERDEFNUM, getVerDefNum()});
|
|
|
|
}
|
|
|
|
if (HasVerNeed) {
|
2016-04-28 04:22:31 +08:00
|
|
|
Add({DT_VERNEED, Out<ELFT>::VerNeed});
|
2016-06-20 19:55:12 +08:00
|
|
|
Add({DT_VERNEEDNUM, Out<ELFT>::VerNeed->getNeedNum()});
|
2016-04-28 04:22:31 +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});
|
2016-07-15 01:40:18 +08:00
|
|
|
Add({DT_MIPS_BASE_ADDRESS, Config->ImageBase});
|
2016-01-26 07:38:34 +08:00
|
|
|
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;
|
2016-08-19 23:23:39 +08:00
|
|
|
case Entry::SecSize:
|
|
|
|
P->d_un.d_val = E.OutSec->getSize();
|
|
|
|
break;
|
2016-01-26 05:32:04 +08:00
|
|
|
case Entry::SymAddr:
|
2016-02-02 05:00:35 +08:00
|
|
|
P->d_un.d_ptr = E.Sym->template getVA<ELFT>();
|
2016-01-26 05:32:04 +08:00
|
|
|
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()
|
2016-05-24 00:30:41 +08:00
|
|
|
: OutputSectionBase<ELFT>(".eh_frame_hdr", SHT_PROGBITS, SHF_ALLOC) {}
|
2016-01-15 21:34:52 +08:00
|
|
|
|
2016-05-23 09:45:05 +08:00
|
|
|
// .eh_frame_hdr contains a binary search table of pointers to FDEs.
|
|
|
|
// Each entry of the search table consists of two values,
|
|
|
|
// the starting PC from where FDEs covers, and the FDE's address.
|
|
|
|
// It is sorted by PC.
|
2016-01-15 21:34:52 +08:00
|
|
|
template <class ELFT> void EhFrameHeader<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
const endianness E = ELFT::TargetEndianness;
|
|
|
|
|
2016-05-23 11:00:33 +08:00
|
|
|
// Sort the FDE list by their PC and uniqueify. Usually there is only
|
|
|
|
// one FDE for a PC (i.e. function), but if ICF merges two functions
|
|
|
|
// into one, there can be more than one FDEs pointing to the address.
|
|
|
|
auto Less = [](const FdeData &A, const FdeData &B) { return A.Pc < B.Pc; };
|
|
|
|
std::stable_sort(Fdes.begin(), Fdes.end(), Less);
|
|
|
|
auto Eq = [](const FdeData &A, const FdeData &B) { return A.Pc == B.Pc; };
|
|
|
|
Fdes.erase(std::unique(Fdes.begin(), Fdes.end(), Eq), Fdes.end());
|
2016-04-12 00:40:08 +08:00
|
|
|
|
2016-05-23 09:31:10 +08:00
|
|
|
Buf[0] = 1;
|
|
|
|
Buf[1] = DW_EH_PE_pcrel | DW_EH_PE_sdata4;
|
|
|
|
Buf[2] = DW_EH_PE_udata4;
|
|
|
|
Buf[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
|
2016-05-24 00:24:16 +08:00
|
|
|
write32<E>(Buf + 4, Out<ELFT>::EhFrame->getVA() - this->getVA() - 4);
|
2016-05-23 11:00:33 +08:00
|
|
|
write32<E>(Buf + 8, Fdes.size());
|
2016-01-15 21:34:52 +08:00
|
|
|
Buf += 12;
|
|
|
|
|
2016-05-23 11:00:33 +08:00
|
|
|
uintX_t VA = this->getVA();
|
|
|
|
for (FdeData &Fde : Fdes) {
|
|
|
|
write32<E>(Buf, Fde.Pc - VA);
|
|
|
|
write32<E>(Buf + 4, Fde.FdeVA - VA);
|
2016-01-15 21:34:52 +08:00
|
|
|
Buf += 8;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-24 00:30:41 +08:00
|
|
|
template <class ELFT> void EhFrameHeader<ELFT>::finalize() {
|
|
|
|
// .eh_frame_hdr has a 12 bytes header followed by an array of FDEs.
|
|
|
|
this->Header.sh_size = 12 + Out<ELFT>::EhFrame->NumFdes * 8;
|
|
|
|
}
|
|
|
|
|
2016-01-15 21:34:52 +08:00
|
|
|
template <class ELFT>
|
2016-05-23 11:00:33 +08:00
|
|
|
void EhFrameHeader<ELFT>::addFde(uint32_t Pc, uint32_t FdeVA) {
|
|
|
|
Fdes.push_back({Pc, FdeVA});
|
2016-01-15 21:34:52 +08:00
|
|
|
}
|
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
2016-02-25 16:23:37 +08:00
|
|
|
OutputSection<ELFT>::OutputSection(StringRef Name, uint32_t Type, uintX_t Flags)
|
|
|
|
: OutputSectionBase<ELFT>(Name, Type, Flags) {
|
|
|
|
if (Type == SHT_RELA)
|
|
|
|
this->Header.sh_entsize = sizeof(Elf_Rela);
|
|
|
|
else if (Type == SHT_REL)
|
|
|
|
this->Header.sh_entsize = sizeof(Elf_Rel);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void OutputSection<ELFT>::finalize() {
|
|
|
|
uint32_t Type = this->Header.sh_type;
|
|
|
|
if (Type != SHT_RELA && Type != SHT_REL)
|
|
|
|
return;
|
|
|
|
this->Header.sh_link = Out<ELFT>::SymTab->SectionIndex;
|
|
|
|
// sh_info for SHT_REL[A] sections should contain the section header index of
|
|
|
|
// the section to which the relocation applies.
|
|
|
|
InputSectionBase<ELFT> *S = Sections[0]->getRelocatedSection();
|
|
|
|
this->Header.sh_info = S->OutSec->SectionIndex;
|
|
|
|
}
|
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) {
|
2016-02-26 02:43:51 +08:00
|
|
|
assert(C->Live);
|
2015-12-26 13:51:07 +08:00
|
|
|
auto *S = cast<InputSection<ELFT>>(C);
|
|
|
|
Sections.push_back(S);
|
|
|
|
S->OutSec = this;
|
2016-06-17 09:18:46 +08:00
|
|
|
this->updateAlignment(S->Alignment);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2016-02-11 07:20:42 +08:00
|
|
|
// If an input string is in the form of "foo.N" where N is a number,
|
|
|
|
// return N. Otherwise, returns 65536, which is one greater than the
|
|
|
|
// lowest priority.
|
|
|
|
static int getPriority(StringRef S) {
|
|
|
|
size_t Pos = S.rfind('.');
|
|
|
|
if (Pos == StringRef::npos)
|
|
|
|
return 65536;
|
|
|
|
int V;
|
|
|
|
if (S.substr(Pos + 1).getAsInteger(10, V))
|
|
|
|
return 65536;
|
|
|
|
return V;
|
|
|
|
}
|
|
|
|
|
2016-06-23 12:33:42 +08:00
|
|
|
// This function is called after we sort input sections
|
|
|
|
// and scan relocations to setup sections' offsets.
|
|
|
|
template <class ELFT> void OutputSection<ELFT>::assignOffsets() {
|
|
|
|
uintX_t Off = this->Header.sh_size;
|
|
|
|
for (InputSection<ELFT> *S : Sections) {
|
|
|
|
Off = alignTo(Off, S->Alignment);
|
|
|
|
S->OutSecOff = Off;
|
|
|
|
Off += S->getSize();
|
|
|
|
}
|
|
|
|
this->Header.sh_size = Off;
|
2016-02-12 07:41:38 +08:00
|
|
|
}
|
|
|
|
|
2016-02-11 07:20:42 +08:00
|
|
|
// Sorts input sections by section name suffixes, so that .foo.N comes
|
|
|
|
// before .foo.M if N < M. Used to sort .{init,fini}_array.N sections.
|
2016-02-12 07:41:38 +08:00
|
|
|
// We want to keep the original order if the priorities are the same
|
|
|
|
// because the compiler keeps the original initialization order in a
|
|
|
|
// translation unit and we need to respect that.
|
2016-02-11 07:20:42 +08:00
|
|
|
// For more detail, read the section of the GCC's manual about init_priority.
|
2016-02-12 07:41:38 +08:00
|
|
|
template <class ELFT> void OutputSection<ELFT>::sortInitFini() {
|
2016-02-11 07:20:42 +08:00
|
|
|
// Sort sections by priority.
|
|
|
|
typedef std::pair<int, InputSection<ELFT> *> Pair;
|
2016-02-11 07:43:16 +08:00
|
|
|
auto Comp = [](const Pair &A, const Pair &B) { return A.first < B.first; };
|
|
|
|
|
2016-02-11 07:20:42 +08:00
|
|
|
std::vector<Pair> V;
|
|
|
|
for (InputSection<ELFT> *S : Sections)
|
2016-09-08 22:06:08 +08:00
|
|
|
V.push_back({getPriority(S->Name), S});
|
2016-02-11 07:43:16 +08:00
|
|
|
std::stable_sort(V.begin(), V.end(), Comp);
|
2016-02-11 07:20:42 +08:00
|
|
|
Sections.clear();
|
|
|
|
for (Pair &P : V)
|
|
|
|
Sections.push_back(P.second);
|
2016-02-12 07:41:38 +08:00
|
|
|
}
|
2016-02-11 07:20:42 +08:00
|
|
|
|
2016-02-12 07:41:38 +08:00
|
|
|
// Returns true if S matches /Filename.?\.o$/.
|
|
|
|
static bool isCrtBeginEnd(StringRef S, StringRef Filename) {
|
|
|
|
if (!S.endswith(".o"))
|
|
|
|
return false;
|
|
|
|
S = S.drop_back(2);
|
|
|
|
if (S.endswith(Filename))
|
|
|
|
return true;
|
|
|
|
return !S.empty() && S.drop_back().endswith(Filename);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool isCrtbegin(StringRef S) { return isCrtBeginEnd(S, "crtbegin"); }
|
|
|
|
static bool isCrtend(StringRef S) { return isCrtBeginEnd(S, "crtend"); }
|
|
|
|
|
|
|
|
// .ctors and .dtors are sorted by this priority from highest to lowest.
|
|
|
|
//
|
|
|
|
// 1. The section was contained in crtbegin (crtbegin contains
|
|
|
|
// some sentinel value in its .ctors and .dtors so that the runtime
|
|
|
|
// can find the beginning of the sections.)
|
|
|
|
//
|
|
|
|
// 2. The section has an optional priority value in the form of ".ctors.N"
|
|
|
|
// or ".dtors.N" where N is a number. Unlike .{init,fini}_array,
|
|
|
|
// they are compared as string rather than number.
|
|
|
|
//
|
|
|
|
// 3. The section is just ".ctors" or ".dtors".
|
|
|
|
//
|
|
|
|
// 4. The section was contained in crtend, which contains an end marker.
|
|
|
|
//
|
|
|
|
// In an ideal world, we don't need this function because .init_array and
|
|
|
|
// .ctors are duplicate features (and .init_array is newer.) However, there
|
|
|
|
// are too many real-world use cases of .ctors, so we had no choice to
|
|
|
|
// support that with this rather ad-hoc semantics.
|
|
|
|
template <class ELFT>
|
|
|
|
static bool compCtors(const InputSection<ELFT> *A,
|
|
|
|
const InputSection<ELFT> *B) {
|
|
|
|
bool BeginA = isCrtbegin(A->getFile()->getName());
|
|
|
|
bool BeginB = isCrtbegin(B->getFile()->getName());
|
|
|
|
if (BeginA != BeginB)
|
|
|
|
return BeginA;
|
|
|
|
bool EndA = isCrtend(A->getFile()->getName());
|
|
|
|
bool EndB = isCrtend(B->getFile()->getName());
|
|
|
|
if (EndA != EndB)
|
|
|
|
return EndB;
|
2016-09-08 22:06:08 +08:00
|
|
|
StringRef X = A->Name;
|
|
|
|
StringRef Y = B->Name;
|
2016-02-12 07:41:38 +08:00
|
|
|
assert(X.startswith(".ctors") || X.startswith(".dtors"));
|
|
|
|
assert(Y.startswith(".ctors") || Y.startswith(".dtors"));
|
|
|
|
X = X.substr(6);
|
|
|
|
Y = Y.substr(6);
|
2016-02-12 08:38:46 +08:00
|
|
|
if (X.empty() && Y.empty())
|
|
|
|
return false;
|
2016-02-12 07:41:38 +08:00
|
|
|
return X < Y;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sorts input sections by the special rules for .ctors and .dtors.
|
|
|
|
// Unfortunately, the rules are different from the one for .{init,fini}_array.
|
|
|
|
// Read the comment above.
|
|
|
|
template <class ELFT> void OutputSection<ELFT>::sortCtorsDtors() {
|
|
|
|
std::stable_sort(Sections.begin(), Sections.end(), compCtors<ELFT>);
|
2016-02-11 07:20:42 +08:00
|
|
|
}
|
|
|
|
|
2016-02-26 22:48:31 +08:00
|
|
|
static void fill(uint8_t *Buf, size_t Size, ArrayRef<uint8_t> A) {
|
|
|
|
size_t I = 0;
|
|
|
|
for (; I + A.size() < Size; I += A.size())
|
|
|
|
memcpy(Buf + I, A.data(), A.size());
|
|
|
|
memcpy(Buf + I, A.data(), Size - I);
|
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
|
2016-04-21 04:13:41 +08:00
|
|
|
ArrayRef<uint8_t> Filler = Script<ELFT>::X->getFiller(this->Name);
|
2016-02-26 22:48:31 +08:00
|
|
|
if (!Filler.empty())
|
|
|
|
fill(Buf, this->getSize(), Filler);
|
2016-03-11 12:23:12 +08:00
|
|
|
if (Config->Threads) {
|
|
|
|
parallel_for_each(Sections.begin(), Sections.end(),
|
|
|
|
[=](InputSection<ELFT> *C) { C->writeTo(Buf); });
|
|
|
|
} else {
|
|
|
|
for (InputSection<ELFT> *C : Sections)
|
|
|
|
C->writeTo(Buf);
|
|
|
|
}
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
|
2015-11-12 03:54:14 +08:00
|
|
|
template <class ELFT>
|
2016-05-23 23:12:41 +08:00
|
|
|
EhOutputSection<ELFT>::EhOutputSection()
|
2016-05-24 00:24:16 +08:00
|
|
|
: OutputSectionBase<ELFT>(".eh_frame", SHT_PROGBITS, SHF_ALLOC) {}
|
2015-11-12 03:54:14 +08:00
|
|
|
|
2016-05-23 07:16:14 +08:00
|
|
|
// Search for an existing CIE record or create a new one.
|
|
|
|
// CIE records from input object files are uniquified by their contents
|
|
|
|
// and where their relocations point to.
|
2015-11-12 03:54:14 +08:00
|
|
|
template <class ELFT>
|
2016-03-13 13:06:50 +08:00
|
|
|
template <class RelTy>
|
2016-07-22 04:18:30 +08:00
|
|
|
CieRecord *EhOutputSection<ELFT>::addCie(EhSectionPiece &Piece,
|
2016-05-24 12:19:20 +08:00
|
|
|
EhInputSection<ELFT> *Sec,
|
2016-07-22 04:18:30 +08:00
|
|
|
ArrayRef<RelTy> Rels) {
|
2015-11-12 03:54:14 +08:00
|
|
|
const endianness E = ELFT::TargetEndianness;
|
2016-05-26 00:37:01 +08:00
|
|
|
if (read32<E>(Piece.data().data() + 4) != 0)
|
2016-09-08 22:06:08 +08:00
|
|
|
fatal("CIE expected at beginning of .eh_frame: " + Sec->Name);
|
2016-05-23 07:16:14 +08:00
|
|
|
|
|
|
|
SymbolBody *Personality = nullptr;
|
2016-07-22 04:18:30 +08:00
|
|
|
unsigned FirstRelI = Piece.FirstRelocation;
|
|
|
|
if (FirstRelI != (unsigned)-1)
|
|
|
|
Personality = &Sec->getFile()->getRelocTargetSym(Rels[FirstRelI]);
|
2016-05-23 07:16:14 +08:00
|
|
|
|
|
|
|
// Search for an existing CIE by CIE contents/relocation target pair.
|
2016-05-26 00:37:01 +08:00
|
|
|
CieRecord *Cie = &CieMap[{Piece.data(), Personality}];
|
2016-05-23 07:16:14 +08:00
|
|
|
|
|
|
|
// If not found, create a new one.
|
2016-05-23 07:52:56 +08:00
|
|
|
if (Cie->Piece == nullptr) {
|
|
|
|
Cie->Piece = &Piece;
|
|
|
|
Cies.push_back(Cie);
|
2016-05-23 07:16:14 +08:00
|
|
|
}
|
|
|
|
return Cie;
|
|
|
|
}
|
2015-11-12 03:54:14 +08:00
|
|
|
|
2016-05-23 07:16:14 +08:00
|
|
|
// There is one FDE per function. Returns true if a given FDE
|
|
|
|
// points to a live function.
|
|
|
|
template <class ELFT>
|
|
|
|
template <class RelTy>
|
2016-07-22 04:18:30 +08:00
|
|
|
bool EhOutputSection<ELFT>::isFdeLive(EhSectionPiece &Piece,
|
2016-05-24 12:19:20 +08:00
|
|
|
EhInputSection<ELFT> *Sec,
|
2016-07-22 04:18:30 +08:00
|
|
|
ArrayRef<RelTy> Rels) {
|
|
|
|
unsigned FirstRelI = Piece.FirstRelocation;
|
|
|
|
if (FirstRelI == (unsigned)-1)
|
2016-05-23 07:16:14 +08:00
|
|
|
fatal("FDE doesn't reference another section");
|
2016-07-22 04:18:30 +08:00
|
|
|
const RelTy &Rel = Rels[FirstRelI];
|
|
|
|
SymbolBody &B = Sec->getFile()->getRelocTargetSym(Rel);
|
2016-05-23 07:16:14 +08:00
|
|
|
auto *D = dyn_cast<DefinedRegular<ELFT>>(&B);
|
|
|
|
if (!D || !D->Section)
|
|
|
|
return false;
|
|
|
|
InputSectionBase<ELFT> *Target = D->Section->Repl;
|
|
|
|
return Target && Target->Live;
|
|
|
|
}
|
2015-11-12 03:54:14 +08:00
|
|
|
|
2016-05-23 07:16:14 +08:00
|
|
|
// .eh_frame is a sequence of CIE or FDE records. In general, there
|
|
|
|
// is one CIE record per input object file which is followed by
|
|
|
|
// a list of FDEs. This function searches an existing CIE or create a new
|
|
|
|
// one and associates FDEs to the CIE.
|
|
|
|
template <class ELFT>
|
|
|
|
template <class RelTy>
|
2016-05-24 12:19:20 +08:00
|
|
|
void EhOutputSection<ELFT>::addSectionAux(EhInputSection<ELFT> *Sec,
|
2016-05-23 07:16:14 +08:00
|
|
|
ArrayRef<RelTy> Rels) {
|
2016-05-25 00:03:27 +08:00
|
|
|
const endianness E = ELFT::TargetEndianness;
|
|
|
|
|
|
|
|
DenseMap<size_t, CieRecord *> OffsetToCie;
|
2016-07-22 04:18:30 +08:00
|
|
|
for (EhSectionPiece &Piece : Sec->Pieces) {
|
2016-05-25 00:03:27 +08:00
|
|
|
// The empty record is the end marker.
|
2016-05-26 00:37:01 +08:00
|
|
|
if (Piece.size() == 4)
|
2016-05-25 03:14:09 +08:00
|
|
|
return;
|
2016-05-25 00:03:27 +08:00
|
|
|
|
|
|
|
size_t Offset = Piece.InputOff;
|
2016-05-26 00:37:01 +08:00
|
|
|
uint32_t ID = read32<E>(Piece.data().data() + 4);
|
2016-05-25 00:03:27 +08:00
|
|
|
if (ID == 0) {
|
|
|
|
OffsetToCie[Offset] = addCie(Piece, Sec, Rels);
|
|
|
|
continue;
|
|
|
|
}
|
2016-05-24 23:17:47 +08:00
|
|
|
|
2016-05-25 00:03:27 +08:00
|
|
|
uint32_t CieOffset = Offset + 4 - ID;
|
|
|
|
CieRecord *Cie = OffsetToCie[CieOffset];
|
|
|
|
if (!Cie)
|
|
|
|
fatal("invalid CIE reference");
|
2015-11-12 03:54:14 +08:00
|
|
|
|
2016-05-25 00:03:27 +08:00
|
|
|
if (!isFdeLive(Piece, Sec, Rels))
|
2016-05-23 07:16:14 +08:00
|
|
|
continue;
|
2016-05-25 00:03:27 +08:00
|
|
|
Cie->FdePieces.push_back(&Piece);
|
2016-05-24 00:30:41 +08:00
|
|
|
NumFdes++;
|
2015-11-12 03:54:14 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
2016-05-23 23:07:59 +08:00
|
|
|
void EhOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
|
2016-05-24 12:19:20 +08:00
|
|
|
auto *Sec = cast<EhInputSection<ELFT>>(C);
|
2016-05-23 07:16:14 +08:00
|
|
|
Sec->OutSec = this;
|
2016-06-17 09:18:46 +08:00
|
|
|
this->updateAlignment(Sec->Alignment);
|
2016-05-23 07:16:14 +08:00
|
|
|
Sections.push_back(Sec);
|
|
|
|
|
|
|
|
// .eh_frame is a sequence of CIE or FDE records. This function
|
|
|
|
// splits it into pieces so that we can call
|
|
|
|
// SplitInputSection::getSectionPiece on the section.
|
2016-05-23 07:53:00 +08:00
|
|
|
Sec->split();
|
2016-05-23 07:16:14 +08:00
|
|
|
if (Sec->Pieces.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (const Elf_Shdr *RelSec = Sec->RelocSection) {
|
|
|
|
ELFFile<ELFT> &Obj = Sec->getFile()->getObj();
|
|
|
|
if (RelSec->sh_type == SHT_RELA)
|
|
|
|
addSectionAux(Sec, Obj.relas(RelSec));
|
|
|
|
else
|
|
|
|
addSectionAux(Sec, Obj.rels(RelSec));
|
2016-01-28 06:23:44 +08:00
|
|
|
return;
|
|
|
|
}
|
2016-05-23 07:16:14 +08:00
|
|
|
addSectionAux(Sec, makeArrayRef<Elf_Rela>(nullptr, nullptr));
|
2015-11-12 03:54:14 +08:00
|
|
|
}
|
|
|
|
|
2015-12-25 04:44:06 +08:00
|
|
|
template <class ELFT>
|
2016-05-22 08:17:11 +08:00
|
|
|
static void writeCieFde(uint8_t *Buf, ArrayRef<uint8_t> D) {
|
|
|
|
memcpy(Buf, D.data(), D.size());
|
2016-05-22 02:10:13 +08:00
|
|
|
|
|
|
|
// Fix the size field. -4 since size does not include the size field itself.
|
2015-12-25 04:44:06 +08:00
|
|
|
const endianness E = ELFT::TargetEndianness;
|
2016-05-22 08:17:11 +08:00
|
|
|
write32<E>(Buf, alignTo(D.size(), sizeof(typename ELFT::uint)) - 4);
|
2015-12-25 04:44:06 +08:00
|
|
|
}
|
|
|
|
|
2016-05-23 23:07:59 +08:00
|
|
|
template <class ELFT> void EhOutputSection<ELFT>::finalize() {
|
2016-07-16 10:47:42 +08:00
|
|
|
if (this->Header.sh_size)
|
|
|
|
return; // Already finalized.
|
2016-04-07 22:22:09 +08:00
|
|
|
|
2016-05-23 07:16:14 +08:00
|
|
|
size_t Off = 0;
|
|
|
|
for (CieRecord *Cie : Cies) {
|
|
|
|
Cie->Piece->OutputOff = Off;
|
|
|
|
Off += alignTo(Cie->Piece->size(), sizeof(uintX_t));
|
2015-11-12 03:54:14 +08:00
|
|
|
|
2016-05-23 07:16:14 +08:00
|
|
|
for (SectionPiece *Fde : Cie->FdePieces) {
|
|
|
|
Fde->OutputOff = Off;
|
|
|
|
Off += alignTo(Fde->size(), sizeof(uintX_t));
|
2016-04-07 22:22:09 +08:00
|
|
|
}
|
|
|
|
}
|
2016-05-23 07:16:14 +08:00
|
|
|
this->Header.sh_size = Off;
|
2016-04-07 22:22:09 +08:00
|
|
|
}
|
|
|
|
|
2016-05-23 11:00:33 +08:00
|
|
|
template <class ELFT> static uint64_t readFdeAddr(uint8_t *Buf, int Size) {
|
|
|
|
const endianness E = ELFT::TargetEndianness;
|
|
|
|
switch (Size) {
|
|
|
|
case DW_EH_PE_udata2:
|
|
|
|
return read16<E>(Buf);
|
|
|
|
case DW_EH_PE_udata4:
|
|
|
|
return read32<E>(Buf);
|
|
|
|
case DW_EH_PE_udata8:
|
|
|
|
return read64<E>(Buf);
|
|
|
|
case DW_EH_PE_absptr:
|
|
|
|
if (ELFT::Is64Bits)
|
|
|
|
return read64<E>(Buf);
|
|
|
|
return read32<E>(Buf);
|
|
|
|
}
|
|
|
|
fatal("unknown FDE size encoding");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns the VA to which a given FDE (on a mmap'ed buffer) is applied to.
|
|
|
|
// We need it to create .eh_frame_hdr section.
|
|
|
|
template <class ELFT>
|
2016-05-23 23:07:59 +08:00
|
|
|
typename ELFT::uint EhOutputSection<ELFT>::getFdePc(uint8_t *Buf, size_t FdeOff,
|
2016-05-23 11:00:33 +08:00
|
|
|
uint8_t Enc) {
|
2016-05-24 00:36:47 +08:00
|
|
|
// The starting address to which this FDE applies is
|
2016-05-23 11:00:33 +08:00
|
|
|
// stored at FDE + 8 byte.
|
|
|
|
size_t Off = FdeOff + 8;
|
|
|
|
uint64_t Addr = readFdeAddr<ELFT>(Buf + Off, Enc & 0x7);
|
|
|
|
if ((Enc & 0x70) == DW_EH_PE_absptr)
|
|
|
|
return Addr;
|
|
|
|
if ((Enc & 0x70) == DW_EH_PE_pcrel)
|
|
|
|
return Addr + this->getVA() + Off;
|
|
|
|
fatal("unknown FDE size relative encoding");
|
|
|
|
}
|
|
|
|
|
2016-05-23 23:07:59 +08:00
|
|
|
template <class ELFT> void EhOutputSection<ELFT>::writeTo(uint8_t *Buf) {
|
2016-04-07 22:22:09 +08:00
|
|
|
const endianness E = ELFT::TargetEndianness;
|
2016-05-23 07:16:14 +08:00
|
|
|
for (CieRecord *Cie : Cies) {
|
|
|
|
size_t CieOffset = Cie->Piece->OutputOff;
|
2016-05-26 00:37:01 +08:00
|
|
|
writeCieFde<ELFT>(Buf + CieOffset, Cie->Piece->data());
|
2016-05-23 07:16:14 +08:00
|
|
|
|
|
|
|
for (SectionPiece *Fde : Cie->FdePieces) {
|
|
|
|
size_t Off = Fde->OutputOff;
|
2016-05-26 00:37:01 +08:00
|
|
|
writeCieFde<ELFT>(Buf + Off, Fde->data());
|
2016-05-23 07:16:14 +08:00
|
|
|
|
|
|
|
// FDE's second word should have the offset to an associated CIE.
|
|
|
|
// Write it.
|
|
|
|
write32<E>(Buf + Off + 4, Off + 4 - CieOffset);
|
2015-11-12 03:54:14 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-24 12:19:20 +08:00
|
|
|
for (EhInputSection<ELFT> *S : Sections)
|
2016-04-13 09:40:19 +08:00
|
|
|
S->relocate(Buf, nullptr);
|
2016-05-23 11:00:33 +08:00
|
|
|
|
|
|
|
// Construct .eh_frame_hdr. .eh_frame_hdr is a binary search table
|
2016-05-24 00:36:47 +08:00
|
|
|
// to get a FDE from an address to which FDE is applied. So here
|
2016-05-23 11:00:33 +08:00
|
|
|
// we obtain two addresses and pass them to EhFrameHdr object.
|
2016-05-24 00:24:16 +08:00
|
|
|
if (Out<ELFT>::EhFrameHdr) {
|
|
|
|
for (CieRecord *Cie : Cies) {
|
2016-05-26 00:37:01 +08:00
|
|
|
uint8_t Enc = getFdeEncoding<ELFT>(Cie->Piece->data());
|
2016-05-24 00:24:16 +08:00
|
|
|
for (SectionPiece *Fde : Cie->FdePieces) {
|
2016-05-24 10:08:38 +08:00
|
|
|
uintX_t Pc = getFdePc(Buf, Fde->OutputOff, Enc);
|
2016-05-24 00:24:16 +08:00
|
|
|
uintX_t FdeVA = this->getVA() + Fde->OutputOff;
|
|
|
|
Out<ELFT>::EhFrameHdr->addFde(Pc, FdeVA);
|
|
|
|
}
|
2016-05-23 11:00:33 +08:00
|
|
|
}
|
|
|
|
}
|
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,
|
2016-02-19 22:17:40 +08:00
|
|
|
uintX_t Flags, uintX_t Alignment)
|
|
|
|
: OutputSectionBase<ELFT>(Name, Type, Flags),
|
2016-07-17 02:55:47 +08:00
|
|
|
Builder(StringTableBuilder::RAW, Alignment) {}
|
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;
|
|
|
|
}
|
2016-05-06 08:52:08 +08:00
|
|
|
for (const std::pair<CachedHash<StringRef>, size_t> &P : Builder.getMap()) {
|
|
|
|
StringRef Data = P.first.Val;
|
2015-10-25 06:51:01 +08:00
|
|
|
memcpy(Buf + P.second, Data.data(), Data.size());
|
2015-10-20 05:00:02 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-22 09:15:32 +08:00
|
|
|
static StringRef toStringRef(ArrayRef<uint8_t> A) {
|
|
|
|
return {(const char *)A.data(), A.size()};
|
|
|
|
}
|
|
|
|
|
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) {
|
2016-05-22 08:25:30 +08:00
|
|
|
auto *Sec = cast<MergeInputSection<ELFT>>(C);
|
|
|
|
Sec->OutSec = this;
|
2016-06-17 09:18:46 +08:00
|
|
|
this->updateAlignment(Sec->Alignment);
|
2016-05-22 09:03:41 +08:00
|
|
|
this->Header.sh_entsize = Sec->getSectionHdr()->sh_entsize;
|
Avoid doing binary search.
MergedInputSection::getOffset is the busiest function in LLD if string
merging is enabled and input files have lots of mergeable sections.
It is usually the case when creating executable with debug info,
so it is pretty common.
The reason why it is slow is because it has to do faily complex
computations. For non-mergeable sections, section contents are
contiguous in output, so in order to compute an output offset,
we only have to add the output section's base address to an input
offset. But for mergeable strings, section contents are split for
merging, so they are not contigous. We've got to do some lookups.
We used to do binary search on the list of section pieces.
It is slow because I think it's hostile to branch prediction.
This patch replaces it with hash table lookup. Seems it's working
pretty well. Below is "perf stat -r10" output when linking clang
with debug info. In this case this patch speeds up about 4%.
Before:
6584.153205 task-clock (msec) # 1.001 CPUs utilized ( +- 0.09% )
238 context-switches # 0.036 K/sec ( +- 6.59% )
0 cpu-migrations # 0.000 K/sec ( +- 50.92% )
1,067,675 page-faults # 0.162 M/sec ( +- 0.15% )
18,369,931,470 cycles # 2.790 GHz ( +- 0.09% )
9,640,680,143 stalled-cycles-frontend # 52.48% frontend cycles idle ( +- 0.18% )
<not supported> stalled-cycles-backend
21,206,747,787 instructions # 1.15 insns per cycle
# 0.45 stalled cycles per insn ( +- 0.04% )
3,817,398,032 branches # 579.786 M/sec ( +- 0.04% )
132,787,249 branch-misses # 3.48% of all branches ( +- 0.02% )
6.579106511 seconds time elapsed ( +- 0.09% )
After:
6312.317533 task-clock (msec) # 1.001 CPUs utilized ( +- 0.19% )
221 context-switches # 0.035 K/sec ( +- 4.11% )
1 cpu-migrations # 0.000 K/sec ( +- 45.21% )
1,280,775 page-faults # 0.203 M/sec ( +- 0.37% )
17,611,539,150 cycles # 2.790 GHz ( +- 0.19% )
10,285,148,569 stalled-cycles-frontend # 58.40% frontend cycles idle ( +- 0.30% )
<not supported> stalled-cycles-backend
18,794,779,900 instructions # 1.07 insns per cycle
# 0.55 stalled cycles per insn ( +- 0.03% )
3,287,450,865 branches # 520.799 M/sec ( +- 0.03% )
72,259,605 branch-misses # 2.20% of all branches ( +- 0.01% )
6.307411828 seconds time elapsed ( +- 0.19% )
Differential Revision: http://reviews.llvm.org/D20645
llvm-svn: 270999
2016-05-27 22:39:13 +08:00
|
|
|
Sections.push_back(Sec);
|
2015-10-20 05:00:02 +08:00
|
|
|
|
2016-05-22 09:03:41 +08:00
|
|
|
bool IsString = this->Header.sh_flags & SHF_STRINGS;
|
2016-01-30 06:18:55 +08:00
|
|
|
|
2016-05-24 10:10:28 +08:00
|
|
|
for (SectionPiece &Piece : Sec->Pieces) {
|
2016-05-22 08:13:04 +08:00
|
|
|
if (!Piece.Live)
|
2016-04-23 06:09:35 +08:00
|
|
|
continue;
|
2016-05-26 00:37:01 +08:00
|
|
|
uintX_t OutputOffset = Builder.add(toStringRef(Piece.data()));
|
2016-05-22 09:03:41 +08:00
|
|
|
if (!IsString || !shouldTailMerge())
|
|
|
|
Piece.OutputOff = 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
|
|
|
}
|
|
|
|
|
Avoid doing binary search.
MergedInputSection::getOffset is the busiest function in LLD if string
merging is enabled and input files have lots of mergeable sections.
It is usually the case when creating executable with debug info,
so it is pretty common.
The reason why it is slow is because it has to do faily complex
computations. For non-mergeable sections, section contents are
contiguous in output, so in order to compute an output offset,
we only have to add the output section's base address to an input
offset. But for mergeable strings, section contents are split for
merging, so they are not contigous. We've got to do some lookups.
We used to do binary search on the list of section pieces.
It is slow because I think it's hostile to branch prediction.
This patch replaces it with hash table lookup. Seems it's working
pretty well. Below is "perf stat -r10" output when linking clang
with debug info. In this case this patch speeds up about 4%.
Before:
6584.153205 task-clock (msec) # 1.001 CPUs utilized ( +- 0.09% )
238 context-switches # 0.036 K/sec ( +- 6.59% )
0 cpu-migrations # 0.000 K/sec ( +- 50.92% )
1,067,675 page-faults # 0.162 M/sec ( +- 0.15% )
18,369,931,470 cycles # 2.790 GHz ( +- 0.09% )
9,640,680,143 stalled-cycles-frontend # 52.48% frontend cycles idle ( +- 0.18% )
<not supported> stalled-cycles-backend
21,206,747,787 instructions # 1.15 insns per cycle
# 0.45 stalled cycles per insn ( +- 0.04% )
3,817,398,032 branches # 579.786 M/sec ( +- 0.04% )
132,787,249 branch-misses # 3.48% of all branches ( +- 0.02% )
6.579106511 seconds time elapsed ( +- 0.09% )
After:
6312.317533 task-clock (msec) # 1.001 CPUs utilized ( +- 0.19% )
221 context-switches # 0.035 K/sec ( +- 4.11% )
1 cpu-migrations # 0.000 K/sec ( +- 45.21% )
1,280,775 page-faults # 0.203 M/sec ( +- 0.37% )
17,611,539,150 cycles # 2.790 GHz ( +- 0.19% )
10,285,148,569 stalled-cycles-frontend # 58.40% frontend cycles idle ( +- 0.30% )
<not supported> stalled-cycles-backend
18,794,779,900 instructions # 1.07 insns per cycle
# 0.55 stalled cycles per insn ( +- 0.03% )
3,287,450,865 branches # 520.799 M/sec ( +- 0.03% )
72,259,605 branch-misses # 2.20% of all branches ( +- 0.01% )
6.307411828 seconds time elapsed ( +- 0.19% )
Differential Revision: http://reviews.llvm.org/D20645
llvm-svn: 270999
2016-05-27 22:39:13 +08:00
|
|
|
template <class ELFT> void MergeOutputSection<ELFT>::finalizePieces() {
|
|
|
|
for (MergeInputSection<ELFT> *Sec : Sections)
|
|
|
|
Sec->finalizePieces();
|
|
|
|
}
|
|
|
|
|
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),
|
2016-07-14 13:46:24 +08:00
|
|
|
Dynamic(Dynamic) {}
|
2015-09-26 01:19:10 +08:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2016-06-23 12:33:42 +08:00
|
|
|
template <class ELFT>
|
|
|
|
typename ELFT::uint DynamicReloc<ELFT>::getOffset() const {
|
|
|
|
if (OutputSec)
|
|
|
|
return OutputSec->getVA() + OffsetInSec;
|
2016-08-19 23:46:28 +08:00
|
|
|
return InputSec->OutSec->getVA() + InputSec->getOffset(OffsetInSec);
|
2016-06-23 12:33:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
typename ELFT::uint DynamicReloc<ELFT>::getAddend() const {
|
|
|
|
if (UseSymVA)
|
|
|
|
return Sym->getVA<ELFT>(Addend);
|
|
|
|
return Addend;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> uint32_t DynamicReloc<ELFT>::getSymIndex() const {
|
|
|
|
if (Sym && !UseSymVA)
|
|
|
|
return Sym->DynsymIndex;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-09-26 01:19:10 +08:00
|
|
|
template <class ELFT>
|
|
|
|
SymbolTableSection<ELFT>::SymbolTableSection(
|
2016-05-24 12:25:47 +08:00
|
|
|
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-05-24 12:25:47 +08:00
|
|
|
StrTabSec(StrTabSec) {
|
2016-01-08 02:20:02 +08:00
|
|
|
this->Header.sh_entsize = sizeof(Elf_Sym);
|
2016-01-30 06:18:57 +08:00
|
|
|
this->Header.sh_addralign = sizeof(uintX_t);
|
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) {
|
2016-03-29 22:07:22 +08:00
|
|
|
// Sort entries related to non-local preemptible symbols by GOT indexes.
|
|
|
|
// All other entries go to the first part of GOT in arbitrary order.
|
2016-06-20 19:37:56 +08:00
|
|
|
bool LIsInLocalGot = !L.first->IsInGlobalMipsGot;
|
|
|
|
bool RIsInLocalGot = !R.first->IsInGlobalMipsGot;
|
|
|
|
if (LIsInLocalGot || RIsInLocalGot)
|
|
|
|
return !RIsInLocalGot;
|
2016-01-29 09:24:25 +08:00
|
|
|
return L.first->GotIndex < R.first->GotIndex;
|
2015-11-12 12:08:12 +08:00
|
|
|
}
|
|
|
|
|
2016-04-08 23:30:56 +08:00
|
|
|
static uint8_t getSymbolBinding(SymbolBody *Body) {
|
ELF: New symbol table design.
This patch implements a new design for the symbol table that stores
SymbolBodies within a memory region of the Symbol object. Symbols are mutated
by constructing SymbolBodies in place over existing SymbolBodies, rather
than by mutating pointers. As mentioned in the initial proposal [1], this
memory layout helps reduce the cache miss rate by improving memory locality.
Performance numbers:
old(s) new(s)
Without debug info:
chrome 7.178 6.432 (-11.5%)
LLVMgold.so 0.505 0.502 (-0.5%)
clang 0.954 0.827 (-15.4%)
llvm-as 0.052 0.045 (-15.5%)
With debug info:
scylla 5.695 5.613 (-1.5%)
clang 14.396 14.143 (-1.8%)
Performance counter results show that the fewer required indirections is
indeed the cause of the improved performance. For example, when linking
chrome, stalled cycles decreases from 14,556,444,002 to 12,959,238,310, and
instructions per cycle increases from 0.78 to 0.83. We are also executing
many fewer instructions (15,516,401,933 down to 15,002,434,310), probably
because we spend less time allocating SymbolBodies.
The new mechanism by which symbols are added to the symbol table is by calling
add* functions on the SymbolTable.
In this patch, I handle local symbols by storing them inside "unparented"
SymbolBodies. This is suboptimal, but if we do want to try to avoid allocating
these SymbolBodies, we can probably do that separately.
I also removed a few members from the SymbolBody class that were only being
used to pass information from the input file to the symbol table.
This patch implements the new design for the ELF linker only. I intend to
prepare a similar patch for the COFF linker.
[1] http://lists.llvm.org/pipermail/llvm-dev/2016-April/098832.html
Differential Revision: http://reviews.llvm.org/D19752
llvm-svn: 268178
2016-05-01 12:55:03 +08:00
|
|
|
Symbol *S = Body->symbol();
|
2016-08-19 16:31:02 +08:00
|
|
|
if (Config->Relocatable)
|
|
|
|
return S->Binding;
|
2016-04-26 21:50:46 +08:00
|
|
|
uint8_t Visibility = S->Visibility;
|
2016-04-08 23:30:56 +08:00
|
|
|
if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
|
|
|
|
return STB_LOCAL;
|
2016-04-26 21:50:46 +08:00
|
|
|
if (Config->NoGnuUnique && S->Binding == STB_GNU_UNIQUE)
|
2016-04-08 23:30:56 +08:00
|
|
|
return STB_GLOBAL;
|
2016-04-26 21:50:46 +08:00
|
|
|
return S->Binding;
|
2016-04-08 23:30:56 +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
|
|
|
|
2016-02-25 16:23:37 +08:00
|
|
|
if (Config->Relocatable) {
|
|
|
|
size_t I = NumLocals;
|
|
|
|
for (const std::pair<SymbolBody *, size_t> &P : Symbols)
|
|
|
|
P.first->DynsymIndex = ++I;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
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-02-17 13:06:40 +08:00
|
|
|
for (const std::pair<SymbolBody *, size_t> &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>
|
2016-02-17 13:06:40 +08:00
|
|
|
void SymbolTableSection<ELFT>::addSymbol(SymbolBody *B) {
|
|
|
|
Symbols.push_back({B, StrTabSec.addString(B->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.
|
2016-08-31 16:46:30 +08:00
|
|
|
if (Config->Discard != DiscardPolicy::All && !StrTabSec.isDynamic())
|
2015-09-30 08:32:10 +08:00
|
|
|
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.
|
2016-05-24 12:25:47 +08:00
|
|
|
for (const std::unique_ptr<ObjectFile<ELFT>> &File :
|
|
|
|
Symtab<ELFT>::X->getObjectFiles()) {
|
2016-04-04 22:04:16 +08:00
|
|
|
for (const std::pair<const DefinedRegular<ELFT> *, size_t> &P :
|
|
|
|
File->KeptLocalSyms) {
|
|
|
|
const DefinedRegular<ELFT> &Body = *P.first;
|
|
|
|
InputSectionBase<ELFT> *Section = Body.Section;
|
2015-09-30 08:54:29 +08:00
|
|
|
auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
|
2016-04-04 22:04:16 +08:00
|
|
|
|
|
|
|
if (!Section) {
|
2015-09-30 08:32:10 +08:00
|
|
|
ESym->st_shndx = SHN_ABS;
|
2016-04-04 22:04:16 +08:00
|
|
|
ESym->st_value = Body.Value;
|
2015-09-30 08:32:10 +08:00
|
|
|
} else {
|
2015-10-20 05:00:02 +08:00
|
|
|
const OutputSectionBase<ELFT> *OutSec = Section->OutSec;
|
|
|
|
ESym->st_shndx = OutSec->SectionIndex;
|
2016-04-04 22:04:16 +08:00
|
|
|
ESym->st_value = OutSec->getVA() + Section->getOffset(Body);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
2016-01-29 09:24:25 +08:00
|
|
|
ESym->st_name = P.second;
|
2016-04-04 22:04:16 +08:00
|
|
|
ESym->st_size = Body.template getSize<ELFT>();
|
2016-04-26 21:50:46 +08:00
|
|
|
ESym->setBindingAndType(STB_LOCAL, Body.Type);
|
ELF2: Implement --gc-sections.
Section garbage collection is a feature to remove unused sections
from outputs. Unused sections are sections that cannot be reachable
from known GC-root symbols or sections. Naturally the feature is
implemented as a mark-sweep garbage collector.
In this patch, I added Live bit to InputSectionBase. If and only
if Live bit is on, the section will be written to the output.
Starting from GC-root symbols or sections, a new function, markLive(),
visits all reachable sections and sets their Live bits. Writer then
ignores sections whose Live bit is off, so that such sections are
excluded from the output.
This change has small negative impact on performance if you use
the feature because making sections means more work. The time to
link Clang changes from 0.356s to 0.386s, or +8%.
It reduces Clang size from 57,764,984 bytes to 55,296,600 bytes.
That is 4.3% reduction.
http://reviews.llvm.org/D13950
llvm-svn: 251043
2015-10-23 02:49:53 +08:00
|
|
|
Buf += sizeof(*ESym);
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
}
|
2015-09-30 08:32:10 +08:00
|
|
|
}
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2015-09-30 08:32:10 +08:00
|
|
|
template <class ELFT>
|
2015-10-19 16:01:51 +08:00
|
|
|
void SymbolTableSection<ELFT>::writeGlobalSymbols(uint8_t *Buf) {
|
2015-09-30 08:32:10 +08:00
|
|
|
// Write the internal symbol table contents to the output symbol table
|
|
|
|
// pointed by Buf.
|
2015-10-21 05:47:58 +08:00
|
|
|
auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
|
2016-02-17 13:06:40 +08:00
|
|
|
for (const std::pair<SymbolBody *, size_t> &P : Symbols) {
|
2016-01-29 09:24:25 +08:00
|
|
|
SymbolBody *Body = P.first;
|
2016-02-17 13:06:40 +08:00
|
|
|
size_t StrOff = 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
|
|
|
|
2016-04-04 22:04:16 +08:00
|
|
|
uint8_t Type = Body->Type;
|
|
|
|
uintX_t Size = Body->getSize<ELFT>();
|
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;
|
2016-02-17 13:06:40 +08:00
|
|
|
ESym->st_name = StrOff;
|
ELF: New symbol table design.
This patch implements a new design for the symbol table that stores
SymbolBodies within a memory region of the Symbol object. Symbols are mutated
by constructing SymbolBodies in place over existing SymbolBodies, rather
than by mutating pointers. As mentioned in the initial proposal [1], this
memory layout helps reduce the cache miss rate by improving memory locality.
Performance numbers:
old(s) new(s)
Without debug info:
chrome 7.178 6.432 (-11.5%)
LLVMgold.so 0.505 0.502 (-0.5%)
clang 0.954 0.827 (-15.4%)
llvm-as 0.052 0.045 (-15.5%)
With debug info:
scylla 5.695 5.613 (-1.5%)
clang 14.396 14.143 (-1.8%)
Performance counter results show that the fewer required indirections is
indeed the cause of the improved performance. For example, when linking
chrome, stalled cycles decreases from 14,556,444,002 to 12,959,238,310, and
instructions per cycle increases from 0.78 to 0.83. We are also executing
many fewer instructions (15,516,401,933 down to 15,002,434,310), probably
because we spend less time allocating SymbolBodies.
The new mechanism by which symbols are added to the symbol table is by calling
add* functions on the SymbolTable.
In this patch, I handle local symbols by storing them inside "unparented"
SymbolBodies. This is suboptimal, but if we do want to try to avoid allocating
these SymbolBodies, we can probably do that separately.
I also removed a few members from the SymbolBody class that were only being
used to pass information from the input file to the symbol table.
This patch implements the new design for the ELF linker only. I intend to
prepare a similar patch for the COFF linker.
[1] http://lists.llvm.org/pipermail/llvm-dev/2016-April/098832.html
Differential Revision: http://reviews.llvm.org/D19752
llvm-svn: 268178
2016-05-01 12:55:03 +08:00
|
|
|
ESym->setVisibility(Body->symbol()->Visibility);
|
2016-02-02 05:00:35 +08:00
|
|
|
ESym->st_value = Body->getVA<ELFT>();
|
2015-09-22 05:38:08 +08:00
|
|
|
|
2016-02-17 12:56:44 +08:00
|
|
|
if (const OutputSectionBase<ELFT> *OutSec = getOutputSection(Body))
|
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;
|
2016-02-26 00:19:15 +08:00
|
|
|
|
|
|
|
// On MIPS we need to mark symbol which has a PLT entry and requires pointer
|
|
|
|
// equality by STO_MIPS_PLT flag. That is necessary to help dynamic linker
|
|
|
|
// distinguish such symbols and MIPS lazy-binding stubs.
|
|
|
|
// https://sourceware.org/ml/binutils/2008-07/txt00000.txt
|
|
|
|
if (Config->EMachine == EM_MIPS && Body->isInPlt() &&
|
|
|
|
Body->NeedsCopyOrPltAddr)
|
2016-02-26 05:09:05 +08:00
|
|
|
ESym->st_other |= STO_MIPS_PLT;
|
2015-10-21 05:47:58 +08:00
|
|
|
++ESym;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-17 12:56:44 +08:00
|
|
|
template <class ELFT>
|
|
|
|
const OutputSectionBase<ELFT> *
|
|
|
|
SymbolTableSection<ELFT>::getOutputSection(SymbolBody *Sym) {
|
|
|
|
switch (Sym->kind()) {
|
|
|
|
case SymbolBody::DefinedSyntheticKind:
|
2016-05-03 09:21:08 +08:00
|
|
|
return cast<DefinedSynthetic<ELFT>>(Sym)->Section;
|
2016-02-17 12:56:44 +08:00
|
|
|
case SymbolBody::DefinedRegularKind: {
|
2016-04-15 08:15:02 +08:00
|
|
|
auto &D = cast<DefinedRegular<ELFT>>(*Sym);
|
2016-03-11 20:06:30 +08:00
|
|
|
if (D.Section)
|
|
|
|
return D.Section->OutSec;
|
2016-02-17 12:56:44 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SymbolBody::DefinedCommonKind:
|
2016-08-02 09:35:13 +08:00
|
|
|
return CommonInputSection<ELFT>::X->OutSec;
|
2016-02-17 12:56:44 +08:00
|
|
|
case SymbolBody::SharedKind:
|
|
|
|
if (cast<SharedSymbol<ELFT>>(Sym)->needsCopy())
|
|
|
|
return Out<ELFT>::Bss;
|
|
|
|
break;
|
2016-04-27 08:05:06 +08:00
|
|
|
case SymbolBody::UndefinedKind:
|
2016-04-08 03:24:51 +08:00
|
|
|
case SymbolBody::LazyArchiveKind:
|
|
|
|
case SymbolBody::LazyObjectKind:
|
2016-02-17 12:56:44 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2016-06-20 19:55:12 +08:00
|
|
|
template <class ELFT>
|
|
|
|
VersionDefinitionSection<ELFT>::VersionDefinitionSection()
|
2016-07-16 10:36:00 +08:00
|
|
|
: OutputSectionBase<ELFT>(".gnu.version_d", SHT_GNU_verdef, SHF_ALLOC) {
|
|
|
|
this->Header.sh_addralign = sizeof(uint32_t);
|
|
|
|
}
|
2016-06-20 19:55:12 +08:00
|
|
|
|
|
|
|
static StringRef getFileDefName() {
|
|
|
|
if (!Config->SoName.empty())
|
|
|
|
return Config->SoName;
|
|
|
|
return Config->OutputFile;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void VersionDefinitionSection<ELFT>::finalize() {
|
|
|
|
FileDefNameOff = Out<ELFT>::DynStrTab->addString(getFileDefName());
|
2016-07-16 12:09:27 +08:00
|
|
|
for (VersionDefinition &V : Config->VersionDefinitions)
|
2016-06-20 19:55:12 +08:00
|
|
|
V.NameOff = Out<ELFT>::DynStrTab->addString(V.Name);
|
|
|
|
|
|
|
|
this->Header.sh_size =
|
|
|
|
(sizeof(Elf_Verdef) + sizeof(Elf_Verdaux)) * getVerDefNum();
|
|
|
|
this->Header.sh_link = Out<ELFT>::DynStrTab->SectionIndex;
|
|
|
|
|
|
|
|
// sh_info should be set to the number of definitions. This fact is missed in
|
|
|
|
// documentation, but confirmed by binutils community:
|
|
|
|
// https://sourceware.org/ml/binutils/2014-11/msg00355.html
|
|
|
|
this->Header.sh_info = getVerDefNum();
|
|
|
|
}
|
|
|
|
|
2016-07-16 10:29:45 +08:00
|
|
|
template <class ELFT>
|
|
|
|
void VersionDefinitionSection<ELFT>::writeOne(uint8_t *Buf, uint32_t Index,
|
|
|
|
StringRef Name, size_t NameOff) {
|
|
|
|
auto *Verdef = reinterpret_cast<Elf_Verdef *>(Buf);
|
2016-06-20 19:55:12 +08:00
|
|
|
Verdef->vd_version = 1;
|
2016-07-01 19:45:10 +08:00
|
|
|
Verdef->vd_cnt = 1;
|
2016-07-16 10:29:45 +08:00
|
|
|
Verdef->vd_aux = sizeof(Elf_Verdef);
|
|
|
|
Verdef->vd_next = sizeof(Elf_Verdef) + sizeof(Elf_Verdaux);
|
|
|
|
Verdef->vd_flags = (Index == 1 ? VER_FLG_BASE : 0);
|
2016-06-20 19:55:12 +08:00
|
|
|
Verdef->vd_ndx = Index;
|
|
|
|
Verdef->vd_hash = hashSysv(Name);
|
|
|
|
|
2016-07-16 10:29:45 +08:00
|
|
|
auto *Verdaux = reinterpret_cast<Elf_Verdaux *>(Buf + sizeof(Elf_Verdef));
|
|
|
|
Verdaux->vda_name = NameOff;
|
2016-06-20 19:55:12 +08:00
|
|
|
Verdaux->vda_next = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void VersionDefinitionSection<ELFT>::writeTo(uint8_t *Buf) {
|
2016-07-16 10:29:45 +08:00
|
|
|
writeOne(Buf, 1, getFileDefName(), FileDefNameOff);
|
2016-06-20 19:55:12 +08:00
|
|
|
|
2016-07-16 12:09:27 +08:00
|
|
|
for (VersionDefinition &V : Config->VersionDefinitions) {
|
2016-07-16 10:29:45 +08:00
|
|
|
Buf += sizeof(Elf_Verdef) + sizeof(Elf_Verdaux);
|
|
|
|
writeOne(Buf, V.Id, V.Name, V.NameOff);
|
|
|
|
}
|
2016-06-20 19:55:12 +08:00
|
|
|
|
2016-07-16 10:29:45 +08:00
|
|
|
// Need to terminate the last version definition.
|
|
|
|
Elf_Verdef *Verdef = reinterpret_cast<Elf_Verdef *>(Buf);
|
|
|
|
Verdef->vd_next = 0;
|
2016-06-20 19:55:12 +08:00
|
|
|
}
|
|
|
|
|
2016-04-28 04:22:31 +08:00
|
|
|
template <class ELFT>
|
|
|
|
VersionTableSection<ELFT>::VersionTableSection()
|
2016-04-30 01:19:45 +08:00
|
|
|
: OutputSectionBase<ELFT>(".gnu.version", SHT_GNU_versym, SHF_ALLOC) {
|
2016-04-30 07:20:30 +08:00
|
|
|
this->Header.sh_addralign = sizeof(uint16_t);
|
2016-04-30 01:19:45 +08:00
|
|
|
}
|
2016-04-28 04:22:31 +08:00
|
|
|
|
|
|
|
template <class ELFT> void VersionTableSection<ELFT>::finalize() {
|
|
|
|
this->Header.sh_size =
|
|
|
|
sizeof(Elf_Versym) * (Out<ELFT>::DynSymTab->getSymbols().size() + 1);
|
|
|
|
this->Header.sh_entsize = sizeof(Elf_Versym);
|
2016-06-06 16:04:53 +08:00
|
|
|
// At the moment of june 2016 GNU docs does not mention that sh_link field
|
|
|
|
// should be set, but Sun docs do. Also readelf relies on this field.
|
|
|
|
this->Header.sh_link = Out<ELFT>::DynSymTab->SectionIndex;
|
2016-04-28 04:22:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void VersionTableSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
auto *OutVersym = reinterpret_cast<Elf_Versym *>(Buf) + 1;
|
|
|
|
for (const std::pair<SymbolBody *, size_t> &P :
|
|
|
|
Out<ELFT>::DynSymTab->getSymbols()) {
|
2016-06-20 19:55:12 +08:00
|
|
|
OutVersym->vs_index = P.first->symbol()->VersionId;
|
2016-04-28 04:22:31 +08:00
|
|
|
++OutVersym;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
VersionNeedSection<ELFT>::VersionNeedSection()
|
2016-04-30 01:19:45 +08:00
|
|
|
: OutputSectionBase<ELFT>(".gnu.version_r", SHT_GNU_verneed, SHF_ALLOC) {
|
2016-04-30 07:20:30 +08:00
|
|
|
this->Header.sh_addralign = sizeof(uint32_t);
|
2016-06-20 19:55:12 +08:00
|
|
|
|
|
|
|
// Identifiers in verneed section start at 2 because 0 and 1 are reserved
|
|
|
|
// for VER_NDX_LOCAL and VER_NDX_GLOBAL.
|
|
|
|
// First identifiers are reserved by verdef section if it exist.
|
|
|
|
NextIndex = getVerDefNum() + 1;
|
2016-04-30 01:19:45 +08:00
|
|
|
}
|
2016-04-28 04:22:31 +08:00
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void VersionNeedSection<ELFT>::addSymbol(SharedSymbol<ELFT> *SS) {
|
|
|
|
if (!SS->Verdef) {
|
2016-06-20 19:55:12 +08:00
|
|
|
SS->symbol()->VersionId = VER_NDX_GLOBAL;
|
2016-04-28 04:22:31 +08:00
|
|
|
return;
|
|
|
|
}
|
2016-07-17 11:11:46 +08:00
|
|
|
SharedFile<ELFT> *F = SS->file();
|
2016-04-28 04:22:31 +08:00
|
|
|
// If we don't already know that we need an Elf_Verneed for this DSO, prepare
|
|
|
|
// to create one by adding it to our needed list and creating a dynstr entry
|
|
|
|
// for the soname.
|
|
|
|
if (F->VerdefMap.empty())
|
|
|
|
Needed.push_back({F, Out<ELFT>::DynStrTab->addString(F->getSoName())});
|
|
|
|
typename SharedFile<ELFT>::NeededVer &NV = F->VerdefMap[SS->Verdef];
|
|
|
|
// If we don't already know that we need an Elf_Vernaux for this Elf_Verdef,
|
|
|
|
// prepare to create one by allocating a version identifier and creating a
|
|
|
|
// dynstr entry for the version name.
|
|
|
|
if (NV.Index == 0) {
|
|
|
|
NV.StrTab = Out<ELFT>::DynStrTab->addString(
|
2016-07-17 11:11:46 +08:00
|
|
|
SS->file()->getStringTable().data() + SS->Verdef->getAux()->vda_name);
|
2016-04-28 04:22:31 +08:00
|
|
|
NV.Index = NextIndex++;
|
|
|
|
}
|
2016-06-20 19:55:12 +08:00
|
|
|
SS->symbol()->VersionId = NV.Index;
|
2016-04-28 04:22:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void VersionNeedSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
// The Elf_Verneeds need to appear first, followed by the Elf_Vernauxs.
|
|
|
|
auto *Verneed = reinterpret_cast<Elf_Verneed *>(Buf);
|
|
|
|
auto *Vernaux = reinterpret_cast<Elf_Vernaux *>(Verneed + Needed.size());
|
|
|
|
|
|
|
|
for (std::pair<SharedFile<ELFT> *, size_t> &P : Needed) {
|
|
|
|
// Create an Elf_Verneed for this DSO.
|
|
|
|
Verneed->vn_version = 1;
|
|
|
|
Verneed->vn_cnt = P.first->VerdefMap.size();
|
|
|
|
Verneed->vn_file = P.second;
|
|
|
|
Verneed->vn_aux =
|
|
|
|
reinterpret_cast<char *>(Vernaux) - reinterpret_cast<char *>(Verneed);
|
|
|
|
Verneed->vn_next = sizeof(Elf_Verneed);
|
|
|
|
++Verneed;
|
|
|
|
|
|
|
|
// Create the Elf_Vernauxs for this Elf_Verneed. The loop iterates over
|
|
|
|
// VerdefMap, which will only contain references to needed version
|
|
|
|
// definitions. Each Elf_Vernaux is based on the information contained in
|
|
|
|
// the Elf_Verdef in the source DSO. This loop iterates over a std::map of
|
|
|
|
// pointers, but is deterministic because the pointers refer to Elf_Verdef
|
|
|
|
// data structures within a single input file.
|
|
|
|
for (auto &NV : P.first->VerdefMap) {
|
|
|
|
Vernaux->vna_hash = NV.first->vd_hash;
|
|
|
|
Vernaux->vna_flags = 0;
|
|
|
|
Vernaux->vna_other = NV.second.Index;
|
|
|
|
Vernaux->vna_name = NV.second.StrTab;
|
|
|
|
Vernaux->vna_next = sizeof(Elf_Vernaux);
|
|
|
|
++Vernaux;
|
|
|
|
}
|
|
|
|
|
|
|
|
Vernaux[-1].vna_next = 0;
|
|
|
|
}
|
|
|
|
Verneed[-1].vn_next = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void VersionNeedSection<ELFT>::finalize() {
|
|
|
|
this->Header.sh_link = Out<ELFT>::DynStrTab->SectionIndex;
|
|
|
|
this->Header.sh_info = Needed.size();
|
|
|
|
unsigned Size = Needed.size() * sizeof(Elf_Verneed);
|
|
|
|
for (std::pair<SharedFile<ELFT> *, size_t> &P : Needed)
|
|
|
|
Size += P.first->VerdefMap.size() * sizeof(Elf_Vernaux);
|
|
|
|
this->Header.sh_size = Size;
|
|
|
|
}
|
|
|
|
|
ELF: Implement --build-id.
This patch implements --build-id. After the linker creates an output file
in the memory buffer, it computes the FNV1 hash of the resulting file
and set the hash to the .note section as a build-id.
GNU ld and gold have the same feature, but their default choice of the
hash function is different. Their default is SHA1.
We made a deliberate choice to not use a secure hash function for the
sake of performance. Computing a secure hash is slow -- for example,
MD5 throughput is usually 400 MB/s or so. SHA1 is slower than that.
As a result, if you pass --build-id to gold, then the linker becomes about
10% slower than that without the option. We observed a similar degradation
in an experimental implementation of build-id for LLD. On the other hand,
we observed only 1-2% performance degradation with the FNV hash.
Since build-id is not for digital certificate or anything, we think that
a very small probability of collision is acceptable.
We considered using other signals such as using input file timestamps as
inputs to a secure hash function. But such signals would have an issue
with build reproducibility (if you build a binary from the same source
tree using the same toolchain, the build id should become the same.)
GNU linkers accepts --build-id=<style> option where style is one of
"MD5", "SHA1", or an arbitrary hex string. That option is out of scope
of this patch.
http://reviews.llvm.org/D18091
llvm-svn: 263292
2016-03-12 04:51:53 +08:00
|
|
|
template <class ELFT>
|
2016-04-08 06:49:21 +08:00
|
|
|
BuildIdSection<ELFT>::BuildIdSection(size_t HashSize)
|
|
|
|
: OutputSectionBase<ELFT>(".note.gnu.build-id", SHT_NOTE, SHF_ALLOC),
|
|
|
|
HashSize(HashSize) {
|
|
|
|
// 16 bytes for the note section header.
|
|
|
|
this->Header.sh_size = 16 + HashSize;
|
ELF: Implement --build-id.
This patch implements --build-id. After the linker creates an output file
in the memory buffer, it computes the FNV1 hash of the resulting file
and set the hash to the .note section as a build-id.
GNU ld and gold have the same feature, but their default choice of the
hash function is different. Their default is SHA1.
We made a deliberate choice to not use a secure hash function for the
sake of performance. Computing a secure hash is slow -- for example,
MD5 throughput is usually 400 MB/s or so. SHA1 is slower than that.
As a result, if you pass --build-id to gold, then the linker becomes about
10% slower than that without the option. We observed a similar degradation
in an experimental implementation of build-id for LLD. On the other hand,
we observed only 1-2% performance degradation with the FNV hash.
Since build-id is not for digital certificate or anything, we think that
a very small probability of collision is acceptable.
We considered using other signals such as using input file timestamps as
inputs to a secure hash function. But such signals would have an issue
with build reproducibility (if you build a binary from the same source
tree using the same toolchain, the build id should become the same.)
GNU linkers accepts --build-id=<style> option where style is one of
"MD5", "SHA1", or an arbitrary hex string. That option is out of scope
of this patch.
http://reviews.llvm.org/D18091
llvm-svn: 263292
2016-03-12 04:51:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT> void BuildIdSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
const endianness E = ELFT::TargetEndianness;
|
|
|
|
write32<E>(Buf, 4); // Name size
|
2016-04-08 06:49:21 +08:00
|
|
|
write32<E>(Buf + 4, HashSize); // Content size
|
ELF: Implement --build-id.
This patch implements --build-id. After the linker creates an output file
in the memory buffer, it computes the FNV1 hash of the resulting file
and set the hash to the .note section as a build-id.
GNU ld and gold have the same feature, but their default choice of the
hash function is different. Their default is SHA1.
We made a deliberate choice to not use a secure hash function for the
sake of performance. Computing a secure hash is slow -- for example,
MD5 throughput is usually 400 MB/s or so. SHA1 is slower than that.
As a result, if you pass --build-id to gold, then the linker becomes about
10% slower than that without the option. We observed a similar degradation
in an experimental implementation of build-id for LLD. On the other hand,
we observed only 1-2% performance degradation with the FNV hash.
Since build-id is not for digital certificate or anything, we think that
a very small probability of collision is acceptable.
We considered using other signals such as using input file timestamps as
inputs to a secure hash function. But such signals would have an issue
with build reproducibility (if you build a binary from the same source
tree using the same toolchain, the build id should become the same.)
GNU linkers accepts --build-id=<style> option where style is one of
"MD5", "SHA1", or an arbitrary hex string. That option is out of scope
of this patch.
http://reviews.llvm.org/D18091
llvm-svn: 263292
2016-03-12 04:51:53 +08:00
|
|
|
write32<E>(Buf + 8, NT_GNU_BUILD_ID); // Type
|
|
|
|
memcpy(Buf + 12, "GNU", 4); // Name string
|
|
|
|
HashBuf = Buf + 16;
|
|
|
|
}
|
|
|
|
|
2016-05-03 07:35:59 +08:00
|
|
|
template <class ELFT>
|
2016-09-02 06:43:03 +08:00
|
|
|
void BuildIdFnv1<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
|
2016-05-03 07:35:59 +08:00
|
|
|
const endianness E = ELFT::TargetEndianness;
|
|
|
|
|
2016-04-08 06:49:21 +08:00
|
|
|
// 64-bit FNV-1 hash
|
2016-05-03 07:35:59 +08:00
|
|
|
uint64_t Hash = 0xcbf29ce484222325;
|
2016-09-02 06:43:03 +08:00
|
|
|
for (uint8_t B : Buf) {
|
|
|
|
Hash *= 0x100000001b3;
|
|
|
|
Hash ^= B;
|
ELF: Implement --build-id.
This patch implements --build-id. After the linker creates an output file
in the memory buffer, it computes the FNV1 hash of the resulting file
and set the hash to the .note section as a build-id.
GNU ld and gold have the same feature, but their default choice of the
hash function is different. Their default is SHA1.
We made a deliberate choice to not use a secure hash function for the
sake of performance. Computing a secure hash is slow -- for example,
MD5 throughput is usually 400 MB/s or so. SHA1 is slower than that.
As a result, if you pass --build-id to gold, then the linker becomes about
10% slower than that without the option. We observed a similar degradation
in an experimental implementation of build-id for LLD. On the other hand,
we observed only 1-2% performance degradation with the FNV hash.
Since build-id is not for digital certificate or anything, we think that
a very small probability of collision is acceptable.
We considered using other signals such as using input file timestamps as
inputs to a secure hash function. But such signals would have an issue
with build reproducibility (if you build a binary from the same source
tree using the same toolchain, the build id should become the same.)
GNU linkers accepts --build-id=<style> option where style is one of
"MD5", "SHA1", or an arbitrary hex string. That option is out of scope
of this patch.
http://reviews.llvm.org/D18091
llvm-svn: 263292
2016-03-12 04:51:53 +08:00
|
|
|
}
|
2016-04-08 06:49:21 +08:00
|
|
|
write64<E>(this->HashBuf, Hash);
|
|
|
|
}
|
|
|
|
|
2016-05-03 07:35:59 +08:00
|
|
|
template <class ELFT>
|
2016-09-02 06:43:03 +08:00
|
|
|
void BuildIdMd5<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
|
2016-07-17 02:55:47 +08:00
|
|
|
MD5 Hash;
|
2016-09-02 06:43:03 +08:00
|
|
|
Hash.update(Buf);
|
2016-04-08 06:49:21 +08:00
|
|
|
MD5::MD5Result Res;
|
|
|
|
Hash.final(Res);
|
|
|
|
memcpy(this->HashBuf, Res, 16);
|
ELF: Implement --build-id.
This patch implements --build-id. After the linker creates an output file
in the memory buffer, it computes the FNV1 hash of the resulting file
and set the hash to the .note section as a build-id.
GNU ld and gold have the same feature, but their default choice of the
hash function is different. Their default is SHA1.
We made a deliberate choice to not use a secure hash function for the
sake of performance. Computing a secure hash is slow -- for example,
MD5 throughput is usually 400 MB/s or so. SHA1 is slower than that.
As a result, if you pass --build-id to gold, then the linker becomes about
10% slower than that without the option. We observed a similar degradation
in an experimental implementation of build-id for LLD. On the other hand,
we observed only 1-2% performance degradation with the FNV hash.
Since build-id is not for digital certificate or anything, we think that
a very small probability of collision is acceptable.
We considered using other signals such as using input file timestamps as
inputs to a secure hash function. But such signals would have an issue
with build reproducibility (if you build a binary from the same source
tree using the same toolchain, the build id should become the same.)
GNU linkers accepts --build-id=<style> option where style is one of
"MD5", "SHA1", or an arbitrary hex string. That option is out of scope
of this patch.
http://reviews.llvm.org/D18091
llvm-svn: 263292
2016-03-12 04:51:53 +08:00
|
|
|
}
|
|
|
|
|
2016-05-03 07:35:59 +08:00
|
|
|
template <class ELFT>
|
2016-09-02 06:43:03 +08:00
|
|
|
void BuildIdSha1<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
|
2016-07-17 02:55:47 +08:00
|
|
|
SHA1 Hash;
|
2016-09-02 06:43:03 +08:00
|
|
|
Hash.update(Buf);
|
2016-04-08 07:51:56 +08:00
|
|
|
memcpy(this->HashBuf, Hash.final().data(), 20);
|
|
|
|
}
|
|
|
|
|
2016-08-26 17:55:37 +08:00
|
|
|
template <class ELFT>
|
2016-09-02 06:43:03 +08:00
|
|
|
void BuildIdUuid<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
|
2016-08-26 17:55:37 +08:00
|
|
|
if (getRandomBytes(this->HashBuf, 16))
|
|
|
|
error("entropy source failure");
|
|
|
|
}
|
|
|
|
|
2016-05-14 05:55:56 +08:00
|
|
|
template <class ELFT>
|
|
|
|
BuildIdHexstring<ELFT>::BuildIdHexstring()
|
|
|
|
: BuildIdSection<ELFT>(Config->BuildIdVector.size()) {}
|
|
|
|
|
|
|
|
template <class ELFT>
|
2016-09-02 06:43:03 +08:00
|
|
|
void BuildIdHexstring<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
|
2016-05-14 05:55:56 +08:00
|
|
|
memcpy(this->HashBuf, Config->BuildIdVector.data(),
|
|
|
|
Config->BuildIdVector.size());
|
|
|
|
}
|
|
|
|
|
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);
|
2016-04-27 13:31:28 +08:00
|
|
|
R->ri_gp_value = Out<ELFT>::Got->getVA() + MipsGPOffset;
|
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;
|
2016-05-27 04:46:01 +08:00
|
|
|
S->OutSec = this;
|
2015-12-20 18:57:34 +08:00
|
|
|
}
|
|
|
|
|
2016-05-04 18:07:38 +08:00
|
|
|
template <class ELFT>
|
|
|
|
MipsOptionsOutputSection<ELFT>::MipsOptionsOutputSection()
|
|
|
|
: OutputSectionBase<ELFT>(".MIPS.options", SHT_MIPS_OPTIONS,
|
|
|
|
SHF_ALLOC | SHF_MIPS_NOSTRIP) {
|
|
|
|
this->Header.sh_addralign = 8;
|
|
|
|
this->Header.sh_entsize = 1;
|
|
|
|
this->Header.sh_size = sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void MipsOptionsOutputSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
auto *Opt = reinterpret_cast<Elf_Mips_Options *>(Buf);
|
|
|
|
Opt->kind = ODK_REGINFO;
|
|
|
|
Opt->size = this->Header.sh_size;
|
|
|
|
Opt->section = 0;
|
|
|
|
Opt->info = 0;
|
|
|
|
auto *Reg = reinterpret_cast<Elf_Mips_RegInfo *>(Buf + sizeof(*Opt));
|
|
|
|
Reg->ri_gp_value = Out<ELFT>::Got->getVA() + MipsGPOffset;
|
|
|
|
Reg->ri_gprmask = GprMask;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void MipsOptionsOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
|
|
|
|
auto *S = cast<MipsOptionsInputSection<ELFT>>(C);
|
|
|
|
if (S->Reginfo)
|
|
|
|
GprMask |= S->Reginfo->ri_gprmask;
|
2016-05-27 04:46:01 +08:00
|
|
|
S->OutSec = this;
|
2016-05-04 18:07:38 +08:00
|
|
|
}
|
|
|
|
|
2016-08-12 14:28:49 +08:00
|
|
|
template <class ELFT>
|
|
|
|
MipsAbiFlagsOutputSection<ELFT>::MipsAbiFlagsOutputSection()
|
|
|
|
: OutputSectionBase<ELFT>(".MIPS.abiflags", SHT_MIPS_ABIFLAGS, SHF_ALLOC) {
|
|
|
|
this->Header.sh_addralign = 8;
|
|
|
|
this->Header.sh_entsize = sizeof(Elf_Mips_ABIFlags);
|
|
|
|
this->Header.sh_size = sizeof(Elf_Mips_ABIFlags);
|
|
|
|
memset(&Flags, 0, sizeof(Flags));
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void MipsAbiFlagsOutputSection<ELFT>::writeTo(uint8_t *Buf) {
|
|
|
|
memcpy(Buf, &Flags, sizeof(Flags));
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
void MipsAbiFlagsOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
|
|
|
|
// Check compatibility and merge fields from input .MIPS.abiflags
|
|
|
|
// to the output one.
|
|
|
|
auto *S = cast<MipsAbiFlagsInputSection<ELFT>>(C);
|
|
|
|
S->OutSec = this;
|
|
|
|
if (S->Flags->version != 0) {
|
|
|
|
error(getFilename(S->getFile()) + ": unexpected .MIPS.abiflags version " +
|
|
|
|
Twine(S->Flags->version));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// LLD checks ISA compatibility in getMipsEFlags(). Here we just
|
|
|
|
// select the highest number of ISA/Rev/Ext.
|
|
|
|
Flags.isa_level = std::max(Flags.isa_level, S->Flags->isa_level);
|
|
|
|
Flags.isa_rev = std::max(Flags.isa_rev, S->Flags->isa_rev);
|
|
|
|
Flags.isa_ext = std::max(Flags.isa_ext, S->Flags->isa_ext);
|
|
|
|
Flags.gpr_size = std::max(Flags.gpr_size, S->Flags->gpr_size);
|
|
|
|
Flags.cpr1_size = std::max(Flags.cpr1_size, S->Flags->cpr1_size);
|
|
|
|
Flags.cpr2_size = std::max(Flags.cpr2_size, S->Flags->cpr2_size);
|
|
|
|
Flags.ases |= S->Flags->ases;
|
|
|
|
Flags.flags1 |= S->Flags->flags1;
|
|
|
|
Flags.flags2 |= S->Flags->flags2;
|
|
|
|
Flags.fp_abi = elf::getMipsFpAbiFlag(Flags.fp_abi, S->Flags->fp_abi,
|
|
|
|
getFilename(S->getFile()));
|
|
|
|
}
|
|
|
|
|
2016-07-12 17:49:43 +08:00
|
|
|
template <class ELFT>
|
|
|
|
std::pair<OutputSectionBase<ELFT> *, bool>
|
|
|
|
OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
|
|
|
|
StringRef OutsecName) {
|
|
|
|
SectionKey<ELFT::Is64Bits> Key = createKey(C, OutsecName);
|
|
|
|
OutputSectionBase<ELFT> *&Sec = Map[Key];
|
|
|
|
if (Sec)
|
|
|
|
return {Sec, false};
|
|
|
|
|
2016-09-08 20:33:41 +08:00
|
|
|
switch (C->kind()) {
|
2016-07-12 17:49:43 +08:00
|
|
|
case InputSectionBase<ELFT>::Regular:
|
|
|
|
Sec = new OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
|
|
|
|
break;
|
|
|
|
case InputSectionBase<ELFT>::EHFrame:
|
|
|
|
return {Out<ELFT>::EhFrame, false};
|
|
|
|
case InputSectionBase<ELFT>::Merge:
|
|
|
|
Sec = new MergeOutputSection<ELFT>(Key.Name, Key.Type, Key.Flags,
|
|
|
|
Key.Alignment);
|
|
|
|
break;
|
|
|
|
case InputSectionBase<ELFT>::MipsReginfo:
|
|
|
|
Sec = new MipsReginfoOutputSection<ELFT>();
|
|
|
|
break;
|
|
|
|
case InputSectionBase<ELFT>::MipsOptions:
|
|
|
|
Sec = new MipsOptionsOutputSection<ELFT>();
|
|
|
|
break;
|
2016-08-12 14:28:49 +08:00
|
|
|
case InputSectionBase<ELFT>::MipsAbiFlags:
|
|
|
|
Sec = new MipsAbiFlagsOutputSection<ELFT>();
|
|
|
|
break;
|
2016-07-12 17:49:43 +08:00
|
|
|
}
|
2016-08-12 09:10:17 +08:00
|
|
|
Out<ELFT>::Pool.emplace_back(Sec);
|
2016-07-12 17:49:43 +08:00
|
|
|
return {Sec, true};
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
SectionKey<ELFT::Is64Bits>
|
|
|
|
OutputSectionFactory<ELFT>::createKey(InputSectionBase<ELFT> *C,
|
|
|
|
StringRef OutsecName) {
|
|
|
|
const Elf_Shdr *H = C->getSectionHdr();
|
|
|
|
uintX_t Flags = H->sh_flags & ~SHF_GROUP & ~SHF_COMPRESSED;
|
|
|
|
|
|
|
|
// For SHF_MERGE we create different output sections for each alignment.
|
|
|
|
// This makes each output section simple and keeps a single level mapping from
|
|
|
|
// input to output.
|
|
|
|
uintX_t Alignment = 0;
|
|
|
|
if (isa<MergeInputSection<ELFT>>(C))
|
|
|
|
Alignment = std::max(H->sh_addralign, H->sh_entsize);
|
|
|
|
|
|
|
|
uint32_t Type = H->sh_type;
|
|
|
|
return SectionKey<ELFT::Is64Bits>{OutsecName, Type, Flags, Alignment};
|
|
|
|
}
|
|
|
|
|
|
|
|
template <bool Is64Bits>
|
|
|
|
typename lld::elf::SectionKey<Is64Bits>
|
|
|
|
DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::getEmptyKey() {
|
|
|
|
return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getEmptyKey(), 0, 0, 0};
|
|
|
|
}
|
|
|
|
|
|
|
|
template <bool Is64Bits>
|
|
|
|
typename lld::elf::SectionKey<Is64Bits>
|
|
|
|
DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::getTombstoneKey() {
|
|
|
|
return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getTombstoneKey(), 0, 0,
|
|
|
|
0};
|
|
|
|
}
|
|
|
|
|
|
|
|
template <bool Is64Bits>
|
|
|
|
unsigned
|
|
|
|
DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::getHashValue(const Key &Val) {
|
|
|
|
return hash_combine(Val.Name, Val.Type, Val.Flags, Val.Alignment);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <bool Is64Bits>
|
|
|
|
bool DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::isEqual(const Key &LHS,
|
|
|
|
const Key &RHS) {
|
|
|
|
return DenseMapInfo<StringRef>::isEqual(LHS.Name, RHS.Name) &&
|
|
|
|
LHS.Type == RHS.Type && LHS.Flags == RHS.Flags &&
|
|
|
|
LHS.Alignment == RHS.Alignment;
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
template struct DenseMapInfo<SectionKey<true>>;
|
|
|
|
template struct DenseMapInfo<SectionKey<false>>;
|
|
|
|
}
|
|
|
|
|
2015-09-22 05:38:08 +08:00
|
|
|
namespace lld {
|
2016-02-28 08:25:54 +08:00
|
|
|
namespace elf {
|
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>;
|
|
|
|
|
2016-05-23 23:07:59 +08:00
|
|
|
template class EhOutputSection<ELF32LE>;
|
|
|
|
template class EhOutputSection<ELF32BE>;
|
|
|
|
template class EhOutputSection<ELF64LE>;
|
|
|
|
template class EhOutputSection<ELF64BE>;
|
2015-11-12 03:54:14 +08:00
|
|
|
|
2015-12-20 18:57:34 +08:00
|
|
|
template class MipsReginfoOutputSection<ELF32LE>;
|
|
|
|
template class MipsReginfoOutputSection<ELF32BE>;
|
|
|
|
template class MipsReginfoOutputSection<ELF64LE>;
|
|
|
|
template class MipsReginfoOutputSection<ELF64BE>;
|
|
|
|
|
2016-05-04 18:07:38 +08:00
|
|
|
template class MipsOptionsOutputSection<ELF32LE>;
|
|
|
|
template class MipsOptionsOutputSection<ELF32BE>;
|
|
|
|
template class MipsOptionsOutputSection<ELF64LE>;
|
|
|
|
template class MipsOptionsOutputSection<ELF64BE>;
|
|
|
|
|
2016-08-12 14:28:49 +08:00
|
|
|
template class MipsAbiFlagsOutputSection<ELF32LE>;
|
|
|
|
template class MipsAbiFlagsOutputSection<ELF32BE>;
|
|
|
|
template class MipsAbiFlagsOutputSection<ELF64LE>;
|
|
|
|
template class MipsAbiFlagsOutputSection<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>;
|
ELF: Implement --build-id.
This patch implements --build-id. After the linker creates an output file
in the memory buffer, it computes the FNV1 hash of the resulting file
and set the hash to the .note section as a build-id.
GNU ld and gold have the same feature, but their default choice of the
hash function is different. Their default is SHA1.
We made a deliberate choice to not use a secure hash function for the
sake of performance. Computing a secure hash is slow -- for example,
MD5 throughput is usually 400 MB/s or so. SHA1 is slower than that.
As a result, if you pass --build-id to gold, then the linker becomes about
10% slower than that without the option. We observed a similar degradation
in an experimental implementation of build-id for LLD. On the other hand,
we observed only 1-2% performance degradation with the FNV hash.
Since build-id is not for digital certificate or anything, we think that
a very small probability of collision is acceptable.
We considered using other signals such as using input file timestamps as
inputs to a secure hash function. But such signals would have an issue
with build reproducibility (if you build a binary from the same source
tree using the same toolchain, the build id should become the same.)
GNU linkers accepts --build-id=<style> option where style is one of
"MD5", "SHA1", or an arbitrary hex string. That option is out of scope
of this patch.
http://reviews.llvm.org/D18091
llvm-svn: 263292
2016-03-12 04:51:53 +08:00
|
|
|
|
2016-04-28 04:22:31 +08:00
|
|
|
template class VersionTableSection<ELF32LE>;
|
|
|
|
template class VersionTableSection<ELF32BE>;
|
|
|
|
template class VersionTableSection<ELF64LE>;
|
|
|
|
template class VersionTableSection<ELF64BE>;
|
|
|
|
|
|
|
|
template class VersionNeedSection<ELF32LE>;
|
|
|
|
template class VersionNeedSection<ELF32BE>;
|
|
|
|
template class VersionNeedSection<ELF64LE>;
|
|
|
|
template class VersionNeedSection<ELF64BE>;
|
|
|
|
|
2016-06-20 19:55:12 +08:00
|
|
|
template class VersionDefinitionSection<ELF32LE>;
|
|
|
|
template class VersionDefinitionSection<ELF32BE>;
|
|
|
|
template class VersionDefinitionSection<ELF64LE>;
|
|
|
|
template class VersionDefinitionSection<ELF64BE>;
|
|
|
|
|
ELF: Implement --build-id.
This patch implements --build-id. After the linker creates an output file
in the memory buffer, it computes the FNV1 hash of the resulting file
and set the hash to the .note section as a build-id.
GNU ld and gold have the same feature, but their default choice of the
hash function is different. Their default is SHA1.
We made a deliberate choice to not use a secure hash function for the
sake of performance. Computing a secure hash is slow -- for example,
MD5 throughput is usually 400 MB/s or so. SHA1 is slower than that.
As a result, if you pass --build-id to gold, then the linker becomes about
10% slower than that without the option. We observed a similar degradation
in an experimental implementation of build-id for LLD. On the other hand,
we observed only 1-2% performance degradation with the FNV hash.
Since build-id is not for digital certificate or anything, we think that
a very small probability of collision is acceptable.
We considered using other signals such as using input file timestamps as
inputs to a secure hash function. But such signals would have an issue
with build reproducibility (if you build a binary from the same source
tree using the same toolchain, the build id should become the same.)
GNU linkers accepts --build-id=<style> option where style is one of
"MD5", "SHA1", or an arbitrary hex string. That option is out of scope
of this patch.
http://reviews.llvm.org/D18091
llvm-svn: 263292
2016-03-12 04:51:53 +08:00
|
|
|
template class BuildIdSection<ELF32LE>;
|
|
|
|
template class BuildIdSection<ELF32BE>;
|
|
|
|
template class BuildIdSection<ELF64LE>;
|
|
|
|
template class BuildIdSection<ELF64BE>;
|
2016-04-08 06:49:21 +08:00
|
|
|
|
|
|
|
template class BuildIdFnv1<ELF32LE>;
|
|
|
|
template class BuildIdFnv1<ELF32BE>;
|
|
|
|
template class BuildIdFnv1<ELF64LE>;
|
|
|
|
template class BuildIdFnv1<ELF64BE>;
|
|
|
|
|
|
|
|
template class BuildIdMd5<ELF32LE>;
|
|
|
|
template class BuildIdMd5<ELF32BE>;
|
|
|
|
template class BuildIdMd5<ELF64LE>;
|
|
|
|
template class BuildIdMd5<ELF64BE>;
|
2016-04-08 07:51:56 +08:00
|
|
|
|
|
|
|
template class BuildIdSha1<ELF32LE>;
|
|
|
|
template class BuildIdSha1<ELF32BE>;
|
|
|
|
template class BuildIdSha1<ELF64LE>;
|
|
|
|
template class BuildIdSha1<ELF64BE>;
|
2016-05-14 05:55:56 +08:00
|
|
|
|
2016-08-26 17:55:37 +08:00
|
|
|
template class BuildIdUuid<ELF32LE>;
|
|
|
|
template class BuildIdUuid<ELF32BE>;
|
|
|
|
template class BuildIdUuid<ELF64LE>;
|
|
|
|
template class BuildIdUuid<ELF64BE>;
|
|
|
|
|
2016-05-14 05:55:56 +08:00
|
|
|
template class BuildIdHexstring<ELF32LE>;
|
|
|
|
template class BuildIdHexstring<ELF32BE>;
|
|
|
|
template class BuildIdHexstring<ELF64LE>;
|
|
|
|
template class BuildIdHexstring<ELF64BE>;
|
2016-07-12 17:49:43 +08:00
|
|
|
|
|
|
|
template class OutputSectionFactory<ELF32LE>;
|
|
|
|
template class OutputSectionFactory<ELF32BE>;
|
|
|
|
template class OutputSectionFactory<ELF64LE>;
|
|
|
|
template class OutputSectionFactory<ELF64BE>;
|
2015-09-22 05:38:08 +08:00
|
|
|
}
|
|
|
|
}
|