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 "llvm-readobj.h" 16 #include "ARMWinEHPrinter.h" 17 #include "CodeView.h" 18 #include "Error.h" 19 #include "ObjDumper.h" 20 #include "StackMapPrinter.h" 21 #include "StreamWriter.h" 22 #include "Win64EHDumper.h" 23 #include "llvm/ADT/DenseMap.h" 24 #include "llvm/ADT/SmallString.h" 25 #include "llvm/ADT/StringExtras.h" 26 #include "llvm/ADT/StringSet.h" 27 #include "llvm/DebugInfo/CodeView/CodeView.h" 28 #include "llvm/DebugInfo/CodeView/Line.h" 29 #include "llvm/DebugInfo/CodeView/TypeIndex.h" 30 #include "llvm/DebugInfo/CodeView/TypeRecord.h" 31 #include "llvm/DebugInfo/CodeView/SymbolRecord.h" 32 #include "llvm/Object/COFF.h" 33 #include "llvm/Object/ObjectFile.h" 34 #include "llvm/Support/COFF.h" 35 #include "llvm/Support/Casting.h" 36 #include "llvm/Support/Compiler.h" 37 #include "llvm/Support/DataExtractor.h" 38 #include "llvm/Support/Format.h" 39 #include "llvm/Support/SourceMgr.h" 40 #include "llvm/Support/Win64EH.h" 41 #include "llvm/Support/raw_ostream.h" 42 #include <algorithm> 43 #include <cstring> 44 #include <system_error> 45 #include <time.h> 46 47 using namespace llvm; 48 using namespace llvm::object; 49 using namespace llvm::codeview; 50 using namespace llvm::support; 51 using namespace llvm::Win64EH; 52 53 namespace { 54 55 class COFFDumper : public ObjDumper { 56 public: 57 COFFDumper(const llvm::object::COFFObjectFile *Obj, StreamWriter& Writer) 58 : ObjDumper(Writer) 59 , Obj(Obj) { 60 } 61 62 void printFileHeaders() override; 63 void printSections() override; 64 void printRelocations() override; 65 void printSymbols() override; 66 void printDynamicSymbols() override; 67 void printUnwindInfo() override; 68 void printCOFFImports() override; 69 void printCOFFExports() override; 70 void printCOFFDirectives() override; 71 void printCOFFBaseReloc() override; 72 void printCodeViewDebugInfo() override; 73 void printStackMap() const override; 74 private: 75 void printSymbol(const SymbolRef &Sym); 76 void printRelocation(const SectionRef &Section, const RelocationRef &Reloc, 77 uint64_t Bias = 0); 78 void printDataDirectory(uint32_t Index, const std::string &FieldName); 79 80 void printDOSHeader(const dos_header *DH); 81 template <class PEHeader> void printPEHeader(const PEHeader *Hdr); 82 void printBaseOfDataField(const pe32_header *Hdr); 83 void printBaseOfDataField(const pe32plus_header *Hdr); 84 85 void printCodeViewSymbolSection(StringRef SectionName, const SectionRef &Section); 86 void printCodeViewTypeSection(StringRef SectionName, const SectionRef &Section); 87 void printCodeViewFieldList(StringRef FieldData); 88 StringRef getTypeName(TypeIndex Ty); 89 StringRef getFileNameForFileOffset(uint32_t FileOffset); 90 void printFileNameForOffset(StringRef Label, uint32_t FileOffset); 91 void printTypeIndex(StringRef FieldName, TypeIndex TI); 92 void printLocalVariableAddrRange(const LocalVariableAddrRange &Range, 93 const coff_section *Sec, 94 StringRef SectionContents); 95 void printLocalVariableAddrGap(StringRef &SymData); 96 97 void printCodeViewSymbolsSubsection(StringRef Subsection, 98 const SectionRef &Section, 99 StringRef SectionContents); 100 101 void printCodeViewFileChecksums(StringRef Subsection); 102 103 void printCodeViewInlineeLines(StringRef Subsection); 104 105 void printMemberAttributes(MemberAttributes Attrs); 106 107 void printRelocatedField(StringRef Label, const coff_section *Sec, 108 StringRef SectionContents, const ulittle32_t *Field, 109 StringRef *RelocSym = nullptr); 110 111 void printBinaryBlockWithRelocs(StringRef Label, const SectionRef &Sec, 112 StringRef SectionContents, StringRef Block); 113 114 /// Given a .debug$S section, find the string table and file checksum table. 115 void initializeFileAndStringTables(StringRef Data); 116 117 void cacheRelocations(); 118 119 std::error_code resolveSymbol(const coff_section *Section, uint64_t Offset, 120 SymbolRef &Sym); 121 std::error_code resolveSymbolName(const coff_section *Section, 122 uint64_t Offset, StringRef &Name); 123 std::error_code resolveSymbolName(const coff_section *Section, 124 StringRef SectionContents, 125 const void *RelocPtr, StringRef &Name); 126 void printImportedSymbols(iterator_range<imported_symbol_iterator> Range); 127 void printDelayImportedSymbols( 128 const DelayImportDirectoryEntryRef &I, 129 iterator_range<imported_symbol_iterator> Range); 130 131 typedef DenseMap<const coff_section*, std::vector<RelocationRef> > RelocMapTy; 132 133 const llvm::object::COFFObjectFile *Obj; 134 bool RelocCached = false; 135 RelocMapTy RelocMap; 136 StringRef CVFileChecksumTable; 137 StringRef CVStringTable; 138 139 /// All user defined type records in .debug$T live in here. Type indices 140 /// greater than 0x1000 are user defined. Subtract 0x1000 from the index to 141 /// index into this vector. 142 SmallVector<StringRef, 10> CVUDTNames; 143 144 StringSet<> TypeNames; 145 }; 146 147 } // namespace 148 149 150 namespace llvm { 151 152 std::error_code createCOFFDumper(const object::ObjectFile *Obj, 153 StreamWriter &Writer, 154 std::unique_ptr<ObjDumper> &Result) { 155 const COFFObjectFile *COFFObj = dyn_cast<COFFObjectFile>(Obj); 156 if (!COFFObj) 157 return readobj_error::unsupported_obj_file_format; 158 159 Result.reset(new COFFDumper(COFFObj, Writer)); 160 return readobj_error::success; 161 } 162 163 } // namespace llvm 164 165 // Given a a section and an offset into this section the function returns the 166 // symbol used for the relocation at the offset. 167 std::error_code COFFDumper::resolveSymbol(const coff_section *Section, 168 uint64_t Offset, SymbolRef &Sym) { 169 cacheRelocations(); 170 const auto &Relocations = RelocMap[Section]; 171 for (const auto &Relocation : Relocations) { 172 uint64_t RelocationOffset = Relocation.getOffset(); 173 174 if (RelocationOffset == Offset) { 175 Sym = *Relocation.getSymbol(); 176 return readobj_error::success; 177 } 178 } 179 return readobj_error::unknown_symbol; 180 } 181 182 // Given a section and an offset into this section the function returns the name 183 // of the symbol used for the relocation at the offset. 184 std::error_code COFFDumper::resolveSymbolName(const coff_section *Section, 185 uint64_t Offset, 186 StringRef &Name) { 187 SymbolRef Symbol; 188 if (std::error_code EC = resolveSymbol(Section, Offset, Symbol)) 189 return EC; 190 ErrorOr<StringRef> NameOrErr = Symbol.getName(); 191 if (std::error_code EC = NameOrErr.getError()) 192 return EC; 193 Name = *NameOrErr; 194 return std::error_code(); 195 } 196 197 // Helper for when you have a pointer to real data and you want to know about 198 // relocations against it. 199 std::error_code COFFDumper::resolveSymbolName(const coff_section *Section, 200 StringRef SectionContents, 201 const void *RelocPtr, 202 StringRef &Name) { 203 assert(SectionContents.data() < RelocPtr && 204 RelocPtr < SectionContents.data() + SectionContents.size() && 205 "pointer to relocated object is not in section"); 206 uint64_t Offset = ptrdiff_t(reinterpret_cast<const char *>(RelocPtr) - 207 SectionContents.data()); 208 return resolveSymbolName(Section, Offset, Name); 209 } 210 211 void COFFDumper::printRelocatedField(StringRef Label, const coff_section *Sec, 212 StringRef SectionContents, 213 const ulittle32_t *Field, 214 StringRef *RelocSym) { 215 StringRef SymStorage; 216 StringRef &Symbol = RelocSym ? *RelocSym : SymStorage; 217 if (!resolveSymbolName(Sec, SectionContents, Field, Symbol)) 218 W.printSymbolOffset(Label, Symbol, *Field); 219 else 220 W.printHex(Label, *Field); 221 } 222 223 void COFFDumper::printBinaryBlockWithRelocs(StringRef Label, 224 const SectionRef &Sec, 225 StringRef SectionContents, 226 StringRef Block) { 227 W.printBinaryBlock(Label, Block); 228 229 assert(SectionContents.begin() < Block.begin() && 230 SectionContents.end() >= Block.end() && 231 "Block is not contained in SectionContents"); 232 uint64_t OffsetStart = Block.data() - SectionContents.data(); 233 uint64_t OffsetEnd = OffsetStart + Block.size(); 234 235 cacheRelocations(); 236 ListScope D(W, "BlockRelocations"); 237 const coff_section *Section = Obj->getCOFFSection(Sec); 238 const auto &Relocations = RelocMap[Section]; 239 for (const auto &Relocation : Relocations) { 240 uint64_t RelocationOffset = Relocation.getOffset(); 241 if (OffsetStart <= RelocationOffset && RelocationOffset < OffsetEnd) 242 printRelocation(Sec, Relocation, OffsetStart); 243 } 244 } 245 246 static const EnumEntry<COFF::MachineTypes> ImageFileMachineType[] = { 247 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_UNKNOWN ), 248 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_AM33 ), 249 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_AMD64 ), 250 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM ), 251 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARMNT ), 252 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_EBC ), 253 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_I386 ), 254 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_IA64 ), 255 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_M32R ), 256 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPS16 ), 257 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPSFPU ), 258 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPSFPU16), 259 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_POWERPC ), 260 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_POWERPCFP), 261 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_R4000 ), 262 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH3 ), 263 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH3DSP ), 264 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH4 ), 265 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH5 ), 266 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_THUMB ), 267 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_WCEMIPSV2) 268 }; 269 270 static const EnumEntry<COFF::Characteristics> ImageFileCharacteristics[] = { 271 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_RELOCS_STRIPPED ), 272 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_EXECUTABLE_IMAGE ), 273 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LINE_NUMS_STRIPPED ), 274 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LOCAL_SYMS_STRIPPED ), 275 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_AGGRESSIVE_WS_TRIM ), 276 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LARGE_ADDRESS_AWARE ), 277 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_LO ), 278 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_32BIT_MACHINE ), 279 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_DEBUG_STRIPPED ), 280 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP), 281 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_NET_RUN_FROM_SWAP ), 282 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_SYSTEM ), 283 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_DLL ), 284 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_UP_SYSTEM_ONLY ), 285 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_HI ) 286 }; 287 288 static const EnumEntry<COFF::WindowsSubsystem> PEWindowsSubsystem[] = { 289 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_UNKNOWN ), 290 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_NATIVE ), 291 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_GUI ), 292 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_CUI ), 293 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_POSIX_CUI ), 294 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI ), 295 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_APPLICATION ), 296 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER), 297 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER ), 298 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_ROM ), 299 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_XBOX ), 300 }; 301 302 static const EnumEntry<COFF::DLLCharacteristics> PEDLLCharacteristics[] = { 303 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA ), 304 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE ), 305 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY ), 306 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NX_COMPAT ), 307 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_ISOLATION ), 308 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_SEH ), 309 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_BIND ), 310 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_APPCONTAINER ), 311 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_WDM_DRIVER ), 312 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_GUARD_CF ), 313 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE), 314 }; 315 316 static const EnumEntry<COFF::SectionCharacteristics> 317 ImageSectionCharacteristics[] = { 318 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NOLOAD ), 319 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NO_PAD ), 320 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_CODE ), 321 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_INITIALIZED_DATA ), 322 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_UNINITIALIZED_DATA), 323 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_OTHER ), 324 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_INFO ), 325 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_REMOVE ), 326 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_COMDAT ), 327 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_GPREL ), 328 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_PURGEABLE ), 329 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_16BIT ), 330 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_LOCKED ), 331 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_PRELOAD ), 332 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1BYTES ), 333 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2BYTES ), 334 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4BYTES ), 335 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8BYTES ), 336 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_16BYTES ), 337 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_32BYTES ), 338 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_64BYTES ), 339 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_128BYTES ), 340 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_256BYTES ), 341 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_512BYTES ), 342 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1024BYTES ), 343 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2048BYTES ), 344 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4096BYTES ), 345 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8192BYTES ), 346 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_NRELOC_OVFL ), 347 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_DISCARDABLE ), 348 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_CACHED ), 349 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_PAGED ), 350 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_SHARED ), 351 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_EXECUTE ), 352 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_READ ), 353 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_WRITE ) 354 }; 355 356 static const EnumEntry<COFF::SymbolBaseType> ImageSymType[] = { 357 { "Null" , COFF::IMAGE_SYM_TYPE_NULL }, 358 { "Void" , COFF::IMAGE_SYM_TYPE_VOID }, 359 { "Char" , COFF::IMAGE_SYM_TYPE_CHAR }, 360 { "Short" , COFF::IMAGE_SYM_TYPE_SHORT }, 361 { "Int" , COFF::IMAGE_SYM_TYPE_INT }, 362 { "Long" , COFF::IMAGE_SYM_TYPE_LONG }, 363 { "Float" , COFF::IMAGE_SYM_TYPE_FLOAT }, 364 { "Double", COFF::IMAGE_SYM_TYPE_DOUBLE }, 365 { "Struct", COFF::IMAGE_SYM_TYPE_STRUCT }, 366 { "Union" , COFF::IMAGE_SYM_TYPE_UNION }, 367 { "Enum" , COFF::IMAGE_SYM_TYPE_ENUM }, 368 { "MOE" , COFF::IMAGE_SYM_TYPE_MOE }, 369 { "Byte" , COFF::IMAGE_SYM_TYPE_BYTE }, 370 { "Word" , COFF::IMAGE_SYM_TYPE_WORD }, 371 { "UInt" , COFF::IMAGE_SYM_TYPE_UINT }, 372 { "DWord" , COFF::IMAGE_SYM_TYPE_DWORD } 373 }; 374 375 static const EnumEntry<COFF::SymbolComplexType> ImageSymDType[] = { 376 { "Null" , COFF::IMAGE_SYM_DTYPE_NULL }, 377 { "Pointer" , COFF::IMAGE_SYM_DTYPE_POINTER }, 378 { "Function", COFF::IMAGE_SYM_DTYPE_FUNCTION }, 379 { "Array" , COFF::IMAGE_SYM_DTYPE_ARRAY } 380 }; 381 382 static const EnumEntry<COFF::SymbolStorageClass> ImageSymClass[] = { 383 { "EndOfFunction" , COFF::IMAGE_SYM_CLASS_END_OF_FUNCTION }, 384 { "Null" , COFF::IMAGE_SYM_CLASS_NULL }, 385 { "Automatic" , COFF::IMAGE_SYM_CLASS_AUTOMATIC }, 386 { "External" , COFF::IMAGE_SYM_CLASS_EXTERNAL }, 387 { "Static" , COFF::IMAGE_SYM_CLASS_STATIC }, 388 { "Register" , COFF::IMAGE_SYM_CLASS_REGISTER }, 389 { "ExternalDef" , COFF::IMAGE_SYM_CLASS_EXTERNAL_DEF }, 390 { "Label" , COFF::IMAGE_SYM_CLASS_LABEL }, 391 { "UndefinedLabel" , COFF::IMAGE_SYM_CLASS_UNDEFINED_LABEL }, 392 { "MemberOfStruct" , COFF::IMAGE_SYM_CLASS_MEMBER_OF_STRUCT }, 393 { "Argument" , COFF::IMAGE_SYM_CLASS_ARGUMENT }, 394 { "StructTag" , COFF::IMAGE_SYM_CLASS_STRUCT_TAG }, 395 { "MemberOfUnion" , COFF::IMAGE_SYM_CLASS_MEMBER_OF_UNION }, 396 { "UnionTag" , COFF::IMAGE_SYM_CLASS_UNION_TAG }, 397 { "TypeDefinition" , COFF::IMAGE_SYM_CLASS_TYPE_DEFINITION }, 398 { "UndefinedStatic", COFF::IMAGE_SYM_CLASS_UNDEFINED_STATIC }, 399 { "EnumTag" , COFF::IMAGE_SYM_CLASS_ENUM_TAG }, 400 { "MemberOfEnum" , COFF::IMAGE_SYM_CLASS_MEMBER_OF_ENUM }, 401 { "RegisterParam" , COFF::IMAGE_SYM_CLASS_REGISTER_PARAM }, 402 { "BitField" , COFF::IMAGE_SYM_CLASS_BIT_FIELD }, 403 { "Block" , COFF::IMAGE_SYM_CLASS_BLOCK }, 404 { "Function" , COFF::IMAGE_SYM_CLASS_FUNCTION }, 405 { "EndOfStruct" , COFF::IMAGE_SYM_CLASS_END_OF_STRUCT }, 406 { "File" , COFF::IMAGE_SYM_CLASS_FILE }, 407 { "Section" , COFF::IMAGE_SYM_CLASS_SECTION }, 408 { "WeakExternal" , COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL }, 409 { "CLRToken" , COFF::IMAGE_SYM_CLASS_CLR_TOKEN } 410 }; 411 412 static const EnumEntry<COFF::COMDATType> ImageCOMDATSelect[] = { 413 { "NoDuplicates", COFF::IMAGE_COMDAT_SELECT_NODUPLICATES }, 414 { "Any" , COFF::IMAGE_COMDAT_SELECT_ANY }, 415 { "SameSize" , COFF::IMAGE_COMDAT_SELECT_SAME_SIZE }, 416 { "ExactMatch" , COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH }, 417 { "Associative" , COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE }, 418 { "Largest" , COFF::IMAGE_COMDAT_SELECT_LARGEST }, 419 { "Newest" , COFF::IMAGE_COMDAT_SELECT_NEWEST } 420 }; 421 422 static const EnumEntry<COFF::WeakExternalCharacteristics> 423 WeakExternalCharacteristics[] = { 424 { "NoLibrary", COFF::IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY }, 425 { "Library" , COFF::IMAGE_WEAK_EXTERN_SEARCH_LIBRARY }, 426 { "Alias" , COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS } 427 }; 428 429 static const EnumEntry<CompileSym3::Flags> CompileSym3Flags[] = { 430 LLVM_READOBJ_ENUM_ENT(CompileSym3, EC), 431 LLVM_READOBJ_ENUM_ENT(CompileSym3, NoDbgInfo), 432 LLVM_READOBJ_ENUM_ENT(CompileSym3, LTCG), 433 LLVM_READOBJ_ENUM_ENT(CompileSym3, NoDataAlign), 434 LLVM_READOBJ_ENUM_ENT(CompileSym3, ManagedPresent), 435 LLVM_READOBJ_ENUM_ENT(CompileSym3, SecurityChecks), 436 LLVM_READOBJ_ENUM_ENT(CompileSym3, HotPatch), 437 LLVM_READOBJ_ENUM_ENT(CompileSym3, CVTCIL), 438 LLVM_READOBJ_ENUM_ENT(CompileSym3, MSILModule), 439 LLVM_READOBJ_ENUM_ENT(CompileSym3, Sdl), 440 LLVM_READOBJ_ENUM_ENT(CompileSym3, PGO), 441 LLVM_READOBJ_ENUM_ENT(CompileSym3, Exp), 442 }; 443 444 static const EnumEntry<codeview::SourceLanguage> SourceLanguages[] = { 445 LLVM_READOBJ_ENUM_ENT(SourceLanguage, C), 446 LLVM_READOBJ_ENUM_ENT(SourceLanguage, Cpp), 447 LLVM_READOBJ_ENUM_ENT(SourceLanguage, Fortran), 448 LLVM_READOBJ_ENUM_ENT(SourceLanguage, Masm), 449 LLVM_READOBJ_ENUM_ENT(SourceLanguage, Pascal), 450 LLVM_READOBJ_ENUM_ENT(SourceLanguage, Basic), 451 LLVM_READOBJ_ENUM_ENT(SourceLanguage, Cobol), 452 LLVM_READOBJ_ENUM_ENT(SourceLanguage, Link), 453 LLVM_READOBJ_ENUM_ENT(SourceLanguage, Cvtres), 454 LLVM_READOBJ_ENUM_ENT(SourceLanguage, Cvtpgd), 455 LLVM_READOBJ_ENUM_ENT(SourceLanguage, CSharp), 456 LLVM_READOBJ_ENUM_ENT(SourceLanguage, VB), 457 LLVM_READOBJ_ENUM_ENT(SourceLanguage, ILAsm), 458 LLVM_READOBJ_ENUM_ENT(SourceLanguage, Java), 459 LLVM_READOBJ_ENUM_ENT(SourceLanguage, JScript), 460 LLVM_READOBJ_ENUM_ENT(SourceLanguage, MSIL), 461 LLVM_READOBJ_ENUM_ENT(SourceLanguage, HLSL), 462 }; 463 464 static const EnumEntry<uint32_t> SubSectionTypes[] = { 465 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, Symbols), 466 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, Lines), 467 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, StringTable), 468 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, FileChecksums), 469 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, FrameData), 470 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, InlineeLines), 471 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, CrossScopeImports), 472 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, CrossScopeExports), 473 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, ILLines), 474 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, FuncMDTokenMap), 475 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, TypeMDTokenMap), 476 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, MergedAssemblyInput), 477 LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, CoffSymbolRVA), 478 }; 479 480 static const EnumEntry<unsigned> CPUTypeNames[] = { 481 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Intel8080), 482 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Intel8086), 483 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Intel80286), 484 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Intel80386), 485 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Intel80486), 486 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Pentium), 487 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, PentiumPro), 488 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Pentium3), 489 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, MIPS), 490 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, MIPS16), 491 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, MIPS32), 492 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, MIPS64), 493 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, MIPSI), 494 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, MIPSII), 495 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, MIPSIII), 496 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, MIPSIV), 497 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, MIPSV), 498 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, M68000), 499 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, M68010), 500 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, M68020), 501 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, M68030), 502 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, M68040), 503 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Alpha), 504 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Alpha21164), 505 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Alpha21164A), 506 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Alpha21264), 507 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Alpha21364), 508 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, PPC601), 509 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, PPC603), 510 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, PPC604), 511 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, PPC620), 512 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, PPCFP), 513 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, PPCBE), 514 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, SH3), 515 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, SH3E), 516 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, SH3DSP), 517 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, SH4), 518 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, SHMedia), 519 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, ARM3), 520 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, ARM4), 521 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, ARM4T), 522 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, ARM5), 523 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, ARM5T), 524 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, ARM6), 525 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, ARM_XMAC), 526 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, ARM_WMMX), 527 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, ARM7), 528 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Omni), 529 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Ia64), 530 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Ia64_2), 531 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, CEE), 532 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, AM33), 533 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, M32R), 534 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, TriCore), 535 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, X64), 536 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, EBC), 537 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Thumb), 538 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, ARMNT), 539 LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, D3D11_Shader), 540 }; 541 542 static const EnumEntry<uint8_t> ProcSymFlags[] = { 543 LLVM_READOBJ_ENUM_ENT(ProcFlags, HasFP), 544 LLVM_READOBJ_ENUM_ENT(ProcFlags, HasIRET), 545 LLVM_READOBJ_ENUM_ENT(ProcFlags, HasFRET), 546 LLVM_READOBJ_ENUM_ENT(ProcFlags, IsNoReturn), 547 LLVM_READOBJ_ENUM_ENT(ProcFlags, IsUnreachable), 548 LLVM_READOBJ_ENUM_ENT(ProcFlags, HasCustomCallingConv), 549 LLVM_READOBJ_ENUM_ENT(ProcFlags, IsNoInline), 550 LLVM_READOBJ_ENUM_ENT(ProcFlags, HasOptimizedDebugInfo), 551 }; 552 553 static const EnumEntry<uint32_t> FrameProcSymFlags[] = { 554 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, HasAlloca), 555 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, HasSetJmp), 556 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, HasLongJmp), 557 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, HasInlineAssembly), 558 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, HasExceptionHandling), 559 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, MarkedInline), 560 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, 561 HasStructuredExceptionHandling), 562 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, Naked), 563 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, SecurityChecks), 564 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, 565 AsynchronousExceptionHandling), 566 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, 567 NoStackOrderingForSecurityChecks), 568 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, Inlined), 569 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, StrictSecurityChecks), 570 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, SafeBuffers), 571 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, 572 ProfileGuidedOptimization), 573 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, ValidProfileCounts), 574 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, OptimizedForSpeed), 575 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, GuardCfg), 576 LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, GuardCfw), 577 }; 578 579 static const EnumEntry<uint32_t> FrameDataFlags[] = { 580 LLVM_READOBJ_ENUM_ENT(FrameData, HasSEH), 581 LLVM_READOBJ_ENUM_ENT(FrameData, HasEH), 582 LLVM_READOBJ_ENUM_ENT(FrameData, IsFunctionStart), 583 }; 584 585 static const EnumEntry<uint16_t> LocalFlags[] = { 586 LLVM_READOBJ_ENUM_ENT(LocalSym, IsParameter), 587 LLVM_READOBJ_ENUM_ENT(LocalSym, IsAddressTaken), 588 LLVM_READOBJ_ENUM_ENT(LocalSym, IsCompilerGenerated), 589 LLVM_READOBJ_ENUM_ENT(LocalSym, IsAggregate), 590 LLVM_READOBJ_ENUM_ENT(LocalSym, IsAggregated), 591 LLVM_READOBJ_ENUM_ENT(LocalSym, IsAliased), 592 LLVM_READOBJ_ENUM_ENT(LocalSym, IsAlias), 593 LLVM_READOBJ_ENUM_ENT(LocalSym, IsReturnValue), 594 LLVM_READOBJ_ENUM_ENT(LocalSym, IsOptimizedOut), 595 LLVM_READOBJ_ENUM_ENT(LocalSym, IsEnregisteredGlobal), 596 LLVM_READOBJ_ENUM_ENT(LocalSym, IsEnregisteredStatic), 597 }; 598 599 static const EnumEntry<uint16_t> FrameCookieKinds[] = { 600 LLVM_READOBJ_ENUM_ENT(FrameCookieSym, Copy), 601 LLVM_READOBJ_ENUM_ENT(FrameCookieSym, XorStackPointer), 602 LLVM_READOBJ_ENUM_ENT(FrameCookieSym, XorFramePointer), 603 LLVM_READOBJ_ENUM_ENT(FrameCookieSym, XorR13), 604 }; 605 606 static const EnumEntry<uint16_t> ClassOptionNames[] = { 607 LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, Packed), 608 LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, HasConstructorOrDestructor), 609 LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, HasOverloadedOperator), 610 LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, Nested), 611 LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, ContainsNestedClass), 612 LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, HasOverloadedAssignmentOperator), 613 LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, HasConversionOperator), 614 LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, ForwardReference), 615 LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, Scoped), 616 LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, HasUniqueName), 617 LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, Sealed), 618 LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, Intrinsic), 619 }; 620 621 static const EnumEntry<uint8_t> MemberAccessNames[] = { 622 LLVM_READOBJ_ENUM_CLASS_ENT(MemberAccess, None), 623 LLVM_READOBJ_ENUM_CLASS_ENT(MemberAccess, Private), 624 LLVM_READOBJ_ENUM_CLASS_ENT(MemberAccess, Protected), 625 LLVM_READOBJ_ENUM_CLASS_ENT(MemberAccess, Public), 626 }; 627 628 static const EnumEntry<uint16_t> MethodOptionNames[] = { 629 LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, Pseudo), 630 LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, NoInherit), 631 LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, NoConstruct), 632 LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, CompilerGenerated), 633 LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, Sealed), 634 }; 635 636 static const EnumEntry<uint16_t> MemberKindNames[] = { 637 LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, Vanilla), 638 LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, Virtual), 639 LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, Static), 640 LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, Friend), 641 LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, IntroducingVirtual), 642 LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, PureVirtual), 643 LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, PureIntroducingVirtual), 644 }; 645 646 /// The names here all end in "*". If the simple type is a pointer type, we 647 /// return the whole name. Otherwise we lop off the last character in our 648 /// StringRef. 649 static const EnumEntry<SimpleTypeKind> SimpleTypeNames[] = { 650 {"void*", SimpleTypeKind::Void}, 651 {"<not translated>*", SimpleTypeKind::NotTranslated}, 652 {"HRESULT*", SimpleTypeKind::HResult}, 653 {"signed char*", SimpleTypeKind::SignedCharacter}, 654 {"unsigned char*", SimpleTypeKind::UnsignedCharacter}, 655 {"char*", SimpleTypeKind::NarrowCharacter}, 656 {"wchar_t*", SimpleTypeKind::WideCharacter}, 657 {"__int8*", SimpleTypeKind::SByte}, 658 {"unsigned __int8*", SimpleTypeKind::Byte}, 659 {"short*", SimpleTypeKind::Int16Short}, 660 {"unsigned short*", SimpleTypeKind::UInt16Short}, 661 {"__int16*", SimpleTypeKind::Int16}, 662 {"unsigned __int16*", SimpleTypeKind::UInt16}, 663 {"long*", SimpleTypeKind::Int32Long}, 664 {"unsigned long*", SimpleTypeKind::UInt32Long}, 665 {"int*", SimpleTypeKind::Int32}, 666 {"unsigned*", SimpleTypeKind::UInt32}, 667 {"__int64*", SimpleTypeKind::Int64Quad}, 668 {"unsigned __int64*", SimpleTypeKind::UInt64Quad}, 669 {"__int64*", SimpleTypeKind::Int64}, 670 {"unsigned __int64*", SimpleTypeKind::UInt64}, 671 {"__int128*", SimpleTypeKind::Int128}, 672 {"unsigned __int128*", SimpleTypeKind::UInt128}, 673 {"__half*", SimpleTypeKind::Float16}, 674 {"float*", SimpleTypeKind::Float32}, 675 {"float*", SimpleTypeKind::Float32PartialPrecision}, 676 {"__float48*", SimpleTypeKind::Float48}, 677 {"double*", SimpleTypeKind::Float64}, 678 {"long double*", SimpleTypeKind::Float80}, 679 {"__float128*", SimpleTypeKind::Float128}, 680 {"_Complex float*", SimpleTypeKind::Complex32}, 681 {"_Complex double*", SimpleTypeKind::Complex64}, 682 {"_Complex long double*", SimpleTypeKind::Complex80}, 683 {"_Complex __float128*", SimpleTypeKind::Complex128}, 684 {"bool*", SimpleTypeKind::Boolean8}, 685 {"__bool16*", SimpleTypeKind::Boolean16}, 686 {"__bool32*", SimpleTypeKind::Boolean32}, 687 {"__bool64*", SimpleTypeKind::Boolean64}, 688 }; 689 690 static const EnumEntry<TypeLeafKind> LeafTypeNames[] = { 691 #define LEAF_TYPE(name, val) LLVM_READOBJ_ENUM_ENT(TypeLeafKind, name), 692 #include "llvm/DebugInfo/CodeView/CVLeafTypes.def" 693 }; 694 695 static const EnumEntry<uint8_t> PtrKindNames[] = { 696 LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Near16), 697 LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Far16), 698 LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Huge16), 699 LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnSegment), 700 LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnValue), 701 LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnSegmentValue), 702 LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnAddress), 703 LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnSegmentAddress), 704 LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnType), 705 LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnSelf), 706 LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Near32), 707 LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Far32), 708 LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Near64), 709 }; 710 711 static const EnumEntry<uint8_t> PtrModeNames[] = { 712 LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, Pointer), 713 LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, LValueReference), 714 LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, PointerToDataMember), 715 LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, PointerToMemberFunction), 716 LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, RValueReference), 717 }; 718 719 static const EnumEntry<uint16_t> PtrMemberRepNames[] = { 720 LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, Unknown), 721 LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, 722 SingleInheritanceData), 723 LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, 724 MultipleInheritanceData), 725 LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, 726 VirtualInheritanceData), 727 LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, GeneralData), 728 LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, 729 SingleInheritanceFunction), 730 LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, 731 MultipleInheritanceFunction), 732 LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, 733 VirtualInheritanceFunction), 734 LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, GeneralFunction), 735 }; 736 737 static const EnumEntry<uint16_t> TypeModifierNames[] = { 738 LLVM_READOBJ_ENUM_CLASS_ENT(ModifierOptions, Const), 739 LLVM_READOBJ_ENUM_CLASS_ENT(ModifierOptions, Volatile), 740 LLVM_READOBJ_ENUM_CLASS_ENT(ModifierOptions, Unaligned), 741 }; 742 743 static const EnumEntry<uint8_t> CallingConventions[] = { 744 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearC), 745 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, FarC), 746 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearPascal), 747 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, FarPascal), 748 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearFast), 749 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, FarFast), 750 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearStdCall), 751 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, FarStdCall), 752 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearSysCall), 753 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, FarSysCall), 754 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, ThisCall), 755 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, MipsCall), 756 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, Generic), 757 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, AlphaCall), 758 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, PpcCall), 759 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, SHCall), 760 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, ArmCall), 761 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, AM33Call), 762 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, TriCall), 763 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, SH5Call), 764 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, M32RCall), 765 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, ClrCall), 766 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, Inline), 767 LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearVector), 768 }; 769 770 static const EnumEntry<uint8_t> FunctionOptionEnum[] = { 771 LLVM_READOBJ_ENUM_CLASS_ENT(FunctionOptions, CxxReturnUdt), 772 LLVM_READOBJ_ENUM_CLASS_ENT(FunctionOptions, Constructor), 773 LLVM_READOBJ_ENUM_CLASS_ENT(FunctionOptions, ConstructorWithVirtualBases), 774 }; 775 776 static const EnumEntry<uint8_t> FileChecksumKindNames[] = { 777 LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, None), 778 LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, MD5), 779 LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, SHA1), 780 LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, SHA256), 781 }; 782 783 template <typename T> 784 static std::error_code getSymbolAuxData(const COFFObjectFile *Obj, 785 COFFSymbolRef Symbol, 786 uint8_t AuxSymbolIdx, const T *&Aux) { 787 ArrayRef<uint8_t> AuxData = Obj->getSymbolAuxData(Symbol); 788 AuxData = AuxData.slice(AuxSymbolIdx * Obj->getSymbolTableEntrySize()); 789 Aux = reinterpret_cast<const T*>(AuxData.data()); 790 return readobj_error::success; 791 } 792 793 void COFFDumper::cacheRelocations() { 794 if (RelocCached) 795 return; 796 RelocCached = true; 797 798 for (const SectionRef &S : Obj->sections()) { 799 const coff_section *Section = Obj->getCOFFSection(S); 800 801 for (const RelocationRef &Reloc : S.relocations()) 802 RelocMap[Section].push_back(Reloc); 803 804 // Sort relocations by address. 805 std::sort(RelocMap[Section].begin(), RelocMap[Section].end(), 806 relocAddressLess); 807 } 808 } 809 810 void COFFDumper::printDataDirectory(uint32_t Index, const std::string &FieldName) { 811 const data_directory *Data; 812 if (Obj->getDataDirectory(Index, Data)) 813 return; 814 W.printHex(FieldName + "RVA", Data->RelativeVirtualAddress); 815 W.printHex(FieldName + "Size", Data->Size); 816 } 817 818 void COFFDumper::printFileHeaders() { 819 time_t TDS = Obj->getTimeDateStamp(); 820 char FormattedTime[20] = { }; 821 strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS)); 822 823 { 824 DictScope D(W, "ImageFileHeader"); 825 W.printEnum ("Machine", Obj->getMachine(), 826 makeArrayRef(ImageFileMachineType)); 827 W.printNumber("SectionCount", Obj->getNumberOfSections()); 828 W.printHex ("TimeDateStamp", FormattedTime, Obj->getTimeDateStamp()); 829 W.printHex ("PointerToSymbolTable", Obj->getPointerToSymbolTable()); 830 W.printNumber("SymbolCount", Obj->getNumberOfSymbols()); 831 W.printNumber("OptionalHeaderSize", Obj->getSizeOfOptionalHeader()); 832 W.printFlags ("Characteristics", Obj->getCharacteristics(), 833 makeArrayRef(ImageFileCharacteristics)); 834 } 835 836 // Print PE header. This header does not exist if this is an object file and 837 // not an executable. 838 const pe32_header *PEHeader = nullptr; 839 error(Obj->getPE32Header(PEHeader)); 840 if (PEHeader) 841 printPEHeader<pe32_header>(PEHeader); 842 843 const pe32plus_header *PEPlusHeader = nullptr; 844 error(Obj->getPE32PlusHeader(PEPlusHeader)); 845 if (PEPlusHeader) 846 printPEHeader<pe32plus_header>(PEPlusHeader); 847 848 if (const dos_header *DH = Obj->getDOSHeader()) 849 printDOSHeader(DH); 850 } 851 852 void COFFDumper::printDOSHeader(const dos_header *DH) { 853 DictScope D(W, "DOSHeader"); 854 W.printString("Magic", StringRef(DH->Magic, sizeof(DH->Magic))); 855 W.printNumber("UsedBytesInTheLastPage", DH->UsedBytesInTheLastPage); 856 W.printNumber("FileSizeInPages", DH->FileSizeInPages); 857 W.printNumber("NumberOfRelocationItems", DH->NumberOfRelocationItems); 858 W.printNumber("HeaderSizeInParagraphs", DH->HeaderSizeInParagraphs); 859 W.printNumber("MinimumExtraParagraphs", DH->MinimumExtraParagraphs); 860 W.printNumber("MaximumExtraParagraphs", DH->MaximumExtraParagraphs); 861 W.printNumber("InitialRelativeSS", DH->InitialRelativeSS); 862 W.printNumber("InitialSP", DH->InitialSP); 863 W.printNumber("Checksum", DH->Checksum); 864 W.printNumber("InitialIP", DH->InitialIP); 865 W.printNumber("InitialRelativeCS", DH->InitialRelativeCS); 866 W.printNumber("AddressOfRelocationTable", DH->AddressOfRelocationTable); 867 W.printNumber("OverlayNumber", DH->OverlayNumber); 868 W.printNumber("OEMid", DH->OEMid); 869 W.printNumber("OEMinfo", DH->OEMinfo); 870 W.printNumber("AddressOfNewExeHeader", DH->AddressOfNewExeHeader); 871 } 872 873 template <class PEHeader> 874 void COFFDumper::printPEHeader(const PEHeader *Hdr) { 875 DictScope D(W, "ImageOptionalHeader"); 876 W.printNumber("MajorLinkerVersion", Hdr->MajorLinkerVersion); 877 W.printNumber("MinorLinkerVersion", Hdr->MinorLinkerVersion); 878 W.printNumber("SizeOfCode", Hdr->SizeOfCode); 879 W.printNumber("SizeOfInitializedData", Hdr->SizeOfInitializedData); 880 W.printNumber("SizeOfUninitializedData", Hdr->SizeOfUninitializedData); 881 W.printHex ("AddressOfEntryPoint", Hdr->AddressOfEntryPoint); 882 W.printHex ("BaseOfCode", Hdr->BaseOfCode); 883 printBaseOfDataField(Hdr); 884 W.printHex ("ImageBase", Hdr->ImageBase); 885 W.printNumber("SectionAlignment", Hdr->SectionAlignment); 886 W.printNumber("FileAlignment", Hdr->FileAlignment); 887 W.printNumber("MajorOperatingSystemVersion", 888 Hdr->MajorOperatingSystemVersion); 889 W.printNumber("MinorOperatingSystemVersion", 890 Hdr->MinorOperatingSystemVersion); 891 W.printNumber("MajorImageVersion", Hdr->MajorImageVersion); 892 W.printNumber("MinorImageVersion", Hdr->MinorImageVersion); 893 W.printNumber("MajorSubsystemVersion", Hdr->MajorSubsystemVersion); 894 W.printNumber("MinorSubsystemVersion", Hdr->MinorSubsystemVersion); 895 W.printNumber("SizeOfImage", Hdr->SizeOfImage); 896 W.printNumber("SizeOfHeaders", Hdr->SizeOfHeaders); 897 W.printEnum ("Subsystem", Hdr->Subsystem, makeArrayRef(PEWindowsSubsystem)); 898 W.printFlags ("Characteristics", Hdr->DLLCharacteristics, 899 makeArrayRef(PEDLLCharacteristics)); 900 W.printNumber("SizeOfStackReserve", Hdr->SizeOfStackReserve); 901 W.printNumber("SizeOfStackCommit", Hdr->SizeOfStackCommit); 902 W.printNumber("SizeOfHeapReserve", Hdr->SizeOfHeapReserve); 903 W.printNumber("SizeOfHeapCommit", Hdr->SizeOfHeapCommit); 904 W.printNumber("NumberOfRvaAndSize", Hdr->NumberOfRvaAndSize); 905 906 if (Hdr->NumberOfRvaAndSize > 0) { 907 DictScope D(W, "DataDirectory"); 908 static const char * const directory[] = { 909 "ExportTable", "ImportTable", "ResourceTable", "ExceptionTable", 910 "CertificateTable", "BaseRelocationTable", "Debug", "Architecture", 911 "GlobalPtr", "TLSTable", "LoadConfigTable", "BoundImport", "IAT", 912 "DelayImportDescriptor", "CLRRuntimeHeader", "Reserved" 913 }; 914 915 for (uint32_t i = 0; i < Hdr->NumberOfRvaAndSize; ++i) { 916 printDataDirectory(i, directory[i]); 917 } 918 } 919 } 920 921 void COFFDumper::printBaseOfDataField(const pe32_header *Hdr) { 922 W.printHex("BaseOfData", Hdr->BaseOfData); 923 } 924 925 void COFFDumper::printBaseOfDataField(const pe32plus_header *) {} 926 927 void COFFDumper::printCodeViewDebugInfo() { 928 // Print types first to build CVUDTNames, then print symbols. 929 for (const SectionRef &S : Obj->sections()) { 930 StringRef SectionName; 931 error(S.getName(SectionName)); 932 if (SectionName == ".debug$T") 933 printCodeViewTypeSection(SectionName, S); 934 } 935 for (const SectionRef &S : Obj->sections()) { 936 StringRef SectionName; 937 error(S.getName(SectionName)); 938 if (SectionName == ".debug$S") 939 printCodeViewSymbolSection(SectionName, S); 940 } 941 } 942 943 /// Consumes sizeof(T) bytes from the given byte sequence. Returns an error if 944 /// there are not enough bytes remaining. Reinterprets the consumed bytes as a 945 /// T object and points 'Res' at them. 946 template <typename T> 947 static std::error_code consumeObject(StringRef &Data, const T *&Res) { 948 if (Data.size() < sizeof(*Res)) 949 return object_error::parse_failed; 950 Res = reinterpret_cast<const T *>(Data.data()); 951 Data = Data.drop_front(sizeof(*Res)); 952 return std::error_code(); 953 } 954 955 static std::error_code consumeUInt32(StringRef &Data, uint32_t &Res) { 956 const ulittle32_t *IntPtr; 957 if (auto EC = consumeObject(Data, IntPtr)) 958 return EC; 959 Res = *IntPtr; 960 return std::error_code(); 961 } 962 963 void COFFDumper::initializeFileAndStringTables(StringRef Data) { 964 while (!Data.empty() && (CVFileChecksumTable.data() == nullptr || 965 CVStringTable.data() == nullptr)) { 966 // The section consists of a number of subsection in the following format: 967 // |SubSectionType|SubSectionSize|Contents...| 968 uint32_t SubType, SubSectionSize; 969 error(consumeUInt32(Data, SubType)); 970 error(consumeUInt32(Data, SubSectionSize)); 971 if (SubSectionSize > Data.size()) 972 return error(object_error::parse_failed); 973 switch (ModuleSubstreamKind(SubType)) { 974 case ModuleSubstreamKind::FileChecksums: 975 CVFileChecksumTable = Data.substr(0, SubSectionSize); 976 break; 977 case ModuleSubstreamKind::StringTable: 978 CVStringTable = Data.substr(0, SubSectionSize); 979 break; 980 default: 981 break; 982 } 983 Data = Data.drop_front(alignTo(SubSectionSize, 4)); 984 } 985 } 986 987 void COFFDumper::printCodeViewSymbolSection(StringRef SectionName, 988 const SectionRef &Section) { 989 StringRef SectionContents; 990 error(Section.getContents(SectionContents)); 991 StringRef Data = SectionContents; 992 993 SmallVector<StringRef, 10> FunctionNames; 994 StringMap<StringRef> FunctionLineTables; 995 996 ListScope D(W, "CodeViewDebugInfo"); 997 // Print the section to allow correlation with printSections. 998 W.printNumber("Section", SectionName, Obj->getSectionID(Section)); 999 1000 uint32_t Magic; 1001 error(consumeUInt32(Data, Magic)); 1002 W.printHex("Magic", Magic); 1003 if (Magic != COFF::DEBUG_SECTION_MAGIC) 1004 return error(object_error::parse_failed); 1005 1006 initializeFileAndStringTables(Data); 1007 1008 while (!Data.empty()) { 1009 // The section consists of a number of subsection in the following format: 1010 // |SubSectionType|SubSectionSize|Contents...| 1011 uint32_t SubType, SubSectionSize; 1012 error(consumeUInt32(Data, SubType)); 1013 error(consumeUInt32(Data, SubSectionSize)); 1014 1015 ListScope S(W, "Subsection"); 1016 W.printEnum("SubSectionType", SubType, makeArrayRef(SubSectionTypes)); 1017 W.printHex("SubSectionSize", SubSectionSize); 1018 1019 // Get the contents of the subsection. 1020 if (SubSectionSize > Data.size()) 1021 return error(object_error::parse_failed); 1022 StringRef Contents = Data.substr(0, SubSectionSize); 1023 1024 // Add SubSectionSize to the current offset and align that offset to find 1025 // the next subsection. 1026 size_t SectionOffset = Data.data() - SectionContents.data(); 1027 size_t NextOffset = SectionOffset + SubSectionSize; 1028 NextOffset = alignTo(NextOffset, 4); 1029 Data = SectionContents.drop_front(NextOffset); 1030 1031 // Optionally print the subsection bytes in case our parsing gets confused 1032 // later. 1033 if (opts::CodeViewSubsectionBytes) 1034 printBinaryBlockWithRelocs("SubSectionContents", Section, SectionContents, 1035 Contents); 1036 1037 switch (ModuleSubstreamKind(SubType)) { 1038 case ModuleSubstreamKind::Symbols: 1039 printCodeViewSymbolsSubsection(Contents, Section, SectionContents); 1040 break; 1041 1042 case ModuleSubstreamKind::InlineeLines: 1043 printCodeViewInlineeLines(Contents); 1044 break; 1045 1046 case ModuleSubstreamKind::FileChecksums: 1047 printCodeViewFileChecksums(Contents); 1048 break; 1049 1050 case ModuleSubstreamKind::Lines: { 1051 // Holds a PC to file:line table. Some data to parse this subsection is 1052 // stored in the other subsections, so just check sanity and store the 1053 // pointers for deferred processing. 1054 1055 if (SubSectionSize < 12) { 1056 // There should be at least three words to store two function 1057 // relocations and size of the code. 1058 error(object_error::parse_failed); 1059 return; 1060 } 1061 1062 StringRef LinkageName; 1063 error(resolveSymbolName(Obj->getCOFFSection(Section), SectionOffset, 1064 LinkageName)); 1065 W.printString("LinkageName", LinkageName); 1066 if (FunctionLineTables.count(LinkageName) != 0) { 1067 // Saw debug info for this function already? 1068 error(object_error::parse_failed); 1069 return; 1070 } 1071 1072 FunctionLineTables[LinkageName] = Contents; 1073 FunctionNames.push_back(LinkageName); 1074 break; 1075 } 1076 case ModuleSubstreamKind::FrameData: { 1077 // First four bytes is a relocation against the function. 1078 const uint32_t *CodePtr; 1079 error(consumeObject(Contents, CodePtr)); 1080 StringRef LinkageName; 1081 error(resolveSymbolName(Obj->getCOFFSection(Section), SectionContents, 1082 CodePtr, LinkageName)); 1083 W.printString("LinkageName", LinkageName); 1084 1085 // To find the active frame description, search this array for the 1086 // smallest PC range that includes the current PC. 1087 while (!Contents.empty()) { 1088 const FrameData *FD; 1089 error(consumeObject(Contents, FD)); 1090 DictScope S(W, "FrameData"); 1091 W.printHex("RvaStart", FD->RvaStart); 1092 W.printHex("CodeSize", FD->CodeSize); 1093 W.printHex("LocalSize", FD->LocalSize); 1094 W.printHex("ParamsSize", FD->ParamsSize); 1095 W.printHex("MaxStackSize", FD->MaxStackSize); 1096 W.printString("FrameFunc", 1097 CVStringTable.drop_front(FD->FrameFunc).split('\0').first); 1098 W.printHex("PrologSize", FD->PrologSize); 1099 W.printHex("SavedRegsSize", FD->SavedRegsSize); 1100 W.printFlags("Flags", FD->Flags, makeArrayRef(FrameDataFlags)); 1101 } 1102 break; 1103 } 1104 1105 // Do nothing for unrecognized subsections. 1106 default: 1107 break; 1108 } 1109 W.flush(); 1110 } 1111 1112 // Dump the line tables now that we've read all the subsections and know all 1113 // the required information. 1114 for (unsigned I = 0, E = FunctionNames.size(); I != E; ++I) { 1115 StringRef Name = FunctionNames[I]; 1116 ListScope S(W, "FunctionLineTable"); 1117 W.printString("LinkageName", Name); 1118 1119 DataExtractor DE(FunctionLineTables[Name], true, 4); 1120 uint32_t Offset = 6; // Skip relocations. 1121 uint16_t Flags = DE.getU16(&Offset); 1122 W.printHex("Flags", Flags); 1123 bool HasColumnInformation = Flags & codeview::LineFlags::HaveColumns; 1124 uint32_t FunctionSize = DE.getU32(&Offset); 1125 W.printHex("CodeSize", FunctionSize); 1126 while (DE.isValidOffset(Offset)) { 1127 // For each range of lines with the same filename, we have a segment 1128 // in the line table. The filename string is accessed using double 1129 // indirection to the string table subsection using the index subsection. 1130 uint32_t OffsetInIndex = DE.getU32(&Offset), 1131 NumLines = DE.getU32(&Offset), 1132 FullSegmentSize = DE.getU32(&Offset); 1133 1134 uint32_t ColumnOffset = Offset + 8 * NumLines; 1135 DataExtractor ColumnDE(DE.getData(), true, 4); 1136 1137 if (FullSegmentSize != 1138 12 + 8 * NumLines + (HasColumnInformation ? 4 * NumLines : 0)) { 1139 error(object_error::parse_failed); 1140 return; 1141 } 1142 1143 ListScope S(W, "FilenameSegment"); 1144 printFileNameForOffset("Filename", OffsetInIndex); 1145 for (unsigned LineIdx = 0; 1146 LineIdx != NumLines && DE.isValidOffset(Offset); ++LineIdx) { 1147 // Then go the (PC, LineNumber) pairs. The line number is stored in the 1148 // least significant 31 bits of the respective word in the table. 1149 uint32_t PC = DE.getU32(&Offset), LineData = DE.getU32(&Offset); 1150 if (PC >= FunctionSize) { 1151 error(object_error::parse_failed); 1152 return; 1153 } 1154 char Buffer[32]; 1155 format("+0x%X", PC).snprint(Buffer, 32); 1156 ListScope PCScope(W, Buffer); 1157 LineInfo LI(LineData); 1158 if (LI.isAlwaysStepInto()) 1159 W.printString("StepInto", StringRef("Always")); 1160 else if (LI.isNeverStepInto()) 1161 W.printString("StepInto", StringRef("Never")); 1162 else 1163 W.printNumber("LineNumberStart", LI.getStartLine()); 1164 W.printNumber("LineNumberEndDelta", LI.getLineDelta()); 1165 W.printBoolean("IsStatement", LI.isStatement()); 1166 if (HasColumnInformation && 1167 ColumnDE.isValidOffsetForDataOfSize(ColumnOffset, 4)) { 1168 uint16_t ColStart = ColumnDE.getU16(&ColumnOffset); 1169 W.printNumber("ColStart", ColStart); 1170 uint16_t ColEnd = ColumnDE.getU16(&ColumnOffset); 1171 W.printNumber("ColEnd", ColEnd); 1172 } 1173 } 1174 // Skip over the column data. 1175 if (HasColumnInformation) { 1176 for (unsigned LineIdx = 0; 1177 LineIdx != NumLines && DE.isValidOffset(Offset); ++LineIdx) { 1178 DE.getU32(&Offset); 1179 } 1180 } 1181 } 1182 } 1183 } 1184 1185 static std::error_code decodeNumerictLeaf(StringRef &Data, APSInt &Num) { 1186 // Used to avoid overload ambiguity on APInt construtor. 1187 bool FalseVal = false; 1188 if (Data.size() < 2) 1189 return object_error::parse_failed; 1190 uint16_t Short = *reinterpret_cast<const ulittle16_t *>(Data.data()); 1191 Data = Data.drop_front(2); 1192 if (Short < LF_NUMERIC) { 1193 Num = APSInt(APInt(/*numBits=*/16, Short, /*isSigned=*/false), 1194 /*isUnsigned=*/true); 1195 return std::error_code(); 1196 } 1197 switch (Short) { 1198 case LF_CHAR: 1199 Num = APSInt(APInt(/*numBits=*/8, 1200 *reinterpret_cast<const int8_t *>(Data.data()), 1201 /*isSigned=*/true), 1202 /*isUnsigned=*/false); 1203 Data = Data.drop_front(1); 1204 return std::error_code(); 1205 case LF_SHORT: 1206 Num = APSInt(APInt(/*numBits=*/16, 1207 *reinterpret_cast<const little16_t *>(Data.data()), 1208 /*isSigned=*/true), 1209 /*isUnsigned=*/false); 1210 Data = Data.drop_front(2); 1211 return std::error_code(); 1212 case LF_USHORT: 1213 Num = APSInt(APInt(/*numBits=*/16, 1214 *reinterpret_cast<const ulittle16_t *>(Data.data()), 1215 /*isSigned=*/false), 1216 /*isUnsigned=*/true); 1217 Data = Data.drop_front(2); 1218 return std::error_code(); 1219 case LF_LONG: 1220 Num = APSInt(APInt(/*numBits=*/32, 1221 *reinterpret_cast<const little32_t *>(Data.data()), 1222 /*isSigned=*/true), 1223 /*isUnsigned=*/false); 1224 Data = Data.drop_front(4); 1225 return std::error_code(); 1226 case LF_ULONG: 1227 Num = APSInt(APInt(/*numBits=*/32, 1228 *reinterpret_cast<const ulittle32_t *>(Data.data()), 1229 /*isSigned=*/FalseVal), 1230 /*isUnsigned=*/true); 1231 Data = Data.drop_front(4); 1232 return std::error_code(); 1233 case LF_QUADWORD: 1234 Num = APSInt(APInt(/*numBits=*/64, 1235 *reinterpret_cast<const little64_t *>(Data.data()), 1236 /*isSigned=*/true), 1237 /*isUnsigned=*/false); 1238 Data = Data.drop_front(8); 1239 return std::error_code(); 1240 case LF_UQUADWORD: 1241 Num = APSInt(APInt(/*numBits=*/64, 1242 *reinterpret_cast<const ulittle64_t *>(Data.data()), 1243 /*isSigned=*/false), 1244 /*isUnsigned=*/true); 1245 Data = Data.drop_front(8); 1246 return std::error_code(); 1247 } 1248 return object_error::parse_failed; 1249 } 1250 1251 /// Decode an unsigned integer numeric leaf value. 1252 std::error_code decodeUIntLeaf(StringRef &Data, uint64_t &Num) { 1253 APSInt N; 1254 if (std::error_code err = decodeNumerictLeaf(Data, N)) 1255 return err; 1256 if (N.isSigned() || !N.isIntN(64)) 1257 return object_error::parse_failed; 1258 Num = N.getLimitedValue(); 1259 return std::error_code(); 1260 } 1261 1262 void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection, 1263 const SectionRef &Section, 1264 StringRef SectionContents) { 1265 if (Subsection.size() < sizeof(SymRecord)) 1266 return error(object_error::parse_failed); 1267 1268 const coff_section *Sec = Obj->getCOFFSection(Section); 1269 1270 // This holds the remaining data to parse. 1271 StringRef Data = Subsection; 1272 1273 bool InFunctionScope = false; 1274 while (!Data.empty()) { 1275 const SymRecord *Rec; 1276 error(consumeObject(Data, Rec)); 1277 1278 StringRef SymData = Data.substr(0, Rec->RecordLength - 2); 1279 StringRef OrigSymData = SymData; 1280 1281 Data = Data.drop_front(Rec->RecordLength - 2); 1282 1283 SymbolRecordKind Kind = Rec->getKind(); 1284 switch (Kind) { 1285 case S_LPROC32: 1286 case S_GPROC32: 1287 case S_GPROC32_ID: 1288 case S_LPROC32_ID: 1289 case S_LPROC32_DPC: 1290 case S_LPROC32_DPC_ID: { 1291 DictScope S(W, "ProcStart"); 1292 const ProcSym *Proc; 1293 error(consumeObject(SymData, Proc)); 1294 if (InFunctionScope) 1295 return error(object_error::parse_failed); 1296 InFunctionScope = true; 1297 1298 StringRef LinkageName; 1299 StringRef DisplayName = SymData.split('\0').first; 1300 W.printHex("PtrParent", Proc->PtrParent); 1301 W.printHex("PtrEnd", Proc->PtrEnd); 1302 W.printHex("PtrNext", Proc->PtrNext); 1303 W.printHex("CodeSize", Proc->CodeSize); 1304 W.printHex("DbgStart", Proc->DbgStart); 1305 W.printHex("DbgEnd", Proc->DbgEnd); 1306 printTypeIndex("FunctionType", Proc->FunctionType); 1307 printRelocatedField("CodeOffset", Sec, SectionContents, &Proc->CodeOffset, 1308 &LinkageName); 1309 W.printHex("Segment", Proc->Segment); 1310 W.printFlags("Flags", Proc->Flags, makeArrayRef(ProcSymFlags)); 1311 W.printString("DisplayName", DisplayName); 1312 W.printString("LinkageName", LinkageName); 1313 break; 1314 } 1315 1316 case S_PROC_ID_END: { 1317 W.startLine() << "ProcEnd\n"; 1318 InFunctionScope = false; 1319 break; 1320 } 1321 1322 case S_BLOCK32: { 1323 DictScope S(W, "BlockStart"); 1324 const BlockSym *Block; 1325 error(consumeObject(SymData, Block)); 1326 1327 StringRef BlockName = SymData.split('\0').first; 1328 StringRef LinkageName; 1329 W.printHex("PtrParent", Block->PtrParent); 1330 W.printHex("PtrEnd", Block->PtrEnd); 1331 W.printHex("CodeSize", Block->CodeSize); 1332 printRelocatedField("CodeOffset", Sec, SectionContents, 1333 &Block->CodeOffset, &LinkageName); 1334 W.printHex("Segment", Block->Segment); 1335 W.printString("BlockName", BlockName); 1336 W.printString("LinkageName", LinkageName); 1337 break; 1338 } 1339 1340 case S_END: { 1341 W.startLine() << "BlockEnd\n"; 1342 InFunctionScope = false; 1343 break; 1344 } 1345 1346 case S_LABEL32: { 1347 DictScope S(W, "Label"); 1348 const LabelSym *Label; 1349 error(consumeObject(SymData, Label)); 1350 1351 StringRef DisplayName = SymData.split('\0').first; 1352 StringRef LinkageName; 1353 printRelocatedField("CodeOffset", Sec, SectionContents, 1354 &Label->CodeOffset, &LinkageName); 1355 W.printHex("Segment", Label->Segment); 1356 W.printHex("Flags", Label->Flags); 1357 W.printFlags("Flags", Label->Flags, makeArrayRef(ProcSymFlags)); 1358 W.printString("DisplayName", DisplayName); 1359 W.printString("LinkageName", LinkageName); 1360 break; 1361 } 1362 1363 case S_INLINESITE: { 1364 DictScope S(W, "InlineSite"); 1365 const InlineSiteSym *InlineSite; 1366 error(consumeObject(SymData, InlineSite)); 1367 W.printHex("PtrParent", InlineSite->PtrParent); 1368 W.printHex("PtrEnd", InlineSite->PtrEnd); 1369 printTypeIndex("Inlinee", InlineSite->Inlinee); 1370 1371 auto GetCompressedAnnotation = [&]() -> uint32_t { 1372 if (SymData.empty()) 1373 return -1; 1374 1375 uint8_t FirstByte = SymData.front(); 1376 SymData = SymData.drop_front(); 1377 1378 if ((FirstByte & 0x80) == 0x00) 1379 return FirstByte; 1380 1381 if (SymData.empty()) 1382 return -1; 1383 1384 uint8_t SecondByte = SymData.front(); 1385 SymData = SymData.drop_front(); 1386 1387 if ((FirstByte & 0xC0) == 0x80) 1388 return ((FirstByte & 0x3F) << 8) | SecondByte; 1389 1390 if (SymData.empty()) 1391 return -1; 1392 1393 uint8_t ThirdByte = SymData.front(); 1394 SymData = SymData.drop_front(); 1395 1396 if (SymData.empty()) 1397 return -1; 1398 1399 uint8_t FourthByte = SymData.front(); 1400 SymData = SymData.drop_front(); 1401 1402 if ((FirstByte & 0xE0) == 0xC0) 1403 return ((FirstByte & 0x1F) << 24) | (SecondByte << 16) | 1404 (ThirdByte << 8) | FourthByte; 1405 1406 return -1; 1407 }; 1408 auto DecodeSignedOperand = [](uint32_t Operand) -> int32_t { 1409 if (Operand & 1) 1410 return -(Operand >> 1); 1411 return Operand >> 1; 1412 }; 1413 1414 ListScope BinaryAnnotations(W, "BinaryAnnotations"); 1415 while (!SymData.empty()) { 1416 uint32_t OpCode = GetCompressedAnnotation(); 1417 switch (OpCode) { 1418 default: 1419 case Invalid: 1420 return error(object_error::parse_failed); 1421 case CodeOffset: 1422 W.printHex("CodeOffset", GetCompressedAnnotation()); 1423 break; 1424 case ChangeCodeOffsetBase: 1425 W.printNumber("ChangeCodeOffsetBase", GetCompressedAnnotation()); 1426 break; 1427 case ChangeCodeOffset: 1428 W.printHex("ChangeCodeOffset", GetCompressedAnnotation()); 1429 break; 1430 case ChangeCodeLength: 1431 W.printHex("ChangeCodeLength", GetCompressedAnnotation()); 1432 break; 1433 case ChangeFile: 1434 printFileNameForOffset("ChangeFile", GetCompressedAnnotation()); 1435 break; 1436 case ChangeLineOffset: 1437 W.printNumber("ChangeLineOffset", 1438 DecodeSignedOperand(GetCompressedAnnotation())); 1439 break; 1440 case ChangeLineEndDelta: 1441 W.printNumber("ChangeLineEndDelta", GetCompressedAnnotation()); 1442 break; 1443 case ChangeRangeKind: 1444 W.printNumber("ChangeRangeKind", GetCompressedAnnotation()); 1445 break; 1446 case ChangeColumnStart: 1447 W.printNumber("ChangeColumnStart", GetCompressedAnnotation()); 1448 break; 1449 case ChangeColumnEndDelta: 1450 W.printNumber("ChangeColumnEndDelta", 1451 DecodeSignedOperand(GetCompressedAnnotation())); 1452 break; 1453 case ChangeCodeOffsetAndLineOffset: { 1454 uint32_t Annotation = GetCompressedAnnotation(); 1455 int32_t LineOffset = DecodeSignedOperand(Annotation >> 4); 1456 uint32_t CodeOffset = Annotation & 0xf; 1457 W.startLine() << "ChangeCodeOffsetAndLineOffset: {CodeOffset: " 1458 << W.hex(CodeOffset) << ", LineOffset: " << LineOffset 1459 << "}\n"; 1460 break; 1461 } 1462 case ChangeCodeLengthAndCodeOffset: { 1463 uint32_t Length = GetCompressedAnnotation(); 1464 uint32_t CodeOffset = GetCompressedAnnotation(); 1465 W.startLine() << "ChangeCodeLengthAndCodeOffset: {CodeOffset: " 1466 << W.hex(CodeOffset) << ", Length: " << W.hex(Length) 1467 << "}\n"; 1468 break; 1469 } 1470 case ChangeColumnEnd: 1471 W.printNumber("ChangeColumnEnd", GetCompressedAnnotation()); 1472 break; 1473 } 1474 } 1475 break; 1476 } 1477 1478 case S_INLINESITE_END: { 1479 DictScope S(W, "InlineSiteEnd"); 1480 break; 1481 } 1482 1483 case S_CALLERS: 1484 case S_CALLEES: { 1485 ListScope S(W, Kind == S_CALLEES ? "Callees" : "Callers"); 1486 uint32_t Count; 1487 error(consumeUInt32(SymData, Count)); 1488 for (uint32_t I = 0; I < Count; ++I) { 1489 const TypeIndex *FuncID; 1490 error(consumeObject(SymData, FuncID)); 1491 printTypeIndex("FuncID", *FuncID); 1492 } 1493 break; 1494 } 1495 1496 case S_LOCAL: { 1497 DictScope S(W, "Local"); 1498 const LocalSym *Local; 1499 error(consumeObject(SymData, Local)); 1500 printTypeIndex("Type", Local->Type); 1501 W.printFlags("Flags", uint16_t(Local->Flags), makeArrayRef(LocalFlags)); 1502 StringRef VarName = SymData.split('\0').first; 1503 W.printString("VarName", VarName); 1504 break; 1505 } 1506 1507 case S_DEFRANGE: { 1508 DictScope S(W, "DefRange"); 1509 const DefRangeSym *DefRange; 1510 error(consumeObject(SymData, DefRange)); 1511 W.printString( 1512 "Program", 1513 CVStringTable.drop_front(DefRange->Program).split('\0').first); 1514 printLocalVariableAddrRange(DefRange->Range, Sec, SectionContents); 1515 printLocalVariableAddrGap(SymData); 1516 break; 1517 } 1518 case S_DEFRANGE_SUBFIELD: { 1519 DictScope S(W, "DefRangeSubfield"); 1520 const DefRangeSubfieldSym *DefRangeSubfield; 1521 error(consumeObject(SymData, DefRangeSubfield)); 1522 W.printString("Program", 1523 CVStringTable.drop_front(DefRangeSubfield->Program) 1524 .split('\0') 1525 .first); 1526 W.printNumber("OffsetInParent", DefRangeSubfield->OffsetInParent); 1527 printLocalVariableAddrRange(DefRangeSubfield->Range, Sec, 1528 SectionContents); 1529 printLocalVariableAddrGap(SymData); 1530 break; 1531 } 1532 case S_DEFRANGE_REGISTER: { 1533 DictScope S(W, "DefRangeRegister"); 1534 const DefRangeRegisterSym *DefRangeRegister; 1535 error(consumeObject(SymData, DefRangeRegister)); 1536 W.printNumber("Register", DefRangeRegister->Register); 1537 W.printNumber("MayHaveNoName", DefRangeRegister->MayHaveNoName); 1538 printLocalVariableAddrRange(DefRangeRegister->Range, Sec, 1539 SectionContents); 1540 printLocalVariableAddrGap(SymData); 1541 break; 1542 } 1543 case S_DEFRANGE_SUBFIELD_REGISTER: { 1544 DictScope S(W, "DefRangeSubfieldRegister"); 1545 const DefRangeSubfieldRegisterSym *DefRangeSubfieldRegisterSym; 1546 error(consumeObject(SymData, DefRangeSubfieldRegisterSym)); 1547 W.printNumber("Register", DefRangeSubfieldRegisterSym->Register); 1548 W.printNumber("MayHaveNoName", 1549 DefRangeSubfieldRegisterSym->MayHaveNoName); 1550 W.printNumber("OffsetInParent", 1551 DefRangeSubfieldRegisterSym->OffsetInParent); 1552 printLocalVariableAddrRange(DefRangeSubfieldRegisterSym->Range, Sec, 1553 SectionContents); 1554 printLocalVariableAddrGap(SymData); 1555 break; 1556 } 1557 case S_DEFRANGE_FRAMEPOINTER_REL: { 1558 DictScope S(W, "DefRangeFramePointerRel"); 1559 const DefRangeFramePointerRelSym *DefRangeFramePointerRel; 1560 error(consumeObject(SymData, DefRangeFramePointerRel)); 1561 W.printNumber("Offset", DefRangeFramePointerRel->Offset); 1562 printLocalVariableAddrRange(DefRangeFramePointerRel->Range, Sec, 1563 SectionContents); 1564 printLocalVariableAddrGap(SymData); 1565 break; 1566 } 1567 case S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE: { 1568 DictScope S(W, "DefRangeFramePointerRelFullScope"); 1569 const DefRangeFramePointerRelFullScopeSym 1570 *DefRangeFramePointerRelFullScope; 1571 error(consumeObject(SymData, DefRangeFramePointerRelFullScope)); 1572 W.printNumber("Offset", DefRangeFramePointerRelFullScope->Offset); 1573 break; 1574 } 1575 case S_DEFRANGE_REGISTER_REL: { 1576 DictScope S(W, "DefRangeRegisterRel"); 1577 const DefRangeRegisterRelSym *DefRangeRegisterRel; 1578 error(consumeObject(SymData, DefRangeRegisterRel)); 1579 W.printNumber("BaseRegister", DefRangeRegisterRel->BaseRegister); 1580 W.printBoolean("HasSpilledUDTMember", 1581 DefRangeRegisterRel->hasSpilledUDTMember()); 1582 W.printNumber("OffsetInParent", DefRangeRegisterRel->offsetInParent()); 1583 W.printNumber("BasePointerOffset", 1584 DefRangeRegisterRel->BasePointerOffset); 1585 printLocalVariableAddrRange(DefRangeRegisterRel->Range, Sec, 1586 SectionContents); 1587 printLocalVariableAddrGap(SymData); 1588 break; 1589 } 1590 1591 case S_CALLSITEINFO: { 1592 DictScope S(W, "CallSiteInfo"); 1593 const CallSiteInfoSym *CallSiteInfo; 1594 error(consumeObject(SymData, CallSiteInfo)); 1595 1596 StringRef LinkageName; 1597 printRelocatedField("CodeOffset", Sec, SectionContents, 1598 &CallSiteInfo->CodeOffset, &LinkageName); 1599 W.printHex("Segment", CallSiteInfo->Segment); 1600 W.printHex("Reserved", CallSiteInfo->Reserved); 1601 printTypeIndex("Type", CallSiteInfo->Type); 1602 W.printString("LinkageName", LinkageName); 1603 break; 1604 } 1605 1606 case S_HEAPALLOCSITE: { 1607 DictScope S(W, "HeapAllocationSite"); 1608 const HeapAllocationSiteSym *HeapAllocationSite; 1609 error(consumeObject(SymData, HeapAllocationSite)); 1610 1611 StringRef LinkageName; 1612 printRelocatedField("CodeOffset", Sec, SectionContents, 1613 &HeapAllocationSite->CodeOffset, &LinkageName); 1614 W.printHex("Segment", HeapAllocationSite->Segment); 1615 W.printHex("CallInstructionSize", 1616 HeapAllocationSite->CallInstructionSize); 1617 printTypeIndex("Type", HeapAllocationSite->Type); 1618 W.printString("LinkageName", LinkageName); 1619 break; 1620 } 1621 1622 case S_FRAMECOOKIE: { 1623 DictScope S(W, "FrameCookie"); 1624 const FrameCookieSym *FrameCookie; 1625 error(consumeObject(SymData, FrameCookie)); 1626 1627 StringRef LinkageName; 1628 printRelocatedField("CodeOffset", Sec, SectionContents, 1629 &FrameCookie->CodeOffset, &LinkageName); 1630 W.printHex("Register", FrameCookie->Register); 1631 W.printEnum("CookieKind", uint16_t(FrameCookie->CookieKind), 1632 makeArrayRef(FrameCookieKinds)); 1633 break; 1634 } 1635 1636 case S_LDATA32: 1637 case S_GDATA32: 1638 case S_LMANDATA: 1639 case S_GMANDATA: { 1640 DictScope S(W, "DataSym"); 1641 const DataSym *Data; 1642 error(consumeObject(SymData, Data)); 1643 1644 StringRef DisplayName = SymData.split('\0').first; 1645 StringRef LinkageName; 1646 printRelocatedField("DataOffset", Sec, SectionContents, &Data->DataOffset, 1647 &LinkageName); 1648 printTypeIndex("Type", Data->Type); 1649 W.printString("DisplayName", DisplayName); 1650 W.printString("LinkageName", LinkageName); 1651 break; 1652 } 1653 1654 case S_LTHREAD32: 1655 case S_GTHREAD32: { 1656 DictScope S(W, "ThreadLocalDataSym"); 1657 const ThreadLocalDataSym *Data; 1658 error(consumeObject(SymData, Data)); 1659 1660 StringRef DisplayName = SymData.split('\0').first; 1661 StringRef LinkageName; 1662 printRelocatedField("DataOffset", Sec, SectionContents, &Data->DataOffset, 1663 &LinkageName); 1664 printTypeIndex("Type", Data->Type); 1665 W.printString("DisplayName", DisplayName); 1666 W.printString("LinkageName", LinkageName); 1667 break; 1668 } 1669 1670 case S_OBJNAME: { 1671 DictScope S(W, "ObjectName"); 1672 const ObjNameSym *ObjName; 1673 error(consumeObject(SymData, ObjName)); 1674 W.printHex("Signature", ObjName->Signature); 1675 StringRef ObjectName = SymData.split('\0').first; 1676 W.printString("ObjectName", ObjectName); 1677 break; 1678 } 1679 1680 case S_COMPILE3: { 1681 DictScope S(W, "CompilerFlags"); 1682 const CompileSym3 *CompFlags; 1683 error(consumeObject(SymData, CompFlags)); 1684 W.printEnum("Language", CompFlags->getLanguage(), 1685 makeArrayRef(SourceLanguages)); 1686 W.printFlags("Flags", CompFlags->flags & ~0xff, 1687 makeArrayRef(CompileSym3Flags)); 1688 W.printEnum("Machine", unsigned(CompFlags->Machine), 1689 makeArrayRef(CPUTypeNames)); 1690 std::string FrontendVersion; 1691 { 1692 raw_string_ostream Out(FrontendVersion); 1693 Out << CompFlags->VersionFrontendMajor << '.' 1694 << CompFlags->VersionFrontendMinor << '.' 1695 << CompFlags->VersionFrontendBuild << '.' 1696 << CompFlags->VersionFrontendQFE; 1697 } 1698 std::string BackendVersion; 1699 { 1700 raw_string_ostream Out(BackendVersion); 1701 Out << CompFlags->VersionBackendMajor << '.' 1702 << CompFlags->VersionBackendMinor << '.' 1703 << CompFlags->VersionBackendBuild << '.' 1704 << CompFlags->VersionBackendQFE; 1705 } 1706 W.printString("FrontendVersion", FrontendVersion); 1707 W.printString("BackendVersion", BackendVersion); 1708 StringRef VersionName = SymData.split('\0').first; 1709 W.printString("VersionName", VersionName); 1710 break; 1711 } 1712 1713 case S_FRAMEPROC: { 1714 DictScope S(W, "FrameProc"); 1715 const FrameProcSym *FrameProc; 1716 error(consumeObject(SymData, FrameProc)); 1717 W.printHex("TotalFrameBytes", FrameProc->TotalFrameBytes); 1718 W.printHex("PaddingFrameBytes", FrameProc->PaddingFrameBytes); 1719 W.printHex("OffsetToPadding", FrameProc->OffsetToPadding); 1720 W.printHex("BytesOfCalleeSavedRegisters", FrameProc->BytesOfCalleeSavedRegisters); 1721 W.printHex("OffsetOfExceptionHandler", FrameProc->OffsetOfExceptionHandler); 1722 W.printHex("SectionIdOfExceptionHandler", FrameProc->SectionIdOfExceptionHandler); 1723 W.printFlags("Flags", FrameProc->Flags, makeArrayRef(FrameProcSymFlags)); 1724 break; 1725 } 1726 1727 case S_UDT: 1728 case S_COBOLUDT: { 1729 DictScope S(W, "UDT"); 1730 const UDTSym *UDT; 1731 error(consumeObject(SymData, UDT)); 1732 printTypeIndex("Type", UDT->Type); 1733 StringRef UDTName = SymData.split('\0').first; 1734 W.printString("UDTName", UDTName); 1735 break; 1736 } 1737 1738 case S_BPREL32: { 1739 DictScope S(W, "BPRelativeSym"); 1740 const BPRelativeSym *BPRel; 1741 error(consumeObject(SymData, BPRel)); 1742 W.printNumber("Offset", BPRel->Offset); 1743 printTypeIndex("Type", BPRel->Type); 1744 StringRef VarName = SymData.split('\0').first; 1745 W.printString("VarName", VarName); 1746 break; 1747 } 1748 1749 case S_REGREL32: { 1750 DictScope S(W, "RegRelativeSym"); 1751 const RegRelativeSym *RegRel; 1752 error(consumeObject(SymData, RegRel)); 1753 W.printHex("Offset", RegRel->Offset); 1754 printTypeIndex("Type", RegRel->Type); 1755 W.printHex("Register", RegRel->Register); 1756 StringRef VarName = SymData.split('\0').first; 1757 W.printString("VarName", VarName); 1758 break; 1759 } 1760 1761 case S_BUILDINFO: { 1762 DictScope S(W, "BuildInfo"); 1763 const BuildInfoSym *BuildInfo; 1764 error(consumeObject(SymData, BuildInfo)); 1765 W.printNumber("BuildId", BuildInfo->BuildId); 1766 break; 1767 } 1768 1769 case S_CONSTANT: 1770 case S_MANCONSTANT: { 1771 DictScope S(W, "Constant"); 1772 const ConstantSym *Constant; 1773 error(consumeObject(SymData, Constant)); 1774 printTypeIndex("Type", Constant->Type); 1775 APSInt Value; 1776 error(decodeNumerictLeaf(SymData, Value)); 1777 W.printNumber("Value", Value); 1778 StringRef Name = SymData.split('\0').first; 1779 W.printString("Name", Name); 1780 break; 1781 } 1782 1783 default: { 1784 DictScope S(W, "UnknownSym"); 1785 W.printHex("Kind", unsigned(Kind)); 1786 W.printHex("Size", Rec->RecordLength); 1787 break; 1788 } 1789 } 1790 1791 if (opts::CodeViewSubsectionBytes) 1792 printBinaryBlockWithRelocs("SymData", Section, SectionContents, 1793 OrigSymData); 1794 W.flush(); 1795 } 1796 W.flush(); 1797 } 1798 1799 void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) { 1800 StringRef Data = Subsection; 1801 while (!Data.empty()) { 1802 DictScope S(W, "FileChecksum"); 1803 const FileChecksum *FC; 1804 error(consumeObject(Data, FC)); 1805 if (FC->FileNameOffset >= CVStringTable.size()) 1806 error(object_error::parse_failed); 1807 StringRef Filename = 1808 CVStringTable.drop_front(FC->FileNameOffset).split('\0').first; 1809 W.printHex("Filename", Filename, FC->FileNameOffset); 1810 W.printHex("ChecksumSize", FC->ChecksumSize); 1811 W.printEnum("ChecksumKind", uint8_t(FC->ChecksumKind), 1812 makeArrayRef(FileChecksumKindNames)); 1813 if (FC->ChecksumSize >= Data.size()) 1814 error(object_error::parse_failed); 1815 StringRef ChecksumBytes = Data.substr(0, FC->ChecksumSize); 1816 W.printBinary("ChecksumBytes", ChecksumBytes); 1817 unsigned PaddedSize = alignTo(FC->ChecksumSize + sizeof(FileChecksum), 4) - 1818 sizeof(FileChecksum); 1819 Data = Data.drop_front(PaddedSize); 1820 } 1821 } 1822 1823 void COFFDumper::printCodeViewInlineeLines(StringRef Subsection) { 1824 StringRef Data = Subsection; 1825 uint32_t Signature; 1826 error(consumeUInt32(Data, Signature)); 1827 bool HasExtraFiles = Signature == unsigned(InlineeLinesSignature::ExtraFiles); 1828 1829 while (!Data.empty()) { 1830 const InlineeSourceLine *ISL; 1831 error(consumeObject(Data, ISL)); 1832 DictScope S(W, "InlineeSourceLine"); 1833 printTypeIndex("Inlinee", ISL->Inlinee); 1834 printFileNameForOffset("FileID", ISL->FileID); 1835 W.printNumber("SourceLineNum", ISL->SourceLineNum); 1836 1837 if (HasExtraFiles) { 1838 uint32_t ExtraFileCount; 1839 error(consumeUInt32(Data, ExtraFileCount)); 1840 W.printNumber("ExtraFileCount", ExtraFileCount); 1841 ListScope ExtraFiles(W, "ExtraFiles"); 1842 for (unsigned I = 0; I < ExtraFileCount; ++I) { 1843 uint32_t FileID; 1844 error(consumeUInt32(Data, FileID)); 1845 printFileNameForOffset("FileID", FileID); 1846 } 1847 } 1848 } 1849 } 1850 1851 StringRef getRemainingTypeBytes(const TypeRecordPrefix *Rec, const char *Start) { 1852 ptrdiff_t StartOffset = Start - reinterpret_cast<const char *>(Rec); 1853 size_t RecSize = Rec->Len + 2; 1854 assert(StartOffset >= 0 && "negative start-offset!"); 1855 assert(static_cast<size_t>(StartOffset) <= RecSize && 1856 "Start beyond the end of Rec"); 1857 return StringRef(Start, RecSize - StartOffset); 1858 } 1859 1860 StringRef getRemainingBytesAsString(const TypeRecordPrefix *Rec, const char *Start) { 1861 StringRef Remaining = getRemainingTypeBytes(Rec, Start); 1862 StringRef Leading, Trailing; 1863 std::tie(Leading, Trailing) = Remaining.split('\0'); 1864 return Leading; 1865 } 1866 1867 StringRef COFFDumper::getTypeName(TypeIndex TI) { 1868 if (TI.isNoType()) 1869 return "<no type>"; 1870 1871 if (TI.isSimple()) { 1872 // This is a simple type. 1873 for (const auto &SimpleTypeName : SimpleTypeNames) { 1874 if (SimpleTypeName.Value == TI.getSimpleKind()) { 1875 if (TI.getSimpleMode() == SimpleTypeMode::Direct) 1876 return SimpleTypeName.Name.drop_back(1); 1877 // Otherwise, this is a pointer type. We gloss over the distinction 1878 // between near, far, 64, 32, etc, and just give a pointer type. 1879 return SimpleTypeName.Name; 1880 } 1881 } 1882 return "<unknown simple type>"; 1883 } 1884 1885 // User-defined type. 1886 StringRef UDTName; 1887 unsigned UDTIndex = TI.getIndex() - 0x1000; 1888 if (UDTIndex < CVUDTNames.size()) 1889 return CVUDTNames[UDTIndex]; 1890 1891 return "<unknown UDT>"; 1892 } 1893 1894 void COFFDumper::printTypeIndex(StringRef FieldName, TypeIndex TI) { 1895 StringRef TypeName; 1896 if (!TI.isNoType()) 1897 TypeName = getTypeName(TI); 1898 if (!TypeName.empty()) 1899 W.printHex(FieldName, TypeName, TI.getIndex()); 1900 else 1901 W.printHex(FieldName, TI.getIndex()); 1902 } 1903 1904 void COFFDumper::printLocalVariableAddrRange( 1905 const LocalVariableAddrRange &Range, const coff_section *Sec, 1906 StringRef SectionContents) { 1907 DictScope S(W, "LocalVariableAddrRange"); 1908 printRelocatedField("OffsetStart", Sec, SectionContents, &Range.OffsetStart); 1909 W.printHex("ISectStart", Range.ISectStart); 1910 W.printHex("Range", Range.Range); 1911 } 1912 1913 void COFFDumper::printLocalVariableAddrGap(StringRef &SymData) { 1914 while (!SymData.empty()) { 1915 const LocalVariableAddrGap *Gap; 1916 error(consumeObject(SymData, Gap)); 1917 ListScope S(W, "LocalVariableAddrGap"); 1918 W.printHex("GapStartOffset", Gap->GapStartOffset); 1919 W.printHex("Range", Gap->Range); 1920 } 1921 } 1922 1923 StringRef COFFDumper::getFileNameForFileOffset(uint32_t FileOffset) { 1924 // The file checksum subsection should precede all references to it. 1925 if (!CVFileChecksumTable.data() || !CVStringTable.data()) 1926 error(object_error::parse_failed); 1927 // Check if the file checksum table offset is valid. 1928 if (FileOffset >= CVFileChecksumTable.size()) 1929 error(object_error::parse_failed); 1930 1931 // The string table offset comes first before the file checksum. 1932 StringRef Data = CVFileChecksumTable.drop_front(FileOffset); 1933 uint32_t StringOffset; 1934 error(consumeUInt32(Data, StringOffset)); 1935 1936 // Check if the string table offset is valid. 1937 if (StringOffset >= CVStringTable.size()) 1938 error(object_error::parse_failed); 1939 1940 // Return the null-terminated string. 1941 return CVStringTable.drop_front(StringOffset).split('\0').first; 1942 } 1943 1944 void COFFDumper::printFileNameForOffset(StringRef Label, uint32_t FileOffset) { 1945 W.printHex(Label, getFileNameForFileOffset(FileOffset), FileOffset); 1946 } 1947 1948 static StringRef getLeafTypeName(TypeLeafKind LT) { 1949 switch (LT) { 1950 case LF_STRING_ID: return "StringId"; 1951 case LF_FIELDLIST: return "FieldList"; 1952 case LF_ARGLIST: 1953 case LF_SUBSTR_LIST: return "ArgList"; 1954 case LF_CLASS: 1955 case LF_STRUCTURE: 1956 case LF_INTERFACE: return "ClassType"; 1957 case LF_UNION: return "UnionType"; 1958 case LF_ENUM: return "EnumType"; 1959 case LF_ARRAY: return "ArrayType"; 1960 case LF_VFTABLE: return "VFTableType"; 1961 case LF_MFUNC_ID: return "MemberFuncId"; 1962 case LF_PROCEDURE: return "ProcedureType"; 1963 case LF_MFUNCTION: return "MemberFunctionType"; 1964 case LF_METHODLIST: return "MethodListEntry"; 1965 case LF_FUNC_ID: return "FuncId"; 1966 case LF_TYPESERVER2: return "TypeServer2"; 1967 case LF_POINTER: return "PointerType"; 1968 case LF_MODIFIER: return "TypeModifier"; 1969 case LF_VTSHAPE: return "VTableShape"; 1970 case LF_UDT_SRC_LINE: return "UDTSrcLine"; 1971 case LF_BUILDINFO: return "BuildInfo"; 1972 default: break; 1973 } 1974 return "UnknownLeaf"; 1975 } 1976 1977 void COFFDumper::printCodeViewTypeSection(StringRef SectionName, 1978 const SectionRef &Section) { 1979 ListScope D(W, "CodeViewTypes"); 1980 W.printNumber("Section", SectionName, Obj->getSectionID(Section)); 1981 StringRef Data; 1982 error(Section.getContents(Data)); 1983 W.printBinaryBlock("Data", Data); 1984 1985 unsigned Magic = *reinterpret_cast<const ulittle32_t *>(Data.data()); 1986 W.printHex("Magic", Magic); 1987 1988 Data = Data.drop_front(4); 1989 1990 while (!Data.empty()) { 1991 const TypeRecordPrefix *Rec; 1992 error(consumeObject(Data, Rec)); 1993 auto Leaf = static_cast<TypeLeafKind>(uint16_t(Rec->Leaf)); 1994 1995 // This record is 'Len - 2' bytes, and the next one starts immediately 1996 // afterwards. 1997 StringRef LeafData = Data.substr(0, Rec->Len - 2); 1998 StringRef RemainingData = Data.drop_front(LeafData.size()); 1999 2000 // Find the name of this leaf type. 2001 StringRef LeafName = getLeafTypeName(Leaf); 2002 DictScope S(W, LeafName); 2003 unsigned NextTypeIndex = 0x1000 + CVUDTNames.size(); 2004 W.printEnum("TypeLeafKind", unsigned(Leaf), makeArrayRef(LeafTypeNames)); 2005 W.printHex("TypeIndex", NextTypeIndex); 2006 2007 // Fill this in inside the switch to get something in CVUDTNames. 2008 StringRef Name; 2009 2010 switch (Leaf) { 2011 default: { 2012 W.printHex("Size", Rec->Len); 2013 break; 2014 } 2015 2016 case LF_STRING_ID: { 2017 const StringId *String; 2018 error(consumeObject(LeafData, String)); 2019 W.printHex("Id", String->id.getIndex()); 2020 StringRef StringData = getRemainingBytesAsString(Rec, LeafData.data()); 2021 W.printString("StringData", StringData); 2022 // Put this in CVUDTNames so it gets printed with LF_UDT_SRC_LINE. 2023 Name = StringData; 2024 break; 2025 } 2026 2027 case LF_FIELDLIST: { 2028 W.printHex("Size", Rec->Len); 2029 // FieldList has no fixed prefix that can be described with a struct. All 2030 // the bytes must be interpreted as more records. 2031 printCodeViewFieldList(LeafData); 2032 break; 2033 } 2034 2035 case LF_ARGLIST: 2036 case LF_SUBSTR_LIST: { 2037 const ArgList *Args; 2038 error(consumeObject(LeafData, Args)); 2039 W.printNumber("NumArgs", Args->NumArgs); 2040 ListScope Arguments(W, "Arguments"); 2041 SmallString<256> TypeName("("); 2042 for (uint32_t ArgI = 0; ArgI != Args->NumArgs; ++ArgI) { 2043 const TypeIndex *Type; 2044 error(consumeObject(LeafData, Type)); 2045 printTypeIndex("ArgType", *Type); 2046 StringRef ArgTypeName = getTypeName(*Type); 2047 TypeName.append(ArgTypeName); 2048 if (ArgI + 1 != Args->NumArgs) 2049 TypeName.append(", "); 2050 } 2051 TypeName.push_back(')'); 2052 Name = TypeNames.insert(TypeName).first->getKey(); 2053 break; 2054 } 2055 2056 case LF_CLASS: 2057 case LF_STRUCTURE: 2058 case LF_INTERFACE: { 2059 const ClassType *Class; 2060 error(consumeObject(LeafData, Class)); 2061 W.printNumber("MemberCount", Class->MemberCount); 2062 uint16_t Props = Class->Properties; 2063 W.printFlags("Properties", Props, makeArrayRef(ClassOptionNames)); 2064 printTypeIndex("FieldList", Class->FieldList); 2065 printTypeIndex("DerivedFrom", Class->DerivedFrom); 2066 printTypeIndex("VShape", Class->VShape); 2067 uint64_t SizeOf; 2068 error(decodeUIntLeaf(LeafData, SizeOf)); 2069 W.printNumber("SizeOf", SizeOf); 2070 StringRef LinkageName; 2071 std::tie(Name, LinkageName) = LeafData.split('\0'); 2072 W.printString("Name", Name); 2073 if (Props & uint16_t(ClassOptions::HasUniqueName)) { 2074 LinkageName = getRemainingBytesAsString(Rec, LinkageName.data()); 2075 if (LinkageName.empty()) 2076 return error(object_error::parse_failed); 2077 W.printString("LinkageName", LinkageName); 2078 } 2079 break; 2080 } 2081 2082 case LF_UNION: { 2083 const UnionType *Union; 2084 error(consumeObject(LeafData, Union)); 2085 W.printNumber("MemberCount", Union->MemberCount); 2086 uint16_t Props = Union->Properties; 2087 W.printFlags("Properties", Props, makeArrayRef(ClassOptionNames)); 2088 printTypeIndex("FieldList", Union->FieldList); 2089 uint64_t SizeOf; 2090 error(decodeUIntLeaf(LeafData, SizeOf)); 2091 W.printNumber("SizeOf", SizeOf); 2092 StringRef LinkageName; 2093 std::tie(Name, LinkageName) = LeafData.split('\0'); 2094 W.printString("Name", Name); 2095 if (Props & uint16_t(ClassOptions::HasUniqueName)) { 2096 LinkageName = getRemainingBytesAsString(Rec, LinkageName.data()); 2097 if (LinkageName.empty()) 2098 return error(object_error::parse_failed); 2099 W.printString("LinkageName", LinkageName); 2100 } 2101 break; 2102 } 2103 2104 case LF_ENUM: { 2105 const EnumType *Enum; 2106 error(consumeObject(LeafData, Enum)); 2107 W.printNumber("NumEnumerators", Enum->NumEnumerators); 2108 W.printFlags("Properties", uint16_t(Enum->Properties), 2109 makeArrayRef(ClassOptionNames)); 2110 printTypeIndex("UnderlyingType", Enum->UnderlyingType); 2111 printTypeIndex("FieldListType", Enum->FieldListType); 2112 Name = LeafData.split('\0').first; 2113 W.printString("Name", Name); 2114 break; 2115 } 2116 2117 case LF_ARRAY: { 2118 const ArrayType *AT; 2119 error(consumeObject(LeafData, AT)); 2120 printTypeIndex("ElementType", AT->ElementType); 2121 printTypeIndex("IndexType", AT->IndexType); 2122 uint64_t SizeOf; 2123 error(decodeUIntLeaf(LeafData, SizeOf)); 2124 W.printNumber("SizeOf", SizeOf); 2125 Name = LeafData.split('\0').first; 2126 W.printString("Name", Name); 2127 break; 2128 } 2129 2130 case LF_VFTABLE: { 2131 const VFTableType *VFT; 2132 error(consumeObject(LeafData, VFT)); 2133 printTypeIndex("CompleteClass", VFT->CompleteClass); 2134 printTypeIndex("OverriddenVFTable", VFT->OverriddenVFTable); 2135 W.printHex("VFPtrOffset", VFT->VFPtrOffset); 2136 StringRef NamesData = LeafData.substr(0, VFT->NamesLen); 2137 std::tie(Name, NamesData) = NamesData.split('\0'); 2138 W.printString("VFTableName", Name); 2139 while (!NamesData.empty()) { 2140 StringRef MethodName; 2141 std::tie(MethodName, NamesData) = NamesData.split('\0'); 2142 W.printString("MethodName", MethodName); 2143 } 2144 break; 2145 } 2146 2147 case LF_MFUNC_ID: { 2148 const MemberFuncId *Id; 2149 error(consumeObject(LeafData, Id)); 2150 printTypeIndex("ClassType", Id->ClassType); 2151 printTypeIndex("FunctionType", Id->FunctionType); 2152 Name = LeafData.split('\0').first; 2153 W.printString("Name", Name); 2154 break; 2155 } 2156 2157 case LF_PROCEDURE: { 2158 const ProcedureType *Proc; 2159 error(consumeObject(LeafData, Proc)); 2160 printTypeIndex("ReturnType", Proc->ReturnType); 2161 W.printEnum("CallingConvention", uint8_t(Proc->CallConv), 2162 makeArrayRef(CallingConventions)); 2163 W.printFlags("FunctionOptions", uint8_t(Proc->Options), 2164 makeArrayRef(FunctionOptionEnum)); 2165 W.printNumber("NumParameters", Proc->NumParameters); 2166 printTypeIndex("ArgListType", Proc->ArgListType); 2167 2168 StringRef ReturnTypeName = getTypeName(Proc->ReturnType); 2169 StringRef ArgListTypeName = getTypeName(Proc->ArgListType); 2170 SmallString<256> TypeName(ReturnTypeName); 2171 TypeName.push_back(' '); 2172 TypeName.append(ArgListTypeName); 2173 Name = TypeNames.insert(TypeName).first->getKey(); 2174 break; 2175 } 2176 2177 case LF_MFUNCTION: { 2178 const MemberFunctionType *MemberFunc; 2179 error(consumeObject(LeafData, MemberFunc)); 2180 printTypeIndex("ReturnType", MemberFunc->ReturnType); 2181 printTypeIndex("ClassType", MemberFunc->ClassType); 2182 printTypeIndex("ThisType", MemberFunc->ThisType); 2183 W.printEnum("CallingConvention", uint8_t(MemberFunc->CallConv), 2184 makeArrayRef(CallingConventions)); 2185 W.printFlags("FunctionOptions", uint8_t(MemberFunc->Options), 2186 makeArrayRef(FunctionOptionEnum)); 2187 W.printNumber("NumParameters", MemberFunc->NumParameters); 2188 printTypeIndex("ArgListType", MemberFunc->ArgListType); 2189 W.printNumber("ThisAdjustment", MemberFunc->ThisAdjustment); 2190 2191 StringRef ReturnTypeName = getTypeName(MemberFunc->ReturnType); 2192 StringRef ClassTypeName = getTypeName(MemberFunc->ClassType); 2193 StringRef ArgListTypeName = getTypeName(MemberFunc->ArgListType); 2194 SmallString<256> TypeName(ReturnTypeName); 2195 TypeName.push_back(' '); 2196 TypeName.append(ClassTypeName); 2197 TypeName.append("::"); 2198 TypeName.append(ArgListTypeName); 2199 Name = TypeNames.insert(TypeName).first->getKey(); 2200 break; 2201 } 2202 2203 case LF_METHODLIST: { 2204 while (!LeafData.empty()) { 2205 const MethodListEntry *Method; 2206 error(consumeObject(LeafData, Method)); 2207 ListScope S(W, "Method"); 2208 printMemberAttributes(Method->Attrs); 2209 printTypeIndex("Type", Method->Type); 2210 if (Method->isIntroducedVirtual()) { 2211 const little32_t *VFTOffsetPtr; 2212 error(consumeObject(LeafData, VFTOffsetPtr)); 2213 W.printHex("VFTableOffset", *VFTOffsetPtr); 2214 } 2215 } 2216 break; 2217 } 2218 2219 case LF_FUNC_ID: { 2220 const FuncId *Func; 2221 error(consumeObject(LeafData, Func)); 2222 printTypeIndex("ParentScope", Func->ParentScope); 2223 printTypeIndex("FunctionType", Func->FunctionType); 2224 StringRef Null; 2225 std::tie(Name, Null) = LeafData.split('\0'); 2226 W.printString("Name", Name); 2227 break; 2228 } 2229 2230 case LF_TYPESERVER2: { 2231 const TypeServer2 *TypeServer; 2232 error(consumeObject(LeafData, TypeServer)); 2233 W.printBinary("Signature", StringRef(TypeServer->Signature, 16)); 2234 W.printNumber("Age", TypeServer->Age); 2235 Name = LeafData.split('\0').first; 2236 W.printString("Name", Name); 2237 break; 2238 } 2239 2240 case LF_POINTER: { 2241 const PointerType *Ptr; 2242 error(consumeObject(LeafData, Ptr)); 2243 printTypeIndex("PointeeType", Ptr->PointeeType); 2244 W.printHex("PointerAttributes", Ptr->Attrs); 2245 W.printEnum("PtrType", unsigned(Ptr->getPtrKind()), 2246 makeArrayRef(PtrKindNames)); 2247 W.printEnum("PtrMode", unsigned(Ptr->getPtrMode()), 2248 makeArrayRef(PtrModeNames)); 2249 W.printNumber("IsFlat", Ptr->isFlat()); 2250 W.printNumber("IsConst", Ptr->isConst()); 2251 W.printNumber("IsVolatile", Ptr->isVolatile()); 2252 W.printNumber("IsUnaligned", Ptr->isUnaligned()); 2253 2254 if (Ptr->isPointerToMember()) { 2255 const PointerToMemberTail *PMT; 2256 error(consumeObject(LeafData, PMT)); 2257 printTypeIndex("ClassType", PMT->ClassType); 2258 W.printEnum("Representation", PMT->Representation, 2259 makeArrayRef(PtrMemberRepNames)); 2260 2261 StringRef PointeeName = getTypeName(Ptr->PointeeType); 2262 StringRef ClassName = getTypeName(PMT->ClassType); 2263 SmallString<256> TypeName(PointeeName); 2264 TypeName.push_back(' '); 2265 TypeName.append(ClassName); 2266 TypeName.append("::*"); 2267 Name = TypeNames.insert(TypeName).first->getKey(); 2268 } else { 2269 W.printBinaryBlock("TailData", LeafData); 2270 2271 SmallString<256> TypeName; 2272 if (Ptr->isConst()) 2273 TypeName.append("const "); 2274 if (Ptr->isVolatile()) 2275 TypeName.append("volatile "); 2276 if (Ptr->isUnaligned()) 2277 TypeName.append("__unaligned "); 2278 2279 TypeName.append(getTypeName(Ptr->PointeeType)); 2280 2281 if (Ptr->getPtrMode() == PointerMode::LValueReference) 2282 TypeName.append("&"); 2283 else if (Ptr->getPtrMode() == PointerMode::RValueReference) 2284 TypeName.append("&&"); 2285 else if (Ptr->getPtrMode() == PointerMode::Pointer) 2286 TypeName.append("*"); 2287 2288 Name = TypeNames.insert(TypeName).first->getKey(); 2289 } 2290 break; 2291 } 2292 2293 case LF_MODIFIER: { 2294 const TypeModifier *Mod; 2295 error(consumeObject(LeafData, Mod)); 2296 printTypeIndex("ModifiedType", Mod->ModifiedType); 2297 W.printFlags("Modifiers", Mod->Modifiers, 2298 makeArrayRef(TypeModifierNames)); 2299 2300 StringRef ModifiedName = getTypeName(Mod->ModifiedType); 2301 SmallString<256> TypeName; 2302 if (Mod->Modifiers & uint16_t(ModifierOptions::Const)) 2303 TypeName.append("const "); 2304 if (Mod->Modifiers & uint16_t(ModifierOptions::Volatile)) 2305 TypeName.append("volatile "); 2306 if (Mod->Modifiers & uint16_t(ModifierOptions::Unaligned)) 2307 TypeName.append("__unaligned "); 2308 TypeName.append(ModifiedName); 2309 Name = TypeNames.insert(TypeName).first->getKey(); 2310 break; 2311 } 2312 2313 case LF_VTSHAPE: { 2314 const VTableShape *Shape; 2315 error(consumeObject(LeafData, Shape)); 2316 unsigned VFEntryCount = Shape->VFEntryCount; 2317 W.printNumber("VFEntryCount", VFEntryCount); 2318 // We could print out whether the methods are near or far, but in practice 2319 // today everything is CV_VTS_near32, so it's just noise. 2320 break; 2321 } 2322 2323 case LF_UDT_SRC_LINE: { 2324 const UDTSrcLine *Line; 2325 error(consumeObject(LeafData, Line)); 2326 printTypeIndex("UDT", Line->UDT); 2327 printTypeIndex("SourceFile", Line->SourceFile); 2328 W.printNumber("LineNumber", Line->LineNumber); 2329 break; 2330 } 2331 2332 case LF_BUILDINFO: { 2333 const BuildInfo *Args; 2334 error(consumeObject(LeafData, Args)); 2335 W.printNumber("NumArgs", Args->NumArgs); 2336 2337 ListScope Arguments(W, "Arguments"); 2338 for (uint32_t ArgI = 0; ArgI != Args->NumArgs; ++ArgI) { 2339 const TypeIndex *Type; 2340 error(consumeObject(LeafData, Type)); 2341 printTypeIndex("ArgType", *Type); 2342 } 2343 break; 2344 } 2345 } 2346 2347 if (opts::CodeViewSubsectionBytes) 2348 W.printBinaryBlock("LeafData", LeafData); 2349 2350 CVUDTNames.push_back(Name); 2351 2352 Data = RemainingData; 2353 // FIXME: The stream contains LF_PAD bytes that we need to ignore, but those 2354 // are typically included in LeafData. We may need to call skipPadding() if 2355 // we ever find a record that doesn't count those bytes. 2356 } 2357 } 2358 2359 static StringRef skipPadding(StringRef Data) { 2360 if (Data.empty()) 2361 return Data; 2362 uint8_t Leaf = Data.front(); 2363 if (Leaf < LF_PAD0) 2364 return Data; 2365 // Leaf is greater than 0xf0. We should advance by the number of bytes in the 2366 // low 4 bits. 2367 return Data.drop_front(Leaf & 0x0F); 2368 } 2369 2370 void COFFDumper::printMemberAttributes(MemberAttributes Attrs) { 2371 W.printEnum("AccessSpecifier", uint8_t(Attrs.getAccess()), 2372 makeArrayRef(MemberAccessNames)); 2373 auto MK = Attrs.getMethodKind(); 2374 // Data members will be vanilla. Don't try to print a method kind for them. 2375 if (MK != MethodKind::Vanilla) 2376 W.printEnum("MethodKind", unsigned(MK), makeArrayRef(MemberKindNames)); 2377 if (Attrs.getFlags() != MethodOptions::None) { 2378 W.printFlags("MethodOptions", unsigned(Attrs.getFlags()), 2379 makeArrayRef(MethodOptionNames)); 2380 } 2381 } 2382 2383 void COFFDumper::printCodeViewFieldList(StringRef FieldData) { 2384 while (!FieldData.empty()) { 2385 const ulittle16_t *LeafPtr; 2386 error(consumeObject(FieldData, LeafPtr)); 2387 uint16_t Leaf = *LeafPtr; 2388 switch (Leaf) { 2389 default: 2390 W.printHex("UnknownMember", Leaf); 2391 // We can't advance once we hit an unknown field. The size is not encoded. 2392 return; 2393 2394 case LF_NESTTYPE: { 2395 const NestedType *Nested; 2396 error(consumeObject(FieldData, Nested)); 2397 DictScope S(W, "NestedType"); 2398 printTypeIndex("Type", Nested->Type); 2399 StringRef Name; 2400 std::tie(Name, FieldData) = FieldData.split('\0'); 2401 W.printString("Name", Name); 2402 break; 2403 } 2404 2405 case LF_ONEMETHOD: { 2406 const OneMethod *Method; 2407 error(consumeObject(FieldData, Method)); 2408 DictScope S(W, "OneMethod"); 2409 printMemberAttributes(Method->Attrs); 2410 printTypeIndex("Type", Method->Type); 2411 // If virtual, then read the vftable offset. 2412 if (Method->isIntroducedVirtual()) { 2413 const little32_t *VFTOffsetPtr; 2414 error(consumeObject(FieldData, VFTOffsetPtr)); 2415 W.printHex("VFTableOffset", *VFTOffsetPtr); 2416 } 2417 StringRef Name; 2418 std::tie(Name, FieldData) = FieldData.split('\0'); 2419 W.printString("Name", Name); 2420 break; 2421 } 2422 2423 case LF_METHOD: { 2424 const OverloadedMethod *Method; 2425 error(consumeObject(FieldData, Method)); 2426 DictScope S(W, "OverloadedMethod"); 2427 W.printHex("MethodCount", Method->MethodCount); 2428 W.printHex("MethodListIndex", Method->MethList.getIndex()); 2429 StringRef Name; 2430 std::tie(Name, FieldData) = FieldData.split('\0'); 2431 W.printString("Name", Name); 2432 break; 2433 } 2434 2435 case LF_MEMBER: { 2436 const DataMember *Field; 2437 error(consumeObject(FieldData, Field)); 2438 DictScope S(W, "DataMember"); 2439 printMemberAttributes(Field->Attrs); 2440 printTypeIndex("Type", Field->Type); 2441 uint64_t FieldOffset; 2442 error(decodeUIntLeaf(FieldData, FieldOffset)); 2443 W.printHex("FieldOffset", FieldOffset); 2444 StringRef Name; 2445 std::tie(Name, FieldData) = FieldData.split('\0'); 2446 W.printString("Name", Name); 2447 break; 2448 } 2449 2450 case LF_STMEMBER: { 2451 const StaticDataMember *Field; 2452 error(consumeObject(FieldData, Field)); 2453 DictScope S(W, "StaticDataMember"); 2454 printMemberAttributes(Field->Attrs); 2455 printTypeIndex("Type", Field->Type); 2456 StringRef Name; 2457 std::tie(Name, FieldData) = FieldData.split('\0'); 2458 W.printString("Name", Name); 2459 break; 2460 } 2461 2462 case LF_VFUNCTAB: { 2463 const VirtualFunctionPointer *VFTable; 2464 error(consumeObject(FieldData, VFTable)); 2465 DictScope S(W, "VirtualFunctionPointer"); 2466 printTypeIndex("Type", VFTable->Type); 2467 break; 2468 } 2469 2470 case LF_ENUMERATE: { 2471 const Enumerator *Enum; 2472 error(consumeObject(FieldData, Enum)); 2473 DictScope S(W, "Enumerator"); 2474 printMemberAttributes(Enum->Attrs); 2475 APSInt EnumValue; 2476 error(decodeNumerictLeaf(FieldData, EnumValue)); 2477 W.printNumber("EnumValue", EnumValue); 2478 StringRef Name; 2479 std::tie(Name, FieldData) = FieldData.split('\0'); 2480 W.printString("Name", Name); 2481 break; 2482 } 2483 2484 case LF_BCLASS: 2485 case LF_BINTERFACE: { 2486 const BaseClass *Base; 2487 error(consumeObject(FieldData, Base)); 2488 DictScope S(W, "BaseClass"); 2489 printMemberAttributes(Base->Attrs); 2490 printTypeIndex("BaseType", Base->BaseType); 2491 uint64_t BaseOffset; 2492 error(decodeUIntLeaf(FieldData, BaseOffset)); 2493 W.printHex("BaseOffset", BaseOffset); 2494 break; 2495 } 2496 2497 case LF_VBCLASS: 2498 case LF_IVBCLASS: { 2499 const VirtualBaseClass *Base; 2500 error(consumeObject(FieldData, Base)); 2501 DictScope S(W, "VirtualBaseClass"); 2502 printMemberAttributes(Base->Attrs); 2503 printTypeIndex("BaseType", Base->BaseType); 2504 printTypeIndex("VBPtrType", Base->VBPtrType); 2505 uint64_t VBPtrOffset, VBTableIndex; 2506 error(decodeUIntLeaf(FieldData, VBPtrOffset)); 2507 error(decodeUIntLeaf(FieldData, VBTableIndex)); 2508 W.printHex("VBPtrOffset", VBPtrOffset); 2509 W.printHex("VBTableIndex", VBTableIndex); 2510 break; 2511 } 2512 } 2513 2514 // Handle padding. 2515 FieldData = skipPadding(FieldData); 2516 } 2517 } 2518 2519 void COFFDumper::printSections() { 2520 ListScope SectionsD(W, "Sections"); 2521 int SectionNumber = 0; 2522 for (const SectionRef &Sec : Obj->sections()) { 2523 ++SectionNumber; 2524 const coff_section *Section = Obj->getCOFFSection(Sec); 2525 2526 StringRef Name; 2527 error(Sec.getName(Name)); 2528 2529 DictScope D(W, "Section"); 2530 W.printNumber("Number", SectionNumber); 2531 W.printBinary("Name", Name, Section->Name); 2532 W.printHex ("VirtualSize", Section->VirtualSize); 2533 W.printHex ("VirtualAddress", Section->VirtualAddress); 2534 W.printNumber("RawDataSize", Section->SizeOfRawData); 2535 W.printHex ("PointerToRawData", Section->PointerToRawData); 2536 W.printHex ("PointerToRelocations", Section->PointerToRelocations); 2537 W.printHex ("PointerToLineNumbers", Section->PointerToLinenumbers); 2538 W.printNumber("RelocationCount", Section->NumberOfRelocations); 2539 W.printNumber("LineNumberCount", Section->NumberOfLinenumbers); 2540 W.printFlags ("Characteristics", Section->Characteristics, 2541 makeArrayRef(ImageSectionCharacteristics), 2542 COFF::SectionCharacteristics(0x00F00000)); 2543 2544 if (opts::SectionRelocations) { 2545 ListScope D(W, "Relocations"); 2546 for (const RelocationRef &Reloc : Sec.relocations()) 2547 printRelocation(Sec, Reloc); 2548 } 2549 2550 if (opts::SectionSymbols) { 2551 ListScope D(W, "Symbols"); 2552 for (const SymbolRef &Symbol : Obj->symbols()) { 2553 if (!Sec.containsSymbol(Symbol)) 2554 continue; 2555 2556 printSymbol(Symbol); 2557 } 2558 } 2559 2560 if (opts::SectionData && 2561 !(Section->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA)) { 2562 StringRef Data; 2563 error(Sec.getContents(Data)); 2564 2565 W.printBinaryBlock("SectionData", Data); 2566 } 2567 } 2568 } 2569 2570 void COFFDumper::printRelocations() { 2571 ListScope D(W, "Relocations"); 2572 2573 int SectionNumber = 0; 2574 for (const SectionRef &Section : Obj->sections()) { 2575 ++SectionNumber; 2576 StringRef Name; 2577 error(Section.getName(Name)); 2578 2579 bool PrintedGroup = false; 2580 for (const RelocationRef &Reloc : Section.relocations()) { 2581 if (!PrintedGroup) { 2582 W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n"; 2583 W.indent(); 2584 PrintedGroup = true; 2585 } 2586 2587 printRelocation(Section, Reloc); 2588 } 2589 2590 if (PrintedGroup) { 2591 W.unindent(); 2592 W.startLine() << "}\n"; 2593 } 2594 } 2595 } 2596 2597 void COFFDumper::printRelocation(const SectionRef &Section, 2598 const RelocationRef &Reloc, uint64_t Bias) { 2599 uint64_t Offset = Reloc.getOffset() - Bias; 2600 uint64_t RelocType = Reloc.getType(); 2601 SmallString<32> RelocName; 2602 StringRef SymbolName; 2603 Reloc.getTypeName(RelocName); 2604 symbol_iterator Symbol = Reloc.getSymbol(); 2605 if (Symbol != Obj->symbol_end()) { 2606 ErrorOr<StringRef> SymbolNameOrErr = Symbol->getName(); 2607 error(SymbolNameOrErr.getError()); 2608 SymbolName = *SymbolNameOrErr; 2609 } 2610 2611 if (opts::ExpandRelocs) { 2612 DictScope Group(W, "Relocation"); 2613 W.printHex("Offset", Offset); 2614 W.printNumber("Type", RelocName, RelocType); 2615 W.printString("Symbol", SymbolName.empty() ? "-" : SymbolName); 2616 } else { 2617 raw_ostream& OS = W.startLine(); 2618 OS << W.hex(Offset) 2619 << " " << RelocName 2620 << " " << (SymbolName.empty() ? "-" : SymbolName) 2621 << "\n"; 2622 } 2623 } 2624 2625 void COFFDumper::printSymbols() { 2626 ListScope Group(W, "Symbols"); 2627 2628 for (const SymbolRef &Symbol : Obj->symbols()) 2629 printSymbol(Symbol); 2630 } 2631 2632 void COFFDumper::printDynamicSymbols() { ListScope Group(W, "DynamicSymbols"); } 2633 2634 static ErrorOr<StringRef> 2635 getSectionName(const llvm::object::COFFObjectFile *Obj, int32_t SectionNumber, 2636 const coff_section *Section) { 2637 if (Section) { 2638 StringRef SectionName; 2639 if (std::error_code EC = Obj->getSectionName(Section, SectionName)) 2640 return EC; 2641 return SectionName; 2642 } 2643 if (SectionNumber == llvm::COFF::IMAGE_SYM_DEBUG) 2644 return StringRef("IMAGE_SYM_DEBUG"); 2645 if (SectionNumber == llvm::COFF::IMAGE_SYM_ABSOLUTE) 2646 return StringRef("IMAGE_SYM_ABSOLUTE"); 2647 if (SectionNumber == llvm::COFF::IMAGE_SYM_UNDEFINED) 2648 return StringRef("IMAGE_SYM_UNDEFINED"); 2649 return StringRef(""); 2650 } 2651 2652 void COFFDumper::printSymbol(const SymbolRef &Sym) { 2653 DictScope D(W, "Symbol"); 2654 2655 COFFSymbolRef Symbol = Obj->getCOFFSymbol(Sym); 2656 const coff_section *Section; 2657 if (std::error_code EC = Obj->getSection(Symbol.getSectionNumber(), Section)) { 2658 W.startLine() << "Invalid section number: " << EC.message() << "\n"; 2659 W.flush(); 2660 return; 2661 } 2662 2663 StringRef SymbolName; 2664 if (Obj->getSymbolName(Symbol, SymbolName)) 2665 SymbolName = ""; 2666 2667 StringRef SectionName = ""; 2668 ErrorOr<StringRef> Res = 2669 getSectionName(Obj, Symbol.getSectionNumber(), Section); 2670 if (Res) 2671 SectionName = *Res; 2672 2673 W.printString("Name", SymbolName); 2674 W.printNumber("Value", Symbol.getValue()); 2675 W.printNumber("Section", SectionName, Symbol.getSectionNumber()); 2676 W.printEnum ("BaseType", Symbol.getBaseType(), makeArrayRef(ImageSymType)); 2677 W.printEnum ("ComplexType", Symbol.getComplexType(), 2678 makeArrayRef(ImageSymDType)); 2679 W.printEnum ("StorageClass", Symbol.getStorageClass(), 2680 makeArrayRef(ImageSymClass)); 2681 W.printNumber("AuxSymbolCount", Symbol.getNumberOfAuxSymbols()); 2682 2683 for (uint8_t I = 0; I < Symbol.getNumberOfAuxSymbols(); ++I) { 2684 if (Symbol.isFunctionDefinition()) { 2685 const coff_aux_function_definition *Aux; 2686 error(getSymbolAuxData(Obj, Symbol, I, Aux)); 2687 2688 DictScope AS(W, "AuxFunctionDef"); 2689 W.printNumber("TagIndex", Aux->TagIndex); 2690 W.printNumber("TotalSize", Aux->TotalSize); 2691 W.printHex("PointerToLineNumber", Aux->PointerToLinenumber); 2692 W.printHex("PointerToNextFunction", Aux->PointerToNextFunction); 2693 2694 } else if (Symbol.isAnyUndefined()) { 2695 const coff_aux_weak_external *Aux; 2696 error(getSymbolAuxData(Obj, Symbol, I, Aux)); 2697 2698 ErrorOr<COFFSymbolRef> Linked = Obj->getSymbol(Aux->TagIndex); 2699 StringRef LinkedName; 2700 std::error_code EC = Linked.getError(); 2701 if (EC || (EC = Obj->getSymbolName(*Linked, LinkedName))) { 2702 LinkedName = ""; 2703 error(EC); 2704 } 2705 2706 DictScope AS(W, "AuxWeakExternal"); 2707 W.printNumber("Linked", LinkedName, Aux->TagIndex); 2708 W.printEnum ("Search", Aux->Characteristics, 2709 makeArrayRef(WeakExternalCharacteristics)); 2710 2711 } else if (Symbol.isFileRecord()) { 2712 const char *FileName; 2713 error(getSymbolAuxData(Obj, Symbol, I, FileName)); 2714 2715 DictScope AS(W, "AuxFileRecord"); 2716 2717 StringRef Name(FileName, Symbol.getNumberOfAuxSymbols() * 2718 Obj->getSymbolTableEntrySize()); 2719 W.printString("FileName", Name.rtrim(StringRef("\0", 1))); 2720 break; 2721 } else if (Symbol.isSectionDefinition()) { 2722 const coff_aux_section_definition *Aux; 2723 error(getSymbolAuxData(Obj, Symbol, I, Aux)); 2724 2725 int32_t AuxNumber = Aux->getNumber(Symbol.isBigObj()); 2726 2727 DictScope AS(W, "AuxSectionDef"); 2728 W.printNumber("Length", Aux->Length); 2729 W.printNumber("RelocationCount", Aux->NumberOfRelocations); 2730 W.printNumber("LineNumberCount", Aux->NumberOfLinenumbers); 2731 W.printHex("Checksum", Aux->CheckSum); 2732 W.printNumber("Number", AuxNumber); 2733 W.printEnum("Selection", Aux->Selection, makeArrayRef(ImageCOMDATSelect)); 2734 2735 if (Section && Section->Characteristics & COFF::IMAGE_SCN_LNK_COMDAT 2736 && Aux->Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) { 2737 const coff_section *Assoc; 2738 StringRef AssocName = ""; 2739 std::error_code EC = Obj->getSection(AuxNumber, Assoc); 2740 ErrorOr<StringRef> Res = getSectionName(Obj, AuxNumber, Assoc); 2741 if (Res) 2742 AssocName = *Res; 2743 if (!EC) 2744 EC = Res.getError(); 2745 if (EC) { 2746 AssocName = ""; 2747 error(EC); 2748 } 2749 2750 W.printNumber("AssocSection", AssocName, AuxNumber); 2751 } 2752 } else if (Symbol.isCLRToken()) { 2753 const coff_aux_clr_token *Aux; 2754 error(getSymbolAuxData(Obj, Symbol, I, Aux)); 2755 2756 ErrorOr<COFFSymbolRef> ReferredSym = 2757 Obj->getSymbol(Aux->SymbolTableIndex); 2758 StringRef ReferredName; 2759 std::error_code EC = ReferredSym.getError(); 2760 if (EC || (EC = Obj->getSymbolName(*ReferredSym, ReferredName))) { 2761 ReferredName = ""; 2762 error(EC); 2763 } 2764 2765 DictScope AS(W, "AuxCLRToken"); 2766 W.printNumber("AuxType", Aux->AuxType); 2767 W.printNumber("Reserved", Aux->Reserved); 2768 W.printNumber("SymbolTableIndex", ReferredName, Aux->SymbolTableIndex); 2769 2770 } else { 2771 W.startLine() << "<unhandled auxiliary record>\n"; 2772 } 2773 } 2774 } 2775 2776 void COFFDumper::printUnwindInfo() { 2777 ListScope D(W, "UnwindInformation"); 2778 switch (Obj->getMachine()) { 2779 case COFF::IMAGE_FILE_MACHINE_AMD64: { 2780 Win64EH::Dumper Dumper(W); 2781 Win64EH::Dumper::SymbolResolver 2782 Resolver = [](const object::coff_section *Section, uint64_t Offset, 2783 SymbolRef &Symbol, void *user_data) -> std::error_code { 2784 COFFDumper *Dumper = reinterpret_cast<COFFDumper *>(user_data); 2785 return Dumper->resolveSymbol(Section, Offset, Symbol); 2786 }; 2787 Win64EH::Dumper::Context Ctx(*Obj, Resolver, this); 2788 Dumper.printData(Ctx); 2789 break; 2790 } 2791 case COFF::IMAGE_FILE_MACHINE_ARMNT: { 2792 ARM::WinEH::Decoder Decoder(W); 2793 Decoder.dumpProcedureData(*Obj); 2794 break; 2795 } 2796 default: 2797 W.printEnum("unsupported Image Machine", Obj->getMachine(), 2798 makeArrayRef(ImageFileMachineType)); 2799 break; 2800 } 2801 } 2802 2803 void COFFDumper::printImportedSymbols( 2804 iterator_range<imported_symbol_iterator> Range) { 2805 for (const ImportedSymbolRef &I : Range) { 2806 StringRef Sym; 2807 error(I.getSymbolName(Sym)); 2808 uint16_t Ordinal; 2809 error(I.getOrdinal(Ordinal)); 2810 W.printNumber("Symbol", Sym, Ordinal); 2811 } 2812 } 2813 2814 void COFFDumper::printDelayImportedSymbols( 2815 const DelayImportDirectoryEntryRef &I, 2816 iterator_range<imported_symbol_iterator> Range) { 2817 int Index = 0; 2818 for (const ImportedSymbolRef &S : Range) { 2819 DictScope Import(W, "Import"); 2820 StringRef Sym; 2821 error(S.getSymbolName(Sym)); 2822 uint16_t Ordinal; 2823 error(S.getOrdinal(Ordinal)); 2824 W.printNumber("Symbol", Sym, Ordinal); 2825 uint64_t Addr; 2826 error(I.getImportAddress(Index++, Addr)); 2827 W.printHex("Address", Addr); 2828 } 2829 } 2830 2831 void COFFDumper::printCOFFImports() { 2832 // Regular imports 2833 for (const ImportDirectoryEntryRef &I : Obj->import_directories()) { 2834 DictScope Import(W, "Import"); 2835 StringRef Name; 2836 error(I.getName(Name)); 2837 W.printString("Name", Name); 2838 uint32_t Addr; 2839 error(I.getImportLookupTableRVA(Addr)); 2840 W.printHex("ImportLookupTableRVA", Addr); 2841 error(I.getImportAddressTableRVA(Addr)); 2842 W.printHex("ImportAddressTableRVA", Addr); 2843 printImportedSymbols(I.imported_symbols()); 2844 } 2845 2846 // Delay imports 2847 for (const DelayImportDirectoryEntryRef &I : Obj->delay_import_directories()) { 2848 DictScope Import(W, "DelayImport"); 2849 StringRef Name; 2850 error(I.getName(Name)); 2851 W.printString("Name", Name); 2852 const delay_import_directory_table_entry *Table; 2853 error(I.getDelayImportTable(Table)); 2854 W.printHex("Attributes", Table->Attributes); 2855 W.printHex("ModuleHandle", Table->ModuleHandle); 2856 W.printHex("ImportAddressTable", Table->DelayImportAddressTable); 2857 W.printHex("ImportNameTable", Table->DelayImportNameTable); 2858 W.printHex("BoundDelayImportTable", Table->BoundDelayImportTable); 2859 W.printHex("UnloadDelayImportTable", Table->UnloadDelayImportTable); 2860 printDelayImportedSymbols(I, I.imported_symbols()); 2861 } 2862 } 2863 2864 void COFFDumper::printCOFFExports() { 2865 for (const ExportDirectoryEntryRef &E : Obj->export_directories()) { 2866 DictScope Export(W, "Export"); 2867 2868 StringRef Name; 2869 uint32_t Ordinal, RVA; 2870 2871 error(E.getSymbolName(Name)); 2872 error(E.getOrdinal(Ordinal)); 2873 error(E.getExportRVA(RVA)); 2874 2875 W.printNumber("Ordinal", Ordinal); 2876 W.printString("Name", Name); 2877 W.printHex("RVA", RVA); 2878 } 2879 } 2880 2881 void COFFDumper::printCOFFDirectives() { 2882 for (const SectionRef &Section : Obj->sections()) { 2883 StringRef Contents; 2884 StringRef Name; 2885 2886 error(Section.getName(Name)); 2887 if (Name != ".drectve") 2888 continue; 2889 2890 error(Section.getContents(Contents)); 2891 2892 W.printString("Directive(s)", Contents); 2893 } 2894 } 2895 2896 static StringRef getBaseRelocTypeName(uint8_t Type) { 2897 switch (Type) { 2898 case COFF::IMAGE_REL_BASED_ABSOLUTE: return "ABSOLUTE"; 2899 case COFF::IMAGE_REL_BASED_HIGH: return "HIGH"; 2900 case COFF::IMAGE_REL_BASED_LOW: return "LOW"; 2901 case COFF::IMAGE_REL_BASED_HIGHLOW: return "HIGHLOW"; 2902 case COFF::IMAGE_REL_BASED_HIGHADJ: return "HIGHADJ"; 2903 case COFF::IMAGE_REL_BASED_ARM_MOV32T: return "ARM_MOV32(T)"; 2904 case COFF::IMAGE_REL_BASED_DIR64: return "DIR64"; 2905 default: return "unknown (" + llvm::utostr(Type) + ")"; 2906 } 2907 } 2908 2909 void COFFDumper::printCOFFBaseReloc() { 2910 ListScope D(W, "BaseReloc"); 2911 for (const BaseRelocRef &I : Obj->base_relocs()) { 2912 uint8_t Type; 2913 uint32_t RVA; 2914 error(I.getRVA(RVA)); 2915 error(I.getType(Type)); 2916 DictScope Import(W, "Entry"); 2917 W.printString("Type", getBaseRelocTypeName(Type)); 2918 W.printHex("Address", RVA); 2919 } 2920 } 2921 2922 void COFFDumper::printStackMap() const { 2923 object::SectionRef StackMapSection; 2924 for (auto Sec : Obj->sections()) { 2925 StringRef Name; 2926 Sec.getName(Name); 2927 if (Name == ".llvm_stackmaps") { 2928 StackMapSection = Sec; 2929 break; 2930 } 2931 } 2932 2933 if (StackMapSection == object::SectionRef()) 2934 return; 2935 2936 StringRef StackMapContents; 2937 StackMapSection.getContents(StackMapContents); 2938 ArrayRef<uint8_t> StackMapContentsArray( 2939 reinterpret_cast<const uint8_t*>(StackMapContents.data()), 2940 StackMapContents.size()); 2941 2942 if (Obj->isLittleEndian()) 2943 prettyPrintStackMap( 2944 llvm::outs(), 2945 StackMapV1Parser<support::little>(StackMapContentsArray)); 2946 else 2947 prettyPrintStackMap(llvm::outs(), 2948 StackMapV1Parser<support::big>(StackMapContentsArray)); 2949 } 2950