Subversion Repositories forwardcom

/****************************    elf.cpp    *********************************

* Author:        Agner Fog

* Date created:  2006-07-18

* Last modified: 2021-05-28

* Version:       1.11

* Project:       Binary tools for ForwardCom instruction set

* Module:        elf.cpp

* Description:

* Module for manipulating ForwardCom ELF files

*

* Class CELF is used for manipulating ELF files.

* It includes functions for reading, interpreting, dumping files,

* splitting into containers or joining containers into an ELF file

*

* This code is based on the ForwardCom ELF specification in elf_forwardcom.h.

* I have included limited support for x86-64 ELF (e_machine == EM_X86_64) for

* testing purposes. This may be removed.

*

* Copyright 2006-2021 GNU General Public License v. 3 http://www.gnu.org/licenses

*****************************************************************************/

#include "stdafx.h"

// File class names

SIntTxt ELFFileClassNames[] = {

    {ELFCLASSNONE,      "None"},

    {ELFCLASS32,        "32-bit object"},

    {ELFCLASS64,        "64-bit object"}

};

// Data encoding names

SIntTxt ELFDataEncodeNames[] = {

    {ELFDATANONE,       "None"},

    {ELFDATA2LSB,       "Little Endian"},

    {ELFDATA2MSB,       "Big Endian"}

};

// ABI names

SIntTxt ELFABINames[] = {

    {ELFOSABI_SYSV,      "System V"},

    {ELFOSABI_HPUX,      "HP-UX"},

    {ELFOSABI_ARM,       "ARM"},

    {ELFOSABI_STANDALONE,"Embedded"},

    {ELFOSABI_FORWARDCOM,"ForwardCom"}

};

// File type names

SIntTxt ELFFileTypeNames[] = {

    {ET_NONE,           "None"},

    {ET_REL,            "Relocatable"},

    {ET_EXEC,           "Executable"},

    {ET_DYN,            "Shared object"},

    {ET_CORE,           "Core file"}

};

// File header flag names

SIntTxt ELFFileFlagNames[] = {

    {EF_INCOMPLETE,     "Has unresolved references"},

    {EF_RELINKABLE,     "Relinkable"},

    {EF_RELOCATE,       "Relocate when loading"},

    {EF_POSITION_DEPENDENT, "Position dependent"}

};

// Section type names

SIntTxt ELFSectionTypeNames[] = {

    {SHT_NULL,          "None"},

    {SHT_PROGBITS,      "Program data"},

    {SHT_SYMTAB,        "Symbol table"},

    {SHT_STRTAB,        "String table"},

    {SHT_RELA,          "Relocation w addends"},

    {SHT_NOTE,          "Notes"},

    {SHT_NOBITS,        "uinitialized"},

    {SHT_COMDAT,        "Communal section"},

    {SHT_LIST,          "List"}

//    {SHT_HASH,          "Symbol hash table"},

//    {SHT_DYNAMIC,       "Dynamic linking info"},

//    {SHT_REL,           "Relocation entries"},

//    {SHT_SHLIB,         "Reserved"},

//    {SHT_DYNSYM,        "Dynamic linker symbol table"},

//    {SHT_GROUP,         "Section group"},

};

// Program header type names

SIntTxt ELFPTypeNames[] = {

     {PT_NULL,        "Unused"},

     {PT_LOAD,        "Loadable program segment"},

     {PT_DYNAMIC,     "Dynamic linking information"},

     {PT_INTERP,      "Program interpreter"},

     {PT_NOTE,        "Auxiliary information"},

     {PT_SHLIB,       "Reserved"},

     {PT_PHDR,        "Entry for header table itself"}

};

// Section flag names

SIntTxt ELFSectionFlagNames[] = {

    {SHF_EXEC,          "executable"},

    {SHF_WRITE,         "writeable"},

    {SHF_READ,          "readable"},

    {SHF_ALLOC,         "allocate"},

    {SHF_IP,            "IP"},

    {SHF_DATAP,         "DATAP"},

    {SHF_THREADP,       "THREADP"},

    {SHF_MERGE,         "merge"},

    {SHF_STRINGS,       "strings"},

    {SHF_INFO_LINK,     "sh_info"},

    {SHF_EVENT_HND,     "event handler"},

    {SHF_DEBUG_INFO,    "debug info"},

    {SHF_COMMENT,       "comment"},

    {SHF_RELINK,        "relinkable"},

    {SHF_AUTOGEN,       "auto-generated"}

};

// Symbol binding names

SIntTxt ELFSymbolBindingNames[] = {

    {STB_LOCAL,         "local"},

    {STB_GLOBAL,        "global"},

    {STB_WEAK,          "weak"},

    {STB_WEAK2,         "weak2"},

    {STB_UNRESOLVED,    "unresolved"}

};

// Symbol Type names

SIntTxt ELFSymbolTypeNames[] = {

    {STT_NOTYPE,        "None"},

    {STT_OBJECT,        "Object"},

    {STT_FUNC,          "Function"},

    {STT_SECTION,       "Section"},

    {STT_FILE,          "File"},

    {STT_CONSTANT,      "Constant"}

};

// Symbol st_other info names

SIntTxt ELFSymbolInfoNames[] = {

    {STV_EXEC,          "executable"},

    {STV_READ,          "read"},

    {STV_WRITE,         "write"},

    {STV_IP,            "ip"},

    {STV_DATAP,         "datap"},

    {STV_THREADP,       "threadp"},

    {STV_REGUSE,        "reguse"},

    {STV_FLOAT,         "float"},

    {STV_STRING,        "string"},

    {STV_UNWIND,        "unwind"},

    {STV_DEBUG,         "debug"},

    {STV_COMMON,        "communal"},

    {STV_RELINK,        "relinkable"},

    {STV_MAIN,          "main"},

    {STV_EXPORTED,      "exported"},

    {STV_THREAD,        "thread"}

};

// Relocation type names x86 64 bit

SIntTxt ELF64RelocationNames[] = {

    {R_X86_64_NONE,      "None"},

    {R_X86_64_64,        "Direct 64 bit"},

    {R_X86_64_PC32,      "Self relative 32 bit signed"},

    {R_X86_64_GOT32,     "32 bit GOT entry"},

    {R_X86_64_PLT32,     "32 bit PLT address"},

    {R_X86_64_COPY,      "Copy symbol at runtime"},

    {R_X86_64_GLOB_DAT,  "Create GOT entry"},

    {R_X86_64_JUMP_SLOT, "Create PLT entry"},

    {R_X86_64_RELATIVE,  "Adjust by program base"},

    {R_X86_64_GOTPCREL,  "32 bit signed pc relative offset to GOT"},

    {R_X86_64_32,        "Direct 32 bit zero extended"},

    {R_X86_64_32S,       "Direct 32 bit sign extended"},

    {R_X86_64_16,        "Direct 16 bit zero extended"},

    {R_X86_64_PC16,      "16 bit sign extended pc relative"},

    {R_X86_64_8,         "Direct 8 bit sign extended"},

    {R_X86_64_PC8,       "8 bit sign extended pc relative"},

    {R_X86_64_IRELATIVE, "32 bit ref. to indirect function PLT"}

};

// Relocation type names for ForwardCom

SIntTxt ELFFwcRelocationTypes[] = {

    {R_FORW_ABS,        "Absolute address"},

    {R_FORW_SELFREL,    "Self relative"},

    {R_FORW_IP_BASE,    "Relative to __ip_base"},

    {R_FORW_DATAP,      "Relative to __datap_base"},

    {R_FORW_THREADP,    "Relative to __threadp_base"},

    {R_FORW_REFP,       "Relative to arbitrary reference point"},

    {R_FORW_SYSFUNC,    "System function ID"},

    {R_FORW_SYSMODUL,   "System module ID"},

    {R_FORW_SYSCALL,    "System module and function ID"},

    {R_FORW_DATASTACK,  "Size of data stack"},

    {R_FORW_CALLSTACK,  "Size of call stack"},

    {R_FORW_REGUSE,     "Register use"}

};

// Relocation sizes for ForwardCom

SIntTxt ELFFwcRelocationSizes[] = {

    {R_FORW_NONE,       "None"},

    {R_FORW_8,          "8 bit"},

    {R_FORW_16,         "16 bit"},

    {R_FORW_24,         "24 bit"},

    {R_FORW_32,         "32 bit"},

    {R_FORW_64,         "64 bit"},

    {R_FORW_32LO,       "Low 16 of 32 bits"},

    {R_FORW_32HI,       "High 16 of 32 bits"},

    {R_FORW_64LO,       "Low 32 of 64 bits"},

    {R_FORW_64HI,       "High 32 of 64 bits"}

};

// Machine names

SIntTxt ELFMachineNames[] = {

    {EM_NONE,         "None"},     // No machine

    {EM_FORWARDCOM,   "ForwardCom"},

    {EM_M32,          "AT&T WE 32100"},

    {EM_SPARC,        "SPARC"},

    {EM_386,          "Intel x86"},

    {EM_68K,          "Motorola m68k"},

    {EM_88K,          "Motorola m88k"},

    {EM_860,          "MIPS R3000 big-endian"},

    {EM_MIPS,         "MIPS R3000 big-endian"},

    {EM_S370,         "IBM System/370"},

    {EM_MIPS_RS3_LE,  "NMIPS R3000 little-endianone"},

    {EM_PARISC,       "HPPA"},

    {EM_VPP500,       "Fujitsu VPP500"},

    {EM_SPARC32PLUS,  "Sun v8plus"},

    {EM_960,          "Intel 80960"},

    {EM_PPC,          "PowerPC"},

    {EM_PPC64,        "PowerPC 64-bit"},

    {EM_S390,         "IBM S390"},

    {EM_V800,         "NEC V800"},

    {EM_FR20,         "Fujitsu FR20"},

    {EM_RH32,         "TRW RH-32"},

    {EM_RCE,          "Motorola RCE"},

    {EM_ARM,          "ARM"},

    {EM_FAKE_ALPHA,   "Digital Alpha"},

    {EM_SH,           "Hitachi SH"},

    {EM_SPARCV9,      "SPARC v9 64-bit"},

    {EM_TRICORE,      "Siemens Tricore"},

    {EM_ARC,          "Argonaut RISC"},

    {EM_H8_300,       "Hitachi H8/300"},

    {EM_H8_300H,      "Hitachi H8/300H"},

    {EM_H8S,          "Hitachi H8S"},

    {EM_H8_500,       "EM_H8_500"},

    {EM_IA_64,        "Intel IA64"},

    {EM_MIPS_X,       "Stanford MIPS-X"},

    {EM_COLDFIRE,     "Motorola Coldfire"},

    {EM_68HC12,       "Motorola M68HC12"},

    {EM_MMA,          "Fujitsu MMA"},

    {EM_PCP,          "Siemens PCP"},

    {EM_NCPU,         "Sony nCPU"},

    {EM_NDR1,         "Denso NDR1"},

    {EM_STARCORE,     "Motorola Start*Core"},

    {EM_ME16,         "Toyota ME16"},

    {EM_ST100,        "ST100"},

    {EM_TINYJ,        "Tinyj"},

    {EM_X86_64,       "x86-64"},

    {EM_PDSP,         "Sony DSP"},

    {EM_FX66,         "Siemens FX66"},

    {EM_ST9PLUS,      "ST9+ 8/16"},

    {EM_ST7,          "ST7 8"},

    {EM_68HC16,       "MC68HC16"},

    {EM_68HC11,       "MC68HC11"},

    {EM_68HC08,       "MC68HC08"},

    {EM_68HC05,       "MC68HC05"},

    {EM_SVX,          "SVx"},

    {EM_AT19,         "ST19"},

    {EM_VAX,          "VAX"},

    {EM_CRIS,         "Axis"},

    {EM_JAVELIN,      "Infineon"},

    {EM_FIREPATH,     "Element 14"},

    {EM_ZSP,          "LSI Logic"},

    {EM_HUANY,        "Harvard"},

    {EM_PRISM,        "SiTera Prism"},

    {EM_AVR,          "Atmel AVR"},

    {EM_FR30,         "FR30"},

    {EM_D10V,         "D10V"},

    {EM_D30V,         "D30V"},

    {EM_V850,         "NEC v850"},

    {EM_M32R,         "M32R"},

    {EM_MN10300,      "MN10300"},

    {EM_MN10200,      "MN10200"},

    {EM_PJ,           "picoJava"},

    {EM_ALPHA,        "Alpha"}

};

// Class CELF members:

// Constructor

CELF::CELF() {

    zeroAllMembers(*this);

}

// ParseFile

void CELF::parseFile() {

    // Load and parse file buffer

    uint32_t i;

    if (dataSize() == 0) {

        nSections = 0;

        return;

    }

    fileHeader = *(ElfFwcEhdr*)buf();             // Copy file header

    nSections = fileHeader.e_shnum;

    sectionHeaders.setNum(nSections);            // Allocate space for section headers

    uint32_t symtabi = 0;                         // Index to symbol table

    // Find section headers

    sectionHeaderSize = fileHeader.e_shentsize;

    if (sectionHeaderSize <= 0) err.submit(ERR_ELF_RECORD_SIZE);

    uint32_t SectionOffset = uint32_t(fileHeader.e_shoff);

    // check header integrity

    if (fileHeader.e_phoff >= dataSize() || fileHeader.e_phoff + (uint32_t)fileHeader.e_phentsize * fileHeader.e_phnum > dataSize()) err.submit(ERR_ELF_INDEX_RANGE);

    if (fileHeader.e_shoff >= dataSize() || fileHeader.e_shoff + (uint32_t)fileHeader.e_shentsize * fileHeader.e_shnum > dataSize()) err.submit(ERR_ELF_INDEX_RANGE);

    if (fileHeader.e_shstrndx >= dataSize()) err.submit(ERR_ELF_INDEX_RANGE);

    if (err.number())

        return;

    for (i = 0; i < nSections; i++) {

        sectionHeaders[i] = get<ElfFwcShdr>(SectionOffset);

        // check section header integrity

        if (sectionHeaders[i].sh_offset > dataSize()

            || (sectionHeaders[i].sh_offset + sectionHeaders[i].sh_size > dataSize() && sectionHeaders[i].sh_type != SHT_NOBITS)

            || sectionHeaders[i].sh_offset + sectionHeaders[i].sh_entsize > dataSize()) {

            err.submit(ERR_ELF_INDEX_RANGE);

        }

        SectionOffset += sectionHeaderSize;

        if (sectionHeaders[i].sh_type == SHT_SYMTAB) {

            // Symbol table found

            symtabi = i;

        }

    }

    if (SectionOffset > dataSize()) err.submit(ERR_ELF_INDEX_RANGE);     // Section table points to outside file

    if (buf() && dataSize()) {  // string table

        uint64_t offset = sectionHeaders[fileHeader.e_shstrndx].sh_offset;

        secStringTable = (char*)buf() + uint32_t(offset);

        secStringTableLen = uint32_t(sectionHeaders[fileHeader.e_shstrndx].sh_size);

        if (offset > dataSize() || offset + secStringTableLen > dataSize()) err.submit(ERR_ELF_INDEX_RANGE);

    }

    // check section names

    for (i = 0; i < nSections; i++) {

        if (sectionHeaders[i].sh_name >= secStringTableLen) { err.submit(ERR_ELF_STRING_TABLE); break; }

    }

    if (symtabi) {

        // Save offset to symbol table

        uint64_t offset = sectionHeaders[symtabi].sh_offset;

        symbolTableOffset = (uint32_t)offset;

        symbolTableEntrySize = (uint32_t)(sectionHeaders[symtabi].sh_entsize); // Entry size of symbol table

        if (symbolTableEntrySize == 0) { err.submit(ERR_ELF_SYMTAB_MISSING); return; } // Avoid division by zero

        symbolTableEntries = uint32_t(sectionHeaders[symtabi].sh_size) / symbolTableEntrySize;

        if (offset > dataSize() || offset > 0xFFFFFFFFU || offset + sectionHeaders[symtabi].sh_entsize > dataSize()

            || offset + sectionHeaders[symtabi].sh_size > dataSize()) err.submit(ERR_ELF_INDEX_RANGE);

        // Find associated string table

        uint32_t stringtabi = sectionHeaders[symtabi].sh_link;

        if (stringtabi >= nSections) {

            err.submit(ERR_ELF_INDEX_RANGE);

            return;

        }

        offset = sectionHeaders[stringtabi].sh_offset;

        symbolStringTableOffset = (uint32_t)offset;

        symbolStringTableSize = (uint32_t)(sectionHeaders[stringtabi].sh_size);

        if (offset > dataSize() || offset > 0xFFFFFFFFU || offset + sectionHeaders[stringtabi].sh_size > dataSize()) err.submit(ERR_ELF_INDEX_RANGE);

        // check all symbol names

        int8_t * symtab = buf() + symbolTableOffset;

        uint32_t symname = 0;

        for (uint32_t symi = 0; symi < symbolTableEntries; symi++) {

            // Copy ElfFwcSym symbol or convert Elf64_Sym symbol

            if (fileHeader.e_machine == EM_FORWARDCOM) {

                symname = ((ElfFwcSym*)symtab)[symi].st_name;

            }

            else {

                // x64 type symbol table entry

                symname = ((Elf64_Sym*)symtab)[symi].st_name;

            }

            if (symname >= symbolStringTableSize) err.submit(ERR_ELF_STRING_TABLE);

        }

    }

}

// Dump

void CELF::dump(int options) {

    printf("\nDump of ELF file %s", cmd.getFilename(cmd.inputFile));

    if (options == 0) options = DUMP_FILEHDR;

    if (options & DUMP_FILEHDR) {

        // File header

        printf("\n-----------------------------------------------");

        printf("\nFile size: %i", dataSize());

        printf("\nFile header:");

        printf("\nFile class: %s, Data encoding: %s, ELF version %i, ABI: %s, ABI version %i",

            Lookup(ELFFileClassNames, fileHeader.e_ident[EI_CLASS]),

            Lookup(ELFDataEncodeNames, fileHeader.e_ident[EI_DATA]),

            fileHeader.e_ident[EI_VERSION],

            Lookup(ELFABINames, fileHeader.e_ident[EI_OSABI]),

            fileHeader.e_ident[EI_ABIVERSION]);

        printf("\nFile type: %s, Machine: %s, version: %i",

            Lookup(ELFFileTypeNames, fileHeader.e_type),

            Lookup(ELFMachineNames, fileHeader.e_machine),

            fileHeader.e_version);

        printf("\nNumber of sections: %2i", nSections);

        if (fileHeader.e_machine == EM_FORWARDCOM) {

            printf("\nip_base: 0x%X, datap_base: 0x%X, threadp_base: 0x%X, entry_point: 0x%X",

                (uint32_t)fileHeader.e_ip_base, (uint32_t)fileHeader.e_datap_base, (uint32_t)fileHeader.e_threadp_base, (uint32_t)fileHeader.e_entry);

        }

    }

    // Always show flags

    if (fileHeader.e_flags) {

        printf("\nFlags:");

        for (int i = 0; i < 32; i++) {

            if (fileHeader.e_flags & (1 << i)) {

                printf(" %s,", Lookup(ELFFileFlagNames, 1 << i));

            }

        }

    }

    if (options & DUMP_LINKMAP) {

        fprintf(stdout, "\nLink map:\n");

        makeLinkMap(stdout);

    }

    if (options & DUMP_RELINKABLE) {

        // Show names of relinkable modules and libraries

        CDynamicArray<SLCommand> mnames;  // list of relinkable modules

        CDynamicArray<SLCommand> lnames;  // list of relinkable libraries

        SLCommand nameRec;                // record containing name

        uint32_t r;                       // record index

        uint32_t sec;                     // section index

        const char * modName;             // module name

        const char * libName;             // library name

        // loop through sections

        for (sec = 0; sec < sectionHeaders.numEntries(); sec++) {

            ElfFwcShdr & secHdr = sectionHeaders[sec];

            if (secHdr.sh_type == 0) continue;

            if (secHdr.sh_flags & SHF_RELINK) {

                // section is relinkable

                if (secHdr.sh_library && secHdr.sh_library < secStringTableLen) {

                    libName = secStringTable + secHdr.sh_library;             // library name

                    nameRec.value = cmd.fileNameBuffer.pushString(libName);

                    lnames.addUnique(nameRec);                                // add only one instance to lnames

                }

                if (secHdr.sh_module && secHdr.sh_module < secStringTableLen) {

                    modName = secStringTable + secHdr.sh_module;              // module name

                    nameRec.value = cmd.fileNameBuffer.pushString(modName);

                    mnames.addUnique(nameRec);                                // add only one instance to mnames

                }

            }

        }

        if (lnames.numEntries()) {

            printf("\n\nRelinkable libraries:");

            for (r = 0; r < lnames.numEntries(); r++) {

                printf("\n   %s", cmd.getFilename((uint32_t)lnames[r].value));

            }

        }

        if (mnames.numEntries()) {

            printf("\n\nRelinkable modules:");

            for (r = 0; r < mnames.numEntries(); r++) {

                printf("\n   %s", cmd.getFilename((uint32_t)mnames[r].value));

            }

        }

    }

    if ((options & DUMP_SECTHDR) && fileHeader.e_phnum) {

        // Dump program headers

        printf("\n\nProgram headers:");

        uint32_t nProgramHeaders = fileHeader.e_phnum;

        uint32_t programHeaderSize = fileHeader.e_phentsize;

        if (nProgramHeaders && programHeaderSize <= 0) err.submit(ERR_ELF_RECORD_SIZE);

        uint32_t programHeaderOffset = (uint32_t)fileHeader.e_phoff;

        ElfFwcPhdr pHeader;

        for (uint32_t i = 0; i < nProgramHeaders; i++) {

            pHeader = get<ElfFwcPhdr>(programHeaderOffset);

            printf("\nProgram header Type: %s, flags 0x%X",

                Lookup(ELFPTypeNames, (uint32_t)pHeader.p_type), (uint32_t)pHeader.p_flags);

            printf("\noffset = 0x%X, vaddr = 0x%X, paddr = 0x%X, filesize = 0x%X, memsize = 0x%X, align = 0x%X",

                (uint32_t)pHeader.p_offset, (uint32_t)pHeader.p_vaddr, (uint32_t)pHeader.p_paddr, (uint32_t)pHeader.p_filesz, (uint32_t)pHeader.p_memsz, 1 << pHeader.p_align);

            programHeaderOffset += programHeaderSize;

            if (pHeader.p_filesz < 0x100 && (uint32_t)pHeader.p_offset < dataSize() && (pHeader.p_flags & SHF_STRINGS)) {

                printf("\nContents: %s", buf() + (int)pHeader.p_offset);

            }

        }

    }

    if (options & DUMP_SECTHDR) {

        // Dump section headers

        printf("\n\nSection headers:");

        for (uint32_t sc = 0; sc < nSections; sc++) {

            // Get copy of 32-bit header or converted 64-bit header

            ElfFwcShdr sheader = sectionHeaders[sc];

            uint32_t entrysize = (uint32_t)(sheader.sh_entsize);

            uint32_t namei = sheader.sh_name;

            if (namei >= secStringTableLen) { err.submit(ERR_ELF_STRING_TABLE); break; }

            printf("\n%2i Name: %-18s Type: %s", sc, secStringTable + namei,

                Lookup(ELFSectionTypeNames, sheader.sh_type));

            if (sheader.sh_flags) {

                printf("\n  Flags: 0x%X:", uint32_t(sheader.sh_flags));

                for (uint32_t fi = 1; fi != 0; fi <<= 1) {

                    if (uint32_t(sheader.sh_flags) & fi) {

                        printf(" %s", Lookup(ELFSectionFlagNames, fi));

                    }

                }

            }

            //if (sheader.sh_addr) 

                printf("\n  Address: 0x%X", uint32_t(sheader.sh_addr));

            if (sheader.sh_offset || sheader.sh_size) {

                printf("\n  FileOffset: 0x%X, Size: 0x%X",

                    uint32_t(sheader.sh_offset), uint32_t(sheader.sh_size));

            }

            if (sheader.sh_align) {

                printf("\n  Alignment: 0x%X", 1 << sheader.sh_align);

            }

            if (sheader.sh_entsize) {

                printf("\n  Entry size: 0x%X", uint32_t(sheader.sh_entsize));

                switch (sheader.sh_type) {

                /*

                case SHT_DYNAMIC:

                    printf("\n  String table: %i", sheader.sh_link);

                    break;

                case SHT_HASH:

                    printf("\n  Symbol table: %i", sheader.sh_link);

                    break; */

                case SHT_RELA: // case SHT_REL:

                    printf("\n  Symbol table: %i",

                        sheader.sh_link);

                    break;

                case SHT_SYMTAB: //case SHT_DYNSYM:

                    printf("\n  Symbol string table: %i, First global symbol: %i",

                        sheader.sh_link, sheader.sh_module);

                    break;

                default:

                    if (sheader.sh_link) {

                        printf("\n  Link: %i", sheader.sh_link);

                    }

                    if (sheader.sh_module) {

                        printf("\n  Info: %i", sheader.sh_module);

                    }

                }

            }

            if (sheader.sh_module && sheader.sh_module < secStringTableLen) {

                printf("\n  Module: %s", secStringTable + sheader.sh_module);

                if (sheader.sh_library) printf(", Library: %s", secStringTable + sheader.sh_library);

            }

            if (sheader.sh_type == SHT_STRTAB && (options & DUMP_STRINGTB)) {

                // Print string table

                printf("\n  String table:");

                char * p = (char*)buf() + uint32_t(sheader.sh_offset) + 1;

                uint32_t nread = 1, len;

                while (nread < uint32_t(sheader.sh_size)) {

                    len = (uint32_t)strlen(p);

                    printf(" >>%s<<", p);

                    nread += len + 1;

                    p += len + 1;

                }

            }

            if ((sheader.sh_type == SHT_SYMTAB) && (options & DUMP_SYMTAB)) {

                // Dump symbol table

                // Find associated string table

                if (sheader.sh_link >= (uint32_t)nSections) { err.submit(ERR_ELF_INDEX_RANGE); sheader.sh_link = 0; }

                uint64_t strtabOffset = sectionHeaders[sheader.sh_link].sh_offset;

                if (strtabOffset >= dataSize()) {

                    err.submit(ERR_ELF_INDEX_RANGE); return;

                }

                int8_t * strtab = buf() + strtabOffset;

                // Find symbol table

                uint32_t symtabsize = (uint32_t)(sheader.sh_size);

                int8_t * symtab = buf() + uint32_t(sheader.sh_offset);

                int8_t * symtabend = symtab + symtabsize;

                if (entrysize < sizeof(Elf64_Sym)) { err.submit(ERR_ELF_RECORD_SIZE); entrysize = sizeof(Elf64_Sym); }

                printf("\n  Symbols:");

                // Loop through symbol table

                int symi;  // Symbol number

                for (symi = 0; symtab < symtabend; symtab += entrysize, symi++) {

                    // Copy ElfFwcSym symbol or convert Elf64_Sym symbol

                    ElfFwcSym sym;

                    if (fileHeader.e_machine == EM_FORWARDCOM) {

                        sym = *(ElfFwcSym*)symtab;

                    }

                    else {

                        // Translate x64 type symbol table entry

                        Elf64_Sym sym64 = *(Elf64_Sym*)symtab;

                        sym.st_name = sym64.st_name;

                        sym.st_type = sym64.st_type;

                        sym.st_bind = sym64.st_bind;

                        sym.st_other = sym64.st_other;

                        sym.st_section = sym64.st_section;

                        sym.st_value = sym64.st_value;

                        sym.st_unitsize = (uint32_t)sym64.st_size;

                        sym.st_unitnum = 1;

                        sym.st_reguse1 = sym.st_reguse2 = 0;

                    }

                    int type = sym.st_type;

                    int binding = sym.st_bind;

                    if (strtabOffset + sym.st_name >= dataSize()) err.submit(ERR_ELF_INDEX_RANGE);

                    else if (*(strtab + sym.st_name)) {

                        printf("\n  %2i Name: %s,", symi, strtab + sym.st_name);

                    }

                    else {

                        printf("\n  %2i Unnamed,", symi);

                    }

                    if (sym.st_value || type == STT_OBJECT || type == STT_FUNC || (int16_t)sym.st_section == SHN_ABS_X86) {

                        printf(" Value: 0x%X", uint32_t(sym.st_value));

                    }

                    if (sym.st_unitsize)  printf(" size: %X*%X", sym.st_unitsize, sym.st_unitnum);

                    if (sym.st_other) {

                        for (int i = 0; i < 32; i++) {

                            if (sym.st_other & 1 << i) {

                                printf(" %s", Lookup(ELFSymbolInfoNames, 1 << i));