Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 2 of 2.

1 files changed, 608 insertions, 608 deletions

diff --git a/contrib/libs/llvm12/tools/dsymutil/MachODebugMapParser.cpp b/contrib/libs/llvm12/tools/dsymutil/MachODebugMapParser.cpp
index 4c05326dc2..37848c561a 100644
--- a/contrib/libs/llvm12/tools/dsymutil/MachODebugMapParser.cpp
+++ b/contrib/libs/llvm12/tools/dsymutil/MachODebugMapParser.cpp
@@ -1,609 +1,609 @@
-//===- tools/dsymutil/MachODebugMapParser.cpp - Parse STABS debug maps ----===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#include "BinaryHolder.h" 
-#include "DebugMap.h" 
-#include "MachOUtils.h" 
-#include "llvm/ADT/Optional.h" 
-#include "llvm/Object/MachO.h" 
-#include "llvm/Support/Path.h" 
-#include "llvm/Support/WithColor.h" 
-#include "llvm/Support/raw_ostream.h" 
-#include <vector> 
- 
-namespace { 
-using namespace llvm; 
-using namespace llvm::dsymutil; 
-using namespace llvm::object; 
- 
-class MachODebugMapParser { 
-public: 
-  MachODebugMapParser(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS, 
-                      StringRef BinaryPath, ArrayRef<std::string> Archs, 
-                      StringRef PathPrefix = "", 
-                      bool PaperTrailWarnings = false, bool Verbose = false) 
-      : BinaryPath(std::string(BinaryPath)), Archs(Archs.begin(), Archs.end()), 
-        PathPrefix(std::string(PathPrefix)), 
-        PaperTrailWarnings(PaperTrailWarnings), BinHolder(VFS, Verbose), 
-        CurrentDebugMapObject(nullptr) {} 
- 
-  /// Parses and returns the DebugMaps of the input binary. The binary contains 
-  /// multiple maps in case it is a universal binary. 
-  /// \returns an error in case the provided BinaryPath doesn't exist 
-  /// or isn't of a supported type. 
-  ErrorOr<std::vector<std::unique_ptr<DebugMap>>> parse(); 
- 
-  /// Walk the symbol table and dump it. 
-  bool dumpStab(); 
- 
-private: 
-  std::string BinaryPath; 
-  SmallVector<StringRef, 1> Archs; 
-  std::string PathPrefix; 
-  bool PaperTrailWarnings; 
- 
-  /// Owns the MemoryBuffer for the main binary. 
-  BinaryHolder BinHolder; 
-  /// Map of the binary symbol addresses. 
-  StringMap<uint64_t> MainBinarySymbolAddresses; 
-  StringRef MainBinaryStrings; 
-  /// The constructed DebugMap. 
-  std::unique_ptr<DebugMap> Result; 
-  /// List of common symbols that need to be added to the debug map. 
-  std::vector<std::string> CommonSymbols; 
- 
-  /// Map of the currently processed object file symbol addresses. 
-  StringMap<Optional<uint64_t>> CurrentObjectAddresses; 
-  /// Element of the debug map corresponding to the current object file. 
-  DebugMapObject *CurrentDebugMapObject; 
- 
-  /// Holds function info while function scope processing. 
-  const char *CurrentFunctionName; 
-  uint64_t CurrentFunctionAddress; 
- 
-  std::unique_ptr<DebugMap> parseOneBinary(const MachOObjectFile &MainBinary, 
-                                           StringRef BinaryPath); 
- 
-  void 
-  switchToNewDebugMapObject(StringRef Filename, 
-                            sys::TimePoint<std::chrono::seconds> Timestamp); 
-  void resetParserState(); 
-  uint64_t getMainBinarySymbolAddress(StringRef Name); 
-  std::vector<StringRef> getMainBinarySymbolNames(uint64_t Value); 
-  void loadMainBinarySymbols(const MachOObjectFile &MainBinary); 
-  void loadCurrentObjectFileSymbols(const object::MachOObjectFile &Obj); 
-  void handleStabSymbolTableEntry(uint32_t StringIndex, uint8_t Type, 
-                                  uint8_t SectionIndex, uint16_t Flags, 
-                                  uint64_t Value); 
- 
-  template <typename STEType> void handleStabDebugMapEntry(const STEType &STE) { 
-    handleStabSymbolTableEntry(STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc, 
-                               STE.n_value); 
-  } 
- 
-  void addCommonSymbols(); 
- 
-  /// Dump the symbol table output header. 
-  void dumpSymTabHeader(raw_ostream &OS, StringRef Arch); 
- 
-  /// Dump the contents of nlist entries. 
-  void dumpSymTabEntry(raw_ostream &OS, uint64_t Index, uint32_t StringIndex, 
-                       uint8_t Type, uint8_t SectionIndex, uint16_t Flags, 
-                       uint64_t Value); 
- 
-  template <typename STEType> 
-  void dumpSymTabEntry(raw_ostream &OS, uint64_t Index, const STEType &STE) { 
-    dumpSymTabEntry(OS, Index, STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc, 
-                    STE.n_value); 
-  } 
-  void dumpOneBinaryStab(const MachOObjectFile &MainBinary, 
-                         StringRef BinaryPath); 
- 
-  void Warning(const Twine &Msg, StringRef File = StringRef()) { 
-    WithColor::warning() << "(" 
-                         << MachOUtils::getArchName( 
-                                Result->getTriple().getArchName()) 
-                         << ") " << File << " " << Msg << "\n"; 
- 
-    if (PaperTrailWarnings) { 
-      if (!File.empty()) 
-        Result->addDebugMapObject(File, sys::TimePoint<std::chrono::seconds>()); 
-      if (Result->end() != Result->begin()) { 
-        auto it = Result->end(); 
-        (*--it)->addWarning(Msg.str()); 
-      } 
-    } 
-  } 
-}; 
- 
-} // anonymous namespace 
- 
-/// Reset the parser state corresponding to the current object 
-/// file. This is to be called after an object file is finished 
-/// processing. 
-void MachODebugMapParser::resetParserState() { 
-  CommonSymbols.clear(); 
-  CurrentObjectAddresses.clear(); 
-  CurrentDebugMapObject = nullptr; 
-} 
- 
-/// Commons symbols won't show up in the symbol map but might need to be 
-/// relocated. We can add them to the symbol table ourselves by combining the 
-/// information in the object file (the symbol name) and the main binary (the 
-/// address). 
-void MachODebugMapParser::addCommonSymbols() { 
-  for (auto &CommonSymbol : CommonSymbols) { 
-    uint64_t CommonAddr = getMainBinarySymbolAddress(CommonSymbol); 
-    if (CommonAddr == 0) { 
-      // The main binary doesn't have an address for the given symbol. 
-      continue; 
-    } 
-    if (!CurrentDebugMapObject->addSymbol(CommonSymbol, None /*ObjectAddress*/, 
-                                          CommonAddr, 0 /*size*/)) { 
-      // The symbol is already present. 
-      continue; 
-    } 
-  } 
-} 
- 
-/// Create a new DebugMapObject. This function resets the state of the 
-/// parser that was referring to the last object file and sets 
-/// everything up to add symbols to the new one. 
-void MachODebugMapParser::switchToNewDebugMapObject( 
-    StringRef Filename, sys::TimePoint<std::chrono::seconds> Timestamp) { 
-  addCommonSymbols(); 
-  resetParserState(); 
- 
-  SmallString<80> Path(PathPrefix); 
-  sys::path::append(Path, Filename); 
- 
-  auto ObjectEntry = BinHolder.getObjectEntry(Path, Timestamp); 
-  if (!ObjectEntry) { 
-    auto Err = ObjectEntry.takeError(); 
-    Warning("unable to open object file: " + toString(std::move(Err)), 
-            Path.str()); 
-    return; 
-  } 
- 
-  auto Object = ObjectEntry->getObjectAs<MachOObjectFile>(Result->getTriple()); 
-  if (!Object) { 
-    auto Err = Object.takeError(); 
-    Warning("unable to open object file: " + toString(std::move(Err)), 
-            Path.str()); 
-    return; 
-  } 
- 
-  CurrentDebugMapObject = 
-      &Result->addDebugMapObject(Path, Timestamp, MachO::N_OSO); 
-  loadCurrentObjectFileSymbols(*Object); 
-} 
- 
-static std::string getArchName(const object::MachOObjectFile &Obj) { 
-  Triple T = Obj.getArchTriple(); 
-  return std::string(T.getArchName()); 
-} 
- 
-std::unique_ptr<DebugMap> 
-MachODebugMapParser::parseOneBinary(const MachOObjectFile &MainBinary, 
-                                    StringRef BinaryPath) { 
-  loadMainBinarySymbols(MainBinary); 
-  ArrayRef<uint8_t> UUID = MainBinary.getUuid(); 
-  Result = 
-      std::make_unique<DebugMap>(MainBinary.getArchTriple(), BinaryPath, UUID); 
-  MainBinaryStrings = MainBinary.getStringTableData(); 
-  for (const SymbolRef &Symbol : MainBinary.symbols()) { 
-    const DataRefImpl &DRI = Symbol.getRawDataRefImpl(); 
-    if (MainBinary.is64Bit()) 
-      handleStabDebugMapEntry(MainBinary.getSymbol64TableEntry(DRI)); 
-    else 
-      handleStabDebugMapEntry(MainBinary.getSymbolTableEntry(DRI)); 
-  } 
- 
-  resetParserState(); 
-  return std::move(Result); 
-} 
- 
-// Table that maps Darwin's Mach-O stab constants to strings to allow printing. 
-// llvm-nm has very similar code, the strings used here are however slightly 
-// different and part of the interface of dsymutil (some project's build-systems 
-// parse the ouptut of dsymutil -s), thus they shouldn't be changed. 
-struct DarwinStabName { 
-  uint8_t NType; 
-  const char *Name; 
-}; 
- 
-static const struct DarwinStabName DarwinStabNames[] = { 
-    {MachO::N_GSYM, "N_GSYM"},    {MachO::N_FNAME, "N_FNAME"}, 
-    {MachO::N_FUN, "N_FUN"},      {MachO::N_STSYM, "N_STSYM"}, 
-    {MachO::N_LCSYM, "N_LCSYM"},  {MachO::N_BNSYM, "N_BNSYM"}, 
-    {MachO::N_PC, "N_PC"},        {MachO::N_AST, "N_AST"}, 
-    {MachO::N_OPT, "N_OPT"},      {MachO::N_RSYM, "N_RSYM"}, 
-    {MachO::N_SLINE, "N_SLINE"},  {MachO::N_ENSYM, "N_ENSYM"}, 
-    {MachO::N_SSYM, "N_SSYM"},    {MachO::N_SO, "N_SO"}, 
-    {MachO::N_OSO, "N_OSO"},      {MachO::N_LSYM, "N_LSYM"}, 
-    {MachO::N_BINCL, "N_BINCL"},  {MachO::N_SOL, "N_SOL"}, 
-    {MachO::N_PARAMS, "N_PARAM"}, {MachO::N_VERSION, "N_VERS"}, 
-    {MachO::N_OLEVEL, "N_OLEV"},  {MachO::N_PSYM, "N_PSYM"}, 
-    {MachO::N_EINCL, "N_EINCL"},  {MachO::N_ENTRY, "N_ENTRY"}, 
-    {MachO::N_LBRAC, "N_LBRAC"},  {MachO::N_EXCL, "N_EXCL"}, 
-    {MachO::N_RBRAC, "N_RBRAC"},  {MachO::N_BCOMM, "N_BCOMM"}, 
-    {MachO::N_ECOMM, "N_ECOMM"},  {MachO::N_ECOML, "N_ECOML"}, 
-    {MachO::N_LENG, "N_LENG"},    {0, nullptr}}; 
- 
-static const char *getDarwinStabString(uint8_t NType) { 
-  for (unsigned i = 0; DarwinStabNames[i].Name; i++) { 
-    if (DarwinStabNames[i].NType == NType) 
-      return DarwinStabNames[i].Name; 
-  } 
-  return nullptr; 
-} 
- 
-void MachODebugMapParser::dumpSymTabHeader(raw_ostream &OS, StringRef Arch) { 
-  OS << "-----------------------------------" 
-        "-----------------------------------\n"; 
-  OS << "Symbol table for: '" << BinaryPath << "' (" << Arch.data() << ")\n"; 
-  OS << "-----------------------------------" 
-        "-----------------------------------\n"; 
-  OS << "Index    n_strx   n_type             n_sect n_desc n_value\n"; 
-  OS << "======== -------- ------------------ ------ ------ ----------------\n"; 
-} 
- 
-void MachODebugMapParser::dumpSymTabEntry(raw_ostream &OS, uint64_t Index, 
-                                          uint32_t StringIndex, uint8_t Type, 
-                                          uint8_t SectionIndex, uint16_t Flags, 
-                                          uint64_t Value) { 
-  // Index 
-  OS << '[' << format_decimal(Index, 6) 
-     << "] " 
-     // n_strx 
-     << format_hex_no_prefix(StringIndex, 8) 
-     << ' ' 
-     // n_type... 
-     << format_hex_no_prefix(Type, 2) << " ("; 
- 
-  if (Type & MachO::N_STAB) 
-    OS << left_justify(getDarwinStabString(Type), 13); 
-  else { 
-    if (Type & MachO::N_PEXT) 
-      OS << "PEXT "; 
-    else 
-      OS << "     "; 
-    switch (Type & MachO::N_TYPE) { 
-    case MachO::N_UNDF: // 0x0 undefined, n_sect == NO_SECT 
-      OS << "UNDF"; 
-      break; 
-    case MachO::N_ABS: // 0x2 absolute, n_sect == NO_SECT 
-      OS << "ABS "; 
-      break; 
-    case MachO::N_SECT: // 0xe defined in section number n_sect 
-      OS << "SECT"; 
-      break; 
-    case MachO::N_PBUD: // 0xc prebound undefined (defined in a dylib) 
-      OS << "PBUD"; 
-      break; 
-    case MachO::N_INDR: // 0xa indirect 
-      OS << "INDR"; 
-      break; 
-    default: 
-      OS << format_hex_no_prefix(Type, 2) << "    "; 
-      break; 
-    } 
-    if (Type & MachO::N_EXT) 
-      OS << " EXT"; 
-    else 
-      OS << "    "; 
-  } 
- 
-  OS << ") " 
-     // n_sect 
-     << format_hex_no_prefix(SectionIndex, 2) 
-     << "     " 
-     // n_desc 
-     << format_hex_no_prefix(Flags, 4) 
-     << "   " 
-     // n_value 
-     << format_hex_no_prefix(Value, 16); 
- 
-  const char *Name = &MainBinaryStrings.data()[StringIndex]; 
-  if (Name && Name[0]) 
-    OS << " '" << Name << "'"; 
- 
-  OS << "\n"; 
-} 
- 
-void MachODebugMapParser::dumpOneBinaryStab(const MachOObjectFile &MainBinary, 
-                                            StringRef BinaryPath) { 
-  loadMainBinarySymbols(MainBinary); 
-  MainBinaryStrings = MainBinary.getStringTableData(); 
-  raw_ostream &OS(llvm::outs()); 
- 
-  dumpSymTabHeader(OS, getArchName(MainBinary)); 
-  uint64_t Idx = 0; 
-  for (const SymbolRef &Symbol : MainBinary.symbols()) { 
-    const DataRefImpl &DRI = Symbol.getRawDataRefImpl(); 
-    if (MainBinary.is64Bit()) 
-      dumpSymTabEntry(OS, Idx, MainBinary.getSymbol64TableEntry(DRI)); 
-    else 
-      dumpSymTabEntry(OS, Idx, MainBinary.getSymbolTableEntry(DRI)); 
-    Idx++; 
-  } 
- 
-  OS << "\n\n"; 
-  resetParserState(); 
-} 
- 
-static bool shouldLinkArch(SmallVectorImpl<StringRef> &Archs, StringRef Arch) { 
-  if (Archs.empty() || is_contained(Archs, "all") || is_contained(Archs, "*")) 
-    return true; 
- 
-  if (Arch.startswith("arm") && Arch != "arm64" && is_contained(Archs, "arm")) 
-    return true; 
- 
-  SmallString<16> ArchName = Arch; 
-  if (Arch.startswith("thumb")) 
-    ArchName = ("arm" + Arch.substr(5)).str(); 
- 
-  return is_contained(Archs, ArchName); 
-} 
- 
-bool MachODebugMapParser::dumpStab() { 
-  auto ObjectEntry = BinHolder.getObjectEntry(BinaryPath); 
-  if (!ObjectEntry) { 
-    auto Err = ObjectEntry.takeError(); 
-    WithColor::error() << "cannot load '" << BinaryPath 
-                       << "': " << toString(std::move(Err)) << '\n'; 
-    return false; 
-  } 
- 
-  auto Objects = ObjectEntry->getObjectsAs<MachOObjectFile>(); 
-  if (!Objects) { 
-    auto Err = Objects.takeError(); 
-    WithColor::error() << "cannot get '" << BinaryPath 
-                       << "' as MachO file: " << toString(std::move(Err)) 
-                       << "\n"; 
-    return false; 
-  } 
- 
-  for (const auto *Object : *Objects) 
-    if (shouldLinkArch(Archs, Object->getArchTriple().getArchName())) 
-      dumpOneBinaryStab(*Object, BinaryPath); 
- 
-  return true; 
-} 
- 
-/// This main parsing routine tries to open the main binary and if 
-/// successful iterates over the STAB entries. The real parsing is 
-/// done in handleStabSymbolTableEntry. 
-ErrorOr<std::vector<std::unique_ptr<DebugMap>>> MachODebugMapParser::parse() { 
-  auto ObjectEntry = BinHolder.getObjectEntry(BinaryPath); 
-  if (!ObjectEntry) { 
-    return errorToErrorCode(ObjectEntry.takeError()); 
-  } 
- 
-  auto Objects = ObjectEntry->getObjectsAs<MachOObjectFile>(); 
-  if (!Objects) { 
-    return errorToErrorCode(Objects.takeError()); 
-  } 
- 
-  std::vector<std::unique_ptr<DebugMap>> Results; 
-  for (const auto *Object : *Objects) 
-    if (shouldLinkArch(Archs, Object->getArchTriple().getArchName())) 
-      Results.push_back(parseOneBinary(*Object, BinaryPath)); 
- 
-  return std::move(Results); 
-} 
- 
-/// Interpret the STAB entries to fill the DebugMap. 
-void MachODebugMapParser::handleStabSymbolTableEntry(uint32_t StringIndex, 
-                                                     uint8_t Type, 
-                                                     uint8_t SectionIndex, 
-                                                     uint16_t Flags, 
-                                                     uint64_t Value) { 
-  if (!(Type & MachO::N_STAB)) 
-    return; 
- 
-  const char *Name = &MainBinaryStrings.data()[StringIndex]; 
- 
-  // An N_OSO entry represents the start of a new object file description. 
-  if (Type == MachO::N_OSO) 
-    return switchToNewDebugMapObject(Name, sys::toTimePoint(Value)); 
- 
-  if (Type == MachO::N_AST) { 
-    SmallString<80> Path(PathPrefix); 
-    sys::path::append(Path, Name); 
-    Result->addDebugMapObject(Path, sys::toTimePoint(Value), Type); 
-    return; 
-  } 
- 
-  // If the last N_OSO object file wasn't found, CurrentDebugMapObject will be 
-  // null. Do not update anything until we find the next valid N_OSO entry. 
-  if (!CurrentDebugMapObject) 
-    return; 
- 
-  uint32_t Size = 0; 
-  switch (Type) { 
-  case MachO::N_GSYM: 
-    // This is a global variable. We need to query the main binary 
-    // symbol table to find its address as it might not be in the 
-    // debug map (for common symbols). 
-    Value = getMainBinarySymbolAddress(Name); 
-    break; 
-  case MachO::N_FUN: 
-    // Functions are scopes in STABS. They have an end marker that 
-    // contains the function size. 
-    if (Name[0] == '\0') { 
-      Size = Value; 
-      Value = CurrentFunctionAddress; 
-      Name = CurrentFunctionName; 
-      break; 
-    } else { 
-      CurrentFunctionName = Name; 
-      CurrentFunctionAddress = Value; 
-      return; 
-    } 
-  case MachO::N_STSYM: 
-    break; 
-  default: 
-    return; 
-  } 
- 
-  auto ObjectSymIt = CurrentObjectAddresses.find(Name); 
- 
-  // If the name of a (non-static) symbol is not in the current object, we 
-  // check all its aliases from the main binary. 
-  if (ObjectSymIt == CurrentObjectAddresses.end() && Type != MachO::N_STSYM) { 
-    for (const auto &Alias : getMainBinarySymbolNames(Value)) { 
-      ObjectSymIt = CurrentObjectAddresses.find(Alias); 
-      if (ObjectSymIt != CurrentObjectAddresses.end()) 
-        break; 
-    } 
-  } 
- 
-  if (ObjectSymIt == CurrentObjectAddresses.end()) { 
-    Warning("could not find object file symbol for symbol " + Twine(Name)); 
-    return; 
-  } 
- 
-  if (!CurrentDebugMapObject->addSymbol(Name, ObjectSymIt->getValue(), Value, 
-                                        Size)) { 
-    Warning(Twine("failed to insert symbol '") + Name + "' in the debug map."); 
-    return; 
-  } 
-} 
- 
-/// Load the current object file symbols into CurrentObjectAddresses. 
-void MachODebugMapParser::loadCurrentObjectFileSymbols( 
-    const object::MachOObjectFile &Obj) { 
-  CurrentObjectAddresses.clear(); 
- 
-  for (auto Sym : Obj.symbols()) { 
-    uint64_t Addr = cantFail(Sym.getValue()); 
-    Expected<StringRef> Name = Sym.getName(); 
-    if (!Name) { 
-      // TODO: Actually report errors helpfully. 
-      consumeError(Name.takeError()); 
-      continue; 
-    } 
-    // The value of some categories of symbols isn't meaningful. For 
-    // example common symbols store their size in the value field, not 
-    // their address. Absolute symbols have a fixed address that can 
-    // conflict with standard symbols. These symbols (especially the 
-    // common ones), might still be referenced by relocations. These 
-    // relocations will use the symbol itself, and won't need an 
-    // object file address. The object file address field is optional 
-    // in the DebugMap, leave it unassigned for these symbols. 
-    uint32_t Flags = cantFail(Sym.getFlags()); 
-    if (Flags & SymbolRef::SF_Absolute) { 
-      CurrentObjectAddresses[*Name] = None; 
-    } else if (Flags & SymbolRef::SF_Common) { 
-      CurrentObjectAddresses[*Name] = None; 
-      CommonSymbols.push_back(std::string(*Name)); 
-    } else { 
-      CurrentObjectAddresses[*Name] = Addr; 
-    } 
-  } 
-} 
- 
-/// Lookup a symbol address in the main binary symbol table. The 
-/// parser only needs to query common symbols, thus not every symbol's 
-/// address is available through this function. 
-uint64_t MachODebugMapParser::getMainBinarySymbolAddress(StringRef Name) { 
-  auto Sym = MainBinarySymbolAddresses.find(Name); 
-  if (Sym == MainBinarySymbolAddresses.end()) 
-    return 0; 
-  return Sym->second; 
-} 
- 
-/// Get all symbol names in the main binary for the given value. 
-std::vector<StringRef> 
-MachODebugMapParser::getMainBinarySymbolNames(uint64_t Value) { 
-  std::vector<StringRef> Names; 
-  for (const auto &Entry : MainBinarySymbolAddresses) { 
-    if (Entry.second == Value) 
-      Names.push_back(Entry.first()); 
-  } 
-  return Names; 
-} 
- 
-/// Load the interesting main binary symbols' addresses into 
-/// MainBinarySymbolAddresses. 
-void MachODebugMapParser::loadMainBinarySymbols( 
-    const MachOObjectFile &MainBinary) { 
-  section_iterator Section = MainBinary.section_end(); 
-  MainBinarySymbolAddresses.clear(); 
-  for (const auto &Sym : MainBinary.symbols()) { 
-    Expected<SymbolRef::Type> TypeOrErr = Sym.getType(); 
-    if (!TypeOrErr) { 
-      // TODO: Actually report errors helpfully. 
-      consumeError(TypeOrErr.takeError()); 
-      continue; 
-    } 
-    SymbolRef::Type Type = *TypeOrErr; 
-    // Skip undefined and STAB entries. 
-    if ((Type == SymbolRef::ST_Debug) || (Type == SymbolRef::ST_Unknown)) 
-      continue; 
-    // In theory, the only symbols of interest are the global variables. These 
-    // are the only ones that need to be queried because the address of common 
-    // data won't be described in the debug map. All other addresses should be 
-    // fetched for the debug map. In reality, by playing with 'ld -r' and 
-    // export lists, you can get symbols described as N_GSYM in the debug map, 
-    // but associated with a local symbol. Gather all the symbols, but prefer 
-    // the global ones. 
-    uint8_t SymType = 
-        MainBinary.getSymbolTableEntry(Sym.getRawDataRefImpl()).n_type; 
-    bool Extern = SymType & (MachO::N_EXT | MachO::N_PEXT); 
-    Expected<section_iterator> SectionOrErr = Sym.getSection(); 
-    if (!SectionOrErr) { 
-      // TODO: Actually report errors helpfully. 
-      consumeError(SectionOrErr.takeError()); 
-      continue; 
-    } 
-    Section = *SectionOrErr; 
+//===- tools/dsymutil/MachODebugMapParser.cpp - Parse STABS debug maps ----===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "BinaryHolder.h"
+#include "DebugMap.h"
+#include "MachOUtils.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/Object/MachO.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/WithColor.h"
+#include "llvm/Support/raw_ostream.h"
+#include <vector>
+
+namespace {
+using namespace llvm;
+using namespace llvm::dsymutil;
+using namespace llvm::object;
+
+class MachODebugMapParser {
+public:
+  MachODebugMapParser(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
+                      StringRef BinaryPath, ArrayRef<std::string> Archs,
+                      StringRef PathPrefix = "",
+                      bool PaperTrailWarnings = false, bool Verbose = false)
+      : BinaryPath(std::string(BinaryPath)), Archs(Archs.begin(), Archs.end()),
+        PathPrefix(std::string(PathPrefix)),
+        PaperTrailWarnings(PaperTrailWarnings), BinHolder(VFS, Verbose),
+        CurrentDebugMapObject(nullptr) {}
+
+  /// Parses and returns the DebugMaps of the input binary. The binary contains
+  /// multiple maps in case it is a universal binary.
+  /// \returns an error in case the provided BinaryPath doesn't exist
+  /// or isn't of a supported type.
+  ErrorOr<std::vector<std::unique_ptr<DebugMap>>> parse();
+
+  /// Walk the symbol table and dump it.
+  bool dumpStab();
+
+private:
+  std::string BinaryPath;
+  SmallVector<StringRef, 1> Archs;
+  std::string PathPrefix;
+  bool PaperTrailWarnings;
+
+  /// Owns the MemoryBuffer for the main binary.
+  BinaryHolder BinHolder;
+  /// Map of the binary symbol addresses.
+  StringMap<uint64_t> MainBinarySymbolAddresses;
+  StringRef MainBinaryStrings;
+  /// The constructed DebugMap.
+  std::unique_ptr<DebugMap> Result;
+  /// List of common symbols that need to be added to the debug map.
+  std::vector<std::string> CommonSymbols;
+
+  /// Map of the currently processed object file symbol addresses.
+  StringMap<Optional<uint64_t>> CurrentObjectAddresses;
+  /// Element of the debug map corresponding to the current object file.
+  DebugMapObject *CurrentDebugMapObject;
+
+  /// Holds function info while function scope processing.
+  const char *CurrentFunctionName;
+  uint64_t CurrentFunctionAddress;
+
+  std::unique_ptr<DebugMap> parseOneBinary(const MachOObjectFile &MainBinary,
+                                           StringRef BinaryPath);
+
+  void
+  switchToNewDebugMapObject(StringRef Filename,
+                            sys::TimePoint<std::chrono::seconds> Timestamp);
+  void resetParserState();
+  uint64_t getMainBinarySymbolAddress(StringRef Name);
+  std::vector<StringRef> getMainBinarySymbolNames(uint64_t Value);
+  void loadMainBinarySymbols(const MachOObjectFile &MainBinary);
+  void loadCurrentObjectFileSymbols(const object::MachOObjectFile &Obj);
+  void handleStabSymbolTableEntry(uint32_t StringIndex, uint8_t Type,
+                                  uint8_t SectionIndex, uint16_t Flags,
+                                  uint64_t Value);
+
+  template <typename STEType> void handleStabDebugMapEntry(const STEType &STE) {
+    handleStabSymbolTableEntry(STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc,
+                               STE.n_value);
+  }
+
+  void addCommonSymbols();
+
+  /// Dump the symbol table output header.
+  void dumpSymTabHeader(raw_ostream &OS, StringRef Arch);
+
+  /// Dump the contents of nlist entries.
+  void dumpSymTabEntry(raw_ostream &OS, uint64_t Index, uint32_t StringIndex,
+                       uint8_t Type, uint8_t SectionIndex, uint16_t Flags,
+                       uint64_t Value);
+
+  template <typename STEType>
+  void dumpSymTabEntry(raw_ostream &OS, uint64_t Index, const STEType &STE) {
+    dumpSymTabEntry(OS, Index, STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc,
+                    STE.n_value);
+  }
+  void dumpOneBinaryStab(const MachOObjectFile &MainBinary,
+                         StringRef BinaryPath);
+
+  void Warning(const Twine &Msg, StringRef File = StringRef()) {
+    WithColor::warning() << "("
+                         << MachOUtils::getArchName(
+                                Result->getTriple().getArchName())
+                         << ") " << File << " " << Msg << "\n";
+
+    if (PaperTrailWarnings) {
+      if (!File.empty())
+        Result->addDebugMapObject(File, sys::TimePoint<std::chrono::seconds>());
+      if (Result->end() != Result->begin()) {
+        auto it = Result->end();
+        (*--it)->addWarning(Msg.str());
+      }
+    }
+  }
+};
+
+} // anonymous namespace
+
+/// Reset the parser state corresponding to the current object
+/// file. This is to be called after an object file is finished
+/// processing.
+void MachODebugMapParser::resetParserState() {
+  CommonSymbols.clear();
+  CurrentObjectAddresses.clear();
+  CurrentDebugMapObject = nullptr;
+}
+
+/// Commons symbols won't show up in the symbol map but might need to be
+/// relocated. We can add them to the symbol table ourselves by combining the
+/// information in the object file (the symbol name) and the main binary (the
+/// address).
+void MachODebugMapParser::addCommonSymbols() {
+  for (auto &CommonSymbol : CommonSymbols) {
+    uint64_t CommonAddr = getMainBinarySymbolAddress(CommonSymbol);
+    if (CommonAddr == 0) {
+      // The main binary doesn't have an address for the given symbol.
+      continue;
+    }
+    if (!CurrentDebugMapObject->addSymbol(CommonSymbol, None /*ObjectAddress*/,
+                                          CommonAddr, 0 /*size*/)) {
+      // The symbol is already present.
+      continue;
+    }
+  }
+}
+
+/// Create a new DebugMapObject. This function resets the state of the
+/// parser that was referring to the last object file and sets
+/// everything up to add symbols to the new one.
+void MachODebugMapParser::switchToNewDebugMapObject(
+    StringRef Filename, sys::TimePoint<std::chrono::seconds> Timestamp) {
+  addCommonSymbols();
+  resetParserState();
+
+  SmallString<80> Path(PathPrefix);
+  sys::path::append(Path, Filename);
+
+  auto ObjectEntry = BinHolder.getObjectEntry(Path, Timestamp);
+  if (!ObjectEntry) {
+    auto Err = ObjectEntry.takeError();
+    Warning("unable to open object file: " + toString(std::move(Err)),
+            Path.str());
+    return;
+  }
+
+  auto Object = ObjectEntry->getObjectAs<MachOObjectFile>(Result->getTriple());
+  if (!Object) {
+    auto Err = Object.takeError();
+    Warning("unable to open object file: " + toString(std::move(Err)),
+            Path.str());
+    return;
+  }
+
+  CurrentDebugMapObject =
+      &Result->addDebugMapObject(Path, Timestamp, MachO::N_OSO);
+  loadCurrentObjectFileSymbols(*Object);
+}
+
+static std::string getArchName(const object::MachOObjectFile &Obj) {
+  Triple T = Obj.getArchTriple();
+  return std::string(T.getArchName());
+}
+
+std::unique_ptr<DebugMap>
+MachODebugMapParser::parseOneBinary(const MachOObjectFile &MainBinary,
+                                    StringRef BinaryPath) {
+  loadMainBinarySymbols(MainBinary);
+  ArrayRef<uint8_t> UUID = MainBinary.getUuid();
+  Result =
+      std::make_unique<DebugMap>(MainBinary.getArchTriple(), BinaryPath, UUID);
+  MainBinaryStrings = MainBinary.getStringTableData();
+  for (const SymbolRef &Symbol : MainBinary.symbols()) {
+    const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
+    if (MainBinary.is64Bit())
+      handleStabDebugMapEntry(MainBinary.getSymbol64TableEntry(DRI));
+    else
+      handleStabDebugMapEntry(MainBinary.getSymbolTableEntry(DRI));
+  }
+
+  resetParserState();
+  return std::move(Result);
+}
+
+// Table that maps Darwin's Mach-O stab constants to strings to allow printing.
+// llvm-nm has very similar code, the strings used here are however slightly
+// different and part of the interface of dsymutil (some project's build-systems
+// parse the ouptut of dsymutil -s), thus they shouldn't be changed.
+struct DarwinStabName {
+  uint8_t NType;
+  const char *Name;
+};
+
+static const struct DarwinStabName DarwinStabNames[] = {
+    {MachO::N_GSYM, "N_GSYM"},    {MachO::N_FNAME, "N_FNAME"},
+    {MachO::N_FUN, "N_FUN"},      {MachO::N_STSYM, "N_STSYM"},
+    {MachO::N_LCSYM, "N_LCSYM"},  {MachO::N_BNSYM, "N_BNSYM"},
+    {MachO::N_PC, "N_PC"},        {MachO::N_AST, "N_AST"},
+    {MachO::N_OPT, "N_OPT"},      {MachO::N_RSYM, "N_RSYM"},
+    {MachO::N_SLINE, "N_SLINE"},  {MachO::N_ENSYM, "N_ENSYM"},
+    {MachO::N_SSYM, "N_SSYM"},    {MachO::N_SO, "N_SO"},
+    {MachO::N_OSO, "N_OSO"},      {MachO::N_LSYM, "N_LSYM"},
+    {MachO::N_BINCL, "N_BINCL"},  {MachO::N_SOL, "N_SOL"},
+    {MachO::N_PARAMS, "N_PARAM"}, {MachO::N_VERSION, "N_VERS"},
+    {MachO::N_OLEVEL, "N_OLEV"},  {MachO::N_PSYM, "N_PSYM"},
+    {MachO::N_EINCL, "N_EINCL"},  {MachO::N_ENTRY, "N_ENTRY"},
+    {MachO::N_LBRAC, "N_LBRAC"},  {MachO::N_EXCL, "N_EXCL"},
+    {MachO::N_RBRAC, "N_RBRAC"},  {MachO::N_BCOMM, "N_BCOMM"},
+    {MachO::N_ECOMM, "N_ECOMM"},  {MachO::N_ECOML, "N_ECOML"},
+    {MachO::N_LENG, "N_LENG"},    {0, nullptr}};
+
+static const char *getDarwinStabString(uint8_t NType) {
+  for (unsigned i = 0; DarwinStabNames[i].Name; i++) {
+    if (DarwinStabNames[i].NType == NType)
+      return DarwinStabNames[i].Name;
+  }
+  return nullptr;
+}
+
+void MachODebugMapParser::dumpSymTabHeader(raw_ostream &OS, StringRef Arch) {
+  OS << "-----------------------------------"
+        "-----------------------------------\n";
+  OS << "Symbol table for: '" << BinaryPath << "' (" << Arch.data() << ")\n";
+  OS << "-----------------------------------"
+        "-----------------------------------\n";
+  OS << "Index    n_strx   n_type             n_sect n_desc n_value\n";
+  OS << "======== -------- ------------------ ------ ------ ----------------\n";
+}
+
+void MachODebugMapParser::dumpSymTabEntry(raw_ostream &OS, uint64_t Index,
+                                          uint32_t StringIndex, uint8_t Type,
+                                          uint8_t SectionIndex, uint16_t Flags,
+                                          uint64_t Value) {
+  // Index
+  OS << '[' << format_decimal(Index, 6)
+     << "] "
+     // n_strx
+     << format_hex_no_prefix(StringIndex, 8)
+     << ' '
+     // n_type...
+     << format_hex_no_prefix(Type, 2) << " (";
+
+  if (Type & MachO::N_STAB)
+    OS << left_justify(getDarwinStabString(Type), 13);
+  else {
+    if (Type & MachO::N_PEXT)
+      OS << "PEXT ";
+    else
+      OS << "     ";
+    switch (Type & MachO::N_TYPE) {
+    case MachO::N_UNDF: // 0x0 undefined, n_sect == NO_SECT
+      OS << "UNDF";
+      break;
+    case MachO::N_ABS: // 0x2 absolute, n_sect == NO_SECT
+      OS << "ABS ";
+      break;
+    case MachO::N_SECT: // 0xe defined in section number n_sect
+      OS << "SECT";
+      break;
+    case MachO::N_PBUD: // 0xc prebound undefined (defined in a dylib)
+      OS << "PBUD";
+      break;
+    case MachO::N_INDR: // 0xa indirect
+      OS << "INDR";
+      break;
+    default:
+      OS << format_hex_no_prefix(Type, 2) << "    ";
+      break;
+    }
+    if (Type & MachO::N_EXT)
+      OS << " EXT";
+    else
+      OS << "    ";
+  }
+
+  OS << ") "
+     // n_sect
+     << format_hex_no_prefix(SectionIndex, 2)
+     << "     "
+     // n_desc
+     << format_hex_no_prefix(Flags, 4)
+     << "   "
+     // n_value
+     << format_hex_no_prefix(Value, 16);
+
+  const char *Name = &MainBinaryStrings.data()[StringIndex];
+  if (Name && Name[0])
+    OS << " '" << Name << "'";
+
+  OS << "\n";
+}
+
+void MachODebugMapParser::dumpOneBinaryStab(const MachOObjectFile &MainBinary,
+                                            StringRef BinaryPath) {
+  loadMainBinarySymbols(MainBinary);
+  MainBinaryStrings = MainBinary.getStringTableData();
+  raw_ostream &OS(llvm::outs());
+
+  dumpSymTabHeader(OS, getArchName(MainBinary));
+  uint64_t Idx = 0;
+  for (const SymbolRef &Symbol : MainBinary.symbols()) {
+    const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
+    if (MainBinary.is64Bit())
+      dumpSymTabEntry(OS, Idx, MainBinary.getSymbol64TableEntry(DRI));
+    else
+      dumpSymTabEntry(OS, Idx, MainBinary.getSymbolTableEntry(DRI));
+    Idx++;
+  }
+
+  OS << "\n\n";
+  resetParserState();
+}
+
+static bool shouldLinkArch(SmallVectorImpl<StringRef> &Archs, StringRef Arch) {
+  if (Archs.empty() || is_contained(Archs, "all") || is_contained(Archs, "*"))
+    return true;
+
+  if (Arch.startswith("arm") && Arch != "arm64" && is_contained(Archs, "arm"))
+    return true;
+
+  SmallString<16> ArchName = Arch;
+  if (Arch.startswith("thumb"))
+    ArchName = ("arm" + Arch.substr(5)).str();
+
+  return is_contained(Archs, ArchName);
+}
+
+bool MachODebugMapParser::dumpStab() {
+  auto ObjectEntry = BinHolder.getObjectEntry(BinaryPath);
+  if (!ObjectEntry) {
+    auto Err = ObjectEntry.takeError();
+    WithColor::error() << "cannot load '" << BinaryPath
+                       << "': " << toString(std::move(Err)) << '\n';
+    return false;
+  }
+
+  auto Objects = ObjectEntry->getObjectsAs<MachOObjectFile>();
+  if (!Objects) {
+    auto Err = Objects.takeError();
+    WithColor::error() << "cannot get '" << BinaryPath
+                       << "' as MachO file: " << toString(std::move(Err))
+                       << "\n";
+    return false;
+  }
+
+  for (const auto *Object : *Objects)
+    if (shouldLinkArch(Archs, Object->getArchTriple().getArchName()))
+      dumpOneBinaryStab(*Object, BinaryPath);
+
+  return true;
+}
+
+/// This main parsing routine tries to open the main binary and if
+/// successful iterates over the STAB entries. The real parsing is
+/// done in handleStabSymbolTableEntry.
+ErrorOr<std::vector<std::unique_ptr<DebugMap>>> MachODebugMapParser::parse() {
+  auto ObjectEntry = BinHolder.getObjectEntry(BinaryPath);
+  if (!ObjectEntry) {
+    return errorToErrorCode(ObjectEntry.takeError());
+  }
+
+  auto Objects = ObjectEntry->getObjectsAs<MachOObjectFile>();
+  if (!Objects) {
+    return errorToErrorCode(Objects.takeError());
+  }
+
+  std::vector<std::unique_ptr<DebugMap>> Results;
+  for (const auto *Object : *Objects)
+    if (shouldLinkArch(Archs, Object->getArchTriple().getArchName()))
+      Results.push_back(parseOneBinary(*Object, BinaryPath));
+
+  return std::move(Results);
+}
+
+/// Interpret the STAB entries to fill the DebugMap.
+void MachODebugMapParser::handleStabSymbolTableEntry(uint32_t StringIndex,
+                                                     uint8_t Type,
+                                                     uint8_t SectionIndex,
+                                                     uint16_t Flags,
+                                                     uint64_t Value) {
+  if (!(Type & MachO::N_STAB))
+    return;
+
+  const char *Name = &MainBinaryStrings.data()[StringIndex];
+
+  // An N_OSO entry represents the start of a new object file description.
+  if (Type == MachO::N_OSO)
+    return switchToNewDebugMapObject(Name, sys::toTimePoint(Value));
+
+  if (Type == MachO::N_AST) {
+    SmallString<80> Path(PathPrefix);
+    sys::path::append(Path, Name);
+    Result->addDebugMapObject(Path, sys::toTimePoint(Value), Type);
+    return;
+  }
+
+  // If the last N_OSO object file wasn't found, CurrentDebugMapObject will be
+  // null. Do not update anything until we find the next valid N_OSO entry.
+  if (!CurrentDebugMapObject)
+    return;
+
+  uint32_t Size = 0;
+  switch (Type) {
+  case MachO::N_GSYM:
+    // This is a global variable. We need to query the main binary
+    // symbol table to find its address as it might not be in the
+    // debug map (for common symbols).
+    Value = getMainBinarySymbolAddress(Name);
+    break;
+  case MachO::N_FUN:
+    // Functions are scopes in STABS. They have an end marker that
+    // contains the function size.
+    if (Name[0] == '\0') {
+      Size = Value;
+      Value = CurrentFunctionAddress;
+      Name = CurrentFunctionName;
+      break;
+    } else {
+      CurrentFunctionName = Name;
+      CurrentFunctionAddress = Value;
+      return;
+    }
+  case MachO::N_STSYM:
+    break;
+  default:
+    return;
+  }
+
+  auto ObjectSymIt = CurrentObjectAddresses.find(Name);
+
+  // If the name of a (non-static) symbol is not in the current object, we
+  // check all its aliases from the main binary.
+  if (ObjectSymIt == CurrentObjectAddresses.end() && Type != MachO::N_STSYM) {
+    for (const auto &Alias : getMainBinarySymbolNames(Value)) {
+      ObjectSymIt = CurrentObjectAddresses.find(Alias);
+      if (ObjectSymIt != CurrentObjectAddresses.end())
+        break;
+    }
+  }
+
+  if (ObjectSymIt == CurrentObjectAddresses.end()) {
+    Warning("could not find object file symbol for symbol " + Twine(Name));
+    return;
+  }
+
+  if (!CurrentDebugMapObject->addSymbol(Name, ObjectSymIt->getValue(), Value,
+                                        Size)) {
+    Warning(Twine("failed to insert symbol '") + Name + "' in the debug map.");
+    return;
+  }
+}
+
+/// Load the current object file symbols into CurrentObjectAddresses.
+void MachODebugMapParser::loadCurrentObjectFileSymbols(
+    const object::MachOObjectFile &Obj) {
+  CurrentObjectAddresses.clear();
+
+  for (auto Sym : Obj.symbols()) {
+    uint64_t Addr = cantFail(Sym.getValue());
+    Expected<StringRef> Name = Sym.getName();
+    if (!Name) {
+      // TODO: Actually report errors helpfully.
+      consumeError(Name.takeError());
+      continue;
+    }
+    // The value of some categories of symbols isn't meaningful. For
+    // example common symbols store their size in the value field, not
+    // their address. Absolute symbols have a fixed address that can
+    // conflict with standard symbols. These symbols (especially the
+    // common ones), might still be referenced by relocations. These
+    // relocations will use the symbol itself, and won't need an
+    // object file address. The object file address field is optional
+    // in the DebugMap, leave it unassigned for these symbols.
+    uint32_t Flags = cantFail(Sym.getFlags());
+    if (Flags & SymbolRef::SF_Absolute) {
+      CurrentObjectAddresses[*Name] = None;
+    } else if (Flags & SymbolRef::SF_Common) {
+      CurrentObjectAddresses[*Name] = None;
+      CommonSymbols.push_back(std::string(*Name));
+    } else {
+      CurrentObjectAddresses[*Name] = Addr;
+    }
+  }
+}
+
+/// Lookup a symbol address in the main binary symbol table. The
+/// parser only needs to query common symbols, thus not every symbol's
+/// address is available through this function.
+uint64_t MachODebugMapParser::getMainBinarySymbolAddress(StringRef Name) {
+  auto Sym = MainBinarySymbolAddresses.find(Name);
+  if (Sym == MainBinarySymbolAddresses.end())
+    return 0;
+  return Sym->second;
+}
+
+/// Get all symbol names in the main binary for the given value.
+std::vector<StringRef>
+MachODebugMapParser::getMainBinarySymbolNames(uint64_t Value) {
+  std::vector<StringRef> Names;
+  for (const auto &Entry : MainBinarySymbolAddresses) {
+    if (Entry.second == Value)
+      Names.push_back(Entry.first());
+  }
+  return Names;
+}
+
+/// Load the interesting main binary symbols' addresses into
+/// MainBinarySymbolAddresses.
+void MachODebugMapParser::loadMainBinarySymbols(
+    const MachOObjectFile &MainBinary) {
+  section_iterator Section = MainBinary.section_end();
+  MainBinarySymbolAddresses.clear();
+  for (const auto &Sym : MainBinary.symbols()) {
+    Expected<SymbolRef::Type> TypeOrErr = Sym.getType();
+    if (!TypeOrErr) {
+      // TODO: Actually report errors helpfully.
+      consumeError(TypeOrErr.takeError());
+      continue;
+    }
+    SymbolRef::Type Type = *TypeOrErr;
+    // Skip undefined and STAB entries.
+    if ((Type == SymbolRef::ST_Debug) || (Type == SymbolRef::ST_Unknown))
+      continue;
+    // In theory, the only symbols of interest are the global variables. These
+    // are the only ones that need to be queried because the address of common
+    // data won't be described in the debug map. All other addresses should be
+    // fetched for the debug map. In reality, by playing with 'ld -r' and
+    // export lists, you can get symbols described as N_GSYM in the debug map,
+    // but associated with a local symbol. Gather all the symbols, but prefer
+    // the global ones.
+    uint8_t SymType =
+        MainBinary.getSymbolTableEntry(Sym.getRawDataRefImpl()).n_type;
+    bool Extern = SymType & (MachO::N_EXT | MachO::N_PEXT);
+    Expected<section_iterator> SectionOrErr = Sym.getSection();
+    if (!SectionOrErr) {
+      // TODO: Actually report errors helpfully.
+      consumeError(SectionOrErr.takeError());
+      continue;
+    }
+    Section = *SectionOrErr;
     if ((Section == MainBinary.section_end() || Section->isText()) && !Extern)
-      continue; 
-    uint64_t Addr = cantFail(Sym.getValue()); 
-    Expected<StringRef> NameOrErr = Sym.getName(); 
-    if (!NameOrErr) { 
-      // TODO: Actually report errors helpfully. 
-      consumeError(NameOrErr.takeError()); 
-      continue; 
-    } 
-    StringRef Name = *NameOrErr; 
-    if (Name.size() == 0 || Name[0] == '\0') 
-      continue; 
-    // Override only if the new key is global. 
-    if (Extern) 
-      MainBinarySymbolAddresses[Name] = Addr; 
-    else 
-      MainBinarySymbolAddresses.try_emplace(Name, Addr); 
-  } 
-} 
- 
-namespace llvm { 
-namespace dsymutil { 
-llvm::ErrorOr<std::vector<std::unique_ptr<DebugMap>>> 
-parseDebugMap(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS, 
-              StringRef InputFile, ArrayRef<std::string> Archs, 
-              StringRef PrependPath, bool PaperTrailWarnings, bool Verbose, 
-              bool InputIsYAML) { 
-  if (InputIsYAML) 
-    return DebugMap::parseYAMLDebugMap(InputFile, PrependPath, Verbose); 
- 
-  MachODebugMapParser Parser(VFS, InputFile, Archs, PrependPath, 
-                             PaperTrailWarnings, Verbose); 
-  return Parser.parse(); 
-} 
- 
-bool dumpStab(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS, 
-              StringRef InputFile, ArrayRef<std::string> Archs, 
-              StringRef PrependPath) { 
-  MachODebugMapParser Parser(VFS, InputFile, Archs, PrependPath, false); 
-  return Parser.dumpStab(); 
-} 
-} // namespace dsymutil 
-} // namespace llvm 
+      continue;
+    uint64_t Addr = cantFail(Sym.getValue());
+    Expected<StringRef> NameOrErr = Sym.getName();
+    if (!NameOrErr) {
+      // TODO: Actually report errors helpfully.
+      consumeError(NameOrErr.takeError());
+      continue;
+    }
+    StringRef Name = *NameOrErr;
+    if (Name.size() == 0 || Name[0] == '\0')
+      continue;
+    // Override only if the new key is global.
+    if (Extern)
+      MainBinarySymbolAddresses[Name] = Addr;
+    else
+      MainBinarySymbolAddresses.try_emplace(Name, Addr);
+  }
+}
+
+namespace llvm {
+namespace dsymutil {
+llvm::ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
+parseDebugMap(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
+              StringRef InputFile, ArrayRef<std::string> Archs,
+              StringRef PrependPath, bool PaperTrailWarnings, bool Verbose,
+              bool InputIsYAML) {
+  if (InputIsYAML)
+    return DebugMap::parseYAMLDebugMap(InputFile, PrependPath, Verbose);
+
+  MachODebugMapParser Parser(VFS, InputFile, Archs, PrependPath,
+                             PaperTrailWarnings, Verbose);
+  return Parser.parse();
+}
+
+bool dumpStab(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
+              StringRef InputFile, ArrayRef<std::string> Archs,
+              StringRef PrependPath) {
+  MachODebugMapParser Parser(VFS, InputFile, Archs, PrependPath, false);
+  return Parser.dumpStab();
+}
+} // namespace dsymutil
+} // namespace llvm