1 //===- Symbolize.h ----------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Header for LLVM symbolization library. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H 14 #define LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H 15 16 #include "llvm/DebugInfo/Symbolize/SymbolizableModule.h" 17 #include "llvm/Object/Binary.h" 18 #include "llvm/Object/ObjectFile.h" 19 #include "llvm/Object/ELFObjectFile.h" 20 #include "llvm/Support/Error.h" 21 #include <algorithm> 22 #include <cstdint> 23 #include <map> 24 #include <memory> 25 #include <string> 26 #include <utility> 27 #include <vector> 28 29 namespace llvm { 30 namespace symbolize { 31 32 using namespace object; 33 34 using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind; 35 using FileLineInfoKind = DILineInfoSpecifier::FileLineInfoKind; 36 37 class LLVMSymbolizer { 38 public: 39 struct Options { 40 FunctionNameKind PrintFunctions = FunctionNameKind::LinkageName; 41 FileLineInfoKind PathStyle = FileLineInfoKind::AbsoluteFilePath; 42 bool UseSymbolTable = true; 43 bool Demangle = true; 44 bool RelativeAddresses = false; 45 bool UntagAddresses = false; 46 bool UseNativePDBReader = false; 47 std::string DefaultArch; 48 std::vector<std::string> DsymHints; 49 std::string FallbackDebugPath; 50 std::string DWPName; 51 std::vector<std::string> DebugFileDirectory; 52 }; 53 54 LLVMSymbolizer() = default; LLVMSymbolizer(const Options & Opts)55 LLVMSymbolizer(const Options &Opts) : Opts(Opts) {} 56 ~LLVMSymbolizer()57 ~LLVMSymbolizer() { 58 flush(); 59 } 60 61 Expected<DILineInfo> symbolizeCode(const ObjectFile &Obj, 62 object::SectionedAddress ModuleOffset); 63 Expected<DILineInfo> symbolizeCode(const std::string &ModuleName, 64 object::SectionedAddress ModuleOffset); 65 Expected<DIInliningInfo> 66 symbolizeInlinedCode(const std::string &ModuleName, 67 object::SectionedAddress ModuleOffset); 68 Expected<DIGlobal> symbolizeData(const std::string &ModuleName, 69 object::SectionedAddress ModuleOffset); 70 Expected<std::vector<DILocal>> 71 symbolizeFrame(const std::string &ModuleName, 72 object::SectionedAddress ModuleOffset); 73 void flush(); 74 75 static std::string 76 DemangleName(const std::string &Name, 77 const SymbolizableModule *DbiModuleDescriptor); 78 79 private: 80 // Bundles together object file with code/data and object file with 81 // corresponding debug info. These objects can be the same. 82 using ObjectPair = std::pair<const ObjectFile *, const ObjectFile *>; 83 84 Expected<DILineInfo> 85 symbolizeCodeCommon(SymbolizableModule *Info, 86 object::SectionedAddress ModuleOffset); 87 88 /// Returns a SymbolizableModule or an error if loading debug info failed. 89 /// Only one attempt is made to load a module, and errors during loading are 90 /// only reported once. Subsequent calls to get module info for a module that 91 /// failed to load will return nullptr. 92 Expected<SymbolizableModule *> 93 getOrCreateModuleInfo(const std::string &ModuleName); 94 95 Expected<SymbolizableModule *> 96 createModuleInfo(const ObjectFile *Obj, 97 std::unique_ptr<DIContext> Context, 98 StringRef ModuleName); 99 100 ObjectFile *lookUpDsymFile(const std::string &Path, 101 const MachOObjectFile *ExeObj, 102 const std::string &ArchName); 103 ObjectFile *lookUpDebuglinkObject(const std::string &Path, 104 const ObjectFile *Obj, 105 const std::string &ArchName); 106 ObjectFile *lookUpBuildIDObject(const std::string &Path, 107 const ELFObjectFileBase *Obj, 108 const std::string &ArchName); 109 110 /// Returns pair of pointers to object and debug object. 111 Expected<ObjectPair> getOrCreateObjectPair(const std::string &Path, 112 const std::string &ArchName); 113 114 /// Return a pointer to object file at specified path, for a specified 115 /// architecture (e.g. if path refers to a Mach-O universal binary, only one 116 /// object file from it will be returned). 117 Expected<ObjectFile *> getOrCreateObject(const std::string &Path, 118 const std::string &ArchName); 119 120 std::map<std::string, std::unique_ptr<SymbolizableModule>, std::less<>> 121 Modules; 122 123 /// Contains cached results of getOrCreateObjectPair(). 124 std::map<std::pair<std::string, std::string>, ObjectPair> 125 ObjectPairForPathArch; 126 127 /// Contains parsed binary for each path, or parsing error. 128 std::map<std::string, OwningBinary<Binary>> BinaryForPath; 129 130 /// Parsed object file for path/architecture pair, where "path" refers 131 /// to Mach-O universal binary. 132 std::map<std::pair<std::string, std::string>, std::unique_ptr<ObjectFile>> 133 ObjectForUBPathAndArch; 134 135 Options Opts; 136 }; 137 138 } // end namespace symbolize 139 } // end namespace llvm 140 141 #endif // LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H 142