tools/dsymutil/MachODebugMapParser.cpp

   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/Object/MachO.h"
  14 #include "llvm/Support/Path.h"
  15 #include "llvm/Support/raw_ostream.h"
  16
  17 namespace {
  18 using namespace llvm;
  19 using namespace llvm::dsymutil;
  20 using namespace llvm::object;
  21
  22 class MachODebugMapParser {
  23 public:
  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) {}
  29
  30   /// \brief Parses and returns the DebugMaps of the input binary.
  31   /// The binary contains multiple maps in case it is a universal
  32   /// binary.
  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();
  36
  37 private:
  38   std::string BinaryPath;
  39   SmallVector<StringRef, 1> Archs;
  40   std::string PathPrefix;
  41
  42   /// Owns the MemoryBuffer for the main binary.
  43   BinaryHolder MainBinaryHolder;
  44   /// Map of the binary symbol addresses.
  45   StringMap<uint64_t> MainBinarySymbolAddresses;
  46   StringRef MainBinaryStrings;
  47   /// The constructed DebugMap.
  48   std::unique_ptr<DebugMap> Result;
  49
  50   /// Owns the MemoryBuffer for the currently handled object file.
  51   BinaryHolder CurrentObjectHolder;
  52   /// Map of the currently processed object file symbol addresses.
  53   StringMap<uint64_t> CurrentObjectAddresses;
  54   /// Element of the debug map corresponfing to the current object file.
  55   DebugMapObject *CurrentDebugMapObject;
  56
  57   /// Holds function info while function scope processing.
  58   const char *CurrentFunctionName;
  59   uint64_t CurrentFunctionAddress;
  60
  61   std::unique_ptr<DebugMap> parseOneBinary(const MachOObjectFile &MainBinary,
  62                                            StringRef BinaryPath);
  63
  64   void switchToNewDebugMapObject(StringRef Filename, sys::TimeValue Timestamp);
  65   void resetParserState();
  66   uint64_t getMainBinarySymbolAddress(StringRef Name);
  67   void loadMainBinarySymbols(const MachOObjectFile &MainBinary);
  68   void loadCurrentObjectFileSymbols(const object::MachOObjectFile &Obj);
  69   void handleStabSymbolTableEntry(uint32_t StringIndex, uint8_t Type,
  70                                   uint8_t SectionIndex, uint16_t Flags,
  71                                   uint64_t Value);
  72
  73   template <typename STEType> void handleStabDebugMapEntry(const STEType &STE) {
  74     handleStabSymbolTableEntry(STE.n_strx, STE.n_type, STE.n_sect, STE.n_desc,
  75                                STE.n_value);
  76   }
  77 };
  78
  79 static void Warning(const Twine &Msg) { errs() << "warning: " + Msg + "\n"; }
  80 }
  81
  82 /// Reset the parser state coresponding to the current object
  83 /// file. This is to be called after an object file is finished
  84 /// processing.
  85 void MachODebugMapParser::resetParserState() {
  86   CurrentObjectAddresses.clear();
  87   CurrentDebugMapObject = nullptr;
  88 }
  89
  90 /// Create a new DebugMapObject. This function resets the state of the
  91 /// parser that was referring to the last object file and sets
  92 /// everything up to add symbols to the new one.
  93 void MachODebugMapParser::switchToNewDebugMapObject(StringRef Filename,
  94                                                     sys::TimeValue Timestamp) {
  95   resetParserState();
  96
  97   SmallString<80> Path(PathPrefix);
  98   sys::path::append(Path, Filename);
  99
 100   auto MachOOrError =
 101       CurrentObjectHolder.GetFilesAs<MachOObjectFile>(Path, Timestamp);
 102   if (auto Error = MachOOrError.getError()) {
 103     Warning(Twine("cannot open debug object \"") + Path.str() + "\": " +
 104             Error.message() + "\n");
 105     return;
 106   }
 107
 108   auto ErrOrAchObj =
 109       CurrentObjectHolder.GetAs<MachOObjectFile>(Result->getTriple());
 110   if (auto Err = ErrOrAchObj.getError()) {
 111     return Warning(Twine("cannot open debug object \"") + Path.str() + "\": " +
 112                    Err.message() + "\n");
 113   }
 114
 115   CurrentDebugMapObject = &Result->addDebugMapObject(Path, Timestamp);
 116   loadCurrentObjectFileSymbols(*ErrOrAchObj);
 117 }
 118
 119 std::unique_ptr<DebugMap>
 120 MachODebugMapParser::parseOneBinary(const MachOObjectFile &MainBinary,
 121                                     StringRef BinaryPath) {
 122   loadMainBinarySymbols(MainBinary);
 123   Result =
 124       make_unique<DebugMap>(BinaryHolder::getTriple(MainBinary), BinaryPath);
 125   MainBinaryStrings = MainBinary.getStringTableData();
 126   for (const SymbolRef &Symbol : MainBinary.symbols()) {
 127     const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
 128     if (MainBinary.is64Bit())
 129       handleStabDebugMapEntry(MainBinary.getSymbol64TableEntry(DRI));
 130     else
 131       handleStabDebugMapEntry(MainBinary.getSymbolTableEntry(DRI));
 132   }
 133
 134   resetParserState();
 135   return std::move(Result);
 136 }
 137
 138 static bool shouldLinkArch(SmallVectorImpl<StringRef> &Archs, StringRef Arch) {
 139   if (Archs.empty() ||
 140       std::find(Archs.begin(), Archs.end(), "all") != Archs.end() ||
 141       std::find(Archs.begin(), Archs.end(), "*") != Archs.end())
 142     return true;
 143
 144   if (Arch.startswith("arm") && Arch != "arm64" &&
 145       std::find(Archs.begin(), Archs.end(), "arm") != Archs.end())
 146     return true;
 147
 148   return std::find(Archs.begin(), Archs.end(), Arch) != Archs.end();
 149 }
 150
 151 /// This main parsing routine tries to open the main binary and if
 152 /// successful iterates over the STAB entries. The real parsing is
 153 /// done in handleStabSymbolTableEntry.
 154 ErrorOr<std::vector<std::unique_ptr<DebugMap>>> MachODebugMapParser::parse() {
 155   auto MainBinOrError =
 156       MainBinaryHolder.GetFilesAs<MachOObjectFile>(BinaryPath);
 157   if (auto Error = MainBinOrError.getError())
 158     return Error;
 159
 160   std::vector<std::unique_ptr<DebugMap>> Results;
 161   Triple T;
 162   for (const auto *Binary : *MainBinOrError)
 163     if (shouldLinkArch(Archs, Binary->getArch(nullptr, &T).getArchName()))
 164       Results.push_back(parseOneBinary(*Binary, BinaryPath));
 165
 166   return std::move(Results);
 167 }
 168
 169 /// Interpret the STAB entries to fill the DebugMap.
 170 void MachODebugMapParser::handleStabSymbolTableEntry(uint32_t StringIndex,
 171                                                      uint8_t Type,
 172                                                      uint8_t SectionIndex,
 173                                                      uint16_t Flags,
 174                                                      uint64_t Value) {
 175   if (!(Type & MachO::N_STAB))
 176     return;
 177
 178   const char *Name = &MainBinaryStrings.data()[StringIndex];
 179
 180   // An N_OSO entry represents the start of a new object file description.
 181   if (Type == MachO::N_OSO) {
 182     sys::TimeValue Timestamp;
 183     Timestamp.fromEpochTime(Value);
 184     return switchToNewDebugMapObject(Name, Timestamp);
 185   }
 186
 187   // If the last N_OSO object file wasn't found,
 188   // CurrentDebugMapObject will be null. Do not update anything
 189   // until we find the next valid N_OSO entry.
 190   if (!CurrentDebugMapObject)
 191     return;
 192
 193   uint32_t Size = 0;
 194   switch (Type) {
 195   case MachO::N_GSYM:
 196     // This is a global variable. We need to query the main binary
 197     // symbol table to find its address as it might not be in the
 198     // debug map (for common symbols).
 199     Value = getMainBinarySymbolAddress(Name);
 200     break;
 201   case MachO::N_FUN:
 202     // Functions are scopes in STABS. They have an end marker that
 203     // contains the function size.
 204     if (Name[0] == '\0') {
 205       Size = Value;
 206       Value = CurrentFunctionAddress;
 207       Name = CurrentFunctionName;
 208       break;
 209     } else {
 210       CurrentFunctionName = Name;
 211       CurrentFunctionAddress = Value;
 212       return;
 213     }
 214   case MachO::N_STSYM:
 215     break;
 216   default:
 217     return;
 218   }
 219
 220   auto ObjectSymIt = CurrentObjectAddresses.find(Name);
 221   if (ObjectSymIt == CurrentObjectAddresses.end())
 222     return Warning("could not find object file symbol for symbol " +
 223                    Twine(Name));
 224   if (!CurrentDebugMapObject->addSymbol(Name, ObjectSymIt->getValue(), Value,
 225                                         Size))
 226     return Warning(Twine("failed to insert symbol '") + Name +
 227                    "' in the debug map.");
 228 }
 229
 230 /// Load the current object file symbols into CurrentObjectAddresses.
 231 void MachODebugMapParser::loadCurrentObjectFileSymbols(
 232     const object::MachOObjectFile &Obj) {
 233   CurrentObjectAddresses.clear();
 234
 235   for (auto Sym : Obj.symbols()) {
 236     uint64_t Addr = Sym.getValue();
 237     ErrorOr<StringRef> Name = Sym.getName();
 238     if (!Name)
 239       continue;
 240     CurrentObjectAddresses[*Name] = Addr;
 241   }
 242 }
 243
 244 /// Lookup a symbol address in the main binary symbol table. The
 245 /// parser only needs to query common symbols, thus not every symbol's
 246 /// address is available through this function.
 247 uint64_t MachODebugMapParser::getMainBinarySymbolAddress(StringRef Name) {
 248   auto Sym = MainBinarySymbolAddresses.find(Name);
 249   if (Sym == MainBinarySymbolAddresses.end())
 250     return 0;
 251   return Sym->second;
 252 }
 253
 254 /// Load the interesting main binary symbols' addresses into
 255 /// MainBinarySymbolAddresses.
 256 void MachODebugMapParser::loadMainBinarySymbols(
 257     const MachOObjectFile &MainBinary) {
 258   section_iterator Section = MainBinary.section_end();
 259   MainBinarySymbolAddresses.clear();
 260   for (const auto &Sym : MainBinary.symbols()) {
 261     SymbolRef::Type Type = Sym.getType();
 262     // Skip undefined and STAB entries.
 263     if ((Type & SymbolRef::ST_Debug) || (Type & SymbolRef::ST_Unknown))
 264       continue;
 265     // The only symbols of interest are the global variables. These
 266     // are the only ones that need to be queried because the address
 267     // of common data won't be described in the debug map. All other
 268     // addresses should be fetched for the debug map.
 269     if (!(Sym.getFlags() & SymbolRef::SF_Global))
 270       continue;
 271     ErrorOr<section_iterator> SectionOrErr = Sym.getSection();
 272     if (!SectionOrErr)
 273       continue;
 274     Section = *SectionOrErr;
 275     if (Section == MainBinary.section_end() || Section->isText())
 276       continue;
 277     uint64_t Addr = Sym.getValue();
 278     ErrorOr<StringRef> NameOrErr = Sym.getName();
 279     if (!NameOrErr)
 280       continue;
 281     StringRef Name = *NameOrErr;
 282     if (Name.size() == 0 || Name[0] == '\0')
 283       continue;
 284     MainBinarySymbolAddresses[Name] = Addr;
 285   }
 286 }
 287
 288 namespace llvm {
 289 namespace dsymutil {
 290 llvm::ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
 291 parseDebugMap(StringRef InputFile, ArrayRef<std::string> Archs,
 292               StringRef PrependPath, bool Verbose, bool InputIsYAML) {
 293   if (!InputIsYAML) {
 294     MachODebugMapParser Parser(InputFile, Archs, PrependPath, Verbose);
 295     return Parser.parse();
 296   } else {
 297     return DebugMap::parseYAMLDebugMap(InputFile, PrependPath, Verbose);
 298   }
 299 }
 300 }
 301 }