1 /**************************************************************************** 2 * 3 * Realmode X86 Emulator Library 4 * 5 * Copyright (C) 1991-2004 SciTech Software, Inc. 6 * Copyright (C) David Mosberger-Tang 7 * Copyright (C) 1999 Egbert Eich 8 * 9 * ======================================================================== 10 * 11 * Permission to use, copy, modify, distribute, and sell this software and 12 * its documentation for any purpose is hereby granted without fee, 13 * provided that the above copyright notice appear in all copies and that 14 * both that copyright notice and this permission notice appear in 15 * supporting documentation, and that the name of the authors not be used 16 * in advertising or publicity pertaining to distribution of the software 17 * without specific, written prior permission. The authors makes no 18 * representations about the suitability of this software for any purpose. 19 * It is provided "as is" without express or implied warranty. 20 * 21 * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 22 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 23 * EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR 24 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF 25 * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR 26 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 27 * PERFORMANCE OF THIS SOFTWARE. 28 * 29 * ======================================================================== 30 * 31 * Language: ANSI C 32 * Environment: Any 33 * Developer: Kendall Bennett 34 * 35 * Description: This file contains the code to handle debugging of the 36 * emulator. 37 * 38 ****************************************************************************/ 39 40 #include "x86emu/x86emui.h" 41 #include <stdarg.h> 42 43 /*----------------------------- Implementation ----------------------------*/ 44 45 #ifdef DEBUG 46 47 static void print_encoded_bytes(u16 s, u16 o); 48 static void print_decoded_instruction(void); 49 static int parse_line(char *s, int *ps, int *n); 50 51 /* should look something like debug's output. */ 52 void X86EMU_trace_regs(void) 53 { 54 if (DEBUG_TRACE()) { 55 x86emu_dump_regs(); 56 } 57 if (DEBUG_DECODE() && !DEBUG_DECODE_NOPRINT()) { 58 printk("%04x:%04x ", M.x86.saved_cs, M.x86.saved_ip); 59 print_encoded_bytes(M.x86.saved_cs, M.x86.saved_ip); 60 print_decoded_instruction(); 61 } 62 } 63 64 void X86EMU_trace_xregs(void) 65 { 66 if (DEBUG_TRACE()) { 67 x86emu_dump_xregs(); 68 } 69 } 70 71 void x86emu_just_disassemble(void) 72 { 73 /* 74 * This routine called if the flag DEBUG_DISASSEMBLE is set kind 75 * of a hack! 76 */ 77 printk("%04x:%04x ", M.x86.saved_cs, M.x86.saved_ip); 78 print_encoded_bytes(M.x86.saved_cs, M.x86.saved_ip); 79 print_decoded_instruction(); 80 } 81 82 static void disassemble_forward(u16 seg, u16 off, int n) 83 { 84 X86EMU_sysEnv tregs; 85 int i; 86 u8 op1; 87 /* 88 * hack, hack, hack. What we do is use the exact machinery set up 89 * for execution, except that now there is an additional state 90 * flag associated with the "execution", and we are using a copy 91 * of the register struct. All the major opcodes, once fully 92 * decoded, have the following two steps: TRACE_REGS(r,m); 93 * SINGLE_STEP(r,m); which disappear if DEBUG is not defined to 94 * the preprocessor. The TRACE_REGS macro expands to: 95 * 96 * if (debug&DEBUG_DISASSEMBLE) 97 * {just_disassemble(); goto EndOfInstruction;} 98 * if (debug&DEBUG_TRACE) trace_regs(r,m); 99 * 100 * ...... and at the last line of the routine. 101 * 102 * EndOfInstruction: end_instr(); 103 * 104 * Up to the point where TRACE_REG is expanded, NO modifications 105 * are done to any register EXCEPT the IP register, for fetch and 106 * decoding purposes. 107 * 108 * This was done for an entirely different reason, but makes a 109 * nice way to get the system to help debug codes. 110 */ 111 tregs = M; 112 tregs.x86.R_IP = off; 113 tregs.x86.R_CS = seg; 114 115 /* reset the decoding buffers */ 116 tregs.x86.enc_str_pos = 0; 117 tregs.x86.enc_pos = 0; 118 119 /* turn on the "disassemble only, no execute" flag */ 120 tregs.x86.debug |= DEBUG_DISASSEMBLE_F; 121 122 /* DUMP NEXT n instructions to screen in straight_line fashion */ 123 /* 124 * This looks like the regular instruction fetch stream, except 125 * that when this occurs, each fetched opcode, upon seeing the 126 * DEBUG_DISASSEMBLE flag set, exits immediately after decoding 127 * the instruction. XXX --- CHECK THAT MEM IS NOT AFFECTED!!! 128 * Note the use of a copy of the register structure... 129 */ 130 for (i = 0; i < n; i++) { 131 op1 = (*sys_rdb) (((u32) M.x86.R_CS << 4) + (M.x86.R_IP++)); 132 (x86emu_optab[op1]) (op1); 133 } 134 /* end major hack mode. */ 135 } 136 137 void x86emu_check_ip_access(void) 138 { 139 /* NULL as of now */ 140 } 141 142 void x86emu_check_sp_access(void) 143 { 144 } 145 146 void x86emu_check_mem_access(u32 dummy) 147 { 148 /* check bounds, etc */ 149 } 150 151 void x86emu_check_data_access(uint dummy1, uint dummy2) 152 { 153 /* check bounds, etc */ 154 } 155 156 void x86emu_inc_decoded_inst_len(int x) 157 { 158 M.x86.enc_pos += x; 159 } 160 161 void x86emu_decode_printf(char *x) 162 { 163 sprintf(M.x86.decoded_buf + M.x86.enc_str_pos, "%s", x); 164 M.x86.enc_str_pos += strlen(x); 165 } 166 167 void x86emu_decode_printf2(char *x, int y) 168 { 169 char temp[100]; 170 sprintf(temp, x, y); 171 sprintf(M.x86.decoded_buf + M.x86.enc_str_pos, "%s", temp); 172 M.x86.enc_str_pos += strlen(temp); 173 } 174 175 void x86emu_end_instr(void) 176 { 177 M.x86.enc_str_pos = 0; 178 M.x86.enc_pos = 0; 179 } 180 181 static void print_encoded_bytes(u16 s, u16 o) 182 { 183 int i; 184 char buf1[64]; 185 for (i = 0; i < M.x86.enc_pos; i++) { 186 sprintf(buf1 + 2 * i, "%02x", fetch_data_byte_abs(s, o + i)); 187 } 188 printk("%-20s", buf1); 189 } 190 191 static void print_decoded_instruction(void) 192 { 193 printk("%s", M.x86.decoded_buf); 194 } 195 196 void x86emu_print_int_vect(u16 iv) 197 { 198 u16 seg, off; 199 200 if (iv > 256) 201 return; 202 seg = fetch_data_word_abs(0, iv * 4); 203 off = fetch_data_word_abs(0, iv * 4 + 2); 204 printk("%04x:%04x ", seg, off); 205 } 206 207 void X86EMU_dump_memory(u16 seg, u16 off, u32 amt) 208 { 209 u32 start = off & 0xfffffff0; 210 u32 end = (off + 16) & 0xfffffff0; 211 u32 i; 212 u32 current; 213 214 current = start; 215 while (end <= off + amt) { 216 printk("%04x:%04x ", seg, start); 217 for (i = start; i < off; i++) 218 printk(" "); 219 for (; i < end; i++) 220 printk("%02x ", fetch_data_byte_abs(seg, i)); 221 printk("\n"); 222 start = end; 223 end = start + 16; 224 } 225 } 226 227 void x86emu_single_step(void) 228 { 229 char s[1024]; 230 int ps[10]; 231 int ntok; 232 int cmd; 233 int done; 234 int segment; 235 int offset; 236 static int breakpoint; 237 static int noDecode = 1; 238 239 char *p; 240 241 if (DEBUG_BREAK()) { 242 if (M.x86.saved_ip != breakpoint) { 243 return; 244 } else { 245 M.x86.debug &= ~DEBUG_DECODE_NOPRINT_F; 246 M.x86.debug |= DEBUG_TRACE_F; 247 M.x86.debug &= ~DEBUG_BREAK_F; 248 print_decoded_instruction(); 249 X86EMU_trace_regs(); 250 } 251 } 252 done = 0; 253 offset = M.x86.saved_ip; 254 while (!done) { 255 printk("-"); 256 cmd = parse_line(s, ps, &ntok); 257 switch (cmd) { 258 case 'u': 259 disassemble_forward(M.x86.saved_cs, (u16) offset, 10); 260 break; 261 case 'd': 262 if (ntok == 2) { 263 segment = M.x86.saved_cs; 264 offset = ps[1]; 265 X86EMU_dump_memory(segment, (u16) offset, 16); 266 offset += 16; 267 } else if (ntok == 3) { 268 segment = ps[1]; 269 offset = ps[2]; 270 X86EMU_dump_memory(segment, (u16) offset, 16); 271 offset += 16; 272 } else { 273 segment = M.x86.saved_cs; 274 X86EMU_dump_memory(segment, (u16) offset, 16); 275 offset += 16; 276 } 277 break; 278 case 'c': 279 M.x86.debug ^= DEBUG_TRACECALL_F; 280 break; 281 case 's': 282 M.x86.debug ^= 283 DEBUG_SVC_F | DEBUG_SYS_F | DEBUG_SYSINT_F; 284 break; 285 case 'r': 286 X86EMU_trace_regs(); 287 break; 288 case 'x': 289 X86EMU_trace_xregs(); 290 break; 291 case 'g': 292 if (ntok == 2) { 293 breakpoint = ps[1]; 294 if (noDecode) { 295 M.x86.debug |= DEBUG_DECODE_NOPRINT_F; 296 } else { 297 M.x86.debug &= ~DEBUG_DECODE_NOPRINT_F; 298 } 299 M.x86.debug &= ~DEBUG_TRACE_F; 300 M.x86.debug |= DEBUG_BREAK_F; 301 done = 1; 302 } 303 break; 304 case 'q': 305 M.x86.debug |= DEBUG_EXIT; 306 return; 307 case 'P': 308 noDecode = (noDecode) ? 0 : 1; 309 printk("Toggled decoding to %s\n", 310 (noDecode) ? "FALSE" : "TRUE"); 311 break; 312 case 't': 313 case 0: 314 done = 1; 315 break; 316 } 317 } 318 } 319 320 int X86EMU_trace_on(void) 321 { 322 return M.x86.debug |= DEBUG_STEP_F | DEBUG_DECODE_F | DEBUG_TRACE_F; 323 } 324 325 int X86EMU_trace_off(void) 326 { 327 return M.x86.debug &= ~(DEBUG_STEP_F | DEBUG_DECODE_F | DEBUG_TRACE_F); 328 } 329 330 static int parse_line(char *s, int *ps, int *n) 331 { 332 int cmd; 333 334 *n = 0; 335 while (*s == ' ' || *s == '\t') 336 s++; 337 ps[*n] = *s; 338 switch (*s) { 339 case '\n': 340 *n += 1; 341 return 0; 342 default: 343 cmd = *s; 344 *n += 1; 345 } 346 347 while (1) { 348 while (*s != ' ' && *s != '\t' && *s != '\n') 349 s++; 350 351 if (*s == '\n') 352 return cmd; 353 354 while (*s == ' ' || *s == '\t') 355 s++; 356 357 *n += 1; 358 } 359 } 360 361 #endif /* DEBUG */ 362 363 void x86emu_dump_regs(void) 364 { 365 printk("\tAX=%04x ", M.x86.R_AX); 366 printk("BX=%04x ", M.x86.R_BX); 367 printk("CX=%04x ", M.x86.R_CX); 368 printk("DX=%04x ", M.x86.R_DX); 369 printk("SP=%04x ", M.x86.R_SP); 370 printk("BP=%04x ", M.x86.R_BP); 371 printk("SI=%04x ", M.x86.R_SI); 372 printk("DI=%04x\n", M.x86.R_DI); 373 printk("\tDS=%04x ", M.x86.R_DS); 374 printk("ES=%04x ", M.x86.R_ES); 375 printk("SS=%04x ", M.x86.R_SS); 376 printk("CS=%04x ", M.x86.R_CS); 377 printk("IP=%04x ", M.x86.R_IP); 378 if (ACCESS_FLAG(F_OF)) 379 printk("OV "); /* CHECKED... */ 380 else 381 printk("NV "); 382 if (ACCESS_FLAG(F_DF)) 383 printk("DN "); 384 else 385 printk("UP "); 386 if (ACCESS_FLAG(F_IF)) 387 printk("EI "); 388 else 389 printk("DI "); 390 if (ACCESS_FLAG(F_SF)) 391 printk("NG "); 392 else 393 printk("PL "); 394 if (ACCESS_FLAG(F_ZF)) 395 printk("ZR "); 396 else 397 printk("NZ "); 398 if (ACCESS_FLAG(F_AF)) 399 printk("AC "); 400 else 401 printk("NA "); 402 if (ACCESS_FLAG(F_PF)) 403 printk("PE "); 404 else 405 printk("PO "); 406 if (ACCESS_FLAG(F_CF)) 407 printk("CY "); 408 else 409 printk("NC "); 410 printk("\n"); 411 } 412 413 void x86emu_dump_xregs(void) 414 { 415 printk("\tEAX=%08x ", M.x86.R_EAX); 416 printk("EBX=%08x ", M.x86.R_EBX); 417 printk("ECX=%08x ", M.x86.R_ECX); 418 printk("EDX=%08x \n", M.x86.R_EDX); 419 printk("\tESP=%08x ", M.x86.R_ESP); 420 printk("EBP=%08x ", M.x86.R_EBP); 421 printk("ESI=%08x ", M.x86.R_ESI); 422 printk("EDI=%08x\n", M.x86.R_EDI); 423 printk("\tDS=%04x ", M.x86.R_DS); 424 printk("ES=%04x ", M.x86.R_ES); 425 printk("SS=%04x ", M.x86.R_SS); 426 printk("CS=%04x ", M.x86.R_CS); 427 printk("EIP=%08x\n\t", M.x86.R_EIP); 428 if (ACCESS_FLAG(F_OF)) 429 printk("OV "); /* CHECKED... */ 430 else 431 printk("NV "); 432 if (ACCESS_FLAG(F_DF)) 433 printk("DN "); 434 else 435 printk("UP "); 436 if (ACCESS_FLAG(F_IF)) 437 printk("EI "); 438 else 439 printk("DI "); 440 if (ACCESS_FLAG(F_SF)) 441 printk("NG "); 442 else 443 printk("PL "); 444 if (ACCESS_FLAG(F_ZF)) 445 printk("ZR "); 446 else 447 printk("NZ "); 448 if (ACCESS_FLAG(F_AF)) 449 printk("AC "); 450 else 451 printk("NA "); 452 if (ACCESS_FLAG(F_PF)) 453 printk("PE "); 454 else 455 printk("PO "); 456 if (ACCESS_FLAG(F_CF)) 457 printk("CY "); 458 else 459 printk("NC "); 460 printk("\n"); 461 } 462