2 * Debugger break-points handling
4 * Copyright 1994 Martin von Loewis
5 * Copyright 1995 Alexandre Julliard
6 * Copyright 1999,2000 Eric Pouech
14 #define DR7_CONTROL_SHIFT 16
15 #define DR7_CONTROL_SIZE 4
17 #define DR7_RW_EXECUTE (0x0)
18 #define DR7_RW_WRITE (0x1)
19 #define DR7_RW_READ (0x3)
21 #define DR7_LEN_1 (0x0)
22 #define DR7_LEN_2 (0x4)
23 #define DR7_LEN_4 (0xC)
25 #define DR7_LOCAL_ENABLE_SHIFT 0
26 #define DR7_GLOBAL_ENABLE_SHIFT 1
27 #define DR7_ENABLE_SIZE 2
29 #define DR7_LOCAL_ENABLE_MASK (0x55)
30 #define DR7_GLOBAL_ENABLE_MASK (0xAA)
32 #define DR7_CONTROL_RESERVED (0xFC00)
33 #define DR7_LOCAL_SLOWDOWN (0x100)
34 #define DR7_GLOBAL_SLOWDOWN (0x200)
36 #define DR7_ENABLE_MASK(dr) (1<<(DR7_LOCAL_ENABLE_SHIFT+DR7_ENABLE_SIZE*(dr)))
37 #define IS_DR7_SET(ctrl,dr) ((ctrl)&DR7_ENABLE_MASK(dr))
38 #define INT3 0xcc /* int 3 opcode */
41 #define MAX_BREAKPOINTS 100
43 static BREAKPOINT breakpoints[MAX_BREAKPOINTS];
45 static int next_bp = 1; /* breakpoint 0 is reserved for step-over */
47 /***********************************************************************
48 * DEBUG_IsStepOverInstr
50 * Determine if the instruction at CS:EIP is an instruction that
51 * we need to step over (like a call or a repetitive string move).
53 static BOOL DEBUG_IsStepOverInstr(void)
60 addr.seg = DEBUG_context.SegCs;
61 addr.off = DEBUG_context.Eip;
62 /* FIXME: old code was using V86BASE(DEBUG_context)
63 * instead of passing thru DOSMEM_MemoryBase
65 instr = (BYTE*)DEBUG_ToLinear(&addr);
69 if (!DEBUG_READ_MEM(instr, &ch, sizeof(ch)))
74 /* Skip all prefixes */
82 case 0x66: /* opcode size prefix */
83 case 0x67: /* addr size prefix */
85 case 0xf2: /* repne */
90 /* Handle call instructions */
92 case 0xcd: /* int <intno> */
93 case 0xe8: /* call <offset> */
94 case 0x9a: /* lcall <seg>:<off> */
97 case 0xff: /* call <regmodrm> */
98 if (!DEBUG_READ_MEM(instr + 1, &ch, sizeof(ch)))
100 return (((ch & 0x38) == 0x10) || ((ch & 0x38) == 0x18));
102 /* Handle string instructions */
104 case 0x6c: /* insb */
105 case 0x6d: /* insw */
106 case 0x6e: /* outsb */
107 case 0x6f: /* outsw */
108 case 0xa4: /* movsb */
109 case 0xa5: /* movsw */
110 case 0xa6: /* cmpsb */
111 case 0xa7: /* cmpsw */
112 case 0xaa: /* stosb */
113 case 0xab: /* stosw */
114 case 0xac: /* lodsb */
115 case 0xad: /* lodsw */
116 case 0xae: /* scasb */
117 case 0xaf: /* scasw */
130 /***********************************************************************
133 * Determine if the instruction at CS:EIP is an instruction that
134 * is a function return.
136 BOOL DEBUG_IsFctReturn(void)
143 addr.seg = DEBUG_context.SegCs;
144 addr.off = DEBUG_context.Eip;
145 /* FIXME: old code was using V86BASE(DEBUG_context)
146 * instead of passing thru DOSMEM_MemoryBase
148 instr = (BYTE*)DEBUG_ToLinear(&addr);
150 if (!DEBUG_READ_MEM(instr, &ch, sizeof(ch)))
153 return (ch == 0xc2) || (ch == 0xc3);
160 /***********************************************************************
161 * DEBUG_SetBreakpoints
163 * Set or remove all the breakpoints.
165 void DEBUG_SetBreakpoints( BOOL set )
170 DEBUG_context.Dr7 &= ~DR7_LOCAL_ENABLE_MASK;
173 for (i = 0; i < next_bp; i++)
175 if (!(breakpoints[i].refcount && breakpoints[i].enabled))
178 switch (breakpoints[i].type) {
182 char ch = set ? INT3 : breakpoints[i].u.opcode;
185 if (!DEBUG_WRITE_MEM( (void*)DEBUG_ToLinear(&breakpoints[i].addr),
188 fprintf(stderr, "Invalid address for breakpoint %d, disabling it\n", i);
189 breakpoints[i].enabled = FALSE;
198 int reg = breakpoints[i].u.w.reg;
203 case 0: lpdr = &DEBUG_context.Dr0; break;
204 case 1: lpdr = &DEBUG_context.Dr1; break;
205 case 2: lpdr = &DEBUG_context.Dr2; break;
206 case 3: lpdr = &DEBUG_context.Dr3; break;
207 default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
210 *lpdr = DEBUG_ToLinear(&breakpoints[i].addr);
211 fprintf(stderr, "Setting DR%d %08lx\n", (lpdr - &DEBUG_context.Dr0) / 4, *lpdr);
212 bits = (breakpoints[i].u.w.rw) ? DR7_RW_WRITE : DR7_RW_READ;
213 switch (breakpoints[i].u.w.len + 1)
215 case 4: bits |= DR7_LEN_4; break;
216 case 2: bits |= DR7_LEN_2; break;
217 case 1: bits |= DR7_LEN_1; break;
218 default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
221 DEBUG_context.Dr7 &= ~(0x0F << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg));
222 DEBUG_context.Dr7 |= bits << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg);
223 DEBUG_context.Dr7 |= DR7_ENABLE_MASK(reg) | DR7_LOCAL_SLOWDOWN;
229 fprintf(stderr, "Setting DR7 %08lx\n", DEBUG_context.Dr7);
232 /***********************************************************************
233 * DEBUG_FindBreakpoint
235 * Find the breakpoint for a given address. Return the breakpoint
236 * number or -1 if none.
237 * If type is DBG_BREAKPOINT, addr is a complete addr
238 * If type is DBG_WATCHPOINT, only addr.off is meaningful and contains
241 static int DEBUG_FindBreakpoint( const DBG_ADDR *addr, int type )
245 for (i = 0; i < next_bp; i++)
247 if (breakpoints[i].refcount && breakpoints[i].enabled &&
248 breakpoints[i].type == type )
250 if ((type == DBG_BREAK &&
251 breakpoints[i].addr.seg == addr->seg &&
252 breakpoints[i].addr.off == addr->off) ||
253 (type == DBG_WATCH &&
254 DEBUG_ToLinear(&breakpoints[i].addr) == addr->off))
261 /***********************************************************************
264 * Find an empty slot in BP table to add a new break/watch point
266 static int DEBUG_InitXPoint(int type, DBG_ADDR* addr)
270 for (num = (next_bp < MAX_BREAKPOINTS) ? next_bp++ : 1;
271 num < MAX_BREAKPOINTS; num++)
273 if (breakpoints[num].refcount == 0)
275 breakpoints[num].refcount = 1;
276 breakpoints[num].enabled = TRUE;
277 breakpoints[num].type = type;
278 breakpoints[num].skipcount = 0;
279 breakpoints[num].addr = *addr;
280 breakpoints[num].is32 = 1;
284 switch (DEBUG_GetSelectorType( addr->seg ))
287 case 16: breakpoints[num].is32 = 0; break;
288 default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
296 fprintf( stderr, "Too many breakpoints. Please delete some.\n" );
300 /***********************************************************************
301 * DEBUG_GetWatchedValue
303 * Returns the value watched by watch point 'num'.
305 static BOOL DEBUG_GetWatchedValue( int num, LPDWORD val )
309 if (!DEBUG_READ_MEM((void*)DEBUG_ToLinear(&breakpoints[num].addr),
310 buf, breakpoints[num].u.w.len + 1))
313 switch (breakpoints[num].u.w.len + 1)
315 case 4: *val = *(DWORD*)buf; break;
316 case 2: *val = *(WORD*)buf; break;
317 case 1: *val = *(BYTE*)buf; break;
318 default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
323 /***********************************************************************
324 * DEBUG_AddBreakpoint
328 void DEBUG_AddBreakpoint( const DBG_VALUE *_value )
330 DBG_VALUE value = *_value;
335 assert(_value->cookie == DV_TARGET || _value->cookie == DV_HOST);
337 DEBUG_FixAddress( &value.addr, DEBUG_context.SegCs );
339 if( value.type != NULL && value.type == DEBUG_TypeIntConst )
342 * We know that we have the actual offset stored somewhere
343 * else in 32-bit space. Grab it, and we
346 seg2 = value.addr.seg;
348 value.addr.off = DEBUG_GetExprValue(&value, NULL);
349 value.addr.seg = seg2;
352 if ((num = DEBUG_FindBreakpoint(&value.addr, DBG_BREAK)) >= 1)
354 breakpoints[num].refcount++;
358 if (!DEBUG_READ_MEM_VERBOSE((void*)DEBUG_ToLinear( &value.addr ), &ch, sizeof(ch)))
361 if ((num = DEBUG_InitXPoint(DBG_BREAK, &value.addr)) == -1)
364 breakpoints[num].u.opcode = ch;
366 fprintf( stderr, "Breakpoint %d at ", num );
367 DEBUG_PrintAddress( &breakpoints[num].addr, breakpoints[num].is32 ? 32 : 16,
369 fprintf( stderr, "\n" );
373 /***********************************************************************
374 * DEBUG_AddWatchpoint
378 void DEBUG_AddWatchpoint( const DBG_VALUE *_value, BOOL is_write )
380 DBG_VALUE value = *_value;
385 assert(_value->cookie == DV_TARGET || _value->cookie == DV_HOST);
387 DEBUG_FixAddress( &value.addr, CS_reg(&DEBUG_context) );
389 if ( value.type != NULL && value.type == DEBUG_TypeIntConst )
392 * We know that we have the actual offset stored somewhere
393 * else in 32-bit space. Grab it, and we
396 seg2 = value.addr.seg;
398 value.addr.off = DEBUG_GetExprValue(&value, NULL);
399 value.addr.seg = seg2;
402 for (num = 1; num < next_bp; num++)
404 if (breakpoints[num].refcount && breakpoints[num].enabled &&
405 breakpoints[num].type == DBG_WATCH) {
406 mask |= (1 << breakpoints[num].u.w.reg);
410 for (reg = 0; reg < 4 && (mask & (1 << reg)); reg++);
413 fprintf(stderr, "All i386 hardware watchpoints have been set. Delete some\n");
418 if ((num = DEBUG_InitXPoint(DBG_WATCH, &value.addr)) == -1)
421 breakpoints[num].u.w.len = 4 - 1;
422 if (_value->type && DEBUG_GetObjectSize(_value->type) < 4)
423 breakpoints[num].u.w.len = 2 - 1;
425 if (!DEBUG_GetWatchedValue( num, &breakpoints[num].u.w.oldval))
427 fprintf(stderr, "Bad address. Watchpoint not set\n");
428 breakpoints[num].refcount = 0;
431 breakpoints[num].u.w.rw = (is_write) ? TRUE : FALSE;
432 breakpoints[reg].u.w.reg = reg;
434 fprintf( stderr, "Watchpoint %d at ", num );
435 DEBUG_PrintAddress( &breakpoints[num].addr, breakpoints[num].is32 ? 32:16, TRUE );
436 fprintf( stderr, "\n" );
439 /***********************************************************************
440 * DEBUG_DelBreakpoint
442 * Delete a breakpoint.
444 void DEBUG_DelBreakpoint( int num )
446 if ((num <= 0) || (num >= next_bp) || breakpoints[num].refcount == 0)
448 fprintf( stderr, "Invalid breakpoint number %d\n", num );
452 if (--breakpoints[num].refcount > 0)
455 if( breakpoints[num].condition != NULL )
457 DEBUG_FreeExpr(breakpoints[num].condition);
458 breakpoints[num].condition = NULL;
461 breakpoints[num].enabled = FALSE;
462 breakpoints[num].refcount = 0;
463 breakpoints[num].skipcount = 0;
466 /***********************************************************************
467 * DEBUG_EnableBreakpoint
469 * Enable or disable a break point.
471 void DEBUG_EnableBreakpoint( int num, BOOL enable )
473 if ((num <= 0) || (num >= next_bp) || breakpoints[num].refcount == 0)
475 fprintf( stderr, "Invalid breakpoint number %d\n", num );
478 breakpoints[num].enabled = (enable) ? TRUE : FALSE;
479 breakpoints[num].skipcount = 0;
483 /***********************************************************************
484 * DEBUG_FindTriggeredWatchpoint
486 * Lookup the watchpoints to see if one has been triggered
487 * Return >= (watch point index) if one is found and *oldval is set to
488 * the value watched before the TRAP
489 * Return -1 if none found (*oldval is undetermined)
491 * Unfortunately, Linux does *NOT* (A REAL PITA) report with ptrace
492 * the DR6 register value, so we have to look with our own need the
496 static int DEBUG_FindTriggeredWatchpoint(LPDWORD oldval)
502 /* Method 1 => get triggered watchpoint from context (doesn't work on Linux
505 for (i = 0; i < next_bp; i++)
508 if (breakpoints[i].refcount && breakpoints[i].enabled &&
509 breakpoints[i].type == DBG_WATCH &&
510 (DEBUG_context.Dr6 & (1 << breakpoints[i].u.w.reg)))
512 DEBUG_context.Dr6 &= ~(1 << breakpoints[i].u.w.reg);
514 *oldval = breakpoints[i].u.w.oldval;
515 if (DEBUG_GetWatchedValue(i, &val)) {
516 breakpoints[i].u.w.oldval = val;
523 /* Method 1 failed, trying method2 */
525 /* Method 2 => check if value has changed among registered watchpoints
526 * this really sucks, but this is how gdb 4.18 works on my linux box
529 for (i = 0; i < next_bp; i++)
532 if (breakpoints[i].refcount && breakpoints[i].enabled &&
533 breakpoints[i].type == DBG_WATCH &&
534 DEBUG_GetWatchedValue(i, &val))
536 *oldval = breakpoints[i].u.w.oldval;
539 DEBUG_context.Dr6 &= ~(1 << breakpoints[i].u.w.reg);
540 breakpoints[i].u.w.oldval = val;
542 /* cannot break, because two watch points may have been triggered on
544 * only one will be reported to the user (FIXME ?)
553 /***********************************************************************
554 * DEBUG_InfoBreakpoints
556 * Display break points information.
558 void DEBUG_InfoBreakpoints(void)
562 fprintf( stderr, "Breakpoints:\n" );
563 for (i = 1; i < next_bp; i++)
565 if (breakpoints[i].refcount && breakpoints[i].type == DBG_BREAK)
567 fprintf( stderr, "%d: %c ", i, breakpoints[i].enabled ? 'y' : 'n');
568 DEBUG_PrintAddress( &breakpoints[i].addr,
569 breakpoints[i].is32 ? 32 : 16, TRUE);
570 fprintf( stderr, " (%u)\n", breakpoints[i].refcount );
571 if( breakpoints[i].condition != NULL )
573 fprintf(stderr, "\t\tstop when ");
574 DEBUG_DisplayExpr(breakpoints[i].condition);
575 fprintf(stderr, "\n");
579 fprintf( stderr, "Watchpoints:\n" );
580 for (i = 1; i < next_bp; i++)
582 if (breakpoints[i].refcount && breakpoints[i].type == DBG_WATCH)
584 fprintf( stderr, "%d: %c ", i, breakpoints[i].enabled ? 'y' : 'n');
585 DEBUG_PrintAddress( &breakpoints[i].addr,
586 breakpoints[i].is32 ? 32 : 16, TRUE);
587 fprintf( stderr, " on %d byte%s (%c)\n",
588 breakpoints[i].u.w.len + 1,
589 breakpoints[i].u.w.len > 0 ? "s" : "",
590 breakpoints[i].u.w.rw ? 'W' : 'R');
591 if( breakpoints[i].condition != NULL )
593 fprintf(stderr, "\t\tstop when ");
594 DEBUG_DisplayExpr(breakpoints[i].condition);
595 fprintf(stderr, "\n");
601 /***********************************************************************
604 * Check whether or not the condition (bp / skipcount) of a break/watch
607 static BOOL DEBUG_ShallBreak( int bpnum )
609 if ( breakpoints[bpnum].condition != NULL )
611 DBG_VALUE value = DEBUG_EvalExpr(breakpoints[bpnum].condition);
613 if ( value.type == NULL )
616 * Something wrong - unable to evaluate this expression.
618 fprintf(stderr, "Unable to evaluate expression ");
619 DEBUG_DisplayExpr(breakpoints[bpnum].condition);
620 fprintf(stderr, "\nTurning off condition\n");
621 DEBUG_AddBPCondition(bpnum, NULL);
623 else if( !DEBUG_GetExprValue( &value, NULL) )
629 if ( breakpoints[bpnum].skipcount > 0 && --breakpoints[bpnum].skipcount > 0 )
635 /***********************************************************************
636 * DEBUG_ShouldContinue
638 * Determine if we should continue execution after a SIGTRAP signal when
639 * executing in the given mode.
641 BOOL DEBUG_ShouldContinue( DWORD code, enum exec_mode mode, int * count )
647 struct symbol_info syminfo;
650 /* If not single-stepping, back up over the int3 instruction */
651 if (code == EXCEPTION_BREAKPOINT)
655 DEBUG_GetCurrentAddress( &addr );
656 bpnum = DEBUG_FindBreakpoint( &addr, DBG_BREAK );
657 breakpoints[0].enabled = FALSE; /* disable the step-over breakpoint */
659 if ((bpnum != 0) && (bpnum != -1))
661 if (!DEBUG_ShallBreak(bpnum)) return TRUE;
663 fprintf( stderr, "Stopped on breakpoint %d at ", bpnum );
664 syminfo = DEBUG_PrintAddress( &breakpoints[bpnum].addr,
665 breakpoints[bpnum].is32 ? 32 : 16, TRUE );
666 fprintf( stderr, "\n" );
668 if( syminfo.list.sourcefile != NULL )
669 DEBUG_List(&syminfo.list, NULL, 0);
673 wpnum = DEBUG_FindTriggeredWatchpoint(&oldval);
674 if ((wpnum != 0) && (wpnum != -1))
676 /* If not single-stepping, do not back up over the int3 instruction */
677 if (code == EXCEPTION_BREAKPOINT)
679 EIP_reg(&DEBUG_context)++;
682 if (!DEBUG_ShallBreak(wpnum)) return TRUE;
684 fprintf(stderr, "Stopped on watchpoint %d at ", wpnum);
685 syminfo = DEBUG_PrintAddress( &addr, !addr.seg ? 32 :
686 DEBUG_GetSelectorType( addr.seg ), TRUE );
688 fprintf(stderr, " values: old=%lu new=%lu\n",
689 oldval, breakpoints[wpnum].u.w.oldval);
690 if (syminfo.list.sourcefile != NULL)
691 DEBUG_List(&syminfo.list, NULL, 0);
696 * If our mode indicates that we are stepping line numbers,
697 * get the current function, and figure out if we are exactly
698 * on a line number or not.
700 if( mode == EXEC_STEP_OVER || mode == EXEC_STEP_INSTR )
702 if( DEBUG_CheckLinenoStatus(&addr) == AT_LINENUMBER )
707 else if( mode == EXEC_STEPI_OVER || mode == EXEC_STEPI_INSTR )
712 if( *count > 0 || mode == EXEC_FINISH )
715 * We still need to execute more instructions.
721 * If we are about to stop, then print out the source line if we
724 if (mode != EXEC_CONT && mode != EXEC_PASS && mode != EXEC_FINISH)
726 DEBUG_FindNearestSymbol( &addr, TRUE, NULL, 0, &syminfo.list);
727 if( syminfo.list.sourcefile != NULL )
729 DEBUG_List(&syminfo.list, NULL, 0);
734 /* If there's no breakpoint and we are not single-stepping, then we */
735 /* must have encountered an int3 in the Windows program; let's skip it. */
736 if ((bpnum == -1) && code == EXCEPTION_BREAKPOINT)
740 /* no breakpoint, continue if in continuous mode */
741 return (mode == EXEC_CONT || mode == EXEC_PASS || mode == EXEC_FINISH);
744 /***********************************************************************
745 * DEBUG_RestartExecution
747 * Remove all breakpoints before entering the debug loop
749 void DEBUG_SuspendExecution( void )
751 DEBUG_SetBreakpoints( FALSE );
752 breakpoints[0] = DEBUG_CurrThread->stepOverBP;
755 /***********************************************************************
756 * DEBUG_RestartExecution
758 * Set the breakpoints to the correct state to restart execution
761 enum exec_mode DEBUG_RestartExecution( enum exec_mode mode, int count )
768 enum exec_mode ret_mode;
772 DEBUG_GetCurrentAddress( &addr );
775 * This is the mode we will be running in after we finish. We would like
776 * to be able to modify this in certain cases.
780 bp = DEBUG_FindBreakpoint( &addr, DBG_BREAK );
781 if ( bp != -1 && bp != 0)
784 * If we have set a new value, then save it in the BP number.
786 if( count != 0 && mode == EXEC_CONT )
788 breakpoints[bp].skipcount = count;
790 mode = EXEC_STEPI_INSTR; /* If there's a breakpoint, skip it */
794 if( mode == EXEC_CONT && count > 1 )
796 fprintf(stderr, "Not stopped at any breakpoint; argument ignored.\n");
800 if( mode == EXEC_FINISH && DEBUG_IsFctReturn() )
802 mode = ret_mode = EXEC_STEPI_INSTR;
805 instr = DEBUG_ToLinear( &addr );
806 DEBUG_READ_MEM((void*)instr, &ch, sizeof(ch));
808 * See if the function we are stepping into has debug info
809 * and line numbers. If not, then we step over it instead.
810 * FIXME - we need to check for things like thunks or trampolines,
811 * as the actual function may in fact have debug info.
815 DEBUG_READ_MEM((void*)(instr + 1), &delta, sizeof(delta));
817 DEBUG_Disasm(&addr2, FALSE);
820 status = DEBUG_CheckLinenoStatus(&addr2);
822 * Anytime we have a trampoline, step over it.
824 if( ((mode == EXEC_STEP_OVER) || (mode == EXEC_STEPI_OVER))
825 && status == FUNC_IS_TRAMPOLINE )
828 fprintf(stderr, "Not stepping into trampoline at %x (no lines)\n",
831 mode = EXEC_STEP_OVER_TRAMPOLINE;
834 if( mode == EXEC_STEP_INSTR && status == FUNC_HAS_NO_LINES )
837 fprintf(stderr, "Not stepping into function at %x (no lines)\n",
840 mode = EXEC_STEP_OVER;
845 if( mode == EXEC_STEP_INSTR )
847 if( DEBUG_CheckLinenoStatus(&addr) == FUNC_HAS_NO_LINES )
849 fprintf(stderr, "Single stepping until exit from function, \n");
850 fprintf(stderr, "which has no line number information.\n");
852 ret_mode = mode = EXEC_FINISH;
858 case EXEC_CONT: /* Continuous execution */
859 case EXEC_PASS: /* Continue, passing exception */
861 DEBUG_context.EFlags &= ~STEP_FLAG;
863 DEBUG_SetBreakpoints( TRUE );
866 case EXEC_STEP_OVER_TRAMPOLINE:
868 * This is the means by which we step over our conversion stubs
869 * in callfrom*.s and callto*.s. We dig the appropriate address
870 * off the stack, and we set the breakpoint there instead of the
871 * address just after the call.
874 DEBUG_READ_MEM((void*)(DEBUG_context.Esp +
875 2 * sizeof(unsigned int)),
876 &addr.off, sizeof(addr.off));
877 DEBUG_context.EFlags &= ~STEP_FLAG;
879 breakpoints[0].addr = addr;
880 breakpoints[0].enabled = TRUE;
881 breakpoints[0].refcount = 1;
882 breakpoints[0].skipcount = 0;
883 DEBUG_READ_MEM((void*)DEBUG_ToLinear( &addr ), &breakpoints[0].u.opcode,
885 DEBUG_SetBreakpoints( TRUE );
889 case EXEC_STEPI_OVER: /* Stepping over a call */
890 case EXEC_STEP_OVER: /* Stepping over a call */
891 if (DEBUG_IsStepOverInstr())
894 DEBUG_context.EFlags &= ~STEP_FLAG;
896 DEBUG_Disasm(&addr, FALSE);
897 breakpoints[0].addr = addr;
898 breakpoints[0].enabled = TRUE;
899 breakpoints[0].refcount = 1;
900 breakpoints[0].skipcount = 0;
901 DEBUG_READ_MEM((void*)DEBUG_ToLinear( &addr ), &breakpoints[0].u.opcode,
903 DEBUG_SetBreakpoints( TRUE );
906 /* else fall through to single-stepping */
908 case EXEC_STEP_INSTR: /* Single-stepping an instruction */
909 case EXEC_STEPI_INSTR: /* Single-stepping an instruction */
911 DEBUG_context.EFlags |= STEP_FLAG;
915 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
917 DEBUG_CurrThread->stepOverBP = breakpoints[0];
922 DEBUG_AddBPCondition(int num, struct expr * exp)
924 if ((num <= 0) || (num >= next_bp) || !breakpoints[num].refcount)
926 fprintf( stderr, "Invalid breakpoint number %d\n", num );
930 if( breakpoints[num].condition != NULL )
932 DEBUG_FreeExpr(breakpoints[num].condition);
933 breakpoints[num].condition = NULL;
938 breakpoints[num].condition = DEBUG_CloneExpr(exp);