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
18namespace {
19using namespace llvm;
20using namespace llvm::dsymutil;
21using namespace llvm::object;
22
23class MachODebugMapParser {
24public:
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
41private:
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
99static 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.
105void 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.
113void 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
139static std::string getArchName(const object::MachOObjectFile &Obj) {
140  Triple ThumbTriple;
141  Triple T = Obj.getArch(nullptr, &ThumbTriple);
142  return T.getArchName();
143}
144
145std::unique_ptr<DebugMap>
146MachODebugMapParser::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.
168struct DarwinStabName {
169  uint8_t NType;
170  const char *Name;
171};
172
173static 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
191static 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
199void 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
209void 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
268void 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
289static 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
302bool 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.
322ErrorOr<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.
338void 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.
401void 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.
425uint64_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.
434void 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
466namespace llvm {
467namespace dsymutil {
468llvm::ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
469parseDebugMap(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
479bool 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
486