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

Derived Classes

  128 class Defined : public Symbol {
  266 class LazyArchive : public Symbol {
  279 class LazyObject : public Symbol {
  288 class Undefined : public Symbol {

Declarations

   40 class Symbol;

   30 class Symbol;

   54 class Symbol;

   34 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; }

   57   static inline bool doit(const From &Val) {
  104   static inline bool doit(const From *Val) {
  106     return isa_impl<To, From>::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);
  305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
  306 cast_or_null(Y *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 };
   91   typedef PointerLikeTypeTraits<T *> NonConst;
   93   static inline const void *getAsVoidPointer(const T *P) {
   96   static inline const T *getFromVoidPointer(const void *P) {

  459     Symbol *target = file->getSymbol(rel.SymbolTableIndex);

  187                               std::random_access_iterator_tag, Symbol *> {
  198     Symbol *operator*() const { return file->getSymbol(I->SymbolTableIndex); }

   43   Symbol *sym = nullptr;
   90   Symbol *entry = nullptr;
  116   std::vector<Symbol *> gcroot;
  128   Symbol *delayLoadHelper = nullptr;
  137   Symbol *sehTable = nullptr;
  138   Symbol *sehCount = nullptr;

  156   Symbol *s = symtab->findMangle(mangle(sym));
  506 Symbol *LinkerDriver::addUndefined(StringRef name) {
  507   Symbol *b = symtab->addUndefined(name);
  515 StringRef LinkerDriver::mangleMaybe(Symbol *s) {
  522   Symbol *mangled = symtab->findMangle(unmangled->getName());
  908 static void markAddrsig(Symbol *s) {
  923     ArrayRef<Symbol *> syms = obj->getSymbols();
  943       for (Symbol *s : syms)
 1805       Symbol *sym = symtab->find(from);
 1924     Symbol *sym = symtab->find(name);

  113   Symbol *addUndefined(StringRef sym);
  115   StringRef mangleMaybe(Symbol *s);

  153     Symbol *b1 = a->file->getSymbol(r1.SymbolTableIndex);
  154     Symbol *b2 = b->file->getSymbol(r2.SymbolTableIndex);
  179     Symbol *b1 = a->file->getSymbol(r1.SymbolTableIndex);
  180     Symbol *b2 = b->file->getSymbol(r2.SymbolTableIndex);
  274       for (Symbol *b : sc->symbols())

   78                                  Symbol *source, Symbol *target) {
   78                                  Symbol *source, Symbol *target) {
  379 Symbol *ObjFile::createRegular(COFFSymbolRef sym) {
  406   SmallVector<std::pair<Symbol *, uint32_t>, 8> weakAliases;
  423     } else if (Optional<Symbol *> optSym =
  461     Symbol *sym = kv.first;
  467 Symbol *ObjFile::createUndefined(COFFSymbolRef sym) {
  574 Optional<Symbol *> ObjFile::createDefined(
  881                          std::vector<Symbol *> &&symbols)
  902   std::vector<std::pair<Symbol *, bool>> comdat(obj->getComdatTable().size());
  910     Symbol *sym;
  919       Symbol *alias = symtab->addUndefined(saver.save(fallback));

  127   std::vector<Symbol *> symbols;
  134   explicit ObjFile(MemoryBufferRef m, std::vector<Symbol *> &&symbols)
  144   ArrayRef<Symbol *> getSymbols() { return symbols; }
  150   Symbol *getSymbol(uint32_t symbolIndex) {
  159   uint32_t addRangeThunkSymbol(Symbol *thunk) {
  256   llvm::Optional<Symbol *>
  261   Symbol *createRegular(COFFSymbolRef sym);
  262   Symbol *createUndefined(COFFSymbolRef sym);
  295   std::vector<Symbol *> symbols;
  311   Symbol *impSym = nullptr;
  312   Symbol *thunkSym = nullptr;
  343                        std::vector<Symbol *> &&symbols);
  345   ArrayRef<Symbol *> getSymbols() { return symbols; }
  353   std::vector<Symbol *> symbols;

  114 static void undefine(Symbol *s) { replaceSymbol<Undefined>(s, s->getName()); }
  119   std::vector<Symbol *> symBodies = f.getSymbols();
  127     Symbol *sym = symBodies[symNum];

   51     for (Symbol *b : file->getSymbols())

   54   for (Symbol *b : config->gcroot)
   62     for (Symbol *b : sc->symbols())

   66 static void forceLazy(Symbol *s) {
   69   case Symbol::Kind::LazyArchiveKind: {
   74   case Symbol::Kind::LazyObjectKind:
   86 static Symbol *getSymbol(SectionChunk *sc, uint32_t addr) {
   89   for (Symbol *s : sc->file->getSymbols()) {
  140     Symbol *sym;
  154       Symbol *sym = getSymbol(sc, r.VirtualAddress);
  193   Symbol *sym;
  226     Symbol *sym = i.second;
  241     Symbol *l = find(("__imp_" + name).str());
  257 bool SymbolTable::handleMinGWAutomaticImport(Symbol *sym, StringRef name) {
  311 reportProblemSymbols(const SmallPtrSetImpl<Symbol *> &undefs,
  312                      const DenseMap<Symbol *, Symbol *> *localImports,
  312                      const DenseMap<Symbol *, Symbol *> *localImports,
  321   for (Symbol *b : config->gcroot) {
  325       if (Symbol *imp = localImports->lookup(b))
  331   DenseMap<Symbol *, int> firstDiag;
  335     for (Symbol *sym : symbols) {
  349         if (Symbol *imp = localImports->lookup(sym))
  368   SmallPtrSet<Symbol *, 8> undefs;
  370     Symbol *sym = i.second;
  378       Symbol *imp = find(name.substr(strlen("__imp_")));
  395   SmallPtrSet<Symbol *, 8> undefs;
  396   DenseMap<Symbol *, Symbol *> localImports;
  396   DenseMap<Symbol *, Symbol *> localImports;
  399     Symbol *sym = i.second;
  427       Symbol *imp = find(name.substr(strlen("__imp_")));
  457 std::pair<Symbol *, bool> SymbolTable::insert(StringRef name) {
  459   Symbol *&sym = symMap[CachedHashStringRef(name)];
  469 std::pair<Symbol *, bool> SymbolTable::insert(StringRef name, InputFile *file) {
  470   std::pair<Symbol *, bool> result = insert(name);
  476 Symbol *SymbolTable::addUndefined(StringRef name, InputFile *f,
  478   Symbol *s;
  492   Symbol *s;
  507   Symbol *s;
  563 void SymbolTable::reportDuplicate(Symbol *existing, InputFile *newFile,
  586 Symbol *SymbolTable::addAbsolute(StringRef n, COFFSymbolRef sym) {
  587   Symbol *s;
  598 Symbol *SymbolTable::addAbsolute(StringRef n, uint64_t va) {
  599   Symbol *s;
  610 Symbol *SymbolTable::addSynthetic(StringRef n, Chunk *c) {
  611   Symbol *s;
  622 Symbol *SymbolTable::addRegular(InputFile *f, StringRef n,
  625   Symbol *s;
  639   Symbol *s;
  653 Symbol *SymbolTable::addCommon(InputFile *f, StringRef n, uint64_t size,
  655   Symbol *s;
  666 Symbol *SymbolTable::addImportData(StringRef n, ImportFile *f) {
  667   Symbol *s;
  680 Symbol *SymbolTable::addImportThunk(StringRef name, DefinedImportData *id,
  682   Symbol *s;
  696   Symbol *sym = findUnderscore(name);
  719 Symbol *SymbolTable::find(StringRef name) {
  723 Symbol *SymbolTable::findUnderscore(StringRef name) {
  731 std::vector<Symbol *> SymbolTable::getSymsWithPrefix(StringRef prefix) {
  732   std::vector<Symbol *> syms;
  744 Symbol *SymbolTable::findMangle(StringRef name) {
  745   if (Symbol *sym = find(name))
  753   std::vector<Symbol *> syms = getSymsWithPrefix(name);
  756     for (auto *s : syms)
  769   if (Symbol *s = findByPrefix(name + "@"))
  772   if (Symbol *s = findByPrefix("@" + name.substr(1) + "@"))
  775   if (Symbol *s = findByPrefix(name.substr(1) + "@@"))
  781 Symbol *SymbolTable::addUndefined(StringRef name) {

   61   bool handleMinGWAutomaticImport(Symbol *sym, StringRef name);
   67   Symbol *find(StringRef name);
   68   Symbol *findUnderscore(StringRef name);
   74   Symbol *findMangle(StringRef name);
   83   Symbol *addUndefined(StringRef name);
   85   Symbol *addSynthetic(StringRef n, Chunk *c);
   86   Symbol *addAbsolute(StringRef n, uint64_t va);
   88   Symbol *addUndefined(StringRef name, InputFile *f, bool isWeakAlias);
   91   Symbol *addAbsolute(StringRef n, COFFSymbolRef s);
   92   Symbol *addRegular(InputFile *f, StringRef n,
   98   Symbol *addCommon(InputFile *f, StringRef n, uint64_t size,
  101   Symbol *addImportData(StringRef n, ImportFile *f);
  102   Symbol *addImportThunk(StringRef name, DefinedImportData *s,
  106   void reportDuplicate(Symbol *existing, InputFile *newFile,
  124   std::pair<Symbol *, bool> insert(StringRef name);
  126   std::pair<Symbol *, bool> insert(StringRef name, InputFile *f);
  128   std::vector<Symbol *> getSymsWithPrefix(StringRef prefix);
  130   llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> symMap;

   46 std::string toString(coff::Symbol &b) {
   96 void Symbol::replaceKeepingName(Symbol *other, size_t size) {
  131   for (Symbol *a = weakAlias; a; a = cast<Undefined>(a)->weakAlias)

   25 std::string toString(coff::Symbol &b);
   74   void replaceKeepingName(Symbol *other, size_t size);
  128 class Defined : public Symbol {
  132   static bool classof(const Symbol *s) { return s->kind() <= LastDefinedKind; }
  154   static bool classof(const Symbol *s) {
  180   static bool classof(const Symbol *s) {
  200   static bool classof(const Symbol *s) {
  225   static bool classof(const Symbol *s) {
  248   static bool classof(const Symbol *s) {
  266 class LazyArchive : public Symbol {
  271   static bool classof(const Symbol *s) { return s->kind() == LazyArchiveKind; }
  279 class LazyObject : public Symbol {
  283   static bool classof(const Symbol *s) { return s->kind() == LazyObjectKind; }
  288 class Undefined : public Symbol {
  292   static bool classof(const Symbol *s) { return s->kind() == UndefinedKind; }
  298   Symbol *weakAlias = nullptr;
  318   static bool classof(const Symbol *s) {
  342   static bool classof(const Symbol *s) {
  365   static bool classof(const Symbol *s) {
  441 void replaceSymbol(Symbol *s, ArgT &&... arg) {

  423       Symbol *relocTarget = file->getSymbol(rel.SymbolTableIndex);
  508       Symbol *relocTarget = sc->file->getSymbol(rel.SymbolTableIndex);
 1086   case Symbol::DefinedAbsoluteKind:
 1090   case Symbol::DefinedSyntheticKind:
 1156       for (Symbol *b : file->getSymbols()) {
 1403   if (Symbol *sym = symtab->findUnderscore("_tls_used")) {
 1415   if (Symbol *sym = symtab->findUnderscore("_load_config_used")) {
 1501                                          Symbol *s) {
 1506   case Symbol::DefinedLocalImportKind:
 1507   case Symbol::DefinedImportDataKind:
 1510   case Symbol::DefinedCommonKind:
 1513   case Symbol::DefinedAbsoluteKind:
 1514   case Symbol::DefinedSyntheticKind:
 1518   case Symbol::LazyArchiveKind:
 1519   case Symbol::LazyObjectKind:
 1520   case Symbol::UndefinedKind:
 1525   case Symbol::DefinedImportThunkKind:
 1530   case Symbol::DefinedRegularKind: {
 1563       Symbol *ref = sc->file->getSymbol(reloc.SymbolTableIndex);
 1616   Symbol *flagSym = symtab->findUnderscore("__guard_flags");
 1646     ArrayRef<Symbol *> objSymbols = file->getSymbols();
 1653       if (Symbol *s = objSymbols[symIndex]) {
 1672   Symbol *t = symtab->findUnderscore(tableSym);
 1673   Symbol *c = symtab->findUnderscore(countSym);
 1699   Symbol *headSym = symtab->findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST__");
 1700   Symbol *endSym = symtab->findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST_END__");
 1720   Symbol *ctorListSym = symtab->findUnderscore("__CTOR_LIST__");
 1721   Symbol *dtorListSym = symtab->findUnderscore("__DTOR_LIST__");

 1983     { typedef _Up     type; };