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 T = Obj.getArchTriple();
141  return T.getArchName();
142}
143
144std::unique_ptr<DebugMap>
145MachODebugMapParser::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.
166struct DarwinStabName {
167  uint8_t NType;
168  const char *Name;
169};
170
171static 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
189static 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
197void 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
207void 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
266void 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
287static 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
304bool 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.
323ErrorOr<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.
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 (!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.
399void 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.
429uint64_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.
438void 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
482namespace llvm {
483namespace dsymutil {
484llvm::ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
485parseDebugMap(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
495bool 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