diff options
Diffstat (limited to 'xorg-server/hw/xfree86/x86emu/decode.c')
| -rw-r--r-- | xorg-server/hw/xfree86/x86emu/decode.c | 1068 |
1 files changed, 534 insertions, 534 deletions
diff --git a/xorg-server/hw/xfree86/x86emu/decode.c b/xorg-server/hw/xfree86/x86emu/decode.c index 9339f4c7f..12f8fb84b 100644 --- a/xorg-server/hw/xfree86/x86emu/decode.c +++ b/xorg-server/hw/xfree86/x86emu/decode.c @@ -46,25 +46,27 @@ REMARKS: Handles any pending asychronous interrupts. ****************************************************************************/ -static void x86emu_intr_handle(void) +static void +x86emu_intr_handle(void) { - u8 intno; - - if (M.x86.intr & INTR_SYNCH) { - intno = M.x86.intno; - if (_X86EMU_intrTab[intno]) { - (*_X86EMU_intrTab[intno])(intno); - } else { - push_word((u16)M.x86.R_FLG); - CLEAR_FLAG(F_IF); - CLEAR_FLAG(F_TF); - push_word(M.x86.R_CS); - M.x86.R_CS = mem_access_word(intno * 4 + 2); - push_word(M.x86.R_IP); - M.x86.R_IP = mem_access_word(intno * 4); - M.x86.intr = 0; - } - } + u8 intno; + + if (M.x86.intr & INTR_SYNCH) { + intno = M.x86.intno; + if (_X86EMU_intrTab[intno]) { + (*_X86EMU_intrTab[intno]) (intno); + } + else { + push_word((u16) M.x86.R_FLG); + CLEAR_FLAG(F_IF); + CLEAR_FLAG(F_TF); + push_word(M.x86.R_CS); + M.x86.R_CS = mem_access_word(intno * 4 + 2); + push_word(M.x86.R_IP); + M.x86.R_IP = mem_access_word(intno * 4); + M.x86.intr = 0; + } + } } /**************************************************************************** @@ -75,11 +77,11 @@ REMARKS: Raise the specified interrupt to be handled before the execution of the next instruction. ****************************************************************************/ -void x86emu_intr_raise( - u8 intrnum) +void +x86emu_intr_raise(u8 intrnum) { - M.x86.intno = intrnum; - M.x86.intr |= INTR_SYNCH; + M.x86.intno = intrnum; + M.x86.intr |= INTR_SYNCH; } /**************************************************************************** @@ -88,38 +90,39 @@ Main execution loop for the emulator. We return from here when the system halts, which is normally caused by a stack fault when we return from the original real mode call. ****************************************************************************/ -void X86EMU_exec(void) +void +X86EMU_exec(void) { - u8 op1; - - M.x86.intr = 0; - DB(x86emu_end_instr();) - - for (;;) { -DB( if (CHECK_IP_FETCH()) - x86emu_check_ip_access();) - /* If debugging, save the IP and CS values. */ - SAVE_IP_CS(M.x86.R_CS, M.x86.R_IP); - INC_DECODED_INST_LEN(1); - if (M.x86.intr) { - if (M.x86.intr & INTR_HALTED) { -DB( if (M.x86.R_SP != 0) { - printk("halted\n"); - X86EMU_trace_regs(); - } - else { - if (M.x86.debug) - printk("Service completed successfully\n"); - }) - return; + u8 op1; + + M.x86.intr = 0; + DB(x86emu_end_instr(); + ) + + for (;;) { + DB(if (CHECK_IP_FETCH()) + x86emu_check_ip_access();) + /* If debugging, save the IP and CS values. */ + SAVE_IP_CS(M.x86.R_CS, M.x86.R_IP); + INC_DECODED_INST_LEN(1); + if (M.x86.intr) { + if (M.x86.intr & INTR_HALTED) { + DB(if (M.x86.R_SP != 0) { + printk("halted\n"); X86EMU_trace_regs();} + else { + if (M.x86.debug) + printk("Service completed successfully\n");} + ) + return; } - if (((M.x86.intr & INTR_SYNCH) && (M.x86.intno == 0 || M.x86.intno == 2)) || - !ACCESS_FLAG(F_IF)) { - x86emu_intr_handle(); - } - } - op1 = (*sys_rdb)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP++)); - (*x86emu_optab[op1])(op1); + if (((M.x86.intr & INTR_SYNCH) && + (M.x86.intno == 0 || M.x86.intno == 2)) || + !ACCESS_FLAG(F_IF)) { + x86emu_intr_handle(); + } + } + op1 = (*sys_rdb) (((u32) M.x86.R_CS << 4) + (M.x86.R_IP++)); + (*x86emu_optab[op1]) (op1); if (M.x86.debug & DEBUG_EXIT) { M.x86.debug &= ~DEBUG_EXIT; return; @@ -131,9 +134,10 @@ DB( if (M.x86.R_SP != 0) { REMARKS: Halts the system by setting the halted system flag. ****************************************************************************/ -void X86EMU_halt_sys(void) +void +X86EMU_halt_sys(void) { - M.x86.intr |= INTR_HALTED; + M.x86.intr |= INTR_HALTED; } /**************************************************************************** @@ -148,19 +152,17 @@ next instruction. NOTE: Do not inline this function, as (*sys_rdb) is already inline! ****************************************************************************/ -void fetch_decode_modrm( - int *mod, - int *regh, - int *regl) +void +fetch_decode_modrm(int *mod, int *regh, int *regl) { - int fetched; - -DB( if (CHECK_IP_FETCH()) - x86emu_check_ip_access();) - fetched = (*sys_rdb)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP++)); - INC_DECODED_INST_LEN(1); - *mod = (fetched >> 6) & 0x03; - *regh = (fetched >> 3) & 0x07; + int fetched; + + DB(if (CHECK_IP_FETCH()) + x86emu_check_ip_access();) + fetched = (*sys_rdb) (((u32) M.x86.R_CS << 4) + (M.x86.R_IP++)); + INC_DECODED_INST_LEN(1); + *mod = (fetched >> 6) & 0x03; + *regh = (fetched >> 3) & 0x07; *regl = (fetched >> 0) & 0x07; } @@ -174,15 +176,16 @@ moves the instruction pointer to the next value. NOTE: Do not inline this function, as (*sys_rdb) is already inline! ****************************************************************************/ -u8 fetch_byte_imm(void) +u8 +fetch_byte_imm(void) { - u8 fetched; + u8 fetched; -DB( if (CHECK_IP_FETCH()) - x86emu_check_ip_access();) - fetched = (*sys_rdb)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP++)); - INC_DECODED_INST_LEN(1); - return fetched; + DB(if (CHECK_IP_FETCH()) + x86emu_check_ip_access();) + fetched = (*sys_rdb) (((u32) M.x86.R_CS << 4) + (M.x86.R_IP++)); + INC_DECODED_INST_LEN(1); + return fetched; } /**************************************************************************** @@ -195,16 +198,17 @@ moves the instruction pointer to the next value. NOTE: Do not inline this function, as (*sys_rdw) is already inline! ****************************************************************************/ -u16 fetch_word_imm(void) +u16 +fetch_word_imm(void) { - u16 fetched; - -DB( if (CHECK_IP_FETCH()) - x86emu_check_ip_access();) - fetched = (*sys_rdw)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP)); - M.x86.R_IP += 2; - INC_DECODED_INST_LEN(2); - return fetched; + u16 fetched; + + DB(if (CHECK_IP_FETCH()) + x86emu_check_ip_access();) + fetched = (*sys_rdw) (((u32) M.x86.R_CS << 4) + (M.x86.R_IP)); + M.x86.R_IP += 2; + INC_DECODED_INST_LEN(2); + return fetched; } /**************************************************************************** @@ -217,16 +221,17 @@ moves the instruction pointer to the next value. NOTE: Do not inline this function, as (*sys_rdw) is already inline! ****************************************************************************/ -u32 fetch_long_imm(void) +u32 +fetch_long_imm(void) { - u32 fetched; - -DB( if (CHECK_IP_FETCH()) - x86emu_check_ip_access();) - fetched = (*sys_rdl)(((u32)M.x86.R_CS << 4) + (M.x86.R_IP)); - M.x86.R_IP += 4; - INC_DECODED_INST_LEN(4); - return fetched; + u32 fetched; + + DB(if (CHECK_IP_FETCH()) + x86emu_check_ip_access();) + fetched = (*sys_rdl) (((u32) M.x86.R_CS << 4) + (M.x86.R_IP)); + M.x86.R_IP += 4; + INC_DECODED_INST_LEN(4); + return fetched; } /**************************************************************************** @@ -258,38 +263,39 @@ cpu-state-varible M.x86.mode. There are several potential states: Each of the above 7 items are handled with a bit in the mode field. ****************************************************************************/ -_INLINE u32 get_data_segment(void) +_INLINE u32 +get_data_segment(void) { #define GET_SEGMENT(segment) - switch (M.x86.mode & SYSMODE_SEGMASK) { - case 0: /* default case: use ds register */ - case SYSMODE_SEGOVR_DS: - case SYSMODE_SEGOVR_DS | SYSMODE_SEG_DS_SS: - return M.x86.R_DS; - case SYSMODE_SEG_DS_SS: /* non-overridden, use ss register */ - return M.x86.R_SS; - case SYSMODE_SEGOVR_CS: - case SYSMODE_SEGOVR_CS | SYSMODE_SEG_DS_SS: - return M.x86.R_CS; - case SYSMODE_SEGOVR_ES: - case SYSMODE_SEGOVR_ES | SYSMODE_SEG_DS_SS: - return M.x86.R_ES; - case SYSMODE_SEGOVR_FS: - case SYSMODE_SEGOVR_FS | SYSMODE_SEG_DS_SS: - return M.x86.R_FS; - case SYSMODE_SEGOVR_GS: - case SYSMODE_SEGOVR_GS | SYSMODE_SEG_DS_SS: - return M.x86.R_GS; - case SYSMODE_SEGOVR_SS: - case SYSMODE_SEGOVR_SS | SYSMODE_SEG_DS_SS: - return M.x86.R_SS; - default: + switch (M.x86.mode & SYSMODE_SEGMASK) { + case 0: /* default case: use ds register */ + case SYSMODE_SEGOVR_DS: + case SYSMODE_SEGOVR_DS | SYSMODE_SEG_DS_SS: + return M.x86.R_DS; + case SYSMODE_SEG_DS_SS: /* non-overridden, use ss register */ + return M.x86.R_SS; + case SYSMODE_SEGOVR_CS: + case SYSMODE_SEGOVR_CS | SYSMODE_SEG_DS_SS: + return M.x86.R_CS; + case SYSMODE_SEGOVR_ES: + case SYSMODE_SEGOVR_ES | SYSMODE_SEG_DS_SS: + return M.x86.R_ES; + case SYSMODE_SEGOVR_FS: + case SYSMODE_SEGOVR_FS | SYSMODE_SEG_DS_SS: + return M.x86.R_FS; + case SYSMODE_SEGOVR_GS: + case SYSMODE_SEGOVR_GS | SYSMODE_SEG_DS_SS: + return M.x86.R_GS; + case SYSMODE_SEGOVR_SS: + case SYSMODE_SEGOVR_SS | SYSMODE_SEG_DS_SS: + return M.x86.R_SS; + default: #ifdef DEBUG - printk("error: should not happen: multiple overrides.\n"); + printk("error: should not happen: multiple overrides.\n"); #endif - HALT_SYS(); - return 0; - } + HALT_SYS(); + return 0; + } } /**************************************************************************** @@ -301,14 +307,14 @@ Byte value read from the absolute memory location. NOTE: Do not inline this function as (*sys_rdX) is already inline! ****************************************************************************/ -u8 fetch_data_byte( - uint offset) +u8 +fetch_data_byte(uint offset) { #ifdef DEBUG - if (CHECK_DATA_ACCESS()) - x86emu_check_data_access((u16)get_data_segment(), offset); + if (CHECK_DATA_ACCESS()) + x86emu_check_data_access((u16) get_data_segment(), offset); #endif - return (*sys_rdb)((get_data_segment() << 4) + offset); + return (*sys_rdb) ((get_data_segment() << 4) + offset); } /**************************************************************************** @@ -320,14 +326,14 @@ Word value read from the absolute memory location. NOTE: Do not inline this function as (*sys_rdX) is already inline! ****************************************************************************/ -u16 fetch_data_word( - uint offset) +u16 +fetch_data_word(uint offset) { #ifdef DEBUG - if (CHECK_DATA_ACCESS()) - x86emu_check_data_access((u16)get_data_segment(), offset); + if (CHECK_DATA_ACCESS()) + x86emu_check_data_access((u16) get_data_segment(), offset); #endif - return (*sys_rdw)((get_data_segment() << 4) + offset); + return (*sys_rdw) ((get_data_segment() << 4) + offset); } /**************************************************************************** @@ -339,14 +345,14 @@ Long value read from the absolute memory location. NOTE: Do not inline this function as (*sys_rdX) is already inline! ****************************************************************************/ -u32 fetch_data_long( - uint offset) +u32 +fetch_data_long(uint offset) { #ifdef DEBUG - if (CHECK_DATA_ACCESS()) - x86emu_check_data_access((u16)get_data_segment(), offset); + if (CHECK_DATA_ACCESS()) + x86emu_check_data_access((u16) get_data_segment(), offset); #endif - return (*sys_rdl)((get_data_segment() << 4) + offset); + return (*sys_rdl) ((get_data_segment() << 4) + offset); } /**************************************************************************** @@ -359,15 +365,14 @@ Byte value read from the absolute memory location. NOTE: Do not inline this function as (*sys_rdX) is already inline! ****************************************************************************/ -u8 fetch_data_byte_abs( - uint segment, - uint offset) +u8 +fetch_data_byte_abs(uint segment, uint offset) { #ifdef DEBUG - if (CHECK_DATA_ACCESS()) - x86emu_check_data_access(segment, offset); + if (CHECK_DATA_ACCESS()) + x86emu_check_data_access(segment, offset); #endif - return (*sys_rdb)(((u32)segment << 4) + offset); + return (*sys_rdb) (((u32) segment << 4) + offset); } /**************************************************************************** @@ -380,15 +385,14 @@ Word value read from the absolute memory location. NOTE: Do not inline this function as (*sys_rdX) is already inline! ****************************************************************************/ -u16 fetch_data_word_abs( - uint segment, - uint offset) +u16 +fetch_data_word_abs(uint segment, uint offset) { #ifdef DEBUG - if (CHECK_DATA_ACCESS()) - x86emu_check_data_access(segment, offset); + if (CHECK_DATA_ACCESS()) + x86emu_check_data_access(segment, offset); #endif - return (*sys_rdw)(((u32)segment << 4) + offset); + return (*sys_rdw) (((u32) segment << 4) + offset); } /**************************************************************************** @@ -401,15 +405,14 @@ Long value read from the absolute memory location. NOTE: Do not inline this function as (*sys_rdX) is already inline! ****************************************************************************/ -u32 fetch_data_long_abs( - uint segment, - uint offset) +u32 +fetch_data_long_abs(uint segment, uint offset) { #ifdef DEBUG - if (CHECK_DATA_ACCESS()) - x86emu_check_data_access(segment, offset); + if (CHECK_DATA_ACCESS()) + x86emu_check_data_access(segment, offset); #endif - return (*sys_rdl)(((u32)segment << 4) + offset); + return (*sys_rdl) (((u32) segment << 4) + offset); } /**************************************************************************** @@ -423,15 +426,14 @@ the current 'default' segment, which may have been overridden. NOTE: Do not inline this function as (*sys_wrX) is already inline! ****************************************************************************/ -void store_data_byte( - uint offset, - u8 val) +void +store_data_byte(uint offset, u8 val) { #ifdef DEBUG - if (CHECK_DATA_ACCESS()) - x86emu_check_data_access((u16)get_data_segment(), offset); + if (CHECK_DATA_ACCESS()) + x86emu_check_data_access((u16) get_data_segment(), offset); #endif - (*sys_wrb)((get_data_segment() << 4) + offset, val); + (*sys_wrb) ((get_data_segment() << 4) + offset, val); } /**************************************************************************** @@ -445,15 +447,14 @@ the current 'default' segment, which may have been overridden. NOTE: Do not inline this function as (*sys_wrX) is already inline! ****************************************************************************/ -void store_data_word( - uint offset, - u16 val) +void +store_data_word(uint offset, u16 val) { #ifdef DEBUG - if (CHECK_DATA_ACCESS()) - x86emu_check_data_access((u16)get_data_segment(), offset); + if (CHECK_DATA_ACCESS()) + x86emu_check_data_access((u16) get_data_segment(), offset); #endif - (*sys_wrw)((get_data_segment() << 4) + offset, val); + (*sys_wrw) ((get_data_segment() << 4) + offset, val); } /**************************************************************************** @@ -467,15 +468,14 @@ the current 'default' segment, which may have been overridden. NOTE: Do not inline this function as (*sys_wrX) is already inline! ****************************************************************************/ -void store_data_long( - uint offset, - u32 val) +void +store_data_long(uint offset, u32 val) { #ifdef DEBUG - if (CHECK_DATA_ACCESS()) - x86emu_check_data_access((u16)get_data_segment(), offset); + if (CHECK_DATA_ACCESS()) + x86emu_check_data_access((u16) get_data_segment(), offset); #endif - (*sys_wrl)((get_data_segment() << 4) + offset, val); + (*sys_wrl) ((get_data_segment() << 4) + offset, val); } /**************************************************************************** @@ -489,16 +489,14 @@ Writes a byte value to an absolute memory location. NOTE: Do not inline this function as (*sys_wrX) is already inline! ****************************************************************************/ -void store_data_byte_abs( - uint segment, - uint offset, - u8 val) +void +store_data_byte_abs(uint segment, uint offset, u8 val) { #ifdef DEBUG - if (CHECK_DATA_ACCESS()) - x86emu_check_data_access(segment, offset); + if (CHECK_DATA_ACCESS()) + x86emu_check_data_access(segment, offset); #endif - (*sys_wrb)(((u32)segment << 4) + offset, val); + (*sys_wrb) (((u32) segment << 4) + offset, val); } /**************************************************************************** @@ -512,16 +510,14 @@ Writes a word value to an absolute memory location. NOTE: Do not inline this function as (*sys_wrX) is already inline! ****************************************************************************/ -void store_data_word_abs( - uint segment, - uint offset, - u16 val) +void +store_data_word_abs(uint segment, uint offset, u16 val) { #ifdef DEBUG - if (CHECK_DATA_ACCESS()) - x86emu_check_data_access(segment, offset); + if (CHECK_DATA_ACCESS()) + x86emu_check_data_access(segment, offset); #endif - (*sys_wrw)(((u32)segment << 4) + offset, val); + (*sys_wrw) (((u32) segment << 4) + offset, val); } /**************************************************************************** @@ -535,16 +531,14 @@ Writes a long value to an absolute memory location. NOTE: Do not inline this function as (*sys_wrX) is already inline! ****************************************************************************/ -void store_data_long_abs( - uint segment, - uint offset, - u32 val) +void +store_data_long_abs(uint segment, uint offset, u32 val) { #ifdef DEBUG - if (CHECK_DATA_ACCESS()) - x86emu_check_data_access(segment, offset); + if (CHECK_DATA_ACCESS()) + x86emu_check_data_access(segment, offset); #endif - (*sys_wrl)(((u32)segment << 4) + offset, val); + (*sys_wrl) (((u32) segment << 4) + offset, val); } /**************************************************************************** @@ -558,37 +552,37 @@ REMARKS: Return a pointer to the register given by the R/RM field of the modrm byte, for byte operands. Also enables the decoding of instructions. ****************************************************************************/ -u8* decode_rm_byte_register( - int reg) +u8 * +decode_rm_byte_register(int reg) { - switch (reg) { - case 0: - DECODE_PRINTF("AL"); - return &M.x86.R_AL; - case 1: - DECODE_PRINTF("CL"); - return &M.x86.R_CL; - case 2: - DECODE_PRINTF("DL"); - return &M.x86.R_DL; - case 3: - DECODE_PRINTF("BL"); - return &M.x86.R_BL; - case 4: - DECODE_PRINTF("AH"); - return &M.x86.R_AH; - case 5: - DECODE_PRINTF("CH"); - return &M.x86.R_CH; - case 6: - DECODE_PRINTF("DH"); - return &M.x86.R_DH; - case 7: - DECODE_PRINTF("BH"); - return &M.x86.R_BH; - } - HALT_SYS(); - return NULL; /* NOT REACHED OR REACHED ON ERROR */ + switch (reg) { + case 0: + DECODE_PRINTF("AL"); + return &M.x86.R_AL; + case 1: + DECODE_PRINTF("CL"); + return &M.x86.R_CL; + case 2: + DECODE_PRINTF("DL"); + return &M.x86.R_DL; + case 3: + DECODE_PRINTF("BL"); + return &M.x86.R_BL; + case 4: + DECODE_PRINTF("AH"); + return &M.x86.R_AH; + case 5: + DECODE_PRINTF("CH"); + return &M.x86.R_CH; + case 6: + DECODE_PRINTF("DH"); + return &M.x86.R_DH; + case 7: + DECODE_PRINTF("BH"); + return &M.x86.R_BH; + } + HALT_SYS(); + return NULL; /* NOT REACHED OR REACHED ON ERROR */ } /**************************************************************************** @@ -602,36 +596,36 @@ REMARKS: Return a pointer to the register given by the R/RM field of the modrm byte, for word operands. Also enables the decoding of instructions. ****************************************************************************/ -u16* decode_rm_word_register( - int reg) +u16 * +decode_rm_word_register(int reg) { - switch (reg) { - case 0: - DECODE_PRINTF("AX"); - return &M.x86.R_AX; - case 1: - DECODE_PRINTF("CX"); - return &M.x86.R_CX; - case 2: - DECODE_PRINTF("DX"); - return &M.x86.R_DX; - case 3: - DECODE_PRINTF("BX"); - return &M.x86.R_BX; - case 4: - DECODE_PRINTF("SP"); - return &M.x86.R_SP; - case 5: - DECODE_PRINTF("BP"); - return &M.x86.R_BP; - case 6: - DECODE_PRINTF("SI"); - return &M.x86.R_SI; - case 7: - DECODE_PRINTF("DI"); - return &M.x86.R_DI; - } - HALT_SYS(); + switch (reg) { + case 0: + DECODE_PRINTF("AX"); + return &M.x86.R_AX; + case 1: + DECODE_PRINTF("CX"); + return &M.x86.R_CX; + case 2: + DECODE_PRINTF("DX"); + return &M.x86.R_DX; + case 3: + DECODE_PRINTF("BX"); + return &M.x86.R_BX; + case 4: + DECODE_PRINTF("SP"); + return &M.x86.R_SP; + case 5: + DECODE_PRINTF("BP"); + return &M.x86.R_BP; + case 6: + DECODE_PRINTF("SI"); + return &M.x86.R_SI; + case 7: + DECODE_PRINTF("DI"); + return &M.x86.R_DI; + } + HALT_SYS(); return NULL; /* NOTREACHED OR REACHED ON ERROR */ } @@ -646,36 +640,36 @@ REMARKS: Return a pointer to the register given by the R/RM field of the modrm byte, for dword operands. Also enables the decoding of instructions. ****************************************************************************/ -u32* decode_rm_long_register( - int reg) +u32 * +decode_rm_long_register(int reg) { switch (reg) { - case 0: - DECODE_PRINTF("EAX"); - return &M.x86.R_EAX; - case 1: - DECODE_PRINTF("ECX"); - return &M.x86.R_ECX; - case 2: - DECODE_PRINTF("EDX"); - return &M.x86.R_EDX; - case 3: - DECODE_PRINTF("EBX"); - return &M.x86.R_EBX; - case 4: - DECODE_PRINTF("ESP"); - return &M.x86.R_ESP; - case 5: - DECODE_PRINTF("EBP"); - return &M.x86.R_EBP; - case 6: - DECODE_PRINTF("ESI"); - return &M.x86.R_ESI; - case 7: - DECODE_PRINTF("EDI"); - return &M.x86.R_EDI; - } - HALT_SYS(); + case 0: + DECODE_PRINTF("EAX"); + return &M.x86.R_EAX; + case 1: + DECODE_PRINTF("ECX"); + return &M.x86.R_ECX; + case 2: + DECODE_PRINTF("EDX"); + return &M.x86.R_EDX; + case 3: + DECODE_PRINTF("EBX"); + return &M.x86.R_EBX; + case 4: + DECODE_PRINTF("ESP"); + return &M.x86.R_ESP; + case 5: + DECODE_PRINTF("EBP"); + return &M.x86.R_EBP; + case 6: + DECODE_PRINTF("ESI"); + return &M.x86.R_ESI; + case 7: + DECODE_PRINTF("EDI"); + return &M.x86.R_EDI; + } + HALT_SYS(); return NULL; /* NOTREACHED OR REACHED ON ERROR */ } @@ -691,126 +685,129 @@ Return a pointer to the register given by the R/RM field of the modrm byte, for word operands, modified from above for the weirdo special case of segreg operands. Also enables the decoding of instructions. ****************************************************************************/ -u16* decode_rm_seg_register( - int reg) +u16 * +decode_rm_seg_register(int reg) { - switch (reg) { - case 0: - DECODE_PRINTF("ES"); - return &M.x86.R_ES; - case 1: - DECODE_PRINTF("CS"); - return &M.x86.R_CS; - case 2: - DECODE_PRINTF("SS"); - return &M.x86.R_SS; - case 3: - DECODE_PRINTF("DS"); - return &M.x86.R_DS; - case 4: - DECODE_PRINTF("FS"); - return &M.x86.R_FS; - case 5: - DECODE_PRINTF("GS"); - return &M.x86.R_GS; - case 6: - case 7: - DECODE_PRINTF("ILLEGAL SEGREG"); - break; - } - HALT_SYS(); - return NULL; /* NOT REACHED OR REACHED ON ERROR */ + switch (reg) { + case 0: + DECODE_PRINTF("ES"); + return &M.x86.R_ES; + case 1: + DECODE_PRINTF("CS"); + return &M.x86.R_CS; + case 2: + DECODE_PRINTF("SS"); + return &M.x86.R_SS; + case 3: + DECODE_PRINTF("DS"); + return &M.x86.R_DS; + case 4: + DECODE_PRINTF("FS"); + return &M.x86.R_FS; + case 5: + DECODE_PRINTF("GS"); + return &M.x86.R_GS; + case 6: + case 7: + DECODE_PRINTF("ILLEGAL SEGREG"); + break; + } + HALT_SYS(); + return NULL; /* NOT REACHED OR REACHED ON ERROR */ } /* * * return offset from the SIB Byte */ -u32 decode_sib_address(int sib, int mod) +u32 +decode_sib_address(int sib, int mod) { u32 base = 0, i = 0, scale = 1; - switch(sib & 0x07) { + switch (sib & 0x07) { case 0: - DECODE_PRINTF("[EAX]"); - base = M.x86.R_EAX; - break; + DECODE_PRINTF("[EAX]"); + base = M.x86.R_EAX; + break; case 1: - DECODE_PRINTF("[ECX]"); - base = M.x86.R_ECX; - break; + DECODE_PRINTF("[ECX]"); + base = M.x86.R_ECX; + break; case 2: - DECODE_PRINTF("[EDX]"); - base = M.x86.R_EDX; - break; + DECODE_PRINTF("[EDX]"); + base = M.x86.R_EDX; + break; case 3: - DECODE_PRINTF("[EBX]"); - base = M.x86.R_EBX; - break; + DECODE_PRINTF("[EBX]"); + base = M.x86.R_EBX; + break; case 4: - DECODE_PRINTF("[ESP]"); - base = M.x86.R_ESP; - M.x86.mode |= SYSMODE_SEG_DS_SS; - break; + DECODE_PRINTF("[ESP]"); + base = M.x86.R_ESP; + M.x86.mode |= SYSMODE_SEG_DS_SS; + break; case 5: - if (mod == 0) { - base = fetch_long_imm(); - DECODE_PRINTF2("%08x", base); - } else { - DECODE_PRINTF("[EBP]"); - base = M.x86.R_ESP; - M.x86.mode |= SYSMODE_SEG_DS_SS; - } - break; + if (mod == 0) { + base = fetch_long_imm(); + DECODE_PRINTF2("%08x", base); + } + else { + DECODE_PRINTF("[EBP]"); + base = M.x86.R_ESP; + M.x86.mode |= SYSMODE_SEG_DS_SS; + } + break; case 6: - DECODE_PRINTF("[ESI]"); - base = M.x86.R_ESI; - break; + DECODE_PRINTF("[ESI]"); + base = M.x86.R_ESI; + break; case 7: - DECODE_PRINTF("[EDI]"); - base = M.x86.R_EDI; - break; + DECODE_PRINTF("[EDI]"); + base = M.x86.R_EDI; + break; } switch ((sib >> 3) & 0x07) { case 0: - DECODE_PRINTF("[EAX"); - i = M.x86.R_EAX; - break; + DECODE_PRINTF("[EAX"); + i = M.x86.R_EAX; + break; case 1: - DECODE_PRINTF("[ECX"); - i = M.x86.R_ECX; - break; + DECODE_PRINTF("[ECX"); + i = M.x86.R_ECX; + break; case 2: - DECODE_PRINTF("[EDX"); - i = M.x86.R_EDX; - break; + DECODE_PRINTF("[EDX"); + i = M.x86.R_EDX; + break; case 3: - DECODE_PRINTF("[EBX"); - i = M.x86.R_EBX; - break; + DECODE_PRINTF("[EBX"); + i = M.x86.R_EBX; + break; case 4: - i = 0; - break; + i = 0; + break; case 5: - DECODE_PRINTF("[EBP"); - i = M.x86.R_EBP; - break; + DECODE_PRINTF("[EBP"); + i = M.x86.R_EBP; + break; case 6: - DECODE_PRINTF("[ESI"); - i = M.x86.R_ESI; - break; + DECODE_PRINTF("[ESI"); + i = M.x86.R_ESI; + break; case 7: - DECODE_PRINTF("[EDI"); - i = M.x86.R_EDI; - break; + DECODE_PRINTF("[EDI"); + i = M.x86.R_EDI; + break; } scale = 1 << ((sib >> 6) & 0x03); if (((sib >> 3) & 0x07) != 4) { - if (scale == 1) { - DECODE_PRINTF("]"); - } else { - DECODE_PRINTF2("*%d]", scale); - } + if (scale == 1) { + DECODE_PRINTF("]"); + } + else { + DECODE_PRINTF2("*%d]", scale); + } } return base + (i * scale); } @@ -835,74 +832,75 @@ NOTE: The code which specifies the corresponding segment (ds vs ss) if a SS access is needed, set this bit. Otherwise, DS access occurs (unless any of the segment override bits are set). ****************************************************************************/ -u32 decode_rm00_address( - int rm) +u32 +decode_rm00_address(int rm) { u32 offset; int sib; if (M.x86.mode & SYSMODE_PREFIX_ADDR) { /* 32-bit addressing */ - switch (rm) { - case 0: - DECODE_PRINTF("[EAX]"); - return M.x86.R_EAX; - case 1: - DECODE_PRINTF("[ECX]"); - return M.x86.R_ECX; - case 2: - DECODE_PRINTF("[EDX]"); - return M.x86.R_EDX; - case 3: - DECODE_PRINTF("[EBX]"); - return M.x86.R_EBX; - case 4: - sib = fetch_byte_imm(); - return decode_sib_address(sib, 0); - case 5: - offset = fetch_long_imm(); - DECODE_PRINTF2("[%08x]", offset); - return offset; - case 6: - DECODE_PRINTF("[ESI]"); - return M.x86.R_ESI; - case 7: - DECODE_PRINTF("[EDI]"); - return M.x86.R_EDI; - } - HALT_SYS(); - } else { + switch (rm) { + case 0: + DECODE_PRINTF("[EAX]"); + return M.x86.R_EAX; + case 1: + DECODE_PRINTF("[ECX]"); + return M.x86.R_ECX; + case 2: + DECODE_PRINTF("[EDX]"); + return M.x86.R_EDX; + case 3: + DECODE_PRINTF("[EBX]"); + return M.x86.R_EBX; + case 4: + sib = fetch_byte_imm(); + return decode_sib_address(sib, 0); + case 5: + offset = fetch_long_imm(); + DECODE_PRINTF2("[%08x]", offset); + return offset; + case 6: + DECODE_PRINTF("[ESI]"); + return M.x86.R_ESI; + case 7: + DECODE_PRINTF("[EDI]"); + return M.x86.R_EDI; + } + HALT_SYS(); + } + else { /* 16-bit addressing */ - switch (rm) { - case 0: - DECODE_PRINTF("[BX+SI]"); + switch (rm) { + case 0: + DECODE_PRINTF("[BX+SI]"); return (M.x86.R_BX + M.x86.R_SI) & 0xffff; - case 1: - DECODE_PRINTF("[BX+DI]"); + case 1: + DECODE_PRINTF("[BX+DI]"); return (M.x86.R_BX + M.x86.R_DI) & 0xffff; - case 2: - DECODE_PRINTF("[BP+SI]"); - M.x86.mode |= SYSMODE_SEG_DS_SS; + case 2: + DECODE_PRINTF("[BP+SI]"); + M.x86.mode |= SYSMODE_SEG_DS_SS; return (M.x86.R_BP + M.x86.R_SI) & 0xffff; - case 3: - DECODE_PRINTF("[BP+DI]"); - M.x86.mode |= SYSMODE_SEG_DS_SS; + case 3: + DECODE_PRINTF("[BP+DI]"); + M.x86.mode |= SYSMODE_SEG_DS_SS; return (M.x86.R_BP + M.x86.R_DI) & 0xffff; - case 4: - DECODE_PRINTF("[SI]"); - return M.x86.R_SI; - case 5: - DECODE_PRINTF("[DI]"); - return M.x86.R_DI; - case 6: - offset = fetch_word_imm(); - DECODE_PRINTF2("[%04x]", offset); - return offset; - case 7: - DECODE_PRINTF("[BX]"); - return M.x86.R_BX; - } - HALT_SYS(); + case 4: + DECODE_PRINTF("[SI]"); + return M.x86.R_SI; + case 5: + DECODE_PRINTF("[DI]"); + return M.x86.R_DI; + case 6: + offset = fetch_word_imm(); + DECODE_PRINTF2("[%04x]", offset); + return offset; + case 7: + DECODE_PRINTF("[BX]"); + return M.x86.R_BX; + } + HALT_SYS(); } return 0; } @@ -918,79 +916,80 @@ REMARKS: Return the offset given by mod=01 addressing. Also enables the decoding of instructions. ****************************************************************************/ -u32 decode_rm01_address( - int rm) +u32 +decode_rm01_address(int rm) { int displacement = 0; int sib; /* Fetch disp8 if no SIB byte */ if (!((M.x86.mode & SYSMODE_PREFIX_ADDR) && (rm == 4))) - displacement = (s8)fetch_byte_imm(); + displacement = (s8) fetch_byte_imm(); if (M.x86.mode & SYSMODE_PREFIX_ADDR) { /* 32-bit addressing */ - switch (rm) { - case 0: - DECODE_PRINTF2("%d[EAX]", displacement); - return M.x86.R_EAX + displacement; - case 1: - DECODE_PRINTF2("%d[ECX]", displacement); - return M.x86.R_ECX + displacement; - case 2: - DECODE_PRINTF2("%d[EDX]", displacement); - return M.x86.R_EDX + displacement; - case 3: - DECODE_PRINTF2("%d[EBX]", displacement); - return M.x86.R_EBX + displacement; - case 4: - sib = fetch_byte_imm(); - displacement = (s8)fetch_byte_imm(); - DECODE_PRINTF2("%d", displacement); - return decode_sib_address(sib, 1) + displacement; - case 5: - DECODE_PRINTF2("%d[EBP]", displacement); - return M.x86.R_EBP + displacement; - case 6: - DECODE_PRINTF2("%d[ESI]", displacement); - return M.x86.R_ESI + displacement; - case 7: - DECODE_PRINTF2("%d[EDI]", displacement); - return M.x86.R_EDI + displacement; - } - HALT_SYS(); - } else { + switch (rm) { + case 0: + DECODE_PRINTF2("%d[EAX]", displacement); + return M.x86.R_EAX + displacement; + case 1: + DECODE_PRINTF2("%d[ECX]", displacement); + return M.x86.R_ECX + displacement; + case 2: + DECODE_PRINTF2("%d[EDX]", displacement); + return M.x86.R_EDX + displacement; + case 3: + DECODE_PRINTF2("%d[EBX]", displacement); + return M.x86.R_EBX + displacement; + case 4: + sib = fetch_byte_imm(); + displacement = (s8) fetch_byte_imm(); + DECODE_PRINTF2("%d", displacement); + return decode_sib_address(sib, 1) + displacement; + case 5: + DECODE_PRINTF2("%d[EBP]", displacement); + return M.x86.R_EBP + displacement; + case 6: + DECODE_PRINTF2("%d[ESI]", displacement); + return M.x86.R_ESI + displacement; + case 7: + DECODE_PRINTF2("%d[EDI]", displacement); + return M.x86.R_EDI + displacement; + } + HALT_SYS(); + } + else { /* 16-bit addressing */ - switch (rm) { - case 0: - DECODE_PRINTF2("%d[BX+SI]", displacement); + switch (rm) { + case 0: + DECODE_PRINTF2("%d[BX+SI]", displacement); return (M.x86.R_BX + M.x86.R_SI + displacement) & 0xffff; - case 1: - DECODE_PRINTF2("%d[BX+DI]", displacement); + case 1: + DECODE_PRINTF2("%d[BX+DI]", displacement); return (M.x86.R_BX + M.x86.R_DI + displacement) & 0xffff; - case 2: - DECODE_PRINTF2("%d[BP+SI]", displacement); - M.x86.mode |= SYSMODE_SEG_DS_SS; + case 2: + DECODE_PRINTF2("%d[BP+SI]", displacement); + M.x86.mode |= SYSMODE_SEG_DS_SS; return (M.x86.R_BP + M.x86.R_SI + displacement) & 0xffff; - case 3: - DECODE_PRINTF2("%d[BP+DI]", displacement); - M.x86.mode |= SYSMODE_SEG_DS_SS; + case 3: + DECODE_PRINTF2("%d[BP+DI]", displacement); + M.x86.mode |= SYSMODE_SEG_DS_SS; return (M.x86.R_BP + M.x86.R_DI + displacement) & 0xffff; - case 4: - DECODE_PRINTF2("%d[SI]", displacement); + case 4: + DECODE_PRINTF2("%d[SI]", displacement); return (M.x86.R_SI + displacement) & 0xffff; - case 5: - DECODE_PRINTF2("%d[DI]", displacement); + case 5: + DECODE_PRINTF2("%d[DI]", displacement); return (M.x86.R_DI + displacement) & 0xffff; - case 6: - DECODE_PRINTF2("%d[BP]", displacement); - M.x86.mode |= SYSMODE_SEG_DS_SS; + case 6: + DECODE_PRINTF2("%d[BP]", displacement); + M.x86.mode |= SYSMODE_SEG_DS_SS; return (M.x86.R_BP + displacement) & 0xffff; - case 7: - DECODE_PRINTF2("%d[BX]", displacement); + case 7: + DECODE_PRINTF2("%d[BX]", displacement); return (M.x86.R_BX + displacement) & 0xffff; - } - HALT_SYS(); + } + HALT_SYS(); } return 0; /* SHOULD NOT HAPPEN */ } @@ -1006,86 +1005,87 @@ REMARKS: Return the offset given by mod=10 addressing. Also enables the decoding of instructions. ****************************************************************************/ -u32 decode_rm10_address( - int rm) +u32 +decode_rm10_address(int rm) { u32 displacement = 0; int sib; /* Fetch disp16 if 16-bit addr mode */ if (!(M.x86.mode & SYSMODE_PREFIX_ADDR)) - displacement = (u16)fetch_word_imm(); + displacement = (u16) fetch_word_imm(); else { - /* Fetch disp32 if no SIB byte */ - if (rm != 4) - displacement = (u32)fetch_long_imm(); + /* Fetch disp32 if no SIB byte */ + if (rm != 4) + displacement = (u32) fetch_long_imm(); } if (M.x86.mode & SYSMODE_PREFIX_ADDR) { /* 32-bit addressing */ - switch (rm) { - case 0: - DECODE_PRINTF2("%08x[EAX]", displacement); - return M.x86.R_EAX + displacement; - case 1: - DECODE_PRINTF2("%08x[ECX]", displacement); - return M.x86.R_ECX + displacement; - case 2: - DECODE_PRINTF2("%08x[EDX]", displacement); - M.x86.mode |= SYSMODE_SEG_DS_SS; - return M.x86.R_EDX + displacement; - case 3: - DECODE_PRINTF2("%08x[EBX]", displacement); - return M.x86.R_EBX + displacement; - case 4: - sib = fetch_byte_imm(); - displacement = (u32)fetch_long_imm(); - DECODE_PRINTF2("%08x", displacement); - return decode_sib_address(sib, 2) + displacement; - break; - case 5: - DECODE_PRINTF2("%08x[EBP]", displacement); - return M.x86.R_EBP + displacement; - case 6: - DECODE_PRINTF2("%08x[ESI]", displacement); - return M.x86.R_ESI + displacement; - case 7: - DECODE_PRINTF2("%08x[EDI]", displacement); - return M.x86.R_EDI + displacement; - } - HALT_SYS(); - } else { + switch (rm) { + case 0: + DECODE_PRINTF2("%08x[EAX]", displacement); + return M.x86.R_EAX + displacement; + case 1: + DECODE_PRINTF2("%08x[ECX]", displacement); + return M.x86.R_ECX + displacement; + case 2: + DECODE_PRINTF2("%08x[EDX]", displacement); + M.x86.mode |= SYSMODE_SEG_DS_SS; + return M.x86.R_EDX + displacement; + case 3: + DECODE_PRINTF2("%08x[EBX]", displacement); + return M.x86.R_EBX + displacement; + case 4: + sib = fetch_byte_imm(); + displacement = (u32) fetch_long_imm(); + DECODE_PRINTF2("%08x", displacement); + return decode_sib_address(sib, 2) + displacement; + break; + case 5: + DECODE_PRINTF2("%08x[EBP]", displacement); + return M.x86.R_EBP + displacement; + case 6: + DECODE_PRINTF2("%08x[ESI]", displacement); + return M.x86.R_ESI + displacement; + case 7: + DECODE_PRINTF2("%08x[EDI]", displacement); + return M.x86.R_EDI + displacement; + } + HALT_SYS(); + } + else { /* 16-bit addressing */ - switch (rm) { - case 0: + switch (rm) { + case 0: DECODE_PRINTF2("%04x[BX+SI]", displacement); return (M.x86.R_BX + M.x86.R_SI + displacement) & 0xffff; - case 1: + case 1: DECODE_PRINTF2("%04x[BX+DI]", displacement); return (M.x86.R_BX + M.x86.R_DI + displacement) & 0xffff; - case 2: - DECODE_PRINTF2("%04x[BP+SI]", displacement); - M.x86.mode |= SYSMODE_SEG_DS_SS; + case 2: + DECODE_PRINTF2("%04x[BP+SI]", displacement); + M.x86.mode |= SYSMODE_SEG_DS_SS; return (M.x86.R_BP + M.x86.R_SI + displacement) & 0xffff; - case 3: - DECODE_PRINTF2("%04x[BP+DI]", displacement); - M.x86.mode |= SYSMODE_SEG_DS_SS; + case 3: + DECODE_PRINTF2("%04x[BP+DI]", displacement); + M.x86.mode |= SYSMODE_SEG_DS_SS; return (M.x86.R_BP + M.x86.R_DI + displacement) & 0xffff; - case 4: + case 4: DECODE_PRINTF2("%04x[SI]", displacement); return (M.x86.R_SI + displacement) & 0xffff; - case 5: + case 5: DECODE_PRINTF2("%04x[DI]", displacement); return (M.x86.R_DI + displacement) & 0xffff; - case 6: - DECODE_PRINTF2("%04x[BP]", displacement); - M.x86.mode |= SYSMODE_SEG_DS_SS; + case 6: + DECODE_PRINTF2("%04x[BP]", displacement); + M.x86.mode |= SYSMODE_SEG_DS_SS; return (M.x86.R_BP + displacement) & 0xffff; - case 7: + case 7: DECODE_PRINTF2("%04x[BX]", displacement); return (M.x86.R_BX + displacement) & 0xffff; - } - HALT_SYS(); + } + HALT_SYS(); } return 0; /*NOTREACHED */ |