/* 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 "symfile.h"
#include "objfiles.h"
#include "linespec.h"
+#include "completer.h"
+#include "gdb.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 *);
typedef struct
{
enum exception_event_kind kind;
- int enable;
+ int enable_p;
}
args_for_catchpoint_enable;
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;
to pass to lookup_internalvar(). */
char *varname;
char *start = ++p;
- value_ptr val;
+ struct value *val;
while (isalnum (*p) || *p == '_')
p++;
{
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;
}
ALL_BREAKPOINTS_SAFE (b, temp)
{
- if (b->enable == permanent)
+ if (b->enable_state == bp_permanent)
/* Permanent breakpoints cannot be inserted or removed. */
continue;
else if (b->type != bp_watchpoint
&& b->type != bp_catch_exec
&& b->type != bp_catch_throw
&& b->type != bp_catch_catch
- && b->enable != disabled
- && b->enable != shlib_disabled
- && b->enable != call_disabled
+ && b->enable_state != bp_disabled
+ && b->enable_state != bp_shlib_disabled
+ && b->enable_state != bp_call_disabled
&& !b->inserted
&& !b->duplicate)
{
{
/* See also: disable_breakpoints_in_shlibs. */
val = 0;
- b->enable = shlib_disabled;
+ b->enable_state = bp_shlib_disabled;
if (!disabled_breaks)
{
target_terminal_ours_for_output ();
return_val = val; /* remember failure */
}
else if (ep_is_exception_catchpoint (b)
- && b->enable != disabled
- && b->enable != shlib_disabled
- && b->enable != call_disabled
+ && b->enable_state != bp_disabled
+ && b->enable_state != bp_shlib_disabled
+ && b->enable_state != bp_call_disabled
&& !b->inserted
&& !b->duplicate)
target_terminal_ours_for_output ();
warning ("Cannot insert catchpoint %d; disabling it.",
b->number);
- b->enable = disabled;
+ b->enable_state = bp_disabled;
}
else
{
args_for_catchpoint_enable args;
args.kind = b->type == bp_catch_catch ?
EX_EVENT_CATCH : EX_EVENT_THROW;
- args.enable = 1;
+ args.enable_p = 1;
val = catch_errors (cover_target_enable_exception_callback,
&args,
message, RETURN_MASK_ALL);
target_terminal_ours_for_output ();
warning ("Cannot insert catchpoint %d; disabling it.",
b->number);
- b->enable = disabled;
+ b->enable_state = bp_disabled;
}
}
else if ((b->type == bp_hardware_watchpoint ||
b->type == bp_read_watchpoint ||
b->type == bp_access_watchpoint)
- && b->enable == enabled
- && b->disposition != del_at_next_stop
+ && b->enable_state == bp_enabled
+ && b->disposition != disp_del_at_next_stop
&& !b->inserted
&& !b->duplicate)
{
struct frame_info *saved_frame;
int saved_level, within_current_scope;
- value_ptr mark = value_mark ();
- value_ptr v;
+ struct value *mark = value_mark ();
+ struct value *v;
/* Save the current frame and level so we can restore it after
evaluating the watchpoint expression on its own frame. */
printf_filtered ("because the program has left the block \n");
printf_filtered ("in which its expression is valid.\n");
if (b->related_breakpoint)
- b->related_breakpoint->disposition = del_at_next_stop;
- b->disposition = del_at_next_stop;
+ b->related_breakpoint->disposition = disp_del_at_next_stop;
+ b->disposition = disp_del_at_next_stop;
}
/* Restore the frame and level. */
else if ((b->type == bp_catch_fork
|| b->type == bp_catch_vfork
|| b->type == bp_catch_exec)
- && b->enable == enabled
+ && b->enable_state == bp_enabled
&& !b->inserted
&& !b->duplicate)
{
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.
+
+ 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.
+
+ 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;
}
{
int val;
- if (b->enable == permanent)
+ if (b->enable_state == bp_permanent)
/* Permanent breakpoints cannot be inserted or removed. */
return 0;
else if ((b->type == bp_hardware_watchpoint ||
b->type == bp_read_watchpoint ||
b->type == bp_access_watchpoint)
- && b->enable == enabled
+ && b->enable_state == bp_enabled
&& !b->duplicate)
{
- value_ptr v, n;
+ struct value *v;
+ struct value *n;
b->inserted = (is == mark_inserted);
/* Walk down the saved value chain. */
else if ((b->type == bp_catch_fork ||
b->type == bp_catch_vfork ||
b->type == bp_catch_exec)
- && b->enable == enabled
+ && b->enable_state == bp_enabled
&& !b->duplicate)
{
val = -1;
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__);
}
else if ((b->type == bp_catch_catch ||
b->type == bp_catch_throw)
- && b->enable == enabled
+ && b->enable_state == bp_enabled
&& !b->duplicate)
{
}
else if (ep_is_exception_catchpoint (b)
&& b->inserted /* sometimes previous insert doesn't happen */
- && b->enable == enabled
+ && b->enable_state == bp_enabled
&& !b->duplicate)
{
int any_breakpoint_here = 0;
ALL_BREAKPOINTS (b)
- if ((b->enable == enabled
- || b->enable == permanent)
+ if ((b->enable_state == bp_enabled
+ || b->enable_state == bp_permanent)
&& b->address == pc) /* bp is enabled and matches pc */
{
if (overlay_debugging &&
section_is_overlay (b->section) &&
!section_is_mapped (b->section))
continue; /* unmapped overlay -- can't be a match */
- else if (b->enable == permanent)
+ else if (b->enable_state == bp_permanent)
return permanent_breakpoint_here;
else
any_breakpoint_here = 1;
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
- && b->enable != shlib_disabled
- && b->enable != call_disabled
+ if (b->enable_state != bp_disabled
+ && b->enable_state != bp_shlib_disabled
+ && b->enable_state != bp_call_disabled
&& b->address == pc
&& (b->thread == -1 || b->thread == thread))
{
|| (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;
}
}
static int
breakpoint_cond_eval (PTR exp)
{
- value_ptr mark = value_mark ();
+ struct value *mark = value_mark ();
int i = !value_true (evaluate_expression ((struct expression *) exp));
value_free_to_mark (mark);
return i;
reinit_frame_cache ();
fr = find_frame_addr_in_frame_chain (b->watchpoint_frame);
within_current_scope = (fr != NULL);
+ /* in_function_epilogue_p() returns a non-zero value if we're still
+ in the function but the stack frame has already been invalidated.
+ Since we can't rely on the values of local variables after the
+ stack has been destroyed, we are treating the watchpoint in that
+ state as `not changed' without further checking. */
+ if (within_current_scope && fr == get_current_frame ()
+ && gdbarch_in_function_epilogue_p (current_gdbarch, read_pc ()))
+ return WP_VALUE_NOT_CHANGED;
if (within_current_scope)
/* If we end up stopping, the current frame will get selected
in normal_stop. So this call to select_frame won't affect
call free_all_values. We can't call free_all_values because
we might be in the middle of evaluating a function call. */
- value_ptr mark = value_mark ();
- value_ptr new_val = evaluate_expression (bs->breakpoint_at->exp);
+ struct value *mark = value_mark ();
+ struct value *new_val = evaluate_expression (bs->breakpoint_at->exp);
if (!value_equal (b->val, new_val))
{
release_value (new_val);
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);
#endif
if (b->related_breakpoint)
- b->related_breakpoint->disposition = del_at_next_stop;
- b->disposition = del_at_next_stop;
+ b->related_breakpoint->disposition = disp_del_at_next_stop;
+ b->disposition = disp_del_at_next_stop;
return WP_DELETED;
}
"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)
{
- if (b->enable == disabled
- || b->enable == shlib_disabled
- || b->enable == call_disabled)
+ if (b->enable_state == bp_disabled
+ || b->enable_state == bp_shlib_disabled
+ || b->enable_state == bp_call_disabled)
continue;
if (b->type != bp_watchpoint
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) &&
/* Error from catch_errors. */
printf_filtered ("Watchpoint %d deleted.\n", b->number);
if (b->related_breakpoint)
- b->related_breakpoint->disposition = del_at_next_stop;
- b->disposition = del_at_next_stop;
+ b->related_breakpoint->disposition = disp_del_at_next_stop;
+ b->disposition = disp_del_at_next_stop;
/* We've already printed what needs to be printed. */
bs->print_it = print_it_done;
b->type == bp_access_watchpoint)
{
CORE_ADDR addr;
- value_ptr v;
+ struct value *v;
int found = 0;
addr = target_stopped_data_address ();
/* Error from catch_errors. */
printf_filtered ("Watchpoint %d deleted.\n", b->number);
if (b->related_breakpoint)
- b->related_breakpoint->disposition = del_at_next_stop;
- b->disposition = del_at_next_stop;
+ b->related_breakpoint->disposition = disp_del_at_next_stop;
+ b->disposition = disp_del_at_next_stop;
/* We've already printed what needs to be printed. */
bs->print_it = print_it_done;
break;
else
{
/* We will stop here */
- if (b->disposition == disable)
- b->enable = disabled;
+ if (b->disposition == disp_disable)
+ b->enable_state = bp_disabled;
bs->commands = b->commands;
if (b->silent)
bs->print = 0;
{
struct breakpoint *b;
ALL_BREAKPOINTS (b)
- if (b->enable == enabled && b->type == bp_watchpoint)
- return 1;
+ if (b->enable_state == bp_enabled && b->type == bp_watchpoint)
+ return 1;
return 0;
}
{
struct breakpoint *b;
ALL_BREAKPOINTS (b)
- if ((b->enable == enabled) &&
+ if ((b->enable_state == bp_enabled) &&
(b->inserted) &&
((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);
/* 4 */
annotate_field (3);
#ifdef UI_OUT
- ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int) b->enable]);
+ ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int) b->enable_state]);
ui_out_spaces (uiout, 2);
#else
- printf_filtered ("%-3c ", bpenables[(int) b->enable]);
+ printf_filtered ("%-3c ", bpenables[(int) b->enable_state]);
#endif
/* 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
}
};
static int
-do_captured_breakpoint_query (void *data)
+do_captured_breakpoint_query (struct ui_out *uiout, void *data)
{
struct captured_breakpoint_query_args *args = data;
register struct breakpoint *b;
}
enum gdb_rc
-gdb_breakpoint_query (/* output object, */ int bnum)
+gdb_breakpoint_query (struct ui_out *uiout, int bnum)
{
struct captured_breakpoint_query_args args;
args.bnum = bnum;
/* For the moment we don't trust print_one_breakpoint() to not throw
an error. */
- return catch_errors (do_captured_breakpoint_query, &args,
- NULL, RETURN_MASK_ALL);
+ return catch_exceptions (uiout, do_captured_breakpoint_query, &args,
+ 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 ();
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_state == bp_disabled ||
+ b->enable_state == bp_shlib_disabled ||
+ b->enable_state == bp_call_disabled) ? " (disabled)"
+ : b->enable_state == bp_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)
- if (b->enable != disabled
- && b->enable != shlib_disabled
- && b->enable != call_disabled
+ if (b->enable_state != bp_disabled
+ && b->enable_state != bp_shlib_disabled
+ && b->enable_state != bp_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)
+ if (b->enable_state == bp_permanent)
{
perm_bp = b;
break;
/* 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
+ if (b->enable_state != bp_disabled
+ && b->enable_state != bp_shlib_disabled
+ && b->enable_state != bp_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;
b->line_number = sal.line;
- b->enable = enabled;
+ b->enable_state = bp_enabled;
b->next = 0;
b->silent = 0;
b->ignore_count = 0;
b1->next = b;
}
- check_duplicates (sal.pc, sal.section);
+ check_duplicates (b);
breakpoints_changed ();
return b;
void
make_breakpoint_permanent (struct breakpoint *b)
{
- b->enable = permanent;
+ b->enable_state = bp_permanent;
/* By definition, permanent breakpoints are already present in the code. */
b->inserted = 1;
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->disposition = disp_donttouch;
+ b->enable_state = bp_disabled;
b->silent = 1;
if (func_name)
- b->addr_string = strsave (func_name);
+ b->addr_string = xstrdup (func_name);
b->number = internal_breakpoint_number--;
}
ALL_BREAKPOINTS (b)
if (b->type == bp_longjmp)
{
- b->enable = enabled;
- check_duplicates (b->address, b->section);
+ b->enable_state = bp_enabled;
+ check_duplicates (b);
}
}
if (b->type == bp_longjmp
|| b->type == bp_longjmp_resume)
{
- b->enable = disabled;
- check_duplicates (b->address, b->section);
+ b->enable_state = bp_disabled;
+ 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;
+ b->disposition = disp_donttouch;
+ b->enable_state = bp_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;
+ b->disposition = disp_donttouch;
return b;
}
#if defined (PC_SOLIB)
if (((b->type == bp_breakpoint) ||
(b->type == bp_hardware_breakpoint)) &&
- b->enable == enabled &&
+ b->enable_state == bp_enabled &&
!b->duplicate &&
PC_SOLIB (b->address))
{
- b->enable = shlib_disabled;
+ b->enable_state = bp_shlib_disabled;
if (!silent)
{
if (!disabled_shlib_breaks)
struct breakpoint *b;
ALL_BREAKPOINTS (b)
- if (b->enable == shlib_disabled)
+ if (b->enable_state == bp_shlib_disabled)
{
char buf[1];
/* Do not reenable the breakpoint if the shared library
is still not mapped in. */
if (target_read_memory (b->address, buf, 1) == 0)
- b->enable = enabled;
+ b->enable_state = bp_enabled;
}
}
/* 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;
else if (addr_start)
b->addr_string = savestring (addr_start, addr_end - addr_start);
- b->enable = enabled;
- b->disposition = tempflag ? del : donttouch;
+ b->enable_state = bp_enabled;
+ b->disposition = tempflag ? disp_del : disp_donttouch;
if (dll_pathname == NULL)
b->dll_pathname = 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;
NULL : savestring (cond_string, strlen (cond_string));
b->thread = thread;
b->addr_string = NULL;
- b->enable = enabled;
- b->disposition = tempflag ? del : donttouch;
+ b->enable_state = bp_enabled;
+ b->disposition = tempflag ? disp_del : disp_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;
NULL : savestring (cond_string, strlen (cond_string));
b->thread = thread;
b->addr_string = NULL;
- b->enable = enabled;
- b->disposition = tempflag ? del : donttouch;
-
- b->type = bp_catch_exec;
+ b->enable_state = bp_enabled;
+ b->disposition = tempflag ? disp_del : disp_donttouch;
mention (b);
}
ALL_BREAKPOINTS (b)
{
- if (b->type == bp_hardware_breakpoint && b->enable == enabled)
+ if (b->type == bp_hardware_breakpoint && b->enable_state == bp_enabled)
i++;
}
*other_type_used = 0;
ALL_BREAKPOINTS (b)
{
- if (b->enable == enabled)
+ if (b->enable_state == bp_enabled)
{
if (b->type == type)
i++;
else if ((b->type == bp_hardware_watchpoint ||
b->type == bp_read_watchpoint ||
b->type == bp_access_watchpoint)
- && b->enable == enabled)
+ && b->enable_state == bp_enabled)
*other_type_used = 1;
}
}
if (b->type == bp_longjmp_resume)
{
b->address = pc;
- b->enable = enabled;
+ b->enable_state = bp_enabled;
if (frame != NULL)
b->frame = frame->frame;
else
b->frame = 0;
- check_duplicates (b->address, b->section);
+ check_duplicates (b);
return;
}
}
|| (b->type == bp_read_watchpoint)
|| (b->type == bp_access_watchpoint)
|| ep_is_exception_catchpoint (b))
- && (b->enable == enabled))
+ && (b->enable_state == bp_enabled))
{
- b->enable = call_disabled;
- check_duplicates (b->address, b->section);
+ b->enable_state = bp_call_disabled;
+ check_duplicates (b);
}
}
}
|| (b->type == bp_read_watchpoint)
|| (b->type == bp_access_watchpoint)
|| ep_is_exception_catchpoint (b))
- && (b->enable == call_disabled))
+ && (b->enable_state == bp_call_disabled))
{
- b->enable = enabled;
- check_duplicates (b->address, b->section);
+ b->enable_state = bp_enabled;
+ check_duplicates (b);
}
}
}
enum bptype type)
{
register struct breakpoint *b;
- b = set_raw_breakpoint (sal);
- b->type = type;
- b->enable = enabled;
- b->disposition = donttouch;
+ b = set_raw_breakpoint (sal, type);
+ b->enable_state = bp_enabled;
+ b->disposition = disp_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;
if (b->source_file)
printf_filtered (": file %s, line %d.",
b->source_file, b->line_number);
- TUIDO (((TuiOpaqueFuncPtr) tui_vAllSetHasBreakAt, b, 1));
- TUIDO (((TuiOpaqueFuncPtr) tuiUpdateAllExecInfos));
}
#ifdef UI_OUT
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];
b->cond_string = cond_string[i];
b->ignore_count = ignore_count;
- b->enable = enabled;
+ b->enable_state = bp_enabled;
b->disposition = disposition;
mention (b);
}
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)
{
create_breakpoints (sals, addr_string, cond, cond_string,
hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
- tempflag ? del : donttouch,
+ tempflag ? disp_del : disp_donttouch,
thread, ignore_count, from_tty);
if (sals.nelts > 1)
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);
}
}
create_breakpoints (sals, addr_string, cond, cond_string,
args->hardwareflag ? bp_hardware_breakpoint : bp_breakpoint,
- args->tempflag ? del : donttouch,
+ args->tempflag ? disp_del : disp_donttouch,
args->thread, args->ignore_count, 0/*from-tty*/);
/* That's it. Discard the cleanups for data inserted into the
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");
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;
+ b->disposition = disp_donttouch;
b->exp = exp;
b->exp_valid_block = exp_valid_block;
b->exp_string = savestring (exp_start, exp_end - exp_start);
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;
+ scope_breakpoint->enable_state = bp_enabled;
/* Automatically delete the breakpoint when it hits. */
- scope_breakpoint->disposition = del;
+ scope_breakpoint->disposition = disp_del;
/* Only break in the proper frame (help with recursion). */
scope_breakpoint->frame = prev_frame->frame;
#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.");
if (blocks_searched[index] == 0)
{
struct block *b = BLOCKVECTOR_BLOCK (bl, index);
- int nsyms;
register int i;
register struct symbol *sym;
- nsyms = BLOCK_NSYMS (b);
-
- for (i = 0; i < nsyms; i++)
+ ALL_BLOCK_SYMBOLS (b, i, sym)
{
- sym = BLOCK_SYM (b, i);
if (STREQ (SYMBOL_NAME (sym), "default"))
{
if (have_default)
/* 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_state = bp_enabled;
+ b->disposition = tempflag ? disp_del : disp_donttouch;
mention (b);
}
{
args_for_catchpoint_enable *args = arg;
struct symtab_and_line *sal;
- sal = target_enable_exception_callback (args->kind, args->enable);
+ sal = target_enable_exception_callback (args->kind, args->enable_p);
if (sal == NULL)
return 0;
else if (sal == (struct symtab_and_line *) -1)
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;
- b->disposition = tempflag ? del : donttouch;
+ b->enable_state = bp_enabled;
+ b->disposition = tempflag ? disp_del : disp_donttouch;
mention (b);
}
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->disposition = disp_del;
+ b->enable_state = bp_enabled;
b->silent = 1;
b->number = internal_breakpoint_number--;
return b;
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
struct breakpoint *b, *temp;
for (; bs; bs = bs->next)
- if (bs->breakpoint_at && bs->breakpoint_at->disposition == del
+ if (bs->breakpoint_at && bs->breakpoint_at->disposition == disp_del
&& bs->stop)
delete_breakpoint (bs->breakpoint_at);
ALL_BREAKPOINTS_SAFE (b, temp)
{
- if (b->disposition == del_at_next_stop)
+ if (b->disposition == disp_del_at_next_stop)
delete_breakpoint (b);
}
}
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;
sprintf (message, message1, bpt->number);
args.kind = bpt->type == bp_catch_catch ?
EX_EVENT_CATCH : EX_EVENT_THROW;
- args.enable = 0;
+ args.enable_p = 0;
catch_errors (cover_target_enable_exception_callback, &args,
message, RETURN_MASK_ALL);
}
break;
}
- /* Before turning off the visuals for the bp, check to see that
- there are no other bps at the same address. */
- if (tui_version)
- {
- int clearIt;
-
- ALL_BREAKPOINTS (b)
- {
- clearIt = (b->address != bpt->address);
- if (!clearIt)
- break;
- }
-
- if (clearIt)
- {
- TUIDO (((TuiOpaqueFuncPtr) tui_vAllSetHasBreakAt, bpt, 0));
- TUIDO (((TuiOpaqueFuncPtr) tuiUpdateAllExecInfos));
- }
- }
-
- 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 (b->address == bpt->address
&& b->section == bpt->section
&& !b->duplicate
- && b->enable != disabled
- && b->enable != shlib_disabled
- && b->enable != call_disabled)
+ && b->enable_state != bp_disabled
+ && b->enable_state != bp_shlib_disabled
+ && b->enable_state != bp_call_disabled)
{
int val;
breakpoint at the same address as the one being deleted.
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 "
+ if (b->enable_state == bp_permanent)
+ 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
int i;
struct symtabs_and_lines sals;
char *s;
- enum enable save_enable;
+ enum enable_state save_enable;
switch (b->type)
{
delete_breakpoint (b);
return 0;
}
- /* In case we have a problem, disable this breakpoint. We'll restore
- its status if we succeed. */
- save_enable = b->enable;
- b->enable = disabled;
+ /* HACK: cagney/2001-11-11: kettenis/2001-11-11: MarkK wrote:
+
+ ``And a hack it is, although Apple's Darwin version of GDB
+ contains an almost identical hack to implement a "future
+ break" command. It seems to work in many real world cases,
+ but it is easy to come up with a test case where the patch
+ doesn't help at all.''
+
+ ``It seems that the way GDB implements breakpoints - in -
+ shared - libraries was designed for a.out shared library
+ systems (SunOS 4) where shared libraries were loaded at a
+ fixed address in memory. Since ELF shared libraries can (and
+ will) be loaded at any address in memory, things break.
+ Fixing this is not trivial. Therefore, I'm not sure whether
+ we should add this hack to the branch only. I cannot
+ guarantee that things will be fixed on the trunk in the near
+ future.''
+
+ In case we have a problem, disable this breakpoint. We'll
+ restore its status if we succeed. Don't disable a
+ shlib_disabled breakpoint though. There's a fair chance we
+ can't re-set it if the shared library it's in hasn't been
+ loaded yet. */
+ save_enable = b->enable_state;
+ if (b->enable_state != bp_shlib_disabled)
+ b->enable_state = bp_disabled;
set_language (b->language);
input_radix = b->input_radix;
{
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
breakpoints_changed ();
}
b->section = sals.sals[i].section;
- b->enable = save_enable; /* Restore it, this worked. */
+ b->enable_state = save_enable; /* Restore it, this worked. */
/* 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)
+ if (b->enable_state == bp_enabled)
mention (b);
value_free_to_mark (mark);
break;
/* 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);
}
}
return;
/* You can't disable permanent breakpoints. */
- if (bpt->enable == permanent)
+ if (bpt->enable_state == bp_permanent)
return;
- bpt->enable = disabled;
+ bpt->enable_state = bp_disabled;
- check_duplicates (bpt->address, bpt->section);
+ check_duplicates (bpt);
if (modify_breakpoint_hook)
modify_breakpoint_hook (bpt);
error ("Hardware breakpoints used exceeds limit.");
}
- if (bpt->enable != permanent)
- bpt->enable = enabled;
+ if (bpt->enable_state != bp_permanent)
+ bpt->enable_state = bp_enabled;
bpt->disposition = disposition;
- check_duplicates (bpt->address, bpt->section);
+ check_duplicates (bpt);
breakpoints_changed ();
if (bpt->type == bp_watchpoint ||
printf_filtered ("\
Cannot enable watchpoint %d because the block in which its expression\n\
is valid is not currently in scope.\n", bpt->number);
- bpt->enable = disabled;
+ bpt->enable_state = bp_disabled;
return;
}
printf_filtered ("\
Cannot enable watchpoint %d because target watch resources\n\
have been allocated for other watchpoints.\n", bpt->number);
- bpt->enable = disabled;
+ bpt->enable_state = bp_disabled;
value_free_to_mark (mark);
return;
}
static void
enable_once_breakpoint (struct breakpoint *bpt)
{
- do_enable_breakpoint (bpt, disable);
+ do_enable_breakpoint (bpt, disp_disable);
}
/* ARGSUSED */
static void
enable_delete_breakpoint (struct breakpoint *bpt)
{
- do_enable_breakpoint (bpt, del);
+ do_enable_breakpoint (bpt, disp_del);
}
/* ARGSUSED */
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 / binutils.git / blobdiff