llvm-project

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
  StringRef PrependPath;
130
  Triple BinaryTriple;
131
};
132

133
} // end anonymous namespace
134

135
ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
136
DebugMap::parseYAMLDebugMap(StringRef InputFile, StringRef PrependPath,
137
                            bool Verbose) {
138
  auto ErrOrFile = MemoryBuffer::getFileOrSTDIN(InputFile);
139
  if (auto Err = ErrOrFile.getError())
140
    return Err;
141

142
  YAMLContext Ctxt;
143

144
  Ctxt.PrependPath = PrependPath;
145

146
  std::unique_ptr<DebugMap> Res;
147
  yaml::Input yin((*ErrOrFile)->getBuffer(), &Ctxt);
148
  yin >> Res;
149

150
  if (auto EC = yin.error())
151
    return EC;
152
  std::vector<std::unique_ptr<DebugMap>> Result;
153
  Result.push_back(std::move(Res));
154
  return std::move(Result);
155
}
156

157
} // end namespace dsymutil
158

159
namespace yaml {
160

161
// Normalize/Denormalize between YAML and a DebugMapObject.
162
struct MappingTraits<dsymutil::DebugMapObject>::YamlDMO {
163
  YamlDMO(IO &io) { Timestamp = 0; }
164
  YamlDMO(IO &io, dsymutil::DebugMapObject &Obj);
165
  dsymutil::DebugMapObject denormalize(IO &IO);
166

167
  std::string Filename;
168
  int64_t Timestamp;
169
  std::vector<dsymutil::DebugMapObject::YAMLSymbolMapping> Entries;
170
};
171

172
void MappingTraits<std::pair<std::string, SymbolMapping>>::mapping(
173
    IO &io, std::pair<std::string, SymbolMapping> &s) {
174
  io.mapRequired("sym", s.first);
175
  io.mapOptional("objAddr", s.second.ObjectAddress);
176
  io.mapRequired("binAddr", s.second.BinaryAddress);
177
  io.mapOptional("size", s.second.Size);
178
}
179

180
void MappingTraits<dsymutil::DebugMapObject>::mapping(
181
    IO &io, dsymutil::DebugMapObject &DMO) {
182
  MappingNormalization<YamlDMO, dsymutil::DebugMapObject> Norm(io, DMO);
183
  io.mapRequired("filename", Norm->Filename);
184
  io.mapOptional("timestamp", Norm->Timestamp);
185
  io.mapRequired("symbols", Norm->Entries);
186
}
187

188
void ScalarTraits<Triple>::output(const Triple &val, void *, raw_ostream &out) {
189
  out << val.str();
190
}
191

192
StringRef ScalarTraits<Triple>::input(StringRef scalar, void *, Triple &value) {
193
  value = Triple(scalar);
194
  return StringRef();
195
}
196

197
size_t
198
SequenceTraits<std::vector<std::unique_ptr<dsymutil::DebugMapObject>>>::size(
199
    IO &io, std::vector<std::unique_ptr<dsymutil::DebugMapObject>> &seq) {
200
  return seq.size();
201
}
202

203
dsymutil::DebugMapObject &
204
SequenceTraits<std::vector<std::unique_ptr<dsymutil::DebugMapObject>>>::element(
205
    IO &, std::vector<std::unique_ptr<dsymutil::DebugMapObject>> &seq,
206
    size_t index) {
207
  if (index >= seq.size()) {
208
    seq.resize(index + 1);
209
    seq[index].reset(new dsymutil::DebugMapObject);
210
  }
211
  return *seq[index];
212
}
213

214
void MappingTraits<dsymutil::DebugMap>::mapping(IO &io,
215
                                                dsymutil::DebugMap &DM) {
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

223
void MappingTraits<std::unique_ptr<dsymutil::DebugMap>>::mapping(
224
    IO &io, std::unique_ptr<dsymutil::DebugMap> &DM) {
225
  if (!DM)
226
    DM.reset(new DebugMap());
227
  io.mapRequired("triple", DM->BinaryTriple);
228
  io.mapOptional("binary-path", DM->BinaryPath);
229
  if (void *Ctxt = io.getContext())
230
    reinterpret_cast<YAMLContext *>(Ctxt)->BinaryTriple = DM->BinaryTriple;
231
  io.mapOptional("objects", DM->Objects);
232
}
233

234
MappingTraits<dsymutil::DebugMapObject>::YamlDMO::YamlDMO(
235
    IO &io, dsymutil::DebugMapObject &Obj) {
236
  Filename = Obj.Filename;
237
  Timestamp = sys::toTimeT(Obj.getTimestamp());
238
  Entries.reserve(Obj.Symbols.size());
239
  for (auto &Entry : Obj.Symbols)
240
    Entries.push_back(
241
        std::make_pair(std::string(Entry.getKey()), Entry.getValue()));
242
  llvm::sort(Entries, llvm::less_first());
243
}
244

245
dsymutil::DebugMapObject
246
MappingTraits<dsymutil::DebugMapObject>::YamlDMO::denormalize(IO &IO) {
247
  BinaryHolder BinHolder(vfs::getRealFileSystem(), /* Verbose =*/false);
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 = 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