XenOn/kolibrios-fun
1
1
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Wiki Activity
a772f5b96f
kolibrios-fun/programs/develop/objconv/converters.h

530 lines
34 KiB
C
Raw Normal View History

Added objconv port. git-svn-id: svn://kolibrios.org@9683 a494cfbc-eb01-0410-851d-a64ba20cac60
2022-02-06 12:09:00 +01:00
/**************************** converters.h ********************************
* Author: Agner Fog
* Date created: 2006-07-15
* Last modified: 2008-05-25
* Project: objconv
* Module: converters.h
* Description:
* Header file for file conversion classes.
*
* Copyright 2006-2008 GNU General Public License http://www.gnu.org/licenses
*****************************************************************************/
/******************************* Classes ********************************
This header file declares various classes for interpreting and converting
different types of object files. These classes are all derived from the
container class CFileBuffer, declared in containers.h.
See containers.h for an explanation of the container classes and the
operators >> and << which can transfer a data buffer from an object of one
class to an object of another class.
*****************************************************************************/
#ifndef CONVERTERS_H
#define CONVERTERS_H
// Structure for string index entry in library
struct SStringEntry {
uint32 String; // Offset to string
uint32 Member; // Library member
};
// Class CResponseFileBuffer is used for storage of a command line response file
class CResponseFileBuffer : public CFileBuffer {
public:
CResponseFileBuffer(char const * filename); // Constructor
~CResponseFileBuffer(); // Destructor
CResponseFileBuffer * next; // Linked list if more than one buffer
};
// Class for deciding what to do with input file
// Its memory buffer contains the input file and later the output file
class CMain : public CFileBuffer {
public:
CMain(); // Constructor
void Go(); // Do whatever the command line parameters say
};
// Class CConverter is used for converting or dumping a file of any type
class CConverter : public CFileBuffer {
public:
CConverter(); // Constructor
void Go(); // Do whatever the command line parameters say
protected:
void DumpCOF(); // Dump PE/COFF file
void DumpELF(); // Dump ELF file
void DumpMACHO(); // Dump Mach-O file
void DumpOMF(); // Dump OMF file
void ParseMACUnivBin(); // Dump Mac universal binary
void COF2COF(); // Make changes in PE file
void COF2ELF(); // Convert PE/COFF to ELF file
void COF2OMF(); // Convert PE/COFF to OMF file
void ELF2ELF(); // Make changes in ELF file
void ELF2COF(); // Convert ELF to PE file
void ELF2MAC(); // Convert ELF to Mach-O file
void OMF2COF(); // Convert OMF file to PE/COFF
void COF2ASM(); // Disassemble PE/COFF file
void ELF2ASM(); // Disassemble ELF file
void MAC2ELF(); // Convert Mach-O file to ELF file
void MAC2MAC(); // Make changes in Mach-O file
void MAC2ASM(); // Disassemble Mach-O file
void OMF2ASM(); // Disassemble OMF file
};
// Class for interpreting and dumping PE/COFF files
class CCOFF : public CFileBuffer {
public:
CCOFF(); // Default constructor
void ParseFile(); // Parse file buffer
void Dump(int options); // Dump file
void PrintSymbolTable(int symnum); // Dump symbol table entries
void PrintImportExport(); // Print imported and exported symbols
static void PrintSegmentCharacteristics(uint32 flags); // Print segment characteristics
char const * GetSymbolName(int8* Symbol); // Get symbol name from 8 byte entry
char const * GetSectionName(int8* Symbol); // Get section name from 8 byte entry
const char * GetFileName(SCOFF_SymTableEntry *); // Get file name from records in symbol table
const char * GetShortFileName(SCOFF_SymTableEntry*);// Same as above. Strips path before filename
char const * GetStorageClassName(uint8 sc); // Get storage class name
void PublicNames(CMemoryBuffer * Strings, CSList<SStringEntry> * Index, int m); // Make list of public names
int GetImageDir(uint32 n, SCOFF_ImageDirAddress * dir); // Find address of image directory for executable files
protected:
CArrayBuf<SCOFF_SectionHeader> SectionHeaders;// Copy of section headers
int NSections; // Number of sections
SCOFF_FileHeader * FileHeader; // File header
SCOFF_SymTableEntry * SymbolTable; // Pointer to symbol table (for object files)
char * StringTable; // Pointer to string table (for object files)
uint32 StringTableSize; // Size of string table (for object files)
int NumberOfSymbols; // Number of symbol table entries (for object files)
uint64 ImageBase; // Image base (for executable files)
SCOFF_OptionalHeader * OptionalHeader; // Optional header (for executable files)
SCOFF_IMAGE_DATA_DIRECTORY * pImageDirs; // Pointer to image directories (for executable files)
uint32 NumImageDirs; // Number of image directories (for executable files)
uint32 EntryPoint; // Entry point (for executable files)
};
// Class for interpreting and dumping ELF files. Has templates for 32 and 64 bit version
template <class TFileHeader, class TSectionHeader, class TSymbol, class TRelocation>
class CELF : public CFileBuffer {
public:
CELF(); // Default constructor
void ParseFile(); // Parse file buffer
void Dump(int options); // Dump file
void PublicNames(CMemoryBuffer * Strings, CSList<SStringEntry> * Index, int m); // Make list of public names
protected:
const char * SymbolName(uint32 index); // Get name of symbol
TFileHeader FileHeader; // Copy of file header
char * SecStringTable; // Section header string table
uint32 SecStringTableLen; // Length of section header string table
uint32 NSections; // Number of sections
int SectionHeaderSize; // Size of each section header
CArrayBuf<TSectionHeader> SectionHeaders; // Copy of section headers
uint32 SymbolTableOffset; // Offset to symbol table
uint32 SymbolTableEntrySize; // Entry size of symbol table
uint32 SymbolTableEntries; // Number of symbols
uint32 SymbolStringTableOffset; // Offset to symbol string table
uint32 SymbolStringTableSize; // Size of symbol string table
};
// Class for interpreting and dumping Mach-O files
class COMF : public CFileBuffer {
public:
COMF(); // Default constructor
void ParseFile(); // Parse file buffer
void Dump(int options); // Dump file
void PublicNames(CMemoryBuffer * Strings, CSList<SStringEntry> * Index, int m); // Make list of public names
protected:
uint32 NumRecords; // Number of records
CSList<SOMFRecordPointer> Records; // Record pointers (List is 0-based)
CMemoryBuffer NameBuffer; // Store segment names and symbol names
CSList<uint32> LocalNameOffset; // Offset into NameBuffer of segment names by name index
CSList<uint32> SegmentNameOffset; // Offset into NameBuffer of segment names by segment index
CSList<uint32> SymbolNameOffset; // Offset into NameBuffer of external symbol names
CSList<uint32> GroupNameOffset; // Offset into NameBuffer of group names
char * GetLocalName(uint32 i); // Get segment name by name index
uint32 GetLocalNameO(uint32 i); // Get segment name by converting name index offset into NameBuffer
const char * GetSegmentName(uint32 i); // Get segment name by segment index
const char * GetSymbolName(uint32 i); // Get external symbol name
const char * GetGroupName(uint32 i); // Get group name by index
static const char * GetRecordTypeName(uint32 i);// Get OMF record type name
void DumpRecordTypes(); // Dump summary of records
void DumpNames(); // Dump local names records
void DumpSymbols(); // Dump public and external names records
void DumpSegments(); // Dump segment records
void DumpRelocations(); // Dump fixup records
void DumpComments(); // Dump coment records
};
// Class for interpreting and dumping Mach-O files. Has templates for 32 and 64 bit version
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
class CMACHO : public CFileBuffer {
public:
CMACHO(); // Default constructor
void ParseFile(); // Parse file buffer
void Dump(int options); // Dump file
void PublicNames(CMemoryBuffer * Strings, CSList<SStringEntry> * Index, int m); // Make list of public names
protected:
TMAC_header FileHeader; // Copy of file header
uint64 ImageBase; // Image base for executable file
uint32 SegmentOffset; // File offset of segment
uint32 SegmentSize; // Size of segment
uint32 SectionHeaderOffset; // File offset of section headers
uint32 NumSections; // Number of sections
uint32 SymTabOffset; // File offset of symbol table
uint32 SymTabNumber; // Number of entries in symbol table
uint32 StringTabOffset; // File offset of string table
uint32 StringTabSize; // Size of string table
uint32 ilocalsym; // index to local symbols
uint32 nlocalsym; // number of local symbols
uint32 iextdefsym; // index to public symbols
uint32 nextdefsym; // number of public symbols
uint32 iundefsym; // index to external symbols
uint32 nundefsym; // number of external symbols
uint32 IndirectSymTabOffset; // file offset to the indirect symbol table
uint32 IndirectSymTabNumber; // number of indirect symbol table entries
};
// Class for parsing Macintosh universal binary
class CMACUNIV : public CFileBuffer {
public:
CMACUNIV(); // Default constructor
void Go(int options); // Apply command line options to all components
};
// class CCOF2ELF handles conversion from PE/COFF file to ELF file. Has templates for 32 and 64 bit version
template <class TELF_Header, class TELF_SectionHeader, class TELF_Symbol, class TELF_Relocation>
class CCOF2ELF : public CCOFF {
public:
CCOF2ELF(); // Constructor
void Convert(); // Do the conversion
protected:
void MakeSegments(); // Convert subfunction: Segments
void MakeSymbolTable(); // Convert subfunction: Symbol table and string tables
void MakeRelocationTables(); // Convert subfunction: Relocation tables
void MakeBinaryFile(); // Convert subfunction: Putting sections together
int symtab; // Symbol table section number
int shstrtab; // Section name string table section number
int strtab; // Object name string table section number
int stabstr; // Debug string table section number
int NumSectionsNew; // Number of sections generated for 'to' file
int MaxSectionsNew; // Number of section buffers allocated for 'to' file
CArrayBuf<CMemoryBuffer> NewSections; // Buffers for building each section
CArrayBuf<TELF_SectionHeader> NewSectionHeaders;// Buffer for temporary section headers
CArrayBuf<int> NewSectIndex; // Buffers for array of new section indices
CArrayBuf<int> NewSymbolIndex; // Buffers for array of new symbol indices
CFileBuffer ToFile; // File buffer for ELF file
TELF_Header NewFileHeader; // New file header
};
// class CCOF2OMF handles conversion from PE/COFF file to OMF file
class CCOF2OMF : public CCOFF {
public:
CCOF2OMF(); // Constructor
void Convert(); // Do the conversion
protected:
void MakeSegmentList(); // Make temporary segment conversion list
void MakeSymbolList(); // Make temporary symbol conversion list
void MakeRelocationsList(); // Make temporary list of relocations (fixups) and sort it
void MakeLNAMES(); // Make THEADR and LNAMES records
void MakeSEGDEF(); // Make SEGDEF and GRPDEF records
void MakeEXTDEF(); // Make EXTDEF records
void MakePUBDEF(); // Make PUBDEF records
void MakeLEDATA(); // Make LEDATA, LIDATA and FIXUPP records
void MakeMODEND(); // Make MODEND record and finish file
CArrayBuf<SOMFSegmentList> SectionBuffer; // Summarize old sections. Translate section index to segment index
CArrayBuf<SOMFSymbolList> SymbolBuffer; // Translate old symbol index to new public/external index
CSList<SOMFRelocation> RelocationBuffer; // Summarize and sort relocations
CMemoryBuffer NameBuffer; // Temporary storage of text strings
COMFFileBuilder ToFile; // File buffer for new OMF file
int NumSegments; // Number of segments in new file
int SectionBufferNum; // Number of entries in SectionBuffer
uint32 NumPublicSymbols; // Number of public symbols in new file
uint32 NumExternalSymbols; // Number of external symbols in new file
uint32 NumRelocations; // Number of entries in RelocationBuffer
};
// class COMF2COF handles conversion from OMF file to PE/COFF file
class COMF2COF : public COMF {
public:
COMF2COF(); // Constructor
void Convert(); // Do the conversion
protected:
// Convert subfunctions:
void MakeFileHeader(); // File header
void MakeSymbolTable1(); // Make symbol table and string table entries for file and segments
void MakeSymbolTable2(); // Make symbol table and string table entries for external symbols
void MakeSymbolTable3(); // Make symbol table and string table entries for public symbols
void MakeSymbolTable4(); // Make symbol table and string table entries for communal symbols
void MakeSymbolTable5(); // Make symbol table and string table entries for local symbols
void MakeSections(); // Make sections and relocation tables
void MakeBinaryFile(); // Putting sections together
void CheckUnsupportedRecords(); // Make warnings if file containes unsupported record types
int NumSectionsNew; // Number of sections in new file
CFileBuffer ToFile; // File buffer for PE/COFF file
CSList<SCOFF_SymTableEntry> NewSymbolTable; // New symbol table entries
CSList<SCOFF_SectionHeader> NewSectionHeaders;// New section headers
CMemoryBuffer NewStringTable; // Buffer for building new string table
CMemoryBuffer NewData; // Raw data for each section in new file and its relocation table
CSList<uint32> SegmentTranslation; // Translate old segment number to new symbol table index
CSList<uint32> ExtdefTranslation; // Translate old external symbol number to new symbol table index
CSList<SOMFLocalSymbol> LocalSymbols; // List for assigning names to unnamed local symbols
SCOFF_FileHeader NewFileHeader; // New file header
};
// class CELF2COF handles conversion from ELF file to PE/COFF file. Has templates for 32 and 64 bit version
template <class TELF_Header, class TELF_SectionHeader, class TELF_Symbol, class TELF_Relocation>
class CELF2COF : public CELF<ELFSTRUCTURES> {
public:
CELF2COF(); // Constructor
void Convert(); // Do the conversion
protected:
void MakeFileHeader(); // Convert subfunction: File header
void MakeSectionsIndex(); // Convert subfunction: Make section index translation table
void MakeSections(); // Convert subfunction: Make sections and relocation tables
void MakeSymbolTable(); // Convert subfunction: Symbol table and string tables
void HideUnusedSymbols(); // Convert subfunction: Hide unused symbols
void MakeBinaryFile(); // Convert subfunction: Putting sections together
int NumSectionsNew; // Number of sections in new file
CArrayBuf<int32> NewSectIndex; // Array of new section indices
CArrayBuf<int32> SymbolsUsed; // Array of new symbol indices
CSList<int32> NewSymbolIndex; // Buffer for array of new symbol indices
CMemoryBuffer NewSymbolTable; // Buffer for building new symbol table
CMemoryBuffer NewStringTable; // Buffer for building new string table
CMemoryBuffer NewRawData; // Buffer for building new raw data area
uint32 RawDataOffset; // File offset for raw data
CFileBuffer ToFile; // File buffer for PE/COFF file
SCOFF_FileHeader NewFileHeader; // New file header
};
// class CELF2MAC handles conversion from ELF file to Mach-O file
template <class TELF_Header, class TELF_SectionHeader, class TELF_Symbol, class TELF_Relocation,
class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
class CELF2MAC : public CELF<ELFSTRUCTURES> {
public:
CELF2MAC(); // Constructor
void Convert(); // Do the conversion
protected:
void MakeFileHeader(); // Convert subfunction: File header
void MakeSectionsIndex(); // Convert subfunction: Make section index translation table
void MakeSections(); // Convert subfunction: Make sections and relocation tables
void MakeSymbolTable(); // Convert subfunction: Symbol table and string tables
void FindUnusedSymbols(); // Convert subfunction: Check if symbols used, remove unused symbols
void MakeBinaryFile(); // Convert subfunction: Putting sections together
// Translate relocations, seperate function for 32 and 64 bits:
void Elf2MacRelocations(Elf32_Shdr &, MAC_section_32 &, uint32 NewRawDataOffset, uint32 oldsec);
void Elf2MacRelocations(Elf64_Shdr &, MAC_section_64 &, uint32 NewRawDataOffset, uint32 oldsec);
int GetImagebaseSymbol(); // Symbol table index of __mh_execute_header
CFileBuffer ToFile; // File buffer for new Mach-O file
CMemoryBuffer NewRawData; // Buffer for building new raw data area
CMemoryBuffer NewRelocationTab; // Buffer for new relocation tables
CMemoryBuffer NewStringTable; // Buffer for building new string table
CMemoryBuffer UnnamedSymbolsTable; // Buffer for assigning names to unnamed symbols
CArrayBuf<int> NewSectIndex; // Array of new section indices
CArrayBuf<MInt> NewSectOffset; // Array of new section offsets
CArrayBuf<int> OldSymbolScope; // Table of symbol bindings: 0 = local, 1 = public, 2 = external
CArrayBuf<int> OldSymbolUsed; // Check if symbol is used
MacSymbolTableBuilder<TMAC_nlist, MInt> NewSymTab[3]; // New symbol tables for local, public, external symbols
uint32 NumSymbols[4]; // Accumulated number of entries in each NewSymTab[]
uint32 NewSectHeadOffset; // File offset to first section header
uint32 NewSymtabOffset; // File offset to symtab command
int NumSectionsNew; // Number of sections in new file
uint32 RawDataOffset; // Offset to raw data in old file
uint32 NumOldSymbols; // Number of symbols in old file
uint32 CommandOffset; // Offset to first load command = segment header
};
// class MAC2ELF handles conversion from Mach-O file to ELF file
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt,
class TELF_Header, class TELF_SectionHeader, class TELF_Symbol, class TELF_Relocation>
class CMAC2ELF : public CMACHO<MACSTRUCTURES> {
public:
CMAC2ELF(); // Constructor
void Convert(); // Do the conversion
protected:
void MakeSegments(); // Convert subfunction: Segments
void MakeSymbolTable(); // Convert subfunction: Symbol table and string tables
void MakeRelocationTables(MAC_header_32&); // Convert subfunction: Relocation tables, 32-bit version
void MakeRelocationTables(MAC_header_64&); // Convert subfunction: Relocation tables, 64-bit version
void MakeImportTables(); // Convert subfunction: Fill import tables
void MakeBinaryFile(); // Convert subfunction: Putting sections together
void TranslateAddress(MInt addr, uint32 & section, uint32 & offset); // Translate address to section + offset
uint32 MakeGOTEntry(int symbol); // Make entry in fake GOT for symbol
void MakeGOT(); // Make fake Global Offset Table
int symtab; // Symbol table section number
int shstrtab; // Section name string table section number
int strtab; // Object name string table section number
int stabstr; // Debug string table section number
uint32 NumSectionsNew; // Number of sections generated for 'to' file
uint32 MaxSectionsNew; // Number of section buffers allocated for 'to' file
uint32 HasGOT; // Contains references to global offset table
int FakeGOTSection; // Fake GOT section number
int FakeGOTSymbol; // Symbol index for fake GOT
TELF_Header NewFileHeader; // New file header
CArrayBuf<CMemoryBuffer> NewSections; // Buffers for building each section
CArrayBuf<TELF_SectionHeader> NewSectionHeaders;// Array of temporary section headers
CArrayBuf<int> NewSectIndex; // Array of new section indices
CArrayBuf<int> NewSymbolIndex; // Array of new symbol indices
CArrayBuf<int> SectionSymbols; // Array of new symbol indices for sections
CFileBuffer ToFile; // File buffer for ELF file
CSList<int> GOTSymbols; // List of symbols needing GOT entry
};
// class CCOF2COF handles symbol changes in a PE/COFF file
class CCOF2COF : public CCOFF {
public:
CCOF2COF(); // Constructor
void Convert(); // Do the conversion
protected:
void MakeSymbolTable(); // Convert subfunction: Symbol table and string tables
void MakeBinaryFile(); // Convert subfunction: Putting sections together
CMemoryBuffer NewSymbolTable; // Buffers for building new symbol table
CMemoryBuffer NewStringTable; // Buffers for building new string table
CFileBuffer ToFile; // File buffer for modified PE file
};
// class CELF2ELF handles symbol changes in ELF file. Has templates for 32 and 64 bit version
template <class TELF_Header, class TELF_SectionHeader, class TELF_Symbol, class TELF_Relocation>
class CELF2ELF : public CELF<ELFSTRUCTURES> {
public:
CELF2ELF(); // Constructor
void Convert(); // Do the conversion
protected:
void MakeSymbolTable(); // Convert subfunction: Symbol table and string tables
void ChangeSections(); // Convert subfunction: Change section names if needed
void MakeBinaryFile(); // Convert subfunction: Putting sections together
uint32 isymtab[2]; // static and dynamic symbol table section number
uint32 istrtab[4]; // string table section number: symbols, dynamic symbols, sections, debug
CMemoryBuffer NewSymbolTable[2]; // Buffers for building new symbol tables: static, dynamic
CMemoryBuffer NewStringTable[4]; // Buffers for building new string tables: symbols, dynamic symbols, sections, debug
CArrayBuf<uint32> NewSymbolIndex; // Array for translating old to new symbol indices
uint32 NumOldSymbols; // Size of NewSymbolIndex table
uint32 FirstGlobalSymbol; // Index to first global symbol in .symtab
CFileBuffer ToFile; // File buffer for modified PE file
};
// class CMAC2MAC handles symbol changes in Mach-O file. Has templates for 32 and 64 bit version
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
class CMAC2MAC : public CMACHO<MACSTRUCTURES> {
public:
CMAC2MAC(); // Constructor
void Convert(); // Do the conversion
protected:
void MakeSymbolTable(); // Convert subfunction: Symbol table and string tables
void ChangeSegments(); // Convert subfunction: Change segment names if needed
void ChangeSections(uint32 HeaderOffset, uint32 Num);// Convert subfunction: Change section names and relocation records if needed
void ChangeImportTable(uint32 FileOffset, uint32 Num);// Convert subfunction: Change symbol indices in import table if needed
void MakeBinaryFile(); // Convert subfunction: Putting sections together
int NewSymbolIndex(int OldIndex); // Convert subfunction: Translate old to new symbol index
uint32 NewFileOffset(uint32 OldOffset); // Convert subfunction: Translate old to new file offset
MacSymbolTableBuilder<TMAC_nlist, MInt> NewSymbols[3];// Buffers for building new symbol tables: local, public, external
CMemoryBuffer NewSymbolTable; // Buffer for building new symbol table
CMemoryBuffer NewStringTable; // Buffer for building new string table
CFileBuffer ToFile; // File buffer for modified PE file
uint32 NumOldSymbols; // Size of NewSymbolIndex table
uint32 NewIlocalsym; // index to local symbols
uint32 NewNlocalsym; // number of local symbols
uint32 NewIextdefsym; // index to public symbols
uint32 NewNextdefsym; // number of public symbols
uint32 NewIundefsym; // index to external symbols
uint32 NewNundefsym; // number of external symbols
uint32 NewSymtabOffset; // Offset to new symbol table
uint32 NewStringtabOffset; // Offset to new string table
uint32 NewStringtabEnd; // Offset to end of new string table
uint32 OldTablesEnd; // End of old symbol table and string table
int32 SizeDifference; // Size of new file minus size of old file
};
// class CCOF2ASM handles disassembly of PE/COFF file
class CCOF2ASM : public CCOFF {
public:
CCOF2ASM(); // Constructor
void Convert(); // Do the conversion
protected:
CDisassembler Disasm; // Disassembler
void MakeSectionList(); // Make Sections list and Relocations list in Disasm
void MakeSymbolList(); // Make Symbols list in Disasm
void MakeDynamicRelocations(); // Make dynamic base relocations for executable files
void MakeImportList(); // Make imported symbols for executable files
void MakeExportList(); // Make exported symbols for executable files
void MakeListLabels(); // Attach names to all image directories
};
// class CELF2ASM handles disassembly of ELF file
template <class TELF_Header, class TELF_SectionHeader, class TELF_Symbol, class TELF_Relocation>
class CELF2ASM : public CELF<ELFSTRUCTURES> {
public:
CELF2ASM(); // Constructor
void Convert(); // Do the conversion
protected:
CDisassembler Disasm; // Disassembler
CArrayBuf<int32>SectionNumberTranslate; // Translate section numbers in source file to section numbers in asm file
CArrayBuf<uint32>SymbolTableOffset; // Addend to add to symbol number for each symbol table
int64 ImageBase; // Image base if executable file
uint32 ExeType; // File type: 0 = object, 1 = DLL/shared object, 2 = executable
uint32 NumSymbols; // Number of symbols defined
void FindImageBase(); // Find image base
void MakeSectionList(); // Make Sections list in Disasm
void MakeSymbolList(); // Make Symbols list in Disasm
void MakeRelocations(); // Make relocations for object and executable files
void MakeImportList(); // Make imported symbols for executable files
void MakeExportList(); // Make exported symbols for executable files
void MakeListLabels(); // Attach names to all image directories
};
// class CMAC2ASM handles disassembly of Mach-O file
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
class CMAC2ASM : public CMACHO<MACSTRUCTURES> {
public:
CMAC2ASM(); // Constructor
void Convert(); // Do the conversion
protected:
void MakeSectionList(); // Make Sections list in Disasm
void MakeSymbolList(); // Make Symbols list in Disasm
void MakeRelocations(); // Make relocation list in Disasm
void MakeImports(); // Make symbol entries for imported symbols
CDisassembler Disasm; // Disassembler
CMemoryBuffer StringBuffer; // Buffer for making section names
CSList<MAC_SECT_WITH_RELOC> RelocationQueue; // List of relocation tables
CSList<TMAC_section*> ImportSections; // List of sections needing extra symbols: import tables, literals, etc.
};
// class COMF2ASM handles disassembly of OMF object files
class COMF2ASM : public COMF {
public:
COMF2ASM(); // Constructor
void Convert(); // Do the conversion
protected:
void CountSegments(); // Make temporary Segments table
void MakeExternalSymbolsTable(); // Make external symbols in Disasm
void MakePublicSymbolsTable(); // Make symbol table entries for public symbols
void MakeCommunalSymbolsTable(); // Make symbol table entries for communal symbols
void MakeGroupDefinitions(); // Make segment group definitions
void MakeSegmentList(); // Make Segments list in Disasm
void MakeRelocations(int32 Segment, uint32 RecNum, uint32 SOffset, uint32 RSize, uint8 * SData);// Make relocation list in Disasm
CDisassembler Disasm; // Disassembler
CSList<SOMFSegment> Segments; // Name, size, etc. of all segments
CSList<uint32> ExtdefTranslation; // Translate old external symbol number to disasm symbol table index
CSList<uint32> PubdefTranslation; // Translate old public symbol number to disasm symbol table index
CMemoryBuffer SegmentData; // Binary segment data
int32 NumSegments; // Number of segments
int32 FirstComDatSection; // First COMDAT section. All sections before this are SEGDEF segments
};
#endif // #ifndef CONVERTERS_H
Copy Permalink