/* Everything about breakpoints, for GDB.
- Copyright 1986, 87, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 1999, 2000
- Free Software Foundation, Inc.
+ Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+ 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
This file is part of GDB.
#include "annotate.h"
#include "symfile.h"
#include "objfiles.h"
+#include "linespec.h"
+#include "completer.h"
#ifdef UI_OUT
#include "ui-out.h"
#endif
static void break_at_finish_command (char *, int);
static void break_at_finish_at_depth_command (char *, int);
-void tbreak_command (char *, int);
-
static void tbreak_at_finish_command (char *, int);
static void break_command_1 (char *, int, int);
static void mention (struct breakpoint *);
-struct breakpoint *set_raw_breakpoint (struct symtab_and_line);
+struct breakpoint *set_raw_breakpoint (struct symtab_and_line, enum bptype);
-static void check_duplicates (CORE_ADDR, asection *);
+static void check_duplicates (struct breakpoint *);
static void describe_other_breakpoints (CORE_ADDR, asection *);
static void catch_exec_command_1 (char *arg, int tempflag, int from_tty);
#endif
-static void create_exception_catchpoint
- (int tempflag, char *cond_string,
- enum exception_event_kind ex_event, struct symtab_and_line *sal);
+static void create_exception_catchpoint (int tempflag, char *cond_string,
+ enum exception_event_kind ex_event,
+ struct symtab_and_line *sal);
-static void catch_exception_command_1
- (enum exception_event_kind ex_event, char *arg, int tempflag, int from_tty);
+static void catch_exception_command_1 (enum exception_event_kind ex_event,
+ char *arg, int tempflag, int from_tty);
static void tcatch_command (char *arg, int from_tty);
/* Prototypes for exported functions. */
-static void awatch_command (char *, int);
-
-static void do_enable_breakpoint (struct breakpoint *, enum bpdisp);
-
/* If FALSE, gdb will not use hardware support for watchpoints, even
if such is available. */
static int can_use_hw_watchpoints;
void _initialize_breakpoint (void);
-void set_breakpoint_count (int);
-
extern int addressprint; /* Print machine addresses? */
static int internal_breakpoint_number = -1;
{
if (b->cond)
{
- free ((PTR) b->cond);
+ xfree (b->cond);
b->cond = 0;
}
if (b->cond_string != NULL)
- free ((PTR) b->cond_string);
+ xfree (b->cond_string);
if (*p == 0)
{
if (bp_addr + bp_size < memaddr + len)
{
/* Copy the section of memory after the breakpoint. */
- status = read_memory_nobpt
- (bp_addr + bp_size,
- myaddr + bp_addr + bp_size - memaddr,
- memaddr + len - (bp_addr + bp_size));
+ status = read_memory_nobpt (bp_addr + bp_size,
+ myaddr + bp_addr + bp_size - memaddr,
+ memaddr + len - (bp_addr + bp_size));
if (status != 0)
return status;
}
switch (b->type)
{
case bp_catch_fork:
- val = target_insert_fork_catchpoint (inferior_pid);
+ val = target_insert_fork_catchpoint (PIDGET (inferior_ptid));
break;
case bp_catch_vfork:
- val = target_insert_vfork_catchpoint (inferior_pid);
+ val = target_insert_vfork_catchpoint (PIDGET (inferior_ptid));
break;
case bp_catch_exec:
- val = target_insert_exec_catchpoint (inferior_pid);
+ val = target_insert_exec_catchpoint (PIDGET (inferior_ptid));
break;
default:
warning ("Internal error, %s line %d.", __FILE__, __LINE__);
{
register struct breakpoint *b;
int val;
- int saved_inferior_pid = inferior_pid;
+ struct cleanup *old_chain = save_inferior_ptid ();
- /* FIXME: use a cleanup, to insure that inferior_pid gets replaced! */
- inferior_pid = pid; /* Because remove_breakpoint will use this global. */
+ /* Set inferior_ptid; remove_breakpoint uses this global. */
+ inferior_ptid = pid_to_ptid (pid);
ALL_BREAKPOINTS (b)
{
if (b->inserted)
val = target_insert_breakpoint (b->address, b->shadow_contents);
if (val != 0)
{
- inferior_pid = saved_inferior_pid;
+ do_cleanups (old_chain);
return val;
}
}
}
- inferior_pid = saved_inferior_pid;
+ do_cleanups (old_chain);
return 0;
}
??rehrauer: Let's hope that merely clearing out this catchpoint's
target address field, if any, is sufficient to have it be reset
- automagically. Certainly on HP-UX that's true. */
+ automagically. Certainly on HP-UX that's true.
+
+ Jim Blandy <jimb@redhat.com>: Actually, zero is a perfectly
+ valid code address on some platforms (like the mn10200 and
+ mn10300 simulators). We shouldn't assign any special
+ interpretation to a breakpoint with a zero address. And in
+ fact, GDB doesn't --- I can't see what that comment above is
+ talking about. As far as I can tell, setting the address of a
+ bp_catch_exec/bp_catch_vfork/bp_catch_fork breakpoint to zero
+ is meaningless, since those are implemented with HP-UX kernel
+ hackery, not by storing breakpoint instructions somewhere. */
if ((b->type == bp_catch_exec) ||
(b->type == bp_catch_vfork) ||
(b->type == bp_catch_fork))
/* If this breakpoint has survived the above battery of checks, then
it must have a symbolic address. Be sure that it gets reevaluated
- to a target address, rather than reusing the old evaluation. */
+ to a target address, rather than reusing the old evaluation.
+
+ Jim Blandy <jimb@redhat.com>: As explained above in the comment
+ for bp_catch_exec and friends, I'm pretty sure this is entirely
+ unnecessary. A call to breakpoint_re_set_one always recomputes
+ the breakpoint's address from scratch, or deletes it if it can't.
+ So I think this assignment could be deleted without effect. */
b->address = (CORE_ADDR) NULL;
}
}
{
register struct breakpoint *b;
int val;
- int saved_inferior_pid = inferior_pid;
+ struct cleanup *old_chain = save_inferior_ptid ();
- if (pid == inferior_pid)
- error ("Cannot detach breakpoints of inferior_pid");
+ if (pid == PIDGET (inferior_ptid))
+ error ("Cannot detach breakpoints of inferior_ptid");
- /* FIXME: use a cleanup, to insure that inferior_pid gets replaced! */
- inferior_pid = pid; /* Because remove_breakpoint will use this global. */
+ /* Set inferior_ptid; remove_breakpoint uses this global. */
+ inferior_ptid = pid_to_ptid (pid);
ALL_BREAKPOINTS (b)
{
if (b->inserted)
val = remove_breakpoint (b, mark_inserted);
if (val != 0)
{
- inferior_pid = saved_inferior_pid;
+ do_cleanups (old_chain);
return val;
}
}
}
- inferior_pid = saved_inferior_pid;
+ do_cleanups (old_chain);
return 0;
}
switch (b->type)
{
case bp_catch_fork:
- val = target_remove_fork_catchpoint (inferior_pid);
+ val = target_remove_fork_catchpoint (PIDGET (inferior_ptid));
break;
case bp_catch_vfork:
- val = target_remove_vfork_catchpoint (inferior_pid);
+ val = target_remove_vfork_catchpoint (PIDGET (inferior_ptid));
break;
case bp_catch_exec:
- val = target_remove_exec_catchpoint (inferior_pid);
+ val = target_remove_exec_catchpoint (PIDGET (inferior_ptid));
break;
default:
warning ("Internal error, %s line %d.", __FILE__, __LINE__);
PC is valid for process/thread PID. */
int
-breakpoint_thread_match (CORE_ADDR pc, int pid)
+breakpoint_thread_match (CORE_ADDR pc, ptid_t ptid)
{
struct breakpoint *b;
int thread;
- thread = pid_to_thread_id (pid);
+ thread = pid_to_thread_id (ptid);
ALL_BREAKPOINTS (b)
if (b->enable != disabled
|| (ep->type == bp_catch_vfork)
|| (ep->type == bp_catch_exec)
|| (ep->type == bp_catch_catch)
- || (ep->type == bp_catch_throw)
-
+ || (ep->type == bp_catch_throw);
/* ??rehrauer: Add more kinds here, as are implemented... */
- ;
}
int
{
return
(ep->type == bp_catch_load)
- || (ep->type == bp_catch_unload)
- ;
+ || (ep->type == bp_catch_unload);
}
int
{
return
(ep->type == bp_catch_catch)
- || (ep->type == bp_catch_throw)
- ;
+ || (ep->type == bp_catch_throw);
}
/* Clear a bpstat so that it says we are not at any breakpoint.
q = p->next;
if (p->old_val != NULL)
value_free (p->old_val);
- free ((PTR) p);
+ xfree (p);
p = q;
}
*bsp = NULL;
struct breakpoint *
bpstat_find_step_resume_breakpoint (bpstat bsp)
{
+ int current_thread;
+
if (bsp == NULL)
error ("Internal error (bpstat_find_step_resume_breakpoint)");
+ current_thread = pid_to_thread_id (inferior_ptid);
+
for (; bsp != NULL; bsp = bsp->next)
{
if ((bsp->breakpoint_at != NULL) &&
- (bsp->breakpoint_at->type == bp_step_resume))
+ (bsp->breakpoint_at->type == bp_step_resume) &&
+ (bsp->breakpoint_at->thread == current_thread ||
+ bsp->breakpoint_at->thread == -1))
return bsp->breakpoint_at;
}
#ifdef UI_OUT
annotate_breakpoint (bs->breakpoint_at->number);
ui_out_text (uiout, "\nBreakpoint ");
- if (interpreter_p && strcmp (interpreter_p, "mi") == 0)
+ if (ui_out_is_mi_like_p (uiout))
ui_out_field_string (uiout, "reason", "breakpoint-hit");
ui_out_field_int (uiout, "bkptno", bs->breakpoint_at->number);
ui_out_text (uiout, ", ");
{
annotate_watchpoint (bs->breakpoint_at->number);
#ifdef UI_OUT
- if (interpreter_p && strcmp (interpreter_p, "mi") == 0)
+ if (ui_out_is_mi_like_p (uiout))
ui_out_field_string (uiout, "reason", "watchpoint-trigger");
mention (bs->breakpoint_at);
- ui_out_list_begin (uiout, "value");
+ ui_out_tuple_begin (uiout, "value");
ui_out_text (uiout, "\nOld value = ");
value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
ui_out_field_stream (uiout, "old", stb);
ui_out_text (uiout, "\nNew value = ");
value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
ui_out_field_stream (uiout, "new", stb);
- ui_out_list_end (uiout);
+ ui_out_tuple_end (uiout);
ui_out_text (uiout, "\n");
#else
mention (bs->breakpoint_at);
case bp_read_watchpoint:
#ifdef UI_OUT
- if (interpreter_p && strcmp (interpreter_p, "mi") == 0)
+ if (ui_out_is_mi_like_p (uiout))
ui_out_field_string (uiout, "reason", "read-watchpoint-trigger");
mention (bs->breakpoint_at);
- ui_out_list_begin (uiout, "value");
+ ui_out_tuple_begin (uiout, "value");
ui_out_text (uiout, "\nValue = ");
value_print (bs->breakpoint_at->val, stb->stream, 0, Val_pretty_default);
ui_out_field_stream (uiout, "value", stb);
- ui_out_list_end (uiout);
+ ui_out_tuple_end (uiout);
ui_out_text (uiout, "\n");
#else
mention (bs->breakpoint_at);
if (bs->old_val != NULL)
{
annotate_watchpoint (bs->breakpoint_at->number);
- if (interpreter_p && strcmp (interpreter_p, "mi") == 0)
+ if (ui_out_is_mi_like_p (uiout))
ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
mention (bs->breakpoint_at);
- ui_out_list_begin (uiout, "value");
+ ui_out_tuple_begin (uiout, "value");
ui_out_text (uiout, "\nOld value = ");
value_print (bs->old_val, stb->stream, 0, Val_pretty_default);
ui_out_field_stream (uiout, "old", stb);
else
{
mention (bs->breakpoint_at);
- if (interpreter_p && strcmp (interpreter_p, "mi") == 0)
- ui_out_list_begin (uiout, "value");
- ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
+ if (ui_out_is_mi_like_p (uiout))
+ ui_out_field_string (uiout, "reason", "access-watchpoint-trigger");
+ ui_out_tuple_begin (uiout, "value");
ui_out_text (uiout, "\nValue = ");
}
value_print (bs->breakpoint_at->val, stb->stream, 0,Val_pretty_default);
ui_out_field_stream (uiout, "new", stb);
- ui_out_list_end (uiout);
+ ui_out_tuple_end (uiout);
ui_out_text (uiout, "\n");
#else
if (bs->old_val != NULL)
case bp_finish:
#ifdef UI_OUT
- if (interpreter_p && strcmp (interpreter_p, "mi") == 0)
+ if (ui_out_is_mi_like_p (uiout))
ui_out_field_string (uiout, "reason", "function-finished");
#endif
return PRINT_UNKNOWN;
case bp_until:
#ifdef UI_OUT
- if (interpreter_p && strcmp (interpreter_p, "mi") == 0)
+ if (ui_out_is_mi_like_p (uiout))
ui_out_field_string (uiout, "reason", "location-reached");
#endif
return PRINT_UNKNOWN;
return print_it_typical (bs);
break;
default:
- internal_error ("print_bp_stop_message: unrecognized enum value");
+ internal_error (__FILE__, __LINE__,
+ "print_bp_stop_message: unrecognized enum value");
break;
}
}
will be deleted already. So we have no choice but print the
information here. */
#ifdef UI_OUT
- if (interpreter_p && strcmp (interpreter_p, "mi") == 0)
+ if (ui_out_is_mi_like_p (uiout))
ui_out_field_string (uiout, "reason", "watchpoint-scope");
ui_out_text (uiout, "\nWatchpoint ");
ui_out_field_int (uiout, "wpnum", bs->breakpoint_at->number);
"Error evaluating expression for watchpoint %d\n";
char message[sizeof (message1) + 30 /* slop */ ];
- /* Get the address where the breakpoint would have been. */
- bp_addr = *pc - (not_a_breakpoint && !SOFTWARE_SINGLE_STEP_P ?
+ /* Get the address where the breakpoint would have been.
+ The "not_a_breakpoint" argument is meant to distinguish
+ between a breakpoint trap event and a trace/singlestep
+ trap event. For a trace/singlestep trap event, we would
+ not want to subtract DECR_PC_AFTER_BREAK from the PC. */
+
+ bp_addr = *pc - (not_a_breakpoint && !SOFTWARE_SINGLE_STEP_P () ?
0 : DECR_PC_AFTER_BREAK);
ALL_BREAKPOINTS_SAFE (b, temp)
ignore it. */
if ((b->type == bp_catch_load)
#if defined(SOLIB_HAVE_LOAD_EVENT)
- && (!SOLIB_HAVE_LOAD_EVENT (inferior_pid)
+ && (!SOLIB_HAVE_LOAD_EVENT (PIDGET (inferior_ptid))
|| ((b->dll_pathname != NULL)
&& (strcmp (b->dll_pathname,
- SOLIB_LOADED_LIBRARY_PATHNAME (inferior_pid))
+ SOLIB_LOADED_LIBRARY_PATHNAME (
+ PIDGET (inferior_ptid)))
!= 0)))
#endif
)
if ((b->type == bp_catch_unload)
#if defined(SOLIB_HAVE_UNLOAD_EVENT)
- && (!SOLIB_HAVE_UNLOAD_EVENT (inferior_pid)
+ && (!SOLIB_HAVE_UNLOAD_EVENT (PIDGET (inferior_ptid))
|| ((b->dll_pathname != NULL)
&& (strcmp (b->dll_pathname,
- SOLIB_UNLOADED_LIBRARY_PATHNAME (inferior_pid))
+ SOLIB_UNLOADED_LIBRARY_PATHNAME (
+ PIDGET (inferior_ptid)))
!= 0)))
#endif
)
continue;
if ((b->type == bp_catch_fork)
- && !target_has_forked (inferior_pid, &b->forked_inferior_pid))
+ && !target_has_forked (PIDGET (inferior_ptid),
+ &b->forked_inferior_pid))
continue;
if ((b->type == bp_catch_vfork)
- && !target_has_vforked (inferior_pid, &b->forked_inferior_pid))
+ && !target_has_vforked (PIDGET (inferior_ptid),
+ &b->forked_inferior_pid))
continue;
if ((b->type == bp_catch_exec)
- && !target_has_execd (inferior_pid, &b->exec_pathname))
+ && !target_has_execd (PIDGET (inferior_ptid), &b->exec_pathname))
continue;
if (ep_is_exception_catchpoint (b) &&
struct breakpoint *b;
ALL_BREAKPOINTS (b)
if (b->enable == enabled && b->type == bp_watchpoint)
- return 1;
+ return 1;
return 0;
}
((b->type == bp_hardware_watchpoint) ||
(b->type == bp_read_watchpoint) ||
(b->type == bp_access_watchpoint)))
- return 1;
+ return 1;
return 0;
}
\f
catchpoint triggers. Clients who may wish to know the name
later must get it from the catchpoint itself.) */
if (ep->triggered_dll_pathname != NULL)
- free (ep->triggered_dll_pathname);
+ xfree (ep->triggered_dll_pathname);
if (ep->type == bp_catch_load)
- dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME (inferior_pid);
+ dll_pathname = SOLIB_LOADED_LIBRARY_PATHNAME (
+ PIDGET (inferior_ptid));
else
- dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME (inferior_pid);
+ dll_pathname = SOLIB_UNLOADED_LIBRARY_PATHNAME (
+ PIDGET (inferior_ptid));
#else
dll_pathname = NULL;
#endif
annotate_record ();
#ifdef UI_OUT
- ui_out_list_begin (uiout, "bkpt");
+ ui_out_tuple_begin (uiout, "bkpt");
#endif
/* 1 */
annotate_field (1);
if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))
|| ((int) b->type != bptypes[(int) b->type].type))
- internal_error ("bptypes table does not describe type #%d.",
+ internal_error (__FILE__, __LINE__,
+ "bptypes table does not describe type #%d.",
(int) b->type);
#ifdef UI_OUT
ui_out_field_string (uiout, "type", bptypes[(int) b->type].description);
/* 5 and 6 */
strcpy (wrap_indent, " ");
if (addressprint)
- strcat (wrap_indent, " ");
+ {
+ if (TARGET_ADDR_BIT <= 32)
+ strcat (wrap_indent, " ");
+ else
+ strcat (wrap_indent, " ");
+ }
switch (b->type)
{
case bp_none:
- internal_error ("print_one_breakpoint: bp_none encountered\n");
+ internal_error (__FILE__, __LINE__,
+ "print_one_breakpoint: bp_none encountered\n");
break;
case bp_watchpoint:
#else
if (addressprint)
{
+ char *tmp;
+
annotate_field (4);
- /* FIXME-32x64: need a print_address_numeric with
- field width */
- printf_filtered
- ("%s ",
- local_hex_string_custom
- ((unsigned long) b->address, "08l"));
+
+ if (TARGET_ADDR_BIT <= 32)
+ tmp = longest_local_hex_string_custom (b->address
+ & (CORE_ADDR) 0xffffffff,
+ "08l");
+ else
+ tmp = longest_local_hex_string_custom (b->address, "016l");
+
+ printf_filtered ("%s ", tmp);
}
annotate_field (5);
*last_addr = b->address;
#ifdef UI_OUT
/* Output the count also if it is zero, but only if this is
mi. FIXME: Should have a better test for this. */
- if (interpreter_p && strcmp (interpreter_p, "mi") == 0)
+ if (ui_out_is_mi_like_p (uiout))
if (show_breakpoint_hit_counts && b->hit_count == 0)
ui_out_field_int (uiout, "times", b->hit_count);
#endif
{
annotate_field (9);
#ifdef UI_OUT
- ui_out_list_begin (uiout, "script");
+ ui_out_tuple_begin (uiout, "script");
print_command_lines (uiout, l, 4);
- ui_out_list_end (uiout);
+ ui_out_tuple_end (uiout);
#else
while (l)
{
#endif
}
#ifdef UI_OUT
- ui_out_list_end (uiout);
+ ui_out_tuple_end (uiout);
do_cleanups (old_chain);
#endif
}
NULL, RETURN_MASK_ALL);
}
-/* Print information on breakpoint number BNUM, or -1 if all.
- If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
- is nonzero, process only watchpoints. */
+/* 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_catch_load
+ || b->type == bp_catch_unload
+ || b->type == bp_catch_fork
+ || b->type == bp_catch_vfork
+ || b->type == bp_catch_exec
+ || b->type == bp_catch_catch
+ || b->type == bp_catch_throw
+ || b->type == bp_hardware_breakpoint
+ || b->type == bp_watchpoint
+ || b->type == bp_read_watchpoint
+ || b->type == bp_access_watchpoint
+ || b->type == bp_hardware_watchpoint);
+}
+
+/* Print information on user settable breakpoint (watchpoint, etc)
+ number BNUM. If BNUM is -1 print all user settable breakpoints.
+ If ALLFLAG is non-zero, include non- user settable breakpoints. */
static void
breakpoint_1 (int bnum, int allflag)
{
register struct breakpoint *b;
CORE_ADDR last_addr = (CORE_ADDR) -1;
- int found_a_breakpoint = 0;
+ int nr_printable_breakpoints;
+ /* Compute the number of rows in the table. */
+ nr_printable_breakpoints = 0;
+ ALL_BREAKPOINTS (b)
+ if (bnum == -1
+ || bnum == b->number)
+ {
+ if (allflag || user_settable_breakpoint (b))
+ nr_printable_breakpoints++;
+ }
+
#ifdef UI_OUT
if (addressprint)
- ui_out_table_begin (uiout, 6, "BreakpointTable");
+ ui_out_table_begin (uiout, 6, nr_printable_breakpoints, "BreakpointTable");
else
- ui_out_table_begin (uiout, 5, "BreakpointTable");
+ ui_out_table_begin (uiout, 5, nr_printable_breakpoints, "BreakpointTable");
+#endif /* UI_OUT */
+
+#ifdef UI_OUT
+ if (nr_printable_breakpoints > 0)
+ annotate_breakpoints_headers ();
+ if (nr_printable_breakpoints > 0)
+ annotate_field (0);
+ ui_out_table_header (uiout, 3, ui_left, "number", "Num"); /* 1 */
+ if (nr_printable_breakpoints > 0)
+ annotate_field (1);
+ ui_out_table_header (uiout, 14, ui_left, "type", "Type"); /* 2 */
+ if (nr_printable_breakpoints > 0)
+ annotate_field (2);
+ ui_out_table_header (uiout, 4, ui_left, "disp", "Disp"); /* 3 */
+ if (nr_printable_breakpoints > 0)
+ annotate_field (3);
+ ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb"); /* 4 */
+ if (addressprint)
+ {
+ if (nr_printable_breakpoints > 0)
+ annotate_field (4);
+ if (TARGET_ADDR_BIT <= 32)
+ ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */
+ else
+ ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */
+ }
+ if (nr_printable_breakpoints > 0)
+ annotate_field (5);
+ ui_out_table_header (uiout, 40, ui_noalign, "what", "What"); /* 6 */
+ ui_out_table_body (uiout);
+ if (nr_printable_breakpoints > 0)
+ annotate_breakpoints_table ();
+#else
+ if (nr_printable_breakpoints > 0)
+ {
+ annotate_breakpoints_headers ();
+ annotate_field (0);
+ printf_filtered ("Num ");
+ annotate_field (1);
+ printf_filtered ("Type ");
+ annotate_field (2);
+ printf_filtered ("Disp ");
+ annotate_field (3);
+ printf_filtered ("Enb ");
+ if (addressprint)
+ {
+ annotate_field (4);
+ if (TARGET_ADDR_BIT <= 32)
+ printf_filtered ("Address ");
+ else
+ printf_filtered ("Address ");
+ }
+ annotate_field (5);
+ printf_filtered ("What\n");
+ annotate_breakpoints_table ();
+ }
#endif /* UI_OUT */
ALL_BREAKPOINTS (b)
{
/* We only print out user settable breakpoints unless the
allflag is set. */
- if (!allflag
- && b->type != bp_breakpoint
- && b->type != bp_catch_load
- && b->type != bp_catch_unload
- && b->type != bp_catch_fork
- && b->type != bp_catch_vfork
- && b->type != bp_catch_exec
- && b->type != bp_catch_catch
- && b->type != bp_catch_throw
- && b->type != bp_hardware_breakpoint
- && b->type != bp_watchpoint
- && b->type != bp_read_watchpoint
- && b->type != bp_access_watchpoint
- && b->type != bp_hardware_watchpoint)
- continue;
-
- if (!found_a_breakpoint++)
- {
- annotate_breakpoints_headers ();
-#ifdef UI_OUT
- annotate_field (0);
- ui_out_table_header (uiout, 3, ui_left, "Num"); /* 1 */
- annotate_field (1);
- ui_out_table_header (uiout, 14, ui_left, "Type"); /* 2 */
- annotate_field (2);
- ui_out_table_header (uiout, 4, ui_left, "Disp"); /* 3 */
- annotate_field (3);
- ui_out_table_header (uiout, 3, ui_left, "Enb"); /* 4 */
- if (addressprint)
- {
- annotate_field (4);
- ui_out_table_header (uiout, 10, ui_left, "Address"); /* 5 */
- }
- annotate_field (5);
- ui_out_table_header (uiout, 40, ui_noalign, "What"); /* 6 */
- ui_out_table_body (uiout);
-#else
- annotate_field (0);
- printf_filtered ("Num ");
- annotate_field (1);
- printf_filtered ("Type ");
- annotate_field (2);
- printf_filtered ("Disp ");
- annotate_field (3);
- printf_filtered ("Enb ");
- if (addressprint)
- {
- annotate_field (4);
- printf_filtered ("Address ");
- }
- annotate_field (5);
- printf_filtered ("What\n");
-#endif /* UI_OUT */
- annotate_breakpoints_table ();
- }
-
- print_one_breakpoint (b, &last_addr);
+ if (allflag || user_settable_breakpoint (b))
+ print_one_breakpoint (b, &last_addr);
}
- if (!found_a_breakpoint)
+
+#ifdef UI_OUT
+ ui_out_table_end (uiout);
+#endif /* UI_OUT */
+
+ if (nr_printable_breakpoints == 0)
{
#ifdef UI_OUT
if (bnum == -1)
set_next_address (last_addr);
}
-#ifdef UI_OUT
- ui_out_table_end (uiout);
-#endif /* UI_OUT */
/* FIXME? Should this be moved up so that it is only called when
there have been breakpoints? */
annotate_breakpoints_table_end ();
int bnum = -1;
if (bnum_exp)
- bnum = parse_and_eval_address (bnum_exp);
+ bnum = parse_and_eval_long (bnum_exp);
breakpoint_1 (bnum, 0);
}
int bnum = -1;
if (bnum_exp)
- bnum = parse_and_eval_address (bnum_exp);
+ bnum = parse_and_eval_long (bnum_exp);
breakpoint_1 (bnum, 1);
}
b->section == section)
{
others--;
- printf_filtered
- ("%d%s%s ",
- b->number,
- ((b->enable == disabled ||
- b->enable == shlib_disabled ||
- b->enable == call_disabled) ? " (disabled)"
- : b->enable == permanent ? " (permanent)"
- : ""),
- (others > 1) ? "," : ((others == 1) ? " and" : ""));
+ printf_filtered ("%d%s%s ",
+ b->number,
+ ((b->enable == disabled ||
+ b->enable == shlib_disabled ||
+ b->enable == call_disabled) ? " (disabled)"
+ : b->enable == permanent ? " (permanent)"
+ : ""),
+ (others > 1) ? ","
+ : ((others == 1) ? " and" : ""));
}
printf_filtered ("also set at pc ");
print_address_numeric (pc, 1, gdb_stdout);
default_breakpoint_line = line;
}
-/* Rescan breakpoints at address ADDRESS,
+/* Return true iff it is meaningful to use the address member of
+ BPT. For some breakpoint types, the address member is irrelevant
+ and it makes no sense to attempt to compare it to other addresses
+ (or use it for any other purpose either).
+
+ More specifically, each of the following breakpoint types will always
+ have a zero valued address and we don't want check_duplicates() to mark
+ breakpoints of any of these types to be a duplicate of an actual
+ breakpoint at address zero:
+
+ bp_watchpoint
+ bp_hardware_watchpoint
+ bp_read_watchpoint
+ bp_access_watchpoint
+ bp_catch_exec
+ bp_longjmp_resume
+ bp_catch_fork
+ bp_catch_vork */
+
+static int
+breakpoint_address_is_meaningful (struct breakpoint *bpt)
+{
+ enum bptype type = bpt->type;
+
+ return (type != bp_watchpoint
+ && type != bp_hardware_watchpoint
+ && type != bp_read_watchpoint
+ && type != bp_access_watchpoint
+ && type != bp_catch_exec
+ && type != bp_longjmp_resume
+ && type != bp_catch_fork
+ && type != bp_catch_vfork);
+}
+
+/* Rescan breakpoints at the same address and section as BPT,
marking the first one as "first" and any others as "duplicates".
This is so that the bpt instruction is only inserted once.
- If we have a permanent breakpoint at ADDRESS, make that one
- the official one, and the rest as duplicates. */
+ If we have a permanent breakpoint at the same place as BPT, make
+ that one the official one, and the rest as duplicates. */
static void
-check_duplicates (CORE_ADDR address, asection *section)
+check_duplicates (struct breakpoint *bpt)
{
register struct breakpoint *b;
register int count = 0;
struct breakpoint *perm_bp = 0;
+ CORE_ADDR address = bpt->address;
+ asection *section = bpt->section;
- if (address == 0) /* Watchpoints are uninteresting */
+ if (! breakpoint_address_is_meaningful (bpt))
return;
ALL_BREAKPOINTS (b)
&& b->enable != shlib_disabled
&& b->enable != call_disabled
&& b->address == address
- && (overlay_debugging == 0 || b->section == section))
+ && (overlay_debugging == 0 || b->section == section)
+ && breakpoint_address_is_meaningful (b))
{
/* Have we found a permanent breakpoint? */
if (b->enable == permanent)
/* Permanent breakpoint should always be inserted. */
if (! perm_bp->inserted)
- internal_error ("allegedly permanent breakpoint is not "
+ internal_error (__FILE__, __LINE__,
+ "allegedly permanent breakpoint is not "
"actually inserted");
ALL_BREAKPOINTS (b)
if (b != perm_bp)
{
if (b->inserted)
- internal_error ("another breakpoint was inserted on top of "
+ internal_error (__FILE__, __LINE__,
+ "another breakpoint was inserted on top of "
"a permanent breakpoint");
if (b->enable != disabled
&& b->enable != shlib_disabled
&& b->enable != call_disabled
&& b->address == address
- && (overlay_debugging == 0 || b->section == section))
+ && (overlay_debugging == 0 || b->section == section)
+ && breakpoint_address_is_meaningful (b))
b->duplicate = 1;
}
}
}
-/* Low level routine to set a breakpoint.
- Takes as args the three things that every breakpoint must have.
- Returns the breakpoint object so caller can set other things.
- Does not set the breakpoint number!
- Does not print anything.
+/* set_raw_breakpoint() is a low level routine for allocating and
+ partially initializing a breakpoint of type BPTYPE. The newly
+ created breakpoint's address, section, source file name, and line
+ number are provided by SAL. The newly created and partially
+ initialized breakpoint is added to the breakpoint chain and
+ is also returned as the value of this function.
- ==> This routine should not be called if there is a chance of later
- error(); otherwise it leaves a bogus breakpoint on the chain. Validate
- your arguments BEFORE calling this routine! */
+ It is expected that the caller will complete the initialization of
+ the newly created breakpoint struct as well as output any status
+ information regarding the creation of a new breakpoint. In
+ particular, set_raw_breakpoint() does NOT set the breakpoint
+ number! Care should be taken to not allow an error() to occur
+ prior to completing the initialization of the breakpoint. If this
+ should happen, a bogus breakpoint will be left on the chain. */
struct breakpoint *
-set_raw_breakpoint (struct symtab_and_line sal)
+set_raw_breakpoint (struct symtab_and_line sal, enum bptype bptype)
{
register struct breakpoint *b, *b1;
b->source_file = savestring (sal.symtab->filename,
strlen (sal.symtab->filename));
b->section = sal.section;
+ b->type = bptype;
b->language = current_language->la_language;
b->input_radix = input_radix;
b->thread = -1;
b1->next = b;
}
- check_duplicates (sal.pc, sal.section);
+ check_duplicates (b);
breakpoints_changed ();
return b;
return;
}
sal.section = find_pc_overlay (sal.pc);
- b = set_raw_breakpoint (sal);
- if (!b)
- return;
+ b = set_raw_breakpoint (sal,
+ func_name != NULL ? bp_longjmp : bp_longjmp_resume);
- b->type = func_name != NULL ? bp_longjmp : bp_longjmp_resume;
b->disposition = donttouch;
b->enable = disabled;
b->silent = 1;
if (func_name)
- b->addr_string = strsave (func_name);
+ b->addr_string = xstrdup (func_name);
b->number = internal_breakpoint_number--;
}
if (b->type == bp_longjmp)
{
b->enable = enabled;
- check_duplicates (b->address, b->section);
+ check_duplicates (b);
}
}
|| b->type == bp_longjmp_resume)
{
b->enable = disabled;
- check_duplicates (b->address, b->section);
+ check_duplicates (b);
}
}
INIT_SAL (&sal); /* initialize to zeroes */
sal.pc = address;
sal.section = find_pc_overlay (sal.pc);
- if ((b = set_raw_breakpoint (sal)) == NULL)
- return NULL;
+ b = set_raw_breakpoint (sal, bp_thread_event);
b->number = internal_breakpoint_number--;
b->disposition = donttouch;
- b->type = bp_thread_event; /* XXX: do we need a new type?
- bp_thread_event */
b->enable = enabled;
/* addr_string has to be used or breakpoint_re_set will delete me. */
sprintf (addr_string, "*0x%s", paddr (b->address));
- b->addr_string = strsave (addr_string);
+ b->addr_string = xstrdup (addr_string);
return b;
}
ALL_BREAKPOINTS_SAFE (b, temp)
if (b->type == bp_shlib_event)
- delete_breakpoint (b);
+ delete_breakpoint (b);
}
struct breakpoint *
INIT_SAL (&sal); /* initialize to zeroes */
sal.pc = address;
sal.section = find_pc_overlay (sal.pc);
- b = set_raw_breakpoint (sal);
+ b = set_raw_breakpoint (sal, bp_shlib_event);
b->number = internal_breakpoint_number--;
b->disposition = donttouch;
- b->type = bp_shlib_event;
return b;
}
/* Make sure that all storage allocated in decode_line_1 gets freed
in case the following errors out. */
- old_chain = make_cleanup (free, sals.sals);
+ old_chain = make_cleanup (xfree, sals.sals);
if (canonical != (char **) NULL)
{
- make_cleanup (free, canonical);
+ make_cleanup (xfree, canonical);
canonical_strings_chain = make_cleanup (null_cleanup, 0);
if (canonical[0] != NULL)
- make_cleanup (free, canonical[0]);
+ make_cleanup (xfree, canonical[0]);
}
resolve_sal_pc (&sals.sals[0]);
if (canonical != (char **) NULL)
discard_cleanups (canonical_strings_chain);
- b = set_raw_breakpoint (sals.sals[0]);
+ b = set_raw_breakpoint (sals.sals[0], bp_kind);
set_breakpoint_count (breakpoint_count + 1);
b->number = breakpoint_count;
b->cond = NULL;
b->dll_pathname = (char *) xmalloc (strlen (dll_pathname) + 1);
strcpy (b->dll_pathname, dll_pathname);
}
- b->type = bp_kind;
mention (b);
do_cleanups (old_chain);
sal.symtab = NULL;
sal.line = 0;
- b = set_raw_breakpoint (sal);
+ b = set_raw_breakpoint (sal, bp_kind);
set_breakpoint_count (breakpoint_count + 1);
b->number = breakpoint_count;
b->cond = NULL;
b->disposition = tempflag ? del : donttouch;
b->forked_inferior_pid = 0;
- b->type = bp_kind;
-
mention (b);
}
sal.symtab = NULL;
sal.line = 0;
- b = set_raw_breakpoint (sal);
+ b = set_raw_breakpoint (sal, bp_catch_exec);
set_breakpoint_count (breakpoint_count + 1);
b->number = breakpoint_count;
b->cond = NULL;
b->enable = enabled;
b->disposition = tempflag ? del : donttouch;
- b->type = bp_catch_exec;
-
mention (b);
}
b->frame = frame->frame;
else
b->frame = 0;
- check_duplicates (b->address, b->section);
+ check_duplicates (b);
return;
}
}
&& (b->enable == enabled))
{
b->enable = call_disabled;
- check_duplicates (b->address, b->section);
+ check_duplicates (b);
}
}
}
&& (b->enable == call_disabled))
{
b->enable = enabled;
- check_duplicates (b->address, b->section);
+ check_duplicates (b);
}
}
}
enum bptype type)
{
register struct breakpoint *b;
- b = set_raw_breakpoint (sal);
- b->type = type;
+ b = set_raw_breakpoint (sal, type);
b->enable = enabled;
b->disposition = donttouch;
b->frame = (frame ? frame->frame : 0);
/* If we're debugging a multi-threaded program, then we
want momentary breakpoints to be active in only a
single thread of control. */
- if (in_thread_list (inferior_pid))
- b->thread = pid_to_thread_id (inferior_pid);
+ if (in_thread_list (inferior_ptid))
+ b->thread = pid_to_thread_id (inferior_ptid);
return b;
}
#ifdef UI_OUT
case bp_watchpoint:
ui_out_text (uiout, "Watchpoint ");
- ui_out_list_begin (uiout, "wpt");
+ ui_out_tuple_begin (uiout, "wpt");
ui_out_field_int (uiout, "number", b->number);
ui_out_text (uiout, ": ");
print_expression (b->exp, stb->stream);
ui_out_field_stream (uiout, "exp", stb);
- ui_out_list_end (uiout);
+ ui_out_tuple_end (uiout);
break;
case bp_hardware_watchpoint:
ui_out_text (uiout, "Hardware watchpoint ");
- ui_out_list_begin (uiout, "wpt");
+ ui_out_tuple_begin (uiout, "wpt");
ui_out_field_int (uiout, "number", b->number);
ui_out_text (uiout, ": ");
print_expression (b->exp, stb->stream);
ui_out_field_stream (uiout, "exp", stb);
- ui_out_list_end (uiout);
+ ui_out_tuple_end (uiout);
break;
#else
case bp_watchpoint:
#ifdef UI_OUT
case bp_read_watchpoint:
ui_out_text (uiout, "Hardware read watchpoint ");
- ui_out_list_begin (uiout, "hw-rwpt");
+ ui_out_tuple_begin (uiout, "hw-rwpt");
ui_out_field_int (uiout, "number", b->number);
ui_out_text (uiout, ": ");
print_expression (b->exp, stb->stream);
ui_out_field_stream (uiout, "exp", stb);
- ui_out_list_end (uiout);
+ ui_out_tuple_end (uiout);
break;
case bp_access_watchpoint:
ui_out_text (uiout, "Hardware access (read/write) watchpoint ");
- ui_out_list_begin (uiout, "hw-awpt");
+ ui_out_tuple_begin (uiout, "hw-awpt");
ui_out_field_int (uiout, "number", b->number);
ui_out_text (uiout, ": ");
print_expression (b->exp, stb->stream);
ui_out_field_stream (uiout, "exp", stb);
- ui_out_list_end (uiout);
+ ui_out_tuple_end (uiout);
break;
#else
case bp_read_watchpoint:
#endif
case bp_breakpoint:
#ifdef UI_OUT
- if (interpreter_p && strcmp (interpreter_p, "mi") == 0)
+ if (ui_out_is_mi_like_p (uiout))
{
say_where = 0;
break;
break;
case bp_hardware_breakpoint:
#ifdef UI_OUT
- if (interpreter_p && strcmp (interpreter_p, "mi") == 0)
+ if (ui_out_is_mi_like_p (uiout))
{
say_where = 0;
break;
do_cleanups (old_chain);
#endif
#ifdef UI_OUT
- if (interpreter_p && strcmp (interpreter_p, "mi") == 0)
+ if (ui_out_is_mi_like_p (uiout))
return;
#endif
printf_filtered ("\n");
if (from_tty)
describe_other_breakpoints (sal.pc, sal.section);
- b = set_raw_breakpoint (sal);
+ b = set_raw_breakpoint (sal, type);
set_breakpoint_count (breakpoint_count + 1);
b->number = breakpoint_count;
- b->type = type;
b->cond = cond[i];
b->thread = thread;
b->addr_string = addr_string[i];
old_chain = make_cleanup (null_cleanup, 0);
/* Make sure that all storage allocated to SALS gets freed. */
- make_cleanup (free, sals.sals);
+ make_cleanup (xfree, sals.sals);
/* Cleanup the addr_string array but not its contents. */
- make_cleanup (free, addr_string);
+ make_cleanup (xfree, addr_string);
/* Allocate space for all the cond expressions. */
cond = xcalloc (sals.nelts, sizeof (struct expression *));
- make_cleanup (free, cond);
+ make_cleanup (xfree, cond);
/* Allocate space for all the cond strings. */
cond_string = xcalloc (sals.nelts, sizeof (char **));
- make_cleanup (free, cond_string);
+ make_cleanup (xfree, cond_string);
/* ----------------------------- SNIP -----------------------------
Anything added to the cleanup chain beyond this point is assumed
for (i = 0; i < sals.nelts; i++)
{
if (addr_string[i] != NULL)
- make_cleanup (free, addr_string[i]);
+ make_cleanup (xfree, addr_string[i]);
}
/* Resolve all line numbers to PC's and verify that the addresses
{
tok = cond_start = end_tok + 1;
cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
- make_cleanup (free, cond[i]);
+ make_cleanup (xfree, cond[i]);
cond_end = tok;
cond_string[i] = savestring (cond_start, cond_end - cond_start);
- make_cleanup (free, cond_string[i]);
+ make_cleanup (xfree, cond_string[i]);
}
else if (toklen >= 1 && strncmp (tok, "thread", toklen) == 0)
{
old_chain = make_cleanup (null_cleanup, 0);
/* Always have a addr_string array, even if it is empty. */
- make_cleanup (free, addr_string);
+ make_cleanup (xfree, addr_string);
/* Make sure that all storage allocated to SALS gets freed. */
- make_cleanup (free, sals.sals);
+ make_cleanup (xfree, sals.sals);
/* Allocate space for all the cond expressions. */
cond = xcalloc (sals.nelts, sizeof (struct expression *));
- make_cleanup (free, cond);
+ make_cleanup (xfree, cond);
/* Allocate space for all the cond strings. */
cond_string = xcalloc (sals.nelts, sizeof (char **));
- make_cleanup (free, cond_string);
+ make_cleanup (xfree, cond_string);
/* ----------------------------- SNIP -----------------------------
Anything added to the cleanup chain beyond this point is assumed
for (i = 0; i < sals.nelts; i++)
{
if (addr_string[i] != NULL)
- make_cleanup (free, addr_string[i]);
+ make_cleanup (xfree, addr_string[i]);
}
/* Wait until now before checking for garbage at the end of the
cond[i] = parse_exp_1 (&tok, block_for_pc (sals.sals[i].pc), 0);
if (*tok != '\0')
error ("Garbage %s follows condition", tok);
- make_cleanup (free, cond[i]);
+ make_cleanup (xfree, cond[i]);
cond_string[i] = xstrdup (args->condition);
}
}
{
struct frame_info *frame;
CORE_ADDR low, high, selected_pc = 0;
- char *extra_args, *level_arg, *addr_string;
+ char *extra_args = NULL;
+ char *level_arg;
+ char *addr_string;
int extra_args_len = 0, if_arg = 0;
if (!arg ||
else
sprintf (addr_string, "*0x%s", paddr_nz (high));
break_command_1 (addr_string, flag, from_tty);
- free (addr_string);
+ xfree (addr_string);
}
else
error ("No function contains the specified address");
struct symtabs_and_lines sals;
struct symtab_and_line sal;
struct cleanup *old_chain;
- char *extra_args;
+ char *extra_args = NULL;
int extra_args_len = 0;
int i, if_arg = 0;
sals = decode_line_1 (&addr_string, 1, (struct symtab *) NULL, 0,
(char ***) NULL);
- free (beg_addr_string);
- old_chain = make_cleanup (free, sals.sals);
+ xfree (beg_addr_string);
+ old_chain = make_cleanup (xfree, sals.sals);
for (i = 0; (i < sals.nelts); i++)
{
sal = sals.sals[i];
else
sprintf (break_string, "*0x%s", paddr_nz (high));
break_command_1 (break_string, flag, from_tty);
- free (break_string);
+ xfree (break_string);
}
else
error ("No function contains the specified address");
startup sequence by the dynamic linker.
However, I tried avoiding that by having HP-UX's implementation of
- TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_pid
+ TARGET_CAN_USE_HW_WATCHPOINT return FALSE if there was no inferior_ptid
yet, which forced slow watches before a "run" or "attach", and it
still fails somewhere in the startup code.
}
#endif /* HPUXHPPA */
+ /* Change the type of breakpoint to an ordinary watchpoint if a hardware
+ watchpoint could not be set. */
+ if (!mem_cnt || target_resources_ok <= 0)
+ bp_type = bp_watchpoint;
+
/* Now set up the breakpoint. */
- b = set_raw_breakpoint (sal);
+ b = set_raw_breakpoint (sal, bp_type);
set_breakpoint_count (breakpoint_count + 1);
b->number = breakpoint_count;
b->disposition = donttouch;
else
b->watchpoint_frame = (CORE_ADDR) 0;
- if (mem_cnt && target_resources_ok > 0)
- b->type = bp_type;
- else
- b->type = bp_watchpoint;
-
/* If the expression is "local", then set up a "watchpoint scope"
breakpoint at the point where we've left the scope of the watchpoint
expression. */
scope_sal.pc = get_frame_pc (prev_frame);
scope_sal.section = find_pc_overlay (scope_sal.pc);
- scope_breakpoint = set_raw_breakpoint (scope_sal);
+ scope_breakpoint = set_raw_breakpoint (scope_sal,
+ bp_watchpoint_scope);
set_breakpoint_count (breakpoint_count + 1);
scope_breakpoint->number = breakpoint_count;
- scope_breakpoint->type = bp_watchpoint_scope;
scope_breakpoint->enable = enabled;
/* Automatically delete the breakpoint when it hits. */
#if !defined(TARGET_REGION_OK_FOR_HW_WATCHPOINT)
#define TARGET_REGION_OK_FOR_HW_WATCHPOINT(ADDR,LEN) \
- TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN)
+ (TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(LEN))
#endif
static int
error ("Couldn't get information on specified line.");
sal = sals.sals[0];
- free ((PTR) sals.sals); /* malloc'd, so freed */
+ xfree (sals.sals); /* malloc'd, so freed */
if (*arg)
error ("Junk at end of arguments.");
/* Create a load breakpoint that only triggers when a load of
the specified dll (or any dll, if no pathname was specified)
occurs. */
- SOLIB_CREATE_CATCH_LOAD_HOOK (inferior_pid, tempflag,
+ SOLIB_CREATE_CATCH_LOAD_HOOK (PIDGET (inferior_ptid), tempflag,
dll_pathname, cond_string);
}
/* Create an unload breakpoint that only triggers when an unload of
the specified dll (or any dll, if no pathname was specified)
occurs. */
- SOLIB_CREATE_CATCH_UNLOAD_HOOK (inferior_pid, tempflag,
+ SOLIB_CREATE_CATCH_UNLOAD_HOOK (PIDGET (inferior_ptid), tempflag,
dll_pathname, cond_string);
}
#endif /* SOLIB_ADD */
{
struct breakpoint *b;
int thread = -1; /* All threads. */
+ enum bptype bptype;
if (!sal) /* no exception support? */
return;
- b = set_raw_breakpoint (*sal);
- set_breakpoint_count (breakpoint_count + 1);
- b->number = breakpoint_count;
- b->cond = NULL;
- b->cond_string = (cond_string == NULL) ?
- NULL : savestring (cond_string, strlen (cond_string));
- b->thread = thread;
- b->addr_string = NULL;
- b->enable = enabled;
- b->disposition = tempflag ? del : donttouch;
switch (ex_event)
{
case EX_EVENT_THROW:
- b->type = bp_catch_throw;
+ bptype = bp_catch_throw;
break;
case EX_EVENT_CATCH:
- b->type = bp_catch_catch;
+ bptype = bp_catch_catch;
break;
default: /* error condition */
- b->type = bp_none;
- b->enable = disabled;
error ("Internal error -- invalid catchpoint kind");
}
+
+ b = set_raw_breakpoint (*sal, bptype);
+ set_breakpoint_count (breakpoint_count + 1);
+ b->number = breakpoint_count;
+ b->cond = NULL;
+ b->cond_string = (cond_string == NULL) ?
+ NULL : savestring (cond_string, strlen (cond_string));
+ b->thread = thread;
+ b->addr_string = NULL;
+ b->enable = enabled;
+ b->disposition = tempflag ? del : donttouch;
mention (b);
}
if (from_tty)
describe_other_breakpoints (sal.pc, sal.section);
- b = set_raw_breakpoint (sal);
- set_breakpoint_count (breakpoint_count + 1);
- b->number = breakpoint_count;
-
/* Important -- this is an ordinary breakpoint. For platforms
with callback support for exceptions,
create_exception_catchpoint() will create special bp types
(bp_catch_catch and bp_catch_throw), and there is code in
insert_breakpoints() and elsewhere that depends on that. */
- b->type = bp_breakpoint;
+ b = set_raw_breakpoint (sal, bp_breakpoint);
+ set_breakpoint_count (breakpoint_count + 1);
+ b->number = breakpoint_count;
b->cond = cond;
b->enable = enabled;
warning ("Multiple breakpoints were set.");
warning ("Use the \"delete\" command to delete unwanted breakpoints.");
}
- free ((PTR) sals.sals);
+ xfree (sals.sals);
}
#if 0
sal.symtab = NULL;
sal.line = 0;
- b = set_raw_breakpoint (sal);
- if (!b)
- error ("Internal error -- couldn't set temp exception breakpoint");
+ b = set_raw_breakpoint (sal, bp_breakpoint);
- b->type = bp_breakpoint;
b->disposition = del;
b->enable = enabled;
b->silent = 1;
set_breakpoint_sal (struct symtab_and_line sal)
{
struct breakpoint *b;
- b = set_raw_breakpoint (sal);
+ b = set_raw_breakpoint (sal, bp_breakpoint);
set_breakpoint_count (breakpoint_count + 1);
b->number = breakpoint_count;
- b->type = bp_breakpoint;
b->cond = 0;
b->thread = -1;
return b;
if (from_tty)
putchar_unfiltered ('\n');
}
- free ((PTR) sals.sals);
+ xfree (sals.sals);
}
\f
/* Delete breakpoint in BS if they are `delete' breakpoints and
breakpoint_delete_event (bpt->number);
if (bpt->inserted)
- remove_breakpoint (bpt, mark_uninserted);
+ remove_breakpoint (bpt, mark_inserted);
if (breakpoint_chain == bpt)
breakpoint_chain = bpt->next;
}
}
- check_duplicates (bpt->address, bpt->section);
+ check_duplicates (bpt);
/* If this breakpoint was inserted, and there is another breakpoint
at the same address, we need to insert the other breakpoint. */
if (bpt->inserted
If there is a permanent breakpoint somewhere, it should
always be the only one inserted. */
if (b->enable == permanent)
- internal_error ("another breakpoint was inserted on top of "
+ internal_error (__FILE__, __LINE__,
+ "another breakpoint was inserted on top of "
"a permanent breakpoint");
if (b->type == bp_hardware_breakpoint)
free_command_lines (&bpt->commands);
if (bpt->cond)
- free (bpt->cond);
+ xfree (bpt->cond);
if (bpt->cond_string != NULL)
- free (bpt->cond_string);
+ xfree (bpt->cond_string);
if (bpt->addr_string != NULL)
- free (bpt->addr_string);
+ xfree (bpt->addr_string);
if (bpt->exp != NULL)
- free (bpt->exp);
+ xfree (bpt->exp);
if (bpt->exp_string != NULL)
- free (bpt->exp_string);
+ xfree (bpt->exp_string);
if (bpt->val != NULL)
value_free (bpt->val);
if (bpt->source_file != NULL)
- free (bpt->source_file);
+ xfree (bpt->source_file);
if (bpt->dll_pathname != NULL)
- free (bpt->dll_pathname);
+ xfree (bpt->dll_pathname);
if (bpt->triggered_dll_pathname != NULL)
- free (bpt->triggered_dll_pathname);
+ xfree (bpt->triggered_dll_pathname);
if (bpt->exec_pathname != NULL)
- free (bpt->exec_pathname);
+ xfree (bpt->exec_pathname);
/* Be sure no bpstat's are pointing at it after it's been freed. */
/* FIXME, how can we find all bpstat's?
bp, we mark it as deleted before freeing its storage. */
bpt->type = bp_none;
- free ((PTR) bpt);
+ xfree (bpt);
}
static void
{
s = b->cond_string;
if (b->cond)
- free ((PTR) b->cond);
+ xfree (b->cond);
b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
}
)
{
if (b->source_file != NULL)
- free (b->source_file);
+ xfree (b->source_file);
if (sals.sals[i].symtab == NULL)
b->source_file = NULL;
else
/* Now that this is re-enabled, check_duplicates
can be used. */
- check_duplicates (b->address, b->section);
+ check_duplicates (b);
}
- free ((PTR) sals.sals);
+ xfree (sals.sals);
break;
case bp_watchpoint:
/* So for now, just use a global context. */
if (b->exp)
- free ((PTR) b->exp);
+ xfree (b->exp);
b->exp = parse_expression (b->exp_string);
b->exp_valid_block = innermost_block;
mark = value_mark ();
{
s = b->cond_string;
if (b->cond)
- free ((PTR) b->cond);
+ xfree (b->cond);
b->cond = parse_exp_1 (&s, (struct block *) 0, 0);
}
if (b->enable == enabled)
/* Reset the thread number of this breakpoint:
- If the breakpoint is for all threads, leave it as-is.
- - Else, reset it to the current thread for inferior_pid. */
+ - Else, reset it to the current thread for inferior_ptid. */
void
breakpoint_re_set_thread (struct breakpoint *b)
{
if (b->thread != -1)
{
- if (in_thread_list (inferior_pid))
- b->thread = pid_to_thread_id (inferior_pid);
+ if (in_thread_list (inferior_ptid))
+ b->thread = pid_to_thread_id (inferior_ptid);
}
}
bpt->enable = disabled;
- check_duplicates (bpt->address, bpt->section);
+ check_duplicates (bpt);
if (modify_breakpoint_hook)
modify_breakpoint_hook (bpt);
if (bpt->enable != permanent)
bpt->enable = enabled;
bpt->disposition = disposition;
- check_duplicates (bpt->address, bpt->section);
+ check_duplicates (bpt);
breakpoints_changed ();
if (bpt->type == bp_watchpoint ||
Usage is `condition N COND', where N is an integer and COND is an\n\
expression to be evaluated whenever breakpoint N is reached. ");
- add_com ("tbreak", class_breakpoint, tbreak_command,
- "Set a temporary breakpoint. Args like \"break\" command.\n\
+ c = add_com ("tbreak", class_breakpoint, tbreak_command,
+ "Set a temporary breakpoint. Args like \"break\" command.\n\
Like \"break\" except the breakpoint is only temporary,\n\
so it will be deleted when hit. Equivalent to \"break\" followed\n\
by using \"enable delete\" on the breakpoint number.");
- add_com ("txbreak", class_breakpoint, tbreak_at_finish_command,
- "Set temporary breakpoint at procedure exit. Either there should\n\
+ c->completer = location_completer;
+
+ c = add_com ("txbreak", class_breakpoint, tbreak_at_finish_command,
+ "Set temporary breakpoint at procedure exit. Either there should\n\
be no argument or the argument must be a depth.\n");
+ c->completer = location_completer;
- add_com ("hbreak", class_breakpoint, hbreak_command,
- "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
+ c = add_com ("hbreak", class_breakpoint, hbreak_command,
+ "Set a hardware assisted breakpoint. Args like \"break\" command.\n\
Like \"break\" except the breakpoint requires hardware support,\n\
some target hardware may not have this support.");
+ c->completer = location_completer;
- add_com ("thbreak", class_breakpoint, thbreak_command,
- "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
+ c = add_com ("thbreak", class_breakpoint, thbreak_command,
+ "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
Like \"hbreak\" except the breakpoint is only temporary,\n\
so it will be deleted when hit.");
+ c->completer = location_completer;
add_prefix_cmd ("enable", class_breakpoint, enable_command,
"Enable some breakpoints.\n\
\n\
See also the \"delete\" command which clears breakpoints by number.", NULL));
- add_com ("break", class_breakpoint, break_command,
- concat ("Set breakpoint at specified line or function.\n\
+ c = add_com ("break", class_breakpoint, break_command,
+ concat ("Set breakpoint at specified line or function.\n\
Argument may be line number, function name, or \"*\" and an address.\n\
If line number is specified, break at start of code for that line.\n\
If function is specified, break at start of code for that function.\n\
Multiple breakpoints at one place are permitted, and useful if conditional.\n\
\n\
Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL));
+ c->completer = location_completer;
+
add_com_alias ("b", "break", class_run, 1);
add_com_alias ("br", "break", class_run, 1);
add_com_alias ("bre", "break", class_run, 1);
so it will be deleted when hit. Equivalent to \"catch\" followed\n\
by using \"enable delete\" on the catchpoint number.");
- add_com ("watch", class_breakpoint, watch_command,
- "Set a watchpoint for an expression.\n\
+ c = add_com ("watch", class_breakpoint, watch_command,
+ "Set a watchpoint for an expression.\n\
A watchpoint stops execution of your program whenever the value of\n\
an expression changes.");
+ c->completer = location_completer;
- add_com ("rwatch", class_breakpoint, rwatch_command,
- "Set a read watchpoint for an expression.\n\
+ c = add_com ("rwatch", class_breakpoint, rwatch_command,
+ "Set a read watchpoint for an expression.\n\
A watchpoint stops execution of your program whenever the value of\n\
an expression is read.");
+ c->completer = location_completer;
- add_com ("awatch", class_breakpoint, awatch_command,
- "Set a watchpoint for an expression.\n\
+ c = add_com ("awatch", class_breakpoint, awatch_command,
+ "Set a watchpoint for an expression.\n\
A watchpoint stops execution of your program whenever the value of\n\
an expression is either read or written.");
+ c->completer = location_completer;
add_info ("watchpoints", breakpoints_info,
"Synonym for ``info breakpoints''.");
projects / deliverable / binutils-gdb.git / blobdiff