/* Everything about breakpoints, for GDB.
- Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1986-2012 Free Software Foundation, Inc.
This file is part of GDB.
#include "target.h"
#include "language.h"
#include "gdb_string.h"
-#include "demangle.h"
+#include "gdb-demangle.h"
#include "filenames.h"
#include "annotate.h"
#include "symfile.h"
#include "memattr.h"
#include "ada-lang.h"
#include "top.h"
-#include "wrapper.h"
#include "valprint.h"
#include "jit.h"
#include "xml-syscall.h"
#include "parser-defs.h"
#include "cli/cli-utils.h"
#include "continuations.h"
+#include "stack.h"
+#include "skip.h"
+#include "record.h"
+#include "gdb_regex.h"
+#include "ax-gdb.h"
/* readline include files */
#include "readline/readline.h"
static void enable_once_command (char *, int);
+static void enable_count_command (char *, int);
+
static void disable_command (char *, int);
static void enable_command (char *, int);
static void breakpoint_re_set_default (struct breakpoint *);
+static void create_sals_from_address_default (char **,
+ struct linespec_result *,
+ enum bptype, char *,
+ char **);
+
+static void create_breakpoints_sal_default (struct gdbarch *,
+ struct linespec_result *,
+ struct linespec_sals *,
+ char *, enum bptype,
+ enum bpdisp, int, int,
+ int,
+ const struct breakpoint_ops *,
+ int, int, int);
+
+static void decode_linespec_default (struct breakpoint *, char **,
+ struct symtabs_and_lines *);
+
static void clear_command (char *, int);
static void catch_command (char *, int);
static struct breakpoint *set_raw_breakpoint_without_location (struct gdbarch *,
enum bptype,
const struct breakpoint_ops *);
+static struct bp_location *add_location_to_breakpoint (struct breakpoint *,
+ const struct symtab_and_line *);
+
/* This function is used in gdbtk sources and thus can not be made
static. */
struct breakpoint *set_raw_breakpoint (struct gdbarch *gdbarch,
static int hw_breakpoint_used_count (void);
-static int hw_watchpoint_used_count (enum bptype, int *);
+static int hw_watchpoint_use_count (struct breakpoint *);
+
+static int hw_watchpoint_used_count_others (struct breakpoint *except,
+ enum bptype type,
+ int *other_type_used);
static void hbreak_command (char *, int);
static void thbreak_command (char *, int);
-static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp);
+static void enable_breakpoint_disp (struct breakpoint *, enum bpdisp,
+ int count);
static void stop_command (char *arg, int from_tty);
static int is_masked_watchpoint (const struct breakpoint *b);
-/* Assuming we're creating a static tracepoint, does S look like a
- static tracepoint marker spec ("-m MARKER_ID")? */
-#define is_marker_spec(s) \
- (s != NULL && strncmp (s, "-m", 2) == 0 && ((s)[2] == ' ' || (s)[2] == '\t'))
+static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
+
+/* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
+ otherwise. */
+
+static int strace_marker_p (struct breakpoint *b);
+
+static void init_catchpoint (struct breakpoint *b,
+ struct gdbarch *gdbarch, int tempflag,
+ char *cond_string,
+ const struct breakpoint_ops *ops);
/* The abstract base class all breakpoint_ops structures inherit
from. */
static const char always_inserted_auto[] = "auto";
static const char always_inserted_on[] = "on";
static const char always_inserted_off[] = "off";
-static const char *always_inserted_enums[] = {
+static const char *const always_inserted_enums[] = {
always_inserted_auto,
always_inserted_off,
always_inserted_on,
int
breakpoints_always_inserted_mode (void)
{
- return (always_inserted_mode == always_inserted_on
- || (always_inserted_mode == always_inserted_auto && non_stop));
+ return ((always_inserted_mode == always_inserted_on
+ || (always_inserted_mode == always_inserted_auto && non_stop))
+ && !RECORD_IS_USED);
+}
+
+static const char condition_evaluation_both[] = "host or target";
+
+/* Modes for breakpoint condition evaluation. */
+static const char condition_evaluation_auto[] = "auto";
+static const char condition_evaluation_host[] = "host";
+static const char condition_evaluation_target[] = "target";
+static const char *const condition_evaluation_enums[] = {
+ condition_evaluation_auto,
+ condition_evaluation_host,
+ condition_evaluation_target,
+ NULL
+};
+
+/* Global that holds the current mode for breakpoint condition evaluation. */
+static const char *condition_evaluation_mode_1 = condition_evaluation_auto;
+
+/* Global that we use to display information to the user (gets its value from
+ condition_evaluation_mode_1. */
+static const char *condition_evaluation_mode = condition_evaluation_auto;
+
+/* Translate a condition evaluation mode MODE into either "host"
+ or "target". This is used mostly to translate from "auto" to the
+ real setting that is being used. It returns the translated
+ evaluation mode. */
+
+static const char *
+translate_condition_evaluation_mode (const char *mode)
+{
+ if (mode == condition_evaluation_auto)
+ {
+ if (target_supports_evaluation_of_breakpoint_conditions ())
+ return condition_evaluation_target;
+ else
+ return condition_evaluation_host;
+ }
+ else
+ return mode;
+}
+
+/* Discovers what condition_evaluation_auto translates to. */
+
+static const char *
+breakpoint_condition_evaluation_mode (void)
+{
+ return translate_condition_evaluation_mode (condition_evaluation_mode);
+}
+
+/* Return true if GDB should evaluate breakpoint conditions or false
+ otherwise. */
+
+static int
+gdb_evaluates_breakpoint_condition_p (void)
+{
+ const char *mode = breakpoint_condition_evaluation_mode ();
+
+ return (mode == condition_evaluation_host);
}
void _initialize_breakpoint (void);
BP_TMP < bp_location + bp_location_count && (B = *BP_TMP); \
BP_TMP++)
+/* Iterates through locations with address ADDRESS for the currently selected
+ program space. BP_LOCP_TMP points to each object. BP_LOCP_START points
+ to where the loop should start from.
+ If BP_LOCP_START is a NULL pointer, the macro automatically seeks the
+ appropriate location to start with. */
+
+#define ALL_BP_LOCATIONS_AT_ADDR(BP_LOCP_TMP, BP_LOCP_START, ADDRESS) \
+ for (BP_LOCP_START = BP_LOCP_START == NULL ? get_first_locp_gte_addr (ADDRESS) : BP_LOCP_START, \
+ BP_LOCP_TMP = BP_LOCP_START; \
+ BP_LOCP_START \
+ && (BP_LOCP_TMP < bp_location + bp_location_count \
+ && (*BP_LOCP_TMP)->address == ADDRESS); \
+ BP_LOCP_TMP++)
+
/* Iterator for tracepoints only. */
#define ALL_TRACEPOINTS(B) \
return make_cleanup (do_cleanup_counted_command_line, cmdp);
}
-/* Default address, symtab and line to put a breakpoint at
- for "break" command with no arg.
- If default_breakpoint_valid is zero, the other three are
- not valid, and "break" with no arg is an error.
-
- This set by print_stack_frame, which calls set_default_breakpoint. */
-
-int default_breakpoint_valid;
-CORE_ADDR default_breakpoint_address;
-struct symtab *default_breakpoint_symtab;
-int default_breakpoint_line;
-struct program_space *default_breakpoint_pspace;
-
\f
/* Return the breakpoint with the specified number, or NULL
if the number does not refer to an existing breakpoint. */
\f
+/* Mark locations as "conditions have changed" in case the target supports
+ evaluating conditions on its side. */
+
+static void
+mark_breakpoint_modified (struct breakpoint *b)
+{
+ struct bp_location *loc;
+
+ /* This is only meaningful if the target is
+ evaluating conditions and if the user has
+ opted for condition evaluation on the target's
+ side. */
+ if (gdb_evaluates_breakpoint_condition_p ()
+ || !target_supports_evaluation_of_breakpoint_conditions ())
+ return;
+
+ if (!is_breakpoint (b))
+ return;
+
+ for (loc = b->loc; loc; loc = loc->next)
+ loc->condition_changed = condition_modified;
+}
+
+/* Mark location as "conditions have changed" in case the target supports
+ evaluating conditions on its side. */
+
+static void
+mark_breakpoint_location_modified (struct bp_location *loc)
+{
+ /* This is only meaningful if the target is
+ evaluating conditions and if the user has
+ opted for condition evaluation on the target's
+ side. */
+ if (gdb_evaluates_breakpoint_condition_p ()
+ || !target_supports_evaluation_of_breakpoint_conditions ())
+
+ return;
+
+ if (!is_breakpoint (loc->owner))
+ return;
+
+ loc->condition_changed = condition_modified;
+}
+
+/* Sets the condition-evaluation mode using the static global
+ condition_evaluation_mode. */
+
+static void
+set_condition_evaluation_mode (char *args, int from_tty,
+ struct cmd_list_element *c)
+{
+ struct breakpoint *b;
+ const char *old_mode, *new_mode;
+
+ if ((condition_evaluation_mode_1 == condition_evaluation_target)
+ && !target_supports_evaluation_of_breakpoint_conditions ())
+ {
+ condition_evaluation_mode_1 = condition_evaluation_mode;
+ warning (_("Target does not support breakpoint condition evaluation.\n"
+ "Using host evaluation mode instead."));
+ return;
+ }
+
+ new_mode = translate_condition_evaluation_mode (condition_evaluation_mode_1);
+ old_mode = translate_condition_evaluation_mode (condition_evaluation_mode);
+
+ /* Only update the mode if the user picked a different one. */
+ if (new_mode != old_mode)
+ {
+ struct bp_location *loc, **loc_tmp;
+ /* If the user switched to a different evaluation mode, we
+ need to synch the changes with the target as follows:
+
+ "host" -> "target": Send all (valid) conditions to the target.
+ "target" -> "host": Remove all the conditions from the target.
+ */
+
+ /* Flip the switch. */
+ condition_evaluation_mode = condition_evaluation_mode_1;
+
+ if (new_mode == condition_evaluation_target)
+ {
+ /* Mark everything modified and synch conditions with the
+ target. */
+ ALL_BP_LOCATIONS (loc, loc_tmp)
+ mark_breakpoint_location_modified (loc);
+ }
+ else
+ {
+ /* Manually mark non-duplicate locations to synch conditions
+ with the target. We do this to remove all the conditions the
+ target knows about. */
+ ALL_BP_LOCATIONS (loc, loc_tmp)
+ if (is_breakpoint (loc->owner) && loc->inserted)
+ loc->needs_update = 1;
+ }
+
+ /* Do the update. */
+ update_global_location_list (1);
+ }
+
+ return;
+}
+
+/* Shows the current mode of breakpoint condition evaluation. Explicitly shows
+ what "auto" is translating to. */
+
+static void
+show_condition_evaluation_mode (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ if (condition_evaluation_mode == condition_evaluation_auto)
+ fprintf_filtered (file,
+ _("Breakpoint condition evaluation "
+ "mode is %s (currently %s).\n"),
+ value,
+ breakpoint_condition_evaluation_mode ());
+ else
+ fprintf_filtered (file, _("Breakpoint condition evaluation mode is %s.\n"),
+ value);
+}
+
+/* A comparison function for bp_location AP and BP that is used by
+ bsearch. This comparison function only cares about addresses, unlike
+ the more general bp_location_compare function. */
+
+static int
+bp_location_compare_addrs (const void *ap, const void *bp)
+{
+ struct bp_location *a = *(void **) ap;
+ struct bp_location *b = *(void **) bp;
+
+ if (a->address == b->address)
+ return 0;
+ else
+ return ((a->address > b->address) - (a->address < b->address));
+}
+
+/* Helper function to skip all bp_locations with addresses
+ less than ADDRESS. It returns the first bp_location that
+ is greater than or equal to ADDRESS. If none is found, just
+ return NULL. */
+
+static struct bp_location **
+get_first_locp_gte_addr (CORE_ADDR address)
+{
+ struct bp_location dummy_loc;
+ struct bp_location *dummy_locp = &dummy_loc;
+ struct bp_location **locp_found = NULL;
+
+ /* Initialize the dummy location's address field. */
+ memset (&dummy_loc, 0, sizeof (struct bp_location));
+ dummy_loc.address = address;
+
+ /* Find a close match to the first location at ADDRESS. */
+ locp_found = bsearch (&dummy_locp, bp_location, bp_location_count,
+ sizeof (struct bp_location **),
+ bp_location_compare_addrs);
+
+ /* Nothing was found, nothing left to do. */
+ if (locp_found == NULL)
+ return NULL;
+
+ /* We may have found a location that is at ADDRESS but is not the first in the
+ location's list. Go backwards (if possible) and locate the first one. */
+ while ((locp_found - 1) >= bp_location
+ && (*(locp_found - 1))->address == address)
+ locp_found--;
+
+ return locp_found;
+}
+
void
set_breakpoint_condition (struct breakpoint *b, char *exp,
int from_tty)
{
xfree (loc->cond);
loc->cond = NULL;
+
+ /* No need to free the condition agent expression
+ bytecode (if we have one). We will handle this
+ when we go through update_global_location_list. */
}
}
}
}
}
+ mark_breakpoint_modified (b);
+
breakpoints_changed ();
observer_notify_breakpoint_modified (b);
}
error (_("Cannot set a condition where a Python 'stop' "
"method has been defined in the breakpoint."));
set_breakpoint_condition (b, p, from_tty);
+
+ if (is_breakpoint (b))
+ update_global_location_list (1);
+
return;
}
bl->address + bp_location_shadow_len_after_address_max <= memaddr */
void
-breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr, LONGEST len)
+breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
+ const gdb_byte *writebuf_org,
+ ULONGEST memaddr, LONGEST len)
{
/* Left boundary, right boundary and median element of our binary
search. */
bp_size -= (bp_addr + bp_size) - (memaddr + len);
}
- memcpy (buf + bp_addr - memaddr,
- bl->target_info.shadow_contents + bptoffset, bp_size);
+ if (readbuf != NULL)
+ {
+ /* Update the read buffer with this inserted breakpoint's
+ shadow. */
+ memcpy (readbuf + bp_addr - memaddr,
+ bl->target_info.shadow_contents + bptoffset, bp_size);
+ }
+ else
+ {
+ struct gdbarch *gdbarch = bl->gdbarch;
+ const unsigned char *bp;
+ CORE_ADDR placed_address = bl->target_info.placed_address;
+ unsigned placed_size = bl->target_info.placed_size;
+
+ /* Update the shadow with what we want to write to memory. */
+ memcpy (bl->target_info.shadow_contents + bptoffset,
+ writebuf_org + bp_addr - memaddr, bp_size);
+
+ /* Determine appropriate breakpoint contents and size for this
+ address. */
+ bp = gdbarch_breakpoint_from_pc (gdbarch, &placed_address, &placed_size);
+
+ /* Update the final write buffer with this inserted
+ breakpoint's INSN. */
+ memcpy (writebuf + bp_addr - memaddr, bp + bptoffset, bp_size);
+ }
}
}
\f
+/* Return true if BPT is either a software breakpoint or a hardware
+ breakpoint. */
+
+int
+is_breakpoint (const struct breakpoint *bpt)
+{
+ return (bpt->type == bp_breakpoint
+ || bpt->type == bp_hardware_breakpoint);
+}
+
/* Return true if BPT is of any hardware watchpoint kind. */
static int
static int
watchpoint_in_thread_scope (struct watchpoint *b)
{
- return (ptid_equal (b->watchpoint_thread, null_ptid)
- || (ptid_equal (inferior_ptid, b->watchpoint_thread)
- && !is_executing (inferior_ptid)));
+ return (b->base.pspace == current_program_space
+ && (ptid_equal (b->watchpoint_thread, null_ptid)
+ || (ptid_equal (inferior_ptid, b->watchpoint_thread)
+ && !is_executing (inferior_ptid))));
}
/* Set watchpoint B to disp_del_at_next_stop, even including its possible
if (reg_cnt)
{
int i, target_resources_ok, other_type_used;
+ enum bptype type;
/* Use an exact watchpoint when there's only one memory region to be
watched, and only one debug register is needed to watch it. */
/* We need to determine how many resources are already
used for all other hardware watchpoints plus this one
to see if we still have enough resources to also fit
- this watchpoint in as well. To guarantee the
- hw_watchpoint_used_count call below counts this
- watchpoint, make sure that it is marked as a hardware
- watchpoint. */
- if (b->base.type == bp_watchpoint)
- b->base.type = bp_hardware_watchpoint;
-
- i = hw_watchpoint_used_count (b->base.type, &other_type_used);
- target_resources_ok = target_can_use_hardware_watchpoint
- (b->base.type, i, other_type_used);
+ this watchpoint in as well. */
+
+ /* If this is a software watchpoint, we try to turn it
+ to a hardware one -- count resources as if B was of
+ hardware watchpoint type. */
+ type = b->base.type;
+ if (type == bp_watchpoint)
+ type = bp_hardware_watchpoint;
+
+ /* This watchpoint may or may not have been placed on
+ the list yet at this point (it won't be in the list
+ if we're trying to create it for the first time,
+ through watch_command), so always account for it
+ manually. */
+
+ /* Count resources used by all watchpoints except B. */
+ i = hw_watchpoint_used_count_others (&b->base, type, &other_type_used);
+
+ /* Add in the resources needed for B. */
+ i += hw_watchpoint_use_count (&b->base);
+
+ target_resources_ok
+ = target_can_use_hardware_watchpoint (type, i, other_type_used);
if (target_resources_ok <= 0)
{
int sw_mode = b->base.ops->works_in_software_mode (&b->base);
else if (target_resources_ok < 0 && !sw_mode)
error (_("There are not enough available hardware "
"resources for this watchpoint."));
- else
- b->base.type = bp_watchpoint;
+
+ /* Downgrade to software watchpoint. */
+ b->base.type = bp_watchpoint;
+ }
+ else
+ {
+ /* If this was a software watchpoint, we've just
+ found we have enough resources to turn it to a
+ hardware watchpoint. Otherwise, this is a
+ nop. */
+ b->base.type = type;
}
}
else if (!b->base.ops->works_in_software_mode (&b->base))
/* Returns 1 iff breakpoint location should be
- inserted in the inferior. */
+ inserted in the inferior. We don't differentiate the type of BL's owner
+ (breakpoint vs. tracepoint), although insert_location in tracepoint's
+ breakpoint_ops is not defined, because in insert_bp_location,
+ tracepoint's insert_location will not be called. */
static int
should_be_inserted (struct bp_location *bl)
{
if (!bl->enabled || bl->shlib_disabled || bl->duplicate)
return 0;
+ if (user_breakpoint_p (bl->owner) && bl->pspace->executing_startup)
+ return 0;
+
/* This is set for example, when we're attached to the parent of a
vfork, and have detached from the child. The child is running
free, and we expect it to do an exec or exit, at which point the
if (bl->pspace->breakpoints_not_allowed)
return 0;
- /* Tracepoints are inserted by the target at a time of its choosing,
- not by us. */
- if (is_tracepoint (bl->owner))
- return 0;
-
return 1;
}
return result;
}
+/* Parses a conditional described by an expression COND into an
+ agent expression bytecode suitable for evaluation
+ by the bytecode interpreter. Return NULL if there was
+ any error during parsing. */
+
+static struct agent_expr *
+parse_cond_to_aexpr (CORE_ADDR scope, struct expression *cond)
+{
+ struct agent_expr *aexpr = NULL;
+ struct cleanup *old_chain = NULL;
+ volatile struct gdb_exception ex;
+
+ if (!cond)
+ return NULL;
+
+ /* We don't want to stop processing, so catch any errors
+ that may show up. */
+ TRY_CATCH (ex, RETURN_MASK_ERROR)
+ {
+ aexpr = gen_eval_for_expr (scope, cond);
+ }
+
+ if (ex.reason < 0)
+ {
+ /* If we got here, it means the condition could not be parsed to a valid
+ bytecode expression and thus can't be evaluated on the target's side.
+ It's no use iterating through the conditions. */
+ return NULL;
+ }
+
+ /* We have a valid agent expression. */
+ return aexpr;
+}
+
+/* Based on location BL, create a list of breakpoint conditions to be
+ passed on to the target. If we have duplicated locations with different
+ conditions, we will add such conditions to the list. The idea is that the
+ target will evaluate the list of conditions and will only notify GDB when
+ one of them is true. */
+
+static void
+build_target_condition_list (struct bp_location *bl)
+{
+ struct bp_location **locp = NULL, **loc2p;
+ int null_condition_or_parse_error = 0;
+ int modified = bl->needs_update;
+ struct bp_location *loc;
+
+ /* This is only meaningful if the target is
+ evaluating conditions and if the user has
+ opted for condition evaluation on the target's
+ side. */
+ if (gdb_evaluates_breakpoint_condition_p ()
+ || !target_supports_evaluation_of_breakpoint_conditions ())
+ return;
+
+ /* Do a first pass to check for locations with no assigned
+ conditions or conditions that fail to parse to a valid agent expression
+ bytecode. If any of these happen, then it's no use to send conditions
+ to the target since this location will always trigger and generate a
+ response back to GDB. */
+ ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
+ {
+ loc = (*loc2p);
+ if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
+ {
+ if (modified)
+ {
+ struct agent_expr *aexpr;
+
+ /* Re-parse the conditions since something changed. In that
+ case we already freed the condition bytecodes (see
+ force_breakpoint_reinsertion). We just
+ need to parse the condition to bytecodes again. */
+ aexpr = parse_cond_to_aexpr (bl->address, loc->cond);
+ loc->cond_bytecode = aexpr;
+
+ /* Check if we managed to parse the conditional expression
+ correctly. If not, we will not send this condition
+ to the target. */
+ if (aexpr)
+ continue;
+ }
+
+ /* If we have a NULL bytecode expression, it means something
+ went wrong or we have a null condition expression. */
+ if (!loc->cond_bytecode)
+ {
+ null_condition_or_parse_error = 1;
+ break;
+ }
+ }
+ }
+
+ /* If any of these happened, it means we will have to evaluate the conditions
+ for the location's address on gdb's side. It is no use keeping bytecodes
+ for all the other duplicate locations, thus we free all of them here.
+
+ This is so we have a finer control over which locations' conditions are
+ being evaluated by GDB or the remote stub. */
+ if (null_condition_or_parse_error)
+ {
+ ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
+ {
+ loc = (*loc2p);
+ if (is_breakpoint (loc->owner) && loc->pspace->num == bl->pspace->num)
+ {
+ /* Only go as far as the first NULL bytecode is
+ located. */
+ if (!loc->cond_bytecode)
+ return;
+
+ free_agent_expr (loc->cond_bytecode);
+ loc->cond_bytecode = NULL;
+ }
+ }
+ }
+
+ /* No NULL conditions or failed bytecode generation. Build a condition list
+ for this location's address. */
+ ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, bl->address)
+ {
+ loc = (*loc2p);
+ if (loc->cond
+ && is_breakpoint (loc->owner)
+ && loc->pspace->num == bl->pspace->num
+ && loc->owner->enable_state == bp_enabled
+ && loc->enabled)
+ /* Add the condition to the vector. This will be used later to send the
+ conditions to the target. */
+ VEC_safe_push (agent_expr_p, bl->target_info.conditions,
+ loc->cond_bytecode);
+ }
+
+ return;
+}
+
/* Insert a low-level "breakpoint" of some type. BL is the breakpoint
location. Any error messages are printed to TMP_ERROR_STREAM; and
DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
{
int val = 0;
- if (!should_be_inserted (bl) || bl->inserted)
+ if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
return 0;
/* Initialize the target-specific information. */
bl->target_info.placed_address_space = bl->pspace->aspace;
bl->target_info.length = bl->length;
+ /* When working with target-side conditions, we must pass all the conditions
+ for the same breakpoint address down to the target since GDB will not
+ insert those locations. With a list of breakpoint conditions, the target
+ can decide when to stop and notify GDB. */
+
+ if (is_breakpoint (bl->owner))
+ {
+ build_target_condition_list (bl);
+ /* Reset the condition modification marker. */
+ bl->needs_update = 0;
+ }
+
if (bl->loc_type == bp_loc_software_breakpoint
|| bl->loc_type == bp_loc_hardware_breakpoint)
{
insert_breakpoint_locations ();
}
+/* This is used when we need to synch breakpoint conditions between GDB and the
+ target. It is the case with deleting and disabling of breakpoints when using
+ always-inserted mode. */
+
+static void
+update_inserted_breakpoint_locations (void)
+{
+ struct bp_location *bl, **blp_tmp;
+ int error_flag = 0;
+ int val = 0;
+ int disabled_breaks = 0;
+ int hw_breakpoint_error = 0;
+
+ struct ui_file *tmp_error_stream = mem_fileopen ();
+ struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_error_stream);
+
+ /* Explicitly mark the warning -- this will only be printed if
+ there was an error. */
+ fprintf_unfiltered (tmp_error_stream, "Warning:\n");
+
+ save_current_space_and_thread ();
+
+ ALL_BP_LOCATIONS (bl, blp_tmp)
+ {
+ /* We only want to update software breakpoints and hardware
+ breakpoints. */
+ if (!is_breakpoint (bl->owner))
+ continue;
+
+ /* We only want to update locations that are already inserted
+ and need updating. This is to avoid unwanted insertion during
+ deletion of breakpoints. */
+ if (!bl->inserted || (bl->inserted && !bl->needs_update))
+ continue;
+
+ switch_to_program_space_and_thread (bl->pspace);
+
+ /* For targets that support global breakpoints, there's no need
+ to select an inferior to insert breakpoint to. In fact, even
+ if we aren't attached to any process yet, we should still
+ insert breakpoints. */
+ if (!gdbarch_has_global_breakpoints (target_gdbarch)
+ && ptid_equal (inferior_ptid, null_ptid))
+ continue;
+
+ val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
+ &hw_breakpoint_error);
+ if (val)
+ error_flag = val;
+ }
+
+ if (error_flag)
+ {
+ target_terminal_ours_for_output ();
+ error_stream (tmp_error_stream);
+ }
+
+ do_cleanups (cleanups);
+}
+
/* Used when starting or continuing the program. */
static void
{
struct breakpoint *bpt;
struct bp_location *bl, **blp_tmp;
- int error = 0;
+ int error_flag = 0;
int val = 0;
int disabled_breaks = 0;
int hw_breakpoint_error = 0;
ALL_BP_LOCATIONS (bl, blp_tmp)
{
- if (!should_be_inserted (bl) || bl->inserted)
+ if (!should_be_inserted (bl) || (bl->inserted && !bl->needs_update))
continue;
/* There is no point inserting thread-specific breakpoints if
val = insert_bp_location (bl, tmp_error_stream, &disabled_breaks,
&hw_breakpoint_error);
if (val)
- error = val;
+ error_flag = val;
}
/* If we failed to insert all locations of a watchpoint, remove
fprintf_unfiltered (tmp_error_stream,
"Could not insert hardware watchpoint %d.\n",
bpt->number);
- error = -1;
+ error_flag = -1;
}
}
- if (error)
+ if (error_flag)
{
/* If a hardware breakpoint or watchpoint was inserted, add a
message about possibly exhausted resources. */
ALL_BP_LOCATIONS (bl, blp_tmp)
{
- if (bl->inserted)
+ if (bl->inserted && !is_tracepoint (bl->owner))
val |= remove_breakpoint (bl, mark_uninserted);
}
return val;
/* Install a master breakpoint on the unwinder's debug hook. */
-void
+static void
create_exception_master_breakpoint (void)
{
struct objfile *objfile;
(gdb) tar rem :9999 # remote Windows gdbserver.
*/
+ case bp_step_resume:
+
+ /* Also remove step-resume breakpoints. */
+
delete_breakpoint (b);
break;
return 1;
}
-/* Modify BS so that the actions will not be performed. */
+/* See breakpoint.h. */
void
-bpstat_clear_actions (bpstat bs)
+bpstat_clear_actions (void)
{
- for (; bs != NULL; bs = bs->next)
+ struct thread_info *tp;
+ bpstat bs;
+
+ if (ptid_equal (inferior_ptid, null_ptid))
+ return;
+
+ tp = find_thread_ptid (inferior_ptid);
+ if (tp == NULL)
+ return;
+
+ for (bs = tp->control.stop_bpstat; bs != NULL; bs = bs->next)
{
decref_counted_command_line (&bs->commands);
- bs->commands_left = NULL;
+
if (bs->old_val != NULL)
{
value_free (bs->old_val);
executing_breakpoint_commands = 0;
}
+/* Return non-zero iff CMD as the first line of a command sequence is `silent'
+ or its equivalent. */
+
+static int
+command_line_is_silent (struct command_line *cmd)
+{
+ return cmd && (strcmp ("silent", cmd->line) == 0
+ || (xdb_commands && strcmp ("Q", cmd->line) == 0));
+}
+
/* Execute all the commands associated with all the breakpoints at
this location. Any of these commands could cause the process to
proceed beyond this point, etc. We look out for such changes by
the tree when we're done. */
ccmd = bs->commands;
bs->commands = NULL;
- this_cmd_tree_chain
- = make_cleanup_decref_counted_command_line (&ccmd);
- cmd = bs->commands_left;
- bs->commands_left = NULL;
+ this_cmd_tree_chain = make_cleanup_decref_counted_command_line (&ccmd);
+ cmd = ccmd ? ccmd->commands : NULL;
+ if (command_line_is_silent (cmd))
+ {
+ /* The action has been already done by bpstat_stop_status. */
+ cmd = cmd->next;
+ }
while (cmd != NULL)
{
void
bpstat_do_actions (void)
{
+ struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup ();
+
/* Do any commands attached to breakpoint we are stopped at. */
while (!ptid_equal (inferior_ptid, null_ptid)
&& target_has_execution
indicate the inferior was not resumed. */
if (!bpstat_do_actions_1 (&inferior_thread ()->control.stop_bpstat))
break;
+
+ discard_cleanups (cleanup_if_error);
}
/* Print out the (old or new) value associated with a watchpoint. */
}
}
+/* A helper function that prints a shared library stopped event. */
+
+static void
+print_solib_event (int is_catchpoint)
+{
+ int any_deleted
+ = !VEC_empty (char_ptr, current_program_space->deleted_solibs);
+ int any_added
+ = !VEC_empty (so_list_ptr, current_program_space->added_solibs);
+
+ if (!is_catchpoint)
+ {
+ if (any_added || any_deleted)
+ ui_out_text (current_uiout,
+ _("Stopped due to shared library event:\n"));
+ else
+ ui_out_text (current_uiout,
+ _("Stopped due to shared library event (no "
+ "libraries added or removed)\n"));
+ }
+
+ if (ui_out_is_mi_like_p (current_uiout))
+ ui_out_field_string (current_uiout, "reason",
+ async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT));
+
+ if (any_deleted)
+ {
+ struct cleanup *cleanup;
+ char *name;
+ int ix;
+
+ ui_out_text (current_uiout, _(" Inferior unloaded "));
+ cleanup = make_cleanup_ui_out_list_begin_end (current_uiout,
+ "removed");
+ for (ix = 0;
+ VEC_iterate (char_ptr, current_program_space->deleted_solibs,
+ ix, name);
+ ++ix)
+ {
+ if (ix > 0)
+ ui_out_text (current_uiout, " ");
+ ui_out_field_string (current_uiout, "library", name);
+ ui_out_text (current_uiout, "\n");
+ }
+
+ do_cleanups (cleanup);
+ }
+
+ if (any_added)
+ {
+ struct so_list *iter;
+ int ix;
+ struct cleanup *cleanup;
+
+ ui_out_text (current_uiout, _(" Inferior loaded "));
+ cleanup = make_cleanup_ui_out_list_begin_end (current_uiout,
+ "added");
+ for (ix = 0;
+ VEC_iterate (so_list_ptr, current_program_space->added_solibs,
+ ix, iter);
+ ++ix)
+ {
+ if (ix > 0)
+ ui_out_text (current_uiout, " ");
+ ui_out_field_string (current_uiout, "library", iter->so_name);
+ ui_out_text (current_uiout, "\n");
+ }
+
+ do_cleanups (cleanup);
+ }
+}
+
/* Print a message indicating what happened. This is called from
normal_stop(). The input to this routine is the head of the bpstat
- list - a list of the eventpoints that caused this stop. This
+ list - a list of the eventpoints that caused this stop. KIND is
+ the target_waitkind for the stopping event. This
routine calls the generic print routine for printing a message
about reasons for stopping. This will print (for example) the
"Breakpoint n," part of the output. The return value of this
further info to be printed. */
enum print_stop_action
-bpstat_print (bpstat bs)
+bpstat_print (bpstat bs, int kind)
{
int val;
return val;
}
+ /* If we had hit a shared library event breakpoint,
+ print_bp_stop_message would print out this message. If we hit an
+ OS-level shared library event, do the same thing. */
+ if (kind == TARGET_WAITKIND_LOADED)
+ {
+ print_solib_event (0);
+ return PRINT_NOTHING;
+ }
+
/* We reached the end of the chain, or we got a null BS to start
with and nothing was printed. */
return PRINT_UNKNOWN;
incref_bp_location (bl);
/* If the condition is false, etc., don't do the commands. */
bs->commands = NULL;
- bs->commands_left = NULL;
bs->old_val = NULL;
bs->print_it = print_it_normal;
return bs;
}
else
{
+ struct ui_out *uiout = current_uiout;
+
/* This seems like the only logical thing to do because
if we temporarily ignored the watchpoint, then when
we reenter the block in which it is valid it contains
static int
bpstat_check_location (const struct bp_location *bl,
- struct address_space *aspace, CORE_ADDR bp_addr)
+ struct address_space *aspace, CORE_ADDR bp_addr,
+ const struct target_waitstatus *ws)
{
struct breakpoint *b = bl->owner;
/* BL is from an existing breakpoint. */
gdb_assert (b != NULL);
- return b->ops->breakpoint_hit (bl, aspace, bp_addr);
+ return b->ops->breakpoint_hit (bl, aspace, bp_addr, ws);
}
/* Determine if the watched values have actually changed, and we
b = bs->breakpoint_at;
gdb_assert (b != NULL);
+ /* Even if the target evaluated the condition on its end and notified GDB, we
+ need to do so again since GDB does not know if we stopped due to a
+ breakpoint or a single step breakpoint. */
+
if (frame_id_p (b->frame_id)
&& !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
bs->stop = 0;
bpstat
bpstat_stop_status (struct address_space *aspace,
- CORE_ADDR bp_addr, ptid_t ptid)
+ CORE_ADDR bp_addr, ptid_t ptid,
+ const struct target_waitstatus *ws)
{
struct breakpoint *b = NULL;
struct bp_location *bl;
if (bl->shlib_disabled)
continue;
- if (!bpstat_check_location (bl, aspace, bp_addr))
+ if (!bpstat_check_location (bl, aspace, bp_addr, ws))
continue;
/* Come here if it's a watchpoint, or if the break address
}
}
+ /* A bit of special processing for shlib breakpoints. We need to
+ process solib loading here, so that the lists of loaded and
+ unloaded libraries are correct before we handle "catch load" and
+ "catch unload". */
+ for (bs = bs_head; bs != NULL; bs = bs->next)
+ {
+ if (bs->breakpoint_at && bs->breakpoint_at->type == bp_shlib_event)
+ {
+ handle_solib_event ();
+ break;
+ }
+ }
+
/* Now go through the locations that caused the target to stop, and
check whether we're interested in reporting this stop to higher
layers, or whether we should resume the target transparently. */
/* We will stop here. */
if (b->disposition == disp_disable)
{
- if (b->enable_state != bp_permanent)
+ --(b->enable_count);
+ if (b->enable_count <= 0
+ && b->enable_state != bp_permanent)
b->enable_state = bp_disabled;
removed_any = 1;
}
bs->print = 0;
bs->commands = b->commands;
incref_counted_command_line (bs->commands);
- bs->commands_left = bs->commands ? bs->commands->commands : NULL;
- if (bs->commands_left
- && (strcmp ("silent", bs->commands_left->line) == 0
- || (xdb_commands
- && strcmp ("Q",
- bs->commands_left->line) == 0)))
- {
- bs->commands_left = bs->commands_left->next;
- bs->print = 0;
- }
+ if (command_line_is_silent (bs->commands
+ ? bs->commands->commands : NULL))
+ bs->print = 0;
}
- /* Print nothing for this entry if we don't stop or don't print. */
- if (bs->stop == 0 || bs->print == 0)
- bs->print_it = print_it_noop;
}
+
+ /* Print nothing for this entry if we don't stop or don't
+ print. */
+ if (!bs->stop || !bs->print)
+ bs->print_it = print_it_noop;
}
/* If we aren't stopping, the value of some hardware watchpoint may
target_terminal_inferior ();
}
+/* Handle an solib event by calling solib_add. */
+
+void
+handle_solib_event (void)
+{
+ clear_program_space_solib_cache (current_inferior ()->pspace);
+
+ /* Check for any newly added shared libraries if we're supposed to
+ be adding them automatically. Switch terminal for any messages
+ produced by breakpoint_re_set. */
+ target_terminal_ours_for_output ();
+#ifdef SOLIB_ADD
+ SOLIB_ADD (NULL, 0, ¤t_target, auto_solib_add);
+#else
+ solib_add (NULL, 0, ¤t_target, auto_solib_add);
+#endif
+ target_terminal_inferior ();
+}
+
/* Prepare WHAT final decision for infrun. */
/* Decide what infrun needs to do with this bpstat. */
bpstat_what (bpstat bs_head)
{
struct bpstat_what retval;
- /* We need to defer calling `solib_add', as adding new symbols
- resets breakpoints, which in turn deletes breakpoint locations,
- and hence may clear unprocessed entries in the BS chain. */
- int shlib_event = 0;
int jit_event = 0;
bpstat bs;
case bp_hardware_breakpoint:
case bp_until:
case bp_finish:
+ case bp_shlib_event:
if (bs->stop)
{
if (bs->print)
This requires no further action. */
}
break;
- case bp_shlib_event:
- shlib_event = 1;
-
- /* If requested, stop when the dynamic linker notifies GDB
- of events. This allows the user to get control and place
- breakpoints in initializer routines for dynamically
- loaded objects (among other things). */
- if (stop_on_solib_events)
- this_action = BPSTAT_WHAT_STOP_NOISY;
- else
- this_action = BPSTAT_WHAT_SINGLE;
- break;
case bp_jit_event:
jit_event = 1;
this_action = BPSTAT_WHAT_SINGLE;
/* These operations may affect the bs->breakpoint_at state so they are
delayed after MAIN_ACTION is decided above. */
- if (shlib_event)
- {
- if (debug_infrun)
- fprintf_unfiltered (gdb_stdlog, "bpstat_what: bp_shlib_event\n");
-
- /* Check for any newly added shared libraries if we're supposed
- to be adding them automatically. */
-
- /* Switch terminal for any messages produced by
- breakpoint_re_set. */
- target_terminal_ours_for_output ();
-
-#ifdef SOLIB_ADD
- SOLIB_ADD (NULL, 0, ¤t_target, auto_solib_add);
-#else
- solib_add (NULL, 0, ¤t_target, auto_solib_add);
-#endif
-
- target_terminal_inferior ();
- }
-
if (jit_event)
{
if (debug_infrun)
return NULL;
}
+/* Determine if the locations of this breakpoint will have their conditions
+ evaluated by the target, host or a mix of both. Returns the following:
+
+ "host": Host evals condition.
+ "host or target": Host or Target evals condition.
+ "target": Target evals condition.
+*/
+
+static const char *
+bp_condition_evaluator (struct breakpoint *b)
+{
+ struct bp_location *bl;
+ char host_evals = 0;
+ char target_evals = 0;
+
+ if (!b)
+ return NULL;
+
+ if (!is_breakpoint (b))
+ return NULL;
+
+ if (gdb_evaluates_breakpoint_condition_p ()
+ || !target_supports_evaluation_of_breakpoint_conditions ())
+ return condition_evaluation_host;
+
+ for (bl = b->loc; bl; bl = bl->next)
+ {
+ if (bl->cond_bytecode)
+ target_evals++;
+ else
+ host_evals++;
+ }
+
+ if (host_evals && target_evals)
+ return condition_evaluation_both;
+ else if (target_evals)
+ return condition_evaluation_target;
+ else
+ return condition_evaluation_host;
+}
+
+/* Determine the breakpoint location's condition evaluator. This is
+ similar to bp_condition_evaluator, but for locations. */
+
+static const char *
+bp_location_condition_evaluator (struct bp_location *bl)
+{
+ if (bl && !is_breakpoint (bl->owner))
+ return NULL;
+
+ if (gdb_evaluates_breakpoint_condition_p ()
+ || !target_supports_evaluation_of_breakpoint_conditions ())
+ return condition_evaluation_host;
+
+ if (bl && bl->cond_bytecode)
+ return condition_evaluation_target;
+ else
+ return condition_evaluation_host;
+}
+
/* Print the LOC location out of the list of B->LOC locations. */
static void
print_breakpoint_location (struct breakpoint *b,
struct bp_location *loc)
{
+ struct ui_out *uiout = current_uiout;
struct cleanup *old_chain = save_current_program_space ();
if (loc != NULL && loc->shlib_disabled)
if (b->display_canonical)
ui_out_field_string (uiout, "what", b->addr_string);
- else if (b->source_file && loc)
+ else if (loc && loc->source_file)
{
struct symbol *sym
= find_pc_sect_function (loc->address, loc->section);
ui_out_wrap_hint (uiout, wrap_indent_at_field (uiout, "what"));
ui_out_text (uiout, "at ");
}
- ui_out_field_string (uiout, "file", b->source_file);
+ ui_out_field_string (uiout, "file", loc->source_file);
ui_out_text (uiout, ":");
if (ui_out_is_mi_like_p (uiout))
ui_out_field_string (uiout, "fullname", fullname);
}
- ui_out_field_int (uiout, "line", b->line_number);
+ ui_out_field_int (uiout, "line", loc->line_number);
}
else if (loc)
{
else
ui_out_field_string (uiout, "pending", b->addr_string);
+ if (loc && is_breakpoint (b)
+ && breakpoint_condition_evaluation_mode () == condition_evaluation_target
+ && bp_condition_evaluator (b) == condition_evaluation_both)
+ {
+ ui_out_text (uiout, " (");
+ ui_out_field_string (uiout, "evaluated-by",
+ bp_location_condition_evaluator (loc));
+ ui_out_text (uiout, ")");
+ }
+
do_cleanups (old_chain);
}
struct command_line *l;
static char bpenables[] = "nynny";
+ struct ui_out *uiout = current_uiout;
int header_of_multiple = 0;
int part_of_multiple = (loc != NULL);
struct value_print_options opts;
else
ui_out_text (uiout, "\tstop only if ");
ui_out_field_string (uiout, "cond", b->cond_string);
+
+ /* Print whether the target is doing the breakpoint's condition
+ evaluation. If GDB is doing the evaluation, don't print anything. */
+ if (is_breakpoint (b)
+ && breakpoint_condition_evaluation_mode ()
+ == condition_evaluation_target)
+ {
+ ui_out_text (uiout, " (");
+ ui_out_field_string (uiout, "evaluated-by",
+ bp_condition_evaluator (b));
+ ui_out_text (uiout, " evals)");
+ }
ui_out_text (uiout, "\n");
}
/* FIXME should make an annotation for this. */
if (ep_is_catchpoint (b))
ui_out_text (uiout, "\tcatchpoint");
+ else if (is_tracepoint (b))
+ ui_out_text (uiout, "\ttracepoint");
else
ui_out_text (uiout, "\tbreakpoint");
ui_out_text (uiout, " already hit ");
ui_out_text (uiout, " hits\n");
}
+ /* Note that an enable count of 1 corresponds to "enable once"
+ behavior, which is reported by the combination of enablement and
+ disposition, so we don't need to mention it here. */
+ if (!part_of_multiple && b->enable_count > 1)
+ {
+ annotate_field (8);
+ ui_out_text (uiout, "\tdisable after ");
+ /* Tweak the wording to clarify that ignore and enable counts
+ are distinct, and have additive effect. */
+ if (b->ignore_count)
+ ui_out_text (uiout, "additional ");
+ else
+ ui_out_text (uiout, "next ");
+ ui_out_field_int (uiout, "enable", b->enable_count);
+ ui_out_text (uiout, " hits\n");
+ }
+
+ if (!part_of_multiple && is_tracepoint (b))
+ {
+ struct tracepoint *tp = (struct tracepoint *) b;
+
+ if (tp->traceframe_usage)
+ {
+ ui_out_text (uiout, "\ttrace buffer usage ");
+ ui_out_field_int (uiout, "traceframe-usage", tp->traceframe_usage);
+ ui_out_text (uiout, " bytes\n");
+ }
+ }
+
l = b->commands ? b->commands->commands : NULL;
if (!part_of_multiple && l)
{
int allflag)
{
struct cleanup *bkpt_chain;
+ struct ui_out *uiout = current_uiout;
bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
struct value_print_options opts;
int print_address_bits = 0;
int print_type_col_width = 14;
+ struct ui_out *uiout = current_uiout;
get_user_print_options (&opts);
static void
default_collect_info (void)
{
+ struct ui_out *uiout = current_uiout;
+
/* If it has no value (which is frequently the case), say nothing; a
message like "No default-collect." gets in user's face when it's
not wanted. */
watchpoints_info (char *args, int from_tty)
{
int num_printed = breakpoint_1 (args, 0, is_watchpoint);
+ struct ui_out *uiout = current_uiout;
if (num_printed == 0)
{
return 0;
}
-/* Print a message describing any breakpoints set at PC. This
+/* Print a message describing any user-breakpoints set at PC. This
concerns with logical breakpoints, so we match program spaces, not
address spaces. */
struct breakpoint *b;
ALL_BREAKPOINTS (b)
- others += breakpoint_has_pc (b, pspace, pc, section);
+ others += (user_breakpoint_p (b)
+ && breakpoint_has_pc (b, pspace, pc, section));
if (others > 0)
{
if (others == 1)
else /* if (others == ???) */
printf_filtered (_("Note: breakpoints "));
ALL_BREAKPOINTS (b)
- if (breakpoint_has_pc (b, pspace, pc, section))
+ if (user_breakpoint_p (b) && breakpoint_has_pc (b, pspace, pc, section))
{
others--;
printf_filtered ("%d", b->number);
printf_filtered (" (thread %d)", b->thread);
printf_filtered ("%s%s ",
((b->enable_state == bp_disabled
- || b->enable_state == bp_call_disabled
- || b->enable_state == bp_startup_disabled)
+ || b->enable_state == bp_call_disabled)
? " (disabled)"
: b->enable_state == bp_permanent
? " (permanent)"
}
}
\f
-/* Set the default place to put a breakpoint
- for the `break' command with no arguments. */
-
-void
-set_default_breakpoint (int valid, struct program_space *pspace,
- CORE_ADDR addr, struct symtab *symtab,
- int line)
-{
- default_breakpoint_valid = valid;
- default_breakpoint_pspace = pspace;
- default_breakpoint_address = addr;
- default_breakpoint_symtab = symtab;
- default_breakpoint_line = line;
-}
/* Return true iff it is meaningful to use the address member of
BPT. For some breakpoint types, the address member is irrelevant
aspace, addr)));
}
+/* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
+ Then, if LOC1 and LOC2 represent the same tracepoint location, returns
+ true, otherwise returns false. */
+
+static int
+tracepoint_locations_match (struct bp_location *loc1,
+ struct bp_location *loc2)
+{
+ if (is_tracepoint (loc1->owner) && is_tracepoint (loc2->owner))
+ /* Since tracepoint locations are never duplicated with others', tracepoint
+ locations at the same address of different tracepoints are regarded as
+ different locations. */
+ return (loc1->address == loc2->address && loc1->owner == loc2->owner);
+ else
+ return 0;
+}
+
/* Assuming LOC1 and LOC2's types' have meaningful target addresses
(breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
represent the same location. */
return 0;
else if (hw_point1)
return watchpoint_locations_match (loc1, loc2);
+ else if (is_tracepoint (loc1->owner) || is_tracepoint (loc2->owner))
+ return tracepoint_locations_match (loc1, loc2);
else
/* We compare bp_location.length in order to cover ranged breakpoints. */
return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
loc->ops = ops;
loc->owner = owner;
loc->cond = NULL;
+ loc->cond_bytecode = NULL;
loc->shlib_disabled = 0;
loc->enabled = 1;
case bp_gnu_ifunc_resolver:
case bp_gnu_ifunc_resolver_return:
loc->loc_type = bp_loc_software_breakpoint;
+ mark_breakpoint_location_modified (loc);
break;
case bp_hardware_breakpoint:
loc->loc_type = bp_loc_hardware_breakpoint;
+ mark_breakpoint_location_modified (loc);
break;
case bp_hardware_watchpoint:
case bp_read_watchpoint:
|| is_tracepoint (loc->owner))
{
int is_gnu_ifunc;
+ const char *function_name;
- find_pc_partial_function_gnu_ifunc (loc->address, &loc->function_name,
+ find_pc_partial_function_gnu_ifunc (loc->address, &function_name,
NULL, NULL, &is_gnu_ifunc);
if (is_gnu_ifunc && !explicit_loc)
struct breakpoint *b = loc->owner;
gdb_assert (loc->pspace == current_program_space);
- if (gnu_ifunc_resolve_name (loc->function_name,
+ if (gnu_ifunc_resolve_name (function_name,
&loc->requested_address))
{
/* Recalculate ADDRESS based on new REQUESTED_ADDRESS. */
}
}
- if (loc->function_name)
- loc->function_name = xstrdup (loc->function_name);
+ if (function_name)
+ loc->function_name = xstrdup (function_name);
}
}
/* Attempt to determine architecture of location identified by SAL. */
-static struct gdbarch *
+struct gdbarch *
get_sal_arch (struct symtab_and_line sal)
{
if (sal.section)
struct symtab_and_line sal, enum bptype bptype,
const struct breakpoint_ops *ops)
{
- CORE_ADDR adjusted_address;
- struct gdbarch *loc_gdbarch;
-
init_raw_breakpoint_without_location (b, gdbarch, bptype, ops);
- loc_gdbarch = get_sal_arch (sal);
- if (!loc_gdbarch)
- loc_gdbarch = b->gdbarch;
+ add_location_to_breakpoint (b, &sal);
if (bptype != bp_catchpoint)
gdb_assert (sal.pspace != NULL);
- /* Adjust the breakpoint's address prior to allocating a location.
- Once we call allocate_bp_location(), that mostly uninitialized
- location will be placed on the location chain. Adjustment of the
- breakpoint may cause target_read_memory() to be called and we do
- not want its scan of the location chain to find a breakpoint and
- location that's only been partially initialized. */
- adjusted_address = adjust_breakpoint_address (loc_gdbarch,
- sal.pc, b->type);
-
- b->loc = allocate_bp_location (b);
- b->loc->gdbarch = loc_gdbarch;
- b->loc->requested_address = sal.pc;
- b->loc->address = adjusted_address;
- b->loc->pspace = sal.pspace;
-
- /* Store the program space that was used to set the breakpoint, for
- breakpoint resetting. */
- b->pspace = sal.pspace;
-
- if (sal.symtab == NULL)
- b->source_file = NULL;
- else
- b->source_file = xstrdup (sal.symtab->filename);
- b->loc->section = sal.section;
- b->line_number = sal.line;
-
- set_breakpoint_location_function (b->loc,
- sal.explicit_pc || sal.explicit_line);
+ /* Store the program space that was used to set the breakpoint,
+ except for ordinary breakpoints, which are independent of the
+ program space. */
+ if (bptype != bp_breakpoint && bptype != bp_hardware_breakpoint)
+ b->pspace = sal.pspace;
breakpoints_changed ();
}
}
}
+void
+delete_longjmp_breakpoint_at_next_stop (int thread)
+{
+ struct breakpoint *b, *b_tmp;
+
+ ALL_BREAKPOINTS_SAFE (b, b_tmp)
+ if (b->type == bp_longjmp || b->type == bp_exception)
+ {
+ if (b->thread == thread)
+ b->disposition = disp_del_at_next_stop;
+ }
+}
+
void
enable_overlay_breakpoints (void)
{
}
}
-/* Disable any breakpoints that are in an unloaded shared library.
- Only apply to enabled breakpoints, disabled ones can just stay
+/* Disable any breakpoints and tracepoints that are in an unloaded shared
+ library. Only apply to enabled breakpoints, disabled ones can just stay
disabled. */
static void
/* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
struct breakpoint *b = loc->owner;
- if ((loc->loc_type == bp_loc_hardware_breakpoint
- || loc->loc_type == bp_loc_software_breakpoint)
- && solib->pspace == loc->pspace
+ if (solib->pspace == loc->pspace
&& !loc->shlib_disabled
- && (b->type == bp_breakpoint
- || b->type == bp_jit_event
- || b->type == bp_hardware_breakpoint)
+ && (((b->type == bp_breakpoint
+ || b->type == bp_jit_event
+ || b->type == bp_hardware_breakpoint)
+ && (loc->loc_type == bp_loc_hardware_breakpoint
+ || loc->loc_type == bp_loc_software_breakpoint))
+ || is_tracepoint (b))
&& solib_contains_address_p (solib, loc->address))
{
loc->shlib_disabled = 1;
static int
breakpoint_hit_catch_fork (const struct bp_location *bl,
- struct address_space *aspace, CORE_ADDR bp_addr)
+ struct address_space *aspace, CORE_ADDR bp_addr,
+ const struct target_waitstatus *ws)
{
struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
- return inferior_has_forked (inferior_ptid, &c->forked_inferior_pid);
+ if (ws->kind != TARGET_WAITKIND_FORKED)
+ return 0;
+
+ c->forked_inferior_pid = ws->value.related_pid;
+ return 1;
}
/* Implement the "print_it" breakpoint_ops method for fork
static enum print_stop_action
print_it_catch_fork (bpstat bs)
{
+ struct ui_out *uiout = current_uiout;
struct breakpoint *b = bs->breakpoint_at;
struct fork_catchpoint *c = (struct fork_catchpoint *) bs->breakpoint_at;
annotate_catchpoint (b->number);
- printf_filtered (_("\nCatchpoint %d (forked process %d), "),
- b->number, ptid_get_pid (c->forked_inferior_pid));
+ if (b->disposition == disp_del)
+ ui_out_text (uiout, "\nTemporary catchpoint ");
+ else
+ ui_out_text (uiout, "\nCatchpoint ");
+ if (ui_out_is_mi_like_p (uiout))
+ {
+ ui_out_field_string (uiout, "reason",
+ async_reason_lookup (EXEC_ASYNC_FORK));
+ ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
+ }
+ ui_out_field_int (uiout, "bkptno", b->number);
+ ui_out_text (uiout, " (forked process ");
+ ui_out_field_int (uiout, "newpid", ptid_get_pid (c->forked_inferior_pid));
+ ui_out_text (uiout, "), ");
return PRINT_SRC_AND_LOC;
}
{
struct fork_catchpoint *c = (struct fork_catchpoint *) b;
struct value_print_options opts;
+ struct ui_out *uiout = current_uiout;
get_user_print_options (&opts);
static int
breakpoint_hit_catch_vfork (const struct bp_location *bl,
- struct address_space *aspace, CORE_ADDR bp_addr)
+ struct address_space *aspace, CORE_ADDR bp_addr,
+ const struct target_waitstatus *ws)
{
struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
- return inferior_has_vforked (inferior_ptid, &c->forked_inferior_pid);
+ if (ws->kind != TARGET_WAITKIND_VFORKED)
+ return 0;
+
+ c->forked_inferior_pid = ws->value.related_pid;
+ return 1;
}
/* Implement the "print_it" breakpoint_ops method for vfork
static enum print_stop_action
print_it_catch_vfork (bpstat bs)
{
+ struct ui_out *uiout = current_uiout;
struct breakpoint *b = bs->breakpoint_at;
struct fork_catchpoint *c = (struct fork_catchpoint *) b;
annotate_catchpoint (b->number);
- printf_filtered (_("\nCatchpoint %d (vforked process %d), "),
- b->number, ptid_get_pid (c->forked_inferior_pid));
+ if (b->disposition == disp_del)
+ ui_out_text (uiout, "\nTemporary catchpoint ");
+ else
+ ui_out_text (uiout, "\nCatchpoint ");
+ if (ui_out_is_mi_like_p (uiout))
+ {
+ ui_out_field_string (uiout, "reason",
+ async_reason_lookup (EXEC_ASYNC_VFORK));
+ ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
+ }
+ ui_out_field_int (uiout, "bkptno", b->number);
+ ui_out_text (uiout, " (vforked process ");
+ ui_out_field_int (uiout, "newpid", ptid_get_pid (c->forked_inferior_pid));
+ ui_out_text (uiout, "), ");
return PRINT_SRC_AND_LOC;
}
{
struct fork_catchpoint *c = (struct fork_catchpoint *) b;
struct value_print_options opts;
+ struct ui_out *uiout = current_uiout;
get_user_print_options (&opts);
/* Field 4, the address, is omitted (which makes the columns not
static struct breakpoint_ops catch_vfork_breakpoint_ops;
-/* An instance of this type is used to represent a syscall catchpoint.
+/* An instance of this type is used to represent an solib catchpoint.
It includes a "struct breakpoint" as a kind of base class; users
downcast to "struct breakpoint *" when needed. A breakpoint is
really of this type iff its ops pointer points to
- CATCH_SYSCALL_BREAKPOINT_OPS. */
+ CATCH_SOLIB_BREAKPOINT_OPS. */
-struct syscall_catchpoint
+struct solib_catchpoint
{
/* The base class. */
struct breakpoint base;
- /* Syscall numbers used for the 'catch syscall' feature. If no
- syscall has been specified for filtering, its value is NULL.
- Otherwise, it holds a list of all syscalls to be caught. The
- list elements are allocated with xmalloc. */
- VEC(int) *syscalls_to_be_caught;
-};
+ /* True for "catch load", false for "catch unload". */
+ unsigned char is_load;
-/* Implement the "dtor" breakpoint_ops method for syscall
- catchpoints. */
+ /* Regular expression to match, if any. COMPILED is only valid when
+ REGEX is non-NULL. */
+ char *regex;
+ regex_t compiled;
+};
static void
-dtor_catch_syscall (struct breakpoint *b)
+dtor_catch_solib (struct breakpoint *b)
{
- struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
+ struct solib_catchpoint *self = (struct solib_catchpoint *) b;
- VEC_free (int, c->syscalls_to_be_caught);
+ if (self->regex)
+ regfree (&self->compiled);
+ xfree (self->regex);
base_breakpoint_ops.dtor (b);
}
-/* Implement the "insert" breakpoint_ops method for syscall
- catchpoints. */
+static int
+insert_catch_solib (struct bp_location *ignore)
+{
+ return 0;
+}
static int
-insert_catch_syscall (struct bp_location *bl)
+remove_catch_solib (struct bp_location *ignore)
{
- struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
- struct inferior *inf = current_inferior ();
+ return 0;
+}
- ++inf->total_syscalls_count;
- if (!c->syscalls_to_be_caught)
- ++inf->any_syscall_count;
- else
- {
- int i, iter;
+static int
+breakpoint_hit_catch_solib (const struct bp_location *bl,
+ struct address_space *aspace,
+ CORE_ADDR bp_addr,
+ const struct target_waitstatus *ws)
+{
+ struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
+ struct breakpoint *other;
- for (i = 0;
- VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
- i++)
- {
- int elem;
+ if (ws->kind == TARGET_WAITKIND_LOADED)
+ return 1;
- if (iter >= VEC_length (int, inf->syscalls_counts))
- {
- int old_size = VEC_length (int, inf->syscalls_counts);
- uintptr_t vec_addr_offset
- = old_size * ((uintptr_t) sizeof (int));
- uintptr_t vec_addr;
- VEC_safe_grow (int, inf->syscalls_counts, iter + 1);
- vec_addr = (uintptr_t) VEC_address (int, inf->syscalls_counts) +
- vec_addr_offset;
- memset ((void *) vec_addr, 0,
- (iter + 1 - old_size) * sizeof (int));
- }
- elem = VEC_index (int, inf->syscalls_counts, iter);
- VEC_replace (int, inf->syscalls_counts, iter, ++elem);
- }
- }
+ ALL_BREAKPOINTS (other)
+ {
+ struct bp_location *other_bl;
- return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
- inf->total_syscalls_count != 0,
- inf->any_syscall_count,
- VEC_length (int, inf->syscalls_counts),
- VEC_address (int, inf->syscalls_counts));
-}
+ if (other == bl->owner)
+ continue;
-/* Implement the "remove" breakpoint_ops method for syscall
- catchpoints. */
+ if (other->type != bp_shlib_event)
+ continue;
-static int
-remove_catch_syscall (struct bp_location *bl)
-{
- struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
- struct inferior *inf = current_inferior ();
+ if (self->base.pspace != NULL && other->pspace != self->base.pspace)
+ continue;
+
+ for (other_bl = other->loc; other_bl != NULL; other_bl = other_bl->next)
+ {
+ if (other->ops->breakpoint_hit (other_bl, aspace, bp_addr, ws))
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+static void
+check_status_catch_solib (struct bpstats *bs)
+{
+ struct solib_catchpoint *self
+ = (struct solib_catchpoint *) bs->breakpoint_at;
+ int ix;
+
+ if (self->is_load)
+ {
+ struct so_list *iter;
+
+ for (ix = 0;
+ VEC_iterate (so_list_ptr, current_program_space->added_solibs,
+ ix, iter);
+ ++ix)
+ {
+ if (!self->regex
+ || regexec (&self->compiled, iter->so_name, 0, NULL, 0) == 0)
+ return;
+ }
+ }
+ else
+ {
+ char *iter;
+
+ for (ix = 0;
+ VEC_iterate (char_ptr, current_program_space->deleted_solibs,
+ ix, iter);
+ ++ix)
+ {
+ if (!self->regex
+ || regexec (&self->compiled, iter, 0, NULL, 0) == 0)
+ return;
+ }
+ }
+
+ bs->stop = 0;
+ bs->print_it = print_it_noop;
+}
+
+static enum print_stop_action
+print_it_catch_solib (bpstat bs)
+{
+ struct breakpoint *b = bs->breakpoint_at;
+ struct ui_out *uiout = current_uiout;
+
+ annotate_catchpoint (b->number);
+ if (b->disposition == disp_del)
+ ui_out_text (uiout, "\nTemporary catchpoint ");
+ else
+ ui_out_text (uiout, "\nCatchpoint ");
+ ui_out_field_int (uiout, "bkptno", b->number);
+ ui_out_text (uiout, "\n");
+ if (ui_out_is_mi_like_p (uiout))
+ ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
+ print_solib_event (1);
+ return PRINT_SRC_AND_LOC;
+}
+
+static void
+print_one_catch_solib (struct breakpoint *b, struct bp_location **locs)
+{
+ struct solib_catchpoint *self = (struct solib_catchpoint *) b;
+ struct value_print_options opts;
+ struct ui_out *uiout = current_uiout;
+ char *msg;
+
+ get_user_print_options (&opts);
+ /* Field 4, the address, is omitted (which makes the columns not
+ line up too nicely with the headers, but the effect is relatively
+ readable). */
+ if (opts.addressprint)
+ {
+ annotate_field (4);
+ ui_out_field_skip (uiout, "addr");
+ }
+
+ annotate_field (5);
+ if (self->is_load)
+ {
+ if (self->regex)
+ msg = xstrprintf (_("load of library matching %s"), self->regex);
+ else
+ msg = xstrdup (_("load of library"));
+ }
+ else
+ {
+ if (self->regex)
+ msg = xstrprintf (_("unload of library matching %s"), self->regex);
+ else
+ msg = xstrdup (_("unload of library"));
+ }
+ ui_out_field_string (uiout, "what", msg);
+ xfree (msg);
+}
+
+static void
+print_mention_catch_solib (struct breakpoint *b)
+{
+ struct solib_catchpoint *self = (struct solib_catchpoint *) b;
+
+ printf_filtered (_("Catchpoint %d (%s)"), b->number,
+ self->is_load ? "load" : "unload");
+}
+
+static void
+print_recreate_catch_solib (struct breakpoint *b, struct ui_file *fp)
+{
+ struct solib_catchpoint *self = (struct solib_catchpoint *) b;
+
+ fprintf_unfiltered (fp, "%s %s",
+ b->disposition == disp_del ? "tcatch" : "catch",
+ self->is_load ? "load" : "unload");
+ if (self->regex)
+ fprintf_unfiltered (fp, " %s", self->regex);
+ fprintf_unfiltered (fp, "\n");
+}
+
+static struct breakpoint_ops catch_solib_breakpoint_ops;
+
+/* A helper function that does all the work for "catch load" and
+ "catch unload". */
+
+static void
+catch_load_or_unload (char *arg, int from_tty, int is_load,
+ struct cmd_list_element *command)
+{
+ struct solib_catchpoint *c;
+ struct gdbarch *gdbarch = get_current_arch ();
+ int tempflag;
+ regex_t compiled;
+ struct cleanup *cleanup;
+
+ tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
+
+ if (!arg)
+ arg = "";
+ arg = skip_spaces (arg);
+
+ c = XCNEW (struct solib_catchpoint);
+ cleanup = make_cleanup (xfree, c);
+
+ if (*arg != '\0')
+ {
+ int errcode;
+
+ errcode = regcomp (&c->compiled, arg, REG_NOSUB);
+ if (errcode != 0)
+ {
+ char *err = get_regcomp_error (errcode, &c->compiled);
+
+ make_cleanup (xfree, err);
+ error (_("Invalid regexp (%s): %s"), err, arg);
+ }
+ c->regex = xstrdup (arg);
+ }
+
+ c->is_load = is_load;
+ init_catchpoint (&c->base, gdbarch, tempflag, NULL,
+ &catch_solib_breakpoint_ops);
+
+ discard_cleanups (cleanup);
+ install_breakpoint (0, &c->base, 1);
+}
+
+static void
+catch_load_command_1 (char *arg, int from_tty,
+ struct cmd_list_element *command)
+{
+ catch_load_or_unload (arg, from_tty, 1, command);
+}
+
+static void
+catch_unload_command_1 (char *arg, int from_tty,
+ struct cmd_list_element *command)
+{
+ catch_load_or_unload (arg, from_tty, 0, command);
+}
+
+/* An instance of this type is used to represent a syscall catchpoint.
+ It includes a "struct breakpoint" as a kind of base class; users
+ downcast to "struct breakpoint *" when needed. A breakpoint is
+ really of this type iff its ops pointer points to
+ CATCH_SYSCALL_BREAKPOINT_OPS. */
+
+struct syscall_catchpoint
+{
+ /* The base class. */
+ struct breakpoint base;
+
+ /* Syscall numbers used for the 'catch syscall' feature. If no
+ syscall has been specified for filtering, its value is NULL.
+ Otherwise, it holds a list of all syscalls to be caught. The
+ list elements are allocated with xmalloc. */
+ VEC(int) *syscalls_to_be_caught;
+};
+
+/* Implement the "dtor" breakpoint_ops method for syscall
+ catchpoints. */
+
+static void
+dtor_catch_syscall (struct breakpoint *b)
+{
+ struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
+
+ VEC_free (int, c->syscalls_to_be_caught);
+
+ base_breakpoint_ops.dtor (b);
+}
+
+/* Implement the "insert" breakpoint_ops method for syscall
+ catchpoints. */
+
+static int
+insert_catch_syscall (struct bp_location *bl)
+{
+ struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
+ struct inferior *inf = current_inferior ();
+
+ ++inf->total_syscalls_count;
+ if (!c->syscalls_to_be_caught)
+ ++inf->any_syscall_count;
+ else
+ {
+ int i, iter;
+
+ for (i = 0;
+ VEC_iterate (int, c->syscalls_to_be_caught, i, iter);
+ i++)
+ {
+ int elem;
+
+ if (iter >= VEC_length (int, inf->syscalls_counts))
+ {
+ int old_size = VEC_length (int, inf->syscalls_counts);
+ uintptr_t vec_addr_offset
+ = old_size * ((uintptr_t) sizeof (int));
+ uintptr_t vec_addr;
+ VEC_safe_grow (int, inf->syscalls_counts, iter + 1);
+ vec_addr = (uintptr_t) VEC_address (int, inf->syscalls_counts) +
+ vec_addr_offset;
+ memset ((void *) vec_addr, 0,
+ (iter + 1 - old_size) * sizeof (int));
+ }
+ elem = VEC_index (int, inf->syscalls_counts, iter);
+ VEC_replace (int, inf->syscalls_counts, iter, ++elem);
+ }
+ }
+
+ return target_set_syscall_catchpoint (PIDGET (inferior_ptid),
+ inf->total_syscalls_count != 0,
+ inf->any_syscall_count,
+ VEC_length (int, inf->syscalls_counts),
+ VEC_address (int, inf->syscalls_counts));
+}
+
+/* Implement the "remove" breakpoint_ops method for syscall
+ catchpoints. */
+
+static int
+remove_catch_syscall (struct bp_location *bl)
+{
+ struct syscall_catchpoint *c = (struct syscall_catchpoint *) bl->owner;
+ struct inferior *inf = current_inferior ();
--inf->total_syscalls_count;
if (!c->syscalls_to_be_caught)
static int
breakpoint_hit_catch_syscall (const struct bp_location *bl,
- struct address_space *aspace, CORE_ADDR bp_addr)
+ struct address_space *aspace, CORE_ADDR bp_addr,
+ const struct target_waitstatus *ws)
{
/* We must check if we are catching specific syscalls in this
breakpoint. If we are, then we must guarantee that the called
const struct syscall_catchpoint *c
= (const struct syscall_catchpoint *) bl->owner;
- if (!inferior_has_called_syscall (inferior_ptid, &syscall_number))
+ if (ws->kind != TARGET_WAITKIND_SYSCALL_ENTRY
+ && ws->kind != TARGET_WAITKIND_SYSCALL_RETURN)
return 0;
+ syscall_number = ws->value.syscall_number;
+
/* Now, checking if the syscall is the same. */
if (c->syscalls_to_be_caught)
{
static enum print_stop_action
print_it_catch_syscall (bpstat bs)
{
+ struct ui_out *uiout = current_uiout;
struct breakpoint *b = bs->breakpoint_at;
/* These are needed because we want to know in which state a
syscall is. It can be in the TARGET_WAITKIND_SYSCALL_ENTRY
ptid_t ptid;
struct target_waitstatus last;
struct syscall s;
- struct cleanup *old_chain;
char *syscall_id;
get_last_target_status (&ptid, &last);
annotate_catchpoint (b->number);
- if (s.name == NULL)
- syscall_id = xstrprintf ("%d", last.value.syscall_number);
+ if (b->disposition == disp_del)
+ ui_out_text (uiout, "\nTemporary catchpoint ");
else
- syscall_id = xstrprintf ("'%s'", s.name);
-
- old_chain = make_cleanup (xfree, syscall_id);
+ ui_out_text (uiout, "\nCatchpoint ");
+ if (ui_out_is_mi_like_p (uiout))
+ {
+ ui_out_field_string (uiout, "reason",
+ async_reason_lookup (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY
+ ? EXEC_ASYNC_SYSCALL_ENTRY
+ : EXEC_ASYNC_SYSCALL_RETURN));
+ ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
+ }
+ ui_out_field_int (uiout, "bkptno", b->number);
if (last.kind == TARGET_WAITKIND_SYSCALL_ENTRY)
- printf_filtered (_("\nCatchpoint %d (call to syscall %s), "),
- b->number, syscall_id);
- else if (last.kind == TARGET_WAITKIND_SYSCALL_RETURN)
- printf_filtered (_("\nCatchpoint %d (returned from syscall %s), "),
- b->number, syscall_id);
+ ui_out_text (uiout, " (call to syscall ");
+ else
+ ui_out_text (uiout, " (returned from syscall ");
- do_cleanups (old_chain);
+ if (s.name == NULL || ui_out_is_mi_like_p (uiout))
+ ui_out_field_int (uiout, "syscall-number", last.value.syscall_number);
+ if (s.name != NULL)
+ ui_out_field_string (uiout, "syscall-name", s.name);
+
+ ui_out_text (uiout, "), ");
return PRINT_SRC_AND_LOC;
}
{
struct syscall_catchpoint *c = (struct syscall_catchpoint *) b;
struct value_print_options opts;
+ struct ui_out *uiout = current_uiout;
get_user_print_options (&opts);
/* Field 4, the address, is omitted (which makes the columns not
}
void
-install_breakpoint (int internal, struct breakpoint *b)
+install_breakpoint (int internal, struct breakpoint *b, int update_gll)
{
add_to_breakpoint_chain (b);
set_breakpoint_number (internal, b);
if (!internal)
mention (b);
observer_notify_breakpoint_created (b);
- update_global_location_list (1);
+
+ if (update_gll)
+ update_global_location_list (1);
}
static void
c->forked_inferior_pid = null_ptid;
- install_breakpoint (0, &c->base);
+ install_breakpoint (0, &c->base, 1);
}
/* Exec catchpoints. */
static int
breakpoint_hit_catch_exec (const struct bp_location *bl,
- struct address_space *aspace, CORE_ADDR bp_addr)
+ struct address_space *aspace, CORE_ADDR bp_addr,
+ const struct target_waitstatus *ws)
{
struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
- return inferior_has_execd (inferior_ptid, &c->exec_pathname);
+ if (ws->kind != TARGET_WAITKIND_EXECD)
+ return 0;
+
+ c->exec_pathname = xstrdup (ws->value.execd_pathname);
+ return 1;
}
static enum print_stop_action
print_it_catch_exec (bpstat bs)
{
+ struct ui_out *uiout = current_uiout;
struct breakpoint *b = bs->breakpoint_at;
struct exec_catchpoint *c = (struct exec_catchpoint *) b;
annotate_catchpoint (b->number);
- printf_filtered (_("\nCatchpoint %d (exec'd %s), "), b->number,
- c->exec_pathname);
+ if (b->disposition == disp_del)
+ ui_out_text (uiout, "\nTemporary catchpoint ");
+ else
+ ui_out_text (uiout, "\nCatchpoint ");
+ if (ui_out_is_mi_like_p (uiout))
+ {
+ ui_out_field_string (uiout, "reason",
+ async_reason_lookup (EXEC_ASYNC_EXEC));
+ ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
+ }
+ ui_out_field_int (uiout, "bkptno", b->number);
+ ui_out_text (uiout, " (exec'd ");
+ ui_out_field_string (uiout, "new-exec", c->exec_pathname);
+ ui_out_text (uiout, "), ");
+
return PRINT_SRC_AND_LOC;
}
{
struct exec_catchpoint *c = (struct exec_catchpoint *) b;
struct value_print_options opts;
+ struct ui_out *uiout = current_uiout;
get_user_print_options (&opts);
init_catchpoint (&c->base, gdbarch, tempflag, NULL, ops);
c->syscalls_to_be_caught = filter;
- install_breakpoint (0, &c->base);
+ install_breakpoint (0, &c->base, 1);
}
static int
return i;
}
+/* Returns the resources B would use if it were a hardware
+ watchpoint. */
+
static int
-hw_watchpoint_used_count (enum bptype type, int *other_type_used)
+hw_watchpoint_use_count (struct breakpoint *b)
{
int i = 0;
- struct breakpoint *b;
struct bp_location *bl;
+ if (!breakpoint_enabled (b))
+ return 0;
+
+ for (bl = b->loc; bl; bl = bl->next)
+ {
+ /* Special types of hardware watchpoints may use more than
+ one register. */
+ i += b->ops->resources_needed (bl);
+ }
+
+ return i;
+}
+
+/* Returns the sum the used resources of all hardware watchpoints of
+ type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
+ the sum of the used resources of all hardware watchpoints of other
+ types _not_ TYPE. */
+
+static int
+hw_watchpoint_used_count_others (struct breakpoint *except,
+ enum bptype type, int *other_type_used)
+{
+ int i = 0;
+ struct breakpoint *b;
+
*other_type_used = 0;
ALL_BREAKPOINTS (b)
{
+ if (b == except)
+ continue;
if (!breakpoint_enabled (b))
continue;
- if (b->type == type)
- for (bl = b->loc; bl; bl = bl->next)
- {
- /* Special types of hardware watchpoints may use more than
- one register. */
- i += b->ops->resources_needed (bl);
- }
- else if (is_hardware_watchpoint (b))
- *other_type_used = 1;
+ if (b->type == type)
+ i += hw_watchpoint_use_count (b);
+ else if (is_hardware_watchpoint (b))
+ *other_type_used = 1;
}
return i;
void
disable_breakpoints_before_startup (void)
{
- struct breakpoint *b;
- int found = 0;
-
- ALL_BREAKPOINTS (b)
- {
- if (b->pspace != current_program_space)
- continue;
-
- if ((b->type == bp_breakpoint
- || b->type == bp_hardware_breakpoint)
- && breakpoint_enabled (b))
- {
- b->enable_state = bp_startup_disabled;
- found = 1;
- }
- }
-
- if (found)
- update_global_location_list (0);
-
current_program_space->executing_startup = 1;
+ update_global_location_list (0);
}
void
enable_breakpoints_after_startup (void)
{
- struct breakpoint *b;
- int found = 0;
-
current_program_space->executing_startup = 0;
-
- ALL_BREAKPOINTS (b)
- {
- if (b->pspace != current_program_space)
- continue;
-
- if ((b->type == bp_breakpoint
- || b->type == bp_hardware_breakpoint)
- && b->enable_state == bp_startup_disabled)
- {
- b->enable_state = bp_enabled;
- found = 1;
- }
- }
-
- if (found)
- breakpoint_re_set ();
+ breakpoint_re_set ();
}
copy->loc->section = orig->loc->section;
copy->loc->pspace = orig->loc->pspace;
- if (orig->source_file == NULL)
- copy->source_file = NULL;
- else
- copy->source_file = xstrdup (orig->source_file);
+ if (orig->loc->source_file != NULL)
+ copy->loc->source_file = xstrdup (orig->loc->source_file);
- copy->line_number = orig->line_number;
+ copy->loc->line_number = orig->loc->line_number;
copy->frame_id = orig->frame_id;
copy->thread = orig->thread;
copy->pspace = orig->pspace;
mention (struct breakpoint *b)
{
b->ops->print_mention (b);
- if (ui_out_is_mi_like_p (uiout))
+ if (ui_out_is_mi_like_p (current_uiout))
return;
printf_filtered ("\n");
}
const struct symtab_and_line *sal)
{
struct bp_location *loc, **tmp;
+ CORE_ADDR adjusted_address;
+ struct gdbarch *loc_gdbarch = get_sal_arch (*sal);
+
+ if (loc_gdbarch == NULL)
+ loc_gdbarch = b->gdbarch;
+
+ /* Adjust the breakpoint's address prior to allocating a location.
+ Once we call allocate_bp_location(), that mostly uninitialized
+ location will be placed on the location chain. Adjustment of the
+ breakpoint may cause target_read_memory() to be called and we do
+ not want its scan of the location chain to find a breakpoint and
+ location that's only been partially initialized. */
+ adjusted_address = adjust_breakpoint_address (loc_gdbarch,
+ sal->pc, b->type);
loc = allocate_bp_location (b);
for (tmp = &(b->loc); *tmp != NULL; tmp = &((*tmp)->next))
;
*tmp = loc;
- loc->gdbarch = get_sal_arch (*sal);
- if (!loc->gdbarch)
- loc->gdbarch = b->gdbarch;
+
loc->requested_address = sal->pc;
- loc->address = adjust_breakpoint_address (loc->gdbarch,
- loc->requested_address, b->type);
+ loc->address = adjusted_address;
loc->pspace = sal->pspace;
gdb_assert (loc->pspace != NULL);
loc->section = sal->section;
+ loc->gdbarch = loc_gdbarch;
+
+ if (sal->symtab != NULL)
+ loc->source_file = xstrdup (sal->symtab->filename);
+ loc->line_number = sal->line;
set_breakpoint_location_function (loc,
sal->explicit_pc || sal->explicit_line);
{
int len;
CORE_ADDR addr;
- const gdb_byte *brk;
+ const gdb_byte *bpoint;
gdb_byte *target_mem;
struct cleanup *cleanup;
int retval = 0;
gdb_assert (loc != NULL);
addr = loc->address;
- brk = gdbarch_breakpoint_from_pc (loc->gdbarch, &addr, &len);
+ bpoint = gdbarch_breakpoint_from_pc (loc->gdbarch, &addr, &len);
/* Software breakpoints unsupported? */
- if (brk == NULL)
+ if (bpoint == NULL)
return 0;
target_mem = alloca (len);
make_show_memory_breakpoints_cleanup (0);
if (target_read_memory (loc->address, target_mem, len) == 0
- && memcmp (target_mem, brk, len) == 0)
+ && memcmp (target_mem, bpoint, len) == 0)
retval = 1;
do_cleanups (cleanup);
static void
init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
struct symtabs_and_lines sals, char *addr_string,
- char *cond_string,
+ char *filter, char *cond_string,
enum bptype type, enum bpdisp disposition,
int thread, int task, int ignore_count,
const struct breakpoint_ops *ops, int from_tty,
if (type == bp_hardware_breakpoint)
{
- int i = hw_breakpoint_used_count ();
- int target_resources_ok =
- target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
+ int target_resources_ok;
+
+ i = hw_breakpoint_used_count ();
+ target_resources_ok =
+ target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
i + 1, 0);
if (target_resources_ok == 0)
error (_("No hardware breakpoint support in the target."));
b->ignore_count = ignore_count;
b->enable_state = enabled ? bp_enabled : bp_disabled;
b->disposition = disposition;
- b->pspace = sals.sals[0].pspace;
if (type == bp_static_tracepoint)
{
struct tracepoint *t = (struct tracepoint *) b;
struct static_tracepoint_marker marker;
- if (is_marker_spec (addr_string))
+ if (strace_marker_p (b))
{
/* We already know the marker exists, otherwise, we
wouldn't see a sal for it. */
char *p = &addr_string[3];
char *endp;
char *marker_str;
- int i;
p = skip_spaces (p);
"tracepoint marker to probe"));
}
- if (enabled && b->pspace->executing_startup
- && (b->type == bp_breakpoint
- || b->type == bp_hardware_breakpoint))
- b->enable_state = bp_startup_disabled;
-
loc = b->loc;
}
else
me. */
b->addr_string
= xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
+ b->filter = filter;
}
static void
create_breakpoint_sal (struct gdbarch *gdbarch,
struct symtabs_and_lines sals, char *addr_string,
- char *cond_string,
+ char *filter, char *cond_string,
enum bptype type, enum bpdisp disposition,
int thread, int task, int ignore_count,
const struct breakpoint_ops *ops, int from_tty,
init_breakpoint_sal (b, gdbarch,
sals, addr_string,
- cond_string,
+ filter, cond_string,
type, disposition,
thread, task, ignore_count,
ops, from_tty,
enabled, internal, display_canonical);
discard_cleanups (old_chain);
- install_breakpoint (internal, b);
-}
-
-/* Remove element at INDEX_TO_REMOVE from SAL, shifting other
- elements to fill the void space. */
-static void
-remove_sal (struct symtabs_and_lines *sal, int index_to_remove)
-{
- int i = index_to_remove+1;
- int last_index = sal->nelts-1;
-
- for (;i <= last_index; ++i)
- sal->sals[i-1] = sal->sals[i];
-
- --(sal->nelts);
-}
-
-/* If appropriate, obtains all sals that correspond to the same file
- and line as SAL, in all program spaces. Users debugging with IDEs,
- will want to set a breakpoint at foo.c:line, and not really care
- about program spaces. This is done only if SAL does not have
- explicit PC and has line and file information. If we got just a
- single expanded sal, return the original.
-
- Otherwise, if SAL.explicit_line is not set, filter out all sals for
- which the name of enclosing function is different from SAL. This
- makes sure that if we have breakpoint originally set in template
- instantiation, say foo<int>(), we won't expand SAL to locations at
- the same line in all existing instantiations of 'foo'. */
-
-static struct symtabs_and_lines
-expand_line_sal_maybe (struct symtab_and_line sal)
-{
- struct symtabs_and_lines expanded;
- CORE_ADDR original_pc = sal.pc;
- char *original_function = NULL;
- int found;
- int i;
- struct cleanup *old_chain;
-
- /* If we have explicit pc, don't expand.
- If we have no line number, we can't expand. */
- if (sal.explicit_pc || sal.line == 0 || sal.symtab == NULL)
- {
- expanded.nelts = 1;
- expanded.sals = xmalloc (sizeof (struct symtab_and_line));
- expanded.sals[0] = sal;
- return expanded;
- }
-
- sal.pc = 0;
-
- old_chain = save_current_space_and_thread ();
-
- switch_to_program_space_and_thread (sal.pspace);
-
- find_pc_partial_function (original_pc, &original_function, NULL, NULL);
-
- /* Note that expand_line_sal visits *all* program spaces. */
- expanded = expand_line_sal (sal);
-
- if (expanded.nelts == 1)
- {
- /* We had one sal, we got one sal. Return that sal, adjusting it
- past the function prologue if necessary. */
- xfree (expanded.sals);
- expanded.nelts = 1;
- expanded.sals = xmalloc (sizeof (struct symtab_and_line));
- sal.pc = original_pc;
- expanded.sals[0] = sal;
- skip_prologue_sal (&expanded.sals[0]);
- do_cleanups (old_chain);
- return expanded;
- }
-
- if (!sal.explicit_line)
- {
- CORE_ADDR func_addr, func_end;
- for (i = 0; i < expanded.nelts; ++i)
- {
- CORE_ADDR pc = expanded.sals[i].pc;
- char *this_function;
-
- /* We need to switch threads as well since we're about to
- read memory. */
- switch_to_program_space_and_thread (expanded.sals[i].pspace);
-
- if (find_pc_partial_function (pc, &this_function,
- &func_addr, &func_end))
- {
- if (this_function
- && strcmp (this_function, original_function) != 0)
- {
- remove_sal (&expanded, i);
- --i;
- }
- }
- }
- }
-
- /* Skip the function prologue if necessary. */
- for (i = 0; i < expanded.nelts; ++i)
- skip_prologue_sal (&expanded.sals[i]);
-
- do_cleanups (old_chain);
-
- if (expanded.nelts <= 1)
- {
- /* This is an ugly workaround. If we get zero expanded sals
- then something is really wrong. Fix that by returning the
- original sal. */
-
- xfree (expanded.sals);
- expanded.nelts = 1;
- expanded.sals = xmalloc (sizeof (struct symtab_and_line));
- sal.pc = original_pc;
- expanded.sals[0] = sal;
- return expanded;
- }
-
- if (original_pc)
- {
- found = 0;
- for (i = 0; i < expanded.nelts; ++i)
- if (expanded.sals[i].pc == original_pc)
- {
- found = 1;
- break;
- }
- gdb_assert (found);
- }
-
- return expanded;
+ install_breakpoint (internal, b, 0);
}
/* Add SALS.nelts breakpoints to the breakpoint table. For each
static void
create_breakpoints_sal (struct gdbarch *gdbarch,
- struct symtabs_and_lines sals,
struct linespec_result *canonical,
char *cond_string,
enum bptype type, enum bpdisp disposition,
int enabled, int internal)
{
int i;
+ struct linespec_sals *lsal;
- for (i = 0; i < sals.nelts; ++i)
+ if (canonical->pre_expanded)
+ gdb_assert (VEC_length (linespec_sals, canonical->sals) == 1);
+
+ for (i = 0; VEC_iterate (linespec_sals, canonical->sals, i, lsal); ++i)
{
- struct symtabs_and_lines expanded =
- expand_line_sal_maybe (sals.sals[i]);
+ /* Note that 'addr_string' can be NULL in the case of a plain
+ 'break', without arguments. */
+ char *addr_string = (canonical->addr_string
+ ? xstrdup (canonical->addr_string)
+ : NULL);
+ char *filter_string = lsal->canonical ? xstrdup (lsal->canonical) : NULL;
+ struct cleanup *inner = make_cleanup (xfree, addr_string);
- create_breakpoint_sal (gdbarch, expanded, canonical->canonical[i],
+ make_cleanup (xfree, filter_string);
+ create_breakpoint_sal (gdbarch, lsal->sals,
+ addr_string,
+ filter_string,
cond_string, type, disposition,
thread, task, ignore_count, ops,
from_tty, enabled, internal,
canonical->special_display);
+ discard_cleanups (inner);
}
}
static void
parse_breakpoint_sals (char **address,
- struct symtabs_and_lines *sals,
struct linespec_result *canonical)
{
char *addr_start = *address;
if ((*address) == NULL
|| (strncmp ((*address), "if", 2) == 0 && isspace ((*address)[2])))
{
- if (default_breakpoint_valid)
+ /* The last displayed codepoint, if it's valid, is our default breakpoint
+ address. */
+ if (last_displayed_sal_is_valid ())
{
+ struct linespec_sals lsal;
struct symtab_and_line sal;
init_sal (&sal); /* Initialize to zeroes. */
- sals->sals = (struct symtab_and_line *)
+ lsal.sals.sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
- sal.pc = default_breakpoint_address;
- sal.line = default_breakpoint_line;
- sal.symtab = default_breakpoint_symtab;
- sal.pspace = default_breakpoint_pspace;
- sal.section = find_pc_overlay (sal.pc);
+
+ /* Set sal's pspace, pc, symtab, and line to the values
+ corresponding to the last call to print_frame_info. */
+ get_last_displayed_sal (&sal);
+ sal.section = find_pc_overlay (sal.pc);
/* "break" without arguments is equivalent to "break *PC"
- where PC is the default_breakpoint_address. So make sure
- to set sal.explicit_pc to prevent GDB from trying to
- expand the list of sals to include all other instances
- with the same symtab and line. */
+ where PC is the last displayed codepoint's address. So
+ make sure to set sal.explicit_pc to prevent GDB from
+ trying to expand the list of sals to include all other
+ instances with the same symtab and line. */
sal.explicit_pc = 1;
- sals->sals[0] = sal;
- sals->nelts = 1;
+ lsal.sals.sals[0] = sal;
+ lsal.sals.nelts = 1;
+ lsal.canonical = NULL;
+
+ VEC_safe_push (linespec_sals, canonical->sals, &lsal);
}
else
error (_("No default breakpoint address now."));
/* Force almost all breakpoints to be in terms of the
current_source_symtab (which is decode_line_1's default).
This should produce the results we want almost all of the
- time while leaving default_breakpoint_* alone.
-
- ObjC: However, don't match an Objective-C method name which
- may have a '+' or '-' succeeded by a '[' */
-
- struct symtab_and_line cursal = get_current_source_symtab_and_line ();
-
- if (default_breakpoint_valid
- && (!cursal.symtab
- || ((strchr ("+-", (*address)[0]) != NULL)
- && ((*address)[1] != '['))))
- *sals = decode_line_1 (address, 1, default_breakpoint_symtab,
- default_breakpoint_line, canonical);
+ time while leaving default_breakpoint_* alone. */
+ if (last_displayed_sal_is_valid ())
+ decode_line_full (address, DECODE_LINE_FUNFIRSTLINE,
+ get_last_displayed_symtab (),
+ get_last_displayed_line (),
+ canonical, NULL, NULL);
else
- *sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
- canonical);
- }
- /* For any SAL that didn't have a canonical string, fill one in. */
- if (sals->nelts > 0 && canonical->canonical == NULL)
- canonical->canonical = xcalloc (sals->nelts, sizeof (char *));
- if (addr_start != (*address))
- {
- int i;
-
- for (i = 0; i < sals->nelts; i++)
- {
- /* Add the string if not present. */
- if (canonical->canonical[i] == NULL)
- canonical->canonical[i] = savestring (addr_start,
- (*address) - addr_start);
- }
+ decode_line_full (address, DECODE_LINE_FUNFIRSTLINE,
+ (struct symtab *) NULL, 0,
+ canonical, NULL, NULL);
}
}
for (i = 0; i < sals->nelts; i++)
{
+ struct gdbarch *sarch;
+
sal = &sals->sals[i];
- rslt = gdbarch_fast_tracepoint_valid_at (gdbarch, sal->pc,
+ sarch = get_sal_arch (*sal);
+ /* We fall back to GDBARCH if there is no architecture
+ associated with SAL. */
+ if (sarch == NULL)
+ sarch = gdbarch;
+ rslt = gdbarch_fast_tracepoint_valid_at (sarch, sal->pc,
NULL, &msg);
old_chain = make_cleanup (xfree, msg);
if (!rslt)
error (_("May not have a fast tracepoint at 0x%s%s"),
- paddress (gdbarch, sal->pc), (msg ? msg : ""));
+ paddress (sarch, sal->pc), (msg ? msg : ""));
do_cleanups (old_chain);
}
int from_tty, int enabled, int internal)
{
volatile struct gdb_exception e;
- struct symtabs_and_lines sals;
- struct symtab_and_line pending_sal;
- char *copy_arg;
+ char *copy_arg = NULL;
char *addr_start = arg;
struct linespec_result canonical;
struct cleanup *old_chain;
gdb_assert (ops != NULL);
- sals.sals = NULL;
- sals.nelts = 0;
init_linespec_result (&canonical);
- if (type_wanted == bp_static_tracepoint && is_marker_spec (arg))
- {
- int i;
-
- sals = decode_static_tracepoint_spec (&arg);
-
- copy_arg = savestring (addr_start, arg - addr_start);
- canonical.canonical = xcalloc (sals.nelts, sizeof (char *));
- for (i = 0; i < sals.nelts; i++)
- canonical.canonical[i] = xstrdup (copy_arg);
- goto done;
- }
-
TRY_CATCH (e, RETURN_MASK_ALL)
{
- parse_breakpoint_sals (&arg, &sals, &canonical);
+ ops->create_sals_from_address (&arg, &canonical, type_wanted,
+ addr_start, ©_arg);
}
/* If caller is interested in rc value from parse, set value. */
switch (e.reason)
{
- case RETURN_QUIT:
- throw_exception (e);
+ case GDB_NO_ERROR:
+ if (VEC_empty (linespec_sals, canonical.sals))
+ return 0;
+ break;
case RETURN_ERROR:
switch (e.error)
{
/* If pending breakpoint support is auto query and the user
selects no, then simply return the error code. */
if (pending_break_support == AUTO_BOOLEAN_AUTO
- && !nquery (_("Make breakpoint pending on "
- "future shared library load? ")))
+ && !nquery (_("Make %s pending on future shared library load? "),
+ bptype_string (type_wanted)))
return 0;
/* At this point, either the user was queried about setting
a pending breakpoint and selected yes, or pending
breakpoint behavior is on and thus a pending breakpoint
is defaulted on behalf of the user. */
- copy_arg = xstrdup (addr_start);
- canonical.canonical = ©_arg;
- sals.nelts = 1;
- sals.sals = &pending_sal;
- pending_sal.pc = 0;
- pending = 1;
+ {
+ struct linespec_sals lsal;
+
+ copy_arg = xstrdup (addr_start);
+ lsal.canonical = xstrdup (copy_arg);
+ lsal.sals.nelts = 1;
+ lsal.sals.sals = XNEW (struct symtab_and_line);
+ init_sal (&lsal.sals.sals[0]);
+ pending = 1;
+ VEC_safe_push (linespec_sals, canonical.sals, &lsal);
+ }
break;
default:
throw_exception (e);
}
break;
default:
- if (!sals.nelts)
- return 0;
+ throw_exception (e);
}
- done:
-
/* Create a chain of things that always need to be cleaned up. */
- old_chain = make_cleanup (null_cleanup, 0);
-
- if (!pending)
- {
- /* Make sure that all storage allocated to SALS gets freed. */
- make_cleanup (xfree, sals.sals);
-
- /* Cleanup the canonical array but not its contents. */
- make_cleanup (xfree, canonical.canonical);
- }
+ old_chain = make_cleanup_destroy_linespec_result (&canonical);
/* ----------------------------- SNIP -----------------------------
Anything added to the cleanup chain beyond this point is assumed
then the memory is not reclaimed. */
bkpt_chain = make_cleanup (null_cleanup, 0);
- /* Mark the contents of the canonical for cleanup. These go on
- the bkpt_chain and only occur if the breakpoint create fails. */
- for (i = 0; i < sals.nelts; i++)
- {
- if (canonical.canonical[i] != NULL)
- make_cleanup (xfree, canonical.canonical[i]);
- }
-
/* Resolve all line numbers to PC's and verify that the addresses
are ok for the target. */
if (!pending)
- breakpoint_sals_to_pc (&sals);
+ {
+ int ix;
+ struct linespec_sals *iter;
+
+ for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
+ breakpoint_sals_to_pc (&iter->sals);
+ }
/* Fast tracepoints may have additional restrictions on location. */
- if (type_wanted == bp_fast_tracepoint)
- check_fast_tracepoint_sals (gdbarch, &sals);
+ if (!pending && type_wanted == bp_fast_tracepoint)
+ {
+ int ix;
+ struct linespec_sals *iter;
+
+ for (ix = 0; VEC_iterate (linespec_sals, canonical.sals, ix, iter); ++ix)
+ check_fast_tracepoint_sals (gdbarch, &iter->sals);
+ }
/* Verify that condition can be parsed, before setting any
breakpoints. Allocate a separate condition expression for each
breakpoint. */
if (!pending)
{
+ struct linespec_sals *lsal;
+
+ lsal = VEC_index (linespec_sals, canonical.sals, 0);
+
if (parse_condition_and_thread)
{
/* Here we only parse 'arg' to separate condition
re-parse it in context of each sal. */
cond_string = NULL;
thread = -1;
- find_condition_and_thread (arg, sals.sals[0].pc, &cond_string,
+ find_condition_and_thread (arg, lsal->sals.sals[0].pc, &cond_string,
&thread, &task);
if (cond_string)
make_cleanup (xfree, cond_string);
}
}
- /* If the user is creating a static tracepoint by marker id
- (strace -m MARKER_ID), then store the sals index, so that
- breakpoint_re_set can try to match up which of the newly
- found markers corresponds to this one, and, don't try to
- expand multiple locations for each sal, given than SALS
- already should contain all sals for MARKER_ID. */
- if (type_wanted == bp_static_tracepoint
- && is_marker_spec (canonical.canonical[0]))
- {
- int i;
-
- for (i = 0; i < sals.nelts; ++i)
- {
- struct symtabs_and_lines expanded;
- struct tracepoint *tp;
- struct cleanup *old_chain;
-
- expanded.nelts = 1;
- expanded.sals = xmalloc (sizeof (struct symtab_and_line));
- expanded.sals[0] = sals.sals[i];
- old_chain = make_cleanup (xfree, expanded.sals);
-
- tp = XCNEW (struct tracepoint);
- init_breakpoint_sal (&tp->base, gdbarch, expanded,
- canonical.canonical[i],
+ ops->create_breakpoints_sal (gdbarch, &canonical, lsal,
cond_string, type_wanted,
tempflag ? disp_del : disp_donttouch,
thread, task, ignore_count, ops,
- from_tty, enabled, internal,
- canonical.special_display);
- /* Given that its possible to have multiple markers with
- the same string id, if the user is creating a static
- tracepoint by marker id ("strace -m MARKER_ID"), then
- store the sals index, so that breakpoint_re_set can
- try to match up which of the newly found markers
- corresponds to this one */
- tp->static_trace_marker_id_idx = i;
-
- install_breakpoint (internal, &tp->base);
-
- do_cleanups (old_chain);
- }
- }
- else
- create_breakpoints_sal (gdbarch, sals, &canonical, cond_string,
- type_wanted,
- tempflag ? disp_del : disp_donttouch,
- thread, task, ignore_count, ops, from_tty,
- enabled, internal);
+ from_tty, enabled, internal);
}
else
{
make_cleanup (xfree, copy_arg);
- b = set_raw_breakpoint_without_location (gdbarch, type_wanted, ops);
- set_breakpoint_number (internal, b);
- b->thread = -1;
- b->addr_string = canonical.canonical[0];
+ if (is_tracepoint_type (type_wanted))
+ {
+ struct tracepoint *t;
+
+ t = XCNEW (struct tracepoint);
+ b = &t->base;
+ }
+ else
+ b = XNEW (struct breakpoint);
+
+ init_raw_breakpoint_without_location (b, gdbarch, type_wanted, ops);
+
+ b->addr_string = copy_arg;
b->cond_string = NULL;
b->ignore_count = ignore_count;
b->disposition = tempflag ? disp_del : disp_donttouch;
b->condition_not_parsed = 1;
b->enable_state = enabled ? bp_enabled : bp_disabled;
- b->pspace = current_program_space;
- b->py_bp_object = NULL;
-
- if (enabled && b->pspace->executing_startup
- && (b->type == bp_breakpoint
- || b->type == bp_hardware_breakpoint))
- b->enable_state = bp_startup_disabled;
+ if ((type_wanted != bp_breakpoint
+ && type_wanted != bp_hardware_breakpoint) || thread != -1)
+ b->pspace = current_program_space;
- if (!internal)
- /* Do not mention breakpoints with a negative number,
- but do notify observers. */
- mention (b);
- observer_notify_breakpoint_created (b);
+ install_breakpoint (internal, b, 0);
}
- if (sals.nelts > 1)
+ if (VEC_length (linespec_sals, canonical.sals) > 1)
{
warning (_("Multiple breakpoints were set.\nUse the "
"\"delete\" command to delete unwanted breakpoints."));
static int
breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
struct address_space *aspace,
- CORE_ADDR bp_addr)
+ CORE_ADDR bp_addr,
+ const struct target_waitstatus *ws)
{
+ if (ws->kind != TARGET_WAITKIND_STOPPED
+ || ws->value.sig != TARGET_SIGNAL_TRAP)
+ return 0;
+
return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
bl->length, aspace, bp_addr);
}
{
struct breakpoint *b = bs->breakpoint_at;
struct bp_location *bl = b->loc;
+ struct ui_out *uiout = current_uiout;
gdb_assert (b->type == bp_hardware_breakpoint);
{
struct bp_location *bl = b->loc;
struct value_print_options opts;
+ struct ui_out *uiout = current_uiout;
/* Ranged breakpoints have only one location. */
gdb_assert (bl && bl->next == NULL);
print_mention_ranged_breakpoint (struct breakpoint *b)
{
struct bp_location *bl = b->loc;
+ struct ui_out *uiout = current_uiout;
gdb_assert (bl);
gdb_assert (b->type == bp_hardware_breakpoint);
CORE_ADDR end;
struct breakpoint *b;
struct symtab_and_line sal_start, sal_end;
- struct symtabs_and_lines sals_start, sals_end;
struct cleanup *cleanup_bkpt;
+ struct linespec_sals *lsal_start, *lsal_end;
/* We don't support software ranged breakpoints. */
if (target_ranged_break_num_registers () < 0)
if (can_use_bp < 0)
error (_("Hardware breakpoints used exceeds limit."));
+ arg = skip_spaces (arg);
if (arg == NULL || arg[0] == '\0')
error(_("No address range specified."));
- sals_start.sals = NULL;
- sals_start.nelts = 0;
init_linespec_result (&canonical_start);
- while (*arg == ' ' || *arg == '\t')
- arg++;
-
- parse_breakpoint_sals (&arg, &sals_start, &canonical_start);
+ arg_start = arg;
+ parse_breakpoint_sals (&arg, &canonical_start);
- sal_start = sals_start.sals[0];
- addr_string_start = canonical_start.canonical[0];
- cleanup_bkpt = make_cleanup (xfree, addr_string_start);
- xfree (sals_start.sals);
- xfree (canonical_start.canonical);
+ cleanup_bkpt = make_cleanup_destroy_linespec_result (&canonical_start);
if (arg[0] != ',')
error (_("Too few arguments."));
- else if (sals_start.nelts == 0)
+ else if (VEC_empty (linespec_sals, canonical_start.sals))
error (_("Could not find location of the beginning of the range."));
- else if (sals_start.nelts != 1)
+
+ lsal_start = VEC_index (linespec_sals, canonical_start.sals, 0);
+
+ if (VEC_length (linespec_sals, canonical_start.sals) > 1
+ || lsal_start->sals.nelts != 1)
error (_("Cannot create a ranged breakpoint with multiple locations."));
- resolve_sal_pc (&sal_start);
+ sal_start = lsal_start->sals.sals[0];
+ addr_string_start = savestring (arg_start, arg - arg_start);
+ make_cleanup (xfree, addr_string_start);
arg++; /* Skip the comma. */
- while (*arg == ' ' || *arg == '\t')
- arg++;
+ arg = skip_spaces (arg);
/* Parse the end location. */
- sals_end.sals = NULL;
- sals_end.nelts = 0;
init_linespec_result (&canonical_end);
arg_start = arg;
- /* We call decode_line_1 directly here instead of using
+ /* We call decode_line_full directly here instead of using
parse_breakpoint_sals because we need to specify the start location's
symtab and line as the default symtab and line for the end of the
range. This makes it possible to have ranges like "foo.c:27, +14",
where +14 means 14 lines from the start location. */
- sals_end = decode_line_1 (&arg, 1, sal_start.symtab, sal_start.line,
- &canonical_end);
-
- /* canonical_end can be NULL if it was of the form "*0xdeadbeef". */
- if (canonical_end.canonical == NULL)
- canonical_end.canonical = xcalloc (1, sizeof (char *));
- /* Add the string if not present. */
- if (arg_start != arg && canonical_end.canonical[0] == NULL)
- canonical_end.canonical[0] = savestring (arg_start, arg - arg_start);
-
- sal_end = sals_end.sals[0];
- addr_string_end = canonical_end.canonical[0];
- make_cleanup (xfree, addr_string_end);
- xfree (sals_end.sals);
- xfree (canonical_end.canonical);
+ decode_line_full (&arg, DECODE_LINE_FUNFIRSTLINE,
+ sal_start.symtab, sal_start.line,
+ &canonical_end, NULL, NULL);
+
+ make_cleanup_destroy_linespec_result (&canonical_end);
- if (sals_end.nelts == 0)
+ if (VEC_empty (linespec_sals, canonical_end.sals))
error (_("Could not find location of the end of the range."));
- else if (sals_end.nelts != 1)
+
+ lsal_end = VEC_index (linespec_sals, canonical_end.sals, 0);
+ if (VEC_length (linespec_sals, canonical_end.sals) > 1
+ || lsal_end->sals.nelts != 1)
error (_("Cannot create a ranged breakpoint with multiple locations."));
- resolve_sal_pc (&sal_end);
+ sal_end = lsal_end->sals.sals[0];
+ addr_string_end = savestring (arg_start, arg - arg_start);
+ make_cleanup (xfree, addr_string_end);
end = find_breakpoint_range_end (sal_end);
if (sal_start.pc > end)
set_breakpoint_count (breakpoint_count + 1);
b->number = breakpoint_count;
b->disposition = disp_donttouch;
- b->addr_string = addr_string_start;
- b->addr_string_range_end = addr_string_end;
+ b->addr_string = xstrdup (addr_string_start);
+ b->addr_string_range_end = xstrdup (addr_string_end);
b->loc->length = length;
- discard_cleanups (cleanup_bkpt);
+ do_cleanups (cleanup_bkpt);
mention (b);
observer_notify_breakpoint_created (b);
means EXP is variable. Also the constant detection may fail for
some constant expressions and in such case still falsely return
zero. */
+
static int
watchpoint_exp_is_const (const struct expression *exp)
{
case UNOP_COMPLEMENT:
case UNOP_ADDR:
case UNOP_HIGH:
+ case UNOP_CAST:
/* Unary, binary and ternary operators: We have to check
their operands. If they are constant, then so is the
result of that operation. For instance, if A and B are
static int
breakpoint_hit_watchpoint (const struct bp_location *bl,
- struct address_space *aspace, CORE_ADDR bp_addr)
+ struct address_space *aspace, CORE_ADDR bp_addr,
+ const struct target_waitstatus *ws)
{
struct breakpoint *b = bl->owner;
struct watchpoint *w = (struct watchpoint *) b;
struct ui_stream *stb;
enum print_stop_action result;
struct watchpoint *w;
+ struct ui_out *uiout = current_uiout;
gdb_assert (bs->bp_location_at != NULL);
{
struct cleanup *ui_out_chain;
struct watchpoint *w = (struct watchpoint *) b;
+ struct ui_out *uiout = current_uiout;
switch (b->type)
{
print_it_masked_watchpoint (bpstat bs)
{
struct breakpoint *b = bs->breakpoint_at;
+ struct ui_out *uiout = current_uiout;
/* Masked watchpoints have only one location. */
gdb_assert (b->loc && b->loc->next == NULL);
print_mention_masked_watchpoint (struct breakpoint *b)
{
struct watchpoint *w = (struct watchpoint *) b;
+ struct ui_out *uiout = current_uiout;
struct cleanup *ui_out_chain;
switch (b->type)
throw_exception (e);
}
- install_breakpoint (internal, b);
+ install_breakpoint (internal, b, 1);
}
/* Return count of debug registers needed to watch the given expression.
struct symtabs_and_lines sals;
struct symtab_and_line sal;
struct frame_info *frame = get_selected_frame (NULL);
+ struct gdbarch *frame_gdbarch = get_frame_arch (frame);
+ struct frame_id stack_frame_id = get_stack_frame_id (frame);
+ struct frame_id caller_frame_id = frame_unwind_caller_id (frame);
struct breakpoint *breakpoint;
struct breakpoint *breakpoint2 = NULL;
struct cleanup *old_chain;
/* Set a breakpoint where the user wants it and at return from
this function. */
- if (default_breakpoint_valid)
- sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
- default_breakpoint_line, NULL);
+ if (last_displayed_sal_is_valid ())
+ sals = decode_line_1 (&arg, DECODE_LINE_FUNFIRSTLINE,
+ get_last_displayed_symtab (),
+ get_last_displayed_line ());
else
- sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, NULL);
+ sals = decode_line_1 (&arg, DECODE_LINE_FUNFIRSTLINE,
+ (struct symtab *) NULL, 0);
if (sals.nelts != 1)
error (_("Couldn't get information on specified line."));
resolve_sal_pc (&sal);
- if (anywhere)
- /* If the user told us to continue until a specified location,
- we don't specify a frame at which we need to stop. */
- breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
- null_frame_id, bp_until);
- else
- /* Otherwise, specify the selected frame, because we want to stop
- only at the very same frame. */
- breakpoint = set_momentary_breakpoint (get_frame_arch (frame), sal,
- get_stack_frame_id (frame),
- bp_until);
-
- old_chain = make_cleanup_delete_breakpoint (breakpoint);
-
tp = inferior_thread ();
thread = tp->num;
+ old_chain = make_cleanup (null_cleanup, NULL);
+
+ /* Installing a breakpoint invalidates the frame chain (as it may
+ need to switch threads), so do any frame handling first. */
+
/* Keep within the current frame, or in frames called by the current
one. */
- if (frame_id_p (frame_unwind_caller_id (frame)))
+ if (frame_id_p (caller_frame_id))
{
- sal = find_pc_line (frame_unwind_caller_pc (frame), 0);
- sal.pc = frame_unwind_caller_pc (frame);
+ struct symtab_and_line sal2;
+
+ sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
+ sal2.pc = frame_unwind_caller_pc (frame);
breakpoint2 = set_momentary_breakpoint (frame_unwind_caller_arch (frame),
- sal,
- frame_unwind_caller_id (frame),
+ sal2,
+ caller_frame_id,
bp_until);
make_cleanup_delete_breakpoint (breakpoint2);
- set_longjmp_breakpoint (tp, frame_unwind_caller_id (frame));
+ set_longjmp_breakpoint (tp, caller_frame_id);
make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
}
+ /* set_momentary_breakpoint could invalidate FRAME. */
+ frame = NULL;
+
+ if (anywhere)
+ /* If the user told us to continue until a specified location,
+ we don't specify a frame at which we need to stop. */
+ breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
+ null_frame_id, bp_until);
+ else
+ /* Otherwise, specify the selected frame, because we want to stop
+ only at the very same frame. */
+ breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
+ stack_frame_id, bp_until);
+ make_cleanup_delete_breakpoint (breakpoint);
+
proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
/* If we are running asynchronously, and proceed call above has
&catch_exec_breakpoint_ops);
c->exec_pathname = NULL;
- install_breakpoint (0, &c->base);
+ install_breakpoint (0, &c->base, 1);
}
static enum print_stop_action
print_it_exception_catchpoint (bpstat bs)
{
+ struct ui_out *uiout = current_uiout;
struct breakpoint *b = bs->breakpoint_at;
int bp_temp, bp_throw;
struct bp_location **last_loc)
{
struct value_print_options opts;
+ struct ui_out *uiout = current_uiout;
get_user_print_options (&opts);
if (opts.addressprint)
static void
print_mention_exception_catchpoint (struct breakpoint *b)
{
+ struct ui_out *uiout = current_uiout;
int bp_temp;
int bp_throw;
b->language = language_ada;
}
-/* Cleanup function for a syscall filter list. */
-static void
-clean_up_filters (void *arg)
-{
- VEC(int) *iter = *(VEC(int) **) arg;
- VEC_free (int, iter);
-}
-
/* Splits the argument using space as delimiter. Returns an xmalloc'd
filter list, or NULL if no filtering is required. */
static VEC(int) *
catch_syscall_split_args (char *arg)
{
VEC(int) *result = NULL;
- struct cleanup *cleanup = make_cleanup (clean_up_filters, &result);
+ struct cleanup *cleanup = make_cleanup (VEC_cleanup (int), &result);
while (*arg != '\0')
{
error (_("Catch requires an event name."));
}
+/* A qsort comparison function that sorts breakpoints in order. */
+
+static int
+compare_breakpoints (const void *a, const void *b)
+{
+ const breakpoint_p *ba = a;
+ uintptr_t ua = (uintptr_t) *ba;
+ const breakpoint_p *bb = b;
+ uintptr_t ub = (uintptr_t) *bb;
+
+ if ((*ba)->number < (*bb)->number)
+ return -1;
+ else if ((*ba)->number > (*bb)->number)
+ return 1;
+
+ /* Now sort by address, in case we see, e..g, two breakpoints with
+ the number 0. */
+ if (ua < ub)
+ return -1;
+ return ub > ub ? 1 : 0;
+}
+
/* Delete breakpoints by address or line. */
static void
clear_command (char *arg, int from_tty)
{
- struct breakpoint *b;
+ struct breakpoint *b, *prev;
VEC(breakpoint_p) *found = 0;
int ix;
int default_match;
struct symtabs_and_lines sals;
struct symtab_and_line sal;
int i;
+ struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
if (arg)
{
- sals = decode_line_spec (arg, 1);
+ sals = decode_line_spec (arg, (DECODE_LINE_FUNFIRSTLINE
+ | DECODE_LINE_LIST_MODE));
default_match = 0;
}
else
xmalloc (sizeof (struct symtab_and_line));
make_cleanup (xfree, sals.sals);
init_sal (&sal); /* Initialize to zeroes. */
- sal.line = default_breakpoint_line;
- sal.symtab = default_breakpoint_symtab;
- sal.pc = default_breakpoint_address;
- sal.pspace = default_breakpoint_pspace;
+
+ /* Set sal's line, symtab, pc, and pspace to the values
+ corresponding to the last call to print_frame_info. If the
+ codepoint is not valid, this will set all the fields to 0. */
+ get_last_displayed_sal (&sal);
if (sal.symtab == 0)
error (_("No source file specified."));
breakpoint. */
found = NULL;
+ make_cleanup (VEC_cleanup (breakpoint_p), &found);
for (i = 0; i < sals.nelts; i++)
{
+ int is_abs, sal_name_len;
+
/* If exact pc given, clear bpts at that pc.
If line given (pc == 0), clear all bpts on specified line.
If defaulting, clear all bpts on default line
1 0 <can't happen> */
sal = sals.sals[i];
+ is_abs = sal.symtab == NULL ? 1 : IS_ABSOLUTE_PATH (sal.symtab->filename);
+ sal_name_len = is_abs ? 0 : strlen (sal.symtab->filename);
/* Find all matching breakpoints and add them to 'found'. */
ALL_BREAKPOINTS (b)
struct bp_location *loc = b->loc;
for (; loc; loc = loc->next)
{
- int pc_match = sal.pc
- && (loc->pspace == sal.pspace)
- && (loc->address == sal.pc)
- && (!section_is_overlay (loc->section)
- || loc->section == sal.section);
- int line_match = ((default_match || (0 == sal.pc))
- && b->source_file != NULL
- && sal.symtab != NULL
- && sal.pspace == loc->pspace
- && filename_cmp (b->source_file,
- sal.symtab->filename) == 0
- && b->line_number == sal.line);
+ /* If the user specified file:line, don't allow a PC
+ match. This matches historical gdb behavior. */
+ int pc_match = (!sal.explicit_line
+ && sal.pc
+ && (loc->pspace == sal.pspace)
+ && (loc->address == sal.pc)
+ && (!section_is_overlay (loc->section)
+ || loc->section == sal.section));
+ int line_match = 0;
+
+ if ((default_match || sal.explicit_line)
+ && loc->source_file != NULL
+ && sal.symtab != NULL
+ && sal.pspace == loc->pspace
+ && loc->line_number == sal.line)
+ {
+ if (filename_cmp (loc->source_file,
+ sal.symtab->filename) == 0)
+ line_match = 1;
+ else if (!IS_ABSOLUTE_PATH (sal.symtab->filename)
+ && compare_filenames_for_search (loc->source_file,
+ sal.symtab->filename,
+ sal_name_len))
+ line_match = 1;
+ }
+
if (pc_match || line_match)
{
match = 1;
VEC_safe_push(breakpoint_p, found, b);
}
}
+
/* Now go thru the 'found' chain and delete them. */
if (VEC_empty(breakpoint_p, found))
{
error (_("No breakpoint at this line."));
}
+ /* Remove duplicates from the vec. */
+ qsort (VEC_address (breakpoint_p, found),
+ VEC_length (breakpoint_p, found),
+ sizeof (breakpoint_p),
+ compare_breakpoints);
+ prev = VEC_index (breakpoint_p, found, 0);
+ for (ix = 1; VEC_iterate (breakpoint_p, found, ix, b); ++ix)
+ {
+ if (b == prev)
+ {
+ VEC_ordered_remove (breakpoint_p, found, ix);
+ --ix;
+ }
+ }
+
if (VEC_length(breakpoint_p, found) > 1)
from_tty = 1; /* Always report if deleted more than one. */
if (from_tty)
}
if (from_tty)
putchar_unfiltered ('\n');
+
+ do_cleanups (cleanups);
}
\f
/* Delete breakpoint in BS if they are `delete' breakpoints and
if (a->address != b->address)
return (a->address > b->address) - (a->address < b->address);
+ /* Sort locations at the same address by their pspace number, keeping
+ locations of the same inferior (in a multi-inferior environment)
+ grouped. */
+
+ if (a->pspace->num != b->pspace->num)
+ return ((a->pspace->num > b->pspace->num)
+ - (a->pspace->num < b->pspace->num));
+
/* Sort permanent breakpoints first. */
if (a_perm != b_perm)
return (a_perm < b_perm) - (a_perm > b_perm);
- /* Make the user-visible order stable across GDB runs. Locations of
- the same breakpoint can be sorted in arbitrary order. */
+ /* Make the internal GDB representation stable across GDB runs
+ where A and B memory inside GDB can differ. Breakpoint locations of
+ the same type at the same address can be sorted in arbitrary order. */
if (a->owner->number != b->owner->number)
- return (a->owner->number > b->owner->number)
- - (a->owner->number < b->owner->number);
+ return ((a->owner->number > b->owner->number)
+ - (a->owner->number < b->owner->number));
return (a > b) - (a < b);
}
}
}
+/* Download tracepoint locations if they haven't been. */
+
+static void
+download_tracepoint_locations (void)
+{
+ struct bp_location *bl, **blp_tmp;
+ struct cleanup *old_chain;
+
+ if (!target_can_download_tracepoint ())
+ return;
+
+ old_chain = save_current_space_and_thread ();
+
+ ALL_BP_LOCATIONS (bl, blp_tmp)
+ {
+ struct tracepoint *t;
+
+ if (!is_tracepoint (bl->owner))
+ continue;
+
+ if ((bl->owner->type == bp_fast_tracepoint
+ ? !may_insert_fast_tracepoints
+ : !may_insert_tracepoints))
+ continue;
+
+ /* In tracepoint, locations are _never_ duplicated, so
+ should_be_inserted is equivalent to
+ unduplicated_should_be_inserted. */
+ if (!should_be_inserted (bl) || bl->inserted)
+ continue;
+
+ switch_to_program_space_and_thread (bl->pspace);
+
+ target_download_tracepoint (bl);
+
+ bl->inserted = 1;
+ t = (struct tracepoint *) bl->owner;
+ t->number_on_target = bl->owner->number;
+ }
+
+ do_cleanups (old_chain);
+}
+
/* Swap the insertion/duplication state between two locations. */
static void
{
const int left_inserted = left->inserted;
const int left_duplicate = left->duplicate;
+ const int left_needs_update = left->needs_update;
const struct bp_target_info left_target_info = left->target_info;
+ /* Locations of tracepoints can never be duplicated. */
+ if (is_tracepoint (left->owner))
+ gdb_assert (!left->duplicate);
+ if (is_tracepoint (right->owner))
+ gdb_assert (!right->duplicate);
+
left->inserted = right->inserted;
left->duplicate = right->duplicate;
+ left->needs_update = right->needs_update;
left->target_info = right->target_info;
right->inserted = left_inserted;
right->duplicate = left_duplicate;
+ right->needs_update = left_needs_update;
right->target_info = left_target_info;
}
+/* Force the re-insertion of the locations at ADDRESS. This is called
+ once a new/deleted/modified duplicate location is found and we are evaluating
+ conditions on the target's side. Such conditions need to be updated on
+ the target. */
+
+static void
+force_breakpoint_reinsertion (struct bp_location *bl)
+{
+ struct bp_location **locp = NULL, **loc2p;
+ struct bp_location *loc;
+ CORE_ADDR address = 0;
+ int pspace_num;
+
+ address = bl->address;
+ pspace_num = bl->pspace->num;
+
+ /* This is only meaningful if the target is
+ evaluating conditions and if the user has
+ opted for condition evaluation on the target's
+ side. */
+ if (gdb_evaluates_breakpoint_condition_p ()
+ || !target_supports_evaluation_of_breakpoint_conditions ())
+ return;
+
+ /* Flag all breakpoint locations with this address and
+ the same program space as the location
+ as "its condition has changed". We need to
+ update the conditions on the target's side. */
+ ALL_BP_LOCATIONS_AT_ADDR (loc2p, locp, address)
+ {
+ loc = *loc2p;
+
+ if (!is_breakpoint (loc->owner)
+ || pspace_num != loc->pspace->num)
+ continue;
+
+ /* Flag the location appropriately. We use a different state to
+ let everyone know that we already updated the set of locations
+ with addr bl->address and program space bl->pspace. This is so
+ we don't have to keep calling these functions just to mark locations
+ that have already been marked. */
+ loc->condition_changed = condition_updated;
+
+ /* Free the agent expression bytecode as well. We will compute
+ it later on. */
+ if (loc->cond_bytecode)
+ {
+ free_agent_expr (loc->cond_bytecode);
+ loc->cond_bytecode = NULL;
+ }
+ }
+}
+
/* If SHOULD_INSERT is false, do not insert any breakpoint locations
into the inferior, only remove already-inserted locations that no
longer should be inserted. Functions that delete a breakpoint or
struct breakpoint *b;
struct bp_location **locp, *loc;
struct cleanup *cleanups;
+ /* Last breakpoint location address that was marked for update. */
+ CORE_ADDR last_addr = 0;
+ /* Last breakpoint location program space that was marked for update. */
+ int last_pspace_num = -1;
/* Used in the duplicates detection below. When iterating over all
bp_locations, points to the first bp_location of a given address.
&& (*loc2p)->address == old_loc->address);
loc2p++)
{
- if (*loc2p == old_loc)
+ /* Check if this is a new/duplicated location or a duplicated
+ location that had its condition modified. If so, we want to send
+ its condition to the target if evaluation of conditions is taking
+ place there. */
+ if ((*loc2p)->condition_changed == condition_modified
+ && (last_addr != old_loc->address
+ || last_pspace_num != old_loc->pspace->num))
{
- found_object = 1;
- break;
+ force_breakpoint_reinsertion (*loc2p);
+ last_pspace_num = old_loc->pspace->num;
}
+
+ if (*loc2p == old_loc)
+ found_object = 1;
}
+ /* We have already handled this address, update it so that we don't
+ have to go through updates again. */
+ last_addr = old_loc->address;
+
+ /* Target-side condition evaluation: Handle deleted locations. */
+ if (!found_object)
+ force_breakpoint_reinsertion (old_loc);
+
/* If this location is no longer present, and inserted, look if
there's maybe a new location at the same address. If so,
mark that one inserted, and don't remove this one. This is
}
else
{
+ /* This location still exists, but it won't be kept in the
+ target since it may have been disabled. We proceed to
+ remove its target-side condition. */
+
/* The location is either no longer present, or got
disabled. See if there's another location at the
same address, in which case we don't need to remove
{
/* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
non-NULL. */
- struct breakpoint *b = loc->owner;
struct bp_location **loc_first_p;
+ b = loc->owner;
- if (b->enable_state == bp_disabled
- || b->enable_state == bp_call_disabled
- || b->enable_state == bp_startup_disabled
- || !loc->enabled
- || loc->shlib_disabled
+ if (!should_be_inserted (loc)
|| !breakpoint_address_is_meaningful (b)
+ /* Don't detect duplicate for tracepoint locations because they are
+ never duplicated. See the comments in field `duplicate' of
+ `struct bp_location'. */
|| is_tracepoint (b))
- continue;
+ {
+ /* Clear the condition modification flag. */
+ loc->condition_changed = condition_unchanged;
+ continue;
+ }
/* Permanent breakpoint should always be inserted. */
if (b->enable_state == bp_permanent && ! loc->inserted)
{
*loc_first_p = loc;
loc->duplicate = 0;
+
+ if (is_breakpoint (loc->owner) && loc->condition_changed)
+ {
+ loc->needs_update = 1;
+ /* Clear the condition modification flag. */
+ loc->condition_changed = condition_unchanged;
+ }
continue;
}
swap_insertion (loc, *loc_first_p);
loc->duplicate = 1;
+ /* Clear the condition modification flag. */
+ loc->condition_changed = condition_unchanged;
+
if ((*loc_first_p)->owner->enable_state == bp_permanent && loc->inserted
&& b->enable_state != bp_permanent)
internal_error (__FILE__, __LINE__,
"a permanent breakpoint"));
}
- if (breakpoints_always_inserted_mode () && should_insert
+ if (breakpoints_always_inserted_mode ()
&& (have_live_inferiors ()
|| (gdbarch_has_global_breakpoints (target_gdbarch))))
- insert_breakpoint_locations ();
+ {
+ if (should_insert)
+ insert_breakpoint_locations ();
+ else
+ {
+ /* Though should_insert is false, we may need to update conditions
+ on the target's side if it is evaluating such conditions. We
+ only update conditions for locations that are marked
+ "needs_update". */
+ update_inserted_breakpoint_locations ();
+ }
+ }
+
+ if (should_insert)
+ download_tracepoint_locations ();
do_cleanups (cleanups);
}
static void
update_global_location_list_nothrow (int inserting)
{
- struct gdb_exception e;
+ volatile struct gdb_exception e;
TRY_CATCH (e, RETURN_MASK_ERROR)
update_global_location_list (inserting);
static void
say_where (struct breakpoint *b)
{
+ struct ui_out *uiout = current_uiout;
struct value_print_options opts;
get_user_print_options (&opts);
}
else
{
- if (opts.addressprint || b->source_file == NULL)
+ if (opts.addressprint || b->loc->source_file == NULL)
{
printf_filtered (" at ");
fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
gdb_stdout);
}
- if (b->source_file)
- printf_filtered (": file %s, line %d.",
- b->source_file, b->line_number);
+ if (b->loc->source_file)
+ {
+ /* If there is a single location, we can print the location
+ more nicely. */
+ if (b->loc->next == NULL)
+ printf_filtered (": file %s, line %d.",
+ b->loc->source_file, b->loc->line_number);
+ else
+ /* This is not ideal, but each location may have a
+ different file name, and this at least reflects the
+ real situation somewhat. */
+ printf_filtered (": %s.", b->addr_string);
+ }
if (b->loc->next)
{
bp_location_dtor (struct bp_location *self)
{
xfree (self->cond);
+ if (self->cond_bytecode)
+ free_agent_expr (self->cond_bytecode);
xfree (self->function_name);
+ xfree (self->source_file);
}
static const struct bp_location_ops bp_location_ops =
decref_counted_command_line (&self->commands);
xfree (self->cond_string);
xfree (self->addr_string);
+ xfree (self->filter);
xfree (self->addr_string_range_end);
- xfree (self->source_file);
}
static struct bp_location *
static int
base_breakpoint_breakpoint_hit (const struct bp_location *bl,
struct address_space *aspace,
- CORE_ADDR bp_addr)
+ CORE_ADDR bp_addr,
+ const struct target_waitstatus *ws)
{
internal_error_pure_virtual_called ();
}
internal_error_pure_virtual_called ();
}
+static void
+base_breakpoint_create_sals_from_address (char **arg,
+ struct linespec_result *canonical,
+ enum bptype type_wanted,
+ char *addr_start,
+ char **copy_arg)
+{
+ internal_error_pure_virtual_called ();
+}
+
+static void
+base_breakpoint_create_breakpoints_sal (struct gdbarch *gdbarch,
+ struct linespec_result *c,
+ struct linespec_sals *lsal,
+ char *cond_string,
+ enum bptype type_wanted,
+ enum bpdisp disposition,
+ int thread,
+ int task, int ignore_count,
+ const struct breakpoint_ops *o,
+ int from_tty, int enabled,
+ int internal)
+{
+ internal_error_pure_virtual_called ();
+}
+
+static void
+base_breakpoint_decode_linespec (struct breakpoint *b, char **s,
+ struct symtabs_and_lines *sals)
+{
+ internal_error_pure_virtual_called ();
+}
+
static struct breakpoint_ops base_breakpoint_ops =
{
base_breakpoint_dtor,
NULL,
base_breakpoint_print_one_detail,
base_breakpoint_print_mention,
- base_breakpoint_print_recreate
+ base_breakpoint_print_recreate,
+ base_breakpoint_create_sals_from_address,
+ base_breakpoint_create_breakpoints_sal,
+ base_breakpoint_decode_linespec,
};
/* Default breakpoint_ops methods. */
static void
bkpt_re_set (struct breakpoint *b)
{
- /* Do not attempt to re-set breakpoints disabled during startup. */
- if (b->enable_state == bp_startup_disabled)
- return;
-
/* FIXME: is this still reachable? */
if (b->addr_string == NULL)
{
static int
bkpt_breakpoint_hit (const struct bp_location *bl,
- struct address_space *aspace, CORE_ADDR bp_addr)
+ struct address_space *aspace, CORE_ADDR bp_addr,
+ const struct target_waitstatus *ws)
{
struct breakpoint *b = bl->owner;
+ if (ws->kind != TARGET_WAITKIND_STOPPED
+ || ws->value.sig != TARGET_SIGNAL_TRAP)
+ return 0;
+
if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
aspace, bp_addr))
return 0;
struct breakpoint *b;
const struct bp_location *bl;
int bp_temp;
+ struct ui_out *uiout = current_uiout;
gdb_assert (bs->bp_location_at != NULL);
static void
bkpt_print_mention (struct breakpoint *b)
{
- if (ui_out_is_mi_like_p (uiout))
+ if (ui_out_is_mi_like_p (current_uiout))
return;
switch (b->type)
_("unhandled breakpoint type %d"), (int) tp->type);
fprintf_unfiltered (fp, " %s", tp->addr_string);
+ print_recreate_thread (tp, fp);
+}
+
+static void
+bkpt_create_sals_from_address (char **arg,
+ struct linespec_result *canonical,
+ enum bptype type_wanted,
+ char *addr_start, char **copy_arg)
+{
+ create_sals_from_address_default (arg, canonical, type_wanted,
+ addr_start, copy_arg);
+}
+
+static void
+bkpt_create_breakpoints_sal (struct gdbarch *gdbarch,
+ struct linespec_result *canonical,
+ struct linespec_sals *lsal,
+ char *cond_string,
+ enum bptype type_wanted,
+ enum bpdisp disposition,
+ int thread,
+ int task, int ignore_count,
+ const struct breakpoint_ops *ops,
+ int from_tty, int enabled,
+ int internal)
+{
+ create_breakpoints_sal_default (gdbarch, canonical, lsal,
+ cond_string, type_wanted,
+ disposition, thread, task,
+ ignore_count, ops, from_tty,
+ enabled, internal);
+}
+
+static void
+bkpt_decode_linespec (struct breakpoint *b, char **s,
+ struct symtabs_and_lines *sals)
+{
+ decode_linespec_default (b, s, sals);
}
/* Virtual table for internal breakpoints. */
static void
internal_bkpt_check_status (bpstat bs)
{
- /* We do not stop for these. */
- bs->stop = 0;
+ if (bs->breakpoint_at->type == bp_shlib_event)
+ {
+ /* If requested, stop when the dynamic linker notifies GDB of
+ events. This allows the user to get control and place
+ breakpoints in initializer routines for dynamically loaded
+ objects (among other things). */
+ bs->stop = stop_on_solib_events;
+ bs->print = stop_on_solib_events;
+ }
+ else
+ bs->stop = 0;
}
static enum print_stop_action
internal_bkpt_print_it (bpstat bs)
{
+ struct ui_out *uiout = current_uiout;
struct breakpoint *b;
b = bs->breakpoint_at;
/* Did we stop because the user set the stop_on_solib_events
variable? (If so, we report this as a generic, "Stopped due
to shlib event" message.) */
- printf_filtered (_("Stopped due to shared library event\n"));
+ print_solib_event (0);
break;
case bp_thread_event:
static enum print_stop_action
momentary_bkpt_print_it (bpstat bs)
{
+ struct ui_out *uiout = current_uiout;
+
if (ui_out_is_mi_like_p (uiout))
{
struct breakpoint *b = bs->breakpoint_at;
static int
tracepoint_breakpoint_hit (const struct bp_location *bl,
- struct address_space *aspace, CORE_ADDR bp_addr)
+ struct address_space *aspace, CORE_ADDR bp_addr,
+ const struct target_waitstatus *ws)
{
/* By definition, the inferior does not report stops at
tracepoints. */
static void
tracepoint_print_mention (struct breakpoint *b)
{
- if (ui_out_is_mi_like_p (uiout))
+ if (ui_out_is_mi_like_p (current_uiout))
return;
switch (b->type)
fprintf_unfiltered (fp, " passcount %d\n", tp->pass_count);
}
+static void
+tracepoint_create_sals_from_address (char **arg,
+ struct linespec_result *canonical,
+ enum bptype type_wanted,
+ char *addr_start, char **copy_arg)
+{
+ create_sals_from_address_default (arg, canonical, type_wanted,
+ addr_start, copy_arg);
+}
+
+static void
+tracepoint_create_breakpoints_sal (struct gdbarch *gdbarch,
+ struct linespec_result *canonical,
+ struct linespec_sals *lsal,
+ char *cond_string,
+ enum bptype type_wanted,
+ enum bpdisp disposition,
+ int thread,
+ int task, int ignore_count,
+ const struct breakpoint_ops *ops,
+ int from_tty, int enabled,
+ int internal)
+{
+ create_breakpoints_sal_default (gdbarch, canonical, lsal,
+ cond_string, type_wanted,
+ disposition, thread, task,
+ ignore_count, ops, from_tty,
+ enabled, internal);
+}
+
+static void
+tracepoint_decode_linespec (struct breakpoint *b, char **s,
+ struct symtabs_and_lines *sals)
+{
+ decode_linespec_default (b, s, sals);
+}
+
struct breakpoint_ops tracepoint_breakpoint_ops;
+/* The breakpoint_ops structure to be used on static tracepoints with
+ markers (`-m'). */
+
+static void
+strace_marker_create_sals_from_address (char **arg,
+ struct linespec_result *canonical,
+ enum bptype type_wanted,
+ char *addr_start, char **copy_arg)
+{
+ struct linespec_sals lsal;
+
+ lsal.sals = decode_static_tracepoint_spec (arg);
+
+ *copy_arg = savestring (addr_start, *arg - addr_start);
+
+ canonical->addr_string = xstrdup (*copy_arg);
+ lsal.canonical = xstrdup (*copy_arg);
+ VEC_safe_push (linespec_sals, canonical->sals, &lsal);
+}
+
+static void
+strace_marker_create_breakpoints_sal (struct gdbarch *gdbarch,
+ struct linespec_result *canonical,
+ struct linespec_sals *lsal,
+ char *cond_string,
+ enum bptype type_wanted,
+ enum bpdisp disposition,
+ int thread,
+ int task, int ignore_count,
+ const struct breakpoint_ops *ops,
+ int from_tty, int enabled,
+ int internal)
+{
+ int i;
+
+ /* If the user is creating a static tracepoint by marker id
+ (strace -m MARKER_ID), then store the sals index, so that
+ breakpoint_re_set can try to match up which of the newly
+ found markers corresponds to this one, and, don't try to
+ expand multiple locations for each sal, given than SALS
+ already should contain all sals for MARKER_ID. */
+
+ for (i = 0; i < lsal->sals.nelts; ++i)
+ {
+ struct symtabs_and_lines expanded;
+ struct tracepoint *tp;
+ struct cleanup *old_chain;
+ char *addr_string;
+
+ expanded.nelts = 1;
+ expanded.sals = &lsal->sals.sals[i];
+
+ addr_string = xstrdup (canonical->addr_string);
+ old_chain = make_cleanup (xfree, addr_string);
+
+ tp = XCNEW (struct tracepoint);
+ init_breakpoint_sal (&tp->base, gdbarch, expanded,
+ addr_string, NULL,
+ cond_string, type_wanted, disposition,
+ thread, task, ignore_count, ops,
+ from_tty, enabled, internal,
+ canonical->special_display);
+ /* Given that its possible to have multiple markers with
+ the same string id, if the user is creating a static
+ tracepoint by marker id ("strace -m MARKER_ID"), then
+ store the sals index, so that breakpoint_re_set can
+ try to match up which of the newly found markers
+ corresponds to this one */
+ tp->static_trace_marker_id_idx = i;
+
+ install_breakpoint (internal, &tp->base, 0);
+
+ discard_cleanups (old_chain);
+ }
+}
+
+static void
+strace_marker_decode_linespec (struct breakpoint *b, char **s,
+ struct symtabs_and_lines *sals)
+{
+ struct tracepoint *tp = (struct tracepoint *) b;
+
+ *sals = decode_static_tracepoint_spec (s);
+ if (sals->nelts > tp->static_trace_marker_id_idx)
+ {
+ sals->sals[0] = sals->sals[tp->static_trace_marker_id_idx];
+ sals->nelts = 1;
+ }
+ else
+ error (_("marker %s not found"), tp->static_trace_marker_id);
+}
+
+static struct breakpoint_ops strace_marker_breakpoint_ops;
+
+static int
+strace_marker_p (struct breakpoint *b)
+{
+ return b->ops == &strace_marker_breakpoint_ops;
+}
+
/* Delete a breakpoint and clean up all traces of it in the data
structures. */
all_locations_are_pending (struct bp_location *loc)
{
for (; loc; loc = loc->next)
- if (!loc->shlib_disabled)
+ if (!loc->shlib_disabled
+ && !loc->pspace->executing_startup)
return 0;
return 1;
}
if (!VEC_empty(static_tracepoint_marker_p, markers))
{
- struct symtab_and_line sal;
+ struct symtab_and_line sal2;
struct symbol *sym;
- struct static_tracepoint_marker *marker;
+ struct static_tracepoint_marker *tpmarker;
+ struct ui_out *uiout = current_uiout;
- marker = VEC_index (static_tracepoint_marker_p, markers, 0);
+ tpmarker = VEC_index (static_tracepoint_marker_p, markers, 0);
xfree (tp->static_trace_marker_id);
- tp->static_trace_marker_id = xstrdup (marker->str_id);
+ tp->static_trace_marker_id = xstrdup (tpmarker->str_id);
warning (_("marker for static tracepoint %d (%s) not "
"found at previous line number"),
b->number, tp->static_trace_marker_id);
- init_sal (&sal);
+ init_sal (&sal2);
- sal.pc = marker->address;
+ sal2.pc = tpmarker->address;
- sal = find_pc_line (marker->address, 0);
- sym = find_pc_sect_function (marker->address, NULL);
+ sal2 = find_pc_line (tpmarker->address, 0);
+ sym = find_pc_sect_function (tpmarker->address, NULL);
ui_out_text (uiout, "Now in ");
if (sym)
{
SYMBOL_PRINT_NAME (sym));
ui_out_text (uiout, " at ");
}
- ui_out_field_string (uiout, "file", sal.symtab->filename);
+ ui_out_field_string (uiout, "file", sal2.symtab->filename);
ui_out_text (uiout, ":");
if (ui_out_is_mi_like_p (uiout))
{
- char *fullname = symtab_to_fullname (sal.symtab);
+ char *fullname = symtab_to_fullname (sal2.symtab);
if (fullname)
ui_out_field_string (uiout, "fullname", fullname);
}
- ui_out_field_int (uiout, "line", sal.line);
+ ui_out_field_int (uiout, "line", sal2.line);
ui_out_text (uiout, "\n");
- b->line_number = sal.line;
+ b->loc->line_number = sal2.line;
- xfree (b->source_file);
+ xfree (b->loc->source_file);
if (sym)
- b->source_file = xstrdup (sal.symtab->filename);
+ b->loc->source_file = xstrdup (sal2.symtab->filename);
else
- b->source_file = NULL;
+ b->loc->source_file = NULL;
xfree (b->addr_string);
b->addr_string = xstrprintf ("%s:%d",
- sal.symtab->filename, b->line_number);
+ sal2.symtab->filename,
+ b->loc->line_number);
/* Might be nice to check if function changed, and warn if
so. */
- release_static_tracepoint_marker (marker);
+ release_static_tracepoint_marker (tpmarker);
}
}
return sal;
int i;
struct bp_location *existing_locations = b->loc;
- /* Ranged breakpoints have only one start location and one end location. */
- gdb_assert (sals_end.nelts == 0 || (sals.nelts == 1 && sals_end.nelts == 1));
+ if (sals_end.nelts != 0 && (sals.nelts != 1 || sals_end.nelts != 1))
+ {
+ /* Ranged breakpoints have only one start location and one end
+ location. */
+ b->enable_state = bp_disabled;
+ update_global_location_list (1);
+ printf_unfiltered (_("Could not reset ranged breakpoint %d: "
+ "multiple locations found\n"),
+ b->number);
+ return;
+ }
/* If there's no new locations, and all existing locations are
pending, don't do anything. This optimizes the common case where
for (i = 0; i < sals.nelts; ++i)
{
- struct bp_location *new_loc =
- add_location_to_breakpoint (b, &(sals.sals[i]));
+ struct bp_location *new_loc;
+
+ switch_to_program_space_and_thread (sals.sals[i].pspace);
+
+ new_loc = add_location_to_breakpoint (b, &(sals.sals[i]));
/* Reparse conditions, they might contain references to the
old symtab. */
if (b->cond_string != NULL)
{
char *s;
- struct gdb_exception e;
+ volatile struct gdb_exception e;
s = b->cond_string;
TRY_CATCH (e, RETURN_MASK_ERROR)
}
}
- if (b->source_file != NULL)
- xfree (b->source_file);
- if (sals.sals[i].symtab == NULL)
- b->source_file = NULL;
- else
- b->source_file = xstrdup (sals.sals[i].symtab->filename);
-
- if (b->line_number == 0)
- b->line_number = sals.sals[i].line;
-
if (sals_end.nelts)
{
CORE_ADDR end = find_breakpoint_range_end (sals_end.sals[0]);
addr_string_to_sals (struct breakpoint *b, char *addr_string, int *found)
{
char *s;
- int marker_spec;
struct symtabs_and_lines sals = {0};
- struct gdb_exception e;
+ volatile struct gdb_exception e;
+ gdb_assert (b->ops != NULL);
s = addr_string;
- marker_spec = b->type == bp_static_tracepoint && is_marker_spec (s);
TRY_CATCH (e, RETURN_MASK_ERROR)
{
- if (marker_spec)
- {
- struct tracepoint *tp = (struct tracepoint *) b;
-
- sals = decode_static_tracepoint_spec (&s);
- if (sals.nelts > tp->static_trace_marker_id_idx)
- {
- sals.sals[0] = sals.sals[tp->static_trace_marker_id_idx];
- sals.nelts = 1;
- }
- else
- error (_("marker %s not found"), tp->static_trace_marker_id);
- }
- else
- sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, NULL);
+ b->ops->decode_linespec (b, &s, &sals);
}
if (e.reason < 0)
{
if (e.error == NOT_FOUND_ERROR
&& (b->condition_not_parsed
|| (b->loc && b->loc->shlib_disabled)
+ || (b->loc && b->loc->pspace->executing_startup)
|| b->enable_state == bp_disabled))
not_found_and_ok = 1;
if (e.reason == 0 || e.error != NOT_FOUND_ERROR)
{
- gdb_assert (sals.nelts == 1);
+ int i;
- resolve_sal_pc (&sals.sals[0]);
+ for (i = 0; i < sals.nelts; ++i)
+ resolve_sal_pc (&sals.sals[i]);
if (b->condition_not_parsed && s && s[0])
{
char *cond_string = 0;
b->condition_not_parsed = 0;
}
- if (b->type == bp_static_tracepoint && !marker_spec)
+ if (b->type == bp_static_tracepoint && !strace_marker_p (b))
sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
*found = 1;
if (found)
{
make_cleanup (xfree, sals.sals);
- expanded = expand_line_sal_maybe (sals.sals[0]);
+ expanded = sals;
}
if (b->addr_string_range_end)
if (found)
{
make_cleanup (xfree, sals_end.sals);
- expanded_end = expand_line_sal_maybe (sals_end.sals[0]);
+ expanded_end = sals_end;
}
}
update_breakpoint_locations (b, expanded, expanded_end);
}
+/* Default method for creating SALs from an address string. It basically
+ calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
+
+static void
+create_sals_from_address_default (char **arg,
+ struct linespec_result *canonical,
+ enum bptype type_wanted,
+ char *addr_start, char **copy_arg)
+{
+ parse_breakpoint_sals (arg, canonical);
+}
+
+/* Call create_breakpoints_sal for the given arguments. This is the default
+ function for the `create_breakpoints_sal' method of
+ breakpoint_ops. */
+
+static void
+create_breakpoints_sal_default (struct gdbarch *gdbarch,
+ struct linespec_result *canonical,
+ struct linespec_sals *lsal,
+ char *cond_string,
+ enum bptype type_wanted,
+ enum bpdisp disposition,
+ int thread,
+ int task, int ignore_count,
+ const struct breakpoint_ops *ops,
+ int from_tty, int enabled,
+ int internal)
+{
+ create_breakpoints_sal (gdbarch, canonical, cond_string,
+ type_wanted, disposition,
+ thread, task, ignore_count, ops, from_tty,
+ enabled, internal);
+}
+
+/* Decode the line represented by S by calling decode_line_full. This is the
+ default function for the `decode_linespec' method of breakpoint_ops. */
+
+static void
+decode_linespec_default (struct breakpoint *b, char **s,
+ struct symtabs_and_lines *sals)
+{
+ struct linespec_result canonical;
+
+ init_linespec_result (&canonical);
+ decode_line_full (s, DECODE_LINE_FUNFIRSTLINE,
+ (struct symtab *) NULL, 0,
+ &canonical, multiple_symbols_all,
+ b->filter);
+
+ /* We should get 0 or 1 resulting SALs. */
+ gdb_assert (VEC_length (linespec_sals, canonical.sals) < 2);
+
+ if (VEC_length (linespec_sals, canonical.sals) > 0)
+ {
+ struct linespec_sals *lsal;
+
+ lsal = VEC_index (linespec_sals, canonical.sals, 0);
+ *sals = lsal->sals;
+ /* Arrange it so the destructor does not free the
+ contents. */
+ lsal->sals.sals = NULL;
+ }
+
+ destroy_linespec_result (&canonical);
+}
+
/* Prepare the global context for a re-set of breakpoint B. */
static struct cleanup *
input_radix = b->input_radix;
cleanups = save_current_space_and_thread ();
- switch_to_program_space_and_thread (b->pspace);
+ if (b->pspace != NULL)
+ switch_to_program_space_and_thread (b->pspace);
set_language (b->language);
return cleanups;
create_longjmp_master_breakpoint ();
create_std_terminate_master_breakpoint ();
create_exception_master_breakpoint ();
+
+ /* While we're at it, reset the skip list too. */
+ skip_re_set ();
}
\f
/* Reset the thread number of this breakpoint:
bpt->enable_state = bp_disabled;
+ /* Mark breakpoint locations modified. */
+ mark_breakpoint_modified (bpt);
+
if (target_supports_enable_disable_tracepoint ()
&& current_trace_status ()->running && is_tracepoint (bpt))
{
struct bp_location *loc = find_location_by_number (args);
if (loc)
{
- loc->enabled = 0;
+ if (loc->enabled)
+ {
+ loc->enabled = 0;
+ mark_breakpoint_location_modified (loc);
+ }
if (target_supports_enable_disable_tracepoint ()
&& current_trace_status ()->running && loc->owner
&& is_tracepoint (loc->owner))
}
static void
-enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition)
+enable_breakpoint_disp (struct breakpoint *bpt, enum bpdisp disposition,
+ int count)
{
int target_resources_ok;
{
/* Initialize it just to avoid a GCC false warning. */
enum enable_state orig_enable_state = 0;
- struct gdb_exception e;
+ volatile struct gdb_exception e;
TRY_CATCH (e, RETURN_MASK_ALL)
{
if (bpt->enable_state != bp_permanent)
bpt->enable_state = bp_enabled;
+ bpt->enable_state = bp_enabled;
+
+ /* Mark breakpoint locations modified. */
+ mark_breakpoint_modified (bpt);
+
if (target_supports_enable_disable_tracepoint ()
&& current_trace_status ()->running && is_tracepoint (bpt))
{
}
bpt->disposition = disposition;
+ bpt->enable_count = count;
update_global_location_list (1);
breakpoints_changed ();
void
enable_breakpoint (struct breakpoint *bpt)
{
- enable_breakpoint_disp (bpt, bpt->disposition);
+ enable_breakpoint_disp (bpt, bpt->disposition, 0);
}
static void
struct bp_location *loc = find_location_by_number (args);
if (loc)
{
- loc->enabled = 1;
+ if (!loc->enabled)
+ {
+ loc->enabled = 1;
+ mark_breakpoint_location_modified (loc);
+ }
if (target_supports_enable_disable_tracepoint ()
&& current_trace_status ()->running && loc->owner
&& is_tracepoint (loc->owner))
map_breakpoint_numbers (args, do_map_enable_breakpoint, NULL);
}
+/* This struct packages up disposition data for application to multiple
+ breakpoints. */
+
+struct disp_data
+{
+ enum bpdisp disp;
+ int count;
+};
+
static void
do_enable_breakpoint_disp (struct breakpoint *bpt, void *arg)
{
- enum bpdisp disp = *(enum bpdisp *) arg;
+ struct disp_data disp_data = *(struct disp_data *) arg;
- enable_breakpoint_disp (bpt, disp);
+ enable_breakpoint_disp (bpt, disp_data.disp, disp_data.count);
}
static void
do_map_enable_once_breakpoint (struct breakpoint *bpt, void *ignore)
{
- enum bpdisp disp = disp_disable;
+ struct disp_data disp = { disp_disable, 1 };
iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
}
map_breakpoint_numbers (args, do_map_enable_once_breakpoint, NULL);
}
+static void
+do_map_enable_count_breakpoint (struct breakpoint *bpt, void *countptr)
+{
+ struct disp_data disp = { disp_disable, *(int *) countptr };
+
+ iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
+}
+
+static void
+enable_count_command (char *args, int from_tty)
+{
+ int count = get_number (&args);
+
+ map_breakpoint_numbers (args, do_map_enable_count_breakpoint, &count);
+}
+
static void
do_map_enable_delete_breakpoint (struct breakpoint *bpt, void *ignore)
{
- enum bpdisp disp = disp_del;
+ struct disp_data disp = { disp_del, 1 };
iterate_over_related_breakpoints (bpt, do_enable_breakpoint_disp, &disp);
}
}
}
-/* Use default_breakpoint_'s, or nothing if they aren't valid. */
+/* Use the last displayed codepoint's values, or nothing
+ if they aren't valid. */
struct symtabs_and_lines
-decode_line_spec_1 (char *string, int funfirstline)
+decode_line_spec_1 (char *string, int flags)
{
struct symtabs_and_lines sals;
if (string == 0)
error (_("Empty line specification."));
- if (default_breakpoint_valid)
- sals = decode_line_1 (&string, funfirstline,
- default_breakpoint_symtab,
- default_breakpoint_line,
- NULL);
+ if (last_displayed_sal_is_valid ())
+ sals = decode_line_1 (&string, flags,
+ get_last_displayed_symtab (),
+ get_last_displayed_line ());
else
- sals = decode_line_1 (&string, funfirstline,
- (struct symtab *) NULL, 0, NULL);
+ sals = decode_line_1 (&string, flags, (struct symtab *) NULL, 0);
if (*string)
error (_("Junk at end of line specification: %s"), string);
return sals;
set_internalvar_integer (lookup_internalvar ("tpnum"), num);
}
-void
+static void
trace_command (char *arg, int from_tty)
{
if (create_breakpoint (get_current_arch (),
set_tracepoint_count (breakpoint_count);
}
-void
+static void
ftrace_command (char *arg, int from_tty)
{
if (create_breakpoint (get_current_arch (),
/* strace command implementation. Creates a static tracepoint. */
-void
+static void
strace_command (char *arg, int from_tty)
{
+ struct breakpoint_ops *ops;
+
+ /* Decide if we are dealing with a static tracepoint marker (`-m'),
+ or with a normal static tracepoint. */
+ if (arg && strncmp (arg, "-m", 2) == 0 && isspace (arg[2]))
+ ops = &strace_marker_breakpoint_ops;
+ else
+ ops = &tracepoint_breakpoint_ops;
+
if (create_breakpoint (get_current_arch (),
arg,
NULL, 0, 1 /* parse arg */,
bp_static_tracepoint /* type_wanted */,
0 /* Ignore count */,
pending_break_support,
- &tracepoint_breakpoint_ops,
+ ops,
from_tty,
1 /* enabled */,
0 /* internal */))
"have no source form, ignoring them"),
utp->number);
+ /* Copy any status information that might be available. */
+ tp->base.hit_count = utp->hit_count;
+ tp->traceframe_usage = utp->traceframe_usage;
+
return tp;
}
static void
tracepoints_info (char *args, int from_tty)
{
+ struct ui_out *uiout = current_uiout;
int num_printed;
num_printed = breakpoint_1 (args, 0, is_tracepoint);
fprintf_unfiltered (fp, " commands\n");
- ui_out_redirect (uiout, fp);
+ ui_out_redirect (current_uiout, fp);
TRY_CATCH (ex, RETURN_MASK_ALL)
{
- print_command_lines (uiout, tp->commands->commands, 2);
+ print_command_lines (current_uiout, tp->commands->commands, 2);
}
- ui_out_redirect (uiout, NULL);
+ ui_out_redirect (current_uiout, NULL);
if (ex.reason < 0)
throw_exception (ex);
return NULL;
}
+/* Zero if any of the breakpoint's locations could be a location where
+ functions have been inlined, nonzero otherwise. */
+
+static int
+is_non_inline_function (struct breakpoint *b)
+{
+ /* The shared library event breakpoint is set on the address of a
+ non-inline function. */
+ if (b->type == bp_shlib_event)
+ return 1;
+
+ return 0;
+}
+
+/* Nonzero if the specified PC cannot be a location where functions
+ have been inlined. */
+
+int
+pc_at_non_inline_function (struct address_space *aspace, CORE_ADDR pc,
+ const struct target_waitstatus *ws)
+{
+ struct breakpoint *b;
+ struct bp_location *bl;
+
+ ALL_BREAKPOINTS (b)
+ {
+ if (!is_non_inline_function (b))
+ continue;
+
+ for (bl = b->loc; bl != NULL; bl = bl->next)
+ {
+ if (!bl->shlib_disabled
+ && bpstat_check_location (bl, aspace, pc, ws))
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
void
initialize_breakpoint_ops (void)
{
ops->insert_location = bkpt_insert_location;
ops->remove_location = bkpt_remove_location;
ops->breakpoint_hit = bkpt_breakpoint_hit;
+ ops->create_sals_from_address = bkpt_create_sals_from_address;
+ ops->create_breakpoints_sal = bkpt_create_breakpoints_sal;
+ ops->decode_linespec = bkpt_decode_linespec;
/* The breakpoint_ops structure to be used in regular breakpoints. */
ops = &bkpt_breakpoint_ops;
ops->print_one_detail = tracepoint_print_one_detail;
ops->print_mention = tracepoint_print_mention;
ops->print_recreate = tracepoint_print_recreate;
+ ops->create_sals_from_address = tracepoint_create_sals_from_address;
+ ops->create_breakpoints_sal = tracepoint_create_breakpoints_sal;
+ ops->decode_linespec = tracepoint_decode_linespec;
+
+ /* Static tracepoints with marker (`-m'). */
+ ops = &strace_marker_breakpoint_ops;
+ *ops = tracepoint_breakpoint_ops;
+ ops->create_sals_from_address = strace_marker_create_sals_from_address;
+ ops->create_breakpoints_sal = strace_marker_create_breakpoints_sal;
+ ops->decode_linespec = strace_marker_decode_linespec;
/* Fork catchpoints. */
ops = &catch_fork_breakpoint_ops;
ops->print_one = print_one_catch_syscall;
ops->print_mention = print_mention_catch_syscall;
ops->print_recreate = print_recreate_catch_syscall;
+
+ /* Solib-related catchpoints. */
+ ops = &catch_solib_breakpoint_ops;
+ *ops = base_breakpoint_ops;
+ ops->dtor = dtor_catch_solib;
+ ops->insert_location = insert_catch_solib;
+ ops->remove_location = remove_catch_solib;
+ ops->breakpoint_hit = breakpoint_hit_catch_solib;
+ ops->check_status = check_status_catch_solib;
+ ops->print_it = print_it_catch_solib;
+ ops->print_one = print_one_catch_solib;
+ ops->print_mention = print_mention_catch_solib;
+ ops->print_recreate = print_recreate_catch_solib;
}
void
If a breakpoint is hit while enabled in this fashion, it is deleted."),
&enablebreaklist);
+ add_cmd ("count", no_class, enable_count_command, _("\
+Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
+If a breakpoint is hit while enabled in this fashion,\n\
+the count is decremented; when it reaches zero, the breakpoint is disabled."),
+ &enablebreaklist);
+
add_cmd ("delete", no_class, enable_delete_command, _("\
Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
If a breakpoint is hit while enabled in this fashion, it is deleted."),
If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
&enablelist);
+ add_cmd ("count", no_class, enable_count_command, _("\
+Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
+If a breakpoint is hit while enabled in this fashion,\n\
+the count is decremented; when it reaches zero, the breakpoint is disabled."),
+ &enablelist);
+
add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
Disable some breakpoints.\n\
Arguments are breakpoint numbers with spaces in between.\n\
/* Add catch and tcatch sub-commands. */
add_catch_command ("catch", _("\
-Catch an exception, when caught.\n\
-With an argument, catch only exceptions with the given name."),
+Catch an exception, when caught."),
catch_catch_command,
NULL,
CATCH_PERMANENT,
CATCH_TEMPORARY);
add_catch_command ("throw", _("\
-Catch an exception, when thrown.\n\
-With an argument, catch only exceptions with the given name."),
+Catch an exception, when thrown."),
catch_throw_command,
NULL,
CATCH_PERMANENT,
NULL,
CATCH_PERMANENT,
CATCH_TEMPORARY);
+ add_catch_command ("load", _("Catch loads of shared libraries.\n\
+Usage: catch load [REGEX]\n\
+If REGEX is given, only stop for libraries matching the regular expression."),
+ catch_load_command_1,
+ NULL,
+ CATCH_PERMANENT,
+ CATCH_TEMPORARY);
+ add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
+Usage: catch unload [REGEX]\n\
+If REGEX is given, only stop for libraries matching the regular expression."),
+ catch_unload_command_1,
+ NULL,
+ CATCH_PERMANENT,
+ CATCH_TEMPORARY);
add_catch_command ("syscall", _("\
Catch system calls by their names and/or numbers.\n\
Arguments say which system calls to catch. If no arguments\n\
&breakpoint_set_cmdlist,
&breakpoint_show_cmdlist);
+ add_setshow_enum_cmd ("condition-evaluation", class_breakpoint,
+ condition_evaluation_enums,
+ &condition_evaluation_mode_1, _("\
+Set mode of breakpoint condition evaluation."), _("\
+Show mode of breakpoint condition evaluation."), _("\
+When this is set to \"gdb\", breakpoint conditions will be\n\
+evaluated on the host's side by GDB. When it is set to \"target\",\n\
+breakpoint conditions will be downloaded to the target (if the target\n\
+supports such feature) and conditions will be evaluated on the target's side.\n\
+If this is set to \"auto\" (default), this will be automatically set to\n\
+\"target\" if it supports condition evaluation, otherwise it will\n\
+be set to \"gdb\""),
+ &set_condition_evaluation_mode,
+ &show_condition_evaluation_mode,
+ &breakpoint_set_cmdlist,
+ &breakpoint_show_cmdlist);
+
add_com ("break-range", class_breakpoint, break_range_command, _("\
Set a breakpoint for an address range.\n\
break-range START-LOCATION, END-LOCATION\n\
projects / deliverable / binutils-gdb.git / blobdiff