X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fbreakpoint.h;h=3197854d3cd9359e87f049f3d12977cff169ba59;hb=db178f47dd4c9d2882da42a8915018d1fb90ea17;hp=69b63ea9327fd679013cf2db72ed5ca4be645ed5;hpb=c80049d3b615691dc902762d5d97551aa9664442;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h index 69b63ea932..3197854d3c 100644 --- a/gdb/breakpoint.h +++ b/gdb/breakpoint.h @@ -1,5 +1,5 @@ /* Data structures associated with breakpoints in GDB. - Copyright (C) 1992-2017 Free Software Foundation, Inc. + Copyright (C) 1992-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -21,17 +21,16 @@ #include "frame.h" #include "value.h" -#include "vec.h" #include "ax.h" #include "command.h" -#include "break-common.h" +#include "gdbsupport/break-common.h" #include "probe.h" #include "location.h" #include -#include "common/array-view.h" +#include "gdbsupport/array-view.h" +#include "gdbsupport/function-view.h" #include "cli/cli-script.h" -struct value; struct block; struct gdbpy_breakpoint_object; struct gdbscm_breakpoint_object; @@ -41,6 +40,17 @@ struct bpstats; struct bp_location; struct linespec_result; struct linespec_sals; +struct inferior; + +/* Enum for exception-handling support in 'catch throw', 'catch rethrow', + 'catch catch' and the MI equivalent. */ + +enum exception_event_kind +{ + EX_EVENT_THROW, + EX_EVENT_RETHROW, + EX_EVENT_CATCH +}; /* Why are we removing the breakpoint from the target? */ @@ -301,31 +311,24 @@ enum bp_loc_type bp_loc_other /* Miscellaneous... */ }; -/* This structure is a collection of function pointers that, if - available, will be called instead of performing the default action - for this bp_loc_type. */ - -struct bp_location_ops -{ - /* Destructor. Releases everything from SELF (but not SELF - itself). */ - void (*dtor) (struct bp_location *self); -}; - class bp_location { public: bp_location () = default; - bp_location (const bp_location_ops *ops, breakpoint *owner); + /* Construct a bp_location with the type inferred from OWNER's + type. */ + explicit bp_location (breakpoint *owner); + + /* Construct a bp_location with type TYPE. */ + bp_location (breakpoint *owner, bp_loc_type type); + + virtual ~bp_location (); /* Chain pointer to the next breakpoint location for the same parent breakpoint. */ bp_location *next = NULL; - /* Methods associated with this location. */ - const bp_location_ops *ops = NULL; - /* The reference count. */ int refc = 0; @@ -372,7 +375,7 @@ public: agent_expr_up cmd_bytecode; /* Signals that breakpoint conditions and/or commands need to be - re-synched with the target. This has no use other than + re-synced with the target. This has no use other than target-side breakpoints. */ bool needs_update = false; @@ -384,17 +387,17 @@ public: /* Is this particular location enabled. */ bool enabled = false; - /* Nonzero if this breakpoint is now inserted. */ + /* True if this breakpoint is now inserted. */ bool inserted = false; - /* Nonzero if this is a permanent breakpoint. There is a breakpoint + /* True if this is a permanent breakpoint. There is a breakpoint instruction hard-wired into the target's code. Don't try to write another breakpoint instruction on top of it, or restore its value. Step over it using the architecture's gdbarch_skip_permanent_breakpoint method. */ bool permanent = false; - /* Nonzero if this is not the first breakpoint in the list + /* True if this is not the first breakpoint in the list for the given address. location of tracepoint can _never_ be duplicated with other locations of tracepoints and other kinds of breakpoints, because two locations at the same @@ -491,6 +494,14 @@ public: ascertain when an event location was set at a different location than the one originally selected by parsing, e.g., inlined symbols. */ const struct symbol *symbol = NULL; + + /* Similarly, the minimal symbol found by the location parser, if + any. This may be used to ascertain if the location was + originally set on a GNU ifunc symbol. */ + const minimal_symbol *msymbol = NULL; + + /* The objfile the symbol or minimal symbol were found in. */ + const struct objfile *objfile = NULL; }; /* The possible return values for print_bpstat, print_it_normal, @@ -659,19 +670,12 @@ enum watchpoint_triggered watch_triggered_yes }; -typedef struct bp_location *bp_location_p; -DEF_VEC_P(bp_location_p); - -/* A reference-counted struct command_line. This is an implementation - detail to the breakpoints module. */ -typedef std::shared_ptr counted_command_line; - /* Some targets (e.g., embedded PowerPC) need two debug registers to set a watchpoint over a memory region. If this flag is true, GDB will use - only one register per watchpoint, thus assuming that all acesses that + only one register per watchpoint, thus assuming that all accesses that modify a memory location happen at its starting address. */ -extern int target_exact_watchpoints; +extern bool target_exact_watchpoints; /* Note that the ->silent field is not currently used by any commands (though the code is in there if it was to be, and set_raw_breakpoint @@ -730,9 +734,8 @@ struct breakpoint event_location_up location; /* The filter that should be passed to decode_line_full when - re-setting this breakpoint. This may be NULL, but otherwise is - allocated with xmalloc. */ - char *filter = NULL; + re-setting this breakpoint. This may be NULL. */ + gdb::unique_xmalloc_ptr filter; /* For a ranged breakpoint, the location we used to find the end of the range. */ @@ -813,10 +816,11 @@ struct watchpoint : public breakpoint /* Value of the watchpoint the last time we checked it, or NULL when we do not know the value yet or the value was not readable. VAL is never lazy. */ - struct value *val; - /* Nonzero if VAL is valid. If VAL_VALID is set but VAL is NULL, + value_ref_ptr val; + + /* True if VAL is valid. If VAL_VALID is set but VAL is NULL, then an error occurred reading the value. */ - int val_valid; + bool val_valid; /* When watching the location of a bitfield, contains the offset and size of the bitfield. Otherwise contains 0. */ @@ -862,11 +866,17 @@ extern struct breakpoint *breakpoint_find_if /* Return true if BPT is either a software breakpoint or a hardware breakpoint. */ -extern int is_breakpoint (const struct breakpoint *bpt); +extern bool is_breakpoint (const struct breakpoint *bpt); + +/* Return true if BPT is of any watchpoint kind, hardware or + software. */ + +extern bool is_watchpoint (const struct breakpoint *bpt); -/* Returns true if BPT is really a watchpoint. */ +/* Return true if BPT is a C++ exception catchpoint (catch + catch/throw/rethrow). */ -extern int is_watchpoint (const struct breakpoint *bpt); +extern bool is_exception_catchpoint (breakpoint *bp); /* An instance of this type is used to represent all kinds of tracepoints. */ @@ -889,7 +899,7 @@ struct tracepoint : public breakpoint ULONGEST traceframe_usage; /* The static tracepoint marker id, if known. */ - char *static_trace_marker_id; + std::string static_trace_marker_id; /* LTTng/UST allow more than one marker with the same ID string, although it unadvised because it confuses tools. When setting @@ -900,8 +910,6 @@ struct tracepoint : public breakpoint int static_trace_marker_id_idx; }; -typedef struct breakpoint *breakpoint_p; -DEF_VEC_P(breakpoint_p); /* The following stuff is an abstract data type "bpstat" ("breakpoint status"). This provides the ability to determine whether we have @@ -917,9 +925,37 @@ extern void bpstat_clear (bpstat *); is part of the bpstat is copied as well. */ extern bpstat bpstat_copy (bpstat); -extern bpstat bpstat_stop_status (const address_space *aspace, - CORE_ADDR pc, ptid_t ptid, +/* Build the (raw) bpstat chain for the stop information given by ASPACE, + BP_ADDR, and WS. Returns the head of the bpstat chain. */ + +extern bpstat build_bpstat_chain (const address_space *aspace, + CORE_ADDR bp_addr, const struct target_waitstatus *ws); + +/* Get a bpstat associated with having just stopped at address + BP_ADDR in thread PTID. STOP_CHAIN may be supplied as a previously + computed stop chain or NULL, in which case the stop chain will be + computed using build_bpstat_chain. + + Determine whether we stopped at a breakpoint, etc, or whether we + don't understand this stop. Result is a chain of bpstat's such + that: + + if we don't understand the stop, the result is a null pointer. + + if we understand why we stopped, the result is not null. + + Each element of the chain refers to a particular breakpoint or + watchpoint at which we have stopped. (We may have stopped for + several reasons concurrently.) + + Each element of the chain has valid next, breakpoint_at, + commands, FIXME??? fields. */ + +extern bpstat bpstat_stop_status (const address_space *aspace, + CORE_ADDR pc, thread_info *thread, + const struct target_waitstatus *ws, + bpstat stop_chain = NULL); /* This bpstat_what stuff tells wait_for_inferior what to do with a breakpoint (a challenging task). @@ -1013,7 +1049,7 @@ struct bpstat_what /* Used for BPSTAT_WHAT_SET_LONGJMP_RESUME and BPSTAT_WHAT_CLEAR_LONGJMP_RESUME. True if we are handling a longjmp, false if we are handling an exception. */ - int is_longjmp; + bool is_longjmp; }; /* Tell what to do about this bpstat. */ @@ -1026,18 +1062,18 @@ extern void bpstat_run_callbacks (bpstat bs_head); /* Find the bpstat associated with a breakpoint. NULL otherwise. */ bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *); -/* Nonzero if a signal that we got in target_wait() was due to +/* True if a signal that we got in target_wait() was due to circumstances explained by the bpstat; the signal is therefore not random. */ -extern int bpstat_explains_signal (bpstat, enum gdb_signal); +extern bool bpstat_explains_signal (bpstat, enum gdb_signal); -/* Nonzero is this bpstat causes a stop. */ -extern int bpstat_causes_stop (bpstat); +/* True if this bpstat causes a stop. */ +extern bool bpstat_causes_stop (bpstat); -/* Nonzero if we should step constantly (e.g. watchpoints on machines +/* True if we should step constantly (e.g. watchpoints on machines without hardware support). This isn't related to a specific bpstat, just to things like whether watchpoints are set. */ -extern int bpstat_should_step (void); +extern bool bpstat_should_step (); /* Print a message indicating what happened. Returns nonzero to say that only the source line should be printed after this (zero @@ -1125,7 +1161,7 @@ struct bpstats counted_command_line commands; /* Old value associated with a watchpoint. */ - struct value *old_val; + value_ref_ptr old_val; /* Nonzero if this breakpoint tells us to print the frame. */ char print; @@ -1223,10 +1259,22 @@ extern void breakpoint_re_set (void); extern void breakpoint_re_set_thread (struct breakpoint *); -extern struct breakpoint *set_momentary_breakpoint +extern void delete_breakpoint (struct breakpoint *); + +struct breakpoint_deleter +{ + void operator() (struct breakpoint *b) const + { + delete_breakpoint (b); + } +}; + +typedef std::unique_ptr breakpoint_up; + +extern breakpoint_up set_momentary_breakpoint (struct gdbarch *, struct symtab_and_line, struct frame_id, enum bptype); -extern struct breakpoint *set_momentary_breakpoint_at_pc +extern breakpoint_up set_momentary_breakpoint_at_pc (struct gdbarch *, CORE_ADDR pc, enum bptype type); extern struct breakpoint *clone_momentary_breakpoint (struct breakpoint *bpkt); @@ -1235,10 +1283,6 @@ extern void set_ignore_count (int, int, int); extern void breakpoint_init_inferior (enum inf_context); -extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *); - -extern void delete_breakpoint (struct breakpoint *); - extern void breakpoint_auto_delete (bpstat); typedef void (*walk_bp_location_callback) (struct bp_location *, void *); @@ -1253,15 +1297,12 @@ extern struct command_line *breakpoint_commands (struct breakpoint *b); NOT be deallocated after use. */ const char *bpdisp_text (enum bpdisp disp); -extern void break_command (char *, int); +extern void break_command (const char *, int); -extern void hbreak_command_wrapper (char *, int); -extern void thbreak_command_wrapper (char *, int); -extern void rbreak_command_wrapper (char *, int); extern void watch_command_wrapper (const char *, int, int); extern void awatch_command_wrapper (const char *, int, int); extern void rwatch_command_wrapper (const char *, int, int); -extern void tbreak_command (char *, int); +extern void tbreak_command (const char *, int); extern struct breakpoint_ops base_breakpoint_ops; extern struct breakpoint_ops bkpt_breakpoint_ops; @@ -1280,7 +1321,7 @@ extern void initialize_breakpoint_ops (void); extern void add_catch_command (const char *name, const char *docstring, - cmd_sfunc_ftype *sfunc, + cmd_const_sfunc_ftype *sfunc, completer_ftype *completer, void *user_data_catch, void *user_data_tcatch); @@ -1311,6 +1352,15 @@ extern void init_catchpoint (struct breakpoint *b, extern void install_breakpoint (int internal, std::unique_ptr &&b, int update_gll); +/* Returns the breakpoint ops appropriate for use with with LOCATION and + according to IS_TRACEPOINT. Use this to ensure, for example, that you pass + the correct ops to create_breakpoint for probe locations. If LOCATION is + NULL, returns bkpt_breakpoint_ops (or tracepoint_breakpoint_ops, if + IS_TRACEPOINT is true). */ + +extern const struct breakpoint_ops *breakpoint_ops_for_event_location + (const struct event_location *location, bool is_tracepoint); + /* Flags that can be passed down to create_breakpoint, etc., to affect breakpoint creation in several ways. */ @@ -1357,7 +1407,9 @@ extern void insert_breakpoints (void); extern int remove_breakpoints (void); -extern int remove_breakpoints_pid (int pid); +/* Remove breakpoints of inferior INF. */ + +extern void remove_breakpoints_inf (inferior *inf); /* This function can be used to update the breakpoint package's state after an exec() system call has been executed. @@ -1472,7 +1524,7 @@ extern void disable_breakpoint (struct breakpoint *); extern void enable_breakpoint (struct breakpoint *); extern void breakpoint_set_commands (struct breakpoint *b, - command_line_up &&commands); + counted_command_line &&commands); extern void breakpoint_set_silent (struct breakpoint *b, int silent); @@ -1509,8 +1561,9 @@ extern void remove_solib_event_breakpoints_at_next_stop (void); extern void disable_breakpoints_in_shlibs (void); -/* This function returns TRUE if ep is a catchpoint. */ -extern int is_catchpoint (struct breakpoint *); +/* This function returns true if B is a catchpoint. */ + +extern bool is_catchpoint (struct breakpoint *b); /* Shared helper function (MI and CLI) for creating and installing a shared object event catchpoint. */ @@ -1583,23 +1636,18 @@ extern struct tracepoint *get_tracepoint_by_number_on_target (int num); /* Find a tracepoint by parsing a number in the supplied string. */ extern struct tracepoint * - get_tracepoint_by_number (char **arg, + get_tracepoint_by_number (const char **arg, number_or_range_parser *parser); -/* Return a vector of all tracepoints currently defined. The vector - is newly allocated; the caller should free when done with it. */ -extern VEC(breakpoint_p) *all_tracepoints (void); +/* Return a vector of all tracepoints currently defined. */ +extern std::vector all_tracepoints (void); -extern int is_tracepoint (const struct breakpoint *b); +/* Return true if B is of tracepoint kind. */ -/* Return a vector of all static tracepoints defined at ADDR. The - vector is newly allocated; the caller should free when done with - it. */ -extern VEC(breakpoint_p) *static_tracepoints_here (CORE_ADDR addr); +extern bool is_tracepoint (const struct breakpoint *b); -/* Function that can be passed to read_command_line to validate - that each command is suitable for tracepoint command list. */ -extern void check_tracepoint_command (char *line, void *closure); +/* Return a vector of all static tracepoints defined at ADDR. */ +extern std::vector static_tracepoints_here (CORE_ADDR addr); /* Create an instance of this to start registering breakpoint numbers for a later "commands" command. */ @@ -1622,8 +1670,8 @@ public: returned. This can be useful for implementing a search for a breakpoint with arbitrary attributes, or for applying an operation to every breakpoint. */ -extern struct breakpoint *iterate_over_breakpoints (int (*) (struct breakpoint *, - void *), void *); +extern struct breakpoint *iterate_over_breakpoints + (gdb::function_view); /* Nonzero if the specified PC cannot be a location where functions have been inlined. */ @@ -1651,4 +1699,22 @@ extern void maybe_print_thread_hit_breakpoint (struct ui_out *uiout); /* Print the specified breakpoint. */ extern void print_breakpoint (breakpoint *bp); +/* Command element for the 'commands' command. */ +extern cmd_list_element *commands_cmd_element; + +/* Whether to use the fixed output when printing information about a + multi-location breakpoint (see PR 9659). */ + +extern bool fix_multi_location_breakpoint_output_globally; + +/* Deal with "catch catch", "catch throw", and "catch rethrow" commands and + the MI equivalents. Sets up to catch events of type EX_EVENT. When + TEMPFLAG is true only the next matching event is caught after which the + catch-point is deleted. If REGEX is not NULL then only exceptions whose + type name matches REGEX will trigger the event. */ + +extern void catch_exception_event (enum exception_event_kind ex_event, + const char *regex, bool tempflag, + int from_tty); + #endif /* !defined (BREAKPOINT_H) */