1 /* Data structures associated with breakpoints in GDB. 2 Copyright (C) 1992-2004, 2007-2012 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 "vec.h" 25 26 struct value; 27 struct block; 28 struct breakpoint_object; 29 struct get_number_or_range_state; 30 struct thread_info; 31 struct bpstats; 32 struct bp_location; 33 34 /* This is the maximum number of bytes a breakpoint instruction can 35 take. Feel free to increase it. It's just used in a few places to 36 size arrays that should be independent of the target 37 architecture. */ 38 39 #define BREAKPOINT_MAX 16 40 41 42 /* Type of breakpoint. */ 43 /* FIXME In the future, we should fold all other breakpoint-like 44 things into here. This includes: 45 46 * single-step (for machines where we have to simulate single 47 stepping) (probably, though perhaps it is better for it to look as 48 much as possible like a single-step to wait_for_inferior). */ 49 50 enum bptype 51 { 52 bp_none = 0, /* Eventpoint has been deleted */ 53 bp_breakpoint, /* Normal breakpoint */ 54 bp_hardware_breakpoint, /* Hardware assisted breakpoint */ 55 bp_until, /* used by until command */ 56 bp_finish, /* used by finish command */ 57 bp_watchpoint, /* Watchpoint */ 58 bp_hardware_watchpoint, /* Hardware assisted watchpoint */ 59 bp_read_watchpoint, /* read watchpoint, (hardware assisted) */ 60 bp_access_watchpoint, /* access watchpoint, (hardware assisted) */ 61 bp_longjmp, /* secret breakpoint to find longjmp() */ 62 bp_longjmp_resume, /* secret breakpoint to escape longjmp() */ 63 64 /* An internal breakpoint that is installed on the unwinder's 65 debug hook. */ 66 bp_exception, 67 /* An internal breakpoint that is set at the point where an 68 exception will land. */ 69 bp_exception_resume, 70 71 /* Used by wait_for_inferior for stepping over subroutine calls, 72 and for skipping prologues. */ 73 bp_step_resume, 74 75 /* Used by wait_for_inferior for stepping over signal 76 handlers. */ 77 bp_hp_step_resume, 78 79 /* Used to detect when a watchpoint expression has gone out of 80 scope. These breakpoints are usually not visible to the user. 81 82 This breakpoint has some interesting properties: 83 84 1) There's always a 1:1 mapping between watchpoints 85 on local variables and watchpoint_scope breakpoints. 86 87 2) It automatically deletes itself and the watchpoint it's 88 associated with when hit. 89 90 3) It can never be disabled. */ 91 bp_watchpoint_scope, 92 93 /* The breakpoint at the end of a call dummy. */ 94 /* FIXME: What if the function we are calling longjmp()s out of 95 the call, or the user gets out with the "return" command? We 96 currently have no way of cleaning up the breakpoint in these 97 (obscure) situations. (Probably can solve this by noticing 98 longjmp, "return", etc., it's similar to noticing when a 99 watchpoint on a local variable goes out of scope (with hardware 100 support for watchpoints)). */ 101 bp_call_dummy, 102 103 /* A breakpoint set on std::terminate, that is used to catch 104 otherwise uncaught exceptions thrown during an inferior call. */ 105 bp_std_terminate, 106 107 /* Some dynamic linkers (HP, maybe Solaris) can arrange for special 108 code in the inferior to run when significant events occur in the 109 dynamic linker (for example a library is loaded or unloaded). 110 111 By placing a breakpoint in this magic code GDB will get control 112 when these significant events occur. GDB can then re-examine 113 the dynamic linker's data structures to discover any newly loaded 114 dynamic libraries. */ 115 bp_shlib_event, 116 117 /* Some multi-threaded systems can arrange for a location in the 118 inferior to be executed when certain thread-related events occur 119 (such as thread creation or thread death). 120 121 By placing a breakpoint at one of these locations, GDB will get 122 control when these events occur. GDB can then update its thread 123 lists etc. */ 124 125 bp_thread_event, 126 127 /* On the same principal, an overlay manager can arrange to call a 128 magic location in the inferior whenever there is an interesting 129 change in overlay status. GDB can update its overlay tables 130 and fiddle with breakpoints in overlays when this breakpoint 131 is hit. */ 132 133 bp_overlay_event, 134 135 /* Master copies of longjmp breakpoints. These are always installed 136 as soon as an objfile containing longjmp is loaded, but they are 137 always disabled. While necessary, temporary clones of bp_longjmp 138 type will be created and enabled. */ 139 140 bp_longjmp_master, 141 142 /* Master copies of std::terminate breakpoints. */ 143 bp_std_terminate_master, 144 145 /* Like bp_longjmp_master, but for exceptions. */ 146 bp_exception_master, 147 148 bp_catchpoint, 149 150 bp_tracepoint, 151 bp_fast_tracepoint, 152 bp_static_tracepoint, 153 154 /* Event for JIT compiled code generation or deletion. */ 155 bp_jit_event, 156 157 /* Breakpoint is placed at the STT_GNU_IFUNC resolver. When hit GDB 158 inserts new bp_gnu_ifunc_resolver_return at the caller. 159 bp_gnu_ifunc_resolver is still being kept here as a different thread 160 may still hit it before bp_gnu_ifunc_resolver_return is hit by the 161 original thread. */ 162 bp_gnu_ifunc_resolver, 163 164 /* On its hit GDB now know the resolved address of the target 165 STT_GNU_IFUNC function. Associated bp_gnu_ifunc_resolver can be 166 deleted now and the breakpoint moved to the target function entry 167 point. */ 168 bp_gnu_ifunc_resolver_return, 169 }; 170 171 /* States of enablement of breakpoint. */ 172 173 enum enable_state 174 { 175 bp_disabled, /* The eventpoint is inactive, and cannot 176 trigger. */ 177 bp_enabled, /* The eventpoint is active, and can 178 trigger. */ 179 bp_call_disabled, /* The eventpoint has been disabled while a 180 call into the inferior is "in flight", 181 because some eventpoints interfere with 182 the implementation of a call on some 183 targets. The eventpoint will be 184 automatically enabled and reset when the 185 call "lands" (either completes, or stops 186 at another eventpoint). */ 187 bp_permanent /* There is a breakpoint instruction 188 hard-wired into the target's code. Don't 189 try to write another breakpoint 190 instruction on top of it, or restore its 191 value. Step over it using the 192 architecture's SKIP_INSN macro. */ 193 }; 194 195 196 /* Disposition of breakpoint. Ie: what to do after hitting it. */ 197 198 enum bpdisp 199 { 200 disp_del, /* Delete it */ 201 disp_del_at_next_stop, /* Delete at next stop, 202 whether hit or not */ 203 disp_disable, /* Disable it */ 204 disp_donttouch /* Leave it alone */ 205 }; 206 207 enum target_hw_bp_type 208 { 209 hw_write = 0, /* Common HW watchpoint */ 210 hw_read = 1, /* Read HW watchpoint */ 211 hw_access = 2, /* Access HW watchpoint */ 212 hw_execute = 3 /* Execute HW breakpoint */ 213 }; 214 215 216 /* Information used by targets to insert and remove breakpoints. */ 217 218 struct bp_target_info 219 { 220 /* Address space at which the breakpoint was placed. */ 221 struct address_space *placed_address_space; 222 223 /* Address at which the breakpoint was placed. This is normally the 224 same as ADDRESS from the bp_location, except when adjustment 225 happens in gdbarch_breakpoint_from_pc. The most common form of 226 adjustment is stripping an alternate ISA marker from the PC which 227 is used to determine the type of breakpoint to insert. */ 228 CORE_ADDR placed_address; 229 230 /* If this is a ranged breakpoint, then this field contains the 231 length of the range that will be watched for execution. */ 232 int length; 233 234 /* If the breakpoint lives in memory and reading that memory would 235 give back the breakpoint, instead of the original contents, then 236 the original contents are cached here. Only SHADOW_LEN bytes of 237 this buffer are valid, and only when the breakpoint is inserted. */ 238 gdb_byte shadow_contents[BREAKPOINT_MAX]; 239 240 /* The length of the data cached in SHADOW_CONTENTS. */ 241 int shadow_len; 242 243 /* The size of the placed breakpoint, according to 244 gdbarch_breakpoint_from_pc, when the breakpoint was inserted. 245 This is generally the same as SHADOW_LEN, unless we did not need 246 to read from the target to implement the memory breakpoint 247 (e.g. if a remote stub handled the details). We may still need 248 the size to remove the breakpoint safely. */ 249 int placed_size; 250 }; 251 252 /* GDB maintains two types of information about each breakpoint (or 253 watchpoint, or other related event). The first type corresponds 254 to struct breakpoint; this is a relatively high-level structure 255 which contains the source location(s), stopping conditions, user 256 commands to execute when the breakpoint is hit, and so forth. 257 258 The second type of information corresponds to struct bp_location. 259 Each breakpoint has one or (eventually) more locations associated 260 with it, which represent target-specific and machine-specific 261 mechanisms for stopping the program. For instance, a watchpoint 262 expression may require multiple hardware watchpoints in order to 263 catch all changes in the value of the expression being watched. */ 264 265 enum bp_loc_type 266 { 267 bp_loc_software_breakpoint, 268 bp_loc_hardware_breakpoint, 269 bp_loc_hardware_watchpoint, 270 bp_loc_other /* Miscellaneous... */ 271 }; 272 273 /* This structure is a collection of function pointers that, if 274 available, will be called instead of performing the default action 275 for this bp_loc_type. */ 276 277 struct bp_location_ops 278 { 279 /* Destructor. Releases everything from SELF (but not SELF 280 itself). */ 281 void (*dtor) (struct bp_location *self); 282 }; 283 284 struct bp_location 285 { 286 /* Chain pointer to the next breakpoint location for 287 the same parent breakpoint. */ 288 struct bp_location *next; 289 290 /* Methods associated with this location. */ 291 const struct bp_location_ops *ops; 292 293 /* The reference count. */ 294 int refc; 295 296 /* Type of this breakpoint location. */ 297 enum bp_loc_type loc_type; 298 299 /* Each breakpoint location must belong to exactly one higher-level 300 breakpoint. This pointer is NULL iff this bp_location is no 301 longer attached to a breakpoint. For example, when a breakpoint 302 is deleted, its locations may still be found in the 303 moribund_locations list, or if we had stopped for it, in 304 bpstats. */ 305 struct breakpoint *owner; 306 307 /* Conditional. Break only if this expression's value is nonzero. 308 Unlike string form of condition, which is associated with 309 breakpoint, this is associated with location, since if breakpoint 310 has several locations, the evaluation of expression can be 311 different for different locations. Only valid for real 312 breakpoints; a watchpoint's conditional expression is stored in 313 the owner breakpoint object. */ 314 struct expression *cond; 315 316 /* This location's address is in an unloaded solib, and so this 317 location should not be inserted. It will be automatically 318 enabled when that solib is loaded. */ 319 char shlib_disabled; 320 321 /* Is this particular location enabled. */ 322 char enabled; 323 324 /* Nonzero if this breakpoint is now inserted. */ 325 char inserted; 326 327 /* Nonzero if this is not the first breakpoint in the list 328 for the given address. location of tracepoint can _never_ 329 be duplicated with other locations of tracepoints and other 330 kinds of breakpoints, because two locations at the same 331 address may have different actions, so both of these locations 332 should be downloaded and so that `tfind N' always works. */ 333 char duplicate; 334 335 /* If we someday support real thread-specific breakpoints, then 336 the breakpoint location will need a thread identifier. */ 337 338 /* Data for specific breakpoint types. These could be a union, but 339 simplicity is more important than memory usage for breakpoints. */ 340 341 /* Architecture associated with this location's address. May be 342 different from the breakpoint architecture. */ 343 struct gdbarch *gdbarch; 344 345 /* The program space associated with this breakpoint location 346 address. Note that an address space may be represented in more 347 than one program space (e.g. each uClinux program will be given 348 its own program space, but there will only be one address space 349 for all of them), but we must not insert more than one location 350 at the same address in the same address space. */ 351 struct program_space *pspace; 352 353 /* Note that zero is a perfectly valid code address on some platforms 354 (for example, the mn10200 (OBSOLETE) and mn10300 simulators). NULL 355 is not a special value for this field. Valid for all types except 356 bp_loc_other. */ 357 CORE_ADDR address; 358 359 /* For hardware watchpoints, the size of the memory region being 360 watched. For hardware ranged breakpoints, the size of the 361 breakpoint range. */ 362 int length; 363 364 /* Type of hardware watchpoint. */ 365 enum target_hw_bp_type watchpoint_type; 366 367 /* For any breakpoint type with an address, this is the section 368 associated with the address. Used primarily for overlay 369 debugging. */ 370 struct obj_section *section; 371 372 /* Address at which breakpoint was requested, either by the user or 373 by GDB for internal breakpoints. This will usually be the same 374 as ``address'' (above) except for cases in which 375 ADJUST_BREAKPOINT_ADDRESS has computed a different address at 376 which to place the breakpoint in order to comply with a 377 processor's architectual constraints. */ 378 CORE_ADDR requested_address; 379 380 char *function_name; 381 382 /* Details of the placed breakpoint, when inserted. */ 383 struct bp_target_info target_info; 384 385 /* Similarly, for the breakpoint at an overlay's LMA, if necessary. */ 386 struct bp_target_info overlay_target_info; 387 388 /* In a non-stop mode, it's possible that we delete a breakpoint, 389 but as we do that, some still running thread hits that breakpoint. 390 For that reason, we need to keep locations belonging to deleted 391 breakpoints for a bit, so that don't report unexpected SIGTRAP. 392 We can't keep such locations forever, so we use a heuristic -- 393 after we process certain number of inferior events since 394 breakpoint was deleted, we retire all locations of that breakpoint. 395 This variable keeps a number of events still to go, when 396 it becomes 0 this location is retired. */ 397 int events_till_retirement; 398 399 /* Line number of this address. */ 400 401 int line_number; 402 403 /* Source file name of this address. */ 404 405 char *source_file; 406 }; 407 408 /* This structure is a collection of function pointers that, if available, 409 will be called instead of the performing the default action for this 410 bptype. */ 411 412 struct breakpoint_ops 413 { 414 /* Destructor. Releases everything from SELF (but not SELF 415 itself). */ 416 void (*dtor) (struct breakpoint *self); 417 418 /* Allocate a location for this breakpoint. */ 419 struct bp_location * (*allocate_location) (struct breakpoint *); 420 421 /* Reevaluate a breakpoint. This is necessary after symbols change 422 (e.g., an executable or DSO was loaded, or the inferior just 423 started). */ 424 void (*re_set) (struct breakpoint *self); 425 426 /* Insert the breakpoint or watchpoint or activate the catchpoint. 427 Return 0 for success, 1 if the breakpoint, watchpoint or 428 catchpoint type is not supported, -1 for failure. */ 429 int (*insert_location) (struct bp_location *); 430 431 /* Remove the breakpoint/catchpoint that was previously inserted 432 with the "insert" method above. Return 0 for success, 1 if the 433 breakpoint, watchpoint or catchpoint type is not supported, 434 -1 for failure. */ 435 int (*remove_location) (struct bp_location *); 436 437 /* Return true if it the target has stopped due to hitting 438 breakpoint location BL. This function does not check if we 439 should stop, only if BL explains the stop. */ 440 int (*breakpoint_hit) (const struct bp_location *bl, struct address_space *, 441 CORE_ADDR); 442 443 /* Check internal conditions of the breakpoint referred to by BS. 444 If we should not stop for this breakpoint, set BS->stop to 0. */ 445 void (*check_status) (struct bpstats *bs); 446 447 /* Tell how many hardware resources (debug registers) are needed 448 for this breakpoint. If this function is not provided, then 449 the breakpoint or watchpoint needs one debug register. */ 450 int (*resources_needed) (const struct bp_location *); 451 452 /* Tell whether we can downgrade from a hardware watchpoint to a software 453 one. If not, the user will not be able to enable the watchpoint when 454 there are not enough hardware resources available. */ 455 int (*works_in_software_mode) (const struct breakpoint *); 456 457 /* The normal print routine for this breakpoint, called when we 458 hit it. */ 459 enum print_stop_action (*print_it) (struct bpstats *bs); 460 461 /* Display information about this breakpoint, for "info 462 breakpoints". */ 463 void (*print_one) (struct breakpoint *, struct bp_location **); 464 465 /* Display extra information about this breakpoint, below the normal 466 breakpoint description in "info breakpoints". 467 468 In the example below, the "address range" line was printed 469 by print_one_detail_ranged_breakpoint. 470 471 (gdb) info breakpoints 472 Num Type Disp Enb Address What 473 2 hw breakpoint keep y in main at test-watch.c:70 474 address range: [0x10000458, 0x100004c7] 475 476 */ 477 void (*print_one_detail) (const struct breakpoint *, struct ui_out *); 478 479 /* Display information about this breakpoint after setting it 480 (roughly speaking; this is called from "mention"). */ 481 void (*print_mention) (struct breakpoint *); 482 483 /* Print to FP the CLI command that recreates this breakpoint. */ 484 void (*print_recreate) (struct breakpoint *, struct ui_file *fp); 485 }; 486 487 /* Helper for breakpoint_ops->print_recreate implementations. Prints 488 the "thread" or "task" condition of B, and then a newline. 489 490 Necessary because most breakpoint implementations accept 491 thread/task conditions at the end of the spec line, like "break foo 492 thread 1", which needs outputting before any breakpoint-type 493 specific extra command necessary for B's recreation. */ 494 extern void print_recreate_thread (struct breakpoint *b, struct ui_file *fp); 495 496 enum watchpoint_triggered 497 { 498 /* This watchpoint definitely did not trigger. */ 499 watch_triggered_no = 0, 500 501 /* Some hardware watchpoint triggered, and it might have been this 502 one, but we do not know which it was. */ 503 watch_triggered_unknown, 504 505 /* This hardware watchpoint definitely did trigger. */ 506 watch_triggered_yes 507 }; 508 509 /* This is used to declare the VEC syscalls_to_be_caught. */ 510 DEF_VEC_I(int); 511 512 typedef struct bp_location *bp_location_p; 513 DEF_VEC_P(bp_location_p); 514 515 /* A reference-counted struct command_line. This lets multiple 516 breakpoints share a single command list. This is an implementation 517 detail to the breakpoints module. */ 518 struct counted_command_line; 519 520 /* Some targets (e.g., embedded PowerPC) need two debug registers to set 521 a watchpoint over a memory region. If this flag is true, GDB will use 522 only one register per watchpoint, thus assuming that all acesses that 523 modify a memory location happen at its starting address. */ 524 525 extern int target_exact_watchpoints; 526 527 /* Note that the ->silent field is not currently used by any commands 528 (though the code is in there if it was to be, and set_raw_breakpoint 529 does set it to 0). I implemented it because I thought it would be 530 useful for a hack I had to put in; I'm going to leave it in because 531 I can see how there might be times when it would indeed be useful */ 532 533 /* This is for all kinds of breakpoints. */ 534 535 struct breakpoint 536 { 537 /* Methods associated with this breakpoint. */ 538 const struct breakpoint_ops *ops; 539 540 struct breakpoint *next; 541 /* Type of breakpoint. */ 542 enum bptype type; 543 /* Zero means disabled; remember the info but don't break here. */ 544 enum enable_state enable_state; 545 /* What to do with this breakpoint after we hit it. */ 546 enum bpdisp disposition; 547 /* Number assigned to distinguish breakpoints. */ 548 int number; 549 550 /* Location(s) associated with this high-level breakpoint. */ 551 struct bp_location *loc; 552 553 /* Non-zero means a silent breakpoint (don't print frame info 554 if we stop here). */ 555 unsigned char silent; 556 /* Non-zero means display ADDR_STRING to the user verbatim. */ 557 unsigned char display_canonical; 558 /* Number of stops at this breakpoint that should 559 be continued automatically before really stopping. */ 560 int ignore_count; 561 /* Chain of command lines to execute when this breakpoint is 562 hit. */ 563 struct counted_command_line *commands; 564 /* Stack depth (address of frame). If nonzero, break only if fp 565 equals this. */ 566 struct frame_id frame_id; 567 568 /* The program space used to set the breakpoint. This is only set 569 for breakpoints which are specific to a program space; for 570 non-thread-specific ordinary breakpoints this is NULL. */ 571 struct program_space *pspace; 572 573 /* String we used to set the breakpoint (malloc'd). */ 574 char *addr_string; 575 576 /* The filter that should be passed to decode_line_full when 577 re-setting this breakpoint. This may be NULL, but otherwise is 578 allocated with xmalloc. */ 579 char *filter; 580 581 /* For a ranged breakpoint, the string we used to find 582 the end of the range (malloc'd). */ 583 char *addr_string_range_end; 584 585 /* Architecture we used to set the breakpoint. */ 586 struct gdbarch *gdbarch; 587 /* Language we used to set the breakpoint. */ 588 enum language language; 589 /* Input radix we used to set the breakpoint. */ 590 int input_radix; 591 /* String form of the breakpoint condition (malloc'd), or NULL if 592 there is no condition. */ 593 char *cond_string; 594 /* String form of exp to use for displaying to the user 595 (malloc'd), or NULL if none. */ 596 597 /* Holds the address of the related watchpoint_scope breakpoint 598 when using watchpoints on local variables (might the concept of 599 a related breakpoint be useful elsewhere, if not just call it 600 the watchpoint_scope breakpoint or something like that. 601 FIXME). */ 602 struct breakpoint *related_breakpoint; 603 604 /* Thread number for thread-specific breakpoint, 605 or -1 if don't care. */ 606 int thread; 607 608 /* Ada task number for task-specific breakpoint, 609 or 0 if don't care. */ 610 int task; 611 612 /* Count of the number of times this breakpoint was taken, dumped 613 with the info, but not used for anything else. Useful for 614 seeing how many times you hit a break prior to the program 615 aborting, so you can back up to just before the abort. */ 616 int hit_count; 617 618 /* Is breakpoint's condition not yet parsed because we found 619 no location initially so had no context to parse 620 the condition in. */ 621 int condition_not_parsed; 622 623 /* With a Python scripting enabled GDB, store a reference to the 624 Python object that has been associated with this breakpoint. 625 This is always NULL for a GDB that is not script enabled. It 626 can sometimes be NULL for enabled GDBs as not all breakpoint 627 types are tracked by the Python scripting API. */ 628 struct breakpoint_object *py_bp_object; 629 }; 630 631 /* An instance of this type is used to represent a watchpoint. It 632 includes a "struct breakpoint" as a kind of base class; users 633 downcast to "struct breakpoint *" when needed. */ 634 635 struct watchpoint 636 { 637 /* The base class. */ 638 struct breakpoint base; 639 640 /* String form of exp to use for displaying to the user (malloc'd), 641 or NULL if none. */ 642 char *exp_string; 643 /* String form to use for reparsing of EXP (malloc'd) or NULL. */ 644 char *exp_string_reparse; 645 646 /* The expression we are watching, or NULL if not a watchpoint. */ 647 struct expression *exp; 648 /* The largest block within which it is valid, or NULL if it is 649 valid anywhere (e.g. consists just of global symbols). */ 650 struct block *exp_valid_block; 651 /* The conditional expression if any. */ 652 struct expression *cond_exp; 653 /* The largest block within which it is valid, or NULL if it is 654 valid anywhere (e.g. consists just of global symbols). */ 655 struct block *cond_exp_valid_block; 656 /* Value of the watchpoint the last time we checked it, or NULL when 657 we do not know the value yet or the value was not readable. VAL 658 is never lazy. */ 659 struct value *val; 660 /* Nonzero if VAL is valid. If VAL_VALID is set but VAL is NULL, 661 then an error occurred reading the value. */ 662 int val_valid; 663 664 /* Holds the frame address which identifies the frame this 665 watchpoint should be evaluated in, or `null' if the watchpoint 666 should be evaluated on the outermost frame. */ 667 struct frame_id watchpoint_frame; 668 669 /* Holds the thread which identifies the frame this watchpoint 670 should be considered in scope for, or `null_ptid' if the 671 watchpoint should be evaluated in all threads. */ 672 ptid_t watchpoint_thread; 673 674 /* For hardware watchpoints, the triggered status according to the 675 hardware. */ 676 enum watchpoint_triggered watchpoint_triggered; 677 678 /* Whether this watchpoint is exact (see 679 target_exact_watchpoints). */ 680 int exact; 681 682 /* The mask address for a masked hardware watchpoint. */ 683 CORE_ADDR hw_wp_mask; 684 }; 685 686 /* Returns true if BPT is really a watchpoint. */ 687 688 extern int is_watchpoint (const struct breakpoint *bpt); 689 690 /* An instance of this type is used to represent all kinds of 691 tracepoints. It includes a "struct breakpoint" as a kind of base 692 class; users downcast to "struct breakpoint *" when needed. */ 693 694 struct tracepoint 695 { 696 /* The base class. */ 697 struct breakpoint base; 698 699 /* Number of times this tracepoint should single-step and collect 700 additional data. */ 701 long step_count; 702 703 /* Number of times this tracepoint should be hit before 704 disabling/ending. */ 705 int pass_count; 706 707 /* The number of the tracepoint on the target. */ 708 int number_on_target; 709 710 /* The total space taken by all the trace frames for this 711 tracepoint. */ 712 ULONGEST traceframe_usage; 713 714 /* The static tracepoint marker id, if known. */ 715 char *static_trace_marker_id; 716 717 /* LTTng/UST allow more than one marker with the same ID string, 718 although it unadvised because it confuses tools. When setting 719 static tracepoints by marker ID, this will record the index in 720 the array of markers we found for the given marker ID for which 721 this static tracepoint corresponds. When resetting breakpoints, 722 we will use this index to try to find the same marker again. */ 723 int static_trace_marker_id_idx; 724 }; 725 726 typedef struct breakpoint *breakpoint_p; 727 DEF_VEC_P(breakpoint_p); 728 729 /* The following stuff is an abstract data type "bpstat" ("breakpoint 730 status"). This provides the ability to determine whether we have 731 stopped at a breakpoint, and what we should do about it. */ 732 733 typedef struct bpstats *bpstat; 734 735 /* Clears a chain of bpstat, freeing storage 736 of each. */ 737 extern void bpstat_clear (bpstat *); 738 739 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that 740 is part of the bpstat is copied as well. */ 741 extern bpstat bpstat_copy (bpstat); 742 743 extern bpstat bpstat_stop_status (struct address_space *aspace, 744 CORE_ADDR pc, ptid_t ptid); 745 746 /* This bpstat_what stuff tells wait_for_inferior what to do with a 747 breakpoint (a challenging task). 748 749 The enum values order defines priority-like order of the actions. 750 Once you've decided that some action is appropriate, you'll never 751 go back and decide something of a lower priority is better. Each 752 of these actions is mutually exclusive with the others. That 753 means, that if you find yourself adding a new action class here and 754 wanting to tell GDB that you have two simultaneous actions to 755 handle, something is wrong, and you probably don't actually need a 756 new action type. 757 758 Note that a step resume breakpoint overrides another breakpoint of 759 signal handling (see comment in wait_for_inferior at where we set 760 the step_resume breakpoint). */ 761 762 enum bpstat_what_main_action 763 { 764 /* Perform various other tests; that is, this bpstat does not 765 say to perform any action (e.g. failed watchpoint and nothing 766 else). */ 767 BPSTAT_WHAT_KEEP_CHECKING, 768 769 /* Remove breakpoints, single step once, then put them back in and 770 go back to what we were doing. It's possible that this should 771 be removed from the main_action and put into a separate field, 772 to more cleanly handle 773 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE. */ 774 BPSTAT_WHAT_SINGLE, 775 776 /* Set longjmp_resume breakpoint, remove all other breakpoints, 777 and continue. The "remove all other breakpoints" part is 778 required if we are also stepping over another breakpoint as 779 well as doing the longjmp handling. */ 780 BPSTAT_WHAT_SET_LONGJMP_RESUME, 781 782 /* Clear longjmp_resume breakpoint, then handle as 783 BPSTAT_WHAT_KEEP_CHECKING. */ 784 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME, 785 786 /* Clear step resume breakpoint, and keep checking. */ 787 BPSTAT_WHAT_STEP_RESUME, 788 789 /* Rather than distinguish between noisy and silent stops here, it 790 might be cleaner to have bpstat_print make that decision (also 791 taking into account stop_print_frame and source_only). But the 792 implications are a bit scary (interaction with auto-displays, 793 etc.), so I won't try it. */ 794 795 /* Stop silently. */ 796 BPSTAT_WHAT_STOP_SILENT, 797 798 /* Stop and print. */ 799 BPSTAT_WHAT_STOP_NOISY, 800 801 /* Clear step resume breakpoint, and keep checking. High-priority 802 step-resume breakpoints are used when even if there's a user 803 breakpoint at the current PC when we set the step-resume 804 breakpoint, we don't want to re-handle any breakpoint other 805 than the step-resume when it's hit; instead we want to move 806 past the breakpoint. This is used in the case of skipping 807 signal handlers. */ 808 BPSTAT_WHAT_HP_STEP_RESUME, 809 }; 810 811 /* An enum indicating the kind of "stack dummy" stop. This is a bit 812 of a misnomer because only one kind of truly a stack dummy. */ 813 enum stop_stack_kind 814 { 815 /* We didn't stop at a stack dummy breakpoint. */ 816 STOP_NONE = 0, 817 818 /* Stopped at a stack dummy. */ 819 STOP_STACK_DUMMY, 820 821 /* Stopped at std::terminate. */ 822 STOP_STD_TERMINATE 823 }; 824 825 struct bpstat_what 826 { 827 enum bpstat_what_main_action main_action; 828 829 /* Did we hit a call dummy breakpoint? This only goes with a 830 main_action of BPSTAT_WHAT_STOP_SILENT or 831 BPSTAT_WHAT_STOP_NOISY (the concept of continuing from a call 832 dummy without popping the frame is not a useful one). */ 833 enum stop_stack_kind call_dummy; 834 835 /* Used for BPSTAT_WHAT_SET_LONGJMP_RESUME and 836 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME. True if we are handling a 837 longjmp, false if we are handling an exception. */ 838 int is_longjmp; 839 }; 840 841 /* The possible return values for print_bpstat, print_it_normal, 842 print_it_done, print_it_noop. */ 843 enum print_stop_action 844 { 845 /* We printed nothing or we need to do some more analysis. */ 846 PRINT_UNKNOWN = -1, 847 848 /* We printed something, and we *do* desire that something to be 849 followed by a location. */ 850 PRINT_SRC_AND_LOC, 851 852 /* We printed something, and we do *not* desire that something to 853 be followed by a location. */ 854 PRINT_SRC_ONLY, 855 856 /* We already printed all we needed to print, don't print anything 857 else. */ 858 PRINT_NOTHING 859 }; 860 861 /* Tell what to do about this bpstat. */ 862 struct bpstat_what bpstat_what (bpstat); 863 864 /* Find the bpstat associated with a breakpoint. NULL otherwise. */ 865 bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *); 866 867 /* Nonzero if a signal that we got in wait() was due to circumstances 868 explained by the BS. */ 869 /* Currently that is true if we have hit a breakpoint, or if there is 870 a watchpoint enabled. */ 871 #define bpstat_explains_signal(bs) ((bs) != NULL) 872 873 /* Nonzero is this bpstat causes a stop. */ 874 extern int bpstat_causes_stop (bpstat); 875 876 /* Nonzero if we should step constantly (e.g. watchpoints on machines 877 without hardware support). This isn't related to a specific bpstat, 878 just to things like whether watchpoints are set. */ 879 extern int bpstat_should_step (void); 880 881 /* Print a message indicating what happened. Returns nonzero to 882 say that only the source line should be printed after this (zero 883 return means print the frame as well as the source line). */ 884 extern enum print_stop_action bpstat_print (bpstat, int); 885 886 /* Put in *NUM the breakpoint number of the first breakpoint we are 887 stopped at. *BSP upon return is a bpstat which points to the 888 remaining breakpoints stopped at (but which is not guaranteed to be 889 good for anything but further calls to bpstat_num). 890 891 Return 0 if passed a bpstat which does not indicate any breakpoints. 892 Return -1 if stopped at a breakpoint that has been deleted since 893 we set it. 894 Return 1 otherwise. */ 895 extern int bpstat_num (bpstat *, int *); 896 897 /* Perform actions associated with the stopped inferior. Actually, we 898 just use this for breakpoint commands. Perhaps other actions will 899 go here later, but this is executed at a late time (from the 900 command loop). */ 901 extern void bpstat_do_actions (void); 902 903 /* Modify all entries of STOP_BPSTAT of INFERIOR_PTID so that the actions will 904 not be performed. */ 905 extern void bpstat_clear_actions (void); 906 907 /* Implementation: */ 908 909 /* Values used to tell the printing routine how to behave for this 910 bpstat. */ 911 enum bp_print_how 912 { 913 /* This is used when we want to do a normal printing of the reason 914 for stopping. The output will depend on the type of eventpoint 915 we are dealing with. This is the default value, most commonly 916 used. */ 917 print_it_normal, 918 /* This is used when nothing should be printed for this bpstat 919 entry. */ 920 print_it_noop, 921 /* This is used when everything which needs to be printed has 922 already been printed. But we still want to print the frame. */ 923 print_it_done 924 }; 925 926 struct bpstats 927 { 928 /* Linked list because there can be more than one breakpoint at 929 the same place, and a bpstat reflects the fact that all have 930 been hit. */ 931 bpstat next; 932 933 /* Location that caused the stop. Locations are refcounted, so 934 this will never be NULL. Note that this location may end up 935 detached from a breakpoint, but that does not necessary mean 936 that the struct breakpoint is gone. E.g., consider a 937 watchpoint with a condition that involves an inferior function 938 call. Watchpoint locations are recreated often (on resumes, 939 hence on infcalls too). Between creating the bpstat and after 940 evaluating the watchpoint condition, this location may hence 941 end up detached from its original owner watchpoint, even though 942 the watchpoint is still listed. If it's condition evaluates as 943 true, we still want this location to cause a stop, and we will 944 still need to know which watchpoint it was originally attached. 945 What this means is that we should not (in most cases) follow 946 the `bpstat->bp_location->owner' link, but instead use the 947 `breakpoint_at' field below. */ 948 struct bp_location *bp_location_at; 949 950 /* Breakpoint that caused the stop. This is nullified if the 951 breakpoint ends up being deleted. See comments on 952 `bp_location_at' above for why do we need this field instead of 953 following the location's owner. */ 954 struct breakpoint *breakpoint_at; 955 956 /* The associated command list. */ 957 struct counted_command_line *commands; 958 959 /* Old value associated with a watchpoint. */ 960 struct value *old_val; 961 962 /* Nonzero if this breakpoint tells us to print the frame. */ 963 char print; 964 965 /* Nonzero if this breakpoint tells us to stop. */ 966 char stop; 967 968 /* Tell bpstat_print and print_bp_stop_message how to print stuff 969 associated with this element of the bpstat chain. */ 970 enum bp_print_how print_it; 971 }; 972 973 enum inf_context 974 { 975 inf_starting, 976 inf_running, 977 inf_exited, 978 inf_execd 979 }; 980 981 /* The possible return values for breakpoint_here_p. 982 We guarantee that zero always means "no breakpoint here". */ 983 enum breakpoint_here 984 { 985 no_breakpoint_here = 0, 986 ordinary_breakpoint_here, 987 permanent_breakpoint_here 988 }; 989 990 991 /* Prototypes for breakpoint-related functions. */ 992 993 extern enum breakpoint_here breakpoint_here_p (struct address_space *, 994 CORE_ADDR); 995 996 extern int moribund_breakpoint_here_p (struct address_space *, CORE_ADDR); 997 998 extern int breakpoint_inserted_here_p (struct address_space *, CORE_ADDR); 999 1000 extern int regular_breakpoint_inserted_here_p (struct address_space *, 1001 CORE_ADDR); 1002 1003 extern int software_breakpoint_inserted_here_p (struct address_space *, 1004 CORE_ADDR); 1005 1006 /* Returns true if there's a hardware watchpoint or access watchpoint 1007 inserted in the range defined by ADDR and LEN. */ 1008 extern int hardware_watchpoint_inserted_in_range (struct address_space *, 1009 CORE_ADDR addr, 1010 ULONGEST len); 1011 1012 extern int breakpoint_thread_match (struct address_space *, 1013 CORE_ADDR, ptid_t); 1014 1015 extern void until_break_command (char *, int, int); 1016 1017 /* Initialize a struct bp_location. */ 1018 1019 extern void init_bp_location (struct bp_location *loc, 1020 const struct bp_location_ops *ops, 1021 struct breakpoint *owner); 1022 1023 extern void update_breakpoint_locations (struct breakpoint *b, 1024 struct symtabs_and_lines sals, 1025 struct symtabs_and_lines sals_end); 1026 1027 extern void breakpoint_re_set (void); 1028 1029 extern void breakpoint_re_set_thread (struct breakpoint *); 1030 1031 extern struct breakpoint *set_momentary_breakpoint 1032 (struct gdbarch *, struct symtab_and_line, struct frame_id, enum bptype); 1033 1034 extern struct breakpoint *set_momentary_breakpoint_at_pc 1035 (struct gdbarch *, CORE_ADDR pc, enum bptype type); 1036 1037 extern struct breakpoint *clone_momentary_breakpoint (struct breakpoint *bpkt); 1038 1039 extern void set_ignore_count (int, int, int); 1040 1041 extern void breakpoint_init_inferior (enum inf_context); 1042 1043 extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *); 1044 1045 extern void delete_breakpoint (struct breakpoint *); 1046 1047 extern void breakpoint_auto_delete (bpstat); 1048 1049 /* Return the chain of command lines to execute when this breakpoint 1050 is hit. */ 1051 extern struct command_line *breakpoint_commands (struct breakpoint *b); 1052 1053 /* Return a string image of DISP. The string is static, and thus should 1054 NOT be deallocated after use. */ 1055 const char *bpdisp_text (enum bpdisp disp); 1056 1057 extern void break_command (char *, int); 1058 1059 extern void hbreak_command_wrapper (char *, int); 1060 extern void thbreak_command_wrapper (char *, int); 1061 extern void rbreak_command_wrapper (char *, int); 1062 extern void watch_command_wrapper (char *, int, int); 1063 extern void awatch_command_wrapper (char *, int, int); 1064 extern void rwatch_command_wrapper (char *, int, int); 1065 extern void tbreak_command (char *, int); 1066 1067 extern struct breakpoint_ops bkpt_breakpoint_ops; 1068 1069 extern void initialize_breakpoint_ops (void); 1070 1071 /* Arguments to pass as context to some catch command handlers. */ 1072 #define CATCH_PERMANENT ((void *) (uintptr_t) 0) 1073 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1) 1074 1075 /* Like add_cmd, but add the command to both the "catch" and "tcatch" 1076 lists, and pass some additional user data to the command 1077 function. */ 1078 1079 extern void 1080 add_catch_command (char *name, char *docstring, 1081 void (*sfunc) (char *args, int from_tty, 1082 struct cmd_list_element *command), 1083 char **(*completer) (struct cmd_list_element *cmd, 1084 char *text, char *word), 1085 void *user_data_catch, 1086 void *user_data_tcatch); 1087 1088 /* Initialize a breakpoint struct for Ada exception catchpoints. */ 1089 1090 extern void 1091 init_ada_exception_breakpoint (struct breakpoint *b, 1092 struct gdbarch *gdbarch, 1093 struct symtab_and_line sal, 1094 char *addr_string, 1095 const struct breakpoint_ops *ops, 1096 int tempflag, 1097 int from_tty); 1098 1099 /* Add breakpoint B on the breakpoint list, and notify the user, the 1100 target and breakpoint_created observers of its existence. If 1101 INTERNAL is non-zero, the breakpoint number will be allocated from 1102 the internal breakpoint count. If UPDATE_GLL is non-zero, 1103 update_global_location_list will be called. */ 1104 1105 extern void install_breakpoint (int internal, struct breakpoint *b, 1106 int update_gll); 1107 1108 /* Flags that can be passed down to create_breakpoint, etc., to affect 1109 breakpoint creation in several ways. */ 1110 1111 enum breakpoint_create_flags 1112 { 1113 /* We're adding a breakpoint to our tables that is already 1114 inserted in the target. */ 1115 CREATE_BREAKPOINT_FLAGS_INSERTED = 1 << 0 1116 }; 1117 1118 extern int create_breakpoint (struct gdbarch *gdbarch, char *arg, 1119 char *cond_string, int thread, 1120 int parse_condition_and_thread, 1121 int tempflag, enum bptype wanted_type, 1122 int ignore_count, 1123 enum auto_boolean pending_break_support, 1124 const struct breakpoint_ops *ops, 1125 int from_tty, 1126 int enabled, 1127 int internal, unsigned flags); 1128 1129 extern void insert_breakpoints (void); 1130 1131 extern int remove_breakpoints (void); 1132 1133 extern int remove_breakpoints_pid (int pid); 1134 1135 /* This function can be used to physically insert eventpoints from the 1136 specified traced inferior process, without modifying the breakpoint 1137 package's state. This can be useful for those targets which 1138 support following the processes of a fork() or vfork() system call, 1139 when both of the resulting two processes are to be followed. */ 1140 extern int reattach_breakpoints (int); 1141 1142 /* This function can be used to update the breakpoint package's state 1143 after an exec() system call has been executed. 1144 1145 This function causes the following: 1146 1147 - All eventpoints are marked "not inserted". 1148 - All eventpoints with a symbolic address are reset such that 1149 the symbolic address must be reevaluated before the eventpoints 1150 can be reinserted. 1151 - The solib breakpoints are explicitly removed from the breakpoint 1152 list. 1153 - A step-resume breakpoint, if any, is explicitly removed from the 1154 breakpoint list. 1155 - All eventpoints without a symbolic address are removed from the 1156 breakpoint list. */ 1157 extern void update_breakpoints_after_exec (void); 1158 1159 /* This function can be used to physically remove hardware breakpoints 1160 and watchpoints from the specified traced inferior process, without 1161 modifying the breakpoint package's state. This can be useful for 1162 those targets which support following the processes of a fork() or 1163 vfork() system call, when one of the resulting two processes is to 1164 be detached and allowed to run free. 1165 1166 It is an error to use this function on the process whose id is 1167 inferior_ptid. */ 1168 extern int detach_breakpoints (int); 1169 1170 /* This function is called when program space PSPACE is about to be 1171 deleted. It takes care of updating breakpoints to not reference 1172 this PSPACE anymore. */ 1173 extern void breakpoint_program_space_exit (struct program_space *pspace); 1174 1175 extern void set_longjmp_breakpoint (struct thread_info *tp, 1176 struct frame_id frame); 1177 extern void delete_longjmp_breakpoint (int thread); 1178 1179 extern void enable_overlay_breakpoints (void); 1180 extern void disable_overlay_breakpoints (void); 1181 1182 extern void set_std_terminate_breakpoint (void); 1183 extern void delete_std_terminate_breakpoint (void); 1184 1185 /* These functions respectively disable or reenable all currently 1186 enabled watchpoints. When disabled, the watchpoints are marked 1187 call_disabled. When re-enabled, they are marked enabled. 1188 1189 The intended client of these functions is call_function_by_hand. 1190 1191 The inferior must be stopped, and all breakpoints removed, when 1192 these functions are used. 1193 1194 The need for these functions is that on some targets (e.g., HP-UX), 1195 gdb is unable to unwind through the dummy frame that is pushed as 1196 part of the implementation of a call command. Watchpoints can 1197 cause the inferior to stop in places where this frame is visible, 1198 and that can cause execution control to become very confused. 1199 1200 Note that if a user sets breakpoints in an interactively called 1201 function, the call_disabled watchpoints will have been re-enabled 1202 when the first such breakpoint is reached. However, on targets 1203 that are unable to unwind through the call dummy frame, watches 1204 of stack-based storage may then be deleted, because gdb will 1205 believe that their watched storage is out of scope. (Sigh.) */ 1206 extern void disable_watchpoints_before_interactive_call_start (void); 1207 1208 extern void enable_watchpoints_after_interactive_call_stop (void); 1209 1210 /* These functions disable and re-enable all breakpoints during 1211 inferior startup. They are intended to be called from solib 1212 code where necessary. This is needed on platforms where the 1213 main executable is relocated at some point during startup 1214 processing, making breakpoint addresses invalid. 1215 1216 If additional breakpoints are created after the routine 1217 disable_breakpoints_before_startup but before the routine 1218 enable_breakpoints_after_startup was called, they will also 1219 be marked as disabled. */ 1220 extern void disable_breakpoints_before_startup (void); 1221 extern void enable_breakpoints_after_startup (void); 1222 1223 /* For script interpreters that need to define breakpoint commands 1224 after they've already read the commands into a struct 1225 command_line. */ 1226 extern enum command_control_type commands_from_control_command 1227 (char *arg, struct command_line *cmd); 1228 1229 extern void clear_breakpoint_hit_counts (void); 1230 1231 extern struct breakpoint *get_breakpoint (int num); 1232 1233 /* The following are for displays, which aren't really breakpoints, 1234 but here is as good a place as any for them. */ 1235 1236 extern void disable_current_display (void); 1237 1238 extern void do_displays (void); 1239 1240 extern void disable_display (int); 1241 1242 extern void clear_displays (void); 1243 1244 extern void disable_breakpoint (struct breakpoint *); 1245 1246 extern void enable_breakpoint (struct breakpoint *); 1247 1248 extern void breakpoint_set_commands (struct breakpoint *b, 1249 struct command_line *commands); 1250 1251 extern void breakpoint_set_silent (struct breakpoint *b, int silent); 1252 1253 extern void breakpoint_set_thread (struct breakpoint *b, int thread); 1254 1255 extern void breakpoint_set_task (struct breakpoint *b, int task); 1256 1257 /* Clear the "inserted" flag in all breakpoints. */ 1258 extern void mark_breakpoints_out (void); 1259 1260 extern void make_breakpoint_permanent (struct breakpoint *); 1261 1262 extern struct breakpoint *create_jit_event_breakpoint (struct gdbarch *, 1263 CORE_ADDR); 1264 1265 extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *, 1266 CORE_ADDR); 1267 1268 extern struct breakpoint *create_thread_event_breakpoint (struct gdbarch *, 1269 CORE_ADDR); 1270 1271 extern void remove_jit_event_breakpoints (void); 1272 1273 extern void remove_solib_event_breakpoints (void); 1274 1275 extern void remove_thread_event_breakpoints (void); 1276 1277 extern void disable_breakpoints_in_shlibs (void); 1278 1279 /* This function returns TRUE if ep is a catchpoint. */ 1280 extern int ep_is_catchpoint (struct breakpoint *); 1281 1282 /* Enable breakpoints and delete when hit. Called with ARG == NULL 1283 deletes all breakpoints. */ 1284 extern void delete_command (char *arg, int from_tty); 1285 1286 /* Manage a software single step breakpoint (or two). Insert may be 1287 called twice before remove is called. */ 1288 extern void insert_single_step_breakpoint (struct gdbarch *, 1289 struct address_space *, 1290 CORE_ADDR); 1291 extern int single_step_breakpoints_inserted (void); 1292 extern void remove_single_step_breakpoints (void); 1293 extern void cancel_single_step_breakpoints (void); 1294 1295 /* Manage manual breakpoints, separate from the normal chain of 1296 breakpoints. These functions are used in murky target-specific 1297 ways. Please do not add more uses! */ 1298 extern void *deprecated_insert_raw_breakpoint (struct gdbarch *, 1299 struct address_space *, 1300 CORE_ADDR); 1301 extern int deprecated_remove_raw_breakpoint (struct gdbarch *, void *); 1302 1303 /* Check if any hardware watchpoints have triggered, according to the 1304 target. */ 1305 int watchpoints_triggered (struct target_waitstatus *); 1306 1307 /* Helper for transparent breakpoint hiding for memory read and write 1308 routines. 1309 1310 Update one of READBUF or WRITEBUF with either the shadows 1311 (READBUF), or the breakpoint instructions (WRITEBUF) of inserted 1312 breakpoints at the memory range defined by MEMADDR and extending 1313 for LEN bytes. If writing, then WRITEBUF is a copy of WRITEBUF_ORG 1314 on entry.*/ 1315 extern void breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf, 1316 const gdb_byte *writebuf_org, 1317 ULONGEST memaddr, LONGEST len); 1318 1319 extern int breakpoints_always_inserted_mode (void); 1320 1321 /* Called each time new event from target is processed. 1322 Retires previously deleted breakpoint locations that 1323 in our opinion won't ever trigger. */ 1324 extern void breakpoint_retire_moribund (void); 1325 1326 /* Set break condition of breakpoint B to EXP. */ 1327 extern void set_breakpoint_condition (struct breakpoint *b, char *exp, 1328 int from_tty); 1329 1330 /* Checks if we are catching syscalls or not. 1331 Returns 0 if not, greater than 0 if we are. */ 1332 extern int catch_syscall_enabled (void); 1333 1334 /* Checks if we are catching syscalls with the specific 1335 syscall_number. Used for "filtering" the catchpoints. 1336 Returns 0 if not, greater than 0 if we are. */ 1337 extern int catching_syscall_number (int syscall_number); 1338 1339 /* Return a tracepoint with the given number if found. */ 1340 extern struct tracepoint *get_tracepoint (int num); 1341 1342 extern struct tracepoint *get_tracepoint_by_number_on_target (int num); 1343 1344 /* Find a tracepoint by parsing a number in the supplied string. */ 1345 extern struct tracepoint * 1346 get_tracepoint_by_number (char **arg, 1347 struct get_number_or_range_state *state, 1348 int optional_p); 1349 1350 /* Return a vector of all tracepoints currently defined. The vector 1351 is newly allocated; the caller should free when done with it. */ 1352 extern VEC(breakpoint_p) *all_tracepoints (void); 1353 1354 extern int is_tracepoint (const struct breakpoint *b); 1355 1356 /* Return a vector of all static tracepoints defined at ADDR. The 1357 vector is newly allocated; the caller should free when done with 1358 it. */ 1359 extern VEC(breakpoint_p) *static_tracepoints_here (CORE_ADDR addr); 1360 1361 /* Function that can be passed to read_command_line to validate 1362 that each command is suitable for tracepoint command list. */ 1363 extern void check_tracepoint_command (char *line, void *closure); 1364 1365 /* Call at the start and end of an "rbreak" command to register 1366 breakpoint numbers for a later "commands" command. */ 1367 extern void start_rbreak_breakpoints (void); 1368 extern void end_rbreak_breakpoints (void); 1369 1370 /* Breakpoint iterator function. 1371 1372 Calls a callback function once for each breakpoint, so long as the 1373 callback function returns false. If the callback function returns 1374 true, the iteration will end and the current breakpoint will be 1375 returned. This can be useful for implementing a search for a 1376 breakpoint with arbitrary attributes, or for applying an operation 1377 to every breakpoint. */ 1378 extern struct breakpoint *iterate_over_breakpoints (int (*) (struct breakpoint *, 1379 void *), void *); 1380 1381 /* Nonzero if the specified PC cannot be a location where functions 1382 have been inlined. */ 1383 1384 extern int pc_at_non_inline_function (struct address_space *aspace, 1385 CORE_ADDR pc); 1386 1387 extern int user_breakpoint_p (struct breakpoint *); 1388 1389 /* Attempt to determine architecture of location identified by SAL. */ 1390 extern struct gdbarch *get_sal_arch (struct symtab_and_line sal); 1391 1392 #endif /* !defined (BREAKPOINT_H) */ 1393