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