1 //===- tools/dsymutil/MachODebugMapParser.cpp - Parse STABS debug maps ----===//
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "BinaryHolder.h"
13 #include "llvm/Object/MachO.h"
14 #include "llvm/Support/Path.h"
15 #include "llvm/Support/raw_ostream.h"
19 using namespace llvm::dsymutil;
20 using namespace llvm::object;
22 class MachODebugMapParser {
24 MachODebugMapParser(StringRef BinaryPath, ArrayRef<std::string> Archs,
25 StringRef PathPrefix = "", bool Verbose = false)
26 : BinaryPath(BinaryPath), Archs(Archs.begin(), Archs.end()),
27 PathPrefix(PathPrefix), MainBinaryHolder(Verbose),
28 CurrentObjectHolder(Verbose), CurrentDebugMapObject(nullptr) {}
30 /// \brief Parses and returns the DebugMaps of the input binary.
31 /// The binary contains multiple maps in case it is a universal
33 /// \returns an error in case the provided BinaryPath doesn't exist
34 /// or isn't of a supported type.
35 ErrorOr<std::vector<std::unique_ptr<DebugMap>>> parse();
37 /// Walk the symbol table and dump it.
41 std::string BinaryPath;
42 SmallVector<StringRef, 1> Archs;
43 std::string PathPrefix;
45 /// Owns the MemoryBuffer for the main binary.
46 BinaryHolder MainBinaryHolder;
47 /// Map of the binary symbol addresses.
48 StringMap<uint64_t> MainBinarySymbolAddresses;
49 StringRef MainBinaryStrings;
50 /// The constructed DebugMap.
51 std::unique_ptr<DebugMap> Result;
53 /// Owns the MemoryBuffer for the currently handled object file.
54 BinaryHolder CurrentObjectHolder;
55 /// Map of the currently processed object file symbol addresses.
56 StringMap<uint64_t> CurrentObjectAddresses;
57 /// Element of the debug map corresponfing to the current object file.
58 DebugMapObject *CurrentDebugMapObject;
60 /// Holds function info while function scope processing.
61 const char *CurrentFunctionName;
62 uint64_t CurrentFunctionAddress;
64 std::unique_ptr<DebugMap> parseOneBinary(const MachOObjectFile &MainBinary,
65 StringRef BinaryPath);
67 void switchToNewDebugMapObject(StringRef Filename, sys::TimeValue Timestamp);
68 void resetParserState();
69 uint64_t getMainBinarySymbolAddress(StringRef Name);
70 void loadMainBinarySymbols(const MachOObjectFile &MainBinary);
71 void loadCurrentObjectFileSymbols(const object::MachOObjectFile &Obj);
72 void handleStabSymbolTableEntry(uint32_t StringIndex, uint8_t Type,
73 uint8_t SectionIndex, uint16_t Flags,
76 template <typename STEType> void handleStabDebugMapEntry(const STEType &STE) {
77 handleStabSymbolTableEntry(STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc,
81 /// Dump the symbol table output header.
82 void dumpSymTabHeader(raw_ostream &OS, StringRef Arch);
84 /// Dump the contents of nlist entries.
85 void dumpSymTabEntry(raw_ostream &OS, uint64_t Index, uint32_t StringIndex,
86 uint8_t Type, uint8_t SectionIndex, uint16_t Flags,
89 template <typename STEType>
90 void dumpSymTabEntry(raw_ostream &OS, uint64_t Index, const STEType &STE) {
91 dumpSymTabEntry(OS, Index, STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc,
94 void dumpOneBinaryStab(const MachOObjectFile &MainBinary,
95 StringRef BinaryPath);
98 static void Warning(const Twine &Msg) { errs() << "warning: " + Msg + "\n"; }
99 } // anonymous namespace
101 /// Reset the parser state coresponding to the current object
102 /// file. This is to be called after an object file is finished
104 void MachODebugMapParser::resetParserState() {
105 CurrentObjectAddresses.clear();
106 CurrentDebugMapObject = nullptr;
109 /// Create a new DebugMapObject. This function resets the state of the
110 /// parser that was referring to the last object file and sets
111 /// everything up to add symbols to the new one.
112 void MachODebugMapParser::switchToNewDebugMapObject(StringRef Filename,
113 sys::TimeValue Timestamp) {
116 SmallString<80> Path(PathPrefix);
117 sys::path::append(Path, Filename);
120 CurrentObjectHolder.GetFilesAs<MachOObjectFile>(Path, Timestamp);
121 if (auto Error = MachOOrError.getError()) {
122 Warning(Twine("cannot open debug object \"") + Path.str() + "\": " +
123 Error.message() + "\n");
128 CurrentObjectHolder.GetAs<MachOObjectFile>(Result->getTriple());
129 if (auto Err = ErrOrAchObj.getError()) {
130 return Warning(Twine("cannot open debug object \"") + Path.str() + "\": " +
131 Err.message() + "\n");
134 CurrentDebugMapObject = &Result->addDebugMapObject(Path, Timestamp);
135 loadCurrentObjectFileSymbols(*ErrOrAchObj);
138 static std::string getArchName(const object::MachOObjectFile &Obj) {
140 Triple T = Obj.getArch(nullptr, &ThumbTriple);
141 return T.getArchName();
144 std::unique_ptr<DebugMap>
145 MachODebugMapParser::parseOneBinary(const MachOObjectFile &MainBinary,
146 StringRef BinaryPath) {
147 loadMainBinarySymbols(MainBinary);
149 make_unique<DebugMap>(BinaryHolder::getTriple(MainBinary), BinaryPath);
150 MainBinaryStrings = MainBinary.getStringTableData();
151 for (const SymbolRef &Symbol : MainBinary.symbols()) {
152 const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
153 if (MainBinary.is64Bit())
154 handleStabDebugMapEntry(MainBinary.getSymbol64TableEntry(DRI));
156 handleStabDebugMapEntry(MainBinary.getSymbolTableEntry(DRI));
160 return std::move(Result);
163 // Table that maps Darwin's Mach-O stab constants to strings to allow printing.
164 // llvm-nm has very similar code, the strings used here are however slightly
165 // different and part of the interface of dsymutil (some project's build-systems
166 // parse the ouptut of dsymutil -s), thus they shouldn't be changed.
167 struct DarwinStabName {
172 static const struct DarwinStabName DarwinStabNames[] = {
173 {MachO::N_GSYM, "N_GSYM"}, {MachO::N_FNAME, "N_FNAME"},
174 {MachO::N_FUN, "N_FUN"}, {MachO::N_STSYM, "N_STSYM"},
175 {MachO::N_LCSYM, "N_LCSYM"}, {MachO::N_BNSYM, "N_BNSYM"},
176 {MachO::N_PC, "N_PC"}, {MachO::N_AST, "N_AST"},
177 {MachO::N_OPT, "N_OPT"}, {MachO::N_RSYM, "N_RSYM"},
178 {MachO::N_SLINE, "N_SLINE"}, {MachO::N_ENSYM, "N_ENSYM"},
179 {MachO::N_SSYM, "N_SSYM"}, {MachO::N_SO, "N_SO"},
180 {MachO::N_OSO, "N_OSO"}, {MachO::N_LSYM, "N_LSYM"},
181 {MachO::N_BINCL, "N_BINCL"}, {MachO::N_SOL, "N_SOL"},
182 {MachO::N_PARAMS, "N_PARAM"}, {MachO::N_VERSION, "N_VERS"},
183 {MachO::N_OLEVEL, "N_OLEV"}, {MachO::N_PSYM, "N_PSYM"},
184 {MachO::N_EINCL, "N_EINCL"}, {MachO::N_ENTRY, "N_ENTRY"},
185 {MachO::N_LBRAC, "N_LBRAC"}, {MachO::N_EXCL, "N_EXCL"},
186 {MachO::N_RBRAC, "N_RBRAC"}, {MachO::N_BCOMM, "N_BCOMM"},
187 {MachO::N_ECOMM, "N_ECOMM"}, {MachO::N_ECOML, "N_ECOML"},
188 {MachO::N_LENG, "N_LENG"}, {0, nullptr}};
190 static const char *getDarwinStabString(uint8_t NType) {
191 for (unsigned i = 0; DarwinStabNames[i].Name; i++) {
192 if (DarwinStabNames[i].NType == NType)
193 return DarwinStabNames[i].Name;
198 void MachODebugMapParser::dumpSymTabHeader(raw_ostream &OS, StringRef Arch) {
199 OS << "-----------------------------------"
200 "-----------------------------------\n";
201 OS << "Symbol table for: '" << BinaryPath << "' (" << Arch.data() << ")\n";
202 OS << "-----------------------------------"
203 "-----------------------------------\n";
204 OS << "Index n_strx n_type n_sect n_desc n_value\n";
205 OS << "======== -------- ------------------ ------ ------ ----------------\n";
208 void MachODebugMapParser::dumpSymTabEntry(raw_ostream &OS, uint64_t Index,
209 uint32_t StringIndex, uint8_t Type,
210 uint8_t SectionIndex, uint16_t Flags,
213 OS << '[' << format_decimal(Index, 6) << "] "
215 << format_hex_no_prefix(StringIndex, 8) << ' '
217 << format_hex_no_prefix(Type, 2) << " (";
219 if (Type & MachO::N_STAB)
220 OS << left_justify(getDarwinStabString(Type), 13);
222 if (Type & MachO::N_PEXT)
226 switch (Type & MachO::N_TYPE) {
227 case MachO::N_UNDF: // 0x0 undefined, n_sect == NO_SECT
230 case MachO::N_ABS: // 0x2 absolute, n_sect == NO_SECT
233 case MachO::N_SECT: // 0xe defined in section number n_sect
236 case MachO::N_PBUD: // 0xc prebound undefined (defined in a dylib)
239 case MachO::N_INDR: // 0xa indirect
243 OS << format_hex_no_prefix(Type, 2) << " ";
246 if (Type & MachO::N_EXT)
254 << format_hex_no_prefix(SectionIndex, 2) << " "
256 << format_hex_no_prefix(Flags, 4) << " "
258 << format_hex_no_prefix(Value, 16);
260 const char *Name = &MainBinaryStrings.data()[StringIndex];
262 OS << " '" << Name << "'";
267 void MachODebugMapParser::dumpOneBinaryStab(const MachOObjectFile &MainBinary,
268 StringRef BinaryPath) {
269 loadMainBinarySymbols(MainBinary);
270 MainBinaryStrings = MainBinary.getStringTableData();
271 raw_ostream &OS(llvm::outs());
273 dumpSymTabHeader(OS, getArchName(MainBinary));
275 for (const SymbolRef &Symbol : MainBinary.symbols()) {
276 const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
277 if (MainBinary.is64Bit())
278 dumpSymTabEntry(OS, Idx, MainBinary.getSymbol64TableEntry(DRI));
280 dumpSymTabEntry(OS, Idx, MainBinary.getSymbolTableEntry(DRI));
288 static bool shouldLinkArch(SmallVectorImpl<StringRef> &Archs, StringRef Arch) {
290 std::find(Archs.begin(), Archs.end(), "all") != Archs.end() ||
291 std::find(Archs.begin(), Archs.end(), "*") != Archs.end())
294 if (Arch.startswith("arm") && Arch != "arm64" &&
295 std::find(Archs.begin(), Archs.end(), "arm") != Archs.end())
298 return std::find(Archs.begin(), Archs.end(), Arch) != Archs.end();
301 bool MachODebugMapParser::dumpStab() {
302 auto MainBinOrError =
303 MainBinaryHolder.GetFilesAs<MachOObjectFile>(BinaryPath);
304 if (auto Error = MainBinOrError.getError()) {
305 llvm::errs() << "Cannot get '" << BinaryPath
306 << "' as MachO file: " << Error.message() << "\n";
311 for (const auto *Binary : *MainBinOrError)
312 if (shouldLinkArch(Archs, Binary->getArch(nullptr, &T).getArchName()))
313 dumpOneBinaryStab(*Binary, BinaryPath);
318 /// This main parsing routine tries to open the main binary and if
319 /// successful iterates over the STAB entries. The real parsing is
320 /// done in handleStabSymbolTableEntry.
321 ErrorOr<std::vector<std::unique_ptr<DebugMap>>> MachODebugMapParser::parse() {
322 auto MainBinOrError =
323 MainBinaryHolder.GetFilesAs<MachOObjectFile>(BinaryPath);
324 if (auto Error = MainBinOrError.getError())
327 std::vector<std::unique_ptr<DebugMap>> Results;
329 for (const auto *Binary : *MainBinOrError)
330 if (shouldLinkArch(Archs, Binary->getArch(nullptr, &T).getArchName()))
331 Results.push_back(parseOneBinary(*Binary, BinaryPath));
333 return std::move(Results);
336 /// Interpret the STAB entries to fill the DebugMap.
337 void MachODebugMapParser::handleStabSymbolTableEntry(uint32_t StringIndex,
339 uint8_t SectionIndex,
342 if (!(Type & MachO::N_STAB))
345 const char *Name = &MainBinaryStrings.data()[StringIndex];
347 // An N_OSO entry represents the start of a new object file description.
348 if (Type == MachO::N_OSO) {
349 sys::TimeValue Timestamp;
350 Timestamp.fromEpochTime(Value);
351 return switchToNewDebugMapObject(Name, Timestamp);
354 // If the last N_OSO object file wasn't found,
355 // CurrentDebugMapObject will be null. Do not update anything
356 // until we find the next valid N_OSO entry.
357 if (!CurrentDebugMapObject)
363 // This is a global variable. We need to query the main binary
364 // symbol table to find its address as it might not be in the
365 // debug map (for common symbols).
366 Value = getMainBinarySymbolAddress(Name);
369 // Functions are scopes in STABS. They have an end marker that
370 // contains the function size.
371 if (Name[0] == '\0') {
373 Value = CurrentFunctionAddress;
374 Name = CurrentFunctionName;
377 CurrentFunctionName = Name;
378 CurrentFunctionAddress = Value;
387 auto ObjectSymIt = CurrentObjectAddresses.find(Name);
388 if (ObjectSymIt == CurrentObjectAddresses.end())
389 return Warning("could not find object file symbol for symbol " +
391 if (!CurrentDebugMapObject->addSymbol(Name, ObjectSymIt->getValue(), Value,
393 return Warning(Twine("failed to insert symbol '") + Name +
394 "' in the debug map.");
397 /// Load the current object file symbols into CurrentObjectAddresses.
398 void MachODebugMapParser::loadCurrentObjectFileSymbols(
399 const object::MachOObjectFile &Obj) {
400 CurrentObjectAddresses.clear();
402 for (auto Sym : Obj.symbols()) {
403 uint64_t Addr = Sym.getValue();
404 ErrorOr<StringRef> Name = Sym.getName();
407 CurrentObjectAddresses[*Name] = Addr;
411 /// Lookup a symbol address in the main binary symbol table. The
412 /// parser only needs to query common symbols, thus not every symbol's
413 /// address is available through this function.
414 uint64_t MachODebugMapParser::getMainBinarySymbolAddress(StringRef Name) {
415 auto Sym = MainBinarySymbolAddresses.find(Name);
416 if (Sym == MainBinarySymbolAddresses.end())
421 /// Load the interesting main binary symbols' addresses into
422 /// MainBinarySymbolAddresses.
423 void MachODebugMapParser::loadMainBinarySymbols(
424 const MachOObjectFile &MainBinary) {
425 section_iterator Section = MainBinary.section_end();
426 MainBinarySymbolAddresses.clear();
427 for (const auto &Sym : MainBinary.symbols()) {
428 SymbolRef::Type Type = Sym.getType();
429 // Skip undefined and STAB entries.
430 if ((Type & SymbolRef::ST_Debug) || (Type & SymbolRef::ST_Unknown))
432 // The only symbols of interest are the global variables. These
433 // are the only ones that need to be queried because the address
434 // of common data won't be described in the debug map. All other
435 // addresses should be fetched for the debug map.
436 if (!(Sym.getFlags() & SymbolRef::SF_Global))
438 ErrorOr<section_iterator> SectionOrErr = Sym.getSection();
441 Section = *SectionOrErr;
442 if (Section == MainBinary.section_end() || Section->isText())
444 uint64_t Addr = Sym.getValue();
445 ErrorOr<StringRef> NameOrErr = Sym.getName();
448 StringRef Name = *NameOrErr;
449 if (Name.size() == 0 || Name[0] == '\0')
451 MainBinarySymbolAddresses[Name] = Addr;
457 llvm::ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
458 parseDebugMap(StringRef InputFile, ArrayRef<std::string> Archs,
459 StringRef PrependPath, bool Verbose, bool InputIsYAML) {
461 MachODebugMapParser Parser(InputFile, Archs, PrependPath, Verbose);
462 return Parser.parse();
464 return DebugMap::parseYAMLDebugMap(InputFile, PrependPath, Verbose);
468 bool dumpStab(StringRef InputFile, ArrayRef<std::string> Archs,
469 StringRef PrependPath) {
470 MachODebugMapParser Parser(InputFile, Archs, PrependPath, false);
471 return Parser.dumpStab();
473 } // namespace dsymutil