X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fbreakpoint.h;h=054eab4d75eff2fab5daf12af98bfb76432d7c38;hb=f3abeff575541dd80e1facd6d0f920e10f77fede;hp=c1d3be9b611c6b8b7a699403e5231659214f52d1;hpb=0b30217134add051e159a192066a1e568ebd837f;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h index c1d3be9b61..054eab4d75 100644 --- a/gdb/breakpoint.h +++ b/gdb/breakpoint.h @@ -1,5 +1,5 @@ /* Data structures associated with breakpoints in GDB. - Copyright (C) 1992-2004, 2007-2012 Free Software Foundation, Inc. + Copyright (C) 1992-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -22,14 +22,22 @@ #include "frame.h" #include "value.h" #include "vec.h" +#include "ax.h" +#include "command.h" +#include "break-common.h" +#include "probe.h" struct value; struct block; -struct breakpoint_object; +struct gdbpy_breakpoint_object; +struct gdbscm_breakpoint_object; struct get_number_or_range_state; struct thread_info; struct bpstats; struct bp_location; +struct linespec_result; +struct linespec_sals; +struct event_location; /* This is the maximum number of bytes a breakpoint instruction can take. Feel free to increase it. It's just used in a few places to @@ -40,18 +48,13 @@ struct bp_location; /* Type of breakpoint. */ -/* FIXME In the future, we should fold all other breakpoint-like - things into here. This includes: - - * single-step (for machines where we have to simulate single - stepping) (probably, though perhaps it is better for it to look as - much as possible like a single-step to wait_for_inferior). */ enum bptype { bp_none = 0, /* Eventpoint has been deleted */ bp_breakpoint, /* Normal breakpoint */ bp_hardware_breakpoint, /* Hardware assisted breakpoint */ + bp_single_step, /* Software single-step */ bp_until, /* used by until command */ bp_finish, /* used by finish command */ bp_watchpoint, /* Watchpoint */ @@ -61,6 +64,12 @@ enum bptype bp_longjmp, /* secret breakpoint to find longjmp() */ bp_longjmp_resume, /* secret breakpoint to escape longjmp() */ + /* Breakpoint placed to the same location(s) like bp_longjmp but used to + protect against stale DUMMY_FRAME. Multiple bp_longjmp_call_dummy and + one bp_call_dummy are chained together by related_breakpoint for each + DUMMY_FRAME. */ + bp_longjmp_call_dummy, + /* An internal breakpoint that is installed on the unwinder's debug hook. */ bp_exception, @@ -90,14 +99,8 @@ enum bptype 3) It can never be disabled. */ bp_watchpoint_scope, - /* The breakpoint at the end of a call dummy. */ - /* FIXME: What if the function we are calling longjmp()s out of - the call, or the user gets out with the "return" command? We - currently have no way of cleaning up the breakpoint in these - (obscure) situations. (Probably can solve this by noticing - longjmp, "return", etc., it's similar to noticing when a - watchpoint on a local variable goes out of scope (with hardware - support for watchpoints)). */ + /* The breakpoint at the end of a call dummy. See bp_longjmp_call_dummy it + is chained with by related_breakpoint. */ bp_call_dummy, /* A breakpoint set on std::terminate, that is used to catch @@ -151,6 +154,13 @@ enum bptype bp_fast_tracepoint, bp_static_tracepoint, + /* A dynamic printf stops at the given location, does a formatted + print, then automatically continues. (Although this is sort of + like a macro packaging up standard breakpoint functionality, + GDB doesn't have a way to construct types of breakpoint from + elements of behavior.) */ + bp_dprintf, + /* Event for JIT compiled code generation or deletion. */ bp_jit_event, @@ -184,12 +194,6 @@ enum enable_state automatically enabled and reset when the call "lands" (either completes, or stops at another eventpoint). */ - bp_permanent /* 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 SKIP_INSN macro. */ }; @@ -204,15 +208,16 @@ enum bpdisp disp_donttouch /* Leave it alone */ }; -enum target_hw_bp_type +/* Status of breakpoint conditions used when synchronizing + conditions with the target. */ + +enum condition_status { - hw_write = 0, /* Common HW watchpoint */ - hw_read = 1, /* Read HW watchpoint */ - hw_access = 2, /* Access HW watchpoint */ - hw_execute = 3 /* Execute HW breakpoint */ + condition_unchanged = 0, + condition_modified, + condition_updated }; - /* Information used by targets to insert and remove breakpoints. */ struct bp_target_info @@ -220,13 +225,16 @@ struct bp_target_info /* Address space at which the breakpoint was placed. */ struct address_space *placed_address_space; - /* Address at which the breakpoint was placed. This is normally the - same as ADDRESS from the bp_location, except when adjustment - happens in gdbarch_breakpoint_from_pc. The most common form of - adjustment is stripping an alternate ISA marker from the PC which - is used to determine the type of breakpoint to insert. */ + /* Address at which the breakpoint was placed. This is normally + the same as REQUESTED_ADDRESS, except when adjustment happens in + gdbarch_breakpoint_from_pc. The most common form of adjustment + is stripping an alternate ISA marker from the PC which is used + to determine the type of breakpoint to insert. */ CORE_ADDR placed_address; + /* Address at which the breakpoint was requested. */ + CORE_ADDR reqstd_address; + /* If this is a ranged breakpoint, then this field contains the length of the range that will be watched for execution. */ int length; @@ -247,6 +255,18 @@ struct bp_target_info (e.g. if a remote stub handled the details). We may still need the size to remove the breakpoint safely. */ int placed_size; + + /* Vector of conditions the target should evaluate if it supports target-side + breakpoint conditions. */ + VEC(agent_expr_p) *conditions; + + /* Vector of commands the target should evaluate if it supports + target-side breakpoint commands. */ + VEC(agent_expr_p) *tcommands; + + /* Flag that is true if the breakpoint should be left in place even + when GDB is not connected. */ + int persist; }; /* GDB maintains two types of information about each breakpoint (or @@ -313,6 +333,33 @@ struct bp_location the owner breakpoint object. */ struct expression *cond; + /* Conditional expression in agent expression + bytecode form. This is used for stub-side breakpoint + condition evaluation. */ + struct agent_expr *cond_bytecode; + + /* Signals that the condition has changed since the last time + we updated the global location list. This means the condition + needs to be sent to the target again. This is used together + with target-side breakpoint conditions. + + condition_unchanged: It means there has been no condition changes. + + condition_modified: It means this location had its condition modified. + + condition_updated: It means we already marked all the locations that are + duplicates of this location and thus we don't need to call + force_breakpoint_reinsertion (...) for this location. */ + + enum condition_status condition_changed; + + struct agent_expr *cmd_bytecode; + + /* Signals that breakpoint conditions and/or commands need to be + re-synched with the target. This has no use other than + target-side breakpoints. */ + char needs_update; + /* This location's address is in an unloaded solib, and so this location should not be inserted. It will be automatically enabled when that solib is loaded. */ @@ -324,6 +371,13 @@ struct bp_location /* Nonzero if this breakpoint is now inserted. */ char inserted; + /* Nonzero 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. */ + char permanent; + /* Nonzero 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 @@ -377,6 +431,15 @@ struct bp_location processor's architectual constraints. */ CORE_ADDR requested_address; + /* An additional address assigned with this location. This is currently + only used by STT_GNU_IFUNC resolver breakpoints to hold the address + of the resolver function. */ + CORE_ADDR related_address; + + /* If the location comes from a probe point, this is the probe associated + with it. */ + struct bound_probe probe; + char *function_name; /* Details of the placed breakpoint, when inserted. */ @@ -396,13 +459,37 @@ struct bp_location it becomes 0 this location is retired. */ int events_till_retirement; - /* Line number of this address. */ + /* Line number which was used to place this location. + + Breakpoint placed into a comment keeps it's user specified line number + despite ADDRESS resolves into a different line number. */ int line_number; - /* Source file name of this address. */ + /* Symtab which was used to place this location. This is used + to find the corresponding source file name. */ - char *source_file; + struct symtab *symtab; +}; + +/* The possible return values for print_bpstat, print_it_normal, + print_it_done, print_it_noop. */ +enum print_stop_action +{ + /* We printed nothing or we need to do some more analysis. */ + PRINT_UNKNOWN = -1, + + /* We printed something, and we *do* desire that something to be + followed by a location. */ + PRINT_SRC_AND_LOC, + + /* We printed something, and we do *not* desire that something to be + followed by a location. */ + PRINT_SRC_ONLY, + + /* We already printed all we needed to print, don't print anything + else. */ + PRINT_NOTHING }; /* This structure is a collection of function pointers that, if available, @@ -436,9 +523,14 @@ struct breakpoint_ops /* Return true if it the target has stopped due to hitting breakpoint location BL. This function does not check if we - should stop, only if BL explains the stop. */ - int (*breakpoint_hit) (const struct bp_location *bl, struct address_space *, - CORE_ADDR); + should stop, only if BL explains the stop. ASPACE is the address + space in which the event occurred, BP_ADDR is the address at + which the inferior stopped, and WS is the target_waitstatus + describing the event. */ + int (*breakpoint_hit) (const struct bp_location *bl, + struct address_space *aspace, + CORE_ADDR bp_addr, + const struct target_waitstatus *ws); /* Check internal conditions of the breakpoint referred to by BS. If we should not stop for this breakpoint, set BS->stop to 0. */ @@ -482,6 +574,49 @@ struct breakpoint_ops /* Print to FP the CLI command that recreates this breakpoint. */ void (*print_recreate) (struct breakpoint *, struct ui_file *fp); + + /* Create SALs from location, storing the result in linespec_result. + + For an explanation about the arguments, see the function + `create_sals_from_location_default'. + + This function is called inside `create_breakpoint'. */ + void (*create_sals_from_location) (const struct event_location *location, + struct linespec_result *canonical, + enum bptype type_wanted); + + /* This method will be responsible for creating a breakpoint given its SALs. + Usually, it just calls `create_breakpoints_sal' (for ordinary + breakpoints). However, there may be some special cases where we might + need to do some tweaks, e.g., see + `strace_marker_create_breakpoints_sal'. + + This function is called inside `create_breakpoint'. */ + void (*create_breakpoints_sal) (struct gdbarch *, + struct linespec_result *, + char *, char *, + enum bptype, enum bpdisp, int, int, + int, const struct breakpoint_ops *, + int, int, int, unsigned); + + /* Given the location (second parameter), this method decodes it and + provides the SAL locations related to it. For ordinary + breakpoints, it calls `decode_line_full'. If SEARCH_PSPACE is + not NULL, symbol search is restricted to just that program space. + + This function is called inside `location_to_sals'. */ + void (*decode_location) (struct breakpoint *b, + const struct event_location *location, + struct program_space *search_pspace, + struct symtabs_and_lines *sals); + + /* Return true if this breakpoint explains a signal. See + bpstat_explains_signal. */ + int (*explains_signal) (struct breakpoint *, enum gdb_signal); + + /* Called after evaluating the breakpoint's condition, + and only if it evaluated true. */ + void (*after_condition_true) (struct bpstats *bs); }; /* Helper for breakpoint_ops->print_recreate implementations. Prints @@ -506,9 +641,6 @@ enum watchpoint_triggered watch_triggered_yes }; -/* This is used to declare the VEC syscalls_to_be_caught. */ -DEF_VEC_I(int); - typedef struct bp_location *bp_location_p; DEF_VEC_P(bp_location_p); @@ -558,6 +690,11 @@ struct breakpoint /* Number of stops at this breakpoint that should be continued automatically before really stopping. */ int ignore_count; + + /* Number of stops at this breakpoint before it will be + disabled. */ + int enable_count; + /* Chain of command lines to execute when this breakpoint is hit. */ struct counted_command_line *commands; @@ -570,17 +707,17 @@ struct breakpoint non-thread-specific ordinary breakpoints this is NULL. */ struct program_space *pspace; - /* String we used to set the breakpoint (malloc'd). */ - char *addr_string; + /* Location we used to set the breakpoint (malloc'd). */ + struct event_location *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; - /* For a ranged breakpoint, the string we used to find + /* For a ranged breakpoint, the location we used to find the end of the range (malloc'd). */ - char *addr_string_range_end; + struct event_location *location_range_end; /* Architecture we used to set the breakpoint. */ struct gdbarch *gdbarch; @@ -591,8 +728,10 @@ struct breakpoint /* String form of the breakpoint condition (malloc'd), or NULL if there is no condition. */ char *cond_string; - /* String form of exp to use for displaying to the user - (malloc'd), or NULL if none. */ + + /* String form of extra parameters, or NULL if there are none. + Malloc'd. */ + char *extra_string; /* Holds the address of the related watchpoint_scope breakpoint when using watchpoints on local variables (might the concept of @@ -624,8 +763,11 @@ struct breakpoint Python object that has been associated with this breakpoint. This is always NULL for a GDB that is not script enabled. It can sometimes be NULL for enabled GDBs as not all breakpoint - types are tracked by the Python scripting API. */ - struct breakpoint_object *py_bp_object; + types are tracked by the scripting language API. */ + struct gdbpy_breakpoint_object *py_bp_object; + + /* Same as py_bp_object, but for Scheme. */ + struct gdbscm_breakpoint_object *scm_bp_object; }; /* An instance of this type is used to represent a watchpoint. It @@ -647,12 +789,12 @@ struct watchpoint struct expression *exp; /* The largest block within which it is valid, or NULL if it is valid anywhere (e.g. consists just of global symbols). */ - struct block *exp_valid_block; + const struct block *exp_valid_block; /* The conditional expression if any. */ struct expression *cond_exp; /* The largest block within which it is valid, or NULL if it is valid anywhere (e.g. consists just of global symbols). */ - struct block *cond_exp_valid_block; + const struct block *cond_exp_valid_block; /* 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. */ @@ -661,6 +803,11 @@ struct watchpoint then an error occurred reading the value. */ int val_valid; + /* When watching the location of a bitfield, contains the offset and size of + the bitfield. Otherwise contains 0. */ + int val_bitpos; + int val_bitsize; + /* Holds the frame address which identifies the frame this watchpoint should be evaluated in, or `null' if the watchpoint should be evaluated on the outermost frame. */ @@ -683,6 +830,25 @@ struct watchpoint CORE_ADDR hw_wp_mask; }; +/* Given a function FUNC (struct breakpoint *B, void *DATA) and + USER_DATA, call FUNC for every known breakpoint passing USER_DATA + as argument. + + If FUNC returns 1, the loop stops and the current + 'struct breakpoint' being processed is returned. If FUNC returns + zero, the loop continues. + + This function returns either a 'struct breakpoint' pointer or NULL. + It was based on BFD's bfd_sections_find_if function. */ + +extern struct breakpoint *breakpoint_find_if + (int (*func) (struct breakpoint *b, void *d), void *user_data); + +/* Return true if BPT is either a software breakpoint or a hardware + breakpoint. */ + +extern int is_breakpoint (const struct breakpoint *bpt); + /* Returns true if BPT is really a watchpoint. */ extern int is_watchpoint (const struct breakpoint *bpt); @@ -741,7 +907,8 @@ extern void bpstat_clear (bpstat *); extern bpstat bpstat_copy (bpstat); extern bpstat bpstat_stop_status (struct address_space *aspace, - CORE_ADDR pc, ptid_t ptid); + CORE_ADDR pc, ptid_t ptid, + const struct target_waitstatus *ws); /* This bpstat_what stuff tells wait_for_inferior what to do with a breakpoint (a challenging task). @@ -838,37 +1005,20 @@ struct bpstat_what int is_longjmp; }; -/* The possible return values for print_bpstat, print_it_normal, - print_it_done, print_it_noop. */ -enum print_stop_action - { - /* We printed nothing or we need to do some more analysis. */ - PRINT_UNKNOWN = -1, - - /* We printed something, and we *do* desire that something to be - followed by a location. */ - PRINT_SRC_AND_LOC, - - /* We printed something, and we do *not* desire that something to - be followed by a location. */ - PRINT_SRC_ONLY, - - /* We already printed all we needed to print, don't print anything - else. */ - PRINT_NOTHING - }; - /* Tell what to do about this bpstat. */ struct bpstat_what bpstat_what (bpstat); - + +/* Run breakpoint event callbacks associated with the breakpoints that + triggered. */ +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 wait() was due to circumstances - explained by the BS. */ -/* Currently that is true if we have hit a breakpoint, or if there is - a watchpoint enabled. */ -#define bpstat_explains_signal(bs) ((bs) != NULL) +/* Nonzero 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); /* Nonzero is this bpstat causes a stop. */ extern int bpstat_causes_stop (bpstat); @@ -990,9 +1140,19 @@ enum breakpoint_here /* Prototypes for breakpoint-related functions. */ +/* Return 1 if there's a program/permanent breakpoint planted in + memory at ADDRESS, return 0 otherwise. */ + +extern int program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address); + extern enum breakpoint_here breakpoint_here_p (struct address_space *, CORE_ADDR); +/* Return true if an enabled breakpoint exists in the range defined by + ADDR and LEN, in ASPACE. */ +extern int breakpoint_in_range_p (struct address_space *aspace, + CORE_ADDR addr, ULONGEST len); + extern int moribund_breakpoint_here_p (struct address_space *, CORE_ADDR); extern int breakpoint_inserted_here_p (struct address_space *, CORE_ADDR); @@ -1003,14 +1163,35 @@ extern int regular_breakpoint_inserted_here_p (struct address_space *, extern int software_breakpoint_inserted_here_p (struct address_space *, CORE_ADDR); +/* Return non-zero iff there is a hardware breakpoint inserted at + PC. */ +extern int hardware_breakpoint_inserted_here_p (struct address_space *, + CORE_ADDR); + +/* Check whether any location of BP is inserted at PC. */ + +extern int breakpoint_has_location_inserted_here (struct breakpoint *bp, + struct address_space *aspace, + CORE_ADDR pc); + +extern int single_step_breakpoint_inserted_here_p (struct address_space *, + CORE_ADDR); + /* Returns true if there's a hardware watchpoint or access watchpoint inserted in the range defined by ADDR and LEN. */ extern int hardware_watchpoint_inserted_in_range (struct address_space *, CORE_ADDR addr, ULONGEST len); -extern int breakpoint_thread_match (struct address_space *, - CORE_ADDR, ptid_t); +/* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the + same breakpoint location. In most targets, this can only be true + if ASPACE1 matches ASPACE2. On targets that have global + breakpoints, the address space doesn't really matter. */ + +extern int breakpoint_address_match (struct address_space *aspace1, + CORE_ADDR addr1, + struct address_space *aspace2, + CORE_ADDR addr2); extern void until_break_command (char *, int, int); @@ -1021,6 +1202,7 @@ extern void init_bp_location (struct bp_location *loc, struct breakpoint *owner); extern void update_breakpoint_locations (struct breakpoint *b, + struct program_space *filter_pspace, struct symtabs_and_lines sals, struct symtabs_and_lines sals_end); @@ -1046,6 +1228,10 @@ extern void delete_breakpoint (struct breakpoint *); extern void breakpoint_auto_delete (bpstat); +typedef void (*walk_bp_location_callback) (struct bp_location *, void *); + +extern void iterate_over_bp_locations (walk_bp_location_callback); + /* Return the chain of command lines to execute when this breakpoint is hit. */ extern struct command_line *breakpoint_commands (struct breakpoint *b); @@ -1064,7 +1250,10 @@ extern void awatch_command_wrapper (char *, int, int); extern void rwatch_command_wrapper (char *, int, int); extern void tbreak_command (char *, int); +extern struct breakpoint_ops base_breakpoint_ops; extern struct breakpoint_ops bkpt_breakpoint_ops; +extern struct breakpoint_ops tracepoint_breakpoint_ops; +extern struct breakpoint_ops dprintf_breakpoint_ops; extern void initialize_breakpoint_ops (void); @@ -1078,10 +1267,8 @@ extern void initialize_breakpoint_ops (void); extern void add_catch_command (char *name, char *docstring, - void (*sfunc) (char *args, int from_tty, - struct cmd_list_element *command), - char **(*completer) (struct cmd_list_element *cmd, - char *text, char *word), + cmd_sfunc_ftype *sfunc, + completer_ftype *completer, void *user_data_catch, void *user_data_tcatch); @@ -1094,8 +1281,14 @@ extern void char *addr_string, const struct breakpoint_ops *ops, int tempflag, + int enabled, int from_tty); +extern void init_catchpoint (struct breakpoint *b, + struct gdbarch *gdbarch, int tempflag, + char *cond_string, + const struct breakpoint_ops *ops); + /* Add breakpoint B on the breakpoint list, and notify the user, the target and breakpoint_created observers of its existence. If INTERNAL is non-zero, the breakpoint number will be allocated from @@ -1105,16 +1298,47 @@ extern void extern void install_breakpoint (int internal, struct breakpoint *b, int update_gll); -extern int create_breakpoint (struct gdbarch *gdbarch, char *arg, +/* Flags that can be passed down to create_breakpoint, etc., to affect + breakpoint creation in several ways. */ + +enum breakpoint_create_flags + { + /* We're adding a breakpoint to our tables that is already + inserted in the target. */ + CREATE_BREAKPOINT_FLAGS_INSERTED = 1 << 0 + }; + +/* Set a breakpoint. This function is shared between CLI and MI functions + for setting a breakpoint at LOCATION. + + This function has two major modes of operations, selected by the + PARSE_EXTRA parameter. + + If PARSE_EXTRA is zero, LOCATION is just the breakpoint's location, + with condition, thread, and extra string specified by the COND_STRING, + THREAD, and EXTRA_STRING parameters. + + If PARSE_EXTRA is non-zero, this function will attempt to extract + the condition, thread, and extra string from EXTRA_STRING, ignoring + the similarly named parameters. + + If INTERNAL is non-zero, the breakpoint number will be allocated + from the internal breakpoint count. + + Returns true if any breakpoint was created; false otherwise. */ + +extern int create_breakpoint (struct gdbarch *gdbarch, + const struct event_location *location, char *cond_string, int thread, - int parse_condition_and_thread, + char *extra_string, + int parse_extra, int tempflag, enum bptype wanted_type, int ignore_count, enum auto_boolean pending_break_support, const struct breakpoint_ops *ops, int from_tty, int enabled, - int internal); + int internal, unsigned flags); extern void insert_breakpoints (void); @@ -1155,7 +1379,7 @@ extern void update_breakpoints_after_exec (void); It is an error to use this function on the process whose id is inferior_ptid. */ -extern int detach_breakpoints (int); +extern int detach_breakpoints (ptid_t ptid); /* This function is called when program space PSPACE is about to be deleted. It takes care of updating breakpoints to not reference @@ -1166,6 +1390,12 @@ extern void set_longjmp_breakpoint (struct thread_info *tp, struct frame_id frame); extern void delete_longjmp_breakpoint (int thread); +/* Mark all longjmp breakpoints from THREAD for later deletion. */ +extern void delete_longjmp_breakpoint_at_next_stop (int thread); + +extern struct breakpoint *set_longjmp_breakpoint_for_call_dummy (void); +extern void check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp); + extern void enable_overlay_breakpoints (void); extern void disable_overlay_breakpoints (void); @@ -1247,14 +1477,19 @@ extern void breakpoint_set_task (struct breakpoint *b, int task); /* Clear the "inserted" flag in all breakpoints. */ extern void mark_breakpoints_out (void); -extern void make_breakpoint_permanent (struct breakpoint *); - extern struct breakpoint *create_jit_event_breakpoint (struct gdbarch *, CORE_ADDR); extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *, CORE_ADDR); +/* Create an solib event breakpoint at ADDRESS in the current program + space, and immediately try to insert it. Returns a pointer to the + breakpoint on success. Deletes the new breakpoint and returns NULL + if inserting the breakpoint fails. */ +extern struct breakpoint *create_and_insert_solib_event_breakpoint + (struct gdbarch *gdbarch, CORE_ADDR address); + extern struct breakpoint *create_thread_event_breakpoint (struct gdbarch *, CORE_ADDR); @@ -1262,34 +1497,31 @@ extern void remove_jit_event_breakpoints (void); extern void remove_solib_event_breakpoints (void); -extern void remove_thread_event_breakpoints (void); +/* Mark solib event breakpoints of the current program space with + delete at next stop disposition. */ +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 ep_is_catchpoint (struct breakpoint *); +extern int is_catchpoint (struct breakpoint *); + +/* Shared helper function (MI and CLI) for creating and installing + a shared object event catchpoint. */ +extern void add_solib_catchpoint (char *arg, int is_load, int is_temp, + int enabled); /* Enable breakpoints and delete when hit. Called with ARG == NULL deletes all breakpoints. */ extern void delete_command (char *arg, int from_tty); -/* Manage a software single step breakpoint (or two). Insert may be - called twice before remove is called. */ +/* Create and insert a new software single step breakpoint for the + current thread. May be called multiple times; each time will add a + new location to the set of potential addresses the next instruction + is at. */ extern void insert_single_step_breakpoint (struct gdbarch *, struct address_space *, CORE_ADDR); -extern int single_step_breakpoints_inserted (void); -extern void remove_single_step_breakpoints (void); -extern void cancel_single_step_breakpoints (void); - -/* Manage manual breakpoints, separate from the normal chain of - breakpoints. These functions are used in murky target-specific - ways. Please do not add more uses! */ -extern void *deprecated_insert_raw_breakpoint (struct gdbarch *, - struct address_space *, - CORE_ADDR); -extern int deprecated_remove_raw_breakpoint (struct gdbarch *, void *); - /* Check if any hardware watchpoints have triggered, according to the target. */ int watchpoints_triggered (struct target_waitstatus *); @@ -1306,7 +1538,17 @@ extern void breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf, const gdb_byte *writebuf_org, ULONGEST memaddr, LONGEST len); -extern int breakpoints_always_inserted_mode (void); +/* Return true if breakpoints should be inserted now. That'll be the + case if either: + + - the target has global breakpoints. + + - "breakpoint always-inserted" is on, and the target has + execution. + + - threads are executing. +*/ +extern int breakpoints_should_be_inserted_now (void); /* Called each time new event from target is processed. Retires previously deleted breakpoint locations that @@ -1314,7 +1556,7 @@ extern int breakpoints_always_inserted_mode (void); extern void breakpoint_retire_moribund (void); /* Set break condition of breakpoint B to EXP. */ -extern void set_breakpoint_condition (struct breakpoint *b, char *exp, +extern void set_breakpoint_condition (struct breakpoint *b, const char *exp, int from_tty); /* Checks if we are catching syscalls or not. @@ -1334,8 +1576,7 @@ 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, - struct get_number_or_range_state *state, - int optional_p); + struct get_number_or_range_state *state); /* Return a vector of all tracepoints currently defined. The vector is newly allocated; the caller should free when done with it. */ @@ -1372,11 +1613,20 @@ extern struct breakpoint *iterate_over_breakpoints (int (*) (struct breakpoint * have been inlined. */ extern int pc_at_non_inline_function (struct address_space *aspace, - CORE_ADDR pc); + CORE_ADDR pc, + const struct target_waitstatus *ws); extern int user_breakpoint_p (struct breakpoint *); /* Attempt to determine architecture of location identified by SAL. */ extern struct gdbarch *get_sal_arch (struct symtab_and_line sal); +extern void breakpoint_free_objfile (struct objfile *objfile); + +extern char *ep_parse_optional_if_clause (char **arg); + +/* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" to + UIOUT iff debugging multiple threads. */ +extern void maybe_print_thread_hit_breakpoint (struct ui_out *uiout); + #endif /* !defined (BREAKPOINT_H) */