#include <stdlib.h> #include <string.h> #include "ia32_reg.h" #include "ia32_insn.h" #define NUM_X86_REGS 92 /* register sizes */ #define REG_DWORD_SIZE 4 #define REG_WORD_SIZE 2 #define REG_BYTE_SIZE 1 #define REG_MMX_SIZE 8 #define REG_SIMD_SIZE 16 #define REG_DEBUG_SIZE 4 #define REG_CTRL_SIZE 4 #define REG_TEST_SIZE 4 #define REG_SEG_SIZE 2 #define REG_FPU_SIZE 10 #define REG_FLAGS_SIZE 4 #define REG_FPCTRL_SIZE 2 #define REG_FPSTATUS_SIZE 2 #define REG_FPTAG_SIZE 2 #define REG_EIP_SIZE 4 #define REG_IP_SIZE 2 /* REGISTER ALIAS TABLE: * * NOTE: the MMX register mapping is fixed to the physical registers * used by the FPU. The floating FP stack does not effect the location * of the MMX registers, so this aliasing is not 100% accurate. * */ static struct { unsigned char alias; /* id of register this is an alias for */ unsigned char shift; /* # of bits register must be shifted */ } ia32_reg_aliases[] = { { 0,0 }, { REG_DWORD_OFFSET, 0 }, /* al : 1 */ { REG_DWORD_OFFSET, 8 }, /* ah : 2 */ { REG_DWORD_OFFSET, 0 }, /* ax : 3 */ { REG_DWORD_OFFSET + 1, 0 }, /* cl : 4 */ { REG_DWORD_OFFSET + 1, 8 }, /* ch : 5 */ { REG_DWORD_OFFSET + 1, 0 }, /* cx : 6 */ { REG_DWORD_OFFSET + 2, 0 }, /* dl : 7 */ { REG_DWORD_OFFSET + 2, 8 }, /* dh : 8 */ { REG_DWORD_OFFSET + 2, 0 }, /* dx : 9 */ { REG_DWORD_OFFSET + 3, 0 }, /* bl : 10 */ { REG_DWORD_OFFSET + 3, 8 }, /* bh : 11 */ { REG_DWORD_OFFSET + 3, 0 }, /* bx : 12 */ { REG_DWORD_OFFSET + 4, 0 }, /* sp : 13 */ { REG_DWORD_OFFSET + 5, 0 }, /* bp : 14 */ { REG_DWORD_OFFSET + 6, 0 }, /* si : 15 */ { REG_DWORD_OFFSET + 7, 0 }, /* di : 16 */ { REG_EIP_INDEX, 0 }, /* ip : 17 */ { REG_FPU_OFFSET, 0 }, /* mm0 : 18 */ { REG_FPU_OFFSET + 1, 0 }, /* mm1 : 19 */ { REG_FPU_OFFSET + 2, 0 }, /* mm2 : 20 */ { REG_FPU_OFFSET + 3, 0 }, /* mm3 : 21 */ { REG_FPU_OFFSET + 4, 0 }, /* mm4 : 22 */ { REG_FPU_OFFSET + 5, 0 }, /* mm5 : 23 */ { REG_FPU_OFFSET + 6, 0 }, /* mm6 : 24 */ { REG_FPU_OFFSET + 7, 0 } /* mm7 : 25 */ }; /* REGISTER TABLE: size, type, and name of every register in the * CPU. Does not include MSRs since the are, after all, * model specific. */ static struct { unsigned int size; enum x86_reg_type type; unsigned int alias; char mnemonic[8]; } ia32_reg_table[NUM_X86_REGS + 2] = { { 0, 0, 0, "" }, /* REG_DWORD_OFFSET */ { REG_DWORD_SIZE, reg_gen | reg_ret, 0, "eax" }, { REG_DWORD_SIZE, reg_gen | reg_count, 0, "ecx" }, { REG_DWORD_SIZE, reg_gen, 0, "edx" }, { REG_DWORD_SIZE, reg_gen, 0, "ebx" }, /* REG_ESP_INDEX */ { REG_DWORD_SIZE, reg_gen | reg_sp, 0, "esp" }, { REG_DWORD_SIZE, reg_gen | reg_fp, 0, "ebp" }, { REG_DWORD_SIZE, reg_gen | reg_src, 0, "esi" }, { REG_DWORD_SIZE, reg_gen | reg_dest, 0, "edi" }, /* REG_WORD_OFFSET */ { REG_WORD_SIZE, reg_gen | reg_ret, 3, "ax" }, { REG_WORD_SIZE, reg_gen | reg_count, 6, "cx" }, { REG_WORD_SIZE, reg_gen, 9, "dx" }, { REG_WORD_SIZE, reg_gen, 12, "bx" }, { REG_WORD_SIZE, reg_gen | reg_sp, 13, "sp" }, { REG_WORD_SIZE, reg_gen | reg_fp, 14, "bp" }, { REG_WORD_SIZE, reg_gen | reg_src, 15, "si" }, { REG_WORD_SIZE, reg_gen | reg_dest, 16, "di" }, /* REG_BYTE_OFFSET */ { REG_BYTE_SIZE, reg_gen, 1, "al" }, { REG_BYTE_SIZE, reg_gen, 4, "cl" }, { REG_BYTE_SIZE, reg_gen, 7, "dl" }, { REG_BYTE_SIZE, reg_gen, 10, "bl" }, { REG_BYTE_SIZE, reg_gen, 2, "ah" }, { REG_BYTE_SIZE, reg_gen, 5, "ch" }, { REG_BYTE_SIZE, reg_gen, 8, "dh" }, { REG_BYTE_SIZE, reg_gen, 11, "bh" }, /* REG_MMX_OFFSET */ { REG_MMX_SIZE, reg_simd, 18, "mm0" }, { REG_MMX_SIZE, reg_simd, 19, "mm1" }, { REG_MMX_SIZE, reg_simd, 20, "mm2" }, { REG_MMX_SIZE, reg_simd, 21, "mm3" }, { REG_MMX_SIZE, reg_simd, 22, "mm4" }, { REG_MMX_SIZE, reg_simd, 23, "mm5" }, { REG_MMX_SIZE, reg_simd, 24, "mm6" }, { REG_MMX_SIZE, reg_simd, 25, "mm7" }, /* REG_SIMD_OFFSET */ { REG_SIMD_SIZE, reg_simd, 0, "xmm0" }, { REG_SIMD_SIZE, reg_simd, 0, "xmm1" }, { REG_SIMD_SIZE, reg_simd, 0, "xmm2" }, { REG_SIMD_SIZE, reg_simd, 0, "xmm3" }, { REG_SIMD_SIZE, reg_simd, 0, "xmm4" }, { REG_SIMD_SIZE, reg_simd, 0, "xmm5" }, { REG_SIMD_SIZE, reg_simd, 0, "xmm6" }, { REG_SIMD_SIZE, reg_simd, 0, "xmm7" }, /* REG_DEBUG_OFFSET */ { REG_DEBUG_SIZE, reg_sys, 0, "dr0" }, { REG_DEBUG_SIZE, reg_sys, 0, "dr1" }, { REG_DEBUG_SIZE, reg_sys, 0, "dr2" }, { REG_DEBUG_SIZE, reg_sys, 0, "dr3" }, { REG_DEBUG_SIZE, reg_sys, 0, "dr4" }, { REG_DEBUG_SIZE, reg_sys, 0, "dr5" }, { REG_DEBUG_SIZE, reg_sys, 0, "dr6" }, { REG_DEBUG_SIZE, reg_sys, 0, "dr7" }, /* REG_CTRL_OFFSET */ { REG_CTRL_SIZE, reg_sys, 0, "cr0" }, { REG_CTRL_SIZE, reg_sys, 0, "cr1" }, { REG_CTRL_SIZE, reg_sys, 0, "cr2" }, { REG_CTRL_SIZE, reg_sys, 0, "cr3" }, { REG_CTRL_SIZE, reg_sys, 0, "cr4" }, { REG_CTRL_SIZE, reg_sys, 0, "cr5" }, { REG_CTRL_SIZE, reg_sys, 0, "cr6" }, { REG_CTRL_SIZE, reg_sys, 0, "cr7" }, /* REG_TEST_OFFSET */ { REG_TEST_SIZE, reg_sys, 0, "tr0" }, { REG_TEST_SIZE, reg_sys, 0, "tr1" }, { REG_TEST_SIZE, reg_sys, 0, "tr2" }, { REG_TEST_SIZE, reg_sys, 0, "tr3" }, { REG_TEST_SIZE, reg_sys, 0, "tr4" }, { REG_TEST_SIZE, reg_sys, 0, "tr5" }, { REG_TEST_SIZE, reg_sys, 0, "tr6" }, { REG_TEST_SIZE, reg_sys, 0, "tr7" }, /* REG_SEG_OFFSET */ { REG_SEG_SIZE, reg_seg, 0, "es" }, { REG_SEG_SIZE, reg_seg, 0, "cs" }, { REG_SEG_SIZE, reg_seg, 0, "ss" }, { REG_SEG_SIZE, reg_seg, 0, "ds" }, { REG_SEG_SIZE, reg_seg, 0, "fs" }, { REG_SEG_SIZE, reg_seg, 0, "gs" }, /* REG_LDTR_INDEX */ { REG_DWORD_SIZE, reg_sys, 0, "ldtr" }, /* REG_GDTR_INDEX */ { REG_DWORD_SIZE, reg_sys, 0, "gdtr" }, /* REG_FPU_OFFSET */ { REG_FPU_SIZE, reg_fpu, 0, "st(0)" }, { REG_FPU_SIZE, reg_fpu, 0, "st(1)" }, { REG_FPU_SIZE, reg_fpu, 0, "st(2)" }, { REG_FPU_SIZE, reg_fpu, 0, "st(3)" }, { REG_FPU_SIZE, reg_fpu, 0, "st(4)" }, { REG_FPU_SIZE, reg_fpu, 0, "st(5)" }, { REG_FPU_SIZE, reg_fpu, 0, "st(6)" }, { REG_FPU_SIZE, reg_fpu, 0, "st(7)" }, /* REG_FLAGS_INDEX : 81 */ { REG_FLAGS_SIZE, reg_cond, 0, "eflags" }, /* REG_FPCTRL_INDEX : 82*/ { REG_FPCTRL_SIZE, reg_fpu | reg_sys, 0, "fpctrl" }, /* REG_FPSTATUS_INDEX : 83*/ { REG_FPSTATUS_SIZE, reg_fpu | reg_sys, 0, "fpstat" }, /* REG_FPTAG_INDEX : 84 */ { REG_FPTAG_SIZE, reg_fpu | reg_sys, 0, "fptag" }, /* REG_EIP_INDEX : 85 */ { REG_EIP_SIZE, reg_pc, 0, "eip" }, /* REG_IP_INDEX : 86 */ { REG_IP_SIZE, reg_pc, 17, "ip" }, /* REG_IDTR_INDEX : 87 */ { REG_DWORD_SIZE, reg_sys, 0, "idtr" }, /* REG_MXCSG_INDEX : SSE Control Reg : 88 */ { REG_DWORD_SIZE, reg_sys | reg_simd, 0, "mxcsr" }, /* REG_TR_INDEX : Task Register : 89 */ { 16 + 64, reg_sys, 0, "tr" }, /* REG_CSMSR_INDEX : SYSENTER_CS_MSR : 90 */ { REG_DWORD_SIZE, reg_sys, 0, "cs_msr" }, /* REG_ESPMSR_INDEX : SYSENTER_ESP_MSR : 91 */ { REG_DWORD_SIZE, reg_sys, 0, "esp_msr" }, /* REG_EIPMSR_INDEX : SYSENTER_EIP_MSR : 92 */ { REG_DWORD_SIZE, reg_sys, 0, "eip_msr" }, { 0 } }; static size_t sz_regtable = NUM_X86_REGS + 1; void ia32_handle_register( x86_reg_t *reg, size_t id ) { unsigned int alias; if (! id || id > sz_regtable ) { return; } memset( reg, 0, sizeof(x86_reg_t) ); strncpy( reg->name, ia32_reg_table[id].mnemonic, MAX_REGNAME ); reg->type = ia32_reg_table[id].type; reg->size = ia32_reg_table[id].size; alias = ia32_reg_table[id].alias; if ( alias ) { reg->alias = ia32_reg_aliases[alias].alias; reg->shift = ia32_reg_aliases[alias].shift; } reg->id = id; return; } size_t ia32_true_register_id( size_t id ) { size_t reg; if (! id || id > sz_regtable ) { return 0; } reg = id; if (ia32_reg_table[reg].alias) { reg = ia32_reg_aliases[ia32_reg_table[reg].alias].alias; } return reg; }