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