1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | |
13 | |
14 | #include "llvm-cxxdump.h" |
15 | #include "Error.h" |
16 | #include "llvm/ADT/ArrayRef.h" |
17 | #include "llvm/Object/Archive.h" |
18 | #include "llvm/Object/ObjectFile.h" |
19 | #include "llvm/Support/Debug.h" |
20 | #include "llvm/Support/Endian.h" |
21 | #include "llvm/Support/FileSystem.h" |
22 | #include "llvm/Support/ManagedStatic.h" |
23 | #include "llvm/Support/PrettyStackTrace.h" |
24 | #include "llvm/Support/Signals.h" |
25 | #include "llvm/Support/TargetRegistry.h" |
26 | #include "llvm/Support/TargetSelect.h" |
27 | #include "llvm/Support/raw_ostream.h" |
28 | #include <map> |
29 | #include <string> |
30 | #include <system_error> |
31 | |
32 | using namespace llvm; |
33 | using namespace llvm::object; |
34 | using namespace llvm::support; |
35 | |
36 | namespace opts { |
37 | cl::list<std::string> InputFilenames(cl::Positional, |
38 | cl::desc("<input object files>"), |
39 | cl::ZeroOrMore); |
40 | } |
41 | |
42 | static int ReturnValue = EXIT_SUCCESS0; |
43 | |
44 | namespace llvm { |
45 | |
46 | static bool error(std::error_code EC) { |
47 | if (!EC) |
48 | return false; |
49 | |
50 | ReturnValue = EXIT_FAILURE1; |
51 | outs() << "\nError reading file: " << EC.message() << ".\n"; |
52 | outs().flush(); |
53 | return true; |
54 | } |
55 | |
56 | } |
57 | |
58 | static void reportError(StringRef Input, StringRef Message) { |
59 | if (Input == "-") |
60 | Input = "<stdin>"; |
61 | |
62 | errs() << Input << ": " << Message << "\n"; |
63 | errs().flush(); |
64 | ReturnValue = EXIT_FAILURE1; |
65 | } |
66 | |
67 | static void reportError(StringRef Input, std::error_code EC) { |
68 | reportError(Input, EC.message()); |
69 | } |
70 | |
71 | static SmallVectorImpl<SectionRef> &getRelocSections(const ObjectFile *Obj, |
72 | const SectionRef &Sec) { |
73 | static bool MappingDone = false; |
74 | static std::map<SectionRef, SmallVector<SectionRef, 1>> SectionRelocMap; |
75 | if (!MappingDone) { |
76 | for (const SectionRef &Section : Obj->sections()) { |
77 | section_iterator Sec2 = Section.getRelocatedSection(); |
78 | if (Sec2 != Obj->section_end()) |
79 | SectionRelocMap[*Sec2].push_back(Section); |
80 | } |
81 | MappingDone = true; |
82 | } |
83 | return SectionRelocMap[Sec]; |
84 | } |
85 | |
86 | static bool collectRelocatedSymbols(const ObjectFile *Obj, |
87 | const SectionRef &Sec, uint64_t SecAddress, |
88 | uint64_t SymAddress, uint64_t SymSize, |
89 | StringRef *I, StringRef *E) { |
90 | uint64_t SymOffset = SymAddress - SecAddress; |
91 | uint64_t SymEnd = SymOffset + SymSize; |
92 | for (const SectionRef &SR : getRelocSections(Obj, Sec)) { |
93 | for (const object::RelocationRef &Reloc : SR.relocations()) { |
94 | if (I == E) |
95 | break; |
96 | const object::symbol_iterator RelocSymI = Reloc.getSymbol(); |
97 | if (RelocSymI == Obj->symbol_end()) |
98 | continue; |
99 | StringRef RelocSymName; |
100 | if (error(RelocSymI->getName(RelocSymName))) |
101 | return true; |
102 | uint64_t Offset; |
103 | if (error(Reloc.getOffset(Offset))) |
104 | return true; |
105 | if (Offset >= SymOffset && Offset < SymEnd) { |
106 | *I = RelocSymName; |
107 | ++I; |
108 | } |
109 | } |
110 | } |
111 | return false; |
112 | } |
113 | |
114 | static bool collectRelocationOffsets( |
115 | const ObjectFile *Obj, const SectionRef &Sec, uint64_t SecAddress, |
116 | uint64_t SymAddress, uint64_t SymSize, StringRef SymName, |
117 | std::map<std::pair<StringRef, uint64_t>, StringRef> &Collection) { |
118 | uint64_t SymOffset = SymAddress - SecAddress; |
119 | uint64_t SymEnd = SymOffset + SymSize; |
120 | for (const SectionRef &SR : getRelocSections(Obj, Sec)) { |
121 | for (const object::RelocationRef &Reloc : SR.relocations()) { |
122 | const object::symbol_iterator RelocSymI = Reloc.getSymbol(); |
123 | if (RelocSymI == Obj->symbol_end()) |
124 | continue; |
125 | StringRef RelocSymName; |
126 | if (error(RelocSymI->getName(RelocSymName))) |
127 | return true; |
128 | uint64_t Offset; |
129 | if (error(Reloc.getOffset(Offset))) |
130 | return true; |
131 | if (Offset >= SymOffset && Offset < SymEnd) |
132 | Collection[std::make_pair(SymName, Offset - SymOffset)] = RelocSymName; |
133 | } |
134 | } |
135 | return false; |
136 | } |
137 | |
138 | static void dumpCXXData(const ObjectFile *Obj) { |
139 | struct CompleteObjectLocator { |
140 | StringRef Symbols[2]; |
141 | ArrayRef<little32_t> Data; |
142 | }; |
143 | struct ClassHierarchyDescriptor { |
144 | StringRef Symbols[1]; |
145 | ArrayRef<little32_t> Data; |
146 | }; |
147 | struct BaseClassDescriptor { |
148 | StringRef Symbols[2]; |
149 | ArrayRef<little32_t> Data; |
150 | }; |
151 | struct TypeDescriptor { |
152 | StringRef Symbols[1]; |
153 | uint64_t AlwaysZero; |
154 | StringRef MangledName; |
155 | }; |
156 | struct ThrowInfo { |
157 | uint32_t Flags; |
158 | }; |
159 | struct CatchableTypeArray { |
160 | uint32_t NumEntries; |
161 | }; |
162 | struct CatchableType { |
163 | uint32_t Flags; |
164 | uint32_t NonVirtualBaseAdjustmentOffset; |
165 | int32_t VirtualBasePointerOffset; |
166 | uint32_t VirtualBaseAdjustmentOffset; |
167 | uint32_t Size; |
168 | StringRef Symbols[2]; |
169 | }; |
170 | std::map<std::pair<StringRef, uint64_t>, StringRef> VFTableEntries; |
171 | std::map<std::pair<StringRef, uint64_t>, StringRef> TIEntries; |
172 | std::map<std::pair<StringRef, uint64_t>, StringRef> CTAEntries; |
173 | std::map<StringRef, ArrayRef<little32_t>> VBTables; |
174 | std::map<StringRef, CompleteObjectLocator> COLs; |
175 | std::map<StringRef, ClassHierarchyDescriptor> CHDs; |
176 | std::map<std::pair<StringRef, uint64_t>, StringRef> BCAEntries; |
177 | std::map<StringRef, BaseClassDescriptor> BCDs; |
178 | std::map<StringRef, TypeDescriptor> TDs; |
179 | std::map<StringRef, ThrowInfo> TIs; |
180 | std::map<StringRef, CatchableTypeArray> CTAs; |
181 | std::map<StringRef, CatchableType> CTs; |
182 | |
183 | std::map<std::pair<StringRef, uint64_t>, StringRef> VTableSymEntries; |
184 | std::map<std::pair<StringRef, uint64_t>, int64_t> VTableDataEntries; |
185 | std::map<std::pair<StringRef, uint64_t>, StringRef> VTTEntries; |
186 | std::map<StringRef, StringRef> TINames; |
187 | |
188 | uint8_t BytesInAddress = Obj->getBytesInAddress(); |
189 | |
190 | for (const object::SymbolRef &Sym : Obj->symbols()) { |
191 | StringRef SymName; |
192 | if (error(Sym.getName(SymName))) |
193 | return; |
194 | object::section_iterator SecI(Obj->section_begin()); |
195 | if (error(Sym.getSection(SecI))) |
196 | return; |
197 | |
198 | if (SecI == Obj->section_end()) |
199 | continue; |
200 | const SectionRef &Sec = *SecI; |
201 | |
202 | if (Sec.isBSS() || Sec.isVirtual()) |
203 | continue; |
204 | StringRef SecContents; |
205 | if (error(Sec.getContents(SecContents))) |
206 | return; |
207 | uint64_t SymAddress, SymSize; |
208 | if (error(Sym.getAddress(SymAddress)) || error(Sym.getSize(SymSize))) |
209 | return; |
210 | uint64_t SecAddress = Sec.getAddress(); |
211 | uint64_t SecSize = Sec.getSize(); |
212 | uint64_t SymOffset = SymAddress - SecAddress; |
213 | StringRef SymContents = SecContents.substr(SymOffset, SymSize); |
214 | |
215 | |
216 | |
217 | |
218 | if (SymName.startswith("??_7")) { |
219 | |
220 | |
221 | collectRelocationOffsets(Obj, Sec, SecAddress, SecAddress, SecSize, |
222 | SymName, VFTableEntries); |
223 | } |
224 | |
225 | |
226 | else if (SymName.startswith("??_8")) { |
227 | ArrayRef<little32_t> VBTableData( |
228 | reinterpret_cast<const little32_t *>(SymContents.data()), |
229 | SymContents.size() / sizeof(little32_t)); |
230 | VBTables[SymName] = VBTableData; |
231 | } |
232 | |
233 | else if (SymName.startswith("??_R4")) { |
234 | CompleteObjectLocator COL; |
235 | COL.Data = ArrayRef<little32_t>( |
236 | reinterpret_cast<const little32_t *>(SymContents.data()), 3); |
237 | StringRef *I = std::begin(COL.Symbols), *E = std::end(COL.Symbols); |
238 | if (collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, |
239 | E)) |
240 | return; |
241 | COLs[SymName] = COL; |
242 | } |
243 | |
244 | else if (SymName.startswith("??_R3")) { |
245 | ClassHierarchyDescriptor CHD; |
246 | CHD.Data = ArrayRef<little32_t>( |
247 | reinterpret_cast<const little32_t *>(SymContents.data()), 3); |
248 | StringRef *I = std::begin(CHD.Symbols), *E = std::end(CHD.Symbols); |
249 | if (collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, |
250 | E)) |
251 | return; |
252 | CHDs[SymName] = CHD; |
253 | } |
254 | |
255 | else if (SymName.startswith("??_R2")) { |
256 | |
257 | |
258 | collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize, |
259 | SymName, BCAEntries); |
260 | } |
261 | |
262 | else if (SymName.startswith("??_R1")) { |
263 | BaseClassDescriptor BCD; |
264 | BCD.Data = ArrayRef<little32_t>( |
265 | reinterpret_cast<const little32_t *>(SymContents.data()) + 1, 5); |
266 | StringRef *I = std::begin(BCD.Symbols), *E = std::end(BCD.Symbols); |
267 | if (collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, |
268 | E)) |
269 | return; |
270 | BCDs[SymName] = BCD; |
271 | } |
272 | |
273 | else if (SymName.startswith("??_R0")) { |
274 | const char *DataPtr = SymContents.drop_front(BytesInAddress).data(); |
275 | TypeDescriptor TD; |
276 | if (BytesInAddress == 8) |
277 | TD.AlwaysZero = *reinterpret_cast<const little64_t *>(DataPtr); |
278 | else |
279 | TD.AlwaysZero = *reinterpret_cast<const little32_t *>(DataPtr); |
280 | TD.MangledName = SymContents.drop_front(BytesInAddress * 2); |
281 | StringRef *I = std::begin(TD.Symbols), *E = std::end(TD.Symbols); |
282 | if (collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, |
283 | E)) |
284 | return; |
285 | TDs[SymName] = TD; |
286 | } |
287 | |
288 | else if (SymName.startswith("_TI") || SymName.startswith("__TI")) { |
289 | ThrowInfo TI; |
290 | TI.Flags = *reinterpret_cast<const little32_t *>(SymContents.data()); |
291 | collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize, |
292 | SymName, TIEntries); |
293 | TIs[SymName] = TI; |
294 | } |
295 | |
296 | else if (SymName.startswith("_CTA") || SymName.startswith("__CTA")) { |
297 | CatchableTypeArray CTA; |
298 | CTA.NumEntries = |
299 | *reinterpret_cast<const little32_t *>(SymContents.data()); |
300 | collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize, |
301 | SymName, CTAEntries); |
302 | CTAs[SymName] = CTA; |
303 | } |
304 | |
305 | else if (SymName.startswith("_CT") || SymName.startswith("__CT")) { |
306 | const little32_t *DataPtr = |
307 | reinterpret_cast<const little32_t *>(SymContents.data()); |
308 | CatchableType CT; |
309 | CT.Flags = DataPtr[0]; |
310 | CT.NonVirtualBaseAdjustmentOffset = DataPtr[2]; |
311 | CT.VirtualBasePointerOffset = DataPtr[3]; |
312 | CT.VirtualBaseAdjustmentOffset = DataPtr[4]; |
313 | CT.Size = DataPtr[5]; |
314 | StringRef *I = std::begin(CT.Symbols), *E = std::end(CT.Symbols); |
315 | if (collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, |
316 | E)) |
317 | return; |
318 | CTs[SymName] = CT; |
319 | } |
320 | |
321 | else if (SymName.startswith("_ZTT") || SymName.startswith("__ZTT")) { |
322 | collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize, |
323 | SymName, VTTEntries); |
324 | } |
325 | |
326 | else if (SymName.startswith("_ZTS") || SymName.startswith("__ZTS")) { |
327 | TINames[SymName] = SymContents.slice(0, SymContents.find('\0')); |
328 | } |
329 | |
330 | else if (SymName.startswith("_ZTV") || SymName.startswith("__ZTV")) { |
331 | collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize, |
332 | SymName, VTableSymEntries); |
333 | for (uint64_t SymOffI = 0; SymOffI < SymSize; SymOffI += BytesInAddress) { |
334 | auto Key = std::make_pair(SymName, SymOffI); |
335 | if (VTableSymEntries.count(Key)) |
336 | continue; |
337 | const char *DataPtr = |
338 | SymContents.substr(SymOffI, BytesInAddress).data(); |
339 | int64_t VData; |
340 | if (BytesInAddress == 8) |
341 | VData = *reinterpret_cast<const little64_t *>(DataPtr); |
342 | else |
343 | VData = *reinterpret_cast<const little32_t *>(DataPtr); |
344 | VTableDataEntries[Key] = VData; |
345 | } |
346 | } |
347 | |
348 | else if (SymName.startswith("_ZTI") || SymName.startswith("__ZTI")) { |
349 | |
350 | } |
351 | } |
352 | for (const auto &VFTableEntry : VFTableEntries) { |
353 | StringRef VFTableName = VFTableEntry.first.first; |
354 | uint64_t Offset = VFTableEntry.first.second; |
355 | StringRef SymName = VFTableEntry.second; |
356 | outs() << VFTableName << '[' << Offset << "]: " << SymName << '\n'; |
357 | } |
358 | for (const std::pair<StringRef, ArrayRef<little32_t>> &VBTable : VBTables) { |
359 | StringRef VBTableName = VBTable.first; |
360 | uint32_t Idx = 0; |
361 | for (little32_t Offset : VBTable.second) { |
362 | outs() << VBTableName << '[' << Idx << "]: " << Offset << '\n'; |
363 | Idx += sizeof(Offset); |
364 | } |
365 | } |
366 | for (const std::pair<StringRef, CompleteObjectLocator> &COLPair : COLs) { |
367 | StringRef COLName = COLPair.first; |
368 | const CompleteObjectLocator &COL = COLPair.second; |
369 | outs() << COLName << "[IsImageRelative]: " << COL.Data[0] << '\n'; |
370 | outs() << COLName << "[OffsetToTop]: " << COL.Data[1] << '\n'; |
371 | outs() << COLName << "[VFPtrOffset]: " << COL.Data[2] << '\n'; |
372 | outs() << COLName << "[TypeDescriptor]: " << COL.Symbols[0] << '\n'; |
373 | outs() << COLName << "[ClassHierarchyDescriptor]: " << COL.Symbols[1] |
374 | << '\n'; |
375 | } |
376 | for (const std::pair<StringRef, ClassHierarchyDescriptor> &CHDPair : CHDs) { |
377 | StringRef CHDName = CHDPair.first; |
378 | const ClassHierarchyDescriptor &CHD = CHDPair.second; |
379 | outs() << CHDName << "[AlwaysZero]: " << CHD.Data[0] << '\n'; |
380 | outs() << CHDName << "[Flags]: " << CHD.Data[1] << '\n'; |
381 | outs() << CHDName << "[NumClasses]: " << CHD.Data[2] << '\n'; |
382 | outs() << CHDName << "[BaseClassArray]: " << CHD.Symbols[0] << '\n'; |
383 | } |
384 | for (const std::pair<std::pair<StringRef, uint64_t>, StringRef> &BCAEntry : |
385 | BCAEntries) { |
386 | StringRef BCAName = BCAEntry.first.first; |
387 | uint64_t Offset = BCAEntry.first.second; |
388 | StringRef SymName = BCAEntry.second; |
389 | outs() << BCAName << '[' << Offset << "]: " << SymName << '\n'; |
390 | } |
391 | for (const std::pair<StringRef, BaseClassDescriptor> &BCDPair : BCDs) { |
392 | StringRef BCDName = BCDPair.first; |
393 | const BaseClassDescriptor &BCD = BCDPair.second; |
394 | outs() << BCDName << "[TypeDescriptor]: " << BCD.Symbols[0] << '\n'; |
395 | outs() << BCDName << "[NumBases]: " << BCD.Data[0] << '\n'; |
396 | outs() << BCDName << "[OffsetInVBase]: " << BCD.Data[1] << '\n'; |
397 | outs() << BCDName << "[VBPtrOffset]: " << BCD.Data[2] << '\n'; |
398 | outs() << BCDName << "[OffsetInVBTable]: " << BCD.Data[3] << '\n'; |
399 | outs() << BCDName << "[Flags]: " << BCD.Data[4] << '\n'; |
400 | outs() << BCDName << "[ClassHierarchyDescriptor]: " << BCD.Symbols[1] |
401 | << '\n'; |
402 | } |
403 | for (const std::pair<StringRef, TypeDescriptor> &TDPair : TDs) { |
404 | StringRef TDName = TDPair.first; |
405 | const TypeDescriptor &TD = TDPair.second; |
406 | outs() << TDName << "[VFPtr]: " << TD.Symbols[0] << '\n'; |
407 | outs() << TDName << "[AlwaysZero]: " << TD.AlwaysZero << '\n'; |
408 | outs() << TDName << "[MangledName]: "; |
409 | outs().write_escaped(TD.MangledName.rtrim(StringRef("\0", 1)), |
410 | true) |
411 | << '\n'; |
412 | } |
413 | for (const std::pair<StringRef, ThrowInfo> &TIPair : TIs) { |
414 | StringRef TIName = TIPair.first; |
415 | const ThrowInfo &TI = TIPair.second; |
416 | auto dumpThrowInfoFlag = [&](const char *Name, uint32_t Flag) { |
417 | outs() << TIName << "[Flags." << Name |
418 | << "]: " << (TI.Flags & Flag ? "true" : "false") << '\n'; |
419 | }; |
420 | auto dumpThrowInfoSymbol = [&](const char *Name, int Offset) { |
421 | outs() << TIName << '[' << Name << "]: "; |
422 | auto Entry = TIEntries.find(std::make_pair(TIName, Offset)); |
423 | outs() << (Entry == TIEntries.end() ? "null" : Entry->second) << '\n'; |
424 | }; |
425 | outs() << TIName << "[Flags]: " << TI.Flags << '\n'; |
426 | dumpThrowInfoFlag("Const", 1); |
427 | dumpThrowInfoFlag("Volatile", 2); |
428 | dumpThrowInfoSymbol("CleanupFn", 4); |
429 | dumpThrowInfoSymbol("ForwardCompat", 8); |
430 | dumpThrowInfoSymbol("CatchableTypeArray", 12); |
431 | } |
432 | for (const std::pair<StringRef, CatchableTypeArray> &CTAPair : CTAs) { |
433 | StringRef CTAName = CTAPair.first; |
434 | const CatchableTypeArray &CTA = CTAPair.second; |
435 | |
436 | outs() << CTAName << "[NumEntries]: " << CTA.NumEntries << '\n'; |
437 | |
438 | unsigned Idx = 0; |
439 | for (auto I = CTAEntries.lower_bound(std::make_pair(CTAName, 0)), |
440 | E = CTAEntries.upper_bound(std::make_pair(CTAName, UINT64_MAX(18446744073709551615UL))); |
441 | I != E; ++I) |
442 | outs() << CTAName << '[' << Idx++ << "]: " << I->second << '\n'; |
443 | } |
444 | for (const std::pair<StringRef, CatchableType> &CTPair : CTs) { |
445 | StringRef CTName = CTPair.first; |
| Function call argument is an uninitialized value |
446 | const CatchableType &CT = CTPair.second; |
447 | auto dumpCatchableTypeFlag = [&](const char *Name, uint32_t Flag) { |
448 | outs() << CTName << "[Flags." << Name |
449 | << "]: " << (CT.Flags & Flag ? "true" : "false") << '\n'; |
450 | }; |
451 | outs() << CTName << "[Flags]: " << CT.Flags << '\n'; |
452 | dumpCatchableTypeFlag("ScalarType", 1); |
453 | dumpCatchableTypeFlag("VirtualInheritance", 4); |
454 | outs() << CTName << "[TypeDescriptor]: " << CT.Symbols[0] << '\n'; |
455 | outs() << CTName << "[NonVirtualBaseAdjustmentOffset]: " |
456 | << CT.NonVirtualBaseAdjustmentOffset << '\n'; |
457 | outs() << CTName |
458 | << "[VirtualBasePointerOffset]: " << CT.VirtualBasePointerOffset |
459 | << '\n'; |
460 | outs() << CTName << "[VirtualBaseAdjustmentOffset]: " |
461 | << CT.VirtualBaseAdjustmentOffset << '\n'; |
462 | outs() << CTName << "[Size]: " << CT.Size << '\n'; |
463 | outs() << CTName |
464 | << "[CopyCtor]: " << (CT.Symbols[1].empty() ? "null" : CT.Symbols[1]) |
465 | << '\n'; |
466 | } |
467 | for (const std::pair<std::pair<StringRef, uint64_t>, StringRef> &VTTPair : |
468 | VTTEntries) { |
469 | StringRef VTTName = VTTPair.first.first; |
470 | uint64_t VTTOffset = VTTPair.first.second; |
471 | StringRef VTTEntry = VTTPair.second; |
472 | outs() << VTTName << '[' << VTTOffset << "]: " << VTTEntry << '\n'; |
473 | } |
474 | for (const std::pair<StringRef, StringRef> &TIPair : TINames) { |
475 | StringRef TIName = TIPair.first; |
476 | outs() << TIName << ": " << TIPair.second << '\n'; |
477 | } |
478 | auto VTableSymI = VTableSymEntries.begin(); |
479 | auto VTableSymE = VTableSymEntries.end(); |
480 | auto VTableDataI = VTableDataEntries.begin(); |
481 | auto VTableDataE = VTableDataEntries.end(); |
482 | for (;;) { |
483 | bool SymDone = VTableSymI == VTableSymE; |
484 | bool DataDone = VTableDataI == VTableDataE; |
485 | if (SymDone && DataDone) |
486 | break; |
487 | if (!SymDone && (DataDone || VTableSymI->first < VTableDataI->first)) { |
488 | StringRef VTableName = VTableSymI->first.first; |
489 | uint64_t Offset = VTableSymI->first.second; |
490 | StringRef VTableEntry = VTableSymI->second; |
491 | outs() << VTableName << '[' << Offset << "]: "; |
492 | outs() << VTableEntry; |
493 | outs() << '\n'; |
494 | ++VTableSymI; |
495 | continue; |
496 | } |
497 | if (!DataDone && (SymDone || VTableDataI->first < VTableSymI->first)) { |
498 | StringRef VTableName = VTableDataI->first.first; |
499 | uint64_t Offset = VTableDataI->first.second; |
500 | int64_t VTableEntry = VTableDataI->second; |
501 | outs() << VTableName << '[' << Offset << "]: "; |
502 | outs() << VTableEntry; |
503 | outs() << '\n'; |
504 | ++VTableDataI; |
505 | continue; |
506 | } |
507 | } |
508 | } |
509 | |
510 | static void dumpArchive(const Archive *Arc) { |
511 | for (const Archive::Child &ArcC : Arc->children()) { |
512 | ErrorOr<std::unique_ptr<Binary>> ChildOrErr = ArcC.getAsBinary(); |
513 | if (std::error_code EC = ChildOrErr.getError()) { |
514 | |
515 | if (EC != object_error::invalid_file_type) |
516 | reportError(Arc->getFileName(), EC.message()); |
517 | continue; |
518 | } |
519 | |
520 | if (ObjectFile *Obj = dyn_cast<ObjectFile>(&*ChildOrErr.get())) |
521 | dumpCXXData(Obj); |
522 | else |
523 | reportError(Arc->getFileName(), cxxdump_error::unrecognized_file_format); |
524 | } |
525 | } |
526 | |
527 | static void dumpInput(StringRef File) { |
528 | |
529 | if (File != "-" && !sys::fs::exists(File)) { |
530 | reportError(File, cxxdump_error::file_not_found); |
531 | return; |
532 | } |
533 | |
534 | |
535 | ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(File); |
536 | if (std::error_code EC = BinaryOrErr.getError()) { |
537 | reportError(File, EC); |
538 | return; |
539 | } |
540 | Binary &Binary = *BinaryOrErr.get().getBinary(); |
541 | |
542 | if (Archive *Arc = dyn_cast<Archive>(&Binary)) |
543 | dumpArchive(Arc); |
544 | else if (ObjectFile *Obj = dyn_cast<ObjectFile>(&Binary)) |
545 | dumpCXXData(Obj); |
546 | else |
547 | reportError(File, cxxdump_error::unrecognized_file_format); |
548 | } |
549 | |
550 | int main(int argc, const char *argv[]) { |
551 | sys::PrintStackTraceOnErrorSignal(); |
552 | PrettyStackTraceProgram X(argc, argv); |
553 | llvm_shutdown_obj Y; |
554 | |
555 | |
556 | llvm::InitializeAllTargetInfos(); |
557 | |
558 | |
559 | cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion); |
560 | |
561 | cl::ParseCommandLineOptions(argc, argv, "LLVM C++ ABI Data Dumper\n"); |
562 | |
563 | |
564 | if (opts::InputFilenames.size() == 0) |
565 | opts::InputFilenames.push_back("-"); |
566 | |
567 | std::for_each(opts::InputFilenames.begin(), opts::InputFilenames.end(), |
568 | dumpInput); |
569 | |
570 | return ReturnValue; |
571 | } |