reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Derived Classes

  286 class Defined : public Symbol {
  321 class CommonSymbol : public Symbol {
  334 class Undefined : public Symbol {
  347 class SharedSymbol : public Symbol {
  398 class LazyArchive : public Symbol {
  414 class LazyObject : public Symbol {

Declarations

   45 class Symbol;

   24 class Symbol;

   36 class Symbol;

   19 class Symbol;

   38 class Symbol;

   24 class Symbol;

   17 class Symbol;

References

  108         const ArrayRef<U *> &A,
  110            std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
  127     ArrayRef(const std::vector<U *, A> &Vec,
  129                  std::is_convertible<U *const *, T const *>::value>::type* = 0)

   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }

   34   using SimpleType = From; // The real type this represents...
   37   static SimpleType &getSimplifiedValue(From &Val) { return Val; }
   41   using NonConstSimpleType = typename simplify_type<From>::SimpleType;
   47   static RetType getSimplifiedValue(const From& Val) {
   57   static inline bool doit(const From &Val) {
   76   static inline bool doit(const From &Val) {
   77     return isa_impl<To, From>::doit(Val);
  104   static inline bool doit(const From *Val) {
  106     return isa_impl<To, From>::doit(*Val);
  141 template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
  142   return isa_impl_wrap<X, const Y,
  143                        typename simplify_type<const Y>::SimpleType>::doit(Val);
  204   using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::ret_type;
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  236       std::is_same<X, typename simplify_type<X>::SimpleType>::value;
  236       std::is_same<X, typename simplify_type<X>::SimpleType>::value;
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  258   return cast_convert_val<X, Y,
  259                           typename simplify_type<Y>::SimpleType>::doit(Val);
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  266                           typename simplify_type<Y*>::SimpleType>::doit(Val);
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
  367 dyn_cast_or_null(Y *Val) {

   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };

   55 struct add_const_past_pointer { using type = const T; };

  389   Symbol *patchSym;
  444     for (Symbol *b : f->getLocalSymbols()) {

   90   Symbol *patchSym;
  320     for (Symbol *s : f->getLocalSymbols()) {

   35   RelExpr getRelExpr(RelType type, const Symbol &s,
   38   void writeGotPlt(uint8_t *buf, const Symbol &s) const override;
   43                   uint64_t branchAddr, const Symbol &s) const override;
   77 RelExpr AArch64::getRelExpr(RelType type, const Symbol &s,
  190 void AArch64::writeGotPlt(uint8_t *buf, const Symbol &) const {
  233                          uint64_t branchAddr, const Symbol &s) const {

   30   RelExpr getRelExpr(RelType type, const Symbol &s,
   83 RelExpr AMDGPU::getRelExpr(RelType type, const Symbol &s,

   30   RelExpr getRelExpr(RelType type, const Symbol &s,
   34   void writeGotPlt(uint8_t *buf, const Symbol &s) const override;
   35   void writeIgotPlt(uint8_t *buf, const Symbol &s) const override;
   42                   uint64_t branchAddr, const Symbol &s) const override;
   83 RelExpr ARM::getRelExpr(RelType type, const Symbol &s,
  153 void ARM::writeGotPlt(uint8_t *buf, const Symbol &) const {
  157 void ARM::writeIgotPlt(uint8_t *buf, const Symbol &s) const {
  265                      uint64_t branchAddr, const Symbol &s) const {

   47   RelExpr getRelExpr(RelType type, const Symbol &s,
   55 RelExpr AVR::getRelExpr(RelType type, const Symbol &s,

   31   RelExpr getRelExpr(RelType type, const Symbol &s,
   88 RelExpr Hexagon::getRelExpr(RelType type, const Symbol &s,

   37   RelExpr getRelExpr(RelType type, const Symbol &s,
   48 RelExpr MSP430::getRelExpr(RelType type, const Symbol &s,

   29   RelExpr getRelExpr(RelType type, const Symbol &s,
   33   void writeGotPlt(uint8_t *buf, const Symbol &s) const override;
   38                   uint64_t branchAddr, const Symbol &s) const override;
   78 RelExpr MIPS<ELFT>::getRelExpr(RelType type, const Symbol &s,
  196 void MIPS<ELFT>::writeGotPlt(uint8_t *buf, const Symbol &) const {
  348                             uint64_t branchAddr, const Symbol &s) const {

   27   RelExpr getRelExpr(RelType type, const Symbol &s,
   38   void writeGotPlt(uint8_t *buf, const Symbol &s) const override;
   40                   uint64_t branchAddr, const Symbol &s) const override;
  166 void PPC::writeGotPlt(uint8_t *buf, const Symbol &s) const {
  172                      uint64_t branchAddr, const Symbol &s) const {
  191 RelExpr PPC::getRelExpr(RelType type, const Symbol &s,

  127       Symbol &sym = tocSec->getFile<ELFT>()->getRelocTargetSym(relas[index]);
  199   RelExpr getRelExpr(RelType type, const Symbol &s,
  208                   uint64_t branchAddr, const Symbol &s) const override;
  537 RelExpr PPC64::getRelExpr(RelType type, const Symbol &s,
  901                        uint64_t branchAddr, const Symbol &s) const {

   27   RelExpr getRelExpr(RelType type, const Symbol &s,
   50 RelExpr SPARCV9::getRelExpr(RelType type, const Symbol &s,

   28   RelExpr getRelExpr(RelType type, const Symbol &s,
   33   void writeGotPlt(uint8_t *buf, const Symbol &s) const override;
   34   void writeIgotPlt(uint8_t *buf, const Symbol &s) const override;
   73 RelExpr X86::getRelExpr(RelType type, const Symbol &s,
  175 void X86::writeGotPlt(uint8_t *buf, const Symbol &s) const {
  181 void X86::writeIgotPlt(uint8_t *buf, const Symbol &s) const {
  416   void writeGotPlt(uint8_t *buf, const Symbol &s) const override;
  425   void writeGotPlt(uint8_t *buf, const Symbol &s) const override;
  437 void RetpolinePic::writeGotPlt(uint8_t *buf, const Symbol &s) const {
  490 void RetpolineNoPic::writeGotPlt(uint8_t *buf, const Symbol &s) const {

   30   RelExpr getRelExpr(RelType type, const Symbol &s,
   34   void writeGotPlt(uint8_t *buf, const Symbol &s) const override;
   75 RelExpr X86_64::getRelExpr(RelType type, const Symbol &s,
  140 void X86_64::writeGotPlt(uint8_t *buf, const Symbol &s) const {
  584   void writeGotPlt(uint8_t *buf, const Symbol &s) const override;
  593   void writeGotPlt(uint8_t *buf, const Symbol &s) const override {}
  605 void Retpoline::writeGotPlt(uint8_t *buf, const Symbol &s) const {

  249         for (Symbol *sym : sections[i]->file->getSymbols())

  100   Symbol &s = file->getRelocTargetSym(rel);

  711   DenseMap<StringRef, Symbol *> map;
  713     for (Symbol *sym : file->getSymbols())
  717     Symbol *sym = map.lookup(name);
 1351         for (Symbol *sym : file->getSymbols())
 1364 static void handleUndefined(Symbol *sym) {
 1383   std::vector<Symbol *> syms;
 1392   for (Symbol *sym : syms)
 1397   Symbol *sym = symtab->find(name);
 1448 static void markAddrsig(Symbol *s) {
 1488     ArrayRef<Symbol *> syms = obj->getSymbols();
 1505       for (Symbol *s : syms)
 1517   Symbol *sym;
 1560 static Symbol *addUndefined(StringRef name) {
 1581     for (Symbol *sym : obj->getGlobalSymbols())
 1596   Symbol *sym;
 1597   Symbol *real;
 1598   Symbol *wrap;
 1615     Symbol *sym = symtab->find(name);
 1619     Symbol *real = addUndefined(saver.save("__real_" + name));
 1620     Symbol *wrap = addUndefined(saver.save("__wrap_" + name));
 1641   DenseMap<Symbol *, Symbol *> map;
 1641   DenseMap<Symbol *, Symbol *> map;
 1649     MutableArrayRef<Symbol *> syms = file->getMutableSymbols();
 1651       if (Symbol *s = map.lookup(syms[i]))
 1757     if (Symbol *sym = symtab->find(arg))
 1761   if (Symbol *sym = symtab->find(config->entry))

  246     Symbol &sa = secA->template getFile<ELFT>()->getRelocTargetSym(ra[i]);
  247     Symbol &sb = secB->template getFile<ELFT>()->getRelocTargetSym(rb[i]);
  329     Symbol &sa = secA->template getFile<ELFT>()->getRelocTargetSym(ra[i]);
  330     Symbol &sb = secB->template getFile<ELFT>()->getRelocTargetSym(rb[i]);
  432     Symbol &s = isec->template getFile<ELFT>()->getRelocTargetSym(rel);

  232 static std::string getSrcMsgAux(ObjFile<ELFT> &file, const Symbol &sym,
  248 std::string InputFile::getSrcMsg(const Symbol &sym, InputSectionBase &sec,
  372 template <class ELFT> ArrayRef<Symbol *> ObjFile<ELFT>::getLocalSymbols() {
  378 template <class ELFT> ArrayRef<Symbol *> ObjFile<ELFT>::getGlobalSymbols() {
 1271       Symbol *s = symtab->addSymbol(
 1400 static Symbol *createBitcodeSymbol(const std::vector<bool> &keptComdats,
 1414     Symbol *ret = symtab->addSymbol(newSym);
 1545     for (Symbol *sym : this->symbols) {

   88   ArrayRef<Symbol *> getSymbols() { return getMutableSymbols(); }
   90   MutableArrayRef<Symbol *> getMutableSymbols() {
  111   std::string getSrcMsg(const Symbol &sym, InputSectionBase &sec,
  143   std::vector<Symbol *> symbols;
  198   ArrayRef<Symbol *> getLocalSymbols();
  199   ArrayRef<Symbol *> getGlobalSymbols();
  210   Symbol &getSymbol(uint32_t symbolIndex) const {
  218   template <typename RelT> Symbol &getRelocTargetSym(const RelT &rel) const {

  285   for (Symbol *b : file->getSymbols())
  327 std::string InputSectionBase::getSrcMsg(const Symbol &sym, uint64_t offset) {
  348   for (Symbol *b : file->getSymbols())
  415     Symbol &sym = file->getRelocTargetSym(rel);
  557 static uint64_t getARMStaticBase(const Symbol &sym) {
  570 static Relocation *getRISCVPCRelHi20(const Symbol *sym, uint64_t addend) {
  605 static int64_t getTlsTpOffset(const Symbol &s) {
  649                                  uint64_t p, const Symbol &sym, RelExpr expr) {
  851     Symbol &sym = getFile<ELFT>()->getRelocTargetSym(rel);
  997   Symbol *moreStackNonSplit = symtab->find("__morestack_non_split");

  174   std::string getSrcMsg(const Symbol &sym, uint64_t offset);

  165   ArrayRef<Symbol *> syms = f.getSymbols();
  171     Symbol *sym = syms[i];

  152   Symbol *b = symtab->find(cmd->name);
  185   Symbol *sym = symtab->insert(cmd->name);
  202   Symbol *sym = symtab->insert(cmd->name);
 1170   if (Symbol *sym = symtab->find(name)) {

   57     for (Symbol *b : file->getSymbols())
   84 static DenseMap<Symbol *, std::string>
   96   DenseMap<Symbol *, std::string> ret;
  156   DenseMap<Symbol *, std::string> symStr = getSymbolStrings(syms);
  190           for (Symbol *sym : sectionSyms[isec])
  235   MapVector<Symbol *, SetVector<InputFile *>> map;
  237     for (Symbol *sym : file->getSymbols()) {
  252     Symbol *sym = kv.first;

   55   void markSymbol(Symbol *sym);
   93   Symbol &sym = sec.getFile<ELFT>()->getRelocTargetSym(rel);
  206 template <class ELFT> void MarkLive<ELFT>::markSymbol(Symbol *sym) {
  300     for (Symbol *s : file->getSymbols())

  350   ArrayRef<Symbol *> symbols = section->file->getSymbols();

   67 static Optional<std::string> getLinkerScriptLocation(const Symbol &sym) {
   80 static std::string getLocation(InputSectionBase &s, const Symbol &sym,
  133 static unsigned handleMipsTlsRelocation(RelType type, Symbol &sym,
  158 handleTlsRelocation(RelType type, Symbol &sym, InputSectionBase &c,
  325 static bool isAbsolute(const Symbol &sym) {
  333 static bool isAbsoluteValue(const Symbol &sym) {
  368 static bool isStaticLinkTimeConstant(RelExpr e, RelType type, const Symbol &sym,
  489     Symbol *sym = symtab->find(name);
  501 static void replaceWithDefined(Symbol &sym, SectionBase *sec, uint64_t value,
  503   Symbol old = sym;
  688   Symbol *sym;
  702 static const Symbol *getAlternativeSpelling(const Undefined &sym) {
  704   DenseMap<StringRef, const Symbol *> map;
  706     for (const Symbol *s : sym.file->getSymbols())
  713     if (const Symbol *s = map.lookup(newName))
  717     if (const Symbol *s = symtab->find(newName))
  733       if (const Symbol *s = suggest(newName))
  743       if (const Symbol *s = suggest(newName))
  752       if (const Symbol *s = suggest(newName))
  758     if (const Symbol *s = suggest(newName))
  768   Symbol &sym = *undef.sym;
  808     if (const Symbol *corrected =
  828   DenseMap<Symbol *, UndefinedDiag *> firstRef;
  847 static bool maybeReportUndefined(Symbol &sym, InputSectionBase &sec,
  934                              Symbol *sym, int64_t addend, RelExpr expr,
  955                         RelocationBaseSection *rel, RelType type, Symbol &sym) {
  962 static void addGotEntry(Symbol &sym) {
  996 static bool canDefineSymbolInExecutable(Symbol &sym) {
 1028                             uint64_t offset, Symbol &sym, const RelTy &rel,
 1169   Symbol &sym = sec.getFile<ELFT>()->getSymbol(symIndex);

  108   Symbol *sym;
  156   llvm::DenseMap<Symbol *, std::vector<Thunk *>> thunkedSymbols;
  160   llvm::DenseMap<Symbol *, Thunk *> thunks;

   34 void SymbolTable::wrap(Symbol *sym, Symbol *real, Symbol *wrap) {
   34 void SymbolTable::wrap(Symbol *sym, Symbol *real, Symbol *wrap) {
   34 void SymbolTable::wrap(Symbol *sym, Symbol *real, Symbol *wrap) {
   52 Symbol *SymbolTable::insert(StringRef name) {
   70   Symbol *sym = reinterpret_cast<Symbol *>(make<SymbolUnion>());
   76   sym->symbolKind = Symbol::PlaceholderKind;
   90 Symbol *SymbolTable::addSymbol(const Symbol &newSym) {
   90 Symbol *SymbolTable::addSymbol(const Symbol &newSym) {
   91   Symbol *sym = symtab->insert(newSym.getName());
   96 Symbol *SymbolTable::find(StringRef name) {
  100   Symbol *sym = symVector[it->second];
  119 StringMap<std::vector<Symbol *>> &SymbolTable::getDemangledSyms() {
  122     for (Symbol *sym : symVector) {
  131 std::vector<Symbol *> SymbolTable::findByVersion(SymbolVersion ver) {
  134   if (Symbol *b = find(ver.name))
  140 std::vector<Symbol *> SymbolTable::findAllByVersion(SymbolVersion ver) {
  141   std::vector<Symbol *> res;
  151   for (Symbol *sym : symVector)
  160     std::vector<Symbol *> syms;
  166     for (Symbol *sym : syms)
  179   std::vector<Symbol *> syms = findByVersion(ver);
  196   for (Symbol *sym : syms) {
  221   for (Symbol *sym : findAllByVersion(ver))
  258   for (Symbol *sym : symVector)

   36   void wrap(Symbol *sym, Symbol *real, Symbol *wrap);
   36   void wrap(Symbol *sym, Symbol *real, Symbol *wrap);
   36   void wrap(Symbol *sym, Symbol *real, Symbol *wrap);
   38   void forEachSymbol(llvm::function_ref<void(Symbol *)> fn) {
   39     for (Symbol *sym : symVector)
   44   Symbol *insert(StringRef name);
   46   Symbol *addSymbol(const Symbol &newSym);
   46   Symbol *addSymbol(const Symbol &newSym);
   50   Symbol *find(StringRef name);
   63   std::vector<Symbol *> findByVersion(SymbolVersion ver);
   64   std::vector<Symbol *> findAllByVersion(SymbolVersion ver);
   66   llvm::StringMap<std::vector<Symbol *>> &getDemangledSyms();
   79   std::vector<Symbol *> symVector;
   85   llvm::Optional<llvm::StringMap<std::vector<Symbol *>>> demangledSyms;

   34 std::string toString(const elf::Symbol &b) { return demangle(b.getName()); }
   56 static uint64_t getSymVA(const Symbol &sym, int64_t &addend) {
   58   case Symbol::DefinedKind: {
  125   case Symbol::SharedKind:
  126   case Symbol::UndefinedKind:
  128   case Symbol::LazyArchiveKind:
  129   case Symbol::LazyObjectKind:
  132   case Symbol::CommonKind:
  134   case Symbol::PlaceholderKind:
  299 void printTraceSymbol(const Symbol *sym) {
  315 void maybeWarnUnorderableSymbol(const Symbol *sym) {
  358 void Symbol::mergeProperties(const Symbol &other) {
  369 void Symbol::resolve(const Symbol &other) {
  378   case Symbol::UndefinedKind:
  381   case Symbol::CommonKind:
  384   case Symbol::DefinedKind:
  387   case Symbol::LazyArchiveKind:
  390   case Symbol::LazyObjectKind:
  393   case Symbol::SharedKind:
  396   case Symbol::PlaceholderKind:
  519 int Symbol::compare(const Symbol *other) const {
  565 static void reportDuplicate(Symbol *sym, InputFile *newFile,

   24 std::string toString(const elf::Symbol &);
  144   inline void replace(const Symbol &newSym);
  211   void mergeProperties(const Symbol &other);
  212   void resolve(const Symbol &other);
  232   int compare(const Symbol *other) const;
  286 class Defined : public Symbol {
  293   static bool classof(const Symbol *s) { return s->isDefined(); }
  321 class CommonSymbol : public Symbol {
  328   static bool classof(const Symbol *s) { return s->isCommon(); }
  334 class Undefined : public Symbol {
  341   static bool classof(const Symbol *s) { return s->kind() == UndefinedKind; }
  347 class SharedSymbol : public Symbol {
  349   static bool classof(const Symbol *s) { return s->kind() == SharedKind; }
  398 class LazyArchive : public Symbol {
  405   static bool classof(const Symbol *s) { return s->kind() == LazyArchiveKind; }
  414 class LazyObject : public Symbol {
  420   static bool classof(const Symbol *s) { return s->kind() == LazyObjectKind; }
  496 void printTraceSymbol(const Symbol *sym);
  513     return sizeof(Symbol);
  521 void Symbol::replace(const Symbol &newSym) {
  534   Symbol old = *this;
  562 void maybeWarnUnorderableSymbol(const Symbol *sym);

  353   Symbol *personality = nullptr;
  387   Symbol &b = sec->template getFile<ELFT>()->getRelocTargetSym(rel);
  609 void GotSection::addEntry(Symbol &sym) {
  614 bool GotSection::addDynTlsEntry(Symbol &sym) {
  633 uint64_t GotSection::getGlobalDynAddr(const Symbol &b) const {
  637 uint64_t GotSection::getGlobalDynOffset(const Symbol &b) const {
  671 void MipsGotSection::addEntry(InputFile &file, Symbol &sym, int64_t addend,
  691 void MipsGotSection::addDynTlsEntry(InputFile &file, Symbol &sym) {
  731                                             const Symbol &sym,
  745 uint64_t MipsGotSection::getSymEntryOffset(const InputFile *f, const Symbol &s,
  748   Symbol *sym = const_cast<Symbol *>(&s);
  762                                             const Symbol &s) const {
  764   Symbol *sym = const_cast<Symbol *>(&s);
  768 const Symbol *MipsGotSection::getFirstGlobalEntry() const {
  941     for (std::pair<Symbol *, size_t> &p : got.tls) {
  942       Symbol *s = p.first;
  947     for (std::pair<Symbol *, size_t> &p : got.dynTlsSymbols) {
  948       Symbol *s = p.first;
  977     for (const std::pair<Symbol *, size_t> &p : got.global) {
 1058       for (const std::pair<const Symbol *, size_t> &p : g.global)
 1060     for (const std::pair<Symbol *, size_t> &p : g.relocs)
 1062     for (const std::pair<Symbol *, size_t> &p : g.tls)
 1064     for (const std::pair<Symbol *, size_t> &p : g.dynTlsSymbols) {
 1094 void GotPltSection::addEntry(Symbol &sym) {
 1106   for (const Symbol *b : entries) {
 1138 void IgotPltSection::addEntry(Symbol &sym) {
 1148   for (const Symbol *b : entries) {
 1239 void DynamicSection<ELFT>::addSym(int32_t tag, Symbol *sym) {
 1432     if (Symbol *b = symtab->find(config->init))
 1435     if (Symbol *b = symtab->find(config->fini))
 1464     if (const Symbol *b = in.mipsGot->getFirstGlobalEntry())
 1535                                      uint64_t offsetInSec, Symbol *sym) {
 1541                                      uint64_t offsetInSec, Symbol *sym,
 2054 void SymbolTableBaseSection::addSymbol(Symbol *b) {
 2062 size_t SymbolTableBaseSection::getSymbolIndex(Symbol *sym) {
 2092 static BssSection *getCommonSec(Symbol *sym) {
 2099 static uint32_t getSymSectionIndex(Symbol *sym) {
 2119     Symbol *sym = ent.sym;
 2173       Symbol *sym = ent.sym;
 2387     Symbol *b = ent.sym;
 2437     Symbol *sym = s.sym;
 2480     const Symbol *b = entries[i];
 2489 template <class ELFT> void PltSection::addEntry(Symbol &sym) {
 2942 void addVerneed(Symbol *ss) {
 3431 void PPC64LongBranchTargetSection::addEntry(Symbol &sym) {
 3448   for (const Symbol *sym : entries) {

  115   llvm::DenseMap<std::pair<ArrayRef<uint8_t>, Symbol *>, CieRecord *> cieMap;
  126   void addEntry(Symbol &sym);
  127   bool addDynTlsEntry(Symbol &sym);
  129   uint64_t getGlobalDynAddr(const Symbol &b) const;
  130   uint64_t getGlobalDynOffset(const Symbol &b) const;
  207   void addEntry(InputFile &file, Symbol &sym, int64_t addend, RelExpr expr);
  208   void addDynTlsEntry(InputFile &file, Symbol &sym);
  211   uint64_t getPageEntryOffset(const InputFile *f, const Symbol &s,
  213   uint64_t getSymEntryOffset(const InputFile *f, const Symbol &s,
  215   uint64_t getGlobalDynOffset(const InputFile *f, const Symbol &s) const;
  222   const Symbol *getFirstGlobalEntry() const;
  324   using GotEntry = std::pair<Symbol *, int64_t>;
  343     llvm::MapVector<Symbol *, size_t> global;
  344     llvm::MapVector<Symbol *, size_t> relocs;
  345     llvm::MapVector<Symbol *, size_t> tls;
  347     llvm::MapVector<Symbol *, size_t> dynTlsSymbols;
  374   void addEntry(Symbol &sym);
  384   std::vector<const Symbol *> entries;
  394   void addEntry(Symbol &sym);
  400   std::vector<const Symbol *> entries;
  423                uint64_t offsetInSec, bool useSymVA, Symbol *sym, int64_t addend)
  445   Symbol *sym;
  481   void addSym(int32_t tag, Symbol *sym);
  491                 Symbol *sym);
  495                 uint64_t offsetInSec, Symbol *sym, int64_t addend, RelExpr expr,
  575   Symbol *sym;
  584   void addSymbol(Symbol *sym);
  586   size_t getSymbolIndex(Symbol *sym);
  598   llvm::DenseMap<Symbol *, size_t> symbolIndexMap;
  642     Symbol *sym;
  676   template <class ELFT> void addEntry(Symbol &sym);
  681   std::vector<const Symbol *> entries;
 1065   void addEntry(Symbol &sym);
 1072   std::vector<const Symbol *> entries;
 1112 void addVerneed(Symbol *ss);

  133                             uint64_t branchAddr, const Symbol &s) const {
  146 void TargetInfo::writeIgotPlt(uint8_t *buf, const Symbol &s) const {

   29   virtual RelExpr getRelExpr(RelType type, const Symbol &s,
   34   virtual void writeGotPlt(uint8_t *buf, const Symbol &s) const {};
   35   virtual void writeIgotPlt(uint8_t *buf, const Symbol &s) const;
   61                           const Symbol &s) const;

   52   AArch64ABSLongThunk(Symbol &dest) : Thunk(dest) {}
   60   AArch64ADRPThunk(Symbol &dest) : Thunk(dest) {}
   76   ARMThunk(Symbol &dest) : Thunk(dest) {}
  106   ThumbThunk(Symbol &dest) : Thunk(dest) { alignment = 2; }
  129   ARMV7ABSLongThunk(Symbol &dest) : ARMThunk(dest) {}
  138   ARMV7PILongThunk(Symbol &dest) : ARMThunk(dest) {}
  147   ThumbV7ABSLongThunk(Symbol &dest) : ThumbThunk(dest) {}
  156   ThumbV7PILongThunk(Symbol &dest) : ThumbThunk(dest) {}
  170   ARMV5ABSLongThunk(Symbol &dest) : ARMThunk(dest) {}
  181   ARMV5PILongThunk(Symbol &dest) : ARMThunk(dest) {}
  193   ThumbV6MABSLongThunk(Symbol &dest) : ThumbThunk(dest) {}
  202   ThumbV6MPILongThunk(Symbol &dest) : ThumbThunk(dest) {}
  212   MipsThunk(Symbol &dest) : Thunk(dest) {}
  223   MicroMipsThunk(Symbol &dest) : Thunk(dest) {}
  234   MicroMipsR6Thunk(Symbol &dest) : Thunk(dest) {}
  244   PPC32PltCallStub(const InputSection &isec, const Relocation &rel, Symbol &dest)
  271   PPC64PltCallStub(Symbol &dest) : Thunk(dest) {}
  292   PPC64LongBranchThunk(Symbol &dest) : Thunk(dest) {}
  297   PPC64PILongBranchThunk(Symbol &dest) : PPC64LongBranchThunk(dest) {
  312   PPC64PDLongBranchThunk(Symbol &dest) : PPC64LongBranchThunk(dest) {
  335 static uint64_t getAArch64ThunkDestVA(const Symbol &s) {
  385 static uint64_t getARMThunkDestVA(const Symbol &s) {
  798 Thunk::Thunk(Symbol &d) : destination(d), offset(0) {}
  802 static Thunk *addThunkAArch64(RelType type, Symbol &s) {
  815 static Thunk *addThunkPreArmv7(RelType reloc, Symbol &s) {
  835 static Thunk *addThunkV6M(RelType reloc, Symbol &s) {
  849 static Thunk *addThunkArm(RelType reloc, Symbol &s) {
  890 static Thunk *addThunkMips(RelType type, Symbol &s) {
  898 static Thunk *addThunkPPC32(const InputSection &isec, const Relocation &rel, Symbol &s) {
  904 static Thunk *addThunkPPC64(RelType type, Symbol &s) {
  916   Symbol &s = *rel.sym;

   30   Thunk(Symbol &destination);
   60   Symbol &destination;

  201   Symbol *s = symtab->find(name);
  211   Symbol *sym = symtab->addSymbol(Defined{nullptr, name, STB_GLOBAL, STV_HIDDEN,
  255   if (Symbol *s = symtab->find(gotSymName)) {
  652 static bool includeInSymtab(const Symbol &b) {
  682     for (Symbol *b : f->getLocalSymbols()) {
 1247     for (Symbol *sym : file->getSymbols())
 1642 static bool computeIsPreemptible(const Symbol &b) {
 1722     Symbol *s = symtab->find("_TLS_MODULE_BASE_");
 1799     DenseSet<Symbol *> syms;
 2517   if (Symbol *b = symtab->find(config->entry))

   52 template <typename T, typename... U> T *make(U &&... args) {

   72     constexpr _Tp&&
   83     constexpr _Tp&&

  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
 1554     { typedef _Tp     type; };
 1558     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1633     { typedef _Tp   type; };
 1983     { typedef _Up     type; };