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