#ifndef LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H
#define LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/DebugInfo/DIContext.h"
-#include "llvm/Object/MachOUniversal.h"
+#include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
#include "llvm/Object/ObjectFile.h"
-#include "llvm/Support/DataExtractor.h"
-#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/ErrorOr.h"
#include <map>
#include <memory>
#include <string>
using namespace object;
using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind;
-class ModuleInfo;
class LLVMSymbolizer {
public:
struct Options {
FunctionNameKind PrintFunctions;
bool UseSymbolTable : 1;
- bool PrintInlining : 1;
bool Demangle : 1;
bool RelativeAddresses : 1;
std::string DefaultArch;
std::vector<std::string> DsymHints;
Options(FunctionNameKind PrintFunctions = FunctionNameKind::LinkageName,
- bool UseSymbolTable = true, bool PrintInlining = true,
- bool Demangle = true, bool RelativeAddresses = false,
- std::string DefaultArch = "")
+ bool UseSymbolTable = true, bool Demangle = true,
+ bool RelativeAddresses = false, std::string DefaultArch = "")
: PrintFunctions(PrintFunctions), UseSymbolTable(UseSymbolTable),
- PrintInlining(PrintInlining), Demangle(Demangle),
- RelativeAddresses(RelativeAddresses), DefaultArch(DefaultArch) {}
+ Demangle(Demangle), RelativeAddresses(RelativeAddresses),
+ DefaultArch(DefaultArch) {}
};
LLVMSymbolizer(const Options &Opts = Options()) : Opts(Opts) {}
flush();
}
- // Returns the result of symbolization for module name/offset as
- // a string (possibly containing newlines).
- std::string
- symbolizeCode(const std::string &ModuleName, uint64_t ModuleOffset);
- std::string
- symbolizeData(const std::string &ModuleName, uint64_t ModuleOffset);
+ ErrorOr<DILineInfo> symbolizeCode(const std::string &ModuleName,
+ uint64_t ModuleOffset);
+ ErrorOr<DIInliningInfo> symbolizeInlinedCode(const std::string &ModuleName,
+ uint64_t ModuleOffset);
+ ErrorOr<DIGlobal> symbolizeData(const std::string &ModuleName,
+ uint64_t ModuleOffset);
void flush();
- static std::string DemangleName(const std::string &Name, ModuleInfo *ModInfo);
+ static std::string DemangleName(const std::string &Name,
+ const SymbolizableModule *ModInfo);
private:
+ // Bundles together object file with code/data and object file with
+ // corresponding debug info. These objects can be the same.
typedef std::pair<ObjectFile*, ObjectFile*> ObjectPair;
- ModuleInfo *getOrCreateModuleInfo(const std::string &ModuleName);
- ObjectFile *lookUpDsymFile(const std::string &Path, const MachOObjectFile *ExeObj,
+ ErrorOr<SymbolizableModule *>
+ getOrCreateModuleInfo(const std::string &ModuleName);
+ ObjectFile *lookUpDsymFile(const std::string &Path,
+ const MachOObjectFile *ExeObj,
const std::string &ArchName);
+ ObjectFile *lookUpDebuglinkObject(const std::string &Path,
+ const ObjectFile *Obj,
+ const std::string &ArchName);
/// \brief Returns pair of pointers to object and debug object.
- ObjectPair getOrCreateObjects(const std::string &Path,
- const std::string &ArchName);
- /// \brief Returns a parsed object file for a given architecture in a
- /// universal binary (or the binary itself if it is an object file).
- ObjectFile *getObjectFileFromBinary(Binary *Bin, const std::string &ArchName);
-
- std::string printDILineInfo(DILineInfo LineInfo, ModuleInfo *ModInfo) const;
-
- // Owns all the parsed binaries and object files.
- SmallVector<std::unique_ptr<Binary>, 4> ParsedBinariesAndObjects;
- SmallVector<std::unique_ptr<MemoryBuffer>, 4> MemoryBuffers;
- void addOwningBinary(OwningBinary<Binary> OwningBin) {
- std::unique_ptr<Binary> Bin;
- std::unique_ptr<MemoryBuffer> MemBuf;
- std::tie(Bin, MemBuf) = OwningBin.takeBinary();
- ParsedBinariesAndObjects.push_back(std::move(Bin));
- MemoryBuffers.push_back(std::move(MemBuf));
- }
-
- std::map<std::string, std::unique_ptr<ModuleInfo>> Modules;
- std::map<std::pair<MachOUniversalBinary *, std::string>, ObjectFile *>
- ObjectFileForArch;
- std::map<std::pair<std::string, std::string>, ObjectPair>
- ObjectPairForPathArch;
+ ErrorOr<ObjectPair> getOrCreateObjectPair(const std::string &Path,
+ const std::string &ArchName);
- Options Opts;
- static const char kBadString[];
-};
+ /// \brief Return a pointer to object file at specified path, for a specified
+ /// architecture (e.g. if path refers to a Mach-O universal binary, only one
+ /// object file from it will be returned).
+ ErrorOr<ObjectFile *> getOrCreateObject(const std::string &Path,
+ const std::string &ArchName);
-class ModuleInfo {
-public:
- ModuleInfo(ObjectFile *Obj, std::unique_ptr<DIContext> DICtx);
+ std::map<std::string, ErrorOr<std::unique_ptr<SymbolizableModule>>> Modules;
- DILineInfo symbolizeCode(uint64_t ModuleOffset,
- const LLVMSymbolizer::Options &Opts) const;
- DIInliningInfo symbolizeInlinedCode(
- uint64_t ModuleOffset, const LLVMSymbolizer::Options &Opts) const;
- bool symbolizeData(uint64_t ModuleOffset, std::string &Name, uint64_t &Start,
- uint64_t &Size) const;
+ /// \brief Contains cached results of getOrCreateObjectPair().
+ std::map<std::pair<std::string, std::string>, ErrorOr<ObjectPair>>
+ ObjectPairForPathArch;
- // Return true if this is a 32-bit x86 PE COFF module.
- bool isWin32Module() const;
+ /// \brief Contains parsed binary for each path, or parsing error.
+ std::map<std::string, ErrorOr<OwningBinary<Binary>>> BinaryForPath;
- // Returns the preferred base of the module, i.e. where the loader would place
- // it in memory assuming there were no conflicts.
- uint64_t getModulePreferredBase() const;
+ /// \brief Parsed object file for path/architecture pair, where "path" refers
+ /// to Mach-O universal binary.
+ std::map<std::pair<std::string, std::string>, ErrorOr<std::unique_ptr<ObjectFile>>>
+ ObjectForUBPathAndArch;
-private:
- bool getNameFromSymbolTable(SymbolRef::Type Type, uint64_t Address,
- std::string &Name, uint64_t &Addr,
- uint64_t &Size) const;
- // For big-endian PowerPC64 ELF, OpdAddress is the address of the .opd
- // (function descriptor) section and OpdExtractor refers to its contents.
- void addSymbol(const SymbolRef &Symbol, uint64_t SymbolSize,
- DataExtractor *OpdExtractor = nullptr,
- uint64_t OpdAddress = 0);
- void addCoffExportSymbols(const COFFObjectFile *CoffObj);
- ObjectFile *Module;
- std::unique_ptr<DIContext> DebugInfoContext;
-
- struct SymbolDesc {
- uint64_t Addr;
- // If size is 0, assume that symbol occupies the whole memory range up to
- // the following symbol.
- uint64_t Size;
- friend bool operator<(const SymbolDesc &s1, const SymbolDesc &s2) {
- return s1.Addr < s2.Addr;
- }
- };
- std::map<SymbolDesc, StringRef> Functions;
- std::map<SymbolDesc, StringRef> Objects;
+ Options Opts;
};
} // namespace symbolize
projects / oota-llvm.git / blobdiff