1 /* Data structures associated with breakpoints in GDB. 2 Copyright (C) 1992-2019 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19 #if !defined (BREAKPOINT_H) 20 #define BREAKPOINT_H 1 21 22 #include "frame.h" 23 #include "value.h" 24 #include "common/vec.h" 25 #include "ax.h" 26 #include "command.h" 27 #include "common/break-common.h" 28 #include "probe.h" 29 #include "location.h" 30 #include <vector> 31 #include "common/array-view.h" 32 #include "cli/cli-script.h" 33 34 struct block; 35 struct gdbpy_breakpoint_object; 36 struct gdbscm_breakpoint_object; 37 struct number_or_range_parser; 38 struct thread_info; 39 struct bpstats; 40 struct bp_location; 41 struct linespec_result; 42 struct linespec_sals; 43 struct inferior; 44 45 /* Why are we removing the breakpoint from the target? */ 46 47 enum remove_bp_reason 48 { 49 /* A regular remove. Remove the breakpoint and forget everything 50 about it. */ 51 REMOVE_BREAKPOINT, 52 53 /* Detach the breakpoints from a fork child. */ 54 DETACH_BREAKPOINT, 55 }; 56 57 /* This is the maximum number of bytes a breakpoint instruction can 58 take. Feel free to increase it. It's just used in a few places to 59 size arrays that should be independent of the target 60 architecture. */ 61 62 #define BREAKPOINT_MAX 16 63 64 65 /* Type of breakpoint. */ 66 67 enum bptype 68 { 69 bp_none = 0, /* Eventpoint has been deleted */ 70 bp_breakpoint, /* Normal breakpoint */ 71 bp_hardware_breakpoint, /* Hardware assisted breakpoint */ 72 bp_single_step, /* Software single-step */ 73 bp_until, /* used by until command */ 74 bp_finish, /* used by finish command */ 75 bp_watchpoint, /* Watchpoint */ 76 bp_hardware_watchpoint, /* Hardware assisted watchpoint */ 77 bp_read_watchpoint, /* read watchpoint, (hardware assisted) */ 78 bp_access_watchpoint, /* access watchpoint, (hardware assisted) */ 79 bp_longjmp, /* secret breakpoint to find longjmp() */ 80 bp_longjmp_resume, /* secret breakpoint to escape longjmp() */ 81 82 /* Breakpoint placed to the same location(s) like bp_longjmp but used to 83 protect against stale DUMMY_FRAME. Multiple bp_longjmp_call_dummy and 84 one bp_call_dummy are chained together by related_breakpoint for each 85 DUMMY_FRAME. */ 86 bp_longjmp_call_dummy, 87 88 /* An internal breakpoint that is installed on the unwinder's 89 debug hook. */ 90 bp_exception, 91 /* An internal breakpoint that is set at the point where an 92 exception will land. */ 93 bp_exception_resume, 94 95 /* Used by wait_for_inferior for stepping over subroutine calls, 96 and for skipping prologues. */ 97 bp_step_resume, 98 99 /* Used by wait_for_inferior for stepping over signal 100 handlers. */ 101 bp_hp_step_resume, 102 103 /* Used to detect when a watchpoint expression has gone out of 104 scope. These breakpoints are usually not visible to the user. 105 106 This breakpoint has some interesting properties: 107 108 1) There's always a 1:1 mapping between watchpoints 109 on local variables and watchpoint_scope breakpoints. 110 111 2) It automatically deletes itself and the watchpoint it's 112 associated with when hit. 113 114 3) It can never be disabled. */ 115 bp_watchpoint_scope, 116 117 /* The breakpoint at the end of a call dummy. See bp_longjmp_call_dummy it 118 is chained with by related_breakpoint. */ 119 bp_call_dummy, 120 121 /* A breakpoint set on std::terminate, that is used to catch 122 otherwise uncaught exceptions thrown during an inferior call. */ 123 bp_std_terminate, 124 125 /* Some dynamic linkers (HP, maybe Solaris) can arrange for special 126 code in the inferior to run when significant events occur in the 127 dynamic linker (for example a library is loaded or unloaded). 128 129 By placing a breakpoint in this magic code GDB will get control 130 when these significant events occur. GDB can then re-examine 131 the dynamic linker's data structures to discover any newly loaded 132 dynamic libraries. */ 133 bp_shlib_event, 134 135 /* Some multi-threaded systems can arrange for a location in the 136 inferior to be executed when certain thread-related events occur 137 (such as thread creation or thread death). 138 139 By placing a breakpoint at one of these locations, GDB will get 140 control when these events occur. GDB can then update its thread 141 lists etc. */ 142 143 bp_thread_event, 144 145 /* On the same principal, an overlay manager can arrange to call a 146 magic location in the inferior whenever there is an interesting 147 change in overlay status. GDB can update its overlay tables 148 and fiddle with breakpoints in overlays when this breakpoint 149 is hit. */ 150 151 bp_overlay_event, 152 153 /* Master copies of longjmp breakpoints. These are always installed 154 as soon as an objfile containing longjmp is loaded, but they are 155 always disabled. While necessary, temporary clones of bp_longjmp 156 type will be created and enabled. */ 157 158 bp_longjmp_master, 159 160 /* Master copies of std::terminate breakpoints. */ 161 bp_std_terminate_master, 162 163 /* Like bp_longjmp_master, but for exceptions. */ 164 bp_exception_master, 165 166 bp_catchpoint, 167 168 bp_tracepoint, 169 bp_fast_tracepoint, 170 bp_static_tracepoint, 171 172 /* A dynamic printf stops at the given location, does a formatted 173 print, then automatically continues. (Although this is sort of 174 like a macro packaging up standard breakpoint functionality, 175 GDB doesn't have a way to construct types of breakpoint from 176 elements of behavior.) */ 177 bp_dprintf, 178 179 /* Event for JIT compiled code generation or deletion. */ 180 bp_jit_event, 181 182 /* Breakpoint is placed at the STT_GNU_IFUNC resolver. When hit GDB 183 inserts new bp_gnu_ifunc_resolver_return at the caller. 184 bp_gnu_ifunc_resolver is still being kept here as a different thread 185 may still hit it before bp_gnu_ifunc_resolver_return is hit by the 186 original thread. */ 187 bp_gnu_ifunc_resolver, 188 189 /* On its hit GDB now know the resolved address of the target 190 STT_GNU_IFUNC function. Associated bp_gnu_ifunc_resolver can be 191 deleted now and the breakpoint moved to the target function entry 192 point. */ 193 bp_gnu_ifunc_resolver_return, 194 }; 195 196 /* States of enablement of breakpoint. */ 197 198 enum enable_state 199 { 200 bp_disabled, /* The eventpoint is inactive, and cannot 201 trigger. */ 202 bp_enabled, /* The eventpoint is active, and can 203 trigger. */ 204 bp_call_disabled, /* The eventpoint has been disabled while a 205 call into the inferior is "in flight", 206 because some eventpoints interfere with 207 the implementation of a call on some 208 targets. The eventpoint will be 209 automatically enabled and reset when the 210 call "lands" (either completes, or stops 211 at another eventpoint). */ 212 }; 213 214 215 /* Disposition of breakpoint. Ie: what to do after hitting it. */ 216 217 enum bpdisp 218 { 219 disp_del, /* Delete it */ 220 disp_del_at_next_stop, /* Delete at next stop, 221 whether hit or not */ 222 disp_disable, /* Disable it */ 223 disp_donttouch /* Leave it alone */ 224 }; 225 226 /* Status of breakpoint conditions used when synchronizing 227 conditions with the target. */ 228 229 enum condition_status 230 { 231 condition_unchanged = 0, 232 condition_modified, 233 condition_updated 234 }; 235 236 /* Information used by targets to insert and remove breakpoints. */ 237 238 struct bp_target_info 239 { 240 /* Address space at which the breakpoint was placed. */ 241 struct address_space *placed_address_space; 242 243 /* Address at which the breakpoint was placed. This is normally 244 the same as REQUESTED_ADDRESS, except when adjustment happens in 245 gdbarch_breakpoint_from_pc. The most common form of adjustment 246 is stripping an alternate ISA marker from the PC which is used 247 to determine the type of breakpoint to insert. */ 248 CORE_ADDR placed_address; 249 250 /* Address at which the breakpoint was requested. */ 251 CORE_ADDR reqstd_address; 252 253 /* If this is a ranged breakpoint, then this field contains the 254 length of the range that will be watched for execution. */ 255 int length; 256 257 /* If the breakpoint lives in memory and reading that memory would 258 give back the breakpoint, instead of the original contents, then 259 the original contents are cached here. Only SHADOW_LEN bytes of 260 this buffer are valid, and only when the breakpoint is inserted. */ 261 gdb_byte shadow_contents[BREAKPOINT_MAX]; 262 263 /* The length of the data cached in SHADOW_CONTENTS. */ 264 int shadow_len; 265 266 /* The breakpoint's kind. It is used in 'kind' parameter in Z 267 packets. */ 268 int kind; 269 270 /* Conditions the target should evaluate if it supports target-side 271 breakpoint conditions. These are non-owning pointers. */ 272 std::vector<agent_expr *> conditions; 273 274 /* Commands the target should evaluate if it supports target-side 275 breakpoint commands. These are non-owning pointers. */ 276 std::vector<agent_expr *> tcommands; 277 278 /* Flag that is true if the breakpoint should be left in place even 279 when GDB is not connected. */ 280 int persist; 281 }; 282 283 /* GDB maintains two types of information about each breakpoint (or 284 watchpoint, or other related event). The first type corresponds 285 to struct breakpoint; this is a relatively high-level structure 286 which contains the source location(s), stopping conditions, user 287 commands to execute when the breakpoint is hit, and so forth. 288 289 The second type of information corresponds to struct bp_location. 290 Each breakpoint has one or (eventually) more locations associated 291 with it, which represent target-specific and machine-specific 292 mechanisms for stopping the program. For instance, a watchpoint 293 expression may require multiple hardware watchpoints in order to 294 catch all changes in the value of the expression being watched. */ 295 296 enum bp_loc_type 297 { 298 bp_loc_software_breakpoint, 299 bp_loc_hardware_breakpoint, 300 bp_loc_hardware_watchpoint, 301 bp_loc_other /* Miscellaneous... */ 302 }; 303 304 class bp_location 305 { 306 public: 307 bp_location () = default; 308 309 bp_location (breakpoint *owner); 310 311 virtual ~bp_location (); 312 313 /* Chain pointer to the next breakpoint location for 314 the same parent breakpoint. */ 315 bp_location *next = NULL; 316 317 /* The reference count. */ 318 int refc = 0; 319 320 /* Type of this breakpoint location. */ 321 bp_loc_type loc_type {}; 322 323 /* Each breakpoint location must belong to exactly one higher-level 324 breakpoint. This pointer is NULL iff this bp_location is no 325 longer attached to a breakpoint. For example, when a breakpoint 326 is deleted, its locations may still be found in the 327 moribund_locations list, or if we had stopped for it, in 328 bpstats. */ 329 breakpoint *owner = NULL; 330 331 /* Conditional. Break only if this expression's value is nonzero. 332 Unlike string form of condition, which is associated with 333 breakpoint, this is associated with location, since if breakpoint 334 has several locations, the evaluation of expression can be 335 different for different locations. Only valid for real 336 breakpoints; a watchpoint's conditional expression is stored in 337 the owner breakpoint object. */ 338 expression_up cond; 339 340 /* Conditional expression in agent expression 341 bytecode form. This is used for stub-side breakpoint 342 condition evaluation. */ 343 agent_expr_up cond_bytecode; 344 345 /* Signals that the condition has changed since the last time 346 we updated the global location list. This means the condition 347 needs to be sent to the target again. This is used together 348 with target-side breakpoint conditions. 349 350 condition_unchanged: It means there has been no condition changes. 351 352 condition_modified: It means this location had its condition modified. 353 354 condition_updated: It means we already marked all the locations that are 355 duplicates of this location and thus we don't need to call 356 force_breakpoint_reinsertion (...) for this location. */ 357 358 condition_status condition_changed {}; 359 360 agent_expr_up cmd_bytecode; 361 362 /* Signals that breakpoint conditions and/or commands need to be 363 re-synched with the target. This has no use other than 364 target-side breakpoints. */ 365 bool needs_update = false; 366 367 /* This location's address is in an unloaded solib, and so this 368 location should not be inserted. It will be automatically 369 enabled when that solib is loaded. */ 370 bool shlib_disabled = false; 371 372 /* Is this particular location enabled. */ 373 bool enabled = false; 374 375 /* Nonzero if this breakpoint is now inserted. */ 376 bool inserted = false; 377 378 /* Nonzero if this is a permanent breakpoint. There is a breakpoint 379 instruction hard-wired into the target's code. Don't try to 380 write another breakpoint instruction on top of it, or restore its 381 value. Step over it using the architecture's 382 gdbarch_skip_permanent_breakpoint method. */ 383 bool permanent = false; 384 385 /* Nonzero if this is not the first breakpoint in the list 386 for the given address. location of tracepoint can _never_ 387 be duplicated with other locations of tracepoints and other 388 kinds of breakpoints, because two locations at the same 389 address may have different actions, so both of these locations 390 should be downloaded and so that `tfind N' always works. */ 391 bool duplicate = false; 392 393 /* If we someday support real thread-specific breakpoints, then 394 the breakpoint location will need a thread identifier. */ 395 396 /* Data for specific breakpoint types. These could be a union, but 397 simplicity is more important than memory usage for breakpoints. */ 398 399 /* Architecture associated with this location's address. May be 400 different from the breakpoint architecture. */ 401 struct gdbarch *gdbarch = NULL; 402 403 /* The program space associated with this breakpoint location 404 address. Note that an address space may be represented in more 405 than one program space (e.g. each uClinux program will be given 406 its own program space, but there will only be one address space 407 for all of them), but we must not insert more than one location 408 at the same address in the same address space. */ 409 program_space *pspace = NULL; 410 411 /* Note that zero is a perfectly valid code address on some platforms 412 (for example, the mn10200 (OBSOLETE) and mn10300 simulators). NULL 413 is not a special value for this field. Valid for all types except 414 bp_loc_other. */ 415 CORE_ADDR address = 0; 416 417 /* For hardware watchpoints, the size of the memory region being 418 watched. For hardware ranged breakpoints, the size of the 419 breakpoint range. */ 420 int length = 0; 421 422 /* Type of hardware watchpoint. */ 423 target_hw_bp_type watchpoint_type {}; 424 425 /* For any breakpoint type with an address, this is the section 426 associated with the address. Used primarily for overlay 427 debugging. */ 428 obj_section *section = NULL; 429 430 /* Address at which breakpoint was requested, either by the user or 431 by GDB for internal breakpoints. This will usually be the same 432 as ``address'' (above) except for cases in which 433 ADJUST_BREAKPOINT_ADDRESS has computed a different address at 434 which to place the breakpoint in order to comply with a 435 processor's architectual constraints. */ 436 CORE_ADDR requested_address = 0; 437 438 /* An additional address assigned with this location. This is currently 439 only used by STT_GNU_IFUNC resolver breakpoints to hold the address 440 of the resolver function. */ 441 CORE_ADDR related_address = 0; 442 443 /* If the location comes from a probe point, this is the probe associated 444 with it. */ 445 bound_probe probe {}; 446 447 char *function_name = NULL; 448 449 /* Details of the placed breakpoint, when inserted. */ 450 bp_target_info target_info {}; 451 452 /* Similarly, for the breakpoint at an overlay's LMA, if necessary. */ 453 bp_target_info overlay_target_info {}; 454 455 /* In a non-stop mode, it's possible that we delete a breakpoint, 456 but as we do that, some still running thread hits that breakpoint. 457 For that reason, we need to keep locations belonging to deleted 458 breakpoints for a bit, so that don't report unexpected SIGTRAP. 459 We can't keep such locations forever, so we use a heuristic -- 460 after we process certain number of inferior events since 461 breakpoint was deleted, we retire all locations of that breakpoint. 462 This variable keeps a number of events still to go, when 463 it becomes 0 this location is retired. */ 464 int events_till_retirement = 0; 465 466 /* Line number which was used to place this location. 467 468 Breakpoint placed into a comment keeps it's user specified line number 469 despite ADDRESS resolves into a different line number. */ 470 471 int line_number = 0; 472 473 /* Symtab which was used to place this location. This is used 474 to find the corresponding source file name. */ 475 476 struct symtab *symtab = NULL; 477 478 /* The symbol found by the location parser, if any. This may be used to 479 ascertain when an event location was set at a different location than 480 the one originally selected by parsing, e.g., inlined symbols. */ 481 const struct symbol *symbol = NULL; 482 483 /* Similarly, the minimal symbol found by the location parser, if 484 any. This may be used to ascertain if the location was 485 originally set on a GNU ifunc symbol. */ 486 const minimal_symbol *msymbol = NULL; 487 488 /* The objfile the symbol or minimal symbol were found in. */ 489 const struct objfile *objfile = NULL; 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 /* We printed nothing or we need to do some more analysis. */ 497 PRINT_UNKNOWN = -1, 498 499 /* We printed something, and we *do* desire that something to be 500 followed by a location. */ 501 PRINT_SRC_AND_LOC, 502 503 /* We printed something, and we do *not* desire that something to be 504 followed by a location. */ 505 PRINT_SRC_ONLY, 506 507 /* We already printed all we needed to print, don't print anything 508 else. */ 509 PRINT_NOTHING 510 }; 511 512 /* This structure is a collection of function pointers that, if available, 513 will be called instead of the performing the default action for this 514 bptype. */ 515 516 struct breakpoint_ops 517 { 518 /* Allocate a location for this breakpoint. */ 519 struct bp_location * (*allocate_location) (struct breakpoint *); 520 521 /* Reevaluate a breakpoint. This is necessary after symbols change 522 (e.g., an executable or DSO was loaded, or the inferior just 523 started). */ 524 void (*re_set) (struct breakpoint *self); 525 526 /* Insert the breakpoint or watchpoint or activate the catchpoint. 527 Return 0 for success, 1 if the breakpoint, watchpoint or 528 catchpoint type is not supported, -1 for failure. */ 529 int (*insert_location) (struct bp_location *); 530 531 /* Remove the breakpoint/catchpoint that was previously inserted 532 with the "insert" method above. Return 0 for success, 1 if the 533 breakpoint, watchpoint or catchpoint type is not supported, 534 -1 for failure. */ 535 int (*remove_location) (struct bp_location *, enum remove_bp_reason reason); 536 537 /* Return true if it the target has stopped due to hitting 538 breakpoint location BL. This function does not check if we 539 should stop, only if BL explains the stop. ASPACE is the address 540 space in which the event occurred, BP_ADDR is the address at 541 which the inferior stopped, and WS is the target_waitstatus 542 describing the event. */ 543 int (*breakpoint_hit) (const struct bp_location *bl, 544 const address_space *aspace, 545 CORE_ADDR bp_addr, 546 const struct target_waitstatus *ws); 547 548 /* Check internal conditions of the breakpoint referred to by BS. 549 If we should not stop for this breakpoint, set BS->stop to 0. */ 550 void (*check_status) (struct bpstats *bs); 551 552 /* Tell how many hardware resources (debug registers) are needed 553 for this breakpoint. If this function is not provided, then 554 the breakpoint or watchpoint needs one debug register. */ 555 int (*resources_needed) (const struct bp_location *); 556 557 /* Tell whether we can downgrade from a hardware watchpoint to a software 558 one. If not, the user will not be able to enable the watchpoint when 559 there are not enough hardware resources available. */ 560 int (*works_in_software_mode) (const struct breakpoint *); 561 562 /* The normal print routine for this breakpoint, called when we 563 hit it. */ 564 enum print_stop_action (*print_it) (struct bpstats *bs); 565 566 /* Display information about this breakpoint, for "info 567 breakpoints". */ 568 void (*print_one) (struct breakpoint *, struct bp_location **); 569 570 /* Display extra information about this breakpoint, below the normal 571 breakpoint description in "info breakpoints". 572 573 In the example below, the "address range" line was printed 574 by print_one_detail_ranged_breakpoint. 575 576 (gdb) info breakpoints 577 Num Type Disp Enb Address What 578 2 hw breakpoint keep y in main at test-watch.c:70 579 address range: [0x10000458, 0x100004c7] 580 581 */ 582 void (*print_one_detail) (const struct breakpoint *, struct ui_out *); 583 584 /* Display information about this breakpoint after setting it 585 (roughly speaking; this is called from "mention"). */ 586 void (*print_mention) (struct breakpoint *); 587 588 /* Print to FP the CLI command that recreates this breakpoint. */ 589 void (*print_recreate) (struct breakpoint *, struct ui_file *fp); 590 591 /* Create SALs from location, storing the result in linespec_result. 592 593 For an explanation about the arguments, see the function 594 `create_sals_from_location_default'. 595 596 This function is called inside `create_breakpoint'. */ 597 void (*create_sals_from_location) (const struct event_location *location, 598 struct linespec_result *canonical, 599 enum bptype type_wanted); 600 601 /* This method will be responsible for creating a breakpoint given its SALs. 602 Usually, it just calls `create_breakpoints_sal' (for ordinary 603 breakpoints). However, there may be some special cases where we might 604 need to do some tweaks, e.g., see 605 `strace_marker_create_breakpoints_sal'. 606 607 This function is called inside `create_breakpoint'. */ 608 void (*create_breakpoints_sal) (struct gdbarch *, 609 struct linespec_result *, 610 gdb::unique_xmalloc_ptr<char>, 611 gdb::unique_xmalloc_ptr<char>, 612 enum bptype, enum bpdisp, int, int, 613 int, const struct breakpoint_ops *, 614 int, int, int, unsigned); 615 616 /* Given the location (second parameter), this method decodes it and 617 returns the SAL locations related to it. For ordinary 618 breakpoints, it calls `decode_line_full'. If SEARCH_PSPACE is 619 not NULL, symbol search is restricted to just that program space. 620 621 This function is called inside `location_to_sals'. */ 622 std::vector<symtab_and_line> (*decode_location) 623 (struct breakpoint *b, 624 const struct event_location *location, 625 struct program_space *search_pspace); 626 627 /* Return true if this breakpoint explains a signal. See 628 bpstat_explains_signal. */ 629 int (*explains_signal) (struct breakpoint *, enum gdb_signal); 630 631 /* Called after evaluating the breakpoint's condition, 632 and only if it evaluated true. */ 633 void (*after_condition_true) (struct bpstats *bs); 634 }; 635 636 /* Helper for breakpoint_ops->print_recreate implementations. Prints 637 the "thread" or "task" condition of B, and then a newline. 638 639 Necessary because most breakpoint implementations accept 640 thread/task conditions at the end of the spec line, like "break foo 641 thread 1", which needs outputting before any breakpoint-type 642 specific extra command necessary for B's recreation. */ 643 extern void print_recreate_thread (struct breakpoint *b, struct ui_file *fp); 644 645 enum watchpoint_triggered 646 { 647 /* This watchpoint definitely did not trigger. */ 648 watch_triggered_no = 0, 649 650 /* Some hardware watchpoint triggered, and it might have been this 651 one, but we do not know which it was. */ 652 watch_triggered_unknown, 653 654 /* This hardware watchpoint definitely did trigger. */ 655 watch_triggered_yes 656 }; 657 658 /* Some targets (e.g., embedded PowerPC) need two debug registers to set 659 a watchpoint over a memory region. If this flag is true, GDB will use 660 only one register per watchpoint, thus assuming that all acesses that 661 modify a memory location happen at its starting address. */ 662 663 extern int target_exact_watchpoints; 664 665 /* Note that the ->silent field is not currently used by any commands 666 (though the code is in there if it was to be, and set_raw_breakpoint 667 does set it to 0). I implemented it because I thought it would be 668 useful for a hack I had to put in; I'm going to leave it in because 669 I can see how there might be times when it would indeed be useful */ 670 671 /* This is for all kinds of breakpoints. */ 672 673 struct breakpoint 674 { 675 virtual ~breakpoint (); 676 677 /* Methods associated with this breakpoint. */ 678 const breakpoint_ops *ops = NULL; 679 680 breakpoint *next = NULL; 681 /* Type of breakpoint. */ 682 bptype type = bp_none; 683 /* Zero means disabled; remember the info but don't break here. */ 684 enum enable_state enable_state = bp_enabled; 685 /* What to do with this breakpoint after we hit it. */ 686 bpdisp disposition = disp_del; 687 /* Number assigned to distinguish breakpoints. */ 688 int number = 0; 689 690 /* Location(s) associated with this high-level breakpoint. */ 691 bp_location *loc = NULL; 692 693 /* True means a silent breakpoint (don't print frame info if we stop 694 here). */ 695 bool silent = false; 696 /* True means display ADDR_STRING to the user verbatim. */ 697 bool display_canonical = false; 698 /* Number of stops at this breakpoint that should be continued 699 automatically before really stopping. */ 700 int ignore_count = 0; 701 702 /* Number of stops at this breakpoint before it will be 703 disabled. */ 704 int enable_count = 0; 705 706 /* Chain of command lines to execute when this breakpoint is 707 hit. */ 708 counted_command_line commands; 709 /* Stack depth (address of frame). If nonzero, break only if fp 710 equals this. */ 711 struct frame_id frame_id = null_frame_id; 712 713 /* The program space used to set the breakpoint. This is only set 714 for breakpoints which are specific to a program space; for 715 non-thread-specific ordinary breakpoints this is NULL. */ 716 program_space *pspace = NULL; 717 718 /* Location we used to set the breakpoint. */ 719 event_location_up location; 720 721 /* The filter that should be passed to decode_line_full when 722 re-setting this breakpoint. This may be NULL, but otherwise is 723 allocated with xmalloc. */ 724 char *filter = NULL; 725 726 /* For a ranged breakpoint, the location we used to find the end of 727 the range. */ 728 event_location_up location_range_end; 729 730 /* Architecture we used to set the breakpoint. */ 731 struct gdbarch *gdbarch = NULL; 732 /* Language we used to set the breakpoint. */ 733 enum language language = language_unknown; 734 /* Input radix we used to set the breakpoint. */ 735 int input_radix = 0; 736 /* String form of the breakpoint condition (malloc'd), or NULL if 737 there is no condition. */ 738 char *cond_string = NULL; 739 740 /* String form of extra parameters, or NULL if there are none. 741 Malloc'd. */ 742 char *extra_string = NULL; 743 744 /* Holds the address of the related watchpoint_scope breakpoint when 745 using watchpoints on local variables (might the concept of a 746 related breakpoint be useful elsewhere, if not just call it the 747 watchpoint_scope breakpoint or something like that. FIXME). */ 748 breakpoint *related_breakpoint = NULL; 749 750 /* Thread number for thread-specific breakpoint, or -1 if don't 751 care. */ 752 int thread = -1; 753 754 /* Ada task number for task-specific breakpoint, or 0 if don't 755 care. */ 756 int task = 0; 757 758 /* Count of the number of times this breakpoint was taken, dumped 759 with the info, but not used for anything else. Useful for seeing 760 how many times you hit a break prior to the program aborting, so 761 you can back up to just before the abort. */ 762 int hit_count = 0; 763 764 /* Is breakpoint's condition not yet parsed because we found no 765 location initially so had no context to parse the condition 766 in. */ 767 int condition_not_parsed = 0; 768 769 /* With a Python scripting enabled GDB, store a reference to the 770 Python object that has been associated with this breakpoint. 771 This is always NULL for a GDB that is not script enabled. It can 772 sometimes be NULL for enabled GDBs as not all breakpoint types 773 are tracked by the scripting language API. */ 774 gdbpy_breakpoint_object *py_bp_object = NULL; 775 776 /* Same as py_bp_object, but for Scheme. */ 777 gdbscm_breakpoint_object *scm_bp_object = NULL; 778 }; 779 780 /* An instance of this type is used to represent a watchpoint. */ 781 782 struct watchpoint : public breakpoint 783 { 784 ~watchpoint () override; 785 786 /* String form of exp to use for displaying to the user (malloc'd), 787 or NULL if none. */ 788 char *exp_string; 789 /* String form to use for reparsing of EXP (malloc'd) or NULL. */ 790 char *exp_string_reparse; 791 792 /* The expression we are watching, or NULL if not a watchpoint. */ 793 expression_up exp; 794 /* The largest block within which it is valid, or NULL if it is 795 valid anywhere (e.g. consists just of global symbols). */ 796 const struct block *exp_valid_block; 797 /* The conditional expression if any. */ 798 expression_up cond_exp; 799 /* The largest block within which it is valid, or NULL if it is 800 valid anywhere (e.g. consists just of global symbols). */ 801 const struct block *cond_exp_valid_block; 802 /* Value of the watchpoint the last time we checked it, or NULL when 803 we do not know the value yet or the value was not readable. VAL 804 is never lazy. */ 805 value_ref_ptr val; 806 /* Nonzero if VAL is valid. If VAL_VALID is set but VAL is NULL, 807 then an error occurred reading the value. */ 808 int val_valid; 809 810 /* When watching the location of a bitfield, contains the offset and size of 811 the bitfield. Otherwise contains 0. */ 812 int val_bitpos; 813 int val_bitsize; 814 815 /* Holds the frame address which identifies the frame this 816 watchpoint should be evaluated in, or `null' if the watchpoint 817 should be evaluated on the outermost frame. */ 818 struct frame_id watchpoint_frame; 819 820 /* Holds the thread which identifies the frame this watchpoint 821 should be considered in scope for, or `null_ptid' if the 822 watchpoint should be evaluated in all threads. */ 823 ptid_t watchpoint_thread; 824 825 /* For hardware watchpoints, the triggered status according to the 826 hardware. */ 827 enum watchpoint_triggered watchpoint_triggered; 828 829 /* Whether this watchpoint is exact (see 830 target_exact_watchpoints). */ 831 int exact; 832 833 /* The mask address for a masked hardware watchpoint. */ 834 CORE_ADDR hw_wp_mask; 835 }; 836 837 /* Given a function FUNC (struct breakpoint *B, void *DATA) and 838 USER_DATA, call FUNC for every known breakpoint passing USER_DATA 839 as argument. 840 841 If FUNC returns 1, the loop stops and the current 842 'struct breakpoint' being processed is returned. If FUNC returns 843 zero, the loop continues. 844 845 This function returns either a 'struct breakpoint' pointer or NULL. 846 It was based on BFD's bfd_sections_find_if function. */ 847 848 extern struct breakpoint *breakpoint_find_if 849 (int (*func) (struct breakpoint *b, void *d), void *user_data); 850 851 /* Return true if BPT is either a software breakpoint or a hardware 852 breakpoint. */ 853 854 extern int is_breakpoint (const struct breakpoint *bpt); 855 856 /* Returns true if BPT is really a watchpoint. */ 857 858 extern int is_watchpoint (const struct breakpoint *bpt); 859 860 /* An instance of this type is used to represent all kinds of 861 tracepoints. */ 862 863 struct tracepoint : public breakpoint 864 { 865 /* Number of times this tracepoint should single-step and collect 866 additional data. */ 867 long step_count; 868 869 /* Number of times this tracepoint should be hit before 870 disabling/ending. */ 871 int pass_count; 872 873 /* The number of the tracepoint on the target. */ 874 int number_on_target; 875 876 /* The total space taken by all the trace frames for this 877 tracepoint. */ 878 ULONGEST traceframe_usage; 879 880 /* The static tracepoint marker id, if known. */ 881 std::string static_trace_marker_id; 882 883 /* LTTng/UST allow more than one marker with the same ID string, 884 although it unadvised because it confuses tools. When setting 885 static tracepoints by marker ID, this will record the index in 886 the array of markers we found for the given marker ID for which 887 this static tracepoint corresponds. When resetting breakpoints, 888 we will use this index to try to find the same marker again. */ 889 int static_trace_marker_id_idx; 890 }; 891 892 893 /* The following stuff is an abstract data type "bpstat" ("breakpoint 894 status"). This provides the ability to determine whether we have 895 stopped at a breakpoint, and what we should do about it. */ 896 897 typedef struct bpstats *bpstat; 898 899 /* Clears a chain of bpstat, freeing storage 900 of each. */ 901 extern void bpstat_clear (bpstat *); 902 903 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that 904 is part of the bpstat is copied as well. */ 905 extern bpstat bpstat_copy (bpstat); 906 907 /* Build the (raw) bpstat chain for the stop information given by ASPACE, 908 BP_ADDR, and WS. Returns the head of the bpstat chain. */ 909 910 extern bpstat build_bpstat_chain (const address_space *aspace, 911 CORE_ADDR bp_addr, 912 const struct target_waitstatus *ws); 913 914 /* Get a bpstat associated with having just stopped at address 915 BP_ADDR in thread PTID. STOP_CHAIN may be supplied as a previously 916 computed stop chain or NULL, in which case the stop chain will be 917 computed using build_bpstat_chain. 918 919 Determine whether we stopped at a breakpoint, etc, or whether we 920 don't understand this stop. Result is a chain of bpstat's such 921 that: 922 923 if we don't understand the stop, the result is a null pointer. 924 925 if we understand why we stopped, the result is not null. 926 927 Each element of the chain refers to a particular breakpoint or 928 watchpoint at which we have stopped. (We may have stopped for 929 several reasons concurrently.) 930 931 Each element of the chain has valid next, breakpoint_at, 932 commands, FIXME??? fields. */ 933 934 extern bpstat bpstat_stop_status (const address_space *aspace, 935 CORE_ADDR pc, thread_info *thread, 936 const struct target_waitstatus *ws, 937 bpstat stop_chain = NULL); 938 939 /* This bpstat_what stuff tells wait_for_inferior what to do with a 940 breakpoint (a challenging task). 941 942 The enum values order defines priority-like order of the actions. 943 Once you've decided that some action is appropriate, you'll never 944 go back and decide something of a lower priority is better. Each 945 of these actions is mutually exclusive with the others. That 946 means, that if you find yourself adding a new action class here and 947 wanting to tell GDB that you have two simultaneous actions to 948 handle, something is wrong, and you probably don't actually need a 949 new action type. 950 951 Note that a step resume breakpoint overrides another breakpoint of 952 signal handling (see comment in wait_for_inferior at where we set 953 the step_resume breakpoint). */ 954 955 enum bpstat_what_main_action 956 { 957 /* Perform various other tests; that is, this bpstat does not 958 say to perform any action (e.g. failed watchpoint and nothing 959 else). */ 960 BPSTAT_WHAT_KEEP_CHECKING, 961 962 /* Remove breakpoints, single step once, then put them back in and 963 go back to what we were doing. It's possible that this should 964 be removed from the main_action and put into a separate field, 965 to more cleanly handle 966 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE. */ 967 BPSTAT_WHAT_SINGLE, 968 969 /* Set longjmp_resume breakpoint, remove all other breakpoints, 970 and continue. The "remove all other breakpoints" part is 971 required if we are also stepping over another breakpoint as 972 well as doing the longjmp handling. */ 973 BPSTAT_WHAT_SET_LONGJMP_RESUME, 974 975 /* Clear longjmp_resume breakpoint, then handle as 976 BPSTAT_WHAT_KEEP_CHECKING. */ 977 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME, 978 979 /* Clear step resume breakpoint, and keep checking. */ 980 BPSTAT_WHAT_STEP_RESUME, 981 982 /* Rather than distinguish between noisy and silent stops here, it 983 might be cleaner to have bpstat_print make that decision (also 984 taking into account stop_print_frame and source_only). But the 985 implications are a bit scary (interaction with auto-displays, 986 etc.), so I won't try it. */ 987 988 /* Stop silently. */ 989 BPSTAT_WHAT_STOP_SILENT, 990 991 /* Stop and print. */ 992 BPSTAT_WHAT_STOP_NOISY, 993 994 /* Clear step resume breakpoint, and keep checking. High-priority 995 step-resume breakpoints are used when even if there's a user 996 breakpoint at the current PC when we set the step-resume 997 breakpoint, we don't want to re-handle any breakpoint other 998 than the step-resume when it's hit; instead we want to move 999 past the breakpoint. This is used in the case of skipping 1000 signal handlers. */ 1001 BPSTAT_WHAT_HP_STEP_RESUME, 1002 }; 1003 1004 /* An enum indicating the kind of "stack dummy" stop. This is a bit 1005 of a misnomer because only one kind of truly a stack dummy. */ 1006 enum stop_stack_kind 1007 { 1008 /* We didn't stop at a stack dummy breakpoint. */ 1009 STOP_NONE = 0, 1010 1011 /* Stopped at a stack dummy. */ 1012 STOP_STACK_DUMMY, 1013 1014 /* Stopped at std::terminate. */ 1015 STOP_STD_TERMINATE 1016 }; 1017 1018 struct bpstat_what 1019 { 1020 enum bpstat_what_main_action main_action; 1021 1022 /* Did we hit a call dummy breakpoint? This only goes with a 1023 main_action of BPSTAT_WHAT_STOP_SILENT or 1024 BPSTAT_WHAT_STOP_NOISY (the concept of continuing from a call 1025 dummy without popping the frame is not a useful one). */ 1026 enum stop_stack_kind call_dummy; 1027 1028 /* Used for BPSTAT_WHAT_SET_LONGJMP_RESUME and 1029 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME. True if we are handling a 1030 longjmp, false if we are handling an exception. */ 1031 int is_longjmp; 1032 }; 1033 1034 /* Tell what to do about this bpstat. */ 1035 struct bpstat_what bpstat_what (bpstat); 1036 1037 /* Run breakpoint event callbacks associated with the breakpoints that 1038 triggered. */ 1039 extern void bpstat_run_callbacks (bpstat bs_head); 1040 1041 /* Find the bpstat associated with a breakpoint. NULL otherwise. */ 1042 bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *); 1043 1044 /* Nonzero if a signal that we got in target_wait() was due to 1045 circumstances explained by the bpstat; the signal is therefore not 1046 random. */ 1047 extern int bpstat_explains_signal (bpstat, enum gdb_signal); 1048 1049 /* Nonzero is this bpstat causes a stop. */ 1050 extern int bpstat_causes_stop (bpstat); 1051 1052 /* Nonzero if we should step constantly (e.g. watchpoints on machines 1053 without hardware support). This isn't related to a specific bpstat, 1054 just to things like whether watchpoints are set. */ 1055 extern int bpstat_should_step (void); 1056 1057 /* Print a message indicating what happened. Returns nonzero to 1058 say that only the source line should be printed after this (zero 1059 return means print the frame as well as the source line). */ 1060 extern enum print_stop_action bpstat_print (bpstat, int); 1061 1062 /* Put in *NUM the breakpoint number of the first breakpoint we are 1063 stopped at. *BSP upon return is a bpstat which points to the 1064 remaining breakpoints stopped at (but which is not guaranteed to be 1065 good for anything but further calls to bpstat_num). 1066 1067 Return 0 if passed a bpstat which does not indicate any breakpoints. 1068 Return -1 if stopped at a breakpoint that has been deleted since 1069 we set it. 1070 Return 1 otherwise. */ 1071 extern int bpstat_num (bpstat *, int *); 1072 1073 /* Perform actions associated with the stopped inferior. Actually, we 1074 just use this for breakpoint commands. Perhaps other actions will 1075 go here later, but this is executed at a late time (from the 1076 command loop). */ 1077 extern void bpstat_do_actions (void); 1078 1079 /* Modify all entries of STOP_BPSTAT of INFERIOR_PTID so that the actions will 1080 not be performed. */ 1081 extern void bpstat_clear_actions (void); 1082 1083 /* Implementation: */ 1084 1085 /* Values used to tell the printing routine how to behave for this 1086 bpstat. */ 1087 enum bp_print_how 1088 { 1089 /* This is used when we want to do a normal printing of the reason 1090 for stopping. The output will depend on the type of eventpoint 1091 we are dealing with. This is the default value, most commonly 1092 used. */ 1093 print_it_normal, 1094 /* This is used when nothing should be printed for this bpstat 1095 entry. */ 1096 print_it_noop, 1097 /* This is used when everything which needs to be printed has 1098 already been printed. But we still want to print the frame. */ 1099 print_it_done 1100 }; 1101 1102 struct bpstats 1103 { 1104 bpstats (); 1105 bpstats (struct bp_location *bl, bpstat **bs_link_pointer); 1106 ~bpstats (); 1107 1108 bpstats (const bpstats &); 1109 bpstats &operator= (const bpstats &) = delete; 1110 1111 /* Linked list because there can be more than one breakpoint at 1112 the same place, and a bpstat reflects the fact that all have 1113 been hit. */ 1114 bpstat next; 1115 1116 /* Location that caused the stop. Locations are refcounted, so 1117 this will never be NULL. Note that this location may end up 1118 detached from a breakpoint, but that does not necessary mean 1119 that the struct breakpoint is gone. E.g., consider a 1120 watchpoint with a condition that involves an inferior function 1121 call. Watchpoint locations are recreated often (on resumes, 1122 hence on infcalls too). Between creating the bpstat and after 1123 evaluating the watchpoint condition, this location may hence 1124 end up detached from its original owner watchpoint, even though 1125 the watchpoint is still listed. If it's condition evaluates as 1126 true, we still want this location to cause a stop, and we will 1127 still need to know which watchpoint it was originally attached. 1128 What this means is that we should not (in most cases) follow 1129 the `bpstat->bp_location->owner' link, but instead use the 1130 `breakpoint_at' field below. */ 1131 struct bp_location *bp_location_at; 1132 1133 /* Breakpoint that caused the stop. This is nullified if the 1134 breakpoint ends up being deleted. See comments on 1135 `bp_location_at' above for why do we need this field instead of 1136 following the location's owner. */ 1137 struct breakpoint *breakpoint_at; 1138 1139 /* The associated command list. */ 1140 counted_command_line commands; 1141 1142 /* Old value associated with a watchpoint. */ 1143 value_ref_ptr old_val; 1144 1145 /* Nonzero if this breakpoint tells us to print the frame. */ 1146 char print; 1147 1148 /* Nonzero if this breakpoint tells us to stop. */ 1149 char stop; 1150 1151 /* Tell bpstat_print and print_bp_stop_message how to print stuff 1152 associated with this element of the bpstat chain. */ 1153 enum bp_print_how print_it; 1154 }; 1155 1156 enum inf_context 1157 { 1158 inf_starting, 1159 inf_running, 1160 inf_exited, 1161 inf_execd 1162 }; 1163 1164 /* The possible return values for breakpoint_here_p. 1165 We guarantee that zero always means "no breakpoint here". */ 1166 enum breakpoint_here 1167 { 1168 no_breakpoint_here = 0, 1169 ordinary_breakpoint_here, 1170 permanent_breakpoint_here 1171 }; 1172 1173 1174 /* Prototypes for breakpoint-related functions. */ 1175 1176 /* Return 1 if there's a program/permanent breakpoint planted in 1177 memory at ADDRESS, return 0 otherwise. */ 1178 1179 extern int program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address); 1180 1181 extern enum breakpoint_here breakpoint_here_p (const address_space *, 1182 CORE_ADDR); 1183 1184 /* Return true if an enabled breakpoint exists in the range defined by 1185 ADDR and LEN, in ASPACE. */ 1186 extern int breakpoint_in_range_p (const address_space *aspace, 1187 CORE_ADDR addr, ULONGEST len); 1188 1189 extern int moribund_breakpoint_here_p (const address_space *, CORE_ADDR); 1190 1191 extern int breakpoint_inserted_here_p (const address_space *, 1192 CORE_ADDR); 1193 1194 extern int software_breakpoint_inserted_here_p (const address_space *, 1195 CORE_ADDR); 1196 1197 /* Return non-zero iff there is a hardware breakpoint inserted at 1198 PC. */ 1199 extern int hardware_breakpoint_inserted_here_p (const address_space *, 1200 CORE_ADDR); 1201 1202 /* Check whether any location of BP is inserted at PC. */ 1203 1204 extern int breakpoint_has_location_inserted_here (struct breakpoint *bp, 1205 const address_space *aspace, 1206 CORE_ADDR pc); 1207 1208 extern int single_step_breakpoint_inserted_here_p (const address_space *, 1209 CORE_ADDR); 1210 1211 /* Returns true if there's a hardware watchpoint or access watchpoint 1212 inserted in the range defined by ADDR and LEN. */ 1213 extern int hardware_watchpoint_inserted_in_range (const address_space *, 1214 CORE_ADDR addr, 1215 ULONGEST len); 1216 1217 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the 1218 same breakpoint location. In most targets, this can only be true 1219 if ASPACE1 matches ASPACE2. On targets that have global 1220 breakpoints, the address space doesn't really matter. */ 1221 1222 extern int breakpoint_address_match (const address_space *aspace1, 1223 CORE_ADDR addr1, 1224 const address_space *aspace2, 1225 CORE_ADDR addr2); 1226 1227 extern void until_break_command (const char *, int, int); 1228 1229 /* Initialize a struct bp_location. */ 1230 1231 extern void update_breakpoint_locations 1232 (struct breakpoint *b, 1233 struct program_space *filter_pspace, 1234 gdb::array_view<const symtab_and_line> sals, 1235 gdb::array_view<const symtab_and_line> sals_end); 1236 1237 extern void breakpoint_re_set (void); 1238 1239 extern void breakpoint_re_set_thread (struct breakpoint *); 1240 1241 extern void delete_breakpoint (struct breakpoint *); 1242 1243 struct breakpoint_deleter 1244 { 1245 void operator() (struct breakpoint *b) const 1246 { 1247 delete_breakpoint (b); 1248 } 1249 }; 1250 1251 typedef std::unique_ptr<struct breakpoint, breakpoint_deleter> breakpoint_up; 1252 1253 extern breakpoint_up set_momentary_breakpoint 1254 (struct gdbarch *, struct symtab_and_line, struct frame_id, enum bptype); 1255 1256 extern breakpoint_up set_momentary_breakpoint_at_pc 1257 (struct gdbarch *, CORE_ADDR pc, enum bptype type); 1258 1259 extern struct breakpoint *clone_momentary_breakpoint (struct breakpoint *bpkt); 1260 1261 extern void set_ignore_count (int, int, int); 1262 1263 extern void breakpoint_init_inferior (enum inf_context); 1264 1265 extern void breakpoint_auto_delete (bpstat); 1266 1267 typedef void (*walk_bp_location_callback) (struct bp_location *, void *); 1268 1269 extern void iterate_over_bp_locations (walk_bp_location_callback); 1270 1271 /* Return the chain of command lines to execute when this breakpoint 1272 is hit. */ 1273 extern struct command_line *breakpoint_commands (struct breakpoint *b); 1274 1275 /* Return a string image of DISP. The string is static, and thus should 1276 NOT be deallocated after use. */ 1277 const char *bpdisp_text (enum bpdisp disp); 1278 1279 extern void break_command (const char *, int); 1280 1281 extern void hbreak_command_wrapper (const char *, int); 1282 extern void thbreak_command_wrapper (const char *, int); 1283 extern void rbreak_command_wrapper (const char *, int); 1284 extern void watch_command_wrapper (const char *, int, int); 1285 extern void awatch_command_wrapper (const char *, int, int); 1286 extern void rwatch_command_wrapper (const char *, int, int); 1287 extern void tbreak_command (const char *, int); 1288 1289 extern struct breakpoint_ops base_breakpoint_ops; 1290 extern struct breakpoint_ops bkpt_breakpoint_ops; 1291 extern struct breakpoint_ops tracepoint_breakpoint_ops; 1292 extern struct breakpoint_ops dprintf_breakpoint_ops; 1293 1294 extern void initialize_breakpoint_ops (void); 1295 1296 /* Arguments to pass as context to some catch command handlers. */ 1297 #define CATCH_PERMANENT ((void *) (uintptr_t) 0) 1298 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1) 1299 1300 /* Like add_cmd, but add the command to both the "catch" and "tcatch" 1301 lists, and pass some additional user data to the command 1302 function. */ 1303 1304 extern void 1305 add_catch_command (const char *name, const char *docstring, 1306 cmd_const_sfunc_ftype *sfunc, 1307 completer_ftype *completer, 1308 void *user_data_catch, 1309 void *user_data_tcatch); 1310 1311 /* Initialize a breakpoint struct for Ada exception catchpoints. */ 1312 1313 extern void 1314 init_ada_exception_breakpoint (struct breakpoint *b, 1315 struct gdbarch *gdbarch, 1316 struct symtab_and_line sal, 1317 const char *addr_string, 1318 const struct breakpoint_ops *ops, 1319 int tempflag, 1320 int enabled, 1321 int from_tty); 1322 1323 extern void init_catchpoint (struct breakpoint *b, 1324 struct gdbarch *gdbarch, int tempflag, 1325 const char *cond_string, 1326 const struct breakpoint_ops *ops); 1327 1328 /* Add breakpoint B on the breakpoint list, and notify the user, the 1329 target and breakpoint_created observers of its existence. If 1330 INTERNAL is non-zero, the breakpoint number will be allocated from 1331 the internal breakpoint count. If UPDATE_GLL is non-zero, 1332 update_global_location_list will be called. */ 1333 1334 extern void install_breakpoint (int internal, std::unique_ptr<breakpoint> &&b, 1335 int update_gll); 1336 1337 /* Flags that can be passed down to create_breakpoint, etc., to affect 1338 breakpoint creation in several ways. */ 1339 1340 enum breakpoint_create_flags 1341 { 1342 /* We're adding a breakpoint to our tables that is already 1343 inserted in the target. */ 1344 CREATE_BREAKPOINT_FLAGS_INSERTED = 1 << 0 1345 }; 1346 1347 /* Set a breakpoint. This function is shared between CLI and MI functions 1348 for setting a breakpoint at LOCATION. 1349 1350 This function has two major modes of operations, selected by the 1351 PARSE_EXTRA parameter. 1352 1353 If PARSE_EXTRA is zero, LOCATION is just the breakpoint's location, 1354 with condition, thread, and extra string specified by the COND_STRING, 1355 THREAD, and EXTRA_STRING parameters. 1356 1357 If PARSE_EXTRA is non-zero, this function will attempt to extract 1358 the condition, thread, and extra string from EXTRA_STRING, ignoring 1359 the similarly named parameters. 1360 1361 If INTERNAL is non-zero, the breakpoint number will be allocated 1362 from the internal breakpoint count. 1363 1364 Returns true if any breakpoint was created; false otherwise. */ 1365 1366 extern int create_breakpoint (struct gdbarch *gdbarch, 1367 const struct event_location *location, 1368 const char *cond_string, int thread, 1369 const char *extra_string, 1370 int parse_extra, 1371 int tempflag, enum bptype wanted_type, 1372 int ignore_count, 1373 enum auto_boolean pending_break_support, 1374 const struct breakpoint_ops *ops, 1375 int from_tty, 1376 int enabled, 1377 int internal, unsigned flags); 1378 1379 extern void insert_breakpoints (void); 1380 1381 extern int remove_breakpoints (void); 1382 1383 extern int remove_breakpoints_inf (inferior *inf); 1384 1385 /* This function can be used to update the breakpoint package's state 1386 after an exec() system call has been executed. 1387 1388 This function causes the following: 1389 1390 - All eventpoints are marked "not inserted". 1391 - All eventpoints with a symbolic address are reset such that 1392 the symbolic address must be reevaluated before the eventpoints 1393 can be reinserted. 1394 - The solib breakpoints are explicitly removed from the breakpoint 1395 list. 1396 - A step-resume breakpoint, if any, is explicitly removed from the 1397 breakpoint list. 1398 - All eventpoints without a symbolic address are removed from the 1399 breakpoint list. */ 1400 extern void update_breakpoints_after_exec (void); 1401 1402 /* This function can be used to physically remove hardware breakpoints 1403 and watchpoints from the specified traced inferior process, without 1404 modifying the breakpoint package's state. This can be useful for 1405 those targets which support following the processes of a fork() or 1406 vfork() system call, when one of the resulting two processes is to 1407 be detached and allowed to run free. 1408 1409 It is an error to use this function on the process whose id is 1410 inferior_ptid. */ 1411 extern int detach_breakpoints (ptid_t ptid); 1412 1413 /* This function is called when program space PSPACE is about to be 1414 deleted. It takes care of updating breakpoints to not reference 1415 this PSPACE anymore. */ 1416 extern void breakpoint_program_space_exit (struct program_space *pspace); 1417 1418 extern void set_longjmp_breakpoint (struct thread_info *tp, 1419 struct frame_id frame); 1420 extern void delete_longjmp_breakpoint (int thread); 1421 1422 /* Mark all longjmp breakpoints from THREAD for later deletion. */ 1423 extern void delete_longjmp_breakpoint_at_next_stop (int thread); 1424 1425 extern struct breakpoint *set_longjmp_breakpoint_for_call_dummy (void); 1426 extern void check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp); 1427 1428 extern void enable_overlay_breakpoints (void); 1429 extern void disable_overlay_breakpoints (void); 1430 1431 extern void set_std_terminate_breakpoint (void); 1432 extern void delete_std_terminate_breakpoint (void); 1433 1434 /* These functions respectively disable or reenable all currently 1435 enabled watchpoints. When disabled, the watchpoints are marked 1436 call_disabled. When re-enabled, they are marked enabled. 1437 1438 The intended client of these functions is call_function_by_hand. 1439 1440 The inferior must be stopped, and all breakpoints removed, when 1441 these functions are used. 1442 1443 The need for these functions is that on some targets (e.g., HP-UX), 1444 gdb is unable to unwind through the dummy frame that is pushed as 1445 part of the implementation of a call command. Watchpoints can 1446 cause the inferior to stop in places where this frame is visible, 1447 and that can cause execution control to become very confused. 1448 1449 Note that if a user sets breakpoints in an interactively called 1450 function, the call_disabled watchpoints will have been re-enabled 1451 when the first such breakpoint is reached. However, on targets 1452 that are unable to unwind through the call dummy frame, watches 1453 of stack-based storage may then be deleted, because gdb will 1454 believe that their watched storage is out of scope. (Sigh.) */ 1455 extern void disable_watchpoints_before_interactive_call_start (void); 1456 1457 extern void enable_watchpoints_after_interactive_call_stop (void); 1458 1459 /* These functions disable and re-enable all breakpoints during 1460 inferior startup. They are intended to be called from solib 1461 code where necessary. This is needed on platforms where the 1462 main executable is relocated at some point during startup 1463 processing, making breakpoint addresses invalid. 1464 1465 If additional breakpoints are created after the routine 1466 disable_breakpoints_before_startup but before the routine 1467 enable_breakpoints_after_startup was called, they will also 1468 be marked as disabled. */ 1469 extern void disable_breakpoints_before_startup (void); 1470 extern void enable_breakpoints_after_startup (void); 1471 1472 /* For script interpreters that need to define breakpoint commands 1473 after they've already read the commands into a struct 1474 command_line. */ 1475 extern enum command_control_type commands_from_control_command 1476 (const char *arg, struct command_line *cmd); 1477 1478 extern void clear_breakpoint_hit_counts (void); 1479 1480 extern struct breakpoint *get_breakpoint (int num); 1481 1482 /* The following are for displays, which aren't really breakpoints, 1483 but here is as good a place as any for them. */ 1484 1485 extern void disable_current_display (void); 1486 1487 extern void do_displays (void); 1488 1489 extern void disable_display (int); 1490 1491 extern void clear_displays (void); 1492 1493 extern void disable_breakpoint (struct breakpoint *); 1494 1495 extern void enable_breakpoint (struct breakpoint *); 1496 1497 extern void breakpoint_set_commands (struct breakpoint *b, 1498 counted_command_line &&commands); 1499 1500 extern void breakpoint_set_silent (struct breakpoint *b, int silent); 1501 1502 extern void breakpoint_set_thread (struct breakpoint *b, int thread); 1503 1504 extern void breakpoint_set_task (struct breakpoint *b, int task); 1505 1506 /* Clear the "inserted" flag in all breakpoints. */ 1507 extern void mark_breakpoints_out (void); 1508 1509 extern struct breakpoint *create_jit_event_breakpoint (struct gdbarch *, 1510 CORE_ADDR); 1511 1512 extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *, 1513 CORE_ADDR); 1514 1515 /* Create an solib event breakpoint at ADDRESS in the current program 1516 space, and immediately try to insert it. Returns a pointer to the 1517 breakpoint on success. Deletes the new breakpoint and returns NULL 1518 if inserting the breakpoint fails. */ 1519 extern struct breakpoint *create_and_insert_solib_event_breakpoint 1520 (struct gdbarch *gdbarch, CORE_ADDR address); 1521 1522 extern struct breakpoint *create_thread_event_breakpoint (struct gdbarch *, 1523 CORE_ADDR); 1524 1525 extern void remove_jit_event_breakpoints (void); 1526 1527 extern void remove_solib_event_breakpoints (void); 1528 1529 /* Mark solib event breakpoints of the current program space with 1530 delete at next stop disposition. */ 1531 extern void remove_solib_event_breakpoints_at_next_stop (void); 1532 1533 extern void disable_breakpoints_in_shlibs (void); 1534 1535 /* This function returns TRUE if ep is a catchpoint. */ 1536 extern int is_catchpoint (struct breakpoint *); 1537 1538 /* Shared helper function (MI and CLI) for creating and installing 1539 a shared object event catchpoint. */ 1540 extern void add_solib_catchpoint (const char *arg, int is_load, int is_temp, 1541 int enabled); 1542 1543 /* Create and insert a new software single step breakpoint for the 1544 current thread. May be called multiple times; each time will add a 1545 new location to the set of potential addresses the next instruction 1546 is at. */ 1547 extern void insert_single_step_breakpoint (struct gdbarch *, 1548 const address_space *, 1549 CORE_ADDR); 1550 1551 /* Insert all software single step breakpoints for the current frame. 1552 Return true if any software single step breakpoints are inserted, 1553 otherwise, return false. */ 1554 extern int insert_single_step_breakpoints (struct gdbarch *); 1555 1556 /* Check if any hardware watchpoints have triggered, according to the 1557 target. */ 1558 int watchpoints_triggered (struct target_waitstatus *); 1559 1560 /* Helper for transparent breakpoint hiding for memory read and write 1561 routines. 1562 1563 Update one of READBUF or WRITEBUF with either the shadows 1564 (READBUF), or the breakpoint instructions (WRITEBUF) of inserted 1565 breakpoints at the memory range defined by MEMADDR and extending 1566 for LEN bytes. If writing, then WRITEBUF is a copy of WRITEBUF_ORG 1567 on entry.*/ 1568 extern void breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf, 1569 const gdb_byte *writebuf_org, 1570 ULONGEST memaddr, LONGEST len); 1571 1572 /* Return true if breakpoints should be inserted now. That'll be the 1573 case if either: 1574 1575 - the target has global breakpoints. 1576 1577 - "breakpoint always-inserted" is on, and the target has 1578 execution. 1579 1580 - threads are executing. 1581 */ 1582 extern int breakpoints_should_be_inserted_now (void); 1583 1584 /* Called each time new event from target is processed. 1585 Retires previously deleted breakpoint locations that 1586 in our opinion won't ever trigger. */ 1587 extern void breakpoint_retire_moribund (void); 1588 1589 /* Set break condition of breakpoint B to EXP. */ 1590 extern void set_breakpoint_condition (struct breakpoint *b, const char *exp, 1591 int from_tty); 1592 1593 /* Checks if we are catching syscalls or not. 1594 Returns 0 if not, greater than 0 if we are. */ 1595 extern int catch_syscall_enabled (void); 1596 1597 /* Checks if we are catching syscalls with the specific 1598 syscall_number. Used for "filtering" the catchpoints. 1599 Returns 0 if not, greater than 0 if we are. */ 1600 extern int catching_syscall_number (int syscall_number); 1601 1602 /* Return a tracepoint with the given number if found. */ 1603 extern struct tracepoint *get_tracepoint (int num); 1604 1605 extern struct tracepoint *get_tracepoint_by_number_on_target (int num); 1606 1607 /* Find a tracepoint by parsing a number in the supplied string. */ 1608 extern struct tracepoint * 1609 get_tracepoint_by_number (const char **arg, 1610 number_or_range_parser *parser); 1611 1612 /* Return a vector of all tracepoints currently defined. */ 1613 extern std::vector<breakpoint *> all_tracepoints (void); 1614 1615 extern int is_tracepoint (const struct breakpoint *b); 1616 1617 /* Return a vector of all static tracepoints defined at ADDR. */ 1618 extern std::vector<breakpoint *> static_tracepoints_here (CORE_ADDR addr); 1619 1620 /* Create an instance of this to start registering breakpoint numbers 1621 for a later "commands" command. */ 1622 1623 class scoped_rbreak_breakpoints 1624 { 1625 public: 1626 1627 scoped_rbreak_breakpoints (); 1628 ~scoped_rbreak_breakpoints (); 1629 1630 DISABLE_COPY_AND_ASSIGN (scoped_rbreak_breakpoints); 1631 }; 1632 1633 /* Breakpoint iterator function. 1634 1635 Calls a callback function once for each breakpoint, so long as the 1636 callback function returns false. If the callback function returns 1637 true, the iteration will end and the current breakpoint will be 1638 returned. This can be useful for implementing a search for a 1639 breakpoint with arbitrary attributes, or for applying an operation 1640 to every breakpoint. */ 1641 extern struct breakpoint *iterate_over_breakpoints (int (*) (struct breakpoint *, 1642 void *), void *); 1643 1644 /* Nonzero if the specified PC cannot be a location where functions 1645 have been inlined. */ 1646 1647 extern int pc_at_non_inline_function (const address_space *aspace, 1648 CORE_ADDR pc, 1649 const struct target_waitstatus *ws); 1650 1651 extern int user_breakpoint_p (struct breakpoint *); 1652 1653 /* Return true if this breakpoint is pending, false if not. */ 1654 extern int pending_breakpoint_p (struct breakpoint *); 1655 1656 /* Attempt to determine architecture of location identified by SAL. */ 1657 extern struct gdbarch *get_sal_arch (struct symtab_and_line sal); 1658 1659 extern void breakpoint_free_objfile (struct objfile *objfile); 1660 1661 extern const char *ep_parse_optional_if_clause (const char **arg); 1662 1663 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" to 1664 UIOUT iff debugging multiple threads. */ 1665 extern void maybe_print_thread_hit_breakpoint (struct ui_out *uiout); 1666 1667 /* Print the specified breakpoint. */ 1668 extern void print_breakpoint (breakpoint *bp); 1669 1670 /* Command element for the 'commands' command. */ 1671 extern cmd_list_element *commands_cmd_element; 1672 1673 #endif /* !defined (BREAKPOINT_H) */ 1674