LLVM  11.0.0git
Symbolize.h
Go to the documentation of this file.
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 
17 #include "llvm/Object/Binary.h"
18 #include "llvm/Object/ObjectFile.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 
36 
38 public:
39  struct Options {
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;
55  LLVMSymbolizer(const Options &Opts) : Opts(Opts) {}
56 
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);
66  symbolizeInlinedCode(const std::string &ModuleName,
67  object::SectionedAddress ModuleOffset);
68  Expected<DIGlobal> symbolizeData(const std::string &ModuleName,
69  object::SectionedAddress ModuleOffset);
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 
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.
93  getOrCreateModuleInfo(const std::string &ModuleName);
94 
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
LLVMContext & Context
This class represents lattice values for constants.
Definition: AllocatorList.h:23
DILineInfoSpecifier::FunctionNameKind FunctionNameKind
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
This class is the base class for all object file types.
Definition: ObjectFile.h:225
DINameKind
A DINameKind is passed to name search methods to specify a preference regarding the type of name reso...
Definition: DIContext.h:132
LLVMSymbolizer(const Options &Opts)
Definition: Symbolize.h:55
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
Analysis containing CSE Info
Definition: CSEInfo.cpp:25
std::vector< std::string > DsymHints
Definition: Symbolize.h:48
DINameKind FunctionNameKind
Definition: DIContext.h:147
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
std::vector< std::string > DebugFileDirectory
Definition: Symbolize.h:51