1 //===- llvm-cxxdump.cpp - Dump C++ data in an Object File -------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Dumps C++ data resident in object files and archives.
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 } // namespace opts
41 
42 static int ReturnValue = EXIT_SUCCESS;
43 
44 namespace llvm {
45 
error(std::error_code EC)46 static bool error(std::error_code EC) {
47   if (!EC)
48     return false;
49 
50   ReturnValue = EXIT_FAILURE;
51   outs() << "\nError reading file: " << EC.message() << ".\n";
52   outs().flush();
53   return true;
54 }
55 
56 } // namespace llvm
57 
reportError(StringRef Input,StringRef Message)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_FAILURE;
65 }
66 
reportError(StringRef Input,std::error_code EC)67 static void reportError(StringRef Input, std::error_code EC) {
68   reportError(Input, EC.message());
69 }
70 
getRelocSections(const ObjectFile * Obj,const SectionRef & Sec)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 
collectRelocatedSymbols(const ObjectFile * Obj,const SectionRef & Sec,uint64_t SecAddress,uint64_t SymAddress,uint64_t SymSize,StringRef * I,StringRef * E)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 
collectRelocationOffsets(const ObjectFile * Obj,const SectionRef & Sec,uint64_t SecAddress,uint64_t SymAddress,uint64_t SymSize,StringRef SymName,std::map<std::pair<StringRef,uint64_t>,StringRef> & Collection)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 
dumpCXXData(const ObjectFile * Obj)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     // Skip external symbols.
198     if (SecI == Obj->section_end())
199       continue;
200     const SectionRef &Sec = *SecI;
201     // Skip virtual or BSS sections.
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     // VFTables in the MS-ABI start with '??_7' and are contained within their
216     // own COMDAT section.  We then determine the contents of the VFTable by
217     // looking at each relocation in the section.
218     if (SymName.startswith("??_7")) {
219       // Each relocation either names a virtual method or a thunk.  We note the
220       // offset into the section and the symbol used for the relocation.
221       collectRelocationOffsets(Obj, Sec, SecAddress, SecAddress, SecSize,
222                                SymName, VFTableEntries);
223     }
224     // VBTables in the MS-ABI start with '??_8' and are filled with 32-bit
225     // offsets of virtual bases.
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     // Complete object locators in the MS-ABI start with '??_R4'
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     // Class hierarchy descriptors in the MS-ABI start with '??_R3'
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     // Class hierarchy descriptors in the MS-ABI start with '??_R2'
255     else if (SymName.startswith("??_R2")) {
256       // Each relocation names a base class descriptor.  We note the offset into
257       // the section and the symbol used for the relocation.
258       collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize,
259                                SymName, BCAEntries);
260     }
261     // Base class descriptors in the MS-ABI start with '??_R1'
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     // Type descriptors in the MS-ABI start with '??_R0'
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     // Throw descriptors in the MS-ABI start with '_TI'
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     // Catchable type arrays in the MS-ABI start with _CTA or __CTA.
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     // Catchable types in the MS-ABI start with _CT or __CT.
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     // Construction vtables in the Itanium ABI start with '_ZTT' or '__ZTT'.
321     else if (SymName.startswith("_ZTT") || SymName.startswith("__ZTT")) {
322       collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize,
323                                SymName, VTTEntries);
324     }
325     // Typeinfo names in the Itanium ABI start with '_ZTS' or '__ZTS'.
326     else if (SymName.startswith("_ZTS") || SymName.startswith("__ZTS")) {
327       TINames[SymName] = SymContents.slice(0, SymContents.find('\0'));
328     }
329     // Vtables in the Itanium ABI start with '_ZTV' or '__ZTV'.
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     // Typeinfo structures in the Itanium ABI start with '_ZTI' or '__ZTI'.
348     else if (SymName.startswith("_ZTI") || SymName.startswith("__ZTI")) {
349       // FIXME: Do something with these!
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 auto &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 auto &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 auto &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 auto &BCAEntry : BCAEntries) {
385     StringRef BCAName = BCAEntry.first.first;
386     uint64_t Offset = BCAEntry.first.second;
387     StringRef SymName = BCAEntry.second;
388     outs() << BCAName << '[' << Offset << "]: " << SymName << '\n';
389   }
390   for (const auto &BCDPair : BCDs) {
391     StringRef BCDName = BCDPair.first;
392     const BaseClassDescriptor &BCD = BCDPair.second;
393     outs() << BCDName << "[TypeDescriptor]: " << BCD.Symbols[0] << '\n';
394     outs() << BCDName << "[NumBases]: " << BCD.Data[0] << '\n';
395     outs() << BCDName << "[OffsetInVBase]: " << BCD.Data[1] << '\n';
396     outs() << BCDName << "[VBPtrOffset]: " << BCD.Data[2] << '\n';
397     outs() << BCDName << "[OffsetInVBTable]: " << BCD.Data[3] << '\n';
398     outs() << BCDName << "[Flags]: " << BCD.Data[4] << '\n';
399     outs() << BCDName << "[ClassHierarchyDescriptor]: " << BCD.Symbols[1]
400            << '\n';
401   }
402   for (const auto &TDPair : TDs) {
403     StringRef TDName = TDPair.first;
404     const TypeDescriptor &TD = TDPair.second;
405     outs() << TDName << "[VFPtr]: " << TD.Symbols[0] << '\n';
406     outs() << TDName << "[AlwaysZero]: " << TD.AlwaysZero << '\n';
407     outs() << TDName << "[MangledName]: ";
408     outs().write_escaped(TD.MangledName.rtrim(StringRef("\0", 1)),
409                          /*UseHexEscapes=*/true)
410         << '\n';
411   }
412   for (const auto &TIPair : TIs) {
413     StringRef TIName = TIPair.first;
414     const ThrowInfo &TI = TIPair.second;
415     auto dumpThrowInfoFlag = [&](const char *Name, uint32_t Flag) {
416       outs() << TIName << "[Flags." << Name
417              << "]: " << (TI.Flags & Flag ? "true" : "false") << '\n';
418     };
419     auto dumpThrowInfoSymbol = [&](const char *Name, int Offset) {
420       outs() << TIName << '[' << Name << "]: ";
421       auto Entry = TIEntries.find(std::make_pair(TIName, Offset));
422       outs() << (Entry == TIEntries.end() ? "null" : Entry->second) << '\n';
423     };
424     outs() << TIName << "[Flags]: " << TI.Flags << '\n';
425     dumpThrowInfoFlag("Const", 1);
426     dumpThrowInfoFlag("Volatile", 2);
427     dumpThrowInfoSymbol("CleanupFn", 4);
428     dumpThrowInfoSymbol("ForwardCompat", 8);
429     dumpThrowInfoSymbol("CatchableTypeArray", 12);
430   }
431   for (const auto &CTAPair : CTAs) {
432     StringRef CTAName = CTAPair.first;
433     const CatchableTypeArray &CTA = CTAPair.second;
434 
435     outs() << CTAName << "[NumEntries]: " << CTA.NumEntries << '\n';
436 
437     unsigned Idx = 0;
438     for (auto I = CTAEntries.lower_bound(std::make_pair(CTAName, 0)),
439               E = CTAEntries.upper_bound(std::make_pair(CTAName, UINT64_MAX));
440          I != E; ++I)
441       outs() << CTAName << '[' << Idx++ << "]: " << I->second << '\n';
442   }
443   for (const auto &CTPair : CTs) {
444     StringRef CTName = CTPair.first;
445     const CatchableType &CT = CTPair.second;
446     auto dumpCatchableTypeFlag = [&](const char *Name, uint32_t Flag) {
447       outs() << CTName << "[Flags." << Name
448              << "]: " << (CT.Flags & Flag ? "true" : "false") << '\n';
449     };
450     outs() << CTName << "[Flags]: " << CT.Flags << '\n';
451     dumpCatchableTypeFlag("ScalarType", 1);
452     dumpCatchableTypeFlag("VirtualInheritance", 4);
453     outs() << CTName << "[TypeDescriptor]: " << CT.Symbols[0] << '\n';
454     outs() << CTName << "[NonVirtualBaseAdjustmentOffset]: "
455            << CT.NonVirtualBaseAdjustmentOffset << '\n';
456     outs() << CTName
457            << "[VirtualBasePointerOffset]: " << CT.VirtualBasePointerOffset
458            << '\n';
459     outs() << CTName << "[VirtualBaseAdjustmentOffset]: "
460            << CT.VirtualBaseAdjustmentOffset << '\n';
461     outs() << CTName << "[Size]: " << CT.Size << '\n';
462     outs() << CTName
463            << "[CopyCtor]: " << (CT.Symbols[1].empty() ? "null" : CT.Symbols[1])
464            << '\n';
465   }
466   for (const auto &VTTPair : VTTEntries) {
467     StringRef VTTName = VTTPair.first.first;
468     uint64_t VTTOffset = VTTPair.first.second;
469     StringRef VTTEntry = VTTPair.second;
470     outs() << VTTName << '[' << VTTOffset << "]: " << VTTEntry << '\n';
471   }
472   for (const auto &TIPair : TINames) {
473     StringRef TIName = TIPair.first;
474     outs() << TIName << ": " << TIPair.second << '\n';
475   }
476   auto VTableSymI = VTableSymEntries.begin();
477   auto VTableSymE = VTableSymEntries.end();
478   auto VTableDataI = VTableDataEntries.begin();
479   auto VTableDataE = VTableDataEntries.end();
480   for (;;) {
481     bool SymDone = VTableSymI == VTableSymE;
482     bool DataDone = VTableDataI == VTableDataE;
483     if (SymDone && DataDone)
484       break;
485     if (!SymDone && (DataDone || VTableSymI->first < VTableDataI->first)) {
486       StringRef VTableName = VTableSymI->first.first;
487       uint64_t Offset = VTableSymI->first.second;
488       StringRef VTableEntry = VTableSymI->second;
489       outs() << VTableName << '[' << Offset << "]: ";
490       outs() << VTableEntry;
491       outs() << '\n';
492       ++VTableSymI;
493       continue;
494     }
495     if (!DataDone && (SymDone || VTableDataI->first < VTableSymI->first)) {
496       StringRef VTableName = VTableDataI->first.first;
497       uint64_t Offset = VTableDataI->first.second;
498       int64_t VTableEntry = VTableDataI->second;
499       outs() << VTableName << '[' << Offset << "]: ";
500       outs() << VTableEntry;
501       outs() << '\n';
502       ++VTableDataI;
503       continue;
504     }
505   }
506 }
507 
dumpArchive(const Archive * Arc)508 static void dumpArchive(const Archive *Arc) {
509   for (const Archive::Child &ArcC : Arc->children()) {
510     ErrorOr<std::unique_ptr<Binary>> ChildOrErr = ArcC.getAsBinary();
511     if (std::error_code EC = ChildOrErr.getError()) {
512       // Ignore non-object files.
513       if (EC != object_error::invalid_file_type)
514         reportError(Arc->getFileName(), EC.message());
515       continue;
516     }
517 
518     if (ObjectFile *Obj = dyn_cast<ObjectFile>(&*ChildOrErr.get()))
519       dumpCXXData(Obj);
520     else
521       reportError(Arc->getFileName(), cxxdump_error::unrecognized_file_format);
522   }
523 }
524 
dumpInput(StringRef File)525 static void dumpInput(StringRef File) {
526   // If file isn't stdin, check that it exists.
527   if (File != "-" && !sys::fs::exists(File)) {
528     reportError(File, cxxdump_error::file_not_found);
529     return;
530   }
531 
532   // Attempt to open the binary.
533   ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(File);
534   if (std::error_code EC = BinaryOrErr.getError()) {
535     reportError(File, EC);
536     return;
537   }
538   Binary &Binary = *BinaryOrErr.get().getBinary();
539 
540   if (Archive *Arc = dyn_cast<Archive>(&Binary))
541     dumpArchive(Arc);
542   else if (ObjectFile *Obj = dyn_cast<ObjectFile>(&Binary))
543     dumpCXXData(Obj);
544   else
545     reportError(File, cxxdump_error::unrecognized_file_format);
546 }
547 
main(int argc,const char * argv[])548 int main(int argc, const char *argv[]) {
549   sys::PrintStackTraceOnErrorSignal();
550   PrettyStackTraceProgram X(argc, argv);
551   llvm_shutdown_obj Y;
552 
553   // Initialize targets.
554   llvm::InitializeAllTargetInfos();
555 
556   // Register the target printer for --version.
557   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
558 
559   cl::ParseCommandLineOptions(argc, argv, "LLVM C++ ABI Data Dumper\n");
560 
561   // Default to stdin if no filename is specified.
562   if (opts::InputFilenames.size() == 0)
563     opts::InputFilenames.push_back("-");
564 
565   std::for_each(opts::InputFilenames.begin(), opts::InputFilenames.end(),
566                 dumpInput);
567 
568   return ReturnValue;
569 }
570