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