1/* Everything about breakpoints, for GDB. 2 3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 5 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, 22 Boston, MA 02111-1307, USA. */ 23 24#include "defs.h" 25#include <ctype.h> 26#include "symtab.h" 27#include "frame.h" 28#include "breakpoint.h" 29#include "gdbtypes.h" 30#include "expression.h" 31#include "gdbcore.h" 32#include "gdbcmd.h" 33#include "value.h" 34#include "command.h" 35#include "inferior.h" 36#include "gdbthread.h" 37#include "target.h" 38#include "language.h" 39#include "gdb_string.h" 40#include "demangle.h" 41#include "annotate.h" 42#include "symfile.h" 43#include "objfiles.h" 44#include "source.h" 45#include "linespec.h" 46#include "completer.h" 47#include "gdb.h" 48#include "ui-out.h" 49#include "cli/cli-script.h" 50#include "gdb_assert.h" 51#include "block.h" 52#include "solist.h" 53#include "observer.h" 54 55#include "gdb-events.h" 56 57/* Prototypes for local functions. */ 58 59static void until_break_command_continuation (struct continuation_arg *arg); 60 61static void catch_command_1 (char *, int, int); 62 63static void enable_delete_command (char *, int); 64 65static void enable_delete_breakpoint (struct breakpoint *); 66 67static void enable_once_command (char *, int); 68 69static void enable_once_breakpoint (struct breakpoint *); 70 71static void disable_command (char *, int); 72 73static void enable_command (char *, int); 74 75static void map_breakpoint_numbers (char *, void (*)(struct breakpoint *)); 76 77static void ignore_command (char *, int); 78 79static int breakpoint_re_set_one (void *); 80 81static void clear_command (char *, int); 82 83static void catch_command (char *, int); 84 85static void watch_command (char *, int); 86 87static int can_use_hardware_watchpoint (struct value *); 88 89extern void break_at_finish_command (char *, int); 90extern void break_at_finish_at_depth_command (char *, int); 91 92extern void tbreak_at_finish_command (char *, int); 93 94static int break_command_1 (char *, int, int, struct breakpoint *); 95 96static void mention (struct breakpoint *); 97 98struct breakpoint *set_raw_breakpoint (struct symtab_and_line, enum bptype); 99 100static void check_duplicates (struct breakpoint *); 101 102static void breakpoint_adjustment_warning (CORE_ADDR, CORE_ADDR, int, int); 103 104static CORE_ADDR adjust_breakpoint_address (CORE_ADDR bpaddr, 105 enum bptype bptype); 106 107static void describe_other_breakpoints (CORE_ADDR, asection *); 108 109static void breakpoints_info (char *, int); 110 111static void breakpoint_1 (int, int); 112 113static bpstat bpstat_alloc (struct breakpoint *, bpstat); 114 115static int breakpoint_cond_eval (void *); 116 117static void cleanup_executing_breakpoints (void *); 118 119static void commands_command (char *, int); 120 121static void condition_command (char *, int); 122 123static int get_number_trailer (char **, int); 124 125static int do_captured_parse_breakpoint (struct ui_out *, void *); 126 127void set_breakpoint_count (int); 128 129typedef enum 130 { 131 mark_inserted, 132 mark_uninserted 133 } 134insertion_state_t; 135 136static int remove_breakpoint (struct bp_location *, insertion_state_t); 137 138static enum print_stop_action print_it_typical (bpstat); 139 140static enum print_stop_action print_bp_stop_message (bpstat bs); 141 142typedef struct 143 { 144 enum exception_event_kind kind; 145 int enable_p; 146 } 147args_for_catchpoint_enable; 148 149static int watchpoint_check (void *); 150 151static int cover_target_enable_exception_callback (void *); 152 153static void maintenance_info_breakpoints (char *, int); 154 155static void create_longjmp_breakpoint (char *); 156 157static void create_overlay_event_breakpoint (char *); 158 159static int hw_breakpoint_used_count (void); 160 161static int hw_watchpoint_used_count (enum bptype, int *); 162 163static void hbreak_command (char *, int); 164 165static void thbreak_command (char *, int); 166 167static void watch_command_1 (char *, int, int); 168 169static void rwatch_command (char *, int); 170 171static void awatch_command (char *, int); 172 173static void do_enable_breakpoint (struct breakpoint *, enum bpdisp); 174 175static void solib_load_unload_1 (char *hookname, 176 int tempflag, 177 char *dll_pathname, 178 char *cond_string, enum bptype bp_kind); 179 180static void create_fork_vfork_event_catchpoint (int tempflag, 181 char *cond_string, 182 enum bptype bp_kind); 183 184static void break_at_finish_at_depth_command_1 (char *arg, 185 int flag, int from_tty); 186 187static void break_at_finish_command_1 (char *arg, int flag, int from_tty); 188 189static void stop_command (char *arg, int from_tty); 190 191static void stopin_command (char *arg, int from_tty); 192 193static void stopat_command (char *arg, int from_tty); 194 195static char *ep_find_event_name_end (char *arg); 196 197static char *ep_parse_optional_if_clause (char **arg); 198 199static char *ep_parse_optional_filename (char **arg); 200 201static void create_exception_catchpoint (int tempflag, char *cond_string, 202 enum exception_event_kind ex_event, 203 struct symtab_and_line *sal); 204 205static void catch_exception_command_1 (enum exception_event_kind ex_event, 206 char *arg, int tempflag, int from_tty); 207 208static void tcatch_command (char *arg, int from_tty); 209 210static void ep_skip_leading_whitespace (char **s); 211 212/* Prototypes for exported functions. */ 213 214/* If FALSE, gdb will not use hardware support for watchpoints, even 215 if such is available. */ 216static int can_use_hw_watchpoints; 217 218/* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints. 219 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints 220 for unrecognized breakpoint locations. 221 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */ 222static enum auto_boolean pending_break_support; 223 224void _initialize_breakpoint (void); 225 226extern int addressprint; /* Print machine addresses? */ 227 228/* Are we executing breakpoint commands? */ 229static int executing_breakpoint_commands; 230 231/* Are overlay event breakpoints enabled? */ 232static int overlay_events_enabled; 233 234/* Walk the following statement or block through all breakpoints. 235 ALL_BREAKPOINTS_SAFE does so even if the statment deletes the current 236 breakpoint. */ 237 238#define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next) 239 240#define ALL_BREAKPOINTS_SAFE(B,TMP) \ 241 for (B = breakpoint_chain; \ 242 B ? (TMP=B->next, 1): 0; \ 243 B = TMP) 244 245/* Similar iterators for the low-level breakpoints. */ 246 247#define ALL_BP_LOCATIONS(B) for (B = bp_location_chain; B; B = B->next) 248 249#define ALL_BP_LOCATIONS_SAFE(B,TMP) \ 250 for (B = bp_location_chain; \ 251 B ? (TMP=B->next, 1): 0; \ 252 B = TMP) 253 254/* True if breakpoint hit counts should be displayed in breakpoint info. */ 255 256int show_breakpoint_hit_counts = 1; 257 258/* Chains of all breakpoints defined. */ 259 260struct breakpoint *breakpoint_chain; 261 262struct bp_location *bp_location_chain; 263 264/* Number of last breakpoint made. */ 265 266int breakpoint_count; 267 268/* Pointer to current exception event record */ 269static struct exception_event_record *current_exception_event; 270 271/* Indicator of whether exception catchpoints should be nuked between 272 runs of a program. */ 273int deprecated_exception_catchpoints_are_fragile = 0; 274 275/* Indicator of when exception catchpoints set-up should be 276 reinitialized -- e.g. when program is re-run. */ 277int deprecated_exception_support_initialized = 0; 278 279/* This function returns a pointer to the string representation of the 280 pathname of the dynamically-linked library that has just been 281 loaded. 282 283 This function must be used only when SOLIB_HAVE_LOAD_EVENT is TRUE, 284 or undefined results are guaranteed. 285 286 This string's contents are only valid immediately after the 287 inferior has stopped in the dynamic linker hook, and becomes 288 invalid as soon as the inferior is continued. Clients should make 289 a copy of this string if they wish to continue the inferior and 290 then access the string. */ 291 292#ifndef SOLIB_LOADED_LIBRARY_PATHNAME 293#define SOLIB_LOADED_LIBRARY_PATHNAME(pid) "" 294#endif 295 296/* This function returns a pointer to the string representation of the 297 pathname of the dynamically-linked library that has just been 298 unloaded. 299 300 This function must be used only when SOLIB_HAVE_UNLOAD_EVENT is 301 TRUE, or undefined results are guaranteed. 302 303 This string's contents are only valid immediately after the 304 inferior has stopped in the dynamic linker hook, and becomes 305 invalid as soon as the inferior is continued. Clients should make 306 a copy of this string if they wish to continue the inferior and 307 then access the string. */ 308 309#ifndef SOLIB_UNLOADED_LIBRARY_PATHNAME 310#define SOLIB_UNLOADED_LIBRARY_PATHNAME(pid) "" 311#endif 312 313/* This function is called by the "catch load" command. It allows the 314 debugger to be notified by the dynamic linker when a specified 315 library file (or any library file, if filename is NULL) is loaded. */ 316 317#ifndef SOLIB_CREATE_CATCH_LOAD_HOOK 318#define SOLIB_CREATE_CATCH_LOAD_HOOK(pid,tempflag,filename,cond_string) \ 319 error ("catch of library loads not yet implemented on this platform") 320#endif 321 322/* This function is called by the "catch unload" command. It allows 323 the debugger to be notified by the dynamic linker when a specified 324 library file (or any library file, if filename is NULL) is 325 unloaded. */ 326 327#ifndef SOLIB_CREATE_CATCH_UNLOAD_HOOK 328#define SOLIB_CREATE_CATCH_UNLOAD_HOOK(pid,tempflag,filename,cond_string) \ 329 error ("catch of library unloads not yet implemented on this platform") 330#endif 331 332/* Return whether a breakpoint is an active enabled breakpoint. */ 333static int 334breakpoint_enabled (struct breakpoint *b) 335{ 336 return (b->enable_state == bp_enabled && !b->pending); 337} 338 339/* Set breakpoint count to NUM. */ 340 341void 342set_breakpoint_count (int num) 343{ 344 breakpoint_count = num; 345 set_internalvar (lookup_internalvar ("bpnum"), 346 value_from_longest (builtin_type_int, (LONGEST) num)); 347} 348 349/* Used in run_command to zero the hit count when a new run starts. */ 350 351void 352clear_breakpoint_hit_counts (void) 353{ 354 struct breakpoint *b; 355 356 ALL_BREAKPOINTS (b) 357 b->hit_count = 0; 358} 359 360/* Default address, symtab and line to put a breakpoint at 361 for "break" command with no arg. 362 if default_breakpoint_valid is zero, the other three are 363 not valid, and "break" with no arg is an error. 364 365 This set by print_stack_frame, which calls set_default_breakpoint. */ 366 367int default_breakpoint_valid; 368CORE_ADDR default_breakpoint_address; 369struct symtab *default_breakpoint_symtab; 370int default_breakpoint_line; 371 372/* *PP is a string denoting a breakpoint. Get the number of the breakpoint. 373 Advance *PP after the string and any trailing whitespace. 374 375 Currently the string can either be a number or "$" followed by the name 376 of a convenience variable. Making it an expression wouldn't work well 377 for map_breakpoint_numbers (e.g. "4 + 5 + 6"). 378 379 TRAILER is a character which can be found after the number; most 380 commonly this is `-'. If you don't want a trailer, use \0. */ 381static int 382get_number_trailer (char **pp, int trailer) 383{ 384 int retval = 0; /* default */ 385 char *p = *pp; 386 387 if (p == NULL) 388 /* Empty line means refer to the last breakpoint. */ 389 return breakpoint_count; 390 else if (*p == '$') 391 { 392 /* Make a copy of the name, so we can null-terminate it 393 to pass to lookup_internalvar(). */ 394 char *varname; 395 char *start = ++p; 396 struct value *val; 397 398 while (isalnum (*p) || *p == '_') 399 p++; 400 varname = (char *) alloca (p - start + 1); 401 strncpy (varname, start, p - start); 402 varname[p - start] = '\0'; 403 val = value_of_internalvar (lookup_internalvar (varname)); 404 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT) 405 retval = (int) value_as_long (val); 406 else 407 { 408 printf_filtered ("Convenience variable must have integer value.\n"); 409 retval = 0; 410 } 411 } 412 else 413 { 414 if (*p == '-') 415 ++p; 416 while (*p >= '0' && *p <= '9') 417 ++p; 418 if (p == *pp) 419 /* There is no number here. (e.g. "cond a == b"). */ 420 { 421 /* Skip non-numeric token */ 422 while (*p && !isspace((int) *p)) 423 ++p; 424 /* Return zero, which caller must interpret as error. */ 425 retval = 0; 426 } 427 else 428 retval = atoi (*pp); 429 } 430 if (!(isspace (*p) || *p == '\0' || *p == trailer)) 431 { 432 /* Trailing junk: return 0 and let caller print error msg. */ 433 while (!(isspace (*p) || *p == '\0' || *p == trailer)) 434 ++p; 435 retval = 0; 436 } 437 while (isspace (*p)) 438 p++; 439 *pp = p; 440 return retval; 441} 442 443 444/* Like get_number_trailer, but don't allow a trailer. */ 445int 446get_number (char **pp) 447{ 448 return get_number_trailer (pp, '\0'); 449} 450 451/* Parse a number or a range. 452 * A number will be of the form handled by get_number. 453 * A range will be of the form <number1> - <number2>, and 454 * will represent all the integers between number1 and number2, 455 * inclusive. 456 * 457 * While processing a range, this fuction is called iteratively; 458 * At each call it will return the next value in the range. 459 * 460 * At the beginning of parsing a range, the char pointer PP will 461 * be advanced past <number1> and left pointing at the '-' token. 462 * Subsequent calls will not advance the pointer until the range 463 * is completed. The call that completes the range will advance 464 * pointer PP past <number2>. 465 */ 466 467int 468get_number_or_range (char **pp) 469{ 470 static int last_retval, end_value; 471 static char *end_ptr; 472 static int in_range = 0; 473 474 if (**pp != '-') 475 { 476 /* Default case: pp is pointing either to a solo number, 477 or to the first number of a range. */ 478 last_retval = get_number_trailer (pp, '-'); 479 if (**pp == '-') 480 { 481 char **temp; 482 483 /* This is the start of a range (<number1> - <number2>). 484 Skip the '-', parse and remember the second number, 485 and also remember the end of the final token. */ 486 487 temp = &end_ptr; 488 end_ptr = *pp + 1; 489 while (isspace ((int) *end_ptr)) 490 end_ptr++; /* skip white space */ 491 end_value = get_number (temp); 492 if (end_value < last_retval) 493 { 494 error ("inverted range"); 495 } 496 else if (end_value == last_retval) 497 { 498 /* degenerate range (number1 == number2). Advance the 499 token pointer so that the range will be treated as a 500 single number. */ 501 *pp = end_ptr; 502 } 503 else 504 in_range = 1; 505 } 506 } 507 else if (! in_range) 508 error ("negative value"); 509 else 510 { 511 /* pp points to the '-' that betokens a range. All 512 number-parsing has already been done. Return the next 513 integer value (one greater than the saved previous value). 514 Do not advance the token pointer 'pp' until the end of range 515 is reached. */ 516 517 if (++last_retval == end_value) 518 { 519 /* End of range reached; advance token pointer. */ 520 *pp = end_ptr; 521 in_range = 0; 522 } 523 } 524 return last_retval; 525} 526 527 528 529/* condition N EXP -- set break condition of breakpoint N to EXP. */ 530 531static void 532condition_command (char *arg, int from_tty) 533{ 534 struct breakpoint *b; 535 char *p; 536 int bnum; 537 538 if (arg == 0) 539 error_no_arg ("breakpoint number"); 540 541 p = arg; 542 bnum = get_number (&p); 543 if (bnum == 0) 544 error ("Bad breakpoint argument: '%s'", arg); 545 546 ALL_BREAKPOINTS (b) 547 if (b->number == bnum) 548 { 549 if (b->cond) 550 { 551 xfree (b->cond); 552 b->cond = 0; 553 } 554 if (b->cond_string != NULL) 555 xfree (b->cond_string); 556 557 if (*p == 0) 558 { 559 b->cond = 0; 560 b->cond_string = NULL; 561 if (from_tty) 562 printf_filtered ("Breakpoint %d now unconditional.\n", bnum); 563 } 564 else 565 { 566 arg = p; 567 /* I don't know if it matters whether this is the string the user 568 typed in or the decompiled expression. */ 569 b->cond_string = savestring (arg, strlen (arg)); 570 if (!b->pending) 571 { 572 b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0); 573 if (*arg) 574 error ("Junk at end of expression"); 575 } 576 } 577 breakpoints_changed (); 578 breakpoint_modify_event (b->number); 579 return; 580 } 581 582 error ("No breakpoint number %d.", bnum); 583} 584 585static void 586commands_command (char *arg, int from_tty) 587{ 588 struct breakpoint *b; 589 char *p; 590 int bnum; 591 struct command_line *l; 592 593 /* If we allowed this, we would have problems with when to 594 free the storage, if we change the commands currently 595 being read from. */ 596 597 if (executing_breakpoint_commands) 598 error ("Can't use the \"commands\" command among a breakpoint's commands."); 599 600 p = arg; 601 bnum = get_number (&p); 602 603 if (p && *p) 604 error ("Unexpected extra arguments following breakpoint number."); 605 606 ALL_BREAKPOINTS (b) 607 if (b->number == bnum) 608 { 609 char *tmpbuf = xstrprintf ("Type commands for when breakpoint %d is hit, one per line.", 610 bnum); 611 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf); 612 l = read_command_lines (tmpbuf, from_tty); 613 do_cleanups (cleanups); 614 free_command_lines (&b->commands); 615 b->commands = l; 616 breakpoints_changed (); 617 breakpoint_modify_event (b->number); 618 return; 619 } 620 error ("No breakpoint number %d.", bnum); 621} 622 623/* Like target_read_memory() but if breakpoints are inserted, return 624 the shadow contents instead of the breakpoints themselves. 625 626 Read "memory data" from whatever target or inferior we have. 627 Returns zero if successful, errno value if not. EIO is used 628 for address out of bounds. If breakpoints are inserted, returns 629 shadow contents, not the breakpoints themselves. From breakpoint.c. */ 630 631int 632deprecated_read_memory_nobpt (CORE_ADDR memaddr, char *myaddr, unsigned len) 633{ 634 int status; 635 struct bp_location *b; 636 CORE_ADDR bp_addr = 0; 637 int bp_size = 0; 638 639 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL) 640 /* No breakpoints on this machine. */ 641 return target_read_memory (memaddr, myaddr, len); 642 643 ALL_BP_LOCATIONS (b) 644 { 645 if (b->owner->type == bp_none) 646 warning ("reading through apparently deleted breakpoint #%d?", 647 b->owner->number); 648 649 if (b->loc_type != bp_loc_software_breakpoint) 650 continue; 651 if (!b->inserted) 652 continue; 653 /* Addresses and length of the part of the breakpoint that 654 we need to copy. */ 655 /* XXXX The m68k, sh and h8300 have different local and remote 656 breakpoint values. BREAKPOINT_FROM_PC still manages to 657 correctly determine the breakpoints memory address and size 658 for these targets. */ 659 bp_addr = b->address; 660 bp_size = 0; 661 if (BREAKPOINT_FROM_PC (&bp_addr, &bp_size) == NULL) 662 continue; 663 if (bp_size == 0) 664 /* bp isn't valid */ 665 continue; 666 if (bp_addr + bp_size <= memaddr) 667 /* The breakpoint is entirely before the chunk of memory we 668 are reading. */ 669 continue; 670 if (bp_addr >= memaddr + len) 671 /* The breakpoint is entirely after the chunk of memory we are 672 reading. */ 673 continue; 674 /* Copy the breakpoint from the shadow contents, and recurse for 675 the things before and after. */ 676 { 677 /* Offset within shadow_contents. */ 678 int bptoffset = 0; 679 680 if (bp_addr < memaddr) 681 { 682 /* Only copy the second part of the breakpoint. */ 683 bp_size -= memaddr - bp_addr; 684 bptoffset = memaddr - bp_addr; 685 bp_addr = memaddr; 686 } 687 688 if (bp_addr + bp_size > memaddr + len) 689 { 690 /* Only copy the first part of the breakpoint. */ 691 bp_size -= (bp_addr + bp_size) - (memaddr + len); 692 } 693 694 memcpy (myaddr + bp_addr - memaddr, 695 b->shadow_contents + bptoffset, bp_size); 696 697 if (bp_addr > memaddr) 698 { 699 /* Copy the section of memory before the breakpoint. */ 700 status = deprecated_read_memory_nobpt (memaddr, myaddr, bp_addr - memaddr); 701 if (status != 0) 702 return status; 703 } 704 705 if (bp_addr + bp_size < memaddr + len) 706 { 707 /* Copy the section of memory after the breakpoint. */ 708 status = deprecated_read_memory_nobpt (bp_addr + bp_size, 709 myaddr + bp_addr + bp_size - memaddr, 710 memaddr + len - (bp_addr + bp_size)); 711 if (status != 0) 712 return status; 713 } 714 return 0; 715 } 716 } 717 /* Nothing overlaps. Just call read_memory_noerr. */ 718 return target_read_memory (memaddr, myaddr, len); 719} 720 721 722/* A wrapper function for inserting catchpoints. */ 723static int 724insert_catchpoint (struct ui_out *uo, void *args) 725{ 726 struct breakpoint *b = (struct breakpoint *) args; 727 int val = -1; 728 729 switch (b->type) 730 { 731 case bp_catch_fork: 732 val = target_insert_fork_catchpoint (PIDGET (inferior_ptid)); 733 break; 734 case bp_catch_vfork: 735 val = target_insert_vfork_catchpoint (PIDGET (inferior_ptid)); 736 break; 737 case bp_catch_exec: 738 val = target_insert_exec_catchpoint (PIDGET (inferior_ptid)); 739 break; 740 default: 741 internal_error (__FILE__, __LINE__, "unknown breakpoint type"); 742 break; 743 } 744 745 if (val < 0) 746 throw_exception (RETURN_ERROR); 747 748 return 0; 749} 750 751/* Helper routine: free the value chain for a breakpoint (watchpoint). */ 752 753static void free_valchain (struct bp_location *b) 754{ 755 struct value *v; 756 struct value *n; 757 758 /* Free the saved value chain. We will construct a new one 759 the next time the watchpoint is inserted. */ 760 for (v = b->owner->val_chain; v; v = n) 761 { 762 n = v->next; 763 value_free (v); 764 } 765 b->owner->val_chain = NULL; 766} 767 768/* Insert a low-level "breakpoint" of some type. BPT is the breakpoint. 769 Any error messages are printed to TMP_ERROR_STREAM; and DISABLED_BREAKS, 770 PROCESS_WARNING, and HW_BREAKPOINT_ERROR are used to report problems. 771 772 NOTE drow/2003-09-09: This routine could be broken down to an object-style 773 method for each breakpoint or catchpoint type. */ 774static int 775insert_bp_location (struct bp_location *bpt, 776 struct ui_file *tmp_error_stream, 777 int *disabled_breaks, int *process_warning, 778 int *hw_breakpoint_error) 779{ 780 int val = 0; 781 782 /* Permanent breakpoints cannot be inserted or removed. Disabled 783 breakpoints should not be inserted. */ 784 if (!breakpoint_enabled (bpt->owner)) 785 return 0; 786 787 if (bpt->inserted || bpt->duplicate) 788 return 0; 789 790 if (bpt->loc_type == bp_loc_software_breakpoint 791 || bpt->loc_type == bp_loc_hardware_breakpoint) 792 { 793 /* First check to see if we have to handle an overlay. */ 794 if (overlay_debugging == ovly_off 795 || bpt->section == NULL 796 || !(section_is_overlay (bpt->section))) 797 { 798 /* No overlay handling: just set the breakpoint. */ 799 800 if (bpt->loc_type == bp_loc_hardware_breakpoint) 801 val = target_insert_hw_breakpoint (bpt->address, 802 bpt->shadow_contents); 803 else 804 val = target_insert_breakpoint (bpt->address, 805 bpt->shadow_contents); 806 } 807 else 808 { 809 /* This breakpoint is in an overlay section. 810 Shall we set a breakpoint at the LMA? */ 811 if (!overlay_events_enabled) 812 { 813 /* Yes -- overlay event support is not active, 814 so we must try to set a breakpoint at the LMA. 815 This will not work for a hardware breakpoint. */ 816 if (bpt->loc_type == bp_loc_hardware_breakpoint) 817 warning ("hardware breakpoint %d not supported in overlay!\n", 818 bpt->owner->number); 819 else 820 { 821 CORE_ADDR addr = overlay_unmapped_address (bpt->address, 822 bpt->section); 823 /* Set a software (trap) breakpoint at the LMA. */ 824 val = target_insert_breakpoint (addr, bpt->shadow_contents); 825 if (val != 0) 826 fprintf_unfiltered (tmp_error_stream, 827 "Overlay breakpoint %d failed: in ROM?", 828 bpt->owner->number); 829 } 830 } 831 /* Shall we set a breakpoint at the VMA? */ 832 if (section_is_mapped (bpt->section)) 833 { 834 /* Yes. This overlay section is mapped into memory. */ 835 if (bpt->loc_type == bp_loc_hardware_breakpoint) 836 val = target_insert_hw_breakpoint (bpt->address, 837 bpt->shadow_contents); 838 else 839 val = target_insert_breakpoint (bpt->address, 840 bpt->shadow_contents); 841 } 842 else 843 { 844 /* No. This breakpoint will not be inserted. 845 No error, but do not mark the bp as 'inserted'. */ 846 return 0; 847 } 848 } 849 850 if (val) 851 { 852 /* Can't set the breakpoint. */ 853#if defined (DISABLE_UNSETTABLE_BREAK) 854 if (DISABLE_UNSETTABLE_BREAK (bpt->address)) 855 { 856 /* See also: disable_breakpoints_in_shlibs. */ 857 val = 0; 858 bpt->owner->enable_state = bp_shlib_disabled; 859 if (!*disabled_breaks) 860 { 861 fprintf_unfiltered (tmp_error_stream, 862 "Cannot insert breakpoint %d.\n", 863 bpt->owner->number); 864 fprintf_unfiltered (tmp_error_stream, 865 "Temporarily disabling shared library breakpoints:\n"); 866 } 867 *disabled_breaks = 1; 868 fprintf_unfiltered (tmp_error_stream, 869 "breakpoint #%d\n", bpt->owner->number); 870 } 871 else 872#endif 873 { 874#ifdef ONE_PROCESS_WRITETEXT 875 *process_warning = 1; 876#endif 877 if (bpt->loc_type == bp_loc_hardware_breakpoint) 878 { 879 *hw_breakpoint_error = 1; 880 fprintf_unfiltered (tmp_error_stream, 881 "Cannot insert hardware breakpoint %d.\n", 882 bpt->owner->number); 883 } 884 else 885 { 886 fprintf_unfiltered (tmp_error_stream, 887 "Cannot insert breakpoint %d.\n", 888 bpt->owner->number); 889 fprintf_filtered (tmp_error_stream, 890 "Error accessing memory address "); 891 print_address_numeric (bpt->address, 1, tmp_error_stream); 892 fprintf_filtered (tmp_error_stream, ": %s.\n", 893 safe_strerror (val)); 894 } 895 896 } 897 } 898 else 899 bpt->inserted = 1; 900 901 return val; 902 } 903 904 else if (bpt->loc_type == bp_loc_hardware_watchpoint 905 /* NOTE drow/2003-09-08: This state only exists for removing 906 watchpoints. It's not clear that it's necessary... */ 907 && bpt->owner->disposition != disp_del_at_next_stop) 908 { 909 /* FIXME drow/2003-09-08: This code sets multiple hardware watchpoints 910 based on the expression. Ideally this should happen at a higher level, 911 and there should be one bp_location for each computed address we 912 must watch. As soon as a many-to-one mapping is available I'll 913 convert this. */ 914 915 int within_current_scope; 916 struct value *mark = value_mark (); 917 struct value *v; 918 struct frame_id saved_frame_id; 919 920 /* Save the current frame's ID so we can restore it after 921 evaluating the watchpoint expression on its own frame. */ 922 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression 923 took a frame parameter, so that we didn't have to change the 924 selected frame. */ 925 saved_frame_id = get_frame_id (deprecated_selected_frame); 926 927 /* Determine if the watchpoint is within scope. */ 928 if (bpt->owner->exp_valid_block == NULL) 929 within_current_scope = 1; 930 else 931 { 932 struct frame_info *fi; 933 fi = frame_find_by_id (bpt->owner->watchpoint_frame); 934 within_current_scope = (fi != NULL); 935 if (within_current_scope) 936 select_frame (fi); 937 } 938 939 if (within_current_scope) 940 { 941 free_valchain (bpt); 942 943 /* Evaluate the expression and cut the chain of values 944 produced off from the value chain. 945 946 Make sure the value returned isn't lazy; we use 947 laziness to determine what memory GDB actually needed 948 in order to compute the value of the expression. */ 949 v = evaluate_expression (bpt->owner->exp); 950 VALUE_CONTENTS (v); 951 value_release_to_mark (mark); 952 953 bpt->owner->val_chain = v; 954 bpt->inserted = 1; 955 956 /* Look at each value on the value chain. */ 957 for (; v; v = v->next) 958 { 959 /* If it's a memory location, and GDB actually needed 960 its contents to evaluate the expression, then we 961 must watch it. */ 962 if (VALUE_LVAL (v) == lval_memory 963 && ! VALUE_LAZY (v)) 964 { 965 struct type *vtype = check_typedef (VALUE_TYPE (v)); 966 967 /* We only watch structs and arrays if user asked 968 for it explicitly, never if they just happen to 969 appear in the middle of some value chain. */ 970 if (v == bpt->owner->val_chain 971 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT 972 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY)) 973 { 974 CORE_ADDR addr; 975 int len, type; 976 977 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v); 978 len = TYPE_LENGTH (VALUE_TYPE (v)); 979 type = hw_write; 980 if (bpt->owner->type == bp_read_watchpoint) 981 type = hw_read; 982 else if (bpt->owner->type == bp_access_watchpoint) 983 type = hw_access; 984 985 val = target_insert_watchpoint (addr, len, type); 986 if (val == -1) 987 { 988 /* Don't exit the loop, try to insert 989 every value on the value chain. That's 990 because we will be removing all the 991 watches below, and removing a 992 watchpoint we didn't insert could have 993 adverse effects. */ 994 bpt->inserted = 0; 995 } 996 val = 0; 997 } 998 } 999 } 1000 /* Failure to insert a watchpoint on any memory value in the 1001 value chain brings us here. */ 1002 if (!bpt->inserted) 1003 { 1004 remove_breakpoint (bpt, mark_uninserted); 1005 *hw_breakpoint_error = 1; 1006 fprintf_unfiltered (tmp_error_stream, 1007 "Could not insert hardware watchpoint %d.\n", 1008 bpt->owner->number); 1009 val = -1; 1010 } 1011 } 1012 else 1013 { 1014 printf_filtered ("Hardware watchpoint %d deleted ", bpt->owner->number); 1015 printf_filtered ("because the program has left the block \n"); 1016 printf_filtered ("in which its expression is valid.\n"); 1017 if (bpt->owner->related_breakpoint) 1018 bpt->owner->related_breakpoint->disposition = disp_del_at_next_stop; 1019 bpt->owner->disposition = disp_del_at_next_stop; 1020 } 1021 1022 /* Restore the selected frame. */ 1023 select_frame (frame_find_by_id (saved_frame_id)); 1024 1025 return val; 1026 } 1027 1028 else if (ep_is_exception_catchpoint (bpt->owner)) 1029 { 1030 /* FIXME drow/2003-09-09: This code sets both a catchpoint and a 1031 breakpoint. Once again, it would be better if this was represented 1032 as two bp_locations. */ 1033 1034 /* If we get here, we must have a callback mechanism for exception 1035 events -- with g++ style embedded label support, we insert 1036 ordinary breakpoints and not catchpoints. */ 1037 val = target_insert_breakpoint (bpt->address, bpt->shadow_contents); 1038 if (val) 1039 { 1040 /* Couldn't set breakpoint for some reason */ 1041 fprintf_unfiltered (tmp_error_stream, 1042 "Cannot insert catchpoint %d; disabling it.\n", 1043 bpt->owner->number); 1044 fprintf_filtered (tmp_error_stream, 1045 "Error accessing memory address "); 1046 print_address_numeric (bpt->address, 1, tmp_error_stream); 1047 fprintf_filtered (tmp_error_stream, ": %s.\n", 1048 safe_strerror (val)); 1049 bpt->owner->enable_state = bp_disabled; 1050 } 1051 else 1052 { 1053 /* Bp set, now make sure callbacks are enabled */ 1054 /* Format possible error msg */ 1055 char *message = xstrprintf ("Error inserting catchpoint %d:\n", 1056 bpt->owner->number); 1057 struct cleanup *cleanups = make_cleanup (xfree, message); 1058 int val; 1059 args_for_catchpoint_enable args; 1060 args.kind = bpt->owner->type == bp_catch_catch ? 1061 EX_EVENT_CATCH : EX_EVENT_THROW; 1062 args.enable_p = 1; 1063 val = catch_errors (cover_target_enable_exception_callback, 1064 &args, message, RETURN_MASK_ALL); 1065 do_cleanups (cleanups); 1066 if (val != 0 && val != -1) 1067 bpt->inserted = 1; 1068 1069 /* Check if something went wrong; val == 0 can be ignored */ 1070 if (val == -1) 1071 { 1072 /* something went wrong */ 1073 fprintf_unfiltered (tmp_error_stream, 1074 "Cannot insert catchpoint %d; disabling it.\n", 1075 bpt->owner->number); 1076 bpt->owner->enable_state = bp_disabled; 1077 } 1078 } 1079 1080 return val; 1081 } 1082 1083 else if (bpt->owner->type == bp_catch_fork 1084 || bpt->owner->type == bp_catch_vfork 1085 || bpt->owner->type == bp_catch_exec) 1086 { 1087 char *prefix = xstrprintf ("warning: inserting catchpoint %d: ", 1088 bpt->owner->number); 1089 struct cleanup *cleanups = make_cleanup (xfree, prefix); 1090 val = catch_exceptions (uiout, insert_catchpoint, bpt->owner, prefix, 1091 RETURN_MASK_ERROR); 1092 do_cleanups (cleanups); 1093 if (val < 0) 1094 bpt->owner->enable_state = bp_disabled; 1095 else 1096 bpt->inserted = 1; 1097 1098 /* We've already printed an error message if there was a problem 1099 inserting this catchpoint, and we've disabled the catchpoint, 1100 so just return success. */ 1101 return 0; 1102 } 1103 1104 return 0; 1105} 1106 1107/* insert_breakpoints is used when starting or continuing the program. 1108 remove_breakpoints is used when the program stops. 1109 Both return zero if successful, 1110 or an `errno' value if could not write the inferior. */ 1111 1112int 1113insert_breakpoints (void) 1114{ 1115 struct bp_location *b, *temp; 1116 int return_val = 0; /* return success code. */ 1117 int val = 0; 1118 int disabled_breaks = 0; 1119 int hw_breakpoint_error = 0; 1120 int process_warning = 0; 1121 1122 struct ui_file *tmp_error_stream = mem_fileopen (); 1123 make_cleanup_ui_file_delete (tmp_error_stream); 1124 1125 /* Explicitly mark the warning -- this will only be printed if 1126 there was an error. */ 1127 fprintf_unfiltered (tmp_error_stream, "Warning:\n"); 1128 1129 ALL_BP_LOCATIONS_SAFE (b, temp) 1130 { 1131 /* Permanent breakpoints cannot be inserted or removed. Disabled 1132 breakpoints should not be inserted. */ 1133 if (!breakpoint_enabled (b->owner)) 1134 continue; 1135 1136 /* FIXME drow/2003-10-07: This code should be pushed elsewhere when 1137 hardware watchpoints are split into multiple loc breakpoints. */ 1138 if ((b->loc_type == bp_loc_hardware_watchpoint 1139 || b->owner->type == bp_watchpoint) && !b->owner->val) 1140 { 1141 struct value *val; 1142 val = evaluate_expression (b->owner->exp); 1143 release_value (val); 1144 if (VALUE_LAZY (val)) 1145 value_fetch_lazy (val); 1146 b->owner->val = val; 1147 } 1148 1149 val = insert_bp_location (b, tmp_error_stream, 1150 &disabled_breaks, &process_warning, 1151 &hw_breakpoint_error); 1152 if (val) 1153 return_val = val; 1154 } 1155 1156 if (return_val) 1157 { 1158 /* If a hardware breakpoint or watchpoint was inserted, add a 1159 message about possibly exhausted resources. */ 1160 if (hw_breakpoint_error) 1161 { 1162 fprintf_unfiltered (tmp_error_stream, 1163 "Could not insert hardware breakpoints:\n\ 1164You may have requested too many hardware breakpoints/watchpoints.\n"); 1165 } 1166#ifdef ONE_PROCESS_WRITETEXT 1167 if (process_warning) 1168 fprintf_unfiltered (tmp_error_stream, 1169 "The same program may be running in another process."); 1170#endif 1171 target_terminal_ours_for_output (); 1172 error_stream (tmp_error_stream); 1173 } 1174 return return_val; 1175} 1176 1177int 1178remove_breakpoints (void) 1179{ 1180 struct bp_location *b; 1181 int val; 1182 1183 ALL_BP_LOCATIONS (b) 1184 { 1185 if (b->inserted) 1186 { 1187 val = remove_breakpoint (b, mark_uninserted); 1188 if (val != 0) 1189 return val; 1190 } 1191 } 1192 return 0; 1193} 1194 1195int 1196remove_hw_watchpoints (void) 1197{ 1198 struct bp_location *b; 1199 int val; 1200 1201 ALL_BP_LOCATIONS (b) 1202 { 1203 if (b->inserted && b->loc_type == bp_loc_hardware_watchpoint) 1204 { 1205 val = remove_breakpoint (b, mark_uninserted); 1206 if (val != 0) 1207 return val; 1208 } 1209 } 1210 return 0; 1211} 1212 1213int 1214reattach_breakpoints (int pid) 1215{ 1216 struct bp_location *b; 1217 int val; 1218 struct cleanup *old_chain = save_inferior_ptid (); 1219 1220 /* Set inferior_ptid; remove_breakpoint uses this global. */ 1221 inferior_ptid = pid_to_ptid (pid); 1222 ALL_BP_LOCATIONS (b) 1223 { 1224 if (b->inserted) 1225 { 1226 remove_breakpoint (b, mark_inserted); 1227 if (b->loc_type == bp_loc_hardware_breakpoint) 1228 val = target_insert_hw_breakpoint (b->address, b->shadow_contents); 1229 else 1230 val = target_insert_breakpoint (b->address, b->shadow_contents); 1231 /* FIXME drow/2003-10-07: This doesn't handle any other kinds of 1232 breakpoints. It's wrong for watchpoints, for example. */ 1233 if (val != 0) 1234 { 1235 do_cleanups (old_chain); 1236 return val; 1237 } 1238 } 1239 } 1240 do_cleanups (old_chain); 1241 return 0; 1242} 1243 1244void 1245update_breakpoints_after_exec (void) 1246{ 1247 struct breakpoint *b; 1248 struct breakpoint *temp; 1249 1250 /* Doing this first prevents the badness of having delete_breakpoint() 1251 write a breakpoint's current "shadow contents" to lift the bp. That 1252 shadow is NOT valid after an exec()! */ 1253 mark_breakpoints_out (); 1254 1255 ALL_BREAKPOINTS_SAFE (b, temp) 1256 { 1257 /* Solib breakpoints must be explicitly reset after an exec(). */ 1258 if (b->type == bp_shlib_event) 1259 { 1260 delete_breakpoint (b); 1261 continue; 1262 } 1263 1264 /* Thread event breakpoints must be set anew after an exec(), 1265 as must overlay event breakpoints. */ 1266 if (b->type == bp_thread_event || b->type == bp_overlay_event) 1267 { 1268 delete_breakpoint (b); 1269 continue; 1270 } 1271 1272 /* Step-resume breakpoints are meaningless after an exec(). */ 1273 if (b->type == bp_step_resume) 1274 { 1275 delete_breakpoint (b); 1276 continue; 1277 } 1278 1279 /* Ditto the sigtramp handler breakpoints. */ 1280 if (b->type == bp_through_sigtramp) 1281 { 1282 delete_breakpoint (b); 1283 continue; 1284 } 1285 1286 /* Ditto the exception-handling catchpoints. */ 1287 if ((b->type == bp_catch_catch) || (b->type == bp_catch_throw)) 1288 { 1289 delete_breakpoint (b); 1290 continue; 1291 } 1292 1293 /* Don't delete an exec catchpoint, because else the inferior 1294 won't stop when it ought! 1295 1296 Similarly, we probably ought to keep vfork catchpoints, 'cause 1297 on this target, we may not be able to stop when the vfork is 1298 seen, but only when the subsequent exec is seen. (And because 1299 deleting fork catchpoints here but not vfork catchpoints will 1300 seem mysterious to users, keep those too.) 1301 1302 ??rehrauer: Let's hope that merely clearing out this catchpoint's 1303 target address field, if any, is sufficient to have it be reset 1304 automagically. Certainly on HP-UX that's true. 1305 1306 Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly 1307 valid code address on some platforms (like the mn10300 1308 simulators). We shouldn't assign any special interpretation to 1309 a breakpoint with a zero address. And in fact, GDB doesn't --- 1310 I can't see what that comment above is talking about. As far 1311 as I can tell, setting the address of a 1312 bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero 1313 is meaningless, since those are implemented with HP-UX kernel 1314 hackery, not by storing breakpoint instructions somewhere. */ 1315 if ((b->type == bp_catch_exec) || 1316 (b->type == bp_catch_vfork) || 1317 (b->type == bp_catch_fork)) 1318 { 1319 b->loc->address = (CORE_ADDR) NULL; 1320 continue; 1321 } 1322 1323 /* bp_finish is a special case. The only way we ought to be able 1324 to see one of these when an exec() has happened, is if the user 1325 caught a vfork, and then said "finish". Ordinarily a finish just 1326 carries them to the call-site of the current callee, by setting 1327 a temporary bp there and resuming. But in this case, the finish 1328 will carry them entirely through the vfork & exec. 1329 1330 We don't want to allow a bp_finish to remain inserted now. But 1331 we can't safely delete it, 'cause finish_command has a handle to 1332 the bp on a bpstat, and will later want to delete it. There's a 1333 chance (and I've seen it happen) that if we delete the bp_finish 1334 here, that its storage will get reused by the time finish_command 1335 gets 'round to deleting the "use to be a bp_finish" breakpoint. 1336 We really must allow finish_command to delete a bp_finish. 1337 1338 In the absense of a general solution for the "how do we know 1339 it's safe to delete something others may have handles to?" 1340 problem, what we'll do here is just uninsert the bp_finish, and 1341 let finish_command delete it. 1342 1343 (We know the bp_finish is "doomed" in the sense that it's 1344 momentary, and will be deleted as soon as finish_command sees 1345 the inferior stopped. So it doesn't matter that the bp's 1346 address is probably bogus in the new a.out, unlike e.g., the 1347 solib breakpoints.) */ 1348 1349 if (b->type == bp_finish) 1350 { 1351 continue; 1352 } 1353 1354 /* Without a symbolic address, we have little hope of the 1355 pre-exec() address meaning the same thing in the post-exec() 1356 a.out. */ 1357 if (b->addr_string == NULL) 1358 { 1359 delete_breakpoint (b); 1360 continue; 1361 } 1362 1363 /* If this breakpoint has survived the above battery of checks, then 1364 it must have a symbolic address. Be sure that it gets reevaluated 1365 to a target address, rather than reusing the old evaluation. 1366 1367 Jim Blandy <jimb@redhat.com>: As explained above in the comment 1368 for bp_catch_exec and friends, I'm pretty sure this is entirely 1369 unnecessary. A call to breakpoint_re_set_one always recomputes 1370 the breakpoint's address from scratch, or deletes it if it can't. 1371 So I think this assignment could be deleted without effect. */ 1372 b->loc->address = (CORE_ADDR) NULL; 1373 } 1374 /* FIXME what about longjmp breakpoints? Re-create them here? */ 1375 create_overlay_event_breakpoint ("_ovly_debug_event"); 1376} 1377 1378int 1379detach_breakpoints (int pid) 1380{ 1381 struct bp_location *b; 1382 int val; 1383 struct cleanup *old_chain = save_inferior_ptid (); 1384 1385 if (pid == PIDGET (inferior_ptid)) 1386 error ("Cannot detach breakpoints of inferior_ptid"); 1387 1388 /* Set inferior_ptid; remove_breakpoint uses this global. */ 1389 inferior_ptid = pid_to_ptid (pid); 1390 ALL_BP_LOCATIONS (b) 1391 { 1392 if (b->inserted) 1393 { 1394 val = remove_breakpoint (b, mark_inserted); 1395 if (val != 0) 1396 { 1397 do_cleanups (old_chain); 1398 return val; 1399 } 1400 } 1401 } 1402 do_cleanups (old_chain); 1403 return 0; 1404} 1405 1406static int 1407remove_breakpoint (struct bp_location *b, insertion_state_t is) 1408{ 1409 int val; 1410 1411 if (b->owner->enable_state == bp_permanent) 1412 /* Permanent breakpoints cannot be inserted or removed. */ 1413 return 0; 1414 1415 if (b->owner->type == bp_none) 1416 warning ("attempted to remove apparently deleted breakpoint #%d?", 1417 b->owner->number); 1418 1419 if (b->loc_type == bp_loc_software_breakpoint 1420 || b->loc_type == bp_loc_hardware_breakpoint) 1421 { 1422 /* "Normal" instruction breakpoint: either the standard 1423 trap-instruction bp (bp_breakpoint), or a 1424 bp_hardware_breakpoint. */ 1425 1426 /* First check to see if we have to handle an overlay. */ 1427 if (overlay_debugging == ovly_off 1428 || b->section == NULL 1429 || !(section_is_overlay (b->section))) 1430 { 1431 /* No overlay handling: just remove the breakpoint. */ 1432 1433 if (b->loc_type == bp_loc_hardware_breakpoint) 1434 val = target_remove_hw_breakpoint (b->address, 1435 b->shadow_contents); 1436 else 1437 val = target_remove_breakpoint (b->address, b->shadow_contents); 1438 } 1439 else 1440 { 1441 /* This breakpoint is in an overlay section. 1442 Did we set a breakpoint at the LMA? */ 1443 if (!overlay_events_enabled) 1444 { 1445 /* Yes -- overlay event support is not active, so we 1446 should have set a breakpoint at the LMA. Remove it. 1447 */ 1448 CORE_ADDR addr = overlay_unmapped_address (b->address, 1449 b->section); 1450 /* Ignore any failures: if the LMA is in ROM, we will 1451 have already warned when we failed to insert it. */ 1452 if (b->loc_type == bp_loc_hardware_breakpoint) 1453 target_remove_hw_breakpoint (addr, b->shadow_contents); 1454 else 1455 target_remove_breakpoint (addr, b->shadow_contents); 1456 } 1457 /* Did we set a breakpoint at the VMA? 1458 If so, we will have marked the breakpoint 'inserted'. */ 1459 if (b->inserted) 1460 { 1461 /* Yes -- remove it. Previously we did not bother to 1462 remove the breakpoint if the section had been 1463 unmapped, but let's not rely on that being safe. We 1464 don't know what the overlay manager might do. */ 1465 if (b->loc_type == bp_loc_hardware_breakpoint) 1466 val = target_remove_hw_breakpoint (b->address, 1467 b->shadow_contents); 1468 else 1469 val = target_remove_breakpoint (b->address, 1470 b->shadow_contents); 1471 } 1472 else 1473 { 1474 /* No -- not inserted, so no need to remove. No error. */ 1475 val = 0; 1476 } 1477 } 1478 if (val) 1479 return val; 1480 b->inserted = (is == mark_inserted); 1481 } 1482 else if (b->loc_type == bp_loc_hardware_watchpoint 1483 && breakpoint_enabled (b->owner) 1484 && !b->duplicate) 1485 { 1486 struct value *v; 1487 struct value *n; 1488 1489 b->inserted = (is == mark_inserted); 1490 /* Walk down the saved value chain. */ 1491 for (v = b->owner->val_chain; v; v = v->next) 1492 { 1493 /* For each memory reference remove the watchpoint 1494 at that address. */ 1495 if (VALUE_LVAL (v) == lval_memory 1496 && ! VALUE_LAZY (v)) 1497 { 1498 struct type *vtype = check_typedef (VALUE_TYPE (v)); 1499 1500 if (v == b->owner->val_chain 1501 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT 1502 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY)) 1503 { 1504 CORE_ADDR addr; 1505 int len, type; 1506 1507 addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v); 1508 len = TYPE_LENGTH (VALUE_TYPE (v)); 1509 type = hw_write; 1510 if (b->owner->type == bp_read_watchpoint) 1511 type = hw_read; 1512 else if (b->owner->type == bp_access_watchpoint) 1513 type = hw_access; 1514 1515 val = target_remove_watchpoint (addr, len, type); 1516 if (val == -1) 1517 b->inserted = 1; 1518 val = 0; 1519 } 1520 } 1521 } 1522 /* Failure to remove any of the hardware watchpoints comes here. */ 1523 if ((is == mark_uninserted) && (b->inserted)) 1524 warning ("Could not remove hardware watchpoint %d.", 1525 b->owner->number); 1526 } 1527 else if ((b->owner->type == bp_catch_fork || 1528 b->owner->type == bp_catch_vfork || 1529 b->owner->type == bp_catch_exec) 1530 && breakpoint_enabled (b->owner) 1531 && !b->duplicate) 1532 { 1533 val = -1; 1534 switch (b->owner->type) 1535 { 1536 case bp_catch_fork: 1537 val = target_remove_fork_catchpoint (PIDGET (inferior_ptid)); 1538 break; 1539 case bp_catch_vfork: 1540 val = target_remove_vfork_catchpoint (PIDGET (inferior_ptid)); 1541 break; 1542 case bp_catch_exec: 1543 val = target_remove_exec_catchpoint (PIDGET (inferior_ptid)); 1544 break; 1545 default: 1546 warning ("Internal error, %s line %d.", __FILE__, __LINE__); 1547 break; 1548 } 1549 if (val) 1550 return val; 1551 b->inserted = (is == mark_inserted); 1552 } 1553 else if ((b->owner->type == bp_catch_catch || 1554 b->owner->type == bp_catch_throw) 1555 && breakpoint_enabled (b->owner) 1556 && !b->duplicate) 1557 { 1558 1559 val = target_remove_breakpoint (b->address, b->shadow_contents); 1560 if (val) 1561 return val; 1562 b->inserted = (is == mark_inserted); 1563 } 1564 else if (ep_is_exception_catchpoint (b->owner) 1565 && b->inserted /* sometimes previous insert doesn't happen */ 1566 && breakpoint_enabled (b->owner) 1567 && !b->duplicate) 1568 { 1569 1570 val = target_remove_breakpoint (b->address, b->shadow_contents); 1571 if (val) 1572 return val; 1573 1574 b->inserted = (is == mark_inserted); 1575 } 1576 1577 return 0; 1578} 1579 1580/* Clear the "inserted" flag in all breakpoints. */ 1581 1582void 1583mark_breakpoints_out (void) 1584{ 1585 struct bp_location *bpt; 1586 1587 ALL_BP_LOCATIONS (bpt) 1588 bpt->inserted = 0; 1589} 1590 1591/* Clear the "inserted" flag in all breakpoints and delete any 1592 breakpoints which should go away between runs of the program. 1593 1594 Plus other such housekeeping that has to be done for breakpoints 1595 between runs. 1596 1597 Note: this function gets called at the end of a run (by 1598 generic_mourn_inferior) and when a run begins (by 1599 init_wait_for_inferior). */ 1600 1601 1602 1603void 1604breakpoint_init_inferior (enum inf_context context) 1605{ 1606 struct breakpoint *b, *temp; 1607 struct bp_location *bpt; 1608 static int warning_needed = 0; 1609 1610 ALL_BP_LOCATIONS (bpt) 1611 bpt->inserted = 0; 1612 1613 ALL_BREAKPOINTS_SAFE (b, temp) 1614 { 1615 switch (b->type) 1616 { 1617 case bp_call_dummy: 1618 case bp_watchpoint_scope: 1619 1620 /* If the call dummy breakpoint is at the entry point it will 1621 cause problems when the inferior is rerun, so we better 1622 get rid of it. 1623 1624 Also get rid of scope breakpoints. */ 1625 delete_breakpoint (b); 1626 break; 1627 1628 case bp_watchpoint: 1629 case bp_hardware_watchpoint: 1630 case bp_read_watchpoint: 1631 case bp_access_watchpoint: 1632 1633 /* Likewise for watchpoints on local expressions. */ 1634 if (b->exp_valid_block != NULL) 1635 delete_breakpoint (b); 1636 if (context == inf_starting) 1637 { 1638 /* Reset val field to force reread of starting value 1639 in insert_breakpoints. */ 1640 if (b->val) 1641 value_free (b->val); 1642 b->val = NULL; 1643 } 1644 break; 1645 default: 1646 /* Likewise for exception catchpoints in dynamic-linked 1647 executables where required */ 1648 if (ep_is_exception_catchpoint (b) 1649 && deprecated_exception_catchpoints_are_fragile) 1650 { 1651 warning_needed = 1; 1652 delete_breakpoint (b); 1653 } 1654 break; 1655 } 1656 } 1657 1658 if (deprecated_exception_catchpoints_are_fragile) 1659 deprecated_exception_support_initialized = 0; 1660 1661 /* Don't issue the warning unless it's really needed... */ 1662 if (warning_needed && (context != inf_exited)) 1663 { 1664 warning ("Exception catchpoints from last run were deleted."); 1665 warning ("You must reinsert them explicitly."); 1666 warning_needed = 0; 1667 } 1668} 1669 1670/* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint 1671 exists at PC. It returns ordinary_breakpoint_here if it's an 1672 ordinary breakpoint, or permanent_breakpoint_here if it's a 1673 permanent breakpoint. 1674 - When continuing from a location with an ordinary breakpoint, we 1675 actually single step once before calling insert_breakpoints. 1676 - When continuing from a localion with a permanent breakpoint, we 1677 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by 1678 the target, to advance the PC past the breakpoint. */ 1679 1680enum breakpoint_here 1681breakpoint_here_p (CORE_ADDR pc) 1682{ 1683 struct bp_location *bpt; 1684 int any_breakpoint_here = 0; 1685 1686 ALL_BP_LOCATIONS (bpt) 1687 { 1688 if (bpt->loc_type != bp_loc_software_breakpoint 1689 && bpt->loc_type != bp_loc_hardware_breakpoint) 1690 continue; 1691 1692 if ((breakpoint_enabled (bpt->owner) 1693 || bpt->owner->enable_state == bp_permanent) 1694 && bpt->address == pc) /* bp is enabled and matches pc */ 1695 { 1696 if (overlay_debugging 1697 && section_is_overlay (bpt->section) 1698 && !section_is_mapped (bpt->section)) 1699 continue; /* unmapped overlay -- can't be a match */ 1700 else if (bpt->owner->enable_state == bp_permanent) 1701 return permanent_breakpoint_here; 1702 else 1703 any_breakpoint_here = 1; 1704 } 1705 } 1706 1707 return any_breakpoint_here ? ordinary_breakpoint_here : 0; 1708} 1709 1710 1711/* breakpoint_inserted_here_p (PC) is just like breakpoint_here_p(), 1712 but it only returns true if there is actually a breakpoint inserted 1713 at PC. */ 1714 1715int 1716breakpoint_inserted_here_p (CORE_ADDR pc) 1717{ 1718 struct bp_location *bpt; 1719 1720 ALL_BP_LOCATIONS (bpt) 1721 { 1722 if (bpt->loc_type != bp_loc_software_breakpoint 1723 && bpt->loc_type != bp_loc_hardware_breakpoint) 1724 continue; 1725 1726 if (bpt->inserted 1727 && bpt->address == pc) /* bp is inserted and matches pc */ 1728 { 1729 if (overlay_debugging 1730 && section_is_overlay (bpt->section) 1731 && !section_is_mapped (bpt->section)) 1732 continue; /* unmapped overlay -- can't be a match */ 1733 else 1734 return 1; 1735 } 1736 } 1737 1738 return 0; 1739} 1740 1741/* This function returns non-zero iff there is a software breakpoint 1742 inserted at PC. */ 1743 1744int 1745software_breakpoint_inserted_here_p (CORE_ADDR pc) 1746{ 1747 struct bp_location *bpt; 1748 int any_breakpoint_here = 0; 1749 1750 ALL_BP_LOCATIONS (bpt) 1751 { 1752 if (bpt->loc_type != bp_loc_software_breakpoint) 1753 continue; 1754 1755 if ((breakpoint_enabled (bpt->owner) 1756 || bpt->owner->enable_state == bp_permanent) 1757 && bpt->inserted 1758 && bpt->address == pc) /* bp is enabled and matches pc */ 1759 { 1760 if (overlay_debugging 1761 && section_is_overlay (bpt->section) 1762 && !section_is_mapped (bpt->section)) 1763 continue; /* unmapped overlay -- can't be a match */ 1764 else 1765 return 1; 1766 } 1767 } 1768 1769 return 0; 1770} 1771 1772/* breakpoint_thread_match (PC, PTID) returns true if the breakpoint at 1773 PC is valid for process/thread PTID. */ 1774 1775int 1776breakpoint_thread_match (CORE_ADDR pc, ptid_t ptid) 1777{ 1778 struct bp_location *bpt; 1779 int thread; 1780 1781 thread = pid_to_thread_id (ptid); 1782 1783 ALL_BP_LOCATIONS (bpt) 1784 { 1785 if (bpt->loc_type != bp_loc_software_breakpoint 1786 && bpt->loc_type != bp_loc_hardware_breakpoint) 1787 continue; 1788 1789 if ((breakpoint_enabled (bpt->owner) 1790 || bpt->owner->enable_state == bp_permanent) 1791 && bpt->address == pc 1792 && (bpt->owner->thread == -1 || bpt->owner->thread == thread)) 1793 { 1794 if (overlay_debugging 1795 && section_is_overlay (bpt->section) 1796 && !section_is_mapped (bpt->section)) 1797 continue; /* unmapped overlay -- can't be a match */ 1798 else 1799 return 1; 1800 } 1801 } 1802 1803 return 0; 1804} 1805 1806 1807/* bpstat stuff. External routines' interfaces are documented 1808 in breakpoint.h. */ 1809 1810int 1811ep_is_catchpoint (struct breakpoint *ep) 1812{ 1813 return 1814 (ep->type == bp_catch_load) 1815 || (ep->type == bp_catch_unload) 1816 || (ep->type == bp_catch_fork) 1817 || (ep->type == bp_catch_vfork) 1818 || (ep->type == bp_catch_exec) 1819 || (ep->type == bp_catch_catch) 1820 || (ep->type == bp_catch_throw); 1821 1822 /* ??rehrauer: Add more kinds here, as are implemented... */ 1823} 1824 1825int 1826ep_is_shlib_catchpoint (struct breakpoint *ep) 1827{ 1828 return 1829 (ep->type == bp_catch_load) 1830 || (ep->type == bp_catch_unload); 1831} 1832 1833int 1834ep_is_exception_catchpoint (struct breakpoint *ep) 1835{ 1836 return 1837 (ep->type == bp_catch_catch) 1838 || (ep->type == bp_catch_throw); 1839} 1840 1841/* Clear a bpstat so that it says we are not at any breakpoint. 1842 Also free any storage that is part of a bpstat. */ 1843 1844void 1845bpstat_clear (bpstat *bsp) 1846{ 1847 bpstat p; 1848 bpstat q; 1849 1850 if (bsp == 0) 1851 return; 1852 p = *bsp; 1853 while (p != NULL) 1854 { 1855 q = p->next; 1856 if (p->old_val != NULL) 1857 value_free (p->old_val); 1858 free_command_lines (&p->commands); 1859 xfree (p); 1860 p = q; 1861 } 1862 *bsp = NULL; 1863} 1864 1865/* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that 1866 is part of the bpstat is copied as well. */ 1867 1868bpstat 1869bpstat_copy (bpstat bs) 1870{ 1871 bpstat p = NULL; 1872 bpstat tmp; 1873 bpstat retval = NULL; 1874 1875 if (bs == NULL) 1876 return bs; 1877 1878 for (; bs != NULL; bs = bs->next) 1879 { 1880 tmp = (bpstat) xmalloc (sizeof (*tmp)); 1881 memcpy (tmp, bs, sizeof (*tmp)); 1882 if (bs->commands != NULL) 1883 tmp->commands = copy_command_lines (bs->commands); 1884 if (bs->old_val != NULL) 1885 tmp->old_val = value_copy (bs->old_val); 1886 1887 if (p == NULL) 1888 /* This is the first thing in the chain. */ 1889 retval = tmp; 1890 else 1891 p->next = tmp; 1892 p = tmp; 1893 } 1894 p->next = NULL; 1895 return retval; 1896} 1897 1898/* Find the bpstat associated with this breakpoint */ 1899 1900bpstat 1901bpstat_find_breakpoint (bpstat bsp, struct breakpoint *breakpoint) 1902{ 1903 if (bsp == NULL) 1904 return NULL; 1905 1906 for (; bsp != NULL; bsp = bsp->next) 1907 { 1908 if (bsp->breakpoint_at == breakpoint) 1909 return bsp; 1910 } 1911 return NULL; 1912} 1913 1914/* Find a step_resume breakpoint associated with this bpstat. 1915 (If there are multiple step_resume bp's on the list, this function 1916 will arbitrarily pick one.) 1917 1918 It is an error to use this function if BPSTAT doesn't contain a 1919 step_resume breakpoint. 1920 1921 See wait_for_inferior's use of this function. */ 1922struct breakpoint * 1923bpstat_find_step_resume_breakpoint (bpstat bsp) 1924{ 1925 int current_thread; 1926 1927 if (bsp == NULL) 1928 error ("Internal error (bpstat_find_step_resume_breakpoint)"); 1929 1930 current_thread = pid_to_thread_id (inferior_ptid); 1931 1932 for (; bsp != NULL; bsp = bsp->next) 1933 { 1934 if ((bsp->breakpoint_at != NULL) && 1935 (bsp->breakpoint_at->type == bp_step_resume) && 1936 (bsp->breakpoint_at->thread == current_thread || 1937 bsp->breakpoint_at->thread == -1)) 1938 return bsp->breakpoint_at; 1939 } 1940 1941 error ("Internal error (no step_resume breakpoint found)"); 1942} 1943 1944 1945/* Return the breakpoint number of the first breakpoint we are stopped 1946 at. *BSP upon return is a bpstat which points to the remaining 1947 breakpoints stopped at (but which is not guaranteed to be good for 1948 anything but further calls to bpstat_num). 1949 Return 0 if passed a bpstat which does not indicate any breakpoints. */ 1950 1951int 1952bpstat_num (bpstat *bsp) 1953{ 1954 struct breakpoint *b; 1955 1956 if ((*bsp) == NULL) 1957 return 0; /* No more breakpoint values */ 1958 else 1959 { 1960 b = (*bsp)->breakpoint_at; 1961 *bsp = (*bsp)->next; 1962 if (b == NULL) 1963 return -1; /* breakpoint that's been deleted since */ 1964 else 1965 return b->number; /* We have its number */ 1966 } 1967} 1968 1969/* Modify BS so that the actions will not be performed. */ 1970 1971void 1972bpstat_clear_actions (bpstat bs) 1973{ 1974 for (; bs != NULL; bs = bs->next) 1975 { 1976 free_command_lines (&bs->commands); 1977 if (bs->old_val != NULL) 1978 { 1979 value_free (bs->old_val); 1980 bs->old_val = NULL; 1981 } 1982 } 1983} 1984 1985/* Stub for cleaning up our state if we error-out of a breakpoint command */ 1986static void 1987cleanup_executing_breakpoints (void *ignore) 1988{ 1989 executing_breakpoint_commands = 0; 1990} 1991 1992/* Execute all the commands associated with all the breakpoints at this 1993 location. Any of these commands could cause the process to proceed 1994 beyond this point, etc. We look out for such changes by checking 1995 the global "breakpoint_proceeded" after each command. */ 1996 1997void 1998bpstat_do_actions (bpstat *bsp) 1999{ 2000 bpstat bs; 2001 struct cleanup *old_chain; 2002 2003 /* Avoid endless recursion if a `source' command is contained 2004 in bs->commands. */ 2005 if (executing_breakpoint_commands) 2006 return; 2007 2008 executing_breakpoint_commands = 1; 2009 old_chain = make_cleanup (cleanup_executing_breakpoints, 0); 2010 2011top: 2012 /* Note that (as of this writing), our callers all appear to 2013 be passing us the address of global stop_bpstat. And, if 2014 our calls to execute_control_command cause the inferior to 2015 proceed, that global (and hence, *bsp) will change. 2016 2017 We must be careful to not touch *bsp unless the inferior 2018 has not proceeded. */ 2019 2020 /* This pointer will iterate over the list of bpstat's. */ 2021 bs = *bsp; 2022 2023 breakpoint_proceeded = 0; 2024 for (; bs != NULL; bs = bs->next) 2025 { 2026 struct command_line *cmd; 2027 struct cleanup *this_cmd_tree_chain; 2028 2029 /* Take ownership of the BSP's command tree, if it has one. 2030 2031 The command tree could legitimately contain commands like 2032 'step' and 'next', which call clear_proceed_status, which 2033 frees stop_bpstat's command tree. To make sure this doesn't 2034 free the tree we're executing out from under us, we need to 2035 take ownership of the tree ourselves. Since a given bpstat's 2036 commands are only executed once, we don't need to copy it; we 2037 can clear the pointer in the bpstat, and make sure we free 2038 the tree when we're done. */ 2039 cmd = bs->commands; 2040 bs->commands = 0; 2041 this_cmd_tree_chain = make_cleanup_free_command_lines (&cmd); 2042 2043 while (cmd != NULL) 2044 { 2045 execute_control_command (cmd); 2046 2047 if (breakpoint_proceeded) 2048 break; 2049 else 2050 cmd = cmd->next; 2051 } 2052 2053 /* We can free this command tree now. */ 2054 do_cleanups (this_cmd_tree_chain); 2055 2056 if (breakpoint_proceeded) 2057 /* The inferior is proceeded by the command; bomb out now. 2058 The bpstat chain has been blown away by wait_for_inferior. 2059 But since execution has stopped again, there is a new bpstat 2060 to look at, so start over. */ 2061 goto top; 2062 } 2063 do_cleanups (old_chain); 2064} 2065 2066/* This is the normal print function for a bpstat. In the future, 2067 much of this logic could (should?) be moved to bpstat_stop_status, 2068 by having it set different print_it values. 2069 2070 Current scheme: When we stop, bpstat_print() is called. It loops 2071 through the bpstat list of things causing this stop, calling the 2072 print_bp_stop_message function on each one. The behavior of the 2073 print_bp_stop_message function depends on the print_it field of 2074 bpstat. If such field so indicates, call this function here. 2075 2076 Return values from this routine (ultimately used by bpstat_print() 2077 and normal_stop() to decide what to do): 2078 PRINT_NOTHING: Means we already printed all we needed to print, 2079 don't print anything else. 2080 PRINT_SRC_ONLY: Means we printed something, and we do *not* desire 2081 that something to be followed by a location. 2082 PRINT_SCR_AND_LOC: Means we printed something, and we *do* desire 2083 that something to be followed by a location. 2084 PRINT_UNKNOWN: Means we printed nothing or we need to do some more 2085 analysis. */ 2086 2087static enum print_stop_action 2088print_it_typical (bpstat bs) 2089{ 2090 struct cleanup *old_chain, *ui_out_chain; 2091 struct ui_stream *stb; 2092 stb = ui_out_stream_new (uiout); 2093 old_chain = make_cleanup_ui_out_stream_delete (stb); 2094 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint 2095 which has since been deleted. */ 2096 if (bs->breakpoint_at == NULL) 2097 return PRINT_UNKNOWN; 2098 2099 switch (bs->breakpoint_at->type) 2100 { 2101 case bp_breakpoint: 2102 case bp_hardware_breakpoint: 2103 if (bs->breakpoint_at->loc->address != bs->breakpoint_at->loc->requested_address) 2104 breakpoint_adjustment_warning (bs->breakpoint_at->loc->requested_address, 2105 bs->breakpoint_at->loc->address, 2106 bs->breakpoint_at->number, 1); 2107 annotate_breakpoint (bs->breakpoint_at->number); 2108 ui_out_text (uiout, "\nBreakpoint "); 2109 if (ui_out_is_mi_like_p (uiout)) 2110 ui_out_field_string (uiout, "reason", "breakpoint-hit"); 2111 ui_out_field_int (uiout, "bkptno", bs->breakpoint_at->number); 2112 ui_out_text (uiout, ", "); 2113 return PRINT_SRC_AND_LOC; 2114 break; 2115 2116 case bp_shlib_event: 2117 /* Did we stop because the user set the stop_on_solib_events 2118 variable? (If so, we report this as a generic, "Stopped due 2119 to shlib event" message.) */ 2120 printf_filtered ("Stopped due to shared library event\n"); 2121 return PRINT_NOTHING; 2122 break; 2123 2124 case bp_thread_event: 2125 /* Not sure how we will get here. 2126 GDB should not stop for these breakpoints. */ 2127 printf_filtered ("Thread Event Breakpoint: gdb should not stop!\n"); 2128 return PRINT_NOTHING; 2129 break; 2130 2131 case bp_overlay_event: 2132 /* By analogy with the thread event, GDB should not stop for these. */ 2133 printf_filtered ("Overlay Event Breakpoint: gdb should not stop!\n"); 2134 return PRINT_NOTHING; 2135 break; 2136 2137 case bp_catch_load: 2138 annotate_catchpoint (bs->breakpoint_at->number); 2139 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number); 2140 printf_filtered ("loaded"); 2141 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname); 2142 return PRINT_SRC_AND_LOC; 2143 break; 2144 2145 case bp_catch_unload: 2146 annotate_catchpoint (bs->breakpoint_at->number); 2147 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number); 2148 printf_filtered ("unloaded"); 2149 printf_filtered (" %s), ", bs->breakpoint_at->triggered_dll_pathname); 2150 return PRINT_SRC_AND_LOC; 2151 break; 2152 2153 case bp_catch_fork: 2154 annotate_catchpoint (bs->breakpoint_at->number); 2155 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number); 2156 printf_filtered ("forked"); 2157 printf_filtered (" process %d), ", 2158 bs->breakpoint_at->forked_inferior_pid); 2159 return PRINT_SRC_AND_LOC; 2160 break; 2161 2162 case bp_catch_vfork: 2163 annotate_catchpoint (bs->breakpoint_at->number); 2164 printf_filtered ("\nCatchpoint %d (", bs->breakpoint_at->number); 2165 printf_filtered ("vforked"); 2166 printf_filtered (" process %d), ", 2167 bs->breakpoint_at->forked_inferior_pid); 2168 return PRINT_SRC_AND_LOC; 2169 break; 2170 2171 case bp_catch_exec: 2172 annotate_catchpoint (bs->breakpoint_at->number); 2173 printf_filtered ("\nCatchpoint %d (exec'd %s), ", 2174 bs->breakpoint_at->number, 2175 bs->breakpoint_at->exec_pathname); 2176 return PRINT_SRC_AND_LOC; 2177 break; 2178 2179 case bp_catch_catch: 2180 if (current_exception_event && 2181 (CURRENT_EXCEPTION_KIND == EX_EVENT_CATCH)) 2182 { 2183 annotate_catchpoint (bs->breakpoint_at->number); 2184 printf_filtered ("\nCatchpoint %d (exception caught), ", 2185 bs->breakpoint_at->number); 2186 printf_filtered ("throw location "); 2187 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE) 2188 printf_filtered ("%s:%d", 2189 CURRENT_EXCEPTION_THROW_FILE, 2190 CURRENT_EXCEPTION_THROW_LINE); 2191 else 2192 printf_filtered ("unknown"); 2193 2194 printf_filtered (", catch location "); 2195 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE) 2196 printf_filtered ("%s:%d", 2197 CURRENT_EXCEPTION_CATCH_FILE, 2198 CURRENT_EXCEPTION_CATCH_LINE); 2199 else 2200 printf_filtered ("unknown"); 2201 2202 printf_filtered ("\n"); 2203 /* don't bother to print location frame info */ 2204 return PRINT_SRC_ONLY; 2205 } 2206 else 2207 { 2208 /* really throw, some other bpstat will handle it */ 2209 return PRINT_UNKNOWN; 2210 } 2211 break; 2212 2213 case bp_catch_throw: 2214 if (current_exception_event && 2215 (CURRENT_EXCEPTION_KIND == EX_EVENT_THROW)) 2216 { 2217 annotate_catchpoint (bs->breakpoint_at->number); 2218 printf_filtered ("\nCatchpoint %d (exception thrown), ", 2219 bs->breakpoint_at->number); 2220 printf_filtered ("throw location "); 2221 if (CURRENT_EXCEPTION_THROW_PC && CURRENT_EXCEPTION_THROW_LINE) 2222 printf_filtered ("%s:%d", 2223 CURRENT_EXCEPTION_THROW_FILE, 2224 CURRENT_EXCEPTION_THROW_LINE); 2225 else 2226 printf_filtered ("unknown"); 2227 2228 printf_filtered (", catch location "); 2229 if (CURRENT_EXCEPTION_CATCH_PC && CURRENT_EXCEPTION_CATCH_LINE) 2230 printf_filtered ("%s:%d", 2231 CURRENT_EXCEPTION_CATCH_FILE, 2232 CURRENT_EXCEPTION_CATCH_LINE); 2233 else 2234 printf_filtered ("unknown"); 2235 2236 printf_filtered ("\n"); 2237 /* don't bother to print location frame info */ 2238 return PRINT_SRC_ONLY; 2239 } 2240 else 2241 { 2242 /* really catch, some other bpstat will handle it */ 2243 return PRINT_UNKNOWN; 2244 } 2245 break; 2246 2247 case bp_watchpoint: 2248 case bp_hardware_watchpoint: 2249 if (bs->old_val != NULL) 2250 { 2251 annotate_watchpoint (bs->breakpoint_at->number); 2252 if (ui_out_is_mi_like_p (uiout)) 2253 ui_out_field_string (uiout, "reason", "watchpoint-trigger"); 2254 mention (bs->breakpoint_at); 2255 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value"); 2256 ui_out_text (uiout, "\nOld value = "); 2257 value_print (bs->old_val, stb->stream, 0, Val_pretty_default); 2258 ui_out_field_stream (uiout, "old", stb); 2259 ui_out_text (uiout, "\nNew value = "); 2260 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default); 2261 ui_out_field_stream (uiout, "new", stb); 2262 do_cleanups (ui_out_chain); 2263 ui_out_text (uiout, "\n"); 2264 value_free (bs->old_val); 2265 bs->old_val = NULL; 2266 } 2267 /* More than one watchpoint may have been triggered. */ 2268 return PRINT_UNKNOWN; 2269 break; 2270 2271 case bp_read_watchpoint: 2272 if (ui_out_is_mi_like_p (uiout)) 2273 ui_out_field_string (uiout, "reason", "read-watchpoint-trigger"); 2274 mention (bs->breakpoint_at); 2275 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value"); 2276 ui_out_text (uiout, "\nValue = "); 2277 value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default); 2278 ui_out_field_stream (uiout, "value", stb); 2279 do_cleanups (ui_out_chain); 2280 ui_out_text (uiout, "\n"); 2281 return PRINT_UNKNOWN; 2282 break; 2283 2284 case bp_access_watchpoint: 2285 if (bs->old_val != NULL) 2286 { 2287 annotate_watchpoint (bs->breakpoint_at->number); 2288 if (ui_out_is_mi_like_p (uiout)) 2289 ui_out_field_string (uiout, "reason", "access-watchpoint-trigger"); 2290 mention (bs->breakpoint_at); 2291 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value"); 2292 ui_out_text (uiout, "\nOld value = "); 2293 value_print (bs->old_val, stb->stream, 0, Val_pretty_default); 2294 ui_out_field_stream (uiout, "old", stb); 2295 value_free (bs->old_val); 2296 bs->old_val = NULL; 2297 ui_out_text (uiout, "\nNew value = "); 2298 } 2299 else 2300 { 2301 mention (bs->breakpoint_at); 2302 if (ui_out_is_mi_like_p (uiout)) 2303 ui_out_field_string (uiout, "reason", "access-watchpoint-trigger"); 2304 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "value"); 2305 ui_out_text (uiout, "\nValue = "); 2306 } 2307 value_print (bs->breakpoint_at->val, stb->stream, 0,Val_pretty_default); 2308 ui_out_field_stream (uiout, "new", stb); 2309 do_cleanups (ui_out_chain); 2310 ui_out_text (uiout, "\n"); 2311 return PRINT_UNKNOWN; 2312 break; 2313 2314 /* Fall through, we don't deal with these types of breakpoints 2315 here. */ 2316 2317 case bp_finish: 2318 if (ui_out_is_mi_like_p (uiout)) 2319 ui_out_field_string (uiout, "reason", "function-finished"); 2320 return PRINT_UNKNOWN; 2321 break; 2322 2323 case bp_until: 2324 if (ui_out_is_mi_like_p (uiout)) 2325 ui_out_field_string (uiout, "reason", "location-reached"); 2326 return PRINT_UNKNOWN; 2327 break; 2328 2329 case bp_none: 2330 case bp_longjmp: 2331 case bp_longjmp_resume: 2332 case bp_step_resume: 2333 case bp_through_sigtramp: 2334 case bp_watchpoint_scope: 2335 case bp_call_dummy: 2336 default: 2337 return PRINT_UNKNOWN; 2338 } 2339} 2340 2341/* Generic routine for printing messages indicating why we 2342 stopped. The behavior of this function depends on the value 2343 'print_it' in the bpstat structure. Under some circumstances we 2344 may decide not to print anything here and delegate the task to 2345 normal_stop(). */ 2346 2347static enum print_stop_action 2348print_bp_stop_message (bpstat bs) 2349{ 2350 switch (bs->print_it) 2351 { 2352 case print_it_noop: 2353 /* Nothing should be printed for this bpstat entry. */ 2354 return PRINT_UNKNOWN; 2355 break; 2356 2357 case print_it_done: 2358 /* We still want to print the frame, but we already printed the 2359 relevant messages. */ 2360 return PRINT_SRC_AND_LOC; 2361 break; 2362 2363 case print_it_normal: 2364 /* Normal case. Call the breakpoint's print_it method, or 2365 print_it_typical. */ 2366 if (bs->breakpoint_at != NULL && bs->breakpoint_at->ops != NULL 2367 && bs->breakpoint_at->ops->print_it != NULL) 2368 return bs->breakpoint_at->ops->print_it (bs->breakpoint_at); 2369 else 2370 return print_it_typical (bs); 2371 break; 2372 2373 default: 2374 internal_error (__FILE__, __LINE__, 2375 "print_bp_stop_message: unrecognized enum value"); 2376 break; 2377 } 2378} 2379 2380/* Print a message indicating what happened. This is called from 2381 normal_stop(). The input to this routine is the head of the bpstat 2382 list - a list of the eventpoints that caused this stop. This 2383 routine calls the generic print routine for printing a message 2384 about reasons for stopping. This will print (for example) the 2385 "Breakpoint n," part of the output. The return value of this 2386 routine is one of: 2387 2388 PRINT_UNKNOWN: Means we printed nothing 2389 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent 2390 code to print the location. An example is 2391 "Breakpoint 1, " which should be followed by 2392 the location. 2393 PRINT_SRC_ONLY: Means we printed something, but there is no need 2394 to also print the location part of the message. 2395 An example is the catch/throw messages, which 2396 don't require a location appended to the end. 2397 PRINT_NOTHING: We have done some printing and we don't need any 2398 further info to be printed.*/ 2399 2400enum print_stop_action 2401bpstat_print (bpstat bs) 2402{ 2403 int val; 2404 2405 /* Maybe another breakpoint in the chain caused us to stop. 2406 (Currently all watchpoints go on the bpstat whether hit or not. 2407 That probably could (should) be changed, provided care is taken 2408 with respect to bpstat_explains_signal). */ 2409 for (; bs; bs = bs->next) 2410 { 2411 val = print_bp_stop_message (bs); 2412 if (val == PRINT_SRC_ONLY 2413 || val == PRINT_SRC_AND_LOC 2414 || val == PRINT_NOTHING) 2415 return val; 2416 } 2417 2418 /* We reached the end of the chain, or we got a null BS to start 2419 with and nothing was printed. */ 2420 return PRINT_UNKNOWN; 2421} 2422 2423/* Evaluate the expression EXP and return 1 if value is zero. 2424 This is used inside a catch_errors to evaluate the breakpoint condition. 2425 The argument is a "struct expression *" that has been cast to char * to 2426 make it pass through catch_errors. */ 2427 2428static int 2429breakpoint_cond_eval (void *exp) 2430{ 2431 struct value *mark = value_mark (); 2432 int i = !value_true (evaluate_expression ((struct expression *) exp)); 2433 value_free_to_mark (mark); 2434 return i; 2435} 2436 2437/* Allocate a new bpstat and chain it to the current one. */ 2438 2439static bpstat 2440bpstat_alloc (struct breakpoint *b, bpstat cbs /* Current "bs" value */ ) 2441{ 2442 bpstat bs; 2443 2444 bs = (bpstat) xmalloc (sizeof (*bs)); 2445 cbs->next = bs; 2446 bs->breakpoint_at = b; 2447 /* If the condition is false, etc., don't do the commands. */ 2448 bs->commands = NULL; 2449 bs->old_val = NULL; 2450 bs->print_it = print_it_normal; 2451 return bs; 2452} 2453 2454/* Possible return values for watchpoint_check (this can't be an enum 2455 because of check_errors). */ 2456/* The watchpoint has been deleted. */ 2457#define WP_DELETED 1 2458/* The value has changed. */ 2459#define WP_VALUE_CHANGED 2 2460/* The value has not changed. */ 2461#define WP_VALUE_NOT_CHANGED 3 2462 2463#define BP_TEMPFLAG 1 2464#define BP_HARDWAREFLAG 2 2465 2466/* Check watchpoint condition. */ 2467 2468static int 2469watchpoint_check (void *p) 2470{ 2471 bpstat bs = (bpstat) p; 2472 struct breakpoint *b; 2473 struct frame_info *fr; 2474 int within_current_scope; 2475 2476 b = bs->breakpoint_at; 2477 2478 if (b->exp_valid_block == NULL) 2479 within_current_scope = 1; 2480 else 2481 { 2482 /* There is no current frame at this moment. If we're going to have 2483 any chance of handling watchpoints on local variables, we'll need 2484 the frame chain (so we can determine if we're in scope). */ 2485 reinit_frame_cache (); 2486 fr = frame_find_by_id (b->watchpoint_frame); 2487 within_current_scope = (fr != NULL); 2488 /* in_function_epilogue_p() returns a non-zero value if we're still 2489 in the function but the stack frame has already been invalidated. 2490 Since we can't rely on the values of local variables after the 2491 stack has been destroyed, we are treating the watchpoint in that 2492 state as `not changed' without further checking. 2493 2494 vinschen/2003-09-04: The former implementation left out the case 2495 that the watchpoint frame couldn't be found by frame_find_by_id() 2496 because the current PC is currently in an epilogue. Calling 2497 gdbarch_in_function_epilogue_p() also when fr == NULL fixes that. */ 2498 if ((!within_current_scope || fr == get_current_frame ()) 2499 && gdbarch_in_function_epilogue_p (current_gdbarch, read_pc ())) 2500 return WP_VALUE_NOT_CHANGED; 2501 if (fr && within_current_scope) 2502 /* If we end up stopping, the current frame will get selected 2503 in normal_stop. So this call to select_frame won't affect 2504 the user. */ 2505 select_frame (fr); 2506 } 2507 2508 if (within_current_scope) 2509 { 2510 /* We use value_{,free_to_}mark because it could be a 2511 *long* time before we return to the command level and 2512 call free_all_values. We can't call free_all_values because 2513 we might be in the middle of evaluating a function call. */ 2514 2515 struct value *mark = value_mark (); 2516 struct value *new_val = evaluate_expression (bs->breakpoint_at->exp); 2517 if (!value_equal (b->val, new_val)) 2518 { 2519 release_value (new_val); 2520 value_free_to_mark (mark); 2521 bs->old_val = b->val; 2522 b->val = new_val; 2523 /* We will stop here */ 2524 return WP_VALUE_CHANGED; 2525 } 2526 else 2527 { 2528 /* Nothing changed, don't do anything. */ 2529 value_free_to_mark (mark); 2530 /* We won't stop here */ 2531 return WP_VALUE_NOT_CHANGED; 2532 } 2533 } 2534 else 2535 { 2536 /* This seems like the only logical thing to do because 2537 if we temporarily ignored the watchpoint, then when 2538 we reenter the block in which it is valid it contains 2539 garbage (in the case of a function, it may have two 2540 garbage values, one before and one after the prologue). 2541 So we can't even detect the first assignment to it and 2542 watch after that (since the garbage may or may not equal 2543 the first value assigned). */ 2544 /* We print all the stop information in print_it_typical(), but 2545 in this case, by the time we call print_it_typical() this bp 2546 will be deleted already. So we have no choice but print the 2547 information here. */ 2548 if (ui_out_is_mi_like_p (uiout)) 2549 ui_out_field_string (uiout, "reason", "watchpoint-scope"); 2550 ui_out_text (uiout, "\nWatchpoint "); 2551 ui_out_field_int (uiout, "wpnum", bs->breakpoint_at->number); 2552 ui_out_text (uiout, " deleted because the program has left the block in\n\ 2553which its expression is valid.\n"); 2554 2555 if (b->related_breakpoint) 2556 b->related_breakpoint->disposition = disp_del_at_next_stop; 2557 b->disposition = disp_del_at_next_stop; 2558 2559 return WP_DELETED; 2560 } 2561} 2562 2563/* Get a bpstat associated with having just stopped at address 2564 BP_ADDR in thread PTID. STOPPED_BY_WATCHPOINT is 1 if the 2565 target thinks we stopped due to a hardware watchpoint, 0 if we 2566 know we did not trigger a hardware watchpoint, and -1 if we do not know. */ 2567 2568/* Determine whether we stopped at a breakpoint, etc, or whether we 2569 don't understand this stop. Result is a chain of bpstat's such that: 2570 2571 if we don't understand the stop, the result is a null pointer. 2572 2573 if we understand why we stopped, the result is not null. 2574 2575 Each element of the chain refers to a particular breakpoint or 2576 watchpoint at which we have stopped. (We may have stopped for 2577 several reasons concurrently.) 2578 2579 Each element of the chain has valid next, breakpoint_at, 2580 commands, FIXME??? fields. */ 2581 2582bpstat 2583bpstat_stop_status (CORE_ADDR bp_addr, ptid_t ptid, int stopped_by_watchpoint) 2584{ 2585 struct breakpoint *b, *temp; 2586 /* True if we've hit a breakpoint (as opposed to a watchpoint). */ 2587 int real_breakpoint = 0; 2588 /* Root of the chain of bpstat's */ 2589 struct bpstats root_bs[1]; 2590 /* Pointer to the last thing in the chain currently. */ 2591 bpstat bs = root_bs; 2592 int thread_id = pid_to_thread_id (ptid); 2593 2594 ALL_BREAKPOINTS_SAFE (b, temp) 2595 { 2596 if (!breakpoint_enabled (b) && b->enable_state != bp_permanent) 2597 continue; 2598 2599 if (b->type != bp_watchpoint 2600 && b->type != bp_hardware_watchpoint 2601 && b->type != bp_read_watchpoint 2602 && b->type != bp_access_watchpoint 2603 && b->type != bp_hardware_breakpoint 2604 && b->type != bp_catch_fork 2605 && b->type != bp_catch_vfork 2606 && b->type != bp_catch_exec 2607 && b->type != bp_catch_catch 2608 && b->type != bp_catch_throw) /* a non-watchpoint bp */ 2609 { 2610 if (b->loc->address != bp_addr) /* address doesn't match */ 2611 continue; 2612 if (overlay_debugging /* unmapped overlay section */ 2613 && section_is_overlay (b->loc->section) 2614 && !section_is_mapped (b->loc->section)) 2615 continue; 2616 } 2617 2618 /* Continuable hardware watchpoints are treated as non-existent if the 2619 reason we stopped wasn't a hardware watchpoint (we didn't stop on 2620 some data address). Otherwise gdb won't stop on a break instruction 2621 in the code (not from a breakpoint) when a hardware watchpoint has 2622 been defined. */ 2623 2624 if ((b->type == bp_hardware_watchpoint 2625 || b->type == bp_read_watchpoint 2626 || b->type == bp_access_watchpoint) 2627 && !stopped_by_watchpoint) 2628 continue; 2629 2630 if (b->type == bp_hardware_breakpoint) 2631 { 2632 if (b->loc->address != bp_addr) 2633 continue; 2634 if (overlay_debugging /* unmapped overlay section */ 2635 && section_is_overlay (b->loc->section) 2636 && !section_is_mapped (b->loc->section)) 2637 continue; 2638 } 2639 2640 /* Is this a catchpoint of a load or unload? If so, did we 2641 get a load or unload of the specified library? If not, 2642 ignore it. */ 2643 if ((b->type == bp_catch_load) 2644#if defined(SOLIB_HAVE_LOAD_EVENT) 2645 && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid)) 2646 || ((b->dll_pathname != NULL) 2647 && (strcmp (b->dll_pathname, 2648 SOLIB_LOADED_LIBRARY_PATHNAME ( 2649 PIDGET (inferior_ptid))) 2650 != 0))) 2651#endif 2652 ) 2653 continue; 2654 2655 if ((b->type == bp_catch_unload) 2656#if defined(SOLIB_HAVE_UNLOAD_EVENT) 2657 && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid)) 2658 || ((b->dll_pathname != NULL) 2659 && (strcmp (b->dll_pathname, 2660 SOLIB_UNLOADED_LIBRARY_PATHNAME ( 2661 PIDGET (inferior_ptid))) 2662 != 0))) 2663#endif 2664 ) 2665 continue; 2666 2667 if ((b->type == bp_catch_fork) 2668 && !inferior_has_forked (PIDGET (inferior_ptid), 2669 &b->forked_inferior_pid)) 2670 continue; 2671 2672 if ((b->type == bp_catch_vfork) 2673 && !inferior_has_vforked (PIDGET (inferior_ptid), 2674 &b->forked_inferior_pid)) 2675 continue; 2676 2677 if ((b->type == bp_catch_exec) 2678 && !inferior_has_execd (PIDGET (inferior_ptid), &b->exec_pathname)) 2679 continue; 2680 2681 if (ep_is_exception_catchpoint (b) && 2682 !(current_exception_event = target_get_current_exception_event ())) 2683 continue; 2684 2685 /* Come here if it's a watchpoint, or if the break address matches */ 2686 2687 bs = bpstat_alloc (b, bs); /* Alloc a bpstat to explain stop */ 2688 2689 /* Watchpoints may change this, if not found to have triggered. */ 2690 bs->stop = 1; 2691 bs->print = 1; 2692 2693 if (b->type == bp_watchpoint || 2694 b->type == bp_hardware_watchpoint) 2695 { 2696 char *message = xstrprintf ("Error evaluating expression for watchpoint %d\n", 2697 b->number); 2698 struct cleanup *cleanups = make_cleanup (xfree, message); 2699 int e = catch_errors (watchpoint_check, bs, message, 2700 RETURN_MASK_ALL); 2701 do_cleanups (cleanups); 2702 switch (e) 2703 { 2704 case WP_DELETED: 2705 /* We've already printed what needs to be printed. */ 2706 /* Actually this is superfluous, because by the time we 2707 call print_it_typical() the wp will be already deleted, 2708 and the function will return immediately. */ 2709 bs->print_it = print_it_done; 2710 /* Stop. */ 2711 break; 2712 case WP_VALUE_CHANGED: 2713 /* Stop. */ 2714 ++(b->hit_count); 2715 break; 2716 case WP_VALUE_NOT_CHANGED: 2717 /* Don't stop. */ 2718 bs->print_it = print_it_noop; 2719 bs->stop = 0; 2720 continue; 2721 default: 2722 /* Can't happen. */ 2723 /* FALLTHROUGH */ 2724 case 0: 2725 /* Error from catch_errors. */ 2726 printf_filtered ("Watchpoint %d deleted.\n", b->number); 2727 if (b->related_breakpoint) 2728 b->related_breakpoint->disposition = disp_del_at_next_stop; 2729 b->disposition = disp_del_at_next_stop; 2730 /* We've already printed what needs to be printed. */ 2731 bs->print_it = print_it_done; 2732 2733 /* Stop. */ 2734 break; 2735 } 2736 } 2737 else if (b->type == bp_read_watchpoint || 2738 b->type == bp_access_watchpoint) 2739 { 2740 CORE_ADDR addr; 2741 struct value *v; 2742 int found = 0; 2743 2744 if (!target_stopped_data_address (¤t_target, &addr)) 2745 continue; 2746 for (v = b->val_chain; v; v = v->next) 2747 { 2748 if (VALUE_LVAL (v) == lval_memory 2749 && ! VALUE_LAZY (v)) 2750 { 2751 struct type *vtype = check_typedef (VALUE_TYPE (v)); 2752 2753 if (v == b->val_chain 2754 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT 2755 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY)) 2756 { 2757 CORE_ADDR vaddr; 2758 2759 vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v); 2760 /* Exact match not required. Within range is 2761 sufficient. */ 2762 if (addr >= vaddr && 2763 addr < vaddr + TYPE_LENGTH (VALUE_TYPE (v))) 2764 found = 1; 2765 } 2766 } 2767 } 2768 if (found) 2769 { 2770 char *message = xstrprintf ("Error evaluating expression for watchpoint %d\n", 2771 b->number); 2772 struct cleanup *cleanups = make_cleanup (xfree, message); 2773 int e = catch_errors (watchpoint_check, bs, message, 2774 RETURN_MASK_ALL); 2775 do_cleanups (cleanups); 2776 switch (e) 2777 { 2778 case WP_DELETED: 2779 /* We've already printed what needs to be printed. */ 2780 bs->print_it = print_it_done; 2781 /* Stop. */ 2782 break; 2783 case WP_VALUE_CHANGED: 2784 if (b->type == bp_read_watchpoint) 2785 { 2786 /* Don't stop: read watchpoints shouldn't fire if 2787 the value has changed. This is for targets 2788 which cannot set read-only watchpoints. */ 2789 bs->print_it = print_it_noop; 2790 bs->stop = 0; 2791 continue; 2792 } 2793 ++(b->hit_count); 2794 break; 2795 case WP_VALUE_NOT_CHANGED: 2796 /* Stop. */ 2797 ++(b->hit_count); 2798 break; 2799 default: 2800 /* Can't happen. */ 2801 case 0: 2802 /* Error from catch_errors. */ 2803 printf_filtered ("Watchpoint %d deleted.\n", b->number); 2804 if (b->related_breakpoint) 2805 b->related_breakpoint->disposition = disp_del_at_next_stop; 2806 b->disposition = disp_del_at_next_stop; 2807 /* We've already printed what needs to be printed. */ 2808 bs->print_it = print_it_done; 2809 break; 2810 } 2811 } 2812 else /* found == 0 */ 2813 { 2814 /* This is a case where some watchpoint(s) triggered, 2815 but not at the address of this watchpoint (FOUND 2816 was left zero). So don't print anything for this 2817 watchpoint. */ 2818 bs->print_it = print_it_noop; 2819 bs->stop = 0; 2820 continue; 2821 } 2822 } 2823 else 2824 { 2825 /* By definition, an encountered breakpoint is a triggered 2826 breakpoint. */ 2827 ++(b->hit_count); 2828 2829 real_breakpoint = 1; 2830 } 2831 2832 if (frame_id_p (b->frame_id) 2833 && !frame_id_eq (b->frame_id, get_frame_id (get_current_frame ()))) 2834 bs->stop = 0; 2835 else 2836 { 2837 int value_is_zero = 0; 2838 2839 if (b->cond) 2840 { 2841 /* Need to select the frame, with all that implies 2842 so that the conditions will have the right context. */ 2843 select_frame (get_current_frame ()); 2844 value_is_zero 2845 = catch_errors (breakpoint_cond_eval, (b->cond), 2846 "Error in testing breakpoint condition:\n", 2847 RETURN_MASK_ALL); 2848 /* FIXME-someday, should give breakpoint # */ 2849 free_all_values (); 2850 } 2851 if (b->cond && value_is_zero) 2852 { 2853 bs->stop = 0; 2854 /* Don't consider this a hit. */ 2855 --(b->hit_count); 2856 } 2857 else if (b->thread != -1 && b->thread != thread_id) 2858 { 2859 bs->stop = 0; 2860 /* Don't consider this a hit. */ 2861 --(b->hit_count); 2862 } 2863 else if (b->ignore_count > 0) 2864 { 2865 b->ignore_count--; 2866 annotate_ignore_count_change (); 2867 bs->stop = 0; 2868 } 2869 else 2870 { 2871 /* We will stop here */ 2872 if (b->disposition == disp_disable) 2873 b->enable_state = bp_disabled; 2874 if (b->silent) 2875 bs->print = 0; 2876 bs->commands = b->commands; 2877 if (bs->commands && 2878 (strcmp ("silent", bs->commands->line) == 0 2879 || (xdb_commands && strcmp ("Q", bs->commands->line) == 0))) 2880 { 2881 bs->commands = bs->commands->next; 2882 bs->print = 0; 2883 } 2884 bs->commands = copy_command_lines (bs->commands); 2885 } 2886 } 2887 /* Print nothing for this entry if we dont stop or if we dont print. */ 2888 if (bs->stop == 0 || bs->print == 0) 2889 bs->print_it = print_it_noop; 2890 } 2891 2892 bs->next = NULL; /* Terminate the chain */ 2893 bs = root_bs->next; /* Re-grab the head of the chain */ 2894 2895 /* The value of a hardware watchpoint hasn't changed, but the 2896 intermediate memory locations we are watching may have. */ 2897 if (bs && !bs->stop && 2898 (bs->breakpoint_at->type == bp_hardware_watchpoint || 2899 bs->breakpoint_at->type == bp_read_watchpoint || 2900 bs->breakpoint_at->type == bp_access_watchpoint)) 2901 { 2902 remove_breakpoints (); 2903 insert_breakpoints (); 2904 } 2905 return bs; 2906} 2907 2908/* Tell what to do about this bpstat. */ 2909struct bpstat_what 2910bpstat_what (bpstat bs) 2911{ 2912 /* Classify each bpstat as one of the following. */ 2913 enum class 2914 { 2915 /* This bpstat element has no effect on the main_action. */ 2916 no_effect = 0, 2917 2918 /* There was a watchpoint, stop but don't print. */ 2919 wp_silent, 2920 2921 /* There was a watchpoint, stop and print. */ 2922 wp_noisy, 2923 2924 /* There was a breakpoint but we're not stopping. */ 2925 bp_nostop, 2926 2927 /* There was a breakpoint, stop but don't print. */ 2928 bp_silent, 2929 2930 /* There was a breakpoint, stop and print. */ 2931 bp_noisy, 2932 2933 /* We hit the longjmp breakpoint. */ 2934 long_jump, 2935 2936 /* We hit the longjmp_resume breakpoint. */ 2937 long_resume, 2938 2939 /* We hit the step_resume breakpoint. */ 2940 step_resume, 2941 2942 /* We hit the through_sigtramp breakpoint. */ 2943 through_sig, 2944 2945 /* We hit the shared library event breakpoint. */ 2946 shlib_event, 2947 2948 /* We caught a shared library event. */ 2949 catch_shlib_event, 2950 2951 /* This is just used to count how many enums there are. */ 2952 class_last 2953 }; 2954 2955 /* Here is the table which drives this routine. So that we can 2956 format it pretty, we define some abbreviations for the 2957 enum bpstat_what codes. */ 2958#define kc BPSTAT_WHAT_KEEP_CHECKING 2959#define ss BPSTAT_WHAT_STOP_SILENT 2960#define sn BPSTAT_WHAT_STOP_NOISY 2961#define sgl BPSTAT_WHAT_SINGLE 2962#define slr BPSTAT_WHAT_SET_LONGJMP_RESUME 2963#define clr BPSTAT_WHAT_CLEAR_LONGJMP_RESUME 2964#define clrs BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE 2965#define sr BPSTAT_WHAT_STEP_RESUME 2966#define ts BPSTAT_WHAT_THROUGH_SIGTRAMP 2967#define shl BPSTAT_WHAT_CHECK_SHLIBS 2968#define shlr BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK 2969 2970/* "Can't happen." Might want to print an error message. 2971 abort() is not out of the question, but chances are GDB is just 2972 a bit confused, not unusable. */ 2973#define err BPSTAT_WHAT_STOP_NOISY 2974 2975 /* Given an old action and a class, come up with a new action. */ 2976 /* One interesting property of this table is that wp_silent is the same 2977 as bp_silent and wp_noisy is the same as bp_noisy. That is because 2978 after stopping, the check for whether to step over a breakpoint 2979 (BPSTAT_WHAT_SINGLE type stuff) is handled in proceed() without 2980 reference to how we stopped. We retain separate wp_silent and 2981 bp_silent codes in case we want to change that someday. 2982 2983 Another possibly interesting property of this table is that 2984 there's a partial ordering, priority-like, of the actions. Once 2985 you've decided that some action is appropriate, you'll never go 2986 back and decide something of a lower priority is better. The 2987 ordering is: 2988 2989 kc < clr sgl shl shlr slr sn sr ss ts 2990 sgl < clrs shl shlr slr sn sr ss ts 2991 slr < err shl shlr sn sr ss ts 2992 clr < clrs err shl shlr sn sr ss ts 2993 clrs < err shl shlr sn sr ss ts 2994 ss < shl shlr sn sr ts 2995 sn < shl shlr sr ts 2996 sr < shl shlr ts 2997 shl < shlr 2998 ts < 2999 shlr < 3000 3001 What I think this means is that we don't need a damned table 3002 here. If you just put the rows and columns in the right order, 3003 it'd look awfully regular. We could simply walk the bpstat list 3004 and choose the highest priority action we find, with a little 3005 logic to handle the 'err' cases, and the CLEAR_LONGJMP_RESUME/ 3006 CLEAR_LONGJMP_RESUME_SINGLE distinction (which breakpoint.h says 3007 is messy anyway). */ 3008 3009 /* step_resume entries: a step resume breakpoint overrides another 3010 breakpoint of signal handling (see comment in wait_for_inferior 3011 at where we set the step_resume breakpoint). */ 3012 /* We handle the through_sigtramp_breakpoint the same way; having both 3013 one of those and a step_resume_breakpoint is probably very rare (?). */ 3014 3015 static const enum bpstat_what_main_action 3016 table[(int) class_last][(int) BPSTAT_WHAT_LAST] = 3017 { 3018 /* old action */ 3019 /* kc ss sn sgl slr clr clrs sr ts shl shlr 3020 */ 3021/*no_effect */ 3022 {kc, ss, sn, sgl, slr, clr, clrs, sr, ts, shl, shlr}, 3023/*wp_silent */ 3024 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr}, 3025/*wp_noisy */ 3026 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr}, 3027/*bp_nostop */ 3028 {sgl, ss, sn, sgl, slr, clrs, clrs, sr, ts, shl, shlr}, 3029/*bp_silent */ 3030 {ss, ss, sn, ss, ss, ss, ss, sr, ts, shl, shlr}, 3031/*bp_noisy */ 3032 {sn, sn, sn, sn, sn, sn, sn, sr, ts, shl, shlr}, 3033/*long_jump */ 3034 {slr, ss, sn, slr, slr, err, err, sr, ts, shl, shlr}, 3035/*long_resume */ 3036 {clr, ss, sn, clrs, err, err, err, sr, ts, shl, shlr}, 3037/*step_resume */ 3038 {sr, sr, sr, sr, sr, sr, sr, sr, ts, shl, shlr}, 3039/*through_sig */ 3040 {ts, ts, ts, ts, ts, ts, ts, ts, ts, shl, shlr}, 3041/*shlib */ 3042 {shl, shl, shl, shl, shl, shl, shl, shl, ts, shl, shlr}, 3043/*catch_shlib */ 3044 {shlr, shlr, shlr, shlr, shlr, shlr, shlr, shlr, ts, shlr, shlr} 3045 }; 3046 3047#undef kc 3048#undef ss 3049#undef sn 3050#undef sgl 3051#undef slr 3052#undef clr 3053#undef clrs 3054#undef err 3055#undef sr 3056#undef ts 3057#undef shl 3058#undef shlr 3059 enum bpstat_what_main_action current_action = BPSTAT_WHAT_KEEP_CHECKING; 3060 struct bpstat_what retval; 3061 3062 retval.call_dummy = 0; 3063 for (; bs != NULL; bs = bs->next) 3064 { 3065 enum class bs_class = no_effect; 3066 if (bs->breakpoint_at == NULL) 3067 /* I suspect this can happen if it was a momentary breakpoint 3068 which has since been deleted. */ 3069 continue; 3070 switch (bs->breakpoint_at->type) 3071 { 3072 case bp_none: 3073 continue; 3074 3075 case bp_breakpoint: 3076 case bp_hardware_breakpoint: 3077 case bp_until: 3078 case bp_finish: 3079 if (bs->stop) 3080 { 3081 if (bs->print) 3082 bs_class = bp_noisy; 3083 else 3084 bs_class = bp_silent; 3085 } 3086 else 3087 bs_class = bp_nostop; 3088 break; 3089 case bp_watchpoint: 3090 case bp_hardware_watchpoint: 3091 case bp_read_watchpoint: 3092 case bp_access_watchpoint: 3093 if (bs->stop) 3094 { 3095 if (bs->print) 3096 bs_class = wp_noisy; 3097 else 3098 bs_class = wp_silent; 3099 } 3100 else 3101 /* There was a watchpoint, but we're not stopping. 3102 This requires no further action. */ 3103 bs_class = no_effect; 3104 break; 3105 case bp_longjmp: 3106 bs_class = long_jump; 3107 break; 3108 case bp_longjmp_resume: 3109 bs_class = long_resume; 3110 break; 3111 case bp_step_resume: 3112 if (bs->stop) 3113 { 3114 bs_class = step_resume; 3115 } 3116 else 3117 /* It is for the wrong frame. */ 3118 bs_class = bp_nostop; 3119 break; 3120 case bp_through_sigtramp: 3121 bs_class = through_sig; 3122 break; 3123 case bp_watchpoint_scope: 3124 bs_class = bp_nostop; 3125 break; 3126 case bp_shlib_event: 3127 bs_class = shlib_event; 3128 break; 3129 case bp_thread_event: 3130 case bp_overlay_event: 3131 bs_class = bp_nostop; 3132 break; 3133 case bp_catch_load: 3134 case bp_catch_unload: 3135 /* Only if this catchpoint triggered should we cause the 3136 step-out-of-dld behaviour. Otherwise, we ignore this 3137 catchpoint. */ 3138 if (bs->stop) 3139 bs_class = catch_shlib_event; 3140 else 3141 bs_class = no_effect; 3142 break; 3143 case bp_catch_fork: 3144 case bp_catch_vfork: 3145 case bp_catch_exec: 3146 if (bs->stop) 3147 { 3148 if (bs->print) 3149 bs_class = bp_noisy; 3150 else 3151 bs_class = bp_silent; 3152 } 3153 else 3154 /* There was a catchpoint, but we're not stopping. 3155 This requires no further action. */ 3156 bs_class = no_effect; 3157 break; 3158 case bp_catch_catch: 3159 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_CATCH) 3160 bs_class = bp_nostop; 3161 else if (bs->stop) 3162 bs_class = bs->print ? bp_noisy : bp_silent; 3163 break; 3164 case bp_catch_throw: 3165 if (!bs->stop || CURRENT_EXCEPTION_KIND != EX_EVENT_THROW) 3166 bs_class = bp_nostop; 3167 else if (bs->stop) 3168 bs_class = bs->print ? bp_noisy : bp_silent; 3169 break; 3170 case bp_call_dummy: 3171 /* Make sure the action is stop (silent or noisy), 3172 so infrun.c pops the dummy frame. */ 3173 bs_class = bp_silent; 3174 retval.call_dummy = 1; 3175 break; 3176 } 3177 current_action = table[(int) bs_class][(int) current_action]; 3178 } 3179 retval.main_action = current_action; 3180 return retval; 3181} 3182 3183/* Nonzero if we should step constantly (e.g. watchpoints on machines 3184 without hardware support). This isn't related to a specific bpstat, 3185 just to things like whether watchpoints are set. */ 3186 3187int 3188bpstat_should_step (void) 3189{ 3190 struct breakpoint *b; 3191 ALL_BREAKPOINTS (b) 3192 if (breakpoint_enabled (b) && b->type == bp_watchpoint) 3193 return 1; 3194 return 0; 3195} 3196 3197/* Nonzero if there are enabled hardware watchpoints. */ 3198int 3199bpstat_have_active_hw_watchpoints (void) 3200{ 3201 struct bp_location *bpt; 3202 ALL_BP_LOCATIONS (bpt) 3203 if (breakpoint_enabled (bpt->owner) 3204 && bpt->inserted 3205 && bpt->loc_type == bp_loc_hardware_watchpoint) 3206 return 1; 3207 return 0; 3208} 3209 3210 3211/* Given a bpstat that records zero or more triggered eventpoints, this 3212 function returns another bpstat which contains only the catchpoints 3213 on that first list, if any. */ 3214void 3215bpstat_get_triggered_catchpoints (bpstat ep_list, bpstat *cp_list) 3216{ 3217 struct bpstats root_bs[1]; 3218 bpstat bs = root_bs; 3219 struct breakpoint *ep; 3220 char *dll_pathname; 3221 3222 bpstat_clear (cp_list); 3223 root_bs->next = NULL; 3224 3225 for (; ep_list != NULL; ep_list = ep_list->next) 3226 { 3227 /* Is this eventpoint a catchpoint? If not, ignore it. */ 3228 ep = ep_list->breakpoint_at; 3229 if (ep == NULL) 3230 break; 3231 if ((ep->type != bp_catch_load) && 3232 (ep->type != bp_catch_unload) && 3233 (ep->type != bp_catch_catch) && 3234 (ep->type != bp_catch_throw)) 3235 /* pai: (temp) ADD fork/vfork here!! */ 3236 continue; 3237 3238 /* Yes; add it to the list. */ 3239 bs = bpstat_alloc (ep, bs); 3240 *bs = *ep_list; 3241 bs->next = NULL; 3242 bs = root_bs->next; 3243 3244#if defined(SOLIB_ADD) 3245 /* Also, for each triggered catchpoint, tag it with the name of 3246 the library that caused this trigger. (We copy the name now, 3247 because it's only guaranteed to be available NOW, when the 3248 catchpoint triggers. Clients who may wish to know the name 3249 later must get it from the catchpoint itself.) */ 3250 if (ep->triggered_dll_pathname != NULL) 3251 xfree (ep->triggered_dll_pathname); 3252 if (ep->type == bp_catch_load) 3253 dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME ( 3254 PIDGET (inferior_ptid)); 3255 else 3256 dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME ( 3257 PIDGET (inferior_ptid)); 3258#else 3259 dll_pathname = NULL; 3260#endif 3261 if (dll_pathname) 3262 { 3263 ep->triggered_dll_pathname = (char *) 3264 xmalloc (strlen (dll_pathname) + 1); 3265 strcpy (ep->triggered_dll_pathname, dll_pathname); 3266 } 3267 else 3268 ep->triggered_dll_pathname = NULL; 3269 } 3270 3271 *cp_list = bs; 3272} 3273 3274/* Print B to gdb_stdout. */ 3275static void 3276print_one_breakpoint (struct breakpoint *b, 3277 CORE_ADDR *last_addr) 3278{ 3279 struct command_line *l; 3280 struct symbol *sym; 3281 struct ep_type_description 3282 { 3283 enum bptype type; 3284 char *description; 3285 }; 3286 static struct ep_type_description bptypes[] = 3287 { 3288 {bp_none, "?deleted?"}, 3289 {bp_breakpoint, "breakpoint"}, 3290 {bp_hardware_breakpoint, "hw breakpoint"}, 3291 {bp_until, "until"}, 3292 {bp_finish, "finish"}, 3293 {bp_watchpoint, "watchpoint"}, 3294 {bp_hardware_watchpoint, "hw watchpoint"}, 3295 {bp_read_watchpoint, "read watchpoint"}, 3296 {bp_access_watchpoint, "acc watchpoint"}, 3297 {bp_longjmp, "longjmp"}, 3298 {bp_longjmp_resume, "longjmp resume"}, 3299 {bp_step_resume, "step resume"}, 3300 {bp_through_sigtramp, "sigtramp"}, 3301 {bp_watchpoint_scope, "watchpoint scope"}, 3302 {bp_call_dummy, "call dummy"}, 3303 {bp_shlib_event, "shlib events"}, 3304 {bp_thread_event, "thread events"}, 3305 {bp_overlay_event, "overlay events"}, 3306 {bp_catch_load, "catch load"}, 3307 {bp_catch_unload, "catch unload"}, 3308 {bp_catch_fork, "catch fork"}, 3309 {bp_catch_vfork, "catch vfork"}, 3310 {bp_catch_exec, "catch exec"}, 3311 {bp_catch_catch, "catch catch"}, 3312 {bp_catch_throw, "catch throw"} 3313 }; 3314 3315 static char *bpdisps[] = 3316 {"del", "dstp", "dis", "keep"}; 3317 static char bpenables[] = "nynny"; 3318 char wrap_indent[80]; 3319 struct ui_stream *stb = ui_out_stream_new (uiout); 3320 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb); 3321 struct cleanup *bkpt_chain; 3322 3323 annotate_record (); 3324 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt"); 3325 3326 /* 1 */ 3327 annotate_field (0); 3328 ui_out_field_int (uiout, "number", b->number); 3329 3330 /* 2 */ 3331 annotate_field (1); 3332 if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0]))) 3333 || ((int) b->type != bptypes[(int) b->type].type)) 3334 internal_error (__FILE__, __LINE__, 3335 "bptypes table does not describe type #%d.", 3336 (int) b->type); 3337 ui_out_field_string (uiout, "type", bptypes[(int) b->type].description); 3338 3339 /* 3 */ 3340 annotate_field (2); 3341 ui_out_field_string (uiout, "disp", bpdisps[(int) b->disposition]); 3342 3343 /* 4 */ 3344 annotate_field (3); 3345 ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int) b->enable_state]); 3346 ui_out_spaces (uiout, 2); 3347 3348 /* 5 and 6 */ 3349 strcpy (wrap_indent, " "); 3350 if (addressprint) 3351 { 3352 if (TARGET_ADDR_BIT <= 32) 3353 strcat (wrap_indent, " "); 3354 else 3355 strcat (wrap_indent, " "); 3356 } 3357 3358 if (b->ops != NULL && b->ops->print_one != NULL) 3359 b->ops->print_one (b, last_addr); 3360 else 3361 switch (b->type) 3362 { 3363 case bp_none: 3364 internal_error (__FILE__, __LINE__, 3365 "print_one_breakpoint: bp_none encountered\n"); 3366 break; 3367 3368 case bp_watchpoint: 3369 case bp_hardware_watchpoint: 3370 case bp_read_watchpoint: 3371 case bp_access_watchpoint: 3372 /* Field 4, the address, is omitted (which makes the columns 3373 not line up too nicely with the headers, but the effect 3374 is relatively readable). */ 3375 if (addressprint) 3376 ui_out_field_skip (uiout, "addr"); 3377 annotate_field (5); 3378 print_expression (b->exp, stb->stream); 3379 ui_out_field_stream (uiout, "what", stb); 3380 break; 3381 3382 case bp_catch_load: 3383 case bp_catch_unload: 3384 /* Field 4, the address, is omitted (which makes the columns 3385 not line up too nicely with the headers, but the effect 3386 is relatively readable). */ 3387 if (addressprint) 3388 ui_out_field_skip (uiout, "addr"); 3389 annotate_field (5); 3390 if (b->dll_pathname == NULL) 3391 { 3392 ui_out_field_string (uiout, "what", "<any library>"); 3393 ui_out_spaces (uiout, 1); 3394 } 3395 else 3396 { 3397 ui_out_text (uiout, "library \""); 3398 ui_out_field_string (uiout, "what", b->dll_pathname); 3399 ui_out_text (uiout, "\" "); 3400 } 3401 break; 3402 3403 case bp_catch_fork: 3404 case bp_catch_vfork: 3405 /* Field 4, the address, is omitted (which makes the columns 3406 not line up too nicely with the headers, but the effect 3407 is relatively readable). */ 3408 if (addressprint) 3409 ui_out_field_skip (uiout, "addr"); 3410 annotate_field (5); 3411 if (b->forked_inferior_pid != 0) 3412 { 3413 ui_out_text (uiout, "process "); 3414 ui_out_field_int (uiout, "what", b->forked_inferior_pid); 3415 ui_out_spaces (uiout, 1); 3416 } 3417 3418 case bp_catch_exec: 3419 /* Field 4, the address, is omitted (which makes the columns 3420 not line up too nicely with the headers, but the effect 3421 is relatively readable). */ 3422 if (addressprint) 3423 ui_out_field_skip (uiout, "addr"); 3424 annotate_field (5); 3425 if (b->exec_pathname != NULL) 3426 { 3427 ui_out_text (uiout, "program \""); 3428 ui_out_field_string (uiout, "what", b->exec_pathname); 3429 ui_out_text (uiout, "\" "); 3430 } 3431 break; 3432 3433 case bp_catch_catch: 3434 /* Field 4, the address, is omitted (which makes the columns 3435 not line up too nicely with the headers, but the effect 3436 is relatively readable). */ 3437 if (addressprint) 3438 ui_out_field_skip (uiout, "addr"); 3439 annotate_field (5); 3440 ui_out_field_string (uiout, "what", "exception catch"); 3441 ui_out_spaces (uiout, 1); 3442 break; 3443 3444 case bp_catch_throw: 3445 /* Field 4, the address, is omitted (which makes the columns 3446 not line up too nicely with the headers, but the effect 3447 is relatively readable). */ 3448 if (addressprint) 3449 ui_out_field_skip (uiout, "addr"); 3450 annotate_field (5); 3451 ui_out_field_string (uiout, "what", "exception throw"); 3452 ui_out_spaces (uiout, 1); 3453 break; 3454 3455 case bp_breakpoint: 3456 case bp_hardware_breakpoint: 3457 case bp_until: 3458 case bp_finish: 3459 case bp_longjmp: 3460 case bp_longjmp_resume: 3461 case bp_step_resume: 3462 case bp_through_sigtramp: 3463 case bp_watchpoint_scope: 3464 case bp_call_dummy: 3465 case bp_shlib_event: 3466 case bp_thread_event: 3467 case bp_overlay_event: 3468 if (addressprint) 3469 { 3470 annotate_field (4); 3471 if (b->pending) 3472 ui_out_field_string (uiout, "addr", "<PENDING>"); 3473 else 3474 ui_out_field_core_addr (uiout, "addr", b->loc->address); 3475 } 3476 annotate_field (5); 3477 *last_addr = b->loc->address; 3478 if (b->source_file) 3479 { 3480 sym = find_pc_sect_function (b->loc->address, b->loc->section); 3481 if (sym) 3482 { 3483 ui_out_text (uiout, "in "); 3484 ui_out_field_string (uiout, "func", 3485 SYMBOL_PRINT_NAME (sym)); 3486 ui_out_wrap_hint (uiout, wrap_indent); 3487 ui_out_text (uiout, " at "); 3488 } 3489 ui_out_field_string (uiout, "file", b->source_file); 3490 ui_out_text (uiout, ":"); 3491 ui_out_field_int (uiout, "line", b->line_number); 3492 } 3493 else if (b->pending) 3494 { 3495 ui_out_field_string (uiout, "pending", b->addr_string); 3496 } 3497 else 3498 { 3499 print_address_symbolic (b->loc->address, stb->stream, demangle, ""); 3500 ui_out_field_stream (uiout, "at", stb); 3501 } 3502 break; 3503 } 3504 3505 if (b->thread != -1) 3506 { 3507 /* FIXME: This seems to be redundant and lost here; see the 3508 "stop only in" line a little further down. */ 3509 ui_out_text (uiout, " thread "); 3510 ui_out_field_int (uiout, "thread", b->thread); 3511 } 3512 3513 ui_out_text (uiout, "\n"); 3514 3515 if (frame_id_p (b->frame_id)) 3516 { 3517 annotate_field (6); 3518 ui_out_text (uiout, "\tstop only in stack frame at "); 3519 /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside 3520 the frame ID. */ 3521 ui_out_field_core_addr (uiout, "frame", b->frame_id.stack_addr); 3522 ui_out_text (uiout, "\n"); 3523 } 3524 3525 if (b->cond) 3526 { 3527 annotate_field (7); 3528 ui_out_text (uiout, "\tstop only if "); 3529 print_expression (b->cond, stb->stream); 3530 ui_out_field_stream (uiout, "cond", stb); 3531 ui_out_text (uiout, "\n"); 3532 } 3533 3534 if (b->pending && b->cond_string) 3535 { 3536 annotate_field (7); 3537 ui_out_text (uiout, "\tstop only if "); 3538 ui_out_field_string (uiout, "cond", b->cond_string); 3539 ui_out_text (uiout, "\n"); 3540 } 3541 3542 if (b->thread != -1) 3543 { 3544 /* FIXME should make an annotation for this */ 3545 ui_out_text (uiout, "\tstop only in thread "); 3546 ui_out_field_int (uiout, "thread", b->thread); 3547 ui_out_text (uiout, "\n"); 3548 } 3549 3550 if (show_breakpoint_hit_counts && b->hit_count) 3551 { 3552 /* FIXME should make an annotation for this */ 3553 if (ep_is_catchpoint (b)) 3554 ui_out_text (uiout, "\tcatchpoint"); 3555 else 3556 ui_out_text (uiout, "\tbreakpoint"); 3557 ui_out_text (uiout, " already hit "); 3558 ui_out_field_int (uiout, "times", b->hit_count); 3559 if (b->hit_count == 1) 3560 ui_out_text (uiout, " time\n"); 3561 else 3562 ui_out_text (uiout, " times\n"); 3563 } 3564 3565 /* Output the count also if it is zero, but only if this is 3566 mi. FIXME: Should have a better test for this. */ 3567 if (ui_out_is_mi_like_p (uiout)) 3568 if (show_breakpoint_hit_counts && b->hit_count == 0) 3569 ui_out_field_int (uiout, "times", b->hit_count); 3570 3571 if (b->ignore_count) 3572 { 3573 annotate_field (8); 3574 ui_out_text (uiout, "\tignore next "); 3575 ui_out_field_int (uiout, "ignore", b->ignore_count); 3576 ui_out_text (uiout, " hits\n"); 3577 } 3578 3579 if ((l = b->commands)) 3580 { 3581 struct cleanup *script_chain; 3582 3583 annotate_field (9); 3584 script_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "script"); 3585 print_command_lines (uiout, l, 4); 3586 do_cleanups (script_chain); 3587 } 3588 do_cleanups (bkpt_chain); 3589 do_cleanups (old_chain); 3590} 3591 3592struct captured_breakpoint_query_args 3593 { 3594 int bnum; 3595 }; 3596 3597static int 3598do_captured_breakpoint_query (struct ui_out *uiout, void *data) 3599{ 3600 struct captured_breakpoint_query_args *args = data; 3601 struct breakpoint *b; 3602 CORE_ADDR dummy_addr = 0; 3603 ALL_BREAKPOINTS (b) 3604 { 3605 if (args->bnum == b->number) 3606 { 3607 print_one_breakpoint (b, &dummy_addr); 3608 return GDB_RC_OK; 3609 } 3610 } 3611 return GDB_RC_NONE; 3612} 3613 3614enum gdb_rc 3615gdb_breakpoint_query (struct ui_out *uiout, int bnum) 3616{ 3617 struct captured_breakpoint_query_args args; 3618 args.bnum = bnum; 3619 /* For the moment we don't trust print_one_breakpoint() to not throw 3620 an error. */ 3621 return catch_exceptions (uiout, do_captured_breakpoint_query, &args, 3622 NULL, RETURN_MASK_ALL); 3623} 3624 3625/* Return non-zero if B is user settable (breakpoints, watchpoints, 3626 catchpoints, et.al.). */ 3627 3628static int 3629user_settable_breakpoint (const struct breakpoint *b) 3630{ 3631 return (b->type == bp_breakpoint 3632 || b->type == bp_catch_load 3633 || b->type == bp_catch_unload 3634 || b->type == bp_catch_fork 3635 || b->type == bp_catch_vfork 3636 || b->type == bp_catch_exec 3637 || b->type == bp_catch_catch 3638 || b->type == bp_catch_throw 3639 || b->type == bp_hardware_breakpoint 3640 || b->type == bp_watchpoint 3641 || b->type == bp_read_watchpoint 3642 || b->type == bp_access_watchpoint 3643 || b->type == bp_hardware_watchpoint); 3644} 3645 3646/* Print information on user settable breakpoint (watchpoint, etc) 3647 number BNUM. If BNUM is -1 print all user settable breakpoints. 3648 If ALLFLAG is non-zero, include non- user settable breakpoints. */ 3649 3650static void 3651breakpoint_1 (int bnum, int allflag) 3652{ 3653 struct breakpoint *b; 3654 CORE_ADDR last_addr = (CORE_ADDR) -1; 3655 int nr_printable_breakpoints; 3656 struct cleanup *bkpttbl_chain; 3657 3658 /* Compute the number of rows in the table. */ 3659 nr_printable_breakpoints = 0; 3660 ALL_BREAKPOINTS (b) 3661 if (bnum == -1 3662 || bnum == b->number) 3663 { 3664 if (allflag || user_settable_breakpoint (b)) 3665 nr_printable_breakpoints++; 3666 } 3667 3668 if (addressprint) 3669 bkpttbl_chain 3670 = make_cleanup_ui_out_table_begin_end (uiout, 6, nr_printable_breakpoints, 3671 "BreakpointTable"); 3672 else 3673 bkpttbl_chain 3674 = make_cleanup_ui_out_table_begin_end (uiout, 5, nr_printable_breakpoints, 3675 "BreakpointTable"); 3676 3677 if (nr_printable_breakpoints > 0) 3678 annotate_breakpoints_headers (); 3679 if (nr_printable_breakpoints > 0) 3680 annotate_field (0); 3681 ui_out_table_header (uiout, 3, ui_left, "number", "Num"); /* 1 */ 3682 if (nr_printable_breakpoints > 0) 3683 annotate_field (1); 3684 ui_out_table_header (uiout, 14, ui_left, "type", "Type"); /* 2 */ 3685 if (nr_printable_breakpoints > 0) 3686 annotate_field (2); 3687 ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */ 3688 if (nr_printable_breakpoints > 0) 3689 annotate_field (3); 3690 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */ 3691 if (addressprint) 3692 { 3693 if (nr_printable_breakpoints > 0) 3694 annotate_field (4); 3695 if (TARGET_ADDR_BIT <= 32) 3696 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */ 3697 else 3698 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */ 3699 } 3700 if (nr_printable_breakpoints > 0) 3701 annotate_field (5); 3702 ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */ 3703 ui_out_table_body (uiout); 3704 if (nr_printable_breakpoints > 0) 3705 annotate_breakpoints_table (); 3706 3707 ALL_BREAKPOINTS (b) 3708 if (bnum == -1 3709 || bnum == b->number) 3710 { 3711 /* We only print out user settable breakpoints unless the 3712 allflag is set. */ 3713 if (allflag || user_settable_breakpoint (b)) 3714 print_one_breakpoint (b, &last_addr); 3715 } 3716 3717 do_cleanups (bkpttbl_chain); 3718 3719 if (nr_printable_breakpoints == 0) 3720 { 3721 if (bnum == -1) 3722 ui_out_message (uiout, 0, "No breakpoints or watchpoints.\n"); 3723 else 3724 ui_out_message (uiout, 0, "No breakpoint or watchpoint number %d.\n", 3725 bnum); 3726 } 3727 else 3728 { 3729 /* Compare against (CORE_ADDR)-1 in case some compiler decides 3730 that a comparison of an unsigned with -1 is always false. */ 3731 if (last_addr != (CORE_ADDR) -1) 3732 set_next_address (last_addr); 3733 } 3734 3735 /* FIXME? Should this be moved up so that it is only called when 3736 there have been breakpoints? */ 3737 annotate_breakpoints_table_end (); 3738} 3739 3740static void 3741breakpoints_info (char *bnum_exp, int from_tty) 3742{ 3743 int bnum = -1; 3744 3745 if (bnum_exp) 3746 bnum = parse_and_eval_long (bnum_exp); 3747 3748 breakpoint_1 (bnum, 0); 3749} 3750 3751static void 3752maintenance_info_breakpoints (char *bnum_exp, int from_tty) 3753{ 3754 int bnum = -1; 3755 3756 if (bnum_exp) 3757 bnum = parse_and_eval_long (bnum_exp); 3758 3759 breakpoint_1 (bnum, 1); 3760} 3761 3762/* Print a message describing any breakpoints set at PC. */ 3763 3764static void 3765describe_other_breakpoints (CORE_ADDR pc, asection *section) 3766{ 3767 int others = 0; 3768 struct breakpoint *b; 3769 3770 ALL_BREAKPOINTS (b) 3771 if (b->loc->address == pc) /* address match / overlay match */ 3772 if (!b->pending && (!overlay_debugging || b->loc->section == section)) 3773 others++; 3774 if (others > 0) 3775 { 3776 printf_filtered ("Note: breakpoint%s ", (others > 1) ? "s" : ""); 3777 ALL_BREAKPOINTS (b) 3778 if (b->loc->address == pc) /* address match / overlay match */ 3779 if (!b->pending && (!overlay_debugging || b->loc->section == section)) 3780 { 3781 others--; 3782 printf_filtered ("%d%s%s ", 3783 b->number, 3784 ((b->enable_state == bp_disabled || 3785 b->enable_state == bp_shlib_disabled || 3786 b->enable_state == bp_call_disabled) 3787 ? " (disabled)" 3788 : b->enable_state == bp_permanent 3789 ? " (permanent)" 3790 : ""), 3791 (others > 1) ? "," 3792 : ((others == 1) ? " and" : "")); 3793 } 3794 printf_filtered ("also set at pc "); 3795 print_address_numeric (pc, 1, gdb_stdout); 3796 printf_filtered (".\n"); 3797 } 3798} 3799 3800/* Set the default place to put a breakpoint 3801 for the `break' command with no arguments. */ 3802 3803void 3804set_default_breakpoint (int valid, CORE_ADDR addr, struct symtab *symtab, 3805 int line) 3806{ 3807 default_breakpoint_valid = valid; 3808 default_breakpoint_address = addr; 3809 default_breakpoint_symtab = symtab; 3810 default_breakpoint_line = line; 3811} 3812 3813/* Return true iff it is meaningful to use the address member of 3814 BPT. For some breakpoint types, the address member is irrelevant 3815 and it makes no sense to attempt to compare it to other addresses 3816 (or use it for any other purpose either). 3817 3818 More specifically, each of the following breakpoint types will always 3819 have a zero valued address and we don't want check_duplicates() to mark 3820 breakpoints of any of these types to be a duplicate of an actual 3821 breakpoint at address zero: 3822 3823 bp_watchpoint 3824 bp_hardware_watchpoint 3825 bp_read_watchpoint 3826 bp_access_watchpoint 3827 bp_catch_exec 3828 bp_longjmp_resume 3829 bp_catch_fork 3830 bp_catch_vork */ 3831 3832static int 3833breakpoint_address_is_meaningful (struct breakpoint *bpt) 3834{ 3835 enum bptype type = bpt->type; 3836 3837 return (type != bp_watchpoint 3838 && type != bp_hardware_watchpoint 3839 && type != bp_read_watchpoint 3840 && type != bp_access_watchpoint 3841 && type != bp_catch_exec 3842 && type != bp_longjmp_resume 3843 && type != bp_catch_fork 3844 && type != bp_catch_vfork); 3845} 3846 3847/* Rescan breakpoints at the same address and section as BPT, 3848 marking the first one as "first" and any others as "duplicates". 3849 This is so that the bpt instruction is only inserted once. 3850 If we have a permanent breakpoint at the same place as BPT, make 3851 that one the official one, and the rest as duplicates. */ 3852 3853static void 3854check_duplicates (struct breakpoint *bpt) 3855{ 3856 struct bp_location *b; 3857 int count = 0; 3858 struct bp_location *perm_bp = 0; 3859 CORE_ADDR address = bpt->loc->address; 3860 asection *section = bpt->loc->section; 3861 3862 if (! breakpoint_address_is_meaningful (bpt)) 3863 return; 3864 3865 ALL_BP_LOCATIONS (b) 3866 if (b->owner->enable_state != bp_disabled 3867 && b->owner->enable_state != bp_shlib_disabled 3868 && !b->owner->pending 3869 && b->owner->enable_state != bp_call_disabled 3870 && b->address == address /* address / overlay match */ 3871 && (!overlay_debugging || b->section == section) 3872 && breakpoint_address_is_meaningful (b->owner)) 3873 { 3874 /* Have we found a permanent breakpoint? */ 3875 if (b->owner->enable_state == bp_permanent) 3876 { 3877 perm_bp = b; 3878 break; 3879 } 3880 3881 count++; 3882 b->duplicate = count > 1; 3883 } 3884 3885 /* If we found a permanent breakpoint at this address, go over the 3886 list again and declare all the other breakpoints there to be the 3887 duplicates. */ 3888 if (perm_bp) 3889 { 3890 perm_bp->duplicate = 0; 3891 3892 /* Permanent breakpoint should always be inserted. */ 3893 if (! perm_bp->inserted) 3894 internal_error (__FILE__, __LINE__, 3895 "allegedly permanent breakpoint is not " 3896 "actually inserted"); 3897 3898 ALL_BP_LOCATIONS (b) 3899 if (b != perm_bp) 3900 { 3901 if (b->owner->enable_state != bp_disabled 3902 && b->owner->enable_state != bp_shlib_disabled 3903 && !b->owner->pending 3904 && b->owner->enable_state != bp_call_disabled 3905 && b->address == address /* address / overlay match */ 3906 && (!overlay_debugging || b->section == section) 3907 && breakpoint_address_is_meaningful (b->owner)) 3908 { 3909 if (b->inserted) 3910 internal_error (__FILE__, __LINE__, 3911 "another breakpoint was inserted on top of " 3912 "a permanent breakpoint"); 3913 3914 b->duplicate = 1; 3915 } 3916 } 3917 } 3918} 3919 3920static void 3921breakpoint_adjustment_warning (CORE_ADDR from_addr, CORE_ADDR to_addr, 3922 int bnum, int have_bnum) 3923{ 3924 char astr1[40]; 3925 char astr2[40]; 3926 3927 strcpy (astr1, hex_string_custom ((unsigned long) from_addr, 8)); 3928 strcpy (astr2, hex_string_custom ((unsigned long) to_addr, 8)); 3929 if (have_bnum) 3930 warning ("Breakpoint %d address previously adjusted from %s to %s.", 3931 bnum, astr1, astr2); 3932 else 3933 warning ("Breakpoint address adjusted from %s to %s.", astr1, astr2); 3934} 3935 3936/* Adjust a breakpoint's address to account for architectural constraints 3937 on breakpoint placement. Return the adjusted address. Note: Very 3938 few targets require this kind of adjustment. For most targets, 3939 this function is simply the identity function. */ 3940 3941static CORE_ADDR 3942adjust_breakpoint_address (CORE_ADDR bpaddr, enum bptype bptype) 3943{ 3944 if (!gdbarch_adjust_breakpoint_address_p (current_gdbarch)) 3945 { 3946 /* Very few targets need any kind of breakpoint adjustment. */ 3947 return bpaddr; 3948 } 3949 else if (bptype == bp_watchpoint 3950 || bptype == bp_hardware_watchpoint 3951 || bptype == bp_read_watchpoint 3952 || bptype == bp_access_watchpoint 3953 || bptype == bp_catch_fork 3954 || bptype == bp_catch_vfork 3955 || bptype == bp_catch_exec) 3956 { 3957 /* Watchpoints and the various bp_catch_* eventpoints should not 3958 have their addresses modified. */ 3959 return bpaddr; 3960 } 3961 else 3962 { 3963 CORE_ADDR adjusted_bpaddr; 3964 3965 /* Some targets have architectural constraints on the placement 3966 of breakpoint instructions. Obtain the adjusted address. */ 3967 adjusted_bpaddr = gdbarch_adjust_breakpoint_address (current_gdbarch, 3968 bpaddr); 3969 3970 /* An adjusted breakpoint address can significantly alter 3971 a user's expectations. Print a warning if an adjustment 3972 is required. */ 3973 if (adjusted_bpaddr != bpaddr) 3974 breakpoint_adjustment_warning (bpaddr, adjusted_bpaddr, 0, 0); 3975 3976 return adjusted_bpaddr; 3977 } 3978} 3979 3980/* Allocate a struct bp_location. */ 3981 3982static struct bp_location * 3983allocate_bp_location (struct breakpoint *bpt, enum bptype bp_type) 3984{ 3985 struct bp_location *loc, *loc_p; 3986 3987 loc = xmalloc (sizeof (struct bp_location)); 3988 memset (loc, 0, sizeof (*loc)); 3989 3990 loc->owner = bpt; 3991 3992 switch (bp_type) 3993 { 3994 case bp_breakpoint: 3995 case bp_until: 3996 case bp_finish: 3997 case bp_longjmp: 3998 case bp_longjmp_resume: 3999 case bp_step_resume: 4000 case bp_through_sigtramp: 4001 case bp_watchpoint_scope: 4002 case bp_call_dummy: 4003 case bp_shlib_event: 4004 case bp_thread_event: 4005 case bp_overlay_event: 4006 case bp_catch_load: 4007 case bp_catch_unload: 4008 loc->loc_type = bp_loc_software_breakpoint; 4009 break; 4010 case bp_hardware_breakpoint: 4011 loc->loc_type = bp_loc_hardware_breakpoint; 4012 break; 4013 case bp_hardware_watchpoint: 4014 case bp_read_watchpoint: 4015 case bp_access_watchpoint: 4016 loc->loc_type = bp_loc_hardware_watchpoint; 4017 break; 4018 case bp_watchpoint: 4019 case bp_catch_fork: 4020 case bp_catch_vfork: 4021 case bp_catch_exec: 4022 case bp_catch_catch: 4023 case bp_catch_throw: 4024 loc->loc_type = bp_loc_other; 4025 break; 4026 default: 4027 internal_error (__FILE__, __LINE__, "unknown breakpoint type"); 4028 } 4029 4030 /* Add this breakpoint to the end of the chain. */ 4031 4032 loc_p = bp_location_chain; 4033 if (loc_p == 0) 4034 bp_location_chain = loc; 4035 else 4036 { 4037 while (loc_p->next) 4038 loc_p = loc_p->next; 4039 loc_p->next = loc; 4040 } 4041 4042 return loc; 4043} 4044 4045/* set_raw_breakpoint() is a low level routine for allocating and 4046 partially initializing a breakpoint of type BPTYPE. The newly 4047 created breakpoint's address, section, source file name, and line 4048 number are provided by SAL. The newly created and partially 4049 initialized breakpoint is added to the breakpoint chain and 4050 is also returned as the value of this function. 4051 4052 It is expected that the caller will complete the initialization of 4053 the newly created breakpoint struct as well as output any status 4054 information regarding the creation of a new breakpoint. In 4055 particular, set_raw_breakpoint() does NOT set the breakpoint 4056 number! Care should be taken to not allow an error() to occur 4057 prior to completing the initialization of the breakpoint. If this 4058 should happen, a bogus breakpoint will be left on the chain. */ 4059 4060struct breakpoint * 4061set_raw_breakpoint (struct symtab_and_line sal, enum bptype bptype) 4062{ 4063 struct breakpoint *b, *b1; 4064 4065 b = (struct breakpoint *) xmalloc (sizeof (struct breakpoint)); 4066 memset (b, 0, sizeof (*b)); 4067 b->loc = allocate_bp_location (b, bptype); 4068 b->loc->requested_address = sal.pc; 4069 b->loc->address = adjust_breakpoint_address (b->loc->requested_address, 4070 bptype); 4071 if (sal.symtab == NULL) 4072 b->source_file = NULL; 4073 else 4074 b->source_file = savestring (sal.symtab->filename, 4075 strlen (sal.symtab->filename)); 4076 b->loc->section = sal.section; 4077 b->type = bptype; 4078 b->language = current_language->la_language; 4079 b->input_radix = input_radix; 4080 b->thread = -1; 4081 b->line_number = sal.line; 4082 b->enable_state = bp_enabled; 4083 b->next = 0; 4084 b->silent = 0; 4085 b->ignore_count = 0; 4086 b->commands = NULL; 4087 b->frame_id = null_frame_id; 4088 b->dll_pathname = NULL; 4089 b->triggered_dll_pathname = NULL; 4090 b->forked_inferior_pid = 0; 4091 b->exec_pathname = NULL; 4092 b->ops = NULL; 4093 b->pending = 0; 4094 4095 /* Add this breakpoint to the end of the chain 4096 so that a list of breakpoints will come out in order 4097 of increasing numbers. */ 4098 4099 b1 = breakpoint_chain; 4100 if (b1 == 0) 4101 breakpoint_chain = b; 4102 else 4103 { 4104 while (b1->next) 4105 b1 = b1->next; 4106 b1->next = b; 4107 } 4108 4109 check_duplicates (b); 4110 breakpoints_changed (); 4111 4112 return b; 4113} 4114 4115 4116/* Note that the breakpoint object B describes a permanent breakpoint 4117 instruction, hard-wired into the inferior's code. */ 4118void 4119make_breakpoint_permanent (struct breakpoint *b) 4120{ 4121 b->enable_state = bp_permanent; 4122 4123 /* By definition, permanent breakpoints are already present in the code. */ 4124 b->loc->inserted = 1; 4125} 4126 4127static struct breakpoint * 4128create_internal_breakpoint (CORE_ADDR address, enum bptype type) 4129{ 4130 static int internal_breakpoint_number = -1; 4131 struct symtab_and_line sal; 4132 struct breakpoint *b; 4133 4134 init_sal (&sal); /* initialize to zeroes */ 4135 4136 sal.pc = address; 4137 sal.section = find_pc_overlay (sal.pc); 4138 4139 b = set_raw_breakpoint (sal, type); 4140 b->number = internal_breakpoint_number--; 4141 b->disposition = disp_donttouch; 4142 4143 return b; 4144} 4145 4146 4147static void 4148create_longjmp_breakpoint (char *func_name) 4149{ 4150 struct breakpoint *b; 4151 struct minimal_symbol *m; 4152 4153 if (func_name == NULL) 4154 b = create_internal_breakpoint (0, bp_longjmp_resume); 4155 else 4156 { 4157 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL) 4158 return; 4159 4160 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m), bp_longjmp); 4161 } 4162 4163 b->enable_state = bp_disabled; 4164 b->silent = 1; 4165 if (func_name) 4166 b->addr_string = xstrdup (func_name); 4167} 4168 4169/* Call this routine when stepping and nexting to enable a breakpoint 4170 if we do a longjmp(). When we hit that breakpoint, call 4171 set_longjmp_resume_breakpoint() to figure out where we are going. */ 4172 4173void 4174enable_longjmp_breakpoint (void) 4175{ 4176 struct breakpoint *b; 4177 4178 ALL_BREAKPOINTS (b) 4179 if (b->type == bp_longjmp) 4180 { 4181 b->enable_state = bp_enabled; 4182 check_duplicates (b); 4183 } 4184} 4185 4186void 4187disable_longjmp_breakpoint (void) 4188{ 4189 struct breakpoint *b; 4190 4191 ALL_BREAKPOINTS (b) 4192 if (b->type == bp_longjmp 4193 || b->type == bp_longjmp_resume) 4194 { 4195 b->enable_state = bp_disabled; 4196 check_duplicates (b); 4197 } 4198} 4199 4200static void 4201create_overlay_event_breakpoint (char *func_name) 4202{ 4203 struct breakpoint *b; 4204 struct minimal_symbol *m; 4205 4206 if ((m = lookup_minimal_symbol_text (func_name, NULL)) == NULL) 4207 return; 4208 4209 b = create_internal_breakpoint (SYMBOL_VALUE_ADDRESS (m), 4210 bp_overlay_event); 4211 b->addr_string = xstrdup (func_name); 4212 4213 if (overlay_debugging == ovly_auto) 4214 { 4215 b->enable_state = bp_enabled; 4216 overlay_events_enabled = 1; 4217 } 4218 else 4219 { 4220 b->enable_state = bp_disabled; 4221 overlay_events_enabled = 0; 4222 } 4223} 4224 4225void 4226enable_overlay_breakpoints (void) 4227{ 4228 struct breakpoint *b; 4229 4230 ALL_BREAKPOINTS (b) 4231 if (b->type == bp_overlay_event) 4232 { 4233 b->enable_state = bp_enabled; 4234 check_duplicates (b); 4235 overlay_events_enabled = 1; 4236 } 4237} 4238 4239void 4240disable_overlay_breakpoints (void) 4241{ 4242 struct breakpoint *b; 4243 4244 ALL_BREAKPOINTS (b) 4245 if (b->type == bp_overlay_event) 4246 { 4247 b->enable_state = bp_disabled; 4248 check_duplicates (b); 4249 overlay_events_enabled = 0; 4250 } 4251} 4252 4253struct breakpoint * 4254create_thread_event_breakpoint (CORE_ADDR address) 4255{ 4256 struct breakpoint *b; 4257 4258 b = create_internal_breakpoint (address, bp_thread_event); 4259 4260 b->enable_state = bp_enabled; 4261 /* addr_string has to be used or breakpoint_re_set will delete me. */ 4262 b->addr_string = xstrprintf ("*0x%s", paddr (b->loc->address)); 4263 4264 return b; 4265} 4266 4267void 4268remove_thread_event_breakpoints (void) 4269{ 4270 struct breakpoint *b, *temp; 4271 4272 ALL_BREAKPOINTS_SAFE (b, temp) 4273 if (b->type == bp_thread_event) 4274 delete_breakpoint (b); 4275} 4276 4277struct captured_parse_breakpoint_args 4278 { 4279 char **arg_p; 4280 struct symtabs_and_lines *sals_p; 4281 char ***addr_string_p; 4282 int *not_found_ptr; 4283 }; 4284 4285struct lang_and_radix 4286 { 4287 enum language lang; 4288 int radix; 4289 }; 4290 4291/* Cleanup helper routine to restore the current language and 4292 input radix. */ 4293static void 4294do_restore_lang_radix_cleanup (void *old) 4295{ 4296 struct lang_and_radix *p = old; 4297 set_language (p->lang); 4298 input_radix = p->radix; 4299} 4300 4301/* Try and resolve a pending breakpoint. */ 4302static int 4303resolve_pending_breakpoint (struct breakpoint *b) 4304{ 4305 /* Try and reparse the breakpoint in case the shared library 4306 is now loaded. */ 4307 struct symtabs_and_lines sals; 4308 struct symtab_and_line pending_sal; 4309 char **cond_string = (char **) NULL; 4310 char *copy_arg = b->addr_string; 4311 char **addr_string; 4312 char *errmsg; 4313 int rc; 4314 int not_found = 0; 4315 struct ui_file *old_gdb_stderr; 4316 struct lang_and_radix old_lr; 4317 struct cleanup *old_chain; 4318 4319 /* Set language, input-radix, then reissue breakpoint command. 4320 Ensure the language and input-radix are restored afterwards. */ 4321 old_lr.lang = current_language->la_language; 4322 old_lr.radix = input_radix; 4323 old_chain = make_cleanup (do_restore_lang_radix_cleanup, &old_lr); 4324 4325 set_language (b->language); 4326 input_radix = b->input_radix; 4327 rc = break_command_1 (b->addr_string, b->flag, b->from_tty, b); 4328 4329 if (rc == GDB_RC_OK) 4330 /* Pending breakpoint has been resolved. */ 4331 printf_filtered ("Pending breakpoint \"%s\" resolved\n", b->addr_string); 4332 4333 do_cleanups (old_chain); 4334 return rc; 4335} 4336 4337#ifdef SOLIB_ADD 4338void 4339remove_solib_event_breakpoints (void) 4340{ 4341 struct breakpoint *b, *temp; 4342 4343 ALL_BREAKPOINTS_SAFE (b, temp) 4344 if (b->type == bp_shlib_event) 4345 delete_breakpoint (b); 4346} 4347 4348struct breakpoint * 4349create_solib_event_breakpoint (CORE_ADDR address) 4350{ 4351 struct breakpoint *b; 4352 4353 b = create_internal_breakpoint (address, bp_shlib_event); 4354 return b; 4355} 4356 4357/* Disable any breakpoints that are on code in shared libraries. Only 4358 apply to enabled breakpoints, disabled ones can just stay disabled. */ 4359 4360void 4361disable_breakpoints_in_shlibs (int silent) 4362{ 4363 struct breakpoint *b; 4364 int disabled_shlib_breaks = 0; 4365 4366 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */ 4367 ALL_BREAKPOINTS (b) 4368 { 4369#if defined (PC_SOLIB) 4370 if (((b->type == bp_breakpoint) || 4371 (b->type == bp_hardware_breakpoint)) && 4372 breakpoint_enabled (b) && 4373 !b->loc->duplicate && 4374 PC_SOLIB (b->loc->address)) 4375 { 4376 b->enable_state = bp_shlib_disabled; 4377 if (!silent) 4378 { 4379 if (!disabled_shlib_breaks) 4380 { 4381 target_terminal_ours_for_output (); 4382 warning ("Temporarily disabling shared library breakpoints:"); 4383 } 4384 disabled_shlib_breaks = 1; 4385 warning ("breakpoint #%d ", b->number); 4386 } 4387 } 4388#endif 4389 } 4390} 4391 4392/* Disable any breakpoints that are in in an unloaded shared library. Only 4393 apply to enabled breakpoints, disabled ones can just stay disabled. */ 4394 4395void 4396disable_breakpoints_in_unloaded_shlib (struct so_list *solib) 4397{ 4398 struct breakpoint *b; 4399 int disabled_shlib_breaks = 0; 4400 4401#if defined (PC_SOLIB) 4402 /* See also: insert_breakpoints, under DISABLE_UNSETTABLE_BREAK. */ 4403 ALL_BREAKPOINTS (b) 4404 { 4405 if ((b->loc->loc_type == bp_loc_hardware_breakpoint 4406 || b->loc->loc_type == bp_loc_software_breakpoint) 4407 && breakpoint_enabled (b) 4408 && !b->loc->duplicate) 4409 { 4410 char *so_name = PC_SOLIB (b->loc->address); 4411 if (so_name 4412 && !strcmp (so_name, solib->so_name)) 4413 { 4414 b->enable_state = bp_shlib_disabled; 4415 /* At this point, we cannot rely on remove_breakpoint 4416 succeeding so we must mark the breakpoint as not inserted 4417 to prevent future errors occurring in remove_breakpoints. */ 4418 b->loc->inserted = 0; 4419 if (!disabled_shlib_breaks) 4420 { 4421 target_terminal_ours_for_output (); 4422 warning ("Temporarily disabling breakpoints for unloaded shared library \"%s\"", 4423 so_name); 4424 } 4425 disabled_shlib_breaks = 1; 4426 } 4427 } 4428 } 4429#endif 4430} 4431 4432/* Try to reenable any breakpoints in shared libraries. */ 4433void 4434re_enable_breakpoints_in_shlibs (void) 4435{ 4436 struct breakpoint *b, *tmp; 4437 4438 ALL_BREAKPOINTS_SAFE (b, tmp) 4439 { 4440 if (b->enable_state == bp_shlib_disabled) 4441 { 4442 char buf[1], *lib; 4443 4444 /* Do not reenable the breakpoint if the shared library 4445 is still not mapped in. */ 4446 lib = PC_SOLIB (b->loc->address); 4447 if (lib != NULL && target_read_memory (b->loc->address, buf, 1) == 0) 4448 b->enable_state = bp_enabled; 4449 } 4450 else if (b->pending && (b->enable_state == bp_enabled)) 4451 { 4452 if (resolve_pending_breakpoint (b) == GDB_RC_OK) 4453 delete_breakpoint (b); 4454 } 4455 } 4456} 4457 4458#endif 4459 4460static void 4461solib_load_unload_1 (char *hookname, int tempflag, char *dll_pathname, 4462 char *cond_string, enum bptype bp_kind) 4463{ 4464 struct breakpoint *b; 4465 struct symtabs_and_lines sals; 4466 struct cleanup *old_chain; 4467 struct cleanup *canonical_strings_chain = NULL; 4468 char *addr_start = hookname; 4469 char *addr_end = NULL; 4470 char **canonical = (char **) NULL; 4471 int thread = -1; /* All threads. */ 4472 4473 /* Set a breakpoint on the specified hook. */ 4474 sals = decode_line_1 (&hookname, 1, (struct symtab *) NULL, 0, &canonical, NULL); 4475 addr_end = hookname; 4476 4477 if (sals.nelts == 0) 4478 { 4479 warning ("Unable to set a breakpoint on dynamic linker callback."); 4480 warning ("Suggest linking with /opt/langtools/lib/end.o."); 4481 warning ("GDB will be unable to track shl_load/shl_unload calls"); 4482 return; 4483 } 4484 if (sals.nelts != 1) 4485 { 4486 warning ("Unable to set unique breakpoint on dynamic linker callback."); 4487 warning ("GDB will be unable to track shl_load/shl_unload calls"); 4488 return; 4489 } 4490 4491 /* Make sure that all storage allocated in decode_line_1 gets freed 4492 in case the following errors out. */ 4493 old_chain = make_cleanup (xfree, sals.sals); 4494 if (canonical != (char **) NULL) 4495 { 4496 make_cleanup (xfree, canonical); 4497 canonical_strings_chain = make_cleanup (null_cleanup, 0); 4498 if (canonical[0] != NULL) 4499 make_cleanup (xfree, canonical[0]); 4500 } 4501 4502 resolve_sal_pc (&sals.sals[0]); 4503 4504 /* Remove the canonical strings from the cleanup, they are needed below. */ 4505 if (canonical != (char **) NULL) 4506 discard_cleanups (canonical_strings_chain); 4507 4508 b = set_raw_breakpoint (sals.sals[0], bp_kind); 4509 set_breakpoint_count (breakpoint_count + 1); 4510 b->number = breakpoint_count; 4511 b->cond = NULL; 4512 b->cond_string = (cond_string == NULL) ? 4513 NULL : savestring (cond_string, strlen (cond_string)); 4514 b->thread = thread; 4515 4516 if (canonical != (char **) NULL && canonical[0] != NULL) 4517 b->addr_string = canonical[0]; 4518 else if (addr_start) 4519 b->addr_string = savestring (addr_start, addr_end - addr_start); 4520 4521 b->enable_state = bp_enabled; 4522 b->disposition = tempflag ? disp_del : disp_donttouch; 4523 4524 if (dll_pathname == NULL) 4525 b->dll_pathname = NULL; 4526 else 4527 { 4528 b->dll_pathname = (char *) xmalloc (strlen (dll_pathname) + 1); 4529 strcpy (b->dll_pathname, dll_pathname); 4530 } 4531 4532 mention (b); 4533 do_cleanups (old_chain); 4534} 4535 4536void 4537create_solib_load_event_breakpoint (char *hookname, int tempflag, 4538 char *dll_pathname, char *cond_string) 4539{ 4540 solib_load_unload_1 (hookname, tempflag, dll_pathname, 4541 cond_string, bp_catch_load); 4542} 4543 4544void 4545create_solib_unload_event_breakpoint (char *hookname, int tempflag, 4546 char *dll_pathname, char *cond_string) 4547{ 4548 solib_load_unload_1 (hookname,tempflag, dll_pathname, 4549 cond_string, bp_catch_unload); 4550} 4551 4552static void 4553create_fork_vfork_event_catchpoint (int tempflag, char *cond_string, 4554 enum bptype bp_kind) 4555{ 4556 struct symtab_and_line sal; 4557 struct breakpoint *b; 4558 int thread = -1; /* All threads. */ 4559 4560 init_sal (&sal); 4561 sal.pc = 0; 4562 sal.symtab = NULL; 4563 sal.line = 0; 4564 4565 b = set_raw_breakpoint (sal, bp_kind); 4566 set_breakpoint_count (breakpoint_count + 1); 4567 b->number = breakpoint_count; 4568 b->cond = NULL; 4569 b->cond_string = (cond_string == NULL) ? 4570 NULL : savestring (cond_string, strlen (cond_string)); 4571 b->thread = thread; 4572 b->addr_string = NULL; 4573 b->enable_state = bp_enabled; 4574 b->disposition = tempflag ? disp_del : disp_donttouch; 4575 b->forked_inferior_pid = 0; 4576 4577 mention (b); 4578} 4579 4580void 4581create_fork_event_catchpoint (int tempflag, char *cond_string) 4582{ 4583 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_fork); 4584} 4585 4586void 4587create_vfork_event_catchpoint (int tempflag, char *cond_string) 4588{ 4589 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_catch_vfork); 4590} 4591 4592void 4593create_exec_event_catchpoint (int tempflag, char *cond_string) 4594{ 4595 struct symtab_and_line sal; 4596 struct breakpoint *b; 4597 int thread = -1; /* All threads. */ 4598 4599 init_sal (&sal); 4600 sal.pc = 0; 4601 sal.symtab = NULL; 4602 sal.line = 0; 4603 4604 b = set_raw_breakpoint (sal, bp_catch_exec); 4605 set_breakpoint_count (breakpoint_count + 1); 4606 b->number = breakpoint_count; 4607 b->cond = NULL; 4608 b->cond_string = (cond_string == NULL) ? 4609 NULL : savestring (cond_string, strlen (cond_string)); 4610 b->thread = thread; 4611 b->addr_string = NULL; 4612 b->enable_state = bp_enabled; 4613 b->disposition = tempflag ? disp_del : disp_donttouch; 4614 4615 mention (b); 4616} 4617 4618static int 4619hw_breakpoint_used_count (void) 4620{ 4621 struct breakpoint *b; 4622 int i = 0; 4623 4624 ALL_BREAKPOINTS (b) 4625 { 4626 if (b->type == bp_hardware_breakpoint && b->enable_state == bp_enabled) 4627 i++; 4628 } 4629 4630 return i; 4631} 4632 4633static int 4634hw_watchpoint_used_count (enum bptype type, int *other_type_used) 4635{ 4636 struct breakpoint *b; 4637 int i = 0; 4638 4639 *other_type_used = 0; 4640 ALL_BREAKPOINTS (b) 4641 { 4642 if (breakpoint_enabled (b)) 4643 { 4644 if (b->type == type) 4645 i++; 4646 else if ((b->type == bp_hardware_watchpoint || 4647 b->type == bp_read_watchpoint || 4648 b->type == bp_access_watchpoint)) 4649 *other_type_used = 1; 4650 } 4651 } 4652 return i; 4653} 4654 4655/* Call this after hitting the longjmp() breakpoint. Use this to set 4656 a new breakpoint at the target of the jmp_buf. 4657 4658 FIXME - This ought to be done by setting a temporary breakpoint 4659 that gets deleted automatically... */ 4660 4661void 4662set_longjmp_resume_breakpoint (CORE_ADDR pc, struct frame_id frame_id) 4663{ 4664 struct breakpoint *b; 4665 4666 ALL_BREAKPOINTS (b) 4667 if (b->type == bp_longjmp_resume) 4668 { 4669 b->loc->requested_address = pc; 4670 b->loc->address = adjust_breakpoint_address (b->loc->requested_address, 4671 b->type); 4672 b->enable_state = bp_enabled; 4673 b->frame_id = frame_id; 4674 check_duplicates (b); 4675 return; 4676 } 4677} 4678 4679void 4680disable_watchpoints_before_interactive_call_start (void) 4681{ 4682 struct breakpoint *b; 4683 4684 ALL_BREAKPOINTS (b) 4685 { 4686 if (((b->type == bp_watchpoint) 4687 || (b->type == bp_hardware_watchpoint) 4688 || (b->type == bp_read_watchpoint) 4689 || (b->type == bp_access_watchpoint) 4690 || ep_is_exception_catchpoint (b)) 4691 && breakpoint_enabled (b)) 4692 { 4693 b->enable_state = bp_call_disabled; 4694 check_duplicates (b); 4695 } 4696 } 4697} 4698 4699void 4700enable_watchpoints_after_interactive_call_stop (void) 4701{ 4702 struct breakpoint *b; 4703 4704 ALL_BREAKPOINTS (b) 4705 { 4706 if (((b->type == bp_watchpoint) 4707 || (b->type == bp_hardware_watchpoint) 4708 || (b->type == bp_read_watchpoint) 4709 || (b->type == bp_access_watchpoint) 4710 || ep_is_exception_catchpoint (b)) 4711 && (b->enable_state == bp_call_disabled)) 4712 { 4713 b->enable_state = bp_enabled; 4714 check_duplicates (b); 4715 } 4716 } 4717} 4718 4719 4720/* Set a breakpoint that will evaporate an end of command 4721 at address specified by SAL. 4722 Restrict it to frame FRAME if FRAME is nonzero. */ 4723 4724struct breakpoint * 4725set_momentary_breakpoint (struct symtab_and_line sal, struct frame_id frame_id, 4726 enum bptype type) 4727{ 4728 struct breakpoint *b; 4729 b = set_raw_breakpoint (sal, type); 4730 b->enable_state = bp_enabled; 4731 b->disposition = disp_donttouch; 4732 b->frame_id = frame_id; 4733 4734 /* If we're debugging a multi-threaded program, then we 4735 want momentary breakpoints to be active in only a 4736 single thread of control. */ 4737 if (in_thread_list (inferior_ptid)) 4738 b->thread = pid_to_thread_id (inferior_ptid); 4739 4740 return b; 4741} 4742 4743 4744/* Tell the user we have just set a breakpoint B. */ 4745 4746static void 4747mention (struct breakpoint *b) 4748{ 4749 int say_where = 0; 4750 struct cleanup *old_chain, *ui_out_chain; 4751 struct ui_stream *stb; 4752 4753 stb = ui_out_stream_new (uiout); 4754 old_chain = make_cleanup_ui_out_stream_delete (stb); 4755 4756 /* FIXME: This is misplaced; mention() is called by things (like 4757 hitting a watchpoint) other than breakpoint creation. It should 4758 be possible to clean this up and at the same time replace the 4759 random calls to breakpoint_changed with this hook, as has already 4760 been done for deprecated_delete_breakpoint_hook and so on. */ 4761 if (deprecated_create_breakpoint_hook) 4762 deprecated_create_breakpoint_hook (b); 4763 breakpoint_create_event (b->number); 4764 4765 if (b->ops != NULL && b->ops->print_mention != NULL) 4766 b->ops->print_mention (b); 4767 else 4768 switch (b->type) 4769 { 4770 case bp_none: 4771 printf_filtered ("(apparently deleted?) Eventpoint %d: ", b->number); 4772 break; 4773 case bp_watchpoint: 4774 ui_out_text (uiout, "Watchpoint "); 4775 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt"); 4776 ui_out_field_int (uiout, "number", b->number); 4777 ui_out_text (uiout, ": "); 4778 print_expression (b->exp, stb->stream); 4779 ui_out_field_stream (uiout, "exp", stb); 4780 do_cleanups (ui_out_chain); 4781 break; 4782 case bp_hardware_watchpoint: 4783 ui_out_text (uiout, "Hardware watchpoint "); 4784 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "wpt"); 4785 ui_out_field_int (uiout, "number", b->number); 4786 ui_out_text (uiout, ": "); 4787 print_expression (b->exp, stb->stream); 4788 ui_out_field_stream (uiout, "exp", stb); 4789 do_cleanups (ui_out_chain); 4790 break; 4791 case bp_read_watchpoint: 4792 ui_out_text (uiout, "Hardware read watchpoint "); 4793 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-rwpt"); 4794 ui_out_field_int (uiout, "number", b->number); 4795 ui_out_text (uiout, ": "); 4796 print_expression (b->exp, stb->stream); 4797 ui_out_field_stream (uiout, "exp", stb); 4798 do_cleanups (ui_out_chain); 4799 break; 4800 case bp_access_watchpoint: 4801 ui_out_text (uiout, "Hardware access (read/write) watchpoint "); 4802 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "hw-awpt"); 4803 ui_out_field_int (uiout, "number", b->number); 4804 ui_out_text (uiout, ": "); 4805 print_expression (b->exp, stb->stream); 4806 ui_out_field_stream (uiout, "exp", stb); 4807 do_cleanups (ui_out_chain); 4808 break; 4809 case bp_breakpoint: 4810 if (ui_out_is_mi_like_p (uiout)) 4811 { 4812 say_where = 0; 4813 break; 4814 } 4815 printf_filtered ("Breakpoint %d", b->number); 4816 say_where = 1; 4817 break; 4818 case bp_hardware_breakpoint: 4819 if (ui_out_is_mi_like_p (uiout)) 4820 { 4821 say_where = 0; 4822 break; 4823 } 4824 printf_filtered ("Hardware assisted breakpoint %d", b->number); 4825 say_where = 1; 4826 break; 4827 case bp_catch_load: 4828 case bp_catch_unload: 4829 printf_filtered ("Catchpoint %d (%s %s)", 4830 b->number, 4831 (b->type == bp_catch_load) ? "load" : "unload", 4832 (b->dll_pathname != NULL) ? 4833 b->dll_pathname : "<any library>"); 4834 break; 4835 case bp_catch_fork: 4836 case bp_catch_vfork: 4837 printf_filtered ("Catchpoint %d (%s)", 4838 b->number, 4839 (b->type == bp_catch_fork) ? "fork" : "vfork"); 4840 break; 4841 case bp_catch_exec: 4842 printf_filtered ("Catchpoint %d (exec)", 4843 b->number); 4844 break; 4845 case bp_catch_catch: 4846 case bp_catch_throw: 4847 printf_filtered ("Catchpoint %d (%s)", 4848 b->number, 4849 (b->type == bp_catch_catch) ? "catch" : "throw"); 4850 break; 4851 4852 case bp_until: 4853 case bp_finish: 4854 case bp_longjmp: 4855 case bp_longjmp_resume: 4856 case bp_step_resume: 4857 case bp_through_sigtramp: 4858 case bp_call_dummy: 4859 case bp_watchpoint_scope: 4860 case bp_shlib_event: 4861 case bp_thread_event: 4862 case bp_overlay_event: 4863 break; 4864 } 4865 4866 if (say_where) 4867 { 4868 if (b->pending) 4869 { 4870 printf_filtered (" (%s) pending.", b->addr_string); 4871 } 4872 else 4873 { 4874 if (addressprint || b->source_file == NULL) 4875 { 4876 printf_filtered (" at "); 4877 print_address_numeric (b->loc->address, 1, gdb_stdout); 4878 } 4879 if (b->source_file) 4880 printf_filtered (": file %s, line %d.", 4881 b->source_file, b->line_number); 4882 } 4883 } 4884 do_cleanups (old_chain); 4885 if (ui_out_is_mi_like_p (uiout)) 4886 return; 4887 printf_filtered ("\n"); 4888} 4889 4890 4891/* Add SALS.nelts breakpoints to the breakpoint table. For each 4892 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i], 4893 COND[i] and COND_STRING[i] values. 4894 4895 The parameter PENDING_BP points to a pending breakpoint that is 4896 the basis of the breakpoints currently being created. The pending 4897 breakpoint may contain a separate condition string or commands 4898 that were added after the initial pending breakpoint was created. 4899 4900 NOTE: If the function succeeds, the caller is expected to cleanup 4901 the arrays ADDR_STRING, COND_STRING, COND and SALS (but not the 4902 array contents). If the function fails (error() is called), the 4903 caller is expected to cleanups both the ADDR_STRING, COND_STRING, 4904 COND and SALS arrays and each of those arrays contents. */ 4905 4906static void 4907create_breakpoints (struct symtabs_and_lines sals, char **addr_string, 4908 struct expression **cond, char **cond_string, 4909 enum bptype type, enum bpdisp disposition, 4910 int thread, int ignore_count, int from_tty, 4911 struct breakpoint *pending_bp) 4912{ 4913 if (type == bp_hardware_breakpoint) 4914 { 4915 int i = hw_breakpoint_used_count (); 4916 int target_resources_ok = 4917 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint, 4918 i + sals.nelts, 0); 4919 if (target_resources_ok == 0) 4920 error ("No hardware breakpoint support in the target."); 4921 else if (target_resources_ok < 0) 4922 error ("Hardware breakpoints used exceeds limit."); 4923 } 4924 4925 /* Now set all the breakpoints. */ 4926 { 4927 int i; 4928 for (i = 0; i < sals.nelts; i++) 4929 { 4930 struct breakpoint *b; 4931 struct symtab_and_line sal = sals.sals[i]; 4932 4933 if (from_tty) 4934 describe_other_breakpoints (sal.pc, sal.section); 4935 4936 b = set_raw_breakpoint (sal, type); 4937 set_breakpoint_count (breakpoint_count + 1); 4938 b->number = breakpoint_count; 4939 b->cond = cond[i]; 4940 b->thread = thread; 4941 if (addr_string[i]) 4942 b->addr_string = addr_string[i]; 4943 else 4944 /* addr_string has to be used or breakpoint_re_set will delete 4945 me. */ 4946 b->addr_string = xstrprintf ("*0x%s", paddr (b->loc->address)); 4947 b->cond_string = cond_string[i]; 4948 b->ignore_count = ignore_count; 4949 b->enable_state = bp_enabled; 4950 b->disposition = disposition; 4951 /* If resolving a pending breakpoint, a check must be made to see if 4952 the user has specified a new condition or commands for the 4953 breakpoint. A new condition will override any condition that was 4954 initially specified with the initial breakpoint command. */ 4955 if (pending_bp) 4956 { 4957 char *arg; 4958 if (pending_bp->cond_string) 4959 { 4960 arg = pending_bp->cond_string; 4961 b->cond_string = savestring (arg, strlen (arg)); 4962 b->cond = parse_exp_1 (&arg, block_for_pc (b->loc->address), 0); 4963 if (*arg) 4964 error ("Junk at end of pending breakpoint condition expression"); 4965 } 4966 /* If there are commands associated with the breakpoint, they should 4967 be copied too. */ 4968 if (pending_bp->commands) 4969 b->commands = copy_command_lines (pending_bp->commands); 4970 4971 /* We have to copy over the ignore_count and thread as well. */ 4972 b->ignore_count = pending_bp->ignore_count; 4973 b->thread = pending_bp->thread; 4974 } 4975 mention (b); 4976 } 4977 } 4978} 4979 4980/* Parse ARG which is assumed to be a SAL specification possibly 4981 followed by conditionals. On return, SALS contains an array of SAL 4982 addresses found. ADDR_STRING contains a vector of (canonical) 4983 address strings. ARG points to the end of the SAL. */ 4984 4985static void 4986parse_breakpoint_sals (char **address, 4987 struct symtabs_and_lines *sals, 4988 char ***addr_string, 4989 int *not_found_ptr) 4990{ 4991 char *addr_start = *address; 4992 *addr_string = NULL; 4993 /* If no arg given, or if first arg is 'if ', use the default 4994 breakpoint. */ 4995 if ((*address) == NULL 4996 || (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2]))) 4997 { 4998 if (default_breakpoint_valid) 4999 { 5000 struct symtab_and_line sal; 5001 init_sal (&sal); /* initialize to zeroes */ 5002 sals->sals = (struct symtab_and_line *) 5003 xmalloc (sizeof (struct symtab_and_line)); 5004 sal.pc = default_breakpoint_address; 5005 sal.line = default_breakpoint_line; 5006 sal.symtab = default_breakpoint_symtab; 5007 sal.section = find_pc_overlay (sal.pc); 5008 sals->sals[0] = sal; 5009 sals->nelts = 1; 5010 } 5011 else 5012 error ("No default breakpoint address now."); 5013 } 5014 else 5015 { 5016 /* Force almost all breakpoints to be in terms of the 5017 current_source_symtab (which is decode_line_1's default). This 5018 should produce the results we want almost all of the time while 5019 leaving default_breakpoint_* alone. 5020 ObjC: However, don't match an Objective-C method name which 5021 may have a '+' or '-' succeeded by a '[' */ 5022 5023 struct symtab_and_line cursal = get_current_source_symtab_and_line (); 5024 5025 if (default_breakpoint_valid 5026 && (!cursal.symtab 5027 || ((strchr ("+-", (*address)[0]) != NULL) 5028 && ((*address)[1] != '[')))) 5029 *sals = decode_line_1 (address, 1, default_breakpoint_symtab, 5030 default_breakpoint_line, addr_string, 5031 not_found_ptr); 5032 else 5033 *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0, 5034 addr_string, not_found_ptr); 5035 } 5036 /* For any SAL that didn't have a canonical string, fill one in. */ 5037 if (sals->nelts > 0 && *addr_string == NULL) 5038 *addr_string = xcalloc (sals->nelts, sizeof (char **)); 5039 if (addr_start != (*address)) 5040 { 5041 int i; 5042 for (i = 0; i < sals->nelts; i++) 5043 { 5044 /* Add the string if not present. */ 5045 if ((*addr_string)[i] == NULL) 5046 (*addr_string)[i] = savestring (addr_start, (*address) - addr_start); 5047 } 5048 } 5049} 5050 5051 5052/* Convert each SAL into a real PC. Verify that the PC can be 5053 inserted as a breakpoint. If it can't throw an error. */ 5054 5055static void 5056breakpoint_sals_to_pc (struct symtabs_and_lines *sals, 5057 char *address) 5058{ 5059 int i; 5060 for (i = 0; i < sals->nelts; i++) 5061 { 5062 resolve_sal_pc (&sals->sals[i]); 5063 5064 /* It's possible for the PC to be nonzero, but still an illegal 5065 value on some targets. 5066 5067 For example, on HP-UX if you start gdb, and before running the 5068 inferior you try to set a breakpoint on a shared library function 5069 "foo" where the inferior doesn't call "foo" directly but does 5070 pass its address to another function call, then we do find a 5071 minimal symbol for the "foo", but it's address is invalid. 5072 (Appears to be an index into a table that the loader sets up 5073 when the inferior is run.) 5074 5075 Give the target a chance to bless sals.sals[i].pc before we 5076 try to make a breakpoint for it. */ 5077#ifdef DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE 5078 if (DEPRECATED_PC_REQUIRES_RUN_BEFORE_USE (sals->sals[i].pc)) 5079 { 5080 if (address == NULL) 5081 error ("Cannot break without a running program."); 5082 else 5083 error ("Cannot break on %s without a running program.", 5084 address); 5085 } 5086#endif 5087 } 5088} 5089 5090static int 5091do_captured_parse_breakpoint (struct ui_out *ui, void *data) 5092{ 5093 struct captured_parse_breakpoint_args *args = data; 5094 5095 parse_breakpoint_sals (args->arg_p, args->sals_p, args->addr_string_p, 5096 args->not_found_ptr); 5097 5098 return GDB_RC_OK; 5099} 5100 5101/* Set a breakpoint according to ARG (function, linenum or *address) 5102 flag: first bit : 0 non-temporary, 1 temporary. 5103 second bit : 0 normal breakpoint, 1 hardware breakpoint. 5104 5105 PENDING_BP is non-NULL when this function is being called to resolve 5106 a pending breakpoint. */ 5107 5108static int 5109break_command_1 (char *arg, int flag, int from_tty, struct breakpoint *pending_bp) 5110{ 5111 int tempflag, hardwareflag; 5112 struct symtabs_and_lines sals; 5113 struct expression **cond = 0; 5114 struct symtab_and_line pending_sal; 5115 char **cond_string = (char **) NULL; 5116 char *copy_arg; 5117 char *err_msg; 5118 char *addr_start = arg; 5119 char **addr_string; 5120 struct cleanup *old_chain; 5121 struct cleanup *breakpoint_chain = NULL; 5122 struct captured_parse_breakpoint_args parse_args; 5123 int i, rc; 5124 int pending = 0; 5125 int thread = -1; 5126 int ignore_count = 0; 5127 int not_found = 0; 5128 5129 hardwareflag = flag & BP_HARDWAREFLAG; 5130 tempflag = flag & BP_TEMPFLAG; 5131 5132 sals.sals = NULL; 5133 sals.nelts = 0; 5134 addr_string = NULL; 5135 5136 parse_args.arg_p = &arg; 5137 parse_args.sals_p = &sals; 5138 parse_args.addr_string_p = &addr_string; 5139 parse_args.not_found_ptr = ¬_found; 5140 5141 rc = catch_exceptions_with_msg (uiout, do_captured_parse_breakpoint, 5142 &parse_args, NULL, &err_msg, 5143 RETURN_MASK_ALL); 5144 5145 /* If caller is interested in rc value from parse, set value. */ 5146 5147 if (rc != GDB_RC_OK) 5148 { 5149 /* Check for file or function not found. */ 5150 if (not_found) 5151 { 5152 /* If called to resolve pending breakpoint, just return error code. */ 5153 if (pending_bp) 5154 return rc; 5155 5156 error_output_message (NULL, err_msg); 5157 xfree (err_msg); 5158 5159 /* If pending breakpoint support is turned off, throw error. */ 5160 5161 if (pending_break_support == AUTO_BOOLEAN_FALSE) 5162 throw_exception (RETURN_ERROR); 5163 5164 /* If pending breakpoint support is auto query and the user selects 5165 no, then simply return the error code. */ 5166 if (pending_break_support == AUTO_BOOLEAN_AUTO && 5167 !nquery ("Make breakpoint pending on future shared library load? ")) 5168 return rc; 5169 5170 /* At this point, either the user was queried about setting a 5171 pending breakpoint and selected yes, or pending breakpoint 5172 behavior is on and thus a pending breakpoint is defaulted 5173 on behalf of the user. */ 5174 copy_arg = xstrdup (addr_start); 5175 addr_string = ©_arg; 5176 sals.nelts = 1; 5177 sals.sals = &pending_sal; 5178 pending_sal.pc = 0; 5179 pending = 1; 5180 } 5181 else 5182 return rc; 5183 } 5184 else if (!sals.nelts) 5185 return GDB_RC_FAIL; 5186 5187 /* Create a chain of things that always need to be cleaned up. */ 5188 old_chain = make_cleanup (null_cleanup, 0); 5189 5190 if (!pending) 5191 { 5192 /* Make sure that all storage allocated to SALS gets freed. */ 5193 make_cleanup (xfree, sals.sals); 5194 5195 /* Cleanup the addr_string array but not its contents. */ 5196 make_cleanup (xfree, addr_string); 5197 } 5198 5199 /* Allocate space for all the cond expressions. */ 5200 cond = xcalloc (sals.nelts, sizeof (struct expression *)); 5201 make_cleanup (xfree, cond); 5202 5203 /* Allocate space for all the cond strings. */ 5204 cond_string = xcalloc (sals.nelts, sizeof (char **)); 5205 make_cleanup (xfree, cond_string); 5206 5207 /* ----------------------------- SNIP ----------------------------- 5208 Anything added to the cleanup chain beyond this point is assumed 5209 to be part of a breakpoint. If the breakpoint create succeeds 5210 then the memory is not reclaimed. */ 5211 breakpoint_chain = make_cleanup (null_cleanup, 0); 5212 5213 /* Mark the contents of the addr_string for cleanup. These go on 5214 the breakpoint_chain and only occure if the breakpoint create 5215 fails. */ 5216 for (i = 0; i < sals.nelts; i++) 5217 { 5218 if (addr_string[i] != NULL) 5219 make_cleanup (xfree, addr_string[i]); 5220 } 5221 5222 /* Resolve all line numbers to PC's and verify that the addresses 5223 are ok for the target. */ 5224 if (!pending) 5225 breakpoint_sals_to_pc (&sals, addr_start); 5226 5227 /* Verify that condition can be parsed, before setting any 5228 breakpoints. Allocate a separate condition expression for each 5229 breakpoint. */ 5230 thread = -1; /* No specific thread yet */ 5231 if (!pending) 5232 { 5233 for (i = 0; i < sals.nelts; i++) 5234 { 5235 char *tok = arg; 5236 while (tok && *tok) 5237 { 5238 char *end_tok; 5239 int toklen; 5240 char *cond_start = NULL; 5241 char *cond_end = NULL; 5242 while (*tok == ' ' || *tok == '\t') 5243 tok++; 5244 5245 end_tok = tok; 5246 5247 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000') 5248 end_tok++; 5249 5250 toklen = end_tok - tok; 5251 5252 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0) 5253 { 5254 tok = cond_start = end_tok + 1; 5255 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 5256 0); 5257 make_cleanup (xfree, cond[i]); 5258 cond_end = tok; 5259 cond_string[i] = savestring (cond_start, 5260 cond_end - cond_start); 5261 make_cleanup (xfree, cond_string[i]); 5262 } 5263 else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0) 5264 { 5265 char *tmptok; 5266 5267 tok = end_tok + 1; 5268 tmptok = tok; 5269 thread = strtol (tok, &tok, 0); 5270 if (tok == tmptok) 5271 error ("Junk after thread keyword."); 5272 if (!valid_thread_id (thread)) 5273 error ("Unknown thread %d\n", thread); 5274 } 5275 else 5276 error ("Junk at end of arguments."); 5277 } 5278 } 5279 create_breakpoints (sals, addr_string, cond, cond_string, 5280 hardwareflag ? bp_hardware_breakpoint 5281 : bp_breakpoint, 5282 tempflag ? disp_del : disp_donttouch, 5283 thread, ignore_count, from_tty, 5284 pending_bp); 5285 } 5286 else 5287 { 5288 struct symtab_and_line sal; 5289 struct breakpoint *b; 5290 5291 sal.symtab = NULL; 5292 sal.pc = 0; 5293 5294 make_cleanup (xfree, copy_arg); 5295 5296 b = set_raw_breakpoint (sal, hardwareflag ? bp_hardware_breakpoint 5297 : bp_breakpoint); 5298 set_breakpoint_count (breakpoint_count + 1); 5299 b->number = breakpoint_count; 5300 b->cond = *cond; 5301 b->thread = thread; 5302 b->addr_string = *addr_string; 5303 b->cond_string = *cond_string; 5304 b->ignore_count = ignore_count; 5305 b->pending = 1; 5306 b->disposition = tempflag ? disp_del : disp_donttouch; 5307 b->from_tty = from_tty; 5308 b->flag = flag; 5309 mention (b); 5310 } 5311 5312 if (sals.nelts > 1) 5313 { 5314 warning ("Multiple breakpoints were set."); 5315 warning ("Use the \"delete\" command to delete unwanted breakpoints."); 5316 } 5317 /* That's it. Discard the cleanups for data inserted into the 5318 breakpoint. */ 5319 discard_cleanups (breakpoint_chain); 5320 /* But cleanup everything else. */ 5321 do_cleanups (old_chain); 5322 5323 return GDB_RC_OK; 5324} 5325 5326/* Set a breakpoint of TYPE/DISPOSITION according to ARG (function, 5327 linenum or *address) with COND and IGNORE_COUNT. */ 5328 5329struct captured_breakpoint_args 5330 { 5331 char *address; 5332 char *condition; 5333 int hardwareflag; 5334 int tempflag; 5335 int thread; 5336 int ignore_count; 5337 }; 5338 5339static int 5340do_captured_breakpoint (void *data) 5341{ 5342 struct captured_breakpoint_args *args = data; 5343 struct symtabs_and_lines sals; 5344 struct expression **cond; 5345 struct cleanup *old_chain; 5346 struct cleanup *breakpoint_chain = NULL; 5347 int i; 5348 char **addr_string; 5349 char **cond_string; 5350 5351 char *address_end; 5352 5353 /* Parse the source and lines spec. Delay check that the expression 5354 didn't contain trailing garbage until after cleanups are in 5355 place. */ 5356 sals.sals = NULL; 5357 sals.nelts = 0; 5358 address_end = args->address; 5359 addr_string = NULL; 5360 parse_breakpoint_sals (&address_end, &sals, &addr_string, 0); 5361 5362 if (!sals.nelts) 5363 return GDB_RC_NONE; 5364 5365 /* Create a chain of things at always need to be cleaned up. */ 5366 old_chain = make_cleanup (null_cleanup, 0); 5367 5368 /* Always have a addr_string array, even if it is empty. */ 5369 make_cleanup (xfree, addr_string); 5370 5371 /* Make sure that all storage allocated to SALS gets freed. */ 5372 make_cleanup (xfree, sals.sals); 5373 5374 /* Allocate space for all the cond expressions. */ 5375 cond = xcalloc (sals.nelts, sizeof (struct expression *)); 5376 make_cleanup (xfree, cond); 5377 5378 /* Allocate space for all the cond strings. */ 5379 cond_string = xcalloc (sals.nelts, sizeof (char **)); 5380 make_cleanup (xfree, cond_string); 5381 5382 /* ----------------------------- SNIP ----------------------------- 5383 Anything added to the cleanup chain beyond this point is assumed 5384 to be part of a breakpoint. If the breakpoint create goes 5385 through then that memory is not cleaned up. */ 5386 breakpoint_chain = make_cleanup (null_cleanup, 0); 5387 5388 /* Mark the contents of the addr_string for cleanup. These go on 5389 the breakpoint_chain and only occure if the breakpoint create 5390 fails. */ 5391 for (i = 0; i < sals.nelts; i++) 5392 { 5393 if (addr_string[i] != NULL) 5394 make_cleanup (xfree, addr_string[i]); 5395 } 5396 5397 /* Wait until now before checking for garbage at the end of the 5398 address. That way cleanups can take care of freeing any 5399 memory. */ 5400 if (*address_end != '\0') 5401 error ("Garbage %s following breakpoint address", address_end); 5402 5403 /* Resolve all line numbers to PC's. */ 5404 breakpoint_sals_to_pc (&sals, args->address); 5405 5406 /* Verify that conditions can be parsed, before setting any 5407 breakpoints. */ 5408 for (i = 0; i < sals.nelts; i++) 5409 { 5410 if (args->condition != NULL) 5411 { 5412 char *tok = args->condition; 5413 cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0); 5414 if (*tok != '\0') 5415 error ("Garbage %s follows condition", tok); 5416 make_cleanup (xfree, cond[i]); 5417 cond_string[i] = xstrdup (args->condition); 5418 } 5419 } 5420 5421 create_breakpoints (sals, addr_string, cond, cond_string, 5422 args->hardwareflag ? bp_hardware_breakpoint : bp_breakpoint, 5423 args->tempflag ? disp_del : disp_donttouch, 5424 args->thread, args->ignore_count, 0/*from-tty*/, 5425 NULL/*pending_bp*/); 5426 5427 /* That's it. Discard the cleanups for data inserted into the 5428 breakpoint. */ 5429 discard_cleanups (breakpoint_chain); 5430 /* But cleanup everything else. */ 5431 do_cleanups (old_chain); 5432 return GDB_RC_OK; 5433} 5434 5435enum gdb_rc 5436gdb_breakpoint (char *address, char *condition, 5437 int hardwareflag, int tempflag, 5438 int thread, int ignore_count) 5439{ 5440 struct captured_breakpoint_args args; 5441 args.address = address; 5442 args.condition = condition; 5443 args.hardwareflag = hardwareflag; 5444 args.tempflag = tempflag; 5445 args.thread = thread; 5446 args.ignore_count = ignore_count; 5447 return catch_errors (do_captured_breakpoint, &args, 5448 NULL, RETURN_MASK_ALL); 5449} 5450 5451 5452static void 5453break_at_finish_at_depth_command_1 (char *arg, int flag, int from_tty) 5454{ 5455 struct frame_info *frame; 5456 CORE_ADDR low, high, selected_pc = 0; 5457 char *extra_args = NULL; 5458 char *level_arg; 5459 int extra_args_len = 0, if_arg = 0; 5460 5461 if (!arg || 5462 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t'))) 5463 { 5464 5465 if (default_breakpoint_valid) 5466 { 5467 if (deprecated_selected_frame) 5468 { 5469 selected_pc = get_frame_pc (deprecated_selected_frame); 5470 if (arg) 5471 if_arg = 1; 5472 } 5473 else 5474 error ("No selected frame."); 5475 } 5476 else 5477 error ("No default breakpoint address now."); 5478 } 5479 else 5480 { 5481 extra_args = strchr (arg, ' '); 5482 if (extra_args) 5483 { 5484 extra_args++; 5485 extra_args_len = strlen (extra_args); 5486 level_arg = (char *) xmalloc (extra_args - arg); 5487 strncpy (level_arg, arg, extra_args - arg - 1); 5488 level_arg[extra_args - arg - 1] = '\0'; 5489 } 5490 else 5491 { 5492 level_arg = (char *) xmalloc (strlen (arg) + 1); 5493 strcpy (level_arg, arg); 5494 } 5495 5496 frame = parse_frame_specification (level_arg); 5497 if (frame) 5498 selected_pc = get_frame_pc (frame); 5499 else 5500 selected_pc = 0; 5501 } 5502 if (if_arg) 5503 { 5504 extra_args = arg; 5505 extra_args_len = strlen (arg); 5506 } 5507 5508 if (selected_pc) 5509 { 5510 if (find_pc_partial_function (selected_pc, (char **) NULL, &low, &high)) 5511 { 5512 char *addr_string; 5513 if (extra_args_len) 5514 addr_string = xstrprintf ("*0x%s %s", paddr_nz (high), extra_args); 5515 else 5516 addr_string = xstrprintf ("*0x%s", paddr_nz (high)); 5517 break_command_1 (addr_string, flag, from_tty, NULL); 5518 xfree (addr_string); 5519 } 5520 else 5521 error ("No function contains the specified address"); 5522 } 5523 else 5524 error ("Unable to set breakpoint at procedure exit"); 5525} 5526 5527 5528static void 5529break_at_finish_command_1 (char *arg, int flag, int from_tty) 5530{ 5531 char *addr_string, *break_string, *beg_addr_string; 5532 CORE_ADDR low, high; 5533 struct symtabs_and_lines sals; 5534 struct symtab_and_line sal; 5535 struct cleanup *old_chain; 5536 char *extra_args = NULL; 5537 int extra_args_len = 0; 5538 int i, if_arg = 0; 5539 5540 if (!arg || 5541 (arg[0] == 'i' && arg[1] == 'f' && (arg[2] == ' ' || arg[2] == '\t'))) 5542 { 5543 if (default_breakpoint_valid) 5544 { 5545 if (deprecated_selected_frame) 5546 { 5547 addr_string = xstrprintf ("*0x%s", 5548 paddr_nz (get_frame_pc (deprecated_selected_frame))); 5549 if (arg) 5550 if_arg = 1; 5551 } 5552 else 5553 error ("No selected frame."); 5554 } 5555 else 5556 error ("No default breakpoint address now."); 5557 } 5558 else 5559 { 5560 addr_string = (char *) xmalloc (strlen (arg) + 1); 5561 strcpy (addr_string, arg); 5562 } 5563 5564 if (if_arg) 5565 { 5566 extra_args = arg; 5567 extra_args_len = strlen (arg); 5568 } 5569 else if (arg) 5570 { 5571 /* get the stuff after the function name or address */ 5572 extra_args = strchr (arg, ' '); 5573 if (extra_args) 5574 { 5575 extra_args++; 5576 extra_args_len = strlen (extra_args); 5577 } 5578 } 5579 5580 sals.sals = NULL; 5581 sals.nelts = 0; 5582 5583 beg_addr_string = addr_string; 5584 sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0, 5585 (char ***) NULL, NULL); 5586 5587 xfree (beg_addr_string); 5588 old_chain = make_cleanup (xfree, sals.sals); 5589 for (i = 0; (i < sals.nelts); i++) 5590 { 5591 sal = sals.sals[i]; 5592 if (find_pc_partial_function (sal.pc, (char **) NULL, &low, &high)) 5593 { 5594 break_string; 5595 if (extra_args_len) 5596 break_string = xstrprintf ("*0x%s %s", paddr_nz (high), 5597 extra_args); 5598 else 5599 break_string = xstrprintf ("*0x%s", paddr_nz (high)); 5600 break_command_1 (break_string, flag, from_tty, NULL); 5601 xfree (break_string); 5602 } 5603 else 5604 error ("No function contains the specified address"); 5605 } 5606 if (sals.nelts > 1) 5607 { 5608 warning ("Multiple breakpoints were set.\n"); 5609 warning ("Use the \"delete\" command to delete unwanted breakpoints."); 5610 } 5611 do_cleanups (old_chain); 5612} 5613 5614 5615/* Helper function for break_command_1 and disassemble_command. */ 5616 5617void 5618resolve_sal_pc (struct symtab_and_line *sal) 5619{ 5620 CORE_ADDR pc; 5621 5622 if (sal->pc == 0 && sal->symtab != NULL) 5623 { 5624 if (!find_line_pc (sal->symtab, sal->line, &pc)) 5625 error ("No line %d in file \"%s\".", 5626 sal->line, sal->symtab->filename); 5627 sal->pc = pc; 5628 } 5629 5630 if (sal->section == 0 && sal->symtab != NULL) 5631 { 5632 struct blockvector *bv; 5633 struct block *b; 5634 struct symbol *sym; 5635 int index; 5636 5637 bv = blockvector_for_pc_sect (sal->pc, 0, &index, sal->symtab); 5638 if (bv != NULL) 5639 { 5640 b = BLOCKVECTOR_BLOCK (bv, index); 5641 sym = block_function (b); 5642 if (sym != NULL) 5643 { 5644 fixup_symbol_section (sym, sal->symtab->objfile); 5645 sal->section = SYMBOL_BFD_SECTION (sym); 5646 } 5647 else 5648 { 5649 /* It really is worthwhile to have the section, so we'll just 5650 have to look harder. This case can be executed if we have 5651 line numbers but no functions (as can happen in assembly 5652 source). */ 5653 5654 struct minimal_symbol *msym; 5655 5656 msym = lookup_minimal_symbol_by_pc (sal->pc); 5657 if (msym) 5658 sal->section = SYMBOL_BFD_SECTION (msym); 5659 } 5660 } 5661 } 5662} 5663 5664void 5665break_command (char *arg, int from_tty) 5666{ 5667 break_command_1 (arg, 0, from_tty, NULL); 5668} 5669 5670void 5671break_at_finish_command (char *arg, int from_tty) 5672{ 5673 break_at_finish_command_1 (arg, 0, from_tty); 5674} 5675 5676void 5677break_at_finish_at_depth_command (char *arg, int from_tty) 5678{ 5679 break_at_finish_at_depth_command_1 (arg, 0, from_tty); 5680} 5681 5682void 5683tbreak_command (char *arg, int from_tty) 5684{ 5685 break_command_1 (arg, BP_TEMPFLAG, from_tty, NULL); 5686} 5687 5688void 5689tbreak_at_finish_command (char *arg, int from_tty) 5690{ 5691 break_at_finish_command_1 (arg, BP_TEMPFLAG, from_tty); 5692} 5693 5694static void 5695hbreak_command (char *arg, int from_tty) 5696{ 5697 break_command_1 (arg, BP_HARDWAREFLAG, from_tty, NULL); 5698} 5699 5700static void 5701thbreak_command (char *arg, int from_tty) 5702{ 5703 break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty, NULL); 5704} 5705 5706static void 5707stop_command (char *arg, int from_tty) 5708{ 5709 printf_filtered ("Specify the type of breakpoint to set.\n\ 5710Usage: stop in <function | address>\n\ 5711 stop at <line>\n"); 5712} 5713 5714static void 5715stopin_command (char *arg, int from_tty) 5716{ 5717 int badInput = 0; 5718 5719 if (arg == (char *) NULL) 5720 badInput = 1; 5721 else if (*arg != '*') 5722 { 5723 char *argptr = arg; 5724 int hasColon = 0; 5725 5726 /* look for a ':'. If this is a line number specification, then 5727 say it is bad, otherwise, it should be an address or 5728 function/method name */ 5729 while (*argptr && !hasColon) 5730 { 5731 hasColon = (*argptr == ':'); 5732 argptr++; 5733 } 5734 5735 if (hasColon) 5736 badInput = (*argptr != ':'); /* Not a class::method */ 5737 else 5738 badInput = isdigit (*arg); /* a simple line number */ 5739 } 5740 5741 if (badInput) 5742 printf_filtered ("Usage: stop in <function | address>\n"); 5743 else 5744 break_command_1 (arg, 0, from_tty, NULL); 5745} 5746 5747static void 5748stopat_command (char *arg, int from_tty) 5749{ 5750 int badInput = 0; 5751 5752 if (arg == (char *) NULL || *arg == '*') /* no line number */ 5753 badInput = 1; 5754 else 5755 { 5756 char *argptr = arg; 5757 int hasColon = 0; 5758 5759 /* look for a ':'. If there is a '::' then get out, otherwise 5760 it is probably a line number. */ 5761 while (*argptr && !hasColon) 5762 { 5763 hasColon = (*argptr == ':'); 5764 argptr++; 5765 } 5766 5767 if (hasColon) 5768 badInput = (*argptr == ':'); /* we have class::method */ 5769 else 5770 badInput = !isdigit (*arg); /* not a line number */ 5771 } 5772 5773 if (badInput) 5774 printf_filtered ("Usage: stop at <line>\n"); 5775 else 5776 break_command_1 (arg, 0, from_tty, NULL); 5777} 5778 5779/* accessflag: hw_write: watch write, 5780 hw_read: watch read, 5781 hw_access: watch access (read or write) */ 5782static void 5783watch_command_1 (char *arg, int accessflag, int from_tty) 5784{ 5785 struct breakpoint *b; 5786 struct symtab_and_line sal; 5787 struct expression *exp; 5788 struct block *exp_valid_block; 5789 struct value *val, *mark; 5790 struct frame_info *frame; 5791 struct frame_info *prev_frame = NULL; 5792 char *exp_start = NULL; 5793 char *exp_end = NULL; 5794 char *tok, *end_tok; 5795 int toklen; 5796 char *cond_start = NULL; 5797 char *cond_end = NULL; 5798 struct expression *cond = NULL; 5799 int i, other_type_used, target_resources_ok = 0; 5800 enum bptype bp_type; 5801 int mem_cnt = 0; 5802 5803 init_sal (&sal); /* initialize to zeroes */ 5804 5805 /* Parse arguments. */ 5806 innermost_block = NULL; 5807 exp_start = arg; 5808 exp = parse_exp_1 (&arg, 0, 0); 5809 exp_end = arg; 5810 exp_valid_block = innermost_block; 5811 mark = value_mark (); 5812 val = evaluate_expression (exp); 5813 release_value (val); 5814 if (VALUE_LAZY (val)) 5815 value_fetch_lazy (val); 5816 5817 tok = arg; 5818 while (*tok == ' ' || *tok == '\t') 5819 tok++; 5820 end_tok = tok; 5821 5822 while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000') 5823 end_tok++; 5824 5825 toklen = end_tok - tok; 5826 if (toklen >= 1 && strncmp (tok, "if", toklen) == 0) 5827 { 5828 tok = cond_start = end_tok + 1; 5829 cond = parse_exp_1 (&tok, 0, 0); 5830 cond_end = tok; 5831 } 5832 if (*tok) 5833 error ("Junk at end of command."); 5834 5835 if (accessflag == hw_read) 5836 bp_type = bp_read_watchpoint; 5837 else if (accessflag == hw_access) 5838 bp_type = bp_access_watchpoint; 5839 else 5840 bp_type = bp_hardware_watchpoint; 5841 5842 mem_cnt = can_use_hardware_watchpoint (val); 5843 if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint) 5844 error ("Expression cannot be implemented with read/access watchpoint."); 5845 if (mem_cnt != 0) 5846 { 5847 i = hw_watchpoint_used_count (bp_type, &other_type_used); 5848 target_resources_ok = 5849 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_type, i + mem_cnt, 5850 other_type_used); 5851 if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint) 5852 error ("Target does not support this type of hardware watchpoint."); 5853 5854 if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint) 5855 error ("Target can only support one kind of HW watchpoint at a time."); 5856 } 5857 5858#if defined(HPUXHPPA) 5859 /* On HP-UX if you set a h/w 5860 watchpoint before the "run" command, the inferior dies with a e.g., 5861 SIGILL once you start it. I initially believed this was due to a 5862 bad interaction between page protection traps and the initial 5863 startup sequence by the dynamic linker. 5864 5865 However, I tried avoiding that by having HP-UX's implementation of 5866 TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid 5867 yet, which forced slow watches before a "run" or "attach", and it 5868 still fails somewhere in the startup code. 5869 5870 Until I figure out what's happening, I'm disallowing watches altogether 5871 before the "run" or "attach" command. We'll tell the user they must 5872 set watches after getting the program started. */ 5873 if (!target_has_execution) 5874 { 5875 warning ("can't do that without a running program; try \"break main\", \"run\" first"); 5876 return; 5877 } 5878#endif /* HPUXHPPA */ 5879 5880 /* Change the type of breakpoint to an ordinary watchpoint if a hardware 5881 watchpoint could not be set. */ 5882 if (!mem_cnt || target_resources_ok <= 0) 5883 bp_type = bp_watchpoint; 5884 5885 /* Now set up the breakpoint. */ 5886 b = set_raw_breakpoint (sal, bp_type); 5887 set_breakpoint_count (breakpoint_count + 1); 5888 b->number = breakpoint_count; 5889 b->disposition = disp_donttouch; 5890 b->exp = exp; 5891 b->exp_valid_block = exp_valid_block; 5892 b->exp_string = savestring (exp_start, exp_end - exp_start); 5893 b->val = val; 5894 b->cond = cond; 5895 if (cond_start) 5896 b->cond_string = savestring (cond_start, cond_end - cond_start); 5897 else 5898 b->cond_string = 0; 5899 5900 frame = block_innermost_frame (exp_valid_block); 5901 if (frame) 5902 { 5903 prev_frame = get_prev_frame (frame); 5904 b->watchpoint_frame = get_frame_id (frame); 5905 } 5906 else 5907 { 5908 memset (&b->watchpoint_frame, 0, sizeof (b->watchpoint_frame)); 5909 } 5910 5911 /* If the expression is "local", then set up a "watchpoint scope" 5912 breakpoint at the point where we've left the scope of the watchpoint 5913 expression. */ 5914 if (innermost_block) 5915 { 5916 if (prev_frame) 5917 { 5918 struct breakpoint *scope_breakpoint; 5919 scope_breakpoint = create_internal_breakpoint (get_frame_pc (prev_frame), 5920 bp_watchpoint_scope); 5921 5922 scope_breakpoint->enable_state = bp_enabled; 5923 5924 /* Automatically delete the breakpoint when it hits. */ 5925 scope_breakpoint->disposition = disp_del; 5926 5927 /* Only break in the proper frame (help with recursion). */ 5928 scope_breakpoint->frame_id = get_frame_id (prev_frame); 5929 5930 /* Set the address at which we will stop. */ 5931 scope_breakpoint->loc->requested_address 5932 = get_frame_pc (prev_frame); 5933 scope_breakpoint->loc->address 5934 = adjust_breakpoint_address (scope_breakpoint->loc->requested_address, 5935 scope_breakpoint->type); 5936 5937 /* The scope breakpoint is related to the watchpoint. We 5938 will need to act on them together. */ 5939 b->related_breakpoint = scope_breakpoint; 5940 } 5941 } 5942 value_free_to_mark (mark); 5943 mention (b); 5944} 5945 5946/* Return count of locations need to be watched and can be handled 5947 in hardware. If the watchpoint can not be handled 5948 in hardware return zero. */ 5949 5950#if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT) 5951#define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \ 5952 (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN)) 5953#endif 5954 5955static int 5956can_use_hardware_watchpoint (struct value *v) 5957{ 5958 int found_memory_cnt = 0; 5959 struct value *head = v; 5960 5961 /* Did the user specifically forbid us to use hardware watchpoints? */ 5962 if (!can_use_hw_watchpoints) 5963 return 0; 5964 5965 /* Make sure that the value of the expression depends only upon 5966 memory contents, and values computed from them within GDB. If we 5967 find any register references or function calls, we can't use a 5968 hardware watchpoint. 5969 5970 The idea here is that evaluating an expression generates a series 5971 of values, one holding the value of every subexpression. (The 5972 expression a*b+c has five subexpressions: a, b, a*b, c, and 5973 a*b+c.) GDB's values hold almost enough information to establish 5974 the criteria given above --- they identify memory lvalues, 5975 register lvalues, computed values, etcetera. So we can evaluate 5976 the expression, and then scan the chain of values that leaves 5977 behind to decide whether we can detect any possible change to the 5978 expression's final value using only hardware watchpoints. 5979 5980 However, I don't think that the values returned by inferior 5981 function calls are special in any way. So this function may not 5982 notice that an expression involving an inferior function call 5983 can't be watched with hardware watchpoints. FIXME. */ 5984 for (; v; v = v->next) 5985 { 5986 if (VALUE_LVAL (v) == lval_memory) 5987 { 5988 if (VALUE_LAZY (v)) 5989 /* A lazy memory lvalue is one that GDB never needed to fetch; 5990 we either just used its address (e.g., `a' in `a.b') or 5991 we never needed it at all (e.g., `a' in `a,b'). */ 5992 ; 5993 else 5994 { 5995 /* Ahh, memory we actually used! Check if we can cover 5996 it with hardware watchpoints. */ 5997 struct type *vtype = check_typedef (VALUE_TYPE (v)); 5998 5999 /* We only watch structs and arrays if user asked for it 6000 explicitly, never if they just happen to appear in a 6001 middle of some value chain. */ 6002 if (v == head 6003 || (TYPE_CODE (vtype) != TYPE_CODE_STRUCT 6004 && TYPE_CODE (vtype) != TYPE_CODE_ARRAY)) 6005 { 6006 CORE_ADDR vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v); 6007 int len = TYPE_LENGTH (VALUE_TYPE (v)); 6008 6009 if (!TARGET_REGION_OK_FOR_HW_WATCHPOINT (vaddr, len)) 6010 return 0; 6011 else 6012 found_memory_cnt++; 6013 } 6014 } 6015 } 6016 else if (v->lval != not_lval && v->modifiable == 0) 6017 return 0; /* ??? What does this represent? */ 6018 else if (v->lval == lval_register) 6019 return 0; /* cannot watch a register with a HW watchpoint */ 6020 } 6021 6022 /* The expression itself looks suitable for using a hardware 6023 watchpoint, but give the target machine a chance to reject it. */ 6024 return found_memory_cnt; 6025} 6026 6027void 6028watch_command_wrapper (char *arg, int from_tty) 6029{ 6030 watch_command (arg, from_tty); 6031} 6032 6033static void 6034watch_command (char *arg, int from_tty) 6035{ 6036 watch_command_1 (arg, hw_write, from_tty); 6037} 6038 6039void 6040rwatch_command_wrapper (char *arg, int from_tty) 6041{ 6042 rwatch_command (arg, from_tty); 6043} 6044 6045static void 6046rwatch_command (char *arg, int from_tty) 6047{ 6048 watch_command_1 (arg, hw_read, from_tty); 6049} 6050 6051void 6052awatch_command_wrapper (char *arg, int from_tty) 6053{ 6054 awatch_command (arg, from_tty); 6055} 6056 6057static void 6058awatch_command (char *arg, int from_tty) 6059{ 6060 watch_command_1 (arg, hw_access, from_tty); 6061} 6062 6063 6064/* Helper routines for the until_command routine in infcmd.c. Here 6065 because it uses the mechanisms of breakpoints. */ 6066 6067/* This function is called by fetch_inferior_event via the 6068 cmd_continuation pointer, to complete the until command. It takes 6069 care of cleaning up the temporary breakpoints set up by the until 6070 command. */ 6071static void 6072until_break_command_continuation (struct continuation_arg *arg) 6073{ 6074 struct cleanup *cleanups; 6075 6076 cleanups = (struct cleanup *) arg->data.pointer; 6077 do_exec_cleanups (cleanups); 6078} 6079 6080void 6081until_break_command (char *arg, int from_tty, int anywhere) 6082{ 6083 struct symtabs_and_lines sals; 6084 struct symtab_and_line sal; 6085 struct frame_info *prev_frame = get_prev_frame (deprecated_selected_frame); 6086 struct breakpoint *breakpoint; 6087 struct cleanup *old_chain; 6088 struct continuation_arg *arg1; 6089 6090 6091 clear_proceed_status (); 6092 6093 /* Set a breakpoint where the user wants it and at return from 6094 this function */ 6095 6096 if (default_breakpoint_valid) 6097 sals = decode_line_1 (&arg, 1, default_breakpoint_symtab, 6098 default_breakpoint_line, (char ***) NULL, NULL); 6099 else 6100 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 6101 0, (char ***) NULL, NULL); 6102 6103 if (sals.nelts != 1) 6104 error ("Couldn't get information on specified line."); 6105 6106 sal = sals.sals[0]; 6107 xfree (sals.sals); /* malloc'd, so freed */ 6108 6109 if (*arg) 6110 error ("Junk at end of arguments."); 6111 6112 resolve_sal_pc (&sal); 6113 6114 if (anywhere) 6115 /* If the user told us to continue until a specified location, 6116 we don't specify a frame at which we need to stop. */ 6117 breakpoint = set_momentary_breakpoint (sal, null_frame_id, bp_until); 6118 else 6119 /* Otherwise, specify the current frame, because we want to stop only 6120 at the very same frame. */ 6121 breakpoint = set_momentary_breakpoint (sal, 6122 get_frame_id (deprecated_selected_frame), 6123 bp_until); 6124 6125 if (!target_can_async_p ()) 6126 old_chain = make_cleanup_delete_breakpoint (breakpoint); 6127 else 6128 old_chain = make_exec_cleanup_delete_breakpoint (breakpoint); 6129 6130 /* If we are running asynchronously, and the target supports async 6131 execution, we are not waiting for the target to stop, in the call 6132 tp proceed, below. This means that we cannot delete the 6133 brekpoints until the target has actually stopped. The only place 6134 where we get a chance to do that is in fetch_inferior_event, so 6135 we must set things up for that. */ 6136 6137 if (target_can_async_p ()) 6138 { 6139 /* In this case the arg for the continuation is just the point 6140 in the exec_cleanups chain from where to start doing 6141 cleanups, because all the continuation does is the cleanups in 6142 the exec_cleanup_chain. */ 6143 arg1 = 6144 (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg)); 6145 arg1->next = NULL; 6146 arg1->data.pointer = old_chain; 6147 6148 add_continuation (until_break_command_continuation, arg1); 6149 } 6150 6151 /* Keep within the current frame, or in frames called by the current 6152 one. */ 6153 if (prev_frame) 6154 { 6155 sal = find_pc_line (get_frame_pc (prev_frame), 0); 6156 sal.pc = get_frame_pc (prev_frame); 6157 breakpoint = set_momentary_breakpoint (sal, get_frame_id (prev_frame), 6158 bp_until); 6159 if (!target_can_async_p ()) 6160 make_cleanup_delete_breakpoint (breakpoint); 6161 else 6162 make_exec_cleanup_delete_breakpoint (breakpoint); 6163 } 6164 6165 proceed (-1, TARGET_SIGNAL_DEFAULT, 0); 6166 /* Do the cleanups now, anly if we are not running asynchronously, 6167 of if we are, but the target is still synchronous. */ 6168 if (!target_can_async_p ()) 6169 do_cleanups (old_chain); 6170} 6171 6172static void 6173ep_skip_leading_whitespace (char **s) 6174{ 6175 if ((s == NULL) || (*s == NULL)) 6176 return; 6177 while (isspace (**s)) 6178 *s += 1; 6179} 6180 6181/* This function examines a string, and attempts to find a token 6182 that might be an event name in the leading characters. If a 6183 possible match is found, a pointer to the last character of 6184 the token is returned. Else, NULL is returned. */ 6185 6186static char * 6187ep_find_event_name_end (char *arg) 6188{ 6189 char *s = arg; 6190 char *event_name_end = NULL; 6191 6192 /* If we could depend upon the presense of strrpbrk, we'd use that... */ 6193 if (arg == NULL) 6194 return NULL; 6195 6196 /* We break out of the loop when we find a token delimiter. 6197 Basically, we're looking for alphanumerics and underscores; 6198 anything else delimites the token. */ 6199 while (*s != '\0') 6200 { 6201 if (!isalnum (*s) && (*s != '_')) 6202 break; 6203 event_name_end = s; 6204 s++; 6205 } 6206 6207 return event_name_end; 6208} 6209 6210 6211/* This function attempts to parse an optional "if <cond>" clause 6212 from the arg string. If one is not found, it returns NULL. 6213 6214 Else, it returns a pointer to the condition string. (It does not 6215 attempt to evaluate the string against a particular block.) And, 6216 it updates arg to point to the first character following the parsed 6217 if clause in the arg string. */ 6218 6219static char * 6220ep_parse_optional_if_clause (char **arg) 6221{ 6222 char *cond_string; 6223 6224 if (((*arg)[0] != 'i') || ((*arg)[1] != 'f') || !isspace ((*arg)[2])) 6225 return NULL; 6226 6227 /* Skip the "if" keyword. */ 6228 (*arg) += 2; 6229 6230 /* Skip any extra leading whitespace, and record the start of the 6231 condition string. */ 6232 ep_skip_leading_whitespace (arg); 6233 cond_string = *arg; 6234 6235 /* Assume that the condition occupies the remainder of the arg string. */ 6236 (*arg) += strlen (cond_string); 6237 6238 return cond_string; 6239} 6240 6241/* This function attempts to parse an optional filename from the arg 6242 string. If one is not found, it returns NULL. 6243 6244 Else, it returns a pointer to the parsed filename. (This function 6245 makes no attempt to verify that a file of that name exists, or is 6246 accessible.) And, it updates arg to point to the first character 6247 following the parsed filename in the arg string. 6248 6249 Note that clients needing to preserve the returned filename for 6250 future access should copy it to their own buffers. */ 6251static char * 6252ep_parse_optional_filename (char **arg) 6253{ 6254 static char filename[1024]; 6255 char *arg_p = *arg; 6256 int i; 6257 char c; 6258 6259 if ((*arg_p == '\0') || isspace (*arg_p)) 6260 return NULL; 6261 6262 for (i = 0;; i++) 6263 { 6264 c = *arg_p; 6265 if (isspace (c)) 6266 c = '\0'; 6267 filename[i] = c; 6268 if (c == '\0') 6269 break; 6270 arg_p++; 6271 } 6272 *arg = arg_p; 6273 6274 return filename; 6275} 6276 6277/* Commands to deal with catching events, such as signals, exceptions, 6278 process start/exit, etc. */ 6279 6280typedef enum 6281{ 6282 catch_fork, catch_vfork 6283} 6284catch_fork_kind; 6285 6286static void 6287catch_fork_command_1 (catch_fork_kind fork_kind, char *arg, int tempflag, 6288 int from_tty) 6289{ 6290 char *cond_string = NULL; 6291 6292 ep_skip_leading_whitespace (&arg); 6293 6294 /* The allowed syntax is: 6295 catch [v]fork 6296 catch [v]fork if <cond> 6297 6298 First, check if there's an if clause. */ 6299 cond_string = ep_parse_optional_if_clause (&arg); 6300 6301 if ((*arg != '\0') && !isspace (*arg)) 6302 error ("Junk at end of arguments."); 6303 6304 /* If this target supports it, create a fork or vfork catchpoint 6305 and enable reporting of such events. */ 6306 switch (fork_kind) 6307 { 6308 case catch_fork: 6309 create_fork_event_catchpoint (tempflag, cond_string); 6310 break; 6311 case catch_vfork: 6312 create_vfork_event_catchpoint (tempflag, cond_string); 6313 break; 6314 default: 6315 error ("unsupported or unknown fork kind; cannot catch it"); 6316 break; 6317 } 6318} 6319 6320static void 6321catch_exec_command_1 (char *arg, int tempflag, int from_tty) 6322{ 6323 char *cond_string = NULL; 6324 6325 ep_skip_leading_whitespace (&arg); 6326 6327 /* The allowed syntax is: 6328 catch exec 6329 catch exec if <cond> 6330 6331 First, check if there's an if clause. */ 6332 cond_string = ep_parse_optional_if_clause (&arg); 6333 6334 if ((*arg != '\0') && !isspace (*arg)) 6335 error ("Junk at end of arguments."); 6336 6337 /* If this target supports it, create an exec catchpoint 6338 and enable reporting of such events. */ 6339 create_exec_event_catchpoint (tempflag, cond_string); 6340} 6341 6342static void 6343catch_load_command_1 (char *arg, int tempflag, int from_tty) 6344{ 6345 char *dll_pathname = NULL; 6346 char *cond_string = NULL; 6347 6348 ep_skip_leading_whitespace (&arg); 6349 6350 /* The allowed syntax is: 6351 catch load 6352 catch load if <cond> 6353 catch load <filename> 6354 catch load <filename> if <cond> 6355 6356 The user is not allowed to specify the <filename> after an 6357 if clause. 6358 6359 We'll ignore the pathological case of a file named "if". 6360 6361 First, check if there's an if clause. If so, then there 6362 cannot be a filename. */ 6363 cond_string = ep_parse_optional_if_clause (&arg); 6364 6365 /* If there was an if clause, then there cannot be a filename. 6366 Else, there might be a filename and an if clause. */ 6367 if (cond_string == NULL) 6368 { 6369 dll_pathname = ep_parse_optional_filename (&arg); 6370 ep_skip_leading_whitespace (&arg); 6371 cond_string = ep_parse_optional_if_clause (&arg); 6372 } 6373 6374 if ((*arg != '\0') && !isspace (*arg)) 6375 error ("Junk at end of arguments."); 6376 6377 /* Create a load breakpoint that only triggers when a load of 6378 the specified dll (or any dll, if no pathname was specified) 6379 occurs. */ 6380 SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid), tempflag, 6381 dll_pathname, cond_string); 6382} 6383 6384static void 6385catch_unload_command_1 (char *arg, int tempflag, int from_tty) 6386{ 6387 char *dll_pathname = NULL; 6388 char *cond_string = NULL; 6389 6390 ep_skip_leading_whitespace (&arg); 6391 6392 /* The allowed syntax is: 6393 catch unload 6394 catch unload if <cond> 6395 catch unload <filename> 6396 catch unload <filename> if <cond> 6397 6398 The user is not allowed to specify the <filename> after an 6399 if clause. 6400 6401 We'll ignore the pathological case of a file named "if". 6402 6403 First, check if there's an if clause. If so, then there 6404 cannot be a filename. */ 6405 cond_string = ep_parse_optional_if_clause (&arg); 6406 6407 /* If there was an if clause, then there cannot be a filename. 6408 Else, there might be a filename and an if clause. */ 6409 if (cond_string == NULL) 6410 { 6411 dll_pathname = ep_parse_optional_filename (&arg); 6412 ep_skip_leading_whitespace (&arg); 6413 cond_string = ep_parse_optional_if_clause (&arg); 6414 } 6415 6416 if ((*arg != '\0') && !isspace (*arg)) 6417 error ("Junk at end of arguments."); 6418 6419 /* Create an unload breakpoint that only triggers when an unload of 6420 the specified dll (or any dll, if no pathname was specified) 6421 occurs. */ 6422 SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid), tempflag, 6423 dll_pathname, cond_string); 6424} 6425 6426/* Commands to deal with catching exceptions. */ 6427 6428/* Set a breakpoint at the specified callback routine for an 6429 exception event callback */ 6430 6431static void 6432create_exception_catchpoint (int tempflag, char *cond_string, 6433 enum exception_event_kind ex_event, 6434 struct symtab_and_line *sal) 6435{ 6436 struct breakpoint *b; 6437 int thread = -1; /* All threads. */ 6438 enum bptype bptype; 6439 6440 if (!sal) /* no exception support? */ 6441 return; 6442 6443 switch (ex_event) 6444 { 6445 case EX_EVENT_THROW: 6446 bptype = bp_catch_throw; 6447 break; 6448 case EX_EVENT_CATCH: 6449 bptype = bp_catch_catch; 6450 break; 6451 default: /* error condition */ 6452 error ("Internal error -- invalid catchpoint kind"); 6453 } 6454 6455 b = set_raw_breakpoint (*sal, bptype); 6456 set_breakpoint_count (breakpoint_count + 1); 6457 b->number = breakpoint_count; 6458 b->cond = NULL; 6459 b->cond_string = (cond_string == NULL) ? 6460 NULL : savestring (cond_string, strlen (cond_string)); 6461 b->thread = thread; 6462 b->addr_string = NULL; 6463 b->enable_state = bp_enabled; 6464 b->disposition = tempflag ? disp_del : disp_donttouch; 6465 mention (b); 6466} 6467 6468static enum print_stop_action 6469print_exception_catchpoint (struct breakpoint *b) 6470{ 6471 annotate_catchpoint (b->number); 6472 6473 if (strstr (b->addr_string, "throw") != NULL) 6474 printf_filtered ("\nCatchpoint %d (exception thrown)\n", 6475 b->number); 6476 else 6477 printf_filtered ("\nCatchpoint %d (exception caught)\n", 6478 b->number); 6479 6480 return PRINT_SRC_AND_LOC; 6481} 6482 6483static void 6484print_one_exception_catchpoint (struct breakpoint *b, CORE_ADDR *last_addr) 6485{ 6486 if (addressprint) 6487 { 6488 annotate_field (4); 6489 ui_out_field_core_addr (uiout, "addr", b->loc->address); 6490 } 6491 annotate_field (5); 6492 *last_addr = b->loc->address; 6493 if (strstr (b->addr_string, "throw") != NULL) 6494 ui_out_field_string (uiout, "what", "exception throw"); 6495 else 6496 ui_out_field_string (uiout, "what", "exception catch"); 6497} 6498 6499static void 6500print_mention_exception_catchpoint (struct breakpoint *b) 6501{ 6502 if (strstr (b->addr_string, "throw") != NULL) 6503 printf_filtered ("Catchpoint %d (throw)", b->number); 6504 else 6505 printf_filtered ("Catchpoint %d (catch)", b->number); 6506} 6507 6508static struct breakpoint_ops gnu_v3_exception_catchpoint_ops = { 6509 print_exception_catchpoint, 6510 print_one_exception_catchpoint, 6511 print_mention_exception_catchpoint 6512}; 6513 6514static int 6515handle_gnu_v3_exceptions (int tempflag, char *cond_string, 6516 enum exception_event_kind ex_event, int from_tty) 6517{ 6518 char *trigger_func_name, *nameptr; 6519 struct symtabs_and_lines sals; 6520 struct breakpoint *b; 6521 6522 if (ex_event == EX_EVENT_CATCH) 6523 trigger_func_name = xstrdup ("__cxa_begin_catch"); 6524 else 6525 trigger_func_name = xstrdup ("__cxa_throw"); 6526 6527 nameptr = trigger_func_name; 6528 sals = decode_line_1 (&nameptr, 1, NULL, 0, NULL, NULL); 6529 if (sals.nelts == 0) 6530 { 6531 xfree (trigger_func_name); 6532 return 0; 6533 } 6534 6535 b = set_raw_breakpoint (sals.sals[0], bp_breakpoint); 6536 set_breakpoint_count (breakpoint_count + 1); 6537 b->number = breakpoint_count; 6538 b->cond = NULL; 6539 b->cond_string = (cond_string == NULL) ? 6540 NULL : savestring (cond_string, strlen (cond_string)); 6541 b->thread = -1; 6542 b->addr_string = trigger_func_name; 6543 b->enable_state = bp_enabled; 6544 b->disposition = tempflag ? disp_del : disp_donttouch; 6545 b->ops = &gnu_v3_exception_catchpoint_ops; 6546 6547 xfree (sals.sals); 6548 mention (b); 6549 return 1; 6550} 6551 6552/* Deal with "catch catch" and "catch throw" commands */ 6553 6554static void 6555catch_exception_command_1 (enum exception_event_kind ex_event, char *arg, 6556 int tempflag, int from_tty) 6557{ 6558 char *cond_string = NULL; 6559 struct symtab_and_line *sal = NULL; 6560 6561 ep_skip_leading_whitespace (&arg); 6562 6563 cond_string = ep_parse_optional_if_clause (&arg); 6564 6565 if ((*arg != '\0') && !isspace (*arg)) 6566 error ("Junk at end of arguments."); 6567 6568 if ((ex_event != EX_EVENT_THROW) && 6569 (ex_event != EX_EVENT_CATCH)) 6570 error ("Unsupported or unknown exception event; cannot catch it"); 6571 6572 if (handle_gnu_v3_exceptions (tempflag, cond_string, ex_event, from_tty)) 6573 return; 6574 6575 /* See if we can find a callback routine */ 6576 sal = target_enable_exception_callback (ex_event, 1); 6577 6578 if (sal) 6579 { 6580 /* We have callbacks from the runtime system for exceptions. 6581 Set a breakpoint on the sal found, if no errors */ 6582 if (sal != (struct symtab_and_line *) -1) 6583 create_exception_catchpoint (tempflag, cond_string, ex_event, sal); 6584 else 6585 return; /* something went wrong with setting up callbacks */ 6586 } 6587 6588 warning ("Unsupported with this platform/compiler combination."); 6589} 6590 6591/* Cover routine to allow wrapping target_enable_exception_catchpoints 6592 inside a catch_errors */ 6593 6594static int 6595cover_target_enable_exception_callback (void *arg) 6596{ 6597 args_for_catchpoint_enable *args = arg; 6598 struct symtab_and_line *sal; 6599 sal = target_enable_exception_callback (args->kind, args->enable_p); 6600 if (sal == NULL) 6601 return 0; 6602 else if (sal == (struct symtab_and_line *) -1) 6603 return -1; 6604 else 6605 return 1; /*is valid */ 6606} 6607 6608static void 6609catch_command_1 (char *arg, int tempflag, int from_tty) 6610{ 6611 6612 /* The first argument may be an event name, such as "start" or "load". 6613 If so, then handle it as such. If it doesn't match an event name, 6614 then attempt to interpret it as an exception name. (This latter is 6615 the v4.16-and-earlier GDB meaning of the "catch" command.) 6616 6617 First, try to find the bounds of what might be an event name. */ 6618 char *arg1_start = arg; 6619 char *arg1_end; 6620 int arg1_length; 6621 6622 if (arg1_start == NULL) 6623 { 6624 /* Old behaviour was to use pre-v-4.16 syntax */ 6625 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */ 6626 /* return; */ 6627 /* Now, this is not allowed */ 6628 error ("Catch requires an event name."); 6629 6630 } 6631 arg1_end = ep_find_event_name_end (arg1_start); 6632 if (arg1_end == NULL) 6633 error ("catch requires an event"); 6634 arg1_length = arg1_end + 1 - arg1_start; 6635 6636 /* Try to match what we found against known event names. */ 6637 if (strncmp (arg1_start, "signal", arg1_length) == 0) 6638 { 6639 error ("Catch of signal not yet implemented"); 6640 } 6641 else if (strncmp (arg1_start, "catch", arg1_length) == 0) 6642 { 6643 catch_exception_command_1 (EX_EVENT_CATCH, arg1_end + 1, 6644 tempflag, from_tty); 6645 } 6646 else if (strncmp (arg1_start, "throw", arg1_length) == 0) 6647 { 6648 catch_exception_command_1 (EX_EVENT_THROW, arg1_end + 1, 6649 tempflag, from_tty); 6650 } 6651 else if (strncmp (arg1_start, "thread_start", arg1_length) == 0) 6652 { 6653 error ("Catch of thread_start not yet implemented"); 6654 } 6655 else if (strncmp (arg1_start, "thread_exit", arg1_length) == 0) 6656 { 6657 error ("Catch of thread_exit not yet implemented"); 6658 } 6659 else if (strncmp (arg1_start, "thread_join", arg1_length) == 0) 6660 { 6661 error ("Catch of thread_join not yet implemented"); 6662 } 6663 else if (strncmp (arg1_start, "start", arg1_length) == 0) 6664 { 6665 error ("Catch of start not yet implemented"); 6666 } 6667 else if (strncmp (arg1_start, "exit", arg1_length) == 0) 6668 { 6669 error ("Catch of exit not yet implemented"); 6670 } 6671 else if (strncmp (arg1_start, "fork", arg1_length) == 0) 6672 { 6673 catch_fork_command_1 (catch_fork, arg1_end + 1, tempflag, from_tty); 6674 } 6675 else if (strncmp (arg1_start, "vfork", arg1_length) == 0) 6676 { 6677 catch_fork_command_1 (catch_vfork, arg1_end + 1, tempflag, from_tty); 6678 } 6679 else if (strncmp (arg1_start, "exec", arg1_length) == 0) 6680 { 6681 catch_exec_command_1 (arg1_end + 1, tempflag, from_tty); 6682 } 6683 else if (strncmp (arg1_start, "load", arg1_length) == 0) 6684 { 6685 catch_load_command_1 (arg1_end + 1, tempflag, from_tty); 6686 } 6687 else if (strncmp (arg1_start, "unload", arg1_length) == 0) 6688 { 6689 catch_unload_command_1 (arg1_end + 1, tempflag, from_tty); 6690 } 6691 else if (strncmp (arg1_start, "stop", arg1_length) == 0) 6692 { 6693 error ("Catch of stop not yet implemented"); 6694 } 6695 6696 /* This doesn't appear to be an event name */ 6697 6698 else 6699 { 6700 /* Pre-v.4.16 behaviour was to treat the argument 6701 as the name of an exception */ 6702 /* catch_throw_command_1 (arg1_start, tempflag, from_tty); */ 6703 /* Now this is not allowed */ 6704 error ("Unknown event kind specified for catch"); 6705 6706 } 6707} 6708 6709/* Used by the gui, could be made a worker for other things. */ 6710 6711struct breakpoint * 6712set_breakpoint_sal (struct symtab_and_line sal) 6713{ 6714 struct breakpoint *b; 6715 b = set_raw_breakpoint (sal, bp_breakpoint); 6716 set_breakpoint_count (breakpoint_count + 1); 6717 b->number = breakpoint_count; 6718 b->cond = 0; 6719 b->thread = -1; 6720 return b; 6721} 6722 6723static void 6724catch_command (char *arg, int from_tty) 6725{ 6726 catch_command_1 (arg, 0, from_tty); 6727} 6728 6729 6730static void 6731tcatch_command (char *arg, int from_tty) 6732{ 6733 catch_command_1 (arg, 1, from_tty); 6734} 6735 6736/* Delete breakpoints by address or line. */ 6737 6738static void 6739clear_command (char *arg, int from_tty) 6740{ 6741 struct breakpoint *b, *tmp, *prev, *found; 6742 int default_match; 6743 struct symtabs_and_lines sals; 6744 struct symtab_and_line sal; 6745 int i; 6746 6747 if (arg) 6748 { 6749 sals = decode_line_spec (arg, 1); 6750 default_match = 0; 6751 } 6752 else 6753 { 6754 sals.sals = (struct symtab_and_line *) 6755 xmalloc (sizeof (struct symtab_and_line)); 6756 make_cleanup (xfree, sals.sals); 6757 init_sal (&sal); /* initialize to zeroes */ 6758 sal.line = default_breakpoint_line; 6759 sal.symtab = default_breakpoint_symtab; 6760 sal.pc = default_breakpoint_address; 6761 if (sal.symtab == 0) 6762 error ("No source file specified."); 6763 6764 sals.sals[0] = sal; 6765 sals.nelts = 1; 6766 6767 default_match = 1; 6768 } 6769 6770 /* For each line spec given, delete bps which correspond 6771 to it. Do it in two passes, solely to preserve the current 6772 behavior that from_tty is forced true if we delete more than 6773 one breakpoint. */ 6774 6775 found = NULL; 6776 for (i = 0; i < sals.nelts; i++) 6777 { 6778 /* If exact pc given, clear bpts at that pc. 6779 If line given (pc == 0), clear all bpts on specified line. 6780 If defaulting, clear all bpts on default line 6781 or at default pc. 6782 6783 defaulting sal.pc != 0 tests to do 6784 6785 0 1 pc 6786 1 1 pc _and_ line 6787 0 0 line 6788 1 0 <can't happen> */ 6789 6790 sal = sals.sals[i]; 6791 prev = NULL; 6792 6793 /* Find all matching breakpoints, remove them from the 6794 breakpoint chain, and add them to the 'found' chain. */ 6795 ALL_BREAKPOINTS_SAFE (b, tmp) 6796 { 6797 /* Are we going to delete b? */ 6798 if (b->type != bp_none 6799 && b->type != bp_watchpoint 6800 && b->type != bp_hardware_watchpoint 6801 && b->type != bp_read_watchpoint 6802 && b->type != bp_access_watchpoint 6803 /* Not if b is a watchpoint of any sort... */ 6804 && (((sal.pc && (b->loc->address == sal.pc)) 6805 && (!section_is_overlay (b->loc->section) 6806 || b->loc->section == sal.section)) 6807 /* Yes, if sal.pc matches b (modulo overlays). */ 6808 || ((default_match || (0 == sal.pc)) 6809 && b->source_file != NULL 6810 && sal.symtab != NULL 6811 && strcmp (b->source_file, sal.symtab->filename) == 0 6812 && b->line_number == sal.line))) 6813 /* Yes, if sal source file and line matches b. */ 6814 { 6815 /* Remove it from breakpoint_chain... */ 6816 if (b == breakpoint_chain) 6817 { 6818 /* b is at the head of the list */ 6819 breakpoint_chain = b->next; 6820 } 6821 else 6822 { 6823 prev->next = b->next; 6824 } 6825 /* And add it to 'found' chain. */ 6826 b->next = found; 6827 found = b; 6828 } 6829 else 6830 { 6831 /* Keep b, and keep a pointer to it. */ 6832 prev = b; 6833 } 6834 } 6835 } 6836 /* Now go thru the 'found' chain and delete them. */ 6837 if (found == 0) 6838 { 6839 if (arg) 6840 error ("No breakpoint at %s.", arg); 6841 else 6842 error ("No breakpoint at this line."); 6843 } 6844 6845 if (found->next) 6846 from_tty = 1; /* Always report if deleted more than one */ 6847 if (from_tty) 6848 printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : ""); 6849 breakpoints_changed (); 6850 while (found) 6851 { 6852 if (from_tty) 6853 printf_unfiltered ("%d ", found->number); 6854 tmp = found->next; 6855 delete_breakpoint (found); 6856 found = tmp; 6857 } 6858 if (from_tty) 6859 putchar_unfiltered ('\n'); 6860} 6861 6862/* Delete breakpoint in BS if they are `delete' breakpoints and 6863 all breakpoints that are marked for deletion, whether hit or not. 6864 This is called after any breakpoint is hit, or after errors. */ 6865 6866void 6867breakpoint_auto_delete (bpstat bs) 6868{ 6869 struct breakpoint *b, *temp; 6870 6871 for (; bs; bs = bs->next) 6872 if (bs->breakpoint_at && bs->breakpoint_at->disposition == disp_del 6873 && bs->stop) 6874 delete_breakpoint (bs->breakpoint_at); 6875 6876 ALL_BREAKPOINTS_SAFE (b, temp) 6877 { 6878 if (b->disposition == disp_del_at_next_stop) 6879 delete_breakpoint (b); 6880 } 6881} 6882 6883/* Delete a breakpoint and clean up all traces of it in the data 6884 structures. */ 6885 6886void 6887delete_breakpoint (struct breakpoint *bpt) 6888{ 6889 struct breakpoint *b; 6890 bpstat bs; 6891 struct bp_location *loc; 6892 6893 if (bpt == NULL) 6894 error ("Internal error (attempted to delete a NULL breakpoint)"); 6895 6896 6897 /* Has this bp already been deleted? This can happen because multiple 6898 lists can hold pointers to bp's. bpstat lists are especial culprits. 6899 6900 One example of this happening is a watchpoint's scope bp. When the 6901 scope bp triggers, we notice that the watchpoint is out of scope, and 6902 delete it. We also delete its scope bp. But the scope bp is marked 6903 "auto-deleting", and is already on a bpstat. That bpstat is then 6904 checked for auto-deleting bp's, which are deleted. 6905 6906 A real solution to this problem might involve reference counts in bp's, 6907 and/or giving them pointers back to their referencing bpstat's, and 6908 teaching delete_breakpoint to only free a bp's storage when no more 6909 references were extent. A cheaper bandaid was chosen. */ 6910 if (bpt->type == bp_none) 6911 return; 6912 6913 if (deprecated_delete_breakpoint_hook) 6914 deprecated_delete_breakpoint_hook (bpt); 6915 breakpoint_delete_event (bpt->number); 6916 6917 if (bpt->loc->inserted) 6918 remove_breakpoint (bpt->loc, mark_inserted); 6919 6920 free_valchain (bpt->loc); 6921 6922 if (breakpoint_chain == bpt) 6923 breakpoint_chain = bpt->next; 6924 6925 if (bp_location_chain == bpt->loc) 6926 bp_location_chain = bpt->loc->next; 6927 6928 /* If we have callback-style exception catchpoints, don't go through 6929 the adjustments to the C++ runtime library etc. if the inferior 6930 isn't actually running. target_enable_exception_callback for a 6931 null target ops vector gives an undesirable error message, so we 6932 check here and avoid it. Since currently (1997-09-17) only HP-UX aCC's 6933 exceptions are supported in this way, it's OK for now. FIXME */ 6934 if (ep_is_exception_catchpoint (bpt) && target_has_execution) 6935 { 6936 /* Format possible error msg */ 6937 char *message = xstrprintf ("Error in deleting catchpoint %d:\n", 6938 bpt->number); 6939 struct cleanup *cleanups = make_cleanup (xfree, message); 6940 args_for_catchpoint_enable args; 6941 args.kind = bpt->type == bp_catch_catch ? 6942 EX_EVENT_CATCH : EX_EVENT_THROW; 6943 args.enable_p = 0; 6944 catch_errors (cover_target_enable_exception_callback, &args, 6945 message, RETURN_MASK_ALL); 6946 do_cleanups (cleanups); 6947 } 6948 6949 6950 ALL_BREAKPOINTS (b) 6951 if (b->next == bpt) 6952 { 6953 b->next = bpt->next; 6954 break; 6955 } 6956 6957 ALL_BP_LOCATIONS (loc) 6958 if (loc->next == bpt->loc) 6959 { 6960 loc->next = bpt->loc->next; 6961 break; 6962 } 6963 6964 check_duplicates (bpt); 6965 /* If this breakpoint was inserted, and there is another breakpoint 6966 at the same address, we need to insert the other breakpoint. */ 6967 if (bpt->loc->inserted 6968 && bpt->type != bp_hardware_watchpoint 6969 && bpt->type != bp_read_watchpoint 6970 && bpt->type != bp_access_watchpoint 6971 && bpt->type != bp_catch_fork 6972 && bpt->type != bp_catch_vfork 6973 && bpt->type != bp_catch_exec) 6974 { 6975 ALL_BREAKPOINTS (b) 6976 if (b->loc->address == bpt->loc->address 6977 && b->loc->section == bpt->loc->section 6978 && !b->loc->duplicate 6979 && b->enable_state != bp_disabled 6980 && b->enable_state != bp_shlib_disabled 6981 && !b->pending 6982 && b->enable_state != bp_call_disabled) 6983 { 6984 int val; 6985 6986 /* We should never reach this point if there is a permanent 6987 breakpoint at the same address as the one being deleted. 6988 If there is a permanent breakpoint somewhere, it should 6989 always be the only one inserted. */ 6990 if (b->enable_state == bp_permanent) 6991 internal_error (__FILE__, __LINE__, 6992 "another breakpoint was inserted on top of " 6993 "a permanent breakpoint"); 6994 6995 if (b->type == bp_hardware_breakpoint) 6996 val = target_insert_hw_breakpoint (b->loc->address, b->loc->shadow_contents); 6997 else 6998 val = target_insert_breakpoint (b->loc->address, b->loc->shadow_contents); 6999 7000 /* If there was an error in the insert, print a message, then stop execution. */ 7001 if (val != 0) 7002 { 7003 struct ui_file *tmp_error_stream = mem_fileopen (); 7004 make_cleanup_ui_file_delete (tmp_error_stream); 7005 7006 7007 if (b->type == bp_hardware_breakpoint) 7008 { 7009 fprintf_unfiltered (tmp_error_stream, 7010 "Cannot insert hardware breakpoint %d.\n" 7011 "You may have requested too many hardware breakpoints.\n", 7012 b->number); 7013 } 7014 else 7015 { 7016 fprintf_unfiltered (tmp_error_stream, "Cannot insert breakpoint %d.\n", b->number); 7017 fprintf_filtered (tmp_error_stream, "Error accessing memory address "); 7018 print_address_numeric (b->loc->address, 1, tmp_error_stream); 7019 fprintf_filtered (tmp_error_stream, ": %s.\n", 7020 safe_strerror (val)); 7021 } 7022 7023 fprintf_unfiltered (tmp_error_stream,"The same program may be running in another process."); 7024 target_terminal_ours_for_output (); 7025 error_stream(tmp_error_stream); 7026 } 7027 else 7028 b->loc->inserted = 1; 7029 } 7030 } 7031 7032 free_command_lines (&bpt->commands); 7033 if (bpt->cond) 7034 xfree (bpt->cond); 7035 if (bpt->cond_string != NULL) 7036 xfree (bpt->cond_string); 7037 if (bpt->addr_string != NULL) 7038 xfree (bpt->addr_string); 7039 if (bpt->exp != NULL) 7040 xfree (bpt->exp); 7041 if (bpt->exp_string != NULL) 7042 xfree (bpt->exp_string); 7043 if (bpt->val != NULL) 7044 value_free (bpt->val); 7045 if (bpt->source_file != NULL) 7046 xfree (bpt->source_file); 7047 if (bpt->dll_pathname != NULL) 7048 xfree (bpt->dll_pathname); 7049 if (bpt->triggered_dll_pathname != NULL) 7050 xfree (bpt->triggered_dll_pathname); 7051 if (bpt->exec_pathname != NULL) 7052 xfree (bpt->exec_pathname); 7053 7054 /* Be sure no bpstat's are pointing at it after it's been freed. */ 7055 /* FIXME, how can we find all bpstat's? 7056 We just check stop_bpstat for now. */ 7057 for (bs = stop_bpstat; bs; bs = bs->next) 7058 if (bs->breakpoint_at == bpt) 7059 { 7060 bs->breakpoint_at = NULL; 7061 bs->old_val = NULL; 7062 /* bs->commands will be freed later. */ 7063 } 7064 /* On the chance that someone will soon try again to delete this same 7065 bp, we mark it as deleted before freeing its storage. */ 7066 bpt->type = bp_none; 7067 7068 xfree (bpt->loc); 7069 xfree (bpt); 7070} 7071 7072static void 7073do_delete_breakpoint_cleanup (void *b) 7074{ 7075 delete_breakpoint (b); 7076} 7077 7078struct cleanup * 7079make_cleanup_delete_breakpoint (struct breakpoint *b) 7080{ 7081 return make_cleanup (do_delete_breakpoint_cleanup, b); 7082} 7083 7084struct cleanup * 7085make_exec_cleanup_delete_breakpoint (struct breakpoint *b) 7086{ 7087 return make_exec_cleanup (do_delete_breakpoint_cleanup, b); 7088} 7089 7090void 7091delete_command (char *arg, int from_tty) 7092{ 7093 struct breakpoint *b, *temp; 7094 7095 dont_repeat (); 7096 7097 if (arg == 0) 7098 { 7099 int breaks_to_delete = 0; 7100 7101 /* Delete all breakpoints if no argument. 7102 Do not delete internal or call-dummy breakpoints, these 7103 have to be deleted with an explicit breakpoint number argument. */ 7104 ALL_BREAKPOINTS (b) 7105 { 7106 if (b->type != bp_call_dummy && 7107 b->type != bp_shlib_event && 7108 b->type != bp_thread_event && 7109 b->type != bp_overlay_event && 7110 b->number >= 0) 7111 breaks_to_delete = 1; 7112 } 7113 7114 /* Ask user only if there are some breakpoints to delete. */ 7115 if (!from_tty 7116 || (breaks_to_delete && query ("Delete all breakpoints? "))) 7117 { 7118 ALL_BREAKPOINTS_SAFE (b, temp) 7119 { 7120 if (b->type != bp_call_dummy && 7121 b->type != bp_shlib_event && 7122 b->type != bp_thread_event && 7123 b->type != bp_overlay_event && 7124 b->number >= 0) 7125 delete_breakpoint (b); 7126 } 7127 } 7128 } 7129 else 7130 map_breakpoint_numbers (arg, delete_breakpoint); 7131} 7132 7133/* Reset a breakpoint given it's struct breakpoint * BINT. 7134 The value we return ends up being the return value from catch_errors. 7135 Unused in this case. */ 7136 7137static int 7138breakpoint_re_set_one (void *bint) 7139{ 7140 /* get past catch_errs */ 7141 struct breakpoint *b = (struct breakpoint *) bint; 7142 struct value *mark; 7143 int i; 7144 int not_found; 7145 int *not_found_ptr = NULL; 7146 struct symtabs_and_lines sals; 7147 char *s; 7148 enum enable_state save_enable; 7149 7150 switch (b->type) 7151 { 7152 case bp_none: 7153 warning ("attempted to reset apparently deleted breakpoint #%d?", 7154 b->number); 7155 return 0; 7156 case bp_breakpoint: 7157 case bp_hardware_breakpoint: 7158 case bp_catch_load: 7159 case bp_catch_unload: 7160 if (b->addr_string == NULL) 7161 { 7162 /* Anything without a string can't be re-set. */ 7163 delete_breakpoint (b); 7164 return 0; 7165 } 7166 /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote: 7167 7168 ``And a hack it is, although Apple's Darwin version of GDB 7169 contains an almost identical hack to implement a "future 7170 break" command. It seems to work in many real world cases, 7171 but it is easy to come up with a test case where the patch 7172 doesn't help at all.'' 7173 7174 ``It seems that the way GDB implements breakpoints - in - 7175 shared - libraries was designed for a.out shared library 7176 systems (SunOS 4) where shared libraries were loaded at a 7177 fixed address in memory. Since ELF shared libraries can (and 7178 will) be loaded at any address in memory, things break. 7179 Fixing this is not trivial. Therefore, I'm not sure whether 7180 we should add this hack to the branch only. I cannot 7181 guarantee that things will be fixed on the trunk in the near 7182 future.'' 7183 7184 In case we have a problem, disable this breakpoint. We'll 7185 restore its status if we succeed. Don't disable a 7186 shlib_disabled breakpoint though. There's a fair chance we 7187 can't re-set it if the shared library it's in hasn't been 7188 loaded yet. */ 7189 7190 if (b->pending) 7191 break; 7192 7193 save_enable = b->enable_state; 7194 if (b->enable_state != bp_shlib_disabled) 7195 b->enable_state = bp_disabled; 7196 else 7197 /* If resetting a shlib-disabled breakpoint, we don't want to 7198 see an error message if it is not found since we will expect 7199 this to occur until the shared library is finally reloaded. 7200 We accomplish this by giving decode_line_1 a pointer to use 7201 for silent notification that the symbol is not found. */ 7202 not_found_ptr = ¬_found; 7203 7204 set_language (b->language); 7205 input_radix = b->input_radix; 7206 s = b->addr_string; 7207 sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, (char ***) NULL, 7208 not_found_ptr); 7209 for (i = 0; i < sals.nelts; i++) 7210 { 7211 resolve_sal_pc (&sals.sals[i]); 7212 7213 /* Reparse conditions, they might contain references to the 7214 old symtab. */ 7215 if (b->cond_string != NULL) 7216 { 7217 s = b->cond_string; 7218 if (b->cond) 7219 { 7220 xfree (b->cond); 7221 /* Avoid re-freeing b->exp if an error during the call 7222 to parse_exp_1. */ 7223 b->cond = NULL; 7224 } 7225 b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0); 7226 } 7227 7228 /* We need to re-set the breakpoint if the address changes... */ 7229 if (b->loc->address != sals.sals[i].pc 7230 /* ...or new and old breakpoints both have source files, and 7231 the source file name or the line number changes... */ 7232 || (b->source_file != NULL 7233 && sals.sals[i].symtab != NULL 7234 && (strcmp (b->source_file, sals.sals[i].symtab->filename) != 0 7235 || b->line_number != sals.sals[i].line) 7236 ) 7237 /* ...or we switch between having a source file and not having 7238 one. */ 7239 || ((b->source_file == NULL) != (sals.sals[i].symtab == NULL)) 7240 ) 7241 { 7242 if (b->source_file != NULL) 7243 xfree (b->source_file); 7244 if (sals.sals[i].symtab == NULL) 7245 b->source_file = NULL; 7246 else 7247 b->source_file = 7248 savestring (sals.sals[i].symtab->filename, 7249 strlen (sals.sals[i].symtab->filename)); 7250 b->line_number = sals.sals[i].line; 7251 b->loc->requested_address = sals.sals[i].pc; 7252 b->loc->address 7253 = adjust_breakpoint_address (b->loc->requested_address, 7254 b->type); 7255 7256 /* Used to check for duplicates here, but that can 7257 cause trouble, as it doesn't check for disabled 7258 breakpoints. */ 7259 7260 mention (b); 7261 7262 /* Might be better to do this just once per breakpoint_re_set, 7263 rather than once for every breakpoint. */ 7264 breakpoints_changed (); 7265 } 7266 b->loc->section = sals.sals[i].section; 7267 b->enable_state = save_enable; /* Restore it, this worked. */ 7268 7269 7270 /* Now that this is re-enabled, check_duplicates 7271 can be used. */ 7272 check_duplicates (b); 7273 7274 } 7275 xfree (sals.sals); 7276 break; 7277 7278 case bp_watchpoint: 7279 case bp_hardware_watchpoint: 7280 case bp_read_watchpoint: 7281 case bp_access_watchpoint: 7282 innermost_block = NULL; 7283 /* The issue arises of what context to evaluate this in. The 7284 same one as when it was set, but what does that mean when 7285 symbols have been re-read? We could save the filename and 7286 functionname, but if the context is more local than that, the 7287 best we could do would be something like how many levels deep 7288 and which index at that particular level, but that's going to 7289 be less stable than filenames or function names. */ 7290 7291 /* So for now, just use a global context. */ 7292 if (b->exp) 7293 { 7294 xfree (b->exp); 7295 /* Avoid re-freeing b->exp if an error during the call to 7296 parse_expression. */ 7297 b->exp = NULL; 7298 } 7299 b->exp = parse_expression (b->exp_string); 7300 b->exp_valid_block = innermost_block; 7301 mark = value_mark (); 7302 if (b->val) 7303 { 7304 value_free (b->val); 7305 /* Avoid re-freeing b->val if an error during the call to 7306 evaluate_expression. */ 7307 b->val = NULL; 7308 } 7309 b->val = evaluate_expression (b->exp); 7310 release_value (b->val); 7311 if (VALUE_LAZY (b->val) && breakpoint_enabled (b)) 7312 value_fetch_lazy (b->val); 7313 7314 if (b->cond_string != NULL) 7315 { 7316 s = b->cond_string; 7317 if (b->cond) 7318 { 7319 xfree (b->cond); 7320 /* Avoid re-freeing b->exp if an error during the call 7321 to parse_exp_1. */ 7322 b->cond = NULL; 7323 } 7324 b->cond = parse_exp_1 (&s, (struct block *) 0, 0); 7325 } 7326 if (breakpoint_enabled (b)) 7327 mention (b); 7328 value_free_to_mark (mark); 7329 break; 7330 case bp_catch_catch: 7331 case bp_catch_throw: 7332 break; 7333 /* We needn't really do anything to reset these, since the mask 7334 that requests them is unaffected by e.g., new libraries being 7335 loaded. */ 7336 case bp_catch_fork: 7337 case bp_catch_vfork: 7338 case bp_catch_exec: 7339 break; 7340 7341 default: 7342 printf_filtered ("Deleting unknown breakpoint type %d\n", b->type); 7343 /* fall through */ 7344 /* Delete longjmp and overlay event breakpoints; they will be 7345 reset later by breakpoint_re_set. */ 7346 case bp_longjmp: 7347 case bp_longjmp_resume: 7348 case bp_overlay_event: 7349 delete_breakpoint (b); 7350 break; 7351 7352 /* This breakpoint is special, it's set up when the inferior 7353 starts and we really don't want to touch it. */ 7354 case bp_shlib_event: 7355 7356 /* Like bp_shlib_event, this breakpoint type is special. 7357 Once it is set up, we do not want to touch it. */ 7358 case bp_thread_event: 7359 7360 /* Keep temporary breakpoints, which can be encountered when we step 7361 over a dlopen call and SOLIB_ADD is resetting the breakpoints. 7362 Otherwise these should have been blown away via the cleanup chain 7363 or by breakpoint_init_inferior when we rerun the executable. */ 7364 case bp_until: 7365 case bp_finish: 7366 case bp_watchpoint_scope: 7367 case bp_call_dummy: 7368 case bp_step_resume: 7369 break; 7370 } 7371 7372 return 0; 7373} 7374 7375/* Re-set all breakpoints after symbols have been re-loaded. */ 7376void 7377breakpoint_re_set (void) 7378{ 7379 struct breakpoint *b, *temp; 7380 enum language save_language; 7381 int save_input_radix; 7382 7383 save_language = current_language->la_language; 7384 save_input_radix = input_radix; 7385 ALL_BREAKPOINTS_SAFE (b, temp) 7386 { 7387 /* Format possible error msg */ 7388 char *message = xstrprintf ("Error in re-setting breakpoint %d:\n", 7389 b->number); 7390 struct cleanup *cleanups = make_cleanup (xfree, message); 7391 catch_errors (breakpoint_re_set_one, b, message, RETURN_MASK_ALL); 7392 do_cleanups (cleanups); 7393 } 7394 set_language (save_language); 7395 input_radix = save_input_radix; 7396 7397 if (GET_LONGJMP_TARGET_P ()) 7398 { 7399 create_longjmp_breakpoint ("longjmp"); 7400 create_longjmp_breakpoint ("_longjmp"); 7401 create_longjmp_breakpoint ("siglongjmp"); 7402 create_longjmp_breakpoint ("_siglongjmp"); 7403 create_longjmp_breakpoint (NULL); 7404 } 7405 7406 create_overlay_event_breakpoint ("_ovly_debug_event"); 7407} 7408 7409/* Reset the thread number of this breakpoint: 7410 7411 - If the breakpoint is for all threads, leave it as-is. 7412 - Else, reset it to the current thread for inferior_ptid. */ 7413void 7414breakpoint_re_set_thread (struct breakpoint *b) 7415{ 7416 if (b->thread != -1) 7417 { 7418 if (in_thread_list (inferior_ptid)) 7419 b->thread = pid_to_thread_id (inferior_ptid); 7420 } 7421} 7422 7423/* Set ignore-count of breakpoint number BPTNUM to COUNT. 7424 If from_tty is nonzero, it prints a message to that effect, 7425 which ends with a period (no newline). */ 7426 7427void 7428set_ignore_count (int bptnum, int count, int from_tty) 7429{ 7430 struct breakpoint *b; 7431 7432 if (count < 0) 7433 count = 0; 7434 7435 ALL_BREAKPOINTS (b) 7436 if (b->number == bptnum) 7437 { 7438 b->ignore_count = count; 7439 if (from_tty) 7440 { 7441 if (count == 0) 7442 printf_filtered ("Will stop next time breakpoint %d is reached.", 7443 bptnum); 7444 else if (count == 1) 7445 printf_filtered ("Will ignore next crossing of breakpoint %d.", 7446 bptnum); 7447 else 7448 printf_filtered ("Will ignore next %d crossings of breakpoint %d.", 7449 count, bptnum); 7450 } 7451 breakpoints_changed (); 7452 breakpoint_modify_event (b->number); 7453 return; 7454 } 7455 7456 error ("No breakpoint number %d.", bptnum); 7457} 7458 7459/* Clear the ignore counts of all breakpoints. */ 7460void 7461breakpoint_clear_ignore_counts (void) 7462{ 7463 struct breakpoint *b; 7464 7465 ALL_BREAKPOINTS (b) 7466 b->ignore_count = 0; 7467} 7468 7469/* Command to set ignore-count of breakpoint N to COUNT. */ 7470 7471static void 7472ignore_command (char *args, int from_tty) 7473{ 7474 char *p = args; 7475 int num; 7476 7477 if (p == 0) 7478 error_no_arg ("a breakpoint number"); 7479 7480 num = get_number (&p); 7481 if (num == 0) 7482 error ("bad breakpoint number: '%s'", args); 7483 if (*p == 0) 7484 error ("Second argument (specified ignore-count) is missing."); 7485 7486 set_ignore_count (num, 7487 longest_to_int (value_as_long (parse_and_eval (p))), 7488 from_tty); 7489 if (from_tty) 7490 printf_filtered ("\n"); 7491} 7492 7493/* Call FUNCTION on each of the breakpoints 7494 whose numbers are given in ARGS. */ 7495 7496static void 7497map_breakpoint_numbers (char *args, void (*function) (struct breakpoint *)) 7498{ 7499 char *p = args; 7500 char *p1; 7501 int num; 7502 struct breakpoint *b, *tmp; 7503 int match; 7504 7505 if (p == 0) 7506 error_no_arg ("one or more breakpoint numbers"); 7507 7508 while (*p) 7509 { 7510 match = 0; 7511 p1 = p; 7512 7513 num = get_number_or_range (&p1); 7514 if (num == 0) 7515 { 7516 warning ("bad breakpoint number at or near '%s'", p); 7517 } 7518 else 7519 { 7520 ALL_BREAKPOINTS_SAFE (b, tmp) 7521 if (b->number == num) 7522 { 7523 struct breakpoint *related_breakpoint = b->related_breakpoint; 7524 match = 1; 7525 function (b); 7526 if (related_breakpoint) 7527 function (related_breakpoint); 7528 break; 7529 } 7530 if (match == 0) 7531 printf_unfiltered ("No breakpoint number %d.\n", num); 7532 } 7533 p = p1; 7534 } 7535} 7536 7537/* Set ignore-count of breakpoint number BPTNUM to COUNT. 7538 If from_tty is nonzero, it prints a message to that effect, 7539 which ends with a period (no newline). */ 7540 7541void 7542disable_breakpoint (struct breakpoint *bpt) 7543{ 7544 /* Never disable a watchpoint scope breakpoint; we want to 7545 hit them when we leave scope so we can delete both the 7546 watchpoint and its scope breakpoint at that time. */ 7547 if (bpt->type == bp_watchpoint_scope) 7548 return; 7549 7550 /* You can't disable permanent breakpoints. */ 7551 if (bpt->enable_state == bp_permanent) 7552 return; 7553 7554 bpt->enable_state = bp_disabled; 7555 7556 check_duplicates (bpt); 7557 7558 if (deprecated_modify_breakpoint_hook) 7559 deprecated_modify_breakpoint_hook (bpt); 7560 breakpoint_modify_event (bpt->number); 7561} 7562 7563static void 7564disable_command (char *args, int from_tty) 7565{ 7566 struct breakpoint *bpt; 7567 if (args == 0) 7568 ALL_BREAKPOINTS (bpt) 7569 switch (bpt->type) 7570 { 7571 case bp_none: 7572 warning ("attempted to disable apparently deleted breakpoint #%d?", 7573 bpt->number); 7574 continue; 7575 case bp_breakpoint: 7576 case bp_catch_load: 7577 case bp_catch_unload: 7578 case bp_catch_fork: 7579 case bp_catch_vfork: 7580 case bp_catch_exec: 7581 case bp_catch_catch: 7582 case bp_catch_throw: 7583 case bp_hardware_breakpoint: 7584 case bp_watchpoint: 7585 case bp_hardware_watchpoint: 7586 case bp_read_watchpoint: 7587 case bp_access_watchpoint: 7588 disable_breakpoint (bpt); 7589 default: 7590 continue; 7591 } 7592 else 7593 map_breakpoint_numbers (args, disable_breakpoint); 7594} 7595 7596static void 7597do_enable_breakpoint (struct breakpoint *bpt, enum bpdisp disposition) 7598{ 7599 int target_resources_ok, other_type_used; 7600 struct value *mark; 7601 7602 if (bpt->type == bp_hardware_breakpoint) 7603 { 7604 int i; 7605 i = hw_breakpoint_used_count (); 7606 target_resources_ok = 7607 TARGET_CAN_USE_HARDWARE_WATCHPOINT (bp_hardware_breakpoint, 7608 i + 1, 0); 7609 if (target_resources_ok == 0) 7610 error ("No hardware breakpoint support in the target."); 7611 else if (target_resources_ok < 0) 7612 error ("Hardware breakpoints used exceeds limit."); 7613 } 7614 7615 if (bpt->pending) 7616 { 7617 if (bpt->enable_state != bp_enabled) 7618 { 7619 /* When enabling a pending breakpoint, we need to check if the breakpoint 7620 is resolvable since shared libraries could have been loaded 7621 after the breakpoint was disabled. */ 7622 breakpoints_changed (); 7623 if (resolve_pending_breakpoint (bpt) == GDB_RC_OK) 7624 { 7625 delete_breakpoint (bpt); 7626 return; 7627 } 7628 bpt->enable_state = bp_enabled; 7629 bpt->disposition = disposition; 7630 } 7631 } 7632 else /* Not a pending breakpoint. */ 7633 { 7634 if (bpt->enable_state != bp_permanent) 7635 bpt->enable_state = bp_enabled; 7636 bpt->disposition = disposition; 7637 check_duplicates (bpt); 7638 breakpoints_changed (); 7639 7640 if (bpt->type == bp_watchpoint || 7641 bpt->type == bp_hardware_watchpoint || 7642 bpt->type == bp_read_watchpoint || 7643 bpt->type == bp_access_watchpoint) 7644 { 7645 struct frame_id saved_frame_id; 7646 7647 saved_frame_id = get_frame_id (get_selected_frame ()); 7648 if (bpt->exp_valid_block != NULL) 7649 { 7650 struct frame_info *fr = 7651 fr = frame_find_by_id (bpt->watchpoint_frame); 7652 if (fr == NULL) 7653 { 7654 printf_filtered ("\ 7655Cannot enable watchpoint %d because the block in which its expression\n\ 7656is valid is not currently in scope.\n", bpt->number); 7657 bpt->enable_state = bp_disabled; 7658 return; 7659 } 7660 select_frame (fr); 7661 } 7662 7663 value_free (bpt->val); 7664 mark = value_mark (); 7665 bpt->val = evaluate_expression (bpt->exp); 7666 release_value (bpt->val); 7667 if (VALUE_LAZY (bpt->val)) 7668 value_fetch_lazy (bpt->val); 7669 7670 if (bpt->type == bp_hardware_watchpoint || 7671 bpt->type == bp_read_watchpoint || 7672 bpt->type == bp_access_watchpoint) 7673 { 7674 int i = hw_watchpoint_used_count (bpt->type, &other_type_used); 7675 int mem_cnt = can_use_hardware_watchpoint (bpt->val); 7676 7677 /* Hack around 'unused var' error for some targets here */ 7678 (void) mem_cnt, i; 7679 target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT ( 7680 bpt->type, i + mem_cnt, other_type_used); 7681 /* we can consider of type is bp_hardware_watchpoint, convert to 7682 bp_watchpoint in the following condition */ 7683 if (target_resources_ok < 0) 7684 { 7685 printf_filtered ("\ 7686Cannot enable watchpoint %d because target watch resources\n\ 7687have been allocated for other watchpoints.\n", bpt->number); 7688 bpt->enable_state = bp_disabled; 7689 value_free_to_mark (mark); 7690 return; 7691 } 7692 } 7693 7694 select_frame (frame_find_by_id (saved_frame_id)); 7695 value_free_to_mark (mark); 7696 } 7697 } 7698 7699 if (deprecated_modify_breakpoint_hook) 7700 deprecated_modify_breakpoint_hook (bpt); 7701 breakpoint_modify_event (bpt->number); 7702} 7703 7704void 7705enable_breakpoint (struct breakpoint *bpt) 7706{ 7707 do_enable_breakpoint (bpt, bpt->disposition); 7708} 7709 7710/* The enable command enables the specified breakpoints (or all defined 7711 breakpoints) so they once again become (or continue to be) effective 7712 in stopping the inferior. */ 7713 7714static void 7715enable_command (char *args, int from_tty) 7716{ 7717 struct breakpoint *bpt; 7718 if (args == 0) 7719 ALL_BREAKPOINTS (bpt) 7720 switch (bpt->type) 7721 { 7722 case bp_none: 7723 warning ("attempted to enable apparently deleted breakpoint #%d?", 7724 bpt->number); 7725 continue; 7726 case bp_breakpoint: 7727 case bp_catch_load: 7728 case bp_catch_unload: 7729 case bp_catch_fork: 7730 case bp_catch_vfork: 7731 case bp_catch_exec: 7732 case bp_catch_catch: 7733 case bp_catch_throw: 7734 case bp_hardware_breakpoint: 7735 case bp_watchpoint: 7736 case bp_hardware_watchpoint: 7737 case bp_read_watchpoint: 7738 case bp_access_watchpoint: 7739 enable_breakpoint (bpt); 7740 default: 7741 continue; 7742 } 7743 else 7744 map_breakpoint_numbers (args, enable_breakpoint); 7745} 7746 7747static void 7748enable_once_breakpoint (struct breakpoint *bpt) 7749{ 7750 do_enable_breakpoint (bpt, disp_disable); 7751} 7752 7753static void 7754enable_once_command (char *args, int from_tty) 7755{ 7756 map_breakpoint_numbers (args, enable_once_breakpoint); 7757} 7758 7759static void 7760enable_delete_breakpoint (struct breakpoint *bpt) 7761{ 7762 do_enable_breakpoint (bpt, disp_del); 7763} 7764 7765static void 7766enable_delete_command (char *args, int from_tty) 7767{ 7768 map_breakpoint_numbers (args, enable_delete_breakpoint); 7769} 7770 7771static void 7772set_breakpoint_cmd (char *args, int from_tty) 7773{ 7774} 7775 7776static void 7777show_breakpoint_cmd (char *args, int from_tty) 7778{ 7779} 7780 7781/* Use default_breakpoint_'s, or nothing if they aren't valid. */ 7782 7783struct symtabs_and_lines 7784decode_line_spec_1 (char *string, int funfirstline) 7785{ 7786 struct symtabs_and_lines sals; 7787 if (string == 0) 7788 error ("Empty line specification."); 7789 if (default_breakpoint_valid) 7790 sals = decode_line_1 (&string, funfirstline, 7791 default_breakpoint_symtab, 7792 default_breakpoint_line, 7793 (char ***) NULL, NULL); 7794 else 7795 sals = decode_line_1 (&string, funfirstline, 7796 (struct symtab *) NULL, 0, (char ***) NULL, NULL); 7797 if (*string) 7798 error ("Junk at end of line specification: %s", string); 7799 return sals; 7800} 7801 7802void 7803_initialize_breakpoint (void) 7804{ 7805 static struct cmd_list_element *breakpoint_set_cmdlist; 7806 static struct cmd_list_element *breakpoint_show_cmdlist; 7807 struct cmd_list_element *c; 7808 7809#ifdef SOLIB_ADD 7810 observer_attach_solib_unloaded (disable_breakpoints_in_unloaded_shlib); 7811#endif 7812 7813 breakpoint_chain = 0; 7814 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful 7815 before a breakpoint is set. */ 7816 breakpoint_count = 0; 7817 7818 add_com ("ignore", class_breakpoint, ignore_command, 7819 "Set ignore-count of breakpoint number N to COUNT.\n\ 7820Usage is `ignore N COUNT'."); 7821 if (xdb_commands) 7822 add_com_alias ("bc", "ignore", class_breakpoint, 1); 7823 7824 add_com ("commands", class_breakpoint, commands_command, 7825 "Set commands to be executed when a breakpoint is hit.\n\ 7826Give breakpoint number as argument after \"commands\".\n\ 7827With no argument, the targeted breakpoint is the last one set.\n\ 7828The commands themselves follow starting on the next line.\n\ 7829Type a line containing \"end\" to indicate the end of them.\n\ 7830Give \"silent\" as the first line to make the breakpoint silent;\n\ 7831then no output is printed when it is hit, except what the commands print."); 7832 7833 add_com ("condition", class_breakpoint, condition_command, 7834 "Specify breakpoint number N to break only if COND is true.\n\ 7835Usage is `condition N COND', where N is an integer and COND is an\n\ 7836expression to be evaluated whenever breakpoint N is reached."); 7837 7838 c = add_com ("tbreak", class_breakpoint, tbreak_command, 7839 "Set a temporary breakpoint. Args like \"break\" command.\n\ 7840Like \"break\" except the breakpoint is only temporary,\n\ 7841so it will be deleted when hit. Equivalent to \"break\" followed\n\ 7842by using \"enable delete\" on the breakpoint number."); 7843 set_cmd_completer (c, location_completer); 7844 7845 c = add_com ("hbreak", class_breakpoint, hbreak_command, 7846 "Set a hardware assisted breakpoint. Args like \"break\" command.\n\ 7847Like \"break\" except the breakpoint requires hardware support,\n\ 7848some target hardware may not have this support."); 7849 set_cmd_completer (c, location_completer); 7850 7851 c = add_com ("thbreak", class_breakpoint, thbreak_command, 7852 "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\ 7853Like \"hbreak\" except the breakpoint is only temporary,\n\ 7854so it will be deleted when hit."); 7855 set_cmd_completer (c, location_completer); 7856 7857 add_prefix_cmd ("enable", class_breakpoint, enable_command, 7858 "Enable some breakpoints.\n\ 7859Give breakpoint numbers (separated by spaces) as arguments.\n\ 7860With no subcommand, breakpoints are enabled until you command otherwise.\n\ 7861This is used to cancel the effect of the \"disable\" command.\n\ 7862With a subcommand you can enable temporarily.", 7863 &enablelist, "enable ", 1, &cmdlist); 7864 if (xdb_commands) 7865 add_com ("ab", class_breakpoint, enable_command, 7866 "Enable some breakpoints.\n\ 7867Give breakpoint numbers (separated by spaces) as arguments.\n\ 7868With no subcommand, breakpoints are enabled until you command otherwise.\n\ 7869This is used to cancel the effect of the \"disable\" command.\n\ 7870With a subcommand you can enable temporarily."); 7871 7872 add_com_alias ("en", "enable", class_breakpoint, 1); 7873 7874 add_abbrev_prefix_cmd ("breakpoints", class_breakpoint, enable_command, 7875 "Enable some breakpoints.\n\ 7876Give breakpoint numbers (separated by spaces) as arguments.\n\ 7877This is used to cancel the effect of the \"disable\" command.\n\ 7878May be abbreviated to simply \"enable\".\n", 7879 &enablebreaklist, "enable breakpoints ", 1, &enablelist); 7880 7881 add_cmd ("once", no_class, enable_once_command, 7882 "Enable breakpoints for one hit. Give breakpoint numbers.\n\ 7883If a breakpoint is hit while enabled in this fashion, it becomes disabled.", 7884 &enablebreaklist); 7885 7886 add_cmd ("delete", no_class, enable_delete_command, 7887 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\ 7888If a breakpoint is hit while enabled in this fashion, it is deleted.", 7889 &enablebreaklist); 7890 7891 add_cmd ("delete", no_class, enable_delete_command, 7892 "Enable breakpoints and delete when hit. Give breakpoint numbers.\n\ 7893If a breakpoint is hit while enabled in this fashion, it is deleted.", 7894 &enablelist); 7895 7896 add_cmd ("once", no_class, enable_once_command, 7897 "Enable breakpoints for one hit. Give breakpoint numbers.\n\ 7898If a breakpoint is hit while enabled in this fashion, it becomes disabled.", 7899 &enablelist); 7900 7901 add_prefix_cmd ("disable", class_breakpoint, disable_command, 7902 "Disable some breakpoints.\n\ 7903Arguments are breakpoint numbers with spaces in between.\n\ 7904To disable all breakpoints, give no argument.\n\ 7905A disabled breakpoint is not forgotten, but has no effect until reenabled.", 7906 &disablelist, "disable ", 1, &cmdlist); 7907 add_com_alias ("dis", "disable", class_breakpoint, 1); 7908 add_com_alias ("disa", "disable", class_breakpoint, 1); 7909 if (xdb_commands) 7910 add_com ("sb", class_breakpoint, disable_command, 7911 "Disable some breakpoints.\n\ 7912Arguments are breakpoint numbers with spaces in between.\n\ 7913To disable all breakpoints, give no argument.\n\ 7914A disabled breakpoint is not forgotten, but has no effect until reenabled."); 7915 7916 add_cmd ("breakpoints", class_alias, disable_command, 7917 "Disable some breakpoints.\n\ 7918Arguments are breakpoint numbers with spaces in between.\n\ 7919To disable all breakpoints, give no argument.\n\ 7920A disabled breakpoint is not forgotten, but has no effect until reenabled.\n\ 7921This command may be abbreviated \"disable\".", 7922 &disablelist); 7923 7924 add_prefix_cmd ("delete", class_breakpoint, delete_command, 7925 "Delete some breakpoints or auto-display expressions.\n\ 7926Arguments are breakpoint numbers with spaces in between.\n\ 7927To delete all breakpoints, give no argument.\n\ 7928\n\ 7929Also a prefix command for deletion of other GDB objects.\n\ 7930The \"unset\" command is also an alias for \"delete\".", 7931 &deletelist, "delete ", 1, &cmdlist); 7932 add_com_alias ("d", "delete", class_breakpoint, 1); 7933 if (xdb_commands) 7934 add_com ("db", class_breakpoint, delete_command, 7935 "Delete some breakpoints.\n\ 7936Arguments are breakpoint numbers with spaces in between.\n\ 7937To delete all breakpoints, give no argument.\n"); 7938 7939 add_cmd ("breakpoints", class_alias, delete_command, 7940 "Delete some breakpoints or auto-display expressions.\n\ 7941Arguments are breakpoint numbers with spaces in between.\n\ 7942To delete all breakpoints, give no argument.\n\ 7943This command may be abbreviated \"delete\".", 7944 &deletelist); 7945 7946 add_com ("clear", class_breakpoint, clear_command, 7947 concat ("Clear breakpoint at specified line or function.\n\ 7948Argument may be line number, function name, or \"*\" and an address.\n\ 7949If line number is specified, all breakpoints in that line are cleared.\n\ 7950If function is specified, breakpoints at beginning of function are cleared.\n\ 7951If an address is specified, breakpoints at that address are cleared.\n\n", 7952 "With no argument, clears all breakpoints in the line that the selected frame\n\ 7953is executing in.\n\ 7954\n\ 7955See also the \"delete\" command which clears breakpoints by number.", NULL)); 7956 7957 c = add_com ("break", class_breakpoint, break_command, 7958 concat ("Set breakpoint at specified line or function.\n\ 7959Argument may be line number, function name, or \"*\" and an address.\n\ 7960If line number is specified, break at start of code for that line.\n\ 7961If function is specified, break at start of code for that function.\n\ 7962If an address is specified, break at that exact address.\n", 7963 "With no arg, uses current execution address of selected stack frame.\n\ 7964This is useful for breaking on return to a stack frame.\n\ 7965\n\ 7966Multiple breakpoints at one place are permitted, and useful if conditional.\n\ 7967\n\ 7968Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL)); 7969 set_cmd_completer (c, location_completer); 7970 7971 add_com_alias ("b", "break", class_run, 1); 7972 add_com_alias ("br", "break", class_run, 1); 7973 add_com_alias ("bre", "break", class_run, 1); 7974 add_com_alias ("brea", "break", class_run, 1); 7975 7976 if (xdb_commands) 7977 { 7978 add_com_alias ("ba", "break", class_breakpoint, 1); 7979 add_com_alias ("bu", "ubreak", class_breakpoint, 1); 7980 } 7981 7982 if (dbx_commands) 7983 { 7984 add_abbrev_prefix_cmd ("stop", class_breakpoint, stop_command, 7985 "Break in function/address or break at a line in the current file.", 7986 &stoplist, "stop ", 1, &cmdlist); 7987 add_cmd ("in", class_breakpoint, stopin_command, 7988 "Break in function or address.\n", &stoplist); 7989 add_cmd ("at", class_breakpoint, stopat_command, 7990 "Break at a line in the current file.\n", &stoplist); 7991 add_com ("status", class_info, breakpoints_info, 7992 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\ 7993The \"Type\" column indicates one of:\n\ 7994\tbreakpoint - normal breakpoint\n\ 7995\twatchpoint - watchpoint\n\ 7996The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\ 7997the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\ 7998breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\ 7999address and file/line number respectively.\n\n", 8000 "Convenience variable \"$_\" and default examine address for \"x\"\n\ 8001are set to the address of the last breakpoint listed.\n\n\ 8002Convenience variable \"$bpnum\" contains the number of the last\n\ 8003breakpoint set.", NULL)); 8004 } 8005 8006 add_info ("breakpoints", breakpoints_info, 8007 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\ 8008The \"Type\" column indicates one of:\n\ 8009\tbreakpoint - normal breakpoint\n\ 8010\twatchpoint - watchpoint\n\ 8011The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\ 8012the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\ 8013breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\ 8014address and file/line number respectively.\n\n", 8015 "Convenience variable \"$_\" and default examine address for \"x\"\n\ 8016are set to the address of the last breakpoint listed.\n\n\ 8017Convenience variable \"$bpnum\" contains the number of the last\n\ 8018breakpoint set.", NULL)); 8019 8020 if (xdb_commands) 8021 add_com ("lb", class_breakpoint, breakpoints_info, 8022 concat ("Status of user-settable breakpoints, or breakpoint number NUMBER.\n\ 8023The \"Type\" column indicates one of:\n\ 8024\tbreakpoint - normal breakpoint\n\ 8025\twatchpoint - watchpoint\n\ 8026The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\ 8027the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\ 8028breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\ 8029address and file/line number respectively.\n\n", 8030 "Convenience variable \"$_\" and default examine address for \"x\"\n\ 8031are set to the address of the last breakpoint listed.\n\n\ 8032Convenience variable \"$bpnum\" contains the number of the last\n\ 8033breakpoint set.", NULL)); 8034 8035 add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints, 8036 concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\ 8037The \"Type\" column indicates one of:\n\ 8038\tbreakpoint - normal breakpoint\n\ 8039\twatchpoint - watchpoint\n\ 8040\tlongjmp - internal breakpoint used to step through longjmp()\n\ 8041\tlongjmp resume - internal breakpoint at the target of longjmp()\n\ 8042\tuntil - internal breakpoint used by the \"until\" command\n\ 8043\tfinish - internal breakpoint used by the \"finish\" command\n", 8044 "The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\ 8045the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\ 8046breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\ 8047address and file/line number respectively.\n\n", 8048 "Convenience variable \"$_\" and default examine address for \"x\"\n\ 8049are set to the address of the last breakpoint listed.\n\n\ 8050Convenience variable \"$bpnum\" contains the number of the last\n\ 8051breakpoint set.", NULL), 8052 &maintenanceinfolist); 8053 8054 add_com ("catch", class_breakpoint, catch_command, 8055 "Set catchpoints to catch events.\n\ 8056Raised signals may be caught:\n\ 8057\tcatch signal - all signals\n\ 8058\tcatch signal <signame> - a particular signal\n\ 8059Raised exceptions may be caught:\n\ 8060\tcatch throw - all exceptions, when thrown\n\ 8061\tcatch throw <exceptname> - a particular exception, when thrown\n\ 8062\tcatch catch - all exceptions, when caught\n\ 8063\tcatch catch <exceptname> - a particular exception, when caught\n\ 8064Thread or process events may be caught:\n\ 8065\tcatch thread_start - any threads, just after creation\n\ 8066\tcatch thread_exit - any threads, just before expiration\n\ 8067\tcatch thread_join - any threads, just after joins\n\ 8068Process events may be caught:\n\ 8069\tcatch start - any processes, just after creation\n\ 8070\tcatch exit - any processes, just before expiration\n\ 8071\tcatch fork - calls to fork()\n\ 8072\tcatch vfork - calls to vfork()\n\ 8073\tcatch exec - calls to exec()\n\ 8074Dynamically-linked library events may be caught:\n\ 8075\tcatch load - loads of any library\n\ 8076\tcatch load <libname> - loads of a particular library\n\ 8077\tcatch unload - unloads of any library\n\ 8078\tcatch unload <libname> - unloads of a particular library\n\ 8079The act of your program's execution stopping may also be caught:\n\ 8080\tcatch stop\n\n\ 8081C++ exceptions may be caught:\n\ 8082\tcatch throw - all exceptions, when thrown\n\ 8083\tcatch catch - all exceptions, when caught\n\ 8084\n\ 8085Do \"help set follow-fork-mode\" for info on debugging your program\n\ 8086after a fork or vfork is caught.\n\n\ 8087Do \"help breakpoints\" for info on other commands dealing with breakpoints."); 8088 8089 add_com ("tcatch", class_breakpoint, tcatch_command, 8090 "Set temporary catchpoints to catch events.\n\ 8091Args like \"catch\" command.\n\ 8092Like \"catch\" except the catchpoint is only temporary,\n\ 8093so it will be deleted when hit. Equivalent to \"catch\" followed\n\ 8094by using \"enable delete\" on the catchpoint number."); 8095 8096 c = add_com ("watch", class_breakpoint, watch_command, 8097 "Set a watchpoint for an expression.\n\ 8098A watchpoint stops execution of your program whenever the value of\n\ 8099an expression changes."); 8100 set_cmd_completer (c, location_completer); 8101 8102 c = add_com ("rwatch", class_breakpoint, rwatch_command, 8103 "Set a read watchpoint for an expression.\n\ 8104A watchpoint stops execution of your program whenever the value of\n\ 8105an expression is read."); 8106 set_cmd_completer (c, location_completer); 8107 8108 c = add_com ("awatch", class_breakpoint, awatch_command, 8109 "Set a watchpoint for an expression.\n\ 8110A watchpoint stops execution of your program whenever the value of\n\ 8111an expression is either read or written."); 8112 set_cmd_completer (c, location_completer); 8113 8114 add_info ("watchpoints", breakpoints_info, 8115 "Synonym for ``info breakpoints''."); 8116 8117 8118 c = add_set_cmd ("can-use-hw-watchpoints", class_support, var_zinteger, 8119 (char *) &can_use_hw_watchpoints, 8120 "Set debugger's willingness to use watchpoint hardware.\n\ 8121If zero, gdb will not use hardware for new watchpoints, even if\n\ 8122such is available. (However, any hardware watchpoints that were\n\ 8123created before setting this to nonzero, will continue to use watchpoint\n\ 8124hardware.)", 8125 &setlist); 8126 deprecated_add_show_from_set (c, &showlist); 8127 8128 can_use_hw_watchpoints = 1; 8129 8130 add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, "\ 8131Breakpoint specific settings\n\ 8132Configure various breakpoint-specific variables such as\n\ 8133pending breakpoint behavior", 8134 &breakpoint_set_cmdlist, "set breakpoint ", 8135 0/*allow-unknown*/, &setlist); 8136 add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, "\ 8137Breakpoint specific settings\n\ 8138Configure various breakpoint-specific variables such as\n\ 8139pending breakpoint behavior", 8140 &breakpoint_show_cmdlist, "show breakpoint ", 8141 0/*allow-unknown*/, &showlist); 8142 8143 add_setshow_auto_boolean_cmd ("pending", no_class, &pending_break_support, "\ 8144Set debugger's behavior regarding pending breakpoints.", "\ 8145Show debugger's behavior regarding pending breakpoints.", "\ 8146If on, an unrecognized breakpoint location will cause gdb to create a\n\ 8147pending breakpoint. If off, an unrecognized breakpoint location results in\n\ 8148an error. If auto, an unrecognized breakpoint location results in a\n\ 8149user-query to see if a pending breakpoint should be created.", "\ 8150Debugger's behavior regarding pending breakpoints is %s.", 8151 NULL, NULL, 8152 &breakpoint_set_cmdlist, 8153 &breakpoint_show_cmdlist); 8154 8155 pending_break_support = AUTO_BOOLEAN_AUTO; 8156} 8157