Subversion Repositories thor

// ============================================================================
//        __
//   \\__/ o\    (C) 2014  Robert Finch, Stratford
//    \  __ /    All rights reserved.
//     \/_//     robfinch<remove>@finitron.ca
//       ||
//
// A64 - Assembler
//  - 64 bit CPU
//
// This source file is free software: you can redistribute it and/or modify 
// it under the terms of the GNU Lesser General Public License as published 
// by the Free Software Foundation, either version 3 of the License, or     
// (at your option) any later version.                                      
//                                                                          
// This source file is distributed in the hope that it will be useful,      
// but WITHOUT ANY WARRANTY; without even the implied warranty of           
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            
// GNU General Public License for more details.                             
//                                                                          
// You should have received a copy of the GNU General Public License        
// along with this program.  If not, see <http://www.gnu.org/licenses/>.    
//                                                                          
// ============================================================================
//
#pragma once
 
#include <string.h>
 
class clsElf64Header {
public:
    enum {
        ELFCLASS32 = 1,
        ELFCLASS64 = 2
    };
    enum {
        ELFDATA2LSB = 1,
        ELFDATA2MSB = 2
    };
 
    char e_ident[16];
    int16_t e_type;
    int16_t e_machine;
    int32_t e_version;
    int64_t e_entry;            // program entry point
    int64_t e_phoff;            // offset in file to program header
    int64_t e_shoff;            // offset in file to section header
    int32_t e_flags;            // 
    int16_t e_ehsize;           // size of ELF header
    int16_t e_phentsize;        // size of program header entry
    int16_t e_phnum;            // number of program header entries
    int16_t e_shentsize;        // size of section header entry
    int16_t e_shnum;            // number of section header entries
    int16_t e_shstrndx;         // section name string table index
 
    clsElf64Header() {
        memset((void*)e_ident,0,sizeof(e_ident));
        e_ident[0] = 127;
        e_ident[1] = 'E';
        e_ident[2] = 'L';
        e_ident[3] = 'F';
        e_type = 0;
        e_machine = 0;
        e_version = 1;
        e_entry = 0;
        e_phoff = 0;
        e_shoff = 0;
        e_flags = 0;
        e_ehsize = 0;
        e_phentsize = 0;
        e_phnum = 0;
        e_shentsize = 0;
        e_shnum = 0;
        e_shstrndx = 0;
    };
 
    void Write(FILE *fp) {
         fwrite((void *)e_ident,1,16,fp);
         fwrite((void *)&e_type,1,sizeof(e_type),fp);
         fwrite((void *)&e_machine,1,sizeof(e_machine),fp);
         fwrite((void *)&e_version,1,sizeof(e_version),fp);
         fwrite((void *)&e_entry,1,sizeof(e_entry),fp);
         fwrite((void *)&e_phoff,1,sizeof(e_phoff),fp);
         fwrite((void *)&e_shoff,1,sizeof(e_shoff),fp);
         fwrite((void *)&e_flags,1,sizeof(e_flags),fp);
         fwrite((void *)&e_ehsize,1,sizeof(e_ehsize),fp);
         fwrite((void *)&e_phentsize,1,sizeof(e_phentsize),fp);
         fwrite((void *)&e_phnum,1,sizeof(e_phnum),fp);
         fwrite((void *)&e_shentsize,1,sizeof(e_shentsize),fp);
         fwrite((void *)&e_shnum,1,sizeof(e_shnum),fp);
         fwrite((void *)&e_shstrndx,1,sizeof(e_shstrndx),fp);
    };
 
    void Read(FILE *fp) {
         fread((void *)e_ident,1,16,fp);
         fread((void *)&e_type,1,sizeof(e_type),fp);
         fread((void *)&e_machine,1,sizeof(e_machine),fp);
         fread((void *)&e_version,1,sizeof(e_version),fp);
         fread((void *)&e_entry,1,sizeof(e_entry),fp);
         fread((void *)&e_phoff,1,sizeof(e_phoff),fp);
         fread((void *)&e_shoff,1,sizeof(e_shoff),fp);
         fread((void *)&e_flags,1,sizeof(e_flags),fp);
         fread((void *)&e_ehsize,1,sizeof(e_ehsize),fp);
         fread((void *)&e_phentsize,1,sizeof(e_phentsize),fp);
         fread((void *)&e_phnum,1,sizeof(e_phnum),fp);
         fread((void *)&e_shentsize,1,sizeof(e_shentsize),fp);
         fread((void *)&e_shnum,1,sizeof(e_shnum),fp);
         fread((void *)&e_shstrndx,1,sizeof(e_shstrndx),fp);
    };
};
 
typedef struct {
    int64_t p_type;             // type of segment
    int64_t p_flags;            // segment attributes
    int64_t p_offset;           // offset in file
    int64_t p_vaddr;            // virtual address
    int64_t p_paddr;            // reserved
    int64_t p_filesz;           // size of segment in file
    int64_t p_memsz;            // size of segment in memory
    int64_t p_align;            // alignment of segment
} Elf64Phdr;
 
class clsElf64Shdr {
public:
    enum {
        SHT_PROGBITS = 1,
        SHT_SYMTAB = 2,
        SHT_STRTAB = 3,
        SHT_REL = 9,
    };
    enum {
        SHF_WRITE = 1,
        SHF_ALLOC = 2,
        SHF_EXECINSTR = 4
    };
    int32_t sh_name;
    int32_t sh_type;
    int64_t sh_flags;
    int64_t sh_addr;
    int64_t sh_offset;
    int64_t sh_size;
    int32_t sh_link;
    int32_t sh_info;
    int64_t sh_addralign;
    int64_t sh_entsize;
 
    void Write(FILE *fp) {
         fwrite((void*)&sh_name,1,sizeof(sh_name),fp);
         fwrite((void*)&sh_type,1,sizeof(sh_type),fp);
         fwrite((void*)&sh_flags,1,sizeof(sh_flags),fp);
         fwrite((void*)&sh_addr,1,sizeof(sh_addr),fp);
         fwrite((void*)&sh_offset,1,sizeof(sh_offset),fp);
         fwrite((void*)&sh_size,1,sizeof(sh_size),fp);
         fwrite((void*)&sh_link,1,sizeof(sh_link),fp);
         fwrite((void*)&sh_info,1,sizeof(sh_info),fp);
         fwrite((void*)&sh_addralign,1,sizeof(sh_addralign),fp);
         fwrite((void*)&sh_entsize,1,sizeof(sh_entsize),fp);
    };
    void Read(FILE *fp) {
         fread((void*)&sh_name,1,sizeof(sh_name),fp);
         fread((void*)&sh_type,1,sizeof(sh_type),fp);
         fread((void*)&sh_flags,1,sizeof(sh_flags),fp);
         fread((void*)&sh_addr,1,sizeof(sh_addr),fp);
         fread((void*)&sh_offset,1,sizeof(sh_offset),fp);
         fread((void*)&sh_size,1,sizeof(sh_size),fp);
         fread((void*)&sh_link,1,sizeof(sh_link),fp);
         fread((void*)&sh_info,1,sizeof(sh_info),fp);
         fread((void*)&sh_addralign,1,sizeof(sh_addralign),fp);
         fread((void*)&sh_entsize,1,sizeof(sh_entsize),fp);
    };
};
 
#define STB_GLOBAL     1
 
typedef struct {
    int32_t st_name;
    int8_t st_info;
    int8_t st_other;
    int16_t st_shndx;
    int64_t st_value;
    int64_t st_size;
} Elf64Symbol;
 
typedef struct {
    int64_t r_offset;
    int64_t r_info;
} Elf64rel;
 
typedef struct {
    int64_t r_offset;
    int64_t r_info;
    int64_t r_addend;
} Elf64rela;
 
// My own constructions
typedef struct {
    clsElf64Shdr hdr;
    int64_t length;
    int64_t index;
    int64_t address;
    int64_t start;
    int64_t end;
    uint8_t bytes[10000000];
} Elf64Section;
 
class clsElf64Section {
public:
    clsElf64Shdr hdr;
    int64_t length;
    int64_t index;
    int64_t address;
    int64_t start;
    int64_t end;
    uint8_t bytes[10000000];
    uint8_t storebyte;
public:
    clsElf64Section() {
        length = 0;
        index = 0;
        start = 0;
        end = 0;
        address = 0;
        memset(bytes,0,sizeof(bytes));
        storebyte = 1;
    };
    void Clear() {
        length = 0;
        index = 0;
        start = 0;
        end = 0;
        address = 0;
        memset(bytes,0,sizeof(bytes));
    };
    void AddByte(int64_t byt) {
    	if (storebyte)
        	bytes[index] = byt & 255LL;
        if (index==0)
            start = address;
        index++;
        address++;
        if (address > end)
            end = address;
    };
    void AddChar(int64_t chr) {
        AddByte(chr & 255LL);
        AddByte((chr >> 8) & 255LL);
    };
    void AddHalf(int64_t chr) {
        AddChar(chr & 0xFFFFLL);
        AddChar((chr >> 16) & 0xFFFFLL);
    };
    void AddWord(int64_t wd) {
        AddHalf(wd & 0xFFFFFFFFLL);
        AddHalf((wd >> 32) & 0xFFFFFFFFLL);
    };
    void Add(Elf64Symbol *sym) {
        AddHalf(sym->st_name);
        AddByte(sym->st_info);        
        AddByte(sym->st_other);
        AddChar(sym->st_shndx);
        AddWord(sym->st_value);
        AddWord(sym->st_size);
    };
    void AddRel(int64_t addr, int64_t info) {
        AddWord(addr);
        AddWord(info);
    };
    void Write(FILE *fp) {
        fwrite((void *)bytes,1,(size_t)hdr.sh_size,fp);
    };
    void Read(FILE *fp) {
        fread((void *)bytes,1,(size_t)hdr.sh_size,fp);
    };
};
 
class clsElf64File
{
public:
    clsElf64Header hdr;
    clsElf64Section *sections[256];
 
    void AddSection(clsElf64Section *sect) {
        sections[hdr.e_shnum] = sect;
        hdr.e_shnum++;
    };
 
    void WriteSectionHeaderTable(FILE *fp) {
        int nn;
 
        for (nn = 0; nn < hdr.e_shnum; nn++) {
            sections[nn]->hdr.Write(fp);
        }
    };
 
    void Write(FILE *fp) {
        int nn;
 
        hdr.Write(fp);        
        fseek(fp, 512, SEEK_SET);
        for (nn = 0; nn < hdr.e_shnum; nn++) {
            fseek(fp, (size_t)sections[nn]->hdr.sh_offset, SEEK_SET);
            sections[nn]->Write(fp);
        }
        fseek(fp, (size_t)hdr.e_shoff, SEEK_SET);
        WriteSectionHeaderTable(fp);
    };
};
 
 
#define Elf64HdrSz   64
#define Elf64pHdrSz  64
#define Elf64ShdrSz  64