summaryrefslogtreecommitdiff
path: root/src/arch/x86/opcodes
diff options
context:
space:
mode:
Diffstat (limited to 'src/arch/x86/opcodes')
-rw-r--r--src/arch/x86/opcodes/Makefile.am55
-rw-r--r--src/arch/x86/opcodes/adc.c161
-rw-r--r--src/arch/x86/opcodes/add.c340
-rw-r--r--src/arch/x86/opcodes/and.c271
-rw-r--r--src/arch/x86/opcodes/arpl.c61
-rw-r--r--src/arch/x86/opcodes/call.c100
-rw-r--r--src/arch/x86/opcodes/cld.c56
-rw-r--r--src/arch/x86/opcodes/cmp.c340
-rw-r--r--src/arch/x86/opcodes/cmps.c64
-rw-r--r--src/arch/x86/opcodes/dec.c137
-rw-r--r--src/arch/x86/opcodes/hlt.c56
-rw-r--r--src/arch/x86/opcodes/inc.c137
-rw-r--r--src/arch/x86/opcodes/int.c93
-rw-r--r--src/arch/x86/opcodes/jump.c1238
-rw-r--r--src/arch/x86/opcodes/lea.c64
-rw-r--r--src/arch/x86/opcodes/leave.c56
-rw-r--r--src/arch/x86/opcodes/mov.c410
-rw-r--r--src/arch/x86/opcodes/movs.c64
-rw-r--r--src/arch/x86/opcodes/movsx.c100
-rw-r--r--src/arch/x86/opcodes/movzx.c100
-rw-r--r--src/arch/x86/opcodes/mul.c137
-rw-r--r--src/arch/x86/opcodes/nop.c56
-rw-r--r--src/arch/x86/opcodes/not.c97
-rw-r--r--src/arch/x86/opcodes/opcodes.h685
-rw-r--r--src/arch/x86/opcodes/or.c304
-rw-r--r--src/arch/x86/opcodes/pop.c95
-rw-r--r--src/arch/x86/opcodes/push.c141
-rw-r--r--src/arch/x86/opcodes/rcl.c235
-rw-r--r--src/arch/x86/opcodes/rcr.c235
-rw-r--r--src/arch/x86/opcodes/ret.c152
-rw-r--r--src/arch/x86/opcodes/rol.c235
-rw-r--r--src/arch/x86/opcodes/ror.c235
-rw-r--r--src/arch/x86/opcodes/sar.c235
-rw-r--r--src/arch/x86/opcodes/sbb.c169
-rw-r--r--src/arch/x86/opcodes/scas.c61
-rw-r--r--src/arch/x86/opcodes/set.c556
-rw-r--r--src/arch/x86/opcodes/shl.c235
-rw-r--r--src/arch/x86/opcodes/shr.c235
-rw-r--r--src/arch/x86/opcodes/stos.c64
-rw-r--r--src/arch/x86/opcodes/sub.c307
-rw-r--r--src/arch/x86/opcodes/test.c235
-rw-r--r--src/arch/x86/opcodes/xchg.c67
-rw-r--r--src/arch/x86/opcodes/xor.c340
43 files changed, 0 insertions, 9014 deletions
diff --git a/src/arch/x86/opcodes/Makefile.am b/src/arch/x86/opcodes/Makefile.am
deleted file mode 100644
index 72eed13..0000000
--- a/src/arch/x86/opcodes/Makefile.am
+++ /dev/null
@@ -1,55 +0,0 @@
-
-noinst_LTLIBRARIES = libarchx86opcodes.la
-
-libarchx86opcodes_la_SOURCES = \
- adc.c \
- add.c \
- and.c \
- arpl.c \
- call.c \
- cld.c \
- cmp.c \
- cmps.c \
- dec.c \
- hlt.c \
- inc.c \
- int.c \
- jump.c \
- lea.c \
- leave.c \
- mov.c \
- movs.c \
- movsx.c \
- movzx.c \
- mul.c \
- nop.c \
- not.c \
- opcodes.h \
- or.c \
- pop.c \
- push.c \
- rcl.c \
- rcr.c \
- ret.c \
- rol.c \
- ror.c \
- sar.c \
- sbb.c \
- scas.c \
- set.c \
- shl.c \
- shr.c \
- stos.c \
- sub.c \
- test.c \
- xchg.c \
- xor.c
-
-libarchx86opcodes_la_LIBADD =
-
-libarchx86opcodes_la_CFLAGS = $(AM_CFLAGS)
-
-
-AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
-
-AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
diff --git a/src/arch/x86/opcodes/adc.c b/src/arch/x86/opcodes/adc.c
deleted file mode 100644
index e85f2f4..0000000
--- a/src/arch/x86/opcodes/adc.c
+++ /dev/null
@@ -1,161 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_adc.c - décodage des additions avec retenue
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'adc' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_adc_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_ADC_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* *
-* Description : Décode une instruction de type 'adc' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_adc_rm8_r8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_ADC_RM8_R8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'adc' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_adc_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_ADC_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'adc' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_adc_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_ADC_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/add.c b/src/arch/x86/opcodes/add.c
deleted file mode 100644
index aaaec61..0000000
--- a/src/arch/x86/opcodes/add.c
+++ /dev/null
@@ -1,340 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_add.c - décodage des additions
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'add al, ...' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_add_al_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_ADD_AL_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'add [e]ax, ...' (16/32 bits).*
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_add_e_ax_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_ADD_E_AX_IMM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_E_AX, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'add' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_add_r8_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_ADD_R8_RM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R8, X86_OTP_RM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'add' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_add_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_ADD_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'add' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_add_rm8_r8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_ADD_RM8_R8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'add' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_add_r1632_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_ADD_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'add' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_add_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_ADD_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'add' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_add_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_ADD_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'add' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_add_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_ADD_RM1632_R1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/and.c b/src/arch/x86/opcodes/and.c
deleted file mode 100644
index c1cf21b..0000000
--- a/src/arch/x86/opcodes/and.c
+++ /dev/null
@@ -1,271 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_and.c - décodage des ET logiques
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'and al, ...' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_and_al_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_AND_AL_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'and [e]ax, ...' (16/32 bits).*
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_and_e_ax_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_AND_E_AX_IMM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_E_AX, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'and' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_and_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_AND_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'and' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_and_rm8_r8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_AND_RM8_R8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'and' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_and_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_AND_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'and' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_and_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_AND_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'and' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_and_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_AND_RM1632_R1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/arpl.c b/src/arch/x86/opcodes/arpl.c
deleted file mode 100644
index da76b4f..0000000
--- a/src/arch/x86/opcodes/arpl.c
+++ /dev/null
@@ -1,61 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_arpl.c - décodage des ajustements de champs RPL
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'arpl' (16 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_arpl_rm16_r16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_ARPL_RM16_R16);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, MDS_16_BITS))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/call.c b/src/arch/x86/opcodes/call.c
deleted file mode 100644
index cdd2672..0000000
--- a/src/arch/x86/opcodes/call.c
+++ /dev/null
@@ -1,100 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_call.c - décodage des appels
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'call' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_call_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_CALL_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'call' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_call_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_CALL_RM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/cld.c b/src/arch/x86/opcodes/cld.c
deleted file mode 100644
index bb4e714..0000000
--- a/src/arch/x86/opcodes/cld.c
+++ /dev/null
@@ -1,56 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_cld.c - décodage de la suppression du drapeau de direction
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'cld'. *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_cld(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_CLD);
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/cmp.c b/src/arch/x86/opcodes/cmp.c
deleted file mode 100644
index ef631d4..0000000
--- a/src/arch/x86/opcodes/cmp.c
+++ /dev/null
@@ -1,340 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_cmp.c - décodage des comparaisons d'opérandes
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'cmp' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_cmp_al_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_CMP_AL_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'cmp' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_cmp_e_ax_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_CMP_E_AX_IMM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_E_AX, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'cmp' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_cmp_r8_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_CMP_R8_RM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R8, X86_OTP_RM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'cmp' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_cmp_r1632_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_CMP_R1632_RM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'cmp' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_cmp_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_CMP_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'cmp' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_cmp_rm8_r8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_CMP_RM8_R8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'cmp' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_cmp_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_CMP_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'cmp' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_cmp_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_CMP_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'cmp' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_cmp_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_CMP_RM1632_R1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/cmps.c b/src/arch/x86/opcodes/cmps.c
deleted file mode 100644
index d48253d..0000000
--- a/src/arch/x86/opcodes/cmps.c
+++ /dev/null
@@ -1,64 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_cmps.c - décodage des comparaisons de chaînes et de scalaires
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'cmps' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_cmps_m8_m8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_CMPS_M8_M8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_SRC_8, X86_OTP_DST_8))
- {
- g_object_unref(G_OBJECT(result));
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/dec.c b/src/arch/x86/opcodes/dec.c
deleted file mode 100644
index ad65604..0000000
--- a/src/arch/x86/opcodes/dec.c
+++ /dev/null
@@ -1,137 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_dec.c - décodage des décrémentations
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'dec' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_dec_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- X86Opcodes opcode; /* Instruction effective */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- opcode = XOP_DEC_E_AX + (data[*pos] - 0x48);
-
- result = g_x86_instruction_new(opcode);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_OP_R1632, oprsize, 0x48))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'dec' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_dec_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_DEC_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'dec' (16/32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_dec_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_DEC_RM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/hlt.c b/src/arch/x86/opcodes/hlt.c
deleted file mode 100644
index bb14269..0000000
--- a/src/arch/x86/opcodes/hlt.c
+++ /dev/null
@@ -1,56 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_hlt.c - décodage de la mise en pause du processeur
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'hlt'. *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_hlt(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_HLT);
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/inc.c b/src/arch/x86/opcodes/inc.c
deleted file mode 100644
index dd37034..0000000
--- a/src/arch/x86/opcodes/inc.c
+++ /dev/null
@@ -1,137 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_inc.c - décodage des incrémentations
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'inc' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_inc_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- X86Opcodes opcode; /* Instruction effective */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- opcode = XOP_INC_E_AX + (data[*pos] - 0x40);
-
- result = g_x86_instruction_new(opcode);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_OP_R1632, oprsize, 0x40))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'inc' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_inc_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_INC_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'inc' (16/32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_inc_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_INC_RM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/int.c b/src/arch/x86/opcodes/int.c
deleted file mode 100644
index 5e1550c..0000000
--- a/src/arch/x86/opcodes/int.c
+++ /dev/null
@@ -1,93 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_int.c - décodage des instructions d'interruption
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* offset = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'int 3'. *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_int_3(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- GArchOperand *three; /* Argument artificiel */
-
- result = g_x86_instruction_new(XOP_INT_3);
-
- three = g_imm_operand_new_from_value(MDS_8_BITS, 3);
- g_arch_instruction_attach_extra_operand(result, three);
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'int'. *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_int_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_INT);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_IMM8))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/jump.c b/src/arch/x86/opcodes/jump.c
deleted file mode 100644
index ae9f68f..0000000
--- a/src/arch/x86/opcodes/jump.c
+++ /dev/null
@@ -1,1238 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_jump.c - décodage des sauts inconditionnels
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'ja' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_ja_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JA_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'ja' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_ja_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JA_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jb' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jb_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JB_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jb' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jb_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JB_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'je' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_je_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JE_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'je' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_je_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JE_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jg' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jg_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JG_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jg' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jg_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JG_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jl' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jl_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JL_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jl' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jl_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JL_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jmp' (petit saut). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jmp_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JMP_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jmp' (grand saut relatif). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jmp_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JMP_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jmp' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jmp_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JMP_RM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM1632, oprsize))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jna' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jna_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JNA_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jna' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jna_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JNA_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jnb' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jnb_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JNB_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jnb' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jnb_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JNB_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jne' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jne_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JNE_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jne' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jne_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JNE_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jng' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jng_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JNG_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jng' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jng_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JNG_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jnl' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jnl_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JNL_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jnl' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jnl_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JNL_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jno' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jno_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JNO_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jno' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jno_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JNO_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jnp' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jnp_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JNP_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jnp' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jnp_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JNP_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jns' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jns_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JNS_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jns' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jns_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JNS_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jo' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jo_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JO_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jo' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jo_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JO_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jp' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jp_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JP_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'jp' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_jp_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JP_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'js' (saut 8b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_js_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_JS_REL8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'js' (saut 16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_js_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_JS_REL1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
- {
- g_object_unref(G_OBJECT(result));
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/lea.c b/src/arch/x86/opcodes/lea.c
deleted file mode 100644
index 3bbfad5..0000000
--- a/src/arch/x86/opcodes/lea.c
+++ /dev/null
@@ -1,64 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_lea.c - décodage des chargements d'adresse effective
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'lea' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_lea_r1632_m(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_LEA_R1632_M);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/leave.c b/src/arch/x86/opcodes/leave.c
deleted file mode 100644
index ede39f0..0000000
--- a/src/arch/x86/opcodes/leave.c
+++ /dev/null
@@ -1,56 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_leave.c - décodage de la préparation d'une sortie d'appel
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'leave'. *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_leave(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_LEAVE);
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/mov.c b/src/arch/x86/opcodes/mov.c
deleted file mode 100644
index 42cc2b8..0000000
--- a/src/arch/x86/opcodes/mov.c
+++ /dev/null
@@ -1,410 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_mov.c - décodage des déplacements de données
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'mov al, ...' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_mov_al_moffs8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_MOV_AL_MOFFS8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_MOFFS8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'mov [e]ax, ...' (16/32 bits).*
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_mov_e_ax_moffs1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_MOV_E_AX_MOFFS1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_E_AX, X86_OTP_MOFFS1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'mov ..., al' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_mov_moffs8_al(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_MOV_MOFFS8_AL);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_MOFFS8, X86_OTP_AL))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'mov ..., [e]ax' (16/32 bits).*
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_mov_moffs1632_e_ax(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_MOV_MOFFS1632_E_AX);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_MOFFS1632, X86_OTP_E_AX, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'mov' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_mov_r8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- X86Opcodes opcode; /* Instruction effective */
-
- opcode = XOP_MOV_AL_IMM8 + (data[*pos] - 0xb0);
-
- result = g_x86_instruction_new(opcode);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_OP_R8, X86_OTP_IMM8, 0xb0))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'mov' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_mov_r1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- X86Opcodes opcode; /* Instruction effective */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- opcode = XOP_MOV_E_AX_IMM1632 + (data[*pos] - 0xb8);
-
- result = g_x86_instruction_new(opcode);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_OP_R1632, X86_OTP_IMM1632, oprsize, 0xb8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'mov' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_mov_r1632_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_MOV_R1632_RM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'mov' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_mov_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_MOV_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* *
-* Description : Décode une instruction de type 'mov' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_mov_rm8_r8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_MOV_RM8_R8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'mov' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_mov_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_MOV_RM1632_IMM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'mov' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_mov_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_MOV_RM1632_R1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/movs.c b/src/arch/x86/opcodes/movs.c
deleted file mode 100644
index f523771..0000000
--- a/src/arch/x86/opcodes/movs.c
+++ /dev/null
@@ -1,64 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_movs.c - décodage des déplacements de données
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'movs' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_movs_m1632_m1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_MOVS_M1632_M1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_DST_1632, X86_OTP_SRC_1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/movsx.c b/src/arch/x86/opcodes/movsx.c
deleted file mode 100644
index dbe0152..0000000
--- a/src/arch/x86/opcodes/movsx.c
+++ /dev/null
@@ -1,100 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_movsx.c - décodage des copies d'opérandes sans mise à zéro
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'movsx' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_movsx_r1632_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_MOVSX_R1632_RM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM8, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'movsx' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_movsx_r1632_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_MOVSX_R1632_RM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/movzx.c b/src/arch/x86/opcodes/movzx.c
deleted file mode 100644
index b12c9d1..0000000
--- a/src/arch/x86/opcodes/movzx.c
+++ /dev/null
@@ -1,100 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_movzx.c - décodage des copies d'opérandes avec mise à zéro
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'movzx' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_movzx_r1632_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_MOVZX_R1632_RM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM8, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'movzx' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_movzx_r1632_rm16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_MOVZX_R1632_RM16);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM16, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/mul.c b/src/arch/x86/opcodes/mul.c
deleted file mode 100644
index 0cc9ad5..0000000
--- a/src/arch/x86/opcodes/mul.c
+++ /dev/null
@@ -1,137 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_mul.c - décodage des multiplications
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* offset = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'imul' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_imul_r1632_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_IMUL_R1632_RM1632_IMM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_three_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM1632, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* offset = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'imul' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_imul_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_IMUL_RM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM1632, oprsize))
- {
- /* TODO 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. *
-* offset = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'imul' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_imul_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_IMUL_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
-
diff --git a/src/arch/x86/opcodes/nop.c b/src/arch/x86/opcodes/nop.c
deleted file mode 100644
index 74e88a4..0000000
--- a/src/arch/x86/opcodes/nop.c
+++ /dev/null
@@ -1,56 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_nop.c - décodage de l'instruction nulle
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'nop'. *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_nop(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_NOP);
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/not.c b/src/arch/x86/opcodes/not.c
deleted file mode 100644
index cf7fcba..0000000
--- a/src/arch/x86/opcodes/not.c
+++ /dev/null
@@ -1,97 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_not.c - décodage des négations par complément à un
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'not' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_not_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_NOT_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'not' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_not_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_NOT_RM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/opcodes.h b/src/arch/x86/opcodes/opcodes.h
deleted file mode 100644
index 84fea64..0000000
--- a/src/arch/x86/opcodes/opcodes.h
+++ /dev/null
@@ -1,685 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * opcodes.h - prototypes pour la liste de tous les opcodes de l'architecture x86
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 _ARCH_X86_OPCODES_OPCODES_H
-#define _ARCH_X86_OPCODES_OPCODES_H
-
-
-#include "../instruction.h"
-#include "../processor.h"
-
-
-
-/* Prototype de décodage d'une instruction x86. */
-typedef GArchInstruction * (* x86_read_instr) (const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-
-
-/* Décode une instruction de type 'adc' (8 bits). */
-GArchInstruction *x86_read_instr_adc_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'adc' (8 bits). */
-GArchInstruction *x86_read_instr_adc_rm8_r8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'adc' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_adc_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'adc' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_adc_rm1632_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'add al, ...' (8 bits). */
-GArchInstruction *x86_read_instr_add_al_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'add [e]ax, ...' (16/32 bits). */
-GArchInstruction *x86_read_instr_add_e_ax_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'add' (8 bits). */
-GArchInstruction *x86_read_instr_add_r8_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'add' (8 bits). */
-GArchInstruction *x86_read_instr_add_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'add' (8 bits). */
-GArchInstruction *x86_read_instr_add_rm8_r8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'add' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_add_r1632_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'add' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_add_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'add' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_add_rm1632_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'add' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_add_rm1632_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'and al, ...' (8 bits). */
-GArchInstruction *x86_read_instr_and_al_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'and [e]ax, ...' (16/32 bits). */
-GArchInstruction *x86_read_instr_and_e_ax_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'and' (8 bits). */
-GArchInstruction *x86_read_instr_and_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'and' (8 bits). */
-GArchInstruction *x86_read_instr_and_rm8_r8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'and' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_and_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'and' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_and_rm1632_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'and' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_and_rm1632_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'arpl' (16 bits). */
-GArchInstruction *x86_read_instr_arpl_rm16_r16(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'call'. */
-GArchInstruction *x86_read_instr_call_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'call' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_call_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'cld'. */
-GArchInstruction *x86_read_instr_cld(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'cmp' (8 bits). */
-GArchInstruction *x86_read_instr_cmp_al_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'cmp' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_cmp_e_ax_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'cmp' (8 bits). */
-GArchInstruction *x86_read_instr_cmp_r8_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'cmp' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_cmp_r1632_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'cmp' (8 bits). */
-GArchInstruction *x86_read_instr_cmp_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'cmp' (8 bits). */
-GArchInstruction *x86_read_instr_cmp_rm8_r8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'cmp' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_cmp_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'cmp' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_cmp_rm1632_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'cmp' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_cmp_rm1632_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'cmps' (8 bits). */
-GArchInstruction *x86_read_instr_cmps_m8_m8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'dec' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_dec_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'dec' (8 bits). */
-GArchInstruction *x86_read_instr_dec_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'dec' (16/32 bits). */
-GArchInstruction *x86_read_instr_dec_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'hlt'. */
-GArchInstruction *x86_read_instr_hlt(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'imul' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_imul_r1632_rm1632_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'imul' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_imul_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'imul' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_imul_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'inc' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_inc_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'inc' (8 bits). */
-GArchInstruction *x86_read_instr_inc_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'inc' (16/32 bits). */
-GArchInstruction *x86_read_instr_inc_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'int 3'. */
-GArchInstruction *x86_read_instr_int_3(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'int'. */
-GArchInstruction *x86_read_instr_int_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'ja' (saut 8b). */
-GArchInstruction *x86_read_instr_ja_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'ja' (saut 16/32b). */
-GArchInstruction *x86_read_instr_ja_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jb' (saut 8b). */
-GArchInstruction *x86_read_instr_jb_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jb' (saut 16/32b). */
-GArchInstruction *x86_read_instr_jb_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'je' (saut 8b). */
-GArchInstruction *x86_read_instr_je_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'je' (saut 16/32b). */
-GArchInstruction *x86_read_instr_je_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jg' (saut 8b). */
-GArchInstruction *x86_read_instr_jg_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jg' (saut 16/32b). */
-GArchInstruction *x86_read_instr_jg_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jl' (saut 8b). */
-GArchInstruction *x86_read_instr_jl_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jl' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_jl_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jna' (saut 8b). */
-GArchInstruction *x86_read_instr_jna_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jna' (saut 16/32b). */
-GArchInstruction *x86_read_instr_jna_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jnb' (saut 8b). */
-GArchInstruction *x86_read_instr_jnb_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jnb' (saut 16/32b). */
-GArchInstruction *x86_read_instr_jnb_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jne' (saut 8b). */
-GArchInstruction *x86_read_instr_jne_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jne' (saut 16/32b). */
-GArchInstruction *x86_read_instr_jne_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jng' (saut 8b). */
-GArchInstruction *x86_read_instr_jng_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jng' (saut 16/32b). */
-GArchInstruction *x86_read_instr_jng_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jnl' (saut 8b). */
-GArchInstruction *x86_read_instr_jnl_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jnl' (saut 16/32b). */
-GArchInstruction *x86_read_instr_jnl_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jno' (saut 8b). */
-GArchInstruction *x86_read_instr_jno_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jno' (saut 16/32b). */
-GArchInstruction *x86_read_instr_jno_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jnp' (saut 8b). */
-GArchInstruction *x86_read_instr_jnp_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jnp' (saut 16/32b). */
-GArchInstruction *x86_read_instr_jnp_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jns' (saut 8b). */
-GArchInstruction *x86_read_instr_jns_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jns' (saut 16/32b). */
-GArchInstruction *x86_read_instr_jns_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jo' (saut 8b). */
-GArchInstruction *x86_read_instr_jo_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jo' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_jo_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jp' (saut 8b). */
-GArchInstruction *x86_read_instr_jp_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jp' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_jp_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'js' (saut 8b). */
-GArchInstruction *x86_read_instr_js_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'js' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_js_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jump' (petit saut). */
-GArchInstruction *x86_read_instr_jmp_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jmp' (grand saut relatif). */
-GArchInstruction *x86_read_instr_jmp_rel1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'jmp' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_jmp_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'lea' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_lea_r1632_m(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'leave'. */
-GArchInstruction *x86_read_instr_leave(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'mov al, ...' (8 bits). */
-GArchInstruction *x86_read_instr_mov_al_moffs8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'mov [e]ax, ...' (16/32 bits). */
-GArchInstruction *x86_read_instr_mov_e_ax_moffs1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'mov ..., al' (8 bits). */
-GArchInstruction *x86_read_instr_mov_moffs8_al(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'mov ..., [e]ax' (16/32 bits). */
-GArchInstruction *x86_read_instr_mov_moffs1632_e_ax(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'mov' (8 bits). */
-GArchInstruction *x86_read_instr_mov_r8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'mov' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_mov_r1632_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'mov' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_mov_r1632_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'mov' (8 bits). */
-GArchInstruction *x86_read_instr_mov_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'mov' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_mov_rm1632_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'mov' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_mov_rm1632_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'mov' (8 bits). */
-GArchInstruction *x86_read_instr_mov_rm8_r8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'movs' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_movs_m1632_m1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'movsx' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_movsx_r1632_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'movsx' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_movsx_r1632_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'movzx' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_movzx_r1632_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'movzx' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_movzx_r1632_rm16(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'nop'. */
-GArchInstruction *x86_read_instr_nop(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'not' (8 bits). */
-GArchInstruction *x86_read_instr_not_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'not' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_not_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'or al, ...' (8 bits). */
-GArchInstruction *x86_read_instr_or_al_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'or' (8 bits). */
-GArchInstruction *x86_read_instr_or_r8_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'or' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_or_r1632_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'or' (8 bits). */
-GArchInstruction *x86_read_instr_or_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'or' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_or_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'or' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_or_rm1632_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'or' (8 bits). */
-GArchInstruction *x86_read_instr_or_rm8_r8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'or' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_or_rm1632_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'popa'. */
-GArchInstruction *x86_read_instr_popa(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'pop' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_pop_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'push' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_push_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'push' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_push_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'push' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_push_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rcl' (8 bits). */
-GArchInstruction *x86_read_instr_rcl_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rcl' (8 bits). */
-GArchInstruction *x86_read_instr_rcl_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rcl' (8 bits). */
-GArchInstruction *x86_read_instr_rcl_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rcl' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_rcl_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rcl' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_rcl_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rcl' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_rcl_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rcr' (8 bits). */
-GArchInstruction *x86_read_instr_rcr_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rcr' (8 bits). */
-GArchInstruction *x86_read_instr_rcr_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rcr' (8 bits). */
-GArchInstruction *x86_read_instr_rcr_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rcr' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_rcr_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rcr' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_rcr_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rcr' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_rcr_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'retf'. */
-GArchInstruction *x86_read_instr_retf(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'retf' (16 bits). */
-GArchInstruction *x86_read_instr_retf_imm16(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'retn'. */
-GArchInstruction *x86_read_instr_retn(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'retn' (16 bits). */
-GArchInstruction *x86_read_instr_retn_imm16(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rol' (8 bits). */
-GArchInstruction *x86_read_instr_rol_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rol' (8 bits). */
-GArchInstruction *x86_read_instr_rol_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rol' (8 bits). */
-GArchInstruction *x86_read_instr_rol_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rol' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_rol_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rol' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_rol_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'rol' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_rol_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'ror' (8 bits). */
-GArchInstruction *x86_read_instr_ror_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'ror' (8 bits). */
-GArchInstruction *x86_read_instr_ror_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'ror' (8 bits). */
-GArchInstruction *x86_read_instr_ror_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'ror' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_ror_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'ror' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_ror_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'ror' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_ror_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sal' (8 bits). */
-#define x86_read_instr_sal_rm8_1 x86_read_instr_shl_rm8_1
-
-/* Décode une instruction de type 'sal' (8 bits). */
-#define x86_read_instr_sal_rm8_cl x86_read_instr_shl_rm8_cl
-
-/* Décode une instruction de type 'sal' (8 bits). */
-#define x86_read_instr_sal_rm8_imm8 x86_read_instr_shl_rm8_imm8
-
-/* Décode une instruction de type 'sal' (16 ou 32 bits). */
-#define x86_read_instr_sal_rm1632_1 x86_read_instr_shl_rm1632_1
-
-/* Décode une instruction de type 'sal' (16 ou 32 bits). */
-#define x86_read_instr_sal_rm1632_cl x86_read_instr_shl_rm1632_cl
-
-/* Décode une instruction de type 'sal' (16 ou 32 bits). */
-#define x86_read_instr_sal_rm1632_1 x86_read_instr_shl_rm1632_1
-
-/* Décode une instruction de type 'sal' (16 ou 32 bits). */
-#define x86_read_instr_sal_rm1632_cl x86_read_instr_shl_rm1632_cl
-
-/* Décode une instruction de type 'sal' (16 ou 32 bits). */
-#define x86_read_instr_sal_rm1632_imm8 x86_read_instr_shl_rm1632_imm8
-
-/* Décode une instruction de type 'sar' (8 bits). */
-GArchInstruction *x86_read_instr_sar_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sar' (8 bits). */
-GArchInstruction *x86_read_instr_sar_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sar' (8 bits). */
-GArchInstruction *x86_read_instr_sar_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sar' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_sar_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sar' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_sar_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sar' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_sar_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sbb' (8 bits). */
-GArchInstruction *x86_read_instr_sbb_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sbb'. */
-GArchInstruction *x86_read_instr_sbb_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sbb' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_sbb_rm1632_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sbb' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_sbb_rm1632_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'scas al, ...' (8 bits). */
-GArchInstruction *x86_read_instr_scas_al_m8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'seta' (8 bits). */
-GArchInstruction *x86_read_instr_seta_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'setb' (8 bits). */
-GArchInstruction *x86_read_instr_setb_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sete' (8 bits). */
-GArchInstruction *x86_read_instr_sete_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'setg' (8 bits). */
-GArchInstruction *x86_read_instr_setg_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'setl' (8 bits). */
-GArchInstruction *x86_read_instr_setl_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'setna' (8 bits). */
-GArchInstruction *x86_read_instr_setna_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'setnb' (8 bits). */
-GArchInstruction *x86_read_instr_setnb_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'setne' (8 bits). */
-GArchInstruction *x86_read_instr_setne_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'setng' (8 bits). */
-GArchInstruction *x86_read_instr_setng_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'setnl' (8 bits). */
-GArchInstruction *x86_read_instr_setnl_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'setno' (8 bits). */
-GArchInstruction *x86_read_instr_setno_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'setnp' (8 bits). */
-GArchInstruction *x86_read_instr_setnp_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'setns' (8 bits). */
-GArchInstruction *x86_read_instr_setns_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'seto' (8 bits). */
-GArchInstruction *x86_read_instr_seto_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'setp' (8 bits). */
-GArchInstruction *x86_read_instr_setp_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sets' (8 bits). */
-GArchInstruction *x86_read_instr_sets_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'shl' (8 bits). */
-GArchInstruction *x86_read_instr_shl_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'shl' (8 bits). */
-GArchInstruction *x86_read_instr_shl_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'shl' (8 bits). */
-GArchInstruction *x86_read_instr_shl_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'shl' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_shl_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'shl' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_shl_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'shl' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_shl_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'shr' (8 bits). */
-GArchInstruction *x86_read_instr_shr_rm8_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'shr' (8 bits). */
-GArchInstruction *x86_read_instr_shr_rm8_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'shr' (8 bits). */
-GArchInstruction *x86_read_instr_shr_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'shr' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_shr_rm1632_1(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'shr' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_shr_rm1632_cl(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'shr' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_shr_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'stos' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_stos_m1632_e_ax(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sub al, ...' (8 bits). */
-GArchInstruction *x86_read_instr_sub_al_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sub [e]ax, ...' (16/32 bits). */
-GArchInstruction *x86_read_instr_sub_e_ax_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sub' (8 bits). */
-GArchInstruction *x86_read_instr_sub_r8_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sub' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_sub_r1632_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sub' (8 bits). */
-GArchInstruction *x86_read_instr_sub_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sub'. */
-GArchInstruction *x86_read_instr_sub_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sub' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_sub_rm1632_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'sub' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_sub_rm1632_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'test al, ...' (8 bits). */
-GArchInstruction *x86_read_instr_test_al_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'test [e]ax, ...' (16/32b). */
-GArchInstruction *x86_read_instr_test_e_ax_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'test' (8 bits). */
-GArchInstruction *x86_read_instr_test_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'test' (8 bits). */
-GArchInstruction *x86_read_instr_test_rm8_r8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'test' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_test_rm1632_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'test' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_test_rm1632_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'xchg' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_xchg_r1632_e_ax(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'xor al, ...' (8 bits). */
-GArchInstruction *x86_read_instr_xor_al_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'xor [e]ax, ...' (16/32 bits). */
-GArchInstruction *x86_read_instr_xor_e_ax_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'xor' (8 bits). */
-GArchInstruction *x86_read_instr_xor_r8_rm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'xor' (8 bits). */
-GArchInstruction *x86_read_instr_xor_rm8_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'xor' (8 bits). */
-GArchInstruction *x86_read_instr_xor_rm8_r8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'xor' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_xor_r1632_rm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'xor' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_xor_rm1632_imm8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'xor' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_xor_rm1632_imm1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-/* Décode une instruction de type 'xor' (16 ou 32 bits). */
-GArchInstruction *x86_read_instr_xor_rm1632_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-
-
-
-#endif /* _ARCH_X86_OPCODES_OPCODES_H */
diff --git a/src/arch/x86/opcodes/or.c b/src/arch/x86/opcodes/or.c
deleted file mode 100644
index 98aaf4c..0000000
--- a/src/arch/x86/opcodes/or.c
+++ /dev/null
@@ -1,304 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_or.c - décodage des OU logiques
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'or al, ...' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_or_al_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_OR_AL_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'or' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_or_r8_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_OR_R8_RM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R8, X86_OTP_RM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'or' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_or_r1632_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_OR_R1632_RM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'or' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_or_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_OR_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'or' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_or_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_OR_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'or' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_or_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_OR_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'or' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_or_rm8_r8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_OR_RM8_R8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'or' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_or_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_OR_RM1632_R1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/pop.c b/src/arch/x86/opcodes/pop.c
deleted file mode 100644
index 3cb92cf..0000000
--- a/src/arch/x86/opcodes/pop.c
+++ /dev/null
@@ -1,95 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_pop.c - décodage des dépilements
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'pop' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_pop_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- X86Opcodes opcode; /* Instruction effective */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- opcode = XOP_POP_E_AX + (data[*pos] - 0x58);
-
- result = g_x86_instruction_new(opcode);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_OP_R1632, oprsize, 0x58))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'popa'. *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_popa(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_POPA);
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/push.c b/src/arch/x86/opcodes/push.c
deleted file mode 100644
index 8c9033d..0000000
--- a/src/arch/x86/opcodes/push.c
+++ /dev/null
@@ -1,141 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_push.c - décodage des empilements
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'push' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_push_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_PUSH_IMM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'push' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_push_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- X86Opcodes opcode; /* Instruction effective */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- opcode = XOP_PUSH_E_AX + (data[*pos] - 0x50);
-
- result = g_x86_instruction_new(opcode);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_OP_R1632, oprsize, 0x50))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'push' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_push_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_PUSH_RM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/rcl.c b/src/arch/x86/opcodes/rcl.c
deleted file mode 100644
index bb2794e..0000000
--- a/src/arch/x86/opcodes/rcl.c
+++ /dev/null
@@ -1,235 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_rcl.c - décodage des rotations à gauche avec retenue
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rcl' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rcl_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_RCL_RM8_1);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rcl' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rcl_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_RCL_RM8_CL);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rcl' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rcl_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_RCL_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rcl' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rcl_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_RCL_RM1632_1);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rcl' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rcl_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_RCL_RM1632_CL);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_CL, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rcl' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rcl_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_RCL_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/rcr.c b/src/arch/x86/opcodes/rcr.c
deleted file mode 100644
index fc3195a..0000000
--- a/src/arch/x86/opcodes/rcr.c
+++ /dev/null
@@ -1,235 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_rcr.c - décodage des rotations à droite avec retenue
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rcr' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rcr_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_RCR_RM8_1);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rcr' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rcr_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_RCR_RM8_CL);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rcr' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rcr_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_RCR_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rcr' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rcr_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_RCR_RM1632_1);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rcr' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rcr_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_RCR_RM1632_CL);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_CL, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rcr' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rcr_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_RCR_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/ret.c b/src/arch/x86/opcodes/ret.c
deleted file mode 100644
index f10a438..0000000
--- a/src/arch/x86/opcodes/ret.c
+++ /dev/null
@@ -1,152 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_ret.c - décodage de la sortie d'un appel
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'retf'. *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_retf(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_RETF);
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'retf' (16 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_retf_imm16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_RETF_IMM16);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_IMM16))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'retn'. *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_retn(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_RETN);
-
- return result;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* prefix = éventuel(s) préfixe(s) remarqué(s). *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'retn' (16 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_retn_imm16(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_RETN_IMM16);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_IMM16))
- {
- g_object_unref(G_OBJECT(result));
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/rol.c b/src/arch/x86/opcodes/rol.c
deleted file mode 100644
index 8db81a5..0000000
--- a/src/arch/x86/opcodes/rol.c
+++ /dev/null
@@ -1,235 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_rol.c - décodage des rotations à gauche sans retenue
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rol' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rol_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_ROL_RM8_1);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rol' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rol_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_ROL_RM8_CL);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rol' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rol_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_ROL_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rol' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rol_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_ROL_RM1632_1);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rol' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rol_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_ROL_RM1632_CL);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_CL, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'rol' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_rol_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_ROL_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/ror.c b/src/arch/x86/opcodes/ror.c
deleted file mode 100644
index 630957e..0000000
--- a/src/arch/x86/opcodes/ror.c
+++ /dev/null
@@ -1,235 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_ror.c - décodage des rotations à droite sans retenue
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'ror' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_ror_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_ROR_RM8_1);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'ror' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_ror_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_ROR_RM8_CL);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'ror' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_ror_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_ROR_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'ror' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_ror_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_ROR_RM1632_1);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'ror' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_ror_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_ROR_RM1632_CL);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_CL, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'ror' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_ror_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_ROR_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/sar.c b/src/arch/x86/opcodes/sar.c
deleted file mode 100644
index a83b6ba..0000000
--- a/src/arch/x86/opcodes/sar.c
+++ /dev/null
@@ -1,235 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_sar.c - décodage des décallages arithmetiques à droite
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sar' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sar_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SAR_RM8_1);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sar' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sar_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SAR_RM8_CL);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sar' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sar_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SAR_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sar' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sar_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SAR_RM1632_1);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sar' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sar_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SAR_RM1632_CL);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_CL, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sar' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sar_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SAR_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/sbb.c b/src/arch/x86/opcodes/sbb.c
deleted file mode 100644
index bdda930..0000000
--- a/src/arch/x86/opcodes/sbb.c
+++ /dev/null
@@ -1,169 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_sbb.c - décodage des soustractions avec retenue
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sbb' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sbb_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SBB_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sbb' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sbb_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SBB_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sbb' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sbb_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SBB_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sbb' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sbb_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SBB_RM1632_R1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/scas.c b/src/arch/x86/opcodes/scas.c
deleted file mode 100644
index bee1584..0000000
--- a/src/arch/x86/opcodes/scas.c
+++ /dev/null
@@ -1,61 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_scas.c - décodage des recherches dans des chaînes ASCII
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'scas al, ...' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_scas_al_m8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SCAS_AL_M8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_AL/*FIXME*/))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/set.c b/src/arch/x86/opcodes/set.c
deleted file mode 100644
index 1126426..0000000
--- a/src/arch/x86/opcodes/set.c
+++ /dev/null
@@ -1,556 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_set.c - décodage des définitions d'octet sur condition
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'seta' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_seta_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETA_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'setb' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_setb_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETB_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sete' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sete_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETE_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'setg' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_setg_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETG_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'setl' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_setl_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETL_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'setna' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_setna_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETNA_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'setnb' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_setnb_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETNB_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'setne' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_setne_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETNE_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'setng' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_setng_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETNG_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'setnl' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_setnl_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETNL_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'setno' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_setno_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETNO_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'setnp' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_setnp_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETNP_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'setns' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_setns_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETNS_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'seto' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_seto_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETO_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'setp' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_setp_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETP_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sets' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sets_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SETS_RM8);
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM8))
- {
- g_object_unref(G_OBJECT(result));
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/shl.c b/src/arch/x86/opcodes/shl.c
deleted file mode 100644
index 8892bc0..0000000
--- a/src/arch/x86/opcodes/shl.c
+++ /dev/null
@@ -1,235 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_shl.c - décodage des décallages logiques à gauche
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'shl' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_shl_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SHL_RM8_1);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'shl' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_shl_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SHL_RM8_CL);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'shl' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_shl_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SHL_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'shl' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_shl_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SHL_RM1632_1);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'shl' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_shl_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SHL_RM1632_CL);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_CL, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'shl' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_shl_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SHL_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/shr.c b/src/arch/x86/opcodes/shr.c
deleted file mode 100644
index b8cdbff..0000000
--- a/src/arch/x86/opcodes/shr.c
+++ /dev/null
@@ -1,235 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_shr.c - décodage des décallages logiques à droite
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'shr' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_shr_rm8_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SHR_RM8_1);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_ONE))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'shr' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_shr_rm8_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SHR_RM8_CL);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_CL))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'shr' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_shr_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SHR_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'shr' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_shr_rm1632_1(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SHR_RM1632_1);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_ONE, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'shr' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_shr_rm1632_cl(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SHR_RM1632_CL);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_CL, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'shr' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_shr_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SHR_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/stos.c b/src/arch/x86/opcodes/stos.c
deleted file mode 100644
index 57a280d..0000000
--- a/src/arch/x86/opcodes/stos.c
+++ /dev/null
@@ -1,64 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_stos.c - décodage des enregistrements de données
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'stos' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_stos_m1632_e_ax(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_STOS_M1632_E_AX);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_DST_1632, X86_OTP_E_AX, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/sub.c b/src/arch/x86/opcodes/sub.c
deleted file mode 100644
index b91d260..0000000
--- a/src/arch/x86/opcodes/sub.c
+++ /dev/null
@@ -1,307 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_sub.c - décodage des soustractions
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sub al, ...' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sub_al_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SUB_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sub [e]ax, ...' (16/32 bits).*
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sub_e_ax_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SUB_E_AX_IMM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_E_AX, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sub' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sub_r8_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SUB_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R8, X86_OTP_RM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sub' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sub_r1632_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SUB_R1632_RM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sub' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sub_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_SUB_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sub' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sub_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SUB_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sub' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sub_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SUB_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'sub' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_sub_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_SUB_RM1632_R1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/test.c b/src/arch/x86/opcodes/test.c
deleted file mode 100644
index bc964a3..0000000
--- a/src/arch/x86/opcodes/test.c
+++ /dev/null
@@ -1,235 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_test.c - décodage des comparaisons logiques
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* offset = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'test al, ...' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_test_al_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_TEST_AL_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* offset = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'test [e]ax, ...' (16/32b). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_test_e_ax_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_TEST_E_AX_IMM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_E_AX, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* offset = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'test' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_test_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_TEST_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* offset = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'test' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_test_rm8_r8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_TEST_RM8_R8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
- {
- /* TODO 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. *
-* offset = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'test' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_test_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_TEST_RM1632_IMM1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* offset = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'test' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_test_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_TEST_RM1632_R1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/xchg.c b/src/arch/x86/opcodes/xchg.c
deleted file mode 100644
index fdbc915..0000000
--- a/src/arch/x86/opcodes/xchg.c
+++ /dev/null
@@ -1,67 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_xchg.c - décodage des échanges de contenu de regitres
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'xchg' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_xchg_r1632_e_ax(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- X86Opcodes opcode; /* Instruction effective */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- opcode = XOP_XCHG_R1632_E_AX + (data[*pos] - 0x90);
-
- result = g_x86_instruction_new(opcode);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_OP_R1632, X86_OTP_E_AX, oprsize, 0x90))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}
diff --git a/src/arch/x86/opcodes/xor.c b/src/arch/x86/opcodes/xor.c
deleted file mode 100644
index e38ff49..0000000
--- a/src/arch/x86/opcodes/xor.c
+++ /dev/null
@@ -1,340 +0,0 @@
-
-/* Chrysalide - Outil d'analyse de fichiers binaires
- * op_xor.c - décodage des OU exclusifs
- *
- * Copyright (C) 2012-2017 Cyrille Bagard
- *
- * This file is part of Chrysalide.
- *
- * Chrysalide 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.
- *
- * Chrysalide 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 "opcodes.h"
-
-
-#include "../operand.h"
-
-
-
-/******************************************************************************
-* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'xor al, ...' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_xor_al_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_XOR_AL_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'xor [e]ax, ...' (16/32 bits).*
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_xor_e_ax_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_XOR_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_E_AX, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'xor' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_xor_r8_rm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_XOR_R8_RM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R8, X86_OTP_RM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'xor' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_xor_rm8_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_XOR_RM8_IMM8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'xor' (8 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_xor_rm8_r8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
-
- result = g_x86_instruction_new(XOP_XOR_RM8_R8);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'xor' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_xor_r1632_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_XOR_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'xor' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_xor_rm1632_imm8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_XOR_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'xor' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_xor_rm1632_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_XOR_RM1632_IMM8);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM1632, oprsize))
- {
- /* TODO 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. *
-* addr = adresse virtuelle de l'instruction. *
-* proc = architecture ciblée par le désassemblage. *
-* *
-* Description : Décode une instruction de type 'xor' (16 ou 32 bits). *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchInstruction *x86_read_instr_xor_rm1632_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
-{
- GArchInstruction *result; /* Instruction à retourner */
- MemoryDataSize oprsize; /* Taille des opérandes */
-
- result = g_x86_instruction_new(XOP_XOR_RM1632_R1632);
-
- oprsize = g_x86_processor_get_operand_size(proc, prefix);
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, oprsize))
- {
- /* TODO free(result);*/
- return NULL;
- }
-
- return result;
-
-}