static int watchpoint_locations_match (struct bp_location *loc1,
struct bp_location *loc2);
+static int breakpoint_location_address_match (struct bp_location *bl,
+ struct address_space *aspace,
+ CORE_ADDR addr);
+
static void breakpoints_info (char *, int);
static void watchpoints_info (char *, int);
static int breakpoint_proceeded;
-static const char *
+const char *
bpdisp_text (enum bpdisp disp)
{
/* NOTE: the following values are a part of MI protocol and
}
}
breakpoints_changed ();
- observer_notify_breakpoint_modified (b->number);
+ observer_notify_breakpoint_modified (b);
}
/* condition N EXP -- set break condition of breakpoint N to EXP. */
decref_counted_command_line (&b->commands);
b->commands = alloc_counted_command_line (commands);
breakpoints_changed ();
- observer_notify_breakpoint_modified (b->number);
+ observer_notify_breakpoint_modified (b);
}
/* Set the internal `silent' flag on the breakpoint. Note that this
b->silent = silent;
if (old_silent != silent)
- observer_notify_breakpoint_modified (b->number);
+ observer_notify_breakpoint_modified (b);
}
/* Set the thread for this breakpoint. If THREAD is -1, make the
b->thread = thread;
if (old_thread != thread)
- observer_notify_breakpoint_modified (b->number);
+ observer_notify_breakpoint_modified (b);
}
/* Set the task for this breakpoint. If TASK is 0, make the
b->task = task;
if (old_task != task)
- observer_notify_breakpoint_modified (b->number);
+ observer_notify_breakpoint_modified (b);
}
void
decref_counted_command_line (&b->commands);
b->commands = info->cmd;
breakpoints_changed ();
- observer_notify_breakpoint_modified (b->number);
+ observer_notify_breakpoint_modified (b);
}
}
memset (&bl->target_info, 0, sizeof (bl->target_info));
bl->target_info.placed_address = bl->address;
bl->target_info.placed_address_space = bl->pspace->aspace;
+ bl->target_info.length = bl->length;
if (bl->loc_type == bp_loc_software_breakpoint
|| bl->loc_type == bp_loc_hardware_breakpoint)
/* See also: disable_breakpoints_in_shlibs. */
val = 0;
bl->shlib_disabled = 1;
+ observer_notify_breakpoint_modified (bl->owner);
if (!*disabled_breaks)
{
fprintf_unfiltered (tmp_error_stream,
&& bl->loc_type != bp_loc_hardware_breakpoint)
continue;
- /* ALL_BP_LOCATIONS bp_location has bl->OWNER always non-NULL. */
+ /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
if ((breakpoint_enabled (bl->owner)
|| bl->owner->enable_state == bp_permanent)
- && breakpoint_address_match (bl->pspace->aspace, bl->address,
- aspace, pc))
+ && breakpoint_location_address_match (bl, aspace, pc))
{
if (overlay_debugging
&& section_is_overlay (bl->section)
int ix;
for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
- if (breakpoint_address_match (loc->pspace->aspace, loc->address,
- aspace, pc))
+ if (breakpoint_location_address_match (loc, aspace, pc))
return 1;
return 0;
continue;
if (bl->inserted
- && breakpoint_address_match (bl->pspace->aspace, bl->address,
- aspace, pc))
+ && breakpoint_location_address_match (bl, aspace, pc))
{
if (overlay_debugging
&& section_is_overlay (bl->section)
&& bl->owner->enable_state != bp_permanent)
continue;
- if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
- aspace, pc))
+ if (!breakpoint_location_address_match (bl, aspace, pc))
continue;
if (bl->owner->thread != -1)
/* BL is from existing struct breakpoint. */
gdb_assert (b != NULL);
+ if (b->ops && b->ops->breakpoint_hit)
+ return b->ops->breakpoint_hit (bl, aspace, bp_addr);
+
/* By definition, the inferior does not report stops at
tracepoints. */
if (is_tracepoint (b))
if (is_hardware_watchpoint (b)
&& b->watchpoint_triggered == watch_triggered_no)
return 0;
-
+
if (b->type == bp_hardware_breakpoint)
{
if (bl->address != bp_addr)
return 0;
}
- if (b->type == bp_catchpoint)
- {
- gdb_assert (b->ops != NULL && b->ops->breakpoint_hit != NULL);
- if (!b->ops->breakpoint_hit (b))
- return 0;
- }
-
return 1;
}
bs->stop = 0;
/* Increase the hit count even though we don't stop. */
++(b->hit_count);
+ observer_notify_breakpoint_modified (b);
}
}
}
for (ix = 0; VEC_iterate (bp_location_p, moribund_locations, ix, loc); ++ix)
{
- if (breakpoint_address_match (loc->pspace->aspace, loc->address,
- aspace, bp_addr))
+ if (breakpoint_location_address_match (loc, aspace, bp_addr))
{
bs = bpstat_alloc (loc, &bs_link);
/* For hits of moribund locations, we should just proceed. */
if (bs->stop)
{
++(b->hit_count);
+ observer_notify_breakpoint_modified (b);
/* We will stop here. */
if (b->disposition == disp_disable)
{
struct command_line *l;
static char bpenables[] = "nynny";
- struct cleanup *bkpt_chain;
int header_of_multiple = 0;
int part_of_multiple = (loc != NULL);
loc = b->loc;
annotate_record ();
- bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
/* 1 */
annotate_field (0);
ui_out_field_int (uiout, "task", b->task);
}
}
-
+
ui_out_text (uiout, "\n");
-
+
+ if (!part_of_multiple && b->ops && b->ops->print_one_detail)
+ b->ops->print_one_detail (b, uiout);
+
if (!part_of_multiple && b->static_trace_marker_id)
{
gdb_assert (b->type == bp_static_tracepoint);
else if (b->exp_string)
ui_out_field_string (uiout, "original-location", b->exp_string);
}
-
- do_cleanups (bkpt_chain);
}
static void
struct bp_location **last_loc,
int allflag)
{
+ struct cleanup *bkpt_chain;
+
+ bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "bkpt");
+
print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
+ do_cleanups (bkpt_chain);
/* If this breakpoint has custom print function,
it's already printed. Otherwise, print individual
internally, that's not a property exposed to user. */
if (b->loc
&& !is_hardware_watchpoint (b)
- && (b->loc->next || !b->loc->enabled)
- && !ui_out_is_mi_like_p (uiout))
+ && (b->loc->next || !b->loc->enabled))
{
struct bp_location *loc;
int n = 1;
+
for (loc = b->loc; loc; loc = loc->next, ++n)
- print_one_breakpoint_location (b, loc, n, last_loc, allflag);
+ {
+ struct cleanup *inner2 =
+ make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
+ print_one_breakpoint_location (b, loc, n, last_loc, allflag);
+ do_cleanups (inner2);
+ }
}
}
}
return GDB_RC_OK;
}
-/* Return non-zero if B is user settable (breakpoints, watchpoints,
- catchpoints, et.al.). */
-
-static int
-user_settable_breakpoint (const struct breakpoint *b)
-{
- return (b->type == bp_breakpoint
- || b->type == bp_catchpoint
- || b->type == bp_hardware_breakpoint
- || is_tracepoint (b)
- || is_watchpoint (b)
- || b->type == bp_gnu_ifunc_resolver);
-}
-
/* Return true if this breakpoint was set by the user, false if it is
internal or momentary. */
int
user_breakpoint_p (struct breakpoint *b)
{
- return user_settable_breakpoint (b) && b->number > 0;
+ return b->number > 0;
}
/* Print information on user settable breakpoint (watchpoint, etc)
&& addr1 == addr2);
}
+/* Returns true if {ASPACE2,ADDR2} falls within the range determined by
+ {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
+ matches ASPACE2. On targets that have global breakpoints, the address
+ space doesn't really matter. */
+
+static int
+breakpoint_address_match_range (struct address_space *aspace1, CORE_ADDR addr1,
+ int len1, struct address_space *aspace2,
+ CORE_ADDR addr2)
+{
+ return ((gdbarch_has_global_breakpoints (target_gdbarch)
+ || aspace1 == aspace2)
+ && addr2 >= addr1 && addr2 < addr1 + len1);
+}
+
+/* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
+ a ranged breakpoint. In most targets, a match happens only if ASPACE
+ matches the breakpoint's address space. On targets that have global
+ breakpoints, the address space doesn't really matter. */
+
+static int
+breakpoint_location_address_match (struct bp_location *bl,
+ struct address_space *aspace,
+ CORE_ADDR addr)
+{
+ return (breakpoint_address_match (bl->pspace->aspace, bl->address,
+ aspace, addr)
+ || (bl->length
+ && breakpoint_address_match_range (bl->pspace->aspace,
+ bl->address, bl->length,
+ aspace, addr)));
+}
+
/* Assuming LOC1 and LOC2's types' have meaningful target addresses
(breakpoint_address_is_meaningful), returns true if LOC1 and LOC2
represent the same location. */
else if (hw_point1)
return watchpoint_locations_match (loc1, loc2);
else
- return breakpoint_address_match (loc1->pspace->aspace, loc1->address,
- loc2->pspace->aspace, loc2->address);
+ /* We compare bp_location.length in order to cover ranged breakpoints. */
+ return (breakpoint_address_match (loc1->pspace->aspace, loc1->address,
+ loc2->pspace->aspace, loc2->address)
+ && loc1->length == loc2->length);
}
static void
delete_breakpoint (b);
}
-struct captured_parse_breakpoint_args
- {
- char **arg_p;
- struct symtabs_and_lines *sals_p;
- struct linespec_result *canonical_p;
- int *not_found_ptr;
- };
-
struct lang_and_radix
{
enum language lang;
}
}
-/* Disable any breakpoints that are in in an unloaded shared library.
+/* Disable any breakpoints that are in an unloaded shared library.
Only apply to enabled breakpoints, disabled ones can just stay
disabled. */
succeeding so we must mark the breakpoint as not inserted
to prevent future errors occurring in remove_breakpoints. */
loc->inserted = 0;
+
+ /* This may cause duplicate notifications for the same breakpoint. */
+ observer_notify_breakpoint_modified (b);
+
if (!disabled_shlib_breaks)
{
target_terminal_ours_for_output ();
catchpoints. */
static int
-breakpoint_hit_catch_fork (struct breakpoint *b)
+breakpoint_hit_catch_fork (const struct bp_location *bl,
+ struct address_space *aspace, CORE_ADDR bp_addr)
{
- return inferior_has_forked (inferior_ptid, &b->forked_inferior_pid);
+ return inferior_has_forked (inferior_ptid, &bl->owner->forked_inferior_pid);
}
/* Implement the "print_it" breakpoint_ops method for fork
NULL, /* resources_needed */
print_it_catch_fork,
print_one_catch_fork,
+ NULL, /* print_one_detail */
print_mention_catch_fork,
print_recreate_catch_fork
};
catchpoints. */
static int
-breakpoint_hit_catch_vfork (struct breakpoint *b)
+breakpoint_hit_catch_vfork (const struct bp_location *bl,
+ struct address_space *aspace, CORE_ADDR bp_addr)
{
- return inferior_has_vforked (inferior_ptid, &b->forked_inferior_pid);
+ return inferior_has_vforked (inferior_ptid, &bl->owner->forked_inferior_pid);
}
/* Implement the "print_it" breakpoint_ops method for vfork
NULL, /* resources_needed */
print_it_catch_vfork,
print_one_catch_vfork,
+ NULL, /* print_one_detail */
print_mention_catch_vfork,
print_recreate_catch_vfork
};
catchpoints. */
static int
-breakpoint_hit_catch_syscall (struct breakpoint *b)
+breakpoint_hit_catch_syscall (const struct bp_location *bl,
+ struct address_space *aspace, CORE_ADDR bp_addr)
{
/* We must check if we are catching specific syscalls in this
breakpoint. If we are, then we must guarantee that the called
syscall is the same syscall we are catching. */
int syscall_number = 0;
+ const struct breakpoint *b = bl->owner;
if (!inferior_has_called_syscall (inferior_ptid, &syscall_number))
return 0;
static void
print_one_catch_syscall (struct breakpoint *b,
- struct bp_location **last_loc)
+ struct bp_location **last_loc)
{
struct value_print_options opts;
NULL, /* resources_needed */
print_it_catch_syscall,
print_one_catch_syscall,
+ NULL, /* print_one_detail */
print_mention_catch_syscall,
print_recreate_catch_syscall
};
create_catchpoint_without_mention (gdbarch, tempflag, cond_string, ops);
mention (b);
+ observer_notify_breakpoint_created (b);
update_global_location_list (1);
return b;
}
static int
-breakpoint_hit_catch_exec (struct breakpoint *b)
+breakpoint_hit_catch_exec (const struct bp_location *bl,
+ struct address_space *aspace, CORE_ADDR bp_addr)
{
- return inferior_has_execd (inferior_ptid, &b->exec_pathname);
+ return inferior_has_execd (inferior_ptid, &bl->owner->exec_pathname);
}
static enum print_stop_action
NULL, /* resources_needed */
print_it_catch_exec,
print_one_catch_exec,
+ NULL, /* print_one_detail */
print_mention_catch_exec,
print_recreate_catch_exec
};
/* Now, we have to mention the breakpoint and update the global
location list. */
mention (b);
+ observer_notify_breakpoint_created (b);
update_global_location_list (1);
}
static int
hw_breakpoint_used_count (void)
{
- struct breakpoint *b;
int i = 0;
+ struct breakpoint *b;
+ struct bp_location *bl;
ALL_BREAKPOINTS (b)
{
if (b->type == bp_hardware_breakpoint && breakpoint_enabled (b))
- i++;
+ for (bl = b->loc; bl; bl = bl->next)
+ {
+ /* Special types of hardware breakpoints may use more than
+ one register. */
+ if (b->ops && b->ops->resources_needed)
+ i += b->ops->resources_needed (bl);
+ else
+ i++;
+ }
}
return i;
get_user_print_options (&opts);
- /* FIXME: This is misplaced; mention() is called by things (like
- hitting a watchpoint) other than breakpoint creation. It should
- be possible to clean this up and at the same time replace the
- random calls to breakpoint_changed with this hook. */
- observer_notify_breakpoint_created (b->number);
-
if (b->ops != NULL && b->ops->print_mention != NULL)
b->ops->print_mention (b);
else
= xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
b->ops = ops;
- if (internal)
- /* Do not mention breakpoints with a negative number, but do
- notify observers. */
- observer_notify_breakpoint_created (b->number);
- else
+ /* Do not mention breakpoints with a negative number, but do
+ notify observers. */
+ if (!internal)
mention (b);
+ observer_notify_breakpoint_created (b);
}
/* Remove element at INDEX_TO_REMOVE from SAL, shifting other
static void
parse_breakpoint_sals (char **address,
struct symtabs_and_lines *sals,
- struct linespec_result *canonical,
- int *not_found_ptr)
+ struct linespec_result *canonical)
{
char *addr_start = *address;
|| ((strchr ("+-", (*address)[0]) != NULL)
&& ((*address)[1] != '['))))
*sals = decode_line_1 (address, 1, default_breakpoint_symtab,
- default_breakpoint_line, canonical,
- not_found_ptr);
+ default_breakpoint_line, canonical);
else
*sals = decode_line_1 (address, 1, (struct symtab *) NULL, 0,
- canonical, not_found_ptr);
+ 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 **));
+ canonical->canonical = xcalloc (sals->nelts, sizeof (char *));
if (addr_start != (*address))
{
int i;
}
}
-static void
-do_captured_parse_breakpoint (struct ui_out *ui, void *data)
-{
- struct captured_parse_breakpoint_args *args = data;
-
- parse_breakpoint_sals (args->arg_p, args->sals_p, args->canonical_p,
- args->not_found_ptr);
-}
-
/* Given TOK, a string specification of condition and thread, as
accepted by the 'break' command, extract the condition
string and thread number and set *COND_STRING and *THREAD.
struct breakpoint_ops *ops,
int from_tty, int enabled, int internal)
{
- struct gdb_exception e;
+ volatile struct gdb_exception e;
struct symtabs_and_lines sals;
struct symtab_and_line pending_sal;
char *copy_arg;
struct linespec_result canonical;
struct cleanup *old_chain;
struct cleanup *bkpt_chain = NULL;
- struct captured_parse_breakpoint_args parse_args;
int i;
int pending = 0;
- int not_found = 0;
int task = 0;
int prev_bkpt_count = breakpoint_count;
sals.nelts = 0;
init_linespec_result (&canonical);
- parse_args.arg_p = &arg;
- parse_args.sals_p = &sals;
- parse_args.canonical_p = &canonical;
- parse_args.not_found_ptr = ¬_found;
-
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 **));
+ canonical.canonical = xcalloc (sals.nelts, sizeof (char *));
for (i = 0; i < sals.nelts; i++)
canonical.canonical[i] = xstrdup (copy_arg);
goto done;
}
- e = catch_exception (uiout, do_captured_parse_breakpoint,
- &parse_args, RETURN_MASK_ALL);
+ TRY_CATCH (e, RETURN_MASK_ALL)
+ {
+ parse_breakpoint_sals (&arg, &sals, &canonical);
+ }
/* If caller is interested in rc value from parse, set value. */
switch (e.reason)
|| b->type == bp_hardware_breakpoint))
b->enable_state = bp_startup_disabled;
- if (internal)
+ if (!internal)
/* Do not mention breakpoints with a negative number,
but do notify observers. */
- observer_notify_breakpoint_created (b->number);
- else
- mention (b);
+ mention (b);
+ observer_notify_breakpoint_created (b);
}
if (sals.nelts > 1)
break_command_1 (arg, 0, from_tty);
}
+/* Implement the "breakpoint_hit" breakpoint_ops method for
+ ranged breakpoints. */
+
+static int
+breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
+ struct address_space *aspace,
+ CORE_ADDR bp_addr)
+{
+ return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
+ bl->length, aspace, bp_addr);
+}
+
+/* Implement the "resources_needed" breakpoint_ops method for
+ ranged breakpoints. */
+
+static int
+resources_needed_ranged_breakpoint (const struct bp_location *bl)
+{
+ return target_ranged_break_num_registers ();
+}
+
+/* Implement the "print_it" breakpoint_ops method for
+ ranged breakpoints. */
+
+static enum print_stop_action
+print_it_ranged_breakpoint (struct breakpoint *b)
+{
+ struct bp_location *bl = b->loc;
+
+ gdb_assert (b->type == bp_hardware_breakpoint);
+
+ /* Ranged breakpoints have only one location. */
+ gdb_assert (bl && bl->next == NULL);
+
+ annotate_breakpoint (b->number);
+ if (b->disposition == disp_del)
+ ui_out_text (uiout, "\nTemporary ranged breakpoint ");
+ else
+ ui_out_text (uiout, "\nRanged breakpoint ");
+ if (ui_out_is_mi_like_p (uiout))
+ {
+ ui_out_field_string (uiout, "reason",
+ async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
+ ui_out_field_string (uiout, "disp", bpdisp_text (b->disposition));
+ }
+ ui_out_field_int (uiout, "bkptno", b->number);
+ ui_out_text (uiout, ", ");
+
+ return PRINT_SRC_AND_LOC;
+}
+
+/* Implement the "print_one" breakpoint_ops method for
+ ranged breakpoints. */
+
+static void
+print_one_ranged_breakpoint (struct breakpoint *b,
+ struct bp_location **last_loc)
+{
+ struct bp_location *bl = b->loc;
+ struct value_print_options opts;
+
+ /* Ranged breakpoints have only one location. */
+ gdb_assert (bl && bl->next == NULL);
+
+ get_user_print_options (&opts);
+
+ if (opts.addressprint)
+ /* We don't print the address range here, it will be printed later
+ by print_one_detail_ranged_breakpoint. */
+ ui_out_field_skip (uiout, "addr");
+ annotate_field (5);
+ print_breakpoint_location (b, bl);
+ *last_loc = bl;
+}
+
+/* Implement the "print_one_detail" breakpoint_ops method for
+ ranged breakpoints. */
+
+static void
+print_one_detail_ranged_breakpoint (const struct breakpoint *b,
+ struct ui_out *uiout)
+{
+ CORE_ADDR address_start, address_end;
+ struct bp_location *bl = b->loc;
+ struct ui_stream *stb = ui_out_stream_new (uiout);
+ struct cleanup *cleanup = make_cleanup_ui_out_stream_delete (stb);
+
+ gdb_assert (bl);
+
+ address_start = bl->address;
+ address_end = address_start + bl->length - 1;
+
+ ui_out_text (uiout, "\taddress range: ");
+ fprintf_unfiltered (stb->stream, "[%s, %s]",
+ print_core_address (bl->gdbarch, address_start),
+ print_core_address (bl->gdbarch, address_end));
+ ui_out_field_stream (uiout, "addr", stb);
+ ui_out_text (uiout, "\n");
+
+ do_cleanups (cleanup);
+}
+
+/* Implement the "print_mention" breakpoint_ops method for
+ ranged breakpoints. */
+
+static void
+print_mention_ranged_breakpoint (struct breakpoint *b)
+{
+ struct bp_location *bl = b->loc;
+
+ gdb_assert (bl);
+ gdb_assert (b->type == bp_hardware_breakpoint);
+
+ if (ui_out_is_mi_like_p (uiout))
+ return;
+
+ printf_filtered (_("Hardware assisted ranged breakpoint %d from %s to %s."),
+ b->number, paddress (bl->gdbarch, bl->address),
+ paddress (bl->gdbarch, bl->address + bl->length - 1));
+}
+
+/* Implement the "print_recreate" breakpoint_ops method for
+ ranged breakpoints. */
+
+static void
+print_recreate_ranged_breakpoint (struct breakpoint *b, struct ui_file *fp)
+{
+ fprintf_unfiltered (fp, "break-range %s, %s", b->addr_string,
+ b->addr_string_range_end);
+}
+
+/* The breakpoint_ops structure to be used in ranged breakpoints. */
+
+static struct breakpoint_ops ranged_breakpoint_ops =
+{
+ NULL, /* insert */
+ NULL, /* remove */
+ breakpoint_hit_ranged_breakpoint,
+ resources_needed_ranged_breakpoint,
+ print_it_ranged_breakpoint,
+ print_one_ranged_breakpoint,
+ print_one_detail_ranged_breakpoint,
+ print_mention_ranged_breakpoint,
+ print_recreate_ranged_breakpoint
+};
+
+/* Find the address where the end of the breakpoint range should be
+ placed, given the SAL of the end of the range. This is so that if
+ the user provides a line number, the end of the range is set to the
+ last instruction of the given line. */
+
+static CORE_ADDR
+find_breakpoint_range_end (struct symtab_and_line sal)
+{
+ CORE_ADDR end;
+
+ /* If the user provided a PC value, use it. Otherwise,
+ find the address of the end of the given location. */
+ if (sal.explicit_pc)
+ end = sal.pc;
+ else
+ {
+ int ret;
+ CORE_ADDR start;
+
+ ret = find_line_pc_range (sal, &start, &end);
+ if (!ret)
+ error (_("Could not find location of the end of the range."));
+
+ /* find_line_pc_range returns the start of the next line. */
+ end--;
+ }
+
+ return end;
+}
+
+/* Implement the "break-range" CLI command. */
+
+static void
+break_range_command (char *arg, int from_tty)
+{
+ char *arg_start, *addr_string_start, *addr_string_end;
+ struct linespec_result canonical_start, canonical_end;
+ int bp_count, can_use_bp, length;
+ 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;
+
+ /* We don't support software ranged breakpoints. */
+ if (target_ranged_break_num_registers () < 0)
+ error (_("This target does not support hardware ranged breakpoints."));
+
+ bp_count = hw_breakpoint_used_count ();
+ bp_count += target_ranged_break_num_registers ();
+ can_use_bp = target_can_use_hardware_watchpoint (bp_hardware_breakpoint,
+ bp_count, 0);
+ if (can_use_bp < 0)
+ error (_("Hardware breakpoints used exceeds limit."));
+
+ 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);
+
+ 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);
+
+ if (arg[0] != ',')
+ error (_("Too few arguments."));
+ else if (sals_start.nelts == 0)
+ error (_("Could not find location of the beginning of the range."));
+ else if (sals_start.nelts != 1)
+ error (_("Cannot create a ranged breakpoint with multiple locations."));
+
+ resolve_sal_pc (&sal_start);
+
+ arg++; /* Skip the comma. */
+ while (*arg == ' ' || *arg == '\t')
+ 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
+ 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);
+
+ if (sals_end.nelts == 0)
+ error (_("Could not find location of the end of the range."));
+ else if (sals_end.nelts != 1)
+ error (_("Cannot create a ranged breakpoint with multiple locations."));
+
+ resolve_sal_pc (&sal_end);
+
+ end = find_breakpoint_range_end (sal_end);
+ if (sal_start.pc > end)
+ error (_("Invalid address range, end preceeds start."));
+
+ length = end - sal_start.pc + 1;
+ if (length < 0)
+ /* Length overflowed. */
+ error (_("Address range too large."));
+ else if (length == 1)
+ {
+ /* This range is simple enough to be handled by
+ the `hbreak' command. */
+ hbreak_command (addr_string_start, 1);
+
+ do_cleanups (cleanup_bkpt);
+
+ return;
+ }
+
+ /* Now set up the breakpoint. */
+ b = set_raw_breakpoint (get_current_arch (), sal_start,
+ bp_hardware_breakpoint);
+ 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->ops = &ranged_breakpoint_ops;
+ b->loc->length = length;
+
+ discard_cleanups (cleanup_bkpt);
+
+ mention (b);
+ observer_notify_breakpoint_created (b);
+ update_global_location_list (1);
+}
+
/* Return non-zero if EXP is verified as constant. Returned zero
means EXP is variable. Also the constant detection may fail for
some constant expressions and in such case still falsely return
resources_needed_watchpoint,
NULL, /* print_it */
NULL, /* print_one */
+ NULL, /* print_one_detail */
NULL, /* print_mention */
NULL /* print_recreate */
};
core_addr_to_string (addr));
xfree (name);
- b->exp_string = xstrprintf ("-location: %.*s",
+ b->exp_string = xstrprintf ("-location %.*s",
(int) (exp_end - exp_start), exp_start);
/* The above expression is in C. */
/* Finally update the new watchpoint. This creates the locations
that should be inserted. */
update_watchpoint (b, 1);
- if (internal)
- /* Do not mention breakpoints with a negative number, but do
+
+ /* Do not mention breakpoints with a negative number, but do
notify observers. */
- observer_notify_breakpoint_created (b->number);
- else
+ if (!internal)
mention (b);
+ observer_notify_breakpoint_created (b);
+
update_global_location_list (1);
}
if (default_breakpoint_valid)
sals = decode_line_1 (&arg, 1, default_breakpoint_symtab,
- default_breakpoint_line, NULL, NULL);
+ default_breakpoint_line, NULL);
else
- sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, NULL, NULL);
+ sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, NULL);
if (sals.nelts != 1)
error (_("Couldn't get information on specified line."));
}
static enum print_stop_action
-print_exception_catchpoint (struct breakpoint *b)
+print_it_exception_catchpoint (struct breakpoint *b)
{
int bp_temp, bp_throw;
NULL, /* remove */
NULL, /* breakpoint_hit */
NULL, /* resources_needed */
- print_exception_catchpoint,
+ print_it_exception_catchpoint,
print_one_exception_catchpoint,
+ NULL, /* print_one_detail */
print_mention_exception_catchpoint,
print_recreate_exception_catchpoint
};
b->ops = ops;
mention (b);
+ observer_notify_breakpoint_created (b);
update_global_location_list (1);
}
bpt->related_breakpoint = bpt;
}
- observer_notify_breakpoint_deleted (bpt->number);
+ observer_notify_breakpoint_deleted (bpt);
if (breakpoint_chain == bpt)
breakpoint_chain = bpt->next;
xfree (bpt->cond_string);
xfree (bpt->cond_exp);
xfree (bpt->addr_string);
+ xfree (bpt->addr_string_range_end);
xfree (bpt->exp);
xfree (bpt->exp_string);
xfree (bpt->exp_string_reparse);
{
int breaks_to_delete = 0;
- /* Delete all breakpoints if no argument.
- Do not delete internal or call-dummy breakpoints, these have
- to be deleted with an explicit breakpoint number argument. */
+ /* Delete all breakpoints if no argument. Do not delete
+ internal breakpoints, these have to be deleted with an
+ explicit breakpoint number argument. */
ALL_BREAKPOINTS (b)
- {
- if (b->type != bp_call_dummy
- && b->type != bp_std_terminate
- && b->type != bp_shlib_event
- && b->type != bp_jit_event
- && b->type != bp_thread_event
- && b->type != bp_overlay_event
- && b->type != bp_longjmp_master
- && b->type != bp_std_terminate_master
- && b->type != bp_exception_master
- && b->number >= 0)
+ if (user_breakpoint_p (b))
{
breaks_to_delete = 1;
break;
}
- }
/* Ask user only if there are some breakpoints to delete. */
if (!from_tty
|| (breaks_to_delete && query (_("Delete all breakpoints? "))))
{
ALL_BREAKPOINTS_SAFE (b, b_tmp)
- {
- if (b->type != bp_call_dummy
- && b->type != bp_std_terminate
- && b->type != bp_shlib_event
- && b->type != bp_thread_event
- && b->type != bp_jit_event
- && b->type != bp_overlay_event
- && b->type != bp_longjmp_master
- && b->type != bp_std_terminate_master
- && b->type != bp_exception_master
- && b->number >= 0)
+ if (user_breakpoint_p (b))
delete_breakpoint (b);
- }
}
}
else
return sal;
}
+/* Returns 1 iff locations A and B are sufficiently same that
+ we don't need to report breakpoint as changed. */
+
+static int
+locations_are_equal (struct bp_location *a, struct bp_location *b)
+{
+ while (a && b)
+ {
+ if (a->address != b->address)
+ return 0;
+
+ if (a->shlib_disabled != b->shlib_disabled)
+ return 0;
+
+ if (a->enabled != b->enabled)
+ return 0;
+
+ a = a->next;
+ b = b->next;
+ }
+
+ if ((a == NULL) != (b == NULL))
+ return 0;
+
+ return 1;
+}
+
+/* Create new breakpoint locations for B (a hardware or software breakpoint)
+ based on SALS and SALS_END. If SALS_END.NELTS is not zero, then B is
+ a ranged breakpoint. */
+
void
update_breakpoint_locations (struct breakpoint *b,
- struct symtabs_and_lines sals)
+ struct symtabs_and_lines sals,
+ struct symtabs_and_lines sals_end)
{
int i;
- char *s;
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 there's no new locations, and all existing locations are
pending, don't do anything. This optimizes the common case where
all locations are in the same shared library, that was unloaded.
old symtab. */
if (b->cond_string != NULL)
{
+ char *s;
struct gdb_exception e;
s = b->cond_string;
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]);
+
+ new_loc->length = end - sals.sals[0].pc + 1;
+ }
}
/* Update locations of permanent breakpoints. */
if (have_ambiguous_names)
{
for (; l; l = l->next)
- if (breakpoint_address_match (e->pspace->aspace, e->address,
- l->pspace->aspace, l->address))
+ if (breakpoint_locations_match (e, l))
{
l->enabled = 0;
break;
}
}
+ if (!locations_are_equal (existing_locations, b->loc))
+ observer_notify_breakpoint_modified (b);
+
update_global_location_list (1);
}
+/* Find the SaL locations corresponding to the given ADDR_STRING.
+ On return, FOUND will be 1 if any SaL was found, zero otherwise. */
+
+static struct symtabs_and_lines
+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;
+
+ s = addr_string;
+ marker_spec = b->type == bp_static_tracepoint && is_marker_spec (s);
+
+ TRY_CATCH (e, RETURN_MASK_ERROR)
+ {
+ if (marker_spec)
+ {
+ sals = decode_static_tracepoint_spec (&s);
+ if (sals.nelts > b->static_trace_marker_id_idx)
+ {
+ sals.sals[0] = sals.sals[b->static_trace_marker_id_idx];
+ sals.nelts = 1;
+ }
+ else
+ error (_("marker %s not found"), b->static_trace_marker_id);
+ }
+ else
+ sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, NULL);
+ }
+ if (e.reason < 0)
+ {
+ int not_found_and_ok = 0;
+ /* For pending breakpoints, it's expected that parsing will
+ fail until the right shared library is loaded. User has
+ already told to create pending breakpoints and don't need
+ extra messages. If breakpoint is in bp_shlib_disabled
+ state, then user already saw the message about that
+ breakpoint being disabled, and don't want to see more
+ errors. */
+ if (e.error == NOT_FOUND_ERROR
+ && (b->condition_not_parsed
+ || (b->loc && b->loc->shlib_disabled)
+ || b->enable_state == bp_disabled))
+ not_found_and_ok = 1;
+
+ if (!not_found_and_ok)
+ {
+ /* We surely don't want to warn about the same breakpoint
+ 10 times. One solution, implemented here, is disable
+ the breakpoint on error. Another solution would be to
+ have separate 'warning emitted' flag. Since this
+ happens only when a binary has changed, I don't know
+ which approach is better. */
+ b->enable_state = bp_disabled;
+ throw_exception (e);
+ }
+ }
+
+ if (e.reason == 0 || e.error != NOT_FOUND_ERROR)
+ {
+ gdb_assert (sals.nelts == 1);
+
+ resolve_sal_pc (&sals.sals[0]);
+ if (b->condition_not_parsed && s && s[0])
+ {
+ char *cond_string = 0;
+ int thread = -1;
+ int task = 0;
+
+ find_condition_and_thread (s, sals.sals[0].pc,
+ &cond_string, &thread, &task);
+ if (cond_string)
+ b->cond_string = cond_string;
+ b->thread = thread;
+ b->task = task;
+ b->condition_not_parsed = 0;
+ }
+
+ if (b->type == bp_static_tracepoint && !marker_spec)
+ sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
+
+ *found = 1;
+ }
+ else
+ *found = 0;
+
+ return sals;
+}
+
+/* Reevaluate a hardware or software breakpoint and recreate its locations.
+ This is necessary after symbols are read (e.g., an executable or DSO
+ was loaded, or the inferior just started). */
+
+static void
+re_set_breakpoint (struct breakpoint *b)
+{
+ int found;
+ struct symtabs_and_lines sals, sals_end;
+ struct symtabs_and_lines expanded = {0};
+ struct symtabs_and_lines expanded_end = {0};
+ struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
+
+ input_radix = b->input_radix;
+ save_current_space_and_thread ();
+ switch_to_program_space_and_thread (b->pspace);
+ set_language (b->language);
+
+ sals = addr_string_to_sals (b, b->addr_string, &found);
+ if (found)
+ {
+ make_cleanup (xfree, sals.sals);
+ expanded = expand_line_sal_maybe (sals.sals[0]);
+ }
+
+ if (b->addr_string_range_end)
+ {
+ sals_end = addr_string_to_sals (b, b->addr_string_range_end, &found);
+ if (found)
+ {
+ make_cleanup (xfree, sals_end.sals);
+ expanded_end = expand_line_sal_maybe (sals_end.sals[0]);
+ }
+ }
+
+ update_breakpoint_locations (b, expanded, expanded_end);
+ do_cleanups (cleanups);
+}
+
/* Reset a breakpoint given it's struct breakpoint * BINT.
The value we return ends up being the return value from catch_errors.
Unused in this case. */
{
/* Get past catch_errs. */
struct breakpoint *b = (struct breakpoint *) bint;
- int not_found = 0;
- int *not_found_ptr = ¬_found;
- struct symtabs_and_lines sals = {0};
- struct symtabs_and_lines expanded = {0};
- char *s;
- struct gdb_exception e;
- struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
- int marker_spec = 0;
switch (b->type)
{
return 0;
}
- input_radix = b->input_radix;
- s = b->addr_string;
-
- save_current_space_and_thread ();
- switch_to_program_space_and_thread (b->pspace);
-
- marker_spec = b->type == bp_static_tracepoint && is_marker_spec (s);
-
- set_language (b->language);
- TRY_CATCH (e, RETURN_MASK_ERROR)
- {
- if (marker_spec)
- {
- sals = decode_static_tracepoint_spec (&s);
- if (sals.nelts > b->static_trace_marker_id_idx)
- {
- sals.sals[0] = sals.sals[b->static_trace_marker_id_idx];
- sals.nelts = 1;
- }
- else
- error (_("marker %s not found"), b->static_trace_marker_id);
- }
- else
- sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0,
- NULL, not_found_ptr);
- }
- if (e.reason < 0)
- {
- int not_found_and_ok = 0;
- /* For pending breakpoints, it's expected that parsing will
- fail until the right shared library is loaded. User has
- already told to create pending breakpoints and don't need
- extra messages. If breakpoint is in bp_shlib_disabled
- state, then user already saw the message about that
- breakpoint being disabled, and don't want to see more
- errors. */
- if (not_found
- && (b->condition_not_parsed
- || (b->loc && b->loc->shlib_disabled)
- || b->enable_state == bp_disabled))
- not_found_and_ok = 1;
-
- if (!not_found_and_ok)
- {
- /* We surely don't want to warn about the same breakpoint
- 10 times. One solution, implemented here, is disable
- the breakpoint on error. Another solution would be to
- have separate 'warning emitted' flag. Since this
- happens only when a binary has changed, I don't know
- which approach is better. */
- b->enable_state = bp_disabled;
- throw_exception (e);
- }
- }
-
- if (!not_found)
- {
- gdb_assert (sals.nelts == 1);
-
- resolve_sal_pc (&sals.sals[0]);
- if (b->condition_not_parsed && s && s[0])
- {
- char *cond_string = 0;
- int thread = -1;
- int task = 0;
-
- find_condition_and_thread (s, sals.sals[0].pc,
- &cond_string, &thread, &task);
- if (cond_string)
- b->cond_string = cond_string;
- b->thread = thread;
- b->task = task;
- b->condition_not_parsed = 0;
- }
-
- if (b->type == bp_static_tracepoint && !marker_spec)
- sals.sals[0] = update_static_tracepoint (b, sals.sals[0]);
-
- expanded = expand_line_sal_maybe (sals.sals[0]);
- }
-
- make_cleanup (xfree, sals.sals);
- update_breakpoint_locations (b, expanded);
+ re_set_breakpoint (b);
break;
case bp_watchpoint:
break;
}
- do_cleanups (cleanups);
return 0;
}
count, bptnum);
}
breakpoints_changed ();
- observer_notify_breakpoint_modified (b->number);
+ observer_notify_breakpoint_modified (b);
return;
}
update_global_location_list (0);
- observer_notify_breakpoint_modified (bpt->number);
+ observer_notify_breakpoint_modified (bpt);
}
/* A callback for map_breakpoint_numbers that calls
static void
disable_command (char *args, int from_tty)
{
- struct breakpoint *bpt;
-
if (args == 0)
- ALL_BREAKPOINTS (bpt)
- switch (bpt->type)
- {
- case bp_none:
- warning (_("attempted to disable apparently deleted breakpoint #%d?"),
- bpt->number);
- break;
- case bp_breakpoint:
- case bp_tracepoint:
- case bp_fast_tracepoint:
- case bp_static_tracepoint:
- case bp_catchpoint:
- case bp_hardware_breakpoint:
- case bp_watchpoint:
- case bp_hardware_watchpoint:
- case bp_read_watchpoint:
- case bp_access_watchpoint:
- disable_breakpoint (bpt);
- break;
- default:
- break;
- }
+ {
+ struct breakpoint *bpt;
+
+ ALL_BREAKPOINTS (bpt)
+ if (user_breakpoint_p (bpt))
+ disable_breakpoint (bpt);
+ }
else if (strchr (args, '.'))
{
struct bp_location *loc = find_location_by_number (args);
update_global_location_list (1);
breakpoints_changed ();
- observer_notify_breakpoint_modified (bpt->number);
+ observer_notify_breakpoint_modified (bpt);
}
static void
enable_command (char *args, int from_tty)
{
- struct breakpoint *bpt;
-
if (args == 0)
- ALL_BREAKPOINTS (bpt)
- switch (bpt->type)
- {
- case bp_none:
- warning (_("attempted to enable apparently deleted breakpoint #%d?"),
- bpt->number);
- break;
- case bp_breakpoint:
- case bp_tracepoint:
- case bp_fast_tracepoint:
- case bp_static_tracepoint:
- case bp_catchpoint:
- case bp_hardware_breakpoint:
- case bp_watchpoint:
- case bp_hardware_watchpoint:
- case bp_read_watchpoint:
- case bp_access_watchpoint:
- enable_breakpoint (bpt);
- break;
- default:
- break;
- }
+ {
+ struct breakpoint *bpt;
+
+ ALL_BREAKPOINTS (bpt)
+ if (user_breakpoint_p (bpt))
+ enable_breakpoint (bpt);
+ }
else if (strchr (args, '.'))
{
struct bp_location *loc = find_location_by_number (args);
sals = decode_line_1 (&string, funfirstline,
default_breakpoint_symtab,
default_breakpoint_line,
- NULL, NULL);
+ NULL);
else
sals = decode_line_1 (&string, funfirstline,
- (struct symtab *) NULL, 0, NULL, NULL);
+ (struct symtab *) NULL, 0, NULL);
if (*string)
error (_("Junk at end of line specification: %s"), string);
return sals;
have to be deleted with an explicit breakpoint number
argument. */
ALL_TRACEPOINTS (b)
- {
- if (b->number >= 0)
+ if (is_tracepoint (b) && user_breakpoint_p (b))
{
breaks_to_delete = 1;
break;
}
- }
/* Ask user only if there are some breakpoints to delete. */
if (!from_tty
|| (breaks_to_delete && query (_("Delete all tracepoints? "))))
{
ALL_BREAKPOINTS_SAFE (b, b_tmp)
- {
- if (is_tracepoint (b)
- && b->number >= 0)
+ if (is_tracepoint (b) && user_breakpoint_p (b))
delete_breakpoint (b);
- }
}
}
else
if (filter && !filter (tp))
continue;
- if (tp->ops != NULL)
+ if (tp->ops != NULL && tp->ops->print_recreate != NULL)
(tp->ops->print_recreate) (tp, fp);
else
{
&show_always_inserted_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\
+where START-LOCATION and END-LOCATION can be one of the following:\n\
+ LINENUM, for that line in the current file,\n\
+ FILE:LINENUM, for that line in that file,\n\
+ +OFFSET, for that number of lines after the current line\n\
+ or the start of the range\n\
+ FUNCTION, for the first line in that function,\n\
+ FILE:FUNCTION, to distinguish among like-named static functions.\n\
+ *ADDRESS, for the instruction at that address.\n\
+\n\
+The breakpoint will stop execution of the inferior whenever it executes\n\
+an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
+range (including START-LOCATION and END-LOCATION)."));
+
automatic_hardware_breakpoints = 1;
observer_attach_about_to_proceed (breakpoint_about_to_proceed);
projects / deliverable / binutils-gdb.git / blobdiff