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); } }