diff --git a/include/llvm/Object/COFF.h b/include/llvm/Object/COFF.h index 209aa76efde..ef9cfb529e7 100644 --- a/include/llvm/Object/COFF.h +++ b/include/llvm/Object/COFF.h @@ -188,7 +188,8 @@ struct coff_aux_section_definition { class COFFObjectFile : public ObjectFile { private: - const coff_file_header *Header; + const coff_file_header *COFFHeader; + const pe32_header *PE32Header; const coff_section *SectionTable; const coff_symbol *SymbolTable; const char *StringTable; @@ -272,6 +273,8 @@ public: virtual StringRef getLoadName() const; error_code getHeader(const coff_file_header *&Res) const; + error_code getCOFFHeader(const coff_file_header *&Res) const; + error_code getPE32Header(const pe32_header *&Res) const; error_code getSection(int32_t index, const coff_section *&Res) const; error_code getSymbol(uint32_t index, const coff_symbol *&Res) const; template diff --git a/lib/Object/Binary.cpp b/lib/Object/Binary.cpp index 201899ffe2e..a1497708c1e 100644 --- a/lib/Object/Binary.cpp +++ b/lib/Object/Binary.cpp @@ -84,8 +84,10 @@ error_code object::createBinary(MemoryBuffer *Source, } case sys::fs::file_magic::coff_object: case sys::fs::file_magic::pecoff_executable: { - OwningPtr ret(new COFFObjectFile(scopedSource.take(), ec)); - if (ec) return ec; + OwningPtr ret( + ObjectFile::createCOFFObjectFile(scopedSource.take())); + if (!ret) + return object_error::invalid_file_type; Result.swap(ret); return object_error::success; } diff --git a/lib/Object/COFFObjectFile.cpp b/lib/Object/COFFObjectFile.cpp index bc5958d3c47..49317e90514 100644 --- a/lib/Object/COFFObjectFile.cpp +++ b/lib/Object/COFFObjectFile.cpp @@ -58,12 +58,12 @@ const coff_symbol *COFFObjectFile::toSymb(DataRefImpl Symb) const { # ifndef NDEBUG // Verify that the symbol points to a valid entry in the symbol table. uintptr_t offset = uintptr_t(addr) - uintptr_t(base()); - if (offset < Header->PointerToSymbolTable - || offset >= Header->PointerToSymbolTable - + (Header->NumberOfSymbols * sizeof(coff_symbol))) + if (offset < COFFHeader->PointerToSymbolTable + || offset >= COFFHeader->PointerToSymbolTable + + (COFFHeader->NumberOfSymbols * sizeof(coff_symbol))) report_fatal_error("Symbol was outside of symbol table."); - assert((offset - Header->PointerToSymbolTable) % sizeof(coff_symbol) + assert((offset - COFFHeader->PointerToSymbolTable) % sizeof(coff_symbol) == 0 && "Symbol did not point to the beginning of a symbol"); # endif @@ -76,7 +76,7 @@ const coff_section *COFFObjectFile::toSec(DataRefImpl Sec) const { # ifndef NDEBUG // Verify that the section points to a valid entry in the section table. if (addr < SectionTable - || addr >= (SectionTable + Header->NumberOfSections)) + || addr >= (SectionTable + COFFHeader->NumberOfSections)) report_fatal_error("Section was outside of section table."); uintptr_t offset = uintptr_t(addr) - uintptr_t(SectionTable); @@ -430,7 +430,8 @@ relocation_iterator COFFObjectFile::getSectionRelEnd(DataRefImpl Sec) const { COFFObjectFile::COFFObjectFile(MemoryBuffer *Object, error_code &ec) : ObjectFile(Binary::ID_COFF, Object) - , Header(0) + , COFFHeader(0) + , PE32Header(0) , SectionTable(0) , SymbolTable(0) , StringTable(0) @@ -438,49 +439,64 @@ COFFObjectFile::COFFObjectFile(MemoryBuffer *Object, error_code &ec) // Check that we at least have enough room for a header. if (!checkSize(Data, ec, sizeof(coff_file_header))) return; - // The actual starting location of the COFF header in the file. This can be - // non-zero in PE/COFF files. - uint64_t HeaderStart = 0; + // The current location in the file where we are looking at. + uint64_t CurPtr = 0; + + // PE header is optional and is present only in executables. If it exists, + // it is placed right after COFF header. + bool hasPEHeader = false; // Check if this is a PE/COFF file. if (base()[0] == 0x4d && base()[1] == 0x5a) { // PE/COFF, seek through MS-DOS compatibility stub and 4-byte // PE signature to find 'normal' COFF header. if (!checkSize(Data, ec, 0x3c + 8)) return; - HeaderStart = *reinterpret_cast(base() + 0x3c); - // Check the PE header. ("PE\0\0") - if (std::memcmp(base() + HeaderStart, "PE\0\0", 4) != 0) { + CurPtr = *reinterpret_cast(base() + 0x3c); + // Check the PE magic bytes. ("PE\0\0") + if (std::memcmp(base() + CurPtr, "PE\0\0", 4) != 0) { ec = object_error::parse_failed; return; } - HeaderStart += 4; // Skip the PE Header. + CurPtr += 4; // Skip the PE magic bytes. + hasPEHeader = true; } - Header = reinterpret_cast(base() + HeaderStart); - if (!checkAddr(Data, ec, uintptr_t(Header), sizeof(coff_file_header))) + COFFHeader = reinterpret_cast(base() + CurPtr); + if (!checkAddr(Data, ec, uintptr_t(COFFHeader), sizeof(coff_file_header))) return; + CurPtr += sizeof(coff_file_header); + + if (hasPEHeader) { + PE32Header = reinterpret_cast(base() + CurPtr); + if (!checkAddr(Data, ec, uintptr_t(PE32Header), sizeof(pe32_header))) + return; + // We only support PE32. If this is PE32 (not PE32+), the magic byte + // should be 0x10b. If this is not PE32, continue as if there's no PE + // header in this file. + if (PE32Header->Magic != 0x10b) + PE32Header = 0; + // There may be optional data directory after PE header. Skip them. + CurPtr += COFFHeader->SizeOfOptionalHeader; + } SectionTable = - reinterpret_cast( base() - + HeaderStart - + sizeof(coff_file_header) - + Header->SizeOfOptionalHeader); + reinterpret_cast(base() + CurPtr); if (!checkAddr(Data, ec, uintptr_t(SectionTable), - Header->NumberOfSections * sizeof(coff_section))) + COFFHeader->NumberOfSections * sizeof(coff_section))) return; - if (Header->PointerToSymbolTable != 0) { + if (COFFHeader->PointerToSymbolTable != 0) { SymbolTable = reinterpret_cast(base() - + Header->PointerToSymbolTable); + + COFFHeader->PointerToSymbolTable); if (!checkAddr(Data, ec, uintptr_t(SymbolTable), - Header->NumberOfSymbols * sizeof(coff_symbol))) + COFFHeader->NumberOfSymbols * sizeof(coff_symbol))) return; // Find string table. StringTable = reinterpret_cast(base()) - + Header->PointerToSymbolTable - + Header->NumberOfSymbols * sizeof(coff_symbol); + + COFFHeader->PointerToSymbolTable + + COFFHeader->NumberOfSymbols * sizeof(coff_symbol); if (!checkAddr(Data, ec, uintptr_t(StringTable), sizeof(ulittle32_t))) return; @@ -545,7 +561,7 @@ section_iterator COFFObjectFile::begin_sections() const { section_iterator COFFObjectFile::end_sections() const { DataRefImpl ret; - ret.p = reinterpret_cast(SectionTable + Header->NumberOfSections); + ret.p = reinterpret_cast(SectionTable + COFFHeader->NumberOfSections); return section_iterator(SectionRef(ret, this)); } @@ -554,7 +570,7 @@ uint8_t COFFObjectFile::getBytesInAddress() const { } StringRef COFFObjectFile::getFileFormatName() const { - switch(Header->Machine) { + switch(COFFHeader->Machine) { case COFF::IMAGE_FILE_MACHINE_I386: return "COFF-i386"; case COFF::IMAGE_FILE_MACHINE_AMD64: @@ -565,7 +581,7 @@ StringRef COFFObjectFile::getFileFormatName() const { } unsigned COFFObjectFile::getArch() const { - switch(Header->Machine) { + switch(COFFHeader->Machine) { case COFF::IMAGE_FILE_MACHINE_I386: return Triple::x86; case COFF::IMAGE_FILE_MACHINE_AMD64: @@ -575,8 +591,19 @@ unsigned COFFObjectFile::getArch() const { } } +// This method is kept here because lld uses this. As soon as we make +// lld to use getCOFFHeader, this method will be removed. error_code COFFObjectFile::getHeader(const coff_file_header *&Res) const { - Res = Header; + return getCOFFHeader(Res); +} + +error_code COFFObjectFile::getCOFFHeader(const coff_file_header *&Res) const { + Res = COFFHeader; + return object_error::success; +} + +error_code COFFObjectFile::getPE32Header(const pe32_header *&Res) const { + Res = PE32Header; return object_error::success; } @@ -587,7 +614,7 @@ error_code COFFObjectFile::getSection(int32_t index, index == COFF::IMAGE_SYM_ABSOLUTE || index == COFF::IMAGE_SYM_DEBUG) Result = NULL; - else if (index > 0 && index <= Header->NumberOfSections) + else if (index > 0 && index <= COFFHeader->NumberOfSections) // We already verified the section table data, so no need to check again. Result = SectionTable + (index - 1); else @@ -608,7 +635,7 @@ error_code COFFObjectFile::getString(uint32_t offset, error_code COFFObjectFile::getSymbol(uint32_t index, const coff_symbol *&Result) const { - if (index < Header->NumberOfSymbols) + if (index < COFFHeader->NumberOfSymbols) Result = SymbolTable + index; else return object_error::parse_failed; @@ -644,12 +671,12 @@ ArrayRef COFFObjectFile::getSymbolAuxData( # ifndef NDEBUG // Verify that the aux symbol points to a valid entry in the symbol table. uintptr_t offset = uintptr_t(aux) - uintptr_t(base()); - if (offset < Header->PointerToSymbolTable - || offset >= Header->PointerToSymbolTable - + (Header->NumberOfSymbols * sizeof(coff_symbol))) + if (offset < COFFHeader->PointerToSymbolTable + || offset >= COFFHeader->PointerToSymbolTable + + (COFFHeader->NumberOfSymbols * sizeof(coff_symbol))) report_fatal_error("Aux Symbol data was outside of symbol table."); - assert((offset - Header->PointerToSymbolTable) % sizeof(coff_symbol) + assert((offset - COFFHeader->PointerToSymbolTable) % sizeof(coff_symbol) == 0 && "Aux Symbol data did not point to the beginning of a symbol"); # endif } @@ -746,7 +773,7 @@ error_code COFFObjectFile::getRelocationTypeName(DataRefImpl Rel, SmallVectorImpl &Result) const { const coff_relocation *reloc = toRel(Rel); StringRef res; - switch (Header->Machine) { + switch (COFFHeader->Machine) { case COFF::IMAGE_FILE_MACHINE_AMD64: switch (reloc->Type) { LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ABSOLUTE); diff --git a/test/tools/llvm-readobj/Inputs/trivial.exe.coff-i386 b/test/tools/llvm-readobj/Inputs/trivial.exe.coff-i386 new file mode 100644 index 00000000000..3009f90da08 Binary files /dev/null and b/test/tools/llvm-readobj/Inputs/trivial.exe.coff-i386 differ diff --git a/test/tools/llvm-readobj/file-headers.test b/test/tools/llvm-readobj/file-headers.test index 226eb934233..1082dccd4c9 100644 --- a/test/tools/llvm-readobj/file-headers.test +++ b/test/tools/llvm-readobj/file-headers.test @@ -2,6 +2,8 @@ RUN: llvm-readobj -h %p/Inputs/trivial.obj.coff-i386 \ RUN: | FileCheck %s -check-prefix COFF32 RUN: llvm-readobj -h %p/Inputs/trivial.obj.coff-x86-64 \ RUN: | FileCheck %s -check-prefix COFF64 +RUN: llvm-readobj -h %p/Inputs/trivial.exe.coff-i386 \ +RUN: | FileCheck %s -check-prefix PE32 RUN: llvm-readobj -h %p/Inputs/trivial.obj.elf-i386 \ RUN: | FileCheck %s -check-prefix ELF32 RUN: llvm-readobj -h %p/Inputs/trivial.obj.elf-x86-64 \ @@ -98,3 +100,52 @@ ELF64-NEXT: SectionHeaderEntrySize: 64 ELF64-NEXT: SectionHeaderCount: 10 ELF64-NEXT: StringTableSectionIndex: 7 ELF64-NEXT: } + +PE32: File: {{(.*[/\\])?}}trivial.exe.coff-i386 +PE32-NEXT: Format: COFF-i386 +PE32-NEXT: Arch: i386 +PE32-NEXT: AddressSize: 32bit +PE32-NEXT: ImageFileHeader { +PE32-NEXT: Machine: IMAGE_FILE_MACHINE_I386 (0x14C) +PE32-NEXT: SectionCount: 1 +PE32-NEXT: TimeDateStamp: 2013-05-24 21:24:34 (0x519FDA92) +PE32-NEXT: PointerToSymbolTable: 0x0 +PE32-NEXT: SymbolCount: 0 +PE32-NEXT: OptionalHeaderSize: 224 +PE32-NEXT: Characteristics [ (0x102) +PE32-NEXT: IMAGE_FILE_32BIT_MACHINE (0x100) +PE32-NEXT: IMAGE_FILE_EXECUTABLE_IMAGE (0x2) +PE32-NEXT: ] +PE32-NEXT: } +PE32-NEXT: ImageOptionalHeader { +PE32-NEXT: MajorLinkerVersion: 10 +PE32-NEXT: MinorLinkerVersion: 0 +PE32-NEXT: SizeOfCode: 512 +PE32-NEXT: SizeOfInitializedData: 0 +PE32-NEXT: SizeOfUninitializedData: 0 +PE32-NEXT: AddressOfEntryPoint: 0x1000 +PE32-NEXT: BaseOfCode: 0x1000 +PE32-NEXT: BaseOfData: 0x2000 +PE32-NEXT: ImageBase: 0x400000 +PE32-NEXT: SectionAlignment: 4096 +PE32-NEXT: FileAlignment: 512 +PE32-NEXT: MajorOperatingSystemVersion: 5 +PE32-NEXT: MinorOperatingSystemVersion: 1 +PE32-NEXT: MajorImageVersion: 0 +PE32-NEXT: MinorImageVersion: 0 +PE32-NEXT: MajorSubsystemVersion: 5 +PE32-NEXT: MinorSubsystemVersion: 1 +PE32-NEXT: SizeOfImage: 8192 +PE32-NEXT: SizeOfHeaders: 512 +PE32-NEXT: Subsystem: IMAGE_SUBSYSTEM_WINDOWS_GUI (0x2) +PE32-NEXT: Subsystem [ (0x8140) +PE32-NEXT: IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE (0x40) +PE32-NEXT: IMAGE_DLL_CHARACTERISTICS_NX_COMPAT (0x100) +PE32-NEXT: IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE (0x8000) +PE32-NEXT: ] +PE32-NEXT: SizeOfStackReserve: 1048576 +PE32-NEXT: SizeOfStackCommit: 4096 +PE32-NEXT: SizeOfHeapReserve: 1048576 +PE32-NEXT: SizeOfHeapCommit: 4096 +PE32-NEXT: NumberOfRvaAndSize: 16 +PE32-NEXT: } diff --git a/tools/llvm-objdump/COFFDump.cpp b/tools/llvm-objdump/COFFDump.cpp index 7b550077ae5..bca6fc983d8 100644 --- a/tools/llvm-objdump/COFFDump.cpp +++ b/tools/llvm-objdump/COFFDump.cpp @@ -229,7 +229,7 @@ static void printCOFFSymbolAddress(llvm::raw_ostream &Out, void llvm::printCOFFUnwindInfo(const COFFObjectFile *Obj) { const coff_file_header *Header; - if (error(Obj->getHeader(Header))) return; + if (error(Obj->getCOFFHeader(Header))) return; if (Header->Machine != COFF::IMAGE_FILE_MACHINE_AMD64) { errs() << "Unsupported image machine type " diff --git a/tools/llvm-readobj/COFFDumper.cpp b/tools/llvm-readobj/COFFDumper.cpp index 3cbb9b3c34b..9c14b467a32 100644 --- a/tools/llvm-readobj/COFFDumper.cpp +++ b/tools/llvm-readobj/COFFDumper.cpp @@ -262,6 +262,31 @@ static const EnumEntry ImageFileCharacteristics[] = { LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_HI ) }; +static const EnumEntry 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 ), +}; + +static const EnumEntry PEDLLCharacteristics[] = { + 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_WDM_DRIVER ), + LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE), +}; + static const EnumEntry ImageSectionCharacteristics[] = { LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NO_PAD ), @@ -536,26 +561,67 @@ void COFFDumper::cacheRelocations() { } void COFFDumper::printFileHeaders() { - const coff_file_header *Header = 0; - if (error(Obj->getHeader(Header))) + // Print COFF header + const coff_file_header *COFFHeader = 0; + if (error(Obj->getCOFFHeader(COFFHeader))) return; - time_t TDS = Header->TimeDateStamp; + time_t TDS = COFFHeader->TimeDateStamp; char FormattedTime[20] = { }; strftime(FormattedTime, 20, "%Y-%m-%d %H:%M:%S", gmtime(&TDS)); { DictScope D(W, "ImageFileHeader"); - W.printEnum ("Machine", Header->Machine, + W.printEnum ("Machine", COFFHeader->Machine, makeArrayRef(ImageFileMachineType)); - W.printNumber("SectionCount", Header->NumberOfSections); - W.printHex ("TimeDateStamp", FormattedTime, Header->TimeDateStamp); - W.printHex ("PointerToSymbolTable", Header->PointerToSymbolTable); - W.printNumber("SymbolCount", Header->NumberOfSymbols); - W.printNumber("OptionalHeaderSize", Header->SizeOfOptionalHeader); - W.printFlags ("Characteristics", Header->Characteristics, + W.printNumber("SectionCount", COFFHeader->NumberOfSections); + W.printHex ("TimeDateStamp", FormattedTime, COFFHeader->TimeDateStamp); + W.printHex ("PointerToSymbolTable", COFFHeader->PointerToSymbolTable); + W.printNumber("SymbolCount", COFFHeader->NumberOfSymbols); + W.printNumber("OptionalHeaderSize", COFFHeader->SizeOfOptionalHeader); + W.printFlags ("Characteristics", COFFHeader->Characteristics, makeArrayRef(ImageFileCharacteristics)); } + + // Print PE header. This header does not exist if this is an object file and + // not an executable. + const pe32_header *PEHeader = 0; + if (error(Obj->getPE32Header(PEHeader))) + return; + + if (PEHeader) { + DictScope D(W, "ImageOptionalHeader"); + W.printNumber("MajorLinkerVersion", PEHeader->MajorLinkerVersion); + W.printNumber("MinorLinkerVersion", PEHeader->MinorLinkerVersion); + W.printNumber("SizeOfCode", PEHeader->SizeOfCode); + W.printNumber("SizeOfInitializedData", PEHeader->SizeOfInitializedData); + W.printNumber("SizeOfUninitializedData", PEHeader->SizeOfUninitializedData); + W.printHex ("AddressOfEntryPoint", PEHeader->AddressOfEntryPoint); + W.printHex ("BaseOfCode", PEHeader->BaseOfCode); + W.printHex ("BaseOfData", PEHeader->BaseOfData); + W.printHex ("ImageBase", PEHeader->ImageBase); + W.printNumber("SectionAlignment", PEHeader->SectionAlignment); + W.printNumber("FileAlignment", PEHeader->FileAlignment); + W.printNumber("MajorOperatingSystemVersion", + PEHeader->MajorOperatingSystemVersion); + W.printNumber("MinorOperatingSystemVersion", + PEHeader->MinorOperatingSystemVersion); + W.printNumber("MajorImageVersion", PEHeader->MajorImageVersion); + W.printNumber("MinorImageVersion", PEHeader->MinorImageVersion); + W.printNumber("MajorSubsystemVersion", PEHeader->MajorSubsystemVersion); + W.printNumber("MinorSubsystemVersion", PEHeader->MinorSubsystemVersion); + W.printNumber("SizeOfImage", PEHeader->SizeOfImage); + W.printNumber("SizeOfHeaders", PEHeader->SizeOfHeaders); + W.printEnum ("Subsystem", PEHeader->Subsystem, + makeArrayRef(PEWindowsSubsystem)); + W.printFlags ("Subsystem", PEHeader->DLLCharacteristics, + makeArrayRef(PEDLLCharacteristics)); + W.printNumber("SizeOfStackReserve", PEHeader->SizeOfStackReserve); + W.printNumber("SizeOfStackCommit", PEHeader->SizeOfStackCommit); + W.printNumber("SizeOfHeapReserve", PEHeader->SizeOfHeapReserve); + W.printNumber("SizeOfHeapCommit", PEHeader->SizeOfHeapCommit); + W.printNumber("NumberOfRvaAndSize", PEHeader->NumberOfRvaAndSize); + } } void COFFDumper::printSections() { @@ -834,7 +900,7 @@ void COFFDumper::printSymbol(symbol_iterator SymI) { void COFFDumper::printUnwindInfo() { const coff_file_header *Header; - if (error(Obj->getHeader(Header))) + if (error(Obj->getCOFFHeader(Header))) return; ListScope D(W, "UnwindInformation"); diff --git a/tools/obj2yaml/coff2yaml.cpp b/tools/obj2yaml/coff2yaml.cpp index 0ec35bfc7e3..1e28c4e9d6c 100644 --- a/tools/obj2yaml/coff2yaml.cpp +++ b/tools/obj2yaml/coff2yaml.cpp @@ -38,7 +38,7 @@ static void check(error_code ec) { COFFDumper::COFFDumper(const object::COFFObjectFile &Obj) : Obj(Obj) { const object::coff_file_header *Header; - check(Obj.getHeader(Header)); + check(Obj.getCOFFHeader(Header)); dumpHeader(Header); dumpSections(Header->NumberOfSections); dumpSymbols(Header->NumberOfSymbols);