1 /* Data structures associated with breakpoints in GDB. 2 Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 3 2002, 2003, 2004 4 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, 21 Boston, MA 02111-1307, USA. */ 22 23 #if !defined (BREAKPOINT_H) 24 #define BREAKPOINT_H 1 25 26 #include "frame.h" 27 #include "value.h" 28 29 #include "gdb-events.h" 30 31 struct value; 32 struct block; 33 34 /* This is the maximum number of bytes a breakpoint instruction can take. 35 Feel free to increase it. It's just used in a few places to size 36 arrays that should be independent of the target architecture. */ 37 38 #define BREAKPOINT_MAX 16 39 40 /* Type of breakpoint. */ 41 /* FIXME In the future, we should fold all other breakpoint-like things into 42 here. This includes: 43 44 * single-step (for machines where we have to simulate single stepping) 45 (probably, though perhaps it is better for it to look as much as 46 possible like a single-step to wait_for_inferior). */ 47 48 enum bptype 49 { 50 bp_none = 0, /* Eventpoint has been deleted. */ 51 bp_breakpoint, /* Normal breakpoint */ 52 bp_hardware_breakpoint, /* Hardware assisted breakpoint */ 53 bp_until, /* used by until command */ 54 bp_finish, /* used by finish command */ 55 bp_watchpoint, /* Watchpoint */ 56 bp_hardware_watchpoint, /* Hardware assisted watchpoint */ 57 bp_read_watchpoint, /* read watchpoint, (hardware assisted) */ 58 bp_access_watchpoint, /* access watchpoint, (hardware assisted) */ 59 bp_longjmp, /* secret breakpoint to find longjmp() */ 60 bp_longjmp_resume, /* secret breakpoint to escape longjmp() */ 61 62 /* Used by wait_for_inferior for stepping over subroutine calls, for 63 stepping over signal handlers, and for skipping prologues. */ 64 bp_step_resume, 65 66 /* Used by wait_for_inferior for stepping over signal handlers. */ 67 bp_through_sigtramp, 68 69 /* Used to detect when a watchpoint expression has gone out of 70 scope. These breakpoints are usually not visible to the user. 71 72 This breakpoint has some interesting properties: 73 74 1) There's always a 1:1 mapping between watchpoints 75 on local variables and watchpoint_scope breakpoints. 76 77 2) It automatically deletes itself and the watchpoint it's 78 associated with when hit. 79 80 3) It can never be disabled. */ 81 bp_watchpoint_scope, 82 83 /* The breakpoint at the end of a call dummy. */ 84 /* FIXME: What if the function we are calling longjmp()s out of the 85 call, or the user gets out with the "return" command? We currently 86 have no way of cleaning up the breakpoint in these (obscure) situations. 87 (Probably can solve this by noticing longjmp, "return", etc., it's 88 similar to noticing when a watchpoint on a local variable goes out 89 of scope (with hardware support for watchpoints)). */ 90 bp_call_dummy, 91 92 /* Some dynamic linkers (HP, maybe Solaris) can arrange for special 93 code in the inferior to run when significant events occur in the 94 dynamic linker (for example a library is loaded or unloaded). 95 96 By placing a breakpoint in this magic code GDB will get control 97 when these significant events occur. GDB can then re-examine 98 the dynamic linker's data structures to discover any newly loaded 99 dynamic libraries. */ 100 bp_shlib_event, 101 102 /* Some multi-threaded systems can arrange for a location in the 103 inferior to be executed when certain thread-related events occur 104 (such as thread creation or thread death). 105 106 By placing a breakpoint at one of these locations, GDB will get 107 control when these events occur. GDB can then update its thread 108 lists etc. */ 109 110 bp_thread_event, 111 112 /* On the same principal, an overlay manager can arrange to call a 113 magic location in the inferior whenever there is an interesting 114 change in overlay status. GDB can update its overlay tables 115 and fiddle with breakpoints in overlays when this breakpoint 116 is hit. */ 117 118 bp_overlay_event, 119 120 /* These breakpoints are used to implement the "catch load" command 121 on platforms whose dynamic linkers support such functionality. */ 122 bp_catch_load, 123 124 /* These breakpoints are used to implement the "catch unload" command 125 on platforms whose dynamic linkers support such functionality. */ 126 bp_catch_unload, 127 128 /* These are not really breakpoints, but are catchpoints that 129 implement the "catch fork", "catch vfork" and "catch exec" commands 130 on platforms whose kernel support such functionality. (I.e., 131 kernels which can raise an event when a fork or exec occurs, as 132 opposed to the debugger setting breakpoints on functions named 133 "fork" or "exec".) */ 134 bp_catch_fork, 135 bp_catch_vfork, 136 bp_catch_exec, 137 138 /* These are catchpoints to implement "catch catch" and "catch throw" 139 commands for C++ exception handling. */ 140 bp_catch_catch, 141 bp_catch_throw 142 143 144 }; 145 146 /* States of enablement of breakpoint. */ 147 148 enum enable_state 149 { 150 bp_disabled, /* The eventpoint is inactive, and cannot trigger. */ 151 bp_enabled, /* The eventpoint is active, and can trigger. */ 152 bp_shlib_disabled, /* The eventpoint's address is in an unloaded solib. 153 The eventpoint will be automatically enabled 154 and reset when that solib is loaded. */ 155 bp_call_disabled, /* The eventpoint has been disabled while a call 156 into the inferior is "in flight", because some 157 eventpoints interfere with the implementation of 158 a call on some targets. The eventpoint will be 159 automatically enabled and reset when the call 160 "lands" (either completes, or stops at another 161 eventpoint). */ 162 bp_startup_disabled, 163 bp_permanent /* There is a breakpoint instruction hard-wired into 164 the target's code. Don't try to write another 165 breakpoint instruction on top of it, or restore 166 its value. Step over it using the architecture's 167 SKIP_INSN macro. */ 168 }; 169 170 171 /* Disposition of breakpoint. Ie: what to do after hitting it. */ 172 173 enum bpdisp 174 { 175 disp_del, /* Delete it */ 176 disp_del_at_next_stop, /* Delete at next stop, whether hit or not */ 177 disp_disable, /* Disable it */ 178 disp_donttouch /* Leave it alone */ 179 }; 180 181 enum target_hw_bp_type 182 { 183 hw_write = 0, /* Common HW watchpoint */ 184 hw_read = 1, /* Read HW watchpoint */ 185 hw_access = 2, /* Access HW watchpoint */ 186 hw_execute = 3 /* Execute HW breakpoint */ 187 }; 188 189 /* GDB maintains two types of information about each breakpoint (or 190 watchpoint, or other related event). The first type corresponds 191 to struct breakpoint; this is a relatively high-level structure 192 which contains the source location(s), stopping conditions, user 193 commands to execute when the breakpoint is hit, and so forth. 194 195 The second type of information corresponds to struct bp_location. 196 Each breakpoint has one or (eventually) more locations associated 197 with it, which represent target-specific and machine-specific 198 mechanisms for stopping the program. For instance, a watchpoint 199 expression may require multiple hardware watchpoints in order to 200 catch all changes in the value of the expression being watched. */ 201 202 enum bp_loc_type 203 { 204 bp_loc_software_breakpoint, 205 bp_loc_hardware_breakpoint, 206 bp_loc_hardware_watchpoint, 207 bp_loc_other /* Miscellaneous... */ 208 }; 209 210 struct bp_location 211 { 212 /* Chain pointer to the next breakpoint location. */ 213 struct bp_location *next; 214 215 /* Type of this breakpoint location. */ 216 enum bp_loc_type loc_type; 217 218 /* Each breakpoint location must belong to exactly one higher-level 219 breakpoint. This and the DUPLICATE flag are more straightforward 220 than reference counting. */ 221 struct breakpoint *owner; 222 223 /* Nonzero if this breakpoint is now inserted. */ 224 char inserted; 225 226 /* Nonzero if this is not the first breakpoint in the list 227 for the given address. */ 228 char duplicate; 229 230 /* If we someday support real thread-specific breakpoints, then 231 the breakpoint location will need a thread identifier. */ 232 233 /* Data for specific breakpoint types. These could be a union, but 234 simplicity is more important than memory usage for breakpoints. */ 235 236 /* Note that zero is a perfectly valid code address on some platforms 237 (for example, the mn10200 (OBSOLETE) and mn10300 simulators). NULL 238 is not a special value for this field. Valid for all types except 239 bp_loc_other. */ 240 CORE_ADDR address; 241 242 /* For any breakpoint type with an address, this is the BFD section 243 associated with the address. Used primarily for overlay debugging. */ 244 asection *section; 245 246 /* "Real" contents of byte where breakpoint has been inserted. 247 Valid only when breakpoints are in the program. Under the complete 248 control of the target insert_breakpoint and remove_breakpoint routines. 249 No other code should assume anything about the value(s) here. 250 Valid only for bp_loc_software_breakpoint. */ 251 char shadow_contents[BREAKPOINT_MAX]; 252 253 /* Address at which breakpoint was requested, either by the user or 254 by GDB for internal breakpoints. This will usually be the same 255 as ``address'' (above) except for cases in which 256 ADJUST_BREAKPOINT_ADDRESS has computed a different address at 257 which to place the breakpoint in order to comply with a 258 processor's architectual constraints. */ 259 CORE_ADDR requested_address; 260 }; 261 262 /* This structure is a collection of function pointers that, if available, 263 will be called instead of the performing the default action for this 264 bptype. */ 265 266 struct breakpoint_ops 267 { 268 /* The normal print routine for this breakpoint, called when we 269 hit it. */ 270 enum print_stop_action (*print_it) (struct breakpoint *); 271 272 /* Display information about this breakpoint, for "info breakpoints". */ 273 void (*print_one) (struct breakpoint *, CORE_ADDR *); 274 275 /* Display information about this breakpoint after setting it (roughly 276 speaking; this is called from "mention"). */ 277 void (*print_mention) (struct breakpoint *); 278 }; 279 280 /* Note that the ->silent field is not currently used by any commands 281 (though the code is in there if it was to be, and set_raw_breakpoint 282 does set it to 0). I implemented it because I thought it would be 283 useful for a hack I had to put in; I'm going to leave it in because 284 I can see how there might be times when it would indeed be useful */ 285 286 /* This is for a breakpoint or a watchpoint. */ 287 288 struct breakpoint 289 { 290 struct breakpoint *next; 291 /* Type of breakpoint. */ 292 enum bptype type; 293 /* Zero means disabled; remember the info but don't break here. */ 294 enum enable_state enable_state; 295 /* What to do with this breakpoint after we hit it. */ 296 enum bpdisp disposition; 297 /* Number assigned to distinguish breakpoints. */ 298 int number; 299 300 /* Location(s) associated with this high-level breakpoint. */ 301 struct bp_location *loc; 302 303 /* Line number of this address. */ 304 305 int line_number; 306 307 /* Source file name of this address. */ 308 309 char *source_file; 310 311 /* Non-zero means a silent breakpoint (don't print frame info 312 if we stop here). */ 313 unsigned char silent; 314 /* Number of stops at this breakpoint that should 315 be continued automatically before really stopping. */ 316 int ignore_count; 317 /* Chain of command lines to execute when this breakpoint is hit. */ 318 struct command_line *commands; 319 /* Stack depth (address of frame). If nonzero, break only if fp 320 equals this. */ 321 struct frame_id frame_id; 322 /* Conditional. Break only if this expression's value is nonzero. */ 323 struct expression *cond; 324 325 /* String we used to set the breakpoint (malloc'd). */ 326 char *addr_string; 327 /* Language we used to set the breakpoint. */ 328 enum language language; 329 /* Input radix we used to set the breakpoint. */ 330 int input_radix; 331 /* String form of the breakpoint condition (malloc'd), or NULL if there 332 is no condition. */ 333 char *cond_string; 334 /* String form of exp (malloc'd), or NULL if none. */ 335 char *exp_string; 336 337 /* The expression we are watching, or NULL if not a watchpoint. */ 338 struct expression *exp; 339 /* The largest block within which it is valid, or NULL if it is 340 valid anywhere (e.g. consists just of global symbols). */ 341 struct block *exp_valid_block; 342 /* Value of the watchpoint the last time we checked it. */ 343 struct value *val; 344 345 /* Holds the value chain for a hardware watchpoint expression. */ 346 struct value *val_chain; 347 348 /* Holds the address of the related watchpoint_scope breakpoint 349 when using watchpoints on local variables (might the concept 350 of a related breakpoint be useful elsewhere, if not just call 351 it the watchpoint_scope breakpoint or something like that. FIXME). */ 352 struct breakpoint *related_breakpoint; 353 354 /* Holds the frame address which identifies the frame this 355 watchpoint should be evaluated in, or `null' if the watchpoint 356 should be evaluated on the outermost frame. */ 357 struct frame_id watchpoint_frame; 358 359 /* Thread number for thread-specific breakpoint, or -1 if don't care */ 360 int thread; 361 362 /* Count of the number of times this breakpoint was taken, dumped 363 with the info, but not used for anything else. Useful for 364 seeing how many times you hit a break prior to the program 365 aborting, so you can back up to just before the abort. */ 366 int hit_count; 367 368 /* Filename of a dynamically-linked library (dll), used for 369 bp_catch_load and bp_catch_unload (malloc'd), or NULL if any 370 library is significant. */ 371 char *dll_pathname; 372 373 /* Filename of a dll whose state change (e.g., load or unload) 374 triggered this catchpoint. This field is only valid immediately 375 after this catchpoint has triggered. */ 376 char *triggered_dll_pathname; 377 378 /* Process id of a child process whose forking triggered this 379 catchpoint. This field is only valid immediately after this 380 catchpoint has triggered. */ 381 int forked_inferior_pid; 382 383 /* Filename of a program whose exec triggered this catchpoint. 384 This field is only valid immediately after this catchpoint has 385 triggered. */ 386 char *exec_pathname; 387 388 /* Methods associated with this breakpoint. */ 389 struct breakpoint_ops *ops; 390 391 /* Was breakpoint issued from a tty? Saved for the use of pending breakpoints. */ 392 int from_tty; 393 394 /* Flag value for pending breakpoint. 395 first bit : 0 non-temporary, 1 temporary. 396 second bit : 0 normal breakpoint, 1 hardware breakpoint. */ 397 int flag; 398 399 /* Is breakpoint pending on shlib loads? */ 400 int pending; 401 }; 402 403 /* The following stuff is an abstract data type "bpstat" ("breakpoint 404 status"). This provides the ability to determine whether we have 405 stopped at a breakpoint, and what we should do about it. */ 406 407 typedef struct bpstats *bpstat; 408 409 /* Interface: */ 410 /* Clear a bpstat so that it says we are not at any breakpoint. 411 Also free any storage that is part of a bpstat. */ 412 extern void bpstat_clear (bpstat *); 413 414 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that 415 is part of the bpstat is copied as well. */ 416 extern bpstat bpstat_copy (bpstat); 417 418 extern bpstat bpstat_stop_status (CORE_ADDR pc, ptid_t ptid, 419 int stopped_by_watchpoint); 420 421 /* This bpstat_what stuff tells wait_for_inferior what to do with a 422 breakpoint (a challenging task). */ 423 424 enum bpstat_what_main_action 425 { 426 /* Perform various other tests; that is, this bpstat does not 427 say to perform any action (e.g. failed watchpoint and nothing 428 else). */ 429 BPSTAT_WHAT_KEEP_CHECKING, 430 431 /* Rather than distinguish between noisy and silent stops here, it 432 might be cleaner to have bpstat_print make that decision (also 433 taking into account stop_print_frame and source_only). But the 434 implications are a bit scary (interaction with auto-displays, etc.), 435 so I won't try it. */ 436 437 /* Stop silently. */ 438 BPSTAT_WHAT_STOP_SILENT, 439 440 /* Stop and print. */ 441 BPSTAT_WHAT_STOP_NOISY, 442 443 /* Remove breakpoints, single step once, then put them back in and 444 go back to what we were doing. It's possible that this should be 445 removed from the main_action and put into a separate field, to more 446 cleanly handle BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE. */ 447 BPSTAT_WHAT_SINGLE, 448 449 /* Set longjmp_resume breakpoint, remove all other breakpoints, 450 and continue. The "remove all other breakpoints" part is required 451 if we are also stepping over another breakpoint as well as doing 452 the longjmp handling. */ 453 BPSTAT_WHAT_SET_LONGJMP_RESUME, 454 455 /* Clear longjmp_resume breakpoint, then handle as 456 BPSTAT_WHAT_KEEP_CHECKING. */ 457 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME, 458 459 /* Clear longjmp_resume breakpoint, then handle as BPSTAT_WHAT_SINGLE. */ 460 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE, 461 462 /* Clear step resume breakpoint, and keep checking. */ 463 BPSTAT_WHAT_STEP_RESUME, 464 465 /* Clear through_sigtramp breakpoint, muck with trap_expected, and keep 466 checking. */ 467 BPSTAT_WHAT_THROUGH_SIGTRAMP, 468 469 /* Check the dynamic linker's data structures for new libraries, then 470 keep checking. */ 471 BPSTAT_WHAT_CHECK_SHLIBS, 472 473 /* Check the dynamic linker's data structures for new libraries, then 474 resume out of the dynamic linker's callback, stop and print. */ 475 BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK, 476 477 /* This is just used to keep track of how many enums there are. */ 478 BPSTAT_WHAT_LAST 479 }; 480 481 struct bpstat_what 482 { 483 enum bpstat_what_main_action main_action; 484 485 /* Did we hit a call dummy breakpoint? This only goes with a main_action 486 of BPSTAT_WHAT_STOP_SILENT or BPSTAT_WHAT_STOP_NOISY (the concept of 487 continuing from a call dummy without popping the frame is not a 488 useful one). */ 489 int call_dummy; 490 }; 491 492 /* The possible return values for print_bpstat, print_it_normal, 493 print_it_done, print_it_noop. */ 494 enum print_stop_action 495 { 496 PRINT_UNKNOWN = -1, 497 PRINT_SRC_AND_LOC, 498 PRINT_SRC_ONLY, 499 PRINT_NOTHING 500 }; 501 502 /* Tell what to do about this bpstat. */ 503 struct bpstat_what bpstat_what (bpstat); 504 505 /* Find the bpstat associated with a breakpoint. NULL otherwise. */ 506 bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *); 507 508 /* Find a step_resume breakpoint associated with this bpstat. 509 (If there are multiple step_resume bp's on the list, this function 510 will arbitrarily pick one.) 511 512 It is an error to use this function if BPSTAT doesn't contain a 513 step_resume breakpoint. 514 515 See wait_for_inferior's use of this function. 516 */ 517 extern struct breakpoint *bpstat_find_step_resume_breakpoint (bpstat); 518 519 /* Nonzero if a signal that we got in wait() was due to circumstances 520 explained by the BS. */ 521 /* Currently that is true if we have hit a breakpoint, or if there is 522 a watchpoint enabled. */ 523 #define bpstat_explains_signal(bs) ((bs) != NULL) 524 525 /* Nonzero if we should step constantly (e.g. watchpoints on machines 526 without hardware support). This isn't related to a specific bpstat, 527 just to things like whether watchpoints are set. */ 528 extern int bpstat_should_step (void); 529 530 /* Nonzero if there are enabled hardware watchpoints. */ 531 extern int bpstat_have_active_hw_watchpoints (void); 532 533 /* Print a message indicating what happened. Returns nonzero to 534 say that only the source line should be printed after this (zero 535 return means print the frame as well as the source line). */ 536 extern enum print_stop_action bpstat_print (bpstat); 537 538 /* Return the breakpoint number of the first breakpoint we are stopped 539 at. *BSP upon return is a bpstat which points to the remaining 540 breakpoints stopped at (but which is not guaranteed to be good for 541 anything but further calls to bpstat_num). 542 Return 0 if passed a bpstat which does not indicate any breakpoints. */ 543 extern int bpstat_num (bpstat *); 544 545 /* Perform actions associated with having stopped at *BSP. Actually, we just 546 use this for breakpoint commands. Perhaps other actions will go here 547 later, but this is executed at a late time (from the command loop). */ 548 extern void bpstat_do_actions (bpstat *); 549 550 /* Modify BS so that the actions will not be performed. */ 551 extern void bpstat_clear_actions (bpstat); 552 553 /* Given a bpstat that records zero or more triggered eventpoints, this 554 function returns another bpstat which contains only the catchpoints 555 on that first list, if any. 556 */ 557 extern void bpstat_get_triggered_catchpoints (bpstat, bpstat *); 558 559 /* Implementation: */ 560 561 /* Values used to tell the printing routine how to behave for this bpstat. */ 562 enum bp_print_how 563 { 564 /* This is used when we want to do a normal printing of the reason 565 for stopping. The output will depend on the type of eventpoint 566 we are dealing with. This is the default value, most commonly 567 used. */ 568 print_it_normal, 569 /* This is used when nothing should be printed for this bpstat entry. */ 570 print_it_noop, 571 /* This is used when everything which needs to be printed has 572 already been printed. But we still want to print the frame. */ 573 print_it_done 574 }; 575 576 struct bpstats 577 { 578 /* Linked list because there can be two breakpoints at the same 579 place, and a bpstat reflects the fact that both have been hit. */ 580 bpstat next; 581 /* Breakpoint that we are at. */ 582 struct breakpoint *breakpoint_at; 583 /* Commands left to be done. */ 584 struct command_line *commands; 585 /* Old value associated with a watchpoint. */ 586 struct value *old_val; 587 588 /* Nonzero if this breakpoint tells us to print the frame. */ 589 char print; 590 591 /* Nonzero if this breakpoint tells us to stop. */ 592 char stop; 593 594 /* Tell bpstat_print and print_bp_stop_message how to print stuff 595 associated with this element of the bpstat chain. */ 596 enum bp_print_how print_it; 597 }; 598 599 enum inf_context 600 { 601 inf_starting, 602 inf_running, 603 inf_exited 604 }; 605 606 /* The possible return values for breakpoint_here_p. 607 We guarantee that zero always means "no breakpoint here". */ 608 enum breakpoint_here 609 { 610 no_breakpoint_here = 0, 611 ordinary_breakpoint_here, 612 permanent_breakpoint_here 613 }; 614 615 616 /* Prototypes for breakpoint-related functions. */ 617 618 extern enum breakpoint_here breakpoint_here_p (CORE_ADDR); 619 620 extern int breakpoint_inserted_here_p (CORE_ADDR); 621 622 extern int software_breakpoint_inserted_here_p (CORE_ADDR); 623 624 extern int breakpoint_thread_match (CORE_ADDR, ptid_t); 625 626 extern void until_break_command (char *, int, int); 627 628 extern void breakpoint_re_set (void); 629 630 extern void breakpoint_re_set_thread (struct breakpoint *); 631 632 extern int ep_is_exception_catchpoint (struct breakpoint *); 633 634 extern struct breakpoint *set_momentary_breakpoint 635 (struct symtab_and_line, struct frame_id, enum bptype); 636 637 extern void set_ignore_count (int, int, int); 638 639 extern void set_default_breakpoint (int, CORE_ADDR, struct symtab *, int); 640 641 extern void mark_breakpoints_out (void); 642 643 extern void breakpoint_init_inferior (enum inf_context); 644 645 extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *); 646 647 extern struct cleanup *make_exec_cleanup_delete_breakpoint (struct breakpoint *); 648 649 extern void delete_breakpoint (struct breakpoint *); 650 651 extern void breakpoint_auto_delete (bpstat); 652 653 extern void breakpoint_clear_ignore_counts (void); 654 655 extern void break_command (char *, int); 656 657 extern void hbreak_command_wrapper (char *, int); 658 extern void thbreak_command_wrapper (char *, int); 659 extern void rbreak_command_wrapper (char *, int); 660 extern void watch_command_wrapper (char *, int); 661 extern void awatch_command_wrapper (char *, int); 662 extern void rwatch_command_wrapper (char *, int); 663 extern void tbreak_command (char *, int); 664 665 extern int insert_breakpoints (void); 666 667 extern int remove_breakpoints (void); 668 669 /* This function can be used to physically insert eventpoints from the 670 specified traced inferior process, without modifying the breakpoint 671 package's state. This can be useful for those targets which support 672 following the processes of a fork() or vfork() system call, when both 673 of the resulting two processes are to be followed. */ 674 extern int reattach_breakpoints (int); 675 676 /* This function can be used to update the breakpoint package's state 677 after an exec() system call has been executed. 678 679 This function causes the following: 680 681 - All eventpoints are marked "not inserted". 682 - All eventpoints with a symbolic address are reset such that 683 the symbolic address must be reevaluated before the eventpoints 684 can be reinserted. 685 - The solib breakpoints are explicitly removed from the breakpoint 686 list. 687 - A step-resume breakpoint, if any, is explicitly removed from the 688 breakpoint list. 689 - All eventpoints without a symbolic address are removed from the 690 breakpoint list. */ 691 extern void update_breakpoints_after_exec (void); 692 693 /* This function can be used to physically remove hardware breakpoints 694 and watchpoints from the specified traced inferior process, without 695 modifying the breakpoint package's state. This can be useful for 696 those targets which support following the processes of a fork() or 697 vfork() system call, when one of the resulting two processes is to 698 be detached and allowed to run free. 699 700 It is an error to use this function on the process whose id is 701 inferior_ptid. */ 702 extern int detach_breakpoints (int); 703 704 extern void enable_longjmp_breakpoint (void); 705 extern void disable_longjmp_breakpoint (void); 706 extern void enable_overlay_breakpoints (void); 707 extern void disable_overlay_breakpoints (void); 708 709 extern void set_longjmp_resume_breakpoint (CORE_ADDR, struct frame_id); 710 /* These functions respectively disable or reenable all currently 711 enabled watchpoints. When disabled, the watchpoints are marked 712 call_disabled. When reenabled, they are marked enabled. 713 714 The intended client of these functions is call_function_by_hand. 715 716 The inferior must be stopped, and all breakpoints removed, when 717 these functions are used. 718 719 The need for these functions is that on some targets (e.g., HP-UX), 720 gdb is unable to unwind through the dummy frame that is pushed as 721 part of the implementation of a call command. Watchpoints can 722 cause the inferior to stop in places where this frame is visible, 723 and that can cause execution control to become very confused. 724 725 Note that if a user sets breakpoints in an interactively called 726 function, the call_disabled watchpoints will have been reenabled 727 when the first such breakpoint is reached. However, on targets 728 that are unable to unwind through the call dummy frame, watches 729 of stack-based storage may then be deleted, because gdb will 730 believe that their watched storage is out of scope. (Sigh.) */ 731 extern void disable_watchpoints_before_interactive_call_start (void); 732 733 extern void enable_watchpoints_after_interactive_call_stop (void); 734 735 736 extern void clear_breakpoint_hit_counts (void); 737 738 extern int get_number (char **); 739 740 extern int get_number_or_range (char **); 741 742 /* The following are for displays, which aren't really breakpoints, but 743 here is as good a place as any for them. */ 744 745 extern void disable_current_display (void); 746 747 extern void do_displays (void); 748 749 extern void disable_display (int); 750 751 extern void clear_displays (void); 752 753 extern void disable_breakpoint (struct breakpoint *); 754 755 extern void enable_breakpoint (struct breakpoint *); 756 757 extern void make_breakpoint_permanent (struct breakpoint *); 758 759 extern struct breakpoint *create_solib_event_breakpoint (CORE_ADDR); 760 761 extern struct breakpoint *create_thread_event_breakpoint (CORE_ADDR); 762 763 extern void remove_solib_event_breakpoints (void); 764 765 extern void remove_thread_event_breakpoints (void); 766 767 extern void disable_breakpoints_in_shlibs (int silent); 768 769 extern void disable_breakpoints_at_startup (int silent); 770 771 extern void re_enable_breakpoints_in_shlibs (void); 772 773 void re_enable_breakpoints_at_startup (void); 774 775 extern void create_solib_load_event_breakpoint (char *, int, char *, char *); 776 777 extern void create_solib_unload_event_breakpoint (char *, int, 778 char *, char *); 779 780 extern void create_fork_event_catchpoint (int, char *); 781 782 extern void create_vfork_event_catchpoint (int, char *); 783 784 extern void create_exec_event_catchpoint (int, char *); 785 786 /* This function returns TRUE if ep is a catchpoint. */ 787 extern int ep_is_catchpoint (struct breakpoint *); 788 789 /* This function returns TRUE if ep is a catchpoint of a 790 shared library (aka dynamically-linked library) event, 791 such as a library load or unload. */ 792 extern int ep_is_shlib_catchpoint (struct breakpoint *); 793 794 extern struct breakpoint *set_breakpoint_sal (struct symtab_and_line); 795 796 /* Enable breakpoints and delete when hit. Called with ARG == NULL 797 deletes all breakpoints. */ 798 extern void delete_command (char *arg, int from_tty); 799 800 /* Pull all H/W watchpoints from the target. Return non-zero if the 801 remove fails. */ 802 extern int remove_hw_watchpoints (void); 803 804 805 /* Indicator of whether exception catchpoints should be nuked between 806 runs of a program. */ 807 extern int deprecated_exception_catchpoints_are_fragile; 808 809 /* Indicator of when exception catchpoints set-up should be 810 reinitialized -- e.g. when program is re-run. */ 811 extern int deprecated_exception_support_initialized; 812 813 #endif /* !defined (BREAKPOINT_H) */ 814