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

Derived Classes

include/llvm/Object/ELFObjectFile.h
  136 class ELFSymbolRef : public SymbolRef {

Declarations

include/llvm/ExecutionEngine/JITSymbol.h
   36 class SymbolRef;
include/llvm/Object/ObjectFile.h
   44 class SymbolRef;
tools/llvm-readobj/Win64EHDumper.h
   18 class SymbolRef;

References

include/llvm/ExecutionEngine/JITSymbol.h
  149   fromObjectSymbol(const object::SymbolRef &Symbol);
  183   static ARMJITSymbolFlags fromObjectSymbol(const object::SymbolRef &Symbol);
include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h
  292         if (Symbol.getFlags() & object::SymbolRef::SF_Undefined)
include/llvm/Object/COFF.h
  900   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
  935   COFFSymbolRef getCOFFSymbol(const SymbolRef &Symbol) const;
  938   unsigned getSymbolSectionID(SymbolRef Sym) const;
include/llvm/Object/COFFImportFile.h
   47     return SymbolRef::SF_Global;
include/llvm/Object/ELFObjectFile.h
  136 class ELFSymbolRef : public SymbolRef {
  138   ELFSymbolRef(const SymbolRef &B) : SymbolRef(B) {
  268   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
  586 Expected<SymbolRef::Type>
  592     return SymbolRef::ST_Unknown;
  594     return SymbolRef::ST_Debug;
  596     return SymbolRef::ST_File;
  598     return SymbolRef::ST_Function;
  602     return SymbolRef::ST_Data;
  604     return SymbolRef::ST_Other;
  612   uint32_t Result = SymbolRef::SF_None;
  615     Result |= SymbolRef::SF_Global;
  618     Result |= SymbolRef::SF_Weak;
  621     Result |= SymbolRef::SF_Absolute;
  624     Result |= SymbolRef::SF_FormatSpecific;
  628     Result |= SymbolRef::SF_FormatSpecific;
  631     Result |= SymbolRef::SF_FormatSpecific;
  638         Result |= SymbolRef::SF_FormatSpecific;
  644       Result |= SymbolRef::SF_Thumb;
  648     Result |= SymbolRef::SF_Undefined;
  651     Result |= SymbolRef::SF_Common;
  654     Result |= SymbolRef::SF_Exported;
  657     Result |= SymbolRef::SF_Hidden;
  883   return symbol_iterator(SymbolRef(SymbolData, this));
 1005   return basic_symbol_iterator(SymbolRef(Sym, this));
 1014   return basic_symbol_iterator(SymbolRef(Sym, this));
 1020   return symbol_iterator(SymbolRef(Sym, this));
 1029   return basic_symbol_iterator(SymbolRef(Sym, this));
include/llvm/Object/MachO.h
  289   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
  292   unsigned getSymbolSectionID(SymbolRef Symb) const;
include/llvm/Object/ObjectFile.h
  126   bool containsSymbol(SymbolRef S) const;
  191   Expected<SymbolRef::Type> getType() const;
  202   symbol_iterator(SymbolRef Sym) : basic_symbol_iterator(Sym) {}
  207   const SymbolRef *operator->() const {
  212   const SymbolRef &operator*() const {
  248   virtual Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const = 0;
  399 inline Expected<SymbolRef::Type> SymbolRef::getType() const {
include/llvm/Object/SymbolSize.h
   27 std::vector<std::pair<SymbolRef, uint64_t>>
include/llvm/Object/Wasm.h
  125   const WasmSymbol &getWasmSymbol(const SymbolRef &Symbol) const;
  169   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
include/llvm/Object/XCOFFObjectFile.h
  245   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
include/llvm/Support/AlignOf.h
   30   T t;
   39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
   50       llvm::detail::SizerImpl<T, Ts...>)];
include/llvm/Support/ErrorOr.h
   59   static const bool isRef = std::is_reference<T>::value;
   61   using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
   64   using storage_type = typename std::conditional<isRef, wrap, T>::type;
   67   using reference = typename std::remove_reference<T>::type &;
   68   using const_reference = const typename std::remove_reference<T>::type &;
   69   using pointer = typename std::remove_reference<T>::type *;
   70   using const_pointer = const typename std::remove_reference<T>::type *;
   87   ErrorOr(OtherT &&Val,
   88           typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
  100       const ErrorOr<OtherT> &Other,
  101       typename std::enable_if<std::is_convertible<OtherT, T>::value>::type * =
  101       typename std::enable_if<std::is_convertible<OtherT, T>::value>::type * =
  120       ErrorOr<OtherT> &&Other,
  121       typename std::enable_if<std::is_convertible<OtherT, T>::value>::type * =
  121       typename std::enable_if<std::is_convertible<OtherT, T>::value>::type * =
  209   void moveConstruct(ErrorOr<OtherT> &&Other) {
  222   void moveAssign(ErrorOr<OtherT> &&Other) {
lib/DebugInfo/DWARF/DWARFContext.cpp
 1290                                        std::map<SymbolRef, SymInfo> &Cache) {
 1295   std::map<SymbolRef, SymInfo>::iterator CacheIt = Cache.end();
 1644       std::map<SymbolRef, SymInfo> AddrCache;
lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp
   72   std::vector<std::pair<SymbolRef, uint64_t>> Symbols =
  160 std::error_code SymbolizableObjectFile::addSymbol(const SymbolRef &Symbol,
  169   Expected<SymbolRef::Type> SymbolTypeOrErr = Symbol.getType();
  172   SymbolRef::Type SymbolType = *SymbolTypeOrErr;
  173   if (SymbolType != SymbolRef::ST_Function && SymbolType != SymbolRef::ST_Data)
  173   if (SymbolType != SymbolRef::ST_Function && SymbolType != SymbolRef::ST_Data)
  204   auto &M = SymbolType == SymbolRef::ST_Function ? Functions : Objects;
  222 bool SymbolizableObjectFile::getNameFromSymbolTable(SymbolRef::Type Type,
  227   const auto &Symbols = Type == SymbolRef::ST_Function ? Functions : Objects;
  266     if (getNameFromSymbolTable(SymbolRef::ST_Function, ModuleOffset.Address,
  291     if (getNameFromSymbolTable(SymbolRef::ST_Function, ModuleOffset.Address,
  304   getNameFromSymbolTable(SymbolRef::ST_Data, ModuleOffset.Address, Res.Name,
lib/DebugInfo/Symbolize/SymbolizableObjectFile.h
   58   bool getNameFromSymbolTable(object::SymbolRef::Type Type, uint64_t Address,
   63   std::error_code addSymbol(const object::SymbolRef &Symbol,
lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp
   40 llvm::JITSymbolFlags::fromObjectSymbol(const object::SymbolRef &Symbol) {
   53   if (*SymbolType & object::SymbolRef::ST_Function)
   60 llvm::ARMJITSymbolFlags::fromObjectSymbol(const object::SymbolRef &Symbol) {
lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
  170 static Error getOffset(const SymbolRef &Sym, SectionRef Sec,
  218       if ((Flags & SymbolRef::SF_Common) || (Flags & SymbolRef::SF_Weak)) {
  218       if ((Flags & SymbolRef::SF_Common) || (Flags & SymbolRef::SF_Weak)) {
  240     if (Flags & SymbolRef::SF_Undefined)
  244     object::SymbolRef::Type SymType;
  290     if (Flags & SymbolRef::SF_Absolute &&
  291         SymType != object::SymbolRef::ST_File) {
  305     } else if (SymType == object::SymbolRef::ST_Function ||
  306                SymType == object::SymbolRef::ST_Data ||
  307                SymType == object::SymbolRef::ST_Unknown ||
  308                SymType == object::SymbolRef::ST_Other) {
  596     if (Flags & SymbolRef::SF_Common) {
  713 RuntimeDyldImpl::getJITSymbolFlags(const SymbolRef &SR) {
  740   for (auto &Sym : SymbolsToAllocate) {
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.cpp
   73 uint64_t RuntimeDyldCOFF::getSymbolOffset(const SymbolRef &Sym) {
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCOFF.h
   41   uint64_t getSymbolOffset(const SymbolRef &Sym);
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
   77   void updateSymbolAddress(const SymbolRef &SymRef, uint64_t Addr);
  124 void DyldELFObject<ELFT>::updateSymbolAddress(const SymbolRef &SymRef,
 1133   SymbolRef::Type SymType = SymbolRef::ST_Unknown;
 1133   SymbolRef::Type SymType = SymbolRef::ST_Unknown;
 1139     Expected<SymbolRef::Type> SymTypeOrErr = Symbol->getType();
 1156     case SymbolRef::ST_Debug: {
 1181     case SymbolRef::ST_Data:
 1182     case SymbolRef::ST_Function:
 1183     case SymbolRef::ST_Unknown: {
 1456       bool IsExtern = Value.SymbolName || SymType == SymbolRef::ST_Unknown;
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h
  268   typedef std::vector<SymbolRef> CommonSymbolList;
  364   virtual Expected<JITSymbolFlags> getJITSymbolFlags(const SymbolRef &Sym);
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFThumb.h
   27   Expected<object::SymbolRef::Type> SymTypeOrErr = Symbol->getType();
   36   if (*SymTypeOrErr != object::SymbolRef::ST_Function)
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h
   36   Expected<JITSymbolFlags> getJITSymbolFlags(const SymbolRef &SR) override {
lib/Object/ArchiveWriter.cpp
  267   if (Symflags & object::SymbolRef::SF_FormatSpecific)
  269   if (!(Symflags & object::SymbolRef::SF_Global))
  271   if (Symflags & object::SymbolRef::SF_Undefined)
lib/Object/COFFObjectFile.cpp
  189 Expected<SymbolRef::Type> COFFObjectFile::getSymbolType(DataRefImpl Ref) const {
  194     return SymbolRef::ST_Function;
  196     return SymbolRef::ST_Unknown;
  198     return SymbolRef::ST_Data;
  200     return SymbolRef::ST_File;
  204     return SymbolRef::ST_Debug;
  207     return SymbolRef::ST_Data;
  209   return SymbolRef::ST_Other;
  214   uint32_t Result = SymbolRef::SF_None;
  217     Result |= SymbolRef::SF_Global;
  220     Result |= SymbolRef::SF_Weak;
  222       Result |= SymbolRef::SF_Undefined;
  226     Result |= SymbolRef::SF_Absolute;
  229     Result |= SymbolRef::SF_FormatSpecific;
  232     Result |= SymbolRef::SF_FormatSpecific;
  235     Result |= SymbolRef::SF_Common;
  238     Result |= SymbolRef::SF_Undefined;
  261 unsigned COFFObjectFile::getSymbolSectionID(SymbolRef Sym) const {
 1162 COFFSymbolRef COFFObjectFile::getCOFFSymbol(const SymbolRef &Symbol) const {
lib/Object/MachOObjectFile.cpp
 1690   for (const SymbolRef &Symbol : symbols()) {
 1804   if (flags & SymbolRef::SF_Common) {
 1815 Expected<SymbolRef::Type>
 1822     return SymbolRef::ST_Debug;
 1826       return SymbolRef::ST_Unknown;
 1833         return SymbolRef::ST_Data;
 1834       return SymbolRef::ST_Function;
 1836   return SymbolRef::ST_Other;
 1845   uint32_t Result = SymbolRef::SF_None;
 1848     Result |= SymbolRef::SF_Indirect;
 1851     Result |= SymbolRef::SF_FormatSpecific;
 1854     Result |= SymbolRef::SF_Global;
 1857         Result |= SymbolRef::SF_Common;
 1859         Result |= SymbolRef::SF_Undefined;
 1863       Result |= SymbolRef::SF_Exported;
 1867     Result |= SymbolRef::SF_Weak;
 1870     Result |= SymbolRef::SF_Thumb;
 1873     Result |= SymbolRef::SF_Absolute;
 1894 unsigned MachOObjectFile::getSymbolSectionID(SymbolRef Sym) const {
lib/Object/ObjectFile.cpp
   40 bool SectionRef::containsSymbol(SymbolRef S) const {
   52   if (Flags & SymbolRef::SF_Undefined)
   54   if (Flags & SymbolRef::SF_Common)
lib/Object/SymbolSize.cpp
   33 static unsigned getSymbolSectionID(const ObjectFile &O, SymbolRef Sym) {
   39 std::vector<std::pair<SymbolRef, uint64_t>>
   41   std::vector<std::pair<SymbolRef, uint64_t>> Ret;
   57     SymbolRef Sym = *I;
lib/Object/WasmObjectFile.cpp
 1251   uint32_t Result = SymbolRef::SF_None;
 1256     Result |= SymbolRef::SF_Weak;
 1258     Result |= SymbolRef::SF_Global;
 1260     Result |= SymbolRef::SF_Hidden;
 1262     Result |= SymbolRef::SF_Undefined;
 1264     Result |= SymbolRef::SF_Executable;
 1286 const WasmSymbol &WasmObjectFile::getWasmSymbol(const SymbolRef &Symb) const {
 1337 Expected<SymbolRef::Type>
 1343     return SymbolRef::ST_Function;
 1345     return SymbolRef::ST_Other;
 1347     return SymbolRef::ST_Data;
 1349     return SymbolRef::ST_Debug;
 1351     return SymbolRef::ST_Other;
 1355   return SymbolRef::ST_Other;
lib/Object/XCOFFObjectFile.cpp
  195 Expected<SymbolRef::Type>
  198   return SymbolRef::ST_Other;
tools/dsymutil/DebugMap.cpp
  255       for (const auto &Sym : Object->symbols()) {
  259                       (SymbolRef::SF_Absolute | SymbolRef::SF_Common))) {
  259                       (SymbolRef::SF_Absolute | SymbolRef::SF_Common))) {
tools/dsymutil/MachODebugMapParser.cpp
  194   for (const SymbolRef &Symbol : MainBinary.symbols()) {
  322   for (const SymbolRef &Symbol : MainBinary.symbols()) {
  479   for (auto Sym : Obj.symbols()) {
  496     if (Flags & SymbolRef::SF_Absolute) {
  498     } else if (Flags & SymbolRef::SF_Common) {
  534   for (const auto &Sym : MainBinary.symbols()) {
  535     Expected<SymbolRef::Type> TypeOrErr = Sym.getType();
  541     SymbolRef::Type Type = *TypeOrErr;
  543     if ((Type == SymbolRef::ST_Debug) || (Type == SymbolRef::ST_Unknown))
  543     if ((Type == SymbolRef::ST_Debug) || (Type == SymbolRef::ST_Unknown))
tools/dsymutil/MachOUtils.cpp
  200     for (const object::SymbolRef &Symbol : Obj.symbols()) {
  207     for (const object::SymbolRef &Symbol : Obj.symbols()) {
tools/lld/wasm/InputFiles.cpp
  349   for (const SymbolRef &sym : wasmObj->symbols()) {
tools/llvm-cfi-verify/lib/FileAnalysis.cpp
  569       object::SymbolRef Sym(Addr.first, Object);
tools/llvm-cxxdump/llvm-cxxdump.cpp
  188   std::vector<std::pair<SymbolRef, uint64_t>> SymAddr =
  192     object::SymbolRef Sym = P.first;
tools/llvm-nm/llvm-nm.cpp
  310     ADefined = !(A.Sym.getFlags() & SymbolRef::SF_Undefined);
  315     BDefined = !(B.Sym.getFlags() & SymbolRef::SF_Undefined);
  370     if (SymFlags & SymbolRef::SF_Global)
  372     if (SymFlags & SymbolRef::SF_Hidden)
  374     if (SymFlags & SymbolRef::SF_Undefined)
  381       if (SymFlags & SymbolRef::SF_Const)
  383       else if (SymFlags & SymbolRef::SF_Executable)
  388     if (SymFlags & SymbolRef::SF_Weak)
  807     bool Undefined = SymFlags & SymbolRef::SF_Undefined;
  808     bool Global = SymFlags & SymbolRef::SF_Global;
  809     bool Weak = SymFlags & SymbolRef::SF_Weak;
 1046   if (Flags & SymbolRef::SF_Executable)
 1055   if (Flags & SymbolRef::SF_Executable)
 1058            (Flags & SymbolRef::SF_Const))
 1086     if (Symflags & object::SymbolRef::SF_Absolute)
 1088     else if (Symflags & object::SymbolRef::SF_Common)
 1090     else if (Symflags & object::SymbolRef::SF_Undefined)
 1112   if ((Symflags & object::SymbolRef::SF_Weak) && !isa<MachOObjectFile>(Obj)) {
 1114     return (!(Symflags & object::SymbolRef::SF_Undefined)) ? toupper(Ret) : Ret;
 1117   if (Symflags & object::SymbolRef::SF_Undefined)
 1120   if (Symflags & object::SymbolRef::SF_Common)
 1124   if (Symflags & object::SymbolRef::SF_Absolute)
 1139   if (!(Symflags & object::SymbolRef::SF_Global))
 1212       if (!DebugSyms && (SymFlags & SymbolRef::SF_FormatSpecific))
 1214       if (WithoutAliases && (SymFlags & SymbolRef::SF_Indirect))
 1227         SymbolRef SymRef(Sym);
 1326           S.SymFlags = SymbolRef::SF_Global;
 1424             U.SymFlags = SymbolRef::SF_Global | SymbolRef::SF_Undefined;
 1424             U.SymFlags = SymbolRef::SF_Global | SymbolRef::SF_Undefined;
 1486           B.SymFlags = SymbolRef::SF_Global | SymbolRef::SF_Undefined;
 1486           B.SymFlags = SymbolRef::SF_Global | SymbolRef::SF_Undefined;
 1545           L.SymFlags = SymbolRef::SF_Global | SymbolRef::SF_Undefined;
 1545           L.SymFlags = SymbolRef::SF_Global | SymbolRef::SF_Undefined;
 1608           W.SymFlags = SymbolRef::SF_Global | SymbolRef::SF_Undefined;
 1608           W.SymFlags = SymbolRef::SF_Global | SymbolRef::SF_Undefined;
tools/llvm-objcopy/MachO/MachOReader.cpp
  191   for (auto Symbol : MachOObj.symbols()) {
tools/llvm-objdump/COFFDump.cpp
  159                                       const SymbolRef &Sym,
  176                                      uint64_t Offset, SymbolRef &Sym) {
  195   SymbolRef Sym;
  209   SymbolRef Sym;
tools/llvm-objdump/MachODump.cpp
  237   bool operator()(const SymbolRef &A, const SymbolRef &B) {
  237   bool operator()(const SymbolRef &A, const SymbolRef &B) {
  238     Expected<SymbolRef::Type> ATypeOrErr = A.getType();
  241     SymbolRef::Type AType = *ATypeOrErr;
  242     Expected<SymbolRef::Type> BTypeOrErr = B.getType();
  245     SymbolRef::Type BType = *BTypeOrErr;
  246     uint64_t AAddr = (AType != SymbolRef::ST_Function) ? 0 : A.getValue();
  247     uint64_t BAddr = (BType != SymbolRef::ST_Function) ? 0 : B.getValue();
  365                                   std::vector<SymbolRef> &Symbols,
  369   for (const SymbolRef &Symbol : MachOObj->symbols()) {
  439     for (const SymbolRef &Symbol : O->symbols()) {
  724         SymbolRef Symbol = *Sym;
  989             SymbolRef Symbol = *O->getSymbolByIndex(r_symbolnum);
 1278   for (const SymbolRef &Symbol : O->symbols()) {
 1279     SymbolRef::Type ST = unwrapOrError(Symbol.getType(), FileName);
 1280     if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data ||
 1280     if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data ||
 1281         ST == SymbolRef::ST_Other) {
 1473   std::vector<std::pair<uint64_t, SymbolRef>> Relocs;
 1623   std::vector<std::pair<uint64_t, SymbolRef>> Relocs;
 2635     SymbolRef Symbol;
 2709       SymbolRef Symbol;
 2747     SymbolRef Symbol;
 2812     SymbolRef Symbol;
 3339   SymbolRef Symbol;
 6890     SymbolRef Symbol;
 7304   std::vector<SymbolRef> Symbols;
 7455     for (const SymbolRef &Symbol : MachOOF->symbols()) {
 7456       SymbolRef::Type ST =
 7458       if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data ||
 7458       if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data ||
 7459           ST == SymbolRef::ST_Other) {
 7501       SymbolRef::Type ST =
 7503       if (ST != SymbolRef::ST_Function && ST != SymbolRef::ST_Data)
 7503       if (ST != SymbolRef::ST_Function && ST != SymbolRef::ST_Data)
 7555         SymbolRef::Type NextSymType = unwrapOrError(
 7557         if (NextSymType == SymbolRef::ST_Function) {
 7573       bool IsThumb = MachOOF->getSymbolFlags(Symb) & SymbolRef::SF_Thumb;
 7815                                       std::map<uint64_t, SymbolRef> &Symbols,
 7865                                  std::map<uint64_t, SymbolRef> &Symbols,
 7882                                std::map<uint64_t, SymbolRef> &Symbols,
 8026                                         std::map<uint64_t, SymbolRef> &Symbols,
 8205   std::map<uint64_t, SymbolRef> Symbols;
 8206   for (const SymbolRef &SymRef : Obj->symbols()) {
tools/llvm-objdump/llvm-objdump.cpp
  890 static uint8_t getElfSymbolType(const ObjectFile *Obj, const SymbolRef &Sym) {
  963       SymbolRef Symbol(PltEntry.first, ElfObj);
 1137   for (const SymbolRef &Symbol : Obj->symbols()) {
 1808     const SymbolRef &Symbol = *I;
 1813     SymbolRef::Type Type = unwrapOrError(Symbol.getType(), FileName,
 1819     if (Type == SymbolRef::ST_Debug && Section != O->section_end()) {
 1830     bool Global = Flags & SymbolRef::SF_Global;
 1831     bool Weak = Flags & SymbolRef::SF_Weak;
 1832     bool Absolute = Flags & SymbolRef::SF_Absolute;
 1833     bool Common = Flags & SymbolRef::SF_Common;
 1834     bool Hidden = Flags & SymbolRef::SF_Hidden;
 1837     if (Type != SymbolRef::ST_Unknown)
 1839     char Debug = (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File)
 1839     char Debug = (Type == SymbolRef::ST_Debug || Type == SymbolRef::ST_File)
 1842     if (Type == SymbolRef::ST_File)
 1844     else if (Type == SymbolRef::ST_Function)
 1846     else if (Type == SymbolRef::ST_Data)
tools/llvm-readobj/ARMWinEHPrinter.cpp
  223 ErrorOr<object::SymbolRef> Decoder::getSymbol(const COFFObjectFile &COFF,
  225   for (const auto &Symbol : COFF.symbols()) {
  226     Expected<SymbolRef::Type> Type = Symbol.getType();
  229     if (FunctionOnly && *Type != SymbolRef::ST_Function)
  241 ErrorOr<SymbolRef> Decoder::getRelocatedSymbol(const COFFObjectFile &,
  893     ErrorOr<SymbolRef> Symbol = getRelocatedSymbol(
  926   ErrorOr<SymbolRef> Function = getRelocatedSymbol(COFF, Section, Offset);
  930   ErrorOr<SymbolRef> XDataRecord = getRelocatedSymbol(COFF, Section, Offset + 4);
 1018   ErrorOr<SymbolRef> Function = getRelocatedSymbol(COFF, Section, Offset);
tools/llvm-readobj/ARMWinEHPrinter.h
  132   ErrorOr<object::SymbolRef>
  136   ErrorOr<object::SymbolRef>
tools/llvm-readobj/COFFDumper.cpp
  110   void printSymbol(const SymbolRef &Sym);
  164                                 SymbolRef &Sym);
  259                                           uint64_t Offset, SymbolRef &Sym) {
  282   SymbolRef Symbol;
 1349       for (const SymbolRef &Symbol : Obj->symbols()) {
 1428   for (const SymbolRef &Symbol : Obj->symbols())
 1448 void COFFDumper::printSymbol(const SymbolRef &Sym) {
tools/llvm-readobj/ELFDumper.cpp
 4721   SymbolRef FuncSym;
tools/llvm-readobj/MachODumper.cpp
   55   void printSymbol(const SymbolRef &Symbol);
  500       for (const SymbolRef &Symbol : Obj->symbols()) {
  610   for (const SymbolRef &Symbol : Obj->symbols()) {
  619 void MachODumper::printSymbol(const SymbolRef &Symbol) {
tools/llvm-readobj/WasmDumper.cpp
   70   void printSymbol(const SymbolRef &Sym);
  161   for (const SymbolRef &Symbol : Obj->symbols())
  222 void WasmDumper::printSymbol(const SymbolRef &Sym) {
tools/llvm-readobj/Win64EHDumper.cpp
  120   SymbolRef Symbol;
  145   SymbolRef Symbol;
tools/llvm-readobj/Win64EHDumper.h
   29                                             uint64_t, object::SymbolRef &,
tools/llvm-readobj/XCOFFDumper.cpp
   51   void printSymbol(const SymbolRef &);
  318 void XCOFFDumper::printSymbol(const SymbolRef &S) {
  426   for (const SymbolRef &S : Obj.symbols())
tools/llvm-rtdyld/llvm-rtdyld.cpp
  417     std::vector<std::pair<SymbolRef, uint64_t>> SymAddr =
  422       object::SymbolRef Sym = P.first;
  423       Expected<SymbolRef::Type> TypeOrErr = Sym.getType();
  429       SymbolRef::Type Type = *TypeOrErr;
  430       if (Type == object::SymbolRef::ST_Function) {
tools/llvm-size/llvm-size.cpp
  202     if (Obj->getSymbolFlags(Sym.getRawDataRefImpl()) & SymbolRef::SF_Common)
tools/obj2yaml/coff2yaml.cpp
  143   for (const auto &S : Obj.symbols()) {
  281   for (const auto &S : Obj.symbols()) {
tools/obj2yaml/macho2yaml.cpp
  481   for (auto Symbol : Obj.symbols()) {
tools/obj2yaml/xcoff2yaml.cpp
   56   for (const SymbolRef &S : Obj.symbols()) {
tools/sancov/sancov.cpp
  626               object::SymbolRef Symbol = *(O.getSymbolByIndex(IndirectSymbol));
  649   for (const object::SymbolRef &Symbol : O.symbols()) {
usr/include/c++/7.4.0/bits/alloc_traits.h
  387       using allocator_type = allocator<_Tp>;
  389       using value_type = _Tp;
  392       using pointer = _Tp*;
  395       using const_pointer = const _Tp*;
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  486 	destroy(allocator_type& __a, _Up* __p)
usr/include/c++/7.4.0/bits/allocator.h
  108     class allocator: public __allocator_base<_Tp>
  113       typedef _Tp*       pointer;
  114       typedef const _Tp* const_pointer;
  115       typedef _Tp&       reference;
  116       typedef const _Tp& const_reference;
  117       typedef _Tp        value_type;
  137 	allocator(const allocator<_Tp1>&) throw() { }
usr/include/c++/7.4.0/bits/move.h
   46     inline _GLIBCXX_CONSTEXPR _Tp*
   47     __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
   72     constexpr _Tp&&
   73     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
   83     constexpr _Tp&&
   84     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
   98     move(_Tp&& __t) noexcept
  104     : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
  105                     is_copy_constructible<_Tp>>::type { };
  184     typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
  185 			      is_move_constructible<_Tp>,
  186 			      is_move_assignable<_Tp>>::value>::type
  187     swap(_Tp& __a, _Tp& __b)
  187     swap(_Tp& __a, _Tp& __b)
  198       _Tp __tmp = _GLIBCXX_MOVE(__a);
usr/include/c++/7.4.0/bits/predefined_ops.h
  176 	operator()(_Iterator __it, _Value& __val)
  214 	operator()(_Value& __val, _Iterator __it)
usr/include/c++/7.4.0/bits/stl_construct.h
   74     _Construct(_T1* __p, _Args&&... __args)
   74     _Construct(_T1* __p, _Args&&... __args)
   75     { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
   75     { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
  204 	     allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_function.h
  121       typedef _Arg1 	first_argument_type; 
  124       typedef _Arg2 	second_argument_type;
  381     struct less : public binary_function<_Tp, _Tp, bool>
  381     struct less : public binary_function<_Tp, _Tp, bool>
  385       operator()(const _Tp& __x, const _Tp& __y) const
  385       operator()(const _Tp& __x, const _Tp& __y) const
usr/include/c++/7.4.0/bits/stl_heap.h
  129 		_Distance __holeIndex, _Distance __topIndex, _Tp __value,
  215 		  _Distance __len, _Tp __value, _Compare __comp)
usr/include/c++/7.4.0/bits/stl_iterator.h
 1224     __make_move_if_noexcept_iterator(_Tp* __i)
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h
  181       typedef _Tp                         value_type;
  183       typedef _Tp*                        pointer;
  184       typedef _Tp&                        reference;
  192       typedef _Tp                         value_type;
  194       typedef const _Tp*                  pointer;
  195       typedef const _Tp&                  reference;
usr/include/c++/7.4.0/bits/stl_map.h
  102       typedef _Key					key_type;
  103       typedef _Tp					mapped_type;
  104       typedef std::pair<const _Key, _Tp>		value_type;
  104       typedef std::pair<const _Key, _Tp>		value_type;
usr/include/c++/7.4.0/bits/stl_pair.h
  100 	return __and_<is_constructible<_T1, const _U1&>,
  100 	return __and_<is_constructible<_T1, const _U1&>,
  101 		      is_constructible<_T2, const _U2&>>::value;
  101 		      is_constructible<_T2, const _U2&>>::value;
  107 	return __and_<is_convertible<const _U1&, _T1>,
  107 	return __and_<is_convertible<const _U1&, _T1>,
  108 		      is_convertible<const _U2&, _T2>>::value;
  108 		      is_convertible<const _U2&, _T2>>::value;
  114 	return __and_<is_constructible<_T1, _U1&&>,
  114 	return __and_<is_constructible<_T1, _U1&&>,
  115 		      is_constructible<_T2, _U2&&>>::value;
  115 		      is_constructible<_T2, _U2&&>>::value;
  121 	return __and_<is_convertible<_U1&&, _T1>,
  121 	return __and_<is_convertible<_U1&&, _T1>,
  122 		      is_convertible<_U2&&, _T2>>::value;
  122 		      is_convertible<_U2&&, _T2>>::value;
  128 	using __do_converts = __and_<is_convertible<const _U1&, _T1>,
  128 	using __do_converts = __and_<is_convertible<const _U1&, _T1>,
  129 				  is_convertible<_U2&&, _T2>>;
  129 				  is_convertible<_U2&&, _T2>>;
  133 	return __and_<is_constructible<_T1, const _U1&>,
  133 	return __and_<is_constructible<_T1, const _U1&>,
  134 		      is_constructible<_T2, _U2&&>,
  134 		      is_constructible<_T2, _U2&&>,
  142 	using __do_converts = __and_<is_convertible<_U1&&, _T1>,
  142 	using __do_converts = __and_<is_convertible<_U1&&, _T1>,
  143 				  is_convertible<const _U2&, _T2>>;
  143 				  is_convertible<const _U2&, _T2>>;
  147 	return __and_<is_constructible<_T1, _U1&&>,
  147 	return __and_<is_constructible<_T1, _U1&&>,
  148 		      is_constructible<_T2, const _U2&&>,
  148 		      is_constructible<_T2, const _U2&&>,
  209     : private __pair_base<_T1, _T2>
  209     : private __pair_base<_T1, _T2>
  211       typedef _T1 first_type;    /// @c first_type is the first bound type
  212       typedef _T2 second_type;   /// @c second_type is the second bound type
  214       _T1 first;                 /// @c first is a copy of the first object
  215       _T2 second;                /// @c second is a copy of the second object
  252       using _PCCP = _PCC<true, _T1, _T2>;
  252       using _PCCP = _PCC<true, _T1, _T2>;
  260       constexpr pair(const _T1& __a, const _T2& __b)
  260       constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  283 			    _T1, _T2>;
  283 			    _T1, _T2>;
  291         constexpr pair(const pair<_U1, _U2>& __p)
  311        constexpr pair(_U1&& __x, const _T2& __y)
  311        constexpr pair(_U1&& __x, const _T2& __y)
  318        explicit constexpr pair(_U1&& __x, const _T2& __y)
  325        constexpr pair(const _T1& __x, _U2&& __y)
  325        constexpr pair(const _T1& __x, _U2&& __y)
  332        explicit pair(const _T1& __x, _U2&& __y)
  341 	constexpr pair(_U1&& __x, _U2&& __y)
  341 	constexpr pair(_U1&& __x, _U2&& __y)
  360 	constexpr pair(pair<_U1, _U2>&& __p)
  362 	  second(std::forward<_U2>(__p.second)) { }
  379 		__and_<is_copy_assignable<_T1>,
  380 		       is_copy_assignable<_T2>>::value,
  390 		__and_<is_move_assignable<_T1>,
  391 		       is_move_assignable<_T2>>::value,
  402       typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
  402       typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
  403 				is_assignable<_T2&, const _U2&>>::value,
  403 				is_assignable<_T2&, const _U2&>>::value,
  405 	operator=(const pair<_U1, _U2>& __p)
  405 	operator=(const pair<_U1, _U2>& __p)
  413       typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
  413       typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
  414 				is_assignable<_T2&, _U2&&>>::value,
  414 				is_assignable<_T2&, _U2&&>>::value,
  416 	operator=(pair<_U1, _U2>&& __p)
  416 	operator=(pair<_U1, _U2>&& __p)
  454     operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  454     operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  524     make_pair(_T1&& __x, _T2&& __y)
usr/include/c++/7.4.0/bits/stl_tree.h
  563       typedef _Key 				key_type;
  758       static const _Key&
  782       static const _Key&
  894 		     const _Key& __k);
  898 		     const _Key& __k) const;
  902 		     const _Key& __k);
  906 		     const _Key& __k) const;
usr/include/c++/7.4.0/bits/stl_uninitialized.h
  288 			   _ForwardIterator __result, allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_vector.h
   77 	rebind<_Tp>::other _Tp_alloc_type;
  216     class vector : protected _Vector_base<_Tp, _Alloc>
  227       typedef _Vector_base<_Tp, _Alloc>			_Base;
  232       typedef _Tp					value_type;
  919       _Tp*
  923       const _Tp*
 1483 	_M_realloc_insert(iterator __position, _Args&&... __args);
usr/include/c++/7.4.0/ext/alloc_traits.h
  117       { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
usr/include/c++/7.4.0/ext/new_allocator.h
   63       typedef _Tp*       pointer;
   64       typedef const _Tp* const_pointer;
   65       typedef _Tp&       reference;
   66       typedef const _Tp& const_reference;
   67       typedef _Tp        value_type;
  111 	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
  130       { return size_t(-1) / sizeof(_Tp); }
  135 	construct(_Up* __p, _Args&&... __args)
  135 	construct(_Up* __p, _Args&&... __args)
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  140 	destroy(_Up* __p) { __p->~_Up(); }
usr/include/c++/7.4.0/type_traits
  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  326     : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
  354     : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
  567     : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  631     : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  762     typename add_rvalue_reference<_Tp>::type declval() noexcept;
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  798       typedef decltype(__test<_Tp>(0)) type;
  811                remove_all_extents<_Tp>::type>::type
  825     : public __is_destructible_safe<_Tp>::type
  889       typedef decltype(__test<_Tp>(0)) type;
  894     : public __and_<__not_<is_void<_Tp>>,
  895                     __is_default_constructible_impl<_Tp>>
  915     : public __is_default_constructible_atom<_Tp>::type
  921     : public __is_default_constructible_safe<_Tp>::type
  984       typedef decltype(__test<_Tp, _Arg>(0)) type;
  989     : public __and_<is_destructible<_Tp>,
  990                     __is_direct_constructible_impl<_Tp, _Arg>>
 1072 			 __is_direct_constructible_ref_cast<_Tp, _Arg>,
 1073 			 __is_direct_constructible_new_safe<_Tp, _Arg>
 1079     : public __is_direct_constructible_new<_Tp, _Arg>::type
 1119     : public __is_direct_constructible<_Tp, _Arg>
 1130     : public __is_constructible_impl<_Tp, _Args...>::type
 1160     : public is_constructible<_Tp, _Tp&&>
 1160     : public is_constructible<_Tp, _Tp&&>
 1166     : public __is_move_constructible_impl<_Tp>
 1215     : public __and_<is_constructible<_Tp, _Args...>,
 1216 		    __is_nt_constructible_impl<_Tp, _Args...>>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1252     : public __is_nothrow_move_constructible_impl<_Tp>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1292     : public __is_copy_assignable_impl<_Tp>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1310     : public __is_move_assignable_impl<_Tp>
 1352     : public is_nothrow_assignable<_Tp&, _Tp&&>
 1352     : public is_nothrow_assignable<_Tp&, _Tp&&>
 1358     : public __is_nt_move_assignable_impl<_Tp>
 1377     static void __helper(const _Tp&);
 1380     static true_type __test(const _Tp&,
 1381                             decltype(__helper<const _Tp&>({}))* = 0);
 1390     typedef decltype(__test(declval<_Tp>())) type;
 1395       : public __is_implicitly_default_constructible_impl<_Tp>::type
 1400       : public __and_<is_default_constructible<_Tp>,
 1401                       __is_implicitly_default_constructible_safe<_Tp>>
 1526 	static void __test_aux(_To1);
 1538       typedef decltype(__test<_From, _To>(0)) type;
 1538       typedef decltype(__test<_From, _To>(0)) type;
 1545     : public __is_convertible_helper<_From, _To>::type
 1545     : public __is_convertible_helper<_From, _To>::type
 1554     { typedef _Tp     type; };
 1558     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1629     { typedef _Tp   type; };
 1633     { typedef _Tp   type; };
 1659     { typedef _Tp&&   type; };
 1664     : public __add_rvalue_reference_helper<_Tp>
 1955     { typedef _Tp     type; };
 2131       typedef _Tp __type;
 2171     { typedef _Iffalse type; };
 2574       typename remove_reference<_Tp>::type>::type>::type