blob: 437b657591d3660b1f0e7fd8debd0d0561ee1635 [file] [log] [blame]
Eric Christopher9cad53c2013-04-03 18:31:38 +00001//===-- 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"
Rafael Espindolaa6e9c3e2014-06-12 17:38:55 +000016#include "ARMWinEHPrinter.h"
Reid Kleckner72e2ba72016-01-13 19:32:35 +000017#include "CodeView.h"
Eric Christopher9cad53c2013-04-03 18:31:38 +000018#include "Error.h"
Chandler Carruth07baed52014-01-13 08:04:33 +000019#include "ObjDumper.h"
Lang Hames0000afd2015-06-26 23:56:53 +000020#include "StackMapPrinter.h"
Eric Christopher9cad53c2013-04-03 18:31:38 +000021#include "StreamWriter.h"
Saleem Abdulrasoole8839a72014-05-25 20:26:45 +000022#include "Win64EHDumper.h"
Eric Christopher9cad53c2013-04-03 18:31:38 +000023#include "llvm/ADT/DenseMap.h"
24#include "llvm/ADT/SmallString.h"
Colin LeMahieu9fbffee2014-11-19 17:10:39 +000025#include "llvm/ADT/StringExtras.h"
Reid Kleckner72e2ba72016-01-13 19:32:35 +000026#include "llvm/ADT/StringSet.h"
Reid Kleckner6b3faef2016-01-13 23:44:57 +000027#include "llvm/DebugInfo/CodeView/CodeView.h"
Reid Klecknere9ab3492016-01-14 19:20:17 +000028#include "llvm/DebugInfo/CodeView/Line.h"
Reid Kleckner6b3faef2016-01-13 23:44:57 +000029#include "llvm/DebugInfo/CodeView/TypeIndex.h"
30#include "llvm/DebugInfo/CodeView/TypeRecord.h"
31#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
Eric Christopher9cad53c2013-04-03 18:31:38 +000032#include "llvm/Object/COFF.h"
33#include "llvm/Object/ObjectFile.h"
Chandler Carruth07baed52014-01-13 08:04:33 +000034#include "llvm/Support/COFF.h"
Eric Christopher9cad53c2013-04-03 18:31:38 +000035#include "llvm/Support/Casting.h"
36#include "llvm/Support/Compiler.h"
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +000037#include "llvm/Support/DataExtractor.h"
Eric Christopher9cad53c2013-04-03 18:31:38 +000038#include "llvm/Support/Format.h"
39#include "llvm/Support/SourceMgr.h"
40#include "llvm/Support/Win64EH.h"
41#include "llvm/Support/raw_ostream.h"
Eric Christopher9cad53c2013-04-03 18:31:38 +000042#include <algorithm>
43#include <cstring>
Rafael Espindolaa6e9c3e2014-06-12 17:38:55 +000044#include <system_error>
Eric Christopher9cad53c2013-04-03 18:31:38 +000045#include <time.h>
46
47using namespace llvm;
48using namespace llvm::object;
Reid Kleckner72e2ba72016-01-13 19:32:35 +000049using namespace llvm::codeview;
Reid Kleckner6b3faef2016-01-13 23:44:57 +000050using namespace llvm::support;
Eric Christopher9cad53c2013-04-03 18:31:38 +000051using namespace llvm::Win64EH;
52
53namespace {
54
55class COFFDumper : public ObjDumper {
56public:
57 COFFDumper(const llvm::object::COFFObjectFile *Obj, StreamWriter& Writer)
58 : ObjDumper(Writer)
59 , Obj(Obj) {
Eric Christopher9cad53c2013-04-03 18:31:38 +000060 }
61
Craig Topperfd38cbe2014-08-30 16:48:34 +000062 void printFileHeaders() override;
63 void printSections() override;
64 void printRelocations() override;
65 void printSymbols() override;
66 void printDynamicSymbols() override;
67 void printUnwindInfo() override;
Rui Ueyama1e152d52014-10-02 17:02:18 +000068 void printCOFFImports() override;
Saleem Abdulrasoolddd92642015-01-03 21:35:09 +000069 void printCOFFExports() override;
Saleem Abdulrasoolf9578632014-10-07 19:37:52 +000070 void printCOFFDirectives() override;
Rui Ueyama74e85132014-11-19 00:18:07 +000071 void printCOFFBaseReloc() override;
Reid Kleckner83ebad32015-12-16 18:28:12 +000072 void printCodeViewDebugInfo() override;
Lang Hames0000afd2015-06-26 23:56:53 +000073 void printStackMap() const override;
Eric Christopher9cad53c2013-04-03 18:31:38 +000074private:
Alexey Samsonov27dc8392014-03-18 06:53:02 +000075 void printSymbol(const SymbolRef &Sym);
Reid Kleckner1c7a9cd2016-01-14 17:51:57 +000076 void printRelocation(const SectionRef &Section, const RelocationRef &Reloc,
77 uint64_t Bias = 0);
Rui Ueyamaed64342b2013-07-19 23:23:29 +000078 void printDataDirectory(uint32_t Index, const std::string &FieldName);
Eric Christopher9cad53c2013-04-03 18:31:38 +000079
David Majnemer50267222014-11-05 06:24:35 +000080 void printDOSHeader(const dos_header *DH);
Rui Ueyama10ed9dd2014-01-26 04:15:52 +000081 template <class PEHeader> void printPEHeader(const PEHeader *Hdr);
82 void printBaseOfDataField(const pe32_header *Hdr);
83 void printBaseOfDataField(const pe32plus_header *Hdr);
84
Reid Kleckner72e2ba72016-01-13 19:32:35 +000085 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);
Reid Kleckner8e7275c2016-01-15 00:11:21 +000089 StringRef getFileNameForFileOffset(uint32_t FileOffset);
90 void printFileNameForOffset(StringRef Label, uint32_t FileOffset);
Reid Kleckner72e2ba72016-01-13 19:32:35 +000091 void printTypeIndex(StringRef FieldName, TypeIndex TI);
David Majnemerd74490f2016-02-03 22:45:21 +000092 void printLocalVariableAddrRange(const LocalVariableAddrRange &Range,
93 const coff_section *Sec,
94 StringRef SectionContents);
David Majnemerac10cfd2016-02-03 22:36:46 +000095 void printLocalVariableAddrGap(const LocalVariableAddrGap &Gap);
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +000096
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +000097 void printCodeViewSymbolsSubsection(StringRef Subsection,
98 const SectionRef &Section,
Reid Kleckner2893fd12016-01-14 17:51:54 +000099 StringRef SectionContents);
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +0000100
Reid Klecknerc31f5302016-01-15 18:06:25 +0000101 void printCodeViewFileChecksums(StringRef Subsection);
102
Reid Klecknere9ab3492016-01-14 19:20:17 +0000103 void printCodeViewInlineeLines(StringRef Subsection);
104
Reid Kleckner72e2ba72016-01-13 19:32:35 +0000105 void printMemberAttributes(MemberAttributes Attrs);
106
Reid Kleckner2893fd12016-01-14 17:51:54 +0000107 void printRelocatedField(StringRef Label, const coff_section *Sec,
108 StringRef SectionContents, const ulittle32_t *Field,
109 StringRef *RelocSym = nullptr);
110
Reid Kleckner1c7a9cd2016-01-14 17:51:57 +0000111 void printBinaryBlockWithRelocs(StringRef Label, const SectionRef &Sec,
112 StringRef SectionContents, StringRef Block);
113
Reid Kleckner8e7275c2016-01-15 00:11:21 +0000114 /// Given a .debug$S section, find the string table and file checksum table.
115 void initializeFileAndStringTables(StringRef Data);
116
Eric Christopher9cad53c2013-04-03 18:31:38 +0000117 void cacheRelocations();
118
Rafael Espindola4453e42942014-06-13 03:07:50 +0000119 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);
Reid Kleckner2893fd12016-01-14 17:51:54 +0000123 std::error_code resolveSymbolName(const coff_section *Section,
124 StringRef SectionContents,
125 const void *RelocPtr, StringRef &Name);
Rui Ueyama979fb402014-10-09 02:16:38 +0000126 void printImportedSymbols(iterator_range<imported_symbol_iterator> Range);
Rui Ueyamaffa4ceb2014-11-13 03:22:54 +0000127 void printDelayImportedSymbols(
128 const DelayImportDirectoryEntryRef &I,
129 iterator_range<imported_symbol_iterator> Range);
Rui Ueyama15d99352014-10-03 00:41:58 +0000130
Eric Christopher9cad53c2013-04-03 18:31:38 +0000131 typedef DenseMap<const coff_section*, std::vector<RelocationRef> > RelocMapTy;
132
133 const llvm::object::COFFObjectFile *Obj;
Rafael Espindola76d650e2015-07-06 14:26:07 +0000134 bool RelocCached = false;
Eric Christopher9cad53c2013-04-03 18:31:38 +0000135 RelocMapTy RelocMap;
Reid Kleckner8e7275c2016-01-15 00:11:21 +0000136 StringRef CVFileChecksumTable;
Timur Iskhodzhanov11603332014-10-06 16:59:44 +0000137 StringRef CVStringTable;
Reid Kleckner72e2ba72016-01-13 19:32:35 +0000138
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;
Eric Christopher9cad53c2013-04-03 18:31:38 +0000145};
146
147} // namespace
148
149
150namespace llvm {
151
Rafael Espindola4453e42942014-06-13 03:07:50 +0000152std::error_code createCOFFDumper(const object::ObjectFile *Obj,
153 StreamWriter &Writer,
154 std::unique_ptr<ObjDumper> &Result) {
Eric Christopher9cad53c2013-04-03 18:31:38 +0000155 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
Saleem Abdulrasool5dd27f42014-05-25 20:26:37 +0000165// Given a a section and an offset into this section the function returns the
166// symbol used for the relocation at the offset.
Rafael Espindola4453e42942014-06-13 03:07:50 +0000167std::error_code COFFDumper::resolveSymbol(const coff_section *Section,
168 uint64_t Offset, SymbolRef &Sym) {
Rafael Espindola76d650e2015-07-06 14:26:07 +0000169 cacheRelocations();
Saleem Abdulrasool5dd27f42014-05-25 20:26:37 +0000170 const auto &Relocations = RelocMap[Section];
171 for (const auto &Relocation : Relocations) {
Rafael Espindola96d071c2015-06-29 23:29:12 +0000172 uint64_t RelocationOffset = Relocation.getOffset();
Eric Christopher9cad53c2013-04-03 18:31:38 +0000173
Saleem Abdulrasool5dd27f42014-05-25 20:26:37 +0000174 if (RelocationOffset == Offset) {
Saleem Abdulrasool4a6f5832014-05-20 05:18:06 +0000175 Sym = *Relocation.getSymbol();
Eric Christopher9cad53c2013-04-03 18:31:38 +0000176 return readobj_error::success;
177 }
178 }
Eric Christopher9cad53c2013-04-03 18:31:38 +0000179 return readobj_error::unknown_symbol;
180}
181
Saleem Abdulrasool5dd27f42014-05-25 20:26:37 +0000182// 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.
Rafael Espindola4453e42942014-06-13 03:07:50 +0000184std::error_code COFFDumper::resolveSymbolName(const coff_section *Section,
185 uint64_t Offset,
186 StringRef &Name) {
Saleem Abdulrasool5dd27f42014-05-25 20:26:37 +0000187 SymbolRef Symbol;
Rafael Espindola4453e42942014-06-13 03:07:50 +0000188 if (std::error_code EC = resolveSymbol(Section, Offset, Symbol))
Saleem Abdulrasool5dd27f42014-05-25 20:26:37 +0000189 return EC;
Rafael Espindola5d0c2ff2015-07-02 20:55:21 +0000190 ErrorOr<StringRef> NameOrErr = Symbol.getName();
191 if (std::error_code EC = NameOrErr.getError())
Saleem Abdulrasool5dd27f42014-05-25 20:26:37 +0000192 return EC;
Rafael Espindola5d0c2ff2015-07-02 20:55:21 +0000193 Name = *NameOrErr;
Rui Ueyama7d099192015-06-09 15:20:42 +0000194 return std::error_code();
Eric Christopher9cad53c2013-04-03 18:31:38 +0000195}
196
Reid Kleckner2893fd12016-01-14 17:51:54 +0000197// Helper for when you have a pointer to real data and you want to know about
198// relocations against it.
199std::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
211void 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
Reid Kleckner1c7a9cd2016-01-14 17:51:57 +0000223void 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
Eric Christopher9cad53c2013-04-03 18:31:38 +0000246static 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 ),
Saleem Abdulrasool5e1780e2014-03-11 03:08:37 +0000251 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARMNT ),
Eric Christopher9cad53c2013-04-03 18:31:38 +0000252 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
270static 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
Rui Ueyama82ebd8e2013-06-12 19:10:33 +0000288static 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
302static const EnumEntry<COFF::DLLCharacteristics> PEDLLCharacteristics[] = {
Rui Ueyama06dc5e72014-01-27 04:22:24 +0000303 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA ),
Rui Ueyama82ebd8e2013-06-12 19:10:33 +0000304 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 ),
Saleem Abdulrasoold90f86d2014-06-27 03:11:18 +0000310 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_APPCONTAINER ),
Rui Ueyama82ebd8e2013-06-12 19:10:33 +0000311 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_WDM_DRIVER ),
Saleem Abdulrasoold90f86d2014-06-27 03:11:18 +0000312 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_GUARD_CF ),
Rui Ueyama82ebd8e2013-06-12 19:10:33 +0000313 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE),
314};
315
Eric Christopher9cad53c2013-04-03 18:31:38 +0000316static const EnumEntry<COFF::SectionCharacteristics>
317ImageSectionCharacteristics[] = {
David Majnemerd3238882015-07-30 16:47:56 +0000318 LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NOLOAD ),
Eric Christopher9cad53c2013-04-03 18:31:38 +0000319 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
356static 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
375static 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
382static 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
412static 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
422static const EnumEntry<COFF::WeakExternalCharacteristics>
423WeakExternalCharacteristics[] = {
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
Reid Kleckner72e2ba72016-01-13 19:32:35 +0000429static 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
444static 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
464static 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
480static 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
542static 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
553static 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
579static 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
585static 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
599static 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
606static 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
621static 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
628static 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
636static 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.
649static 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
Reid Kleckner6b3faef2016-01-13 23:44:57 +0000690static const EnumEntry<TypeLeafKind> LeafTypeNames[] = {
691#define LEAF_TYPE(name, val) LLVM_READOBJ_ENUM_ENT(TypeLeafKind, name),
692#include "llvm/DebugInfo/CodeView/CVLeafTypes.def"
Reid Kleckner72e2ba72016-01-13 19:32:35 +0000693};
694
695static 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
711static 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
719static 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
737static 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
743static 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
770static 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
Reid Klecknerc31f5302016-01-15 18:06:25 +0000776static 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
Rafael Espindola4453e42942014-06-13 03:07:50 +0000783template <typename T>
784static std::error_code getSymbolAuxData(const COFFObjectFile *Obj,
David Majnemer44f51e52014-09-10 12:51:52 +0000785 COFFSymbolRef Symbol,
786 uint8_t AuxSymbolIdx, const T *&Aux) {
Eric Christopher9cad53c2013-04-03 18:31:38 +0000787 ArrayRef<uint8_t> AuxData = Obj->getSymbolAuxData(Symbol);
David Majnemer44f51e52014-09-10 12:51:52 +0000788 AuxData = AuxData.slice(AuxSymbolIdx * Obj->getSymbolTableEntrySize());
Eric Christopher9cad53c2013-04-03 18:31:38 +0000789 Aux = reinterpret_cast<const T*>(AuxData.data());
790 return readobj_error::success;
791}
792
Eric Christopher9cad53c2013-04-03 18:31:38 +0000793void COFFDumper::cacheRelocations() {
Rafael Espindola76d650e2015-07-06 14:26:07 +0000794 if (RelocCached)
795 return;
796 RelocCached = true;
797
Alexey Samsonov27dc8392014-03-18 06:53:02 +0000798 for (const SectionRef &S : Obj->sections()) {
799 const coff_section *Section = Obj->getCOFFSection(S);
Eric Christopher9cad53c2013-04-03 18:31:38 +0000800
Alexey Samsonov27dc8392014-03-18 06:53:02 +0000801 for (const RelocationRef &Reloc : S.relocations())
Alexey Samsonovaa4d2952014-03-14 14:22:49 +0000802 RelocMap[Section].push_back(Reloc);
Eric Christopher9cad53c2013-04-03 18:31:38 +0000803
804 // Sort relocations by address.
805 std::sort(RelocMap[Section].begin(), RelocMap[Section].end(),
806 relocAddressLess);
807 }
808}
809
Rui Ueyamaed64342b2013-07-19 23:23:29 +0000810void 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
Eric Christopher9cad53c2013-04-03 18:31:38 +0000818void COFFDumper::printFileHeaders() {
David Majnemer44f51e52014-09-10 12:51:52 +0000819 time_t TDS = Obj->getTimeDateStamp();
Eric Christopher9cad53c2013-04-03 18:31:38 +0000820 char FormattedTime[20] = { };
821 strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS));
822
823 {
824 DictScope D(W, "ImageFileHeader");
David Majnemer44f51e52014-09-10 12:51:52 +0000825 W.printEnum ("Machine", Obj->getMachine(),
Eric Christopher9cad53c2013-04-03 18:31:38 +0000826 makeArrayRef(ImageFileMachineType));
David Majnemer44f51e52014-09-10 12:51:52 +0000827 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(),
Eric Christopher9cad53c2013-04-03 18:31:38 +0000833 makeArrayRef(ImageFileCharacteristics));
834 }
Rui Ueyama82ebd8e2013-06-12 19:10:33 +0000835
836 // Print PE header. This header does not exist if this is an object file and
837 // not an executable.
Craig Toppere6cb63e2014-04-25 04:24:47 +0000838 const pe32_header *PEHeader = nullptr;
Rafael Espindolafb3acd62015-07-20 03:23:55 +0000839 error(Obj->getPE32Header(PEHeader));
Rui Ueyama10ed9dd2014-01-26 04:15:52 +0000840 if (PEHeader)
841 printPEHeader<pe32_header>(PEHeader);
Rui Ueyama82ebd8e2013-06-12 19:10:33 +0000842
Craig Toppere6cb63e2014-04-25 04:24:47 +0000843 const pe32plus_header *PEPlusHeader = nullptr;
Rafael Espindolafb3acd62015-07-20 03:23:55 +0000844 error(Obj->getPE32PlusHeader(PEPlusHeader));
Rui Ueyama10ed9dd2014-01-26 04:15:52 +0000845 if (PEPlusHeader)
846 printPEHeader<pe32plus_header>(PEPlusHeader);
David Majnemer50267222014-11-05 06:24:35 +0000847
848 if (const dos_header *DH = Obj->getDOSHeader())
849 printDOSHeader(DH);
850}
851
852void 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);
Rui Ueyama10ed9dd2014-01-26 04:15:52 +0000871}
Rui Ueyamaed64342b2013-07-19 23:23:29 +0000872
Rui Ueyama10ed9dd2014-01-26 04:15:52 +0000873template <class PEHeader>
874void 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));
David Majnemer774aadf2014-11-18 02:45:28 +0000898 W.printFlags ("Characteristics", Hdr->DLLCharacteristics,
Rui Ueyama10ed9dd2014-01-26 04:15:52 +0000899 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);
Rui Ueyamaed64342b2013-07-19 23:23:29 +0000905
Rui Ueyama10ed9dd2014-01-26 04:15:52 +0000906 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]);
Rui Ueyamaed64342b2013-07-19 23:23:29 +0000917 }
Rui Ueyama82ebd8e2013-06-12 19:10:33 +0000918 }
Eric Christopher9cad53c2013-04-03 18:31:38 +0000919}
920
Rui Ueyama10ed9dd2014-01-26 04:15:52 +0000921void COFFDumper::printBaseOfDataField(const pe32_header *Hdr) {
922 W.printHex("BaseOfData", Hdr->BaseOfData);
923}
924
925void COFFDumper::printBaseOfDataField(const pe32plus_header *) {}
926
Reid Kleckner83ebad32015-12-16 18:28:12 +0000927void COFFDumper::printCodeViewDebugInfo() {
Reid Kleckner72e2ba72016-01-13 19:32:35 +0000928 // Print types first to build CVUDTNames, then print symbols.
Reid Kleckner83ebad32015-12-16 18:28:12 +0000929 for (const SectionRef &S : Obj->sections()) {
Reid Kleckner72e2ba72016-01-13 19:32:35 +0000930 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);
Reid Kleckner83ebad32015-12-16 18:28:12 +0000940 }
941}
942
Reid Kleckner72e2ba72016-01-13 19:32:35 +0000943/// 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.
946template <typename T>
947static 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
955static 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
Reid Kleckner8e7275c2016-01-15 00:11:21 +0000963void 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
Reid Kleckner72e2ba72016-01-13 19:32:35 +0000987void COFFDumper::printCodeViewSymbolSection(StringRef SectionName,
988 const SectionRef &Section) {
989 StringRef SectionContents;
990 error(Section.getContents(SectionContents));
991 StringRef Data = SectionContents;
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +0000992
993 SmallVector<StringRef, 10> FunctionNames;
994 StringMap<StringRef> FunctionLineTables;
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +0000995
Zachary Turner99f02152015-02-18 19:32:05 +0000996 ListScope D(W, "CodeViewDebugInfo");
Reid Kleckner72e2ba72016-01-13 19:32:35 +0000997 // Print the section to allow correlation with printSections.
998 W.printNumber("Section", SectionName, Obj->getSectionID(Section));
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +0000999
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001000 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
Reid Kleckner8e7275c2016-01-15 00:11:21 +00001006 initializeFileAndStringTables(Data);
1007
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001008 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;
Rui Ueyamada00f2f2016-01-14 21:06:47 +00001028 NextOffset = alignTo(NextOffset, 4);
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001029 Data = SectionContents.drop_front(NextOffset);
1030
1031 // Optionally print the subsection bytes in case our parsing gets confused
1032 // later.
1033 if (opts::CodeViewSubsectionBytes)
Reid Kleckneraf49ecb2016-01-15 22:09:13 +00001034 printBinaryBlockWithRelocs("SubSectionContents", Section, SectionContents,
1035 Contents);
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001036
1037 switch (ModuleSubstreamKind(SubType)) {
1038 case ModuleSubstreamKind::Symbols:
Reid Kleckner2893fd12016-01-14 17:51:54 +00001039 printCodeViewSymbolsSubsection(Contents, Section, SectionContents);
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001040 break;
Reid Klecknere9ab3492016-01-14 19:20:17 +00001041
1042 case ModuleSubstreamKind::InlineeLines:
1043 printCodeViewInlineeLines(Contents);
1044 break;
1045
Reid Klecknerc31f5302016-01-15 18:06:25 +00001046 case ModuleSubstreamKind::FileChecksums:
1047 printCodeViewFileChecksums(Contents);
1048 break;
1049
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001050 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.
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +00001058 error(object_error::parse_failed);
1059 return;
1060 }
1061
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001062 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;
Zachary Turner99f02152015-02-18 19:32:05 +00001070 }
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +00001071
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001072 FunctionLineTables[LinkageName] = Contents;
1073 FunctionNames.push_back(LinkageName);
1074 break;
1075 }
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001076 case ModuleSubstreamKind::FrameData: {
Reid Kleckneraf49ecb2016-01-15 22:09:13 +00001077 // First four bytes is a relocation against the function.
1078 const uint32_t *CodePtr;
1079 error(consumeObject(Contents, CodePtr));
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001080 StringRef LinkageName;
Reid Kleckneraf49ecb2016-01-15 22:09:13 +00001081 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));
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001101 }
1102 break;
1103 }
1104
1105 // Do nothing for unrecognized subsections.
1106 default:
1107 break;
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +00001108 }
Reid Kleckneraf49ecb2016-01-15 22:09:13 +00001109 W.flush();
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +00001110 }
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");
Reid Kleckner7c0c0c02015-12-15 01:23:55 +00001117 W.printString("LinkageName", Name);
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +00001118
1119 DataExtractor DE(FunctionLineTables[Name], true, 4);
David Majnemer3f49e662015-07-09 00:19:51 +00001120 uint32_t Offset = 6; // Skip relocations.
1121 uint16_t Flags = DE.getU16(&Offset);
1122 W.printHex("Flags", Flags);
Reid Kleckner2214ed82016-01-29 00:49:42 +00001123 bool HasColumnInformation = Flags & codeview::LineFlags::HaveColumns;
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +00001124 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),
David Majnemer04948362016-01-13 01:05:16 +00001131 NumLines = DE.getU32(&Offset),
David Majnemer0373d532015-07-09 18:14:31 +00001132 FullSegmentSize = DE.getU32(&Offset);
1133
David Majnemer04948362016-01-13 01:05:16 +00001134 uint32_t ColumnOffset = Offset + 8 * NumLines;
1135 DataExtractor ColumnDE(DE.getData(), true, 4);
1136
David Majnemer0373d532015-07-09 18:14:31 +00001137 if (FullSegmentSize !=
David Majnemer04948362016-01-13 01:05:16 +00001138 12 + 8 * NumLines + (HasColumnInformation ? 4 * NumLines : 0)) {
David Majnemer0373d532015-07-09 18:14:31 +00001139 error(object_error::parse_failed);
1140 return;
1141 }
Justin Bognera1413db2015-07-09 04:27:36 +00001142
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +00001143 ListScope S(W, "FilenameSegment");
Reid Kleckner8e7275c2016-01-15 00:11:21 +00001144 printFileNameForOffset("Filename", OffsetInIndex);
David Majnemer04948362016-01-13 01:05:16 +00001145 for (unsigned LineIdx = 0;
1146 LineIdx != NumLines && DE.isValidOffset(Offset); ++LineIdx) {
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +00001147 // 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.
David Majnemer04948362016-01-13 01:05:16 +00001149 uint32_t PC = DE.getU32(&Offset), LineData = DE.getU32(&Offset);
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +00001150 if (PC >= FunctionSize) {
1151 error(object_error::parse_failed);
1152 return;
1153 }
1154 char Buffer[32];
1155 format("+0x%X", PC).snprint(Buffer, 32);
David Majnemer04948362016-01-13 01:05:16 +00001156 ListScope PCScope(W, Buffer);
Reid Kleckner2214ed82016-01-29 00:49:42 +00001157 uint32_t LineNumberStart = LineData & codeview::LineInfo::StartLineMask;
David Majnemer04948362016-01-13 01:05:16 +00001158 uint32_t LineNumberEndDelta =
Reid Kleckner2214ed82016-01-29 00:49:42 +00001159 (LineData & codeview::LineInfo::EndLineDeltaMask) >>
1160 codeview::LineInfo::EndLineDeltaShift;
Reid Kleckner828883b2016-01-29 16:39:04 +00001161 bool IsStatement = LineData & codeview::LineInfo::StatementFlag;
David Majnemer04948362016-01-13 01:05:16 +00001162 W.printNumber("LineNumberStart", LineNumberStart);
1163 W.printNumber("LineNumberEndDelta", LineNumberEndDelta);
1164 W.printBoolean("IsStatement", IsStatement);
1165 if (HasColumnInformation &&
1166 ColumnDE.isValidOffsetForDataOfSize(ColumnOffset, 4)) {
1167 uint16_t ColStart = ColumnDE.getU16(&ColumnOffset);
David Majnemer3f49e662015-07-09 00:19:51 +00001168 W.printNumber("ColStart", ColStart);
David Majnemer04948362016-01-13 01:05:16 +00001169 uint16_t ColEnd = ColumnDE.getU16(&ColumnOffset);
David Majnemer3f49e662015-07-09 00:19:51 +00001170 W.printNumber("ColEnd", ColEnd);
1171 }
1172 }
David Majnemer04948362016-01-13 01:05:16 +00001173 // Skip over the column data.
1174 if (HasColumnInformation) {
1175 for (unsigned LineIdx = 0;
1176 LineIdx != NumLines && DE.isValidOffset(Offset); ++LineIdx) {
1177 DE.getU32(&Offset);
1178 }
1179 }
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +00001180 }
1181 }
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001182}
1183
1184static std::error_code decodeNumerictLeaf(StringRef &Data, APSInt &Num) {
1185 // Used to avoid overload ambiguity on APInt construtor.
1186 bool FalseVal = false;
1187 if (Data.size() < 2)
1188 return object_error::parse_failed;
1189 uint16_t Short = *reinterpret_cast<const ulittle16_t *>(Data.data());
1190 Data = Data.drop_front(2);
1191 if (Short < LF_NUMERIC) {
1192 Num = APSInt(APInt(/*numBits=*/16, Short, /*isSigned=*/false),
1193 /*isUnsigned=*/true);
1194 return std::error_code();
1195 }
1196 switch (Short) {
1197 case LF_CHAR:
1198 Num = APSInt(APInt(/*numBits=*/8,
1199 *reinterpret_cast<const int8_t *>(Data.data()),
1200 /*isSigned=*/true),
1201 /*isUnsigned=*/false);
1202 Data = Data.drop_front(1);
1203 return std::error_code();
1204 case LF_SHORT:
1205 Num = APSInt(APInt(/*numBits=*/16,
1206 *reinterpret_cast<const little16_t *>(Data.data()),
1207 /*isSigned=*/true),
1208 /*isUnsigned=*/false);
1209 Data = Data.drop_front(2);
1210 return std::error_code();
1211 case LF_USHORT:
1212 Num = APSInt(APInt(/*numBits=*/16,
1213 *reinterpret_cast<const ulittle16_t *>(Data.data()),
1214 /*isSigned=*/false),
1215 /*isUnsigned=*/true);
1216 Data = Data.drop_front(2);
1217 return std::error_code();
1218 case LF_LONG:
1219 Num = APSInt(APInt(/*numBits=*/32,
1220 *reinterpret_cast<const little32_t *>(Data.data()),
1221 /*isSigned=*/true),
1222 /*isUnsigned=*/false);
1223 Data = Data.drop_front(4);
1224 return std::error_code();
1225 case LF_ULONG:
1226 Num = APSInt(APInt(/*numBits=*/32,
1227 *reinterpret_cast<const ulittle32_t *>(Data.data()),
1228 /*isSigned=*/FalseVal),
1229 /*isUnsigned=*/true);
1230 Data = Data.drop_front(4);
1231 return std::error_code();
1232 case LF_QUADWORD:
1233 Num = APSInt(APInt(/*numBits=*/64,
1234 *reinterpret_cast<const little64_t *>(Data.data()),
1235 /*isSigned=*/true),
1236 /*isUnsigned=*/false);
1237 Data = Data.drop_front(8);
1238 return std::error_code();
1239 case LF_UQUADWORD:
1240 Num = APSInt(APInt(/*numBits=*/64,
1241 *reinterpret_cast<const ulittle64_t *>(Data.data()),
1242 /*isSigned=*/false),
1243 /*isUnsigned=*/true);
1244 Data = Data.drop_front(8);
1245 return std::error_code();
1246 }
1247 return object_error::parse_failed;
1248}
1249
1250/// Decode an unsigned integer numeric leaf value.
1251std::error_code decodeUIntLeaf(StringRef &Data, uint64_t &Num) {
1252 APSInt N;
1253 if (std::error_code err = decodeNumerictLeaf(Data, N))
1254 return err;
1255 if (N.isSigned() || !N.isIntN(64))
1256 return object_error::parse_failed;
1257 Num = N.getLimitedValue();
1258 return std::error_code();
Timur Iskhodzhanov48703be2013-12-19 11:37:14 +00001259}
1260
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +00001261void COFFDumper::printCodeViewSymbolsSubsection(StringRef Subsection,
1262 const SectionRef &Section,
Reid Kleckner2893fd12016-01-14 17:51:54 +00001263 StringRef SectionContents) {
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001264 if (Subsection.size() < sizeof(SymRecord))
1265 return error(object_error::parse_failed);
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +00001266
Reid Kleckner2893fd12016-01-14 17:51:54 +00001267 const coff_section *Sec = Obj->getCOFFSection(Section);
1268
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001269 // This holds the remaining data to parse.
1270 StringRef Data = Subsection;
1271
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +00001272 bool InFunctionScope = false;
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001273 while (!Data.empty()) {
1274 const SymRecord *Rec;
1275 error(consumeObject(Data, Rec));
1276
1277 StringRef SymData = Data.substr(0, Rec->RecordLength - 2);
Reid Kleckner1c7a9cd2016-01-14 17:51:57 +00001278 StringRef OrigSymData = SymData;
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001279
1280 Data = Data.drop_front(Rec->RecordLength - 2);
1281
Reid Kleckner6b3faef2016-01-13 23:44:57 +00001282 SymbolRecordKind Kind = Rec->getKind();
1283 switch (Kind) {
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001284 case S_LPROC32:
1285 case S_GPROC32:
1286 case S_GPROC32_ID:
1287 case S_LPROC32_ID:
1288 case S_LPROC32_DPC:
1289 case S_LPROC32_DPC_ID: {
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +00001290 DictScope S(W, "ProcStart");
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001291 const ProcSym *Proc;
1292 error(consumeObject(SymData, Proc));
1293 if (InFunctionScope)
1294 return error(object_error::parse_failed);
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +00001295 InFunctionScope = true;
1296
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001297 StringRef LinkageName;
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001298 StringRef DisplayName = SymData.split('\0').first;
1299 W.printHex("PtrParent", Proc->PtrParent);
1300 W.printHex("PtrEnd", Proc->PtrEnd);
1301 W.printHex("PtrNext", Proc->PtrNext);
1302 W.printHex("CodeSize", Proc->CodeSize);
1303 W.printHex("DbgStart", Proc->DbgStart);
1304 W.printHex("DbgEnd", Proc->DbgEnd);
1305 printTypeIndex("FunctionType", Proc->FunctionType);
Reid Kleckner2893fd12016-01-14 17:51:54 +00001306 printRelocatedField("CodeOffset", Sec, SectionContents, &Proc->CodeOffset,
1307 &LinkageName);
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001308 W.printHex("Segment", Proc->Segment);
1309 W.printFlags("Flags", Proc->Flags, makeArrayRef(ProcSymFlags));
1310 W.printString("DisplayName", DisplayName);
1311 W.printString("LinkageName", LinkageName);
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +00001312 break;
1313 }
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001314
1315 case S_PROC_ID_END: {
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +00001316 W.startLine() << "ProcEnd\n";
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +00001317 InFunctionScope = false;
1318 break;
1319 }
Zachary Turner99f02152015-02-18 19:32:05 +00001320
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001321 case S_BLOCK32: {
1322 DictScope S(W, "BlockStart");
1323 const BlockSym *Block;
1324 error(consumeObject(SymData, Block));
1325
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001326 StringRef BlockName = SymData.split('\0').first;
Reid Kleckner2893fd12016-01-14 17:51:54 +00001327 StringRef LinkageName;
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001328 W.printHex("PtrParent", Block->PtrParent);
1329 W.printHex("PtrEnd", Block->PtrEnd);
1330 W.printHex("CodeSize", Block->CodeSize);
Reid Kleckner2893fd12016-01-14 17:51:54 +00001331 printRelocatedField("CodeOffset", Sec, SectionContents,
1332 &Block->CodeOffset, &LinkageName);
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001333 W.printHex("Segment", Block->Segment);
1334 W.printString("BlockName", BlockName);
1335 W.printString("LinkageName", LinkageName);
1336 break;
1337 }
1338
1339 case S_END: {
1340 W.startLine() << "BlockEnd\n";
1341 InFunctionScope = false;
1342 break;
1343 }
1344
1345 case S_LABEL32: {
1346 DictScope S(W, "Label");
1347 const LabelSym *Label;
1348 error(consumeObject(SymData, Label));
1349
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001350 StringRef DisplayName = SymData.split('\0').first;
Reid Kleckner2893fd12016-01-14 17:51:54 +00001351 StringRef LinkageName;
1352 printRelocatedField("CodeOffset", Sec, SectionContents,
1353 &Label->CodeOffset, &LinkageName);
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001354 W.printHex("Segment", Label->Segment);
1355 W.printHex("Flags", Label->Flags);
1356 W.printFlags("Flags", Label->Flags, makeArrayRef(ProcSymFlags));
1357 W.printString("DisplayName", DisplayName);
1358 W.printString("LinkageName", LinkageName);
1359 break;
1360 }
1361
1362 case S_INLINESITE: {
1363 DictScope S(W, "InlineSite");
1364 const InlineSiteSym *InlineSite;
1365 error(consumeObject(SymData, InlineSite));
1366 W.printHex("PtrParent", InlineSite->PtrParent);
1367 W.printHex("PtrEnd", InlineSite->PtrEnd);
1368 printTypeIndex("Inlinee", InlineSite->Inlinee);
David Majnemere21e9092016-01-14 06:12:30 +00001369
1370 auto GetCompressedAnnotation = [&]() -> uint32_t {
1371 if (SymData.empty())
1372 return -1;
1373
1374 uint8_t FirstByte = SymData.front();
1375 SymData = SymData.drop_front();
1376
1377 if ((FirstByte & 0x80) == 0x00)
1378 return FirstByte;
1379
1380 if (SymData.empty())
1381 return -1;
1382
1383 uint8_t SecondByte = SymData.front();
1384 SymData = SymData.drop_front();
1385
1386 if ((FirstByte & 0xC0) == 0x80)
1387 return ((FirstByte & 0x3F) << 8) | SecondByte;
1388
1389 if (SymData.empty())
1390 return -1;
1391
1392 uint8_t ThirdByte = SymData.front();
1393 SymData = SymData.drop_front();
1394
1395 if (SymData.empty())
1396 return -1;
1397
1398 uint8_t FourthByte = SymData.front();
1399 SymData = SymData.drop_front();
1400
1401 if ((FirstByte & 0xE0) == 0xC0)
1402 return ((FirstByte & 0x1F) << 24) | (SecondByte << 16) |
1403 (ThirdByte << 8) | FourthByte;
1404
1405 return -1;
1406 };
1407 auto DecodeSignedOperand = [](uint32_t Operand) -> int32_t {
1408 if (Operand & 1)
1409 return -(Operand >> 1);
1410 return Operand >> 1;
1411 };
1412
1413 ListScope BinaryAnnotations(W, "BinaryAnnotations");
1414 while (!SymData.empty()) {
1415 uint32_t OpCode = GetCompressedAnnotation();
1416 switch (OpCode) {
1417 default:
1418 case Invalid:
1419 return error(object_error::parse_failed);
1420 case CodeOffset:
Reid Kleckner43842b52016-01-14 21:50:05 +00001421 W.printHex("CodeOffset", GetCompressedAnnotation());
David Majnemere21e9092016-01-14 06:12:30 +00001422 break;
1423 case ChangeCodeOffsetBase:
1424 W.printNumber("ChangeCodeOffsetBase", GetCompressedAnnotation());
1425 break;
1426 case ChangeCodeOffset:
Reid Kleckner43842b52016-01-14 21:50:05 +00001427 W.printHex("ChangeCodeOffset", GetCompressedAnnotation());
David Majnemere21e9092016-01-14 06:12:30 +00001428 break;
1429 case ChangeCodeLength:
Reid Kleckner1fcd6102016-02-02 17:41:18 +00001430 W.printHex("ChangeCodeLength", GetCompressedAnnotation());
David Majnemere21e9092016-01-14 06:12:30 +00001431 break;
1432 case ChangeFile:
Reid Kleckneraf49ecb2016-01-15 22:09:13 +00001433 printFileNameForOffset("ChangeFile", GetCompressedAnnotation());
David Majnemere21e9092016-01-14 06:12:30 +00001434 break;
1435 case ChangeLineOffset:
1436 W.printNumber("ChangeLineOffset",
1437 DecodeSignedOperand(GetCompressedAnnotation()));
1438 break;
1439 case ChangeLineEndDelta:
1440 W.printNumber("ChangeLineEndDelta", GetCompressedAnnotation());
1441 break;
1442 case ChangeRangeKind:
1443 W.printNumber("ChangeRangeKind", GetCompressedAnnotation());
1444 break;
1445 case ChangeColumnStart:
1446 W.printNumber("ChangeColumnStart", GetCompressedAnnotation());
1447 break;
1448 case ChangeColumnEndDelta:
1449 W.printNumber("ChangeColumnEndDelta",
1450 DecodeSignedOperand(GetCompressedAnnotation()));
1451 break;
1452 case ChangeCodeOffsetAndLineOffset: {
1453 uint32_t Annotation = GetCompressedAnnotation();
Reid Kleckner8e7275c2016-01-15 00:11:21 +00001454 int32_t LineOffset = DecodeSignedOperand(Annotation >> 4);
Reid Kleckner43842b52016-01-14 21:50:05 +00001455 uint32_t CodeOffset = Annotation & 0xf;
Reid Kleckner400f3932016-01-20 23:21:14 +00001456 W.startLine() << "ChangeCodeOffsetAndLineOffset: {CodeOffset: "
1457 << W.hex(CodeOffset) << ", LineOffset: " << LineOffset
Reid Kleckner43842b52016-01-14 21:50:05 +00001458 << "}\n";
David Majnemere21e9092016-01-14 06:12:30 +00001459 break;
1460 }
1461 case ChangeCodeLengthAndCodeOffset: {
Reid Kleckner43842b52016-01-14 21:50:05 +00001462 uint32_t Length = GetCompressedAnnotation();
1463 uint32_t CodeOffset = GetCompressedAnnotation();
Reid Kleckner400f3932016-01-20 23:21:14 +00001464 W.startLine() << "ChangeCodeLengthAndCodeOffset: {CodeOffset: "
1465 << W.hex(CodeOffset) << ", Length: " << W.hex(Length)
1466 << "}\n";
David Majnemere21e9092016-01-14 06:12:30 +00001467 break;
1468 }
1469 case ChangeColumnEnd:
1470 W.printNumber("ChangeColumnEnd", GetCompressedAnnotation());
1471 break;
1472 }
1473 }
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001474 break;
1475 }
1476
1477 case S_INLINESITE_END: {
1478 DictScope S(W, "InlineSiteEnd");
1479 break;
1480 }
1481
Reid Kleckner43842b52016-01-14 21:50:05 +00001482 case S_CALLERS:
1483 case S_CALLEES: {
1484 ListScope S(W, Kind == S_CALLEES ? "Callees" : "Callers");
1485 uint32_t Count;
1486 error(consumeUInt32(SymData, Count));
1487 for (uint32_t I = 0; I < Count; ++I) {
1488 const TypeIndex *FuncID;
1489 error(consumeObject(SymData, FuncID));
1490 printTypeIndex("FuncID", *FuncID);
1491 }
1492 break;
1493 }
1494
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001495 case S_LOCAL: {
1496 DictScope S(W, "Local");
1497 const LocalSym *Local;
1498 error(consumeObject(SymData, Local));
1499 printTypeIndex("Type", Local->Type);
1500 W.printFlags("Flags", uint16_t(Local->Flags), makeArrayRef(LocalFlags));
1501 StringRef VarName = SymData.split('\0').first;
1502 W.printString("VarName", VarName);
1503 break;
1504 }
1505
David Majnemerac10cfd2016-02-03 22:36:46 +00001506 case S_DEFRANGE_REGISTER: {
1507 DictScope S(W, "DefRangeRegister");
1508 const DefRangeRegisterSym *DefRangeRegister;
1509 error(consumeObject(SymData, DefRangeRegister));
1510 W.printNumber("Register", DefRangeRegister->Register);
1511 W.printNumber("MayHaveNoName", DefRangeRegister->MayHaveNoName);
David Majnemerd74490f2016-02-03 22:45:21 +00001512 printLocalVariableAddrRange(DefRangeRegister->Range, Sec,
1513 SectionContents);
David Majnemerac10cfd2016-02-03 22:36:46 +00001514 while (!SymData.empty()) {
1515 const LocalVariableAddrGap *Gap;
1516 error(consumeObject(SymData, Gap));
1517 printLocalVariableAddrGap(*Gap);
1518 }
1519 break;
1520 }
1521 case S_DEFRANGE_SUBFIELD_REGISTER: {
1522 DictScope S(W, "DefRangeSubfieldRegister");
1523 const DefRangeSubfieldRegisterSym *DefRangeSubfieldRegisterSym;
1524 error(consumeObject(SymData, DefRangeSubfieldRegisterSym));
1525 W.printNumber("Register", DefRangeSubfieldRegisterSym->Register);
1526 W.printNumber("MayHaveNoName",
1527 DefRangeSubfieldRegisterSym->MayHaveNoName);
1528 W.printNumber("OffsetInParent",
1529 DefRangeSubfieldRegisterSym->OffsetInParent);
David Majnemerd74490f2016-02-03 22:45:21 +00001530 printLocalVariableAddrRange(DefRangeSubfieldRegisterSym->Range, Sec,
1531 SectionContents);
David Majnemerac10cfd2016-02-03 22:36:46 +00001532 while (!SymData.empty()) {
1533 const LocalVariableAddrGap *Gap;
1534 error(consumeObject(SymData, Gap));
1535 printLocalVariableAddrGap(*Gap);
1536 }
1537 break;
1538 }
1539 case S_DEFRANGE_FRAMEPOINTER_REL: {
1540 DictScope S(W, "DefRangeFramePointerRel");
1541 const DefRangeFramePointerRelSym *DefRangeFramePointerRel;
1542 error(consumeObject(SymData, DefRangeFramePointerRel));
1543 W.printNumber("Offset", DefRangeFramePointerRel->Offset);
David Majnemerd74490f2016-02-03 22:45:21 +00001544 printLocalVariableAddrRange(DefRangeFramePointerRel->Range, Sec,
1545 SectionContents);
David Majnemerac10cfd2016-02-03 22:36:46 +00001546 while (!SymData.empty()) {
1547 const LocalVariableAddrGap *Gap;
1548 error(consumeObject(SymData, Gap));
1549 printLocalVariableAddrGap(*Gap);
1550 }
1551 break;
1552 }
1553 case S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE: {
1554 DictScope S(W, "DefRangeFramePointerRelFullScope");
1555 const DefRangeFramePointerRelFullScopeSym
1556 *DefRangeFramePointerRelFullScope;
1557 error(consumeObject(SymData, DefRangeFramePointerRelFullScope));
1558 W.printNumber("Offset", DefRangeFramePointerRelFullScope->Offset);
1559 break;
1560 }
1561 case S_DEFRANGE_REGISTER_REL: {
1562 DictScope S(W, "DefRangeRegisterRel");
1563 const DefRangeRegisterRelSym *DefRangeRegisterRel;
1564 error(consumeObject(SymData, DefRangeRegisterRel));
1565 W.printNumber("BaseRegister", DefRangeRegisterRel->BaseRegister);
1566 W.printBoolean("HasSpilledUDTMember",
1567 DefRangeRegisterRel->hasSpilledUDTMember());
1568 W.printNumber("OffsetInParent", DefRangeRegisterRel->offsetInParent());
David Majnemerd74490f2016-02-03 22:45:21 +00001569 printLocalVariableAddrRange(DefRangeRegisterRel->Range, Sec,
1570 SectionContents);
David Majnemerac10cfd2016-02-03 22:36:46 +00001571 while (!SymData.empty()) {
1572 const LocalVariableAddrGap *Gap;
1573 error(consumeObject(SymData, Gap));
1574 printLocalVariableAddrGap(*Gap);
1575 }
1576 break;
1577 }
1578
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001579 case S_CALLSITEINFO: {
1580 DictScope S(W, "CallSiteInfo");
1581 const CallSiteInfoSym *CallSiteInfo;
1582 error(consumeObject(SymData, CallSiteInfo));
1583
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001584 StringRef LinkageName;
Reid Kleckner2893fd12016-01-14 17:51:54 +00001585 printRelocatedField("CodeOffset", Sec, SectionContents,
1586 &CallSiteInfo->CodeOffset, &LinkageName);
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001587 W.printHex("Segment", CallSiteInfo->Segment);
1588 W.printHex("Reserved", CallSiteInfo->Reserved);
1589 printTypeIndex("Type", CallSiteInfo->Type);
1590 W.printString("LinkageName", LinkageName);
1591 break;
1592 }
1593
1594 case S_HEAPALLOCSITE: {
1595 DictScope S(W, "HeapAllocationSite");
1596 const HeapAllocationSiteSym *HeapAllocationSite;
1597 error(consumeObject(SymData, HeapAllocationSite));
1598
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001599 StringRef LinkageName;
Reid Kleckner2893fd12016-01-14 17:51:54 +00001600 printRelocatedField("CodeOffset", Sec, SectionContents,
1601 &HeapAllocationSite->CodeOffset, &LinkageName);
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001602 W.printHex("Segment", HeapAllocationSite->Segment);
1603 W.printHex("CallInstructionSize",
1604 HeapAllocationSite->CallInstructionSize);
1605 printTypeIndex("Type", HeapAllocationSite->Type);
1606 W.printString("LinkageName", LinkageName);
1607 break;
1608 }
1609
1610 case S_FRAMECOOKIE: {
1611 DictScope S(W, "FrameCookie");
1612 const FrameCookieSym *FrameCookie;
1613 error(consumeObject(SymData, FrameCookie));
Reid Kleckner2893fd12016-01-14 17:51:54 +00001614
1615 StringRef LinkageName;
1616 printRelocatedField("CodeOffset", Sec, SectionContents,
1617 &FrameCookie->CodeOffset, &LinkageName);
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001618 W.printHex("Register", FrameCookie->Register);
1619 W.printEnum("CookieKind", uint16_t(FrameCookie->CookieKind),
1620 makeArrayRef(FrameCookieKinds));
1621 break;
1622 }
1623
1624 case S_LDATA32:
1625 case S_GDATA32:
1626 case S_LMANDATA:
1627 case S_GMANDATA: {
1628 DictScope S(W, "DataSym");
1629 const DataSym *Data;
1630 error(consumeObject(SymData, Data));
1631
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001632 StringRef DisplayName = SymData.split('\0').first;
Reid Kleckner2893fd12016-01-14 17:51:54 +00001633 StringRef LinkageName;
1634 printRelocatedField("DataOffset", Sec, SectionContents, &Data->DataOffset,
1635 &LinkageName);
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001636 printTypeIndex("Type", Data->Type);
1637 W.printString("DisplayName", DisplayName);
1638 W.printString("LinkageName", LinkageName);
1639 break;
1640 }
Reid Kleckner2893fd12016-01-14 17:51:54 +00001641
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001642 case S_LTHREAD32:
1643 case S_GTHREAD32: {
1644 DictScope S(W, "ThreadLocalDataSym");
Reid Kleckner2893fd12016-01-14 17:51:54 +00001645 const ThreadLocalDataSym *Data;
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001646 error(consumeObject(SymData, Data));
1647
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001648 StringRef DisplayName = SymData.split('\0').first;
Reid Kleckner2893fd12016-01-14 17:51:54 +00001649 StringRef LinkageName;
1650 printRelocatedField("DataOffset", Sec, SectionContents, &Data->DataOffset,
1651 &LinkageName);
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001652 printTypeIndex("Type", Data->Type);
1653 W.printString("DisplayName", DisplayName);
1654 W.printString("LinkageName", LinkageName);
1655 break;
1656 }
1657
1658 case S_OBJNAME: {
1659 DictScope S(W, "ObjectName");
1660 const ObjNameSym *ObjName;
1661 error(consumeObject(SymData, ObjName));
1662 W.printHex("Signature", ObjName->Signature);
1663 StringRef ObjectName = SymData.split('\0').first;
1664 W.printString("ObjectName", ObjectName);
1665 break;
1666 }
1667
1668 case S_COMPILE3: {
1669 DictScope S(W, "CompilerFlags");
1670 const CompileSym3 *CompFlags;
1671 error(consumeObject(SymData, CompFlags));
1672 W.printEnum("Language", CompFlags->getLanguage(),
1673 makeArrayRef(SourceLanguages));
1674 W.printFlags("Flags", CompFlags->flags & ~0xff,
1675 makeArrayRef(CompileSym3Flags));
1676 W.printEnum("Machine", unsigned(CompFlags->Machine),
1677 makeArrayRef(CPUTypeNames));
1678 std::string FrontendVersion;
1679 {
1680 raw_string_ostream Out(FrontendVersion);
1681 Out << CompFlags->VersionFrontendMajor << '.'
1682 << CompFlags->VersionFrontendMinor << '.'
1683 << CompFlags->VersionFrontendBuild << '.'
1684 << CompFlags->VersionFrontendQFE;
Zachary Turner99f02152015-02-18 19:32:05 +00001685 }
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001686 std::string BackendVersion;
1687 {
1688 raw_string_ostream Out(BackendVersion);
1689 Out << CompFlags->VersionBackendMajor << '.'
1690 << CompFlags->VersionBackendMinor << '.'
1691 << CompFlags->VersionBackendBuild << '.'
1692 << CompFlags->VersionBackendQFE;
1693 }
1694 W.printString("FrontendVersion", FrontendVersion);
1695 W.printString("BackendVersion", BackendVersion);
1696 StringRef VersionName = SymData.split('\0').first;
1697 W.printString("VersionName", VersionName);
1698 break;
1699 }
Zachary Turner99f02152015-02-18 19:32:05 +00001700
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001701 case S_FRAMEPROC: {
1702 DictScope S(W, "FrameProc");
1703 const FrameProcSym *FrameProc;
1704 error(consumeObject(SymData, FrameProc));
1705 W.printHex("TotalFrameBytes", FrameProc->TotalFrameBytes);
1706 W.printHex("PaddingFrameBytes", FrameProc->PaddingFrameBytes);
1707 W.printHex("OffsetToPadding", FrameProc->OffsetToPadding);
1708 W.printHex("BytesOfCalleeSavedRegisters", FrameProc->BytesOfCalleeSavedRegisters);
1709 W.printHex("OffsetOfExceptionHandler", FrameProc->OffsetOfExceptionHandler);
1710 W.printHex("SectionIdOfExceptionHandler", FrameProc->SectionIdOfExceptionHandler);
1711 W.printFlags("Flags", FrameProc->Flags, makeArrayRef(FrameProcSymFlags));
1712 break;
1713 }
1714
1715 case S_UDT:
1716 case S_COBOLUDT: {
1717 DictScope S(W, "UDT");
1718 const UDTSym *UDT;
1719 error(consumeObject(SymData, UDT));
1720 printTypeIndex("Type", UDT->Type);
1721 StringRef UDTName = SymData.split('\0').first;
1722 W.printString("UDTName", UDTName);
1723 break;
1724 }
1725
1726 case S_BPREL32: {
1727 DictScope S(W, "BPRelativeSym");
1728 const BPRelativeSym *BPRel;
1729 error(consumeObject(SymData, BPRel));
David Majnemerac10cfd2016-02-03 22:36:46 +00001730 W.printNumber("Offset", BPRel->Offset);
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001731 printTypeIndex("Type", BPRel->Type);
1732 StringRef VarName = SymData.split('\0').first;
1733 W.printString("VarName", VarName);
1734 break;
1735 }
1736
1737 case S_REGREL32: {
1738 DictScope S(W, "RegRelativeSym");
1739 const RegRelativeSym *RegRel;
1740 error(consumeObject(SymData, RegRel));
1741 W.printHex("Offset", RegRel->Offset);
1742 printTypeIndex("Type", RegRel->Type);
1743 W.printHex("Register", RegRel->Register);
1744 StringRef VarName = SymData.split('\0').first;
1745 W.printString("VarName", VarName);
1746 break;
1747 }
1748
1749 case S_BUILDINFO: {
1750 DictScope S(W, "BuildInfo");
1751 const BuildInfoSym *BuildInfo;
1752 error(consumeObject(SymData, BuildInfo));
1753 W.printNumber("BuildId", BuildInfo->BuildId);
1754 break;
1755 }
1756
1757 case S_CONSTANT:
1758 case S_MANCONSTANT: {
1759 DictScope S(W, "Constant");
1760 const ConstantSym *Constant;
1761 error(consumeObject(SymData, Constant));
1762 printTypeIndex("Type", Constant->Type);
1763 APSInt Value;
1764 error(decodeNumerictLeaf(SymData, Value));
1765 W.printNumber("Value", Value);
1766 StringRef Name = SymData.split('\0').first;
1767 W.printString("Name", Name);
1768 break;
1769 }
1770
1771 default: {
1772 DictScope S(W, "UnknownSym");
Reid Kleckner6b3faef2016-01-13 23:44:57 +00001773 W.printHex("Kind", unsigned(Kind));
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001774 W.printHex("Size", Rec->RecordLength);
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +00001775 break;
1776 }
Zachary Turner99f02152015-02-18 19:32:05 +00001777 }
Reid Kleckner1c7a9cd2016-01-14 17:51:57 +00001778
1779 if (opts::CodeViewSubsectionBytes)
1780 printBinaryBlockWithRelocs("SymData", Section, SectionContents,
1781 OrigSymData);
Reid Kleckneraf49ecb2016-01-15 22:09:13 +00001782 W.flush();
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +00001783 }
Reid Kleckneraf49ecb2016-01-15 22:09:13 +00001784 W.flush();
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001785}
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +00001786
Reid Klecknerc31f5302016-01-15 18:06:25 +00001787void COFFDumper::printCodeViewFileChecksums(StringRef Subsection) {
1788 StringRef Data = Subsection;
1789 while (!Data.empty()) {
1790 DictScope S(W, "FileChecksum");
1791 const FileChecksum *FC;
1792 error(consumeObject(Data, FC));
1793 if (FC->FileNameOffset >= CVStringTable.size())
1794 error(object_error::parse_failed);
1795 StringRef Filename =
1796 CVStringTable.drop_front(FC->FileNameOffset).split('\0').first;
1797 W.printHex("Filename", Filename, FC->FileNameOffset);
1798 W.printHex("ChecksumSize", FC->ChecksumSize);
1799 W.printEnum("ChecksumKind", uint8_t(FC->ChecksumKind),
1800 makeArrayRef(FileChecksumKindNames));
1801 if (FC->ChecksumSize >= Data.size())
1802 error(object_error::parse_failed);
1803 StringRef ChecksumBytes = Data.substr(0, FC->ChecksumSize);
1804 W.printBinary("ChecksumBytes", ChecksumBytes);
Rafael Espindolaa79078c2016-01-18 20:55:24 +00001805 unsigned PaddedSize = alignTo(FC->ChecksumSize + sizeof(FileChecksum), 4) -
1806 sizeof(FileChecksum);
Reid Klecknerc31f5302016-01-15 18:06:25 +00001807 Data = Data.drop_front(PaddedSize);
1808 }
1809}
1810
Reid Klecknere9ab3492016-01-14 19:20:17 +00001811void COFFDumper::printCodeViewInlineeLines(StringRef Subsection) {
1812 StringRef Data = Subsection;
1813 uint32_t Signature;
1814 error(consumeUInt32(Data, Signature));
1815 bool HasExtraFiles = Signature == unsigned(InlineeLinesSignature::ExtraFiles);
1816
1817 while (!Data.empty()) {
1818 const InlineeSourceLine *ISL;
1819 error(consumeObject(Data, ISL));
1820 DictScope S(W, "InlineeSourceLine");
1821 printTypeIndex("Inlinee", ISL->Inlinee);
Reid Kleckner8e7275c2016-01-15 00:11:21 +00001822 printFileNameForOffset("FileID", ISL->FileID);
Reid Klecknere9ab3492016-01-14 19:20:17 +00001823 W.printNumber("SourceLineNum", ISL->SourceLineNum);
1824
1825 if (HasExtraFiles) {
1826 uint32_t ExtraFileCount;
1827 error(consumeUInt32(Data, ExtraFileCount));
1828 W.printNumber("ExtraFileCount", ExtraFileCount);
1829 ListScope ExtraFiles(W, "ExtraFiles");
1830 for (unsigned I = 0; I < ExtraFileCount; ++I) {
1831 uint32_t FileID;
1832 error(consumeUInt32(Data, FileID));
Reid Kleckner8e7275c2016-01-15 00:11:21 +00001833 printFileNameForOffset("FileID", FileID);
Reid Klecknere9ab3492016-01-14 19:20:17 +00001834 }
1835 }
1836 }
1837}
1838
Reid Kleckner6b3faef2016-01-13 23:44:57 +00001839StringRef getRemainingTypeBytes(const TypeRecordPrefix *Rec, const char *Start) {
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001840 ptrdiff_t StartOffset = Start - reinterpret_cast<const char *>(Rec);
1841 size_t RecSize = Rec->Len + 2;
1842 assert(StartOffset >= 0 && "negative start-offset!");
1843 assert(static_cast<size_t>(StartOffset) <= RecSize &&
1844 "Start beyond the end of Rec");
1845 return StringRef(Start, RecSize - StartOffset);
1846}
1847
Reid Kleckner6b3faef2016-01-13 23:44:57 +00001848StringRef getRemainingBytesAsString(const TypeRecordPrefix *Rec, const char *Start) {
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001849 StringRef Remaining = getRemainingTypeBytes(Rec, Start);
1850 StringRef Leading, Trailing;
1851 std::tie(Leading, Trailing) = Remaining.split('\0');
1852 return Leading;
1853}
1854
1855StringRef COFFDumper::getTypeName(TypeIndex TI) {
1856 if (TI.isNoType())
1857 return "<no type>";
1858
1859 if (TI.isSimple()) {
1860 // This is a simple type.
1861 for (const auto &SimpleTypeName : SimpleTypeNames) {
1862 if (SimpleTypeName.Value == TI.getSimpleKind()) {
1863 if (TI.getSimpleMode() == SimpleTypeMode::Direct)
1864 return SimpleTypeName.Name.drop_back(1);
1865 // Otherwise, this is a pointer type. We gloss over the distinction
1866 // between near, far, 64, 32, etc, and just give a pointer type.
1867 return SimpleTypeName.Name;
1868 }
1869 }
1870 return "<unknown simple type>";
1871 }
1872
1873 // User-defined type.
1874 StringRef UDTName;
1875 unsigned UDTIndex = TI.getIndex() - 0x1000;
1876 if (UDTIndex < CVUDTNames.size())
1877 return CVUDTNames[UDTIndex];
1878
1879 return "<unknown UDT>";
1880}
1881
1882void COFFDumper::printTypeIndex(StringRef FieldName, TypeIndex TI) {
1883 StringRef TypeName;
1884 if (!TI.isNoType())
1885 TypeName = getTypeName(TI);
1886 if (!TypeName.empty())
1887 W.printHex(FieldName, TypeName, TI.getIndex());
1888 else
1889 W.printHex(FieldName, TI.getIndex());
1890}
1891
David Majnemerac10cfd2016-02-03 22:36:46 +00001892void COFFDumper::printLocalVariableAddrRange(
David Majnemerd74490f2016-02-03 22:45:21 +00001893 const LocalVariableAddrRange &Range, const coff_section *Sec,
1894 StringRef SectionContents) {
1895 printRelocatedField("OffsetStart", Sec, SectionContents, &Range.OffsetStart);
1896 W.printHex("ISectStart", Range.ISectStart);
David Majnemerac10cfd2016-02-03 22:36:46 +00001897 W.printNumber("Range", Range.Range);
1898}
1899
1900void COFFDumper::printLocalVariableAddrGap(const LocalVariableAddrGap &Gap) {
1901 W.printNumber("GapStartOffset", Gap.GapStartOffset);
1902 W.printNumber("Range", Gap.Range);
1903}
1904
Reid Kleckner8e7275c2016-01-15 00:11:21 +00001905StringRef COFFDumper::getFileNameForFileOffset(uint32_t FileOffset) {
1906 // The file checksum subsection should precede all references to it.
1907 if (!CVFileChecksumTable.data() || !CVStringTable.data())
1908 error(object_error::parse_failed);
1909 // Check if the file checksum table offset is valid.
1910 if (FileOffset >= CVFileChecksumTable.size())
1911 error(object_error::parse_failed);
1912
1913 // The string table offset comes first before the file checksum.
1914 StringRef Data = CVFileChecksumTable.drop_front(FileOffset);
1915 uint32_t StringOffset;
1916 error(consumeUInt32(Data, StringOffset));
1917
1918 // Check if the string table offset is valid.
1919 if (StringOffset >= CVStringTable.size())
1920 error(object_error::parse_failed);
1921
1922 // Return the null-terminated string.
1923 return CVStringTable.drop_front(StringOffset).split('\0').first;
1924}
1925
1926void COFFDumper::printFileNameForOffset(StringRef Label, uint32_t FileOffset) {
1927 W.printHex(Label, getFileNameForFileOffset(FileOffset), FileOffset);
1928}
1929
Reid Kleckner6b3faef2016-01-13 23:44:57 +00001930static StringRef getLeafTypeName(TypeLeafKind LT) {
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001931 switch (LT) {
1932 case LF_STRING_ID: return "StringId";
1933 case LF_FIELDLIST: return "FieldList";
1934 case LF_ARGLIST:
1935 case LF_SUBSTR_LIST: return "ArgList";
1936 case LF_CLASS:
1937 case LF_STRUCTURE:
1938 case LF_INTERFACE: return "ClassType";
1939 case LF_UNION: return "UnionType";
1940 case LF_ENUM: return "EnumType";
1941 case LF_ARRAY: return "ArrayType";
1942 case LF_VFTABLE: return "VFTableType";
1943 case LF_MFUNC_ID: return "MemberFuncId";
1944 case LF_PROCEDURE: return "ProcedureType";
1945 case LF_MFUNCTION: return "MemberFunctionType";
1946 case LF_METHODLIST: return "MethodListEntry";
1947 case LF_FUNC_ID: return "FuncId";
1948 case LF_TYPESERVER2: return "TypeServer2";
1949 case LF_POINTER: return "PointerType";
1950 case LF_MODIFIER: return "TypeModifier";
1951 case LF_VTSHAPE: return "VTableShape";
1952 case LF_UDT_SRC_LINE: return "UDTSrcLine";
1953 case LF_BUILDINFO: return "BuildInfo";
1954 default: break;
1955 }
1956 return "UnknownLeaf";
1957}
1958
1959void COFFDumper::printCodeViewTypeSection(StringRef SectionName,
1960 const SectionRef &Section) {
1961 ListScope D(W, "CodeViewTypes");
1962 W.printNumber("Section", SectionName, Obj->getSectionID(Section));
1963 StringRef Data;
1964 error(Section.getContents(Data));
1965 W.printBinaryBlock("Data", Data);
1966
1967 unsigned Magic = *reinterpret_cast<const ulittle32_t *>(Data.data());
1968 W.printHex("Magic", Magic);
1969
1970 Data = Data.drop_front(4);
1971
1972 while (!Data.empty()) {
Reid Kleckner6b3faef2016-01-13 23:44:57 +00001973 const TypeRecordPrefix *Rec;
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001974 error(consumeObject(Data, Rec));
Reid Kleckner6b3faef2016-01-13 23:44:57 +00001975 auto Leaf = static_cast<TypeLeafKind>(uint16_t(Rec->Leaf));
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001976
1977 // This record is 'Len - 2' bytes, and the next one starts immediately
1978 // afterwards.
1979 StringRef LeafData = Data.substr(0, Rec->Len - 2);
1980 StringRef RemainingData = Data.drop_front(LeafData.size());
1981
1982 // Find the name of this leaf type.
1983 StringRef LeafName = getLeafTypeName(Leaf);
1984 DictScope S(W, LeafName);
1985 unsigned NextTypeIndex = 0x1000 + CVUDTNames.size();
Reid Kleckner6b3faef2016-01-13 23:44:57 +00001986 W.printEnum("TypeLeafKind", unsigned(Leaf), makeArrayRef(LeafTypeNames));
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001987 W.printHex("TypeIndex", NextTypeIndex);
1988
1989 // Fill this in inside the switch to get something in CVUDTNames.
1990 StringRef Name;
1991
1992 switch (Leaf) {
1993 default: {
1994 W.printHex("Size", Rec->Len);
Reid Kleckner72e2ba72016-01-13 19:32:35 +00001995 break;
1996 }
1997
1998 case LF_STRING_ID: {
1999 const StringId *String;
2000 error(consumeObject(LeafData, String));
2001 W.printHex("Id", String->id.getIndex());
2002 StringRef StringData = getRemainingBytesAsString(Rec, LeafData.data());
2003 W.printString("StringData", StringData);
2004 // Put this in CVUDTNames so it gets printed with LF_UDT_SRC_LINE.
2005 Name = StringData;
2006 break;
2007 }
2008
2009 case LF_FIELDLIST: {
2010 W.printHex("Size", Rec->Len);
2011 // FieldList has no fixed prefix that can be described with a struct. All
2012 // the bytes must be interpreted as more records.
2013 printCodeViewFieldList(LeafData);
2014 break;
2015 }
2016
2017 case LF_ARGLIST:
2018 case LF_SUBSTR_LIST: {
2019 const ArgList *Args;
2020 error(consumeObject(LeafData, Args));
2021 W.printNumber("NumArgs", Args->NumArgs);
2022 ListScope Arguments(W, "Arguments");
2023 SmallString<256> TypeName("(");
2024 for (uint32_t ArgI = 0; ArgI != Args->NumArgs; ++ArgI) {
2025 const TypeIndex *Type;
2026 error(consumeObject(LeafData, Type));
2027 printTypeIndex("ArgType", *Type);
2028 StringRef ArgTypeName = getTypeName(*Type);
2029 TypeName.append(ArgTypeName);
2030 if (ArgI + 1 != Args->NumArgs)
2031 TypeName.append(", ");
2032 }
2033 TypeName.push_back(')');
2034 Name = TypeNames.insert(TypeName).first->getKey();
2035 break;
2036 }
2037
2038 case LF_CLASS:
2039 case LF_STRUCTURE:
2040 case LF_INTERFACE: {
2041 const ClassType *Class;
2042 error(consumeObject(LeafData, Class));
2043 W.printNumber("MemberCount", Class->MemberCount);
2044 uint16_t Props = Class->Properties;
2045 W.printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
2046 printTypeIndex("FieldList", Class->FieldList);
2047 printTypeIndex("DerivedFrom", Class->DerivedFrom);
2048 printTypeIndex("VShape", Class->VShape);
2049 uint64_t SizeOf;
2050 error(decodeUIntLeaf(LeafData, SizeOf));
2051 W.printNumber("SizeOf", SizeOf);
2052 StringRef LinkageName;
2053 std::tie(Name, LinkageName) = LeafData.split('\0');
2054 W.printString("Name", Name);
2055 if (Props & uint16_t(ClassOptions::HasUniqueName)) {
2056 LinkageName = getRemainingBytesAsString(Rec, LinkageName.data());
2057 if (LinkageName.empty())
2058 return error(object_error::parse_failed);
2059 W.printString("LinkageName", LinkageName);
2060 }
2061 break;
2062 }
2063
2064 case LF_UNION: {
2065 const UnionType *Union;
2066 error(consumeObject(LeafData, Union));
2067 W.printNumber("MemberCount", Union->MemberCount);
2068 uint16_t Props = Union->Properties;
2069 W.printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
2070 printTypeIndex("FieldList", Union->FieldList);
2071 uint64_t SizeOf;
2072 error(decodeUIntLeaf(LeafData, SizeOf));
2073 W.printNumber("SizeOf", SizeOf);
2074 StringRef LinkageName;
2075 std::tie(Name, LinkageName) = LeafData.split('\0');
2076 W.printString("Name", Name);
2077 if (Props & uint16_t(ClassOptions::HasUniqueName)) {
2078 LinkageName = getRemainingBytesAsString(Rec, LinkageName.data());
2079 if (LinkageName.empty())
2080 return error(object_error::parse_failed);
2081 W.printString("LinkageName", LinkageName);
2082 }
2083 break;
2084 }
2085
2086 case LF_ENUM: {
2087 const EnumType *Enum;
2088 error(consumeObject(LeafData, Enum));
2089 W.printNumber("NumEnumerators", Enum->NumEnumerators);
2090 W.printFlags("Properties", uint16_t(Enum->Properties),
2091 makeArrayRef(ClassOptionNames));
2092 printTypeIndex("UnderlyingType", Enum->UnderlyingType);
2093 printTypeIndex("FieldListType", Enum->FieldListType);
2094 Name = LeafData.split('\0').first;
2095 W.printString("Name", Name);
2096 break;
2097 }
2098
2099 case LF_ARRAY: {
2100 const ArrayType *AT;
2101 error(consumeObject(LeafData, AT));
2102 printTypeIndex("ElementType", AT->ElementType);
2103 printTypeIndex("IndexType", AT->IndexType);
2104 uint64_t SizeOf;
2105 error(decodeUIntLeaf(LeafData, SizeOf));
2106 W.printNumber("SizeOf", SizeOf);
2107 Name = LeafData.split('\0').first;
2108 W.printString("Name", Name);
2109 break;
2110 }
2111
2112 case LF_VFTABLE: {
2113 const VFTableType *VFT;
2114 error(consumeObject(LeafData, VFT));
2115 printTypeIndex("CompleteClass", VFT->CompleteClass);
2116 printTypeIndex("OverriddenVFTable", VFT->OverriddenVFTable);
2117 W.printHex("VFPtrOffset", VFT->VFPtrOffset);
2118 StringRef NamesData = LeafData.substr(0, VFT->NamesLen);
2119 std::tie(Name, NamesData) = NamesData.split('\0');
2120 W.printString("VFTableName", Name);
2121 while (!NamesData.empty()) {
2122 StringRef MethodName;
2123 std::tie(MethodName, NamesData) = NamesData.split('\0');
2124 W.printString("MethodName", MethodName);
2125 }
2126 break;
2127 }
2128
2129 case LF_MFUNC_ID: {
2130 const MemberFuncId *Id;
2131 error(consumeObject(LeafData, Id));
2132 printTypeIndex("ClassType", Id->ClassType);
2133 printTypeIndex("FunctionType", Id->FunctionType);
2134 Name = LeafData.split('\0').first;
2135 W.printString("Name", Name);
2136 break;
2137 }
2138
2139 case LF_PROCEDURE: {
2140 const ProcedureType *Proc;
2141 error(consumeObject(LeafData, Proc));
2142 printTypeIndex("ReturnType", Proc->ReturnType);
2143 W.printEnum("CallingConvention", uint8_t(Proc->CallConv),
2144 makeArrayRef(CallingConventions));
2145 W.printFlags("FunctionOptions", uint8_t(Proc->Options),
2146 makeArrayRef(FunctionOptionEnum));
2147 W.printNumber("NumParameters", Proc->NumParameters);
2148 printTypeIndex("ArgListType", Proc->ArgListType);
2149
2150 StringRef ReturnTypeName = getTypeName(Proc->ReturnType);
2151 StringRef ArgListTypeName = getTypeName(Proc->ArgListType);
2152 SmallString<256> TypeName(ReturnTypeName);
2153 TypeName.push_back(' ');
2154 TypeName.append(ArgListTypeName);
2155 Name = TypeNames.insert(TypeName).first->getKey();
2156 break;
2157 }
2158
2159 case LF_MFUNCTION: {
2160 const MemberFunctionType *MemberFunc;
2161 error(consumeObject(LeafData, MemberFunc));
2162 printTypeIndex("ReturnType", MemberFunc->ReturnType);
2163 printTypeIndex("ClassType", MemberFunc->ClassType);
2164 printTypeIndex("ThisType", MemberFunc->ThisType);
2165 W.printEnum("CallingConvention", uint8_t(MemberFunc->CallConv),
2166 makeArrayRef(CallingConventions));
2167 W.printFlags("FunctionOptions", uint8_t(MemberFunc->Options),
2168 makeArrayRef(FunctionOptionEnum));
2169 W.printNumber("NumParameters", MemberFunc->NumParameters);
2170 printTypeIndex("ArgListType", MemberFunc->ArgListType);
2171 W.printNumber("ThisAdjustment", MemberFunc->ThisAdjustment);
2172
2173 StringRef ReturnTypeName = getTypeName(MemberFunc->ReturnType);
2174 StringRef ClassTypeName = getTypeName(MemberFunc->ClassType);
2175 StringRef ArgListTypeName = getTypeName(MemberFunc->ArgListType);
2176 SmallString<256> TypeName(ReturnTypeName);
2177 TypeName.push_back(' ');
2178 TypeName.append(ClassTypeName);
2179 TypeName.append("::");
2180 TypeName.append(ArgListTypeName);
2181 Name = TypeNames.insert(TypeName).first->getKey();
2182 break;
2183 }
2184
2185 case LF_METHODLIST: {
2186 while (!LeafData.empty()) {
2187 const MethodListEntry *Method;
2188 error(consumeObject(LeafData, Method));
2189 ListScope S(W, "Method");
2190 printMemberAttributes(Method->Attrs);
2191 printTypeIndex("Type", Method->Type);
2192 if (Method->isIntroducedVirtual()) {
2193 const little32_t *VFTOffsetPtr;
2194 error(consumeObject(LeafData, VFTOffsetPtr));
2195 W.printHex("VFTableOffset", *VFTOffsetPtr);
2196 }
2197 }
2198 break;
2199 }
2200
2201 case LF_FUNC_ID: {
2202 const FuncId *Func;
2203 error(consumeObject(LeafData, Func));
2204 printTypeIndex("ParentScope", Func->ParentScope);
2205 printTypeIndex("FunctionType", Func->FunctionType);
Reid Kleckner089db212016-01-14 17:52:01 +00002206 StringRef Null;
Reid Kleckner72e2ba72016-01-13 19:32:35 +00002207 std::tie(Name, Null) = LeafData.split('\0');
2208 W.printString("Name", Name);
2209 break;
2210 }
2211
2212 case LF_TYPESERVER2: {
2213 const TypeServer2 *TypeServer;
2214 error(consumeObject(LeafData, TypeServer));
2215 W.printBinary("Signature", StringRef(TypeServer->Signature, 16));
2216 W.printNumber("Age", TypeServer->Age);
2217 Name = LeafData.split('\0').first;
2218 W.printString("Name", Name);
2219 break;
2220 }
2221
2222 case LF_POINTER: {
2223 const PointerType *Ptr;
2224 error(consumeObject(LeafData, Ptr));
2225 printTypeIndex("PointeeType", Ptr->PointeeType);
2226 W.printHex("PointerAttributes", Ptr->Attrs);
2227 W.printEnum("PtrType", unsigned(Ptr->getPtrKind()),
2228 makeArrayRef(PtrKindNames));
2229 W.printEnum("PtrMode", unsigned(Ptr->getPtrMode()),
2230 makeArrayRef(PtrModeNames));
2231 W.printNumber("IsFlat", Ptr->isFlat());
2232 W.printNumber("IsConst", Ptr->isConst());
2233 W.printNumber("IsVolatile", Ptr->isVolatile());
2234 W.printNumber("IsUnaligned", Ptr->isUnaligned());
2235
2236 if (Ptr->isPointerToMember()) {
2237 const PointerToMemberTail *PMT;
2238 error(consumeObject(LeafData, PMT));
2239 printTypeIndex("ClassType", PMT->ClassType);
2240 W.printEnum("Representation", PMT->Representation,
2241 makeArrayRef(PtrMemberRepNames));
2242
2243 StringRef PointeeName = getTypeName(Ptr->PointeeType);
2244 StringRef ClassName = getTypeName(PMT->ClassType);
2245 SmallString<256> TypeName(PointeeName);
2246 TypeName.push_back(' ');
2247 TypeName.append(ClassName);
2248 TypeName.append("::*");
2249 Name = TypeNames.insert(TypeName).first->getKey();
2250 } else {
2251 W.printBinaryBlock("TailData", LeafData);
2252
2253 SmallString<256> TypeName;
2254 if (Ptr->isConst())
2255 TypeName.append("const ");
2256 if (Ptr->isVolatile())
2257 TypeName.append("volatile ");
2258 if (Ptr->isUnaligned())
2259 TypeName.append("__unaligned ");
2260
2261 TypeName.append(getTypeName(Ptr->PointeeType));
2262
2263 if (Ptr->getPtrMode() == PointerMode::LValueReference)
2264 TypeName.append("&");
2265 else if (Ptr->getPtrMode() == PointerMode::RValueReference)
2266 TypeName.append("&&");
2267 else if (Ptr->getPtrMode() == PointerMode::Pointer)
2268 TypeName.append("*");
2269
2270 Name = TypeNames.insert(TypeName).first->getKey();
2271 }
2272 break;
2273 }
2274
2275 case LF_MODIFIER: {
2276 const TypeModifier *Mod;
2277 error(consumeObject(LeafData, Mod));
2278 printTypeIndex("ModifiedType", Mod->ModifiedType);
2279 W.printFlags("Modifiers", Mod->Modifiers,
2280 makeArrayRef(TypeModifierNames));
2281
2282 StringRef ModifiedName = getTypeName(Mod->ModifiedType);
2283 SmallString<256> TypeName;
2284 if (Mod->Modifiers & uint16_t(ModifierOptions::Const))
2285 TypeName.append("const ");
2286 if (Mod->Modifiers & uint16_t(ModifierOptions::Volatile))
2287 TypeName.append("volatile ");
2288 if (Mod->Modifiers & uint16_t(ModifierOptions::Unaligned))
2289 TypeName.append("__unaligned ");
2290 TypeName.append(ModifiedName);
2291 Name = TypeNames.insert(TypeName).first->getKey();
2292 break;
2293 }
2294
2295 case LF_VTSHAPE: {
2296 const VTableShape *Shape;
2297 error(consumeObject(LeafData, Shape));
2298 unsigned VFEntryCount = Shape->VFEntryCount;
2299 W.printNumber("VFEntryCount", VFEntryCount);
2300 // We could print out whether the methods are near or far, but in practice
2301 // today everything is CV_VTS_near32, so it's just noise.
2302 break;
2303 }
2304
2305 case LF_UDT_SRC_LINE: {
2306 const UDTSrcLine *Line;
2307 error(consumeObject(LeafData, Line));
2308 printTypeIndex("UDT", Line->UDT);
2309 printTypeIndex("SourceFile", Line->SourceFile);
2310 W.printNumber("LineNumber", Line->LineNumber);
2311 break;
2312 }
2313
2314 case LF_BUILDINFO: {
2315 const BuildInfo *Args;
2316 error(consumeObject(LeafData, Args));
2317 W.printNumber("NumArgs", Args->NumArgs);
2318
2319 ListScope Arguments(W, "Arguments");
2320 for (uint32_t ArgI = 0; ArgI != Args->NumArgs; ++ArgI) {
2321 const TypeIndex *Type;
2322 error(consumeObject(LeafData, Type));
2323 printTypeIndex("ArgType", *Type);
2324 }
2325 break;
2326 }
2327 }
2328
Reid Kleckner1c7a9cd2016-01-14 17:51:57 +00002329 if (opts::CodeViewSubsectionBytes)
2330 W.printBinaryBlock("LeafData", LeafData);
2331
Reid Kleckner72e2ba72016-01-13 19:32:35 +00002332 CVUDTNames.push_back(Name);
2333
2334 Data = RemainingData;
2335 // FIXME: The stream contains LF_PAD bytes that we need to ignore, but those
2336 // are typically included in LeafData. We may need to call skipPadding() if
2337 // we ever find a record that doesn't count those bytes.
2338 }
2339}
2340
2341static StringRef skipPadding(StringRef Data) {
2342 if (Data.empty())
2343 return Data;
2344 uint8_t Leaf = Data.front();
2345 if (Leaf < LF_PAD0)
2346 return Data;
2347 // Leaf is greater than 0xf0. We should advance by the number of bytes in the
2348 // low 4 bits.
2349 return Data.drop_front(Leaf & 0x0F);
2350}
2351
2352void COFFDumper::printMemberAttributes(MemberAttributes Attrs) {
2353 W.printEnum("AccessSpecifier", uint8_t(Attrs.getAccess()),
2354 makeArrayRef(MemberAccessNames));
2355 auto MK = Attrs.getMethodKind();
2356 // Data members will be vanilla. Don't try to print a method kind for them.
2357 if (MK != MethodKind::Vanilla)
2358 W.printEnum("MethodKind", unsigned(MK), makeArrayRef(MemberKindNames));
2359 if (Attrs.getFlags() != MethodOptions::None) {
2360 W.printFlags("MethodOptions", unsigned(Attrs.getFlags()),
2361 makeArrayRef(MethodOptionNames));
2362 }
2363}
2364
2365void COFFDumper::printCodeViewFieldList(StringRef FieldData) {
2366 while (!FieldData.empty()) {
2367 const ulittle16_t *LeafPtr;
2368 error(consumeObject(FieldData, LeafPtr));
2369 uint16_t Leaf = *LeafPtr;
2370 switch (Leaf) {
2371 default:
2372 W.printHex("UnknownMember", Leaf);
2373 // We can't advance once we hit an unknown field. The size is not encoded.
2374 return;
2375
2376 case LF_NESTTYPE: {
2377 const NestedType *Nested;
2378 error(consumeObject(FieldData, Nested));
2379 DictScope S(W, "NestedType");
2380 printTypeIndex("Type", Nested->Type);
2381 StringRef Name;
2382 std::tie(Name, FieldData) = FieldData.split('\0');
2383 W.printString("Name", Name);
2384 break;
2385 }
2386
2387 case LF_ONEMETHOD: {
2388 const OneMethod *Method;
2389 error(consumeObject(FieldData, Method));
2390 DictScope S(W, "OneMethod");
2391 printMemberAttributes(Method->Attrs);
2392 printTypeIndex("Type", Method->Type);
2393 // If virtual, then read the vftable offset.
2394 if (Method->isIntroducedVirtual()) {
2395 const little32_t *VFTOffsetPtr;
2396 error(consumeObject(FieldData, VFTOffsetPtr));
2397 W.printHex("VFTableOffset", *VFTOffsetPtr);
2398 }
2399 StringRef Name;
2400 std::tie(Name, FieldData) = FieldData.split('\0');
2401 W.printString("Name", Name);
2402 break;
2403 }
2404
2405 case LF_METHOD: {
2406 const OverloadedMethod *Method;
2407 error(consumeObject(FieldData, Method));
2408 DictScope S(W, "OverloadedMethod");
2409 W.printHex("MethodCount", Method->MethodCount);
2410 W.printHex("MethodListIndex", Method->MethList.getIndex());
2411 StringRef Name;
2412 std::tie(Name, FieldData) = FieldData.split('\0');
2413 W.printString("Name", Name);
2414 break;
2415 }
2416
2417 case LF_MEMBER: {
2418 const DataMember *Field;
2419 error(consumeObject(FieldData, Field));
2420 DictScope S(W, "DataMember");
2421 printMemberAttributes(Field->Attrs);
2422 printTypeIndex("Type", Field->Type);
2423 uint64_t FieldOffset;
2424 error(decodeUIntLeaf(FieldData, FieldOffset));
2425 W.printHex("FieldOffset", FieldOffset);
2426 StringRef Name;
2427 std::tie(Name, FieldData) = FieldData.split('\0');
2428 W.printString("Name", Name);
2429 break;
2430 }
2431
2432 case LF_STMEMBER: {
2433 const StaticDataMember *Field;
2434 error(consumeObject(FieldData, Field));
2435 DictScope S(W, "StaticDataMember");
2436 printMemberAttributes(Field->Attrs);
2437 printTypeIndex("Type", Field->Type);
2438 StringRef Name;
2439 std::tie(Name, FieldData) = FieldData.split('\0');
2440 W.printString("Name", Name);
2441 break;
2442 }
2443
2444 case LF_VFUNCTAB: {
2445 const VirtualFunctionPointer *VFTable;
2446 error(consumeObject(FieldData, VFTable));
2447 DictScope S(W, "VirtualFunctionPointer");
2448 printTypeIndex("Type", VFTable->Type);
2449 break;
2450 }
2451
2452 case LF_ENUMERATE: {
2453 const Enumerator *Enum;
2454 error(consumeObject(FieldData, Enum));
2455 DictScope S(W, "Enumerator");
2456 printMemberAttributes(Enum->Attrs);
2457 APSInt EnumValue;
2458 error(decodeNumerictLeaf(FieldData, EnumValue));
2459 W.printNumber("EnumValue", EnumValue);
2460 StringRef Name;
2461 std::tie(Name, FieldData) = FieldData.split('\0');
2462 W.printString("Name", Name);
2463 break;
2464 }
2465
2466 case LF_BCLASS:
2467 case LF_BINTERFACE: {
2468 const BaseClass *Base;
2469 error(consumeObject(FieldData, Base));
2470 DictScope S(W, "BaseClass");
2471 printMemberAttributes(Base->Attrs);
2472 printTypeIndex("BaseType", Base->BaseType);
2473 uint64_t BaseOffset;
2474 error(decodeUIntLeaf(FieldData, BaseOffset));
2475 W.printHex("BaseOffset", BaseOffset);
2476 break;
2477 }
2478
2479 case LF_VBCLASS:
2480 case LF_IVBCLASS: {
2481 const VirtualBaseClass *Base;
2482 error(consumeObject(FieldData, Base));
2483 DictScope S(W, "VirtualBaseClass");
2484 printMemberAttributes(Base->Attrs);
2485 printTypeIndex("BaseType", Base->BaseType);
2486 printTypeIndex("VBPtrType", Base->VBPtrType);
2487 uint64_t VBPtrOffset, VBTableIndex;
2488 error(decodeUIntLeaf(FieldData, VBPtrOffset));
2489 error(decodeUIntLeaf(FieldData, VBTableIndex));
2490 W.printHex("VBPtrOffset", VBPtrOffset);
2491 W.printHex("VBTableIndex", VBTableIndex);
2492 break;
2493 }
2494 }
2495
2496 // Handle padding.
2497 FieldData = skipPadding(FieldData);
2498 }
Timur Iskhodzhanov56af52f2014-10-23 22:25:31 +00002499}
2500
Eric Christopher9cad53c2013-04-03 18:31:38 +00002501void COFFDumper::printSections() {
Eric Christopher9cad53c2013-04-03 18:31:38 +00002502 ListScope SectionsD(W, "Sections");
2503 int SectionNumber = 0;
Alexey Samsonov27dc8392014-03-18 06:53:02 +00002504 for (const SectionRef &Sec : Obj->sections()) {
Eric Christopher9cad53c2013-04-03 18:31:38 +00002505 ++SectionNumber;
Alexey Samsonov27dc8392014-03-18 06:53:02 +00002506 const coff_section *Section = Obj->getCOFFSection(Sec);
Eric Christopher9cad53c2013-04-03 18:31:38 +00002507
2508 StringRef Name;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002509 error(Sec.getName(Name));
Eric Christopher9cad53c2013-04-03 18:31:38 +00002510
2511 DictScope D(W, "Section");
2512 W.printNumber("Number", SectionNumber);
2513 W.printBinary("Name", Name, Section->Name);
2514 W.printHex ("VirtualSize", Section->VirtualSize);
2515 W.printHex ("VirtualAddress", Section->VirtualAddress);
2516 W.printNumber("RawDataSize", Section->SizeOfRawData);
2517 W.printHex ("PointerToRawData", Section->PointerToRawData);
2518 W.printHex ("PointerToRelocations", Section->PointerToRelocations);
2519 W.printHex ("PointerToLineNumbers", Section->PointerToLinenumbers);
2520 W.printNumber("RelocationCount", Section->NumberOfRelocations);
2521 W.printNumber("LineNumberCount", Section->NumberOfLinenumbers);
2522 W.printFlags ("Characteristics", Section->Characteristics,
2523 makeArrayRef(ImageSectionCharacteristics),
2524 COFF::SectionCharacteristics(0x00F00000));
2525
2526 if (opts::SectionRelocations) {
2527 ListScope D(W, "Relocations");
Alexey Samsonov27dc8392014-03-18 06:53:02 +00002528 for (const RelocationRef &Reloc : Sec.relocations())
2529 printRelocation(Sec, Reloc);
Eric Christopher9cad53c2013-04-03 18:31:38 +00002530 }
2531
2532 if (opts::SectionSymbols) {
2533 ListScope D(W, "Symbols");
Alexey Samsonov27dc8392014-03-18 06:53:02 +00002534 for (const SymbolRef &Symbol : Obj->symbols()) {
Rafael Espindola80291272014-10-08 15:28:58 +00002535 if (!Sec.containsSymbol(Symbol))
Eric Christopher9cad53c2013-04-03 18:31:38 +00002536 continue;
2537
Alexey Samsonov27dc8392014-03-18 06:53:02 +00002538 printSymbol(Symbol);
Eric Christopher9cad53c2013-04-03 18:31:38 +00002539 }
2540 }
2541
David Majnemerdac39852014-09-26 22:32:16 +00002542 if (opts::SectionData &&
2543 !(Section->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA)) {
Eric Christopher9cad53c2013-04-03 18:31:38 +00002544 StringRef Data;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002545 error(Sec.getContents(Data));
Eric Christopher9cad53c2013-04-03 18:31:38 +00002546
2547 W.printBinaryBlock("SectionData", Data);
2548 }
2549 }
2550}
2551
2552void COFFDumper::printRelocations() {
2553 ListScope D(W, "Relocations");
2554
Eric Christopher9cad53c2013-04-03 18:31:38 +00002555 int SectionNumber = 0;
Alexey Samsonov27dc8392014-03-18 06:53:02 +00002556 for (const SectionRef &Section : Obj->sections()) {
Eric Christopher9cad53c2013-04-03 18:31:38 +00002557 ++SectionNumber;
Eric Christopher9cad53c2013-04-03 18:31:38 +00002558 StringRef Name;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002559 error(Section.getName(Name));
Eric Christopher9cad53c2013-04-03 18:31:38 +00002560
2561 bool PrintedGroup = false;
Alexey Samsonov27dc8392014-03-18 06:53:02 +00002562 for (const RelocationRef &Reloc : Section.relocations()) {
Eric Christopher9cad53c2013-04-03 18:31:38 +00002563 if (!PrintedGroup) {
2564 W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n";
2565 W.indent();
2566 PrintedGroup = true;
2567 }
2568
Alexey Samsonov27dc8392014-03-18 06:53:02 +00002569 printRelocation(Section, Reloc);
Eric Christopher9cad53c2013-04-03 18:31:38 +00002570 }
2571
2572 if (PrintedGroup) {
2573 W.unindent();
2574 W.startLine() << "}\n";
2575 }
2576 }
2577}
2578
Alexey Samsonov27dc8392014-03-18 06:53:02 +00002579void COFFDumper::printRelocation(const SectionRef &Section,
Reid Kleckner1c7a9cd2016-01-14 17:51:57 +00002580 const RelocationRef &Reloc, uint64_t Bias) {
2581 uint64_t Offset = Reloc.getOffset() - Bias;
Rafael Espindola99c041b2015-06-30 01:53:01 +00002582 uint64_t RelocType = Reloc.getType();
Eric Christopher9cad53c2013-04-03 18:31:38 +00002583 SmallString<32> RelocName;
Eric Christopher9cad53c2013-04-03 18:31:38 +00002584 StringRef SymbolName;
Rafael Espindola41bb4322015-06-30 04:08:37 +00002585 Reloc.getTypeName(RelocName);
Alexey Samsonovaa4d2952014-03-14 14:22:49 +00002586 symbol_iterator Symbol = Reloc.getSymbol();
Rafael Espindola5d0c2ff2015-07-02 20:55:21 +00002587 if (Symbol != Obj->symbol_end()) {
2588 ErrorOr<StringRef> SymbolNameOrErr = Symbol->getName();
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002589 error(SymbolNameOrErr.getError());
Rafael Espindola5d0c2ff2015-07-02 20:55:21 +00002590 SymbolName = *SymbolNameOrErr;
2591 }
Eric Christopher9cad53c2013-04-03 18:31:38 +00002592
Nico Rieckf3f0b792013-04-12 04:01:52 +00002593 if (opts::ExpandRelocs) {
2594 DictScope Group(W, "Relocation");
2595 W.printHex("Offset", Offset);
2596 W.printNumber("Type", RelocName, RelocType);
David Majnemer1f80b0a2014-11-13 07:42:11 +00002597 W.printString("Symbol", SymbolName.empty() ? "-" : SymbolName);
Nico Rieckf3f0b792013-04-12 04:01:52 +00002598 } else {
2599 raw_ostream& OS = W.startLine();
2600 OS << W.hex(Offset)
2601 << " " << RelocName
David Majnemer1f80b0a2014-11-13 07:42:11 +00002602 << " " << (SymbolName.empty() ? "-" : SymbolName)
Nico Rieckf3f0b792013-04-12 04:01:52 +00002603 << "\n";
2604 }
Eric Christopher9cad53c2013-04-03 18:31:38 +00002605}
2606
2607void COFFDumper::printSymbols() {
2608 ListScope Group(W, "Symbols");
2609
Alexey Samsonov27dc8392014-03-18 06:53:02 +00002610 for (const SymbolRef &Symbol : Obj->symbols())
2611 printSymbol(Symbol);
Eric Christopher9cad53c2013-04-03 18:31:38 +00002612}
2613
Alexey Samsonov27dc8392014-03-18 06:53:02 +00002614void COFFDumper::printDynamicSymbols() { ListScope Group(W, "DynamicSymbols"); }
Eric Christopher9cad53c2013-04-03 18:31:38 +00002615
David Majnemer236b0ca2014-11-17 11:17:17 +00002616static ErrorOr<StringRef>
2617getSectionName(const llvm::object::COFFObjectFile *Obj, int32_t SectionNumber,
2618 const coff_section *Section) {
David Majnemerf4dc4562014-09-20 00:25:06 +00002619 if (Section) {
2620 StringRef SectionName;
David Majnemer236b0ca2014-11-17 11:17:17 +00002621 if (std::error_code EC = Obj->getSectionName(Section, SectionName))
2622 return EC;
David Majnemerf4dc4562014-09-20 00:25:06 +00002623 return SectionName;
2624 }
David Majnemerf4dc4562014-09-20 00:25:06 +00002625 if (SectionNumber == llvm::COFF::IMAGE_SYM_DEBUG)
David Majnemer236b0ca2014-11-17 11:17:17 +00002626 return StringRef("IMAGE_SYM_DEBUG");
David Majnemerf4dc4562014-09-20 00:25:06 +00002627 if (SectionNumber == llvm::COFF::IMAGE_SYM_ABSOLUTE)
David Majnemer236b0ca2014-11-17 11:17:17 +00002628 return StringRef("IMAGE_SYM_ABSOLUTE");
David Majnemerf4dc4562014-09-20 00:25:06 +00002629 if (SectionNumber == llvm::COFF::IMAGE_SYM_UNDEFINED)
David Majnemer236b0ca2014-11-17 11:17:17 +00002630 return StringRef("IMAGE_SYM_UNDEFINED");
2631 return StringRef("");
David Majnemerf4dc4562014-09-20 00:25:06 +00002632}
2633
Alexey Samsonov27dc8392014-03-18 06:53:02 +00002634void COFFDumper::printSymbol(const SymbolRef &Sym) {
Eric Christopher9cad53c2013-04-03 18:31:38 +00002635 DictScope D(W, "Symbol");
2636
David Majnemer44f51e52014-09-10 12:51:52 +00002637 COFFSymbolRef Symbol = Obj->getCOFFSymbol(Sym);
Eric Christopher9cad53c2013-04-03 18:31:38 +00002638 const coff_section *Section;
David Majnemer44f51e52014-09-10 12:51:52 +00002639 if (std::error_code EC = Obj->getSection(Symbol.getSectionNumber(), Section)) {
Eric Christopher9cad53c2013-04-03 18:31:38 +00002640 W.startLine() << "Invalid section number: " << EC.message() << "\n";
2641 W.flush();
2642 return;
2643 }
2644
2645 StringRef SymbolName;
2646 if (Obj->getSymbolName(Symbol, SymbolName))
2647 SymbolName = "";
2648
David Majnemer236b0ca2014-11-17 11:17:17 +00002649 StringRef SectionName = "";
2650 ErrorOr<StringRef> Res =
2651 getSectionName(Obj, Symbol.getSectionNumber(), Section);
2652 if (Res)
2653 SectionName = *Res;
Eric Christopher9cad53c2013-04-03 18:31:38 +00002654
2655 W.printString("Name", SymbolName);
David Majnemer44f51e52014-09-10 12:51:52 +00002656 W.printNumber("Value", Symbol.getValue());
2657 W.printNumber("Section", SectionName, Symbol.getSectionNumber());
2658 W.printEnum ("BaseType", Symbol.getBaseType(), makeArrayRef(ImageSymType));
2659 W.printEnum ("ComplexType", Symbol.getComplexType(),
Eric Christopher9cad53c2013-04-03 18:31:38 +00002660 makeArrayRef(ImageSymDType));
David Majnemer44f51e52014-09-10 12:51:52 +00002661 W.printEnum ("StorageClass", Symbol.getStorageClass(),
Eric Christopher9cad53c2013-04-03 18:31:38 +00002662 makeArrayRef(ImageSymClass));
David Majnemer44f51e52014-09-10 12:51:52 +00002663 W.printNumber("AuxSymbolCount", Symbol.getNumberOfAuxSymbols());
Eric Christopher9cad53c2013-04-03 18:31:38 +00002664
David Majnemer44f51e52014-09-10 12:51:52 +00002665 for (uint8_t I = 0; I < Symbol.getNumberOfAuxSymbols(); ++I) {
2666 if (Symbol.isFunctionDefinition()) {
Eric Christopher9cad53c2013-04-03 18:31:38 +00002667 const coff_aux_function_definition *Aux;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002668 error(getSymbolAuxData(Obj, Symbol, I, Aux));
Eric Christopher9cad53c2013-04-03 18:31:38 +00002669
2670 DictScope AS(W, "AuxFunctionDef");
2671 W.printNumber("TagIndex", Aux->TagIndex);
2672 W.printNumber("TotalSize", Aux->TotalSize);
David Majnemerf3a2af52014-03-19 04:33:27 +00002673 W.printHex("PointerToLineNumber", Aux->PointerToLinenumber);
Eric Christopher9cad53c2013-04-03 18:31:38 +00002674 W.printHex("PointerToNextFunction", Aux->PointerToNextFunction);
Eric Christopher9cad53c2013-04-03 18:31:38 +00002675
David Majnemerc7d7c6f2014-10-31 05:07:00 +00002676 } else if (Symbol.isAnyUndefined()) {
David Majnemerf3a2af52014-03-19 04:33:27 +00002677 const coff_aux_weak_external *Aux;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002678 error(getSymbolAuxData(Obj, Symbol, I, Aux));
Eric Christopher9cad53c2013-04-03 18:31:38 +00002679
David Majnemer44f51e52014-09-10 12:51:52 +00002680 ErrorOr<COFFSymbolRef> Linked = Obj->getSymbol(Aux->TagIndex);
Eric Christopher9cad53c2013-04-03 18:31:38 +00002681 StringRef LinkedName;
David Majnemer44f51e52014-09-10 12:51:52 +00002682 std::error_code EC = Linked.getError();
2683 if (EC || (EC = Obj->getSymbolName(*Linked, LinkedName))) {
Eric Christopher9cad53c2013-04-03 18:31:38 +00002684 LinkedName = "";
2685 error(EC);
2686 }
2687
2688 DictScope AS(W, "AuxWeakExternal");
2689 W.printNumber("Linked", LinkedName, Aux->TagIndex);
2690 W.printEnum ("Search", Aux->Characteristics,
2691 makeArrayRef(WeakExternalCharacteristics));
Eric Christopher9cad53c2013-04-03 18:31:38 +00002692
David Majnemer44f51e52014-09-10 12:51:52 +00002693 } else if (Symbol.isFileRecord()) {
2694 const char *FileName;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002695 error(getSymbolAuxData(Obj, Symbol, I, FileName));
Eric Christopher9cad53c2013-04-03 18:31:38 +00002696
Nico Rieck0ab8e602013-04-22 08:35:11 +00002697 DictScope AS(W, "AuxFileRecord");
Saleem Abdulrasoold38c6b12014-04-14 02:37:23 +00002698
David Majnemer44f51e52014-09-10 12:51:52 +00002699 StringRef Name(FileName, Symbol.getNumberOfAuxSymbols() *
2700 Obj->getSymbolTableEntrySize());
Saleem Abdulrasoold38c6b12014-04-14 02:37:23 +00002701 W.printString("FileName", Name.rtrim(StringRef("\0", 1)));
Saleem Abdulrasool3b5e0012014-04-16 04:15:29 +00002702 break;
David Majnemer44f51e52014-09-10 12:51:52 +00002703 } else if (Symbol.isSectionDefinition()) {
Eric Christopher9cad53c2013-04-03 18:31:38 +00002704 const coff_aux_section_definition *Aux;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002705 error(getSymbolAuxData(Obj, Symbol, I, Aux));
Eric Christopher9cad53c2013-04-03 18:31:38 +00002706
David Majnemer4d571592014-09-15 19:42:42 +00002707 int32_t AuxNumber = Aux->getNumber(Symbol.isBigObj());
2708
Eric Christopher9cad53c2013-04-03 18:31:38 +00002709 DictScope AS(W, "AuxSectionDef");
2710 W.printNumber("Length", Aux->Length);
2711 W.printNumber("RelocationCount", Aux->NumberOfRelocations);
2712 W.printNumber("LineNumberCount", Aux->NumberOfLinenumbers);
2713 W.printHex("Checksum", Aux->CheckSum);
David Majnemer4d571592014-09-15 19:42:42 +00002714 W.printNumber("Number", AuxNumber);
Eric Christopher9cad53c2013-04-03 18:31:38 +00002715 W.printEnum("Selection", Aux->Selection, makeArrayRef(ImageCOMDATSelect));
Eric Christopher9cad53c2013-04-03 18:31:38 +00002716
Nico Riecka711dee2013-04-22 08:34:59 +00002717 if (Section && Section->Characteristics & COFF::IMAGE_SCN_LNK_COMDAT
Eric Christopher9cad53c2013-04-03 18:31:38 +00002718 && Aux->Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
2719 const coff_section *Assoc;
David Majnemer236b0ca2014-11-17 11:17:17 +00002720 StringRef AssocName = "";
2721 std::error_code EC = Obj->getSection(AuxNumber, Assoc);
2722 ErrorOr<StringRef> Res = getSectionName(Obj, AuxNumber, Assoc);
2723 if (Res)
2724 AssocName = *Res;
2725 if (!EC)
2726 EC = Res.getError();
2727 if (EC) {
Eric Christopher9cad53c2013-04-03 18:31:38 +00002728 AssocName = "";
2729 error(EC);
2730 }
2731
David Majnemer4d571592014-09-15 19:42:42 +00002732 W.printNumber("AssocSection", AssocName, AuxNumber);
Eric Christopher9cad53c2013-04-03 18:31:38 +00002733 }
David Majnemer44f51e52014-09-10 12:51:52 +00002734 } else if (Symbol.isCLRToken()) {
Eric Christopher9cad53c2013-04-03 18:31:38 +00002735 const coff_aux_clr_token *Aux;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002736 error(getSymbolAuxData(Obj, Symbol, I, Aux));
Eric Christopher9cad53c2013-04-03 18:31:38 +00002737
David Majnemer44f51e52014-09-10 12:51:52 +00002738 ErrorOr<COFFSymbolRef> ReferredSym =
2739 Obj->getSymbol(Aux->SymbolTableIndex);
Nico Rieck8678acd2014-03-17 01:46:52 +00002740 StringRef ReferredName;
David Majnemer44f51e52014-09-10 12:51:52 +00002741 std::error_code EC = ReferredSym.getError();
2742 if (EC || (EC = Obj->getSymbolName(*ReferredSym, ReferredName))) {
Nico Rieck8678acd2014-03-17 01:46:52 +00002743 ReferredName = "";
2744 error(EC);
2745 }
2746
Eric Christopher9cad53c2013-04-03 18:31:38 +00002747 DictScope AS(W, "AuxCLRToken");
2748 W.printNumber("AuxType", Aux->AuxType);
2749 W.printNumber("Reserved", Aux->Reserved);
Nico Rieck8678acd2014-03-17 01:46:52 +00002750 W.printNumber("SymbolTableIndex", ReferredName, Aux->SymbolTableIndex);
Eric Christopher9cad53c2013-04-03 18:31:38 +00002751
2752 } else {
2753 W.startLine() << "<unhandled auxiliary record>\n";
2754 }
2755 }
2756}
2757
2758void COFFDumper::printUnwindInfo() {
Eric Christopher9cad53c2013-04-03 18:31:38 +00002759 ListScope D(W, "UnwindInformation");
David Majnemer44f51e52014-09-10 12:51:52 +00002760 switch (Obj->getMachine()) {
Saleem Abdulrasoole8839a72014-05-25 20:26:45 +00002761 case COFF::IMAGE_FILE_MACHINE_AMD64: {
2762 Win64EH::Dumper Dumper(W);
Rafael Espindola4453e42942014-06-13 03:07:50 +00002763 Win64EH::Dumper::SymbolResolver
2764 Resolver = [](const object::coff_section *Section, uint64_t Offset,
2765 SymbolRef &Symbol, void *user_data) -> std::error_code {
2766 COFFDumper *Dumper = reinterpret_cast<COFFDumper *>(user_data);
2767 return Dumper->resolveSymbol(Section, Offset, Symbol);
2768 };
Saleem Abdulrasool65dbbb52014-05-25 21:37:59 +00002769 Win64EH::Dumper::Context Ctx(*Obj, Resolver, this);
Saleem Abdulrasoole8839a72014-05-25 20:26:45 +00002770 Dumper.printData(Ctx);
2771 break;
Eric Christopher9cad53c2013-04-03 18:31:38 +00002772 }
Saleem Abdulrasoole6971ca2014-06-04 15:47:15 +00002773 case COFF::IMAGE_FILE_MACHINE_ARMNT: {
2774 ARM::WinEH::Decoder Decoder(W);
2775 Decoder.dumpProcedureData(*Obj);
2776 break;
2777 }
Saleem Abdulrasoole8839a72014-05-25 20:26:45 +00002778 default:
David Majnemer44f51e52014-09-10 12:51:52 +00002779 W.printEnum("unsupported Image Machine", Obj->getMachine(),
Saleem Abdulrasoole8839a72014-05-25 20:26:45 +00002780 makeArrayRef(ImageFileMachineType));
2781 break;
Eric Christopher9cad53c2013-04-03 18:31:38 +00002782 }
2783}
2784
Rui Ueyama979fb402014-10-09 02:16:38 +00002785void COFFDumper::printImportedSymbols(
2786 iterator_range<imported_symbol_iterator> Range) {
2787 for (const ImportedSymbolRef &I : Range) {
Rui Ueyama15d99352014-10-03 00:41:58 +00002788 StringRef Sym;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002789 error(I.getSymbolName(Sym));
Rui Ueyama15d99352014-10-03 00:41:58 +00002790 uint16_t Ordinal;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002791 error(I.getOrdinal(Ordinal));
Rui Ueyama15d99352014-10-03 00:41:58 +00002792 W.printNumber("Symbol", Sym, Ordinal);
2793 }
2794}
2795
Rui Ueyamaffa4ceb2014-11-13 03:22:54 +00002796void COFFDumper::printDelayImportedSymbols(
2797 const DelayImportDirectoryEntryRef &I,
2798 iterator_range<imported_symbol_iterator> Range) {
2799 int Index = 0;
2800 for (const ImportedSymbolRef &S : Range) {
2801 DictScope Import(W, "Import");
2802 StringRef Sym;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002803 error(S.getSymbolName(Sym));
Rui Ueyamaffa4ceb2014-11-13 03:22:54 +00002804 uint16_t Ordinal;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002805 error(S.getOrdinal(Ordinal));
Rui Ueyamaffa4ceb2014-11-13 03:22:54 +00002806 W.printNumber("Symbol", Sym, Ordinal);
2807 uint64_t Addr;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002808 error(I.getImportAddress(Index++, Addr));
Rui Ueyamaffa4ceb2014-11-13 03:22:54 +00002809 W.printHex("Address", Addr);
2810 }
2811}
2812
Rui Ueyama1e152d52014-10-02 17:02:18 +00002813void COFFDumper::printCOFFImports() {
Rui Ueyama15d99352014-10-03 00:41:58 +00002814 // Regular imports
Rui Ueyama979fb402014-10-09 02:16:38 +00002815 for (const ImportDirectoryEntryRef &I : Obj->import_directories()) {
Rui Ueyama1e152d52014-10-02 17:02:18 +00002816 DictScope Import(W, "Import");
2817 StringRef Name;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002818 error(I.getName(Name));
Rui Ueyama1e152d52014-10-02 17:02:18 +00002819 W.printString("Name", Name);
2820 uint32_t Addr;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002821 error(I.getImportLookupTableRVA(Addr));
Rui Ueyama1e152d52014-10-02 17:02:18 +00002822 W.printHex("ImportLookupTableRVA", Addr);
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002823 error(I.getImportAddressTableRVA(Addr));
Rui Ueyama1e152d52014-10-02 17:02:18 +00002824 W.printHex("ImportAddressTableRVA", Addr);
Rui Ueyama979fb402014-10-09 02:16:38 +00002825 printImportedSymbols(I.imported_symbols());
Rui Ueyama15d99352014-10-03 00:41:58 +00002826 }
2827
2828 // Delay imports
Rui Ueyama979fb402014-10-09 02:16:38 +00002829 for (const DelayImportDirectoryEntryRef &I : Obj->delay_import_directories()) {
Rui Ueyama15d99352014-10-03 00:41:58 +00002830 DictScope Import(W, "DelayImport");
2831 StringRef Name;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002832 error(I.getName(Name));
Rui Ueyama15d99352014-10-03 00:41:58 +00002833 W.printString("Name", Name);
Rui Ueyama1af08652014-10-03 18:07:18 +00002834 const delay_import_directory_table_entry *Table;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002835 error(I.getDelayImportTable(Table));
Rui Ueyama1af08652014-10-03 18:07:18 +00002836 W.printHex("Attributes", Table->Attributes);
2837 W.printHex("ModuleHandle", Table->ModuleHandle);
2838 W.printHex("ImportAddressTable", Table->DelayImportAddressTable);
2839 W.printHex("ImportNameTable", Table->DelayImportNameTable);
2840 W.printHex("BoundDelayImportTable", Table->BoundDelayImportTable);
2841 W.printHex("UnloadDelayImportTable", Table->UnloadDelayImportTable);
Rui Ueyamaffa4ceb2014-11-13 03:22:54 +00002842 printDelayImportedSymbols(I, I.imported_symbols());
Rui Ueyama1e152d52014-10-02 17:02:18 +00002843 }
2844}
Saleem Abdulrasoolf9578632014-10-07 19:37:52 +00002845
Saleem Abdulrasoolddd92642015-01-03 21:35:09 +00002846void COFFDumper::printCOFFExports() {
2847 for (const ExportDirectoryEntryRef &E : Obj->export_directories()) {
2848 DictScope Export(W, "Export");
2849
2850 StringRef Name;
2851 uint32_t Ordinal, RVA;
2852
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002853 error(E.getSymbolName(Name));
2854 error(E.getOrdinal(Ordinal));
2855 error(E.getExportRVA(RVA));
Saleem Abdulrasoolddd92642015-01-03 21:35:09 +00002856
2857 W.printNumber("Ordinal", Ordinal);
2858 W.printString("Name", Name);
2859 W.printHex("RVA", RVA);
2860 }
2861}
2862
Saleem Abdulrasoolf9578632014-10-07 19:37:52 +00002863void COFFDumper::printCOFFDirectives() {
2864 for (const SectionRef &Section : Obj->sections()) {
2865 StringRef Contents;
2866 StringRef Name;
2867
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002868 error(Section.getName(Name));
Saleem Abdulrasoolf9578632014-10-07 19:37:52 +00002869 if (Name != ".drectve")
2870 continue;
2871
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002872 error(Section.getContents(Contents));
Saleem Abdulrasoolf9578632014-10-07 19:37:52 +00002873
2874 W.printString("Directive(s)", Contents);
2875 }
2876}
Rui Ueyama74e85132014-11-19 00:18:07 +00002877
2878static StringRef getBaseRelocTypeName(uint8_t Type) {
2879 switch (Type) {
2880 case COFF::IMAGE_REL_BASED_ABSOLUTE: return "ABSOLUTE";
2881 case COFF::IMAGE_REL_BASED_HIGH: return "HIGH";
2882 case COFF::IMAGE_REL_BASED_LOW: return "LOW";
2883 case COFF::IMAGE_REL_BASED_HIGHLOW: return "HIGHLOW";
2884 case COFF::IMAGE_REL_BASED_HIGHADJ: return "HIGHADJ";
Saleem Abdulrasool5a41c372015-01-16 20:16:09 +00002885 case COFF::IMAGE_REL_BASED_ARM_MOV32T: return "ARM_MOV32(T)";
Rui Ueyama74e85132014-11-19 00:18:07 +00002886 case COFF::IMAGE_REL_BASED_DIR64: return "DIR64";
Colin LeMahieu9fbffee2014-11-19 17:10:39 +00002887 default: return "unknown (" + llvm::utostr(Type) + ")";
Rui Ueyama74e85132014-11-19 00:18:07 +00002888 }
2889}
2890
2891void COFFDumper::printCOFFBaseReloc() {
2892 ListScope D(W, "BaseReloc");
2893 for (const BaseRelocRef &I : Obj->base_relocs()) {
2894 uint8_t Type;
2895 uint32_t RVA;
Rafael Espindolafb3acd62015-07-20 03:23:55 +00002896 error(I.getRVA(RVA));
2897 error(I.getType(Type));
Rui Ueyama74e85132014-11-19 00:18:07 +00002898 DictScope Import(W, "Entry");
2899 W.printString("Type", getBaseRelocTypeName(Type));
2900 W.printHex("Address", RVA);
2901 }
2902}
Lang Hames0000afd2015-06-26 23:56:53 +00002903
2904void COFFDumper::printStackMap() const {
2905 object::SectionRef StackMapSection;
2906 for (auto Sec : Obj->sections()) {
2907 StringRef Name;
2908 Sec.getName(Name);
2909 if (Name == ".llvm_stackmaps") {
2910 StackMapSection = Sec;
2911 break;
2912 }
2913 }
2914
2915 if (StackMapSection == object::SectionRef())
2916 return;
2917
2918 StringRef StackMapContents;
2919 StackMapSection.getContents(StackMapContents);
2920 ArrayRef<uint8_t> StackMapContentsArray(
2921 reinterpret_cast<const uint8_t*>(StackMapContents.data()),
2922 StackMapContents.size());
2923
2924 if (Obj->isLittleEndian())
2925 prettyPrintStackMap(
2926 llvm::outs(),
2927 StackMapV1Parser<support::little>(StackMapContentsArray));
2928 else
2929 prettyPrintStackMap(llvm::outs(),
2930 StackMapV1Parser<support::big>(StackMapContentsArray));
2931}