debugger/break.c

   1 /*
   2  * Debugger break-points handling
   3  *
   4  * Copyright 1994 Martin von Loewis
   5  * Copyright 1995 Alexandre Julliard
   6  */
   7
   8 #include "config.h"
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <sys/types.h>
  12 #ifdef HAVE_SYS_MMAN_H
  13 #include <sys/mman.h>
  14 #endif
  15 #include "wine/winbase16.h"
  16 #include "module.h"
  17 #include "neexe.h"
  18 #include "process.h"
  19 #include "task.h"
  20 #include "miscemu.h"
  21 #include "toolhelp.h"
  22 #include "debugger.h"
  23 #include "dosexe.h"
  24
  25 #define INT3          0xcc   /* int 3 opcode */
  26
  27 #define MAX_BREAKPOINTS 100
  28
  29 typedef struct
  30 {
  31     DBG_ADDR      addr;
  32     BYTE          addrlen;
  33     BYTE          opcode;
  34     BOOL16        enabled;
  35     WORD          skipcount;
  36     BOOL16        in_use;
  37     struct expr * condition;
  38 } BREAKPOINT;
  39
  40 static BREAKPOINT breakpoints[MAX_BREAKPOINTS];
  41
  42 static int next_bp = 1;  /* breakpoint 0 is reserved for step-over */
  43
  44
  45 /***********************************************************************
  46  *           DEBUG_ChangeOpcode
  47  *
  48  * Change the opcode at segment:addr.
  49  */
  50 static void DEBUG_SetOpcode( const DBG_ADDR *addr, BYTE op )
  51 {
  52     BYTE *ptr = DBG_ADDR_TO_LIN(addr);
  53
  54     /* There are a couple of problems with this. On Linux prior to
  55        1.1.62, this call fails (ENOACCESS) due to a bug in fs/exec.c.
  56        This code is currently not tested at all on BSD.
  57        How do I get the old protection in order to restore it later on?
  58        */
  59     if (mprotect((caddr_t)((int)ptr & (~4095)), 4096,
  60                  PROT_READ | PROT_WRITE | PROT_EXEC) == -1)
  61     {
  62         perror( "Can't set break point" );
  63         return;
  64     }
  65     *ptr = op;
  66     /* mprotect((caddr_t)(addr->off & ~4095), 4096,
  67        PROT_READ | PROT_EXEC ); */
  68 }
  69
  70
  71 /***********************************************************************
  72  *           DEBUG_IsStepOverInstr
  73  *
  74  * Determine if the instruction at CS:EIP is an instruction that
  75  * we need to step over (like a call or a repetitive string move).
  76  */
  77 static BOOL DEBUG_IsStepOverInstr()
  78 {
  79     BYTE *instr = (BYTE *)CTX_SEG_OFF_TO_LIN( &DEBUG_context,
  80                                               CS_reg(&DEBUG_context),
  81                                               EIP_reg(&DEBUG_context) );
  82
  83     for (;;)
  84     {
  85         switch(*instr)
  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             return (((instr[1] & 0x38) == 0x10) ||
 112                     ((instr[1] & 0x38) == 0x18));
 113
 114           /* Handle string instructions */
 115
 116         case 0x6c:  /* insb */
 117         case 0x6d:  /* insw */
 118         case 0x6e:  /* outsb */
 119         case 0x6f:  /* outsw */
 120         case 0xa4:  /* movsb */
 121         case 0xa5:  /* movsw */
 122         case 0xa6:  /* cmpsb */
 123         case 0xa7:  /* cmpsw */
 124         case 0xaa:  /* stosb */
 125         case 0xab:  /* stosw */
 126         case 0xac:  /* lodsb */
 127         case 0xad:  /* lodsw */
 128         case 0xae:  /* scasb */
 129         case 0xaf:  /* scasw */
 130             return TRUE;
 131
 132         default:
 133             return FALSE;
 134         }
 135     }
 136 }
 137
 138
 139 /***********************************************************************
 140  *           DEBUG_IsFctReturn
 141  *
 142  * Determine if the instruction at CS:EIP is an instruction that
 143  * is a function return.
 144  */
 145 BOOL DEBUG_IsFctReturn(void)
 146 {
 147     BYTE *instr = (BYTE *)CTX_SEG_OFF_TO_LIN( &DEBUG_context,
 148                                               CS_reg(&DEBUG_context),
 149                                               EIP_reg(&DEBUG_context) );
 150
 151     for (;;)
 152     {
 153         switch(*instr)
 154         {
 155         case 0xc2:
 156         case 0xc3:
 157           return TRUE;
 158         default:
 159             return FALSE;
 160         }
 161     }
 162 }
 163
 164
 165 /***********************************************************************
 166  *           DEBUG_SetBreakpoints
 167  *
 168  * Set or remove all the breakpoints.
 169  */
 170 void DEBUG_SetBreakpoints( BOOL set )
 171 {
 172     int i;
 173
 174     for (i = 0; i < MAX_BREAKPOINTS; i++)
 175     {
 176         if (breakpoints[i].in_use && breakpoints[i].enabled)
 177         {
 178             /* Note: we check for read here, because if reading is allowed */
 179             /*       writing permission will be forced in DEBUG_SetOpcode. */
 180             if (DEBUG_IsBadReadPtr( &breakpoints[i].addr, 1 ))
 181             {
 182                 fprintf( stderr, "Invalid address for breakpoint %d, disabling it\n", i );
 183                 breakpoints[i].enabled = FALSE;
 184             }
 185             else DEBUG_SetOpcode( &breakpoints[i].addr,
 186                                   set ? INT3 : breakpoints[i].opcode );
 187         }
 188     }
 189 }
 190
 191
 192 /***********************************************************************
 193  *           DEBUG_FindBreakpoint
 194  *
 195  * Find the breakpoint for a given address. Return the breakpoint
 196  * number or -1 if none.
 197  */
 198 int DEBUG_FindBreakpoint( const DBG_ADDR *addr )
 199 {
 200     int i;
 201
 202     for (i = 0; i < MAX_BREAKPOINTS; i++)
 203     {
 204         if (breakpoints[i].in_use && breakpoints[i].enabled &&
 205             breakpoints[i].addr.seg == addr->seg &&
 206             breakpoints[i].addr.off == addr->off) return i;
 207     }
 208     return -1;
 209 }
 210
 211
 212 /***********************************************************************
 213  *           DEBUG_AddBreakpoint
 214  *
 215  * Add a breakpoint.
 216  */
 217 void DEBUG_AddBreakpoint( const DBG_ADDR *address )
 218 {
 219     DBG_ADDR addr = *address;
 220     int num;
 221     unsigned int seg2;
 222     BYTE *p;
 223
 224     DBG_FIX_ADDR_SEG( &addr, CS_reg(&DEBUG_context) );
 225
 226     if( addr.type != NULL && addr.type == DEBUG_TypeIntConst )
 227       {
 228         /*
 229          * We know that we have the actual offset stored somewhere
 230          * else in 32-bit space.  Grab it, and we
 231          * should be all set.
 232          */
 233         seg2 = addr.seg;
 234         addr.seg = 0;
 235         addr.off = DEBUG_GetExprValue(&addr, NULL);
 236         addr.seg = seg2;
 237       }
 238     if (!DBG_CHECK_READ_PTR( &addr, 1 )) return;
 239
 240     if (next_bp < MAX_BREAKPOINTS)
 241         num = next_bp++;
 242     else  /* try to find an empty slot */
 243     {
 244         for (num = 1; num < MAX_BREAKPOINTS; num++)
 245             if (!breakpoints[num].in_use) break;
 246         if (num >= MAX_BREAKPOINTS)
 247         {
 248             fprintf( stderr, "Too many breakpoints. Please delete some.\n" );
 249             return;
 250         }
 251     }
 252     p = DBG_ADDR_TO_LIN( &addr );
 253     breakpoints[num].addr    = addr;
 254     breakpoints[num].addrlen = !addr.seg ? 32 :
 255                          (GET_SEL_FLAGS(addr.seg) & LDT_FLAGS_32BIT) ? 32 : 16;
 256     breakpoints[num].opcode  = *p;
 257     breakpoints[num].enabled = TRUE;
 258     breakpoints[num].in_use  = TRUE;
 259     breakpoints[num].skipcount = 0;
 260     fprintf( stderr, "Breakpoint %d at ", num );
 261     DEBUG_PrintAddress( &breakpoints[num].addr, breakpoints[num].addrlen,
 262                         TRUE );
 263     fprintf( stderr, "\n" );
 264 }
 265
 266
 267 /***********************************************************************
 268  *           DEBUG_DelBreakpoint
 269  *
 270  * Delete a breakpoint.
 271  */
 272 void DEBUG_DelBreakpoint( int num )
 273 {
 274     if ((num <= 0) || (num >= next_bp) || !breakpoints[num].in_use)
 275     {
 276         fprintf( stderr, "Invalid breakpoint number %d\n", num );
 277         return;
 278     }
 279
 280     if( breakpoints[num].condition != NULL )
 281       {
 282         DEBUG_FreeExpr(breakpoints[num].condition);
 283         breakpoints[num].condition = NULL;
 284       }
 285
 286     breakpoints[num].enabled = FALSE;
 287     breakpoints[num].in_use  = FALSE;
 288     breakpoints[num].skipcount = 0;
 289 }
 290
 291
 292 /***********************************************************************
 293  *           DEBUG_EnableBreakpoint
 294  *
 295  * Enable or disable a break point.
 296  */
 297 void DEBUG_EnableBreakpoint( int num, BOOL enable )
 298 {
 299     if ((num <= 0) || (num >= next_bp) || !breakpoints[num].in_use)
 300     {
 301         fprintf( stderr, "Invalid breakpoint number %d\n", num );
 302         return;
 303     }
 304     breakpoints[num].enabled = enable;
 305     breakpoints[num].skipcount = 0;
 306 }
 307
 308
 309 /***********************************************************************
 310  *           DEBUG_InfoBreakpoints
 311  *
 312  * Display break points information.
 313  */
 314 void DEBUG_InfoBreakpoints(void)
 315 {
 316     int i;
 317
 318     fprintf( stderr, "Breakpoints:\n" );
 319     for (i = 1; i < next_bp; i++)
 320     {
 321         if (breakpoints[i].in_use)
 322         {
 323             fprintf( stderr, "%d: %c ", i, breakpoints[i].enabled ? 'y' : 'n');
 324             DEBUG_PrintAddress( &breakpoints[i].addr, breakpoints[i].addrlen,
 325                                 TRUE);
 326             fprintf( stderr, "\n" );
 327             if( breakpoints[i].condition != NULL )
 328               {
 329                 fprintf(stderr, "\t\tstop when  ");
 330                 DEBUG_DisplayExpr(breakpoints[i].condition);
 331                 fprintf(stderr, "\n");
 332               }
 333         }
 334     }
 335 }
 336
 337
 338 /***********************************************************************
 339  *           DEBUG_AddTaskEntryBreakpoint
 340  *
 341  * Add a breakpoint at the entry point of the given task
 342  */
 343 void DEBUG_AddTaskEntryBreakpoint( HTASK16 hTask )
 344 {
 345     TDB *pTask = (TDB *)GlobalLock16( hTask );
 346     NE_MODULE *pModule;
 347     DBG_ADDR addr = { NULL, 0, 0 };
 348
 349     if ( pTask )
 350     {
 351         if (!(pModule = NE_GetPtr( pTask->hModule ))) return;
 352         if (pModule->flags & NE_FFLAGS_LIBMODULE) return;  /* Library */
 353
 354         if (pModule->lpDosTask) { /* DOS module */
 355             addr.seg = pModule->lpDosTask->init_cs | ((DWORD)pModule->self << 16);
 356             addr.off = pModule->lpDosTask->init_ip;
 357             fprintf( stderr, "DOS task '%s': ", NE_MODULE_NAME( pModule ) );
 358             DEBUG_AddBreakpoint( &addr );
 359         } else
 360         if (!(pModule->flags & NE_FFLAGS_WIN32))  /* NE module */
 361         {
 362             addr.seg =
 363                 GlobalHandleToSel16(NE_SEG_TABLE(pModule)[pModule->cs-1].hSeg);
 364             addr.off = pModule->ip;
 365             fprintf( stderr, "Win16 task '%s': ", NE_MODULE_NAME( pModule ) );
 366             DEBUG_AddBreakpoint( &addr );
 367         }
 368         else /* PE module */
 369         {
 370             addr.seg = 0;
 371             addr.off = (DWORD)RVA_PTR( pModule->module32,
 372                            OptionalHeader.AddressOfEntryPoint);
 373             fprintf( stderr, "Win32 task '%s': ", NE_MODULE_NAME( pModule ) );
 374             DEBUG_AddBreakpoint( &addr );
 375         }
 376     }
 377
 378     DEBUG_SetBreakpoints( TRUE );  /* Setup breakpoints */
 379 }
 380
 381
 382 /***********************************************************************
 383  *           DEBUG_ShouldContinue
 384  *
 385  * Determine if we should continue execution after a SIGTRAP signal when
 386  * executing in the given mode.
 387  */
 388 BOOL DEBUG_ShouldContinue( enum exec_mode mode, int * count )
 389 {
 390     DBG_ADDR addr;
 391     DBG_ADDR cond_addr;
 392     int bpnum;
 393     struct list_id list;
 394     TDB *pTask = (TDB*)GlobalLock16( GetCurrentTask() );
 395
 396       /* If not single-stepping, back up over the int3 instruction */
 397     if (!(EFL_reg(&DEBUG_context) & STEP_FLAG)) EIP_reg(&DEBUG_context)--;
 398
 399     addr.seg = CS_reg(&DEBUG_context);
 400     addr.off = EIP_reg(&DEBUG_context);
 401     if (ISV86(&DEBUG_context)) addr.seg |= (DWORD)(pTask?(pTask->hModule):0)<<16; else
 402     if (IS_SELECTOR_SYSTEM(addr.seg)) addr.seg = 0;
 403
 404     GlobalUnlock16( GetCurrentTask() );
 405
 406     bpnum = DEBUG_FindBreakpoint( &addr );
 407     breakpoints[0].enabled = 0;  /* disable the step-over breakpoint */
 408
 409     if ((bpnum != 0) && (bpnum != -1))
 410     {
 411         if( breakpoints[bpnum].condition != NULL )
 412           {
 413             cond_addr = DEBUG_EvalExpr(breakpoints[bpnum].condition);
 414             if( cond_addr.type == NULL )
 415               {
 416                 /*
 417                  * Something wrong - unable to evaluate this expression.
 418                  */
 419                 fprintf(stderr, "Unable to evaluate expression ");
 420                 DEBUG_DisplayExpr(breakpoints[bpnum].condition);
 421                 fprintf(stderr, "\nTurning off condition\n");
 422                 DEBUG_AddBPCondition(bpnum, NULL);
 423               }
 424             else if( ! DEBUG_GetExprValue( &cond_addr, NULL) )
 425               {
 426                 return TRUE;
 427               }
 428           }
 429
 430         if( breakpoints[bpnum].skipcount > 0 )
 431           {
 432             breakpoints[bpnum].skipcount--;
 433             if( breakpoints[bpnum].skipcount > 0 )
 434               {
 435                 return TRUE;
 436               }
 437           }
 438         fprintf( stderr, "Stopped on breakpoint %d at ", bpnum );
 439         DEBUG_PrintAddress( &breakpoints[bpnum].addr,
 440                             breakpoints[bpnum].addrlen, TRUE );
 441         fprintf( stderr, "\n" );
 442
 443         /*
 444          * See if there is a source file for this bp.  If so,
 445          * then dig it out and display one line.
 446          */
 447         DEBUG_FindNearestSymbol( &addr, TRUE, NULL, 0, &list);
 448         if( list.sourcefile != NULL )
 449           {
 450             DEBUG_List(&list, NULL, 0);
 451           }
 452         return FALSE;
 453     }
 454
 455     /*
 456      * If our mode indicates that we are stepping line numbers,
 457      * get the current function, and figure out if we are exactly
 458      * on a line number or not.
 459      */
 460     if( mode == EXEC_STEP_OVER
 461         || mode == EXEC_STEP_INSTR )
 462       {
 463         if( DEBUG_CheckLinenoStatus(&addr) == AT_LINENUMBER )
 464           {
 465             (*count)--;
 466           }
 467       }
 468     else if( mode == EXEC_STEPI_OVER
 469         || mode == EXEC_STEPI_INSTR )
 470
 471       {
 472         (*count)--;
 473       }
 474
 475     if( *count > 0 || mode == EXEC_FINISH )
 476       {
 477         /*
 478          * We still need to execute more instructions.
 479          */
 480         return TRUE;
 481       }
 482
 483     /*
 484      * If we are about to stop, then print out the source line if we
 485      * have it.
 486      */
 487     if ((mode != EXEC_CONT && mode != EXEC_PASS && mode != EXEC_FINISH))
 488       {
 489         DEBUG_FindNearestSymbol( &addr, TRUE, NULL, 0, &list);
 490         if( list.sourcefile != NULL )
 491           {
 492             DEBUG_List(&list, NULL, 0);
 493           }
 494       }
 495
 496     /* If there's no breakpoint and we are not single-stepping, then we     */
 497     /* must have encountered an int3 in the Windows program; let's skip it. */
 498     if ((bpnum == -1) && !(EFL_reg(&DEBUG_context) & STEP_FLAG))
 499         EIP_reg(&DEBUG_context)++;
 500
 501       /* no breakpoint, continue if in continuous mode */
 502     return (mode == EXEC_CONT || mode == EXEC_PASS || mode == EXEC_FINISH);
 503 }
 504
 505
 506 /***********************************************************************
 507  *           DEBUG_RestartExecution
 508  *
 509  * Set the breakpoints to the correct state to restart execution
 510  * in the given mode.
 511  */
 512 enum exec_mode DEBUG_RestartExecution( enum exec_mode mode, int count )
 513 {
 514     DBG_ADDR addr;
 515     DBG_ADDR addr2;
 516     int bp;
 517     int delta;
 518     int status;
 519     unsigned int * value;
 520     enum exec_mode ret_mode;
 521     BYTE *instr;
 522     TDB *pTask = (TDB*)GlobalLock16( GetCurrentTask() );
 523
 524     addr.seg = CS_reg(&DEBUG_context);
 525     addr.off = EIP_reg(&DEBUG_context);
 526     if (ISV86(&DEBUG_context)) addr.seg |= (DWORD)(pTask?(pTask->hModule):0)<<16; else
 527     if (IS_SELECTOR_SYSTEM(addr.seg)) addr.seg = 0;
 528
 529     GlobalUnlock16( GetCurrentTask() );
 530
 531     /*
 532      * This is the mode we will be running in after we finish.  We would like
 533      * to be able to modify this in certain cases.
 534      */
 535     ret_mode = mode;
 536
 537     bp = DEBUG_FindBreakpoint( &addr );
 538     if ( bp != -1 && bp != 0)
 539       {
 540         /*
 541          * If we have set a new value, then save it in the BP number.
 542          */
 543         if( count != 0 && mode == EXEC_CONT )
 544           {
 545             breakpoints[bp].skipcount = count;
 546           }
 547         mode = EXEC_STEPI_INSTR;  /* If there's a breakpoint, skip it */
 548       }
 549     else
 550       {
 551         if( mode == EXEC_CONT && count > 1 )
 552           {
 553             fprintf(stderr,"Not stopped at any breakpoint; argument ignored.\n");
 554           }
 555       }
 556
 557     if( mode == EXEC_FINISH && DEBUG_IsFctReturn() )
 558       {
 559         mode = ret_mode = EXEC_STEPI_INSTR;
 560       }
 561
 562     instr = (BYTE *)CTX_SEG_OFF_TO_LIN( &DEBUG_context,
 563                                         CS_reg(&DEBUG_context),
 564                                         EIP_reg(&DEBUG_context) );
 565     /*
 566      * See if the function we are stepping into has debug info
 567      * and line numbers.  If not, then we step over it instead.
 568      * FIXME - we need to check for things like thunks or trampolines,
 569      * as the actual function may in fact have debug info.
 570      */
 571     if( *instr == 0xe8 )
 572       {
 573         delta = *(unsigned int*) (instr + 1);
 574         addr2 = addr;
 575         DEBUG_Disasm(&addr2, FALSE);
 576         addr2.off += delta;
 577
 578         status = DEBUG_CheckLinenoStatus(&addr2);
 579         /*
 580          * Anytime we have a trampoline, step over it.
 581          */
 582         if( ((mode == EXEC_STEP_OVER) || (mode == EXEC_STEPI_OVER))
 583             && status == FUNC_IS_TRAMPOLINE )
 584           {
 585 #if 0
 586             fprintf(stderr, "Not stepping into trampoline at %x (no lines)\n",
 587                     addr2.off);
 588 #endif
 589             mode = EXEC_STEP_OVER_TRAMPOLINE;
 590           }
 591
 592         if( mode == EXEC_STEP_INSTR && status == FUNC_HAS_NO_LINES )
 593           {
 594 #if 0
 595             fprintf(stderr, "Not stepping into function at %x (no lines)\n",
 596                     addr2.off);
 597 #endif
 598             mode = EXEC_STEP_OVER;
 599           }
 600       }
 601
 602
 603     if( mode == EXEC_STEP_INSTR )
 604       {
 605         if( DEBUG_CheckLinenoStatus(&addr) == FUNC_HAS_NO_LINES )
 606           {
 607             fprintf(stderr, "Single stepping until exit from function, \n");
 608             fprintf(stderr, "which has no line number information.\n");
 609
 610             ret_mode = mode = EXEC_FINISH;
 611           }
 612       }
 613
 614     switch(mode)
 615     {
 616     case EXEC_CONT: /* Continuous execution */
 617     case EXEC_PASS: /* Continue, passing exception */
 618         EFL_reg(&DEBUG_context) &= ~STEP_FLAG;
 619         DEBUG_SetBreakpoints( TRUE );
 620         break;
 621
 622     case EXEC_STEP_OVER_TRAMPOLINE:
 623       /*
 624        * This is the means by which we step over our conversion stubs
 625        * in callfrom*.s and callto*.s.  We dig the appropriate address
 626        * off the stack, and we set the breakpoint there instead of the
 627        * address just after the call.
 628        */
 629       value = (unsigned int *) ESP_reg(&DEBUG_context) + 2;
 630       addr.off = *value;
 631       EFL_reg(&DEBUG_context) &= ~STEP_FLAG;
 632       breakpoints[0].addr    = addr;
 633       breakpoints[0].enabled = TRUE;
 634       breakpoints[0].in_use  = TRUE;
 635       breakpoints[0].skipcount = 0;
 636       breakpoints[0].opcode  = *(BYTE *)DBG_ADDR_TO_LIN( &addr );
 637       DEBUG_SetBreakpoints( TRUE );
 638       break;
 639
 640     case EXEC_FINISH:
 641     case EXEC_STEPI_OVER:  /* Stepping over a call */
 642     case EXEC_STEP_OVER:  /* Stepping over a call */
 643         if (DEBUG_IsStepOverInstr())
 644         {
 645             EFL_reg(&DEBUG_context) &= ~STEP_FLAG;
 646             DEBUG_Disasm(&addr, FALSE);
 647             breakpoints[0].addr    = addr;
 648             breakpoints[0].enabled = TRUE;
 649             breakpoints[0].in_use  = TRUE;
 650             breakpoints[0].skipcount = 0;
 651             breakpoints[0].opcode  = *(BYTE *)DBG_ADDR_TO_LIN( &addr );
 652             DEBUG_SetBreakpoints( TRUE );
 653             break;
 654         }
 655         /* else fall through to single-stepping */
 656
 657     case EXEC_STEP_INSTR: /* Single-stepping an instruction */
 658     case EXEC_STEPI_INSTR: /* Single-stepping an instruction */
 659         EFL_reg(&DEBUG_context) |= STEP_FLAG;
 660         break;
 661     }
 662     return ret_mode;
 663 }
 664
 665 int
 666 DEBUG_AddBPCondition(int num, struct expr * exp)
 667 {
 668     if ((num <= 0) || (num >= next_bp) || !breakpoints[num].in_use)
 669     {
 670         fprintf( stderr, "Invalid breakpoint number %d\n", num );
 671         return FALSE;
 672     }
 673
 674     if( breakpoints[num].condition != NULL )
 675       {
 676         DEBUG_FreeExpr(breakpoints[num].condition);
 677         breakpoints[num].condition = NULL;
 678       }
 679
 680     if( exp != NULL )
 681       {
 682         breakpoints[num].condition = DEBUG_CloneExpr(exp);
 683       }
 684
 685    return TRUE;
 686 }