winedbg: Hardware breakpoints
[wine] / programs / winedbg / break.c
1 /*
2  * Debugger break-points handling
3  *
4  * Copyright 1994 Martin von Loewis
5  * Copyright 1995 Alexandre Julliard
6  * Copyright 1999,2000 Eric Pouech
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22
23 #include "config.h"
24 #include "debugger.h"
25 #include "wine/debug.h"
26
27 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
28
29 static int is_xpoint_break(int bpnum)
30 {
31     int type = dbg_curr_process->bp[bpnum].xpoint_type;
32
33     if (type == be_xpoint_break || type == be_xpoint_watch_exec) return TRUE;
34     if (type == be_xpoint_watch_read || type == be_xpoint_watch_write) return FALSE;
35     RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
36     return 0; /* never reached */
37 }
38
39 /***********************************************************************
40  *           break_set_xpoints
41  *
42  * Set or remove all the breakpoints & watchpoints
43  */
44 void  break_set_xpoints(BOOL set)
45 {
46     static BOOL                 last; /* = 0 = FALSE */
47
48     unsigned int                i, ret, size;
49     void*                       addr;
50     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
51
52     if (set == last) return;
53     last = set;
54
55     for (i = 0; i < dbg_curr_process->next_bp; i++)
56     {
57         if (!bp[i].refcount || !bp[i].enabled) continue;
58
59         if (is_xpoint_break(i))
60             size = 0;
61         else
62             size = bp[i].w.len + 1;
63         addr = (void*)memory_to_linear_addr(&bp[i].addr);
64
65         if (set)
66             ret = be_cpu->insert_Xpoint(dbg_curr_process->handle,
67                                         dbg_curr_process->process_io,
68                                         &dbg_context, bp[i].xpoint_type, addr,
69                                         &bp[i].info, size);
70         else
71             ret = be_cpu->remove_Xpoint(dbg_curr_process->handle, 
72                                         dbg_curr_process->process_io,
73                                         &dbg_context, bp[i].xpoint_type, addr,
74                                         bp[i].info, size);
75         if (!ret)
76         {
77             dbg_printf("Invalid address (");
78             print_address(&bp[i].addr, FALSE);
79             dbg_printf(") for breakpoint %d, disabling it\n", i);
80             bp[i].enabled = FALSE;
81         }
82     }
83 }
84
85 /***********************************************************************
86  *           find_xpoint
87  *
88  * Find the breakpoint for a given address. Return the breakpoint
89  * number or -1 if none.
90  */
91 static int find_xpoint(const ADDRESS* addr, enum be_xpoint_type type)
92 {
93     int                         i;
94     void*                       lin = memory_to_linear_addr(addr);
95     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
96
97     for (i = 0; i < dbg_curr_process->next_bp; i++)
98     {
99         if (bp[i].refcount && bp[i].enabled && bp[i].xpoint_type == type &&
100             memory_to_linear_addr(&bp[i].addr) == lin)
101             return i;
102     }
103     return -1;
104 }
105
106 /***********************************************************************
107  *           init_xpoint
108  *
109  * Find an empty slot in BP table to add a new break/watch point
110  */
111 static  int init_xpoint(int type, const ADDRESS* addr)
112 {
113     int                         num;
114     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
115
116     for (num = (dbg_curr_process->next_bp < MAX_BREAKPOINTS) ? 
117              dbg_curr_process->next_bp++ : 1;
118          num < MAX_BREAKPOINTS; num++)
119     {
120         if (bp[num].refcount == 0)
121         {
122             bp[num].refcount    = 1;
123             bp[num].enabled     = TRUE;
124             bp[num].xpoint_type = type;
125             bp[num].skipcount   = 0;
126             bp[num].addr        = *addr;
127             return num;
128         }
129     }
130
131     dbg_printf("Too many bp. Please delete some.\n");
132     return -1;
133 }
134
135 /***********************************************************************
136  *           get_watched_value
137  *
138  * Returns the value watched by watch point 'num'.
139  */
140 static  BOOL    get_watched_value(int num, LPDWORD val)
141 {
142     BYTE        buf[4];
143
144     if (!dbg_read_memory(memory_to_linear_addr(&dbg_curr_process->bp[num].addr),
145                          buf, dbg_curr_process->bp[num].w.len + 1))
146         return FALSE;
147
148     switch (dbg_curr_process->bp[num].w.len + 1)
149     {
150     case 4:     *val = *(DWORD*)buf;    break;
151     case 2:     *val = *(WORD*)buf;     break;
152     case 1:     *val = *(BYTE*)buf;     break;
153     default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
154     }
155     return TRUE;
156 }
157
158 /***********************************************************************
159  *           break_add_break
160  *
161  * Add a breakpoint.
162  */
163 BOOL break_add_break(const ADDRESS* addr, BOOL verbose, BOOL swbp)
164 {
165     int                         num;
166     BYTE                        ch;
167     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
168     int                         type = swbp ? be_xpoint_break : be_xpoint_watch_exec;
169
170     if ((num = find_xpoint(addr, type)) >= 1)
171     {
172         bp[num].refcount++;
173         dbg_printf("Breakpoint %d at ", num);
174         print_address(&bp[num].addr, TRUE);
175         dbg_printf(" (refcount=%d)\n", bp[num].refcount);
176         return TRUE;
177     }
178
179     if (!dbg_read_memory(memory_to_linear_addr(addr), &ch, sizeof(ch)))
180     {
181         if (verbose)
182         {
183             dbg_printf("Invalid address ");
184             print_bare_address(addr);
185             dbg_printf(", can't set breakpoint\n");
186         }
187         return FALSE;
188     }
189
190     if ((num = init_xpoint(type, addr)) == -1)
191         return FALSE;
192
193     dbg_printf("Breakpoint %d at ", num);
194     print_address(&bp[num].addr, TRUE);
195     dbg_printf("\n");
196
197     return TRUE;
198 }
199
200 /***********************************************************************
201  *           break_add_break_from_lvalue
202  *
203  * Add a breakpoint.
204  */
205 BOOL break_add_break_from_lvalue(const struct dbg_lvalue* lvalue, BOOL swbp)
206 {
207     ADDRESS     addr;
208
209     types_extract_as_address(lvalue, &addr);
210
211     if (!break_add_break(&addr, TRUE, swbp))
212     {
213         if (!DBG_IVAR(CanDeferOnBPByAddr))
214         {
215             dbg_printf("Invalid address, can't set breakpoint\n"
216                        "You can turn on deferring bp by address by setting $CanDeferOnBPByAddr to 1\n");
217             return FALSE;
218         }
219         dbg_printf("Unable to add breakpoint, will check again any time a new DLL is loaded\n");
220         dbg_curr_process->delayed_bp = 
221             dbg_heap_realloc(dbg_curr_process->delayed_bp,
222                              sizeof(struct dbg_delayed_bp) * ++dbg_curr_process->num_delayed_bp);
223
224         dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].is_symbol   = FALSE;
225         dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].software_bp = swbp;
226         dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].u.addr      = addr;
227         return TRUE;
228     }
229     return FALSE;
230 }
231
232 /***********************************************************************
233  *           break_add_break_from_id
234  *
235  * Add a breakpoint from a function name (and eventually a line #)
236  */
237 void    break_add_break_from_id(const char *name, int lineno, BOOL swbp)
238 {
239     struct dbg_lvalue   lvalue;
240     int                 i;
241
242     switch (symbol_get_lvalue(name, lineno, &lvalue, TRUE))
243     {
244     case sglv_found:
245         break_add_break(&lvalue.addr, TRUE, swbp);
246         return;
247     case sglv_unknown:
248         break;
249     case sglv_aborted: /* user aborted symbol lookup */
250         return;
251     }
252
253     dbg_printf("Unable to add breakpoint, will check again when a new DLL is loaded\n");
254     for (i = 0; i < dbg_curr_process->num_delayed_bp; i++)
255     {
256         if (dbg_curr_process->delayed_bp[i].is_symbol &&
257             !strcmp(name, dbg_curr_process->delayed_bp[i].u.symbol.name) &&
258             lineno == dbg_curr_process->delayed_bp[i].u.symbol.lineno)
259             return;
260     }
261     dbg_curr_process->delayed_bp = dbg_heap_realloc(dbg_curr_process->delayed_bp,
262                                                     sizeof(struct dbg_delayed_bp) * ++dbg_curr_process->num_delayed_bp);
263
264     dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].is_symbol       = TRUE;
265     dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].software_bp     = swbp;
266     dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].u.symbol.name   = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(name) + 1), name);
267     dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].u.symbol.lineno = lineno;
268 }
269
270 struct cb_break_lineno
271 {
272     int         lineno;
273     ADDRESS     addr;
274 };
275
276 static BOOL CALLBACK line_cb(SRCCODEINFO* sci, void* user)
277 {
278     struct cb_break_lineno*      bkln = user;
279
280     if (bkln->lineno == sci->LineNumber)
281     {
282         bkln->addr.Mode = AddrModeFlat;
283         bkln->addr.Offset = sci->Address;
284         return FALSE;
285     }
286     return TRUE;
287 }
288
289 /***********************************************************************
290  *           break_add_break_from_lineno
291  *
292  * Add a breakpoint from a line number in current file
293  */
294 void    break_add_break_from_lineno(int lineno, BOOL swbp)
295 {
296     struct cb_break_lineno      bkln;
297
298     memory_get_current_pc(&bkln.addr);
299
300     if (lineno != -1)
301     {
302         IMAGEHLP_LINE   il;
303
304
305         DWORD           disp;
306         DWORD           linear = (DWORD)memory_to_linear_addr(&bkln.addr);
307
308         il.SizeOfStruct = sizeof(il);
309         if (!SymGetLineFromAddr(dbg_curr_process->handle, linear, &disp, &il))
310
311         {
312             dbg_printf("Unable to add breakpoint (unknown address %lx)\n", linear);
313             return;
314         }
315         bkln.addr.Offset = 0;
316         bkln.lineno = lineno;
317         SymEnumLines(dbg_curr_process->handle, linear, NULL, il.FileName, line_cb, &bkln);
318         if (!bkln.addr.Offset)
319         {
320             dbg_printf("Unknown line number\n"
321                        "(either out of file, or no code at given line number)\n");
322             return;
323         }
324     }
325
326     break_add_break(&bkln.addr, TRUE, swbp);
327 }
328
329 /***********************************************************************
330  *           break_check_delayed_bp
331  *
332  * Check is a registered delayed BP is now available.
333  */
334 void break_check_delayed_bp(void)
335 {
336     struct dbg_lvalue           lvalue;
337     int                         i;
338     struct dbg_delayed_bp*      dbp = dbg_curr_process->delayed_bp;
339
340     for (i = 0; i < dbg_curr_process->num_delayed_bp; i++)
341     {
342         if (dbp[i].is_symbol)
343         {
344             if (symbol_get_lvalue(dbp[i].u.symbol.name, dbp[i].u.symbol.lineno,
345                                   &lvalue, TRUE) != sglv_found)
346                 continue;
347             if (lvalue.cookie != DLV_TARGET) continue;
348         }
349         else
350             lvalue.addr = dbp[i].u.addr;
351         WINE_TRACE("trying to add delayed %s-bp\n", dbp[i].is_symbol ? "S" : "A");
352         if (!dbp[i].is_symbol)
353             WINE_TRACE("\t%04x:%08lx\n", 
354                        dbp[i].u.addr.Segment, dbp[i].u.addr.Offset);
355         else
356             WINE_TRACE("\t'%s' @ %d\n", 
357                        dbp[i].u.symbol.name, dbp[i].u.symbol.lineno);
358
359         if (break_add_break(&lvalue.addr, FALSE, dbp[i].software_bp))
360             memmove(&dbp[i], &dbp[i+1], (--dbg_curr_process->num_delayed_bp - i) * sizeof(*dbp));
361     }
362 }
363
364 /***********************************************************************
365  *           break_add_watch
366  *
367  * Add a watchpoint.
368  */
369 static void break_add_watch(const struct dbg_lvalue* lvalue, BOOL is_write)
370 {
371     int         num;
372     DWORD64     l = 4;
373
374     num = init_xpoint((is_write) ? be_xpoint_watch_write : be_xpoint_watch_read,
375                       &lvalue->addr);
376     if (num == -1) return;
377
378     if (lvalue->type.id != dbg_itype_none)
379     {
380         if (types_get_info(&lvalue->type, TI_GET_LENGTH, &l))
381         {
382             switch (l)
383             {
384             case 4: case 2: case 1: break;
385             default:
386                 dbg_printf("Unsupported length (%s) for watch-points, defaulting to 4\n",
387                            wine_dbgstr_longlong(l));
388                 break;
389             }
390         }
391         else dbg_printf("Cannot get watch size, defaulting to 4\n");
392     }
393     dbg_curr_process->bp[num].w.len = (DWORD)l - 1;
394
395     if (!get_watched_value(num, &dbg_curr_process->bp[num].w.oldval))
396     {
397         dbg_printf("Bad address. Watchpoint not set\n");
398         dbg_curr_process->bp[num].refcount = 0;
399         return;
400     }
401     dbg_printf("Watchpoint %d at ", num);
402     print_address(&dbg_curr_process->bp[num].addr, TRUE);
403     dbg_printf("\n");
404 }
405
406 /******************************************************************
407  *              break_add_watch_from_lvalue
408  *
409  * Adds a watch point from an address (stored in a lvalue)
410  */
411 void break_add_watch_from_lvalue(const struct dbg_lvalue* lvalue)
412 {
413     struct dbg_lvalue   lval;
414
415     types_extract_as_address(lvalue, &lval.addr);
416     lval.type.id = dbg_itype_none;
417
418     break_add_watch(&lval, TRUE);
419 }
420
421 /***********************************************************************
422  *           break_add_watch_from_id
423  *
424  * Add a watchpoint from a symbol name
425  */
426 void    break_add_watch_from_id(const char *name)
427 {
428     struct dbg_lvalue    lvalue;
429
430     switch (symbol_get_lvalue(name, -1, &lvalue, TRUE))
431     {
432     case sglv_found:
433         break_add_watch(&lvalue, 1);
434         break;
435     case sglv_unknown:
436         dbg_printf("Unable to add watchpoint\n");
437         break;
438     case sglv_aborted: /* user aborted symbol lookup */
439         break;
440     }
441 }
442
443 /***********************************************************************
444  *           break_delete_xpoint
445  *
446  * Delete a breakpoint.
447  */
448 void break_delete_xpoint(int num)
449 {
450     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
451
452     if ((num <= 0) || (num >= dbg_curr_process->next_bp) ||
453         bp[num].refcount == 0)
454     {
455         dbg_printf("Invalid breakpoint number %d\n", num);
456         return;
457     }
458
459     if (--bp[num].refcount > 0)
460         return;
461
462     if (bp[num].condition != NULL)
463     {
464         expr_free(bp[num].condition);
465         bp[num].condition = NULL;
466     }
467
468     bp[num].enabled = FALSE;
469     bp[num].refcount = 0;
470     bp[num].skipcount = 0;
471 }
472
473 static inline BOOL module_is_container(const IMAGEHLP_MODULE* wmod_cntnr,
474                                      const IMAGEHLP_MODULE* wmod_child)
475 {
476     return wmod_cntnr->BaseOfImage <= wmod_child->BaseOfImage &&
477         (DWORD)wmod_cntnr->BaseOfImage + wmod_cntnr->ImageSize >=
478         (DWORD)wmod_child->BaseOfImage + wmod_child->ImageSize;
479 }
480
481 /******************************************************************
482  *              break_delete_xpoints_from_module
483  *
484  * Remove all Xpoints from module which base is 'base'
485  */
486 void break_delete_xpoints_from_module(unsigned long base)
487 {
488     IMAGEHLP_MODULE             im, im_elf;
489     int                         i;
490     DWORD                       linear;
491     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
492
493     /* FIXME: should do it also on the ELF sibbling if any */
494     im.SizeOfStruct = sizeof(im);
495     im_elf.SizeOfStruct = sizeof(im_elf);
496     if (!SymGetModuleInfo(dbg_curr_process->handle, base, &im)) return;
497
498     /* try to get in fact the underlying ELF module (if any) */
499     if (SymGetModuleInfo(dbg_curr_process->handle, im.BaseOfImage - 1, &im_elf) &&
500         im_elf.BaseOfImage <= im.BaseOfImage &&
501         (DWORD)im_elf.BaseOfImage + im_elf.ImageSize >= (DWORD)im.BaseOfImage + im.ImageSize)
502         im = im_elf;
503
504     for (i = 0; i < dbg_curr_process->next_bp; i++)
505     {
506         linear = (DWORD)memory_to_linear_addr(&bp[i].addr);
507         if (bp[i].refcount && bp[i].enabled &&
508             im.BaseOfImage <= linear && linear < im.BaseOfImage + im.ImageSize)
509         {
510             break_delete_xpoint(i);
511         }
512     }
513 }
514
515 /***********************************************************************
516  *           break_enable_xpoint
517  *
518  * Enable or disable a break point.
519  */
520 void break_enable_xpoint(int num, BOOL enable)
521 {
522     if ((num <= 0) || (num >= dbg_curr_process->next_bp) || 
523         dbg_curr_process->bp[num].refcount == 0)
524     {
525         dbg_printf("Invalid breakpoint number %d\n", num);
526         return;
527     }
528     dbg_curr_process->bp[num].enabled = (enable) ? TRUE : FALSE;
529     dbg_curr_process->bp[num].skipcount = 0;
530 }
531
532
533 /***********************************************************************
534  *           find_triggered_watch
535  *
536  * Lookup the watchpoints to see if one has been triggered
537  * Return >= (watch point index) if one is found and *oldval is set to
538  *      the value watched before the TRAP
539  * Return -1 if none found (*oldval is undetermined)
540  *
541  * Unfortunately, Linux does *NOT* (A REAL PITA) report with ptrace
542  * the DR6 register value, so we have to look with our own need the
543  * cause of the TRAP.
544  * -EP
545  */
546 static int find_triggered_watch(LPDWORD oldval)
547 {
548     int                         found = -1;
549     int                         i;
550     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
551
552     /* Method 1 => get triggered watchpoint from context (doesn't work on Linux
553      * 2.2.x). This should be fixed in >= 2.2.16
554      */
555     for (i = 0; i < dbg_curr_process->next_bp; i++)
556     {
557         DWORD val = 0;
558
559         if (bp[i].refcount && bp[i].enabled && !is_xpoint_break(i) &&
560             (be_cpu->is_watchpoint_set(&dbg_context, bp[i].info)))
561         {
562             be_cpu->clear_watchpoint(&dbg_context, bp[i].info);
563
564             *oldval = bp[i].w.oldval;
565             if (get_watched_value(i, &val))
566             {
567                 bp[i].w.oldval = val;
568                 return i;
569             }
570         }
571     }
572
573     /* Method 1 failed, trying method 2 */
574
575     /* Method 2 => check if value has changed among registered watchpoints
576      * this really sucks, but this is how gdb 4.18 works on my linux box
577      * -EP
578      */
579     for (i = 0; i < dbg_curr_process->next_bp; i++)
580     {
581         DWORD val = 0;
582
583         if (bp[i].refcount && bp[i].enabled && !is_xpoint_break(i) &&
584             get_watched_value(i, &val))
585         {
586             *oldval = bp[i].w.oldval;
587             if (val != *oldval)
588             {
589                 be_cpu->clear_watchpoint(&dbg_context, bp[i].info);
590                 bp[i].w.oldval = val;
591                 found = i;
592                 /* cannot break, because two watch points may have been triggered on
593                  * the same access
594                  * only one will be reported to the user (FIXME ?)
595                  */
596             }
597         }
598     }
599     return found;
600 }
601
602 /***********************************************************************
603  *           break_info
604  *
605  * Display break & watch points information.
606  */
607 void break_info(void)
608 {
609     int                         i;
610     int                         nbp = 0, nwp = 0;
611     struct dbg_delayed_bp*      dbp = dbg_curr_process->delayed_bp;
612     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
613
614     for (i = 1; i < dbg_curr_process->next_bp; i++)
615     {
616         if (bp[i].refcount)
617         {
618             if (is_xpoint_break(i)) nbp++; else nwp++;
619         }
620     }
621
622     if (nbp)
623     {
624         dbg_printf("Breakpoints:\n");
625         for (i = 1; i < dbg_curr_process->next_bp; i++)
626         {
627             if (!bp[i].refcount || !is_xpoint_break(i))
628                 continue;
629             dbg_printf("%d: %c ", i, bp[i].enabled ? 'y' : 'n');
630             print_address(&bp[i].addr, TRUE);
631             dbg_printf(" (%u)%s\n", bp[i].refcount, 
632                        bp[i].xpoint_type == be_xpoint_watch_exec ? " (hardware assisted)" : "");
633             if (bp[i].condition != NULL)
634             {
635                 dbg_printf("\t\tstop when  ");
636                 expr_print(bp[i].condition);
637                 dbg_printf("\n");
638             }
639         }
640     }
641     else dbg_printf("No breakpoints\n");
642     if (nwp)
643     {
644         dbg_printf("Watchpoints:\n");
645         for (i = 1; i < dbg_curr_process->next_bp; i++)
646         {
647             if (!bp[i].refcount || is_xpoint_break(i))
648                 continue;
649             dbg_printf("%d: %c ", i, bp[i].enabled ? 'y' : 'n');
650             print_address(&bp[i].addr, TRUE);
651             dbg_printf(" on %d byte%s (%c)\n",
652                        bp[i].w.len + 1, bp[i].w.len > 0 ? "s" : "",
653                        bp[i].xpoint_type == be_xpoint_watch_write ? 'W' : 'R');
654             if (bp[i].condition != NULL)
655             {
656                 dbg_printf("\t\tstop when ");
657                 expr_print(bp[i].condition);
658                 dbg_printf("\n");
659             }
660         }
661     }
662     else dbg_printf("No watchpoints\n");
663     if (dbg_curr_process->num_delayed_bp)
664     {
665         dbg_printf("Delayed breakpoints:\n");
666         for (i = 0; i < dbg_curr_process->num_delayed_bp; i++)
667         {
668             if (dbp[i].is_symbol)
669             {
670                 dbg_printf("%d: %s", i, dbp[i].u.symbol.name);
671                 if (dbp[i].u.symbol.lineno != -1)
672                     dbg_printf(" at line %u", dbp[i].u.symbol.lineno);
673             }
674             else
675             {
676                 dbg_printf("%d: ", i);
677                 print_address(&dbp[i].u.addr, FALSE);
678             }
679             dbg_printf("\n");
680         }
681     }
682 }
683
684 /***********************************************************************
685  *           should_stop
686  *
687  * Check whether or not the condition (bp / skipcount) of a break/watch
688  * point are met.
689  */
690 static  BOOL should_stop(int bpnum)
691 {
692     struct dbg_breakpoint*      bp = &dbg_curr_process->bp[bpnum];
693
694     if (bp->condition != NULL)
695     {
696         struct dbg_lvalue lvalue = expr_eval(bp->condition);
697
698         if (lvalue.type.id == dbg_itype_none)
699         {
700             /*
701              * Something wrong - unable to evaluate this expression.
702              */
703             dbg_printf("Unable to evaluate expression ");
704             expr_print(bp->condition);
705             dbg_printf("\nTurning off condition\n");
706             break_add_condition(bpnum, NULL);
707         }
708         else if (!types_extract_as_integer(&lvalue))
709         {
710             return FALSE;
711         }
712     }
713
714     if (bp->skipcount > 0) bp->skipcount--;
715     return bp->skipcount == 0;
716 }
717
718 /***********************************************************************
719  *           break_should_continue
720  *
721  * Determine if we should continue execution after a SIGTRAP signal when
722  * executing in the given mode.
723  */
724 BOOL break_should_continue(ADDRESS* addr, DWORD code, int* count, BOOL* is_break)
725 {
726     DWORD               oldval = 0;
727     enum dbg_exec_mode  mode = dbg_curr_thread->exec_mode;
728
729     *is_break = FALSE;
730     /* If not single-stepping, back up to the break instruction */
731     if (code == EXCEPTION_BREAKPOINT)
732         addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, TRUE);
733
734     dbg_curr_process->bp[0].enabled = FALSE;  /* disable the step-over breakpoint */
735
736     dbg_curr_thread->stopped_xpoint = find_xpoint(addr, be_xpoint_break);
737     if (dbg_curr_thread->stopped_xpoint > 0)
738     {
739         if (!should_stop(dbg_curr_thread->stopped_xpoint)) return TRUE;
740
741         dbg_printf("Stopped on breakpoint %d at ", dbg_curr_thread->stopped_xpoint);
742         print_address(&dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].addr, TRUE);
743         dbg_printf("\n");
744         return FALSE;
745     }
746
747     dbg_curr_thread->stopped_xpoint = find_xpoint(addr, be_xpoint_watch_exec);
748     if (dbg_curr_thread->stopped_xpoint > 0)
749     {
750         /* If not single-stepping, do not back up over the break instruction */
751         if (code == EXCEPTION_BREAKPOINT)
752             addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, FALSE);
753
754         if (!should_stop(dbg_curr_thread->stopped_xpoint)) return TRUE;
755
756         dbg_printf("Stopped on breakpoint %d at ", dbg_curr_thread->stopped_xpoint);
757         print_address(&dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].addr, TRUE);
758         dbg_printf("\n");
759         return FALSE;
760     }
761
762     dbg_curr_thread->stopped_xpoint = find_triggered_watch(&oldval);
763     if (dbg_curr_thread->stopped_xpoint > 0)
764     {
765         /* If not single-stepping, do not back up over the break instruction */
766         if (code == EXCEPTION_BREAKPOINT)
767             addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, FALSE);
768
769         if (!should_stop(dbg_curr_thread->stopped_xpoint)) return TRUE;
770
771         dbg_printf("Stopped on watchpoint %d at ", dbg_curr_thread->stopped_xpoint);
772         print_address(addr, TRUE);
773         dbg_printf(" values: old=%lu new=%lu\n",
774                    oldval, dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].w.oldval);
775         return FALSE;
776     }
777
778     /*
779      * If our mode indicates that we are stepping line numbers,
780      * get the current function, and figure out if we are exactly
781      * on a line number or not.
782      */
783     if (mode == dbg_exec_step_over_line || mode == dbg_exec_step_into_line)
784     {
785         if (symbol_get_function_line_status(addr) == dbg_on_a_line_number)
786         {
787             (*count)--;
788         }
789     }
790     else if (mode == dbg_exec_step_over_insn || mode == dbg_exec_step_into_insn)
791     {
792         (*count)--;
793     }
794
795     if (*count > 0 || mode == dbg_exec_finish)
796     {
797         /*
798          * We still need to execute more instructions.
799          */
800         return TRUE;
801     }
802
803     /* If there's no breakpoint and we are not single-stepping, then
804      * either we must have encountered a break insn in the Windows program
805      * or someone is trying to stop us
806      */
807     if (dbg_curr_thread->stopped_xpoint == -1 && code == EXCEPTION_BREAKPOINT)
808     {
809         *is_break = TRUE;
810         addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, FALSE);
811         return FALSE;
812     }
813
814     /* no breakpoint, continue if in continuous mode */
815     return mode == dbg_exec_cont || mode == dbg_exec_finish;
816 }
817
818 /***********************************************************************
819  *           break_suspend_execution
820  *
821  * Remove all bp before entering the debug loop
822  */
823 void    break_suspend_execution(void)
824 {
825     break_set_xpoints(FALSE);
826     dbg_curr_process->bp[0] = dbg_curr_thread->step_over_bp;
827 }
828
829 /***********************************************************************
830  *           break_restart_execution
831  *
832  * Set the bp to the correct state to restart execution
833  * in the given mode.
834  */
835 void break_restart_execution(int count)
836 {
837     ADDRESS                     addr;
838     enum dbg_line_status        status;
839     enum dbg_exec_mode          mode, ret_mode;
840     ADDRESS                     callee;
841     void*                       linear;
842
843     memory_get_current_pc(&addr);
844     linear = memory_to_linear_addr(&addr);
845
846     /*
847      * This is the mode we will be running in after we finish.  We would like
848      * to be able to modify this in certain cases.
849      */
850     ret_mode = mode = dbg_curr_thread->exec_mode;
851
852     /* we've stopped on a xpoint (other than step over) */
853     if (dbg_curr_thread->stopped_xpoint > 0)
854     {
855         /*
856          * If we have set a new value, then save it in the BP number.
857          */
858         if (count != 0 && mode == dbg_exec_cont)
859         {
860             dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].skipcount = count;
861         }
862         /* If we've stopped on a breakpoint, single step over it (, then run) */
863         if (is_xpoint_break(dbg_curr_thread->stopped_xpoint))
864             mode = dbg_exec_step_into_insn;
865     }
866     else if (mode == dbg_exec_cont && count > 1)
867     {
868         dbg_printf("Not stopped at any breakpoint; argument ignored.\n");
869     }
870
871     if (mode == dbg_exec_finish && be_cpu->is_function_return(linear))
872     {
873         mode = ret_mode = dbg_exec_step_into_insn;
874     }
875
876     /*
877      * See if the function we are stepping into has debug info
878      * and line numbers.  If not, then we step over it instead.
879      * FIXME - we need to check for things like thunks or trampolines,
880      * as the actual function may in fact have debug info.
881      */
882     if (be_cpu->is_function_call(linear, &callee))
883     {
884         status = symbol_get_function_line_status(&callee);
885 #if 0
886         /* FIXME: we need to get the thunk type */
887         /*
888          * Anytime we have a trampoline, step over it.
889          */
890         if ((mode == EXEC_STEP_OVER || mode == EXEC_STEPI_OVER)
891             && status == dbg_in_a_thunk)
892         {
893             WINE_WARN("Not stepping into trampoline at %p (no lines)\n", 
894                       memory_to_linear_addr(&callee));
895             mode = EXEC_STEP_OVER_TRAMPOLINE;
896         }
897 #endif
898         if (mode == dbg_exec_step_into_line && status == dbg_no_line_info)
899         {
900             WINE_WARN("Not stepping into function at %p (no lines)\n",
901                       memory_to_linear_addr(&callee));
902             mode = dbg_exec_step_over_line;
903         }
904     }
905
906     if (mode == dbg_exec_step_into_line && 
907         symbol_get_function_line_status(&addr) == dbg_no_line_info)
908     {
909         dbg_printf("Single stepping until exit from function, \n"
910                    "which has no line number information.\n");
911         ret_mode = mode = dbg_exec_finish;
912     }
913
914     switch (mode)
915     {
916     case dbg_exec_cont: /* Continuous execution */
917         be_cpu->single_step(&dbg_context, FALSE);
918         break_set_xpoints(TRUE);
919         break;
920
921 #if 0
922     case EXEC_STEP_OVER_TRAMPOLINE:
923         /*
924          * This is the means by which we step over our conversion stubs
925          * in callfrom*.s and callto*.s.  We dig the appropriate address
926          * off the stack, and we set the breakpoint there instead of the
927          * address just after the call.
928          */
929         be_cpu->get_addr(dbg_curr_thread->handle, &dbg_context,
930                          be_cpu_addr_stack, &addr);
931         /* FIXME: we assume stack grows as on an i386 */
932         addr.Offset += 2 * sizeof(unsigned int);
933         dbg_read_memory(memory_to_linear_addr(&addr),
934                         &addr.Offset, sizeof(addr.Offset));
935         dbg_curr_process->bp[0].addr = addr;
936         dbg_curr_process->bp[0].enabled = TRUE;
937         dbg_curr_process->bp[0].refcount = 1;
938         dbg_curr_process->bp[0].skipcount = 0;
939         dbg_curr_process->bp[0].xpoint_type = be_xpoint_break;
940         dbg_curr_process->bp[0].condition = NULL;
941         be_cpu->single_step(&dbg_context, FALSE);
942         break_set_xpoints(TRUE);
943         break;
944 #endif
945
946     case dbg_exec_finish:
947     case dbg_exec_step_over_insn:  /* Stepping over a call */
948     case dbg_exec_step_over_line:  /* Stepping over a call */
949         if (be_cpu->is_step_over_insn(linear))
950         {
951             be_cpu->disasm_one_insn(&addr, FALSE);
952             dbg_curr_process->bp[0].addr = addr;
953             dbg_curr_process->bp[0].enabled = TRUE;
954             dbg_curr_process->bp[0].refcount = 1;
955             dbg_curr_process->bp[0].skipcount = 0;
956             dbg_curr_process->bp[0].xpoint_type = be_xpoint_break;
957             dbg_curr_process->bp[0].condition = NULL;
958             be_cpu->single_step(&dbg_context, FALSE);
959             break_set_xpoints(TRUE);
960             break;
961         }
962         /* else fall through to single-stepping */
963
964     case dbg_exec_step_into_line: /* Single-stepping a line */
965     case dbg_exec_step_into_insn: /* Single-stepping an instruction */
966         be_cpu->single_step(&dbg_context, TRUE);
967         break;
968     default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
969     }
970     dbg_curr_thread->step_over_bp = dbg_curr_process->bp[0];
971     dbg_curr_thread->exec_mode = ret_mode;
972 }
973
974 int break_add_condition(int num, struct expr* exp)
975 {
976     if (num <= 0 || num >= dbg_curr_process->next_bp || 
977         !dbg_curr_process->bp[num].refcount)
978     {
979         dbg_printf("Invalid breakpoint number %d\n", num);
980         return FALSE;
981     }
982
983     if (dbg_curr_process->bp[num].condition != NULL)
984     {
985         expr_free(dbg_curr_process->bp[num].condition);
986         dbg_curr_process->bp[num].condition = NULL;
987     }
988
989     if (exp != NULL) dbg_curr_process->bp[num].condition = expr_clone(exp, NULL);
990
991     return TRUE;
992 }