Subversion Repositories forwardcom

/****************************  converters.h   ********************************
* Author:        Agner Fog
* Date created:  2017-04-17
* Last modified: 2018-03-30
* Version:       1.10
* Project:       Binary tools for ForwardCom instruction set
* Module:        converters.h
* Description:
* Header file for file conversion classes.
*
* Copyright 2006-2020 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.
 
*****************************************************************************/
 
#pragma once
 
// Buffer for symbol names during assembly, linking, and library operations
// symbolNameBuffer is made global in order to make it accessible to bool operator < (ElfFWC_Sym2 const &, ElfFWC_Sym2 const &)
// It is defined in assem1.cpp
extern CTextFileBuffer symbolNameBuffer;      // Buffer for symbol names 
 
 
// Structure for string index entry in library
struct SSymbolEntry {
    uint32_t name;                        // name as offset into symbolNameBuffer
    uint32_t library;                     // library index (1-based) or 0 if object file
    uint32_t member;                      // module or library member offset
    uint32_t sectioni;                    // section index within module
    uint32_t symindex;                    // index into symbol table
    uint16_t st_other;                    // attributes: STV_SECT_ATTR
    uint8_t  st_type;                     // symbol type
    uint8_t  st_bind;                     // symbol binding
    uint8_t  status;                      // 1: has no value yet. 2: has been matched. 4: unresolved
};
 
// operator for sorting string entries
inline bool operator < (SSymbolEntry const & a, SSymbolEntry const & b) {
    int compare = strcmp(symbolNameBuffer.getString(a.name), symbolNameBuffer.getString(b.name));
    if (compare) return compare < 0;             // compare names
    if ((a.st_bind | b.st_bind) & STB_IGNORE) return false;    // ignore binding
    return (a.st_bind & STB_WEAK) < (b.st_bind & STB_WEAK);    // strong before weak
}
 
// operator for comparing string entries. Compares name only
inline bool operator == (SSymbolEntry const & a, SSymbolEntry const & b) {
    return strcmp(symbolNameBuffer.getString(a.name), symbolNameBuffer.getString(b.name)) == 0;
}
 
 
// Class CConverter contains the input file. 
// It redirects the task specified on the command line to some other converter class
class CConverter : public CFileBuffer {
public:
    CConverter();                       // Constructor
    void go();                          // Main action
protected:
    void readInputFile();               // read input file
    void dumpELF();                     // Dump x86 ELF file
    void disassemble();                 // Disassemble ForwardCom ELF file
    void assemble();                    // Assemble ForwardCom assembly file
    void link();                        // Link object files into executable file
    void emulate();                     // emulate and run executable file
    void lib();                         // Build or modify function libraries
};
 
// Class for interpreting and dumping ELF files
class CELF : public CFileBuffer {
public:
    CELF();                                       // Default constructor
    void parseFile();                             // Parse file buffer
    void dump(int options);                       // Dump file
    void makeLinkMap(FILE * stream);              // Write a link map
    void listSymbols(CMemoryBuffer * strings, CDynamicArray<SSymbolEntry> * index, uint32_t m, uint32_t l, int scope); // Make list of public and external symbols
    ElfFwcSym * getSymbol(uint32_t symindex);     // Get a symbol record
    int  split();                                 // Split ELF file into containers
    int  join(ElfFwcEhdr * header);               // Join containers into ELF file
    void reset();                                 // Reset everything
    uint32_t addSection(ElfFwcShdr & section, CMemoryBuffer const & strings, CMemoryBuffer const & data); // Add section header and section data
    void extendSection(ElfFwcShdr & section, CMemoryBuffer const & data);                 // Extend previously added section
    void insertFiller(uint64_t numBytes);         // Insert alignment fillers between sections
    void addModuleNames(CDynamicArray<uint32_t>& moduleNames, CDynamicArray<uint32_t>& libraryNames);
    void updateModuleNames(CDynamicArray<ElfFwcShdr> &newSectionHeaders, CMemoryBuffer &newShStrtab); // Put module names and library names into section string table for relinkable sections
    // Add module name and library name to relinkable sections
    void addProgHeader(ElfFwcPhdr & header);      // Add program header
    uint32_t addSymbol(ElfFwcSym & symbol, CMemoryBuffer const & strings);               // Add a symbol
    void addRelocation(ElfFwcReloc & relocation); // Add a relocation
    void removePrivateSymbols(int debugOptions);  // remove local symbols and adjust relocation records with new symbol indexes
    CDynamicArray<ElfFwcShdr> const & getSectionHeaders() const { return sectionHeaders; }  // get sectionHeaders for copying. Used by disassembly listing
    CDynamicArray<ElfFwcSym> const & getSymbols() const { return symbols; }                // get symbols buffer for copying
    CDynamicArray<ElfFwcReloc> const & getRelocations() const { return relocations; }      // get relocations buffer for copying
    CMemoryBuffer const & getStringBuffer() const { return stringBuffer; }                  // get string buffer for copying
    CMemoryBuffer const & getDataBuffer() const { return dataBuffer; }                      // get data buffer for copying
    CFileBuffer & makeHexBuffer();                // make hexadecimal code file
    CDynamicArray<ElfFwcSym> symbols;             // List of symbols
    uint32_t moduleName;                          // Name of file or module as index into cmd.fileNameBuffer
    uint32_t library;                             // Library index if this module is extracted from a library
    bool relinkable;                              // module can be replaced by relinking
    const char * symbolName(uint32_t index);      // Get name of symbol
protected:
    char * secStringTable;                        // Section header string table
    uint32_t secStringTableLen;                   // Length of section header string table
    uint32_t nSections;                           // Number of sections
    int sectionHeaderSize;                        // Size of each section header
    uint32_t symbolTableOffset;                   // Offset to symbol table
    uint32_t symbolTableEntrySize;                // Entry size of symbol table
    uint32_t symbolTableEntries;                  // Number of symbols
    uint32_t symbolStringTableOffset;             // Offset to symbol string table
    uint32_t symbolStringTableSize;               // Size of symbol string table
    ElfFwcEhdr fileHeader;                        // Copy of file header
    CDynamicArray<ElfFwcShdr> sectionHeaders;     // Copy of section headers
    CDynamicArray<ElfFwcPhdr> programHeaders;     // Copy of program headers   
    CDynamicArray<ElfFwcReloc> relocations;       // List of relocations
    CMemoryBuffer stringBuffer;                   // String buffer with names of symbols and sections
    CMemoryBuffer dataBuffer;                     // Raw data for sections
    CDynamicArray<uint32_t> moduleNames;          // module names as index into cmd.fileNameBuffer. used by join function
    CDynamicArray<uint32_t> libraryNames;         // library names as index into cmd.stringBuffer. used by join function
    friend class CLinker;                         // Give linker access to internal buffers
    friend void operator >> (CELF & a, CELF & b); // Transfer ownership of buffer
    friend void operator << (CELF & a, CELF & b); // Transfer ownership of buffer
};
 
// transfer ownership of data buffer and properties except what can be generated by the split function
inline void operator >> (CELF & a, CELF & b) {
    static_cast<CFileBuffer&>(a) >> static_cast<CFileBuffer&>(b);
    b.moduleName = a.moduleName;
    b.library = a.library;
    b.relinkable = a.relinkable;
}
 
inline void operator << (CELF & b, CELF & a) {
    a >> b;
}