cmd: Don't read past end of thisVar in WCMD_expand_envvar (valgrind).
[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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 = 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 ADDRESS64* 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 ADDRESS64* 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, DWORD64* val)
141 {
142     DWORD64     buf[1];
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 8:     *val = *(DWORD64*)buf;  break;
151     case 4:     *val = *(DWORD*)buf;    break;
152     case 2:     *val = *(WORD*)buf;     break;
153     case 1:     *val = *(BYTE*)buf;     break;
154     default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
155     }
156     return TRUE;
157 }
158
159 /***********************************************************************
160  *           break_add_break
161  *
162  * Add a breakpoint.
163  */
164 BOOL break_add_break(const ADDRESS64* addr, BOOL verbose, BOOL swbp)
165 {
166     int                         num;
167     BYTE                        ch;
168     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
169     int                         type = swbp ? be_xpoint_break : be_xpoint_watch_exec;
170
171     if ((num = find_xpoint(addr, type)) >= 1)
172     {
173         bp[num].refcount++;
174         dbg_printf("Breakpoint %d at ", num);
175         print_address(&bp[num].addr, TRUE);
176         dbg_printf(" (refcount=%d)\n", bp[num].refcount);
177         return TRUE;
178     }
179
180     if (!dbg_read_memory(memory_to_linear_addr(addr), &ch, sizeof(ch)))
181     {
182         if (verbose)
183         {
184             dbg_printf("Invalid address ");
185             print_bare_address(addr);
186             dbg_printf(", can't set breakpoint\n");
187         }
188         return FALSE;
189     }
190
191     if ((num = init_xpoint(type, addr)) == -1)
192         return FALSE;
193
194     dbg_printf("Breakpoint %d at ", num);
195     print_address(&bp[num].addr, TRUE);
196     dbg_printf("\n");
197
198     return TRUE;
199 }
200
201 /***********************************************************************
202  *           break_add_break_from_lvalue
203  *
204  * Add a breakpoint.
205  */
206 BOOL break_add_break_from_lvalue(const struct dbg_lvalue* lvalue, BOOL swbp)
207 {
208     ADDRESS64   addr;
209
210     types_extract_as_address(lvalue, &addr);
211
212     if (!break_add_break(&addr, TRUE, swbp))
213     {
214         if (!DBG_IVAR(CanDeferOnBPByAddr))
215         {
216             dbg_printf("Invalid address, can't set breakpoint\n"
217                        "You can turn on deferring bp by address by setting $CanDeferOnBPByAddr to 1\n");
218             return FALSE;
219         }
220         dbg_printf("Unable to add breakpoint, will check again any time a new DLL is loaded\n");
221         dbg_curr_process->delayed_bp = 
222             dbg_heap_realloc(dbg_curr_process->delayed_bp,
223                              sizeof(struct dbg_delayed_bp) * ++dbg_curr_process->num_delayed_bp);
224
225         dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].is_symbol   = FALSE;
226         dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].software_bp = swbp;
227         dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].u.addr      = addr;
228         return TRUE;
229     }
230     return FALSE;
231 }
232
233 /***********************************************************************
234  *           break_add_break_from_id
235  *
236  * Add a breakpoint from a function name (and eventually a line #)
237  */
238 void    break_add_break_from_id(const char *name, int lineno, BOOL swbp)
239 {
240     struct dbg_lvalue   lvalue;
241     int                 i;
242
243     switch (symbol_get_lvalue(name, lineno, &lvalue, TRUE))
244     {
245     case sglv_found:
246         break_add_break(&lvalue.addr, TRUE, swbp);
247         return;
248     case sglv_unknown:
249         break;
250     case sglv_aborted: /* user aborted symbol lookup */
251         return;
252     }
253
254     dbg_printf("Unable to add breakpoint, will check again when a new DLL is loaded\n");
255     for (i = 0; i < dbg_curr_process->num_delayed_bp; i++)
256     {
257         if (dbg_curr_process->delayed_bp[i].is_symbol &&
258             !strcmp(name, dbg_curr_process->delayed_bp[i].u.symbol.name) &&
259             lineno == dbg_curr_process->delayed_bp[i].u.symbol.lineno)
260             return;
261     }
262     dbg_curr_process->delayed_bp = dbg_heap_realloc(dbg_curr_process->delayed_bp,
263                                                     sizeof(struct dbg_delayed_bp) * ++dbg_curr_process->num_delayed_bp);
264
265     dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].is_symbol       = TRUE;
266     dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].software_bp     = swbp;
267     dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].u.symbol.name   = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(name) + 1), name);
268     dbg_curr_process->delayed_bp[dbg_curr_process->num_delayed_bp - 1].u.symbol.lineno = lineno;
269 }
270
271 struct cb_break_lineno
272 {
273     const char* filename;
274     int         lineno;
275     ADDRESS64   addr;
276 };
277
278 static BOOL CALLBACK line_cb(SRCCODEINFO* sci, void* user)
279 {
280     struct cb_break_lineno*      bkln = user;
281
282     if (bkln->lineno == sci->LineNumber)
283     {
284         bkln->addr.Mode = AddrModeFlat;
285         bkln->addr.Offset = sci->Address;
286         return FALSE;
287     }
288     return TRUE;
289 }
290
291 static BOOL CALLBACK mcb(PCWSTR module, DWORD64 base, void* user)
292 {
293     struct cb_break_lineno*      bkln = user;
294
295     SymEnumLines(dbg_curr_process->handle, base, NULL, bkln->filename, line_cb, bkln);
296     /* continue module enum if no addr found
297      * FIXME: we don't report when several addresses match the same filename/lineno pair
298      */
299     return !bkln->addr.Offset;
300 }
301
302 /***********************************************************************
303  *           break_add_break_from_lineno
304  *
305  * Add a breakpoint from a line number in current file
306  */
307 void break_add_break_from_lineno(const char *filename, int lineno, BOOL swbp)
308 {
309     struct cb_break_lineno      bkln;
310     bkln.addr.Offset = 0;
311     bkln.lineno = lineno;
312
313     if (!filename)
314     {
315         DWORD disp;
316         ADDRESS64 curr;
317         IMAGEHLP_LINE64 il;
318         DWORD_PTR linear;
319
320         memory_get_current_pc(&curr);
321         linear = (DWORD_PTR)memory_to_linear_addr(&curr);
322         il.SizeOfStruct = sizeof(il);
323         if (!SymGetLineFromAddr64(dbg_curr_process->handle, linear, &disp, &il))
324         {
325             dbg_printf("Unable to add breakpoint (unknown address %lx)\n", linear);
326             return;
327         }
328         filename = il.FileName;
329         SymEnumLines(dbg_curr_process->handle, linear, NULL, filename, line_cb, &bkln);
330     }
331     else
332     {
333         /* we have to enumerate across modules */
334         bkln.filename = filename;
335         SymEnumerateModulesW64(dbg_curr_process->handle, mcb, &bkln);
336     }
337     if (bkln.addr.Offset)
338         break_add_break(&bkln.addr, TRUE, swbp);
339     else
340         dbg_printf("Unknown line number\n"
341                    "(either out of file, or no code at given line number)\n");
342 }
343
344 /***********************************************************************
345  *           break_check_delayed_bp
346  *
347  * Check is a registered delayed BP is now available.
348  */
349 void break_check_delayed_bp(void)
350 {
351     struct dbg_lvalue           lvalue;
352     int                         i;
353     struct dbg_delayed_bp*      dbp = dbg_curr_process->delayed_bp;
354     char                        hexbuf[MAX_OFFSET_TO_STR_LEN];
355
356     for (i = 0; i < dbg_curr_process->num_delayed_bp; i++)
357     {
358         if (dbp[i].is_symbol)
359         {
360             if (symbol_get_lvalue(dbp[i].u.symbol.name, dbp[i].u.symbol.lineno,
361                                   &lvalue, TRUE) != sglv_found)
362                 continue;
363             if (lvalue.cookie != DLV_TARGET) continue;
364         }
365         else
366             lvalue.addr = dbp[i].u.addr;
367         WINE_TRACE("trying to add delayed %s-bp\n", dbp[i].is_symbol ? "S" : "A");
368         if (!dbp[i].is_symbol)
369             WINE_TRACE("\t%04x:%s\n", 
370                        dbp[i].u.addr.Segment,
371                        memory_offset_to_string(hexbuf, dbp[i].u.addr.Offset, 0));
372         else
373             WINE_TRACE("\t'%s' @ %d\n", 
374                        dbp[i].u.symbol.name, dbp[i].u.symbol.lineno);
375
376         if (break_add_break(&lvalue.addr, FALSE, dbp[i].software_bp))
377             memmove(&dbp[i], &dbp[i+1], (--dbg_curr_process->num_delayed_bp - i) * sizeof(*dbp));
378     }
379 }
380
381 /***********************************************************************
382  *           break_add_watch
383  *
384  * Add a watchpoint.
385  */
386 static void break_add_watch(const struct dbg_lvalue* lvalue, BOOL is_write)
387 {
388     int         num;
389     DWORD64     l = 4;
390
391     if (lvalue->cookie == DLV_HOST)
392     {
393         dbg_printf("Cannot set a watch point on register or register-based variable\n");
394         return;
395     }
396     num = init_xpoint((is_write) ? be_xpoint_watch_write : be_xpoint_watch_read,
397                       &lvalue->addr);
398     if (num == -1) return;
399
400     if (lvalue->type.id != dbg_itype_none)
401     {
402         if (types_get_info(&lvalue->type, TI_GET_LENGTH, &l))
403         {
404             switch (l)
405             {
406             case 4: case 2: case 1: break;
407             default:
408                 dbg_printf("Unsupported length (%s) for watch-points, defaulting to 4\n",
409                            wine_dbgstr_longlong(l));
410                 break;
411             }
412         }
413         else dbg_printf("Cannot get watch size, defaulting to 4\n");
414     }
415     dbg_curr_process->bp[num].w.len = (DWORD)l - 1;
416
417     if (!get_watched_value(num, &dbg_curr_process->bp[num].w.oldval))
418     {
419         dbg_printf("Bad address. Watchpoint not set\n");
420         dbg_curr_process->bp[num].refcount = 0;
421         return;
422     }
423     dbg_printf("Watchpoint %d at ", num);
424     print_address(&dbg_curr_process->bp[num].addr, TRUE);
425     dbg_printf("\n");
426 }
427
428 /******************************************************************
429  *              break_add_watch_from_lvalue
430  *
431  * Adds a watch point from an address (stored in a lvalue)
432  */
433 void break_add_watch_from_lvalue(const struct dbg_lvalue* lvalue,BOOL is_write)
434 {
435     struct dbg_lvalue   lval;
436
437     types_extract_as_address(lvalue, &lval.addr);
438     lval.type.id = dbg_itype_none;
439
440     break_add_watch(&lval, is_write);
441 }
442
443 /***********************************************************************
444  *           break_add_watch_from_id
445  *
446  * Add a watchpoint from a symbol name
447  */
448 void    break_add_watch_from_id(const char *name, BOOL is_write)
449 {
450     struct dbg_lvalue    lvalue;
451
452     switch (symbol_get_lvalue(name, -1, &lvalue, TRUE))
453     {
454     case sglv_found:
455         break_add_watch(&lvalue, is_write);
456         break;
457     case sglv_unknown:
458         dbg_printf("Unable to add watchpoint\n");
459         break;
460     case sglv_aborted: /* user aborted symbol lookup */
461         break;
462     }
463 }
464
465 /***********************************************************************
466  *           break_delete_xpoint
467  *
468  * Delete a breakpoint.
469  */
470 void break_delete_xpoint(int num)
471 {
472     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
473
474     if ((num <= 0) || (num >= dbg_curr_process->next_bp) ||
475         bp[num].refcount == 0)
476     {
477         dbg_printf("Invalid breakpoint number %d\n", num);
478         return;
479     }
480
481     if (--bp[num].refcount > 0)
482         return;
483
484     if (bp[num].condition != NULL)
485     {
486         expr_free(bp[num].condition);
487         bp[num].condition = NULL;
488     }
489
490     bp[num].enabled = FALSE;
491     bp[num].refcount = 0;
492     bp[num].skipcount = 0;
493 }
494
495 static inline BOOL module_is_container(const IMAGEHLP_MODULE* wmod_cntnr,
496                                      const IMAGEHLP_MODULE* wmod_child)
497 {
498     return wmod_cntnr->BaseOfImage <= wmod_child->BaseOfImage &&
499         wmod_cntnr->BaseOfImage + wmod_cntnr->ImageSize >=
500         wmod_child->BaseOfImage + wmod_child->ImageSize;
501 }
502
503 /******************************************************************
504  *              break_delete_xpoints_from_module
505  *
506  * Remove all Xpoints from module which base is 'base'
507  */
508 void break_delete_xpoints_from_module(DWORD64 base)
509 {
510     IMAGEHLP_MODULE64           im, im_elf;
511     int                         i;
512     DWORD_PTR                   linear;
513     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
514
515     /* FIXME: should do it also on the ELF sibbling if any */
516     im.SizeOfStruct = sizeof(im);
517     im_elf.SizeOfStruct = sizeof(im_elf);
518     if (!SymGetModuleInfo64(dbg_curr_process->handle, base, &im)) return;
519
520     /* try to get in fact the underlying ELF module (if any) */
521     if (SymGetModuleInfo64(dbg_curr_process->handle, im.BaseOfImage - 1, &im_elf) &&
522         im_elf.BaseOfImage <= im.BaseOfImage &&
523         im_elf.BaseOfImage + im_elf.ImageSize >= im.BaseOfImage + im.ImageSize)
524         im = im_elf;
525
526     for (i = 0; i < dbg_curr_process->next_bp; i++)
527     {
528         if (bp[i].refcount && bp[i].enabled)
529         {
530             linear = (DWORD_PTR)memory_to_linear_addr(&bp[i].addr);
531             if (im.BaseOfImage <= linear && linear < im.BaseOfImage + im.ImageSize)
532             {
533                 break_delete_xpoint(i);
534             }
535         }
536     }
537 }
538
539 /***********************************************************************
540  *           break_enable_xpoint
541  *
542  * Enable or disable a break point.
543  */
544 void break_enable_xpoint(int num, BOOL enable)
545 {
546     if ((num <= 0) || (num >= dbg_curr_process->next_bp) || 
547         dbg_curr_process->bp[num].refcount == 0)
548     {
549         dbg_printf("Invalid breakpoint number %d\n", num);
550         return;
551     }
552     dbg_curr_process->bp[num].enabled = (enable) ? TRUE : FALSE;
553     dbg_curr_process->bp[num].skipcount = 0;
554 }
555
556
557 /***********************************************************************
558  *           find_triggered_watch
559  *
560  * Lookup the watchpoints to see if one has been triggered
561  * Return >= (watch point index) if one is found
562  * Return -1 if none found
563  *
564  * Unfortunately, Linux used to *NOT* (A REAL PITA) report with ptrace
565  * the DR6 register value, so we have to look with our own need the
566  * cause of the TRAP.
567  * -EP
568  */
569 static int find_triggered_watch(void)
570 {
571     int                         found = -1;
572     int                         i;
573     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
574
575     /* Method 1 => get triggered watchpoint from context (doesn't work on Linux
576      * 2.2.x). This should be fixed in >= 2.2.16
577      */
578     for (i = 0; i < dbg_curr_process->next_bp; i++)
579     {
580         DWORD64 val = 0;
581
582         if (bp[i].refcount && bp[i].enabled && !is_xpoint_break(i) &&
583             (be_cpu->is_watchpoint_set(&dbg_context, bp[i].info)))
584         {
585             be_cpu->clear_watchpoint(&dbg_context, bp[i].info);
586
587             if (get_watched_value(i, &val))
588             {
589                 bp[i].w.oldval = val;
590                 return i;
591             }
592         }
593     }
594
595     /* Method 1 failed, trying method 2 */
596
597     /* Method 2 => check if value has changed among registered watchpoints
598      * this really sucks, but this is how gdb 4.18 works on my linux box
599      * -EP
600      */
601     for (i = 0; i < dbg_curr_process->next_bp; i++)
602     {
603         DWORD64 val = 0;
604
605         if (bp[i].refcount && bp[i].enabled && !is_xpoint_break(i) &&
606             get_watched_value(i, &val))
607         {
608             if (val != bp[i].w.oldval)
609             {
610                 be_cpu->clear_watchpoint(&dbg_context, bp[i].info);
611                 bp[i].w.oldval = val;
612                 found = i;
613                 /* cannot break, because two watch points may have been triggered on
614                  * the same access
615                  * only one will be reported to the user (FIXME ?)
616                  */
617             }
618         }
619     }
620     return found;
621 }
622
623 /***********************************************************************
624  *           break_info
625  *
626  * Display break & watch points information.
627  */
628 void break_info(void)
629 {
630     int                         i;
631     int                         nbp = 0, nwp = 0;
632     struct dbg_delayed_bp*      dbp = dbg_curr_process->delayed_bp;
633     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
634
635     for (i = 1; i < dbg_curr_process->next_bp; i++)
636     {
637         if (bp[i].refcount)
638         {
639             if (is_xpoint_break(i)) nbp++; else nwp++;
640         }
641     }
642
643     if (nbp)
644     {
645         dbg_printf("Breakpoints:\n");
646         for (i = 1; i < dbg_curr_process->next_bp; i++)
647         {
648             if (!bp[i].refcount || !is_xpoint_break(i))
649                 continue;
650             dbg_printf("%d: %c ", i, bp[i].enabled ? 'y' : 'n');
651             print_address(&bp[i].addr, TRUE);
652             dbg_printf(" (%u)%s\n", bp[i].refcount, 
653                        bp[i].xpoint_type == be_xpoint_watch_exec ? " (hardware assisted)" : "");
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 breakpoints\n");
663     if (nwp)
664     {
665         dbg_printf("Watchpoints:\n");
666         for (i = 1; i < dbg_curr_process->next_bp; i++)
667         {
668             if (!bp[i].refcount || is_xpoint_break(i))
669                 continue;
670             dbg_printf("%d: %c ", i, bp[i].enabled ? 'y' : 'n');
671             print_address(&bp[i].addr, TRUE);
672             dbg_printf(" on %d byte%s (%c)\n",
673                        bp[i].w.len + 1, bp[i].w.len > 0 ? "s" : "",
674                        bp[i].xpoint_type == be_xpoint_watch_write ? 'W' : 'R');
675             if (bp[i].condition != NULL)
676             {
677                 dbg_printf("\t\tstop when ");
678                 expr_print(bp[i].condition);
679                 dbg_printf("\n");
680             }
681         }
682     }
683     else dbg_printf("No watchpoints\n");
684     if (dbg_curr_process->num_delayed_bp)
685     {
686         dbg_printf("Delayed breakpoints:\n");
687         for (i = 0; i < dbg_curr_process->num_delayed_bp; i++)
688         {
689             if (dbp[i].is_symbol)
690             {
691                 dbg_printf("%d: %s", i, dbp[i].u.symbol.name);
692                 if (dbp[i].u.symbol.lineno != -1)
693                     dbg_printf(" at line %u", dbp[i].u.symbol.lineno);
694             }
695             else
696             {
697                 dbg_printf("%d: ", i);
698                 print_address(&dbp[i].u.addr, FALSE);
699             }
700             dbg_printf("\n");
701         }
702     }
703 }
704
705 /***********************************************************************
706  *           should_stop
707  *
708  * Check whether or not the condition (bp / skipcount) of a break/watch
709  * point are met.
710  */
711 static  BOOL should_stop(int bpnum)
712 {
713     struct dbg_breakpoint*      bp = &dbg_curr_process->bp[bpnum];
714
715     if (bp->condition != NULL)
716     {
717         struct dbg_lvalue lvalue = expr_eval(bp->condition);
718
719         if (lvalue.type.id == dbg_itype_none)
720         {
721             /*
722              * Something wrong - unable to evaluate this expression.
723              */
724             dbg_printf("Unable to evaluate expression ");
725             expr_print(bp->condition);
726             dbg_printf("\nTurning off condition\n");
727             break_add_condition(bpnum, NULL);
728         }
729         else if (!types_extract_as_integer(&lvalue))
730         {
731             return FALSE;
732         }
733     }
734
735     if (bp->skipcount > 0) bp->skipcount--;
736     return bp->skipcount == 0;
737 }
738
739 /***********************************************************************
740  *           break_should_continue
741  *
742  * Determine if we should continue execution after a SIGTRAP signal when
743  * executing in the given mode.
744  */
745 BOOL break_should_continue(ADDRESS64* addr, DWORD code)
746 {
747     enum dbg_exec_mode  mode = dbg_curr_thread->exec_mode;
748
749
750     if (dbg_curr_thread->stopped_xpoint > 0)
751     {
752         if (!should_stop(dbg_curr_thread->stopped_xpoint)) return TRUE;
753
754         switch (dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].xpoint_type)
755         {
756         case be_xpoint_break:
757         case be_xpoint_watch_exec:
758             dbg_printf("Stopped on breakpoint %d at ", dbg_curr_thread->stopped_xpoint);
759             print_address(&dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].addr, TRUE);
760             dbg_printf("\n");
761             break;
762         case be_xpoint_watch_read:
763         case be_xpoint_watch_write:
764             dbg_printf("Stopped on watchpoint %d at ", dbg_curr_thread->stopped_xpoint);
765             print_address(addr, TRUE);
766             dbg_printf(" new value %s\n",
767                        wine_dbgstr_longlong(dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].w.oldval));
768         }
769         return FALSE;
770     }
771
772     /*
773      * If our mode indicates that we are stepping line numbers,
774      * get the current function, and figure out if we are exactly
775      * on a line number or not.
776      */
777     if (mode == dbg_exec_step_over_line || mode == dbg_exec_step_into_line)
778     {
779         if (symbol_get_function_line_status(addr) == dbg_on_a_line_number)
780             dbg_curr_thread->exec_count--;
781     }
782     else if (mode == dbg_exec_step_over_insn || mode == dbg_exec_step_into_insn)
783         dbg_curr_thread->exec_count--;
784
785     if (dbg_curr_thread->exec_count > 0 || mode == dbg_exec_finish)
786     {
787         /*
788          * We still need to execute more instructions.
789          */
790         return TRUE;
791     }
792
793     /* no breakpoint, continue if in continuous mode */
794     return mode == dbg_exec_cont || mode == dbg_exec_finish;
795 }
796
797 /***********************************************************************
798  *           break_adjust_pc
799  *
800  * Adjust PC to the address where the trap (if any) actually occurred
801  * Also sets dbg_curr_thread->stopped_xpoint
802  */
803 void break_adjust_pc(ADDRESS64* addr, DWORD code, BOOL first_chance, BOOL* is_break)
804 {
805     /* break / watch points are handled on first chance */
806     if ( !first_chance )
807     {
808         *is_break = TRUE;
809         dbg_curr_thread->stopped_xpoint = -1;
810         return;
811     }
812     *is_break = FALSE;
813
814     /* If not single-stepping, back up to the break instruction */
815     if (code == EXCEPTION_BREAKPOINT)
816         addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, TRUE);
817
818     dbg_curr_thread->stopped_xpoint = find_xpoint(addr, be_xpoint_break);
819     dbg_curr_process->bp[0].enabled = FALSE;  /* disable the step-over breakpoint */
820
821     if (dbg_curr_thread->stopped_xpoint > 0) return;
822
823     if (dbg_curr_thread->stopped_xpoint < 0)
824     {
825         dbg_curr_thread->stopped_xpoint = find_xpoint(addr, be_xpoint_watch_exec);
826         if (dbg_curr_thread->stopped_xpoint < 0)
827             dbg_curr_thread->stopped_xpoint = find_triggered_watch();
828         if (dbg_curr_thread->stopped_xpoint > 0)
829         {
830             /* If not single-stepping, do not back up over the break instruction */
831             if (code == EXCEPTION_BREAKPOINT)
832                 addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, FALSE);
833             return;
834         }
835     }
836
837     /* If there's no breakpoint and we are not single-stepping, then
838      * either we must have encountered a break insn in the Windows program
839      * or someone is trying to stop us
840      */
841     if (dbg_curr_thread->stopped_xpoint == -1 && code == EXCEPTION_BREAKPOINT)
842     {
843         *is_break = TRUE;
844         addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, FALSE);
845     }
846 }
847
848 /***********************************************************************
849  *           break_suspend_execution
850  *
851  * Remove all bp before entering the debug loop
852  */
853 void    break_suspend_execution(void)
854 {
855     break_set_xpoints(FALSE);
856     dbg_curr_process->bp[0] = dbg_curr_thread->step_over_bp;
857 }
858
859 /***********************************************************************
860  *           break_restart_execution
861  *
862  * Set the bp to the correct state to restart execution
863  * in the given mode.
864  */
865 void break_restart_execution(int count)
866 {
867     ADDRESS64                   addr;
868     enum dbg_line_status        status;
869     enum dbg_exec_mode          mode, ret_mode;
870     ADDRESS64                   callee;
871     void*                       linear;
872
873     memory_get_current_pc(&addr);
874     linear = memory_to_linear_addr(&addr);
875
876     /*
877      * This is the mode we will be running in after we finish.  We would like
878      * to be able to modify this in certain cases.
879      */
880     ret_mode = mode = dbg_curr_thread->exec_mode;
881
882     /* we've stopped on a xpoint (other than step over) */
883     if (dbg_curr_thread->stopped_xpoint > 0)
884     {
885         /*
886          * If we have set a new value, then save it in the BP number.
887          */
888         if (count != 0 && mode == dbg_exec_cont)
889         {
890             dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].skipcount = count;
891         }
892         /* If we've stopped on a breakpoint, single step over it (, then run) */
893         if (is_xpoint_break(dbg_curr_thread->stopped_xpoint))
894             mode = dbg_exec_step_into_insn;
895     }
896     else if (mode == dbg_exec_cont && count > 1)
897     {
898         dbg_printf("Not stopped at any breakpoint; argument ignored.\n");
899     }
900
901     if (mode == dbg_exec_finish && be_cpu->is_function_return(linear))
902     {
903         mode = ret_mode = dbg_exec_step_into_insn;
904     }
905
906     /*
907      * See if the function we are stepping into has debug info
908      * and line numbers.  If not, then we step over it instead.
909      * FIXME - we need to check for things like thunks or trampolines,
910      * as the actual function may in fact have debug info.
911      */
912     if (be_cpu->is_function_call(linear, &callee))
913     {
914         status = symbol_get_function_line_status(&callee);
915 #if 0
916         /* FIXME: we need to get the thunk type */
917         /*
918          * Anytime we have a trampoline, step over it.
919          */
920         if ((mode == EXEC_STEP_OVER || mode == EXEC_STEPI_OVER)
921             && status == dbg_in_a_thunk)
922         {
923             WINE_WARN("Not stepping into trampoline at %p (no lines)\n", 
924                       memory_to_linear_addr(&callee));
925             mode = EXEC_STEP_OVER_TRAMPOLINE;
926         }
927 #endif
928         if (mode == dbg_exec_step_into_line && status == dbg_no_line_info)
929         {
930             WINE_WARN("Not stepping into function at %p (no lines)\n",
931                       memory_to_linear_addr(&callee));
932             mode = dbg_exec_step_over_line;
933         }
934     }
935
936     if (mode == dbg_exec_step_into_line && 
937         symbol_get_function_line_status(&addr) == dbg_no_line_info)
938     {
939         dbg_printf("Single stepping until exit from function,\n"
940                    "which has no line number information.\n");
941         ret_mode = mode = dbg_exec_finish;
942     }
943
944     switch (mode)
945     {
946     case dbg_exec_cont: /* Continuous execution */
947         be_cpu->single_step(&dbg_context, FALSE);
948         break_set_xpoints(TRUE);
949         break;
950
951 #if 0
952     case EXEC_STEP_OVER_TRAMPOLINE:
953         /*
954          * This is the means by which we step over our conversion stubs
955          * in callfrom*.s and callto*.s.  We dig the appropriate address
956          * off the stack, and we set the breakpoint there instead of the
957          * address just after the call.
958          */
959         be_cpu->get_addr(dbg_curr_thread->handle, &dbg_context,
960                          be_cpu_addr_stack, &addr);
961         /* FIXME: we assume stack grows as on an i386 */
962         addr.Offset += 2 * sizeof(unsigned int);
963         dbg_read_memory(memory_to_linear_addr(&addr),
964                         &addr.Offset, sizeof(addr.Offset));
965         dbg_curr_process->bp[0].addr = addr;
966         dbg_curr_process->bp[0].enabled = TRUE;
967         dbg_curr_process->bp[0].refcount = 1;
968         dbg_curr_process->bp[0].skipcount = 0;
969         dbg_curr_process->bp[0].xpoint_type = be_xpoint_break;
970         dbg_curr_process->bp[0].condition = NULL;
971         be_cpu->single_step(&dbg_context, FALSE);
972         break_set_xpoints(TRUE);
973         break;
974 #endif
975
976     case dbg_exec_finish:
977     case dbg_exec_step_over_insn:  /* Stepping over a call */
978     case dbg_exec_step_over_line:  /* Stepping over a call */
979         if (be_cpu->is_step_over_insn(linear))
980         {
981             be_cpu->disasm_one_insn(&addr, FALSE);
982             dbg_curr_process->bp[0].addr = addr;
983             dbg_curr_process->bp[0].enabled = TRUE;
984             dbg_curr_process->bp[0].refcount = 1;
985             dbg_curr_process->bp[0].skipcount = 0;
986             dbg_curr_process->bp[0].xpoint_type = be_xpoint_break;
987             dbg_curr_process->bp[0].condition = NULL;
988             be_cpu->single_step(&dbg_context, FALSE);
989             break_set_xpoints(TRUE);
990             break;
991         }
992         /* else fall through to single-stepping */
993
994     case dbg_exec_step_into_line: /* Single-stepping a line */
995     case dbg_exec_step_into_insn: /* Single-stepping an instruction */
996         be_cpu->single_step(&dbg_context, TRUE);
997         break;
998     default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
999     }
1000     dbg_curr_thread->step_over_bp = dbg_curr_process->bp[0];
1001     dbg_curr_thread->exec_mode = ret_mode;
1002 }
1003
1004 int break_add_condition(int num, struct expr* exp)
1005 {
1006     if (num <= 0 || num >= dbg_curr_process->next_bp || 
1007         !dbg_curr_process->bp[num].refcount)
1008     {
1009         dbg_printf("Invalid breakpoint number %d\n", num);
1010         return FALSE;
1011     }
1012
1013     if (dbg_curr_process->bp[num].condition != NULL)
1014     {
1015         expr_free(dbg_curr_process->bp[num].condition);
1016         dbg_curr_process->bp[num].condition = NULL;
1017     }
1018
1019     if (exp != NULL) dbg_curr_process->bp[num].condition = expr_clone(exp, NULL);
1020
1021     return TRUE;
1022 }