summaryrefslogtreecommitdiff
path: root/src/arch/x86
diff options
context:
space:
mode:
Diffstat (limited to 'src/arch/x86')
-rw-r--r--src/arch/x86/Makefile.am11
-rw-r--r--src/arch/x86/instruction.h349
-rw-r--r--src/arch/x86/op_adc.c98
-rw-r--r--src/arch/x86/op_add.c211
-rw-r--r--src/arch/x86/op_and.c90
-rw-r--r--src/arch/x86/op_call.c50
-rw-r--r--src/arch/x86/op_cld.c11
-rw-r--r--src/arch/x86/op_cmp.c88
-rw-r--r--src/arch/x86/op_dec.c16
-rw-r--r--src/arch/x86/op_hlt.c11
-rw-r--r--src/arch/x86/op_inc.c16
-rw-r--r--src/arch/x86/op_int.c42
-rw-r--r--src/arch/x86/op_jump.c543
-rw-r--r--src/arch/x86/op_lea.c41
-rw-r--r--src/arch/x86/op_leave.c11
-rw-r--r--src/arch/x86/op_mov.c279
-rw-r--r--src/arch/x86/op_movsx.c4
-rw-r--r--src/arch/x86/op_movzx.c4
-rw-r--r--src/arch/x86/op_nop.c14
-rw-r--r--src/arch/x86/op_not.c22
-rw-r--r--src/arch/x86/op_or.c107
-rw-r--r--src/arch/x86/op_pop.c23
-rw-r--r--src/arch/x86/op_push.c60
-rw-r--r--src/arch/x86/op_rcl.c24
-rw-r--r--src/arch/x86/op_rcr.c24
-rw-r--r--src/arch/x86/op_ret.c11
-rw-r--r--src/arch/x86/op_rol.c24
-rw-r--r--src/arch/x86/op_ror.c24
-rw-r--r--src/arch/x86/op_sar.c24
-rw-r--r--src/arch/x86/op_sbb.c77
-rw-r--r--src/arch/x86/op_shl.c48
-rw-r--r--src/arch/x86/op_shr.c24
-rw-r--r--src/arch/x86/op_sub.c171
-rw-r--r--src/arch/x86/op_test.c44
-rw-r--r--src/arch/x86/op_xchg.c69
-rw-r--r--src/arch/x86/op_xor.c207
-rw-r--r--src/arch/x86/opcodes.h294
-rw-r--r--src/arch/x86/operand.c1458
-rw-r--r--src/arch/x86/operand.h127
-rw-r--r--src/arch/x86/processor.c963
-rw-r--r--src/arch/x86/processor.h26
41 files changed, 2952 insertions, 2788 deletions
diff --git a/src/arch/x86/Makefile.am b/src/arch/x86/Makefile.am
index 8f49e54..063a7ce 100644
--- a/src/arch/x86/Makefile.am
+++ b/src/arch/x86/Makefile.am
@@ -2,7 +2,7 @@
noinst_LTLIBRARIES = libarchx86.la
libarchx86_la_SOURCES = \
- instruction.h \
+ instruction.h instruction.c \
op_adc.c \
op_add.c \
op_and.c \
@@ -17,8 +17,6 @@ libarchx86_la_SOURCES = \
op_lea.c \
op_leave.c \
op_mov.c \
- op_movsx.c \
- op_movzx.c \
op_nop.c \
op_not.c \
op_or.c \
@@ -35,10 +33,15 @@ libarchx86_la_SOURCES = \
op_shr.c \
op_sub.c \
op_test.c \
+ op_xchg.c \
op_xor.c \
opcodes.h \
operand.h operand.c \
- processor.h processor.c
+ processor.h processor.c \
+ registers.h registers.c
+
+# op_movsx.c
+# op_movzx.c
libarchx86_la_CFLAGS = $(AM_CFLAGS)
diff --git a/src/arch/x86/instruction.h b/src/arch/x86/instruction.h
index cbdbe2d..1a65066 100644
--- a/src/arch/x86/instruction.h
+++ b/src/arch/x86/instruction.h
@@ -26,223 +26,250 @@
#include "../instruction.h"
-#include "../instruction-int.h"
-
-
-
-/* Définition d'une instruction x86 */
-typedef struct _asm_x86_instr asm_x86_instr;
/* Enumération de tous les opcodes */
typedef enum _X86Opcodes
{
- X86_OP_ADD_RM8_R8, /* add (0x00) */
- X86_OP_ADD_RM1632_R1632, /* add ([0x66] 0x01) */
- X86_OP_ADD_R8_RM8, /* add (0x02) */
- X86_OP_ADD_R1632_RM1632, /* add ([0x66] 0x03) */
- X86_OP_ADD_AL_IMM8, /* add (0x04) */
- X86_OP_ADD_E_AX_IMM1632, /* sub ([0x66] 0x05) */
-
- X86_OP_ADC_RM8_R8, /* adc (0x10) */
-
- X86_OP_OR_R8_RM8, /* or (0x0a) */
-
- X86_OP_OR_AL_IMM8, /* or (0x0c) */
-
- X86_OP_AND_RM8_R8, /* and (0x00) */
-
- X86_OP_SUB_R1632_RM1632, /* sub ([0x66] 0x29) */
-
- X86_OP_SUB_R8_RM8, /* add (0x2a) */
- X86_OP_SUB_AL_IMM8, /* sub (0x2c) */
- X86_OP_SUB_E_AX_IMM1632, /* sub ([0x66] 0x2d) */
-
- X86_OP_XOR_RM8_R8, /* xor (0x30) */
- X86_OP_XOR_RM1632_R1632, /* xor ([0x66] 0x31) */
- X86_OP_XOR_R8_RM8, /* xor (0x32) */
- X86_OP_XOR_R1632_RM1632, /* xor ([0x66] 0x33) */
- X86_OP_XOR_AL_IMM8, /* xor (0x34) */
- X86_OP_XOR_E_AX_IMM1632, /* xor ([0x66] 0x35) */
-
- X86_OP_CMP_RM1632_R1632, /* cmp ([0x66] 0x39) */
-
- X86_OP_INC_E_AX, /* inc ([0x66] 0x40) */
- X86_OP_INC_E_CX, /* inc ([0x66] 0x41) */
- X86_OP_INC_E_DX, /* inc ([0x66] 0x42) */
- X86_OP_INC_E_BX, /* inc ([0x66] 0x43) */
- X86_OP_INC_E_SP, /* inc ([0x66] 0x44) */
- X86_OP_INC_E_BP, /* inc ([0x66] 0x45) */
- X86_OP_INC_E_SI, /* inc ([0x66] 0x46) */
- X86_OP_INC_E_DI, /* inc ([0x66] 0x47) */
-
- X86_OP_DEC_E_AX, /* dec ([0x66] 0x48) */
- X86_OP_DEC_E_CX, /* dec ([0x66] 0x49) */
- X86_OP_DEC_E_DX, /* dec ([0x66] 0x4a) */
- X86_OP_DEC_E_BX, /* dec ([0x66] 0x4b) */
- X86_OP_DEC_E_SP, /* dec ([0x66] 0x4c) */
- X86_OP_DEC_E_BP, /* dec ([0x66] 0x4d) */
- X86_OP_DEC_E_SI, /* dec ([0x66] 0x4e) */
- X86_OP_DEC_E_DI, /* dec ([0x66] 0x4f) */
-
- X86_OP_PUSH_E_AX, /* push ([0x66] 0x50) */
- X86_OP_PUSH_E_CX, /* push ([0x66] 0x51) */
- X86_OP_PUSH_E_DX, /* push ([0x66] 0x52) */
- X86_OP_PUSH_E_BX, /* push ([0x66] 0x53) */
- X86_OP_PUSH_E_SP, /* push ([0x66] 0x54) */
- X86_OP_PUSH_E_BP, /* push ([0x66] 0x55) */
- X86_OP_PUSH_E_SI, /* push ([0x66] 0x56) */
- X86_OP_PUSH_E_DI, /* push ([0x66] 0x57) */
-
- X86_OP_POP_E_AX, /* pop ([0x66] 0x58) */
- X86_OP_POP_E_CX, /* pop ([0x66] 0x59) */
- X86_OP_POP_E_DX, /* pop ([0x66] 0x5a) */
- X86_OP_POP_E_BX, /* pop ([0x66] 0x5b) */
- X86_OP_POP_E_SP, /* pop ([0x66] 0x5c) */
- X86_OP_POP_E_BP, /* pop ([0x66] 0x5d) */
- X86_OP_POP_E_SI, /* pop ([0x66] 0x5e) */
- X86_OP_POP_E_DI, /* pop ([0x66] 0x5f) */
+ XOP_ADD_RM8_R8, /* add (0x00) */
+ XOP_ADD_RM1632_R1632, /* add ([0x66] 0x01) */
+ XOP_ADD_R8_RM8, /* add (0x02) */
+ XOP_ADD_R1632_RM1632, /* add ([0x66] 0x03) */
+ XOP_ADD_AL_IMM8, /* add (0x04) */
+ XOP_ADD_E_AX_IMM1632, /* sub ([0x66] 0x05) */
+
+ XOP_OR_R8_RM8, /* or (0x0a) */
+ XOP_OR_AL_IMM8, /* or (0x0c) */
+
+ XOP_ADC_RM8_R8, /* adc (0x10) */
+
+ XOP_AND_RM8_R8, /* and (0x20) */
+
+ XOP_SUB_RM1632_R1632, /* sub ([0x66] 0x29) */
+
+ XOP_SUB_R8_RM8, /* sub (0x2a) */
+ XOP_SUB_AL_IMM8, /* sub (0x2c) */
+
+ XOP_SUB_E_AX_IMM1632, /* sub ([0x66] 0x2d) */
+
+
+ XOP_XOR_RM8_R8, /* xor (0x30) */
+ XOP_XOR_RM1632_R1632, /* xor ([0x66] 0x31) */
+ XOP_XOR_R8_RM8, /* xor (0x32) */
+ XOP_XOR_R1632_RM1632, /* xor ([0x66] 0x33) */
+ XOP_XOR_AL_IMM8, /* xor (0x34) */
+ XOP_XOR_E_AX_IMM1632, /* xor ([0x66] 0x35) */
+
+
+ XOP_CMP_RM1632_R1632, /* cmp ([0x66] 0x39) */
+ XOP_INC_E_AX, /* inc ([0x66] 0x40) */
+ XOP_INC_E_CX, /* inc ([0x66] 0x41) */
+ XOP_INC_E_DX, /* inc ([0x66] 0x42) */
+ XOP_INC_E_BX, /* inc ([0x66] 0x43) */
+ XOP_INC_E_SP, /* inc ([0x66] 0x44) */
+ XOP_INC_E_BP, /* inc ([0x66] 0x45) */
+ XOP_INC_E_SI, /* inc ([0x66] 0x46) */
+ XOP_INC_E_DI, /* inc ([0x66] 0x47) */
+ XOP_DEC_E_AX, /* dec ([0x66] 0x48) */
+ XOP_DEC_E_CX, /* dec ([0x66] 0x49) */
+ XOP_DEC_E_DX, /* dec ([0x66] 0x4a) */
+ XOP_DEC_E_BX, /* dec ([0x66] 0x4b) */
+ XOP_DEC_E_SP, /* dec ([0x66] 0x4c) */
+ XOP_DEC_E_BP, /* dec ([0x66] 0x4d) */
+ XOP_DEC_E_SI, /* dec ([0x66] 0x4e) */
+ XOP_DEC_E_DI, /* dec ([0x66] 0x4f) */
+ XOP_PUSH_E_AX, /* push ([0x66] 0x50) */
+ XOP_PUSH_E_CX, /* push ([0x66] 0x51) */
+ XOP_PUSH_E_DX, /* push ([0x66] 0x52) */
+ XOP_PUSH_E_BX, /* push ([0x66] 0x53) */
+ XOP_PUSH_E_SP, /* push ([0x66] 0x54) */
+ XOP_PUSH_E_BP, /* push ([0x66] 0x55) */
+ XOP_PUSH_E_SI, /* push ([0x66] 0x56) */
+ XOP_PUSH_E_DI, /* push ([0x66] 0x57) */
+ XOP_POP_E_AX, /* pop ([0x66] 0x58) */
+ XOP_POP_E_CX, /* pop ([0x66] 0x59) */
+ XOP_POP_E_DX, /* pop ([0x66] 0x5a) */
+ XOP_POP_E_BX, /* pop ([0x66] 0x5b) */
+ XOP_POP_E_SP, /* pop ([0x66] 0x5c) */
+ XOP_POP_E_BP, /* pop ([0x66] 0x5d) */
+ XOP_POP_E_SI, /* pop ([0x66] 0x5e) */
+ XOP_POP_E_DI, /* pop ([0x66] 0x5f) */
+
+
+ XOP_PUSH_IMM1632, /* push ([0x66] 0x68) */
+
+
+ XOP_JO_REL8, /* jo (0x70) */
+ XOP_JNO_REL8, /* jno (0x71) */
+ XOP_JB_REL8, /* jb (0x72) */
+ XOP_JNB_REL8, /* jnb (0x73) */
+ XOP_JE_REL8, /* je (0x74) */
+ XOP_JNE_REL8, /* jne (0x75) */
+ XOP_JNA_REL8, /* jna (0x76) */
+ XOP_JA_REL8, /* ja (0x77) */
+ XOP_JS_REL8, /* js (0x78) */
+ XOP_JNS_REL8, /* jns (0x79) */
+ XOP_JP_REL8, /* jp (0x7a) */
+ XOP_JNP_REL8, /* jnp (0x7b) */
+ XOP_JL_REL8, /* jl (0x7c) */
+ XOP_JNL_REL8, /* jnl (0x7d) */
+ XOP_JNG_REL8, /* jng (0x7e) */
+ XOP_JG_REL8, /* jg (0x7f) */
+ XOP_ADD_RM8_IMM8, /* add (0x80 0) */
+ XOP_OR_RM8_IMM8, /* or (0x80 1) */
+ XOP_ADC_RM8_IMM8, /* adc (0x80 2) */
+ XOP_SBB_RM8_IMM8, /* sbb (0x80 3) */
+ XOP_AND_RM8_IMM8, /* and (0x80 4) */
+ XOP_SUB_RM8_IMM8, /* sub (0x80 5) */
+ XOP_XOR_RM8_IMM8, /* xor (0x80 6) */
+ XOP_CMP_RM8_IMM8, /* cmp (0x80 7) */
+ XOP_ADD_RM1632_IMM1632, /* add ([0x66] 0x81 0) */
+ XOP_OR_RM1632_IMM1632, /* or ([0x66] 0x81 1) */
+ XOP_ADC_RM1632_IMM1632, /* adc ([0x66] 0x81 2) */
+ XOP_SBB_RM1632_IMM1632, /* sbb ([0x66] 0x81 3) */
+ XOP_AND_RM1632_IMM1632, /* and ([0x66] 0x81 4) */
+ XOP_SUB_RM1632_IMM1632, /* sub ([0x66] 0x81 5) */
+ XOP_XOR_RM1632_IMM1632, /* xor ([0x66] 0x81 6) */
+ XOP_CMP_RM1632_IMM1632, /* xor ([0x66] 0x81 7) */
- X86_OP_PUSH_IMM1632, /* push ([0x66] 0x68) */
- X86_OP_JB_REL8, /* jb (0x72) */
- X86_OP_JNB_REL8, /* jnb (0x73) */
+ XOP_ADD_RM1632_IMM8, /* add ([0x66] 0x83 0) */
+ XOP_OR_RM1632_IMM8, /* or ([0x66] 0x83 1) */
+ XOP_ADC_RM1632_IMM8, /* adc ([0x66] 0x83 2) */
+ XOP_SBB_RM1632_IMM8, /* sbb ([0x66] 0x83 3) */
+ XOP_AND_RM1632_IMM8, /* and ([0x66] 0x83 4) */
+ XOP_SUB_RM1632_IMM8, /* sub ([0x66] 0x83 5) */
+ XOP_XOR_RM1632_IMM8, /* xor ([0x66] 0x83 6) */
+ XOP_CMP_RM1632_IMM8, /* cmp ([0x66] 0x83 7) */
- X86_OP_JE_8, /* je (0x74) */
- X86_OP_JNE_8, /* jne (0x75) */
- X86_OP_JG_REL8, /* jg (0x7f) */
- X86_OP_XOR_RM8_IMM8, /* xor (0x80 6) */
- X86_OP_CMP_RM8_IMM8, /* cmp (0x80 7) */
+ XOP_TEST_RM8_R8, /* test (0x84) */
+ XOP_TEST_RM1632_R1632, /* test ([0x66] 0x85) */
- X86_OP_ADD_RM1632_IMM1632, /* add ([0x66] 0x81 0) */
- X86_OP_OR_RM1632_IMM1632, /* or ([0x66] 0x81 1) */
- X86_OP_ADC_RM1632_IMM1632, /* adc ([0x66] 0x81 2) */
- X86_OP_SBB_RM1632_IMM1632, /* sbb ([0x66] 0x81 3) */
- X86_OP_AND_RM1632_IMM1632, /* and ([0x66] 0x81 4) */
- X86_OP_SUB_RM1632_IMM1632, /* sub ([0x66] 0x81 5) */
- X86_OP_XOR_RM1632_IMM1632, /* xor ([0x66] 0x81 6) */
- X86_OP_CMP_RM1632_IMM1632, /* xor ([0x66] 0x81 7) */
- X86_OP_ADD_RM1632_IMM8, /* add ([0x66] 0x83 0) */
- X86_OP_OR_RM1632_IMM8, /* or ([0x66] 0x83 1) */
- X86_OP_ADC_RM1632_IMM8, /* adc ([0x66] 0x83 2) */
- X86_OP_SBB_RM1632_IMM8, /* sbb ([0x66] 0x83 3) */
- X86_OP_AND_RM1632_IMM8, /* and ([0x66] 0x83 4) */
- X86_OP_SUB_RM1632_IMM8, /* sub ([0x66] 0x83 5) */
- X86_OP_XOR_RM1632_IMM8, /* xor ([0x66] 0x83 6) */
- X86_OP_CMP_RM1632_IMM8, /* cmp ([0x66] 0x08 7) */
- X86_OP_TEST_RM8_R8, /* test ([0x66] 0x84) */
- X86_OP_TEST_RM1632_R1632, /* test ([0x66] 0x85) */
+ XOP_MOV_RM8_R8, /* mov (0x88) */
+ XOP_MOV_RM1632_R1632, /* mov ([0x66] 0x89) */
- X86_OP_MOV_RM8_R8, /* mov (0x88) */
- X86_OP_MOV_RM1632_R1632, /* mov ([0x66] 0x89) */
+ XOP_MOV_R1632_RM1632, /* mov ([0x66] 0x8b) */
- X86_OP_MOV_R1632_RM1632, /* mov ([0x66] 0x8b) */
- X86_OP_LEA, /* lea ([0x66] 0x8d) */ /* 66 ? */
- X86_OP_NOP, /* nop (0x90) */
+ XOP_LEA_R1632_M, /* lea ([0x66] 0x8d) */
+
+
+ XOP_NOP, /* nop (0x90) */
- X86_OP_MOV_MOFFS_TO_AL, /* mov (0xa0) */
- X86_OP_MOV_MOFFS_TO_E_AX, /* mov ([0x66] 0xa1) */
- X86_OP_MOV_AL_TO_MOFFS, /* mov (0xa2) */
- X86_OP_MOV_E_AX_TO_MOFFS, /* mov ([0x66] 0xa3) */
- X86_OP_TEST_AL, /* test (0xa8) */
- X86_OP_TEST_E_AX, /* test ([0x66] 0xa9) */
-
- X86_OP_MOV_E_AX, /* mov ([0x66] 0xb8) */
- X86_OP_MOV_E_CX, /* mov ([0x66] 0xb9) */
- X86_OP_MOV_E_DX, /* mov ([0x66] 0xba) */
- X86_OP_MOV_E_BX, /* mov ([0x66] 0xbb) */
- X86_OP_MOV_E_SP, /* mov ([0x66] 0xbc) */
- X86_OP_MOV_E_BP, /* mov ([0x66] 0xbd) */
- X86_OP_MOV_E_SI, /* mov ([0x66] 0xbe) */
- X86_OP_MOV_E_DI, /* mov ([0x66] 0xbf) */
+ XOP_XCHG_R1632_E_AX, /* xchg ([0x66] 0x90) */
+ XOP_XCHG_R1632_E_CX, /* xchg ([0x66] 0x91) */
+ XOP_XCHG_R1632_E_DX, /* xchg ([0x66] 0x92) */
+ XOP_XCHG_R1632_E_BX, /* xchg ([0x66] 0x93) */
+ XOP_XCHG_R1632_E_SP, /* xchg ([0x66] 0x94) */
+ XOP_XCHG_R1632_E_BP, /* xchg ([0x66] 0x95) */
+ XOP_XCHG_R1632_E_SI, /* xchg ([0x66] 0x96) */
+ XOP_XCHG_R1632_E_DI, /* xchg ([0x66] 0x97) */
- X86_OP_ROL_RM1632_IMM8, /* rol ([0x66] 0xc1 0) */
- X86_OP_ROR_RM1632_IMM8, /* ror ([0x66] 0xc1 1) */
- X86_OP_RCL_RM1632_IMM8, /* rcl ([0x66] 0xc1 2) */
- X86_OP_RCR_RM1632_IMM8, /* rcr ([0x66] 0xc1 3) */
- X86_OP_SHL_RM1632_IMM8, /* shl ([0x66] 0xc1 4) */
- X86_OP_SHR_RM1632_IMM8, /* shr ([0x66] 0xc1 5) */
- X86_OP_SAL_RM1632_IMM8, /* sal ([0x66] 0xc1 6) */
- X86_OP_SAR_RM1632_IMM8, /* sar ([0x66] 0xc1 7) */
- X86_OP_RET, /* ret (0xc3) */
+ XOP_MOV_AL_MOFFS8, /* mov (0xa0) */
+ XOP_MOV_E_AX_MOFFS1632, /* mov ([0x66] 0xa1) */
+ XOP_MOV_MOFFS8_AL, /* mov (0xa2) */
+ XOP_MOV_MOFFS1632_E_AX, /* mov ([0x66] 0xa3) */
- X86_OP_MOV_IMM8_TO_RM8, /* mov (0xc6) */
- X86_OP_MOV_IMM1632_TO_RM1632, /* mov ([0x66] 0xc7) */
- X86_OP_LEAVE, /* leave (0xc9) */
+ XOP_TEST_AL_IMM8, /* test (0xa8) */
+ XOP_TEST_E_AX_IMM1632, /* test ([0x66] 0xa9) */
- X86_OP_INT_3, /* int 3 (0xcc) */
- X86_OP_INT, /* int (0xcd) */
- X86_OP_SHL_RM1632_CL, /* shl ([0x66] 0xd3 4) */
+ XOP_MOV_E_AX_IMM1632, /* mov ([0x66] 0xb8) */
+ XOP_MOV_E_CX_IMM1632, /* mov ([0x66] 0xb9) */
+ XOP_MOV_E_DX_IMM1632, /* mov ([0x66] 0xba) */
+ XOP_MOV_E_BX_IMM1632, /* mov ([0x66] 0xbb) */
+ XOP_MOV_E_SP_IMM1632, /* mov ([0x66] 0xbc) */
+ XOP_MOV_E_BP_IMM1632, /* mov ([0x66] 0xbd) */
+ XOP_MOV_E_SI_IMM1632, /* mov ([0x66] 0xbe) */
+ XOP_MOV_E_DI_IMM1632, /* mov ([0x66] 0xbf) */
- X86_OP_CALL_REL1632, /* call ([0x66] 0xe8) */
- X86_OP_JMP_REL1632, /* jmp ([0x66] 0xe9) */
- X86_OP_JMP_8, /* jmp (0xeb) */
+ XOP_ROL_RM1632_IMM8, /* rol ([0x66] 0xc1 0) */
+ XOP_ROR_RM1632_IMM8, /* ror ([0x66] 0xc1 1) */
+ XOP_RCL_RM1632_IMM8, /* rcl ([0x66] 0xc1 2) */
+ XOP_RCR_RM1632_IMM8, /* rcr ([0x66] 0xc1 3) */
+ XOP_SHL_RM1632_IMM8, /* shl ([0x66] 0xc1 4) */
+ XOP_SHR_RM1632_IMM8, /* shr ([0x66] 0xc1 5) */
+ XOP_SAL_RM1632_IMM8, /* sal ([0x66] 0xc1 6) */
+ XOP_SAR_RM1632_IMM8, /* sar ([0x66] 0xc1 7) */
- X86_OP_HLT, /* hlt (0xf4) */
- X86_OP_NOT_RM1632, /* not ([0x66] 0xf7 2) */
+ XOP_RET, /* ret (0xc3) */
- X86_OP_CLD, /* cld (0xfc) */
+ XOP_MOV_RM8_IMM8, /* mov (0xc6 0) */
+ XOP_MOV_RM1632_IMM1632, /* mov ([0x66] 0xc7 0) */
- X86_OP_CALL_RM1632, /* call ([0x66] 0xff 2) */
- X86_OP_JMP_RM1632, /* jmp ([0x66] 0xff 4) */
- X86_OP_PUSH_RM1632, /* push ([0x66] 0xff 6) */
+ XOP_LEAVE, /* leave (0xc9) */
- X86_OP_MOVZX_R1632_RM8, /* movzx ([0x66] 0x0f 0xb6) */
+ XOP_INT_3, /* int 3 (0xcc) */
+ XOP_INT, /* int (0xcd) */
- X86_OP_MOVSX_R1632_RM8, /* movsx ([0x66] 0x0f 0xbe) */
+ XOP_SHL_RM1632_CL, /* shl ([0x66] 0xd3 4) */
- X86_OP_COUNT
+ XOP_CALL_REL1632, /* call ([0x66] 0xe8) */
+ XOP_JMP_REL1632, /* jmp ([0x66] 0xe9) */
-} X86Opcodes;
+ XOP_JMP_REL8, /* jmp (0xeb) */
+ XOP_HLT, /* hlt (0xf4) */
+ XOP_NOT_RM1632, /* not ([0x66] 0xf7 2) */
+ XOP_CLD, /* cld (0xfc) */
-/* Eventuel préfixe rencontré */
-typedef enum _X86Prefix
-{
- X86_PRE_NONE = (0 << 0), /* Aucun préfixe */
+ XOP_CALL_RM1632, /* call ([0x66] 0xff 2) */
+ XOP_JMP_RM1632, /* jmp ([0x66] 0xff 4) */
+ XOP_PUSH_RM1632, /* push ([0x66] 0xff 6) */
+
+ XOP_COUNT
+} X86Opcodes;
- /* Groupe 3 */
- X86_PRE_OPSIZE = (1 << 1), /* Basculement des opérandes */
+#define G_TYPE_X86_INSTRUCTION g_x86_instruction_get_type()
+#define G_X86_INSTRUCTION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_x86_instruction_get_type(), GX86Instruction))
+#define G_IS_X86_INSTRUCTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_x86_instruction_get_type()))
+#define G_X86_INSTRUCTION_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_x86_instruction_get_type(), GX86InstructionIface))
- /* Autres */
- X86_PRE_ESCAPE = (1 << 3) /* Opcode sur deux octets */
+/* Définition générique d'une instruction d'architecture x86 (instance) */
+typedef struct _GX86Instruction GX86Instruction;
-} X86Prefix;
+/* Définition générique d'une instruction d'architecture x86 (classe) */
+typedef struct _GX86InstructionClass GX86InstructionClass;
+/* Indique le type défini pour une instruction d'architecture x86. */
+GType g_x86_instruction_get_type(void);
-/* Définition d'une instruction x86 */
-struct _asm_x86_instr
-{
- asm_instr base; /* A laisser en premier... */
+/* Crée une instruction pour l'architecture x86. */
+GArchInstruction *g_x86_instruction_new(X86Opcodes);
- X86Opcodes type;
- X86Prefix prefix; /* Eventuel préfixe trouvé */
+/* --------------------- AIDE A LA MISE EN PLACE D'INSTRUCTIONS --------------------- */
-};
+/* Types de préfixes pour x86 */
+typedef enum _X86Prefix
+{
+ XPX_NONE = (0 << 0), /* Code d'instruction pur */
+
+ XPX_OPERAND_SIZE_OVERRIDE = (1 << 0), /* Taille des opérandes */
+} X86Prefix;
+/* Recherche l'identifiant de la prochaine instruction. */
+X86Opcodes x86_guess_next_instruction(const bin_t *, off_t, off_t, X86Prefix *, bool *);
diff --git a/src/arch/x86/op_adc.c b/src/arch/x86/op_adc.c
index 679bfb4..6ee4ed3 100644
--- a/src/arch/x86/op_adc.c
+++ b/src/arch/x86/op_adc.c
@@ -32,13 +32,13 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'adc' (8 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -46,20 +46,15 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_adc_imm8_to_rm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
- AsmOperandSize oprsize; /* Taille des opérandes */
-
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ GArchInstruction *result; /* Instruction à retourner */
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_ADC_RM8_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -70,11 +65,6 @@ asm_x86_instr *x86_read_instr_adc_imm8_to_rm1632(const uint8_t *data, off_t *pos
/******************************************************************************
* *
-* 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 'adc' (8 bits). *
* *
@@ -84,17 +74,15 @@ asm_x86_instr *x86_read_instr_adc_imm8_to_rm1632(const uint8_t *data, off_t *pos
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_adc_rm8_r8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ result = g_x86_instruction_new(XOP_ADC_RM8_R8);
if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -105,11 +93,11 @@ asm_x86_instr *x86_read_instr_adc_rm8_r8(const uint8_t *data, off_t *pos, off_t
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -119,20 +107,54 @@ asm_x86_instr *x86_read_instr_adc_rm8_r8(const uint8_t *data, off_t *pos, off_t
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_adc_rm1632_imm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ 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 */
+ AsmOperandSize oprsize; /* Taille des opérandes */
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_ADC_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_add.c b/src/arch/x86/op_add.c
index 98973cd..93506a1 100644
--- a/src/arch/x86/op_add.c
+++ b/src/arch/x86/op_add.c
@@ -32,11 +32,11 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -46,17 +46,15 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_add_al_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ result = g_x86_instruction_new(XOP_ADD_AL_IMM8);
if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_IMM8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -67,11 +65,11 @@ asm_x86_instr *x86_read_instr_add_al_imm8(const uint8_t *data, off_t *pos, off_t
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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).*
* *
@@ -81,20 +79,18 @@ asm_x86_instr *x86_read_instr_add_al_imm8(const uint8_t *data, off_t *pos, off_t
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_add_e_ax_imm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_ADD_E_AX_IMM1632);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -105,13 +101,13 @@ asm_x86_instr *x86_read_instr_add_e_ax_imm1632(const uint8_t *data, off_t *pos,
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'add' (8 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -119,20 +115,48 @@ asm_x86_instr *x86_read_instr_add_e_ax_imm1632(const uint8_t *data, off_t *pos,
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_add_imm8_to_rm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
- AsmOperandSize oprsize; /* Taille des opérandes */
+ 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;
+ }
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ return result;
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+}
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -143,11 +167,11 @@ asm_x86_instr *x86_read_instr_add_imm8_to_rm1632(const uint8_t *data, off_t *pos
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -157,17 +181,15 @@ asm_x86_instr *x86_read_instr_add_imm8_to_rm1632(const uint8_t *data, off_t *pos
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_add_r8_rm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_ADD_RM8_R8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R8, X86_OTP_RM8))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -178,11 +200,11 @@ asm_x86_instr *x86_read_instr_add_r8_rm8(const uint8_t *data, off_t *pos, off_t
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -192,20 +214,18 @@ asm_x86_instr *x86_read_instr_add_r8_rm8(const uint8_t *data, off_t *pos, off_t
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_add_r1632_rm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_ADD_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -216,13 +236,13 @@ asm_x86_instr *x86_read_instr_add_r1632_rm1632(const uint8_t *data, off_t *pos,
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'add' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -230,17 +250,18 @@ asm_x86_instr *x86_read_instr_add_r1632_rm1632(const uint8_t *data, off_t *pos,
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_add_rm8_r8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
+ AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_ADD_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -251,11 +272,11 @@ asm_x86_instr *x86_read_instr_add_rm8_r8(const uint8_t *data, off_t *pos, off_t
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -265,20 +286,18 @@ asm_x86_instr *x86_read_instr_add_rm8_r8(const uint8_t *data, off_t *pos, off_t
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_add_rm1632_imm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_ADD_RM1632_IMM8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -289,11 +308,11 @@ asm_x86_instr *x86_read_instr_add_rm1632_imm1632(const uint8_t *data, off_t *pos
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -303,20 +322,18 @@ asm_x86_instr *x86_read_instr_add_rm1632_imm1632(const uint8_t *data, off_t *pos
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_add_rm1632_r1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_ADD_RM1632_R1632);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_and.c b/src/arch/x86/op_and.c
index bcea898..c923441 100644
--- a/src/arch/x86/op_and.c
+++ b/src/arch/x86/op_and.c
@@ -32,11 +32,11 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -46,17 +46,43 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_and_rm8_r8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_AND_RM8_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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 '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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -67,11 +93,11 @@ asm_x86_instr *x86_read_instr_and_rm8_r8(const uint8_t *data, off_t *pos, off_t
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -81,20 +107,18 @@ asm_x86_instr *x86_read_instr_and_rm8_r8(const uint8_t *data, off_t *pos, off_t
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_and_rm1632_with_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_AND_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -105,11 +129,11 @@ asm_x86_instr *x86_read_instr_and_rm1632_with_imm8(const uint8_t *data, off_t *p
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -119,20 +143,18 @@ asm_x86_instr *x86_read_instr_and_rm1632_with_imm8(const uint8_t *data, off_t *p
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_and_rm1632_imm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_AND_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_call.c b/src/arch/x86/op_call.c
index 7641214..f121dd3 100644
--- a/src/arch/x86/op_call.c
+++ b/src/arch/x86/op_call.c
@@ -32,11 +32,11 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -46,22 +46,18 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_call_rel1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_call_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_CALL_REL1632);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- ASM_INSTRUCTION(result)->type = AIT_CALL;
-
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, offset))
+ if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, addr))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -72,11 +68,11 @@ asm_x86_instr *x86_read_instr_call_rel1632(const uint8_t *data, off_t *pos, off_
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -86,22 +82,18 @@ asm_x86_instr *x86_read_instr_call_rel1632(const uint8_t *data, off_t *pos, off_
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_call_rm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_call_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ result = g_x86_instruction_new(XOP_CALL_RM1632);
- ASM_INSTRUCTION(result)->type = AIT_CALL;
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM1632, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_cld.c b/src/arch/x86/op_cld.c
index c6d5411..fe59683 100644
--- a/src/arch/x86/op_cld.c
+++ b/src/arch/x86/op_cld.c
@@ -34,7 +34,8 @@
* 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. *
+* 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'. *
@@ -45,13 +46,11 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_cld(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_cld(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result;
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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
index 95e1347..709054b 100644
--- a/src/arch/x86/op_cmp.c
+++ b/src/arch/x86/op_cmp.c
@@ -32,11 +32,11 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -46,17 +46,15 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_cmp_rm8_with_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ result = g_x86_instruction_new(XOP_CMP_RM8_IMM8);
if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -67,13 +65,13 @@ asm_x86_instr *x86_read_instr_cmp_rm8_with_imm8(const uint8_t *data, off_t *pos,
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'cmp' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -81,20 +79,18 @@ asm_x86_instr *x86_read_instr_cmp_rm8_with_imm8(const uint8_t *data, off_t *pos,
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_cmp_rm1632_with_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_CMP_RM1632_IMM8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -105,11 +101,11 @@ asm_x86_instr *x86_read_instr_cmp_rm1632_with_imm8(const uint8_t *data, off_t *p
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -119,20 +115,18 @@ asm_x86_instr *x86_read_instr_cmp_rm1632_with_imm8(const uint8_t *data, off_t *p
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_cmp_rm1632_imm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_CMP_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -143,11 +137,11 @@ asm_x86_instr *x86_read_instr_cmp_rm1632_imm1632(const uint8_t *data, off_t *pos
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -157,20 +151,18 @@ asm_x86_instr *x86_read_instr_cmp_rm1632_imm1632(const uint8_t *data, off_t *pos
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_cmp_rm1632_with_r1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_CMP_RM1632_R1632);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_dec.c b/src/arch/x86/op_dec.c
index dd3562e..f140b85 100644
--- a/src/arch/x86/op_dec.c
+++ b/src/arch/x86/op_dec.c
@@ -35,7 +35,8 @@
* 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. *
+* 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). *
@@ -46,20 +47,21 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_dec_r1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_dec_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
+ X86Opcodes opcode; /* Instruction effective */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ opcode = XOP_DEC_E_AX + (data[*pos] - 0x48);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(opcode);
- ASM_INSTRUCTION(result)->opcode = data[*pos];
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
if (!x86_read_one_operand(result, data, pos, len, X86_OTP_OP_R1632, oprsize, 0x48))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_hlt.c b/src/arch/x86/op_hlt.c
index b789dca..c38c1cc 100644
--- a/src/arch/x86/op_hlt.c
+++ b/src/arch/x86/op_hlt.c
@@ -34,7 +34,8 @@
* 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. *
+* 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'. *
@@ -45,13 +46,11 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_hlt(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_hlt(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result;
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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
index 912d432..b80e448 100644
--- a/src/arch/x86/op_inc.c
+++ b/src/arch/x86/op_inc.c
@@ -35,7 +35,8 @@
* 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. *
+* 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). *
@@ -46,20 +47,21 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_inc_r1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_inc_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
+ X86Opcodes opcode; /* Instruction effective */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ opcode = XOP_INC_E_AX + (data[*pos] - 0x40);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(opcode);
- ASM_INSTRUCTION(result)->opcode = data[*pos];
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
if (!x86_read_one_operand(result, data, pos, len, X86_OTP_OP_R1632, oprsize, 0x40))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_int.c b/src/arch/x86/op_int.c
index 4fdb73a..98b5ce9 100644
--- a/src/arch/x86/op_int.c
+++ b/src/arch/x86/op_int.c
@@ -27,6 +27,7 @@
#include "../instruction-int.h"
#include "opcodes.h"
#include "operand.h"
+#include "../immediate.h"
@@ -35,7 +36,8 @@
* 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. *
+* 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'. *
@@ -46,19 +48,11 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_int(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_int(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
-
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ GArchInstruction *result; /* Instruction à retourner */
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_IMM8))
- {
- free(result);
- return NULL;
- }
+ result = g_x86_instruction_new(XOP_INT);
return result;
@@ -81,27 +75,15 @@ asm_x86_instr *x86_read_instr_int(const uint8_t *data, off_t *pos, off_t len, ui
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_int_3(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_int_3(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
- asm_x86_operand *op; /* Opérande unique décodé */
-
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- op = create_new_x86_operand();
- if (!fill_imm_operand_with_value(ASM_OPERAND(op), AOS_8_BITS, (int []) { 3 }))
- {
- free(op);
- free(result);
- return NULL;
- }
+ GArchInstruction *result; /* Instruction à retourner */
+ GArchOperand *three; /* Argument artificiel */
- ASM_INSTRUCTION(result)->operands = (asm_operand **)calloc(1, sizeof(asm_operand *));
- ASM_INSTRUCTION(result)->operands_count = 1;
+ result = g_x86_instruction_new(XOP_INT_3);
- ASM_INSTRUCTION(result)->operands[0] = ASM_OPERAND(op);
+ three = g_imm_operand_new_from_value(AOS_8_BITS, 3);
+ g_arch_instruction_attach_one_operand(result, three);
return result;
diff --git a/src/arch/x86/op_jump.c b/src/arch/x86/op_jump.c
index 4a7fc72..709ff24 100644
--- a/src/arch/x86/op_jump.c
+++ b/src/arch/x86/op_jump.c
@@ -32,11 +32,44 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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 si supérieur). *
+* *
+* 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))
+ {
+ /* TODO free(result);*/
+ return NULL;
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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 si inférieur). *
* *
@@ -46,19 +79,48 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_jb_rel8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_jb_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ 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))
+ {
+ /* TODO free(result);*/
+ return NULL;
+ }
+
+ return result;
+
+}
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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 si égal). *
+* *
+* 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 */
- ASM_INSTRUCTION(result)->type = AIT_JUMP;
+ result = g_x86_instruction_new(XOP_JE_REL8);
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, offset))
+ if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -69,13 +131,13 @@ asm_x86_instr *x86_read_instr_jb_rel8(const uint8_t *data, off_t *pos, off_t len
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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' (petit saut). *
+* Description : Décode une instruction de type 'jg' (saut 8b si supérieur). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -83,19 +145,48 @@ asm_x86_instr *x86_read_instr_jb_rel8(const uint8_t *data, off_t *pos, off_t len
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_je_8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_jg_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ 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))
+ {
+ /* TODO free(result);*/
+ return NULL;
+ }
+
+ return result;
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+}
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
- ASM_INSTRUCTION(result)->type = AIT_JUMP;
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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 si inférieur). *
+* *
+* Retour : Instruction mise en place ou NULL. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, offset))
+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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -106,13 +197,46 @@ asm_x86_instr *x86_read_instr_je_8(const uint8_t *data, off_t *pos, off_t len, u
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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 si supérieur). *
+* 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))
+ {
+ /* TODO free(result);*/
+ return NULL;
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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. *
* *
@@ -120,19 +244,87 @@ asm_x86_instr *x86_read_instr_je_8(const uint8_t *data, off_t *pos, off_t len, u
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_jg_rel8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_jmp_rel1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
+ AsmOperandSize 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))
+ {
+ /* TODO free(result);*/
+ return NULL;
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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 */
+ AsmOperandSize 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))
+ {
+ /* TODO free(result);*/
+ return NULL;
+ }
+
+ return result;
+
+}
+
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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 si !supérieur).*
+* *
+* Retour : Instruction mise en place ou NULL. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+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 */
- ASM_INSTRUCTION(result)->type = AIT_JUMP;
+ result = g_x86_instruction_new(XOP_JNA_REL8);
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, offset))
+ if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -143,11 +335,11 @@ asm_x86_instr *x86_read_instr_jg_rel8(const uint8_t *data, off_t *pos, off_t len
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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 si !inférieur).*
* *
@@ -157,19 +349,48 @@ asm_x86_instr *x86_read_instr_jg_rel8(const uint8_t *data, off_t *pos, off_t len
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_jnb_rel8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_jnb_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ 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))
+ {
+ /* TODO free(result);*/
+ return NULL;
+ }
+
+ return result;
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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 si !égal). *
+* *
+* Retour : Instruction mise en place ou NULL. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+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 */
- ASM_INSTRUCTION(result)->type = AIT_JUMP;
+ result = g_x86_instruction_new(XOP_JNE_REL8);
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, offset))
+ if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -180,13 +401,13 @@ asm_x86_instr *x86_read_instr_jnb_rel8(const uint8_t *data, off_t *pos, off_t le
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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' (petit saut). *
+* Description : Décode une instruction de type 'jng' (saut 8b si !supérieur).*
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -194,19 +415,48 @@ asm_x86_instr *x86_read_instr_jnb_rel8(const uint8_t *data, off_t *pos, off_t le
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_jne_8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_jng_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ 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))
+ {
+ /* TODO free(result);*/
+ return NULL;
+ }
+
+ return result;
+
+}
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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 si !inférieur).*
+* *
+* 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 */
- ASM_INSTRUCTION(result)->type = AIT_JUMP;
+ result = g_x86_instruction_new(XOP_JNL_REL8);
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, offset))
+ if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -217,13 +467,13 @@ asm_x86_instr *x86_read_instr_jne_8(const uint8_t *data, off_t *pos, off_t len,
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'jno' (saut 8b si !débordemt).*
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -231,19 +481,48 @@ asm_x86_instr *x86_read_instr_jne_8(const uint8_t *data, off_t *pos, off_t len,
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_jmp_8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_jno_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_JNO_REL8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
+ {
+ /* TODO free(result);*/
+ return NULL;
+ }
- ASM_INSTRUCTION(result)->type = AIT_JUMP;
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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 si !parité). *
+* *
+* 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, offset))
+ if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -254,13 +533,13 @@ asm_x86_instr *x86_read_instr_jmp_8(const uint8_t *data, off_t *pos, off_t len,
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'jns' (saut 8b si !signée). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -268,22 +547,48 @@ asm_x86_instr *x86_read_instr_jmp_8(const uint8_t *data, off_t *pos, off_t len,
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_jmp_rel1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_jns_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
- AsmOperandSize oprsize; /* Taille des opérandes */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_JNS_REL8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
+ {
+ /* TODO free(result);*/
+ return NULL;
+ }
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ return result;
+
+}
- ASM_INSTRUCTION(result)->type = AIT_JUMP;
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL1632, oprsize, offset))
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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 si débordement).*
+* *
+* 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -294,13 +599,13 @@ asm_x86_instr *x86_read_instr_jmp_rel1632(const uint8_t *data, off_t *pos, off_t
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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' (saut en mémoire). *
+* Description : Décode une instruction de type 'jp' (saut 8b si parité). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -308,22 +613,48 @@ asm_x86_instr *x86_read_instr_jmp_rel1632(const uint8_t *data, off_t *pos, off_t
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_jmp_rm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_jp_rel8(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
- AsmOperandSize oprsize; /* Taille des opérandes */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_JP_REL8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ if (!x86_read_one_operand(result, data, pos, len, X86_OTP_REL8, addr))
+ {
+ /* TODO free(result);*/
+ return NULL;
+ }
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ return result;
- ASM_INSTRUCTION(result)->type = AIT_JUMP;
+}
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM1632, oprsize))
+
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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 si signée). *
+* *
+* 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_lea.c b/src/arch/x86/op_lea.c
index bf63818..4ea1943 100644
--- a/src/arch/x86/op_lea.c
+++ b/src/arch/x86/op_lea.c
@@ -32,11 +32,11 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -46,40 +46,21 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_lea(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- asm_x86_operand *reg1; /* Registre de destination */
- asm_x86_operand *reg2; /* Registre de source */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_LEA_R1632_M);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- reg1 = x86_create_reg1632_operand_from_modrm(data[*pos], oprsize == AOS_32_BITS, false);
- if (reg1 == NULL)
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM1632, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
- reg2 = x86_create_content1632_operand(data, pos, len, oprsize == AOS_32_BITS, true);
- if (reg2 == NULL)
- {
- free(result);
- free(reg1);
- return NULL;
- }
-
- ASM_INSTRUCTION(result)->operands = (asm_operand **)calloc(2, sizeof(asm_operand *));
- ASM_INSTRUCTION(result)->operands_count = 2;
-
- ASM_INSTRUCTION(result)->operands[0] = ASM_OPERAND(reg1);
- ASM_INSTRUCTION(result)->operands[1] = ASM_OPERAND(reg2);
-
return result;
}
diff --git a/src/arch/x86/op_leave.c b/src/arch/x86/op_leave.c
index 550d4dc..05d347a 100644
--- a/src/arch/x86/op_leave.c
+++ b/src/arch/x86/op_leave.c
@@ -34,7 +34,8 @@
* 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. *
+* 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'. *
@@ -45,13 +46,11 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_leave(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_leave(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result;
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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
index efa23c4..4828ba1 100644
--- a/src/arch/x86/op_mov.c
+++ b/src/arch/x86/op_mov.c
@@ -32,13 +32,13 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'mov al, ...' (8 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -46,17 +46,15 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_mov_al_to_moffs8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_MOV_AL_MOFFS8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_MOFFS8, X86_OTP_AL))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_MOFFS8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -67,13 +65,13 @@ asm_x86_instr *x86_read_instr_mov_al_to_moffs8(const uint8_t *data, off_t *pos,
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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).*
+* Description : Décode une instruction de type 'mov [e]ax, ...' (16/32 bits).*
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -81,20 +79,18 @@ asm_x86_instr *x86_read_instr_mov_al_to_moffs8(const uint8_t *data, off_t *pos,
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_mov_e_ax_to_moffs1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_MOV_E_AX_MOFFS1632);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_E_AX, X86_OTP_MOFFS1632, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -105,13 +101,13 @@ asm_x86_instr *x86_read_instr_mov_e_ax_to_moffs1632(const uint8_t *data, off_t *
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'mov ..., al' (8 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -119,17 +115,15 @@ asm_x86_instr *x86_read_instr_mov_e_ax_to_moffs1632(const uint8_t *data, off_t *
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_mov_imm8_to_rm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_MOV_MOFFS8_AL);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_MOFFS8, X86_OTP_AL))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -140,13 +134,13 @@ asm_x86_instr *x86_read_instr_mov_imm8_to_rm8(const uint8_t *data, off_t *pos, o
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'mov ..., [e]ax' (16/32 bits).*
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -154,54 +148,21 @@ asm_x86_instr *x86_read_instr_mov_imm8_to_rm8(const uint8_t *data, off_t *pos, o
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_mov_imm1632_to_r1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- asm_x86_operand *reg; /* Registre de destination */
- asm_x86_operand *value; /* Valeur portée */
-
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[*pos];
+ result = g_x86_instruction_new(XOP_MOV_MOFFS1632_E_AX);
- /*
- if (!x86_read_one_operand(result, data, pos, len, X86_OTP_OP_R1632, oprsize, 0x40))
- {
- free(result);
- return NULL;
- }
- */
-
-
-
-
-
- reg = x86_create_reg1632_operand(data[(*pos)++], oprsize == AOS_32_BITS, 0xb8);
- if (reg == NULL)
- {
- free(result);
- return NULL;
- }
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
- value = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(value), oprsize, data, pos, len))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_MOFFS1632, X86_OTP_E_AX, oprsize))
{
- free(reg);
- free(value);
- free(result);
+ /* TODO free(result);*/
return NULL;
}
- ASM_INSTRUCTION(result)->operands = (asm_operand **)calloc(2, sizeof(asm_operand *));
- ASM_INSTRUCTION(result)->operands_count = 2;
-
- ASM_INSTRUCTION(result)->operands[0] = ASM_OPERAND(reg);
- ASM_INSTRUCTION(result)->operands[1] = ASM_OPERAND(value);
-
return result;
}
@@ -209,11 +170,11 @@ asm_x86_instr *x86_read_instr_mov_imm1632_to_r1632(const uint8_t *data, off_t *p
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -223,20 +184,21 @@ asm_x86_instr *x86_read_instr_mov_imm1632_to_r1632(const uint8_t *data, off_t *p
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_mov_imm1632_to_rm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
+ X86Opcodes opcode; /* Instruction effective */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ opcode = XOP_MOV_E_AX_IMM1632 + (data[*pos] - 0xb8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(opcode);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_OP_R1632, X86_OTP_IMM1632, oprsize, 0xb8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -247,13 +209,13 @@ asm_x86_instr *x86_read_instr_mov_imm1632_to_rm1632(const uint8_t *data, off_t *
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'mov' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -261,17 +223,18 @@ asm_x86_instr *x86_read_instr_mov_imm1632_to_rm1632(const uint8_t *data, off_t *
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_mov_moffs8_to_al(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
+ AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_MOV_R1632_RM1632);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_MOFFS8))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM1632, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -282,13 +245,13 @@ asm_x86_instr *x86_read_instr_mov_moffs8_to_al(const uint8_t *data, off_t *pos,
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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).*
+* Description : Décode une instruction de type 'mov' (8 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -296,20 +259,15 @@ asm_x86_instr *x86_read_instr_mov_moffs8_to_al(const uint8_t *data, off_t *pos,
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_mov_moffs1632_to_e_ax(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
- AsmOperandSize oprsize; /* Taille des opérandes */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_MOV_RM8_IMM8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_E_AX, X86_OTP_MOFFS1632, oprsize))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -320,13 +278,8 @@ asm_x86_instr *x86_read_instr_mov_moffs1632_to_e_ax(const uint8_t *data, off_t *
/******************************************************************************
* *
-* 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 'mov' (16 ou 32 bits). *
+* Description : Décode une instruction de type 'mov' (8 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -334,20 +287,15 @@ asm_x86_instr *x86_read_instr_mov_moffs1632_to_e_ax(const uint8_t *data, off_t *
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_mov_r1632_to_rm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
- AsmOperandSize oprsize; /* Taille des opérandes */
-
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ GArchInstruction *result; /* Instruction à retourner */
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_MOV_RM8_R8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, oprsize))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -358,11 +306,11 @@ asm_x86_instr *x86_read_instr_mov_r1632_to_rm1632(const uint8_t *data, off_t *po
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -372,20 +320,18 @@ asm_x86_instr *x86_read_instr_mov_r1632_to_rm1632(const uint8_t *data, off_t *po
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_mov_rm1632_to_r1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_MOV_RM1632_IMM1632);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM1632, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -396,13 +342,13 @@ asm_x86_instr *x86_read_instr_mov_rm1632_to_r1632(const uint8_t *data, off_t *po
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'mov' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -410,17 +356,18 @@ asm_x86_instr *x86_read_instr_mov_rm1632_to_r1632(const uint8_t *data, off_t *po
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_mov_rm8_r8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
+ AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_MOV_RM1632_R1632);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_movsx.c b/src/arch/x86/op_movsx.c
index 461309f..e75f1a1 100644
--- a/src/arch/x86/op_movsx.c
+++ b/src/arch/x86/op_movsx.c
@@ -59,13 +59,13 @@ asm_x86_instr *x86_read_instr_movsx_r1632_rm8(const uint8_t *data, off_t *pos, o
oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
+ /*
if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM8, oprsize))
{
free(result);
return NULL;
}
-
+ */
return result;
}
diff --git a/src/arch/x86/op_movzx.c b/src/arch/x86/op_movzx.c
index 4df1303..c1629d9 100644
--- a/src/arch/x86/op_movzx.c
+++ b/src/arch/x86/op_movzx.c
@@ -59,13 +59,13 @@ asm_x86_instr *x86_read_instr_movzx_r1632_rm8(const uint8_t *data, off_t *pos, o
oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
+ /*
if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM8, oprsize))
{
free(result);
return NULL;
}
-
+ */
return result;
}
diff --git a/src/arch/x86/op_nop.c b/src/arch/x86/op_nop.c
index 3c1b989..1c2d4c1 100644
--- a/src/arch/x86/op_nop.c
+++ b/src/arch/x86/op_nop.c
@@ -21,9 +21,6 @@
*/
-#include <malloc.h>
-
-
#include "../instruction-int.h"
#include "opcodes.h"
@@ -34,7 +31,8 @@
* 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. *
+* 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'. *
@@ -45,13 +43,11 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_nop(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_nop(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result;
-
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ GArchInstruction *result; /* Instruction à retourner */
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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
index 6deb61c..f57c754 100644
--- a/src/arch/x86/op_not.c
+++ b/src/arch/x86/op_not.c
@@ -32,11 +32,11 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -46,20 +46,18 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_not_rm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_not_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_NOT_RM1632);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM1632, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_or.c b/src/arch/x86/op_or.c
index 198a0bb..1f1e78d 100644
--- a/src/arch/x86/op_or.c
+++ b/src/arch/x86/op_or.c
@@ -32,11 +32,6 @@
/******************************************************************************
* *
-* 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 'or al, ...' (8 bits). *
* *
@@ -46,17 +41,15 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_or_al_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ result = g_x86_instruction_new(XOP_OR_AL_IMM8);
if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_IMM8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -67,11 +60,6 @@ asm_x86_instr *x86_read_instr_or_al_imm8(const uint8_t *data, off_t *pos, off_t
/******************************************************************************
* *
-* 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 'or' (8 bits). *
* *
@@ -81,17 +69,15 @@ asm_x86_instr *x86_read_instr_or_al_imm8(const uint8_t *data, off_t *pos, off_t
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_or_r8_rm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
-
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ GArchInstruction *result; /* Instruction à retourner */
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ result = g_x86_instruction_new(XOP_OR_R8_RM8);
if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R8, X86_OTP_RM8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -102,11 +88,44 @@ asm_x86_instr *x86_read_instr_or_r8_rm8(const uint8_t *data, off_t *pos, off_t l
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -116,20 +135,18 @@ asm_x86_instr *x86_read_instr_or_r8_rm8(const uint8_t *data, off_t *pos, off_t l
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_or_rm1632_with_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_OR_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -140,11 +157,11 @@ asm_x86_instr *x86_read_instr_or_rm1632_with_imm8(const uint8_t *data, off_t *po
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -154,20 +171,18 @@ asm_x86_instr *x86_read_instr_or_rm1632_with_imm8(const uint8_t *data, off_t *po
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_or_rm1632_imm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_OR_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_pop.c b/src/arch/x86/op_pop.c
index ab0d278..c362898 100644
--- a/src/arch/x86/op_pop.c
+++ b/src/arch/x86/op_pop.c
@@ -32,11 +32,11 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -46,20 +46,21 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_pop_r1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_pop_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
+ X86Opcodes opcode; /* Instruction effective */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ opcode = XOP_POP_E_AX + (data[*pos] - 0x58);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(opcode);
- ASM_INSTRUCTION(result)->opcode = data[*pos];
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
if (!x86_read_one_operand(result, data, pos, len, X86_OTP_OP_R1632, oprsize, 0x58))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_push.c b/src/arch/x86/op_push.c
index f51bd6f..0e0d100 100644
--- a/src/arch/x86/op_push.c
+++ b/src/arch/x86/op_push.c
@@ -27,7 +27,6 @@
#include "../instruction-int.h"
#include "opcodes.h"
#include "operand.h"
-#include "processor.h"
@@ -36,7 +35,8 @@
* 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. *
+* 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). *
@@ -47,22 +47,18 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_push_imm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_push_imm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_PUSH_IMM1632);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- ASM_INSTRUCTION(result)->type = AIT_PUSH;
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
if (!x86_read_one_operand(result, data, pos, len, X86_OTP_IMM1632, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -76,7 +72,8 @@ asm_x86_instr *x86_read_instr_push_imm1632(const uint8_t *data, off_t *pos, off_
* 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. *
+* 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). *
@@ -87,22 +84,21 @@ asm_x86_instr *x86_read_instr_push_imm1632(const uint8_t *data, off_t *pos, off_
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_push_r1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_push_r1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
+ X86Opcodes opcode; /* Instruction effective */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ opcode = XOP_PUSH_E_AX + (data[*pos] - 0x50);
- ASM_INSTRUCTION(result)->opcode = data[*pos];
+ result = g_x86_instruction_new(opcode);
- ASM_INSTRUCTION(result)->type = AIT_PUSH;
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
if (!x86_read_one_operand(result, data, pos, len, X86_OTP_OP_R1632, oprsize, 0x50))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -113,11 +109,11 @@ asm_x86_instr *x86_read_instr_push_r1632(const uint8_t *data, off_t *pos, off_t
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -127,22 +123,18 @@ asm_x86_instr *x86_read_instr_push_r1632(const uint8_t *data, off_t *pos, off_t
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_push_rm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_push_rm1632(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ result = g_x86_instruction_new(XOP_PUSH_RM1632);
- ASM_INSTRUCTION(result)->type = AIT_PUSH;
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
if (!x86_read_one_operand(result, data, pos, len, X86_OTP_RM1632, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_rcl.c b/src/arch/x86/op_rcl.c
index ab0fd05..e3d95b3 100644
--- a/src/arch/x86/op_rcl.c
+++ b/src/arch/x86/op_rcl.c
@@ -32,13 +32,13 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'rcl' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -46,20 +46,18 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_rcl_rm1632_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_RCL_RM1632_IMM8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_rcr.c b/src/arch/x86/op_rcr.c
index 78807f9..028a53c 100644
--- a/src/arch/x86/op_rcr.c
+++ b/src/arch/x86/op_rcr.c
@@ -32,13 +32,13 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'rcr' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -46,20 +46,18 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_rcr_rm1632_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_RCR_RM1632_IMM8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_ret.c b/src/arch/x86/op_ret.c
index 8f2a54a..fcb4d6d 100644
--- a/src/arch/x86/op_ret.c
+++ b/src/arch/x86/op_ret.c
@@ -34,7 +34,8 @@
* 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. *
+* 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 'ret'. *
@@ -45,13 +46,11 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_ret(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+GArchInstruction *x86_read_instr_ret(const bin_t *data, off_t *pos, off_t len, vmpa_t addr, X86Prefix prefix, const GX86Processor *proc)
{
- asm_x86_instr *result;
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ result = g_x86_instruction_new(XOP_RET);
return result;
diff --git a/src/arch/x86/op_rol.c b/src/arch/x86/op_rol.c
index 047f7cd..9f42ada 100644
--- a/src/arch/x86/op_rol.c
+++ b/src/arch/x86/op_rol.c
@@ -32,13 +32,13 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'rol' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -46,20 +46,18 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_rol_rm1632_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_ROL_RM1632_IMM8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_ror.c b/src/arch/x86/op_ror.c
index 5dca287..5220259 100644
--- a/src/arch/x86/op_ror.c
+++ b/src/arch/x86/op_ror.c
@@ -32,13 +32,13 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'ror' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -46,20 +46,18 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_ror_rm1632_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_ROR_RM1632_IMM8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_sar.c b/src/arch/x86/op_sar.c
index 5e82cd8..2d7dc30 100644
--- a/src/arch/x86/op_sar.c
+++ b/src/arch/x86/op_sar.c
@@ -32,13 +32,13 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'sar' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -46,20 +46,18 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_sar_rm1632_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_SAR_RM1632_IMM8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_sbb.c b/src/arch/x86/op_sbb.c
index 20619cc..24c70e7 100644
--- a/src/arch/x86/op_sbb.c
+++ b/src/arch/x86/op_sbb.c
@@ -32,11 +32,44 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -46,20 +79,18 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_sbb_rm1632_with_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_SBB_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -70,11 +101,11 @@ asm_x86_instr *x86_read_instr_sbb_rm1632_with_imm8(const uint8_t *data, off_t *p
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -84,20 +115,18 @@ asm_x86_instr *x86_read_instr_sbb_rm1632_with_imm8(const uint8_t *data, off_t *p
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_sbb_rm1632_imm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_SBB_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_shl.c b/src/arch/x86/op_shl.c
index fbcb0db..f6d9a77 100644
--- a/src/arch/x86/op_shl.c
+++ b/src/arch/x86/op_shl.c
@@ -32,13 +32,13 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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'. *
+* Description : Décode une instruction de type 'shl' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -46,20 +46,18 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_shl_rm1632_cl(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_SHL_RM1632_CL);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -70,13 +68,13 @@ asm_x86_instr *x86_read_instr_shl_rm1632_cl(const uint8_t *data, off_t *pos, off
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'shl' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -84,20 +82,18 @@ asm_x86_instr *x86_read_instr_shl_rm1632_cl(const uint8_t *data, off_t *pos, off
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_shl_rm1632_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_SHL_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_shr.c b/src/arch/x86/op_shr.c
index 0ba8c4e..e6b4edf 100644
--- a/src/arch/x86/op_shr.c
+++ b/src/arch/x86/op_shr.c
@@ -32,13 +32,13 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'shr' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -46,20 +46,18 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_shr_rm1632_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_SHR_RM1632_IMM8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_sub.c b/src/arch/x86/op_sub.c
index bffc758..192c848 100644
--- a/src/arch/x86/op_sub.c
+++ b/src/arch/x86/op_sub.c
@@ -32,11 +32,11 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -46,17 +46,15 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_sub_al_with_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ result = g_x86_instruction_new(XOP_SUB_RM8_IMM8);
if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_IMM8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -67,11 +65,11 @@ asm_x86_instr *x86_read_instr_sub_al_with_imm8(const uint8_t *data, off_t *pos,
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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).*
* *
@@ -81,20 +79,18 @@ asm_x86_instr *x86_read_instr_sub_al_with_imm8(const uint8_t *data, off_t *pos,
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_sub_e_ax_with_imm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_SUB_E_AX_IMM1632);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -105,13 +101,13 @@ asm_x86_instr *x86_read_instr_sub_e_ax_with_imm1632(const uint8_t *data, off_t *
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'sub' (8 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -119,20 +115,48 @@ asm_x86_instr *x86_read_instr_sub_e_ax_with_imm1632(const uint8_t *data, off_t *
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_sub_imm8_from_rm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
- AsmOperandSize oprsize; /* Taille des opérandes */
+ 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;
+ }
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ return result;
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+}
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
+/******************************************************************************
+* *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -143,11 +167,11 @@ asm_x86_instr *x86_read_instr_sub_imm8_from_rm1632(const uint8_t *data, off_t *p
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -157,20 +181,18 @@ asm_x86_instr *x86_read_instr_sub_imm8_from_rm1632(const uint8_t *data, off_t *p
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_sub_r1632_from_rm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_SUB_RM1632_IMM8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, oprsize))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM8, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -181,13 +203,13 @@ asm_x86_instr *x86_read_instr_sub_r1632_from_rm1632(const uint8_t *data, off_t *
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'sub' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -195,17 +217,18 @@ asm_x86_instr *x86_read_instr_sub_r1632_from_rm1632(const uint8_t *data, off_t *
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_sub_r8_rm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
+ AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_SUB_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R8, X86_OTP_RM8))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_IMM1632, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -216,11 +239,11 @@ asm_x86_instr *x86_read_instr_sub_r8_rm8(const uint8_t *data, off_t *pos, off_t
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -230,20 +253,18 @@ asm_x86_instr *x86_read_instr_sub_r8_rm8(const uint8_t *data, off_t *pos, off_t
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_sub_rm1632_imm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_SUB_RM1632_R1632);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM1632, X86_OTP_R1632, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_test.c b/src/arch/x86/op_test.c
index 1d8d18a..39f5777 100644
--- a/src/arch/x86/op_test.c
+++ b/src/arch/x86/op_test.c
@@ -46,17 +46,15 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_test_al(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ result = g_x86_instruction_new(XOP_TEST_AL_IMM8);
if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_IMM8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -81,20 +79,18 @@ asm_x86_instr *x86_read_instr_test_al(const uint8_t *data, off_t *pos, off_t len
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_test_e_ax(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_TEST_E_AX_IMM1632);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -119,17 +115,15 @@ asm_x86_instr *x86_read_instr_test_e_ax(const uint8_t *data, off_t *pos, off_t l
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_test_rm8_with_r8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ result = g_x86_instruction_new(XOP_TEST_RM8_R8);
if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -154,20 +148,18 @@ asm_x86_instr *x86_read_instr_test_rm8_with_r8(const uint8_t *data, off_t *pos,
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_test_rm1632_with_r1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_TEST_RM1632_R1632);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/op_xchg.c b/src/arch/x86/op_xchg.c
new file mode 100644
index 0000000..7a7d71b
--- /dev/null
+++ b/src/arch/x86/op_xchg.c
@@ -0,0 +1,69 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * op_xchg.c - décodage des échanges de contenu de regitres
+ *
+ * Copyright (C) 2009 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <malloc.h>
+
+
+#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 */
+ AsmOperandSize 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
index eabb88e..b6e690b 100644
--- a/src/arch/x86/op_xor.c
+++ b/src/arch/x86/op_xor.c
@@ -32,11 +32,11 @@
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -46,17 +46,15 @@
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_xor_al_with_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ result = g_x86_instruction_new(XOP_XOR_AL_IMM8);
if (!x86_read_two_operands(result, data, pos, len, X86_OTP_AL, X86_OTP_IMM8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -67,11 +65,11 @@ asm_x86_instr *x86_read_instr_xor_al_with_imm8(const uint8_t *data, off_t *pos,
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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).*
* *
@@ -81,20 +79,18 @@ asm_x86_instr *x86_read_instr_xor_al_with_imm8(const uint8_t *data, off_t *pos,
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_xor_e_ax_with_imm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_XOR_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -105,11 +101,11 @@ asm_x86_instr *x86_read_instr_xor_e_ax_with_imm1632(const uint8_t *data, off_t *
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -119,20 +115,15 @@ asm_x86_instr *x86_read_instr_xor_e_ax_with_imm1632(const uint8_t *data, off_t *
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_xor_rm8_with_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
- AsmOperandSize oprsize; /* Taille des opérandes */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_XOR_R8_RM8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8, oprsize))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R8, X86_OTP_RM8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -143,11 +134,11 @@ asm_x86_instr *x86_read_instr_xor_rm8_with_imm8(const uint8_t *data, off_t *pos,
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -157,17 +148,15 @@ asm_x86_instr *x86_read_instr_xor_rm8_with_imm8(const uint8_t *data, off_t *pos,
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_xor_r8_with_rm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_XOR_RM8_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R8, X86_OTP_RM8))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_IMM8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -178,13 +167,13 @@ asm_x86_instr *x86_read_instr_xor_r8_with_rm8(const uint8_t *data, off_t *pos, o
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'xor' (8 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -192,20 +181,15 @@ asm_x86_instr *x86_read_instr_xor_r8_with_rm8(const uint8_t *data, off_t *pos, o
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_xor_r1632_with_rm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
- AsmOperandSize oprsize; /* Taille des opérandes */
-
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ GArchInstruction *result; /* Instruction à retourner */
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_XOR_RM8_R8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
-
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM1632, oprsize))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -216,13 +200,13 @@ asm_x86_instr *x86_read_instr_xor_r1632_with_rm1632(const uint8_t *data, off_t *
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
+* Description : Décode une instruction de type 'xor' (16 ou 32 bits). *
* *
* Retour : Instruction mise en place ou NULL. *
* *
@@ -230,17 +214,18 @@ asm_x86_instr *x86_read_instr_xor_r1632_with_rm1632(const uint8_t *data, off_t *
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_xor_rm8_with_r8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
+ AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_XOR_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ oprsize = g_x86_processor_get_operand_size(proc, prefix);
- if (!x86_read_two_operands(result, data, pos, len, X86_OTP_RM8, X86_OTP_R8))
+ if (!x86_read_two_operands(result, data, pos, len, X86_OTP_R1632, X86_OTP_RM1632, oprsize))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -251,11 +236,11 @@ asm_x86_instr *x86_read_instr_xor_rm8_with_r8(const uint8_t *data, off_t *pos, o
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -265,20 +250,18 @@ asm_x86_instr *x86_read_instr_xor_rm8_with_r8(const uint8_t *data, off_t *pos, o
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_xor_rm1632_with_imm8(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_XOR_RM1632_IMM8);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -289,11 +272,11 @@ asm_x86_instr *x86_read_instr_xor_rm1632_with_imm8(const uint8_t *data, off_t *p
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -303,20 +286,18 @@ asm_x86_instr *x86_read_instr_xor_rm1632_with_imm8(const uint8_t *data, off_t *p
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_xor_rm1632_imm1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
+ result = g_x86_instruction_new(XOP_XOR_RM1632_IMM8);
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
-
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
@@ -327,11 +308,11 @@ asm_x86_instr *x86_read_instr_xor_rm1632_imm1632(const uint8_t *data, off_t *pos
/******************************************************************************
* *
-* 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. *
+* Paramètres : data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des 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). *
* *
@@ -341,20 +322,18 @@ asm_x86_instr *x86_read_instr_xor_rm1632_imm1632(const uint8_t *data, off_t *pos
* *
******************************************************************************/
-asm_x86_instr *x86_read_instr_xor_rm1632_with_r1632(const uint8_t *data, off_t *pos, off_t len, uint64_t offset, const asm_x86_processor *proc)
+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)
{
- asm_x86_instr *result; /* Instruction à retourner */
+ GArchInstruction *result; /* Instruction à retourner */
AsmOperandSize oprsize; /* Taille des opérandes */
- result = (asm_x86_instr *)calloc(1, sizeof(asm_x86_instr));
-
- oprsize = switch_x86_operand_size_if_needed(proc, data, pos);
+ result = g_x86_instruction_new(XOP_XOR_RM1632_R1632);
- ASM_INSTRUCTION(result)->opcode = data[(*pos)++];
+ 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))
{
- free(result);
+ /* TODO free(result);*/
return NULL;
}
diff --git a/src/arch/x86/opcodes.h b/src/arch/x86/opcodes.h
index c16b9be..212d1bc 100644
--- a/src/arch/x86/opcodes.h
+++ b/src/arch/x86/opcodes.h
@@ -25,281 +25,325 @@
#define _ARCH_X86_OPCODES_H
-#include <stdint.h>
-#include <sys/types.h>
-
-
#include "processor.h"
#include "instruction.h"
-/* Décode une instruction de type 'adc' (16 ou 32 bits). */
-asm_x86_instr *x86_read_instr_adc_imm8_to_rm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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). */
-asm_x86_instr *x86_read_instr_adc_rm8_r8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_adc_rm1632_imm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_add_al_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_add_e_ax_imm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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' (16 ou 32 bits). */
-asm_x86_instr *x86_read_instr_add_imm8_to_rm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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). */
-asm_x86_instr *x86_read_instr_add_r8_rm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_add_r1632_rm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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' (8 bits). */
-asm_x86_instr *x86_read_instr_add_rm8_r8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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). */
-asm_x86_instr *x86_read_instr_add_rm1632_imm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_add_rm1632_r1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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' (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). */
-asm_x86_instr *x86_read_instr_and_rm8_r8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_and_rm1632_with_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_and_rm1632_imm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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 'call'. */
-asm_x86_instr *x86_read_instr_call_rel1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_call_rm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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'. */
-asm_x86_instr *x86_read_instr_cld(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
-
-/* Décode une instruction de type 'cmp' (8 bits). */
-asm_x86_instr *x86_read_instr_cmp_rm8_with_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_cmp_rm1632_with_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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' (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). */
-asm_x86_instr *x86_read_instr_cmp_rm1632_imm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_cmp_rm1632_with_r1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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 'dec'. */
-asm_x86_instr *x86_read_instr_dec_r1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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 'hlt'. */
-asm_x86_instr *x86_read_instr_hlt(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+GArchInstruction *x86_read_instr_hlt(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-/* Décode une instruction de type 'inc'. */
-asm_x86_instr *x86_read_instr_inc_r1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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 'int'. */
+GArchInstruction *x86_read_instr_int(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
/* Décode une instruction de type 'int 3'. */
-asm_x86_instr *x86_read_instr_int_3(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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'. */
-asm_x86_instr *x86_read_instr_int(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* Décode une instruction de type 'ja' (saut 8b si supérieur). */
+GArchInstruction *x86_read_instr_ja_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
/* Décode une instruction de type 'jb' (saut 8b si inférieur). */
-asm_x86_instr *x86_read_instr_jb_rel8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+GArchInstruction *x86_read_instr_jb_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-/* Décode une instruction de type 'je' (petit saut). */
-asm_x86_instr *x86_read_instr_je_8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* Décode une instruction de type 'je' (saut 8b si égal). */
+GArchInstruction *x86_read_instr_je_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
/* Décode une instruction de type 'jg' (saut 8b si supérieur). */
-asm_x86_instr *x86_read_instr_jg_rel8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+GArchInstruction *x86_read_instr_jg_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'jl' (saut 8b si inférieur). */
+GArchInstruction *x86_read_instr_jl_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'jna' (saut 8b si !supérieur). */
+GArchInstruction *x86_read_instr_jna_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
/* Décode une instruction de type 'jnb' (saut 8b si !inférieur). */
-asm_x86_instr *x86_read_instr_jnb_rel8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+GArchInstruction *x86_read_instr_jnb_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'jne' (saut 8b si !égal). */
+GArchInstruction *x86_read_instr_jne_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'jng' (saut 8b si !supérieur). */
+GArchInstruction *x86_read_instr_jng_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'jnl' (saut 8b si !inférieur). */
+GArchInstruction *x86_read_instr_jnl_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'jno' (saut 8b si !débordemt). */
+GArchInstruction *x86_read_instr_jno_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'jnp' (saut 8b si !parité). */
+GArchInstruction *x86_read_instr_jnp_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'jns' (saut 8b si !signée). */
+GArchInstruction *x86_read_instr_jns_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-/* Décode une instruction de type 'jne' (petit saut). */
-asm_x86_instr *x86_read_instr_jne_8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* Décode une instruction de type 'jo' (saut 8b si débordement). */
+GArchInstruction *x86_read_instr_jo_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'jp' (saut 8b si parité). */
+GArchInstruction *x86_read_instr_jp_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
+
+/* Décode une instruction de type 'js' (saut 8b si signée). */
+GArchInstruction *x86_read_instr_js_rel8(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
/* Décode une instruction de type 'jump' (petit saut). */
-asm_x86_instr *x86_read_instr_jmp_8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_jmp_rel1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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' (saut en mémoire). */
-asm_x86_instr *x86_read_instr_jmp_rm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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). */
-asm_x86_instr *x86_read_instr_lea(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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'. */
-asm_x86_instr *x86_read_instr_leave(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_mov_al_to_moffs8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_mov_e_ax_to_moffs1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
-
-/* Décode une instruction de type 'mov' (8 bits). */
-asm_x86_instr *x86_read_instr_mov_imm8_to_rm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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' (16 ou 32 bits). */
-asm_x86_instr *x86_read_instr_mov_imm1632_to_r1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_mov_imm1632_to_rm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
-
-/* Décode une instruction de type 'mov al, ...' (8 bits). */
-asm_x86_instr *x86_read_instr_mov_moffs8_to_al(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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 [e]ax, ...' (16/32 bits). */
-asm_x86_instr *x86_read_instr_mov_moffs1632_to_e_ax(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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). */
-asm_x86_instr *x86_read_instr_mov_r1632_to_rm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_mov_rm1632_to_r1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_mov_rm8_r8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
-
-/* Décode une instruction de type 'movsx' (8 bits). */
-asm_x86_instr *x86_read_instr_movsx_r1632_rm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
-
-/* Décode une instruction de type 'movzx' (8 bits). */
-asm_x86_instr *x86_read_instr_movzx_r1632_rm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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 'nop'. */
-asm_x86_instr *x86_read_instr_nop(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+GArchInstruction *x86_read_instr_nop(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
/* Décode une instruction de type 'not' (16 ou 32 bits). */
-asm_x86_instr *x86_read_instr_not_rm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_or_al_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_or_r8_rm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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' (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). */
-asm_x86_instr *x86_read_instr_or_rm1632_with_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_or_rm1632_imm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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 'pop' (16 ou 32 bits). */
-asm_x86_instr *x86_read_instr_pop_r1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_push_imm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_push_r1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_push_rm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_rcl_rm1632_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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). */
-asm_x86_instr *x86_read_instr_rcr_rm1632_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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 'ret'. */
-asm_x86_instr *x86_read_instr_ret(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+GArchInstruction *x86_read_instr_ret(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
-/* Décode une instruction de type 'rol' (8 bits). */
-asm_x86_instr *x86_read_instr_rol_rm1632_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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). */
-asm_x86_instr *x86_read_instr_ror_rm1632_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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). */
+/* 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). */
-asm_x86_instr *x86_read_instr_sar_rm1632_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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'. */
-asm_x86_instr *x86_read_instr_sbb_rm1632_with_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_sbb_rm1632_imm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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 'shl'. */
-asm_x86_instr *x86_read_instr_shl_rm1632_cl(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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' (8 bits). */
-asm_x86_instr *x86_read_instr_shl_rm1632_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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). */
-asm_x86_instr *x86_read_instr_shr_rm1632_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+/* 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 'sub al, ...' (8 bits). */
-asm_x86_instr *x86_read_instr_sub_al_with_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_sub_e_ax_with_imm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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' (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'. */
-asm_x86_instr *x86_read_instr_sub_imm8_from_rm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_sub_r1632_from_rm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
-
-/* Décode une instruction de type 'sub' (8 bits). */
-asm_x86_instr *x86_read_instr_sub_r8_rm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_sub_rm1632_imm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_test_al(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_test_e_ax(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_test_rm8_with_r8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_test_rm1632_with_r1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_xor_al_with_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_xor_e_ax_with_imm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_xor_rm8_with_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_xor_r8_with_rm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
-
-/* Décode une instruction de type 'xor' (16 ou 32 bits). */
-asm_x86_instr *x86_read_instr_xor_r1632_with_rm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_xor_rm8_with_r8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_xor_rm1632_with_imm8(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_xor_rm1632_imm1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+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). */
-asm_x86_instr *x86_read_instr_xor_rm1632_with_r1632(const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
+GArchInstruction *x86_read_instr_xor_rm1632_r1632(const bin_t *, off_t *, off_t, vmpa_t, X86Prefix, const GX86Processor *);
diff --git a/src/arch/x86/operand.c b/src/arch/x86/operand.c
index 38e1468..1424b3e 100644
--- a/src/arch/x86/operand.c
+++ b/src/arch/x86/operand.c
@@ -29,1315 +29,868 @@
#include <stdio.h>
+#include "registers.h"
+#include "../immediate.h"
#include "../operand.h"
#include "../operand-int.h"
+#include "../../common/extstr.h"
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
+/* ---------------------- COQUILLE VIDE POUR LES OPERANDES X86 ---------------------- */
-
-/* Liste des registres 8 bits */
-typedef enum _X868bRegister
+/* Définition d'un opérande de la x86 (instance) */
+struct _GX86Operand
{
- X86_REG8_AL = 0, /* Registre AL */
- X86_REG8_CL = 1, /* Registre AL */
- X86_REG8_DL = 2, /* Registre AL */
- X86_REG8_BL = 3, /* Registre AL */
- X86_REG8_AH = 4, /* Registre AH */
- X86_REG8_CH = 5, /* Registre AH */
- X86_REG8_DH = 6, /* Registre AH */
- X86_REG8_BH = 7, /* Registre AH */
+ GArchOperand parent; /* Instance parente */
- X86_REG8_NONE /* Aucun registre */
+};
-} X868bRegister;
-/* Liste des registres 16 bits */
-typedef enum _X8616bRegister
+/* Définition d'un opérande de la x86 (classe) */
+struct _GX86OperandClass
{
- X86_REG16_AX = 0, /* Registre AX */
- X86_REG16_CX = 1, /* Registre AX */
- X86_REG16_DX = 2, /* Registre AX */
- X86_REG16_BX = 3, /* Registre AX */
- X86_REG16_SP = 4, /* Registre SP */
- X86_REG16_BP = 5, /* Registre BP */
- X86_REG16_SI = 6, /* Registre SI */
- X86_REG16_DI = 7, /* Registre DI */
+ GArchOperandClass parent; /* Classe parente */
- X86_REG16_NONE /* Aucun registre */
+};
-} X8616bRegister;
-/* Liste des registres 32 bits */
-typedef enum _X8632bRegister
-{
- X86_REG32_EAX = 0, /* Registre EAX */
- X86_REG32_ECX = 1, /* Registre EAX */
- X86_REG32_EDX = 2, /* Registre EAX */
- X86_REG32_EBX = 3, /* Registre EAX */
- X86_REG32_ESP = 4, /* Registre ESP */
- X86_REG32_EBP = 5, /* Registre EBP */
- X86_REG32_ESI = 6, /* Registre ESI */
- X86_REG32_EDI = 7, /* Registre EDI */
+/* Initialise la classe des opérandes x86 de base. */
+static void g_x86_operand_class_init(GX86OperandClass *);
- X86_REG32_NONE /* Aucun registre */
+/* Initialise une instance d'opérande de base pour la x86. */
+static void g_x86_operand_init(GX86Operand *);
-} X8632bRegister;
-/* Registre X86 */
-typedef union _x86_register
-{
- X868bRegister reg8; /* Registre 8 bits */
- X8616bRegister reg16; /* Registre 16 bits */
- X8632bRegister reg32; /* Registre 32 bits */
+/* ------------------------ OPERANDES VISANT UN REGISTRE X86 ------------------------ */
+
-} x86_register;
+/* Définition d'un opérande visant un registre x86 (instance) */
+struct _GX86RegisterOperand
+{
+ GX86Operand parent; /* Instance parente */
+ x86_register *reg; /* Registre représenté */
+};
-/* Définition d'une opérande x86 */
-struct _asm_x86_operand
+/* Définition d'un opérande visant un registre x86 (classe) */
+struct _GX86RegisterOperandClass
{
- asm_operand base; /* A laisser en premier */
+ GX86OperandClass parent; /* Classe parente */
- x86_register rindex; /* Registre servant d'indice */
+};
- bool content; /* Contenu d'un registre */
- uint8_t scale; /* Puissance de deux */
- x86_register rbase; /* Registre de base */
- asm_operand *displacement; /* Décallage supplémentaire */
+/* 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 *);
+/* Traduit un opérande en version humainement lisible. */
+static char *g_x86_register_operand_get_text(const GX86RegisterOperand *, const exe_format *, AsmSyntax);
-#define NULL ((void *)0)
+/* ----------------------- OPERANDES COMPLEXES DE TYPE MOD/RM ----------------------- */
-/* Récupère l'indentifiant interne d'un registre. */
-bool get_x86_register(x86_register *, AsmOperandSize, uint8_t);
+/* Définition d'un opérande x86 de type ModRM (instance) */
+struct _GX86ModRMOperand
+{
+ GX86Operand parent; /* Instance parente */
+ uint8_t scale; /* Puissance de deux */
+ x86_register *index; /* Registre servant d'indice */
+ x86_register *base; /* Registre de base */
+ GImmOperand *displacement; /* Décallage supplémentaire */
-/* Traduit une opérande de registre en texte. */
-void _x86_print_reg_operand(const x86_register *reg, AsmOperandSize, char *, size_t, AsmSyntax);
+};
+/* Définition d'un opérande x86 de type ModRM (classe) */
+struct _GX86ModRMOperandClass
+{
+ GX86OperandClass parent; /* Classe parente */
+};
-/* Crée une opérande renvoyant vers un registre 16 ou 32 bits. */
-asm_x86_operand *x86_create_r1632_operand_from_opcode(uint8_t, bool, uint8_t);
+/* 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 *);
+/* Traduit un opérande en version humainement lisible. */
+static char *g_x86_mod_rm_operand_get_text(const GX86ModRMOperand *, const exe_format *, AsmSyntax);
-/******************************************************************************
-* *
-* Paramètres : - *
-* *
-* Description : Crée une opérande vierge pour x86. *
-* *
-* Retour : Opérande nouvellement créée. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
+/* ------------------------- OPERANDES D'ADRESSES RELATIVES ------------------------- */
-asm_x86_operand *create_new_x86_operand(void)
+
+/* Définition d'un opérande x86 d'adresse relative (instance) */
+struct _GX86RelativeOperand
{
- asm_x86_operand *result; /* Structure à retourner */
+ GX86Operand parent; /* Instance parente */
- result = (asm_x86_operand *)calloc(1, sizeof(asm_x86_operand));
+ GImmOperand *immediate; /* Adresse visée reconstituée */
- result->scale = 0;
- result->rbase.reg32 = X86_REG32_NONE;
+};
- return result;
+/* 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 *);
+/* Traduit un opérande en version humainement lisible. */
+static char *g_x86_relative_operand_get_text(const GX86RelativeOperand *, const exe_format *, AsmSyntax);
-/******************************************************************************
-* *
-* Paramètres : reg = registre à définir. [OUT] *
-* size = indique la taille du registre. *
-* value = valeur correspondant au registre. *
-* *
-* Description : Récupère l'indentifiant interne d'un registre. *
-* *
-* Retour : true si la définition est opérée, false sinon. *
-* *
-* Remarques : -  *
-* *
-******************************************************************************/
+/* ------------------------ OPERANDES D'EMPLACEMENTS MEMOIRE ------------------------ */
+
-bool get_x86_register(x86_register *reg, AsmOperandSize size, uint8_t value)
+/* Définition d'un opérande visant un emplacement mémoire x86 (instance) */
+struct _GX86MOffsOperand
{
- switch (size)
- {
- case AOS_8_BITS:
- switch (value)
- {
- case 0 ... 7:
- reg->reg8 = (X868bRegister)value;
- break;
- default:
- return false;
- break;
- }
- break;
+ GX86Operand parent; /* Instance parente */
- case AOS_16_BITS:
- switch (value)
- {
- case 0 ... 7:
- reg->reg16 = (X8616bRegister)value;
- break;
- default:
- return false;
- break;
- }
- break;
+ GImmOperand *offset; /* Adresse mémoire visée */
- case AOS_32_BITS:
- switch (value)
- {
- case 0 ... 7:
- reg->reg32 = (X8632bRegister)value;
- break;
- default:
- return false;
- break;
- }
- break;
+};
- case AOS_64_BITS:
- return false;
- break;
+/* Définition d'un opérande visant un emplacement mémoire x86 (classe) */
+struct _GX86MOffsOperandClass
+{
+ GX86OperandClass parent; /* Classe parente */
- }
+};
- return true;
-}
+/* 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 *);
+
+/* Traduit un opérande en version humainement lisible. */
+static char *g_x86_moffs_operand_get_text(const GX86MOffsOperand *, const exe_format *, AsmSyntax);
+/* ---------------------------------------------------------------------------------- */
+/* 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 : data = donnée à analyser. *
-* is_reg32 = indique si le registre est un registre 32 bits. *
-* base = valeur du premier registre. *
+* Paramètres : klass = classe à initialiser. *
* *
-* Description : Crée une opérande renvoyant vers un registre 16 ou 32 bits. *
+* Description : Initialise la classe des opérandes x86 de base. *
* *
-* Retour : Opérande mise en place ou NULL. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-asm_x86_operand *x86_create_reg1632_operand(uint8_t data, bool is_reg32, uint8_t base)
+static void g_x86_operand_class_init(GX86OperandClass *klass)
{
- asm_x86_operand *result; /* Registre à retourner */
-
- result = create_new_x86_operand();
-
- ASM_OPERAND(result)->type = AOT_REG;
- ASM_OPERAND(result)->size = (is_reg32 ? AOS_32_BITS : AOS_16_BITS);
-
- if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, data - base))
- {
- free(result);
- return NULL;
- }
-
- return result;
}
/******************************************************************************
* *
-* Paramètres : data = donnée à analyser. *
-* is_reg32 = indique si le registre est un registre 32 bits. *
-* first = indique la partie du ModR/M à traiter. *
+* Paramètres : operand = instance à initialiser. *
* *
-* Description : Crée une opérande renvoyant vers un registre 16 ou 32 bits. *
+* Description : Initialise une instance d'opérande de registre x86. *
* *
-* Retour : Opérande mise en place ou NULL. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-asm_x86_operand *x86_create_reg1632_operand_from_modrm(uint8_t data, bool is_reg32, bool first)
+static void g_x86_operand_init(GX86Operand *operand)
{
- asm_x86_operand *result; /* Registre à retourner */
- uint8_t reg; /* Transcription du registre */
- if (first) reg = data & 0x07;
- else reg = (data & 0x38) >> 3;
+}
- result = create_new_x86_operand();
- ASM_OPERAND(result)->type = AOT_REG;
- ASM_OPERAND(result)->size = (is_reg32 ? AOS_32_BITS : AOS_16_BITS);
- if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, reg))
- {
- free(result);
- return NULL;
- }
+/* ---------------------------------------------------------------------------------- */
+/* OPERANDES VISANT UN REGISTRE X86 */
+/* ---------------------------------------------------------------------------------- */
- return result;
-}
+/* 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 : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* is_reg32 = indique si le registre est un registre 32 bits. *
-* first = indique la partie du ModR/M à traiter. *
+* Paramètres : klass = classe à initialiser. *
* *
-* Description : Crée une opérande renvoyant vers un contenu 16 ou 32 bits. *
+* Description : Initialise la classe des opérandes de registre x86. *
* *
-* Retour : Opérande mise en place ou NULL. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-asm_x86_operand *x86_create_content1632_operand(const uint8_t *data, off_t *pos, off_t len, bool is_reg32, bool first)
+static void g_x86_register_operand_class_init(GX86RegisterOperandClass *klass)
{
- asm_x86_operand *result; /* Registre à retourner */
- uint8_t mod; /* Modificateur présent */
- /* Pas de contenu */
- mod = (data[*pos] & 0xc0);
- if (mod == 0xc0) return NULL;
-
- result = x86_create_reg1632_operand_from_modrm(data[*pos], is_reg32, first);
- if (result == NULL) return NULL;
-
- result->content = true;
-
- (*pos)++;
+}
- /* Vieille astuce de l'emplacement mémoire fixe ? */
- if (result->rindex.reg32 == X86_REG32_EBP && mod == 0x00)
- {
- free(result);
- result = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(result), AOS_32_BITS/* FIXME ? */, data, pos, len))
- {
- (*pos)--;
- free(result);
- return NULL;
- }
+/******************************************************************************
+* *
+* Paramètres : operand = instance à initialiser. *
+* *
+* Description : Initialise une instance d'opérande de registre x86. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
- return result;
+static void g_x86_register_operand_init(GX86RegisterOperand *operand)
+{
+ GArchOperand *parent; /* Instance parente */
- }
+ parent = G_ARCH_OPERAND(operand);
- /* A la recherche d'un SIB */
- if (result->rindex.reg32 == X86_REG32_ESP)
- {
- if (!get_x86_register(&result->rbase, ASM_OPERAND(result)->size, data[*pos] & 0x07))
- {
- (*pos)--;
- free(result);
- return NULL;
- }
+ parent->get_text = (get_operand_text_fc)g_x86_register_operand_get_text;
- if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, (data[*pos] & 0x38) >> 3))
- {
- (*pos)--;
- free(result);
- return NULL;
- }
+}
- result->scale = ((data[*pos] & 0xc0) >> 6);
- if (result->rindex.reg32 == X86_REG32_ESP)
- {
- result->rindex.reg32 = result->rbase.reg32;
- result->rbase.reg32 = X86_REG32_NONE;
- }
+/******************************************************************************
+* *
+* 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 : - *
+* *
+******************************************************************************/
- (*pos)++;
+GArchOperand *g_x86_register_operand_new_from_opcode(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size, bin_t base)
+{
+ GX86RegisterOperand *result; /* Structure à retourner */
+ x86_register *reg; /* Registre lu */
- }
+ reg = get_x86_register(size, data[*pos] - base);
- /* Décallage supplémentaire ? */
- switch (mod)
+ if (reg != NULL)
{
- case 0x00:
- if (result->rbase.reg32 == X86_REG32_EBP)
- {
- result->rbase.reg32 = X86_REG32_NONE;
+ (*pos)++;
- result->displacement = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(result->displacement), ASM_OPERAND(result)->size, data, pos, len))
- {
- (*pos) -= 2;
- free(result->displacement);
- free(result);
- return NULL;
- }
+ result = g_object_new(G_TYPE_X86_REGISTER_OPERAND, NULL);
- }
- break;
-
- case 0x40:
- result->displacement = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(result->displacement), AOS_8_BITS_SIGNED, data, pos, len))
- {
- (*pos) -= 2;
- free(result->displacement);
- free(result);
- return NULL;
- }
- break;
-
- case 0x80:
- result->displacement = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(result->displacement), AOS_32_BITS_SIGNED, data, pos, len))
- {
- (*pos) -= 2;
- free(result->displacement);
- free(result);
- return NULL;
- }
- break;
+ result->reg = reg;
}
+ else result = NULL;
- return result;
+ return G_ARCH_OPERAND(result);
}
-
-
-
/******************************************************************************
* *
-* Paramètres : data = donnée à analyser. *
+* 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 une opérande renvoyant vers un registre 8 bits. *
+* Description : Crée un opérande visant un registre X86. *
* *
-* Retour : Opérande mise en place ou NULL. *
+* Retour : Opérande mis en place. *
* *
* Remarques : - *
* *
******************************************************************************/
-asm_x86_operand *x86_create_r8_operand(uint8_t data, bool first)
+GArchOperand *g_x86_register_operand_new_from_mod_rm(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size, bool first)
{
- asm_x86_operand *result; /* Registre à retourner */
- uint8_t reg; /* Transcription du registre */
+ GX86RegisterOperand *result; /* Structure à retourner */
+ bin_t index; /* Registre lu */
+ x86_register *reg; /* Registre créé */
- if (first) reg = data & 0x07;
- else reg = (data & 0x38) >> 3;
+ if (first) index = data[*pos] & 0x07;
+ else index = (data[*pos] & 0x38) >> 3;
- result = create_new_x86_operand();
+ reg = get_x86_register(size, index);
- ASM_OPERAND(result)->type = AOT_REG;
- ASM_OPERAND(result)->size = AOS_8_BITS;
-
- if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, reg))
+ if (reg != NULL)
{
- free(result);
- return NULL;
+ (*pos)++;
+
+ result = g_object_new(G_TYPE_X86_REGISTER_OPERAND, NULL);
+
+ result->reg = reg;
+
}
+ else result = NULL;
- return result;
+ 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. *
+* Paramètres : index = indice du registre visé. *
+* size = taille de l'opérande, et donc du registre. *
* *
-* Description : Crée une opérande à partir d'un registre/une mémoire 8 bits. *
+* Description : Crée un opérande visant un registre X86 donnée. *
* *
-* Retour : Opérande mise en place ou NULL. *
+* Retour : Opérande mis en place. *
* *
* Remarques : - *
* *
******************************************************************************/
-asm_x86_operand *x86_create_rm8_operand(const uint8_t *data, off_t *pos, off_t len, ...)
+GArchOperand *g_x86_register_operand_new_from_index(bin_t index, AsmOperandSize size)
{
- asm_x86_operand *result; /* Registre à retourner */
- uint8_t mod; /* Modificateur présent */
-
- /* Registre simple... */
+ GX86RegisterOperand *result; /* Structure à retourner */
+ x86_register *reg; /* Registre lu */
- result = x86_create_r8_operand(data[*pos], true);
- if (result == NULL) return NULL;
+ reg = get_x86_register(size, index);
- mod = (data[*pos] & 0xc0);
-
- (*pos)++;
-
- if (mod == 0xc0) return result;
-
- result->content = true;
-
- /* Vieille astuce de l'emplacement mémoire fixe ? */
- if (result->rindex.reg8 == X86_REG8_CH && mod == 0x00)
+ if (reg != NULL)
{
- free(result);
+ result = g_object_new(G_TYPE_X86_REGISTER_OPERAND, NULL);
- result = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(result), AOS_32_BITS/* FIXME! 16/32 */, data, pos, len))
- {
- free(result);
- return NULL;
- }
-
- return result;
+ result->reg = reg;
}
+ else result = NULL;
- /* A la recherche d'un SIB */
- if (result->rindex.reg8 == X86_REG8_AH)
- {
- if (!get_x86_register(&result->rbase, ASM_OPERAND(result)->size, data[*pos] & 0x07))
- {
- free(result);
- return NULL;
- }
+ return G_ARCH_OPERAND(result);
- if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, (data[*pos] & 0x38) >> 3))
- {
- free(result);
- return NULL;
- }
-
- result->scale = ((data[*pos] & 0xc0) >> 6);
+}
- if (result->rindex.reg8 == X86_REG8_AH)
- {
- result->rindex.reg8 = result->rbase.reg8;
- result->rbase.reg8 = X86_REG8_NONE;
- }
- (*pos)++;
+/******************************************************************************
+* *
+* Paramètres : operand = opérande à traiter. *
+* format = format du binaire manipulé. *
+* syntax = type de représentation demandée. *
+* *
+* Description : Traduit un opérande en version humainement lisible. *
+* *
+* Retour : Chaîne de caractères à libérer de la mémoire. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
- }
+static char *g_x86_register_operand_get_text(const GX86RegisterOperand *operand, const exe_format *format, AsmSyntax syntax)
+{
+ char *result; /* Chaîne à retourner */
- /* Décallage supplémentaire ? */
- switch (mod)
- {
- case 0x00:
- if (result->rbase.reg8 == X86_REG8_CH)
- {
- result->rbase.reg8 = X86_REG8_NONE;
+ result = x86_register_as_text(operand->reg, syntax);
- result->displacement = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(result->displacement), ASM_OPERAND(result)->size, data, pos, len))
- {
- free(result->displacement);
- free(result);
- return NULL;
- }
+ return result;
- }
- break;
+}
- case 0x40:
- result->displacement = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(result->displacement), AOS_8_BITS_SIGNED, data, pos, len))
- {
- free(result->displacement);
- free(result);
- return NULL;
- }
- break;
- case 0x80:
- result->displacement = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(result->displacement), AOS_32_BITS/* FIXME ! 16/32 */, data, pos, len))
- {
- free(result->displacement);
- free(result);
- return NULL;
- }
- break;
- }
+/* ---------------------------------------------------------------------------------- */
+/* OPERANDES COMPLEXES DE TYPE MOD/RM */
+/* ---------------------------------------------------------------------------------- */
- return result;
-}
+/* 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 : data = donnée à analyser. *
-* is_reg32 = indique si le registre est un registre 32 bits. *
-* first = indique la partie du ModR/M à traiter. *
+* Paramètres : klass = classe à initialiser. *
* *
-* Description : Crée une opérande renvoyant vers un registre 16 ou 32 bits. *
+* Description : Initialise la classe des opérandes x86 de type ModRM. *
* *
-* Retour : Opérande mise en place ou NULL. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-asm_x86_operand *x86_create_r1632_operand(uint8_t data, bool is_reg32, bool first)
+static void g_x86_mod_rm_operand_class_init(GX86ModRMOperandClass *klass)
{
- asm_x86_operand *result; /* Registre à retourner */
- uint8_t reg; /* Transcription du registre */
-
- if (first) reg = data & 0x07;
- else reg = (data & 0x38) >> 3;
-
- result = create_new_x86_operand();
-
- ASM_OPERAND(result)->type = AOT_REG;
- ASM_OPERAND(result)->size = (is_reg32 ? AOS_32_BITS : AOS_16_BITS);
-
- if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, reg))
- {
- free(result);
- return NULL;
- }
-
- return result;
}
/******************************************************************************
* *
-* Paramètres : data = donnée à analyser. *
-* is_reg32 = indique si le registre est un registre 32 bits. *
-* base = valeur du premier registre. *
+* Paramètres : operand = instance à initialiser. *
* *
-* Description : Crée une opérande renvoyant vers un registre 16 ou 32 bits. *
+* Description : Initialise une instance d'opérande x86 de type ModRM. *
* *
-* Retour : Opérande mise en place ou NULL. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-asm_x86_operand *x86_create_r1632_operand_from_opcode(uint8_t data, bool is_reg32, uint8_t base)
+static void g_x86_mod_rm_operand_init(GX86ModRMOperand *operand)
{
- asm_x86_operand *result; /* Registre à retourner */
-
- result = create_new_x86_operand();
+ GArchOperand *parent; /* Instance parente */
- ASM_OPERAND(result)->type = AOT_REG;
- ASM_OPERAND(result)->size = (is_reg32 ? AOS_32_BITS : AOS_16_BITS);
+ parent = G_ARCH_OPERAND(operand);
- if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, data - base))
- {
- free(result);
- return NULL;
- }
-
- return result;
+ parent->get_text = (get_operand_text_fc)g_x86_mod_rm_operand_get_text;
}
/******************************************************************************
* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* is_reg32 = indique si le registre est un registre 32 bits. *
+* 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 une opérande à partir d'un registre/une mémoire 16/32b. *
+* Description : Crée un opérande x86 de type ModRM. *
* *
-* Retour : Opérande mise en place ou NULL. *
+* Retour : Opérande mis en place. *
* *
* Remarques : - *
* *
******************************************************************************/
-asm_x86_operand *x86_create_rm1632_operand(const uint8_t *data, off_t *pos, off_t len, bool is_reg32, ...)
+GArchOperand *g_x86_mod_rm_operand_new(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size)
{
- asm_x86_operand *result; /* Registre à retourner */
+ GX86ModRMOperand *result; /* Structure à retourner */
uint8_t mod; /* Modificateur présent */
-
- /* Registre simple... */
-
- result = x86_create_r1632_operand(data[*pos], is_reg32, true);
- if (result == NULL) return NULL;
+ x86_register *reg; /* Registre lu */
mod = (data[*pos] & 0xc0);
- (*pos)++;
+ if (mod == 0xc0)
+ return g_x86_register_operand_new_from_mod_rm(data, pos, len, size, true);
- if (mod == 0xc0) return result;
+ reg = get_x86_register(size, data[*pos] & 0x07);
+ if (reg == NULL) return NULL;
- result->content = true;
+ (*pos)++;
/* Vieille astuce de l'emplacement mémoire fixe ? */
- if (result->rindex.reg32 == X86_REG32_EBP && mod == 0x00)
- {
- free(result);
-
- result = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(result), AOS_32_BITS/* FIXME ? */, data, pos, len))
- {
- free(result);
- return NULL;
- }
+ if (is_x86_register_base_pointer(reg) && mod == 0x00)
+ return g_imm_operand_new_from_data(MDS_32_BITS/* FIXME */, data, pos, len, SRE_LITTLE);
- return result;
-
- }
+ result = g_object_new(G_TYPE_X86_MOD_RM_OPERAND, NULL);
/* A la recherche d'un SIB */
- if (result->rindex.reg32 == X86_REG32_ESP)
+ if (is_x86_register_stack_pointer(reg))
{
- if (!get_x86_register(&result->rbase, ASM_OPERAND(result)->size, data[*pos] & 0x07))
- {
- free(result);
- return NULL;
- }
+ free_x86_register(reg);
- if (!get_x86_register(&result->rindex, ASM_OPERAND(result)->size, (data[*pos] & 0x38) >> 3))
- {
- free(result);
- return NULL;
- }
+ result->base = get_x86_register(size, data[*pos] & 0x07);
+ if (result->base == NULL) goto gxmron_error;
+
+ result->index = get_x86_register(size, (data[*pos] & 0x38) >> 3);
+ if (result->base == NULL) goto gxmron_error;
result->scale = ((data[*pos] & 0xc0) >> 6);
- if (result->rindex.reg32 == X86_REG32_ESP)
+ if (is_x86_register_stack_pointer(result->index))
{
- result->rindex.reg32 = result->rbase.reg32;
- result->rbase.reg32 = X86_REG32_NONE;
+ result->index = result->base;
+ free_x86_register(result->base);
+ result->base = NULL;
}
(*pos)++;
}
+ else result->index = reg;
+
/* Décallage supplémentaire ? */
switch (mod)
{
case 0x00:
- if (result->rbase.reg32 == X86_REG32_EBP)
+ if (result->base != NULL && is_x86_register_base_pointer(result->base))
{
- result->rbase.reg32 = X86_REG32_NONE;
+ free_x86_register(result->base);
+ result->base = NULL;
- result->displacement = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(result->displacement), ASM_OPERAND(result)->size, data, pos, len))
- {
- free(result->displacement);
- free(result);
- return NULL;
- }
+ result->displacement = g_imm_operand_new_from_data(size/* FIXME : !convert mds/aos */, data, pos, len, SRE_LITTLE);
+ if (result->displacement == NULL) goto gxmron_error;
}
break;
case 0x40:
- result->displacement = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(result->displacement), AOS_8_BITS_SIGNED, data, pos, len))
- {
- free(result->displacement);
- free(result);
- return NULL;
- }
+ result->displacement = g_imm_operand_new_from_data(MDS_8_BITS_SIGNED, data, pos, len, SRE_LITTLE);
+ if (result->displacement == NULL) goto gxmron_error;
break;
case 0x80:
- result->displacement = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(result->displacement), AOS_32_BITS_SIGNED, data, pos, len))
- {
- free(result->displacement);
- free(result);
- return NULL;
- }
+ result->displacement = g_imm_operand_new_from_data(MDS_32_BITS_SIGNED/* FIXME ! 16/32 */, data, pos, len, SRE_LITTLE);
+ if (result->displacement == NULL) goto gxmron_error;
break;
}
- return result;
-
-}
-
-
-
-
-
-
-
-
+ return G_ARCH_OPERAND(result);
+ gxmron_error:
-
-
-/******************************************************************************
-* *
-* Paramètres : reg = registre à imprimer. *
-* size = indique la taille du registre. *
-* buffer = tampon de sortie mis à disposition. [OUT] *
-* len = taille de ce tampon. *
-* syntax = type de représentation demandée. *
-* *
-* Description : Traduit une opérande de registre en texte. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-void _x86_print_reg_operand(const x86_register *reg, AsmOperandSize size, char *buffer, size_t len, AsmSyntax syntax)
-{
- switch (syntax)
- {
- case ASX_INTEL:
- switch (size)
- {
- case AOS_8_BITS:
- switch (reg->reg8)
- {
- case X86_REG8_AL:
- snprintf(buffer, len, "al");
- break;
- case X86_REG8_CL:
- snprintf(buffer, len, "cl");
- break;
- case X86_REG8_DL:
- snprintf(buffer, len, "dl");
- break;
- case X86_REG8_BL:
- snprintf(buffer, len, "bl");
- break;
- case X86_REG8_AH:
- snprintf(buffer, len, "ah");
- break;
- case X86_REG8_CH:
- snprintf(buffer, len, "ch");
- break;
- case X86_REG8_DH:
- snprintf(buffer, len, "dh");
- break;
- case X86_REG8_BH:
- snprintf(buffer, len, "bh");
- break;
- case X86_REG8_NONE:
- /* Ne devrait jamais arriver */
- break;
- }
- break;
-
- case AOS_16_BITS:
- switch (reg->reg16)
- {
- case X86_REG16_AX:
- snprintf(buffer, len, "ax");
- break;
- case X86_REG16_CX:
- snprintf(buffer, len, "cx");
- break;
- case X86_REG16_DX:
- snprintf(buffer, len, "dx");
- break;
- case X86_REG16_BX:
- snprintf(buffer, len, "bx");
- break;
- case X86_REG16_SP:
- snprintf(buffer, len, "sp");
- break;
- case X86_REG16_BP:
- snprintf(buffer, len, "bp");
- break;
- case X86_REG16_SI:
- snprintf(buffer, len, "si");
- break;
- case X86_REG16_DI:
- snprintf(buffer, len, "di");
- break;
- case X86_REG16_NONE:
- /* Ne devrait jamais arriver */
- break;
- }
- break;
-
- case AOS_32_BITS:
- switch (reg->reg32)
- {
- case X86_REG32_EAX:
- snprintf(buffer, len, "eax");
- break;
- case X86_REG32_ECX:
- snprintf(buffer, len, "ecx");
- break;
- case X86_REG32_EDX:
- snprintf(buffer, len, "edx");
- break;
- case X86_REG32_EBX:
- snprintf(buffer, len, "ebx");
- break;
- case X86_REG32_ESP:
- snprintf(buffer, len, "esp");
- break;
- case X86_REG32_EBP:
- snprintf(buffer, len, "ebp");
- break;
- case X86_REG32_ESI:
- snprintf(buffer, len, "esi");
- break;
- case X86_REG32_EDI:
- snprintf(buffer, len, "edi");
- break;
- case X86_REG32_NONE:
- /* Ne devrait jamais arriver */
- break;
- }
- break;
-
- case AOS_64_BITS:
- break;
-
- }
- break;
-
- case ASX_ATT:
- switch (size)
- {
- case AOS_8_BITS:
- switch (reg->reg8)
- {
- case X86_REG8_AL:
- snprintf(buffer, len, "%%al");
- break;
- case X86_REG8_CL:
- snprintf(buffer, len, "%%cl");
- break;
- case X86_REG8_DL:
- snprintf(buffer, len, "%%dl");
- break;
- case X86_REG8_BL:
- snprintf(buffer, len, "%%bl");
- break;
- case X86_REG8_AH:
- snprintf(buffer, len, "%%ah");
- break;
- case X86_REG8_CH:
- snprintf(buffer, len, "%%ch");
- break;
- case X86_REG8_DH:
- snprintf(buffer, len, "%%dh");
- break;
- case X86_REG8_BH:
- snprintf(buffer, len, "%%bh");
- break;
- case X86_REG8_NONE:
- /* Ne devrait jamais arriver */
- break;
- }
- break;
-
- case AOS_16_BITS:
- switch (reg->reg16)
- {
- case X86_REG16_AX:
- snprintf(buffer, len, "%%ax");
- break;
- case X86_REG16_CX:
- snprintf(buffer, len, "%%cx");
- break;
- case X86_REG16_DX:
- snprintf(buffer, len, "%%dx");
- break;
- case X86_REG16_BX:
- snprintf(buffer, len, "%%bx");
- break;
- case X86_REG16_SP:
- snprintf(buffer, len, "%%sp");
- break;
- case X86_REG16_BP:
- snprintf(buffer, len, "%%bp");
- break;
- case X86_REG16_SI:
- snprintf(buffer, len, "%%si");
- break;
- case X86_REG16_DI:
- snprintf(buffer, len, "%%di");
- break;
- case X86_REG16_NONE:
- /* Ne devrait jamais arriver */
- break;
- }
- break;
-
- case AOS_32_BITS:
- switch (reg->reg32)
- {
- case X86_REG32_EAX:
- snprintf(buffer, len, "%%eax");
- break;
- case X86_REG32_ECX:
- snprintf(buffer, len, "%%ecx");
- break;
- case X86_REG32_EDX:
- snprintf(buffer, len, "%%edx");
- break;
- case X86_REG32_EBX:
- snprintf(buffer, len, "%%ebx");
- break;
- case X86_REG32_ESP:
- snprintf(buffer, len, "%%esp");
- break;
- case X86_REG32_EBP:
- snprintf(buffer, len, "%%ebp");
- break;
- case X86_REG32_ESI:
- snprintf(buffer, len, "%%esi");
- break;
- case X86_REG32_EDI:
- snprintf(buffer, len, "%%edi");
- break;
- case X86_REG32_NONE:
- /* Ne devrait jamais arriver */
- break;
- }
- break;
-
- case AOS_64_BITS:
- break;
-
- }
- break;
-
- }
+ /* FIXME free(result);*/
+ return NULL;
}
/******************************************************************************
* *
-* Paramètres : operand = instruction à traiter. *
-* buffer = tampon de sortie mis à disposition. [OUT] *
-* len = taille de ce tampon. *
+* Paramètres : operand = opérande à traiter. *
+* format = format du binaire manipulé. *
* syntax = type de représentation demandée. *
* *
-* Description : Traduit une opérande de registre en texte. *
+* Description : Traduit un opérande en version humainement lisible. *
* *
-* Retour : - *
+* Retour : Chaîne de caractères à libérer de la mémoire. *
* *
* Remarques : - *
* *
******************************************************************************/
-void x86_print_reg_operand(const asm_x86_operand *operand, char *buffer, size_t len, AsmSyntax syntax)
+static char *g_x86_mod_rm_operand_get_text(const GX86ModRMOperand *operand, const exe_format *format, AsmSyntax syntax)
{
- size_t pos; /* Position de traitement */
+ char *result; /* Chaîne à retourner */
+ char *tmp; /* Chaîne de registre */
switch (syntax)
{
case ASX_INTEL:
- if (operand->content)
- {
- strcpy(buffer, "[");
+ result = (char *)calloc(1 + 10 + 2, sizeof(char));
- if (operand->scale > 0)
- snprintf(&buffer[1], len - 1, "%d*", (int)pow(2, operand->scale));
+ strcpy(result, "[");
- pos = strlen(buffer);
+ if (operand->scale > 0)
+ snprintf(&result[1], 12, "%d*", (int)pow(2, operand->scale));
- }
- else pos = 0;
+ tmp = x86_register_as_text(operand->index, syntax);
+ result = stradd(result, tmp);
+ free(tmp);
-
- _x86_print_reg_operand(&operand->rindex, ASM_OPERAND(operand)->size, &buffer[pos], len - pos, syntax);
-
- if (operand->rbase.reg32 != X86_REG32_NONE)
+ if (operand->base != NULL)
{
- strcat(buffer, "+"); /* TODO: n */
- pos = strlen(buffer);
+ result = stradd(result, "+");
- _x86_print_reg_operand(&operand->rbase, ASM_OPERAND(operand)->size, &buffer[pos], len - pos, syntax);
+ tmp = x86_register_as_text(operand->base, syntax);
+ result = stradd(result, tmp);
+ free(tmp);
}
-
if (operand->displacement != NULL)
{
- if (is_imm_operand_negative(operand->displacement)) strcat(buffer, "-");
- else strcat(buffer, "+");
- pos = strlen(buffer);
+ if (g_imm_operand_is_negative(operand->displacement)) result = stradd(result, "-");
+ else result = stradd(result, "+");
- print_imm_operand(operand->displacement, &buffer[pos], len - pos, syntax);
+ tmp = g_arch_operand_get_text(G_ARCH_OPERAND(operand->displacement), format, syntax);
+ result = stradd(result, tmp);
+ free(tmp);
}
-
-
- if (operand->content) strcat(buffer, "]");
+ result = stradd(result, "]");
break;
case ASX_ATT:
+ result = strdup("[modRM]");
break;
}
-}
+ return result;
+}
+/* ---------------------------------------------------------------------------------- */
+/* 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)
+{
-/* ---------------------------------------------------------------------------------- */
-/* OPERANDES D'EMPLACEMENTS MEMOIRE */
-/* ---------------------------------------------------------------------------------- */
+}
/******************************************************************************
* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* Paramètres : operand = instance à initialiser. *
* *
-* Description : Crée une opérande à partir d'un emplacement mémoire 8 bits. *
+* Description : Initialise une instance d'opérande x86 d'adresse relative. *
* *
-* Retour : Opérande mise en place ou NULL. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-asm_x86_operand *x86_create_moffs8_operand(const uint8_t *data, off_t *pos, off_t len)
+static void g_x86_relative_operand_init(GX86RelativeOperand *operand)
{
- asm_x86_operand *result; /* Emplacement à retourner */
-
- result = create_new_x86_operand();
-
- if (!fill_imm_operand(ASM_OPERAND(result), AOS_8_BITS, data, pos, len))
- {
- free(result);
- return NULL;
- }
+ GArchOperand *parent; /* Instance parente */
- ASM_OPERAND(result)->type = AOT_MOFFS;
+ parent = G_ARCH_OPERAND(operand);
- return result;
+ parent->get_text = (get_operand_text_fc)g_x86_relative_operand_get_text;
}
/******************************************************************************
* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* is_reg32 = indique si le registre est un registre 32 bits. *
+* 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 une opérande à partir d'un emplacement mémoire 16/32b. *
+* Description : Crée un opérande X86 d'adresse relative. *
* *
-* Retour : Opérande mise en place ou NULL. *
+* Retour : Opérande mis en place. *
* *
* Remarques : - *
* *
******************************************************************************/
-asm_x86_operand *x86_create_moffs1632_operand(const uint8_t *data, off_t *pos, off_t len, bool is_reg32)
+GArchOperand *g_x86_relative_operand_new(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size, vmpa_t base)
{
- asm_x86_operand *result; /* Emplacement à retourner */
+ GX86RelativeOperand *result; /* Structure à retourner */
+ off_t init_pos; /* Position avant lecture */
+ uint8_t val8; /* Valeur sur 8 bits */
+ uint16_t val16; /* Valeur sur 16 bits */
+ uint32_t val32; /* Valeur sur 32 bits */
+ uint32_t address32; /* Adresse finale visée */
- result = create_new_x86_operand();
+ init_pos = *pos;
- if (!fill_imm_operand(ASM_OPERAND(result), is_reg32 ? AOS_32_BITS : AOS_16_BITS, data, pos, len))
+ switch (size)
{
- free(result);
- return NULL;
+ case AOS_8_BITS_UNSIGNED:
+ read_u8(&val8, data, pos, len, SRE_LITTLE);
+ address32 = val8;
+ break;
+ case AOS_16_BITS_UNSIGNED:
+ read_u16(&val16, data, pos, len, SRE_LITTLE);
+ address32 = val16;
+ break;
+ case AOS_32_BITS_UNSIGNED:
+ read_u32(&val32, data, pos, len, SRE_LITTLE);
+ address32 = val32;
+ break;
+ default:
+ return NULL;
+ break;
}
- ASM_OPERAND(result)->type = AOT_MOFFS;
+ address32 += base + (*pos - init_pos);
- return result;
+ result = g_object_new(G_TYPE_X86_RELATIVE_OPERAND, NULL);
+ result->immediate = g_imm_operand_new_from_value(AOS_32_BITS/*FIXME*/, address32);
+
+ return G_ARCH_OPERAND(result);
}
/******************************************************************************
* *
-* Paramètres : operand = instruction à traiter. *
-* buffer = tampon de sortie mis à disposition. [OUT] *
-* len = taille de ce tampon. *
+* Paramètres : operand = opérande à traiter. *
+* format = format du binaire manipulé. *
* syntax = type de représentation demandée. *
* *
-* Description : Traduit une opérande d'emplacement mémoire en texte. *
+* Description : Traduit un opérande en version humainement lisible. *
* *
-* Retour : - *
+* Retour : Chaîne de caractères à libérer de la mémoire. *
* *
* Remarques : - *
* *
******************************************************************************/
-void x86_print_moffs_operand(const asm_x86_operand *operand, char *buffer, size_t len, AsmSyntax syntax)
+static char *g_x86_relative_operand_get_text(const GX86RelativeOperand *operand, const exe_format *format, AsmSyntax syntax)
{
- switch (syntax)
- {
- case ASX_INTEL:
- if (len > 3)
- {
- strcpy(buffer, "ds:");
- print_imm_operand(ASM_OPERAND(operand), &buffer[3], len - 3, ASX_INTEL);
- }
- break;
+ char *result; /* Chaîne à retourner */
- case ASX_ATT:
- print_imm_operand(ASM_OPERAND(operand), buffer, len, ASX_INTEL);
- break;
+ result = g_arch_operand_get_text(operand->immediate, format, syntax);
- }
+ return result;
}
/* ---------------------------------------------------------------------------------- */
-/* OPERANDES D'ADRESSES RELATIVES */
+/* 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 : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
+* Paramètres : klass = classe à initialiser. *
* *
-* Description : Crée une opérande à partir d'une adresse relative (8 bits). *
+* Description : Initialise la classe des opérandes d'emplacement mémoire x86.*
* *
-* Retour : Opérande mise en place ou NULL. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-asm_x86_operand *x86_create_rel8_operand_in_32b(uint64_t base, const uint8_t *data, off_t *pos, off_t len)
+static void g_x86_moffs_operand_class_init(GX86MOffsOperandClass *klass)
{
- asm_x86_operand *result; /* Emplacement à retourner */
- off_t init_pos; /* Position avant lecture */
- int8_t offset; /* Décallage à appliquer */
- uint32_t address; /* Adresse finale visée */
- result = create_new_x86_operand();
+}
- init_pos = *pos;
- address = base;
- if (!read_imm_value(AOS_8_BITS, data, pos, len, &offset))
- {
- free(result);
- return NULL;
- }
+/******************************************************************************
+* *
+* Paramètres : operand = instance à initialiser. *
+* *
+* Description : Initialise une instance d'opérande d'emplacement mémoire x86.*
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
- address = base + (*pos - init_pos) + offset;
+static void g_x86_moffs_operand_init(GX86MOffsOperand *operand)
+{
+ GArchOperand *parent; /* Instance parente */
- if (!fill_imm_operand_with_value(ASM_OPERAND(result), AOS_32_BITS, &address))
- {
- free(result);
- return NULL;
- }
+ parent = G_ARCH_OPERAND(operand);
- return result;
+ parent->get_text = (get_operand_text_fc)g_x86_moffs_operand_get_text;
}
/******************************************************************************
* *
-* Paramètres : data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* len = taille totale des données à analyser. *
-* is_reg32 = indique si le registre est un registre 32 bits. *
+* 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 une opérande à partir d'une adresse relative (16/32b). *
+* Description : Crée un opérande d'emplacement mémoire x86. *
* *
-* Retour : Opérande mise en place ou NULL. *
+* Retour : Opérande mis en place. *
* *
* Remarques : - *
* *
******************************************************************************/
-asm_x86_operand *x86_create_rel1632_operand_in_32b(uint64_t base, const uint8_t *data, off_t *pos, off_t len, bool is_reg32)
+GArchOperand *g_x86_moffs_operand_new(const bin_t *data, off_t *pos, off_t len, AsmOperandSize size)
{
- asm_x86_operand *result; /* Emplacement à retourner */
- off_t init_pos; /* Position avant lecture */
- int32_t offset32; /* Décallage 32b à appliquer */
- int16_t offset16; /* Décallage 16b à appliquer */
- uint32_t address; /* Adresse finale visée */
+ GX86MOffsOperand *result; /* Structure à retourner */
+ GImmOperand *offset; /* Emplacement lu */
- result = create_new_x86_operand();
+ result = NULL;
- init_pos = *pos;
- address = base;
+ offset = g_imm_operand_new_from_data(size/* FIXME : !convert mds/aos */, data, pos, len, SRE_LITTLE);
- if (is_reg32)
+ if (offset != NULL)
{
- if (!read_imm_value(AOS_32_BITS, data, pos, len, &offset32))
- {
- free(result);
- return NULL;
- }
+ result = g_object_new(G_TYPE_X86_MOFFS_OPERAND, NULL);
+ result->offset = offset;
+ }
- address = base + (*pos - init_pos) + offset32;
+ return G_ARCH_OPERAND(result);
- }
- else
- {
- if (!read_imm_value(AOS_16_BITS, data, pos, len, &offset16))
- {
- free(result);
- return NULL;
- }
+}
- address = base + (*pos - init_pos) + offset16;
- }
+/******************************************************************************
+* *
+* Paramètres : operand = opérande à traiter. *
+* format = format du binaire manipulé. *
+* syntax = type de représentation demandée. *
+* *
+* Description : Traduit un opérande en version humainement lisible. *
+* *
+* Retour : Chaîne de caractères à libérer de la mémoire. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
- if (!fill_imm_operand_with_value(ASM_OPERAND(result), AOS_32_BITS, &address))
- {
- free(result);
- return NULL;
- }
+static char *g_x86_moffs_operand_get_text(const GX86MOffsOperand *operand, const exe_format *format, AsmSyntax syntax)
+{
+ char *result; /* Chaîne à retourner */
+
+ result = g_arch_operand_get_text(operand->offset, format, syntax);
+
+ result = strprep(result, "ds:");
return result;
@@ -1367,13 +920,13 @@ asm_x86_operand *x86_create_rel1632_operand_in_32b(uint64_t base, const uint8_t
* *
******************************************************************************/
-bool x86_read_one_operand(asm_x86_instr *instr, const uint8_t *data, off_t *pos, off_t len, X86OperandType type, ...)
+bool x86_read_one_operand(GArchInstruction *instr, const bin_t *data, off_t *pos, off_t len, X86OperandType type, ...)
{
va_list ap; /* Liste des compléments */
AsmOperandSize oprsize; /* Taille des opérandes */
- uint64_t offset; /* Adresse courante */
- uint8_t base; /* Indice du premier registre */
- asm_x86_operand *op; /* Opérande unique décodé */
+ vmpa_t offset; /* Adresse courante */
+ bin_t base; /* Indice du premier registre */
+ GArchOperand *op; /* Opérande unique décodé */
va_start(ap, type);
@@ -1382,72 +935,60 @@ bool x86_read_one_operand(asm_x86_instr *instr, const uint8_t *data, off_t *pos,
switch (type)
{
case X86_OTP_IMM8:
- op = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(op), AOS_8_BITS, data, pos, len))
- {
- free(op);
- op = NULL;
- }
+ op = g_imm_operand_new_from_data(MDS_8_BITS, data, pos, len, SRE_LITTLE);
break;
case X86_OTP_IMM1632:
- oprsize = va_arg(ap, AsmOperandSize);
- op = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(op), oprsize, data, pos, len))
- {
- free(op);
- op = NULL;
- }
+ if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
+ op = g_imm_operand_new_from_data(oprsize == AOS_32_BITS ? MDS_32_BITS : MDS_16_BITS, data, pos, len, SRE_LITTLE);
break;
case X86_OTP_REL8:
- offset = va_arg(ap, uint64_t);
- /* TODO : 64bits */
- op = x86_create_rel8_operand_in_32b(offset + 1, data, pos, len);
+ offset = va_arg(ap, vmpa_t);
+ op = g_x86_relative_operand_new(data, pos, len, AOS_8_BITS, offset + 1);
break;
case X86_OTP_REL1632:
oprsize = va_arg(ap, AsmOperandSize);
- offset = va_arg(ap, uint64_t);
- /* TODO : 64bits */
- op = x86_create_rel1632_operand_in_32b(offset + 1, data, pos, len, oprsize == AOS_32_BITS);
+ offset = va_arg(ap, vmpa_t);
+ op = g_x86_relative_operand_new(data, pos, len, oprsize, offset + 1);
break;
case X86_OTP_R8:
- op = x86_create_r8_operand(data[(*pos)++], true);
+ op = g_x86_register_operand_new_from_mod_rm(data, pos, len, AOS_8_BITS, true);
break;
case X86_OTP_R1632:
oprsize = va_arg(ap, AsmOperandSize);
- op = x86_create_r1632_operand(data[(*pos)++], oprsize == AOS_32_BITS, true);
+ op = g_x86_register_operand_new_from_mod_rm(data, pos, len, oprsize, true);
break;
case X86_OTP_OP_R1632:
oprsize = va_arg(ap, AsmOperandSize);
- base = (uint8_t)va_arg(ap, int);
- op = x86_create_r1632_operand_from_opcode(data[(*pos)++], oprsize == AOS_32_BITS, base);
+ base = (bin_t)va_arg(ap, int);
+ op = g_x86_register_operand_new_from_opcode(data, pos, len, oprsize, base);
break;
case X86_OTP_RM8:
- op = x86_create_rm8_operand(data, pos, len);
+ op = g_x86_mod_rm_operand_new(data, pos, len, AOS_8_BITS);
break;
case X86_OTP_RM1632:
oprsize = va_arg(ap, AsmOperandSize);
- op = x86_create_rm1632_operand(data, pos, len, oprsize == AOS_32_BITS);
+ op = g_x86_mod_rm_operand_new(data, pos, len, oprsize);
break;
case X86_OTP_CL:
- op = x86_create_r8_operand(0x01, true);
+ op = g_x86_register_operand_new_from_index(0x01, AOS_8_BITS);
break;
case X86_OTP_AL:
- op = x86_create_r8_operand(0x00, true);
+ op = g_x86_register_operand_new_from_index(0x00, AOS_8_BITS);
break;
case X86_OTP_E_AX:
oprsize = va_arg(ap, AsmOperandSize);
- op = x86_create_r1632_operand(0x00, oprsize == AOS_32_BITS, true);
+ op = g_x86_register_operand_new_from_index(0x00, oprsize);
break;
}
@@ -1456,12 +997,7 @@ bool x86_read_one_operand(asm_x86_instr *instr, const uint8_t *data, off_t *pos,
if (op == NULL) return false;
- /* Assemblage final */
-
- ASM_INSTRUCTION(instr)->operands = (asm_operand **)calloc(1, sizeof(asm_operand *));
- ASM_INSTRUCTION(instr)->operands_count = 1;
-
- ASM_INSTRUCTION(instr)->operands[0] = ASM_OPERAND(op);
+ g_arch_instruction_attach_one_operand(instr, op);
return true;
@@ -1486,16 +1022,17 @@ bool x86_read_one_operand(asm_x86_instr *instr, const uint8_t *data, off_t *pos,
* *
******************************************************************************/
-bool x86_read_two_operands(asm_x86_instr *instr, const uint8_t *data, off_t *pos, off_t len, X86OperandType type1, X86OperandType type2, ...)
+bool x86_read_two_operands(GArchInstruction *instr, const bin_t *data, off_t *pos, off_t len, X86OperandType type1, X86OperandType type2, ...)
{
va_list ap; /* Liste des compléments */
AsmOperandSize oprsize; /* Taille des opérandes */
bool op1_first; /* Position de l'opérande #1 */
bool op2_first; /* Position de l'opérande #2 */
off_t op1_pos; /* Position après lecture #1 */
- asm_x86_operand *op1; /* Premier opérande décodé */
+ bin_t base; /* Indice du premier registre */
+ GArchOperand *op1; /* Premier opérande décodé */
off_t op2_pos; /* Position après lecture #2 */
- asm_x86_operand *op2; /* Second opérande décodé */
+ GArchOperand *op2; /* Second opérande décodé */
va_start(ap, type2);
@@ -1523,44 +1060,59 @@ bool x86_read_two_operands(asm_x86_instr *instr, const uint8_t *data, off_t *pos
switch (type1)
{
+ case X86_OTP_IMM8:
+ op1 = g_imm_operand_new_from_data(MDS_8_BITS, data, &op1_pos, len, SRE_LITTLE);
+ break;
+
+ case X86_OTP_IMM1632:
+ if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
+ op1 = g_imm_operand_new_from_data(oprsize == AOS_32_BITS ? MDS_32_BITS : MDS_16_BITS, data, &op1_pos, len, SRE_LITTLE);
+ break;
+
case X86_OTP_MOFFS8:
- op1 = x86_create_moffs8_operand(data, &op1_pos, len);
+ op1 = g_x86_moffs_operand_new(data, &op1_pos, len, AOS_8_BITS);
break;
case X86_OTP_MOFFS1632:
oprsize = va_arg(ap, AsmOperandSize);
- op1 = x86_create_moffs1632_operand(data, &op1_pos, len, oprsize == AOS_32_BITS);
+ op1 = g_x86_moffs_operand_new(data, &op1_pos, len, oprsize);
break;
case X86_OTP_R8:
- op1 = x86_create_r8_operand(data[op1_pos++], op1_first);
+ op1 = g_x86_register_operand_new_from_mod_rm(data, &op1_pos, len, AOS_8_BITS, op1_first);
break;
case X86_OTP_R1632:
oprsize = va_arg(ap, AsmOperandSize);
- op1 = x86_create_r1632_operand(data[op1_pos++], oprsize == AOS_32_BITS, op1_first);
+ op1 = g_x86_register_operand_new_from_mod_rm(data, &op1_pos, len, oprsize, op1_first);
+ break;
+
+ case X86_OTP_OP_R1632:
+ oprsize = va_arg(ap, AsmOperandSize);
+ base = (bin_t)va_arg(ap, int);
+ op1 = g_x86_register_operand_new_from_opcode(data, &op1_pos, len, oprsize, base);
break;
case X86_OTP_RM8:
- op1 = x86_create_rm8_operand(data, &op1_pos, len);
+ op1 = g_x86_mod_rm_operand_new(data, &op1_pos, len, AOS_8_BITS);
break;
case X86_OTP_RM1632:
oprsize = va_arg(ap, AsmOperandSize);
- op1 = x86_create_rm1632_operand(data, &op1_pos, len, oprsize == AOS_32_BITS);
+ op1 = g_x86_mod_rm_operand_new(data, &op1_pos, len, oprsize);
break;
case X86_OTP_CL:
- op1 = x86_create_r8_operand(0x01, op1_first);
+ op1 = g_x86_register_operand_new_from_index(0x01, AOS_8_BITS);
break;
case X86_OTP_AL:
- op1 = x86_create_r8_operand(0x00, op1_first);
+ op1 = g_x86_register_operand_new_from_index(0x00, AOS_8_BITS);
break;
case X86_OTP_E_AX:
oprsize = va_arg(ap, AsmOperandSize);
- op1 = x86_create_r1632_operand(0x00, oprsize == AOS_32_BITS, op1_first);
+ op1 = g_x86_register_operand_new_from_index(0x00, oprsize);
break;
}
@@ -1580,62 +1132,52 @@ bool x86_read_two_operands(asm_x86_instr *instr, const uint8_t *data, off_t *pos
switch (type2)
{
case X86_OTP_IMM8:
- op2 = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(op2), AOS_8_BITS, data, &op2_pos, len))
- {
- free(op2);
- op2 = NULL;
- }
+ op2 = g_imm_operand_new_from_data(MDS_8_BITS, data, &op2_pos, len, SRE_LITTLE);
break;
case X86_OTP_IMM1632:
if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
- op2 = create_new_x86_operand();
- if (!fill_imm_operand(ASM_OPERAND(op2), oprsize, data, &op2_pos, len))
- {
- free(op2);
- op2 = NULL;
- }
+ op2 = g_imm_operand_new_from_data(oprsize == AOS_32_BITS ? MDS_32_BITS : MDS_16_BITS, data, &op2_pos, len, SRE_LITTLE);
break;
case X86_OTP_MOFFS8:
- op2 = x86_create_moffs8_operand(data, &op2_pos, len);
+ op2 = g_x86_moffs_operand_new(data, &op2_pos, len, AOS_8_BITS);
break;
case X86_OTP_MOFFS1632:
if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
- op2 = x86_create_moffs1632_operand(data, &op2_pos, len, oprsize == AOS_32_BITS);
+ op2 = g_x86_moffs_operand_new(data, &op2_pos, len, oprsize);
break;
case X86_OTP_R8:
- op2 = x86_create_r8_operand(data[op2_pos++], op2_first);
+ op2 = g_x86_register_operand_new_from_mod_rm(data, &op2_pos, len, AOS_8_BITS, op2_first);
break;
case X86_OTP_R1632:
if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
- op2 = x86_create_r1632_operand(data[op2_pos++], oprsize == AOS_32_BITS, op2_first);
+ op2 = g_x86_register_operand_new_from_mod_rm(data, &op2_pos, len, oprsize, op2_first);
break;
case X86_OTP_RM8:
- op2 = x86_create_rm8_operand(data, &op2_pos, len);
+ op2 = g_x86_mod_rm_operand_new(data, &op2_pos, len, AOS_8_BITS);
break;
case X86_OTP_RM1632:
if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
- op2 = x86_create_rm1632_operand(data, &op2_pos, len, oprsize == AOS_32_BITS);
+ op2 = g_x86_mod_rm_operand_new(data, &op2_pos, len, oprsize);
break;
case X86_OTP_CL:
- op2 = x86_create_r8_operand(0x01, op2_first);
+ op2 = g_x86_register_operand_new_from_index(0x01, AOS_8_BITS);
break;
case X86_OTP_AL:
- op2 = x86_create_r8_operand(0x00, op2_first);
+ op2 = g_x86_register_operand_new_from_index(0x00, AOS_8_BITS);
break;
case X86_OTP_E_AX:
if (oprsize == AOS_UNDEFINED) oprsize = va_arg(ap, AsmOperandSize);
- op2 = x86_create_r1632_operand(0x00, oprsize == AOS_32_BITS, op2_first);
+ op2 = g_x86_register_operand_new_from_index(0x00, oprsize);
break;
}
@@ -1653,11 +1195,7 @@ bool x86_read_two_operands(asm_x86_instr *instr, const uint8_t *data, off_t *pos
*pos = MAX(op1_pos, op2_pos);
- ASM_INSTRUCTION(instr)->operands = (asm_operand **)calloc(2, sizeof(asm_operand *));
- ASM_INSTRUCTION(instr)->operands_count = 2;
-
- ASM_INSTRUCTION(instr)->operands[0] = ASM_OPERAND(op1);
- ASM_INSTRUCTION(instr)->operands[1] = ASM_OPERAND(op2);
+ g_arch_instruction_attach_two_operands(instr, op1, op2);
return true;
diff --git a/src/arch/x86/operand.h b/src/arch/x86/operand.h
index c9ade39..bc495a0 100644
--- a/src/arch/x86/operand.h
+++ b/src/arch/x86/operand.h
@@ -26,75 +26,132 @@
#include <stdbool.h>
-#include <stdint.h>
-#include "instruction.h"
+#include "../instruction.h"
-/* Définition d'une opérande x86 */
-typedef struct _asm_x86_operand asm_x86_operand;
+/* ---------------------- 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))
-/* Crée une opérande vierge pour x86. */
-asm_x86_operand *create_new_x86_operand(void);
+/* Définition d'un opérande de la x86 (instance) */
+typedef struct _GX86Operand GX86Operand;
+/* Définition d'un opérande de la x86 (classe) */
+typedef struct _GX86OperandClass GX86OperandClass;
-/* Crée une opérande renvoyant vers un registre 16 ou 32 bits. */
-asm_x86_operand *x86_create_reg1632_operand(uint8_t, bool, uint8_t);
-/* Crée une opérande renvoyant vers un registre 16 ou 32 bits. */
-asm_x86_operand *x86_create_reg1632_operand_from_modrm(uint8_t, bool, bool);
+/* Indique le type défini par la GLib pour un opérande de x86. */
+GType g_x86_operand_get_type(void);
-/* Crée une opérande renvoyant vers un contenu 16 ou 32 bits. */
-asm_x86_operand *x86_create_content1632_operand(const uint8_t *, off_t *, off_t, bool, bool);
+/* ------------------------ OPERANDES VISANT UN REGISTRE X86 ------------------------ */
-/* Crée une opérande renvoyant vers un registre 8 bits. */
-asm_x86_operand *x86_create_r8_operand(uint8_t, bool);
-/* Crée une opérande à partir d'un registre/une mémoire 8 bits. */
-asm_x86_operand *x86_create_rm8_operand(const uint8_t *, off_t *, off_t, ...);
+#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))
-/* Crée une opérande renvoyant vers un registre 16 ou 32 bits. */
-asm_x86_operand *x86_create_r1632_operand(uint8_t, bool, bool);
-/* Crée une opérande à partir d'un registre/une mémoire 16/32b. */
-asm_x86_operand *x86_create_rm1632_operand(const uint8_t *, off_t *, off_t, bool, ...);
+/* 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;
-/* Traduit une opérande de registre en texte. */
-void x86_print_reg_operand(const asm_x86_operand *, char *, size_t, AsmSyntax);
+/* 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, AsmOperandSize, 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, AsmOperandSize, bool);
+
+/* Crée un opérande visant un registre X86 donnée. */
+GArchOperand *g_x86_register_operand_new_from_index(bin_t, AsmOperandSize);
+
+
+
+/* ----------------------- 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))
-/* ------------------------ OPERANDES D'EMPLACEMENTS MEMOIRE ------------------------ */
+/* Définition d'un opérande x86 de type ModRM (instance) */
+typedef struct _GX86ModRMOperand GX86ModRMOperand;
-/* Crée une opérande à partir d'un emplacement mémoire 8 bits. */
-asm_x86_operand *x86_create_moffs8_operand(const uint8_t *, off_t *, off_t);
+/* Définition d'un opérande x86 de type ModRM (classe) */
+typedef struct _GX86ModRMOperandClass GX86ModRMOperandClass;
-/* Crée une opérande à partir d'un emplacement mémoire 16/32b. */
-asm_x86_operand *x86_create_moffs1632_operand(const uint8_t *, off_t *, off_t, bool);
-/* Traduit une opérande d'emplacement mémoire en texte. */
-void x86_print_moffs_operand(const asm_x86_operand *, char *, size_t, AsmSyntax);
+/* 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, AsmOperandSize);
/* ------------------------- OPERANDES D'ADRESSES RELATIVES ------------------------- */
-/* Crée une opérande à partir d'une adresse relative (8 bits). */
-asm_x86_operand *x86_create_rel8_operand_in_32b(uint64_t, const uint8_t *, off_t *, off_t);
+#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, AsmOperandSize, vmpa_t);
+
+
+
+/* ------------------------ 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 une opérande à partir d'une adresse relative (16/32b). */
-asm_x86_operand *x86_create_rel1632_operand_in_32b(uint64_t, const uint8_t *, off_t *, off_t, bool);
+/* Crée un opérande d'emplacement mémoire x86. */
+GArchOperand *g_x86_moffs_operand_new(const bin_t *, off_t *, off_t, AsmOperandSize);
@@ -136,10 +193,10 @@ typedef enum _X86OperandType
/* Procède à la lecture d'un opérande donné. */
-bool x86_read_one_operand(asm_x86_instr *, const uint8_t *, off_t *, off_t, X86OperandType, ...);
+bool x86_read_one_operand(GArchInstruction *, const bin_t *data, off_t *pos, off_t, X86OperandType, ...);
/* Procède à la lecture de deux opérandes donnés. */
-bool x86_read_two_operands(asm_x86_instr *, const uint8_t *, off_t *, off_t, X86OperandType, X86OperandType, ...);
+bool x86_read_two_operands(GArchInstruction *, const bin_t *data, off_t *pos, off_t, X86OperandType, X86OperandType, ...);
diff --git a/src/arch/x86/processor.c b/src/arch/x86/processor.c
index dfb2f12..82b0f23 100644
--- a/src/arch/x86/processor.c
+++ b/src/arch/x86/processor.c
@@ -24,182 +24,112 @@
#include "processor.h"
-#include <malloc.h>
-#include <stdio.h>
-
-
#include "../processor-int.h"
-#include "instruction.h"
#include "opcodes.h"
-#include "operand.h"
-#include "../../common/extstr.h"
-
-
-typedef asm_x86_instr * (* read_instr) (const uint8_t *, off_t *, off_t, uint64_t, const asm_x86_processor *);
-/* Carte d'identité d'un opcode */
-typedef struct _x86_opcode
+/* Définition du processeur de la x86 (instance) */
+struct _GX86Processor
{
- X86Prefix prefix; /* Préfixe(s) eventuel(s) */
- uint8_t opcode; /* Opcode seul */
- uint8_t op_ext; /* Extension de l'opcode */
-
- bool has_op_ext; /* Ext. à prendre en compte ? */
-
- const char *name; /* Désignation humaine */
- read_instr read; /* Décodage de l'instruction */
-
-} x86_opcode;
-
-
-#define EXT_OPCODE_MASK 0x38
-
-
-
-
-
-#define register_opcode(target, _opcode, _name, _read) \
- do { \
- target.prefix = X86_PRE_NONE; \
- target.opcode = _opcode; \
- target.has_op_ext = false; \
- target.name = _name; \
- target.read = _read; \
- } while (0)
-
-#define register_opcode_1632(target, _opcode, _name, _read) \
- do { \
- target.prefix = X86_PRE_OPSIZE; \
- target.opcode = _opcode; \
- target.has_op_ext = false; \
- target.name = _name; \
- target.read = _read; \
- } while (0)
-
-#define register_opcode_with_ext(target, _opcode, _ext, _name, _read) \
- do { \
- target.prefix = X86_PRE_NONE; \
- target.opcode = _opcode; \
- target.op_ext = _ext << 3; \
- target.has_op_ext = true; \
- target.name = _name; \
- target.read = _read; \
- } while (0)
-
-#define register_opcode_1632_with_ext(target, _opcode, _ext, _name, _read) \
- do { \
- target.prefix = X86_PRE_OPSIZE; \
- target.opcode = _opcode; \
- target.op_ext = _ext << 3; \
- target.has_op_ext = true; \
- target.name = _name; \
- target.read = _read; \
- } while (0)
-
-#define register_2b_opcode_1632(target, _opcode, _name, _read) \
- do { \
- target.prefix = X86_PRE_ESCAPE | X86_PRE_OPSIZE; \
- target.opcode = _opcode; \
- target.has_op_ext = false; \
- target.name = _name; \
- target.read = _read; \
- } while (0)
-
-
-
-
-
-
-
-
+ GArchProcessor parent; /* Instance parente */
+};
-/* Définition générique d'une architecture */
-struct _asm_x86_processor
+/* Définition du processeur de la x86 (classe) */
+struct _GX86ProcessorClass
{
- asm_processor base; /* A laisser en premier... */
-
- AsmOperandSize operand_size; /* Taille par défaut */
-
- x86_opcode opcodes[X86_OP_COUNT]; /* Liste des opcodes supportés */
+ GArchProcessorClass parent; /* Classe parente */
};
+/* Initialise la classe des lignes de descriptions initiales. */
+static void g_x86_processor_class_init(GX86ProcessorClass *);
+/* Initialise la classe des lignes de descriptions initiales. */
+static void g_x86_processor_init(GX86Processor *);
+/* Décode une instruction dans un flux de données. */
+static GArchInstruction *g_x86_processor_decode_instruction(const GX86Processor *, const bin_t *, off_t *, off_t, vmpa_t);
-/* Enregistre toutes les instructions reconnues pour x86. */
-void x86_register_instructions(asm_x86_processor *);
+/* Indique le type défini par la GLib pour le processeur x86. */
+G_DEFINE_TYPE(GX86Processor, g_x86_processor, G_TYPE_ARCH_PROCESSOR);
-/* Décode une instruction dans un flux de données. */
-asm_instr *x86_fetch_instruction(const asm_x86_processor *, const uint8_t *, off_t *, off_t, uint64_t);
-/* Traduit une instruction en version humainement lisible. */
-void x86_print_instruction(const asm_x86_processor *, const exe_format *, const asm_x86_instr *, char *, size_t, AsmSyntax);
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des lignes de descriptions initiales. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+static void g_x86_processor_class_init(GX86ProcessorClass *klass)
+{
+}
/******************************************************************************
* *
-* Paramètres : - *
+* Paramètres : proc = instance à initialiser. *
* *
-* Description : Crée le support de l'architecture x86. *
+* Description : Initialise la classe des lignes de descriptions initiales. *
* *
-* Retour : Architecture mise en place. *
+* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
-asm_processor *create_x86_processor(void)
+static void g_x86_processor_init(GX86Processor *proc)
{
- asm_x86_processor *result; /* Architecture à retourner */
-
- result = (asm_x86_processor *)calloc(1, sizeof(asm_x86_processor));
+ GArchProcessor *parent; /* Instance parente */
- result->operand_size = AOS_32_BITS;
+ parent = G_ARCH_PROCESSOR(proc);
- x86_register_instructions(result);
+ parent->endianness = SRE_BIG;
- ASM_PROCESSOR(result)->fetch_instr = (fetch_instruction_)x86_fetch_instruction;
- ASM_PROCESSOR(result)->print_instr = (print_instruction_)x86_print_instruction;
-
- return ASM_PROCESSOR(result);
+ parent->decode = (decode_instruction_fc)g_x86_processor_decode_instruction;
}
/******************************************************************************
* *
-* Paramètres : proc = architecture visée par la consultation. *
+* Paramètres : - *
* *
-* Description : Fournit la taille courante des opérandes pour x86. *
+* Description : Crée le support de l'architecture x86. *
* *
-* Retour : Taille d'opérande (16 ou 32 bits). *
+* Retour : Architecture mise en place. *
* *
* Remarques : - *
* *
******************************************************************************/
-AsmOperandSize get_x86_current_operand_size(const asm_x86_processor *proc)
+GArchProcessor *g_x86_processor_new(void)
{
- return proc->operand_size;
+ GArchProcessor *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_X86_PROCESSOR, NULL);
+
+ return result;
}
/******************************************************************************
* *
-* Paramètres : proc = architecture visée par la consultation. *
-* data = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
+* Paramètres : proc = architecture visée par la consultation. *
+* prefix = bascule à consulter. *
* *
* Description : Fournit la taille supplantée des opérandes pour x86. *
* *
@@ -209,16 +139,16 @@ AsmOperandSize get_x86_current_operand_size(const asm_x86_processor *proc)
* *
******************************************************************************/
-AsmOperandSize switch_x86_operand_size_if_needed(const asm_x86_processor *proc, const uint8_t *data, off_t *pos)
+AsmOperandSize g_x86_processor_get_operand_size(const GX86Processor *proc, X86Prefix prefix)
{
AsmOperandSize result; /* Taille à renvoyer */
- if (data[*pos] == 0x66)
- {
- result = (proc->operand_size == AOS_32_BITS ? AOS_16_BITS : AOS_32_BITS);
- (*pos)++;
- }
- else result = proc->operand_size;
+ /* FIXME */
+
+ if (prefix & XPX_OPERAND_SIZE_OVERRIDE)
+ result = (AOS_32_BITS/*proc->operand_size*/ == AOS_32_BITS ? AOS_16_BITS : AOS_32_BITS);
+
+ else result = AOS_32_BITS/*proc->operand_size*/;
return result;
@@ -228,362 +158,557 @@ AsmOperandSize switch_x86_operand_size_if_needed(const asm_x86_processor *proc,
/******************************************************************************
* *
* Paramètres : proc = architecture visée par la procédure. *
+* data = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* len = taille totale des données à analyser. *
+* addr = adresse virtuelle de l'instruction. *
* *
-* Description : Enregistre toutes les instructions reconnues pour x86. *
+* Description : Décode une instruction dans un flux de données. *
* *
-* Retour : - *
+* Retour : Instruction mise en place. *
* *
* Remarques : - *
* *
******************************************************************************/
-void x86_register_instructions(asm_x86_processor *proc)
+static GArchInstruction *g_x86_processor_decode_instruction(const GX86Processor *proc, const bin_t *data, off_t *pos, off_t len, vmpa_t addr)
{
- register_opcode(proc->opcodes[X86_OP_ADD_RM8_R8], 0x00, "add", x86_read_instr_add_rm8_r8);
- register_opcode_1632(proc->opcodes[X86_OP_ADD_RM1632_R1632], 0x01, "add", x86_read_instr_add_rm1632_r1632);
- register_opcode(proc->opcodes[X86_OP_ADD_R8_RM8], 0x02, "add", x86_read_instr_add_r8_rm8);
- register_opcode_1632(proc->opcodes[X86_OP_ADD_R1632_RM1632], 0x03, "add", x86_read_instr_add_r1632_rm1632);
- register_opcode(proc->opcodes[X86_OP_ADD_AL_IMM8], 0x04, "add", x86_read_instr_add_al_imm8);
- register_opcode_1632(proc->opcodes[X86_OP_ADD_E_AX_IMM1632], 0x05, "add", x86_read_instr_add_e_ax_imm1632);
-
- register_opcode(proc->opcodes[X86_OP_ADC_RM8_R8], 0x10, "adc", x86_read_instr_adc_rm8_r8);
-
- register_opcode(proc->opcodes[X86_OP_OR_R8_RM8], 0x0a, "or", x86_read_instr_or_r8_rm8);
-
- register_opcode(proc->opcodes[X86_OP_OR_AL_IMM8], 0x0c, "or", x86_read_instr_or_al_imm8);
-
- register_opcode(proc->opcodes[X86_OP_AND_RM8_R8], 0x20, "and", x86_read_instr_and_rm8_r8);
-
- register_opcode_1632(proc->opcodes[X86_OP_SUB_R1632_RM1632], 0x29, "sub", x86_read_instr_sub_r1632_from_rm1632);
-
- register_opcode(proc->opcodes[X86_OP_SUB_R8_RM8], 0x2a, "sub", x86_read_instr_sub_r8_rm8);
- register_opcode(proc->opcodes[X86_OP_SUB_AL_IMM8], 0x2c, "sub", x86_read_instr_sub_al_with_imm8);
- register_opcode_1632(proc->opcodes[X86_OP_SUB_E_AX_IMM1632], 0x2d, "sub", x86_read_instr_sub_e_ax_with_imm1632);
-
- register_opcode(proc->opcodes[X86_OP_XOR_RM8_R8], 0x30, "xor", x86_read_instr_xor_rm8_with_r8);
- register_opcode_1632(proc->opcodes[X86_OP_XOR_RM1632_R1632], 0x31, "xor", x86_read_instr_xor_rm1632_with_r1632);
- register_opcode(proc->opcodes[X86_OP_XOR_R8_RM8], 0x32, "xor", x86_read_instr_xor_r8_with_rm8);
- register_opcode_1632(proc->opcodes[X86_OP_XOR_R1632_RM1632], 0x33, "xor", x86_read_instr_xor_r1632_with_rm1632);
- register_opcode(proc->opcodes[X86_OP_XOR_AL_IMM8], 0x34, "xor", x86_read_instr_xor_al_with_imm8);
- register_opcode_1632(proc->opcodes[X86_OP_XOR_E_AX_IMM1632], 0x35, "xor", x86_read_instr_xor_e_ax_with_imm1632);
-
- register_opcode_1632(proc->opcodes[X86_OP_CMP_RM1632_R1632], 0x39, "cmp", x86_read_instr_cmp_rm1632_with_r1632);
-
- register_opcode_1632(proc->opcodes[X86_OP_INC_E_AX], 0x40, "inc", x86_read_instr_inc_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_INC_E_CX], 0x41, "inc", x86_read_instr_inc_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_INC_E_DX], 0x42, "inc", x86_read_instr_inc_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_INC_E_BX], 0x43, "inc", x86_read_instr_inc_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_INC_E_SP], 0x44, "inc", x86_read_instr_inc_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_INC_E_BP], 0x45, "inc", x86_read_instr_inc_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_INC_E_SI], 0x46, "inc", x86_read_instr_inc_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_INC_E_DI], 0x47, "inc", x86_read_instr_inc_r1632);
-
- register_opcode_1632(proc->opcodes[X86_OP_DEC_E_AX], 0x48, "dec", x86_read_instr_dec_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_DEC_E_CX], 0x49, "dec", x86_read_instr_dec_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_DEC_E_DX], 0x4a, "dec", x86_read_instr_dec_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_DEC_E_BX], 0x4b, "dec", x86_read_instr_dec_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_DEC_E_SP], 0x4c, "dec", x86_read_instr_dec_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_DEC_E_BP], 0x4d, "dec", x86_read_instr_dec_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_DEC_E_SI], 0x4e, "dec", x86_read_instr_dec_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_DEC_E_DI], 0x4f, "dec", x86_read_instr_dec_r1632);
-
- register_opcode_1632(proc->opcodes[X86_OP_PUSH_E_AX], 0x50, "push", x86_read_instr_push_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_PUSH_E_CX], 0x51, "push", x86_read_instr_push_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_PUSH_E_DX], 0x52, "push", x86_read_instr_push_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_PUSH_E_BX], 0x53, "push", x86_read_instr_push_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_PUSH_E_SP], 0x54, "push", x86_read_instr_push_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_PUSH_E_BP], 0x55, "push", x86_read_instr_push_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_PUSH_E_SI], 0x56, "push", x86_read_instr_push_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_PUSH_E_DI], 0x57, "push", x86_read_instr_push_r1632);
-
- register_opcode_1632(proc->opcodes[X86_OP_POP_E_AX], 0x58, "pop", x86_read_instr_pop_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_POP_E_CX], 0x59, "pop", x86_read_instr_pop_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_POP_E_DX], 0x5a, "pop", x86_read_instr_pop_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_POP_E_BX], 0x5b, "pop", x86_read_instr_pop_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_POP_E_SP], 0x5c, "pop", x86_read_instr_pop_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_POP_E_BP], 0x5d, "pop", x86_read_instr_pop_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_POP_E_SI], 0x5e, "pop", x86_read_instr_pop_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_POP_E_DI], 0x5f, "pop", x86_read_instr_pop_r1632);
+ GArchInstruction *result; /* Instruction à renvoyer */
+ X86Prefix prefix; /* Préfixes avec l'instr. */
+ bool care; /* Traitement des opcodes */
+ X86Opcodes id; /* Identifiant d'instruction */
- register_opcode_1632(proc->opcodes[X86_OP_PUSH_IMM1632], 0x68, "push", x86_read_instr_push_imm1632);
+ id = x86_guess_next_instruction(data, *pos, len, &prefix, &care);
- register_opcode(proc->opcodes[X86_OP_JB_REL8], 0x72, "jb", x86_read_instr_jb_rel8);
- register_opcode(proc->opcodes[X86_OP_JNB_REL8], 0x73, "jnb", x86_read_instr_jnb_rel8);
+ if (prefix & XPX_OPERAND_SIZE_OVERRIDE) (*pos)++;
- register_opcode(proc->opcodes[X86_OP_JE_8], 0x74, "je", x86_read_instr_je_8);
- register_opcode(proc->opcodes[X86_OP_JNE_8], 0x75, "jne", x86_read_instr_jne_8);
- register_opcode(proc->opcodes[X86_OP_JG_REL8], 0x7f, "jg", x86_read_instr_jg_rel8);
+ if (id != XOP_COUNT && !care) (*pos)++;
- register_opcode_with_ext(proc->opcodes[X86_OP_XOR_RM8_IMM8], 0x80, 6, "xor", x86_read_instr_xor_rm8_with_imm8);
- register_opcode_with_ext(proc->opcodes[X86_OP_CMP_RM8_IMM8], 0x80, 7, "cmp", x86_read_instr_cmp_rm8_with_imm8);
+ switch (id)
+ {
+ case XOP_ADD_RM8_R8:
+ result = x86_read_instr_add_rm8_r8(data, pos, len, addr, prefix, proc);
+ break;
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_ADD_RM1632_IMM1632], 0x81, 0, "add", x86_read_instr_add_rm1632_imm1632);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_OR_RM1632_IMM1632], 0x81, 1, "or", x86_read_instr_or_rm1632_imm1632);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_ADC_RM1632_IMM1632], 0x81, 2, "adc", x86_read_instr_adc_rm1632_imm1632);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_SBB_RM1632_IMM1632], 0x81, 3, "sbb", x86_read_instr_sbb_rm1632_imm1632);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_AND_RM1632_IMM1632], 0x81, 4, "and", x86_read_instr_and_rm1632_imm1632);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_SUB_RM1632_IMM1632], 0x81, 5, "sub", x86_read_instr_sub_rm1632_imm1632);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_XOR_RM1632_IMM1632], 0x81, 6, "xor", x86_read_instr_xor_rm1632_imm1632);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_CMP_RM1632_IMM1632], 0x81, 7, "cmp", x86_read_instr_cmp_rm1632_imm1632);
+ case XOP_ADD_RM1632_R1632:
+ result = x86_read_instr_add_rm1632_r1632(data, pos, len, addr, prefix, proc);
+ break;
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_ADD_RM1632_IMM8], 0x83, 0, "add", x86_read_instr_add_imm8_to_rm1632);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_OR_RM1632_IMM8], 0x83, 1, "or", x86_read_instr_or_rm1632_with_imm8);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_ADC_RM1632_IMM8], 0x83, 2, "adc", x86_read_instr_adc_imm8_to_rm1632);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_SBB_RM1632_IMM8], 0x83, 3, "sbb", x86_read_instr_sbb_rm1632_with_imm8);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_AND_RM1632_IMM8], 0x83, 4, "and", x86_read_instr_and_rm1632_with_imm8);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_SUB_RM1632_IMM8], 0x83, 5, "sub", x86_read_instr_sub_imm8_from_rm1632);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_XOR_RM1632_IMM8], 0x83, 6, "xor", x86_read_instr_xor_rm1632_with_imm8);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_CMP_RM1632_IMM8], 0x83, 7, "cmp", x86_read_instr_cmp_rm1632_with_imm8);
+ case XOP_ADD_R8_RM8:
+ result = x86_read_instr_add_r8_rm8(data, pos, len, addr, prefix, proc);
+ break;
- register_opcode(proc->opcodes[X86_OP_TEST_RM8_R8], 0x84, "test", x86_read_instr_test_rm8_with_r8);
- register_opcode_1632(proc->opcodes[X86_OP_TEST_RM1632_R1632], 0x85, "test", x86_read_instr_test_rm1632_with_r1632);
+ case XOP_ADD_R1632_RM1632:
+ result = x86_read_instr_add_r1632_rm1632(data, pos, len, addr, prefix, proc);
+ break;
- register_opcode(proc->opcodes[X86_OP_MOV_RM8_R8], 0x88, "mov", x86_read_instr_mov_rm8_r8);
- register_opcode_1632(proc->opcodes[X86_OP_MOV_RM1632_R1632], 0x89, "mov", x86_read_instr_mov_r1632_to_rm1632);
+ case XOP_ADD_AL_IMM8:
+ result = x86_read_instr_add_al_imm8(data, pos, len, addr, prefix, proc);
+ break;
- register_opcode_1632(proc->opcodes[X86_OP_MOV_R1632_RM1632], 0x8b, "mov", x86_read_instr_mov_rm1632_to_r1632);
+ case XOP_ADD_E_AX_IMM1632:
+ result = x86_read_instr_add_e_ax_imm1632(data, pos, len, addr, prefix, proc);
+ break;
- register_opcode_1632(proc->opcodes[X86_OP_LEA], 0x8d, "lea", x86_read_instr_lea);
- register_opcode(proc->opcodes[X86_OP_NOP], 0x90, "nop", x86_read_instr_nop);
+ case XOP_OR_R8_RM8:
+ result = x86_read_instr_or_r8_rm8(data, pos, len, addr, prefix, proc);
+ break;
- register_opcode(proc->opcodes[X86_OP_MOV_MOFFS_TO_AL], 0xa0, "mov", x86_read_instr_mov_moffs8_to_al);
- register_opcode_1632(proc->opcodes[X86_OP_MOV_MOFFS_TO_E_AX], 0xa1, "mov", x86_read_instr_mov_moffs1632_to_e_ax);
- register_opcode(proc->opcodes[X86_OP_MOV_AL_TO_MOFFS], 0xa2, "mov", x86_read_instr_mov_al_to_moffs8);
- register_opcode_1632(proc->opcodes[X86_OP_MOV_E_AX_TO_MOFFS], 0xa3, "mov", x86_read_instr_mov_e_ax_to_moffs1632);
+ case XOP_OR_AL_IMM8:
+ result = x86_read_instr_or_al_imm8(data, pos, len, addr, prefix, proc);
+ break;
- register_opcode(proc->opcodes[X86_OP_TEST_AL], 0xa8, "test", x86_read_instr_test_al);
- register_opcode_1632(proc->opcodes[X86_OP_TEST_E_AX], 0xa9, "test", x86_read_instr_test_e_ax);
-
- register_opcode_1632(proc->opcodes[X86_OP_MOV_E_AX], 0xb8, "mov", x86_read_instr_mov_imm1632_to_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_MOV_E_CX], 0xb9, "mov", x86_read_instr_mov_imm1632_to_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_MOV_E_DX], 0xba, "mov", x86_read_instr_mov_imm1632_to_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_MOV_E_BX], 0xbb, "mov", x86_read_instr_mov_imm1632_to_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_MOV_E_SP], 0xbc, "mov", x86_read_instr_mov_imm1632_to_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_MOV_E_BP], 0xbd, "mov", x86_read_instr_mov_imm1632_to_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_MOV_E_SI], 0xbe, "mov", x86_read_instr_mov_imm1632_to_r1632);
- register_opcode_1632(proc->opcodes[X86_OP_MOV_E_DI], 0xbf, "mov", x86_read_instr_mov_imm1632_to_r1632);
-
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_ROL_RM1632_IMM8], 0xc1, 0, "rol", x86_read_instr_rol_rm1632_imm8);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_ROR_RM1632_IMM8], 0xc1, 1, "ror", x86_read_instr_ror_rm1632_imm8);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_RCL_RM1632_IMM8], 0xc1, 2, "rcl", x86_read_instr_rcl_rm1632_imm8);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_RCR_RM1632_IMM8], 0xc1, 3, "rcr", x86_read_instr_rcr_rm1632_imm8);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_SHL_RM1632_IMM8], 0xc1, 4, "shl", x86_read_instr_shl_rm1632_imm8);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_SHR_RM1632_IMM8], 0xc1, 5, "shr", x86_read_instr_shr_rm1632_imm8);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_SAL_RM1632_IMM8], 0xc1, 6, "sal", x86_read_instr_sal_rm1632_imm8);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_SAR_RM1632_IMM8], 0xc1, 7, "sar", x86_read_instr_sar_rm1632_imm8);
-
- register_opcode(proc->opcodes[X86_OP_RET], 0xc3, "ret", x86_read_instr_ret);
- register_opcode(proc->opcodes[X86_OP_MOV_IMM8_TO_RM8], 0xc6, "mov", x86_read_instr_mov_imm8_to_rm8);
- register_opcode_1632(proc->opcodes[X86_OP_MOV_IMM1632_TO_RM1632], 0xc7, "mov", x86_read_instr_mov_imm1632_to_rm1632);
- register_opcode(proc->opcodes[X86_OP_LEAVE], 0xc9, "leave", x86_read_instr_leave);
- register_opcode(proc->opcodes[X86_OP_INT_3], 0xcc, "int", x86_read_instr_int_3);
- register_opcode(proc->opcodes[X86_OP_INT], 0xcd, "int", x86_read_instr_int);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_SHL_RM1632_CL], 0xd3, 4, "shl", x86_read_instr_shl_rm1632_cl);
+ case XOP_ADC_RM8_R8:
+ result = x86_read_instr_adc_rm8_r8(data, pos, len, addr, prefix, proc);
+ break;
- register_opcode_1632(proc->opcodes[X86_OP_CALL_REL1632], 0xe8, "call", x86_read_instr_call_rel1632);
- register_opcode_1632(proc->opcodes[X86_OP_JMP_REL1632], 0xe9, "jmp", x86_read_instr_jmp_rel1632);
- register_opcode(proc->opcodes[X86_OP_JMP_8], 0xeb, "jmp", x86_read_instr_jmp_8);
+ case XOP_AND_RM8_R8:
+ result = x86_read_instr_and_rm8_r8(data, pos, len, addr, prefix, proc);
+ break;
- register_opcode(proc->opcodes[X86_OP_HLT], 0xf4, "hlt", x86_read_instr_hlt);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_NOT_RM1632], 0xf7, 7, "not", x86_read_instr_not_rm1632);
+ case XOP_SUB_RM1632_R1632:
+ result = x86_read_instr_sub_rm1632_r1632(data, pos, len, addr, prefix, proc);
+ break;
- register_opcode(proc->opcodes[X86_OP_CLD], 0xfc, "cld", x86_read_instr_cld);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_CALL_RM1632], 0xff, 2, "call", x86_read_instr_call_rm1632);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_JMP_RM1632], 0xff, 4, "jmp", x86_read_instr_jmp_rm1632);
- register_opcode_1632_with_ext(proc->opcodes[X86_OP_PUSH_RM1632], 0xff, 6, "push", x86_read_instr_push_rm1632);
+ case XOP_SUB_R8_RM8:
+ result = x86_read_instr_sub_r8_rm8(data, pos, len, addr, prefix, proc);
+ break;
- register_2b_opcode_1632(proc->opcodes[X86_OP_MOVZX_R1632_RM8], 0xb6, "movzx", x86_read_instr_movzx_r1632_rm8);
+ case XOP_SUB_AL_IMM8:
+ result = x86_read_instr_sub_al_imm8(data, pos, len, addr, prefix, proc);
+ break;
- register_2b_opcode_1632(proc->opcodes[X86_OP_MOVSX_R1632_RM8], 0xbe, "movsx", x86_read_instr_movsx_r1632_rm8);
-}
+ case XOP_SUB_E_AX_IMM1632:
+ result = x86_read_instr_sub_e_ax_imm1632(data, pos, len, addr, prefix, proc);
+ break;
+ case XOP_XOR_RM8_R8:
+ result = x86_read_instr_xor_rm8_r8(data, pos, len, addr, prefix, proc);
+ break;
-/******************************************************************************
-* *
-* Paramètres : proc = architecture visée par la procédure. *
-* 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. *
-* *
-* Description : Décode une instruction dans un flux de données. *
-* *
-* Retour : Instruction mise en place ou NULL. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
+ case XOP_XOR_RM1632_R1632:
+ result = x86_read_instr_xor_rm1632_r1632(data, pos, len, addr, prefix, proc);
+ break;
-asm_instr *x86_fetch_instruction(const asm_x86_processor *proc, const uint8_t *data, off_t *pos, off_t len, uint64_t offset)
-{
- asm_x86_instr *result; /* Résultat à faire remonter */
- X86Prefix prefix; /* Préfixe détecté */
- off_t k; /* Itération sur le contenu */
- X86Opcodes i; /* Boucle de parcours */
+ case XOP_XOR_R8_RM8:
+ result = x86_read_instr_xor_r8_rm8(data, pos, len, addr, prefix, proc);
+ break;
- result = NULL;
+ case XOP_XOR_R1632_RM1632:
+ result = x86_read_instr_xor_r1632_rm1632(data, pos, len, addr, prefix, proc);
+ break;
- prefix = X86_PRE_NONE;
+ case XOP_XOR_AL_IMM8:
+ result = x86_read_instr_xor_al_imm8(data, pos, len, addr, prefix, proc);
+ break;
- for (k = *pos; k < len; k++)
- switch (data[k])
- {
- case 0x66:
- prefix |= X86_PRE_OPSIZE;
- break;
+ case XOP_XOR_E_AX_IMM1632:
+ result = x86_read_instr_xor_e_ax_imm1632(data, pos, len, addr, prefix, proc);
+ break;
- case 0x0f:
- prefix |= X86_PRE_ESCAPE;
- break;
- default:
- goto found_instr;
- break;
- }
+ case XOP_CMP_RM1632_R1632:
+ result = x86_read_instr_cmp_rm1632_r1632(data, pos, len, addr, prefix, proc);
+ break;
- /* Contenu binaire tronqué */
- return NULL;
+ case XOP_INC_E_AX:
+ case XOP_INC_E_CX:
+ case XOP_INC_E_DX:
+ case XOP_INC_E_BX:
+ case XOP_INC_E_SP:
+ case XOP_INC_E_BP:
+ case XOP_INC_E_SI:
+ case XOP_INC_E_DI:
+ result = x86_read_instr_inc_r1632(data, pos, len, addr, prefix, proc);
+ break;
- found_instr:
+ case XOP_DEC_E_AX:
+ case XOP_DEC_E_CX:
+ case XOP_DEC_E_DX:
+ case XOP_DEC_E_BX:
+ case XOP_DEC_E_SP:
+ case XOP_DEC_E_BP:
+ case XOP_DEC_E_SI:
+ case XOP_DEC_E_DI:
+ result = x86_read_instr_dec_r1632(data, pos, len, addr, prefix, proc);
+ break;
- for (i = 0; i < X86_OP_COUNT; i++)
- {
- if ((prefix & proc->opcodes[i].prefix) != prefix) continue;
+ case XOP_PUSH_E_AX:
+ case XOP_PUSH_E_CX:
+ case XOP_PUSH_E_DX:
+ case XOP_PUSH_E_BX:
+ case XOP_PUSH_E_SP:
+ case XOP_PUSH_E_BP:
+ case XOP_PUSH_E_SI:
+ case XOP_PUSH_E_DI:
+ result = x86_read_instr_push_r1632(data, pos, len, addr, prefix, proc);
+ break;
- if (data[k] != proc->opcodes[i].opcode) continue;
+ case XOP_POP_E_AX:
+ case XOP_POP_E_CX:
+ case XOP_POP_E_DX:
+ case XOP_POP_E_BX:
+ case XOP_POP_E_SP:
+ case XOP_POP_E_BP:
+ case XOP_POP_E_SI:
+ case XOP_POP_E_DI:
+ result = x86_read_instr_pop_r1632(data, pos, len, addr, prefix, proc);
+ break;
- result = proc->opcodes[i].read(data, pos, len, offset, proc);
- if (result != NULL) result->type = i;
- break;
+ case XOP_PUSH_IMM1632:
+ result = x86_read_instr_push_imm1632(data, pos, len, addr, prefix, proc);
+ break;
- }
- return ASM_INSTRUCTION(result);
-}
+ case XOP_JO_REL8:
+ result = x86_read_instr_jo_rel8(data, pos, len, addr, prefix, proc);
+ break;
+ case XOP_JNO_REL8:
+ result = x86_read_instr_jno_rel8(data, pos, len, addr, prefix, proc);
+ break;
-/******************************************************************************
-* *
-* Paramètres : proc = architecture visée par la procédure. *
-* format = format du binaire manipulé. *
-* instr = instruction à traiter. *
-* buffer = tampon de sortie mis à disposition. [OUT] *
-* len = taille de ce tampon. *
-* syntax = type de représentation demandée. *
-* *
-* Description : Traduit une instruction en version humainement lisible. *
-* *
-* Retour : - *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
+ case XOP_JB_REL8:
+ result = x86_read_instr_jb_rel8(data, pos, len, addr, prefix, proc);
+ break;
-void x86_print_instruction(const asm_x86_processor *proc, const exe_format *format, const asm_x86_instr *instr, char *buffer, size_t len, AsmSyntax syntax)
-{
- size_t i; /* Boucle de parcours */
- char opbuffer[3][256]; /* Tampon pour les textes */
- char *label; /* Etiquette de symbole */
- SymbolType symtype; /* Type de symbole */
- uint64_t offset; /* Décallage final constaté */
- size_t oplen; /* Taille de description */
-
- /* Impression des opérandes */
-
- for (i = 0; i < ASM_INSTRUCTION(instr)->operands_count; i++)
- switch (ASM_OPERAND(ASM_INSTRUCTION(instr)->operands[i])->type)
- {
- case AOT_NONE:
- print_db_operand(ASM_OPERAND(ASM_INSTRUCTION(instr)->operands[i]), opbuffer[i], 256, syntax);
- break;
- case AOT_IMM:
- print_imm_operand(ASM_OPERAND(ASM_INSTRUCTION(instr)->operands[i]), opbuffer[i], 256, syntax);
-
- offset = ASM_OPERAND(ASM_INSTRUCTION(instr)->operands[i])->unsigned_imm.val32; /* FIXME !!! */
-
- if (ASM_OPERAND(ASM_INSTRUCTION(instr)->operands[i])->size == proc->operand_size
- && resolve_exe_symbol(format, &label, &symtype, &offset))
- {
- oplen = strlen(opbuffer[i]);
-
- switch (symtype)
- {
- case STP_SECTION:
- if (offset == 0) snprintf(&opbuffer[i][oplen], 256 - oplen, " &lt;%s&gt;", label);
- else snprintf(&opbuffer[i][oplen], 256 - oplen, " &lt;%s+0x%llx&gt;", label, offset);
- break;
-
- case STP_STRING:
- label = escape_crlf(label);
- snprintf(&opbuffer[i][oplen], 256 - oplen, " \"%s\"", label);
- break;
-
- }
-
- free(label);
-
- }
-
- break;
- case AOT_REG:
- x86_print_reg_operand(ASM_INSTRUCTION(instr)->operands[i], opbuffer[i], 256, syntax);
- break;
- case AOT_MEM:
- break;
- case AOT_MOFFS:
- x86_print_moffs_operand(ASM_INSTRUCTION(instr)->operands[i], opbuffer[i], 256, syntax);
- break;
- }
-
- /* Impression globale finale */
-
- if (ASM_INSTRUCTION(instr)->type == AIT_DB)
- snprintf(buffer, len, "db\t%s", opbuffer[0]);
-
- else
- switch (ASM_INSTRUCTION(instr)->operands_count)
- {
- case 0:
- snprintf(buffer, len, "%s", proc->opcodes[instr->type].name);
- break;
-
- case 1:
- snprintf(buffer, len, "%s\t%s", proc->opcodes[instr->type].name, opbuffer[0]);
- break;
-
- case 2:
- switch (syntax)
- {
- case ASX_INTEL:
- snprintf(buffer, len, "%s\t%s, %s", proc->opcodes[instr->type].name, opbuffer[0], opbuffer[1]);
- break;
- case ASX_ATT:
- snprintf(buffer, len, "%s\t%s, %s", proc->opcodes[instr->type].name, opbuffer[1], opbuffer[0]);
- break;
- }
- break;
-
- }
+ case XOP_JNB_REL8:
+ result = x86_read_instr_jnb_rel8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_JE_REL8:
+ result = x86_read_instr_je_rel8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_JNE_REL8:
+ result = x86_read_instr_jne_rel8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_JNA_REL8:
+ result = x86_read_instr_jna_rel8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_JA_REL8:
+ result = x86_read_instr_ja_rel8(data, pos, len, addr, prefix, proc);
+ break;
-}
+ case XOP_JS_REL8:
+ result = x86_read_instr_js_rel8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_JNS_REL8:
+ result = x86_read_instr_jns_rel8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_JP_REL8:
+ result = x86_read_instr_jp_rel8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_JNP_REL8:
+ result = x86_read_instr_jnp_rel8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_JL_REL8:
+ result = x86_read_instr_jl_rel8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_JNL_REL8:
+ result = x86_read_instr_jnl_rel8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_JNG_REL8:
+ result = x86_read_instr_jng_rel8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_JG_REL8:
+ result = x86_read_instr_jg_rel8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_ADD_RM8_IMM8:
+ result = x86_read_instr_add_rm8_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_OR_RM8_IMM8:
+ result = x86_read_instr_or_rm8_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_ADC_RM8_IMM8:
+ result = x86_read_instr_adc_rm8_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_SBB_RM8_IMM8:
+ result = x86_read_instr_sbb_rm8_imm8(data, pos, len, addr, prefix, proc);
+ break;
+ case XOP_AND_RM8_IMM8:
+ result = x86_read_instr_and_rm8_imm8(data, pos, len, addr, prefix, proc);
+ break;
+ case XOP_SUB_RM8_IMM8:
+ result = x86_read_instr_sub_rm8_imm8(data, pos, len, addr, prefix, proc);
+ break;
+ case XOP_XOR_RM8_IMM8:
+ result = x86_read_instr_xor_rm8_imm8(data, pos, len, addr, prefix, proc);
+ break;
+ case XOP_CMP_RM8_IMM8:
+ result = x86_read_instr_cmp_rm8_imm8(data, pos, len, addr, prefix, proc);
+ break;
+ case XOP_ADD_RM1632_IMM1632:
+ result = x86_read_instr_add_rm1632_imm1632(data, pos, len, addr, prefix, proc);
+ break;
+ case XOP_OR_RM1632_IMM1632:
+ result = x86_read_instr_or_rm1632_imm1632(data, pos, len, addr, prefix, proc);
+ break;
+ case XOP_ADC_RM1632_IMM1632:
+ result = x86_read_instr_adc_rm1632_imm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_SBB_RM1632_IMM1632:
+ result = x86_read_instr_sbb_rm1632_imm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_AND_RM1632_IMM1632:
+ result = x86_read_instr_and_rm1632_imm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_SUB_RM1632_IMM1632:
+ result = x86_read_instr_sub_rm1632_imm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_XOR_RM1632_IMM1632:
+ result = x86_read_instr_xor_rm1632_imm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_CMP_RM1632_IMM1632:
+ result = x86_read_instr_cmp_rm1632_imm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+
+
+
+
+ case XOP_ADD_RM1632_IMM8:
+ result = x86_read_instr_add_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_OR_RM1632_IMM8:
+ result = x86_read_instr_or_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_ADC_RM1632_IMM8:
+ result = x86_read_instr_adc_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_SBB_RM1632_IMM8:
+ result = x86_read_instr_sbb_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_AND_RM1632_IMM8:
+ result = x86_read_instr_and_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_SUB_RM1632_IMM8:
+ result = x86_read_instr_sub_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_XOR_RM1632_IMM8:
+ result = x86_read_instr_xor_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_CMP_RM1632_IMM8:
+ result = x86_read_instr_cmp_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+
+ case XOP_TEST_RM8_R8:
+ result = x86_read_instr_test_rm8_r8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_TEST_RM1632_R1632:
+ result = x86_read_instr_test_rm1632_r1632(data, pos, len, addr, prefix, proc);
+ break;
+
+
+ case XOP_MOV_RM8_R8:
+ result = x86_read_instr_mov_rm8_r8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_MOV_RM1632_R1632:
+ result = x86_read_instr_mov_rm1632_r1632(data, pos, len, addr, prefix, proc);
+ break;
+
+
+ case XOP_MOV_R1632_RM1632:
+ result = x86_read_instr_mov_r1632_rm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_LEA_R1632_M:
+ result = x86_read_instr_lea_r1632_m(data, pos, len, addr, prefix, proc);
+ break;
+
+
+ case XOP_NOP:
+ result = x86_read_instr_nop(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_XCHG_R1632_E_AX:
+ case XOP_XCHG_R1632_E_CX:
+ case XOP_XCHG_R1632_E_DX:
+ case XOP_XCHG_R1632_E_BX:
+ case XOP_XCHG_R1632_E_SP:
+ case XOP_XCHG_R1632_E_BP:
+ case XOP_XCHG_R1632_E_SI:
+ case XOP_XCHG_R1632_E_DI:
+ result = x86_read_instr_xchg_r1632_e_ax(data, pos, len, addr, prefix, proc);
+ break;
+
+
+
+ case XOP_MOV_AL_MOFFS8:
+ result = x86_read_instr_mov_al_moffs8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_MOV_E_AX_MOFFS1632:
+ result = x86_read_instr_mov_e_ax_moffs1632(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_MOV_MOFFS8_AL:
+ result = x86_read_instr_mov_moffs8_al(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_MOV_MOFFS1632_E_AX:
+ result = x86_read_instr_mov_moffs1632_e_ax(data, pos, len, addr, prefix, proc);
+ break;
+
+
+
+ case XOP_TEST_AL_IMM8:
+ result = x86_read_instr_test_al_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_TEST_E_AX_IMM1632:
+ result = x86_read_instr_test_e_ax_imm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+
+
+
+ case XOP_MOV_E_AX_IMM1632:
+ case XOP_MOV_E_CX_IMM1632:
+ case XOP_MOV_E_DX_IMM1632:
+ case XOP_MOV_E_BX_IMM1632:
+ case XOP_MOV_E_SP_IMM1632:
+ case XOP_MOV_E_BP_IMM1632:
+ case XOP_MOV_E_SI_IMM1632:
+ case XOP_MOV_E_DI_IMM1632:
+ result = x86_read_instr_mov_r1632_imm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+
+
+
+ case XOP_ROL_RM1632_IMM8:
+ result = x86_read_instr_rol_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_ROR_RM1632_IMM8:
+ result = x86_read_instr_ror_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_RCL_RM1632_IMM8:
+ result = x86_read_instr_rcl_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_RCR_RM1632_IMM8:
+ result = x86_read_instr_rcr_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_SHL_RM1632_IMM8:
+ result = x86_read_instr_shl_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_SHR_RM1632_IMM8:
+ result = x86_read_instr_shr_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_SAL_RM1632_IMM8:
+ result = x86_read_instr_sal_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_SAR_RM1632_IMM8:
+ result = x86_read_instr_sar_rm1632_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+
+
+
+
+
+ case XOP_RET:
+ result = x86_read_instr_ret(data, pos, len, addr, prefix, proc);
+ break;
+
+
+
+ case XOP_MOV_RM8_IMM8:
+ result = x86_read_instr_mov_rm8_imm8(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_MOV_RM1632_IMM1632:
+ result = x86_read_instr_mov_rm1632_imm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+
+
+
+ case XOP_LEAVE:
+ result = x86_read_instr_leave(data, pos, len, addr, prefix, proc);
+ break;
+
+
+
+ case XOP_INT_3:
+ result = x86_read_instr_int_3(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_INT:
+ result = x86_read_instr_int(data, pos, len, addr, prefix, proc);
+ break;
+
+
+ case XOP_SHL_RM1632_CL:
+ result = x86_read_instr_shl_rm1632_cl(data, pos, len, addr, prefix, proc);
+ break;
+
+
+ case XOP_CALL_REL1632:
+ result = x86_read_instr_call_rel1632(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_JMP_REL1632:
+ result = x86_read_instr_jmp_rel1632(data, pos, len, addr, prefix, proc);
+ break;
+
+
+
+ case XOP_JMP_REL8:
+ result = x86_read_instr_jmp_rel8(data, pos, len, addr, prefix, proc);
+ break;
+
+
+
+ case XOP_HLT:
+ result = x86_read_instr_hlt(data, pos, len, addr, prefix, proc);
+ break;
+
+
+ case XOP_NOT_RM1632:
+ result = x86_read_instr_not_rm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+
+ case XOP_CLD:
+ result = x86_read_instr_cld(data, pos, len, addr, prefix, proc);
+ break;
+
+
+ case XOP_CALL_RM1632:
+ result = x86_read_instr_call_rm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_JMP_RM1632:
+ result = x86_read_instr_jmp_rm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+ case XOP_PUSH_RM1632:
+ result = x86_read_instr_push_rm1632(data, pos, len, addr, prefix, proc);
+ break;
+
+ default:
+ result = NULL;
+ break;
+
+ }
+
+ return result;
+
+}
diff --git a/src/arch/x86/processor.h b/src/arch/x86/processor.h
index 036966f..1014d11 100644
--- a/src/arch/x86/processor.h
+++ b/src/arch/x86/processor.h
@@ -25,24 +25,32 @@
#define _ARCH_X86_PROCESSOR_H
-#include "../instruction.h"
#include "../processor.h"
+#include "instruction.h"
-/* Définition générique d'une architecture */
-typedef struct _asm_x86_processor asm_x86_processor;
+#define G_TYPE_X86_PROCESSOR g_x86_processor_get_type()
+#define G_X86_PROCESSOR(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_x86_processor_get_type(), GX86Processor))
+#define G_IS_X86_PROCESSOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_x86_processor_get_type()))
+#define G_X86_PROCESSOR_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_x86_processor_get_type(), GX86ProcessorIface))
-/* Crée le support de l'architecture x86. */
-asm_processor *create_x86_processor(void);
+/* Définition du processeur de la x86 (instance) */
+typedef struct _GX86Processor GX86Processor;
-/* Fournit la taille courante des opérandes pour x86. */
-AsmOperandSize get_x86_current_operand_size(const asm_x86_processor *);
+/* Définition du processeur de la x86 (classe) */
+typedef struct _GX86ProcessorClass GX86ProcessorClass;
-/* Fournit la taille supplantée des opérandes pour x86. */
-AsmOperandSize switch_x86_operand_size_if_needed(const asm_x86_processor *, const uint8_t *, off_t *);
+/* Indique le type défini par la GLib pour le processeur x86. */
+GType g_x86_processor_get_type(void);
+
+/* Crée le support de l'architecture x86. */
+GArchProcessor *g_x86_processor_new(void);
+
+/* Fournit la taille supplantée des opérandes pour x86. */
+AsmOperandSize g_x86_processor_get_operand_size(const GX86Processor *, X86Prefix);