2 * Debugger i386 specific functions
4 * Copyright 2004 Eric Pouech
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/debug.h"
24 WINE_DEFAULT_DEBUG_CHANNEL(winedbg
);
29 extern void be_i386_disasm_one_insn(ADDRESS64
* addr
, int display
);
31 #define STEP_FLAG 0x00000100 /* single step flag */
32 #define V86_FLAG 0x00020000
34 #define IS_VM86_MODE(ctx) (ctx->EFlags & V86_FLAG)
36 static ADDRESS_MODE
get_selector_type(HANDLE hThread
, const CONTEXT
* ctx
, WORD sel
)
40 if (IS_VM86_MODE(ctx
)) return AddrModeReal
;
41 /* null or system selector */
42 if (!(sel
& 4) || ((sel
>> 3) < 17)) return AddrModeFlat
;
43 if (dbg_curr_process
->process_io
->get_selector(hThread
, sel
, &le
))
44 return le
.HighWord
.Bits
.Default_Big
? AddrMode1632
: AddrMode1616
;
45 /* selector doesn't exist */
49 static void* be_i386_linearize(HANDLE hThread
, const ADDRESS64
* addr
)
56 return (void*)((DWORD
)(LOWORD(addr
->Segment
) << 4) + (DWORD
)addr
->Offset
);
58 if (!(addr
->Segment
& 4) || ((addr
->Segment
>> 3) < 17))
59 return (void*)(DWORD
)addr
->Offset
;
62 if (!dbg_curr_process
->process_io
->get_selector(hThread
, addr
->Segment
, &le
)) return NULL
;
63 return (void*)((le
.HighWord
.Bits
.BaseHi
<< 24) +
64 (le
.HighWord
.Bits
.BaseMid
<< 16) + le
.BaseLow
+
67 return (void*)(DWORD
)addr
->Offset
;
72 static unsigned be_i386_build_addr(HANDLE hThread
, const CONTEXT
* ctx
, ADDRESS64
* addr
,
73 unsigned seg
, unsigned long offset
)
75 addr
->Mode
= AddrModeFlat
;
77 addr
->Offset
= offset
;
80 addr
->Mode
= get_selector_type(hThread
, ctx
, seg
);
85 addr
->Offset
&= 0xffff;
98 static unsigned be_i386_get_addr(HANDLE hThread
, const CONTEXT
* ctx
,
99 enum be_cpu_addr bca
, ADDRESS64
* addr
)
104 return be_i386_build_addr(hThread
, ctx
, addr
, ctx
->SegCs
, ctx
->Eip
);
105 case be_cpu_addr_stack
:
106 return be_i386_build_addr(hThread
, ctx
, addr
, ctx
->SegSs
, ctx
->Esp
);
107 case be_cpu_addr_frame
:
108 return be_i386_build_addr(hThread
, ctx
, addr
, ctx
->SegSs
, ctx
->Ebp
);
113 static unsigned be_i386_get_register_info(int regno
, enum be_cpu_addr
* kind
)
117 case CV_REG_EIP
: *kind
= be_cpu_addr_pc
; return TRUE
;
118 case CV_REG_EBP
: *kind
= be_cpu_addr_frame
; return TRUE
;
119 case CV_REG_ESP
: *kind
= be_cpu_addr_stack
; return TRUE
;
124 static void be_i386_single_step(CONTEXT
* ctx
, BOOL enable
)
126 if (enable
) ctx
->EFlags
|= STEP_FLAG
;
127 else ctx
->EFlags
&= ~STEP_FLAG
;
130 static void be_i386_all_print_context(HANDLE hThread
, const CONTEXT
* ctx
)
132 long double ST
[8]; /* These are for floating regs */
135 /* Break out the FPU state and the floating point registers */
136 dbg_printf("Floating Point Unit status:\n");
137 dbg_printf(" FLCW:%04x ", LOWORD(ctx
->FloatSave
.ControlWord
));
138 dbg_printf(" FLTW:%04x ", LOWORD(ctx
->FloatSave
.TagWord
));
139 dbg_printf(" FLEO:%08x ", (unsigned int) ctx
->FloatSave
.ErrorOffset
);
140 dbg_printf(" FLSW:%04x", LOWORD(ctx
->FloatSave
.StatusWord
));
142 /* Isolate the condition code bits - note they are not contiguous */
143 dbg_printf("(CC:%d%d%d%d", (ctx
->FloatSave
.StatusWord
& 0x00004000) >> 14,
144 (ctx
->FloatSave
.StatusWord
& 0x00000400) >> 10,
145 (ctx
->FloatSave
.StatusWord
& 0x00000200) >> 9,
146 (ctx
->FloatSave
.StatusWord
& 0x00000100) >> 8);
148 /* Now pull out the 3 bit of the TOP stack pointer */
149 dbg_printf(" TOP:%01x", (unsigned int) (ctx
->FloatSave
.StatusWord
& 0x00003800) >> 11);
151 /* Lets analyse the error bits and indicate the status
152 * the Invalid Op flag has sub status which is tested as follows */
153 if (ctx
->FloatSave
.StatusWord
& 0x00000001) { /* Invalid Fl OP */
154 if (ctx
->FloatSave
.StatusWord
& 0x00000040) { /* Stack Fault */
155 if (ctx
->FloatSave
.StatusWord
& 0x00000200) /* C1 says Overflow */
156 dbg_printf(" #IE(Stack Overflow)");
158 dbg_printf(" #IE(Stack Underflow)"); /* Underflow */
160 else dbg_printf(" #IE(Arthimetic error)"); /* Invalid Fl OP */
163 if (ctx
->FloatSave
.StatusWord
& 0x00000002) dbg_printf(" #DE"); /* Denormalised OP */
164 if (ctx
->FloatSave
.StatusWord
& 0x00000004) dbg_printf(" #ZE"); /* Zero Divide */
165 if (ctx
->FloatSave
.StatusWord
& 0x00000008) dbg_printf(" #OE"); /* Overflow */
166 if (ctx
->FloatSave
.StatusWord
& 0x00000010) dbg_printf(" #UE"); /* Underflow */
167 if (ctx
->FloatSave
.StatusWord
& 0x00000020) dbg_printf(" #PE"); /* Precision error */
168 if (ctx
->FloatSave
.StatusWord
& 0x00000040)
169 if (!(ctx
->FloatSave
.StatusWord
& 0x00000001))
170 dbg_printf(" #SE"); /* Stack Fault (don't think this can occur) */
171 if (ctx
->FloatSave
.StatusWord
& 0x00000080) dbg_printf(" #ES"); /* Error Summary */
172 if (ctx
->FloatSave
.StatusWord
& 0x00008000) dbg_printf(" #FB"); /* FPU Busy */
175 /* Here are the rest of the registers */
176 dbg_printf(" FLES:%08x FLDO:%08x FLDS:%08x FLCNS:%08x\n",
177 ctx
->FloatSave
.ErrorSelector
,
178 ctx
->FloatSave
.DataOffset
,
179 ctx
->FloatSave
.DataSelector
,
180 ctx
->FloatSave
.Cr0NpxState
);
182 /* Now for the floating point registers */
183 dbg_printf("Floating Point Registers:\n");
184 for (cnt
= 0; cnt
< 4; cnt
++)
186 memcpy(&ST
[cnt
], &ctx
->FloatSave
.RegisterArea
[cnt
* 10], 10);
187 dbg_printf(" ST%d:%Lf ", cnt
, ST
[cnt
]);
190 for (cnt
= 4; cnt
< 8; cnt
++)
192 memcpy(&ST
[cnt
], &ctx
->FloatSave
.RegisterArea
[cnt
* 10], 10);
193 dbg_printf(" ST%d:%Lf ", cnt
, ST
[cnt
]);
198 static void be_i386_print_context(HANDLE hThread
, const CONTEXT
* ctx
, int all_regs
)
200 static const char flags
[] = "aVR-N--ODITSZ-A-P-C";
204 dbg_printf("Register dump:\n");
206 /* First get the segment registers out of the way */
207 dbg_printf(" CS:%04x SS:%04x DS:%04x ES:%04x FS:%04x GS:%04x",
208 (WORD
)ctx
->SegCs
, (WORD
)ctx
->SegSs
,
209 (WORD
)ctx
->SegDs
, (WORD
)ctx
->SegEs
,
210 (WORD
)ctx
->SegFs
, (WORD
)ctx
->SegGs
);
213 for (i
= 0; buf
[i
]; i
++)
214 if (buf
[i
] != '-' && !(ctx
->EFlags
& (1 << (sizeof(flags
) - 2 - i
))))
217 switch (get_selector_type(hThread
, ctx
, ctx
->SegCs
))
221 dbg_printf("\n IP:%04x SP:%04x BP:%04x FLAGS:%04x(%s)\n",
222 LOWORD(ctx
->Eip
), LOWORD(ctx
->Esp
),
223 LOWORD(ctx
->Ebp
), LOWORD(ctx
->EFlags
), buf
);
224 dbg_printf(" AX:%04x BX:%04x CX:%04x DX:%04x SI:%04x DI:%04x\n",
225 LOWORD(ctx
->Eax
), LOWORD(ctx
->Ebx
),
226 LOWORD(ctx
->Ecx
), LOWORD(ctx
->Edx
),
227 LOWORD(ctx
->Esi
), LOWORD(ctx
->Edi
));
231 dbg_printf("\n EIP:%08x ESP:%08x EBP:%08x EFLAGS:%08x(%s)\n",
232 ctx
->Eip
, ctx
->Esp
, ctx
->Ebp
, ctx
->EFlags
, buf
);
233 dbg_printf(" EAX:%08x EBX:%08x ECX:%08x EDX:%08x\n",
234 ctx
->Eax
, ctx
->Ebx
, ctx
->Ecx
, ctx
->Edx
);
235 dbg_printf(" ESI:%08x EDI:%08x\n",
240 if (all_regs
) be_i386_all_print_context(hThread
, ctx
); /* print floating regs */
244 static void be_i386_print_segment_info(HANDLE hThread
, const CONTEXT
* ctx
)
246 if (get_selector_type(hThread
, ctx
, ctx
->SegCs
) == AddrMode1616
)
248 info_win32_segments(ctx
->SegDs
>> 3, 1);
249 if (ctx
->SegEs
!= ctx
->SegDs
) info_win32_segments(ctx
->SegEs
>> 3, 1);
251 info_win32_segments(ctx
->SegFs
>> 3, 1);
254 static struct dbg_internal_var be_i386_ctx
[] =
256 {CV_REG_AL
, "AL", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Eax
), dbg_itype_unsigned_char_int
},
257 {CV_REG_CL
, "CL", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Ecx
), dbg_itype_unsigned_char_int
},
258 {CV_REG_DL
, "DL", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Edx
), dbg_itype_unsigned_char_int
},
259 {CV_REG_BL
, "BL", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Ebx
), dbg_itype_unsigned_char_int
},
260 {CV_REG_AH
, "AH", (DWORD_PTR
*)(FIELD_OFFSET(CONTEXT
, Eax
)+1), dbg_itype_unsigned_char_int
},
261 {CV_REG_CH
, "CH", (DWORD_PTR
*)(FIELD_OFFSET(CONTEXT
, Ecx
)+1), dbg_itype_unsigned_char_int
},
262 {CV_REG_DH
, "DH", (DWORD_PTR
*)(FIELD_OFFSET(CONTEXT
, Edx
)+1), dbg_itype_unsigned_char_int
},
263 {CV_REG_BH
, "BH", (DWORD_PTR
*)(FIELD_OFFSET(CONTEXT
, Ebx
)+1), dbg_itype_unsigned_char_int
},
264 {CV_REG_AX
, "AX", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Eax
), dbg_itype_unsigned_short_int
},
265 {CV_REG_CX
, "CX", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Ecx
), dbg_itype_unsigned_short_int
},
266 {CV_REG_DX
, "DX", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Edx
), dbg_itype_unsigned_short_int
},
267 {CV_REG_BX
, "BX", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Ebx
), dbg_itype_unsigned_short_int
},
268 {CV_REG_SP
, "SP", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Esp
), dbg_itype_unsigned_short_int
},
269 {CV_REG_BP
, "BP", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Ebp
), dbg_itype_unsigned_short_int
},
270 {CV_REG_SI
, "SI", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Esi
), dbg_itype_unsigned_short_int
},
271 {CV_REG_DI
, "DI", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Edi
), dbg_itype_unsigned_short_int
},
272 {CV_REG_EAX
, "EAX", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Eax
), dbg_itype_unsigned_int
},
273 {CV_REG_ECX
, "ECX", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Ecx
), dbg_itype_unsigned_int
},
274 {CV_REG_EDX
, "EDX", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Edx
), dbg_itype_unsigned_int
},
275 {CV_REG_EBX
, "EBX", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Ebx
), dbg_itype_unsigned_int
},
276 {CV_REG_ESP
, "ESP", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Esp
), dbg_itype_unsigned_int
},
277 {CV_REG_EBP
, "EBP", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Ebp
), dbg_itype_unsigned_int
},
278 {CV_REG_ESI
, "ESI", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Esi
), dbg_itype_unsigned_int
},
279 {CV_REG_EDI
, "EDI", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Edi
), dbg_itype_unsigned_int
},
280 {CV_REG_ES
, "ES", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, SegEs
), dbg_itype_unsigned_short_int
},
281 {CV_REG_CS
, "CS", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, SegCs
), dbg_itype_unsigned_short_int
},
282 {CV_REG_SS
, "SS", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, SegSs
), dbg_itype_unsigned_short_int
},
283 {CV_REG_DS
, "DS", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, SegDs
), dbg_itype_unsigned_short_int
},
284 {CV_REG_FS
, "FS", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, SegFs
), dbg_itype_unsigned_short_int
},
285 {CV_REG_GS
, "GS", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, SegGs
), dbg_itype_unsigned_short_int
},
286 {CV_REG_IP
, "IP", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Eip
), dbg_itype_unsigned_short_int
},
287 {CV_REG_FLAGS
, "FLAGS", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, EFlags
), dbg_itype_unsigned_short_int
},
288 {CV_REG_EIP
, "EIP", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, Eip
), dbg_itype_unsigned_int
},
289 {CV_REG_EFLAGS
, "EFLAGS", (DWORD_PTR
*)FIELD_OFFSET(CONTEXT
, EFlags
), dbg_itype_unsigned_int
},
290 {0, NULL
, 0, dbg_itype_none
}
293 static unsigned be_i386_is_step_over_insn(const void* insn
)
299 if (!dbg_read_memory(insn
, &ch
, sizeof(ch
))) return FALSE
;
303 /* Skip all prefixes */
310 case 0x66: /* opcode size prefix */
311 case 0x67: /* addr size prefix */
312 case 0xf0: /* lock */
313 case 0xf2: /* repne */
314 case 0xf3: /* repe */
315 insn
= (const char*)insn
+ 1;
318 /* Handle call instructions */
319 case 0xcd: /* int <intno> */
320 case 0xe8: /* call <offset> */
321 case 0x9a: /* lcall <seg>:<off> */
324 case 0xff: /* call <regmodrm> */
325 if (!dbg_read_memory((const char*)insn
+ 1, &ch
, sizeof(ch
)))
327 return (((ch
& 0x38) == 0x10) || ((ch
& 0x38) == 0x18));
329 /* Handle string instructions */
330 case 0x6c: /* insb */
331 case 0x6d: /* insw */
332 case 0x6e: /* outsb */
333 case 0x6f: /* outsw */
334 case 0xa4: /* movsb */
335 case 0xa5: /* movsw */
336 case 0xa6: /* cmpsb */
337 case 0xa7: /* cmpsw */
338 case 0xaa: /* stosb */
339 case 0xab: /* stosw */
340 case 0xac: /* lodsb */
341 case 0xad: /* lodsw */
342 case 0xae: /* scasb */
343 case 0xaf: /* scasw */
352 static unsigned be_i386_is_function_return(const void* insn
)
356 if (!dbg_read_memory(insn
, &ch
, sizeof(ch
))) return FALSE
;
357 if (ch
== 0xF3) /* REP */
359 insn
= (const char*)insn
+ 1;
360 if (!dbg_read_memory(insn
, &ch
, sizeof(ch
))) return FALSE
;
362 return (ch
== 0xC2) || (ch
== 0xC3);
365 static unsigned be_i386_is_break_insn(const void* insn
)
369 if (!dbg_read_memory(insn
, &c
, sizeof(c
))) return FALSE
;
373 static unsigned get_size(ADDRESS_MODE am
)
375 if (am
== AddrModeReal
|| am
== AddrMode1616
) return 16;
379 static BOOL
fetch_value(const char* addr
, unsigned sz
, int* value
)
387 if (!dbg_read_memory(addr
, &value8
, sizeof(value8
)))
392 if (!dbg_read_memory(addr
, &value16
, sizeof(value16
)))
397 if (!dbg_read_memory(addr
, value
, sizeof(*value
)))
400 default: return FALSE
;
405 static unsigned be_i386_is_func_call(const void* insn
, ADDRESS64
* callee
)
411 unsigned operand_size
;
412 ADDRESS_MODE cs_addr_mode
;
414 cs_addr_mode
= get_selector_type(dbg_curr_thread
->handle
, &dbg_context
,
416 operand_size
= get_size(cs_addr_mode
);
418 /* get operand_size (also getting rid of the various prefixes */
421 if (!dbg_read_memory(insn
, &ch
, sizeof(ch
))) return FALSE
;
424 operand_size
= 48 - operand_size
; /* 16 => 32, 32 => 16 */
425 insn
= (const char*)insn
+ 1;
427 } while (ch
== 0x66 || ch
== 0x67);
431 case 0xe8: /* relative near call */
432 callee
->Mode
= cs_addr_mode
;
433 if (!fetch_value((const char*)insn
+ 1, operand_size
, &delta
))
435 callee
->Segment
= dbg_context
.SegCs
;
436 callee
->Offset
= (DWORD
)insn
+ 1 + (operand_size
/ 8) + delta
;
439 case 0x9a: /* absolute far call */
440 if (!dbg_read_memory((const char*)insn
+ 1 + operand_size
/ 8,
441 &segment
, sizeof(segment
)))
443 callee
->Mode
= get_selector_type(dbg_curr_thread
->handle
, &dbg_context
,
445 if (!fetch_value((const char*)insn
+ 1, operand_size
, &delta
))
447 callee
->Segment
= segment
;
448 callee
->Offset
= delta
;
452 if (!dbg_read_memory((const char*)insn
+ 1, &ch
, sizeof(ch
)))
454 /* keep only the CALL and LCALL insn:s */
455 switch ((ch
>> 3) & 0x07)
458 segment
= dbg_context
.SegCs
;
461 if (!dbg_read_memory((const char*)insn
+ 1 + operand_size
/ 8,
462 &segment
, sizeof(segment
)))
465 default: return FALSE
;
467 /* FIXME: we only support the 32 bit far calls for now */
468 if (operand_size
!= 32)
470 WINE_FIXME("Unsupported yet call insn (0xFF 0x%02x) with 16 bit operand-size at %p\n", ch
, insn
);
473 switch (ch
& 0xC7) /* keep Mod R/M only (skip reg) */
478 WINE_FIXME("Unsupported yet call insn (0xFF 0x%02x) (SIB bytes) at %p\n", ch
, insn
);
480 case 0x05: /* addr32 */
481 if ((ch
& 0x38) == 0x10 || /* call */
482 (ch
& 0x38) == 0x18) /* lcall */
485 if (!dbg_read_memory((const char *)insn
+ 2, &addr
, sizeof(addr
)))
487 if ((ch
& 0x38) == 0x18) /* lcall */
489 if (!dbg_read_memory((const char*)addr
+ operand_size
, &segment
, sizeof(segment
)))
492 else segment
= dbg_context
.SegCs
;
493 if (!dbg_read_memory((const char*)addr
, &dst
, sizeof(dst
)))
495 callee
->Mode
= get_selector_type(dbg_curr_thread
->handle
, &dbg_context
, segment
);
496 callee
->Segment
= segment
;
497 callee
->Offset
= dst
;
504 case 0x00: dst
= dbg_context
.Eax
; break;
505 case 0x01: dst
= dbg_context
.Ecx
; break;
506 case 0x02: dst
= dbg_context
.Edx
; break;
507 case 0x03: dst
= dbg_context
.Ebx
; break;
508 case 0x04: dst
= dbg_context
.Esp
; break;
509 case 0x05: dst
= dbg_context
.Ebp
; break;
510 case 0x06: dst
= dbg_context
.Esi
; break;
511 case 0x07: dst
= dbg_context
.Edi
; break;
513 if ((ch
>> 6) != 0x03) /* indirect address */
515 if (ch
>> 6) /* we got a displacement */
517 if (!fetch_value((const char*)insn
+ 2, (ch
>> 6) == 0x01 ? 8 : 32, &delta
))
521 if (((ch
>> 3) & 0x07) == 0x03) /* LCALL */
523 if (!dbg_read_memory((const char*)dst
+ operand_size
, &segment
, sizeof(segment
)))
526 else segment
= dbg_context
.SegCs
;
527 if (!dbg_read_memory((const char*)dst
, &delta
, sizeof(delta
)))
529 callee
->Mode
= get_selector_type(dbg_curr_thread
->handle
, &dbg_context
,
531 callee
->Segment
= segment
;
532 callee
->Offset
= delta
;
536 callee
->Mode
= cs_addr_mode
;
537 callee
->Segment
= dbg_context
.SegCs
;
538 callee
->Offset
= dst
;
548 static unsigned be_i386_is_jump(const void* insn
, ADDRESS64
* jumpee
)
552 unsigned operand_size
;
553 ADDRESS_MODE cs_addr_mode
;
555 cs_addr_mode
= get_selector_type(dbg_curr_thread
->handle
, &dbg_context
,
557 operand_size
= get_size(cs_addr_mode
);
559 /* get operand_size (also getting rid of the various prefixes */
562 if (!dbg_read_memory(insn
, &ch
, sizeof(ch
))) return FALSE
;
565 operand_size
= 48 - operand_size
; /* 16 => 32, 32 => 16 */
566 insn
= (const char*)insn
+ 1;
568 } while (ch
== 0x66 || ch
== 0x67);
572 case 0xe9: /* jmp near */
573 jumpee
->Mode
= cs_addr_mode
;
574 if (!fetch_value((const char*)insn
+ 1, operand_size
, &delta
))
576 jumpee
->Segment
= dbg_context
.SegCs
;
577 jumpee
->Offset
= (DWORD
)insn
+ 1 + (operand_size
/ 8) + delta
;
579 default: WINE_FIXME("unknown %x\n", ch
); return FALSE
;
584 #define DR7_CONTROL_SHIFT 16
585 #define DR7_CONTROL_SIZE 4
587 #define DR7_RW_EXECUTE (0x0)
588 #define DR7_RW_WRITE (0x1)
589 #define DR7_RW_READ (0x3)
591 #define DR7_LEN_1 (0x0)
592 #define DR7_LEN_2 (0x4)
593 #define DR7_LEN_4 (0xC)
595 #define DR7_LOCAL_ENABLE_SHIFT 0
596 #define DR7_GLOBAL_ENABLE_SHIFT 1
597 #define DR7_ENABLE_SIZE 2
599 #define DR7_LOCAL_ENABLE_MASK (0x55)
600 #define DR7_GLOBAL_ENABLE_MASK (0xAA)
602 #define DR7_CONTROL_RESERVED (0xFC00)
603 #define DR7_LOCAL_SLOWDOWN (0x100)
604 #define DR7_GLOBAL_SLOWDOWN (0x200)
606 #define DR7_ENABLE_MASK(dr) (1<<(DR7_LOCAL_ENABLE_SHIFT+DR7_ENABLE_SIZE*(dr)))
607 #define IS_DR7_SET(ctrl,dr) ((ctrl)&DR7_ENABLE_MASK(dr))
609 static inline int be_i386_get_unused_DR(CONTEXT
* ctx
, DWORD
** r
)
611 if (!IS_DR7_SET(ctx
->Dr7
, 0))
616 if (!IS_DR7_SET(ctx
->Dr7
, 1))
621 if (!IS_DR7_SET(ctx
->Dr7
, 2))
626 if (!IS_DR7_SET(ctx
->Dr7
, 3))
631 dbg_printf("All hardware registers have been used\n");
636 static unsigned be_i386_insert_Xpoint(HANDLE hProcess
, const struct be_process_io
* pio
,
637 CONTEXT
* ctx
, enum be_xpoint_type type
,
638 void* addr
, unsigned long* val
, unsigned size
)
648 case be_xpoint_break
:
649 if (size
!= 0) return 0;
650 if (!pio
->read(hProcess
, addr
, &ch
, 1, &sz
) || sz
!= 1) return 0;
653 if (!pio
->write(hProcess
, addr
, &ch
, 1, &sz
) || sz
!= 1) return 0;
655 case be_xpoint_watch_exec
:
656 bits
= DR7_RW_EXECUTE
;
658 case be_xpoint_watch_read
:
661 case be_xpoint_watch_write
:
664 if ((reg
= be_i386_get_unused_DR(ctx
, &pr
)) == -1) return 0;
666 if (type
!= be_xpoint_watch_exec
) switch (size
)
668 case 4: bits
|= DR7_LEN_4
; break;
669 case 2: bits
|= DR7_LEN_2
; break;
670 case 1: bits
|= DR7_LEN_1
; break;
674 /* clear old values */
675 ctx
->Dr7
&= ~(0x0F << (DR7_CONTROL_SHIFT
+ DR7_CONTROL_SIZE
* reg
));
676 /* set the correct ones */
677 ctx
->Dr7
|= bits
<< (DR7_CONTROL_SHIFT
+ DR7_CONTROL_SIZE
* reg
);
678 ctx
->Dr7
|= DR7_ENABLE_MASK(reg
) | DR7_LOCAL_SLOWDOWN
;
681 dbg_printf("Unknown bp type %c\n", type
);
687 static unsigned be_i386_remove_Xpoint(HANDLE hProcess
, const struct be_process_io
* pio
,
688 CONTEXT
* ctx
, enum be_xpoint_type type
,
689 void* addr
, unsigned long val
, unsigned size
)
696 case be_xpoint_break
:
697 if (size
!= 0) return 0;
698 if (!pio
->read(hProcess
, addr
, &ch
, 1, &sz
) || sz
!= 1) return 0;
699 if (ch
!= (unsigned char)0xCC)
700 WINE_FIXME("Cannot get back %02x instead of 0xCC at %08lx\n",
701 ch
, (unsigned long)addr
);
702 ch
= (unsigned char)val
;
703 if (!pio
->write(hProcess
, addr
, &ch
, 1, &sz
) || sz
!= 1) return 0;
705 case be_xpoint_watch_exec
:
706 case be_xpoint_watch_read
:
707 case be_xpoint_watch_write
:
708 /* simply disable the entry */
709 ctx
->Dr7
&= ~DR7_ENABLE_MASK(val
);
712 dbg_printf("Unknown bp type %c\n", type
);
718 static unsigned be_i386_is_watchpoint_set(const CONTEXT
* ctx
, unsigned idx
)
720 return ctx
->Dr6
& (1 << idx
);
723 static void be_i386_clear_watchpoint(CONTEXT
* ctx
, unsigned idx
)
725 ctx
->Dr6
&= ~(1 << idx
);
728 static int be_i386_adjust_pc_for_break(CONTEXT
* ctx
, BOOL way
)
739 static int be_i386_fetch_integer(const struct dbg_lvalue
* lvalue
, unsigned size
,
740 unsigned ext_sign
, LONGLONG
* ret
)
742 if (size
!= 1 && size
!= 2 && size
!= 4 && size
!= 8) return FALSE
;
744 memset(ret
, 0, sizeof(*ret
)); /* clear unread bytes */
745 /* FIXME: this assumes that debuggee and debugger use the same
746 * integral representation
748 if (!memory_read_value(lvalue
, size
, ret
)) return FALSE
;
750 /* propagate sign information */
751 if (ext_sign
&& size
< 8 && (*ret
>> (size
* 8 - 1)) != 0)
754 *ret
|= neg
<< (size
* 8);
759 static int be_i386_fetch_float(const struct dbg_lvalue
* lvalue
, unsigned size
,
762 char tmp
[sizeof(long double)];
764 /* FIXME: this assumes that debuggee and debugger use the same
765 * representation for reals
767 if (!memory_read_value(lvalue
, size
, tmp
)) return FALSE
;
769 /* float & double types have to be promoted to a long double */
770 if (size
== sizeof(float)) *ret
= *(float*)tmp
;
771 else if (size
== sizeof(double)) *ret
= *(double*)tmp
;
772 else if (size
== sizeof(long double)) *ret
= *(long double*)tmp
;
778 static int be_i386_store_integer(const struct dbg_lvalue
* lvalue
, unsigned size
,
779 unsigned is_signed
, LONGLONG val
)
781 /* this is simple as we're on a little endian CPU */
782 return memory_write_value(lvalue
, size
, &val
);
785 struct backend_cpu be_i386
=
787 IMAGE_FILE_MACHINE_I386
,
792 be_i386_get_register_info
,
794 be_i386_print_context
,
795 be_i386_print_segment_info
,
797 be_i386_is_step_over_insn
,
798 be_i386_is_function_return
,
799 be_i386_is_break_insn
,
800 be_i386_is_func_call
,
802 be_i386_disasm_one_insn
,
803 be_i386_insert_Xpoint
,
804 be_i386_remove_Xpoint
,
805 be_i386_is_watchpoint_set
,
806 be_i386_clear_watchpoint
,
807 be_i386_adjust_pc_for_break
,
808 be_i386_fetch_integer
,
810 be_i386_store_integer
,