gdb/breakpoint.c

   1 /* Everything about breakpoints, for GDB.
   2    Copyright (C) 1986, 1987 Free Software Foundation, Inc.
   3
   4 GDB is distributed in the hope that it will be useful, but WITHOUT ANY
   5 WARRANTY.  No author or distributor accepts responsibility to anyone
   6 for the consequences of using it or for whether it serves any
   7 particular purpose or works at all, unless he says so in writing.
   8 Refer to the GDB General Public License for full details.
   9
  10 Everyone is granted permission to copy, modify and redistribute GDB,
  11 but only under the conditions described in the GDB General Public
  12 License.  A copy of this license is supposed to have been given to you
  13 along with GDB so you can know your rights and responsibilities.  It
  14 should be in a file named COPYING.  Among other things, the copyright
  15 notice and this notice must be preserved on all copies.
  16
  17 In other words, go ahead and share GDB, but don't try to stop
  18 anyone else from sharing it farther.  Help stamp out software hoarding!
  19 */
  20
  21 #include "defs.h"
  22 #include "param.h"
  23 #include "symtab.h"
  24 #include "frame.h"
  25
  26 #include <stdio.h>
  27
  28 /* This is the sequence of bytes we insert for a breakpoint.  */
  29
  30 static char break_insn[] = BREAKPOINT;
  31
  32 /* States of enablement of breakpoint.
  33    `temporary' means disable when hit.
  34    `delete' means delete when hit.  */
  35
  36 enum enable { disabled, enabled, temporary, delete};
  37
  38 /* Not that the ->silent field is not currently used by any commands
  39    (though the code is in there if it was to be and set_raw_breakpoint
  40    does set it to 0).  I implemented it because I thought it would be
  41    useful for a hack I had to put in; I'm going to leave it in because
  42    I can see how there might be times when it would indeed be useful */
  43
  44 struct breakpoint
  45 {
  46   struct breakpoint *next;
  47   /* Number assigned to distinguish breakpoints.  */
  48   int number;
  49   /* Address to break at.  */
  50   CORE_ADDR address;
  51   /* Line number of this address.  Redundant.  */
  52   int line_number;
  53   /* Symtab of file of this address.  Redundant.  */
  54   struct symtab *symtab;
  55   /* Zero means disabled; remember the info but don't break here.  */
  56   enum enable enable;
  57   /* Non-zero means a silent breakpoint (don't print frame info
  58      if we stop here). */
  59   unsigned char silent;
  60   /* Number of stops at this breakpoint that should
  61      be continued automatically before really stopping.  */
  62   int ignore_count;
  63   /* "Real" contents of byte where breakpoint has been inserted.
  64      Valid only when breakpoints are in the program.  */
  65   char shadow_contents[sizeof break_insn];
  66   /* Nonzero if this breakpoint is now inserted.  */
  67   char inserted;
  68   /* Nonzero if this is not the first breakpoint in the list
  69      for the given address.  */
  70   char duplicate;
  71   /* Chain of command lines to execute when this breakpoint is hit.  */
  72   struct command_line *commands;
  73   /* Stack depth (address of frame).  If nonzero, break only if fp
  74      equals this.  */
  75   FRAME_ADDR frame;
  76   /* Conditional.  Break only if this expression's value is nonzero.  */
  77   struct expression *cond;
  78 };
  79
  80 #define ALL_BREAKPOINTS(b)  for (b = breakpoint_chain; b; b = b->next)
  81
  82 /* Chain of all breakpoints defined.  */
  83
  84 struct breakpoint *breakpoint_chain;
  85
  86 /* Number of last breakpoint made.  */
  87
  88 static int breakpoint_count;
  89
  90 /* Default address, symtab and line to put a breakpoint at
  91    for "break" command with no arg.
  92    if default_breakpoint_valid is zero, the other three are
  93    not valid, and "break" with no arg is an error.
  94
  95    This set by print_stack_frame, which calls set_default_breakpoint.  */
  96
  97 int default_breakpoint_valid;
  98 CORE_ADDR default_breakpoint_address;
  99 struct symtab *default_breakpoint_symtab;
 100 int default_breakpoint_line;
 101
 102 /* Remaining commands (not yet executed)
 103    of last breakpoint hit.  */
 104
 105 struct command_line *breakpoint_commands;
 106
 107 static void delete_breakpoint ();
 108 void clear_momentary_breakpoints ();
 109 void breakpoint_auto_delete ();
 110 \f
 111 /* condition N EXP -- set break condition of breakpoint N to EXP.  */
 112
 113 static void
 114 condition_command (arg, from_tty)
 115      char *arg;
 116      int from_tty;
 117 {
 118   register struct breakpoint *b;
 119   register char *p;
 120   register int bnum;
 121   register struct expression *expr;
 122
 123   if (arg == 0)
 124     error_no_arg ("breakpoint number");
 125
 126   p = arg;
 127   while (*p >= '0' && *p <= '9') p++;
 128   bnum = atoi (arg);
 129
 130   ALL_BREAKPOINTS (b)
 131     if (b->number == bnum)
 132       {
 133         if (b->cond)
 134           free (b->cond);
 135         if (*p == 0)
 136           {
 137             b->cond = 0;
 138             if (from_tty)
 139               printf ("Breakpoint %d now unconditional.\n", bnum);
 140           }
 141         else
 142           {
 143             if (*p != ' ' && *p != '\t')
 144               error ("Arguments must be an integer (breakpoint number) and an expression.");
 145
 146             /* Find start of expression */
 147             while (*p == ' ' || *p == '\t') p++;
 148
 149             arg = p;
 150             b->cond = (struct expression *) parse_c_1 (&arg, block_for_pc (b->address), 0);
 151             if (*arg)
 152               error ("Junk at end of expression");
 153           }
 154         return;
 155       }
 156
 157   error ("No breakpoint number %d.", bnum);
 158 }
 159
 160 static void
 161 commands_command (arg)
 162      char *arg;
 163 {
 164   register struct breakpoint *b;
 165   register char *p, *p1;
 166   register int bnum;
 167   struct command_line *l;
 168
 169   /* If we allowed this, we would have problems with when to
 170      free the storage, if we change the commands currently
 171      being read from.  */
 172
 173   if (breakpoint_commands)
 174     error ("Can't use the \"commands\" command among a breakpoint's commands.");
 175
 176   /* Allow commands by itself to refer to the last breakpoint.  */
 177   if (arg == 0)
 178     bnum = breakpoint_count;
 179   else
 180     {
 181       p = arg;
 182       if (! (*p >= '0' && *p <= '9'))
 183         error ("Argument must be integer (a breakpoint number).");
 184
 185       while (*p >= '0' && *p <= '9') p++;
 186       if (*p)
 187         error ("Unexpected extra arguments following breakpoint number.");
 188
 189       bnum = atoi (arg);
 190     }
 191
 192   ALL_BREAKPOINTS (b)
 193     if (b->number == bnum)
 194       {
 195         if (input_from_terminal_p ())
 196           {
 197             printf ("Type commands for when breakpoint %d is hit, one per line.\n\
 198 End with a line saying just \"end\".\n", bnum);
 199             fflush (stdout);
 200           }
 201         l = read_command_lines ();
 202         free_command_lines (&b->commands);
 203         b->commands = l;
 204         return;
 205       }
 206   error ("No breakpoint number %d.", bnum);
 207 }
 208
 209 /* Called from command loop to execute the commands
 210    associated with the breakpoint we just stopped at.  */
 211
 212 void
 213 do_breakpoint_commands ()
 214 {
 215   while (breakpoint_commands)
 216     {
 217       char *line = breakpoint_commands->line;
 218       breakpoint_commands = breakpoint_commands->next;
 219       execute_command (line, 0);
 220       /* If command was "cont", breakpoint_commands is now 0,
 221          of if we stopped at yet another breakpoint which has commands,
 222          it is now the commands for the new breakpoint.  */
 223     }
 224   clear_momentary_breakpoints ();
 225 }
 226
 227 /* Used when the program is proceeded, to eliminate any remaining
 228    commands attached to the previous breakpoint we stopped at.  */
 229
 230 void
 231 clear_breakpoint_commands ()
 232 {
 233   breakpoint_commands = 0;
 234   breakpoint_auto_delete (0);
 235 }
 236
 237 /* Functions to get and set the current list of pending
 238    breakpoint commands.  These are used by run_stack_dummy
 239    to preserve the commands around a function call.  */
 240
 241 struct command_line *
 242 get_breakpoint_commands ()
 243 {
 244   return breakpoint_commands;
 245 }
 246
 247 void
 248 set_breakpoint_commands (cmds)
 249      struct command_line *cmds;
 250 {
 251   breakpoint_commands = cmds;
 252 }
 253 \f
 254 /* insert_breakpoints is used when starting or continuing the program.
 255    remove_breakpoints is used when the program stops.
 256    Both return zero if successful,
 257    or an `errno' value if could not write the inferior.  */
 258
 259 int
 260 insert_breakpoints ()
 261 {
 262   register struct breakpoint *b;
 263   int val;
 264
 265 #ifdef BREAKPOINT_DEBUG
 266   printf ("Inserting breakpoints.\n");
 267 #endif /* BREAKPOINT_DEBUG */
 268
 269   ALL_BREAKPOINTS (b)
 270     if (b->enable != disabled && ! b->inserted && ! b->duplicate)
 271       {
 272         read_memory (b->address, b->shadow_contents, sizeof break_insn);
 273         val = write_memory (b->address, break_insn, sizeof break_insn);
 274         if (val)
 275           return val;
 276 #ifdef BREAKPOINT_DEBUG
 277         printf ("Inserted breakpoint at 0x%x, shadow 0x%x, 0x%x.\n",
 278                 b->address, b->shadow_contents[0], b->shadow_contents[1]);
 279 #endif /* BREAKPOINT_DEBUG */
 280         b->inserted = 1;
 281       }
 282   return 0;
 283 }
 284
 285 int
 286 remove_breakpoints ()
 287 {
 288   register struct breakpoint *b;
 289   int val;
 290
 291 #ifdef BREAKPOINT_DEBUG
 292   printf ("Removing breakpoints.\n");
 293 #endif /* BREAKPOINT_DEBUG */
 294
 295   ALL_BREAKPOINTS (b)
 296     if (b->inserted)
 297       {
 298         val = write_memory (b->address, b->shadow_contents, sizeof break_insn);
 299         if (val)
 300           return val;
 301         b->inserted = 0;
 302 #ifdef BREAKPOINT_DEBUG
 303         printf ("Removed breakpoint at 0x%x, shadow 0x%x, 0x%x.\n",
 304                 b->address, b->shadow_contents[0], b->shadow_contents[1]);
 305 #endif /* BREAKPOINT_DEBUG */
 306       }
 307
 308   return 0;
 309 }
 310
 311 /* Clear the "inserted" flag in all breakpoints.
 312    This is done when the inferior is loaded.  */
 313
 314 void
 315 mark_breakpoints_out ()
 316 {
 317   register struct breakpoint *b;
 318
 319   ALL_BREAKPOINTS (b)
 320     b->inserted = 0;
 321 }
 322
 323 /* breakpoint_here_p (PC) returns 1 if an enabled breakpoint exists at PC.
 324    When continuing from a location with a breakpoint,
 325    we actually single step once before calling insert_breakpoints.  */
 326
 327 int
 328 breakpoint_here_p (pc)
 329      CORE_ADDR pc;
 330 {
 331   register struct breakpoint *b;
 332
 333   ALL_BREAKPOINTS (b)
 334     if (b->enable != disabled && b->address == pc)
 335       return 1;
 336
 337   return 0;
 338 }
 339
 340 /* Evaluate the expression EXP and return 1 if value is zero.
 341    This is used inside a catch_errors to evaluate the breakpoint condition.  */
 342
 343 int
 344 breakpoint_cond_eval (exp)
 345      struct expression *exp;
 346 {
 347   return value_zerop (evaluate_expression (exp));
 348 }
 349
 350 /* Return 0 if PC is not the address just after a breakpoint,
 351    or -1 if breakpoint says do not stop now,
 352    or -2 if breakpoint says it has deleted itself and don't stop,
 353    or -3 if hit a breakpoint number -3 (delete when program stops),
 354    or else the number of the breakpoint,
 355    with 0x1000000 added (or subtracted, for a negative return value) for
 356    a silent breakpoint.  */
 357
 358 int
 359 breakpoint_stop_status (pc, frame_address)
 360      CORE_ADDR pc;
 361      FRAME_ADDR frame_address;
 362 {
 363   register struct breakpoint *b;
 364   register int cont = 0;
 365
 366   /* Get the address where the breakpoint would have been.  */
 367   pc -= DECR_PC_AFTER_BREAK;
 368
 369   ALL_BREAKPOINTS (b)
 370     if (b->enable != disabled && b->address == pc)
 371       {
 372         if (b->frame && b->frame != frame_address)
 373           cont = -1;
 374         else
 375           {
 376             int value_zero;
 377             if (b->cond)
 378               {
 379                 value_zero
 380                   = catch_errors (breakpoint_cond_eval, b->cond,
 381                                   "Error occurred in testing breakpoint condition.");
 382                 free_all_values ();
 383               }
 384             if (b->cond && value_zero)
 385               {
 386                 cont = -1;
 387               }
 388             else if (b->ignore_count > 0)
 389               {
 390                 b->ignore_count--;
 391                 cont = -1;
 392               }
 393             else
 394               {
 395                 if (b->enable == temporary)
 396                   b->enable = disabled;
 397                 breakpoint_commands = b->commands;
 398                 if (b->silent
 399                     || (breakpoint_commands
 400                         && !strcmp ("silent", breakpoint_commands->line)))
 401                   {
 402                     if (breakpoint_commands)
 403                       breakpoint_commands = breakpoint_commands->next;
 404                     return (b->number > 0 ?
 405                             0x1000000 + b->number :
 406                             b->number - 0x1000000);
 407                   }
 408                 return b->number;
 409               }
 410           }
 411       }
 412
 413   return cont;
 414 }
 415 \f
 416 static void
 417 breakpoint_1 (bnum)
 418      int bnum;
 419 {
 420   register struct breakpoint *b;
 421   register struct command_line *l;
 422   register struct symbol *sym;
 423   CORE_ADDR last_addr = -1;
 424
 425   ALL_BREAKPOINTS (b)
 426     if (bnum == -1 || bnum == b->number)
 427       {
 428         printf ("#%-3d %c  0x%08x ", b->number,
 429                 "nyod"[(int) b->enable],
 430                 b->address);
 431         last_addr = b->address;
 432         if (b->symtab)
 433           {
 434             sym = find_pc_function (b->address);
 435             if (sym)
 436               printf (" in %s (%s line %d)", SYMBOL_NAME (sym),
 437                       b->symtab->filename, b->line_number);
 438             else
 439               printf ("%s line %d", b->symtab->filename, b->line_number);
 440           }
 441         printf ("\n");
 442
 443         if (b->ignore_count)
 444           printf ("\tignore next %d hits\n", b->ignore_count);
 445         if (b->frame)
 446           printf ("\tstop only in stack frame at 0x%x\n", b->frame);
 447         if (b->cond)
 448           {
 449             printf ("\tbreak only if ");
 450             print_expression (b->cond, stdout);
 451             printf ("\n");
 452           }
 453         if (l = b->commands)
 454           while (l)
 455             {
 456               printf ("\t%s\n", l->line);
 457               l = l->next;
 458             }
 459       }
 460
 461   if (last_addr != -1)
 462     set_next_address (last_addr);
 463 }
 464
 465 static void
 466 breakpoints_info (bnum_exp)
 467      char *bnum_exp;
 468 {
 469   int bnum = -1;
 470
 471   if (bnum_exp)
 472     bnum = parse_and_eval_address (bnum_exp);
 473   else if (breakpoint_chain == 0)
 474     printf ("No breakpoints.\n");
 475   else
 476     printf ("Breakpoints:\n\
 477 Num Enb   Address    Where\n");
 478
 479   breakpoint_1 (bnum);
 480 }
 481
 482 /* Print a message describing any breakpoints set at PC.  */
 483
 484 static void
 485 describe_other_breakpoints (pc)
 486      register CORE_ADDR pc;
 487 {
 488   register int others = 0;
 489   register struct breakpoint *b;
 490
 491   ALL_BREAKPOINTS (b)
 492     if (b->address == pc)
 493       others++;
 494   if (others > 0)
 495     {
 496       printf ("Note: breakpoint%s ", (others > 1) ? "s" : "");
 497       ALL_BREAKPOINTS (b)
 498         if (b->address == pc)
 499           {
 500             others--;
 501             printf ("%d%s%s ",
 502                     b->number,
 503                     (b->enable == disabled) ? " (disabled)" : "",
 504                     (others > 1) ? "," : ((others == 1) ? " and" : ""));
 505           }
 506       printf (" also set at pc 0x%x\n", pc);
 507     }
 508 }
 509 \f
 510 /* Set the default place to put a breakpoint
 511    for the `break' command with no arguments.  */
 512
 513 void
 514 set_default_breakpoint (valid, addr, symtab, line)
 515      int valid;
 516      CORE_ADDR addr;
 517      struct symtab *symtab;
 518      int line;
 519 {
 520   default_breakpoint_valid = valid;
 521   default_breakpoint_address = addr;
 522   default_breakpoint_symtab = symtab;
 523   default_breakpoint_line = line;
 524 }
 525
 526 /* Rescan breakpoints at address ADDRESS,
 527    marking the first one as "first" and any others as "duplicates".
 528    This is so that the bpt instruction is only inserted once.  */
 529
 530 static void
 531 check_duplicates (address)
 532      CORE_ADDR address;
 533 {
 534   register struct breakpoint *b;
 535   register int count = 0;
 536
 537   ALL_BREAKPOINTS (b)
 538     if (b->enable != disabled && b->address == address)
 539       {
 540         count++;
 541         b->duplicate = count > 1;
 542       }
 543 }
 544
 545 /* Low level routine to set a breakpoint.
 546    Takes as args the three things that every breakpoint must have.
 547    Returns the breakpoint object so caller can set other things.
 548    Does not set the breakpoint number!
 549    Does not print anything.  */
 550
 551 static struct breakpoint *
 552 set_raw_breakpoint (sal)
 553      struct symtab_and_line sal;
 554 {
 555   register struct breakpoint *b, *b1;
 556
 557   b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint));
 558   bzero (b, sizeof *b);
 559   b->address = sal.pc;
 560   b->symtab = sal.symtab;
 561   b->line_number = sal.line;
 562   b->enable = enabled;
 563   b->next = 0;
 564   b->silent = 0;
 565
 566   /* Add this breakpoint to the end of the chain
 567      so that a list of breakpoints will come out in order
 568      of increasing numbers.  */
 569
 570   b1 = breakpoint_chain;
 571   if (b1 == 0)
 572     breakpoint_chain = b;
 573   else
 574     {
 575       while (b1->next)
 576         b1 = b1->next;
 577       b1->next = b;
 578     }
 579
 580   check_duplicates (sal.pc);
 581
 582   return b;
 583 }
 584
 585 /* Set a breakpoint that will evaporate an end of command
 586    at address specified by SAL.
 587    Restrict it to frame FRAME if FRAME is nonzero.  */
 588
 589 void
 590 set_momentary_breakpoint (sal, frame)
 591      struct symtab_and_line sal;
 592      FRAME frame;
 593 {
 594   register struct breakpoint *b;
 595   b = set_raw_breakpoint (sal);
 596   b->number = -3;
 597   b->enable = delete;
 598   b->frame = (frame ? FRAME_FP (frame) : 0);
 599 }
 600
 601 void
 602 clear_momentary_breakpoints ()
 603 {
 604   register struct breakpoint *b;
 605   ALL_BREAKPOINTS (b)
 606     if (b->number == -3)
 607       {
 608         delete_breakpoint (b);
 609         break;
 610       }
 611 }
 612 \f
 613 /* Set a breakpoint from a symtab and line.
 614    If TEMPFLAG is nonzero, it is a temporary breakpoint.
 615    Print the same confirmation messages that the breakpoint command prints.  */
 616
 617 void
 618 set_breakpoint (s, line, tempflag)
 619      struct symtab *s;
 620      int line;
 621      int tempflag;
 622 {
 623   register struct breakpoint *b;
 624   struct symtab_and_line sal;
 625
 626   sal.symtab = s;
 627   sal.line = line;
 628   sal.pc = find_line_pc (sal.symtab, sal.line);
 629   if (sal.pc == 0)
 630     error ("No line %d in file \"%s\".\n", sal.line, sal.symtab->filename);
 631   else
 632     {
 633       describe_other_breakpoints (sal.pc);
 634
 635       b = set_raw_breakpoint (sal);
 636       b->number = ++breakpoint_count;
 637       b->cond = 0;
 638       if (tempflag)
 639         b->enable = temporary;
 640
 641       printf ("Breakpoint %d at 0x%x", b->number, b->address);
 642       if (b->symtab)
 643         printf (": file %s, line %d.", b->symtab->filename, b->line_number);
 644       printf ("\n");
 645     }
 646 }
 647 \f
 648 /* Set a breakpoint according to ARG (function, linenum or *address)
 649    and make it temporary if TEMPFLAG is nonzero. */
 650
 651 static void
 652 break_command_1 (arg, tempflag, from_tty)
 653      char *arg;
 654      int tempflag, from_tty;
 655 {
 656   struct symtabs_and_lines sals;
 657   struct symtab_and_line sal;
 658   register struct expression *cond = 0;
 659   register struct breakpoint *b;
 660   char *save_arg;
 661   int i;
 662   CORE_ADDR pc;
 663
 664   sals.sals = NULL;
 665   sals.nelts = 0;
 666
 667   sal.line = sal.pc = sal.end = 0;
 668   sal.symtab = 0;
 669
 670   /* If no arg given, or if first arg is 'if ', use the default breakpoint. */
 671
 672   if (!arg || (arg[0] == 'i' && arg[1] == 'f'
 673                && (arg[2] == ' ' || arg[2] == '\t')))
 674     {
 675       if (default_breakpoint_valid)
 676         {
 677           sals.sals = (struct symtab_and_line *)
 678             malloc (sizeof (struct symtab_and_line));
 679           sal.pc = default_breakpoint_address;
 680           sal.line = default_breakpoint_line;
 681           sal.symtab = default_breakpoint_symtab;
 682           sals.sals[0] = sal;
 683           sals.nelts = 1;
 684         }
 685       else
 686         error ("No default breakpoint address now.");
 687     }
 688   else
 689     if (default_breakpoint_valid)
 690       sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
 691                             default_breakpoint_line);
 692     else
 693       sals = decode_line_1 (&arg, 1, 0, 0);
 694
 695   if (! sals.nelts)
 696     return;
 697
 698   save_arg = arg;
 699   for (i = 0; i < sals.nelts; i++)
 700     {
 701       sal = sals.sals[i];
 702       if (sal.pc == 0 && sal.symtab != 0)
 703         {
 704           pc = find_line_pc (sal.symtab, sal.line);
 705           if (pc == 0)
 706             error ("No line %d in file \"%s\".",
 707                    sal.line, sal.symtab->filename);
 708         }
 709       else
 710         pc = sal.pc;
 711
 712       while (arg && *arg)
 713         {
 714           if (arg[0] == 'i' && arg[1] == 'f'
 715               && (arg[2] == ' ' || arg[2] == '\t'))
 716             cond = (struct expression *) parse_c_1 ((arg += 2, &arg),
 717                                                     block_for_pc (pc), 0);
 718           else
 719             error ("Junk at end of arguments.");
 720         }
 721       arg = save_arg;
 722       sals.sals[i].pc = pc;
 723     }
 724
 725   for (i = 0; i < sals.nelts; i++)
 726     {
 727       sal = sals.sals[i];
 728
 729       if (from_tty)
 730         describe_other_breakpoints (sal.pc);
 731
 732       b = set_raw_breakpoint (sal);
 733       b->number = ++breakpoint_count;
 734       b->cond = cond;
 735       if (tempflag)
 736         b->enable = temporary;
 737
 738       printf ("Breakpoint %d at 0x%x", b->number, b->address);
 739       if (b->symtab)
 740         printf (": file %s, line %d.", b->symtab->filename, b->line_number);
 741       printf ("\n");
 742     }
 743
 744   if (sals.nelts > 1)
 745     {
 746       printf ("Multiple breakpoints were set.\n");
 747       printf ("Use the \"delete\" command to delete unwanted breakpoints.\n");
 748     }
 749   free (sals.sals);
 750 }
 751
 752 static void
 753 break_command (arg, from_tty)
 754      char *arg;
 755      int from_tty;
 756 {
 757   break_command_1 (arg, 0, from_tty);
 758 }
 759
 760 static void
 761 tbreak_command (arg, from_tty)
 762      char *arg;
 763      int from_tty;
 764 {
 765   break_command_1 (arg, 1, from_tty);
 766 }
 767 \f
 768 /*
 769  * Helper routine for the until_command routine in infcmd.c.  Here
 770  * because it uses the mechanisms of breakpoints.
 771  */
 772 void
 773 until_break_command(arg, from_tty)
 774      char *arg;
 775      int from_tty;
 776 {
 777   struct symtabs_and_lines sals;
 778   struct symtab_and_line sal;
 779   FRAME frame = get_current_frame ();
 780   FRAME prev_frame = get_prev_frame (frame);
 781
 782   /* Set a breakpoint where the user wants it and at return from
 783      this function */
 784
 785   if (default_breakpoint_valid)
 786     sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
 787                           default_breakpoint_line);
 788   else
 789     sals = decode_line_1 (&arg, 1, 0, 0);
 790
 791   if (sals.nelts != 1)
 792     error ("Couldn't get information on specified line.");
 793
 794   sal = sals.sals[0];
 795   free (sals.sals);             /* malloc'd, so freed */
 796
 797   if (*arg)
 798     error ("Junk at end of arguments.");
 799
 800   if (sal.pc == 0 && sal.symtab != 0)
 801     sal.pc = find_line_pc (sal.symtab, sal.line);
 802
 803   if (sal.pc == 0)
 804     error ("No line %d in file \"%s\".", sal.line, sal.symtab->filename);
 805
 806   set_momentary_breakpoint (sal, 0);
 807
 808   /* Keep within the current frame */
 809
 810   if (prev_frame)
 811     {
 812       struct frame_info *fi;
 813
 814       fi = get_frame_info (prev_frame);
 815       sal = find_pc_line (fi->pc, 0);
 816       sal.pc = fi->pc;
 817       set_momentary_breakpoint (sal, prev_frame);
 818     }
 819
 820   proceed (-1, -1, 0);
 821 }
 822 \f
 823 static void
 824 clear_command (arg, from_tty)
 825      char *arg;
 826      int from_tty;
 827 {
 828   register struct breakpoint *b, *b1;
 829   struct symtabs_and_lines sals;
 830   struct symtab_and_line sal;
 831   register struct breakpoint *found;
 832   int i;
 833
 834   if (arg)
 835     {
 836       sals = decode_line_spec (arg, 1);
 837     }
 838   else
 839     {
 840       sals.sals = (struct symtab_and_line *) malloc (sizeof (struct symtab_and_line));
 841       sal.line = default_breakpoint_line;
 842       sal.symtab = default_breakpoint_symtab;
 843       sal.pc = 0;
 844       if (sal.symtab == 0)
 845         error ("No source file specified.");
 846
 847       sals.sals[0] = sal;
 848       sals.nelts = 1;
 849     }
 850
 851   for (i = 0; i < sals.nelts; i++)
 852     {
 853       /* If exact pc given, clear bpts at that pc.
 854          But if sal.pc is zero, clear all bpts on specified line.  */
 855       sal = sals.sals[i];
 856       found = (struct breakpoint *) 0;
 857       while (breakpoint_chain
 858              && (sal.pc ? breakpoint_chain->address == sal.pc
 859                  : (breakpoint_chain->symtab == sal.symtab
 860                     && breakpoint_chain->line_number == sal.line)))
 861         {
 862           b1 = breakpoint_chain;
 863           breakpoint_chain = b1->next;
 864           b1->next = found;
 865           found = b1;
 866         }
 867
 868       ALL_BREAKPOINTS (b)
 869         while (b->next
 870                && (sal.pc ? b->next->address == sal.pc
 871                    : (b->next->symtab == sal.symtab
 872                       && b->next->line_number == sal.line)))
 873           {
 874             b1 = b->next;
 875             b->next = b1->next;
 876             b1->next = found;
 877             found = b1;
 878           }
 879
 880       if (found == 0)
 881         error ("No breakpoint at %s.", arg);
 882
 883       if (found->next) from_tty = 1; /* Always report if deleted more than one */
 884       if (from_tty) printf ("Deleted breakpoint%s ", found->next ? "s" : "");
 885       while (found)
 886         {
 887           if (from_tty) printf ("%d ", found->number);
 888           b1 = found->next;
 889           delete_breakpoint (found);
 890           found = b1;
 891         }
 892       if (from_tty) putchar ('\n');
 893     }
 894   free (sals.sals);
 895 }
 896 \f
 897 /* Delete breakpoint number BNUM if it is a `delete' breakpoint.
 898    This is called after breakpoint BNUM has been hit.
 899    Also delete any breakpoint numbered -3 unless there are breakpoint
 900    commands to be executed.  */
 901
 902 void
 903 breakpoint_auto_delete (bnum)
 904      int bnum;
 905 {
 906   register struct breakpoint *b;
 907   if (bnum != 0)
 908     ALL_BREAKPOINTS (b)
 909       if (b->number == bnum)
 910         {
 911           if (b->enable == delete)
 912             delete_breakpoint (b);
 913           break;
 914         }
 915   if (breakpoint_commands == 0)
 916     clear_momentary_breakpoints ();
 917 }
 918
 919 static void
 920 delete_breakpoint (bpt)
 921      struct breakpoint *bpt;
 922 {
 923   register struct breakpoint *b;
 924
 925   if (bpt->inserted)
 926     write_memory (bpt->address, bpt->shadow_contents, sizeof break_insn);
 927
 928   if (breakpoint_chain == bpt)
 929     breakpoint_chain = bpt->next;
 930
 931   ALL_BREAKPOINTS (b)
 932     if (b->next == bpt)
 933       {
 934         b->next = bpt->next;
 935         break;
 936       }
 937
 938   check_duplicates (bpt->address);
 939
 940   free_command_lines (&bpt->commands);
 941   if (bpt->cond)
 942     free (bpt->cond);
 943   free (bpt);
 944 }
 945
 946 static void map_breakpoint_numbers ();
 947
 948 static void
 949 delete_command (arg, from_tty)
 950      char *arg;
 951      int from_tty;
 952 {
 953   register struct breakpoint *b, *b1;
 954
 955   if (arg == 0)
 956     {
 957       if (!from_tty || query ("Delete all breakpoints? "))
 958         {
 959           /* No arg; clear all breakpoints.  */
 960           while (breakpoint_chain)
 961             delete_breakpoint (breakpoint_chain);
 962         }
 963     }
 964   else
 965     map_breakpoint_numbers (arg, delete_breakpoint);
 966 }
 967
 968 /* Delete all breakpoints.
 969    Done when new symtabs are loaded, since the break condition expressions
 970    may become invalid, and the breakpoints are probably wrong anyway.  */
 971
 972 void
 973 clear_breakpoints ()
 974 {
 975   delete_command (0, 0);
 976 }
 977 \f
 978 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
 979    If from_tty is nonzero, it prints a message to that effect,
 980    which ends with a period (no newline).  */
 981
 982 void
 983 set_ignore_count (bptnum, count, from_tty)
 984      int bptnum, count, from_tty;
 985 {
 986   register struct breakpoint *b;
 987
 988   if (count < 0)
 989     count = 0;
 990
 991   ALL_BREAKPOINTS (b)
 992     if (b->number == bptnum)
 993       {
 994         b->ignore_count = count;
 995         if (!from_tty)
 996           return;
 997         else if (count == 0)
 998           printf ("Will stop next time breakpoint %d is reached.", bptnum);
 999         else if (count == 1)
1000           printf ("Will ignore next crossing of breakpoint %d.", bptnum);
1001         else
1002           printf ("Will ignore next %d crossings of breakpoint %d.",
1003                   count, bptnum);
1004         return;
1005       }
1006
1007   error ("No breakpoint number %d.", bptnum);
1008 }
1009
1010 /* Command to set ignore-count of breakpoint N to COUNT.  */
1011
1012 static void
1013 ignore_command (args, from_tty)
1014      char *args;
1015      int from_tty;
1016 {
1017   register char *p = args;
1018   register int num;
1019
1020   if (p == 0)
1021     error_no_arg ("a breakpoint number");
1022
1023   while (*p >= '0' && *p <= '9') p++;
1024   if (*p && *p != ' ' && *p != '\t')
1025     error ("First argument must be a breakpoint number.");
1026
1027   num = atoi (args);
1028
1029   if (*p == 0)
1030     error ("Second argument (specified ignore-count) is missing.");
1031
1032   set_ignore_count (num, parse_and_eval_address (p), from_tty);
1033   printf ("\n");
1034 }
1035 \f
1036 /* Call FUNCTION on each of the breakpoints
1037    whose numbers are given in ARGS.  */
1038
1039 static void
1040 map_breakpoint_numbers (args, function)
1041      char *args;
1042      void (*function) ();
1043 {
1044   register char *p = args;
1045   register char *p1;
1046   register int num;
1047   register struct breakpoint *b;
1048
1049   if (p == 0)
1050     error_no_arg ("one or more breakpoint numbers");
1051
1052   while (*p)
1053     {
1054       p1 = p;
1055       while (*p1 >= '0' && *p1 <= '9') p1++;
1056       if (*p1 && *p1 != ' ' && *p1 != '\t')
1057         error ("Arguments must be breakpoint numbers.");
1058
1059       num = atoi (p);
1060
1061       ALL_BREAKPOINTS (b)
1062         if (b->number == num)
1063           {
1064             function (b);
1065             goto win;
1066           }
1067       printf ("No breakpoint number %d.\n", num);
1068     win:
1069       p = p1;
1070       while (*p == ' ' || *p == '\t') p++;
1071     }
1072 }
1073
1074 static void
1075 enable_breakpoint (bpt)
1076      struct breakpoint *bpt;
1077 {
1078   bpt->enable = enabled;
1079
1080   check_duplicates (bpt->address);
1081 }
1082
1083 static void
1084 enable_command (args)
1085      char *args;
1086 {
1087   map_breakpoint_numbers (args, enable_breakpoint);
1088 }
1089
1090 static void
1091 disable_breakpoint (bpt)
1092      struct breakpoint *bpt;
1093 {
1094   bpt->enable = disabled;
1095
1096   check_duplicates (bpt->address);
1097 }
1098
1099 static void
1100 disable_command (args)
1101      char *args;
1102 {
1103   register struct breakpoint *bpt;
1104   if (args == 0)
1105     ALL_BREAKPOINTS (bpt)
1106       disable_breakpoint (bpt);
1107   else
1108     map_breakpoint_numbers (args, disable_breakpoint);
1109 }
1110
1111 static void
1112 enable_once_breakpoint (bpt)
1113      struct breakpoint *bpt;
1114 {
1115   bpt->enable = temporary;
1116
1117   check_duplicates (bpt->address);
1118 }
1119
1120 static void
1121 enable_once_command (args)
1122      char *args;
1123 {
1124   map_breakpoint_numbers (args, enable_once_breakpoint);
1125 }
1126
1127 static void
1128 enable_delete_breakpoint (bpt)
1129      struct breakpoint *bpt;
1130 {
1131   bpt->enable = delete;
1132
1133   check_duplicates (bpt->address);
1134 }
1135
1136 static void
1137 enable_delete_command (args)
1138      char *args;
1139 {
1140   map_breakpoint_numbers (args, enable_delete_breakpoint);
1141 }
1142 \f
1143 /*
1144  * Use default_breakpoint_'s, or nothing if they aren't valid.
1145  */
1146 struct symtabs_and_lines
1147 decode_line_spec_1 (string, funfirstline)
1148      char *string;
1149      int funfirstline;
1150 {
1151   struct symtabs_and_lines sals;
1152   if (string == 0)
1153     error ("Empty line specification.");
1154   if (default_breakpoint_valid)
1155     sals = decode_line_1 (&string, funfirstline,
1156                           default_breakpoint_symtab, default_breakpoint_line);
1157   else
1158     sals = decode_line_1 (&string, funfirstline, 0, 0);
1159   if (*string)
1160     error ("Junk at end of line specification: %s", string);
1161   return sals;
1162 }
1163 \f
1164
1165 /* Chain containing all defined enable commands.  */
1166
1167 extern struct cmd_list_element
1168   *enablelist, *disablelist,
1169   *deletelist, *enablebreaklist;
1170
1171 extern struct cmd_list_element *cmdlist;
1172
1173 void
1174 _initialize_breakpoint ()
1175 {
1176   breakpoint_chain = 0;
1177   breakpoint_count = 0;
1178
1179   add_com ("ignore", class_breakpoint, ignore_command,
1180            "Set ignore-count of breakpoint number N to COUNT.");
1181
1182   add_com ("commands", class_breakpoint, commands_command,
1183            "Set commands to be executed when a breakpoint is hit.\n\
1184 Give breakpoint number as argument after \"commands\".\n\
1185 With no argument, the targeted breakpoint is the last one set.\n\
1186 The commands themselves follow starting on the next line.\n\
1187 Type a line containing \"end\" to indicate the end of them.\n\
1188 Give \"silent\" as the first line to make the breakpoint silent;\n\
1189 then no output is printed when it is hit, except what the commands print.");
1190
1191   add_com ("condition", class_breakpoint, condition_command,
1192            "Specify breakpoint number N to break only if COND is true.\n\
1193 N is an integer; COND is a C expression to be evaluated whenever\n\
1194 breakpoint N is reached.  Actually break only when COND is nonzero.");
1195
1196   add_com ("tbreak", class_breakpoint, tbreak_command,
1197            "Set a temporary breakpoint.  Args like \"break\" command.\n\
1198 Like \"break\" except the breakpoint is only enabled temporarily,\n\
1199 so it will be disabled when hit.  Equivalent to \"break\" followed\n\
1200 by using \"enable once\" on the breakpoint number.");
1201
1202   add_prefix_cmd ("enable", class_breakpoint, enable_command,
1203                   "Enable some breakpoints or auto-display expressions.\n\
1204 Give breakpoint numbers (separated by spaces) as arguments.\n\
1205 With no subcommand, breakpoints are enabled until you command otherwise.\n\
1206 This is used to cancel the effect of the \"disable\" command.\n\
1207 With a subcommand you can enable temporarily.\n\
1208 \n\
1209 The \"display\" subcommand applies to auto-displays instead of breakpoints.",
1210                   &enablelist, "enable ", 1, &cmdlist);
1211
1212   add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command,
1213                   "Enable some breakpoints or auto-display expressions.\n\
1214 Give breakpoint numbers (separated by spaces) as arguments.\n\
1215 With no subcommand, breakpoints are enabled until you command otherwise.\n\
1216 This is used to cancel the effect of the \"disable\" command.\n\
1217 May be abbreviates to simply \"enable\".\n\
1218 With a subcommand you can enable temporarily.",
1219                   &enablebreaklist, "enable breakpoints ", 1, &enablelist);
1220
1221   add_cmd ("once", no_class, enable_once_command,
1222            "Enable breakpoints for one hit.  Give breakpoint numbers.\n\
1223 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
1224 See the \"tbreak\" command which sets a breakpoint and enables it once.",
1225            &enablebreaklist);
1226
1227   add_cmd ("delete", no_class, enable_delete_command,
1228            "Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
1229 If a breakpoint is hit while enabled in this fashion, it is deleted.",
1230            &enablebreaklist);
1231
1232   add_cmd ("delete", no_class, enable_delete_command,
1233            "Enable breakpoints and delete when hit.  Give breakpoint numbers.\n\
1234 If a breakpoint is hit while enabled in this fashion, it is deleted.",
1235            &enablelist);
1236
1237   add_cmd ("once", no_class, enable_once_command,
1238            "Enable breakpoints for one hit.  Give breakpoint numbers.\n\
1239 If a breakpoint is hit while enabled in this fashion, it becomes disabled.\n\
1240 See the \"tbreak\" command which sets a breakpoint and enables it once.",
1241            &enablelist);
1242
1243   add_prefix_cmd ("disable", class_breakpoint, disable_command,
1244            "Disable some breakpoints or auto-display expressions.\n\
1245 Arguments are breakpoint numbers with spaces in between.\n\
1246 To disable all breakpoints, give no argument.\n\
1247 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
1248 \n\
1249 The \"display\" subcommand applies to auto-displays instead of breakpoints.",
1250                   &disablelist, "disable ", 1, &cmdlist);
1251   add_com_alias ("dis", "disable", class_breakpoint, 1);
1252
1253   add_abbrev_cmd ("breakpoints", class_breakpoint, disable_command,
1254            "Disable some breakpoints or auto-display expressions.\n\
1255 Arguments are breakpoint numbers with spaces in between.\n\
1256 To disable all breakpoints, give no argument.\n\
1257 A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\
1258 This command may be abbreviated \"disable\".",
1259            &disablelist);
1260
1261   add_prefix_cmd ("delete", class_breakpoint, delete_command,
1262            "Delete some breakpoints or auto-display expressions.\n\
1263 Arguments are breakpoint numbers with spaces in between.\n\
1264 To delete all breakpoints, give no argument.\n\
1265 \n\
1266 The \"display\" subcommand applies to auto-displays instead of breakpoints.",
1267                   &deletelist, "delete ", 1, &cmdlist);
1268   add_com_alias ("d", "delete", class_breakpoint, 1);
1269   add_com_alias ("unset", "delete", class_breakpoint, 1);
1270
1271   add_abbrev_cmd ("breakpoints", class_breakpoint, delete_command,
1272            "Delete some breakpoints or auto-display expressions.\n\
1273 Arguments are breakpoint numbers with spaces in between.\n\
1274 To delete all breakpoints, give no argument.\n\
1275 This command may be abbreviated \"delete\".",
1276            &deletelist);
1277
1278   add_com ("clear", class_breakpoint, clear_command,
1279            "Clear breakpoint at specified line or function.\n\
1280 Argument may be line number, function name, or \"*\" and an address.\n\
1281 If line number is specified, all breakpoints in that line are cleared.\n\
1282 If function is specified, breakpoints at beginning of function are cleared.\n\
1283 If an address is specified, breakpoints at that address are cleared.\n\n\
1284 With no argument, clears all breakpoints in the line that the selected frame\n\
1285 is executing in.\n\
1286 \n\
1287 See also the \"delete\" command which clears breakpoints by number.");
1288
1289   add_com ("break", class_breakpoint, break_command,
1290            "Set breakpoint at specified line or function.\n\
1291 Argument may be line number, function name, or \"*\" and an address.\n\
1292 If line number is specified, break at start of code for that line.\n\
1293 If function is specified, break at start of code for that function.\n\
1294 If an address is specified, break at that exact address.\n\
1295 With no arg, uses current execution address of selected stack frame.\n\
1296 This is useful for breaking on return to a stack frame.\n\
1297 \n\
1298 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
1299 \n\
1300 Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
1301   add_com_alias ("b", "break", class_run, 1);
1302   add_com_alias ("br", "break", class_run, 1);
1303   add_com_alias ("bre", "break", class_run, 1);
1304   add_com_alias ("brea", "break", class_run, 1);
1305
1306   add_info ("breakpoints", breakpoints_info,
1307             "Status of all breakpoints, or breakpoint number NUMBER.\n\
1308 Second column is \"y\" for enabled breakpoint, \"n\" for disabled,\n\
1309 \"o\" for enabled once (disable when hit), \"d\" for enable but delete when hit.\n\
1310 Then come the address and the file/line number.\n\n\
1311 Convenience variable \"$_\" and default examine address for \"x\"\n\
1312 are set to the address of the last breakpoint listed.");
1313 }
1314