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 = make_unique<DebugMap>(BinaryHolder::getTriple(MainBinary));
124   MainBinaryStrings = MainBinary.getStringTableData();
125   for (const SymbolRef &Symbol : MainBinary.symbols()) {
126     const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
127     if (MainBinary.is64Bit())
128       handleStabDebugMapEntry(MainBinary.getSymbol64TableEntry(DRI));
129     else
130       handleStabDebugMapEntry(MainBinary.getSymbolTableEntry(DRI));
131   }
132 
133   resetParserState();
134   return std::move(Result);
135 }
136 
137 static bool shouldLinkArch(SmallVectorImpl<StringRef> &Archs, StringRef Arch) {
138   if (Archs.empty() ||
139       std::find(Archs.begin(), Archs.end(), "all") != Archs.end() ||
140       std::find(Archs.begin(), Archs.end(), "*") != Archs.end())
141     return true;
142 
143   if (Arch.startswith("arm") && Arch != "arm64" &&
144       std::find(Archs.begin(), Archs.end(), "arm") != Archs.end())
145     return true;
146 
147   return std::find(Archs.begin(), Archs.end(), Arch) != Archs.end();
148 }
149 
150 /// This main parsing routine tries to open the main binary and if
151 /// successful iterates over the STAB entries. The real parsing is
152 /// done in handleStabSymbolTableEntry.
153 ErrorOr<std::vector<std::unique_ptr<DebugMap>>> MachODebugMapParser::parse() {
154   auto MainBinOrError =
155       MainBinaryHolder.GetFilesAs<MachOObjectFile>(BinaryPath);
156   if (auto Error = MainBinOrError.getError())
157     return Error;
158 
159   std::vector<std::unique_ptr<DebugMap>> Results;
160   Triple T;
161   for (const auto *Binary : *MainBinOrError)
162     if (shouldLinkArch(Archs, Binary->getArch(nullptr, &T).getArchName()))
163       Results.push_back(parseOneBinary(*Binary, BinaryPath));
164 
165   return std::move(Results);
166 }
167 
168 /// Interpret the STAB entries to fill the DebugMap.
169 void MachODebugMapParser::handleStabSymbolTableEntry(uint32_t StringIndex,
170                                                      uint8_t Type,
171                                                      uint8_t SectionIndex,
172                                                      uint16_t Flags,
173                                                      uint64_t Value) {
174   if (!(Type & MachO::N_STAB))
175     return;
176 
177   const char *Name = &MainBinaryStrings.data()[StringIndex];
178 
179   // An N_OSO entry represents the start of a new object file description.
180   if (Type == MachO::N_OSO) {
181     sys::TimeValue Timestamp;
182     Timestamp.fromEpochTime(Value);
183     return switchToNewDebugMapObject(Name, Timestamp);
184   }
185 
186   // If the last N_OSO object file wasn't found,
187   // CurrentDebugMapObject will be null. Do not update anything
188   // until we find the next valid N_OSO entry.
189   if (!CurrentDebugMapObject)
190     return;
191 
192   uint32_t Size = 0;
193   switch (Type) {
194   case MachO::N_GSYM:
195     // This is a global variable. We need to query the main binary
196     // symbol table to find its address as it might not be in the
197     // debug map (for common symbols).
198     Value = getMainBinarySymbolAddress(Name);
199     break;
200   case MachO::N_FUN:
201     // Functions are scopes in STABS. They have an end marker that
202     // contains the function size.
203     if (Name[0] == '\0') {
204       Size = Value;
205       Value = CurrentFunctionAddress;
206       Name = CurrentFunctionName;
207       break;
208     } else {
209       CurrentFunctionName = Name;
210       CurrentFunctionAddress = Value;
211       return;
212     }
213   case MachO::N_STSYM:
214     break;
215   default:
216     return;
217   }
218 
219   auto ObjectSymIt = CurrentObjectAddresses.find(Name);
220   if (ObjectSymIt == CurrentObjectAddresses.end())
221     return Warning("could not find object file symbol for symbol " +
222                    Twine(Name));
223   if (!CurrentDebugMapObject->addSymbol(Name, ObjectSymIt->getValue(), Value,
224                                         Size))
225     return Warning(Twine("failed to insert symbol '") + Name +
226                    "' in the debug map.");
227 }
228 
229 /// Load the current object file symbols into CurrentObjectAddresses.
230 void MachODebugMapParser::loadCurrentObjectFileSymbols(
231     const object::MachOObjectFile &Obj) {
232   CurrentObjectAddresses.clear();
233 
234   for (auto Sym : Obj.symbols()) {
235     uint64_t Addr = Sym.getValue();
236     ErrorOr<StringRef> Name = Sym.getName();
237     if (!Name)
238       continue;
239     CurrentObjectAddresses[*Name] = Addr;
240   }
241 }
242 
243 /// Lookup a symbol address in the main binary symbol table. The
244 /// parser only needs to query common symbols, thus not every symbol's
245 /// address is available through this function.
246 uint64_t MachODebugMapParser::getMainBinarySymbolAddress(StringRef Name) {
247   auto Sym = MainBinarySymbolAddresses.find(Name);
248   if (Sym == MainBinarySymbolAddresses.end())
249     return 0;
250   return Sym->second;
251 }
252 
253 /// Load the interesting main binary symbols' addresses into
254 /// MainBinarySymbolAddresses.
255 void MachODebugMapParser::loadMainBinarySymbols(
256     const MachOObjectFile &MainBinary) {
257   section_iterator Section = MainBinary.section_end();
258   MainBinarySymbolAddresses.clear();
259   for (const auto &Sym : MainBinary.symbols()) {
260     SymbolRef::Type Type = Sym.getType();
261     // Skip undefined and STAB entries.
262     if ((Type & SymbolRef::ST_Debug) || (Type & SymbolRef::ST_Unknown))
263       continue;
264     // The only symbols of interest are the global variables. These
265     // are the only ones that need to be queried because the address
266     // of common data won't be described in the debug map. All other
267     // addresses should be fetched for the debug map.
268     if (!(Sym.getFlags() & SymbolRef::SF_Global))
269       continue;
270     ErrorOr<section_iterator> SectionOrErr = Sym.getSection();
271     if (!SectionOrErr)
272       continue;
273     Section = *SectionOrErr;
274     if (Section == MainBinary.section_end() || Section->isText())
275       continue;
276     uint64_t Addr = Sym.getValue();
277     ErrorOr<StringRef> NameOrErr = Sym.getName();
278     if (!NameOrErr)
279       continue;
280     StringRef Name = *NameOrErr;
281     if (Name.size() == 0 || Name[0] == '\0')
282       continue;
283     MainBinarySymbolAddresses[Name] = Addr;
284   }
285 }
286 
287 namespace llvm {
288 namespace dsymutil {
289 llvm::ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
290 parseDebugMap(StringRef InputFile, ArrayRef<std::string> Archs,
291               StringRef PrependPath, bool Verbose, bool InputIsYAML) {
292   if (!InputIsYAML) {
293     MachODebugMapParser Parser(InputFile, Archs, PrependPath, Verbose);
294     return Parser.parse();
295   } else {
296     return DebugMap::parseYAMLDebugMap(InputFile, PrependPath, Verbose);
297   }
298 }
299 }
300 }
301