1//===- tools/dsymutil/MachODebugMapParser.cpp - Parse STABS debug maps ----===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9#include "BinaryHolder.h" 10#include "DebugMap.h" 11#include "MachOUtils.h" 12#include "llvm/ADT/Optional.h" 13#include "llvm/Object/MachO.h" 14#include "llvm/Support/Path.h" 15#include "llvm/Support/WithColor.h" 16#include "llvm/Support/raw_ostream.h" 17#include <vector> 18 19namespace { 20using namespace llvm; 21using namespace llvm::dsymutil; 22using namespace llvm::object; 23 24class MachODebugMapParser { 25public: 26 MachODebugMapParser(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS, 27 StringRef BinaryPath, ArrayRef<std::string> Archs, 28 StringRef PathPrefix = "", 29 bool PaperTrailWarnings = false, bool Verbose = false) 30 : BinaryPath(std::string(BinaryPath)), Archs(Archs.begin(), Archs.end()), 31 PathPrefix(std::string(PathPrefix)), 32 PaperTrailWarnings(PaperTrailWarnings), BinHolder(VFS, Verbose), 33 CurrentDebugMapObject(nullptr) {} 34 35 /// Parses and returns the DebugMaps of the input binary. The binary contains 36 /// multiple maps in case it is a universal binary. 37 /// \returns an error in case the provided BinaryPath doesn't exist 38 /// or isn't of a supported type. 39 ErrorOr<std::vector<std::unique_ptr<DebugMap>>> parse(); 40 41 /// Walk the symbol table and dump it. 42 bool dumpStab(); 43 44private: 45 std::string BinaryPath; 46 SmallVector<StringRef, 1> Archs; 47 std::string PathPrefix; 48 bool PaperTrailWarnings; 49 50 /// Owns the MemoryBuffer for the main binary. 51 BinaryHolder BinHolder; 52 /// Map of the binary symbol addresses. 53 StringMap<uint64_t> MainBinarySymbolAddresses; 54 StringRef MainBinaryStrings; 55 /// The constructed DebugMap. 56 std::unique_ptr<DebugMap> Result; 57 /// List of common symbols that need to be added to the debug map. 58 std::vector<std::string> CommonSymbols; 59 60 /// Map of the currently processed object file symbol addresses. 61 StringMap<Optional<uint64_t>> CurrentObjectAddresses; 62 /// Element of the debug map corresponding to the current object file. 63 DebugMapObject *CurrentDebugMapObject; 64 65 /// Holds function info while function scope processing. 66 const char *CurrentFunctionName; 67 uint64_t CurrentFunctionAddress; 68 69 std::unique_ptr<DebugMap> parseOneBinary(const MachOObjectFile &MainBinary, 70 StringRef BinaryPath); 71 72 void 73 switchToNewDebugMapObject(StringRef Filename, 74 sys::TimePoint<std::chrono::seconds> Timestamp); 75 void resetParserState(); 76 uint64_t getMainBinarySymbolAddress(StringRef Name); 77 std::vector<StringRef> getMainBinarySymbolNames(uint64_t Value); 78 void loadMainBinarySymbols(const MachOObjectFile &MainBinary); 79 void loadCurrentObjectFileSymbols(const object::MachOObjectFile &Obj); 80 void handleStabSymbolTableEntry(uint32_t StringIndex, uint8_t Type, 81 uint8_t SectionIndex, uint16_t Flags, 82 uint64_t Value); 83 84 template <typename STEType> void handleStabDebugMapEntry(const STEType &STE) { 85 handleStabSymbolTableEntry(STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc, 86 STE.n_value); 87 } 88 89 void addCommonSymbols(); 90 91 /// Dump the symbol table output header. 92 void dumpSymTabHeader(raw_ostream &OS, StringRef Arch); 93 94 /// Dump the contents of nlist entries. 95 void dumpSymTabEntry(raw_ostream &OS, uint64_t Index, uint32_t StringIndex, 96 uint8_t Type, uint8_t SectionIndex, uint16_t Flags, 97 uint64_t Value); 98 99 template <typename STEType> 100 void dumpSymTabEntry(raw_ostream &OS, uint64_t Index, const STEType &STE) { 101 dumpSymTabEntry(OS, Index, STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc, 102 STE.n_value); 103 } 104 void dumpOneBinaryStab(const MachOObjectFile &MainBinary, 105 StringRef BinaryPath); 106 107 void Warning(const Twine &Msg, StringRef File = StringRef()) { 108 WithColor::warning() << "(" 109 << MachOUtils::getArchName( 110 Result->getTriple().getArchName()) 111 << ") " << File << " " << Msg << "\n"; 112 113 if (PaperTrailWarnings) { 114 if (!File.empty()) 115 Result->addDebugMapObject(File, sys::TimePoint<std::chrono::seconds>()); 116 if (Result->end() != Result->begin()) 117 (*--Result->end())->addWarning(Msg.str()); 118 } 119 } 120}; 121 122} // anonymous namespace 123 124/// Reset the parser state corresponding to the current object 125/// file. This is to be called after an object file is finished 126/// processing. 127void MachODebugMapParser::resetParserState() { 128 CommonSymbols.clear(); 129 CurrentObjectAddresses.clear(); 130 CurrentDebugMapObject = nullptr; 131} 132 133/// Commons symbols won't show up in the symbol map but might need to be 134/// relocated. We can add them to the symbol table ourselves by combining the 135/// information in the object file (the symbol name) and the main binary (the 136/// address). 137void MachODebugMapParser::addCommonSymbols() { 138 for (auto &CommonSymbol : CommonSymbols) { 139 uint64_t CommonAddr = getMainBinarySymbolAddress(CommonSymbol); 140 if (CommonAddr == 0) { 141 // The main binary doesn't have an address for the given symbol. 142 continue; 143 } 144 if (!CurrentDebugMapObject->addSymbol(CommonSymbol, None /*ObjectAddress*/, 145 CommonAddr, 0 /*size*/)) { 146 // The symbol is already present. 147 continue; 148 } 149 } 150} 151 152/// Create a new DebugMapObject. This function resets the state of the 153/// parser that was referring to the last object file and sets 154/// everything up to add symbols to the new one. 155void MachODebugMapParser::switchToNewDebugMapObject( 156 StringRef Filename, sys::TimePoint<std::chrono::seconds> Timestamp) { 157 addCommonSymbols(); 158 resetParserState(); 159 160 SmallString<80> Path(PathPrefix); 161 sys::path::append(Path, Filename); 162 163 auto ObjectEntry = BinHolder.getObjectEntry(Path, Timestamp); 164 if (!ObjectEntry) { 165 auto Err = ObjectEntry.takeError(); 166 Warning("unable to open object file: " + toString(std::move(Err)), 167 Path.str()); 168 return; 169 } 170 171 auto Object = ObjectEntry->getObjectAs<MachOObjectFile>(Result->getTriple()); 172 if (!Object) { 173 auto Err = Object.takeError(); 174 Warning("unable to open object file: " + toString(std::move(Err)), 175 Path.str()); 176 return; 177 } 178 179 CurrentDebugMapObject = 180 &Result->addDebugMapObject(Path, Timestamp, MachO::N_OSO); 181 loadCurrentObjectFileSymbols(*Object); 182} 183 184static std::string getArchName(const object::MachOObjectFile &Obj) { 185 Triple T = Obj.getArchTriple(); 186 return std::string(T.getArchName()); 187} 188 189std::unique_ptr<DebugMap> 190MachODebugMapParser::parseOneBinary(const MachOObjectFile &MainBinary, 191 StringRef BinaryPath) { 192 loadMainBinarySymbols(MainBinary); 193 ArrayRef<uint8_t> UUID = MainBinary.getUuid(); 194 Result = 195 std::make_unique<DebugMap>(MainBinary.getArchTriple(), BinaryPath, UUID); 196 MainBinaryStrings = MainBinary.getStringTableData(); 197 for (const SymbolRef &Symbol : MainBinary.symbols()) { 198 const DataRefImpl &DRI = Symbol.getRawDataRefImpl(); 199 if (MainBinary.is64Bit()) 200 handleStabDebugMapEntry(MainBinary.getSymbol64TableEntry(DRI)); 201 else 202 handleStabDebugMapEntry(MainBinary.getSymbolTableEntry(DRI)); 203 } 204 205 resetParserState(); 206 return std::move(Result); 207} 208 209// Table that maps Darwin's Mach-O stab constants to strings to allow printing. 210// llvm-nm has very similar code, the strings used here are however slightly 211// different and part of the interface of dsymutil (some project's build-systems 212// parse the ouptut of dsymutil -s), thus they shouldn't be changed. 213struct DarwinStabName { 214 uint8_t NType; 215 const char *Name; 216}; 217 218static const struct DarwinStabName DarwinStabNames[] = { 219 {MachO::N_GSYM, "N_GSYM"}, {MachO::N_FNAME, "N_FNAME"}, 220 {MachO::N_FUN, "N_FUN"}, {MachO::N_STSYM, "N_STSYM"}, 221 {MachO::N_LCSYM, "N_LCSYM"}, {MachO::N_BNSYM, "N_BNSYM"}, 222 {MachO::N_PC, "N_PC"}, {MachO::N_AST, "N_AST"}, 223 {MachO::N_OPT, "N_OPT"}, {MachO::N_RSYM, "N_RSYM"}, 224 {MachO::N_SLINE, "N_SLINE"}, {MachO::N_ENSYM, "N_ENSYM"}, 225 {MachO::N_SSYM, "N_SSYM"}, {MachO::N_SO, "N_SO"}, 226 {MachO::N_OSO, "N_OSO"}, {MachO::N_LSYM, "N_LSYM"}, 227 {MachO::N_BINCL, "N_BINCL"}, {MachO::N_SOL, "N_SOL"}, 228 {MachO::N_PARAMS, "N_PARAM"}, {MachO::N_VERSION, "N_VERS"}, 229 {MachO::N_OLEVEL, "N_OLEV"}, {MachO::N_PSYM, "N_PSYM"}, 230 {MachO::N_EINCL, "N_EINCL"}, {MachO::N_ENTRY, "N_ENTRY"}, 231 {MachO::N_LBRAC, "N_LBRAC"}, {MachO::N_EXCL, "N_EXCL"}, 232 {MachO::N_RBRAC, "N_RBRAC"}, {MachO::N_BCOMM, "N_BCOMM"}, 233 {MachO::N_ECOMM, "N_ECOMM"}, {MachO::N_ECOML, "N_ECOML"}, 234 {MachO::N_LENG, "N_LENG"}, {0, nullptr}}; 235 236static const char *getDarwinStabString(uint8_t NType) { 237 for (unsigned i = 0; DarwinStabNames[i].Name; i++) { 238 if (DarwinStabNames[i].NType == NType) 239 return DarwinStabNames[i].Name; 240 } 241 return nullptr; 242} 243 244void MachODebugMapParser::dumpSymTabHeader(raw_ostream &OS, StringRef Arch) { 245 OS << "-----------------------------------" 246 "-----------------------------------\n"; 247 OS << "Symbol table for: '" << BinaryPath << "' (" << Arch.data() << ")\n"; 248 OS << "-----------------------------------" 249 "-----------------------------------\n"; 250 OS << "Index n_strx n_type n_sect n_desc n_value\n"; 251 OS << "======== -------- ------------------ ------ ------ ----------------\n"; 252} 253 254void MachODebugMapParser::dumpSymTabEntry(raw_ostream &OS, uint64_t Index, 255 uint32_t StringIndex, uint8_t Type, 256 uint8_t SectionIndex, uint16_t Flags, 257 uint64_t Value) { 258 // Index 259 OS << '[' << format_decimal(Index, 6) 260 << "] " 261 // n_strx 262 << format_hex_no_prefix(StringIndex, 8) 263 << ' ' 264 // n_type... 265 << format_hex_no_prefix(Type, 2) << " ("; 266 267 if (Type & MachO::N_STAB) 268 OS << left_justify(getDarwinStabString(Type), 13); 269 else { 270 if (Type & MachO::N_PEXT) 271 OS << "PEXT "; 272 else 273 OS << " "; 274 switch (Type & MachO::N_TYPE) { 275 case MachO::N_UNDF: // 0x0 undefined, n_sect == NO_SECT 276 OS << "UNDF"; 277 break; 278 case MachO::N_ABS: // 0x2 absolute, n_sect == NO_SECT 279 OS << "ABS "; 280 break; 281 case MachO::N_SECT: // 0xe defined in section number n_sect 282 OS << "SECT"; 283 break; 284 case MachO::N_PBUD: // 0xc prebound undefined (defined in a dylib) 285 OS << "PBUD"; 286 break; 287 case MachO::N_INDR: // 0xa indirect 288 OS << "INDR"; 289 break; 290 default: 291 OS << format_hex_no_prefix(Type, 2) << " "; 292 break; 293 } 294 if (Type & MachO::N_EXT) 295 OS << " EXT"; 296 else 297 OS << " "; 298 } 299 300 OS << ") " 301 // n_sect 302 << format_hex_no_prefix(SectionIndex, 2) 303 << " " 304 // n_desc 305 << format_hex_no_prefix(Flags, 4) 306 << " " 307 // n_value 308 << format_hex_no_prefix(Value, 16); 309 310 const char *Name = &MainBinaryStrings.data()[StringIndex]; 311 if (Name && Name[0]) 312 OS << " '" << Name << "'"; 313 314 OS << "\n"; 315} 316 317void MachODebugMapParser::dumpOneBinaryStab(const MachOObjectFile &MainBinary, 318 StringRef BinaryPath) { 319 loadMainBinarySymbols(MainBinary); 320 MainBinaryStrings = MainBinary.getStringTableData(); 321 raw_ostream &OS(llvm::outs()); 322 323 dumpSymTabHeader(OS, getArchName(MainBinary)); 324 uint64_t Idx = 0; 325 for (const SymbolRef &Symbol : MainBinary.symbols()) { 326 const DataRefImpl &DRI = Symbol.getRawDataRefImpl(); 327 if (MainBinary.is64Bit()) 328 dumpSymTabEntry(OS, Idx, MainBinary.getSymbol64TableEntry(DRI)); 329 else 330 dumpSymTabEntry(OS, Idx, MainBinary.getSymbolTableEntry(DRI)); 331 Idx++; 332 } 333 334 OS << "\n\n"; 335 resetParserState(); 336} 337 338static bool shouldLinkArch(SmallVectorImpl<StringRef> &Archs, StringRef Arch) { 339 if (Archs.empty() || is_contained(Archs, "all") || is_contained(Archs, "*")) 340 return true; 341 342 if (Arch.startswith("arm") && Arch != "arm64" && is_contained(Archs, "arm")) 343 return true; 344 345 SmallString<16> ArchName = Arch; 346 if (Arch.startswith("thumb")) 347 ArchName = ("arm" + Arch.substr(5)).str(); 348 349 return is_contained(Archs, ArchName); 350} 351 352bool MachODebugMapParser::dumpStab() { 353 auto ObjectEntry = BinHolder.getObjectEntry(BinaryPath); 354 if (!ObjectEntry) { 355 auto Err = ObjectEntry.takeError(); 356 WithColor::error() << "cannot load '" << BinaryPath 357 << "': " << toString(std::move(Err)) << '\n'; 358 return false; 359 } 360 361 auto Objects = ObjectEntry->getObjectsAs<MachOObjectFile>(); 362 if (!Objects) { 363 auto Err = Objects.takeError(); 364 WithColor::error() << "cannot get '" << BinaryPath 365 << "' as MachO file: " << toString(std::move(Err)) 366 << "\n"; 367 return false; 368 } 369 370 for (const auto *Object : *Objects) 371 if (shouldLinkArch(Archs, Object->getArchTriple().getArchName())) 372 dumpOneBinaryStab(*Object, BinaryPath); 373 374 return true; 375} 376 377/// This main parsing routine tries to open the main binary and if 378/// successful iterates over the STAB entries. The real parsing is 379/// done in handleStabSymbolTableEntry. 380ErrorOr<std::vector<std::unique_ptr<DebugMap>>> MachODebugMapParser::parse() { 381 auto ObjectEntry = BinHolder.getObjectEntry(BinaryPath); 382 if (!ObjectEntry) { 383 return errorToErrorCode(ObjectEntry.takeError()); 384 } 385 386 auto Objects = ObjectEntry->getObjectsAs<MachOObjectFile>(); 387 if (!Objects) { 388 return errorToErrorCode(Objects.takeError()); 389 } 390 391 std::vector<std::unique_ptr<DebugMap>> Results; 392 for (const auto *Object : *Objects) 393 if (shouldLinkArch(Archs, Object->getArchTriple().getArchName())) 394 Results.push_back(parseOneBinary(*Object, BinaryPath)); 395 396 return std::move(Results); 397} 398 399/// Interpret the STAB entries to fill the DebugMap. 400void MachODebugMapParser::handleStabSymbolTableEntry(uint32_t StringIndex, 401 uint8_t Type, 402 uint8_t SectionIndex, 403 uint16_t Flags, 404 uint64_t Value) { 405 if (!(Type & MachO::N_STAB)) 406 return; 407 408 const char *Name = &MainBinaryStrings.data()[StringIndex]; 409 410 // An N_OSO entry represents the start of a new object file description. 411 if (Type == MachO::N_OSO) 412 return switchToNewDebugMapObject(Name, sys::toTimePoint(Value)); 413 414 if (Type == MachO::N_AST) { 415 SmallString<80> Path(PathPrefix); 416 sys::path::append(Path, Name); 417 Result->addDebugMapObject(Path, sys::toTimePoint(Value), Type); 418 return; 419 } 420 421 // If the last N_OSO object file wasn't found, CurrentDebugMapObject will be 422 // null. Do not update anything until we find the next valid N_OSO entry. 423 if (!CurrentDebugMapObject) 424 return; 425 426 uint32_t Size = 0; 427 switch (Type) { 428 case MachO::N_GSYM: 429 // This is a global variable. We need to query the main binary 430 // symbol table to find its address as it might not be in the 431 // debug map (for common symbols). 432 Value = getMainBinarySymbolAddress(Name); 433 break; 434 case MachO::N_FUN: 435 // Functions are scopes in STABS. They have an end marker that 436 // contains the function size. 437 if (Name[0] == '\0') { 438 Size = Value; 439 Value = CurrentFunctionAddress; 440 Name = CurrentFunctionName; 441 break; 442 } else { 443 CurrentFunctionName = Name; 444 CurrentFunctionAddress = Value; 445 return; 446 } 447 case MachO::N_STSYM: 448 break; 449 default: 450 return; 451 } 452 453 auto ObjectSymIt = CurrentObjectAddresses.find(Name); 454 455 // If the name of a (non-static) symbol is not in the current object, we 456 // check all its aliases from the main binary. 457 if (ObjectSymIt == CurrentObjectAddresses.end() && Type != MachO::N_STSYM) { 458 for (const auto &Alias : getMainBinarySymbolNames(Value)) { 459 ObjectSymIt = CurrentObjectAddresses.find(Alias); 460 if (ObjectSymIt != CurrentObjectAddresses.end()) 461 break; 462 } 463 } 464 465 // ThinLTO adds a unique suffix to exported private symbols. 466 if (ObjectSymIt == CurrentObjectAddresses.end()) { 467 for (auto Iter = CurrentObjectAddresses.begin(); 468 Iter != CurrentObjectAddresses.end(); ++Iter) { 469 llvm::StringRef SymbolName = Iter->getKey(); 470 auto Pos = SymbolName.rfind(".llvm."); 471 if (Pos != llvm::StringRef::npos && SymbolName.substr(0, Pos) == Name) { 472 ObjectSymIt = Iter; 473 break; 474 } 475 } 476 } 477 478 if (ObjectSymIt == CurrentObjectAddresses.end()) { 479 Warning("could not find object file symbol for symbol " + Twine(Name)); 480 return; 481 } 482 483 if (!CurrentDebugMapObject->addSymbol(Name, ObjectSymIt->getValue(), Value, 484 Size)) { 485 Warning(Twine("failed to insert symbol '") + Name + "' in the debug map."); 486 return; 487 } 488} 489 490/// Load the current object file symbols into CurrentObjectAddresses. 491void MachODebugMapParser::loadCurrentObjectFileSymbols( 492 const object::MachOObjectFile &Obj) { 493 CurrentObjectAddresses.clear(); 494 495 for (auto Sym : Obj.symbols()) { 496 uint64_t Addr = cantFail(Sym.getValue()); 497 Expected<StringRef> Name = Sym.getName(); 498 if (!Name) { 499 // TODO: Actually report errors helpfully. 500 consumeError(Name.takeError()); 501 continue; 502 } 503 // The value of some categories of symbols isn't meaningful. For 504 // example common symbols store their size in the value field, not 505 // their address. Absolute symbols have a fixed address that can 506 // conflict with standard symbols. These symbols (especially the 507 // common ones), might still be referenced by relocations. These 508 // relocations will use the symbol itself, and won't need an 509 // object file address. The object file address field is optional 510 // in the DebugMap, leave it unassigned for these symbols. 511 uint32_t Flags = cantFail(Sym.getFlags()); 512 if (Flags & SymbolRef::SF_Absolute) { 513 CurrentObjectAddresses[*Name] = None; 514 } else if (Flags & SymbolRef::SF_Common) { 515 CurrentObjectAddresses[*Name] = None; 516 CommonSymbols.push_back(std::string(*Name)); 517 } else { 518 CurrentObjectAddresses[*Name] = Addr; 519 } 520 } 521} 522 523/// Lookup a symbol address in the main binary symbol table. The 524/// parser only needs to query common symbols, thus not every symbol's 525/// address is available through this function. 526uint64_t MachODebugMapParser::getMainBinarySymbolAddress(StringRef Name) { 527 auto Sym = MainBinarySymbolAddresses.find(Name); 528 if (Sym == MainBinarySymbolAddresses.end()) 529 return 0; 530 return Sym->second; 531} 532 533/// Get all symbol names in the main binary for the given value. 534std::vector<StringRef> 535MachODebugMapParser::getMainBinarySymbolNames(uint64_t Value) { 536 std::vector<StringRef> Names; 537 for (const auto &Entry : MainBinarySymbolAddresses) { 538 if (Entry.second == Value) 539 Names.push_back(Entry.first()); 540 } 541 return Names; 542} 543 544/// Load the interesting main binary symbols' addresses into 545/// MainBinarySymbolAddresses. 546void MachODebugMapParser::loadMainBinarySymbols( 547 const MachOObjectFile &MainBinary) { 548 section_iterator Section = MainBinary.section_end(); 549 MainBinarySymbolAddresses.clear(); 550 for (const auto &Sym : MainBinary.symbols()) { 551 Expected<SymbolRef::Type> TypeOrErr = Sym.getType(); 552 if (!TypeOrErr) { 553 // TODO: Actually report errors helpfully. 554 consumeError(TypeOrErr.takeError()); 555 continue; 556 } 557 SymbolRef::Type Type = *TypeOrErr; 558 // Skip undefined and STAB entries. 559 if ((Type == SymbolRef::ST_Debug) || (Type == SymbolRef::ST_Unknown)) 560 continue; 561 // In theory, the only symbols of interest are the global variables. These 562 // are the only ones that need to be queried because the address of common 563 // data won't be described in the debug map. All other addresses should be 564 // fetched for the debug map. In reality, by playing with 'ld -r' and 565 // export lists, you can get symbols described as N_GSYM in the debug map, 566 // but associated with a local symbol. Gather all the symbols, but prefer 567 // the global ones. 568 uint8_t SymType = 569 MainBinary.getSymbolTableEntry(Sym.getRawDataRefImpl()).n_type; 570 bool Extern = SymType & (MachO::N_EXT | MachO::N_PEXT); 571 Expected<section_iterator> SectionOrErr = Sym.getSection(); 572 if (!SectionOrErr) { 573 // TODO: Actually report errors helpfully. 574 consumeError(SectionOrErr.takeError()); 575 continue; 576 } 577 Section = *SectionOrErr; 578 if ((Section == MainBinary.section_end() || Section->isText()) && !Extern) 579 continue; 580 uint64_t Addr = cantFail(Sym.getValue()); 581 Expected<StringRef> NameOrErr = Sym.getName(); 582 if (!NameOrErr) { 583 // TODO: Actually report errors helpfully. 584 consumeError(NameOrErr.takeError()); 585 continue; 586 } 587 StringRef Name = *NameOrErr; 588 if (Name.size() == 0 || Name[0] == '\0') 589 continue; 590 // Override only if the new key is global. 591 if (Extern) 592 MainBinarySymbolAddresses[Name] = Addr; 593 else 594 MainBinarySymbolAddresses.try_emplace(Name, Addr); 595 } 596} 597 598namespace llvm { 599namespace dsymutil { 600llvm::ErrorOr<std::vector<std::unique_ptr<DebugMap>>> 601parseDebugMap(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS, 602 StringRef InputFile, ArrayRef<std::string> Archs, 603 StringRef PrependPath, bool PaperTrailWarnings, bool Verbose, 604 bool InputIsYAML) { 605 if (InputIsYAML) 606 return DebugMap::parseYAMLDebugMap(InputFile, PrependPath, Verbose); 607 608 MachODebugMapParser Parser(VFS, InputFile, Archs, PrependPath, 609 PaperTrailWarnings, Verbose); 610 return Parser.parse(); 611} 612 613bool dumpStab(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS, 614 StringRef InputFile, ArrayRef<std::string> Archs, 615 StringRef PrependPath) { 616 MachODebugMapParser Parser(VFS, InputFile, Archs, PrependPath, false); 617 return Parser.dumpStab(); 618} 619} // namespace dsymutil 620} // namespace llvm 621