From f7d126acb7718d4a13ac64c0d71c7d019cc8c18c Mon Sep 17 00:00:00 2001 From: Cyrille Bagard Date: Thu, 18 Oct 2012 00:28:06 +0000 Subject: Reorganized the code for the x86 architecture support. git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@274 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a --- ChangeLog | 127 ++++ configure.ac | 2 + src/arch/dalvik/operands/register.c | 1 - src/arch/x86/Makefile.am | 47 +- src/arch/x86/op_adc.c | 163 ----- src/arch/x86/op_add.c | 342 --------- src/arch/x86/op_and.c | 273 -------- src/arch/x86/op_arpl.c | 63 -- src/arch/x86/op_call.c | 102 --- src/arch/x86/op_cld.c | 57 -- src/arch/x86/op_cmp.c | 342 --------- src/arch/x86/op_cmps.c | 63 -- src/arch/x86/op_dec.c | 139 ---- src/arch/x86/op_hlt.c | 57 -- src/arch/x86/op_inc.c | 139 ---- src/arch/x86/op_int.c | 96 --- src/arch/x86/op_jump.c | 1237 --------------------------------- src/arch/x86/op_lea.c | 66 -- src/arch/x86/op_leave.c | 57 -- src/arch/x86/op_mov.c | 412 ----------- src/arch/x86/op_movs.c | 66 -- src/arch/x86/op_movsx.c | 102 --- src/arch/x86/op_movzx.c | 102 --- src/arch/x86/op_mul.c | 139 ---- src/arch/x86/op_nop.c | 54 -- src/arch/x86/op_not.c | 99 --- src/arch/x86/op_or.c | 306 -------- src/arch/x86/op_pop.c | 97 --- src/arch/x86/op_push.c | 143 ---- src/arch/x86/op_rcl.c | 237 ------- src/arch/x86/op_rcr.c | 237 ------- src/arch/x86/op_ret.c | 154 ----- src/arch/x86/op_rol.c | 237 ------- src/arch/x86/op_ror.c | 237 ------- src/arch/x86/op_sar.c | 237 ------- src/arch/x86/op_sbb.c | 171 ----- src/arch/x86/op_scas.c | 63 -- src/arch/x86/op_set.c | 555 --------------- src/arch/x86/op_shl.c | 237 ------- src/arch/x86/op_shr.c | 237 ------- src/arch/x86/op_stos.c | 66 -- src/arch/x86/op_sub.c | 309 --------- src/arch/x86/op_test.c | 237 ------- src/arch/x86/op_xchg.c | 69 -- src/arch/x86/op_xor.c | 342 --------- src/arch/x86/opcodes.h | 685 ------------------ src/arch/x86/opcodes/Makefile.am | 57 ++ src/arch/x86/opcodes/adc.c | 161 +++++ src/arch/x86/opcodes/add.c | 340 +++++++++ src/arch/x86/opcodes/and.c | 271 ++++++++ src/arch/x86/opcodes/arpl.c | 61 ++ src/arch/x86/opcodes/call.c | 100 +++ src/arch/x86/opcodes/cld.c | 56 ++ src/arch/x86/opcodes/cmp.c | 340 +++++++++ src/arch/x86/opcodes/cmps.c | 64 ++ src/arch/x86/opcodes/dec.c | 137 ++++ src/arch/x86/opcodes/hlt.c | 56 ++ src/arch/x86/opcodes/inc.c | 137 ++++ src/arch/x86/opcodes/int.c | 93 +++ src/arch/x86/opcodes/jump.c | 1238 +++++++++++++++++++++++++++++++++ src/arch/x86/opcodes/lea.c | 64 ++ src/arch/x86/opcodes/leave.c | 56 ++ src/arch/x86/opcodes/mov.c | 410 +++++++++++ src/arch/x86/opcodes/movs.c | 64 ++ src/arch/x86/opcodes/movsx.c | 100 +++ src/arch/x86/opcodes/movzx.c | 100 +++ src/arch/x86/opcodes/mul.c | 137 ++++ src/arch/x86/opcodes/nop.c | 56 ++ src/arch/x86/opcodes/not.c | 97 +++ src/arch/x86/opcodes/opcodes.h | 685 ++++++++++++++++++ src/arch/x86/opcodes/or.c | 304 ++++++++ src/arch/x86/opcodes/pop.c | 95 +++ src/arch/x86/opcodes/push.c | 141 ++++ src/arch/x86/opcodes/rcl.c | 235 +++++++ src/arch/x86/opcodes/rcr.c | 235 +++++++ src/arch/x86/opcodes/ret.c | 152 ++++ src/arch/x86/opcodes/rol.c | 235 +++++++ src/arch/x86/opcodes/ror.c | 235 +++++++ src/arch/x86/opcodes/sar.c | 235 +++++++ src/arch/x86/opcodes/sbb.c | 169 +++++ src/arch/x86/opcodes/scas.c | 61 ++ src/arch/x86/opcodes/set.c | 556 +++++++++++++++ src/arch/x86/opcodes/shl.c | 235 +++++++ src/arch/x86/opcodes/shr.c | 235 +++++++ src/arch/x86/opcodes/stos.c | 64 ++ src/arch/x86/opcodes/sub.c | 307 ++++++++ src/arch/x86/opcodes/test.c | 235 +++++++ src/arch/x86/opcodes/xchg.c | 67 ++ src/arch/x86/opcodes/xor.c | 340 +++++++++ src/arch/x86/operand.c | 1305 ----------------------------------- src/arch/x86/operand.h | 169 +---- src/arch/x86/operands/Makefile.am | 21 + src/arch/x86/operands/data.c | 207 ++++++ src/arch/x86/operands/data.h | 60 ++ src/arch/x86/operands/modrm.c | 436 ++++++++++++ src/arch/x86/operands/modrm.h | 70 ++ src/arch/x86/operands/moffs.c | 189 +++++ src/arch/x86/operands/moffs.h | 59 ++ src/arch/x86/operands/register.c | 265 +++++++ src/arch/x86/operands/register.h | 66 ++ src/arch/x86/operands/relative.c | 221 ++++++ src/arch/x86/operands/relative.h | 63 ++ src/arch/x86/processor.c | 2 +- 103 files changed, 10812 insertions(+), 10540 deletions(-) delete mode 100644 src/arch/x86/op_adc.c delete mode 100644 src/arch/x86/op_add.c delete mode 100644 src/arch/x86/op_and.c delete mode 100644 src/arch/x86/op_arpl.c delete mode 100644 src/arch/x86/op_call.c delete mode 100644 src/arch/x86/op_cld.c delete mode 100644 src/arch/x86/op_cmp.c delete mode 100644 src/arch/x86/op_cmps.c delete mode 100644 src/arch/x86/op_dec.c delete mode 100644 src/arch/x86/op_hlt.c delete mode 100644 src/arch/x86/op_inc.c delete mode 100644 src/arch/x86/op_int.c delete mode 100644 src/arch/x86/op_jump.c delete mode 100644 src/arch/x86/op_lea.c delete mode 100644 src/arch/x86/op_leave.c delete mode 100644 src/arch/x86/op_mov.c delete mode 100644 src/arch/x86/op_movs.c delete mode 100644 src/arch/x86/op_movsx.c delete mode 100644 src/arch/x86/op_movzx.c delete mode 100644 src/arch/x86/op_mul.c delete mode 100644 src/arch/x86/op_nop.c delete mode 100644 src/arch/x86/op_not.c delete mode 100644 src/arch/x86/op_or.c delete mode 100644 src/arch/x86/op_pop.c delete mode 100644 src/arch/x86/op_push.c delete mode 100644 src/arch/x86/op_rcl.c delete mode 100644 src/arch/x86/op_rcr.c delete mode 100644 src/arch/x86/op_ret.c delete mode 100644 src/arch/x86/op_rol.c delete mode 100644 src/arch/x86/op_ror.c delete mode 100644 src/arch/x86/op_sar.c delete mode 100644 src/arch/x86/op_sbb.c delete mode 100644 src/arch/x86/op_scas.c delete mode 100644 src/arch/x86/op_set.c delete mode 100644 src/arch/x86/op_shl.c delete mode 100644 src/arch/x86/op_shr.c delete mode 100644 src/arch/x86/op_stos.c delete mode 100644 src/arch/x86/op_sub.c delete mode 100644 src/arch/x86/op_test.c delete mode 100644 src/arch/x86/op_xchg.c delete mode 100644 src/arch/x86/op_xor.c delete mode 100644 src/arch/x86/opcodes.h create mode 100644 src/arch/x86/opcodes/Makefile.am create mode 100644 src/arch/x86/opcodes/adc.c create mode 100644 src/arch/x86/opcodes/add.c create mode 100644 src/arch/x86/opcodes/and.c create mode 100644 src/arch/x86/opcodes/arpl.c create mode 100644 src/arch/x86/opcodes/call.c create mode 100644 src/arch/x86/opcodes/cld.c create mode 100644 src/arch/x86/opcodes/cmp.c create mode 100644 src/arch/x86/opcodes/cmps.c create mode 100644 src/arch/x86/opcodes/dec.c create mode 100644 src/arch/x86/opcodes/hlt.c create mode 100644 src/arch/x86/opcodes/inc.c create mode 100644 src/arch/x86/opcodes/int.c create mode 100644 src/arch/x86/opcodes/jump.c create mode 100644 src/arch/x86/opcodes/lea.c create mode 100644 src/arch/x86/opcodes/leave.c create mode 100644 src/arch/x86/opcodes/mov.c create mode 100644 src/arch/x86/opcodes/movs.c create mode 100644 src/arch/x86/opcodes/movsx.c create mode 100644 src/arch/x86/opcodes/movzx.c create mode 100644 src/arch/x86/opcodes/mul.c create mode 100644 src/arch/x86/opcodes/nop.c create mode 100644 src/arch/x86/opcodes/not.c create mode 100644 src/arch/x86/opcodes/opcodes.h create mode 100644 src/arch/x86/opcodes/or.c create mode 100644 src/arch/x86/opcodes/pop.c create mode 100644 src/arch/x86/opcodes/push.c create mode 100644 src/arch/x86/opcodes/rcl.c create mode 100644 src/arch/x86/opcodes/rcr.c create mode 100644 src/arch/x86/opcodes/ret.c create mode 100644 src/arch/x86/opcodes/rol.c create mode 100644 src/arch/x86/opcodes/ror.c create mode 100644 src/arch/x86/opcodes/sar.c create mode 100644 src/arch/x86/opcodes/sbb.c create mode 100644 src/arch/x86/opcodes/scas.c create mode 100644 src/arch/x86/opcodes/set.c create mode 100644 src/arch/x86/opcodes/shl.c create mode 100644 src/arch/x86/opcodes/shr.c create mode 100644 src/arch/x86/opcodes/stos.c create mode 100644 src/arch/x86/opcodes/sub.c create mode 100644 src/arch/x86/opcodes/test.c create mode 100644 src/arch/x86/opcodes/xchg.c create mode 100644 src/arch/x86/opcodes/xor.c create mode 100644 src/arch/x86/operands/Makefile.am create mode 100644 src/arch/x86/operands/data.c create mode 100644 src/arch/x86/operands/data.h create mode 100644 src/arch/x86/operands/modrm.c create mode 100644 src/arch/x86/operands/modrm.h create mode 100644 src/arch/x86/operands/moffs.c create mode 100644 src/arch/x86/operands/moffs.h create mode 100644 src/arch/x86/operands/register.c create mode 100644 src/arch/x86/operands/register.h create mode 100644 src/arch/x86/operands/relative.c create mode 100644 src/arch/x86/operands/relative.h diff --git a/ChangeLog b/ChangeLog index 27c0ed2..098c5ea 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,132 @@ 12-10-18 Cyrille Bagard + * configure.ac: + Add the new Makfiles from the src/arch/x86/opcodes and + src/arch/x86/operands directories to AC_CONFIG_FILES. + + * src/arch/dalvik/operands/register.c: + Typo. + + * src/arch/x86/Makefile.am: + Update libarchx86_la_SOURCES, libarchx86_la_LIBADD and SUBDIRS. + + * src/arch/x86/op_adc.c: + * src/arch/x86/op_add.c: + * src/arch/x86/op_and.c: + * src/arch/x86/op_arpl.c: + * src/arch/x86/op_call.c: + * src/arch/x86/op_cld.c: + * src/arch/x86/op_cmp.c: + * src/arch/x86/op_cmps.c: + Moved entries: move these files to opcodes/. + + * src/arch/x86/opcodes/adc.c: + * src/arch/x86/opcodes/add.c: + * src/arch/x86/opcodes/and.c: + * src/arch/x86/opcodes/arpl.c: + * src/arch/x86/opcodes/call.c: + * src/arch/x86/opcodes/cld.c: + * src/arch/x86/opcodes/cmp.c: + * src/arch/x86/opcodes/cmps.c: + * src/arch/x86/opcodes/dec.c: + * src/arch/x86/opcodes.h: + Moved entry: move this file to opcodes/. + + * src/arch/x86/opcodes/hlt.c: + * src/arch/x86/opcodes/inc.c: + * src/arch/x86/opcodes/int.c: + * src/arch/x86/opcodes/jump.c: + * src/arch/x86/opcodes/lea.c: + * src/arch/x86/opcodes/leave.c: + * src/arch/x86/opcodes/Makefile.am: + * src/arch/x86/opcodes/mov.c: + * src/arch/x86/opcodes/movs.c: + * src/arch/x86/opcodes/movsx.c: + * src/arch/x86/opcodes/movzx.c: + * src/arch/x86/opcodes/mul.c: + * src/arch/x86/opcodes/nop.c: + * src/arch/x86/opcodes/not.c: + * src/arch/x86/opcodes/opcodes.h: + * src/arch/x86/opcodes/or.c: + * src/arch/x86/opcodes/pop.c: + * src/arch/x86/opcodes/push.c: + * src/arch/x86/opcodes/rcl.c: + * src/arch/x86/opcodes/rcr.c: + * src/arch/x86/opcodes/ret.c: + * src/arch/x86/opcodes/rol.c: + * src/arch/x86/opcodes/ror.c: + * src/arch/x86/opcodes/sar.c: + * src/arch/x86/opcodes/sbb.c: + * src/arch/x86/opcodes/scas.c: + * src/arch/x86/opcodes/set.c: + * src/arch/x86/opcodes/shl.c: + * src/arch/x86/opcodes/shr.c: + * src/arch/x86/opcodes/stos.c: + * src/arch/x86/opcodes/sub.c: + * src/arch/x86/opcodes/test.c: + * src/arch/x86/opcodes/xchg.c: + * src/arch/x86/opcodes/xor.c: + New entries: define a proper location for all x86 opcodes. + + * src/arch/x86/op_dec.c: + Moved entries: move these files to opcodes/. + + * src/arch/x86/operand.c: + * src/arch/x86/operand.h: + Update code. + + * src/arch/x86/operands/data.c: + * src/arch/x86/operands/data.h: + * src/arch/x86/operands/Makefile.am: + * src/arch/x86/operands/modrm.c: + * src/arch/x86/operands/modrm.h: + * src/arch/x86/operands/moffs.c: + * src/arch/x86/operands/moffs.h: + * src/arch/x86/operands/register.c: + * src/arch/x86/operands/register.h: + * src/arch/x86/operands/relative.c: + * src/arch/x86/operands/relative.h: + New entries: define a proper location for all x86 operands. + + * src/arch/x86/op_hlt.c: + * src/arch/x86/op_inc.c: + * src/arch/x86/op_int.c: + * src/arch/x86/op_jump.c: + * src/arch/x86/op_lea.c: + * src/arch/x86/op_leave.c: + * src/arch/x86/op_mov.c: + * src/arch/x86/op_movs.c: + * src/arch/x86/op_movsx.c: + * src/arch/x86/op_movzx.c: + * src/arch/x86/op_mul.c: + * src/arch/x86/op_nop.c: + * src/arch/x86/op_not.c: + * src/arch/x86/op_or.c: + * src/arch/x86/op_pop.c: + * src/arch/x86/op_push.c: + * src/arch/x86/op_rcl.c: + * src/arch/x86/op_rcr.c: + * src/arch/x86/op_ret.c: + * src/arch/x86/op_rol.c: + * src/arch/x86/op_ror.c: + * src/arch/x86/op_sar.c: + * src/arch/x86/op_sbb.c: + * src/arch/x86/op_scas.c: + * src/arch/x86/op_set.c: + * src/arch/x86/op_shl.c: + * src/arch/x86/op_shr.c: + * src/arch/x86/op_stos.c: + * src/arch/x86/op_sub.c: + * src/arch/x86/op_test.c: + * src/arch/x86/op_xchg.c: + * src/arch/x86/op_xor.c: + Moved entries: move these files to opcodes/. + + * src/arch/x86/processor.c: + Update code. + +12-10-18 Cyrille Bagard + * src/common/endianness.c: * src/common/endianness.h: * src/common/environment.c: diff --git a/configure.ac b/configure.ac index 8cef052..0a79182 100644 --- a/configure.ac +++ b/configure.ac @@ -266,6 +266,8 @@ AC_CONFIG_FILES([Makefile src/arch/jvm/Makefile src/arch/mips/Makefile src/arch/x86/Makefile + src/arch/x86/opcodes/Makefile + src/arch/x86/operands/Makefile src/common/Makefile src/debug/Makefile src/debug/jdwp/Makefile diff --git a/src/arch/dalvik/operands/register.c b/src/arch/dalvik/operands/register.c index cca4ee7..fb95004 100644 --- a/src/arch/dalvik/operands/register.c +++ b/src/arch/dalvik/operands/register.c @@ -60,7 +60,6 @@ static void g_dalvik_register_operand_print(const GDalvikRegisterOperand *, GBuf - /* Indique le type défini par la GLib pour un opérande de registre Dalvik. */ G_DEFINE_TYPE(GDalvikRegisterOperand, g_dalvik_register_operand, G_TYPE_ARCH_OPERAND); diff --git a/src/arch/x86/Makefile.am b/src/arch/x86/Makefile.am index ff246c0..b7b72d6 100644 --- a/src/arch/x86/Makefile.am +++ b/src/arch/x86/Makefile.am @@ -3,52 +3,13 @@ noinst_LTLIBRARIES = libarchx86.la libarchx86_la_SOURCES = \ instruction.h instruction.c \ - op_adc.c \ - op_add.c \ - op_and.c \ - op_arpl.c \ - op_call.c \ - op_cld.c \ - op_cmp.c \ - op_cmps.c \ - op_dec.c \ - op_hlt.c \ - op_inc.c \ - op_int.c \ - op_jump.c \ - op_lea.c \ - op_leave.c \ - op_mov.c \ - op_movs.c \ - op_movsx.c \ - op_movzx.c \ - op_mul.c \ - op_nop.c \ - op_not.c \ - op_or.c \ - op_pop.c \ - op_push.c \ - op_rcl.c \ - op_rcr.c \ - op_ret.c \ - op_rol.c \ - op_ror.c \ - op_sar.c \ - op_sbb.c \ - op_scas.c \ - op_set.c \ - op_shl.c \ - op_shr.c \ - op_stos.c \ - op_sub.c \ - op_test.c \ - op_xchg.c \ - op_xor.c \ - opcodes.h \ operand.h operand.c \ processor.h processor.c \ registers.h registers.c +libarchx86_la_LIBADD = \ + opcodes/libarchx86opcodes.la \ + operands/libarchx86operands.la libarchx86_la_CFLAGS = $(AM_CFLAGS) @@ -60,4 +21,4 @@ AM_CPPFLAGS = AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) -SUBDIRS = +SUBDIRS = opcodes operands diff --git a/src/arch/x86/op_adc.c b/src/arch/x86/op_adc.c deleted file mode 100644 index f098c8c..0000000 --- a/src/arch/x86/op_adc.c +++ /dev/null @@ -1,163 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_adc.c - décodage des additions avec retenue - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_add.c b/src/arch/x86/op_add.c deleted file mode 100644 index 71a8da5..0000000 --- a/src/arch/x86/op_add.c +++ /dev/null @@ -1,342 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_add.c - décodage des additions - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_and.c b/src/arch/x86/op_and.c deleted file mode 100644 index 709434d..0000000 --- a/src/arch/x86/op_and.c +++ /dev/null @@ -1,273 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_and.c - décodage des ET logiques - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_arpl.c b/src/arch/x86/op_arpl.c deleted file mode 100644 index 22ff122..0000000 --- a/src/arch/x86/op_arpl.c +++ /dev/null @@ -1,63 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_arpl.c - décodage des ajustements de champs RPL - * - * Copyright (C) 2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_call.c b/src/arch/x86/op_call.c deleted file mode 100644 index 83d00b4..0000000 --- a/src/arch/x86/op_call.c +++ /dev/null @@ -1,102 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_call.c - décodage des appels - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_cld.c b/src/arch/x86/op_cld.c deleted file mode 100644 index 197202f..0000000 --- a/src/arch/x86/op_cld.c +++ /dev/null @@ -1,57 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_cld.c - décodage de la suppression du drapeau de direction - * - * Copyright (C) 2008-2009 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#include "opcodes.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/op_cmp.c b/src/arch/x86/op_cmp.c deleted file mode 100644 index dd14bfb..0000000 --- a/src/arch/x86/op_cmp.c +++ /dev/null @@ -1,342 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_cmp.c - décodage des comparaisons d'opérandes - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_cmps.c b/src/arch/x86/op_cmps.c deleted file mode 100644 index 6d2f2b6..0000000 --- a/src/arch/x86/op_cmps.c +++ /dev/null @@ -1,63 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_cmps.c - décodage des comparaisons de chaînes et de scalaires - * - * Copyright (C) 2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include "../instruction-int.h" -#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/op_dec.c b/src/arch/x86/op_dec.c deleted file mode 100644 index 609ad6a..0000000 --- a/src/arch/x86/op_dec.c +++ /dev/null @@ -1,139 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_dec.c - décodage des décrémentations - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_hlt.c b/src/arch/x86/op_hlt.c deleted file mode 100644 index 53016a3..0000000 --- a/src/arch/x86/op_hlt.c +++ /dev/null @@ -1,57 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_hlt.c - décodage de la mise en pause du processeur - * - * Copyright (C) 2008-2009 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#include "opcodes.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/op_inc.c b/src/arch/x86/op_inc.c deleted file mode 100644 index 8ebf8bf..0000000 --- a/src/arch/x86/op_inc.c +++ /dev/null @@ -1,139 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_inc.c - décodage des incrémentations - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_int.c b/src/arch/x86/op_int.c deleted file mode 100644 index 74bfcd4..0000000 --- a/src/arch/x86/op_int.c +++ /dev/null @@ -1,96 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_int.c - décodage des instructions d'interruption - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#include "opcodes.h" -#include "operand.h" -#include "../immediate.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/op_jump.c b/src/arch/x86/op_jump.c deleted file mode 100644 index a49782e..0000000 --- a/src/arch/x86/op_jump.c +++ /dev/null @@ -1,1237 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_jump.c - décodage des sauts inconditionnels - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include "../instruction-int.h" -#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/op_lea.c b/src/arch/x86/op_lea.c deleted file mode 100644 index b49dfbb..0000000 --- a/src/arch/x86/op_lea.c +++ /dev/null @@ -1,66 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_lea.c - décodage des chargements d'adresse effective - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_leave.c b/src/arch/x86/op_leave.c deleted file mode 100644 index 1c57d4d..0000000 --- a/src/arch/x86/op_leave.c +++ /dev/null @@ -1,57 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_leave.c - décodage de la préparation d'une sortie d'appel - * - * Copyright (C) 2008-2009 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#include "opcodes.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/op_mov.c b/src/arch/x86/op_mov.c deleted file mode 100644 index ce84e62..0000000 --- a/src/arch/x86/op_mov.c +++ /dev/null @@ -1,412 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_mov.c - décodage des déplacements de données - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_movs.c b/src/arch/x86/op_movs.c deleted file mode 100644 index 0d3cbad..0000000 --- a/src/arch/x86/op_movs.c +++ /dev/null @@ -1,66 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_movs.c - décodage des déplacements de données - * - * Copyright (C) 2009-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_movsx.c b/src/arch/x86/op_movsx.c deleted file mode 100644 index 0cbd817..0000000 --- a/src/arch/x86/op_movsx.c +++ /dev/null @@ -1,102 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_movsx.c - décodage des copies d'opérandes sans mise à zéro - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_movzx.c b/src/arch/x86/op_movzx.c deleted file mode 100644 index 1c47582..0000000 --- a/src/arch/x86/op_movzx.c +++ /dev/null @@ -1,102 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_movzx.c - décodage des copies d'opérandes avec mise à zéro - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_mul.c b/src/arch/x86/op_mul.c deleted file mode 100644 index 7b48b29..0000000 --- a/src/arch/x86/op_mul.c +++ /dev/null @@ -1,139 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_mul.c - décodage des multiplications - * - * Copyright (C) 2009-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_nop.c b/src/arch/x86/op_nop.c deleted file mode 100644 index 5e0bf72..0000000 --- a/src/arch/x86/op_nop.c +++ /dev/null @@ -1,54 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_nop.c - décodage de l'instruction nulle - * - * Copyright (C) 2008-2009 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include "../instruction-int.h" -#include "opcodes.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/op_not.c b/src/arch/x86/op_not.c deleted file mode 100644 index 78d90ff..0000000 --- a/src/arch/x86/op_not.c +++ /dev/null @@ -1,99 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_not.c - décodage des négations par complément à un - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_or.c b/src/arch/x86/op_or.c deleted file mode 100644 index 28e7aa7..0000000 --- a/src/arch/x86/op_or.c +++ /dev/null @@ -1,306 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_or.c - décodage des OU logiques - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_pop.c b/src/arch/x86/op_pop.c deleted file mode 100644 index ed48c9e..0000000 --- a/src/arch/x86/op_pop.c +++ /dev/null @@ -1,97 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_pop.c - décodage des dépilements - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_push.c b/src/arch/x86/op_push.c deleted file mode 100644 index 56621e3..0000000 --- a/src/arch/x86/op_push.c +++ /dev/null @@ -1,143 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_push.c - décodage des empilements - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_rcl.c b/src/arch/x86/op_rcl.c deleted file mode 100644 index 6634b83..0000000 --- a/src/arch/x86/op_rcl.c +++ /dev/null @@ -1,237 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_rcl.c - décodage des rotations à gauche avec retenue - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_rcr.c b/src/arch/x86/op_rcr.c deleted file mode 100644 index 69a63da..0000000 --- a/src/arch/x86/op_rcr.c +++ /dev/null @@ -1,237 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_rcr.c - décodage des rotations à droite avec retenue - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_ret.c b/src/arch/x86/op_ret.c deleted file mode 100644 index 6713992..0000000 --- a/src/arch/x86/op_ret.c +++ /dev/null @@ -1,154 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_ret.c - décodage de la sortie d'un appel - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_rol.c b/src/arch/x86/op_rol.c deleted file mode 100644 index 6f85110..0000000 --- a/src/arch/x86/op_rol.c +++ /dev/null @@ -1,237 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_rol.c - décodage des rotations à gauche sans retenue - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_ror.c b/src/arch/x86/op_ror.c deleted file mode 100644 index cedf20c..0000000 --- a/src/arch/x86/op_ror.c +++ /dev/null @@ -1,237 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_ror.c - décodage des rotations à droite sans retenue - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_sar.c b/src/arch/x86/op_sar.c deleted file mode 100644 index 8024e42..0000000 --- a/src/arch/x86/op_sar.c +++ /dev/null @@ -1,237 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_sar.c - décodage des décallages arithmetiques à droite - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_sbb.c b/src/arch/x86/op_sbb.c deleted file mode 100644 index 1939bb8..0000000 --- a/src/arch/x86/op_sbb.c +++ /dev/null @@ -1,171 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_sbb.c - décodage des soustractions avec retenue - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_scas.c b/src/arch/x86/op_scas.c deleted file mode 100644 index 2ec8230..0000000 --- a/src/arch/x86/op_scas.c +++ /dev/null @@ -1,63 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_scas.c - décodage des recherches dans des chaînes ASCII - * - * Copyright (C) 2009 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_set.c b/src/arch/x86/op_set.c deleted file mode 100644 index 65721d9..0000000 --- a/src/arch/x86/op_set.c +++ /dev/null @@ -1,555 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_set.c - décodage des définitions d'octet sur condition - * - * Copyright (C) 2009-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include "../instruction-int.h" -#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/op_shl.c b/src/arch/x86/op_shl.c deleted file mode 100644 index 9494d3e..0000000 --- a/src/arch/x86/op_shl.c +++ /dev/null @@ -1,237 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_shl.c - décodage des décallages logiques à gauche - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_shr.c b/src/arch/x86/op_shr.c deleted file mode 100644 index 28496a6..0000000 --- a/src/arch/x86/op_shr.c +++ /dev/null @@ -1,237 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_shr.c - décodage des décallages logiques à droite - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_stos.c b/src/arch/x86/op_stos.c deleted file mode 100644 index 2635c2a..0000000 --- a/src/arch/x86/op_stos.c +++ /dev/null @@ -1,66 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_stos.c - décodage des enregistrements de données - * - * Copyright (C) 2009-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_sub.c b/src/arch/x86/op_sub.c deleted file mode 100644 index 31deb4f..0000000 --- a/src/arch/x86/op_sub.c +++ /dev/null @@ -1,309 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_sub.c - décodage des soustractions - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_test.c b/src/arch/x86/op_test.c deleted file mode 100644 index 16109ee..0000000 --- a/src/arch/x86/op_test.c +++ /dev/null @@ -1,237 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_test.c - décodage des comparaisons logiques - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_xchg.c b/src/arch/x86/op_xchg.c deleted file mode 100644 index dec2560..0000000 --- a/src/arch/x86/op_xchg.c +++ /dev/null @@ -1,69 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_xchg.c - décodage des échanges de contenu de regitres - * - * Copyright (C) 2009-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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/op_xor.c b/src/arch/x86/op_xor.c deleted file mode 100644 index 575d7e7..0000000 --- a/src/arch/x86/op_xor.c +++ /dev/null @@ -1,342 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * op_xor.c - décodage des OU exclusifs - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#include - - -#include "../instruction-int.h" -#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; - -} diff --git a/src/arch/x86/opcodes.h b/src/arch/x86/opcodes.h deleted file mode 100644 index ed5d07e..0000000 --- a/src/arch/x86/opcodes.h +++ /dev/null @@ -1,685 +0,0 @@ - -/* OpenIDA - Outil d'analyse de fichiers binaires - * opcodes.h - prototypes pour la liste de tous les opcodes de l'architecture x86 - * - * Copyright (C) 2008-2010 Cyrille Bagard - * - * This file is part of OpenIDA. - * - * OpenIDA is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. - * - * OpenIDA is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with Foobar. If not, see . - */ - - -#ifndef _ARCH_X86_OPCODES_H -#define _ARCH_X86_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_H */ diff --git a/src/arch/x86/opcodes/Makefile.am b/src/arch/x86/opcodes/Makefile.am new file mode 100644 index 0000000..6f7f71e --- /dev/null +++ b/src/arch/x86/opcodes/Makefile.am @@ -0,0 +1,57 @@ + +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) + + +INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) + +AM_CPPFLAGS = + +AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) diff --git a/src/arch/x86/opcodes/adc.c b/src/arch/x86/opcodes/adc.c new file mode 100644 index 0000000..7aad32a --- /dev/null +++ b/src/arch/x86/opcodes/adc.c @@ -0,0 +1,161 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_adc.c - décodage des additions avec retenue + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..5f323e9 --- /dev/null +++ b/src/arch/x86/opcodes/add.c @@ -0,0 +1,340 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_add.c - décodage des additions + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..6eb22cf --- /dev/null +++ b/src/arch/x86/opcodes/and.c @@ -0,0 +1,271 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_and.c - décodage des ET logiques + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..cb3e7db --- /dev/null +++ b/src/arch/x86/opcodes/arpl.c @@ -0,0 +1,61 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_arpl.c - décodage des ajustements de champs RPL + * + * Copyright (C) 2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..2e5c74d --- /dev/null +++ b/src/arch/x86/opcodes/call.c @@ -0,0 +1,100 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_call.c - décodage des appels + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..2c998b0 --- /dev/null +++ b/src/arch/x86/opcodes/cld.c @@ -0,0 +1,56 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_cld.c - décodage de la suppression du drapeau de direction + * + * Copyright (C) 2008-2009 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#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 new file mode 100644 index 0000000..1ff951a --- /dev/null +++ b/src/arch/x86/opcodes/cmp.c @@ -0,0 +1,340 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_cmp.c - décodage des comparaisons d'opérandes + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..725b464 --- /dev/null +++ b/src/arch/x86/opcodes/cmps.c @@ -0,0 +1,64 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_cmps.c - décodage des comparaisons de chaînes et de scalaires + * + * Copyright (C) 2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..87e7b11 --- /dev/null +++ b/src/arch/x86/opcodes/dec.c @@ -0,0 +1,137 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_dec.c - décodage des décrémentations + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..cde96fb --- /dev/null +++ b/src/arch/x86/opcodes/hlt.c @@ -0,0 +1,56 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_hlt.c - décodage de la mise en pause du processeur + * + * Copyright (C) 2008-2009 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#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 new file mode 100644 index 0000000..ee28566 --- /dev/null +++ b/src/arch/x86/opcodes/inc.c @@ -0,0 +1,137 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_inc.c - décodage des incrémentations + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..8acf17b --- /dev/null +++ b/src/arch/x86/opcodes/int.c @@ -0,0 +1,93 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_int.c - décodage des instructions d'interruption + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..c4bf9a5 --- /dev/null +++ b/src/arch/x86/opcodes/jump.c @@ -0,0 +1,1238 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_jump.c - décodage des sauts inconditionnels + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..0291b6f --- /dev/null +++ b/src/arch/x86/opcodes/lea.c @@ -0,0 +1,64 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_lea.c - décodage des chargements d'adresse effective + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..7e6128a --- /dev/null +++ b/src/arch/x86/opcodes/leave.c @@ -0,0 +1,56 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_leave.c - décodage de la préparation d'une sortie d'appel + * + * Copyright (C) 2008-2009 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#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 new file mode 100644 index 0000000..a19689f --- /dev/null +++ b/src/arch/x86/opcodes/mov.c @@ -0,0 +1,410 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_mov.c - décodage des déplacements de données + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..7a10006 --- /dev/null +++ b/src/arch/x86/opcodes/movs.c @@ -0,0 +1,64 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_movs.c - décodage des déplacements de données + * + * Copyright (C) 2009-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..e5ec52d --- /dev/null +++ b/src/arch/x86/opcodes/movsx.c @@ -0,0 +1,100 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_movsx.c - décodage des copies d'opérandes sans mise à zéro + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..6648443 --- /dev/null +++ b/src/arch/x86/opcodes/movzx.c @@ -0,0 +1,100 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_movzx.c - décodage des copies d'opérandes avec mise à zéro + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..848fbdc --- /dev/null +++ b/src/arch/x86/opcodes/mul.c @@ -0,0 +1,137 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_mul.c - décodage des multiplications + * + * Copyright (C) 2009-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..95e692c --- /dev/null +++ b/src/arch/x86/opcodes/nop.c @@ -0,0 +1,56 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_nop.c - décodage de l'instruction nulle + * + * Copyright (C) 2008-2009 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#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 new file mode 100644 index 0000000..1a0c909 --- /dev/null +++ b/src/arch/x86/opcodes/not.c @@ -0,0 +1,97 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_not.c - décodage des négations par complément à un + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..6b65673 --- /dev/null +++ b/src/arch/x86/opcodes/opcodes.h @@ -0,0 +1,685 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * opcodes.h - prototypes pour la liste de tous les opcodes de l'architecture x86 + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#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 new file mode 100644 index 0000000..14bf0ba --- /dev/null +++ b/src/arch/x86/opcodes/or.c @@ -0,0 +1,304 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_or.c - décodage des OU logiques + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..62c0d47 --- /dev/null +++ b/src/arch/x86/opcodes/pop.c @@ -0,0 +1,95 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_pop.c - décodage des dépilements + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..8702857 --- /dev/null +++ b/src/arch/x86/opcodes/push.c @@ -0,0 +1,141 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_push.c - décodage des empilements + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..be98e23 --- /dev/null +++ b/src/arch/x86/opcodes/rcl.c @@ -0,0 +1,235 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_rcl.c - décodage des rotations à gauche avec retenue + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..a8204f7 --- /dev/null +++ b/src/arch/x86/opcodes/rcr.c @@ -0,0 +1,235 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_rcr.c - décodage des rotations à droite avec retenue + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..e1ffddf --- /dev/null +++ b/src/arch/x86/opcodes/ret.c @@ -0,0 +1,152 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_ret.c - décodage de la sortie d'un appel + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..240e953 --- /dev/null +++ b/src/arch/x86/opcodes/rol.c @@ -0,0 +1,235 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_rol.c - décodage des rotations à gauche sans retenue + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..af66330 --- /dev/null +++ b/src/arch/x86/opcodes/ror.c @@ -0,0 +1,235 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_ror.c - décodage des rotations à droite sans retenue + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..360cffb --- /dev/null +++ b/src/arch/x86/opcodes/sar.c @@ -0,0 +1,235 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_sar.c - décodage des décallages arithmetiques à droite + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..b842436 --- /dev/null +++ b/src/arch/x86/opcodes/sbb.c @@ -0,0 +1,169 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_sbb.c - décodage des soustractions avec retenue + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..f3275b5 --- /dev/null +++ b/src/arch/x86/opcodes/scas.c @@ -0,0 +1,61 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_scas.c - décodage des recherches dans des chaînes ASCII + * + * Copyright (C) 2009 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#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 new file mode 100644 index 0000000..7d93723 --- /dev/null +++ b/src/arch/x86/opcodes/set.c @@ -0,0 +1,556 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_set.c - décodage des définitions d'octet sur condition + * + * Copyright (C) 2009-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..487efd6 --- /dev/null +++ b/src/arch/x86/opcodes/shl.c @@ -0,0 +1,235 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_shl.c - décodage des décallages logiques à gauche + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..a493f71 --- /dev/null +++ b/src/arch/x86/opcodes/shr.c @@ -0,0 +1,235 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_shr.c - décodage des décallages logiques à droite + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..8c285d8 --- /dev/null +++ b/src/arch/x86/opcodes/stos.c @@ -0,0 +1,64 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_stos.c - décodage des enregistrements de données + * + * Copyright (C) 2009-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..8179feb --- /dev/null +++ b/src/arch/x86/opcodes/sub.c @@ -0,0 +1,307 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_sub.c - décodage des soustractions + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..12a2ab5 --- /dev/null +++ b/src/arch/x86/opcodes/test.c @@ -0,0 +1,235 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_test.c - décodage des comparaisons logiques + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..f4122db --- /dev/null +++ b/src/arch/x86/opcodes/xchg.c @@ -0,0 +1,67 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_xchg.c - décodage des échanges de contenu de regitres + * + * Copyright (C) 2009-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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 new file mode 100644 index 0000000..0d0bfeb --- /dev/null +++ b/src/arch/x86/opcodes/xor.c @@ -0,0 +1,340 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * op_xor.c - décodage des OU exclusifs + * + * Copyright (C) 2008-2010 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "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; + +} diff --git a/src/arch/x86/operand.c b/src/arch/x86/operand.c index 36faa76..85f2fb9 100644 --- a/src/arch/x86/operand.c +++ b/src/arch/x86/operand.c @@ -23,1311 +23,6 @@ #include "operand.h" -#include -#include -#include -#include - - -#include "../operand-int.h" -#include "../../common/extstr.h" - - - -/* ---------------------- COQUILLE VIDE POUR LES OPERANDES X86 ---------------------- */ - - -/* Définition d'un opérande de x86 (instance) */ -struct _GX86Operand -{ - GArchOperand parent; /* Instance parente */ - -}; - - -/* Définition d'un opérande de x86 (classe) */ -struct _GX86OperandClass -{ - GArchOperandClass parent; /* Classe parente */ - -}; - - -/* Initialise la classe des opérandes x86 de base. */ -static void g_x86_operand_class_init(GX86OperandClass *); - -/* Initialise une instance d'opérande de base pour x86. */ -static void g_x86_operand_init(GX86Operand *); - - - -/* ------------------------ OPERANDES VISANT UN REGISTRE X86 ------------------------ */ - - -/* Définition d'un opérande visant un registre x86 (instance) */ -struct _GX86RegisterOperand -{ - GX86Operand parent; /* Instance parente */ - - GX86Register *reg; /* Registre représenté */ - -}; - - -/* Définition d'un opérande visant un registre x86 (classe) */ -struct _GX86RegisterOperandClass -{ - GX86OperandClass parent; /* Classe parente */ - -}; - - -/* Initialise la classe des opérandes de registre x86. */ -static void g_x86_register_operand_class_init(GX86RegisterOperandClass *); - -/* Initialise une instance d'opérande de registre x86. */ -static void g_x86_register_operand_init(GX86RegisterOperand *); - -/* Ajoute du texte simple à un fichier ouvert en écriture. */ -static void g_x86_register_operand_add_text(const GX86RegisterOperand *, GRenderingOptions *, MainRendering, FILE *); - -/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */ -static void g_x86_register_operand_to_buffer(const GX86RegisterOperand *, GBufferLine *, GRenderingOptions *); - - - -/* ----------------------- OPERANDES COMPLEXES DE TYPE MOD/RM ----------------------- */ - - -/* Définition d'un opérande x86 de type ModRM (instance) */ -struct _GX86ModRMOperand -{ - GX86Operand parent; /* Instance parente */ - - uint8_t scale; /* Puissance de deux */ - GX86Register *index; /* Registre servant d'indice */ - GX86Register *base; /* Registre de base */ - GImmOperand *displacement; /* Décallage supplémentaire */ - -}; - - -/* Définition d'un opérande x86 de type ModRM (classe) */ -struct _GX86ModRMOperandClass -{ - GX86OperandClass parent; /* Classe parente */ - -}; - - -/* Initialise la classe des opérandes x86 de type ModRM. */ -static void g_x86_mod_rm_operand_class_init(GX86ModRMOperandClass *); - -/* Initialise une instance d'opérande x86 de type ModRM. */ -static void g_x86_mod_rm_operand_init(GX86ModRMOperand *); - -/* Ajoute du texte simple à un fichier ouvert en écriture. */ -static void g_x86_mod_rm_operand_add_text(const GX86ModRMOperand *, GRenderingOptions *, MainRendering, FILE *); - -/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */ -static void g_x86_mod_rm_operand_to_buffer(const GX86ModRMOperand *, GBufferLine *, GRenderingOptions *); - - - -/* ------------------------- OPERANDES D'ADRESSES RELATIVES ------------------------- */ - - -/* Définition d'un opérande x86 d'adresse relative (instance) */ -struct _GX86RelativeOperand -{ - GX86Operand parent; /* Instance parente */ - - GImmOperand *immediate; /* Adresse visée reconstituée */ - -}; - -/* Définition d'un opérande x86 d'adresse relative (classe) */ -struct _GX86RelativeOperandClass -{ - GX86OperandClass parent; /* Classe parente */ - -}; - - -/* Initialise la classe des opérandes x86 d'adresse relative. */ -static void g_x86_relative_operand_class_init(GX86RelativeOperandClass *); - -/* Initialise une instance d'opérande x86 d'adresse relative. */ -static void g_x86_relative_operand_init(GX86RelativeOperand *); - -/* Ajoute du texte simple à un fichier ouvert en écriture. */ -static void g_x86_relative_operand_add_text(const GX86RelativeOperand *, GRenderingOptions *, MainRendering, FILE *); - -/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */ -static void g_x86_relative_operand_to_buffer(const GX86RelativeOperand *, GBufferLine *, GRenderingOptions *); - - - -/* ------------------------ OPERANDES D'EMPLACEMENTS MEMOIRE ------------------------ */ - - -/* Définition d'un opérande visant un emplacement mémoire x86 (instance) */ -struct _GX86MOffsOperand -{ - GX86Operand parent; /* Instance parente */ - - GImmOperand *offset; /* Adresse mémoire visée */ - -}; - -/* Définition d'un opérande visant un emplacement mémoire x86 (classe) */ -struct _GX86MOffsOperandClass -{ - GX86OperandClass parent; /* Classe parente */ - -}; - - -/* Initialise la classe des opérandes d'emplacement mémoire x86. */ -static void g_x86_moffs_operand_class_init(GX86MOffsOperandClass *); - -/* Initialise une instance d'opérande d'emplacement mémoire x86. */ -static void g_x86_moffs_operand_init(GX86MOffsOperand *); - -/* Ajoute du texte simple à un fichier ouvert en écriture. */ -static void g_x86_moffs_operand_add_text(const GX86MOffsOperand *, GRenderingOptions *, MainRendering, FILE *); - -/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */ -static void g_x86_moffs_operand_to_buffer(const GX86MOffsOperand *, GBufferLine *, GRenderingOptions *); - - - -/* ---------------------- OPERANDES DE MANIPULATION DE DONNEES ---------------------- */ - - -/* Définition d'un opérande x86 de manipulation de données (instance) */ -struct _GX86DataOperand -{ - GX86Operand parent; /* Instance parente */ - - GX86Register *reg; /* Registre représenté */ - bool dest; /* Déduction du type de segment*/ - -}; - -/* Définition d'un opérande x86 de manipulation de données (classe) */ -struct _GX86DataOperandClass -{ - GX86OperandClass parent; /* Classe parente */ - -}; - - -/* Initialise la classe des opérandes x86 pointant des données. */ -static void g_x86_data_operand_class_init(GX86DataOperandClass *); - -/* Initialise une instance d'opérande x86 pointant des données. */ -static void g_x86_data_operand_init(GX86DataOperand *); - -/* Ajoute du texte simple à un fichier ouvert en écriture. */ -static void g_x86_data_operand_add_text(const GX86DataOperand *, GRenderingOptions *, MainRendering, FILE *); - -/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */ -static void g_x86_data_operand_to_buffer(const GX86DataOperand *, GBufferLine *, GRenderingOptions *); - - - -/* ---------------------------------------------------------------------------------- */ -/* COQUILLE VIDE POUR LES OPERANDES X86 */ -/* ---------------------------------------------------------------------------------- */ - - -/* Indique le type défini par la GLib pour un opérande de x86. */ -G_DEFINE_TYPE(GX86Operand, g_x86_operand, G_TYPE_ARCH_OPERAND); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des opérandes x86 de base. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_operand_class_init(GX86OperandClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : operand = instance à initialiser. * -* * -* Description : Initialise une instance d'opérande de base pour x86. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_operand_init(GX86Operand *operand) -{ - -} - - - -/* ---------------------------------------------------------------------------------- */ -/* OPERANDES VISANT UN REGISTRE X86 */ -/* ---------------------------------------------------------------------------------- */ - - -/* Indique le type défini par la GLib pour un opérande de registre x86. */ -G_DEFINE_TYPE(GX86RegisterOperand, g_x86_register_operand, G_TYPE_X86_OPERAND); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des opérandes de registre x86. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_register_operand_class_init(GX86RegisterOperandClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : operand = instance à initialiser. * -* * -* Description : Initialise une instance d'opérande de registre x86. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_register_operand_init(GX86RegisterOperand *operand) -{ - GContentExporter *parent; /* Instance parente */ - - parent = G_CONTENT_EXPORTER(operand); - - parent->add_text = (add_text_fc)g_x86_register_operand_add_text; - parent->export_buffer = (export_buffer_fc)g_x86_register_operand_to_buffer; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* len = taille totale des données à analyser. * -* size = taille de l'opérande, et donc du registre. * -* base = indice du premier registre. * -* * -* Description : Crée un opérande visant un registre x86. * -* * -* Retour : Opérande mis en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchOperand *g_x86_register_operand_new_from_opcode(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size, bin_t base) -{ - GX86RegisterOperand *result; /* Structure à retourner */ - GX86Register *reg; /* Registre lu */ - - reg = g_x86_register_new(size, data[*pos] - base); - - if (reg != NULL) - { - (*pos)++; - - result = g_object_new(G_TYPE_X86_REGISTER_OPERAND, NULL); - - result->reg = reg; - - } - else result = NULL; - - return G_ARCH_OPERAND(result); - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* len = taille totale des données à analyser. * -* size = taille de l'opérande, et donc du registre. * -* first = indique la partie du ModR/M à traiter. * -* * -* Description : Crée un opérande visant un registre x86. * -* * -* Retour : Opérande mis en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchOperand *g_x86_register_operand_new_from_mod_rm(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size, bool first) -{ - GX86RegisterOperand *result; /* Structure à retourner */ - bin_t index; /* Registre lu */ - GX86Register *reg; /* Registre créé */ - - if (first) index = data[*pos] & 0x07; - else index = (data[*pos] & 0x38) >> 3; - - reg = g_x86_register_new(size, index); - - if (reg != NULL) - { - (*pos)++; - - result = g_object_new(G_TYPE_X86_REGISTER_OPERAND, NULL); - - result->reg = reg; - - } - else result = NULL; - - return G_ARCH_OPERAND(result); - -} - - -/****************************************************************************** -* * -* Paramètres : index = indice du registre visé. * -* size = taille de l'opérande, et donc du registre. * -* * -* Description : Crée un opérande visant un registre x86 donné. * -* * -* Retour : Opérande mis en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchOperand *g_x86_register_operand_new_from_index(bin_t index, MemoryDataSize size) -{ - GX86RegisterOperand *result; /* Structure à retourner */ - GX86Register *reg; /* Registre lu */ - - reg = g_x86_register_new(size, index); - - if (reg != NULL) - { - result = g_object_new(G_TYPE_X86_REGISTER_OPERAND, NULL); - - result->reg = reg; - - } - else result = NULL; - - return G_ARCH_OPERAND(result); - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à transcrire. * -* options = options de rendu. * -* rendering = support effectif final des lignes de code. * -* stream = flux ouvert en écriture. * -* * -* Description : Ajoute du texte simple à un fichier ouvert en écriture. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_register_operand_add_text(const GX86RegisterOperand *operand, GRenderingOptions *options, MainRendering rendering, FILE *stream) -{ - g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->reg), options, rendering, stream); - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à transcrire. * -* buffer = espace où placer ledit contenu. * -* options = options de rendu. * -* * -* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_register_operand_to_buffer(const GX86RegisterOperand *operand, GBufferLine *buffer, GRenderingOptions *options) -{ - g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->reg), buffer, options); - -} - - - -/* ---------------------------------------------------------------------------------- */ -/* OPERANDES COMPLEXES DE TYPE MOD/RM */ -/* ---------------------------------------------------------------------------------- */ - - -/* Indique le type défini par la GLib pour un opérande x86 de type ModRM. */ -G_DEFINE_TYPE(GX86ModRMOperand, g_x86_mod_rm_operand, G_TYPE_ARCH_OPERAND); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des opérandes x86 de type ModRM. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_mod_rm_operand_class_init(GX86ModRMOperandClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : operand = instance à initialiser. * -* * -* Description : Initialise une instance d'opérande x86 de type ModRM. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_mod_rm_operand_init(GX86ModRMOperand *operand) -{ - GContentExporter *parent; /* Instance parente */ - - parent = G_CONTENT_EXPORTER(operand); - - parent->add_text = (add_text_fc)g_x86_mod_rm_operand_add_text; - parent->export_buffer = (export_buffer_fc)g_x86_mod_rm_operand_to_buffer; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* len = taille totale des données à analyser. * -* size = taille de l'opérande, et donc du registre. * -* * -* Description : Crée un opérande x86 de type ModRM. * -* * -* Retour : Opérande mis en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchOperand *g_x86_mod_rm_operand_new(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size) -{ - GX86ModRMOperand *result; /* Structure à retourner */ - uint8_t mod; /* Modificateur présent */ - GX86Register *reg; /* Registre lu */ - - mod = (data[*pos] & 0xc0); - - if (mod == 0xc0) - return g_x86_register_operand_new_from_mod_rm(data, pos, len, size, true); - - reg = g_x86_register_new(size, data[*pos] & 0x07); - if (reg == NULL) return NULL; - - (*pos)++; - - /* Vieille astuce de l'emplacement mémoire fixe ? */ - if (g_x86_register_is_base_pointer(reg) && mod == 0x00) - { - /* FIXME *///free_x86_register(reg); - return g_imm_operand_new_from_data(MDS_32_BITS/* FIXME */, data, pos, len, SRE_LITTLE /*FIXME*/); - } - - result = g_object_new(G_TYPE_X86_MOD_RM_OPERAND, NULL); - - /* A la recherche d'un SIB */ - if (g_x86_register_is_stack_pointer(reg)) - { - /* FIXME *///free_x86_register(reg); - - result->base = g_x86_register_new(size, data[*pos] & 0x07); - if (result->base == NULL) goto gxmron_error; - - result->index = g_x86_register_new(size, (data[*pos] & 0x38) >> 3); - if (result->index == NULL) goto gxmron_error; - - result->scale = ((data[*pos] & 0xc0) >> 6); - - if (g_x86_register_is_stack_pointer(result->index)) - { - /* FIXME *///free_x86_register(result->index); - result->index = result->base; - result->base = NULL; - } - - (*pos)++; - - } - - else result->index = reg; - - /* Décallage supplémentaire ? */ - switch (mod) - { - case 0x00: - if (result->base != NULL && g_x86_register_is_base_pointer(result->base)) - { - /* FIXME *///free_x86_register(result->base); - result->base = NULL; - - result->displacement = g_imm_operand_new_from_data(size/* FIXME : !convert mds/aos */, data, pos, len, SRE_LITTLE /* FIXME */); - if (result->displacement == NULL) goto gxmron_error; - - } - break; - - case 0x40: - result->displacement = g_imm_operand_new_from_data(MDS_8_BITS_SIGNED, data, pos, len, SRE_LITTLE /* FIXME */); - if (result->displacement == NULL) goto gxmron_error; - break; - - case 0x80: - result->displacement = g_imm_operand_new_from_data(MDS_32_BITS_SIGNED/* FIXME ! 16/32 */, data, pos, len, SRE_LITTLE /* FIXME */); - if (result->displacement == NULL) goto gxmron_error; - break; - - } - - return G_ARCH_OPERAND(result); - - gxmron_error: - - /* FIXME free(result);*/ - return NULL; - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à transcrire. * -* options = options de rendu. * -* rendering = support effectif final des lignes de code. * -* stream = flux ouvert en écriture. * -* * -* Description : Ajoute du texte simple à un fichier ouvert en écriture. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_mod_rm_operand_add_text(const GX86ModRMOperand *operand, GRenderingOptions *options, MainRendering rendering, FILE *stream) -{ - GContentExporter *exporter; /* Autre vision de l'opérande */ - char tmp[2]; /* Echelle en puissance de 2 */ - - exporter = G_CONTENT_EXPORTER(operand); - - switch (g_rendering_options_get_syntax(options)) - { - case ASX_INTEL: - - g_content_exporter_insert_text(exporter, stream, "[", 1, RTT_HOOK); - - if (operand->scale > 0) - { - snprintf(tmp, 2, "%d", (int)pow(2, operand->scale)); - - g_content_exporter_insert_text(exporter, stream, tmp, 1, RTT_IMMEDIATE); - - g_content_exporter_insert_text(exporter, stream, "*", 1, RTT_SIGNS); - - } - - g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->index), - options, rendering, stream); - - if (operand->base != NULL) - { - g_content_exporter_insert_text(exporter, stream, "+", 1, RTT_SIGNS); - - g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->base), - options, rendering, stream); - - } - - if (operand->displacement != NULL) - { - if (g_imm_operand_is_negative(operand->displacement)) - g_content_exporter_insert_text(exporter, stream, "-", 1, RTT_SIGNS); - else - g_content_exporter_insert_text(exporter, stream, "+", 1, RTT_SIGNS); - - g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->displacement), - options, rendering, stream); - - } - - g_content_exporter_insert_text(exporter, stream, "]", 1, RTT_HOOK); - - break; - - case ASX_ATT: - - /* TODO */ - g_content_exporter_insert_text(exporter, stream, "[ModRM]", 7, RTT_HOOK); - - break; - - } - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à transcrire. * -* buffer = espace où placer ledit contenu. * -* options = options de rendu. * -* * -* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_mod_rm_operand_to_buffer(const GX86ModRMOperand *operand, GBufferLine *buffer, GRenderingOptions *options) -{ - GContentExporter *exporter; /* Autre vision de l'opérande */ - char tmp[2]; /* Echelle en puissance de 2 */ - - exporter = G_CONTENT_EXPORTER(operand); - - switch (g_rendering_options_get_syntax(options)) - { - case ASX_INTEL: - - g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, - "[", 1, RTT_HOOK); - - if (operand->scale > 0) - { - snprintf(tmp, 2, "%d", (int)pow(2, operand->scale)); - - g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, - tmp, 1, RTT_IMMEDIATE); - - g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, - "*", 1, RTT_SIGNS); - - } - - g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->index), buffer, options); - - if (operand->base != NULL) - { - g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, - "+", 1, RTT_SIGNS); - - g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->base), buffer, options); - - } - - if (operand->displacement != NULL) - { - if (g_imm_operand_is_negative(operand->displacement)) - g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, - "-", 1, RTT_SIGNS); - else - g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, - "+", 1, RTT_SIGNS); - - g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->displacement), buffer, options); - - } - - g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, - "]", 1, RTT_HOOK); - - break; - - case ASX_ATT: - - /* TODO */ - g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, - "[ModRM]", 7, RTT_HOOK); - - break; - - } - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à consulter. * -* scale = facteur sous forme de puissance de deux. [OUT * -* index = register principal de l'opérande. [OUT] * -* * -* Description : Fournit l'indice et l'échelle d'un opérande x86 ModRM. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_x86_mod_rm_operand_get_scale_and_index(const GX86ModRMOperand *operand, uint8_t *scale, const GX86Register **index) -{ - *scale = operand->scale; - *index = operand->index; - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à consulter. * -* * -* Description : Fournit le registre de base d'un opérande x86 ModRM. * -* * -* Retour : Registre de base de l'opérande. * -* * -* Remarques : - * -* * -******************************************************************************/ - -const GX86Register *g_x86_mod_rm_operand_get_base(const GX86ModRMOperand *operand) -{ - return operand->base; - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à consulter. * -* * -* Description : Fournit le décallage supplémentaire d'un opérande x86 ModRM. * -* * -* Retour : Décallage numérique pour l'opérande. * -* * -* Remarques : - * -* * -******************************************************************************/ - -const GImmOperand *g_x86_mod_rm_operand_get_displacement(const GX86ModRMOperand *operand) -{ - return operand->displacement; - -} - - - -/* ---------------------------------------------------------------------------------- */ -/* OPERANDES D'ADRESSES RELATIVES */ -/* ---------------------------------------------------------------------------------- */ - - -/* Indique le type défini par la GLib pour un opérande x86 d'adresse relative. */ -G_DEFINE_TYPE(GX86RelativeOperand, g_x86_relative_operand, G_TYPE_X86_OPERAND); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des opérandes x86 d'adresse relative. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_relative_operand_class_init(GX86RelativeOperandClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : operand = instance à initialiser. * -* * -* Description : Initialise une instance d'opérande x86 d'adresse relative. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_relative_operand_init(GX86RelativeOperand *operand) -{ - GContentExporter *parent; /* Instance parente */ - - parent = G_CONTENT_EXPORTER(operand); - - parent->add_text = (add_text_fc)g_x86_relative_operand_add_text; - parent->export_buffer = (export_buffer_fc)g_x86_relative_operand_to_buffer; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* len = taille totale des données à analyser. * -* size = taille de l'opérande, et donc du registre. * -* base = adresse de référence pour le calcul. * -* * -* Description : Crée un opérande X86 d'adresse relative. * -* * -* Retour : Opérande mis en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchOperand *g_x86_relative_operand_new(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size, vmpa_t base) -{ - GX86RelativeOperand *result; /* Structure à retourner */ - off_t init_pos; /* Position avant lecture */ - int8_t val8; /* Valeur sur 8 bits */ - int16_t val16; /* Valeur sur 16 bits */ - int32_t val32; /* Valeur sur 32 bits */ - vmpa_t address; /* Adresse finale visée */ - - init_pos = *pos; - - switch (size) - { - case MDS_8_BITS_UNSIGNED: - read_s8(&val8, data, pos, len, SRE_LITTLE /* FIXME */); - address = base + (*pos - init_pos) + val8; - break; - case MDS_16_BITS_UNSIGNED: - read_s16(&val16, data, pos, len, SRE_LITTLE /* FIXME */); - address = base + (*pos - init_pos) + val16; - break; - case MDS_32_BITS_UNSIGNED: - read_s32(&val32, data, pos, len, SRE_LITTLE /* FIXME */); - address = base + (*pos - init_pos) + val32; - break; - default: - return NULL; - break; - } - - result = g_object_new(G_TYPE_X86_RELATIVE_OPERAND, NULL); - result->immediate = g_imm_operand_new_from_value(MDS_32_BITS/*FIXME*/, (uint32_t)address/* FIXME */); - - return G_ARCH_OPERAND(result); - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à transcrire. * -* options = options de rendu. * -* rendering = support effectif final des lignes de code. * -* stream = flux ouvert en écriture. * -* * -* Description : Ajoute du texte simple à un fichier ouvert en écriture. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_relative_operand_add_text(const GX86RelativeOperand *operand, GRenderingOptions *options, MainRendering rendering, FILE *stream) -{ - g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->immediate), options, rendering, stream); - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à transcrire. * -* buffer = espace où placer ledit contenu. * -* options = options de rendu. * -* * -* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_relative_operand_to_buffer(const GX86RelativeOperand *operand, GBufferLine *buffer, GRenderingOptions *options) -{ - g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->immediate), buffer, options); - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à traiter. * -* * -* Description : Fournit l'adresse représentée par une opérande X86. * -* * -* Retour : Valeur portée par l'opérande. * -* * -* Remarques : - * -* * -******************************************************************************/ - -const GImmOperand *g_x86_relative_operand_get_value(const GX86RelativeOperand *operand) -{ - return operand->immediate; - -} - - - -/* ---------------------------------------------------------------------------------- */ -/* OPERANDES D'EMPLACEMENTS MEMOIRE */ -/* ---------------------------------------------------------------------------------- */ - - -/* Indique le type défini par la GLib pour un opérande d'emplacement mémoire x86. */ -G_DEFINE_TYPE(GX86MOffsOperand, g_x86_moffs_operand, G_TYPE_X86_OPERAND); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des opérandes d'emplacement mémoire x86.* -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_moffs_operand_class_init(GX86MOffsOperandClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : operand = instance à initialiser. * -* * -* Description : Initialise une instance d'opérande d'emplacement mémoire x86.* -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_moffs_operand_init(GX86MOffsOperand *operand) -{ - GContentExporter *parent; /* Instance parente */ - - parent = G_CONTENT_EXPORTER(operand); - - parent->add_text = (add_text_fc)g_x86_moffs_operand_add_text; - parent->export_buffer = (export_buffer_fc)g_x86_moffs_operand_to_buffer; - -} - - -/****************************************************************************** -* * -* Paramètres : data = flux de données à analyser. * -* pos = position courante dans ce flux. [OUT] * -* len = taille totale des données à analyser. * -* size = taille de l'opérande, et donc du registre. * -* * -* Description : Crée un opérande d'emplacement mémoire x86. * -* * -* Retour : Opérande mis en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchOperand *g_x86_moffs_operand_new(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size) -{ - GX86MOffsOperand *result; /* Structure à retourner */ - GImmOperand *offset; /* Emplacement lu */ - - result = NULL; - - offset = g_imm_operand_new_from_data(size, data, pos, len, SRE_LITTLE /* FIXME */); - - if (offset != NULL) - { - result = g_object_new(G_TYPE_X86_MOFFS_OPERAND, NULL); - result->offset = offset; - } - - return G_ARCH_OPERAND(result); - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à transcrire. * -* options = options de rendu. * -* rendering = support effectif final des lignes de code. * -* stream = flux ouvert en écriture. * -* * -* Description : Ajoute du texte simple à un fichier ouvert en écriture. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_moffs_operand_add_text(const GX86MOffsOperand *operand, GRenderingOptions *options, MainRendering rendering, FILE *stream) -{ - g_content_exporter_insert_text(G_CONTENT_EXPORTER(operand), stream, "ds:", 3, RTT_SEGMENT); - - g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->offset), options, rendering, stream); - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à transcrire. * -* buffer = espace où placer ledit contenu. * -* options = options de rendu. * -* * -* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_moffs_operand_to_buffer(const GX86MOffsOperand *operand, GBufferLine *buffer, GRenderingOptions *options) -{ - g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY, - "ds:", 3, RTT_SEGMENT); - - g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->offset), buffer, options); - -} - - - -/* ---------------------------------------------------------------------------------- */ -/* OPERANDES DE MANIPULATION DE DONNEES */ -/* ---------------------------------------------------------------------------------- */ - - -/* Indique le type défini par la GLib pour un opérande x86 de manipulation de données. */ -G_DEFINE_TYPE(GX86DataOperand, g_x86_data_operand, G_TYPE_X86_OPERAND); - - -/****************************************************************************** -* * -* Paramètres : klass = classe à initialiser. * -* * -* Description : Initialise la classe des opérandes x86 pointant des données. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_data_operand_class_init(GX86DataOperandClass *klass) -{ - -} - - -/****************************************************************************** -* * -* Paramètres : operand = instance à initialiser. * -* * -* Description : Initialise une instance d'opérande pointant des données. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_data_operand_init(GX86DataOperand *operand) -{ - GContentExporter *parent; /* Instance parente */ - - parent = G_CONTENT_EXPORTER(operand); - - parent->add_text = (add_text_fc)g_x86_data_operand_add_text; - parent->export_buffer = (export_buffer_fc)g_x86_data_operand_to_buffer; - -} - - -/****************************************************************************** -* * -* Paramètres : size = taille de l'opérande, et donc du registre. * -* dest = indique si la cible est une destination ou une source.* -* * -* Description : Crée un opérande x86 de manipulation de données. * -* * -* Retour : Opérande mis en place. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GArchOperand *g_x86_data_operand_new(MemoryDataSize size, bool dest) -{ - GX86DataOperand *result; /* Structure à retourner */ - - result = g_object_new(G_TYPE_X86_DATA_OPERAND, NULL); - - result->reg = g_x86_register_new(MDS_32_BITS/* FIXME size*/, dest ? 0x07 : 0x06); - result->dest = dest; - - return G_ARCH_OPERAND(result); - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à transcrire. * -* options = options de rendu. * -* rendering = support effectif final des lignes de code. * -* stream = flux ouvert en écriture. * -* * -* Description : Ajoute du texte simple à un fichier ouvert en écriture. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_data_operand_add_text(const GX86DataOperand *operand, GRenderingOptions *options, MainRendering rendering, FILE *stream) -{ - GContentExporter *exporter; /* Autre vision de l'opérande */ - - exporter = G_CONTENT_EXPORTER(operand); - - if (operand->dest) - g_content_exporter_insert_text(exporter, stream, "es:", 3, RTT_SEGMENT); - else - g_content_exporter_insert_text(exporter, stream, "ds:", 3, RTT_SEGMENT); - - g_content_exporter_insert_text(exporter, stream, "[", 1, RTT_HOOK); - - g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->reg), options, rendering, stream); - - g_content_exporter_insert_text(exporter, stream, "]", 1, RTT_HOOK); - -} - - -/****************************************************************************** -* * -* Paramètres : operand = opérande à transcrire. * -* buffer = espace où placer ledit contenu. * -* options = options de rendu. * -* * -* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_x86_data_operand_to_buffer(const GX86DataOperand *operand, GBufferLine *buffer, GRenderingOptions *options) -{ - GContentExporter *exporter; /* Autre vision de l'opérande */ - - exporter = G_CONTENT_EXPORTER(operand); - - if (operand->dest) - g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY, - "es:", 3, RTT_SEGMENT); - else - g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY, - "ds:", 3, RTT_SEGMENT); - - g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY, - "[", 1, RTT_HOOK); - - g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->reg), buffer, options); - - g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY, - "]", 1, RTT_HOOK); - -} - - - -/* ---------------------------------------------------------------------------------- */ -/* AIDE A LA CREATION D'OPERANDES */ -/* ---------------------------------------------------------------------------------- */ - /****************************************************************************** * * diff --git a/src/arch/x86/operand.h b/src/arch/x86/operand.h index 17d8844..01a12c5 100644 --- a/src/arch/x86/operand.h +++ b/src/arch/x86/operand.h @@ -28,174 +28,15 @@ #include -#include "../immediate.h" +#include "operands/data.h" +#include "operands/modrm.h" +#include "operands/moffs.h" +#include "operands/register.h" +#include "operands/relative.h" #include "../instruction.h" -#include "registers.h" -/* ---------------------- COQUILLE VIDE POUR LES OPERANDES X86 ---------------------- */ - - -#define G_TYPE_X86_OPERAND g_x86_operand_get_type() -#define G_X86_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_x86_operand_get_type(), GX86Operand)) -#define G_IS_X86_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_x86_operand_get_type())) -#define G_X86_OPERAND_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_x86_operand_get_type(), GX86OperandIface)) - - -/* Définition d'un opérande de x86 (instance) */ -typedef struct _GX86Operand GX86Operand; - -/* Définition d'un opérande de x86 (classe) */ -typedef struct _GX86OperandClass GX86OperandClass; - - -/* Indique le type défini par la GLib pour un opérande de x86. */ -GType g_x86_operand_get_type(void); - - - -/* ------------------------ OPERANDES VISANT UN REGISTRE X86 ------------------------ */ - - -#define G_TYPE_X86_REGISTER_OPERAND g_x86_register_operand_get_type() -#define G_X86_REGISTER_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_x86_register_operand_get_type(), GX86RegisterOperand)) -#define G_IS_X86_REGISTER_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_x86_register_operand_get_type())) -#define G_X86_REGISTER_OPERAND_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_x86_register_operand_get_type(), GX86RegisterOperandIface)) - - -/* Définition d'un opérande visant un registre x86 (instance) */ -typedef struct _GX86RegisterOperand GX86RegisterOperand; - -/* Définition d'un opérande visant un registre x86 (classe) */ -typedef struct _GX86RegisterOperandClass GX86RegisterOperandClass; - - -/* Indique le type défini par la GLib pour un opérande de registre x86. */ -GType g_x86_register_operand_get_type(void); - -/* Crée un opérande visant un registre x86. */ -GArchOperand *g_x86_register_operand_new_from_opcode(const bin_t *, off_t *, off_t, MemoryDataSize, bin_t); - -/* Crée un opérande visant un registre x86. */ -GArchOperand *g_x86_register_operand_new_from_mod_rm(const bin_t *, off_t *, off_t, MemoryDataSize, bool); - -/* Crée un opérande visant un registre x86 donné. */ -GArchOperand *g_x86_register_operand_new_from_index(bin_t, MemoryDataSize); - - - -/* ----------------------- OPERANDES COMPLEXES DE TYPE MOD/RM ----------------------- */ - - -#define G_TYPE_X86_MOD_RM_OPERAND g_x86_mod_rm_operand_get_type() -#define G_X86_MOD_RM_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_x86_mod_rm_operand_get_type(), GX86ModRMOperand)) -#define G_IS_X86_MOD_RM_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_x86_mod_rm_operand_get_type())) -#define G_X86_MOD_RM_OPERAND_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_x86_mod_rm_operand_get_type(), GX86ModRMOperandIface)) - - -/* Définition d'un opérande x86 de type ModRM (instance) */ -typedef struct _GX86ModRMOperand GX86ModRMOperand; - -/* Définition d'un opérande x86 de type ModRM (classe) */ -typedef struct _GX86ModRMOperandClass GX86ModRMOperandClass; - - -/* Indique le type défini par la GLib pour un opérande x86 de type ModRM. */ -GType g_x86_mod_rm_operand_get_type(void); - -/* Crée un opérande x86 de type ModRM. */ -GArchOperand *g_x86_mod_rm_operand_new(const bin_t *, off_t *, off_t, MemoryDataSize); - -/* Fournit l'indice et l'échelle d'un opérande x86 ModRM. */ -void g_x86_mod_rm_operand_get_scale_and_index(const GX86ModRMOperand *operand, uint8_t *, const GX86Register **); - -/* Fournit le registre de base d'un opérande x86 ModRM. */ -const GX86Register *g_x86_mod_rm_operand_get_base(const GX86ModRMOperand *); - -/* Fournit le décallage supplémentaire d'un opérande x86 ModRM. */ -const GImmOperand *g_x86_mod_rm_operand_get_displacement(const GX86ModRMOperand *); - - - -/* ------------------------- OPERANDES D'ADRESSES RELATIVES ------------------------- */ - - -#define G_TYPE_X86_RELATIVE_OPERAND g_x86_relative_operand_get_type() -#define G_X86_RELATIVE_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_x86_relative_operand_get_type(), GX86RelativeOperand)) -#define G_IS_X86_RELATIVE_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_x86_relative_operand_get_type())) -#define G_X86_RELATIVE_OPERAND_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_x86_relative_operand_get_type(), GX86RelativeOperandIface)) - - -/* Définition d'un opérande x86 d'adresse relative (instance) */ -typedef struct _GX86RelativeOperand GX86RelativeOperand; - -/* Définition d'un opérande x86 d'adresse relative (classe) */ -typedef struct _GX86RelativeOperandClass GX86RelativeOperandClass; - - -/* Indique le type défini par la GLib pour un opérande x86 d'adresse relative. */ -GType g_x86_relative_operand_get_type(void); - -/* Crée un opérande X86 d'adresse relative. */ -GArchOperand *g_x86_relative_operand_new(const bin_t *, off_t *, off_t, MemoryDataSize, vmpa_t); - -/* Fournit l'adresse représentée par une opérande X86. */ -const GImmOperand *g_x86_relative_operand_get_value(const GX86RelativeOperand *); - - - -/* ------------------------ OPERANDES D'EMPLACEMENTS MEMOIRE ------------------------ */ - - -#define G_TYPE_X86_MOFFS_OPERAND g_x86_moffs_operand_get_type() -#define G_X86_MOFFS_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_x86_moffs_operand_get_type(), GX86MoffsOperand)) -#define G_IS_X86_MOFFS_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_x86_moffs_operand_get_type())) -#define G_X86_MOFFS_OPERAND_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_x86_moffs_operand_get_type(), GX86MoffsOperandIface)) - - -/* Définition d'un opérande visant un emplacement mémoire x86 (instance) */ -typedef struct _GX86MOffsOperand GX86MOffsOperand; - -/* Définition d'un opérande visant un emplacement mémoire x86 (classe) */ -typedef struct _GX86MOffsOperandClass GX86MOffsOperandClass; - - -/* Indique le type défini par la GLib pour un opérande d'emplacement mémoire x86. */ -GType g_x86_moffs_operand_get_type(void); - -/* Crée un opérande d'emplacement mémoire x86. */ -GArchOperand *g_x86_moffs_operand_new(const bin_t *, off_t *, off_t, MemoryDataSize); - - - -/* ---------------------- OPERANDES DE MANIPULATION DE DONNEES ---------------------- */ - - -#define G_TYPE_X86_DATA_OPERAND g_x86_data_operand_get_type() -#define G_X86_DATA_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_x86_data_operand_get_type(), GX86DataOperand)) -#define G_IS_X86_DATA_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_x86_data_operand_get_type())) -#define G_X86_DATA_OPERAND_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_x86_data_operand_get_type(), GX86DataOperandIface)) - - -/* Définition d'un opérande x86 de manipulation de données (instance) */ -typedef struct _GX86DataOperand GX86DataOperand; - -/* Définition d'un opérande x86 de manipulation de données (classe) */ -typedef struct _GX86DataOperandClass GX86DataOperandClass; - - -/* Indique le type défini par la GLib pour un opérande x86 de manipulation de données. */ -GType g_x86_data_operand_get_type(void); - -/* Crée un opérande x86 de manipulation de données. */ -GArchOperand *g_x86_data_operand_new(MemoryDataSize, bool); - - - -/* ------------------------- AIDE A LA CREATION D'OPERANDES ------------------------- */ - - /* Construction d'identifiants typés */ #define X86_OTP_IMM_TYPE 0x8000 diff --git a/src/arch/x86/operands/Makefile.am b/src/arch/x86/operands/Makefile.am new file mode 100644 index 0000000..ac48667 --- /dev/null +++ b/src/arch/x86/operands/Makefile.am @@ -0,0 +1,21 @@ + +noinst_LTLIBRARIES = libarchx86operands.la + +libarchx86operands_la_SOURCES = \ + data.h data.c \ + modrm.h modrm.c \ + moffs.h moffs.c \ + register.h register.c \ + relative.h relative.c + +libarchx86_la_CFLAGS = $(AM_CFLAGS) + + +INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) + +AM_CPPFLAGS = + +AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) + + +SUBDIRS = diff --git a/src/arch/x86/operands/data.c b/src/arch/x86/operands/data.c new file mode 100644 index 0000000..22f16b7 --- /dev/null +++ b/src/arch/x86/operands/data.c @@ -0,0 +1,207 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * data.c - opérandes de manipulation de données + * + * Copyright (C) 2012 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "data.h" + + +#include "../registers.h" +#include "../../operand-int.h" + + + +/* Définition d'un opérande x86 de manipulation de données (instance) */ +struct _GX86DataOperand +{ + GArchOperand parent; /* Instance parente */ + + GX86Register *reg; /* Registre représenté */ + bool dest; /* Déduction du type de segment*/ + +}; + +/* Définition d'un opérande x86 de manipulation de données (classe) */ +struct _GX86DataOperandClass +{ + GArchOperandClass parent; /* Classe parente */ + +}; + + +/* Initialise la classe des opérandes x86 pointant des données. */ +static void g_x86_data_operand_class_init(GX86DataOperandClass *); + +/* Initialise une instance d'opérande x86 pointant des données. */ +static void g_x86_data_operand_init(GX86DataOperand *); + +/* Ajoute du texte simple à un fichier ouvert en écriture. */ +static void g_x86_data_operand_add_text(const GX86DataOperand *, GRenderingOptions *, MainRendering, FILE *); + +/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */ +static void g_x86_data_operand_to_buffer(const GX86DataOperand *, GBufferLine *, GRenderingOptions *); + + + +/* Indique le type défini par la GLib pour un opérande x86 de manipulation de données. */ +G_DEFINE_TYPE(GX86DataOperand, g_x86_data_operand, G_TYPE_ARCH_OPERAND); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des opérandes x86 pointant des données. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_data_operand_class_init(GX86DataOperandClass *klass) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : operand = instance à initialiser. * +* * +* Description : Initialise une instance d'opérande pointant des données. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_data_operand_init(GX86DataOperand *operand) +{ + GContentExporter *parent; /* Instance parente */ + + parent = G_CONTENT_EXPORTER(operand); + + parent->add_text = (add_text_fc)g_x86_data_operand_add_text; + parent->export_buffer = (export_buffer_fc)g_x86_data_operand_to_buffer; + +} + + +/****************************************************************************** +* * +* Paramètres : size = taille de l'opérande, et donc du registre. * +* dest = indique si la cible est une destination ou une source.* +* * +* Description : Crée un opérande x86 de manipulation de données. * +* * +* Retour : Opérande mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GArchOperand *g_x86_data_operand_new(MemoryDataSize size, bool dest) +{ + GX86DataOperand *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_X86_DATA_OPERAND, NULL); + + result->reg = g_x86_register_new(MDS_32_BITS/* FIXME size*/, dest ? 0x07 : 0x06); + result->dest = dest; + + return G_ARCH_OPERAND(result); + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à transcrire. * +* options = options de rendu. * +* rendering = support effectif final des lignes de code. * +* stream = flux ouvert en écriture. * +* * +* Description : Ajoute du texte simple à un fichier ouvert en écriture. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_data_operand_add_text(const GX86DataOperand *operand, GRenderingOptions *options, MainRendering rendering, FILE *stream) +{ + GContentExporter *exporter; /* Autre vision de l'opérande */ + + exporter = G_CONTENT_EXPORTER(operand); + + if (operand->dest) + g_content_exporter_insert_text(exporter, stream, "es:", 3, RTT_SEGMENT); + else + g_content_exporter_insert_text(exporter, stream, "ds:", 3, RTT_SEGMENT); + + g_content_exporter_insert_text(exporter, stream, "[", 1, RTT_HOOK); + + g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->reg), options, rendering, stream); + + g_content_exporter_insert_text(exporter, stream, "]", 1, RTT_HOOK); + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à transcrire. * +* buffer = espace où placer ledit contenu. * +* options = options de rendu. * +* * +* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_data_operand_to_buffer(const GX86DataOperand *operand, GBufferLine *buffer, GRenderingOptions *options) +{ + GContentExporter *exporter; /* Autre vision de l'opérande */ + + exporter = G_CONTENT_EXPORTER(operand); + + if (operand->dest) + g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY, + "es:", 3, RTT_SEGMENT); + else + g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY, + "ds:", 3, RTT_SEGMENT); + + g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY, + "[", 1, RTT_HOOK); + + g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->reg), buffer, options); + + g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY, + "]", 1, RTT_HOOK); + +} diff --git a/src/arch/x86/operands/data.h b/src/arch/x86/operands/data.h new file mode 100644 index 0000000..406698e --- /dev/null +++ b/src/arch/x86/operands/data.h @@ -0,0 +1,60 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * data.h - prototypes pour les opérandes de manipulation de données + * + * Copyright (C) 2012 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#ifndef _ARCH_X86_OPERANDS_DATA_H +#define _ARCH_X86_OPERANDS_DATA_H + + +#include + + +#include "../../operand.h" +#include "../../../common/endianness.h" + + + +#define G_TYPE_X86_DATA_OPERAND g_x86_data_operand_get_type() +#define G_X86_DATA_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_x86_data_operand_get_type(), GX86DataOperand)) +#define G_IS_X86_DATA_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_x86_data_operand_get_type())) +#define G_X86_DATA_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_X86_DATA_OPERAND, GX86DataOperandClass)) +#define G_IS_X86_DATA_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_X86_DATA_OPERAND)) +#define G_X86_DATA_OPERAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_X86_DATA_OPERAND, GX86DataOperandClass)) + + + +/* Définition d'un opérande x86 de manipulation de données (instance) */ +typedef struct _GX86DataOperand GX86DataOperand; + +/* Définition d'un opérande x86 de manipulation de données (classe) */ +typedef struct _GX86DataOperandClass GX86DataOperandClass; + + +/* Indique le type défini par la GLib pour un opérande x86 de manipulation de données. */ +GType g_x86_data_operand_get_type(void); + +/* Crée un opérande x86 de manipulation de données. */ +GArchOperand *g_x86_data_operand_new(MemoryDataSize, bool); + + + +#endif /* _ARCH_X86_OPERANDS_DATA_H */ diff --git a/src/arch/x86/operands/modrm.c b/src/arch/x86/operands/modrm.c new file mode 100644 index 0000000..892d5dc --- /dev/null +++ b/src/arch/x86/operands/modrm.c @@ -0,0 +1,436 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * modrm.c - opérandes de type mod/rm + * + * Copyright (C) 2012 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "modrm.h" + + +#include + + +#include "register.h" +#include "../../operand-int.h" + + + +/* Définition d'un opérande x86 de type ModRM (instance) */ +struct _GX86ModRMOperand +{ + GArchOperand parent; /* Instance parente */ + + uint8_t scale; /* Puissance de deux */ + GX86Register *index; /* Registre servant d'indice */ + GX86Register *base; /* Registre de base */ + GImmOperand *displacement; /* Décallage supplémentaire */ + +}; + + +/* Définition d'un opérande x86 de type ModRM (classe) */ +struct _GX86ModRMOperandClass +{ + GArchOperandClass parent; /* Classe parente */ + +}; + + +/* Initialise la classe des opérandes x86 de type ModRM. */ +static void g_x86_mod_rm_operand_class_init(GX86ModRMOperandClass *); + +/* Initialise une instance d'opérande x86 de type ModRM. */ +static void g_x86_mod_rm_operand_init(GX86ModRMOperand *); + +/* Ajoute du texte simple à un fichier ouvert en écriture. */ +static void g_x86_mod_rm_operand_add_text(const GX86ModRMOperand *, GRenderingOptions *, MainRendering, FILE *); + +/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */ +static void g_x86_mod_rm_operand_to_buffer(const GX86ModRMOperand *, GBufferLine *, GRenderingOptions *); + + + +/* Indique le type défini par la GLib pour un opérande x86 de type ModRM. */ +G_DEFINE_TYPE(GX86ModRMOperand, g_x86_mod_rm_operand, G_TYPE_ARCH_OPERAND); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des opérandes x86 de type ModRM. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_mod_rm_operand_class_init(GX86ModRMOperandClass *klass) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : operand = instance à initialiser. * +* * +* Description : Initialise une instance d'opérande x86 de type ModRM. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_mod_rm_operand_init(GX86ModRMOperand *operand) +{ + GContentExporter *parent; /* Instance parente */ + + parent = G_CONTENT_EXPORTER(operand); + + parent->add_text = (add_text_fc)g_x86_mod_rm_operand_add_text; + parent->export_buffer = (export_buffer_fc)g_x86_mod_rm_operand_to_buffer; + +} + + +/****************************************************************************** +* * +* Paramètres : data = flux de données à analyser. * +* pos = position courante dans ce flux. [OUT] * +* len = taille totale des données à analyser. * +* size = taille de l'opérande, et donc du registre. * +* * +* Description : Crée un opérande x86 de type ModRM. * +* * +* Retour : Opérande mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GArchOperand *g_x86_mod_rm_operand_new(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size) +{ + GX86ModRMOperand *result; /* Structure à retourner */ + uint8_t mod; /* Modificateur présent */ + GX86Register *reg; /* Registre lu */ + + mod = (data[*pos] & 0xc0); + + if (mod == 0xc0) + return g_x86_register_operand_new_from_mod_rm(data, pos, len, size, true); + + reg = g_x86_register_new(size, data[*pos] & 0x07); + if (reg == NULL) return NULL; + + (*pos)++; + + /* Vieille astuce de l'emplacement mémoire fixe ? */ + if (g_x86_register_is_base_pointer(reg) && mod == 0x00) + { + /* FIXME *///free_x86_register(reg); + return g_imm_operand_new_from_data(MDS_32_BITS/* FIXME */, data, pos, len, SRE_LITTLE /*FIXME*/); + } + + result = g_object_new(G_TYPE_X86_MOD_RM_OPERAND, NULL); + + /* A la recherche d'un SIB */ + if (g_x86_register_is_stack_pointer(reg)) + { + /* FIXME *///free_x86_register(reg); + + result->base = g_x86_register_new(size, data[*pos] & 0x07); + if (result->base == NULL) goto gxmron_error; + + result->index = g_x86_register_new(size, (data[*pos] & 0x38) >> 3); + if (result->index == NULL) goto gxmron_error; + + result->scale = ((data[*pos] & 0xc0) >> 6); + + if (g_x86_register_is_stack_pointer(result->index)) + { + /* FIXME *///free_x86_register(result->index); + result->index = result->base; + result->base = NULL; + } + + (*pos)++; + + } + + else result->index = reg; + + /* Décallage supplémentaire ? */ + switch (mod) + { + case 0x00: + if (result->base != NULL && g_x86_register_is_base_pointer(result->base)) + { + /* FIXME *///free_x86_register(result->base); + result->base = NULL; + + result->displacement = g_imm_operand_new_from_data(size/* FIXME : !convert mds/aos */, data, pos, len, SRE_LITTLE /* FIXME */); + if (result->displacement == NULL) goto gxmron_error; + + } + break; + + case 0x40: + result->displacement = g_imm_operand_new_from_data(MDS_8_BITS_SIGNED, data, pos, len, SRE_LITTLE /* FIXME */); + if (result->displacement == NULL) goto gxmron_error; + break; + + case 0x80: + result->displacement = g_imm_operand_new_from_data(MDS_32_BITS_SIGNED/* FIXME ! 16/32 */, data, pos, len, SRE_LITTLE /* FIXME */); + if (result->displacement == NULL) goto gxmron_error; + break; + + } + + return G_ARCH_OPERAND(result); + + gxmron_error: + + /* FIXME free(result);*/ + return NULL; + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à transcrire. * +* options = options de rendu. * +* rendering = support effectif final des lignes de code. * +* stream = flux ouvert en écriture. * +* * +* Description : Ajoute du texte simple à un fichier ouvert en écriture. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_mod_rm_operand_add_text(const GX86ModRMOperand *operand, GRenderingOptions *options, MainRendering rendering, FILE *stream) +{ + GContentExporter *exporter; /* Autre vision de l'opérande */ + char tmp[2]; /* Echelle en puissance de 2 */ + + exporter = G_CONTENT_EXPORTER(operand); + + switch (g_rendering_options_get_syntax(options)) + { + case ASX_INTEL: + + g_content_exporter_insert_text(exporter, stream, "[", 1, RTT_HOOK); + + if (operand->scale > 0) + { + snprintf(tmp, 2, "%d", (int)pow(2, operand->scale)); + + g_content_exporter_insert_text(exporter, stream, tmp, 1, RTT_IMMEDIATE); + + g_content_exporter_insert_text(exporter, stream, "*", 1, RTT_SIGNS); + + } + + g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->index), + options, rendering, stream); + + if (operand->base != NULL) + { + g_content_exporter_insert_text(exporter, stream, "+", 1, RTT_SIGNS); + + g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->base), + options, rendering, stream); + + } + + if (operand->displacement != NULL) + { + if (g_imm_operand_is_negative(operand->displacement)) + g_content_exporter_insert_text(exporter, stream, "-", 1, RTT_SIGNS); + else + g_content_exporter_insert_text(exporter, stream, "+", 1, RTT_SIGNS); + + g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->displacement), + options, rendering, stream); + + } + + g_content_exporter_insert_text(exporter, stream, "]", 1, RTT_HOOK); + + break; + + case ASX_ATT: + + /* TODO */ + g_content_exporter_insert_text(exporter, stream, "[ModRM]", 7, RTT_HOOK); + + break; + + } + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à transcrire. * +* buffer = espace où placer ledit contenu. * +* options = options de rendu. * +* * +* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_mod_rm_operand_to_buffer(const GX86ModRMOperand *operand, GBufferLine *buffer, GRenderingOptions *options) +{ + GContentExporter *exporter; /* Autre vision de l'opérande */ + char tmp[2]; /* Echelle en puissance de 2 */ + + exporter = G_CONTENT_EXPORTER(operand); + + switch (g_rendering_options_get_syntax(options)) + { + case ASX_INTEL: + + g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, + "[", 1, RTT_HOOK); + + if (operand->scale > 0) + { + snprintf(tmp, 2, "%d", (int)pow(2, operand->scale)); + + g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, + tmp, 1, RTT_IMMEDIATE); + + g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, + "*", 1, RTT_SIGNS); + + } + + g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->index), buffer, options); + + if (operand->base != NULL) + { + g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, + "+", 1, RTT_SIGNS); + + g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->base), buffer, options); + + } + + if (operand->displacement != NULL) + { + if (g_imm_operand_is_negative(operand->displacement)) + g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, + "-", 1, RTT_SIGNS); + else + g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, + "+", 1, RTT_SIGNS); + + g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->displacement), buffer, options); + + } + + g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, + "]", 1, RTT_HOOK); + + break; + + case ASX_ATT: + + /* TODO */ + g_content_exporter_insert_into_buffer(exporter, buffer, BLC_ASSEMBLY, + "[ModRM]", 7, RTT_HOOK); + + break; + + } + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à consulter. * +* scale = facteur sous forme de puissance de deux. [OUT * +* index = register principal de l'opérande. [OUT] * +* * +* Description : Fournit l'indice et l'échelle d'un opérande x86 ModRM. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_x86_mod_rm_operand_get_scale_and_index(const GX86ModRMOperand *operand, uint8_t *scale, const GX86Register **index) +{ + *scale = operand->scale; + *index = operand->index; + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à consulter. * +* * +* Description : Fournit le registre de base d'un opérande x86 ModRM. * +* * +* Retour : Registre de base de l'opérande. * +* * +* Remarques : - * +* * +******************************************************************************/ + +const GX86Register *g_x86_mod_rm_operand_get_base(const GX86ModRMOperand *operand) +{ + return operand->base; + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à consulter. * +* * +* Description : Fournit le décallage supplémentaire d'un opérande x86 ModRM. * +* * +* Retour : Décallage numérique pour l'opérande. * +* * +* Remarques : - * +* * +******************************************************************************/ + +const GImmOperand *g_x86_mod_rm_operand_get_displacement(const GX86ModRMOperand *operand) +{ + return operand->displacement; + +} diff --git a/src/arch/x86/operands/modrm.h b/src/arch/x86/operands/modrm.h new file mode 100644 index 0000000..89a274f --- /dev/null +++ b/src/arch/x86/operands/modrm.h @@ -0,0 +1,70 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * modrm.h - prototypes pour les opérandes de type mod/rm + * + * Copyright (C) 2012 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#ifndef _ARCH_X86_OPERANDS_MODRM_H +#define _ARCH_X86_OPERANDS_MODRM_H + + +#include + + +#include "../registers.h" +#include "../../immediate.h" +#include "../../operand.h" +#include "../../../common/endianness.h" + + + +#define G_TYPE_X86_MOD_RM_OPERAND g_x86_mod_rm_operand_get_type() +#define G_X86_MOD_RM_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_x86_mod_rm_operand_get_type(), GX86ModRMOperand)) +#define G_IS_X86_MOD_RM_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_x86_mod_rm_operand_get_type())) +#define G_X86_MOD_RM_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_X86_MOD_RM_OPERAND, GX86ModRMOperandClass)) +#define G_IS_X86_MOD_RM_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_X86_MOD_RM_OPERAND)) +#define G_X86_MOD_RM_OPERAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_X86_MOD_RM_OPERAND, GX86ModRMOperandClass)) + + +/* Définition d'un opérande x86 de type ModRM (instance) */ +typedef struct _GX86ModRMOperand GX86ModRMOperand; + +/* Définition d'un opérande x86 de type ModRM (classe) */ +typedef struct _GX86ModRMOperandClass GX86ModRMOperandClass; + + +/* Indique le type défini par la GLib pour un opérande x86 de type ModRM. */ +GType g_x86_mod_rm_operand_get_type(void); + +/* Crée un opérande x86 de type ModRM. */ +GArchOperand *g_x86_mod_rm_operand_new(const bin_t *, off_t *, off_t, MemoryDataSize); + +/* Fournit l'indice et l'échelle d'un opérande x86 ModRM. */ +void g_x86_mod_rm_operand_get_scale_and_index(const GX86ModRMOperand *operand, uint8_t *, const GX86Register **); + +/* Fournit le registre de base d'un opérande x86 ModRM. */ +const GX86Register *g_x86_mod_rm_operand_get_base(const GX86ModRMOperand *); + +/* Fournit le décallage supplémentaire d'un opérande x86 ModRM. */ +const GImmOperand *g_x86_mod_rm_operand_get_displacement(const GX86ModRMOperand *); + + + +#endif /* _ARCH_X86_OPERANDS_MODRM_H */ diff --git a/src/arch/x86/operands/moffs.c b/src/arch/x86/operands/moffs.c new file mode 100644 index 0000000..3754e79 --- /dev/null +++ b/src/arch/x86/operands/moffs.c @@ -0,0 +1,189 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * moffs.c - opérandes d'emplacements mémoire + * + * Copyright (C) 2012 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "moffs.h" + + +#include "../../immediate.h" +#include "../../operand-int.h" + + + +/* Définition d'un opérande visant un emplacement mémoire x86 (instance) */ +struct _GX86MOffsOperand +{ + GArchOperand parent; /* Instance parente */ + + GImmOperand *offset; /* Adresse mémoire visée */ + +}; + +/* Définition d'un opérande visant un emplacement mémoire x86 (classe) */ +struct _GX86MOffsOperandClass +{ + GArchOperandClass parent; /* Classe parente */ + +}; + + +/* Initialise la classe des opérandes d'emplacement mémoire x86. */ +static void g_x86_moffs_operand_class_init(GX86MOffsOperandClass *); + +/* Initialise une instance d'opérande d'emplacement mémoire x86. */ +static void g_x86_moffs_operand_init(GX86MOffsOperand *); + +/* Ajoute du texte simple à un fichier ouvert en écriture. */ +static void g_x86_moffs_operand_add_text(const GX86MOffsOperand *, GRenderingOptions *, MainRendering, FILE *); + +/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */ +static void g_x86_moffs_operand_to_buffer(const GX86MOffsOperand *, GBufferLine *, GRenderingOptions *); + + + +/* Indique le type défini par la GLib pour un opérande d'emplacement mémoire x86. */ +G_DEFINE_TYPE(GX86MOffsOperand, g_x86_moffs_operand, G_TYPE_ARCH_OPERAND); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des opérandes d'emplacement mémoire x86.* +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_moffs_operand_class_init(GX86MOffsOperandClass *klass) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : operand = instance à initialiser. * +* * +* Description : Initialise une instance d'opérande d'emplacement mémoire x86.* +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_moffs_operand_init(GX86MOffsOperand *operand) +{ + GContentExporter *parent; /* Instance parente */ + + parent = G_CONTENT_EXPORTER(operand); + + parent->add_text = (add_text_fc)g_x86_moffs_operand_add_text; + parent->export_buffer = (export_buffer_fc)g_x86_moffs_operand_to_buffer; + +} + + +/****************************************************************************** +* * +* Paramètres : data = flux de données à analyser. * +* pos = position courante dans ce flux. [OUT] * +* len = taille totale des données à analyser. * +* size = taille de l'opérande, et donc du registre. * +* * +* Description : Crée un opérande d'emplacement mémoire x86. * +* * +* Retour : Opérande mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GArchOperand *g_x86_moffs_operand_new(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size) +{ + GX86MOffsOperand *result; /* Structure à retourner */ + GImmOperand *offset; /* Emplacement lu */ + + result = NULL; + + offset = g_imm_operand_new_from_data(size, data, pos, len, SRE_LITTLE /* FIXME */); + + if (offset != NULL) + { + result = g_object_new(G_TYPE_X86_MOFFS_OPERAND, NULL); + result->offset = offset; + } + + return G_ARCH_OPERAND(result); + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à transcrire. * +* options = options de rendu. * +* rendering = support effectif final des lignes de code. * +* stream = flux ouvert en écriture. * +* * +* Description : Ajoute du texte simple à un fichier ouvert en écriture. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_moffs_operand_add_text(const GX86MOffsOperand *operand, GRenderingOptions *options, MainRendering rendering, FILE *stream) +{ + g_content_exporter_insert_text(G_CONTENT_EXPORTER(operand), stream, "ds:", 3, RTT_SEGMENT); + + g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->offset), options, rendering, stream); + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à transcrire. * +* buffer = espace où placer ledit contenu. * +* options = options de rendu. * +* * +* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_moffs_operand_to_buffer(const GX86MOffsOperand *operand, GBufferLine *buffer, GRenderingOptions *options) +{ + g_content_exporter_insert_into_buffer(G_CONTENT_EXPORTER(operand), buffer, BLC_ASSEMBLY, + "ds:", 3, RTT_SEGMENT); + + g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->offset), buffer, options); + +} diff --git a/src/arch/x86/operands/moffs.h b/src/arch/x86/operands/moffs.h new file mode 100644 index 0000000..b4f8889 --- /dev/null +++ b/src/arch/x86/operands/moffs.h @@ -0,0 +1,59 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * moffs.h - prototypes pour les opérandes d'emplacements mémoire + * + * Copyright (C) 2012 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#ifndef _ARCH_X86_OPERANDS_MOFFS_H +#define _ARCH_X86_OPERANDS_MOFFS_H + + +#include + + +#include "../../operand.h" +#include "../../../common/endianness.h" + + + +#define G_TYPE_X86_MOFFS_OPERAND g_x86_moffs_operand_get_type() +#define G_X86_MOFFS_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_x86_moffs_operand_get_type(), GX86MoffsOperand)) +#define G_IS_X86_MOFFS_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_x86_moffs_operand_get_type())) +#define G_X86_MOFFS_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_X86_MOFFS_OPERAND, GX86MoffsOperandClass)) +#define G_IS_X86_MOFFS_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_X86_MOFFS_OPERAND)) +#define G_X86_MOFFS_OPERAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_X86_MOFFS_OPERAND, GX86MoffsOperandClass)) + + +/* Définition d'un opérande visant un emplacement mémoire x86 (instance) */ +typedef struct _GX86MOffsOperand GX86MOffsOperand; + +/* Définition d'un opérande visant un emplacement mémoire x86 (classe) */ +typedef struct _GX86MOffsOperandClass GX86MOffsOperandClass; + + +/* Indique le type défini par la GLib pour un opérande d'emplacement mémoire x86. */ +GType g_x86_moffs_operand_get_type(void); + +/* Crée un opérande d'emplacement mémoire x86. */ +GArchOperand *g_x86_moffs_operand_new(const bin_t *, off_t *, off_t, MemoryDataSize); + + + +#endif /* _ARCH_X86_OPERANDS_MOFFS_H */ diff --git a/src/arch/x86/operands/register.c b/src/arch/x86/operands/register.c new file mode 100644 index 0000000..a70ea60 --- /dev/null +++ b/src/arch/x86/operands/register.c @@ -0,0 +1,265 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * register.c - opérandes visant un registre x86 + * + * Copyright (C) 2012 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "register.h" + + +#include "../../operand-int.h" + + + +/* Définition d'un opérande visant un registre x86 (instance) */ +struct _GX86RegisterOperand +{ + GArchOperand parent; /* Instance parente */ + + GX86Register *reg; /* Registre représenté */ + +}; + + +/* Définition d'un opérande visant un registre x86 (classe) */ +struct _GX86RegisterOperandClass +{ + GArchOperandClass parent; /* Classe parente */ + +}; + + +/* Initialise la classe des opérandes de registre x86. */ +static void g_x86_register_operand_class_init(GX86RegisterOperandClass *); + +/* Initialise une instance d'opérande de registre x86. */ +static void g_x86_register_operand_init(GX86RegisterOperand *); + +/* Ajoute du texte simple à un fichier ouvert en écriture. */ +static void g_x86_register_operand_add_text(const GX86RegisterOperand *, GRenderingOptions *, MainRendering, FILE *); + +/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */ +static void g_x86_register_operand_to_buffer(const GX86RegisterOperand *, GBufferLine *, GRenderingOptions *); + + + +/* Indique le type défini par la GLib pour un opérande de registre x86. */ +G_DEFINE_TYPE(GX86RegisterOperand, g_x86_register_operand, G_TYPE_ARCH_OPERAND); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des opérandes de registre x86. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_register_operand_class_init(GX86RegisterOperandClass *klass) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : operand = instance à initialiser. * +* * +* Description : Initialise une instance d'opérande de registre x86. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_register_operand_init(GX86RegisterOperand *operand) +{ + GContentExporter *parent; /* Instance parente */ + + parent = G_CONTENT_EXPORTER(operand); + + parent->add_text = (add_text_fc)g_x86_register_operand_add_text; + parent->export_buffer = (export_buffer_fc)g_x86_register_operand_to_buffer; + +} + + +/****************************************************************************** +* * +* Paramètres : data = flux de données à analyser. * +* pos = position courante dans ce flux. [OUT] * +* len = taille totale des données à analyser. * +* size = taille de l'opérande, et donc du registre. * +* base = indice du premier registre. * +* * +* Description : Crée un opérande visant un registre x86. * +* * +* Retour : Opérande mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GArchOperand *g_x86_register_operand_new_from_opcode(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size, bin_t base) +{ + GX86RegisterOperand *result; /* Structure à retourner */ + GX86Register *reg; /* Registre lu */ + + reg = g_x86_register_new(size, data[*pos] - base); + + if (reg != NULL) + { + (*pos)++; + + result = g_object_new(G_TYPE_X86_REGISTER_OPERAND, NULL); + + result->reg = reg; + + } + else result = NULL; + + return G_ARCH_OPERAND(result); + +} + + +/****************************************************************************** +* * +* Paramètres : data = flux de données à analyser. * +* pos = position courante dans ce flux. [OUT] * +* len = taille totale des données à analyser. * +* size = taille de l'opérande, et donc du registre. * +* first = indique la partie du ModR/M à traiter. * +* * +* Description : Crée un opérande visant un registre x86. * +* * +* Retour : Opérande mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GArchOperand *g_x86_register_operand_new_from_mod_rm(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size, bool first) +{ + GX86RegisterOperand *result; /* Structure à retourner */ + bin_t index; /* Registre lu */ + GX86Register *reg; /* Registre créé */ + + if (first) index = data[*pos] & 0x07; + else index = (data[*pos] & 0x38) >> 3; + + reg = g_x86_register_new(size, index); + + if (reg != NULL) + { + (*pos)++; + + result = g_object_new(G_TYPE_X86_REGISTER_OPERAND, NULL); + + result->reg = reg; + + } + else result = NULL; + + return G_ARCH_OPERAND(result); + +} + + +/****************************************************************************** +* * +* Paramètres : index = indice du registre visé. * +* size = taille de l'opérande, et donc du registre. * +* * +* Description : Crée un opérande visant un registre x86 donné. * +* * +* Retour : Opérande mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GArchOperand *g_x86_register_operand_new_from_index(bin_t index, MemoryDataSize size) +{ + GX86RegisterOperand *result; /* Structure à retourner */ + GX86Register *reg; /* Registre lu */ + + reg = g_x86_register_new(size, index); + + if (reg != NULL) + { + result = g_object_new(G_TYPE_X86_REGISTER_OPERAND, NULL); + + result->reg = reg; + + } + else result = NULL; + + return G_ARCH_OPERAND(result); + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à transcrire. * +* options = options de rendu. * +* rendering = support effectif final des lignes de code. * +* stream = flux ouvert en écriture. * +* * +* Description : Ajoute du texte simple à un fichier ouvert en écriture. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_register_operand_add_text(const GX86RegisterOperand *operand, GRenderingOptions *options, MainRendering rendering, FILE *stream) +{ + g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->reg), options, rendering, stream); + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à transcrire. * +* buffer = espace où placer ledit contenu. * +* options = options de rendu. * +* * +* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_register_operand_to_buffer(const GX86RegisterOperand *operand, GBufferLine *buffer, GRenderingOptions *options) +{ + g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->reg), buffer, options); + +} diff --git a/src/arch/x86/operands/register.h b/src/arch/x86/operands/register.h new file mode 100644 index 0000000..11bc87e --- /dev/null +++ b/src/arch/x86/operands/register.h @@ -0,0 +1,66 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * register.h - prototypes pour les opérandes visant un registre x86 + * + * Copyright (C) 2012 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#ifndef _ARCH_X86_OPERANDS_REGISTER_H +#define _ARCH_X86_OPERANDS_REGISTER_H + + +#include + + +#include "../registers.h" +#include "../../operand.h" +#include "../../../common/endianness.h" + + + +#define G_TYPE_X86_REGISTER_OPERAND g_x86_register_operand_get_type() +#define G_X86_REGISTER_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_x86_register_operand_get_type(), GX86RegisterOperand)) +#define G_IS_X86_REGISTER_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_x86_register_operand_get_type())) +#define G_X86_REGISTER_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_X86_REGISTER_OPERAND, GX86RegisterOperandClass)) +#define G_IS_X86_REGISTER_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_X86_REGISTER_OPERAND)) +#define G_X86_REGISTER_OPERAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_X86_REGISTER_OPERAND, GX86RegisterOperandClass)) + + +/* Définition d'un opérande visant un registre x86 (instance) */ +typedef struct _GX86RegisterOperand GX86RegisterOperand; + +/* Définition d'un opérande visant un registre x86 (classe) */ +typedef struct _GX86RegisterOperandClass GX86RegisterOperandClass; + + +/* Indique le type défini par la GLib pour un opérande de registre x86. */ +GType g_x86_register_operand_get_type(void); + +/* Crée un opérande visant un registre x86. */ +GArchOperand *g_x86_register_operand_new_from_opcode(const bin_t *, off_t *, off_t, MemoryDataSize, bin_t); + +/* Crée un opérande visant un registre x86. */ +GArchOperand *g_x86_register_operand_new_from_mod_rm(const bin_t *, off_t *, off_t, MemoryDataSize, bool); + +/* Crée un opérande visant un registre x86 donné. */ +GArchOperand *g_x86_register_operand_new_from_index(bin_t, MemoryDataSize); + + + +#endif /* _ARCH_X86_OPERANDS_REGISTER_H */ diff --git a/src/arch/x86/operands/relative.c b/src/arch/x86/operands/relative.c new file mode 100644 index 0000000..3235a0d --- /dev/null +++ b/src/arch/x86/operands/relative.c @@ -0,0 +1,221 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * relative.c - opérandes d'adresses relatives + * + * Copyright (C) 2012 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#include "relative.h" + + +#include "../../operand-int.h" + + + +/* Définition d'un opérande x86 d'adresse relative (instance) */ +struct _GX86RelativeOperand +{ + GArchOperand parent; /* Instance parente */ + + GImmOperand *immediate; /* Adresse visée reconstituée */ + +}; + +/* Définition d'un opérande x86 d'adresse relative (classe) */ +struct _GX86RelativeOperandClass +{ + GArchOperandClass parent; /* Classe parente */ + +}; + + +/* Initialise la classe des opérandes x86 d'adresse relative. */ +static void g_x86_relative_operand_class_init(GX86RelativeOperandClass *); + +/* Initialise une instance d'opérande x86 d'adresse relative. */ +static void g_x86_relative_operand_init(GX86RelativeOperand *); + +/* Ajoute du texte simple à un fichier ouvert en écriture. */ +static void g_x86_relative_operand_add_text(const GX86RelativeOperand *, GRenderingOptions *, MainRendering, FILE *); + +/* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */ +static void g_x86_relative_operand_to_buffer(const GX86RelativeOperand *, GBufferLine *, GRenderingOptions *); + + + +/* Indique le type défini par la GLib pour un opérande x86 d'adresse relative. */ +G_DEFINE_TYPE(GX86RelativeOperand, g_x86_relative_operand, G_TYPE_ARCH_OPERAND); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des opérandes x86 d'adresse relative. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_relative_operand_class_init(GX86RelativeOperandClass *klass) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : operand = instance à initialiser. * +* * +* Description : Initialise une instance d'opérande x86 d'adresse relative. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_relative_operand_init(GX86RelativeOperand *operand) +{ + GContentExporter *parent; /* Instance parente */ + + parent = G_CONTENT_EXPORTER(operand); + + parent->add_text = (add_text_fc)g_x86_relative_operand_add_text; + parent->export_buffer = (export_buffer_fc)g_x86_relative_operand_to_buffer; + +} + + +/****************************************************************************** +* * +* Paramètres : data = flux de données à analyser. * +* pos = position courante dans ce flux. [OUT] * +* len = taille totale des données à analyser. * +* size = taille de l'opérande, et donc du registre. * +* base = adresse de référence pour le calcul. * +* * +* Description : Crée un opérande X86 d'adresse relative. * +* * +* Retour : Opérande mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GArchOperand *g_x86_relative_operand_new(const bin_t *data, off_t *pos, off_t len, MemoryDataSize size, vmpa_t base) +{ + GX86RelativeOperand *result; /* Structure à retourner */ + off_t init_pos; /* Position avant lecture */ + int8_t val8; /* Valeur sur 8 bits */ + int16_t val16; /* Valeur sur 16 bits */ + int32_t val32; /* Valeur sur 32 bits */ + vmpa_t address; /* Adresse finale visée */ + + init_pos = *pos; + + switch (size) + { + case MDS_8_BITS_UNSIGNED: + read_s8(&val8, data, pos, len, SRE_LITTLE /* FIXME */); + address = base + (*pos - init_pos) + val8; + break; + case MDS_16_BITS_UNSIGNED: + read_s16(&val16, data, pos, len, SRE_LITTLE /* FIXME */); + address = base + (*pos - init_pos) + val16; + break; + case MDS_32_BITS_UNSIGNED: + read_s32(&val32, data, pos, len, SRE_LITTLE /* FIXME */); + address = base + (*pos - init_pos) + val32; + break; + default: + return NULL; + break; + } + + result = g_object_new(G_TYPE_X86_RELATIVE_OPERAND, NULL); + result->immediate = g_imm_operand_new_from_value(MDS_32_BITS/*FIXME*/, (uint32_t)address/* FIXME */); + + return G_ARCH_OPERAND(result); + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à transcrire. * +* options = options de rendu. * +* rendering = support effectif final des lignes de code. * +* stream = flux ouvert en écriture. * +* * +* Description : Ajoute du texte simple à un fichier ouvert en écriture. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_relative_operand_add_text(const GX86RelativeOperand *operand, GRenderingOptions *options, MainRendering rendering, FILE *stream) +{ + g_content_exporter_add_text(G_CONTENT_EXPORTER(operand->immediate), options, rendering, stream); + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à transcrire. * +* buffer = espace où placer ledit contenu. * +* options = options de rendu. * +* * +* Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_x86_relative_operand_to_buffer(const GX86RelativeOperand *operand, GBufferLine *buffer, GRenderingOptions *options) +{ + g_content_exporter_to_buffer(G_CONTENT_EXPORTER(operand->immediate), buffer, options); + +} + + +/****************************************************************************** +* * +* Paramètres : operand = opérande à traiter. * +* * +* Description : Fournit l'adresse représentée par une opérande X86. * +* * +* Retour : Valeur portée par l'opérande. * +* * +* Remarques : - * +* * +******************************************************************************/ + +const GImmOperand *g_x86_relative_operand_get_value(const GX86RelativeOperand *operand) +{ + return operand->immediate; + +} diff --git a/src/arch/x86/operands/relative.h b/src/arch/x86/operands/relative.h new file mode 100644 index 0000000..083444a --- /dev/null +++ b/src/arch/x86/operands/relative.h @@ -0,0 +1,63 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * relative.h - prototypes pour les opérandes d'adresses relatives + * + * Copyright (C) 2012 Cyrille Bagard + * + * This file is part of OpenIDA. + * + * OpenIDA is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * OpenIDA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see . + */ + + +#ifndef _ARCH_X86_OPERANDS_RELATIVE_H +#define _ARCH_X86_OPERANDS_RELATIVE_H + + +#include + + +#include "../../immediate.h" +#include "../../operand.h" +#include "../../../common/endianness.h" + + + +#define G_TYPE_X86_RELATIVE_OPERAND g_x86_relative_operand_get_type() +#define G_X86_RELATIVE_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_x86_relative_operand_get_type(), GX86RelativeOperand)) +#define G_IS_X86_RELATIVE_OPERAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_x86_relative_operand_get_type())) +#define G_X86_RELATIVE_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_X86_RELATIVE_OPERAND, GX86RelativeOperandClass)) +#define G_IS_X86_RELATIVE_OPERAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_X86_RELATIVE_OPERAND)) +#define G_X86_RELATIVE_OPERAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_X86_RELATIVE_OPERAND, GX86RelativeOperandClass)) + + +/* Définition d'un opérande x86 d'adresse relative (instance) */ +typedef struct _GX86RelativeOperand GX86RelativeOperand; + +/* Définition d'un opérande x86 d'adresse relative (classe) */ +typedef struct _GX86RelativeOperandClass GX86RelativeOperandClass; + + +/* Indique le type défini par la GLib pour un opérande x86 d'adresse relative. */ +GType g_x86_relative_operand_get_type(void); + +/* Crée un opérande X86 d'adresse relative. */ +GArchOperand *g_x86_relative_operand_new(const bin_t *, off_t *, off_t, MemoryDataSize, vmpa_t); + +/* Fournit l'adresse représentée par une opérande X86. */ +const GImmOperand *g_x86_relative_operand_get_value(const GX86RelativeOperand *); + + + +#endif /* _ARCH_X86_OPERANDS_RELATIVE_H */ diff --git a/src/arch/x86/processor.c b/src/arch/x86/processor.c index 672f4e1..e5056f9 100644 --- a/src/arch/x86/processor.c +++ b/src/arch/x86/processor.c @@ -24,8 +24,8 @@ #include "processor.h" +#include "opcodes/opcodes.h" #include "../processor-int.h" -#include "opcodes.h" -- cgit v0.11.2-87-g4458