Home | History | Annotate | Download | only in dsymutil 
      1 //===- tools/dsymutil/MachODebugMapParser.cpp - Parse STABS debug maps ----===//
      2 //
      3 //                             The LLVM Linker
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 #include "BinaryHolder.h"
     11 #include "DebugMap.h"
     12 #include "dsymutil.h"
     13 #include "llvm/ADT/Optional.h"
     14 #include "llvm/Object/MachO.h"
     15 #include "llvm/Support/Path.h"
     16 #include "llvm/Support/raw_ostream.h"
     17 
     18 namespace {
     19 using namespace llvm;
     20 using namespace llvm::dsymutil;
     21 using namespace llvm::object;
     22 
     23 class MachODebugMapParser {
     24 public:
     25   MachODebugMapParser(StringRef BinaryPath, ArrayRef<std::string> Archs,
     26                       StringRef PathPrefix = "", bool Verbose = false)
     27       : BinaryPath(BinaryPath), Archs(Archs.begin(), Archs.end()),
     28         PathPrefix(PathPrefix), MainBinaryHolder(Verbose),
     29         CurrentObjectHolder(Verbose), CurrentDebugMapObject(nullptr) {}
     30 
     31   /// \brief Parses and returns the DebugMaps of the input binary.
     32   /// The binary contains multiple maps in case it is a universal
     33   /// binary.
     34   /// \returns an error in case the provided BinaryPath doesn't exist
     35   /// or isn't of a supported type.
     36   ErrorOr<std::vector<std::unique_ptr<DebugMap>>> parse();
     37 
     38   /// Walk the symbol table and dump it.
     39   bool dumpStab();
     40 
     41 private:
     42   std::string BinaryPath;
     43   SmallVector<StringRef, 1> Archs;
     44   std::string PathPrefix;
     45 
     46   /// Owns the MemoryBuffer for the main binary.
     47   BinaryHolder MainBinaryHolder;
     48   /// Map of the binary symbol addresses.
     49   StringMap<uint64_t> MainBinarySymbolAddresses;
     50   StringRef MainBinaryStrings;
     51   /// The constructed DebugMap.
     52   std::unique_ptr<DebugMap> Result;
     53 
     54   /// Owns the MemoryBuffer for the currently handled object file.
     55   BinaryHolder CurrentObjectHolder;
     56   /// Map of the currently processed object file symbol addresses.
     57   StringMap<Optional<uint64_t>> CurrentObjectAddresses;
     58   /// Element of the debug map corresponfing to the current object file.
     59   DebugMapObject *CurrentDebugMapObject;
     60 
     61   /// Holds function info while function scope processing.
     62   const char *CurrentFunctionName;
     63   uint64_t CurrentFunctionAddress;
     64 
     65   std::unique_ptr<DebugMap> parseOneBinary(const MachOObjectFile &MainBinary,
     66                                            StringRef BinaryPath);
     67 
     68   void switchToNewDebugMapObject(StringRef Filename, sys::TimeValue Timestamp);
     69   void resetParserState();
     70   uint64_t getMainBinarySymbolAddress(StringRef Name);
     71   void loadMainBinarySymbols(const MachOObjectFile &MainBinary);
     72   void loadCurrentObjectFileSymbols(const object::MachOObjectFile &Obj);
     73   void handleStabSymbolTableEntry(uint32_t StringIndex, uint8_t Type,
     74                                   uint8_t SectionIndex, uint16_t Flags,
     75                                   uint64_t Value);
     76 
     77   template <typename STEType> void handleStabDebugMapEntry(const STEType &STE) {
     78     handleStabSymbolTableEntry(STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc,
     79                                STE.n_value);
     80   }
     81 
     82   /// Dump the symbol table output header.
     83   void dumpSymTabHeader(raw_ostream &OS, StringRef Arch);
     84 
     85   /// Dump the contents of nlist entries.
     86   void dumpSymTabEntry(raw_ostream &OS, uint64_t Index, uint32_t StringIndex,
     87                        uint8_t Type, uint8_t SectionIndex, uint16_t Flags,
     88                        uint64_t Value);
     89 
     90   template <typename STEType>
     91   void dumpSymTabEntry(raw_ostream &OS, uint64_t Index, const STEType &STE) {
     92     dumpSymTabEntry(OS, Index, STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc,
     93                     STE.n_value);
     94   }
     95   void dumpOneBinaryStab(const MachOObjectFile &MainBinary,
     96                          StringRef BinaryPath);
     97 };
     98 
     99 static void Warning(const Twine &Msg) { errs() << "warning: " + Msg + "\n"; }
    100 } // anonymous namespace
    101 
    102 /// Reset the parser state coresponding to the current object
    103 /// file. This is to be called after an object file is finished
    104 /// processing.
    105 void MachODebugMapParser::resetParserState() {
    106   CurrentObjectAddresses.clear();
    107   CurrentDebugMapObject = nullptr;
    108 }
    109 
    110 /// Create a new DebugMapObject. This function resets the state of the
    111 /// parser that was referring to the last object file and sets
    112 /// everything up to add symbols to the new one.
    113 void MachODebugMapParser::switchToNewDebugMapObject(StringRef Filename,
    114                                                     sys::TimeValue Timestamp) {
    115   resetParserState();
    116 
    117   SmallString<80> Path(PathPrefix);
    118   sys::path::append(Path, Filename);
    119 
    120   auto MachOOrError =
    121       CurrentObjectHolder.GetFilesAs<MachOObjectFile>(Path, Timestamp);
    122   if (auto Error = MachOOrError.getError()) {
    123     Warning(Twine("cannot open debug object \"") + Path.str() + "\": " +
    124             Error.message() + "\n");
    125     return;
    126   }
    127 
    128   auto ErrOrAchObj =
    129       CurrentObjectHolder.GetAs<MachOObjectFile>(Result->getTriple());
    130   if (auto Err = ErrOrAchObj.getError()) {
    131     return Warning(Twine("cannot open debug object \"") + Path.str() + "\": " +
    132                    Err.message() + "\n");
    133   }
    134 
    135   CurrentDebugMapObject = &Result->addDebugMapObject(Path, Timestamp);
    136   loadCurrentObjectFileSymbols(*ErrOrAchObj);
    137 }
    138 
    139 static std::string getArchName(const object::MachOObjectFile &Obj) {
    140   Triple T = Obj.getArchTriple();
    141   return T.getArchName();
    142 }
    143 
    144 std::unique_ptr<DebugMap>
    145 MachODebugMapParser::parseOneBinary(const MachOObjectFile &MainBinary,
    146                                     StringRef BinaryPath) {
    147   loadMainBinarySymbols(MainBinary);
    148   Result = make_unique<DebugMap>(MainBinary.getArchTriple(), BinaryPath);
    149   MainBinaryStrings = MainBinary.getStringTableData();
    150   for (const SymbolRef &Symbol : MainBinary.symbols()) {
    151     const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
    152     if (MainBinary.is64Bit())
    153       handleStabDebugMapEntry(MainBinary.getSymbol64TableEntry(DRI));
    154     else
    155       handleStabDebugMapEntry(MainBinary.getSymbolTableEntry(DRI));
    156   }
    157 
    158   resetParserState();
    159   return std::move(Result);
    160 }
    161 
    162 // Table that maps Darwin's Mach-O stab constants to strings to allow printing.
    163 // llvm-nm has very similar code, the strings used here are however slightly
    164 // different and part of the interface of dsymutil (some project's build-systems
    165 // parse the ouptut of dsymutil -s), thus they shouldn't be changed.
    166 struct DarwinStabName {
    167   uint8_t NType;
    168   const char *Name;
    169 };
    170 
    171 static const struct DarwinStabName DarwinStabNames[] = {
    172     {MachO::N_GSYM, "N_GSYM"},    {MachO::N_FNAME, "N_FNAME"},
    173     {MachO::N_FUN, "N_FUN"},      {MachO::N_STSYM, "N_STSYM"},
    174     {MachO::N_LCSYM, "N_LCSYM"},  {MachO::N_BNSYM, "N_BNSYM"},
    175     {MachO::N_PC, "N_PC"},        {MachO::N_AST, "N_AST"},
    176     {MachO::N_OPT, "N_OPT"},      {MachO::N_RSYM, "N_RSYM"},
    177     {MachO::N_SLINE, "N_SLINE"},  {MachO::N_ENSYM, "N_ENSYM"},
    178     {MachO::N_SSYM, "N_SSYM"},    {MachO::N_SO, "N_SO"},
    179     {MachO::N_OSO, "N_OSO"},      {MachO::N_LSYM, "N_LSYM"},
    180     {MachO::N_BINCL, "N_BINCL"},  {MachO::N_SOL, "N_SOL"},
    181     {MachO::N_PARAMS, "N_PARAM"}, {MachO::N_VERSION, "N_VERS"},
    182     {MachO::N_OLEVEL, "N_OLEV"},  {MachO::N_PSYM, "N_PSYM"},
    183     {MachO::N_EINCL, "N_EINCL"},  {MachO::N_ENTRY, "N_ENTRY"},
    184     {MachO::N_LBRAC, "N_LBRAC"},  {MachO::N_EXCL, "N_EXCL"},
    185     {MachO::N_RBRAC, "N_RBRAC"},  {MachO::N_BCOMM, "N_BCOMM"},
    186     {MachO::N_ECOMM, "N_ECOMM"},  {MachO::N_ECOML, "N_ECOML"},
    187     {MachO::N_LENG, "N_LENG"},    {0, nullptr}};
    188 
    189 static const char *getDarwinStabString(uint8_t NType) {
    190   for (unsigned i = 0; DarwinStabNames[i].Name; i++) {
    191     if (DarwinStabNames[i].NType == NType)
    192       return DarwinStabNames[i].Name;
    193   }
    194   return nullptr;
    195 }
    196 
    197 void MachODebugMapParser::dumpSymTabHeader(raw_ostream &OS, StringRef Arch) {
    198   OS << "-----------------------------------"
    199         "-----------------------------------\n";
    200   OS << "Symbol table for: '" << BinaryPath << "' (" << Arch.data() << ")\n";
    201   OS << "-----------------------------------"
    202         "-----------------------------------\n";
    203   OS << "Index    n_strx   n_type             n_sect n_desc n_value\n";
    204   OS << "======== -------- ------------------ ------ ------ ----------------\n";
    205 }
    206 
    207 void MachODebugMapParser::dumpSymTabEntry(raw_ostream &OS, uint64_t Index,
    208                                           uint32_t StringIndex, uint8_t Type,
    209                                           uint8_t SectionIndex, uint16_t Flags,
    210                                           uint64_t Value) {
    211   // Index
    212   OS << '[' << format_decimal(Index, 6) << "] "
    213      // n_strx
    214      << format_hex_no_prefix(StringIndex, 8) << ' '
    215      // n_type...
    216      << format_hex_no_prefix(Type, 2) << " (";
    217 
    218   if (Type & MachO::N_STAB)
    219     OS << left_justify(getDarwinStabString(Type), 13);
    220   else {
    221     if (Type & MachO::N_PEXT)
    222       OS << "PEXT ";
    223     else
    224       OS << "     ";
    225     switch (Type & MachO::N_TYPE) {
    226     case MachO::N_UNDF: // 0x0 undefined, n_sect == NO_SECT
    227       OS << "UNDF";
    228       break;
    229     case MachO::N_ABS: // 0x2 absolute, n_sect == NO_SECT
    230       OS << "ABS ";
    231       break;
    232     case MachO::N_SECT: // 0xe defined in section number n_sect
    233       OS << "SECT";
    234       break;
    235     case MachO::N_PBUD: // 0xc prebound undefined (defined in a dylib)
    236       OS << "PBUD";
    237       break;
    238     case MachO::N_INDR: // 0xa indirect
    239       OS << "INDR";
    240       break;
    241     default:
    242       OS << format_hex_no_prefix(Type, 2) << "    ";
    243       break;
    244     }
    245     if (Type & MachO::N_EXT)
    246       OS << " EXT";
    247     else
    248       OS << "    ";
    249   }
    250 
    251   OS << ") "
    252      // n_sect
    253      << format_hex_no_prefix(SectionIndex, 2) << "     "
    254      // n_desc
    255      << format_hex_no_prefix(Flags, 4) << "   "
    256      // n_value
    257      << format_hex_no_prefix(Value, 16);
    258 
    259   const char *Name = &MainBinaryStrings.data()[StringIndex];
    260   if (Name && Name[0])
    261     OS << " '" << Name << "'";
    262 
    263   OS << "\n";
    264 }
    265 
    266 void MachODebugMapParser::dumpOneBinaryStab(const MachOObjectFile &MainBinary,
    267                                             StringRef BinaryPath) {
    268   loadMainBinarySymbols(MainBinary);
    269   MainBinaryStrings = MainBinary.getStringTableData();
    270   raw_ostream &OS(llvm::outs());
    271 
    272   dumpSymTabHeader(OS, getArchName(MainBinary));
    273   uint64_t Idx = 0;
    274   for (const SymbolRef &Symbol : MainBinary.symbols()) {
    275     const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
    276     if (MainBinary.is64Bit())
    277       dumpSymTabEntry(OS, Idx, MainBinary.getSymbol64TableEntry(DRI));
    278     else
    279       dumpSymTabEntry(OS, Idx, MainBinary.getSymbolTableEntry(DRI));
    280     Idx++;
    281   }
    282 
    283   OS << "\n\n";
    284   resetParserState();
    285 }
    286 
    287 static bool shouldLinkArch(SmallVectorImpl<StringRef> &Archs, StringRef Arch) {
    288   if (Archs.empty() ||
    289       std::find(Archs.begin(), Archs.end(), "all") != Archs.end() ||
    290       std::find(Archs.begin(), Archs.end(), "*") != Archs.end())
    291     return true;
    292 
    293   if (Arch.startswith("arm") && Arch != "arm64" &&
    294       std::find(Archs.begin(), Archs.end(), "arm") != Archs.end())
    295     return true;
    296 
    297   SmallString<16> ArchName = Arch;
    298   if (Arch.startswith("thumb"))
    299     ArchName = ("arm" + Arch.substr(5)).str();
    300 
    301   return std::find(Archs.begin(), Archs.end(), ArchName) != Archs.end();
    302 }
    303 
    304 bool MachODebugMapParser::dumpStab() {
    305   auto MainBinOrError =
    306       MainBinaryHolder.GetFilesAs<MachOObjectFile>(BinaryPath);
    307   if (auto Error = MainBinOrError.getError()) {
    308     llvm::errs() << "Cannot get '" << BinaryPath
    309                  << "' as MachO file: " << Error.message() << "\n";
    310     return false;
    311   }
    312 
    313   for (const auto *Binary : *MainBinOrError)
    314     if (shouldLinkArch(Archs, Binary->getArchTriple().getArchName()))
    315       dumpOneBinaryStab(*Binary, BinaryPath);
    316 
    317   return true;
    318 }
    319 
    320 /// This main parsing routine tries to open the main binary and if
    321 /// successful iterates over the STAB entries. The real parsing is
    322 /// done in handleStabSymbolTableEntry.
    323 ErrorOr<std::vector<std::unique_ptr<DebugMap>>> MachODebugMapParser::parse() {
    324   auto MainBinOrError =
    325       MainBinaryHolder.GetFilesAs<MachOObjectFile>(BinaryPath);
    326   if (auto Error = MainBinOrError.getError())
    327     return Error;
    328 
    329   std::vector<std::unique_ptr<DebugMap>> Results;
    330   for (const auto *Binary : *MainBinOrError)
    331     if (shouldLinkArch(Archs, Binary->getArchTriple().getArchName()))
    332       Results.push_back(parseOneBinary(*Binary, BinaryPath));
    333 
    334   return std::move(Results);
    335 }
    336 
    337 /// Interpret the STAB entries to fill the DebugMap.
    338 void MachODebugMapParser::handleStabSymbolTableEntry(uint32_t StringIndex,
    339                                                      uint8_t Type,
    340                                                      uint8_t SectionIndex,
    341                                                      uint16_t Flags,
    342                                                      uint64_t Value) {
    343   if (!(Type & MachO::N_STAB))
    344     return;
    345 
    346   const char *Name = &MainBinaryStrings.data()[StringIndex];
    347 
    348   // An N_OSO entry represents the start of a new object file description.
    349   if (Type == MachO::N_OSO) {
    350     sys::TimeValue Timestamp;
    351     Timestamp.fromEpochTime(Value);
    352     return switchToNewDebugMapObject(Name, Timestamp);
    353   }
    354 
    355   // If the last N_OSO object file wasn't found,
    356   // CurrentDebugMapObject will be null. Do not update anything
    357   // until we find the next valid N_OSO entry.
    358   if (!CurrentDebugMapObject)
    359     return;
    360 
    361   uint32_t Size = 0;
    362   switch (Type) {
    363   case MachO::N_GSYM:
    364     // This is a global variable. We need to query the main binary
    365     // symbol table to find its address as it might not be in the
    366     // debug map (for common symbols).
    367     Value = getMainBinarySymbolAddress(Name);
    368     break;
    369   case MachO::N_FUN:
    370     // Functions are scopes in STABS. They have an end marker that
    371     // contains the function size.
    372     if (Name[0] == '\0') {
    373       Size = Value;
    374       Value = CurrentFunctionAddress;
    375       Name = CurrentFunctionName;
    376       break;
    377     } else {
    378       CurrentFunctionName = Name;
    379       CurrentFunctionAddress = Value;
    380       return;
    381     }
    382   case MachO::N_STSYM:
    383     break;
    384   default:
    385     return;
    386   }
    387 
    388   auto ObjectSymIt = CurrentObjectAddresses.find(Name);
    389   if (ObjectSymIt == CurrentObjectAddresses.end())
    390     return Warning("could not find object file symbol for symbol " +
    391                    Twine(Name));
    392   if (!CurrentDebugMapObject->addSymbol(Name, ObjectSymIt->getValue(), Value,
    393                                         Size))
    394     return Warning(Twine("failed to insert symbol '") + Name +
    395                    "' in the debug map.");
    396 }
    397 
    398 /// Load the current object file symbols into CurrentObjectAddresses.
    399 void MachODebugMapParser::loadCurrentObjectFileSymbols(
    400     const object::MachOObjectFile &Obj) {
    401   CurrentObjectAddresses.clear();
    402 
    403   for (auto Sym : Obj.symbols()) {
    404     uint64_t Addr = Sym.getValue();
    405     Expected<StringRef> Name = Sym.getName();
    406     if (!Name) {
    407       // TODO: Actually report errors helpfully.
    408       consumeError(Name.takeError());
    409       continue;
    410     }
    411     // The value of some categories of symbols isn't meaningful. For
    412     // example common symbols store their size in the value field, not
    413     // their address. Absolute symbols have a fixed address that can
    414     // conflict with standard symbols. These symbols (especially the
    415     // common ones), might still be referenced by relocations. These
    416     // relocations will use the symbol itself, and won't need an
    417     // object file address. The object file address field is optional
    418     // in the DebugMap, leave it unassigned for these symbols.
    419     if (Sym.getFlags() & (SymbolRef::SF_Absolute | SymbolRef::SF_Common))
    420       CurrentObjectAddresses[*Name] = None;
    421     else
    422       CurrentObjectAddresses[*Name] = Addr;
    423   }
    424 }
    425 
    426 /// Lookup a symbol address in the main binary symbol table. The
    427 /// parser only needs to query common symbols, thus not every symbol's
    428 /// address is available through this function.
    429 uint64_t MachODebugMapParser::getMainBinarySymbolAddress(StringRef Name) {
    430   auto Sym = MainBinarySymbolAddresses.find(Name);
    431   if (Sym == MainBinarySymbolAddresses.end())
    432     return 0;
    433   return Sym->second;
    434 }
    435 
    436 /// Load the interesting main binary symbols' addresses into
    437 /// MainBinarySymbolAddresses.
    438 void MachODebugMapParser::loadMainBinarySymbols(
    439     const MachOObjectFile &MainBinary) {
    440   section_iterator Section = MainBinary.section_end();
    441   MainBinarySymbolAddresses.clear();
    442   for (const auto &Sym : MainBinary.symbols()) {
    443     Expected<SymbolRef::Type> TypeOrErr = Sym.getType();
    444     if (!TypeOrErr) {
    445       // TODO: Actually report errors helpfully.
    446       consumeError(TypeOrErr.takeError());
    447       continue;
    448     }
    449     SymbolRef::Type Type = *TypeOrErr;
    450     // Skip undefined and STAB entries.
    451     if ((Type & SymbolRef::ST_Debug) || (Type & SymbolRef::ST_Unknown))
    452       continue;
    453     // The only symbols of interest are the global variables. These
    454     // are the only ones that need to be queried because the address
    455     // of common data won't be described in the debug map. All other
    456     // addresses should be fetched for the debug map.
    457     if (!(Sym.getFlags() & SymbolRef::SF_Global))
    458       continue;
    459     Expected<section_iterator> SectionOrErr = Sym.getSection();
    460     if (!SectionOrErr) {
    461       // TODO: Actually report errors helpfully.
    462       consumeError(SectionOrErr.takeError());
    463       continue;
    464     }
    465     Section = *SectionOrErr;
    466     if (Section == MainBinary.section_end() || Section->isText())
    467       continue;
    468     uint64_t Addr = Sym.getValue();
    469     Expected<StringRef> NameOrErr = Sym.getName();
    470     if (!NameOrErr) {
    471       // TODO: Actually report errors helpfully.
    472       consumeError(NameOrErr.takeError());
    473       continue;
    474     }
    475     StringRef Name = *NameOrErr;
    476     if (Name.size() == 0 || Name[0] == '\0')
    477       continue;
    478     MainBinarySymbolAddresses[Name] = Addr;
    479   }
    480 }
    481 
    482 namespace llvm {
    483 namespace dsymutil {
    484 llvm::ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
    485 parseDebugMap(StringRef InputFile, ArrayRef<std::string> Archs,
    486               StringRef PrependPath, bool Verbose, bool InputIsYAML) {
    487   if (!InputIsYAML) {
    488     MachODebugMapParser Parser(InputFile, Archs, PrependPath, Verbose);
    489     return Parser.parse();
    490   } else {
    491     return DebugMap::parseYAMLDebugMap(InputFile, PrependPath, Verbose);
    492   }
    493 }
    494 
    495 bool dumpStab(StringRef InputFile, ArrayRef<std::string> Archs,
    496               StringRef PrependPath) {
    497   MachODebugMapParser Parser(InputFile, Archs, PrependPath, false);
    498   return Parser.dumpStab();
    499 }
    500 } // namespace dsymutil
    501 } // namespace llvm
    502