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