Index: tools/CMakeLists.txt =================================================================== --- tools/CMakeLists.txt +++ tools/CMakeLists.txt @@ -36,6 +36,7 @@ add_llvm_tool_subdirectory(llvm-readobj) add_llvm_tool_subdirectory(llvm-rtdyld) add_llvm_tool_subdirectory(llvm-dwarfdump) +add_llvm_tool_subdirectory(dsymutil) add_llvm_tool_subdirectory(llvm-vtabledump) if( LLVM_USE_INTEL_JITEVENTS ) add_llvm_tool_subdirectory(llvm-jitlistener) Index: tools/Makefile =================================================================== --- tools/Makefile +++ tools/Makefile @@ -33,7 +33,7 @@ macho-dump llvm-objdump llvm-readobj llvm-rtdyld \ llvm-dwarfdump llvm-cov llvm-size llvm-stress llvm-mcmarkup \ llvm-profdata llvm-symbolizer obj2yaml yaml2obj llvm-c-test \ - llvm-vtabledump verify-uselistorder + llvm-vtabledump verify-uselistorder dsymutil # If Intel JIT Events support is configured, build an extra tool to test it. ifeq ($(USE_INTEL_JITEVENTS), 1) Index: tools/dsymutil/CMakeLists.txt =================================================================== --- /dev/null +++ tools/dsymutil/CMakeLists.txt @@ -0,0 +1,12 @@ +set(LLVM_LINK_COMPONENTS + Object + Support + ) + +add_llvm_tool(llvm-dsymutil + dsymutil.cpp + DebugMap.cpp + DwarfLinker.cpp + MachODebugMapParser.cpp + ) + Index: tools/dsymutil/DebugMap.h =================================================================== --- /dev/null +++ tools/dsymutil/DebugMap.h @@ -0,0 +1,122 @@ +//===- tools/dsymutil/DebugMap.h - Generic debug map representation -------===// +// +// The LLVM Linker +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// +/// This file contains the class declaration of the DebugMap +/// entity. A DebugMap lists all the object files linked together to +/// produce an executable along with the linked address of all the +/// atoms used in these object files. +/// The DebugMap is an input to the DwarfLinker class that will +/// extract the Dwarf debug information from the referenced object +/// files and link their usefull debug info together. +/// +//===----------------------------------------------------------------------===// +#ifndef DSYMUTIL_DEBUGMAP_H +#define DSYMUTIL_DEBUGMAP_H + +#include "llvm/ADT/StringMap.h" +#include "llvm/Object/ObjectFile.h" +#include "llvm/Support/ErrorOr.h" +#include "llvm/Support/Format.h" +#include "llvm/ADT/iterator_range.h" +#include "llvm/Support/raw_ostream.h" + +#include + +namespace llvm { +class DebugMapObject; + +/// \brief The DebugMap object stores the list of object files to +/// query for debug information along with the mapping between the +/// symbols' addresses in the object file to their linked address in +/// the linked binary. +/// +/// A DebugMap producer could look like this: +/// DebugMap *DM = new DebugMap(); +/// for (const auto &Obj: LinkedObjects) { +/// DebugMapObject &DMO = DM->addDebugMapObject(Obj.getPath()); +/// for (const auto &Sym: Obj.getLinkedSymbols()) +/// DMO.addSymbol(Sym.getName(), Sym.getObjectFileAddress(), +/// Sym.getBinaryAddress()); +/// } +/// +/// A DebugMap consumer can then use the map to link the debug +/// information. For example something along the lines of: +/// for (const auto &DMO: DM->objects()) { +/// auto Obj = createBinary(DMO.getObjectFilename()); +/// for (auto &DIE: Obj.getDwarfDIEs()) { +/// if (SymbolMapping *Sym = DMO.lookup(DIE.getName())) +/// DIE.relocate(Sym->ObjectAddress, Sym->BinaryAddress); +/// else +/// DIE.discardSubtree(); +/// } +/// } +class DebugMap +{ + typedef std::vector> ObjectContainer; + ObjectContainer Objects; + +public: + typedef ObjectContainer::const_iterator const_iterator; + + iterator_range objects() const { + return make_range(begin(), end()); + } + + const_iterator begin() const { + return Objects.begin(); + } + + const_iterator end() const { + return Objects.end(); + } + + /// This function adds an DebugMapObject to the list owned by this + /// debug map. + DebugMapObject& addDebugMapObject(StringRef ObjectFilePath); + + void dump() const; +}; + +/// \brief The DebugMapObject represents one object file described by +/// the DebugMap. It contains a list of mappings between addresses in +/// the object file and in the final binary for all the linked atoms +/// in this object file. +class DebugMapObject { +public: + struct SymbolMapping { + uint64_t ObjectAddress; + uint64_t BinaryAddress; + }; + + /// \brief Adds a symbol mapping to this DebugMapObject. + void addSymbol(llvm::StringRef SymName, uint64_t ObjectAddress, + uint64_t BinaryAddress); + + /// \bried Lookup a symbol mapping. + /// \returns null if the symbol isn't found. + const SymbolMapping *lookupSymbol(StringRef SymbolName) const; + + llvm::StringRef getObjectFilename() const { return Filename; } + + void dump() const; + +private: + friend class DebugMap; + /// DebugMapObjects can only be constructed by the owning DebugMap. + DebugMapObject(StringRef ObjectFilename); + + std::string Filename; + StringMap Symbols; +}; + +} + +#endif // DSYMUTIL_DEBUGMAP_H Index: tools/dsymutil/DebugMap.cpp =================================================================== --- /dev/null +++ tools/dsymutil/DebugMap.cpp @@ -0,0 +1,61 @@ +//===- tools/dsymutil/DebugMap.cpp - Generic debug map representation -----===// +// +// The LLVM Linker +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#include "DebugMap.h" + +#include "llvm/ADT/STLExtras.h" +#include "llvm/Support/DataTypes.h" + +namespace llvm { + +using namespace llvm::object; + +DebugMapObject::DebugMapObject(StringRef ObjectFilename) + : Filename(ObjectFilename) {} + +void DebugMapObject::addSymbol(StringRef Name, uint64_t ObjectAddress, + uint64_t BinaryAddress) { + SymbolMapping &Sym = Symbols[Name]; + assert(Sym.ObjectAddress == 0 && Sym.BinaryAddress == 0 && + "Symbol added twice in the same file."); + Sym.ObjectAddress = ObjectAddress; + Sym.BinaryAddress = BinaryAddress; +} + +void DebugMapObject::dump() const { + errs() << "Object file " << getObjectFilename() << '\n'; + auto End = Symbols.end(); + for (auto SymIt = Symbols.begin(); SymIt != End; ++SymIt) { + const auto &Sym = SymIt->getValue(); + errs() << format(" %s\t%016" PRIx64 " => %016" PRIx64 "\n", + SymIt->getKeyData(), + Sym.ObjectAddress, Sym.BinaryAddress); + } +} + +DebugMapObject& DebugMap::addDebugMapObject(StringRef ObjectFilePath) { + Objects.emplace_back(new DebugMapObject(ObjectFilePath)); + return *Objects.back(); +} + +const DebugMapObject::SymbolMapping * +DebugMapObject::lookupSymbol(StringRef SymbolName) const { + StringMap::const_iterator Sym = Symbols.find(SymbolName); + if (Sym == Symbols.end()) + return nullptr; + return &Sym->getValue(); +} + +void DebugMap::dump() const { + errs() << "DEBUG MAP:\n"; + for (const auto &Obj: objects()) + Obj->dump(); +} + + +} Index: tools/dsymutil/DwarfLinker.h =================================================================== --- /dev/null +++ tools/dsymutil/DwarfLinker.h @@ -0,0 +1,40 @@ +//===- tools/dsymutil/DwarfLinker.h - Dwarf debug info linker -------------===// +// +// The LLVM Linker +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// +/// This file contains the class declaration of the DwarfLinker +/// object. A DwarfLinker takes a DebugMap as input and links the +/// debug information of all the referenced object files together. It +/// may drop and rewrite some parts of the debug info tree in the +/// process. +/// +//===----------------------------------------------------------------------===// +#ifndef DSYMUTIL_DWARFLINKER_H +#define DSYMUTIL_DWARFLINKER_H + +#include "llvm/ADT/StringRef.h" + +namespace llvm { + +class DebugMap; + +class DwarfLinker { + std::string OutputFilename; +public: + DwarfLinker(StringRef OutputFilename); + + /// \brief Link the passed debug map into the ouptut file. + /// \returns false if the link encountered a fatal error. + bool link(const DebugMap&); +}; + +} + +#endif Index: tools/dsymutil/DwarfLinker.cpp =================================================================== --- /dev/null +++ tools/dsymutil/DwarfLinker.cpp @@ -0,0 +1,22 @@ +//===- tools/dsymutil/DwarfLinker.cpp - Dwarf debug info linker -----------===// +// +// The LLVM Linker +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#include "DwarfLinker.h" +#include "DebugMap.h" + +namespace llvm { + +DwarfLinker::DwarfLinker(StringRef Filename) + : OutputFilename(Filename) +{} + +bool DwarfLinker::link(const DebugMap &Map) { + return true; +} + +} Index: tools/dsymutil/MachODebugMapParser.h =================================================================== --- /dev/null +++ tools/dsymutil/MachODebugMapParser.h @@ -0,0 +1,70 @@ +//===- tools/dsymutil/MachODebugMapParser.h - Parse STABS debug maps ------===// +// +// The LLVM Linker +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// +/// This file contains the class declaration for the code that parses STABS +/// debug maps that are embedded in the binaries symbol tables. +/// +//===----------------------------------------------------------------------===// +#ifndef DSYMUTIL_MACHODEBUGMAPPARSER_H +#define DSYMUTIL_MACHODEBUGMAPPARSER_H + +#include "DebugMap.h" + +#include "llvm/ADT/StringMap.h" +#include "llvm/Object/MachO.h" +#include "llvm/Object/Error.h" + +namespace llvm { + +class MachODebugMapParser { +public: + MachODebugMapParser(StringRef BinaryPath) + : BinaryPath(BinaryPath) {} + + /// \brief Parses and returns the DebugMap of the input binary. + /// \returns an error in case the provided BinaryPath doesn't exist + /// or isn't of a supported type. + ErrorOr> parse(); + +private: + std::string BinaryPath; + /// OwningBinary constructed from the BinaryPath. + object::OwningBinary MainOwningBinary; + /// Map of the binary symbol addresses. + StringMap MainBinarySymbolAddresses; + /// The constructed DebugMap. + std::unique_ptr Result; + + /// Handle to the currently processed object file. + object::OwningBinary CurrentObjectFile; + /// Map of the currently processed object file symbol addresses. + StringMap CurrentObjectAddresses; + /// Element of the debug map corresponfing to the current object file. + DebugMapObject *CurrentDebugMapObject; + + void newDebugMapObject(StringRef Filename); + void resetParserState(); + uint64_t getMainBinarySymbolAddress(StringRef Name); + void loadMainBinarySymbols(); + void loadCurrentObjectFileSymbols(); + void handleStabSymbolTableEntry(uint32_t StringIndex, uint8_t Type, + uint8_t SectionIndex, uint16_t Flags, + uint64_t Value); + + template void handleStabDebugMapEntry(const STEType &STE) { + handleStabSymbolTableEntry(STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc, + STE.n_value); + } +}; + +} + +#endif // DSYMUTIL_MACHODEBUGMAPPARSER_H Index: tools/dsymutil/MachODebugMapParser.cpp =================================================================== --- /dev/null +++ tools/dsymutil/MachODebugMapParser.cpp @@ -0,0 +1,189 @@ +//===- tools/dsymutil/MachODebugMapParser.cpp - Parse STABS debug maps ----===// +// +// The LLVM Linker +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "MachODebugMapParser.h" + +using namespace llvm::object; + +namespace llvm { + +static void Warning(const Twine &Msg) { errs() << "warning: " + Msg + "\n"; } + +static ErrorOr> createMachOBinary(StringRef file) { + ErrorOr> BinaryOrErr = createBinary(file); + if (BinaryOrErr.getError()) + return BinaryOrErr.getError(); + + std::unique_ptr Bin; + std::unique_ptr Buf; + std::tie(Bin, Buf) = BinaryOrErr->takeBinary(); + if (!isa(Bin.get())) + return make_error_code(object_error::invalid_file_type); + + std::unique_ptr MachOFile(cast(Bin.release())); + return OwningBinary(std::move(MachOFile), std::move(Buf)); +} + +/// Reset the parser state coresponding to the current object +/// file. This is to be called after an object file is finished +/// processing. +void MachODebugMapParser::resetParserState() { + CurrentObjectFile = OwningBinary(); + CurrentObjectAddresses.clear(); + CurrentDebugMapObject = nullptr; +} + +/// Create a new DebugMapObject. This function resets the state of the +/// parser that was referring to the last object file and sets +/// everything up to add symbols to the new one. +void MachODebugMapParser::newDebugMapObject(StringRef Filename) { + resetParserState(); + + auto MachOOrError = createMachOBinary(Filename); + if (auto Error = MachOOrError.getError()) { + Warning(Twine("Cannot open debug object \"") + Filename + "\": " + + Error.message() + "\n"); + CurrentDebugMapObject = nullptr; + return; + } + + CurrentObjectFile = std::move(*MachOOrError); + loadCurrentObjectFileSymbols(); + CurrentDebugMapObject = &Result->addDebugMapObject(Filename); +} + +/// This main parsing routine tries to open the main binary and if +/// successful iterates over the STAB entries. The real parsing is +/// done in handleStabSymbolTableEntry. +ErrorOr> MachODebugMapParser::parse() { + auto MainBinaryOrError = createMachOBinary(BinaryPath); + if (MainBinaryOrError.getError()) + return MainBinaryOrError.getError(); + + MainOwningBinary = std::move(*MainBinaryOrError); + Result = make_unique(); + const auto &MainBinary = *MainOwningBinary.getBinary(); + for (const SymbolRef &Symbol : MainBinary.symbols()) { + const DataRefImpl &DRI = Symbol.getRawDataRefImpl(); + if (MainBinary.is64Bit()) + handleStabDebugMapEntry(MainBinary.getSymbol64TableEntry(DRI)); + else + handleStabDebugMapEntry(MainBinary.getSymbolTableEntry(DRI)); + } + + resetParserState(); + return std::move(Result); +} + +/// Interpret the STAB entries to fill the DebugMap. +void MachODebugMapParser::handleStabSymbolTableEntry(uint32_t StringIndex, + uint8_t Type, + uint8_t SectionIndex, + uint16_t Flags, + uint64_t Value) { + if (!(Type & MachO::N_STAB)) + return; + + const MachOObjectFile &MachOBinary = *MainOwningBinary.getBinary(); + const char *Name = &MachOBinary.getStringTableData().data()[StringIndex]; + + // An N_OSO entry represents the start of a new object file description. + if (Type == MachO::N_OSO) + return newDebugMapObject(Name); + + // If the last N_OSO object file wasn't found, + // CurrentDebugMapObject will be null. Do not update anything + // until we find the next valid N_OSO entry. + if (!CurrentDebugMapObject) + return; + + switch (Type) { + case MachO::N_GSYM: + // This is a global variable. We need to query the main binary + // symbol table to find its address as it might not be in the + // debug map (for common symbols). + Value = getMainBinarySymbolAddress(Name); + if (Value == UnknownAddressOrSize) + return Warning("Could not find relocated address for global symbol " + + Twine(Name)); + break; + case MachO::N_FUN: + // Functions are scopes in STABS. They have an end marker that we + // need to ignore. + if (Name[0] == '\0') + return; + break; + case MachO::N_STSYM: + break; + default: + return; + } + + auto ObjectSymIt = CurrentObjectAddresses.find(Name); + if (ObjectSymIt == CurrentObjectAddresses.end()) + return Warning("Could not find object file symbol for symbol " + + Twine(Name)); + CurrentDebugMapObject->addSymbol(Name, ObjectSymIt->getValue(), Value); +} + +/// Load the current object file symbols into CurrentObjectAddresses. +void MachODebugMapParser::loadCurrentObjectFileSymbols() { + CurrentObjectAddresses.clear(); + const auto &Binary = *CurrentObjectFile.getBinary(); + + for (auto Sym : Binary.symbols()) { + StringRef Name; + uint64_t Addr; + if (Sym.getAddress(Addr) || Addr == UnknownAddressOrSize || + Sym.getName(Name)) + continue; + CurrentObjectAddresses[Name] = Addr; + } +} + +/// Lookup a symbol address in the main binary symbol table. The +/// parser only needs to query common symbols, thus not every symbol's +/// address is available through this function. +uint64_t MachODebugMapParser::getMainBinarySymbolAddress(StringRef Name) { + if (MainBinarySymbolAddresses.empty()) + loadMainBinarySymbols(); + + auto Sym = MainBinarySymbolAddresses.find(Name); + if (Sym == MainBinarySymbolAddresses.end()) + return UnknownAddressOrSize; + return Sym->second; +} + +/// Load the interesting main binary symbols' addresses into +/// MainBinarySymbolAddresses. +void MachODebugMapParser::loadMainBinarySymbols() { + const MachOObjectFile &Binary = *MainOwningBinary.getBinary(); + section_iterator Section = Binary.section_end(); + for (const auto &Sym : Binary.symbols()) { + SymbolRef::Type Type; + // Skip undefined and STAB entries. + if (Sym.getType(Type) || (Type & SymbolRef::ST_Debug) || + (Type & SymbolRef::ST_Unknown)) + continue; + StringRef Name; + uint64_t Addr; + // The only symbols of interest are the global variables. These + // are the only ones that need to be queried because the address + // of common data won't be described in the debug map. All other + // addresses should be fetched for the debug map. + if (Sym.getAddress(Addr) || Addr == UnknownAddressOrSize || + !(Sym.getFlags() & SymbolRef::SF_Global) || + Sym.getSection(Section) || Section->isText() || Sym.getName(Name) || + Name.size() == 0 || Name[0] == '\0') + continue; + MainBinarySymbolAddresses[Name] = Addr; + } +} + +} Index: tools/dsymutil/Makefile =================================================================== --- /dev/null +++ tools/dsymutil/Makefile @@ -0,0 +1,17 @@ +##===- tools/dsymutil/Makefile -----------------------------*- Makefile -*-===## +# +# The LLVM Compiler Infrastructure +# +# This file is distributed under the University of Illinois Open Source +# License. See LICENSE.TXT for details. +# +##===----------------------------------------------------------------------===## + +LEVEL := ../.. +TOOLNAME := llvm-dsymutil +LINK_COMPONENTS := Object Support + +# This tool has no plugins, optimize startup time. +TOOL_NO_EXPORTS := 1 + +include $(LEVEL)/Makefile.common Index: tools/dsymutil/dsymutil.cpp =================================================================== --- /dev/null +++ tools/dsymutil/dsymutil.cpp @@ -0,0 +1,55 @@ +//===-- dsymutil.cpp - Debug info dumping utility for llvm ----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This program is a utility that aims to be a dropin replacement for +// Darwin's dsymutil. +// +//===----------------------------------------------------------------------===// + +#include "DebugMap.h" +#include "DwarfLinker.h" +#include "MachODebugMapParser.h" + +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/PrettyStackTrace.h" +#include "llvm/Support/Options.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/Support/Signals.h" + +#include + +static llvm::cl::opt InputFile(llvm::cl::Positional, + llvm::cl::desc(""), + llvm::cl::init("-")); + +static llvm::cl::opt Verbose("v", llvm::cl::desc("Verbosity level"), + llvm::cl::init(false)); + +int main(int argc, char **argv) { + llvm::sys::PrintStackTraceOnErrorSignal(); + llvm::PrettyStackTraceProgram StackPrinter(argc, argv); + llvm::llvm_shutdown_obj Shutdown; + + llvm::cl::ParseCommandLineOptions(argc, argv, "llvm dsymutil\n"); + + llvm::MachODebugMapParser Parser(InputFile); + llvm::ErrorOr> DebugMap = Parser.parse(); + + if (auto EC = DebugMap.getError()) { + llvm::errs() << "error: Cannot parse the debug map for \"" << InputFile << + "\": " << EC.message() << '\n'; + return 1; + } + + if (Verbose) + (*DebugMap)->dump(); + + llvm::DwarfLinker Linker(InputFile + ".dwarf"); + return !Linker.link(*DebugMap.get()); +}