/* OpenIDA - Outil d'analyse de fichiers binaires
* operand.c - gestion des operandes de l'architecture x86
*
* 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 .
*/
#include "operand.h"
#include
#include
#include
#include
#include "../operand.h"
#include "../operand-int.h"
#define MAX(a, b) ((a) > (b) ? (a) : (b))
/* 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 */
typedef union _x86_register
{
X868bRegister reg8; /* Registre 8 bits */
X8616bRegister reg16; /* Registre 16 bits */
X8632bRegister reg32; /* Registre 32 bits */
} x86_register;
/* Définition d'une opérande x86 */
struct _asm_x86_operand
{
asm_operand base; /* A laisser en premier */
x86_register rindex; /* Registre servant d'indice */
bool content; /* Contenu d'un registre */
uint8_t scale; /* Puissance de deux */
x86_register rbase; /* Registre de base */
asm_operand *displacement; /* Décallage supplémentaire */
};
#define NULL ((void *)0)
/* Récupère l'indentifiant interne d'un registre. */
bool get_x86_register(x86_register *, AsmOperandSize, uint8_t);
/* Traduit une opérande de registre en texte. */
void _x86_print_reg_operand(const x86_register *reg, AsmOperandSize, char *, size_t, AsmSyntax);
/* Crée une opérande renvoyant vers un registre 16 ou 32 bits. */
asm_x86_operand *x86_create_r1632_operand_from_opcode(uint8_t, bool, uint8_t);
/******************************************************************************
* *
* Paramètres : - *
* *
* Description : Crée une opérande vierge pour x86. *
* *
* Retour : Opérande nouvellement créée. *
* *
* Remarques : - *
* *
******************************************************************************/
asm_x86_operand *create_new_x86_operand(void)
{
asm_x86_operand *result; /* Structure à retourner */
result = (asm_x86_operand *)calloc(1, sizeof(asm_x86_operand));
result->scale = 0;
result->rbase.reg32 = X86_REG32_NONE;
return result;
}
/******************************************************************************
* *
* Paramètres : reg = registre à définir. [OUT] *
* size = indique la taille du registre. *
* value = valeur correspondant au registre. *
* *
* Description : Récupère l'indentifiant interne d'un registre. *
* *
* Retour : true si la définition est opérée, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
bool get_x86_register(x86_register *reg, AsmOperandSize size, uint8_t value)
{
switch (size)
{
case AOS_8_BITS:
switch (value)
{
case 0 ... 7:
reg->reg8 = (X868bRegister)value;
break;
default:
return false;
break;
}
break;
case AOS_16_BITS:
switch (value)
{
case 0 ... 7:
reg->reg16 = (X8616bRegister)value;
break;
default:
return false;
break;
}
break;
case AOS_32_BITS:
switch (value)
{
case 0 ... 7:
reg->reg32 = (X8632bRegister)value;
break;
default:
return false;
break;
}
break;
case AOS_64_BITS:
return false;
break;
}
return true;
}
/******************************************************************************
* *
* Paramètres : data = donnée à analyser. *
* is_reg32 = indique si le registre est un registre 32 bits. *
* base = valeur du premier registre. *
* *
* Description : Crée une opérande renvoyant vers un registre 16 ou 32 bits. *
* *
* Retour : Opérande mise en place ou NULL. *
* *
* Remarques : - *
* *
******************************************************************************/
asm_x86_operand *x86_create_reg1632_operand(uint8_t data, bool is_reg32, uint8_t base)
{
asm_x86_operand *result; /* Registre à retourner */
result = create_new_x86_operand();
ASM_OPERAND(result)->type = AOT_REG;
ASM_OPERAND(result)->size = (is_reg32 ? AOS_32_BITS : AOS_16_BITS);
if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, data - base))
{
free(result);
return NULL;
}
return result;
}
/******************************************************************************
* *
* Paramètres : data = donnée à analyser. *
* is_reg32 = indique si le registre est un registre 32 bits. *
* first = indique la partie du ModR/M à traiter. *
* *
* Description : Crée une opérande renvoyant vers un registre 16 ou 32 bits. *
* *
* Retour : Opérande mise en place ou NULL. *
* *
* Remarques : - *
* *
******************************************************************************/
asm_x86_operand *x86_create_reg1632_operand_from_modrm(uint8_t data, bool is_reg32, bool first)
{
asm_x86_operand *result; /* Registre à retourner */
uint8_t reg; /* Transcription du registre */
if (first) reg = data & 0x07;
else reg = (data & 0x38) >> 3;
result = create_new_x86_operand();
ASM_OPERAND(result)->type = AOT_REG;
ASM_OPERAND(result)->size = (is_reg32 ? AOS_32_BITS : AOS_16_BITS);
if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, reg))
{
free(result);
return NULL;
}
return result;
}
/******************************************************************************
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
* len = taille totale des données à analyser. *
* is_reg32 = indique si le registre est un registre 32 bits. *
* first = indique la partie du ModR/M à traiter. *
* *
* Description : Crée une opérande renvoyant vers un contenu 16 ou 32 bits. *
* *
* Retour : Opérande mise en place ou NULL. *
* *
* Remarques : - *
* *
******************************************************************************/
asm_x86_operand *x86_create_content1632_operand(const uint8_t *data, off_t *pos, off_t len, bool is_reg32, bool first)
{
asm_x86_operand *result; /* Registre à retourner */
uint8_t mod; /* Modificateur présent */
/* Pas de contenu */
mod = (data[*pos] & 0xc0);
if (mod == 0xc0) return NULL;
result = x86_create_reg1632_operand_from_modrm(data[*pos], is_reg32, first);
if (result == NULL) return NULL;
result->content = true;
(*pos)++;
/* Vieille astuce de l'emplacement mémoire fixe ? */
if (result->rindex.reg32 == X86_REG32_EBP && mod == 0x00)
{
free(result);
result = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result), AOS_32_BITS/* FIXME ? */, data, pos, len))
{
(*pos)--;
free(result);
return NULL;
}
return result;
}
/* A la recherche d'un SIB */
if (result->rindex.reg32 == X86_REG32_ESP)
{
if (!get_x86_register(&result->rbase, ASM_OPERAND(result)->size, data[*pos] & 0x07))
{
(*pos)--;
free(result);
return NULL;
}
if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, (data[*pos] & 0x38) >> 3))
{
(*pos)--;
free(result);
return NULL;
}
result->scale = ((data[*pos] & 0xc0) >> 6);
if (result->rindex.reg32 == X86_REG32_ESP)
{
result->rindex.reg32 = result->rbase.reg32;
result->rbase.reg32 = X86_REG32_NONE;
}
(*pos)++;
}
/* Décallage supplémentaire ? */
switch (mod)
{
case 0x00:
if (result->rbase.reg32 == X86_REG32_EBP)
{
result->rbase.reg32 = X86_REG32_NONE;
result->displacement = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result->displacement), ASM_OPERAND(result)->size, data, pos, len))
{
(*pos) -= 2;
free(result->displacement);
free(result);
return NULL;
}
}
break;
case 0x40:
result->displacement = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result->displacement), AOS_8_BITS, data, pos, len))
{
(*pos) -= 2;
free(result->displacement);
free(result);
return NULL;
}
break;
case 0x80:
result->displacement = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result->displacement), AOS_32_BITS, data, pos, len))
{
(*pos) -= 2;
free(result->displacement);
free(result);
return NULL;
}
break;
}
return result;
}
/******************************************************************************
* *
* Paramètres : data = donnée à analyser. *
* first = indique la partie du ModR/M à traiter. *
* *
* Description : Crée une opérande renvoyant vers un registre 8 bits. *
* *
* Retour : Opérande mise en place ou NULL. *
* *
* Remarques : - *
* *
******************************************************************************/
asm_x86_operand *x86_create_r8_operand(uint8_t data, bool first)
{
asm_x86_operand *result; /* Registre à retourner */
uint8_t reg; /* Transcription du registre */
if (first) reg = data & 0x07;
else reg = (data & 0x38) >> 3;
result = create_new_x86_operand();
ASM_OPERAND(result)->type = AOT_REG;
ASM_OPERAND(result)->size = AOS_8_BITS;
if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, reg))
{
free(result);
return NULL;
}
return result;
}
/******************************************************************************
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
* len = taille totale des données à analyser. *
* *
* Description : Crée une opérande à partir d'un registre/une mémoire 8 bits. *
* *
* Retour : Opérande mise en place ou NULL. *
* *
* Remarques : - *
* *
******************************************************************************/
asm_x86_operand *x86_create_rm8_operand(const uint8_t *data, off_t *pos, off_t len, ...)
{
asm_x86_operand *result; /* Registre à retourner */
uint8_t mod; /* Modificateur présent */
/* Registre simple... */
result = x86_create_r8_operand(data[*pos], true);
if (result == NULL) return NULL;
mod = (data[*pos] & 0xc0);
(*pos)++;
if (mod == 0xc0) return result;
result->content = true;
/* Vieille astuce de l'emplacement mémoire fixe ? */
if (result->rindex.reg8 == X86_REG8_CH && mod == 0x00)
{
free(result);
result = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result), AOS_32_BITS/* FIXME! 16/32 */, data, pos, len))
{
free(result);
return NULL;
}
return result;
}
/* A la recherche d'un SIB */
if (result->rindex.reg8 == X86_REG8_AH)
{
if (!get_x86_register(&result->rbase, ASM_OPERAND(result)->size, data[*pos] & 0x07))
{
free(result);
return NULL;
}
if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, (data[*pos] & 0x38) >> 3))
{
free(result);
return NULL;
}
result->scale = ((data[*pos] & 0xc0) >> 6);
if (result->rindex.reg8 == X86_REG8_AH)
{
result->rindex.reg8 = result->rbase.reg8;
result->rbase.reg8 = X86_REG8_NONE;
}
(*pos)++;
}
/* Décallage supplémentaire ? */
switch (mod)
{
case 0x00:
if (result->rbase.reg8 == X86_REG8_CH)
{
result->rbase.reg8 = X86_REG8_NONE;
result->displacement = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result->displacement), ASM_OPERAND(result)->size, data, pos, len))
{
free(result->displacement);
free(result);
return NULL;
}
}
break;
case 0x40:
result->displacement = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result->displacement), AOS_8_BITS, data, pos, len))
{
free(result->displacement);
free(result);
return NULL;
}
break;
case 0x80:
result->displacement = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result->displacement), AOS_32_BITS/* FIXME ! 16/32 */, data, pos, len))
{
free(result->displacement);
free(result);
return NULL;
}
break;
}
return result;
}
/******************************************************************************
* *
* Paramètres : data = donnée à analyser. *
* is_reg32 = indique si le registre est un registre 32 bits. *
* first = indique la partie du ModR/M à traiter. *
* *
* Description : Crée une opérande renvoyant vers un registre 16 ou 32 bits. *
* *
* Retour : Opérande mise en place ou NULL. *
* *
* Remarques : - *
* *
******************************************************************************/
asm_x86_operand *x86_create_r1632_operand(uint8_t data, bool is_reg32, bool first)
{
asm_x86_operand *result; /* Registre à retourner */
uint8_t reg; /* Transcription du registre */
if (first) reg = data & 0x07;
else reg = (data & 0x38) >> 3;
result = create_new_x86_operand();
ASM_OPERAND(result)->type = AOT_REG;
ASM_OPERAND(result)->size = (is_reg32 ? AOS_32_BITS : AOS_16_BITS);
if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, reg))
{
free(result);
return NULL;
}
return result;
}
/******************************************************************************
* *
* Paramètres : data = donnée à analyser. *
* is_reg32 = indique si le registre est un registre 32 bits. *
* base = valeur du premier registre. *
* *
* Description : Crée une opérande renvoyant vers un registre 16 ou 32 bits. *
* *
* Retour : Opérande mise en place ou NULL. *
* *
* Remarques : - *
* *
******************************************************************************/
asm_x86_operand *x86_create_r1632_operand_from_opcode(uint8_t data, bool is_reg32, uint8_t base)
{
asm_x86_operand *result; /* Registre à retourner */
result = create_new_x86_operand();
ASM_OPERAND(result)->type = AOT_REG;
ASM_OPERAND(result)->size = (is_reg32 ? AOS_32_BITS : AOS_16_BITS);
if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, data - base))
{
free(result);
return NULL;
}
return result;
}
/******************************************************************************
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
* len = taille totale des données à analyser. *
* is_reg32 = indique si le registre est un registre 32 bits. *
* *
* Description : Crée une opérande à partir d'un registre/une mémoire 16/32b. *
* *
* Retour : Opérande mise en place ou NULL. *
* *
* Remarques : - *
* *
******************************************************************************/
asm_x86_operand *x86_create_rm1632_operand(const uint8_t *data, off_t *pos, off_t len, bool is_reg32, ...)
{
asm_x86_operand *result; /* Registre à retourner */
uint8_t mod; /* Modificateur présent */
/* Registre simple... */
result = x86_create_r1632_operand(data[*pos], is_reg32, true);
if (result == NULL) return NULL;
mod = (data[*pos] & 0xc0);
(*pos)++;
if (mod == 0xc0) return result;
result->content = true;
/* Vieille astuce de l'emplacement mémoire fixe ? */
if (result->rindex.reg32 == X86_REG32_EBP && mod == 0x00)
{
free(result);
result = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result), AOS_32_BITS/* FIXME ? */, data, pos, len))
{
free(result);
return NULL;
}
return result;
}
/* A la recherche d'un SIB */
if (result->rindex.reg32 == X86_REG32_ESP)
{
if (!get_x86_register(&result->rbase, ASM_OPERAND(result)->size, data[*pos] & 0x07))
{
free(result);
return NULL;
}
if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, (data[*pos] & 0x38) >> 3))
{
free(result);
return NULL;
}
result->scale = ((data[*pos] & 0xc0) >> 6);
if (result->rindex.reg32 == X86_REG32_ESP)
{
result->rindex.reg32 = result->rbase.reg32;
result->rbase.reg32 = X86_REG32_NONE;
}
(*pos)++;
}
/* Décallage supplémentaire ? */
switch (mod)
{
case 0x00:
if (result->rbase.reg32 == X86_REG32_EBP)
{
result->rbase.reg32 = X86_REG32_NONE;
result->displacement = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result->displacement), ASM_OPERAND(result)->size, data, pos, len))
{
free(result->displacement);
free(result);
return NULL;
}
}
break;
case 0x40:
result->displacement = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result->displacement), AOS_8_BITS, data, pos, len))
{
free(result->displacement);
free(result);
return NULL;
}
break;
case 0x80:
result->displacement = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result->displacement), AOS_32_BITS, data, pos, len))
{
free(result->displacement);
free(result);
return NULL;
}
break;
}
return result;
}
/******************************************************************************
* *
* Paramètres : reg = registre à imprimer. *
* size = indique la taille du registre. *
* buffer = tampon de sortie mis à disposition. [OUT] *
* len = taille de ce tampon. *
* syntax = type de représentation demandée. *
* *
* Description : Traduit une opérande de registre en texte. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void _x86_print_reg_operand(const x86_register *reg, AsmOperandSize size, char *buffer, size_t len, AsmSyntax syntax)
{
switch (syntax)
{
case ASX_INTEL:
switch (size)
{
case AOS_8_BITS:
switch (reg->reg8)
{
case X86_REG8_AL:
snprintf(buffer, len, "al");
break;
case X86_REG8_CL:
snprintf(buffer, len, "cl");
break;
case X86_REG8_DL:
snprintf(buffer, len, "dl");
break;
case X86_REG8_BL:
snprintf(buffer, len, "bl");
break;
case X86_REG8_AH:
snprintf(buffer, len, "ah");
break;
case X86_REG8_CH:
snprintf(buffer, len, "ch");
break;
case X86_REG8_DH:
snprintf(buffer, len, "dh");
break;
case X86_REG8_BH:
snprintf(buffer, len, "bh");
break;
case X86_REG8_NONE:
/* Ne devrait jamais arriver */
break;
}
break;
case AOS_16_BITS:
switch (reg->reg16)
{
case X86_REG16_AX:
snprintf(buffer, len, "ax");
break;
case X86_REG16_CX:
snprintf(buffer, len, "cx");
break;
case X86_REG16_DX:
snprintf(buffer, len, "dx");
break;
case X86_REG16_BX:
snprintf(buffer, len, "bx");
break;
case X86_REG16_SP:
snprintf(buffer, len, "sp");
break;
case X86_REG16_BP:
snprintf(buffer, len, "bp");
break;
case X86_REG16_SI:
snprintf(buffer, len, "si");
break;
case X86_REG16_DI:
snprintf(buffer, len, "di");
break;
case X86_REG16_NONE:
/* Ne devrait jamais arriver */
break;
}
break;
case AOS_32_BITS:
switch (reg->reg32)
{
case X86_REG32_EAX:
snprintf(buffer, len, "eax");
break;
case X86_REG32_ECX:
snprintf(buffer, len, "ecx");
break;
case X86_REG32_EDX:
snprintf(buffer, len, "edx");
break;
case X86_REG32_EBX:
snprintf(buffer, len, "ebx");
break;
case X86_REG32_ESP:
snprintf(buffer, len, "esp");
break;
case X86_REG32_EBP:
snprintf(buffer, len, "ebp");
break;
case X86_REG32_ESI:
snprintf(buffer, len, "esi");
break;
case X86_REG32_EDI:
snprintf(buffer, len, "edi");
break;
case X86_REG32_NONE:
/* Ne devrait jamais arriver */
break;
}
break;
case AOS_64_BITS:
break;
}
break;
case ASX_ATT:
switch (size)
{
case AOS_8_BITS:
switch (reg->reg8)
{
case X86_REG8_AL:
snprintf(buffer, len, "%%al");
break;
case X86_REG8_CL:
snprintf(buffer, len, "%%cl");
break;
case X86_REG8_DL:
snprintf(buffer, len, "%%dl");
break;
case X86_REG8_BL:
snprintf(buffer, len, "%%bl");
break;
case X86_REG8_AH:
snprintf(buffer, len, "%%ah");
break;
case X86_REG8_CH:
snprintf(buffer, len, "%%ch");
break;
case X86_REG8_DH:
snprintf(buffer, len, "%%dh");
break;
case X86_REG8_BH:
snprintf(buffer, len, "%%bh");
break;
case X86_REG8_NONE:
/* Ne devrait jamais arriver */
break;
}
break;
case AOS_16_BITS:
switch (reg->reg16)
{
case X86_REG16_AX:
snprintf(buffer, len, "%%ax");
break;
case X86_REG16_CX:
snprintf(buffer, len, "%%cx");
break;
case X86_REG16_DX:
snprintf(buffer, len, "%%dx");
break;
case X86_REG16_BX:
snprintf(buffer, len, "%%bx");
break;
case X86_REG16_SP:
snprintf(buffer, len, "%%sp");
break;
case X86_REG16_BP:
snprintf(buffer, len, "%%bp");
break;
case X86_REG16_SI:
snprintf(buffer, len, "%%si");
break;
case X86_REG16_DI:
snprintf(buffer, len, "%%di");
break;
case X86_REG16_NONE:
/* Ne devrait jamais arriver */
break;
}
break;
case AOS_32_BITS:
switch (reg->reg32)
{
case X86_REG32_EAX:
snprintf(buffer, len, "%%eax");
break;
case X86_REG32_ECX:
snprintf(buffer, len, "%%ecx");
break;
case X86_REG32_EDX:
snprintf(buffer, len, "%%edx");
break;
case X86_REG32_EBX:
snprintf(buffer, len, "%%ebx");
break;
case X86_REG32_ESP:
snprintf(buffer, len, "%%esp");
break;
case X86_REG32_EBP:
snprintf(buffer, len, "%%ebp");
break;
case X86_REG32_ESI:
snprintf(buffer, len, "%%esi");
break;
case X86_REG32_EDI:
snprintf(buffer, len, "%%edi");
break;
case X86_REG32_NONE:
/* Ne devrait jamais arriver */
break;
}
break;
case AOS_64_BITS:
break;
}
break;
}
}
/******************************************************************************
* *
* Paramètres : operand = instruction à traiter. *
* buffer = tampon de sortie mis à disposition. [OUT] *
* len = taille de ce tampon. *
* syntax = type de représentation demandée. *
* *
* Description : Traduit une opérande de registre en texte. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void x86_print_reg_operand(const asm_x86_operand *operand, char *buffer, size_t len, AsmSyntax syntax)
{
size_t pos; /* Position de traitement */
switch (syntax)
{
case ASX_INTEL:
if (operand->content)
{
strcpy(buffer, "[");
if (operand->scale > 0)
snprintf(&buffer[1], len - 1, "%d*", (int)pow(2, operand->scale));
pos = strlen(buffer);
}
else pos = 0;
_x86_print_reg_operand(&operand->rindex, ASM_OPERAND(operand)->size, &buffer[pos], len - pos, syntax);
if (operand->rbase.reg32 != X86_REG32_NONE)
{
strcat(buffer, "+"); /* TODO: n */
pos = strlen(buffer);
_x86_print_reg_operand(&operand->rbase, ASM_OPERAND(operand)->size, &buffer[pos], len - pos, syntax);
}
if (operand->displacement != NULL)
{
strcat(buffer, "+"); /* TODO: n */
pos = strlen(buffer);
print_imm_operand(operand->displacement, &buffer[pos], len - pos, syntax);
}
if (operand->content) strcat(buffer, "]");
break;
case ASX_ATT:
break;
}
}
/* ---------------------------------------------------------------------------------- */
/* OPERANDES D'EMPLACEMENTS MEMOIRE */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
* len = taille totale des données à analyser. *
* *
* Description : Crée une opérande à partir d'un emplacement mémoire 8 bits. *
* *
* Retour : Opérande mise en place ou NULL. *
* *
* Remarques : - *
* *
******************************************************************************/
asm_x86_operand *x86_create_moffs8_operand(const uint8_t *data, off_t *pos, off_t len)
{
asm_x86_operand *result; /* Emplacement à retourner */
result = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result), AOS_8_BITS, data, pos, len))
{
free(result);
return NULL;
}
ASM_OPERAND(result)->type = AOT_MOFFS;
return result;
}
/******************************************************************************
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
* len = taille totale des données à analyser. *
* is_reg32 = indique si le registre est un registre 32 bits. *
* *
* Description : Crée une opérande à partir d'un emplacement mémoire 16/32b. *
* *
* Retour : Opérande mise en place ou NULL. *
* *
* Remarques : - *
* *
******************************************************************************/
asm_x86_operand *x86_create_moffs1632_operand(const uint8_t *data, off_t *pos, off_t len, bool is_reg32)
{
asm_x86_operand *result; /* Emplacement à retourner */
result = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(result), is_reg32 ? AOS_32_BITS : AOS_16_BITS, data, pos, len))
{
free(result);
return NULL;
}
ASM_OPERAND(result)->type = AOT_MOFFS;
return result;
}
/******************************************************************************
* *
* Paramètres : operand = instruction à traiter. *
* buffer = tampon de sortie mis à disposition. [OUT] *
* len = taille de ce tampon. *
* syntax = type de représentation demandée. *
* *
* Description : Traduit une opérande d'emplacement mémoire en texte. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void x86_print_moffs_operand(const asm_x86_operand *operand, char *buffer, size_t len, AsmSyntax syntax)
{
switch (syntax)
{
case ASX_INTEL:
if (len > 3)
{
strcpy(buffer, "ds:");
print_imm_operand(ASM_OPERAND(operand), &buffer[3], len - 3, ASX_INTEL);
}
break;
case ASX_ATT:
print_imm_operand(ASM_OPERAND(operand), buffer, len, ASX_INTEL);
break;
}
}
/* ---------------------------------------------------------------------------------- */
/* OPERANDES D'ADRESSES RELATIVES */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
* len = taille totale des données à analyser. *
* *
* Description : Crée une opérande à partir d'une adresse relative (8 bits). *
* *
* Retour : Opérande mise en place ou NULL. *
* *
* Remarques : - *
* *
******************************************************************************/
asm_x86_operand *x86_create_rel8_operand_in_32b(uint64_t base, const uint8_t *data, off_t *pos, off_t len)
{
asm_x86_operand *result; /* Emplacement à retourner */
off_t init_pos; /* Position avant lecture */
int8_t offset; /* Décallage à appliquer */
uint32_t address; /* Adresse finale visée */
result = create_new_x86_operand();
init_pos = *pos;
address = base;
if (!read_imm_value(AOS_8_BITS, data, pos, len, &offset))
{
free(result);
return NULL;
}
address = base + (*pos - init_pos) + offset;
if (!fill_imm_operand_with_value(ASM_OPERAND(result), AOS_32_BITS, &address))
{
free(result);
return NULL;
}
return result;
}
/******************************************************************************
* *
* Paramètres : data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
* len = taille totale des données à analyser. *
* is_reg32 = indique si le registre est un registre 32 bits. *
* *
* Description : Crée une opérande à partir d'une adresse relative (16/32b). *
* *
* Retour : Opérande mise en place ou NULL. *
* *
* Remarques : - *
* *
******************************************************************************/
asm_x86_operand *x86_create_rel1632_operand_in_32b(uint64_t base, const uint8_t *data, off_t *pos, off_t len, bool is_reg32)
{
asm_x86_operand *result; /* Emplacement à retourner */
off_t init_pos; /* Position avant lecture */
int32_t offset32; /* Décallage 32b à appliquer */
int16_t offset16; /* Décallage 16b à appliquer */
uint32_t address; /* Adresse finale visée */
result = create_new_x86_operand();
init_pos = *pos;
address = base;
if (is_reg32)
{
if (!read_imm_value(AOS_32_BITS, data, pos, len, &offset32))
{
free(result);
return NULL;
}
address = base + (*pos - init_pos) + offset32;
}
else
{
if (!read_imm_value(AOS_16_BITS, data, pos, len, &offset16))
{
free(result);
return NULL;
}
address = base + (*pos - init_pos) + offset16;
}
if (!fill_imm_operand_with_value(ASM_OPERAND(result), AOS_32_BITS, &address))
{
free(result);
return NULL;
}
return result;
}
/* ---------------------------------------------------------------------------------- */
/* AIDE A LA CREATION D'OPERANDES */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : instr = instruction dont la définition est à compléter. [OUT]*
* data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
* len = taille totale des données à analyser. *
* type = type de l'opérande. *
* ... = éventuelle(s) information(s) complémentaire(s). *
* *
* Description : Procède à la lecture d'un opérande donné. *
* *
* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
bool x86_read_one_operand(asm_x86_instr *instr, const uint8_t *data, off_t *pos, off_t len, X86OperandType type, ...)
{
va_list ap; /* Liste des compléments */
AsmOperandSize oprsize; /* Taille des opérandes */
uint64_t offset; /* Adresse courante */
uint8_t base; /* Indice du premier registre */
asm_x86_operand *op; /* Opérande unique décodé */
va_start(ap, type);
/* Lecture du premier opérande */
switch (type)
{
case X86_OTP_IMM8:
op = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(op), AOS_8_BITS, data, pos, len))
{
free(op);
op = NULL;
}
break;
case X86_OTP_IMM1632:
oprsize = va_arg(ap, AsmOperandSize);
op = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(op), oprsize, data, pos, len))
{
free(op);
op = NULL;
}
break;
case X86_OTP_REL8:
offset = va_arg(ap, uint64_t);
/* TODO : 64bits */
op = x86_create_rel8_operand_in_32b(offset + 1, data, pos, len);
break;
case X86_OTP_REL1632:
oprsize = va_arg(ap, AsmOperandSize);
offset = va_arg(ap, uint64_t);
/* TODO : 64bits */
op = x86_create_rel1632_operand_in_32b(offset + 1, data, pos, len, oprsize == AOS_32_BITS);
break;
case X86_OTP_R8:
op = x86_create_r8_operand(data[(*pos)++], true);
break;
case X86_OTP_R1632:
oprsize = va_arg(ap, AsmOperandSize);
op = x86_create_r1632_operand(data[(*pos)++], oprsize == AOS_32_BITS, true);
break;
case X86_OTP_OP_R1632:
oprsize = va_arg(ap, AsmOperandSize);
base = (uint8_t)va_arg(ap, int);
op = x86_create_r1632_operand_from_opcode(data[(*pos)++], oprsize == AOS_32_BITS, base);
break;
case X86_OTP_RM8:
op = x86_create_rm8_operand(data, pos, len);
break;
case X86_OTP_RM1632:
oprsize = va_arg(ap, AsmOperandSize);
op = x86_create_rm1632_operand(data, pos, len, oprsize == AOS_32_BITS);
break;
case X86_OTP_CL:
op = x86_create_r8_operand(0x01, true);
break;
case X86_OTP_AL:
op = x86_create_r8_operand(0x00, true);
break;
case X86_OTP_E_AX:
oprsize = va_arg(ap, AsmOperandSize);
op = x86_create_r1632_operand(0x00, oprsize == AOS_32_BITS, true);
break;
}
va_end(ap);
if (op == NULL) return false;
/* Assemblage final */
ASM_INSTRUCTION(instr)->operands = (asm_operand **)calloc(1, sizeof(asm_operand *));
ASM_INSTRUCTION(instr)->operands_count = 1;
ASM_INSTRUCTION(instr)->operands[0] = ASM_OPERAND(op);
return true;
}
/******************************************************************************
* *
* Paramètres : instr = instruction dont la définition est à compléter. [OUT]*
* data = flux de données à analyser. *
* pos = position courante dans ce flux. [OUT] *
* len = taille totale des données à analyser. *
* type1 = type du premier opérande. *
* type2 = type du second opérande. *
* ... = éventuelle(s) information(s) complémentaire(s). *
* *
* Description : Procède à la lecture de deux opérandes donnés. *
* *
* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
bool x86_read_two_operands(asm_x86_instr *instr, const uint8_t *data, off_t *pos, off_t len, X86OperandType type1, X86OperandType type2, ...)
{
va_list ap; /* Liste des compléments */
AsmOperandSize oprsize; /* Taille des opérandes */
bool op1_first; /* Position de l'opérande #1 */
bool op2_first; /* Position de l'opérande #2 */
off_t op1_pos; /* Position après lecture #1 */
asm_x86_operand *op1; /* Premier opérande décodé */
off_t op2_pos; /* Position après lecture #2 */
asm_x86_operand *op2; /* Second opérande décodé */
va_start(ap, type2);
oprsize = AOS_UNDEFINED;
if (type1 & X86_OTP_RM_TYPE)
{
op1_first = true;
op2_first = false;
}
else if (type2 & X86_OTP_RM_TYPE)
{
op1_first = false;
op2_first = true;
}
else
{
op1_first = true;
op2_first = false;
}
/* Lecture du premier opérande */
op1_pos = *pos;
switch (type1)
{
case X86_OTP_MOFFS8:
op1 = x86_create_moffs8_operand(data, &op1_pos, len);
break;
case X86_OTP_MOFFS1632:
oprsize = va_arg(ap, AsmOperandSize);
op1 = x86_create_moffs1632_operand(data, &op1_pos, len, oprsize == AOS_32_BITS);
break;
case X86_OTP_R8:
op1 = x86_create_r8_operand(data[op1_pos++], op1_first);
break;
case X86_OTP_R1632:
oprsize = va_arg(ap, AsmOperandSize);
op1 = x86_create_r1632_operand(data[op1_pos++], oprsize == AOS_32_BITS, op1_first);
break;
case X86_OTP_RM8:
op1 = x86_create_rm8_operand(data, &op1_pos, len);
break;
case X86_OTP_RM1632:
oprsize = va_arg(ap, AsmOperandSize);
op1 = x86_create_rm1632_operand(data, &op1_pos, len, oprsize == AOS_32_BITS);
break;
case X86_OTP_CL:
op1 = x86_create_r8_operand(0x01, op1_first);
break;
case X86_OTP_AL:
op1 = x86_create_r8_operand(0x00, op1_first);
break;
case X86_OTP_E_AX:
oprsize = va_arg(ap, AsmOperandSize);
op1 = x86_create_r1632_operand(0x00, oprsize == AOS_32_BITS, op1_first);
break;
}
if (op1 == NULL)
{
va_end(ap);
return false;
}
/* Lecture du second opérande */
if ((type1 & X86_OTP_REG_TYPE || type1 & X86_OTP_RM_TYPE) && (type2 & X86_OTP_IMM_TYPE))
op2_pos = op1_pos;
else op2_pos = *pos;
switch (type2)
{
case X86_OTP_IMM8:
op2 = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(op2), AOS_8_BITS, data, &op2_pos, len))
{
free(op2);
op2 = NULL;
}
break;
case X86_OTP_IMM1632:
if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
op2 = create_new_x86_operand();
if (!fill_imm_operand(ASM_OPERAND(op2), oprsize, data, &op2_pos, len))
{
free(op2);
op2 = NULL;
}
break;
case X86_OTP_MOFFS8:
op2 = x86_create_moffs8_operand(data, &op2_pos, len);
break;
case X86_OTP_MOFFS1632:
if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
op2 = x86_create_moffs1632_operand(data, &op2_pos, len, oprsize == AOS_32_BITS);
break;
case X86_OTP_R8:
op2 = x86_create_r8_operand(data[op2_pos++], op2_first);
break;
case X86_OTP_R1632:
if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
op2 = x86_create_r1632_operand(data[op2_pos++], oprsize == AOS_32_BITS, op2_first);
break;
case X86_OTP_RM8:
op2 = x86_create_rm8_operand(data, &op2_pos, len);
break;
case X86_OTP_RM1632:
if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
op2 = x86_create_rm1632_operand(data, &op2_pos, len, oprsize == AOS_32_BITS);
break;
case X86_OTP_CL:
op2 = x86_create_r8_operand(0x01, op2_first);
break;
case X86_OTP_AL:
op2 = x86_create_r8_operand(0x00, op2_first);
break;
case X86_OTP_E_AX:
if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
op2 = x86_create_r1632_operand(0x00, oprsize == AOS_32_BITS, op2_first);
break;
}
if (op2 == NULL)
{
free(op1);
va_end(ap);
return false;
}
va_end(ap);
/* Assemblage final */
*pos = MAX(op1_pos, op2_pos);
ASM_INSTRUCTION(instr)->operands = (asm_operand **)calloc(2, sizeof(asm_operand *));
ASM_INSTRUCTION(instr)->operands_count = 2;
ASM_INSTRUCTION(instr)->operands[0] = ASM_OPERAND(op1);
ASM_INSTRUCTION(instr)->operands[1] = ASM_OPERAND(op2);
return true;
}