path: root/src/arch/x86/registers.c

/* OpenIDA - Outil d'analyse de fichiers binaires
 * registers.c - aides auxiliaires relatives aux registres x86
 *
 * Copyright (C) 2009 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/>.
 */


#include "registers.h"


#include <malloc.h>
#include <stdio.h>



/* Liste des registres 8 bits */
typedef enum _X868bRegister
{
    X86_REG8_AL = 0,                        /* Registre AL                 */
    X86_REG8_CL = 1,                        /* Registre AL                 */
    X86_REG8_DL = 2,                        /* Registre AL                 */
    X86_REG8_BL = 3,                        /* Registre AL                 */
    X86_REG8_AH = 4,                        /* Registre AH                 */
    X86_REG8_CH = 5,                        /* Registre AH                 */
    X86_REG8_DH = 6,                        /* Registre AH                 */
    X86_REG8_BH = 7,                        /* Registre AH                 */

    X86_REG8_NONE                           /* Aucun registre              */

} X868bRegister;

/* Liste des registres 16 bits */
typedef enum _X8616bRegister
{
    X86_REG16_AX = 0,                       /* Registre AX                 */
    X86_REG16_CX = 1,                       /* Registre AX                 */
    X86_REG16_DX = 2,                       /* Registre AX                 */
    X86_REG16_BX = 3,                       /* Registre AX                 */
    X86_REG16_SP = 4,                       /* Registre SP                 */
    X86_REG16_BP = 5,                       /* Registre BP                 */
    X86_REG16_SI = 6,                       /* Registre SI                 */
    X86_REG16_DI = 7,                       /* Registre DI                 */

    X86_REG16_NONE                          /* Aucun registre              */

} X8616bRegister;

/* Liste des registres 32 bits */
typedef enum _X8632bRegister
{
    X86_REG32_EAX = 0,                      /* Registre EAX                */
    X86_REG32_ECX = 1,                      /* Registre EAX                */
    X86_REG32_EDX = 2,                      /* Registre EAX                */
    X86_REG32_EBX = 3,                      /* Registre EAX                */
    X86_REG32_ESP = 4,                      /* Registre ESP                */
    X86_REG32_EBP = 5,                      /* Registre EBP                */
    X86_REG32_ESI = 6,                      /* Registre ESI                */
    X86_REG32_EDI = 7,                      /* Registre EDI                */

    X86_REG32_NONE                          /* Aucun registre              */

} X8632bRegister;


/* Registre x86 */
struct _x86_register
{
    union
    {
        X868bRegister reg8;                 /* Registre 8 bits             */
        X8616bRegister reg16;               /* Registre 16 bits            */
        X8632bRegister reg32;               /* Registre 32 bits            */

    } reg;

    AsmOperandSize size;                    /* Taille de ce registre       */

};



/******************************************************************************
*                                                                             *
*  Paramètres  : size  = indique la taille du registre.                       *
*                value = valeur correspondant au registre.                    *
*                                                                             *
*  Description : Récupère l'indentifiant interne d'un registre.               *
*                                                                             *
*  Retour      : Registre définit ou NULL.                                    *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

x86_register *get_x86_register(AsmOperandSize size, bin_t value)
{
    x86_register *result;                   /* Représentation à renvoyer   */

    result = (x86_register *)calloc(1, sizeof(x86_register));

    result->size = size;

    switch (size)
    {
        case AOS_8_BITS:
            switch (value)
            {
                case 0 ... 7:
                    result->reg.reg8 = (X868bRegister)value;
                    break;
                default:
                    goto gxr_error;
                    break;
            }
            break;

        case AOS_16_BITS:
            switch (value)
            {
                case 0 ... 7:
                    result->reg.reg16 = (X8616bRegister)value;
                    break;
                default:
                    goto gxr_error;
                    break;
            }
            break;

        case AOS_32_BITS:
            switch (value)
            {
                case 0 ... 7:
                    result->reg.reg32 = (X8632bRegister)value;
                    break;
                default:
                    goto gxr_error;
                    break;
            }
            break;

        default:
            goto gxr_error;
            break;

    }

    return result;

 gxr_error:

    free(result);

    return NULL;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = registre à supprimer.                                  *
*                                                                             *
*  Description : Efface de la mémoire l'indentifiant interne d'un registre.   *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void free_x86_register(x86_register *reg)
{
    free(reg);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = registre à consulter.                                  *
*                                                                             *
*  Description : Indique si le registre correspond à ebp ou similaire.        *
*                                                                             *
*  Retour      : true si la correspondance est avérée, false sinon.           *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool is_x86_register_base_pointer(const x86_register *reg)
{
    bool result;                            /* Bilan à remonter            */

    switch (reg->size)
    {
        case AOS_8_BITS_UNSIGNED:
        case AOS_8_BITS_SIGNED:
            result = (reg->reg.reg8 == X86_REG8_CH);
            break;
        case AOS_16_BITS_UNSIGNED:
        case AOS_16_BITS_SIGNED:
            result = (reg->reg.reg16 == X86_REG16_BP);
            break;
        case AOS_32_BITS_UNSIGNED:
        case AOS_32_BITS_SIGNED:
            result = (reg->reg.reg32 == X86_REG32_EBP);
            break;
            /*
        case AOS_64_BITS_UNSIGNED:
        case AOS_64_BITS_SIGNED:
            result = (reg->reg.reg8 == X86_REG8_CH);
            break;
            */
        default:
            result = false;

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg = registre à consulter.                                  *
*                                                                             *
*  Description : Indique si le registre correspond à esp ou similaire.        *
*                                                                             *
*  Retour      : true si la correspondance est avérée, false sinon.           *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool is_x86_register_stack_pointer(const x86_register *reg)
{
    bool result;                            /* Bilan à remonter            */

    switch (reg->size)
    {
        case AOS_8_BITS_UNSIGNED:
        case AOS_8_BITS_SIGNED:
            result = (reg->reg.reg8 == X86_REG8_AH);
            break;
        case AOS_16_BITS_UNSIGNED:
        case AOS_16_BITS_SIGNED:
            result = (reg->reg.reg16 == X86_REG16_SP);
            break;
        case AOS_32_BITS_UNSIGNED:
        case AOS_32_BITS_SIGNED:
            result = (reg->reg.reg32 == X86_REG32_ESP);
            break;
            /*
        case AOS_64_BITS_UNSIGNED:
        case AOS_64_BITS_SIGNED:
            result = (reg->reg.reg8 == X86_REG8_CH);
            break;
            */
        default:
            result = false;

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : reg    = registre à imprimer.                                *
*                syntax = type de représentation demandée.                    *
*                                                                             *
*  Description : Traduit un registre x86 en texte.                            *
*                                                                             *
*  Retour      : Traduction en chaîne à libérer de la mémoire.                *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

char *x86_register_as_text(const x86_register *reg, AsmSyntax syntax)
{
    char *result;                           /* Chaîne à renvoyer           */

    result = (char *)calloc(5, sizeof(char));

    switch (syntax)
    {
        case ASX_INTEL:
            switch (reg->size)
            {
                case AOS_8_BITS:
                    switch (reg->reg.reg8)
                    {
                        case X86_REG8_AL:
                            snprintf(result, 5, "al");
                            break;
                        case X86_REG8_CL:
                            snprintf(result, 5, "cl");
                            break;
                        case X86_REG8_DL:
                            snprintf(result, 5, "dl");
                            break;
                        case X86_REG8_BL:
                            snprintf(result, 5, "bl");
                            break;
                        case X86_REG8_AH:
                            snprintf(result, 5, "ah");
                            break;
                        case X86_REG8_CH:
                            snprintf(result, 5, "ch");
                            break;
                        case X86_REG8_DH:
                            snprintf(result, 5, "dh");
                            break;
                        case X86_REG8_BH:
                            snprintf(result, 5, "bh");
                            break;
                        case X86_REG8_NONE:
                            /* Ne devrait jamais arriver */
                            break;
                    }
                    break;

                case AOS_16_BITS:
                    switch (reg->reg.reg16)
                    {
                        case X86_REG16_AX:
                            snprintf(result, 5, "ax");
                            break;
                        case X86_REG16_CX:
                            snprintf(result, 5, "cx");
                            break;
                        case X86_REG16_DX:
                            snprintf(result, 5, "dx");
                            break;
                        case X86_REG16_BX:
                            snprintf(result, 5, "bx");
                            break;
                        case X86_REG16_SP:
                            snprintf(result, 5, "sp");
                            break;
                        case X86_REG16_BP:
                            snprintf(result, 5, "bp");
                            break;
                        case X86_REG16_SI:
                            snprintf(result, 5, "si");
                            break;
                        case X86_REG16_DI:
                            snprintf(result, 5, "di");
                            break;
                        case X86_REG16_NONE:
                            /* Ne devrait jamais arriver */
                            break;
                    }
                    break;

                case AOS_32_BITS:
                    switch (reg->reg.reg32)
                    {
                        case X86_REG32_EAX:
                            snprintf(result, 5, "eax");
                            break;
                        case X86_REG32_ECX:
                            snprintf(result, 5, "ecx");
                            break;
                        case X86_REG32_EDX:
                            snprintf(result, 5, "edx");
                            break;
                        case X86_REG32_EBX:
                            snprintf(result, 5, "ebx");
                            break;
                        case X86_REG32_ESP:
                            snprintf(result, 5, "esp");
                            break;
                        case X86_REG32_EBP:
                            snprintf(result, 5, "ebp");
                            break;
                        case X86_REG32_ESI:
                            snprintf(result, 5, "esi");
                            break;
                        case X86_REG32_EDI:
                            snprintf(result, 5, "edi");
                            break;
                        case X86_REG32_NONE:
                            printf("null reg\n");
                            /* Ne devrait jamais arriver */
                            break;
                    }
                    break;

                default:
                    break;

            }
            break;

        case ASX_ATT:
            switch (reg->size)
            {
                case AOS_8_BITS:
                    switch (reg->reg.reg8)
                    {
                        case X86_REG8_AL:
                            snprintf(result, 5, "%%al");
                            break;
                        case X86_REG8_CL:
                            snprintf(result, 5, "%%cl");
                            break;
                        case X86_REG8_DL:
                            snprintf(result, 5, "%%dl");
                            break;
                        case X86_REG8_BL:
                            snprintf(result, 5, "%%bl");
                            break;
                        case X86_REG8_AH:
                            snprintf(result, 5, "%%ah");
                            break;
                        case X86_REG8_CH:
                            snprintf(result, 5, "%%ch");
                            break;
                        case X86_REG8_DH:
                            snprintf(result, 5, "%%dh");
                            break;
                        case X86_REG8_BH:
                            snprintf(result, 5, "%%bh");
                            break;
                        case X86_REG8_NONE:
                            /* Ne devrait jamais arriver */
                            break;
                    }
                    break;

                case AOS_16_BITS:
                    switch (reg->reg.reg16)
                    {
                        case X86_REG16_AX:
                            snprintf(result, 5, "%%ax");
                            break;
                        case X86_REG16_CX:
                            snprintf(result, 5, "%%cx");
                            break;
                        case X86_REG16_DX:
                            snprintf(result, 5, "%%dx");
                            break;
                        case X86_REG16_BX:
                            snprintf(result, 5, "%%bx");
                            break;
                        case X86_REG16_SP:
                            snprintf(result, 5, "%%sp");
                            break;
                        case X86_REG16_BP:
                            snprintf(result, 5, "%%bp");
                            break;
                        case X86_REG16_SI:
                            snprintf(result, 5, "%%si");
                            break;
                        case X86_REG16_DI:
                            snprintf(result, 5, "%%di");
                            break;
                        case X86_REG16_NONE:
                            /* Ne devrait jamais arriver */
                            break;
                    }
                    break;

                case AOS_32_BITS:
                    switch (reg->reg.reg32)
                    {
                        case X86_REG32_EAX:
                            snprintf(result, 5, "%%eax");
                            break;
                        case X86_REG32_ECX:
                            snprintf(result, 5, "%%ecx");
                            break;
                        case X86_REG32_EDX:
                            snprintf(result, 5, "%%edx");
                            break;
                        case X86_REG32_EBX:
                            snprintf(result, 5, "%%ebx");
                            break;
                        case X86_REG32_ESP:
                            snprintf(result, 5, "%%esp");
                            break;
                        case X86_REG32_EBP:
                            snprintf(result, 5, "%%ebp");
                            break;
                        case X86_REG32_ESI:
                            snprintf(result, 5, "%%esi");
                            break;
                        case X86_REG32_EDI:
                            snprintf(result, 5, "%%edi");
                            break;
                        case X86_REG32_NONE:
                            /* Ne devrait jamais arriver */
                            break;
                    }
                    break;

                default:
                    break;

            }
            break;

        default:
            break;

    }

    return result;

}