debugger/break.c

   1 /*
   2  * Debugger break-points handling
   3  *
   4  * Copyright 1994 Martin von Loewis
   5  * Copyright 1995 Alexandre Julliard
   6  * Copyright 1999,2000 Eric Pouech
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24 #include "debugger.h"
  25
  26 #ifdef __i386__
  27 #define DR7_CONTROL_SHIFT       16
  28 #define DR7_CONTROL_SIZE        4
  29
  30 #define DR7_RW_EXECUTE          (0x0)
  31 #define DR7_RW_WRITE            (0x1)
  32 #define DR7_RW_READ             (0x3)
  33
  34 #define DR7_LEN_1               (0x0)
  35 #define DR7_LEN_2               (0x4)
  36 #define DR7_LEN_4               (0xC)
  37
  38 #define DR7_LOCAL_ENABLE_SHIFT  0
  39 #define DR7_GLOBAL_ENABLE_SHIFT 1
  40 #define DR7_ENABLE_SIZE         2
  41
  42 #define DR7_LOCAL_ENABLE_MASK   (0x55)
  43 #define DR7_GLOBAL_ENABLE_MASK  (0xAA)
  44
  45 #define DR7_CONTROL_RESERVED    (0xFC00)
  46 #define DR7_LOCAL_SLOWDOWN      (0x100)
  47 #define DR7_GLOBAL_SLOWDOWN     (0x200)
  48
  49 #define DR7_ENABLE_MASK(dr)     (1<<(DR7_LOCAL_ENABLE_SHIFT+DR7_ENABLE_SIZE*(dr)))
  50 #define IS_DR7_SET(ctrl,dr)     ((ctrl)&DR7_ENABLE_MASK(dr))
  51 #define INT3          0xcc   /* int 3 opcode */
  52 #endif
  53
  54 #define MAX_BREAKPOINTS 100
  55
  56 static DBG_BREAKPOINT breakpoints[MAX_BREAKPOINTS];
  57
  58 static int next_bp = 1;  /* breakpoint 0 is reserved for step-over */
  59
  60 /***********************************************************************
  61  *           DEBUG_IsStepOverInstr
  62  *
  63  * Determine if the instruction at CS:EIP is an instruction that
  64  * we need to step over (like a call or a repetitive string move).
  65  */
  66 static BOOL DEBUG_IsStepOverInstr(void)
  67 {
  68 #ifdef __i386__
  69     BYTE*       instr;
  70     BYTE        ch;
  71     DBG_ADDR    addr;
  72
  73     addr.seg = DEBUG_context.SegCs;
  74     addr.off = DEBUG_context.Eip;
  75     /* FIXME: old code was using V86BASE(DEBUG_context)
  76      * instead of passing through DOSMEM_MemoryBase
  77      */
  78     instr = (BYTE*)DEBUG_ToLinear(&addr);
  79
  80     for (;;)
  81     {
  82         if (!DEBUG_READ_MEM(instr, &ch, sizeof(ch)))
  83             return FALSE;
  84
  85         switch (ch)
  86         {
  87           /* Skip all prefixes */
  88
  89         case 0x2e:  /* cs: */
  90         case 0x36:  /* ss: */
  91         case 0x3e:  /* ds: */
  92         case 0x26:  /* es: */
  93         case 0x64:  /* fs: */
  94         case 0x65:  /* gs: */
  95         case 0x66:  /* opcode size prefix */
  96         case 0x67:  /* addr size prefix */
  97         case 0xf0:  /* lock */
  98         case 0xf2:  /* repne */
  99         case 0xf3:  /* repe */
 100             instr++;
 101             continue;
 102
 103           /* Handle call instructions */
 104
 105         case 0xcd:  /* int <intno> */
 106         case 0xe8:  /* call <offset> */
 107         case 0x9a:  /* lcall <seg>:<off> */
 108             return TRUE;
 109
 110         case 0xff:  /* call <regmodrm> */
 111             if (!DEBUG_READ_MEM(instr + 1, &ch, sizeof(ch)))
 112                 return FALSE;
 113             return (((ch & 0x38) == 0x10) || ((ch & 0x38) == 0x18));
 114
 115           /* Handle string instructions */
 116
 117         case 0x6c:  /* insb */
 118         case 0x6d:  /* insw */
 119         case 0x6e:  /* outsb */
 120         case 0x6f:  /* outsw */
 121         case 0xa4:  /* movsb */
 122         case 0xa5:  /* movsw */
 123         case 0xa6:  /* cmpsb */
 124         case 0xa7:  /* cmpsw */
 125         case 0xaa:  /* stosb */
 126         case 0xab:  /* stosw */
 127         case 0xac:  /* lodsb */
 128         case 0xad:  /* lodsw */
 129         case 0xae:  /* scasb */
 130         case 0xaf:  /* scasw */
 131             return TRUE;
 132
 133         default:
 134             return FALSE;
 135         }
 136     }
 137 #else
 138     return FALSE;
 139 #endif
 140 }
 141
 142
 143 /***********************************************************************
 144  *           DEBUG_IsFctReturn
 145  *
 146  * Determine if the instruction at CS:EIP is an instruction that
 147  * is a function return.
 148  */
 149 BOOL DEBUG_IsFctReturn(void)
 150 {
 151 #ifdef __i386__
 152     BYTE*       instr;
 153     BYTE        ch;
 154     DBG_ADDR    addr;
 155
 156     addr.seg = DEBUG_context.SegCs;
 157     addr.off = DEBUG_context.Eip;
 158     /* FIXME: old code was using V86BASE(DEBUG_context)
 159      * instead of passing through DOSMEM_MemoryBase
 160      */
 161     instr = (BYTE*)DEBUG_ToLinear(&addr);
 162
 163     if (!DEBUG_READ_MEM(instr, &ch, sizeof(ch)))
 164         return FALSE;
 165
 166     return (ch == 0xc2) || (ch == 0xc3);
 167 #else
 168     return FALSE;
 169 #endif
 170 }
 171
 172
 173 /***********************************************************************
 174  *           DEBUG_SetBreakpoints
 175  *
 176  * Set or remove all the breakpoints.
 177  */
 178 void DEBUG_SetBreakpoints( BOOL set )
 179 {
 180    int          i;
 181
 182 #ifdef __i386__
 183    DEBUG_context.Dr7 &= ~DR7_LOCAL_ENABLE_MASK;
 184 #endif
 185
 186    for (i = 0; i < next_bp; i++)
 187    {
 188       if (!(breakpoints[i].refcount && breakpoints[i].enabled))
 189          continue;
 190
 191       switch (breakpoints[i].type) {
 192       case DBG_BREAK:
 193          {
 194 #ifdef __i386__
 195             char ch = set ? INT3 : breakpoints[i].u.b.opcode;
 196
 197             if (!DEBUG_WRITE_MEM( (void*)DEBUG_ToLinear(&breakpoints[i].addr),
 198                                   &ch, sizeof(ch) ))
 199             {
 200                DEBUG_Printf(DBG_CHN_MESG, "Invalid address for breakpoint %d, disabling it\n", i);
 201                breakpoints[i].enabled = FALSE;
 202             }
 203 #endif
 204          }
 205          break;
 206       case DBG_WATCH:
 207          if (set)
 208          {
 209 #ifdef __i386__
 210             DWORD       bits;
 211             int         reg = breakpoints[i].u.w.reg;
 212             LPDWORD     lpdr = NULL;
 213
 214             switch (reg)
 215             {
 216                case 0: lpdr = &DEBUG_context.Dr0; break;
 217                case 1: lpdr = &DEBUG_context.Dr1; break;
 218                case 2: lpdr = &DEBUG_context.Dr2; break;
 219                case 3: lpdr = &DEBUG_context.Dr3; break;
 220                default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
 221             }
 222
 223             *lpdr = DEBUG_ToLinear(&breakpoints[i].addr);
 224             bits = (breakpoints[i].u.w.rw) ? DR7_RW_WRITE : DR7_RW_READ;
 225             switch (breakpoints[i].u.w.len + 1)
 226             {
 227                case 4: bits |= DR7_LEN_4;       break;
 228                case 2: bits |= DR7_LEN_2;       break;
 229                case 1: bits |= DR7_LEN_1;       break;
 230                default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
 231             }
 232
 233             DEBUG_context.Dr7 &= ~(0x0F << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg));
 234             DEBUG_context.Dr7 |= bits << (DR7_CONTROL_SHIFT + DR7_CONTROL_SIZE * reg);
 235             DEBUG_context.Dr7 |= DR7_ENABLE_MASK(reg) | DR7_LOCAL_SLOWDOWN;
 236 #endif
 237          }
 238          break;
 239       }
 240    }
 241 }
 242
 243 /***********************************************************************
 244  *           DEBUG_FindBreakpoint
 245  *
 246  * Find the breakpoint for a given address. Return the breakpoint
 247  * number or -1 if none.
 248  * If type is DBG_BREAKPOINT, addr is a complete addr
 249  * If type is DBG_WATCHPOINT, only addr.off is meaningful and contains
 250  * linear address
 251  */
 252 static int DEBUG_FindBreakpoint( const DBG_ADDR *addr, int type )
 253 {
 254    int i;
 255
 256    for (i = 0; i < next_bp; i++)
 257    {
 258       if (breakpoints[i].refcount && breakpoints[i].enabled &&
 259           breakpoints[i].type == type )
 260       {
 261          if ((type == DBG_BREAK &&
 262               breakpoints[i].addr.seg == addr->seg &&
 263               breakpoints[i].addr.off == addr->off) ||
 264              (type == DBG_WATCH &&
 265               DEBUG_ToLinear(&breakpoints[i].addr) == addr->off))
 266             return i;
 267       }
 268    }
 269    return -1;
 270 }
 271
 272 /***********************************************************************
 273  *           DEBUG_InitXPoint
 274  *
 275  * Find an empty slot in BP table to add a new break/watch point
 276  */
 277 static  int     DEBUG_InitXPoint(int type, DBG_ADDR* addr)
 278 {
 279    int  num;
 280
 281    for (num = (next_bp < MAX_BREAKPOINTS) ? next_bp++ : 1;
 282         num < MAX_BREAKPOINTS; num++)
 283    {
 284       if (breakpoints[num].refcount == 0)
 285       {
 286           breakpoints[num].refcount = 1;
 287           breakpoints[num].enabled = TRUE;
 288           breakpoints[num].type    = type;
 289           breakpoints[num].skipcount = 0;
 290           breakpoints[num].addr = *addr;
 291           switch (DEBUG_GetSelectorType( addr->seg ))
 292           {
 293           case MODE_32:
 294               breakpoints[num].is32 = 1;
 295               break;
 296           case MODE_VM86:
 297           case MODE_16:
 298               breakpoints[num].is32 = 0;
 299               break;
 300           default:
 301               RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
 302           }
 303           return num;
 304       }
 305    }
 306
 307    DEBUG_Printf( DBG_CHN_MESG, "Too many breakpoints. Please delete some.\n" );
 308    return -1;
 309 }
 310
 311 /***********************************************************************
 312  *           DEBUG_GetWatchedValue
 313  *
 314  * Returns the value watched by watch point 'num'.
 315  */
 316 static  BOOL    DEBUG_GetWatchedValue( int num, LPDWORD val )
 317 {
 318    BYTE         buf[4];
 319
 320    if (!DEBUG_READ_MEM((void*)DEBUG_ToLinear(&breakpoints[num].addr),
 321                        buf, breakpoints[num].u.w.len + 1))
 322       return FALSE;
 323
 324    switch (breakpoints[num].u.w.len + 1)
 325    {
 326       case 4:   *val = *(DWORD*)buf;    break;
 327       case 2:   *val = *(WORD*)buf;     break;
 328       case 1:   *val = *(BYTE*)buf;     break;
 329       default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
 330    }
 331    return TRUE;
 332 }
 333
 334 /***********************************************************************
 335  *           DEBUG_AddBreakpoint
 336  *
 337  * Add a breakpoint.
 338  */
 339 void DEBUG_AddBreakpoint( const DBG_VALUE *_value, BOOL (*func)(void) )
 340 {
 341     DBG_VALUE value = *_value;
 342     int num;
 343     BYTE ch;
 344
 345     if( value.type != NULL && value.type == DEBUG_GetBasicType(DT_BASIC_CONST_INT) )
 346     {
 347         /*
 348          * We know that we have the actual offset stored somewhere
 349          * else in 32-bit space.  Grab it, and we
 350          * should be all set.
 351          */
 352         unsigned int seg2 = value.addr.seg;
 353         value.addr.seg = 0;
 354         value.addr.off = DEBUG_GetExprValue(&value, NULL);
 355         value.addr.seg = seg2;
 356     }
 357
 358     if ((num = DEBUG_FindBreakpoint(&value.addr, DBG_BREAK)) >= 1)
 359     {
 360        breakpoints[num].refcount++;
 361        return;
 362     }
 363
 364     if (!DEBUG_READ_MEM_VERBOSE((void*)DEBUG_ToLinear( &value.addr ), &ch, sizeof(ch)))
 365     {
 366        DEBUG_Printf( DBG_CHN_MESG, "Invalid address, can't set breakpoint\n");
 367        return;
 368     }
 369
 370     if ((num = DEBUG_InitXPoint(DBG_BREAK, &value.addr)) == -1)
 371        return;
 372
 373     breakpoints[num].u.b.opcode = ch;
 374     breakpoints[num].u.b.func = func;
 375
 376     DEBUG_Printf( DBG_CHN_MESG, "Breakpoint %d at ", num );
 377     DEBUG_PrintAddress( &breakpoints[num].addr, breakpoints[num].is32 ? MODE_32 : MODE_16,
 378                         TRUE );
 379     DEBUG_Printf( DBG_CHN_MESG, "\n" );
 380 }
 381
 382 /***********************************************************************
 383  *           DEBUG_AddBreakpointFromId
 384  *
 385  * Add a breakpoint from a function name (and eventually a line #)
 386  */
 387 void    DEBUG_AddBreakpointFromId(const char *name, int lineno)
 388 {
 389    DBG_VALUE    value;
 390    int          i;
 391
 392    if (DEBUG_GetSymbolValue(name, lineno, &value, TRUE)) {
 393       DEBUG_AddBreakpoint(&value, NULL);
 394       return;
 395    }
 396
 397    DEBUG_Printf(DBG_CHN_MESG, "Unable to add breakpoint, will check again when a new DLL is loaded\n");
 398    for (i = 0; i < DEBUG_CurrProcess->num_delayed_bp; i++) {
 399       if (!strcmp(name, DEBUG_CurrProcess->delayed_bp[i].name) &&
 400           lineno == DEBUG_CurrProcess->delayed_bp[i].lineno) {
 401          return;
 402       }
 403    }
 404    DEBUG_CurrProcess->delayed_bp = DBG_realloc(DEBUG_CurrProcess->delayed_bp,
 405                                                sizeof(DBG_DELAYED_BP) * ++DEBUG_CurrProcess->num_delayed_bp);
 406
 407    DEBUG_CurrProcess->delayed_bp[DEBUG_CurrProcess->num_delayed_bp - 1].name = strcpy(DBG_alloc(strlen(name) + 1), name);
 408    DEBUG_CurrProcess->delayed_bp[DEBUG_CurrProcess->num_delayed_bp - 1].lineno = lineno;
 409 }
 410
 411 /***********************************************************************
 412  *           DEBUG_AddBreakpointFromLineno
 413  *
 414  * Add a breakpoint from a line number in current file
 415  */
 416 void    DEBUG_AddBreakpointFromLineno(int lineno)
 417 {
 418    DBG_VALUE                    value;
 419
 420    DEBUG_GetCurrentAddress(&value.addr);
 421
 422    if (lineno != -1) {
 423       struct name_hash* nh;
 424
 425       DEBUG_FindNearestSymbol(&value.addr, TRUE, &nh, 0, NULL);
 426       if (nh == NULL) {
 427          DEBUG_Printf(DBG_CHN_MESG, "Unable to add breakpoint\n");
 428          return;
 429       }
 430       DEBUG_GetLineNumberAddr(nh, lineno, &value.addr, TRUE);
 431    }
 432
 433    value.type = NULL;
 434    value.cookie = DV_TARGET;
 435    DEBUG_AddBreakpoint( &value, NULL );
 436 }
 437
 438 /***********************************************************************
 439  *           DEBUG_CheckDelayedBP
 440  *
 441  * Check is a registered delayed BP is now available.
 442  */
 443 void            DEBUG_CheckDelayedBP(void)
 444 {
 445    DBG_VALUE            value;
 446    int                  i = 0;
 447    DBG_DELAYED_BP*      dbp = DEBUG_CurrProcess->delayed_bp;
 448
 449    while (i < DEBUG_CurrProcess->num_delayed_bp) {
 450       if (DEBUG_GetSymbolValue(dbp[i].name, dbp[i].lineno, &value, TRUE)) {
 451          DEBUG_AddBreakpoint(&value, NULL);
 452          memmove(&dbp[i], &dbp[i+1], (--DEBUG_CurrProcess->num_delayed_bp - i) * sizeof(*dbp));
 453       } else {
 454          i++;
 455       }
 456    }
 457 }
 458
 459 /***********************************************************************
 460  *           DEBUG_AddWatchpoint
 461  *
 462  * Add a watchpoint.
 463  */
 464 void DEBUG_AddWatchpoint( const DBG_VALUE *_value, BOOL is_write )
 465 {
 466    DBG_VALUE    value = *_value;
 467    int          num, reg = -1;
 468    unsigned     seg2;
 469    DWORD        mask = 0;
 470
 471    assert(_value->cookie == DV_TARGET || _value->cookie == DV_HOST);
 472
 473 #ifdef __i386__
 474    DEBUG_FixAddress( &value.addr, DEBUG_context.SegCs );
 475 #endif
 476
 477    if ( value.type != NULL && value.type == DEBUG_GetBasicType(DT_BASIC_CONST_INT) )
 478    {
 479       /*
 480        * We know that we have the actual offset stored somewhere
 481        * else in 32-bit space.  Grab it, and we
 482        * should be all set.
 483        */
 484       seg2 = value.addr.seg;
 485       value.addr.seg = 0;
 486       value.addr.off = DEBUG_GetExprValue(&value, NULL);
 487       value.addr.seg = seg2;
 488    }
 489
 490    for (num = 1; num < next_bp; num++)
 491    {
 492       if (breakpoints[num].refcount && breakpoints[num].enabled &&
 493           breakpoints[num].type == DBG_WATCH) {
 494          mask |= (1 << breakpoints[num].u.w.reg);
 495       }
 496    }
 497 #ifdef __i386__
 498    for (reg = 0; reg < 4 && (mask & (1 << reg)); reg++);
 499    if (reg == 4)
 500    {
 501       DEBUG_Printf(DBG_CHN_MESG, "All i386 hardware watchpoints have been set. Delete some\n");
 502       return;
 503    }
 504 #endif
 505
 506    if ((num = DEBUG_InitXPoint(DBG_WATCH, &value.addr)) == -1)
 507       return;
 508
 509    breakpoints[num].u.w.len = 4 - 1;
 510    if (_value->type && DEBUG_GetObjectSize(_value->type) < 4)
 511       breakpoints[num].u.w.len = 2 - 1;
 512
 513    if (!DEBUG_GetWatchedValue( num, &breakpoints[num].u.w.oldval))
 514    {
 515       DEBUG_Printf(DBG_CHN_MESG, "Bad address. Watchpoint not set\n");
 516       breakpoints[num].refcount = 0;
 517    }
 518    else
 519    {
 520       breakpoints[num].u.w.rw = (is_write) ? TRUE : FALSE;
 521       breakpoints[reg].u.w.reg = reg;
 522
 523       DEBUG_Printf( DBG_CHN_MESG, "Watchpoint %d at ", num );
 524       DEBUG_PrintAddress( &breakpoints[num].addr, breakpoints[num].is32 ? MODE_32 : MODE_16, TRUE );
 525       DEBUG_Printf( DBG_CHN_MESG, "\n" );
 526    }
 527 }
 528
 529 /***********************************************************************
 530  *           DEBUG_AddWathpointFromId
 531  *
 532  * Add a watchpoint from a symbol name (and eventually a line #)
 533  */
 534 void    DEBUG_AddWatchpointFromId(const char *name)
 535 {
 536    DBG_VALUE value;
 537
 538    if( DEBUG_GetSymbolValue(name, -1, &value, TRUE) )
 539       DEBUG_AddWatchpoint( &value, 1 );
 540    else
 541       DEBUG_Printf(DBG_CHN_MESG, "Unable to add watchpoint\n");
 542 }
 543
 544 /***********************************************************************
 545  *           DEBUG_DelBreakpoint
 546  *
 547  * Delete a breakpoint.
 548  */
 549 void DEBUG_DelBreakpoint( int num )
 550 {
 551     if ((num <= 0) || (num >= next_bp) || breakpoints[num].refcount == 0)
 552     {
 553         DEBUG_Printf( DBG_CHN_MESG, "Invalid breakpoint number %d\n", num );
 554         return;
 555     }
 556
 557     if (--breakpoints[num].refcount > 0)
 558        return;
 559
 560     if( breakpoints[num].condition != NULL )
 561     {
 562        DEBUG_FreeExpr(breakpoints[num].condition);
 563        breakpoints[num].condition = NULL;
 564     }
 565
 566     breakpoints[num].enabled = FALSE;
 567     breakpoints[num].refcount = 0;
 568     breakpoints[num].skipcount = 0;
 569 }
 570
 571 /***********************************************************************
 572  *           DEBUG_EnableBreakpoint
 573  *
 574  * Enable or disable a break point.
 575  */
 576 void DEBUG_EnableBreakpoint( int num, BOOL enable )
 577 {
 578     if ((num <= 0) || (num >= next_bp) || breakpoints[num].refcount == 0)
 579     {
 580         DEBUG_Printf( DBG_CHN_MESG, "Invalid breakpoint number %d\n", num );
 581         return;
 582     }
 583     breakpoints[num].enabled = (enable) ? TRUE : FALSE;
 584     breakpoints[num].skipcount = 0;
 585 }
 586
 587
 588 /***********************************************************************
 589  *           DEBUG_FindTriggeredWatchpoint
 590  *
 591  * Lookup the watchpoints to see if one has been triggered
 592  * Return >= (watch point index) if one is found and *oldval is set to
 593  *      the value watched before the TRAP
 594  * Return -1 if none found (*oldval is undetermined)
 595  *
 596  * Unfortunately, Linux does *NOT* (A REAL PITA) report with ptrace
 597  * the DR6 register value, so we have to look with our own need the
 598  * cause of the TRAP.
 599  * -EP
 600  */
 601 static int DEBUG_FindTriggeredWatchpoint(LPDWORD oldval)
 602 {
 603    int                          found = -1;
 604 #ifdef __i386__
 605    int                          i;
 606
 607    /* Method 1 => get triggered watchpoint from context (doesn't work on Linux
 608     * 2.2.x). This should be fixed in >= 2.2.16
 609     */
 610    for (i = 0; i < next_bp; i++)
 611    {
 612       DWORD val = 0;
 613
 614       if (breakpoints[i].refcount && breakpoints[i].enabled &&
 615           breakpoints[i].type == DBG_WATCH &&
 616           (DEBUG_context.Dr6 & (1 << breakpoints[i].u.w.reg)))
 617       {
 618          DEBUG_context.Dr6 &= ~(1 << breakpoints[i].u.w.reg);
 619
 620          *oldval = breakpoints[i].u.w.oldval;
 621          if (DEBUG_GetWatchedValue(i, &val)) {
 622             breakpoints[i].u.w.oldval = val;
 623             return i;
 624          }
 625       }
 626    }
 627
 628    /* Method 1 failed, trying method 2 */
 629
 630    /* Method 2 => check if value has changed among registered watchpoints
 631     * this really sucks, but this is how gdb 4.18 works on my linux box
 632     * -EP
 633     */
 634    for (i = 0; i < next_bp; i++)
 635    {
 636       DWORD val = 0;
 637
 638       if (breakpoints[i].refcount && breakpoints[i].enabled &&
 639           breakpoints[i].type == DBG_WATCH &&
 640           DEBUG_GetWatchedValue(i, &val))
 641       {
 642          *oldval = breakpoints[i].u.w.oldval;
 643          if (val != *oldval)
 644          {
 645             DEBUG_context.Dr6 &= ~(1 << breakpoints[i].u.w.reg);
 646             breakpoints[i].u.w.oldval = val;
 647             found = i;
 648             /* cannot break, because two watch points may have been triggered on
 649              * the same access
 650              * only one will be reported to the user (FIXME ?)
 651              */
 652          }
 653       }
 654    }
 655 #endif
 656    return found;
 657 }
 658
 659 /***********************************************************************
 660  *           DEBUG_InfoBreakpoints
 661  *
 662  * Display break points information.
 663  */
 664 void DEBUG_InfoBreakpoints(void)
 665 {
 666     int i;
 667
 668     DEBUG_Printf( DBG_CHN_MESG, "Breakpoints:\n" );
 669     for (i = 1; i < next_bp; i++)
 670     {
 671         if (breakpoints[i].refcount && breakpoints[i].type == DBG_BREAK)
 672         {
 673             DEBUG_Printf( DBG_CHN_MESG, "%d: %c ", i, breakpoints[i].enabled ? 'y' : 'n');
 674             DEBUG_PrintAddress( &breakpoints[i].addr,
 675                                 breakpoints[i].is32 ? MODE_32 : MODE_16, TRUE);
 676             DEBUG_Printf( DBG_CHN_MESG, " (%u)\n", breakpoints[i].refcount );
 677             if( breakpoints[i].condition != NULL )
 678             {
 679                 DEBUG_Printf(DBG_CHN_MESG, "\t\tstop when  ");
 680                 DEBUG_DisplayExpr(breakpoints[i].condition);
 681                 DEBUG_Printf(DBG_CHN_MESG, "\n");
 682             }
 683         }
 684     }
 685     DEBUG_Printf( DBG_CHN_MESG, "Watchpoints:\n" );
 686     for (i = 1; i < next_bp; i++)
 687     {
 688         if (breakpoints[i].refcount && breakpoints[i].type == DBG_WATCH)
 689         {
 690             DEBUG_Printf( DBG_CHN_MESG, "%d: %c ", i, breakpoints[i].enabled ? 'y' : 'n');
 691             DEBUG_PrintAddress( &breakpoints[i].addr,
 692                                 breakpoints[i].is32 ? MODE_32 : MODE_16, TRUE);
 693             DEBUG_Printf( DBG_CHN_MESG, " on %d byte%s (%c)\n",
 694                      breakpoints[i].u.w.len + 1,
 695                      breakpoints[i].u.w.len > 0 ? "s" : "",
 696                      breakpoints[i].u.w.rw ? 'W' : 'R');
 697             if( breakpoints[i].condition != NULL )
 698             {
 699                 DEBUG_Printf(DBG_CHN_MESG, "\t\tstop when  ");
 700                 DEBUG_DisplayExpr(breakpoints[i].condition);
 701                 DEBUG_Printf(DBG_CHN_MESG, "\n");
 702             }
 703         }
 704     }
 705 }
 706
 707 /***********************************************************************
 708  *           DEBUG_ShallBreak
 709  *
 710  * Check whether or not the condition (bp / skipcount) of a break/watch
 711  * point are met.
 712  */
 713 static  BOOL DEBUG_ShallBreak( int bpnum )
 714 {
 715     if ( breakpoints[bpnum].condition != NULL )
 716     {
 717         DBG_VALUE value = DEBUG_EvalExpr(breakpoints[bpnum].condition);
 718
 719         if ( value.type == NULL )
 720         {
 721             /*
 722              * Something wrong - unable to evaluate this expression.
 723              */
 724             DEBUG_Printf(DBG_CHN_MESG, "Unable to evaluate expression ");
 725             DEBUG_DisplayExpr(breakpoints[bpnum].condition);
 726             DEBUG_Printf(DBG_CHN_MESG, "\nTurning off condition\n");
 727             DEBUG_AddBPCondition(bpnum, NULL);
 728         }
 729         else if( !DEBUG_GetExprValue( &value, NULL) )
 730         {
 731             return FALSE;
 732         }
 733     }
 734
 735     if ( breakpoints[bpnum].skipcount > 0 && --breakpoints[bpnum].skipcount > 0 )
 736         return FALSE;
 737
 738    if ((breakpoints[bpnum].type == DBG_BREAK) && breakpoints[bpnum].u.b.func)
 739        return breakpoints[bpnum].u.b.func();
 740    return TRUE;
 741 }
 742
 743 /***********************************************************************
 744  *           DEBUG_ShouldContinue
 745  *
 746  * Determine if we should continue execution after a SIGTRAP signal when
 747  * executing in the given mode.
 748  */
 749 BOOL DEBUG_ShouldContinue( DBG_ADDR *addr, DWORD code, int * count )
 750 {
 751     int                 bpnum;
 752     DWORD               oldval;
 753     int                 wpnum;
 754     enum dbg_mode       addr_mode;
 755     struct symbol_info  syminfo;
 756     enum exec_mode      mode = DEBUG_CurrThread->exec_mode;
 757
 758 #ifdef __i386__
 759     /* If not single-stepping, back up over the int3 instruction */
 760     if (code == EXCEPTION_BREAKPOINT)
 761     {
 762        DEBUG_context.Eip--;
 763        addr->off--;
 764     }
 765 #endif
 766
 767     bpnum = DEBUG_FindBreakpoint( addr, DBG_BREAK );
 768     breakpoints[0].enabled = FALSE;  /* disable the step-over breakpoint */
 769
 770     if ((bpnum != 0) && (bpnum != -1))
 771     {
 772         if (!DEBUG_ShallBreak(bpnum)) return TRUE;
 773
 774         DEBUG_Printf( DBG_CHN_MESG, "Stopped on breakpoint %d at ", bpnum );
 775         syminfo = DEBUG_PrintAddress( &breakpoints[bpnum].addr,
 776                                       breakpoints[bpnum].is32 ? MODE_32 : MODE_16, TRUE );
 777         DEBUG_Printf( DBG_CHN_MESG, "\n" );
 778
 779         if( syminfo.list.sourcefile != NULL )
 780             DEBUG_List(&syminfo.list, NULL, 0);
 781         return FALSE;
 782     }
 783
 784     wpnum = DEBUG_FindTriggeredWatchpoint(&oldval);
 785     if ((wpnum != 0) && (wpnum != -1))
 786     {
 787        /* If not single-stepping, do not back up over the int3 instruction */
 788        if (code == EXCEPTION_BREAKPOINT)
 789        {
 790 #ifdef __i386__
 791            DEBUG_context.Eip++;
 792            addr->off++;
 793 #endif
 794        }
 795        if (!DEBUG_ShallBreak(wpnum)) return TRUE;
 796
 797        addr_mode = DEBUG_GetSelectorType( addr->seg );
 798        DEBUG_Printf(DBG_CHN_MESG, "Stopped on watchpoint %d at ", wpnum);
 799        syminfo = DEBUG_PrintAddress( addr, addr_mode, TRUE );
 800
 801        DEBUG_Printf(DBG_CHN_MESG, " values: old=%lu new=%lu\n",
 802                     oldval, breakpoints[wpnum].u.w.oldval);
 803        if (syminfo.list.sourcefile != NULL)
 804           DEBUG_List(&syminfo.list, NULL, 0);
 805        return FALSE;
 806     }
 807
 808     /*
 809      * If our mode indicates that we are stepping line numbers,
 810      * get the current function, and figure out if we are exactly
 811      * on a line number or not.
 812      */
 813     if( mode == EXEC_STEP_OVER || mode == EXEC_STEP_INSTR )
 814     {
 815         if( DEBUG_CheckLinenoStatus(addr) == AT_LINENUMBER )
 816         {
 817             (*count)--;
 818         }
 819     }
 820     else if( mode == EXEC_STEPI_OVER || mode == EXEC_STEPI_INSTR )
 821     {
 822         (*count)--;
 823     }
 824
 825     if( *count > 0 || mode == EXEC_FINISH )
 826     {
 827         /*
 828          * We still need to execute more instructions.
 829          */
 830         return TRUE;
 831     }
 832
 833     /*
 834      * If we are about to stop, then print out the source line if we
 835      * have it.
 836      */
 837     if (mode != EXEC_CONT && mode != EXEC_FINISH)
 838     {
 839         DEBUG_FindNearestSymbol( addr, TRUE, NULL, 0, &syminfo.list);
 840         if( syminfo.list.sourcefile != NULL )
 841         {
 842             DEBUG_List(&syminfo.list, NULL, 0);
 843         }
 844     }
 845
 846 #ifdef __i386__
 847     /* If there's no breakpoint and we are not single-stepping, then
 848      * either we must have encountered an int3 in the Windows program
 849      * or someone is trying to stop us
 850      * If the later, (no int3 opcode at current address) then stop,
 851      * otherwise, let's skip it.
 852      */
 853     if ((bpnum == -1) && code == EXCEPTION_BREAKPOINT)
 854     {
 855         unsigned char   c;
 856
 857         if (!DEBUG_READ_MEM(&addr, &c, 1)) c = 0xCC;
 858         DEBUG_context.Eip++;
 859         addr->off++;
 860         if (c != 0xCC) return FALSE;
 861     }
 862 #endif
 863
 864     /* no breakpoint, continue if in continuous mode */
 865     return (mode == EXEC_CONT || mode == EXEC_FINISH);
 866 }
 867
 868 /***********************************************************************
 869  *           DEBUG_SuspendExecution
 870  *
 871  * Remove all breakpoints before entering the debug loop
 872  */
 873 void    DEBUG_SuspendExecution( void )
 874 {
 875    DEBUG_SetBreakpoints( FALSE );
 876    breakpoints[0] = DEBUG_CurrThread->stepOverBP;
 877 }
 878
 879 /***********************************************************************
 880  *           DEBUG_RestartExecution
 881  *
 882  * Set the breakpoints to the correct state to restart execution
 883  * in the given mode.
 884  */
 885 void DEBUG_RestartExecution( int count )
 886 {
 887     DBG_ADDR addr;
 888     DBG_ADDR addr2;
 889     int bp;
 890     int delta;
 891     int status;
 892     enum exec_mode mode, ret_mode;
 893     DWORD instr;
 894     unsigned char ch;
 895
 896     DEBUG_GetCurrentAddress( &addr );
 897
 898     /*
 899      * This is the mode we will be running in after we finish.  We would like
 900      * to be able to modify this in certain cases.
 901      */
 902     ret_mode = mode = DEBUG_CurrThread->exec_mode;
 903
 904     bp = DEBUG_FindBreakpoint( &addr, DBG_BREAK );
 905     if ( bp != -1 && bp != 0)
 906       {
 907         /*
 908          * If we have set a new value, then save it in the BP number.
 909          */
 910         if( count != 0 && mode == EXEC_CONT )
 911           {
 912             breakpoints[bp].skipcount = count;
 913           }
 914         mode = EXEC_STEPI_INSTR;  /* If there's a breakpoint, skip it */
 915       }
 916     else
 917       {
 918         if( mode == EXEC_CONT && count > 1 )
 919           {
 920             DEBUG_Printf(DBG_CHN_MESG, "Not stopped at any breakpoint; argument ignored.\n");
 921           }
 922       }
 923
 924     if( mode == EXEC_FINISH && DEBUG_IsFctReturn() )
 925       {
 926         mode = ret_mode = EXEC_STEPI_INSTR;
 927       }
 928
 929     instr = DEBUG_ToLinear( &addr );
 930     DEBUG_READ_MEM((void*)instr, &ch, sizeof(ch));
 931     /*
 932      * See if the function we are stepping into has debug info
 933      * and line numbers.  If not, then we step over it instead.
 934      * FIXME - we need to check for things like thunks or trampolines,
 935      * as the actual function may in fact have debug info.
 936      */
 937     if ( ch == 0xe8 )
 938       {
 939         DEBUG_READ_MEM((void*)(instr + 1), &delta, sizeof(delta));
 940         addr2 = addr;
 941         DEBUG_Disasm(&addr2, FALSE);
 942         addr2.off += delta;
 943
 944         status = DEBUG_CheckLinenoStatus(&addr2);
 945         /*
 946          * Anytime we have a trampoline, step over it.
 947          */
 948         if( ((mode == EXEC_STEP_OVER) || (mode == EXEC_STEPI_OVER))
 949             && status == FUNC_IS_TRAMPOLINE )
 950           {
 951 #if 0
 952             DEBUG_Printf(DBG_CHN_MESG, "Not stepping into trampoline at %x (no lines)\n",
 953                     addr2.off);
 954 #endif
 955             mode = EXEC_STEP_OVER_TRAMPOLINE;
 956           }
 957
 958         if( mode == EXEC_STEP_INSTR && status == FUNC_HAS_NO_LINES )
 959           {
 960 #if 0
 961             DEBUG_Printf(DBG_CHN_MESG, "Not stepping into function at %x (no lines)\n",
 962                     addr2.off);
 963 #endif
 964             mode = EXEC_STEP_OVER;
 965           }
 966       }
 967
 968
 969     if( mode == EXEC_STEP_INSTR )
 970       {
 971         if( DEBUG_CheckLinenoStatus(&addr) == FUNC_HAS_NO_LINES )
 972           {
 973             DEBUG_Printf(DBG_CHN_MESG, "Single stepping until exit from function, \n");
 974             DEBUG_Printf(DBG_CHN_MESG, "which has no line number information.\n");
 975
 976             ret_mode = mode = EXEC_FINISH;
 977           }
 978       }
 979
 980     switch(mode)
 981     {
 982     case EXEC_CONT: /* Continuous execution */
 983 #ifdef __i386__
 984         DEBUG_context.EFlags &= ~STEP_FLAG;
 985 #endif
 986         DEBUG_SetBreakpoints( TRUE );
 987         break;
 988
 989     case EXEC_STEP_OVER_TRAMPOLINE:
 990       /*
 991        * This is the means by which we step over our conversion stubs
 992        * in callfrom*.s and callto*.s.  We dig the appropriate address
 993        * off the stack, and we set the breakpoint there instead of the
 994        * address just after the call.
 995        */
 996 #ifdef __i386__
 997       DEBUG_READ_MEM((void*)(DEBUG_context.Esp +
 998                              2 * sizeof(unsigned int)),
 999                      &addr.off, sizeof(addr.off));
1000       DEBUG_context.EFlags &= ~STEP_FLAG;
1001 #endif
1002       breakpoints[0].addr    = addr;
1003       breakpoints[0].enabled = TRUE;
1004       breakpoints[0].refcount = 1;
1005       breakpoints[0].skipcount = 0;
1006       DEBUG_READ_MEM((void*)DEBUG_ToLinear( &addr ), &breakpoints[0].u.b.opcode,
1007                      sizeof(char));
1008       DEBUG_SetBreakpoints( TRUE );
1009       break;
1010
1011     case EXEC_FINISH:
1012     case EXEC_STEPI_OVER:  /* Stepping over a call */
1013     case EXEC_STEP_OVER:  /* Stepping over a call */
1014         if (DEBUG_IsStepOverInstr())
1015         {
1016 #ifdef __i386__
1017             DEBUG_context.EFlags &= ~STEP_FLAG;
1018 #endif
1019             DEBUG_Disasm(&addr, FALSE);
1020             breakpoints[0].addr    = addr;
1021             breakpoints[0].enabled = TRUE;
1022             breakpoints[0].refcount = 1;
1023             breakpoints[0].skipcount = 0;
1024             DEBUG_READ_MEM((void*)DEBUG_ToLinear( &addr ), &breakpoints[0].u.b.opcode,
1025                            sizeof(char));
1026             DEBUG_SetBreakpoints( TRUE );
1027             break;
1028         }
1029         /* else fall through to single-stepping */
1030
1031     case EXEC_STEP_INSTR: /* Single-stepping an instruction */
1032     case EXEC_STEPI_INSTR: /* Single-stepping an instruction */
1033 #ifdef __i386__
1034         DEBUG_context.EFlags |= STEP_FLAG;
1035 #endif
1036         break;
1037     default:
1038         RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
1039     }
1040     DEBUG_CurrThread->stepOverBP = breakpoints[0];
1041     DEBUG_CurrThread->exec_mode = ret_mode;
1042 }
1043
1044 int
1045 DEBUG_AddBPCondition(int num, struct expr * exp)
1046 {
1047     if ((num <= 0) || (num >= next_bp) || !breakpoints[num].refcount)
1048     {
1049         DEBUG_Printf( DBG_CHN_MESG, "Invalid breakpoint number %d\n", num );
1050         return FALSE;
1051     }
1052
1053     if( breakpoints[num].condition != NULL )
1054       {
1055         DEBUG_FreeExpr(breakpoints[num].condition);
1056         breakpoints[num].condition = NULL;
1057       }
1058
1059     if( exp != NULL )
1060       {
1061         breakpoints[num].condition = DEBUG_CloneExpr(exp);
1062       }
1063
1064    return TRUE;
1065 }