2 * Debugger break-points handling
4 * Copyright 1994 Martin von Loewis
5 * Copyright 1995 Alexandre Julliard
6 * Copyright 1999,2000 Eric Pouech
13 #define DR7_CONTROL_SHIFT 16
14 #define DR7_CONTROL_SIZE 4
16 #define DR7_RW_EXECUTE (0x0)
17 #define DR7_RW_WRITE (0x1)
18 #define DR7_RW_READ (0x3)
20 #define DR7_LEN_1 (0x0)
21 #define DR7_LEN_2 (0x4)
22 #define DR7_LEN_4 (0xC)
24 #define DR7_LOCAL_ENABLE_SHIFT 0
25 #define DR7_GLOBAL_ENABLE_SHIFT 1
26 #define DR7_ENABLE_SIZE 2
28 #define DR7_LOCAL_ENABLE_MASK (0x55)
29 #define DR7_GLOBAL_ENABLE_MASK (0xAA)
31 #define DR7_CONTROL_RESERVED (0xFC00)
32 #define DR7_LOCAL_SLOWDOWN (0x100)
33 #define DR7_GLOBAL_SLOWDOWN (0x200)
35 #define DR7_ENABLE_MASK(dr) (1<<(DR7_LOCAL_ENABLE_SHIFT+DR7_ENABLE_SIZE*(dr)))
36 #define IS_DR7_SET(ctrl,dr) ((ctrl)&DR7_ENABLE_MASK(dr))
37 #define INT3 0xcc /* int 3 opcode */
40 #define MAX_BREAKPOINTS 100
42 static DBG_BREAKPOINT breakpoints
[MAX_BREAKPOINTS
];
44 static int next_bp
= 1; /* breakpoint 0 is reserved for step-over */
46 /***********************************************************************
47 * DEBUG_IsStepOverInstr
49 * Determine if the instruction at CS:EIP is an instruction that
50 * we need to step over (like a call or a repetitive string move).
52 static BOOL
DEBUG_IsStepOverInstr(void)
59 addr
.seg
= DEBUG_context
.SegCs
;
60 addr
.off
= DEBUG_context
.Eip
;
61 /* FIXME: old code was using V86BASE(DEBUG_context)
62 * instead of passing thru DOSMEM_MemoryBase
64 instr
= (BYTE
*)DEBUG_ToLinear(&addr
);
68 if (!DEBUG_READ_MEM(instr
, &ch
, sizeof(ch
)))
73 /* Skip all prefixes */
81 case 0x66: /* opcode size prefix */
82 case 0x67: /* addr size prefix */
84 case 0xf2: /* repne */
89 /* Handle call instructions */
91 case 0xcd: /* int <intno> */
92 case 0xe8: /* call <offset> */
93 case 0x9a: /* lcall <seg>:<off> */
96 case 0xff: /* call <regmodrm> */
97 if (!DEBUG_READ_MEM(instr
+ 1, &ch
, sizeof(ch
)))
99 return (((ch
& 0x38) == 0x10) || ((ch
& 0x38) == 0x18));
101 /* Handle string instructions */
103 case 0x6c: /* insb */
104 case 0x6d: /* insw */
105 case 0x6e: /* outsb */
106 case 0x6f: /* outsw */
107 case 0xa4: /* movsb */
108 case 0xa5: /* movsw */
109 case 0xa6: /* cmpsb */
110 case 0xa7: /* cmpsw */
111 case 0xaa: /* stosb */
112 case 0xab: /* stosw */
113 case 0xac: /* lodsb */
114 case 0xad: /* lodsw */
115 case 0xae: /* scasb */
116 case 0xaf: /* scasw */
129 /***********************************************************************
132 * Determine if the instruction at CS:EIP is an instruction that
133 * is a function return.
135 BOOL
DEBUG_IsFctReturn(void)
142 addr
.seg
= DEBUG_context
.SegCs
;
143 addr
.off
= DEBUG_context
.Eip
;
144 /* FIXME: old code was using V86BASE(DEBUG_context)
145 * instead of passing thru DOSMEM_MemoryBase
147 instr
= (BYTE
*)DEBUG_ToLinear(&addr
);
149 if (!DEBUG_READ_MEM(instr
, &ch
, sizeof(ch
)))
152 return (ch
== 0xc2) || (ch
== 0xc3);
159 /***********************************************************************
160 * DEBUG_SetBreakpoints
162 * Set or remove all the breakpoints.
164 void DEBUG_SetBreakpoints( BOOL set
)
169 DEBUG_context
.Dr7
&= ~DR7_LOCAL_ENABLE_MASK
;
172 for (i
= 0; i
< next_bp
; i
++)
174 if (!(breakpoints
[i
].refcount
&& breakpoints
[i
].enabled
))
177 switch (breakpoints
[i
].type
) {
181 char ch
= set
? INT3
: breakpoints
[i
].u
.b
.opcode
;
183 if (!DEBUG_WRITE_MEM( (void*)DEBUG_ToLinear(&breakpoints
[i
].addr
),
186 DEBUG_Printf(DBG_CHN_MESG
, "Invalid address for breakpoint %d, disabling it\n", i
);
187 breakpoints
[i
].enabled
= FALSE
;
197 int reg
= breakpoints
[i
].u
.w
.reg
;
202 case 0: lpdr
= &DEBUG_context
.Dr0
; break;
203 case 1: lpdr
= &DEBUG_context
.Dr1
; break;
204 case 2: lpdr
= &DEBUG_context
.Dr2
; break;
205 case 3: lpdr
= &DEBUG_context
.Dr3
; break;
206 default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR
, 0, 0, NULL
);
209 *lpdr
= DEBUG_ToLinear(&breakpoints
[i
].addr
);
210 bits
= (breakpoints
[i
].u
.w
.rw
) ? DR7_RW_WRITE
: DR7_RW_READ
;
211 switch (breakpoints
[i
].u
.w
.len
+ 1)
213 case 4: bits
|= DR7_LEN_4
; break;
214 case 2: bits
|= DR7_LEN_2
; break;
215 case 1: bits
|= DR7_LEN_1
; break;
216 default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR
, 0, 0, NULL
);
219 DEBUG_context
.Dr7
&= ~(0x0F << (DR7_CONTROL_SHIFT
+ DR7_CONTROL_SIZE
* reg
));
220 DEBUG_context
.Dr7
|= bits
<< (DR7_CONTROL_SHIFT
+ DR7_CONTROL_SIZE
* reg
);
221 DEBUG_context
.Dr7
|= DR7_ENABLE_MASK(reg
) | DR7_LOCAL_SLOWDOWN
;
229 /***********************************************************************
230 * DEBUG_FindBreakpoint
232 * Find the breakpoint for a given address. Return the breakpoint
233 * number or -1 if none.
234 * If type is DBG_BREAKPOINT, addr is a complete addr
235 * If type is DBG_WATCHPOINT, only addr.off is meaningful and contains
238 static int DEBUG_FindBreakpoint( const DBG_ADDR
*addr
, int type
)
242 for (i
= 0; i
< next_bp
; i
++)
244 if (breakpoints
[i
].refcount
&& breakpoints
[i
].enabled
&&
245 breakpoints
[i
].type
== type
)
247 if ((type
== DBG_BREAK
&&
248 breakpoints
[i
].addr
.seg
== addr
->seg
&&
249 breakpoints
[i
].addr
.off
== addr
->off
) ||
250 (type
== DBG_WATCH
&&
251 DEBUG_ToLinear(&breakpoints
[i
].addr
) == addr
->off
))
258 /***********************************************************************
261 * Find an empty slot in BP table to add a new break/watch point
263 static int DEBUG_InitXPoint(int type
, DBG_ADDR
* addr
)
267 for (num
= (next_bp
< MAX_BREAKPOINTS
) ? next_bp
++ : 1;
268 num
< MAX_BREAKPOINTS
; num
++)
270 if (breakpoints
[num
].refcount
== 0)
272 breakpoints
[num
].refcount
= 1;
273 breakpoints
[num
].enabled
= TRUE
;
274 breakpoints
[num
].type
= type
;
275 breakpoints
[num
].skipcount
= 0;
276 breakpoints
[num
].addr
= *addr
;
277 breakpoints
[num
].is32
= 1;
281 switch (DEBUG_GetSelectorType( addr
->seg
))
284 case 16: breakpoints
[num
].is32
= 0; break;
285 default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR
, 0, 0, NULL
);
293 DEBUG_Printf( DBG_CHN_MESG
, "Too many breakpoints. Please delete some.\n" );
297 /***********************************************************************
298 * DEBUG_GetWatchedValue
300 * Returns the value watched by watch point 'num'.
302 static BOOL
DEBUG_GetWatchedValue( int num
, LPDWORD val
)
306 if (!DEBUG_READ_MEM((void*)DEBUG_ToLinear(&breakpoints
[num
].addr
),
307 buf
, breakpoints
[num
].u
.w
.len
+ 1))
310 switch (breakpoints
[num
].u
.w
.len
+ 1)
312 case 4: *val
= *(DWORD
*)buf
; break;
313 case 2: *val
= *(WORD
*)buf
; break;
314 case 1: *val
= *(BYTE
*)buf
; break;
315 default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR
, 0, 0, NULL
);
320 /***********************************************************************
321 * DEBUG_AddBreakpoint
325 void DEBUG_AddBreakpoint( const DBG_VALUE
*_value
, BOOL (*func
)(void) )
327 DBG_VALUE value
= *_value
;
332 assert(_value
->cookie
== DV_TARGET
|| _value
->cookie
== DV_HOST
);
335 DEBUG_FixAddress( &value
.addr
, DEBUG_context
.SegCs
);
338 if( value
.type
!= NULL
&& value
.type
== DEBUG_TypeIntConst
)
341 * We know that we have the actual offset stored somewhere
342 * else in 32-bit space. Grab it, and we
345 seg2
= value
.addr
.seg
;
347 value
.addr
.off
= DEBUG_GetExprValue(&value
, NULL
);
348 value
.addr
.seg
= seg2
;
351 if ((num
= DEBUG_FindBreakpoint(&value
.addr
, DBG_BREAK
)) >= 1)
353 breakpoints
[num
].refcount
++;
357 if (!DEBUG_READ_MEM_VERBOSE((void*)DEBUG_ToLinear( &value
.addr
), &ch
, sizeof(ch
)))
360 if ((num
= DEBUG_InitXPoint(DBG_BREAK
, &value
.addr
)) == -1)
363 breakpoints
[num
].u
.b
.opcode
= ch
;
364 breakpoints
[num
].u
.b
.func
= func
;
366 DEBUG_Printf( DBG_CHN_MESG
, "Breakpoint %d at ", num
);
367 DEBUG_PrintAddress( &breakpoints
[num
].addr
, breakpoints
[num
].is32
? 32 : 16,
369 DEBUG_Printf( DBG_CHN_MESG
, "\n" );
372 /***********************************************************************
373 * DEBUG_AddBreakpointFromId
375 * Add a breakpoint from a function name (and eventually a line #)
377 void DEBUG_AddBreakpointFromId(const char *name
, int lineno
)
381 if (DEBUG_GetSymbolValue(name
, lineno
, &value
, TRUE
))
382 DEBUG_AddBreakpoint(&value
, NULL
);
384 DEBUG_Printf(DBG_CHN_MESG
, "Unable to add breakpoint\n");
387 /***********************************************************************
388 * DEBUG_AddBreakpointFromLineno
390 * Add a breakpoint from a line number in current file
392 void DEBUG_AddBreakpointFromLineno(int lineno
)
396 DEBUG_GetCurrentAddress(&value
.addr
);
399 struct name_hash
* nh
;
401 DEBUG_FindNearestSymbol(&value
.addr
, TRUE
, &nh
, 0, NULL
);
403 DEBUG_Printf(DBG_CHN_MESG
,"Unable to add breakpoint\n");
406 DEBUG_GetLineNumberAddr(nh
, lineno
, &value
.addr
, TRUE
);
410 value
.cookie
= DV_TARGET
;
411 DEBUG_AddBreakpoint( &value
, NULL
);
414 /***********************************************************************
415 * DEBUG_AddWatchpoint
419 void DEBUG_AddWatchpoint( const DBG_VALUE
*_value
, BOOL is_write
)
421 DBG_VALUE value
= *_value
;
426 assert(_value
->cookie
== DV_TARGET
|| _value
->cookie
== DV_HOST
);
429 DEBUG_FixAddress( &value
.addr
, DEBUG_context
.SegCs
);
432 if ( value
.type
!= NULL
&& value
.type
== DEBUG_TypeIntConst
)
435 * We know that we have the actual offset stored somewhere
436 * else in 32-bit space. Grab it, and we
439 seg2
= value
.addr
.seg
;
441 value
.addr
.off
= DEBUG_GetExprValue(&value
, NULL
);
442 value
.addr
.seg
= seg2
;
445 for (num
= 1; num
< next_bp
; num
++)
447 if (breakpoints
[num
].refcount
&& breakpoints
[num
].enabled
&&
448 breakpoints
[num
].type
== DBG_WATCH
) {
449 mask
|= (1 << breakpoints
[num
].u
.w
.reg
);
453 for (reg
= 0; reg
< 4 && (mask
& (1 << reg
)); reg
++);
456 DEBUG_Printf(DBG_CHN_MESG
, "All i386 hardware watchpoints have been set. Delete some\n");
461 if ((num
= DEBUG_InitXPoint(DBG_WATCH
, &value
.addr
)) == -1)
464 breakpoints
[num
].u
.w
.len
= 4 - 1;
465 if (_value
->type
&& DEBUG_GetObjectSize(_value
->type
) < 4)
466 breakpoints
[num
].u
.w
.len
= 2 - 1;
468 if (!DEBUG_GetWatchedValue( num
, &breakpoints
[num
].u
.w
.oldval
))
470 DEBUG_Printf(DBG_CHN_MESG
, "Bad address. Watchpoint not set\n");
471 breakpoints
[num
].refcount
= 0;
474 breakpoints
[num
].u
.w
.rw
= (is_write
) ? TRUE
: FALSE
;
475 breakpoints
[reg
].u
.w
.reg
= reg
;
477 DEBUG_Printf( DBG_CHN_MESG
, "Watchpoint %d at ", num
);
478 DEBUG_PrintAddress( &breakpoints
[num
].addr
, breakpoints
[num
].is32
? 32:16, TRUE
);
479 DEBUG_Printf( DBG_CHN_MESG
, "\n" );
482 /***********************************************************************
483 * DEBUG_AddWathpointFromId
485 * Add a watchpoint from a symbol name (and eventually a line #)
487 void DEBUG_AddWatchpointFromId(const char *name
, int lineno
)
491 if( DEBUG_GetSymbolValue(name
, lineno
, &value
, TRUE
) )
492 DEBUG_AddWatchpoint( &value
, 1 );
494 DEBUG_Printf(DBG_CHN_MESG
, "Unable to add watchpoint\n");
497 /***********************************************************************
498 * DEBUG_DelBreakpoint
500 * Delete a breakpoint.
502 void DEBUG_DelBreakpoint( int num
)
504 if ((num
<= 0) || (num
>= next_bp
) || breakpoints
[num
].refcount
== 0)
506 DEBUG_Printf( DBG_CHN_MESG
, "Invalid breakpoint number %d\n", num
);
510 if (--breakpoints
[num
].refcount
> 0)
513 if( breakpoints
[num
].condition
!= NULL
)
515 DEBUG_FreeExpr(breakpoints
[num
].condition
);
516 breakpoints
[num
].condition
= NULL
;
519 breakpoints
[num
].enabled
= FALSE
;
520 breakpoints
[num
].refcount
= 0;
521 breakpoints
[num
].skipcount
= 0;
524 /***********************************************************************
525 * DEBUG_EnableBreakpoint
527 * Enable or disable a break point.
529 void DEBUG_EnableBreakpoint( int num
, BOOL enable
)
531 if ((num
<= 0) || (num
>= next_bp
) || breakpoints
[num
].refcount
== 0)
533 DEBUG_Printf( DBG_CHN_MESG
, "Invalid breakpoint number %d\n", num
);
536 breakpoints
[num
].enabled
= (enable
) ? TRUE
: FALSE
;
537 breakpoints
[num
].skipcount
= 0;
541 /***********************************************************************
542 * DEBUG_FindTriggeredWatchpoint
544 * Lookup the watchpoints to see if one has been triggered
545 * Return >= (watch point index) if one is found and *oldval is set to
546 * the value watched before the TRAP
547 * Return -1 if none found (*oldval is undetermined)
549 * Unfortunately, Linux does *NOT* (A REAL PITA) report with ptrace
550 * the DR6 register value, so we have to look with our own need the
554 static int DEBUG_FindTriggeredWatchpoint(LPDWORD oldval
)
560 /* Method 1 => get triggered watchpoint from context (doesn't work on Linux
563 for (i
= 0; i
< next_bp
; i
++)
567 if (breakpoints
[i
].refcount
&& breakpoints
[i
].enabled
&&
568 breakpoints
[i
].type
== DBG_WATCH
&&
569 (DEBUG_context
.Dr6
& (1 << breakpoints
[i
].u
.w
.reg
)))
571 DEBUG_context
.Dr6
&= ~(1 << breakpoints
[i
].u
.w
.reg
);
573 *oldval
= breakpoints
[i
].u
.w
.oldval
;
574 if (DEBUG_GetWatchedValue(i
, &val
)) {
575 breakpoints
[i
].u
.w
.oldval
= val
;
581 /* Method 1 failed, trying method 2 */
583 /* Method 2 => check if value has changed among registered watchpoints
584 * this really sucks, but this is how gdb 4.18 works on my linux box
587 for (i
= 0; i
< next_bp
; i
++)
591 if (breakpoints
[i
].refcount
&& breakpoints
[i
].enabled
&&
592 breakpoints
[i
].type
== DBG_WATCH
&&
593 DEBUG_GetWatchedValue(i
, &val
))
595 *oldval
= breakpoints
[i
].u
.w
.oldval
;
598 DEBUG_context
.Dr6
&= ~(1 << breakpoints
[i
].u
.w
.reg
);
599 breakpoints
[i
].u
.w
.oldval
= val
;
601 /* cannot break, because two watch points may have been triggered on
603 * only one will be reported to the user (FIXME ?)
612 /***********************************************************************
613 * DEBUG_InfoBreakpoints
615 * Display break points information.
617 void DEBUG_InfoBreakpoints(void)
621 DEBUG_Printf( DBG_CHN_MESG
, "Breakpoints:\n" );
622 for (i
= 1; i
< next_bp
; i
++)
624 if (breakpoints
[i
].refcount
&& breakpoints
[i
].type
== DBG_BREAK
)
626 DEBUG_Printf( DBG_CHN_MESG
, "%d: %c ", i
, breakpoints
[i
].enabled
? 'y' : 'n');
627 DEBUG_PrintAddress( &breakpoints
[i
].addr
,
628 breakpoints
[i
].is32
? 32 : 16, TRUE
);
629 DEBUG_Printf( DBG_CHN_MESG
, " (%u)\n", breakpoints
[i
].refcount
);
630 if( breakpoints
[i
].condition
!= NULL
)
632 DEBUG_Printf(DBG_CHN_MESG
, "\t\tstop when ");
633 DEBUG_DisplayExpr(breakpoints
[i
].condition
);
634 DEBUG_Printf(DBG_CHN_MESG
, "\n");
638 DEBUG_Printf( DBG_CHN_MESG
, "Watchpoints:\n" );
639 for (i
= 1; i
< next_bp
; i
++)
641 if (breakpoints
[i
].refcount
&& breakpoints
[i
].type
== DBG_WATCH
)
643 DEBUG_Printf( DBG_CHN_MESG
, "%d: %c ", i
, breakpoints
[i
].enabled
? 'y' : 'n');
644 DEBUG_PrintAddress( &breakpoints
[i
].addr
,
645 breakpoints
[i
].is32
? 32 : 16, TRUE
);
646 DEBUG_Printf( DBG_CHN_MESG
, " on %d byte%s (%c)\n",
647 breakpoints
[i
].u
.w
.len
+ 1,
648 breakpoints
[i
].u
.w
.len
> 0 ? "s" : "",
649 breakpoints
[i
].u
.w
.rw
? 'W' : 'R');
650 if( breakpoints
[i
].condition
!= NULL
)
652 DEBUG_Printf(DBG_CHN_MESG
, "\t\tstop when ");
653 DEBUG_DisplayExpr(breakpoints
[i
].condition
);
654 DEBUG_Printf(DBG_CHN_MESG
, "\n");
660 /***********************************************************************
663 * Check whether or not the condition (bp / skipcount) of a break/watch
666 static BOOL
DEBUG_ShallBreak( int bpnum
)
668 if ( breakpoints
[bpnum
].condition
!= NULL
)
670 DBG_VALUE value
= DEBUG_EvalExpr(breakpoints
[bpnum
].condition
);
672 if ( value
.type
== NULL
)
675 * Something wrong - unable to evaluate this expression.
677 DEBUG_Printf(DBG_CHN_MESG
, "Unable to evaluate expression ");
678 DEBUG_DisplayExpr(breakpoints
[bpnum
].condition
);
679 DEBUG_Printf(DBG_CHN_MESG
, "\nTurning off condition\n");
680 DEBUG_AddBPCondition(bpnum
, NULL
);
682 else if( !DEBUG_GetExprValue( &value
, NULL
) )
688 if ( breakpoints
[bpnum
].skipcount
> 0 && --breakpoints
[bpnum
].skipcount
> 0 )
691 if ((breakpoints
[bpnum
].type
== DBG_BREAK
) && breakpoints
[bpnum
].u
.b
.func
)
692 return breakpoints
[bpnum
].u
.b
.func();
696 /***********************************************************************
697 * DEBUG_ShouldContinue
699 * Determine if we should continue execution after a SIGTRAP signal when
700 * executing in the given mode.
702 BOOL
DEBUG_ShouldContinue( DWORD code
, enum exec_mode mode
, int * count
)
709 struct symbol_info syminfo
;
712 /* If not single-stepping, back up over the int3 instruction */
713 if (code
== EXCEPTION_BREAKPOINT
)
717 DEBUG_GetCurrentAddress( &addr
);
718 bpnum
= DEBUG_FindBreakpoint( &addr
, DBG_BREAK
);
719 breakpoints
[0].enabled
= FALSE
; /* disable the step-over breakpoint */
721 if ((bpnum
!= 0) && (bpnum
!= -1))
723 if (!DEBUG_ShallBreak(bpnum
)) return TRUE
;
725 DEBUG_Printf( DBG_CHN_MESG
, "Stopped on breakpoint %d at ", bpnum
);
726 syminfo
= DEBUG_PrintAddress( &breakpoints
[bpnum
].addr
,
727 breakpoints
[bpnum
].is32
? 32 : 16, TRUE
);
728 DEBUG_Printf( DBG_CHN_MESG
, "\n" );
730 if( syminfo
.list
.sourcefile
!= NULL
)
731 DEBUG_List(&syminfo
.list
, NULL
, 0);
735 wpnum
= DEBUG_FindTriggeredWatchpoint(&oldval
);
736 if ((wpnum
!= 0) && (wpnum
!= -1))
738 /* If not single-stepping, do not back up over the int3 instruction */
739 if (code
== EXCEPTION_BREAKPOINT
)
746 if (!DEBUG_ShallBreak(wpnum
)) return TRUE
;
749 addrlen
= !addr
.seg
? 32 : DEBUG_GetSelectorType( addr
.seg
);
751 DEBUG_Printf(DBG_CHN_MESG
, "Stopped on watchpoint %d at ", wpnum
);
752 syminfo
= DEBUG_PrintAddress( &addr
, addrlen
, TRUE
);
754 DEBUG_Printf(DBG_CHN_MESG
, " values: old=%lu new=%lu\n",
755 oldval
, breakpoints
[wpnum
].u
.w
.oldval
);
756 if (syminfo
.list
.sourcefile
!= NULL
)
757 DEBUG_List(&syminfo
.list
, NULL
, 0);
762 * If our mode indicates that we are stepping line numbers,
763 * get the current function, and figure out if we are exactly
764 * on a line number or not.
766 if( mode
== EXEC_STEP_OVER
|| mode
== EXEC_STEP_INSTR
)
768 if( DEBUG_CheckLinenoStatus(&addr
) == AT_LINENUMBER
)
773 else if( mode
== EXEC_STEPI_OVER
|| mode
== EXEC_STEPI_INSTR
)
778 if( *count
> 0 || mode
== EXEC_FINISH
)
781 * We still need to execute more instructions.
787 * If we are about to stop, then print out the source line if we
790 if (mode
!= EXEC_CONT
&& mode
!= EXEC_PASS
&& mode
!= EXEC_FINISH
)
792 DEBUG_FindNearestSymbol( &addr
, TRUE
, NULL
, 0, &syminfo
.list
);
793 if( syminfo
.list
.sourcefile
!= NULL
)
795 DEBUG_List(&syminfo
.list
, NULL
, 0);
800 /* If there's no breakpoint and we are not single-stepping, then we */
801 /* must have encountered an int3 in the Windows program; let's skip it. */
802 if ((bpnum
== -1) && code
== EXCEPTION_BREAKPOINT
)
806 /* no breakpoint, continue if in continuous mode */
807 return (mode
== EXEC_CONT
|| mode
== EXEC_PASS
|| mode
== EXEC_FINISH
);
810 /***********************************************************************
811 * DEBUG_SuspendExecution
813 * Remove all breakpoints before entering the debug loop
815 void DEBUG_SuspendExecution( void )
817 DEBUG_SetBreakpoints( FALSE
);
818 breakpoints
[0] = DEBUG_CurrThread
->stepOverBP
;
821 /***********************************************************************
822 * DEBUG_RestartExecution
824 * Set the breakpoints to the correct state to restart execution
827 enum exec_mode
DEBUG_RestartExecution( enum exec_mode mode
, int count
)
834 enum exec_mode ret_mode
;
838 DEBUG_GetCurrentAddress( &addr
);
841 * This is the mode we will be running in after we finish. We would like
842 * to be able to modify this in certain cases.
846 bp
= DEBUG_FindBreakpoint( &addr
, DBG_BREAK
);
847 if ( bp
!= -1 && bp
!= 0)
850 * If we have set a new value, then save it in the BP number.
852 if( count
!= 0 && mode
== EXEC_CONT
)
854 breakpoints
[bp
].skipcount
= count
;
856 mode
= EXEC_STEPI_INSTR
; /* If there's a breakpoint, skip it */
860 if( mode
== EXEC_CONT
&& count
> 1 )
862 DEBUG_Printf(DBG_CHN_MESG
, "Not stopped at any breakpoint; argument ignored.\n");
866 if( mode
== EXEC_FINISH
&& DEBUG_IsFctReturn() )
868 mode
= ret_mode
= EXEC_STEPI_INSTR
;
871 instr
= DEBUG_ToLinear( &addr
);
872 DEBUG_READ_MEM((void*)instr
, &ch
, sizeof(ch
));
874 * See if the function we are stepping into has debug info
875 * and line numbers. If not, then we step over it instead.
876 * FIXME - we need to check for things like thunks or trampolines,
877 * as the actual function may in fact have debug info.
881 DEBUG_READ_MEM((void*)(instr
+ 1), &delta
, sizeof(delta
));
883 DEBUG_Disasm(&addr2
, FALSE
);
886 status
= DEBUG_CheckLinenoStatus(&addr2
);
888 * Anytime we have a trampoline, step over it.
890 if( ((mode
== EXEC_STEP_OVER
) || (mode
== EXEC_STEPI_OVER
))
891 && status
== FUNC_IS_TRAMPOLINE
)
894 DEBUG_Printf(DBG_CHN_MESG
, "Not stepping into trampoline at %x (no lines)\n",
897 mode
= EXEC_STEP_OVER_TRAMPOLINE
;
900 if( mode
== EXEC_STEP_INSTR
&& status
== FUNC_HAS_NO_LINES
)
903 DEBUG_Printf(DBG_CHN_MESG
, "Not stepping into function at %x (no lines)\n",
906 mode
= EXEC_STEP_OVER
;
911 if( mode
== EXEC_STEP_INSTR
)
913 if( DEBUG_CheckLinenoStatus(&addr
) == FUNC_HAS_NO_LINES
)
915 DEBUG_Printf(DBG_CHN_MESG
, "Single stepping until exit from function, \n");
916 DEBUG_Printf(DBG_CHN_MESG
, "which has no line number information.\n");
918 ret_mode
= mode
= EXEC_FINISH
;
924 case EXEC_CONT
: /* Continuous execution */
925 case EXEC_PASS
: /* Continue, passing exception */
927 DEBUG_context
.EFlags
&= ~STEP_FLAG
;
929 DEBUG_SetBreakpoints( TRUE
);
932 case EXEC_STEP_OVER_TRAMPOLINE
:
934 * This is the means by which we step over our conversion stubs
935 * in callfrom*.s and callto*.s. We dig the appropriate address
936 * off the stack, and we set the breakpoint there instead of the
937 * address just after the call.
940 DEBUG_READ_MEM((void*)(DEBUG_context
.Esp
+
941 2 * sizeof(unsigned int)),
942 &addr
.off
, sizeof(addr
.off
));
943 DEBUG_context
.EFlags
&= ~STEP_FLAG
;
945 breakpoints
[0].addr
= addr
;
946 breakpoints
[0].enabled
= TRUE
;
947 breakpoints
[0].refcount
= 1;
948 breakpoints
[0].skipcount
= 0;
949 DEBUG_READ_MEM((void*)DEBUG_ToLinear( &addr
), &breakpoints
[0].u
.b
.opcode
,
951 DEBUG_SetBreakpoints( TRUE
);
955 case EXEC_STEPI_OVER
: /* Stepping over a call */
956 case EXEC_STEP_OVER
: /* Stepping over a call */
957 if (DEBUG_IsStepOverInstr())
960 DEBUG_context
.EFlags
&= ~STEP_FLAG
;
962 DEBUG_Disasm(&addr
, FALSE
);
963 breakpoints
[0].addr
= addr
;
964 breakpoints
[0].enabled
= TRUE
;
965 breakpoints
[0].refcount
= 1;
966 breakpoints
[0].skipcount
= 0;
967 DEBUG_READ_MEM((void*)DEBUG_ToLinear( &addr
), &breakpoints
[0].u
.b
.opcode
,
969 DEBUG_SetBreakpoints( TRUE
);
972 /* else fall through to single-stepping */
974 case EXEC_STEP_INSTR
: /* Single-stepping an instruction */
975 case EXEC_STEPI_INSTR
: /* Single-stepping an instruction */
977 DEBUG_context
.EFlags
|= STEP_FLAG
;
981 RaiseException(DEBUG_STATUS_INTERNAL_ERROR
, 0, 0, NULL
);
983 DEBUG_CurrThread
->stepOverBP
= breakpoints
[0];
988 DEBUG_AddBPCondition(int num
, struct expr
* exp
)
990 if ((num
<= 0) || (num
>= next_bp
) || !breakpoints
[num
].refcount
)
992 DEBUG_Printf( DBG_CHN_MESG
, "Invalid breakpoint number %d\n", num
);
996 if( breakpoints
[num
].condition
!= NULL
)
998 DEBUG_FreeExpr(breakpoints
[num
].condition
);
999 breakpoints
[num
].condition
= NULL
;
1004 breakpoints
[num
].condition
= DEBUG_CloneExpr(exp
);