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
29namespace llvm {
30namespace symbolize {
31
32using namespace object;
33
34using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
35
36class LLVMSymbolizer {
37public:
38  struct Options {
39    FunctionNameKind PrintFunctions = FunctionNameKind::LinkageName;
40    bool UseSymbolTable = true;
41    bool Demangle = true;
42    bool RelativeAddresses = false;
43    bool UntagAddresses = false;
44    std::string DefaultArch;
45    std::vector<std::string> DsymHints;
46    std::string FallbackDebugPath;
47    std::string DWPName;
48    std::vector<std::string> DebugFileDirectory;
49  };
50
51  LLVMSymbolizer() = default;
52  LLVMSymbolizer(const Options &Opts) : Opts(Opts) {}
53
54  ~LLVMSymbolizer() {
55    flush();
56  }
57
58  Expected<DILineInfo> symbolizeCode(const ObjectFile &Obj,
59                                     object::SectionedAddress ModuleOffset);
60  Expected<DILineInfo> symbolizeCode(const std::string &ModuleName,
61                                     object::SectionedAddress ModuleOffset);
62  Expected<DIInliningInfo>
63  symbolizeInlinedCode(const std::string &ModuleName,
64                       object::SectionedAddress ModuleOffset);
65  Expected<DIGlobal> symbolizeData(const std::string &ModuleName,
66                                   object::SectionedAddress ModuleOffset);
67  Expected<std::vector<DILocal>>
68  symbolizeFrame(const std::string &ModuleName,
69                 object::SectionedAddress ModuleOffset);
70  void flush();
71
72  static std::string
73  DemangleName(const std::string &Name,
74               const SymbolizableModule *DbiModuleDescriptor);
75
76private:
77  // Bundles together object file with code/data and object file with
78  // corresponding debug info. These objects can be the same.
79  using ObjectPair = std::pair<const ObjectFile *, const ObjectFile *>;
80
81  Expected<DILineInfo>
82  symbolizeCodeCommon(SymbolizableModule *Info,
83                      object::SectionedAddress ModuleOffset);
84
85  /// Returns a SymbolizableModule or an error if loading debug info failed.
86  /// Only one attempt is made to load a module, and errors during loading are
87  /// only reported once. Subsequent calls to get module info for a module that
88  /// failed to load will return nullptr.
89  Expected<SymbolizableModule *>
90  getOrCreateModuleInfo(const std::string &ModuleName);
91
92  Expected<SymbolizableModule *>
93  createModuleInfo(const ObjectFile *Obj,
94                   std::unique_ptr<DIContext> Context,
95                   StringRef ModuleName);
96
97  ObjectFile *lookUpDsymFile(const std::string &Path,
98                             const MachOObjectFile *ExeObj,
99                             const std::string &ArchName);
100  ObjectFile *lookUpDebuglinkObject(const std::string &Path,
101                                    const ObjectFile *Obj,
102                                    const std::string &ArchName);
103  ObjectFile *lookUpBuildIDObject(const std::string &Path,
104                                  const ELFObjectFileBase *Obj,
105                                  const std::string &ArchName);
106
107  /// Returns pair of pointers to object and debug object.
108  Expected<ObjectPair> getOrCreateObjectPair(const std::string &Path,
109                                            const std::string &ArchName);
110
111  /// Return a pointer to object file at specified path, for a specified
112  /// architecture (e.g. if path refers to a Mach-O universal binary, only one
113  /// object file from it will be returned).
114  Expected<ObjectFile *> getOrCreateObject(const std::string &Path,
115                                          const std::string &ArchName);
116
117  std::map<std::string, std::unique_ptr<SymbolizableModule>> Modules;
118
119  /// Contains cached results of getOrCreateObjectPair().
120  std::map<std::pair<std::string, std::string>, ObjectPair>
121      ObjectPairForPathArch;
122
123  /// Contains parsed binary for each path, or parsing error.
124  std::map<std::string, OwningBinary<Binary>> BinaryForPath;
125
126  /// Parsed object file for path/architecture pair, where "path" refers
127  /// to Mach-O universal binary.
128  std::map<std::pair<std::string, std::string>, std::unique_ptr<ObjectFile>>
129      ObjectForUBPathAndArch;
130
131  Options Opts;
132};
133
134} // end namespace symbolize
135} // end namespace llvm
136
137#endif // LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H
138