This is a BIOS emulator, porting from SciTech for u-boot, mainly for
[platform/kernel/u-boot.git] / drivers / bios_emulator / x86emu / debug.c
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 }