void CCOF2ASM::MakeListLabels() {
// Attach names to all image directories
SCOFF_ImageDirAddress dir;
uint32 i;
for (i = 0; i < NumImageDirs; i++) {
if (GetImageDir(i, &dir)) {
// Found a directory. Make label for it
Disasm.AddSymbol(ASM_SEGMENT_IMGREL, dir.VirtualAddress, 4, 0, 1, 0, dir.Name);
}
}
}
void FftWaveUi::InitWidget()
{
xyz_rbtn_ = new QRadioButton("XYZ");
x_rbtn_ = new QRadioButton("X");
y_rbtn_ = new QRadioButton("Y");
z_rbtn_ = new QRadioButton("Z");
QButtonGroup* bgroup = new QButtonGroup;
bgroup->addButton(xyz_rbtn_);
bgroup->addButton(x_rbtn_);
bgroup->addButton(y_rbtn_);
bgroup->addButton(z_rbtn_);
QString dir;
GetImageDir(dir);
back_tbtn_ = new QToolButton;
back_tbtn_->setIcon(QIcon(dir + IMG_BACK));
back_tbtn_->setIconSize(QSize(24, 24));
xyz_rbtn_->setChecked(true);
fft_image_ = new FftImage;
close_btn_ = new QPushButton(STRING_CLOSE);
}
void CCOFF::PrintImportExport() {
// Print imported and exported symbols
// Table directory address
SCOFF_ImageDirAddress dir;
uint32 i; // Index into OrdinalTable and NamePointerTable
uint32 Ordinal; // Index into ExportAddressTable
uint32 Address; // Virtual address of exported symbol
uint32 NameOffset; // Section offset of symbol name
uint32 SectionOffset; // Section offset of table
const char * Name; // Name of symbol
// Check if 64 bit
int Is64bit = OptionalHeader->h64.Magic == COFF_Magic_PE64;
// Exported names
if (GetImageDir(0, &dir)) {
// Beginning of export section is export directory
SCOFF_ExportDirectory * pExportDirectory = &Get<SCOFF_ExportDirectory>(dir.FileOffset);
// Find ExportAddressTable
SectionOffset = pExportDirectory->ExportAddressTableRVA - dir.VirtualAddress;
if (SectionOffset == 0 || SectionOffset >= dir.MaxOffset) {
// Points outside section
err.submit(2035); return;
}
uint32 * pExportAddressTable = &Get<uint32>(dir.FileOffset + SectionOffset);
// Find ExportNameTable
SectionOffset = pExportDirectory->NamePointerTableRVA - dir.VirtualAddress;
if (SectionOffset == 0 || SectionOffset >= dir.MaxOffset) {
// Points outside section
err.submit(2035); return;
}
uint32 * pExportNameTable = &Get<uint32>(dir.FileOffset + SectionOffset);
// Find ExportOrdinalTable
SectionOffset = pExportDirectory->OrdinalTableRVA - dir.VirtualAddress;
if (SectionOffset == 0 || SectionOffset >= dir.MaxOffset) {
// Points outside section
err.submit(2035); return;
}
uint16 * pExportOrdinalTable = &Get<uint16>(dir.FileOffset + SectionOffset);
// Get further properties
uint32 NumExports = pExportDirectory->AddressTableEntries;
uint32 NumExportNames = pExportDirectory->NamePointerEntries;
uint32 OrdinalBase = pExportDirectory->OrdinalBase;
// Print exported names
printf("\n\nExported symbols:");
// Loop through export tables
for (i = 0; i < NumExports; i++) {
Address = 0;
Name = "(None)";
// Get ordinal from table
Ordinal = pExportOrdinalTable[i];
// Address table is indexed by ordinal
if (Ordinal < NumExports) {
Address = pExportAddressTable[Ordinal];
}
// Find name if there is a name list entry
if (i < NumExportNames) {
NameOffset = pExportNameTable[i] - dir.VirtualAddress;
if (NameOffset && NameOffset < dir.MaxOffset) {
Name = &Get<char>(dir.FileOffset + NameOffset);
}
}
// Print ordinal, address and name
printf("\n Ordinal %3i, Address %6X, Name %s",
Ordinal + OrdinalBase, Address, Name);
}
}
// Imported names
if (GetImageDir(1, &dir)) {
// Print imported names
printf("\n\nImported symbols:");
// Pointer to current import directory entry
SCOFF_ImportDirectory * ImportEntry = &Get<SCOFF_ImportDirectory>(dir.FileOffset);
// Pointer to current import lookup table entry
int32 * LookupEntry = 0;
// Pointer to current hint/name table entry
SCOFF_ImportHintName * HintNameEntry;
// Loop through import directory until null entry
while (ImportEntry->DLLNameRVA) {
// Get DLL name
NameOffset = ImportEntry->DLLNameRVA - dir.VirtualAddress;
if (NameOffset < dir.MaxOffset) {
Name = &Get<char>(dir.FileOffset + NameOffset);
}
else {
Name = "Error";
}
// Print DLL name
printf("\nFrom %s", Name);
// Get lookup table
SectionOffset = ImportEntry->ImportLookupTableRVA;
if (SectionOffset == 0) SectionOffset = ImportEntry->ImportAddressTableRVA;
if (SectionOffset == 0) continue;
SectionOffset -= dir.VirtualAddress;
if (SectionOffset >= dir.MaxOffset) break; // Out of range
LookupEntry = &Get<int32>(dir.FileOffset + SectionOffset);
// Loop through lookup table
while (LookupEntry[0]) {
if (LookupEntry[Is64bit] < 0) {
// Imported by ordinal
printf("\n Ordinal %i", uint16(LookupEntry[0]));
}
else {
// Find entry in hint/name table
SectionOffset = (LookupEntry[0] & 0x7FFFFFFF) - dir.VirtualAddress;;
if (SectionOffset >= dir.MaxOffset) continue; // Out of range
HintNameEntry = &Get<SCOFF_ImportHintName>(dir.FileOffset + SectionOffset);
// Print name
printf("\n %04X %s", HintNameEntry->Hint, HintNameEntry->Name);
// Check if exported
if (HintNameEntry->Hint) {
// printf(", Export entry %i", HintNameEntry->Hint);
}
}
// Loop next
LookupEntry += Is64bit ? 2 : 1;
}
// Loop next
ImportEntry++;
}
}
}
// Debug dump
void CCOFF::Dump(int options) {
uint32 i, j;
if (options & DUMP_FILEHDR) {
// File header
printf("\nDump of PE/COFF file %s", FileName);
printf("\n-----------------------------------------------");
printf("\nFile size: %i", GetDataSize());
printf("\nFile header:");
printf("\nMachine: %s", Lookup(COFFMachineNames,FileHeader->Machine));
printf("\nTimeDate: 0x%08X", FileHeader->TimeDateStamp);
printf(" - %s", timestring(FileHeader->TimeDateStamp));
printf("\nNumber of sections: %2i", FileHeader->NumberOfSections);
printf("\nNumber of symbols: %2i", FileHeader->NumberOfSymbols);
printf("\nOptional header size: %i", FileHeader->SizeOfOptionalHeader);
printf("\nFlags: 0x%04X", FileHeader->Flags);
// May be removed:
printf("\nSymbol table offset: %i", FileHeader->PSymbolTable);
printf("\nString table offset: %i", FileHeader->PSymbolTable + FileHeader->NumberOfSymbols * SIZE_SCOFF_SymTableEntry);
printf("\nSection headers offset: %i", (uint32)sizeof(SCOFF_FileHeader) + FileHeader->SizeOfOptionalHeader);
// Optional header
if (OptionalHeader) {
printf("\n\nOptional header:");
if (OptionalHeader->h32.Magic != COFF_Magic_PE64) {
// 32 bit optional header
printf("\nMagic number: 0x%X", OptionalHeader->h32.Magic);
printf("\nSize of code: 0x%X", OptionalHeader->h32.SizeOfCode);
printf("\nSize of uninitialized data: 0x%X", OptionalHeader->h32.SizeOfInitializedData);
printf("\nAddress of entry point: 0x%X", OptionalHeader->h32.AddressOfEntryPoint);
printf("\nBase of code: 0x%X", OptionalHeader->h32.BaseOfCode);
printf("\nBase of data: 0x%X", OptionalHeader->h32.BaseOfData);
printf("\nImage base: 0x%X", OptionalHeader->h32.ImageBase);
printf("\nSection alignment: 0x%X", OptionalHeader->h32.SectionAlignment);
printf("\nFile alignment: 0x%X", OptionalHeader->h32.FileAlignment);
printf("\nSize of image: 0x%X", OptionalHeader->h32.SizeOfImage);
printf("\nSize of headers: 0x%X", OptionalHeader->h32.SizeOfHeaders);
printf("\nDll characteristics: 0x%X", OptionalHeader->h32.DllCharacteristics);
printf("\nSize of stack reserve: 0x%X", OptionalHeader->h32.SizeOfStackReserve);
printf("\nSize of stack commit: 0x%X", OptionalHeader->h32.SizeOfStackCommit);
printf("\nSize of heap reserve: 0x%X", OptionalHeader->h32.SizeOfHeapReserve);
printf("\nSize of heap commit: 0x%X", OptionalHeader->h32.SizeOfHeapCommit);
}
else {
// 64 bit optional header
printf("\nMagic number: 0x%X", OptionalHeader->h64.Magic);
printf("\nSize of code: 0x%X", OptionalHeader->h64.SizeOfCode);
printf("\nSize of uninitialized data: 0x%X", OptionalHeader->h64.SizeOfInitializedData);
printf("\nAddress of entry point: 0x%X", OptionalHeader->h64.AddressOfEntryPoint);
printf("\nBase of code: 0x%X", OptionalHeader->h64.BaseOfCode);
printf("\nImage base: 0x%08X%08X", HighDWord(OptionalHeader->h64.ImageBase), uint32(OptionalHeader->h64.ImageBase));
printf("\nSection alignment: 0x%X", OptionalHeader->h64.SectionAlignment);
printf("\nFile alignment: 0x%X", OptionalHeader->h64.FileAlignment);
printf("\nSize of image: 0x%X", OptionalHeader->h64.SizeOfImage);
printf("\nSize of headers: 0x%X", OptionalHeader->h64.SizeOfHeaders);
printf("\nDll characteristics: 0x%X", OptionalHeader->h64.DllCharacteristics);
printf("\nSize of stack reserve: 0x%08X%08X", HighDWord(OptionalHeader->h64.SizeOfStackReserve), uint32(OptionalHeader->h64.SizeOfStackReserve));
printf("\nSize of stack commit: 0x%08X%08X", HighDWord(OptionalHeader->h64.SizeOfStackCommit), uint32(OptionalHeader->h64.SizeOfStackCommit));
printf("\nSize of heap reserve: 0x%08X%08X", HighDWord(OptionalHeader->h64.SizeOfHeapReserve), uint32(OptionalHeader->h64.SizeOfHeapReserve));
printf("\nSize of heap commit: 0x%08X%08X", HighDWord(OptionalHeader->h64.SizeOfHeapCommit), uint32(OptionalHeader->h64.SizeOfHeapCommit));
}
// Data directories
SCOFF_ImageDirAddress dir;
for (i = 0; i < NumImageDirs; i++) {
if (GetImageDir(i, &dir)) {
printf("\nDirectory %2i, %s:\n Address 0x%04X, Size 0x%04X, Section %i, Offset 0x%04X",
i, dir.Name,
dir.VirtualAddress, dir.Size, dir.Section, dir.SectionOffset);
}
}
}
}
if ((options & DUMP_STRINGTB) && FileHeader->PSymbolTable && StringTableSize > 4) {
// String table
char * p = StringTable + 4;
uint32 nread = 4, len;
printf("\n\nString table:");
while (nread < StringTableSize) {
len = (int)strlen(p);
if (len > 0) {
printf("\n>>%s<<", p);
nread += len + 1;
p += len + 1;
}
}
}
// Symbol tables
if (options & DUMP_SYMTAB) {
// Symbol table (object file)
if (NumberOfSymbols) PrintSymbolTable(-1);
// Import and export tables (executable file)
if (OptionalHeader) PrintImportExport();
}
// Section headers
if (options & (DUMP_SECTHDR | DUMP_SYMTAB | DUMP_RELTAB)) {
for (j = 0; j < (uint32)NSections; j++) {
SCOFF_SectionHeader * SectionHeader = &SectionHeaders[j];
printf("\n\n%2i Section %s", j+1, GetSectionName(SectionHeader->Name));
//printf("\nFile offset of header: 0x%X", (int)((int8*)SectionHeader-buffer));
printf("\nVirtual size: 0x%X", SectionHeader->VirtualSize);
if (SectionHeader->VirtualAddress) {
printf("\nVirtual address: 0x%X", SectionHeader->VirtualAddress);}
if (SectionHeader->PRawData || SectionHeader->SizeOfRawData) {
printf("\nSize of raw data: 0x%X", SectionHeader->SizeOfRawData);
printf("\nRaw data pointer: 0x%X", SectionHeader->PRawData);
}
printf("\nCharacteristics: ");
PrintSegmentCharacteristics(SectionHeader->Flags);
// print relocations
if ((options & DUMP_RELTAB) && SectionHeader->NRelocations > 0) {
printf("\nRelocation entries: %i", SectionHeader->NRelocations);
printf("\nRelocation entries pointer: 0x%X", SectionHeader->PRelocations);
// Pointer to relocation entry
union {
SCOFF_Relocation * p; // pointer to record
int8 * b; // used for address calculation and incrementing
} Reloc;
Reloc.b = Buf() + SectionHeader->PRelocations;
printf("\nRelocations:");
for (i = 0; i < SectionHeader->NRelocations; i++) {
printf("\nAddr: 0x%X, symi: %i, type: %s",
Reloc.p->VirtualAddress,
Reloc.p->SymbolTableIndex,
(WordSize == 32) ? Lookup(COFF32RelNames,Reloc.p->Type) : Lookup(COFF64RelNames,Reloc.p->Type));
if (Reloc.p->Type < COFF32_RELOC_SEG12)
{
// Check if address is within file
if (SectionHeader->PRawData + Reloc.p->VirtualAddress < GetDataSize()) {
int32 addend = *(int32*)(Buf() + SectionHeader->PRawData + Reloc.p->VirtualAddress);
if (addend) printf(", Implicit addend: %i", addend);
}
else {
printf(". Error: Address is outside file");
}
}
PrintSymbolTable(Reloc.p->SymbolTableIndex);
Reloc.b += SIZE_SCOFF_Relocation; // Next relocation record
}
}
// print line numbers
if (SectionHeader->NLineNumbers > 0) {
printf("\nLine number entries: %i", SectionHeader->NLineNumbers);
printf(" Line number pointer: %i\nLines:", SectionHeader->PLineNumbers);
// Pointer to line number entry
union {
SCOFF_LineNumbers * p; // pointer to record
int8 * b; // used for address calculation and incrementing
} Linnum;
Linnum.b = Buf() + SectionHeader->PLineNumbers;
for (i = 0; i < SectionHeader->NLineNumbers; i++) {
if (Linnum.p->Line) { // Record contains line number
printf(" %i:%i", Linnum.p->Line, Linnum.p->Addr);
}
else { // Record contains function name
}
Linnum.b += SIZE_SCOFF_LineNumbers; // Next line number record
}
}
}
}
}
void WaveExplorerUi::CreateMenu()
{
QString dir;
GetImageDir(dir);
menu_ = new QMenu(this);
xyz_action_ = new QWidgetAction(this);
east_action_ = new QWidgetAction(this);
north_action_ = new QWidgetAction(this);
deep_action_ = new QWidgetAction(this);
tilt_to_dc_action_ = new QWidgetAction(this);
bandpass_action_ = new QWidgetAction(this);
notch_action_ = new QWidgetAction(this);
xyz_rbtn_ = new QRadioButton("XYZ");
x_rbtn_ = new QRadioButton("X");
y_rbtn_ = new QRadioButton("Y");
z_rbtn_ = new QRadioButton("Z");
tilt_to_dc_cbox_ = new QCheckBox(STRING_WAVEEXPLORER_TILT_TO_DC);
bandpass_cbox_ = new QCheckBox(STRING_WAVEEXPLORER_BANDPASS);
notch_cbox_ = new QCheckBox(STRING_FILTERSETUP_TRAPED_WAVE);
QButtonGroup* bg = new QButtonGroup(this);
bg->addButton(xyz_rbtn_);
bg->addButton(x_rbtn_);
bg->addButton(y_rbtn_);
bg->addButton(z_rbtn_);
min_label_ = new QLabel("Min");
max_label_ = new QLabel("Max");
min_dsbox_ = new QDoubleSpinBox;
max_dsbox_ = new QDoubleSpinBox;
min_dsbox_->setMinimum(0.01);
max_dsbox_->setMinimum(0.01);
min_dsbox_->setMaximum(QWIDGETSIZE_MAX);
max_dsbox_->setMaximum(QWIDGETSIZE_MAX);
SetBpParaEnabled(false);
QGridLayout* bp_layout_g = new QGridLayout;
bp_layout_g->addWidget(bandpass_cbox_, 0, 0, 1, 3);
bp_layout_g->addWidget(min_label_, 1, 1, 1, 1);
bp_layout_g->addWidget(min_dsbox_, 1, 2, 1, 3);
bp_layout_g->addWidget(max_label_, 2, 1, 1, 1);
bp_layout_g->addWidget(max_dsbox_, 2, 2, 1, 3);
bp_layout_g->setMargin(0);
bp_layout_g->setSpacing(0);
bp_wgt_ = new QWidget;
bp_wgt_->setLayout(bp_layout_g);
xyz_action_->setDefaultWidget(xyz_rbtn_);
east_action_->setDefaultWidget(x_rbtn_);
north_action_->setDefaultWidget(y_rbtn_);
deep_action_->setDefaultWidget(z_rbtn_);
tilt_to_dc_action_->setDefaultWidget(tilt_to_dc_cbox_);
bandpass_action_->setDefaultWidget(bp_wgt_);
notch_action_->setDefaultWidget(notch_cbox_);
xyz_rbtn_->setChecked(true);
xyz_rbtn_->setStyleSheet("color:red");
menu_->addAction(xyz_action_);
menu_->addAction(east_action_);
menu_->addAction(north_action_);
menu_->addAction(deep_action_);
menu_->addSeparator();
menu_->addAction(tilt_to_dc_action_);
menu_->addAction(bandpass_action_);
menu_->addAction(notch_action_);
}
void CCOF2ASM::MakeExportList() {
// Make exported symbols for executable files
// Define entry point
if (OptionalHeader->h32.AddressOfEntryPoint) {
Disasm.AddSymbol(ASM_SEGMENT_IMGREL, OptionalHeader->h32.AddressOfEntryPoint, 0, 0x83, 4, 0, "Entry_point");
}
// Get export table directory address
SCOFF_ImageDirAddress expdir;
// Exported names
if (!GetImageDir(0, &expdir)) {
// No export directory
return;
}
// Beginning of export section is export directory
SCOFF_ExportDirectory * pExportDirectory = &Get<SCOFF_ExportDirectory>(expdir.FileOffset);
// Find ExportAddressTable
uint32 ExportAddressTableOffset = pExportDirectory->ExportAddressTableRVA - expdir.VirtualAddress;
if (ExportAddressTableOffset == 0 || ExportAddressTableOffset >= expdir.MaxOffset) {
// Points outside section
err.submit(2035); return;
}
uint32 * pExportAddressTable = &Get<uint32>(expdir.FileOffset + ExportAddressTableOffset);
// Find ExportNameTable
uint32 ExportNameTableOffset = pExportDirectory->NamePointerTableRVA - expdir.VirtualAddress;
if (ExportNameTableOffset == 0 || ExportNameTableOffset >= expdir.MaxOffset) {
// Points outside section
err.submit(2035); return;
}
uint32 * pExportNameTable = &Get<uint32>(expdir.FileOffset + ExportNameTableOffset);
// Find ExportOrdinalTable
uint32 ExportOrdinalTableOffset = pExportDirectory->OrdinalTableRVA - expdir.VirtualAddress;
if (ExportOrdinalTableOffset == 0 || ExportOrdinalTableOffset >= expdir.MaxOffset) {
// Points outside section
err.submit(2035); return;
}
uint16 * pExportOrdinalTable = &Get<uint16>(expdir.FileOffset + ExportOrdinalTableOffset);
// Get further properties
uint32 NumExports = pExportDirectory->AddressTableEntries;
uint32 NumExportNames = pExportDirectory->NamePointerEntries;
uint32 OrdinalBase = pExportDirectory->OrdinalBase;
uint32 i; // Index into pExportOrdinalTable and pExportNameTable
uint32 Ordinal; // Index into pExportAddressTable
uint32 Address; // Image-relative address of symbol
uint32 NameOffset; // Section-relative address of name
uint32 FirstName = 0; // Image-relative address of first name table entry
const char * Name = 0; // Name of symbol
char NameBuffer[64]; // Buffer for making name
// Loop through export tables
for (i = 0; i < NumExports; i++) {
Address = 0;
Name = "?";
// Get ordinal from table
Ordinal = pExportOrdinalTable[i];
// Address table is indexed by ordinal
if (Ordinal < NumExports) {
Address = pExportAddressTable[Ordinal];
}
// Find name if there is a name list entry
if (i < NumExportNames) {
NameOffset = pExportNameTable[i] - expdir.VirtualAddress;
if (NameOffset && NameOffset < expdir.MaxOffset) {
Name = &Get<char>(expdir.FileOffset + NameOffset);
if (FirstName == 0) FirstName = pExportNameTable[i];
}
}
else {
// No name. Make name from ordinal number
sprintf(NameBuffer, "Ordinal_%i", Ordinal + OrdinalBase);
Name = NameBuffer;
}
// Define symbol
Disasm.AddSymbol(ASM_SEGMENT_IMGREL, Address, 0, 0x83, 4, 0, Name);
}
// Make label for export section
Disasm.AddSymbol(ASM_SEGMENT_IMGREL, expdir.VirtualAddress, 4, 3, 2, 0, "Export_tables");
// Make labels for export tables
Disasm.AddSymbol(ASM_SEGMENT_IMGREL, ExportAddressTableOffset - expdir.FileOffset + expdir.VirtualAddress, 4, 3, 2, 0, "Export_address_table");
Disasm.AddSymbol(ASM_SEGMENT_IMGREL, ExportOrdinalTableOffset - expdir.FileOffset + expdir.VirtualAddress, 4, 3, 2, 0, "Export_ordinal_table");
Disasm.AddSymbol(ASM_SEGMENT_IMGREL, ExportNameTableOffset - expdir.FileOffset + expdir.VirtualAddress, 4, 3, 2, 0, "Export_name_pointer_table");
Disasm.AddSymbol(ASM_SEGMENT_IMGREL, FirstName, 1, 1, 2, 0, "Export_name_table");
}
void CCOF2ASM::MakeImportList() {
// Make imported symbols for executable files
// Find import table
SCOFF_ImageDirAddress impdir;
if (!GetImageDir(1, &impdir)) {
// No import table found
return;
}
// Beginning of import section is import directory
SCOFF_ImportDirectory * pImportDirectory = &Get<SCOFF_ImportDirectory>(impdir.FileOffset);
// Check if 64 bit
int Is64bit = OptionalHeader->h64.Magic == COFF_Magic_PE64; // 1 if 64 bit
uint32 EntrySize = Is64bit ? 8 : 4; // Size of address table entries
uint32 NameOffset; // Offset to name
const char * SymbolName; // Name of symbol
const char * DLLName; // Name of DLL containing symbol
char NameBuffer[64]; // Buffer for creating name of ordinal symbols
uint32 SectionOffset; // Section-relative address of current entry
uint32 HintNameOffset; // Section-relative address of hint/name table
uint32 FirstHintNameOffset = 0; // First HintNameOffset = start of hint/name table
uint32 AddressTableOffset; // Offset of import address table relative to import lookup table
// Pointer to current import directory entry
SCOFF_ImportDirectory * ImportEntry = pImportDirectory;
// Pointer to current import lookup table entry
int32 * LookupEntry = 0;
// Pointer to current hint/name table entry
SCOFF_ImportHintName * HintNameEntry;
// Loop through import directory until null entry
while (ImportEntry->DLLNameRVA) {
// Get DLL name
NameOffset = ImportEntry->DLLNameRVA - impdir.VirtualAddress;
if (NameOffset < impdir.MaxOffset) {
DLLName = &Get<char>(impdir.FileOffset + NameOffset);
}
else {
DLLName = "?";
}
// Get lookup table
SectionOffset = ImportEntry->ImportLookupTableRVA;
if (SectionOffset == 0) SectionOffset = ImportEntry->ImportAddressTableRVA;
if (SectionOffset == 0) continue;
// Get distance from import lookup table to import address table
AddressTableOffset = ImportEntry->ImportAddressTableRVA - SectionOffset;
// Section relative address
SectionOffset -= impdir.VirtualAddress;
if (SectionOffset >= impdir.MaxOffset) break; // Out of range
// Loop through lookup table
while (1) {
// Pointer to lookup table entry
LookupEntry = &Get<int32>(impdir.FileOffset + SectionOffset);
// End when entry is empty
if (!LookupEntry[0]) break;
if (LookupEntry[Is64bit] < 0) {
// Imported by ordinal. Give it a name
strncpy(NameBuffer, DLLName, 20);
// Remove dot from name
char * dot = strchr(NameBuffer,'.');
if (dot) *dot = 0;
// Add ordinal number to name
sprintf(NameBuffer+strlen(NameBuffer), "_Ordinal_%i", uint16(LookupEntry[0]));
SymbolName = NameBuffer;
}
else {
// Find entry in hint/name table
HintNameOffset = (LookupEntry[0] & 0x7FFFFFFF) - impdir.VirtualAddress;
if (HintNameOffset >= impdir.MaxOffset) goto LOOPNEXT; // Out of range
if (!FirstHintNameOffset) FirstHintNameOffset = HintNameOffset;
HintNameEntry = &Get<SCOFF_ImportHintName>(impdir.FileOffset + HintNameOffset);
// Get name
SymbolName = HintNameEntry->Name;
}
// Add symbol
Disasm.AddSymbol(ASM_SEGMENT_IMGREL, impdir.VirtualAddress + SectionOffset + AddressTableOffset,
EntrySize, 0xC, 0x20, 0, SymbolName, DLLName);
// Loop next
LOOPNEXT:
SectionOffset += EntrySize;
}
// Loop next
ImportEntry++;
}
// Make label for import name table
if (FirstHintNameOffset) {
Disasm.AddSymbol(ASM_SEGMENT_IMGREL, impdir.VirtualAddress + FirstHintNameOffset, 1, 1, 1, 0, "Import_name_table");
}
}
void CCOF2ASM::MakeDynamicRelocations() {
// Make dynamic base relocations for executable files
// Find base relocation table
SCOFF_ImageDirAddress reldir;
if (!GetImageDir(5, &reldir)) {
// No base relocation table found
return;
}
SCOFF_BaseRelocationBlock * pBaseRelocation; // Start of dynamic base relocation section
// Beginning of .reloc section is first base relocation block
pBaseRelocation = &Get<SCOFF_BaseRelocationBlock>(reldir.FileOffset);
uint32 ROffset = 0; // Offset into .reloc section
uint32 BlockEnd; // Offset of end of current block
uint32 PageOffset; // Image-relative address of begin of page
// Make pointer to header or entry in .reloc section
union {
SCOFF_BaseRelocationBlock * header;
SCOFF_BaseRelocation * entry;
int8 * b;
} Pointer;
// Loop throung .reloc section
while (ROffset < reldir.MaxOffset) {
// Set Pointer to current position
Pointer.header = pBaseRelocation;
Pointer.b += ROffset;
// Read base relocation block
PageOffset = Pointer.header->PageRVA;
BlockEnd = ROffset + Pointer.header->BlockSize;
// Read entries in this block
ROffset += sizeof(SCOFF_BaseRelocationBlock);
Pointer.b += sizeof(SCOFF_BaseRelocationBlock);
// Loop through entries
while (ROffset < BlockEnd) {
// Set Pointer to current position
Pointer.header = pBaseRelocation;
Pointer.b += ROffset;
if (Pointer.entry->Type == COFF_REL_BASED_HIGHLOW) {
// Add relocation record, 32 bit
// Section = ASM_SEGMENT_IMGREL means offset is image-relative
// Type = 0x20 means already relocated to image base
Disasm.AddRelocation(ASM_SEGMENT_IMGREL, Pointer.entry->Offset + PageOffset, 0, 0x21, 4, 0);
}
else if (Pointer.entry->Type == COFF_REL_BASED_DIR64) {
// Add relocation record, 64 bit
Disasm.AddRelocation(ASM_SEGMENT_IMGREL, Pointer.entry->Offset + PageOffset, 0, 0x21, 8, 0);
}
// Go to next
ROffset += sizeof(SCOFF_BaseRelocation);
if (Pointer.entry->Type == COFF_REL_BASED_HIGHADJ) ROffset += sizeof(SCOFF_BaseRelocation);
}
// Finished block. Align by 4
ROffset = (ROffset + 3) & uint32(-4);
}
}
