tools/dsymutil/MachODebugMapParser.cpp

   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 ThumbTriple;
 141   Triple T = Obj.getArch(nullptr, &ThumbTriple);
 142   return T.getArchName();
 143 }
 144
 145 std::unique_ptr<DebugMap>
 146 MachODebugMapParser::parseOneBinary(const MachOObjectFile &MainBinary,
 147                                     StringRef BinaryPath) {
 148   loadMainBinarySymbols(MainBinary);
 149   Result =
 150       make_unique<DebugMap>(BinaryHolder::getTriple(MainBinary), BinaryPath);
 151   MainBinaryStrings = MainBinary.getStringTableData();
 152   for (const SymbolRef &Symbol : MainBinary.symbols()) {
 153     const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
 154     if (MainBinary.is64Bit())
 155       handleStabDebugMapEntry(MainBinary.getSymbol64TableEntry(DRI));
 156     else
 157       handleStabDebugMapEntry(MainBinary.getSymbolTableEntry(DRI));
 158   }
 159
 160   resetParserState();
 161   return std::move(Result);
 162 }
 163
 164 // Table that maps Darwin's Mach-O stab constants to strings to allow printing.
 165 // llvm-nm has very similar code, the strings used here are however slightly
 166 // different and part of the interface of dsymutil (some project's build-systems
 167 // parse the ouptut of dsymutil -s), thus they shouldn't be changed.
 168 struct DarwinStabName {
 169   uint8_t NType;
 170   const char *Name;
 171 };
 172
 173 static const struct DarwinStabName DarwinStabNames[] = {
 174     {MachO::N_GSYM, "N_GSYM"},    {MachO::N_FNAME, "N_FNAME"},
 175     {MachO::N_FUN, "N_FUN"},      {MachO::N_STSYM, "N_STSYM"},
 176     {MachO::N_LCSYM, "N_LCSYM"},  {MachO::N_BNSYM, "N_BNSYM"},
 177     {MachO::N_PC, "N_PC"},        {MachO::N_AST, "N_AST"},
 178     {MachO::N_OPT, "N_OPT"},      {MachO::N_RSYM, "N_RSYM"},
 179     {MachO::N_SLINE, "N_SLINE"},  {MachO::N_ENSYM, "N_ENSYM"},
 180     {MachO::N_SSYM, "N_SSYM"},    {MachO::N_SO, "N_SO"},
 181     {MachO::N_OSO, "N_OSO"},      {MachO::N_LSYM, "N_LSYM"},
 182     {MachO::N_BINCL, "N_BINCL"},  {MachO::N_SOL, "N_SOL"},
 183     {MachO::N_PARAMS, "N_PARAM"}, {MachO::N_VERSION, "N_VERS"},
 184     {MachO::N_OLEVEL, "N_OLEV"},  {MachO::N_PSYM, "N_PSYM"},
 185     {MachO::N_EINCL, "N_EINCL"},  {MachO::N_ENTRY, "N_ENTRY"},
 186     {MachO::N_LBRAC, "N_LBRAC"},  {MachO::N_EXCL, "N_EXCL"},
 187     {MachO::N_RBRAC, "N_RBRAC"},  {MachO::N_BCOMM, "N_BCOMM"},
 188     {MachO::N_ECOMM, "N_ECOMM"},  {MachO::N_ECOML, "N_ECOML"},
 189     {MachO::N_LENG, "N_LENG"},    {0, nullptr}};
 190
 191 static const char *getDarwinStabString(uint8_t NType) {
 192   for (unsigned i = 0; DarwinStabNames[i].Name; i++) {
 193     if (DarwinStabNames[i].NType == NType)
 194       return DarwinStabNames[i].Name;
 195   }
 196   return nullptr;
 197 }
 198
 199 void MachODebugMapParser::dumpSymTabHeader(raw_ostream &OS, StringRef Arch) {
 200   OS << "-----------------------------------"
 201         "-----------------------------------\n";
 202   OS << "Symbol table for: '" << BinaryPath << "' (" << Arch.data() << ")\n";
 203   OS << "-----------------------------------"
 204         "-----------------------------------\n";
 205   OS << "Index    n_strx   n_type             n_sect n_desc n_value\n";
 206   OS << "======== -------- ------------------ ------ ------ ----------------\n";
 207 }
 208
 209 void MachODebugMapParser::dumpSymTabEntry(raw_ostream &OS, uint64_t Index,
 210                                           uint32_t StringIndex, uint8_t Type,
 211                                           uint8_t SectionIndex, uint16_t Flags,
 212                                           uint64_t Value) {
 213   // Index
 214   OS << '[' << format_decimal(Index, 6) << "] "
 215      // n_strx
 216      << format_hex_no_prefix(StringIndex, 8) << ' '
 217      // n_type...
 218      << format_hex_no_prefix(Type, 2) << " (";
 219
 220   if (Type & MachO::N_STAB)
 221     OS << left_justify(getDarwinStabString(Type), 13);
 222   else {
 223     if (Type & MachO::N_PEXT)
 224       OS << "PEXT ";
 225     else
 226       OS << "     ";
 227     switch (Type & MachO::N_TYPE) {
 228     case MachO::N_UNDF: // 0x0 undefined, n_sect == NO_SECT
 229       OS << "UNDF";
 230       break;
 231     case MachO::N_ABS: // 0x2 absolute, n_sect == NO_SECT
 232       OS << "ABS ";
 233       break;
 234     case MachO::N_SECT: // 0xe defined in section number n_sect
 235       OS << "SECT";
 236       break;
 237     case MachO::N_PBUD: // 0xc prebound undefined (defined in a dylib)
 238       OS << "PBUD";
 239       break;
 240     case MachO::N_INDR: // 0xa indirect
 241       OS << "INDR";
 242       break;
 243     default:
 244       OS << format_hex_no_prefix(Type, 2) << "    ";
 245       break;
 246     }
 247     if (Type & MachO::N_EXT)
 248       OS << " EXT";
 249     else
 250       OS << "    ";
 251   }
 252
 253   OS << ") "
 254      // n_sect
 255      << format_hex_no_prefix(SectionIndex, 2) << "     "
 256      // n_desc
 257      << format_hex_no_prefix(Flags, 4) << "   "
 258      // n_value
 259      << format_hex_no_prefix(Value, 16);
 260
 261   const char *Name = &MainBinaryStrings.data()[StringIndex];
 262   if (Name && Name[0])
 263     OS << " '" << Name << "'";
 264
 265   OS << "\n";
 266 }
 267
 268 void MachODebugMapParser::dumpOneBinaryStab(const MachOObjectFile &MainBinary,
 269                                             StringRef BinaryPath) {
 270   loadMainBinarySymbols(MainBinary);
 271   MainBinaryStrings = MainBinary.getStringTableData();
 272   raw_ostream &OS(llvm::outs());
 273
 274   dumpSymTabHeader(OS, getArchName(MainBinary));
 275   uint64_t Idx = 0;
 276   for (const SymbolRef &Symbol : MainBinary.symbols()) {
 277     const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
 278     if (MainBinary.is64Bit())
 279       dumpSymTabEntry(OS, Idx, MainBinary.getSymbol64TableEntry(DRI));
 280     else
 281       dumpSymTabEntry(OS, Idx, MainBinary.getSymbolTableEntry(DRI));
 282     Idx++;
 283   }
 284
 285   OS << "\n\n";
 286   resetParserState();
 287 }
 288
 289 static bool shouldLinkArch(SmallVectorImpl<StringRef> &Archs, StringRef Arch) {
 290   if (Archs.empty() ||
 291       std::find(Archs.begin(), Archs.end(), "all") != Archs.end() ||
 292       std::find(Archs.begin(), Archs.end(), "*") != Archs.end())
 293     return true;
 294
 295   if (Arch.startswith("arm") && Arch != "arm64" &&
 296       std::find(Archs.begin(), Archs.end(), "arm") != Archs.end())
 297     return true;
 298
 299   return std::find(Archs.begin(), Archs.end(), Arch) != Archs.end();
 300 }
 301
 302 bool MachODebugMapParser::dumpStab() {
 303   auto MainBinOrError =
 304       MainBinaryHolder.GetFilesAs<MachOObjectFile>(BinaryPath);
 305   if (auto Error = MainBinOrError.getError()) {
 306     llvm::errs() << "Cannot get '" << BinaryPath
 307                  << "' as MachO file: " << Error.message() << "\n";
 308     return false;
 309   }
 310
 311   Triple T;
 312   for (const auto *Binary : *MainBinOrError)
 313     if (shouldLinkArch(Archs, Binary->getArch(nullptr, &T).getArchName()))
 314       dumpOneBinaryStab(*Binary, BinaryPath);
 315
 316   return true;
 317 }
 318
 319 /// This main parsing routine tries to open the main binary and if
 320 /// successful iterates over the STAB entries. The real parsing is
 321 /// done in handleStabSymbolTableEntry.
 322 ErrorOr<std::vector<std::unique_ptr<DebugMap>>> MachODebugMapParser::parse() {
 323   auto MainBinOrError =
 324       MainBinaryHolder.GetFilesAs<MachOObjectFile>(BinaryPath);
 325   if (auto Error = MainBinOrError.getError())
 326     return Error;
 327
 328   std::vector<std::unique_ptr<DebugMap>> Results;
 329   Triple T;
 330   for (const auto *Binary : *MainBinOrError)
 331     if (shouldLinkArch(Archs, Binary->getArch(nullptr, &T).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 (!ObjectSymIt->getValue())
 393     return;
 394   if (!CurrentDebugMapObject->addSymbol(Name, *ObjectSymIt->getValue(), Value,
 395                                         Size))
 396     return Warning(Twine("failed to insert symbol '") + Name +
 397                    "' in the debug map.");
 398 }
 399
 400 /// Load the current object file symbols into CurrentObjectAddresses.
 401 void MachODebugMapParser::loadCurrentObjectFileSymbols(
 402     const object::MachOObjectFile &Obj) {
 403   CurrentObjectAddresses.clear();
 404
 405   for (auto Sym : Obj.symbols()) {
 406     uint64_t Addr = Sym.getValue();
 407     ErrorOr<StringRef> Name = Sym.getName();
 408     if (!Name)
 409       continue;
 410     // Objective-C on i386 uses artificial absolute symbols to
 411     // perform some link time checks. Those symbols have a fixed 0
 412     // address that might conflict with real symbols in the object
 413     // file. As I cannot see a way for absolute symbols to find
 414     // their way into the debug information, let's just ignore those.
 415     if (Sym.getFlags() & SymbolRef::SF_Absolute)
 416       CurrentObjectAddresses[*Name] = None;
 417     else
 418       CurrentObjectAddresses[*Name] = Addr;
 419   }
 420 }
 421
 422 /// Lookup a symbol address in the main binary symbol table. The
 423 /// parser only needs to query common symbols, thus not every symbol's
 424 /// address is available through this function.
 425 uint64_t MachODebugMapParser::getMainBinarySymbolAddress(StringRef Name) {
 426   auto Sym = MainBinarySymbolAddresses.find(Name);
 427   if (Sym == MainBinarySymbolAddresses.end())
 428     return 0;
 429   return Sym->second;
 430 }
 431
 432 /// Load the interesting main binary symbols' addresses into
 433 /// MainBinarySymbolAddresses.
 434 void MachODebugMapParser::loadMainBinarySymbols(
 435     const MachOObjectFile &MainBinary) {
 436   section_iterator Section = MainBinary.section_end();
 437   MainBinarySymbolAddresses.clear();
 438   for (const auto &Sym : MainBinary.symbols()) {
 439     SymbolRef::Type Type = Sym.getType();
 440     // Skip undefined and STAB entries.
 441     if ((Type & SymbolRef::ST_Debug) || (Type & SymbolRef::ST_Unknown))
 442       continue;
 443     // The only symbols of interest are the global variables. These
 444     // are the only ones that need to be queried because the address
 445     // of common data won't be described in the debug map. All other
 446     // addresses should be fetched for the debug map.
 447     if (!(Sym.getFlags() & SymbolRef::SF_Global))
 448       continue;
 449     ErrorOr<section_iterator> SectionOrErr = Sym.getSection();
 450     if (!SectionOrErr)
 451       continue;
 452     Section = *SectionOrErr;
 453     if (Section == MainBinary.section_end() || Section->isText())
 454       continue;
 455     uint64_t Addr = Sym.getValue();
 456     ErrorOr<StringRef> NameOrErr = Sym.getName();
 457     if (!NameOrErr)
 458       continue;
 459     StringRef Name = *NameOrErr;
 460     if (Name.size() == 0 || Name[0] == '\0')
 461       continue;
 462     MainBinarySymbolAddresses[Name] = Addr;
 463   }
 464 }
 465
 466 namespace llvm {
 467 namespace dsymutil {
 468 llvm::ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
 469 parseDebugMap(StringRef InputFile, ArrayRef<std::string> Archs,
 470               StringRef PrependPath, bool Verbose, bool InputIsYAML) {
 471   if (!InputIsYAML) {
 472     MachODebugMapParser Parser(InputFile, Archs, PrependPath, Verbose);
 473     return Parser.parse();
 474   } else {
 475     return DebugMap::parseYAMLDebugMap(InputFile, PrependPath, Verbose);
 476   }
 477 }
 478
 479 bool dumpStab(StringRef InputFile, ArrayRef<std::string> Archs,
 480               StringRef PrependPath) {
 481   MachODebugMapParser Parser(InputFile, Archs, PrependPath, false);
 482   return Parser.dumpStab();
 483 }
 484 } // namespace dsymutil
 485 } // namespace llvm