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:
MachODebugMapParser(StringRef BinaryPath,ArrayRef<std::string> Archs,StringRef PathPrefix="",bool Verbose=false)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
handleStabDebugMapEntry(const STEType & STE)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>
dumpSymTabEntry(raw_ostream & OS,uint64_t Index,const STEType & STE)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
Warning(const Twine & Msg)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.
resetParserState()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.
switchToNewDebugMapObject(StringRef Filename,sys::TimeValue Timestamp)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
getArchName(const object::MachOObjectFile & Obj)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>
parseOneBinary(const MachOObjectFile & MainBinary,StringRef BinaryPath)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
getDarwinStabString(uint8_t NType)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
dumpSymTabHeader(raw_ostream & OS,StringRef Arch)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
dumpSymTabEntry(raw_ostream & OS,uint64_t Index,uint32_t StringIndex,uint8_t Type,uint8_t SectionIndex,uint16_t Flags,uint64_t Value)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
dumpOneBinaryStab(const MachOObjectFile & MainBinary,StringRef BinaryPath)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
shouldLinkArch(SmallVectorImpl<StringRef> & Archs,StringRef Arch)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
dumpStab()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.
parse()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.
handleStabSymbolTableEntry(uint32_t StringIndex,uint8_t Type,uint8_t SectionIndex,uint16_t Flags,uint64_t Value)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.
loadCurrentObjectFileSymbols(const object::MachOObjectFile & Obj)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.
getMainBinarySymbolAddress(StringRef Name)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.
loadMainBinarySymbols(const MachOObjectFile & MainBinary)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>>>
parseDebugMap(StringRef InputFile,ArrayRef<std::string> Archs,StringRef PrependPath,bool Verbose,bool InputIsYAML)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
dumpStab(StringRef InputFile,ArrayRef<std::string> Archs,StringRef PrependPath)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
486