2015-08-14 22:12:54 +08:00
|
|
|
//===- Symbols.h ------------------------------------------------*- C++ -*-===//
|
2015-07-25 05:03:07 +08:00
|
|
|
//
|
|
|
|
// The LLVM Linker
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef LLD_ELF_SYMBOLS_H
|
|
|
|
#define LLD_ELF_SYMBOLS_H
|
|
|
|
|
2015-08-25 04:06:32 +08:00
|
|
|
#include "Chunks.h"
|
|
|
|
|
2015-07-25 05:03:07 +08:00
|
|
|
#include "lld/Core/LLVM.h"
|
|
|
|
#include "llvm/Object/ELF.h"
|
|
|
|
|
|
|
|
namespace lld {
|
|
|
|
namespace elf2 {
|
|
|
|
|
|
|
|
using llvm::object::ELFFile;
|
|
|
|
|
|
|
|
class Chunk;
|
|
|
|
class InputFile;
|
|
|
|
class SymbolBody;
|
2015-07-29 06:58:25 +08:00
|
|
|
template <class ELFT> class ObjectFile;
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
// A real symbol object, SymbolBody, is usually accessed indirectly
|
|
|
|
// through a Symbol. There's always one Symbol for each symbol name.
|
|
|
|
// The resolver updates SymbolBody pointers as it resolves symbols.
|
|
|
|
struct Symbol {
|
|
|
|
explicit Symbol(SymbolBody *P) : Body(P) {}
|
|
|
|
SymbolBody *Body;
|
|
|
|
};
|
|
|
|
|
|
|
|
// The base class for real symbol classes.
|
|
|
|
class SymbolBody {
|
|
|
|
public:
|
|
|
|
enum Kind {
|
2015-08-12 01:10:02 +08:00
|
|
|
DefinedFirst = 0,
|
|
|
|
DefinedRegularKind = 0,
|
2015-08-27 20:40:06 +08:00
|
|
|
DefinedAbsoluteKind = 1,
|
|
|
|
DefinedWeakKind = 2,
|
|
|
|
DefinedLast = 2,
|
|
|
|
UndefinedWeakKind = 3,
|
|
|
|
UndefinedKind = 4,
|
|
|
|
UndefinedSyntheticKind = 5
|
2015-07-25 05:03:07 +08:00
|
|
|
};
|
|
|
|
|
2015-07-29 06:58:25 +08:00
|
|
|
Kind kind() const { return static_cast<Kind>(SymbolKind); }
|
2015-07-25 05:03:07 +08:00
|
|
|
|
2015-08-15 00:46:28 +08:00
|
|
|
bool isStrongUndefined() {
|
|
|
|
return SymbolKind == UndefinedKind || SymbolKind == UndefinedSyntheticKind;
|
|
|
|
}
|
|
|
|
|
2015-07-25 05:03:07 +08:00
|
|
|
// Returns the symbol name.
|
2015-07-29 06:58:25 +08:00
|
|
|
StringRef getName() const { return Name; }
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
// A SymbolBody has a backreference to a Symbol. Originally they are
|
|
|
|
// doubly-linked. A backreference will never change. But the pointer
|
|
|
|
// in the Symbol may be mutated by the resolver. If you have a
|
|
|
|
// pointer P to a SymbolBody and are not sure whether the resolver
|
|
|
|
// has chosen the object among other objects having the same name,
|
|
|
|
// you can access P->Backref->Body to get the resolver's result.
|
|
|
|
void setBackref(Symbol *P) { Backref = P; }
|
2015-08-28 07:15:56 +08:00
|
|
|
SymbolBody *getReplacement() { return Backref ? Backref->Body : this; }
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
// Decides which symbol should "win" in the symbol table, this or
|
|
|
|
// the Other. Returns 1 if this wins, -1 if the Other wins, or 0 if
|
|
|
|
// they are duplicate (conflicting) symbols.
|
2015-07-28 04:39:01 +08:00
|
|
|
int compare(SymbolBody *Other);
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
protected:
|
2015-08-14 22:38:44 +08:00
|
|
|
SymbolBody(Kind K, StringRef Name) : SymbolKind(K), Name(Name) {}
|
2015-07-25 05:03:07 +08:00
|
|
|
|
2015-07-29 06:58:25 +08:00
|
|
|
protected:
|
|
|
|
const unsigned SymbolKind : 8;
|
|
|
|
StringRef Name;
|
2015-07-25 05:03:07 +08:00
|
|
|
Symbol *Backref = nullptr;
|
|
|
|
};
|
|
|
|
|
2015-08-15 00:46:28 +08:00
|
|
|
// This is for symbols created from elf files and not from the command line.
|
|
|
|
// Since they come from object files, they have a Elf_Sym.
|
|
|
|
//
|
|
|
|
// FIXME: Another alternative is to give every symbol an Elf_Sym. To do that
|
|
|
|
// we have to delay creating the symbol table until the output format is
|
|
|
|
// known and some of its methods will be templated. We should experiment with
|
|
|
|
// that once we have a bit more code.
|
|
|
|
template <class ELFT> class ELFSymbolBody : public SymbolBody {
|
|
|
|
protected:
|
|
|
|
typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
|
|
|
|
ELFSymbolBody(Kind K, StringRef Name, const Elf_Sym &Sym)
|
|
|
|
: SymbolBody(K, Name), Sym(Sym) {}
|
|
|
|
|
|
|
|
public:
|
|
|
|
const Elf_Sym &Sym;
|
|
|
|
|
|
|
|
static bool classof(const SymbolBody *S) {
|
|
|
|
Kind K = S->kind();
|
|
|
|
return K >= DefinedFirst && K <= UndefinedKind;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-07-25 05:03:07 +08:00
|
|
|
// The base class for any defined symbols, including absolute symbols,
|
|
|
|
// etc.
|
2015-08-15 00:46:28 +08:00
|
|
|
template <class ELFT> class Defined : public ELFSymbolBody<ELFT> {
|
|
|
|
typedef ELFSymbolBody<ELFT> Base;
|
2015-08-27 20:40:06 +08:00
|
|
|
|
|
|
|
protected:
|
|
|
|
typedef typename Base::Kind Kind;
|
|
|
|
typedef typename Base::Elf_Sym Elf_Sym;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit Defined(Kind K, StringRef N, const Elf_Sym &Sym)
|
|
|
|
: ELFSymbolBody<ELFT>(K, N, Sym) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class ELFT> class DefinedAbsolute : public Defined<ELFT> {
|
|
|
|
typedef ELFSymbolBody<ELFT> Base;
|
|
|
|
typedef typename Base::Elf_Sym Elf_Sym;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit DefinedAbsolute(StringRef N, const Elf_Sym &Sym)
|
|
|
|
: Defined<ELFT>(Base::DefinedAbsoluteKind, N, Sym) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class ELFT> class DefinedInSection : public Defined<ELFT> {
|
|
|
|
typedef ELFSymbolBody<ELFT> Base;
|
2015-08-15 00:46:28 +08:00
|
|
|
typedef typename Base::Kind Kind;
|
|
|
|
|
2015-07-25 05:03:07 +08:00
|
|
|
public:
|
2015-08-15 00:46:28 +08:00
|
|
|
typedef typename Base::Elf_Sym Elf_Sym;
|
2015-08-14 23:10:49 +08:00
|
|
|
|
2015-08-27 20:40:06 +08:00
|
|
|
explicit DefinedInSection(Kind K, StringRef N, const Elf_Sym &Sym,
|
|
|
|
SectionChunk<ELFT> &Section)
|
|
|
|
: Defined<ELFT>(K, N, Sym), Section(Section) {}
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
static bool classof(const SymbolBody *S) {
|
|
|
|
Kind K = S->kind();
|
2015-08-15 00:46:28 +08:00
|
|
|
return Base::DefinedFirst <= K && K <= Base::DefinedLast;
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
2015-08-25 04:06:32 +08:00
|
|
|
|
|
|
|
const SectionChunk<ELFT> &Section;
|
2015-07-25 05:03:07 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
// Regular defined symbols read from object file symbol tables.
|
2015-08-27 20:40:06 +08:00
|
|
|
template <class ELFT> class DefinedRegular : public DefinedInSection<ELFT> {
|
2015-08-14 23:10:49 +08:00
|
|
|
typedef Defined<ELFT> Base;
|
|
|
|
typedef typename Base::Elf_Sym Elf_Sym;
|
|
|
|
|
2015-07-25 05:03:07 +08:00
|
|
|
public:
|
2015-08-25 04:06:32 +08:00
|
|
|
explicit DefinedRegular(StringRef N, const Elf_Sym &Sym,
|
|
|
|
SectionChunk<ELFT> &Section)
|
2015-08-27 20:40:06 +08:00
|
|
|
: DefinedInSection<ELFT>(Base::DefinedRegularKind, N, Sym, Section) {}
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
static bool classof(const SymbolBody *S) {
|
2015-08-14 23:10:49 +08:00
|
|
|
return S->kind() == Base::DefinedRegularKind;
|
2015-07-25 05:03:07 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-08-27 20:40:06 +08:00
|
|
|
template <class ELFT> class DefinedWeak : public DefinedInSection<ELFT> {
|
2015-08-14 23:10:49 +08:00
|
|
|
typedef Defined<ELFT> Base;
|
|
|
|
typedef typename Base::Elf_Sym Elf_Sym;
|
|
|
|
|
2015-08-12 01:33:02 +08:00
|
|
|
public:
|
2015-08-25 04:06:32 +08:00
|
|
|
explicit DefinedWeak(StringRef N, const Elf_Sym &Sym,
|
|
|
|
SectionChunk<ELFT> &Section)
|
2015-08-27 20:40:06 +08:00
|
|
|
: DefinedInSection<ELFT>(Base::DefinedWeakKind, N, Sym, Section) {}
|
2015-08-12 01:33:02 +08:00
|
|
|
|
|
|
|
static bool classof(const SymbolBody *S) {
|
2015-08-14 23:10:49 +08:00
|
|
|
return S->kind() == Base::DefinedWeakKind;
|
2015-08-12 01:33:02 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-07-25 05:03:07 +08:00
|
|
|
// Undefined symbols.
|
2015-08-15 00:46:28 +08:00
|
|
|
class SyntheticUndefined : public SymbolBody {
|
2015-07-25 05:03:07 +08:00
|
|
|
public:
|
2015-08-15 00:46:28 +08:00
|
|
|
explicit SyntheticUndefined(StringRef N) : SymbolBody(UndefinedKind, N) {}
|
2015-07-25 05:03:07 +08:00
|
|
|
|
|
|
|
static bool classof(const SymbolBody *S) {
|
|
|
|
return S->kind() == UndefinedKind;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-08-15 00:46:28 +08:00
|
|
|
template <class ELFT> class Undefined : public ELFSymbolBody<ELFT> {
|
|
|
|
typedef ELFSymbolBody<ELFT> Base;
|
|
|
|
typedef typename Base::Elf_Sym Elf_Sym;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit Undefined(StringRef N, const Elf_Sym &Sym)
|
|
|
|
: ELFSymbolBody<ELFT>(Base::UndefinedKind, N, Sym) {}
|
|
|
|
|
|
|
|
static bool classof(const SymbolBody *S) {
|
|
|
|
return S->kind() == Base::UndefinedKind;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class ELFT> class UndefinedWeak : public ELFSymbolBody<ELFT> {
|
|
|
|
typedef ELFSymbolBody<ELFT> Base;
|
|
|
|
typedef typename Base::Elf_Sym Elf_Sym;
|
|
|
|
|
2015-08-12 01:57:05 +08:00
|
|
|
public:
|
2015-08-15 00:46:28 +08:00
|
|
|
explicit UndefinedWeak(StringRef N, const Elf_Sym &Sym)
|
|
|
|
: ELFSymbolBody<ELFT>(Base::UndefinedWeakKind, N, Sym) {}
|
2015-08-12 01:57:05 +08:00
|
|
|
|
|
|
|
static bool classof(const SymbolBody *S) {
|
2015-08-15 00:46:28 +08:00
|
|
|
return S->kind() == Base::UndefinedWeakKind;
|
2015-08-12 01:57:05 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-07-25 05:03:07 +08:00
|
|
|
} // namespace elf2
|
|
|
|
} // namespace lld
|
|
|
|
|
|
|
|
#endif
|