contrib/llvm/tools/lld/ELF/SymbolTable.h

   1 //===- SymbolTable.h --------------------------------------------*- C++ -*-===//
   2 //
   3 //                             The LLVM Linker
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLD_ELF_SYMBOL_TABLE_H
  11 #define LLD_ELF_SYMBOL_TABLE_H
  12
  13 #include "InputFiles.h"
  14 #include "LTO.h"
  15 #include "lld/Common/Strings.h"
  16 #include "llvm/ADT/CachedHashString.h"
  17 #include "llvm/ADT/DenseMap.h"
  18
  19 namespace lld {
  20 namespace elf {
  21 class Defined;
  22 class SectionBase;
  23
  24 // SymbolTable is a bucket of all known symbols, including defined,
  25 // undefined, or lazy symbols (the last one is symbols in archive
  26 // files whose archive members are not yet loaded).
  27 //
  28 // We put all symbols of all files to a SymbolTable, and the
  29 // SymbolTable selects the "best" symbols if there are name
  30 // conflicts. For example, obviously, a defined symbol is better than
  31 // an undefined symbol. Or, if there's a conflict between a lazy and a
  32 // undefined, it'll read an archive member to read a real definition
  33 // to replace the lazy symbol. The logic is implemented in the
  34 // add*() functions, which are called by input files as they are parsed. There
  35 // is one add* function per symbol type.
  36 class SymbolTable {
  37 public:
  38   template <class ELFT> void addFile(InputFile *File);
  39   template <class ELFT> void addCombinedLTOObject();
  40   void wrap(Symbol *Sym, Symbol *Real, Symbol *Wrap);
  41
  42   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
  43
  44   template <class ELFT>
  45   Symbol *addUndefined(StringRef Name, uint8_t Binding, uint8_t StOther,
  46                        uint8_t Type, bool CanOmitFromDynSym, InputFile *File);
  47
  48   Defined *addDefined(StringRef Name, uint8_t StOther, uint8_t Type,
  49                       uint64_t Value, uint64_t Size, uint8_t Binding,
  50                       SectionBase *Section, InputFile *File);
  51
  52   template <class ELFT>
  53   void addShared(StringRef Name, SharedFile<ELFT> &F,
  54                  const typename ELFT::Sym &Sym, uint32_t Alignment,
  55                  uint32_t VerdefIndex);
  56
  57   template <class ELFT>
  58   void addLazyArchive(StringRef Name, ArchiveFile &F,
  59                       const llvm::object::Archive::Symbol S);
  60
  61   template <class ELFT> void addLazyObject(StringRef Name, LazyObjFile &Obj);
  62
  63   Symbol *addBitcode(StringRef Name, uint8_t Binding, uint8_t StOther,
  64                      uint8_t Type, bool CanOmitFromDynSym, BitcodeFile &File);
  65
  66   Symbol *addCommon(StringRef Name, uint64_t Size, uint32_t Alignment,
  67                     uint8_t Binding, uint8_t StOther, uint8_t Type,
  68                     InputFile &File);
  69
  70   std::pair<Symbol *, bool> insert(StringRef Name, uint8_t Visibility,
  71                                    bool CanOmitFromDynSym, InputFile *File);
  72
  73   template <class ELFT> void fetchLazy(Symbol *Sym);
  74
  75   void scanVersionScript();
  76
  77   Symbol *find(StringRef Name);
  78
  79   void trace(StringRef Name);
  80
  81   void handleDynamicList();
  82
  83   // Set of .so files to not link the same shared object file more than once.
  84   llvm::DenseMap<StringRef, InputFile *> SoNames;
  85
  86 private:
  87   std::pair<Symbol *, bool> insertName(StringRef Name);
  88
  89   std::vector<Symbol *> findByVersion(SymbolVersion Ver);
  90   std::vector<Symbol *> findAllByVersion(SymbolVersion Ver);
  91
  92   llvm::StringMap<std::vector<Symbol *>> &getDemangledSyms();
  93   void assignExactVersion(SymbolVersion Ver, uint16_t VersionId,
  94                           StringRef VersionName);
  95   void assignWildcardVersion(SymbolVersion Ver, uint16_t VersionId);
  96
  97   // The order the global symbols are in is not defined. We can use an arbitrary
  98   // order, but it has to be reproducible. That is true even when cross linking.
  99   // The default hashing of StringRef produces different results on 32 and 64
 100   // bit systems so we use a map to a vector. That is arbitrary, deterministic
 101   // but a bit inefficient.
 102   // FIXME: Experiment with passing in a custom hashing or sorting the symbols
 103   // once symbol resolution is finished.
 104   llvm::DenseMap<llvm::CachedHashStringRef, int> SymMap;
 105   std::vector<Symbol *> SymVector;
 106
 107   // Comdat groups define "link once" sections. If two comdat groups have the
 108   // same name, only one of them is linked, and the other is ignored. This set
 109   // is used to uniquify them.
 110   llvm::DenseSet<llvm::CachedHashStringRef> ComdatGroups;
 111
 112   // A map from demangled symbol names to their symbol objects.
 113   // This mapping is 1:N because two symbols with different versions
 114   // can have the same name. We use this map to handle "extern C++ {}"
 115   // directive in version scripts.
 116   llvm::Optional<llvm::StringMap<std::vector<Symbol *>>> DemangledSyms;
 117
 118   // For LTO.
 119   std::unique_ptr<BitcodeCompiler> LTO;
 120 };
 121
 122 extern SymbolTable *Symtab;
 123 } // namespace elf
 124 } // namespace lld
 125
 126 #endif