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