git.oblomov.eu Git - wine/blob - 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 != 0;
 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 }