COFFDumper.cpp

//===-- COFFDumper.cpp - COFF-specific dumper -------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file implements the COFF-specific dumper for llvm-readobj.
///
//===----------------------------------------------------------------------===//

#include"ARMWinEHPrinter.h"
#include"ObjDumper.h"
#include"StackMapPrinter.h"
#include"Win64EHDumper.h"
#include"llvm-readobj.h"
#include"llvm/ADT/DenseMap.h"
#include"llvm/ADT/SmallString.h"
#include"llvm/ADT/StringExtras.h"
#include"llvm/BinaryFormat/COFF.h"
#include"llvm/DebugInfo/CodeView/CVTypeVisitor.h"
#include"llvm/DebugInfo/CodeView/CodeView.h"
#include"llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
#include"llvm/DebugInfo/CodeView/DebugFrameDataSubsection.h"
#include"llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
#include"llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
#include"llvm/DebugInfo/CodeView/DebugStringTableSubsection.h"
#include"llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
#include"llvm/DebugInfo/CodeView/Line.h"
#include"llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
#include"llvm/DebugInfo/CodeView/RecordSerialization.h"
#include"llvm/DebugInfo/CodeView/SymbolDumpDelegate.h"
#include"llvm/DebugInfo/CodeView/SymbolDumper.h"
#include"llvm/DebugInfo/CodeView/SymbolRecord.h"
#include"llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
#include"llvm/DebugInfo/CodeView/TypeHashing.h"
#include"llvm/DebugInfo/CodeView/TypeIndex.h"
#include"llvm/DebugInfo/CodeView/TypeRecord.h"
#include"llvm/DebugInfo/CodeView/TypeStreamMerger.h"
#include"llvm/DebugInfo/CodeView/TypeTableCollection.h"
#include"llvm/Object/COFF.h"
#include"llvm/Object/ObjectFile.h"
#include"llvm/Object/WindowsResource.h"
#include"llvm/Support/BinaryStreamReader.h"
#include"llvm/Support/Casting.h"
#include"llvm/Support/Compiler.h"
#include"llvm/Support/ConvertUTF.h"
#include"llvm/Support/FormatVariadic.h"
#include"llvm/Support/LEB128.h"
#include"llvm/Support/ScopedPrinter.h"
#include"llvm/Support/Win64EH.h"
#include"llvm/Support/raw_ostream.h"
#include<ctime>

usingnamespacellvm;
usingnamespacellvm::object;
usingnamespacellvm::codeview;
usingnamespacellvm::support;
usingnamespacellvm::Win64EH;

namespace {

structLoadConfigTables {
uint64_t SEHTableVA = 0;
uint64_t SEHTableCount = 0;
uint32_t GuardFlags = 0;
uint64_t GuardFidTableVA = 0;
uint64_t GuardFidTableCount = 0;
uint64_t GuardIatTableVA = 0;
uint64_t GuardIatTableCount = 0;
uint64_t GuardLJmpTableVA = 0;
uint64_t GuardLJmpTableCount = 0;
uint64_t GuardEHContTableVA = 0;
uint64_t GuardEHContTableCount = 0;
};

classCOFFDumper : publicObjDumper {
public:
friendclassCOFFObjectDumpDelegate;
COFFDumper(const llvm::object::COFFObjectFile *Obj, ScopedPrinter &Writer)
 : ObjDumper(Writer, Obj->getFileName()), Obj(Obj), Writer(Writer),
 Types(100) {}

voidprintFileHeaders() override;
voidprintSectionHeaders() override;
voidprintRelocations() override;
voidprintUnwindInfo() override;

voidprintNeededLibraries() override;

voidprintCOFFImports() override;
voidprintCOFFExports() override;
voidprintCOFFDirectives() override;
voidprintCOFFBaseReloc() override;
voidprintCOFFDebugDirectory() override;
voidprintCOFFTLSDirectory() override;
voidprintCOFFResources() override;
voidprintCOFFLoadConfig() override;
voidprintCodeViewDebugInfo() override;
voidmergeCodeViewTypes(llvm::codeview::MergingTypeTableBuilder &CVIDs,
 llvm::codeview::MergingTypeTableBuilder &CVTypes,
 llvm::codeview::GlobalTypeTableBuilder &GlobalCVIDs,
 llvm::codeview::GlobalTypeTableBuilder &GlobalCVTypes,
bool GHash) override;
voidprintStackMap() constoverride;
voidprintAddrsig() override;
voidprintCGProfile() override;

private:
 StringRef getSymbolName(uint32_t Index);
voidprintSymbols() override;
voidprintDynamicSymbols() override;
voidprintSymbol(const SymbolRef &Sym);
voidprintRelocation(const SectionRef &Section, const RelocationRef &Reloc,
uint64_t Bias = 0);
voidprintDataDirectory(uint32_t Index, const std::string &FieldName);

voidprintDOSHeader(const dos_header *DH);
template <classPEHeader> voidprintPEHeader(const PEHeader *Hdr);
voidprintBaseOfDataField(const pe32_header *Hdr);
voidprintBaseOfDataField(const pe32plus_header *Hdr);
template <typename T>
voidprintCOFFLoadConfig(const T *Conf, LoadConfigTables &Tables);
template <typename IntTy>
voidprintCOFFTLSDirectory(const coff_tls_directory<IntTy> *TlsTable);
typedefvoid (*PrintExtraCB)(raw_ostream &, constuint8_t *);
voidprintRVATable(uint64_t TableVA, uint64_t Count, uint64_t EntrySize,
 PrintExtraCB PrintExtra = nullptr);

voidprintCodeViewSymbolSection(StringRef SectionName, const SectionRef &Section);
voidprintCodeViewTypeSection(StringRef SectionName, const SectionRef &Section);
 StringRef getFileNameForFileOffset(uint32_t FileOffset);
voidprintFileNameForOffset(StringRef Label, uint32_t FileOffset);
voidprintTypeIndex(StringRef FieldName, TypeIndex TI) {
// Forward to CVTypeDumper for simplicity.
codeview::printTypeIndex(Writer, FieldName, TI, Types);
 }

voidprintCodeViewSymbolsSubsection(StringRef Subsection,
const SectionRef &Section,
 StringRef SectionContents);

voidprintCodeViewFileChecksums(StringRef Subsection);

voidprintCodeViewInlineeLines(StringRef Subsection);

voidprintRelocatedField(StringRef Label, const coff_section *Sec,
uint32_t RelocOffset, uint32_t Offset,
 StringRef *RelocSym = nullptr);

uint32_tcountTotalTableEntries(ResourceSectionRef RSF,
const coff_resource_dir_table &Table,
 StringRef Level);

voidprintResourceDirectoryTable(ResourceSectionRef RSF,
const coff_resource_dir_table &Table,
 StringRef Level);

voidprintBinaryBlockWithRelocs(StringRef Label, const SectionRef &Sec,
 StringRef SectionContents, StringRef Block);

/// Given a .debug$S section, find the string table and file checksum table.
voidinitializeFileAndStringTables(BinaryStreamReader &Reader);

voidcacheRelocations();

 std::error_code resolveSymbol(const coff_section *Section, uint64_t Offset,
 SymbolRef &Sym);
 std::error_code resolveSymbolName(const coff_section *Section,
uint64_t Offset, StringRef &Name);
 std::error_code resolveSymbolName(const coff_section *Section,
 StringRef SectionContents,
constvoid *RelocPtr, StringRef &Name);
voidprintImportedSymbols(iterator_range<imported_symbol_iterator> Range);
voidprintDelayImportedSymbols(
const DelayImportDirectoryEntryRef &I,
 iterator_range<imported_symbol_iterator> Range);

typedef DenseMap<const coff_section*, std::vector<RelocationRef> > RelocMapTy;

const llvm::object::COFFObjectFile *Obj;
bool RelocCached = false;
 RelocMapTy RelocMap;

 DebugChecksumsSubsectionRef CVFileChecksumTable;

 DebugStringTableSubsectionRef CVStringTable;

/// Track the compilation CPU type. S_COMPILE3 symbol records typically come
/// first, but if we don't see one, just assume an X64 CPU type. It is common.
 CPUType CompilationCPUType = CPUType::X64;

 ScopedPrinter &Writer;
 LazyRandomTypeCollection Types;
};

classCOFFObjectDumpDelegate : publicSymbolDumpDelegate {
public:
COFFObjectDumpDelegate(COFFDumper &CD, const SectionRef &SR,
const COFFObjectFile *Obj, StringRef SectionContents)
 : CD(CD), SR(SR), SectionContents(SectionContents) {
 Sec = Obj->getCOFFSection(SR);
 }

uint32_tgetRecordOffset(BinaryStreamReader Reader) override {
 ArrayRef<uint8_t> Data;
if (auto EC = Reader.readLongestContiguousChunk(Data)) {
llvm::consumeError(std::move(EC));
return0;
 }
return Data.data() - SectionContents.bytes_begin();
 }

voidprintRelocatedField(StringRef Label, uint32_t RelocOffset,
uint32_t Offset, StringRef *RelocSym) override {
 CD.printRelocatedField(Label, Sec, RelocOffset, Offset, RelocSym);
 }

voidprintBinaryBlockWithRelocs(StringRef Label,
 ArrayRef<uint8_t> Block) override {
 StringRef SBlock(reinterpret_cast<constchar *>(Block.data()),
 Block.size());
if (opts::CodeViewSubsectionBytes)
 CD.printBinaryBlockWithRelocs(Label, SR, SectionContents, SBlock);
 }

 StringRef getFileNameForFileOffset(uint32_t FileOffset) override {
return CD.getFileNameForFileOffset(FileOffset);
 }

 DebugStringTableSubsectionRef getStringTable() override {
return CD.CVStringTable;
 }

private:
 COFFDumper &CD;
const SectionRef &SR;
const coff_section *Sec;
 StringRef SectionContents;
};

} // end namespace

namespacellvm {

std::unique_ptr<ObjDumper> createCOFFDumper(const object::COFFObjectFile &Obj,
 ScopedPrinter &Writer) {
return std::make_unique<COFFDumper>(&Obj, Writer);
}

} // namespace llvm

// Given a section and an offset into this section the function returns the
// symbol used for the relocation at the offset.
std::error_code COFFDumper::resolveSymbol(const coff_section *Section,
uint64_t Offset, SymbolRef &Sym) {
cacheRelocations();
constauto &Relocations = RelocMap[Section];
auto SymI = Obj->symbol_end();
for (constauto &Relocation : Relocations) {
uint64_t RelocationOffset = Relocation.getOffset();

if (RelocationOffset == Offset) {
 SymI = Relocation.getSymbol();
break;
 }
 }
if (SymI == Obj->symbol_end())
returninconvertibleErrorCode();
 Sym = *SymI;
returnstd::error_code();
}

// Given a section and an offset into this section the function returns the name
// of the symbol used for the relocation at the offset.
std::error_code COFFDumper::resolveSymbolName(const coff_section *Section,
uint64_t Offset,
 StringRef &Name) {
 SymbolRef Symbol;
if (std::error_code EC = resolveSymbol(Section, Offset, Symbol))
return EC;
 Expected<StringRef> NameOrErr = Symbol.getName();
if (!NameOrErr)
returnerrorToErrorCode(NameOrErr.takeError());
 Name = *NameOrErr;
returnstd::error_code();
}

// Helper for when you have a pointer to real data and you want to know about
// relocations against it.
std::error_code COFFDumper::resolveSymbolName(const coff_section *Section,
 StringRef SectionContents,
constvoid *RelocPtr,
 StringRef &Name) {
assert(SectionContents.data() < RelocPtr &&
 RelocPtr < SectionContents.data() + SectionContents.size() &&
"pointer to relocated object is not in section");
uint64_t Offset = ptrdiff_t(reinterpret_cast<constchar *>(RelocPtr) -
 SectionContents.data());
returnresolveSymbolName(Section, Offset, Name);
}

voidCOFFDumper::printRelocatedField(StringRef Label, const coff_section *Sec,
uint32_t RelocOffset, uint32_t Offset,
 StringRef *RelocSym) {
 StringRef SymStorage;
 StringRef &Symbol = RelocSym ? *RelocSym : SymStorage;
if (!resolveSymbolName(Sec, RelocOffset, Symbol))
 W.printSymbolOffset(Label, Symbol, Offset);
else
 W.printHex(Label, RelocOffset);
}

voidCOFFDumper::printBinaryBlockWithRelocs(StringRef Label,
const SectionRef &Sec,
 StringRef SectionContents,
 StringRef Block) {
 W.printBinaryBlock(Label, Block);

assert(SectionContents.begin() < Block.begin() &&
 SectionContents.end() >= Block.end() &&
"Block is not contained in SectionContents");
uint64_t OffsetStart = Block.data() - SectionContents.data();
uint64_t OffsetEnd = OffsetStart + Block.size();

 W.flush();
cacheRelocations();
 ListScope D(W, "BlockRelocations");
const coff_section *Section = Obj->getCOFFSection(Sec);
constauto &Relocations = RelocMap[Section];
for (constauto &Relocation : Relocations) {
uint64_t RelocationOffset = Relocation.getOffset();
if (OffsetStart <= RelocationOffset && RelocationOffset < OffsetEnd)
printRelocation(Sec, Relocation, OffsetStart);
 }
}

const EnumEntry<COFF::MachineTypes> ImageFileMachineType[] = {
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_UNKNOWN ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_AM33 ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_AMD64 ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM64 ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM64EC ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARMNT ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_EBC ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_I386 ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_IA64 ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_M32R ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPS16 ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPSFPU ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPSFPU16),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_POWERPC ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_POWERPCFP),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_R4000 ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH3 ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH3DSP ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH4 ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH5 ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_THUMB ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_WCEMIPSV2)
};

const EnumEntry<COFF::Characteristics> ImageFileCharacteristics[] = {
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_RELOCS_STRIPPED ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_EXECUTABLE_IMAGE ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LINE_NUMS_STRIPPED ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LOCAL_SYMS_STRIPPED ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_AGGRESSIVE_WS_TRIM ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LARGE_ADDRESS_AWARE ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_LO ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_32BIT_MACHINE ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_DEBUG_STRIPPED ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_NET_RUN_FROM_SWAP ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_SYSTEM ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_DLL ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_UP_SYSTEM_ONLY ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_HI )
};

const EnumEntry<COFF::WindowsSubsystem> PEWindowsSubsystem[] = {
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_UNKNOWN ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_NATIVE ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_GUI ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_CUI ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_POSIX_CUI ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_APPLICATION ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_ROM ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_XBOX ),
};

const EnumEntry<COFF::DLLCharacteristics> PEDLLCharacteristics[] = {
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NX_COMPAT ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_ISOLATION ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_SEH ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_BIND ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_APPCONTAINER ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_WDM_DRIVER ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_GUARD_CF ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE),
};

staticconst EnumEntry<COFF::ExtendedDLLCharacteristics>
 PEExtendedDLLCharacteristics[] = {
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_EX_CET_COMPAT),
};

staticconst EnumEntry<COFF::SectionCharacteristics>
ImageSectionCharacteristics[] = {
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NOLOAD ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NO_PAD ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_CODE ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_INITIALIZED_DATA ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_UNINITIALIZED_DATA),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_OTHER ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_INFO ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_REMOVE ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_COMDAT ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_GPREL ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_PURGEABLE ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_16BIT ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_LOCKED ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_PRELOAD ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_16BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_32BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_64BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_128BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_256BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_512BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1024BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2048BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4096BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8192BYTES ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_NRELOC_OVFL ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_DISCARDABLE ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_CACHED ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_PAGED ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_SHARED ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_EXECUTE ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_READ ),
LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_WRITE )
};

const EnumEntry<COFF::SymbolBaseType> ImageSymType[] = {
 { "Null" , COFF::IMAGE_SYM_TYPE_NULL },
 { "Void" , COFF::IMAGE_SYM_TYPE_VOID },
 { "Char" , COFF::IMAGE_SYM_TYPE_CHAR },
 { "Short" , COFF::IMAGE_SYM_TYPE_SHORT },
 { "Int" , COFF::IMAGE_SYM_TYPE_INT },
 { "Long" , COFF::IMAGE_SYM_TYPE_LONG },
 { "Float" , COFF::IMAGE_SYM_TYPE_FLOAT },
 { "Double", COFF::IMAGE_SYM_TYPE_DOUBLE },
 { "Struct", COFF::IMAGE_SYM_TYPE_STRUCT },
 { "Union" , COFF::IMAGE_SYM_TYPE_UNION },
 { "Enum" , COFF::IMAGE_SYM_TYPE_ENUM },
 { "MOE" , COFF::IMAGE_SYM_TYPE_MOE },
 { "Byte" , COFF::IMAGE_SYM_TYPE_BYTE },
 { "Word" , COFF::IMAGE_SYM_TYPE_WORD },
 { "UInt" , COFF::IMAGE_SYM_TYPE_UINT },
 { "DWord" , COFF::IMAGE_SYM_TYPE_DWORD }
};

const EnumEntry<COFF::SymbolComplexType> ImageSymDType[] = {
 { "Null" , COFF::IMAGE_SYM_DTYPE_NULL },
 { "Pointer" , COFF::IMAGE_SYM_DTYPE_POINTER },
 { "Function", COFF::IMAGE_SYM_DTYPE_FUNCTION },
 { "Array" , COFF::IMAGE_SYM_DTYPE_ARRAY }
};

const EnumEntry<COFF::SymbolStorageClass> ImageSymClass[] = {
 { "EndOfFunction" , COFF::IMAGE_SYM_CLASS_END_OF_FUNCTION },
 { "Null" , COFF::IMAGE_SYM_CLASS_NULL },
 { "Automatic" , COFF::IMAGE_SYM_CLASS_AUTOMATIC },
 { "External" , COFF::IMAGE_SYM_CLASS_EXTERNAL },
 { "Static" , COFF::IMAGE_SYM_CLASS_STATIC },
 { "Register" , COFF::IMAGE_SYM_CLASS_REGISTER },
 { "ExternalDef" , COFF::IMAGE_SYM_CLASS_EXTERNAL_DEF },
 { "Label" , COFF::IMAGE_SYM_CLASS_LABEL },
 { "UndefinedLabel" , COFF::IMAGE_SYM_CLASS_UNDEFINED_LABEL },
 { "MemberOfStruct" , COFF::IMAGE_SYM_CLASS_MEMBER_OF_STRUCT },
 { "Argument" , COFF::IMAGE_SYM_CLASS_ARGUMENT },
 { "StructTag" , COFF::IMAGE_SYM_CLASS_STRUCT_TAG },
 { "MemberOfUnion" , COFF::IMAGE_SYM_CLASS_MEMBER_OF_UNION },
 { "UnionTag" , COFF::IMAGE_SYM_CLASS_UNION_TAG },
 { "TypeDefinition" , COFF::IMAGE_SYM_CLASS_TYPE_DEFINITION },
 { "UndefinedStatic", COFF::IMAGE_SYM_CLASS_UNDEFINED_STATIC },
 { "EnumTag" , COFF::IMAGE_SYM_CLASS_ENUM_TAG },
 { "MemberOfEnum" , COFF::IMAGE_SYM_CLASS_MEMBER_OF_ENUM },
 { "RegisterParam" , COFF::IMAGE_SYM_CLASS_REGISTER_PARAM },
 { "BitField" , COFF::IMAGE_SYM_CLASS_BIT_FIELD },
 { "Block" , COFF::IMAGE_SYM_CLASS_BLOCK },
 { "Function" , COFF::IMAGE_SYM_CLASS_FUNCTION },
 { "EndOfStruct" , COFF::IMAGE_SYM_CLASS_END_OF_STRUCT },
 { "File" , COFF::IMAGE_SYM_CLASS_FILE },
 { "Section" , COFF::IMAGE_SYM_CLASS_SECTION },
 { "WeakExternal" , COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL },
 { "CLRToken" , COFF::IMAGE_SYM_CLASS_CLR_TOKEN }
};

const EnumEntry<COFF::COMDATType> ImageCOMDATSelect[] = {
 { "NoDuplicates", COFF::IMAGE_COMDAT_SELECT_NODUPLICATES },
 { "Any" , COFF::IMAGE_COMDAT_SELECT_ANY },
 { "SameSize" , COFF::IMAGE_COMDAT_SELECT_SAME_SIZE },
 { "ExactMatch" , COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH },
 { "Associative" , COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE },
 { "Largest" , COFF::IMAGE_COMDAT_SELECT_LARGEST },
 { "Newest" , COFF::IMAGE_COMDAT_SELECT_NEWEST }
};

const EnumEntry<COFF::DebugType> ImageDebugType[] = {
 {"Unknown", COFF::IMAGE_DEBUG_TYPE_UNKNOWN},
 {"COFF", COFF::IMAGE_DEBUG_TYPE_COFF},
 {"CodeView", COFF::IMAGE_DEBUG_TYPE_CODEVIEW},
 {"FPO", COFF::IMAGE_DEBUG_TYPE_FPO},
 {"Misc", COFF::IMAGE_DEBUG_TYPE_MISC},
 {"Exception", COFF::IMAGE_DEBUG_TYPE_EXCEPTION},
 {"Fixup", COFF::IMAGE_DEBUG_TYPE_FIXUP},
 {"OmapToSrc", COFF::IMAGE_DEBUG_TYPE_OMAP_TO_SRC},
 {"OmapFromSrc", COFF::IMAGE_DEBUG_TYPE_OMAP_FROM_SRC},
 {"Borland", COFF::IMAGE_DEBUG_TYPE_BORLAND},
 {"Reserved10", COFF::IMAGE_DEBUG_TYPE_RESERVED10},
 {"CLSID", COFF::IMAGE_DEBUG_TYPE_CLSID},
 {"VCFeature", COFF::IMAGE_DEBUG_TYPE_VC_FEATURE},
 {"POGO", COFF::IMAGE_DEBUG_TYPE_POGO},
 {"ILTCG", COFF::IMAGE_DEBUG_TYPE_ILTCG},
 {"MPX", COFF::IMAGE_DEBUG_TYPE_MPX},
 {"Repro", COFF::IMAGE_DEBUG_TYPE_REPRO},
 {"ExtendedDLLCharacteristics",
 COFF::IMAGE_DEBUG_TYPE_EX_DLLCHARACTERISTICS},
};

staticconst EnumEntry<COFF::WeakExternalCharacteristics>
WeakExternalCharacteristics[] = {
 { "NoLibrary", COFF::IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY },
 { "Library" , COFF::IMAGE_WEAK_EXTERN_SEARCH_LIBRARY },
 { "Alias" , COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS }
};

const EnumEntry<uint32_t> SubSectionTypes[] = {
LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, Symbols),
LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, Lines),
LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, StringTable),
LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, FileChecksums),
LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, FrameData),
LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, InlineeLines),
LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, CrossScopeImports),
LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, CrossScopeExports),
LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, ILLines),
LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, FuncMDTokenMap),
LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, TypeMDTokenMap),
LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, MergedAssemblyInput),
LLVM_READOBJ_ENUM_CLASS_ENT(DebugSubsectionKind, CoffSymbolRVA),
};

const EnumEntry<uint32_t> FrameDataFlags[] = {
LLVM_READOBJ_ENUM_ENT(FrameData, HasSEH),
LLVM_READOBJ_ENUM_ENT(FrameData, HasEH),
LLVM_READOBJ_ENUM_ENT(FrameData, IsFunctionStart),
};

const EnumEntry<uint8_t> FileChecksumKindNames[] = {
LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, None),
LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, MD5),
LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, SHA1),
LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, SHA256),
};

const EnumEntry<uint32_t> PELoadConfigGuardFlags[] = {
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, CF_INSTRUMENTED),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, CFW_INSTRUMENTED),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, CF_FUNCTION_TABLE_PRESENT),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, SECURITY_COOKIE_UNUSED),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, PROTECT_DELAYLOAD_IAT),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 DELAYLOAD_IAT_IN_ITS_OWN_SECTION),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_EXPORT_SUPPRESSION_INFO_PRESENT),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, CF_ENABLE_EXPORT_SUPPRESSION),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags, CF_LONGJUMP_TABLE_PRESENT),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 EH_CONTINUATION_TABLE_PRESENT),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_5BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_6BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_7BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_8BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_9BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_10BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_11BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_12BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_13BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_14BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_15BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_16BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_17BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_18BYTES),
LLVM_READOBJ_ENUM_CLASS_ENT(COFF::GuardFlags,
 CF_FUNCTION_TABLE_SIZE_19BYTES),
};

template <typename T>
static std::error_code getSymbolAuxData(const COFFObjectFile *Obj,
 COFFSymbolRef Symbol,
uint8_t AuxSymbolIdx, const T *&Aux) {
 ArrayRef<uint8_t> AuxData = Obj->getSymbolAuxData(Symbol);
 AuxData = AuxData.slice(AuxSymbolIdx * Obj->getSymbolTableEntrySize());
 Aux = reinterpret_cast<const T*>(AuxData.data());
returnstd::error_code();
}

voidCOFFDumper::cacheRelocations() {
if (RelocCached)
return;
 RelocCached = true;

for (const SectionRef &S : Obj->sections()) {
const coff_section *Section = Obj->getCOFFSection(S);

append_range(RelocMap[Section], S.relocations());

// Sort relocations by address.
llvm::sort(RelocMap[Section], [](RelocationRef L, RelocationRef R) {
return L.getOffset() < R.getOffset();
 });
 }
}

voidCOFFDumper::printDataDirectory(uint32_t Index,
const std::string &FieldName) {
const data_directory *Data = Obj->getDataDirectory(Index);
if (!Data)
return;
 W.printHex(FieldName + "RVA", Data->RelativeVirtualAddress);
 W.printHex(FieldName + "Size", Data->Size);
}

voidCOFFDumper::printFileHeaders() {
time_t TDS = Obj->getTimeDateStamp();
char FormattedTime[20] = { };
strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS));

 {
 DictScope D(W, "ImageFileHeader");
 W.printEnum ("Machine", Obj->getMachine(),
makeArrayRef(ImageFileMachineType));
 W.printNumber("SectionCount", Obj->getNumberOfSections());
 W.printHex ("TimeDateStamp", FormattedTime, Obj->getTimeDateStamp());
 W.printHex ("PointerToSymbolTable", Obj->getPointerToSymbolTable());
 W.printNumber("SymbolCount", Obj->getNumberOfSymbols());
 W.printNumber("StringTableSize", Obj->getStringTableSize());
 W.printNumber("OptionalHeaderSize", Obj->getSizeOfOptionalHeader());
 W.printFlags ("Characteristics", Obj->getCharacteristics(),
makeArrayRef(ImageFileCharacteristics));
 }

// Print PE header. This header does not exist if this is an object file and
// not an executable.
if (const pe32_header *PEHeader = Obj->getPE32Header())
 printPEHeader<pe32_header>(PEHeader);

if (const pe32plus_header *PEPlusHeader = Obj->getPE32PlusHeader())
 printPEHeader<pe32plus_header>(PEPlusHeader);

if (const dos_header *DH = Obj->getDOSHeader())
printDOSHeader(DH);
}

voidCOFFDumper::printDOSHeader(const dos_header *DH) {
 DictScope D(W, "DOSHeader");
 W.printString("Magic", StringRef(DH->Magic, sizeof(DH->Magic)));
 W.printNumber("UsedBytesInTheLastPage", DH->UsedBytesInTheLastPage);
 W.printNumber("FileSizeInPages", DH->FileSizeInPages);
 W.printNumber("NumberOfRelocationItems", DH->NumberOfRelocationItems);
 W.printNumber("HeaderSizeInParagraphs", DH->HeaderSizeInParagraphs);
 W.printNumber("MinimumExtraParagraphs", DH->MinimumExtraParagraphs);
 W.printNumber("MaximumExtraParagraphs", DH->MaximumExtraParagraphs);
 W.printNumber("InitialRelativeSS", DH->InitialRelativeSS);
 W.printNumber("InitialSP", DH->InitialSP);
 W.printNumber("Checksum", DH->Checksum);
 W.printNumber("InitialIP", DH->InitialIP);
 W.printNumber("InitialRelativeCS", DH->InitialRelativeCS);
 W.printNumber("AddressOfRelocationTable", DH->AddressOfRelocationTable);
 W.printNumber("OverlayNumber", DH->OverlayNumber);
 W.printNumber("OEMid", DH->OEMid);
 W.printNumber("OEMinfo", DH->OEMinfo);
 W.printNumber("AddressOfNewExeHeader", DH->AddressOfNewExeHeader);
}

template <classPEHeader>
voidCOFFDumper::printPEHeader(const PEHeader *Hdr) {
 DictScope D(W, "ImageOptionalHeader");
 W.printHex ("Magic", Hdr->Magic);
 W.printNumber("MajorLinkerVersion", Hdr->MajorLinkerVersion);
 W.printNumber("MinorLinkerVersion", Hdr->MinorLinkerVersion);
 W.printNumber("SizeOfCode", Hdr->SizeOfCode);
 W.printNumber("SizeOfInitializedData", Hdr->SizeOfInitializedData);
 W.printNumber("SizeOfUninitializedData", Hdr->SizeOfUninitializedData);
 W.printHex ("AddressOfEntryPoint", Hdr->AddressOfEntryPoint);
 W.printHex ("BaseOfCode", Hdr->BaseOfCode);
printBaseOfDataField(Hdr);
 W.printHex ("ImageBase", Hdr->ImageBase);
 W.printNumber("SectionAlignment", Hdr->SectionAlignment);
 W.printNumber("FileAlignment", Hdr->FileAlignment);
 W.printNumber("MajorOperatingSystemVersion",
 Hdr->MajorOperatingSystemVersion);
 W.printNumber("MinorOperatingSystemVersion",
 Hdr->MinorOperatingSystemVersion);
 W.printNumber("MajorImageVersion", Hdr->MajorImageVersion);
 W.printNumber("MinorImageVersion", Hdr->MinorImageVersion);
 W.printNumber("MajorSubsystemVersion", Hdr->MajorSubsystemVersion);
 W.printNumber("MinorSubsystemVersion", Hdr->MinorSubsystemVersion);
 W.printNumber("SizeOfImage", Hdr->SizeOfImage);
 W.printNumber("SizeOfHeaders", Hdr->SizeOfHeaders);
 W.printEnum ("Subsystem", Hdr->Subsystem, makeArrayRef(PEWindowsSubsystem));
 W.printFlags ("Characteristics", Hdr->DLLCharacteristics,
makeArrayRef(PEDLLCharacteristics));
 W.printNumber("SizeOfStackReserve", Hdr->SizeOfStackReserve);
 W.printNumber("SizeOfStackCommit", Hdr->SizeOfStackCommit);
 W.printNumber("SizeOfHeapReserve", Hdr->SizeOfHeapReserve);
 W.printNumber("SizeOfHeapCommit", Hdr->SizeOfHeapCommit);
 W.printNumber("NumberOfRvaAndSize", Hdr->NumberOfRvaAndSize);

if (Hdr->NumberOfRvaAndSize > 0) {
 DictScope D(W, "DataDirectory");
staticconstchar * const directory[] = {
"ExportTable", "ImportTable", "ResourceTable", "ExceptionTable",
"CertificateTable", "BaseRelocationTable", "Debug", "Architecture",
"GlobalPtr", "TLSTable", "LoadConfigTable", "BoundImport", "IAT",
"DelayImportDescriptor", "CLRRuntimeHeader", "Reserved"
 };

for (uint32_t i = 0; i < Hdr->NumberOfRvaAndSize; ++i)
if (i < sizeof(directory) / sizeof(char *))
printDataDirectory(i, directory[i]);
else
printDataDirectory(i, "Unknown");
 }
}

voidCOFFDumper::printCOFFDebugDirectory() {
 ListScope LS(W, "DebugDirectory");
for (const debug_directory &D : Obj->debug_directories()) {
char FormattedTime[20] = {};
time_t TDS = D.TimeDateStamp;
strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS));
 DictScope S(W, "DebugEntry");
 W.printHex("Characteristics", D.Characteristics);
 W.printHex("TimeDateStamp", FormattedTime, D.TimeDateStamp);
 W.printHex("MajorVersion", D.MajorVersion);
 W.printHex("MinorVersion", D.MinorVersion);
 W.printEnum("Type", D.Type, makeArrayRef(ImageDebugType));
 W.printHex("SizeOfData", D.SizeOfData);
 W.printHex("AddressOfRawData", D.AddressOfRawData);
 W.printHex("PointerToRawData", D.PointerToRawData);
// Ideally, if D.AddressOfRawData == 0, we should try to load the payload
// using D.PointerToRawData instead.
if (D.AddressOfRawData == 0)
continue;
if (D.Type == COFF::IMAGE_DEBUG_TYPE_CODEVIEW) {
const codeview::DebugInfo *DebugInfo;
 StringRef PDBFileName;
if (Error E = Obj->getDebugPDBInfo(&D, DebugInfo, PDBFileName))
reportError(std::move(E), Obj->getFileName());

 DictScope PDBScope(W, "PDBInfo");
 W.printHex("PDBSignature", DebugInfo->Signature.CVSignature);
if (DebugInfo->Signature.CVSignature == OMF::Signature::PDB70) {
 W.printBinary("PDBGUID", makeArrayRef(DebugInfo->PDB70.Signature));
 W.printNumber("PDBAge", DebugInfo->PDB70.Age);
 W.printString("PDBFileName", PDBFileName);
 }
 } elseif (D.SizeOfData != 0) {
// FIXME: Data visualization for IMAGE_DEBUG_TYPE_VC_FEATURE and
// IMAGE_DEBUG_TYPE_POGO?
 ArrayRef<uint8_t> RawData;
if (Error E = Obj->getRvaAndSizeAsBytes(D.AddressOfRawData,
 D.SizeOfData, RawData))
reportError(std::move(E), Obj->getFileName());
if (D.Type == COFF::IMAGE_DEBUG_TYPE_EX_DLLCHARACTERISTICS) {
// FIXME right now the only possible value would fit in 8 bits,
// but that might change in the future
uint16_t Characteristics = RawData[0];
 W.printFlags("ExtendedCharacteristics", Characteristics,
makeArrayRef(PEExtendedDLLCharacteristics));
 }
 W.printBinaryBlock("RawData", RawData);
 }
 }
}

voidCOFFDumper::printRVATable(uint64_t TableVA, uint64_t Count,
uint64_t EntrySize, PrintExtraCB PrintExtra) {
uintptr_t TableStart, TableEnd;
if (Error E = Obj->getVaPtr(TableVA, TableStart))
reportError(std::move(E), Obj->getFileName());
if (Error E =
 Obj->getVaPtr(TableVA + Count * EntrySize - 1, TableEnd))
reportError(std::move(E), Obj->getFileName());
 TableEnd++;
for (uintptr_t I = TableStart; I < TableEnd; I += EntrySize) {
uint32_t RVA = *reinterpret_cast<constulittle32_t *>(I);
 raw_ostream &OS = W.startLine();
 OS << W.hex(Obj->getImageBase() + RVA);
if (PrintExtra)
PrintExtra(OS, reinterpret_cast<constuint8_t *>(I));
 OS << '\n';
 }
}

voidCOFFDumper::printCOFFLoadConfig() {
 LoadConfigTables Tables;
if (Obj->is64())
printCOFFLoadConfig(Obj->getLoadConfig64(), Tables);
else
printCOFFLoadConfig(Obj->getLoadConfig32(), Tables);

if (auto CHPE = Obj->getCHPEMetadata()) {
 ListScope LS(W, "CHPEMetadata");
 W.printHex("Version", CHPE->Version);

if (CHPE->CodeMapCount) {
 ListScope CMLS(W, "CodeMap");

uintptr_t CodeMapInt;
if (Error E = Obj->getRvaPtr(CHPE->CodeMap, CodeMapInt))
reportError(std::move(E), Obj->getFileName());
auto CodeMap = reinterpret_cast<const chpe_range_entry *>(CodeMapInt);
for (uint32_t i = 0; i < CHPE->CodeMapCount; i++) {
uint32_t Start = CodeMap[i].StartOffset & ~3;
 W.startLine() << W.hex(Start) << " - "
 << W.hex(Start + CodeMap[i].Length) << "";
switch (CodeMap[i].StartOffset & 3) {
case CHPE_RANGE_ARM64:
 W.getOStream() << "ARM64\n";
break;
case CHPE_RANGE_ARM64EC:
 W.getOStream() << "ARM64EC\n";
break;
case CHPE_RANGE_AMD64:
 W.getOStream() << "X64\n";
break;
default:
 W.getOStream() << W.hex(CodeMap[i].StartOffset & 3) << "\n";
break;
 }
 }
 } else {
 W.printNumber("CodeMap", CHPE->CodeMap);
 }

if (CHPE->CodeRangesToEntryPointsCount) {
 ListScope CRLS(W, "CodeRangesToEntryPoints");

uintptr_t CodeRangesInt;
if (Error E =
 Obj->getRvaPtr(CHPE->CodeRangesToEntryPoints, CodeRangesInt))
reportError(std::move(E), Obj->getFileName());
auto CodeRanges =
reinterpret_cast<const chpe_code_range_entry *>(CodeRangesInt);
for (uint32_t i = 0; i < CHPE->CodeRangesToEntryPointsCount; i++) {
 W.startLine() << W.hex(CodeRanges[i].StartRva) << " - "
 << W.hex(CodeRanges[i].EndRva) << " -> "
 << W.hex(CodeRanges[i].EntryPoint) << "\n";
 }
 } else {
 W.printNumber("CodeRangesToEntryPoints", CHPE->CodeRangesToEntryPoints);
 }

if (CHPE->RedirectionMetadataCount) {
 ListScope RMLS(W, "RedirectionMetadata");

uintptr_t RedirMetadataInt;
if (Error E = Obj->getRvaPtr(CHPE->RedirectionMetadata, RedirMetadataInt))
reportError(std::move(E), Obj->getFileName());
auto RedirMetadata =
reinterpret_cast<const chpe_redirection_entry *>(RedirMetadataInt);
for (uint32_t i = 0; i < CHPE->RedirectionMetadataCount; i++) {
 W.startLine() << W.hex(RedirMetadata[i].Source) << " -> "
 << W.hex(RedirMetadata[i].Destination) << "\n";
 }
 } else {
 W.printNumber("RedirectionMetadata", CHPE->RedirectionMetadata);
 }

 W.printHex("__os_arm64x_dispatch_call_no_redirect",
 CHPE->__os_arm64x_dispatch_call_no_redirect);
 W.printHex("__os_arm64x_dispatch_ret", CHPE->__os_arm64x_dispatch_ret);
 W.printHex("__os_arm64x_dispatch_call", CHPE->__os_arm64x_dispatch_call);
 W.printHex("__os_arm64x_dispatch_icall", CHPE->__os_arm64x_dispatch_icall);
 W.printHex("__os_arm64x_dispatch_icall_cfg",
 CHPE->__os_arm64x_dispatch_icall_cfg);
 W.printHex("AlternateEntryPoint", CHPE->AlternateEntryPoint);
 W.printHex("AuxiliaryIAT", CHPE->AuxiliaryIAT);
 W.printHex("GetX64InformationFunctionPointer",
 CHPE->GetX64InformationFunctionPointer);
 W.printHex("SetX64InformationFunctionPointer",
 CHPE->SetX64InformationFunctionPointer);
 W.printHex("ExtraRFETable", CHPE->ExtraRFETable);
 W.printHex("ExtraRFETableSize", CHPE->ExtraRFETableSize);
 W.printHex("__os_arm64x_dispatch_fptr", CHPE->__os_arm64x_dispatch_fptr);
 W.printHex("AuxiliaryIATCopy", CHPE->AuxiliaryIATCopy);
 }

if (Tables.SEHTableVA) {
 ListScope LS(W, "SEHTable");
printRVATable(Tables.SEHTableVA, Tables.SEHTableCount, 4);
 }

auto PrintGuardFlags = [](raw_ostream &OS, constuint8_t *Entry) {
uint8_t Flags = *reinterpret_cast<constuint8_t *>(Entry + 4);
if (Flags)
 OS << " flags " << utohexstr(Flags);
 };

if (Tables.GuardFidTableVA) {
 ListScope LS(W, "GuardFidTable");
if (uint32_tSize =
 Tables.GuardFlags &
uint32_t(COFF::GuardFlags::CF_FUNCTION_TABLE_SIZE_MASK)) {
// The size mask gives the number of extra bytes in addition to the 4-byte
// RVA of each entry in the table. As of writing only a 1-byte extra flag
// has been defined.
Size = (Size >> 28) + 4;
printRVATable(Tables.GuardFidTableVA, Tables.GuardFidTableCount, Size,
 PrintGuardFlags);
 } else {
printRVATable(Tables.GuardFidTableVA, Tables.GuardFidTableCount, 4);
 }
 }

if (Tables.GuardIatTableVA) {
 ListScope LS(W, "GuardIatTable");
printRVATable(Tables.GuardIatTableVA, Tables.GuardIatTableCount, 4);
 }

if (Tables.GuardLJmpTableVA) {
 ListScope LS(W, "GuardLJmpTable");
printRVATable(Tables.GuardLJmpTableVA, Tables.GuardLJmpTableCount, 4);
 }

if (Tables.GuardEHContTableVA) {
 ListScope LS(W, "GuardEHContTable");
printRVATable(Tables.GuardEHContTableVA, Tables.GuardEHContTableCount, 5,
 PrintGuardFlags);
 }
}

template <typename T>
voidCOFFDumper::printCOFFLoadConfig(const T *Conf, LoadConfigTables &Tables) {
if (!Conf)
return;

 ListScope LS(W, "LoadConfig");
char FormattedTime[20] = {};
time_t TDS = Conf->TimeDateStamp;
strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS));
 W.printHex("Size", Conf->Size);

// Print everything before SecurityCookie. The vast majority of images today
// have all these fields.
if (Conf->Size < offsetof(T, SEHandlerTable))
return;
 W.printHex("TimeDateStamp", FormattedTime, TDS);
 W.printHex("MajorVersion", Conf->MajorVersion);
 W.printHex("MinorVersion", Conf->MinorVersion);
 W.printHex("GlobalFlagsClear", Conf->GlobalFlagsClear);
 W.printHex("GlobalFlagsSet", Conf->GlobalFlagsSet);
 W.printHex("CriticalSectionDefaultTimeout",
 Conf->CriticalSectionDefaultTimeout);
 W.printHex("DeCommitFreeBlockThreshold", Conf->DeCommitFreeBlockThreshold);
 W.printHex("DeCommitTotalFreeThreshold", Conf->DeCommitTotalFreeThreshold);
 W.printHex("LockPrefixTable", Conf->LockPrefixTable);
 W.printHex("MaximumAllocationSize", Conf->MaximumAllocationSize);
 W.printHex("VirtualMemoryThreshold", Conf->VirtualMemoryThreshold);