1 //===-- COFFDumper.cpp - COFF-specific dumper -------------------*- 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 /// \file 11 /// \brief This file implements the COFF-specific dumper for llvm-readobj. 12 /// 13 //===----------------------------------------------------------------------===// 14 15 #include "ARMWinEHPrinter.h" 16 #include "CodeView.h" 17 #include "Error.h" 18 #include "ObjDumper.h" 19 #include "StackMapPrinter.h" 20 #include "Win64EHDumper.h" 21 #include "llvm-readobj.h" 22 #include "llvm/ADT/DenseMap.h" 23 #include "llvm/ADT/SmallString.h" 24 #include "llvm/ADT/StringExtras.h" 25 #include "llvm/DebugInfo/CodeView/CVTypeDumper.h" 26 #include "llvm/DebugInfo/CodeView/CodeView.h" 27 #include "llvm/DebugInfo/CodeView/Line.h" 28 #include "llvm/DebugInfo/CodeView/RecordSerialization.h" 29 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h" 30 #include "llvm/DebugInfo/CodeView/SymbolDumpDelegate.h" 31 #include "llvm/DebugInfo/CodeView/SymbolDumper.h" 32 #include "llvm/DebugInfo/CodeView/SymbolRecord.h" 33 #include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h" 34 #include "llvm/DebugInfo/CodeView/TypeIndex.h" 35 #include "llvm/DebugInfo/CodeView/TypeRecord.h" 36 #include "llvm/DebugInfo/CodeView/TypeStreamMerger.h" 37 #include "llvm/DebugInfo/CodeView/TypeTableBuilder.h" 38 #include "llvm/DebugInfo/MSF/BinaryByteStream.h" 39 #include "llvm/Object/COFF.h" 40 #include "llvm/Object/ObjectFile.h" 41 #include "llvm/Support/COFF.h" 42 #include "llvm/Support/Casting.h" 43 #include "llvm/Support/Compiler.h" 44 #include "llvm/Support/DataExtractor.h" 45 #include "llvm/Support/Format.h" 46 #include "llvm/Support/Path.h" 47 #include "llvm/Support/ScopedPrinter.h" 48 #include "llvm/Support/SourceMgr.h" 49 #include "llvm/Support/Win64EH.h" 50 #include "llvm/Support/raw_ostream.h" 51 #include <algorithm> 52 #include <cstring> 53 #include <system_error> 54 #include <time.h> 55 56 using namespace llvm; 57 using namespace llvm::object; 58 using namespace llvm::codeview; 59 using namespace llvm::support; 60 using namespace llvm::Win64EH; 61 62 namespace { 63 64 class COFFDumper : public ObjDumper { 65 public: 66 friend class COFFObjectDumpDelegate; 67 COFFDumper(const llvm::object::COFFObjectFile *Obj, ScopedPrinter &Writer) 68 : ObjDumper(Writer), Obj(Obj), Writer(Writer) {} 69 70 void printFileHeaders() override; 71 void printSections() override; 72 void printRelocations() override; 73 void printSymbols() override; 74 void printDynamicSymbols() override; 75 void printUnwindInfo() override; 76 void printCOFFImports() override; 77 void printCOFFExports() override; 78 void printCOFFDirectives() override; 79 void printCOFFBaseReloc() override; 80 void printCOFFDebugDirectory() override; 81 void printCodeViewDebugInfo() override; 82 void mergeCodeViewTypes(llvm::codeview::TypeTableBuilder &CVTypes) override; 83 void printStackMap() const override; 84 private: 85 void printSymbol(const SymbolRef &Sym); 86 void printRelocation(const SectionRef &Section, const RelocationRef &Reloc, 87 uint64_t Bias = 0); 88 void printDataDirectory(uint32_t Index, const std::string &FieldName); 89 90 void printDOSHeader(const dos_header *DH); 91 template <class PEHeader> void printPEHeader(const PEHeader *Hdr); 92 void printBaseOfDataField(const pe32_header *Hdr); 93 void printBaseOfDataField(const pe32plus_header *Hdr); 94 95 void printCodeViewSymbolSection(StringRef SectionName, const SectionRef &Section); 96 void printCodeViewTypeSection(StringRef SectionName, const SectionRef &Section); 97 StringRef getTypeName(TypeIndex Ty); 98 StringRef getFileNameForFileOffset(uint32_t FileOffset); 99 void printFileNameForOffset(StringRef Label, uint32_t FileOffset); 100 void printTypeIndex(StringRef FieldName, TypeIndex TI) { 101 // Forward to CVTypeDumper for simplicity. 102 CVTypeDumper::printTypeIndex(Writer, FieldName, TI, TypeDB); 103 } 104 105 void printCodeViewSymbolsSubsection(StringRef Subsection, 106 const SectionRef &Section, 107 StringRef SectionContents); 108 109 void printCodeViewFileChecksums(StringRef Subsection); 110 111 void printCodeViewInlineeLines(StringRef Subsection); 112 113 void printRelocatedField(StringRef Label, const coff_section *Sec, 114 uint32_t RelocOffset, uint32_t Offset, 115 StringRef *RelocSym = nullptr); 116 117 void printBinaryBlockWithRelocs(StringRef Label, const SectionRef &Sec, 118 StringRef SectionContents, StringRef Block); 119 120 /// Given a .debug$S section, find the string table and file checksum table. 121 void initializeFileAndStringTables(StringRef Data); 122 123 void cacheRelocations(); 124 125 std::error_code resolveSymbol(const coff_section *Section, uint64_t Offset, 126 SymbolRef &Sym); 127 std::error_code resolveSymbolName(const coff_section *Section, 128 uint64_t Offset, StringRef &Name); 129 std::error_code resolveSymbolName(const coff_section *Section, 130 StringRef SectionContents, 131 const void *RelocPtr, StringRef &Name); 132 void printImportedSymbols(iterator_range<imported_symbol_iterator> Range); 133 void printDelayImportedSymbols( 134 const DelayImportDirectoryEntryRef &I, 135 iterator_range<imported_symbol_iterator> Range); 136 137 typedef DenseMap<const coff_section*, std::vector<RelocationRef> > RelocMapTy; 138 139 const llvm::object::COFFObjectFile *Obj; 140 bool RelocCached = false; 141 RelocMapTy RelocMap; 142 StringRef CVFileChecksumTable; 143 StringRef CVStringTable; 144 145 ScopedPrinter &Writer; 146 TypeDatabase TypeDB; 147 }; 148 149 class COFFObjectDumpDelegate : public SymbolDumpDelegate { 150 public: 151 COFFObjectDumpDelegate(COFFDumper &CD, const SectionRef &SR, 152 const COFFObjectFile *Obj, StringRef SectionContents) 153 : CD(CD), SR(SR), SectionContents(SectionContents) { 154 Sec = Obj->getCOFFSection(SR); 155 } 156 157 uint32_t getRecordOffset(BinaryStreamReader Reader) override { 158 ArrayRef<uint8_t> Data; 159 if (auto EC = Reader.readLongestContiguousChunk(Data)) { 160 llvm::consumeError(std::move(EC)); 161 return 0; 162 } 163 return Data.data() - SectionContents.bytes_begin(); 164 } 165 166 void printRelocatedField(StringRef Label, uint32_t RelocOffset, 167 uint32_t Offset, StringRef *RelocSym) override { 168 CD.printRelocatedField(Label, Sec, RelocOffset, Offset, RelocSym); 169 } 170 171 void printBinaryBlockWithRelocs(StringRef Label, 172 ArrayRef<uint8_t> Block) override { 173 StringRef SBlock(reinterpret_cast<const char *>(Block.data()), 174 Block.size()); 175 if (opts::CodeViewSubsectionBytes) 176 CD.printBinaryBlockWithRelocs(Label, SR, SectionContents, SBlock); 177 } 178 179 StringRef getFileNameForFileOffset(uint32_t FileOffset) override { 180 return CD.getFileNameForFileOffset(FileOffset); 181 } 182 183 StringRef getStringTable() override { return CD.CVStringTable; } 184 185 private: 186 COFFDumper &CD; 187 const SectionRef &SR; 188 const coff_section *Sec; 189 StringRef SectionContents; 190 }; 191 192 } // end namespace 193 194 namespace llvm { 195 196 std::error_code createCOFFDumper(const object::ObjectFile *Obj, 197 ScopedPrinter &Writer, 198 std::unique_ptr<ObjDumper> &Result) { 199 const COFFObjectFile *COFFObj = dyn_cast<COFFObjectFile>(Obj); 200 if (!COFFObj) 201 return readobj_error::unsupported_obj_file_format; 202 203 Result.reset(new COFFDumper(COFFObj, Writer)); 204 return readobj_error::success; 205 } 206 207 } // namespace llvm 208 209 // Given a a section and an offset into this section the function returns the 210 // symbol used for the relocation at the offset. 211 std::error_code COFFDumper::resolveSymbol(const coff_section *Section, 212 uint64_t Offset, SymbolRef &Sym) { 213 cacheRelocations(); 214 const auto &Relocations = RelocMap[Section]; 215 auto SymI = Obj->symbol_end(); 216 for (const auto &Relocation : Relocations) { 217 uint64_t RelocationOffset = Relocation.getOffset(); 218 219 if (RelocationOffset == Offset) { 220 SymI = Relocation.getSymbol(); 221 break; 222 } 223 } 224 if (SymI == Obj->symbol_end()) 225 return readobj_error::unknown_symbol; 226 Sym = *SymI; 227 return readobj_error::success; 228 } 229 230 // Given a section and an offset into this section the function returns the name 231 // of the symbol used for the relocation at the offset. 232 std::error_code COFFDumper::resolveSymbolName(const coff_section *Section, 233 uint64_t Offset, 234 StringRef &Name) { 235 SymbolRef Symbol; 236 if (std::error_code EC = resolveSymbol(Section, Offset, Symbol)) 237 return EC; 238 Expected<StringRef> NameOrErr = Symbol.getName(); 239 if (!NameOrErr) 240 return errorToErrorCode(NameOrErr.takeError()); 241 Name = *NameOrErr; 242 return std::error_code(); 243 } 244 245 // Helper for when you have a pointer to real data and you want to know about 246 // relocations against it. 247 std::error_code COFFDumper::resolveSymbolName(const coff_section *Section, 248 StringRef SectionContents, 249 const void *RelocPtr, 250 StringRef &Name) { 251 assert(SectionContents.data() < RelocPtr && 252 RelocPtr < SectionContents.data() + SectionContents.size() && 253 "pointer to relocated object is not in section"); 254 uint64_t Offset = ptrdiff_t(reinterpret_cast<const char *>(RelocPtr) - 255 SectionContents.data()); 256 return resolveSymbolName(Section, Offset, Name); 257 } 258 259 void COFFDumper::printRelocatedField(StringRef Label, const coff_section *Sec, 260 uint32_t RelocOffset, uint32_t Offset, 261 StringRef *RelocSym) { 262 StringRef SymStorage; 263 StringRef &Symbol = RelocSym ? *RelocSym : SymStorage; 264 if (!resolveSymbolName(Sec, RelocOffset, Symbol)) 265 W.printSymbolOffset(Label, Symbol, Offset); 266 else 267 W.printHex(Label, RelocOffset); 268 } 269 270 void COFFDumper::printBinaryBlockWithRelocs(StringRef Label, 271 const SectionRef &Sec, 272 StringRef SectionContents, 273 StringRef Block) { 274 W.printBinaryBlock(Label, Block); 275 276 assert(SectionContents.begin() < Block.begin() && 277 SectionContents.end() >= Block.end() && 278 "Block is not contained in SectionContents"); 279 uint64_t OffsetStart = Block.data() - SectionContents.data(); 280 uint64_t OffsetEnd = OffsetStart + Block.size(); 281 282 W.flush(); 283 cacheRelocations(); 284 ListScope D(W, "BlockRelocations"); 285 const coff_section *Section = Obj->getCOFFSection(Sec); 286 const auto &Relocations = RelocMap[Section]; 287 for (const auto &Relocation : Relocations) { 288 uint64_t RelocationOffset = Relocation.getOffset(); 289 if (OffsetStart <= RelocationOffset && RelocationOffset < OffsetEnd) 290 printRelocation(Sec, Relocation, OffsetStart); 291 } 292 } 293 294 static const EnumEntry<COFF::MachineTypes> ImageFileMachineType[] = { 295 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_UNKNOWN ), 296 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_AM33 ), 297 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_AMD64 ), 298 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM ), 299 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARMNT ), 300 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_EBC ), 301 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_I386 ), 302 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_IA64 ), 303 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_M32R ), 304 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPS16 ), 305 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPSFPU ), 306 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPSFPU16), 307 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_POWERPC ), 308 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_POWERPCFP), 309 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_R4000 ), 310 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH3 ), 311 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH3DSP ), 312 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH4 ), 313 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH5 ), 314 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_THUMB ), 315 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_WCEMIPSV2) 316 }; 317 318 static const EnumEntry<COFF::Characteristics> ImageFileCharacteristics[] = { 319 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_RELOCS_STRIPPED ), 320 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_EXECUTABLE_IMAGE ), 321 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LINE_NUMS_STRIPPED ), 322 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LOCAL_SYMS_STRIPPED ), 323 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_AGGRESSIVE_WS_TRIM ), 324 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LARGE_ADDRESS_AWARE ), 325 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_LO ), 326 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_32BIT_MACHINE ), 327 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_DEBUG_STRIPPED ), 328 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP), 329 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_NET_RUN_FROM_SWAP ), 330 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_SYSTEM ), 331 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_DLL ), 332 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_UP_SYSTEM_ONLY ), 333 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_HI ) 334 }; 335 336 static const EnumEntry<COFF::WindowsSubsystem> PEWindowsSubsystem[] = { 337 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_UNKNOWN ), 338 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_NATIVE ), 339 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_GUI ), 340 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_CUI ), 341 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_POSIX_CUI ), 342 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI ), 343 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_APPLICATION ), 344 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER), 345 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER ), 346 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_ROM ), 347 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_XBOX ), 348 }; 349 350 static const EnumEntry<COFF::DLLCharacteristics> PEDLLCharacteristics[] = { 351 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA ), 352 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE ), 353 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY ), 354 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NX_COMPAT ), 355 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_ISOLATION ), 356 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_SEH ), 357 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_BIND ), 358 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_APPCONTAINER ), 359 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_WDM_DRIVER ), 360 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_GUARD_CF ), 361 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE), 362 }; 363 364 static const EnumEntry<COFF::SectionCharacteristics> 365 ImageSectionCharacteristics[] = { 366 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NOLOAD ), 367 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NO_PAD ), 368 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_CODE ), 369 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_INITIALIZED_DATA ), 370 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_UNINITIALIZED_DATA), 371 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_OTHER ), 372 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_INFO ), 373 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_REMOVE ), 374 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_COMDAT ), 375 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_GPREL ), 376 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_PURGEABLE ), 377 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_16BIT ), 378 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_LOCKED ), 379 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_PRELOAD ), 380 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1BYTES ), 381 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2BYTES ), 382 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4BYTES ), 383 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8BYTES ), 384 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_16BYTES ), 385 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_32BYTES ), 386 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_64BYTES ), 387 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_128BYTES ), 388 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_256BYTES ), 389 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_512BYTES ), 390 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1024BYTES ), 391 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2048BYTES ), 392 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4096BYTES ), 393 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8192BYTES ), 394 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_NRELOC_OVFL ), 395 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_DISCARDABLE ), 396 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_CACHED ), 397 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_PAGED ), 398 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_SHARED ), 399 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_EXECUTE ), 400 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_READ ), 401 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_WRITE ) 402 }; 403 404 static const EnumEntry<COFF::SymbolBaseType> ImageSymType[] = { 405 { "Null" , COFF::IMAGE_SYM_TYPE_NULL }, 406 { "Void" , COFF::IMAGE_SYM_TYPE_VOID }, 407 { "Char" , COFF::IMAGE_SYM_TYPE_CHAR }, 408 { "Short" , COFF::IMAGE_SYM_TYPE_SHORT }, 409 { "Int" , COFF::IMAGE_SYM_TYPE_INT }, 410 { "Long" , COFF::IMAGE_SYM_TYPE_LONG }, 411 { "Float" , COFF::IMAGE_SYM_TYPE_FLOAT }, 412 { "Double", COFF::IMAGE_SYM_TYPE_DOUBLE }, 413 { "Struct", COFF::IMAGE_SYM_TYPE_STRUCT }, 414 { "Union" , COFF::IMAGE_SYM_TYPE_UNION }, 415 { "Enum" , COFF::IMAGE_SYM_TYPE_ENUM }, 416 { "MOE" , COFF::IMAGE_SYM_TYPE_MOE }, 417 { "Byte" , COFF::IMAGE_SYM_TYPE_BYTE }, 418 { "Word" , COFF::IMAGE_SYM_TYPE_WORD }, 419 { "UInt" , COFF::IMAGE_SYM_TYPE_UINT }, 420 { "DWord" , COFF::IMAGE_SYM_TYPE_DWORD } 421 }; 422 423 static const EnumEntry<COFF::SymbolComplexType> ImageSymDType[] = { 424 { "Null" , COFF::IMAGE_SYM_DTYPE_NULL }, 425 { "Pointer" , COFF::IMAGE_SYM_DTYPE_POINTER }, 426 { "Function", COFF::IMAGE_SYM_DTYPE_FUNCTION }, 427 { "Array" , COFF::IMAGE_SYM_DTYPE_ARRAY } 428 }; 429 430 static const EnumEntry<COFF::SymbolStorageClass> ImageSymClass[] = { 431 { "EndOfFunction" , COFF::IMAGE_SYM_CLASS_END_OF_FUNCTION }, 432 { "Null" , COFF::IMAGE_SYM_CLASS_NULL }, 433 { "Automatic" , COFF::IMAGE_SYM_CLASS_AUTOMATIC }, 434 { "External" , COFF::IMAGE_SYM_CLASS_EXTERNAL }, 435 { "Static" , COFF::IMAGE_SYM_CLASS_STATIC }, 436 { "Register" , COFF::IMAGE_SYM_CLASS_REGISTER }, 437 { "ExternalDef" , COFF::IMAGE_SYM_CLASS_EXTERNAL_DEF }, 438 { "Label" , COFF::IMAGE_SYM_CLASS_LABEL }, 439 { "UndefinedLabel" , COFF::IMAGE_SYM_CLASS_UNDEFINED_LABEL }, 440 { "MemberOfStruct" , COFF::IMAGE_SYM_CLASS_MEMBER_OF_STRUCT }, 441 { "Argument" , COFF::IMAGE_SYM_CLASS_ARGUMENT }, 442 { "StructTag" , COFF::IMAGE_SYM_CLASS_STRUCT_TAG }, 443 { "MemberOfUnion" , COFF::IMAGE_SYM_CLASS_MEMBER_OF_UNION }, 444 { "UnionTag" , COFF::IMAGE_SYM_CLASS_UNION_TAG }, 445 { "TypeDefinition" , COFF::IMAGE_SYM_CLASS_TYPE_DEFINITION }, 446 { "UndefinedStatic", COFF::IMAGE_SYM_CLASS_UNDEFINED_STATIC }, 447 { "EnumTag" , COFF::IMAGE_SYM_CLASS_ENUM_TAG }, 448 { "MemberOfEnum" , COFF::IMAGE_SYM_CLASS_MEMBER_OF_ENUM }, 449 { "RegisterParam" , COFF::IMAGE_SYM_CLASS_REGISTER_PARAM }, 450 { "BitField" , COFF::IMAGE_SYM_CLASS_BIT_FIELD }, 451 { "Block" , COFF::IMAGE_SYM_CLASS_BLOCK }, 452 { "Function" , COFF::IMAGE_SYM_CLASS_FUNCTION }, 453 { "EndOfStruct" , COFF::IMAGE_SYM_CLASS_END_OF_STRUCT }, 454 { "File" , COFF::IMAGE_SYM_CLASS_FILE }, 455 { "Section" , COFF::IMAGE_SYM_CLASS_SECTION }, 456 { "WeakExternal" , COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL }, 457 { "CLRToken" , COFF::IMAGE_SYM_CLASS_CLR_TOKEN } 458 }; 459 460 static const EnumEntry<COFF::COMDATType> ImageCOMDATSelect[] = { 461 { "NoDuplicates", COFF::IMAGE_COMDAT_SELECT_NODUPLICATES }, 462 { "Any" , COFF::IMAGE_COMDAT_SELECT_ANY }, 463 { "SameSize" , COFF::IMAGE_COMDAT_SELECT_SAME_SIZE }, 464 { "ExactMatch" , COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH }, 465 { "Associative" , COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE }, 466 { "Largest" , COFF::IMAGE_COMDAT_SELECT_LARGEST }, 467 { "Newest" , COFF::IMAGE_COMDAT_SELECT_NEWEST } 468 }; 469 470 static const EnumEntry<COFF::DebugType> ImageDebugType[] = { 471 { "Unknown" , COFF::IMAGE_DEBUG_TYPE_UNKNOWN }, 472 { "COFF" , COFF::IMAGE_DEBUG_TYPE_COFF }, 473 { "CodeView" , COFF::IMAGE_DEBUG_TYPE_CODEVIEW }, 474 { "FPO" , COFF::IMAGE_DEBUG_TYPE_FPO }, 475 { "Misc" , COFF::IMAGE_DEBUG_TYPE_MISC }, 476 { "Exception" , COFF::IMAGE_DEBUG_TYPE_EXCEPTION }, 477 { "Fixup" , COFF::IMAGE_DEBUG_TYPE_FIXUP }, 478 { "OmapToSrc" , COFF::IMAGE_DEBUG_TYPE_OMAP_TO_SRC }, 479 { "OmapFromSrc", COFF::IMAGE_DEBUG_TYPE_OMAP_FROM_SRC }, 480 { "Borland" , COFF::IMAGE_DEBUG_TYPE_BORLAND }, 481 { "Reserved10" , COFF::IMAGE_DEBUG_TYPE_RESERVED10 }, 482 { "CLSID" , COFF::IMAGE_DEBUG_TYPE_CLSID }, 483 { "VCFeature" , COFF::IMAGE_DEBUG_TYPE_VC_FEATURE }, 484 { "POGO" , COFF::IMAGE_DEBUG_TYPE_POGO }, 485 { "ILTCG" , COFF::IMAGE_DEBUG_TYPE_ILTCG }, 486 { "MPX" , COFF::IMAGE_DEBUG_TYPE_MPX }, 487 { "Repro" , COFF::IMAGE_DEBUG_TYPE_REPRO }, 488 }; 489 490 static const EnumEntry<COFF::WeakExternalCharacteristics> 491 WeakExternalCharacteristics[] = { 492 { "NoLibrary", COFF::IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY }, 493 { "Library" , COFF::IMAGE_WEAK_EXTERN_SEARCH_LIBRARY }, 494 { "Alias" , COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS } 495 }; 496 497 static const EnumEntry<uint32_t> SubSectionTypes[] = { 498 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, Symbols), 499 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, Lines), 500 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, StringTable), 501 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, FileChecksums), 502 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, FrameData), 503 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, InlineeLines), 504 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, CrossScopeImports), 505 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, CrossScopeExports), 506 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, ILLines), 507 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, FuncMDTokenMap), 508 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, TypeMDTokenMap), 509 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, MergedAssemblyInput), 510 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, CoffSymbolRVA), 511 }; 512 513 static const EnumEntry<uint32_t> FrameDataFlags[] = { 514 LLVM_READOBJ_ENUM_ENT(FrameData, HasSEH), 515 LLVM_READOBJ_ENUM_ENT(FrameData, HasEH), 516 LLVM_READOBJ_ENUM_ENT(FrameData, IsFunctionStart), 517 }; 518 519 static const EnumEntry<uint8_t> FileChecksumKindNames[] = { 520 LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, None), 521 LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, MD5), 522 LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, SHA1), 523 LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, SHA256), 524 }; 525 526 template <typename T> 527 static std::error_code getSymbolAuxData(const COFFObjectFile *Obj, 528 COFFSymbolRef Symbol, 529 uint8_t AuxSymbolIdx, const T *&Aux) { 530 ArrayRef<uint8_t> AuxData = Obj->getSymbolAuxData(Symbol); 531 AuxData = AuxData.slice(AuxSymbolIdx * Obj->getSymbolTableEntrySize()); 532 Aux = reinterpret_cast<const T*>(AuxData.data()); 533 return readobj_error::success; 534 } 535 536 void COFFDumper::cacheRelocations() { 537 if (RelocCached) 538 return; 539 RelocCached = true; 540 541 for (const SectionRef &S : Obj->sections()) { 542 const coff_section *Section = Obj->getCOFFSection(S); 543 544 for (const RelocationRef &Reloc : S.relocations()) 545 RelocMap[Section].push_back(Reloc); 546 547 // Sort relocations by address. 548 std::sort(RelocMap[Section].begin(), RelocMap[Section].end(), 549 relocAddressLess); 550 } 551 } 552 553 void COFFDumper::printDataDirectory(uint32_t Index, const std::string &FieldName) { 554 const data_directory *Data; 555 if (Obj->getDataDirectory(Index, Data)) 556 return; 557 W.printHex(FieldName + "RVA", Data->RelativeVirtualAddress); 558 W.printHex(FieldName + "Size", Data->Size); 559 } 560 561 void COFFDumper::printFileHeaders() { 562 time_t TDS = Obj->getTimeDateStamp(); 563 char FormattedTime[20] = { }; 564 strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS)); 565 566 { 567 DictScope D(W, "ImageFileHeader"); 568 W.printEnum ("Machine", Obj->getMachine(), 569 makeArrayRef(ImageFileMachineType)); 570 W.printNumber("SectionCount", Obj->getNumberOfSections()); 571 W.printHex ("TimeDateStamp", FormattedTime, Obj->getTimeDateStamp()); 572 W.printHex ("PointerToSymbolTable", Obj->getPointerToSymbolTable()); 573 W.printNumber("SymbolCount", Obj->getNumberOfSymbols()); 574 W.printNumber("OptionalHeaderSize", Obj->getSizeOfOptionalHeader()); 575 W.printFlags ("Characteristics", Obj->getCharacteristics(), 576 makeArrayRef(ImageFileCharacteristics)); 577 } 578 579 // Print PE header. This header does not exist if this is an object file and 580 // not an executable. 581 const pe32_header *PEHeader = nullptr; 582 error(Obj->getPE32Header(PEHeader)); 583 if (PEHeader) 584 printPEHeader<pe32_header>(PEHeader); 585 586 const pe32plus_header *PEPlusHeader = nullptr; 587 error(Obj->getPE32PlusHeader(PEPlusHeader)); 588 if (PEPlusHeader) 589 printPEHeader<pe32plus_header>(PEPlusHeader); 590 591 if (const dos_header *DH = Obj->getDOSHeader()) 592 printDOSHeader(DH); 593 } 594 595 void COFFDumper::printDOSHeader(const dos_header *DH) { 596 DictScope D(W, "DOSHeader"); 597 W.printString("Magic", StringRef(DH->Magic, sizeof(DH->Magic))); 598 W.printNumber("UsedBytesInTheLastPage", DH->UsedBytesInTheLastPage); 599 W.printNumber("FileSizeInPages", DH->FileSizeInPages); 600 W.printNumber("NumberOfRelocationItems", DH->NumberOfRelocationItems); 601 W.printNumber("HeaderSizeInParagraphs", DH->HeaderSizeInParagraphs); 602 W.printNumber("MinimumExtraParagraphs", DH->MinimumExtraParagraphs); 603 W.printNumber("MaximumExtraParagraphs", DH->MaximumExtraParagraphs); 604 W.printNumber("InitialRelativeSS", DH->InitialRelativeSS); 605 W.printNumber("InitialSP", DH->InitialSP); 606 W.printNumber("Checksum", DH->Checksum); 607 W.printNumber("InitialIP", DH->InitialIP); 608 W.printNumber("InitialRelativeCS", DH->InitialRelativeCS); 609 W.printNumber("AddressOfRelocationTable", DH->AddressOfRelocationTable); 610 W.printNumber("OverlayNumber", DH->OverlayNumber); 611 W.printNumber("OEMid", DH->OEMid); 612 W.printNumber("OEMinfo", DH->OEMinfo); 613 W.printNumber("AddressOfNewExeHeader", DH->AddressOfNewExeHeader); 614 } 615 616 template <class PEHeader> 617 void COFFDumper::printPEHeader(const PEHeader *Hdr) { 618 DictScope D(W, "ImageOptionalHeader"); 619 W.printNumber("MajorLinkerVersion", Hdr->MajorLinkerVersion); 620 W.printNumber("MinorLinkerVersion", Hdr->MinorLinkerVersion); 621 W.printNumber("SizeOfCode", Hdr->SizeOfCode); 622 W.printNumber("SizeOfInitializedData", Hdr->SizeOfInitializedData); 623 W.printNumber("SizeOfUninitializedData", Hdr->SizeOfUninitializedData); 624 W.printHex ("AddressOfEntryPoint", Hdr->AddressOfEntryPoint); 625 W.printHex ("BaseOfCode", Hdr->BaseOfCode); 626 printBaseOfDataField(Hdr); 627 W.printHex ("ImageBase", Hdr->ImageBase); 628 W.printNumber("SectionAlignment", Hdr->SectionAlignment); 629 W.printNumber("FileAlignment", Hdr->FileAlignment); 630 W.printNumber("MajorOperatingSystemVersion", 631 Hdr->MajorOperatingSystemVersion); 632 W.printNumber("MinorOperatingSystemVersion", 633 Hdr->MinorOperatingSystemVersion); 634 W.printNumber("MajorImageVersion", Hdr->MajorImageVersion); 635 W.printNumber("MinorImageVersion", Hdr->MinorImageVersion); 636 W.printNumber("MajorSubsystemVersion", Hdr->MajorSubsystemVersion); 637 W.printNumber("MinorSubsystemVersion", Hdr->MinorSubsystemVersion); 638 W.printNumber("SizeOfImage", Hdr->SizeOfImage); 639 W.printNumber("SizeOfHeaders", Hdr->SizeOfHeaders); 640 W.printEnum ("Subsystem", Hdr->Subsystem, makeArrayRef(PEWindowsSubsystem)); 641 W.printFlags ("Characteristics", Hdr->DLLCharacteristics, 642 makeArrayRef(PEDLLCharacteristics)); 643 W.printNumber("SizeOfStackReserve", Hdr->SizeOfStackReserve); 644 W.printNumber("SizeOfStackCommit", Hdr->SizeOfStackCommit); 645 W.printNumber("SizeOfHeapReserve", Hdr->SizeOfHeapReserve); 646 W.printNumber("SizeOfHeapCommit", Hdr->SizeOfHeapCommit); 647 W.printNumber("NumberOfRvaAndSize", Hdr->NumberOfRvaAndSize); 648 649 if (Hdr->NumberOfRvaAndSize > 0) { 650 DictScope D(W, "DataDirectory"); 651 static const char * const directory[] = { 652 "ExportTable", "ImportTable", "ResourceTable", "ExceptionTable", 653 "CertificateTable", "BaseRelocationTable", "Debug", "Architecture", 654 "GlobalPtr", "TLSTable", "LoadConfigTable", "BoundImport", "IAT", 655 "DelayImportDescriptor", "CLRRuntimeHeader", "Reserved" 656 }; 657 658 for (uint32_t i = 0; i < Hdr->NumberOfRvaAndSize; ++i) 659 printDataDirectory(i, directory[i]); 660 } 661 } 662 663 void COFFDumper::printCOFFDebugDirectory() { 664 ListScope LS(W, "DebugDirectory"); 665 for (const debug_directory &D : Obj->debug_directories()) { 666 char FormattedTime[20] = {}; 667 time_t TDS = D.TimeDateStamp; 668 strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS)); 669 DictScope S(W, "DebugEntry"); 670 W.printHex("Characteristics", D.Characteristics); 671 W.printHex("TimeDateStamp", FormattedTime, D.TimeDateStamp); 672 W.printHex("MajorVersion", D.MajorVersion); 673 W.printHex("MinorVersion", D.MinorVersion); 674 W.printEnum("Type", D.Type, makeArrayRef(ImageDebugType)); 675 W.printHex("SizeOfData", D.SizeOfData); 676 W.printHex("AddressOfRawData", D.AddressOfRawData); 677 W.printHex("PointerToRawData", D.PointerToRawData); 678 if (D.Type == COFF::IMAGE_DEBUG_TYPE_CODEVIEW) { 679 const codeview::DebugInfo *DebugInfo; 680 StringRef PDBFileName; 681 error(Obj->getDebugPDBInfo(&D, DebugInfo, PDBFileName)); 682 DictScope PDBScope(W, "PDBInfo"); 683 W.printHex("PDBSignature", DebugInfo->Signature.CVSignature); 684 if (DebugInfo->Signature.CVSignature == OMF::Signature::PDB70) { 685 W.printBinary("PDBGUID", makeArrayRef(DebugInfo->PDB70.Signature)); 686 W.printNumber("PDBAge", DebugInfo->PDB70.Age); 687 W.printString("PDBFileName", PDBFileName); 688 } 689 } else { 690 // FIXME: Type values of 12 and 13 are commonly observed but are not in 691 // the documented type enum. Figure out what they mean. 692 ArrayRef<uint8_t> RawData; 693 error( 694 Obj->getRvaAndSizeAsBytes(D.AddressOfRawData, D.SizeOfData, RawData)); 695 W.printBinaryBlock("RawData", RawData); 696 } 697 } 698 } 699 700 void COFFDumper::printBaseOfDataField(const pe32_header *Hdr) { 701 W.printHex("BaseOfData", Hdr->BaseOfData); 702 } 703 704 void COFFDumper::printBaseOfDataField(const pe32plus_header *) {} 705 706 void COFFDumper::printCodeViewDebugInfo() { 707 // Print types first to build CVUDTNames, then print symbols. 708 for (const SectionRef &S : Obj->sections()) { 709 StringRef SectionName; 710 error(S.getName(SectionName)); 711 if (SectionName == ".debug$T") 712 printCodeViewTypeSection(SectionName, S); 713 } 714 for (const SectionRef &S : Obj->sections()) { 715 StringRef SectionName; 716 error(S.getName(SectionName)); 717 if (SectionName == ".debug$S") 718 printCodeViewSymbolSection(SectionName, S); 719 } 720 } 721 722 void COFFDumper::initializeFileAndStringTables(StringRef Data) { 723 while (!Data.empty() && (CVFileChecksumTable.data() == nullptr || 724 CVStringTable.data() == nullptr)) { 725 // The section consists of a number of subsection in the following format: 726 // |SubSectionType|SubSectionSize|Contents...| 727 uint32_t SubType, SubSectionSize; 728 error(consume(Data, SubType)); 729 error(consume(Data, SubSectionSize)); 730 if (SubSectionSize > Data.size()) 731 return error(object_error::parse_failed); 732 switch (ModuleSubstreamKind(SubType)) { 733 case ModuleSubstreamKind::FileChecksums: 734 CVFileChecksumTable = Data.substr(0, SubSectionSize); 735 break; 736 case ModuleSubstreamKind::StringTable: 737 CVStringTable = Data.substr(0, SubSectionSize); 738 break; 739 default: 740 break; 741 } 742 uint32_t PaddedSize = alignTo(SubSectionSize, 4); 743 if (PaddedSize > Data.size()) 744 error(object_error::parse_failed); 745 Data = Data.drop_front(PaddedSize); 746 } 747 } 748 749 void COFFDumper::printCodeViewSymbolSection(StringRef SectionName, 750 const SectionRef &Section) { 751 StringRef SectionContents; 752 error(Section.getContents(SectionContents)); 753 StringRef Data = SectionContents; 754 755 SmallVector<StringRef, 10> FunctionNames; 756 StringMap<StringRef> FunctionLineTables; 757 758 ListScope D(W, "CodeViewDebugInfo"); 759 // Print the section to allow correlation with printSections. 760 W.printNumber("Section", SectionName, Obj->getSectionID(Section)); 761 762 uint32_t Magic; 763 error(consume(Data, Magic)); 764 W.printHex("Magic", Magic); 765 if (Magic != COFF::DEBUG_SECTION_MAGIC) 766 return error(object_error::parse_failed); 767 768 initializeFileAndStringTables(Data); 769 770 // TODO: Convert this over to using ModuleSubstreamVisitor. 771 while (!Data.empty()) { 772 // The section consists of a number of subsection in the following format: 773 // |SubSectionType|SubSectionSize|Contents...| 774 uint32_t SubType, SubSectionSize; 775 error(consume(Data, SubType)); 776 error(consume(Data, SubSectionSize)); 777 778 ListScope S(W, "Subsection"); 779 W.printEnum("SubSectionType", SubType, makeArrayRef(SubSectionTypes)); 780 W.printHex("SubSectionSize", SubSectionSize); 781 782 // Get the contents of the subsection. 783 if (SubSectionSize > Data.size()) 784 return error(object_error::parse_failed); 785 StringRef Contents = Data.substr(0, SubSectionSize); 786 787 // Add SubSectionSize to the current offset and align that offset to find 788 // the next subsection. 789 size_t SectionOffset = Data.data() - SectionContents.data(); 790 size_t NextOffset = SectionOffset + SubSectionSize; 791 NextOffset = alignTo(NextOffset, 4); 792 if (NextOffset > SectionContents.size()) 793 return error(object_error::parse_failed); 794 Data = SectionContents.drop_front(NextOffset); 795 796 // Optionally print the subsection bytes in case our parsing gets confused 797 // later. 798 if (opts::CodeViewSubsectionBytes) 799 printBinaryBlockWithRelocs("SubSectionContents", Section, SectionContents, 800 Contents); 801 802 switch (ModuleSubstreamKind(SubType)) { 803 case ModuleSubstreamKind::Symbols: 804 printCodeViewSymbolsSubsection(Contents, Section, SectionContents); 805 break; 806 807 case ModuleSubstreamKind::InlineeLines: 808 printCodeViewInlineeLines(Contents); 809 break; 810 811 case ModuleSubstreamKind::FileChecksums: 812 printCodeViewFileChecksums(Contents); 813 break; 814 815 case ModuleSubstreamKind::Lines: { 816 // Holds a PC to file:line table. Some data to parse this subsection is 817 // stored in the other subsections, so just check sanity and store the 818 // pointers for deferred processing. 819 820 if (SubSectionSize < 12) { 821 // There should be at least three words to store two function 822 // relocations and size of the code. 823 error(object_error::parse_failed); 824 return; 825 } 826 827 StringRef LinkageName; 828 error(resolveSymbolName(Obj->getCOFFSection(Section), SectionOffset, 829 LinkageName)); 830 W.printString("LinkageName", LinkageName); 831 if (FunctionLineTables.count(LinkageName) != 0) { 832 // Saw debug info for this function already? 833 error(object_error::parse_failed); 834 return; 835 } 836 837 FunctionLineTables[LinkageName] = Contents; 838 FunctionNames.push_back(LinkageName); 839 break; 840 } 841 case ModuleSubstreamKind::FrameData: { 842 // First four bytes is a relocation against the function. 843 BinaryByteStream S(Contents); 844 BinaryStreamReader SR(S); 845 const uint32_t *CodePtr; 846 error(SR.readObject(CodePtr)); 847 StringRef LinkageName; 848 error(resolveSymbolName(Obj->getCOFFSection(Section), SectionContents, 849 CodePtr, LinkageName)); 850 W.printString("LinkageName", LinkageName); 851 852 // To find the active frame description, search this array for the 853 // smallest PC range that includes the current PC. 854 while (!SR.empty()) { 855 const FrameData *FD; 856 error(SR.readObject(FD)); 857 858 if (FD->FrameFunc >= CVStringTable.size()) 859 error(object_error::parse_failed); 860 861 StringRef FrameFunc = 862 CVStringTable.drop_front(FD->FrameFunc).split('\0').first; 863 864 DictScope S(W, "FrameData"); 865 W.printHex("RvaStart", FD->RvaStart); 866 W.printHex("CodeSize", FD->CodeSize); 867 W.printHex("LocalSize", FD->LocalSize); 868 W.printHex("ParamsSize", FD->ParamsSize); 869 W.printHex("MaxStackSize", FD->MaxStackSize); 870 W.printString("FrameFunc", FrameFunc); 871 W.printHex("PrologSize", FD->PrologSize); 872 W.printHex("SavedRegsSize", FD->SavedRegsSize); 873 W.printFlags("Flags", FD->Flags, makeArrayRef(FrameDataFlags)); 874 } 875 break; 876 } 877 878 // Do nothing for unrecognized subsections. 879 default: 880 break; 881 } 882 W.flush(); 883 } 884 885 // Dump the line tables now that we've read all the subsections and know all 886 // the required information. 887 for (unsigned I = 0, E = FunctionNames.size(); I != E; ++I) { 888 StringRef Name = FunctionNames[I]; 889 ListScope S(W, "FunctionLineTable"); 890 W.printString("LinkageName", Name); 891 892 DataExtractor DE(FunctionLineTables[Name], true, 4); 893 uint32_t Offset = 6; // Skip relocations. 894 uint16_t Flags = DE.getU16(&Offset); 895 W.printHex("Flags", Flags); 896 bool HasColumnInformation = Flags & codeview::LineFlags::HaveColumns; 897 uint32_t FunctionSize = DE.getU32(&Offset); 898 W.printHex("CodeSize", FunctionSize); 899 while (DE.isValidOffset(Offset)) { 900 // For each range of lines with the same filename, we have a segment 901 // in the line table. The filename string is accessed using double 902 // indirection to the string table subsection using the index subsection. 903 uint32_t OffsetInIndex = DE.getU32(&Offset), 904 NumLines = DE.getU32(&Offset), 905 FullSegmentSize = DE.getU32(&Offset); 906 907 uint32_t ColumnOffset = Offset + 8 * NumLines; 908 DataExtractor ColumnDE(DE.getData(), true, 4); 909 910 if (FullSegmentSize != 911 12 + 8 * NumLines + (HasColumnInformation ? 4 * NumLines : 0)) { 912 error(object_error::parse_failed); 913 return; 914 } 915 916 ListScope S(W, "FilenameSegment"); 917 printFileNameForOffset("Filename", OffsetInIndex); 918 for (unsigned LineIdx = 0; 919 LineIdx != NumLines && DE.isValidOffset(Offset); ++LineIdx) { 920 // Then go the (PC, LineNumber) pairs. The line number is stored in the 921 // least significant 31 bits of the respective word in the table. 922 uint32_t PC = DE.getU32(&Offset), LineData = DE.getU32(&Offset); 923 if (PC >= FunctionSize) { 924 error(object_error::parse_failed); 925 return; 926 } 927 char Buffer[32]; 928 format("+0x%X", PC).snprint(Buffer, 32); 929 ListScope PCScope(W, Buffer); 930 LineInfo LI(LineData); 931 if (LI.isAlwaysStepInto()) 932 W.printString("StepInto", StringRef("Always")); 933 else if (LI.isNeverStepInto()) 934 W.printString("StepInto", StringRef("Never")); 935 else 936 W.printNumber("LineNumberStart", LI.getStartLine()); 937 W.printNumber("LineNumberEndDelta", LI.getLineDelta()); 938 W.printBoolean("IsStatement", LI.isStatement()); 939 if (HasColumnInformation && 940 ColumnDE.isValidOffsetForDataOfSize(ColumnOffset, 4)) { 941 uint16_t ColStart = ColumnDE.getU16(&ColumnOffset); 942 W.printNumber("ColStart", ColStart); 943 uint16_t ColEnd = ColumnDE.getU16(&ColumnOffset); 944 W.printNumber("ColEnd", ColEnd); 945 } 946 } 947 // Skip over the column data. 948 if (HasColumnInformation) { 949 for (unsigned LineIdx = 0; 950 LineIdx != NumLines && DE.isValidOffset(Offset); ++LineIdx) { 951 DE.getU32(&Offset); 952 } 953 } 954 } 955 } 956 } 957 958 void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection, 959 const SectionRef &Section, 960 StringRef SectionContents) { 961 ArrayRef<uint8_t> BinaryData(Subsection.bytes_begin(), 962 Subsection.bytes_end()); 963 auto CODD = llvm::make_unique<COFFObjectDumpDelegate>(*this, Section, Obj, 964 SectionContents); 965 966 CVSymbolDumper CVSD(W, TypeDB, std::move(CODD), 967 opts::CodeViewSubsectionBytes); 968 BinaryByteStream Stream(BinaryData); 969 CVSymbolArray Symbols; 970 BinaryStreamReader Reader(Stream); 971 if (auto EC = Reader.readArray(Symbols, Reader.getLength())) { 972 consumeError(std::move(EC)); 973 W.flush(); 974 error(object_error::parse_failed); 975 } 976 977 if (auto EC = CVSD.dump(Symbols)) { 978 W.flush(); 979 error(std::move(EC)); 980 } 981 W.flush(); 982 } 983 984 void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) { 985 BinaryByteStream S(Subsection); 986 BinaryStreamReader SR(S); 987 while (!SR.empty()) { 988 DictScope S(W, "FileChecksum"); 989 const FileChecksum *FC; 990 error(SR.readObject(FC)); 991 if (FC->FileNameOffset >= CVStringTable.size()) 992 error(object_error::parse_failed); 993 StringRef Filename = 994 CVStringTable.drop_front(FC->FileNameOffset).split('\0').first; 995 W.printHex("Filename", Filename, FC->FileNameOffset); 996 W.printHex("ChecksumSize", FC->ChecksumSize); 997 W.printEnum("ChecksumKind", uint8_t(FC->ChecksumKind), 998 makeArrayRef(FileChecksumKindNames)); 999 if (FC->ChecksumSize >= SR.bytesRemaining()) 1000 error(object_error::parse_failed); 1001 ArrayRef<uint8_t> ChecksumBytes; 1002 error(SR.readBytes(ChecksumBytes, FC->ChecksumSize)); 1003 W.printBinary("ChecksumBytes", ChecksumBytes); 1004 unsigned PaddedSize = alignTo(FC->ChecksumSize + sizeof(FileChecksum), 4) - 1005 sizeof(FileChecksum); 1006 PaddedSize -= ChecksumBytes.size(); 1007 if (PaddedSize > SR.bytesRemaining()) 1008 error(object_error::parse_failed); 1009 error(SR.skip(PaddedSize)); 1010 } 1011 } 1012 1013 void COFFDumper::printCodeViewInlineeLines(StringRef Subsection) { 1014 BinaryByteStream S(Subsection); 1015 BinaryStreamReader SR(S); 1016 uint32_t Signature; 1017 error(SR.readInteger(Signature, llvm::support::little)); 1018 bool HasExtraFiles = Signature == unsigned(InlineeLinesSignature::ExtraFiles); 1019 1020 while (!SR.empty()) { 1021 const InlineeSourceLine *ISL; 1022 error(SR.readObject(ISL)); 1023 DictScope S(W, "InlineeSourceLine"); 1024 printTypeIndex("Inlinee", ISL->Inlinee); 1025 printFileNameForOffset("FileID", ISL->FileID); 1026 W.printNumber("SourceLineNum", ISL->SourceLineNum); 1027 1028 if (HasExtraFiles) { 1029 uint32_t ExtraFileCount; 1030 error(SR.readInteger(ExtraFileCount, llvm::support::little)); 1031 W.printNumber("ExtraFileCount", ExtraFileCount); 1032 ListScope ExtraFiles(W, "ExtraFiles"); 1033 for (unsigned I = 0; I < ExtraFileCount; ++I) { 1034 uint32_t FileID; 1035 error(SR.readInteger(FileID, llvm::support::little)); 1036 printFileNameForOffset("FileID", FileID); 1037 } 1038 } 1039 } 1040 } 1041 1042 StringRef COFFDumper::getFileNameForFileOffset(uint32_t FileOffset) { 1043 // The file checksum subsection should precede all references to it. 1044 if (!CVFileChecksumTable.data() || !CVStringTable.data()) 1045 error(object_error::parse_failed); 1046 // Check if the file checksum table offset is valid. 1047 if (FileOffset >= CVFileChecksumTable.size()) 1048 error(object_error::parse_failed); 1049 1050 // The string table offset comes first before the file checksum. 1051 StringRef Data = CVFileChecksumTable.drop_front(FileOffset); 1052 uint32_t StringOffset; 1053 error(consume(Data, StringOffset)); 1054 1055 // Check if the string table offset is valid. 1056 if (StringOffset >= CVStringTable.size()) 1057 error(object_error::parse_failed); 1058 1059 // Return the null-terminated string. 1060 return CVStringTable.drop_front(StringOffset).split('\0').first; 1061 } 1062 1063 void COFFDumper::printFileNameForOffset(StringRef Label, uint32_t FileOffset) { 1064 W.printHex(Label, getFileNameForFileOffset(FileOffset), FileOffset); 1065 } 1066 1067 void COFFDumper::mergeCodeViewTypes(TypeTableBuilder &CVTypes) { 1068 for (const SectionRef &S : Obj->sections()) { 1069 StringRef SectionName; 1070 error(S.getName(SectionName)); 1071 if (SectionName == ".debug$T") { 1072 StringRef Data; 1073 error(S.getContents(Data)); 1074 uint32_t Magic; 1075 error(consume(Data, Magic)); 1076 if (Magic != 4) 1077 error(object_error::parse_failed); 1078 ArrayRef<uint8_t> Bytes(reinterpret_cast<const uint8_t *>(Data.data()), 1079 Data.size()); 1080 BinaryByteStream Stream(Bytes); 1081 CVTypeArray Types; 1082 BinaryStreamReader Reader(Stream); 1083 if (auto EC = Reader.readArray(Types, Reader.getLength())) { 1084 consumeError(std::move(EC)); 1085 W.flush(); 1086 error(object_error::parse_failed); 1087 } 1088 1089 if (auto EC = mergeTypeStreams(CVTypes, nullptr, Types)) { 1090 consumeError(std::move(EC)); 1091 return error(object_error::parse_failed); 1092 } 1093 } 1094 } 1095 } 1096 1097 void COFFDumper::printCodeViewTypeSection(StringRef SectionName, 1098 const SectionRef &Section) { 1099 ListScope D(W, "CodeViewTypes"); 1100 W.printNumber("Section", SectionName, Obj->getSectionID(Section)); 1101 1102 StringRef Data; 1103 error(Section.getContents(Data)); 1104 if (opts::CodeViewSubsectionBytes) 1105 W.printBinaryBlock("Data", Data); 1106 1107 uint32_t Magic; 1108 error(consume(Data, Magic)); 1109 W.printHex("Magic", Magic); 1110 if (Magic != COFF::DEBUG_SECTION_MAGIC) 1111 return error(object_error::parse_failed); 1112 1113 CVTypeDumper CVTD(TypeDB); 1114 TypeDumpVisitor TDV(TypeDB, &W, opts::CodeViewSubsectionBytes); 1115 if (auto EC = CVTD.dump({Data.bytes_begin(), Data.bytes_end()}, TDV)) { 1116 W.flush(); 1117 error(llvm::errorToErrorCode(std::move(EC))); 1118 } 1119 } 1120 1121 void COFFDumper::printSections() { 1122 ListScope SectionsD(W, "Sections"); 1123 int SectionNumber = 0; 1124 for (const SectionRef &Sec : Obj->sections()) { 1125 ++SectionNumber; 1126 const coff_section *Section = Obj->getCOFFSection(Sec); 1127 1128 StringRef Name; 1129 error(Sec.getName(Name)); 1130 1131 DictScope D(W, "Section"); 1132 W.printNumber("Number", SectionNumber); 1133 W.printBinary("Name", Name, Section->Name); 1134 W.printHex ("VirtualSize", Section->VirtualSize); 1135 W.printHex ("VirtualAddress", Section->VirtualAddress); 1136 W.printNumber("RawDataSize", Section->SizeOfRawData); 1137 W.printHex ("PointerToRawData", Section->PointerToRawData); 1138 W.printHex ("PointerToRelocations", Section->PointerToRelocations); 1139 W.printHex ("PointerToLineNumbers", Section->PointerToLinenumbers); 1140 W.printNumber("RelocationCount", Section->NumberOfRelocations); 1141 W.printNumber("LineNumberCount", Section->NumberOfLinenumbers); 1142 W.printFlags ("Characteristics", Section->Characteristics, 1143 makeArrayRef(ImageSectionCharacteristics), 1144 COFF::SectionCharacteristics(0x00F00000)); 1145 1146 if (opts::SectionRelocations) { 1147 ListScope D(W, "Relocations"); 1148 for (const RelocationRef &Reloc : Sec.relocations()) 1149 printRelocation(Sec, Reloc); 1150 } 1151 1152 if (opts::SectionSymbols) { 1153 ListScope D(W, "Symbols"); 1154 for (const SymbolRef &Symbol : Obj->symbols()) { 1155 if (!Sec.containsSymbol(Symbol)) 1156 continue; 1157 1158 printSymbol(Symbol); 1159 } 1160 } 1161 1162 if (opts::SectionData && 1163 !(Section->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA)) { 1164 StringRef Data; 1165 error(Sec.getContents(Data)); 1166 1167 W.printBinaryBlock("SectionData", Data); 1168 } 1169 } 1170 } 1171 1172 void COFFDumper::printRelocations() { 1173 ListScope D(W, "Relocations"); 1174 1175 int SectionNumber = 0; 1176 for (const SectionRef &Section : Obj->sections()) { 1177 ++SectionNumber; 1178 StringRef Name; 1179 error(Section.getName(Name)); 1180 1181 bool PrintedGroup = false; 1182 for (const RelocationRef &Reloc : Section.relocations()) { 1183 if (!PrintedGroup) { 1184 W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n"; 1185 W.indent(); 1186 PrintedGroup = true; 1187 } 1188 1189 printRelocation(Section, Reloc); 1190 } 1191 1192 if (PrintedGroup) { 1193 W.unindent(); 1194 W.startLine() << "}\n"; 1195 } 1196 } 1197 } 1198 1199 void COFFDumper::printRelocation(const SectionRef &Section, 1200 const RelocationRef &Reloc, uint64_t Bias) { 1201 uint64_t Offset = Reloc.getOffset() - Bias; 1202 uint64_t RelocType = Reloc.getType(); 1203 SmallString<32> RelocName; 1204 StringRef SymbolName; 1205 Reloc.getTypeName(RelocName); 1206 symbol_iterator Symbol = Reloc.getSymbol(); 1207 if (Symbol != Obj->symbol_end()) { 1208 Expected<StringRef> SymbolNameOrErr = Symbol->getName(); 1209 error(errorToErrorCode(SymbolNameOrErr.takeError())); 1210 SymbolName = *SymbolNameOrErr; 1211 } 1212 1213 if (opts::ExpandRelocs) { 1214 DictScope Group(W, "Relocation"); 1215 W.printHex("Offset", Offset); 1216 W.printNumber("Type", RelocName, RelocType); 1217 W.printString("Symbol", SymbolName.empty() ? "-" : SymbolName); 1218 } else { 1219 raw_ostream& OS = W.startLine(); 1220 OS << W.hex(Offset) 1221 << " " << RelocName 1222 << " " << (SymbolName.empty() ? "-" : SymbolName) 1223 << "\n"; 1224 } 1225 } 1226 1227 void COFFDumper::printSymbols() { 1228 ListScope Group(W, "Symbols"); 1229 1230 for (const SymbolRef &Symbol : Obj->symbols()) 1231 printSymbol(Symbol); 1232 } 1233 1234 void COFFDumper::printDynamicSymbols() { ListScope Group(W, "DynamicSymbols"); } 1235 1236 static ErrorOr<StringRef> 1237 getSectionName(const llvm::object::COFFObjectFile *Obj, int32_t SectionNumber, 1238 const coff_section *Section) { 1239 if (Section) { 1240 StringRef SectionName; 1241 if (std::error_code EC = Obj->getSectionName(Section, SectionName)) 1242 return EC; 1243 return SectionName; 1244 } 1245 if (SectionNumber == llvm::COFF::IMAGE_SYM_DEBUG) 1246 return StringRef("IMAGE_SYM_DEBUG"); 1247 if (SectionNumber == llvm::COFF::IMAGE_SYM_ABSOLUTE) 1248 return StringRef("IMAGE_SYM_ABSOLUTE"); 1249 if (SectionNumber == llvm::COFF::IMAGE_SYM_UNDEFINED) 1250 return StringRef("IMAGE_SYM_UNDEFINED"); 1251 return StringRef(""); 1252 } 1253 1254 void COFFDumper::printSymbol(const SymbolRef &Sym) { 1255 DictScope D(W, "Symbol"); 1256 1257 COFFSymbolRef Symbol = Obj->getCOFFSymbol(Sym); 1258 const coff_section *Section; 1259 if (std::error_code EC = Obj->getSection(Symbol.getSectionNumber(), Section)) { 1260 W.startLine() << "Invalid section number: " << EC.message() << "\n"; 1261 W.flush(); 1262 return; 1263 } 1264 1265 StringRef SymbolName; 1266 if (Obj->getSymbolName(Symbol, SymbolName)) 1267 SymbolName = ""; 1268 1269 StringRef SectionName = ""; 1270 ErrorOr<StringRef> Res = 1271 getSectionName(Obj, Symbol.getSectionNumber(), Section); 1272 if (Res) 1273 SectionName = *Res; 1274 1275 W.printString("Name", SymbolName); 1276 W.printNumber("Value", Symbol.getValue()); 1277 W.printNumber("Section", SectionName, Symbol.getSectionNumber()); 1278 W.printEnum ("BaseType", Symbol.getBaseType(), makeArrayRef(ImageSymType)); 1279 W.printEnum ("ComplexType", Symbol.getComplexType(), 1280 makeArrayRef(ImageSymDType)); 1281 W.printEnum ("StorageClass", Symbol.getStorageClass(), 1282 makeArrayRef(ImageSymClass)); 1283 W.printNumber("AuxSymbolCount", Symbol.getNumberOfAuxSymbols()); 1284 1285 for (uint8_t I = 0; I < Symbol.getNumberOfAuxSymbols(); ++I) { 1286 if (Symbol.isFunctionDefinition()) { 1287 const coff_aux_function_definition *Aux; 1288 error(getSymbolAuxData(Obj, Symbol, I, Aux)); 1289 1290 DictScope AS(W, "AuxFunctionDef"); 1291 W.printNumber("TagIndex", Aux->TagIndex); 1292 W.printNumber("TotalSize", Aux->TotalSize); 1293 W.printHex("PointerToLineNumber", Aux->PointerToLinenumber); 1294 W.printHex("PointerToNextFunction", Aux->PointerToNextFunction); 1295 1296 } else if (Symbol.isAnyUndefined()) { 1297 const coff_aux_weak_external *Aux; 1298 error(getSymbolAuxData(Obj, Symbol, I, Aux)); 1299 1300 ErrorOr<COFFSymbolRef> Linked = Obj->getSymbol(Aux->TagIndex); 1301 StringRef LinkedName; 1302 std::error_code EC = Linked.getError(); 1303 if (EC || (EC = Obj->getSymbolName(*Linked, LinkedName))) { 1304 LinkedName = ""; 1305 error(EC); 1306 } 1307 1308 DictScope AS(W, "AuxWeakExternal"); 1309 W.printNumber("Linked", LinkedName, Aux->TagIndex); 1310 W.printEnum ("Search", Aux->Characteristics, 1311 makeArrayRef(WeakExternalCharacteristics)); 1312 1313 } else if (Symbol.isFileRecord()) { 1314 const char *FileName; 1315 error(getSymbolAuxData(Obj, Symbol, I, FileName)); 1316 1317 DictScope AS(W, "AuxFileRecord"); 1318 1319 StringRef Name(FileName, Symbol.getNumberOfAuxSymbols() * 1320 Obj->getSymbolTableEntrySize()); 1321 W.printString("FileName", Name.rtrim(StringRef("\0", 1))); 1322 break; 1323 } else if (Symbol.isSectionDefinition()) { 1324 const coff_aux_section_definition *Aux; 1325 error(getSymbolAuxData(Obj, Symbol, I, Aux)); 1326 1327 int32_t AuxNumber = Aux->getNumber(Symbol.isBigObj()); 1328 1329 DictScope AS(W, "AuxSectionDef"); 1330 W.printNumber("Length", Aux->Length); 1331 W.printNumber("RelocationCount", Aux->NumberOfRelocations); 1332 W.printNumber("LineNumberCount", Aux->NumberOfLinenumbers); 1333 W.printHex("Checksum", Aux->CheckSum); 1334 W.printNumber("Number", AuxNumber); 1335 W.printEnum("Selection", Aux->Selection, makeArrayRef(ImageCOMDATSelect)); 1336 1337 if (Section && Section->Characteristics & COFF::IMAGE_SCN_LNK_COMDAT 1338 && Aux->Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) { 1339 const coff_section *Assoc; 1340 StringRef AssocName = ""; 1341 std::error_code EC = Obj->getSection(AuxNumber, Assoc); 1342 ErrorOr<StringRef> Res = getSectionName(Obj, AuxNumber, Assoc); 1343 if (Res) 1344 AssocName = *Res; 1345 if (!EC) 1346 EC = Res.getError(); 1347 if (EC) { 1348 AssocName = ""; 1349 error(EC); 1350 } 1351 1352 W.printNumber("AssocSection", AssocName, AuxNumber); 1353 } 1354 } else if (Symbol.isCLRToken()) { 1355 const coff_aux_clr_token *Aux; 1356 error(getSymbolAuxData(Obj, Symbol, I, Aux)); 1357 1358 ErrorOr<COFFSymbolRef> ReferredSym = 1359 Obj->getSymbol(Aux->SymbolTableIndex); 1360 StringRef ReferredName; 1361 std::error_code EC = ReferredSym.getError(); 1362 if (EC || (EC = Obj->getSymbolName(*ReferredSym, ReferredName))) { 1363 ReferredName = ""; 1364 error(EC); 1365 } 1366 1367 DictScope AS(W, "AuxCLRToken"); 1368 W.printNumber("AuxType", Aux->AuxType); 1369 W.printNumber("Reserved", Aux->Reserved); 1370 W.printNumber("SymbolTableIndex", ReferredName, Aux->SymbolTableIndex); 1371 1372 } else { 1373 W.startLine() << "<unhandled auxiliary record>\n"; 1374 } 1375 } 1376 } 1377 1378 void COFFDumper::printUnwindInfo() { 1379 ListScope D(W, "UnwindInformation"); 1380 switch (Obj->getMachine()) { 1381 case COFF::IMAGE_FILE_MACHINE_AMD64: { 1382 Win64EH::Dumper Dumper(W); 1383 Win64EH::Dumper::SymbolResolver 1384 Resolver = [](const object::coff_section *Section, uint64_t Offset, 1385 SymbolRef &Symbol, void *user_data) -> std::error_code { 1386 COFFDumper *Dumper = reinterpret_cast<COFFDumper *>(user_data); 1387 return Dumper->resolveSymbol(Section, Offset, Symbol); 1388 }; 1389 Win64EH::Dumper::Context Ctx(*Obj, Resolver, this); 1390 Dumper.printData(Ctx); 1391 break; 1392 } 1393 case COFF::IMAGE_FILE_MACHINE_ARMNT: { 1394 ARM::WinEH::Decoder Decoder(W); 1395 Decoder.dumpProcedureData(*Obj); 1396 break; 1397 } 1398 default: 1399 W.printEnum("unsupported Image Machine", Obj->getMachine(), 1400 makeArrayRef(ImageFileMachineType)); 1401 break; 1402 } 1403 } 1404 1405 void COFFDumper::printImportedSymbols( 1406 iterator_range<imported_symbol_iterator> Range) { 1407 for (const ImportedSymbolRef &I : Range) { 1408 StringRef Sym; 1409 error(I.getSymbolName(Sym)); 1410 uint16_t Ordinal; 1411 error(I.getOrdinal(Ordinal)); 1412 W.printNumber("Symbol", Sym, Ordinal); 1413 } 1414 } 1415 1416 void COFFDumper::printDelayImportedSymbols( 1417 const DelayImportDirectoryEntryRef &I, 1418 iterator_range<imported_symbol_iterator> Range) { 1419 int Index = 0; 1420 for (const ImportedSymbolRef &S : Range) { 1421 DictScope Import(W, "Import"); 1422 StringRef Sym; 1423 error(S.getSymbolName(Sym)); 1424 uint16_t Ordinal; 1425 error(S.getOrdinal(Ordinal)); 1426 W.printNumber("Symbol", Sym, Ordinal); 1427 uint64_t Addr; 1428 error(I.getImportAddress(Index++, Addr)); 1429 W.printHex("Address", Addr); 1430 } 1431 } 1432 1433 void COFFDumper::printCOFFImports() { 1434 // Regular imports 1435 for (const ImportDirectoryEntryRef &I : Obj->import_directories()) { 1436 DictScope Import(W, "Import"); 1437 StringRef Name; 1438 error(I.getName(Name)); 1439 W.printString("Name", Name); 1440 uint32_t Addr; 1441 error(I.getImportLookupTableRVA(Addr)); 1442 W.printHex("ImportLookupTableRVA", Addr); 1443 error(I.getImportAddressTableRVA(Addr)); 1444 W.printHex("ImportAddressTableRVA", Addr); 1445 printImportedSymbols(I.imported_symbols()); 1446 } 1447 1448 // Delay imports 1449 for (const DelayImportDirectoryEntryRef &I : Obj->delay_import_directories()) { 1450 DictScope Import(W, "DelayImport"); 1451 StringRef Name; 1452 error(I.getName(Name)); 1453 W.printString("Name", Name); 1454 const delay_import_directory_table_entry *Table; 1455 error(I.getDelayImportTable(Table)); 1456 W.printHex("Attributes", Table->Attributes); 1457 W.printHex("ModuleHandle", Table->ModuleHandle); 1458 W.printHex("ImportAddressTable", Table->DelayImportAddressTable); 1459 W.printHex("ImportNameTable", Table->DelayImportNameTable); 1460 W.printHex("BoundDelayImportTable", Table->BoundDelayImportTable); 1461 W.printHex("UnloadDelayImportTable", Table->UnloadDelayImportTable); 1462 printDelayImportedSymbols(I, I.imported_symbols()); 1463 } 1464 } 1465 1466 void COFFDumper::printCOFFExports() { 1467 for (const ExportDirectoryEntryRef &E : Obj->export_directories()) { 1468 DictScope Export(W, "Export"); 1469 1470 StringRef Name; 1471 uint32_t Ordinal, RVA; 1472 1473 error(E.getSymbolName(Name)); 1474 error(E.getOrdinal(Ordinal)); 1475 error(E.getExportRVA(RVA)); 1476 1477 W.printNumber("Ordinal", Ordinal); 1478 W.printString("Name", Name); 1479 W.printHex("RVA", RVA); 1480 } 1481 } 1482 1483 void COFFDumper::printCOFFDirectives() { 1484 for (const SectionRef &Section : Obj->sections()) { 1485 StringRef Contents; 1486 StringRef Name; 1487 1488 error(Section.getName(Name)); 1489 if (Name != ".drectve") 1490 continue; 1491 1492 error(Section.getContents(Contents)); 1493 1494 W.printString("Directive(s)", Contents); 1495 } 1496 } 1497 1498 static StringRef getBaseRelocTypeName(uint8_t Type) { 1499 switch (Type) { 1500 case COFF::IMAGE_REL_BASED_ABSOLUTE: return "ABSOLUTE"; 1501 case COFF::IMAGE_REL_BASED_HIGH: return "HIGH"; 1502 case COFF::IMAGE_REL_BASED_LOW: return "LOW"; 1503 case COFF::IMAGE_REL_BASED_HIGHLOW: return "HIGHLOW"; 1504 case COFF::IMAGE_REL_BASED_HIGHADJ: return "HIGHADJ"; 1505 case COFF::IMAGE_REL_BASED_ARM_MOV32T: return "ARM_MOV32(T)"; 1506 case COFF::IMAGE_REL_BASED_DIR64: return "DIR64"; 1507 default: return "unknown (" + llvm::utostr(Type) + ")"; 1508 } 1509 } 1510 1511 void COFFDumper::printCOFFBaseReloc() { 1512 ListScope D(W, "BaseReloc"); 1513 for (const BaseRelocRef &I : Obj->base_relocs()) { 1514 uint8_t Type; 1515 uint32_t RVA; 1516 error(I.getRVA(RVA)); 1517 error(I.getType(Type)); 1518 DictScope Import(W, "Entry"); 1519 W.printString("Type", getBaseRelocTypeName(Type)); 1520 W.printHex("Address", RVA); 1521 } 1522 } 1523 1524 void COFFDumper::printStackMap() const { 1525 object::SectionRef StackMapSection; 1526 for (auto Sec : Obj->sections()) { 1527 StringRef Name; 1528 Sec.getName(Name); 1529 if (Name == ".llvm_stackmaps") { 1530 StackMapSection = Sec; 1531 break; 1532 } 1533 } 1534 1535 if (StackMapSection == object::SectionRef()) 1536 return; 1537 1538 StringRef StackMapContents; 1539 StackMapSection.getContents(StackMapContents); 1540 ArrayRef<uint8_t> StackMapContentsArray( 1541 reinterpret_cast<const uint8_t*>(StackMapContents.data()), 1542 StackMapContents.size()); 1543 1544 if (Obj->isLittleEndian()) 1545 prettyPrintStackMap( 1546 llvm::outs(), 1547 StackMapV2Parser<support::little>(StackMapContentsArray)); 1548 else 1549 prettyPrintStackMap(llvm::outs(), 1550 StackMapV2Parser<support::big>(StackMapContentsArray)); 1551 } 1552 1553 void llvm::dumpCodeViewMergedTypes(ScopedPrinter &Writer, 1554 llvm::codeview::TypeTableBuilder &CVTypes) { 1555 // Flatten it first, then run our dumper on it. 1556 ListScope S(Writer, "MergedTypeStream"); 1557 SmallString<0> Buf; 1558 CVTypes.ForEachRecord([&](TypeIndex TI, ArrayRef<uint8_t> Record) { 1559 Buf.append(Record.begin(), Record.end()); 1560 }); 1561 1562 TypeDatabase TypeDB; 1563 CVTypeDumper CVTD(TypeDB); 1564 TypeDumpVisitor TDV(TypeDB, &Writer, opts::CodeViewSubsectionBytes); 1565 if (auto EC = 1566 CVTD.dump({Buf.str().bytes_begin(), Buf.str().bytes_end()}, TDV)) { 1567 Writer.flush(); 1568 error(llvm::errorToErrorCode(std::move(EC))); 1569 } 1570 } 1571