Subversion Repositories riscv_vhdl

/**

 * @file

 * @copyright  Copyright 2016 GNSS Sensor Ltd. All right reserved.

 * @author     Sergey Khabarov - sergeykhbr@gmail.com

 * @brief      elf-file loader class declaration.

 */

#ifndef __DEBUGGER_ELF_TYPES_H__

#define __DEBUGGER_ELF_TYPES_H__

#include <inttypes.h>

namespace debugger {

//#define EI_NIDENT 16

#define ARCH_64BITS

#ifdef ARCH_64BITS

typedef uint64_t   ElfAddr64;

typedef uint64_t   ElfOff64;

#else

typedef unsigned int   Elf32_Addr;

typedef unsigned int   Elf32_Off;

#endif

typedef unsigned short ElfHalf;

typedef signed   int   ElfSword;

typedef unsigned int   ElfWord;

typedef uint64_t       ElfDWord;

typedef unsigned int   ElfAddr32;

typedef unsigned int   ElfOff32;

static const char MAGIC_BYTES[]  = {0x7f,'E','L','F',0};

enum E_EI {

    EI_MAG0,

    EI_MAG1,

    EI_MAG2,

    EI_MAG3,

    EI_CLASS,

    EI_DATA,

    EI_VERSION,

    EI_PAD,

    EI_NIDENT=16

};

static const uint8_t ELFCLASSNONE = 0;

static const uint8_t ELFCLASS32   = 1;

static const uint8_t ELFCLASS64   = 2;

static const uint8_t ELFDATANONE  = 0;

static const uint8_t ELFDATA2LSB  = 1;

static const uint8_t ELFDATA2MSB  = 2;

static const uint8_t EV_NONE      = 0;          // Invalid version

static const uint8_t EV_CURRENT   = 1;          // Current version

//etype values:

static const ElfHalf ET_NONE      = 0;       // no file type

static const ElfHalf ET_REL       = 1;       // rellocatable file

static const ElfHalf ET_EXEC      = 2;       // executable file

static const ElfHalf ET_DYN       = 3;       // shared object file

static const ElfHalf ET_CORE      = 4;       // core file

static const ElfHalf ET_LOPROC    = 0xff00;  // Processor-specific

static const ElfHalf ET_HIPROC    = 0xffff;  // Processor-specific

//emachine values:

static const ElfHalf EM_NONE      = 0;       // No machine

static const ElfHalf EM_M32       = 1;       // AT&T WE 32100

static const ElfHalf EM_SPARC     = 2;       // SPARC

static const ElfHalf EM_386       = 3;       // Intel 386

static const ElfHalf EM_68K       = 4;       // Motorola 68000

static const ElfHalf EM_88K       = 5;       // Motorola 88000

static const ElfHalf EM_860       = 7;       // Intel 80860

static const ElfHalf EM_MIPS      = 8;       // MIPS RS3000

struct Elf32_Ehdr {

    unsigned char e_ident[EI_NIDENT];

    ElfHalf e_type;      // Shared/Executable/Rellocalable etc

    ElfHalf e_machine;   // SPARC, X86 etc

    ElfWord e_version;   //

    ElfAddr32 e_entry;     // entry point

    ElfOff32  e_phoff;     // Program header offset

    ElfOff32  e_shoff;     // Section Header offset

    ElfWord e_flags;

    ElfHalf e_ehsize;

    ElfHalf e_phentsize; // size of one entry in the Program header. All entries are the same size

    ElfHalf e_phnum;     // number of entries in a Program header

    ElfHalf e_shentsize; // entry size in the section header table. all entries are the same size

    ElfHalf e_shnum;     // number of section header entries

    ElfHalf e_shstrndx;

};

struct Elf64_Ehdr {

    unsigned char e_ident[EI_NIDENT];

    ElfHalf e_type;      // Shared/Executable/Rellocalable etc

    ElfHalf e_machine;   // SPARC, X86 etc

    ElfWord e_version;   //

    ElfAddr64 e_entry;     // entry point

    ElfOff64  e_phoff;     // Program header offset

    ElfOff64  e_shoff;     // Section Header offset

    ElfWord e_flags;

    ElfHalf e_ehsize;

    ElfHalf e_phentsize; // size of one entry in the Program header. All entries are the same size

    ElfHalf e_phnum;     // number of entries in a Program header

    ElfHalf e_shentsize; // entry size in the section header table. all entries are the same size

    ElfHalf e_shnum;     // number of section header entries

    ElfHalf e_shstrndx;

};

static ElfHalf SwapBytes(ElfHalf v) {

     v = ((v>>8)&0xff) | ((v&0xFF)<<8);

     return v;

}

static ElfWord SwapBytes(ElfWord v) {

    v = ((v >> 24) & 0xff) | ((v >> 8) & 0xff00)

      | ((v << 8) & 0xff0000) | ((v & 0xFF) << 24);

    return v;

}

static ElfDWord SwapBytes(ElfDWord v) {

    v = ((v >> 56) & 0xffull) | ((v >> 48) & 0xff00ull)

      | ((v >> 40) & 0xff0000ull) | ((v >> 32) & 0xff000000ull)

      | ((v << 8) & 0xff000000ull) | ((v << 16) & 0xff0000000000ull)

      | ((v << 24) & 0xff0000000000ull) | ((v << 32) & 0xff00000000000000ull);

    return v;

}

class ElfHeaderType {

 public:

    ElfHeaderType(uint8_t *img) {

        pimg_ = img;

        isElf_ = true;

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

            if (pimg_[i] != MAGIC_BYTES[i]) {

                isElf_ = false;

            }

        }

        is32b_ = pimg_[EI_CLASS] == ELFCLASS32;

        isMsb_ = pimg_[EI_DATA] == ELFDATA2MSB;

        if (is32b_) {

            Elf32_Ehdr *h = reinterpret_cast<Elf32_Ehdr *>(pimg_);

            if (isMsb_) {

                e_shoff_ = SwapBytes(h->e_shoff);

                e_shnum_ = SwapBytes(h->e_shnum);

                e_phoff_ = SwapBytes(h->e_phoff);

            } else {

                e_shoff_ = h->e_shoff;

                e_shnum_ = h->e_shnum;

                e_phoff_ = h->e_phoff;

            }

        } else {

            Elf64_Ehdr *h = reinterpret_cast<Elf64_Ehdr *>(pimg_);

            if (isMsb_) {

                e_shoff_ = SwapBytes(h->e_shoff);

                e_shnum_ = SwapBytes(h->e_shnum);

                e_phoff_ = SwapBytes(h->e_phoff);

            } else {

                e_shoff_ = h->e_shoff;

                e_shnum_ = h->e_shnum;

                e_phoff_ = h->e_phoff;

            }

        }

    }

    virtual bool isElf() { return isElf_; }

    virtual bool isElf32() { return is32b_; }

    virtual bool isElfMsb() { return isMsb_; }

    virtual uint64_t get_shoff() { return e_shoff_; }

    virtual ElfHalf get_shnum() { return e_shnum_; }

    virtual uint64_t get_phoff() { return e_phoff_; }

 protected:

    uint8_t *pimg_;

    bool isElf_;

    bool is32b_;

    bool isMsb_;

    uint64_t e_shoff_;

    ElfHalf e_shnum_;

    uint64_t e_phoff_;

};

//sh_type:

static const ElfWord SHT_NULL      = 0;          // section header is inactive

static const ElfWord SHT_PROGBITS  = 1;          // section with CPU instructions

static const ElfWord SHT_SYMTAB    = 2;          // section contains symbols table (also as SHT_DYNSIM)

static const ElfWord SHT_STRTAB    = 3;          // section holds string table

static const ElfWord SHT_RELA      = 4;          // section with relocation data

static const ElfWord SHT_HASH      = 5;          // section with hash table. Must be for the dynamic lib

static const ElfWord SHT_DYNAMIC   = 6;          // section holds information for dynamic linking.

static const ElfWord SHT_NOTE      = 7;

static const ElfWord SHT_NOBITS    = 8;          // section with not initialized data

static const ElfWord SHT_REL       = 9;

static const ElfWord SHT_SHLIB     = 10;

static const ElfWord SHT_DYNSYM    = 11;         // section contains debug symbol table

static const ElfWord SHT_LOPROC    = 0x70000000;

static const ElfWord SHT_HIPROC    = 0x7fffffff;

static const ElfWord SHT_HIUSER    = 0xffffffff;

//sh_flags:

static const ElfWord SHF_WRITE     = 0x1;        // section contains data that should be writable during process execution.

static const ElfWord SHF_ALLOC     = 0x2;        // section occupies memory during process execution. 

static const ElfWord SHF_EXECINSTR = 0x4;        // section contains executable machine instructions.

static const ElfWord SHF_MASKPROC  = 0xf0000000; // processor-specific sematic

struct Elf32_Shdr {

    ElfWord    sh_name;//Index in a header section table (gives name of section)

    ElfWord    sh_type;

        ElfWord sh_flags;       /* SHF_... */

        ElfAddr32       sh_addr;

        ElfOff32        sh_offset;

        ElfWord sh_size;

    ElfWord    sh_link;

    ElfWord    sh_info;

    ElfWord   sh_addralign;

    ElfWord   sh_entsize;

};

struct Elf64_Shdr {

    ElfWord    sh_name;//Index in a header section table (gives name of section)

    ElfWord    sh_type;

    ElfDWord   sh_flags;

    ElfAddr64  sh_addr;

    ElfOff64   sh_offset;

    ElfDWord   sh_size;

    ElfWord    sh_link;

    ElfWord    sh_info;

    ElfDWord   sh_addralign;

    ElfDWord   sh_entsize;

};

class SectionHeaderType {

 public:

    SectionHeaderType(uint8_t *img, ElfHeaderType *h) {

        if (h->isElf32()) {

            Elf32_Shdr *sh = reinterpret_cast<Elf32_Shdr *>(img);

            if (h->isElfMsb()) {

                sh_name_ = SwapBytes(sh->sh_name);

                sh_type_ = SwapBytes(sh->sh_type);

                sh_flags_ = SwapBytes(sh->sh_flags);

                sh_addr_ = SwapBytes(sh->sh_addr);

                sh_offset_ = SwapBytes(sh->sh_offset);

                sh_size_ = SwapBytes(sh->sh_size);

                sh_entsize_ = SwapBytes(sh->sh_entsize);

            } else {

                sh_name_ = sh->sh_name;

                sh_type_ = sh->sh_type;

                sh_flags_ = sh->sh_flags;

                sh_addr_ = sh->sh_addr;

                sh_offset_ = sh->sh_offset;

                sh_size_ = sh->sh_size;

                sh_entsize_ = sh->sh_entsize;

            }

        } else {

            Elf64_Shdr *sh = reinterpret_cast<Elf64_Shdr *>(img);

            if (h->isElfMsb()) {

                sh_name_ = SwapBytes(sh->sh_name);

                sh_type_ = SwapBytes(sh->sh_type);

                sh_flags_ = SwapBytes(sh->sh_flags);

                sh_addr_ = SwapBytes(sh->sh_addr);

                sh_offset_ = SwapBytes(sh->sh_offset);

                sh_size_ = SwapBytes(sh->sh_size);

                sh_entsize_ = SwapBytes(sh->sh_entsize);

            } else {

                sh_name_ = sh->sh_name;

                sh_type_ = sh->sh_type;

                sh_flags_ = sh->sh_flags;

                sh_addr_ = sh->sh_addr;

                sh_offset_ = sh->sh_offset;

                sh_size_ = sh->sh_size;

                sh_entsize_ = sh->sh_entsize;

            }

        }

    }

    virtual ElfWord get_name() { return sh_name_; }

    virtual ElfWord get_type() { return sh_type_; }

    virtual uint64_t get_offset() { return sh_offset_; }

    virtual uint64_t get_size() { return sh_size_; }

    virtual uint64_t get_addr() { return sh_addr_; }

    virtual uint64_t get_flags() { return sh_flags_; }

    virtual uint64_t get_entsize() { return sh_entsize_; }

 protected:

    ElfWord sh_name_;

    ElfWord sh_type_;

    uint64_t sh_offset_;

    uint64_t sh_size_;

    uint64_t sh_addr_;

    uint64_t sh_flags_;

    uint64_t sh_entsize_;

};

#define ELF32_ST_BIND(i) ((i)>>4)

#define ELF32_ST_TYPE(i) ((i)&0xf)

#define ELF32_ST_INFO(b,t) (((b)<<4) + ((t)&0xf))

static const unsigned char STB_LOCAL   = 0;

static const unsigned char STB_GLOBAL  = 1;

static const unsigned char STB_WEAK    = 2;

static const unsigned char STB_LOPROC  = 13;

static const unsigned char STB_HIPROC  = 15;

static const unsigned char STT_NOTYPE  = 0;

static const unsigned char STT_OBJECT  = 1;

static const unsigned char STT_FUNC    = 2;

static const unsigned char STT_SECTION = 3;

static const unsigned char STT_FILE    = 4;

static const unsigned char STT_LOPROC  = 13;

static const unsigned char STT_HIPROC  = 15;

struct Elf32_Sym {

    ElfWord    st_name;

        ElfAddr32       st_value;

        ElfWord st_size;

        unsigned char   st_info;

        unsigned char   st_other;

        ElfHalf st_shndx;

};

struct Elf64_Sym {

    ElfWord    st_name;

        unsigned char   st_info;

        unsigned char   st_other;

        ElfHalf st_shndx;

        ElfAddr64       st_value;

        ElfDWord        st_size;

};

class SymbolTableType {

 public:

    SymbolTableType(uint8_t *img, ElfHeaderType *h) {

        if (h->isElf32()) {

            Elf32_Sym *st = reinterpret_cast<Elf32_Sym *>(img);

            if (h->isElfMsb()) {

                st_name_ = SwapBytes(st->st_name);

                st_value_ = SwapBytes(st->st_value);

                st_size_ = SwapBytes(st->st_size);

            } else {

                st_name_ = st->st_name;

                st_value_ = st->st_value;

                st_size_ = st->st_size;

            }

            st_info_ = st->st_info;

        } else {

            Elf64_Sym *st = reinterpret_cast<Elf64_Sym *>(img);

            if (h->isElfMsb()) {

                st_name_ = SwapBytes(st->st_name);

                st_value_ = SwapBytes(st->st_value);

                st_size_ = SwapBytes(st->st_size);

            } else {

                st_name_ = st->st_name;

                st_value_ = st->st_value;

                st_size_ = st->st_size;

            }

            st_info_ = st->st_info;

        }

    }

    virtual ElfWord get_name() { return st_name_; }

    virtual uint64_t get_value() { return st_value_; }

    virtual uint64_t get_size() { return st_size_; }

    virtual unsigned char get_info() { return st_info_; }

 protected:

    ElfWord    st_name_;

    unsigned char st_info_;

    uint64_t st_value_;

    uint64_t st_size_;

};

//p_type:

static const ElfWord PT_NULL     = 0;

static const ElfWord PT_LOAD     = 1;

static const ElfWord PT_DYNAMIC  = 2;

static const ElfWord PT_INTERP   = 3;

static const ElfWord PT_NOTE     = 4;

static const ElfWord PT_SHLIB    = 5;

static const ElfWord PT_PHDR     = 6;

static const ElfWord PT_LOPROC   = 0x70000000;

static const ElfWord PT_HIPROC   = 0x7fffffff;

typedef struct ProgramHeaderType64

{

  uint32_t    p_type;

  uint32_t    p_offset;

  uint64_t    p_vaddr;

  uint64_t    p_paddr;

#ifdef ARCH_64BITS

    ElfDWord    p_filesz;

    ElfDWord    p_memsz;

    ElfDWord    p_flags;

    ElfDWord    p_align;

#else

        Elf32_Word      p_filesz;

        Elf32_Word      p_memsz;

        Elf32_Word      p_flags;

        Elf32_Word      p_align;

#endif

} ProgramHeaderType64;

typedef struct ProgramHeaderType32

{

  uint32_t    p_type;

  uint32_t    p_offset;

  ElfAddr32    p_vaddr;

  ElfAddr32    p_paddr;

  ElfWord       p_filesz;

  ElfWord       p_memsz;

  ElfWord       p_flags;

  ElfWord       p_align;

} ProgramHeaderType32;

}  // namespace debugger

#endif  // __DEBUGGER_ELF_TYPES_H__