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 = (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 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, 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 ADDRESS64* 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     ADDRESS64   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     ADDRESS64   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_PTR       linear = (DWORD_PTR)memory_to_linear_addr(&bkln.addr);
 307
 308         il.SizeOfStruct = sizeof(il);
 309         if (!SymGetLineFromAddr(dbg_curr_process->handle, linear, &disp, &il))
 310         {
 311             dbg_printf("Unable to add breakpoint (unknown address %lx)\n", linear);
 312             return;
 313         }
 314         bkln.addr.Offset = 0;
 315         bkln.lineno = lineno;
 316         SymEnumLines(dbg_curr_process->handle, linear, NULL, il.FileName, line_cb, &bkln);
 317         if (!bkln.addr.Offset)
 318         {
 319             dbg_printf("Unknown line number\n"
 320                        "(either out of file, or no code at given line number)\n");
 321             return;
 322         }
 323     }
 324
 325     break_add_break(&bkln.addr, TRUE, swbp);
 326 }
 327
 328 /***********************************************************************
 329  *           break_check_delayed_bp
 330  *
 331  * Check is a registered delayed BP is now available.
 332  */
 333 void break_check_delayed_bp(void)
 334 {
 335     struct dbg_lvalue           lvalue;
 336     int                         i;
 337     struct dbg_delayed_bp*      dbp = dbg_curr_process->delayed_bp;
 338     char                        hexbuf[MAX_OFFSET_TO_STR_LEN];
 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:%s\n",
 354                        dbp[i].u.addr.Segment,
 355                        memory_offset_to_string(hexbuf, dbp[i].u.addr.Offset, 0));
 356         else
 357             WINE_TRACE("\t'%s' @ %d\n",
 358                        dbp[i].u.symbol.name, dbp[i].u.symbol.lineno);
 359
 360         if (break_add_break(&lvalue.addr, FALSE, dbp[i].software_bp))
 361             memmove(&dbp[i], &dbp[i+1], (--dbg_curr_process->num_delayed_bp - i) * sizeof(*dbp));
 362     }
 363 }
 364
 365 /***********************************************************************
 366  *           break_add_watch
 367  *
 368  * Add a watchpoint.
 369  */
 370 static void break_add_watch(const struct dbg_lvalue* lvalue, BOOL is_write)
 371 {
 372     int         num;
 373     DWORD64     l = 4;
 374
 375     num = init_xpoint((is_write) ? be_xpoint_watch_write : be_xpoint_watch_read,
 376                       &lvalue->addr);
 377     if (num == -1) return;
 378
 379     if (lvalue->type.id != dbg_itype_none)
 380     {
 381         if (types_get_info(&lvalue->type, TI_GET_LENGTH, &l))
 382         {
 383             switch (l)
 384             {
 385             case 4: case 2: case 1: break;
 386             default:
 387                 dbg_printf("Unsupported length (%s) for watch-points, defaulting to 4\n",
 388                            wine_dbgstr_longlong(l));
 389                 break;
 390             }
 391         }
 392         else dbg_printf("Cannot get watch size, defaulting to 4\n");
 393     }
 394     dbg_curr_process->bp[num].w.len = (DWORD)l - 1;
 395
 396     if (!get_watched_value(num, &dbg_curr_process->bp[num].w.oldval))
 397     {
 398         dbg_printf("Bad address. Watchpoint not set\n");
 399         dbg_curr_process->bp[num].refcount = 0;
 400         return;
 401     }
 402     dbg_printf("Watchpoint %d at ", num);
 403     print_address(&dbg_curr_process->bp[num].addr, TRUE);
 404     dbg_printf("\n");
 405 }
 406
 407 /******************************************************************
 408  *              break_add_watch_from_lvalue
 409  *
 410  * Adds a watch point from an address (stored in a lvalue)
 411  */
 412 void break_add_watch_from_lvalue(const struct dbg_lvalue* lvalue)
 413 {
 414     struct dbg_lvalue   lval;
 415
 416     types_extract_as_address(lvalue, &lval.addr);
 417     lval.type.id = dbg_itype_none;
 418
 419     break_add_watch(&lval, TRUE);
 420 }
 421
 422 /***********************************************************************
 423  *           break_add_watch_from_id
 424  *
 425  * Add a watchpoint from a symbol name
 426  */
 427 void    break_add_watch_from_id(const char *name)
 428 {
 429     struct dbg_lvalue    lvalue;
 430
 431     switch (symbol_get_lvalue(name, -1, &lvalue, TRUE))
 432     {
 433     case sglv_found:
 434         break_add_watch(&lvalue, 1);
 435         break;
 436     case sglv_unknown:
 437         dbg_printf("Unable to add watchpoint\n");
 438         break;
 439     case sglv_aborted: /* user aborted symbol lookup */
 440         break;
 441     }
 442 }
 443
 444 /***********************************************************************
 445  *           break_delete_xpoint
 446  *
 447  * Delete a breakpoint.
 448  */
 449 void break_delete_xpoint(int num)
 450 {
 451     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
 452
 453     if ((num <= 0) || (num >= dbg_curr_process->next_bp) ||
 454         bp[num].refcount == 0)
 455     {
 456         dbg_printf("Invalid breakpoint number %d\n", num);
 457         return;
 458     }
 459
 460     if (--bp[num].refcount > 0)
 461         return;
 462
 463     if (bp[num].condition != NULL)
 464     {
 465         expr_free(bp[num].condition);
 466         bp[num].condition = NULL;
 467     }
 468
 469     bp[num].enabled = FALSE;
 470     bp[num].refcount = 0;
 471     bp[num].skipcount = 0;
 472 }
 473
 474 static inline BOOL module_is_container(const IMAGEHLP_MODULE* wmod_cntnr,
 475                                      const IMAGEHLP_MODULE* wmod_child)
 476 {
 477     return wmod_cntnr->BaseOfImage <= wmod_child->BaseOfImage &&
 478         wmod_cntnr->BaseOfImage + wmod_cntnr->ImageSize >=
 479         wmod_child->BaseOfImage + wmod_child->ImageSize;
 480 }
 481
 482 /******************************************************************
 483  *              break_delete_xpoints_from_module
 484  *
 485  * Remove all Xpoints from module which base is 'base'
 486  */
 487 void break_delete_xpoints_from_module(unsigned long base)
 488 {
 489     IMAGEHLP_MODULE             im, im_elf;
 490     int                         i;
 491     DWORD_PTR                   linear;
 492     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
 493
 494     /* FIXME: should do it also on the ELF sibbling if any */
 495     im.SizeOfStruct = sizeof(im);
 496     im_elf.SizeOfStruct = sizeof(im_elf);
 497     if (!SymGetModuleInfo(dbg_curr_process->handle, base, &im)) return;
 498
 499     /* try to get in fact the underlying ELF module (if any) */
 500     if (SymGetModuleInfo(dbg_curr_process->handle, im.BaseOfImage - 1, &im_elf) &&
 501         im_elf.BaseOfImage <= im.BaseOfImage &&
 502         im_elf.BaseOfImage + im_elf.ImageSize >= im.BaseOfImage + im.ImageSize)
 503         im = im_elf;
 504
 505     for (i = 0; i < dbg_curr_process->next_bp; i++)
 506     {
 507         linear = (DWORD_PTR)memory_to_linear_addr(&bp[i].addr);
 508         if (bp[i].refcount && bp[i].enabled &&
 509             im.BaseOfImage <= linear && linear < im.BaseOfImage + im.ImageSize)
 510         {
 511             break_delete_xpoint(i);
 512         }
 513     }
 514 }
 515
 516 /***********************************************************************
 517  *           break_enable_xpoint
 518  *
 519  * Enable or disable a break point.
 520  */
 521 void break_enable_xpoint(int num, BOOL enable)
 522 {
 523     if ((num <= 0) || (num >= dbg_curr_process->next_bp) ||
 524         dbg_curr_process->bp[num].refcount == 0)
 525     {
 526         dbg_printf("Invalid breakpoint number %d\n", num);
 527         return;
 528     }
 529     dbg_curr_process->bp[num].enabled = (enable) ? TRUE : FALSE;
 530     dbg_curr_process->bp[num].skipcount = 0;
 531 }
 532
 533
 534 /***********************************************************************
 535  *           find_triggered_watch
 536  *
 537  * Lookup the watchpoints to see if one has been triggered
 538  * Return >= (watch point index) if one is found and *oldval is set to
 539  *      the value watched before the TRAP
 540  * Return -1 if none found (*oldval is undetermined)
 541  *
 542  * Unfortunately, Linux does *NOT* (A REAL PITA) report with ptrace
 543  * the DR6 register value, so we have to look with our own need the
 544  * cause of the TRAP.
 545  * -EP
 546  */
 547 static int find_triggered_watch(LPDWORD oldval)
 548 {
 549     int                         found = -1;
 550     int                         i;
 551     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
 552
 553     /* Method 1 => get triggered watchpoint from context (doesn't work on Linux
 554      * 2.2.x). This should be fixed in >= 2.2.16
 555      */
 556     for (i = 0; i < dbg_curr_process->next_bp; i++)
 557     {
 558         DWORD val = 0;
 559
 560         if (bp[i].refcount && bp[i].enabled && !is_xpoint_break(i) &&
 561             (be_cpu->is_watchpoint_set(&dbg_context, bp[i].info)))
 562         {
 563             be_cpu->clear_watchpoint(&dbg_context, bp[i].info);
 564
 565             *oldval = bp[i].w.oldval;
 566             if (get_watched_value(i, &val))
 567             {
 568                 bp[i].w.oldval = val;
 569                 return i;
 570             }
 571         }
 572     }
 573
 574     /* Method 1 failed, trying method 2 */
 575
 576     /* Method 2 => check if value has changed among registered watchpoints
 577      * this really sucks, but this is how gdb 4.18 works on my linux box
 578      * -EP
 579      */
 580     for (i = 0; i < dbg_curr_process->next_bp; i++)
 581     {
 582         DWORD val = 0;
 583
 584         if (bp[i].refcount && bp[i].enabled && !is_xpoint_break(i) &&
 585             get_watched_value(i, &val))
 586         {
 587             *oldval = bp[i].w.oldval;
 588             if (val != *oldval)
 589             {
 590                 be_cpu->clear_watchpoint(&dbg_context, bp[i].info);
 591                 bp[i].w.oldval = val;
 592                 found = i;
 593                 /* cannot break, because two watch points may have been triggered on
 594                  * the same access
 595                  * only one will be reported to the user (FIXME ?)
 596                  */
 597             }
 598         }
 599     }
 600     return found;
 601 }
 602
 603 /***********************************************************************
 604  *           break_info
 605  *
 606  * Display break & watch points information.
 607  */
 608 void break_info(void)
 609 {
 610     int                         i;
 611     int                         nbp = 0, nwp = 0;
 612     struct dbg_delayed_bp*      dbp = dbg_curr_process->delayed_bp;
 613     struct dbg_breakpoint*      bp = dbg_curr_process->bp;
 614
 615     for (i = 1; i < dbg_curr_process->next_bp; i++)
 616     {
 617         if (bp[i].refcount)
 618         {
 619             if (is_xpoint_break(i)) nbp++; else nwp++;
 620         }
 621     }
 622
 623     if (nbp)
 624     {
 625         dbg_printf("Breakpoints:\n");
 626         for (i = 1; i < dbg_curr_process->next_bp; i++)
 627         {
 628             if (!bp[i].refcount || !is_xpoint_break(i))
 629                 continue;
 630             dbg_printf("%d: %c ", i, bp[i].enabled ? 'y' : 'n');
 631             print_address(&bp[i].addr, TRUE);
 632             dbg_printf(" (%u)%s\n", bp[i].refcount,
 633                        bp[i].xpoint_type == be_xpoint_watch_exec ? " (hardware assisted)" : "");
 634             if (bp[i].condition != NULL)
 635             {
 636                 dbg_printf("\t\tstop when  ");
 637                 expr_print(bp[i].condition);
 638                 dbg_printf("\n");
 639             }
 640         }
 641     }
 642     else dbg_printf("No breakpoints\n");
 643     if (nwp)
 644     {
 645         dbg_printf("Watchpoints:\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(" on %d byte%s (%c)\n",
 653                        bp[i].w.len + 1, bp[i].w.len > 0 ? "s" : "",
 654                        bp[i].xpoint_type == be_xpoint_watch_write ? 'W' : 'R');
 655             if (bp[i].condition != NULL)
 656             {
 657                 dbg_printf("\t\tstop when ");
 658                 expr_print(bp[i].condition);
 659                 dbg_printf("\n");
 660             }
 661         }
 662     }
 663     else dbg_printf("No watchpoints\n");
 664     if (dbg_curr_process->num_delayed_bp)
 665     {
 666         dbg_printf("Delayed breakpoints:\n");
 667         for (i = 0; i < dbg_curr_process->num_delayed_bp; i++)
 668         {
 669             if (dbp[i].is_symbol)
 670             {
 671                 dbg_printf("%d: %s", i, dbp[i].u.symbol.name);
 672                 if (dbp[i].u.symbol.lineno != -1)
 673                     dbg_printf(" at line %u", dbp[i].u.symbol.lineno);
 674             }
 675             else
 676             {
 677                 dbg_printf("%d: ", i);
 678                 print_address(&dbp[i].u.addr, FALSE);
 679             }
 680             dbg_printf("\n");
 681         }
 682     }
 683 }
 684
 685 /***********************************************************************
 686  *           should_stop
 687  *
 688  * Check whether or not the condition (bp / skipcount) of a break/watch
 689  * point are met.
 690  */
 691 static  BOOL should_stop(int bpnum)
 692 {
 693     struct dbg_breakpoint*      bp = &dbg_curr_process->bp[bpnum];
 694
 695     if (bp->condition != NULL)
 696     {
 697         struct dbg_lvalue lvalue = expr_eval(bp->condition);
 698
 699         if (lvalue.type.id == dbg_itype_none)
 700         {
 701             /*
 702              * Something wrong - unable to evaluate this expression.
 703              */
 704             dbg_printf("Unable to evaluate expression ");
 705             expr_print(bp->condition);
 706             dbg_printf("\nTurning off condition\n");
 707             break_add_condition(bpnum, NULL);
 708         }
 709         else if (!types_extract_as_integer(&lvalue))
 710         {
 711             return FALSE;
 712         }
 713     }
 714
 715     if (bp->skipcount > 0) bp->skipcount--;
 716     return bp->skipcount == 0;
 717 }
 718
 719 /***********************************************************************
 720  *           break_should_continue
 721  *
 722  * Determine if we should continue execution after a SIGTRAP signal when
 723  * executing in the given mode.
 724  */
 725 BOOL break_should_continue(ADDRESS64* addr, DWORD code)
 726 {
 727     enum dbg_exec_mode  mode = dbg_curr_thread->exec_mode;
 728
 729
 730     if (dbg_curr_thread->stopped_xpoint > 0)
 731     {
 732         if (!should_stop(dbg_curr_thread->stopped_xpoint)) return TRUE;
 733
 734         switch (dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].xpoint_type)
 735         {
 736         case be_xpoint_break:
 737         case be_xpoint_watch_exec:
 738             dbg_printf("Stopped on breakpoint %d at ", dbg_curr_thread->stopped_xpoint);
 739             print_address(&dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].addr, TRUE);
 740             dbg_printf("\n");
 741             break;
 742         case be_xpoint_watch_read:
 743         case be_xpoint_watch_write:
 744             dbg_printf("Stopped on watchpoint %d at ", dbg_curr_thread->stopped_xpoint);
 745             print_address(addr, TRUE);
 746             dbg_printf(" new value %u\n",
 747                        dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].w.oldval);
 748         }
 749         return FALSE;
 750     }
 751
 752     /*
 753      * If our mode indicates that we are stepping line numbers,
 754      * get the current function, and figure out if we are exactly
 755      * on a line number or not.
 756      */
 757     if (mode == dbg_exec_step_over_line || mode == dbg_exec_step_into_line)
 758     {
 759         if (symbol_get_function_line_status(addr) == dbg_on_a_line_number)
 760             dbg_curr_thread->exec_count--;
 761     }
 762     else if (mode == dbg_exec_step_over_insn || mode == dbg_exec_step_into_insn)
 763         dbg_curr_thread->exec_count--;
 764
 765     if (dbg_curr_thread->exec_count > 0 || mode == dbg_exec_finish)
 766     {
 767         /*
 768          * We still need to execute more instructions.
 769          */
 770         return TRUE;
 771     }
 772
 773     /* no breakpoint, continue if in continuous mode */
 774     return mode == dbg_exec_cont || mode == dbg_exec_finish;
 775 }
 776
 777 /***********************************************************************
 778  *           break_adjust_pc
 779  *
 780  * Adjust PC to the address where the trap (if any) actually occurred
 781  * Also sets dbg_curr_thread->stopped_xpoint
 782  */
 783 void break_adjust_pc(ADDRESS64* addr, DWORD code, BOOL first_chance, BOOL* is_break)
 784 {
 785     DWORD               oldval = 0;
 786
 787     /* break / watch points are handled on first chance */
 788     if ( !first_chance )
 789     {
 790         *is_break = TRUE;
 791         dbg_curr_thread->stopped_xpoint = -1;
 792         return;
 793     }
 794     *is_break = FALSE;
 795
 796     /* If not single-stepping, back up to the break instruction */
 797     if (code == EXCEPTION_BREAKPOINT)
 798         addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, TRUE);
 799
 800     dbg_curr_thread->stopped_xpoint = find_xpoint(addr, be_xpoint_break);
 801     dbg_curr_process->bp[0].enabled = FALSE;  /* disable the step-over breakpoint */
 802
 803     if (dbg_curr_thread->stopped_xpoint > 0) return;
 804
 805     if (dbg_curr_thread->stopped_xpoint < 0)
 806     {
 807         dbg_curr_thread->stopped_xpoint = find_xpoint(addr, be_xpoint_watch_exec);
 808         if (dbg_curr_thread->stopped_xpoint < 0)
 809             dbg_curr_thread->stopped_xpoint = find_triggered_watch(&oldval);
 810         if (dbg_curr_thread->stopped_xpoint > 0)
 811         {
 812             /* If not single-stepping, do not back up over the break instruction */
 813             if (code == EXCEPTION_BREAKPOINT)
 814                 addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, FALSE);
 815             return;
 816         }
 817     }
 818
 819     /* If there's no breakpoint and we are not single-stepping, then
 820      * either we must have encountered a break insn in the Windows program
 821      * or someone is trying to stop us
 822      */
 823     if (dbg_curr_thread->stopped_xpoint == -1 && code == EXCEPTION_BREAKPOINT)
 824     {
 825         *is_break = TRUE;
 826         addr->Offset += be_cpu->adjust_pc_for_break(&dbg_context, FALSE);
 827     }
 828 }
 829
 830 /***********************************************************************
 831  *           break_suspend_execution
 832  *
 833  * Remove all bp before entering the debug loop
 834  */
 835 void    break_suspend_execution(void)
 836 {
 837     break_set_xpoints(FALSE);
 838     dbg_curr_process->bp[0] = dbg_curr_thread->step_over_bp;
 839 }
 840
 841 /***********************************************************************
 842  *           break_restart_execution
 843  *
 844  * Set the bp to the correct state to restart execution
 845  * in the given mode.
 846  */
 847 void break_restart_execution(int count)
 848 {
 849     ADDRESS64                   addr;
 850     enum dbg_line_status        status;
 851     enum dbg_exec_mode          mode, ret_mode;
 852     ADDRESS64                   callee;
 853     void*                       linear;
 854
 855     memory_get_current_pc(&addr);
 856     linear = memory_to_linear_addr(&addr);
 857
 858     /*
 859      * This is the mode we will be running in after we finish.  We would like
 860      * to be able to modify this in certain cases.
 861      */
 862     ret_mode = mode = dbg_curr_thread->exec_mode;
 863
 864     /* we've stopped on a xpoint (other than step over) */
 865     if (dbg_curr_thread->stopped_xpoint > 0)
 866     {
 867         /*
 868          * If we have set a new value, then save it in the BP number.
 869          */
 870         if (count != 0 && mode == dbg_exec_cont)
 871         {
 872             dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].skipcount = count;
 873         }
 874         /* If we've stopped on a breakpoint, single step over it (, then run) */
 875         if (is_xpoint_break(dbg_curr_thread->stopped_xpoint))
 876             mode = dbg_exec_step_into_insn;
 877     }
 878     else if (mode == dbg_exec_cont && count > 1)
 879     {
 880         dbg_printf("Not stopped at any breakpoint; argument ignored.\n");
 881     }
 882
 883     if (mode == dbg_exec_finish && be_cpu->is_function_return(linear))
 884     {
 885         mode = ret_mode = dbg_exec_step_into_insn;
 886     }
 887
 888     /*
 889      * See if the function we are stepping into has debug info
 890      * and line numbers.  If not, then we step over it instead.
 891      * FIXME - we need to check for things like thunks or trampolines,
 892      * as the actual function may in fact have debug info.
 893      */
 894     if (be_cpu->is_function_call(linear, &callee))
 895     {
 896         status = symbol_get_function_line_status(&callee);
 897 #if 0
 898         /* FIXME: we need to get the thunk type */
 899         /*
 900          * Anytime we have a trampoline, step over it.
 901          */
 902         if ((mode == EXEC_STEP_OVER || mode == EXEC_STEPI_OVER)
 903             && status == dbg_in_a_thunk)
 904         {
 905             WINE_WARN("Not stepping into trampoline at %p (no lines)\n",
 906                       memory_to_linear_addr(&callee));
 907             mode = EXEC_STEP_OVER_TRAMPOLINE;
 908         }
 909 #endif
 910         if (mode == dbg_exec_step_into_line && status == dbg_no_line_info)
 911         {
 912             WINE_WARN("Not stepping into function at %p (no lines)\n",
 913                       memory_to_linear_addr(&callee));
 914             mode = dbg_exec_step_over_line;
 915         }
 916     }
 917
 918     if (mode == dbg_exec_step_into_line &&
 919         symbol_get_function_line_status(&addr) == dbg_no_line_info)
 920     {
 921         dbg_printf("Single stepping until exit from function,\n"
 922                    "which has no line number information.\n");
 923         ret_mode = mode = dbg_exec_finish;
 924     }
 925
 926     switch (mode)
 927     {
 928     case dbg_exec_cont: /* Continuous execution */
 929         be_cpu->single_step(&dbg_context, FALSE);
 930         break_set_xpoints(TRUE);
 931         break;
 932
 933 #if 0
 934     case EXEC_STEP_OVER_TRAMPOLINE:
 935         /*
 936          * This is the means by which we step over our conversion stubs
 937          * in callfrom*.s and callto*.s.  We dig the appropriate address
 938          * off the stack, and we set the breakpoint there instead of the
 939          * address just after the call.
 940          */
 941         be_cpu->get_addr(dbg_curr_thread->handle, &dbg_context,
 942                          be_cpu_addr_stack, &addr);
 943         /* FIXME: we assume stack grows as on an i386 */
 944         addr.Offset += 2 * sizeof(unsigned int);
 945         dbg_read_memory(memory_to_linear_addr(&addr),
 946                         &addr.Offset, sizeof(addr.Offset));
 947         dbg_curr_process->bp[0].addr = addr;
 948         dbg_curr_process->bp[0].enabled = TRUE;
 949         dbg_curr_process->bp[0].refcount = 1;
 950         dbg_curr_process->bp[0].skipcount = 0;
 951         dbg_curr_process->bp[0].xpoint_type = be_xpoint_break;
 952         dbg_curr_process->bp[0].condition = NULL;
 953         be_cpu->single_step(&dbg_context, FALSE);
 954         break_set_xpoints(TRUE);
 955         break;
 956 #endif
 957
 958     case dbg_exec_finish:
 959     case dbg_exec_step_over_insn:  /* Stepping over a call */
 960     case dbg_exec_step_over_line:  /* Stepping over a call */
 961         if (be_cpu->is_step_over_insn(linear))
 962         {
 963             be_cpu->disasm_one_insn(&addr, FALSE);
 964             dbg_curr_process->bp[0].addr = addr;
 965             dbg_curr_process->bp[0].enabled = TRUE;
 966             dbg_curr_process->bp[0].refcount = 1;
 967             dbg_curr_process->bp[0].skipcount = 0;
 968             dbg_curr_process->bp[0].xpoint_type = be_xpoint_break;
 969             dbg_curr_process->bp[0].condition = NULL;
 970             be_cpu->single_step(&dbg_context, FALSE);
 971             break_set_xpoints(TRUE);
 972             break;
 973         }
 974         /* else fall through to single-stepping */
 975
 976     case dbg_exec_step_into_line: /* Single-stepping a line */
 977     case dbg_exec_step_into_insn: /* Single-stepping an instruction */
 978         be_cpu->single_step(&dbg_context, TRUE);
 979         break;
 980     default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
 981     }
 982     dbg_curr_thread->step_over_bp = dbg_curr_process->bp[0];
 983     dbg_curr_thread->exec_mode = ret_mode;
 984 }
 985
 986 int break_add_condition(int num, struct expr* exp)
 987 {
 988     if (num <= 0 || num >= dbg_curr_process->next_bp ||
 989         !dbg_curr_process->bp[num].refcount)
 990     {
 991         dbg_printf("Invalid breakpoint number %d\n", num);
 992         return FALSE;
 993     }
 994
 995     if (dbg_curr_process->bp[num].condition != NULL)
 996     {
 997         expr_free(dbg_curr_process->bp[num].condition);
 998         dbg_curr_process->bp[num].condition = NULL;
 999     }
1000
1001     if (exp != NULL) dbg_curr_process->bp[num].condition = expr_clone(exp, NULL);
1002
1003     return TRUE;
1004 }