1 //=== tools/dsymutil/DebugMap.h - Generic debug map representation -*- C++ -*-//
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 /// \file
11 ///
12 /// This file contains the class declaration of the DebugMap
13 /// entity. A DebugMap lists all the object files linked together to
14 /// produce an executable along with the linked address of all the
15 /// atoms used in these object files.
16 /// The DebugMap is an input to the DwarfLinker class that will
17 /// extract the Dwarf debug information from the referenced object
18 /// files and link their usefull debug info together.
19 ///
20 //===----------------------------------------------------------------------===//
21 #ifndef LLVM_TOOLS_DSYMUTIL_DEBUGMAP_H
22 #define LLVM_TOOLS_DSYMUTIL_DEBUGMAP_H
23
24 #include "llvm/ADT/DenseMap.h"
25 #include "llvm/ADT/StringMap.h"
26 #include "llvm/ADT/Triple.h"
27 #include "llvm/ADT/iterator_range.h"
28 #include "llvm/Object/ObjectFile.h"
29 #include "llvm/Support/ErrorOr.h"
30 #include "llvm/Support/Format.h"
31 #include "llvm/Support/Path.h"
32 #include "llvm/Support/TimeValue.h"
33 #include "llvm/Support/YAMLTraits.h"
34 #include <vector>
35
36 namespace llvm {
37 class raw_ostream;
38
39 namespace dsymutil {
40 class DebugMapObject;
41
42 /// \brief The DebugMap object stores the list of object files to
43 /// query for debug information along with the mapping between the
44 /// symbols' addresses in the object file to their linked address in
45 /// the linked binary.
46 ///
47 /// A DebugMap producer could look like this:
48 /// DebugMap *DM = new DebugMap();
49 /// for (const auto &Obj: LinkedObjects) {
50 /// DebugMapObject &DMO = DM->addDebugMapObject(Obj.getPath());
51 /// for (const auto &Sym: Obj.getLinkedSymbols())
52 /// DMO.addSymbol(Sym.getName(), Sym.getObjectFileAddress(),
53 /// Sym.getBinaryAddress());
54 /// }
55 ///
56 /// A DebugMap consumer can then use the map to link the debug
57 /// information. For example something along the lines of:
58 /// for (const auto &DMO: DM->objects()) {
59 /// auto Obj = createBinary(DMO.getObjectFilename());
60 /// for (auto &DIE: Obj.getDwarfDIEs()) {
61 /// if (SymbolMapping *Sym = DMO.lookup(DIE.getName()))
62 /// DIE.relocate(Sym->ObjectAddress, Sym->BinaryAddress);
63 /// else
64 /// DIE.discardSubtree();
65 /// }
66 /// }
67 class DebugMap {
68 Triple BinaryTriple;
69 std::string BinaryPath;
70 typedef std::vector<std::unique_ptr<DebugMapObject>> ObjectContainer;
71 ObjectContainer Objects;
72
73 /// For YAML IO support.
74 ///@{
75 friend yaml::MappingTraits<std::unique_ptr<DebugMap>>;
76 friend yaml::MappingTraits<DebugMap>;
77 DebugMap() = default;
78 ///@}
79 public:
DebugMap(const Triple & BinaryTriple,StringRef BinaryPath)80 DebugMap(const Triple &BinaryTriple, StringRef BinaryPath)
81 : BinaryTriple(BinaryTriple), BinaryPath(BinaryPath) {}
82
83 typedef ObjectContainer::const_iterator const_iterator;
84
objects()85 iterator_range<const_iterator> objects() const {
86 return make_range(begin(), end());
87 }
88
begin()89 const_iterator begin() const { return Objects.begin(); }
90
end()91 const_iterator end() const { return Objects.end(); }
92
93 /// This function adds an DebugMapObject to the list owned by this
94 /// debug map.
95 DebugMapObject &addDebugMapObject(StringRef ObjectFilePath,
96 sys::TimeValue Timestamp);
97
getTriple()98 const Triple &getTriple() const { return BinaryTriple; }
99
getBinaryPath()100 StringRef getBinaryPath() const { return BinaryPath; }
101
102 void print(raw_ostream &OS) const;
103
104 #ifndef NDEBUG
105 void dump() const;
106 #endif
107
108 /// Read a debug map for \a InputFile.
109 static ErrorOr<std::vector<std::unique_ptr<DebugMap>>>
110 parseYAMLDebugMap(StringRef InputFile, StringRef PrependPath, bool Verbose);
111 };
112
113 /// \brief The DebugMapObject represents one object file described by
114 /// the DebugMap. It contains a list of mappings between addresses in
115 /// the object file and in the linked binary for all the linked atoms
116 /// in this object file.
117 class DebugMapObject {
118 public:
119 struct SymbolMapping {
120 Optional<yaml::Hex64> ObjectAddress;
121 yaml::Hex64 BinaryAddress;
122 yaml::Hex32 Size;
SymbolMappingSymbolMapping123 SymbolMapping(Optional<uint64_t> ObjectAddr, uint64_t BinaryAddress,
124 uint32_t Size)
125 : BinaryAddress(BinaryAddress), Size(Size) {
126 if (ObjectAddr)
127 ObjectAddress = *ObjectAddr;
128 }
129 /// For YAML IO support
130 SymbolMapping() = default;
131 };
132
133 typedef StringMapEntry<SymbolMapping> DebugMapEntry;
134
135 /// \brief Adds a symbol mapping to this DebugMapObject.
136 /// \returns false if the symbol was already registered. The request
137 /// is discarded in this case.
138 bool addSymbol(llvm::StringRef SymName, Optional<uint64_t> ObjectAddress,
139 uint64_t LinkedAddress, uint32_t Size);
140
141 /// \brief Lookup a symbol mapping.
142 /// \returns null if the symbol isn't found.
143 const DebugMapEntry *lookupSymbol(StringRef SymbolName) const;
144
145 /// \brief Lookup an objectfile address.
146 /// \returns null if the address isn't found.
147 const DebugMapEntry *lookupObjectAddress(uint64_t Address) const;
148
getObjectFilename()149 llvm::StringRef getObjectFilename() const { return Filename; }
150
getTimestamp()151 sys::TimeValue getTimestamp() const { return Timestamp; }
152
symbols()153 iterator_range<StringMap<SymbolMapping>::const_iterator> symbols() const {
154 return make_range(Symbols.begin(), Symbols.end());
155 }
156
157 void print(raw_ostream &OS) const;
158 #ifndef NDEBUG
159 void dump() const;
160 #endif
161 private:
162 friend class DebugMap;
163 /// DebugMapObjects can only be constructed by the owning DebugMap.
164 DebugMapObject(StringRef ObjectFilename, sys::TimeValue Timestamp);
165
166 std::string Filename;
167 sys::TimeValue Timestamp;
168 StringMap<SymbolMapping> Symbols;
169 DenseMap<uint64_t, DebugMapEntry *> AddressToMapping;
170
171 /// For YAMLIO support.
172 ///@{
173 typedef std::pair<std::string, SymbolMapping> YAMLSymbolMapping;
174 friend yaml::MappingTraits<dsymutil::DebugMapObject>;
175 friend yaml::SequenceTraits<std::vector<std::unique_ptr<DebugMapObject>>>;
176 friend yaml::SequenceTraits<std::vector<YAMLSymbolMapping>>;
177 DebugMapObject() = default;
178
179 public:
180 DebugMapObject &operator=(DebugMapObject RHS) {
181 std::swap(Filename, RHS.Filename);
182 std::swap(Timestamp, RHS.Timestamp);
183 std::swap(Symbols, RHS.Symbols);
184 std::swap(AddressToMapping, RHS.AddressToMapping);
185 return *this;
186 }
DebugMapObject(DebugMapObject && RHS)187 DebugMapObject(DebugMapObject &&RHS) {
188 Filename = std::move(RHS.Filename);
189 Timestamp = std::move(RHS.Timestamp);
190 Symbols = std::move(RHS.Symbols);
191 AddressToMapping = std::move(RHS.AddressToMapping);
192 }
193 ///@}
194 };
195 }
196 }
197
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::dsymutil::DebugMapObject::YAMLSymbolMapping)198 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::dsymutil::DebugMapObject::YAMLSymbolMapping)
199
200 namespace llvm {
201 namespace yaml {
202
203 using namespace llvm::dsymutil;
204
205 template <>
206 struct MappingTraits<std::pair<std::string, DebugMapObject::SymbolMapping>> {
207 static void mapping(IO &io,
208 std::pair<std::string, DebugMapObject::SymbolMapping> &s);
209 static const bool flow = true;
210 };
211
212 template <> struct MappingTraits<dsymutil::DebugMapObject> {
213 struct YamlDMO;
214 static void mapping(IO &io, dsymutil::DebugMapObject &DMO);
215 };
216
217 template <> struct ScalarTraits<Triple> {
218 static void output(const Triple &val, void *, llvm::raw_ostream &out);
219 static StringRef input(StringRef scalar, void *, Triple &value);
220 static bool mustQuote(StringRef) { return true; }
221 };
222
223 template <>
224 struct SequenceTraits<std::vector<std::unique_ptr<dsymutil::DebugMapObject>>> {
225 static size_t
226 size(IO &io, std::vector<std::unique_ptr<dsymutil::DebugMapObject>> &seq);
227 static dsymutil::DebugMapObject &
228 element(IO &, std::vector<std::unique_ptr<dsymutil::DebugMapObject>> &seq,
229 size_t index);
230 };
231
232 template <> struct MappingTraits<dsymutil::DebugMap> {
233 static void mapping(IO &io, dsymutil::DebugMap &DM);
234 };
235
236 template <> struct MappingTraits<std::unique_ptr<dsymutil::DebugMap>> {
237 static void mapping(IO &io, std::unique_ptr<dsymutil::DebugMap> &DM);
238 };
239 }
240 }
241
242 #endif // LLVM_TOOLS_DSYMUTIL_DEBUGMAP_H
243