/**************************************************************************** * * Realmode X86 Emulator Library * * Copyright (C) 1991-2004 SciTech Software, Inc. * Copyright (C) David Mosberger-Tang * Copyright (C) 1999 Egbert Eich * * ======================================================================== * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and that * both that copyright notice and this permission notice appear in * supporting documentation, and that the name of the authors not be used * in advertising or publicity pertaining to distribution of the software * without specific, written prior permission. The authors makes no * representations about the suitability of this software for any purpose. * It is provided "as is" without express or implied warranty. * * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. * * ======================================================================== * * Language: ANSI C * Environment: Any * Developer: Kendall Bennett * * Description: This file contains the code to handle debugging of the * emulator. * ****************************************************************************/ #include "x86emui.h" /*----------------------------- Implementation ----------------------------*/ #ifdef DEBUG static void print_encoded_bytes (u16 s, u16 o); static void print_decoded_instruction (void); int parse_line (char *s, int *ps, int *n); /* should look something like debug's output. */ void X86EMU_trace_regs (void) { if (DEBUG_TRACE()) { if (M.x86.mode & (SYSMODE_PREFIX_DATA | SYSMODE_PREFIX_ADDR)) { x86emu_dump_xregs(); } else { x86emu_dump_regs(); } } if (DEBUG_DECODE() && ! DEBUG_DECODE_NOPRINT()) { printf("%04x:%04x ",M.x86.saved_cs, M.x86.saved_ip); print_encoded_bytes( M.x86.saved_cs, M.x86.saved_ip); print_decoded_instruction(); } } void X86EMU_trace_xregs (void) { if (DEBUG_TRACE()) { x86emu_dump_xregs(); } } void x86emu_just_disassemble (void) { /* * This routine called if the flag DEBUG_DISASSEMBLE is set kind * of a hack! */ printf("%04x:%04x ",M.x86.saved_cs, M.x86.saved_ip); print_encoded_bytes( M.x86.saved_cs, M.x86.saved_ip); print_decoded_instruction(); } void disassemble_forward (u16 seg, u16 off, int n) { X86EMU_sysEnv tregs; int i; u8 op1; /* * hack, hack, hack. What we do is use the exact machinery set up * for execution, except that now there is an additional state * flag associated with the "execution", and we are using a copy * of the register struct. All the major opcodes, once fully * decoded, have the following two steps: TRACE_REGS(r,m); * SINGLE_STEP(r,m); which disappear if DEBUG is not defined to * the preprocessor. The TRACE_REGS macro expands to: * * if (debug&DEBUG_DISASSEMBLE) * {just_disassemble(); goto EndOfInstruction;} * if (debug&DEBUG_TRACE) trace_regs(r,m); * * ...... and at the last line of the routine. * * EndOfInstruction: end_instr(); * * Up to the point where TRACE_REG is expanded, NO modifications * are done to any register EXCEPT the IP register, for fetch and * decoding purposes. * * This was done for an entirely different reason, but makes a * nice way to get the system to help debug codes. */ tregs = M; tregs.x86.R_IP = off; tregs.x86.R_CS = seg; /* reset the decoding buffers */ tregs.x86.enc_str_pos = 0; tregs.x86.enc_pos = 0; /* turn on the "disassemble only, no execute" flag */ tregs.x86.debug |= DEBUG_DISASSEMBLE_F; /* DUMP NEXT n instructions to screen in straight_line fashion */ /* * This looks like the regular instruction fetch stream, except * that when this occurs, each fetched opcode, upon seeing the * DEBUG_DISASSEMBLE flag set, exits immediately after decoding * the instruction. XXX --- CHECK THAT MEM IS NOT AFFECTED!!! * Note the use of a copy of the register structure... */ for (i=0; i<n; i++) { op1 = (*sys_rdb)(((u32)M.x86.R_CS<<4) + (M.x86.R_IP++)); (x86emu_optab[op1])(op1); } /* end major hack mode. */ } void x86emu_check_ip_access (void) { /* NULL as of now */ } void x86emu_check_sp_access (void) { } void x86emu_check_mem_access (u32 dummy) { /* check bounds, etc */ } void x86emu_check_data_access (uint dummy1, uint dummy2) { /* check bounds, etc */ } void x86emu_inc_decoded_inst_len (int x) { M.x86.enc_pos += x; } void x86emu_decode_printf (const char *x) { strcpy(M.x86.decoded_buf+M.x86.enc_str_pos,x); M.x86.enc_str_pos += strlen(x); } void x86emu_decode_printf2 (const char *x, int y) { char temp[100]; snprintf(temp, sizeof(temp), x,y); strcpy(M.x86.decoded_buf+M.x86.enc_str_pos,temp); M.x86.enc_str_pos += strlen(temp); } void x86emu_end_instr (void) { M.x86.enc_str_pos = 0; M.x86.enc_pos = 0; } static void print_encoded_bytes (u16 s, u16 o) { int i; char buf1[64]; for (i=0; i< M.x86.enc_pos; i++) { snprintf(buf1+2*i, 64 - 2 * i, "%02x", fetch_data_byte_abs(s,o+i)); } printf("%-20s ",buf1); } static void print_decoded_instruction (void) { printf("%s", M.x86.decoded_buf); } void x86emu_print_int_vect (u16 iv) { u16 seg,off; if (iv > 256) return; seg = fetch_data_word_abs(0,iv*4); off = fetch_data_word_abs(0,iv*4+2); printf("%04x:%04x ", seg, off); } void X86EMU_dump_memory (u16 seg, u16 off, u32 amt) { u32 start = off & 0xfffffff0; u32 end = (off+16) & 0xfffffff0; u32 i; while (end <= off + amt) { printf("%04x:%04x ", seg, start); for (i=start; i< off; i++) printf(" "); for ( ; i< end; i++) printf("%02x ", fetch_data_byte_abs(seg,i)); printf("\n"); start = end; end = start + 16; } } void x86emu_single_step (void) { #if 0 char s[1024]; int ps[10]; int ntok; int cmd; int done; int segment; int offset; static int breakpoint; static int noDecode = 1; if (DEBUG_BREAK()) { if (M.x86.saved_ip != breakpoint) { return; } else { M.x86.debug &= ~DEBUG_DECODE_NOPRINT_F; M.x86.debug |= DEBUG_TRACE_F; M.x86.debug &= ~DEBUG_BREAK_F; print_decoded_instruction (); X86EMU_trace_regs(); } } done=0; offset = M.x86.saved_ip; while (!done) { printf("-"); (void)fgets(s, 1023, stdin); cmd = parse_line(s, ps, &ntok); switch(cmd) { case 'u': disassemble_forward(M.x86.saved_cs,(u16)offset,10); break; case 'd': if (ntok == 2) { segment = M.x86.saved_cs; offset = ps[1]; X86EMU_dump_memory(segment,(u16)offset,16); offset += 16; } else if (ntok == 3) { segment = ps[1]; offset = ps[2]; X86EMU_dump_memory(segment,(u16)offset,16); offset += 16; } else { segment = M.x86.saved_cs; X86EMU_dump_memory(segment,(u16)offset,16); offset += 16; } break; case 'c': M.x86.debug ^= DEBUG_TRACECALL_F; break; case 's': M.x86.debug ^= DEBUG_SVC_F | DEBUG_SYS_F | DEBUG_SYSINT_F; break; case 'r': X86EMU_trace_regs(); break; case 'x': X86EMU_trace_xregs(); break; case 'g': if (ntok == 2) { breakpoint = ps[1]; if (noDecode) { M.x86.debug |= DEBUG_DECODE_NOPRINT_F; } else { M.x86.debug &= ~DEBUG_DECODE_NOPRINT_F; } M.x86.debug &= ~DEBUG_TRACE_F; M.x86.debug |= DEBUG_BREAK_F; done = 1; } break; case 'q': M.x86.debug |= DEBUG_EXIT; return; case 'P': noDecode = (noDecode)?0:1; printf("Toggled decoding to %s\n",(noDecode)?"FALSE":"TRUE"); break; case 't': case 0: done = 1; break; } } #endif } int X86EMU_trace_on(void) { return M.x86.debug |= DEBUG_STEP_F | DEBUG_DECODE_F | DEBUG_TRACE_F; } int X86EMU_trace_off(void) { return M.x86.debug &= ~(DEBUG_STEP_F | DEBUG_DECODE_F | DEBUG_TRACE_F); } int parse_line (char *s, int *ps, int *n) { #if 0 int cmd; *n = 0; while(*s == ' ' || *s == '\t') s++; ps[*n] = *s; switch (*s) { case '\n': *n += 1; return 0; default: cmd = *s; *n += 1; } while (1) { while (*s != ' ' && *s != '\t' && *s != '\n') s++; if (*s == '\n') return cmd; while(*s == ' ' || *s == '\t') s++; sscanf(s,"%x",&ps[*n]); *n += 1; } #else return 0; #endif } #endif /* DEBUG */ void x86emu_dump_regs (void) { printf("\tAX=%04x ", M.x86.R_AX ); printf("BX=%04x ", M.x86.R_BX ); printf("CX=%04x ", M.x86.R_CX ); printf("DX=%04x ", M.x86.R_DX ); printf("SP=%04x ", M.x86.R_SP ); printf("BP=%04x ", M.x86.R_BP ); printf("SI=%04x ", M.x86.R_SI ); printf("DI=%04x\n", M.x86.R_DI ); printf("\tDS=%04x ", M.x86.R_DS ); printf("ES=%04x ", M.x86.R_ES ); printf("SS=%04x ", M.x86.R_SS ); printf("CS=%04x ", M.x86.R_CS ); printf("IP=%04x ", M.x86.R_IP ); if (ACCESS_FLAG(F_OF)) printf("OV "); /* CHECKED... */ else printf("NV "); if (ACCESS_FLAG(F_DF)) printf("DN "); else printf("UP "); if (ACCESS_FLAG(F_IF)) printf("EI "); else printf("DI "); if (ACCESS_FLAG(F_SF)) printf("NG "); else printf("PL "); if (ACCESS_FLAG(F_ZF)) printf("ZR "); else printf("NZ "); if (ACCESS_FLAG(F_AF)) printf("AC "); else printf("NA "); if (ACCESS_FLAG(F_PF)) printf("PE "); else printf("PO "); if (ACCESS_FLAG(F_CF)) printf("CY "); else printf("NC "); printf("\n"); } void x86emu_dump_xregs (void) { printf("\tEAX=%08x ", M.x86.R_EAX ); printf("EBX=%08x ", M.x86.R_EBX ); printf("ECX=%08x ", M.x86.R_ECX ); printf("EDX=%08x\n", M.x86.R_EDX ); printf("\tESP=%08x ", M.x86.R_ESP ); printf("EBP=%08x ", M.x86.R_EBP ); printf("ESI=%08x ", M.x86.R_ESI ); printf("EDI=%08x\n", M.x86.R_EDI ); printf("\tDS=%04x ", M.x86.R_DS ); printf("ES=%04x ", M.x86.R_ES ); printf("SS=%04x ", M.x86.R_SS ); printf("CS=%04x ", M.x86.R_CS ); printf("EIP=%08x\n\t", M.x86.R_EIP ); if (ACCESS_FLAG(F_OF)) printf("OV "); /* CHECKED... */ else printf("NV "); if (ACCESS_FLAG(F_DF)) printf("DN "); else printf("UP "); if (ACCESS_FLAG(F_IF)) printf("EI "); else printf("DI "); if (ACCESS_FLAG(F_SF)) printf("NG "); else printf("PL "); if (ACCESS_FLAG(F_ZF)) printf("ZR "); else printf("NZ "); if (ACCESS_FLAG(F_AF)) printf("AC "); else printf("NA "); if (ACCESS_FLAG(F_PF)) printf("PE "); else printf("PO "); if (ACCESS_FLAG(F_CF)) printf("CY "); else printf("NC "); printf("\n"); }