2016-10-20 17:19:48 +08:00
|
|
|
//===- GdbIndex.cpp -------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Linker
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2017-03-29 08:09:40 +08:00
|
|
|
// The -gdb-index option instructs the linker to emit a .gdb_index section.
|
|
|
|
// The section contains information to make gdb startup faster.
|
|
|
|
// The format of the section is described at
|
|
|
|
// https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html.
|
2016-10-20 17:19:48 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "GdbIndex.h"
|
2017-03-02 05:08:21 +08:00
|
|
|
#include "Memory.h"
|
2016-12-17 18:18:05 +08:00
|
|
|
#include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
|
2016-12-15 17:08:13 +08:00
|
|
|
#include "llvm/Object/ELFObjectFile.h"
|
2016-10-20 17:19:48 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
using namespace llvm::object;
|
2017-03-02 06:03:17 +08:00
|
|
|
using namespace lld;
|
2016-12-15 17:08:13 +08:00
|
|
|
using namespace lld::elf;
|
2016-10-20 17:19:48 +08:00
|
|
|
|
2016-12-15 20:07:53 +08:00
|
|
|
std::pair<bool, GdbSymbol *> GdbHashTab::add(uint32_t Hash, size_t Offset) {
|
2017-03-02 06:24:46 +08:00
|
|
|
GdbSymbol *&Sym = Map[Offset];
|
2017-03-02 05:08:21 +08:00
|
|
|
if (Sym)
|
|
|
|
return {false, Sym};
|
|
|
|
Sym = make<GdbSymbol>(Hash, Offset);
|
|
|
|
return {true, Sym};
|
2016-12-15 20:07:53 +08:00
|
|
|
}
|
|
|
|
|
2017-03-02 05:08:21 +08:00
|
|
|
void GdbHashTab::finalizeContents() {
|
2017-03-03 01:55:29 +08:00
|
|
|
uint32_t Size = std::max<uint32_t>(1024, NextPowerOf2(Map.size() * 4 / 3));
|
|
|
|
uint32_t Mask = Size - 1;
|
|
|
|
Table.resize(Size);
|
2017-03-02 05:08:21 +08:00
|
|
|
|
|
|
|
for (auto &P : Map) {
|
|
|
|
GdbSymbol *Sym = P.second;
|
2017-03-03 01:55:29 +08:00
|
|
|
uint32_t I = Sym->NameHash & Mask;
|
|
|
|
uint32_t Step = ((Sym->NameHash * 17) & Mask) | 1;
|
2017-03-02 05:08:21 +08:00
|
|
|
|
2017-03-03 01:55:29 +08:00
|
|
|
while (Table[I])
|
|
|
|
I = (I + Step) & Mask;
|
|
|
|
Table[I] = Sym;
|
2016-12-15 20:07:53 +08:00
|
|
|
}
|
|
|
|
}
|
2017-07-20 06:27:35 +08:00
|
|
|
|
|
|
|
template <class ELFT>
|
2017-07-27 06:13:32 +08:00
|
|
|
LLDDwarfObj<ELFT>::LLDDwarfObj(ObjFile<ELFT> *Obj) : Obj(Obj) {
|
2017-07-20 06:27:35 +08:00
|
|
|
for (InputSectionBase *Sec : Obj->getSections()) {
|
|
|
|
if (!Sec)
|
|
|
|
continue;
|
|
|
|
if (LLDDWARFSection *M = StringSwitch<LLDDWARFSection *>(Sec->Name)
|
|
|
|
.Case(".debug_info", &InfoSection)
|
|
|
|
.Case(".debug_ranges", &RangeSection)
|
|
|
|
.Case(".debug_line", &LineSection)
|
|
|
|
.Default(nullptr)) {
|
|
|
|
M->Data = toStringRef(Sec->Data);
|
|
|
|
M->Sec = Sec;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (Sec->Name == ".debug_abbrev")
|
|
|
|
AbbrevSection = toStringRef(Sec->Data);
|
|
|
|
else if (Sec->Name == ".debug_gnu_pubnames")
|
|
|
|
GnuPubNamesSection = toStringRef(Sec->Data);
|
|
|
|
else if (Sec->Name == ".debug_gnu_pubtypes")
|
|
|
|
GnuPubTypesSection = toStringRef(Sec->Data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find if there is a relocation at Pos in Sec. The code is a bit
|
|
|
|
// more complicated than usual because we need to pass a section index
|
|
|
|
// to llvm since it has no idea about InputSection.
|
|
|
|
template <class ELFT>
|
|
|
|
template <class RelTy>
|
|
|
|
Optional<RelocAddrEntry>
|
|
|
|
LLDDwarfObj<ELFT>::findAux(const InputSectionBase &Sec, uint64_t Pos,
|
|
|
|
ArrayRef<RelTy> Rels) const {
|
2017-08-01 12:11:03 +08:00
|
|
|
auto It = std::lower_bound(
|
|
|
|
Rels.begin(), Rels.end(), Pos,
|
|
|
|
[](const RelTy &A, uint64_t B) { return A.r_offset < B; });
|
|
|
|
if (It == Rels.end() || It->r_offset != Pos)
|
2017-07-20 06:27:35 +08:00
|
|
|
return None;
|
2017-08-01 12:11:03 +08:00
|
|
|
const RelTy &Rel = *It;
|
|
|
|
|
2017-07-27 06:13:32 +08:00
|
|
|
const ObjFile<ELFT> *File = Sec.getFile<ELFT>();
|
2017-07-20 06:27:35 +08:00
|
|
|
uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL);
|
2017-08-03 01:35:18 +08:00
|
|
|
const typename ELFT::Sym &Sym = File->getELFSyms()[SymIndex];
|
2017-07-20 06:27:35 +08:00
|
|
|
uint32_t SecIndex = File->getSectionIndex(Sym);
|
|
|
|
SymbolBody &B = File->getRelocTargetSym(Rel);
|
|
|
|
auto &DR = cast<DefinedRegular>(B);
|
|
|
|
uint64_t Val = DR.Value + getAddend<ELFT>(Rel);
|
|
|
|
|
|
|
|
// FIXME: We should be consistent about always adding the file
|
|
|
|
// offset or not.
|
|
|
|
if (DR.Section->Flags & ELF::SHF_ALLOC)
|
|
|
|
Val += cast<InputSection>(DR.Section)->getOffsetInFile();
|
|
|
|
|
2017-08-01 12:18:57 +08:00
|
|
|
return RelocAddrEntry{SecIndex, Val};
|
2017-07-20 06:27:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ELFT>
|
|
|
|
Optional<RelocAddrEntry> LLDDwarfObj<ELFT>::find(const llvm::DWARFSection &S,
|
|
|
|
uint64_t Pos) const {
|
|
|
|
auto &Sec = static_cast<const LLDDWARFSection &>(S);
|
|
|
|
if (Sec.Sec->AreRelocsRela)
|
|
|
|
return findAux(*Sec.Sec, Pos, Sec.Sec->template relas<ELFT>());
|
|
|
|
return findAux(*Sec.Sec, Pos, Sec.Sec->template rels<ELFT>());
|
|
|
|
}
|
|
|
|
|
|
|
|
template class elf::LLDDwarfObj<ELF32LE>;
|
|
|
|
template class elf::LLDDwarfObj<ELF32BE>;
|
|
|
|
template class elf::LLDDwarfObj<ELF64LE>;
|
|
|
|
template class elf::LLDDwarfObj<ELF64BE>;
|