X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fbreakpoint.h;h=94d93852d3599558c5e3c86c2dcc7c5fff2ca1a2;hb=607685ecee1015d6c37e0d800d40453dc0aadc8c;hp=438f347fae93455f346051ff8fe472d5ab77541a;hpb=36dfb11c8b13be20baf34ea4ba772255c605e0ed;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h index 438f347fae..94d93852d3 100644 --- a/gdb/breakpoint.h +++ b/gdb/breakpoint.h @@ -1,7 +1,5 @@ /* Data structures associated with breakpoints in GDB. - Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, - 2002, 2003, 2004, 2007, 2008, 2009, 2010, 2011 - Free Software Foundation, Inc. + Copyright (C) 1992-2015 Free Software Foundation, Inc. This file is part of GDB. @@ -24,14 +22,21 @@ #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; /* 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 @@ -42,18 +47,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 */ @@ -63,6 +63,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, @@ -92,14 +98,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 @@ -153,6 +153,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, @@ -186,20 +193,6 @@ enum enable_state automatically enabled and reset when the call "lands" (either completes, or stops at another eventpoint). */ - bp_startup_disabled, /* The eventpoint has been disabled during - inferior startup. This is necessary on - some targets where the main executable - will get relocated during startup, making - breakpoint addresses invalid. The - eventpoint will be automatically enabled - and reset once inferior startup is - complete. */ - 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. */ }; @@ -214,15 +207,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 @@ -230,13 +224,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; @@ -257,6 +254,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 @@ -323,6 +332,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. */ @@ -334,6 +370,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 @@ -387,6 +430,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. */ @@ -405,6 +457,38 @@ struct bp_location This variable keeps a number of events still to go, when it becomes 0 this location is retired. */ int events_till_retirement; + + /* 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; + + /* Symtab which was used to place this location. This is used + to find the corresponding source file name. */ + + 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, @@ -438,9 +522,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. */ @@ -484,6 +573,45 @@ 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 address string, storing the result in linespec_result. + + For an explanation about the arguments, see the function + `create_sals_from_address_default'. + + This function is called inside `create_breakpoint'. */ + void (*create_sals_from_address) (char **, struct linespec_result *, + enum bptype, char *, char **); + + /* 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 address string (second parameter), this method decodes it + and provides the SAL locations related to it. For ordinary breakpoints, + it calls `decode_line_full'. + + This function is called inside `addr_string_to_sals'. */ + void (*decode_linespec) (struct breakpoint *, char **, + struct symtabs_and_lines *); + + /* 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 @@ -508,9 +636,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); @@ -552,14 +677,6 @@ struct breakpoint /* Location(s) associated with this high-level breakpoint. */ struct bp_location *loc; - /* Line number of this address. */ - - int line_number; - - /* Source file name of this address. */ - - char *source_file; - /* Non-zero means a silent breakpoint (don't print frame info if we stop here). */ unsigned char silent; @@ -568,6 +685,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; @@ -575,12 +697,19 @@ struct breakpoint equals this. */ struct frame_id frame_id; - /* The program space used to set the breakpoint. */ + /* The program space used to set the breakpoint. This is only set + for breakpoints which are specific to a program space; for + non-thread-specific ordinary breakpoints this is NULL. */ struct program_space *pspace; /* String we used to set the breakpoint (malloc'd). */ char *addr_string; + /* 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 the end of the range (malloc'd). */ char *addr_string_range_end; @@ -594,8 +723,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 @@ -627,8 +758,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 @@ -650,12 +784,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. */ @@ -664,6 +798,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. */ @@ -686,6 +825,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); @@ -744,7 +902,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). @@ -841,37 +1000,16 @@ 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); /* 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); @@ -993,6 +1131,11 @@ 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); @@ -1006,14 +1149,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); @@ -1049,6 +1213,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); @@ -1067,7 +1235,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); @@ -1081,10 +1252,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); @@ -1097,8 +1266,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 @@ -1108,16 +1283,27 @@ extern void extern void install_breakpoint (int internal, struct breakpoint *b, int update_gll); +/* 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 + }; + extern int create_breakpoint (struct gdbarch *gdbarch, char *arg, char *cond_string, int thread, - int parse_condition_and_thread, + char *extra_string, + int parse_arg, 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); @@ -1158,7 +1344,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 @@ -1169,6 +1355,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); @@ -1250,14 +1442,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); @@ -1265,44 +1462,60 @@ extern void remove_jit_event_breakpoints (void); extern void remove_solib_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 remove_thread_event_breakpoints (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 *); -/* Update BUF, which is LEN bytes read from the target address MEMADDR, - by replacing any memory breakpoints with their shadowed contents. */ -void breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr, - LONGEST len); +/* Helper for transparent breakpoint hiding for memory read and write + routines. -extern int breakpoints_always_inserted_mode (void); + Update one of READBUF or WRITEBUF with either the shadows + (READBUF), or the breakpoint instructions (WRITEBUF) of inserted + breakpoints at the memory range defined by MEMADDR and extending + for LEN bytes. If writing, then WRITEBUF is a copy of WRITEBUF_ORG + on entry.*/ +extern void breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf, + const gdb_byte *writebuf_org, + ULONGEST memaddr, LONGEST len); + +/* 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 @@ -1310,7 +1523,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. @@ -1330,8 +1543,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. */ @@ -1368,11 +1580,16 @@ 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); + #endif /* !defined (BREAKPOINT_H) */