2015-07-25 05:03:07 +08:00
|
|
|
//===- SymbolTable.cpp ----------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Linker
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "SymbolTable.h"
|
2015-09-12 06:42:45 +08:00
|
|
|
#include "Config.h"
|
2015-08-06 23:08:23 +08:00
|
|
|
#include "Error.h"
|
2015-07-25 05:03:07 +08:00
|
|
|
#include "Symbols.h"
|
2015-09-23 02:19:46 +08:00
|
|
|
#include "Target.h"
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
2015-08-31 09:16:19 +08:00
|
|
|
using namespace llvm::object;
|
2015-09-23 02:19:46 +08:00
|
|
|
using namespace llvm::ELF;
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
using namespace lld;
|
|
|
|
using namespace lld::elf2;
|
|
|
|
|
2015-09-09 06:51:46 +08:00
|
|
|
SymbolTable::SymbolTable() {}
|
2015-07-25 05:03:07 +08:00
|
|
|
|
2015-09-17 22:02:10 +08:00
|
|
|
bool SymbolTable::shouldUseRela() const {
|
|
|
|
ELFKind K = getFirstELF()->getELFKind();
|
|
|
|
return K == ELF64LEKind || K == ELF64BEKind;
|
|
|
|
}
|
|
|
|
|
2015-08-04 22:29:01 +08:00
|
|
|
void SymbolTable::addFile(std::unique_ptr<InputFile> File) {
|
2015-07-25 05:03:07 +08:00
|
|
|
File->parse();
|
|
|
|
InputFile *FileP = File.release();
|
2015-09-05 06:28:10 +08:00
|
|
|
if (auto *AF = dyn_cast<ArchiveFile>(FileP)) {
|
|
|
|
ArchiveFiles.emplace_back(AF);
|
|
|
|
for (Lazy &Sym : AF->getLazySymbols())
|
|
|
|
addLazy(&Sym);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
addELFFile(cast<ELFFileBase>(FileP));
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
2015-09-23 05:24:52 +08:00
|
|
|
static TargetInfo *createTarget(uint16_t EMachine) {
|
|
|
|
switch (EMachine) {
|
|
|
|
case EM_PPC:
|
|
|
|
return new PPCTargetInfo();
|
|
|
|
case EM_ARM:
|
|
|
|
return new ARMTargetInfo();
|
|
|
|
case EM_PPC64:
|
|
|
|
return new PPC64TargetInfo();
|
|
|
|
case EM_X86_64:
|
|
|
|
return new X86_64TargetInfo();
|
|
|
|
case EM_386:
|
|
|
|
return new X86TargetInfo();
|
|
|
|
}
|
|
|
|
error("Unknown target machine");
|
|
|
|
}
|
|
|
|
|
2015-09-23 02:19:46 +08:00
|
|
|
template <class ELFT> void SymbolTable::init(uint16_t EMachine) {
|
2015-09-23 05:24:52 +08:00
|
|
|
Target.reset(createTarget(EMachine));
|
2015-09-12 06:42:45 +08:00
|
|
|
if (Config->Shared)
|
|
|
|
return;
|
2015-09-09 06:34:57 +08:00
|
|
|
EntrySym = new (Alloc) Undefined<ELFT>("_start", Undefined<ELFT>::Synthetic);
|
|
|
|
resolve<ELFT>(EntrySym);
|
2015-08-31 09:46:20 +08:00
|
|
|
}
|
|
|
|
|
2015-09-04 08:09:43 +08:00
|
|
|
template <class ELFT> void SymbolTable::addELFFile(ELFFileBase *File) {
|
2015-09-04 04:03:54 +08:00
|
|
|
if (const ELFFileBase *Old = getFirstELF()) {
|
2015-09-04 03:13:13 +08:00
|
|
|
if (!Old->isCompatibleWith(*File))
|
|
|
|
error(Twine(Old->getName() + " is incompatible with " + File->getName()));
|
2015-08-31 09:16:19 +08:00
|
|
|
} else {
|
2015-09-23 02:19:46 +08:00
|
|
|
init<ELFT>(File->getEMachine());
|
2015-09-04 08:09:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (auto *O = dyn_cast<ObjectFileBase>(File)) {
|
|
|
|
ObjectFiles.emplace_back(O);
|
|
|
|
for (SymbolBody *Body : O->getSymbols())
|
|
|
|
resolve<ELFT>(Body);
|
|
|
|
}
|
|
|
|
|
2015-09-08 23:50:05 +08:00
|
|
|
if (auto *S = dyn_cast<SharedFile<ELFT>>(File)) {
|
2015-09-04 08:09:43 +08:00
|
|
|
SharedFiles.emplace_back(S);
|
2015-09-08 23:50:05 +08:00
|
|
|
for (SharedSymbol<ELFT> &Body : S->getSharedSymbols())
|
|
|
|
resolve<ELFT>(&Body);
|
|
|
|
}
|
2015-09-04 08:09:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void SymbolTable::addELFFile(ELFFileBase *File) {
|
|
|
|
switch (File->getELFKind()) {
|
2015-09-10 02:02:23 +08:00
|
|
|
case ELF32LEKind:
|
|
|
|
addELFFile<ELF32LE>(File);
|
|
|
|
break;
|
|
|
|
case ELF32BEKind:
|
|
|
|
addELFFile<ELF32BE>(File);
|
|
|
|
break;
|
|
|
|
case ELF64LEKind:
|
|
|
|
addELFFile<ELF64LE>(File);
|
|
|
|
break;
|
|
|
|
case ELF64BEKind:
|
|
|
|
addELFFile<ELF64BE>(File);
|
|
|
|
break;
|
2015-08-05 20:03:34 +08:00
|
|
|
}
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
|
2015-09-23 22:10:24 +08:00
|
|
|
template <class ELFT>
|
2015-09-24 20:58:44 +08:00
|
|
|
void SymbolTable::dupError(const SymbolBody &Old, const SymbolBody &New) {
|
2015-09-23 22:10:24 +08:00
|
|
|
typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
|
|
|
|
typedef typename ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
|
|
|
|
|
|
|
|
const Elf_Sym &OldE = cast<ELFSymbolBody<ELFT>>(Old).Sym;
|
|
|
|
const Elf_Sym &NewE = cast<ELFSymbolBody<ELFT>>(New).Sym;
|
|
|
|
ELFFileBase *OldFile = nullptr;
|
|
|
|
ELFFileBase *NewFile = nullptr;
|
|
|
|
|
|
|
|
for (const std::unique_ptr<ObjectFileBase> &F : ObjectFiles) {
|
|
|
|
const auto &File = cast<ObjectFile<ELFT>>(*F);
|
|
|
|
Elf_Sym_Range Syms = File.getObj()->symbols(File.getSymbolTable());
|
|
|
|
if (&OldE > Syms.begin() && &OldE < Syms.end())
|
|
|
|
OldFile = F.get();
|
|
|
|
if (&NewE > Syms.begin() && &NewE < Syms.end())
|
|
|
|
NewFile = F.get();
|
|
|
|
}
|
|
|
|
|
|
|
|
error(Twine("duplicate symbol: ") + Old.getName() + " in " +
|
|
|
|
OldFile->getName() + " and " + NewFile->getName());
|
|
|
|
}
|
|
|
|
|
2015-07-25 05:03:07 +08:00
|
|
|
// This function resolves conflicts if there's an existing symbol with
|
|
|
|
// the same name. Decisions are made based on symbol type.
|
2015-08-31 09:16:19 +08:00
|
|
|
template <class ELFT> void SymbolTable::resolve(SymbolBody *New) {
|
2015-09-05 06:28:10 +08:00
|
|
|
Symbol *Sym = insert(New);
|
|
|
|
if (Sym->Body == New)
|
|
|
|
return;
|
|
|
|
|
|
|
|
SymbolBody *Existing = Sym->Body;
|
|
|
|
|
|
|
|
if (Lazy *L = dyn_cast<Lazy>(Existing)) {
|
|
|
|
if (New->isUndefined()) {
|
|
|
|
addMemberFile(L);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Found a definition for something also in an archive. Ignore the archive
|
|
|
|
// definition.
|
|
|
|
Sym->Body = New;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// compare() returns -1, 0, or 1 if the lhs symbol is less preferable,
|
|
|
|
// equivalent (conflicting), or more preferable, respectively.
|
|
|
|
int comp = Existing->compare<ELFT>(New);
|
|
|
|
if (comp < 0)
|
|
|
|
Sym->Body = New;
|
2015-09-23 22:10:24 +08:00
|
|
|
else if (comp == 0)
|
2015-09-24 20:58:44 +08:00
|
|
|
dupError<ELFT>(*Existing, *New);
|
2015-09-05 06:28:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Symbol *SymbolTable::insert(SymbolBody *New) {
|
2015-07-25 05:03:07 +08:00
|
|
|
// Find an existing Symbol or create and insert a new one.
|
|
|
|
StringRef Name = New->getName();
|
|
|
|
Symbol *&Sym = Symtab[Name];
|
|
|
|
if (!Sym) {
|
|
|
|
Sym = new (Alloc) Symbol(New);
|
|
|
|
New->setBackref(Sym);
|
2015-09-05 06:28:10 +08:00
|
|
|
return Sym;
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
New->setBackref(Sym);
|
2015-09-05 06:28:10 +08:00
|
|
|
return Sym;
|
|
|
|
}
|
2015-07-25 05:03:07 +08:00
|
|
|
|
2015-09-05 06:28:10 +08:00
|
|
|
void SymbolTable::addLazy(Lazy *New) {
|
|
|
|
Symbol *Sym = insert(New);
|
|
|
|
if (Sym->Body == New)
|
|
|
|
return;
|
2015-07-25 05:03:07 +08:00
|
|
|
SymbolBody *Existing = Sym->Body;
|
2015-09-05 06:28:10 +08:00
|
|
|
if (Existing->isDefined() || Existing->isLazy())
|
|
|
|
return;
|
|
|
|
Sym->Body = New;
|
|
|
|
assert(Existing->isUndefined() && "Unexpected symbol kind.");
|
|
|
|
addMemberFile(New);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SymbolTable::addMemberFile(Lazy *Body) {
|
|
|
|
std::unique_ptr<InputFile> File = Body->getMember();
|
|
|
|
|
|
|
|
// getMember returns nullptr if the member was already read from the library.
|
|
|
|
if (!File)
|
|
|
|
return;
|
|
|
|
|
|
|
|
addFile(std::move(File));
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|