RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-12-01 07:30:31 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert "llvm-objdump: Dump COFF import table if -private-headers option is given."

Browse Source 
This reverts commit r191472 because it's failing on BE machine.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@191480 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Rui Ueyama 2013-09-27 01:29:36 +00:00
parent 10965f2045
commit 4715a11dcf
15 changed files with 160 additions and 390 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
include/llvm/Object/COFF.h
View File

@ -23,8 +23,6 @@ namespace llvm {
class ArrayRef; class ArrayRef;
namespace object { namespace object {
class ImportDirectoryEntryRef;
typedef content_iterator<ImportDirectoryEntryRef> import_directory_iterator;
/// The DOS compatible header at the front of all PE/COFF executables. /// The DOS compatible header at the front of all PE/COFF executables.
struct dos_header { struct dos_header {
@ -204,7 +202,6 @@ struct coff_aux_section_definition {
class COFFObjectFile : public ObjectFile { class COFFObjectFile : public ObjectFile {
private: private:
friend class ImportDirectoryEntryRef;
const coff_file_header *COFFHeader; const coff_file_header *COFFHeader;
const pe32_header *PE32Header; const pe32_header *PE32Header;
const data_directory *DataDirectory; const data_directory *DataDirectory;
@ -212,8 +209,6 @@ private:
const coff_symbol *SymbolTable; const coff_symbol *SymbolTable;
const char *StringTable; const char *StringTable;
uint32_t StringTableSize; uint32_t StringTableSize;
const import_directory_table_entry *ImportDirectory;
uint32_t NumberOfImportDirectory;
error_code getString(uint32_t offset, StringRef &Res) const; error_code getString(uint32_t offset, StringRef &Res) const;
@ -221,9 +216,6 @@ private:
const coff_section *toSec(DataRefImpl Sec) const; const coff_section *toSec(DataRefImpl Sec) const;
const coff_relocation *toRel(DataRefImpl Rel) const; const coff_relocation *toRel(DataRefImpl Rel) const;
error_code initSymbolTablePtr();
error_code initImportTablePtr();
protected: protected:
virtual error_code getSymbolNext(DataRefImpl Symb, SymbolRef &Res) const; virtual error_code getSymbolNext(DataRefImpl Symb, SymbolRef &Res) const;
virtual error_code getSymbolName(DataRefImpl Symb, StringRef &Res) const; virtual error_code getSymbolName(DataRefImpl Symb, StringRef &Res) const;
@ -295,9 +287,6 @@ public:
virtual unsigned getArch() const; virtual unsigned getArch() const;
virtual StringRef getLoadName() const; virtual StringRef getLoadName() const;
import_directory_iterator getImportDirectoryBegin() const;
import_directory_iterator getImportDirectoryEnd() const;
error_code getHeader(const coff_file_header *&Res) const; error_code getHeader(const coff_file_header *&Res) const;
error_code getCOFFHeader(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 getPE32Header(const pe32_header *&Res) const;
@ -318,37 +307,12 @@ public:
error_code getSectionContents(const coff_section *Sec, error_code getSectionContents(const coff_section *Sec,
ArrayRef<uint8_t> &Res) const; ArrayRef<uint8_t> &Res) const;
error_code getRvaPtr(uint32_t Rva, uintptr_t &Res) const;
error_code getHintName(uint32_t Rva, uint16_t &Hint, StringRef &Name) const;
static inline bool classof(const Binary *v) { static inline bool classof(const Binary *v) {
return v->isCOFF(); return v->isCOFF();
} }
}; };
// The iterator for the import directory table. }
class ImportDirectoryEntryRef { }
public:
ImportDirectoryEntryRef() : OwningObject(0) {}
ImportDirectoryEntryRef(DataRefImpl ImportDirectory,
const COFFObjectFile *Owner)
: ImportDirectoryPimpl(ImportDirectory), OwningObject(Owner) {}
bool operator==(const ImportDirectoryEntryRef &Other) const;
error_code getNext(ImportDirectoryEntryRef &Result) const;
error_code getName(StringRef &Result) const;
error_code
getImportTableEntry(const import_directory_table_entry *&Result) const;
error_code
getImportLookupEntry(const COFF::ImportLookupTableEntry32 *&Result) const;
private:
DataRefImpl ImportDirectoryPimpl;
const COFFObjectFile *OwningObject;
};
} // end namespace object
} // end namespace llvm
#endif #endif

196
lib/Object/COFFObjectFile.cpp
View File

@ -16,8 +16,6 @@
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/StringSwitch.h"
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm; using namespace llvm;
using namespace object; using namespace object;
@ -431,94 +429,6 @@ relocation_iterator COFFObjectFile::getSectionRelEnd(DataRefImpl Sec) const {
return relocation_iterator(RelocationRef(ret, this)); return relocation_iterator(RelocationRef(ret, this));
} }
// Initialize the pointer to the symbol table.
error_code COFFObjectFile::initSymbolTablePtr() {
if (error_code ec = getObject(
SymbolTable, Data, base() + COFFHeader->PointerToSymbolTable,
COFFHeader->NumberOfSymbols * sizeof(coff_symbol)))
return ec;
// Find string table. The first four byte of the string table contains the
// total size of the string table, including the size field itself. If the
// string table is empty, the value of the first four byte would be 4.
const uint8_t *StringTableAddr =
base() + COFFHeader->PointerToSymbolTable +
COFFHeader->NumberOfSymbols * sizeof(coff_symbol);
const ulittle32_t *StringTableSizePtr;
if (error_code ec = getObject(StringTableSizePtr, Data, StringTableAddr))
return ec;
StringTableSize = *StringTableSizePtr;
if (error_code ec =
getObject(StringTable, Data, StringTableAddr, StringTableSize))
return ec;
// Check that the string table is null terminated if has any in it.
if (StringTableSize < 4 ||
(StringTableSize > 4 && StringTable[StringTableSize - 1] != 0))
return object_error::parse_failed;
return object_error::success;
}
// Returns the file offset for the given RVA.
error_code COFFObjectFile::getRvaPtr(uint32_t Rva, uintptr_t &Res) const {
error_code ec;
for (section_iterator i = begin_sections(), e = end_sections(); i != e;
i.increment(ec)) {
if (ec)
return ec;
const coff_section *Section = getCOFFSection(i);
uint32_t SectionStart = Section->VirtualAddress;
uint32_t SectionEnd = Section->VirtualAddress + Section->VirtualSize;
if (SectionStart <= Rva && Rva < SectionEnd) {
uint32_t Offset = Rva - SectionStart;
Res = uintptr_t(base()) + Section->PointerToRawData + Offset;
return object_error::success;
}
}
return object_error::parse_failed;
}
// Returns hint and name fields, assuming \p Rva is pointing to a Hint/Name
// table entry.
error_code COFFObjectFile::
getHintName(uint32_t Rva, uint16_t &Hint, StringRef &Name) const {
uintptr_t IntPtr = 0;
if (error_code ec = getRvaPtr(Rva, IntPtr))
return ec;
const uint8_t *Ptr = reinterpret_cast<const uint8_t *>(IntPtr);
Hint = *reinterpret_cast<const ulittle16_t *>(Ptr);
Name = StringRef(reinterpret_cast<const char *>(Ptr + 2));
return object_error::success;
}
// Find the import table.
error_code COFFObjectFile::initImportTablePtr() {
// First, we get the RVA of the import table. If the file lacks a pointer to
// the import table, do nothing.
const data_directory *DataEntry;
if (getDataDirectory(COFF::IMPORT_TABLE, DataEntry))
return object_error::success;
// Do nothing if the pointer to import table is NULL.
if (DataEntry->RelativeVirtualAddress == 0)
return object_error::success;
uint32_t ImportTableRva = DataEntry->RelativeVirtualAddress;
NumberOfImportDirectory = DataEntry->Size /
sizeof(import_directory_table_entry);
// Find the section that contains the RVA. This is needed because the RVA is
// the import table's memory address which is different from its file offset.
uintptr_t IntPtr = 0;
if (error_code ec = getRvaPtr(ImportTableRva, IntPtr))
return ec;
ImportDirectory = reinterpret_cast<
const import_directory_table_entry *>(IntPtr);
// It's an error if there's no section containing the Import Table RVA.
return object_error::parse_failed;
}
COFFObjectFile::COFFObjectFile(MemoryBuffer *Object, error_code &ec) COFFObjectFile::COFFObjectFile(MemoryBuffer *Object, error_code &ec)
: ObjectFile(Binary::ID_COFF, Object) : ObjectFile(Binary::ID_COFF, Object)
, COFFHeader(0) , COFFHeader(0)
@ -527,9 +437,7 @@ COFFObjectFile::COFFObjectFile(MemoryBuffer *Object, error_code &ec)
, SectionTable(0) , SectionTable(0)
, SymbolTable(0) , SymbolTable(0)
, StringTable(0) , StringTable(0)
, StringTableSize(0) , StringTableSize(0) {
, ImportDirectory(0)
, NumberOfImportDirectory(0) {
// Check that we at least have enough room for a header. // Check that we at least have enough room for a header.
if (!checkSize(Data, ec, sizeof(coff_file_header))) return; if (!checkSize(Data, ec, sizeof(coff_file_header))) return;
@ -580,28 +488,45 @@ COFFObjectFile::COFFObjectFile(MemoryBuffer *Object, error_code &ec)
COFFHeader->NumberOfSections * sizeof(coff_section)))) COFFHeader->NumberOfSections * sizeof(coff_section))))
return; return;
// Initialize the pointer to the symbol table. if (COFFHeader->PointerToSymbolTable != 0) {
if (COFFHeader->PointerToSymbolTable != 0) if ((ec = getObject(SymbolTable, Data,
if ((ec = initSymbolTablePtr())) base() + COFFHeader->PointerToSymbolTable,
COFFHeader->NumberOfSymbols * sizeof(coff_symbol))))
return; return;
// Initialize the pointer to the beginning of the import table. // Find string table. The first four byte of the string table contains the
if ((ec = initImportTablePtr())) // total size of the string table, including the size field itself. If the
return; // string table is empty, the value of the first four byte would be 4.
const uint8_t *StringTableAddr = base() + COFFHeader->PointerToSymbolTable
+ COFFHeader->NumberOfSymbols * sizeof(coff_symbol);
const ulittle32_t *StringTableSizePtr;
if ((ec = getObject(StringTableSizePtr, Data, StringTableAddr)))
return;
StringTableSize = *StringTableSizePtr;
if ((ec = getObject(StringTable, Data, StringTableAddr, StringTableSize)))
return;
// Check that the string table is null terminated if has any in it.
if (StringTableSize < 4
|| (StringTableSize > 4 && StringTable[StringTableSize - 1] != 0)) {
ec = object_error::parse_failed;
return;
}
}
ec = object_error::success; ec = object_error::success;
} }
symbol_iterator COFFObjectFile::begin_symbols() const { symbol_iterator COFFObjectFile::begin_symbols() const {
DataRefImpl ret; DataRefImpl ret;
ret.p = reinterpret_cast<uintptr_t>(SymbolTable); ret.p = reinterpret_cast<intptr_t>(SymbolTable);
return symbol_iterator(SymbolRef(ret, this)); return symbol_iterator(SymbolRef(ret, this));
} }
symbol_iterator COFFObjectFile::end_symbols() const { symbol_iterator COFFObjectFile::end_symbols() const {
// The symbol table ends where the string table begins. // The symbol table ends where the string table begins.
DataRefImpl ret; DataRefImpl ret;
ret.p = reinterpret_cast<uintptr_t>(StringTable); ret.p = reinterpret_cast<intptr_t>(StringTable);
return symbol_iterator(SymbolRef(ret, this)); return symbol_iterator(SymbolRef(ret, this));
} }
@ -630,32 +555,16 @@ StringRef COFFObjectFile::getLoadName() const {
return ""; return "";
} }
import_directory_iterator COFFObjectFile::getImportDirectoryBegin() const {
DataRefImpl Imp;
Imp.p = reinterpret_cast<uintptr_t>(ImportDirectory);
return import_directory_iterator(ImportDirectoryEntryRef(Imp, this));
}
import_directory_iterator COFFObjectFile::getImportDirectoryEnd() const {
DataRefImpl Imp;
if (ImportDirectory) {
Imp.p = reinterpret_cast<uintptr_t>(
ImportDirectory + (NumberOfImportDirectory - 1));
} else {
Imp.p = 0;
}
return import_directory_iterator(ImportDirectoryEntryRef(Imp, this));
}
section_iterator COFFObjectFile::begin_sections() const { section_iterator COFFObjectFile::begin_sections() const {
DataRefImpl ret; DataRefImpl ret;
ret.p = reinterpret_cast<uintptr_t>(SectionTable); ret.p = reinterpret_cast<intptr_t>(SectionTable);
return section_iterator(SectionRef(ret, this)); return section_iterator(SectionRef(ret, this));
} }
section_iterator COFFObjectFile::end_sections() const { section_iterator COFFObjectFile::end_sections() const {
DataRefImpl ret; DataRefImpl ret;
ret.p = reinterpret_cast<uintptr_t>(SectionTable + COFFHeader->NumberOfSections); ret.p = reinterpret_cast<intptr_t>(SectionTable + COFFHeader->NumberOfSections);
return section_iterator(SectionRef(ret, this)); return section_iterator(SectionRef(ret, this));
} }
@ -767,7 +676,7 @@ error_code COFFObjectFile::getSymbolName(const coff_symbol *symbol,
ArrayRef<uint8_t> COFFObjectFile::getSymbolAuxData( ArrayRef<uint8_t> COFFObjectFile::getSymbolAuxData(
const coff_symbol *symbol) const { const coff_symbol *symbol) const {
const uint8_t *aux = NULL; const uint8_t *aux = NULL;
if ( symbol->NumberOfAuxSymbols > 0 ) { if ( symbol->NumberOfAuxSymbols > 0 ) {
// AUX data comes immediately after the symbol in COFF // AUX data comes immediately after the symbol in COFF
aux = reinterpret_cast<const uint8_t *>(symbol + 1); aux = reinterpret_cast<const uint8_t *>(symbol + 1);
@ -868,6 +777,7 @@ const coff_relocation *COFFObjectFile::getCOFFRelocation(
return toRel(It->getRawDataRefImpl()); return toRel(It->getRawDataRefImpl());
} }
#define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(enum) \ #define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(enum) \
case COFF::enum: res = #enum; break; case COFF::enum: res = #enum; break;
@ -948,52 +858,6 @@ error_code COFFObjectFile::getLibraryPath(DataRefImpl LibData,
report_fatal_error("getLibraryPath not implemented in COFFObjectFile"); report_fatal_error("getLibraryPath not implemented in COFFObjectFile");
} }
bool ImportDirectoryEntryRef::
operator==(const ImportDirectoryEntryRef &Other) const {
return ImportDirectoryPimpl == Other.ImportDirectoryPimpl;
}
static const import_directory_table_entry *toImportEntry(DataRefImpl Imp) {
return reinterpret_cast<const import_directory_table_entry *>(Imp.p);
}
error_code
ImportDirectoryEntryRef::getNext(ImportDirectoryEntryRef &Result) const {
const import_directory_table_entry *Dir = toImportEntry(ImportDirectoryPimpl);
Dir += 1;
DataRefImpl Next;
Next.p = reinterpret_cast<uintptr_t>(Dir);
Result = ImportDirectoryEntryRef(Next, OwningObject);
return object_error::success;
}
error_code ImportDirectoryEntryRef::
getImportTableEntry(const import_directory_table_entry *&Result) const {
Result = toImportEntry(ImportDirectoryPimpl);
return object_error::success;
}
error_code ImportDirectoryEntryRef::getName(StringRef &Result) const {
const import_directory_table_entry *Dir = toImportEntry(ImportDirectoryPimpl);
uintptr_t IntPtr = 0;
if (error_code ec = OwningObject->getRvaPtr(Dir->NameRVA, IntPtr))
return ec;
const char *Ptr = reinterpret_cast<const char *>(IntPtr);
Result = StringRef(Ptr);
return object_error::success;
}
error_code ImportDirectoryEntryRef::getImportLookupEntry(
const COFF::ImportLookupTableEntry32 *&Result) const {
const import_directory_table_entry *Dir = toImportEntry(ImportDirectoryPimpl);
uintptr_t IntPtr = 0;
if (error_code ec = OwningObject->getRvaPtr(
Dir->ImportLookupTableRVA, IntPtr))
return ec;
Result = reinterpret_cast<const COFF::ImportLookupTableEntry32 *>(IntPtr);
return object_error::success;
}
namespace llvm { namespace llvm {
ObjectFile *ObjectFile::createCOFFObjectFile(MemoryBuffer *Object) { ObjectFile *ObjectFile::createCOFFObjectFile(MemoryBuffer *Object) {

BIN
test/tools/llvm-objdump/Inputs/nop.exe.coff-i386
View File

Binary file not shown.

BIN
test/tools/llvm-objdump/Inputs/trivial.obj.elf-i386
View File

Binary file not shown.

BIN
test/tools/llvm-objdump/Inputs/win64-unwind.exe.coff-x86_64
View File

Binary file not shown.

53
test/tools/llvm-objdump/Inputs/win64-unwind.exe.coff-x86_64.asm
View File

@ -1,53 +0,0 @@
.text
.globl func
.def func; .scl 2; .type 32; .endef
.seh_proc func
func:
.seh_pushframe @code
subq $24, %rsp
.seh_stackalloc 24
movq %rsi, 16(%rsp)
.seh_savereg %rsi, 16
movups %xmm8, (%rsp)
.seh_savexmm %xmm8, 0
pushq %rbx
.seh_pushreg 3
mov %rsp, %rbx
.seh_setframe 3, 0
.seh_endprologue
.seh_handler __C_specific_handler, @except
.seh_handlerdata
.long 0
.text
.seh_startchained
.seh_endprologue
.seh_endchained
lea (%rbx), %rsp
pop %rbx
addq $24, %rsp
ret
.seh_endproc
// Test emission of small functions.
.globl smallFunc
.def smallFunc; .scl 2; .type 32; .endef
.seh_proc smallFunc
smallFunc:
ret
.seh_endproc
// Function with big stack allocation.
.globl allocFunc
.def allocFunc; .scl 2; .type 32; .endef
.seh_proc allocFunc
allocFunc:
.seh_pushframe @code
subq $65520, %rsp
.seh_stackalloc 65520
sub $8454128, %rsp
.seh_stackalloc 8454128
.seh_endprologue
add $8454128, %rsp
addq $65520, %rsp
ret
.seh_endproc

9
test/tools/llvm-objdump/coff-private-headers.test
View File

@ -1,9 +0,0 @@
// RUN: llvm-objdump -p %p/Inputs/nop.exe.coff-i386 | FileCheck %s
CHECK: The Import Tables:
CHECK-NEXT: lookup 00005028 time 00000000 fwd 00000000 name 00005096 addr 00005058
CHECK: DLL Name: KERNEL32.dll
CHECK-NEXT: Hint/Ord Name
CHECK-NEXT: 365 ExitProcess

15
test/tools/llvm-objdump/disassembly-show-raw.s Normal file
View File

@ -0,0 +1,15 @@
// RUN: llvm-mc -filetype=obj -arch=x86 %s | llvm-objdump -d - \
// RUN: | FileCheck %s -check-prefix=WITHRAW
// RUN: llvm-mc -filetype=obj -arch=x86 %s | llvm-objdump -d -no-show-raw-insn - \
// RUN: | FileCheck %s -check-prefix=NORAW
// Expect to find the raw incoding when run with raw output (default), but not
// when run explicitly with -no-show-raw-insn
movl 0, %eax
// WITHRAW: a1 00 00 00 00 movl
// NORAW: movl
// NORAW-NOT: a1 00

14
test/tools/llvm-objdump/disassembly-show-raw.test
View File

@ -1,14 +0,0 @@
// RUN: llvm-objdump -d %p/Inputs/trivial.obj.elf-i386 \
// RUN: | FileCheck %s -check-prefix=WITHRAW
// RUN: llvm-objdump -d -no-show-raw-insn %p/Inputs/trivial.obj.elf-i386 \
// RUN: | FileCheck %s -check-prefix=NORAW
// Expect to find the raw incoding when run with raw output (default), but not
// when run explicitly with -no-show-raw-insn
WITHRAW: a1 00 00 00 00 movl
NORAW: movl
NORAW-NOT: a1 00

4
test/tools/llvm-objdump/lit.local.cfg Normal file
View File

@ -0,0 +1,4 @@
targets = set(config.root.targets_to_build.split())
if not 'X86' in targets:
config.unsupported = True

106
test/tools/llvm-objdump/win64-unwind-data.s Normal file
View File

@ -0,0 +1,106 @@
// This test checks that the unwind data is dumped by llvm-objdump.
// RUN: llvm-mc -triple x86_64-pc-win32 -filetype=obj %s | llvm-objdump -u - | FileCheck %s
// CHECK: Unwind info:
// CHECK: Function Table:
// CHECK-NEXT: Start Address: func
// CHECK-NEXT: End Address: func + 0x001b
// CHECK-NEXT: Unwind Info Address: .xdata
// CHECK-NEXT: Version: 1
// CHECK-NEXT: Flags: 1 UNW_ExceptionHandler
// CHECK-NEXT: Size of prolog: 18
// CHECK-NEXT: Number of Codes: 8
// CHECK-NEXT: Frame register: RBX
// CHECK-NEXT: Frame offset: 0
// CHECK-NEXT: Unwind Codes:
// CHECK-NEXT: 0x12: UOP_SetFPReg
// CHECK-NEXT: 0x0f: UOP_PushNonVol RBX
// CHECK-NEXT: 0x0e: UOP_SaveXMM128 XMM8 [0x0000]
// CHECK-NEXT: 0x09: UOP_SaveNonVol RSI [0x0010]
// CHECK-NEXT: 0x04: UOP_AllocSmall 24
// CHECK-NEXT: 0x00: UOP_PushMachFrame w/o error code
// CHECK: Function Table:
// CHECK-NEXT: Start Address: func + 0x0012
// CHECK-NEXT: End Address: func + 0x0012
// CHECK-NEXT: Unwind Info Address: .xdata + 0x001c
// CHECK-NEXT: Version: 1
// CHECK-NEXT: Flags: 4 UNW_ChainInfo
// CHECK-NEXT: Size of prolog: 0
// CHECK-NEXT: Number of Codes: 0
// CHECK-NEXT: No frame pointer used
// CHECK: Function Table:
// CHECK-NEXT: Start Address: smallFunc
// CHECK-NEXT: End Address: smallFunc + 0x0001
// CHECK-NEXT: Unwind Info Address: .xdata + 0x002c
// CHECK-NEXT: Version: 1
// CHECK-NEXT: Flags: 0
// CHECK-NEXT: Size of prolog: 0
// CHECK-NEXT: Number of Codes: 0
// CHECK-NEXT: No frame pointer used
// CHECK: Function Table:
// CHECK-NEXT: Start Address: allocFunc
// CHECK-NEXT: End Address: allocFunc + 0x001d
// CHECK-NEXT: Unwind Info Address: .xdata + 0x0034
// CHECK-NEXT: Version: 1
// CHECK-NEXT: Flags: 0
// CHECK-NEXT: Size of prolog: 14
// CHECK-NEXT: Number of Codes: 6
// CHECK-NEXT: No frame pointer used
// CHECK-NEXT: Unwind Codes:
// CHECK-NEXT: 0x0e: UOP_AllocLarge 8454128
// CHECK-NEXT: 0x07: UOP_AllocLarge 8190
// CHECK-NEXT: 0x00: UOP_PushMachFrame w/o error code
.text
.globl func
.def func; .scl 2; .type 32; .endef
.seh_proc func
func:
.seh_pushframe @code
subq $24, %rsp
.seh_stackalloc 24
movq %rsi, 16(%rsp)
.seh_savereg %rsi, 16
movups %xmm8, (%rsp)
.seh_savexmm %xmm8, 0
pushq %rbx
.seh_pushreg 3
mov %rsp, %rbx
.seh_setframe 3, 0
.seh_endprologue
.seh_handler __C_specific_handler, @except
.seh_handlerdata
.long 0
.text
.seh_startchained
.seh_endprologue
.seh_endchained
lea (%rbx), %rsp
pop %rbx
addq $24, %rsp
ret
.seh_endproc
// Test emission of small functions.
.globl smallFunc
.def smallFunc; .scl 2; .type 32; .endef
.seh_proc smallFunc
smallFunc:
ret
.seh_endproc
// Function with big stack allocation.
.globl allocFunc
.def allocFunc; .scl 2; .type 32; .endef
.seh_proc allocFunc
allocFunc:
.seh_pushframe @code
subq $65520, %rsp
.seh_stackalloc 65520
sub $8454128, %rsp
.seh_stackalloc 8454128
.seh_endprologue
add $8454128, %rsp
addq $65520, %rsp
ret
.seh_endproc

52
test/tools/llvm-objdump/win64-unwind-data.test
View File

@ -1,52 +0,0 @@
// This test checks that the unwind data is dumped by llvm-objdump.
// RUN: llvm-objdump -u %p/Inputs/win64-unwind.exe.coff-x86_64 | FileCheck %s
CHECK: Unwind info:
CHECK: Function Table:
CHECK-NEXT: Start Address: func
CHECK-NEXT: End Address: func + 0x001b
CHECK-NEXT: Unwind Info Address: .xdata
CHECK-NEXT: Version: 1
CHECK-NEXT: Flags: 1 UNW_ExceptionHandler
CHECK-NEXT: Size of prolog: 18
CHECK-NEXT: Number of Codes: 8
CHECK-NEXT: Frame register: RBX
CHECK-NEXT: Frame offset: 0
CHECK-NEXT: Unwind Codes:
CHECK-NEXT: 0x12: UOP_SetFPReg
CHECK-NEXT: 0x0f: UOP_PushNonVol RBX
CHECK-NEXT: 0x0e: UOP_SaveXMM128 XMM8 [0x0000]
CHECK-NEXT: 0x09: UOP_SaveNonVol RSI [0x0010]
CHECK-NEXT: 0x04: UOP_AllocSmall 24
CHECK-NEXT: 0x00: UOP_PushMachFrame w/o error code
CHECK: Function Table:
CHECK-NEXT: Start Address: func + 0x0012
CHECK-NEXT: End Address: func + 0x0012
CHECK-NEXT: Unwind Info Address: .xdata + 0x001c
CHECK-NEXT: Version: 1
CHECK-NEXT: Flags: 4 UNW_ChainInfo
CHECK-NEXT: Size of prolog: 0
CHECK-NEXT: Number of Codes: 0
CHECK-NEXT: No frame pointer used
CHECK: Function Table:
CHECK-NEXT: Start Address: smallFunc
CHECK-NEXT: End Address: smallFunc + 0x0001
CHECK-NEXT: Unwind Info Address: .xdata + 0x002c
CHECK-NEXT: Version: 1
CHECK-NEXT: Flags: 0
CHECK-NEXT: Size of prolog: 0
CHECK-NEXT: Number of Codes: 0
CHECK-NEXT: No frame pointer used
CHECK: Function Table:
CHECK-NEXT: Start Address: allocFunc
CHECK-NEXT: End Address: allocFunc + 0x001d
CHECK-NEXT: Unwind Info Address: .xdata + 0x0034
CHECK-NEXT: Version: 1
CHECK-NEXT: Flags: 0
CHECK-NEXT: Size of prolog: 14
CHECK-NEXT: Number of Codes: 6
CHECK-NEXT: No frame pointer used
CHECK-NEXT: Unwind Codes:
CHECK-NEXT: 0x0e: UOP_AllocLarge 8454128
CHECK-NEXT: 0x07: UOP_AllocLarge 8190
CHECK-NEXT: 0x00: UOP_PushMachFrame w/o error code

46
tools/llvm-objdump/COFFDump.cpp
View File

@ -227,48 +227,6 @@ static void printCOFFSymbolAddress(llvm::raw_ostream &Out,
Out << format(" + 0x%04x", Disp); Out << format(" + 0x%04x", Disp);
} }
// Prints import tables. The import table is a table containing the list of
// DLL name and symbol names which will be linked by the loader.
static void printImportTables(const COFFObjectFile *Obj) {
outs() << "The Import Tables:\n";
error_code ec;
for (import_directory_iterator i = Obj->getImportDirectoryBegin(),
e = Obj->getImportDirectoryEnd();
i != e; i = i.increment(ec)) {
if (ec)
return;
const import_directory_table_entry *Dir;
StringRef Name;
if (i->getImportTableEntry(Dir)) return;
if (i->getName(Name)) return;
outs() << format(" lookup %08x time %08x fwd %08x name %08x addr %08x\n\n",
static_cast<uint32_t>(Dir->ImportLookupTableRVA),
static_cast<uint32_t>(Dir->TimeDateStamp),
static_cast<uint32_t>(Dir->ForwarderChain),
static_cast<uint32_t>(Dir->NameRVA),
static_cast<uint32_t>(Dir->ImportAddressTableRVA));
outs() << " DLL Name: " << Name << "\n";
outs() << " Hint/Ord Name\n";
const COFF::ImportLookupTableEntry32 *entry;
if (i->getImportLookupEntry(entry))
return;
for (; entry->data; ++entry) {
if (entry->isOrdinal()) {
outs() << format(" % 6d\n", entry->getOrdinal());
continue;
}
uint16_t Hint;
StringRef Name;
if (Obj->getHintName(entry->getHintNameRVA(), Hint, Name))
return;
outs() << format(" % 6d ", Hint) << Name << "\n";
}
outs() << "\n";
}
}
void llvm::printCOFFUnwindInfo(const COFFObjectFile *Obj) { void llvm::printCOFFUnwindInfo(const COFFObjectFile *Obj) {
const coff_file_header *Header; const coff_file_header *Header;
if (error(Obj->getCOFFHeader(Header))) return; if (error(Obj->getCOFFHeader(Header))) return;
@ -395,7 +353,3 @@ void llvm::printCOFFUnwindInfo(const COFFObjectFile *Obj) {
} }
} }
} }
void llvm::printCOFFFileHeader(const object::ObjectFile *Obj) {
printImportTables(dyn_cast<const COFFObjectFile>(Obj));
}

12
tools/llvm-objdump/llvm-objdump.cpp
View File

@ -770,14 +770,6 @@ static void PrintUnwindInfo(const ObjectFile *o) {
} }
} }
static void printPrivateFileHeader(const ObjectFile *o) {
if (o->isELF()) {
printELFFileHeader(o);
} else if (o->isCOFF()) {
printCOFFFileHeader(o);
}
}
static void DumpObject(const ObjectFile *o) { static void DumpObject(const ObjectFile *o) {
outs() << '\n'; outs() << '\n';
outs() << o->getFileName() outs() << o->getFileName()
@ -795,8 +787,8 @@ static void DumpObject(const ObjectFile *o) {
PrintSymbolTable(o); PrintSymbolTable(o);
if (UnwindInfo) if (UnwindInfo)
PrintUnwindInfo(o); PrintUnwindInfo(o);
if (PrivateHeaders) if (PrivateHeaders && o->isELF())
printPrivateFileHeader(o); printELFFileHeader(o);
} }
/// @brief Dump each object file in \a a; /// @brief Dump each object file in \a a;

3
tools/llvm-objdump/llvm-objdump.h
View File

@ -34,8 +34,7 @@ void DumpBytes(StringRef bytes);
void DisassembleInputMachO(StringRef Filename); void DisassembleInputMachO(StringRef Filename);
void printCOFFUnwindInfo(const object::COFFObjectFile* o); void printCOFFUnwindInfo(const object::COFFObjectFile* o);
void printELFFileHeader(const object::ObjectFile *o); void printELFFileHeader(const object::ObjectFile *o);
void printCOFFFileHeader(const object::ObjectFile *o);
} // end namespace llvm }
#endif #endif