1283625Sdim//===- llvm-cxxdump.cpp - Dump C++ data in an Object File -------*- C++ -*-===// 2283625Sdim// 3283625Sdim// The LLVM Compiler Infrastructure 4283625Sdim// 5283625Sdim// This file is distributed under the University of Illinois Open Source 6283625Sdim// License. See LICENSE.TXT for details. 7283625Sdim// 8283625Sdim//===----------------------------------------------------------------------===// 9283625Sdim// 10283625Sdim// Dumps C++ data resident in object files and archives. 11283625Sdim// 12283625Sdim//===----------------------------------------------------------------------===// 13283625Sdim 14283625Sdim#include "llvm-cxxdump.h" 15283625Sdim#include "Error.h" 16283625Sdim#include "llvm/ADT/ArrayRef.h" 17283625Sdim#include "llvm/Object/Archive.h" 18283625Sdim#include "llvm/Object/ObjectFile.h" 19285181Sdim#include "llvm/Object/SymbolSize.h" 20283625Sdim#include "llvm/Support/Debug.h" 21283625Sdim#include "llvm/Support/Endian.h" 22283625Sdim#include "llvm/Support/FileSystem.h" 23283625Sdim#include "llvm/Support/ManagedStatic.h" 24283625Sdim#include "llvm/Support/PrettyStackTrace.h" 25283625Sdim#include "llvm/Support/Signals.h" 26283625Sdim#include "llvm/Support/TargetRegistry.h" 27283625Sdim#include "llvm/Support/TargetSelect.h" 28283625Sdim#include "llvm/Support/raw_ostream.h" 29283625Sdim#include <map> 30283625Sdim#include <string> 31283625Sdim#include <system_error> 32283625Sdim 33283625Sdimusing namespace llvm; 34283625Sdimusing namespace llvm::object; 35283625Sdimusing namespace llvm::support; 36283625Sdim 37283625Sdimnamespace opts { 38283625Sdimcl::list<std::string> InputFilenames(cl::Positional, 39283625Sdim cl::desc("<input object files>"), 40283625Sdim cl::ZeroOrMore); 41283625Sdim} // namespace opts 42283625Sdim 43283625Sdimnamespace llvm { 44283625Sdim 45296417Sdimstatic void error(std::error_code EC) { 46283625Sdim if (!EC) 47296417Sdim return; 48283625Sdim outs() << "\nError reading file: " << EC.message() << ".\n"; 49283625Sdim outs().flush(); 50296417Sdim exit(1); 51283625Sdim} 52283625Sdim 53283625Sdim} // namespace llvm 54283625Sdim 55283625Sdimstatic void reportError(StringRef Input, StringRef Message) { 56283625Sdim if (Input == "-") 57283625Sdim Input = "<stdin>"; 58283625Sdim errs() << Input << ": " << Message << "\n"; 59283625Sdim errs().flush(); 60296417Sdim exit(1); 61283625Sdim} 62283625Sdim 63283625Sdimstatic void reportError(StringRef Input, std::error_code EC) { 64283625Sdim reportError(Input, EC.message()); 65283625Sdim} 66283625Sdim 67296417Sdimstatic std::map<SectionRef, SmallVector<SectionRef, 1>> SectionRelocMap; 68283625Sdim 69296417Sdimstatic void collectRelocatedSymbols(const ObjectFile *Obj, 70283625Sdim const SectionRef &Sec, uint64_t SecAddress, 71283625Sdim uint64_t SymAddress, uint64_t SymSize, 72283625Sdim StringRef *I, StringRef *E) { 73283625Sdim uint64_t SymOffset = SymAddress - SecAddress; 74283625Sdim uint64_t SymEnd = SymOffset + SymSize; 75296417Sdim for (const SectionRef &SR : SectionRelocMap[Sec]) { 76283625Sdim for (const object::RelocationRef &Reloc : SR.relocations()) { 77283625Sdim if (I == E) 78283625Sdim break; 79283625Sdim const object::symbol_iterator RelocSymI = Reloc.getSymbol(); 80283625Sdim if (RelocSymI == Obj->symbol_end()) 81283625Sdim continue; 82285181Sdim ErrorOr<StringRef> RelocSymName = RelocSymI->getName(); 83296417Sdim error(RelocSymName.getError()); 84285181Sdim uint64_t Offset = Reloc.getOffset(); 85283625Sdim if (Offset >= SymOffset && Offset < SymEnd) { 86285181Sdim *I = *RelocSymName; 87283625Sdim ++I; 88283625Sdim } 89283625Sdim } 90283625Sdim } 91283625Sdim} 92283625Sdim 93296417Sdimstatic void collectRelocationOffsets( 94283625Sdim const ObjectFile *Obj, const SectionRef &Sec, uint64_t SecAddress, 95283625Sdim uint64_t SymAddress, uint64_t SymSize, StringRef SymName, 96283625Sdim std::map<std::pair<StringRef, uint64_t>, StringRef> &Collection) { 97283625Sdim uint64_t SymOffset = SymAddress - SecAddress; 98283625Sdim uint64_t SymEnd = SymOffset + SymSize; 99296417Sdim for (const SectionRef &SR : SectionRelocMap[Sec]) { 100283625Sdim for (const object::RelocationRef &Reloc : SR.relocations()) { 101283625Sdim const object::symbol_iterator RelocSymI = Reloc.getSymbol(); 102283625Sdim if (RelocSymI == Obj->symbol_end()) 103283625Sdim continue; 104285181Sdim ErrorOr<StringRef> RelocSymName = RelocSymI->getName(); 105296417Sdim error(RelocSymName.getError()); 106285181Sdim uint64_t Offset = Reloc.getOffset(); 107283625Sdim if (Offset >= SymOffset && Offset < SymEnd) 108285181Sdim Collection[std::make_pair(SymName, Offset - SymOffset)] = *RelocSymName; 109283625Sdim } 110283625Sdim } 111283625Sdim} 112283625Sdim 113283625Sdimstatic void dumpCXXData(const ObjectFile *Obj) { 114283625Sdim struct CompleteObjectLocator { 115283625Sdim StringRef Symbols[2]; 116283625Sdim ArrayRef<little32_t> Data; 117283625Sdim }; 118283625Sdim struct ClassHierarchyDescriptor { 119283625Sdim StringRef Symbols[1]; 120283625Sdim ArrayRef<little32_t> Data; 121283625Sdim }; 122283625Sdim struct BaseClassDescriptor { 123283625Sdim StringRef Symbols[2]; 124283625Sdim ArrayRef<little32_t> Data; 125283625Sdim }; 126283625Sdim struct TypeDescriptor { 127283625Sdim StringRef Symbols[1]; 128283625Sdim uint64_t AlwaysZero; 129283625Sdim StringRef MangledName; 130283625Sdim }; 131283625Sdim struct ThrowInfo { 132283625Sdim uint32_t Flags; 133283625Sdim }; 134283625Sdim struct CatchableTypeArray { 135283625Sdim uint32_t NumEntries; 136283625Sdim }; 137283625Sdim struct CatchableType { 138283625Sdim uint32_t Flags; 139283625Sdim uint32_t NonVirtualBaseAdjustmentOffset; 140283625Sdim int32_t VirtualBasePointerOffset; 141283625Sdim uint32_t VirtualBaseAdjustmentOffset; 142283625Sdim uint32_t Size; 143283625Sdim StringRef Symbols[2]; 144283625Sdim }; 145283625Sdim std::map<std::pair<StringRef, uint64_t>, StringRef> VFTableEntries; 146283625Sdim std::map<std::pair<StringRef, uint64_t>, StringRef> TIEntries; 147283625Sdim std::map<std::pair<StringRef, uint64_t>, StringRef> CTAEntries; 148283625Sdim std::map<StringRef, ArrayRef<little32_t>> VBTables; 149283625Sdim std::map<StringRef, CompleteObjectLocator> COLs; 150283625Sdim std::map<StringRef, ClassHierarchyDescriptor> CHDs; 151283625Sdim std::map<std::pair<StringRef, uint64_t>, StringRef> BCAEntries; 152283625Sdim std::map<StringRef, BaseClassDescriptor> BCDs; 153283625Sdim std::map<StringRef, TypeDescriptor> TDs; 154283625Sdim std::map<StringRef, ThrowInfo> TIs; 155283625Sdim std::map<StringRef, CatchableTypeArray> CTAs; 156283625Sdim std::map<StringRef, CatchableType> CTs; 157283625Sdim 158283625Sdim std::map<std::pair<StringRef, uint64_t>, StringRef> VTableSymEntries; 159283625Sdim std::map<std::pair<StringRef, uint64_t>, int64_t> VTableDataEntries; 160283625Sdim std::map<std::pair<StringRef, uint64_t>, StringRef> VTTEntries; 161283625Sdim std::map<StringRef, StringRef> TINames; 162283625Sdim 163296417Sdim SectionRelocMap.clear(); 164296417Sdim for (const SectionRef &Section : Obj->sections()) { 165296417Sdim section_iterator Sec2 = Section.getRelocatedSection(); 166296417Sdim if (Sec2 != Obj->section_end()) 167296417Sdim SectionRelocMap[*Sec2].push_back(Section); 168296417Sdim } 169296417Sdim 170283625Sdim uint8_t BytesInAddress = Obj->getBytesInAddress(); 171283625Sdim 172285181Sdim std::vector<std::pair<SymbolRef, uint64_t>> SymAddr = 173285181Sdim object::computeSymbolSizes(*Obj); 174285181Sdim 175285181Sdim for (auto &P : SymAddr) { 176285181Sdim object::SymbolRef Sym = P.first; 177285181Sdim uint64_t SymSize = P.second; 178285181Sdim ErrorOr<StringRef> SymNameOrErr = Sym.getName(); 179296417Sdim error(SymNameOrErr.getError()); 180285181Sdim StringRef SymName = *SymNameOrErr; 181296417Sdim ErrorOr<object::section_iterator> SecIOrErr = Sym.getSection(); 182296417Sdim error(SecIOrErr.getError()); 183296417Sdim object::section_iterator SecI = *SecIOrErr; 184283625Sdim // Skip external symbols. 185283625Sdim if (SecI == Obj->section_end()) 186283625Sdim continue; 187283625Sdim const SectionRef &Sec = *SecI; 188283625Sdim // Skip virtual or BSS sections. 189283625Sdim if (Sec.isBSS() || Sec.isVirtual()) 190283625Sdim continue; 191283625Sdim StringRef SecContents; 192296417Sdim error(Sec.getContents(SecContents)); 193286684Sdim ErrorOr<uint64_t> SymAddressOrErr = Sym.getAddress(); 194296417Sdim error(SymAddressOrErr.getError()); 195286684Sdim uint64_t SymAddress = *SymAddressOrErr; 196283625Sdim uint64_t SecAddress = Sec.getAddress(); 197283625Sdim uint64_t SecSize = Sec.getSize(); 198283625Sdim uint64_t SymOffset = SymAddress - SecAddress; 199283625Sdim StringRef SymContents = SecContents.substr(SymOffset, SymSize); 200283625Sdim 201283625Sdim // VFTables in the MS-ABI start with '??_7' and are contained within their 202283625Sdim // own COMDAT section. We then determine the contents of the VFTable by 203283625Sdim // looking at each relocation in the section. 204283625Sdim if (SymName.startswith("??_7")) { 205283625Sdim // Each relocation either names a virtual method or a thunk. We note the 206283625Sdim // offset into the section and the symbol used for the relocation. 207283625Sdim collectRelocationOffsets(Obj, Sec, SecAddress, SecAddress, SecSize, 208283625Sdim SymName, VFTableEntries); 209283625Sdim } 210283625Sdim // VBTables in the MS-ABI start with '??_8' and are filled with 32-bit 211283625Sdim // offsets of virtual bases. 212283625Sdim else if (SymName.startswith("??_8")) { 213283625Sdim ArrayRef<little32_t> VBTableData( 214283625Sdim reinterpret_cast<const little32_t *>(SymContents.data()), 215283625Sdim SymContents.size() / sizeof(little32_t)); 216283625Sdim VBTables[SymName] = VBTableData; 217283625Sdim } 218283625Sdim // Complete object locators in the MS-ABI start with '??_R4' 219283625Sdim else if (SymName.startswith("??_R4")) { 220283625Sdim CompleteObjectLocator COL; 221296417Sdim COL.Data = makeArrayRef( 222283625Sdim reinterpret_cast<const little32_t *>(SymContents.data()), 3); 223283625Sdim StringRef *I = std::begin(COL.Symbols), *E = std::end(COL.Symbols); 224296417Sdim collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E); 225283625Sdim COLs[SymName] = COL; 226283625Sdim } 227283625Sdim // Class hierarchy descriptors in the MS-ABI start with '??_R3' 228283625Sdim else if (SymName.startswith("??_R3")) { 229283625Sdim ClassHierarchyDescriptor CHD; 230296417Sdim CHD.Data = makeArrayRef( 231283625Sdim reinterpret_cast<const little32_t *>(SymContents.data()), 3); 232283625Sdim StringRef *I = std::begin(CHD.Symbols), *E = std::end(CHD.Symbols); 233296417Sdim collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E); 234283625Sdim CHDs[SymName] = CHD; 235283625Sdim } 236283625Sdim // Class hierarchy descriptors in the MS-ABI start with '??_R2' 237283625Sdim else if (SymName.startswith("??_R2")) { 238283625Sdim // Each relocation names a base class descriptor. We note the offset into 239283625Sdim // the section and the symbol used for the relocation. 240283625Sdim collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize, 241283625Sdim SymName, BCAEntries); 242283625Sdim } 243283625Sdim // Base class descriptors in the MS-ABI start with '??_R1' 244283625Sdim else if (SymName.startswith("??_R1")) { 245283625Sdim BaseClassDescriptor BCD; 246296417Sdim BCD.Data = makeArrayRef( 247283625Sdim reinterpret_cast<const little32_t *>(SymContents.data()) + 1, 5); 248283625Sdim StringRef *I = std::begin(BCD.Symbols), *E = std::end(BCD.Symbols); 249296417Sdim collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E); 250283625Sdim BCDs[SymName] = BCD; 251283625Sdim } 252283625Sdim // Type descriptors in the MS-ABI start with '??_R0' 253283625Sdim else if (SymName.startswith("??_R0")) { 254283625Sdim const char *DataPtr = SymContents.drop_front(BytesInAddress).data(); 255283625Sdim TypeDescriptor TD; 256283625Sdim if (BytesInAddress == 8) 257283625Sdim TD.AlwaysZero = *reinterpret_cast<const little64_t *>(DataPtr); 258283625Sdim else 259283625Sdim TD.AlwaysZero = *reinterpret_cast<const little32_t *>(DataPtr); 260283625Sdim TD.MangledName = SymContents.drop_front(BytesInAddress * 2); 261283625Sdim StringRef *I = std::begin(TD.Symbols), *E = std::end(TD.Symbols); 262296417Sdim collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E); 263283625Sdim TDs[SymName] = TD; 264283625Sdim } 265283625Sdim // Throw descriptors in the MS-ABI start with '_TI' 266283625Sdim else if (SymName.startswith("_TI") || SymName.startswith("__TI")) { 267283625Sdim ThrowInfo TI; 268283625Sdim TI.Flags = *reinterpret_cast<const little32_t *>(SymContents.data()); 269283625Sdim collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize, 270283625Sdim SymName, TIEntries); 271283625Sdim TIs[SymName] = TI; 272283625Sdim } 273283625Sdim // Catchable type arrays in the MS-ABI start with _CTA or __CTA. 274283625Sdim else if (SymName.startswith("_CTA") || SymName.startswith("__CTA")) { 275283625Sdim CatchableTypeArray CTA; 276283625Sdim CTA.NumEntries = 277283625Sdim *reinterpret_cast<const little32_t *>(SymContents.data()); 278283625Sdim collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize, 279283625Sdim SymName, CTAEntries); 280283625Sdim CTAs[SymName] = CTA; 281283625Sdim } 282283625Sdim // Catchable types in the MS-ABI start with _CT or __CT. 283283625Sdim else if (SymName.startswith("_CT") || SymName.startswith("__CT")) { 284283625Sdim const little32_t *DataPtr = 285283625Sdim reinterpret_cast<const little32_t *>(SymContents.data()); 286283625Sdim CatchableType CT; 287283625Sdim CT.Flags = DataPtr[0]; 288283625Sdim CT.NonVirtualBaseAdjustmentOffset = DataPtr[2]; 289283625Sdim CT.VirtualBasePointerOffset = DataPtr[3]; 290283625Sdim CT.VirtualBaseAdjustmentOffset = DataPtr[4]; 291283625Sdim CT.Size = DataPtr[5]; 292283625Sdim StringRef *I = std::begin(CT.Symbols), *E = std::end(CT.Symbols); 293296417Sdim collectRelocatedSymbols(Obj, Sec, SecAddress, SymAddress, SymSize, I, E); 294283625Sdim CTs[SymName] = CT; 295283625Sdim } 296283625Sdim // Construction vtables in the Itanium ABI start with '_ZTT' or '__ZTT'. 297283625Sdim else if (SymName.startswith("_ZTT") || SymName.startswith("__ZTT")) { 298283625Sdim collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize, 299283625Sdim SymName, VTTEntries); 300283625Sdim } 301283625Sdim // Typeinfo names in the Itanium ABI start with '_ZTS' or '__ZTS'. 302283625Sdim else if (SymName.startswith("_ZTS") || SymName.startswith("__ZTS")) { 303283625Sdim TINames[SymName] = SymContents.slice(0, SymContents.find('\0')); 304283625Sdim } 305283625Sdim // Vtables in the Itanium ABI start with '_ZTV' or '__ZTV'. 306283625Sdim else if (SymName.startswith("_ZTV") || SymName.startswith("__ZTV")) { 307283625Sdim collectRelocationOffsets(Obj, Sec, SecAddress, SymAddress, SymSize, 308283625Sdim SymName, VTableSymEntries); 309283625Sdim for (uint64_t SymOffI = 0; SymOffI < SymSize; SymOffI += BytesInAddress) { 310283625Sdim auto Key = std::make_pair(SymName, SymOffI); 311283625Sdim if (VTableSymEntries.count(Key)) 312283625Sdim continue; 313283625Sdim const char *DataPtr = 314283625Sdim SymContents.substr(SymOffI, BytesInAddress).data(); 315283625Sdim int64_t VData; 316283625Sdim if (BytesInAddress == 8) 317283625Sdim VData = *reinterpret_cast<const little64_t *>(DataPtr); 318283625Sdim else 319283625Sdim VData = *reinterpret_cast<const little32_t *>(DataPtr); 320283625Sdim VTableDataEntries[Key] = VData; 321283625Sdim } 322283625Sdim } 323283625Sdim // Typeinfo structures in the Itanium ABI start with '_ZTI' or '__ZTI'. 324283625Sdim else if (SymName.startswith("_ZTI") || SymName.startswith("__ZTI")) { 325283625Sdim // FIXME: Do something with these! 326283625Sdim } 327283625Sdim } 328283625Sdim for (const auto &VFTableEntry : VFTableEntries) { 329283625Sdim StringRef VFTableName = VFTableEntry.first.first; 330283625Sdim uint64_t Offset = VFTableEntry.first.second; 331283625Sdim StringRef SymName = VFTableEntry.second; 332283625Sdim outs() << VFTableName << '[' << Offset << "]: " << SymName << '\n'; 333283625Sdim } 334283625Sdim for (const auto &VBTable : VBTables) { 335283625Sdim StringRef VBTableName = VBTable.first; 336283625Sdim uint32_t Idx = 0; 337283625Sdim for (little32_t Offset : VBTable.second) { 338283625Sdim outs() << VBTableName << '[' << Idx << "]: " << Offset << '\n'; 339283625Sdim Idx += sizeof(Offset); 340283625Sdim } 341283625Sdim } 342283625Sdim for (const auto &COLPair : COLs) { 343283625Sdim StringRef COLName = COLPair.first; 344283625Sdim const CompleteObjectLocator &COL = COLPair.second; 345283625Sdim outs() << COLName << "[IsImageRelative]: " << COL.Data[0] << '\n'; 346283625Sdim outs() << COLName << "[OffsetToTop]: " << COL.Data[1] << '\n'; 347283625Sdim outs() << COLName << "[VFPtrOffset]: " << COL.Data[2] << '\n'; 348283625Sdim outs() << COLName << "[TypeDescriptor]: " << COL.Symbols[0] << '\n'; 349283625Sdim outs() << COLName << "[ClassHierarchyDescriptor]: " << COL.Symbols[1] 350283625Sdim << '\n'; 351283625Sdim } 352283625Sdim for (const auto &CHDPair : CHDs) { 353283625Sdim StringRef CHDName = CHDPair.first; 354283625Sdim const ClassHierarchyDescriptor &CHD = CHDPair.second; 355283625Sdim outs() << CHDName << "[AlwaysZero]: " << CHD.Data[0] << '\n'; 356283625Sdim outs() << CHDName << "[Flags]: " << CHD.Data[1] << '\n'; 357283625Sdim outs() << CHDName << "[NumClasses]: " << CHD.Data[2] << '\n'; 358283625Sdim outs() << CHDName << "[BaseClassArray]: " << CHD.Symbols[0] << '\n'; 359283625Sdim } 360283625Sdim for (const auto &BCAEntry : BCAEntries) { 361283625Sdim StringRef BCAName = BCAEntry.first.first; 362283625Sdim uint64_t Offset = BCAEntry.first.second; 363283625Sdim StringRef SymName = BCAEntry.second; 364283625Sdim outs() << BCAName << '[' << Offset << "]: " << SymName << '\n'; 365283625Sdim } 366283625Sdim for (const auto &BCDPair : BCDs) { 367283625Sdim StringRef BCDName = BCDPair.first; 368283625Sdim const BaseClassDescriptor &BCD = BCDPair.second; 369283625Sdim outs() << BCDName << "[TypeDescriptor]: " << BCD.Symbols[0] << '\n'; 370283625Sdim outs() << BCDName << "[NumBases]: " << BCD.Data[0] << '\n'; 371283625Sdim outs() << BCDName << "[OffsetInVBase]: " << BCD.Data[1] << '\n'; 372283625Sdim outs() << BCDName << "[VBPtrOffset]: " << BCD.Data[2] << '\n'; 373283625Sdim outs() << BCDName << "[OffsetInVBTable]: " << BCD.Data[3] << '\n'; 374283625Sdim outs() << BCDName << "[Flags]: " << BCD.Data[4] << '\n'; 375283625Sdim outs() << BCDName << "[ClassHierarchyDescriptor]: " << BCD.Symbols[1] 376283625Sdim << '\n'; 377283625Sdim } 378283625Sdim for (const auto &TDPair : TDs) { 379283625Sdim StringRef TDName = TDPair.first; 380283625Sdim const TypeDescriptor &TD = TDPair.second; 381283625Sdim outs() << TDName << "[VFPtr]: " << TD.Symbols[0] << '\n'; 382283625Sdim outs() << TDName << "[AlwaysZero]: " << TD.AlwaysZero << '\n'; 383283625Sdim outs() << TDName << "[MangledName]: "; 384283625Sdim outs().write_escaped(TD.MangledName.rtrim(StringRef("\0", 1)), 385283625Sdim /*UseHexEscapes=*/true) 386283625Sdim << '\n'; 387283625Sdim } 388283625Sdim for (const auto &TIPair : TIs) { 389283625Sdim StringRef TIName = TIPair.first; 390283625Sdim const ThrowInfo &TI = TIPair.second; 391283625Sdim auto dumpThrowInfoFlag = [&](const char *Name, uint32_t Flag) { 392283625Sdim outs() << TIName << "[Flags." << Name 393283625Sdim << "]: " << (TI.Flags & Flag ? "true" : "false") << '\n'; 394283625Sdim }; 395283625Sdim auto dumpThrowInfoSymbol = [&](const char *Name, int Offset) { 396283625Sdim outs() << TIName << '[' << Name << "]: "; 397283625Sdim auto Entry = TIEntries.find(std::make_pair(TIName, Offset)); 398283625Sdim outs() << (Entry == TIEntries.end() ? "null" : Entry->second) << '\n'; 399283625Sdim }; 400283625Sdim outs() << TIName << "[Flags]: " << TI.Flags << '\n'; 401283625Sdim dumpThrowInfoFlag("Const", 1); 402283625Sdim dumpThrowInfoFlag("Volatile", 2); 403283625Sdim dumpThrowInfoSymbol("CleanupFn", 4); 404283625Sdim dumpThrowInfoSymbol("ForwardCompat", 8); 405283625Sdim dumpThrowInfoSymbol("CatchableTypeArray", 12); 406283625Sdim } 407283625Sdim for (const auto &CTAPair : CTAs) { 408283625Sdim StringRef CTAName = CTAPair.first; 409283625Sdim const CatchableTypeArray &CTA = CTAPair.second; 410283625Sdim 411283625Sdim outs() << CTAName << "[NumEntries]: " << CTA.NumEntries << '\n'; 412283625Sdim 413283625Sdim unsigned Idx = 0; 414283625Sdim for (auto I = CTAEntries.lower_bound(std::make_pair(CTAName, 0)), 415283625Sdim E = CTAEntries.upper_bound(std::make_pair(CTAName, UINT64_MAX)); 416283625Sdim I != E; ++I) 417283625Sdim outs() << CTAName << '[' << Idx++ << "]: " << I->second << '\n'; 418283625Sdim } 419283625Sdim for (const auto &CTPair : CTs) { 420283625Sdim StringRef CTName = CTPair.first; 421283625Sdim const CatchableType &CT = CTPair.second; 422283625Sdim auto dumpCatchableTypeFlag = [&](const char *Name, uint32_t Flag) { 423283625Sdim outs() << CTName << "[Flags." << Name 424283625Sdim << "]: " << (CT.Flags & Flag ? "true" : "false") << '\n'; 425283625Sdim }; 426283625Sdim outs() << CTName << "[Flags]: " << CT.Flags << '\n'; 427283625Sdim dumpCatchableTypeFlag("ScalarType", 1); 428283625Sdim dumpCatchableTypeFlag("VirtualInheritance", 4); 429283625Sdim outs() << CTName << "[TypeDescriptor]: " << CT.Symbols[0] << '\n'; 430283625Sdim outs() << CTName << "[NonVirtualBaseAdjustmentOffset]: " 431283625Sdim << CT.NonVirtualBaseAdjustmentOffset << '\n'; 432283625Sdim outs() << CTName 433283625Sdim << "[VirtualBasePointerOffset]: " << CT.VirtualBasePointerOffset 434283625Sdim << '\n'; 435283625Sdim outs() << CTName << "[VirtualBaseAdjustmentOffset]: " 436283625Sdim << CT.VirtualBaseAdjustmentOffset << '\n'; 437283625Sdim outs() << CTName << "[Size]: " << CT.Size << '\n'; 438283625Sdim outs() << CTName 439283625Sdim << "[CopyCtor]: " << (CT.Symbols[1].empty() ? "null" : CT.Symbols[1]) 440283625Sdim << '\n'; 441283625Sdim } 442283625Sdim for (const auto &VTTPair : VTTEntries) { 443283625Sdim StringRef VTTName = VTTPair.first.first; 444283625Sdim uint64_t VTTOffset = VTTPair.first.second; 445283625Sdim StringRef VTTEntry = VTTPair.second; 446283625Sdim outs() << VTTName << '[' << VTTOffset << "]: " << VTTEntry << '\n'; 447283625Sdim } 448283625Sdim for (const auto &TIPair : TINames) { 449283625Sdim StringRef TIName = TIPair.first; 450283625Sdim outs() << TIName << ": " << TIPair.second << '\n'; 451283625Sdim } 452283625Sdim auto VTableSymI = VTableSymEntries.begin(); 453283625Sdim auto VTableSymE = VTableSymEntries.end(); 454283625Sdim auto VTableDataI = VTableDataEntries.begin(); 455283625Sdim auto VTableDataE = VTableDataEntries.end(); 456283625Sdim for (;;) { 457283625Sdim bool SymDone = VTableSymI == VTableSymE; 458283625Sdim bool DataDone = VTableDataI == VTableDataE; 459283625Sdim if (SymDone && DataDone) 460283625Sdim break; 461283625Sdim if (!SymDone && (DataDone || VTableSymI->first < VTableDataI->first)) { 462283625Sdim StringRef VTableName = VTableSymI->first.first; 463283625Sdim uint64_t Offset = VTableSymI->first.second; 464283625Sdim StringRef VTableEntry = VTableSymI->second; 465283625Sdim outs() << VTableName << '[' << Offset << "]: "; 466283625Sdim outs() << VTableEntry; 467283625Sdim outs() << '\n'; 468283625Sdim ++VTableSymI; 469283625Sdim continue; 470283625Sdim } 471283625Sdim if (!DataDone && (SymDone || VTableDataI->first < VTableSymI->first)) { 472283625Sdim StringRef VTableName = VTableDataI->first.first; 473283625Sdim uint64_t Offset = VTableDataI->first.second; 474283625Sdim int64_t VTableEntry = VTableDataI->second; 475283625Sdim outs() << VTableName << '[' << Offset << "]: "; 476283625Sdim outs() << VTableEntry; 477283625Sdim outs() << '\n'; 478283625Sdim ++VTableDataI; 479283625Sdim continue; 480283625Sdim } 481283625Sdim } 482283625Sdim} 483283625Sdim 484283625Sdimstatic void dumpArchive(const Archive *Arc) { 485296417Sdim for (auto &ErrorOrChild : Arc->children()) { 486296417Sdim error(ErrorOrChild.getError()); 487296417Sdim const Archive::Child &ArcC = *ErrorOrChild; 488283625Sdim ErrorOr<std::unique_ptr<Binary>> ChildOrErr = ArcC.getAsBinary(); 489283625Sdim if (std::error_code EC = ChildOrErr.getError()) { 490283625Sdim // Ignore non-object files. 491283625Sdim if (EC != object_error::invalid_file_type) 492283625Sdim reportError(Arc->getFileName(), EC.message()); 493283625Sdim continue; 494283625Sdim } 495283625Sdim 496283625Sdim if (ObjectFile *Obj = dyn_cast<ObjectFile>(&*ChildOrErr.get())) 497283625Sdim dumpCXXData(Obj); 498283625Sdim else 499283625Sdim reportError(Arc->getFileName(), cxxdump_error::unrecognized_file_format); 500283625Sdim } 501283625Sdim} 502283625Sdim 503283625Sdimstatic void dumpInput(StringRef File) { 504283625Sdim // Attempt to open the binary. 505283625Sdim ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(File); 506283625Sdim if (std::error_code EC = BinaryOrErr.getError()) { 507283625Sdim reportError(File, EC); 508283625Sdim return; 509283625Sdim } 510283625Sdim Binary &Binary = *BinaryOrErr.get().getBinary(); 511283625Sdim 512283625Sdim if (Archive *Arc = dyn_cast<Archive>(&Binary)) 513283625Sdim dumpArchive(Arc); 514283625Sdim else if (ObjectFile *Obj = dyn_cast<ObjectFile>(&Binary)) 515283625Sdim dumpCXXData(Obj); 516283625Sdim else 517283625Sdim reportError(File, cxxdump_error::unrecognized_file_format); 518283625Sdim} 519283625Sdim 520283625Sdimint main(int argc, const char *argv[]) { 521283625Sdim sys::PrintStackTraceOnErrorSignal(); 522283625Sdim PrettyStackTraceProgram X(argc, argv); 523283625Sdim llvm_shutdown_obj Y; 524283625Sdim 525283625Sdim // Initialize targets. 526283625Sdim llvm::InitializeAllTargetInfos(); 527283625Sdim 528283625Sdim // Register the target printer for --version. 529283625Sdim cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion); 530283625Sdim 531283625Sdim cl::ParseCommandLineOptions(argc, argv, "LLVM C++ ABI Data Dumper\n"); 532283625Sdim 533283625Sdim // Default to stdin if no filename is specified. 534283625Sdim if (opts::InputFilenames.size() == 0) 535283625Sdim opts::InputFilenames.push_back("-"); 536283625Sdim 537283625Sdim std::for_each(opts::InputFilenames.begin(), opts::InputFilenames.end(), 538283625Sdim dumpInput); 539283625Sdim 540296417Sdim return EXIT_SUCCESS; 541283625Sdim} 542