/* OpenIDA - Outil d'analyse de fichiers binaires
 * elf-int.h - prototypes pour les structures internes du format ELF
 *
 * Copyright (C) 2008 Cyrille Bagard
 *
 *  This file is part of OpenIDA.
 *
 *  OpenIDA is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  OpenIDA 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 Foobar.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef _FORMAT_ELF_ELF_INT_H
#define _FORMAT_ELF_ELF_INT_H



#include <elf.h>
#include <sys/types.h>


#include "../exe_format-int.h"



/* Chaîne de caractères présente */
typedef struct _elf_string
{
    const char *value;                      /* Valeur humainement lisible  */
    size_t len;                             /* Longueur de la chaîne       */
    vmpa_t address;                         /* Adresse de localisation     */

} elf_string;

/* Symbole trouvé */
typedef struct _elf_symbol
{
    const char *name;                       /* Désignation du symbole      */
    uint64_t address;                       /* Adresse du symbole          */
    off_t size;                             /* Taille du code associé      */

} elf_symbol;

/* Relocalisation trouvée */
typedef struct _elf_relocation
{
    const char *name;                       /* Désignation du symbole      */
    vmpa_t address;                         /* Adresse du symbole          */

} elf_relocation;



/* Description du format ELF */
struct _elf_format
{
    exe_format dummy;                       /* A laisser en premier        */

    Elf32_Ehdr header;                      /* En-tête du format           */
    bool is_32b;                            /* Format du binaire           */

    char *sec_names;                        /* Noms des sections           */
    size_t sec_size;                        /* Taille de ces définitions   */

    elf_relocation *relocations;            /* Liste des relocalisations   */
    size_t rel_count;                       /* Taille de cette liste       */

    GBinRoutine **routines;                 /* Liste des routines trouvées */
    size_t routines_count;                  /* Nombre de ces routines      */

    elf_symbol *symbols;                    /* Liste des symboles          */
    size_t sym_count;                       /* Taille de cette liste       */

    elf_string *strings;                    /* Liste des chaînes           */
    size_t str_count;                       /* Taille de cette liste       */

};




/* En-tête de programme ELF */
typedef union _Elf_Phdr
{
    Elf32_Phdr header32;                    /* Version 32 bits             */
    Elf64_Phdr header64;                    /* Version 64 bits             */

} Elf_Phdr;

#define ELF_PHDR(fmt, hdr, fld) (fmt->is_32b ? (hdr)->header32.fld : (hdr)->header64.fld)


/* Entrée de la table de relocalisation */

typedef union _Elf_Rel
{
    Elf32_Rel rel32;                        /* Version 32 bits             */
    Elf64_Rel rel64;                        /* Version 64 bits             */

} Elf_Rel;

#define ELF_SIZEOF_REL(fmt) (fmt->is_32b ? sizeof(Elf32_Rel) : sizeof(Elf64_Rel))

#define ELF_REL(fmt, rl, fld) (fmt->is_32b ? rl.rel32.fld : rl.rel64.fld)

#define ELF_REL_SYM(fmt, rl) (fmt->is_32b ? ELF32_R_SYM(rl.rel32.r_info) : ELF64_R_SYM(rl.rel64.r_info))
#define ELF_REL_TYPE(fmt, rl) (fmt->is_32b ? ELF32_R_TYPE(rl.rel32.r_info) : ELF64_R_TYPE(rl.rel64.r_info))


/* Information sur un symbole */

typedef union _Elf_Sym
{
    Elf32_Sym sym32;                        /* Version 32 bits             */
    Elf64_Sym sym64;                        /* Version 64 bits             */

} Elf_Sym;

#define ELF_SIZEOF_SYM(fmt) (fmt->is_32b ? sizeof(Elf32_Sym) : sizeof(Elf64_Sym))

#define ELF_SYM(fmt, sb, fld) (fmt->is_32b ? sb.sym32.fld : sb.sym64.fld)


#define ELF_ST_TYPE ELF32_ST_TYPE




#endif  /* _FORMAT_ELF_ELF_INT_H */