include/llvm/DebugInfo/Symbolize/Symbolize.h

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