xref: /llvm-project/llvm/tools/dsymutil/DebugMap.cpp (revision 2ccbea1d738332cd92d8d33fdd51dfac3482328e) 
1 //===- tools/dsymutil/DebugMap.cpp - Generic debug map representation -----===//
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 "DebugMap.h"
10 #include "BinaryHolder.h"
11 #include "llvm/ADT/SmallString.h"
12 #include "llvm/ADT/StringMap.h"
13 #include "llvm/ADT/StringRef.h"
14 #include "llvm/BinaryFormat/MachO.h"
15 #include "llvm/Object/ObjectFile.h"
16 #include "llvm/Support/Chrono.h"
17 #include "llvm/Support/Error.h"
18 #include "llvm/Support/Format.h"
19 #include "llvm/Support/MemoryBuffer.h"
20 #include "llvm/Support/Path.h"
21 #include "llvm/Support/WithColor.h"
22 #include "llvm/Support/YAMLTraits.h"
23 #include "llvm/Support/raw_ostream.h"
24 #include "llvm/TargetParser/Triple.h"
25 #include <algorithm>
26 #include <cinttypes>
27 #include <cstdint>
28 #include <memory>
29 #include <optional>
30 #include <string>
31 #include <utility>
32 #include <vector>
33 
34 namespace llvm {
35 
36 namespace dsymutil {
37 
38 using namespace llvm::object;
39 
40 DebugMapObject::DebugMapObject(StringRef ObjectFilename,
41                                sys::TimePoint<std::chrono::seconds> Timestamp,
42                                uint8_t Type)
43     : Filename(std::string(ObjectFilename)), Timestamp(Timestamp), Type(Type) {}
44 
45 bool DebugMapObject::addSymbol(StringRef Name,
46                                std::optional<uint64_t> ObjectAddress,
47                                uint64_t LinkedAddress, uint32_t Size) {
48   if (Symbols.count(Name)) {
49     // Symbol was previously added.
50     return true;
51   }
52 
53   auto InsertResult = Symbols.insert(
54       std::make_pair(Name, SymbolMapping(ObjectAddress, LinkedAddress, Size)));
55 
56   if (ObjectAddress && InsertResult.second)
57     AddressToMapping[*ObjectAddress] = &*InsertResult.first;
58   return InsertResult.second;
59 }
60 
61 void DebugMapObject::setRelocationMap(dsymutil::RelocationMap &RM) {
62   RelocMap.emplace(RM);
63 }
64 
65 void DebugMapObject::setInstallName(StringRef IN) { InstallName.emplace(IN); }
66 
67 void DebugMapObject::print(raw_ostream &OS) const {
68   OS << getObjectFilename() << ":\n";
69   // Sort the symbols in alphabetical order, like llvm-nm (and to get
70   // deterministic output for testing).
71   using Entry = std::pair<StringRef, SymbolMapping>;
72   std::vector<Entry> Entries;
73   Entries.reserve(Symbols.getNumItems());
74   for (const auto &Sym : Symbols)
75     Entries.push_back(std::make_pair(Sym.getKey(), Sym.getValue()));
76   llvm::sort(Entries, llvm::less_first());
77   for (const auto &Sym : Entries) {
78     if (Sym.second.ObjectAddress)
79       OS << format("\t%016" PRIx64, uint64_t(*Sym.second.ObjectAddress));
80     else
81       OS << "\t????????????????";
82     OS << format(" => %016" PRIx64 "+0x%x\t%s\n",
83                  uint64_t(Sym.second.BinaryAddress), uint32_t(Sym.second.Size),
84                  Sym.first.data());
85   }
86   OS << '\n';
87 }
88 
89 #ifndef NDEBUG
90 void DebugMapObject::dump() const { print(errs()); }
91 #endif
92 
93 DebugMapObject &
94 DebugMap::addDebugMapObject(StringRef ObjectFilePath,
95                             sys::TimePoint<std::chrono::seconds> Timestamp,
96                             uint8_t Type) {
97   Objects.emplace_back(new DebugMapObject(ObjectFilePath, Timestamp, Type));
98   return *Objects.back();
99 }
100 
101 const DebugMapObject::DebugMapEntry *
102 DebugMapObject::lookupSymbol(StringRef SymbolName) const {
103   StringMap<SymbolMapping>::const_iterator Sym = Symbols.find(SymbolName);
104   if (Sym == Symbols.end())
105     return nullptr;
106   return &*Sym;
107 }
108 
109 const DebugMapObject::DebugMapEntry *
110 DebugMapObject::lookupObjectAddress(uint64_t Address) const {
111   auto Mapping = AddressToMapping.find(Address);
112   if (Mapping == AddressToMapping.end())
113     return nullptr;
114   return Mapping->getSecond();
115 }
116 
117 void DebugMap::print(raw_ostream &OS) const {
118   yaml::Output yout(OS, /* Ctxt = */ nullptr, /* WrapColumn = */ 0);
119   yout << const_cast<DebugMap &>(*this);
120 }
121 
122 #ifndef NDEBUG
123 void DebugMap::dump() const { print(errs()); }
124 #endif
125 
126 namespace {
127 
128 struct YAMLContext {
129   YAMLContext(BinaryHolder &BinHolder, StringRef PrependPath)
130       : BinHolder(BinHolder), PrependPath(PrependPath) {}
131   BinaryHolder &BinHolder;
132   StringRef PrependPath;
133   Triple BinaryTriple;
134 };
135 
136 } // end anonymous namespace
137 
138 ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
139 DebugMap::parseYAMLDebugMap(BinaryHolder &BinHolder, StringRef InputFile,
140                             StringRef PrependPath, bool Verbose) {
141   auto ErrOrFile = MemoryBuffer::getFileOrSTDIN(InputFile);
142   if (auto Err = ErrOrFile.getError())
143     return Err;
144 
145   YAMLContext Ctxt(BinHolder, PrependPath);
146 
147   std::unique_ptr<DebugMap> Res;
148   yaml::Input yin((*ErrOrFile)->getBuffer(), &Ctxt);
149   yin >> Res;
150 
151   if (auto EC = yin.error())
152     return EC;
153   std::vector<std::unique_ptr<DebugMap>> Result;
154   Result.push_back(std::move(Res));
155   return std::move(Result);
156 }
157 
158 } // end namespace dsymutil
159 
160 namespace yaml {
161 
162 // Normalize/Denormalize between YAML and a DebugMapObject.
163 struct MappingTraits<dsymutil::DebugMapObject>::YamlDMO {
164   YamlDMO(IO &io) { Timestamp = 0; }
165   YamlDMO(IO &io, dsymutil::DebugMapObject &Obj);
166   dsymutil::DebugMapObject denormalize(IO &IO);
167 
168   std::string Filename;
169   int64_t Timestamp;
170   std::vector<dsymutil::DebugMapObject::YAMLSymbolMapping> Entries;
171 };
172 
173 void MappingTraits<std::pair<std::string, SymbolMapping>>::mapping(
174     IO &io, std::pair<std::string, SymbolMapping> &s) {
175   io.mapRequired("sym", s.first);
176   io.mapOptional("objAddr", s.second.ObjectAddress);
177   io.mapRequired("binAddr", s.second.BinaryAddress);
178   io.mapOptional("size", s.second.Size);
179 }
180 
181 void MappingTraits<dsymutil::DebugMapObject>::mapping(
182     IO &io, dsymutil::DebugMapObject &DMO) {
183   MappingNormalization<YamlDMO, dsymutil::DebugMapObject> Norm(io, DMO);
184   io.mapRequired("filename", Norm->Filename);
185   io.mapOptional("timestamp", Norm->Timestamp);
186   io.mapRequired("symbols", Norm->Entries);
187 }
188 
189 void ScalarTraits<Triple>::output(const Triple &val, void *, raw_ostream &out) {
190   out << val.str();
191 }
192 
193 StringRef ScalarTraits<Triple>::input(StringRef scalar, void *, Triple &value) {
194   value = Triple(scalar);
195   return StringRef();
196 }
197 
198 size_t
199 SequenceTraits<std::vector<std::unique_ptr<dsymutil::DebugMapObject>>>::size(
200     IO &io, std::vector<std::unique_ptr<dsymutil::DebugMapObject>> &seq) {
201   return seq.size();
202 }
203 
204 dsymutil::DebugMapObject &
205 SequenceTraits<std::vector<std::unique_ptr<dsymutil::DebugMapObject>>>::element(
206     IO &, std::vector<std::unique_ptr<dsymutil::DebugMapObject>> &seq,
207     size_t index) {
208   if (index >= seq.size()) {
209     seq.resize(index + 1);
210     seq[index].reset(new dsymutil::DebugMapObject);
211   }
212   return *seq[index];
213 }
214 
215 void MappingTraits<dsymutil::DebugMap>::mapping(IO &io,
216                                                 dsymutil::DebugMap &DM) {
217   io.mapRequired("triple", DM.BinaryTriple);
218   io.mapOptional("binary-path", DM.BinaryPath);
219   if (void *Ctxt = io.getContext())
220     reinterpret_cast<YAMLContext *>(Ctxt)->BinaryTriple = DM.BinaryTriple;
221   io.mapOptional("objects", DM.Objects);
222 }
223 
224 void MappingTraits<std::unique_ptr<dsymutil::DebugMap>>::mapping(
225     IO &io, std::unique_ptr<dsymutil::DebugMap> &DM) {
226   if (!DM)
227     DM.reset(new DebugMap());
228   io.mapRequired("triple", DM->BinaryTriple);
229   io.mapOptional("binary-path", DM->BinaryPath);
230   if (void *Ctxt = io.getContext())
231     reinterpret_cast<YAMLContext *>(Ctxt)->BinaryTriple = DM->BinaryTriple;
232   io.mapOptional("objects", DM->Objects);
233 }
234 
235 MappingTraits<dsymutil::DebugMapObject>::YamlDMO::YamlDMO(
236     IO &io, dsymutil::DebugMapObject &Obj) {
237   Filename = Obj.Filename;
238   Timestamp = sys::toTimeT(Obj.getTimestamp());
239   Entries.reserve(Obj.Symbols.size());
240   for (auto &Entry : Obj.Symbols)
241     Entries.push_back(
242         std::make_pair(std::string(Entry.getKey()), Entry.getValue()));
243   llvm::sort(Entries, llvm::less_first());
244 }
245 
246 dsymutil::DebugMapObject
247 MappingTraits<dsymutil::DebugMapObject>::YamlDMO::denormalize(IO &IO) {
248   const auto &Ctxt = *reinterpret_cast<YAMLContext *>(IO.getContext());
249   SmallString<80> Path(Ctxt.PrependPath);
250   StringMap<uint64_t> SymbolAddresses;
251 
252   sys::path::append(Path, Filename);
253 
254   auto ObjectEntry = Ctxt.BinHolder.getObjectEntry(Path);
255   if (!ObjectEntry) {
256     auto Err = ObjectEntry.takeError();
257     WithColor::warning() << "Unable to open " << Path << " "
258                          << toString(std::move(Err)) << '\n';
259   } else {
260     auto Object = ObjectEntry->getObject(Ctxt.BinaryTriple);
261     if (!Object) {
262       auto Err = Object.takeError();
263       WithColor::warning() << "Unable to open " << Path << " "
264                            << toString(std::move(Err)) << '\n';
265     } else {
266       for (const auto &Sym : Object->symbols()) {
267         Expected<uint64_t> AddressOrErr = Sym.getValue();
268         if (!AddressOrErr) {
269           // TODO: Actually report errors helpfully.
270           consumeError(AddressOrErr.takeError());
271           continue;
272         }
273         Expected<StringRef> Name = Sym.getName();
274         Expected<uint32_t> FlagsOrErr = Sym.getFlags();
275         if (!Name || !FlagsOrErr ||
276             (*FlagsOrErr & (SymbolRef::SF_Absolute | SymbolRef::SF_Common))) {
277           // TODO: Actually report errors helpfully.
278           if (!FlagsOrErr)
279             consumeError(FlagsOrErr.takeError());
280           if (!Name)
281             consumeError(Name.takeError());
282           continue;
283         }
284         SymbolAddresses[*Name] = *AddressOrErr;
285       }
286     }
287   }
288 
289   uint8_t Type = MachO::N_OSO;
290   if (Path.ends_with(".dylib")) {
291     // FIXME: find a more resilient way
292     Type = MachO::N_LIB;
293   }
294   dsymutil::DebugMapObject Res(Path, sys::toTimePoint(Timestamp), Type);
295 
296   for (auto &Entry : Entries) {
297     auto &Mapping = Entry.second;
298     std::optional<uint64_t> ObjAddress;
299     if (Mapping.ObjectAddress)
300       ObjAddress = *Mapping.ObjectAddress;
301     auto AddressIt = SymbolAddresses.find(Entry.first);
302     if (AddressIt != SymbolAddresses.end())
303       ObjAddress = AddressIt->getValue();
304     Res.addSymbol(Entry.first, ObjAddress, Mapping.BinaryAddress, Mapping.Size);
305   }
306   return Res;
307 }
308 
309 } // end namespace yaml
310 } // end namespace llvm
311