path: root/drivers/staging/nmf-cm/cm/engine/elf/inc/elfabi.h

/*
 * Copyright (C) ST-Ericsson SA 2010
 * Author: Jean-Philippe FASSINO <jean-philippe.fassino@stericsson.com> for ST-Ericsson.
 * License terms: GNU General Public License (GPL) version 2.
 */
#ifndef _CM_ELF_H
#define _CM_ELF_H 1

typedef t_uint16 Elf32_Half;
typedef t_uint16 Elf64_Half;

typedef t_uint32 Elf32_Word;
typedef t_sint32 Elf32_Sword;
typedef t_uint32 Elf64_Word;
typedef t_sint32 Elf64_Sword;

typedef t_uint64 Elf32_Xword;
typedef t_sint64 Elf32_Sxword;
typedef t_uint64 Elf64_Xword;
typedef t_sint64 Elf64_Sxword;

typedef t_uint32 Elf32_Addr;
typedef t_uint64 Elf64_Addr;

typedef t_uint32 Elf32_Off;
typedef t_uint64 Elf64_Off;

typedef t_uint16 Elf32_Section;
typedef t_uint16 Elf64_Section;

typedef Elf32_Half Elf32_Versym;
typedef Elf64_Half Elf64_Versym;


/*********************************************
 * Header
 *********************************************/
#define EI_NIDENT (16)                              //!< Size of e_ident[]

#define EI_MAG0         0               //!< File identification
#define ELFMAG0             0x7f

#define EI_MAG1         1               //!< File identification
#define ELFMAG1             'E'

#define EI_MAG2         2               //!< File identification
#define ELFMAG2             'L'

#define EI_MAG3         3               //!< File identification
#define ELFMAG3             'F'

#define EI_CLASS        4               //!< File class
#define ELFCLASSNONE        0               //!< Invalid class
#define ELFCLASS32          1               //!< 32-bit objects
#define ELFCLASS64          2               //!< 64-bit objects

#define EI_DATA         5               //!< Data encoding
#define ELFDATANONE         0               //!< Invalid data encoding
#define ELFDATA2LSB         1               //!< 2's complement, little endian
#define ELFDATA2MSB         2               //!< 2's complement, big endian

#define EI_VERSION      6               //!< File version

#define EI_OSABI        7               //!< OS ABI identification
#define ELFOSABI_NONE       0               //!<  No extension
#define ELFOSABI_HPUX       1               //!<  HP-UX
#define ELFOSABI_NETBSD     2               //!<  NetBSD
#define ELFOSABI_LINUX      3               //!<  Linux
#define ELFOSABI_SOLARIS    6               //!<  Sun Solaris
#define ELFOSABI_AIX        7               //!<  AIX
#define ELFOSABI_IRIX       8               //!<  IRIX
#define ELFOSABI_FREEBSD    9               //!<  FreeBSD
#define ELFOSABI_TRU64      10              //!<  Compaq TRU64 UNIX
#define ELFOSABI_MODESTO    11              //!<  Novell Modesto
#define ELFOSABI_OPENBSD    12              //!<  Open BSD
#define ELFOSABI_OPENVMS    13              //!<  Open VMS
#define ELFOSABI_NSK        14              //!<  HP Non-Stop-Kernel

#define EI_ABIVERSION   8               //!< ABI version

#define EI_PAD          9               //!< Start of padding byte


typedef struct
{
    unsigned char       e_ident[EI_NIDENT];             //!< The initial bytes mark the file as an object file and provide machine-independent data with which to decode and interpret the file's contents
    Elf32_Half          e_type;                         //!< This member identifies the object file type
    Elf32_Half          e_machine;                      //!< This member's value specifies the required architecture for an individual file
    Elf32_Word          e_version;                      //!< This member identifies the object file version
    Elf32_Addr          e_entry;                        //!< This member gives the virtual address to which the system first transfers control, thus starting the process
    Elf32_Off           e_phoff;                        //!< This member holds the program header table's file offset in bytes
    Elf32_Off           e_shoff;                        //!< This member holds the section header table's file offset in bytes
    Elf32_Word          e_flags;                        //!< This member holds processor-specific flags associated with the file
    Elf32_Half          e_ehsize;                       //!< This member holds the ELF header's size in bytes
    Elf32_Half          e_phentsize;                    //!< This member holds the size in bytes of one entry in the file's program header table; all entries are the same size
    Elf32_Half          e_phnum;                        //!< This member holds the number of entries in the program header table
    Elf32_Half          e_shentsize;                    //!< This member holds a section header's size in bytes
    Elf32_Half          e_shnum;                        //!< This member holds the number of entries in the section header table
    Elf32_Half          e_shstrndx;                     //!< This member holds the section header table index of the entry associated with the section name string table
} Elf32_Ehdr;       //!< 32bit Entry Header

typedef struct
{
    unsigned char       e_ident[EI_NIDENT];             //!< The initial bytes mark the file as an object file and provide machine-independent data with which to decode and interpret the file's contents
    Elf64_Half          e_type;                         //!< This member identifies the object file type
    Elf64_Half          e_machine;                      //!< This member's value specifies the required architecture for an individual file
    Elf64_Word          e_version;                      //!< This member identifies the object file version
    Elf64_Addr          e_entry;                        //!< This member gives the virtual address to which the system first transfers control, thus starting the process
    Elf64_Off           e_phoff;                        //!< This member holds the program header table's file offset in bytes
    Elf64_Off           e_shoff;                        //!< This member holds the section header table's file offset in bytes
    Elf64_Word          e_flags;                        //!< This member holds processor-specific flags associated with the file
    Elf64_Half          e_ehsize;                       //!< This member holds the ELF header's size in bytes
    Elf64_Half          e_phentsize;                    //!< This member holds the size in bytes of one entry in the file's program header table; all entries are the same size
    Elf64_Half          e_phnum;                        //!< This member holds the number of entries in the program header table
    Elf64_Half          e_shentsize;                    //!< This member holds a section header's size in bytes
    Elf64_Half          e_shnum;                        //!< This member holds the number of entries in the section header table
    Elf64_Half          e_shstrndx;                     //!< This member holds the section header table index of the entry associated with the section name string table
} Elf64_Ehdr;       //!< 64bit Entry Header

/*
 * e_type
 */
#define ET_NONE         0                   //!< No file type
#define ET_REL          1                   //!< Relocatable file
#define ET_EXEC         2                   //!< Executable file
#define ET_DYN          3                   //!< Shared object file
#define ET_CORE         4                   //!< Core file
#define ET_LOOS         0xfe00              //!< Operating system-specific
#define ET_HIOS         0xfeff              //!< Operating system-specific
#define ET_LOPROC       0xff00              //!< Processor-specific
#define ET_HIPROC       0xffff              //!< Processor-specific

/*
 * e_machine
 */
#define EM_NONE             0               //!< No machine
#define EM_M32              1               //!< AT&T WE 32100
#define EM_SPARC            2               //!< SUN SPARC
#define EM_386              3               //!< Intel 80386
#define EM_68K              4               //!< Motorola 68000
#define EM_88K              5               //!< Motorola 88000
#define EM_860              7               //!< Intel 80860
#define EM_MIPS             8               //!< MIPS I architecture
#define EM_S370             9               //!< IBM System/370
#define EM_MIPS_RS3_LE      10              //!< MIPS R3000 little-endian
#define EM_PARISC           15              //!< HPPA
#define EM_VPP500           17              //!< Fujitsu VPP500
#define EM_SPARC32PLUS      18              //!< Enhanced instruction set SPARC
#define EM_960              19              //!< Intel 80960
#define EM_PPC              20              //!< PowerPC
#define EM_PPC64            21              //!< 64-bit PowerPC
#define EM_S390             22              //!< IBM System/390 Processor
#define EM_V800             36              //!< NEC V800
#define EM_FR20             37              //!< Fujitsu FR20
#define EM_RH32             38              //!< TRW RH-32
#define EM_RCE              39              //!< Motorola RCE
#define EM_ARM              40              //!< Advanced RISC Machines ARM
#define EM_FAKE_ALPHA       41              //!< Digital Alpha
#define EM_SH               42              //!< Hitachi SH
#define EM_SPARCV9          43              //!< SPARC Version 9
#define EM_TRICORE          44              //!< Siemens TriCore embedded processor
#define EM_ARC              45              //!< Argonaut RISC Core, Argonaut Technologies Inc
#define EM_H8_300           46              //!< Hitachi H8/300
#define EM_H8_300H          47              //!< Hitachi H8/300H
#define EM_H8S              48              //!< Hitachi H8S
#define EM_H8_500           49              //!< Hitachi H8/500
#define EM_IA_64            50              //!< Intel IA-64 processor architecture
#define EM_MIPS_X           51              //!< Stanford MIPS-X
#define EM_COLDFIRE         52              //!< Motorola ColdFire
#define EM_68HC12           53              //!< Motorola M68HC12
#define EM_MMA              54              //!< Fujitsu MMA Multimedia Accelerator
#define EM_PCP              55              //!< Siemens PCP
#define EM_NCPU             56              //!< Sony nCPU embedded RISC processor
#define EM_NDR1             57              //!< Denso NDR1 microprocessor
#define EM_STARCORE         58              //!< Motorola Start*Core processor
#define EM_ME16             59              //!< Toyota ME16 processor
#define EM_ST100            60              //!< STMicroelectronics ST100 processor
#define EM_TINYJ            61              //!< Advanced Logic Corp. TinyJ embedded processor family
#define EM_X86_64           62              //!< AMD x86-64 architecture
#define EM_PDSP             63              //!< Sony DSP Processor
#define EM_PDP10            64              //!< Digital Equipment Corp. PDP-10
#define EM_PDP11            65              //!< Digital Equipment Corp. PDP-11
#define EM_FX66             66              //!< Siemens FX66 microcontroller
#define EM_ST9PLUS          67              //!< STMicroelectronics ST9+ 8/16 bit microcontroller
#define EM_ST7              68              //!< STMicroelectronics ST7 8-bit microcontroller
#define EM_68HC16           69              //!< Motorola MC68HC16 Microcontroller
#define EM_68HC11           70              //!< Motorola MC68HC11 Microcontroller
#define EM_68HC08           71              //!< Motorola MC68HC08 Microcontroller
#define EM_68HC05           72              //!< Motorola MC68HC05 Microcontroller
#define EM_SVX              73              //!< Silicon Graphics SVx
#define EM_ST19             74              //!< STMicroelectronics ST19 8-bit microcontroller
#define EM_VAX              75              //!< Digital VAX
#define EM_CRIS             76              //!< Axis Communications 32-bit embedded processor
#define EM_JAVELIN          77              //!< Infifineon Technologies 32-bit embedded processor
#define EM_FIREPATH         78              //!< Element 14 64-bit DSP Processor
#define EM_ZSP              79              //!< LSI Logic 16-bit DSP Processor
#define EM_MMIX             80              //!< Donald Knuth's educational 64-bit processor
#define EM_HUANY            81              //!< Harvard University machine-independent object files
#define EM_PRISM            82              //!< SiTera Prism
#define EM_AVR              83              //!< Atmel AVR 8-bit microcontroller
#define EM_FR30             84              //!< Fujitsu FR30
#define EM_D10V             85              //!< Mitsubishi D10V
#define EM_D30V             86              //!< Mitsubishi D30V
#define EM_V850             87              //!< NEC v850
#define EM_M32R             88              //!< Mitsubishi M32R
#define EM_MN10300          89              //!< Matsushita MN10300
#define EM_MN10200          90              //!< Matsushita MN10200
#define EM_PJ               91              //!< picoJava
#define EM_OPENRISC         92              //!< OpenRISC 32-bit embedded processor
#define EM_ARC_A5           93              //!< ARC International ARCompact processor (old spelling/synonym: EM_ARC_A5)
#define EM_XTENSA           94              //!< Tensilica Xtensa Architecture
#define EM_VIDEOCORE        95              //!< Alphamosaic VideoCore processor
#define EM_TMM_GPP          96              //!< Thompson Multimedia General Purpose Processor
#define EM_NS32K            97              //!< National Semiconductor 32000 series
#define EM_TPC              98              //!< Tenor Network TPC processor
#define EM_SNP1K            99              //!< Trebia SNP 1000 processor
#define EM_ST200            100             //!< STMicroelectronics (www.st.com) ST200 microcontroller
#define EM_IP2K             101             //!< Ubicom IP2xxx microcontroller family
#define EM_MAX              102             //!< MAX Processor
#define EM_CR               103             //!< National Semiconductor CompactRISC microprocessor
#define EM_F2MC16           104             //!< Fujitsu F2MC16
#define EM_MSP430           105             //!< Texaxas Instruments embedded microcontroller msp430
#define EM_BLACKFIN         106             //!< Analog Devices Blackfin (DSP) processor
#define EM_SE_C33           107             //!< S1C33 Family of Seiko Epspson processors
#define EM_SEP              108             //!< Sharp embedded microprocessor
#define EM_ARCA             109             //!< Arca RISC Microprocessor
#define EM_UNICORE          110             //!< Microprocessor series from PKU-Unity Ltd. and MPRC of Peking University
#define EM_EXCESS           111             //!< eXcess: 16/32/64-bit configurable embedded CPU
#define EM_DXP              112             //!< Icera Semiconductor Inc. Deep Execution Processor
#define EM_ALTERA_NIOS2     113             //!< Altera Nios II soft-core processor
#define EM_CRX              114             //!< National Semiconductor CompactRISC CRX microprocessor
#define EM_XGATE            115             //!< Motorola XGATE embedded processor
#define EM_C166             116             //!< Infifineon C16x/XC16x processor
#define EM_M16C             117             //!< Renesas M16C series microprocessors
#define EM_DSPIC30F         118             //!< Microchip Technology dsPIC30F Digital Signal Controller
#define EM_CE               119             //!< Freescale Communication Engine RISC core
#define EM_M32C             120             //!< Renesas M32C series microprocessors
#define EM_TSK3000          131             //!< Altium TSK3000 core
#define EM_RS08             132             //!< Freescale RS08 embedded processor
#define EM_ECOG2            134             //!< Cyan Technology eCOG2 microprocessor
#define EM_SCORE7           135             //!< Sunplus S+core7 RISC processor
#define EM_DSP24            136             //!< New Japan Radio (NJR) 24-bit DSP Processor
#define EM_VIDEOCORE3       137             //!< Broadcom VideoCore III processor
#define EM_LATTICEMICO32    138             //!< RISC processor for Lattice FPGA architecture
#define EM_SE_C17           139             //!< Seiko Epspson C17 family
#define EM_TI_C6000         140             //!< The Texaxas Instruments TMS320C6000 DSP family
#define EM_TI_C2000         141             //!< The Texaxas Instruments TMS320C2000 DSP family
#define EM_TI_C5500         142             //!< The Texaxas Instruments TMS320C55x DSP family
#define EM_MMDSP_PLUS       160             //!< STMicroelectronics 64bit VLIW Data Signal Processor
#define EM_CYPRESS_M8C      161             //!< Cypress M8C microprocessor
#define EM_R32C             162             //!< Renesas R32C series microprocessors
#define EM_TRIMEDIA         163             //!< NXP Semiconductors TriMedia architecture family
#define EM_QDSP6            164             //!< QUALCOMM DSP6 Processor
#define EM_8051             165             //!< Intel 8051 and variants
#define EM_STXP7X           166             //!< STMicroelectronics STxP7x family of configurable and extensible RISC processors
#define EM_NDS32            167             //!< Andes Technology compact code size embedded RISC processor family
#define EM_ECOG1            168             //!< Cyan Technology eCOG1X family
#define EM_ECOG1X           168             //!< Cyan Technology eCOG1X family
#define EM_MAXQ30           169             //!< Dallas Semiconductor MAXQ30 Core Micro-controllers
#define EM_XIMO16           170             //!< New Japan Radio (NJR) 16-bit DSP Processor
#define EM_MANIK            171             //!< M2000 Reconfigurable RISC Microprocessor
#define EM_CRAYNV2          172             //!< Cray Inc. NV2 vector architecture
#define EM_RX               173             //!< Renesas RX family
#define EM_METAG            174             //!< Imagination Technologies META processor architecture
#define EM_MCST_ELBRUS      175             //!< MCST Elbrus general purpose hardware architecture
#define EM_ECOG16           176             //!< Cyan Technology eCOG16 family
#define EM_CR16             177             //!< National Semiconductor CompactRISC CR16 16-bit microprocessor
#define EM_ETPU             178             //!< Freescale Extended Time Processing Unit
#define EM_SLE9X            179             //!< Infifineon Technologies SLE9X core
#define EM_AVR32            185             //!< Atmel Corporation 32-bit microprocessor family
#define EM_STM8             186             //!< STMicroeletronics STM8 8-bit microcontroller
#define EM_TILE64           187             //!< Tilera TILE64 multicore architecture family
#define EM_TILEPRO          188             //!< Tilera TILEPro multicore architecture family
#define EM_MICROBLAZE       189             //!< Xilinx MicroBlaze 32-bit RISC soft processor core
#define EM_CUDA             190             //!< NVIDIA CUDA architecture
#define EM_TILEGX           191             //!< Tilera TILE-Gx multicore architecture family

/*
 * e_version (version)
 */
#define EV_NONE             0               //!< Invalid version
#define EV_CURRENT          1               //!< Current version


/*********************************************
 * Section
 *********************************************/
typedef struct
{
  Elf32_Word            sh_name;                    //!< This member specifies the name of the section
  Elf32_Word            sh_type;                    //!< This member categorizes the section's contents and semantics
  Elf32_Word            sh_flags;                   //!< Sections support 1-bit flags that describe miscellaneous attributes
  Elf32_Addr            sh_addr;                    //!< If the section will appear in the memory image of a process, this member gives the address at which the section's first byte should reside
  Elf32_Off             sh_offset;                  //!< This member's value gives the byte offset from the beginning of the file to the first byte in the section
  Elf32_Word            sh_size;                    //!< This member gives the section's size in bytes
  Elf32_Word            sh_link;                    //!< This member holds a section header table index link, whose interpretation depends on the section type
  Elf32_Word            sh_info;                    //!< This member holds extra information, whose interpretation depends on the section type
  Elf32_Word            sh_addralign;               //!< Some sections have address alignment constraints
  Elf32_Word            sh_entsize;                 //!< Some sections hold a table of fixed-size entries, such as a symbol table
} Elf32_Shdr;       //!< 32bit Section header

typedef struct
{
  Elf64_Word            sh_name;                    //!< This member specifies the name of the section
  Elf64_Word            sh_type;                    //!< This member categorizes the section's contents and semantics
  Elf64_Xword           sh_flags;                   //!< Sections support 1-bit flags that describe miscellaneous attributes
  Elf64_Addr            sh_addr;                    //!< If the section will appear in the memory image of a process, this member gives the address at which the section's first byte should reside
  Elf64_Off             sh_offset;                  //!< This member's value gives the byte offset from the beginning of the file to the first byte in the section
  Elf64_Xword           sh_size;                    //!< This member gives the section's size in bytes
  Elf64_Word            sh_link;                    //!< This member holds a section header table index link, whose interpretation depends on the section type
  Elf64_Word            sh_info;                    //!< This member holds extra information, whose interpretation depends on the section type
  Elf64_Xword           sh_addralign;               //!< Some sections have address alignment constraints
  Elf64_Xword           sh_entsize;                 //!< Some sections hold a table of fixed-size entries, such as a symbol table
} Elf64_Shdr;       //!< 64bit Section header

/*
 * Special Section Indexes
 */
#define SHN_UNDEF           0                   //!< This value marks an undefined, missing, irrelevant, or otherwise meaningless section reference
#define SHN_LORESERVE       0xff00              //!< This value specifies the lower bound of the range of reserved indexes
#define SHN_LOPROC          0xff00              //!< Values in this inclusive range are reserved for processor-specific semantics
#define SHN_HIPROC          0xff1f              //!< Values in this inclusive range are reserved for processor-specific semantics
#define SHN_LOOS            0xff20              //!< Values in this inclusive range are reserved for operating system-specific semantics
#define SHN_HIOS            0xff3f              //!< Values in this inclusive range are reserved for operating system-specific semantics
#define SHN_ABS             0xfff1              //!< This value specifies absolute values for the corresponding reference
#define SHN_COMMON          0xfff2              //!< Symbols defined relative to this section are common symbols
#define SHN_XINDEX          0xffff              //!< This value is an escape value
#define SHN_HIRESERVE       0xffff              //!< This value specifies the upper bound of the range of reserved indexes

/*
 * sh_type
 */
#define SHT_NULL            0                   //!< This value marks the section header as inactive
#define SHT_PROGBITS        1                   //!< The section holds information defined by the program
#define SHT_SYMTAB          2                   //!< These sections hold a symbol table
#define SHT_STRTAB          3                   //!< The section holds a string table
#define SHT_RELA            4                   //!< The section holds relocation entries with explicit addends, such as type Elf32_Rela for the 32-bit class of object files or type Elf64_Rela for the 64-bit class of object files
#define SHT_HASH            5                   //!< The section holds a symbol hash table
#define SHT_DYNAMIC         6                   //!< The section holds information for dynamic linking
#define SHT_NOTE            7                   //!< The section holds information that marks the file in some way
#define SHT_NOBITS          8                   //!< A section of this type occupies no space in the file but otherwise resembles SHT_PROGBITS
#define SHT_REL             9                   //!< The section holds relocation entries without explicit addends, such as type Elf32_Rel for the 32-bit class of object files or type Elf64_Rel for the 64-bit class of object files
#define SHT_SHLIB           10                  //!< This section type is reserved but has unspecified semantics
#define SHT_DYNSYM          11                  //!<
#define SHT_INIT_ARRAY      14                  //!< This section contains an array of pointers to initialization functions
#define SHT_FINI_ARRAY      15                  //!< This section contains an array of pointers to termination functions
#define SHT_PREINIT_ARRAY   16                  //!< This section contains an array of pointers to functions that are invoked before all other initialization functions
#define SHT_GROUP           17                  //!< This section defines a section group
#define SHT_SYMTAB_SHNDX    18                  //!< This section is associated with a section of type SHT_SYMTAB and is required if any of the section header indexes referenced by that symbol table contain the escape value SHN_XINDEX
#define SHT_LOOS            0x60000000          //!< Values in this inclusive range are reserved for operating system-specific semantics
#define SHT_HIOS            0x6fffffff          //!< Values in this inclusive range are reserved for operating system-specific semantics
#define SHT_LOPROC          0x70000000          //!< Values in this inclusive range are reserved for processor-specific semantics
#define SHT_HIPROC          0x7fffffff          //!< Values in this inclusive range are reserved for processor-specific semantics
#define SHT_LOUSER          0x80000000          //!< This value specifies the upper bound of the range of indexes reserved for application programs
#define SHT_HIUSER          0x8fffffff          //!< This value specifies the upper bound of the range of indexes reserved for application programs

/*
 * sh_flags
 */
#define SHF_WRITE               0x1             //!< The section contains data that should be writable during process execution
#define SHF_ALLOC               0x2             //!< The section occupies memory during process execution
#define SHF_EXECINSTR           0x4             //!< The section contains executable machine instructions
#define SHF_MERGE               0x10            //!< The data in the section may be merged to eliminate duplication
#define SHF_STRINGS             0x20            //!< The data elements in the section consist of null-terminated character strings
#define SHF_INFO_LINK           0x40            //!< The sh_info field of this section header holds a section header table index
#define SHF_LINK_ORDER          0x80            //!< This flag adds special ordering requirements for link editors
#define SHF_OS_NONCONFORMING    0x100           //!< This section requires special OS-specific processing (beyond the standard linking rules) to avoid incorrect behavior
#define SHF_GROUP               0x200           //!< This section is a member (perhaps the only one) of a section group
#define SHF_TLS                 0x400           //!< This section holds Thread-Local Storage, meaning that each separate execution flow has its own distinct instance of this data
#define SHF_MASKOS              0x0ff00000      //!< All bits included in this mask are reserved for operating system-specific semantics
#define SHF_MASKPROC            0xf0000000      //!< All bits included in this mask are reserved for processor-specific semantics


/*********************************************
 * Symbol
 *********************************************/
typedef struct
{
    Elf32_Word          st_name;                //!< This member holds an index into the object file's symbol string table, which holds the character representations of the symbol names
    Elf32_Addr          st_value;               //!< This member gives the value of the associated symbol
    Elf32_Word          st_size;                //!< Many symbols have associated sizes
    unsigned char       st_info;                //!< This member specifies the symbol's type and binding attributes
    unsigned char       st_other;               //!< This member currently specifies a symbol's visibility
    Elf32_Section       st_shndx;               //!< Every symbol table entry is defined in relation to some section
} Elf32_Sym;

typedef struct
{
    Elf64_Word          st_name;                //!< This member holds an index into the object file's symbol string table, which holds the character representations of the symbol names
    unsigned char       st_info;                //!< This member specifies the symbol's type and binding attributes
    unsigned char       st_other;               //!< This member currently specifies a symbol's visibility
    Elf64_Section       st_shndx;               //!< Every symbol table entry is defined in relation to some section
    Elf64_Addr          st_value;               //!< This member gives the value of the associated symbol
    Elf64_Xword         st_size;                //!< Many symbols have associated sizes
} Elf64_Sym;

/*
 * st_info
 */
#define ELF32_ST_BIND(i)            ((i)>>4)
#define ELF32_ST_TYPE(i)            ((i)&0xf)
#define ELF32_ST_INFO(b,t)          (((b)<<4)+((t)&0xf))

#define ELF64_ST_BIND(i)            ((i)>>4)
#define ELF64_ST_TYPE(i)            ((i)&0xf)
#define ELF64_ST_INFO(b,t)          (((b)<<4)+((t)&0xf))


/* st_info (symbol binding) */
#define STB_LOCAL               0           //!< Local symbols are not visible outside the object file containing their definition
#define STB_GLOBAL              1           //!< Global symbols are visible to all object files being combined
#define STB_WEAK                2           //!< Weak symbols resemble global symbols, but their definitions have lower precedence
#define STB_LOOS                10          //!< Values in this inclusive range are reserved for operating system-specific semantics
#define STB_HIOS                12          //!< Values in this inclusive range are reserved for operating system-specific semantics
#define STB_LOPROC              13          //!< Values in this inclusive range are reserved for processor-specific semantics
#define STB_HIPROC              15          //!< Values in this inclusive range are reserved for processor-specific semantics

/* st_info (symbol type)  */
#define STT_NOTYPE              0           //!< The symbol's type is not specified
#define STT_OBJECT              1           //!< The symbol is associated with a data object, such as a variable, an array, and so on
#define STT_FUNC                2           //!< The symbol is associated with a function or other executable code
#define STT_SECTION             3           //!< The symbol is associated with a section
#define STT_FILE                4           //!< Conventionally, the symbol's name gives the name of the source file associated with the object file
#define STT_COMMON              5           //!< The symbol labels an uninitialized common block
#define STT_TLS                 6           //!<  The symbol specifies a Thread-Local Storage entity
#define STT_LOOS                10          //!< Values in this inclusive range are reserved for operating system-specific semantics
#define STT_HIOS                12          //!< Values in this inclusive range are reserved for operating system-specific semantics
#define STT_LOPROC              13          //!< Values in this inclusive range are reserved for processor-specific semantics
#define STT_HIPROC              15          //!< Values in this inclusive range are reserved for processor-specific semantics

/*
 * st_other
 */
#define ELF32_ST_VISIBILITY(o)          ((o)&0x3)
#define ELF64_ST_VISIBILITY(o)          ((o)&0x3)


#define STV_DEFAULT             0         //!< The visibility of symbols with the STV_DEFAULT attribute is as specified by the symbol's binding type
#define STV_INTERNAL            1         //!< A symbol defined in the current component is protected if it is visible in other components but not preemptable, meaning that any reference to such a symbol from within the defining component must be resolved to the definition in that component, even if there is a definition in another component that would preempt by the default rules
#define STV_HIDDEN              2         //!< A symbol defined in the current component is hidden if its name is not visible to other components
#define STV_PROTECTED           3         //!< The meaning of this visibility attribute may be defined by processor supplements to further constrain hidden symbols


/*********************************************
 * Relocation
 *********************************************/
typedef struct
{
    Elf32_Addr          r_offset;           //!< This member gives the location at which to apply the relocation action
    Elf32_Word          r_info;             //!< This member gives both the symbol table index with respect to which the relocation must be made, and the type of relocation to apply
} Elf32_Rel;        //!< 32bits Relocation Entries

typedef struct
{
    Elf64_Addr          r_offset;           //!< This member gives the location at which to apply the relocation action
    Elf64_Xword         r_info;             //!< This member gives both the symbol table index with respect to which the relocation must be made, and the type of relocation to apply
} Elf64_Rel;        //!< 32bits Relocation Entries

typedef struct
{
    Elf32_Addr          r_offset;           //!< This member gives the location at which to apply the relocation action
    Elf32_Word          r_info;             //!< This member gives both the symbol table index with respect to which the relocation must be made, and the type of relocation to apply
    Elf32_Sword         r_addend;           //!< This member specifies a constant addend used to compute the value to be stored into the relocatable field
} Elf32_Rela;        //!< 32bits Relocation Addend Entries

typedef struct
{
    Elf64_Addr          r_offset;           //!< This member gives the location at which to apply the relocation action
    Elf64_Xword         r_info;             //!< This member gives both the symbol table index with respect to which the relocation must be made, and the type of relocation to apply
    Elf64_Sxword        r_addend;           //!< This member specifies a constant addend used to compute the value to be stored into the relocatable field
} Elf64_Rela;        //!< 32bits Relocation Addend Entries


/*
 * r_info
 */
#define ELF32_R_SYM(i)              ((i)>>8)
#define ELF32_R_TYPE(i)             ((unsigned char)(i))
#define ELF32_R_INFO(s,t)           (((s)<<8)+(unsigned char)(t))

#define ELF64_R_SYM(i)              ((i)>>32)
#define ELF64_R_TYPE(i)             ((i)&0xffffffffL)
#define ELF64_R_INFO(s,t)           (((s)<<32)+((t)&0xffffffffL))



/*********************************************
 * Program
 *********************************************/
typedef struct
{
    Elf32_Word          p_type;             //!< This member tells what kind of segment this array element describes or how to interpret the array element's information
    Elf32_Off           p_offset;           //!< This member gives the offset from the beginning of the file at which the first byte of the segment resides
    Elf32_Addr          p_vaddr;            //!< This member gives the virtual address at which the first byte of the segment resides in memory
    Elf32_Addr          p_paddr;            //!< On systems for which physical addressing is relevant, this member is reserved for the segment's physical address
    Elf32_Word          p_filesz;           //!< This member gives the number of bytes in the file image of the segment; it may be zero
    Elf32_Word          p_memsz;            //!< This member gives the number of bytes in the memory image of the segment; it may be zero
    Elf32_Word          p_flags;            //!< This member gives flags relevant to the segment
    Elf32_Word          p_align;            //!< As ``Program Loading'' describes in this chapter of the processor supplement, loadable process segments must have congruent values for p_vaddr and p_offset, modulo the page size
} Elf32_Phdr;       //!< 32bits Program header

typedef struct
{
    Elf64_Word          p_type;             //!< This member tells what kind of segment this array element describes or how to interpret the array element's information
    Elf64_Word          p_flags;            //!< This member gives flags relevant to the segment
    Elf64_Off           p_offset;           //!< This member gives the offset from the beginning of the file at which the first byte of the segment resides
    Elf64_Addr          p_vaddr;            //!< This member gives the virtual address at which the first byte of the segment resides in memory
    Elf64_Addr          p_paddr;            //!< On systems for which physical addressing is relevant, this member is reserved for the segment's physical address
    Elf64_Xword         p_filesz;           //!< This member gives the number of bytes in the file image of the segment; it may be zero
    Elf64_Xword         p_memsz;            //!< This member gives the number of bytes in the memory image of the segment; it may be zero
    Elf64_Xword         p_align;            //!< As ``Program Loading'' describes in this chapter of the processor supplement, loadable process segments must have congruent values for p_vaddr and p_offset, modulo the page size
} Elf64_Phdr;       //!< 64bits Program header

/*
 * p_type
 */
#define PT_NULL                 0                   //!< The array element is unused; other members' values are undefined
#define PT_LOAD                 1                   //!< The array element specifies a loadable segment, described by p_filesz and p_memsz
#define PT_DYNAMIC              2                   //!< The array element specifies dynamic linking information
#define PT_INTERP               3                   //!< The array element specifies the location and size of a null-terminated path name to invoke as an interpreter
#define PT_NOTE                 4                   //!< The array element specifies the location and size of auxiliary information
#define PT_SHLIB                5                   //!< This segment type is reserved but has unspecified semantics
#define PT_PHDR                 6                   //!< The array element, if present, specifies the location and size of the program header table itself, both in the file and in the memory image of the program
#define PT_TLS                  7                   //!< The array element specifies the Thread-Local Storage template
#define PT_LOOS                 0x60000000          //!< Values in this inclusive range are reserved for operating system-specific semantics
#define PT_HIOS                 0x6fffffff          //!< Values in this inclusive range are reserved for operating system-specific semantics
#define PT_LOPROC               0x70000000          //!< Values in this inclusive range are reserved for processor-specific semantics
#define PT_HIPROC               0x7fffffff          //!< Values in this inclusive range are reserved for processor-specific semantics

/*
 * p_flags
 */
#define PF_X                    (1 << 0)            //!< Execute
#define PF_W                    (1 << 1)            //!< Write
#define PF_R                    (1 << 2)            //!< Read
#define PF_MASKOS               0x0ff00000          //!< Unspecified
#define PF_MASKPROC             0xf0000000          //!< Unspecified

#endif